xradio 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

xradio/measurement_set/__init__.py

@@ -4,7 +4,7 @@ convert, and retrieve information from Processing Set and Measurement Sets nodes
 Processing Set DataTree
 """
 
-import toolviper.utils.logger as _logger
+import warnings
 
 from .processing_set_xdt import ProcessingSetXdt
 from .open_processing_set import open_processing_set
@@ -27,9 +27,10 @@ try:
         estimate_conversion_memory_and_cores,
     )
 except ModuleNotFoundError as exc:
-    _logger.warning(
-        "Could not import the function to convert from MSv2 to MSv4. "
-        f"That functionality will not be available. Details: {exc}"
+    warnings.warn(
+        f"Could not import the function to convert from MSv2 to MSv4. "
+        f"That functionality will not be available. Details: {exc}",
+        UserWarning,
     )
 else:
     __all__.extend(

xradio/measurement_set/_utils/_msv2/_tables/read.py

@@ -93,9 +93,12 @@ def convert_mjd_time(rawtimes: np.ndarray) -> np.ndarray:
     np.ndarray
         times converted to pandas reference and datetime type
     """
+
+    print("^^^^^^^", rawtimes, MJD_DIF_UNIX, SECS_IN_DAY)
     times_reref = pd.to_datetime(
         (rawtimes - MJD_DIF_UNIX) * SECS_IN_DAY, unit="s"
     ).values
+    print("^^^^^^^", times_reref)
 
     return times_reref
 
