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

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/histogram.py

@@ -94,7 +94,7 @@ def allocate_histogram_dataset(num_packets: int) -> xr.Dataset:
     """
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs(instrument="hi")
-    attr_mgr.load_variable_attributes("imap_hi_variable_attrs.yaml")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
     # preallocate the xr.DataArrays for all CDF attributes based on number of packets
     coords = dict()
     coords["epoch"] = xr.DataArray(

imap_processing/hi/l1a/science_direct_event.py

@@ -263,7 +263,7 @@ def create_dataset(de_data_list: list, packet_met_time: list) -> xr.Dataset:
     # Load the CDF attributes
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs("hi")
-    attr_mgr.load_variable_attributes("imap_hi_variable_attrs.yaml")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
     # uncomment this once Maxine's PR is merged
     # attr_mgr.add_global_attribute("Data_version", data_version)
 

imap_processing/hi/l1b/hi_l1b.py

@@ -15,7 +15,12 @@ from imap_processing.hi.utils import (
     create_dataset_variables,
     parse_sensor_number,
 )
-from imap_processing.spice.geometry import SpiceFrame, instrument_pointing
+from imap_processing.spice.geometry import (
+    SpiceFrame,
+    get_instrument_spin_phase,
+    get_spacecraft_spin_phase,
+    instrument_pointing,
+)
 from imap_processing.spice.time import j2000ns_to_j2000s
 from imap_processing.utils import convert_raw_to_eu
 
@@ -40,7 +45,7 @@ class CoincidenceBitmap(IntEnum):
 logger = logging.getLogger(__name__)
 ATTR_MGR = ImapCdfAttributes()
 ATTR_MGR.add_instrument_global_attrs("hi")
-ATTR_MGR.load_variable_attributes("imap_hi_variable_attrs.yaml")
+ATTR_MGR.add_instrument_variable_attrs(instrument="hi", level=None)
 
 
 def hi_l1b(l1a_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
@@ -116,17 +121,16 @@ def annotate_direct_events(l1a_dataset: xr.Dataset) -> xr.Dataset:
     """
     l1b_dataset = l1a_dataset.copy()
     l1b_dataset.update(compute_coincidence_type_and_time_deltas(l1b_dataset))
+    l1b_dataset.update(de_nominal_bin_and_spin_phase(l1b_dataset))
     l1b_dataset.update(compute_hae_coordinates(l1b_dataset))
