imap-processing 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

imap_processing/tests/ultra/test_data/mock_data.py

@@ -0,0 +1,161 @@
+"""Mock expected data for use in some tests."""
+
+import numpy as np
+import spiceypy as spice
+import xarray as xr
+
+from imap_processing.spice.kernels import ensure_spice
+from imap_processing.ultra.l1c.ultra_l1c_pset_bins import build_energy_bins
+
+DEFAULT_SPACING_DEG_L1C = 0.5
+
+
+def mock_l1c_pset_product(
+    spacing_deg: float = DEFAULT_SPACING_DEG_L1C,
+    stripe_center_lon: int = 0,
+    timestr: str = "2025-01-01T00:00:00",
+    head: str = "45",
+) -> xr.Dataset:
+    """
+    Mock the L1C PSET product with recognizable but unrealistic counts.
+
+    This is not meant to perfectly mimic the real data, but to provide a
+    recognizable structure for L2 testing purposes.
+    Function will produce an xarray.Dataset with at least the variables and shapes:
+    counts: (num_lat_bins, num_lon_bins, num_energy_bins)
+    exposure_time: (num_lat_bins, num_lon_bins)
+    sensitivity: (num_lat_bins, num_lon_bins, num_energy_bins)
+
+    and the coordinate variables:
+    latitude: (num_lat_bins)
+    longitude: (num_lon_bins)
+    energy: (determined by build_energy_bins function)
+    head: Either '45' or '90'. Default is '45'.
+
+    as well as the epoch (assumed to be a single time for each product).
+
+    The counts are generated along a stripe, centered at a given longitude.
+    This stripe can be thought of as a 'vertical' line if the lon/az axis is plotted
+    as the x-axis and the lat/el axis is plotted as the y-axis. See the figure below.
+
+    ^  Elevation/Latitude
+    |
+    |    000000000000002468642000000000000000000000000000000
+    |    000000000000002468642000000000000000000000000000000
+    |    000000000000002468642000000000000000000000000000000
+    |    000000000000002468642000000000000000000000000000000
+    |    000000000000002468642000000000000000000000000000000
+    |    000000000000002468642000000000000000000000000000000
+    |    000000000000002468642000000000000000000000000000000
+    --------------------------------------------------------->
+    Azimuth/Longitude ->
+
+    Fig. 1: Example of the '90' sensor head stripe
+
+    To distinguish between the two sensor heads, the counts are halved in the '45' head
+    at latitudes above 0 degrees.
+
+    ^  Elevation/Latitude
+    |
+    |    000000000000000000000000000123432100000000000000000
+    |    000000000000000000000000000123432100000000000000000
+    |    000000000000000000000000000123432100000000000000000
+    |    000000000000000000000000000123432100000000000000000
+    |    000000000000000000000000000246864200000000000000000
+    |    000000000000000000000000000246864200000000000000000
+    |    000000000000000000000000000246864200000000000000000
+    --------------------------------------------------------->
+    Azimuth/Longitude ->
+
+    Fig. 2: Example of the '45' sensor head stripe
+
+    Parameters
+    ----------
+    spacing_deg : float, optional
+        The bin spacing in degrees (default is 0.5 degrees).
+    stripe_center_lon : int, optional
+        The center longitude of the stripe in degrees (default is 0).
+    timestr : str, optional
+        The time string for the epoch (default is "2025-01-01T00:00:00").
+    head : str, optional
+        The sensor head (either '45' or '90') (default is '45').
+    """
+    num_lat_bins = int(180 / spacing_deg)
+    num_lon_bins = int(360 / spacing_deg)
+    stripe_center_lon_bin = int(stripe_center_lon / spacing_deg)
+
+    _, energy_bin_midpoints = build_energy_bins()
+    energy_bin_midpoints = energy_bin_midpoints[1:]
+    num_energy_bins = len(energy_bin_midpoints)
+
+    grid_shape = (num_lon_bins, num_lat_bins, num_energy_bins)
+
+    def get_binomial_counts(distance_scaling, lon_bin, central_lon_bin):
+        # Note, this is not quite correct, as it won't wrap around at 720
+        distance_lon_bin = np.abs(lon_bin - central_lon_bin)
+
+        rng = np.random.default_rng(seed=42)
+        return rng.binomial(
+            n=50,
+            p=np.maximum(1 - (distance_lon_bin / distance_scaling), 0.01),
+        )
+
+    counts = np.fromfunction(
+        lambda lon_bin, lat_bin, energy_bin: get_binomial_counts(
+            distance_scaling=20,
+            lon_bin=lon_bin,
+            central_lon_bin=stripe_center_lon_bin,
+        ),
+        shape=grid_shape,
+    )
+
+    exposure_time = np.zeros(grid_shape[:2]) + 0.1
+    if head == "90":
+        exposure_time[
+            stripe_center_lon_bin : stripe_center_lon_bin + int(20 / spacing_deg),
+            :,
+        ] = 1
+    else:
+        counts[
+            :,
+            : int(90 / spacing_deg),
+            :,
+        ] / 2
+        counts = counts.astype(int)
+        exposure_time[
+            stripe_center_lon_bin : stripe_center_lon_bin + int(70 / spacing_deg),
+            : int(90 / spacing_deg),
+        ] = 1
+
+    sensitivity = np.ones(grid_shape)
+
+    pset_product = xr.Dataset(
+        {
+            "counts": (
+                ["azimuth_bin_center", "elevation_bin_center", "energy_bin_center"],
+                counts,
+            ),
+            "exposure_time": (
+                ["azimuth_bin_center", "elevation_bin_center"],
+                exposure_time,
+            ),
+            "sensitivity": (
+                ["azimuth_bin_center", "elevation_bin_center", "energy_bin_center"],
+                sensitivity,
+            ),
+            "epoch": ensure_spice(spice.str2et, time_kernels_only=True)(timestr),
+        },
+        coords={
+            "azimuth_bin_center": np.arange(0 + spacing_deg / 2, 360, spacing_deg),
+            "elevation_bin_center": np.arange(-90 + spacing_deg / 2, 90, spacing_deg),
+            "energy_bin_center": energy_bin_midpoints,
+        },
+        attrs={
+            "Logical_file_id": (
+                f"imap_ultra_l1c_{head}sensor-pset_{timestr[:4]}"
+                f"{timestr[5:7]}{timestr[8:10]}-repointNNNNN_vNNN"
+            )
+        },
+    )
+
+    return pset_product

