xradio 0.0.40__py3-none-any.whl → 0.0.41__py3-none-any.whl

xradio/{vis/_vis_utils → correlated_data/_utils}/_ms/create_antenna_xds.py

@@ -6,14 +6,16 @@ import numpy as np
 import xarray as xr
 import os
 
-from xradio.vis._vis_utils._ms.subtables import subt_rename_ids
-from xradio.vis._vis_utils._ms._tables.read import (
+from xradio.correlated_data._utils._ms.subtables import subt_rename_ids
+from xradio.correlated_data._utils._ms._tables.read import (
     load_generic_table,
+    convert_casacore_time,
     convert_casacore_time_to_mjd,
     make_taql_where_between_min_max,
+    table_exists,
 )
 from xradio._utils.schema import convert_generic_xds_to_xradio_schema
-from xradio.vis._vis_utils._ms.msv4_sub_xdss import interpolate_to_time
+from xradio.correlated_data._utils._ms.msv4_sub_xdss import interpolate_to_time
 
 from xradio._utils.list_and_array import (
     check_if_consistent,
@@ -29,8 +31,6 @@ def create_antenna_xds(
     antenna_id: list,
     feed_id: list,
     telescope_name: str,
-    time_min_max: Tuple[np.float64, np.float64],
-    phase_cal_interp_time: Union[xr.DataArray, None] = None,
 ) -> xr.Dataset:
     """
     Create an Xarray Dataset containing antenna information.
@@ -47,10 +47,6 @@ def create_antenna_xds(
         List of feed IDs.
     telescope_name : str
         Name of the telescope.
-    time_min_max : Tuple[np.float46, np.float64]
-        Min / max times to constrain loading (usually to the time range relevant to an MSv4)
-    phase_cal_interp_time : Union[xr.DataArray, None]
-        Time axis to interpolate the data vars to (usually main MSv4 time)
 
     Returns
     ----------
@@ -64,13 +60,6 @@ def create_antenna_xds(
         ant_xds, in_file, antenna_id, feed_id, spectral_window_id
     )
 
-    ant_xds = extract_phase_cal_info(
-        ant_xds, in_file, spectral_window_id, time_min_max, phase_cal_interp_time
-    )  # Only used in VLBI.
-    ant_xds = extract_gain_curve_info(
-        ant_xds, in_file, spectral_window_id
-    )  # Only used in VLBI.
-
     ant_xds.attrs["overall_telescope_name"] = telescope_name
     return ant_xds
 
@@ -164,6 +153,15 @@ def extract_antenna_info(
     else:
         ant_xds.attrs["relocatable_antennas"] = False
 
+    ant_xds = ant_xds.assign_coords(
+        {
+            "telescope_name": (
+                "antenna_name",
+                np.array([telescope_name for ant in ant_xds["antenna_name"]]),
+            )
+        }
+    )
+
     return ant_xds
 
 
@@ -277,103 +275,122 @@ def extract_feed_info(
     return ant_xds
 
 
-def extract_gain_curve_info(
-    ant_xds: xr.Dataset, in_file: str, spectral_window_id: int
+def create_gain_curve_xds(
+    in_file: str, spectral_window_id: int, ant_xds: xr.Dataset
 ) -> xr.Dataset:
     """
-    Reformats MSv2 GAIN CURVE table content to MSv4 schema.
+    Produces a gain_curve_xds, reformats MSv2 GAIN CURVE table content to MSv4 schema.
 
     Parameters
     ----------
-    ant_xds : xr.Dataset
-        The dataset that will be updated with gain curve information.
     in_file : str
         Path to the input MSv2.
     spectral_window_id : int
         The ID of the spectral window.
+    ant_xds : xr.Dataset
+        The antenna_xds that has information such as names, stations, etc., for coordinates
 
     Returns
     -------
     xr.Dataset
         The updated antenna dataset with gain curve information.
     """
-    if os.path.exists(
-        os.path.join(in_file, "GAIN_CURVE")
-    ):  # Check if the table exists.
-        generic_gain_curve_xds = load_generic_table(
-            in_file,
+
+    gain_curve_xds = None
+    if not table_exists(os.path.join(in_file, "GAIN_CURVE")):
+        return gain_curve_xds
+
+    generic_gain_curve_xds = load_generic_table(
+        in_file,
+        "GAIN_CURVE",
+        taql_where=f" where (ANTENNA_ID IN [{','.join(map(str,ant_xds.antenna_id.values))}]) AND (SPECTRAL_WINDOW_ID = {spectral_window_id})",
+    )
+
+    if not generic_gain_curve_xds.data_vars:
+        # Some times the gain_curve table is empty (this is the case with ngEHT simulation data we have).
+        return gain_curve_xds
+
+    assert (
+        len(generic_gain_curve_xds.SPECTRAL_WINDOW_ID) == 1
+    ), "Only one spectral window is supported."
+    generic_gain_curve_xds = generic_gain_curve_xds.isel(
+        SPECTRAL_WINDOW_ID=0, drop=True
+    )  # Drop the spectral window dimension as it is singleton.
+
+    assert (
+        len(generic_gain_curve_xds.TIME) == 1
+    ), "Only one gain curve measurement per antenna is supported."
+    measured_time = generic_gain_curve_xds.coords["TIME"].values[0]
+    generic_gain_curve_xds = generic_gain_curve_xds.isel(TIME=0, drop=True)
+
+    generic_gain_curve_xds = generic_gain_curve_xds.sel(
+        ANTENNA_ID=ant_xds.antenna_id, drop=False
+    )  # Make sure the antenna_id is in the same order as the xds .
+
+    gain_curve_xds = xr.Dataset(attrs={"type": "gain_curve"})
+
+    to_new_data_variables = {
+        "INTERVAL": ["GAIN_CURVE_INTERVAL", ["antenna_name"]],
+        "GAIN": [
             "GAIN_CURVE",
-            taql_where=f" where (ANTENNA_ID IN [{','.join(map(str,ant_xds.antenna_id.values))}]) AND (SPECTRAL_WINDOW_ID = {spectral_window_id})",
-        )
+            ["antenna_name", "poly_term", "receptor_label"],
+        ],
+        "SENSITIVITY": [
+            "GAIN_CURVE_SENSITIVITY",
+            ["antenna_name", "receptor_label"],
+        ],
+    }
 
-        if (
-            generic_gain_curve_xds.data_vars
-        ):  # Some times the gain_curve table is empty (this is the case with ngEHT simulation data we have).
-
-            assert (
-                len(generic_gain_curve_xds.SPECTRAL_WINDOW_ID) == 1
-            ), "Only one spectral window is supported."
-            generic_gain_curve_xds = generic_gain_curve_xds.isel(
-                SPECTRAL_WINDOW_ID=0, drop=True
-            )  # Drop the spectral window dimension as it is singleton.
-
-            assert (
-                len(generic_gain_curve_xds.TIME) == 1
-            ), "Only one gain curve measurement per antenna is supported."
-            generic_gain_curve_xds = generic_gain_curve_xds.isel(TIME=0, drop=True)
-
-            generic_gain_curve_xds = generic_gain_curve_xds.sel(
-                ANTENNA_ID=ant_xds.antenna_id, drop=False
-            )  # Make sure the antenna_id is in the same order as the xds .
-
-            to_new_data_variables = {
-                "INTERVAL": ["GAIN_CURVE_INTERVAL", ["antenna_name"]],
-                "GAIN": [
-                    "GAIN_CURVE",
-                    ["antenna_name", "poly_term", "receptor_label"],
-                ],
-                "SENSITIVITY": [
-                    "GAIN_CURVE_SENSITIVITY",
-                    ["antenna_name", "receptor_label"],
-                ],
-            }
-
-            to_new_coords = {
-                "TYPE": ["gain_curve_type", ["antenna_name"]],
-            }
-
-            # print(generic_gain_curve_xds)
-
-            ant_xds = convert_generic_xds_to_xradio_schema(
-                generic_gain_curve_xds,
-                ant_xds,
-                to_new_data_variables,
-                to_new_coords,
-            )
-            ant_xds["GAIN_CURVE"] = ant_xds["GAIN_CURVE"].transpose(
-                "antenna_name", "receptor_label", "poly_term"
-            )
+    to_new_coords = {
+        "TYPE": ["gain_curve_type", ["antenna_name"]],
+    }
 
-        return ant_xds
+    gain_curve_xds = convert_generic_xds_to_xradio_schema(
+        generic_gain_curve_xds,
+        gain_curve_xds,
+        to_new_data_variables,
+        to_new_coords,
+    )
 
-    else:
-        return ant_xds
+    ant_borrowed_coords = {
+        "antenna_name": ant_xds.coords["antenna_name"],
+        "station": ant_xds.coords["station"],
+        "mount": ant_xds.coords["mount"],
+        "telescope_name": ant_xds.coords["telescope_name"],
+        "receptor_label": ant_xds.coords["receptor_label"],
+        "polarization_type": ant_xds.coords["polarization_type"],
+    }
+    gain_curve_xds = gain_curve_xds.assign_coords(ant_borrowed_coords)
+
+    gain_curve_xds.attrs.update(
+        {
+            "measured_date": np.datetime_as_string(
+                convert_casacore_time([measured_time])[0]
+            )
+        }
+    )
 
+    return gain_curve_xds
 
-def extract_phase_cal_info(
-    ant_xds, path, spectral_window_id, time_min_max, phase_cal_interp_time
-):
+
+def create_phase_calibration_xds(
+    in_file: str,
+    spectral_window_id: int,
+    ant_xds: xr.Dataset,
+    time_min_max: Tuple[np.float64, np.float64],
+    phase_cal_interp_time: Union[xr.DataArray, None] = None,
+) -> xr.Dataset:
     """
-    Reformats MSv2 Phase Cal table content to MSv4 schema.
+    Produces a phase_calibration_xds, reformats MSv2 Phase Cal table content to MSv4 schema.
 
     Parameters
     ----------
-    ant_xds : xr.Dataset
-        The dataset that will be updated with phase cal information.
     in_file : str
         Path to the input MSv2.
     spectral_window_id : int
         The ID of the spectral window.
+    ant_xds : xr.Dataset
+        The antenna_xds that has information such as names, stations, etc., for coordinates
     time_min_max : Tuple[np.float46, np.float64]
         Min / max times to constrain loading (usually to the time range relevant to an MSv4)
     interp_time : Union[xr.DataArray, None]
@@ -385,98 +402,109 @@ def extract_phase_cal_info(
         The updated antenna dataset with phase cal information.
     """
 
-    if os.path.exists(os.path.join(path, "PHASE_CAL")):
+    phase_cal_xds = None
+    if not table_exists(os.path.join(in_file, "PHASE_CAL")):
+        return phase_cal_xds
 
-        # Only read data between the min and max times of the visibility data in the MSv4.
-        taql_time_range = make_taql_where_between_min_max(
-            time_min_max, path, "PHASE_CAL", "TIME"
-        )
-        generic_phase_cal_xds = load_generic_table(
-            path,
-            "PHASE_CAL",
-            timecols=["TIME"],
-            taql_where=f" {taql_time_range} AND (ANTENNA_ID IN [{','.join(map(str,ant_xds.antenna_id.values))}]) AND (SPECTRAL_WINDOW_ID = {spectral_window_id})",
-        )
+    # Only read data between the min and max times of the visibility data in the MSv4.
+    taql_time_range = make_taql_where_between_min_max(
+        time_min_max, in_file, "PHASE_CAL", "TIME"
+    )
+    generic_phase_cal_xds = load_generic_table(
+        in_file,
+        "PHASE_CAL",
+        timecols=["TIME"],
+        taql_where=f" {taql_time_range} AND (ANTENNA_ID IN [{','.join(map(str,ant_xds.antenna_id.values))}]) AND (SPECTRAL_WINDOW_ID = {spectral_window_id})",
+    )
 
-        assert (
-            len(generic_phase_cal_xds.SPECTRAL_WINDOW_ID) == 1
-        ), "Only one spectral window is supported."
-        generic_phase_cal_xds = generic_phase_cal_xds.isel(
-            SPECTRAL_WINDOW_ID=0, drop=True
-        )  # Drop the spectral window dimension as it is singleton.
-
-        generic_phase_cal_xds = generic_phase_cal_xds.sel(
-            ANTENNA_ID=ant_xds.antenna_id, drop=False
-        )  # Make sure the antenna_id is in the same order as the xds.
-
-        to_new_data_variables = {
-            "INTERVAL": ["PHASE_CAL_INTERVAL", ["antenna_name", "time_phase_cal"]],
-            "TONE_FREQUENCY": [
-                "PHASE_CAL_TONE_FREQUENCY",
-                ["antenna_name", "time_phase_cal", "tone_label", "receptor_label"],
-            ],
-            "PHASE_CAL": [
-                "PHASE_CAL",
-                ["antenna_name", "time_phase_cal", "tone_label", "receptor_label"],
-            ],
-            "CABLE_CAL": ["PHASE_CAL_CABLE_CAL", ["antenna_name", "time_phase_cal"]],
-        }
+    assert (
+        len(generic_phase_cal_xds.SPECTRAL_WINDOW_ID) == 1
+    ), "Only one spectral window is supported."
+    generic_phase_cal_xds = generic_phase_cal_xds.isel(
+        SPECTRAL_WINDOW_ID=0, drop=True
+    )  # Drop the spectral window dimension as it is singleton.
+
+    generic_phase_cal_xds = generic_phase_cal_xds.sel(
+        ANTENNA_ID=ant_xds.antenna_id, drop=False
+    )  # Make sure the antenna_id is in the same order as the xds.
 
-        to_new_coords = {
-            "TIME": ["time_phase_cal", ["time_phase_cal"]],
-        }
+    to_new_data_variables = {
+        "INTERVAL": ["PHASE_CAL_INTERVAL", ["antenna_name", "time_phase_cal"]],
+        "TONE_FREQUENCY": [
+            "PHASE_CAL_TONE_FREQUENCY",
+            ["antenna_name", "time_phase_cal", "tone_label", "receptor_label"],
+        ],
+        "PHASE_CAL": [
+            "PHASE_CAL",
+            ["antenna_name", "time_phase_cal", "tone_label", "receptor_label"],
+        ],
+        "CABLE_CAL": ["PHASE_CAL_CABLE_CAL", ["antenna_name", "time_phase_cal"]],
+    }
 
-        ant_xds = convert_generic_xds_to_xradio_schema(
-            generic_phase_cal_xds, ant_xds, to_new_data_variables, to_new_coords
-        )
-        ant_xds["PHASE_CAL"] = ant_xds["PHASE_CAL"].transpose(
-            "antenna_name", "time_phase_cal", "receptor_label", "tone_label"
-        )
+    to_new_coords = {
+        "TIME": ["time_phase_cal", ["time_phase_cal"]],
+    }
 
-        ant_xds["PHASE_CAL_TONE_FREQUENCY"] = ant_xds[
-            "PHASE_CAL_TONE_FREQUENCY"
-        ].transpose("antenna_name", "time_phase_cal", "receptor_label", "tone_label")
-
-        # ant_xds = ant_xds.assign_coords({"tone_label" : "freq_" + np.arange(ant_xds.sizes["tone_label"]).astype(str)}) #Works on laptop but fails in github test runner.
-        ant_xds = ant_xds.assign_coords(
-            {
-                "tone_label": np.array(
-                    list(
-                        map(
-                            lambda x, y: x + "_" + y,
-                            ["freq"] * ant_xds.sizes["tone_label"],
-                            np.arange(ant_xds.sizes["tone_label"]).astype(str),
-                        )
-                    )
-                )
-            }
-        )
+    phase_cal_xds = xr.Dataset(attrs={"type": "phase_cal"})
+    phase_cal_xds = convert_generic_xds_to_xradio_schema(
+        generic_phase_cal_xds, phase_cal_xds, to_new_data_variables, to_new_coords
+    )
 
-        ant_xds["time_phase_cal"] = (
-            ant_xds.time_phase_cal.astype("float64").astype("float64") / 10**9
+    phase_cal_xds["PHASE_CAL"] = phase_cal_xds["PHASE_CAL"].transpose(
+        "antenna_name", "time_phase_cal", "receptor_label", "tone_label"
+    )
+    phase_cal_xds["PHASE_CAL_TONE_FREQUENCY"] = phase_cal_xds[
+        "PHASE_CAL_TONE_FREQUENCY"
+    ].transpose("antenna_name", "time_phase_cal", "receptor_label", "tone_label")
+
+    ant_borrowed_coords = {
+        "antenna_name": ant_xds.coords["antenna_name"],
+        "station": ant_xds.coords["station"],
+        "mount": ant_xds.coords["mount"],
+        "telescope_name": ant_xds.coords["telescope_name"],
+        "receptor_label": ant_xds.coords["receptor_label"],
+        "polarization_type": ant_xds.coords["polarization_type"],
+    }
+    # phase_cal_xds = phase_cal_xds.assign_coords({"tone_label" : "freq_" + np.arange(phase_cal_xds.sizes["tone_label"]).astype(str)}) #Works on laptop but fails in github test runner.
+    tone_label_coord = {
+        "tone_label": np.array(
+            list(
+                map(
+                    lambda x, y: x + "_" + y,
+                    ["freq"] * phase_cal_xds.sizes["tone_label"],
+                    np.arange(phase_cal_xds.sizes["tone_label"]).astype(str),
+                )
+            )
         )
+    }
+    phase_cal_xds = phase_cal_xds.assign_coords(ant_borrowed_coords | tone_label_coord)
 
-        ant_xds = interpolate_to_time(
-            ant_xds, phase_cal_interp_time, "antenna_xds", time_name="time_phase_cal"
-        )
+    # Adjust expected types
+    phase_cal_xds["time_phase_cal"] = (
+        phase_cal_xds.time_phase_cal.astype("float64").astype("float64") / 10**9
+    )
 
-        time_coord_attrs = {
-            "type": "time",
-            "units": ["s"],
-            "scale": "UTC",
-            "format": "UNIX",
-        }
+    phase_cal_xds = interpolate_to_time(
+        phase_cal_xds,
+        phase_cal_interp_time,
+        "antenna_xds",
+        time_name="time_phase_cal",
+    )
 
-        # If we interpolate rename the time_ephemeris_axis axis to time.
-        if phase_cal_interp_time is not None:
-            time_coord = {"time": ("time_phase_cal", phase_cal_interp_time.data)}
-            ant_xds = ant_xds.assign_coords(time_coord)
-            ant_xds.coords["time"].attrs.update(time_coord_attrs)
-            ant_xds = ant_xds.swap_dims({"time_phase_cal": "time"}).drop_vars(
-                "time_phase_cal"
-            )
+    time_coord_attrs = {
+        "type": "time",
+        "units": ["s"],
+        "scale": "UTC",
+        "format": "UNIX",
+    }
 
-        return ant_xds
+    # If we interpolate rename the time_phase_cal axis to time.
+    if phase_cal_interp_time is not None:
+        time_coord = {"time": ("time_phase_cal", phase_cal_interp_time.data)}
+        phase_cal_xds = phase_cal_xds.assign_coords(time_coord)
+        phase_cal_xds.coords["time"].attrs.update(time_coord_attrs)
+        phase_cal_xds = phase_cal_xds.swap_dims({"time_phase_cal": "time"}).drop_vars(
+            "time_phase_cal"
+        )
 
-    else:
-        return ant_xds
+    return phase_cal_xds

xradio/{vis/_vis_utils → correlated_data/_utils}/_ms/create_field_and_source_xds.py

@@ -6,9 +6,9 @@ import numpy as np
 import xarray as xr
 
 import toolviper.utils.logger as logger
-from xradio.vis._vis_utils._ms.msv4_sub_xdss import interpolate_to_time
-from xradio.vis._vis_utils._ms.subtables import subt_rename_ids
-from xradio.vis._vis_utils._ms._tables.read import (
+from xradio.correlated_data._utils._ms.msv4_sub_xdss import interpolate_to_time
+from xradio.correlated_data._utils._ms.subtables import subt_rename_ids
+from xradio.correlated_data._utils._ms._tables.read import (
     convert_casacore_time_to_mjd,
     make_taql_where_between_min_max,
     load_generic_table,
@@ -160,7 +160,7 @@ def extract_ephemeris_info(
 
     # Get meta data.
     ephemeris_meta = ephemeris_xds.attrs["other"]["msv2"]["ctds_attrs"]
-    ephemris_column_description = ephemeris_xds.attrs["other"]["msv2"]["ctds_attrs"][
+    ephemeris_column_description = ephemeris_xds.attrs["other"]["msv2"]["ctds_attrs"][
         "column_descriptions"
     ]
 
@@ -174,27 +174,27 @@ def extract_ephemeris_info(
         sky_coord_frame = "ICRS"  # We will have to just assume this.
 
     # Find out witch keyword is used for units (UNIT/QuantumUnits)
-    if "UNIT" in ephemris_column_description["RA"]["keywords"]:
+    if "UNIT" in ephemeris_column_description["RA"]["keywords"]:
         unit_keyword = "UNIT"
     else:
         unit_keyword = "QuantumUnits"
 
     temp_xds = xr.Dataset()
 
-    # Add mandatory data: OBSERVATION_POSITION
-    observation_position = [
+    # Add mandatory data: OBSERVER_POSITION
+    observer_position = [
         ephemeris_meta["GeoLong"],
         ephemeris_meta["GeoLat"],
         ephemeris_meta["GeoDist"],
     ]
-    temp_xds["OBSERVATION_POSITION"] = xr.DataArray(
-        observation_position, dims=["ellipsoid_pos_label"]
+    temp_xds["OBSERVER_POSITION"] = xr.DataArray(
+        observer_position, dims=["ellipsoid_pos_label"]
     )
-    temp_xds["OBSERVATION_POSITION"].attrs.update(
+    temp_xds["OBSERVER_POSITION"].attrs.update(
         {
             "type": "location",
             "units": ["deg", "deg", "m"],
-            "data": observation_position,
+            "data": observer_position,
             "ellipsoid": "WGS84",
             "origin_object_name": "Earth",
             "coordinate_system": ephemeris_meta["obsloc"].lower(),
@@ -210,13 +210,13 @@ def extract_ephemeris_info(
                 ephemeris_xds["Rho"].data,
             )
         ),
-        dims=["time_ephemeris_axis", "sky_pos_label"],
+        dims=["time_ephemeris", "sky_pos_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(ephemris_column_description["RA"]["keywords"][unit_keyword]),
-        cast_to_str(ephemris_column_description["DEC"]["keywords"][unit_keyword]),
-        cast_to_str(ephemris_column_description["Rho"]["keywords"][unit_keyword]),
+        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(
         {"type": "sky_coord", "frame": sky_coord_frame, "units": sky_coord_units}
@@ -227,16 +227,17 @@ 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
-        "RadVel": ["SOURCE_RADIAL_VELOCITY", ["time_ephemeris_axis"]],
+        "RadVel": ["SOURCE_RADIAL_VELOCITY", time_ephemeris_dim],
         # optional: data NORTH_POLE_POSITION_ANGLE and NORTH_POLE_ANGULAR_DISTANCE
-        "NP_ang": ["NORTH_POLE_POSITION_ANGLE", ["time_ephemeris_axis"]],
-        "NP_dist": ["NORTH_POLE_ANGULAR_DISTANCE", ["time_ephemeris_axis"]],
+        "NP_ang": ["NORTH_POLE_POSITION_ANGLE", time_ephemeris_dim],
+        "NP_dist": ["NORTH_POLE_ANGULAR_DISTANCE", time_ephemeris_dim],
         # optional: HELIOCENTRIC_RADIAL_VELOCITY
-        "rdot": ["HELIOCENTRIC_RADIAL_VELOCITY", ["time_ephemeris_axis"]],
+        "rdot": ["HELIOCENTRIC_RADIAL_VELOCITY", time_ephemeris_dim],
         # optional: OBSERVER_PHASE_ANGLE
-        "phang": ["OBSERVER_PHASE_ANGLE", ["time_ephemeris_axis"]],
+        "phang": ["OBSERVER_PHASE_ANGLE", time_ephemeris_dim],
     }
     convert_generic_xds_to_xradio_schema(
         ephemeris_xds, temp_xds, to_new_data_variables, {}
@@ -251,7 +252,7 @@ def extract_ephemeris_info(
                     "type": "quantity",
                     "units": [
                         cast_to_str(
-                            ephemris_column_description[generic_var_name]["keywords"][
+                            ephemeris_column_description[generic_var_name]["keywords"][
                                 unit_keyword
                             ]
                         )
@@ -260,7 +261,7 @@ def extract_ephemeris_info(
             )
 
     # Add optional data: SUB_OBSERVER_POSITION and SUB_SOLAR_POSITION
-    if "DiskLong" in ephemris_column_description:
+    if "DiskLong" in ephemeris_column_description:
         key_lon = "DiskLong"
         key_lat = "DiskLat"
     else:
@@ -268,7 +269,7 @@ def extract_ephemeris_info(
         key_lat = "diskLat"
 
     if key_lon in ephemeris_xds.data_vars:
-        temp_xds["SUB_OBSERVER_POSITION"] = xr.DataArray(
+        temp_xds["SUB_OBSERVER_DIRECTION"] = xr.DataArray(
             np.column_stack(
                 (
                     ephemeris_xds[key_lon].data,
@@ -276,10 +277,10 @@ def extract_ephemeris_info(
                     np.zeros(ephemeris_xds[key_lon].shape),
                 )
             ),
-            dims=["time_ephemeris_axis", "ellipsoid_pos_label"],
+            dims=["time_ephemeris", "ellipsoid_pos_label"],
         )
 
-        temp_xds["SUB_OBSERVER_POSITION"].attrs.update(
+        temp_xds["SUB_OBSERVER_DIRECTION"].attrs.update(
             {
                 "type": "location",
                 "ellipsoid": "NA",
@@ -287,10 +288,10 @@ def extract_ephemeris_info(
                 "coordinate_system": "planetodetic",
                 "units": [
                     cast_to_str(
-                        ephemris_column_description[key_lon]["keywords"][unit_keyword]
+                        ephemeris_column_description[key_lon]["keywords"][unit_keyword]
                     ),
                     cast_to_str(
-                        ephemris_column_description[key_lat]["keywords"][unit_keyword]
+                        ephemeris_column_description[key_lat]["keywords"][unit_keyword]
                     ),
                     "m",
                 ],
@@ -306,7 +307,7 @@ def extract_ephemeris_info(
                     ephemeris_xds["r"].data,
                 )
             ),
-            dims=["time_ephemeris_axis", "ellipsoid_pos_label"],
+            dims=["time_ephemeris", "ellipsoid_pos_label"],
         )
         temp_xds["SUB_SOLAR_POSITION"].attrs.update(
             {
@@ -316,22 +317,22 @@ def extract_ephemeris_info(
                 "coordinate_system": "planetodetic",
                 "units": [
                     cast_to_str(
-                        ephemris_column_description["SI_lon"]["keywords"][unit_keyword]
+                        ephemeris_column_description["SI_lon"]["keywords"][unit_keyword]
                     ),
                     cast_to_str(
-                        ephemris_column_description["SI_lat"]["keywords"][unit_keyword]
+                        ephemeris_column_description["SI_lat"]["keywords"][unit_keyword]
                     ),
                     cast_to_str(
-                        ephemris_column_description["r"]["keywords"][unit_keyword]
+                        ephemeris_column_description["r"]["keywords"][unit_keyword]
                     ),
                 ],
             }
         )
 
-    # We are using the "time_ephemeris_axis" 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.
+    # 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"],
-        "time_ephemeris_axis": ephemeris_xds["time"].data,
+        "time_ephemeris": ephemeris_xds["time"].data,
         "sky_pos_label": ["ra", "dec", "dist"],
     }
     temp_xds = temp_xds.assign_coords(coords)
@@ -341,21 +342,21 @@ def extract_ephemeris_info(
         "scale": "UTC",
         "format": "UNIX",
     }
-    temp_xds["time_ephemeris_axis"].attrs.update(time_coord_attrs)
+    temp_xds["time_ephemeris"].attrs.update(time_coord_attrs)
 
     # Convert to si units and interpolate if ephemeris_interpolate=True:
     temp_xds = convert_to_si_units(temp_xds)
     temp_xds = interpolate_to_time(
-        temp_xds, interp_time, "field_and_source_xds", time_name="time_ephemeris_axis"
+        temp_xds, interp_time, "field_and_source_xds", time_name="time_ephemeris"
     )
 
-    # If we interpolate rename the time_ephemeris_axis axis to time.
+    # If we interpolate rename the time_ephemeris axis to time.
     if interp_time is not None:
-        time_coord = {"time": ("time_ephemeris_axis", interp_time.data)}
+        time_coord = {"time": ("time_ephemeris", interp_time.data)}
         temp_xds = temp_xds.assign_coords(time_coord)
         temp_xds.coords["time"].attrs.update(time_coord_attrs)
-        temp_xds = temp_xds.swap_dims({"time_ephemeris_axis": "time"}).drop_vars(
-            "time_ephemeris_axis"
+        temp_xds = temp_xds.swap_dims({"time_ephemeris": "time"}).drop_vars(
+            "time_ephemeris"
         )
 
     xds = xr.merge([xds, temp_xds])