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

imap_processing/glows/l1b/glows_l1b_data.py

@@ -4,12 +4,227 @@ import dataclasses
 import json
 from dataclasses import InitVar, dataclass, field
 from pathlib import Path
-from typing import Optional
 
 import numpy as np
+import xarray as xr
+from scipy.stats import circmean, circstd
 
 from imap_processing.glows import FLAG_LENGTH
 from imap_processing.glows.utils.constants import TimeTuple
+from imap_processing.spice import geometry
+from imap_processing.spice.geometry import SpiceBody, SpiceFrame
+from imap_processing.spice.spin import (
+    get_instrument_spin_phase,
+    get_spin_angle,
+    get_spin_data,
+)
+from imap_processing.spice.time import met_to_datetime64, met_to_sclkticks, sct_to_et
+
+
+@dataclass
+class PipelineSettings:  # numpydoc ignore=PR02
+    """
+    GLOWS L1B Pipeline Settings for controlling bad-angle and bad-time flag processing.
+
+    This class extracts pipeline settings from the JSON configuration file processed
+    through GlowsAncillaryCombiner.
+
+    Based on Section 3.12 of the GLOWS algorithm document, the pipeline settings
+    file contains parameters for the ground-processing pipeline including thresholds,
+    bad-time flags to be activated, bad-angle flags to be activated, and other
+    processing controls.
+
+    Parameters
+    ----------
+    pipeline_dataset : xr.Dataset
+        Dataset from GlowsAncillaryCombiner.combined_dataset containing the
+        pipeline settings data extracted from the JSON file.
+
+    Attributes
+    ----------
+    active_bad_angle_flags : list[bool]
+        Binary mask determining which of the 4 bad-angle flags are active:
+        [is_close_to_uv_source, is_inside_excluded_region,
+         is_excluded_by_instr_team, is_suspected_transient]
+        Default: All flags set to True (all active).
+
+    active_bad_time_flags : list[bool]
+        Binary mask determining which bad-time flags from onboard processing
+        should be used for quality control to identify "good time" L1B blocks.
+
+    sunrise_offset : float
+        Offset in hours to adjust sunrise time relative to onboard settings
+        for fine-tuning the day/night boundary determination.
+
+    sunset_offset : float
+        Offset in hours to adjust sunset time relative to onboard settings
+        for fine-tuning the day/night boundary determination.
+
+    processing_thresholds : dict
+        Various thresholds and parameters for ground processing pipeline
+        that control sensitivity and quality criteria for L1B data processing.
+
+    Notes
+    -----
+    Usage example:
+
+    .. code-block:: python
+
+        # Create combiner for pipeline settings file
+        pipeline_combiner = GlowsAncillaryCombiner(pipeline_settings_files, end_date)
+
+        # Create PipelineSettings object
+        pipeline_settings = PipelineSettings(pipeline_combiner.combined_dataset)
+
+        # Use the settings
+        if pipeline_settings.active_bad_angle_flags[0]:  # is_close_to_uv_source
+            # Process UV source exclusions
+            pass
+    """
+
+    pipeline_dataset: InitVar[xr.Dataset]
+
+    # Extracted pipeline settings attributes
+    active_bad_angle_flags: list[bool] = field(init=False)
+    active_bad_time_flags: list[bool] = field(init=False)
+    sunrise_offset: float = field(init=False)
+    sunset_offset: float = field(init=False)
+    processing_thresholds: dict = field(init=False)
+
+    def __post_init__(self, pipeline_dataset: xr.Dataset) -> None:
+        """
+        Extract pipeline settings from the dataset.
+
+        Parameters
+        ----------
+        pipeline_dataset : xr.Dataset
+            Dataset containing pipeline settings data variables.
+        """
+        # Extract active bad-angle flags (default to all True if not present)
+        if "active_bad_angle_flags" in pipeline_dataset.data_vars:
+            self.active_bad_angle_flags = list(
+                pipeline_dataset["active_bad_angle_flags"].values
+            )
+        else:
+            # Default: all 4 bad-angle flags are active
+            self.active_bad_angle_flags = [True, True, True, True]
+
+        # Extract active bad-time flags (default to all True if not present)
+        if "active_bad_time_flags" in pipeline_dataset.data_vars:
+            self.active_bad_time_flags = list(
+                pipeline_dataset["active_bad_time_flags"].values
+            )
+        else:
+            # Default: assume all bad-time flags are active
+            self.active_bad_time_flags = [True] * 16  # Typical number of bad-time flags
+
+        # Extract sunrise/sunset offsets (default to 0.0 if not present)
+        self.sunrise_offset = float(pipeline_dataset.get("sunrise_offset", 0.0))
+        self.sunset_offset = float(pipeline_dataset.get("sunset_offset", 0.0))
+
+        # Extract processing thresholds (collect all threshold-related variables)
+        self.processing_thresholds = {}
+        for var_name in pipeline_dataset.data_vars:
+            if "threshold" in var_name.lower() or "limit" in var_name.lower():
+                self.processing_thresholds[var_name] = pipeline_dataset[var_name].item()
+
+
+@dataclass
+class AncillaryExclusions:
+    """
+    Organize input ancillary files for GLOWS L1B bad-angle flag processing.
+
+    This class holds the four types of ancillary datasets required for computing
+    bad-angle flags in GLOWS L1B histogram processing. All datasets should be
+    obtained from the GlowsAncillaryCombiner.combined_dataset property after
+    processing the respective ancillary files.
+
+    Attributes
+    ----------
+    excluded_regions : xr.Dataset
+        Dataset containing excluded sky regions with ecliptic coordinates.
+        Expected structure from GlowsAncillaryCombiner:
+        - 'ecliptic_longitude_deg': DataArray with dimension ('epoch', 'region')
+        - 'ecliptic_latitude_deg': DataArray with dimension ('epoch', 'region')
+
+    uv_sources : xr.Dataset
+        Dataset containing UV sources (stars) with coordinates and masking radii.
+        Expected structure from GlowsAncillaryCombiner:
+        - 'object_name': DataArray with dimension ('epoch', 'source')
+        - 'ecliptic_longitude_deg': DataArray with dimension ('epoch', 'source')
+        - 'ecliptic_latitude_deg': DataArray with dimension ('epoch', 'source')
+        - 'angular_radius_for_masking': DataArray with dimension ('epoch', 'source')
+
+    suspected_transients : xr.Dataset
+        Dataset containing suspected transient signals with time-based masks.
+        Expected structure from GlowsAncillaryCombiner:
+        - 'l1b_unique_block_identifier', dimensions ('epoch', 'time_block')
+        - 'histogram_mask_array', dimensions ('epoch', 'time_block')
+
+    exclusions_by_instr_team : xr.Dataset
+        Dataset containing manual exclusions by instrument team with time-based masks.
+        Expected structure from GlowsAncillaryCombiner:
+        - 'l1b_unique_block_identifier', dimensions ('epoch', 'time_block')
+        - 'histogram_mask_array', dimensions ('epoch', 'time_block')
+
+    Notes
+    -----
+    Usage example:
+
+    .. code-block:: python
+
+        # Create combiners for each ancillary file type
+        excluded_regions_combiner = GlowsAncillaryCombiner(
+            excluded_regions_files, end_date)
+        uv_sources_combiner = GlowsAncillaryCombiner(uv_sources_files, end_date)
+        suspected_transients_combiner = GlowsAncillaryCombiner(
+            suspected_transients_files, end_date)
+        exclusions_combiner = GlowsAncillaryCombiner(exclusions_files, end_date)
+
+        # Create AncillaryExclusions object
+        exclusions = AncillaryExclusions(
+            excluded_regions=excluded_regions_combiner.combined_dataset,
+            uv_sources=uv_sources_combiner.combined_dataset,
+            suspected_transients=suspected_transients_combiner.combined_dataset,
+            exclusions_by_instr_team=exclusions_combiner.combined_dataset
+        )
+
+        # Filter for a specific day using limit_by_day method
+        day_exclusions = exclusions.limit_by_day(np.datetime64('2025-09-23'))
+    """
+
+    excluded_regions: xr.Dataset
+    uv_sources: xr.Dataset
+    suspected_transients: xr.Dataset
+    exclusions_by_instr_team: xr.Dataset
+
+    def limit_by_day(self, day: np.datetime64) -> "AncillaryExclusions":
+        """
+        Return a new AncillaryExclusions object with data filtered for a specified day.
+
+        This method does not mutate the original object and can be called multiple times
+        with different days.
+
+        Parameters
+        ----------
+        day : np.datetime64
+            The day to filter data for.
+
+        Returns
+        -------
+        AncillaryExclusions
+            New instance with data filtered for the specified day.
+        """
+        return AncillaryExclusions(
+            excluded_regions=self.excluded_regions.sel(epoch=day, method="nearest"),
+            uv_sources=self.uv_sources.sel(epoch=day, method="nearest"),
+            suspected_transients=self.suspected_transients.sel(
+                epoch=day, method="nearest"
+            ),
+            exclusions_by_instr_team=self.exclusions_by_instr_team.sel(
+                epoch=day, method="nearest"
+            ),
+        )
 
 
 class AncillaryParameters:
