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

imap_processing/tests/ultra/unit/test_ultra_l1b_extended.py

@@ -4,8 +4,10 @@ import numpy as np
 import pandas as pd
 import pytest
 
+from imap_processing import imap_module_directory
 from imap_processing.spice.spin import get_spin_data
 from imap_processing.ultra.constants import UltraConstants
+from imap_processing.ultra.l1b.lookup_utils import get_angular_profiles
 from imap_processing.ultra.l1b.ultra_l1b_extended import (
     CoinType,
     StartType,
@@ -16,32 +18,35 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
     get_ctof,
     get_de_energy_kev,
     get_de_velocity,
+    get_efficiency,
     get_energy_pulse_height,
     get_energy_ssd,
     get_eventtimes,
     get_front_x_position,
     get_front_y_position,
+    get_fwhm,
     get_path_length,
     get_ph_tof_and_back_positions,
     get_phi_theta,
     get_ssd_back_position_and_tof_offset,
     get_ssd_tof,
+    interpolate_fwhm,
 )
 
+TEST_PATH = imap_module_directory / "tests" / "ultra" / "data" / "l1"
 
-@pytest.fixture()
+
+@pytest.fixture
 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
-    )
+    de_dataset = de_dataset.where(de_dataset["start_type"] != 255, drop=True)
 
     df = pd.read_csv(events_fsw_comparison_theta_0)
     df_filt = df[df["StartType"] != -1]
 
     d, yf = get_front_y_position(
-        de_dataset["START_TYPE"].data, df_filt.Yb.values.astype("float")
+        de_dataset["start_type"].data, df_filt.Yb.values.astype("float")
     )
 
     return df_filt, d, yf, de_dataset
@@ -55,8 +60,9 @@ def test_get_front_x_position(
     df_filt, _, _, de_dataset = test_fixture
 
     xf = get_front_x_position(
-        de_dataset["START_TYPE"].data,
-        de_dataset["START_POS_TDC"].data,
+        de_dataset["start_type"].data,
+        de_dataset["start_pos_tdc"].data,
+        "ultra45",
     )
 
     assert xf == pytest.approx(df_filt["Xf"].astype("float"), 1e-5)
@@ -96,7 +102,7 @@ def test_get_ph_tof_and_back_positions(
     )
 
     ph_indices = np.nonzero(
-        np.isin(de_dataset["STOP_TYPE"], [StopType.Top.value, StopType.Bottom.value])
+        np.isin(de_dataset["stop_type"], [StopType.Top.value, StopType.Bottom.value])
     )[0]
 
     selected_rows = df_filt.iloc[ph_indices]
@@ -114,7 +120,9 @@ def test_get_ssd_back_position_and_tof_offset(
 ):
     """Tests get_ssd_back_position function."""
     _, _, _, de_dataset = test_fixture
-    yb, tof_offset, ssd_number = get_ssd_back_position_and_tof_offset(de_dataset)
+    yb, tof_offset, ssd_number = get_ssd_back_position_and_tof_offset(
+        de_dataset, "ultra45"
+    )
 
     df = pd.read_csv(events_fsw_comparison_theta_0)
     df_filt = df[(df["StartType"] != -1) & (df["StopType"] >= 8)]
@@ -159,7 +167,7 @@ def test_get_coincidence_positions(test_fixture):
 
     # Filter for stop type.
     indices = np.nonzero(
-        np.isin(de_dataset["STOP_TYPE"], [StopType.Top.value, StopType.Bottom.value])
+        np.isin(de_dataset["stop_type"], [StopType.Top.value, StopType.Bottom.value])
     )[0]
     de_filtered = de_dataset.isel(epoch=indices)
     rows = df_filt.iloc[indices]
@@ -182,17 +190,17 @@ def test_calculate_etof_xc(test_fixture):
     )
     # Filter based on STOP_TYPE.
     indices = np.nonzero(
-        np.isin(de_dataset["STOP_TYPE"], [StopType.Top.value, StopType.Bottom.value])
+        np.isin(de_dataset["stop_type"], [StopType.Top.value, StopType.Bottom.value])
     )[0]
     de_filtered = de_dataset.isel(epoch=indices)
     df_filtered = df_filt.iloc[indices]
 
     # Filter for COIN_TYPE Top and Bottom.
