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

imap_processing/ena_maps/utils/corrections.py

@@ -1,6 +1,8 @@
 """L2 corrections common to multiple IMAP ENA instruments."""
 
+import logging
 from pathlib import Path
+from typing import TypeVar
 
 import numpy as np
 import pandas as pd
@@ -8,11 +10,23 @@ 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.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
 
+logger = logging.getLogger(__name__)
+
+# Tell ruff to ignore ambiguous Greek letters in formulas in this file
+# ruff: noqa: RUF003
+
+# Create a TypeVar to represent the specific class being passed in
+# Bound to LoHiBasePointingSet, meaning it must be LoHiBasePointingSet
+# or a subclass of it
+LoHiBasePsetSubclass = TypeVar("LoHiBasePsetSubclass", bound=LoHiBasePointingSet)
+
 # Physical constants for Compton-Getting correction
 # Units: electron_volt = [J / eV]
 #        erg = [J / erg]
@@ -307,7 +321,9 @@ class PowerLawFluxCorrector:
         return corrected_flux, corrected_flux_stat_unc
 
 
-def _add_spacecraft_velocity_to_pset(pset: LoHiBasePointingSet) -> None:
+def _add_spacecraft_velocity_to_pset(
+    pset: LoHiBasePsetSubclass,
+) -> LoHiBasePsetSubclass:
     """
     Calculate and add spacecraft velocity data to pointing set.
 
@@ -316,6 +332,11 @@ def _add_spacecraft_velocity_to_pset(pset: LoHiBasePointingSet) -> None:
     pset : LoHiBasePointingSet
         Pointing set object to be updated.
 
+    Returns
+    -------
+    pset : LoHiBasePointingSet
+        Pointing set object with spacecraft velocity data added.
+
     Notes
     -----
     Adds the following DataArrays to pset.data:
@@ -342,8 +363,10 @@ def _add_spacecraft_velocity_to_pset(pset: LoHiBasePointingSet) -> None:
     )
     pset.data["sc_direction_vector"] = pset.data["sc_velocity"] / sc_velocity_km_per_sec
 
+    return pset
+
 
-def _add_cartesian_look_direction(pset: LoHiBasePointingSet) -> None:
+def _add_cartesian_look_direction(pset: LoHiBasePsetSubclass) -> LoHiBasePsetSubclass:
     """
     Calculate and add look direction vectors to pointing set.
 
@@ -352,6 +375,11 @@ def _add_cartesian_look_direction(pset: LoHiBasePointingSet) -> None:
     pset : LoHiBasePointingSet
         Pointing set object to be updated.
 
+    Returns
+    -------
+    pset : LoHiBasePointingSet
+        Pointing set object with look direction vectors added.
+
     Notes
     -----
     Adds the following DataArray to pset.data:
@@ -376,11 +404,13 @@ def _add_cartesian_look_direction(pset: LoHiBasePointingSet) -> None:
         dims=[*longitudes.dims, CoordNames.CARTESIAN_VECTOR.value],
     )
 
+    return pset
+
 
 def _calculate_compton_getting_transform(
-    pset: LoHiBasePointingSet,
+    pset: LoHiBasePsetSubclass,
     energy_hf: xr.DataArray,
-) -> None:
+) -> LoHiBasePsetSubclass:
     """
     Apply Compton-Getting transformation to compute ENA source directions.
 
@@ -400,14 +430,24 @@ def _calculate_compton_getting_transform(
     energy_hf : xr.DataArray
         ENA energies in the heliosphere frame in eV.
 
+    Returns
+    -------
+    pset : LoHiBasePointingSet
+        Pointing set object with Compton-Getting related variables added and
+        updated az_el_points.
+
     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)
+    - "energy_hf": ENA energies in the heliosphere frame (eV)
+    - "ram_mask": Mask indicating whether ENA source direction is from the ram
+      direction.
+    Updates the following DataArrays in pset.data:
+    - "hae_longitude": ENA source longitudes in heliosphere frame (degrees)
+    - "hae_latitude": ENA source latitudes in heliosphere frame (degrees)
     """
     # Store heliosphere frame energies
     pset.data["energy_hf"] = energy_hf
