imap-processing 0.6.0__py3-none-any.whl

imap_processing/ultra/l0/ultra_utils.py

@@ -0,0 +1,326 @@
+"""Contains data classes to support Ultra L0 processing."""
+
+from dataclasses import fields
+from typing import NamedTuple, Union
+
+import numpy as np
+
+
+class PacketProperties(NamedTuple):
+    """Class that represents properties of the ULTRA packet type."""
+
+    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
+    # precision that can be recovered from compressed data (could be None).
+
+
+# Define PacketProperties instances directly in the module namespace
+ULTRA_AUX = PacketProperties(
+    apid=[880, 994],
+    logical_source=["imap_ultra_l1a_45sensor-aux", "imap_ultra_l1a_90sensor-aux"],
+    addition_to_logical_desc="Auxiliary",
+    width=None,
+    block=None,
+    len_array=None,
+    mantissa_bit_length=None,
+)
+ULTRA_RATES = PacketProperties(
+    apid=[881, 945],
+    logical_source=["imap_ultra_l1a_45sensor-rates", "imap_ultra_l1a_90sensor-rates"],
+    addition_to_logical_desc="Image Rates",
+    width=5,
+    block=16,
+    len_array=48,
+    mantissa_bit_length=12,
+)
+ULTRA_TOF = PacketProperties(
+    apid=[883, 947],
+    logical_source=[
+        "imap_ultra_l1a_45sensor-histogram",
+        "imap_ultra_l1a_90sensor-histogram",
+    ],
+    addition_to_logical_desc="Time of Flight Images",
+    width=4,
+    block=15,
+    len_array=None,
+    mantissa_bit_length=4,
+)
+ULTRA_EVENTS = PacketProperties(
+    apid=[896, 960],
+    logical_source=["imap_ultra_l1a_45sensor-de", "imap_ultra_l1a_90sensor-de"],
+    addition_to_logical_desc="Single Events",
+    width=None,
+    block=None,
+    len_array=None,
+    mantissa_bit_length=None,
+)
+
+
+# Module-level constant for event field ranges
+# Module-level constant for event field ranges
+EVENT_FIELD_RANGES = {
+    # Coincidence Type
+    "COIN_TYPE": (0, 2),
+    # Start Type
+    "START_TYPE": (2, 4),
+    # Stop Type
+    "STOP_TYPE": (4, 8),
+    # Start Position Time to Digital Converter
+    "START_POS_TDC": (8, 19),
+    # Stop North Time to Digital Converter
+    "STOP_NORTH_TDC": (19, 30),
+    # Stop East Time to Digital Converter
+    "STOP_EAST_TDC": (30, 41),
+    # Stop South Time to Digital Converter
+    "STOP_SOUTH_TDC": (41, 52),
+    # Stop West Time to Digital Converter
+    "STOP_WEST_TDC": (52, 63),
+    # Coincidence North Time to Digital Converter
+    "COIN_NORTH_TDC": (63, 74),
+    # Coincidence South Time to Digital Converter
+    "COIN_SOUTH_TDC": (74, 85),
+    # Coincidence Discrete Time to Digital Converter
+    "COIN_DISCRETE_TDC": (85, 96),
+    # Energy/Pulse Height
+    "ENERGY_PH": (96, 108),
+    # Pulse Width
+    "PULSE_WIDTH": (108, 119),
+    # Event Flag Count
+    "EVENT_FLAG_CNT": (119, 120),
+    # Event Flag PHCmpSL
+    "EVENT_FLAG_PHCMPSL": (120, 121),
+    # Event Flag PHCmpSR
+    "EVENT_FLAG_PHCMPSR": (121, 122),
+    # Event Flag PHCmpCD
+    "EVENT_FLAG_PHCMPCD": (122, 123),
+    # Solid State Detector Flags
+    "SSD_FLAG_7": (123, 124),
+    "SSD_FLAG_6": (124, 125),
+    "SSD_FLAG_5": (125, 126),
+    "SSD_FLAG_4": (126, 127),
+    "SSD_FLAG_3": (127, 128),
+    "SSD_FLAG_2": (128, 129),
+    "SSD_FLAG_1": (129, 130),
+    "SSD_FLAG_0": (130, 131),
+    # Constant Fraction Discriminator Flag Coincidence Top North
+    "CFD_FLAG_COINTN": (131, 132),
+    # Constant Fraction Discriminator Flag Coincidence Bottom North
+    "CFD_FLAG_COINBN": (132, 133),
+    # Constant Fraction Discriminator Flag Coincidence Top South
+    "CFD_FLAG_COINTS": (133, 134),
+    # Constant Fraction Discriminator Flag Coincidence Bottom South
+    "CFD_FLAG_COINBS": (134, 135),
+    # Constant Fraction Discriminator Flag Coincidence Discrete
+    "CFD_FLAG_COIND": (135, 136),
+    # Constant Fraction Discriminator Flag Start Right Full
+    "CFD_FLAG_STARTRF": (136, 137),
+    # Constant Fraction Discriminator Flag Start Left Full
+    "CFD_FLAG_STARTLF": (137, 138),
+    # Constant Fraction Discriminator Flag Start Position Right
+    "CFD_FLAG_STARTRP": (138, 139),
+    # Constant Fraction Discriminator Flag Start Position Left
+    "CFD_FLAG_STARTLP": (139, 140),
+    # Constant Fraction Discriminator Flag Stop Top North
+    "CFD_FLAG_STOPTN": (140, 141),
+    # Constant Fraction Discriminator Flag Stop Bottom North
+    "CFD_FLAG_STOPBN": (141, 142),
+    # Constant Fraction Discriminator Flag Stop Top East
+    "CFD_FLAG_STOPTE": (142, 143),
+    # Constant Fraction Discriminator Flag Stop Bottom East
+    "CFD_FLAG_STOPBE": (143, 144),
+    # Constant Fraction Discriminator Flag Stop Top South
+    "CFD_FLAG_STOPTS": (144, 145),
+    # Constant Fraction Discriminator Flag Stop Bottom South
+    "CFD_FLAG_STOPBS": (145, 146),
+    # Constant Fraction Discriminator Flag Stop Top West
+    "CFD_FLAG_STOPTW": (146, 147),
+    # Constant Fraction Discriminator Flag Stop Bottom West
+    "CFD_FLAG_STOPBW": (147, 148),
+    # Bin
+    "BIN": (148, 156),
+    # Phase Angle
+    "PHASE_ANGLE": (156, 166),
+}
+
+
+RATES_KEYS = [
+    # Start Right Full Constant Fraction Discriminator (CFD) Pulses
+    "START_RF",
+    # Start Left Full Constant Fraction Discriminator (CFD) Pulses
+    "START_LF",
+    # Start Position Right Full Constant Fraction Discriminator (CFD) Pulses
+    "START_RP",
+    # Start Position Left Constant Fraction Discriminator (CFD) Pulses
+    "START_LP",
+    # Stop Top North Constant Fraction Discriminator (CFD) Pulses
+    "STOP_TN",
+    # Stop Bottom North Constant Fraction Discriminator (CFD) Pulses
+    "STOP_BN",
+    # Stop Top East Constant Fraction Discriminator (CFD) Pulses
+    "STOP_TE",
+    # Stop Bottom East Constant Fraction Discriminator (CFD) Pulses
+    "STOP_BE",
+    # Stop Top South Constant Fraction Discriminator (CFD) Pulses
+    "STOP_TS",
+    # Stop Bottom South Constant Fraction Discriminator (CFD) Pulses
+    "STOP_BS",
+    # Stop Top West Constant Fraction Discriminator (CFD) Pulses
+    "STOP_TW",
+    # Stop Bottom West Constant Fraction Discriminator (CFD) Pulses
+    "STOP_BW",
+    # Coincidence Top North Constant Fraction Discriminator (CFD) Pulses
+    "COIN_TN",
+    # Coincidence Bottom North Constant Fraction Discriminator (CFD) Pulses
+    "COIN_BN",
+    # Coincidence Top South Constant Fraction Discriminator (CFD) Pulses
+    "COIN_TS",
+    # Coincidence Bottom South Constant Fraction Discriminator (CFD) Pulses
+    "COIN_BS",
+    # Coincidence Discrete Constant Fraction Discriminator (CFD) Pulses
+    "COIN_D",
+    # Solid State Detector (SSD) Energy Pulses
+    "SSD0",
+    "SSD1",
+    "SSD2",
+    "SSD3",
+    "SSD4",
+    "SSD5",
+    "SSD6",
+    "SSD7",
+    # Start Position Time to Digital Converter (TDC) Chip VE Pulses
+    "START_POS",
+    # Stop North TDC-chip VE Pulses
+    "STOP_N",
+    # Stop East TDC-chip VE Pulses
+    "STOP_E",
+    # Stop South TDC-chip VE Pulses
+    "STOP_S",
+    # Stop West TDC-chip VE Pulses
+    "STOP_W",
+    # Coincidence North TDC-chip VE Pulses
+    "COIN_N_TDC",
+    # Coincidence Discrete TDC-chip VE Pulses
+    "COIN_D_TDC",
+    # Coincidence South TDC-chip VE Pulses
+    "COIN_S_TDC",
+    # Stop Top North Valid Pulse Height Flag
+    "STOP_TOP_N",
+    # Stop Bottom North Valid Pulse Height Flag
+    "STOP_BOT_N",
+    # Start-Right/Stop Single Coincidence.
+    # Stop can be either Top or Bottom.
+    # Coincidence is allowed, but not required.
+    # No SSD.
+    "START_RIGHT_STOP_COIN_SINGLE",
+    # Start-Left/Stop Single Coincidence.
+    # Stop can be either Top or Bottom.
+    # Coincidence is allowed, but not required.
+    # No SSD.
+    "START_LEFT_STOP_COIN_SINGLE",
+    # Start-Right/Stop/Coin Coincidence.
+    # Double Coincidence.
+    # Stop/Coin can be either Top or Bottom. No SSD.
+    "START_RIGHT_STOP_COIN_DOUBLE",
+    # Start-Left/Stop/Coin Coincidence.
+    # Double Coincidence.
+    # Stop/Coin can be either Top or Bottom. No SSD.
+    "START_LEFT_STOP_COIN_DOUBLE",
+    # Start/Stop/Coin Coincidence +
+    # Position Match.
+    # Double Coincidence + Fine Position Match
+    # between Stop and Coin measurements.
+    # No SSD.
+    "START_STOP_COIN_POS",
+    # Start-Right/SSD/Coin-D Coincidence.
+    # Energy Coincidence.
+    "START_RIGHT_SSD_COIN_D",
+    # Start-Left/SSD/Coin-D Coincidence.
+    # Energy Coincidence.
+    "START_LEFT_SSD_COIN_D",
+    # Event Analysis Activity Time.
+    "EVENT_ACTIVE_TIME",
+    # Events that would have been written to the FIFO.
+    # (attempted to write).
+    "FIFO_VALID_EVENTS",
+    # Events generated by the pulser.
+    "PULSER_EVENTS",
+    # Coincidence (windowed) between the Stop/Coin top.
+    "WINDOW_STOP_COIN",
+    # Coincidence between Start Left and Window-Stop/Coin.
+    "START_LEFT_WINDOW_STOP_COIN",
+    # Coincidence between Start Right and Window-Stop/Coin.
+    "START_RIGHT_WINDOW_STOP_COIN",
+    # TODO: Below will be added later. It is not in the current data.
+    # Processed events generated by the pulser.
+    # "PROCESSED_PULSER_EVENTS",
+    # Processed events.
+    # "PROCESSED_EVENTS",
+    # Discarded events.
+    # "DISCARDED_EVENTS"
+]
+
+
+def append_fillval(decom_data: dict, packet):  # type: ignore[no-untyped-def]
+    # ToDo, need packet param type
+    """
+    Append fill values to all fields.
+
+    Parameters
+    ----------
+    decom_data : dict
+        Parsed data.
+    packet : space_packet_parser.parser.Packet
+        Packet.
+    """
+    for key in decom_data:
+        if (key not in packet.header.keys()) and (key not in packet.data.keys()):
+            decom_data[key].append(np.iinfo(np.int64).min)
+
+
+def parse_event(event_binary: str) -> dict:
+    """
+    Parse a binary string representing a single event.
+
+    Parameters
+    ----------
+    event_binary : str
+        Event binary string.
+
+    Returns
+    -------
+    fields_dict : dict
+        Dict of the fields for a single event.
+    """
+    fields_dict = {}
+    for field, (start, end) in EVENT_FIELD_RANGES.items():
+        field_value = int(event_binary[start:end], 2)
+        fields_dict[field] = field_value
+    return fields_dict
+
+
+def append_ccsds_fields(decom_data: dict, ccsds_data_object: object) -> None:
+    """
+    Append CCSDS fields to event_data.
+
+    Parameters
+    ----------
+    decom_data : dict
+        Parsed data.
+    ccsds_data_object : DataclassInstance
+        CCSDS data object.
+    """
+    for field in fields(ccsds_data_object.__class__):  # type: ignore[arg-type]
+        ccsds_key = field.name
+        if ccsds_key not in decom_data:
+            decom_data[ccsds_key] = []
+        decom_data[ccsds_key].append(getattr(ccsds_data_object, ccsds_key))

