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

imap_processing/tests/ultra/data/mock_data.py

@@ -0,0 +1,341 @@
+"""Mock expected data for use in some tests."""
+
+import astropy_healpix.healpy as hp
+import numpy as np
+import spiceypy as spice
+import xarray as xr
+
+from imap_processing.ena_maps.utils.coordinates import CoordNames
+from imap_processing.spice.kernels import ensure_spice
+from imap_processing.spice.time import str_to_et
+from imap_processing.ultra.l1c.ultra_l1c_pset_bins import build_energy_bins
+
+DEFAULT_RECT_SPACING_DEG_L1C = 0.5
+DEFAULT_HEALPIX_NSIDE_L1C = 128
+
+
+def mock_l1c_pset_product_rectangular(  # noqa: PLR0913
+    spacing_deg: float = DEFAULT_RECT_SPACING_DEG_L1C,
+    stripe_center_lat: int = 0,
+    width_scale: float = 10.0,
+    counts_scaling_params: tuple[int, float] = (100, 0.01),
+    peak_exposure: float = 1000.0,
+    timestr: str = "2025-01-01T00:00:00",
+    head: str = "45",
+) -> xr.Dataset:
+    """
+    Mock the L1C PSET product with recognizable but unrealistic counts.
+
+    This is not meant to perfectly mimic the real data, but to provide a
+    recognizable structure for L2 testing purposes.
+    Function will produce an xarray.Dataset with at least the variables and shapes:
+    counts: (1 epoch, num_energy_bins, num_lon_bins, num_lat_bins)
+    exposure_time: (num_lon_bins, num_lat_bins)
+    sensitivity: (1 epoch, num_energy_bins, num_lon_bins, num_lat_bins)
+
+    and the coordinate variables:
+    the epoch (assumed to be a single time for each product).
+    energy: (determined by build_energy_bins function)
+    longitude: (num_lon_bins)
+    latitude: (num_lat_bins)
+
+    While not a coordinate, PSETs can also be distinguished by the 'head' attribute.
+    head: Either '45' or '90'. Default is '45'.
+
+    The counts are generated along a stripe, centered at a given latitude.
+    This stripe can be thought of as a 'horizontal' line if the lon/az axis is plotted
+    as the x-axis and the lat/el axis is plotted as the y-axis. See the figure below.
+
+    ^  Elevation/Latitude
+    |
+    |    000000000000000000000000000000000000000000000000000     |
+    |    000000000000000000000000000000000000000000000000000     |
+    |    000000000000000000000000000000000000000000000000000     |
+    |    000000000000000000000000000000000000000000000000000     |
+    |    000000000000000000000000000000000000000000000000000      \
+    |    222222222222222222222222222222222222222222222222222       \
+    |    444444444444444444444444444444444444444444444444444        \
+    |    666666666666666666666666666666666666666666666666666         |
+    |    444444444444444444444444444444444444444444444444444        /
+    |    222222222222222222222222222222222222222222222222222       /
+    |    000000000000000000000000000000000000000000000000000      /
+    |    000000000000000000000000000000000000000000000000000     |
+    --------------------------------------------------------->
+    Azimuth/Longitude ->
+
+    Fig. 1: Example of the '90' sensor head stripe
+
+    Parameters
+    ----------
+    spacing_deg : float, optional
+        The bin spacing in degrees (default is 0.5 degrees).
+    stripe_center_lat : int, optional
+        The center latitude of the stripe in degrees (default is 0).
+    width_scale : float, optional
+        The width of the stripe in degrees (default is 20 degrees).
+    counts_scaling_params : tuple[int, float], optional
+        The parameters for the binomial distribution of counts (default is (100, 0.01)).
+        The 0th element is the number of trials to draw,
+        the 1st element scales the probability of success for each trial.
+    peak_exposure : float, optional
+        The peak exposure time (default is 1000.0).
+    timestr : str, optional
+        The time string for the epoch (default is "2025-01-01T00:00:00").
+    head : str, optional
+        The sensor head (either '45' or '90') (default is '45').
+    """
+    num_lat_bins = int(180 / spacing_deg)
+    num_lon_bins = int(360 / spacing_deg)
+    stripe_center_lat_bin = int((stripe_center_lat + 90) / spacing_deg)
+
+    _, energy_bin_midpoints, _ = build_energy_bins()
+    num_energy_bins = len(energy_bin_midpoints)
+
+    # 1 epoch x num_energy_bins x num_lon_bins x num_lat_bins
+    grid_shape = (1, num_energy_bins, num_lon_bins, num_lat_bins)
+
+    def get_binomial_counts(distance_scaling, lat_bin, central_lat_bin):
+        # Note, this is not quite correct, as it won't wrap around at 360 degrees
+        # but it's all meant to provide a recognizable pattern for testing
+        distance_lat_bin = np.abs(lat_bin - central_lat_bin)
+
+        rng = np.random.default_rng(seed=42)
+        return rng.binomial(
+            n=counts_scaling_params[0],
+            p=np.maximum(
+                1 - (distance_lat_bin / distance_scaling), counts_scaling_params[1]
+            ),
+        )
+
+    counts = np.fromfunction(
+        lambda epoch, energy_bin, lon_bin, lat_bin: get_binomial_counts(
+            distance_scaling=width_scale,
+            lat_bin=lat_bin,
+            central_lat_bin=stripe_center_lat_bin,
+        ),
+        shape=grid_shape,
+    )
+
+    # exposure_time should be a gaussian distribution centered on the stripe
+    # with a width of 20 degrees
+    exposure_time = np.zeros(grid_shape[2:])
+    exposure_time = np.fromfunction(
+        lambda lon_bin, lat_bin: np.exp(
+            -((lat_bin - stripe_center_lat_bin) ** 2) / (2 * width_scale**2)
+        ),
+        shape=grid_shape[2:],
+    )
+    exposure_time /= exposure_time.max()
+    exposure_time *= peak_exposure
+    counts = counts.astype(int)
+    sensitivity = np.ones(grid_shape)
+
+    # Determine the epoch, which is TT time in nanoseconds since J2000 epoch
+    tdb_et = str_to_et(timestr)
+    tt_j2000ns = (
+        ensure_spice(spice.unitim, time_kernels_only=True)(tdb_et, "ET", "TT") * 1e9
+    )
+
+    pset_product = xr.Dataset(
+        {
+            "counts": (
+                [
+                    CoordNames.TIME.value,
+                    CoordNames.ENERGY.value,
+                    CoordNames.AZIMUTH_L1C.value,
+                    CoordNames.ELEVATION_L1C.value,
+                ],
+                counts,
+            ),
+            "exposure_time": (
+                [
+                    CoordNames.TIME.value,
+                    CoordNames.AZIMUTH_L1C.value,
+                    CoordNames.ELEVATION_L1C.value,
+                ],
+                np.expand_dims(exposure_time, axis=0),
+            ),
+            "sensitivity": (
+                [
+                    CoordNames.TIME.value,
+                    CoordNames.ENERGY.value,
+                    CoordNames.AZIMUTH_L1C.value,
+                    CoordNames.ELEVATION_L1C.value,
+                ],
+                sensitivity,
+            ),
+        },
+        coords={
+            CoordNames.TIME.value: [
+                tt_j2000ns,
+            ],
+            CoordNames.ENERGY.value: energy_bin_midpoints,
+            CoordNames.AZIMUTH_L1C.value: np.arange(
+                0 + spacing_deg / 2, 360, spacing_deg
+            ),
+            CoordNames.ELEVATION_L1C.value: np.arange(
+                -90 + spacing_deg / 2, 90, spacing_deg
+            ),
+        },
+        attrs={
+            "Logical_file_id": (
+                f"imap_ultra_l1c_{head}sensor-pset_{timestr[:4]}"
+                f"{timestr[5:7]}{timestr[8:10]}-repointNNNNN_vNNN"
+            )
+        },
+    )
+
+    return pset_product
+
+
+def mock_l1c_pset_product_healpix(  # noqa: PLR0913
+    nside: int = DEFAULT_HEALPIX_NSIDE_L1C,
+    stripe_center_lat: int = 0,
+    width_scale: float = 10.0,
+    counts_scaling_params: tuple[int, float] = (100, 0.01),
+    peak_exposure: float = 1000.0,
+    timestr: str = "2025-01-01T00:00:00",
+    head: str = "45",
+) -> xr.Dataset:
+    """
+    Mock the L1C PSET product with recognizable but unrealistic counts.
+
+    See the docstring for mock_l1c_pset_product_rectangular for more details about
+    the structure of the dataset.
+    The rectangular and Healpix mocked datasets are very similar in structure, though
+    the actual values at a given latitude and longitude may be different. This is only
+    meant to provide a recognizable structure for L2 testing purposes.
+
+    The counts are generated along a stripe, centered at a given latitude.
+    This stripe can be thought of as a 'vertical' line if the lon/az axis is plotted
+    as the x-axis and the lat/el axis is plotted as the y-axis. See the figure below.
+
+    ^  Elevation/Latitude
+    |
+    |                   00000000000000000000                     |
+    |               0000000000000000000000000000                 |
+    |           0000000000000000000000000000000000000            |
+    |        0000000000000000000000000000000000000000000         |
+    |      00000000000000000000000000000000000000000000000       |
+    |     0000000000000000000000000000000000000000000000000       \
+    |    222222222222222222222222222222222222222222222222222       \
+    |    444444444444444444444444444444444444444444444444444        \
+    |    666666666666666666666666666666666666666666666666666         |
+    |     4444444444444444444444444444444444444444444444444         /
+    |      22222222222222222222222222222222222222222222222         /
+    |        0000000000000000000000000000000000000000000          /
+    |           0000000000000000000000000000000000000            |
+    |               0000000000000000000000000000                 |
+    |                   00000000000000000000                     |
+    --------------------------------------------------------->
+    Azimuth/Longitude ->
+
+    Fig. 1: Example of the '90' sensor head stripe on a HEALPix grid
+
+    Parameters
+    ----------
+    nside : int, optional
+        The HEALPix nside parameter (default is 128).
+    stripe_center_lat : int, optional
+        The center latitude of the stripe in degrees (default is 0).
+    width_scale : float, optional
+        The width of the stripe in degrees (default is 10 degrees).
+    counts_scaling_params : tuple[int, float], optional
+        The parameters for the binomial distribution of counts (default is (100, 0.01)).
+        The 0th element is the number of trials to draw,
+        the 1st element scales the probability of success for each trial.
+    peak_exposure : float, optional
+        The peak exposure time (default is 1000.0).
+    timestr : str, optional
+        The time string for the epoch (default is "2025-01-01T00:00:00").
+    head : str, optional
+        The sensor head (either '45' or '90') (default is '45').
+    """
+    _, energy_bin_midpoints, _ = build_energy_bins()
+    num_energy_bins = len(energy_bin_midpoints)
+    npix = hp.nside2npix(nside)
+    counts = np.zeros(npix)
+    exposure_time = np.zeros(npix)
+
+    # Get latitude for each healpix pixel
+    pix_indices = np.arange(npix)
+    lon_pix, lat_pix = hp.pix2ang(nside, pix_indices, lonlat=True)
+
+    counts = np.zeros(shape=(num_energy_bins, npix))
+
+    # Calculate probability based on distance from target latitude
+    lat_diff = np.abs(lat_pix - stripe_center_lat)
+    prob_scaling_factor = counts_scaling_params[1] * np.exp(
+        -(lat_diff**2) / (2 * width_scale**2)
+    )
+    # Generate counts using binomial distribution
+    rng = np.random.default_rng(seed=42)
+    counts = np.array(
+        [
+            rng.binomial(n=counts_scaling_params[0], p=prob_scaling_factor)
+            for _ in range(num_energy_bins)
+        ]
+    )
+
+    # Generate exposure times using gaussian distribution
+    exposure_time = peak_exposure * (prob_scaling_factor / prob_scaling_factor.max())
+
+    # Ensure counts are integers
+    counts = counts.astype(int)
+    # add an epoch dimension
+    counts = np.expand_dims(counts, axis=0)
+    sensitivity = np.ones_like(counts)
+
+    # Determine the epoch, which is TT time in nanoseconds since J2000 epoch
+    tdb_et = str_to_et(timestr)
+    tt_j2000ns = (
+        ensure_spice(spice.unitim, time_kernels_only=True)(tdb_et, "ET", "TT") * 1e9
+    )
+
+    pset_product = xr.Dataset(
+        {
+            "counts": (
+                [
+                    CoordNames.TIME.value,
+                    CoordNames.ENERGY.value,
+                    CoordNames.HEALPIX_INDEX.value,
+                ],
+                counts,
+            ),
+            "exposure_time": (
+                [CoordNames.HEALPIX_INDEX.value],
+                exposure_time,
+            ),
+            "sensitivity": (
+                [
+                    CoordNames.TIME.value,
+                    CoordNames.ENERGY.value,
+                    CoordNames.HEALPIX_INDEX.value,
+                ],
+                sensitivity,
+            ),
+            CoordNames.AZIMUTH_L1C.value: (
+                [CoordNames.HEALPIX_INDEX.value],
+                lon_pix,
+            ),
+            CoordNames.ELEVATION_L1C.value: (
+                [CoordNames.HEALPIX_INDEX.value],
+                lat_pix,
+            ),
+        },
+        coords={
+            CoordNames.TIME.value: [
+                tt_j2000ns,
+            ],
+            CoordNames.ENERGY.value: energy_bin_midpoints,
+            CoordNames.HEALPIX_INDEX.value: pix_indices,
+        },
+        attrs={
+            "Logical_file_id": (
+                f"imap_ultra_l1c_{head}sensor-pset_{timestr[:4]}"
+                f"{timestr[5:7]}{timestr[8:10]}-repointNNNNN_vNNN"
+            )
+        },
+    )
+
+    return pset_product

