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

imap_processing/mag/l1d/mag_l1d_data.py

@@ -1,6 +1,7 @@
 # mypy: disable-error-code="unused-ignore"
 """Data classes for MAG L1D processing."""
 
+import logging
 from dataclasses import InitVar, dataclass
 
 import numpy as np
@@ -14,7 +15,9 @@ from imap_processing.mag.l2.mag_l2 import retrieve_matrix_from_l2_calibration
 from imap_processing.mag.l2.mag_l2_data import MagL2L1dBase, ValidFrames
 from imap_processing.spice import spin
 from imap_processing.spice.geometry import frame_transform
-from imap_processing.spice.time import ttj2000ns_to_met
+from imap_processing.spice.time import ttj2000ns_to_et, ttj2000ns_to_met
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -166,6 +169,9 @@ class MagL1d(MagL2L1dBase):  # type: ignore[misc]
             The day we are processing, in np.datetime64[D] format. This is used to
             truncate the data to exactly 24 hours.
         """
+        # The main data frame is MAGO, even though we have MAGI data included.
+        self.frame = ValidFrames.MAGO
+
         # set the magnitude before truncating
         self.magnitude = np.zeros(self.vectors.shape[0], dtype=np.float64)  # type: ignore[has-type]
         self.truncate_to_24h(day)
@@ -272,15 +278,42 @@ class MagL1d(MagL2L1dBase):  # type: ignore[misc]
         end_frame : ValidFrames
             The frame to rotate to. Should be one of the ValidFrames enum.
         """
+        # Self.frame should refer to the main data in self.vectors, which is MAGO
+        # data. For most frames, MAGO and MAGI are in the same frame, except the
+        # instrument reference frame.
+        if ValidFrames.MAGI in (self.frame, end_frame):
+            raise ValueError(
+                "MAGL1d.frame should never be equal to MAGI frame. If the "
+                "data is in the instrument frame, use MAGO."
+            )
+
         start_frame = self.frame
-        super().rotate_frame(end_frame)
+
+        if self.epoch_et is None:
+            self.epoch_et: np.ndarray = ttj2000ns_to_et(self.epoch)
+            self.magi_epoch_et: np.ndarray = ttj2000ns_to_et(self.magi_epoch)
+
+        self.vectors = frame_transform(
+            self.epoch_et,
+            self.vectors,
+            from_frame=start_frame.value,
+            to_frame=end_frame.value,
+        )
+
+        # If we were in MAGO frame, we need to rotate MAGI vectors from MAGI to
+        # end_frame
+        if start_frame == ValidFrames.MAGO:
+            start_frame = ValidFrames.MAGI
+
         self.magi_vectors = frame_transform(
-            self.magi_epoch,
+            self.magi_epoch_et,
             self.magi_vectors,
             from_frame=start_frame.value,
             to_frame=end_frame.value,
         )
 
+        self.frame = end_frame
+
     def _calibrate_and_offset_vectors(
         self,
         mago_calibration: np.ndarray,

imap_processing/mag/l2/mag_l2.py

@@ -90,6 +90,7 @@ def mag_l2(
     )
     # level 2 vectors don't include range
     vectors = cal_vectors[:, :3]
+    instrument_frame = ValidFrames.MAGO if always_output_mago else ValidFrames.MAGI
 
     l2_data = MagL2(
         vectors=vectors,
@@ -101,6 +102,7 @@ def mag_l2(
         data_mode=mode,
         offsets=offsets_dataset["offsets"].data,
         timedelta=offsets_dataset["timedeltas"].data,
+        frame=instrument_frame,
     )
 
     attributes = ImapCdfAttributes()

imap_processing/mag/l2/mag_l2_data.py

@@ -20,7 +20,8 @@ from imap_processing.spice.time import (
 class ValidFrames(Enum):
     """SPICE reference frames for output."""
 
-    MAG = SpiceFrame.IMAP_MAG
+    MAGO = SpiceFrame.IMAP_MAG_O
+    MAGI = SpiceFrame.IMAP_MAG_I
     DSRF = SpiceFrame.IMAP_DPS
     SRF = SpiceFrame.IMAP_SPACECRAFT
     GSE = SpiceFrame.IMAP_GSE
@@ -56,7 +57,7 @@ class MagL2L1dBase:
         Quality bitmask for each vector. Should be of length n. Copied from offset
         file in L2, marked as good always in L1D.
     frame:
-        The reference frame of the input vectors. Starts as the MAG instrument frame.
+        The reference frame of the input vectors. Defaults to the MAGO instrument frame.
     epoch_et: np.ndarray
         The epoch timestamps converted to ET format. Used for frame transformations.
         Calculated on first use and then saved. Should not be passed in.
@@ -70,7 +71,7 @@ class MagL2L1dBase:
     quality_bitmask: np.ndarray
     data_mode: DataMode
     magnitude: np.ndarray = field(init=False)
-    frame: ValidFrames = ValidFrames.MAG
+    frame: ValidFrames = ValidFrames.MAGO
     epoch_et: np.ndarray | None = field(init=False, default=None)
 
     def generate_dataset(

imap_processing/quality_flags.py

@@ -43,6 +43,7 @@ class ImapDEOutliersUltraFlags(FlagNameMixin):
     NONE = CommonFlags.NONE
     FOV = 2**0  # bit 0
     PHCORR = 2**1  # bit 1
+    COINPH = 2**2  # bit 4 # Event validity
 
 
 class ImapHkUltraFlags(FlagNameMixin):
@@ -83,6 +84,13 @@ class ImapDEScatteringUltraFlags(FlagNameMixin):
     NAN_PHI_OR_THETA = 2**1  # bit 1
 
 
+class ImapPSETUltraFlags(FlagNameMixin):
+    """IMAP Ultra Rates flags."""
+
+    NONE = CommonFlags.NONE
+    EARTH_FOV = 2**0  # bit 0
+
+
 class ImapInstrumentUltraFlags(FlagNameMixin):
     """IMAP Ultra flags using other instruments."""
 
@@ -131,3 +139,9 @@ class SWAPIFlags(
     SCEM_V_ST = 2**12  # bit 12
     SCEM_I_ST = 2**13  # bit 13
     SCEM_INT_ST = 2**14  # bit 14
+
+
+class GLOWSL1bFlags(FlagNameMixin):
+    """Glows L1b flags."""
+
+    NONE = CommonFlags.NONE

imap_processing/spice/geometry.py

@@ -21,7 +21,7 @@ from numpy.typing import NDArray
 class SpiceBody(IntEnum):
     """Enum containing SPICE IDs for bodies that we use."""
 
-    # A subset of IMAP Specific bodies as defined in imap_wkcp.tf
+    # A subset of IMAP Specific bodies as defined in imap_001.tf
     IMAP = -43
     IMAP_SPACECRAFT = -43000
     # IMAP Pointing Frame (Despun) as defined in imap_science_xxx.tf
@@ -33,7 +33,7 @@ class SpiceBody(IntEnum):
 
 
 class SpiceFrame(IntEnum):
-    """SPICE IDs for reference frames in imap_wkcp.tf and imap_science_xxx.tf."""
+    """SPICE IDs for reference frames in imap_###.tf and imap_science_xxx.tf."""
 
     # Standard SPICE Frames
     J2000 = spiceypy.irfnum("J2000")
@@ -41,7 +41,7 @@ class SpiceFrame(IntEnum):
     ITRF93 = 13000
     # IMAP Pointing Frame (Despun) as defined in imap_science_xxx.tf
     IMAP_DPS = -43901
-    # IMAP specific as defined in imap_wkcp.tf
+    # IMAP specific as defined in imap_###.tf
     IMAP_SPACECRAFT = -43000
     IMAP_LO_BASE = -43100
     IMAP_LO_STAR_SENSOR = -43103
@@ -50,13 +50,17 @@ class SpiceFrame(IntEnum):
     IMAP_HI_90 = -43160
     IMAP_ULTRA_45 = -43200
     IMAP_ULTRA_90 = -43210
-    IMAP_MAG = -43250
+    # TODO: remove IMAP_MAG frame once all usages have been removed
+    IMAP_MAG = -43999
+    IMAP_MAG_BOOM = -43250
+    IMAP_MAG_I = -43251
+    IMAP_MAG_O = -43252
     IMAP_SWE = -43300
     IMAP_SWAPI = -43350
     IMAP_CODICE = -43400
     IMAP_HIT = -43500
     IMAP_IDEX = -43700
-    IMAP_GLOWS = -43750
+    IMAP_GLOWS = -43751
 
     # IMAP Science Frames (new additions from imap_science_xxx.tf)
     IMAP_OMD = -43900
@@ -87,7 +91,8 @@ BORESIGHT_LOOKUP = {
     SpiceFrame.IMAP_HI_90: np.array([0, 1, 0]),
     SpiceFrame.IMAP_ULTRA_45: np.array([0, 0, 1]),
     SpiceFrame.IMAP_ULTRA_90: np.array([0, 0, 1]),
-    SpiceFrame.IMAP_MAG: np.array([0, 0, 1]),
+    SpiceFrame.IMAP_MAG_I: np.array([0, 0, 1]),
+    SpiceFrame.IMAP_MAG_O: np.array([0, 0, 1]),
     SpiceFrame.IMAP_SWE: np.array([-1, 0, 0]),
     SpiceFrame.IMAP_SWAPI: np.array([0, 1, 0]),
     SpiceFrame.IMAP_CODICE: np.array([0, 0, 1]),
@@ -162,7 +167,8 @@ def get_instrument_mounting_az_el(instrument: SpiceFrame) -> np.ndarray:
         SpiceFrame.IMAP_HI_90: np.array([0, 1, 0]),
         SpiceFrame.IMAP_ULTRA_45: np.array([0, 0, 1]),
         SpiceFrame.IMAP_ULTRA_90: np.array([0, 0, 1]),
-        SpiceFrame.IMAP_MAG: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_MAG_I: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_MAG_O: np.array([-1, 0, 0]),
         SpiceFrame.IMAP_SWE: np.array([-1, 0, 0]),
         SpiceFrame.IMAP_SWAPI: np.array([0, 0, -1]),
         SpiceFrame.IMAP_CODICE: np.array([-1, 0, 0]),
@@ -214,7 +220,8 @@ def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> fl
         SpiceFrame.IMAP_HIT: 120 / 360,  # 30 + 90 = 120
         SpiceFrame.IMAP_SWE: 243 / 360,  # 153 + 90 = 243
         SpiceFrame.IMAP_GLOWS: 217 / 360,  # 127 + 90 = 217
-        SpiceFrame.IMAP_MAG: 90 / 360,  # 0 + 90 = 90
+        SpiceFrame.IMAP_MAG_I: 90 / 360,  # 0 + 90 = 90
+        SpiceFrame.IMAP_MAG_O: 90 / 360,  # 0 + 90 = 90
     }
     return phase_offset_lookup[instrument]
 

imap_processing/spice/pointing_frame.py

@@ -195,7 +195,7 @@ def calculate_pointing_attitude_segments(
 
     - Latest NAIF leapseconds kernel (naif0012.tls)
     - The latest IMAP sclk (imap_sclk_NNNN.tsc)
-    - The latest IMAP frame kernel (imap_wkcp.tf)
+    - The latest IMAP frame kernel (imap_###.tf)
     - IMAP DPS frame kernel (imap_science_100.tf)
     - IMAP historical attitude kernel from which the pointing frame kernel will
     be generated.
@@ -210,7 +210,9 @@ def calculate_pointing_attitude_segments(
     count = spiceypy.ktotal("ck")
     loaded_ck_kernel, _, _, _ = spiceypy.kdata(count - 1, "ck")
     if str(ck_path) != loaded_ck_kernel:
-        raise ValueError(f"Error: Expected CK kernel {ck_path}")
+        raise ValueError(
+            f"Error: Expected CK kernel {ck_path} but loaded {loaded_ck_kernel}"
+        )
 
     id_imap_spacecraft = spiceypy.gipool("FRAME_IMAP_SPACECRAFT", 0, 1)
 

imap_processing/spice/repoint.py

@@ -9,6 +9,8 @@ import pandas as pd
 from numpy import typing as npt
 
 from imap_processing.spice import config
+from imap_processing.spice.geometry import imap_state
+from imap_processing.spice.time import met_to_sclkticks, sct_to_et
 
 logger = logging.getLogger(__name__)
 
@@ -221,3 +223,50 @@ def get_pointing_times(met_time: float) -> tuple[float, float]:
     ][0]
     pointing_end_met = repoint_df["repoint_start_met"].iloc[pointing_idx + 1].item()
     return pointing_start_met, pointing_end_met
+
+
+def get_pointing_mid_time(met_time: float) -> float:
+    """
+    Get mid-point of the pointing for the given MET time.
+
+    Get the mid-point time between the end of one repoint and
+    start of the next. Input could be a MET time.
+
+    Parameters
+    ----------
+    met_time : float
+        The MET time in a repoint.
+
+    Returns
+    -------
+    repoint_mid_time : float
+        The mid MET time of the repoint maneuver.
+    """
+    pointing_start_met, pointing_end_met = get_pointing_times(met_time)
+    return (pointing_start_met + pointing_end_met) / 2
+
+
+def get_mid_point_state(met_time: float) -> npt.NDArray:
+    """
+    Get IMAP state for the mid-point.
+
+    Get IMAP state for the mid-point of the pointing in
+    reference frame, ECLIPJ2000 and observer, SUN.
+
+    Parameters
+    ----------
+    met_time : float
+        The MET time in a pointing.
+
+    Returns
+    -------
+    mid_point_state : numpy.ndarray
+        The mid state of the pointing maneuver.
+    """
+    # Get mid point time in ET
+    mid_point_time = get_pointing_mid_time(met_time)
+    mid_point_time_et = sct_to_et(met_to_sclkticks(mid_point_time))
+
+    # Convert mid point time to state
+    pointing_state = imap_state(mid_point_time_et)
+    return pointing_state

imap_processing/ultra/constants.py

@@ -80,6 +80,14 @@ class UltraConstants:
 
     # Thresholds for culling based on counts (keV).
     CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [
+        3.0,
+        10.0,
+        20.0,
+        50.0,
+        300.0,
+        1e5,
+    ]
+    PSET_ENERGY_BIN_EDGES: ClassVar[list] = [
         3.385,
         4.13722222222222,
         5.05660493827161,
@@ -106,3 +114,24 @@ class UltraConstants:
         341.989454569026,
         1e5,
     ]
+
+    # Valid event filter constants
+    # Note these appear similar to image params constants
+    # but they should be used only for the valid event filter.
+    ETOFOFF1_EVENTFILTER = 100
+    ETOFOFF2_EVENTFILTER = -50
+    ETOFSLOPE1_EVENTFILTER = 6667
+    ETOFSLOPE2_EVENTFILTER = 7500
+    ETOFMAX_EVENTFILTER = 90
+    ETOFMIN_EVENTFILTER = -400
+    TOFDIFFTPMIN_EVENTFILTER = 226
+    TOFDIFFTPMAX_EVENTFILTER = 266
+
+    TOFXE_SPECIES_GROUPS: ClassVar[dict[str, list[int]]] = {
+        "proton": [3],
+        "non_proton": [20, 28, 36],
+    }
+    TOFXPH_SPECIES_GROUPS: ClassVar[dict[str, list[int]]] = {
+        "proton": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
+        "non_proton": [20, 21, 22, 23, 24, 25, 26],
+    }

imap_processing/ultra/l1b/badtimes.py

@@ -7,13 +7,14 @@ from numpy.typing import NDArray
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset, extract_data_dict
 
 FILLVAL_UINT16 = 65535
+FILLVAL_FLOAT32 = -1.0e31
 FILLVAL_FLOAT64 = -1.0e31
 FILLVAL_UINT32 = 4294967295
 
 
 def calculate_badtimes(
     extendedspin_dataset: xr.Dataset,
-    cullingmask_spins: NDArray,
+    goodtimes_spins: NDArray,
     name: str,
 ) -> xr.Dataset:
     """
@@ -23,7 +24,7 @@ def calculate_badtimes(
     ----------
     extendedspin_dataset : xarray.Dataset
         Dataset containing the data.
-    cullingmask_spins : np.ndarray
+    goodtimes_spins : np.ndarray
         Dataset containing the culled data.
     name : str
         Name of the dataset.
@@ -33,11 +34,9 @@ def calculate_badtimes(
     badtimes_dataset : xarray.Dataset
         Dataset containing the extendedspin data that has been culled.
     """
+    n_bins = extendedspin_dataset.dims["energy_bin_geometric_mean"]
     culled_spins = np.setdiff1d(
-        extendedspin_dataset["spin_number"].values, cullingmask_spins
-    )
-    extendedspin_dataset = extendedspin_dataset.assign_coords(
-        epoch=("spin_number", extendedspin_dataset["epoch"].values)
+        extendedspin_dataset["spin_number"].values, goodtimes_spins
     )
     filtered_dataset = extendedspin_dataset.sel(spin_number=culled_spins)
 
@@ -48,9 +47,6 @@ def calculate_badtimes(
     if badtimes_dataset["spin_number"].size == 0:
         badtimes_dataset = badtimes_dataset.drop_dims("spin_number")
         badtimes_dataset = badtimes_dataset.expand_dims(spin_number=[FILLVAL_UINT32])
-        badtimes_dataset = badtimes_dataset.assign_coords(
-            epoch=("spin_number", [extendedspin_dataset["epoch"].values[0]])
-        )
         badtimes_dataset["spin_start_time"] = xr.DataArray(
             np.array([FILLVAL_FLOAT64], dtype="float64"), dims=["spin_number"]
         )
@@ -60,16 +56,44 @@ def calculate_badtimes(
         badtimes_dataset["spin_rate"] = xr.DataArray(
             np.array([FILLVAL_FLOAT64], dtype="float64"), dims=["spin_number"]
         )
+        badtimes_dataset["start_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        badtimes_dataset["stop_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        badtimes_dataset["coin_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        badtimes_dataset["rejected_events_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_UINT32], dtype="uint32"),
+            dims=["spin_number"],
+        )
         badtimes_dataset["quality_attitude"] = xr.DataArray(
             np.array([FILLVAL_UINT16], dtype="uint16"), dims=["spin_number"]
         )
+        badtimes_dataset["quality_hk"] = xr.DataArray(
+            np.array([FILLVAL_UINT16], dtype="uint16"),
+            dims=["spin_number"],
+        )
+        badtimes_dataset["quality_instruments"] = xr.DataArray(
+            np.array([FILLVAL_UINT16], dtype="uint16"),
+            dims=["spin_number"],
+        )
         badtimes_dataset["quality_ena_rates"] = (
             ("energy_bin_geometric_mean", "spin_number"),
-            np.full((3, 1), FILLVAL_UINT16, dtype="uint16"),
+            np.full((n_bins, 1), FILLVAL_UINT16, dtype="uint16"),
         )
         badtimes_dataset["ena_rates"] = (
             ("energy_bin_geometric_mean", "spin_number"),
-            np.full((3, 1), FILLVAL_FLOAT64, dtype="float64"),
+            np.full((n_bins, 1), FILLVAL_FLOAT64, dtype="float64"),
+        )
+        badtimes_dataset["ena_rates_threshold"] = (
+            ("energy_bin_geometric_mean", "spin_number"),
+            np.full((n_bins, 1), FILLVAL_FLOAT32, dtype="float32"),
         )
 
     return badtimes_dataset

imap_processing/ultra/l1b/de.py

@@ -42,6 +42,7 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 FILLVAL_UINT8 = 255
+FILLVAL_UINT32 = 4294967295
 FILLVAL_FLOAT32 = -1.0e31
 
 
@@ -82,7 +83,6 @@ def calculate_de(
         "event_type",
         "de_event_met",
         "phase_angle",
-        "spin",
     ]
     dataset_keys = [
         "coin_type",
@@ -90,7 +90,6 @@ def calculate_de(
         "stop_type",
         "shcoarse",
         "phase_angle",
-        "spin",
     ]
 
     de_dict.update(
@@ -127,6 +126,7 @@ def calculate_de(
     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)
+    e_bin_l1a = 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)
@@ -143,6 +143,7 @@ def calculate_de(
     quality_flags = np.full(
         de_dataset["epoch"].shape, ImapDEOutliersUltraFlags.NONE.value, dtype=np.uint16
     )
+
     scattering_quality_flags = np.full(
         de_dataset["epoch"].shape,
         ImapDEScatteringUltraFlags.NONE.value,
@@ -196,7 +197,6 @@ def calculate_de(
         (xb[ph_indices], yb[ph_indices]),
         d[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],
@@ -213,8 +213,13 @@ def calculate_de(
         etof[ph_indices],
         xc[ph_indices],
         xb[ph_indices],
+        de_dataset["stop_north_tdc"][ph_indices].values,
+        de_dataset["stop_south_tdc"][ph_indices].values,
+        de_dataset["stop_east_tdc"][ph_indices].values,
+        de_dataset["stop_west_tdc"][ph_indices].values,
         f"ultra{sensor}",
         ancillary_files,
+        quality_flags[ph_indices],
     )
     e_bin[ph_indices] = determine_ebin_pulse_height(
         energy[ph_indices],
@@ -224,6 +229,7 @@ def calculate_de(
         coinphvalid,
         ancillary_files,
     )
+    species_bin[ph_indices] = determine_species(e_bin[ph_indices], "PH")
     ctof[ph_indices], magnitude_v[ph_indices] = get_ctof(
         tof[ph_indices], r[ph_indices], "PH"
     )
@@ -257,9 +263,7 @@ def calculate_de(
         f"ultra{sensor}",
         ancillary_files,
     )
-    species_bin[ssd_indices] = determine_species(
-        tof[ssd_indices], r[ssd_indices], "SSD"
-    )
+    species_bin[ssd_indices] = determine_species(e_bin[ssd_indices], "SSD")
     ctof[ssd_indices], magnitude_v[ssd_indices] = get_ctof(
         tof[ssd_indices], r[ssd_indices], "SSD"
     )
@@ -289,7 +293,6 @@ def calculate_de(
             de_dict["tof_start_stop"][valid_indices],
         )
     )
-    de_dict["direct_event_velocity"] = velocities.astype(np.float32)
     de_dict["direct_event_unit_velocity"] = v_hat.astype(np.float32)
     de_dict["direct_event_unit_position"] = r_hat.astype(np.float32)
 
@@ -298,7 +301,10 @@ def calculate_de(
     )
     de_dict["tof_energy"] = tof_energy
     de_dict["energy"] = energy
-    de_dict["ebin"] = e_bin
+    de_dict["computed_ebin"] = e_bin
+    valid_ebin = de_dataset["bin"].values != FILLVAL_UINT32
+    e_bin_l1a[valid_ebin] = de_dataset["bin"].values[valid_ebin]
+    de_dict["ebin"] = e_bin_l1a
     de_dict["species"] = species_bin
 
     # Annotated Events.
@@ -313,7 +319,7 @@ def calculate_de(
             helio_velocity[valid_events],
         ) = get_annotated_particle_velocity(
             event_times[valid_events],
-            de_dict["direct_event_velocity"][valid_events],
+            velocities.astype(np.float32)[valid_events],
             ultra_frame,
             SpiceFrame.IMAP_DPS,
             SpiceFrame.IMAP_SPACECRAFT,

imap_processing/ultra/l1b/extendedspin.py

@@ -2,6 +2,7 @@
 
 import numpy as np
 import xarray as xr
+from numpy.typing import NDArray
 
 from imap_processing.ultra.l1b.ultra_l1b_culling import (
     count_rejected_events_per_spin,
@@ -15,6 +16,7 @@ from imap_processing.ultra.l1b.ultra_l1b_culling import (
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 FILLVAL_UINT16 = 65535
+FILLVAL_FLOAT32 = -1.0e31
 
 
 def calculate_extendedspin(
@@ -44,7 +46,7 @@ def calculate_extendedspin(
     de_dataset = dict_datasets[f"imap_ultra_l1b_{instrument_id}sensor-de"]
 
     extendedspin_dict = {}
-    rates_qf, spin, energy_midpoints, n_sigma_per_energy = flag_rates(
+    rates_qf, spin, energy_bin_geometric_mean, n_sigma_per_energy = flag_rates(
         de_dataset["spin"].values,
         de_dataset["energy"].values,
     )
@@ -58,12 +60,6 @@ def calculate_extendedspin(
     hk_qf = flag_hk(de_dataset["spin"].values)
     inst_qf = flag_imap_instruments(de_dataset["spin"].values)
 
-    # Get the first epoch for each spin.
-    mask = xr.DataArray(np.isin(de_dataset["spin"], spin), dims="epoch")
-    filtered_dataset = de_dataset.where(mask, drop=True)
-    _, first_indices = np.unique(filtered_dataset["spin"].values, return_index=True)
-    first_epochs = filtered_dataset["epoch"].values[first_indices]
-
     # Get the number of pulses per spin.
     pulses = get_pulses_per_spin(rates_dataset)
 
@@ -75,18 +71,34 @@ def calculate_extendedspin(
         de_dataset["quality_outliers"].values,
     )
     # These will be the coordinates.
-    extendedspin_dict["epoch"] = first_epochs
     extendedspin_dict["spin_number"] = spin
-    extendedspin_dict["energy_bin_geometric_mean"] = energy_midpoints
+    extendedspin_dict["energy_bin_geometric_mean"] = energy_bin_geometric_mean
 
     extendedspin_dict["ena_rates"] = count_rates
     extendedspin_dict["ena_rates_threshold"] = n_sigma_per_energy
     extendedspin_dict["spin_start_time"] = spin_starttime
     extendedspin_dict["spin_period"] = spin_period
     extendedspin_dict["spin_rate"] = spin_rates
-    extendedspin_dict["start_pulses_per_spin"] = pulses.start_per_spin
-    extendedspin_dict["stop_pulses_per_spin"] = pulses.stop_per_spin
-    extendedspin_dict["coin_pulses_per_spin"] = pulses.coin_per_spin
+
+    # Get index of pulses.unique_spins corresponding to each spin.
+    idx: NDArray[np.intp] = np.searchsorted(pulses.unique_spins, spin)
+
+    # Validate that the spin values match
+    valid = (idx < pulses.unique_spins.size) & (pulses.unique_spins[idx] == spin)
+
+    start_per_spin = np.full(len(spin), FILLVAL_FLOAT32, dtype=np.float32)
+    stop_per_spin = np.full(len(spin), FILLVAL_FLOAT32, dtype=np.float32)
+    coin_per_spin = np.full(len(spin), FILLVAL_FLOAT32, dtype=np.float32)
+
+    # Fill only the valid ones
+    start_per_spin[valid] = pulses.start_per_spin[idx[valid]]
+    stop_per_spin[valid] = pulses.stop_per_spin[idx[valid]]
+    coin_per_spin[valid] = pulses.coin_per_spin[idx[valid]]
+
+    # account for rates spins which are not in the direct event spins
+    extendedspin_dict["start_pulses_per_spin"] = start_per_spin
+    extendedspin_dict["stop_pulses_per_spin"] = stop_per_spin
+    extendedspin_dict["coin_pulses_per_spin"] = coin_per_spin
     extendedspin_dict["rejected_events_per_spin"] = rejected_counts
     extendedspin_dict["quality_attitude"] = attitude_qf
     extendedspin_dict["quality_ena_rates"] = rates_qf