imap-processing 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

imap_processing/codice/codice_l1a.py

@@ -166,19 +166,17 @@ class CoDICEL1aPipeline:
         """
         self.coords = {}
 
-        coord_names = ["epoch", *list(self.config["output_dims"].keys())]
-
-        # These are labels unique to lo-counters products coordinates
-        if self.config["dataset_name"] in [
-            "imap_codice_l1a_lo-counters-aggregated",
-            "imap_codice_l1a_lo-counters-singles",
-        ]:
-            coord_names.append("spin_sector_pairs_label")
+        coord_names = [
+            "epoch",
+            *self.config["output_dims"].keys(),
+            *[key + "_label" for key in self.config["output_dims"].keys()],
+        ]
 
         # Define the values for the coordinates
         for name in coord_names:
             if name == "epoch":
                 values = self.calculate_epoch_values()
+                dims = [name]
             elif name in [
                 "esa_step",
                 "inst_az",
@@ -188,6 +186,7 @@ class CoDICEL1aPipeline:
                 "ssd_index",
             ]:
                 values = np.arange(self.config["output_dims"][name])
+                dims = [name]
             elif name == "spin_sector_pairs_label":
                 values = np.array(
                     [
@@ -199,12 +198,23 @@ class CoDICEL1aPipeline:
                         "150-180 deg",
                     ]
                 )
+                dims = [name]
+            elif name in [
+                "spin_sector_label",
+                "esa_step_label",
+                "inst_az_label",
+                "spin_sector_index_label",
+                "ssd_index_label",
+            ]:
+                key = name.removesuffix("_label")
+                values = np.arange(self.config["output_dims"][key]).astype(str)
+                dims = [key]
 
             coord = xr.DataArray(
                 values,
                 name=name,
-                dims=[name],
-                attrs=self.cdf_attrs.get_variable_attributes(name),
+                dims=dims,
+                attrs=self.cdf_attrs.get_variable_attributes(name, check_schema=False),
             )
 
             self.coords[name] = coord
@@ -282,7 +292,7 @@ class CoDICEL1aPipeline:
         if self.config["dataset_name"] == "imap_codice_l1a_hi-sectored":
             for species in self.config["energy_table"]:
                 dataset = self.define_energy_bins(dataset, species)
-            dataset = dataset.drop_vars("esa_step")
+            dataset = dataset.drop_vars(["esa_step", "esa_step_label"])
 
         return dataset
 
@@ -316,14 +326,16 @@ class CoDICEL1aPipeline:
             centers,
             dims=[energy_bin_name],
             attrs=self.cdf_attrs.get_variable_attributes(
-                f"{self.config['dataset_name'].split('_')[-1]}-{energy_bin_name}"
+                f"{self.config['dataset_name'].split('_')[-1]}-{energy_bin_name}",
+                check_schema=False,
             ),
         )
         dataset[f"{energy_bin_name}_delta"] = xr.DataArray(
             deltas,
             dims=[f"{energy_bin_name}_delta"],
             attrs=self.cdf_attrs.get_variable_attributes(
-                f"{self.config['dataset_name'].split('_')[-1]}-{energy_bin_name}_delta"
+                f"{self.config['dataset_name'].split('_')[-1]}-{energy_bin_name}_delta",
+                check_schema=False,
             ),
         )
 
@@ -360,13 +372,15 @@ class CoDICEL1aPipeline:
             if variable_name == "energy_table":
                 variable_data = self.get_energy_table()
                 dims = ["esa_step"]
-                attrs = self.cdf_attrs.get_variable_attributes("energy_table")
+                attrs = self.cdf_attrs.get_variable_attributes(
+                    "energy_table", check_schema=False
+                )
 
             elif variable_name == "acquisition_time_per_step":
                 variable_data = self.get_acquisition_times()
                 dims = ["esa_step"]
                 attrs = self.cdf_attrs.get_variable_attributes(
-                    "acquisition_time_per_step"
+                    "acquisition_time_per_step", check_schema=False
                 )
 
             # These variables can be gathered straight from the packet data
@@ -660,7 +674,9 @@ class CoDICEL1aPipeline:
         self.cdf_attrs.add_instrument_variable_attrs("codice", "l1a")
 
 
-def group_ialirt_data(packets: xr.Dataset, data_field_range: range) -> list[bytearray]:
+def group_ialirt_data(
+    packets: xr.Dataset, data_field_range: range, prefix: str
+) -> list[bytearray]:
     """
     Group together the individual I-ALiRT data fields.
 