imap_processing/tests/ultra/unit/conftest.py

@@ -4,6 +4,7 @@ from unittest import mock
 
 import numpy as np
 import pytest
+import xarray as xr
 
 from imap_processing import decom, imap_module_directory
 from imap_processing.ultra.l0.decom_ultra import process_ultra_apids
@@ -24,7 +25,7 @@ def ccsds_path():
         imap_module_directory
         / "tests"
         / "ultra"
-        / "test_data"
+        / "data"
         / "l0"
         / "Ultra45_EM_SwRI_Cal_Run7_ThetaScan_20220530T225054.CCSDS"
     )
@@ -37,7 +38,7 @@ def ccsds_path_events():
         imap_module_directory
         / "tests"
         / "ultra"
-        / "test_data"
+        / "data"
         / "l0"
         / "FM45_7P_Phi0.0_BeamCal_LinearScan_phi0.04_theta-0.01_20230821T121304.CCSDS"
     )
@@ -50,7 +51,7 @@ def ccsds_path_theta_0():
         imap_module_directory
         / "tests"
         / "ultra"
-        / "test_data"
+        / "data"
         / "l0"
         / "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50_theta-0.00"
         "_20240207T102740.CCSDS"
@@ -64,7 +65,7 @@ def ccsds_path_tof():
         imap_module_directory
         / "tests"
         / "ultra"