-    l1b_de_var_names = [
-        "esa_energy_step",
-        "spin_phase",
-        "quality_flag",
-        "nominal_bin",
-    ]
-    new_data_vars = create_dataset_variables(
-        l1b_de_var_names, l1b_dataset["epoch"].size, att_manager_lookup_str="hi_de_{0}"
+    l1b_dataset.update(de_esa_energy_step(l1b_dataset))
+    l1b_dataset.update(
+        create_dataset_variables(
+            ["quality_flag"],
+            l1b_dataset["epoch"].size,
+            att_manager_lookup_str="hi_de_{0}",
+        )
     )
-    l1b_dataset.update(new_data_vars)
     l1b_dataset = l1b_dataset.drop_vars(
         ["tof_1", "tof_2", "tof_3", "de_tag", "ccsds_met", "meta_event_met"]
     )
@@ -258,6 +262,47 @@ def compute_coincidence_type_and_time_deltas(
     return new_vars
 
 
+def de_nominal_bin_and_spin_phase(dataset: xr.Dataset) -> dict[str, xr.DataArray]:
+    """
+    Compute nominal bin and instrument spin-phase for each direct event.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        Direct event data to compute instrument spin-phase for.
+
+    Returns
+    -------
+    new_vars : dict[str, xarray.DataArray]
+        Dictionary containing new "spin_phase" variable.
+    """
+    new_vars = create_dataset_variables(
+        [
+            "spin_phase",
+            "nominal_bin",
+        ],
+        len(dataset.epoch),
+        att_manager_lookup_str="hi_de_{0}",
+    )
+
+    # nominal_bin is the index number of the 90 4-degree bins that each DE would
+    # be binned into in the histogram packet. The Hi histogram data is binned by
+    # spacecraft spin-phase, not instrument spin-phase, so the same is done here.
+    met_query_times = j2000ns_to_j2000s(dataset.event_met.values)
+    imap_spin_phase = get_spacecraft_spin_phase(met_query_times)
+    new_vars["nominal_bin"].values = np.asarray(imap_spin_phase * 360 / 4).astype(
+        np.uint8
+    )
+
+    sensor_number = parse_sensor_number(dataset.attrs["Logical_source"])
+    new_vars["spin_phase"].values = np.asarray(
+        get_instrument_spin_phase(
+            met_query_times, SpiceFrame[f"IMAP_HI_{sensor_number}"]
+        )
+    ).astype(np.float32)
+    return new_vars
+
+
 def compute_hae_coordinates(dataset: xr.Dataset) -> dict[str, xr.DataArray]:
     """
     Compute HAE latitude and longitude.
@@ -296,3 +341,32 @@ def compute_hae_coordinates(dataset: xr.Dataset) -> dict[str, xr.DataArray]:
     new_vars["hae_longitude"].values = pointing_coordinates[:, 1]
 
     return new_vars
+
+
+def de_esa_energy_step(dataset: xr.Dataset) -> dict[str, xr.DataArray]:
+    """
+    Compute esa_energy_step for each direct event.
+
+    TODO: For now this function just returns the esa_step from the input dataset.
+        Eventually, it will take L1B housekeeping data and determine the esa
+        energy steps from that data.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        The partial L1B dataset.
+
+    Returns
+    -------
+    new_vars : dict[str, xarray.DataArray]
+        Keys are variable names and values are `xarray.DataArray`.
+    """
+    new_vars = create_dataset_variables(
+        ["esa_energy_step"],
+        len(dataset.epoch),
+        att_manager_lookup_str="hi_de_{0}",
+    )
+    # TODO: Implement this algorithm
+    new_vars["esa_energy_step"].values = dataset.esa_step.values
+
+    return new_vars

imap_processing/hi/l1c/hi_l1c.py

@@ -94,7 +94,7 @@ def allocate_pset_dataset(n_esa_steps: int, sensor_str: str) -> xr.Dataset:
     """
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs("hi")
-    attr_mgr.load_variable_attributes("imap_hi_variable_attrs.yaml")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
 
     # preallocate coordinates xr.DataArrays
     coords = dict()
@@ -115,6 +115,20 @@ def allocate_pset_dataset(n_esa_steps: int, sensor_str: str) -> xr.Dataset:
         dims=["esa_energy_step"],
         attrs=attrs,
     )
+    # TODO: define calibration product number to coincidence type mapping and
+    #     use the number of calibration products here. I believe it will be 5
+    #     0 for any, 1-4, for the number of detector hits.
+    n_calibration_prod = 5
+    attrs = attr_mgr.get_variable_attributes(
+        "hi_pset_calibration_prod", check_schema=False
+    ).copy()
+    dtype = attrs.pop("dtype")
+    coords["calibration_prod"] = xr.DataArray(
+        np.arange(n_calibration_prod, dtype=dtype),
+        name="calibration_prod",
+        dims=["calibration_prod"],
+        attrs=attrs,
+    )
     # spin angle bins are 0.1 degree bins for full 360 degree spin
     attrs = attr_mgr.get_variable_attributes(
         "hi_pset_spin_angle_bin", check_schema=False
@@ -157,6 +171,14 @@ def allocate_pset_dataset(n_esa_steps: int, sensor_str: str) -> xr.Dataset:
             "hi_pset_esa_energy_step_label", check_schema=False
         ),
     )
