imap-processing 0.18.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

imap_processing/idex/idex_l2b.py

@@ -17,8 +17,9 @@ Examples
     l1a_data, l1a_evt_data, l1b_evt_data = PacketParser(l0_file)
     l1b_data = idex_l1b(l1a_data)
     l1a_data = idex_l2a(l1b_data)
-    l2b_data = idex_l2b(l2a_data, [evt_data])
-    write_cdf(l2b_data)
+    l2b_and_l2c_datasets = idex_l2b(l2a_data, [evt_data])
+    write_cdf(l2b_and_l2c_datasets[0])
+    write_cdf(l2b_and_l2c_datasets[1])
 """
 
 import collections
@@ -29,9 +30,11 @@ from datetime import datetime, timedelta
 import numpy as np
 import xarray as xr
 
+from imap_processing.ena_maps.ena_maps import SkyTilingType
 from imap_processing.ena_maps.utils.spatial_utils import AzElSkyGrid
 from imap_processing.idex.idex_constants import (
     FG_TO_KG,
+    IDEX_EVENT_REFERENCE_FRAME,
     IDEX_SPACING_DEG,
     SECONDS_IN_DAY,
     IDEXEvtAcquireCodes,
@@ -81,9 +84,12 @@ LAT_BINS_EDGES = SKY_GRID.el_bin_edges
 
 def idex_l2b(
     l2a_datasets: list[xr.Dataset], evt_datasets: list[xr.Dataset]
-) -> xr.Dataset:
+) -> list[xr.Dataset]:
     """
-    Will process IDEX l2a data to create l2b data products.
+    Will process IDEX l2a data to create l2b and l2c data products.
+
+    IDEX L2B processing creates L2b and L2c at the same time because L2c needs no
+    additional dependencies and is a natural extension of L2b processing.
 
     Parameters
     ----------
