xradio 0.0.34__py3-none-any.whl → 0.0.37__py3-none-any.whl

xradio/vis/schema.py

@@ -12,10 +12,16 @@ import numpy
 # Dimensions
 Time = Literal["time"]
 """ Observation time dimension """
-AntennaId = Literal["antenna_id"]
-""" Antenna ID dimension """
-ReceptorName = Literal["receptor_name"]
-""" Receptor name dimension """
+AntennaName = Literal["antenna_name"]
+""" Antenna name dimension """
+StationId = Literal["station_id"]
+""" Station ID dimension """
+ReceptorId = Literal["receptor_id"]
+""" Receptor ID dimension """
+ReceptorLabel = Literal["receptor_label"]
+""" Receptor label dimension """
+ToneLabel = Literal["tone_label"]
+""" Tone label dimension """
 BaselineId = Literal["baseline_id"]
 """ Baseline ID dimension """
 Frequency = Literal["frequency"]
@@ -24,40 +30,77 @@ Polarization = Literal["polarization"]
 """ Polarization dimension """
 UvwLabel = Literal["uvw_label"]
 """ Coordinate dimension of UVW data (typically shape 3 for 'u', 'v', 'w') """
-XyzLabel = Literal["xyz_label"]
-""" Coordinate dimension of earth location data (typically shape 3 and 'x', 'y', 'z')"""
+SkyDirLabel = Literal["sky_dir_label"]
+""" Coordinate labels of sky directions (typically shape 2 and 'ra', 'dec') """
+SphericalDirLabel = Literal["spherical_dir_label"]
+""" Coordinate labels of spherical directions (shape 2 and 'lon', 'lat1' """
+SkyPosLabel = Literal["sky_pos_label"]
+""" Coordinate labels of sky positions (typically shape 3 and 'ra', 'dec', 'dist') """
+SphericalPosLabel = Literal["spherical_pos_label"]
+""" Coordinate labels of spherical positions (shape shape 3 and 'lon', 'lat1', 'dist2') """
+EllipsoidPosLabel = Literal["ellipsoid_pos_label"]
+""" Coordinate labels of geodetic earth location data (typically shape 3 and 'lon', 'lat', 'height')"""
+CartesianPosLabel = Literal["cartesian_pos_label"]
+""" Coordinate labels of geocentric earth location data (typically shape 3 and 'x', 'y', 'z')"""
+TimePhaseCal = Literal["time_phase_cal"]
+""" Coordinate label for VLBI-specific phase cal time axis """
 TimePolynomial = Literal["time_polynomial"]
 """ For data that is represented as variable in time using Taylor expansion """
-SkyCoordLabel = Literal["sky_coord_label"]
-""" Unlabeled axis """
+PolyTerm = Literal["poly_term"]
+""" Polynomial term used in VLBI GAIN_CURVE """
+LineLabel = Literal["line_label"]
+""" Line labels (for line names and variables). """
 
+# Represents "no dimension", i.e. used for coordinates and data variables with
+# zero dimensions.
+ZD = tuple[()]
 
-# Plain data class models
-@dict_schema
-class SourceInfoDict:
-    # TODO
-    pass
+# Quantities
 
 
 @xarray_dataarray_schema
 class TimeArray:
-    data: Data[Time, float]
+    """
+    Representation of a time quantity.
+
+    :py:class:`astropy.time.Time` serves as the reference implementation.
+    Data can be converted as follows::
+
+        astropy.time.Time(data * astropy.units.Unit(attrs['units'][0]),
+                          format=attrs['format'], scale=attrs['scale'])
+
+    All formats that express time as floating point numbers since an epoch
+    are permissible, so at present the realistic options are:
+
+    * ``mjd`` (from 1858-11-17 00:00:00 UTC)
+    * ``unix`` (from 1970-01-01 00:00:00 UTC)
+    * ``unix_tai`` (from 1970-01-01 00:00:00 TAI)
+    * ``cxcsec`` (from 1998-01-01 00:00:00 TT)
+    * ``gps`` (from 1980-01-06 00:00:00 UTC)
+
+    """
+
+    data: Data[ZD, float]
+    """Time since epoch, typically in seconds (see ``units``)."""
 
     scale: Attr[str] = "tai"
-    """Astropy time scales."""
-    format: Attr[str] = "unix"
-    """Seconds from 1970-01-01 00:00:00 UTC"""
+    """
+    Time scale of data. Must be one of ``(‘tai’, ‘tcb’, ‘tcg’, ‘tdb’, ‘tt’, ‘ut1’, ‘utc’)``,
+    see :py:class:`astropy.time.Time`
+    """
+    format: Attr[str] = "unix_tai"
+    """Time representation and epoch, see :py:class:`TimeArray`."""
 
     type: Attr[str] = "time"
-    units: Attr[list] = ("s",)
+    units: Attr[list[str]] = ("s",)
 
 
 @xarray_dataarray_schema
 class SkyCoordArray:
-    data: Data[SkyCoordLabel, float]
+    data: Data[Union[SkyDirLabel, SkyPosLabel], float]
 
     type: Attr[str] = "sky_coord"
-    units: Attr[list] = ("rad", "rad")
+    units: Attr[list[str]] = ("rad", "rad")
     frame: Attr[str] = ""
     """
     From fixvis docs: clean and the im tool ignore the reference frame
@@ -69,8 +112,61 @@ class SkyCoordArray:
     """
 
 