@@ -160,7 +163,7 @@ def make_taql_where_between_min_max(
     if min_max_range is None:
         taql = None
     else:
-        (min_val, max_val) = min_max_range
+        min_val, max_val = min_max_range
         taql = f"where {colname} >= {min_val} AND {colname} <= {max_val}"
 
     return taql
@@ -226,7 +229,7 @@ def find_projected_min_max_array(
     """Does the min/max checks and search for find_projected_min_max_table()"""
 
     sorted_array = np.sort(array)
-    (range_min, range_max) = min_max
+    range_min, range_max = min_max
     if len(sorted_array) < 2:
         tol = np.finfo(sorted_array.dtype).eps * 4
     else:
@@ -891,7 +894,8 @@ def raw_col_data_to_coords_vars(
 
     if col in timecols:
         if col == "MJD":
-            data = convert_mjd_time(data).astype("float64") / 1e9
+            # data = convert_mjd_time(data).astype("float64") / 1e9
+            data = convert_mjd_time(data).astype("datetime64[ns]").view("int64") / 1e9
         else:
             try:
                 data = convert_casacore_time(data, False)

xradio/measurement_set/_utils/_msv2/conversion.py

@@ -1017,7 +1017,7 @@ def convert_and_write_partition(
     add_reshaping_indices: bool = False,
     storage_backend="zarr",
     parallel_mode: str = "none",
-    overwrite: bool = False,
+    persistence_mode: str = "w-",
 ):
     """_summary_
 
@@ -1057,8 +1057,8 @@ def convert_and_write_partition(
         _description_, by default "zarr"
     parallel_mode : _type_, optional
         _description_
-    overwrite : bool, optional
-        _description_, by default False
+    persistence_mode: str = "w-",
+        _description_, by default "w-"
 
     Returns
     -------
@@ -1368,11 +1368,6 @@ def convert_and_write_partition(
             pathlib.Path(in_file).name.replace(".ms", "") + "_" + str(ms_v4_id),
         )
 
-        if overwrite:
-            mode = "w"
-        else:
-            mode = "w-"
-
         if is_single_dish:
             xds.attrs["type"] = "spectrum"
             xds = xds.drop_vars("UVW")
@@ -1416,7 +1411,9 @@ def convert_and_write_partition(
             ms_xdt["/phased_array_xds"] = phased_array_xds
 
         if storage_backend == "zarr":
-            ms_xdt.to_zarr(store=os.path.join(out_file, ms_v4_name), mode=mode)
+            ms_xdt.to_zarr(
+                store=os.path.join(out_file, ms_v4_name), mode=persistence_mode
+            )
         elif storage_backend == "netcdf":
             # xds.to_netcdf(path=file_name+"/MAIN", mode=mode) #Does not work
             raise

xradio/measurement_set/_utils/_msv2/create_field_and_source_xds.py

@@ -285,6 +285,7 @@ def extract_ephemeris_info(
     # Metadata has to be fixed manually. Alternatively, issues like
     # UNIT/QuantumUnits issue could be handled in convert_generic_xds_to_xradio_schema,
     # but for now preferring not to pollute that function.
+
     time_ephemeris_dim = ["time_ephemeris"]
     to_new_data_variables = {
         # mandatory: SOURCE_RADIAL_VELOCITY

xradio/measurement_set/_utils/_msv2/msv4_sub_xdss.py

@@ -27,7 +27,6 @@ from xradio.measurement_set._utils._msv2._tables.read import (
     table_has_column,
 )
 
-
 standard_time_coord_attrs = make_time_measure_attrs(time_format="unix")
 
 
@@ -81,6 +80,7 @@ def rename_and_interpolate_to_time(
     )
 
     # rename the time_* axis to time.
+
     time_coord = {"time": (time_initial_name, interp_time.data)}
     renamed_time_xds = interpolated_xds.assign_coords(time_coord)
     renamed_time_xds.coords["time"].attrs.update(standard_time_coord_attrs)

xradio/measurement_set/_utils/_utils/interpolate.py

@@ -41,6 +41,10 @@ def interpolate_to_time(
             method = "linear"
         else:
             method = "nearest"
+
+        # print("xds before interp:",xds.NORTH_POLE_ANGULAR_DISTANCE.values, xds[time_name].values)
+        # print("interp_time data:",interp_time,interp_time.data)
+        # print("method:",method)
         xds = xds.interp(
             {time_name: interp_time.data}, method=method, assume_sorted=True
         )
@@ -56,5 +60,6 @@ def interpolate_to_time(
             f"{message_prefix}: interpolating the time coordinate "
             f"from {points_before} to {points_after} points"
         )
+        # print("xds after interp:",xds.NORTH_POLE_ANGULAR_DISTANCE.values, xds[time_name].values)
 
     return xds

xradio/measurement_set/_utils/_utils/partition_attrs.py

@@ -2,7 +2,6 @@ from typing import Dict, TypedDict, Union
 
 import xarray as xr
 
-
 PartitionIds = TypedDict(
     "PartitionIds",
     {

xradio/measurement_set/convert_msv2_to_processing_set.py

@@ -68,7 +68,7 @@ def convert_msv2_to_processing_set(
     add_reshaping_indices: bool = False,
     storage_backend: Literal["zarr", "netcdf"] = "zarr",
     parallel_mode: Literal["none", "partition", "time"] = "none",
-    overwrite: bool = False,
+    persistence_mode: str = "w-",
 ):
     """Convert a Measurement Set v2 into a Processing Set of Measurement Set v4.
 
@@ -110,8 +110,11 @@ def convert_msv2_to_processing_set(
         Choose whether to use Dask to execute conversion in parallel, by default "none" and conversion occurs serially.
         The option "partition", parallelises the conversion over partitions specified by `partition_scheme`. The option "time" can only be used for phased array interferometers where there are no partitions
         in the MS v2; instead the MS v2 is parallelised along the time dimension and can be controlled by `main_chunksize`.
-    overwrite : bool, optional
-        Whether to overwrite an existing processing set, by default False.
+    persistence_mode : str, optional
+        “w” means create (overwrite if exists);
+        “w-” means create (fail if exists);
+        “a” means override all existing variables including dimension coordinates (create if does not exist); Use this mode if you want to add to an existing Processing Set.
+        The default is "w-".
     """
 
     # Create empty data tree
@@ -122,10 +125,7 @@ def convert_msv2_to_processing_set(
     if not str(out_file).endswith("ps.zarr"):
         out_file += ".ps.zarr"
 
-    if overwrite:
-        ps_dt.to_zarr(store=out_file, mode="w")
-    else:
-        ps_dt.to_zarr(store=out_file, mode="w-")
+    ps_dt.to_zarr(store=out_file, mode=persistence_mode)
 
     # Check `parallel_mode` is valid
     try:
@@ -192,7 +192,7 @@ def convert_msv2_to_processing_set(
                     add_reshaping_indices=add_reshaping_indices,
                     compressor=compressor,
                     parallel_mode=parallel_mode,
-                    overwrite=overwrite,
+                    persistence_mode=persistence_mode,
                 )
             )
         else:
@@ -214,7 +214,7 @@ def convert_msv2_to_processing_set(
                 add_reshaping_indices=add_reshaping_indices,
                 compressor=compressor,
                 parallel_mode=parallel_mode,
-                overwrite=overwrite,
+                persistence_mode=persistence_mode,
             )
             end_time = time.time()
             logger.debug(

xradio/measurement_set/load_processing_set.py

@@ -1,8 +1,6 @@
 import os
 from typing import Dict, Union
-import dask
 import xarray as xr
-import s3fs
 
 
 def load_processing_set(
@@ -48,6 +46,8 @@ def load_processing_set(
         In memory representation of processing set using xr.DataTree.
     """
     from xradio._utils.zarr.common import _get_file_system_and_items
+    import dask
+    import s3fs
 
     file_system, ms_store_list = _get_file_system_and_items(ps_store)
 

xradio/measurement_set/measurement_set_xdt.py

@@ -5,7 +5,8 @@ from typing import Any, Union
 import numpy as np
 import xarray as xr
 
-from xradio._utils.list_and_array import to_list
+from xradio._utils.list_and_array import to_python_type
+from xradio._utils.xarray_helpers import get_data_group_name, create_new_data_group
 
 MS_DATASET_TYPES = {"visibility", "spectrum", "radiometer"}
 
@@ -151,11 +152,7 @@ class MeasurementSetXdt:
         if self._xdt.attrs.get("type") not in MS_DATASET_TYPES:
             raise InvalidAccessorLocation(f"{self._xdt.path} is not a MSv4 node.")
 
-        if data_group_name is None:
-            if "base" in self._xdt.attrs["data_groups"]:
-                data_group_name = "base"
-            else:
-                data_group_name = list(self._xdt.attrs["data_groups"].keys())[0]
+        data_group_name = get_data_group_name(self._xdt, data_group_name)
 
         field_and_source_xds_name = self._xdt.attrs["data_groups"][data_group_name][
             "field_and_source"
@@ -188,16 +185,12 @@ class MeasurementSetXdt:
                 f"{self._xdt.path} is not a MSv4 node (type {self._xdt.attrs.get('type')}."
             )
 
-        if data_group_name is None:
-            if "base" in self._xdt.attrs["data_groups"]:
-                data_group_name = "base"
-            else:
-                data_group_name = list(self._xdt.attrs["data_groups"].keys())[0]
+        data_group_name = get_data_group_name(self._xdt, data_group_name)
 
         field_and_source_xds = self._xdt.xr_ms.get_field_and_source_xds(data_group_name)
 
         if "line_name" in field_and_source_xds.coords:
-            line_name = to_list(
+            line_name = to_python_type(
                 np.unique(np.ravel(field_and_source_xds.line_name.values))
             )
         else:
@@ -218,10 +211,14 @@ class MeasurementSetXdt:
         partition_info = {
             "spectral_window_name": self._xdt.frequency.attrs["spectral_window_name"],
             "spectral_window_intents": spw_intent,
-            "field_name": to_list(np.unique(field_and_source_xds.field_name.values)),
-            "polarization_setup": to_list(self._xdt.polarization.values),
-            "scan_name": to_list(np.unique(self._xdt.scan_name.values)),
-            "source_name": to_list(np.unique(field_and_source_xds.source_name.values)),
+            "field_name": to_python_type(
+                np.unique(field_and_source_xds.field_name.values)
+            ),
+            "polarization_setup": to_python_type(self._xdt.polarization.values),
+            "scan_name": to_python_type(np.unique(self._xdt.scan_name.values)),
+            "source_name": to_python_type(
+                np.unique(field_and_source_xds.source_name.values)
+            ),
             "scan_intents": scan_intents,
             "line_name": line_name,
             "data_group_name": data_group_name,
@@ -232,13 +229,7 @@ class MeasurementSetXdt:
     def add_data_group(
         self,
         new_data_group_name: str,
-        correlated_data: str = None,
-        weight: str = None,
-        flag: str = None,
-        uvw: str = None,
-        field_and_source_xds: str = None,
-        date_time: str = None,
-        description: str = None,
+        new_data_group: dict = {},
         data_group_dv_shared_with: str = None,
     ) -> xr.DataTree:
         """Adds a data group to the MSv4 DataTree, grouping the given data, weight, flag, etc. variables
@@ -248,20 +239,8 @@ class MeasurementSetXdt:
         ----------
         new_data_group_name : str
             _description_
-        correlated_data : str, optional
-            _description_, by default None
-        weights : str, optional
-            _description_, by default None
-        flag : str, optional
-            _description_, by default None
-        uvw : str, optional
-            _description_, by default None
-        field_and_source_xds : str, optional
-            _description_, by default None
-        date_time : str, optional
-            _description_, by default None
-        description : str, optional
-            _description_, by default None
+        new_data_group : dict
+            _description_
         data_group_dv_shared_with : str, optional
             _description_, by default "base"
 
@@ -271,63 +250,74 @@ class MeasurementSetXdt:
             MSv4 DataTree with the new group added
         """
 
-        if data_group_dv_shared_with is None:
-            data_group_dv_shared_with = self._xdt.xr_ms._get_default_data_group_name()
-        default_data_group = self._xdt.attrs["data_groups"][data_group_dv_shared_with]
-
-        new_data_group = {}
-
-        if correlated_data is None:
-            correlated_data = default_data_group["correlated_data"]
-        new_data_group["correlated_data"] = correlated_data
-        assert (
-            correlated_data in self._xdt.ds.data_vars
-        ), f"Data variable {correlated_data} not found in dataset."
-
-        if weight is None:
-            weight = default_data_group["weight"]
-        new_data_group["weight"] = weight
-        assert (
-            weight in self._xdt.ds.data_vars
-        ), f"Data variable {weight} not found in dataset."
-
-        if flag is None:
-            flag = default_data_group["flag"]
-        new_data_group["flag"] = flag
-        assert (
-            flag in self._xdt.ds.data_vars
-        ), f"Data variable {flag} not found in dataset."
-
-        if self._xdt.attrs["type"] == "visibility":
-            if uvw is None:
-                uvw = default_data_group["uvw"]
-            new_data_group["uvw"] = uvw
-            assert (
-                uvw in self._xdt.ds.data_vars
-            ), f"Data variable {uvw} not found in dataset."
-
-        if field_and_source_xds is None:
-            field_and_source_xds = default_data_group["field_and_source"]
-        new_data_group["field_and_source"] = field_and_source_xds
-        assert (
-            field_and_source_xds in self._xdt.children
-        ), f"Data variable {field_and_source_xds} not found in dataset."
-
-        if date_time is None:
-            date_time = datetime.datetime.now(datetime.timezone.utc).isoformat()
-        new_data_group["date"] = date_time
-
-        if description is None:
-            description = ""
-        new_data_group["description"] = description
+        if self._xdt.attrs.get("type") not in MS_DATASET_TYPES:
+            raise InvalidAccessorLocation(
+                f"{self._xdt.path} is not a MSv4 node (type {self._xdt.attrs.get('type')}."
+            )
+
+        new_data_group_name, new_data_group = create_new_data_group(
+            self._xdt,
+            "msv4",
+            new_data_group_name,
+            new_data_group,
+            data_group_dv_shared_with=data_group_dv_shared_with,
+        )
 
         self._xdt.attrs["data_groups"][new_data_group_name] = new_data_group
-
         return self._xdt
 
-    def _get_default_data_group_name(self):
-        if "base" in self._xdt.attrs["data_groups"]:
-            data_group_name = "base"
-        else:
-            data_group_name = list(self._xdt.attrs["data_groups"].keys())[0]
-        return data_group_name
+        # data_group_dv_shared_with = get_data_group_name(
+        #     self._xdt, data_group_dv_shared_with
+        # )
+
+        # default_data_group = self._xdt.attrs["data_groups"][data_group_dv_shared_with]
+
+        # new_data_group = {}
+
+        # if correlated_data is None:
+        #     correlated_data = default_data_group["correlated_data"]
+        # new_data_group["correlated_data"] = correlated_data
+        # assert (
+        #     correlated_data in self._xdt.ds.data_vars
+        # ), f"Data variable {correlated_data} not found in dataset."
+
+        # if weight is None:
+        #     weight = default_data_group["weight"]
+        # new_data_group["weight"] = weight
+        # assert (
+        #     weight in self._xdt.ds.data_vars
+        # ), f"Data variable {weight} not found in dataset."
+
+        # if flag is None:
+        #     flag = default_data_group["flag"]
+        # new_data_group["flag"] = flag
+        # assert (
+        #     flag in self._xdt.ds.data_vars
+        # ), f"Data variable {flag} not found in dataset."
+
+        # if self._xdt.attrs["type"] == "visibility":
+        #     if uvw is None:
+        #         uvw = default_data_group["uvw"]
+        #     new_data_group["uvw"] = uvw
+        #     assert (
+        #         uvw in self._xdt.ds.data_vars
+        #     ), f"Data variable {uvw} not found in dataset."
+
+        # if field_and_source_xds is None:
+        #     field_and_source_xds = default_data_group["field_and_source"]
+        # new_data_group["field_and_source"] = field_and_source_xds
+        # assert (
+        #     field_and_source_xds in self._xdt.children
+        # ), f"Data variable {field_and_source_xds} not found in dataset."
+
+        # if date_time is None:
+        #     date_time = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        # new_data_group["date"] = date_time
+
+        # if description is None:
+        #     description = ""
+        # new_data_group["description"] = description
+
+        # self._xdt.attrs["data_groups"][new_data_group_name] = new_data_group
+
+        # return self._xdt

xradio/measurement_set/open_processing_set.py

@@ -1,5 +1,4 @@
 from xradio._utils.zarr.common import _get_file_system_and_items
-import s3fs
 import xarray as xr
 
 
@@ -25,6 +24,7 @@ def open_processing_set(
     """
 
     file_system, ms_store_list = _get_file_system_and_items(ps_store)
+    import s3fs
 
     if isinstance(file_system, s3fs.core.S3FileSystem):
         mapping = s3fs.S3Map(root=ps_store, s3=file_system, check=False)

xradio/measurement_set/processing_set_xdt.py

@@ -2,6 +2,7 @@ import pandas as pd
 from xradio._utils.list_and_array import to_list
 import numpy as np
 import xarray as xr
+from xradio.measurement_set.measurement_set_xdt import get_data_group_name
 
 PS_DATASET_TYPES = {"processing_set"}
 
@@ -38,7 +39,7 @@ class ProcessingSetXdt:
         self.meta = {"summary": {}}
 
     def summary(
-        self, data_group: str | None = None, first_columns: list[str] = None
+        self, data_group_name: str | None = None, first_columns: list[str] = None
     ) -> pd.DataFrame:
         """
         Generate and retrieve a summary of the Processing Set as a data frame.
@@ -53,7 +54,7 @@ class ProcessingSetXdt:
 
         Parameters
         ----------
-        data_group : str, optional
+        data_group_name : str, optional
             The data group to summarize. By default the "base" group
             is used (if found), or otherwise the first group found.
         first_columns : list[str], optional
@@ -73,31 +74,33 @@ 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:
+        def find_data_group_base_or_first(
+            data_group_name: 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 = (
+            if data_group_name is None:
+                data_group_name = (
                     "base"
                     if "base" in first_data_groups
                     else next(iter(first_data_groups))
                 )
-            return data_group
+            return data_group_name
 
         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)
+        data_group_name = find_data_group_base_or_first(data_group_name, self._xdt)
 
-        if data_group in self.meta["summary"]:
-            summary = self.meta["summary"][data_group]
+        if data_group_name in self.meta["summary"]:
+            summary = self.meta["summary"][data_group_name]
         else:
-            self.meta["summary"][data_group] = self._summary(data_group).sort_values(
-                by=["name"], ascending=True
-            )
-            summary = self.meta["summary"][data_group]
+            self.meta["summary"][data_group_name] = self._summary(
+                data_group_name
+            ).sort_values(by=["name"], ascending=True)
+            summary = self.meta["summary"][data_group_name]
 
         if first_columns:
             found_columns = [col for col in first_columns if col in summary.columns]
@@ -187,7 +190,7 @@ class ProcessingSetXdt:
             self.meta["freq_axis"] = freq_axis
             return self.meta["freq_axis"]
 
-    def _summary(self, data_group: str = None):
+    def _summary(self, data_group_name: str = None):
         summary_data = {
             "name": [],
             "scan_intents": [],
@@ -225,7 +228,7 @@ class ProcessingSetXdt:
             )
             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"]
+            data_name = value.attrs["data_groups"][data_group_name]["correlated_data"]
 
             if "VISIBILITY" in data_name:
                 center_name = "FIELD_PHASE_CENTER_DIRECTION"
@@ -253,7 +256,7 @@ class ProcessingSetXdt:
             )
             summary_data["end_frequency"].append(to_list(value["frequency"].values)[-1])
 
-            field_and_source_xds = value.xr_ms.get_field_and_source_xds(data_group)
+            field_and_source_xds = value.xr_ms.get_field_and_source_xds(data_group_name)
 
             if field_and_source_xds.attrs["type"] == "field_and_source_ephemeris":
                 summary_data["field_coords"].append("Ephemeris")
@@ -377,14 +380,16 @@ class ProcessingSetXdt:
 
         return sub_ps_xdt
 
-    def get_combined_field_and_source_xds(self, data_group: str = "base") -> xr.Dataset:
+    def get_combined_field_and_source_xds(
+        self, data_group_name: str = "base"
+    ) -> xr.Dataset:
         """
         Combine all non-ephemeris `field_and_source_xds` datasets from a Processing Set for a data group into a
         single dataset.
 
         Parameters
         ----------
-        data_group : str, optional
+        data_group_name : str, optional
             The data group to process. Default is "base".
 
         Returns
@@ -405,7 +410,9 @@ class ProcessingSetXdt:
 
         combined_field_and_source_xds = xr.Dataset()
         for ms_name, ms_xdt in self._xdt.items():
-            field_and_source_xds = ms_xdt.xr_ms.get_field_and_source_xds(data_group)
+            field_and_source_xds = ms_xdt.xr_ms.get_field_and_source_xds(
+                data_group_name
+            )
 
             if not field_and_source_xds.attrs["type"] == "field_and_source_ephemeris":
 
@@ -474,14 +481,14 @@ class ProcessingSetXdt:
         return combined_field_and_source_xds
 
     def get_combined_field_and_source_xds_ephemeris(
-        self, data_group: str = "base"
+        self, data_group_name: str = "base"
     ) -> xr.Dataset:
         """
         Combine all ephemeris `field_and_source_xds` datasets from a Processing Set for a datagroup into a single dataset.
 
         Parameters
         ----------
-        data_group : str, optional
+        data_group_name : str, optional
             The data group to process. Default is "base".
 
         Returns
@@ -503,7 +510,7 @@ class ProcessingSetXdt:
         combined_ephemeris_field_and_source_xds = xr.Dataset()
         for ms_name, ms_xdt in self._xdt.items():
             field_and_source_xds = field_and_source_xds = (
-                ms_xdt.xr_ms.get_field_and_source_xds(data_group)
+                ms_xdt.xr_ms.get_field_and_source_xds(data_group_name)
             )
 
             if field_and_source_xds.attrs["type"] == "field_and_source_ephemeris":
@@ -599,7 +606,7 @@ class ProcessingSetXdt:
         return combined_ephemeris_field_and_source_xds
 
     def plot_phase_centers(
-        self, label_all_fields: bool = False, data_group: str = "base"
+        self, label_all_fields: bool = False, data_group_name: str = "base"
     ):
         """
         Plot the phase center locations of all fields in the Processing Set.
@@ -612,7 +619,7 @@ class ProcessingSetXdt:
         ----------
         label_all_fields : bool, optional
             If `True`, all fields will be labeled on the plot. Default is `False`.
-        data_group : str, optional
+        data_group_name : str, optional
             The data group to use for processing. Default is "base".
 
         Returns
@@ -641,10 +648,10 @@ class ProcessingSetXdt:
             )
 
         combined_field_and_source_xds = self.get_combined_field_and_source_xds(
-            data_group
+            data_group_name
         )
         combined_ephemeris_field_and_source_xds = (
-            self.get_combined_field_and_source_xds_ephemeris(data_group)
+            self.get_combined_field_and_source_xds_ephemeris(data_group_name)
         )
         from matplotlib import pyplot as plt