imap-processing 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

imap_processing/ena_maps/utils/corrections.py

@@ -4,7 +4,23 @@ from pathlib import Path
 
 import numpy as np
 import pandas as pd
+import xarray as xr
 from numpy.polynomial import Polynomial
+from scipy.constants import electron_volt, erg, proton_mass
+
+from imap_processing.ena_maps.ena_maps import LoHiBasePointingSet
+from imap_processing.ena_maps.utils.coordinates import CoordNames
+from imap_processing.spice import geometry
+from imap_processing.spice.time import ttj2000ns_to_et
+
+# Physical constants for Compton-Getting correction
+# Units: electron_volt = [J / eV]
+#        erg = [J / erg]
+# To get [erg / eV], => electron_volt [J / eV] / erg [J / erg] = erg_per_ev [erg / eV]
+ERG_PER_EV = electron_volt / erg  # erg per eV - unit conversion factor
+# Units: proton_mass = [kg]
+# Here, we convert proton_mass to grams
+PROTON_MASS_GRAMS = proton_mass * 1e3  # proton mass in grams
 
 
 class PowerLawFluxCorrector:
@@ -289,3 +305,255 @@ class PowerLawFluxCorrector:
             )
 
         return corrected_flux, corrected_flux_stat_unc
+
+
+def _add_spacecraft_velocity_to_pset(pset: LoHiBasePointingSet) -> None:
+    """
+    Calculate and add spacecraft velocity data to pointing set.
+
+    Parameters
+    ----------
+    pset : LoHiBasePointingSet
+        Pointing set object to be updated.
+
+    Notes
+    -----
+    Adds the following DataArrays to pset.data:
+    - "sc_velocity": Spacecraft velocity vector (km/s) with dims ["x_y_z"]
+    - "sc_direction_vector": Spacecraft velocity unit vector with dims ["x_y_z"]
+    """
+    # Compute ephemeris time (J2000 seconds) of PSET midpoint time
+    # TODO: Use the Pointing midpoint time. Epoch should be start time
+    #     but use it until we can make Lo and Hi PSETs have a consistent
+    #     variable to hold the midpoint time.
+    et = ttj2000ns_to_et(pset.data["epoch"].values[0])
+    # Get spacecraft state in HAE frame
+    sc_state = geometry.imap_state(et, ref_frame=geometry.SpiceFrame.IMAP_HAE)
+    sc_velocity_vector = sc_state[3:6]
+
+    # Store spacecraft velocity as DataArray
+    pset.data["sc_velocity"] = xr.DataArray(
+        sc_velocity_vector, dims=[CoordNames.CARTESIAN_VECTOR.value]
+    )
+
+    # Calculate spacecraft speed and direction
+    sc_velocity_km_per_sec = np.linalg.norm(
+        pset.data["sc_velocity"], axis=-1, keepdims=True
+    )
+    pset.data["sc_direction_vector"] = pset.data["sc_velocity"] / sc_velocity_km_per_sec
+
+
+def _add_cartesian_look_direction(pset: LoHiBasePointingSet) -> None:
+    """
+    Calculate and add look direction vectors to pointing set.
+
+    Parameters
+    ----------
+    pset : LoHiBasePointingSet
+        Pointing set object to be updated.
+
+    Notes
+    -----
+    Adds the following DataArray to pset.data:
+    - "look_direction": Cartesian unit vectors with dims [...spatial_dims, "x_y_z"]
+    """
+    longitudes = pset.data["hae_longitude"]
+    latitudes = pset.data["hae_latitude"]
+
+    # Stack spherical coordinates (r=1 for unit vectors, azimuth, elevation)
+    spherical_coords = np.stack(
+        [
+            np.ones_like(longitudes),  # r = 1 for unit vectors
+            longitudes,  # azimuth = longitude
+            latitudes,  # elevation = latitude
+        ],
+        axis=-1,
+    )
+
+    # Convert to Cartesian coordinates and store as DataArray
+    pset.data["look_direction"] = xr.DataArray(
+        geometry.spherical_to_cartesian(spherical_coords),
+        dims=[*longitudes.dims, CoordNames.CARTESIAN_VECTOR.value],
+    )
+
+
+def _calculate_compton_getting_transform(
+    pset: LoHiBasePointingSet,
+    energy_hf: xr.DataArray,
+) -> None:
+    """
+    Apply Compton-Getting transformation to compute ENA source directions.
+
+    This implements the Compton-Getting velocity transformation to correct
+    for the motion of the spacecraft through the heliosphere. The transformation
+    accounts for the Doppler shift of ENA energies and the aberration of
+    arrival directions.
+
+    All calculations are performed using xarray DataArrays to preserve
+    dimension information throughout the computation.
+
+    Parameters
+    ----------
+    pset : LoHiBasePointingSet
+        Pointing set object with sc_velocity, sc_direction_vector, and
+        look_direction already added.
+    energy_hf : xr.DataArray
+        ENA energies in the heliosphere frame in eV.
+
+    Notes
+    -----
+    The algorithm is based on the "Appendix A. The IMAP-Lo Mapping Algorithms"
+    document.
+    Adds the following DataArrays to pset.data:
+    - "energy_sc": ENA energies in spacecraft frame (eV)
+    - "ena_source_hae_longitude": ENA source longitudes in heliosphere frame (degrees)
+    - "ena_source_hae_latitude": ENA source latitudes in heliosphere frame (degrees)
+    """
+    # Store heliosphere frame energies
+    pset.data["energy_hf"] = energy_hf
+
+    # Calculate spacecraft speed
+    sc_velocity_km_per_sec = np.linalg.norm(
+        pset.data["sc_velocity"], axis=-1, keepdims=True
+    )
+
+    # Calculate dot product between look directions and spacecraft direction vector
+    # Use Einstein summation for efficient vectorized dot product
+    dot_product = xr.DataArray(
+        np.einsum(
+            "...i,...i->...",
+            pset.data["look_direction"],
+            pset.data["sc_direction_vector"],
+        ),
+        dims=pset.data["look_direction"].dims[:-1],
+    )
+
+    # Calculate the kinetic energy of a hydrogen ENA traveling at spacecraft velocity
+    # E_u = (1/2) * m * U_sc^2 (convert km/s to cm/s with 1.0e5 factor)
+    energy_u = (
+        0.5 * PROTON_MASS_GRAMS * (sc_velocity_km_per_sec * 1e5) ** 2 / ERG_PER_EV
+    )
+
+    # Note: Tim thinks that this approach seems backwards. Here, we are assuming
+    #     that ENAs are observed in the heliosphere frame at the ESA energy levels.
+    #     We then calculate the velocity that said ENAs would have in the spacecraft
+    #     frame as well as the CG corrected energy level in the spacecraft frame.
+    #     We then use this velocity to calculate and the velocity of the spacecraft
+    #     to do the vector math which determines the ENA source direction in the
+    #     heliosphere frame.
+    #     The ENAs are in fact observed in the spacecraft frame at a known energy
+    #     level in the spacecraft frame. Why don't we use that energy level to
+    #     calculate the source direction in the spacecraft frame and then do the
+    #     vector math to find the source direction in the heliosphere frame? We
+    #     would also need to calculate the CG corrected ENA energy in the heliosphere
+    #     frame and keep track of that when binning.
+
+    # Calculate y values for each energy level (Equation 61)
+    # y_k = sqrt(E^h_k / E^u)
+    y = np.sqrt(pset.data["energy_hf"] / energy_u)
+
+    # Velocity magnitude factor calculation (Equation 62)
+    # x_k = (êₛ · û_sc) + sqrt(y² + (êₛ · û_sc)² - 1)
+    x = dot_product + np.sqrt(y**2 + dot_product**2 - 1)
+
+    # Calculate ENA speed in the spacecraft frame
+    # |v⃗_sc| = x_k * U_sc
+    velocity_sc = x * sc_velocity_km_per_sec
+
+    # Calculate the kinetic energy in the spacecraft frame
+    # E_sc = (1/2) * M_p * v_sc² (convert km/s to cm/s with 1.0e5 factor)
+    pset.data["energy_sc"] = (
+        0.5 * PROTON_MASS_GRAMS * (velocity_sc * 1e5) ** 2 / ERG_PER_EV
+    )
+
+    # Calculate the velocity vector in the spacecraft frame
+    # v⃗_sc = |v_sc| * êₛ (velocity direction follows look direction)
+    velocity_vector_sc = velocity_sc * pset.data["look_direction"]
+
+    # Calculate the ENA velocity vector in the heliosphere frame
+    # v⃗_helio = v⃗_sc - U⃗_sc (simple velocity addition)
+    velocity_vector_helio = velocity_vector_sc - pset.data["sc_velocity"]
+
+    # Convert to spherical coordinates to get ENA source directions
+    ena_source_direction_helio = geometry.cartesian_to_spherical(
+        velocity_vector_helio.data
+    )
+
+    # Update the PSET hae_longitude and hae_latitude variables with the new
+    # energy-dependent values.
+    pset.data["hae_longitude"] = (
+        pset.data["energy_sc"].dims,
+        ena_source_direction_helio[..., 1],
+    )
+    pset.data["hae_latitude"] = (
+        pset.data["energy_sc"].dims,
+        ena_source_direction_helio[..., 2],
+    )
+
+    # For ram/anti-ram filtering we can use the sign of the scalar projection
+    # of the ENA source direction onto the spacecraft velocity vector.
+    # ram_mask = (v⃗_helio · û_sc) >= 0
+    ram_mask = (
+        np.einsum(
+            "...i,...i->...", velocity_vector_helio, pset.data["sc_direction_vector"]
+        )
+        >= 0
+    )
+    pset.data["ram_mask"] = xr.DataArray(
+        ram_mask,
+        dims=velocity_vector_helio.dims[:-1],
+    )
+
+
+def apply_compton_getting_correction(
+    pset: LoHiBasePointingSet,
+    energy_hf: xr.DataArray,
+) -> None:
+    """
+    Apply Compton-Getting correction to a pointing set and update coordinates.
+
+    This function performs the Compton-Getting velocity transformation to correct
+    ENA observations for the motion of the spacecraft through the heliosphere.
+    The corrected coordinates represent the true source directions of the ENAs
+    in the heliosphere frame.
+
+    The pointing set is modified in-place: new variables are added to the dataset
+    for the corrected coordinates and energies, and the az_el_points attribute
+    is updated to use the corrected coordinates for binning.
+
+    All calculations are performed using xarray DataArrays to preserve dimension
+    information throughout the computation.
+
+    Parameters
+    ----------
+    pset : LoHiBasePointingSet
+        Pointing set object containing HAE longitude/latitude coordinates.
+    energy_hf : xr.DataArray
+        ENA energies in the heliosphere frame in eV. Must be 1D with an
+        energy dimension.
+
+    Notes
+    -----
+    This function adds the following variables to the pointing set dataset:
+    - "sc_velocity": Spacecraft velocity vector (km/s)
+    - "sc_direction_vector": Spacecraft velocity unit vector
+    - "look_direction": Cartesian unit vectors of observation directions
+    - "energy_hf": ENA energies in heliosphere frame (eV)
+    - "energy_sc": ENA energies in spacecraft frame (eV)
+    - "ena_source_hae_longitude": ENA source longitudes in heliosphere frame (degrees)
+    - "ena_source_hae_latitude": ENA source latitudes in heliosphere frame (degrees)
+
+    The az_el_points attribute is updated to use the corrected coordinates,
+    which will be used for subsequent binning operations.
+    """
+    # Step 1: Add spacecraft velocity and direction to pset
+    _add_spacecraft_velocity_to_pset(pset)
+
+    # Step 2: Calculate and add look direction vectors to pset
+    _add_cartesian_look_direction(pset)
+
+    # Step 3: Apply Compton-Getting transformation
+    _calculate_compton_getting_transform(pset, energy_hf)
+
+    # Step 4: Update az_el_points to use the corrected coordinates
+    pset.update_az_el_points()

