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

imap_processing/tests/ultra/unit/test_de.py

@@ -0,0 +1,113 @@
+"""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()
+def df_filt(de_dataset, events_fsw_comparison_theta_0):
+    """Fixture to import test dataset."""
+    df = pd.read_csv(events_fsw_comparison_theta_0)
+    df_filt = df[df["StartType"] != -1]
+    df_filt = df_filt.replace("FILL", 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):
+    """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")
+
+    # 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"))
+
+    # Coincidence positions
+    assert np.allclose(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"))
+
+    # 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"))
+
+    # 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"))
+
+    # Energies and species
+    assert np.allclose(dataset["energy"], df_filt["Energy"].astype("float"))
+    species_array = dataset["species"][
+        np.where(
+            (dataset["tof_corrected"] > UltraConstants.CTOF_SPECIES_MIN)
+            & (dataset["tof_corrected"] < UltraConstants.CTOF_SPECIES_MAX)
+        )[0]
+    ]
+    assert np.all(species_array == "H")
+
+    # Velocities in various frames
+    test_tof = dataset["tof_start_stop"]
+    assert np.allclose(
+        dataset["vx_ultra"][test_tof > 0],
+        -df_filt["vhatX"].astype("float").values[test_tof > 0],
+        rtol=1e-2,
+    )
+    assert np.allclose(
+        dataset["vy_ultra"][test_tof > 0],
+        -df_filt["vhatY"].astype("float").values[test_tof > 0],
+        rtol=1e-2,
+    )
+    assert np.allclose(
+        dataset["vz_ultra"][test_tof > 0],
+        -df_filt["vhatZ"].astype("float").values[test_tof > 0],
+        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"]),)
+
+    # Event efficiency
+    assert np.allclose(
+        dataset["event_efficiency"],
+        np.full(len(de_dataset["epoch"]), np.nan),
+        equal_nan=True,
+    )

imap_processing/tests/ultra/unit/test_spatial_utils.py

@@ -0,0 +1,125 @@
+"""Test creation of solid angle map."""
+
+import numpy as np
+import numpy.testing as npt
+import pytest
+
+from imap_processing.ultra.utils import spatial_utils
+
+# Parameterize with spacings (degrees here):
+valid_spacings = [0.1, 0.25, 0.5, 1, 5, 10, 20]
+invalid_spacings = [0, -1, 11]
+invalid_spacings_match_str = [
+    "Spacing must be positive valued, non-zero.",
+    "Spacing must be positive valued, non-zero.",
+    "Spacing must divide evenly into pi radians.",
+]
+
+
+def test_build_spatial_bins():
+    """Tests build_spatial_bins function."""
+    az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints = (
+        spatial_utils.build_spatial_bins()
+    )
+
+    assert az_bin_edges[0] == 0
+    assert az_bin_edges[-1] == 360
+    assert len(az_bin_edges) == 721
+
+    assert el_bin_edges[0] == -90
+    assert el_bin_edges[-1] == 90
+    assert len(el_bin_edges) == 361
+
+    assert len(az_bin_midpoints) == 720
+    np.testing.assert_allclose(az_bin_midpoints[0], 0.25, atol=1e-4)
+    np.testing.assert_allclose(az_bin_midpoints[-1], 359.75, atol=1e-4)
+
+    assert len(el_bin_midpoints) == 360
+    np.testing.assert_allclose(el_bin_midpoints[0], -89.75, atol=1e-4)
+    np.testing.assert_allclose(el_bin_midpoints[-1], 89.75, atol=1e-4)
+
+
+@pytest.mark.parametrize("spacing", valid_spacings)
+def test_build_solid_angle_map(spacing):
+    """Test build_solid_angle_map function."""
+    solid_angle_map_steradians = spatial_utils.build_solid_angle_map(
+        spacing, input_degrees=True, output_degrees=False
+    )
+    assert np.isclose(np.sum(solid_angle_map_steradians), 4 * np.pi, atol=0, rtol=1e-9)
+
+    solid_angle_map_sqdeg = spatial_utils.build_solid_angle_map(
+        np.deg2rad(spacing), input_degrees=False, output_degrees=True
+    )
+    assert np.isclose(
+        np.sum(solid_angle_map_sqdeg), 4 * np.pi * (180 / np.pi) ** 2, atol=0, rtol=1e-9
+    )
+
+
+@pytest.mark.parametrize(
+    "spacing, match_str", zip(invalid_spacings, invalid_spacings_match_str)
+)
+def test_build_solid_angle_map_invalid_spacing(spacing, match_str):
+    """Test build_solid_angle_map function raises error for invalid spacing."""
+    with pytest.raises(ValueError, match=match_str):
+        _ = spatial_utils.build_solid_angle_map(
+            spacing, input_degrees=True, output_degrees=False
+        )
+
+
+@pytest.mark.parametrize("spacing", valid_spacings)
+def test_build_az_el_grid(spacing):
+    """Test build_az_el_grid function."""
+    az_range, el_range, az_grid, el_grid = spatial_utils.build_az_el_grid(
+        spacing=spacing,
+        input_degrees=True,
+        output_degrees=True,
+        centered_azimuth=False,
+        centered_elevation=True,
+    )
+
+    # Size checks
+    assert az_range.size == int(360 / spacing)
+    assert el_range.size == int(180 / spacing)
+    assert az_range.size == az_grid.shape[1]
+    assert el_range.size == el_grid.shape[0]
+
+    # Check grid values
+    expected_az_range = np.arange((spacing / 2), 360 + (spacing / 2), spacing)
+    expected_el_range = np.arange(-90 + (spacing / 2), 90 + (spacing / 2), spacing)[
+        ::-1
+    ]  # Note el order is reversed
+
+    npt.assert_allclose(az_range, expected_az_range, atol=1e-12)
+    npt.assert_allclose(el_range, expected_el_range, atol=1e-12)
+
+
+def test_rewrap_even_spaced_el_az_grid_1d():
+    """Test rewrap_even_spaced_el_az_grid function, without extra axis."""
+    orig_shape = (180 * 12, 360 * 12)
+    orig_grid = np.fromfunction(lambda i, j: i**2 + j, orig_shape, dtype=int)
+    raveled_values = orig_grid.ravel(order="F")
+    rewrapped_grid_infer_shape = spatial_utils.rewrap_even_spaced_el_az_grid(
+        raveled_values
+    )
+    rewrapped_grid_known_shape = spatial_utils.rewrap_even_spaced_el_az_grid(
+        raveled_values, shape=orig_shape
+    )
+
+    assert np.array_equal(rewrapped_grid_infer_shape, orig_grid)
+    assert np.array_equal(rewrapped_grid_known_shape, orig_grid)
+
+
+def test_rewrap_even_spaced_el_az_grid_2d():
+    """Test rewrap_even_spaced_el_az_grid function, with extra axis."""
+    orig_shape = (180 * 12, 360 * 12, 5)
+    orig_grid = np.fromfunction(lambda i, j, k: i**2 + j + k, orig_shape, dtype=int)
+    raveled_values = orig_grid.reshape(-1, 5, order="F")
+    rewrapped_grid_infer_shape = spatial_utils.rewrap_even_spaced_el_az_grid(
+        raveled_values, extra_axis=True
+    )
+    rewrapped_grid_known_shape = spatial_utils.rewrap_even_spaced_el_az_grid(
+        raveled_values, shape=orig_shape, extra_axis=True
+    )
+    assert raveled_values.shape == (180 * 12 * 360 * 12, 5)
+    assert np.array_equal(rewrapped_grid_infer_shape, orig_grid)
+    assert np.array_equal(rewrapped_grid_known_shape, orig_grid)

imap_processing/tests/ultra/unit/test_ultra_l1b.py

@@ -1,3 +1,5 @@
+from unittest import mock
+
 import numpy as np
 import pytest
 import xarray as xr
@@ -73,7 +75,7 @@ def test_create_dataset(mock_data_l1b_dict):
     assert "epoch" in dataset.coords
     assert dataset.coords["epoch"].dtype == "datetime64[ns]"
     assert dataset.attrs["Logical_source"] == "imap_ultra_l1b_45sensor-de"
-    assert dataset["x_front"].attrs["UNITS"] == "mm"
+    assert dataset["x_front"].attrs["UNITS"] == "mm / 100"
     np.testing.assert_array_equal(dataset["x_front"], np.zeros(3))
 
 
@@ -99,9 +101,31 @@ def test_ultra_l1b_rates(mock_data_l1a_rates_dict):
     )
 
 
-def test_ultra_l1b_de(mock_data_l1a_de_aux_dict):
+@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."""
-    output_datasets = ultra_l1b(mock_data_l1a_de_aux_dict, data_version="001")
+    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"

imap_processing/tests/ultra/unit/test_ultra_l1b_annotated.py

@@ -5,7 +5,9 @@ import pytest
 import spiceypy as spice
 
 from imap_processing.spice.geometry import SpiceFrame
-from imap_processing.ultra.l1b.ultra_l1b_annotated import get_particle_velocity
+from imap_processing.ultra.l1b.ultra_l1b_annotated import (
+    get_annotated_particle_velocity,
+)
 
 
 @pytest.fixture()
@@ -45,18 +47,37 @@ def test_get_particle_velocity(spice_test_data_path, kernels):
     times = np.array([start])
     instrument_velocity = np.array([[41.18609, -471.24467, -832.8784]])
 
-    sc_velocity_45, helio_velocity_45 = get_particle_velocity(
-        times, instrument_velocity, SpiceFrame.IMAP_ULTRA_45, SpiceFrame.IMAP_DPS
+    sc_velocity_45, sc_dps_velocity_45, helio_velocity_45 = (
+        get_annotated_particle_velocity(
+            times,
+            instrument_velocity,
+            SpiceFrame.IMAP_ULTRA_45,
+            SpiceFrame.IMAP_DPS,
+            SpiceFrame.IMAP_SPACECRAFT,
+        )
     )
-    sc_velocity_90, helio_velocity_90 = get_particle_velocity(
-        times, instrument_velocity, SpiceFrame.IMAP_ULTRA_90, SpiceFrame.IMAP_DPS
+    sc_velocity_90, sc_dps_velocity_90, helio_velocity_90 = (
+        get_annotated_particle_velocity(
+            times,
+            instrument_velocity,
+            SpiceFrame.IMAP_ULTRA_90,
+            SpiceFrame.IMAP_DPS,
+            SpiceFrame.IMAP_SPACECRAFT,
+        )
     )
 
     # Compute the magnitude of the velocity vectors in both frames
-    magnitude_45 = np.linalg.norm(sc_velocity_45)
-    magnitude_90 = np.linalg.norm(sc_velocity_90)
+    magnitude_sc_45 = np.linalg.norm(sc_velocity_45)
+    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")
 
-    assert np.allclose(magnitude_45, magnitude_90, atol=1e-6)
-    assert np.array_equal((helio_velocity_45 - state[0][3:6]).flatten(), sc_velocity_45)
-    assert np.array_equal((helio_velocity_90 - state[0][3:6]).flatten(), sc_velocity_90)
+    assert np.allclose(magnitude_sc_45, magnitude_sc_90, atol=1e-6)
+    assert np.allclose(magnitude_dps_45, magnitude_dps_90, atol=1e-6)
+    assert np.array_equal(
+        (helio_velocity_45 - state[0][3:6]).flatten(), sc_dps_velocity_45
+    )
+    assert np.array_equal(
+        (helio_velocity_90 - state[0][3:6]).flatten(), sc_dps_velocity_90
+    )

imap_processing/tests/ultra/unit/test_ultra_l1b_extended.py

@@ -4,24 +4,24 @@ import numpy as np
 import pandas as pd
 import pytest
 
+from imap_processing.ultra.constants import UltraConstants
 from imap_processing.ultra.l1b.ultra_l1b_extended import (
     CoinType,
     StartType,
     StopType,
     calculate_etof_xc,
-    determine_species_pulse_height,
-    determine_species_ssd,
+    determine_species,
     get_coincidence_positions,
     get_ctof,
     get_energy_pulse_height,
     get_energy_ssd,
     get_front_x_position,
     get_front_y_position,
-    get_particle_velocity,
     get_path_length,
     get_ph_tof_and_back_positions,
     get_ssd_back_position_and_tof_offset,
     get_ssd_tof,
+    get_unit_vector,
 )
 
 
@@ -213,8 +213,8 @@ def test_calculate_etof_xc(de_dataset, yf_fixture):
     )
 
 
-def test_get_particle_velocity(de_dataset, yf_fixture):
-    """Tests get_particle_velocity function."""
+def test_get_unit_vector(de_dataset, yf_fixture):
+    """Tests get_unit_vector function."""
     df_filt, _, _ = yf_fixture
 
     ph_indices = np.nonzero(
@@ -229,7 +229,7 @@ def test_get_particle_velocity(de_dataset, yf_fixture):
     test_d = ph_rows["d"].astype("float").values
     test_tof = ph_rows["TOF"].astype("float").values
 
-    vhat_x, vhat_y, vhat_z = get_particle_velocity(
+    vhat_x, vhat_y, vhat_z = get_unit_vector(
         (test_xf, test_yf),
         (test_xb, test_yb),
         test_d,
@@ -254,7 +254,7 @@ def test_get_particle_velocity(de_dataset, yf_fixture):
 def test_get_ssd_tof(de_dataset, yf_fixture):
     """Tests get_ssd_tof function."""
     df_filt, _, _ = yf_fixture
-    df_ssd = df_filt[df_filt["StopType"].isin(StopType.SSD.value)]
+    df_ssd = df_filt[np.isin(df_filt["StopType"], [StopType.SSD.value])]
     test_xf = df_filt["Xf"].astype("float").values
 
     ssd_tof = get_ssd_tof(de_dataset, test_xf)
@@ -267,7 +267,7 @@ def test_get_ssd_tof(de_dataset, yf_fixture):
 def test_get_energy_ssd(de_dataset, yf_fixture):
     """Tests get_energy_ssd function."""
     df_filt, _, _ = yf_fixture
-    df_ssd = df_filt[df_filt["StopType"].isin(StopType.SSD.value)]
+    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)
     test_energy = df_ssd["Energy"].astype("float")
@@ -278,7 +278,7 @@ def test_get_energy_ssd(de_dataset, yf_fixture):
 def test_get_energy_pulse_height(de_dataset, yf_fixture):
     """Tests get_energy_ssd function."""
     df_filt, _, _ = yf_fixture
-    df_ph = df_filt[df_filt["StopType"].isin(StopType.PH.value)]
+    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]
@@ -297,46 +297,66 @@ def test_get_energy_pulse_height(de_dataset, yf_fixture):
 def test_get_ctof(yf_fixture):
     """Tests get_ctof function."""
     df_filt, _, _ = yf_fixture
+    df_filt = df_filt[df_filt["eTOF"].astype("str") != "FILL"]
+    df_filt = df_filt[df_filt["cTOF"].astype("float") > 0]
 
-    df_ph_ssd = df_filt[
-        df_filt["StopType"].isin([StopType.SSD.value, StopType.PH.value])
-    ]
+    df_ph = df_filt[np.isin(df_filt["StopType"], [StopType.PH.value])]
+    df_ssd = df_filt[np.isin(df_filt["StopType"], [StopType.SSD.value])]
 
-    ctof = get_ctof(
-        df_ph_ssd["TOF"].astype("float").to_numpy(),
-        df_ph_ssd["r"].astype("float").to_numpy(),
+    ph_ctof, ph_magnitude_v = get_ctof(
+        df_ph["TOF"].astype("float").to_numpy(),
+        df_ph["r"].astype("float").to_numpy(),
+        "PH",
     )
 
+    ssd_ctof, ssd_magnitude_v = get_ctof(
+        df_ssd["TOF"].astype("float").to_numpy(),
+        df_ssd["r"].astype("float").to_numpy(),
+        "SSD",
+    )
+
+    np.testing.assert_allclose(
+        ph_ctof, df_ph["cTOF"].astype("float"), atol=1e-05, rtol=0
+    )
+    np.testing.assert_allclose(
+        ssd_ctof, df_ssd["cTOF"].astype("float"), atol=1e-05, rtol=0
+    )
     np.testing.assert_allclose(
-        ctof, df_ph_ssd["cTOF"].astype("float"), atol=1e-05, rtol=0
+        ph_magnitude_v, df_ph["vmag"].astype("float"), atol=1e-01, rtol=0
+    )
+    np.testing.assert_allclose(
+        ssd_magnitude_v, df_ssd["vmag"].astype("float"), atol=1e-01, rtol=0
     )
 
 
-def test_determine_species_ph(yf_fixture):
-    """Tests determine_species_ph function."""
+def test_determine_species(yf_fixture):
+    """Tests determine_species function."""
     df_filt, _, _ = yf_fixture
-    df_ph = df_filt[df_filt["StopType"].isin(StopType.PH.value)]
+    df_ph = df_filt[np.isin(df_filt["StopType"], [StopType.PH.value])]
+    df_ssd = df_filt[np.isin(df_filt["StopType"], [StopType.SSD.value])]
 
-    bin = determine_species_pulse_height(
-        df_ph["Energy"].astype("float").to_numpy(),
+    species_bin_ph = determine_species(
         df_ph["TOF"].astype("float").to_numpy(),
         df_ph["r"].astype("float").to_numpy(),
+        "PH",
     )
-
-    # TODO: add in bin values.
-    np.testing.assert_allclose(bin, np.zeros(len(bin)), atol=1e-05, rtol=0)
-
-
-def test_determine_species_ssd(yf_fixture):
-    """Tests determine_species_ssd function."""
-    df_filt, _, _ = yf_fixture
-    df_ssd = df_filt[df_filt["StopType"].isin(StopType.SSD.value)]
-
-    bin = determine_species_ssd(
-        df_ssd["Energy"].astype("float").to_numpy(),
+    species_bin_ssd = determine_species(
         df_ssd["TOF"].astype("float").to_numpy(),
         df_ssd["r"].astype("float").to_numpy(),
+        "SSD",
     )
 
-    # TODO: add in bin values.
-    np.testing.assert_allclose(bin, np.zeros(len(bin)), atol=1e-05, rtol=0)
+    h_indices_ph = np.where(species_bin_ph == "H")[0]
+    ctof_indices_ph = np.where(
+        (df_ph["cTOF"].astype("float") > UltraConstants.CTOF_SPECIES_MIN)
+        & (df_ph["cTOF"].astype("float") < UltraConstants.CTOF_SPECIES_MAX)
+    )[0]
+
+    h_indices_ssd = np.where(species_bin_ssd == "H")[0]
+    ctof_indices_ssd = np.where(
+        (df_ssd["cTOF"].astype("float") > UltraConstants.CTOF_SPECIES_MIN)
+        & (df_ssd["cTOF"].astype("float") < UltraConstants.CTOF_SPECIES_MAX)
+    )[0]
+
+    np.testing.assert_array_equal(h_indices_ph, ctof_indices_ph)
+    np.testing.assert_array_equal(h_indices_ssd, ctof_indices_ssd)

imap_processing/tests/ultra/unit/test_ultra_l1c_pset_bins.py

@@ -3,19 +3,17 @@
 import cdflib
 import numpy as np
 import pytest
-import spiceypy as spice
 from cdflib import CDF
 
 from imap_processing import imap_module_directory
 from imap_processing.ultra.l1c.ultra_l1c_pset_bins import (
     build_energy_bins,
-    build_spatial_bins,
-    cartesian_to_spherical,
     get_helio_exposure_times,
     get_histogram,
     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"
 
@@ -32,33 +30,15 @@ def test_data():
     return v, energy
 
 
-@pytest.fixture()
-def kernels(spice_test_data_path):
-    """List SPICE kernels."""
-    required_kernels = [
-        "imap_science_0001.tf",
-        "imap_sclk_0000.tsc",
-        "sim_1yr_imap_attitude.bc",
-        "imap_wkcp.tf",
-        "naif0012.tls",
-        "sim_1yr_imap_pointing_frame.bc",
-        "de440s.bsp",
-        "imap_spk_demo.bsp",
-    ]
-    kernels = [str(spice_test_data_path / kernel) for kernel in required_kernels]
-
-    return kernels
-
-
 def test_build_energy_bins():
     """Tests build_energy_bins function."""
     energy_bin_edges, energy_midpoints = build_energy_bins()
-    energy_bin_start = energy_bin_edges[:-1]
-    energy_bin_end = energy_bin_edges[1:]
+    energy_bin_start = [interval[0] for interval in energy_bin_edges]
+    energy_bin_end = [interval[1] for interval in energy_bin_edges]
 
     assert energy_bin_start[0] == 0
     assert energy_bin_start[1] == 3.385
-    assert len(energy_bin_edges) == 25
+    assert len(energy_bin_edges) == 24
     assert energy_midpoints[0] == (energy_bin_start[0] + energy_bin_end[0]) / 2
 
     # Comparison to expected values.
@@ -67,44 +47,6 @@ def test_build_energy_bins():
     np.testing.assert_allclose(energy_bin_end[-1], 341.989, atol=1e-4)
 
 
-def test_build_spatial_bins():
-    """Tests build_spatial_bins function."""
-    az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints = (
-        build_spatial_bins()
-    )
-
-    assert az_bin_edges[0] == 0
-    assert az_bin_edges[-1] == 360
-    assert len(az_bin_edges) == 721
-
-    assert el_bin_edges[0] == -90
-    assert el_bin_edges[-1] == 90
-    assert len(el_bin_edges) == 361
-
-    assert len(az_bin_midpoints) == 720
-    np.testing.assert_allclose(az_bin_midpoints[0], 0.25, atol=1e-4)
-    np.testing.assert_allclose(az_bin_midpoints[-1], 359.75, atol=1e-4)
-
-    assert len(el_bin_midpoints) == 360
-    np.testing.assert_allclose(el_bin_midpoints[0], -89.75, atol=1e-4)
-    np.testing.assert_allclose(el_bin_midpoints[-1], 89.75, atol=1e-4)
-
-
-def test_cartesian_to_spherical(test_data):
-    """Tests cartesian_to_spherical function."""
-    v, _ = test_data
-
-    az_sc, el_sc, r = cartesian_to_spherical(v)
-
-    # MATLAB code outputs:
-    np.testing.assert_allclose(
-        np.unique(np.radians(az_sc)), np.array([1.31300, 2.34891]), atol=1e-05, rtol=0
-    )
-    np.testing.assert_allclose(
-        np.unique(np.radians(el_sc)), np.array([-0.88901, -0.70136]), atol=1e-05, rtol=0
-    )
-
-
 def test_get_histogram(test_data):
     """Tests get_histogram function."""
     v, energy = test_data
@@ -119,7 +61,7 @@ def test_get_histogram(test_data):
     assert hist.shape == (
         len(az_bin_edges) - 1,
         len(el_bin_edges) - 1,
-        len(energy_bin_edges) - 1,
+        len(energy_bin_edges),
     )
 
 
@@ -143,10 +85,10 @@ def test_get_pointing_frame_exposure_times():
 
 
 @pytest.mark.external_kernel()
-def test_et_helio_exposure_times(kernels):
+@pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
+def test_get_helio_exposure_times():
     """Tests get_helio_exposure_times function."""
 
-    spice.furnsh(kernels)
     constant_exposure = BASE_PATH / "dps_grid45_compressed.cdf"
     start_time = 829485054.185627
     end_time = 829567884.185627
@@ -185,9 +127,9 @@ def test_et_helio_exposure_times(kernels):
             transposed_exposure = np.transpose(exposure_data, (2, 1, 0))
             exposures.append(transposed_exposure)
 
-    np.array_equal(exposures[0], exposure_3d[:, :, 0])
-    np.array_equal(exposures[1], exposure_3d[:, :, 1])
-    np.array_equal(exposures[2], exposure_3d[:, :, 2])
+    assert np.array_equal(np.squeeze(exposures[0]), exposure_3d[:, :, 0])
+    assert np.array_equal(np.squeeze(exposures[1]), exposure_3d[:, :, 11])
+    assert np.array_equal(np.squeeze(exposures[2]), exposure_3d[:, :, 23])
 
 
 def test_get_pointing_frame_sensitivity():

imap_processing/ultra/constants.py

@@ -52,13 +52,22 @@ class UltraConstants:
     DF: float = 3.39  # Distance from slit to foil [mm]
 
     # Derived constants
-    DMIN: float = (
+    DMIN_PH_CTOF: float = (
         Z_DS - (2**0.5) * DF
     )  # Minimum distance between front and back detectors [mm]
-    DMIN_SSD_CTOF: float = (DMIN**2) / (
-        DMIN - Z_DSTOP
+    DMIN_SSD_CTOF: float = (DMIN_PH_CTOF**2) / (
+        DMIN_PH_CTOF - Z_DSTOP
     )  # SSD-specific correction to DMIN [mm]
 
     # Conversion factors
     KEV_J = 1.602180000000000e-16  # 1.6021766339999e-16 # keV to joules
     MASS_H = 1.6735575e-27  # Mass of a hydrogen atom in kilograms.
+
+    # Energy bin constants
+    ALPHA = 0.2  # deltaE/E
+    ENERGY_START = 3.385  # energy start for the Ultra grids
+    N_BINS = 23  # number of energy bins
+
+    # Constants for species determination based on ctof range.
+    CTOF_SPECIES_MIN = 50
+    CTOF_SPECIES_MAX = 200