-@dict_schema
-class FieldInfoDict:
+@xarray_dataarray_schema
+class SkyCoordOffsetArray:
+    data: Data[Union[SkyDirLabel, SkyPosLabel], float]
+
+    type: Attr[str] = "sky_coord"
+    units: Attr[list[str]] = ("rad", "rad")
+
+
+@xarray_dataarray_schema
+class QuantityArray:
+    """
+    Anonymous quantity, possibly with associated units
+
+    Often used for distances / differences (integration time, channel width etcetera).
+    """
+
+    data: Data[ZD, float]
+
+    units: Attr[list[str]]
+    type: Attr[str] = "quantity"
+
+
+# Coordinates / Axes
+@xarray_dataarray_schema
+class TimeCoordArray:
+    """Data model of visibility time axis. See also :py:class:`TimeArray`."""
+
+    data: Data[Time, float]
+    """
+    Time, expressed in seconds since the epoch (see ``scale`` &
+    ``format``), see also see :py:class:`TimeArray`.
+    """
+
+    integration_time: Optional[Attr[QuantityArray]] = None
+    """ The nominal sampling interval (ms v2). Units of seconds. """
+    effective_integration_time: Optional[Attr[str]] = None
+    """
+    Name of data array that contains the integration time that includes
+    the effects of missing data.
+    """
+
+    type: Attr[str] = "time"
+    """ Coordinate type. Should be ``"time"``. """
+    units: Attr[list[str]] = ("s",)
+    """ Units to associate with axis"""
+    scale: Attr[str] = "tai"
+    """ Astropy time scales, see :py:class:`TimeArray` """
+    format: Attr[str] = "unix"
+    """ Astropy format, see :py:class:`TimeArray`"""
+    long_name: Optional[Attr[str]] = "Observation Time"
+    """ Long-form name to use for axis"""
+
+
+@xarray_dataset_schema
+class FieldSourceXds:
     """
     Field positions for each source.
 
@@ -78,52 +174,154 @@ class FieldInfoDict:
     For single dishes, this is the nominal pointing direction.
     """
 
-    name: str
+    source_name: Optional[Coord[Union[ZD, Time], str]]
+    """ Source name. """
+    field_name: Optional[Coord[Union[ZD, Time], str]]
     """Field name."""
-    field_id: int
-    """Field id"""
-    code: str
-    """Field code indicating special characteristics of the field; user specified."""
-    time_reference: Optional[TimeArray]
+
+    time: Optional[Coordof[TimeCoordArray]]
+    """Midpoint of time for which this set of parameters is accurate"""
+
+    line_label: Optional[Coord[LineLabel, str]]
+    """ Line labels (for line names and variables). """
+
+    line_names: Optional[Coord[Union[tuple[LineLabel], tuple[Time, LineLabel]], str]]
+    """ Line names (e.g. v=1, J=1-0, SiO). """
+
+    FIELD_PHASE_CENTER: Optional[Data[Union[ZD, Time], SkyCoordOffsetArray]]
     """
-    Time reference for the directions and rates. When used in :py:class:`VisibilityXds` should match 
-    the scale and format given for ``time`` (see :py:class:`TimeArray`).
+    Offset from the SOURCE_DIRECTION that gives the direction of phase
+    center for which the fringes have been stopped-that is a point source in
+    this direction will produce a constant measured phase (page 2 of
+    https://articles.adsabs.harvard.edu/pdf/1999ASPC..180...79F). For
+    conversion from MSv2, frame refers column keywords by default. If frame
+    varies with field, it refers DelayDir_Ref column instead.
+    """
+    FIELD_DELAY_CENTER: Optional[
+        Data[Union[tuple[SkyDirLabel], tuple[Time, SkyDirLabel]], numpy.float64]
+    ]
+    """
+    Offset from the SOURCE_DIRECTION that gives the direction of delay
+    center where coherence is maximized by inserting delay into one element of
+    an interferometer to compensate for the geometrical and instrumental
+    differential delay. (For conversion from MSv2, frame refers column keywords
+    by default. If frame varies with field, it refers PhaseDir_Ref column
+    instead.)
+    """
+
+    SOURCE_LOCATION: Optional[
+        Data[
+            Union[
+                tuple[SkyPosLabel],
+                tuple[Time, SkyPosLabel],
+                tuple[SkyDirLabel],
+                tuple[Time, SkyDirLabel],
+            ],
+            numpy.float64,
+        ]
+    ]
+    """
+    CASA Table Cols: RA,DEC,Rho."Astrometric RA and Dec and Geocentric
+    distance with respect to the observer’s location (Geocentric). "Adjusted
+    for light-time aberration only. With respect to the reference plane and
+    equinox of the chosen system (ICRF or FK4/B1950). If the FK4/B1950 frame
+    output is selected, elliptic aberration terms are added. Astrometric RA/DEC
+    is generally used when comparing or reducing data against a star catalog."
+    https://ssd.jpl.nasa.gov/horizons/manual.html : 1. Astrometric RA & DEC
     """
-    delay_direction: SkyCoordArray
 
+    LINE_REST_FREQUENCY: Optional[
+        Data[Union[tuple[LineLabel], tuple[Time, LineLabel]], numpy.float64]
+    ]
+    """ Rest frequencies for the transitions. """
 
