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

imap_processing/tests/swe/test_swe_l1b.py

@@ -6,6 +6,10 @@ from imap_processing.cdf.utils import load_cdf, write_cdf
 from imap_processing.swe.l1a.swe_l1a import swe_l1a
 from imap_processing.swe.l1a.swe_science import swe_science
 from imap_processing.swe.l1b.swe_l1b import swe_l1b
+from imap_processing.swe.l1b.swe_l1b_science import (
+    convert_counts_to_rate,
+    deadtime_correction,
+)
 
 
 def test_swe_l1b(decom_test_data_derived):
@@ -41,19 +45,36 @@ def test_swe_l1b(decom_test_data_derived):
         )
 
 
-def test_cdf_creation():
+def test_cdf_creation(l1b_validation_df):
     """Test that CDF file is created and has the correct name."""
     test_data_path = "tests/swe/l0_data/2024051010_SWE_SCIENCE_packet.bin"
     l1a_datasets = swe_l1a(imap_module_directory / test_data_path, "002")
 
-    sci_l1a_filepath = write_cdf(l1a_datasets)
-
-    assert sci_l1a_filepath.name == "imap_swe_l1a_sci_20240510_v002.cdf"
-
-    # reads data from CDF file and passes to l1b
-    l1a_cdf_dataset = load_cdf(sci_l1a_filepath)
-    l1b_dataset = swe_l1b(l1a_cdf_dataset, "002")
+    l1b_dataset = swe_l1b(l1a_datasets, "002")
 
     sci_l1b_filepath = write_cdf(l1b_dataset)
 
     assert sci_l1b_filepath.name == "imap_swe_l1b_sci_20240510_v002.cdf"
+    # load the CDF file and compare the values
+    l1b_cdf_dataset = load_cdf(sci_l1b_filepath)
+    processed_science = l1b_cdf_dataset["science_data"].data
+    validation_science = l1b_validation_df.values[:, 1:].reshape(6, 24, 30, 7)
+    np.testing.assert_allclose(processed_science, validation_science, rtol=1e-7)
+
+
+def test_count_rate():
+    x = np.array([1, 10, 100, 1000, 10000, 38911, 65535])
+    acq_duration = 80000
+    deatime_corrected = deadtime_correction(x, acq_duration)
+    count_rate = convert_counts_to_rate(deatime_corrected, acq_duration)
+    # Ruth provided the expected output for this test
+    expected_output = [
+        12.50005653,
+        125.00562805,
+        1250.56278121,
+        12556.50455087,
+        130890.05519127,
+        589631.73670132,
+        1161815.68783304,
+    ]
+    np.testing.assert_allclose(count_rate, expected_output, rtol=1e-7)

imap_processing/tests/test_utils.py

@@ -99,7 +99,7 @@ def test_packet_file_to_datasets(use_derived_value, expected_mode):
 
 
 def test_packet_file_to_datasets_flat_definition():
-    test_file = "tests/idex/imap_idex_l0_raw_20230725_v001.pkts"
+    test_file = "tests/idex/imap_idex_l0_raw_20231214_v001.pkts"
     packet_files = imap_module_directory / test_file
     packet_definition = (
         imap_module_directory / "idex/packet_definitions/idex_packet_definition.xml"

imap_processing/tests/ultra/unit/test_de.py

@@ -0,0 +1,108 @@
+"""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.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"))
+    assert np.allclose(
+        dataset["species"], np.full(len(de_dataset["epoch"]), np.nan, dtype=np.uint8)
+    )
+
+    # 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_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

@@ -17,11 +17,11 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
     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,
@@ -298,17 +298,27 @@ def test_get_ctof(yf_fixture):
     """Tests get_ctof function."""
     df_filt, _, _ = yf_fixture
 
-    df_ph_ssd = df_filt[
-        df_filt["StopType"].isin([StopType.SSD.value, StopType.PH.value])
-    ]
+    df_ph = df_filt[df_filt["StopType"].isin([StopType.PH.value])]
+
+    df_ssd = df_filt[df_filt["StopType"].isin([StopType.SSD.value])]
+
+    ph_ctof = get_ctof(
+        df_ph["TOF"].astype("float").to_numpy(),
+        df_ph["r"].astype("float").to_numpy(),
+        "PH",
+    )
 
-    ctof = get_ctof(
-        df_ph_ssd["TOF"].astype("float").to_numpy(),
-        df_ph_ssd["r"].astype("float").to_numpy(),
+    ssd_ctof = get_ctof(
+        df_ssd["TOF"].astype("float").to_numpy(),
+        df_ssd["r"].astype("float").to_numpy(),
+        "SSD",
     )
 
     np.testing.assert_allclose(
-        ctof, df_ph_ssd["cTOF"].astype("float"), atol=1e-05, rtol=0
+        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
     )
 
 

imap_processing/tests/ultra/unit/test_ultra_l1c_pset_bins.py

@@ -3,14 +3,12 @@
 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,
@@ -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.
@@ -90,21 +70,6 @@ def test_build_spatial_bins():
     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 +84,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 +108,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_et_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 +150,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,18 @@ 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