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

imap_processing/tests/ultra/unit/test_de.py

@@ -6,6 +6,7 @@ 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
 
 
@@ -66,9 +67,13 @@ def test_calculate_de(mock_get_annotated_particle_velocity, de_dataset, df_filt)
 
     # Energies and species
     assert np.allclose(dataset["energy"], df_filt["Energy"].astype("float"))
-    assert np.allclose(
-        dataset["species"], np.full(len(de_dataset["epoch"]), np.nan, dtype=np.uint8)
-    )
+    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"]

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_extended.py

@@ -4,13 +4,13 @@ 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,
@@ -254,7 +254,7 @@ def test_get_unit_vector(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,18 +297,19 @@ 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 = 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])]
 
-    df_ssd = df_filt[df_filt["StopType"].isin([StopType.SSD.value])]
-
-    ph_ctof = get_ctof(
+    ph_ctof, ph_magnitude_v = get_ctof(
         df_ph["TOF"].astype("float").to_numpy(),
         df_ph["r"].astype("float").to_numpy(),
         "PH",
     )
 
-    ssd_ctof = get_ctof(
+    ssd_ctof, ssd_magnitude_v = get_ctof(
         df_ssd["TOF"].astype("float").to_numpy(),
         df_ssd["r"].astype("float").to_numpy(),
         "SSD",
@@ -320,33 +321,42 @@ def test_get_ctof(yf_fixture):
     np.testing.assert_allclose(
         ssd_ctof, df_ssd["cTOF"].astype("float"), atol=1e-05, rtol=0
     )
+    np.testing.assert_allclose(
+        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

@@ -8,12 +8,12 @@ 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,
     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"
 
@@ -47,29 +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_get_histogram(test_data):
     """Tests get_histogram function."""
     v, energy = test_data
@@ -109,7 +86,7 @@ def test_get_pointing_frame_exposure_times():
 
 @pytest.mark.external_kernel()
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
-def test_et_helio_exposure_times():
+def test_get_helio_exposure_times():
     """Tests get_helio_exposure_times function."""
 
     constant_exposure = BASE_PATH / "dps_grid45_compressed.cdf"

imap_processing/ultra/constants.py

@@ -67,3 +67,7 @@ class UltraConstants:
     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

imap_processing/ultra/l1b/de.py

@@ -10,8 +10,7 @@ from imap_processing.ultra.l1b.ultra_l1b_annotated import (
 )
 from imap_processing.ultra.l1b.ultra_l1b_extended import (
     StopType,
-    determine_species_pulse_height,
-    determine_species_ssd,
+    determine_species,
     get_coincidence_positions,
     get_ctof,
     get_energy_pulse_height,
@@ -57,9 +56,8 @@ def calculate_de(de_dataset: xr.Dataset, name: str) -> xr.Dataset:
     etof = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
     ctof = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
     energy = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    # TODO: uint8 fills with zeros instead of nans.
-    #  Confirm with Ultra team what fill values and dtype we want.
-    species_bin = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.uint8)
+    #  TODO: Confirm with Ultra team what fill values and dtype we want.
+    species_bin = np.full(len(de_dataset["epoch"]), "UNKNOWN", dtype="U10")
     t2 = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
 
     # Drop events with invalid start type.
@@ -95,13 +93,11 @@ def calculate_de(de_dataset: xr.Dataset, name: str) -> xr.Dataset:
         (xb[ph_indices], yb[ph_indices]),
         d[ph_indices],
     )
-    species_bin[ph_indices] = determine_species_pulse_height(
-        energy[ph_indices], tof[ph_indices], r[ph_indices]
-    )
+    species_bin[ph_indices] = determine_species(tof[ph_indices], r[ph_indices], "PH")
     etof[ph_indices], xc[ph_indices] = get_coincidence_positions(
         de_dataset.isel(epoch=ph_indices), t2[ph_indices], f"ultra{sensor}"
     )
-    ctof[ph_indices] = get_ctof(tof[ph_indices], r[ph_indices], "PH")
+    ctof[ph_indices], _ = get_ctof(tof[ph_indices], r[ph_indices], "PH")
 
     # SSD
     ssd_indices = np.nonzero(np.isin(de_dataset["STOP_TYPE"], StopType.SSD.value))[0]
@@ -119,12 +115,10 @@ def calculate_de(de_dataset: xr.Dataset, name: str) -> xr.Dataset:
         (xb[ssd_indices], yb[ssd_indices]),
         d[ssd_indices],
     )
-    species_bin[ssd_indices] = determine_species_ssd(
-        energy[ssd_indices],
-        tof[ssd_indices],
-        r[ssd_indices],
+    species_bin[ssd_indices] = determine_species(
+        tof[ssd_indices], r[ssd_indices], "SSD"
     )
-    ctof[ssd_indices] = get_ctof(tof[ssd_indices], r[ssd_indices], "SSD")
+    ctof[ssd_indices], _ = get_ctof(tof[ssd_indices], r[ssd_indices], "SSD")
 
     # Combine ph_yb and ssd_yb along with their indices
     de_dict["x_front"] = xf.astype(np.float32)

imap_processing/ultra/l1b/ultra_l1b_extended.py

@@ -648,9 +648,11 @@ def get_energy_ssd(de_dataset: xarray.Dataset, ssd: np.ndarray) -> NDArray[np.fl
     return energy_norm
 
 
-def get_ctof(tof: np.ndarray, path_length: np.ndarray, type: str) -> NDArray:
+def get_ctof(
+    tof: np.ndarray, path_length: np.ndarray, type: str
+) -> tuple[NDArray, NDArray]:
     """
-    Calculate the corrected TOF.
+    Calculate the corrected TOF and the magnitude of the particle velocity.
 
     The corrected TOF (ctof) is the TOF normalized with respect
     to a fixed distance dmin between the front and back detectors.
@@ -666,33 +668,35 @@ def get_ctof(tof: np.ndarray, path_length: np.ndarray, type: str) -> NDArray:
     path_length : np.ndarray
         Path length (r) (hundredths of a millimeter).
     type : str
-        Type of event, either "ph" or "ssd".
+        Type of event, either "PH" or "SSD".
 
     Returns
     -------
     ctof : np.ndarray
         Corrected TOF (tenths of a ns).
+    magnitude_v : np.ndarray
+        Magnitude of the particle velocity (km/s).
     """
     dmin_ctof = getattr(UltraConstants, f"DMIN_{type}_CTOF")
 
     # Multiply times 100 to convert to hundredths of a millimeter.
     ctof = tof * dmin_ctof * 100 / path_length
 
-    return ctof
+    # Convert from mm/0.1ns to km/s.
+    magnitude_v = dmin_ctof / ctof * 1e4
 
+    return ctof, magnitude_v
 
-def determine_species_pulse_height(
-    energy: np.ndarray, tof: np.ndarray, path_length: np.ndarray
-) -> NDArray:
+
+def determine_species(tof: np.ndarray, path_length: np.ndarray, type: str) -> NDArray:
     """
     Determine the species for pulse-height events.
 
-    Species is determined from the particle energy and velocity.
+    Species is determined from the particle velocity.
     For velocity, the particle TOF is normalized with respect
     to a fixed distance dmin between the front and back detectors.
     The normalized TOF is termed the corrected TOF (ctof).
-    Particle species are determined from
-    the energy and ctof using a lookup table.
+    Particle species are determined from ctof using thresholds.
 
     Further description is available on pages 42-44 of
     IMAP-Ultra Flight Software Specification document
@@ -700,72 +704,27 @@ def determine_species_pulse_height(
 
     Parameters
     ----------
-    energy : np.ndarray
-        Energy from the SSD event (keV).
-    tof : np.ndarray
-        Time of flight of the SSD event (tenths of a nanosecond).
-    path_length : np.ndarray
-        Path length (r) (hundredths of a millimeter).
-
-    Returns
-    -------
-    bin : np.array
-        Species bin.
-    """
-    # PH event TOF normalization to Z axis
-    ctof = get_ctof(tof, path_length, "PH")
-    # TODO: need lookup tables
-    # placeholder
-    bin = np.zeros(len(ctof))
-    # bin = PHxTOFSpecies[ctof, energy]
-
-    return bin
-
-
-def determine_species_ssd(
-    energy: np.ndarray, tof: np.ndarray, path_length: np.ndarray
-) -> NDArray:
-    """
-    Determine the species for SSD events.
-
-    Species is determined from the particle's energy and velocity.
-    For velocity, the particle's TOF is normalized with respect
-    to a fixed distance dmin between the front and back detectors.
-    For SSD events, an adjustment is also made to the path length
-    to account for the shorter distances that such events
-    travel to reach the detector. The normalized TOF is termed
-    the corrected tof (ctof). Particle species are determined from
-    the energy and cTOF using a lookup table.
-
-    Further description is available on pages 42-44 of
-    IMAP-Ultra Flight Software Specification document
-    (7523-9009_Rev_-.pdf).
-
-    Parameters
-    ----------
-    energy : np.ndarray
-        Energy from the SSD event (keV).
     tof : np.ndarray
         Time of flight of the SSD event (tenths of a nanosecond).
     path_length : np.ndarray
         Path length (r) (hundredths of a millimeter).
+    type : str
+        Type of data (PH or SSD).
 
     Returns
     -------
-    bin : np.ndarray
+    species_bin : np.array
         Species bin.
     """
-    # SSD event TOF normalization to Z axis
-    ctof = get_ctof(tof, path_length, "SSD")
-
-    bin = np.zeros(len(ctof))  # placeholder
-
-    # TODO: get these lookup tables
-    # if r < get_image_params("PathSteepThresh"):
-    #     # bin = ExTOFSpeciesSteep[energy, ctof]
-    # elif r < get_image_params("PathMediumThresh"):
-    #     # bin = ExTOFSpeciesMedium[energy, ctof]
-    # else:
-    #     # bin = ExTOFSpeciesFlat[energy, ctof]
-
-    return bin
+    # Event TOF normalization to Z axis
+    ctof, _ = get_ctof(tof, path_length, type)
+    # Initialize bin array
+    species_bin = np.full(len(ctof), "UNKNOWN", dtype="U10")
+
+    # Assign "H" to bins where cTOF is within the specified range
+    species_bin[
+        (ctof > UltraConstants.CTOF_SPECIES_MIN)
+        & (ctof < UltraConstants.CTOF_SPECIES_MAX)
+    ] = "H"
+
+    return species_bin

imap_processing/ultra/l1c/ultra_l1c_pset_bins.py

@@ -13,6 +13,7 @@ from imap_processing.spice.geometry import (
     spherical_to_cartesian,
 )
 from imap_processing.ultra.constants import UltraConstants
+from imap_processing.ultra.utils.spatial_utils import build_spatial_bins
 
 # TODO: add species binning.
 
@@ -47,42 +48,6 @@ def build_energy_bins() -> tuple[list[tuple[float, float]], np.ndarray]:
     return intervals, energy_midpoints
 
 
-def build_spatial_bins(
-    az_spacing: float = 0.5,
-    el_spacing: float = 0.5,
-) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-    """
-    Build spatial bin boundaries for azimuth and elevation.
-
-    Parameters
-    ----------
-    az_spacing : float, optional
-        The azimuth bin spacing in degrees (default is 0.5 degrees).
-    el_spacing : float, optional
-        The elevation bin spacing in degrees (default is 0.5 degrees).
-
-    Returns
-    -------
-    az_bin_edges : np.ndarray
-        Array of azimuth bin boundary values.
-    el_bin_edges : np.ndarray
-        Array of elevation bin boundary values.
-    az_bin_midpoints : np.ndarray
-        Array of azimuth bin midpoint values.
-    el_bin_midpoints : np.ndarray
-        Array of elevation bin midpoint values.
-    """
-    # Azimuth bins from 0 to 360 degrees.
-    az_bin_edges = np.arange(0, 360 + az_spacing, az_spacing)
-    az_bin_midpoints = az_bin_edges[:-1] + az_spacing / 2  # Midpoints between edges
-
-    # Elevation bins from -90 to 90 degrees.
-    el_bin_edges = np.arange(-90, 90 + el_spacing, el_spacing)
-    el_bin_midpoints = el_bin_edges[:-1] + el_spacing / 2  # Midpoints between edges
-
-    return az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints
-
-
 def get_histogram(
     vhat: tuple[np.ndarray, np.ndarray, np.ndarray],
     energy: np.ndarray,