-@xarray_dataarray_schema
-class QuantityArray:
-    """
-    Anonymous quantity
+    LINE_SYSTEMIC_VELOCITY: Optional[
+        Data[Union[tuple[LineLabel], tuple[Time, LineLabel]], numpy.float64]
+    ]
+    """ Systemic velocity at reference """
+
+    SOURCE_RADIAL_VELOCITY: Optional[Data[tuple[Time], numpy.float64]]
+    """ CASA Table Cols: RadVel. Geocentric distance rate """
+
+    NORTH_POLE_POSITION_ANGLE: Optional[Data[tuple[Time], numpy.float64]]
+    """ CASA Table cols: NP_ang, "Targets' apparent north-pole position angle (counter-clockwise with respect to direction of true-of-date reference-frame north pole) and angular distance from the sub-observer point (center of disc) at print time. A negative distance indicates the north-pole is on the hidden hemisphere." https://ssd.jpl.nasa.gov/horizons/manual.html : 17. North pole position angle & distance from disc center. """
+
+    NORTH_POLE_ANGULAR_DISTANCE: Optional[Data[tuple[Time], numpy.float64]]
+    """ CASA Table cols: NP_dist, "Targets' apparent north-pole position angle (counter-clockwise with respect to direction of true-of date reference-frame north pole) and angular distance from the sub-observer point (center of disc) at print time. A negative distance indicates the north-pole is on the hidden hemisphere."https://ssd.jpl.nasa.gov/horizons/manual.html : 17. North pole position angle & distance from disc center. """
+
+    SUB_OBSERVER_DIRECTION: Optional[
+        Data[tuple[Time, SphericalDirLabel], numpy.float64]
+    ]
+    """ CASA Table cols: DiskLong, DiskLat. "Apparent planetodetic longitude and latitude of the center of the target disc seen by the OBSERVER at print-time. This is not exactly the same as the "nearest point" for a non-spherical target shape (since the center of the disc might not be the point closest to the observer), but is generally very close if not a very irregular body shape. The IAU2009 rotation models are used except for Earth and MOON, which use higher-precision models. For the gas giants Jupiter, Saturn, Uranus and Neptune, IAU2009 longitude is based on the "System III" prime meridian rotation angle of the magnetic field. By contrast, pole direction (thus latitude) is relative to the body dynamical equator. There can be an offset between the magnetic pole and the dynamical pole of rotation. Down-leg light travel-time from target to observer is taken into account. Latitude is the angle between the equatorial plane and perpendicular to the reference ellipsoid of the body and body oblateness thereby included. The reference ellipsoid is an oblate spheroid with a single flatness coefficient in which the y-axis body radius is taken to be the same value as the x-axis radius. Whether longitude is positive to the east or west for the target will be indicated at the end of the output ephemeris." https://ssd.jpl.nasa.gov/horizons/manual.html : 14. Observer sub-longitude & sub-latitude """
+
+    SUB_SOLAR_POSITION: Optional[Data[tuple[Time, SphericalPosLabel], numpy.float64]]
+    """ CASA Table cols: Sl_lon, Sl_lat, r. "Heliocentric distance along with "Apparent sub-solar longitude and latitude of the Sun on the target. The apparent planetodetic longitude and latitude of the center of the target disc as seen from the Sun, as seen by the observer at print-time.  This is _NOT_ exactly the same as the "sub-solar" (nearest) point for a non-spherical target shape (since the center of the disc seen from the Sun might not be the closest point to the Sun), but is very close if not a highly irregular body shape.  Light travel-time from Sun to target and from target to observer is taken into account.  Latitude is the angle between the equatorial plane and the line perpendicular to the reference ellipsoid of the body. The reference ellipsoid is an oblate spheroid with a single flatness coefficient in which the y-axis body radius is taken to be the same value as the x-axis radius. Uses IAU2009 rotation models except for Earth and Moon, which uses a higher precision models. Values for Jupiter, Saturn, Uranus and Neptune are Set III, referring to rotation of their magnetic fields.  Whether longitude is positive to the east or west for the target will be indicated at the end of the output ephemeris." https://ssd.jpl.nasa.gov/horizons/manual.html : 15. Solar sub-longitude & sub-latitude  """
+
+    HELIOCENTRIC_RADIAL_VELOCITY: Optional[Data[tuple[Time], numpy.float64]]
+    """ CASA Table cols: rdot."The Sun's apparent range-rate relative to the target, as seen by the observer. A positive "rdot" means the target was moving away from the Sun, negative indicates movement toward the Sun." https://ssd.jpl.nasa.gov/horizons/manual.html : 19. Solar range & range-rate (relative to target) """
+
+    OBSERVER_PHASE_ANGLE: Optional[Data[tuple[Time], numpy.float64]]
+    """ CASA Table cols: phang.""phi" is the true PHASE ANGLE at the observers' location at print time. "PAB-LON" and "PAB-LAT" are the FK4/B1950 or ICRF/J2000 ecliptic longitude and latitude of the phase angle bisector direction; the outward directed angle bisecting the arc created by the apparent vector from Sun to target center and the astrometric vector from observer to target center. For an otherwise uniform ellipsoid, the time when its long-axis is perpendicular to the PAB direction approximately corresponds to lightcurve maximum (or maximum brightness) of the body. PAB is discussed in Harris et al., Icarus 57, 251-258 (1984)." https://ssd.jpl.nasa.gov/horizons/manual.html : Phase angle and bisector """
+
+    OBSERVER_POSITION: Optional[
+        Data[Union[tuple[EllipsoidPosLabel], tuple[CartesianPosLabel]], numpy.float64]
+    ]
+    """ Observer location. """
+
+    # --- Attributes ---
+    DOPPLER_SHIFT_VELOCITY: Optional[Attr[numpy.float64]]
+    """ Velocity definition of the Doppler shift, e.g., RADIO or OPTICAL velocity in m/s """
+
+    source_model_url: Optional[Attr[str]]
+    """URL to access source model"""
+    ephemeris_name: Optional[Attr[str]]
+    """The name of the ephemeris. For example DE430.
+
+    This can be used with Astropy solar_system_ephemeris.set('DE430'), see
+    https://docs.astropy.org/en/stable/coordinates/solarsystem.html.
     """
+    is_ephemeris: Attr[bool] = False
 
-    data: Data[tuple[()], float]
+    type: Attr[str] = "field_and_source"
+    """
+    Type of dataset.
+    """
 
-    type: Attr[str]
-    units: Attr[list]
+    # --- Optional coordinates ---
+    sky_dir_label: Optional[Coord[SkyDirLabel, str]] = ("ra", "dec")
+    """ Coordinate labels of sky directions (typically shape 2 and 'ra', 'dec') """
+    sky_pos_label: Optional[Coord[SkyPosLabel, str]] = ("ra", "dec", "dist")
+    """ Coordinate lables of sky positions (typically shape 3 and 'ra', 'dec', 'dist') """
+    ellipsoid_pos_label: Optional[Coord[EllipsoidPosLabel, str]] = (
+        "lon",
+        "lat",
+        "height",
+    )
+    """ Coordinate labels of geodetic earth location data (typically shape 3 and 'lon', 'lat', 'height')"""
+    cartesian_pos_label: Optional[Coord[CartesianPosLabel, str]] = ("x", "y", "z")
+    """ Coordinate labels of geocentric earth location data (typically shape 3 and 'x', 'y', 'z')"""
 
 
 @xarray_dataarray_schema
 class SpectralCoordArray:
-    data: Data[tuple[()], float]
+    data: Data[ZD, float]
 
     frame: Attr[str] = "gcrs"
     """Astropy time scales."""
 
     type: Attr[str] = "frequency"
-    units: Attr[list] = ("Hz",)
+    units: Attr[list[str]] = ("Hz",)
 
 
 @xarray_dataarray_schema
 class EarthLocationArray:
-    data: Data[XyzLabel, float]
+    data: Data[CartesianPosLabel, float]
 
     ellipsoid: Attr[str]
     """
     ITRF makes use of GRS80 ellipsoid and WGS84 makes use of WGS84 ellipsoid
     """
-    units: Attr[list] = ("m", "m", "m")
+    units: Attr[list[str]] = ("m", "m", "m")
     """
     If the units are a list of strings then it must be the same length as
     the last dimension of the data array. This allows for having different
@@ -132,9 +330,25 @@ class EarthLocationArray:
     """
 
 