imap_processing/ultra/l1a/ultra_l1a.py

@@ -0,0 +1,319 @@
+"""Generate ULTRA L1a CDFs."""
+
+# TODO: Evaluate naming conventions for fields and variables
+# TODO: Improved short and long descriptions for each variable
+# TODO: Improved var_notes for each variable
+import logging
+from typing import Optional
+
+import numpy as np
+import xarray as xr
+
+from imap_processing import decom, imap_module_directory
+from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
+from imap_processing.spice.time import met_to_j2000ns
+from imap_processing.ultra.l0.decom_ultra import process_ultra_apids
+from imap_processing.ultra.l0.ultra_utils import (
+    ULTRA_AUX,
+    ULTRA_EVENTS,
+    ULTRA_RATES,
+    ULTRA_TOF,
+)
+from imap_processing.utils import group_by_apid
+
+logger = logging.getLogger(__name__)
+
+
+def initiate_data_arrays(decom_ultra: dict, apid: int) -> xr.Dataset:
+    """
+    Initiate xarray data arrays.
+
+    Parameters
+    ----------
+    decom_ultra : dict
+        Parsed data.
+    apid : int
+        Packet APID.
+
+    Returns
+    -------
+    dataset : xarray.Dataset
+        Data in xarray format.
+    """
+    if apid in ULTRA_EVENTS.apid:
+        index = ULTRA_EVENTS.apid.index(apid)
+        logical_source = ULTRA_EVENTS.logical_source[index]
+        addition_to_logical_desc = ULTRA_EVENTS.addition_to_logical_desc
+        raw_time = decom_ultra["EVENTTIMES"]
+    elif apid in ULTRA_TOF.apid:
+        index = ULTRA_TOF.apid.index(apid)
+        logical_source = ULTRA_TOF.logical_source[index]
+        addition_to_logical_desc = ULTRA_TOF.addition_to_logical_desc
+        raw_time = np.unique(decom_ultra["SHCOARSE"])
+    elif apid in ULTRA_AUX.apid:
+        index = ULTRA_AUX.apid.index(apid)
+        logical_source = ULTRA_AUX.logical_source[index]
+        addition_to_logical_desc = ULTRA_AUX.addition_to_logical_desc
+        raw_time = decom_ultra["SHCOARSE"]
+    elif apid in ULTRA_RATES.apid:
+        index = ULTRA_RATES.apid.index(apid)
+        logical_source = ULTRA_RATES.logical_source[index]
+        addition_to_logical_desc = ULTRA_RATES.addition_to_logical_desc
+        raw_time = decom_ultra["SHCOARSE"]
+    else:
+        raise ValueError(f"APID {apid} not recognized.")
+
+    # Load the CDF attributes
+    cdf_manager = ImapCdfAttributes()
+    cdf_manager.add_instrument_global_attrs("ultra")
+    cdf_manager.add_instrument_variable_attrs("ultra", "l1a")
+
+    epoch_time = xr.DataArray(
+        met_to_j2000ns(raw_time),
+        name="epoch",
+        dims=["epoch"],
+        attrs=cdf_manager.get_variable_attributes("epoch"),
+    )
+
+    sci_cdf_attrs = cdf_manager.get_global_attributes("imap_ultra_l1a_sci")
+    # replace the logical source and logical source description
+    sci_cdf_attrs["Logical_source"] = logical_source
+    sci_cdf_attrs["Logical_source_desc"] = (
+        f"IMAP Mission ULTRA Instrument Level-1A {addition_to_logical_desc} Data"
+    )
+
+    if apid not in (ULTRA_TOF.apid[0], ULTRA_TOF.apid[1]):
+        dataset = xr.Dataset(
+            coords={"epoch": epoch_time},
+            attrs=sci_cdf_attrs,
+        )
+    else:
+        row = xr.DataArray(
+            # Number of pixel rows
+            np.arange(54),
+            name="row",
+            dims=["row"],
+            attrs=cdf_manager.get_variable_attributes("ultra_metadata_attrs"),
+        )
+
+        column = xr.DataArray(
+            # Number of pixel columns
+            np.arange(180),
+            name="column",
+            dims=["column"],
+            attrs=cdf_manager.get_variable_attributes("ultra_metadata_attrs"),
+        )
+
+        sid = xr.DataArray(
+            # Number of pixel columns
+            np.arange(8),
+            name="sid",
+            dims=["sid"],
+            attrs=cdf_manager.get_variable_attributes("ultra_metadata_attrs"),
+        )
+
+        dataset = xr.Dataset(
+            coords={"epoch": epoch_time, "sid": sid, "row": row, "column": column},
+            attrs=sci_cdf_attrs,
+        )
+
+    return dataset
+
+
+def get_event_time(decom_ultra_dict: dict) -> dict:
+    """
+    Get event times using data from events and aux packets.
+
+    Parameters
+    ----------
+    decom_ultra_dict : dict
+        Events and aux data.
+
+    Returns
+    -------
+    decom_events : dict
+        Ultra events data with calculated events timestamps.
+
+    Notes
+    -----
+    Equation for event time:
+    t = t_(spin start) + t_(spin start sub)/1000 +
+    t_(spin duration)/1000 * phase_angle/720
+    """
+    event_times, durations, spin_starts = ([] for _ in range(3))
+    decom_aux = decom_ultra_dict[ULTRA_AUX.apid[0]]
+    decom_events: dict = decom_ultra_dict[ULTRA_EVENTS.apid[0]]
+
+    timespinstart_array = np.array(decom_aux["TIMESPINSTART"])
+    timespinstartsub_array = np.array(decom_aux["TIMESPINSTARTSUB"]) / 1000
+
+    # spin start according to aux data
+    aux_spin_starts = timespinstart_array + timespinstartsub_array
+
+    for time in np.unique(decom_events["SHCOARSE"]):
+        # Get the nearest spin start and duration prior to the event
+        spin_start = aux_spin_starts[aux_spin_starts <= time][-1]
+        duration = np.array(decom_aux["DURATION"])[aux_spin_starts <= time][-1]
+
+        # Find the events
+        event_indices = np.where(np.array(decom_events["SHCOARSE"]) == time)
+
+        for event_index in event_indices[0]:
+            phase_angle = decom_events["PHASE_ANGLE"][event_index]
+
+            durations.append(duration)
+            spin_starts.append(spin_start)
+
+            # If there were no events, the time is set to 'SHCOARSE'
+            if decom_events["COUNT"][event_index] == 0:
+                event_times.append(decom_events["SHCOARSE"][event_index])
+            else:
+                event_times.append(spin_start + (duration / 1000) * (phase_angle / 720))
+
+    decom_events["DURATION"] = durations
+    decom_events["TIMESPINSTART"] = spin_starts
+    decom_events["EVENTTIMES"] = event_times
+
+    return decom_events
+
+
+def create_dataset(decom_ultra_dict: dict) -> xr.Dataset:
+    """
+    Create xarray for packet.
+
+    Parameters
+    ----------
+    decom_ultra_dict : dict
+        Dictionary of parsed data.
+
+    Returns
+    -------
+    dataset : xarray.Dataset
+        Data in xarray format.
+    """
+    # Combine events and aux datasets so we can have proper event timestamps
+    if ULTRA_EVENTS.apid[0] in decom_ultra_dict.keys():
+        apid = ULTRA_EVENTS.apid[0]
+        decom_ultra = get_event_time(decom_ultra_dict)
+    else:
+        apid = next(iter(decom_ultra_dict.keys()))
+        decom_ultra = decom_ultra_dict[apid]
+
+    # Load the CDF attributes
+    # TODO: call this once and pass the object to the function
+    cdf_manager = ImapCdfAttributes()
+    cdf_manager.add_instrument_global_attrs("ultra")
+    cdf_manager.add_instrument_variable_attrs("ultra", "l1a")
+
+    dataset = initiate_data_arrays(decom_ultra, apid)
+
+    for key, value in decom_ultra.items():
+        # EVENT DATA and FASTDATA_00 have been broken down further
+        # (see ultra_utils.py) and are therefore not needed.
+        # SID is also not needed as it is used as a dimension.
+        if key in {"EVENTDATA", "FASTDATA_00", "SID"}:
+            continue
+        # Everything in the TOF packet has dimensions of (time, sid) except
+        # for PACKETDATA which has dimensions of (time, sid, row, column) and
+        # SHCOARSE with has dimensions of (time)
+        elif apid == ULTRA_TOF.apid[0] and key != "PACKETDATA" and key != "SHCOARSE":
+            # TODO: fix this to use the correct attributes
+            attrs = cdf_manager.get_variable_attributes("ultra_support_attrs")
+            dims = ["epoch", "sid"]
+        # AUX enums require string attributes
+        elif key in [
+            "SPINPERIODVALID",
+            "SPINPHASEVALID",
+            "SPINPERIODSOURCE",
+            "CATBEDHEATERFLAG",
+            "HWMODE",
+            "IMCENB",
+            "LEFTDEFLECTIONCHARGE",
+            "RIGHTDEFLECTIONCHARGE",
+        ]:
+            # TODO: fix this to use the correct attributes
+            attrs = cdf_manager.get_variable_attributes("string_base_attrs")
+            dims = ["epoch"]
+        # TOF packetdata has multiple dimensions
+        elif key == "PACKETDATA":
+            # TODO: fix this to use the correct attributes
+            attrs = cdf_manager.get_variable_attributes("packet_data_attrs")
+            dims = ["epoch", "sid", "row", "column"]
+        # Use metadata with a single dimension for
+        # all other data products
+        else:
+            # TODO: fix this to use the correct attributes
+            attrs = cdf_manager.get_variable_attributes("ultra_support_attrs")
+            dims = ["epoch"]
+
+        dataset[key] = xr.DataArray(
+            value,
+            name=key if key == "epoch" else key.lower(),
+            dims=dims,
+            attrs=attrs,
+        )
+
+    return dataset
+
+
+def ultra_l1a(
+    packet_file: str, data_version: str, apid: Optional[int] = None
+) -> list[xr.Dataset]:
+    """
+    Will process ULTRA L0 data into L1A CDF files at output_filepath.
+
+    Parameters
+    ----------
+    packet_file : str
+        Path to the CCSDS data packet file.
+    data_version : str
+        Version of the data product being created.
+    apid : Optional[int]
+        Optional apid.
+
+    Returns
+    -------
+    output_datasets : list[xarray.Dataset]
+        List of xarray.Dataset.
+    """
+    xtce = str(
+        f"{imap_module_directory}/ultra/packet_definitions/" f"ULTRA_SCI_COMBINED.xml"
+    )
+
+    packets = decom.decom_packets(packet_file, xtce)
+    grouped_data = group_by_apid(packets)
+
+    output_datasets = []
+
+    # This is used for two purposes currently:
+    # 1. For testing purposes to only generate a dataset for a single apid.
+    #    Each test dataset is only for a single apid while the rest of the apids
+    #    contain zeros. Ideally we would have
+    #    test data for all apids and remove this parameter.
+    # 2. When we are generating the l1a dataset for the events packet since
+    #    right now we need to combine the events and aux packets to get the
+    #    correct event timestamps (get_event_time). This part will change
+    #    when we begin using the spin table in the database instead of the aux packet.
+    if apid is not None:
+        apids = [apid]
+    else:
+        apids = list(grouped_data.keys())
+
+    for apid in apids:
+        if apid == ULTRA_EVENTS.apid[0]:
+            decom_ultra_dict = {
+                apid: process_ultra_apids(grouped_data[apid], apid),
+                ULTRA_AUX.apid[0]: process_ultra_apids(
+                    grouped_data[ULTRA_AUX.apid[0]], ULTRA_AUX.apid[0]
+                ),
+            }
+        else:
+            decom_ultra_dict = {
+                apid: process_ultra_apids(grouped_data[apid], apid),
+            }
+        dataset = create_dataset(decom_ultra_dict)
+        # TODO: move this to use ImapCdfAttributes().add_global_attribute()
+        dataset.attrs["Data_version"] = data_version
+        output_datasets.append(dataset)
+
+    return output_datasets

