tessl/pypi-python-casacore
Python bindings for the CASACORE radio astronomy library providing comprehensive interfaces for table operations, image processing, coordinate systems, and astronomical measurements.
—
Pending
coordinate-systems.mddocs/
Coordinate Systems and Measures
Astronomical reference frames, coordinate conversions, and measurement systems. Handles directions, positions, epochs, frequencies, Doppler shifts, and baseline/UVW coordinates with full support for reference frame transformations and precise astronomical calculations.
Core Imports
from casacore.measures import measures, is_measureCapabilities
Measures Server
Central server for managing astronomical reference frames and performing coordinate transformations.
class measures:
def __init__(self):
"""Create measures server instance."""
def measure(self, v, rf, off=None):
"""
Convert measure to specified reference frame.
Parameters:
- v: dict, measure to convert
- rf: str, target reference frame
- off: dict, optional offset measure
Returns:
dict, converted measure
"""
def doframe(self, v):
"""
Set measure as part of reference frame.
Parameters:
- v: dict, measure to add to frame
Returns:
bool, True if successfully added to frame
"""
def list_codes(self, m):
"""
Get valid reference codes for measure type.
Parameters:
- m: dict, measure to get codes for
Returns:
dict with 'normal' and 'extra' code lists
"""
def is_measure(v):
"""
Check if object is a valid measure.
Parameters:
- v: object to check
Returns:
bool, True if valid measure
"""Direction Measures
Handle celestial directions with support for various coordinate systems and epochs.
class measures:
def direction(self, rf='', v0='0..', v1='90..', off=None):
"""
Create direction measure.
Parameters:
- rf: str, reference frame ('J2000', 'B1950', 'GALACTIC', 'AZEL', etc.)
- v0: str or quantity, longitude/RA (angle)
- v1: str or quantity, latitude/Dec (angle)
- off: dict, optional offset direction
Returns:
dict, direction measure with 'type': 'direction'
Reference frames:
- J2000, JMEAN, JTRUE: Julian epoch systems
- B1950, BMEAN, BTRUE: Besselian epoch systems
- APP: Apparent (topocentric)
- GALACTIC: Galactic coordinates
- SUPERGAL: Supergalactic coordinates
- ECLIPTIC, MECLIPTIC, TECLIPTIC: Ecliptic systems
- HADEC: Hour angle/declination
- AZEL: Azimuth/elevation (requires position frame)
- Planets: MERCURY, VENUS, MARS, JUPITER, SATURN, URANUS, NEPTUNE, PLUTO, MOON, SUN
"""Position Measures
Handle terrestrial and celestial positions with various geodetic systems.
class measures:
def position(self, rf='', v0='0..', v1='90..', v2='0m', off=None):
"""
Create position measure.
Parameters:
- rf: str, reference frame ('WGS84', 'ITRF')
- v0: str or quantity, longitude or X (angle or length)
- v1: str or quantity, latitude or Y (angle or length)
- v2: str or quantity, height or Z (length)
- off: dict, optional offset position
Returns:
dict, position measure with 'type': 'position'
Reference frames:
- WGS84: World Geodetic System 1984
- ITRF: International Terrestrial Reference Frame
"""
def observatory(self, name):
"""
Get position measure for known observatory.
Parameters:
- name: str, observatory name (case insensitive)
Returns:
dict, position measure for observatory
Known observatories include:
ALMA, ATCA, BIMA, CLRO, DRAO, DWL, GB, JCMT,
MOPRA, NRAO12M, PKS, VLA, WSRT, and others
"""
def get_observatories(self):
"""
Get list of known observatory names.
Returns:
list of str, observatory names
"""Epoch and Time Measures
Handle time epochs with various time systems and conversions.
class measures:
def epoch(self, rf='', v0='0.0d', off=None):
"""
Create epoch measure.
Parameters:
- rf: str, time reference frame
- v0: str or quantity, time value
- off: dict, optional offset epoch
Returns:
dict, epoch measure with 'type': 'epoch'
Reference frames:
- UTC: Coordinated Universal Time
- TAI: International Atomic Time
- LAST: Local Apparent Sidereal Time (requires position)
- LMST: Local Mean Sidereal Time (requires position)
- GMST1: Greenwich Mean Sidereal Time
- GAST: Greenwich Apparent Sidereal Time
- UT1: Universal Time 1
- UT2: Universal Time 2
- TDT: Terrestrial Dynamical Time
- TCG: Geocentric Coordinate Time
- TDB: Barycentric Dynamical Time
- TCB: Barycentric Coordinate Time
"""
def framenow(self):
"""Set epoch frame to current time."""Frequency and Spectral Measures
Handle radio frequencies with Doppler corrections and reference frame conversions.
class measures:
def frequency(self, rf='', v0='0Hz', off=None):
"""
Create frequency measure.
Parameters:
- rf: str, reference frame
- v0: str or quantity, frequency value
- off: dict, optional offset frequency
Returns:
dict, frequency measure with 'type': 'frequency'
Reference frames:
- REST: Rest frequency
- LSRK: Local Standard of Rest (kinematic)
- LSRD: Local Standard of Rest (dynamic)
- BARY: Barycentric
- GEO: Geocentric (requires epoch)
- TOPO: Topocentric (requires epoch and position)
- GALACTO: Galactocentric
"""
def doppler(self, rf='', v0=0.0, off=None):
"""
Create Doppler measure.
Parameters:
- rf: str, Doppler convention
- v0: float, str, or quantity, Doppler value
- off: dict, optional offset Doppler
Returns:
dict, Doppler measure with 'type': 'doppler'
Conventions:
- RADIO: Radio convention (f_rest - f_obs)/f_rest
- OPTICAL: Optical convention (λ_obs - λ_rest)/λ_rest
- Z: Redshift z
- RATIO: Velocity ratio v/c
- RELATIVISTIC: Relativistic formula
- BETA: β = v/c
- GAMMA: Lorentz factor γ
"""
def radialvelocity(self, rf='', v0='0m/s', off=None):
"""
Create radial velocity measure.
Parameters:
- rf: str, reference frame (same as frequency frames)
- v0: str or quantity, velocity value
- off: dict, optional offset velocity
Returns:
dict, radial velocity measure with 'type': 'radialvelocity'
"""
def line(self, name):
"""
Get frequency measure for spectral line.
Parameters:
- name: str, spectral line name (minimum match)
Returns:
dict, frequency measure for line
Known lines include:
HI, OH1612, OH1665, OH1667, OH1720, CO115271,
H2O22235, SiO86847, CO230538, and others
"""
def get_lines(self):
"""
Get list of known spectral line names.
Returns:
list of str, line names
"""Baseline and UVW Coordinates
Handle interferometric baseline coordinates and UVW transformations.
class measures:
def baseline(self, rf='', v0='0..', v1='', v2='', off=None):
"""
Create baseline measure.
Parameters:
- rf: str, reference frame ('ITRF' or direction codes)
- v0: str or quantity, X or longitude
- v1: str or quantity, Y or latitude
- v2: str or quantity, Z or height
- off: dict, optional offset baseline
Returns:
dict, baseline measure with 'type': 'baseline'
"""
def uvw(self, rf='', v0='0..', v1='', v2='', off=None):
"""
Create UVW coordinate measure.
Parameters:
- rf: str, reference frame ('ITRF' or direction codes)
- v0: str or quantity, U coordinate
- v1: str or quantity, V coordinate
- v2: str or quantity, W coordinate
- off: dict, optional offset UVW
Returns:
dict, UVW measure with 'type': 'uvw'
"""
def touvw(self, v):
"""
Convert baseline to UVW coordinates.
Requires direction and epoch in frame.
Parameters:
- v: dict, baseline measure
Returns:
dict with UVW measure and derivatives
"""
def expand(self, v):
"""
Calculate baseline differences from positions.
Parameters:
- v: dict, position, baseline, or UVW measure
Returns:
dict with expanded measure and coordinate differences
"""
def asbaseline(self, pos):
"""
Convert position to baseline measure.
Parameters:
- pos: dict, position measure
Returns:
dict, baseline measure
"""Coordinate Conversions
Convert between different measure types with proper reference frame handling.
class measures:
def tofrequency(self, rf, v0, rfq):
"""
Convert Doppler to frequency.
Parameters:
- rf: str, frequency reference frame
- v0: dict, Doppler measure
- rfq: dict or quantity, rest frequency
Returns:
dict, frequency measure
"""
def to_frequency(self, rf, v0, rfq):
"""Alias for tofrequency."""
def todoppler(self, rf, v0, rfq):
"""
Convert frequency or radial velocity to Doppler.
Parameters:
- rf: str, Doppler convention
- v0: dict, frequency or radial velocity measure
- rfq: dict or quantity, rest frequency (for frequency input)
Returns:
dict, Doppler measure
"""
def to_doppler(self, rf, v0, rfq):
"""Alias for todoppler."""
def toradialvelocity(self, rf, v0):
"""
Convert Doppler to radial velocity.
Parameters:
- rf: str, velocity reference frame
- v0: dict, Doppler measure
Returns:
dict, radial velocity measure
"""
def to_radialvelocity(self, rf, v0):
"""Alias for toradialvelocity."""
def torestfrequency(self, f0, d0):
"""
Calculate rest frequency from observed frequency and Doppler.
Parameters:
- f0: dict, frequency measure
- d0: dict, Doppler measure
Returns:
dict, rest frequency measure
"""
def to_restfrequency(self, f0, d0):
"""Alias for torestfrequency."""Astronomical Calculations
Perform astronomical calculations like rise/set times, separations, and position angles.
class measures:
def rise(self, crd, ev='5deg'):
"""
Calculate rise/set hour angles.
Requires position and epoch in frame.
Parameters:
- crd: dict, direction measure
- ev: str or quantity, elevation limit
Returns:
dict with 'rise' and 'set' hour angles, or strings 'above'/'below'
"""
def riseset(self, crd, ev="5deg"):
"""
Calculate rise/set times in UTC and sidereal time.
Parameters:
- crd: dict, direction measure
- ev: str or quantity, elevation limit
Returns:
dict with rise/set times and solution status
"""
def posangle(self, m0, m1):
"""
Calculate position angle between two directions.
Parameters:
- m0: dict, first direction measure
- m1: dict, second direction measure
Returns:
quantity, position angle
"""
def separation(self, m0, m1):
"""
Calculate angular separation between two directions.
Parameters:
- m0: dict, first direction measure
- m1: dict, second direction measure
Returns:
quantity, angular separation
"""Source and Reference Catalogs
Access built-in catalogs of astronomical sources and reference objects.
class measures:
def source(self, name):
"""
Get direction measure for astronomical source.
Parameters:
- name: str, source name (minimum match)
Returns:
dict, direction measure for source
"""
def get_sources(self):
"""
Get list of known source names.
Returns:
list of str, source names
"""Earth Magnetic Field
Handle Earth's magnetic field measurements and models.
class measures:
def earthmagnetic(self, rf='', v0='0G', v1='0..', v2='90..', off=None):
"""
Create Earth magnetic field measure.
Parameters:
- rf: str, reference frame ('IGRF')
- v0: str or quantity, field strength or longitude
- v1: str or quantity, latitude
- v2: str or quantity, height
- off: dict, optional offset
Returns:
dict, earth magnetic measure with 'type': 'earthmagnetic'
Reference frames:
- IGRF: International Geomagnetic Reference Field
"""Observatory and Reference Data
Access built-in catalogs of observatories and spectral lines.
class measures:
def observatory(self, name):
"""
Get position measure for named observatory.
Parameters:
- name: str, observatory name (case-insensitive)
Returns:
dict, position measure for observatory
Common observatories: ALMA, ATCA, BIMA, CLRO, DRAO, DWL, GB, JCMT,
MOPRA, NRAO12M, PKS, VLA, WSRT
"""
def get_observatories(self):
"""
Get list of known observatory names.
Returns:
list of str, observatory names
"""
def line(self, name):
"""
Get frequency measure for spectral line.
Parameters:
- name: str, spectral line name (minimum match)
Returns:
dict, frequency measure for line
Common lines: HI, OH1612, OH1665, OH1667, OH1720, CO115271,
H2O22235, SiO86847, CO230538, H107A, H110A, etc.
"""
def get_lines(self):
"""
Get list of known spectral line names.
Returns:
list of str, spectral line names
"""Baseline and UVW Operations
Handle baseline measures and UVW coordinate transformations for interferometry.
class measures:
def touvw(self, v):
"""
Convert baseline to UVW coordinates.
Requires direction and epoch in reference frame.
Parameters:
- v: dict, baseline measure
Returns:
dict, UVW measure with additional 'xyz' and 'dot' quantities
"""
def expand(self, v):
"""
Calculate differences between position/baseline measures.
Parameters:
- v: dict, baseline, position, or UVW measure
Returns:
dict with 'measure' and 'xyz' difference quantities
"""
def asbaseline(self, pos):
"""
Convert position measure to baseline measure.
Parameters:
- pos: dict, position measure
Returns:
dict, baseline measure
"""
def as_baseline(self, pos):
"""Alias for asbaseline."""Frame Management
Advanced reference frame management and time handling.
class measures:
def framenow(self):
"""Set epoch frame to current time."""
def frame_now(self):
"""Alias for framenow."""
def set_data_path(self, pth):
"""
Set path to measures data directory.
Parameters:
- pth: str, absolute path to data directory
"""Measure Utilities
Utility functions for working with measures and extracting information.
class measures:
def getvalue(self, v):
"""
Get quantity values from measure.
Parameters:
- v: dict, measure
Returns:
list of quantities (m0, m1, m2, ...)
"""
def get_value(self, v):
"""Alias for getvalue."""
def get_type(self, m):
"""
Get measure type.
Parameters:
- m: dict, measure
Returns:
str, measure type
"""
def get_ref(self, m):
"""
Get reference frame.
Parameters:
- m: dict, measure
Returns:
str, reference frame code
"""
def get_offset(self, m):
"""
Get offset measure.
Parameters:
- m: dict, measure
Returns:
dict, offset measure or None
"""Usage Examples
Basic Coordinate Transformations
from casacore.measures import measures
from casacore.quanta import quantity
# Create measures server
dm = measures()
# Set reference frame (position and time)
dm.doframe(dm.observatory('VLA'))
dm.doframe(dm.epoch('UTC', 'today'))
# Create source direction
source = dm.direction('J2000', '12h30m00s', '-30d00m00s')
print(f"Source: RA={source['m0']}, Dec={source['m1']}")
# Convert to azimuth/elevation
azel = dm.measure(source, 'AZEL')
print(f"Az/El: Az={azel['m0']}, El={azel['m1']}")
# Convert to galactic coordinates
galactic = dm.measure(source, 'GALACTIC')
print(f"Galactic: l={galactic['m0']}, b={galactic['m1']}")Frequency and Doppler Conversions
# Create frequency measure
obs_freq = dm.frequency('TOPO', '1.42040575GHz') # Observed HI frequency
# Create Doppler measure
doppler = dm.doppler('RADIO', '100km/s')
# Get rest frequency for HI line
hi_rest = dm.line('HI')
print(f"HI rest frequency: {hi_rest['m0']}")
# Convert Doppler to frequency
conv_freq = dm.tofrequency('LSRK', doppler, hi_rest)
print(f"Converted frequency: {conv_freq['m0']}")
# Convert frequency to velocity
velocity = dm.todoppler('RADIO', obs_freq, hi_rest)
radial_vel = dm.toradialvelocity('LSRK', velocity)
print(f"Radial velocity: {radial_vel['m0']}")Rise/Set Calculations
# Calculate rise/set times for a source
source = dm.source('3C147') # Use known source
# Set observation parameters
dm.doframe(dm.observatory('WSRT'))
dm.doframe(dm.epoch('UTC', '2023-06-15/12:00:00'))
# Calculate rise/set
riseset = dm.riseset(source, ev='10deg') # 10 degree elevation limit
if riseset['solved']:
print(f"Rise time (UTC): {riseset['rise']['utc']['m0']}")
print(f"Set time (UTC): {riseset['set']['utc']['m0']}")
print(f"Rise time (LST): {riseset['rise']['last']['m0']}")
print(f"Set time (LST): {riseset['set']['last']['m0']}")
else:
print("Source is always above or below horizon")Baseline to UVW Transformation
# Create baseline measure (antenna separation)
baseline = dm.baseline('ITRF', '100m', '200m', '50m')
# Set observation parameters for UVW calculation
dm.doframe(dm.source('CYGA')) # Set source direction
dm.doframe(dm.epoch('UTC', '2023-06-15/18:00:00'))
# Convert baseline to UVW coordinates
uvw_result = dm.touvw(baseline)
uvw_coords = uvw_result
print(f"UVW: U={uvw_coords['m0']}, V={uvw_coords['m1']}, W={uvw_coords['m2']}")
# Get time derivatives (for Earth rotation tracking)
if 'dot' in uvw_result:
print(f"UVW rates: {uvw_result['dot']}")Angular Measurements
# Calculate separation between two sources
source1 = dm.source('CYGA')
source2 = dm.source('CASB')
separation = dm.separation(source1, source2)
print(f"Angular separation: {separation}")
# Calculate position angle
pos_angle = dm.posangle(source1, source2)
print(f"Position angle: {pos_angle}")Install with Tessl CLI
npx tessl i tessl/pypi-python-casacore