imap-processing 0.17.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,8 +30,12 @@ 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,
 )
@@ -71,12 +76,20 @@ CHARGE_BIN_EDGES = np.array(
 )
 SPIN_PHASE_BIN_EDGES = np.array([0, 90, 180, 270, 360])
 
+# Get the rectangular map grid with the specified spacing
+SKY_GRID = AzElSkyGrid(IDEX_SPACING_DEG)
+LON_BINS_EDGES = SKY_GRID.az_bin_edges
+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
     ----------
@@ -87,140 +100,254 @@ 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
     l2a_dataset = xr.concat(l2a_datasets, dim="epoch")
     epoch_doy_unique = np.unique(epoch_to_doy(l2a_dataset["epoch"].data))
-    counts_by_charge, counts_by_mass, daily_epoch = compute_counts_by_charge_and_mass(
-        l2a_dataset, epoch_doy_unique
-    )
+    (
+        counts_by_charge,
+        counts_by_mass,
+        counts_by_charge_map,
+        counts_by_mass_map,
+        daily_epoch,
+    ) = compute_counts_by_charge_and_mass(l2a_dataset, epoch_doy_unique)
     # Get science acquisition percentage for each day
     daily_on_percentage = get_science_acquisition_on_percentage(evt_dataset)
-    rate_by_charge, rate_by_mass, rate_quality_flags = compute_rates_by_charge_and_mass(
-        counts_by_charge, counts_by_mass, epoch_doy_unique, daily_on_percentage
+    (
+        rate_by_charge,
+        rate_by_mass,
+        rate_by_charge_map,
+        rate_by_mass_map,
+        rate_quality_flags,
+    ) = compute_rates_by_charge_and_mass(
+        counts_by_charge,
+        counts_by_mass,
+        counts_by_charge_map,
+        counts_by_mass_map,
+        epoch_doy_unique,
+        daily_on_percentage,
     )
     # Create l2b Dataset
-    charge_bins = np.arange(len(CHARGE_BIN_EDGES))
-    mass_bins = np.arange(len(CHARGE_BIN_EDGES))
-    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),
     )
-    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),
-            dims="impact_charge_bins",
-            attrs=idex_attrs.get_variable_attributes(
+            data=charge_bin_means.astype(str),
+            dims="impact_charge",
+            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_bins",
-            attrs=idex_attrs.get_variable_attributes(
-                "spin_phase_labels", check_schema=False
-            ),
-        ),
         "mass_labels": xr.DataArray(
             name="mass_labels",
-            data=mass_bins.astype(str),
-            dims="mass_bins",
-            attrs=idex_attrs.get_variable_attributes("mass_labels", check_schema=False),
+            data=mass_bin_means.astype(str),
+            dims="mass",
+            attrs=idex_l2b_attrs.get_variable_attributes(
+                "mass_labels", check_schema=False
+            ),
         ),
