imap-processing 0.19.2__tar.gz → 0.19.3__tar.gz

{imap_processing-0.19.2 → imap_processing-0.19.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imap-processing
-Version: 0.19.2
+Version: 0.19.3
 Summary: IMAP Science Operations Center Processing
 License: MIT
 Keywords: IMAP,SDC,SOC,Science Operations
@@ -30,7 +30,7 @@ Provides-Extra: tools
 Requires-Dist: astropy-healpix (>=1.0)
 Requires-Dist: cdflib (>=1.3.6,<2.0.0)
 Requires-Dist: healpy (>=1.18.0,<2.0.0) ; extra == "map-visualization"
-Requires-Dist: imap-data-access (>=0.32.0)
+Requires-Dist: imap-data-access (>=0.35.0)
 Requires-Dist: mypy (==1.10.1) ; extra == "dev"
 Requires-Dist: netcdf4 (>=1.7.2,<2.0.0) ; extra == "test"
 Requires-Dist: numpy (<=3)

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/_version.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced later during substitution.
-__version__ = "0.19.2"
-__version_tuple__ = (0, 19, 2)
+__version__ = "0.19.3"
+__version_tuple__ = (0, 19, 3)

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/cdf/config/imap_enamaps_l2-common_variable_attrs.yaml

@@ -207,6 +207,50 @@ exposure_factor: &exposure_factor
   DISPLAY_TYPE: no_plot
   DICT_KEY: SPASE>TemporalDescription:Exposure,Qualifier:Directional,CoordinateSystemName:HAE,CoordinateRepresentation:Spherical
 
+geometric_function:
+  <<: *default_float32
+  CATDESC: The geometric function calculated from multiple pointing sets.
+  FIELDNAM: geometric_function
+  UNITS: cm^2 sr
+  DEPEND_0: epoch
+  VAR_TYPE: data
+  LABLAXIS: Geometric Factor
+  DISPLAY_TYPE: no_plot
+  DICT_KEY: SPASE>Particle>ParticleType:Atom,ParticleQuantity:GeometricFactor,Qualifier:Directional,CoordinateSystemName:HAE,CoordinateRepresentation:Spherical
+
+efficiency:
+  <<: *default_float32
+  CATDESC: Event efficiency calculated from multiple pointing sets.
+  FIELDNAM: efficiency
+  UNITS: " "
+  DEPEND_0: epoch
+  VAR_TYPE: data
+  LABLAXIS: Efficiency
+  DISPLAY_TYPE: no_plot
+  DICT_KEY: SPASE>Particle>ParticleType:Atom,ParticleQuantity:Other
+
+positional_uncert_theta:
+  <<: *default_float32
+  CATDESC: Positional uncertainty in theta direction calculated from multiple pointing sets.
+  FIELDNAM: positional_uncertainty_theta
+  UNITS: degrees
+  DEPEND_0: epoch
+  VAR_TYPE: data
+  LABLAXIS: Position Uncertainty Theta
+  DISPLAY_TYPE: no_plot
+  DICT_KEY: SPASE>Particle>ParticleType:Atom,ParticleQuantity:ArrivalDirection,Qualifier:Uncertainty,CoordinateSystemName:HAE,CoordinateRepresentation:Spherical
+
+positional_uncert_phi:
+  <<: *default_float32
+  CATDESC: Positional uncertainty in phi direction calculated from multiple pointing sets.
+  FIELDNAM: positional_uncertainty_phi
+  UNITS: degrees
+  DEPEND_0: epoch
+  VAR_TYPE: data
+  LABLAXIS: Position Uncertainty Phi
+  DISPLAY_TYPE: no_plot
+  DICT_KEY: SPASE>Particle>ParticleType:Atom,ParticleQuantity:ArrivalDirection,Qualifier:Uncertainty,CoordinateSystemName:HAE,CoordinateRepresentation:Spherical
+
 obs_date: &obs_date
   <<: *default_int64
   datatype: int64

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/cdf/config/imap_enamaps_l2-healpix_variable_attrs.yaml

@@ -72,6 +72,29 @@ sensitivity:
   LABL_PTR_1: energy_label
   LABL_PTR_2: pixel_index_label
 
+efficiency:
+  DEPEND_1: energy
+  DEPEND_2: pixel_index
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: pixel_index_label
+
+geometric_function:
+  DEPEND_1: energy
+  DEPEND_2: pixel_index
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: pixel_index_label
+
+positional_uncert_theta:
+  DEPEND_1: energy
+  DEPEND_2: pixel_index
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: pixel_index_label
+
+positional_uncert_phi:
+  DEPEND_1: energy
+  DEPEND_2: pixel_index
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: pixel_index_label
 # These data variables will have an extra (energy) dimension
 # only if the energy dimension is present in the L1C data.
 # The default is energy-independent.
@@ -99,6 +122,12 @@ obs_date:
   LABL_PTR_1: energy_label
   LABL_PTR_2: pixel_index_label
 
+obs_date_range:
+  DEPEND_1: energy
+  DEPEND_2: pixel_index
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: pixel_index_label
+
 solid_angle:
   DEPEND_1: pixel_index
   LABL_PTR_1: pixel_index_label

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/cdf/config/imap_enamaps_l2-rectangular_variable_attrs.yaml

@@ -134,6 +134,38 @@ exposure_factor:
   LABL_PTR_2: longitude_label
   LABL_PTR_3: latitude_label
 
+efficiency:
+  DEPEND_1: energy
+  DEPEND_2: longitude
+  DEPEND_3: latitude
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: longitude_label
+  LABL_PTR_3: latitude_label
+
+geometric_function:
+  DEPEND_1: energy
+  DEPEND_2: longitude
+  DEPEND_3: latitude
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: longitude_label
+  LABL_PTR_3: latitude_label
+
+positional_uncert_theta:
+  DEPEND_1: energy
+  DEPEND_2: longitude
+  DEPEND_3: latitude
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: longitude_label
+  LABL_PTR_3: latitude_label
+
+positional_uncert_phi:
+  DEPEND_1: energy
+  DEPEND_2: longitude
+  DEPEND_3: latitude
+  LABL_PTR_1: energy_label
+  LABL_PTR_2: longitude_label
+  LABL_PTR_3: latitude_label
+
 obs_date:
   DEPEND_1: energy
   DEPEND_2: longitude

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/cdf/config/imap_ultra_global_cdf_attrs.yaml

@@ -68,28 +68,28 @@ imap_ultra_l1a_90sensor-histogram-ena-extof-hi-ang:
     Logical_source: imap_ultra_l1a_90sensor-histogram-ena-extof-hi-ang
     Logical_source_description: IMAP-Ultra Instrument Level-1A ExTOF Hi Angular Data.
 
-imap_ultra_l1a_45sensor-histogram-ena-extof-hi-time:
+imap_ultra_l1a_45sensor-histogram-ion-extof-hi-time:
     <<: *instrument_base
     Data_type: L1A_Histogram>Level-1A ExTOF
-    Logical_source: imap_ultra_l1a_45sensor-histogram-ena-extof-hi-time
+    Logical_source: imap_ultra_l1a_45sensor-histogram-ion-extof-hi-time
     Logical_source_description: IMAP-Ultra Instrument Level-1A ExTOF Hi Time Data.
 
-imap_ultra_l1a_90sensor-histogram-ena-extof-hi-time:
+imap_ultra_l1a_90sensor-histogram-ion-extof-hi-time:
     <<: *instrument_base
     Data_type: L1A_Histogram>Level-1A ExTOF
-    Logical_source: imap_ultra_l1a_90sensor-histogram-ena-extof-hi-time
+    Logical_source: imap_ultra_l1a_90sensor-histogram-ion-extof-hi-time
     Logical_source_description: IMAP-Ultra Instrument Level-1A ExTOF Hi Time Data.
 
-imap_ultra_l1a_45sensor-histogram-ena-extof-hi-nrg:
+imap_ultra_l1a_45sensor-histogram-ion-extof-hi-nrg:
     <<: *instrument_base
     Data_type: L1A_Histogram>Level-1A ExTOF
-    Logical_source: imap_ultra_l1a_45sensor-histogram-ena-extof-hi-nrg
+    Logical_source: imap_ultra_l1a_45sensor-histogram-ion-extof-hi-nrg
     Logical_source_description: IMAP-Ultra Instrument Level-1A ExTOF Hi Energy Data.
 
-imap_ultra_l1a_90sensor-histogram-ena-extof-hi-nrg:
+imap_ultra_l1a_90sensor-histogram-ion-extof-hi-nrg:
     <<: *instrument_base
     Data_type: L1A_Histogram>Level-1A ExTOF
-    Logical_source: imap_ultra_l1a_90sensor-histogram-ena-extof-hi-nrg
+    Logical_source: imap_ultra_l1a_90sensor-histogram-ion-extof-hi-nrg
     Logical_source_description: IMAP-Ultra Instrument Level-1A ExTOF Hi Energy Data.
 
 imap_ultra_l1a_45sensor-rates:

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/ialirt/l0/ialirt_spice.py

@@ -133,8 +133,7 @@ def transform_instrument_vectors_to_inertial(
     spin_phase: NDArray,
     sc_inertial_right: NDArray,
     sc_inertial_decline: NDArray,
-    # TODO: Use correct IMAP_MAG_I or IMAP_MAG_O frame here
-    instrument_frame: SpiceFrame = SpiceFrame.IMAP_MAG,
+    instrument_frame: SpiceFrame,
     spacecraft_frame: SpiceFrame = SpiceFrame.IMAP_SPACECRAFT,
 ) -> NDArray:
     """

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/ialirt/l0/parse_mag.py

@@ -268,6 +268,9 @@ def calculate_l1b(
         retrieve_matrix_from_single_l1b_calibration(calibration_dataset, is_mago=False)
     )
 
+    logger.info(f"calibration_matrix_mago shape: {calibration_matrix_mago.shape}.")
+    logger.info(f"calibration_matrix_magi shape: {calibration_matrix_magi.shape}.")
+
     # Get time values for each group.
     time_data = get_time(
         grouped_data, group, pkt_counter, time_shift_mago, time_shift_magi
@@ -392,6 +395,7 @@ def transform_to_inertial(
     attitude_time: np.ndarray,
     target_time: float,
     mag_vector: np.ndarray,
+    instrument_frame: SpiceFrame,
 ) -> np.ndarray:
     """
     Transform vector to ECLIPJ2000.
@@ -415,6 +419,8 @@ def transform_to_inertial(
         Example: time_data['primary_epoch'].
     mag_vector : numpy.ndarray
         Vector, shape (3).
+    instrument_frame : SpiceFrame
+        SPICE frame of the instrument.
 
     Returns
     -------
@@ -478,6 +484,7 @@ def transform_to_inertial(
         np.array([spin_phase_deg]),
         np.array([ra_deg]),
         np.array([dec_deg]),
+        instrument_frame,
     )[0]
 
     return inertial_vector
@@ -570,6 +577,7 @@ def process_packet(
     mago_times_all = []
     magi_vectors_all = []
     magi_times_all = []
+    incomplete_groups = []
 
     for group in unique_groups:
         # Get status values for each group.
@@ -581,10 +589,7 @@ def process_packet(
         ]
 
         if not np.array_equal(pkt_counter, np.arange(4)):
-            logger.info(
-                f"Group {group} does not contain all values from 0 to "
-                f"3 without duplicates."
-            )
+            incomplete_groups.append(group)
             continue
 
         # Get decoded status data.
@@ -648,6 +653,7 @@ def process_packet(
             attitude_time,
             time_data["primary_epoch"],
             mago_out,
+            SpiceFrame.IMAP_MAG_O,
         )
         magi_inertial_vector = transform_to_inertial(
             sc_spin_phase_rad.values,
@@ -656,6 +662,7 @@ def process_packet(
             attitude_time,
             time_data["secondary_epoch"],
             magi_out,
+            SpiceFrame.IMAP_MAG_I,
         )
 
         met = grouped_data["met"][(grouped_data["group"] == group).values]
@@ -665,6 +672,13 @@ def process_packet(
         magi_vectors_all.append(magi_inertial_vector)
         magi_times_all.append(time_data["secondary_epoch"])
 
+    if incomplete_groups:
+        logger.info(
+            f"The following mag groups were skipped due to "
+            f"missing or duplicate pkt_counter values: "
+            f"{incomplete_groups}"
+        )
+
     mago_corrected, magnitude = apply_gradiometry_correction(
         np.array(mago_vectors_all),
         np.array(mago_times_all),

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/ialirt/l0/process_hit.py

@@ -127,6 +127,7 @@ def process_hit(xarray_data: xr.Dataset) -> list[dict]:
         Dictionary final data product.
     """
     hit_data = []
+    incomplete_groups = []
 
     # Subsecond time conversion specified in 7516-9054 GSW-FSW ICD.
     # Value of SCLK subseconds, unsigned, (LSB = 1/256 sec)
@@ -148,10 +149,7 @@ def process_hit(xarray_data: xr.Dataset) -> list[dict]:
 
         # Ensure no duplicates and all values from 0 to 59 are present
         if not np.array_equal(subcom_values, np.arange(60)):
-            logger.warning(
-                f"Group {group} does not contain all values from 0 to "
-                f"59 without duplicates."
-            )
+            incomplete_groups.append(group)
             continue
 
         fast_rate_1 = grouped_data["hit_fast_rate_1"][
@@ -187,4 +185,11 @@ def process_hit(xarray_data: xr.Dataset) -> list[dict]:
             }
         )
 
+    if incomplete_groups:
+        logger.info(
+            f"The following hit groups were skipped due to "
+            f"missing or duplicate pkt_counter values: "
+            f"{incomplete_groups}"
+        )
+
     return hit_data

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/ialirt/l0/process_swapi.py

@@ -158,6 +158,7 @@ def process_swapi_ialirt(
     # Add required parameters.
     sci_dataset["met"] = met
     met_values = []
+    incomplete_groups = []
 
     grouped_dataset = find_groups(sci_dataset, (0, 11), "swapi_seq_number", "met")
 
@@ -179,12 +180,16 @@ def process_swapi_ialirt(
 
         # Ensure no duplicates and all values from 0 to 11 are present
         if not np.array_equal(seq_values.astype(int), np.arange(12)):
-            logger.info(
-                f"SWAPI group {group} does not contain all sequence values from 0 to "
-                f"11 without duplicates."
-            )
+            incomplete_groups.append(group)
             continue
 
+    if incomplete_groups:
+        logger.info(
+            f"The following swapi groups were skipped due to "
+            f"missing or duplicate pkt_counter values: "
+            f"{incomplete_groups}"
+        )
+
     raw_coin_count = process_sweep_data(grouped_dataset, "swapi_coin_cnt")
     raw_coin_rate = raw_coin_count / SWAPI_LIVETIME
     count_rate_error = np.sqrt(raw_coin_count) / SWAPI_LIVETIME

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/ialirt/l0/process_swe.py

@@ -478,6 +478,7 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
     grouped_data = find_groups(accumulated_data, (0, 59), "swe_seq", "time_seconds")
     unique_groups = np.unique(grouped_data["group"])
     swe_data: list[dict] = []
+    incomplete_groups = []
 
     for group in unique_groups:
         # Sequence values for the group should be 0-59 with no duplicates.
@@ -485,10 +486,7 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
 
         # Ensure no duplicates and all values from 0 to 59 are present
         if not np.array_equal(seq_values, np.arange(60)):
-            logger.info(
-                f"Group {group} does not contain all values from 0 to "
-                f"59 without duplicates."
-            )
+            incomplete_groups.append(group)
             continue
         # Prepare raw counts array just for this group
         # (8 energy steps, 7 CEMs, 30 phi bins)
@@ -570,4 +568,11 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
             },
         )
 
+    if incomplete_groups:
+        logger.info(
+            f"The following swe groups were skipped due to "
+            f"missing or duplicate pkt_counter values: "
+            f"{incomplete_groups}"
+        )
+
     return swe_data

{imap_processing-0.19.2 → imap_processing-0.19.3}/imap_processing/spice/geometry.py

@@ -50,8 +50,6 @@ class SpiceFrame(IntEnum):
     IMAP_HI_90 = -43160
     IMAP_ULTRA_45 = -43200
     IMAP_ULTRA_90 = -43210
-    # 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_processing-0.19.2 → imap_processing-0.19.3}/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-0.19.2 → imap_processing-0.19.3}/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-0.19.2 → imap_processing-0.19.3}/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,