@@ -246,11 +461,11 @@ class DirectEventL1B:
     pulse_test_in_progress: InitVar[np.double]
     memory_error_detected: InitVar[np.double]
     # The following variables are created from the InitVar data
-    de_flags: Optional[np.ndarray] = field(init=False, default=None)
+    de_flags: np.ndarray | None = field(init=False, default=None)
     # TODO: First two values of DE are sec/subsec
-    direct_event_glows_times: Optional[np.ndarray] = field(init=False, default=None)
+    direct_event_glows_times: np.ndarray | None = field(init=False, default=None)
     # 3rd value is pulse length
-    direct_event_pulse_lengths: Optional[np.ndarray] = field(init=False, default=None)
+    direct_event_pulse_lengths: np.ndarray | None = field(init=False, default=None)
     # TODO: where does the multi-event flag go?
 
     def __post_init__(
@@ -495,17 +710,20 @@ class HistogramL1B:
     # )  # Could be datetime TODO: Can't put a string in data
     imap_spin_angle_bin_cntr: np.ndarray = field(init=False)  # Same size as bins
     histogram_flag_array: np.ndarray = field(init=False)
-    spin_period_ground_average: np.double = field(init=False)  # retrieved from SPICE?
-    spin_period_ground_std_dev: np.double = field(init=False)  # retrieved from SPICE?
-    position_angle_offset_average: np.double = field(init=False)  # retrieved from SPICE
+    # These two are retrieved from spin data
+    spin_period_ground_average: np.double = field(init=False)
+    spin_period_ground_std_dev: np.double = field(init=False)
+    position_angle_offset_average: np.double = field(init=False)  # from SPICE
     position_angle_offset_std_dev: np.double = field(init=False)  # from SPICE
-    spin_axis_orientation_std_dev: np.double = field(init=False)  # from SPICE
-    spin_axis_orientation_average: np.double = field(init=False)  # retrieved from SPICE
-    spacecraft_location_average: np.ndarray = field(init=False)  # retrieved from SPIC
-    spacecraft_location_std_dev: np.ndarray = field(init=False)  # retrieved from SPIC
-    spacecraft_velocity_average: np.ndarray = field(init=False)  # retrieved from SPIC
-    spacecraft_velocity_std_dev: np.ndarray = field(init=False)  # retrieved from SPIC
+    spin_axis_orientation_std_dev: np.ndarray = field(init=False)  # from SPICE
+    spin_axis_orientation_average: np.ndarray = field(init=False)  # from SPICE
+    spacecraft_location_average: np.ndarray = field(init=False)  # from SPICE
+    spacecraft_location_std_dev: np.ndarray = field(init=False)  # from SPICE
+    spacecraft_velocity_average: np.ndarray = field(init=False)  # from SPICE
+    spacecraft_velocity_std_dev: np.ndarray = field(init=False)  # from SPICE
     flags: np.ndarray = field(init=False)
+    ancillary_exclusions: InitVar[AncillaryExclusions]
+    ancillary_parameters: InitVar[AncillaryParameters]
     # TODO:
     # - Determine a good way to output flags as "human readable"
     # - Add spice pieces
@@ -519,6 +737,8 @@ class HistogramL1B:
         hv_voltage_variance: np.double,
         spin_period_variance: np.double,
         pulse_length_variance: np.double,
+        ancillary_exclusions: AncillaryExclusions,
+        ancillary_parameters: AncillaryParameters,
     ) -> None:
         """
         Will process data.
@@ -535,63 +755,130 @@ class HistogramL1B:
             Encoded spin period variance.
         pulse_length_variance : numpy.double
             Encoded pulse length variance.
+        ancillary_exclusions : AncillaryExclusions
+            Ancillary exclusions data for bad-angle flag processing.
+        ancillary_parameters : AncillaryParameters
+            Ancillary parameters for decoding histogram data.
         """
         # self.histogram_flag_array = np.zeros((2,))
