imap-processing 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

imap_processing/ultra/l1a/ultra_l1a.py

@@ -1,248 +1,30 @@
 """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 import imap_module_directory
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
-from imap_processing.spice.time import met_to_ttj2000ns
-from imap_processing.ultra.l0.decom_ultra import process_ultra_apids
+from imap_processing.ultra.l0.decom_ultra import (
+    process_ultra_events,
+    process_ultra_rates,
+    process_ultra_tof,
+)
 from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_AUX,
     ULTRA_EVENTS,
+    ULTRA_HK,
     ULTRA_RATES,
     ULTRA_TOF,
 )
-from imap_processing.utils import group_by_apid
+from imap_processing.utils import packet_file_to_datasets
 
 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["SHCOARSE"]
-    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_ttj2000ns(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_id(decom_ultra_dict: dict) -> dict:
-    """
-    Get unique event IDs using data from events packets.
-
-    Parameters
-    ----------
-    decom_ultra_dict : dict
-        Events data.
-
-    Returns
-    -------
-    decom_events : dict
-        Ultra events data with calculated unique event IDs as 64-bit integers.
-    """
-    decom_events: dict = decom_ultra_dict[ULTRA_EVENTS.apid[0]]
-
-    event_ids = []
-    packet_counters = {}
-
-    for met in decom_events["SHCOARSE"]:
-        # Initialize the counter for a new packet (MET value)
-        if met not in packet_counters:
-            packet_counters[met] = 0
-        else:
-            packet_counters[met] += 1
-
-        # Left shift SHCOARSE (u32) by 31 bits, to make room for our event counters
-        # (31 rather than 32 to keep it positive in the int64 representation)
-        # Append the current number of events in this packet to the right-most bits
-        # This makes each event a unique value including the MET and event number
-        # in the packet
-        # NOTE: CDF does not allow for uint64 values,
-        # so we use int64 representation here
-        event_id = (np.int64(met) << np.int64(31)) | np.int64(packet_counters[met])
-        event_ids.append(event_id)
-
-    decom_events["EVENTID"] = event_ids
-
-    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_id(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]:
+def ultra_l1a(packet_file: str, apid_input: Optional[int] = None) -> list[xr.Dataset]:
     """
     Will process ULTRA L0 data into L1A CDF files at output_filepath.
 
@@ -250,9 +32,7 @@ def ultra_l1a(
     ----------
     packet_file : str
         Path to the CCSDS data packet file.
-    data_version : str
-        Version of the data product being created.
-    apid : Optional[int]
+    apid_input : Optional[int]
         Optional apid.
 
     Returns
@@ -261,11 +41,10 @@ def ultra_l1a(
         List of xarray.Dataset.
     """
     xtce = str(
-        f"{imap_module_directory}/ultra/packet_definitions/" f"ULTRA_SCI_COMBINED.xml"
+        f"{imap_module_directory}/ultra/packet_definitions/ULTRA_SCI_COMBINED.xml"
     )
 
-    packets = decom.decom_packets(packet_file, xtce)
-    grouped_data = group_by_apid(packets)
+    datasets_by_apid = packet_file_to_datasets(packet_file, xtce)
 
     output_datasets = []
 
@@ -274,18 +53,51 @@ def ultra_l1a(
     #    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.
-    if apid is not None:
-        apids = [apid]
+    if apid_input is not None:
+        apids = [apid_input]
     else:
-        apids = list(grouped_data.keys())
+        apids = list(datasets_by_apid.keys())
+
+    # Update dataset global attributes
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs("ultra")
+    attr_mgr.add_instrument_variable_attrs("ultra", "l1a")
 
     for apid in apids:
-        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)
+        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 ULTRA_RATES.apid:
+            decom_ultra_dataset = process_ultra_rates(datasets_by_apid[apid])
+            gattr_key = ULTRA_RATES.logical_source[ULTRA_RATES.apid.index(apid)]
+        elif apid in ULTRA_EVENTS.apid:
+            decom_ultra_dataset = process_ultra_events(datasets_by_apid[apid])
+            gattr_key = ULTRA_EVENTS.logical_source[ULTRA_EVENTS.apid.index(apid)]
+            # Add coordinate attributes
+            attrs = attr_mgr.get_variable_attributes("event_id")
+            decom_ultra_dataset.coords["event_id"].attrs.update(attrs)
+        elif apid in ULTRA_HK.apid:
+            decom_ultra_dataset = datasets_by_apid[apid]
+            gattr_key = ULTRA_HK.logical_source[ULTRA_HK.apid.index(apid)]
+        else:
+            logger.error(f"APID {apid} not recognized.")
+            # TODO: here we can put other apids
+            continue
+
+        decom_ultra_dataset.attrs.update(attr_mgr.get_global_attributes(gattr_key))
+
+        # Add data variable attributes
+        for key in decom_ultra_dataset.data_vars:
+            attrs = attr_mgr.get_variable_attributes(key.lower())
+            decom_ultra_dataset.data_vars[key].attrs.update(attrs)
+
+        # Add coordinate attributes
+        attrs = attr_mgr.get_variable_attributes("epoch", check_schema=False)
+        decom_ultra_dataset.coords["epoch"].attrs.update(attrs)
+
+        output_datasets.append(decom_ultra_dataset)
 
     return output_datasets

imap_processing/ultra/l1b/badtimes.py

@@ -11,7 +11,6 @@ def calculate_badtimes(
     extendedspin_dataset: xr.Dataset,
     cullingmask_spins: NDArray,
     name: str,
-    data_version: str,
 ) -> xr.Dataset:
     """
     Create dataset with defined datatypes for Badtimes Data.
@@ -24,8 +23,6 @@ def calculate_badtimes(
         Dataset containing the culled data.
     name : str
         Name of the dataset.
-    data_version : str
-        Version of the data.
 
     Returns
     -------
@@ -38,6 +35,6 @@ def calculate_badtimes(
 
     filtered_dataset = extendedspin_dataset.sel(spin_number=culled_spins)
 
-    badtimes_dataset = create_dataset(filtered_dataset, name, "l1b", data_version)
+    badtimes_dataset = create_dataset(filtered_dataset, name, "l1b")
 
     return badtimes_dataset

imap_processing/ultra/l1b/cullingmask.py

@@ -6,9 +6,7 @@ from imap_processing.quality_flags import ImapAttitudeUltraFlags, ImapRatesUltra
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 
-def calculate_cullingmask(
-    extendedspin_dataset: xr.Dataset, name: str, data_version: str
-) -> xr.Dataset:
+def calculate_cullingmask(extendedspin_dataset: xr.Dataset, name: str) -> xr.Dataset:
     """
     Create dataset with defined datatype for Culling Mask Data.
 
@@ -18,8 +16,6 @@ def calculate_cullingmask(
         Dataset containing the data.
     name : str
         Name of the dataset.
-    data_version : str
-        Version of the data.
 
     Returns
     -------
@@ -47,6 +43,6 @@ def calculate_cullingmask(
         spin_number=extendedspin_dataset["spin_number"][good_mask]
     )
 
-    cullingmask_dataset = create_dataset(filtered_dataset, name, "l1b", data_version)
+    cullingmask_dataset = create_dataset(filtered_dataset, name, "l1b")
 
     return cullingmask_dataset

imap_processing/ultra/l1b/de.py

@@ -20,6 +20,7 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
     get_eventtimes,
     get_front_x_position,
     get_front_y_position,
+    get_fwhm,
     get_path_length,
     get_ph_tof_and_back_positions,
     get_phi_theta,
@@ -28,8 +29,11 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
 )
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
+FILLVAL_UINT8 = 255
+FILLVAL_FLOAT32 = -1.0e31
 
-def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dataset:
+
+def calculate_de(de_dataset: xr.Dataset, name: str) -> xr.Dataset:
     """
     Create dataset with defined datatypes for Direct Event Data.
 
@@ -39,8 +43,6 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
         L1a dataset containing direct event data.
     name : str
         Name of the l1a dataset.
-    data_version : str
-        Version of the data.
 
     Returns
     -------
@@ -52,7 +54,7 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
 
     # Define epoch and spin.
     de_dict["epoch"] = de_dataset["epoch"].data
-    de_dict["spin"] = de_dataset["SPIN"].data
+    de_dict["spin"] = de_dataset["spin"].data
 
     # Add already populated fields.
     keys = [
@@ -64,61 +66,66 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
         "spin",
     ]
     dataset_keys = [
-        "COIN_TYPE",
-        "START_TYPE",
-        "STOP_TYPE",
-        "SHCOARSE",
-        "PHASE_ANGLE",
-        "SPIN",
+        "coin_type",
+        "start_type",
+        "stop_type",
+        "shcoarse",
+        "phase_angle",
+        "spin",
     ]
 
     de_dict.update(
         {key: de_dataset[dataset_key] for key, dataset_key in zip(keys, dataset_keys)}
     )
 
-    valid_mask = de_dataset["START_TYPE"].data != np.iinfo(np.int64).min
+    valid_mask = de_dataset["start_type"].data != FILLVAL_UINT8
     ph_mask = np.isin(
-        de_dataset["STOP_TYPE"].data, [StopType.Top.value, StopType.Bottom.value]
+        de_dataset["stop_type"].data, [StopType.Top.value, StopType.Bottom.value]
     )
-    ssd_mask = np.isin(de_dataset["STOP_TYPE"].data, [StopType.SSD.value])
+    ssd_mask = np.isin(de_dataset["stop_type"].data, [StopType.SSD.value])
 
     valid_indices = np.nonzero(valid_mask)[0]
     ph_indices = np.nonzero(valid_mask & ph_mask)[0]
     ssd_indices = np.nonzero(valid_mask & ssd_mask)[0]
 
     # Instantiate arrays
-    xf = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    yf = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    xb = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    yb = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    xc = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    d = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float64)
-    r = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    phi = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    theta = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    tof = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    etof = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    ctof = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    magnitude_v = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    energy = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    species_bin = np.full(len(de_dataset["epoch"]), "UNKNOWN", dtype="U10")
-    t2 = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    event_times = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float64)
-    spin_starts = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float64)
-    spin_period_sec = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float64)
+    xf = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    yf = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    xb = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    yb = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    xc = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    d = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float64)
+    r = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    phi = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    theta = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    tof = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    etof = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    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)
+    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.float64)
+    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)
 
     xf[valid_indices] = get_front_x_position(
-        de_dataset["START_TYPE"].data[valid_indices],
-        de_dataset["START_POS_TDC"].data[valid_indices],
+        de_dataset["start_type"].data[valid_indices],
+        de_dataset["start_pos_tdc"].data[valid_indices],
+        f"ultra{sensor}",
     )
+    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_dataset["PHASE_ANGLE"].data[valid_indices],
+        de_dataset["spin"].data[valid_indices],
+        de_dataset["phase_angle"].data[valid_indices],
     )
 
     # Pulse height
@@ -126,13 +133,14 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
         get_ph_tof_and_back_positions(de_dataset, xf, f"ultra{sensor}")
     )
     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]
     )
     energy[ph_indices] = get_energy_pulse_height(
-        de_dataset["STOP_TYPE"].data[ph_indices],
-        de_dataset["ENERGY_PH"].data[ph_indices],
+        de_dataset["stop_type"].data[ph_indices],
+        de_dataset["energy_ph"].data[ph_indices],
         xb[ph_indices],
         yb[ph_indices],
+        f"ultra{sensor}",
     )
     r[ph_indices] = get_path_length(
         (xf[ph_indices], yf[ph_indices]),
@@ -153,13 +161,15 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
     )
 
     # SSD
-    tof[ssd_indices] = get_ssd_tof(de_dataset, xf)
-    yb[ssd_indices], _, ssd_number = get_ssd_back_position_and_tof_offset(de_dataset)
+    tof[ssd_indices] = get_ssd_tof(de_dataset, xf, f"ultra{sensor}")
+    yb[ssd_indices], _, ssd_number = get_ssd_back_position_and_tof_offset(
+        de_dataset, f"ultra{sensor}"
+    )
     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]
     )
     energy[ssd_indices] = get_energy_ssd(de_dataset, ssd_number)
     r[ssd_indices] = get_path_length(
@@ -197,13 +207,15 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
     de_dict["phi"] = phi
     de_dict["theta"] = theta
 
-    v = get_de_velocity(
+    v, vhat, r = get_de_velocity(
         (de_dict["x_front"], de_dict["y_front"]),
         (de_dict["x_back"], de_dict["y_back"]),
         de_dict["front_back_distance"],
         de_dict["tof_start_stop"],
     )
     de_dict["direct_event_velocity"] = v.astype(np.float32)
+    de_dict["direct_event_unit_velocity"] = vhat.astype(np.float32)
+    de_dict["direct_event_unit_position"] = r.astype(np.float32)
 
     de_dict["tof_energy"] = get_de_energy_kev(v, species_bin)
     de_dict["energy"] = energy
@@ -226,11 +238,14 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
     de_dict["energy_spacecraft"] = get_de_energy_kev(sc_dps_velocity, species_bin)
     de_dict["energy_heliosphere"] = get_de_energy_kev(helio_velocity, species_bin)
 
-    # TODO: TBD.
-    de_dict["event_efficiency"] = np.full(
-        len(de_dataset["epoch"]), np.nan, dtype=np.float32
+    de_dict["phi_fwhm"], de_dict["theta_fwhm"] = get_fwhm(
+        start_type,
+        f"ultra{sensor}",
+        de_dict["tof_energy"],
+        de_dict["phi"],
+        de_dict["theta"],
     )
 
-    dataset = create_dataset(de_dict, name, "l1b", data_version)
+    dataset = create_dataset(de_dict, name, "l1b")
 
     return dataset

imap_processing/ultra/l1b/extendedspin.py

@@ -1,5 +1,6 @@
 """Calculate Extended Spin."""
 
+import numpy as np
 import xarray as xr
 
 from imap_processing.ultra.l1b.ultra_l1b_culling import (
@@ -13,7 +14,6 @@ from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 def calculate_extendedspin(
     dict_datasets: dict[str, xr.Dataset],
     name: str,
-    data_version: str,
     instrument_id: int,
 ) -> xr.Dataset:
     """
@@ -25,8 +25,6 @@ def calculate_extendedspin(
         Dictionary containing all the datasets.
     name : str
         Name of the dataset.
-    data_version : str
-        Version of the data.
     instrument_id : int
         Instrument ID.
 
@@ -49,8 +47,14 @@ def calculate_extendedspin(
     attitude_qf, spin_rates, spin_period, spin_starttime = flag_attitude(
         de_dataset["spin"].values, aux_dataset
     )
+    # 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]
 
     # These will be the coordinates.
+    extendedspin_dict["epoch"] = first_epochs
     extendedspin_dict["spin_number"] = spin
     extendedspin_dict["energy_bin_geometric_mean"] = energy_midpoints
 
@@ -62,6 +66,6 @@ def calculate_extendedspin(
     extendedspin_dict["quality_attitude"] = attitude_qf
     extendedspin_dict["quality_ena_rates"] = rates_qf
 
-    extendedspin_dataset = create_dataset(extendedspin_dict, name, "l1b", data_version)
+    extendedspin_dataset = create_dataset(extendedspin_dict, name, "l1b")
 
     return extendedspin_dataset