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

imap_processing/tests/ultra/unit/test_ultra_l1b.py

@@ -1,5 +1,3 @@
-from unittest import mock
-
 import numpy as np
 import pytest
 import xarray as xr
@@ -32,45 +30,58 @@ def mock_data_l1a_rates_dict():
 
 
 @pytest.fixture()
-def mock_data_l1a_de_aux_dict():
-    # Create sample data for the xarray Dataset
-    epoch = np.arange(
-        "2024-02-07T15:28:37", "2024-02-07T15:28:42", dtype="datetime64[s]"
-    ).astype("datetime64[ns]")
-
-    data_vars = {
-        "var": ("epoch", np.zeros(5)),
-    }
-
-    attrs = {
-        "Logical_source": "imap_ultra_l1a_45sensor-name",
-        "Logical_source_description": "IMAP Mission ULTRA Instrument "
-        "Level-1A Single-Sensor Data",
-    }
+def mock_data_l1b_de_dict():
+    epoch = np.array(
+        [760591786368000000, 760591787368000000, 760591788368000000],
+        dtype="datetime64[ns]",
+    )
+    data_dict = {"epoch": epoch, "x_front": np.zeros(3), "y_front": np.zeros(3)}
+    return data_dict
 
-    dataset = xr.Dataset(data_vars, coords={"epoch": epoch}, attrs=attrs)
 
+@pytest.fixture()
+def mock_data_l1b_extendedspin_dict():
+    spin = np.array(
+        [0, 1, 2],
+        dtype="uint32",
+    )
+    energy = np.array(
+        [0, 1],
+        dtype="int32",
+    )
+    quality = np.zeros((2, 3), dtype="uint16")
     data_dict = {
-        "imap_ultra_l1a_45sensor-de": dataset,
-        "imap_ultra_l1a_45sensor-aux": dataset,
+        "spin_number": spin,
+        "energy_bin_geometric_mean": energy,
+        "quality_ena_rates": quality,
     }
-
     return data_dict
 
 
