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

imap_processing/codice/data/lo_stepping_values.csv

@@ -1,4 +1,4 @@
-table_num,row_num,num_reps,store_data,e1,e2,e3,e4,e5,e6,e7,e8,acq_time
+table_num,half_spin_num,num_reps,store_data,e1,e2,e3,e4,e5,e6,e7,e8,acq_time
 0,0,1,12,0,-,-,-,-,-,-,-,578.708333
 0,1,1,12,1,-,-,-,-,-,-,-,578.708333
 0,2,1,12,2,-,-,-,-,-,-,-,578.708333

imap_processing/decom.py

@@ -6,14 +6,11 @@ to decommutate CCSDS packet data using a given XTCE packet definition.
 """
 
 from pathlib import Path
-from typing import Union
 
 from space_packet_parser import definitions
 
 
-def decom_packets(
-    packet_file: Union[str, Path], xtce_packet_definition: Union[str, Path]
-) -> list:
+def decom_packets(packet_file: str | Path, xtce_packet_definition: str | Path) -> list:
     """
     Unpack CCSDS data packet.
 

imap_processing/ena_maps/ena_maps.py

@@ -412,6 +412,7 @@ class RectangularPointingSet(PointingSet):
         for dim, constructed_bins in zip(
             [CoordNames.AZIMUTH_L1C.value, CoordNames.ELEVATION_L1C.value],
             [self.sky_grid.az_bin_midpoints, self.sky_grid.el_bin_midpoints],
+            strict=False,
         ):
             if not np.allclose(
                 sorted(constructed_bins),
@@ -522,6 +523,7 @@ class UltraPointingSet(HealpixPointingSet):
         for dim, constructed_bins in zip(
             [CoordNames.AZIMUTH_L1C.value, CoordNames.ELEVATION_L1C.value],
             [azimuth_pixel_center, elevation_pixel_center],
+            strict=False,
         ):
             if not np.allclose(
                 self.data[dim],
@@ -590,13 +592,31 @@ class HiPointingSet(PointingSet):
 
     Parameters
     ----------
-    dataset : xarray.Dataset
-        Hi L1C pointing set data loaded in an xarray.DataArray.
+    dataset : xarray.Dataset | str | Path
+        Hi L1C pointing set data loaded in a xarray.DataArray.
+    spin_phase : str
+        Include ENAs from "full", "ram" or "anti-ram" phases of the spin.
     """
 
-    def __init__(self, dataset: xr.Dataset):
+    def __init__(self, dataset: xr.Dataset | str | Path, spin_phase: str):
         super().__init__(dataset, spice_reference_frame=geometry.SpiceFrame.ECLIPJ2000)
 
+        # Filter out ENAs from non-selected portions of the spin.
+        if spin_phase not in ["full", "ram", "anti-ram"]:
+            raise ValueError(f"Unrecognized spin_phase value: {spin_phase}.")
+        # ram only includes spin-phase interval [0, 0.5)
+        # which is the first half of the spin_angle_bins
+        elif spin_phase == "ram":
+            self.data = self.data.isel(
+                spin_angle_bin=slice(0, self.data["spin_angle_bin"].data.size // 2)
+            )
+        # anti-ram includes spin-phase interval [0.5, 1)
+        # which is the second half of the spin_angle_bins
+        elif spin_phase == "anti-ram":
+            self.data = self.data.isel(
+                spin_angle_bin=slice(self.data["spin_angle_bin"].data.size // 2, None)
+            )
+
         # Rename some PSET vars to match L2 variables
         self.data = self.data.rename(
             {
@@ -631,29 +651,16 @@ class LoPointingSet(PointingSet):
     """
 
     def __init__(self, dataset: xr.Dataset):
-        super().__init__(dataset, spice_reference_frame=geometry.SpiceFrame.IMAP_DPS)
-        # TODO: Use spatial_utils.az_el_grid instead of
-        #  manually creating the lon/lat values
-        inferred_spacing_deg = 360 / dataset.longitude.size
-        longitude_bin_centers = np.arange(
-            0 + inferred_spacing_deg / 2, 360, inferred_spacing_deg
-        )
-        latitude_bin_centers = np.arange(
-            -2 + inferred_spacing_deg / 2, 2, inferred_spacing_deg
-        )
+        super().__init__(dataset, spice_reference_frame=geometry.SpiceFrame.IMAP_HAE)
 
-        # Could be wrong about the order here
-        longitude_grid, latitude_grid = np.meshgrid(
-            longitude_bin_centers,
-            latitude_bin_centers,
-            indexing="ij",
+        # The HAE centers are stored in the pset as (1, 3600, 40) arrays
+        self.az_el_points = np.column_stack(
+            (
+                np.squeeze(self.data["hae_longitude"]).values.ravel(),
+                np.squeeze(self.data["hae_latitude"]).values.ravel(),
+            )
         )
-
-        longitude = longitude_grid.ravel()
-        latitude = latitude_grid.ravel()
-
-        self.az_el_points = np.column_stack((longitude, latitude))
-        self.spatial_coords = ("longitude", "latitude")
+        self.spatial_coords = ("spin_angle", "off_angle")
 
 
 # Define the Map classes
@@ -761,6 +768,7 @@ class AbstractSkyMap(ABC):
         pointing_set: PointingSet,
         value_keys: list[str] | None = None,
         index_match_method: IndexMatchMethod = IndexMatchMethod.PUSH,
+        pset_valid_mask: NDArray | None = None,
     ) -> None:
         """
         Project a pointing set's values to the map grid.
@@ -782,6 +790,10 @@ class AbstractSkyMap(ABC):
         index_match_method : IndexMatchMethod, optional
             The method of index matching to use for all values.
             Default is IndexMatchMethod.PUSH.
+        pset_valid_mask : NDArray, optional
+            A boolean mask of shape (number of pointing set pixels,) indicating
+            which pixels in the pointing set should be considered valid for projection.
+            If None, all pixels are considered valid. Default is None.
 
         Raises
         ------
@@ -794,6 +806,9 @@ class AbstractSkyMap(ABC):
             if value_key not in pointing_set.data.data_vars:
                 raise ValueError(f"Value key {value_key} not found in pointing set.")
 
+        if pset_valid_mask is None:
+            pset_valid_mask = np.ones(pointing_set.num_points, dtype=bool)
+
         if index_match_method is IndexMatchMethod.PUSH:
             # Determine the indices of the sky map grid that correspond to
             # each pixel in the pointing set.
@@ -853,22 +868,32 @@ class AbstractSkyMap(ABC):
                     value_array=raveled_pset_data,
                     projection_grid_shape=self.binning_grid_shape,
                     projection_indices=matched_indices_push,
+                    input_valid_mask=pset_valid_mask,
                 )
+                # TODO: we may need to allow for unweighted/weighted means here by
+                # dividing pointing_projected_values by some binned weights.
+                # For unweighted means, we could use the number of pointing set pixels
+                # that correspond to each map pixel as the weights.
+                self.data_1d[value_key] += pointing_projected_values
             elif index_match_method is IndexMatchMethod.PULL:
+                valid_map_mask = pset_valid_mask[matched_indices_pull]
                 # We know that there will only be one value per sky map pixel,
                 # so we can use the matched indices directly
-                pointing_projected_values = raveled_pset_data[..., matched_indices_pull]
+                pointing_projected_values = raveled_pset_data[
+                    ..., matched_indices_pull[valid_map_mask]
+                ]
+                # TODO: we may need to allow for unweighted/weighted means here by
+                # dividing pointing_projected_values by some binned weights.
+                # For unweighted means, we could use the number of pointing set pixels
+                # that correspond to each map pixel as the weights.
+                self.data_1d[value_key].values[..., valid_map_mask] += (
+                    pointing_projected_values
+                )
             else:
                 raise NotImplementedError(
                     "Only PUSH and PULL index matching methods are supported."
                 )
 
-            # TODO: we may need to allow for unweighted/weighted means here by
-            # dividing pointing_projected_values by some binned weights.
-            # For unweighted means, we could use the number of pointing set pixels
-            # that correspond to each map pixel as the weights.
-            self.data_1d[value_key] += pointing_projected_values
-
         # TODO: The max epoch needs to include the pset duration. Right now it
         #     is just capturing the start epoch. See issue #1747
         self.min_epoch = min(self.min_epoch, pointing_set.epoch)
@@ -1162,6 +1187,10 @@ class RectangularSkyMap(AbstractSkyMap):
         # Rewrap each data array in the data_1d to the original 2D grid shape
         rewrapped_data = {}
         for key in self.data_1d.data_vars:
+            # Don't rewrap non-spatial variables
+            if CoordNames.GENERIC_PIXEL.value not in self.data_1d[key].coords:
+                rewrapped_data[key] = self.data_1d[key]
+                continue
             # drop pixel dim from the end, and add the spatial coords as dims
             rewrapped_dims = [
                 dim
@@ -1267,18 +1296,17 @@ class RectangularSkyMap(AbstractSkyMap):
                     name=f"{coord_name}_delta",
                     dims=[coord_name],
                 )
-            # Add energy delta_minus and delta_plus variables
             elif coord_name == CoordNames.ENERGY_L2.value:
-                cdf_ds[f"{coord_name}_delta_minus"] = xr.DataArray(
-                    xr.full_like(cdf_ds[coord_name], np.nan),
-                    name=f"{coord_name}_delta",
-                    dims=[coord_name],
-                )
-                cdf_ds[f"{coord_name}_delta_plus"] = xr.DataArray(
-                    xr.full_like(cdf_ds[coord_name], np.nan),
-                    name=f"{coord_name}_delta",
-                    dims=[coord_name],
-                )
+                if f"{coord_name}_delta_minus" not in cdf_ds:
+                    raise KeyError(
+                        f"Required variable '{coord_name}_delta_minus' "
+                        f"not found in cdf Dataset."
+                    )
+                if f"{coord_name}_delta_plus" not in cdf_ds:
+                    raise KeyError(
+                        f"Required variable '{coord_name}_delta_plus' "
+                        f"not found in cdf Dataset."
+                    )
 
         # Object which holds CDF attributes for the map
         cdf_attrs = ImapCdfAttributes()
@@ -1748,7 +1776,7 @@ class HealpixSkyMap(AbstractSkyMap):
             # into two lists, then convert both to numpy arrays
             # and move the pixel dim to the last dim of values
             interpolated_data_by_rect_pixel, subdiv_depth_of_value_by_pixel = zip(
-                *best_value_and_recursion_depth_by_pixel
+                *best_value_and_recursion_depth_by_pixel, strict=False
             )
             interpolated_data_by_rect_pixel = np.moveaxis(
                 np.array(interpolated_data_by_rect_pixel), 0, -1

imap_processing/ena_maps/utils/corrections.py

@@ -0,0 +1,291 @@
+"""L2 corrections common to multiple IMAP ENA instruments."""
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from numpy.polynomial import Polynomial
+
+
+class PowerLawFluxCorrector:
+    """
+    IMAP-Lo flux correction algorithm implementation.
+
+    Based on Section 5 of the Mapping Algorithm Document. Applies corrections for
+    ESA transmission integration over energy bandpass using iterative
+    predictor-corrector scheme to estimate source fluxes from observed fluxes.
+
+    Parameters
+    ----------
+    coeffs_file : str or Path
+        Location of CSV file containing ESA transmission coefficients.
+    """
+
+    def __init__(self, coeffs_file: str | Path):
+        """Initialize PowerLawFluxCorrector."""
+        # Load the csv file
+        eta_coeffs_df = pd.read_csv(coeffs_file, index_col="esa_step")
+        # Create a lookup dictionary to get the correct np.polynomial.Polynomial
+        # for a given esa_step
+        coeff_columns = ["M0", "M1", "M2", "M3", "M4", "M5"]
+        self.polynomial_lookup = {
+            row.name: Polynomial(row[coeff_columns].values)
+            for _, row in eta_coeffs_df.iterrows()
+        }
+
+    def eta_esa(self, k: np.ndarray, gamma: np.ndarray) -> np.ndarray:
+        """
+        Calculate ESA transmission scale factor η_esa,k(γ) for each energy level.
+
+        Parameters
+        ----------
+        k : np.ndarray
+            Energy levels.
+        gamma : np.ndarray
+            Power-law slopes.
+
+        Returns
+        -------
+        np.ndarray
+            ESA transmission scale factors.
+        """
+        k = np.atleast_1d(k)
+        gamma = np.atleast_1d(gamma)
+        eta = np.empty_like(gamma)
+        for i, esa_step in enumerate(k):
+            eta[i] = self.polynomial_lookup[esa_step](gamma[i])
+            # Negative transmissions get set to 1
+            if eta[i] < 0:
+                eta[i] = 1
+
+        return eta
+
+    @staticmethod
+    def estimate_power_law_slope(
+        fluxes: np.ndarray,
+        energies: np.ndarray,
+        uncertainties: np.ndarray | None = None,
+    ) -> tuple[np.ndarray, np.ndarray | None]:
+        """
+        Estimate power-law slopes γ_k for each energy level using vectorized operations.
+
+        Implements equations (36)-(41) from the Mapping Algorithm Document v7
+        with proper boundary handling. Uses extended arrays with repeated
+        endpoints for unified calculation, and handles zero fluxes by falling
+        back to linear differencing or returning NaN where both central and
+        linear differencing fail.
+
+        Parameters
+        ----------
+        fluxes : np.ndarray
+            Array of differential fluxes [J_1, J_2, ..., J_7].
+        energies : np.ndarray
+            Array of energy levels [E_1, E_2, ..., E_7].
+        uncertainties : np.ndarray, optional
+            Array of flux uncertainties [δJ_1, δJ_2, ..., δJ_7].
+
+        Returns
+        -------
+        gamma : np.ndarray
+            Array of power-law slopes.
+        delta_gamma : np.ndarray or None
+            Array of uncertainty slopes (if uncertainties provided).
+        """
+        n_levels = len(fluxes)
+        gamma = np.full(n_levels, 0, dtype=float)
+        delta_gamma = (
+            np.full(n_levels, 0, dtype=float) if uncertainties is not None else None
+        )
+
+        # Create an array of indices that can be used to create a padded array where
+        # the padding duplicates the first element on the front and the last element
+        # on the end of the array
+        extended_inds = np.pad(np.arange(n_levels), 1, mode="edge")
+
+        # Compute logs, setting non-positive fluxes to NaN
+        log_fluxes = np.log(np.where(fluxes > 0, fluxes, np.nan))
+        log_energies = np.log(energies)
+        # Create extended arrays by repeating first and last values. This allows
+        # for linear differencing to be used on the ends and central differencing
+        # to be used on the interior of the array with a single vectorized equation.
+        # Interior points use central differencing equation:
+        #     gamma_k = ln(J_{k+1}/J_{k-1}) / ln(E_{k+1}/E_{k-1})
+        # Left boundary uses linear forward differencing:
+        #     gamma_k = ln(J_{k+1}/J_{k}) / ln(E_{k+1}/E_{k})
+        # Right boundary uses linear backward differencing:
+        #     gamma_k = ln(J_{k}/J_{k-1}) / ln(E_{k}/E_{k-1})
+        log_extended_fluxes = log_fluxes[extended_inds]
+        log_extended_energies = log_energies[extended_inds]
+
+        # Extract the left and right log values to use in slope calculation
+        left_log_fluxes = log_extended_fluxes[:-2]  # indices 0 to n_levels-1
+        right_log_fluxes = log_extended_fluxes[2:]  # indices 2 to n_levels+1
+        left_log_energies = log_extended_energies[:-2]
+        right_log_energies = log_extended_energies[2:]
+
+        # Compute power-law slopes for valid indices
+        central_valid = np.isfinite(left_log_fluxes) & np.isfinite(right_log_fluxes)
+        gamma[central_valid] = (
+            (right_log_fluxes - left_log_fluxes)
+            / (right_log_energies - left_log_energies)
+        )[central_valid]
+
+        # Compute uncertainty slopes
+        if uncertainties is not None:
+            with np.errstate(divide="ignore"):
+                rel_unc_sq = (uncertainties / fluxes) ** 2
+            extended_rel_unc_sq = rel_unc_sq[extended_inds]
+            delta_gamma = np.sqrt(
+                extended_rel_unc_sq[:-2] + extended_rel_unc_sq[2:]
+            ) / (log_extended_energies[2:] - log_extended_energies[:-2])
+            delta_gamma[~central_valid] = 0
+
+        # Handle one-sided differencing for points where central differencing failed
+        need_fallback = ~central_valid & np.isfinite(log_fluxes)
+        # Exclude first and last points since they already use the correct
+        # one-sided differencing
+        interior_fallback = np.zeros_like(need_fallback, dtype=bool)
+        interior_fallback[1:-1] = need_fallback[1:-1]
+
+        if np.any(interior_fallback):
+            indices = np.where(interior_fallback)[0]
+
+            for k in indices:
+                # For interior points: try forward first, then backward
+                if k < n_levels - 1 and np.isfinite(log_fluxes[k + 1]):
+                    gamma[k] = (log_fluxes[k + 1] - log_fluxes[k]) / (
+                        log_energies[k + 1] - log_energies[k]
+                    )
+
+                    # Compute uncertainty slope using same differencing
+                    if isinstance(delta_gamma, np.ndarray):
+                        delta_gamma[k] = np.sqrt(rel_unc_sq[k + 1] + rel_unc_sq[k]) / (
+                            log_energies[k + 1] - log_energies[k]
+                        )
+
+                elif k > 0 and np.isfinite(log_fluxes[k - 1]):
+                    gamma[k] = (log_fluxes[k] - log_fluxes[k - 1]) / (
+                        log_energies[k] - log_energies[k - 1]
+                    )
+
+                    # Compute uncertainty slope using same differencing
+                    if isinstance(delta_gamma, np.ndarray):
+                        delta_gamma[k] = np.sqrt(rel_unc_sq[k] + rel_unc_sq[k - 1]) / (
+                            log_energies[k] - log_energies[k - 1]
+                        )
+
+        return gamma, delta_gamma
+
+    def predictor_corrector_iteration(
+        self,
+        observed_fluxes: np.ndarray,
+        observed_uncertainties: np.ndarray,
+        energies: np.ndarray,
+        max_iterations: int = 20,
+        convergence_threshold: float = 0.005,
+    ) -> tuple[np.ndarray, np.ndarray, int]:
+        """
+        Estimate source fluxes using iterative predictor-corrector scheme.
+
+        Implements the algorithm from Appendix A of the Mapping Algorithm Document.
+
+        Parameters
+        ----------
+        observed_fluxes : np.ndarray
+            Array of observed fluxes.
+        observed_uncertainties : numpy.ndarray
+            Array of observed uncertainties.
+        energies : np.ndarray
+            Array of energy levels.
+        max_iterations : int, optional
+            Maximum number of iterations, by default 20.
+        convergence_threshold : float, optional
+            RMS convergence criterion, by default 0.005 (0.5%).
+
+        Returns
+        -------
+        source_fluxes : np.ndarray
+            Final estimate of source fluxes.
+        source_uncertainties : np.ndarray
+            Final estimate of source uncertainties.
+        n_iterations : int
+            Number of iterations run.
+        """
+        n_levels = len(observed_fluxes)
+        energy_levels = np.arange(n_levels) + 1
+
+        # Initial power-law estimate from observed fluxes
+        gamma_initial, _ = self.estimate_power_law_slope(observed_fluxes, energies)
+
+        # Initial source flux estimate
+        eta_initial = self.eta_esa(energy_levels, gamma_initial)
+        source_fluxes_n = observed_fluxes / eta_initial
+
+        for _iteration in range(max_iterations):
+            # Store previous iteration
+            source_fluxes_prev = source_fluxes_n.copy()
+
+            # Predictor step
+            gamma_pred, _ = self.estimate_power_law_slope(source_fluxes_n, energies)
+            gamma_half = 0.5 * (gamma_initial + gamma_pred)
+
+            # Predictor source flux estimate
+            eta_half = self.eta_esa(energy_levels, gamma_half)
+            source_fluxes_half = observed_fluxes / eta_half
+
+            # Corrector step
+            gamma_corr, _ = self.estimate_power_law_slope(source_fluxes_half, energies)
+            gamma_n = 0.5 * (gamma_pred + gamma_corr)
+
+            # Final source flux estimate for this iteration
+            eta_final = self.eta_esa(energy_levels, gamma_n)
+            source_fluxes_n = observed_fluxes / eta_final
+            source_uncertainties = observed_uncertainties / eta_final
+
+            # Check convergence
+            ratios_sq = (source_fluxes_n / source_fluxes_prev) ** 2
+            chi_n = np.sqrt(np.mean(ratios_sq)) - 1
+
+            if chi_n < convergence_threshold:
+                break
+
+        return source_fluxes_n, source_uncertainties, _iteration + 1
+
+    def apply_flux_correction(
+        self, flux: np.ndarray, flux_stat_unc: np.ndarray, energies: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Apply flux correction to observed fluxes.
+
+        Iterative predictor-corrector scheme is run on each spatial pixel
+        individually to correct fluxes and statistical uncertainties. This method
+        is intended to be used with the unwrapped data in the ena_maps.AbstractSkyMap
+        class or child classes.
+
+        Parameters
+        ----------
+        flux : numpy.ndarray
+            Input flux with shape (n_energy, n_spatial_pixels).
+        flux_stat_unc : np.ndarray
+            Statistical uncertainty for input fluxes. Shape must match the shape
+            of flux.
+        energies : numpy.ndarray
+            Array of energy levels in units of eV or keV.
+
+        Returns
+        -------
+        tuple[numpy.ndarray, numpy.ndarray]
+            Corrected fluxes and flux uncertainties.
+        """
+        corrected_flux = np.empty_like(flux)
+        corrected_flux_stat_unc = np.empty_like(flux_stat_unc)
+
+        # loop over spatial pixels (last dimension)
+        for i_pixel in range(flux.shape[-1]):
+            corrected_flux[:, i_pixel], corrected_flux_stat_unc[:, i_pixel], _ = (
+                self.predictor_corrector_iteration(
+                    flux[:, i_pixel], flux_stat_unc[:, i_pixel], energies
+                )
+            )
+
+        return corrected_flux, corrected_flux_stat_unc

imap_processing/ena_maps/utils/map_utils.py

@@ -15,6 +15,7 @@ def bin_single_array_at_indices(
     projection_grid_shape: tuple[int, ...],
     projection_indices: NDArray,
     input_indices: NDArray | None = None,
+    input_valid_mask: NDArray | None = None,
 ) -> NDArray:
     """
     Bin an array of values at the given indices.
@@ -39,6 +40,9 @@ def bin_single_array_at_indices(
         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.
+    input_valid_mask : NDArray, optional
+        Boolean mask array for valid values in input grid.
+        If None, all pixels are considered valid. Default is None.
 
     Returns
     -------
@@ -55,6 +59,8 @@ def bin_single_array_at_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:
@@ -69,20 +75,25 @@ def bin_single_array_at_indices(
             " projection indices."
         )
 
+    input_valid_mask = np.asarray(input_valid_mask, dtype=bool)
+    mask_idx = input_valid_mask[input_indices]
+
     num_projection_indices = np.prod(projection_grid_shape)
 
+    # Only valid values are summed into bins.
     if value_array.ndim == 1:
+        values = value_array[input_indices]
         binned_values = np.bincount(
-            projection_indices,
-            weights=value_array[input_indices],
+            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,
-                weights=x[..., input_indices],
+                projection_indices[mask_idx],
+                weights=x[..., input_indices][mask_idx],
                 minlength=num_projection_indices,
             ),
             axis=-1,
@@ -96,6 +107,7 @@ def bin_values_at_indices(
     projection_grid_shape: tuple[int, ...],
     projection_indices: NDArray,
     input_indices: NDArray | None = None,
+    input_valid_mask: NDArray | None = None,
 ) -> dict[str, NDArray]:
     """
     Project values from input grid to projection grid based on matched indices.
@@ -118,6 +130,9 @@ def bin_values_at_indices(
         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), behavior is determined by bin_single_array_at_indices.
+    input_valid_mask : NDArray, optional
+        Boolean mask array for valid values in input grid.
+        If None, all pixels are considered valid. Default is None.
 
     Returns
     -------
@@ -137,6 +152,7 @@ def bin_values_at_indices(
             projection_grid_shape=projection_grid_shape,
             projection_indices=projection_indices,
             input_indices=input_indices,
+            input_valid_mask=input_valid_mask,
         )
 
     return binned_values_dict

imap_processing/ena_maps/utils/naming.py

@@ -33,7 +33,7 @@ _sensor_types = int | Literal["45", "90", "combined", "ic", "lc", ""]
 # Must be specified separately for purpose of type checking vs comparison
 valid_spice_frame_strings = ["sf", "hf", "hk"]
 _spice_frame_str_types = Literal["sf", "hf", "hk"]
-_coord_frame_str_types = Literal["hae",]
+_coord_frame_str_types = Literal["hae", "hre", "hnu", "gcs"]
 
 # Mapping of inertial frames to their longer names used in logical source descriptors
 INERTIAL_FRAME_LONG_NAMES = {
@@ -334,7 +334,13 @@ class MapDescriptor:
             If the frame string is not recognized.
         """
         if frame_str == "hae":
-            return SpiceFrame.ECLIPJ2000
+            return SpiceFrame.IMAP_HAE
+        elif frame_str == "hre":
+            return SpiceFrame.IMAP_HRE
+        elif frame_str == "hnu":
+            return SpiceFrame.IMAP_HNU
+        elif frame_str == "gcs":
+            return SpiceFrame.IMAP_GCS
         else:
             raise NotImplementedError("Coordinate frame is not yet implemented.")