+    data_vars["calibration_prod_label"] = xr.DataArray(
+        coords["calibration_prod"].values.astype(str),
+        name="calibration_prod_label",
+        dims=["calibration_prod"],
+        attrs=attr_mgr.get_variable_attributes(
+            "hi_pset_calibration_prod_label", check_schema=False
+        ),
+    )
     data_vars["spin_bin_label"] = xr.DataArray(
         coords["spin_angle_bin"].values.astype(str),
         name="spin_bin_label",

imap_processing/hi/utils.py

@@ -174,7 +174,7 @@ def create_dataset_variables(
     """
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs("hi")
-    attr_mgr.load_variable_attributes("imap_hi_variable_attrs.yaml")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
 
     new_variables = dict()
     for var in variable_names:

imap_processing/hit/hit_utils.py

@@ -0,0 +1,221 @@
+"""
+Classes and functions used in HIT processing.
+
+This module contains utility classes and functions that are used by
+HIT processing modules.
+"""
+
+from enum import IntEnum
+
+import numpy as np
+import xarray as xr
+
+from imap_processing import imap_module_directory
+from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
+from imap_processing.utils import packet_file_to_datasets
+
+
+class HitAPID(IntEnum):
+    """
+    HIT APID Mappings.
+
+    Attributes
+    ----------
+    HIT_HSKP: int
+        Housekeeping
+    HIT_SCIENCE : int
+        Science
+    HIT_IALRT : int
+        I-ALiRT
+    """
+
+    HIT_HSKP = 1251
+    HIT_SCIENCE = 1252
+    HIT_IALRT = 1253
+
+
+def get_datasets_by_apid(
+    packet_file: str, derived: bool = False
+) -> dict[int, xr.Dataset]:
+    """
+    Get datasets by APID from a CCSDS packet file.
+
+    Parameters
+    ----------
+    packet_file : str
+        Path to the CCSDS data packet file.
+    derived : bool, optional
+        Flag to use derived values, by default False.
+        Only set to True to get engineering units for L1B
+        housekeeping data product.
+
+    Returns
+    -------
+    datasets_by_apid : dict[int, xr.Dataset]
+        Dictionary of xarray datasets by APID.
+    """
+    # Unpack ccsds file
+    packet_definition = (
+        imap_module_directory / "hit/packet_definitions/hit_packet_definitions.xml"
+    )
+    datasets_by_apid: dict[int, xr.Dataset] = packet_file_to_datasets(
+        packet_file=packet_file,
+        xtce_packet_definition=packet_definition,
+        use_derived_value=derived,
+    )
+    return datasets_by_apid
+
+
+def get_attribute_manager(data_version: str, level: str) -> ImapCdfAttributes:
+    """
+    Create an attribute manager for the HIT data products.
+
+    Parameters
+    ----------
+    data_version : str
+        Version of the data product being created.
+    level : str
+        Data level of the product being created.
+
+    Returns
+    -------
+    attr_mgr : ImapCdfAttributes
+        Attribute manager to set CDF attributes.
+    """
+    # Create the attribute manager for this data level
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs(instrument="hit")
+    attr_mgr.add_instrument_variable_attrs(instrument="hit", level=level)
+    attr_mgr.add_global_attribute("Data_version", data_version)
+    return attr_mgr
+
+
+def concatenate_leak_variables(
+    dataset: xr.Dataset, adc_channels: xr.DataArray
+) -> xr.Dataset:
+    """
+    Concatenate leak variables in the dataset.
+
+    Updates the housekeeping dataset to replace the individual
+    leak_i_00, leak_i_01, ..., leak_i_63 variables with a single
+    leak_i variable as a 2D array. "i" here represents current
+    in the leakage current [Voltage] data.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        Dataset containing 64 leak variables.
+    adc_channels : xarray.DataArray
+        DataArray to be used as a dimension for the concatenated leak variables.
+
+    Returns
+    -------
+    dataset : xarray.Dataset
+        Updated dataset with concatenated leak variables.
+    """
+    # Stack 64 leak variables (leak_00, leak_01, ..., leak_63)
+    leak_vars = [dataset[f"leak_i_{i:02d}"] for i in range(64)]
+
+    # Concatenate along 'adc_channels' and reorder dimensions
+    stacked_leaks = xr.concat(leak_vars, dim=adc_channels).transpose(
+        "epoch", "adc_channels"
+    )
+    dataset["leak_i"] = stacked_leaks
+
+    # Drop the individual leak variables
+    updated_dataset = dataset.drop_vars([f"leak_i_{i:02d}" for i in range(64)])
+
+    return updated_dataset
+
+
+def process_housekeeping_data(
+    dataset: xr.Dataset, attr_mgr: ImapCdfAttributes, logical_source: str
+) -> xr.Dataset:
+    """
+    Will process housekeeping dataset for CDF product.
+
+    Updates the housekeeping dataset with a single 2D leak_i
+    variable. Also updates the dataset attributes, coordinates
+    and data variable dimensions according to specifications in
+    a cdf yaml file. This function is used for both L1A and L1B
+    housekeeping data products.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        Dataset containing HIT housekeeping data.
+
+    attr_mgr : ImapCdfAttributes
+        Attribute manager used to get the data product field's attributes.
+
+    logical_source : str
+        Logical source of the data -> imap_hit_l1a_hk or imap_hit_l1b_hk.
+
+    Returns
+    -------
+    dataset : xarray.Dataset
+        An updated dataset ready for CDF conversion.
+    """
+    # Drop keys that are not CDF data variables
+    drop_keys = [
+        "pkt_apid",
+        "sc_tick",
+        "version",
+        "type",
+        "sec_hdr_flg",
+        "seq_flgs",
+        "src_seq_ctr",
+        "pkt_len",
+        "hskp_spare1",
+        "hskp_spare2",
+        "hskp_spare3",
+        "hskp_spare4",
+        "hskp_spare5",
+    ]
+
+    # Drop variables not needed for CDF
+    dataset = dataset.drop_vars(drop_keys)
+
+    # Create data arrays for dependencies
+    adc_channels = xr.DataArray(
+        np.arange(64, dtype=np.uint8),
+        name="adc_channels",
+        dims=["adc_channels"],
+        attrs=attr_mgr.get_variable_attributes("adc_channels"),
+    )
+
+    # NOTE: LABL_PTR_1 should be CDF_CHAR.
+    adc_channels_label = xr.DataArray(
+        adc_channels.values.astype(str),
+        name="adc_channels_label",
+        dims=["adc_channels_label"],
+        attrs=attr_mgr.get_variable_attributes("adc_channels_label"),
+    )
+
+    # Update dataset coordinates and attributes
+    dataset = dataset.assign_coords(
+        {
+            "adc_channels": adc_channels,
+            "adc_channels_label": adc_channels_label,
+        }
+    )
+    dataset.attrs = attr_mgr.get_global_attributes(logical_source)
+
+    # Stack 64 leak variables (leak_00, leak_01, ..., leak_63)
+    dataset = concatenate_leak_variables(dataset, adc_channels)
+
+    # Assign attributes and dimensions to each data array in the Dataset
+    for field in dataset.data_vars.keys():
+        # Create a dict of dimensions using the DEPEND_I keys in the
+        # attributes
+        dims = {
+            key: value
+            for key, value in attr_mgr.get_variable_attributes(field).items()
+            if "DEPEND" in key
+        }
+        dataset[field].attrs = attr_mgr.get_variable_attributes(field)
+        dataset[field].assign_coords(dims)
+
+    dataset.epoch.attrs = attr_mgr.get_variable_attributes("epoch")
+
+    return dataset

imap_processing/hit/l0/constants.py

@@ -0,0 +1,118 @@
+"""HIT L0 constants for data decommutation."""
+
+from collections import namedtuple
+
+import numpy as np
+
+# energy_units: MeV/n
+MOD_10_MAPPING = {
+    0: {"species": "H", "energy_min": 1.8, "energy_max": 3.6},
+    1: {"species": "H", "energy_min": 4, "energy_max": 6},
+    2: {"species": "H", "energy_min": 6, "energy_max": 10},
+    3: {"species": "4He", "energy_min": 4, "energy_max": 6},
+    4: {"species": "4He", "energy_min": 6, "energy_max": 12},
+    5: {"species": "CNO", "energy_min": 4, "energy_max": 6},
+    6: {"species": "CNO", "energy_min": 6, "energy_max": 12},
+    7: {"species": "NeMgSi", "energy_min": 4, "energy_max": 6},
+    8: {"species": "NeMgSi", "energy_min": 6, "energy_max": 12},
+    9: {"species": "Fe", "energy_min": 4, "energy_max": 12},
+}
+
+# Structure to hold binary details for a
+# section of science data. Used to unpack
+# binary data.
+HITPacking = namedtuple(
+    "HITPacking",
+    [
+        "bit_length",
+        "section_length",
+        "shape",
+    ],
+)
+
+# Define data structure for counts rates data
+COUNTS_DATA_STRUCTURE = {
+    # field: bit_length, section_length, shape
+    # ------------------------------------------
+    # science frame header
+    "hdr_unit_num": HITPacking(2, 2, (1,)),
+    "hdr_frame_version": HITPacking(6, 6, (1,)),
+    "hdr_dynamic_threshold_state": HITPacking(2, 2, (1,)),
+    "hdr_leak_conv": HITPacking(1, 1, (1,)),
+    "hdr_heater_duty_cycle": HITPacking(4, 4, (1,)),
+    "hdr_code_ok": HITPacking(1, 1, (1,)),
+    "hdr_minute_cnt": HITPacking(8, 8, (1,)),
+    # ------------------------------------------
+    # spare bits. Contains no data
+    "spare": HITPacking(24, 24, (1,)),
+    # ------------------------------------------
+    # erates - contains livetime counters
+    "livetime": HITPacking(16, 16, (1,)),  # livetime counter
+    "num_trig": HITPacking(16, 16, (1,)),  # number of triggers
+    "num_reject": HITPacking(16, 16, (1,)),  # number of rejected events
+    "num_acc_w_pha": HITPacking(
+        16, 16, (1,)
+    ),  # number of accepted events with PHA data
+    "num_acc_no_pha": HITPacking(16, 16, (1,)),  # number of events without PHA data
+    "num_haz_trig": HITPacking(16, 16, (1,)),  # number of triggers with hazard flag
+    "num_haz_reject": HITPacking(
+        16, 16, (1,)
+    ),  # number of rejected events with hazard flag
+    "num_haz_acc_w_pha": HITPacking(
+        16, 16, (1,)
+    ),  # number of accepted hazard events with PHA data
+    "num_haz_acc_no_pha": HITPacking(
+        16, 16, (1,)
+    ),  # number of hazard events without PHA data
+    # -------------------------------------------
+    "sngrates": HITPacking(16, 1856, (2, 58)),  # single rates
+    # -------------------------------------------
+    # evprates - contains event processing rates
+    "nread": HITPacking(16, 16, (1,)),  # events read from event fifo
+    "nhazard": HITPacking(16, 16, (1,)),  # events tagged with hazard flag
+    "nadcstim": HITPacking(16, 16, (1,)),  # adc-stim events
+    "nodd": HITPacking(16, 16, (1,)),  # odd events
+    "noddfix": HITPacking(16, 16, (1,)),  # odd events that were fixed in sw
+    "nmulti": HITPacking(
+        16, 16, (1,)
+    ),  # events with multiple hits in a single detector
+    "nmultifix": HITPacking(16, 16, (1,)),  # multi events that were fixed in sw
+    "nbadtraj": HITPacking(16, 16, (1,)),  # bad trajectory
+    "nl2": HITPacking(16, 16, (1,)),  # events sorted into L12 event category
+    "nl3": HITPacking(16, 16, (1,)),  # events sorted into L123 event category
+    "nl4": HITPacking(16, 16, (1,)),  # events sorted into L1423 event category
+    "npen": HITPacking(16, 16, (1,)),  # events sorted into penetrating event category
+    "nformat": HITPacking(16, 16, (1,)),  # nothing currently goes in this slot
+    "naside": HITPacking(16, 16, (1,)),  # A-side events
+    "nbside": HITPacking(16, 16, (1,)),  # B-side events
+    "nerror": HITPacking(16, 16, (1,)),  # events that caused a processing error
+    "nbadtags": HITPacking(
+        16, 16, (1,)
+    ),  # events with inconsistent tags vs pulse heights
+    # -------------------------------------------
+    # other count rates
+    "coinrates": HITPacking(16, 416, (26,)),  # coincidence rates
+    "bufrates": HITPacking(16, 512, (32,)),  # priority buffer rates
+    "l2fgrates": HITPacking(16, 2112, (132,)),  # range 2 foreground rates
+    "l2bgrates": HITPacking(16, 192, (12,)),  # range 2 background rates
+    "l3fgrates": HITPacking(16, 2672, (167,)),  # range 3 foreground rates
+    "l3bgrates": HITPacking(16, 192, (12,)),  # range 3 background rates
+    "penfgrates": HITPacking(16, 528, (33,)),  # range 4 foreground rates
+    "penbgrates": HITPacking(16, 240, (15,)),  # range 4 background rates
+    "ialirtrates": HITPacking(16, 320, (20,)),  # ialirt rates
+    "sectorates": HITPacking(16, 1920, (8, 15)),  # sectored rates
+    "l4fgrates": HITPacking(16, 768, (48,)),  # all range foreground rates
+    "l4bgrates": HITPacking(16, 384, (24,)),  # all range foreground rates
+}
+
+
+# Define the pattern of grouping flags in a complete science frame.
+FLAG_PATTERN = np.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2])
+
+# Define size of science frame (num of packets)
+FRAME_SIZE = len(FLAG_PATTERN)
+
+# Define the number of bits in the mantissa and exponent for
+# decompressing data
+MANTISSA_BITS = 12
+EXPONENT_BITS = 4