+@dict_schema
+class PartitionInfoDict:
+    # spectral_window_id: missing / remove for good?
+    spectral_window_name: str
+    # field_id: missing / probably remove for good?
+    field_name: list[str]
+    # source_id: mising / remove for good?
+    line_name: list[str]
+    scan_number: list[int]
+    source_name: list[str]
+    polarization_setup: list[str]
+    num_lines: int
+    obs_mode: list[str]
+    taql: Optional[str]
+
+
 @dict_schema
 class ObservationInfoDict:
-    observer: List[str]
+    observer: list
     """List of observer names."""
     project: str
     """Project Code/Project_UID"""
@@ -169,41 +383,6 @@ class ProcessorInfoDict:
     """Processor sub-type, e.g. ”GBT” or ”JIVE”."""
 
 
-# Coordinates / Axes
-@xarray_dataarray_schema
-class TimeArray:
-    """Data model of time axis"""
-
-    data: Data[Time, float]
-    """ Time, expressed in SI seconds since the epoch (see ``scale`` & ``format``). """
-
-    integration_time: Attr[Optional[TimeArray]] = None
-    """ The nominal sampling interval (ms v2). Units of seconds. """
-    effective_integration_time: Attr[Optional[TimeArray]] = None
-    """ Name of data array that contains the integration time that includes the effects of missing data. """
-
-    type: Attr[str] = "time"
-    """ Coordinate type. Should be ``"time"``. """
-    units: Attr[list[str]] = ("s",)
-    """ Units to associate with axis"""
-    scale: Attr[str] = "tai"
-    """ Astropy time scales, see :py:class:`astropy.time.Time` """
-    format: Attr[str] = "unix"
-    """ Astropy format, see :py:class:`astropy.time.Time`. Default seconds from 1970-01-01 00:00:00 UTC """
-    long_name: Optional[Attr[str]] = "Observation Time"
-    """ Long-form name to use for axis"""
-
-
-@xarray_dataarray_schema
-class AntennaArray:
-    data: Data[AntennaId, int]
-    """
-    Antenna id of an antenna. Maps to ``antenna_id``
-    in :py:class:`AntennaXds`.
-    """
-    long_name: Optional[Attr[str]] = "Antenna ID"
-
-
 @xarray_dataarray_schema
 class BaselineArray:
     """TODO: documentation"""
@@ -214,13 +393,22 @@ class BaselineArray:
 
 
 @xarray_dataarray_schema
-class BaselineAntennaArray:
-    data: Data[BaselineId, Union[numpy.int64, numpy.int32]]
-    """
-    Antenna id for an antenna in a baseline. Maps to ``attrs['antenna_xds'].antenna_id``
-    in :py:class:`VisibilityXds`
-    """
-    long_name: Optional[Attr[str]] = "Baseline Antenna ID"
+class BaselineAntennaNameArray:
+    """Array of antenna_name by baseline_id, as used in main_xds and main_sd_xds
+    (antenna_name by baseline_id dim"""
+
+    data: Data[BaselineId, str]
+    """Unique id for each baseline."""
+    long_name: Optional[Attr[str]] = "Antenna name by baseline_id"
+
+
+@xarray_dataarray_schema
+class AntennaNameArray:
+    """TODO: documentation"""
+
+    data: Data[AntennaName, str]
+    """Unique name for each antenna(_station)."""
+    long_name: Optional[Attr[str]] = "Antenna name"
 
 
 @xarray_dataset_schema
@@ -237,14 +425,14 @@ class FrequencyArray:
     """ Time, expressed in SI seconds since the epoch. """
     spectral_window_name: Attr[str]
     """ Name associated with spectral window. """
-    frequency_group_name: Attr[str]
+    frequency_group_name: Optional[Attr[str]]
     """ Name associated with frequency group - needed for multi-band VLBI fringe-fitting."""
     reference_frequency: Attr[SpectralCoordArray]
     """ A frequency representative of the spectral window, usually the sky
     frequency corresponding to the DC edge of the baseband. Used by the calibration
     system if a fixed scaling frequency is required or in algorithms to identify the
     observing band. """
-    channel_width: Attr[SpectralCoordArray]
+    channel_width: Attr[QuantityArray]  # Not SpectralCoord, as it is a difference
     """ The nominal channel bandwidth. Same units as data array (see units key). """
     doppler: Optional[Attr[DopplerXds]]
     """ Doppler tracking information """
@@ -312,14 +500,40 @@ class VisibilityArray:
         tuple[Time, BaselineId, Frequency, Polarization],
         Union[numpy.complex64, numpy.complex128],
     ]
-    time: Coord[tuple[()], TimeArray]
+
+    time: Coord[tuple[()], TimeCoordArray]
     baseline_id: Coord[tuple[()], BaselineArray]
-    frequency: Coord[tuple[()], FrequencyArray]
     polarization: Coord[tuple[()], PolarizationArray]
-    field_info: Attr[FieldInfoDict]
+    frequency: Coord[tuple[()], FrequencyArray]
+    time: Coord[ZD, TimeCoordArray]
+    baseline_id: Coord[ZD, BaselineArray]
+    polarization: Coord[ZD, PolarizationArray]
+    frequency: Coord[ZD, FrequencyArray]
+
+    field_and_source_xds: Attr[FieldSourceXds]
     long_name: Optional[Attr[str]] = "Visibility values"
     """ Long-form name to use for axis. Should be ``"Visibility values"``"""
-    units: Attr[list] = ("Jy",)
+    units: Attr[list[str]] = ("Jy",)
+
+
+@xarray_dataarray_schema
+class SpectrumArray:
+    """Definition of xr.DataArray for SPECTRUM data (single dish)"""
+
+    data: Data[
+        tuple[Time, AntennaName, Frequency, Polarization],
+        Union[numpy.float64, numpy.float32, numpy.float16],
+    ]
+
+    time: Coordof[TimeCoordArray]
+    antenna_name: Coordof[AntennaNameArray]
+    frequency: Coordof[FrequencyArray]
+    polarization: Coordof[PolarizationArray]
+
+    field_and_source_xds: Attr[FieldSourceXds]
+    long_name: Optional[Attr[str]] = "Spectrum values"
+    """ Long-form name to use for axis. Should be ``"Spectrum values"``"""
+    units: Attr[list[str]] = ("Jy",)
 
 
 @xarray_dataarray_schema
