imap-processing 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

imap_processing/glows/l1b/glows_l1b_data.py

@@ -417,19 +417,19 @@ class HistogramL1B:
         IMAP spin angle ψ for bin centers
     filter_temperature_average
         block-averaged value, decoded to Celsius degrees using Eq. (47)
-    filter_temperature_variance
+    filter_temperature_std_dev
         standard deviation (1 sigma), decoded to Celsius degrees using Eq. (51)
     hv_voltage_average
         block-averaged value, decoded to volts using Eq. (47)
-    hv_voltage_variance
+    hv_voltage_std_dev
         standard deviation (1 sigma), decoded to volts using Eq. (51)
     spin_period_average
         block-averaged onboard value, decoded to seconds using Eq. (47)
-    spin_period_variance
+    spin_period_std_dev
         standard deviation (1 sigma), decoded to seconds using Eq. (51)
     pulse_length_average
         block-averaged value, decoded to μs using Eq. (47)
-    pulse_length_variance
+    pulse_length_std_dev
     standard deviation (1 sigma), decoded to μs using Eq. (51)
     glows_start_time
         GLOWS clock, subseconds as decimal part of float
@@ -444,24 +444,24 @@ class HistogramL1B:
         is_inside_excluded_region, is_excluded_by_instr_team, is_suspected_transient]
     spin_period_ground_average
         block-averaged value computed on ground
-    spin_period_ground_variance
+    spin_period_ground_std_dev
         standard deviation (1 sigma)
     position_angle_offset_average
         block-averaged value in degrees
-    position_angle_offset_variance
+    position_angle_offset_std_dev
         standard deviation (1 sigma)
-    spin_axis_orientation_variance
+    spin_axis_orientation_std_dev
         standard deviation( 1 sigma): ∆λ, ∆φ for ⟨λ⟩, ⟨φ⟩
     spin_axis_orientation_average
         block-averaged spin-axis ecliptic longitude ⟨λ⟩ and latitude ⟨φ⟩ in degrees
     spacecraft_location_average
         block-averaged Cartesian ecliptic coordinates ⟨X⟩, ⟨Y ⟩, ⟨Z⟩ [km] of IMAP
-    spacecraft_location_variance
+    spacecraft_location_std_dev
         standard deviations (1 sigma) ∆X, ∆Y , ∆Z for ⟨X⟩, ⟨Y ⟩, ⟨Z⟩
     spacecraft_velocity_average
         block-averaged values ⟨VX⟩, ⟨VY⟩, ⟨VZ⟩ [km/s] of IMAP velocity components
         (Cartesian ecliptic frame)
-    spacecraft_velocity_variance
+    spacecraft_velocity_std_dev
         standard deviations (1 sigma) ∆VX , ∆VY , ∆VZ for ⟨VX ⟩, ⟨VY ⟩, ⟨VZ ⟩
     flags
         flags for extra information, per histogram. This should be a human-readable
@@ -470,9 +470,7 @@ class HistogramL1B:
 
     histogram: np.ndarray
     flight_software_version: str
-    # pkts_file_name: str TODO: add this in L0
     seq_count_in_pkts_file: int
-    # l1a_file_name: str TODO: add this
     # ancillary_data_files: np.ndarray TODO Add this
     first_spin_id: int
     last_spin_id: int
@@ -482,13 +480,17 @@ class HistogramL1B:
     number_of_bins_per_histogram: int
     number_of_events: int
     filter_temperature_average: np.double
-    filter_temperature_variance: np.double
+    filter_temperature_variance: InitVar[np.double]
+    filter_temperature_std_dev: np.double = field(init=False)
     hv_voltage_average: np.double
-    hv_voltage_variance: np.double
+    hv_voltage_variance: InitVar[np.double]
+    hv_voltage_std_dev: np.double = field(init=False)
     spin_period_average: np.double
-    spin_period_variance: np.double
+    spin_period_variance: InitVar[np.double]
+    spin_period_std_dev: np.double = field(init=False)
     pulse_length_average: np.double
-    pulse_length_variance: np.double
+    pulse_length_variance: InitVar[np.double]
+    pulse_length_std_dev: np.double = field(init=False)
     imap_start_time: np.double  # No conversion needed from l1a->l1b
     imap_time_offset: np.double  # No conversion needed from l1a->l1b
     glows_start_time: np.double  # No conversion needed from l1a->l1b
