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

xradio/measurement_set/_utils/_msv2/create_field_and_source_xds.py

@@ -18,10 +18,9 @@ from xradio.measurement_set._utils._msv2._tables.read import (
     load_generic_table,
 )
 from xradio._utils.list_and_array import cast_to_str, get_pad_value
-
+from xradio._utils.dict_helpers import make_quantity_attrs
 from xradio._utils.coord_math import (
     convert_to_si_units,
-    add_position_offsets,
     wrap_to_pi,
 )
 
@@ -45,7 +44,7 @@ def create_field_and_source_xds(
     is_single_dish: bool,
     time_min_max: Tuple[np.float64, np.float64],
     ephemeris_interpolate: bool = True,
-) -> tuple[xr.Dataset, int]:
+) -> tuple[xr.Dataset, np.ndarray, int]:
     """
     Create a field and source xarray dataset (xds) from the given input file, field ID, and spectral window ID.
     Data is extracted from the FIELD and SOURCE tables and if there is ephemeris data, it is also extracted.
@@ -72,6 +71,8 @@ def create_field_and_source_xds(
     -------
     field_and_source_xds : xr.Dataset
         The xarray dataset containing the field and source information.
+    source_id : np.ndarray[int]
+        Source ID(s) corresponding to the field(s)
     num_lines : int
         Sum of num_lines for all unique sources.
     """