@@ -335,11 +549,13 @@ class FlagArray:
             tuple[Time, BaselineId, Frequency, Polarization],
             tuple[Time, BaselineId, Frequency],
             tuple[Time, BaselineId],
+            tuple[Time, AntennaName, Frequency, Polarization],  # SD
         ],
         bool,
     ]
-    time: Coordof[TimeArray]
-    baseline_id: Coordof[BaselineArray]
+    time: Coordof[TimeCoordArray]
+    baseline_id: Optional[Coordof[BaselineArray]]  # Only IF
+    antenna_name: Optional[Coordof[AntennaNameArray]]  # Only SD
     frequency: Coordof[FrequencyArray]
     polarization: Optional[Coordof[PolarizationArray]] = None
     long_name: Optional[Attr[str]] = "Visibility flags"
@@ -360,12 +576,14 @@ class WeightArray:
             tuple[Time, BaselineId, Frequency, Polarization],
             tuple[Time, BaselineId, Frequency],
             tuple[Time, BaselineId],
+            tuple[Time, AntennaName, Frequency, Polarization],  # SD
         ],
         Union[numpy.float16, numpy.float32, numpy.float64],
     ]
     """Visibility weights"""
-    time: Coordof[TimeArray]
-    baseline_id: Coordof[BaselineArray]
+    time: Coordof[TimeCoordArray]
+    baseline_id: Optional[Coordof[BaselineArray]]  # Only IF
+    antenna_name: Optional[Coordof[AntennaNameArray]]  # Only SD
     frequency: Optional[Coordof[FrequencyArray]] = None
     polarization: Optional[Coordof[PolarizationArray]] = None
     long_name: Optional[Attr[str]] = "Visibility weights"
@@ -406,6 +624,9 @@ class UvwArray:
             tuple[Time, BaselineId, Frequency, Polarization, UvwLabel],
             tuple[Time, BaselineId, Frequency, UvwLabel],
             tuple[Time, BaselineId, UvwLabel],
+            tuple[Time, AntennaName, UvwLabel],  # SD
+            tuple[Time, AntennaName, Frequency, UvwLabel],  # SD
+            tuple[Time, AntennaName, Frequency, Polarization],  # SD
         ],
         Union[
             numpy.float16,
@@ -414,8 +635,9 @@ class UvwArray:
         ],
     ]
     """Baseline coordinates from ``baseline_antenna2_id`` to ``baseline_antenna1_id``"""
-    time: Coordof[TimeArray]
-    baseline_id: Coordof[BaselineArray]
+    time: Coordof[TimeCoordArray]
+    baseline_id: Optional[Coordof[BaselineArray]]  # Only IF
+    antenna_name: Optional[Coordof[AntennaNameArray]]  # Only SD
     frequency: Optional[Coordof[FrequencyArray]] = None
     polarization: Optional[Coordof[PolarizationArray]] = None
     uvw_label: Coordof[UvwLabelArray] = ("u", "v", "w")
@@ -433,12 +655,14 @@ class TimeSamplingArray:
             tuple[Time, BaselineId, Frequency, Polarization],
             tuple[Time, BaselineId, Frequency],
             tuple[Time, BaselineId],
+            tuple[Time, AntennaName],  # SD
         ],
         float,
     ]
 
-    time: Coordof[TimeArray]
-    baseline_id: Coordof[BaselineArray]
+    time: Coordof[TimeCoordArray]
+    baseline_id: Optional[Coordof[BaselineArray]]  # Only IF
+    antenna_name: Optional[Coordof[AntennaNameArray]]  # Only SD
     frequency: Optional[Coordof[FrequencyArray]] = None
     polarization: Optional[Coordof[PolarizationArray]] = None
 
@@ -448,7 +672,7 @@ class TimeSamplingArray:
     """ Astropy format, see :py:class:`astropy.time.Time`. Default seconds from 1970-01-01 00:00:00 UTC """
 
     long_name: Optional[Attr[str]] = "Time sampling data"
-    units: Attr[str] = "s"
+    units: Attr[list[str]] = ("s",)
 
 
 @xarray_dataarray_schema
@@ -470,11 +694,11 @@ class FreqSamplingArray:
     :py:class:`VisibilityXds`.
     """
     frequency: Coordof[FrequencyArray]
-    time: Optional[Coordof[TimeArray]] = None
+    time: Optional[Coordof[TimeCoordArray]] = None
     baseline_id: Optional[Coordof[BaselineArray]] = None
     polarization: Optional[Coordof[PolarizationArray]] = None
     long_name: Optional[Attr[str]] = "Frequency sampling data"
-    units: Attr[str] = "Hz"
+    units: Attr[list[str]] = ("Hz",)
     frame: Attr[str] = "icrs"
     """
     Astropy velocity reference frames (see :external:ref:`astropy-spectralcoord`).
@@ -489,105 +713,220 @@ class FreqSamplingArray:
 
 @xarray_dataset_schema
 class AntennaXds:
-    # --- Coordinates ---
-    antenna_id: Coordof[AntennaArray]
-    """Antenna ID"""
-    name: Coord[AntennaId, str]
-
-    """Antenna name."""
-    station: Coord[AntennaId, str]
-    """Name of the station pad (relevant to arrays with moving antennas)."""
-    antenna_type: Optional[Coord[AntennaId, str]]
-    """Antenna type.
-    
-    Reserved keywords include: (``GROUND-BASED`` - conventional
-    antennas; ``SPACE-BASED`` - orbiting antennas; ``TRACKING-STN`` - tracking
-    stations)."""
-    mount: Coord[AntennaId, str]
-    """Mount type of the antenna.
-
-    Reserved keywords include: (``EQUATORIAL`` - equatorial mount; ``ALTAZ`` -
-    azimuth-elevation mount; ``X-Y`` - x-y mount; ``SPACE-HALCA`` - specific
-    orientation model.)"""
-    observatory: Optional[Coord[AntennaId, str]]
-    """Support for VLBI"""
-    receptor_name: Optional[Coord[ReceptorName, str]]
-    """Names of receptors"""
-    xyz_label: Coord[XyzLabel, str]
-    """Coordinate dimension of earth location data (typically shape 3 and 'x', 'y', 'z')"""
-    sky_coord_label: Optional[Coord[SkyCoordLabel, str]]
-    """Coordinate dimension of sky coordinate data (possibly shape 2 and 'RA', "Dec")"""
-
-    # --- Data variables ---
-    POSITION: Data[AntennaId, EarthLocationArray]
+    # Coordinates
+    antenna_name: Coordof[AntennaNameArray]
+    """ Antenna name """
+    station: Coord[AntennaName, str]
+    """ Name of the station pad (relevant to arrays with moving antennas). """
+    mount: Coord[AntennaName, str]
+    """ Mount type of the antenna. Reserved keywords include: ”EQUATORIAL” - equatorial mount;
+    ”ALT-AZ” - azimuth-elevation mount;
+    "ALT-AZ+ROTATOR"  alt-az mount with feed rotator; introduced for ASKAP dishes;
+    "ALT-AZ+NASMYTH-R": Nasmyth mount with receivers at the right-hand side of the cabin. Many high-frequency antennas used for VLBI have such a mount typel;
+    "ALT-AZ+NASMYTH-L:: Nasmyth mount with receivers at the left-hand side of the cabin.
+    ”X-Y” - x-y mount;
+    ”SPACE-HALCA” - specific orientation model."""
+    telescope_name: Optional[Coord[AntennaName, str]]
+    """ Useful when data is combined from mutiple arrays for example ACA + ALMA. """
+    # TODO: receptor_label, polarization_type, sky_dir_label set as optional
+    # for datasets like test_alma_ephemris_mosaic. See also BEAM_OFFSET below.
+    receptor_label: Optional[Coord[ReceptorLabel, str]]
+    """ Names of receptors """
+    polarization_type: Optional[Coord[tuple[AntennaName, ReceptorLabel], str]]
+    """ Polarization type to which each receptor responds (e.g. ”R”,”L”,”X” or ”Y”).
+    This is the receptor polarization type as recorded in the final correlated data (e.g. ”RR”); i.e.
+    as measured after all polarization combiners. ['X','Y'], ['R','L'] """
+    cartesian_pos_label: Optional[Coord[CartesianPosLabel, str]]
+    """ (x,y,z) - either cartesian or ellipsoid """
+    ellipsoid_pos_label: Optional[Coord[EllipsoidPosLabel, str]]
+    """ (lon, lat, dist) - either cartesian or ellipsoid"""
+    sky_dir_label: Optional[Coord[SkyDirLabel, str]]
+    """ ra, dec """
+    time: Optional[Coordof[TimeCoordArray]]
+    """ Time for VLBI phase cal"""
+    time_phase_cal: Optional[Coord[TimePhaseCal, numpy.float64]]
+    """ Time for VLBI phase cal"""
+    tone_label: Optional[Coord[ToneLabel, str]]
+    """ ? """
+    gain_curve_type: Optional[Coord[AntennaName, str]]
+    """ ? """
+
+    # Data variables
+    ANTENNA_POSITION: Data[
+        Union[
+            tuple[AntennaName, EllipsoidPosLabel], tuple[AntennaName, CartesianPosLabel]
+        ],
+        QuantityArray,
+    ]  # EarthLocationArray
     """
     In a right-handed frame, X towards the intersection of the equator and
     the Greenwich meridian, Z towards the pole.
     """
-    FEED_OFFSET: Data[tuple[AntennaId, XyzLabel], QuantityArray]
+    ANTENNA_FEED_OFFSET: Data[
+        Union[
+            tuple[AntennaName, EllipsoidPosLabel], tuple[AntennaName, CartesianPosLabel]
+        ],
+        QuantityArray,
+    ]
     """
     Offset of feed relative to position (``Antenna_Table.offset + Feed_Table.position``).
     """
-    DISH_DIAMETER: Data[AntennaId, QuantityArray]
+    ANTENNA_DISH_DIAMETER: Optional[Data[tuple[AntennaName], QuantityArray]]
     """
     Nominal diameter of dish, as opposed to the effective diameter.
     """
-    BEAM_OFFSET: Optional[Data[AntennaId, SkyCoordArray]]
+    ANTENNA_EFFECTIVE_DISH_DIAMETER: Optional[
+        Data[tuple[AntennaName, ReceptorLabel, SkyDirLabel], QuantityArray]
+    ]
+    """ Airy Disk Model .... """
+
+    # TODO: setting BEAM_OFFSET and RECEPTOR_ANGLE as optional for now, as it
+    # is not present in some datasets (example: test_alma_ephemris_mosaic)
+    BEAM_OFFSET: Optional[Data[tuple[AntennaName, ReceptorLabel], SkyCoordArray]]
     """
     Beam position offset, as defined on the sky but in the antenna
     reference frame.
     """
-    RECEPTOR_ANGLE: Optional[Data[tuple[AntennaId, ReceptorName], QuantityArray]]
+    RECEPTOR_ANGLE: Optional[Data[tuple[AntennaName, ReceptorLabel], QuantityArray]]
     """
     Polarization reference angle. Converts into parallactic angle in the sky domain.
     """
-    FOCUS_LENGTH: Optional[Data[AntennaId, QuantityArray]]
+    FOCUS_LENGTH: Optional[Data[tuple[AntennaName], QuantityArray]]
     """
     Focus length. As defined along the optical axis of the antenna.
     """
-    ARRAY_CENTER: Optional[Data[AntennaId, EarthLocationArray]]
-    EFFECTIVE_DISH_DIAMETER: Optional[Data[AntennaId, QuantityArray]]
 
-    # --- Attributes ---
-    telescope_name: Optional[Attr[str]]
+    GAIN_CURVE: Optional[
+        Data[tuple[AntennaName, ReceptorLabel, PolyTerm], numpy.float32]
+    ]
+    """ VLBI. ?  """
+    GAIN_CURVE_INTERVAL: Optional[Data[tuple[AntennaName], QuantityArray]]
+    """ VLBI. ?  """
+    GAIN_CURVE_SENSITIVITY: Optional[
+        Data[tuple[AntennaName, ReceptorLabel], numpy.float32]
+    ]
+    """ VLBI. ?  """
+    PHASE_CAL: Optional[
+        Data[
+            Union[
+                tuple[AntennaName, Time, ReceptorLabel, ToneLabel],
+                tuple[AntennaName, TimePhaseCal, ReceptorLabel, ToneLabel],
+            ],
+            numpy.complex64,
+        ]
+    ]
+    """ VLBI. ?  """
+    PHASE_CAL_CABLE_CAL: Optional[
+        Data[
+            Union[tuple[AntennaName, Time], tuple[AntennaName, TimePhaseCal]],
+            QuantityArray,
+        ]
+    ]
+    """ VLBI. ?  """
+    PHASE_CAL_INTERVAL: Optional[
+        Data[
+            Union[tuple[AntennaName, Time], tuple[AntennaName, TimePhaseCal]],
+            QuantityArray,
+        ]
+    ]
+    """ VLBI. ?  """
+    PHASE_CAL_TONE_FREQUENCY: Optional[
+        Data[
+            Union[
+                tuple[AntennaName, Time, ReceptorLabel, ToneLabel],
+                tuple[AntennaName, TimePhaseCal, ReceptorLabel, ToneLabel],
+            ],
+            QuantityArray,
+        ]
+    ]
+    """ VLBI. ?  """
+
+    # Attributes
+    overall_telescope_name: Optional[Attr[str]]
     """
-    From MS v2 observation table
+    The name of the collection of arrays and dishes that were used for the observation.
+    In many instances this will only be a single array or dish. An example of a
+    telescope consistening of mutiple arrays and dishes is the EHT. The coordinate
+    telescope_name will give the names of the constituent arrays and dishes. From
+    MSv2 observation table.
     """
+    relocatable_antennas: Optional[Attr[bool]]
+    """ Can the antennas be moved (ALMA, VLA, NOEMA) """
     type: Attr[str] = "antenna"
     """
     Type of dataset. Expected to be ``antenna``
     """
 
 
+@xarray_dataset_schema
+class WeatherXds:
+    """Weather. Contains station positions and time-dependent mean external
+    atmosphere and weather information"""
+
+    # Coordinates
+    time: Coordof[TimeCoordArray]
+    """ Mid-point of the time interval """
+    station_id: Coord[StationId, numpy.int64]
+    """ Station identifier """
+    antenna_name: Optional[Coordof[AntennaNameArray]]
+    """ Antenna identifier """
+
+    # Data variables (all optional)
+    H2O: Optional[Data[tuple[StationId, Time], QuantityArray]] = None
+    """ Average column density of water """
+    IONOS_ELECTRON: Optional[Data[tuple[StationId, Time], QuantityArray]] = None
+    """ Average column density of electrons """
+    PRESSURE: Optional[Data[tuple[StationId, Time], QuantityArray]] = None
+    """ Ambient atmospheric pressure """
+    REL_HUMIDITY: Optional[Data[tuple[StationId, Time], QuantityArray]] = None
+    """ Ambient relative humidity """
+    TEMPERATURE: Optional[Data[tuple[StationId, Time], QuantityArray]] = None
+    """ Ambient air temperature for an antenna """
+    DEW_POINT: Optional[Data[tuple[StationId, Time], QuantityArray]] = None
+    """ Dew point """
+    WIND_DIRECTION: Optional[Data[tuple[StationId, Time], QuantityArray]] = None
+    """ Average wind direction """
+    WIND_SPEED: Optional[Data[tuple[StationId, Time], QuantityArray]] = None
+    """ Average wind speed """
+    STATION_POSITION: Optional[Data[tuple[StationId], QuantityArray]] = None
+    """ Station position """
+
+    # Attributes
+    type: Attr[str] = "weather"
+    """
+    Type of dataset.
+    """
+
+
 @xarray_dataset_schema
 class PointingXds:
-    time: Coordof[TimeArray]
+    time: Coordof[TimeCoordArray]
     """
     Mid-point of the time interval for which the information in this row is
     valid.  Required to use the same time measure reference as in visibility dataset
     """
-    antenna_id: Coordof[AntennaArray]
+    antenna_name: Coordof[AntennaNameArray]
     """
-    Antenna identifier, as specified by baseline_antenna1/2_id in visibility dataset
+    Antenna name, as specified by baseline_antenna1/2_name in visibility dataset
     """
-    sky_coord_label: Coord[SkyCoordLabel, str]
+    sky_dir_label: Coord[SkyDirLabel, str]
     """
     Direction labels.
     """
 
     BEAM_POINTING: Data[
-        Union[tuple[Time, AntennaId, TimePolynomial], tuple[Time, AntennaId]],
+        Union[tuple[Time, AntennaName, TimePolynomial], tuple[Time, AntennaName]],
         SkyCoordArray,
     ]
     """
     Antenna pointing direction, optionally expressed as polynomial coefficients. DIRECTION in MSv3.
     """
-    DISH_MEASURED_POINTING: Optional[Data[tuple[Time, AntennaId], SkyCoordArray]]
+    DISH_MEASURED_POINTING: Optional[Data[tuple[Time, AntennaName], SkyCoordArray]]
     """
     The current encoder values on the primary axes of the mount type for
     the antenna. ENCODER in MSv3.
     """
-    OVER_THE_TOP: Optional[Data[tuple[Time, AntennaId], bool]]
+    OVER_THE_TOP: Optional[Data[tuple[Time, AntennaName], bool]]
 
 
 @xarray_dataset_schema
@@ -597,15 +936,59 @@ class SpectralCoordXds:
 
 
 @xarray_dataset_schema
-class SourceXds:
+class PhasedArrayXds:
     # TODO
     pass
 
 
 @xarray_dataset_schema
-class PhasedArrayXds:
-    # TODO
-    pass
+class SystemCalibrationXds:
+    """System calibration. Contains time- and frequency- variable
+    calibration measurements for each antenna, as indexed on receptor"""
+
+    # Coordinates
+    antenna_name: Coordof[AntennaNameArray]
+    """ Antenna identifier """
+    time: Coordof[TimeCoordArray]
+    """ Midpoint of time for which this set of parameters is accurate """
+    receptor_id: Optional[Coord[ReceptorId, numpy.float64]] = None
+    """  """
+    frequency: Optional[Coordof[FrequencyArray]] = None
+    """  """
+
+    # Data variables (all optional)
+    PHASE_DIFFERENCE: Optional[Data[tuple[Time, AntennaName], numpy.float64]] = None
+    """ Phase difference between receptor 0 and receptor 1 """
+    TCAL: Optional[
+        Data[tuple[Time, AntennaName, ReceptorId, Frequency], QuantityArray]
+    ] = None
+    """ Calibration temp """
+    TRX: Optional[
+        Data[tuple[Time, AntennaName, ReceptorId, Frequency], QuantityArray]
+    ] = None
+    """ Receiver temperature """
+    TSKY: Optional[
+        Data[tuple[Time, AntennaName, ReceptorId, Frequency], QuantityArray]
+    ] = None
+    """ Sky temperature """
+    TSYS: Optional[
+        Data[tuple[Time, AntennaName, ReceptorId, Frequency], QuantityArray]
+    ] = None
+    """ System temperature """
+    TANT: Optional[
+        Data[tuple[Time, AntennaName, ReceptorId, Frequency], QuantityArray]
+    ] = None
+    """ Antenna temperature """
+    TANT_SYS: Optional[
+        Data[tuple[Time, AntennaName, ReceptorId, Frequency], QuantityArray]
+    ] = None
+    """ TANT/TSYS """
+
+    # Attributes
+    type: Attr[str] = "system_calibration"
+    """
+    Type of dataset.
+    """
 
 
 @xarray_dataset_schema