imap_processing/tests/ultra/unit/conftest.py

@@ -1,5 +1,7 @@
 """Pytest plugin module for test data paths"""
 
+from unittest import mock
+
 import numpy as np
 import pytest
 
@@ -8,8 +10,10 @@ from imap_processing.ultra.l0.decom_ultra import process_ultra_apids
 from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_AUX,
     ULTRA_EVENTS,
+    ULTRA_RATES,
 )
 from imap_processing.ultra.l1a import ultra_l1a
+from imap_processing.ultra.l1b.ultra_l1b import ultra_l1b
 from imap_processing.utils import group_by_apid
 
 
@@ -165,3 +169,72 @@ def de_dataset(ccsds_path_theta_0, xtce_path):
         dataset["START_TYPE"] != np.iinfo(np.int64).min, drop=True
     )
     return l1a_de_dataset
+
+
+@pytest.fixture()
+def rates_dataset(ccsds_path_theta_0, xtce_path):
+    """L1A test data"""
+    packets = decom.decom_packets(ccsds_path_theta_0, xtce_path)
+    grouped_data = group_by_apid(packets)
+    decom_ultra_rates = process_ultra_apids(
+        grouped_data[ULTRA_RATES.apid[0]], ULTRA_RATES.apid[0]
+    )
+    l1a_rates_dataset = ultra_l1a.create_dataset(
+        {
+            ULTRA_RATES.apid[0]: decom_ultra_rates,
+        }
+    )
+    return l1a_rates_dataset
+
+
+@pytest.fixture()
+def aux_dataset(ccsds_path_theta_0, xtce_path):
+    """L1A test data"""
+    packets = decom.decom_packets(ccsds_path_theta_0, xtce_path)
+    grouped_data = group_by_apid(packets)
+    decom_ultra_aux = process_ultra_apids(
+        grouped_data[ULTRA_AUX.apid[0]], ULTRA_AUX.apid[0]
+    )
+    l1a_aux_dataset = ultra_l1a.create_dataset(
+        {
+            ULTRA_AUX.apid[0]: decom_ultra_aux,
+        }
+    )
+    return l1a_aux_dataset
+
+
+@pytest.fixture()
+@mock.patch("imap_processing.ultra.l1b.de.get_annotated_particle_velocity")
+def l1b_datasets(
+    mock_get_annotated_particle_velocity, de_dataset, use_fake_spin_data_for_time
+):
+    """L1B test data"""
+
+    data_dict = {}
+    data_dict[de_dataset.attrs["Logical_source"]] = de_dataset
+    # TODO: this is a placeholder for the hk dataset.
+    data_dict["imap_ultra_l1a_45sensor-hk"] = aux_dataset
+    data_dict["imap_ultra_l1a_45sensor-rates"] = rates_dataset
+    use_fake_spin_data_for_time(
+        de_dataset["EVENTTIMES"][0], de_dataset["EVENTTIMES"][-1]
+    )
+
+    # Mock get_annotated_particle_velocity to avoid needing kernels
+    def side_effect_func(event_times, position, ultra_frame, dps_frame, sc_frame):
+        """
+        Mock behavior of get_annotated_particle_velocity.
+
+        Returns NaN-filled arrays matching the expected output shape.
+        """
+        num_events = event_times.size
+        return (
+            np.full((num_events, 3), np.nan),  # sc_velocity
+            np.full((num_events, 3), np.nan),  # sc_dps_velocity
+            np.full((num_events, 3), np.nan),  # helio_velocity
+        )
+
+    mock_get_annotated_particle_velocity.side_effect = side_effect_func
+
+    output_datasets = ultra_l1b(data_dict, data_version="001")
+
+    return output_datasets