@@ -499,40 +501,60 @@ class HistogramL1B:
     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_variance: 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
-    position_angle_offset_variance: np.double = field(init=False)  # from SPICE
-    spin_axis_orientation_variance: 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_variance: 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_variance: np.ndarray = field(init=False)  # retrieved from SPIC
+    spacecraft_velocity_std_dev: np.ndarray = field(init=False)  # retrieved from SPIC
     flags: np.ndarray = field(init=False)
     # TODO:
     # - Determine a good way to output flags as "human readable"
     # - Add spice pieces
-    # - add in the filenames for the input files - should they be global attributes?
     # - also unique identifiers
     # - Bad angle algorithm using SPICE locations
     # - Move ancillary file to AWS
 
-    def __post_init__(self) -> None:
-        """Will process data."""
+    def __post_init__(
+        self,
+        filter_temperature_variance: np.double,
+        hv_voltage_variance: np.double,
+        spin_period_variance: np.double,
+        pulse_length_variance: np.double,
+    ) -> None:
+        """
+        Will process data.
+
+        The input variance values are used to calculate the output standard deviation.
+
+        Parameters
+        ----------
+        filter_temperature_variance : numpy.double
+            Encoded filter temperature variance.
+        hv_voltage_variance : numpy.double
+            Encoded HV voltage variance.
+        spin_period_variance : numpy.double
+            Encoded spin period variance.
+        pulse_length_variance : numpy.double
+            Encoded pulse length variance.
+        """
         # self.histogram_flag_array = np.zeros((2,))
 
         # 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_variance = 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_variance = np.double(-999.9)
-        self.spin_axis_orientation_variance = 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_variance = 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_variance = np.array([-999.9, -999.9, -999.9])
+        self.spacecraft_velocity_std_dev = np.array([-999.9, -999.9, -999.9])
         # Will require some additional inputs
         self.imap_spin_angle_bin_cntr = np.zeros((3600,))
 
@@ -546,34 +568,34 @@ class HistogramL1B:
         self.filter_temperature_average = self.ancillary_parameters.decode(
             "filter_temperature", self.filter_temperature_average
         )