-    index_top = np.nonzero(np.isin(de_filtered["COIN_TYPE"], CoinType.Top.value))[0]
+    index_top = np.nonzero(np.isin(de_filtered["coin_type"], CoinType.Top.value))[0]
     de_top = de_filtered.isel(epoch=index_top)
     df_top = df_filtered.iloc[index_top]
 
-    index_bottom = np.nonzero(np.isin(de_filtered["COIN_TYPE"], CoinType.Bottom.value))[
+    index_bottom = np.nonzero(np.isin(de_filtered["coin_type"], CoinType.Bottom.value))[
         0
     ]
     de_bottom = de_filtered.isel(epoch=index_bottom)
@@ -231,7 +239,7 @@ def test_get_de_velocity(test_fixture):
         for col in ["Xf", "Yf", "Xb", "Yb", "d", "TOF"]
     )
 
-    v = get_de_velocity(
+    v, vhat, r = get_de_velocity(
         (test_xf, test_yf),
         (test_xb, test_yb),
         test_d,
@@ -258,6 +266,42 @@ def test_get_de_velocity(test_fixture):
         atol=1e-01,
         rtol=0,
     )
+    np.testing.assert_allclose(
+        vhat[test_tof > 0][:, 0],
+        df_ph["vhatX"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
+    )
+    np.testing.assert_allclose(
+        vhat[test_tof > 0][:, 1],
+        df_ph["vhatY"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
+    )
+    np.testing.assert_allclose(
+        vhat[test_tof > 0][:, 2],
+        df_ph["vhatZ"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
+    )
+    np.testing.assert_allclose(
+        r[test_tof > 0][:, 0],
+        -df_ph["vhatX"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
+    )
+    np.testing.assert_allclose(
+        r[test_tof > 0][:, 1],
+        -df_ph["vhatY"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
+    )
+    np.testing.assert_allclose(
+        r[test_tof > 0][:, 2],
+        -df_ph["vhatZ"].astype("float").values[test_tof > 0],
+        atol=1e-01,
+        rtol=0,
+    )
 
 
 def test_get_ssd_tof(test_fixture):
@@ -266,7 +310,7 @@ def test_get_ssd_tof(test_fixture):
     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)
+    ssd_tof = get_ssd_tof(de_dataset, test_xf, "ultra45")
 
     np.testing.assert_allclose(
         ssd_tof, df_ssd["TOF"].astype("float"), atol=1e-05, rtol=0
@@ -289,7 +333,7 @@ def test_get_de_energy_kev(test_fixture):
         for col in ["Xf", "Yf", "Xb", "Yb", "d", "TOF"]
     )
 
-    v = get_de_velocity(
+    v, v_hat, r_hat = get_de_velocity(
         (test_xf, test_yf),
         (test_xb, test_yb),
         test_d,
@@ -297,7 +341,7 @@ def test_get_de_energy_kev(test_fixture):
     )
 
     energy = get_de_energy_kev(v, species_bin_ph)
-    index_hydrogen = np.where(species_bin_ph == "H")
+    index_hydrogen = np.where(species_bin_ph == 1)
     actual_energy = energy[index_hydrogen[0]]
     expected_energy = df_ph["energy_revised"].astype("float")
 
@@ -308,7 +352,7 @@ def test_get_energy_ssd(test_fixture):
     """Tests get_energy_ssd function."""
     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)
+    _, _, ssd_number = get_ssd_back_position_and_tof_offset(de_dataset, "ultra45")
     energy = get_energy_ssd(de_dataset, ssd_number)
     test_energy = df_ssd["Energy"].astype("float")
 
@@ -320,14 +364,18 @@ def test_get_energy_pulse_height(test_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])
+        np.isin(de_dataset["stop_type"], [StopType.Top.value, StopType.Bottom.value])
     )[0]
 
     test_xb = df_filt["Xb"].astype("float").values
     test_yb = df_filt["Yb"].astype("float").values
 
     energy = get_energy_pulse_height(
-        de_dataset["STOP_TYPE"].data, de_dataset["ENERGY_PH"].data, test_xb, test_yb
+        de_dataset["stop_type"].data,
+        de_dataset["energy_ph"].data,
+        test_xb,
+        test_yb,
+        "ultra45",
     )
     test_energy = df_ph["Energy"].astype("float")
 
@@ -386,13 +434,13 @@ def test_determine_species(test_fixture):
         "SSD",
     )
 
-    h_indices_ph = np.where(species_bin_ph == "H")[0]
+    h_indices_ph = np.where(species_bin_ph == 1)[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]
+    h_indices_ssd = np.where(species_bin_ssd == 1)[0]
     ctof_indices_ssd = np.where(
         (df_ssd["cTOF"].astype("float") > UltraConstants.CTOF_SPECIES_MIN)
         & (df_ssd["cTOF"].astype("float") < UltraConstants.CTOF_SPECIES_MAX)
@@ -427,31 +475,117 @@ def test_get_eventtimes(test_fixture, use_fake_spin_data_for_time):
     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
+        de_dataset["spin"].values, de_dataset["phase_angle"].values
     )
 
     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()]
+    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
+        expected_min_df["spin_start_sec_sclk"]
+        + expected_min_df["spin_start_subsec_sclk"] / 1e6
     )
     spin_start_max = (
-        expected_max_df["spin_start_sec"] + expected_max_df["spin_start_subsec"] / 1000
+        expected_max_df["spin_start_sec_sclk"]
+        + expected_max_df["spin_start_subsec_sclk"] / 1e6
     )
 
     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
