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

imap_processing/swapi/l2/swapi_l2.py

@@ -12,31 +12,77 @@ from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 logger = logging.getLogger(__name__)
 
 
-TIME_PER_BIN = 0.167  # seconds
+SWAPI_LIVETIME = 0.145  # seconds
 
 
 def solve_full_sweep_energy(
-    esa_lvl5_data: np.ndarray, esa_table_df: pd.DataFrame, lut_notes_df: pd.DataFrame
+    esa_lvl5_data: np.ndarray,
+    sweep_table: np.ndarray,
+    esa_table_df: pd.DataFrame,
+    lut_notes_df: pd.DataFrame,
+    data_time: npt.NDArray[np.datetime64],
 ) -> npt.NDArray:
     """
     Calculate the energy of each full sweep data.
 
+    Get the fixed energy values for steps 0-62 using the
+    esa_table_df information. It's important to ensure
+    that the correct fixed energy values are selected for
+    the specified time, as the sweep table can contain
+    different values depending on the operational phase
+    (e.g., I+T, pre-launch, post-launch). There may be
+    more fixed energy added in the future. TODO: add
+    document section once SWAPI document is updated.
+
+    Now, find the last 9 fine energy values using steps
+    noted in the section x in the algorithm document.
+
     Parameters
     ----------
     esa_lvl5_data : numpy.ndarray
         The L1 data input.
+    sweep_table : numpy.ndarray
+        Sweep table information.
     esa_table_df : pandas.DataFrame
         The ESA unit conversion table that contains first 63 energies.
     lut_notes_df : pandas.DataFrame
         The LUT notes table that contains the last 9 fine energies.
+    data_time : numpy.ndarray
+        The collection time of the data.
 
     Returns
     -------
     energy : numpy.ndarray
         The energy of each full sweep data.
     """
-    # Read 0 - 62 energy steps' fixed energy value
-    fixed_energy_values = esa_table_df["Energy"].values[:63]
+    # Convert timestamp from string to datetime
+    # and to the same format as data_time
+    esa_table_df["timestamp"] = pd.to_datetime(
+        esa_table_df["timestamp"], format="%m/%d/%Y %H:%M"
+    )
+    esa_table_df["timestamp"] = esa_table_df["timestamp"].to_numpy(
+        dtype="datetime64[ns]"
+    )
+
+    first_63_energies = []
+
+    for time, sweep_id in zip(data_time, sweep_table, strict=False):
+        # Find the sweep's ESA data for the given time and sweep_id
+        subset = esa_table_df[
+            (esa_table_df["timestamp"] <= time) & (esa_table_df["Sweep #"] == sweep_id)
+        ]
+        if subset.empty:
+            first_63_energies.append(np.full(63, np.nan, dtype=np.float64))
+            continue
+
+        # Subset data can contain multiple 72 energy values with last 9 fine energies
+        # with 'Solve' value. We need to sort by time and ESA step to maintain correct
+        # order. Then take the last group of 72 steps values and select first 63
+        # values only.
+        subset = subset.sort_values(["timestamp", "ESA Step #"])
+        grouped = subset["Energy"].values.reshape(-1, 72)
+        first_63 = grouped[-1, :63]
+        first_63_energies.append(first_63)
 
     # Find last 9 fine energy values of all sweeps data
     # -------------------------------------------------