-@pytest.fixture()
-def mock_data_l1b_dict():
-    epoch = np.array(
-        [760591786368000000, 760591787368000000, 760591788368000000],
-        dtype="datetime64[ns]",
+def test_create_extendedspin_dataset(mock_data_l1b_extendedspin_dict):
+    """Tests that dataset is created as expected."""
+    dataset = create_dataset(
+        mock_data_l1b_extendedspin_dict,
+        "imap_ultra_l1b_45sensor-extendedspin",
+        "l1b",
+        "001",
+    )
+
+    assert "spin_number" in dataset.coords
+    assert "energy_bin_geometric_mean" in dataset.coords
+    assert dataset.coords["spin_number"].dtype == "uint32"
+    assert dataset.attrs["Logical_source"] == "imap_ultra_l1b_45sensor-extendedspin"
+    assert dataset["quality_ena_rates"].attrs["UNITS"] == " "
+    np.testing.assert_array_equal(
+        dataset["quality_ena_rates"], np.zeros((2, 3), dtype="uint16")
     )
-    data_dict = {"epoch": epoch, "x_front": np.zeros(3), "y_front": np.zeros(3)}
-    return data_dict
 
 
-def test_create_dataset(mock_data_l1b_dict):
+def test_create_de_dataset(mock_data_l1b_de_dict):
     """Tests that dataset is created as expected."""
-    dataset = create_dataset(mock_data_l1b_dict, "imap_ultra_l1b_45sensor-de", "l1b")
+    dataset = create_dataset(
+        mock_data_l1b_de_dict, "imap_ultra_l1b_45sensor-de", "l1b", "001"
+    )
 
     assert "epoch" in dataset.coords
     assert dataset.coords["epoch"].dtype == "datetime64[ns]"
@@ -79,58 +90,21 @@ def test_create_dataset(mock_data_l1b_dict):
     np.testing.assert_array_equal(dataset["x_front"], np.zeros(3))
 
 
-def test_ultra_l1b_rates(mock_data_l1a_rates_dict):
+def test_ultra_l1b(l1b_datasets):
     """Tests that L1b data is created."""
-    output_datasets = ultra_l1b(mock_data_l1a_rates_dict, data_version="001")
 
-    assert len(output_datasets) == 3
-    assert (
-        output_datasets[0].attrs["Logical_source"]
-        == "imap_ultra_l1b_45sensor-extendedspin"
-    )
-    assert (
-        output_datasets[1].attrs["Logical_source"]
-        == "imap_ultra_l1b_45sensor-cullingmask"
-    )
-    assert (
-        output_datasets[2].attrs["Logical_source"] == "imap_ultra_l1b_45sensor-badtimes"
-    )
-    assert (
-        output_datasets[0].attrs["Logical_source_description"]
-        == "IMAP-Ultra Instrument Level-1B Extended Spin Data."
-    )
+    assert len(l1b_datasets) == 4
 
+    # Define the suffixes and prefix
+    prefix = "imap_ultra_l1b_45sensor"
+    suffixes = ["de", "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
 
-@pytest.mark.external_kernel()
-@pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
-@mock.patch("imap_processing.ultra.l1b.de.get_annotated_particle_velocity")
-def test_ultra_l1b_de(mock_get_annotated_particle_velocity, de_dataset):
-    """Tests that L1b data is created."""
-    data_dict = {}
-    data_dict[de_dataset.attrs["Logical_source"]] = de_dataset
-    data_dict["imap_ultra_l1a_45sensor-aux"] = de_dataset
-
-    # 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")
-
-    assert len(output_datasets) == 1
-    assert output_datasets[0].attrs["Logical_source"] == "imap_ultra_l1b_45sensor-de"
     assert (
-        output_datasets[0].attrs["Logical_source_description"]
+        l1b_datasets[0].attrs["Logical_source_description"]
         == "IMAP-Ultra Instrument Level-1B Direct Event Data."
     )
 

imap_processing/tests/ultra/unit/test_ultra_l1b_annotated.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 import pytest
-import spiceypy as spice
+import spiceypy
 
 from imap_processing.spice.geometry import SpiceFrame
 from imap_processing.ultra.l1b.ultra_l1b_annotated import (
@@ -31,9 +31,9 @@ def kernels(spice_test_data_path):
 @pytest.mark.external_kernel()
 def test_get_particle_velocity(spice_test_data_path, kernels):
     """Tests get_particle_velocity function."""
-    spice.furnsh(kernels)
+    spiceypy.furnsh(kernels)
 
-    pointing_cover = spice.ckcov(
+    pointing_cover = spiceypy.ckcov(
         str(spice_test_data_path / "sim_1yr_imap_pointing_frame.bc"),
         SpiceFrame.IMAP_DPS.value,
         True,
@@ -42,7 +42,7 @@ def test_get_particle_velocity(spice_test_data_path, kernels):
         "TDB",
     )
     # Get start and end time of first interval
-    start, _ = spice.wnfetd(pointing_cover, 0)
+    start, _ = spiceypy.wnfetd(pointing_cover, 0)
 
     times = np.array([start])
     instrument_velocity = np.array([[41.18609, -471.24467, -832.8784]])
@@ -71,7 +71,7 @@ def test_get_particle_velocity(spice_test_data_path, kernels):
     magnitude_sc_90 = np.linalg.norm(sc_velocity_90)
     magnitude_dps_45 = np.linalg.norm(sc_dps_velocity_45)
     magnitude_dps_90 = np.linalg.norm(sc_dps_velocity_90)
-    state, lt = spice.spkezr("IMAP", times, "IMAP_DPS", "NONE", "SUN")
+    state, lt = spiceypy.spkezr("IMAP", times, "IMAP_DPS", "NONE", "SUN")
 
     assert np.allclose(magnitude_sc_45, magnitude_sc_90, atol=1e-6)
     assert np.allclose(magnitude_dps_45, magnitude_dps_90, atol=1e-6)

imap_processing/tests/ultra/unit/test_ultra_l1b_culling.py

@@ -0,0 +1,114 @@
+"""Tests Culling for ULTRA L1b."""
+
+import numpy as np
+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 (
+    flag_attitude,
+    flag_spin,
+    get_energy_histogram,
+    get_n_sigma,
+    get_spin,
+)
+
+
+@pytest.fixture()
+def test_data(use_fake_spin_data_for_time):
+    """Fixture to compute and return test data."""
+
+    time = np.arange(0, 32, 2)
+    spin_number = np.array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2])
+    energy = np.array([5, 5, 5, 5, 5, 5, 5, 5, 5, 15, 15, 25, -2, -2, -2, 2])
+
+    use_fake_spin_data_for_time(time[0], time[-1])
+
+    energy_edges = UltraConstants.CULLING_ENERGY_BIN_EDGES
+    unique_spins = np.unique(spin_number)
+    expected_counts = np.zeros((len(energy_edges) - 1, len(unique_spins)))
+
+    for spin_idx, spin in enumerate(unique_spins):
+        for energy_idx in range(len(energy_edges) - 1):
+            count = np.sum(
+                (spin_number == spin)
+                & (energy >= energy_edges[energy_idx])
+                & (energy < energy_edges[energy_idx + 1])
+            )
+            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)
+
+
+def test_get_energy_histogram(test_data):
+    """Tests get_energy_histogram function."""
+
+    _, spin_number, energy, expected_counts = test_data
+
+    hist, _, counts, duration = get_energy_histogram(spin_number, energy)
+
+    assert np.all(counts == expected_counts)
+    assert np.all(hist == expected_counts / 15)
+    assert duration == 15
+
+
+def test_flag_attitude(use_fake_spin_data_for_time):
+    """Tests flag_attitude function."""
+
+    start = 4.45015658e08
+    stop = 4.45015873e08
+    use_fake_spin_data_for_time(start, stop)
+    quality_flags, spin_rates, spin_period, spin_start_time = flag_attitude(
+        np.linspace(start, stop, num=20)
+    )
+
+    flag = ImapAttitudeUltraFlags(quality_flags[0])
+    assert flag.name == "NONE"
+    assert np.all(quality_flags == ImapAttitudeUltraFlags.NONE.value)
+    assert np.all(spin_rates == 60 / spin_period)
+    assert np.all(np.diff(spin_start_time) == 15)
+
+
+def test_get_n_sigma():
+    """Tests get_six_sigma function."""
+
+    counts = np.array([[16, 4, 1], [0, 0, 0], [1, 1, 1], [2, 0, 5]])
+    threshold = get_n_sigma(counts / 15, 15, 6)
+
+    assert np.all(threshold >= 3 / 15)
+    mean = np.mean(counts[0] / 15)
+    squared_differences = (counts[0] / 15 - mean) ** 2
+    variance = np.mean(squared_differences)
+    std_dev = np.sqrt(variance)
+
+    np.testing.assert_allclose(mean + std_dev * 6, threshold[0], atol=1e-2, rtol=0)
+
+
+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)
+    threshold = get_n_sigma(expected_counts / 15, 15, 1)
+
+    # At the first energy level were the rates > threshold and the counts > threshold?
+    assert np.all(
+        quality_flags[expected_counts == 0] == ImapRatesUltraFlags.ZEROCOUNTS.value
+    )
+    high_rates_flag = quality_flags[expected_counts / 15 > threshold[:, np.newaxis]]
+    assert np.all(high_rates_flag == ImapRatesUltraFlags.HIGHRATES.value)

imap_processing/tests/ultra/unit/test_ultra_l1b_extended.py

@@ -13,6 +13,9 @@ 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_front_x_position,
@@ -21,7 +24,6 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
     get_ph_tof_and_back_positions,
     get_ssd_back_position_and_tof_offset,
     get_ssd_tof,
-    get_unit_vector,
 )
 
 
@@ -213,41 +215,42 @@ def test_calculate_etof_xc(de_dataset, yf_fixture):
     )
 
 
-def test_get_unit_vector(de_dataset, yf_fixture):
-    """Tests get_unit_vector function."""
+def test_get_de_velocity(de_dataset, yf_fixture):
+    """Tests get_de_velocity function."""
     df_filt, _, _ = yf_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])
-    )[0]
-
-    ph_rows = df_filt.iloc[ph_indices]
-    test_xf = ph_rows["Xf"].astype("float").values
-    test_yf = ph_rows["Yf"].astype("float").values
-    test_xb = ph_rows["Xb"].astype("float").values
-    test_yb = ph_rows["Yb"].astype("float").values
-    test_d = ph_rows["d"].astype("float").values
-    test_tof = ph_rows["TOF"].astype("float").values
+    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"]
+    )
 
-    vhat_x, vhat_y, vhat_z = get_unit_vector(
+    v = get_de_velocity(
         (test_xf, test_yf),
         (test_xb, test_yb),
         test_d,
         test_tof,
     )
-    # FSW test data should be negative and not have an analysis
-    # for negative tof values.
-    assert vhat_x[test_tof > 0] == pytest.approx(
-        -df_filt["vhatX"].iloc[ph_indices].astype("float").values[test_tof > 0],
-        rel=1e-2,
+
+    v_x, v_y, v_z = v[:, 0], v[:, 1], v[:, 2]
+
+    np.testing.assert_allclose(
+        v_x[test_tof > 0],
+        df_ph["vx"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
     )
-    assert vhat_y[test_tof > 0] == pytest.approx(
-        -df_filt["vhatY"].iloc[ph_indices].astype("float").values[test_tof > 0],
-        rel=1e-2,
+    np.testing.assert_allclose(
+        v_y[test_tof > 0],
+        df_ph["vy"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
     )
-    assert vhat_z[test_tof > 0] == pytest.approx(
-        -df_filt["vhatZ"].iloc[ph_indices].astype("float").values[test_tof > 0],
-        rel=1e-2,
+    np.testing.assert_allclose(
+        v_z[test_tof > 0],
+        df_ph["vz"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
     )
 
 
@@ -264,6 +267,37 @@ def test_get_ssd_tof(de_dataset, yf_fixture):
     )
 
 
+def test_get_de_energy_kev(de_dataset, yf_fixture):
+    """Tests get_de_energy_kev function."""
+    df_filt, _, _ = yf_fixture
+    df_ph = df_filt[np.isin(df_filt["StopType"], [StopType.PH.value])]
+    df_ph = df_ph[df_ph["energy_revised"].astype("str") != "FILL"]
+
+    species_bin_ph = determine_species(
+        df_ph["TOF"].astype("float").to_numpy(),
+        df_ph["r"].astype("float").to_numpy(),
+        "PH",
+    )
+    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"]
+    )
+
+    v = get_de_velocity(
+        (test_xf, test_yf),
+        (test_xb, test_yb),
+        test_d,
+        test_tof,
+    )
+
+    energy = get_de_energy_kev(v, species_bin_ph)
+    index_hydrogen = np.where(species_bin_ph == "H")
+    actual_energy = energy[index_hydrogen[0]]
+    expected_energy = df_ph["energy_revised"].astype("float")
+
+    np.testing.assert_allclose(actual_energy, expected_energy, atol=1e-01, rtol=0)
+
+
 def test_get_energy_ssd(de_dataset, yf_fixture):
     """Tests get_energy_ssd function."""
     df_filt, _, _ = yf_fixture
@@ -360,3 +394,29 @@ def test_determine_species(yf_fixture):
 
     np.testing.assert_array_equal(h_indices_ph, ctof_indices_ph)
     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])]
+
+    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"]
+    )
+
+    v = get_de_velocity(
+        (test_xf, test_yf),
+        (test_xb, test_yb),
+        test_d,
+        test_tof,
+    )
+    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)

imap_processing/tests/ultra/unit/test_ultra_l1c.py

@@ -68,7 +68,7 @@ def mock_data_l1c_dict():
 def test_create_dataset(mock_data_l1c_dict):
     """Tests that dataset is created as expected."""
     dataset = create_dataset(
-        mock_data_l1c_dict, "imap_ultra_l1c_45sensor-histogram", "l1c"
+        mock_data_l1c_dict, "imap_ultra_l1c_45sensor-histogram", "l1c", "001"
     )
 
     assert "epoch" in dataset.coords

imap_processing/tests/ultra/unit/test_ultra_l1c_pset_bins.py

@@ -6,6 +6,7 @@ import pytest
 from cdflib import CDF
 
 from imap_processing import imap_module_directory
+from imap_processing.ena_maps.utils.spatial_utils import build_spatial_bins
 from imap_processing.ultra.l1c.ultra_l1c_pset_bins import (
     build_energy_bins,
     get_helio_exposure_times,
@@ -13,7 +14,6 @@ from imap_processing.ultra.l1c.ultra_l1c_pset_bins import (
     get_pointing_frame_exposure_times,
     get_pointing_frame_sensitivity,
 )
-from imap_processing.ultra.utils.spatial_utils import build_spatial_bins
 
 BASE_PATH = imap_module_directory / "ultra" / "lookup_tables"
 
@@ -52,7 +52,7 @@ def test_get_histogram(test_data):
     v, energy = test_data
 
     az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints = (
-        build_spatial_bins()
+        np.rad2deg(angle_radians) for angle_radians in (build_spatial_bins())
     )
     energy_bin_edges, _ = build_energy_bins()
 
@@ -101,7 +101,7 @@ def test_get_helio_exposure_times():
 
     energy_bin_edges, energy_midpoints = build_energy_bins()
     az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints = (
-        build_spatial_bins()
+        np.rad2deg(angle_radians) for angle_radians in (build_spatial_bins())
     )
 
     assert exposure_3d.shape == (

imap_processing/ultra/constants.py

@@ -1,6 +1,7 @@
 """Module for constants and useful shared classes used in Ultra."""
 
 from dataclasses import dataclass
+from typing import ClassVar
 
 
 @dataclass(frozen=True)
@@ -60,7 +61,8 @@ class UltraConstants:
     )  # SSD-specific correction to DMIN [mm]
 
     # Conversion factors
-    KEV_J = 1.602180000000000e-16  # 1.6021766339999e-16 # keV to joules
+    KEV_J = 1.602177e-16  # keV to joules
+    J_KEV = 1 / KEV_J  # joules to keV
     MASS_H = 1.6735575e-27  # Mass of a hydrogen atom in kilograms.
 
     # Energy bin constants
@@ -71,3 +73,11 @@ class UltraConstants:
     # Constants for species determination based on ctof range.
     CTOF_SPECIES_MIN = 50
     CTOF_SPECIES_MAX = 200
+
+    # RPMs for the Ultra instrument.
+    # TODO: this is a placeholder.
+    CULLING_RPM_MIN = 2.0
+    CULLING_RPM_MAX = 6.0
+
+    # Thresholds for culling based on counts.
+    CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [-1e5, 0, 10, 20, 1e5]

imap_processing/ultra/l1a/ultra_l1a.py

@@ -11,7 +11,7 @@ import xarray as xr
 
 from imap_processing import decom, imap_module_directory
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
-from imap_processing.spice.time import met_to_j2000ns
+from imap_processing.spice.time import met_to_ttj2000ns
 from imap_processing.ultra.l0.decom_ultra import process_ultra_apids
 from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_AUX,
@@ -69,7 +69,7 @@ def initiate_data_arrays(decom_ultra: dict, apid: int) -> xr.Dataset:
     cdf_manager.add_instrument_variable_attrs("ultra", "l1a")
 
     epoch_time = xr.DataArray(
-        met_to_j2000ns(raw_time),
+        met_to_ttj2000ns(raw_time),
         name="epoch",
         dims=["epoch"],
         attrs=cdf_manager.get_variable_attributes("epoch"),

imap_processing/ultra/l1b/badtimes.py

@@ -1,26 +1,43 @@
 """Calculate Badtimes."""
 
+import numpy as np
 import xarray as xr
+from numpy.typing import NDArray
 
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 
-def calculate_badtimes(extended_spin_dict: dict, name: str) -> xr.Dataset:
+def calculate_badtimes(
+    extendedspin_dataset: xr.Dataset,
+    cullingmask_spins: NDArray,
+    name: str,
+    data_version: str,
+) -> xr.Dataset:
     """
     Create dataset with defined datatypes for Badtimes Data.
 
     Parameters
     ----------
-    extended_spin_dict : dict
-        L1b data dictionary.
+    extendedspin_dataset : xarray.Dataset
+        Dataset containing the data.
+    cullingmask_spins : np.ndarray
+        Dataset containing the culled data.
     name : str
         Name of the dataset.
+    data_version : str
+        Version of the data.
 
     Returns
     -------
     badtimes_dataset : xarray.Dataset
-        Dataset containing the data.
+        Dataset containing the extendedspin data that has been culled.
     """
-    badtimes_dataset = create_dataset(extended_spin_dict, name, "l1b")
+    culled_spins = np.setdiff1d(
+        extendedspin_dataset["spin_number"].values, cullingmask_spins
+    )
+
+    filtered_dataset = extendedspin_dataset.sel(spin_number=culled_spins)
+
+    badtimes_dataset = create_dataset(filtered_dataset, name, "l1b", data_version)
 
     return badtimes_dataset

imap_processing/ultra/l1b/cullingmask.py

@@ -2,25 +2,51 @@
 
 import xarray as xr
 
+from imap_processing.quality_flags import ImapAttitudeUltraFlags, ImapRatesUltraFlags
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 
-def calculate_cullingmask(extended_spin_dict: dict, name: str) -> xr.Dataset:
+def calculate_cullingmask(
+    extendedspin_dataset: xr.Dataset, name: str, data_version: str
+) -> xr.Dataset:
     """
     Create dataset with defined datatype for Culling Mask Data.
 
     Parameters
     ----------
-    extended_spin_dict : dict
-        L1b data dictionary.
+    extendedspin_dataset : xarray.Dataset
+        Dataset containing the data.
     name : str
         Name of the dataset.
+    data_version : str
+        Version of the data.
 
     Returns
     -------
     cullingmask_dataset : xarray.Dataset
-        Dataset containing the data.
+        Dataset containing the extendedspin data that remains after culling.
     """
-    cullingmask_dataset = create_dataset(extended_spin_dict, name, "l1b")
+    # If the spin rate was too high or low then the spin should be thrown out.
+    # If the rates at any energy level are too high then throw out the entire spin.
+    good_mask = (
+        (
+            extendedspin_dataset["quality_attitude"]
+            & ImapAttitudeUltraFlags.SPINRATE.value
+        )
+        == 0
+    ) & (
+        (
+            (
+                extendedspin_dataset["quality_ena_rates"]
+                & ImapRatesUltraFlags.HIGHRATES.value
+            )
+            == 0
+        ).all(dim="energy_bin_geometric_mean")
+    )
+    filtered_dataset = extendedspin_dataset.sel(
+        spin_number=extendedspin_dataset["spin_number"][good_mask]
+    )
+
+    cullingmask_dataset = create_dataset(filtered_dataset, name, "l1b", data_version)
 
     return cullingmask_dataset