+        de_dataset["phase_angle"][0] / 720
     )
     event_times_max = spin_start_max.values[0] + spin_period_sec_max * (
-        de_dataset["PHASE_ANGLE"][-1] / 720
+        de_dataset["phase_angle"][-1] / 720
     )
 
     assert event_times_min == event_times.min()
     assert event_times_max == event_times.max()
+
+
+def test_interpolate_fwhm():
+    """Tests interpolate_fwhm function."""
+
+    # Test interpolation of FWHM values
+    test_phi = np.linspace(1, 53, 40)
+    test_theta = np.linspace(-44, 43, 40)
+    test_energy = np.full(test_theta.shape, 10)
+    lt_table = get_angular_profiles("left", "ultra45")
+
+    phi_interp, theta_interp = interpolate_fwhm(
+        lt_table, test_energy, test_phi, test_theta
+    )
+
+    lt_table_e10 = lt_table[lt_table.Energy == 10]
+    lt_table_test = lt_table_e10.sort_values("phi_degrees")
+    phi_fwhm_expected = np.interp(
+        test_phi, lt_table_test.phi_degrees, lt_table_test.phi_fwhm
+    )
+
+    np.testing.assert_allclose(phi_fwhm_expected, phi_interp, atol=1e-03, rtol=0)
+
+    # Test empty input
+    phi_interp, theta_interp = interpolate_fwhm(
+        lt_table, np.array([]), np.array([]), np.array([])
+    )
+
+    assert phi_interp.size == 0
+    assert theta_interp.size == 0
+
+
+def test_get_fwhm():
+    """Tests get_fwhm function."""
+
+    test_phi = np.linspace(1, 53, 40)
+    test_theta = np.linspace(-44, 43, 40)
+    test_energy = np.full(test_phi.shape, 10)
+    test_start_type = np.empty(test_theta.shape, dtype=int)
+    test_start_type[:20] = 1  # First half -> Left
+    test_start_type[20:] = 2  # Second half -> Right
+
+    phi_interp, theta_interp = get_fwhm(
+        start_type=test_start_type,
+        sensor="ultra45",
+        energy=test_energy,
+        phi_inst=test_phi,
+        theta_inst=test_theta,
+    )
+
+    idx_left = test_start_type == StartType.Left.value
+    test_phi_left = test_phi[idx_left]
+
+    lt_table = get_angular_profiles("left", "ultra45")
+    lt_table_e10 = lt_table[lt_table.Energy == 10]
+    lt_table_sorted = lt_table_e10.sort_values("phi_degrees")
+
+    phi_expected_left = np.interp(
+        test_phi_left,
+        lt_table_sorted.phi_degrees.values,
+        lt_table_sorted.phi_fwhm.values,
+    )
+
+    np.testing.assert_allclose(
+        phi_interp[idx_left], phi_expected_left, atol=1e-3, rtol=0
+    )
+
+    assert phi_interp.shape == test_phi.shape
+    assert theta_interp.shape == test_theta.shape
+
+
+@pytest.mark.external_test_data
+def test_get_efficiency():
+    """Tests get_efficiency function."""
+
+    # spot check
+    theta = np.array([-52.7, 52.7, -52.7, -52.7])
+    phi = np.array([-60, 60, -60, -50])
+    energy = np.array([3, 80, 39.75, 7])
+
+    efficiency = get_efficiency(energy, phi, theta)
+    expected_efficiency = np.array([0.0593281, 0.21803386, 0.0593281, 0.0628940])
+
+    np.testing.assert_allclose(efficiency, expected_efficiency, atol=1e-03, rtol=0)

