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

xradio/measurement_set/_utils/_msv2/msv4_sub_xdss.py

@@ -8,12 +8,19 @@ import xarray as xr
 from numpy.typing import ArrayLike
 
 from xradio._utils.coord_math import convert_to_si_units
+from xradio._utils.dict_helpers import (
+    make_time_measure_attrs,
+    make_spectral_coord_measure_attrs,
+)
 from xradio._utils.schema import (
     column_description_casacore_to_msv4_measure,
     convert_generic_xds_to_xradio_schema,
 )
-from .subtables import subt_rename_ids
-from ._tables.read import (
+from xradio.measurement_set._utils._utils.interpolate import (
+    interpolate_to_time,
+)
+from xradio.measurement_set._utils._msv2.subtables import subt_rename_ids
+from xradio.measurement_set._utils._msv2._tables.read import (
     load_generic_table,
     make_taql_where_between_min_max,
     table_exists,
@@ -21,12 +28,7 @@ from ._tables.read import (
 )
 
 
-standard_time_coord_attrs = {
-    "type": "time",
-    "units": ["s"],
-    "scale": "utc",
-    "format": "unix",
-}
+standard_time_coord_attrs = make_time_measure_attrs(time_format="unix")
 
 
 def rename_and_interpolate_to_time(
@@ -89,57 +91,6 @@ def rename_and_interpolate_to_time(
     return renamed_time_xds
 
 
-def interpolate_to_time(
-    xds: xr.Dataset,
-    interp_time: Union[xr.DataArray, None],
-    message_prefix: str,
-    time_name: str = "time",
-) -> xr.Dataset:
-    """
-    Interpolate the time coordinate of the input xarray dataset to the
-    a data array. This can be used for example to interpolate a pointing_xds
-    to the time coord of the (main) MSv4, or similarly the ephemeris
-    data variables of a field_and_source_xds.
-
-    Uses interpolation method "linear", unless the source number of points is
-    1 in which case "nearest" is used, to avoid divide-by-zero issues.
-
-    Parameters:
-    ----------
-    xds : xr.Dataset
-        Xarray dataset to interpolate (presumably a pointing_xds or an xds of
-        ephemeris variables)
-    interp_time : Union[xr.DataArray, None]
-        Time axis to interpolate the dataset to (usually main MSv4 time)
-    message_prefix: str
-        A prefix for info/debug/etc. messages
-
-    Returns:
-    -------
-    interpolated_xds : xr.Dataset
-        xarray dataset with time axis interpolated to interp_time.
-    """
-    if interp_time is not None:
-        points_before = xds[time_name].size
-        if points_before > 1:
-            method = "linear"
-        else:
-            method = "nearest"
-        xds = xds.interp(
-            {time_name: interp_time.data}, method=method, assume_sorted=True
-        )
-        # scan_name sneaks in as a coordinate of the main time axis, drop it
-        if "scan_name" in xds.coords:
-            xds = xds.drop_vars("scan_name")
-        points_after = xds[time_name].size
-        logger.debug(
-            f"{message_prefix}: interpolating the time coordinate "
-            f"from {points_before} to {points_after} points"
-        )
-
-    return xds
-
-
 def make_taql_where_weather(
     in_file: str, ant_xds_station_name_ids: xr.DataArray
 ) -> str:
@@ -233,6 +184,7 @@ def prepare_generic_weather_xds_and_station_name(
         generic_weather_xds = load_generic_table(
             in_file,
             "WEATHER",
+            timecols=["TIME"],
             rename_ids=subt_rename_ids["WEATHER"],
             taql_where=taql_where,
         )
@@ -282,7 +234,7 @@ def finalize_station_position(
         # 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
+        # borrow from ant_position_with_ids but without carrying over other coords
         weather_xds = weather_xds.assign(
             {
                 "STATION_POSITION": (
@@ -318,6 +270,7 @@ def create_weather_xds(in_file: str, ant_position_with_ids: xr.DataArray):
         generic_weather_xds = load_generic_table(
             in_file,
             "WEATHER",
+            timecols=["TIME"],
             rename_ids=subt_rename_ids["WEATHER"],
         )
     except ValueError as _exc:
@@ -342,7 +295,7 @@ def create_weather_xds(in_file: str, ant_position_with_ids: xr.DataArray):
     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],
+        "H2O": ["H2O", dims_station_time],
         "IONOS_ELECTRON": ["IONOS_ELECTRON", dims_station_time],
         "PRESSURE": ["PRESSURE", dims_station_time],
         "REL_HUMIDITY": ["REL_HUMIDITY", dims_station_time],
@@ -381,6 +334,8 @@ def create_weather_xds(in_file: str, ant_position_with_ids: xr.DataArray):
     for data_var in weather_xds:
         if weather_xds.data_vars[data_var].dtype != np.float64:
             weather_xds[data_var] = weather_xds[data_var].astype(np.float64)
+    if "time_weather" in weather_xds.coords:
+        weather_xds.coords["time_weather"].attrs["type"] = "time_weather"
 
     return weather_xds
 
@@ -437,10 +392,10 @@ def correct_generic_pointing_xds(
                 and generic_pointing_xds.sizes["dir"] == 0
             ):
                 # When some direction variables are "empty" but some are populated properly
-                if "dim_2" in generic_pointing_xds[key].sizes:
+                if "dim_2" in generic_pointing_xds[data_var_name].sizes:
                     data_var_data = xr.DataArray(
-                        generic_pointing_xds[key].values,
-                        dims=generic_pointing_xds[key].dims,
+                        generic_pointing_xds[data_var_name].values,
+                        dims=generic_pointing_xds[data_var_name].dims,
                     )
                 else:
                     shape = tuple(
@@ -449,7 +404,7 @@ def correct_generic_pointing_xds(
                     ) + (2,)
                     data_var_data = xr.DataArray(
                         np.full(shape, np.nan),
-                        dims=generic_pointing_xds[key].dims,
+                        dims=generic_pointing_xds[data_var_name].dims,
                     )
                 correct_pointing_xds[data_var_name].data = data_var_data
 
@@ -501,6 +456,7 @@ def create_pointing_xds(
     generic_pointing_xds = load_generic_table(
         in_file,
         "POINTING",
+        timecols=["TIME"],
         rename_ids=subt_rename_ids["POINTING"],
         taql_where=taql_where,
     )
@@ -608,7 +564,7 @@ def prepare_generic_sys_cal_xds(generic_sys_cal_xds: xr.Dataset) -> xr.Dataset:
         )
     elif (
         "frequency" in generic_sys_cal_xds.sizes
-        and not "dim_3" in generic_sys_cal_xds.sizes
+        and "dim_3" not in generic_sys_cal_xds.sizes
     ):
         # because order is (...,frequency,receptor), when frequency is missing
         # receptor can get wrongly labeled as frequency
@@ -665,6 +621,7 @@ def create_system_calibration_xds(
         generic_sys_cal_xds = load_generic_table(
             in_file,
             "SYSCAL",
+            timecols=["TIME"],
             rename_ids=subt_rename_ids["SYSCAL"],
             taql_where=(
                 f" where (SPECTRAL_WINDOW_ID = {spectral_window_id})"
@@ -725,11 +682,9 @@ def create_system_calibration_xds(
             "frequency_system_cal": generic_sys_cal_xds.coords["frequency"].data
         }
         sys_cal_xds = sys_cal_xds.assign_coords(frequency_coord)
-        frequency_measure = {
-            "type": main_xds_frequency.attrs["type"],
-            "units": main_xds_frequency.attrs["units"],
-            "observer": main_xds_frequency.attrs["observer"],
-        }
+        frequency_measure = make_spectral_coord_measure_attrs(
+            main_xds_frequency.attrs["units"], main_xds_frequency.attrs["observer"]
+        )
         sys_cal_xds.coords["frequency_system_cal"].attrs.update(frequency_measure)
 
     sys_cal_xds = rename_and_interpolate_to_time(
@@ -828,7 +783,7 @@ def create_phased_array_xds(
     }
     data_vars["COORDINATE_AXES"].attrs = {
         "type": "rotation_matrix",
-        "units": ["dimensionless", "dimensionless", "dimensionless"],
+        "units": "dimensionless",
     }
     # Remove the "frame" attribute if it exists, because ELEMENT_OFFSET is
     # defined in a station-local frame for which no standard name exists

xradio/measurement_set/_utils/_msv2/partition_queries.py

@@ -1,17 +1,13 @@
 import itertools
 import toolviper.utils.logger as logger
-from pathlib import Path
-from typing import Dict, List, Tuple, Union
 
 import numpy as np
-import xarray as xr
 
 try:
     from casacore import tables
 except ImportError:
     import xradio._utils._casacore.casacore_from_casatools as tables
 
-from ._tables.table_query import open_table_ro, open_query
 from ._tables.read import table_exists
 
 
@@ -31,7 +27,7 @@ def create_partitions(in_file: str, partition_scheme: list) -> list[dict]:
     partition_scheme:  list
         A MS v4 can only contain a single data description (spectral window and polarization setup), and observation mode. Consequently, the MS v2 is partitioned when converting to MS v4.
         In addition to data description and polarization setup a finer partitioning is possible by specifying a list of partitioning keys. Any combination of the following keys are possible:
-        "FIELD_ID", "SCAN_NUMBER", "STATE_ID", "SOURCE_ID", "SUB_SCAN_NUMBER".
+        "FIELD_ID", "SCAN_NUMBER", "STATE_ID", "SOURCE_ID", "SUB_SCAN_NUMBER", "ANTENNA1".
         For mosaics where the phase center is rapidly changing (such as VLA on the fly mosaics)  partition_scheme should be set to an empty list []. By default, ["FIELD_ID"].
     Returns
     -------
@@ -152,259 +148,3 @@ def create_partitions(in_file: str, partition_scheme: list) -> list[dict]:
             partitions.append(partition_info)
 
     return partitions
-
-
-# Used by code that will be deprecated at some stage. See #192
-# Still need to clarify what to do about intent string filtering ('WVR', etc.)
-
-
-def make_partition_ids_by_ddi_intent(
-    infile: str, spw_names: xr.DataArray
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-    """
-    Produces arrays of per-partition ddi, scan, state_id, for when
-    using the partition scheme 'intents' (ddi, scan, subscans(state_ids))
-
-    Parameters
-    ----------
-    infile : str
-        return: arrays with indices that define every partition
-    spw_names: xr.DataArray
-
-
-    Returns
-    -------
-    Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
-        arrays with indices that define every partition
-    """
-    # TODO: could explore other TAQL alternatives, like
-    # select ... from ::STATE where OBS_MODE = ...
-    #
-    # This will work only if intents are already alphabetically sorted (grouped),
-    # won't work for alternating intents:
-    # taql_intents = "select rowid() as ROWS from $state_tbl GROUPBY OBS_MODE "
-
-    with open_table_ro(str(Path(infile, "STATE"))) as state_tbl:
-        distinct_obs_mode = find_distinct_obs_mode(infile, state_tbl)
-
-        if distinct_obs_mode is None:
-            return partition_when_empty_state(infile)
-
-        with open_table_ro(infile) as main_tbl:
-            (
-                data_desc_id,
-                state_id_partitions,
-                intent_names,
-            ) = make_ddi_state_intent_lists(
-                main_tbl, state_tbl, distinct_obs_mode, spw_names
-            )
-
-    # Take whatever scans given by the STATE_IDs and DDIs
-    scan_number = [None] * len(state_id_partitions)
-
-    return data_desc_id, scan_number, state_id_partitions, intent_names
-
-
-def find_distinct_obs_mode(
-    infile: str, state_table: tables.table
-) -> Union[List[str], None]:
-    """
-    Produce a list of unique "scan/subscan" intents.
-
-    Parameters
-    ----------
-    infile : str
-        Path to the MS
-    state_table : tables.table
-        casacore table object to read from
-
-    Returns
-    -------
-    Union[List[str], None]
-        List of unique "scan/subscan" intents as given in the
-        OBS_MODE column of the STATE subtable. None if the STATE subtable
-        is empty or there is a problem reading it
-    """
-    taql_distinct_intents = "select DISTINCT OBS_MODE from $state_table"
-    with open_query(state_table, taql_distinct_intents) as query_intents:
-        if query_intents.nrows() == 0:
-            logger.warning(
-                "STATE subtable has no data. Cannot partition by scan/subscan intent"
-            )
-            return None
-
-        distinct_obs_mode = query_intents.getcol("OBS_MODE")
-        logger.debug(
-            f"  Query for distinct OBS_MODE len: {len(distinct_obs_mode)}, values: {distinct_obs_mode}"
-        )
-        return distinct_obs_mode
-
-
-def make_ddi_state_intent_lists(
-    main_tbl: tables.table,
-    state_tbl: tables.table,
-    distinct_obs_mode: np.ndarray,
-    spw_name_by_ddi: Dict[int, str],
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """
-    Produce arrays of (ddi indices, state indices, intent string)
-    for every distinct intent string, where every item represents one
-    partition of the main table
-
-    As the obs_mode strings have concatenated intent strings from all
-    the scan and subscan intents, this function has started
-    implementing some simple heuristics to remove the intent items
-    that are not related to the respective DDIs (for example WVR
-    intent is the only kept when the DDI/SPW has WVR in its name). See
-    call to filter_intents_per_ddi()
-
-    Parameters
-    ----------
-    main_tbl : tables.table
-        main MS table openend as a casacore.tables.table
-    state_tbl : tables.table
-        STATE subtable openend as a casacore.tables.table
-    distinct_obs_mode : np.ndarray
-        list of unique/distinct OBS_MODE strings from the STATE table
-    spw_name_by_ddi: Dict[int, str]
-
-
-    Returns
-    -------
-    Tuple[np.ndarray, np.ndarray, np.ndarray]
-        arrays of (ddi indices, state indices, intent string)
-    """
-    data_desc_id, state_id_partitions, intent_names = [], [], []
-    for intent in distinct_obs_mode:
-        where_intent = f"where OBS_MODE = '{intent}'"
-        taql_states = f"select ROWID() as ROWS from $state_tbl {where_intent}"
-        with open_query(state_tbl, taql_states) as query_states:
-            state_ids_for_intent = query_states.getcol("ROWS")
-
-        state_ids = " OR STATE_ID = ".join(np.char.mod("%d", state_ids_for_intent))
-        taql_partition = (
-            f"select DISTINCT DATA_DESC_ID from $main_tbl where STATE_ID = {state_ids}"
-        )
-        with open_query(main_tbl, taql_partition) as query_ddi_intent:
-            # No data for these STATE_IDs
-            if query_ddi_intent.nrows() == 0:
-                continue
-
-            # Will implicitly take whatever scans given the STATE_IDs
-            # and DDIs scan_number. Not needed:
-            # scan_number = query_ddi_intent.getcol("SCAN_NUMBER")
-            ddis = query_ddi_intent.getcol("DATA_DESC_ID")
-
-            data_desc_id.extend(ddis)
-            state_id_partitions.extend([state_ids_for_intent] * len(ddis))
-
-            # Try to select/exclude confusing or mixed intent names such as 'WVR#*'
-            intents_ddi = filter_intents_per_ddi(ddis, "WVR", intent, spw_name_by_ddi)
-            intent_names.extend(intents_ddi)
-
-    logger.debug(
-        f"Produced data_desc_id: {data_desc_id},\n state_id_partitions: {state_id_partitions}"
-    )
-    return data_desc_id, state_id_partitions, intent_names
-
-
-def filter_intents_per_ddi(
-    ddis: List[int], substr: str, intents: str, spw_name_by_ddi: Dict[int, str]
-) -> List[str]:
-    """
-    For a given pair of:
-    - substring (say 'WVR') associated with a type of intent we want to differentiate
-    - intents string (multiple comma-separated scan/subscan intents)
-    => do: for every DDI passed in the list of ddis, either keep only the
-    intents that have that substring (if there are any) or drop them, depending on
-    whether that substring is present in the SPW name. This is to filter in only
-    the intents that really apply to every DDI/SPW.
-
-    Parameters
-    ----------
-    ddis : List[int]
-        list of ddis for which the intents have to be filtered
-    substr : str
-        substring to filter by
-    intents : str
-        string with a comma-separated list of individual
-        scan/subscan intent strings (like scan/subscan intents as stored
-        in the MS STATE/OBS_MODE
-    spw_name_by_ddi : Dict[int, str]
-        SPW names by DDI ID (row index) key
-
-    Returns
-    -------
-    List[str]
-        list where the intents related to 'substr' have been filtered in our out
-    """
-    present = substr in intents
-    # Nothing to effectively filter, full cs-list of intents apply to all DDIs
-    if not present:
-        return [intents] * len(ddis)
-
-    every_intent = intents.split(",")
-    filtered_intents = []
-    for ddi in ddis:
-        spw_name = spw_name_by_ddi.get(ddi, "")
-
-        if not spw_name:
-            # we cannot say / cannot filter
-            filtered_intents.append(intents)
-            continue
-
-        # A not-xor to select/deselect (or keep-only/drop) the intents that apply
-        # to this DDI
-        ddi_intents = [
-            intnt for intnt in every_intent if (substr in intnt) == (substr in spw_name)
-        ]
-        ddi_intents = ",".join(ddi_intents)
-        filtered_intents.append(ddi_intents)
-
-    return filtered_intents
-
-
-def partition_when_empty_state(
-    infile: str,
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-    """
-    Generate fallback partition ids when trying to partition by
-    'intent' but the STATE table is empty.
-
-    Some MSs have no STATE rows and in the main table STATE_ID==-1
-    (that is not a valid MSv2 but it happens).
-
-    Parameters
-    ----------
-    infile : str
-        Path to the MS
-
-    Returns
-    -------
-    Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
-        same as make_partition_ids_by_ddi_intent but with
-        effectively only ddi indices and other indices set to None ("any
-        IDs found")
-    """
-    try:
-        main_table = None
-
-        main_table = tables.table(
-            infile, readonly=True, lockoptions={"option": "usernoread"}, ack=False
-        )
-        taql_ddis = "select DISTINCT DATA_DESC_ID from $main_table"
-        with open_query(main_table, taql_ddis) as query_per_intent:
-            # Will take whatever scans given the STATE_IDs and DDIs
-            # scan_number = query_per_intent.getcol("SCAN_NUMBER")
-            distinct_ddis = query_per_intent.getcol("DATA_DESC_ID")
-
-        logger.debug(
-            f"Producing {len(distinct_ddis)} partitions for ddis: {distinct_ddis}"
-        )
-        nparts = len(distinct_ddis)
-
-    finally:
-        if main_table:
-            main_table.close()
-
-    return distinct_ddis, [None] * nparts, [None] * nparts, [""] * nparts

xradio/measurement_set/_utils/_msv2/subtables.py

@@ -1,16 +1,3 @@
-import os
-
-import toolviper.utils.logger as logger
-
-from pathlib import Path
-from typing import Dict, List
-
-import xarray as xr
-
-from ._tables.read import load_generic_table, table_exists
-from ._tables.read_subtables import read_ephemerides, read_delayed_pointing_table
-
-
 subt_rename_ids = {
     "ANTENNA": {"row": "antenna_id", "dim_1": "xyz"},
     "FEED": {"dim_1": "xyz", "dim_2": "receptor", "dim_3": "receptor2"},
@@ -27,97 +14,3 @@ subt_rename_ids = {
     # Would make sense for non-std "WS_NX_STATION_POSITION"
     "WEATHER": {"dim_1": "xyz"},
 }
-
-
-def read_ms_subtables(
-    infile: str, done_subt: List[str], asdm_subtables: bool = False
-) -> Dict[str, xr.Dataset]:
-    """
-    Read MSv2 subtables (main table keywords) as xr.Dataset
-
-    Parameters
-    ----------
-    infile : str
-        input MeasurementSet path
-    done_subt : List[str]
-        Subtables that were already read, to skip them
-    asdm_subtables : bool (Default value = False)
-        Whether to also read ASDM_* subtables
-
-    Returns
-    -------
-    Dict[str, xr.Dataset]
-        dict of xarray datasets read from subtables (metadata tables)
-
-    """
-    ignore_msv2_cols_subt = ["FLAG_CMD", "FLAG_ROW", "BEAM_ID"]
-    skip_tables = ["SORTED_TABLE", "FLAG_CMD"] + done_subt
-    stbl_list = sorted(
-        [
-            tname
-            for tname in os.listdir(infile)
-            if (tname not in skip_tables)
-            and (os.path.isdir(os.path.join(infile, tname)))
-            and (table_exists(os.path.join(infile, tname)))
-        ]
-    )
-
-    subtables = {}
-    for _ii, subt_name in enumerate(stbl_list):
-        if not asdm_subtables and subt_name.startswith("ASDM_"):
-            logger.debug(f"skipping ASDM_ subtable {subt_name}...")
-            continue
-        else:
-            logger.debug(f"reading subtable {subt_name}...")
-
-        if subt_name == "POINTING":
-            subt_path = Path(infile, subt_name)
-            rename_ids = {"dim_2": "n_polynomial", "dim_3": "dir"}
-            xds = read_delayed_pointing_table(str(subt_path), rename_ids=rename_ids)
-        else:
-            xds = load_generic_table(
-                infile,
-                subt_name,
-                timecols=["TIME"],
-                ignore=ignore_msv2_cols_subt,
-                rename_ids=subt_rename_ids.get(subt_name, None),
-            )
-
-        if len(xds.sizes) != 0:
-            subtables[subt_name.lower()] = xds
-
-    if "field" in subtables:
-        ephem_xds = read_ephemerides(infile)
-        if ephem_xds:
-            subtables["ephemerides"] = ephem_xds
-
-    return subtables
-
-
-def add_pointing_to_partition(
-    xds_part: xr.Dataset, xds_pointing: xr.Dataset
-) -> xr.Dataset:
-    """
-    Take pointing variables from a (delayed) pointing dataset and
-    transfer them to a main table partition dataset (interpolating into
-    the destination time axis)
-
-    Parameters
-    ----------
-    xds_part : xr.Dataset
-        a partition/sub-xds of the main table
-    xds_pointing : xr.Dataset
-        the xds read from the pointing subtable
-
-    Returns
-    -------
-    xr.Dataset
-        partition xds with pointing variables added/interpolated from the
-        pointing_xds into its time axis
-
-    """
-    interp_xds = xds_pointing.interp(time=xds_part.time, method="nearest")
-    for var in interp_xds.data_vars:
-        xds_part[f"pointing_{var}"] = interp_xds[var]
-
-    return xds_part

xradio/measurement_set/_utils/_utils/interpolate.py

@@ -0,0 +1,60 @@
+from typing import Union
+
+import xarray as xr
+
+import toolviper.utils.logger as logger
+
+
+def interpolate_to_time(
+    xds: xr.Dataset,
+    interp_time: Union[xr.DataArray, None],
+    message_prefix: str,
+    time_name: str = "time",
+) -> xr.Dataset:
+    """
+    Interpolate the time coordinate of the input xarray dataset to the
+    a data array. This can be used for example to interpolate a pointing_xds
+    to the time coord of the (main) MSv4, or similarly the ephemeris
+    data variables of a field_and_source_xds.
+
+    Uses interpolation method "linear", unless the source number of points is
+    1 in which case "nearest" is used, to avoid divide-by-zero issues.
+
+    Parameters:
+    ----------
+    xds : xr.Dataset
+        Xarray dataset to interpolate (presumably a pointing_xds or an xds of
+        ephemeris variables)
+    interp_time : Union[xr.DataArray, None]
+        Time axis to interpolate the dataset to (usually main MSv4 time)
+    message_prefix: str
+        A prefix for info/debug/etc. messages
+
+    Returns:
+    -------
+    interpolated_xds : xr.Dataset
+        xarray dataset with time axis interpolated to interp_time.
+    """
+    if interp_time is not None:
+        points_before = xds[time_name].size
+        if points_before > 1:
+            method = "linear"
+        else:
+            method = "nearest"
+        xds = xds.interp(
+            {time_name: interp_time.data}, method=method, assume_sorted=True
+        )
+        # scan_name sneaks in as a coordinate of the main time axis, drop it
+        if (
+            "type" in xds.attrs
+            and xds.attrs["type"] not in ["visibility", "spectrum", "wvr"]
+            and "scan_name" in xds.coords
+        ):
+            xds = xds.drop_vars("scan_name")
+        points_after = xds[time_name].size
+        logger.debug(
+            f"{message_prefix}: interpolating the time coordinate "
+            f"from {points_before} to {points_after} points"
+        )
+
+    return xds

xradio/measurement_set/_utils/_zarr/encoding.py

@@ -4,11 +4,6 @@ def add_encoding(xds, compressor, chunks=None):
 
     chunks = {**dict(xds.sizes), **chunks}  # Add missing sizes if presents.
 
-    encoding = {}
     for da_name in list(xds.data_vars):
-        if chunks:
-            da_chunks = [chunks[dim_name] for dim_name in xds[da_name].sizes]
-            xds[da_name].encoding = {"compressor": compressor, "chunks": da_chunks}
-            # print(xds[da_name].encoding)
-        else:
-            xds[da_name].encoding = {"compressor": compressor}
+        da_chunks = [chunks[dim_name] for dim_name in xds[da_name].sizes]
+        xds[da_name].encoding = {"compressor": compressor, "chunks": da_chunks}

xradio/measurement_set/convert_msv2_to_processing_set.py

@@ -116,8 +116,6 @@ def convert_msv2_to_processing_set(
     if not str(out_file).endswith("ps.zarr"):
         out_file += ".ps.zarr"
 
-    print("Output file: ", out_file)
-
     if overwrite:
         ps_dt.to_zarr(store=out_file, mode="w")
     else: