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

imap_processing/ultra/l1b/de.py

@@ -4,12 +4,16 @@ import numpy as np
 import xarray as xr
 
 from imap_processing.cdf.utils import parse_filename_like
+from imap_processing.quality_flags import ImapDEUltraFlags
 from imap_processing.spice.geometry import SpiceFrame
+from imap_processing.ultra.l1b.lookup_utils import get_geometric_factor
 from imap_processing.ultra.l1b.ultra_l1b_annotated import (
     get_annotated_particle_velocity,
 )
 from imap_processing.ultra.l1b.ultra_l1b_extended import (
     StopType,
+    determine_ebin_pulse_height,
+    determine_ebin_ssd,
     determine_species,
     get_coincidence_positions,
     get_ctof,
@@ -25,6 +29,7 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
     get_path_length,
     get_ph_tof_and_back_positions,
     get_phi_theta,
+    get_spin_number,
     get_ssd_back_position_and_tof_offset,
     get_ssd_tof,
 )
@@ -59,7 +64,10 @@ def calculate_de(
 
     # Define epoch and spin.
     de_dict["epoch"] = de_dataset["epoch"].data
-    de_dict["spin"] = de_dataset["spin"].data
+    spin_number = get_spin_number(
+        de_dataset["shcoarse"].values, de_dataset["spin"].values
+    )
+    de_dict["spin"] = spin_number
 
     # Add already populated fields.
     keys = [
@@ -108,6 +116,7 @@ def calculate_de(
     ctof = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
     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)
     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)
@@ -116,40 +125,44 @@ def calculate_de(
     sc_dps_velocity = np.full(shape, FILLVAL_FLOAT32, dtype=np.float32)
     helio_velocity = np.full(shape, FILLVAL_FLOAT32, dtype=np.float32)
     spin_starts = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float64)
-    spin_period_sec = np.full(
-        len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float64
-    )
+
     start_type = np.full(len(de_dataset["epoch"]), FILLVAL_UINT8, dtype=np.uint8)
+    quality_flags = np.full(
+        de_dataset["epoch"].shape, ImapDEUltraFlags.NONE.value, dtype=np.uint16
+    )
 
     xf[valid_indices] = get_front_x_position(
         de_dataset["start_type"].data[valid_indices],
         de_dataset["start_pos_tdc"].data[valid_indices],
         f"ultra{sensor}",
+        ancillary_files,
     )
     start_type[valid_indices] = de_dataset["start_type"].data[valid_indices]
 
     (
         event_times[valid_indices],
         spin_starts[valid_indices],
-        spin_period_sec[valid_indices],
+        _,
     ) = get_eventtimes(
-        de_dataset["spin"].data[valid_indices],
+        de_dict["spin"][valid_indices],
         de_dataset["phase_angle"].data[valid_indices],
     )
 
     # Pulse height
     tof[ph_indices], t2[ph_indices], xb[ph_indices], yb[ph_indices] = (
-        get_ph_tof_and_back_positions(de_dataset, xf, f"ultra{sensor}")
+        get_ph_tof_and_back_positions(de_dataset, xf, f"ultra{sensor}", ancillary_files)
     )
     d[ph_indices], yf[ph_indices] = get_front_y_position(
-        de_dataset["start_type"].data[ph_indices], yb[ph_indices]
+        de_dataset["start_type"].data[ph_indices], yb[ph_indices], ancillary_files
     )
-    energy[ph_indices] = get_energy_pulse_height(
+    energy[ph_indices], _ = get_energy_pulse_height(
         de_dataset["stop_type"].data[ph_indices],
         de_dataset["energy_ph"].data[ph_indices],
         xb[ph_indices],
         yb[ph_indices],
         f"ultra{sensor}",
+        ancillary_files,
+        quality_flags[ph_indices],
     )
     r[ph_indices] = get_path_length(
         (xf[ph_indices], yf[ph_indices]),
@@ -161,26 +174,32 @@ def calculate_de(
         (xb[ph_indices], yb[ph_indices]),
         d[ph_indices],
     )
+    e_bin[ph_indices] = determine_ebin_pulse_height(
+        energy[ph_indices], tof[ph_indices], r[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], f"ultra{sensor}"
+        de_dataset.isel(epoch=ph_indices),
+        t2[ph_indices],
+        f"ultra{sensor}",
+        ancillary_files,
     )
     ctof[ph_indices], magnitude_v[ph_indices] = get_ctof(
         tof[ph_indices], r[ph_indices], "PH"
     )
 
     # SSD
-    tof[ssd_indices] = get_ssd_tof(de_dataset, xf, f"ultra{sensor}")
+    tof[ssd_indices] = get_ssd_tof(de_dataset, xf, f"ultra{sensor}", ancillary_files)
     yb[ssd_indices], _, ssd_number = get_ssd_back_position_and_tof_offset(
-        de_dataset, f"ultra{sensor}"
+        de_dataset, f"ultra{sensor}", ancillary_files
     )
     xc[ssd_indices] = np.zeros(len(ssd_indices))
     xb[ssd_indices] = np.zeros(len(ssd_indices))
     etof[ssd_indices] = np.zeros(len(ssd_indices))
     d[ssd_indices], yf[ssd_indices] = get_front_y_position(
-        de_dataset["start_type"].data[ssd_indices], yb[ssd_indices]
+        de_dataset["start_type"].data[ssd_indices], yb[ssd_indices], ancillary_files
     )
-    energy[ssd_indices] = get_energy_ssd(de_dataset, ssd_number)
+    energy[ssd_indices] = get_energy_ssd(de_dataset, ssd_number, ancillary_files)
     r[ssd_indices] = get_path_length(
         (xf[ssd_indices], yf[ssd_indices]),
         (xb[ssd_indices], yb[ssd_indices]),
@@ -191,6 +210,9 @@ def calculate_de(
         (xb[ssd_indices], yb[ssd_indices]),
         d[ssd_indices],
     )
+    e_bin[ssd_indices] = determine_ebin_ssd(
+        energy[ssd_indices], tof[ssd_indices], r[ssd_indices]
+    )
     species_bin[ssd_indices] = determine_species(
         tof[ssd_indices], r[ssd_indices], "SSD"
     )
@@ -202,7 +224,6 @@ def calculate_de(
     de_dict["x_front"] = xf.astype(np.float32)
     de_dict["event_times"] = event_times
     de_dict["spin_starts"] = spin_starts
-    de_dict["spin_period"] = spin_period_sec
     de_dict["y_front"] = yf
     de_dict["x_back"] = xb
     de_dict["y_back"] = yb
@@ -228,6 +249,7 @@ def calculate_de(
 
     de_dict["tof_energy"] = get_de_energy_kev(v, species_bin)
     de_dict["energy"] = energy
+    de_dict["ebin"] = e_bin
     de_dict["species"] = species_bin
 
     # Annotated Events.
@@ -261,10 +283,26 @@ def calculate_de(
         de_dict["tof_energy"],
         de_dict["phi"],
         de_dict["theta"],
+        ancillary_files,
     )
     de_dict["event_efficiency"] = get_efficiency(
         de_dict["tof_energy"], de_dict["phi"], de_dict["theta"], ancillary_files
     )
+    de_dict["geometric_factor_blades"] = get_geometric_factor(
+        ancillary_files,
+        "l1b-sensor-gf-blades",
+        de_dict["phi"],
+        de_dict["theta"],
+        quality_flags,
+    )
+    de_dict["geometric_factor_noblades"] = get_geometric_factor(
+        ancillary_files,
+        "l1b-sensor-gf-noblades",
+        de_dict["phi"],
+        de_dict["theta"],
+        quality_flags,
+    )
+    de_dict["quality_fov"] = quality_flags
 
     dataset = create_dataset(de_dict, name, "l1b")
 

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,
+    ],
+}