imap_processing/tests/ultra/unit/test_ultra_l1c.py

@@ -6,7 +6,7 @@ from imap_processing.ultra.l1c.ultra_l1c import ultra_l1c
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 
-@pytest.fixture()
+@pytest.fixture
 def mock_data_l1b_dict():
     # Create sample data for the xarray Dataset
     epoch = np.arange(
@@ -55,7 +55,7 @@ def mock_data_l1b_dict():
     return data_dict
 
 
-@pytest.fixture()
+@pytest.fixture
 def mock_data_l1c_dict():
     epoch = np.array(
         [760591786368000000, 760591787368000000, 760591788368000000],
@@ -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", "001"
+        mock_data_l1c_dict, "imap_ultra_l1c_45sensor-histogram", "l1c"
     )
 
     assert "epoch" in dataset.coords
@@ -80,7 +80,7 @@ def test_create_dataset(mock_data_l1c_dict):
 
 def test_ultra_l1c(mock_data_l1b_dict):
     """Tests that L1c data is created."""
-    output_datasets = ultra_l1c(mock_data_l1b_dict, data_version="001")
+    output_datasets = ultra_l1c(mock_data_l1b_dict)
 
     assert len(output_datasets) == 1
     assert (
@@ -101,4 +101,4 @@ def test_ultra_l1c_error(mock_data_l1b_dict):
     with pytest.raises(
         ValueError, match="Data dictionary does not contain the expected keys."
     ):
-        ultra_l1c(mock_data_l1b_dict, data_version="001")
+        ultra_l1c(mock_data_l1b_dict)

imap_processing/tests/ultra/unit/test_ultra_l1c_pset_bins.py

@@ -1,14 +1,11 @@
 "Tests pointing sets"
 
 import astropy_healpix.healpy as hp
-import cdflib
 import numpy as np
 import pandas as pd
 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_background_rates,
@@ -16,13 +13,14 @@ from imap_processing.ultra.l1c.ultra_l1c_pset_bins import (
     get_spacecraft_exposure_times,
     get_spacecraft_histogram,
     get_spacecraft_sensitivity,
+    grid_sensitivity,
 )
 
 BASE_PATH = imap_module_directory / "ultra" / "lookup_tables"
 TEST_PATH = imap_module_directory / "tests" / "ultra" / "data" / "l1"
 
 
-@pytest.fixture()
+@pytest.fixture
 def test_data():
     """Test data fixture."""
     vx_sc = np.array([-186.5575, 508.5697, 508.5697, 508.5697])
@@ -98,7 +96,7 @@ def test_get_background_rates():
     assert background_rates.shape == hp.nside2npix(128)
 
 
-@pytest.mark.external_test_data()
+@pytest.mark.external_test_data
 def test_get_spacecraft_exposure_times():
     """Test get_spacecraft_exposure_times function."""
     constant_exposure = TEST_PATH / "ultra_90_dps_exposure.csv"
@@ -113,67 +111,49 @@ def test_get_spacecraft_exposure_times():
     )
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
 def test_get_helio_exposure_times():
     """Tests get_helio_exposure_times function."""
 
-    constant_exposure = BASE_PATH / "dps_grid45_compressed.cdf"
     start_time = 829485054.185627
     end_time = 829567884.185627
-    mid_time = np.average([start_time, end_time])
-
-    with cdflib.CDF(constant_exposure) as cdf_file:
-        sc_exposure = cdf_file.varget("dps_grid45")
 
-    exposure_3d = get_helio_exposure_times(mid_time, sc_exposure)
-
-    energy_bin_edges, energy_midpoints, _ = build_energy_bins()
-    az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints = (
-        build_spatial_bins()
-    )
+    mid_time = np.average([start_time, end_time])
 
-    assert exposure_3d.shape == (
-        len(el_bin_midpoints),
-        len(az_bin_midpoints),
-        len(energy_midpoints),
-    )
+    constant_exposure = TEST_PATH / "ultra_90_dps_exposure.csv"
+    df_exposure = pd.read_csv(constant_exposure)
 
-    cdf_files = [
-        ("dps_exposure_helio_45_E1.cdf", "dps_exposure_helio_45_E1"),
-        ("dps_exposure_helio_45_E12.cdf", "dps_exposure_helio_45_E12"),
-        ("dps_exposure_helio_45_E24.cdf", "dps_exposure_helio_45_E24"),
-    ]
+    helio_exposure = get_helio_exposure_times(mid_time, df_exposure)
 
-    cdf_directory = imap_module_directory / "tests" / "ultra" / "data" / "l1"
+    _, energy_midpoints, _ = build_energy_bins()
 
-    exposures = []
+    nside = 128
+    npix = hp.nside2npix(nside)
+    assert helio_exposure.shape == (npix, len(energy_midpoints))
 
-    for file_name, var_name in cdf_files:
-        file_path = cdf_directory / file_name
-        with CDF(file_path) as cdf_file:
-            exposure_data = cdf_file.varget(var_name)
-            transposed_exposure = np.transpose(exposure_data, (2, 1, 0))
-            exposures.append(transposed_exposure)
+    total_input = np.sum(df_exposure["Exposure Time"].values)
+    total_output = np.sum(helio_exposure[:, 23])
 
-    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])
+    assert np.allclose(total_input, total_output, atol=1e-6)
 
 
-@pytest.mark.external_test_data()
+@pytest.mark.external_test_data
 def test_get_spacecraft_sensitivity():
     """Tests get_spacecraft_sensitivity function."""
     # TODO: remove below here with lookup table aux api
