xradio 0.0.56__py3-none-any.whl → 0.0.59__py3-none-any.whl

xradio/measurement_set/processing_set_xdt.py

@@ -1,8 +1,6 @@
 import pandas as pd
 from xradio._utils.list_and_array import to_list
-import numbers
 import numpy as np
-import toolviper.utils.logger as logger
 import xarray as xr
 
 PS_DATASET_TYPES = {"processing_set"}
@@ -39,7 +37,7 @@ class ProcessingSetXdt:
         self._xdt = datatree
         self.meta = {"summary": {}}
 
-    def summary(self, data_group: str = "base") -> pd.DataFrame:
+    def summary(self, data_group: str = None) -> pd.DataFrame:
         """
         Generate and retrieve a summary of the Processing Set.
 
@@ -50,7 +48,8 @@ class ProcessingSetXdt:
         Parameters
         ----------
         data_group : str, optional
-            The data group to summarize. Default is "base".
+            The data group to summarize. By default the "base" group
+            is used (if found), or otherwise the first group found.
 
         Returns
         -------
@@ -58,11 +57,24 @@ class ProcessingSetXdt:
             A DataFrame containing the summary information of the specified data group.
         """
 
+        def find_data_group_base_or_first(data_group: str, xdt: xr.DataTree) -> str:
+            first_msv4 = next(iter(xdt.values()))
+            first_data_groups = first_msv4.attrs["data_groups"]
+            if data_group is None:
+                data_group = (
+                    "base"
+                    if "base" in first_data_groups
+                    else next(iter(first_data_groups))
+                )
+            return data_group
+
         if self._xdt.attrs.get("type") not in PS_DATASET_TYPES:
             raise InvalidAccessorLocation(
                 f"{self._xdt.path} is not a processing set node."
             )
 
+        data_group = find_data_group_base_or_first(data_group, self._xdt)
+
         if data_group in self.meta["summary"]:
             return self.meta["summary"][data_group]
         else:
@@ -130,7 +142,7 @@ class ProcessingSetXdt:
         if "freq_axis" in self.meta:
             return self.meta["freq_axis"]
         else:
-            spw_ids = []
+            spw_names = []
             freq_axis_list = []
             frame = self._xdt[next(iter(self._xdt.children))].frequency.attrs[
                 "observer"
@@ -139,15 +151,17 @@ class ProcessingSetXdt:
                 assert (
                     frame == ms_xdt.frequency.attrs["observer"]
                 ), "Frequency reference frame not consistent in Processing Set."
-                if ms_xdt.frequency.attrs["spectral_window_id"] not in spw_ids:
-                    spw_ids.append(ms_xdt.frequency.attrs["spectral_window_id"])
+                if ms_xdt.frequency.attrs["spectral_window_name"] not in spw_names:
+                    spw_names.append(ms_xdt.frequency.attrs["spectral_window_name"])
                     freq_axis_list.append(ms_xdt.frequency)
 
-            freq_axis = xr.concat(freq_axis_list, dim="frequency").sortby("frequency")
+            freq_axis = xr.concat(freq_axis_list, dim="frequency", join="outer").sortby(
+                "frequency"
+            )
             self.meta["freq_axis"] = freq_axis
             return self.meta["freq_axis"]
 
-    def _summary(self, data_group: str = "base"):
+    def _summary(self, data_group: str = None):
         summary_data = {
             "name": [],
             "intents": [],
@@ -155,6 +169,7 @@ class ProcessingSetXdt:
             "polarization": [],
             "scan_name": [],
             "spw_name": [],
+            "spw_intent": [],
             "field_name": [],
             "source_name": [],
             "line_name": [],
@@ -171,15 +186,16 @@ class ProcessingSetXdt:
             summary_data["name"].append(key)
             summary_data["intents"].append(partition_info["intents"])
             summary_data["spw_name"].append(partition_info["spectral_window_name"])
+            summary_data["spw_intent"].append(partition_info["spectral_window_intent"])
             summary_data["polarization"].append(value.polarization.values)
             summary_data["scan_name"].append(partition_info["scan_name"])
             data_name = value.attrs["data_groups"][data_group]["correlated_data"]
 
             if "VISIBILITY" in data_name:
-                center_name = "FIELD_PHASE_CENTER"
+                center_name = "FIELD_PHASE_CENTER_DIRECTION"
 
             if "SPECTRUM" in data_name:
-                center_name = "FIELD_REFERENCE_CENTER"
+                center_name = "FIELD_REFERENCE_CENTER_DIRECTION"
 
             summary_data["shape"].append(value[data_name].shape)
 
@@ -255,10 +271,10 @@ class ProcessingSetXdt:
         Examples
         --------
         >>> # Select all MSs with intents 'OBSERVE_TARGET#ON_SOURCE' and polarization 'RR' or 'LL'
-        >>> selected_ps = ps.query(intents='OBSERVE_TARGET#ON_SOURCE', polarization=['RR', 'LL'])
+        >>> selected_ps_xdt = ps_xdt.xr_ps.query(intents='OBSERVE_TARGET#ON_SOURCE', polarization=['RR', 'LL'])
 
         >>> # Select all MSs with start_frequency greater than 100 GHz and less than 200 GHz
-        >>> selected_ps = ps.query(query='start_frequency > 100e9 AND end_frequency < 200e9')
+        >>> selected_ps_xdt = ps_xdt.xr_ps.query(query='start_frequency > 100e9 AND end_frequency < 200e9')
         """
 
         if self._xdt.attrs.get("type") not in PS_DATASET_TYPES:
@@ -345,10 +361,6 @@ class ProcessingSetXdt:
 
         combined_field_and_source_xds = xr.Dataset()
         for ms_name, ms_xdt in self._xdt.items():
-            correlated_data_name = ms_xdt.attrs["data_groups"][data_group][
-                "correlated_data"
-            ]
-
             field_and_source_xds = ms_xdt.xr_ms.get_field_and_source_xds(data_group)
 
             if not field_and_source_xds.attrs["type"] == "field_and_source_ephemeris":
@@ -369,38 +381,39 @@ class ProcessingSetXdt:
                     combined_field_and_source_xds = xr.concat(
                         [combined_field_and_source_xds, field_and_source_xds],
                         dim="field_name",
+                        join="outer",
                     )
 
         if (len(combined_field_and_source_xds.data_vars) > 0) and (
-            "FIELD_PHASE_CENTER" in combined_field_and_source_xds
+            "FIELD_PHASE_CENTER_DIRECTION" in combined_field_and_source_xds
         ):
             combined_field_and_source_xds = (
                 combined_field_and_source_xds.drop_duplicates("field_name")
             )
 
-            combined_field_and_source_xds["MEAN_PHASE_CENTER"] = (
-                combined_field_and_source_xds["FIELD_PHASE_CENTER"].mean(
+            combined_field_and_source_xds["MEAN_PHASE_CENTER_DIRECTION"] = (
+                combined_field_and_source_xds["FIELD_PHASE_CENTER_DIRECTION"].mean(
                     dim=["field_name"]
                 )
             )
 
             ra1 = (
-                combined_field_and_source_xds["FIELD_PHASE_CENTER"]
+                combined_field_and_source_xds["FIELD_PHASE_CENTER_DIRECTION"]
                 .sel(sky_dir_label="ra")
                 .values
             )
             dec1 = (
-                combined_field_and_source_xds["FIELD_PHASE_CENTER"]
+                combined_field_and_source_xds["FIELD_PHASE_CENTER_DIRECTION"]
                 .sel(sky_dir_label="dec")
                 .values
             )
             ra2 = (
-                combined_field_and_source_xds["MEAN_PHASE_CENTER"]
+                combined_field_and_source_xds["MEAN_PHASE_CENTER_DIRECTION"]
                 .sel(sky_dir_label="ra")
                 .values
             )
             dec2 = (
-                combined_field_and_source_xds["MEAN_PHASE_CENTER"]
+                combined_field_and_source_xds["MEAN_PHASE_CENTER_DIRECTION"]
                 .sel(sky_dir_label="dec")
                 .values
             )
@@ -445,11 +458,6 @@ class ProcessingSetXdt:
 
         combined_ephemeris_field_and_source_xds = xr.Dataset()
         for ms_name, ms_xdt in self._xdt.items():
-
-            correlated_data_name = ms_xdt.attrs["data_groups"][data_group][
-                "correlated_data"
-            ]
-
             field_and_source_xds = field_and_source_xds = (
                 ms_xdt.xr_ms.get_field_and_source_xds(data_group)
             )
@@ -466,7 +474,7 @@ class ProcessingSetXdt:
                     del field_and_source_xds["line_name"]
                     del field_and_source_xds["line_label"]
 
-                from xradio.measurement_set._utils._msv2.msv4_sub_xdss import (
+                from xradio.measurement_set._utils._utils.interpolate import (
                     interpolate_to_time,
                 )
 
@@ -494,24 +502,27 @@ class ProcessingSetXdt:
                     combined_ephemeris_field_and_source_xds = xr.concat(
                         [combined_ephemeris_field_and_source_xds, field_and_source_xds],
                         dim="time",
+                        join="outer",
                     )
 
         if (len(combined_ephemeris_field_and_source_xds.data_vars) > 0) and (
-            "FIELD_PHASE_CENTER" in combined_ephemeris_field_and_source_xds
+            "FIELD_PHASE_CENTER_DIRECTION" in combined_ephemeris_field_and_source_xds
         ):
 
             from xradio._utils.coord_math import wrap_to_pi
 
             offset = (
-                combined_ephemeris_field_and_source_xds["FIELD_PHASE_CENTER"]
-                - combined_ephemeris_field_and_source_xds["SOURCE_LOCATION"]
+                combined_ephemeris_field_and_source_xds["FIELD_PHASE_CENTER_DIRECTION"]
+                - combined_ephemeris_field_and_source_xds["SOURCE_DIRECTION"]
             )
             combined_ephemeris_field_and_source_xds["FIELD_OFFSET"] = xr.DataArray(
-                wrap_to_pi(offset.sel(sky_pos_label=["ra", "dec"])).values,
+                wrap_to_pi(offset.sel(sky_dir_label=["ra", "dec"])).values,
                 dims=["time", "sky_dir_label"],
             )
             combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].attrs = (
-                combined_ephemeris_field_and_source_xds["FIELD_PHASE_CENTER"].attrs
+                combined_ephemeris_field_and_source_xds[
+                    "FIELD_PHASE_CENTER_DIRECTION"
+                ].attrs
             )
             combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].attrs["units"] = (
                 combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].attrs["units"][
@@ -594,15 +605,15 @@ class ProcessingSetXdt:
         from matplotlib import pyplot as plt
 
         if (len(combined_field_and_source_xds.data_vars) > 0) and (
-            "FIELD_PHASE_CENTER" in combined_field_and_source_xds
+            "FIELD_PHASE_CENTER_DIRECTION" in combined_field_and_source_xds
         ):
             fig = plt.figure()
             plt.title("Field Phase Center Locations")
             scatter = plt.scatter(
-                combined_field_and_source_xds["FIELD_PHASE_CENTER"].sel(
+                combined_field_and_source_xds["FIELD_PHASE_CENTER_DIRECTION"].sel(
                     sky_dir_label="ra"
                 ),
-                combined_field_and_source_xds["FIELD_PHASE_CENTER"].sel(
+                combined_field_and_source_xds["FIELD_PHASE_CENTER_DIRECTION"].sel(
                     sky_dir_label="dec"
                 ),
             )
@@ -620,8 +631,8 @@ class ProcessingSetXdt:
                 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"),
+                center_field["FIELD_PHASE_CENTER_DIRECTION"].sel(sky_dir_label="ra"),
+                center_field["FIELD_PHASE_CENTER_DIRECTION"].sel(sky_dir_label="dec"),
                 color="red",
                 label=center_label,
             )
@@ -632,7 +643,7 @@ class ProcessingSetXdt:
             plt.show()
 
         if (len(combined_ephemeris_field_and_source_xds.data_vars) > 0) and (
-            "FIELD_PHASE_CENTER" in combined_ephemeris_field_and_source_xds
+            "FIELD_PHASE_CENTER_DIRECTION" in combined_ephemeris_field_and_source_xds
         ):
 
             fig = plt.figure()
@@ -714,6 +725,7 @@ class ProcessingSetXdt:
                     dim="antenna_name",
                     data_vars="minimal",
                     coords="minimal",
+                    join="outer",
                 )
 
         # ALMA WVR antenna_xds data has a NaN value for the antenna receptor angle.
@@ -805,7 +817,6 @@ class ProcessingSetXdt:
             """
             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()
@@ -814,7 +825,7 @@ class ProcessingSetXdt:
                 for idx, (x, y) in enumerate(
                     zip(coord_x + offset_x, coord_y + offset_y)
                 ):
-                    annotation = axis.annotate(
+                    axis.annotate(
                         antenna_names[idx],
                         (x, y),
                         alpha=1,
@@ -867,801 +878,3 @@ class ProcessingSetXdt:
             fig.canvas.mpl_connect("motion_notify_event", antenna_hover)
 
         plt.show()
-
-
-# class ProcessingSet(dict):
-#     """
-#     A dictionary subclass representing a Processing Set (PS) containing Measurement Sets v4 (MS).
-
-#     This class extends the built-in `dict` class to provide additional methods for
-#     manipulating and selecting subsets of the Processing Set. It includes functionality
-#     for summarizing metadata, selecting subsets based on various criteria, and
-#     exporting the data to storage formats.
-
-#     Parameters
-#     ----------
-#     *args : dict, optional
-#         Variable length argument list passed to the base `dict` class.
-#     **kwargs : dict, optional
-#         Arbitrary keyword arguments passed to the base `dict` class.
-#     """
-
-#     def __init__(self, *args, **kwargs):
-#         """
-#         Initialize the ProcessingSet instance.
-
-#         Parameters
-#         ----------
-#         *args : dict, optional
-#             Variable length argument list passed to the base `dict` class.
-#         **kwargs : dict, optional
-#             Arbitrary keyword arguments passed to the base `dict` class.
-#         """
-#         super().__init__(*args, **kwargs)
-#         self.meta = {"summary": {}}
-
-#     def summary(self, data_group="base"):
-#         """
-#         Generate and retrieve a summary of the Processing Set.
-
-#         The summary includes information such as the names of the Measurement Sets,
-#         their intents, polarizations, spectral window names, field names, source names,
-#         field coordinates, start frequencies, and end frequencies.
-
-#         Parameters
-#         ----------
-#         data_group : str, optional
-#             The data group to summarize. Default is "base".
-
-#         Returns
-#         -------
-#         pandas.DataFrame
-#             A DataFrame containing the summary information of the specified data group.
-#         """
-
-#         if data_group in self.meta["summary"]:
-#             return self.meta["summary"][data_group]
-#         else:
-#             self.meta["summary"][data_group] = self._summary(data_group).sort_values(
-#                 by=["name"], ascending=True
-#             )
-#             return self.meta["summary"][data_group]
-
-#     def get_ps_max_dims(self):
-#         """
-#         Determine the maximum dimensions across all Measurement Sets in the Processing Set.
-
-#         This method examines each Measurement Set's dimensions and computes the maximum
-#         size for each dimension across the entire Processing Set.
-
-#         For example, if the Processing Set contains two MSs with dimensions (50, 20, 30) and (10, 30, 40),
-#         the maximum dimensions will be (50, 30, 40).
-
-#         Returns
-#         -------
-#         dict
-#             A dictionary containing the maximum dimensions of the Processing Set, with dimension names as keys
-#             and their maximum sizes as values.
-#         """
-#         if "max_dims" in self.meta:
-#             return self.meta["max_dims"]
-#         else:
-#             self.meta["max_dims"] = self._get_ps_max_dims()
-#             return self.meta["max_dims"]
-
-#     def get_ps_freq_axis(self):
-#         """
-#         Combine the frequency axes of all Measurement Sets in the Processing Set.
-
-#         This method aggregates the frequency information from each Measurement Set to create
-#         a unified frequency axis for the entire Processing Set.
-
-#         Returns
-#         -------
-#         xarray.DataArray
-#             The combined frequency axis of the Processing Set.
-#         """
-#         if "freq_axis" in self.meta:
-#             return self.meta["freq_axis"]
-#         else:
-#             self.meta["freq_axis"] = self._get_ps_freq_axis()
-#             return self.meta["freq_axis"]
-
-#     def _summary(self, data_group="base"):
-#         summary_data = {
-#             "name": [],
-#             "intents": [],
-#             "shape": [],
-#             "polarization": [],
-#             "scan_name": [],
-#             "spw_name": [],
-#             "field_name": [],
-#             "source_name": [],
-#             "line_name": [],
-#             "field_coords": [],
-#             "start_frequency": [],
-#             "end_frequency": [],
-#         }
-#         from astropy.coordinates import SkyCoord
-#         import astropy.units as u
-
-#         for key, value in self.items():
-#             summary_data["name"].append(key)
-#             summary_data["intents"].append(partition_info["intents"])
-#             summary_data["spw_name"].append(
-#                 partition_info["spectral_window_name"]
-#             )
-#             summary_data["polarization"].append(value.polarization.values)
-#             summary_data["scan_name"].append(partition_info["scan_name"])
-#             data_name = value.attrs["data_groups"][data_group]["correlated_data"]
-
-#             if "VISIBILITY" in data_name:
-#                 center_name = "FIELD_PHASE_CENTER"
-
-#             if "SPECTRUM" in data_name:
-#                 center_name = "FIELD_REFERENCE_CENTER"
-
-#             summary_data["shape"].append(value[data_name].shape)
-
-#             summary_data["field_name"].append(
-#                 partition_info["field_name"]
-#             )
-#             summary_data["source_name"].append(
-#                 partition_info["source_name"]
-#             )
-
-#             summary_data["line_name"].append(partition_info["line_name"])
-
-#             summary_data["start_frequency"].append(
-#                 to_list(value["frequency"].values)[0]
-#             )
-#             summary_data["end_frequency"].append(to_list(value["frequency"].values)[-1])
-
-#             if (
-#                 value[data_name].attrs["field_and_source_xds"].attrs["type"]
-#                 == "field_and_source_ephemeris"
-#             ):
-#                 summary_data["field_coords"].append("Ephemeris")
-#             # elif (
-#             #     "time"
-#             #     in value[data_name].attrs["field_and_source_xds"][center_name].coords
-#             # ):
-#             elif (
-#                 value[data_name]
-#                 .attrs["field_and_source_xds"][center_name]["field_name"]
-#                 .size
-#                 > 1
-#             ):
-#                 summary_data["field_coords"].append("Multi-Phase-Center")
-#             else:
-#                 ra_dec_rad = (
-#                     value[data_name]
-#                     .attrs["field_and_source_xds"][center_name]
-#                     .values[0, :]
-#                 )
-#                 frame = (
-#                     value[data_name]
-#                     .attrs["field_and_source_xds"][center_name]
-#                     .attrs["frame"]
-#                     .lower()
-#                 )
-
-#                 coord = SkyCoord(
-#                     ra=ra_dec_rad[0] * u.rad, dec=ra_dec_rad[1] * u.rad, frame=frame
-#                 )
-
-#                 summary_data["field_coords"].append(
-#                     [
-#                         frame,
-#                         coord.ra.to_string(unit=u.hour, precision=2),
-#                         coord.dec.to_string(unit=u.deg, precision=2),
-#                     ]
-#                 )
-
-#         summary_df = pd.DataFrame(summary_data)
-#         return summary_df
-
-#     def _get_ps_freq_axis(self):
-
-#         spw_ids = []
-#         freq_axis_list = []
-#         frame = self.get(0).frequency.attrs["observer"]
-#         for ms_xds in self.values():
-#             assert (
-#                 frame == ms_xds.frequency.attrs["observer"]
-#             ), "Frequency reference frame not consistent in Processing Set."
-#             if ms_xds.frequency.attrs["spectral_window_id"] not in spw_ids:
-#                 spw_ids.append(ms_xds.frequency.attrs["spectral_window_id"])
-#                 freq_axis_list.append(ms_xds.frequency)
-
-#         freq_axis = xr.concat(freq_axis_list, dim="frequency").sortby("frequency")
-#         return freq_axis
-
-#     def _get_ps_max_dims(self):
-#         max_dims = None
-#         for ms_xds in self.values():
-#             if max_dims is None:
-#                 max_dims = dict(ms_xds.sizes)
-#             else:
-#                 for dim_name, size in ms_xds.sizes.items():
-#                     if dim_name in max_dims:
-#                         if max_dims[dim_name] < size:
-#                             max_dims[dim_name] = size
-#                     else:
-#                         max_dims[dim_name] = size
-#         return max_dims
-
-#     def get(self, id):
-#         return self[list(self.keys())[id]]
-
-#     def sel(self, string_exact_match: bool = True, query: str = None, **kwargs):
-#         """
-#         Select a subset of the Processing Set based on specified criteria.
-
-#         This method allows filtering the Processing Set by matching column names and values
-#         or by applying a Pandas query string. The selection criteria can target various
-#         attributes of the Measurement Sets such as intents, polarization, spectral window names, etc.
-
-#         Note
-#         ----
-#         This selection does not modify the actual data within the Measurement Sets. For example, if
-#         a Measurement Set has `field_name=['field_0','field_10','field_08']` and `ps.query(field_name='field_0')`
-#         is invoked, the resulting subset will still contain the original list `['field_0','field_10','field_08']`.
-
-#         Parameters
-#         ----------
-#         string_exact_match : bool, optional
-#             If `True`, string matching will require exact matches for string and string list columns.
-#             If `False`, partial matches are allowed. Default is `True`.
-#         query : str, optional
-#             A Pandas query string to apply additional filtering. Default is `None`.
-#         **kwargs : dict
-#             Keyword arguments representing column names and their corresponding values to filter the Processing Set.
-
-#         Returns
-#         -------
-#         ProcessingSet
-#             A new `ProcessingSet` instance containing only the Measurement Sets that match the selection criteria.
-
-#         Examples
-#         --------
-#         >>> # Select all MSs with intents 'OBSERVE_TARGET#ON_SOURCE' and polarization 'RR' or 'LL'
-#         >>> selected_ps = ps.query(intents='OBSERVE_TARGET#ON_SOURCE', polarization=['RR', 'LL'])
-
-#         >>> # Select all MSs with start_frequency greater than 100 GHz and less than 200 GHz
-#         >>> selected_ps = ps.query(query='start_frequency > 100e9 AND end_frequency < 200e9')
-#         """
-#         import numpy as np
-
-#         def select_rows(df, col, sel_vals, string_exact_match):
-#             def check_selection(row_val):
-#                 row_val = to_list(
-#                     row_val
-#                 )  # make sure that it is a list so that we can iterate over it.
-
-#                 for rw in row_val:
-#                     for s in sel_vals:
-#                         if string_exact_match:
-#                             if rw == s:
-#                                 return True
-#                         else:
-#                             if s in rw:
-#                                 return True
-#                 return False
-
-#             return df[df[col].apply(check_selection)]
-
-#         summary_table = self.summary()
-#         for key, value in kwargs.items():
-#             value = to_list(value)  # make sure value is a list.
-
-#             if len(value) == 1 and isinstance(value[0], slice):
-#                 summary_table = summary_table[
-#                     summary_table[key].between(value[0].start, value[0].stop)
-#                 ]
-#             else:
-#                 summary_table = select_rows(
-#                     summary_table, key, value, string_exact_match
-#                 )
-
-#         if query is not None:
-#             summary_table = summary_table.query(query)
-
-#         sub_ps = ProcessingSet()
-#         for key, val in self.items():
-#             if key in summary_table["name"].values:
-#                 sub_ps[key] = val
-
-#         return sub_ps
-
-#     def ms_sel(self, **kwargs):
-#         """
-#         Select a subset of the Processing Set by applying the `xarray.Dataset.sel` method to each Measurement Set.
-
-#         This method allows for selection based on label-based indexing for each dimension of the datasets.
-
-#         Parameters
-#         ----------
-#         **kwargs : dict
-#             Keyword arguments representing dimension names and the labels to select along those dimensions.
-#             These are passed directly to the `xarray.Dataset.sel <https://docs.xarray.dev/en/latest/generated/xarray.Dataset.sel.html>`__ method.
-
-#         Returns
-#         -------
-#         ProcessingSet
-#             A new `ProcessingSet` instance containing the selected subsets of each Measurement Set.
-#         """
-#         sub_ps = ProcessingSet()
-#         for key, val in self.items():
-#             sub_ps[key] = val.sel(kwargs)
-#         return sub_ps
-
-#     def ms_isel(self, **kwargs):
-#         """
-#         Select a subset of the Processing Set by applying the `isel` method to each Measurement Set.
-
-#         This method allows for selection based on integer-based indexing for each dimension of the datasets.
-
-#         Parameters
-#         ----------
-#         **kwargs : dict
-#             Keyword arguments representing dimension names and the integer indices to select along those dimensions.
-#             These are passed directly to the `xarray.Dataset.isel <https://docs.xarray.dev/en/latest/generated/xarray.Dataset.isel.html>`__ method.
-
-#         Returns
-#         -------
-#         ProcessingSet
-#             A new `ProcessingSet` instance containing the selected subsets of each Measurement Set.
-#         """
-#         sub_ps = ProcessingSet()
-#         for key, val in self.items():
-#             sub_ps[key] = val.isel(kwargs)
-#         return sub_ps
-
-#     def to_store(self, store, **kwargs):
-#         """
-#         Write the Processing Set to a Zarr store.
-
-#         This method serializes each Measurement Set within the Processing Set to a separate Zarr group
-#         within the specified store directory. Note that writing to cloud storage is not supported yet.
-
-#         Parameters
-#         ----------
-#         store : str
-#             The filesystem path to the Zarr store directory where the data will be saved.
-#         **kwargs : dict, optional
-#             Additional keyword arguments to be passed to the `xarray.Dataset.to_zarr` method.
-#             Refer to the `xarray.Dataset.to_zarr <https://docs.xarray.dev/en/latest/generated/xarray.Dataset.to_zarr.html>`__
-#             for available options.
-
-#         Returns
-#         -------
-#         None
-
-#         Raises
-#         ------
-#         OSError
-#             If the specified store path is invalid or not writable.
-
-#         Examples
-#         --------
-#         >>> # Save the Processing Set to a local Zarr store
-#         >>> ps.to_store('/path/to/zarr_store')
-#         """
-#         import os
-
-#         for key, value in self.items():
-#             value.to_store(os.path.join(store, key), **kwargs)
-
-#     def get_combined_field_and_source_xds(self, data_group="base"):
-#         """
-#         Combine all non-ephemeris `field_and_source_xds` datasets from a Processing Set for a datagroup into a single dataset.
-
-#         Parameters
-#         ----------
-#         data_group : str, optional
-#             The data group to process. Default is "base".
-
-#         Returns
-#         -------
-#         xarray.Dataset
-#             combined_field_and_source_xds: Combined dataset for standard fields.
-
-#         Raises
-#         ------
-#         ValueError
-#             If the `field_and_source_xds` attribute is missing or improperly formatted in any Measurement Set.
-#         """
-
-#         combined_field_and_source_xds = xr.Dataset()
-#         for ms_name, ms_xds in self.items():
-#             correlated_data_name = ms_xds.attrs["data_groups"][data_group][
-#                 "correlated_data"
-#             ]
-
-#             field_and_source_xds = (
-#                 ms_xds[correlated_data_name]
-#                 .attrs["field_and_source_xds"]
-#                 .copy(deep=True)
-#             )
-
-#             if not field_and_source_xds.attrs["type"] == "field_and_source_ephemeris":
-
-#                 if (
-#                     "line_name" in field_and_source_xds.coords
-#                 ):  # Not including line info since it is a function of spw.
-#                     field_and_source_xds = field_and_source_xds.drop_vars(
-#                         ["LINE_REST_FREQUENCY", "LINE_SYSTEMIC_VELOCITY"],
-#                         errors="ignore",
-#                     )
-#                     del field_and_source_xds["line_name"]
-#                     del field_and_source_xds["line_label"]
-
-#                 if len(combined_field_and_source_xds.data_vars) == 0:
-#                     combined_field_and_source_xds = field_and_source_xds
-#                 else:
-#                     combined_field_and_source_xds = xr.concat(
-#                         [combined_field_and_source_xds, field_and_source_xds],
-#                         dim="field_name",
-#                     )
-
-#         if (len(combined_field_and_source_xds.data_vars) > 0) and (
-#             "FIELD_PHASE_CENTER" in combined_field_and_source_xds
-#         ):
-#             combined_field_and_source_xds = (
-#                 combined_field_and_source_xds.drop_duplicates("field_name")
-#             )
-
-#             combined_field_and_source_xds["MEAN_PHASE_CENTER"] = (
-#                 combined_field_and_source_xds["FIELD_PHASE_CENTER"].mean(
-#                     dim=["field_name"]
-#                 )
-#             )
-
-#             ra1 = (
-#                 combined_field_and_source_xds["FIELD_PHASE_CENTER"]
-#                 .sel(sky_dir_label="ra")
-#                 .values
-#             )
-#             dec1 = (
-#                 combined_field_and_source_xds["FIELD_PHASE_CENTER"]
-#                 .sel(sky_dir_label="dec")
-#                 .values
-#             )
-#             ra2 = (
-#                 combined_field_and_source_xds["MEAN_PHASE_CENTER"]
-#                 .sel(sky_dir_label="ra")
-#                 .values
-#             )
-#             dec2 = (
-#                 combined_field_and_source_xds["MEAN_PHASE_CENTER"]
-#                 .sel(sky_dir_label="dec")
-#                 .values
-#             )
-
-#             from xradio._utils.coord_math import haversine
-
-#             distance = haversine(ra1, dec1, ra2, dec2)
-#             min_index = distance.argmin()
-
-#             combined_field_and_source_xds.attrs["center_field_name"] = (
-#                 combined_field_and_source_xds.field_name[min_index].values
-#             )
-
-#         return combined_field_and_source_xds
-
-
-#     def get_combined_field_and_source_xds_ephemeris(self, data_group="base"):
-#         """
-#         Combine all ephemeris `field_and_source_xds` datasets from a Processing Set for a datagroup into a single dataset.
-
-#         Parameters
-#         ----------
-#         data_group : str, optional
-#             The data group to process. Default is "base".
-
-#         Returns
-#         -------
-#         xarray.Dataset
-#             - combined_ephemeris_field_and_source_xds: Combined dataset for ephemeris fields.
-
-#         Raises
-#         ------
-#         ValueError
-#             If the `field_and_source_xds` attribute is missing or improperly formatted in any Measurement Set.
-#         """
-
-#         combined_ephemeris_field_and_source_xds = xr.Dataset()
-#         for ms_name, ms_xds in self.items():
-
-#             correlated_data_name = ms_xds.attrs["data_groups"][data_group][
-#                 "correlated_data"
-#             ]
-
-#             field_and_source_xds = (
-#                 ms_xds[correlated_data_name]
-#                 .attrs["field_and_source_xds"]
-#                 .copy(deep=True)
-#             )
-
-#             if field_and_source_xds.attrs["type"] == "field_and_source_ephemeris":
-
-#                 if (
-#                     "line_name" in field_and_source_xds.coords
-#                 ):  # Not including line info since it is a function of spw.
-#                     field_and_source_xds = field_and_source_xds.drop_vars(
-#                         ["LINE_REST_FREQUENCY", "LINE_SYSTEMIC_VELOCITY"],
-#                         errors="ignore",
-#                     )
-#                     del field_and_source_xds["line_name"]
-#                     del field_and_source_xds["line_label"]
-
-#                 from xradio.measurement_set._utils._msv2.msv4_sub_xdss import (
-#                     interpolate_to_time,
-#                 )
-
-#                 if "time_ephemeris" in field_and_source_xds:
-#                     field_and_source_xds = interpolate_to_time(
-#                         field_and_source_xds,
-#                         field_and_source_xds.time,
-#                         "field_and_source_xds",
-#                         "time_ephemeris",
-#                     )
-#                     del field_and_source_xds["time_ephemeris"]
-#                     field_and_source_xds = field_and_source_xds.rename(
-#                         {"time_ephemeris": "time"}
-#                     )
-
-#                 if "OBSERVER_POSITION" in field_and_source_xds:
-#                     field_and_source_xds = field_and_source_xds.drop_vars(
-#                         ["OBSERVER_POSITION"], errors="ignore"
-#                     )
-
-#                 if len(combined_ephemeris_field_and_source_xds.data_vars) == 0:
-#                     combined_ephemeris_field_and_source_xds = field_and_source_xds
-#                 else:
-
-#                     combined_ephemeris_field_and_source_xds = xr.concat(
-#                         [combined_ephemeris_field_and_source_xds, field_and_source_xds],
-#                         dim="time",
-#                     )
-
-#         if (len(combined_ephemeris_field_and_source_xds.data_vars) > 0) and (
-#             "FIELD_PHASE_CENTER" in combined_ephemeris_field_and_source_xds
-#         ):
-
-#             from xradio._utils.coord_math import wrap_to_pi
-
-#             offset = (
-#                 combined_ephemeris_field_and_source_xds["FIELD_PHASE_CENTER"]
-#                 - combined_ephemeris_field_and_source_xds["SOURCE_LOCATION"]
-#             )
-#             combined_ephemeris_field_and_source_xds["FIELD_OFFSET"] = xr.DataArray(
-#                 wrap_to_pi(offset.sel(sky_pos_label=["ra", "dec"])).values,
-#                 dims=["time", "sky_dir_label"],
-#             )
-#             combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].attrs = (
-#                 combined_ephemeris_field_and_source_xds["FIELD_PHASE_CENTER"].attrs
-#             )
-#             combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].attrs["units"] = (
-#                 combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].attrs["units"][
-#                     :2
-#                 ]
-#             )
-
-#             ra1 = (
-#                 combined_ephemeris_field_and_source_xds["FIELD_OFFSET"]
-#                 .sel(sky_dir_label="ra")
-#                 .values
-#             )
-#             dec1 = (
-#                 combined_ephemeris_field_and_source_xds["FIELD_OFFSET"]
-#                 .sel(sky_dir_label="dec")
-#                 .values
-#             )
-#             ra2 = 0.0
-#             dec2 = 0.0
-
-#             from xradio._utils.coord_math import haversine
-
-#             distance = haversine(ra1, dec1, ra2, dec2)
-#             min_index = distance.argmin()
-
-#             combined_ephemeris_field_and_source_xds.attrs["center_field_name"] = (
-#                 combined_ephemeris_field_and_source_xds.field_name[min_index].values
-#             )
-
-#         return combined_ephemeris_field_and_source_xds
-
-#     def plot_phase_centers(self, label_all_fields=False, data_group="base"):
-#         """
-#         Plot the phase center locations of all fields in the Processing Set.
-
-#         This method is primarily used for visualizing mosaics. It generates scatter plots of
-#         the phase center coordinates for both standard and ephemeris fields. The central field
-#         is highlighted in red based on the closest phase center calculation.
-
-#         Parameters
-#         ----------
-#         label_all_fields : bool, optional
-#             If `True`, all fields will be labeled on the plot. Default is `False`.
-#         data_group : str, optional
-#             The data group to use for processing. Default is "base".
-
-#         Returns
-#         -------
-#         None
-
-#         Raises
-#         ------
-#         ValueError
-#             If the combined datasets are empty or improperly formatted.
-#         """
-#         combined_field_and_source_xds = self.get_combined_field_and_source_xds(
-#             data_group
-#         )
-#         combined_ephemeris_field_and_source_xds = (
-#             self.get_combined_field_and_source_xds_ephemeris(data_group)
-#         )
-#         from matplotlib import pyplot as plt
-
-#         if (len(combined_field_and_source_xds.data_vars) > 0) and (
-#             "FIELD_PHASE_CENTER" in combined_field_and_source_xds
-#         ):
-#             plt.figure()
-#             plt.title("Field Phase Center Locations")
-#             plt.scatter(
-#                 combined_field_and_source_xds["FIELD_PHASE_CENTER"].sel(
-#                     sky_dir_label="ra"
-#                 ),
-#                 combined_field_and_source_xds["FIELD_PHASE_CENTER"].sel(
-#                     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
-#             )
-#             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,
-#             )
-#             plt.xlabel("RA (rad)")
-#             plt.ylabel("DEC (rad)")
-#             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()
-#             plt.title(
-#                 "Offset of Field Phase Center from Source Location (Ephemeris Data)"
-#             )
-#             plt.scatter(
-#                 combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].sel(
-#                     sky_dir_label="ra"
-#                 ),
-#                 combined_ephemeris_field_and_source_xds["FIELD_OFFSET"].sel(
-#                     sky_dir_label="dec"
-#                 ),
-#             )
-
-#             center_field_name = combined_ephemeris_field_and_source_xds.attrs[
-#                 "center_field_name"
-#             ]
-
-#             combined_ephemeris_field_and_source_xds = (
-#                 combined_ephemeris_field_and_source_xds.set_xindex("field_name")
-#             )
-
-#             center_field = combined_ephemeris_field_and_source_xds.sel(
-#                 field_name=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,
-#             )
-#             plt.xlabel("RA Offset (rad)")
-#             plt.ylabel("DEC Offset (rad)")
-#             plt.legend()
-#             plt.show()
-
-#     def get_combined_antenna_xds(self):
-#         """
-#         Combine the `antenna_xds` datasets from all Measurement Sets into a single dataset.
-
-#         This method concatenates the antenna datasets from each Measurement Set along the 'antenna_name' dimension.
-
-#         Returns
-#         -------
-#         xarray.Dataset
-#             A combined `xarray.Dataset` containing antenna information from all Measurement Sets.
-
-#         Raises
-#         ------
-#         ValueError
-#             If antenna datasets are missing required variables or improperly formatted.
-#         """
-#         combined_antenna_xds = xr.Dataset()
-#         for cor_name, ms_xds in self.items():
-#             antenna_xds = ms_xds.antenna_xds.copy(deep=True)
-
-#             if len(combined_antenna_xds.data_vars) == 0:
-#                 combined_antenna_xds = antenna_xds
-#             else:
-#                 combined_antenna_xds = xr.concat(
-#                     [combined_antenna_xds, antenna_xds],
-#                     dim="antenna_name",
-#                     data_vars="minimal",
-#                     coords="minimal",
-#                 )
-
-#         # ALMA WVR antenna_xds data has a NaN value for the antenna receptor angle.
-#         if "ANTENNA_RECEPTOR_ANGLE" in combined_antenna_xds.data_vars:
-#             combined_antenna_xds = combined_antenna_xds.dropna("antenna_name")
-
-#         combined_antenna_xds = combined_antenna_xds.drop_duplicates("antenna_name")
-
-#         return combined_antenna_xds
-
-#     def plot_antenna_positions(self):
-#         """
-#         Plot the antenna positions of all antennas in the Processing Set.
-
-#         This method generates three scatter plots displaying the antenna positions in different planes:
-#         - X vs Y
-#         - X vs Z
-#         - Y vs Z
-
-#         Parameters
-#         ----------
-#         None
-
-#         Returns
-#         -------
-#         None
-
-#         Raises
-#         ------
-#         ValueError
-#             If the combined antenna dataset is empty or missing required coordinates.
-#         """
-#         combined_antenna_xds = self.get_combined_antenna_xds()
-#         from matplotlib import pyplot as plt
-
-#         plt.figure()
-#         plt.title("Antenna Positions")
-#         plt.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()
-
-#         plt.figure()
-#         plt.title("Antenna Positions")
-#         plt.scatter(
-#             combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="x"),
-#             combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="z"),
-#         )
-#         plt.xlabel("x (m)")
-#         plt.ylabel("z (m)")
-#         plt.show()
-
-#         plt.figure()
-#         plt.title("Antenna Positions")
-#         plt.scatter(
-#             combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="y"),
-#             combined_antenna_xds["ANTENNA_POSITION"].sel(cartesian_pos_label="z"),
-#         )
-#         plt.xlabel("y (m)")
-#         plt.ylabel("z (m)")
-#         plt.show()