-        "impact_charge_bins": xr.DataArray(
-            name="impact_charge_bins",
-            data=charge_bins,
-            dims="impact_charge_bins",
-            attrs=idex_attrs.get_variable_attributes(
-                "impact_charge_bins", check_schema=False
+        "impact_charge": xr.DataArray(
+            name="impact_charge",
+            data=charge_bin_means,
+            dims="impact_charge",
+            attrs=idex_l2b_attrs.get_variable_attributes(
+                "impact_charge", check_schema=False
             ),
         ),
-        "mass_bins": xr.DataArray(
-            name="mass_bins",
-            data=mass_bins,
-            dims="mass_bins",
-            attrs=idex_attrs.get_variable_attributes("mass_bins", check_schema=False),
+        "mass": xr.DataArray(
+            name="mass",
+            data=mass_bin_means,
+            dims="mass",
+            attrs=idex_l2b_attrs.get_variable_attributes("mass", check_schema=False),
         ),
-        "spin_phase_bins": xr.DataArray(
-            name="spin_phase_bins",
-            data=spin_phase_bins,
-            dims="spin_phase_bins",
-            attrs=idex_attrs.get_variable_attributes(
-                "spin_phase_bins", check_schema=False
+    }
+    l2b_vars = common_vars | {
+        "spin_phase": xr.DataArray(
+            name="spin_phase",
+            data=spin_phase_means,
+            dims="spin_phase",
+            attrs=idex_l2b_attrs.get_variable_attributes(
+                "spin_phase", 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
+            ),
+        ),
+        "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", "charge_bins", "spin_phase_bins"),
-            attrs=idex_attrs.get_variable_attributes("counts_by_charge"),
+            dims=("epoch", "impact_charge", "spin_phase"),
+            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_bins", "spin_phase_bins"),
-            attrs=idex_attrs.get_variable_attributes("counts_by_mass"),
+            dims=("epoch", "mass", "spin_phase"),
+            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", "charge_bins", "spin_phase_bins"),
-            attrs=idex_attrs.get_variable_attributes("rate_by_charge"),
+            dims=("epoch", "impact_charge", "spin_phase"),
+            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_bins", "spin_phase_bins"),
-            attrs=idex_attrs.get_variable_attributes("rate_by_mass"),
+            dims=("epoch", "mass", "spin_phase"),
+            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",
+            data=counts_by_charge_map.astype(np.int64),
+            dims=(
+                "epoch",
+                "impact_charge",
+                "rectangular_lon_pixel",
+                "rectangular_lat_pixel",
+            ),
+            attrs=idex_l2c_attrs.get_variable_attributes("counts_by_charge_map"),
+        ),
+        "counts_by_mass_map": xr.DataArray(
+            name="counts_by_mass_map",
+            data=counts_by_mass_map.astype(np.int64),
+            dims=(
+                "epoch",
+                "mass",
+                "rectangular_lon_pixel",
+                "rectangular_lat_pixel",
+            ),
+            attrs=idex_l2c_attrs.get_variable_attributes("counts_by_mass_map"),
+        ),
+        "rate_by_charge_map": xr.DataArray(
+            name="rate_by_charge_map",
+            data=rate_by_charge_map,
+            dims=(
+                "epoch",
+                "impact_charge",
+                "rectangular_lon_pixel",
+                "rectangular_lat_pixel",
+            ),
+            attrs=idex_l2c_attrs.get_variable_attributes("rate_by_charge_map"),
+        ),
+        "rate_by_mass_map": xr.DataArray(
+            name="rate_by_mass_map",
+            data=rate_by_mass_map,
+            dims=(
+                "epoch",
+                "mass",
+                "rectangular_lon_pixel",
+                "rectangular_lat_pixel",
+            ),
+            attrs=idex_l2c_attrs.get_variable_attributes("rate_by_mass_map"),
+        ),
+    }
+
     l2b_dataset = xr.Dataset(
         coords={"epoch": epoch},
-        data_vars=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,
     )
-    # Copy longitude and latitude from the l2a dataset
-    l2b_dataset["longitude"] = l2a_dataset["longitude"].copy()
-    l2b_dataset["latitude"] = l2a_dataset["latitude"].copy()
+    # 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(
     l2a_dataset: xr.Dataset, epoch_doy_unique: np.ndarray
-) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
     """
-    Compute the dust event counts by charge and mass by spin phase per day.
+    Compute the dust counts by charge and mass by spin phase or lon and lat per day.
 
     Parameters
     ----------
@@ -231,20 +358,17 @@ def compute_counts_by_charge_and_mass(
 
     Returns
     -------
-    tuple[np.ndarray, np.ndarray, np.ndarray]
+    tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]
         Two 3D arrays containing counts by charge or mass, and by spin phase for each
-        dataset, and a 1D array of daily epoch values.
+        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, 11 charge bins, and 11 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), len(SPIN_PHASE_BIN_EDGES) - 1),
-    )
-    counts_by_mass = np.zeros(
-        (len(epoch_doy_unique), len(MASS_BIN_EDGES), len(SPIN_PHASE_BIN_EDGES) - 1),
-    )
-    daily_epoch = np.zeros(len(epoch_doy_unique))
+    # 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]
         # Get the indices for the current day
@@ -258,39 +382,89 @@ def compute_counts_by_charge_and_mass(
         ]
         charge_vals = l2a_dataset["target_low_impact_charge"].data[current_day_indices]
         spin_phase_angles = l2a_dataset["spin_phase"].data[current_day_indices]
+        # Make sure longitude values are in the range [0, 360)
+        longitude = np.mod(l2a_dataset["longitude"].data[current_day_indices], 360)
+        latitude = l2a_dataset["latitude"].data[current_day_indices]
         # Convert units
-        mass_vals = FG_TO_KG * np.array(mass_vals)
-        # Bin masses
-        binned_mass = np.array(np.digitize(mass_vals, bins=MASS_BIN_EDGES))
-        # Bin charges
-        binned_charge = np.array(np.digitize(charge_vals, bins=CHARGE_BIN_EDGES))
+        mass_vals = FG_TO_KG * np.atleast_1d(mass_vals)
         # Bin spin phases
         binned_spin_phase = bin_spin_phases(spin_phase_angles)
-        # 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 last bin into the last bin and keep the values below the first bin.
-        binned_charge[binned_charge == len(CHARGE_BIN_EDGES)] = (
-            len(CHARGE_BIN_EDGES) - 1
+        # 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
+        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]
         )
-        binned_mass[binned_mass == len(MASS_BIN_EDGES)] = len(MASS_BIN_EDGES) - 1
+        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 (
+        np.stack(counts_by_charge),
+        np.stack(counts_by_mass),
+        np.stack(counts_by_charge_map),
+        np.stack(counts_by_mass_map),
+        daily_epoch,
+    )
 
-        # TODO use np.histogramdd to compute the counts by charge and mass.
-        # Count dust events for each spin phase and mass bin or charge bin.
-        for mass_bin, charge_bin, spin_phase_bin in zip(
-            binned_mass, binned_charge, binned_spin_phase
-        ):
-            counts_by_mass[i, mass_bin, spin_phase_bin] += 1
-            counts_by_charge[i, charge_bin, spin_phase_bin] += 1
 
-    return counts_by_charge, counts_by_mass, daily_epoch
+def compute_rates(
+    counts: np.ndarray, epoch_doy_percent_on: np.ndarray, non_zero_inds: np.ndarray
+) -> np.ndarray:
+    """
+    Compute the count rates given the percent uptime of IDEX.
+
+    Parameters
+    ----------
+    counts : np.ndarray
+        Count values for the dust events.
+    epoch_doy_percent_on : np.ndarray
+        Percentage of time science acquisition was on for each day of the year.
+    non_zero_inds : np.ndarray
+        Indices of the days with non-zero science acquisition percentage.
+
+    Returns
+    -------
+    np.ndarray
+        Count rates.
+    """
+    while len(epoch_doy_percent_on.shape) < len(counts.shape):
+        epoch_doy_percent_on = np.expand_dims(epoch_doy_percent_on, axis=-1)
+
+    return counts[non_zero_inds] / (
+        0.01 * epoch_doy_percent_on[non_zero_inds] * SECONDS_IN_DAY
+    )
 
 
 def compute_rates_by_charge_and_mass(
     counts_by_charge: np.ndarray,
     counts_by_mass: np.ndarray,
+    counts_by_charge_map: np.ndarray,
+    counts_by_mass_map: np.ndarray,
     epoch_doy: np.ndarray,
     daily_on_percentage: dict,
-) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
     """
     Compute the dust event counts rates by charge and mass by spin phase for each day.
 
@@ -299,7 +473,11 @@ def compute_rates_by_charge_and_mass(
     counts_by_charge : np.ndarray
         3D array containing counts by charge and spin phase for each dataset.
     counts_by_mass : np.ndarray
-        3D array containing counts by mass and spin phase for each dataset.
+        3D array containing counts by mass and lon and lat for each dataset.
+    counts_by_charge_map : np.ndarray
+        4D array containing counts by charge and lon and lat for each dataset.
+    counts_by_mass_map : np.ndarray
+        4D array containing counts by mass and spin phase for each dataset.
     epoch_doy : np.ndarray
         Unique days of year corresponding to the epochs in the dataset.
     daily_on_percentage : dict
@@ -314,6 +492,8 @@ def compute_rates_by_charge_and_mass(
     # Initialize arrays to hold rates.
     rate_by_charge = np.full(counts_by_charge.shape, -1.0)
     rate_by_mass = np.full(counts_by_mass.shape, -1.0)
+    rate_by_charge_map = np.full(counts_by_charge_map.shape, -1.0)
+    rate_by_mass_map = np.full(counts_by_mass_map.shape, -1.0)
     # Initialize an array to hold quality flags for each epoch. A quality flag of 0
     # indicates that there was no science acquisition data for that epoch, and the rate
     # is not valid. A quality flag of 1 indicates that the rate is valid.
@@ -336,18 +516,26 @@ def compute_rates_by_charge_and_mass(
     # acquisition time.
     non_zero_inds = np.where(epoch_doy_percent_on > 0)[0]
     # Compute rates only for days with non-zero science acquisition percentage
-    rate_by_charge[non_zero_inds] = counts_by_charge[non_zero_inds] / (
-        0.01
-        * epoch_doy_percent_on[non_zero_inds, np.newaxis, np.newaxis]
-        * SECONDS_IN_DAY
+    rate_by_charge[non_zero_inds] = compute_rates(
+        counts_by_charge, epoch_doy_percent_on, non_zero_inds
+    )
+    rate_by_mass[non_zero_inds] = compute_rates(
+        counts_by_mass, epoch_doy_percent_on, non_zero_inds
+    )
+    rate_by_charge_map[non_zero_inds] = compute_rates(
+        counts_by_charge_map, epoch_doy_percent_on, non_zero_inds
     )
-    rate_by_mass[non_zero_inds] = counts_by_mass[non_zero_inds] / (
-        0.01
-        * epoch_doy_percent_on[non_zero_inds, np.newaxis, np.newaxis]
-        * SECONDS_IN_DAY
+    rate_by_mass_map[non_zero_inds] = compute_rates(
+        counts_by_mass_map, epoch_doy_percent_on, non_zero_inds
     )
 
-    return rate_by_charge, rate_by_mass, rate_quality_flags
+    return (
+        rate_by_charge,
+        rate_by_mass,
+        rate_by_charge_map,
+        rate_by_mass_map,
+        rate_quality_flags,
+    )
 
 
 def bin_spin_phases(spin_phases: xr.DataArray) -> np.ndarray:
@@ -370,7 +558,7 @@ def bin_spin_phases(spin_phases: xr.DataArray) -> np.ndarray:
             f"phase angle range, [0, 360)."
         )
     # Shift spin phases by +45° so that the first bin starts at 0°.
-    # Use mod to wrap values > 360 to 0.
+    # Use mod to wrap values >= 360 to 0.
     shifted_spin_phases = (spin_phases + 45) % 360
     # Use np.digitize to find the bin index for each spin phase.
     bin_indices = np.digitize(shifted_spin_phases, SPIN_PHASE_BIN_EDGES, right=False)
@@ -419,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):
@@ -458,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_apid.py

@@ -13,3 +13,4 @@ class LoAPID(IntEnum):
     ILO_SCI_DE = 706  # Science direct event data
     ILO_STAR = 707  # Science star sensor data, every spin
     ILO_SPIN = 708  # Spin information for each science cycle (28 spins)
+    ILO_DIAG_PCC = 725  # Diagnostic pivot platform information