@@ -670,6 +686,8 @@ def group_ialirt_data(packets: xr.Dataset, data_field_range: range) -> list[byte
         The dataset containing the I-ALiRT data packets.
     data_field_range : range
         The range of the individual data fields (15 or lo, 6 for hi).
+    prefix : str
+        The prefix used to index the data (i.e. ``cod_lo`` or ``cod_hi``).
 
     Returns
     -------
@@ -679,14 +697,28 @@ def group_ialirt_data(packets: xr.Dataset, data_field_range: range) -> list[byte
     current_data_stream = bytearray()
     grouped_data = []
 
+    # Workaround to get this function working for both I-ALiRT spacecraft
+    # data and CoDICE-specific I-ALiRT test data from Joey
+    # TODO: Once CoDICE I-ALiRT processing is more established, we can probably
+    #       do away with processing the test data from Joey and just use the
+    #       I-ALiRT data that is constructed closer to what we expect in-flight.
+    if hasattr(packets, "acquisition_time"):
+        time_key = "acquisition_time"
+        counter_key = "counter"
+        data_key = "data"
+    else:
+        time_key = f"{prefix}_acq"
+        counter_key = f"{prefix}_counter"
+        data_key = f"{prefix}_data"
+
     # When a counter value of 255 is encountered, this signifies the
     # end of the data stream
-    for packet_num in range(0, len(packets.acquisition_time.data)):
-        counter = packets.counter.data[packet_num]
+    for packet_num in range(0, len(packets[time_key].data)):
+        counter = packets[counter_key].data[packet_num]
         if counter != 255:
             for field in data_field_range:
                 current_data_stream.extend(
-                    bytearray([packets[f"data_{field:02}"].data[packet_num]])
+                    bytearray([packets[f"{data_key}_{field:02}"].data[packet_num]])
                 )
         else:
             # At this point, if there are data, the data stream is ready
@@ -743,7 +775,7 @@ def create_binned_dataset(
         np.array(data["epoch"], dtype=np.uint64),
         name="epoch",
         dims=["epoch"],
-        attrs=pipeline.cdf_attrs.get_variable_attributes("epoch"),
+        attrs=pipeline.cdf_attrs.get_variable_attributes("epoch", check_schema=False),
     )
     dataset = xr.Dataset(
         coords={"epoch": coord},
@@ -751,10 +783,11 @@ def create_binned_dataset(
     )
 
     # Add the data variables
+    descriptor = pipeline.config["dataset_name"].removeprefix("imap_codice_l1a_")
     for species in pipeline.config["energy_table"]:
         # Add the species data to the dataset
         values = np.array(data[species], dtype=np.uint32)
-        attrs = pipeline.cdf_attrs.get_variable_attributes(f"hi-omni-{species}")
+        attrs = pipeline.cdf_attrs.get_variable_attributes(f"{descriptor}-{species}")
         dims = ["epoch", f"energy_{species}"]
         dataset[species] = xr.DataArray(
             values,
@@ -843,13 +876,19 @@ def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
         epochs,
         name="epoch",
         dims=["epoch"],
-        attrs=cdf_attrs.get_variable_attributes("epoch"),
+        attrs=cdf_attrs.get_variable_attributes("epoch", check_schema=False),
     )
     event_num = xr.DataArray(
         np.arange(10000),
         name="event_num",
         dims=["event_num"],
-        attrs=cdf_attrs.get_variable_attributes("event_num"),
+        attrs=cdf_attrs.get_variable_attributes("event_num", check_schema=False),
+    )
+    event_num_label = xr.DataArray(
+        np.arange(10000).astype(str),
+        name="event_num_label",
+        dims=["event_num"],
+        attrs=cdf_attrs.get_variable_attributes("event_num_label", check_schema=False),
     )
 
     # Create the dataset to hold the data variables
@@ -858,7 +897,11 @@ def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
     elif apid == CODICEAPID.COD_HI_PHA:
         attrs = cdf_attrs.get_global_attributes("imap_codice_l1a_hi-pha")
     dataset = xr.Dataset(
-        coords={"epoch": epoch, "event_num": event_num},
+        coords={
+            "epoch": epoch,
+            "event_num": event_num,
+            "event_num_label": event_num_label,
+        },
         attrs=attrs,
     )
 
@@ -903,7 +946,7 @@ def create_hskp_dataset(packet: xr.Dataset) -> xr.Dataset:
         packet.epoch,
         name="epoch",
         dims=["epoch"],
-        attrs=cdf_attrs.get_variable_attributes("epoch"),
+        attrs=cdf_attrs.get_variable_attributes("epoch", check_schema=False),
     )
 
     dataset = xr.Dataset(
@@ -928,7 +971,13 @@ def create_hskp_dataset(packet: xr.Dataset) -> xr.Dataset:
         if variable in exclude_variables:
             continue
 
-        attrs = cdf_attrs.get_variable_attributes(variable)
+        # The housekeeping spin_period variable has different values than
+        # the spin_value attribute in other datasets, so it gets special
+        # treatment
+        if variable == "spin_period":
+            attrs = cdf_attrs.get_variable_attributes("spin_period_hskp")
+        else:
+            attrs = cdf_attrs.get_variable_attributes(variable)
 
         dataset[variable] = xr.DataArray(
             packet[variable].data, dims=["epoch"], attrs=attrs
@@ -972,72 +1021,79 @@ def create_ialirt_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
     # See sections 10.4.1 and 10.4.2 in the algorithm document
     if apid == CODICEAPID.COD_LO_IAL:
         data_field_range = range(0, 15)
+        prefix = "cod_lo"
     elif apid == CODICEAPID.COD_HI_IAL:
         data_field_range = range(0, 5)
+        prefix = "cod_hi"
 
     # Group together packets of I-ALiRT data to form complete data sets
-    grouped_data = group_ialirt_data(packets, data_field_range)
-
-    # Process each group to get the science data and corresponding metadata
-    science_values, metadata_values = process_ialirt_data_streams(grouped_data)
-
-    # How data are processed is different for lo-iarlirt and hi-ialirt
-    if apid == CODICEAPID.COD_HI_IAL:
-        # Set some necessary values and process as a binned dataset similar to
-        # a hi-omni data product
-        metadata_for_processing = [
-            "table_id",
-            "plan_id",
-            "plan_step",
-            "view_id",
-            "spin_period",
-            "suspect",
-        ]
-        for var in metadata_for_processing:
-            packets[var] = metadata_values[var.upper()]
-        dataset = create_binned_dataset(apid, packets, science_values)
-
-    elif apid == CODICEAPID.COD_LO_IAL:
-        # Create a nominal instance of the pipeline and process similar to a
-        # lo-sw-species data product
-        pipeline = CoDICEL1aPipeline(
-            metadata_values["TABLE_ID"][0],
-            metadata_values["PLAN_ID"][0],
-            metadata_values["PLAN_STEP"][0],
-            metadata_values["VIEW_ID"][0],
-        )
-        pipeline.set_data_product_config(apid, packets)
-        pipeline.decompress_data(science_values)
-        pipeline.reshape_data()
-
-        # The calculate_epoch_values method needs acq_start_seconds and
-        # acq_start_subseconds attributes on the dataset
-        pipeline.dataset["acq_start_seconds"] = (
-            "_",
-            metadata_values["ACQ_START_SECONDS"],
-        )
-        pipeline.dataset["acq_start_subseconds"] = (
-            "_",
-            metadata_values["ACQ_START_SUBSECONDS"],
-        )
+    grouped_data = group_ialirt_data(packets, data_field_range, prefix)
+
+    if grouped_data:
+        # Process each group to get the science data and corresponding metadata
+        science_values, metadata_values = process_ialirt_data_streams(grouped_data)
+
+        # How data are processed is different for lo-iarlirt and hi-ialirt
+        if apid == CODICEAPID.COD_HI_IAL:
+            # Set some necessary values and process as a binned dataset similar to
+            # a hi-omni data product
+            metadata_for_processing = [
+                "table_id",
+                "plan_id",
+                "plan_step",
+                "view_id",
+                "spin_period",
+                "suspect",
+            ]
+            for var in metadata_for_processing:
+                packets[var] = metadata_values[var.upper()]
+            dataset = create_binned_dataset(apid, packets, science_values)
+
+        elif apid == CODICEAPID.COD_LO_IAL:
+            # Create a nominal instance of the pipeline and process similar to a
+            # lo-sw-species data product
+            pipeline = CoDICEL1aPipeline(
+                metadata_values["TABLE_ID"][0],
+                metadata_values["PLAN_ID"][0],
+                metadata_values["PLAN_STEP"][0],
+                metadata_values["VIEW_ID"][0],
+            )
+            pipeline.set_data_product_config(apid, packets)
+            pipeline.decompress_data(science_values)
+            pipeline.reshape_data()
 
-        pipeline.define_coordinates()
+            # The calculate_epoch_values method needs acq_start_seconds and
+            # acq_start_subseconds attributes on the dataset
+            pipeline.dataset["acq_start_seconds"] = (
+                "_",
+                metadata_values["ACQ_START_SECONDS"],
+            )
+            pipeline.dataset["acq_start_subseconds"] = (
+                "_",
+                metadata_values["ACQ_START_SUBSECONDS"],
+            )
 
-        # The dataset also needs the metadata that will be carried through
-        # to the final data product
-        for field in [
-            "spin_period",
-            "suspect",
-            "st_bias_gain_mode",
-            "sw_bias_gain_mode",
-            "rgfo_half_spin",
-            "nso_half_spin",
-        ]:
-            pipeline.dataset[field] = ("_", metadata_values[field.upper()])
+            pipeline.define_coordinates()
 
-        dataset = pipeline.define_data_variables()
+            # The dataset also needs the metadata that will be carried through
+            # to the final data product
+            for field in [
+                "spin_period",
+                "suspect",
+                "st_bias_gain_mode",
+                "sw_bias_gain_mode",
+                "rgfo_half_spin",
+                "nso_half_spin",
+            ]:
+                pipeline.dataset[field] = ("_", metadata_values[field.upper()])
 
-    return dataset
+            dataset = pipeline.define_data_variables()
+
+        return dataset
+
+    else:
+        logger.warning("No I-ALiRT data found")
+        return None
 
 
 def get_de_metadata(packets: xr.Dataset, segment: int) -> bytes:

imap_processing/codice/codice_l1b.py

@@ -9,9 +9,13 @@ from imap_processing.codice.codice_l1b import process_codice_l1b
 dataset = process_codice_l1b(l1a_filenanme)
 """
 
+# TODO: Figure out how to convert hi-priority data product. Need an updated
+#       algorithm document that describes this.
+
 import logging
 from pathlib import Path
 
+import numpy as np
 import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
@@ -22,6 +26,71 @@ logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
 
+def convert_to_rates(
+    dataset: xr.Dataset, descriptor: str, variable_name: str
+) -> np.ndarray:
+    """
+    Apply a conversion from counts to rates.
+
+    The formula for conversion from counts to rates is specific to each data
+    product, but is largely grouped by CoDICE-Lo and CoDICE-Hi products.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        The L1b dataset containing the data to convert.
+    descriptor : str
+        The descriptor of the data product of interest.
+    variable_name : str
+        The variable name to apply the conversion to.
+
+    Returns
+    -------
+    rates_data : np.ndarray
+        The converted data array.
+    """
+    # TODO: Temporary workaround to create CDFs for SIT-4. Revisit after SIT-4.
+    acq_times = 1
+
+    if descriptor in [
+        "lo-counters-aggregated",
+        "lo-counters-singles",
+        "lo-nsw-angular",
+        "lo-sw-angular",
+        "lo-nsw-priority",
+        "lo-sw-priority",
+        "lo-nsw-species",
+        "lo-sw-species",
+        "lo-ialirt",
+    ]:
+        # Applying rate calculation described in section 10.2 of the algorithm
+        # document
+        rates_data = dataset[variable_name].data / (
+            acq_times
+            * 1e-6  # Converting from microseconds to seconds
+            * constants.L1B_DATA_PRODUCT_CONFIGURATIONS[descriptor]["num_spin_sectors"]
+        )
+    elif descriptor in [
+        "hi-counters-aggregated",
+        "hi-counters-singles",
+        "hi-omni",
+        "hi-priority",
+        "hi-sectored",
+        "hi-ialirt",
+    ]:
+        # Applying rate calculation described in section 10.1 of the algorithm
+        # document
+        rates_data = dataset[variable_name].data / (
+            constants.L1B_DATA_PRODUCT_CONFIGURATIONS[descriptor]["num_spin_sectors"]
+            * constants.L1B_DATA_PRODUCT_CONFIGURATIONS[descriptor]["num_spins"]
+            * acq_times
+        )
+    elif descriptor == "hskp":
+        rates_data = dataset[variable_name].data / acq_times
+
+    return rates_data
+
+
 def process_codice_l1b(file_path: Path) -> xr.Dataset:
     """
     Will process CoDICE l1a data to create l1b data products.
@@ -45,7 +114,11 @@ def process_codice_l1b(file_path: Path) -> xr.Dataset:
     # set some useful distinguishing variables
     dataset_name = l1a_dataset.attrs["Logical_source"].replace("_l1a_", "_l1b_")
     descriptor = dataset_name.removeprefix("imap_codice_l1b_")
-    apid = constants.CODICEAPID_MAPPING[descriptor]
+
+    # Direct event data products do not have a level L1B
+    if descriptor in ["lo-pha", "hi-pha"]:
+        logger.warning("Encountered direct event data product. Skipping L1b processing")
+        return None
 
     # Get the L1b CDF attributes
     cdf_attrs = ImapCdfAttributes()
@@ -60,32 +133,32 @@ def process_codice_l1b(file_path: Path) -> xr.Dataset:
 
     # Determine which variables need to be converted from counts to rates
     # TODO: Figure out exactly which hskp variables need to be converted
+    # Housekeeping and binned datasets are treated a bit differently since
+    # not all variables need to be converted
     if descriptor == "hskp":
-        data_variables = []
-        support_variables = ["cmdexe", "cmdrjct"]
-        variables_to_convert = support_variables
+        # TODO: Check with Joey if any housekeeping data needs to be converted
+        variables_to_convert = []
+    elif descriptor == "hi-sectored":
+        variables_to_convert = ["h", "he3he4", "cno", "fe"]
+    elif descriptor == "hi-omni":
+        variables_to_convert = ["h", "he3", "he4", "c", "o", "ne_mg_si", "fe", "uh"]
+    elif descriptor == "hi-ialirt":
+        variables_to_convert = ["h"]
     else:
-        data_variables = getattr(
+        variables_to_convert = getattr(
             constants, f"{descriptor.upper().replace('-', '_')}_VARIABLE_NAMES"
         )
-        support_variables = constants.DATA_PRODUCT_CONFIGURATIONS[apid][
-            "support_variables"
-        ]
-        variables_to_convert = data_variables + support_variables
 
+    # Apply the conversion to rates
     for variable_name in variables_to_convert:
-        # Apply conversion of data from counts to rates
-        # TODO: Properly implement conversion factors on a per-data-product basis
-        #       For now, just divide by 100 to get float values
-        l1b_dataset[variable_name].data = l1b_dataset[variable_name].data / 100
+        l1b_dataset[variable_name].data = convert_to_rates(
+            l1b_dataset, descriptor, variable_name
+        )
 
         # Set the variable attributes
-        if variable_name in data_variables:
-            cdf_attrs_key = f"{descriptor}-{variable_name}"
-        elif variable_name in support_variables:
-            cdf_attrs_key = variable_name
+        cdf_attrs_key = f"{descriptor}-{variable_name}"
         l1b_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
-            cdf_attrs_key
+            cdf_attrs_key, check_schema=False
         )
 
     logger.info(f"\nFinal data product:\n{l1b_dataset}\n")

imap_processing/codice/codice_l2.py

@@ -0,0 +1,81 @@
+"""
+Perform CoDICE l2 processing.
+
+This module processes CoDICE l1 files and creates L2 data products.
+
+Notes
+-----
+from imap_processing.codice.codice_l2 import process_codice_l2
+dataset = process_codice_l2(l1_filename)
+"""
+
+import logging
+from pathlib import Path
+
+import xarray as xr
+
+from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
+from imap_processing.cdf.utils import load_cdf
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+def process_codice_l2(file_path: Path) -> xr.Dataset:
+    """
+    Will process CoDICE l1 data to create l2 data products.
+
+    Parameters
+    ----------
+    file_path : pathlib.Path
+        Path to the CoDICE L1 file to process.
+
+    Returns
+    -------
+    l2_dataset : xarray.Dataset
+        The``xarray`` dataset containing the science data and supporting metadata.
+    """
+    logger.info(f"Processing {file_path}")
+
+    # Open the l1 file
+    l1_dataset = load_cdf(file_path)
+
+    # Use the logical source as a way to distinguish between data products and
+    # set some useful distinguishing variables
+    # TODO: Could clean this up by using imap-data-access methods?
+    dataset_name = l1_dataset.attrs["Logical_source"]
+    data_level = dataset_name.removeprefix("imap_codice_").split("_")[0]
+    descriptor = dataset_name.removeprefix(f"imap_codice_{data_level}_")
+    dataset_name = dataset_name.replace(data_level, "l2")
+
+    # TODO: Temporary work-around to replace "PHA" naming convention with
+    #       "direct events" This will eventually be changed at the L1 level and
+    #       thus this will eventually be removed.
+    if descriptor == "lo-pha":
+        dataset_name = dataset_name.replace("lo-pha", "lo-direct-events")
+    elif descriptor == "hi-pha":
+        dataset_name = dataset_name.replace("hi-pha", "hi-direct-events")
+
+    # Use the L1 data product as a starting point for L2
+    l2_dataset = l1_dataset.copy()
+
+    # Get the L2 CDF attributes
+    cdf_attrs = ImapCdfAttributes()
+    cdf_attrs.add_instrument_global_attrs("codice")
+    cdf_attrs.add_instrument_variable_attrs("codice", "l2")
+
+    # Update the global attributes
+    l2_dataset.attrs = cdf_attrs.get_global_attributes(dataset_name)
+
+    # Set the variable attributes
+    for variable_name in l2_dataset:
+        l2_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
+            variable_name, check_schema=False
+        )
+
+    # TODO: Add L2-specific algorithms/functionality here. For SIT-4, we can
+    #       just keep the data as-is.
+
+    logger.info(f"\nFinal data product:\n{l2_dataset}\n")
+
+    return l2_dataset

imap_processing/codice/constants.py

@@ -158,6 +158,17 @@ LO_PHA_VARIABLE_NAMES = [
     f"P{n}_{field}" for n in range(8) for field in LO_PHA_CDF_FIELDS
 ]
 
+# Final I-ALiRT data product fields
+CODICE_LO_IAL_DATA_FIELDS = [
+    "c_over_o_abundance",
+    "mg_over_o_abundance",
+    "fe_over_o_abundance",
+    "c_plus_6_over_c_plus_5_ratio",
+    "o_plus_7_over_o_plus_6_ratio",
+    "fe_low_over_fe_high_ratio",
+]
+CODICE_HI_IAL_DATA_FIELDS = ["h"]
+
 # lo- and hi-counters-aggregated data product variables are dynamically
 # determined based on the number of active counters
 # TODO: Try to convince Joey to move to lower case variable names with
@@ -663,6 +674,63 @@ DATA_PRODUCT_CONFIGURATIONS: dict[CODICEAPID | int, dict] = {
     },
 }
 
+# Various configurations to support L1b processing of individual data products
+# Much of these are described in the algorithm document in chapter 11 ("Data
+# Level 1B")
+L1B_DATA_PRODUCT_CONFIGURATIONS: dict[str, dict] = {
+    "hi-counters-aggregated": {
+        "num_spin_sectors": 24,
+        "num_spins": 16,
+    },
+    "hi-counters-singles": {
+        "num_spin_sectors": 24,
+        "num_spins": 16,
+    },
+    "hi-ialirt": {
+        "num_spin_sectors": 24,
+        "num_spins": 4,
+    },
+    "hi-omni": {
+        "num_spin_sectors": 24,
+        "num_spins": 4,
+    },
+    "hi-priority": {  # TODO: Ask Joey to define these
+        "num_spin_sectors": 1,
+        "num_spins": 1,
+    },
+    "hi-sectored": {
+        "num_spin_sectors": 2,
+        "num_spins": 16,
+    },
+    "lo-counters-aggregated": {
+        "num_spin_sectors": 2,
+    },
+    "lo-counters-singles": {
+        "num_spin_sectors": 2,
+    },
+    "lo-nsw-angular": {
+        "num_spin_sectors": 1,
+    },
+    "lo-sw-angular": {
+        "num_spin_sectors": 1,
+    },
+    "lo-nsw-priority": {
+        "num_spin_sectors": 1,
+    },
+    "lo-sw-priority": {
+        "num_spin_sectors": 1,
+    },
+    "lo-nsw-species": {
+        "num_spin_sectors": 12,
+    },
+    "lo-sw-species": {
+        "num_spin_sectors": 12,
+    },
+    "lo-ialirt": {
+        "num_spin_sectors": 12,
+    },
+}
+
 # Various configurations to support processing of direct events data products
 # These are described in the algorithm document in chapter 10 ("Data Level 1A")
 DE_DATA_PRODUCT_CONFIGURATIONS: dict[Any, dict[str, Any]] = {