imap_processing/tests/ultra/unit/test_badtimes.py

@@ -0,0 +1,58 @@
+import numpy as np
+import xarray as xr
+
+from imap_processing.quality_flags import ImapAttitudeUltraFlags, ImapRatesUltraFlags
+from imap_processing.ultra.l1b.badtimes import calculate_badtimes
+from imap_processing.ultra.l1b.cullingmask import calculate_cullingmask
+
+
+def test_calculate_badtimes():
+    """Test calculate_badtimes."""
+
+    spin_numbers = np.array([0, 1, 2, 3])
+    energy_bins = np.array([10, 20, 30, 40])
+
+    quality_attitude = np.full(
+        spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
+    )
+
+    quality_ena_rates = np.full(
+        (len(energy_bins), len(spin_numbers)),
+        ImapRatesUltraFlags.NONE.value,
+        dtype=np.uint16,
+    )
+
+    quality_ena_rates[:, 0] |= ImapRatesUltraFlags.ZEROCOUNTS.value
+    quality_ena_rates[0, 1] |= ImapRatesUltraFlags.ZEROCOUNTS.value
+    quality_ena_rates[0, 2] |= ImapRatesUltraFlags.HIGHRATES.value
+    quality_ena_rates[0, 3] |= (
+        ImapRatesUltraFlags.ZEROCOUNTS.value | ImapRatesUltraFlags.HIGHRATES.value
+    )
+
+    ds = xr.Dataset(
+        {
+            "quality_attitude": (("spin_number",), quality_attitude),
+            "quality_ena_rates": (
+                ("energy_bin_geometric_mean", "spin_number"),
+                quality_ena_rates,
+            ),
+        },
+        coords={
+            "spin_number": spin_numbers,
+            "energy_bin_geometric_mean": energy_bins,
+        },
+    )
+
+    culling_ds = calculate_cullingmask(
+        ds, name="imap_ultra_l1b_45sensor-badtimes", data_version="v1"
+    )
+    badtimes_ds = calculate_badtimes(
+        ds,
+        culling_ds["spin_number"].values,
+        name="imap_ultra_l1b_45sensor-badtimes",
+        data_version="v1",
+    )
+
+    assert not np.any(
+        np.isin(culling_ds["spin_number"].values, badtimes_ds["spin_number"].values)
+    )

imap_processing/tests/ultra/unit/test_cullingmask.py

@@ -0,0 +1,87 @@
+import numpy as np
+import xarray as xr
+
+from imap_processing.quality_flags import ImapAttitudeUltraFlags, ImapRatesUltraFlags
+from imap_processing.ultra.l1b.cullingmask import calculate_cullingmask
+
+
+def test_calculate_cullingmask_attitude():
+    """Test calculate_cullingmask for attitude culling."""
+
+    spin_numbers = np.array([0, 1])
+    energy_bins = np.array([10, 20, 30, 40])
+
+    quality_attitude = np.full(
+        spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
+    )
+    quality_attitude[1] |= ImapAttitudeUltraFlags.SPINRATE.value
+
+    quality_ena_rates = np.full(
+        (len(energy_bins), len(spin_numbers)),
+        ImapRatesUltraFlags.NONE.value,
+        dtype=np.uint16,
+    )
+
+    ds = xr.Dataset(
+        {
+            "quality_attitude": (("spin_number",), quality_attitude),
+            "quality_ena_rates": (
+                ("energy_bin_geometric_mean", "spin_number"),
+                quality_ena_rates,
+            ),
+        },
+        coords={
+            "spin_number": spin_numbers,
+            "energy_bin_geometric_mean": energy_bins,
+        },
+    )
+
+    result_ds = calculate_cullingmask(
+        ds, name="imap_ultra_l1b_45sensor-cullingmask", data_version="v1"
+    )
+
+    np.testing.assert_array_equal(result_ds["spin_number"].values, np.array([0]))
+
+
+def test_calculate_cullingmask_rates():
+    """Test calculate_cullingmask for rates culling."""
+    spin_numbers = np.array([0, 1, 2, 3])
+    energy_bins = np.array([10, 20, 30, 40])
+
+    quality_attitude = np.full(
+        spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
+    )
+
+    quality_ena_rates = np.full(
+        (len(energy_bins), len(spin_numbers)),
+        ImapRatesUltraFlags.NONE.value,
+        dtype=np.uint16,
+    )
+
+    quality_ena_rates[:, 0] |= ImapRatesUltraFlags.ZEROCOUNTS.value
+    quality_ena_rates[0, 1] |= ImapRatesUltraFlags.ZEROCOUNTS.value
+    quality_ena_rates[0, 2] |= ImapRatesUltraFlags.HIGHRATES.value
+    quality_ena_rates[0, 3] |= (
+        ImapRatesUltraFlags.ZEROCOUNTS.value | ImapRatesUltraFlags.HIGHRATES.value
+    )
+
+    ds = xr.Dataset(
+        {
+            "quality_attitude": (("spin_number",), quality_attitude),
+            "quality_ena_rates": (
+                ("energy_bin_geometric_mean", "spin_number"),
+                quality_ena_rates,
+            ),
+        },
+        coords={
+            "spin_number": spin_numbers,
+            "energy_bin_geometric_mean": energy_bins,
+        },
+    )
+
+    result_ds = calculate_cullingmask(
+        ds, name="imap_ultra_l1b_45sensor-cullingmask", data_version="v1"
+    )
+
+    expected_spins = np.array([0, 1])
+    np.testing.assert_array_equal(result_ds["spin_number"].values, expected_spins)

imap_processing/tests/ultra/unit/test_de.py

@@ -1,13 +1,10 @@
 """Tests Extended Raw Events for ULTRA L1b."""
 
-from unittest import mock
-
 import numpy as np
 import pandas as pd
 import pytest
 
 from imap_processing.ultra.constants import UltraConstants
-from imap_processing.ultra.l1b.de import calculate_de
 
 
 @pytest.fixture()
@@ -20,94 +17,98 @@ def df_filt(de_dataset, events_fsw_comparison_theta_0):
     return df_filt
 
 
-@mock.patch("imap_processing.ultra.l1b.de.get_annotated_particle_velocity")
-def test_calculate_de(mock_get_annotated_particle_velocity, de_dataset, df_filt):
+def test_calculate_de(l1b_datasets, df_filt):
     """Tests calculate_de function."""
 
-    # Mock get_annotated_particle_velocity to avoid needing kernels
-    def side_effect_func(event_times, position, ultra_frame, dps_frame, sc_frame):
-        """
-        Mock behavior of get_annotated_particle_velocity.
-
-        Returns NaN-filled arrays matching the expected output shape.
-        """
-        num_events = event_times.size
-        return (
-            np.full((num_events, 3), np.nan),  # sc_velocity
-            np.full((num_events, 3), np.nan),  # sc_dps_velocity
-            np.full((num_events, 3), np.nan),  # helio_velocity
-        )
-
-    mock_get_annotated_particle_velocity.side_effect = side_effect_func
-
-    dataset = calculate_de(de_dataset, "imap_ultra_l1b_45sensor-de")
-
+    l1b_de_dataset = l1b_datasets[0]
     # Front and back positions
-    assert np.allclose(dataset["x_front"].data, df_filt["Xf"].astype("float"))
-    assert np.allclose(dataset["y_front"], df_filt["Yf"].astype("float"))
-    assert np.allclose(dataset["x_back"], df_filt["Xb"].astype("float"))
-    assert np.allclose(dataset["y_back"], df_filt["Yb"].astype("float"))
+    assert np.allclose(l1b_de_dataset["x_front"].data, df_filt["Xf"].astype("float"))
+    assert np.allclose(l1b_de_dataset["y_front"], df_filt["Yf"].astype("float"))
+    assert np.allclose(l1b_de_dataset["x_back"], df_filt["Xb"].astype("float"))
+    assert np.allclose(l1b_de_dataset["y_back"], df_filt["Yb"].astype("float"))
 
     # Coincidence positions
-    assert np.allclose(dataset["x_coin"], df_filt["Xc"].astype("float"))
+    assert np.allclose(l1b_de_dataset["x_coin"], df_filt["Xc"].astype("float"))
 
     # Time of flight
-    assert np.allclose(dataset["tof_start_stop"], df_filt["TOF"].astype("float"))
-    assert np.allclose(dataset["tof_stop_coin"], df_filt["eTOF"].astype("float"))
-    assert np.allclose(dataset["tof_corrected"], df_filt["cTOF"].astype("float"))
+    assert np.allclose(l1b_de_dataset["tof_start_stop"], df_filt["TOF"].astype("float"))
+    assert np.allclose(l1b_de_dataset["tof_stop_coin"], df_filt["eTOF"].astype("float"))
+    assert np.allclose(l1b_de_dataset["tof_corrected"], df_filt["cTOF"].astype("float"))
 
     # Distances and path lengths
-    assert np.allclose(dataset["front_back_distance"], df_filt["d"].astype("float"))
-    assert np.allclose(dataset["path_length"], df_filt["r"].astype("float"))
+    assert np.allclose(
+        l1b_de_dataset["front_back_distance"], df_filt["d"].astype("float")
+    )
+    assert np.allclose(l1b_de_dataset["path_length"], df_filt["r"].astype("float"))
 
     # Coincidence, start, and event types
-    assert np.allclose(dataset["coincidence_type"], df_filt["CoinType"].astype("float"))
-    assert np.allclose(dataset["start_type"], df_filt["StartType"].astype("float"))
-    assert np.allclose(dataset["event_type"], df_filt["StopType"].astype("float"))
+    assert np.allclose(
+        l1b_de_dataset["coincidence_type"], df_filt["CoinType"].astype("float")
+    )
+    assert np.allclose(
+        l1b_de_dataset["start_type"], df_filt["StartType"].astype("float")
+    )
+    assert np.allclose(
+        l1b_de_dataset["event_type"], df_filt["StopType"].astype("float")
+    )
 
     # Energies and species