@@ -613,12 +996,17 @@ class VisibilityXds:
     """TODO: documentation"""
 
     # --- Required Coordinates ---
-    time: Coordof[TimeArray]
+    time: Coordof[TimeCoordArray]
     """
     The time coordinate is the mid-point of the nominal sampling interval, as
     specified in the ``ms_v4.time.attrs['integration_time']`` (ms v2 interval).
     """
-    baseline_id: Coordof[BaselineArray]
+    baseline_id: Optional[Coordof[BaselineArray]]  # IF. not present in main_sd_xds
+    """ Baseline ID """
+    antenna_name: Optional[
+        Coordof[AntennaNameArray]
+    ]  # Single-dish. not present in main_xds
+    """ antenna_name """
     frequency: Coordof[FrequencyArray]
     """Center frequencies for each channel."""
     polarization: Coordof[PolarizationArray]
@@ -626,27 +1014,50 @@ class VisibilityXds:
     Labels for polarization types, e.g. ``['XX','XY','YX','YY']``, ``['RR','RL','LR','LL']``.
     """
     uvw_label: Optional[Coordof[UvwLabelArray]]
-
-    # --- Required data variables ---
-    VISIBILITY: Dataof[VisibilityArray]
+    """ u,v,w """
+    baseline_antenna1_name: Optional[Coordof[BaselineAntennaNameArray]]  # IF
+    """Antenna name for 1st antenna in baseline. Maps to ``attrs['antenna_xds'].antenna_name``"""
+    baseline_antenna2_name: Optional[Coordof[BaselineAntennaNameArray]]  # IF
+    """Antenna name for 2nd antenna in baseline. Maps to ``attrs['antenna_xds'].antenna_name``"""
 
     # --- Required Attributes ---
+    partition_info: Attr[PartitionInfoDict]
     antenna_xds: Attr[AntennaXds]
 
     # --- Optional Coordinates ---
-    baseline_antenna1_id: Optional[Coordof[BaselineAntennaArray]] = None
-    """Antenna id for 1st antenna in baseline. Maps to ``attrs['antenna_xds'].antenna_id``"""
-    baseline_antenna2_id: Optional[Coordof[BaselineAntennaArray]] = None
-    """Antenna id for 2nd antenna in baseline. Maps to ``attrs['antenna_xds'].antenna_id``"""
-    scan_id: Optional[Coord[Time, int]] = None
+    scan_number: Optional[Coord[Time, Union[numpy.int64, numpy.int32]]] = None
     """Arbitary scan number to identify data taken in the same logical scan."""
 
+    # --- Required data variables ---
+
     # --- Optional data variables / arrays ---
+
+    # Either VISIBILITY (interferometry) or SPECTRUM (single-dish)
+    VISIBILITY: Optional[Dataof[VisibilityArray]] = None
     """Complex visibilities, either simulated or measured by interferometer."""
+    SPECTRUM: Optional[Dataof[SpectrumArray]] = None
+    """Single dish data, either simulated or measured by an antenna."""
+
+    VISIBILITY_CORRECTED: Optional[Dataof[VisibilityArray]] = None
+    VISIBILITY_MODEL: Optional[Dataof[VisibilityArray]] = None
+    SPECTRUM_CORRECTED: Optional[Dataof[SpectrumArray]] = None
+
     FLAG: Optional[Dataof[FlagArray]] = None
     WEIGHT: Optional[Dataof[WeightArray]] = None
     UVW: Optional[Dataof[UvwArray]] = None
-    EFFECTIVE_INTEGRATION_TIME: Optional[Dataof[TimeSamplingArray]] = None
+    EFFECTIVE_INTEGRATION_TIME: Optional[
+        Data[
+            Union[
+                tuple[Time, BaselineId],
+                tuple[Time, BaselineId, Frequency],
+                tuple[Time, BaselineId, Frequency, Polarization],
+                tuple[Time, AntennaName],  # SD
+                tuple[Time, AntennaName, Frequency],  # SD
+                tuple[Time, AntennaName, Frequency, Polarization],  # SD
+            ],
+            QuantityArray,
+        ]
+    ] = None
     """
     The integration time, including the effects of missing data, in contrast to
     ``integration_time`` attribute of the ``time`` coordinate,
@@ -665,11 +1076,12 @@ class VisibilityXds:
     """Includes the effects of missing data unlike ``frequency``."""
 
     # --- Optional Attributes ---
-    pointing_xds: Optional[Attr[PointingXds]] = None
-    source_xds: Optional[Attr[SourceXds]] = None
-    pased_array_xds: Optional[Attr[PhasedArrayXds]] = None
     observation_info: Optional[Attr[ObservationInfoDict]] = None
-    observation_info: Optional[Attr[ProcessorInfoDict]] = None
+    processor_info: Optional[Attr[ProcessorInfoDict]] = None
+    weather_xds: Optional[Attr[WeatherXds]] = None
+    pointing_xds: Optional[Attr[PointingXds]] = None
+    phased_array_xds: Optional[Attr[PhasedArrayXds]] = None
+    system_calibration_xds: Optional[Attr[SystemCalibrationXds]] = None
 
     version: Optional[Attr[str]] = None  # TODO:
     """Semantic version of xradio data format"""
@@ -685,3 +1097,6 @@ class VisibilityXds:
     """
 
     type: Attr[str] = "visibility"
+    """
+    Dataset type
+    """