@@ -455,6 +495,8 @@ def _calculate_compton_getting_transform(
     # Velocity magnitude factor calculation (Equation 62)
     # x_k = (êₛ · û_sc) + sqrt(y² + (êₛ · û_sc)² - 1)
     x = dot_product + np.sqrt(y**2 + dot_product**2 - 1)
+    # Get the dimensions in the right order so that spatial is last
+    x = x.transpose(dot_product.dims[0], y.dims[0], dot_product.dims[1])
 
     # Calculate ENA speed in the spacecraft frame
     # |v⃗_sc| = x_k * U_sc
@@ -504,11 +546,13 @@ def _calculate_compton_getting_transform(
         dims=velocity_vector_helio.dims[:-1],
     )
 
+    return pset
+
 
 def apply_compton_getting_correction(
-    pset: LoHiBasePointingSet,
+    pset: LoHiBasePsetSubclass,
     energy_hf: xr.DataArray,
-) -> None:
+) -> LoHiBasePsetSubclass:
     """
     Apply Compton-Getting correction to a pointing set and update coordinates.
 
@@ -532,6 +576,11 @@ def apply_compton_getting_correction(
         ENA energies in the heliosphere frame in eV. Must be 1D with an
         energy dimension.
 
+    Returns
+    -------
+    pset : LoHiBasePointingSet
+        Updated pointing set object with Compton-Getting related variables added.
+
     Notes
     -----
     This function adds the following variables to the pointing set dataset:
@@ -540,20 +589,153 @@ def apply_compton_getting_correction(
     - "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)
+    This function modifies the following variables in the pointing set dataset:
+    - "hae_longitude": ENA source longitudes in heliosphere frame (degrees)
+    - "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)
+    pset = _add_spacecraft_velocity_to_pset(pset)
 
     # Step 2: Calculate and add look direction vectors to pset
-    _add_cartesian_look_direction(pset)
+    pset = _add_cartesian_look_direction(pset)
 
     # Step 3: Apply Compton-Getting transformation
-    _calculate_compton_getting_transform(pset, energy_hf)
+    pset = _calculate_compton_getting_transform(pset, energy_hf)
 
     # Step 4: Update az_el_points to use the corrected coordinates
     pset.update_az_el_points()
+
+    return pset
+
+
+def interpolate_map_flux_to_helio_frame(
+    map_ds: xr.Dataset,
+    esa_energies_ev: xr.DataArray,
+    helio_energies_ev: xr.DataArray,
+) -> xr.Dataset:
+    """
+    Interpolate flux from spacecraft frame to heliocentric frame energies.
+
+    This implements the Compton-Getting interpolation step that transforms
+    flux measurements from the spacecraft frame to the heliocentric frame.
+    The algorithm follows these steps:
+    1. For each spatial pixel and energy step, get the spacecraft energy
+    2. Find bounding ESA energy channels for interpolation
+    3. Perform power-law interpolation between bounding channels to spacecraft energy
+    4. Apply energy scaling transformation to heliocentric frame
+
+    Parameters
+    ----------
+    map_ds : xarray.Dataset
+        Map dataset with `energy_sc` data variable containing the spacecraft
+        frame energies for each spatial pixel and ESA energy step.
+    esa_energies_ev : xarray.DataArray
+        The ESA nominal central energies (in eV).
+    helio_energies_ev : xarray.DataArray
+        The heliocentric frame energies to interpolate to (in eV).
+        In practice, these are the same as esa_energies_ev.
+
+    Returns
+    -------
+    map_ds : xarray.Dataset
+        Updated map dataset with interpolated heliocentric frame fluxes.
+    """
+    logger.info("Performing Compton-Getting interpolation to heliocentric frame")
+
+    # Work with xarray DataArrays to handle arbitrary spatial dimensions
+    energy_sc = map_ds["energy_sc"]
+    intensity = map_ds["ena_intensity"]
+    stat_unc = map_ds["ena_intensity_stat_uncert"]
+    sys_err = map_ds["ena_intensity_sys_err"]
+
+    # Step 1: Find bounding ESA energy indices for each position
+    # Use np.searchsorted on flattened array, then reshape back
+    esa_energy_vals = esa_energies_ev.values
+    energy_sc_flat = energy_sc.values.ravel()
+
+    # Find right bound index for each element (vectorized)
+    right_idx_flat = np.searchsorted(esa_energy_vals, energy_sc_flat, side="right")
+    right_idx_flat = np.clip(right_idx_flat, 1, len(esa_energy_vals) - 1)
+    left_idx_flat = right_idx_flat - 1
+
+    # Reshape indices back to match energy_sc shape
+    right_idx = right_idx_flat.reshape(energy_sc.shape)
+    left_idx = left_idx_flat.reshape(energy_sc.shape)
+
+    # Create DataArrays for indices with same dims as energy_sc
+    # Note: we need to avoid coordinate name conflicts when using isel()
+    # The energy dimension should be present in dims but not as a coordinate
+    # since we're using these as indices into the energy dimension
+    # Create coordinates dict without the energy coordinate
+    coords_without_energy = {k: v for k, v in energy_sc.coords.items() if k != "energy"}
+
+    right_idx_da = xr.DataArray(
+        right_idx, dims=energy_sc.dims, coords=coords_without_energy
+    )
+    left_idx_da = xr.DataArray(
+        left_idx, dims=energy_sc.dims, coords=coords_without_energy
+    )
+
+    # Step 2: Extract flux values at bounding energy channels
+    # Use xarray's advanced indexing to get fluxes at left and right indices
+    flux_left = intensity.isel({"energy": left_idx_da})
+    flux_right = intensity.isel({"energy": right_idx_da})
+    stat_unc_left = stat_unc.isel({"energy": left_idx_da})
+    stat_unc_right = stat_unc.isel({"energy": right_idx_da})
+    sys_err_left = sys_err.isel({"energy": left_idx_da})
+
+    # Get energy values at boundaries - select from esa_energies_ev using indices
+    energy_left = esa_energies_ev.isel({"energy": left_idx_da})
+    energy_right = esa_energies_ev.isel({"energy": right_idx_da})
+
+    # Step 3: Perform power-law interpolation to spacecraft energy
+    # slope = log(f_right/f_left) / log(e_right/e_left)
+    # flux_sc = f_left * (energy_sc / e_left)^slope
+    with np.errstate(divide="ignore", invalid="ignore"):
+        # Calculate slope for power-law interpolation
+        slope = np.log(flux_right / flux_left) / np.log(energy_right / energy_left)
+
+        # Interpolate flux using power-law
+        flux_sc = flux_left * ((energy_sc / energy_left) ** slope)
+
+        # Interpolation factor for uncertainty propagation (Equations 75 & 76)
+        unc_factor = np.log(energy_sc / energy_left) / np.log(
+            energy_right / energy_left
+        )
+
+        # Statistical uncertainty propagation (Equation 75):
+        # δJ = J * sqrt((δJ_left/J_left)^2 * (1 + unc_factor^2) + (δJ_right/J_right)^2)
+        stat_unc_sc = flux_sc * np.sqrt(
+            (stat_unc_left / flux_left) ** 2 * (1.0 + unc_factor**2)
+            + (stat_unc_right / flux_right) ** 2
+        )
+
+        # Systematic uncertainty propagation (Equation 76):
+        # σJ^g = σJ^src_kref * (⟨E^s_kref⟩ / E^ESA_kref)^γ_kref * (E^h / ⟨E^s_kref⟩)
+        # Systematic error scales proportionally with flux during power-law
+        # interpolation
+        sys_err_sc = sys_err_left * ((energy_sc / energy_left) ** slope)
+
+    # Step 4: Energy scaling transformation (Liouville theorem)
+    # flux_helio = flux_sc * (helio_energy / energy_sc)
+    # Use xarray broadcasting - helio_energies_ev will broadcast along esa_energy_step
+    with np.errstate(divide="ignore", invalid="ignore"):
+        energy_ratio = helio_energies_ev / energy_sc
+        flux_helio = flux_sc * energy_ratio
+        stat_unc_helio = stat_unc_sc * energy_ratio
+        sys_err_helio = sys_err_sc * energy_ratio
+
+    # Set any location where the value is not finite to NaN (converts +/-inf to NaN)
+    flux_helio = flux_helio.where(np.isfinite(flux_helio), np.nan)
+    stat_unc_helio = stat_unc_helio.where(np.isfinite(stat_unc_helio), np.nan)
+    sys_err_helio = sys_err_helio.where(np.isfinite(sys_err_helio), np.nan)
+
+    # Update the dataset with interpolated values
+    map_ds["ena_intensity"] = flux_helio
+    map_ds["ena_intensity_stat_uncert"] = stat_unc_helio
+    map_ds["ena_intensity_sys_err"] = sys_err_helio
+
+    return map_ds

imap_processing/ena_maps/utils/naming.py

@@ -342,7 +342,9 @@ class MapDescriptor:
         elif frame_str == "gcs":
             return SpiceFrame.IMAP_GCS
         else:
-            raise NotImplementedError("Coordinate frame is not yet implemented.")
+            raise NotImplementedError(
+                f"Coordinate frame {frame_str} is not yet implemented."
+            )
 
     def to_empty_map(
         self,

imap_processing/hi/hi_l1c.py

@@ -102,7 +102,7 @@ def generate_pset_dataset(
 
     pset_dataset = empty_pset_dataset(
         de_dataset.epoch.data[0],
-        de_dataset.esa_energy_step.data,
+        de_dataset.esa_energy_step,
         config_df.cal_prod_config.number_of_products,
         logical_source_parts["sensor"],
     )
@@ -121,7 +121,7 @@ def generate_pset_dataset(
 
 
 def empty_pset_dataset(
-    epoch_val: int, l1b_energy_steps: np.ndarray, n_cal_prods: int, sensor_str: str
+    epoch_val: int, l1b_energy_steps: xr.DataArray, n_cal_prods: int, sensor_str: str
 ) -> xr.Dataset:
     """
     Allocate an empty xarray.Dataset with appropriate pset coordinates.
