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

imap_processing/swe/l1b/swe_l1b.py

@@ -767,10 +767,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

@@ -80,4 +80,52 @@ class UltraConstants:
     CULLING_RPM_MAX = 6.0
 
     # Thresholds for culling based on counts.
-    CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [0, 10, 20, 1e5]
+    CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [
+        3.385,
+        4.13722222222222,
+        4.13722222222222,
+        5.05660493827161,
+        5.05660493827161,
+        6.18029492455419,
+        6.18029492455419,
+        7.55369379667734,
+        7.55369379667734,
+        9.23229241816119,
+        9.23229241816119,
+        11.2839129555303,
+        11.2839129555303,
+        13.7914491678704,
+        13.7914491678704,
+        16.8562156496194,
+        16.8562156496194,
+        20.6020413495348,
+        20.6020413495348,
+        25.1802727605426,
+        25.1802727605426,
+        30.775888929552,
+        30.775888929552,
+        37.6149753583414,
+        37.6149753583414,
+        45.9738587713061,
+        45.9738587713061,
+        56.1902718315964,
+        56.1902718315964,
+        68.6769989052845,
+        68.6769989052845,
+        83.93855421757,
+        83.93855421757,
+        102.591566265919,
+        102.591566265919,
+        125.38969210279,
+        125.38969210279,
+        153.254068125632,
+        153.254068125632,
+        187.310527709106,
+        187.310527709106,
+        228.93508942224,
+        228.93508942224,
+        279.809553738294,
+        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

@@ -10,15 +10,23 @@ class PacketProperties(NamedTuple):
     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, 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: 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).
+    image_planes: Union[int, None] = None
+    # number of images. See table 11 in the FSSD.
+    pixel_window_rows: Union[int, None] = None
+    # number of rows in each image. See table 49 in the FSSD.
+    pixel_window_columns: Union[int, None] = None
+    # number of columns in each image. See table 49 in the FSSD.
+    image_planes_per_packet: Union[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 +72,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

@@ -24,14 +24,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
 
@@ -87,6 +92,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 +114,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 QUALITY_FLAG_FILTERS
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset, extract_data_dict
 
 FILLVAL_UINT16 = 65535
@@ -32,14 +32,14 @@ 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 QUALITY_FLAG_FILTERS["quality_attitude"])
         )
         == 0
     ) & (
         (
             (
                 extendedspin_dataset["quality_ena_rates"]
-                & ImapRatesUltraFlags.HIGHRATES.value
+                & sum(flag.value for flag in QUALITY_FLAG_FILTERS["quality_ena_rates"])
             )
             == 0
         ).all(dim="energy_bin_geometric_mean")

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")