+        day = met_to_datetime64(self.imap_start_time)
 
-        # TODO: These pieces will need to be filled in from SPICE kernels. For now,
-        #  they are placeholders. GLOWS example code has better placeholders if needed.
-        self.spin_period_ground_average = np.double(-999.9)
-        self.spin_period_ground_std_dev = np.double(-999.9)
-        self.position_angle_offset_average = np.double(-999.9)
-        self.position_angle_offset_std_dev = np.double(-999.9)
-        self.spin_axis_orientation_std_dev = np.double(-999.9)
-        self.spin_axis_orientation_average = np.double(-999.9)
-        self.spacecraft_location_average = np.array([-999.9, -999.9, -999.9])
-        self.spacecraft_location_std_dev = np.array([-999.9, -999.9, -999.9])
-        self.spacecraft_velocity_average = np.array([-999.9, -999.9, -999.9])
-        self.spacecraft_velocity_std_dev = np.array([-999.9, -999.9, -999.9])
+        # Add SPICE related variables
+        self.update_spice_parameters()
         # Will require some additional inputs
         self.imap_spin_angle_bin_cntr = np.zeros((3600,))
 
         # TODO: This should probably be an AWS file
         # TODO Pass in AncillaryParameters object instead of reading here.
-        with open(
-            Path(__file__).parents[1] / "ancillary" / "l1b_conversion_table_v001.json"
-        ) as f:
-            self.ancillary_parameters = AncillaryParameters(json.loads(f.read()))
 