-    efficiences = TEST_PATH / "Ultra_90_DPS_efficiencies_all.csv"
+    efficiencies = TEST_PATH / "Ultra_90_DPS_efficiencies_all.csv"
     geometric_function = TEST_PATH / "ultra_90_dps_gf.csv"
 
-    df_efficiencies = pd.read_csv(efficiences)
+    df_efficiencies = pd.read_csv(efficiencies)
     df_geometric_function = pd.read_csv(geometric_function)
 
-    sensitivity = get_spacecraft_sensitivity(df_efficiencies, df_geometric_function)
+    sensitivity, energy_vals, right_ascension, declination = get_spacecraft_sensitivity(
+        df_efficiencies, df_geometric_function
+    )
 
-    assert sensitivity.shape == df_efficiencies.shape
+    assert sensitivity.shape == (df_efficiencies.shape[0], df_efficiencies.shape[1] - 2)
+    assert np.array_equal(energy_vals, np.arange(3.0, 80.5, 0.5))
 
     df_efficiencies_test = pd.DataFrame(
         {"3.0keV": [1.0, 2.0], "3.5keV": [3.0, 4.0], "4.0keV": [5.0, 6.0]}
@@ -192,3 +172,12 @@ def test_get_spacecraft_sensitivity():
     assert np.allclose(
         df_sensitivity_test.to_numpy(), expected_sensitivity.to_numpy(), atol=1e-6
     )
+
+    expected_result = sensitivity["3.0keV"].values
+    result = grid_sensitivity(df_efficiencies, df_geometric_function, 3.0)
+
+    assert np.allclose(result, expected_result, atol=1e-5)
+
+    # Check that out-of-bounds energy returns all NaNs
+    result = grid_sensitivity(df_efficiencies, df_geometric_function, 2.5)
+    assert np.isnan(result).all()