imap_processing/ena_maps/utils/map_utils.py

@@ -10,6 +10,89 @@ from numpy.typing import NDArray
 logger = logging.getLogger(__name__)
 
 
+def vectorized_bincount(
+    indices: NDArray, weights: NDArray | None = None, minlength: int = 0
+) -> NDArray:
+    """
+    Vectorized version of np.bincount for multi-dimensional arrays.
+
+    This function applies np.bincount across multi-dimensional input arrays by
+    adding offsets to the indices and flattening, then reshaping the result.
+    This approach allows broadcasting between indices and weights.
+
+    Parameters
+    ----------
+    indices : NDArray
+        Array of non-negative integers to be binned. Can be multi-dimensional.
+        If multi-dimensional, bincount is applied independently along each
+        leading dimension.
+    weights : NDArray, optional
+        Array of weights that is broadcastable with indices. If provided, each
+        weight is accumulated into its corresponding bin. If None (default),
+        each index contributes a count of 1.
+    minlength : int, optional
+        Minimum number of bins in the output array. Applied to each independent
+        bincount operation. Default is 0.
+
+    Returns
+    -------
+    NDArray
+        Array of binned values with the same leading dimensions as the input
+        arrays, and a final dimension of size minlength (or the maximum index + 1,
+        whichever is larger).
+
+    See Also
+    --------
+    numpy.bincount : The underlying function being vectorized.
+
+    Examples
+    --------
+    >>> indices = np.array([[0, 1, 1], [2, 2, 3]])
+    >>> vectorized_bincount(indices, minlength=4)
+    array([[1., 2., 0., 0.],
+           [0., 0., 2., 1.]])
+    """
+    # Handle 1D case directly
+    if indices.ndim == 1 and (weights is None or weights.ndim == 1):
+        return np.bincount(indices, weights=weights, minlength=minlength)
+
+    # For multi-dimensional arrays, broadcast indices and weights
+    if weights is not None:
+        indices_bc, weights_bc = np.broadcast_arrays(indices, weights)
+        weights_flat = weights_bc.ravel()
+    else:
+        indices_bc = indices
+        weights_flat = None
+
+    # Get the shape for reshaping output
+    non_spatial_shape = indices_bc.shape[:-1]
+    n_binsets = np.prod(non_spatial_shape)
+
+    # Determine actual minlength if not specified
+    if minlength == 0:
+        minlength = int(np.max(indices_bc)) + 1
+
+    # We want to flatten the multi-dimensional bincount problem into a 1D problem.
+    # This can be done by offsetting the indices for each element of each additional
+    # dimension by an integer multiple of the number of bins. Doing so gives
+    # each element in the additional dimensions its own set of 1D bins: index 0
+    # uses bins [0, minlength), index 1 uses bins [minlength, 2*minlength), etc.
+    offsets = np.arange(n_binsets).reshape(*non_spatial_shape, 1) * minlength
+    indices_flat = (indices_bc + offsets).ravel()
+
+    # Single bincount call with flattened data
+    binned_flat = np.bincount(
+        indices_flat, weights=weights_flat, minlength=n_binsets * minlength
+    )
+
+    # Reshape to separate each sample's bins
+    binned_values = binned_flat.reshape(n_binsets, -1)[:, :minlength].reshape(
+        *non_spatial_shape, minlength
+    )
+
+    return binned_values
+
+
 def bin_single_array_at_indices(
     value_array: NDArray,
     projection_grid_shape: tuple[int, ...],
@@ -25,7 +108,7 @@ def bin_single_array_at_indices(
     Parameters
     ----------
     value_array : NDArray
-        Array of values to bin. The final axis be the one and only spatial axis.
+        Array of values to bin. The final axis is the one and only spatial axis.
         If other axes are present, they will be binned independently
         along the spatial axis.
     projection_grid_shape : tuple[int, ...]
@@ -34,71 +117,89 @@ def bin_single_array_at_indices(
         or just (number of bins,) if the grid is 1D.
     projection_indices : NDArray
         Ordered indices for projection grid, corresponding to indices in input grid.
-        1 dimensional. May be non-unique, depending on the projection method.
+        Can be 1-dimensional or multi-dimensional. If multi-dimensional, must be
+        broadcastable with value_array. May contain non-unique indices, depending
+        on the projection method.
     input_indices : NDArray
         Ordered indices for input grid, corresponding to indices in projection grid.
         1 dimensional. May be non-unique, depending on the projection method.
-        If None (default), an arange of the same length as the
-        final axis of value_array is used.
+        If None (default), an numpy.arange of the same length as the final axis of
+        value_array is used.
     input_valid_mask : NDArray, optional
         Boolean mask array for valid values in input grid.
         If None, all pixels are considered valid. Default is None.
+        Must be broadcastable with value_array and projection_indices.
 
     Returns
     -------
     NDArray
-        Binned values on the projection grid.
+        Binned values on the projection grid. The output shape depends on the
+        input shapes after broadcasting:
+        - If value_array is 1D: returns 1D array of shape (num_projection_indices,)
+        - If value_array is multi-dimensional: returns array with shape
+          (*value_array.shape[:-1], num_projection_indices), where the leading
+          dimensions match value_array's non-spatial dimensions and the final
+          dimension contains the binned values for each projection grid position.
+        - If projection_indices is multi-dimensional and broadcasts with value_array,
+          the output shape will be (broadcasted_shape[:-1], num_projection_indices).
 
     Raises
     ------
     ValueError
-        If the input and projection indices are not 1D arrays
-        with the same number of elements.
-    NotImplementedError
-        If the input value_array has dimensionality less than 1.
+        If input_indices is not a 1D array, or if the arrays cannot be
+        broadcast together.
     """
+    # Set and check input_indices
     if input_indices is None:
         input_indices = np.arange(value_array.shape[-1])
-    if input_valid_mask is None:
-        input_valid_mask = np.ones(value_array.shape[-1], dtype=bool)
-
-    # Both sets of indices must be 1D with the same number of elements
-    if input_indices.ndim != 1 or projection_indices.ndim != 1:
+    # input_indices must be 1D
+    if input_indices.ndim != 1:
         raise ValueError(
-            "Indices must be 1D arrays. "
+            "input_indices must be a 1D array. "
             "If using a rectangular grid, the indices must be unwrapped."
         )
-    if input_indices.size != projection_indices.size:
-        raise ValueError(
-            "The number of input and projection indices must be the same. \n"
-            f"Received {input_indices.size} input indices and {projection_indices.size}"
-            " projection indices."
+
+    # Verify projection_indices is broadcastable with value_array
+    try:
+        broadcasted_shape = np.broadcast_shapes(
+            projection_indices.shape, value_array.shape
         )
+    except ValueError as e:
+        raise ValueError(
+            f"projection_indices shape {projection_indices.shape} must be "
+            f"broadcastable with value_array shape {value_array.shape}"
+        ) from e
 
-    input_valid_mask = np.asarray(input_valid_mask, dtype=bool)
-    mask_idx = input_valid_mask[input_indices]
+    # Set and check input_valid_mask
+    if input_valid_mask is None:
+        input_valid_mask = np.ones(value_array.shape[-1], dtype=bool)
+    else:
+        input_valid_mask = np.asarray(input_valid_mask, dtype=bool)
+    # Verify input_valid_mask is broadcastable with value_array
+    try:
+        np.broadcast_shapes(input_valid_mask.shape, value_array.shape)
+    except ValueError as e:
+        raise ValueError(
+            f"input_valid_mask shape {input_valid_mask.shape} must be "
+            f"broadcastable with value_array shape {value_array.shape}"
+        ) from e
 
-    num_projection_indices = np.prod(projection_grid_shape)
+    # Broadcast input_valid_mask to match value_array shape if needed
+    input_valid_mask_bc = np.broadcast_to(input_valid_mask, broadcasted_shape)
+
+    # Select values at input_indices positions along the spatial axis
+    values = value_array[..., input_indices]
+
+    # Apply mask: set invalid values to 0
+    values_masked = np.where(input_valid_mask_bc, values, 0)
+
+    num_projection_indices = int(np.prod(projection_grid_shape))
+
+    # Use vectorized_bincount to handle arbitrary dimensions
+    binned_values = vectorized_bincount(
+        projection_indices, weights=values_masked, minlength=num_projection_indices
+    )
 
-    # Only valid values are summed into bins.
-    if value_array.ndim == 1:
-        values = value_array[input_indices]
-        binned_values = np.bincount(
-            projection_indices[mask_idx],
-            weights=values[mask_idx],
-            minlength=num_projection_indices,
-        )
-    elif value_array.ndim >= 2:
-        # Apply bincount to each row independently
-        binned_values = np.apply_along_axis(
-            lambda x: np.bincount(
-                projection_indices[mask_idx],
-                weights=x[..., input_indices][mask_idx],
-                minlength=num_projection_indices,
-            ),
-            axis=-1,
-            arr=value_array,
-        )
     return binned_values
 
 

imap_processing/hi/hi_l2.py

@@ -323,20 +323,15 @@ def combine_calibration_products(
     # Perform inverse-variance weighted averaging
     # Handle divide by zero and invalid values
     with np.errstate(divide="ignore", invalid="ignore"):
-        # Calculate weights for statistical variance combination using only
-        # statistical variance
-        stat_weights = 1.0 / improved_stat_variance
-
-        # Combined statistical uncertainty from inverse-variance formula
-        combined_stat_unc = np.sqrt(1.0 / stat_weights.sum(dim="calibration_prod"))
-
         # Use total variance weights for flux combination
         flux_weights = 1.0 / total_variance
         weighted_flux_sum = (ena_flux * flux_weights).sum(dim="calibration_prod")
         combined_flux = weighted_flux_sum / flux_weights.sum(dim="calibration_prod")
 
     map_ds["ena_intensity"] = combined_flux
-    map_ds["ena_intensity_stat_uncert"] = combined_stat_unc
+    map_ds["ena_intensity_stat_uncert"] = np.sqrt(
+        (map_ds["ena_intensity_stat_uncert"] ** 2).sum(dim="calibration_prod")
+    )
     # For systematic error, just do quadrature sum over the systematic error for
     # each calibration product.
     map_ds["ena_intensity_sys_err"] = np.sqrt((sys_err**2).sum(dim="calibration_prod"))

imap_processing/ialirt/constants.py

@@ -65,5 +65,11 @@ STATIONS = {
         latitude=54.2632,  # degrees North
         altitude=0.1,  # approx 100 meters
         min_elevation_deg=5,  # 5 degrees is the requirement
-    )
+    ),
+    "Manaus": StationProperties(
+        longitude=-59.969334,  # degrees East (negative = West)
+        latitude=-2.891257,  # degrees North (negative = South)
+        altitude=0.1,  # approx 100 meters
+        min_elevation_deg=5,  # 5 degrees is the requirement
+    ),
 }

imap_processing/ialirt/generate_coverage.py

@@ -77,7 +77,7 @@ def generate_coverage(
                 dsn_outage_mask |= (time_range >= start_et) & (time_range <= end_et)
 
     for station_name, (lon, lat, alt, min_elevation) in stations.items():
-        azimuth, elevation = calculate_azimuth_and_elevation(lon, lat, alt, time_range)
+        _azimuth, elevation = calculate_azimuth_and_elevation(lon, lat, alt, time_range)
         visible = elevation > min_elevation
 
         outage_mask = np.zeros(time_range.shape, dtype=bool)

imap_processing/ialirt/l0/process_codice.py

@@ -4,11 +4,56 @@ import logging
 from decimal import Decimal
 from typing import Any
 
+import numpy as np
 import xarray as xr
 
+from imap_processing.codice import decompress
+from imap_processing.ialirt.utils.grouping import find_groups
+
 logger = logging.getLogger(__name__)
 
+FILLVAL_UINT8 = 255
 FILLVAL_FLOAT32 = Decimal(str(-1.0e31))
+COD_LO_COUNTER = 232
+COD_HI_COUNTER = 197
+COD_LO_RANGE = range(0, 15)
+COD_HI_RANGE = range(0, 5)
+
+
+def concatenate_bytes(grouped_data: xr.Dataset, group: int, sensor: str) -> bytearray:
+    """
+    Concatenate all data fields for a specific group into a single bytearray.
+
+    Parameters
+    ----------
+    grouped_data : xr.Dataset
+        The grouped CoDICE dataset containing cod_{sensor}_data_XX variables.
+    group : int
+        The group number to extract.
+    sensor : str
+        The sensor type, either 'lo' or 'hi'.
+
+    Returns
+    -------
+    current_data_stream: bytearray
+        The concatenated data stream for the selected group.
+    """
+    current_data_stream = bytearray()
+    group_mask = (grouped_data["group"] == group).values
+
+    cod_ranges = {
+        "lo": COD_LO_RANGE,
+        "hi": COD_HI_RANGE,
+    }
+
+    # Loop through all data fields.
+    for field in cod_ranges[sensor]:
+        data_array = grouped_data[f"cod_{sensor}_data_{field:02}"].values[group_mask]
+
+        # Convert each value to uint8 and extend the byte stream
+        current_data_stream.extend(np.uint8(data_array).tobytes())
+
+    return current_data_stream
 
 
 def process_codice(
@@ -35,6 +80,27 @@ def process_codice(
     - Calculate L2 CoDICE pseudodensities (pg 37 of Algorithm Document)
     - Calculate the public data products
     """
+    grouped_cod_lo_data = find_groups(
+        dataset, (0, COD_LO_COUNTER), "cod_lo_counter", "cod_lo_acq"
+    )
+    grouped_cod_hi_data = find_groups(
+        dataset, (0, COD_HI_COUNTER), "cod_hi_counter", "cod_hi_acq"
+    )
+    unique_cod_lo_groups = np.unique(grouped_cod_lo_data["group"])
+    unique_cod_hi_groups = np.unique(grouped_cod_hi_data["group"])
+
+    for group in unique_cod_lo_groups:
+        cod_lo_data_stream = concatenate_bytes(grouped_cod_lo_data, group, "lo")
+
+        # Decompress binary stream
+        decompressed_data = decompress._apply_pack_24_bit(bytes(cod_lo_data_stream))
+
+    for group in unique_cod_hi_groups:
+        cod_hi_data_stream = concatenate_bytes(grouped_cod_hi_data, group, "lo")
+
+        # Decompress binary stream
+        decompressed_data = decompress._apply_lossy_a(bytes(cod_hi_data_stream))  # noqa
+
     # For I-ALiRT SIT, the test data being used has all zeros and thus no
     # groups can be found, thus there is no data to process
     # TODO: Once I-ALiRT test data is acquired that actually has data in it,

imap_processing/ialirt/utils/create_xarray.py

@@ -155,6 +155,7 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
                 "sc_velocity_GSM",
                 "sc_velocity_GSE",
                 "mag_hk_status",
+                "spice_kernels",
             ]:
                 continue
             elif key in ["mag_B_GSE", "mag_B_GSM", "mag_B_RTN"]:

imap_processing/idex/idex_l2a.py

@@ -118,7 +118,7 @@ def idex_l2a(l1b_dataset: xr.Dataset, ancillary_files: dict) -> xr.Dataset:
     atomic_masses_path = f"{imap_module_directory}/idex/atomic_masses.csv"
     atomic_masses = pd.read_csv(atomic_masses_path)
     masses = atomic_masses["Mass"]
-    stretches, shifts, mass_scales = time_to_mass(tof_high.data, hs_time.data, masses)
+    _stretches, _shifts, mass_scales = time_to_mass(tof_high.data, hs_time.data, masses)
 
     # TODO use correct fillval
     mass_scales_da = xr.DataArray(
@@ -379,7 +379,7 @@ def log_smooth_powerlaw(log_v: float, log_a: float, params: np.ndarray) -> float
     # segments.
     # vb and vc are the characteristic speeds where the slope transition happens, and k
     # setting the sharpness of the transitions.
-    a1, a2, a3, vb, vc, k, m = params
+    a1, a2, a3, vb, vc, _k, m = params
     v = 10**log_v
     base = log_a + a1 * log_v
     transition1 = (1 + (v / vb) ** m) ** ((a2 - a1) / m)

imap_processing/idex/idex_l2b.py

@@ -645,7 +645,7 @@ def get_science_acquisition_on_percentage(evt_dataset: xr.Dataset) -> dict:
          of year.
     """
     # Get science acquisition start and stop times
-    evt_logs, evt_time, evt_values = get_science_acquisition_timestamps(evt_dataset)
+    _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 "