-        / "test_data"
+        / "data"
         / "l0"
         / "FM45_TV_Cycle6_Hot_Ops_Front212_20240124T063837.CCSDS"
     )
@@ -88,7 +89,7 @@ def rates_test_path():
         "ultra45_raw_sc_ultraimgrates_Ultra45_EM_SwRI_Cal_Run7_ThetaScan_"
         "20220530T225054.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
 @pytest.fixture()
@@ -98,7 +99,7 @@ def aux_test_path():
         "ultra45_raw_sc_auxdata_Ultra45_EM_SwRI_Cal_Run7_ThetaScan_"
         "20220530T225054.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
 @pytest.fixture()
@@ -108,7 +109,7 @@ def events_test_path():
         "ultra45_raw_sc_ultrarawimgevent_FM45_7P_Phi00_BeamCal_"
         "LinearScan_phi004_theta-001_20230821T121304.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
 @pytest.fixture()
@@ -118,7 +119,7 @@ def tof_test_path():
         "ultra45_raw_sc_enaphxtofhangimg_FM45_TV_Cycle6_Hot_Ops_"
         "Front212_20240124T063837.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
 @pytest.fixture()
@@ -126,9 +127,7 @@ def decom_test_data(request, xtce_path):
     """Read test data from file"""
     apid = request.param["apid"]
     filename = request.param["filename"]
