xradio 0.0.36__tar.gz → 0.0.37__tar.gz

{xradio-0.0.36/src/xradio.egg-info → xradio-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xradio
-Version: 0.0.36
+Version: 0.0.37
 Summary:  Xarray Radio Astronomy Data IO
 Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>
 License: BSD 3-Clause License

{xradio-0.0.36 → xradio-0.0.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xradio"
-version = "0.0.36"
+version = "0.0.37"
 description = " Xarray Radio Astronomy Data IO"
 authors = [
     {name = "Jan-Willem Steeb", email="jsteeb@nrao.edu"},

{xradio-0.0.36 → xradio-0.0.37}/src/xradio/vis/_vis_utils/_ms/conversion.py

@@ -80,7 +80,7 @@ def check_chunksize(chunksize: dict, xds_type: str) -> None:
         allowed_dims = [
             "time",
             "baseline_id",
-            "antenna_id",
+            "antenna_name",
             "frequency",
             "polarization",
         ]
@@ -138,7 +138,7 @@ def mem_chunksize_to_dict_main(chunksize: float, xds: xr.Dataset) -> Dict[str, i
     It presently relies on the logic of mem_chunksize_to_dict_main_balanced() to find a
     balanced list of dimension sizes for the chunks
 
-    Assumes these relevant dims: (time, antenna_id/baseline_id, frequency,
+    Assumes these relevant dims: (time, antenna_name/baseline_id, frequency,
     polarization).
     """
 
@@ -149,11 +149,11 @@ def mem_chunksize_to_dict_main(chunksize: float, xds: xr.Dataset) -> Dict[str, i
             "Cannot calculate chunk sizes when memory bound ({chunksize}) does not even allow all polarizations in one chunk"
         )
 
-    baseline_or_antenna_id = find_baseline_or_antenna_var(xds)
-    total_size = calc_used_gb(xds.sizes, baseline_or_antenna_id, sizeof_vis)
+    baseline_or_antenna_name = find_baseline_or_antenna_var(xds)
+    total_size = calc_used_gb(xds.sizes, baseline_or_antenna_name, sizeof_vis)
 
     ratio = chunksize / total_size
-    chunked_dims = ["time", baseline_or_antenna_id, "frequency", "polarization"]
+    chunked_dims = ["time", baseline_or_antenna_name, "frequency", "polarization"]
     if ratio >= 1:
         result = {dim: xds.sizes[dim] for dim in chunked_dims}
         logger.debug(
@@ -162,14 +162,17 @@ def mem_chunksize_to_dict_main(chunksize: float, xds: xr.Dataset) -> Dict[str, i
     else:
         xds_dim_sizes = {k: xds.sizes[k] for k in chunked_dims}
         result = mem_chunksize_to_dict_main_balanced(
-            chunksize, xds_dim_sizes, baseline_or_antenna_id, sizeof_vis
+            chunksize, xds_dim_sizes, baseline_or_antenna_name, sizeof_vis
         )
 
     return result
 
 
 def mem_chunksize_to_dict_main_balanced(
-    chunksize: float, xds_dim_sizes: dict, baseline_or_antenna_id: str, sizeof_vis: int
+    chunksize: float,
+    xds_dim_sizes: dict,
+    baseline_or_antenna_name: str,
+    sizeof_vis: int,
 ) -> Dict[str, int]:
     """
     Assumes the ratio is <1 and all pols can fit in memory (from
@@ -236,7 +239,7 @@ def mem_chunksize_to_dict_main_balanced(
             dim_chunksizes[idx] += int_delta
         used = np.prod(dim_chunksizes) * sizeof_vis / GiBYTES_TO_BYTES
 
-    chunked_dim_names = ["time", baseline_or_antenna_id, "frequency", "polarization"]
+    chunked_dim_names = ["time", baseline_or_antenna_name, "frequency", "polarization"]
     dim_chunksizes_int = [int(v) for v in dim_chunksizes]
     result = dict(zip(chunked_dim_names, dim_chunksizes_int))
 
@@ -314,11 +317,11 @@ def mem_chunksize_to_dict_pointing(chunksize: float, xds: xr.Dataset) -> Dict[st
 
 def find_baseline_or_antenna_var(xds: xr.Dataset) -> str:
     if "baseline_id" in xds.coords:
-        baseline_or_antenna_id = "baseline_id"
-    elif "antenna_id" in xds.coords:
-        baseline_or_antenna_id = "antenna_id"
+        baseline_or_antenna_name = "baseline_id"
+    elif "antenna_name" in xds.coords:
+        baseline_or_antenna_name = "antenna_name"
 
-    return baseline_or_antenna_id
+    return baseline_or_antenna_name
 
 
 def itemsize_vis_spec(xds: xr.Dataset) -> int:
@@ -352,11 +355,11 @@ def itemsize_pointing_spec(xds: xr.Dataset) -> int:
 
 
 def calc_used_gb(
-    chunksizes: dict, baseline_or_antenna_id: str, sizeof_vis: int
+    chunksizes: dict, baseline_or_antenna_name: str, sizeof_vis: int
 ) -> float:
     return (
         chunksizes["time"]
-        * chunksizes[baseline_or_antenna_id]
+        * chunksizes[baseline_or_antenna_name]
         * chunksizes["frequency"]
         * chunksizes["polarization"]
         * sizeof_vis
@@ -734,7 +737,6 @@ def convert_and_write_partition(
     """
 
     taql_where = create_taql_query(partition_info)
-    # print("taql_where", taql_where)
     ddi = partition_info["DATA_DESC_ID"][0]
     obs_mode = str(partition_info["OBS_MODE"][0])
 
@@ -877,7 +879,8 @@ def convert_and_write_partition(
             )
 
             # Change antenna_ids to antenna_names
-            xds = antenna_ids_to_names(xds, ant_xds)
+            xds = antenna_ids_to_names(xds, ant_xds, is_single_dish)
+            ant_xds_name_ids = ant_xds["antenna_name"].set_xindex("antenna_id")
             ant_xds = ant_xds.drop_vars(
                 "antenna_id"
             )  # No longer needed after converting to name.
@@ -897,7 +900,7 @@ def convert_and_write_partition(
                 else:
                     pointing_interp_time = None
                 pointing_xds = create_pointing_xds(
-                    in_file, time_min_max, pointing_interp_time
+                    in_file, ant_xds_name_ids, time_min_max, pointing_interp_time
                 )
                 pointing_chunksize = parse_chunksize(
                     pointing_chunksize, "pointing", pointing_xds
@@ -953,7 +956,6 @@ def convert_and_write_partition(
 
             # Fix UVW frame
             # From CASA fixvis docs: clean and the im tool ignore the reference frame claimed by the UVW column (it is often mislabelled as ITRF when it is really FK5 (J2000)) and instead assume the (u, v, w)s are in the same frame as the phase tracking center. calcuvw does not yet force the UVW column and field centers to use the same reference frame! Blank = use the phase tracking frame of vis.
-            # print('##################',field_and_source_xds)
             if is_single_dish:
                 xds.UVW.attrs["frame"] = field_and_source_xds[
                     "FIELD_REFERENCE_CENTER"
@@ -1037,17 +1039,19 @@ def convert_and_write_partition(
     # logger.info("Saved ms_v4 " + file_name + " in " + str(time.time() - start_with) + "s")
 
 
-def antenna_ids_to_names(xds, ant_xds):
+def antenna_ids_to_names(
+    xds: xr.Dataset, ant_xds: xr.Dataset, is_single_dish: bool
+) -> xr.Dataset:
     ant_xds = ant_xds.set_xindex(
         "antenna_id"
     )  # Allows for non-dimension coordinate selection.
 
-    if "baseline_antenna1_id" in xds:  # Interferometer
-        xds["baseline_antenna1_id"] = ant_xds["antenna_name"].sel(
-            antenna_id=xds["baseline_antenna1_id"]
+    if not is_single_dish:  # Interferometer
+        xds["baseline_antenna1_id"].data = ant_xds["antenna_name"].sel(
+            antenna_id=xds["baseline_antenna1_id"].data
         )
-        xds["baseline_antenna2_id"] = ant_xds["antenna_name"].sel(
-            antenna_id=xds["baseline_antenna2_id"]
+        xds["baseline_antenna2_id"].data = ant_xds["antenna_name"].sel(
+            antenna_id=xds["baseline_antenna2_id"].data
         )
         xds = xds.rename(
             {
@@ -1055,9 +1059,23 @@ def antenna_ids_to_names(xds, ant_xds):
                 "baseline_antenna2_id": "baseline_antenna2_name",
             }
         )
-    else:  # Single Dish
-        xds["antenna_id"] = ant_xds["antenna_name"].sel(antenna_id=xds["antenna_id"])
-        xds = xds.rename({"antenna_id": "antenna_name"})
+    else:
+        xds["baseline_id"] = ant_xds["antenna_name"].sel(antenna_id=xds["baseline_id"])
+        unwanted_coords_from_ant_xds = [
+            "antenna_id",
+            "antenna_name",
+            "mount",
+            "station",
+        ]
+        for unwanted_coord in unwanted_coords_from_ant_xds:
+            xds = xds.drop_vars(unwanted_coord)
+        xds = xds.rename({"baseline_id": "antenna_name"})
+
+        # drop more vars that seem unwanted in main_sd_xds, but there shouuld be a better way
+        # of not creating them in the first place
+        unwanted_coords_sd = ["baseline_antenna1_id", "baseline_antenna2_id"]
+        for unwanted_coord in unwanted_coords_sd:
+            xds = xds.drop_vars(unwanted_coord)
 
     return xds
 

{xradio-0.0.36 → xradio-0.0.37}/src/xradio/vis/_vis_utils/_ms/create_antenna_xds.py

@@ -127,7 +127,6 @@ def extract_antenna_info(
     )  # Make sure the antenna_id order is correct.
 
     # ['OFFSET', 'POSITION', 'DISH_DIAMETER', 'FLAG_ROW', 'MOUNT', 'NAME', 'STATION']
-    ant_xds = xr.Dataset()
     ant_xds = ant_xds.assign_coords({"cartesian_pos_label": ["x", "y", "z"]})
 
     ant_xds = convert_generic_xds_to_xradio_schema(
@@ -254,9 +253,13 @@ def extract_feed_info(
 
     # print('ant_xds["ANTENNA_FEED_OFFSET"]',ant_xds["ANTENNA_FEED_OFFSET"].data)
     # print('generic_feed_xds["POSITION"].data',generic_feed_xds["POSITION"].data)
+    feed_offset_attrs = ant_xds["ANTENNA_FEED_OFFSET"].attrs
     ant_xds["ANTENNA_FEED_OFFSET"] = (
         ant_xds["ANTENNA_FEED_OFFSET"] + generic_feed_xds["POSITION"].data
     )
+    # recover attrs after arithmetic operation
+    ant_xds["ANTENNA_FEED_OFFSET"].attrs.update(feed_offset_attrs)
+
     coords = {}
     # coords["receptor_label"] = "pol_" + np.arange(ant_xds.sizes["receptor_label"]).astype(str) #Works on laptop but fails in github test runner.
     coords["receptor_label"] = np.array(

{xradio-0.0.36 → xradio-0.0.37}/src/xradio/vis/_vis_utils/_ms/create_field_and_source_xds.py

@@ -30,7 +30,7 @@ def create_field_and_source_xds(
     is_single_dish: bool,
     time_min_max: Tuple[np.float64, np.float64],
     ephemeris_interp_time: Union[xr.DataArray, None] = None,
-):
+) -> tuple[xr.Dataset, int]:
     """
     Create a field and source xarray dataset (xds) from the given input file, field ID, and spectral window ID.
     Data is extracted from the FIELD and SOURCE tables and if there is ephemeris data, it is also extracted.
@@ -57,11 +57,13 @@ def create_field_and_source_xds(
     -------
     field_and_source_xds : xr.Dataset
         The xarray dataset containing the field and source information.
+    num_lines : int
+        Sum of num_lines for all unique sources.
     """
 
     start_time = time.time()
 
-    field_and_source_xds = xr.Dataset()
+    field_and_source_xds = xr.Dataset(attrs={"type": "field_and_source"})
 
     field_and_source_xds, ephemeris_path, ephemeris_table_name, source_id = (
         extract_field_info_and_check_ephemeris(
@@ -433,7 +435,9 @@ def extract_ephemeris_info(
     return xds
 
 
-def extract_source_info(xds, path, source_id, spectral_window_id):
+def extract_source_info(
+    xds: xr.Dataset, path: str, source_id: int, spectral_window_id: int
+) -> tuple[xr.Dataset, int]:
     """
     Extracts source information from the given path and adds it to the xarray dataset.
 

{xradio-0.0.36 → xradio-0.0.37}/src/xradio/vis/_vis_utils/_ms/msv4_sub_xdss.py

@@ -121,11 +121,13 @@ def create_weather_xds(in_file: str):
     # ['ANTENNA_ID', 'TIME', 'INTERVAL', 'H2O', 'IONOS_ELECTRON',
     #  'PRESSURE', 'REL_HUMIDITY', 'TEMPERATURE', 'DEW_POINT',
     #  'WIND_DIRECTION', 'WIND_SPEED']
-    weather_xds = xr.Dataset()
-
+    weather_xds = xr.Dataset(attrs={"type": "weather"})
+    time_attrs = column_description_casacore_to_msv4_measure(
+        weather_column_description["TIME"]
+    )
     coords = {
         "station_id": generic_weather_xds["STATION_ID"].data,
-        "time": generic_weather_xds["TIME"].data,
+        "time": ("time", generic_weather_xds["TIME"].data, time_attrs),
     }
     for key in generic_weather_xds:
         msv4_measure = column_description_casacore_to_msv4_measure(
@@ -181,6 +183,7 @@ def create_weather_xds(in_file: str):
 
 def create_pointing_xds(
     in_file: str,
+    ant_xds_name_ids: xr.DataArray,
     time_min_max: Union[Tuple[np.float64, np.float64], None],
     interp_time: Union[xr.DataArray, None] = None,
 ) -> xr.Dataset:
@@ -194,6 +197,8 @@ def create_pointing_xds(
     ----------
     in_file : str
         Input MS name.
+    ant_xds_name_ids : xr.Dataset
+        antenna_name data array from antenna_xds, with name/id information
     time_min_max : tuple
         min / max times values to constrain loading (from the TIME column)
     interp_time : Union[xr.DataArray, None] (Default value = None)
@@ -220,19 +225,19 @@ def create_pointing_xds(
         # "on_source": "ON_SOURCE",   # removed
         "OVER_THE_TOP": "OVER_THE_TOP",
     }
-    time_ant_dims = ["time", "antenna_id"]
+    time_ant_dims = ["time", "antenna_name"]
     time_ant_dir_dims = time_ant_dims + ["sky_dir_label"]
     data_variable_dims = {
-        # "name": ["time", "antenna_id"],   # removed
-        # "time_origin": ["time", "antenna_id"],   # removed?
+        # "name": ["time", "antenna_name"],   # removed
+        # "time_origin": ["time", "antenna_name"],   # removed?
         "DIRECTION": time_ant_dir_dims,
         "ENCODER": time_ant_dir_dims,
         "TARGET": time_ant_dir_dims,
         "POINTING_OFFSET": time_ant_dir_dims,
         "SOURCE_OFFSET": time_ant_dir_dims,
-        # "pointing_model_id": ["time", "antenna_id"],   # removed
-        # "tracking": ["time", "antenna_id"],   # => attribute
-        # "on_source": ["time", "antenna_id"],  # removed
+        # "pointing_model_id": ["time", "antenna_name"],   # removed
+        # "tracking": ["time", "antenna_name"],   # => attribute
+        # "on_source": ["time", "antenna_name"],  # removed
         "OVER_THE_TOP": time_ant_dims,
     }
     # Unused here
@@ -263,7 +268,7 @@ def create_pointing_xds(
         "ctds_attrs"
     ]["column_descriptions"]
 
-    pointing_xds = xr.Dataset()
+    pointing_xds = xr.Dataset(attrs={"type": "pointing"})
     for key in generic_pointing_xds:
         if key in to_new_data_variable_names:
             data_var_name = to_new_data_variable_names[key]
@@ -312,7 +317,9 @@ def create_pointing_xds(
 
     coords = {
         "time": generic_pointing_xds["TIME"].values,
-        "antenna_id": np.arange(generic_pointing_xds.sizes["ANTENNA_ID"]),
+        "antenna_name": ant_xds_name_ids.sel(
+            antenna_id=generic_pointing_xds["ANTENNA_ID"]
+        ).data,
         "sky_dir_label": ["ra", "dec"],
     }
     pointing_xds = pointing_xds.assign_coords(coords)

{xradio-0.0.36 → xradio-0.0.37}/src/xradio/vis/read_processing_set.py

@@ -38,7 +38,7 @@ def read_processing_set(
         data_groups = xds.attrs["data_groups"]
 
         if (obs_modes is None) or (
-            xds.attrs["partition_info"]["obs_mode"] in obs_modes
+            bool(set(xds.attrs["partition_info"]["obs_mode"]).intersection(obs_modes))
         ):
             sub_xds_dict, field_and_source_xds_dict = _read_sub_xds(
                 ms_store, file_system=file_system, data_groups=data_groups

{xradio-0.0.36 → xradio-0.0.37}/src/xradio/vis/schema.py

@@ -12,14 +12,16 @@ import numpy
 # Dimensions
 Time = Literal["time"]
 """ Observation time dimension """
-AntennaId = Literal["antenna_id"]
-""" Antenna ID dimension """
+AntennaName = Literal["antenna_name"]
+""" Antenna name dimension """
 StationId = Literal["station_id"]
 """ Station ID dimension """
 ReceptorId = Literal["receptor_id"]
 """ Receptor ID dimension """
-ReceptorName = Literal["receptor_label"]
-""" Receptor name 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"]
@@ -40,8 +42,12 @@ 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 """
+PolyTerm = Literal["poly_term"]
+""" Polynomial term used in VLBI GAIN_CURVE """
 LineLabel = Literal["line_label"]
 """ Line labels (for line names and variables). """
 
@@ -276,6 +282,11 @@ class FieldSourceXds:
     """
     is_ephemeris: Attr[bool] = False
 
+    type: Attr[str] = "field_and_source"
+    """
+    Type of dataset.
+    """
+
     # --- Optional coordinates ---
     sky_dir_label: Optional[Coord[SkyDirLabel, str]] = ("ra", "dec")
     """ Coordinate labels of sky directions (typically shape 2 and 'ra', 'dec') """
@@ -319,6 +330,22 @@ 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
@@ -366,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
@@ -485,17 +521,15 @@ class SpectrumArray:
     """Definition of xr.DataArray for SPECTRUM data (single dish)"""
 
     data: Data[
-        tuple[Time, BaselineId, Frequency, Polarization],
+        tuple[Time, AntennaName, Frequency, Polarization],
         Union[numpy.float64, numpy.float32, numpy.float16],
     ]
-    time: Coord[tuple[()], TimeCoordArray]
 
-    # in the spreadsheet this is antenna_id:
-    # antenna_id: Coord[AntennaId, Union[int, numpy.int32]]
-    baseline_id: Coord[tuple[()], BaselineArray]
+    time: Coordof[TimeCoordArray]
+    antenna_name: Coordof[AntennaNameArray]
+    frequency: Coordof[FrequencyArray]
+    polarization: Coordof[PolarizationArray]
 
-    polarization: Coord[tuple[()], PolarizationArray]
-    frequency: Coord[tuple[()], FrequencyArray]
     field_and_source_xds: Attr[FieldSourceXds]
     long_name: Optional[Attr[str]] = "Spectrum values"
     """ Long-form name to use for axis. Should be ``"Spectrum values"``"""
@@ -515,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[TimeCoordArray]
-    baseline_id: Coordof[BaselineArray]
+    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"
@@ -540,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[TimeCoordArray]
-    baseline_id: Coordof[BaselineArray]
+    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"
@@ -586,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,
@@ -595,7 +636,8 @@ class UvwArray:
     ]
     """Baseline coordinates from ``baseline_antenna2_id`` to ``baseline_antenna1_id``"""
     time: Coordof[TimeCoordArray]
-    baseline_id: Coordof[BaselineArray]
+    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")
@@ -613,12 +655,14 @@ class TimeSamplingArray:
             tuple[Time, BaselineId, Frequency, Polarization],
             tuple[Time, BaselineId, Frequency],
             tuple[Time, BaselineId],
+            tuple[Time, AntennaName],  # SD
         ],
         float,
     ]
 
     time: Coordof[TimeCoordArray]
-    baseline_id: Coordof[BaselineArray]
+    baseline_id: Optional[Coordof[BaselineArray]]  # Only IF
+    antenna_name: Optional[Coordof[AntennaNameArray]]  # Only SD
     frequency: Optional[Coordof[FrequencyArray]] = None
     polarization: Optional[Coordof[PolarizationArray]] = None
 
@@ -667,88 +711,147 @@ class FreqSamplingArray:
 # Data Sets
 
 
-@xarray_dataset_schema
-class AntennaXdsEmptyWhileRevampedTODO:
-    """Minimal placeholder so that it shows in the main xds
-    docs. TODO: update AntennaXds once review moves on
-    """
-
-    antenna_name: Coord[Literal["antenna_name"], str]
-    receptor_label: Optional[Coord[ReceptorName, str]]
-    cartesian_pos_label: Coord[CartesianPosLabel, str]
-    sky_dir_label: Optional[Coord[SkyDirLabel, str]]
-    gain_curve_time: Optional[Coord[Literal["gain_curve_time"], numpy.float64]]
-    poly_term: Optional[Coord[Literal["poly_term"], numpy.int64]]
-    phase_cal_time: Optional[Coord[Literal["phase_cal_time"], numpy.float64]]
-    tone_label: Optional[Coord[Literal["tone_label"], numpy.int64]]
-
-
 @xarray_dataset_schema
 class AntennaXds:
-    # --- Coordinates ---
-    antenna_id: Coord[AntennaId, Union[int, numpy.int32]]
-    """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"""
-    cartesian_pos_label: Coord[CartesianPosLabel, str]
-    """Coordinate dimension of earth location data (typically shape 3 and 'x', 'y', 'z')"""
+    # 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]]
-    """Coordinate dimension of sky coordinate data (possibly shape 2 and 'RA', "Dec")"""
-
-    # --- Data variables ---
-    ANTENNA_POSITION: Data[AntennaId, EarthLocationArray]
+    """ 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.
     """
-    ANTENNA_FEED_OFFSET: Data[tuple[AntennaId, CartesianPosLabel], 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``).
     """
-    ANTENNA_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``
@@ -757,12 +860,42 @@ class AntennaXds:
 
 @xarray_dataset_schema
 class WeatherXds:
-    """TODO: largely incomplete"""
+    """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 """
-    time: Coord[Time, numpy.float64]
-    """ Mid-point of the time interval """
+    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
@@ -772,9 +905,9 @@ class PointingXds:
     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: Coord[AntennaId, Union[int, numpy.int32]]
+    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_dir_label: Coord[SkyDirLabel, str]
     """
@@ -782,18 +915,18 @@ class PointingXds:
     """
 
     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
@@ -810,15 +943,53 @@ class PhasedArrayXds:
 
 @xarray_dataset_schema
 class SystemCalibrationXds:
-    """TODO: largely incomplete"""
+    """System calibration. Contains time- and frequency- variable
+    calibration measurements for each antenna, as indexed on receptor"""
 
-    antenna_id: Coord[AntennaId, Union[int, numpy.int32]]
+    # Coordinates
+    antenna_name: Coordof[AntennaNameArray]
     """ Antenna identifier """
-    time: Coord[Time, numpy.float64]
+    time: Coordof[TimeCoordArray]
     """ Midpoint of time for which this set of parameters is accurate """
-    receptor_id: Coord[ReceptorId, numpy.float64]
+    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
 class VisibilityXds:
@@ -830,7 +1001,12 @@ class VisibilityXds:
     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]
@@ -838,18 +1014,18 @@ class VisibilityXds:
     Labels for polarization types, e.g. ``['XX','XY','YX','YY']``, ``['RR','RL','LR','LL']``.
     """
     uvw_label: Optional[Coordof[UvwLabelArray]]
+    """ 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 ---
-    # TODO: on hold while antenna_xds is reviewed/ updated
-    # antenna_xds: Attr[AntennaXds]
-    # antenna_xds: Attr[AntennaXdsEmptyWhileRevampedTODO]
+    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 ---
@@ -875,6 +1051,9 @@ class VisibilityXds:
                 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,
         ]

{xradio-0.0.36 → xradio-0.0.37/src/xradio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xradio
-Version: 0.0.36
+Version: 0.0.37
 Summary:  Xarray Radio Astronomy Data IO
 Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>
 License: BSD 3-Clause License