-        self.filter_temperature_average = self.ancillary_parameters.decode(
+        self.filter_temperature_average = ancillary_parameters.decode(
             "filter_temperature", self.filter_temperature_average
         )
-        self.filter_temperature_std_dev = self.ancillary_parameters.decode_std_dev(
+        self.filter_temperature_std_dev = ancillary_parameters.decode_std_dev(
             "filter_temperature", filter_temperature_variance
         )
 
-        self.hv_voltage_average = self.ancillary_parameters.decode(
+        self.hv_voltage_average = ancillary_parameters.decode(
             "hv_voltage", self.hv_voltage_average
         )
-        self.hv_voltage_std_dev = self.ancillary_parameters.decode_std_dev(
+        self.hv_voltage_std_dev = ancillary_parameters.decode_std_dev(
             "hv_voltage", hv_voltage_variance
         )
-        self.spin_period_average = self.ancillary_parameters.decode(
+        self.spin_period_average = ancillary_parameters.decode(
             "spin_period", self.spin_period_average
         )
-        self.spin_period_std_dev = self.ancillary_parameters.decode_std_dev(
+        self.spin_period_std_dev = ancillary_parameters.decode_std_dev(
             "spin_period", spin_period_variance
         )
-        self.pulse_length_average = self.ancillary_parameters.decode(
+        self.pulse_length_average = ancillary_parameters.decode(
             "pulse_length", self.pulse_length_average
         )
-        self.pulse_length_std_dev = self.ancillary_parameters.decode_std_dev(
+        self.pulse_length_std_dev = ancillary_parameters.decode_std_dev(
             "pulse_length", pulse_length_variance
         )
 
-        self.histogram_flag_array = np.zeros((4, 3600), dtype=np.uint8)
+        # get the data for the correct day
+        day_exclusions = ancillary_exclusions.limit_by_day(day)
+
+        # Initialize histogram flag array: [is_close_to_uv_source,
+        # is_inside_excluded_region, is_excluded_by_instr_team,
+        # is_suspected_transient] x 3600 bins
+        self.histogram_flag_array = self._compute_histogram_flag_array(day_exclusions)
         # self.unique_block_identifier = np.datetime_as_string(
         #     np.datetime64(int(self.imap_start_time), "ns"), "s"
         # )
         self.flags = np.ones((FLAG_LENGTH,), dtype=np.uint8)
 
+    def update_spice_parameters(self) -> None:
+        """Update SPICE parameters based on the current state."""
+        data_start_met = self.imap_start_time
+        # use of imap_start_time and glows_time_offset is correct.
+        data_end_met = np.double(self.imap_start_time) + np.double(
+            self.glows_time_offset
+        )
+        data_start_time_et = sct_to_et(met_to_sclkticks(data_start_met))
+        data_end_time_et = sct_to_et(met_to_sclkticks(data_end_met))
+
+        time_range = np.arange(data_start_time_et, data_end_time_et)
+
+        # Calculate spin period
+        # ---------------------
+        spin_data = get_spin_data()
+        # select spin data within the range from data start time to end time
+        spin_data = spin_data[
+            (spin_data["spin_start_met"] >= data_start_met)
+            & (spin_data["spin_start_met"] <= data_end_met)
+        ]
+
+        self.spin_period_ground_average = np.average(spin_data["spin_period_sec"])
+        self.spin_period_ground_std_dev = np.std(spin_data["spin_period_sec"])
+
+        # Calculate position angle offset
+        # --------------------------------
+        angle_offset = 360 - get_spin_angle(
+            get_instrument_spin_phase(
+                self.imap_start_time, instrument=geometry.SpiceFrame.IMAP_GLOWS
+            ),
+            degrees=True,
+        )
+        self.position_angle_offset_average = np.double(angle_offset)
+        self.position_angle_offset_std_dev = np.double(
+            0.0
+        )  # Set to zero per algorithm document
+
+        # Calculate spin axis orientation
+
+        spin_axis_all_times = geometry.cartesian_to_latitudinal(
+            geometry.frame_transform(
+                time_range,
+                np.array([0, 0, 1]),
+                SpiceFrame.IMAP_DPS,
+                SpiceFrame.ECLIPJ2000,
+            )
+        )
+        # Calculate circular statistics for longitude (wraps around)
+        lon_mean = circmean(spin_axis_all_times[..., 1], low=-np.pi, high=np.pi)
+        lon_std = circstd(spin_axis_all_times[..., 1], low=-np.pi, high=np.pi)
+        lat_mean = circmean(spin_axis_all_times[..., 2], low=-np.pi, high=np.pi)
+        lat_std = circstd(spin_axis_all_times[..., 2], low=-np.pi, high=np.pi)
+        self.spin_axis_orientation_average = np.array([lon_mean, lat_mean])
+        self.spin_axis_orientation_std_dev = np.array([lon_std, lat_std])
+
+        # Calculate spacecraft location and velocity
+        # ------------------------------------------
+        # imap_state returns [x, y, z, vx, vy, vz].
+        # First three columns for position and last three for velocity.
+        imap_state = geometry.imap_state(
+            et=time_range, ref_frame=SpiceFrame.ECLIPJ2000, observer=SpiceBody.SUN
+        )
+        position = imap_state[:, :3]
+        velocity = imap_state[:, 3:]
+        # averange and standard deviation over time (rows)
+        self.spacecraft_location_average = np.average(position, axis=0)
+        self.spacecraft_location_std_dev = np.std(position, axis=0)
+        self.spacecraft_velocity_average = np.average(velocity, axis=0)
+        self.spacecraft_velocity_std_dev = np.std(velocity, axis=0)
+
     def output_data(self) -> tuple:
         """
         Output the L1B DataArrays as a tuple.
@@ -628,3 +915,28 @@ class HistogramL1B:
         )
 
         return flags
+
+    def _compute_histogram_flag_array(
+        self, exclusions: AncillaryExclusions
+    ) -> np.ndarray:
+        """
+        Compute the histogram flag array for bad-angle flags.
+
+        Creates a (4, 3600) array where each row represents a different flag type:
+        - Row 0: is_close_to_uv_source
+        - Row 1: is_inside_excluded_region
+        - Row 2: is_excluded_by_instr_team
+        - Row 3: is_suspected_transient
+
+        Parameters
+        ----------
+        exclusions : AncillaryExclusions
+            Ancillary exclusions data filtered for the current day.
+
+        Returns
+        -------
+        np.ndarray
+            Array of shape (4, 3600) with bad-angle flags for each bin.
+        """
+        # TODO: fill out once spice data is available
+        return np.zeros((4, 3600), dtype=np.uint8)

imap_processing/glows/l2/glows_l2.py

@@ -218,6 +218,11 @@ def create_l2_dataset(
         "spacecraft_velocity_std_dev",
     ]
 
+    longitudinal_variables = [
+        "spin_axis_orientation_average",
+        "spin_axis_orientation_std_dev",
+    ]
+
     for key, value in dataclasses.asdict(histogram_l2).items():
         if key in ecliptic_variables:
             output[key] = xr.DataArray(
@@ -225,6 +230,12 @@ def create_l2_dataset(
                 dims=["epoch", "ecliptic"],
                 attrs=attrs.get_variable_attributes(key),
             )
+        elif key in longitudinal_variables:
+            output[key] = xr.DataArray(
+                value,
+                dims=["epoch", "latitudinal"],
+                attrs=attrs.get_variable_attributes(key),
+            )
         elif key == "bad_time_flag_occurrences":
             output[key] = xr.DataArray(
                 value,

imap_processing/hi/hi_l1a.py

@@ -3,7 +3,6 @@
 import logging
 from collections import defaultdict
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 import xarray as xr
@@ -54,10 +53,52 @@ LONG_COUNTERS = (
 )
 TOTAL_COUNTERS = ("a_total", "b_total", "c_total", "fee_de_recd", "fee_de_sent")
 
+# MEMDMP Packet definition of uint32 fields
+# This is a mapping of variable name to index when the dump_data in the
+# HVSCI MEMDMP packet is interpreted as an array of uint32 values.
+MEMDMP_DATA_INDS = {
+    "lastbin_shorten": 9,
+    "coinc_length": 60,
+    "de_timetag": 65,
+    "ab_min": 67,
+    "ab_max": 68,
+    "ac_min": 69,
+    "ac_max": 70,
+    "ba_min": 71,
+    "ba_max": 72,
+    "bc_min": 73,
+    "bc_max": 74,
+    "ca_min": 75,
+    "ca_max": 76,
+    "cb_min": 77,
+    "cb_max": 78,
+    "cc_min": 79,
+    "cc_max": 80,
+    "cfd_dac_a": 82,
+    "cfd_dac_b": 83,
+    "cfd_dac_c": 84,
+    "cfd_dac_d": 85,
+    "de_mask": 87,
+    "ab_rnk": 89,
+    "cc_rnk": 90,
+    "ac_rnk": 91,
+    "bc_rnk": 92,
+    "abc_rnk": 93,
+    "acc_rnk": 94,
+    "bcc_rnk": 95,
+    "abcc_rnk": 96,
+    "esa_table": 100,
+    "esa_steps": 101,
+    "sci_cull": 106,
+    "eng_cull": 107,
+    "spins_per_step": 108,
+    "spins_per_de": 109,
+}
+
 logger = logging.getLogger(__name__)
 
 
-def hi_l1a(packet_file_path: Union[str, Path]) -> list[xr.Dataset]:
+def hi_l1a(packet_file_path: str | Path) -> list[xr.Dataset]:
     """
     Will process IMAP raw data to l1a.
 
@@ -95,6 +136,9 @@ def hi_l1a(packet_file_path: Union[str, Path]) -> list[xr.Dataset]:
         elif apid_enum in [HIAPID.H45_DIAG_FEE, HIAPID.H90_DIAG_FEE]:
             data = datasets_by_apid[apid]
             gattr_key = "imap_hi_l1a_diagfee_attrs"
+        elif apid_enum in [HIAPID.H45_MEMDMP, HIAPID.H90_MEMDMP]:
+            data = finish_memdmp_dataset(datasets_by_apid[apid])
+            gattr_key = "imap_hi_l1a_memdmp_attrs"
 
         # Update dataset global attributes
         attr_mgr = ImapCdfAttributes()
@@ -111,7 +155,7 @@ def hi_l1a(packet_file_path: Union[str, Path]) -> list[xr.Dataset]:
 
 
 def hi_packet_file_to_datasets(
-    packet_file_path: Union[str, Path], use_derived_value: bool = False
+    packet_file_path: str | Path, use_derived_value: bool = False
 ) -> dict[int, xr.Dataset]:
     """
     Extract hi datasets from packet file.
@@ -445,3 +489,80 @@ def unpack_hist_counter(counter_bytes: bytes) -> NDArray[np.uint16]:
     odd_uint12 = ((split_unit8 & (2**4 - 1)) << 8) + lower_uint8
     output_array = np.column_stack((even_uint12, odd_uint12)).reshape(-1, 90)
     return output_array
+
+
+def finish_memdmp_dataset(input_ds: xr.Dataset) -> xr.Dataset:
+    """
+    Create dataset for a number of Hi Memory Dump packets.
+
+    Parameters
+    ----------
+    input_ds : xarray.Dataset
+        Dataset of Hi-45 or Hi-90 MEMDMP packets generated using the
+        `imap_processing.utils.packet_file_to_datasets` function.
+
+    Returns
+    -------
+    dataset : xarray.Dataset
+        Dataset containing data from only MEMDMP packets generated upon entering
+        HVSCI. Specific memory items have been parsed out of the chunk of dumped
+        memory.
+    """
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs(instrument="hi")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
+
+    # We only care about the MEMDMP packets that are generated upon
+    # entry to HVSCI mode. This is very hacky, but the suggested way
+    # to identify these MEMDMP packets is to check that pktlen == 521
+    # Here, we remove packets where pktlen != 521
+    dataset = input_ds.where(input_ds["pkt_len"] == 521, drop=True)
+    logger.debug(
+        f"After trimming MEMDMP packets with pkt_len != 521,"
+        f"{dataset['epoch'].data.size} packets remain with a set"
+        f"of MEMORY_IDs = {set(dataset['memory_id'].data)}"
+    )
+
+    # Rename shcoarse variable (do this first since it copies the input_ds)
+    dataset = dataset.rename_vars({"shcoarse": "ccsds_met"})
+
+    dataset.epoch.attrs.update(
+        attr_mgr.get_variable_attributes("epoch"),
+    )
+
+    # Update existing variable attributes
+    for var_name in [
+        "version",
+        "type",
+        "sec_hdr_flg",
+        "pkt_apid",
+        "seq_flgs",
+        "src_seq_ctr",
+        "pkt_len",
+        "ccsds_met",
+        "cksum",
+    ]:
+        attrs = attr_mgr.get_variable_attributes(f"hi_hist_{var_name}")
+        dataset.data_vars[var_name].attrs.update(attrs)
+
+    new_vars = dict()
+    # Concatenate the dump_data from all packets into a single bytes string and
+    # interpret that bytes string as an array of uint32 values.
+    full_uint32_data = np.frombuffer(dataset["dump_data"].data.sum(), dtype=">u4")
+    # index_stride is the stride to traverse from packet to packet for a given
+    # item in the binary dump data.
+    index_stride = int(dataset["num_bytes"].data[0] // 4)
+    for new_var, offset in MEMDMP_DATA_INDS.items():
+        # The indices for each variable in the dump_data is the starting
+        # offset index with a stride of the number of bytes in the dump
+        # data divided by 4 (32-bit values).
+        new_vars[new_var] = xr.DataArray(
+            data=full_uint32_data[offset::index_stride],
+            dims=["epoch"],
+        )
+
+    # Remove binary memory dump data and add parsed variables
+    dataset = dataset.drop("dump_data")
+    dataset.update(new_vars)
+
+    return dataset