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

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
 
 
@@ -323,20 +363,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"))
@@ -425,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.
@@ -434,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
     -------
@@ -443,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/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,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_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/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,
             },

imap_processing/ialirt/process_ephemeris.py

@@ -72,6 +72,7 @@ def calculate_azimuth_and_elevation(
     altitude: float,
     observation_time: float | np.ndarray,
     target: str = SpiceBody.IMAP.name,
+    obsref: str = "ITRF93",
 ) -> tuple:
     """
     Calculate azimuth and elevation.
@@ -91,6 +92,9 @@ def calculate_azimuth_and_elevation(
         is to be computed. Expressed as ephemeris time, seconds past J2000 TDB.
     target : str (Optional)
         The target body. Default is "IMAP".
+    obsref : str (Optional)
+        Body-fixed, body-centered reference frame wrt
+        observer's center.
 
     Returns
     -------
@@ -120,7 +124,7 @@ def calculate_azimuth_and_elevation(
             elplsz=True,  # Elevation increases from the XY plane toward +Z
             obspos=ground_station_position_ecef,  # observer pos. to center of motion
             obsctr="EARTH",  # Name of the center of motion
-            obsref="IAU_EARTH",  # Body-fixed, body-centered reference frame wrt
+            obsref=obsref,  # Body-fixed, body-centered reference frame wrt
             # observer's center
         )
         azimuth.append(np.rad2deg(azel_results[0][1]))
@@ -223,7 +227,7 @@ def build_output(
 
     # For now, assume that kernel management will be handled by ensure_spice
     azimuth, elevation = calculate_azimuth_and_elevation(
-        longitude, latitude, altitude, time_range
+        longitude, latitude, altitude, time_range, obsref="ITRF93"
     )
 
     output_dict["time"] = et_to_utc(time_range, format_str="ISOC")

imap_processing/ialirt/utils/create_xarray.py

@@ -52,7 +52,7 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
         ["radial", "tangential", "normal"],
         name="RTN_component",
         dims=["RTN_component"],
-        attrs=cdf_manager.get_variable_attributes("RTN_componentt", check_schema=False),
+        attrs=cdf_manager.get_variable_attributes("RTN_component", check_schema=False),
     )
 
     esa_step = xr.DataArray(
@@ -85,7 +85,7 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
         name="codice_hi_h_spin_angle",
         dims=["codice_hi_h_spin_angle"],
         attrs=cdf_manager.get_variable_attributes(
-            "codice_hi_h_spin_anglen", check_schema=False
+            "codice_hi_h_spin_angle", check_schema=False
         ),
     )
 
@@ -155,6 +155,8 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
                 "sc_velocity_GSM",
                 "sc_velocity_GSE",
                 "mag_hk_status",
+                "spice_kernels",
+                "instrument",
             ]:
                 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 "

imap_processing/lo/l1c/lo_l1c.py

@@ -11,9 +11,14 @@ from scipy.stats import binned_statistic_dd
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.lo import lo_ancillary
 from imap_processing.lo.l1b.lo_l1b import set_bad_or_goodtimes
+from imap_processing.spice.geometry import SpiceFrame, frame_transform_az_el
 from imap_processing.spice.repoint import get_pointing_times
 from imap_processing.spice.spin import get_spin_number
-from imap_processing.spice.time import met_to_ttj2000ns, ttj2000ns_to_met
+from imap_processing.spice.time import (
+    met_to_ttj2000ns,
+    ttj2000ns_to_et,
+    ttj2000ns_to_met,
+)
 
 N_ESA_ENERGY_STEPS = 7
 N_SPIN_ANGLE_BINS = 3600
@@ -164,6 +169,10 @@ def lo_l1c(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
             attr_mgr,
         )
 
+        pset["hae_longitude"], pset["hae_latitude"] = set_pointing_directions(
+            pset["epoch"].item()
+        )
+
     pset.attrs = attr_mgr.get_global_attributes(logical_source)
 
     pset = pset.assign_coords(
@@ -293,9 +302,9 @@ def create_pset_counts(
     # Create the histogram with 3600 longitude bins, 40 latitude bins, and 7 energy bins
     lon_edges = np.arange(3601)
     lat_edges = np.arange(41)
-    energy_edges = np.arange(8)
+    energy_edges = np.arange(1, 9)
 
-    hist, edges = np.histogramdd(
+    hist, _edges = np.histogramdd(
         data,
         bins=[energy_edges, lon_edges, lat_edges],
     )
@@ -572,7 +581,7 @@ def set_background_rates(
             if row["type"] == "rate":
                 bg_rates[esa_step, bin_start:bin_end, :] = value
             elif row["type"] == "sigma":
-                bg_stat_uncert[esa_step, bin_start:bin_end, :] = value
+                bg_sys_err[esa_step, bin_start:bin_end, :] = value
             else:
                 raise ValueError("Unknown background type in ancillary file.")
     # set the background rates, uncertainties, and systematic errors
@@ -597,3 +606,52 @@ def set_background_rates(
     )
 
     return bg_rates_data, bg_stat_uncert_data, bg_sys_err_data
+
+
+def set_pointing_directions(epoch: float) -> tuple[xr.DataArray, xr.DataArray]:
+    """
+    Set the pointing directions for the given epoch.
+
+    The pointing directions are calculated by transforming Spin and off angles
+    to HAE longitude and latitude using SPICE. This returns the HAE longitude and
+    latitude as (3600, 40) arrays for each the latitude and longitude.
+
+    Parameters
+    ----------
+    epoch : float
+        The epoch time in TTJ2000ns.
+
+    Returns
+    -------
+    hae_longitude : xr.DataArray
+        The HAE longitude for each spin and off angle bin.
+    hae_latitude : xr.DataArray
+        The HAE latitude for each spin and off angle bin.
+    """
+    et = ttj2000ns_to_et(epoch)
+    # create a meshgrid of spin and off angles using the bin centers
+    spin, off = np.meshgrid(
+        SPIN_ANGLE_BIN_CENTERS, OFF_ANGLE_BIN_CENTERS, indexing="ij"
+    )
+    dps_az_el = np.stack([spin, off], axis=-1)
+
+    # Transform from DPS Az/El to HAE lon/lat
+    hae_az_el = frame_transform_az_el(
+        et, dps_az_el, SpiceFrame.IMAP_DPS, SpiceFrame.IMAP_HAE, degrees=True
+    )
+
+    return xr.DataArray(
+        data=hae_az_el[:, :, 0].astype(np.float64),
+        dims=["spin_angle", "off_angle"],
+        # TODO: Add hae_longitude to yaml
+        # attrs=attr_mgr.get_variable_attributes(
+        #    "hae_longitude"
+        # )
+    ), xr.DataArray(
+        data=hae_az_el[:, :, 1].astype(np.float64),
+        dims=["spin_angle", "off_angle"],
+        # TODO: Add hae_longitude to yaml
+        # attrs=attr_mgr.get_variable_attributes(
+        #    "hae_latitude"
+        # )
+    )