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

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

@@ -229,7 +229,7 @@ def calculate_ena_intensity(
     Returns
     -------
     map_ds : xarray.Dataset
-        Map dataset with new variables: ena_intensity, ena_intensity_stat_unc,
+        Map dataset with new variables: ena_intensity, ena_intensity_stat_uncert,
         ena_intensity_sys_err.
     """
     # read calibration product configuration file
@@ -248,7 +248,7 @@ def calculate_ena_intensity(
     # Convert ENA Signal Rate to Flux
     flux_conversion_divisor = geometric_factor * esa_energy
     map_ds["ena_intensity"] = map_ds["ena_signal_rates"] / flux_conversion_divisor
-    map_ds["ena_intensity_stat_unc"] = (
+    map_ds["ena_intensity_stat_uncert"] = (
         map_ds["ena_signal_rate_stat_unc"] / flux_conversion_divisor
     )
     map_ds["ena_intensity_sys_err"] = map_ds["bg_rates_unc"] / flux_conversion_divisor
@@ -268,12 +268,12 @@ def calculate_ena_intensity(
         # dimension by passing the zeroth element.
         corrected_intensity, corrected_stat_unc = corrector.apply_flux_correction(
             map_ds["ena_intensity"].values[0],
-            map_ds["ena_intensity_stat_unc"].values[0],
+            map_ds["ena_intensity_stat_uncert"].values[0],
             esa_energy.data,
         )
         # Add the size 1 epoch dimension back in to the corrected fluxes.
         map_ds["ena_intensity"].data = corrected_intensity[np.newaxis, ...]
-        map_ds["ena_intensity_stat_unc"].data = corrected_stat_unc[np.newaxis, ...]
+        map_ds["ena_intensity_stat_uncert"].data = corrected_stat_unc[np.newaxis, ...]
 
     return map_ds
 
@@ -302,7 +302,7 @@ def combine_calibration_products(
     Returns
     -------
     map_ds : xarray.Dataset
-        Map dataset with updated variables: ena_intensity, ena_intensity_stat_unc,
+        Map dataset with updated variables: ena_intensity, ena_intensity_stat_uncert,
         ena_intensity_sys_err now combined across calibration products at each
         energy level.
     """
@@ -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_unc"] = 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"))
@@ -377,7 +372,7 @@ def _calculate_improved_stat_variance(
 
     if n_calib_prods <= 1:
         # No improvement possible with single calibration product
-        return map_ds["ena_intensity_stat_unc"] ** 2
+        return map_ds["ena_intensity_stat_uncert"] ** 2
 
     logger.debug("Computing geometric factor normalized signal rates")
 
@@ -417,7 +412,7 @@ def _calculate_improved_stat_variance(
     # Handle invalid cases by falling back to original uncertainties
     improved_variance = xr.where(
         ~np.isfinite(improved_variance) | (geometric_factors == 0),
-        map_ds["ena_intensity_stat_unc"],
+        map_ds["ena_intensity_stat_uncert"],
         improved_variance,
     )
 

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/ialirt_spice.py

@@ -177,7 +177,7 @@ def transform_instrument_vectors_to_inertial(
     )
 
     # Get static mount matrix
-    mount_matrix = spice.pxform(instrument_frame.name, spacecraft_frame.name, 0.0)
+    mount_matrix = spice.pxform(instrument_frame.name, spacecraft_frame.name, 0.0).T
 
     # Compute total rotations
     total_rotations = compute_total_rotation(

imap_processing/ialirt/l0/parse_mag.py

@@ -719,6 +719,39 @@ def process_packet(
                 "mag_theta_B_GSM": Decimal(str(theta_gsm[i])),
                 "mag_phi_B_GSE": Decimal(str(phi_gse[i])),
                 "mag_theta_B_GSE": Decimal(str(theta_gse[i])),
+                "mag_hk_status": {
+                    "hk1v5_warn": bool(status_data["hk1v5_warn"]),
+                    "hk1v5_danger": bool(status_data["hk1v5_danger"]),
+                    "hk1v5c_warn": bool(status_data["hk1v5c_warn"]),
+                    "hk1v5c_danger": bool(status_data["hk1v5c_danger"]),
+                    "hk1v8_warn": bool(status_data["hk1v8_warn"]),
+                    "hk1v8_danger": bool(status_data["hk1v8_danger"]),
+                    "hk1v8c_warn": bool(status_data["hk1v8c_warn"]),
+                    "hk1v8c_danger": bool(status_data["hk1v8c_danger"]),
+                    "fob_saturated": bool(status_data["fob_saturated"]),
+                    "fib_saturated": bool(status_data["fib_saturated"]),
+                    "mode": int(status_data["mode"]),
+                    "icu_temp": int(status_data["icu_temp"]),
+                    "hk2v5_warn": bool(status_data["hk2v5_warn"]),
+                    "hk2v5_danger": bool(status_data["hk2v5_danger"]),
+                    "hk2v5c_warn": bool(status_data["hk2v5c_warn"]),
+                    "hk2v5c_danger": bool(status_data["hk2v5c_danger"]),
+                    "hk3v3": int(status_data["hk3v3"]),
+                    "hk3v3_current": int(status_data["hk3v3_current"]),
+                    "pri_isvalid": bool(status_data["pri_isvalid"]),
+                    "hkp8v5_warn": bool(status_data["hkp8v5_warn"]),
+                    "hkp8v5_danger": bool(status_data["hkp8v5_danger"]),
+                    "hkp8v5c_warn": bool(status_data["hkp8v5c_warn"]),
+                    "hkp8v5c_danger": bool(status_data["hkp8v5c_danger"]),
+                    "hkn8v5": int(status_data["hkn8v5"]),
+                    "hkn8v5_current": int(status_data["hkn8v5_current"]),
+                    "fob_temp": int(status_data["fob_temp"]),
+                    "fib_temp": int(status_data["fib_temp"]),
+                    "fob_range": int(status_data["fob_range"]),
+                    "fib_range": int(status_data["fib_range"]),
+                    "multbit_errs": bool(status_data["multbit_errs"]),
+                    "sec_isvalid": bool(status_data["sec_isvalid"]),
+                },
             }
         )
 

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

@@ -154,6 +154,8 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
                 "sc_position_GSE",
                 "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 "

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(
@@ -295,7 +304,7 @@ def create_pset_counts(
     lat_edges = np.arange(41)
     energy_edges = np.arange(8)
 
-    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"
+        # )
+    )