imap-processing 0.19.0__py3-none-any.whl → 0.19.3__py3-none-any.whl

imap_processing/ultra/l1b/de.py

@@ -42,6 +42,7 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 FILLVAL_UINT8 = 255
+FILLVAL_UINT32 = 4294967295
 FILLVAL_FLOAT32 = -1.0e31
 
 
@@ -82,7 +83,6 @@ def calculate_de(
         "event_type",
         "de_event_met",
         "phase_angle",
-        "spin",
     ]
     dataset_keys = [
         "coin_type",
@@ -90,7 +90,6 @@ def calculate_de(
         "stop_type",
         "shcoarse",
         "phase_angle",
-        "spin",
     ]
 
     de_dict.update(
@@ -127,6 +126,7 @@ def calculate_de(
     magnitude_v = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
     energy = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
     e_bin = np.full(len(de_dataset["epoch"]), FILLVAL_UINT8, dtype=np.uint8)
+    e_bin_l1a = np.full(len(de_dataset["epoch"]), FILLVAL_UINT8, dtype=np.uint8)
     species_bin = np.full(len(de_dataset["epoch"]), FILLVAL_UINT8, dtype=np.uint8)
     t2 = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
     event_times = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
@@ -143,6 +143,7 @@ def calculate_de(
     quality_flags = np.full(
         de_dataset["epoch"].shape, ImapDEOutliersUltraFlags.NONE.value, dtype=np.uint16
     )
+
     scattering_quality_flags = np.full(
         de_dataset["epoch"].shape,
         ImapDEScatteringUltraFlags.NONE.value,
@@ -196,7 +197,6 @@ def calculate_de(
         (xb[ph_indices], yb[ph_indices]),
         d[ph_indices],
     )
-    species_bin[ph_indices] = determine_species(tof[ph_indices], r[ph_indices], "PH")
     etof[ph_indices], xc[ph_indices] = get_coincidence_positions(
         de_dataset.isel(epoch=ph_indices),
         t2[ph_indices],
@@ -213,8 +213,13 @@ def calculate_de(
         etof[ph_indices],
         xc[ph_indices],
         xb[ph_indices],
+        de_dataset["stop_north_tdc"][ph_indices].values,
+        de_dataset["stop_south_tdc"][ph_indices].values,
+        de_dataset["stop_east_tdc"][ph_indices].values,
+        de_dataset["stop_west_tdc"][ph_indices].values,
         f"ultra{sensor}",
         ancillary_files,
+        quality_flags[ph_indices],
     )
     e_bin[ph_indices] = determine_ebin_pulse_height(
         energy[ph_indices],
@@ -224,6 +229,7 @@ def calculate_de(
         coinphvalid,
         ancillary_files,
     )
+    species_bin[ph_indices] = determine_species(e_bin[ph_indices], "PH")
     ctof[ph_indices], magnitude_v[ph_indices] = get_ctof(
         tof[ph_indices], r[ph_indices], "PH"
     )
@@ -257,9 +263,7 @@ def calculate_de(
         f"ultra{sensor}",
         ancillary_files,
     )
-    species_bin[ssd_indices] = determine_species(
-        tof[ssd_indices], r[ssd_indices], "SSD"
-    )
+    species_bin[ssd_indices] = determine_species(e_bin[ssd_indices], "SSD")
     ctof[ssd_indices], magnitude_v[ssd_indices] = get_ctof(
         tof[ssd_indices], r[ssd_indices], "SSD"
     )
@@ -289,7 +293,6 @@ def calculate_de(
             de_dict["tof_start_stop"][valid_indices],
         )
     )
-    de_dict["direct_event_velocity"] = velocities.astype(np.float32)
     de_dict["direct_event_unit_velocity"] = v_hat.astype(np.float32)
     de_dict["direct_event_unit_position"] = r_hat.astype(np.float32)
 
@@ -298,7 +301,10 @@ def calculate_de(
     )
     de_dict["tof_energy"] = tof_energy
     de_dict["energy"] = energy
-    de_dict["ebin"] = e_bin
+    de_dict["computed_ebin"] = e_bin
+    valid_ebin = de_dataset["bin"].values != FILLVAL_UINT32
+    e_bin_l1a[valid_ebin] = de_dataset["bin"].values[valid_ebin]
+    de_dict["ebin"] = e_bin_l1a
     de_dict["species"] = species_bin
 
     # Annotated Events.
@@ -313,7 +319,7 @@ def calculate_de(
             helio_velocity[valid_events],
         ) = get_annotated_particle_velocity(
             event_times[valid_events],
-            de_dict["direct_event_velocity"][valid_events],
+            velocities.astype(np.float32)[valid_events],
             ultra_frame,
             SpiceFrame.IMAP_DPS,
             SpiceFrame.IMAP_SPACECRAFT,

imap_processing/ultra/l1b/extendedspin.py

@@ -2,6 +2,7 @@
 
 import numpy as np
 import xarray as xr
+from numpy.typing import NDArray
 
 from imap_processing.ultra.l1b.ultra_l1b_culling import (
     count_rejected_events_per_spin,
@@ -15,6 +16,7 @@ from imap_processing.ultra.l1b.ultra_l1b_culling import (
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 FILLVAL_UINT16 = 65535
+FILLVAL_FLOAT32 = -1.0e31
 
 
 def calculate_extendedspin(
@@ -44,7 +46,7 @@ def calculate_extendedspin(
     de_dataset = dict_datasets[f"imap_ultra_l1b_{instrument_id}sensor-de"]
 
     extendedspin_dict = {}
-    rates_qf, spin, energy_midpoints, n_sigma_per_energy = flag_rates(
+    rates_qf, spin, energy_bin_geometric_mean, n_sigma_per_energy = flag_rates(
         de_dataset["spin"].values,
         de_dataset["energy"].values,
     )
@@ -58,12 +60,6 @@ def calculate_extendedspin(
     hk_qf = flag_hk(de_dataset["spin"].values)
     inst_qf = flag_imap_instruments(de_dataset["spin"].values)
 
-    # Get the first epoch for each spin.
-    mask = xr.DataArray(np.isin(de_dataset["spin"], spin), dims="epoch")
-    filtered_dataset = de_dataset.where(mask, drop=True)
-    _, first_indices = np.unique(filtered_dataset["spin"].values, return_index=True)
-    first_epochs = filtered_dataset["epoch"].values[first_indices]
-
     # Get the number of pulses per spin.
     pulses = get_pulses_per_spin(rates_dataset)
 
@@ -75,18 +71,34 @@ def calculate_extendedspin(
         de_dataset["quality_outliers"].values,
     )
     # These will be the coordinates.
-    extendedspin_dict["epoch"] = first_epochs
     extendedspin_dict["spin_number"] = spin
-    extendedspin_dict["energy_bin_geometric_mean"] = energy_midpoints
+    extendedspin_dict["energy_bin_geometric_mean"] = energy_bin_geometric_mean
 
     extendedspin_dict["ena_rates"] = count_rates
     extendedspin_dict["ena_rates_threshold"] = n_sigma_per_energy
     extendedspin_dict["spin_start_time"] = spin_starttime
     extendedspin_dict["spin_period"] = spin_period
     extendedspin_dict["spin_rate"] = spin_rates
-    extendedspin_dict["start_pulses_per_spin"] = pulses.start_per_spin
-    extendedspin_dict["stop_pulses_per_spin"] = pulses.stop_per_spin
-    extendedspin_dict["coin_pulses_per_spin"] = pulses.coin_per_spin
+
+    # Get index of pulses.unique_spins corresponding to each spin.
+    idx: NDArray[np.intp] = np.searchsorted(pulses.unique_spins, spin)
+
+    # Validate that the spin values match
+    valid = (idx < pulses.unique_spins.size) & (pulses.unique_spins[idx] == spin)
+
+    start_per_spin = np.full(len(spin), FILLVAL_FLOAT32, dtype=np.float32)
+    stop_per_spin = np.full(len(spin), FILLVAL_FLOAT32, dtype=np.float32)
+    coin_per_spin = np.full(len(spin), FILLVAL_FLOAT32, dtype=np.float32)
+
+    # Fill only the valid ones
+    start_per_spin[valid] = pulses.start_per_spin[idx[valid]]
+    stop_per_spin[valid] = pulses.stop_per_spin[idx[valid]]
+    coin_per_spin[valid] = pulses.coin_per_spin[idx[valid]]
+
+    # account for rates spins which are not in the direct event spins
+    extendedspin_dict["start_pulses_per_spin"] = start_per_spin
+    extendedspin_dict["stop_pulses_per_spin"] = stop_per_spin
+    extendedspin_dict["coin_pulses_per_spin"] = coin_per_spin
     extendedspin_dict["rejected_events_per_spin"] = rejected_counts
     extendedspin_dict["quality_attitude"] = attitude_qf
     extendedspin_dict["quality_ena_rates"] = rates_qf

imap_processing/ultra/l1b/goodtimes.py

@@ -0,0 +1,112 @@
+"""Calculate Goodtimes."""
+
+import numpy as np
+import xarray as xr
+
+from imap_processing.ultra.l1b.quality_flag_filters import SPIN_QUALITY_FLAG_FILTERS
+from imap_processing.ultra.utils.ultra_l1_utils import create_dataset, extract_data_dict
+
+FILLVAL_UINT16 = 65535
+FILLVAL_FLOAT32 = -1.0e31
+FILLVAL_FLOAT64 = -1.0e31
+FILLVAL_UINT32 = 4294967295
+
+
+def calculate_goodtimes(extendedspin_dataset: xr.Dataset, name: str) -> xr.Dataset:
+    """
+    Create dataset with defined datatype for Goodtimes Data.
+
+    Parameters
+    ----------
+    extendedspin_dataset : xarray.Dataset
+        Dataset containing the data.
+    name : str
+        Name of the dataset.
+
+    Returns
+    -------
+    goodtimes_dataset : xarray.Dataset
+        Dataset containing the extendedspin data that remains after culling.
+    """
+    n_bins = extendedspin_dataset.dims["energy_bin_geometric_mean"]
+    # If the spin rate was too high or low then the spin should be thrown out.
+    # If the rates at any energy level are too high then throw out the entire spin.
+    good_mask = (
+        (
+            extendedspin_dataset["quality_attitude"]
+            & sum(flag.value for flag in SPIN_QUALITY_FLAG_FILTERS["quality_attitude"])
+        )
+        == 0
+    ) & (
+        (
+            (
+                extendedspin_dataset["quality_ena_rates"]
+                & sum(
+                    flag.value
+                    for flag in SPIN_QUALITY_FLAG_FILTERS["quality_ena_rates"]
+                )
+            )
+            == 0
+        ).all(dim="energy_bin_geometric_mean")
+    )
+    filtered_dataset = extendedspin_dataset.sel(
+        spin_number=extendedspin_dataset["spin_number"][good_mask]
+    )
+
+    data_dict = extract_data_dict(filtered_dataset)
+
+    goodtimes_dataset = create_dataset(data_dict, name, "l1b")
+
+    if goodtimes_dataset["spin_number"].size == 0:
+        goodtimes_dataset = goodtimes_dataset.drop_dims("spin_number")
+        goodtimes_dataset = goodtimes_dataset.expand_dims(spin_number=[FILLVAL_UINT32])
+        goodtimes_dataset["spin_start_time"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT64], dtype="float64"), dims=["spin_number"]
+        )
+        goodtimes_dataset["spin_period"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT64], dtype="float64"), dims=["spin_number"]
+        )
+        goodtimes_dataset["spin_rate"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT64], dtype="float64"), dims=["spin_number"]
+        )
+        goodtimes_dataset["start_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["stop_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["coin_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["rejected_events_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_UINT32], dtype="uint32"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["quality_attitude"] = xr.DataArray(
+            np.array([FILLVAL_UINT16], dtype="uint16"), dims=["spin_number"]
+        )
+        goodtimes_dataset["quality_hk"] = xr.DataArray(
+            np.array([FILLVAL_UINT16], dtype="uint16"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["quality_instruments"] = xr.DataArray(
+            np.array([FILLVAL_UINT16], dtype="uint16"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["quality_ena_rates"] = (
+            ("energy_bin_geometric_mean", "spin_number"),
+            np.full((n_bins, 1), FILLVAL_UINT16, dtype="uint16"),
+        )
+        goodtimes_dataset["ena_rates"] = (
+            ("energy_bin_geometric_mean", "spin_number"),
+            np.full((n_bins, 1), FILLVAL_FLOAT64, dtype="float64"),
+        )
+        goodtimes_dataset["ena_rates_threshold"] = (
+            ("energy_bin_geometric_mean", "spin_number"),
+            np.full((n_bins, 1), FILLVAL_FLOAT32, dtype="float32"),
+        )
+
+    return goodtimes_dataset

imap_processing/ultra/l1b/lookup_utils.py

@@ -345,7 +345,7 @@ def load_scattering_lookup_tables(ancillary_files: dict, instrument_id: int) ->
     # TODO remove the line below when the 45 sensor scattering coefficients are
     #  delivered.
     instrument_id = 90
-    descriptor = f"l1b-{instrument_id}sensor-scattering-calibration"
+    descriptor = f"l1b-{instrument_id}sensor-scattering-calibration-data"
     theta_grid = pd.read_csv(
         ancillary_files[descriptor], header=None, skiprows=7, nrows=241
     ).to_numpy(dtype=float)

imap_processing/ultra/l1b/ultra_l1b.py

@@ -3,9 +3,9 @@
 import xarray as xr
 
 from imap_processing.ultra.l1b.badtimes import calculate_badtimes
-from imap_processing.ultra.l1b.cullingmask import calculate_cullingmask
 from imap_processing.ultra.l1b.de import calculate_de
 from imap_processing.ultra.l1b.extendedspin import calculate_extendedspin
+from imap_processing.ultra.l1b.goodtimes import calculate_goodtimes
 
 
 def ultra_l1b(data_dict: dict, ancillary_files: dict) -> list[xr.Dataset]:
@@ -29,7 +29,7 @@ def ultra_l1b(data_dict: dict, ancillary_files: dict) -> list[xr.Dataset]:
     General flow:
     1. l1a data products are created (upstream to this code)
     2. l1b de is created here and dropped in s3 kicking off processing again
-    3. l1b extended, culling, badtimes created here
+    3. l1b extended, goodtimes, badtimes created here
     """
     output_datasets = []
 
@@ -72,22 +72,22 @@ def ultra_l1b(data_dict: dict, ancillary_files: dict) -> list[xr.Dataset]:
             output_datasets.append(extendedspin_dataset)
         elif (
             f"imap_ultra_l1b_{instrument_id}sensor-extendedspin" in data_dict
-            and f"imap_ultra_l1b_{instrument_id}sensor-cullingmask" in data_dict
+            and f"imap_ultra_l1b_{instrument_id}sensor-goodtimes" in data_dict
         ):
             badtimes_dataset = calculate_badtimes(
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-extendedspin"],
-                data_dict[f"imap_ultra_l1b_{instrument_id}sensor-cullingmask"][
+                data_dict[f"imap_ultra_l1b_{instrument_id}sensor-goodtimes"][
                     "spin_number"
                 ].values,
                 f"imap_ultra_l1b_{instrument_id}sensor-badtimes",
             )
             output_datasets.append(badtimes_dataset)
         elif f"imap_ultra_l1b_{instrument_id}sensor-extendedspin" in data_dict:
-            cullingmask_dataset = calculate_cullingmask(
+            goodtimes_dataset = calculate_goodtimes(
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-extendedspin"],
-                f"imap_ultra_l1b_{instrument_id}sensor-cullingmask",
+                f"imap_ultra_l1b_{instrument_id}sensor-goodtimes",
             )
-            output_datasets.append(cullingmask_dataset)
+            output_datasets.append(goodtimes_dataset)
     if not output_datasets:
         raise ValueError("Data dictionary does not contain the expected keys.")
 

imap_processing/ultra/l1b/ultra_l1b_culling.py

@@ -31,6 +31,7 @@ SPIN_DURATION = 15  # Default spin duration in seconds.
 RateResult = namedtuple(
     "RateResult",
     [
+        "unique_spins",
         "start_per_spin",
         "stop_per_spin",
         "coin_per_spin",
@@ -249,8 +250,8 @@ def flag_rates(
         Quality flags.
     spin : NDArray
         Spin data.
-    energy_midpoints : NDArray
-        Energy midpoint data.
+    energy_bin_geometric_mean : NDArray
+        Energy bin geometric mean.
     n_sigma_per_energy_reshape : NDArray
         N sigma per energy.
     """
@@ -264,7 +265,7 @@ def flag_rates(
     threshold = get_n_sigma(count_rates, duration, sigma=sigma)
 
     bin_edges = np.array(UltraConstants.CULLING_ENERGY_BIN_EDGES)
-    energy_midpoints = np.sqrt(bin_edges[:-1] * bin_edges[1:])
+    energy_bin_geometric_mean = np.sqrt(bin_edges[:-1] * bin_edges[1:])
     spin = np.unique(spin_number)
 
     # Indices where the counts exceed the threshold
@@ -275,7 +276,7 @@ def flag_rates(
     quality_flags[:, 0] |= ImapRatesUltraFlags.FIRSTSPIN.value
     quality_flags[:, -1] |= ImapRatesUltraFlags.LASTSPIN.value
 
-    return quality_flags, spin, energy_midpoints, threshold
+    return quality_flags, spin, energy_bin_geometric_mean, threshold
 
 
 def compare_aux_univ_spin_table(
@@ -424,6 +425,8 @@ def get_pulses_per_spin(rates: xr.Dataset) -> RateResult:
 
     Returns
     -------
+    unique_spins : NDArray
+        Unique spin numbers.
     start_per_spin : NDArray
         Total start pulses per spin.
     stop_per_spin : NDArray
@@ -474,6 +477,7 @@ def get_pulses_per_spin(rates: xr.Dataset) -> RateResult:
     coin_per_spin = np.bincount(spin_idx, weights=coin_pulses)
 
     return RateResult(
+        unique_spins=unique_spins,
         start_per_spin=start_per_spin,
         stop_per_spin=stop_per_spin,
         coin_per_spin=coin_per_spin,

imap_processing/ultra/l1b/ultra_l1b_extended.py

@@ -12,7 +12,9 @@ from numpy import ndarray
 from numpy.typing import NDArray
 from scipy.interpolate import LinearNDInterpolator, RegularGridInterpolator
 
+from imap_processing.quality_flags import ImapDEOutliersUltraFlags
 from imap_processing.spice.spin import get_spin_data
+from imap_processing.spice.time import sct_to_et
 from imap_processing.ultra.constants import UltraConstants
 from imap_processing.ultra.l1b.lookup_utils import (
     get_angular_profiles,
@@ -552,7 +554,7 @@ def get_de_velocity(
     v_hat = velocities / np.linalg.norm(velocities, axis=1)[:, None]
     r_hat = -v_hat
 
-    return velocities, v_hat, r_hat
+    return velocities, -v_hat, -r_hat
 
 
 def get_ssd_tof(
@@ -837,25 +839,16 @@ def get_ctof(
     return ctof, magnitude_v
 
 
-def determine_species(tof: np.ndarray, path_length: np.ndarray, type: str) -> NDArray:
+def determine_species(e_bin: np.ndarray, type: str) -> NDArray:
     """
     Determine the species for pulse-height events.
 
-    Species is determined from the particle velocity.
-    For velocity, the particle TOF is normalized with respect
-    to a fixed distance dmin between the front and back detectors.
-    The normalized TOF is termed the corrected TOF (ctof).
-    Particle species are determined from ctof using thresholds.
-
-    Further description is available on pages 42-44 of
-    IMAP-Ultra Flight Software Specification document.
+    Species is determined using the computed e_bin.
 
     Parameters
     ----------
-    tof : np.ndarray
-        Time of flight of the SSD event (tenths of a nanosecond).
-    path_length : np.ndarray
-        Path length (r) (hundredths of a millimeter).
+    e_bin : np.ndarray
+        Computed e_bin.
     type : str
         Type of data (PH or SSD).
 
@@ -864,11 +857,17 @@ def determine_species(tof: np.ndarray, path_length: np.ndarray, type: str) -> ND
     species_bin : np.array
         Species bin.
     """
-    # Event TOF normalization to Z axis
-    ctof, _ = get_ctof(tof, path_length, type)
-    # Assign Species 1 ("H") to bins
-    # TODO: this is a placeholder for future species assignments.
-    species_bin = np.full(len(ctof), 1, dtype=np.uint8)
+    if type == "PH":
+        species_groups = UltraConstants.TOFXPH_SPECIES_GROUPS
+    if type == "SSD":
+        species_groups = UltraConstants.TOFXE_SPECIES_GROUPS
+
+    non_proton_bins = species_groups["non_proton"]
+    proton_bins = species_groups["proton"]
+
+    species_bin = np.full(e_bin.shape, fill_value=2, dtype=int)
+    species_bin[np.isin(e_bin, non_proton_bins)] = 0
+    species_bin[np.isin(e_bin, proton_bins)] = 1
 
     return species_bin
 
@@ -984,9 +983,9 @@ def get_eventtimes(
     Returns
     -------
     event_times : np.ndarray
-        Event times.
+        Event times in et.
     spin_starts : np.ndarray
-        Spin start times.
+        Spin start times in et.
     spin_period_sec : np.ndarray
         Spin period in seconds.
 
@@ -1007,7 +1006,7 @@ def get_eventtimes(
 
     event_times = spin_starts + spin_period_sec * (phase_angle / 720)
 
-    return event_times, spin_starts, spin_period_sec
+    return sct_to_et(event_times), sct_to_et(spin_starts), spin_period_sec
 
 
 def interpolate_fwhm(
@@ -1375,54 +1374,91 @@ def is_coin_ph_valid(
     etof: NDArray,
     xc: NDArray,
     xb: NDArray,
+    stop_north_tdc: NDArray,
+    stop_south_tdc: NDArray,
+    stop_east_tdc: NDArray,
+    stop_west_tdc: NDArray,
     sensor: str,
     ancillary_files: dict,
+    quality_flags: NDArray,
 ) -> NDArray:
     """
-    Determine whether Coincidence-PH data are valid.
-
-    This is based on thresholds defined in the IMAP-Ultra Flight Software Specification
-    (see page 36).
+    Determine event validity.
 
     Parameters
     ----------
     etof : NDArray
-        Electron TOF (tenths of a nanosecond).
+        Time for the electrons to travel back to the coincidence
+        anode (tenths of a nanosecond).
     xc : NDArray
-        Coincidence X position (hundredths of a mm).
+        X coincidence position (hundredths of a millimeter).
     xb : NDArray
-        Back X position (hundredths of a mm).
+        Back positions in x direction (hundredths of a millimeter).
+    stop_north_tdc : NDArray
+        Stop North Time to Digital Converter.
+    stop_south_tdc : NDArray
+        Stop South Time to Digital Converter.
+    stop_east_tdc : NDArray
+        Stop East Time to Digital Converter.
+    stop_west_tdc : NDArray
+        Stop West Time to Digital Converter.
     sensor : str
         Sensor name: "ultra45" or "ultra90".
     ancillary_files : dict
         Ancillary files for lookup.
+    quality_flags : NDArray
+        Quality flag to set when there is an outlier.
 
     Returns
     -------
-    valid_mask : NDArray
-        Boolean array indicating Coin-PH validity.
+    combined_mask : NDArray
+        Boolean array indicating whether back TOF is valid.
 
     Notes
     -----
-    Logic derived from page 36 of the IMAP-Ultra Flight Software Specification document.
+    From page 36 of the IMAP-Ultra Flight Software Specification document.
     """
-    etof_min = get_image_params("eTOFMin", sensor, ancillary_files)
-    etof_max = get_image_params("eTOFMax", sensor, ancillary_files)
-
-    etof_valid = (etof >= etof_min) & (etof <= etof_max)
+    # Make certain etof is within range for tenths of a nanosecond.
+    etof_valid = (etof >= UltraConstants.ETOFMIN_EVENTFILTER) & (
+        etof <= UltraConstants.ETOFMAX_EVENTFILTER
+    )
 
+    # Hundredths of a mm.
     diff_x = xc - xb
-    etof_offset1 = get_image_params("eTOFOff1", sensor, ancillary_files)
-    etof_offset2 = get_image_params("eTOFOff2", sensor, ancillary_files)
-    etof_slope1 = get_image_params("eTOFSlope1", sensor, ancillary_files)
-    etof_slope2 = get_image_params("eTOFSlope2", sensor, ancillary_files)
 
-    t1 = (etof - etof_offset1) * etof_slope1 / 1024
-    t2 = (etof - etof_offset2) * etof_slope2 / 1024
+    t1 = (
+        (etof - UltraConstants.ETOFOFF1_EVENTFILTER)
+        * UltraConstants.ETOFSLOPE1_EVENTFILTER
+        / 1024
+    )
+    t2 = (
+        (etof - UltraConstants.ETOFOFF2_EVENTFILTER)
+        * UltraConstants.ETOFSLOPE2_EVENTFILTER
+        / 1024
+    )
 
     condition_1 = (diff_x >= t1) & (diff_x <= t2)
     condition_2 = (diff_x >= -t2) & (diff_x <= -t1)
 
     spatial_valid = condition_1 | condition_2
 
-    return etof_valid & spatial_valid
+    sp_n_norm = get_norm(stop_north_tdc, "SpN", sensor, ancillary_files)
+    sp_s_norm = get_norm(stop_south_tdc, "SpS", sensor, ancillary_files)
+    sp_e_norm = get_norm(stop_east_tdc, "SpE", sensor, ancillary_files)
+    sp_w_norm = get_norm(stop_west_tdc, "SpW", sensor, ancillary_files)
+
+    tofx = sp_n_norm + sp_s_norm
+    tofy = sp_e_norm + sp_w_norm
+
+    # Units in tenths of a nanosecond
+    delta_tof = tofy - tofx
+
+    delta_tof_mask = (delta_tof >= UltraConstants.TOFDIFFTPMIN_EVENTFILTER) & (
+        delta_tof <= UltraConstants.TOFDIFFTPMAX_EVENTFILTER
+    )
+
+    combined_mask = etof_valid & spatial_valid & delta_tof_mask
+
+    quality_flags[~combined_mask] |= ImapDEOutliersUltraFlags.COINPH.value
+
+    return combined_mask