@@ -96,13 +142,9 @@ def solve_full_sweep_energy(
     # order it should be in:
     #  [64, 65, 66, 67, 68, 69, 70, 71, 72]
     energy_values = np.flip(energy_values, axis=1)
-    # Expand to match the number of rows in energy_values
-    first_63_values = np.tile(
-        fixed_energy_values, (energy_values.shape[0], 1)
-    )  # (epoch, 63)
 
     # Append the first_63_values in front of energy_values
-    sweeps_energy_value = np.hstack((first_63_values, energy_values))
+    sweeps_energy_value = np.hstack([first_63_energies, energy_values])
 
     return sweeps_energy_value
 
@@ -117,14 +159,12 @@ def swapi_l2(
 
     To process science data to L2, we need to:
     - convert counts to rates. This is done by dividing the counts by the
-        TIME_PER_BIN time. TIME_PER_BIN is the exposure time per energy bin which is
-        obtained by dividing the time for one complete sweep
-        (12 s, coarse + fine sweep) by the total energy steps (72),
-        i.e., TIME_PER_BIN = 12/72 = 0.167 s. This will be constant.
+        SWAPI_LIVETIME time. LIVETIME is data acquisition time. It will
+        be constant, SWAPI_LIVETIME = 0.145 s.
 
     - update uncertainty. Calculate new uncertainty value using
-        SWP_PCEM_ERR data from level one and divide by TIME_PER_BIN. Eg.
-            SWP_PCEM_UNC = SWP_PCEM_ERR / TIME_PER_BIN
+        SWP_PCEM_ERR data from level one and divide by SWAPI_LIVETIME. Eg.
+            SWP_PCEM_UNC = SWP_PCEM_ERR / SWAPI_LIVETIME
         Do the same for SCEM and COIN data.
 
     Parameters
@@ -169,8 +209,10 @@ def swapi_l2(
     esa_lvl5_hex = np.vectorize(lambda x: format(x, "X"))(l1_dataset["esa_lvl5"].values)
     esa_energy = solve_full_sweep_energy(
         esa_lvl5_hex,
+        l1_dataset["sweep_table"].data,
         esa_table_df=esa_table_df,
         lut_notes_df=lut_notes_df,
+        data_time=np.array(l1_dataset["epoch"].data, dtype="datetime64[ns]"),
     )
 
     l2_dataset["swp_esa_energy"] = xr.DataArray(
@@ -189,9 +231,9 @@ def swapi_l2(
     ]
 
     # convert counts to rate
-    l2_dataset["swp_pcem_rate"] = l1_dataset["swp_pcem_counts"] / TIME_PER_BIN
-    l2_dataset["swp_scem_rate"] = l1_dataset["swp_scem_counts"] / TIME_PER_BIN
-    l2_dataset["swp_coin_rate"] = l1_dataset["swp_coin_counts"] / TIME_PER_BIN
+    l2_dataset["swp_pcem_rate"] = l1_dataset["swp_pcem_counts"] / SWAPI_LIVETIME
+    l2_dataset["swp_scem_rate"] = l1_dataset["swp_scem_counts"] / SWAPI_LIVETIME
+    l2_dataset["swp_coin_rate"] = l1_dataset["swp_coin_counts"] / SWAPI_LIVETIME
     # update attrs
     l2_dataset["swp_pcem_rate"].attrs = cdf_manager.get_variable_attributes("pcem_rate")
     l2_dataset["swp_scem_rate"].attrs = cdf_manager.get_variable_attributes("scem_rate")
@@ -199,22 +241,22 @@ def swapi_l2(
 
     # update uncertainty
     l2_dataset["swp_pcem_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_pcem_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_pcem_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_pcem_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_pcem_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_pcem_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_scem_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_scem_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_scem_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_scem_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_scem_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_scem_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_coin_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_coin_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_coin_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_coin_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_coin_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_coin_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     # update attrs
     l2_dataset[

imap_processing/swapi/swapi_utils.py

@@ -51,7 +51,7 @@ def read_swapi_lut_table(file_path: Path) -> pd.DataFrame:
         .astype(str)
         .str.replace(",", "", regex=False)
         .replace("Solve", -1)
-        .astype(np.int64)
+        .astype(np.float64)
     )
 
     return df

imap_processing/swe/l1b/swe_l1b.py

@@ -2,7 +2,6 @@
 
 import logging
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 import numpy.typing as npt
@@ -51,7 +50,7 @@ def get_esa_dataframe(esa_table_number: int) -> pd.DataFrame:
 
 
 def deadtime_correction(
-    counts: np.ndarray, acq_duration: Union[int, npt.NDArray]
+    counts: np.ndarray, acq_duration: int | npt.NDArray
 ) -> npt.NDArray:
     """
     Calculate deadtime correction.
@@ -767,10 +766,8 @@ def swe_l1b_science(dependencies: ProcessingInputCollection) -> xr.Dataset:
 
     # Store ESA energies of full cycle for L2 purposes.
     esa_energies = get_esa_energy_pattern(esa_lut_files[0])
-    # Repeat energies to be in the same shape as the science data
-    esa_energies = np.repeat(esa_energies, total_packets // 4).reshape(
-        -1, swe_constants.N_ESA_STEPS, swe_constants.N_ANGLE_SECTORS
-    )
+    # Repeat the (24, 30) energy pattern n_cycles times along a new first axis
+    esa_energies = np.repeat(esa_energies[np.newaxis, :, :], total_packets // 4, axis=0)
     # Convert voltage to electron energy in eV by apply conversion factor
     esa_energies = esa_energies * swe_constants.ENERGY_CONVERSION_FACTOR
     # ------------------------------------------------------------------

imap_processing/ultra/constants.py

@@ -51,7 +51,6 @@ class UltraConstants:
     Z_DSTOP: float = 2.6 / 2  # Position of stop foil on Z axis [mm]
     Z_DS: float = 46.19 - (2.6 / 2)  # Position of slit on Z axis [mm]
     DF: float = 3.39  # Distance from slit to foil [mm]
-
     # Derived constants
     DMIN_PH_CTOF: float = (
         Z_DS - (2**0.5) * DF
@@ -79,5 +78,31 @@ class UltraConstants:
     CULLING_RPM_MIN = 2.0
     CULLING_RPM_MAX = 6.0
 
-    # Thresholds for culling based on counts.
-    CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [0, 10, 20, 1e5]
+    # Thresholds for culling based on counts (keV).
+    CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [
+        3.385,
+        4.13722222222222,
+        5.05660493827161,
+        6.18029492455419,
+        7.55369379667734,
+        9.23229241816119,
+        11.2839129555303,
+        13.7914491678704,
+        16.8562156496194,
+        20.6020413495348,
+        25.1802727605426,
+        30.775888929552,
+        37.6149753583414,
+        45.9738587713061,
+        56.1902718315964,
+        68.6769989052845,
+        83.93855421757,
+        102.591566265919,
+        125.38969210279,
+        153.254068125632,
+        187.310527709106,
+        228.93508942224,
+        279.809553738294,
+        341.989454569026,
+        1e5,
+    ]

imap_processing/ultra/l0/decom_tools.py

@@ -4,6 +4,7 @@ import numpy as np
 from numpy.typing import NDArray
 
 from imap_processing.ultra.l0.ultra_utils import (
+    PacketProperties,
     parse_event,
 )
 from imap_processing.utils import convert_to_binary_string
@@ -155,8 +156,7 @@ def decompress_binary(
 def decompress_image(
     pixel0: int,
     binary_data: str,
-    width_bit: int,
-    mantissa_bit_length: int,
+    packet_props: PacketProperties,
 ) -> NDArray:
     """
     Will decompress a binary string representing an image into a matrix of pixel values.
@@ -171,10 +171,9 @@ def decompress_image(
         The first, unmodified pixel p0,0.
     binary_data : str
         Binary string.
-    width_bit : int
-        The bit width that describes the width of data in the block.
-    mantissa_bit_length : int
-        The bit length of the mantissa.
+    packet_props : PacketProperties
+        Properties of the packet, including width bit, mantissa bit length and pixel
+        window dimensions.
 
     Returns
     -------
@@ -187,10 +186,18 @@ def decompress_image(
     This process is described starting on page 168 in IMAP-Ultra Flight
     Software Specification document.
     """
-    rows = 54
-    cols = 180
+    rows = packet_props.pixel_window_rows
+    cols = packet_props.pixel_window_columns
+    width_bit = packet_props.width
+    mantissa_bit_length = packet_props.mantissa_bit_length
     pixels_per_block = 15
 
+    if width_bit is None or rows is None or cols is None or mantissa_bit_length is None:
+        raise ValueError(
+            "Packet properties must specify pixel window dimensions, "
+            "width bit, and mantissa bit length for this packet type."
+        )
+
     blocks_per_row = cols // pixels_per_block
 
     # Compressed pixel matrix

imap_processing/ultra/l0/decom_ultra.py

@@ -1,6 +1,7 @@
 """Decommutates Ultra CCSDS packets."""
 
 import logging
+import math
 from collections import defaultdict
 from typing import cast
 
@@ -29,7 +30,7 @@ from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_PRI_3_EVENTS,
     ULTRA_PRI_4_EVENTS,
     ULTRA_RATES,
-    ULTRA_TOF,
+    PacketProperties,
 )
 from imap_processing.utils import convert_to_binary_string
 
@@ -37,7 +38,7 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def process_ultra_tof(ds: xr.Dataset) -> xr.Dataset:
+def process_ultra_tof(ds: xr.Dataset, packet_props: PacketProperties) -> xr.Dataset:
     """
     Unpack and decode Ultra TOF packets.
 
@@ -45,6 +46,9 @@ def process_ultra_tof(ds: xr.Dataset) -> xr.Dataset:
     ----------
     ds : xarray.Dataset
         TOF dataset.
+    packet_props : PacketProperties
+        Information that defines properties of the packet including the pixel window
+        dimensions of images and number of image panes.
 
     Returns
     -------
@@ -53,14 +57,35 @@ def process_ultra_tof(ds: xr.Dataset) -> xr.Dataset:
     """
     scalar_keys = [key for key in ds.data_vars if key not in ("packetdata", "sid")]
 
+    image_planes = packet_props.image_planes
+    rows = packet_props.pixel_window_rows
+    cols = packet_props.pixel_window_columns
+    planes_per_packet = packet_props.image_planes_per_packet
+
+    if (
+        image_planes is None
+        or rows is None
+        or cols is None
+        or planes_per_packet is None
+    ):
+        raise ValueError(
+            "Packet properties must specify pixel window dimensions, "
+            "width bit, image planes, and image planes per packet for this packet type."
+        )
+    # Calculate the number of image packets based on the number of image panes and
+    # planes per packet.
+    # There may be cases where the last packet has fewer planes than the
+    # planes_per_packet, to account for this, we use ceiling division.
+    num_image_packets = math.ceil(image_planes / planes_per_packet)
+
     decom_data: defaultdict[str, list[np.ndarray]] = defaultdict(list)
     decom_data["packetdata"] = []
     valid_epoch = []
-    width = cast(int, ULTRA_TOF.width)
-    mantissa_bit_length = cast(int, ULTRA_TOF.mantissa_bit_length)
 
     for val, group in ds.groupby("epoch"):
-        if set(group["sid"].values) >= set(range(8)):
+        if set(group["sid"].values) >= set(
+            np.arange(0, image_planes, planes_per_packet)
+        ):
             valid_epoch.append(val)
             group.sortby("sid")
 
@@ -68,13 +93,12 @@ def process_ultra_tof(ds: xr.Dataset) -> xr.Dataset:
                 decom_data[key].append(group[key].values)
 
             image = []
-            for i in range(8):
+            for i in range(num_image_packets):
                 binary = convert_to_binary_string(group["packetdata"].values[i])
                 decompressed = decompress_image(
                     group["p00"].values[i],
                     binary,
-                    width,
-                    mantissa_bit_length,
+                    packet_props,
                 )
                 image.append(decompressed)
 
@@ -87,9 +111,9 @@ def process_ultra_tof(ds: xr.Dataset) -> xr.Dataset:
 
     coords = {
         "epoch": np.array(valid_epoch, dtype=np.uint64),
-        "sid": xr.DataArray(np.arange(8), dims=["sid"], name="sid"),
-        "row": xr.DataArray(np.arange(54), dims=["row"], name="row"),
-        "column": xr.DataArray(np.arange(180), dims=["column"], name="column"),
+        "sid": xr.DataArray(np.arange(num_image_packets), dims=["sid"], name="sid"),
+        "row": xr.DataArray(np.arange(rows), dims=["row"], name="row"),
+        "column": xr.DataArray(np.arange(cols), dims=["column"], name="column"),
     }
 
     dataset = xr.Dataset(coords=coords)

imap_processing/ultra/l0/ultra_utils.py

@@ -1,6 +1,6 @@
 """Contains data classes to support Ultra L0 processing."""
 
-from typing import NamedTuple, Union
+from typing import NamedTuple
 
 
 class PacketProperties(NamedTuple):
@@ -9,16 +9,22 @@ class PacketProperties(NamedTuple):
     apid: list  # List of APIDs
     logical_source: list  # List of logical sources
     addition_to_logical_desc: str  # Description of the logical source
-    width: Union[int, None]  # Width of binary data (could be None).
-    block: Union[int, None]  # Number of values in each block (could be None).
-    # This is important for decompressing the images and
-    # a description is available on page 171 of IMAP-Ultra Flight
-    # Software Specification document (7523-9009_Rev_-.pdf).
-    len_array: Union[
-        int, None
-    ]  # Length of the array to be decompressed (could be None).
-    mantissa_bit_length: Union[int, None]  # used to determine the level of
+    width: int | None  # Width of binary data (could be None).
+    # Block, image_planes, pixel_window_rows, and pixel_window_columns are important for
+    # decompressing the images and a description is available on page 171 of IMAP-Ultra
+    # Flight Software Specification document (7523-9009_Rev_-.pdf).
+    block: int | None  # Number of values in each block (could be None).
+    len_array: int | None  # Length of the array to be decompressed (could be None).
+    mantissa_bit_length: int | None  # used to determine the level of
     # precision that can be recovered from compressed data (could be None).
+    image_planes: int | None = None
+    # number of images. See table 11 in the FSSD.
+    pixel_window_rows: int | None = None
+    # number of rows in each image. See table 49 in the FSSD.
+    pixel_window_columns: int | None = None
+    # number of columns in each image. See table 49 in the FSSD.
+    image_planes_per_packet: int | None = None
+    # number of image planes in each packet. See table 52 in the FSSD.
 
 
 # Define PacketProperties instances directly in the module namespace
@@ -64,15 +70,99 @@ ULTRA_ENERGY_SPECTRA = PacketProperties(
     len_array=1,
     mantissa_bit_length=5,
 )
-ULTRA_TOF = PacketProperties(
+ULTRA_PHXTOF_HIGH_ANGULAR = PacketProperties(
     apid=[883, 947],
     logical_source=[
         "imap_ultra_l1a_45sensor-histogram-ena-phxtof-hi-ang",
         "imap_ultra_l1a_90sensor-histogram-ena-phxtof-hi-ang",
     ],
-    addition_to_logical_desc="Time of Flight Images",
+    addition_to_logical_desc="Pulse Height Time of Flight High Angular Images",
     width=4,
     block=15,
+    image_planes=8,
+    pixel_window_rows=54,
+    pixel_window_columns=180,
+    image_planes_per_packet=1,
+    len_array=None,
+    mantissa_bit_length=4,
+)
+ULTRA_PHXTOF_HIGH_ENERGY = PacketProperties(
+    apid=[884, 948],
+    logical_source=[
+        "imap_ultra_l1a_45sensor-histogram-ena-phxtof-hi-nrg",
+        "imap_ultra_l1a_90sensor-histogram-ena-phxtof-hi-nrg",
+    ],
+    addition_to_logical_desc="Pulse Height By Time of Flight High Energy Images",
+    width=4,
+    block=15,
+    image_planes=28,
+    pixel_window_rows=27,
+    pixel_window_columns=90,
+    image_planes_per_packet=1,
+    len_array=None,
+    mantissa_bit_length=4,
+)
+ULTRA_PHXTOF_HIGH_TIME = PacketProperties(
+    apid=[885, 949],
+    logical_source=[
+        "imap_ultra_l1a_45sensor-histogram-ena-phxtof-hi-time",
+        "imap_ultra_l1a_90sensor-histogram-ena-phxtof-hi-time",
+    ],
+    addition_to_logical_desc="Time of Flight High Time Images",
+    width=4,
+    block=15,
+    image_planes=8,
+    pixel_window_rows=18,
+    pixel_window_columns=60,
+    image_planes_per_packet=2,
+    len_array=None,
+    mantissa_bit_length=4,
+)
+ULTRA_EXTOF_HIGH_ANGULAR = PacketProperties(
+    apid=[886, 950],
+    logical_source=[
+        "imap_ultra_l1a_45sensor-histogram-ena-extof-hi-ang",
+        "imap_ultra_l1a_90sensor-histogram-ena-extof-hi-ang",
+    ],
+    addition_to_logical_desc="Energy By Time of Flight High Angular Images",
+    width=4,
+    block=15,
+    image_planes=12,
+    pixel_window_rows=18,
+    pixel_window_columns=60,
+    image_planes_per_packet=2,
+    len_array=None,
+    mantissa_bit_length=4,
+)
+ULTRA_EXTOF_HIGH_TIME = PacketProperties(
+    apid=[888, 952],
+    logical_source=[
+        "imap_ultra_l1a_45sensor-histogram-ena-extof-hi-time",
+        "imap_ultra_l1a_90sensor-histogram-ena-extof-hi-time",
+    ],
+    addition_to_logical_desc="Energy By Time of Flight High Time Images",
+    width=4,
+    block=15,
+    image_planes=4,
+    pixel_window_rows=9,
+    pixel_window_columns=30,
+    image_planes_per_packet=8,
+    len_array=None,
+    mantissa_bit_length=4,
+)
+ULTRA_EXTOF_HIGH_ENERGY = PacketProperties(
+    apid=[887, 951],
+    logical_source=[
+        "imap_ultra_l1a_45sensor-histogram-ena-extof-hi-nrg",
+        "imap_ultra_l1a_90sensor-histogram-ena-extof-hi-nrg",
+    ],
+    addition_to_logical_desc="Energy By Time of Flight High Energy Images",
+    width=4,
+    block=15,
+    image_planes=44,
+    pixel_window_rows=9,
+    pixel_window_columns=30,
+    image_planes_per_packet=8,
     len_array=None,
     mantissa_bit_length=4,
 )

imap_processing/ultra/l1a/ultra_l1a.py

@@ -1,7 +1,6 @@
 """Generate ULTRA L1a CDFs."""
 
 import logging
-from typing import Optional
 
 import xarray as xr
 
@@ -24,14 +23,19 @@ from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_ENERGY_RATES,
     ULTRA_ENERGY_SPECTRA,
     ULTRA_EVENTS,
+    ULTRA_EXTOF_HIGH_ANGULAR,
+    ULTRA_EXTOF_HIGH_ENERGY,
+    ULTRA_EXTOF_HIGH_TIME,
     ULTRA_HK,
     ULTRA_MACROS_CHECKSUM,
+    ULTRA_PHXTOF_HIGH_ANGULAR,
+    ULTRA_PHXTOF_HIGH_ENERGY,
+    ULTRA_PHXTOF_HIGH_TIME,
     ULTRA_PRI_1_EVENTS,
     ULTRA_PRI_2_EVENTS,
     ULTRA_PRI_3_EVENTS,
     ULTRA_PRI_4_EVENTS,
     ULTRA_RATES,
-    ULTRA_TOF,
 )
 from imap_processing.utils import packet_file_to_datasets
 
@@ -39,7 +43,7 @@ logger = logging.getLogger(__name__)
 
 
 def ultra_l1a(  # noqa: PLR0912
-    packet_file: str, apid_input: Optional[int] = None
+    packet_file: str, apid_input: int | None = None
 ) -> list[xr.Dataset]:
     """
     Will process ULTRA L0 data into L1A CDF files at output_filepath.
@@ -87,6 +91,19 @@ def ultra_l1a(  # noqa: PLR0912
         for i, apid in enumerate(group.apid)
     }
 
+    all_l1a_image_apids = {
+        apid: group
+        for group in [
+            ULTRA_PHXTOF_HIGH_ANGULAR,
+            ULTRA_PHXTOF_HIGH_ENERGY,
+            ULTRA_PHXTOF_HIGH_TIME,
+            ULTRA_EXTOF_HIGH_ANGULAR,
+            ULTRA_EXTOF_HIGH_TIME,
+            ULTRA_EXTOF_HIGH_ENERGY,
+        ]
+        for apid in group.apid
+    }
+
     # Update dataset global attributes
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs("ultra")
@@ -96,9 +113,12 @@ def ultra_l1a(  # noqa: PLR0912
         if apid in ULTRA_AUX.apid:
             decom_ultra_dataset = datasets_by_apid[apid]
             gattr_key = ULTRA_AUX.logical_source[ULTRA_AUX.apid.index(apid)]
-        elif apid in ULTRA_TOF.apid:
-            decom_ultra_dataset = process_ultra_tof(datasets_by_apid[apid])
-            gattr_key = ULTRA_TOF.logical_source[ULTRA_TOF.apid.index(apid)]
+        elif apid in all_l1a_image_apids:
+            packet_props = all_l1a_image_apids[apid]
+            decom_ultra_dataset = process_ultra_tof(
+                datasets_by_apid[apid], packet_props
+            )
+            gattr_key = packet_props.logical_source[packet_props.apid.index(apid)]
         elif apid in ULTRA_RATES.apid:
             decom_ultra_dataset = process_ultra_rates(datasets_by_apid[apid])
             decom_ultra_dataset = decom_ultra_dataset.drop_vars("fastdata_00")

imap_processing/ultra/l1b/cullingmask.py

@@ -3,7 +3,7 @@
 import numpy as np
 import xarray as xr
 
-from imap_processing.quality_flags import ImapAttitudeUltraFlags, ImapRatesUltraFlags
+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
@@ -32,14 +32,17 @@ def calculate_cullingmask(extendedspin_dataset: xr.Dataset, name: str) -> xr.Dat
     good_mask = (
         (
             extendedspin_dataset["quality_attitude"]
-            & ImapAttitudeUltraFlags.SPINRATE.value
+            & sum(flag.value for flag in SPIN_QUALITY_FLAG_FILTERS["quality_attitude"])
         )
         == 0
     ) & (
         (
             (
                 extendedspin_dataset["quality_ena_rates"]
-                & ImapRatesUltraFlags.HIGHRATES.value
+                & sum(
+                    flag.value
+                    for flag in SPIN_QUALITY_FLAG_FILTERS["quality_ena_rates"]
+                )
             )
             == 0
         ).all(dim="energy_bin_geometric_mean")