@@ -94,16 +100,18 @@ def idex_l2b(
 
     Returns
     -------
-    l2b_dataset : xarray.Dataset
-        The``xarray`` dataset containing the science data and supporting metadata.
+    list[xarray.Dataset]
+        The``xarray`` datasets containing the l2b and l2c science data and supporting
+        metadata.
     """
     logger.info(
-        f"Running IDEX L2B processing on datasets: "
-        f"{[ds.attrs['Logical_source'] for ds in l2a_datasets]}"
+        "Running IDEX L2B and L2C processing on L2a datasets. NOTE: L2C datasets are "
+        "processed at the same time as L2B datasets because L2C needs no additional "
+        "dependencies."
     )
-
     # create the attribute manager for this data level
-    idex_attrs = get_idex_attrs("l2b")
+    idex_l2b_attrs = get_idex_attrs("l2b")
+    idex_l2c_attrs = get_idex_attrs("l2c")
     evt_dataset = xr.concat(evt_datasets, dim="epoch")
 
     # Concat all the l2a datasets together
@@ -133,125 +141,138 @@ def idex_l2b(
         daily_on_percentage,
     )
     # Create l2b Dataset
-    charge_bins = np.arange(len(CHARGE_BIN_EDGES) - 1)
-    mass_bins = np.arange(len(CHARGE_BIN_EDGES) - 1)
-    spin_phase_bins = np.arange(len(SPIN_PHASE_BIN_EDGES) - 1)
+    charge_bin_means = np.sqrt(CHARGE_BIN_EDGES[:-1] * CHARGE_BIN_EDGES[1:])
+    mass_bin_means = np.sqrt(MASS_BIN_EDGES[:-1] * MASS_BIN_EDGES[1:])
+    spin_phase_means = (SPIN_PHASE_BIN_EDGES[:-1] + SPIN_PHASE_BIN_EDGES[1:]) / 2
+
+    # Define xarrays that are shared between l2b and l2c
     epoch = xr.DataArray(
         name="epoch",
         data=daily_epoch,
         dims="epoch",
-        attrs=idex_attrs.get_variable_attributes("epoch", check_schema=False),
+        attrs=idex_l2b_attrs.get_variable_attributes("epoch", check_schema=False),
     )
-    data_vars = {
+
+    common_vars = {
         "impact_day_of_year": xr.DataArray(
             name="impact_day_of_year",
             data=epoch_doy_unique,
             dims="epoch",
-            attrs=idex_attrs.get_variable_attributes("impact_day_of_year"),
-        ),
-        "rate_calculation_quality_flags": xr.DataArray(
-            name="rate_calculation_quality_flags",
-            data=rate_quality_flags,
-            dims="epoch",
-            attrs=idex_attrs.get_variable_attributes("rate_calculation_quality_flags"),
+            attrs=idex_l2b_attrs.get_variable_attributes("impact_day_of_year"),
         ),
         "charge_labels": xr.DataArray(
             name="impact_charge_labels",
-            data=charge_bins.astype(str),
+            data=charge_bin_means.astype(str),
             dims="impact_charge",
-            attrs=idex_attrs.get_variable_attributes(
+            attrs=idex_l2b_attrs.get_variable_attributes(
                 "charge_labels", check_schema=False
             ),
         ),
-        "spin_phase_labels": xr.DataArray(
-            name="spin_phase_labels",
-            data=spin_phase_bins.astype(str),
-            dims="spin_phase",
-            attrs=idex_attrs.get_variable_attributes(
-                "spin_phase_labels", check_schema=False
-            ),
-        ),
         "mass_labels": xr.DataArray(
             name="mass_labels",
-            data=mass_bins.astype(str),
+            data=mass_bin_means.astype(str),
             dims="mass",
-            attrs=idex_attrs.get_variable_attributes("mass_labels", check_schema=False),
-        ),
-        "rectangular_lon_pixel_label": xr.DataArray(
-            name="rectangular_lon_pixel_label",
-            data=SKY_GRID.az_bin_midpoints.astype(str),
-            dims="rectangular_lon_pixel",
-            attrs=idex_attrs.get_variable_attributes(
-                "rectangular_lon_pixel_label", check_schema=False
-            ),
-        ),
-        "rectangular_lat_pixel_label": xr.DataArray(
-            name="rectangular_lat_pixel_label",
-            data=SKY_GRID.el_bin_midpoints.astype(str),
-            dims="rectangular_lat_pixel",
-            attrs=idex_attrs.get_variable_attributes(
-                "rectangular_lat_pixel_label", check_schema=False
+            attrs=idex_l2b_attrs.get_variable_attributes(
+                "mass_labels", check_schema=False
             ),
         ),
         "impact_charge": xr.DataArray(
             name="impact_charge",
-            data=charge_bins,
+            data=charge_bin_means,
             dims="impact_charge",
-            attrs=idex_attrs.get_variable_attributes(
+            attrs=idex_l2b_attrs.get_variable_attributes(
                 "impact_charge", check_schema=False
             ),
         ),
         "mass": xr.DataArray(
             name="mass",
-            data=mass_bins,
+            data=mass_bin_means,
             dims="mass",
-            attrs=idex_attrs.get_variable_attributes("mass", check_schema=False),
+            attrs=idex_l2b_attrs.get_variable_attributes("mass", check_schema=False),
         ),
+    }
+    l2b_vars = common_vars | {
         "spin_phase": xr.DataArray(
             name="spin_phase",
-            data=spin_phase_bins,
+            data=spin_phase_means,
             dims="spin_phase",
-            attrs=idex_attrs.get_variable_attributes("spin_phase", check_schema=False),
+            attrs=idex_l2b_attrs.get_variable_attributes(
+                "spin_phase", check_schema=False
+            ),
         ),
-        "rectangular_lon_pixel": xr.DataArray(
-            name="rectangular_lon_pixel",
-            data=SKY_GRID.az_bin_midpoints,
-            dims="rectangular_lon_pixel",
-            attrs=idex_attrs.get_variable_attributes(
-                "rectangular_lon_pixel", check_schema=False
+        "spin_phase_labels": xr.DataArray(
+            name="spin_phase_labels",
+            data=spin_phase_means.astype(str),
+            dims="spin_phase",
+            attrs=idex_l2b_attrs.get_variable_attributes(
+                "spin_phase_labels", check_schema=False
             ),
         ),
-        "rectangular_lat_pixel": xr.DataArray(
-            name="rectangular_lat_pixel",
-            data=SKY_GRID.el_bin_midpoints,
-            dims="rectangular_lat_pixel",
-            attrs=idex_attrs.get_variable_attributes(
-                "rectangular_lat_pixel", check_schema=False
+        "rate_calculation_quality_flags": xr.DataArray(
+            name="rate_calculation_quality_flags",
+            data=rate_quality_flags,
+            dims="epoch",
+            attrs=idex_l2b_attrs.get_variable_attributes(
+                "rate_calculation_quality_flags"
             ),
         ),
         "counts_by_charge": xr.DataArray(
             name="counts_by_charge",
             data=counts_by_charge.astype(np.int64),
             dims=("epoch", "impact_charge", "spin_phase"),
-            attrs=idex_attrs.get_variable_attributes("counts_by_charge"),
+            attrs=idex_l2b_attrs.get_variable_attributes("counts_by_charge"),
         ),
         "counts_by_mass": xr.DataArray(
             name="counts_by_mass",
             data=counts_by_mass.astype(np.int64),
             dims=("epoch", "mass", "spin_phase"),
-            attrs=idex_attrs.get_variable_attributes("counts_by_mass"),
+            attrs=idex_l2b_attrs.get_variable_attributes("counts_by_mass"),
         ),
         "rate_by_charge": xr.DataArray(
             name="rate_by_charge",
             data=rate_by_charge,
             dims=("epoch", "impact_charge", "spin_phase"),
-            attrs=idex_attrs.get_variable_attributes("rate_by_charge"),
+            attrs=idex_l2b_attrs.get_variable_attributes("rate_by_charge"),
         ),
         "rate_by_mass": xr.DataArray(
             name="rate_by_mass",
             data=rate_by_mass,
             dims=("epoch", "mass", "spin_phase"),
-            attrs=idex_attrs.get_variable_attributes("rate_by_mass"),
+            attrs=idex_l2b_attrs.get_variable_attributes("rate_by_mass"),
+        ),
+    }
+    l2c_vars = common_vars | {
+        "rectangular_lon_pixel_label": xr.DataArray(
+            name="rectangular_lon_pixel_label",
+            data=SKY_GRID.az_bin_midpoints.astype(str),
+            dims="rectangular_lon_pixel",
+            attrs=idex_l2c_attrs.get_variable_attributes(
+                "rectangular_lon_pixel_label", check_schema=False
+            ),
+        ),
+        "rectangular_lat_pixel_label": xr.DataArray(
+            name="rectangular_lat_pixel_label",
+            data=SKY_GRID.el_bin_midpoints.astype(str),
+            dims="rectangular_lat_pixel",
+            attrs=idex_l2c_attrs.get_variable_attributes(
+                "rectangular_lat_pixel_label", check_schema=False
+            ),
+        ),
+        "rectangular_lon_pixel": xr.DataArray(
+            name="rectangular_lon_pixel",
+            data=SKY_GRID.az_bin_midpoints,
+            dims="rectangular_lon_pixel",
+            attrs=idex_l2c_attrs.get_variable_attributes(
+                "rectangular_lon_pixel", check_schema=False
+            ),
+        ),
+        "rectangular_lat_pixel": xr.DataArray(
+            name="rectangular_lat_pixel",
+            data=SKY_GRID.el_bin_midpoints,
+            dims="rectangular_lat_pixel",
+            attrs=idex_l2c_attrs.get_variable_attributes(
+                "rectangular_lat_pixel", check_schema=False
+            ),
         ),
         "counts_by_charge_map": xr.DataArray(
             name="counts_by_charge_map",
@@ -262,7 +283,7 @@ def idex_l2b(
                 "rectangular_lon_pixel",
                 "rectangular_lat_pixel",
             ),
-            attrs=idex_attrs.get_variable_attributes("counts_by_charge_map"),
+            attrs=idex_l2c_attrs.get_variable_attributes("counts_by_charge_map"),
         ),
         "counts_by_mass_map": xr.DataArray(
             name="counts_by_mass_map",
@@ -273,7 +294,7 @@ def idex_l2b(
                 "rectangular_lon_pixel",
                 "rectangular_lat_pixel",
             ),
-            attrs=idex_attrs.get_variable_attributes("counts_by_mass_map"),
+            attrs=idex_l2c_attrs.get_variable_attributes("counts_by_mass_map"),
         ),
         "rate_by_charge_map": xr.DataArray(
             name="rate_by_charge_map",
@@ -284,7 +305,7 @@ def idex_l2b(
                 "rectangular_lon_pixel",
                 "rectangular_lat_pixel",
             ),
-            attrs=idex_attrs.get_variable_attributes("rate_by_charge_map"),
+            attrs=idex_l2c_attrs.get_variable_attributes("rate_by_charge_map"),
         ),
         "rate_by_mass_map": xr.DataArray(
             name="rate_by_mass_map",
@@ -295,18 +316,31 @@ def idex_l2b(
                 "rectangular_lon_pixel",
                 "rectangular_lat_pixel",
             ),
-            attrs=idex_attrs.get_variable_attributes("rate_by_mass_map"),
+            attrs=idex_l2c_attrs.get_variable_attributes("rate_by_mass_map"),
         ),
     }
+
     l2b_dataset = xr.Dataset(
         coords={"epoch": epoch},
-        data_vars=data_vars,
-        attrs=idex_attrs.get_global_attributes("imap_idex_l2b_sci"),
+        data_vars=l2b_vars,
+        attrs=idex_l2b_attrs.get_global_attributes("imap_idex_l2b_sci"),
+    )
+    l2c_dataset = xr.Dataset(
+        coords={"epoch": epoch},
+        data_vars=l2c_vars,
     )
+    # Add map attributes
+    map_attrs = {
+        "sky_tiling_type": SkyTilingType.RECTANGULAR.value,
+        "Spacing_degrees": str(IDEX_SPACING_DEG),
+        "Spice_reference_frame": IDEX_EVENT_REFERENCE_FRAME.name,
+    } | idex_l2c_attrs.get_global_attributes("imap_idex_l2c_sci-rectangular")
 
-    logger.info("IDEX L2B science data processing completed.")
+    l2c_dataset.attrs.update(map_attrs)
 
-    return l2b_dataset
+    logger.info("IDEX L2B and L2C science data processing completed.")
+
+    return [l2b_dataset, l2c_dataset]
 
 
 def compute_counts_by_charge_and_mass(
@@ -329,37 +363,11 @@ def compute_counts_by_charge_and_mass(
         dataset, Two 4D arrays containing counts by charge or mass, and by lon and lat
         for each dataset, and a 1D array of daily epoch values.
     """
-    # Initialize arrays to hold counts.
-    # There should be 4 spin phase bins, 10 charge bins, and 10 mass bins.
-    # The first bin for charge and mass is for values below the first bin edge.
-    counts_by_charge = np.zeros(
-        (
-            len(epoch_doy_unique),
-            len(CHARGE_BIN_EDGES) - 1,
-            len(SPIN_PHASE_BIN_EDGES) - 1,
-        ),
-    )
-    counts_by_mass = np.zeros(
-        (len(epoch_doy_unique), len(MASS_BIN_EDGES) - 1, len(SPIN_PHASE_BIN_EDGES) - 1),
-    )
-    # Initialize arrays to hold count maps. Each map is a 3 or 4D array with shape
-    # (epoch, 10 [charge or mass], 60 [longitude bins], 30 [latitude bins]).
-    counts_by_charge_map = np.zeros(
-        (
-            len(epoch_doy_unique),
-            len(CHARGE_BIN_EDGES) - 1,
-            len(LON_BINS_EDGES) - 1,
-            len(LAT_BINS_EDGES) - 1,
-        ),
-    )
-    counts_by_mass_map = np.zeros(
-        (
-            len(epoch_doy_unique),
-            len(MASS_BIN_EDGES) - 1,
-            len(LON_BINS_EDGES) - 1,
-            len(LAT_BINS_EDGES) - 1,
-        ),
-    )
+    # Initialize lists to hold counts.
+    counts_by_charge = []
+    counts_by_mass = []
+    counts_by_charge_map = []
+    counts_by_mass_map = []
     daily_epoch = np.zeros(len(epoch_doy_unique), dtype=np.float64)
     for i in range(len(epoch_doy_unique)):
         doy = epoch_doy_unique[i]
@@ -379,43 +387,44 @@ def compute_counts_by_charge_and_mass(
         latitude = l2a_dataset["latitude"].data[current_day_indices]
         # Convert units
         mass_vals = FG_TO_KG * np.atleast_1d(mass_vals)
-        # Bin masses
-        binned_mass = np.asarray(np.digitize(mass_vals, bins=MASS_BIN_EDGES))
-        # Bin charges
-        binned_charge = np.asarray(np.digitize(charge_vals, bins=CHARGE_BIN_EDGES))
         # Bin spin phases
         binned_spin_phase = bin_spin_phases(spin_phase_angles)
-        # Bin longitude and latitude into the rectangular grid.
-        binned_longitude = np.asarray(np.digitize(longitude, bins=LON_BINS_EDGES))
+        # Clip arrays to ensure that the values are within the valid range of bins.
         # Latitude should be binned with the right edge included. 90 is a valid latitude
-        binned_latitude = np.asarray(np.digitize(latitude, bins=LAT_BINS_EDGES))
-        # Clip latitude value above the right edge to be in the last bin
-        binned_latitude = np.clip(binned_latitude, 1, len(LAT_BINS_EDGES) - 1)
-        # If the values in the array are beyond the bounds of bins, 0 or len(bins) it is
-        # returned as such. In this case, the desired result is to place the values
-        # beyond the first or last bin into the first or last bin, respectively.
-        binned_charge = np.clip(binned_charge, 1, len(CHARGE_BIN_EDGES) - 1)
-        binned_mass = np.clip(binned_mass, 1, len(MASS_BIN_EDGES) - 1)
-
-        # Count dust events for each spin phase, mass bin, charge bin, and bin into
-        # a rectangular grid
-        for mass_bin, charge_bin, spin_phase_bin, lon_bin, lat_bin in zip(
-            binned_mass,
-            binned_charge,
-            binned_spin_phase,
-            binned_longitude,
-            binned_latitude,
-        ):
-            counts_by_mass[i, mass_bin - 1, spin_phase_bin] += 1
-            counts_by_charge[i, charge_bin - 1, spin_phase_bin] += 1
-            counts_by_mass_map[i, mass_bin - 1, lon_bin - 1, lat_bin - 1] += 1
-            counts_by_charge_map[i, charge_bin - 1, lon_bin - 1, lat_bin - 1] += 1
+        latitude = np.clip(latitude, -90, 90)
+        mass_vals = np.clip(mass_vals, MASS_BIN_EDGES[0], MASS_BIN_EDGES[-1])
+        charge_vals = np.clip(charge_vals, CHARGE_BIN_EDGES[0], CHARGE_BIN_EDGES[-1])
+
+        counts_by_mass.append(
+            np.histogramdd(
+                np.column_stack([mass_vals, binned_spin_phase]),
+                bins=[MASS_BIN_EDGES, np.arange(5)],
+            )[0]
+        )
+        counts_by_charge.append(
+            np.histogramdd(
+                np.column_stack([charge_vals, binned_spin_phase]),
+                bins=[CHARGE_BIN_EDGES, np.arange(5)],
+            )[0]
+        )
+        counts_by_mass_map.append(
+            np.histogramdd(
+                np.column_stack([mass_vals, longitude, latitude]),
+                bins=[MASS_BIN_EDGES, LON_BINS_EDGES, LAT_BINS_EDGES],
+            )[0]
+        )
+        counts_by_charge_map.append(
+            np.histogramdd(
+                np.column_stack([charge_vals, longitude, latitude]),
+                bins=[CHARGE_BIN_EDGES, LON_BINS_EDGES, LAT_BINS_EDGES],
+            )[0]
+        )
 
     return (
-        counts_by_charge,
-        counts_by_mass,
-        counts_by_charge_map,
-        counts_by_mass_map,
+        np.stack(counts_by_charge),
+        np.stack(counts_by_mass),
+        np.stack(counts_by_charge_map),
+        np.stack(counts_by_mass_map),
         daily_epoch,
     )
 
@@ -598,7 +607,7 @@ def get_science_acquisition_timestamps(
     epochs = evt_dataset["epoch"][sc_indices].data
     # Now the state change values and check if it is either a science
     # acquisition start or science acquisition stop event.
-    for v1, v2, epoch in zip(val1, val2, epochs):
+    for v1, v2, epoch in zip(val1, val2, epochs, strict=False):
         # An "acquire" start will have val1=ACQSETUP and val2=ACQ
         # An "acquire" stop will have val1=ACQ and val2=CHILL
         if (v1, v2) == (IDEXEvtAcquireCodes.ACQSETUP, IDEXEvtAcquireCodes.ACQ):
@@ -637,6 +646,12 @@ def get_science_acquisition_on_percentage(evt_dataset: xr.Dataset) -> dict:
     """
     # Get science acquisition start and stop times
     evt_logs, evt_time, evt_values = get_science_acquisition_timestamps(evt_dataset)
+    if len(evt_time) == 0:
+        logger.warning(
+            "No science acquisition events found in event dataset. Returning empty "
+            "uptime percentages. All rate variables will be set to -1."
+        )
+        return {}
     # Track total and 'on' durations per day
     daily_totals: collections.defaultdict = defaultdict(timedelta)
     daily_on: collections.defaultdict = defaultdict(timedelta)

imap_processing/idex/idex_utils.py

@@ -1,7 +1,5 @@
 """Contains helper functions to support IDEX processing."""
 
-from typing import Optional
-
 import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
@@ -31,7 +29,7 @@ def setup_dataset(
     dataset: xr.Dataset,
     match_strings: list,
     idex_attrs: ImapCdfAttributes,
-    data_vars: Optional[dict] = None,
+    data_vars: dict | None = None,
 ) -> xr.Dataset:
     """
     Initialize a dataset and copy over any dataArrays.

imap_processing/lo/l0/lo_science.py

@@ -37,28 +37,28 @@ HistPacking = namedtuple(
 
 HIST_DATA_META = {
     # field: bit_length, section_length, shape
-    "start_a": HistPacking(12, 504, (6, 7)),
-    "start_c": HistPacking(12, 504, (6, 7)),
-    "stop_b0": HistPacking(12, 504, (6, 7)),
-    "stop_b3": HistPacking(12, 504, (6, 7)),
-    "tof0_count": HistPacking(8, 336, (6, 7)),
-    "tof1_count": HistPacking(8, 336, (6, 7)),
-    "tof2_count": HistPacking(8, 336, (6, 7)),
-    "tof3_count": HistPacking(8, 336, (6, 7)),
-    "tof0_tof1": HistPacking(8, 3360, (60, 7)),
-    "tof0_tof2": HistPacking(8, 3360, (60, 7)),
-    "tof1_tof2": HistPacking(8, 3360, (60, 7)),
-    "silver": HistPacking(8, 3360, (60, 7)),
-    "disc_tof0": HistPacking(8, 336, (6, 7)),
-    "disc_tof1": HistPacking(8, 336, (6, 7)),
-    "disc_tof2": HistPacking(8, 336, (6, 7)),
-    "disc_tof3": HistPacking(8, 336, (6, 7)),
-    "pos0": HistPacking(12, 504, (6, 7)),
-    "pos1": HistPacking(12, 504, (6, 7)),
-    "pos2": HistPacking(12, 504, (6, 7)),
-    "pos3": HistPacking(12, 504, (6, 7)),
-    "hydrogen": HistPacking(8, 3360, (60, 7)),
-    "oxygen": HistPacking(8, 3360, (60, 7)),
+    "start_a": HistPacking(12, 504, (7, 6)),
+    "start_c": HistPacking(12, 504, (7, 6)),
+    "stop_b0": HistPacking(12, 504, (7, 6)),
+    "stop_b3": HistPacking(12, 504, (7, 6)),
+    "tof0_count": HistPacking(8, 336, (7, 6)),
+    "tof1_count": HistPacking(8, 336, (7, 6)),
+    "tof2_count": HistPacking(8, 336, (7, 6)),
+    "tof3_count": HistPacking(8, 336, (7, 6)),
+    "tof0_tof1": HistPacking(8, 3360, (7, 60)),
+    "tof0_tof2": HistPacking(8, 3360, (7, 60)),
+    "tof1_tof2": HistPacking(8, 3360, (7, 60)),
+    "silver": HistPacking(8, 3360, (7, 60)),
+    "disc_tof0": HistPacking(8, 336, (7, 6)),
+    "disc_tof1": HistPacking(8, 336, (7, 6)),
+    "disc_tof2": HistPacking(8, 336, (7, 6)),
+    "disc_tof3": HistPacking(8, 336, (7, 6)),
+    "pos0": HistPacking(12, 504, (7, 6)),
+    "pos1": HistPacking(12, 504, (7, 6)),
+    "pos2": HistPacking(12, 504, (7, 6)),
+    "pos3": HistPacking(12, 504, (7, 6)),
+    "hydrogen": HistPacking(8, 3360, (7, 60)),
+    "oxygen": HistPacking(8, 3360, (7, 60)),
 }
 
 
@@ -399,7 +399,7 @@ def combine_segmented_packets(dataset: xr.Dataset) -> xr.Dataset:
     # Combine the segmented packets into a single binary string
     dataset["events"] = [
         "".join(dataset["data"].values[start : end + 1])
-        for start, end in zip(seg_starts, seg_ends)
+        for start, end in zip(seg_starts, seg_ends, strict=False)
     ]
 
     # drop any group of segmented packets that aren't sequential
@@ -441,7 +441,8 @@ def find_valid_groups(
     """
     # Check if the sequence counters from the CCSDS header are sequential
     grouped_seq_ctrs = [
-        np.array(seq_ctrs[start : end + 1]) for start, end in zip(seg_starts, seg_ends)
+        np.array(seq_ctrs[start : end + 1])
+        for start, end in zip(seg_starts, seg_ends, strict=False)
     ]
     valid_groups = [is_sequential(seq_ctrs) for seq_ctrs in grouped_seq_ctrs]
     return valid_groups

imap_processing/lo/l1b/lo_l1b.py

@@ -3,7 +3,7 @@
 import logging
 from dataclasses import Field
 from pathlib import Path
-from typing import Any, Union
+from typing import Any
 
 import numpy as np
 import xarray as xr
@@ -204,7 +204,7 @@ def get_avg_spin_durations_per_cycle(
     return avg_spin_durations_per_cycle
 
 
-def get_spin_angle(l1a_de: xr.Dataset) -> Union[np.ndarray[np.float64], Any]:
+def get_spin_angle(l1a_de: xr.Dataset) -> np.ndarray[np.float64] | Any:
     """
     Get the spin angle (0 - 360 degrees) for each DE.
 
@@ -587,7 +587,7 @@ def convert_tofs_to_eu(
     tof_conversions = [TOF0_CONV, TOF1_CONV, TOF2_CONV, TOF3_CONV]
 
     # Loop through the TOF fields and convert them to engineering units
-    for tof, conv in zip(tof_fields, tof_conversions):
+    for tof, conv in zip(tof_fields, tof_conversions, strict=False):
         # Get the fill value for the L1A and L1B TOF
         fillval_1a = attr_mgr_l1a.get_variable_attributes(tof)["FILLVAL"]
         fillval_1b = attr_mgr_l1b.get_variable_attributes(tof)["FILLVAL"]