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

imap_processing/tests/ultra/unit/test_spacecraft_pset.py

@@ -0,0 +1,78 @@
+"""Tests Spacecraft PSET for ULTRA L1c."""
+
+import numpy as np
+import pandas as pd
+import pytest
+import spiceypy
+import xarray as xr
+
+from imap_processing import imap_module_directory
+from imap_processing.spice.geometry import SpiceFrame
+from imap_processing.spice.kernels import ensure_spice
+from imap_processing.ultra.l1b.ultra_l1b_annotated import (
+    get_annotated_particle_velocity,
+)
+from imap_processing.ultra.l1b.ultra_l1b_extended import (
+    get_de_energy_kev,
+    get_de_velocity,
+)
+from imap_processing.ultra.l1c.spacecraft_pset import calculate_spacecraft_pset
+
+TEST_PATH = imap_module_directory / "tests" / "ultra" / "data" / "l1"
+
+
+@pytest.mark.external_test_data()
+@pytest.mark.external_kernel()
+@ensure_spice
+@pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
+def test_pset():
+    """Tests calculate_pset function."""
+    # This is just setting up the data so that it is in the format of l1b_de_dataset.
+    test_path = TEST_PATH / "ultra-90_raw_event_data_shortened.csv"
+    df = pd.read_csv(test_path)
+    instrument_velocity = get_de_velocity(
+        (df["Xf"], df["Yf"]), (df["Xb"], df["Yb"]), df["d"], df["TOF"].values
+    )
+
+    et = spiceypy.str2et(df["Epoch"].values)
+    epoch = df["MET"].values
+
+    frame_velocities = get_annotated_particle_velocity(
+        et,
+        instrument_velocity,
+        SpiceFrame.IMAP_ULTRA_90,
+        SpiceFrame.IMAP_DPS,
+        SpiceFrame.IMAP_SPACECRAFT,
+    )
+
+    particle_velocity_dps_spacecraft = frame_velocities[1]
+
+    # Assume everything is Hydrogen
+    species = np.full(len(particle_velocity_dps_spacecraft), "H", dtype="<U1")
+    energy_dps_spacecraft = get_de_energy_kev(particle_velocity_dps_spacecraft, species)
+
+    test_l1b_de_dataset = xr.Dataset(
+        {
+            "species": (["epoch"], species),
+            "velocity_dps_sc": (
+                ["epoch", "component"],
+                particle_velocity_dps_spacecraft,
+            ),
+            "energy_spacecraft": (["epoch"], energy_dps_spacecraft),
+        },
+        coords={
+            "epoch": ("epoch", epoch),
+            "component": ("component", ["vx", "vy", "vz"]),
+        },
+    )
+
+    spacecraft_pset = calculate_spacecraft_pset(
+        test_l1b_de_dataset,
+        test_l1b_de_dataset,  # placeholder for extendedspin_dataset
+        test_l1b_de_dataset,  # placeholder for cullingmask_dataset
+        "imap_ultra_l1c_45sensor-spacecraftpset",
+        "001",
+    )
+    assert "healpix" in spacecraft_pset.coords
+    assert "epoch" in spacecraft_pset.coords
+    assert "energy_bin_geometric_mean" in spacecraft_pset.coords

imap_processing/tests/ultra/unit/test_ultra_l1a.py

@@ -1,3 +1,4 @@
+import numpy as np
 import pytest
 
 from imap_processing import decom
@@ -9,7 +10,11 @@ from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_RATES,
     ULTRA_TOF,
 )
-from imap_processing.ultra.l1a.ultra_l1a import create_dataset, ultra_l1a
+from imap_processing.ultra.l1a.ultra_l1a import (
+    create_dataset,
+    get_event_id,
+    ultra_l1a,
+)
 from imap_processing.utils import group_by_apid
 
 
@@ -253,10 +258,7 @@ def test_cdf_rates(ccsds_path_theta_0, decom_test_data):
     test_data = ultra_l1a(
         ccsds_path_theta_0, data_version="001", apid=ULTRA_RATES.apid[0]
     )
-    # TODO: Dropping duplicates to ignore ISTP for now. Need to update test data
-    # or wait for an update to cdflib
-    test_data[0] = test_data[0].sortby("epoch").groupby("epoch").first()
-    test_data_path = write_cdf(test_data[0])
+    test_data_path = write_cdf(test_data[0], istp=False)
 
     assert test_data_path.exists()
     assert test_data_path.name == "imap_ultra_l1a_45sensor-rates_20240207_v001.cdf"
@@ -319,20 +321,34 @@ def test_cdf_events(ccsds_path_theta_0, decom_ultra_aux, decom_test_data):
     test_data = ultra_l1a(
         ccsds_path_theta_0, data_version="001", apid=ULTRA_EVENTS.apid[0]
     )
-    # TODO: Dropping duplicates to ignore ISTP for now. Need to update test data
-    # or wait for an update to cdflib
-    test_data[0] = test_data[0].sortby("epoch").groupby("epoch").first()
-    test_data_path = write_cdf(test_data[0])
+    test_data_path = write_cdf(test_data[0], istp=False)
 
     assert test_data_path.exists()
     assert test_data_path.name == "imap_ultra_l1a_45sensor-de_20240207_v001.cdf"
 
-    dataset_events = create_dataset(
-        {ULTRA_EVENTS.apid[0]: decom_ultra_events, ULTRA_AUX.apid[0]: decom_ultra_aux}
-    )
+    dataset_events = create_dataset({ULTRA_EVENTS.apid[0]: decom_ultra_events})
     input_xarray_events = load_cdf(test_data_path)
 
     # write_cdf() injects some attributes that are not in the xarray
     assert set(dataset_events.attrs.keys()).issubset(
         set(input_xarray_events.attrs.keys())
     )
+
+
+def test_get_event_id():
+    """Test get_event_id"""
+    decom_ultra_dict = {
+        ULTRA_EVENTS.apid[0]: {"SHCOARSE": [445015662, 445015663, 445015664, 445015664]}
+    }
+    decom_events = get_event_id(decom_ultra_dict)
+    counters_for_met = []
+    for i in range(len(decom_events["EVENTID"])):
+        event_id = decom_events["EVENTID"][i]
+        met_extracted = event_id >> np.int64(31)
+
+        assert met_extracted == np.int64(
+            decom_ultra_dict[ULTRA_EVENTS.apid[0]]["SHCOARSE"][i]
+        )
+        counters_for_met.append(event_id & np.int64(0x7FFFFFFF))
+
+    assert counters_for_met == [0, 0, 0, 1]

imap_processing/tests/ultra/unit/test_ultra_l1b.py

@@ -2,6 +2,7 @@ import numpy as np
 import pytest
 import xarray as xr
 
+from imap_processing.cdf.utils import write_cdf
 from imap_processing.ultra.l1b.ultra_l1b import ultra_l1b
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
@@ -49,10 +50,12 @@ def mock_data_l1b_extendedspin_dict():
         [0, 1],
         dtype="int32",
     )
+    spin_start_time = np.array([0, 1, 2], dtype="uint64")
     quality = np.zeros((2, 3), dtype="uint16")
     data_dict = {
         "spin_number": spin,
         "energy_bin_geometric_mean": energy,
+        "spin_start_time": spin_start_time,
         "quality_ena_rates": quality,
     }
     return data_dict
@@ -90,22 +93,47 @@ def test_create_de_dataset(mock_data_l1b_de_dict):
     np.testing.assert_array_equal(dataset["x_front"], np.zeros(3))
 
 
-def test_ultra_l1b(l1b_datasets):
+def test_ultra_l1b(l1b_de_dataset):
     """Tests that L1b data is created."""
 
-    assert len(l1b_datasets) == 4
+    assert len(l1b_de_dataset) == 1
+
+    assert (
+        l1b_de_dataset[0].attrs["Logical_source_description"]
+        == "IMAP-Ultra Instrument Level-1B Direct Event Data."
+    )
+
+
+def test_cdf_de(l1b_de_dataset):
+    """Tests that CDF file is created and contains same attributes as xarray."""
+    test_data_path = write_cdf(l1b_de_dataset[0], istp=False)
+    assert test_data_path.exists()
+    assert test_data_path.name == "imap_ultra_l1b_45sensor-de_20240207_v001.cdf"
+
+
+def test_ultra_l1b_extendedspin(l1b_extendedspin_dataset):
+    """Tests that L1b data is created."""
+
+    assert len(l1b_extendedspin_dataset) == 3
 
     # Define the suffixes and prefix
     prefix = "imap_ultra_l1b_45sensor"
-    suffixes = ["de", "extendedspin", "cullingmask", "badtimes"]
+    suffixes = ["extendedspin", "cullingmask", "badtimes"]
 
     for i in range(len(suffixes)):
         expected_logical_source = f"{prefix}-{suffixes[i]}"
-        assert l1b_datasets[i].attrs["Logical_source"] == expected_logical_source
+        assert (
+            l1b_extendedspin_dataset[i].attrs["Logical_source"]
+            == expected_logical_source
+        )
+
 
+def test_cdf_extendedspin(l1b_extendedspin_dataset):
+    """Tests that CDF file is created and contains same attributes as xarray."""
+    test_data_path = write_cdf(l1b_extendedspin_dataset[0], istp=False)
+    assert test_data_path.exists()
     assert (
-        l1b_datasets[0].attrs["Logical_source_description"]
-        == "IMAP-Ultra Instrument Level-1B Direct Event Data."
+        test_data_path.name == "imap_ultra_l1b_45sensor-extendedspin_20000101_v001.cdf"
     )
 
 

imap_processing/tests/ultra/unit/test_ultra_l1b_culling.py

@@ -6,11 +6,12 @@ import pytest
 from imap_processing.quality_flags import ImapAttitudeUltraFlags, ImapRatesUltraFlags
 from imap_processing.ultra.constants import UltraConstants
 from imap_processing.ultra.l1b.ultra_l1b_culling import (
+    compare_aux_univ_spin_table,
     flag_attitude,
     flag_spin,
     get_energy_histogram,
     get_n_sigma,
-    get_spin,
+    get_spin_data,
 )
 
 
@@ -37,28 +38,13 @@ def test_data(use_fake_spin_data_for_time):
             )
             expected_counts[energy_idx, spin_idx] = count
 
-    return time, spin_number, energy, expected_counts
-
-
-def test_get_spin(use_fake_spin_data_for_time):
-    """Tests get_spin function."""
-
-    nspins = 5
-    spin_period = 15
-    start = 0
-    stop = start + (nspins + 1) * spin_period
-    use_fake_spin_data_for_time(start, stop)
-    spin_number = get_spin(np.linspace(start, stop, num=20))
-
-    assert len(spin_number) == len(np.linspace(start, stop, num=20))
-    expected_num_spins = np.ceil((stop - start) / 15) + 1
-    assert np.array_equal(len(np.unique(spin_number)), expected_num_spins)
+    return spin_number, energy, expected_counts
 
 
 def test_get_energy_histogram(test_data):
     """Tests get_energy_histogram function."""
 
-    _, spin_number, energy, expected_counts = test_data
+    spin_number, energy, expected_counts = test_data
 
     hist, _, counts, duration = get_energy_histogram(spin_number, energy)
 
@@ -67,19 +53,17 @@ def test_get_energy_histogram(test_data):
     assert duration == 15
 
 
-def test_flag_attitude(use_fake_spin_data_for_time):
+def test_flag_attitude(use_fake_spin_data_for_time, faux_aux_dataset):
     """Tests flag_attitude function."""
 
-    start = 4.45015658e08
-    stop = 4.45015873e08
-    use_fake_spin_data_for_time(start, stop)
+    use_fake_spin_data_for_time(0, 15 * 147)
     quality_flags, spin_rates, spin_period, spin_start_time = flag_attitude(
-        np.linspace(start, stop, num=20)
+        faux_aux_dataset["SPINNUMBER"].values, faux_aux_dataset
     )
 
     flag = ImapAttitudeUltraFlags(quality_flags[0])
     assert flag.name == "NONE"
-    assert np.all(quality_flags == ImapAttitudeUltraFlags.NONE.value)
+    assert quality_flags[-1] == ImapAttitudeUltraFlags.AUXMISMATCH.value
     assert np.all(spin_rates == 60 / spin_period)
     assert np.all(np.diff(spin_start_time) == 15)
 
@@ -102,8 +86,8 @@ def test_get_n_sigma():
 def test_flag_spin(test_data):
     """Tests flag_spin function."""
 
-    time, _, energy, expected_counts = test_data
-    quality_flags, spin, energy, _ = flag_spin(time, energy, 1)
+    spin_number, energy, expected_counts = test_data
+    quality_flags, spin, energy, _ = flag_spin(spin_number, energy, 1)
     threshold = get_n_sigma(expected_counts / 15, 15, 1)
 
     # At the first energy level were the rates > threshold and the counts > threshold?
@@ -112,3 +96,15 @@ def test_flag_spin(test_data):
     )
     high_rates_flag = quality_flags[expected_counts / 15 > threshold[:, np.newaxis]]
     assert np.all(high_rates_flag == ImapRatesUltraFlags.HIGHRATES.value)
+
+
+def test_compare_aux_univ_spin_table(use_fake_spin_data_for_time, faux_aux_dataset):
+    """Tests compare_aux_univ_spin_table function."""
+    use_fake_spin_data_for_time(0, 15 * 147)
+    spins = faux_aux_dataset["SPINNUMBER"].values
+    spin_df = get_spin_data()
+
+    result = compare_aux_univ_spin_table(faux_aux_dataset, spins, spin_df)
+    expected = np.array([False] * 14 + [True])
+
+    assert np.all(result == expected)

imap_processing/tests/ultra/unit/test_ultra_l1b_extended.py

@@ -4,6 +4,7 @@ import numpy as np
 import pandas as pd
 import pytest
 
+from imap_processing.spice.spin import get_spin_data
 from imap_processing.ultra.constants import UltraConstants
 from imap_processing.ultra.l1b.ultra_l1b_extended import (
     CoinType,
@@ -13,23 +14,29 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
     determine_species,
     get_coincidence_positions,
     get_ctof,
-    get_de_az_el,
     get_de_energy_kev,
     get_de_velocity,
     get_energy_pulse_height,
     get_energy_ssd,
+    get_eventtimes,
     get_front_x_position,
     get_front_y_position,
     get_path_length,
     get_ph_tof_and_back_positions,
+    get_phi_theta,
     get_ssd_back_position_and_tof_offset,
     get_ssd_tof,
 )
 
 
 @pytest.fixture()
-def yf_fixture(de_dataset, events_fsw_comparison_theta_0):
+def test_fixture(de_dataset, events_fsw_comparison_theta_0):
     """Fixture to compute and return yf and related data."""
+    # Remove start_type with fill values
+    de_dataset = de_dataset.where(
+        de_dataset["START_TYPE"] != np.iinfo(np.int64).min, drop=True
+    )
+
     df = pd.read_csv(events_fsw_comparison_theta_0)
     df_filt = df[df["StartType"] != -1]
 
@@ -37,16 +44,15 @@ def yf_fixture(de_dataset, events_fsw_comparison_theta_0):
         de_dataset["START_TYPE"].data, df_filt.Yb.values.astype("float")
     )
 
-    return df_filt, d, yf
+    return df_filt, d, yf, de_dataset
 
 
 def test_get_front_x_position(
-    de_dataset,
-    yf_fixture,
+    test_fixture,
 ):
     """Tests get_front_x_position function."""
 
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, de_dataset = test_fixture
 
     xf = get_front_x_position(
         de_dataset["START_TYPE"].data,
@@ -56,18 +62,18 @@ def test_get_front_x_position(
     assert xf == pytest.approx(df_filt["Xf"].astype("float"), 1e-5)
 
 
-def test_get_front_y_position(yf_fixture):
+def test_get_front_y_position(test_fixture):
     """Tests get_front_y_position function."""
-    df_filt, d, yf = yf_fixture
+    df_filt, d, yf, _ = test_fixture
 
     assert yf == pytest.approx(df_filt["Yf"].astype("float"), abs=1e-5)
     assert d == pytest.approx(df_filt["d"].astype("float"), abs=1e-5)
 
 
-def test_get_path_length(de_dataset, yf_fixture):
+def test_get_path_length(test_fixture):
     """Tests get_path_length function."""
 
-    df_filt, d, yf = yf_fixture
+    df_filt, d, yf, _ = test_fixture
 
     test_xf = df_filt["Xf"].astype("float").values
     test_yf = df_filt["Yf"].astype("float").values
@@ -79,12 +85,11 @@ def test_get_path_length(de_dataset, yf_fixture):
 
 
 def test_get_ph_tof_and_back_positions(
-    de_dataset,
-    yf_fixture,
+    test_fixture,
 ):
     """Tests get_ph_tof_and_back_positions function."""
 
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, de_dataset = test_fixture
 
     ph_tof, _, ph_xb, ph_yb = get_ph_tof_and_back_positions(
         de_dataset, df_filt.Xf.astype("float").values, "ultra45"
@@ -104,10 +109,11 @@ def test_get_ph_tof_and_back_positions(
 
 
 def test_get_ssd_back_position_and_tof_offset(
-    de_dataset,
+    test_fixture,
     events_fsw_comparison_theta_0,
 ):
     """Tests get_ssd_back_position function."""
+    _, _, _, de_dataset = test_fixture
     yb, tof_offset, ssd_number = get_ssd_back_position_and_tof_offset(de_dataset)
 
     df = pd.read_csv(events_fsw_comparison_theta_0)
@@ -143,9 +149,9 @@ def test_get_ssd_back_position_and_tof_offset(
     assert np.all(ssd_number_rt <= 7), "Values in ssd_number_rt out of range."
 
 
-def test_get_coincidence_positions(de_dataset, yf_fixture):
+def test_get_coincidence_positions(test_fixture):
     """Tests get_coincidence_positions function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, de_dataset = test_fixture
     # Get particle tof (t2).
     _, t2, _, _ = get_ph_tof_and_back_positions(
         de_dataset, df_filt.Xf.astype("float").values, "ultra45"
@@ -167,9 +173,9 @@ def test_get_coincidence_positions(de_dataset, yf_fixture):
     )
 
 
-def test_calculate_etof_xc(de_dataset, yf_fixture):
+def test_calculate_etof_xc(test_fixture):
     """Tests calculate_etof_xc function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, de_dataset = test_fixture
     # Get particle tof (t2).
     _, t2, _, _ = get_ph_tof_and_back_positions(
         de_dataset, df_filt.Xf.astype("float").values, "ultra45"
@@ -215,9 +221,9 @@ def test_calculate_etof_xc(de_dataset, yf_fixture):
     )
 
 
-def test_get_de_velocity(de_dataset, yf_fixture):
+def test_get_de_velocity(test_fixture):
     """Tests get_de_velocity function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, _ = test_fixture
     df_ph = df_filt[np.isin(df_filt["StopType"], [StopType.PH.value])]
 
     test_xf, test_yf, test_xb, test_yb, test_d, test_tof = (
@@ -254,9 +260,9 @@ def test_get_de_velocity(de_dataset, yf_fixture):
     )
 
 
-def test_get_ssd_tof(de_dataset, yf_fixture):
+def test_get_ssd_tof(test_fixture):
     """Tests get_ssd_tof function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, de_dataset = test_fixture
     df_ssd = df_filt[np.isin(df_filt["StopType"], [StopType.SSD.value])]
     test_xf = df_filt["Xf"].astype("float").values
 
@@ -267,9 +273,9 @@ def test_get_ssd_tof(de_dataset, yf_fixture):
     )
 
 
-def test_get_de_energy_kev(de_dataset, yf_fixture):
+def test_get_de_energy_kev(test_fixture):
     """Tests get_de_energy_kev function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, _ = test_fixture
     df_ph = df_filt[np.isin(df_filt["StopType"], [StopType.PH.value])]
     df_ph = df_ph[df_ph["energy_revised"].astype("str") != "FILL"]
 
@@ -298,9 +304,9 @@ def test_get_de_energy_kev(de_dataset, yf_fixture):
     np.testing.assert_allclose(actual_energy, expected_energy, atol=1e-01, rtol=0)
 
 
-def test_get_energy_ssd(de_dataset, yf_fixture):
+def test_get_energy_ssd(test_fixture):
     """Tests get_energy_ssd function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, de_dataset = test_fixture
     df_ssd = df_filt[np.isin(df_filt["StopType"], [StopType.SSD.value])]
     _, _, ssd_number = get_ssd_back_position_and_tof_offset(de_dataset)
     energy = get_energy_ssd(de_dataset, ssd_number)
@@ -309,9 +315,9 @@ def test_get_energy_ssd(de_dataset, yf_fixture):
     assert np.array_equal(test_energy, energy)
 
 
-def test_get_energy_pulse_height(de_dataset, yf_fixture):
+def test_get_energy_pulse_height(test_fixture):
     """Tests get_energy_ssd function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, de_dataset = test_fixture
     df_ph = df_filt[np.isin(df_filt["StopType"], [StopType.PH.value])]
     ph_indices = np.nonzero(
         np.isin(de_dataset["STOP_TYPE"], [StopType.Top.value, StopType.Bottom.value])
@@ -328,9 +334,9 @@ def test_get_energy_pulse_height(de_dataset, yf_fixture):
     assert np.array_equal(test_energy, energy[ph_indices])
 
 
-def test_get_ctof(yf_fixture):
+def test_get_ctof(test_fixture):
     """Tests get_ctof function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, _ = test_fixture
     df_filt = df_filt[df_filt["eTOF"].astype("str") != "FILL"]
     df_filt = df_filt[df_filt["cTOF"].astype("float") > 0]
 
@@ -363,9 +369,9 @@ def test_get_ctof(yf_fixture):
     )
 
 
-def test_determine_species(yf_fixture):
+def test_determine_species(test_fixture):
     """Tests determine_species function."""
-    df_filt, _, _ = yf_fixture
+    df_filt, _, _, _ = test_fixture
     df_ph = df_filt[np.isin(df_filt["StopType"], [StopType.PH.value])]
     df_ssd = df_filt[np.isin(df_filt["StopType"], [StopType.SSD.value])]
 
@@ -396,27 +402,56 @@ def test_determine_species(yf_fixture):
     np.testing.assert_array_equal(h_indices_ssd, ctof_indices_ssd)
 
 
-def test_get_de_az_el(de_dataset, yf_fixture):
-    """Tests get_de_az_el function."""
-    df_filt, _, _ = yf_fixture
-    df_filt = df_filt[
-        (df_filt["event_theta"].astype("str") != "FILL")
-        & (df_filt["TOF"].astype("float") >= 0)
-    ]
-    df_ph = df_filt[np.isin(df_filt["StopType"], [StopType.PH.value])]
+def test_get_phi_theta(test_fixture):
+    """Tests get_phi_theta function."""
+    df_filt, d, _, _ = test_fixture
 
-    test_xf, test_yf, test_xb, test_yb, test_d, test_tof = (
-        df_ph[col].astype("float").values
-        for col in ["Xf", "Yf", "Xb", "Yb", "d", "TOF"]
+    test_xf = df_filt["Xf"].astype("float").values
+    test_yf = df_filt["Yf"].astype("float").values
+
+    test_xb = df_filt["Xb"].astype("float").values
+    test_yb = df_filt["Yb"].astype("float").values
+
+    phi, theta = get_phi_theta((test_xf, test_yf), (test_xb, test_yb), d)
+    expected_phi = df_filt["phi"].astype("float")
+    expected_theta = df_filt["theta"].astype("float")
+
+    np.testing.assert_allclose(phi, expected_phi, atol=1e-03, rtol=0)
+    np.testing.assert_allclose(theta, expected_theta, atol=1e-03, rtol=0)
+
+
+def test_get_eventtimes(test_fixture, use_fake_spin_data_for_time):
+    """Tests get_eventtimes function."""
+    df_filt, _, _, de_dataset = test_fixture
+    # Create a spin table that cover spin 0-141
+    use_fake_spin_data_for_time(0, 141 * 15)
+
+    event_times, spin_starts, spin_period_sec = get_eventtimes(
+        de_dataset["SPIN"].values, de_dataset["PHASE_ANGLE"].values
     )
 
-    v = get_de_velocity(
-        (test_xf, test_yf),
-        (test_xb, test_yb),
-        test_d,
-        test_tof,
+    spin_df = get_spin_data()
+    expected_min_df = spin_df[spin_df["spin_number"] == de_dataset["SPIN"].values.min()]
+    expected_max_df = spin_df[spin_df["spin_number"] == de_dataset["SPIN"].values.max()]
+    spin_period_sec_min = expected_min_df["spin_period_sec"].values[0]
+    spin_period_sec_max = expected_max_df["spin_period_sec"].values[0]
+
+    spin_start_min = (
+        expected_min_df["spin_start_sec"] + expected_min_df["spin_start_subsec"] / 1000
+    )
+    spin_start_max = (
+        expected_max_df["spin_start_sec"] + expected_max_df["spin_start_subsec"] / 1000
+    )
+
+    assert spin_start_min.values[0] == spin_starts.min()
+    assert spin_start_max.values[0] == spin_starts.max()
+
+    event_times_min = spin_start_min.values[0] + spin_period_sec_min * (
+        de_dataset["PHASE_ANGLE"][0] / 720
+    )
+    event_times_max = spin_start_max.values[0] + spin_period_sec_max * (
+        de_dataset["PHASE_ANGLE"][-1] / 720
     )
-    az, _ = get_de_az_el(v)
-    expected_phi = df_ph["event_phi"].astype("float")
 
-    np.testing.assert_allclose(az, expected_phi % (2 * np.pi), atol=1e-03, rtol=0)
+    assert event_times_min == event_times.min()
+    assert event_times_max == event_times.max()