-    ccsds_path = (
-        imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
-    )
+    ccsds_path = imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
     packets = decom.decom_packets(ccsds_path, xtce_path)
     grouped_data = group_by_apid(packets)
@@ -144,7 +143,7 @@ def events_fsw_comparison_theta_0():
         "ultra45_raw_sc_ultrarawimg_withFSWcalcs_FM45_40P_Phi28p5_"
         "BeamCal_LinearScan_phi2850_theta-000_20240207T102740.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
 @pytest.fixture()
@@ -158,17 +157,14 @@ def de_dataset(ccsds_path_theta_0, xtce_path):
     decom_ultra_aux = process_ultra_apids(
         grouped_data[ULTRA_AUX.apid[0]], ULTRA_AUX.apid[0]
     )
-    dataset = ultra_l1a.create_dataset(
+    de_dataset = ultra_l1a.create_dataset(
         {
             ULTRA_EVENTS.apid[0]: decom_ultra_events,
             ULTRA_AUX.apid[0]: decom_ultra_aux,
         }
     )
-    # Remove start_type with fill values
-    l1a_de_dataset = dataset.where(
-        dataset["START_TYPE"] != np.iinfo(np.int64).min, drop=True
-    )
-    return l1a_de_dataset
+
+    return de_dataset
 
 
 @pytest.fixture()
@@ -203,21 +199,49 @@ def aux_dataset(ccsds_path_theta_0, xtce_path):
     return l1a_aux_dataset
 
 
+@pytest.fixture()
+def faux_aux_dataset():
+    """Fixture to compute and return aux test data."""
+
+    num_spins = 15
+    spin_duration = 15  # in seconds
+
+    epoch = np.arange(0, num_spins, 1)
+    spin_number = np.arange(127, 142)
+    spin_start_time = np.arange(1905, 2115 + spin_duration, spin_duration)
+    spin_period_sec = np.full(num_spins, 15)
+    spin_period_sec[-1] = 14
+    spin_start_sec = np.arange(1905, 2130, 15)
+    spin_start_subsec = np.zeros(num_spins)
+
+    test_aux_dataset = xr.Dataset(
+        data_vars={
+            "TIMESPINSTART": ("epoch", spin_start_sec),
+            "TIMESPINSTARTSUB": ("epoch", spin_start_subsec),
+            "DURATION": ("epoch", spin_period_sec),
+            "SPINNUMBER": ("epoch", spin_number),
+            "TIMESPINDATA": ("epoch", spin_start_time),
+            "SPINPERIOD": ("epoch", spin_period_sec),
+        },
+        coords={"epoch": ("epoch", epoch)},
+    )
+
+    return test_aux_dataset
+
+
 @pytest.fixture()
 @mock.patch("imap_processing.ultra.l1b.de.get_annotated_particle_velocity")
-def l1b_datasets(
-    mock_get_annotated_particle_velocity, de_dataset, use_fake_spin_data_for_time
+def l1b_de_dataset(
+    mock_get_annotated_particle_velocity,
+    de_dataset,
+    use_fake_spin_data_for_time,
 ):
     """L1B test data"""
 
     data_dict = {}
     data_dict[de_dataset.attrs["Logical_source"]] = de_dataset
-    # TODO: this is a placeholder for the hk dataset.
-    data_dict["imap_ultra_l1a_45sensor-hk"] = aux_dataset
-    data_dict["imap_ultra_l1a_45sensor-rates"] = rates_dataset
-    use_fake_spin_data_for_time(
-        de_dataset["EVENTTIMES"][0], de_dataset["EVENTTIMES"][-1]
-    )
+    # Create a spin table that cover spin 0-141
+    use_fake_spin_data_for_time(0, 141 * 15)
 
     # Mock get_annotated_particle_velocity to avoid needing kernels
     def side_effect_func(event_times, position, ultra_frame, dps_frame, sc_frame):
@@ -238,3 +262,22 @@ def l1b_datasets(
     output_datasets = ultra_l1b(data_dict, data_version="001")
 
     return output_datasets
+
+
+@pytest.fixture()
+def l1b_extendedspin_dataset(
+    l1b_de_dataset,
+    rates_dataset,
+    faux_aux_dataset,
+):
+    """L1B de test data"""
+    data_dict = {}
+    data_dict["imap_ultra_l1b_45sensor-de"] = l1b_de_dataset[0]
+    data_dict["imap_ultra_l1a_45sensor-aux"] = faux_aux_dataset
+    # TODO: this is a placeholder for the hk dataset.
+    data_dict["imap_ultra_l1a_45sensor-hk"] = faux_aux_dataset
+    data_dict["imap_ultra_l1a_45sensor-rates"] = rates_dataset
+
+    output_datasets = ultra_l1b(data_dict, data_version="001")
+
+    return output_datasets

imap_processing/tests/ultra/unit/test_badtimes.py

@@ -11,6 +11,7 @@ def test_calculate_badtimes():
 
     spin_numbers = np.array([0, 1, 2, 3])
     energy_bins = np.array([10, 20, 30, 40])
+    spin_start_time = np.array([0, 1, 2, 3])
 
     quality_attitude = np.full(
         spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
@@ -36,6 +37,7 @@ def test_calculate_badtimes():
                 ("energy_bin_geometric_mean", "spin_number"),
                 quality_ena_rates,
             ),
+            "spin_start_time": (("spin_number",), spin_start_time),
         },
         coords={
             "spin_number": spin_numbers,

imap_processing/tests/ultra/unit/test_cullingmask.py

@@ -10,6 +10,7 @@ def test_calculate_cullingmask_attitude():
 
     spin_numbers = np.array([0, 1])
     energy_bins = np.array([10, 20, 30, 40])
+    spin_start_time = np.array([0, 1])
 
     quality_attitude = np.full(
         spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
@@ -29,6 +30,7 @@ def test_calculate_cullingmask_attitude():
                 ("energy_bin_geometric_mean", "spin_number"),
                 quality_ena_rates,
             ),
+            "spin_start_time": (("spin_number",), spin_start_time),
         },
         coords={
             "spin_number": spin_numbers,
@@ -47,6 +49,7 @@ def test_calculate_cullingmask_rates():
     """Test calculate_cullingmask for rates culling."""
     spin_numbers = np.array([0, 1, 2, 3])
     energy_bins = np.array([10, 20, 30, 40])
+    spin_start_time = np.array([0, 1, 2, 3])
 
     quality_attitude = np.full(
         spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
@@ -72,6 +75,7 @@ def test_calculate_cullingmask_rates():
                 ("energy_bin_geometric_mean", "spin_number"),
                 quality_ena_rates,
             ),
+            "spin_start_time": (("spin_number",), spin_start_time),
         },
         coords={
             "spin_number": spin_numbers,

imap_processing/tests/ultra/unit/test_de.py

@@ -17,10 +17,13 @@ def df_filt(de_dataset, events_fsw_comparison_theta_0):
     return df_filt
 
 
-def test_calculate_de(l1b_datasets, df_filt):
+def test_calculate_de(l1b_de_dataset, df_filt):
     """Tests calculate_de function."""
 
-    l1b_de_dataset = l1b_datasets[0]
+    l1b_de_dataset = l1b_de_dataset[0]
+    l1b_de_dataset = l1b_de_dataset.where(
+        l1b_de_dataset["start_type"] != np.iinfo(np.int64).min, drop=True
+    )
     # Front and back positions
     assert np.allclose(l1b_de_dataset["x_front"].data, df_filt["Xf"].astype("float"))
     assert np.allclose(l1b_de_dataset["y_front"], df_filt["Yf"].astype("float"))
@@ -94,8 +97,13 @@ def test_calculate_de(l1b_datasets, df_filt):
         rtol=1e-2,
     )
     assert np.allclose(
-        l1b_de_dataset["azimuth"].values[condition],
-        df_filt["event_phi"].astype("float").values[condition] % (2 * np.pi),
+        l1b_de_dataset["phi"].values,
+        df_filt["phi"].astype("float").values,
+        rtol=1e-2,
+    )
+    assert np.allclose(
+        l1b_de_dataset["theta"].values,
+        df_filt["theta"].astype("float").values,
         rtol=1e-2,
     )
 

imap_processing/tests/ultra/unit/test_decom_apid_881.py

@@ -4,6 +4,7 @@ import numpy as np
 import pandas as pd
 import pytest
 
+from imap_processing import imap_module_directory
 from imap_processing.ultra.l0.ultra_utils import RATES_KEYS, ULTRA_RATES
 
 
@@ -48,3 +49,46 @@ def test_image_rate_decom(decom_test_data, rates_test_path):
     for name in RATES_KEYS:
         arr.append(decom_ultra[name][total_packets - 1])
     assert expected_arrn == arr
+
+
+@pytest.mark.parametrize(
+    "decom_test_data",
+    [
+        pytest.param(
+            {
+                "apid": ULTRA_RATES.apid[0],
+                "filename": "FM45_UltraFM45_Functional_2024-01-22T0105_"
+                "20240122T010548.CCSDS",
+            }
+        )
+    ],
+    indirect=True,
+)
+def test_image_rate_decom_zero_width(decom_test_data):
+    """This function tests for cases in which the width is zero within the packet."""
+    test_path = (
+        imap_module_directory
+        / "tests"
+        / "ultra"
+        / "data"
+        / "l0"
+        / "ultra45_raw_sc_ultraimgrates_20220530_00.csv"
+    )
+
+    decom_ultra, _ = decom_test_data
+
+    df = pd.read_csv(test_path, index_col="MET")
+    total_packets = 163
+
+    np.testing.assert_array_equal(df.SID, decom_ultra["SID"])
+    np.testing.assert_array_equal(df.Spin, decom_ultra["SPIN"])
+    np.testing.assert_array_equal(df.AbortFlag, decom_ultra["ABORTFLAG"])
+    np.testing.assert_array_equal(df.StartDelay, decom_ultra["STARTDELAY"])
+
+    for i in range(total_packets):
+        t = int(df["SequenceCount"].iloc[i])  # Ensure we get an integer value
+        expected_arr = json.loads(df.loc[df["SequenceCount"] == t, "Counts"].values[0])
+        arr = []
+        for name in RATES_KEYS:
+            arr.append(decom_ultra[name][i])
+        assert expected_arr == arr