imap_processing/ultra/l1b/badtimes.py

@@ -0,0 +1,26 @@
+"""Calculate Badtimes."""
+
+import xarray as xr
+
+from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
+
+
+def calculate_badtimes(extended_spin_dict: dict, name: str) -> xr.Dataset:
+    """
+    Create dataset with defined datatypes for Badtimes Data.
+
+    Parameters
+    ----------
+    extended_spin_dict : dict
+        L1b data dictionary.
+    name : str
+        Name of the dataset.
+
+    Returns
+    -------
+    badtimes_dataset : xarray.Dataset
+        Dataset containing the data.
+    """
+    badtimes_dataset = create_dataset(extended_spin_dict, name, "l1b")
+
+    return badtimes_dataset

imap_processing/ultra/l1b/cullingmask.py

@@ -0,0 +1,26 @@
+"""Calculate Culling Mask."""
+
+import xarray as xr
+
+from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
+
+
+def calculate_cullingmask(extended_spin_dict: dict, name: str) -> xr.Dataset:
+    """
+    Create dataset with defined datatype for Culling Mask Data.
+
+    Parameters
+    ----------
+    extended_spin_dict : dict
+        L1b data dictionary.
+    name : str
+        Name of the dataset.
+
+    Returns
+    -------
+    cullingmask_dataset : xarray.Dataset
+        Dataset containing the data.
+    """
+    cullingmask_dataset = create_dataset(extended_spin_dict, name, "l1b")
+
+    return cullingmask_dataset