imap-processing 0.19.0__py3-none-any.whl → 0.19.3__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,15 @@ class SpiceFrame(IntEnum):
     IMAP_HI_90 = -43160
     IMAP_ULTRA_45 = -43200
     IMAP_ULTRA_90 = -43210
-    IMAP_MAG = -43250
+    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 +89,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 +165,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 +218,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/l0/decom_tools.py

@@ -157,6 +157,7 @@ def decompress_image(
     pixel0: int,
     binary_data: str,
     packet_props: PacketProperties,
+    planes_per_packet: int = 1,
 ) -> NDArray:
     """
     Will decompress a binary string representing an image into a matrix of pixel values.
@@ -174,11 +175,15 @@ def decompress_image(
     packet_props : PacketProperties
         Properties of the packet, including width bit, mantissa bit length and pixel
         window dimensions.
+    planes_per_packet : int
+        Number of image planes in the packet. Default is 1.
 
     Returns
     -------
-    p_decom : NDArray
-        A 2D numpy array representing pixel values.
+    planes : NDArray
+        A 3D numpy array representing pixel values.
+        The last two dimensions correspond to the image dimensions, and the first
+        is the number of image planes.
         Each pixel is stored as an unsigned 16-bit integer (uint16).
 
     Notes
@@ -199,51 +204,58 @@ def decompress_image(
         )
 
     blocks_per_row = cols // pixels_per_block
-
-    # Compressed pixel matrix
-    p = np.zeros((rows, cols), dtype=np.uint16)
-    # Decompressed pixel matrix
-    p_decom = np.zeros((rows, cols), dtype=np.int16)
-
+    current_pixel0 = pixel0  # Use the parameter for first plane
+    planes = []
+    plane_num = 0
     pos = 0  # Starting position in the binary string
-
-    for i in range(rows):
-        for j in range(blocks_per_row):
-            # Read the width for the block.
-            w, pos = read_and_advance(binary_data, width_bit, pos)
-            for k in range(pixels_per_block):
-                # Handle the special case in which the width is 0
-                if w == 0:
-                    value = 0
-                else:
-                    # Find the value of each pixel in the block
-                    value, pos = read_and_advance(binary_data, w, pos)
-
-                # if the least significant bit of value is set (odd)
-                if value & 0x01:
-                    # value >> 1: shifts bits of value one place to the right
-                    # ~: bitwise NOT operator (flips bits)
-                    delta_f = ~(value >> 1)
-                else:
-                    delta_f = value >> 1
-
-                # Calculate the new pixel value and update pixel0
-                column_index = j * pixels_per_block + k
-                # 0xff is the hexadecimal representation of the number 255,
-                # Keeps only the last 8 bits of the result of pixel0 - delta_f
-                # This operation ensures that the result is within the range
-                # of an 8-bit byte (0-255)
-                # Use np.int16 for the arithmetic operation to avoid overflow
-                # Then implicitly cast back to the p's uint16 dtype for storage
-                p[i][column_index] = np.int16(pixel0) - delta_f
-                # Perform logarithmic decompression on the pixel value
-                p_decom[i][column_index] = log_decompression(
-                    p[i][column_index], mantissa_bit_length
-                )
-                pixel0 = p[i][column_index]
-        pixel0 = p[i][0]
-
-    return p_decom
+    while plane_num < planes_per_packet:
+        # Compressed pixel matrix
+        p = np.zeros((rows, cols), dtype=np.uint16)
+        # Decompressed pixel matrix
+        p_decom = np.zeros((rows, cols), dtype=np.int16)
+
+        for i in range(rows):
+            for j in range(blocks_per_row):
+                # Read the width for the block.
+                w, pos = read_and_advance(binary_data, width_bit, pos)
+                for k in range(pixels_per_block):
+                    # Handle the special case in which the width is 0
+                    if w == 0:
+                        value = 0
+                    else:
+                        # Find the value of each pixel in the block
+                        value, pos = read_and_advance(binary_data, w, pos)
+
+                    # if the least significant bit of value is set (odd)
+                    if value & 0x01:
+                        # value >> 1: shifts bits of value one place to the right
+                        # ~: bitwise NOT operator (flips bits)
+                        delta_f = ~(value >> 1)
+                    else:
+                        delta_f = value >> 1
+
+                    # Calculate the new pixel value and update pixel0
+                    column_index = j * pixels_per_block + k
+                    # 0xff is the hexadecimal representation of the number 255,
+                    # Keeps only the last 8 bits of the result of pixel0 - delta_f
+                    # This operation ensures that the result is within the range
+                    # of an 8-bit byte (0-255)
+                    # Use np.int16 for the arithmetic operation to avoid overflow
+                    # Then implicitly cast back to the p's uint16 dtype for storage
+                    p[i][column_index] = np.int16(current_pixel0) - delta_f
+                    # Perform logarithmic decompression on the pixel value
+                    p_decom[i][column_index] = log_decompression(
+                        p[i][column_index], mantissa_bit_length
+                    )
+                    current_pixel0 = p[i][column_index]
+            current_pixel0 = p[i][0]
+        planes.append(p_decom)
+        plane_num += 1
+        # Read P00 for the next plane (if not the last plane)
+        if plane_num < planes_per_packet:
+            current_pixel0, pos = read_and_advance(binary_data, 8, pos)
+
+    return np.stack(planes)
 
 
 def read_image_raw_events_binary(

imap_processing/ultra/l0/decom_ultra.py

@@ -81,54 +81,66 @@ def process_ultra_tof(ds: xr.Dataset, packet_props: PacketProperties) -> xr.Data
     decom_data: defaultdict[str, list[np.ndarray]] = defaultdict(list)
     decom_data["packetdata"] = []
     valid_epoch = []
-
     for val, group in ds.groupby("epoch"):
         if set(group["sid"].values) >= set(
             np.arange(0, image_planes, planes_per_packet)
         ):
+            plane_count = 0
             valid_epoch.append(val)
             group.sortby("sid")
 
             for key in scalar_keys:
-                decom_data[key].append(group[key].values)
+                # Repeat the scalar values for each image plane. There may be cases
+                # where the last packet has fewer planes than the planes_per_packet, so
+                # we slice to ensure the correct length.
+                decom_data[key].append(
+                    np.tile(group[key].values, planes_per_packet)[:image_planes]
+                )
 
             image = []
             for i in range(num_image_packets):
                 binary = convert_to_binary_string(group["packetdata"].values[i])
+                # Determine how many planes to decompress in this packet.
+                # the last packet might have fewer planes than planes_per_packet.
+                # Take the minimum of the remaining planes or the max planes per packet
+                # value.
+                planes_in_packet = min(image_planes - plane_count, planes_per_packet)
                 decompressed = decompress_image(
                     group["p00"].values[i],
                     binary,
                     packet_props,
+                    planes_in_packet,
                 )
                 image.append(decompressed)
+                plane_count += planes_in_packet
 
-            decom_data["packetdata"].append(np.stack(image))
+            decom_data["packetdata"].append(np.concatenate(image, axis=0))
 
     for key in scalar_keys:
-        decom_data[key] = np.stack(decom_data[key])
+        decom_data[key] = np.stack(decom_data[key], axis=0)
 
-    decom_data["packetdata"] = np.stack(decom_data["packetdata"])
+    decom_data["packetdata"] = np.stack(decom_data["packetdata"], axis=0)
 
     coords = {
         "epoch": np.array(valid_epoch, dtype=np.uint64),
-        "sid": xr.DataArray(np.arange(num_image_packets), dims=["sid"], name="sid"),
+        "plane": xr.DataArray(np.arange(image_planes), dims=["plane"], name="plane"),
         "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)
 
-    # Add scalar keys (2D: epoch x sid)
+    # Add scalar keys (2D: epoch x packets)
     for key in scalar_keys:
         dataset[key] = xr.DataArray(
             decom_data[key],
-            dims=["epoch", "sid"],
+            dims=["epoch", "plane"],
         )
 
     # Add PACKETDATA (4D: epoch x sid x row x column)
     dataset["packetdata"] = xr.DataArray(
         decom_data["packetdata"],
-        dims=["epoch", "sid", "row", "column"],
+        dims=["epoch", "plane", "row", "column"],
     )
 
     return dataset

imap_processing/ultra/l0/ultra_utils.py

@@ -137,8 +137,8 @@ ULTRA_EXTOF_HIGH_ANGULAR = PacketProperties(
 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",
+        "imap_ultra_l1a_45sensor-histogram-ion-extof-hi-time",
+        "imap_ultra_l1a_90sensor-histogram-ion-extof-hi-time",
     ],
     addition_to_logical_desc="Energy By Time of Flight High Time Images",
     width=4,
@@ -153,8 +153,8 @@ ULTRA_EXTOF_HIGH_TIME = PacketProperties(
 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",
+        "imap_ultra_l1a_45sensor-histogram-ion-extof-hi-nrg",
+        "imap_ultra_l1a_90sensor-histogram-ion-extof-hi-nrg",
     ],
     addition_to_logical_desc="Energy By Time of Flight High Energy Images",
     width=4,

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