imap-processing 0.17.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

imap_processing/ultra/l1b/extendedspin.py

@@ -5,11 +5,16 @@ import xarray as xr
 
 from imap_processing.ultra.l1b.ultra_l1b_culling import (
     flag_attitude,
-    flag_spin,
+    flag_hk,
+    flag_imap_instruments,
+    flag_rates,
     get_energy_histogram,
+    get_pulses_per_spin,
 )
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
+FILLVAL_UINT16 = 65535
+
 
 def calculate_extendedspin(
     dict_datasets: dict[str, xr.Dataset],
@@ -34,10 +39,11 @@ def calculate_extendedspin(
         Dataset containing the data.
     """
     aux_dataset = dict_datasets[f"imap_ultra_l1a_{instrument_id}sensor-aux"]
+    rates_dataset = dict_datasets[f"imap_ultra_l1a_{instrument_id}sensor-rates"]
     de_dataset = dict_datasets[f"imap_ultra_l1b_{instrument_id}sensor-de"]
 
     extendedspin_dict = {}
-    rates_qf, spin, energy_midpoints, n_sigma_per_energy = flag_spin(
+    rates_qf, spin, energy_midpoints, n_sigma_per_energy = flag_rates(
         de_dataset["spin"].values,
         de_dataset["energy"].values,
     )
@@ -47,12 +53,19 @@ def calculate_extendedspin(
     attitude_qf, spin_rates, spin_period, spin_starttime = flag_attitude(
         de_dataset["spin"].values, aux_dataset
     )
+    # TODO: We will add to this later
+    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.
+    start_per_spin, stop_per_spin, coin_per_spin = get_pulses_per_spin(rates_dataset)
+
     # These will be the coordinates.
     extendedspin_dict["epoch"] = first_epochs
     extendedspin_dict["spin_number"] = spin
@@ -63,8 +76,19 @@ def calculate_extendedspin(
     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"] = start_per_spin
+    extendedspin_dict["stop_pulses_per_spin"] = stop_per_spin
+    extendedspin_dict["coin_pulses_per_spin"] = coin_per_spin
+    # TODO: this will be used to track rejected events in each
+    #  spin based on quality flags in de l1b data.
+    extendedspin_dict["rejected_events_per_spin"] = np.full_like(
+        spin, FILLVAL_UINT16, dtype=np.uint16
+    )
+
     extendedspin_dict["quality_attitude"] = attitude_qf
     extendedspin_dict["quality_ena_rates"] = rates_qf
+    extendedspin_dict["quality_hk"] = hk_qf
+    extendedspin_dict["quality_instruments"] = inst_qf
 
     extendedspin_dataset = create_dataset(extendedspin_dict, name, "l1b")
 

imap_processing/ultra/l1b/lookup_utils.py

@@ -4,43 +4,12 @@ import numpy as np
 import numpy.typing as npt
 import pandas as pd
 import xarray as xr
+from numpy.typing import NDArray
 
-from imap_processing import imap_module_directory
-
-BASE_PATH = imap_module_directory / "ultra" / "lookup_tables"
-
-_YADJUST_DF = pd.read_csv(BASE_PATH / "yadjust.csv").set_index("dYLUT")
-_TDC_NORM_DF_ULTRA45 = pd.read_csv(
-    BASE_PATH / "ultra45_tdc_norm.csv", header=1, index_col="Index"
-)
-_TDC_NORM_DF_ULTRA90 = pd.read_csv(
-    BASE_PATH / "ultra90_tdc_norm.csv", header=1, index_col="Index"
-)
-_BACK_POS_DF_ULTRA45 = pd.read_csv(
-    BASE_PATH / "ultra45_back-pos-luts.csv", index_col="Index_offset"
-)
-_BACK_POS_DF_ULTRA90 = pd.read_csv(
-    BASE_PATH / "ultra90_back-pos-luts.csv", index_col="Index_offset"
-)
-_ENERGY_NORM_DF = pd.read_csv(BASE_PATH / "EgyNorm.mem.csv")
-_IMAGE_PARAMS_DF = {
-    "ultra45": pd.read_csv(BASE_PATH / "FM45_Startup1_ULTRA_IMGPARAMS_20240719.csv"),
-    "ultra90": pd.read_csv(BASE_PATH / "FM90_Startup1_ULTRA_IMGPARAMS_20240719.csv"),
-}
-
-_FWHM_TABLES = {
-    ("left", "ultra45"): pd.read_csv(BASE_PATH / "Angular_Profiles_FM45_LeftSlit.csv"),
-    ("right", "ultra45"): pd.read_csv(
-        BASE_PATH / "Angular_Profiles_FM45_RightSlit.csv"
-    ),
-    ("left", "ultra90"): pd.read_csv(BASE_PATH / "Angular_Profiles_FM90_LeftSlit.csv"),
-    ("right", "ultra90"): pd.read_csv(
-        BASE_PATH / "Angular_Profiles_FM90_RightSlit.csv"
-    ),
-}
-
-
-def get_y_adjust(dy_lut: np.ndarray) -> npt.NDArray:
+from imap_processing.quality_flags import ImapDEUltraFlags
+
+
+def get_y_adjust(dy_lut: np.ndarray, ancillary_files: dict) -> npt.NDArray:
     """
     Adjust the front yf position based on the particle's trajectory.
 
@@ -52,16 +21,21 @@ def get_y_adjust(dy_lut: np.ndarray) -> npt.NDArray:
     ----------
     dy_lut : np.ndarray
         Change in y direction used for the lookup table (mm).
+    ancillary_files : dict[Path]
+        Ancillary files containing the lookup tables.
 
     Returns
     -------
     yadj : np.ndarray
         Y adjustment (mm).
     """
-    return _YADJUST_DF["dYAdj"].iloc[dy_lut].values
+    yadjust_df = pd.read_csv(ancillary_files["l1b-yadjust-lookup"]).set_index("dYLUT")
+    return yadjust_df["dYAdj"].iloc[dy_lut].values
 
 
-def get_norm(dn: xr.DataArray, key: str, file_label: str) -> npt.NDArray:
+def get_norm(
+    dn: xr.DataArray, key: str, file_label: str, ancillary_files: dict
+) -> npt.NDArray:
     """
     Correct mismatches between the stop Time to Digital Converters (TDCs).
 
@@ -82,6 +56,8 @@ def get_norm(dn: xr.DataArray, key: str, file_label: str) -> npt.NDArray:
         BtSpNNorm, BtSpSNorm, BtSpENorm, or BtSpWNorm.
     file_label : str
         Instrument (ultra45 or ultra90).
+    ancillary_files : dict[Path]
+        Ancillary files containing the lookup tables.
 
     Returns
     -------
@@ -89,16 +65,22 @@ def get_norm(dn: xr.DataArray, key: str, file_label: str) -> npt.NDArray:
         Normalized DNs.
     """
     if file_label == "ultra45":
-        tdc_norm_df = _TDC_NORM_DF_ULTRA45
+        tdc_norm_df = pd.read_csv(
+            ancillary_files["l1b-45sensor-tdc-norm-lookup"], header=1, index_col="Index"
+        )
     else:
-        tdc_norm_df = _TDC_NORM_DF_ULTRA90
+        tdc_norm_df = pd.read_csv(
+            ancillary_files["l1b-90sensor-tdc-norm-lookup"], header=1, index_col="Index"
+        )
 
     dn_norm = tdc_norm_df[key].iloc[dn].values
 
     return dn_norm
 
 
-def get_back_position(back_index: np.ndarray, key: str, file_label: str) -> npt.NDArray:
+def get_back_position(
+    back_index: np.ndarray, key: str, file_label: str, ancillary_files: dict
+) -> npt.NDArray:
     """
     Convert normalized TDC values using lookup tables.
 
@@ -117,6 +99,8 @@ def get_back_position(back_index: np.ndarray, key: str, file_label: str) -> npt.
         XBkTp, YBkTp, XBkBt, or YBkBt.
     file_label : str
         Instrument (ultra45 or ultra90).
+    ancillary_files : dict[Path]
+        Ancillary files containing the lookup tables.
 
     Returns
     -------
@@ -124,14 +108,20 @@ def get_back_position(back_index: np.ndarray, key: str, file_label: str) -> npt.
         Converted DNs to Units of hundredths of a millimeter.
     """
     if file_label == "ultra45":
-        back_pos_df = _BACK_POS_DF_ULTRA45
+        back_pos_df = pd.read_csv(
+            ancillary_files["l1b-45sensor-back-pos-lookup"], index_col="Index_offset"
+        )
     else:
-        back_pos_df = _BACK_POS_DF_ULTRA90
+        back_pos_df = pd.read_csv(
+            ancillary_files["l1b-90sensor-back-pos-lookup"], index_col="Index_offset"
+        )
 
     return back_pos_df[key].values[back_index]
 
 
-def get_energy_norm(ssd: np.ndarray, composite_energy: np.ndarray) -> npt.NDArray:
+def get_energy_norm(
+    ssd: np.ndarray, composite_energy: np.ndarray, ancillary_files: dict
+) -> npt.NDArray:
     """
     Normalize composite energy per SSD using a lookup table.
 
@@ -146,6 +136,8 @@ def get_energy_norm(ssd: np.ndarray, composite_energy: np.ndarray) -> npt.NDArra
         Acts as index 1.
     composite_energy : np.ndarray
         Acts as index 2.
+    ancillary_files : dict[Path]
+        Ancillary files containing the lookup tables.
 
     Returns
     -------
@@ -153,11 +145,11 @@ def get_energy_norm(ssd: np.ndarray, composite_energy: np.ndarray) -> npt.NDArra
         Normalized composite energy.
     """
     row_number = ssd * 4096 + composite_energy
+    norm_lookup = pd.read_csv(ancillary_files["l1b-egynorm-lookup"])
+    return norm_lookup["NormEnergy"].iloc[row_number]
 
-    return _ENERGY_NORM_DF["NormEnergy"].iloc[row_number]
 
-
-def get_image_params(image: str, sensor: str) -> np.float64:
+def get_image_params(image: str, sensor: str, ancillary_files: dict) -> np.float64:
     """
     Lookup table for image parameters.
 
@@ -171,18 +163,26 @@ def get_image_params(image: str, sensor: str) -> np.float64:
         The column name to lookup in the CSV file, e.g., 'XFTLTOFF' or 'XFTRTOFF'.
     sensor : str
         Sensor name: "ultra45" or "ultra90".
+    ancillary_files : dict[Path]
+        Ancillary files containing the lookup tables.
 
     Returns
     -------
     value : np.float64
         Image parameter value from the CSV file.
     """
-    lookup_table = _IMAGE_PARAMS_DF[sensor]
+    if sensor == "ultra45":
+        lookup_table = pd.read_csv(ancillary_files["l1b-45sensor-imgparams-lookup"])
+    else:
+        lookup_table = pd.read_csv(ancillary_files["l1b-90sensor-imgparams-lookup"])
+
     value: np.float64 = lookup_table[image].values[0]
     return value
 
 
-def get_angular_profiles(start_type: str, sensor: str) -> pd.DataFrame:
+def get_angular_profiles(
+    start_type: str, sensor: str, ancillary_files: dict
+) -> pd.DataFrame:
     """
     Lookup table for FWHM for theta and phi.
 
@@ -195,13 +195,16 @@ def get_angular_profiles(start_type: str, sensor: str) -> pd.DataFrame:
        Start Type: Left, Right.
     sensor : str
         Sensor name: "ultra45" or "ultra90".
+    ancillary_files : dict[Path]
+        Ancillary files.
 
     Returns
     -------
     lookup_table : DataFrame
         Angular profile lookup table for a given start_type and sensor.
     """
-    lookup_table = _FWHM_TABLES[(start_type.lower(), sensor)]
+    lut_descriptor = f"l1b-{sensor[-2:]}sensor-{start_type.lower()}slit-lookup"
+    lookup_table = pd.read_csv(ancillary_files[lut_descriptor])
 
     return lookup_table
 
@@ -227,3 +230,121 @@ def get_energy_efficiencies(ancillary_files: dict) -> pd.DataFrame:
     lookup_table = pd.read_csv(ancillary_files["l1b-45sensor-logistic-interpolation"])
 
     return lookup_table
+
+
+def get_geometric_factor(
+    ancillary_files: dict,
+    filename: str,
+    phi: NDArray,
+    theta: NDArray,
+    quality_flag: NDArray,
+) -> tuple[NDArray, NDArray]:
+    """
+    Lookup table for geometric factor using nearest neighbor.
+
+    Parameters
+    ----------
+    ancillary_files : dict[Path]
+        Ancillary files.
+    filename : str
+        Name of the file in ancillary_files to use.
+    phi : NDArray
+        Azimuth angles in degrees.
+    theta : NDArray
+        Elevation angles in degrees.
+    quality_flag : NDArray
+        Quality flag to set when geometric factor is zero.
+
+    Returns
+    -------
+    geometric_factor : NDArray
+        Geometric factor.
+    """
+    gf_table = pd.read_csv(
+        ancillary_files[filename], header=None, skiprows=6, nrows=301
+    ).to_numpy(dtype=float)
+    theta_table = pd.read_csv(
+        ancillary_files[filename], header=None, skiprows=308, nrows=301
+    ).to_numpy(dtype=float)
+    phi_table = pd.read_csv(
+        ancillary_files[filename], header=None, skiprows=610, nrows=301
+    ).to_numpy(dtype=float)
+
+    # Assume uniform grids: extract 1D arrays from first row/col
+    theta_vals = theta_table[0, :]  # columns represent theta
+    phi_vals = phi_table[:, 0]  # rows represent phi
+
+    # Find nearest index in table for each input value
+    phi_idx = np.abs(phi_vals[:, None] - phi).argmin(axis=0)
+    theta_idx = np.abs(theta_vals[:, None] - theta).argmin(axis=0)
+
+    # Fetch geometric factor values at nearest (phi, theta) pairs
+    geometric_factor = gf_table[phi_idx, theta_idx]
+
+    phi_rad = np.deg2rad(phi)
+    numerator = 5.0 * np.cos(phi_rad)
+    denominator = 1 + 2.80 * np.cos(phi_rad)
+    # Equation 19 in the Ultra Algorithm Document.
+    theta_nom = np.arctan(numerator / denominator)
+    theta_nom = np.rad2deg(theta_nom)
+
+    outside_fov = np.abs(theta) > theta_nom
+    quality_flag[outside_fov] |= ImapDEUltraFlags.FOV.value
+
+    return geometric_factor
+
+
+def get_ph_corrected(
+    sensor: str,
+    location: str,
+    ancillary_files: dict,
+    xlut: NDArray,
+    ylut: NDArray,
+    quality_flag: NDArray,
+) -> tuple[NDArray, NDArray]:
+    """
+    PH correction for stop anodes, top and bottom.
+
+    Further description is available starting on
+    page 207 of the Ultra Flight Software Document.
+
+    Parameters
+    ----------
+    sensor : str
+        Sensor name: "ultra45" or "ultra90".
+    location : str
+        Location: "tp" or "bt".
+    ancillary_files : dict[Path]
+        Ancillary files.
+    xlut : NDArray
+        X lookup index for PH correction.
+    ylut : NDArray
+        Y lookup index for PH correction.
+    quality_flag : NDArray
+        Quality flag to set when there is an outlier.
+
+    Returns
+    -------
+    ph_correction : NDArray
+        Correction for pulse height.
+    quality_flag : NDArray
+        Quality flag updated with PH correction flags.
+    """
+    ph_correct = pd.read_csv(
+        ancillary_files[f"l1b-{sensor[-2:]}sensor-sp{location}phcorr"], header=None
+    )
+    ph_correct_array = ph_correct.to_numpy()
+
+    max_x, max_y = ph_correct_array.shape[0] - 1, ph_correct_array.shape[1] - 1
+
+    # Clamp indices to nearest valid value
+    xlut_clamped = np.clip(xlut.astype(int), 0, max_x)
+    ylut_clamped = np.clip(ylut.astype(int), 0, max_y)
+
+    # Flag where clamping occurred
+    flagged_mask = (xlut != xlut_clamped) | (ylut != ylut_clamped)
+    quality_flag[flagged_mask] |= ImapDEUltraFlags.PHCORR.value
+
+    ph_correction = ph_correct_array[xlut_clamped, ylut_clamped]
+
+    return ph_correction, quality_flag

imap_processing/ultra/l1b/quality_flag_filters.py

@@ -0,0 +1,14 @@
+"""Contains list of QFs to use for filtering."""
+
+from imap_processing.quality_flags import (
+    FlagNameMixin,
+    ImapRatesUltraFlags,
+)
+
+QUALITY_FLAG_FILTERS: dict[str, list[FlagNameMixin]] = {
+    "quality_attitude": [],
+    "quality_ena_rates": [
+        ImapRatesUltraFlags.FIRSTSPIN,
+        ImapRatesUltraFlags.LASTSPIN,
+    ],
+}

imap_processing/ultra/l1b/ultra_l1b_culling.py

@@ -7,7 +7,12 @@ import pandas as pd
 import xarray as xr
 from numpy.typing import NDArray
 
-from imap_processing.quality_flags import ImapAttitudeUltraFlags, ImapRatesUltraFlags
+from imap_processing.quality_flags import (
+    ImapAttitudeUltraFlags,
+    ImapHkUltraFlags,
+    ImapInstrumentUltraFlags,
+    ImapRatesUltraFlags,
+)
 from imap_processing.spice.spin import get_spin_data
 from imap_processing.ultra.constants import UltraConstants
 
@@ -106,6 +111,10 @@ def flag_attitude(
 
     spin_period = spin_df.loc[spin_df.spin_number.isin(spins), "spin_period_sec"]
     spin_starttime = spin_df.loc[spin_df.spin_number.isin(spins), "spin_start_met"]
+    spin_phase_valid = spin_df.loc[spin_df.spin_number.isin(spins), "spin_phase_valid"]
+    spin_period_valid = spin_df.loc[
+        spin_df.spin_number.isin(spins), "spin_period_valid"
+    ]
     spin_rates = 60 / spin_period  # 60 seconds in a minute
     bad_spin_rate_indices = (spin_rates < UltraConstants.CULLING_RPM_MIN) | (
         spin_rates > UltraConstants.CULLING_RPM_MAX
@@ -118,9 +127,59 @@ def flag_attitude(
     mismatch_indices = compare_aux_univ_spin_table(aux_dataset, spins, spin_df)
     quality_flags[mismatch_indices] |= ImapAttitudeUltraFlags.AUXMISMATCH.value
 
+    # Spin phase validity flag
+    phase_invalid_indices = spin_phase_valid == 0
+    quality_flags[phase_invalid_indices] |= ImapAttitudeUltraFlags.SPINPHASE.value
+
+    # Spin period validity flag
+    period_invalid_indices = ~spin_period_valid
+    quality_flags[period_invalid_indices] |= ImapAttitudeUltraFlags.SPINPERIOD.value
+
     return quality_flags, spin_rates, spin_period, spin_starttime
 
 
+def flag_hk(spin_number: NDArray) -> NDArray:
+    """
+    Flag data based on hk.
+
+    Parameters
+    ----------
+    spin_number : NDArray
+        Spin number at each direct event.
+
+    Returns
+    -------
+    quality_flags : NDArray
+        Quality flags..
+    """
+    spins = np.unique(spin_number)  # Get unique spins
+    quality_flags = np.full(spins.shape, ImapHkUltraFlags.NONE.value, dtype=np.uint16)
+
+    return quality_flags
+
+
+def flag_imap_instruments(spin_number: NDArray) -> NDArray:
+    """
+    Flag data based on other IMAP instruments.
+
+    Parameters
+    ----------
+    spin_number : NDArray
+        Spin number at each direct event.
+
+    Returns
+    -------
+    quality_flags : NDArray
+        Quality flags..
+    """
+    spins = np.unique(spin_number)  # Get unique spins
+    quality_flags = np.full(
+        spins.shape, ImapInstrumentUltraFlags.NONE.value, dtype=np.uint16
+    )
+
+    return quality_flags
+
+
 def get_n_sigma(count_rates: NDArray, mean_duration: float, sigma: int = 6) -> NDArray:
     """
     Calculate the threshold for the HIGHRATES flag.
@@ -140,7 +199,8 @@ def get_n_sigma(count_rates: NDArray, mean_duration: float, sigma: int = 6) -> N
     threshold : NDArray
         Threshold for applying HIGHRATES flag.
     """
-    sigma_per_energy = np.std(count_rates, axis=1)
+    # Take the Sample Standard Deviation.
+    sigma_per_energy = np.std(count_rates, axis=1, ddof=1)
     n_sigma_per_energy = sigma * sigma_per_energy
     mean_per_energy = np.mean(count_rates, axis=1)
     # Must have a HIGHRATES threshold of at least 3 counts per spin.
@@ -149,7 +209,7 @@ def get_n_sigma(count_rates: NDArray, mean_duration: float, sigma: int = 6) -> N
     return threshold
 
 
-def flag_spin(
+def flag_rates(
     spin_number: NDArray, energy: NDArray, sigma: int = 6
 ) -> tuple[NDArray, NDArray, NDArray, NDArray]:
     """
@@ -182,8 +242,6 @@ def flag_spin(
         count_rates.shape, ImapRatesUltraFlags.NONE.value, dtype=np.uint16
     )
 
-    # Zero counts/spin/energy level
-    quality_flags[counts == 0] |= ImapRatesUltraFlags.ZEROCOUNTS.value
     threshold = get_n_sigma(count_rates, duration, sigma=sigma)
 
     bin_edges = np.array(UltraConstants.CULLING_ENERGY_BIN_EDGES)
@@ -194,6 +252,10 @@ def flag_spin(
     indices_n_sigma = count_rates > threshold[:, np.newaxis]
     quality_flags[indices_n_sigma] |= ImapRatesUltraFlags.HIGHRATES.value
 
+    # Flags the first and last spin
+    quality_flags[:, 0] |= ImapRatesUltraFlags.FIRSTSPIN.value
+    quality_flags[:, -1] |= ImapRatesUltraFlags.LASTSPIN.value
+
     return quality_flags, spin, energy_midpoints, threshold
 
 
@@ -256,3 +318,134 @@ def compare_aux_univ_spin_table(
     mismatch_indices[missing_spin_mask] = True
 
     return mismatch_indices
+
+
+# TODO: Make this a common util since it is being used for the de and rates packets.
+def get_spin_and_duration(met: NDArray, spin: NDArray) -> tuple[NDArray, NDArray]:
+    """
+    Get the spin number and duration.
+
+    Parameters
+    ----------
+    met : NDArray
+        Mission elapsed time.
+    spin : NDArray
+        Spin number 0-255.
+
+    Returns
+    -------
+    assigned_spin_number : NDArray
+        Spin number for packet data product.
+    """
+    # Packet data.
+    # Since the spin number in the direct events packet
+    # is only 8 bits it goes from 0-255.
+    # Within a pointing that means we will always have duplicate spin numbers.
+    # In other words, different spins will be represented by the same spin number.
+    # Just to make certain that we won't accidentally combine
+    # multiple spins we need to sort by time here.
+    sort_idx = np.argsort(met)
+    packet_met_sorted = met[sort_idx]
+    packet_spin_sorted = spin[sort_idx]
+    # Here we are finding the start and end indices of each spin in the sorted array.
+    is_new_spin = np.concatenate(
+        [[True], packet_spin_sorted.values[1:] != packet_spin_sorted.values[:-1]]
+    )
+    spin_start_indices = np.where(is_new_spin)[0]
+    spin_end_indices = np.append(spin_start_indices[1:], len(packet_met_sorted))
+
+    # Universal Spin Table.
+    spin_df = get_spin_data()
+    # Retrieve the met values of the start of the spin.
+    spin_start_mets = spin_df["spin_start_met"].values
+    # Retrieve the corresponding spin numbers.
+    spin_numbers = spin_df["spin_number"].values
+    spin_period_sec = spin_df["spin_period_sec"].values
+    assigned_spin_number_sorted = np.empty(packet_spin_sorted.shape, dtype=np.uint32)
+    assigned_spin_duration_sorted = np.empty(packet_spin_sorted.shape, dtype=np.float32)
+    # These last 8 bits are the same as the spin number in the DE packet.
+    # So this will give us choices of which spins are
+    # available to assign to the packet data.
+    possible_spins = spin_numbers & 0xFF
+
+    # Assign each group based on time.
+    for start, end in zip(spin_start_indices, spin_end_indices):
+        # Now that we have the possible spins from the Universal Spin Table,
+        # we match the times of those spins to the nearest times in the DE data.
+        possible_times = spin_start_mets[
+            possible_spins == packet_spin_sorted.values[start]
+        ]
+        # Get nearest time for matching spins.
+        nearest_idx = np.abs(possible_times - packet_met_sorted.values[start]).argmin()
+        nearest_value = possible_times[nearest_idx]
+        assigned_spin_number_sorted[start:end] = spin_numbers[
+            spin_start_mets == nearest_value
+        ]
+        assigned_spin_duration_sorted[start:end] = spin_period_sec[
+            spin_start_mets == nearest_value
+        ]
+
+    # Undo the sort to match original order.
+    assigned_spin_number = np.empty_like(assigned_spin_number_sorted)
+    assigned_spin_number[sort_idx] = assigned_spin_number_sorted
+    assigned_duration = np.empty_like(assigned_spin_duration_sorted)
+    assigned_duration[sort_idx] = assigned_spin_duration_sorted
+
+    return assigned_spin_number, assigned_duration
+
+
+def get_pulses_per_spin(rates: xr.Dataset) -> tuple[NDArray, NDArray, NDArray]:
+    """
+    Get the total number of pulses per spin.
+
+    Parameters
+    ----------
+    rates : xr.Dataset
+        Rates dataset.
+
+    Returns
+    -------
+    start_per_spin : NDArray
+        Total start pulses per spin.
+    stop_per_spin : NDArray
+        Total stop pulses per spin.
+    coin_per_spin : NDArray
+        Total coincidence pulses per spin.
+    """
+    spin_number, duration = get_spin_and_duration(rates["shcoarse"], rates["spin"])
+
+    # Top coin pulses
+    top_coin_pulses = np.stack(
+        [v for k, v in rates.items() if k.startswith("coin_t")], axis=1
+    )
+    max_top_coin_pulse = np.max(top_coin_pulses, axis=1)
+
+    # Bottom coin pulses
+    bottom_coin_pulses = np.stack(
+        [v for k, v in rates.items() if k.startswith("coin_b")], axis=1
+    )
+    max_bottom_coin_pulse = np.max(bottom_coin_pulses, axis=1)
+
+    # Top stop pulses
+    top_stop_pulses = np.stack(
+        [v for k, v in rates.items() if k.startswith("stop_t")], axis=1
+    )
+    max_top_stop_pulse = np.max(top_stop_pulses, axis=1)
+
+    # Bottom stop pulses
+    bottom_stop_pulses = np.stack(
+        [v for k, v in rates.items() if k.startswith("stop_b")], axis=1
+    )
+    max_bottom_stop_pulse = np.max(bottom_stop_pulses, axis=1)
+
+    stop_pulses = max_top_stop_pulse + max_bottom_stop_pulse
+    start_pulses = rates["start_rf"] + rates["start_lf"]
+    coin_pulses = max_top_coin_pulse + max_bottom_coin_pulse
+
+    unique_spins, spin_idx = np.unique(spin_number, return_inverse=True)
+
+    start_per_spin = np.bincount(spin_idx, weights=start_pulses)
+    stop_per_spin = np.bincount(spin_idx, weights=stop_pulses)
+    coin_per_spin = np.bincount(spin_idx, weights=coin_pulses)
+
+    return start_per_spin, stop_per_spin, coin_per_spin