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

imap_processing/tests/idex/test_idex_l0.py

@@ -7,7 +7,7 @@ from imap_processing import imap_module_directory
 
 
 def test_idex_decom_length(decom_test_data: xr.Dataset):
-    """Verify that there are 6 data variables in the output.
+    """Verify that the output data has the expected number of data variables.
 
     Parameters
     ----------
@@ -18,7 +18,7 @@ def test_idex_decom_length(decom_test_data: xr.Dataset):
 
 
 def test_idex_decom_event_num(decom_test_data: xr.Dataset):
-    """Verify that 19 impacts were gathered by the test data.
+    """Verify that 14 impacts were gathered by the test data.
 
     Parameters
     ----------
@@ -26,7 +26,7 @@ def test_idex_decom_event_num(decom_test_data: xr.Dataset):
         The dataset to test with
     """
     for var in decom_test_data:
-        assert len(decom_test_data[var]) == 19
+        assert len(decom_test_data[var]) == 14
 
 
 def test_idex_tof_high_data(decom_test_data: xr.Dataset):

imap_processing/tests/idex/test_idex_l1a.py

@@ -21,7 +21,7 @@ def test_idex_cdf_file(decom_test_data: xr.Dataset):
     file_name = write_cdf(decom_test_data)
 
     assert file_name.exists()
-    assert file_name.name == "imap_idex_l1_sci_20230725_v001.cdf"
+    assert file_name.name == "imap_idex_l1a_sci_20231214_v001.cdf"
 
 
 def test_bad_cdf_attributes(decom_test_data: xr.Dataset):

imap_processing/tests/lo/test_lo_science.py

@@ -195,9 +195,9 @@ def test_combine_segmented_packets(segmented_pkts_fake_data):
         dataset["events"].values,
         np.array(
             [
-                "0000000001,0000000010,0000000100,0000001000",
+                "0000000001000000001000000001000000001000",
                 "0000010000",
-                "0100000000,1000000000",
+                "01000000001000000000",
             ]
         ),
     )

imap_processing/tests/mag/test_mag_l1b.py

@@ -12,18 +12,38 @@ from imap_processing.mag.l1b.mag_l1b import mag_l1b, mag_l1b_processing
 def mag_l1a_dataset():
     epoch = xr.DataArray(np.arange(20), name="epoch", dims=["epoch"])
     direction = xr.DataArray(np.arange(4), name="direction", dims=["direction"])
+    compression = xr.DataArray(np.arange(2), name="compression", dims=["compression"])
+
+    direction_label = xr.DataArray(
+        direction.values.astype(str),
+        name="direction_label",
+        dims=["direction_label"],
+    )
+
+    compression_label = xr.DataArray(
+        compression.values.astype(str),
+        name="compression_label",
+        dims=["compression_label"],
+    )
+
     vectors = xr.DataArray(
         np.zeros((20, 4)),
         dims=["epoch", "direction"],
         coords={"epoch": epoch, "direction": direction},
     )
+    compression_flags = xr.DataArray(
+        np.zeros((20, 2), dtype=np.int8), dims=["epoch", "compression"]
+    )
 
     vectors[0, :] = np.array([1, 1, 1, 0])
 
     output_dataset = xr.Dataset(
-        coords={"epoch": epoch, "direction": direction},
+        coords={"epoch": epoch, "direction": direction, "compression": compression},
     )
     output_dataset["vectors"] = vectors
+    output_dataset["compression_flags"] = compression_flags
+    output_dataset["direction_label"] = direction_label
+    output_dataset["compression_label"] = compression_label
 
     return output_dataset
 
@@ -66,13 +86,49 @@ def test_mag_attributes(mag_l1a_dataset):
     assert output.attrs["Data_level"] == "L1B"
 
 
-@pytest.mark.skip(reason="Epoch variable data need to be monotonically increasing")
 def test_cdf_output():
     l1a_cdf = load_cdf(
-        Path(__file__).parent / "imap_mag_l1a_burst-magi_20231025_v001.cdf"
+        Path(__file__).parent / "imap_mag_l1a_norm-magi_20251017_v001.cdf"
     )
     l1b_dataset = mag_l1b(l1a_cdf, "v001")
 
     output_path = write_cdf(l1b_dataset)
 
     assert Path.exists(output_path)
+
+
+def test_mag_compression_scale(mag_l1a_dataset):
+    test_calibration = np.array(
+        [
+            [2.2972202, 0.0, 0.0],
+            [0.00348625, 2.23802879, 0.0],
+            [-0.00250788, -0.00888437, 2.24950008],
+        ]
+    )
+    mag_l1a_dataset["vectors"][0, :] = np.array([1, 1, 1, 0])
+    mag_l1a_dataset["vectors"][1, :] = np.array([1, 1, 1, 0])
+    mag_l1a_dataset["vectors"][2, :] = np.array([1, 1, 1, 0])
+    mag_l1a_dataset["vectors"][3, :] = np.array([1, 1, 1, 0])
+
+    mag_l1a_dataset["compression_flags"][0, :] = np.array([1, 16], dtype=np.int8)
+    mag_l1a_dataset["compression_flags"][1, :] = np.array([0, 0], dtype=np.int8)
+    mag_l1a_dataset["compression_flags"][2, :] = np.array([1, 18], dtype=np.int8)
+    mag_l1a_dataset["compression_flags"][3, :] = np.array([1, 14], dtype=np.int8)
+
+    mag_l1a_dataset.attrs["Logical_source"] = ["imap_mag_l1a_norm-mago"]
+    output = mag_l1b(mag_l1a_dataset, "v001")
+
+    calibrated_vectors = np.matmul(np.array([1, 1, 1]), test_calibration)
+    # 16 bit width is the standard
+    assert np.allclose(output["vectors"].data[0][:3], calibrated_vectors)
+    # uncompressed data is uncorrected
+    assert np.allclose(output["vectors"].data[1][:3], calibrated_vectors)
+
+    # width of 18 should be multiplied by 1/4
+    scaled_vectors = calibrated_vectors * 1 / 4
+    # should be corrected
+    assert np.allclose(output["vectors"].data[2][:3], scaled_vectors)
+
+    # width of 14 should be multiplied by 4
+    scaled_vectors = calibrated_vectors * 4
+    assert np.allclose(output["vectors"].data[3][:3], scaled_vectors)

imap_processing/tests/spice/test_data/imap_ena_sim_metakernel.template

@@ -3,4 +3,6 @@
 {SPICE_TEST_DATA_PATH}/imap_spk_demo.bsp
 {SPICE_TEST_DATA_PATH}/sim_1yr_imap_attitude.bc
 {SPICE_TEST_DATA_PATH}/imap_wkcp.tf
-{SPICE_TEST_DATA_PATH}/de440s.bsp
+{SPICE_TEST_DATA_PATH}/de440s.bsp
+{SPICE_TEST_DATA_PATH}/imap_science_0001.tf
+{SPICE_TEST_DATA_PATH}/sim_1yr_imap_pointing_frame.bc

imap_processing/tests/spice/test_geometry.py

@@ -8,6 +8,8 @@ import spiceypy as spice
 from imap_processing.spice.geometry import (
     SpiceBody,
     SpiceFrame,
+    basis_vectors,
+    cartesian_to_spherical,
     frame_transform,
     get_instrument_spin_phase,
     get_rotation_matrix,
@@ -16,7 +18,9 @@ from imap_processing.spice.geometry import (
     get_spin_data,
     imap_state,
     instrument_pointing,
+    spherical_to_cartesian,
 )
+from imap_processing.spice.kernels import ensure_spice
 
 
 @pytest.mark.parametrize(
@@ -99,10 +103,10 @@ def test_get_spacecraft_spin_phase_value_error(query_met_times, fake_spin_data):
         _ = get_spacecraft_spin_phase(query_met_times)
 
 
-@pytest.mark.usefixtures("_set_spin_data_filepath")
-def test_get_spin_data():
+@pytest.mark.usefixtures("use_fake_spin_data_for_time")
+def test_get_spin_data(use_fake_spin_data_for_time):
     """Test get_spin_data() with generated spin data."""
-
+    use_fake_spin_data_for_time(453051323.0 - 56120)
     spin_data = get_spin_data()
 
     (
@@ -250,7 +254,7 @@ def test_frame_transform_exceptions():
         match="Mismatch in number of position vectors and Ephemeris times provided.",
     ):
         frame_transform(
-            np.arange(2),
+            1,
             np.arange(9).reshape((3, 3)),
             SpiceFrame.ECLIPJ2000,
             SpiceFrame.IMAP_HIT,
@@ -306,3 +310,79 @@ def test_instrument_pointing(furnish_kernels):
             et, SpiceFrame.IMAP_HI_90, SpiceFrame.ECLIPJ2000, cartesian=True
         )
         assert ins_pointing.shape == (3, 3)
+
+
+@pytest.mark.external_kernel()
+@pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
+def test_basis_vectors():
+    """Test coverage for basis_vectors()."""
+    # This call to SPICE needs to be wrapped with `ensure_spice` so that kernels
+    # get furnished automatically
+    et = ensure_spice(spice.utc2et)("2025-09-30T12:00:00.000")
+    # test input of float
+    sc_axes = basis_vectors(et, SpiceFrame.IMAP_SPACECRAFT, SpiceFrame.IMAP_SPACECRAFT)
+    np.testing.assert_array_equal(sc_axes, np.eye(3))
+    # test array of et input
+    et_array = np.arange(10) + et
+    sc_axes = basis_vectors(et_array, SpiceFrame.IMAP_SPACECRAFT, SpiceFrame.ECLIPJ2000)
+    assert sc_axes.shape == (10, 3, 3)
+    # Verify that for each time, the basis vectors are correct
+    for et, basis_matrix in zip(et_array, sc_axes):
+        np.testing.assert_array_equal(
+            basis_matrix,
+            frame_transform(
+                et * np.ones(3),
+                np.eye(3),
+                SpiceFrame.IMAP_SPACECRAFT,
+                SpiceFrame.ECLIPJ2000,
+            ),
+        )
+
+
+def test_cartesian_to_spherical():
+    """Tests cartesian_to_spherical function."""
+
+    step = 0.05
+    x = np.arange(-1, 1 + step, step)
+    y = np.arange(-1, 1 + step, step)
+    z = np.arange(-1, 1 + step, step)
+    x, y, z = np.meshgrid(x, y, z)
+
+    cartesian_points = np.stack((x.ravel(), y.ravel(), z.ravel()), axis=-1)
+
+    for point in cartesian_points:
+        r, az, el = cartesian_to_spherical(point)
+        r_spice, colat_spice, slong_spice = spice.recsph(point)
+
+        # Convert SPICE co-latitude to elevation
+        el_spice = 90 - np.degrees(colat_spice)
+        az_spice = np.degrees(slong_spice)
+
+        # Normalize azimuth to [0, 360]
+        az_spice = az_spice % 360
+
+        np.testing.assert_allclose(r, r_spice, atol=1e-5)
+        np.testing.assert_allclose(az, az_spice, atol=1e-5)
+        np.testing.assert_allclose(el, el_spice, atol=1e-5)
+
+
+def test_spherical_to_cartesian():
+    """Tests spherical_to_cartesian function."""
+
+    azimuth = np.linspace(0, 2 * np.pi, 50)
+    elevation = np.linspace(-np.pi / 2, np.pi / 2, 50)
+    theta, elev = np.meshgrid(azimuth, elevation)
+    r = 1.0
+
+    spherical_points = np.stack(
+        (r * np.ones_like(theta).ravel(), theta.ravel(), elev.ravel()), axis=-1
+    )
+
+    # Convert elevation to colatitude for SPICE
+    colat = np.pi / 2 - spherical_points[:, 2]
+
+    for i in range(len(colat)):
+        cartesian_coords = spherical_to_cartesian(np.array([spherical_points[i]]))
+        spice_coords = spice.sphrec(r, colat[i], spherical_points[i, 1])
+
+        np.testing.assert_allclose(cartesian_coords[0], spice_coords, atol=1e-5)

imap_processing/tests/swe/conftest.py

@@ -74,3 +74,36 @@ def l1a_validation_df():
     # Fill NaNs with the previous value
     df["shcoarse"] = df["shcoarse"].ffill()
     return df
+
+
+@pytest.fixture(scope="session")
+def l1b_validation_df():
+    """Read validation data from file"""
+    l1_val_path = imap_module_directory / "tests/swe/l1_validation"
+    filename = "swe_l0_unpacked-data_20240510_v001_VALIDATION_L1B_v3.dat"
+
+    # Define column names for validation data
+    column_names = [
+        "shcoarse",
+        "cem_1",
+        "cem_2",
+        "cem_3",
+        "cem_4",
+        "cem_5",
+        "cem_6",
+        "cem_7",
+    ]
+
+    # Read the data, specifying na_values and delimiter
+    df = pd.read_csv(
+        l1_val_path / filename,
+        skiprows=12,  # Skip the first 10 rows of comments
+        sep=r"\s*,\s*",  # Regex to handle spaces and commas as delimiters
+        names=column_names,
+        na_values=["", " "],  # Treat empty strings or spaces as NaN
+        engine="python",
+    )
+
+    # Fill NaNs with the previous value
+    df["shcoarse"] = df["shcoarse"].ffill()
+    return df