-        self.filter_temperature_variance = self.ancillary_parameters.decode_std_dev(
-            "filter_temperature", self.filter_temperature_variance
+        self.filter_temperature_std_dev = self.ancillary_parameters.decode_std_dev(
+            "filter_temperature", filter_temperature_variance
         )
 
         self.hv_voltage_average = self.ancillary_parameters.decode(
             "hv_voltage", self.hv_voltage_average
         )
-        self.hv_voltage_variance = self.ancillary_parameters.decode_std_dev(
-            "hv_voltage", self.hv_voltage_variance
+        self.hv_voltage_std_dev = self.ancillary_parameters.decode_std_dev(
+            "hv_voltage", hv_voltage_variance
         )
         self.spin_period_average = self.ancillary_parameters.decode(
             "spin_period", self.spin_period_average
         )
-        self.spin_period_variance = self.ancillary_parameters.decode_std_dev(
-            "spin_period", self.spin_period_variance
+        self.spin_period_std_dev = self.ancillary_parameters.decode_std_dev(
+            "spin_period", spin_period_variance
         )
         self.pulse_length_average = self.ancillary_parameters.decode(
             "pulse_length", self.pulse_length_average
         )
-        self.pulse_length_variance = self.ancillary_parameters.decode_std_dev(
-            "pulse_length", self.pulse_length_variance
+        self.pulse_length_std_dev = self.ancillary_parameters.decode_std_dev(
+            "pulse_length", pulse_length_variance
         )
 
         self.histogram_flag_array = np.zeros((4, 3600), dtype=np.uint8)
         # self.unique_block_identifier = np.datetime_as_string(
         #     np.datetime64(int(self.imap_start_time), "ns"), "s"
         # )
-        self.flags = np.zeros((17, 3600), dtype=np.uint8)
+        self.flags = np.ones((17,), dtype=np.uint8)
 
     def output_data(self) -> tuple:
         """

imap_processing/glows/l2/glows_l2_data.py

@@ -0,0 +1,123 @@
+"""Module containing the class definition for the HistogramL2 class."""
+
+from dataclasses import InitVar, dataclass, field
+
+import numpy as np
+
+
+@dataclass
+class HistogramL2:
+    """
+    Dataclass describing Histogram L2 data variables and methods.
+
+    This class collects multiple HistogramL1B classes into one L2 per observational day.
+
+    flight_software_version : str
+    number_of_good_l1b_inputs : int
+        number of good-time Level-1B times used for generation of Level-2 data
+    total_l1b_inputs : int
+      number of all Level-1B times for observational day
+    identifier : int
+        unique Level-2 histogram identifier
+    start_time : numpy.double
+        UTC start time of a given observational day
+    end_time : numpy.double
+        UTC end time of a given observational day
+    daily_lightcurve : numpy.ndarray
+        arrays for observational-day-accumulated lightcurve
+    filter_temperature_average : numpy.ndarray
+        observational-day-averaged filter temperature [Celsius deg]
+    filter_temperature_variance : numpy.ndarray
+        standard deviation for filter temperature [Celsius deg]
+    hv_voltage_average : numpy.ndarray
+        observational-day-averaged channeltron voltage [volt]
+    hv_voltage_variance : numpy.ndarray
+        standard deviation for channeltron voltage [volt]
+    spin_period_average : numpy.ndarray
+        observational-day-averaged spin period [s] (onboard value)
+    spin_period_variance : numpy.ndarray
+        a standard deviation for spin period [s]
+    pulse_length_average : numpy.ndarray
+        observational-day-averaged pulse length [μs]
+    pulse_length_variance : numpy.ndarray
+        standard deviation for pulse length [μs]
+    spin_period_ground_average : numpy.ndarray
+        observational-day-averaged spin period [s] (ground value)
+    spin_period_ground_variance : numpy.ndarray
+        a standard deviation for spin period [s]
+    position_angle_offset_average : numpy.ndarray
+        observational-day-averaged GLOWS angular offset [deg]
+    position_angle_offset_variance : numpy.ndarray
+        standard deviation for GLOWS angular offset [seg]
+    spin_axis_orientation_variance : numpy.ndarray
+        standard deviation for spin-axis longitude and latitude [deg]
+    spacecraft_location_variance : numpy.ndarray
+        standard deviation for ecliptic coordinates [km] of IMAP
+    spacecraft_velocity_variance : numpy.ndarray
+        standard deviation for IMAP velocity components [km/s]
+    spin_axis_orientation_average : numpy.ndarray
+        observational-day-averaged spin-axis ecliptic longitude and latitude [deg]
+    spacecraft_location_average : numpy.ndarray
+        observational-day-averaged Cartesian ecliptic coordinates ⟨X⟩, ⟨Y ⟩, ⟨Z⟩ [km]
+        of IMAP
+    spacecraft_velocity_average : numpy.ndarray
+        observational-day-averaged values ⟨VX ⟩, ⟨VY ⟩, ⟨VZ ⟩ of IMAP velocity
+        components [km/s] (Cartesian ecliptic frame)
+    bad_time_flag_occurrences : numpy.ndarray
+        numbers of occurrences of blocks for each bad-time flag during observational day
+    """
+
+    flight_software_version: str
+    number_of_good_l1b_inputs: int
+    total_l1b_inputs: int
+    # identifier: int  # comes from unique_block_identifier
+    start_time: np.double
+    end_time: np.double
+    daily_lightcurve: np.ndarray = field(init=False)
+    filter_temperature_average: np.ndarray[np.double]
+    filter_temperature_std_dev: np.ndarray[np.double]
+    hv_voltage_average: np.ndarray[np.double]
+    hv_voltage_std_dev: np.ndarray[np.double]
+    spin_period_average: np.ndarray[np.double]
+    spin_period_std_dev: np.ndarray[np.double]
+    pulse_length_average: np.ndarray[np.double]
+    pulse_length_std_dev: np.ndarray[np.double]
+    spin_period_ground_average: np.ndarray[np.double]
+    spin_period_ground_std_dev: np.ndarray[np.double]
+    position_angle_offset_average: np.ndarray[np.double]
+    position_angle_offset_std_dev: np.ndarray[np.double]
+    spin_axis_orientation_std_dev: np.ndarray[np.double]
+    spacecraft_location_std_dev: np.ndarray[np.double]
+    spacecraft_velocity_std_dev: np.ndarray[np.double]
+    spin_axis_orientation_average: np.ndarray[np.double]
+    spacecraft_location_average: np.ndarray[np.double]
+    spacecraft_velocity_average: np.ndarray[np.double]
+    bad_time_flag_occurrences: np.ndarray
+    histogram: InitVar[np.ndarray]
+
+    def __post_init__(self, histogram: np.ndarray) -> None:
+        """
+        Post-initialization method to generate the daily light curve from one histogram.
+
+        Parameters
+        ----------
+        histogram : numpy.ndarray
+            Histogram data from L1B, of shape (bins,) where bins is nominally 3600.
+        """
+        self.daily_lightcurve = self.generate_lightcurve(histogram)
+
+    def generate_lightcurve(self, histogram: np.ndarray) -> np.ndarray:
+        """
+        Given an array of (n, bins) histograms, generate one lightcurve of size (bins).
+
+        Parameters
+        ----------
+        histogram : numpy.ndarray
+            Histogram data from L1B, of shape (bins,) where bins is nominally 3600.
+
+        Returns
+        -------
+        numpy.ndarray
+            Lightcurve of size (bins).
+        """
+        return np.zeros(3600)  # type: ignore[no-any-return]

imap_processing/hi/l1a/hi_l1a.py

@@ -33,7 +33,7 @@ def hi_l1a(packet_file_path: Union[str, Path], data_version: str) -> list[xr.Dat
         List of processed xarray dataset.
     """
     packet_def_file = (
-        imap_module_directory / "hi/packet_definitions/hi_packet_definition.xml"
+        imap_module_directory / "hi/packet_definitions/TLM_HI_COMBINED_SCI.xml"
     )
     datasets_by_apid = packet_file_to_datasets(
         packet_file=packet_file_path, xtce_packet_definition=packet_def_file
@@ -42,18 +42,18 @@ def hi_l1a(packet_file_path: Union[str, Path], data_version: str) -> list[xr.Dat
     # Process science to l1a.
     processed_data = []
     for apid in datasets_by_apid:
-        if apid == HIAPID.H45_SCI_CNT:
+        if apid in [HIAPID.H45_SCI_CNT, HIAPID.H90_SCI_CNT]:
             logger.info(
                 "Processing histogram data for [%s] packets", HIAPID.H45_SCI_CNT.name
             )
             data = hist_create_dataset(datasets_by_apid[apid])
-        elif apid == HIAPID.H45_SCI_DE:
+        elif apid in [HIAPID.H45_SCI_DE, HIAPID.H90_SCI_DE]:
             logger.info(
                 "Processing direct event data for [%s] packets", HIAPID.H45_SCI_DE.name
             )
 
             data = science_direct_event(datasets_by_apid[apid])
-        elif apid == HIAPID.H45_APP_NHK:
+        elif apid in [HIAPID.H45_APP_NHK, HIAPID.H90_APP_NHK]:
             logger.info(
                 "Processing housekeeping data for [%s] packets", HIAPID.H45_APP_NHK.name
             )

imap_processing/hi/l1a/histogram.py

@@ -2,36 +2,36 @@
 
 import numpy as np
 import xarray as xr
+from numpy._typing import NDArray
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
-from imap_processing.utils import convert_to_binary_string
 
 # define the names of the 24 counter arrays
 # contained in the histogram packet
 QUALIFIED_COUNTERS = (
-    "qual_ab",
-    "qual_c1c2",
-    "qual_ac1",
-    "qual_bc1",
-    "qual_abc1",
-    "qual_ac1c2",
-    "qual_bc1c2",
-    "qual_abc1c2",
+    "ab_qualified",
+    "c1c2_qualified",
+    "ac1_qualified",
+    "bc1_qualified",
+    "abc1_qualified",
+    "ac1c2_qualified",
+    "bc1c2_qualified",
+    "abc1c2_qualified",
 )
 LONG_COUNTERS = (
-    "long_a",
-    "long_b",
-    "long_c",
-    "long_ab",
-    "long_c1c2",
-    "long_ac1",
-    "long_bc1",
-    "long_abc1",
-    "long_ac1c2",
-    "long_bc1c2",
-    "long_abc1c2",
+    "a_first_only",
+    "b_first_only",
+    "c_first_only",
+    "ab_long",
+    "c1c2_long",
+    "ac1_long",
+    "bc1_long",
+    "abc1_long",
+    "ac1c2_long",
+    "bc1c2_long",
+    "abc1c2_long",
 )
-TOTAL_COUNTERS = ("total_a", "total_b", "total_c", "fee_de_sent", "fee_de_recd")
+TOTAL_COUNTERS = ("a_total", "b_total", "c_total", "fee_de_recd", "fee_de_sent")
 
 
 def create_dataset(input_ds: xr.Dataset) -> xr.Dataset:
@@ -41,99 +41,56 @@ def create_dataset(input_ds: xr.Dataset) -> xr.Dataset:
     Parameters
     ----------
     input_ds : xarray.Dataset
-        Dataset of packets.
+        Dataset of packets generated using the
+        `imap_processing.utils.packet_file_to_datasets` function.
 
     Returns
     -------
     dataset : xarray.Dataset
         Dataset with all metadata field data in xr.DataArray.
     """
-    dataset = allocate_histogram_dataset(len(input_ds.epoch))
-
-    # TODO: Move into the allocate dataset function?
-    dataset["epoch"].data[:] = input_ds["epoch"].data
-    dataset["ccsds_met"].data = input_ds["ccsds_met"].data
-    dataset["esa_stepping_num"].data = input_ds["esa_step"].data
-
-    # unpack the packets data into the Dataset
-    # (npackets, 24 * 90 * 12)
-    # TODO: Look into avoiding the for-loops below
-    #       It seems like we could try to reshape the arrays and do some numpy
-    #       broadcasting rather than for-loops directly here
-    for i_epoch, counters_bytes_data in enumerate(input_ds["counters"].data):
-        binary_str_val = convert_to_binary_string(counters_bytes_data)
-        # unpack 24 arrays of 90 12-bit unsigned integers
-        counter_ints = [
-            int(binary_str_val[i * 12 : (i + 1) * 12], 2) for i in range(90 * 24)
-        ]
-        # populate the dataset with the unpacked integers
-        for i_counter, counter in enumerate(
-            (*QUALIFIED_COUNTERS, *LONG_COUNTERS, *TOTAL_COUNTERS)
-        ):
-            dataset[counter][i_epoch] = counter_ints[
-                i_counter * 90 : (i_counter + 1) * 90
-            ]
-
-    return dataset
-
-
-def allocate_histogram_dataset(num_packets: int) -> xr.Dataset:
-    """
-    Allocate empty xarray.Dataset for specified number of Hi Histogram packets.
-
-    Parameters
-    ----------
-    num_packets : int
-        The number of Hi Histogram packets to allocate space for
-        in the xarray.Dataset.
-
-    Returns
-    -------
-    dataset : xarray.Dataset
-        Empty xarray.Dataset ready to be filled with packet data.
-    """
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs(instrument="hi")
-    attr_mgr.load_variable_attributes("imap_hi_variable_attrs.yaml")
-    # preallocate the xr.DataArrays for all CDF attributes based on number of packets
-    coords = dict()
-    coords["epoch"] = xr.DataArray(
-        np.empty(num_packets, dtype="datetime64[ns]"),
-        name="epoch",
-        dims=["epoch"],
-        attrs=attr_mgr.get_variable_attributes("epoch"),
-    )
-    # Histogram data is binned in 90, 4-degree bins
-    coords["angle"] = xr.DataArray(
-        np.arange(2, 360, 4),
-        name="angle",
-        dims=["angle"],
-        attrs=attr_mgr.get_variable_attributes("hi_hist_angle"),
-    )
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
 
-    data_vars = dict()
-    # Generate label variables
-    data_vars["angle_label"] = xr.DataArray(
-        coords["angle"].values.astype(str),
-        name="angle_label",
-        dims=["angle"],
-        attrs=attr_mgr.get_variable_attributes(
-            "hi_hist_angle_label", check_schema=False
-        ),
-    )
-    # Other data variables
-    data_vars["ccsds_met"] = xr.DataArray(
-        np.empty(num_packets, dtype=np.uint32),
-        dims=["epoch"],
-        attrs=attr_mgr.get_variable_attributes("hi_hist_ccsds_met"),
+    # Rename shcoarse variable (do this first since it copies the input_ds)
+    dataset = input_ds.rename_vars({"shcoarse": "ccsds_met"})
+
+    dataset.epoch.attrs.update(
+        attr_mgr.get_variable_attributes("epoch"),
     )
-    data_vars["esa_stepping_num"] = xr.DataArray(
-        np.empty(num_packets, dtype=np.uint8),
-        dims=["epoch"],
-        attrs=attr_mgr.get_variable_attributes("hi_hist_esa_step"),
+    # Add the hist_angle coordinate
+    # Histogram data is binned in 90, 4-degree bins
+    attrs = attr_mgr.get_variable_attributes("hi_hist_angle")
+    dataset.coords.update(
+        {
+            "angle": xr.DataArray(
+                np.arange(2, 360, 4),
+                name="angle",
+                dims=["angle"],
+                attrs=attrs,
+            )
+        }
     )
-
-    # Allocate xarray.DataArray objects for the 24 90-element histogram counters
+    # Update existing variable attributes
+    for var_name in [
+        "version",
+        "type",
+        "sec_hdr_flg",
+        "pkt_apid",
+        "seq_flgs",
+        "src_seq_ctr",
+        "pkt_len",
+        "ccsds_met",
+        "esa_step",
+        "num_of_spins",
+        "cksum",
+    ]:
+        attrs = attr_mgr.get_variable_attributes(f"hi_hist_{var_name}")
+        dataset.data_vars[var_name].attrs.update(attrs)
+
+    new_vars = dict()
+    # Populate 90-element histogram counters
     default_counter_attrs = attr_mgr.get_variable_attributes("hi_hist_counters")
     for counter_name in (*QUALIFIED_COUNTERS, *LONG_COUNTERS, *TOTAL_COUNTERS):
         # Inject counter name into generic counter attributes
@@ -141,15 +98,56 @@ def allocate_histogram_dataset(num_packets: int) -> xr.Dataset:
         for key, val in counter_attrs.items():
             if isinstance(val, str) and "{counter_name}" in val:
                 counter_attrs[key] = val.format(counter_name=counter_name)
-        data_vars[counter_name] = xr.DataArray(
-            data=np.empty((num_packets, len(coords["angle"])), np.uint16),
+        # Instantiate the counter DataArray
+        new_vars[counter_name] = xr.DataArray(
+            data=unpack_hist_counter(input_ds[counter_name].data.sum()),
             dims=["epoch", "angle"],
             attrs=counter_attrs,
         )
 
-    dataset = xr.Dataset(
-        data_vars=data_vars,
-        coords=coords,
-        attrs=attr_mgr.get_global_attributes("imap_hi_l1a_hist_attrs"),
+    # Generate label variable for angle coordinate
+    new_vars["angle_label"] = xr.DataArray(
+        dataset.coords["angle"].values.astype(str),
+        name="angle_label",
+        dims=["angle"],
+        attrs=attr_mgr.get_variable_attributes(
+            "hi_hist_angle_label", check_schema=False
+        ),
     )
+
+    dataset.update(new_vars)
+    dataset.attrs.update(attr_mgr.get_global_attributes("imap_hi_l1a_hist_attrs"))
+
     return dataset
+
+
+def unpack_hist_counter(counter_bytes: bytes) -> NDArray[np.uint16]:
+    """
+    Unpack Hi SCI_CNT counter data for a single counter.
+
+    Parameters
+    ----------
+    counter_bytes : bytes
+        Sum individual bytes for all epochs of a Hi SCI_CNT counter.
+
+    Returns
+    -------
+    output_array : numpy.ndarray[numpy.uint16]
+        The unpacked 12-bit unsigned integers for the input bytes. The
+        output array has a shape of (n, 90) where n is the number of SCI_CNT
+        packets in the input dataset.
+    """
+    # Interpret bytes for all epochs of current counter as uint8 array
+    counter_uint8 = np.frombuffer(counter_bytes, dtype=np.uint8)
+    # Split into triplets of upper-byte, split-byte and lower-byte arrays
+    upper_uint8, split_unit8, lower_uint8 = np.reshape(
+        counter_uint8, (3, -1), order="F"
+    ).astype(np.uint16)
+    # Compute even indexed uint12 values from upper-byte and first 4-bits of
+    # split-byte
+    even_uint12 = (upper_uint8 << 4) + (split_unit8 >> 4)
+    # Compute odd indexed uint12 values from lower 4-bits of split-byte and
+    # lower-byte
+    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