-    assert np.allclose(dataset["energy"], df_filt["Energy"].astype("float"))
-    species_array = dataset["species"][
+    assert np.allclose(l1b_de_dataset["energy"], df_filt["Energy"].astype("float"))
+    species_array = l1b_de_dataset["species"][
         np.where(
-            (dataset["tof_corrected"] > UltraConstants.CTOF_SPECIES_MIN)
-            & (dataset["tof_corrected"] < UltraConstants.CTOF_SPECIES_MAX)
+            (l1b_de_dataset["tof_corrected"] > UltraConstants.CTOF_SPECIES_MIN)
+            & (l1b_de_dataset["tof_corrected"] < UltraConstants.CTOF_SPECIES_MAX)
         )[0]
     ]
     assert np.all(species_array == "H")
 
     # Velocities in various frames
-    test_tof = dataset["tof_start_stop"]
+    test_tof = l1b_de_dataset["tof_start_stop"]
+    test_ph = l1b_de_dataset["event_type"]
+    test_species = l1b_de_dataset["species"]
+    condition = (test_tof > 0) & (test_ph < 8)
     assert np.allclose(
-        dataset["vx_ultra"][test_tof > 0],
-        -df_filt["vhatX"].astype("float").values[test_tof > 0],
+        l1b_de_dataset["direct_event_velocity"][:, 0].values[condition],
+        df_filt["vx"].astype("float").values[condition],
         rtol=1e-2,
     )
     assert np.allclose(
-        dataset["vy_ultra"][test_tof > 0],
-        -df_filt["vhatY"].astype("float").values[test_tof > 0],
+        l1b_de_dataset["direct_event_velocity"][:, 1].values[condition],
+        df_filt["vy"].astype("float").values[condition],
         rtol=1e-2,
     )
     assert np.allclose(
-        dataset["vz_ultra"][test_tof > 0],
-        -df_filt["vhatZ"].astype("float").values[test_tof > 0],
+        l1b_de_dataset["direct_event_velocity"][:, 2].values[condition],
+        df_filt["vz"].astype("float").values[condition],
+        rtol=1e-2,
+    )
+    assert np.allclose(
+        l1b_de_dataset["velocity_magnitude"].values[condition],
+        df_filt["vmag"].astype("float").values[condition],
+        rtol=1e-2,
+    )
+    condition = (test_tof > 0) & (test_ph < 8) & (test_species == "H")
+    assert np.allclose(
+        l1b_de_dataset["tof_energy"].values[condition],
+        df_filt["energy_revised"].astype("float").values[condition],
+        rtol=1e-2,
+    )
+    assert np.allclose(
+        l1b_de_dataset["azimuth"].values[condition],
+        df_filt["event_phi"].astype("float").values[condition] % (2 * np.pi),
         rtol=1e-2,
     )
 
-    assert dataset["vx_sc"].shape == (len(de_dataset["epoch"]),)
-    assert dataset["vy_sc"].shape == (len(de_dataset["epoch"]),)
-    assert dataset["vz_sc"].shape == (len(de_dataset["epoch"]),)
-
-    assert dataset["vx_dps_sc"].shape == (len(de_dataset["epoch"]),)
-    assert dataset["vy_dps_sc"].shape == (len(de_dataset["epoch"]),)
-    assert dataset["vz_dps_sc"].shape == (len(de_dataset["epoch"]),)
-
-    assert dataset["vx_dps_helio"].shape == (len(de_dataset["epoch"]),)
-    assert dataset["vy_dps_helio"].shape == (len(de_dataset["epoch"]),)
-    assert dataset["vz_dps_helio"].shape == (len(de_dataset["epoch"]),)
+    assert l1b_de_dataset["velocity_sc"].shape == (len(l1b_de_dataset["epoch"]), 3)
+    assert l1b_de_dataset["velocity_dps_sc"].shape == (len(l1b_de_dataset["epoch"]), 3)
+    assert l1b_de_dataset["velocity_dps_helio"].shape == (
+        len(l1b_de_dataset["epoch"]),
+        3,
+    )
 
     # Event efficiency
     assert np.allclose(
-        dataset["event_efficiency"],
-        np.full(len(de_dataset["epoch"]), np.nan),
+        l1b_de_dataset["event_efficiency"],
+        np.full(len(l1b_de_dataset["epoch"]), np.nan),
         equal_nan=True,
     )

imap_processing/tests/ultra/unit/test_ultra_l1a.py

@@ -107,7 +107,7 @@ def test_xarray_rates(decom_test_data):
 
     # # Spot check metadata data and attributes
     # j2000_time = (
-    #     np.datetime64("2024-02-07T15:28:37.184000", "ns") - J2000_EPOCH
+    #     np.datetime64("2024-02-07T15:28:37.184000", "ns") - TTJ2000_EPOCH
     # ).astype(np.int64)
     # specific_epoch_data = dataset.sel(epoch=j2000_time)["START_RF"]
     # startrf_list = specific_epoch_data.values.tolist()
@@ -147,7 +147,7 @@ def test_xarray_tof(decom_test_data):
 
     # # Spot check metadata data and attributes
     # j2000_time = (
-    #     np.datetime64("2024-02-07T15:28:36.184000", "ns") - J2000_EPOCH
+    #     np.datetime64("2024-02-07T15:28:36.184000", "ns") - TTJ2000_EPOCH
     # ).astype(np.int64)
     # specific_epoch_data = dataset.sel(epoch=j2000_time, sid=0)["PACKETDATA"]
     # packetdata_attr = dataset.variables["PACKETDATA"].attrs
@@ -196,7 +196,7 @@ def test_xarray_events(decom_test_data, decom_ultra_aux, events_test_path):
 
     # # Spot check metadata data and attributes
     # j2000_time = (
-    #     np.datetime64("2024-02-07T15:28:37.184000", "ns") - J2000_EPOCH
+    #     np.datetime64("2024-02-07T15:28:37.184000", "ns") - TTJ2000_EPOCH
     # ).astype(np.int64)
     # specific_epoch_data = dataset.sel(epoch=j2000_time)["COIN_TYPE"]
     # cointype_list = specific_epoch_data.values.tolist()