@@ -130,7 +130,7 @@ def empty_pset_dataset(
     ----------
     epoch_val : int
         The starting epoch in J2000 TT nanoseconds for data in the PSET.
-    l1b_energy_steps : np.ndarray
+    l1b_energy_steps : xarray.DataArray
         The array of esa_energy_step data from the L1B DE product.
     n_cal_prods : int
         Number of calibration products to allocate.
@@ -164,8 +164,12 @@ def empty_pset_dataset(
         "hi_pset_esa_energy_step", check_schema=False
     ).copy()
     dtype = attrs.pop("dtype")
-    # Find the unique, non-zero esa_energy_steps from the L1B data
-    esa_energy_steps = np.array(sorted(set(l1b_energy_steps) - {0}), dtype=dtype)
+    # Find the unique esa_energy_steps from the L1B data
+    # Exclude 0 and FILLVAL
+    esa_energy_steps = np.array(
+        sorted(set(l1b_energy_steps.values) - {0, l1b_energy_steps.attrs["FILLVAL"]}),
+        dtype=dtype,
+    )
     coords["esa_energy_step"] = xr.DataArray(
         esa_energy_steps,
         name="esa_energy_step",
@@ -571,11 +575,26 @@ def find_second_de_packet_data(l1b_dataset: xr.Dataset) -> xr.Dataset:
     # We should get two CCSDS packets per 8-spin ESA step.
     # Get the indices of the packet before each ESA change.
     esa_step = epoch_dataset["esa_step"].values
+    esa_energy_step = epoch_dataset["esa_energy_step"].values
+    # A change in esa_step should indicate the location of the second packet in
+    # each pair of DE packets at an esa_energy_step. In practice, during some
+    # calibration activities, it was observed that the esa_energy_step can change
+    # when the esa_step did not. So, we look for either to change and use the
+    # indices of those changes to identify the second packet in each pair. We
+    # also need to add the last packet index and assume an energy step change
+    # occurs after the last packet.
     second_esa_packet_idx = np.append(
-        np.flatnonzero(np.diff(esa_step) != 0), len(esa_step) - 1
+        np.flatnonzero((np.diff(esa_step) != 0) | (np.diff(esa_energy_step) != 0)),
+        len(esa_step) - 1,
+    )
+    # Remove esa energy steps at 0 - these are calibrations
+    keep_mask = esa_energy_step[second_esa_packet_idx] != 0
+    # Remove esa energy steps at FILLVAL - these are unidentified
+    keep_mask &= (
+        esa_energy_step[second_esa_packet_idx]
+        != l1b_dataset["esa_energy_step"].attrs["FILLVAL"]
     )
-    # Remove esa steps at 0 - these are calibrations
-    second_esa_packet_idx = second_esa_packet_idx[esa_step[second_esa_packet_idx] != 0]
+    second_esa_packet_idx = second_esa_packet_idx[keep_mask]
     # Remove indices where we don't have two consecutive packets at the same ESA
     if second_esa_packet_idx[0] == 0:
         logger.warning(
@@ -584,7 +603,8 @@ def find_second_de_packet_data(l1b_dataset: xr.Dataset) -> xr.Dataset:
         )
         second_esa_packet_idx = second_esa_packet_idx[1:]
     missing_esa_pair_mask = (
-        esa_step[second_esa_packet_idx - 1] != esa_step[second_esa_packet_idx]
+        esa_energy_step[second_esa_packet_idx - 1]
+        != esa_energy_step[second_esa_packet_idx]
     )
     if missing_esa_pair_mask.any():
         logger.warning(
@@ -629,9 +649,11 @@ def get_de_clock_ticks_for_esa_step(
     # ESA step group so this match is the end time. The start time is
     # 8-spins earlier.
     spin_start_mets = spin_df.spin_start_met.to_numpy()
-    # CCSDS MET has one second resolution, add one to it to make sure it is
-    # greater than the spin start time it ended on.
-    end_time_ind = np.flatnonzero(ccsds_met + 1 >= spin_start_mets).max()
+    # CCSDS MET has one second resolution, add two to it to make sure it is
+    # greater than the spin start time it ended on. Theotretically, adding
+    # one second should be sufficeint, but in practice, with flight data, adding
+    # two seconds was found to be necessary.
+    end_time_ind = np.flatnonzero(ccsds_met + 2 >= spin_start_mets).max()
 
     # If the minimum absolute difference is greater than 1/2 the spin-phase
     # we have a problem.

imap_processing/hi/hi_l2.py

@@ -11,14 +11,26 @@ from imap_processing.ena_maps.ena_maps import (
     HiPointingSet,
     RectangularSkyMap,
 )
-from imap_processing.ena_maps.utils.corrections import PowerLawFluxCorrector
+from imap_processing.ena_maps.utils.corrections import (
+    PowerLawFluxCorrector,
+    apply_compton_getting_correction,
+    interpolate_map_flux_to_helio_frame,
+)
 from imap_processing.ena_maps.utils.naming import MapDescriptor
 from imap_processing.hi.utils import CalibrationProductConfig
 
 logger = logging.getLogger(__name__)
 
+SC_FRAME_VARS_TO_PROJECT = {
+    "counts",
+    "exposure_factor",
+    "bg_rates",
+    "bg_rates_unc",
+    "obs_date",
+}
+HELIO_FRAME_VARS_TO_PROJECT = SC_FRAME_VARS_TO_PROJECT | {"energy_sc"}
 # TODO: is an exposure time weighted average for obs_date appropriate?
-VARS_TO_EXPOSURE_TIME_AVERAGE = ["bg_rates", "bg_rates_unc", "obs_date"]
+FULL_EXPOSURE_TIME_AVERAGE_SET = {"bg_rates", "bg_rates_unc", "obs_date", "energy_sc"}
 
 
 def hi_l2(
@@ -98,33 +110,64 @@ def generate_hi_map(
         The sky map with all the PSET data projected into the map.
     """
     output_map = descriptor.to_empty_map()
+    vars_to_bin = (
+        HELIO_FRAME_VARS_TO_PROJECT
+        if descriptor.frame_descriptor == "hf"
+        else SC_FRAME_VARS_TO_PROJECT
+    )
+    vars_to_exposure_time_average = FULL_EXPOSURE_TIME_AVERAGE_SET & vars_to_bin
 
     if not isinstance(output_map, RectangularSkyMap):
         raise NotImplementedError("Healpix map output not supported for Hi")
 
-    # TODO: Implement Compton-Getting correction
-    if descriptor.frame_descriptor != "sf":
-        raise NotImplementedError("CG correction not implemented for Hi")
+    cached_esa_steps = None
 
     for pset_path in psets:
         logger.info(f"Processing {pset_path}")
-        pset = HiPointingSet(pset_path, spin_phase=descriptor.spin_phase)
-
-        # Background rate and uncertainty are exposure time weighted means in
-        # the map.
-        for var in VARS_TO_EXPOSURE_TIME_AVERAGE:
-            pset.data[var] *= pset.data["exposure_factor"]
+        pset = HiPointingSet(pset_path)
+
+        # Store the first PSET esa_energy_step values and make sure every PSET
+        # contains the same set of esa_energy_step values.
+        # TODO: Correctly handle PSETs with different esa_energy_step values.
+        if cached_esa_steps is None:
+            cached_esa_steps = pset.data["esa_energy_step"].values.copy()
+            esa_ds = esa_energy_df(
+                l2_ancillary_path_dict["esa-energies"],
+                pset.data["esa_energy_step"].values,
+            ).to_xarray()
+            energy_kev = esa_ds["nominal_central_energy"]
+        if not np.array_equal(cached_esa_steps, pset.data["esa_energy_step"].values):
+            raise ValueError(
+                "All PSETs must have the same set of esa_energy_step values."
+            )
+
+        if descriptor.frame_descriptor == "hf":
+            # convert esa nominal central energy from keV to eV
+            esa_energy_ev = energy_kev * 1000
+            pset = apply_compton_getting_correction(pset, esa_energy_ev)
+
+        # Multiply variables that need to be exposure time weighted average by
+        # exposure factor.
+        for var in vars_to_exposure_time_average:
+            if var in pset.data:
+                pset.data[var] *= pset.data["exposure_factor"]
+
+        # Set the mask used to filter ram/anti-ram pixels
+        pset_valid_mask = None  # Default to no mask (full spin)
+        if descriptor.spin_phase == "ram":
+            pset_valid_mask = pset.data["ram_mask"]
+        elif descriptor.spin_phase == "anti":
+            pset_valid_mask = ~pset.data["ram_mask"]
 
         # Project (bin) the PSET variables into the map pixels
         output_map.project_pset_values_to_map(
-            pset,
-            ["counts", "exposure_factor", "bg_rates", "bg_rates_unc", "obs_date"],
+            pset, list(vars_to_bin), pset_valid_mask=pset_valid_mask
         )
 
     # Finish the exposure time weighted mean calculation of backgrounds
     # Allow divide by zero to fill set pixels with zero exposure time to NaN
     with np.errstate(divide="ignore"):
-        for var in VARS_TO_EXPOSURE_TIME_AVERAGE:
+        for var in vars_to_exposure_time_average:
             output_map.data_1d[var] /= output_map.data_1d["exposure_factor"]
 
     output_map.data_1d.update(calculate_ena_signal_rates(output_map.data_1d))
@@ -138,30 +181,27 @@ def generate_hi_map(
     # TODO: Figure out how to compute obs_date_range (stddev of obs_date)
     output_map.data_1d["obs_date_range"] = xr.zeros_like(output_map.data_1d["obs_date"])
 
+    # Set the energy_step_delta values to the energy bandpass half-width-half-max
+    energy_delta = esa_ds["bandpass_fwhm"] / 2
+    output_map.data_1d["energy_delta_minus"] = energy_delta
+    output_map.data_1d["energy_delta_plus"] = energy_delta
+
     # Rename and convert coordinate from esa_energy_step energy
-    esa_df = esa_energy_df(
-        l2_ancillary_path_dict["esa-energies"],
-        output_map.data_1d["esa_energy_step"].data,
-    )
     output_map.data_1d = output_map.data_1d.rename({"esa_energy_step": "energy"})
-    output_map.data_1d = output_map.data_1d.assign_coords(
-        energy=esa_df["nominal_central_energy"].values
-    )
-    # Set the energy_step_delta values to the energy bandpass half-width-half-max
-    energy_delta = esa_df["bandpass_fwhm"].values / 2
-    output_map.data_1d["energy_delta_minus"] = xr.DataArray(
-        energy_delta,
-        name="energy_delta_minus",
-        dims=["energy"],
-    )
-    output_map.data_1d["energy_delta_plus"] = xr.DataArray(
-        energy_delta,
-        name="energy_delta_plus",
-        dims=["energy"],
-    )
+    output_map.data_1d = output_map.data_1d.assign_coords(energy=energy_kev.values)
 
     output_map.data_1d = output_map.data_1d.drop("esa_energy_step_label")
 
+    # Apply Compton-Getting interpolation for heliocentric frame maps
+    if descriptor.frame_descriptor == "hf":
+        esa_energy_ev = esa_energy_ev.rename({"esa_energy_step": "energy"})
+        esa_energy_ev = esa_energy_ev.assign_coords(energy=energy_kev.values)
+        output_map.data_1d = interpolate_map_flux_to_helio_frame(
+            output_map.data_1d,
+            output_map.data_1d["energy"] * 1000,  # Convert ESA energies to eV
+            esa_energy_ev,  # heliocentric energies (same as ESA energies)
+        )
+
     return output_map
 
 
@@ -420,7 +460,7 @@ def _calculate_improved_stat_variance(
 
 
 def esa_energy_df(
-    esa_energies_path: str | Path, esa_energy_steps: np.ndarray
+    esa_energies_path: str | Path, esa_energy_steps: np.ndarray | slice | None = None
 ) -> pd.DataFrame:
     """
     Lookup the nominal central energy values for given esa energy steps.
@@ -429,8 +469,9 @@ def esa_energy_df(
     ----------
     esa_energies_path : str or pathlib.Path
         Location of the calibration csv file containing the lookup data.
-    esa_energy_steps : numpy.ndarray
-        The ESA energy steps to get energies for.
+    esa_energy_steps : numpy.ndarray, slice, or None
+        The ESA energy steps to get energies for. If not provided (default is None),
+        the full dataframe is returned.
 
     Returns
     -------
@@ -438,6 +479,8 @@ def esa_energy_df(
         Full data frame from the csv file filtered to only include the
         esa_energy_steps input.
     """
+    if esa_energy_steps is None:
+        esa_energy_steps = slice(None)
     esa_energies_lut = pd.read_csv(
         esa_energies_path, comment="#", index_col="esa_energy_step"
     )

imap_processing/ialirt/generate_coverage.py

@@ -77,7 +77,9 @@ 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, obsref="IAU_EARTH"
+        )
         visible = elevation > min_elevation
 
         outage_mask = np.zeros(time_range.shape, dtype=bool)

imap_processing/ialirt/l0/parse_mag.py

@@ -710,6 +710,7 @@ def process_packet(
                 "met": int(met_all[i]),
                 "met_in_utc": met_to_utc(met_all[i]).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met_all[i])),
+                "instrument": "mag",
                 "mag_epoch": int(mago_times_all[i]),
                 "mag_B_GSE": [Decimal(str(v)) for v in gse_vector[i]],
                 "mag_B_GSM": [Decimal(str(v)) for v in gsm_vector[i]],

imap_processing/ialirt/l0/process_hit.py

@@ -171,6 +171,7 @@ def process_hit(xarray_data: xr.Dataset) -> list[dict]:
                 "met": int(met),
                 "met_in_utc": met_to_utc(met).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met)),
+                "instrument": "hit",
                 "hit_e_a_side_low_en": int(l1["IALRT_RATE_1"] + l1["IALRT_RATE_2"]),
                 "hit_e_a_side_med_en": int(l1["IALRT_RATE_5"] + l1["IALRT_RATE_6"]),
                 "hit_e_a_side_high_en": int(l1["IALRT_RATE_7"]),

imap_processing/ialirt/l0/process_swapi.py

@@ -226,6 +226,7 @@ def process_swapi_ialirt(
                 "met": int(met_values[entry]),
                 "met_in_utc": met_to_utc(met_values[entry]).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met_values[entry])),
+                "instrument": "swapi",
                 "swapi_pseudo_proton_speed": Decimal(solution["pseudo_speed"][entry]),
                 "swapi_pseudo_proton_density": Decimal(
                     solution["pseudo_density"][entry]

imap_processing/ialirt/l0/process_swe.py

@@ -553,6 +553,7 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
                 "met": met_first_half,
                 "met_in_utc": met_to_utc(met_first_half).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met_first_half)),
+                "instrument": "swe",
                 "swe_normalized_counts": [int(val) for val in summed_first],
                 "swe_counterstreaming_electrons": bde_first_half,
             },
@@ -563,6 +564,7 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
                 "met": met_second_half,
                 "met_in_utc": met_to_utc(met_second_half).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met_second_half)),
+                "instrument": "swe",
                 "swe_normalized_counts": [int(val) for val in summed_second],
                 "swe_counterstreaming_electrons": bde_second_half,
             },