xradio 0.0.50__tar.gz → 0.0.51__tar.gz

{xradio-0.0.50/src/xradio.egg-info → xradio-0.0.51}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: xradio
-Version: 0.0.50
+Version: 0.0.51
 Summary:  Xarray Radio Astronomy Data IO
-Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>
+Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>, Federico Montesino Pouzols <pouzols@eso.edu>, Dave Mehringer <dmehring@nrao.edu>, Peter Wortmann <peter.wortmann@skao.int>
 License: BSD 3-Clause License
         
         All works in this repository are copyrighted 2024.  
@@ -43,7 +43,7 @@ License-File: LICENSE.txt
 Requires-Dist: astropy
 Requires-Dist: dask
 Requires-Dist: distributed
-Requires-Dist: toolviper
+Requires-Dist: toolviper>=0.0.11
 Requires-Dist: numba>=0.57.0
 Requires-Dist: numpy
 Requires-Dist: pytest
@@ -79,7 +79,13 @@ Dynamic: license-file
 # xradio
 Xarray Radio Astronomy Data IO is still in development.
 
-[![Python 3.9 3.10 3.11 3.12](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%203.12-blue)](https://www.python.org/downloads/release/python-380/)
+[![Python 3.11 3.12 3.13](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/downloads/release/python-3130/)
+![Linux Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-linux.yml/badge.svg?branch=main)
+![macOS Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml/badge.svg?branch=main)
+![ipynb Tests](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml/badge.svg?branch=main)
+[![Coverage](https://codecov.io/gh/casangi/xradio/branch/main/graph/badge.svg)](https://codecov.io/gh/casangi/xradio/branch/main/xradio)
+[![Documentation Status](https://readthedocs.org/projects/xradio/badge/?version=latest)](https://xradio.readthedocs.io)
+[![Version Status](https://img.shields.io/pypi/v/xradio.svg)](https://pypi.python.org/pypi/xradio/)
 
 # Installing
 It is recommended to use the conda environment manager from [miniforge](https://github.com/conda-forge/miniforge) to create a clean, self-contained runtime where XRADIO and all its dependencies can be installed:

xradio-0.0.51/README.md

@@ -0,0 +1,27 @@
+# xradio
+Xarray Radio Astronomy Data IO is still in development.
+
+[![Python 3.11 3.12 3.13](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/downloads/release/python-3130/)
+![Linux Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-linux.yml/badge.svg?branch=main)
+![macOS Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml/badge.svg?branch=main)
+![ipynb Tests](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml/badge.svg?branch=main)
+[![Coverage](https://codecov.io/gh/casangi/xradio/branch/main/graph/badge.svg)](https://codecov.io/gh/casangi/xradio/branch/main/xradio)
+[![Documentation Status](https://readthedocs.org/projects/xradio/badge/?version=latest)](https://xradio.readthedocs.io)
+[![Version Status](https://img.shields.io/pypi/v/xradio.svg)](https://pypi.python.org/pypi/xradio/)
+
+# Installing
+It is recommended to use the conda environment manager from [miniforge](https://github.com/conda-forge/miniforge) to create a clean, self-contained runtime where XRADIO and all its dependencies can be installed:
+```sh
+conda create --name xradio python=3.12 --no-default-packages
+conda activate xradio
+```
+> 📝 On macOS it is required to pre-install `python-casacore` using `conda install -c conda-forge python-casacore`.
+
+XRADIO can now be installed using:
+```sh
+pip install xradio
+```
+This will also install the minimal dependencies for XRADIO. To install the minimal dependencies and the interactive components (JupyterLab) use:
+```sh
+pip install "xradio[interactive]"
+```

{xradio-0.0.50 → xradio-0.0.51}/pyproject.toml

@@ -1,9 +1,12 @@
 [project]
 name = "xradio"
-version = "0.0.50"
+version = "0.0.51"
 description = " Xarray Radio Astronomy Data IO"
 authors = [
     {name = "Jan-Willem Steeb", email="jsteeb@nrao.edu"},
+    {name = "Federico Montesino Pouzols", email="pouzols@eso.edu"},
+    {name = "Dave Mehringer", email="dmehring@nrao.edu"},
+    {name = "Peter Wortmann", email="peter.wortmann@skao.int"}
 ]
 license = {file = "LICENSE.txt"}
 readme = "README.md"
@@ -13,7 +16,7 @@ dependencies = [
     'astropy',
     'dask',
     'distributed',
-    'toolviper',
+    'toolviper>=0.0.11',
     'numba>=0.57.0',
     'numpy',
     'pytest',

{xradio-0.0.50 → xradio-0.0.51}/src/xradio/_utils/schema.py

@@ -190,14 +190,14 @@ casacore_to_msv4_measure_type = {
             "LSRK": "lsrk",
             "LSRD": "lsrd",
             "BARY": "BARY",
-            "GEO": "GEO",
+            "GEO": "gcrs",
             "TOPO": "TOPO",
         },  # The frames/observer we are not sure if/how to translate to astropy are uppercase
     },
     "position": {
         "type": "location",
         "Ref": "frame",
-        "Ref_map": {"ITRF": "GRS80"},
+        "Ref_map": {"ITRF": "ITRS"},
     },
     "uvw": {
         "type": "uvw",

{xradio-0.0.50 → xradio-0.0.51}/src/xradio/measurement_set/_utils/_msv2/conversion.py

@@ -1214,13 +1214,13 @@ def convert_and_write_partition(
         )
         # but before, keep the name-id arrays, we need them for the pointing and weather xds
         ant_xds_name_ids = ant_xds["antenna_name"].set_xindex("antenna_id")
-        ant_xds_station_name_ids = ant_xds["station"].set_xindex("antenna_id")
+        ant_position_xds_with_ids = ant_xds["ANTENNA_POSITION"].set_xindex("antenna_id")
         # No longer needed after converting to name.
         ant_xds = ant_xds.drop_vars("antenna_id")
 
         # Create weather_xds
         start = time.time()
-        weather_xds = create_weather_xds(in_file, ant_xds_station_name_ids)
+        weather_xds = create_weather_xds(in_file, ant_position_xds_with_ids)
         logger.debug("Time weather " + str(time.time() - start))
 
         # Create pointing_xds
@@ -1425,7 +1425,7 @@ def antenna_ids_to_names(
             "antenna_id",
             "antenna_name",
             "mount",
-            "station",
+            "station_name",
         ]
         for unwanted_coord in unwanted_coords_from_ant_xds:
             xds = xds.drop_vars(unwanted_coord)

{xradio-0.0.50 → xradio-0.0.51}/src/xradio/measurement_set/_utils/_msv2/create_antenna_xds.py

@@ -109,7 +109,7 @@ def extract_antenna_info(
 
     to_new_coords = {
         "NAME": ["antenna_name", ["antenna_name"]],
-        "STATION": ["station", ["antenna_name"]],
+        "STATION": ["station_name", ["antenna_name"]],
         "MOUNT": ["mount", ["antenna_name"]],
         # "PHASED_ARRAY_ID": ["phased_array_id", ["antenna_name"]],
         "antenna_id": ["antenna_id", ["antenna_name"]],
@@ -158,9 +158,9 @@ def extract_antenna_info(
 
         # None of the native numpy functions work on the github test runner.
         antenna_name = ant_xds["antenna_name"].values
-        station = ant_xds["station"].values
+        station_name = ant_xds["station_name"].values
         antenna_name = np.array(
-            list(map(lambda x, y: x + "_" + y, antenna_name, station))
+            list(map(lambda x, y: x + "_" + y, antenna_name, station_name))
         )
 
         ant_xds["antenna_name"] = xr.DataArray(antenna_name, dims=["antenna_name"])
@@ -376,7 +376,7 @@ def create_gain_curve_xds(
 
     ant_borrowed_coords = {
         "antenna_name": ant_xds.coords["antenna_name"],
-        "station": ant_xds.coords["station"],
+        "station_name": ant_xds.coords["station_name"],
         "mount": ant_xds.coords["mount"],
         "telescope_name": ant_xds.coords["telescope_name"],
         "receptor_label": ant_xds.coords["receptor_label"],
@@ -486,7 +486,7 @@ def create_phase_calibration_xds(
 
     ant_borrowed_coords = {
         "antenna_name": ant_xds.coords["antenna_name"],
-        "station": ant_xds.coords["station"],
+        "station_name": ant_xds.coords["station_name"],
         "mount": ant_xds.coords["mount"],
         "telescope_name": ant_xds.coords["telescope_name"],
         "receptor_label": ant_xds.coords["receptor_label"],

{xradio-0.0.50 → xradio-0.0.51}/src/xradio/measurement_set/_utils/_msv2/create_field_and_source_xds.py

@@ -226,9 +226,10 @@ def extract_ephemeris_info(
             "type": "location",
             "units": ["deg", "deg", "m"],
             "data": observer_position,
-            "frame": "WGS84",
+            "frame": "ITRS",
             "origin_object_name": "Earth",
             "coordinate_system": ephemeris_meta["obsloc"].lower(),
+            "ellipsoid": "WGS84",
         }
     )  # I think the units are ['deg','deg','m'] and 'WGS84'.
 

{xradio-0.0.50 → xradio-0.0.51}/src/xradio/measurement_set/_utils/_msv2/msv4_sub_xdss.py

@@ -172,7 +172,130 @@ def make_taql_where_weather(
     return taql_where
 
 
-def create_weather_xds(in_file: str, ant_xds_station_name_ids: xr.DataArray):
+def prepare_generic_weather_xds_and_station_name(
+    generic_weather_xds: xr.Dataset,
+    in_file: str,
+    ant_position_with_ids: xr.DataArray,
+    has_asdm_station_position: bool,
+) -> tuple[xr.Dataset, np.ndarray]:
+    """
+    A generic_weather_xds loaded with load_generic_table() might still need to be reloaded
+    with an additional WHERE condition to constrain the indices of antennas. But this depends on whether
+    ASDM/importasdm extension columns are present or not.
+
+    This also prepares the station_name values:
+    - if has_asdm_station_ids:
+       - tries to find from ASDM_STATION the station names,
+       - otherwise, takes ids (antenna_ids in generic_weather were actually the ASDM_STATION_IDs
+    - else: get the values from antenna_xds (the stations present)
+
+
+    Parameters
+    ----------
+    generic_weather_xds : xr.Dataset
+        generic dataset read from an MSv2 WEATHER subtable
+    in_file : str
+        Input MS name.
+    ant_position_with_ids : xr.DataArray
+        antenna_position data var from the antenna_xds (expected to still include the initial ANTENNA_ID
+        coordinate as well as other coordinates from the antenna_xds)
+    has_asdm_station_position : bool
+        wHether this generic weatehr_xds should be treated as including the nonstandard extensions
+        NS_WX_STATION_ID and NS_WX_STATION_POSITION as created by CASA/importasdm (ALMA and VLA).
+
+    Returns
+    -------
+    (generic_weather_xds, station_name): tuple[[xarray.Dataset, numpy.ndarray]
+        Weather Xarray Dataset prepared for generic conversion to MSv4, values for the station_name coordinate
+    """
+
+    if has_asdm_station_position:
+        asdm_station_path = os.path.join(in_file, "ASDM_STATION")
+        if table_exists(asdm_station_path):
+            asdm_station_xds = load_generic_table(in_file, "ASDM_STATION")
+            station_name = asdm_station_xds.name.values[
+                generic_weather_xds["ANTENNA_ID"].values
+            ]
+        else:
+            # if no info from ASDM_STATION, use the indices from antenna_id which was actually the NS_WX_STATION_ID
+            len_antenna_id = generic_weather_xds.sizes["ANTENNA_ID"]
+            station_name = list(
+                map(
+                    lambda x, y: x + "_" + y,
+                    ["Station"] * len_antenna_id,
+                    generic_weather_xds["ANTENNA_ID"].values.astype(str),
+                )
+            )
+
+    else:
+        taql_where = make_taql_where_weather(in_file, ant_position_with_ids)
+        generic_weather_xds = load_generic_table(
+            in_file,
+            "WEATHER",
+            rename_ids=subt_rename_ids["WEATHER"],
+            taql_where=taql_where,
+        )
+
+        if not generic_weather_xds.data_vars:
+            # for example when the weather subtable only has info for antennas/stations
+            # not present in the MSv4 (no overlap between antennas loaded in ant_xds and weather)
+            return None, None
+
+        stations_present = ant_position_with_ids.sel(
+            antenna_id=generic_weather_xds["ANTENNA_ID"]
+        ).station_name
+        station_name = stations_present.values
+
+    return generic_weather_xds, station_name
+
+
+def finalize_station_position(
+    weather_xds: xr.Dataset, ant_position_with_ids, has_asdm_station_position: bool
+) -> xr.Dataset:
+    """
+    For a STATION_POSITION data var being added to a weather_xds, make sure coordinates and dimensions
+    are conforming to the schema.
+
+    Parameters
+    ----------
+    weather_xds : xr.Dataset
+        weather_xds where we still need to ensure the right coordinates and attributes
+    ant_position_with_ids : xr.DataArray
+        antenna_position data var from the antenna_xds (expected to still include the initial ANTENNA_ID
+        coordinate as well as other coordinates from the antenna_xds)
+    has_asdm_station_position : bool
+        Whether this generic weatehr_xds should be treated as including the nonstandard extensions
+        NS_WX_STATION_ID and NS_WX_STATION_POSITION as created by CASA/importasdm (ALMA and VLA).
+
+    Returns
+    -------
+    weather_xds: xarray.Dataset
+        Weather Xarray Dataset with all coordinates and attributes in STATION_POSITION
+    """
+    if has_asdm_station_position:
+        # STATION_POSITION has been created but needs prooper dimensions and attrs
+        # Drop the time dim
+        weather_xds["STATION_POSITION"] = weather_xds["STATION_POSITION"].sel(
+            time_weather=0, drop=True, method="nearest"
+        )
+        # borrow location frame attributes from antenna position
+        weather_xds["STATION_POSITION"].attrs = ant_position_with_ids.attrs
+    else:
+        # borrow from ant_posision_with_ids but without carrying over other coords
+        weather_xds = weather_xds.assign(
+            {
+                "STATION_POSITION": (
+                    ["station_name", "cartesian_pos_label"],
+                    ant_position_with_ids.values,
+                    ant_position_with_ids.attrs,
+                )
+            }
+        )
+
+    return weather_xds
+
+
+def create_weather_xds(in_file: str, ant_position_with_ids: xr.DataArray):
     """
     Creates a Weather Xarray Dataset from a MS v2 WEATHER table.
 
@@ -180,8 +303,9 @@ def create_weather_xds(in_file: str, ant_xds_station_name_ids: xr.DataArray):
     ----------
     in_file : str
         Input MS name.
-    ant_xds_station_name_ids : xr.DataArray
-        station name data array from antenna_xds, with name/id information
+    ant_position_with_ids : xr.DataArray
+        antenna_position data var from the antenna_xds (expected to still including the initial ANTENNA_ID coordinate
+        as wellas other coordinates from the antenna_xds)
 
     Returns
     -------
@@ -190,32 +314,32 @@ def create_weather_xds(in_file: str, ant_xds_station_name_ids: xr.DataArray):
     """
 
     try:
-        taql_where = make_taql_where_weather(in_file, ant_xds_station_name_ids)
         generic_weather_xds = load_generic_table(
             in_file,
             "WEATHER",
             rename_ids=subt_rename_ids["WEATHER"],
-            taql_where=taql_where,
         )
     except ValueError as _exc:
         return None
 
-    if not generic_weather_xds.data_vars:
-        # for example when the weather subtable only has info for antennas/stations
-        # not present in the MSv4 (no overlap between antennas loaded in ant_xds and weather)
+    has_asdm_station_position = (
+        "NS_WX_STATION_POSITION" in generic_weather_xds.data_vars
+    )
+    generic_weather_xds, station_name = prepare_generic_weather_xds_and_station_name(
+        generic_weather_xds, in_file, ant_position_with_ids, has_asdm_station_position
+    )
+    if not generic_weather_xds:
         return None
 
     weather_xds = xr.Dataset(attrs={"type": "weather"})
-    stations_present = ant_xds_station_name_ids.sel(
-        antenna_id=generic_weather_xds["ANTENNA_ID"]
-    )
     coords = {
-        "station_name": stations_present.data,
-        "antenna_name": stations_present.coords["antenna_name"].data,
+        "station_name": station_name,
+        "cartesian_pos_label": ["x", "y", "z"],
     }
     weather_xds = weather_xds.assign_coords(coords)
 
     dims_station_time = ["station_name", "time_weather"]
+    dims_station_time_position = dims_station_time + ["cartesian_pos_label"]
     to_new_data_variables = {
         "H20": ["H2O", dims_station_time],
         "IONOS_ELECTRON": ["IONOS_ELECTRON", dims_station_time],
@@ -226,6 +350,15 @@ def create_weather_xds(in_file: str, ant_xds_station_name_ids: xr.DataArray):
         "WIND_DIRECTION": ["WIND_DIRECTION", dims_station_time],
         "WIND_SPEED": ["WIND_SPEED", dims_station_time],
     }
+    if has_asdm_station_position:
+        to_new_data_variables.update(
+            {
+                "NS_WX_STATION_POSITION": [
+                    "STATION_POSITION",
+                    dims_station_time_position,
+                ],
+            }
+        )
 
     to_new_coords = {
         "TIME": ["time_weather", ["time_weather"]],
@@ -234,6 +367,9 @@ def create_weather_xds(in_file: str, ant_xds_station_name_ids: xr.DataArray):
     weather_xds = convert_generic_xds_to_xradio_schema(
         generic_weather_xds, weather_xds, to_new_data_variables, to_new_coords
     )
+    weather_xds = finalize_station_position(
+        weather_xds, ant_position_with_ids, has_asdm_station_position
+    )
 
     # TODO: option to interpolate to main time
 
@@ -256,6 +392,7 @@ def correct_generic_pointing_xds(
     and tries to correct several deviations from the MSv2 specs seen in
     common test data.
     The problems fixed here include wrong dimensions:
+
     - for example transposed dimensions with respect to the MSv2 specs (output
     from CASA simulator),
     - missing/additional unexpected dimensions when some of the columns are
@@ -423,6 +560,7 @@ def prepare_generic_sys_cal_xds(generic_sys_cal_xds: xr.Dataset) -> xr.Dataset:
     sys_cal_xds dataset, as their structure differs in dimensions and order
     of dimensions.
     This function performs various prepareation steps, such as:
+
     - filter out dimensions not neeed for an individual MSv4 (SPW, FEED),
     - drop variables loaded from columns with all items set to empty array,
     - transpose the dimensions frequency,receptor

{xradio-0.0.50 → xradio-0.0.51}/src/xradio/measurement_set/processing_set_xdt.py

@@ -569,6 +569,17 @@ class ProcessingSetXdt:
         ValueError
             If the combined datasets are empty or improperly formatted.
         """
+
+        def setup_annotations_all(axis, scatter, field_names):
+            """
+            Creates annotations for when label_all_fields=True
+            """
+            coord_x, coord_y = np.array(scatter.get_offsets()).transpose()
+            offset_x = np.abs(np.max(coord_x) - np.min(coord_x)) * 0.01
+            offset_y = np.abs(np.max(coord_y) - np.min(coord_y)) * 0.01
+            for idx, (x, y) in enumerate(zip(coord_x + offset_x, coord_y + offset_y)):
+                axis.annotate(field_names[idx], (x, y), alpha=1)
+
         if self._xdt.attrs.get("type") not in PS_DATASET_TYPES:
             raise InvalidAccessorLocation(
                 f"{self._xdt.path} is not a processing set node."
@@ -585,9 +596,9 @@ class ProcessingSetXdt:
         if (len(combined_field_and_source_xds.data_vars) > 0) and (
             "FIELD_PHASE_CENTER" in combined_field_and_source_xds
         ):
-            plt.figure()
+            fig = plt.figure()
             plt.title("Field Phase Center Locations")
-            plt.scatter(
+            scatter = plt.scatter(
                 combined_field_and_source_xds["FIELD_PHASE_CENTER"].sel(
                     sky_dir_label="ra"
                 ),
@@ -595,31 +606,40 @@ class ProcessingSetXdt:
                     sky_dir_label="dec"
                 ),
             )
-
             center_field_name = combined_field_and_source_xds.attrs["center_field_name"]
             center_field = combined_field_and_source_xds.sel(
                 field_name=center_field_name
             )
+
+            if label_all_fields:
+                field_name = combined_field_and_source_xds.field_name.values
+                setup_annotations_all(fig.axes[0], scatter, field_name)
+                fig.axes[0].margins(0.2, 0.2)
+                center_label = None
+            else:
+                center_label = center_field_name
+
             plt.scatter(
                 center_field["FIELD_PHASE_CENTER"].sel(sky_dir_label="ra"),
                 center_field["FIELD_PHASE_CENTER"].sel(sky_dir_label="dec"),
                 color="red",
-                label=center_field_name,
+                label=center_label,
             )
             plt.xlabel("RA (rad)")
             plt.ylabel("DEC (rad)")
-            plt.legend()
+            if not label_all_fields:
+                plt.legend()
             plt.show()
 
         if (len(combined_ephemeris_field_and_source_xds.data_vars) > 0) and (
             "FIELD_PHASE_CENTER" in combined_ephemeris_field_and_source_xds
         ):
 
-            plt.figure()
+            fig = plt.figure()
             plt.title(
                 "Offset of Field Phase Center from Source Location (Ephemeris Data)"
             )
-            plt.scatter(
+            scatter = plt.scatter(
                 combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].sel(
                     sky_dir_label="ra"
                 ),
@@ -639,15 +659,26 @@ class ProcessingSetXdt:
             center_field = combined_ephemeris_field_and_source_xds.sel(
                 field_name=center_field_name
             )
+
+            if label_all_fields:
+                field_name = combined_ephemeris_field_and_source_xds.field_name.values
+                setup_annotations_all(fig.axes[0], scatter, field_name)
+                fig.axes[0].margins(0.2, 0.2)
+                center_label = None
+            else:
+                center_label = center_field_name
+
             plt.scatter(
                 center_field["FIELD_OFFSET"].sel(sky_dir_label="ra"),
                 center_field["FIELD_OFFSET"].sel(sky_dir_label="dec"),
                 color="red",
-                label=center_field_name,
+                label=center_label,
             )
+
             plt.xlabel("RA Offset (rad)")
             plt.ylabel("DEC Offset (rad)")
-            plt.legend()
+            if not label_all_fields:
+                plt.legend()
             plt.show()
 
     def get_combined_antenna_xds(self) -> xr.Dataset:
@@ -693,18 +724,23 @@ class ProcessingSetXdt:
 
         return combined_antenna_xds
 
-    def plot_antenna_positions(self):
+    def plot_antenna_positions(self, label_all_antennas: bool = False):
         """
         Plot the antenna positions of all antennas in the Processing Set.
 
-        This method generates three scatter plots displaying the antenna positions in different planes:
+        This method generates and displays a figure with three scatter plots, displaying the antenna
+        positions in different planes:
+
         - X vs Y
         - X vs Z
         - Y vs Z
 
+        The antenna names are shown on hovering their positions, unless label_all_antennas is enabled.
+
         Parameters
         ----------
-        None
+        label_all_antennas : bool, optional
+            If 'True', annotations are shown with the names of every antenna next to their positions.
 
         Returns
         -------
@@ -715,6 +751,75 @@ class ProcessingSetXdt:
         ValueError
             If the combined antenna dataset is empty or missing required coordinates.
         """
+
+        def antenna_hover(event):
+            if event.inaxes in antenna_axes:
+                for axis in antenna_axes:
+                    contained, indices = scatter_map[axis].contains(event)
+                    annotation = annotations_map[axis]
+                    if contained:
+                        scatter = scatter_map[axis]
+                        update_antenna_annotation(indices, scatter, annotation)
+                        annotation.set_visible(True)
+                        fig.canvas.draw_idle()
+                    else:
+                        visible = annotation.get_visible()
+                        if visible:
+                            annotation.set_visible(False)
+                            fig.canvas.draw_idle()
+
+        def update_antenna_annotation(indices, scatter, annotation):
+            position = scatter.get_offsets()[indices["ind"][0]]
+            annotation.xy = position
+            text = "{}".format(" ".join([antenna_names[num] for num in indices["ind"]]))
+            annotation.set_text(text)
+            annotation.get_bbox_patch().set_facecolor("#e8d192")
+            annotation.get_bbox_patch().set_alpha(1)
+
+        def setup_annotations_for_hover(antenna_axes, scatter_plots):
+            """
+            Creates annotations on all the axes requested.
+
+            Returns
+            -------
+            dict
+                dict from antenna axes -> annotation objects
+            """
+            antenna_annotations = []
+            for axis in antenna_axes:
+                annotation = axis.annotate(
+                    "",
+                    xy=(0, 0),
+                    xytext=(10, 15),
+                    textcoords="offset points",
+                    arrowprops=dict(arrowstyle="-|>"),
+                    bbox=dict(boxstyle="round", fc="w"),
+                )
+                antenna_annotations.append(annotation)
+                annotation.set_visible(False)
+            annotations_map = dict(zip(antenna_axes, antenna_annotations))
+
+            return annotations_map
+
+        def setup_annotations_for_all(antenna_axes, scatter_map):
+            """
+            Creates annotations for when label_all_antennas=True
+            """
+            antenna_annotations = []
+            for axis in antenna_axes:
+                scatter = scatter_map[axis]
+                coord_x, coord_y = np.array(scatter.get_offsets()).transpose()
+                offset_x = np.abs(np.max(coord_x) - np.min(coord_x)) * 0.01
+                offset_y = np.abs(np.max(coord_y) - np.min(coord_y)) * 0.01
+                for idx, (x, y) in enumerate(
+                    zip(coord_x + offset_x, coord_y + offset_y)
+                ):
+                    annotation = axis.annotate(
+                        antenna_names[idx],
+                        (x, y),
+                        alpha=1,
+                    )
+
         if self._xdt.attrs.get("type") not in PS_DATASET_TYPES:
             raise InvalidAccessorLocation(
                 f"{self._xdt.path} is not a processing set node."
@@ -723,34 +828,44 @@ class ProcessingSetXdt:
         combined_antenna_xds = self.get_combined_antenna_xds()
         from matplotlib import pyplot as plt
 
-        plt.figure()
-        plt.title("Antenna Positions")
-        plt.scatter(
+        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 8))
+        fig.suptitle("Antenna Positions")
+        fig.subplots_adjust(
+            wspace=0.25, hspace=0.25, left=0.1, right=0.95, top=0.9, bottom=0.1
+        )
+
+        scatter1 = ax1.scatter(
             combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="x"),
             combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="y"),
         )
-        plt.xlabel("x (m)")
-        plt.ylabel("y (m)")
-        plt.show()
+        ax1.set_xlabel("x (m)")
+        ax1.set_ylabel("y (m)")
+        antenna_names = combined_antenna_xds.antenna_name.values
 
-        plt.figure()
-        plt.title("Antenna Positions")
-        plt.scatter(
-            combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="x"),
+        scatter2 = ax2.scatter(
+            combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="y"),
             combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="z"),
         )
-        plt.xlabel("x (m)")
-        plt.ylabel("z (m)")
-        plt.show()
+        ax2.set_xlabel("y (m)")
+        ax2.set_ylabel("z (m)")
 
-        plt.figure()
-        plt.title("Antenna Positions")
-        plt.scatter(
-            combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="y"),
+        scatter3 = ax3.scatter(
+            combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="x"),
             combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="z"),
         )
-        plt.xlabel("y (m)")
-        plt.ylabel("z (m)")
+        ax3.set_xlabel("x (m)")
+        ax3.set_ylabel("z (m)")
+
+        ax4.axis("off")
+
+        antenna_axes = [ax1, ax2, ax3]
+        scatter_map = dict(zip(antenna_axes, [scatter1, scatter2, scatter3]))
+        if label_all_antennas:
+            annotations_map = setup_annotations_for_all(antenna_axes, scatter_map)
+        else:
+            annotations_map = setup_annotations_for_hover(antenna_axes, scatter_map)
+            fig.canvas.mpl_connect("motion_notify_event", antenna_hover)
+
         plt.show()
 
 

{xradio-0.0.50 → xradio-0.0.51}/src/xradio/measurement_set/schema.py

@@ -27,7 +27,7 @@ TimeWeather = Literal["time_weather"]
 AntennaName = Literal["antenna_name"]
 """ Antenna name dimension """
 StationName = Literal["station_name"]
-""" Station identifier dimension """
+""" Station name dimension """
 ReceptorLabel = Literal["receptor_label"]
 """ Receptor label dimension """
 ToneLabel = Literal["tone_label"]
@@ -295,7 +295,7 @@ class SkyCoordArray:
 
     type: Attr[SkyCoord] = "sky_coord"
     units: Attr[UnitsOfSkyCoordInRadians] = ("rad", "rad")
-    frame: Attr[AllowedSkyCoordFrames] = ""
+    frame: Attr[AllowedSkyCoordFrames] = "icrs"
     """
     Possible values are astropy SkyCoord frames.
     Several casacore frames found in MSv2 are translated to astropy frames as follows: AZELGEO=>altaz, J2000=>fk5, ICRS=>icrs.
@@ -324,7 +324,7 @@ class PointingBeamArray:
 
     type: Attr[SkyCoord] = "sky_coord"
     units: Attr[UnitsOfSkyCoordInRadians] = ("rad", "rad")
-    frame: Attr[AllowedSkyCoordFrames] = "fk5"
+    frame: Attr[AllowedSkyCoordFrames] = "icrs"
     """
     From 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
@@ -341,7 +341,7 @@ class LocalSkyCoordArray:
 
     type: Attr[SkyCoord] = "sky_coord"
     units: Attr[UnitsOfSkyCoordInRadians] = ("rad", "rad")
-    frame: Attr[AllowedSkyCoordFrames] = "fk5"
+    frame: Attr[AllowedSkyCoordFrames] = "icrs"
     """
     From 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
@@ -518,7 +518,7 @@ AllowedSpectralCoordFrames = Literal[
     # "LSRK" -> "lsrk",
     # "LSRD" -> "lsrd",
     "BARY",
-    "GEO",
+    # "GEO", -> "gcrs"
     "TOPO",
     # astropy frames
     "gcrs",
@@ -540,17 +540,20 @@ class SpectralCoordArray:
 
     units: Attr[UnitsHertz] = ("Hz",)
 
-    observer: Attr[AllowedSpectralCoordFrames] = "gcrs"
+    observer: Attr[AllowedSpectralCoordFrames] = "icrs"
     """
     Capitalized reference observers are from casacore. TOPO implies creating astropy earth_location.
     Astropy velocity reference frames are lowercase. Note that Astropy does not use the name 'TOPO' (telescope centric)
     rather it assumes if no velocity frame is given that this is the default.
+
+    When converting from MSv2 and casacore frequency frames, the following translations from casacore to astropy
+    frame names are applied: GEO=>gcrs, LSRK=>lsrk, LSRD=>lsrd
     """
 
     type: Attr[SpectralCoord] = "spectral_coord"
 
 
-AllowedLocationFrames = Literal["ITRF", "GRS80", "WGS84", "WGS72", "Undefined"]
+AllowedLocationFrames = Literal["ITRS", "Undefined"]
 
 
 AllowedLocationCoordinateSystems = Literal[
@@ -562,11 +565,16 @@ AllowedLocationCoordinateSystems = Literal[
 ]
 
 
+AllowedEllipsoid = Literal["GRS80", "WGS84", "WGS72"]
+
+
 @xarray_dataarray_schema
 class LocationArray:
     """
-    Measure type used for example in antenna_xds/ANTENNA_POSITION, field_and_source_xds/OBSERVER_POSITION
-    Data dimensions can be EllipsoidPosLabel or CartesianPosLabel
+    Measure type used for example in antenna_xds/ANTENNA_POSITION, weather_xds/STATION_POSITION,
+    field_and_source_xds(ephemeris)/OBSERVER_POSITION.
+
+    Data dimensions can be CartesianPosLabel or EllipsoidPosLabel
     """
 
     data: Data[Union[EllipsoidPosLabel, CartesianPosLabel], float]
@@ -575,13 +583,13 @@ class LocationArray:
     """
     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
-    units in the same data array,for example geodetic coordinates could use
+    units in the same data array, for example geodetic coordinates could use
     ``['rad','rad','m']``.
     """
 
     frame: Attr[AllowedLocationFrames]
     """
-    Can be ITRF, GRS80, WGS84, WGS72, Undefined
+    Reference frame. Can be ITRS (assumed for all Earth locations) or Undefined (used in non-Earth locations).
     """
 
     coordinate_system: Attr[AllowedLocationCoordinateSystems]
@@ -589,24 +597,29 @@ class LocationArray:
 
     origin_object_name: Attr[str]
     """
-    earth/sun/moon/etc
+    earth/sun/moon/etc.
+    """
+
+    ellipsoid: Optional[Attr[AllowedEllipsoid]]
+    """
+    Ellipsoid used in geodetic Earth locations (with EllipsoidPosLabel coordinate)
     """
 
     type: Attr[Location] = "location"
-    """ """
+    """ Measure type. Should be ``"location"``."""
 
 
 @xarray_dataarray_schema
 class EllipsoidPosLocationArray:
     """
-    Measure type used for example in field_and_source_xds/SUB_OBSERVER_POSITION, SUB_SOLAR_POSITION
+    Measure type used for example in field_and_source_xds(ephemeris) / SUB_OBSERVER_DIRECTION, SUB_SOLAR_POSITION
     """
 
     data: Data[EllipsoidPosLabel, float]
 
     frame: Attr[AllowedLocationFrames]
     """
-    Can be ITRF, GRS80, WGS84, WGS72
+    Reference frame. Can be ITRS (assumed for all Earth locations) or Undefined (used in non-Earth locations).
     """
 
     coordinate_system: Attr[AllowedLocationCoordinateSystems]
@@ -618,7 +631,7 @@ class EllipsoidPosLocationArray:
     """
 
     type: Attr[Location] = "location"
-    """ """
+    """ Measure type. Should be ``"location"``."""
 
     units: Attr[UnitsOfPositionInRadians] = ("rad", "rad", "m")
     """
@@ -1445,7 +1458,7 @@ class AntennaXds:
     # Coordinates
     antenna_name: Coordof[AntennaNameArray]
     """ Antenna name """
-    station: Coord[AntennaName, str]
+    station_name: 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;
@@ -1529,7 +1542,7 @@ class GainCurveXds:
     # Coordinates
     antenna_name: Coordof[AntennaNameArray]
     """ Antenna name """
-    station: Coord[AntennaName, str]
+    station_name: 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;
@@ -1588,7 +1601,7 @@ class PhaseCalibrationXds:
     # Coordinates
     antenna_name: Coordof[AntennaNameArray]
     """ Antenna name """
-    station: Coord[AntennaName, str]
+    station_name: 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;
@@ -1672,13 +1685,11 @@ class WeatherXds:
 
     # Coordinates
     station_name: Coord[StationName, str]
-    """ Station identifier """
+    """ Station name """
     time: Optional[Coordof[TimeInterpolatedCoordArray]]
     """ Mid-point of the time interval. Labeled 'time' when interpolated to main time axis """
     time_weather: Optional[Coordof[TimeWeatherCoordArray]]
     """ Mid-point of the time interval. Labeled 'time_weather' when not interpolated to main time axis """
-    antenna_name: Optional[Coordof[AntennaNameArray]]
-    """ Antenna identifier """
     ellipsoid_pos_label: Optional[Coord[EllipsoidPosLabel, str]] = (
         "lon",
         "lat",
@@ -1688,6 +1699,10 @@ class WeatherXds:
     cartesian_pos_label: Optional[Coord[CartesianPosLabel, str]] = ("x", "y", "z")
     """ Coordinate labels of geocentric earth location data (typically shape 3 and 'x', 'y', 'z')"""
 
+    # Station position variable - required
+    STATION_POSITION: Data[tuple[StationName], LocationArray] = None
+    """ Position of the weather station """
+
     # Data variables (all optional)
     H2O: Optional[
         Data[
@@ -1766,8 +1781,6 @@ class WeatherXds:
         ]
     ] = None
     """ Average wind speed """
-    STATION_POSITION: Optional[Data[tuple[StationName], LocationArray]] = None
-    """ Station position """
 
     # Attributes
     type: Attr[Literal["weather"]] = "weather"
@@ -1883,7 +1896,9 @@ class SystemCalibrationXds:
 
     # Coordinates
     antenna_name: Coordof[AntennaNameArray]
-    """ Antenna identifier """
+    """ Antenna name """
+    station_name: Coord[AntennaName, str]
+    """ Name of the station pad (relevant to arrays with moving antennas). """
     receptor_label: Coord[ReceptorLabel, str]
     """ Names of receptors """
     polarization_type: Coord[tuple[AntennaName, ReceptorLabel], str]

{xradio-0.0.50 → xradio-0.0.51/src/xradio.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: xradio
-Version: 0.0.50
+Version: 0.0.51
 Summary:  Xarray Radio Astronomy Data IO
-Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>
+Author-email: Jan-Willem Steeb <jsteeb@nrao.edu>, Federico Montesino Pouzols <pouzols@eso.edu>, Dave Mehringer <dmehring@nrao.edu>, Peter Wortmann <peter.wortmann@skao.int>
 License: BSD 3-Clause License
         
         All works in this repository are copyrighted 2024.  
@@ -43,7 +43,7 @@ License-File: LICENSE.txt
 Requires-Dist: astropy
 Requires-Dist: dask
 Requires-Dist: distributed
-Requires-Dist: toolviper
+Requires-Dist: toolviper>=0.0.11
 Requires-Dist: numba>=0.57.0
 Requires-Dist: numpy
 Requires-Dist: pytest
@@ -79,7 +79,13 @@ Dynamic: license-file
 # xradio
 Xarray Radio Astronomy Data IO is still in development.
 
-[![Python 3.9 3.10 3.11 3.12](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%203.12-blue)](https://www.python.org/downloads/release/python-380/)
+[![Python 3.11 3.12 3.13](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/downloads/release/python-3130/)
+![Linux Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-linux.yml/badge.svg?branch=main)
+![macOS Tests](https://github.com/casangi/xradio/actions/workflows/python-testing-macos.yml/badge.svg?branch=main)
+![ipynb Tests](https://github.com/casangi/xradio/actions/workflows/run-ipynb.yml/badge.svg?branch=main)
+[![Coverage](https://codecov.io/gh/casangi/xradio/branch/main/graph/badge.svg)](https://codecov.io/gh/casangi/xradio/branch/main/xradio)
+[![Documentation Status](https://readthedocs.org/projects/xradio/badge/?version=latest)](https://xradio.readthedocs.io)
+[![Version Status](https://img.shields.io/pypi/v/xradio.svg)](https://pypi.python.org/pypi/xradio/)
 
 # Installing
 It is recommended to use the conda environment manager from [miniforge](https://github.com/conda-forge/miniforge) to create a clean, self-contained runtime where XRADIO and all its dependencies can be installed:

{xradio-0.0.50 → xradio-0.0.51}/src/xradio.egg-info/requires.txt

@@ -1,7 +1,7 @@
 astropy
 dask
 distributed
-toolviper
+toolviper>=0.0.11
 numba>=0.57.0
 numpy
 pytest

xradio-0.0.50/README.md

@@ -1,21 +0,0 @@
-# xradio
-Xarray Radio Astronomy Data IO is still in development.
-
-[![Python 3.9 3.10 3.11 3.12](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%203.12-blue)](https://www.python.org/downloads/release/python-380/)
-
-# Installing
-It is recommended to use the conda environment manager from [miniforge](https://github.com/conda-forge/miniforge) to create a clean, self-contained runtime where XRADIO and all its dependencies can be installed:
-```sh
-conda create --name xradio python=3.12 --no-default-packages
-conda activate xradio
-```
-> 📝 On macOS it is required to pre-install `python-casacore` using `conda install -c conda-forge python-casacore`.
-
-XRADIO can now be installed using:
-```sh
-pip install xradio
-```
-This will also install the minimal dependencies for XRADIO. To install the minimal dependencies and the interactive components (JupyterLab) use:
-```sh
-pip install "xradio[interactive]"
-```