imap-processing 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

imap_processing/ena_maps/utils/coordinates.py

@@ -0,0 +1,19 @@
+"""Define utils and classes related to coordinates of the ENA maps."""
+
+from enum import Enum
+
+
+class CoordNames(Enum):
+    """Enumeration of the names of the coordinates in the L1C and L2 ENA datasets."""
+
+    GENERIC_PIXEL = "pixel"
+
+    TIME = "epoch"
+    ENERGY = "energy"
+    HEALPIX_INDEX = "healpix_index"
+
+    # The names of the az/el angular coordinates may differ between L1C and L2 data
+    AZIMUTH_L1C = "longitude"
+    ELEVATION_L1C = "latitude"
+    AZIMUTH_L2 = "longitude"
+    ELEVATION_L2 = "latitude"

imap_processing/ena_maps/utils/map_utils.py

@@ -12,20 +12,22 @@ logger = logging.getLogger(__name__)
 
 def bin_single_array_at_indices(
     value_array: NDArray,
-    projection_grid_shape: tuple[int, int],
+    projection_grid_shape: tuple[int, ...],
     projection_indices: NDArray,
     input_indices: NDArray | None = None,
 ) -> NDArray:
     """
     Bin an array of values at the given indices.
 
+    NOTE: The output array's spatial axis is always the final (-1) axis.
+
     Parameters
     ----------
     value_array : NDArray
-        Array of values to bin. The 0th axis must be the one and only spatial axis.
+        Array of values to bin. The final axis be the one and only spatial axis.
         If other axes are present, they will be binned independently
-        along the 0th (spatial) axis.
-    projection_grid_shape : tuple[int]
+        along the spatial axis.
+    projection_grid_shape : tuple[int, ...]
         The shape of the grid onto which values are projected
         (rows, columns) if the grid is rectangular,
         or just (number of bins,) if the grid is 1D.
@@ -36,7 +38,7 @@ def bin_single_array_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), an arange of the same length as the
-        0th axis of value_array is used.
+        final axis of value_array is used.
 
     Returns
     -------
@@ -52,7 +54,7 @@ def bin_single_array_at_indices(
         If the input value_array has dimensionality less than 1.
     """
     if input_indices is None:
-        input_indices = np.arange(value_array.shape[0])
+        input_indices = np.arange(value_array.shape[-1])
 
     # Both sets of indices must be 1D with the same number of elements
     if input_indices.ndim != 1 or projection_indices.ndim != 1:
@@ -80,23 +82,18 @@ def bin_single_array_at_indices(
         binned_values = np.apply_along_axis(
             lambda x: np.bincount(
                 projection_indices,
-                weights=x[input_indices, ...],
+                weights=x[..., input_indices],
                 minlength=num_projection_indices,
             ),
-            axis=0,
+            axis=-1,
             arr=value_array,
         )
-    else:
-        raise NotImplementedError(
-            "Only 1+ Dimensional arrays are supported for binning. "
-            f"Received array with shape {value_array.shape}."
-        )
     return binned_values
 
 
 def bin_values_at_indices(
     input_values_to_bin: dict[str, NDArray],
-    projection_grid_shape: tuple[int, int],
+    projection_grid_shape: tuple[int, ...],
     projection_indices: NDArray,
     input_indices: NDArray | None = None,
 ) -> dict[str, NDArray]:
@@ -107,10 +104,10 @@ def bin_values_at_indices(
     ----------
     input_values_to_bin : dict[str, NDArray]
         Dict matching variable names to arrays of values to bin.
-        The 0th axis of each array must be the one and only spatial axis,
+        The final (-1) axis of each array must be the one and only spatial axis,
         which the indices correspond to and on which the values will be binned.
-        The other axes will be binned independently along this 0th axis.
-    projection_grid_shape : tuple[int, int]
+        The other axes will be binned independently along this final spatial axis.
+    projection_grid_shape : tuple[int, ...]
         The shape of the grid onto which values are projected (rows, columns).
         This size of the resulting grid (rows * columns) will be the size of the
         projected values contained in the output dictionary.

imap_processing/ena_maps/utils/spatial_utils.py

@@ -15,8 +15,7 @@ def build_spatial_bins(
     """
     Build spatial bin boundaries for azimuth and elevation.
 
-    Input angles in degrees for consistency with map inputs,
-    output angles in radians for internal use.
+    Input/output angles in degrees.
 
     Parameters
     ----------
@@ -28,13 +27,13 @@ def build_spatial_bins(
     Returns
     -------
     az_bin_edges : np.ndarray
-        Array of azimuth bin boundary values in radians.
+        Array of azimuth bin boundary values in degrees.
     el_bin_edges : np.ndarray
-        Array of elevation bin boundary values in radians.
+        Array of elevation bin boundary values in degrees.
     az_bin_midpoints : np.ndarray
-        Array of azimuth bin midpoint values in radians.
+        Array of azimuth bin midpoint values in degrees.
     el_bin_midpoints : np.ndarray
-        Array of elevation bin midpoint values in radians.
+        Array of elevation bin midpoint values in degrees.
     """
     # Azimuth bins from 0 to 360 degrees.
     az_bin_edges = np.arange(0, 360 + az_spacing_deg, az_spacing_deg)
@@ -44,12 +43,11 @@ def build_spatial_bins(
     el_bin_edges = np.arange(-90, 90 + el_spacing_deg, el_spacing_deg)
     el_bin_midpoints = el_bin_edges[:-1] + el_spacing_deg / 2  # Midpoints between edges
 
-    # Convert all angles to radians and return them
     return (
-        np.deg2rad(az_bin_edges),
-        np.deg2rad(el_bin_edges),
-        np.deg2rad(az_bin_midpoints),
-        np.deg2rad(el_bin_midpoints),
+        az_bin_edges,
+        el_bin_edges,
+        az_bin_midpoints,
+        el_bin_midpoints,
     )
 
 
@@ -59,6 +57,10 @@ def build_solid_angle_map(
     """
     Build a solid angle map in steradians for a given spacing in degrees.
 
+    NOTE: This function works in radians internally and returns steradians, while other
+    functions in this module work in degrees. Expressing solid angles in steradians
+    is the preferred unit for ENA Maps.
+
     Parameters
     ----------
     spacing_deg : float
@@ -96,23 +98,26 @@ def build_solid_angle_map(
 @typing.no_type_check
 def rewrap_even_spaced_az_el_grid(
     raveled_values: NDArray,
-    shape: tuple[int] | None = None,
+    grid_shape: tuple[int] | None = None,
     order: typing.Literal["C"] | typing.Literal["F"] = "C",
 ) -> NDArray:
     """
     Take an unwrapped (raveled) 1D array and reshapes it into a 2D az/el grid.
 
+    In the input, unwrapped grid, the spatial axis is the final (-1) axis.
+    In the output, the spatial axes are the -2 (azimuth) and -1 (elevation) axes.
+
     Assumes the following must be true of the original grid:
     1. Grid was evenly spaced in angular space,
     2. Grid had the same spacing in both azimuth and elevation.
-    3. Azimuth is axis 0 (and extends a total of 360 degrees).
-    4. Elevation is axis 1 (and extends a total of 180 degrees),
+    3. Azimuth is the first spatial axis (and extends a total of 360 degrees).
+    4. Elevation is the second spatial axis (and extends a total of 180 degrees).
 
     Parameters
     ----------
     raveled_values : NDArray
         1D array of values to be reshaped into a 2D grid.
-    shape : tuple[int], optional
+    grid_shape : tuple[int], optional
         The shape of the original grid, if known, by default None.
         If None, the shape will be inferred from the size of the input array.
     order : {'C', 'F'}, optional
@@ -121,35 +126,27 @@ def rewrap_even_spaced_az_el_grid(
     Returns
     -------
     NDArray
-        The reshaped 2D grid of values.
-
-    Raises
-    ------
-    ValueError
-        If the input is not a 1D array or 2D array with an 'extra' non-spatial axis.
+        The reshaped 2D grid of values with (azimuth, elevation) as the final 2 axes.
     """
-    if raveled_values.ndim > 2:
-        raise ValueError(
-            "Input must be a 1D array or 2D array with only one spatial axis as axis 0."
-        )
-
     # We can infer the shape if its evenly spaced and 2D
-    if not shape:
-        spacing_deg = 1 / np.sqrt(raveled_values.shape[0] / (360 * 180))
-        shape = (int(360 // spacing_deg), int(180 // spacing_deg))
+    if not grid_shape:
+        spacing_deg = 1 / np.sqrt(raveled_values.shape[-1] / (360 * 180))
+        grid_shape = (int(360 // spacing_deg), int(180 // spacing_deg))
 
-    if raveled_values.ndim == 2:
-        shape = (shape[0], shape[1], raveled_values.shape[1])
-    return raveled_values.reshape(shape, order=order)
+    if raveled_values.ndim == 1:
+        array_shape = grid_shape
+    else:
+        array_shape = (*raveled_values.shape[:-1], *grid_shape)
+    return raveled_values.reshape(array_shape, order=order)
 
 
 class AzElSkyGrid:
     """
     Representation of a 2D grid of azimuth and elevation angles covering the sky.
 
-    All angles are stored internally in radians.
-    Azimuth is within the range [0, 2*pi) radians,
-    elevation is within the range [-pi/2, pi/2) radians.
+    All angles are stored internally in degrees.
+    Azimuth is within the range [0, 360) degrees,
+    elevation is within the range [-90, 90) degrees.
 
     Parameters
     ----------
@@ -157,13 +154,13 @@ class AzElSkyGrid:
         Spacing of the grid in degrees, by default 0.5.
     reversed_elevation : bool, optional
         Whether the elevation grid should be reversed, by default False.
-        If False, the elevation grid will be from -pi/2 to pi/2 radians (-90 to 90 deg).
-        If True, the elevation grid will be from pi/2 to -pi/2 radians (90 to -90 deg).
+        If False, the elevation grid will be from -90 to 90 deg.
+        If True, the elevation grid will be from 90 to -90 deg.
 
     Raises
     ------
     ValueError
-        If the spacing is not positive or does not divide evenly into pi radians.
+        If the spacing is not positive or does not divide evenly into 180 degrees.
     """
 
     def __init__(
@@ -174,25 +171,26 @@ class AzElSkyGrid:
         # Store grid properties
         self.reversed_elevation = reversed_elevation
 
-        # Internally, work in radians, regardless of desired output units
-        self.spacing = np.deg2rad(spacing_deg)
+        # Internally, work in degrees
+        self.spacing_deg = spacing_deg
 
-        # Ensure valid grid spacing (positive, divides evenly into pi radians)
-        if self.spacing <= 0:
+        # Ensure valid grid spacing (positive, divides evenly into 180 degrees)
+        if self.spacing_deg <= 0:
             raise ValueError("Spacing must be positive valued, non-zero.")
 
-        if not np.isclose((np.pi / self.spacing) % 1, 0):
-            raise ValueError("Spacing must divide evenly into pi radians.")
+        if not np.isclose((180 / self.spacing_deg) % 1, 0):
+            raise ValueError("Spacing must divide evenly into 180 degrees.")
 
         # build_spacial_bins creates the bin edges and centers for azimuth and elevation
         # E.g. for spacing=1, az_bin_edges = [0, 1, 2, ..., 359, 360] deg.
-        # However returned values are in radians.
         (
             self.az_bin_edges,
             self.el_bin_edges,
             self.az_bin_midpoints,
             self.el_bin_midpoints,
-        ) = build_spatial_bins(az_spacing_deg=spacing_deg, el_spacing_deg=spacing_deg)
+        ) = build_spatial_bins(
+            az_spacing_deg=self.spacing_deg, el_spacing_deg=self.spacing_deg
+        )
 
         # If desired, reverse the elevation range so that the grid is in the order
         # defined by the Ultra prototype code (`build_dps_grid.m`).
@@ -221,6 +219,6 @@ class AzElSkyGrid:
             A string representation of the AzElSkyGrid.
         """
         return (
-            f"AzElSkyGrid with a spacing of {self.spacing:.4e} radians. "
+            f"AzElSkyGrid with a spacing of {self.spacing_deg:.4e} degrees. "
             f"{self.grid_shape} Grid."
         )

imap_processing/hi/l1a/hi_l1a.py

@@ -7,8 +7,8 @@ from typing import Union
 import xarray as xr
 
 from imap_processing import imap_module_directory
+from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.hi.l1a.histogram import create_dataset as hist_create_dataset
-from imap_processing.hi.l1a.housekeeping import process_housekeeping
 from imap_processing.hi.l1a.science_direct_event import science_direct_event
 from imap_processing.hi.utils import HIAPID
 from imap_processing.utils import packet_file_to_datasets
@@ -42,30 +42,36 @@ def hi_l1a(packet_file_path: Union[str, Path], data_version: str) -> list[xr.Dat
     # Process science to l1a.
     processed_data = []
     for apid in datasets_by_apid:
-        if apid in [HIAPID.H45_SCI_CNT, HIAPID.H90_SCI_CNT]:
-            logger.info(
-                "Processing histogram data for [%s] packets", HIAPID.H45_SCI_CNT.name
-            )
-            data = hist_create_dataset(datasets_by_apid[apid])
-        elif apid in [HIAPID.H45_SCI_DE, HIAPID.H90_SCI_DE]:
-            logger.info(
-                "Processing direct event data for [%s] packets", HIAPID.H45_SCI_DE.name
-            )
+        try:
+            apid_enum = HIAPID(apid)
+        except ValueError as err:
+            raise RuntimeError(f"Encountered unexpected APID [{apid}]") from err
+
+        logger.info(f"Processing IMAP-Hi data for {apid_enum.name} packets")
 
+        if apid_enum in [HIAPID.H45_SCI_CNT, HIAPID.H90_SCI_CNT]:
+            data = hist_create_dataset(datasets_by_apid[apid])
+            gattr_key = "imap_hi_l1a_hist_attrs"
+        elif apid_enum in [HIAPID.H45_SCI_DE, HIAPID.H90_SCI_DE]:
             data = science_direct_event(datasets_by_apid[apid])
-        elif apid in [HIAPID.H45_APP_NHK, HIAPID.H90_APP_NHK]:
-            logger.info(
-                "Processing housekeeping data for [%s] packets", HIAPID.H45_APP_NHK.name
-            )
-            data = process_housekeeping(datasets_by_apid[apid])
-        else:
-            raise RuntimeError(f"Encountered unexpected APID [{apid}]")
+            gattr_key = "imap_hi_l1a_de_attrs"
+        elif apid_enum in [HIAPID.H45_APP_NHK, HIAPID.H90_APP_NHK]:
+            data = datasets_by_apid[apid]
+            gattr_key = "imap_hi_l1a_hk_attrs"
+        elif apid_enum in [HIAPID.H45_DIAG_FEE, HIAPID.H90_DIAG_FEE]:
+            data = datasets_by_apid[apid]
+            gattr_key = "imap_hi_l1a_diagfee_attrs"
+
+        # Update dataset global attributes
+        attr_mgr = ImapCdfAttributes()
+        attr_mgr.add_instrument_global_attrs("hi")
+        data.attrs.update(attr_mgr.get_global_attributes(gattr_key))
 
         # TODO: revisit this
         data.attrs["Data_version"] = data_version
 
         # set the sensor string in Logical_source
-        sensor_str = HIAPID(apid).sensor
+        sensor_str = apid_enum.sensor
         data.attrs["Logical_source"] = data.attrs["Logical_source"].format(
             sensor=sensor_str
         )

imap_processing/hi/l1a/histogram.py

@@ -116,7 +116,6 @@ def create_dataset(input_ds: xr.Dataset) -> xr.Dataset:
     )
 
     dataset.update(new_vars)
-    dataset.attrs.update(attr_mgr.get_global_attributes("imap_hi_l1a_hist_attrs"))
 
     return dataset
 

imap_processing/hi/l1a/science_direct_event.py

@@ -31,11 +31,11 @@ def parse_direct_events(de_data: bytes) -> dict[str, npt.ArrayLike]:
     IMAP-Hi direct event data information is stored in
     48-bits as follows:
 
-    |        Read 48-bits into 2, 16, 10, 10, 10, bits. Each of these breaks
+    |        Read 48-bits into 16, 2, 10, 10, 10, bits. Each of these breaks
     |        down as:
     |
-    |            start_bitmask_data - 2 bits (tA=1, tB=2, tC1=3, META=0)
     |            de_tag - 16 bits
+    |            start_bitmask_data - 2 bits (tA=1, tB=2, tC1=3)
     |            tof_1 - 10 bit counter
     |            tof_2 - 10 bit counter
     |            tof_3 - 10 bit counter
@@ -70,16 +70,16 @@ def parse_direct_events(de_data: bytes) -> dict[str, npt.ArrayLike]:
     # direct events.
     # Considering the 6-bytes of data for each DE as 3 2-byte words,
     # each word contains the following:
-    # word_0: 2-bits of Trigger ID, upper 14-bits of de_tag
-    # word_1: lower 2-bits of de_tag, 10-bits tof_1, upper 4-bits of tof_2
+    # word_0: full 16-bits is the de_tag
+    # word_1: 2-bits of Trigger ID, 10-bits tof_1, upper 4-bits of tof_2
     # word_2: lower 6-bits of tof_2, 10-bits of tof_3
     data_uint16 = np.reshape(
         np.frombuffer(de_data, dtype=">u2"), (3, -1), order="F"
     ).astype(np.uint16)
 
     de_dict = dict()
-    de_dict["trigger_id"] = (data_uint16[0] >> 14).astype(np.uint8)
-    de_dict["de_tag"] = (data_uint16[0] << 2) + (data_uint16[1] >> 14)
+    de_dict["de_tag"] = data_uint16[0]
+    de_dict["trigger_id"] = (data_uint16[1] >> 14).astype(np.uint8)
     de_dict["tof_1"] = (data_uint16[1] & int(b"00111111_11110000", 2)) >> 4
     de_dict["tof_2"] = ((data_uint16[1] & int(b"00000000_00001111", 2)) << 6) + (
         data_uint16[2] >> 10
@@ -147,10 +147,8 @@ def create_dataset(de_data_dict: dict[str, npt.ArrayLike]) -> xr.Dataset:
         attrs=event_met_attrs,
     )
 
-    de_global_attrs = attr_mgr.get_global_attributes("imap_hi_l1a_de_attrs")
     dataset = xr.Dataset(
         coords={"epoch": epoch, "event_met": event_met},
-        attrs=de_global_attrs,
     )
 
     for var_name, data in de_data_dict.items():

imap_processing/hi/l1b/hi_l1b.py

@@ -12,6 +12,7 @@ from imap_processing.cdf.utils import parse_filename_like
 from imap_processing.hi.l1a.science_direct_event import HALF_CLOCK_TICK_S
 from imap_processing.hi.utils import (
     HIAPID,
+    CoincidenceBitmap,
     HiConstants,
     create_dataset_variables,
     parse_sensor_number,
@@ -36,15 +37,6 @@ class TriggerId(IntEnum):
     C = 3
 
 
-class CoincidenceBitmap(IntEnum):
-    """IntEnum class for coincidence type bitmap values."""
-
-    A = 2**3
-    B = 2**2
-    C1 = 2**1
-    C2 = 2**0
-
-
 logger = logging.getLogger(__name__)
 ATTR_MGR = ImapCdfAttributes()
 ATTR_MGR.add_instrument_global_attrs("hi")
@@ -124,7 +116,7 @@ def annotate_direct_events(l1a_dataset: xr.Dataset) -> xr.Dataset:
     """
     l1b_dataset = l1a_dataset.copy()
     l1b_dataset.update(de_esa_energy_step(l1b_dataset))
-    l1b_dataset.update(compute_coincidence_type_and_time_deltas(l1b_dataset))
+    l1b_dataset.update(compute_coincidence_type_and_tofs(l1b_dataset))
     l1b_dataset.update(de_nominal_bin_and_spin_phase(l1b_dataset))
     l1b_dataset.update(compute_hae_coordinates(l1b_dataset))
     l1b_dataset.update(
@@ -154,14 +146,14 @@ def annotate_direct_events(l1a_dataset: xr.Dataset) -> xr.Dataset:
     return l1b_dataset
 
 
-def compute_coincidence_type_and_time_deltas(
+def compute_coincidence_type_and_tofs(
     dataset: xr.Dataset,
 ) -> dict[str, xr.DataArray]:
     """
-    Compute coincidence type and time deltas.
+    Compute coincidence type and time of flights.
 
-    Generates the new variables "coincidence_type", "delta_t_ab", "delta_t_ac1",
-    "delta_t_bc1", and "delta_t_c1c2" and returns a dictionary with the new
+    Generates the new variables "coincidence_type", "tof_ab", "tof_ac1",
+    "tof_bc1", and "tof_c1c2" and returns a dictionary with the new
     variables that can be added to the input dataset by calling the
     xarray.Dataset.update method.
 
@@ -178,16 +170,16 @@ def compute_coincidence_type_and_time_deltas(
     new_vars = create_dataset_variables(
         [
             "coincidence_type",
-            "delta_t_ab",
-            "delta_t_ac1",
-            "delta_t_bc1",
-            "delta_t_c1c2",
+            "tof_ab",
+            "tof_ac1",
+            "tof_bc1",
+            "tof_c1c2",
         ],
         len(dataset.event_met),
         att_manager_lookup_str="hi_de_{0}",
     )
 
-    # compute masks needed for coincidence type and delta t calculations
+    # compute masks needed for coincidence type and ToF calculations
     a_first = dataset.trigger_id.values == TriggerId.A
     b_first = dataset.trigger_id.values == TriggerId.B
     c_first = dataset.trigger_id.values == TriggerId.C
@@ -221,56 +213,56 @@ def compute_coincidence_type_and_time_deltas(
     # |      2      |      B      |  t_a - t_b  | t_c1 - t_b  | t_c2 - t_c1 |
     # |      3      |      C      |  t_a - t_c1 | t_b  - t_c1 | t_c2 - t_c1 |
 
-    # Prepare for delta_t calculations by converting TOF values to nanoseconds
+    # Prepare for L1B ToF calculations by converting L1A TOF values to nanoseconds
     tof_1_ns = (dataset.tof_1.values * HiConstants.TOF1_TICK_DUR).astype(np.int32)
     tof_2_ns = (dataset.tof_2.values * HiConstants.TOF2_TICK_DUR).astype(np.int32)
     tof_3_ns = (dataset.tof_3.values * HiConstants.TOF3_TICK_DUR).astype(np.int32)
 
-    # # ********** delta_t_ab = (t_b - t_a) **********
+    # # ********** tof_ab = (t_b - t_a) **********
     # Table: row 1, column 1
     a_and_tof1 = a_first & tof1_valid
-    new_vars["delta_t_ab"].values[a_and_tof1] = tof_1_ns[a_and_tof1]
+    new_vars["tof_ab"].values[a_and_tof1] = tof_1_ns[a_and_tof1]
     # Table: row 2, column 1
     b_and_tof1 = b_first & tof1_valid
-    new_vars["delta_t_ab"].values[b_and_tof1] = -1 * tof_1_ns[b_and_tof1]
+    new_vars["tof_ab"].values[b_and_tof1] = -1 * tof_1_ns[b_and_tof1]
     # Table: row 3, column 1 and 2
-    # delta_t_ab = (t_b - t_c1) - (t_a - t_c1) = (t_b - t_a)
+    # tof_ab = (t_b - t_c1) - (t_a - t_c1) = (t_b - t_a)
     c_and_tof1and2 = c_first & tof1and2_valid
-    new_vars["delta_t_ab"].values[c_and_tof1and2] = (
+    new_vars["tof_ab"].values[c_and_tof1and2] = (
         tof_2_ns[c_and_tof1and2] - tof_1_ns[c_and_tof1and2]
     )
 
-    # ********** delta_t_ac1 = (t_c1 - t_a) **********
+    # ********** tof_ac1 = (t_c1 - t_a) **********
     # Table: row 1, column 2
     a_and_tof2 = a_first & tof2_valid
-    new_vars["delta_t_ac1"].values[a_and_tof2] = tof_2_ns[a_and_tof2]
+    new_vars["tof_ac1"].values[a_and_tof2] = tof_2_ns[a_and_tof2]
     # Table: row 2, column 1 and 2
-    # delta_t_ac1 = (t_c1 - t_b) - (t_a - t_b) = (t_c1 - t_a)
+    # tof_ac1 = (t_c1 - t_b) - (t_a - t_b) = (t_c1 - t_a)
     b_and_tof1and2 = b_first & tof1and2_valid
-    new_vars["delta_t_ac1"].values[b_and_tof1and2] = (
+    new_vars["tof_ac1"].values[b_and_tof1and2] = (
         tof_2_ns[b_and_tof1and2] - tof_1_ns[b_and_tof1and2]
     )
     # Table: row 3, column 1
     c_and_tof1 = c_first & tof1_valid
-    new_vars["delta_t_ac1"].values[c_and_tof1] = -1 * tof_1_ns[c_and_tof1]
+    new_vars["tof_ac1"].values[c_and_tof1] = -1 * tof_1_ns[c_and_tof1]
 
-    # ********** delta_t_bc1 = (t_c1 - t_b) **********
+    # ********** tof_bc1 = (t_c1 - t_b) **********
     # Table: row 1, column 1 and 2
-    # delta_t_bc1 = (t_c1 - t_a) - (t_b - t_a) => (t_c1 - t_b)
+    # tof_bc1 = (t_c1 - t_a) - (t_b - t_a) => (t_c1 - t_b)
     a_and_tof1and2 = a_first & tof1and2_valid
-    new_vars["delta_t_bc1"].values[a_and_tof1and2] = (
+    new_vars["tof_bc1"].values[a_and_tof1and2] = (
         tof_2_ns[a_and_tof1and2] - tof_1_ns[a_and_tof1and2]
     )
     # Table: row 2, column 2
     b_and_tof2 = b_first & tof2_valid
-    new_vars["delta_t_bc1"].values[b_and_tof2] = tof_2_ns[b_and_tof2]
+    new_vars["tof_bc1"].values[b_and_tof2] = tof_2_ns[b_and_tof2]
     # Table: row 3, column 2
     c_and_tof2 = c_first & tof2_valid
-    new_vars["delta_t_bc1"].values[c_and_tof2] = -1 * tof_2_ns[c_and_tof2]
+    new_vars["tof_bc1"].values[c_and_tof2] = -1 * tof_2_ns[c_and_tof2]
 
-    # ********** delta_t_c1c2 = (t_c2 - t_c1) **********
+    # ********** tof_c1c2 = (t_c2 - t_c1) **********
     # Table: all rows, column 3
-    new_vars["delta_t_c1c2"].values[tof3_valid] = tof_3_ns[tof3_valid]
+    new_vars["tof_c1c2"].values[tof3_valid] = tof_3_ns[tof3_valid]
 
     return new_vars
 
@@ -325,8 +317,8 @@ def compute_hae_coordinates(dataset: xr.Dataset) -> dict[str, xr.DataArray]:
     Parameters
     ----------
     dataset : xarray.Dataset
-        The partial L1B dataset that has had coincidence type, time deltas, and
-        spin phase computed and added to the L1A data.
+        The partial L1B dataset that has had coincidence type, times of flight,
+        and spin phase computed and added to the L1A data.
 
     Returns
     -------