@@ -158,6 +159,10 @@ def extract_ephemeris_info(
     # Consequently a lot of hardcoding is needed to extract the information.
     # https://casadocs.readthedocs.io/en/latest/notebooks/external-data.html
 
+    xds = xds.assign_coords(
+        {"sky_dis_label": ["dist"], "cartesian_pos_label": ["x", "y", "z"]}
+    )
+
     # Only read data between the min and max times of the visibility data in the MSv4.
     min_max_mjd = (
         convert_casacore_time_to_mjd(time_min_max[0]),
@@ -214,44 +219,64 @@ def extract_ephemeris_info(
     temp_xds = xr.Dataset()
 
     # Add mandatory data: OBSERVER_POSITION
-    observer_position = [
-        ephemeris_meta["GeoLong"],
-        ephemeris_meta["GeoLat"],
-        ephemeris_meta["GeoDist"],
-    ]
+    # Convert Observer position to geodetic coordinates
+    from astropy import units as u
+    from astropy.coordinates import EarthLocation
+    from astropy.time import Time
+
+    # Create an EarthLocation object for the geodetic coordinates
+    # Assume that geodetic coordinates are given in degrees and meters
+    location = EarthLocation.from_geodetic(
+        lon=ephemeris_meta["GeoLong"] * u.deg,
+        lat=ephemeris_meta["GeoLat"] * u.deg,
+        height=ephemeris_meta["GeoDist"] * u.m,
+        ellipsoid="WGS84",  # Explicitly specify WGS84
+    )
+
+    # Get the ITRS Cartesian coordinates (x, y, z)
+    observer_position = location.itrs.cartesian.xyz
+
     temp_xds["OBSERVER_POSITION"] = xr.DataArray(
-        observer_position, dims=["ellipsoid_pos_label"]
+        observer_position, dims=["cartesian_pos_label"]
     )
     temp_xds["OBSERVER_POSITION"].attrs.update(
         {
             "type": "location",
-            "units": ["deg", "deg", "m"],
-            "data": observer_position,
+            "units": "m",
             "frame": "ITRS",
             "origin_object_name": "Earth",
             "coordinate_system": ephemeris_meta["obsloc"].lower(),
-            "ellipsoid": "WGS84",
         }
-    )  # I think the units are ['deg','deg','m'] and 'WGS84'.
+    )
 
-    # Add (optional) data: SOURCE_LOCATION (POSITION / sky_pos_label)
-    temp_xds["SOURCE_LOCATION"] = xr.DataArray(
+    temp_xds["SOURCE_DIRECTION"] = xr.DataArray(
         np.column_stack(
             (
                 ephemeris_xds["RA"].data,
                 ephemeris_xds["DEC"].data,
-                ephemeris_xds["Rho"].data,
             )
         ),
-        dims=["time_ephemeris", "sky_pos_label"],
+        dims=["time_ephemeris", "sky_dir_label"],
     )
+
+    temp_xds["SOURCE_DISTANCE"] = xr.DataArray(
+        np.column_stack((ephemeris_xds["Rho"].data,)),
+        dims=["time_ephemeris", "sky_dis_label"],
+    )
+
     # Have to use cast_to_str because the ephemeris table units are not consistently in a list or a string.
-    sky_coord_units = [
-        cast_to_str(ephemeris_column_description["RA"]["keywords"][unit_keyword]),
-        cast_to_str(ephemeris_column_description["DEC"]["keywords"][unit_keyword]),
-        cast_to_str(ephemeris_column_description["Rho"]["keywords"][unit_keyword]),
-    ]
-    temp_xds["SOURCE_LOCATION"].attrs.update(
+    sky_coord_units = cast_to_str(
+        ephemeris_column_description["RA"]["keywords"][unit_keyword]
+    )
+
+    temp_xds["SOURCE_DIRECTION"].attrs.update(
+        {"type": "sky_coord", "frame": sky_coord_frame, "units": sky_coord_units}
+    )
+
+    sky_coord_units = cast_to_str(
+        ephemeris_column_description["Rho"]["keywords"][unit_keyword]
+    )
+    temp_xds["SOURCE_DISTANCE"].attrs.update(
         {"type": "sky_coord", "frame": sky_coord_frame, "units": sky_coord_units}
     )
 
@@ -281,16 +306,13 @@ def extract_ephemeris_info(
         msv4_var_name = msv4_variable_def[0]
         if msv4_var_name in temp_xds:
             temp_xds[msv4_var_name].attrs.update(
-                {
-                    "type": "quantity",
-                    "units": [
-                        cast_to_str(
-                            ephemeris_column_description[generic_var_name]["keywords"][
-                                unit_keyword
-                            ]
-                        )
-                    ],
-                }
+                make_quantity_attrs(
+                    cast_to_str(
+                        ephemeris_column_description[generic_var_name]["keywords"][
+                            unit_keyword
+                        ]
+                    )
+                )
             )
 
     # Add optional data: SUB_OBSERVER_DIRECTION and SUB_SOLAR_POSITION
@@ -307,10 +329,9 @@ def extract_ephemeris_info(
                 (
                     ephemeris_xds[key_lon].data,
                     ephemeris_xds[key_lat].data,
-                    np.zeros(ephemeris_xds[key_lon].shape),
                 )
             ),
-            dims=["time_ephemeris", "ellipsoid_pos_label"],
+            dims=["time_ephemeris", "ellipsoid_dir_label"],
         )
 
         temp_xds["SUB_OBSERVER_DIRECTION"].attrs.update(
@@ -319,54 +340,55 @@ def extract_ephemeris_info(
                 "frame": "Undefined",
                 "origin_object_name": ephemeris_meta["NAME"],
                 "coordinate_system": "planetodetic",
-                "units": [
-                    cast_to_str(
-                        ephemeris_column_description[key_lon]["keywords"][unit_keyword]
-                    ),
-                    cast_to_str(
-                        ephemeris_column_description[key_lat]["keywords"][unit_keyword]
-                    ),
-                    "m",
-                ],
+                "units": cast_to_str(
+                    ephemeris_column_description[key_lon]["keywords"][unit_keyword]
+                ),
             }
         )
 
     if "SI_lon" in ephemeris_xds.data_vars:
-        temp_xds["SUB_SOLAR_POSITION"] = xr.DataArray(
+        temp_xds["SUB_SOLAR_DIRECTION"] = xr.DataArray(
             np.column_stack(
                 (
                     ephemeris_xds["SI_lon"].data,
                     ephemeris_xds["SI_lat"].data,
-                    ephemeris_xds["r"].data,
                 )
             ),
-            dims=["time_ephemeris", "ellipsoid_pos_label"],
+            dims=["time_ephemeris", "ellipsoid_dir_label"],
         )
-        temp_xds["SUB_SOLAR_POSITION"].attrs.update(
+        temp_xds["SUB_SOLAR_DIRECTION"].attrs.update(
             {
                 "type": "location",
                 "frame": "Undefined",
                 "origin_object_name": "Sun",
                 "coordinate_system": "planetodetic",
-                "units": [
-                    cast_to_str(
-                        ephemeris_column_description["SI_lon"]["keywords"][unit_keyword]
-                    ),
-                    cast_to_str(
-                        ephemeris_column_description["SI_lat"]["keywords"][unit_keyword]
-                    ),
-                    cast_to_str(
-                        ephemeris_column_description["r"]["keywords"][unit_keyword]
-                    ),
-                ],
+                "units": cast_to_str(
+                    ephemeris_column_description["SI_lon"]["keywords"][unit_keyword]
+                ),
+            }
+        )
+
+        temp_xds["SUB_SOLAR_DISTANCE"] = xr.DataArray(
+            [ephemeris_xds["r"].data],
+            dims=["time_ephemeris", "ellipsoid_dis_label"],
+        )
+        temp_xds["SUB_SOLAR_DISTANCE"].attrs.update(
+            {
+                "type": "location",
+                "frame": "Undefined",
+                "origin_object_name": "Sun",
+                "coordinate_system": "planetodetic",
+                "units": cast_to_str(
+                    ephemeris_column_description["r"]["keywords"][unit_keyword]
+                ),
             }
         )
 
     # We are using the "time_ephemeris" label because it might not match the optional time axis of the source and field info. If ephemeris_interpolate=True then rename it to time.
     coords = {
-        "ellipsoid_pos_label": ["lon", "lat", "dist"],
+        "ellipsoid_dir_label": ["lon", "lat"],
+        "ellipsoid_dis_label": ["dist"],
         "time_ephemeris": ephemeris_xds["time"].data,
-        "sky_pos_label": ["ra", "dec", "dist"],
     }
     temp_xds = temp_xds.assign_coords(coords)
     temp_xds["time_ephemeris"].attrs.update(standard_time_coord_attrs)
@@ -379,10 +401,18 @@ def extract_ephemeris_info(
         temp_xds = rename_and_interpolate_to_time(
             temp_xds, "time_ephemeris", interp_time, "field_and_source_xds"
         )
-        source_location_interp = temp_xds["SOURCE_LOCATION"]
+        source_direction_interp = temp_xds["SOURCE_DIRECTION"]
+        source_distance_interp = temp_xds["SOURCE_DISTANCE"]
+
     else:
-        source_location_interp = interpolate_to_time(
-            temp_xds["SOURCE_LOCATION"],
+        source_direction_interp = interpolate_to_time(
+            temp_xds["SOURCE_DIRECTION"],
+            interp_time,
+            "field_and_source_xds",
+            "time_ephemeris",
+        )
+        source_distance_interp = interpolate_to_time(
+            temp_xds["SOURCE_DISTANCE"],
             interp_time,
             "field_and_source_xds",
             "time_ephemeris",
@@ -390,68 +420,38 @@ def extract_ephemeris_info(
 
     xds = xr.merge([xds, temp_xds])
 
-    # Add the SOURCE_LOCATION to the FIELD_PHASE_CENTER or FIELD_REFERENCE_CENTER. Ephemeris obs: When loaded from the MSv2 field table the FIELD_REFERENCE_CENTER or FIELD_PHASE_CENTER only contain an offset from the SOURCE_LOCATION.
-    # We also need to add a distance dimension to the FIELD_PHASE_CENTER or FIELD_REFERENCE_CENTER to match the SOURCE_LOCATION.
-    # FIELD_PHASE_CENTER is used for interferometer data and FIELD_REFERENCE_CENTER is used for single dish data.
+    # Add the SOURCE_DIRECTION to the FIELD_PHASE_CENTER or FIELD_REFERENCE_CENTER. Ephemeris obs: When loaded from the MSv2 field table the FIELD_REFERENCE_CENTER or FIELD_PHASE_CENTER only contain an offset from the SOURCE_DIRECTION.
+    # We also need to add a distance dimension to the FIELD_PHASE_CENTER or FIELD_REFERENCE_CENTER to match the SOURCE_DIRECTION.
+    # FIELD_PHASE_CENTER_DIRECTION is used for interferometer data and FIELD_REFERENCE_CENTER_DIRECTION is used for single dish data.
     if is_single_dish:
-        center_dv = "FIELD_REFERENCE_CENTER"
+        center_dir_dv = "FIELD_REFERENCE_CENTER_DIRECTION"
+        center_dis_dv = "FIELD_REFERENCE_CENTER_DISTANCE"
     else:
-        center_dv = "FIELD_PHASE_CENTER"
+        center_dir_dv = "FIELD_PHASE_CENTER_DIRECTION"
+        center_dis_dv = "FIELD_PHASE_CENTER_DISTANCE"
 
     xds = xds.sel(field_name=field_names)  # Expand for all times in ms
     xds = xds.assign_coords({"time": ("field_name", interp_time)})
     xds["time"].attrs.update(standard_time_coord_attrs)
     xds = xds.swap_dims({"field_name": "time"})
 
-    source_location_interp
-    field_phase_center = wrap_to_pi(
-        xds[center_dv].values + source_location_interp[:, 0:2].values
+    field_phase_center_direction = wrap_to_pi(
+        xds[center_dir_dv].values + source_direction_interp.values
     )
 
-    field_phase_center = np.column_stack(
-        (field_phase_center, np.zeros(xds[center_dv].values.shape[0]))
+    xds[center_dir_dv] = xr.DataArray(
+        field_phase_center_direction,
+        dims=["time", "sky_dir_label"],
     )
 
-    field_phase_center[:, -1] = (
-        field_phase_center[:, -1] + source_location_interp[:, -1].values
+    xds[center_dis_dv] = xr.DataArray(
+        source_distance_interp.values,
+        dims=["time", "sky_dis_label"],
     )
 
-    xds[center_dv] = xr.DataArray(
-        field_phase_center,
-        dims=["time", "sky_pos_label"],
-    )
+    xds[center_dir_dv].attrs.update(xds["SOURCE_DIRECTION"].attrs)
 
-    # if "time" in xds[center_dv].coords:
-    #     assert (
-    #         interp_time is not None
-    #     ), 'ephemeris_interpolate must be True if there is ephemeris data and multiple fields (this will occur if "FIELD_ID" is not in partition_scheme).'
-
-    #     field_phase_center = wrap_to_pi(
-    #         xds[center_dv].values + xds["SOURCE_LOCATION"][:, 0:2].values
-    #     )
-    #     field_phase_center = np.column_stack(
-    #         (field_phase_center, np.zeros(xds[center_dv].values.shape[0]))
-    #     )
-    #     field_phase_center[:, -1] = (
-    #         field_phase_center[:, -1] + xds["SOURCE_LOCATION"][:, -1].values
-    #     )
-
-    #     xds[center_dv] = xr.DataArray(
-    #         field_phase_center,
-    #         dims=[xds["SOURCE_LOCATION"].dims[0], "sky_pos_label"],
-    #     )
-    # else:
-    #     field_phase_center = (
-    #         np.append(xds[center_dv].values, 0) + xds["SOURCE_LOCATION"].values
-    #     )
-    #     field_phase_center[:, 0:2] = wrap_to_pi(field_phase_center[:, 0:2])
-
-    #     xds[center_dv] = xr.DataArray(
-    #         field_phase_center,
-    #         dims=[xds["SOURCE_LOCATION"].dims[0], "sky_pos_label"],
-    #     )
-
-    xds[center_dv].attrs.update(xds["SOURCE_LOCATION"].attrs)
+    xds[center_dis_dv].attrs.update(xds["SOURCE_DISTANCE"].attrs)
 
     return xds
 
@@ -573,7 +573,9 @@ def pad_missing_sources(
     for missing_id in missing_source_ids:
         missing_source_xds[concat_dim] = missing_id
         xdss_to_concat.append(missing_source_xds)
-    filled_source_xds = xr.concat(xdss_to_concat, concat_dim).sortby(concat_dim)
+    filled_source_xds = xr.concat(xdss_to_concat, concat_dim, join="outer").sortby(
+        concat_dim
+    )
 
     return filled_source_xds
 
@@ -611,7 +613,7 @@ def extract_source_info(
 
     if all(source_id == -1):
         logger.warning(
-            f"Source_id is -1. No source information will be included in the field_and_source_xds."
+            "Source_id is -1. No source information will be included in the field_and_source_xds."
         )
         xds = xds.assign_coords(
             {"source_name": ("field_name", unknown)}
@@ -655,7 +657,7 @@ def extract_source_info(
     # ), "Can only process source table with a single time entry for a source_id and spectral_window_id."
     if len(source_xds.TIME) > len(unique_source_id):
         logger.warning(
-            f"Source table has more than one time entry for a source_id and spectral_window_id. This is not currently supported. Only the first time entry will be used."
+            "Source table has more than one time entry for a source_id and spectral_window_id. This is not currently supported. Only the first time entry will be used."
         )
         source_xds = source_xds.drop_duplicates("SOURCE_ID", keep="first")
 
@@ -689,9 +691,6 @@ def extract_source_info(
     # If ephemeris data is present we ignore the SOURCE_DIRECTION in the source table.
     if not is_ephemeris:
         direction_msv2_col = "DIRECTION"
-        msv4_measure = column_description_casacore_to_msv4_measure(
-            source_column_description[direction_msv2_col]
-        )
 
         msv2_direction_dims = source_xds[direction_msv2_col].dims
         if (
@@ -709,7 +708,7 @@ def extract_source_info(
         location_msv4_measure = column_description_casacore_to_msv4_measure(
             source_column_description[direction_msv2_col]
         )
-        xds["SOURCE_LOCATION"] = xr.DataArray(
+        xds["SOURCE_DIRECTION"] = xr.DataArray(
             direction_var.data, dims=direction_dims, attrs=location_msv4_measure
         )
 
@@ -739,14 +738,15 @@ def extract_source_info(
 
     # Need to add doppler info if present. Add check.
     try:
-        doppler_xds = load_generic_table(
+        load_generic_table(
             path,
             "DOPPLER",
         )
-        assert (
-            False
-        ), "Doppler table present. Please open an issue on https://github.com/casangi/xradio/issues so that we can add support for this."
-    except:
+        logger.warning(
+            "Doppler table present. Please open an issue on "
+            "https://github.com/casangi/xradio/issues so that we can add support for this."
+        )
+    except ValueError:
         pass
 
     xds = xds.assign_coords(coords)
@@ -756,50 +756,6 @@ def extract_source_info(
     return xds, np.sum(num_lines[unique_source_ids_indices])
 
 
-def make_field_dims_and_coords(
-    field_xds: xr.Dataset, field_id: Union[int, np.ndarray], field_times: list
-) -> tuple[list, dict]:
-    """
-    Produces the dimensions and coordinates used in the field data variables
-    extracted from the MSv2 FIELD subtable (FIELD_PHASE_CENTER/
-    FIELD_REFERENCE_CENTER).
-
-    Parameters:
-    ----------
-    field_xds: xr.Dataset
-        generic field xarray dataset
-    field_id: Union[int, np.ndarray]
-        field_id of the dataset
-    field_times:
-        Unique times for the dataset (when not partitioning by FIELD_ID)
-
-    Returns:
-    -------
-    tuple : tuple[list, dict]
-        The dimensions and coordinates to use with field data variables. The
-        dimensions are produced as a list of dimension names, and the
-        coordinates as a dict for xarray coords.
-    """
-
-    coords = {"sky_dir_label": ["ra", "dec"]}
-
-    # field_times is the same as the time axis in the main MSv4 dataset and is used if more than one field is present.
-    if field_times is not None:
-        coords["time"] = field_times
-        dims = ["time", "sky_dir_label"]
-        coords["field_name"] = (
-            "time",
-            np.char.add(field_xds["NAME"].data, np.char.add("_", field_id.astype(str))),
-        )
-        # coords["field_id"] = ("time", field_id)
-    else:
-        coords["field_name"] = field_xds["NAME"].values.item() + "_" + str(field_id)
-        # coords["field_id"] = field_id
-        dims = ["field_name", "sky_dir_label"]
-
-    return dims, coords
-
-
 def extract_field_info_and_check_ephemeris(
     field_and_source_xds: xr.Dataset,
     in_file: str,
@@ -892,14 +848,17 @@ def extract_field_info_and_check_ephemeris(
     if is_single_dish:
         to_new_data_variables = {
             "REFERENCE_DIR": [
-                "FIELD_REFERENCE_CENTER",
+                "FIELD_REFERENCE_CENTER_DIRECTION",
                 ["field_name", "sky_dir_label"],
             ],
             "FIELD_ID": ["FIELD_ID", ["field_name"]],
         }
     else:
         to_new_data_variables = {
-            "PHASE_DIR": ["FIELD_PHASE_CENTER", ["field_name", "sky_dir_label"]],
+            "PHASE_DIR": [
+                "FIELD_PHASE_CENTER_DIRECTION",
+                ["field_name", "sky_dir_label"],
+            ],
             # "DELAY_DIR": ["FIELD_DELAY_CENTER",["field_name", "sky_dir_label"]],
             # "REFERENCE_DIR": ["FIELD_REFERENCE_CENTER",["field_name", "sky_dir_label"]],
         }
@@ -937,59 +896,6 @@ def extract_field_info_and_check_ephemeris(
     # field_id shouldn ot be in final xds, and no longer needed past this point
     field_and_source_xds = field_and_source_xds.drop_vars("field_id")
 
-    # dims, coords = make_field_dims_and_coords(field_xds, field_id, field_times)
-
-    # if is_single_dish:
-    #     field_data_variables = {
-    #         "REFERENCE_DIR": "FIELD_REFERENCE_CENTER",
-    #     }
-    # else:
-    #     field_data_variables = {
-    #         # "DELAY_DIR": "FIELD_DELAY_CENTER",
-    #         "PHASE_DIR": "FIELD_PHASE_CENTER",
-    #         # "REFERENCE_DIR": "FIELD_REFERENCE_CENTER",
-    #     }
-
-    # field_column_description = field_xds.attrs["other"]["msv2"]["ctds_attrs"][
-    #     "column_descriptions"
-    # ]
-
-    # delay_dir_ref_col = "DelayDir_Ref"
-    # if field_xds.get(delay_dir_ref_col) is None:
-    #     delaydir_ref = None
-    # else:
-    #     delaydir_ref = check_if_consistent(
-    #         field_xds.get(delay_dir_ref_col), delay_dir_ref_col
-    #     )
-
-    # for generic_name, msv4_name in field_data_variables.items():
-    #     msv4_measure = column_description_casacore_to_msv4_measure(
-    #         field_column_description[generic_name], ref_code=delaydir_ref
-    #     )
-
-    #     print(msv4_name,generic_name,field_xds[generic_name].data.shape,field_xds[generic_name].data)
-
-    #     field_and_source_xds[msv4_name] = xr.DataArray.from_dict(
-    #         {
-    #             "dims": dims,
-    #             "data": list(field_xds[generic_name].data),
-    #             "attrs": msv4_measure,
-    #         }
-    #     )
-
-    #     field_measures_type = "sky_coord"
-    #     field_and_source_xds[msv4_name].attrs["type"] = field_measures_type
-
-    # field_and_source_xds = field_and_source_xds.assign_coords(coords)
-    # if "time" in field_and_source_xds:
-    #     time_column_description = field_xds.attrs["other"]["msv2"]["ctds_attrs"][
-    #         "column_descriptions"
-    #     ]["TIME"]
-    #     time_msv4_measure = column_description_casacore_to_msv4_measure(
-    #         time_column_description
-    #     )
-    #     field_and_source_xds.coords["time"].attrs.update(time_msv4_measure)
-
     return (
         field_and_source_xds,
         ephemeris_path,

xradio/measurement_set/_utils/_msv2/msv2_to_msv4_meta.py

@@ -1,4 +1,3 @@
-import toolviper.utils.logger as logger
 from xradio._utils.schema import column_description_casacore_to_msv4_measure
 
 col_to_data_variable_names = {
@@ -39,6 +38,6 @@ def create_attribute_metadata(col, main_column_descriptions):
     if col in ["DATA", "CORRECTED_DATA", "WEIGHT"]:
         if not attrs_metadata:
             attrs_metadata["type"] = "quanta"
-            attrs_metadata["units"] = ["unkown"]
+            attrs_metadata["units"] = "unkown"
 
     return attrs_metadata

xradio/measurement_set/_utils/_msv2/msv4_info_dicts.py

@@ -10,7 +10,7 @@ import toolviper.utils.logger as logger
 
 from .subtables import subt_rename_ids
 from ._tables.read import load_generic_table, convert_casacore_time
-from xradio._utils.list_and_array import check_if_consistent, unique_1d, to_list
+from xradio._utils.list_and_array import check_if_consistent
 
 
 def create_info_dicts(
@@ -47,12 +47,13 @@ def create_info_dicts(
        info dicts ready to be used to update the attrs of the MSv4
     """
 
-    if "line_name" in field_and_source_xds.coords:
-        line_name = to_list(unique_1d(np.ravel(field_and_source_xds.line_name.values)))
-    else:
-        line_name = []
-
     info_dicts = {}
+
+    # if "line_name" in field_and_source_xds.coords:
+    #     line_name = to_list(unique_1d(np.ravel(field_and_source_xds.line_name.values)))
+    # else:
+    #     line_name = []
+
     # info_dicts["partition_info"] = {
     #     # "spectral_window_id": xds.frequency.attrs["spectral_window_id"],
     #     "spectral_window_name": xds.frequency.attrs["spectral_window_name"],
@@ -125,7 +126,7 @@ def create_observation_info(in_file: str, observation_id: int):
         exec_block_xds = load_generic_table(in_file, "ASDM_EXECBLOCK")
     except ValueError as exc:
         logger.debug(
-            "Did not find the ASDM_EXECBLOCK subtable, not loading optional fields in observation_info"
+            f"Did not find the ASDM_EXECBLOCK subtable, not loading optional fields in observation_info. Exception: {exc}"
         )
     if exec_block_xds:
         exec_block_info = extract_exec_block_info(exec_block_xds)