imap-processing 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

imap_processing/codice/codice_l1a.py

@@ -26,15 +26,12 @@ from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.codice import constants
 from imap_processing.codice.codice_l0 import decom_packets
 from imap_processing.codice.decompress import decompress
-from imap_processing.codice.utils import CODICEAPID
+from imap_processing.codice.utils import CODICEAPID, CoDICECompression
 from imap_processing.spice.time import met_to_ttj2000ns
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
-# TODO: Determine what should go in event data CDF and how it should be
-#       structured.
-
 
 class CoDICEL1aPipeline:
     """
@@ -537,9 +534,7 @@ class CoDICEL1aPipeline:
         # No longer need to keep the raw data around
         del self.raw_data
 
-    def set_data_product_config(
-        self, apid: int, dataset: xr.Dataset, data_version: str
-    ) -> None:
+    def set_data_product_config(self, apid: int, dataset: xr.Dataset) -> None:
         """
         Set the various settings for defining the data products.
 
@@ -549,79 +544,139 @@ class CoDICEL1aPipeline:
             The APID of interest.
         dataset : xarray.Dataset
             The dataset for the APID of interest.
-        data_version : str
-            Version of the data product being created.
         """
         # Set the packet dataset so that it can be easily called from various
         # methods
         self.dataset = dataset
 
         # Set various configurations of the data product
-        self.config: dict[str, Any] = constants.DATA_PRODUCT_CONFIGURATIONS.get(apid)  # type: ignore
+        self.config: dict[str, Any] = constants.DATA_PRODUCT_CONFIGURATIONS[apid]
 
         # Gather and set the CDF attributes
         self.cdf_attrs = ImapCdfAttributes()
         self.cdf_attrs.add_instrument_global_attrs("codice")
         self.cdf_attrs.add_instrument_variable_attrs("codice", "l1a")
-        self.cdf_attrs.add_global_attribute("Data_version", data_version)
 
 
-def create_event_dataset(
-    apid: int, packet: xr.Dataset, data_version: str
-) -> xr.Dataset:
+def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
     """
-    Create dataset for event data.
+    Create dataset for direct event data.
+
+    For direct event data, the raw data from the spacecraft is organized first
+    by epoch, then by priority, then by events. For example, for a CoDICE-Lo
+    dataset with 10 epochs, we expect the length of the `event_data` field to
+    be (10 epochs * 8 priorities) = 80 items, with each item being a compressed
+    byte object representing a variable number of events (up to 10000 events).
+    Each compressed byte object is comprised of several fields with specific
+    bit lengths/positions, described by the constants.[LO|HI]_DE_BIT_STRUCTURE
+    dictionary. Padding is added to any fields that have less than 10000 events.
+
+    In order to process these data, we must take the decommed raw data, group
+    the packets appropriately based on their `seq_flgs`, decompress the data,
+    then arrange the data into CDF data variables for each priority and bit
+    field. For example, P2_SpinAngle represents the spin angles for the 2nd
+    priority data.
 
     Parameters
     ----------
     apid : int
         The APID of the packet.
-    packet : xarray.Dataset
-        The packet to process.
-    data_version : str
-        Version of the data product being created.
+    packets : xarray.Dataset
+        The packets to process..
 
     Returns
     -------
     dataset : xarray.Dataset
-        Xarray dataset containing the event data.
+        Xarray dataset containing the direct event data.
     """
+    # Set some useful variables unique to CoDICE-Lo and CoDICE-Hi
     if apid == CODICEAPID.COD_LO_PHA:
-        dataset_name = "imap_codice_l1a_lo-pha"
+        num_priorities = 8
+        cdf_fields = [
+            "NumEvents",
+            "DataQuality",
+            "APDGain",
+            "APD_ID",
+            "APDEnergy",
+            "TOF",
+            "MultiFlag",
+            "PHAType",
+            "SpinAngle",
+            "EnergyStep",
+        ]
     elif apid == CODICEAPID.COD_HI_PHA:
-        dataset_name = "imap_codice_l1a_hi-pha"
+        num_priorities = 6
+        cdf_fields = [
+            "NumEvents",
+            "DataQuality",
+            "SSDEnergy0,TOF",
+            "SSD_ID",
+            "ERGE",
+            "MultiFlag",
+            "Type",
+            "SpinAngle",
+            "SpinNumber",
+        ]
+
+    # Group and decompress the data
+    grouped_data = group_data(packets)
+    decompressed_data = [
+        decompress(group, CoDICECompression.LOSSLESS) for group in grouped_data
+    ]
 
-    # Extract the data
-    # event_data = packet.event_data.data (Currently turned off, see TODO)
+    # Reshape the packet data into CDF-ready variables
+    data = reshape_de_data(packets, decompressed_data, num_priorities)
 
+    # Gather the CDF attributes
     cdf_attrs = ImapCdfAttributes()
     cdf_attrs.add_instrument_global_attrs("codice")
     cdf_attrs.add_instrument_variable_attrs("codice", "l1a")
-    cdf_attrs.add_global_attribute("Data_version", data_version)
 
     # Define coordinates
+    # For epoch, we take the first epoch from each priority set
     epoch = xr.DataArray(
-        packet.epoch,
+        packets.epoch[::num_priorities],
         name="epoch",
         dims=["epoch"],
         attrs=cdf_attrs.get_variable_attributes("epoch"),
     )
+    event_num = xr.DataArray(
+        np.arange(10000),
+        name="event_num",
+        dims=["event_num"],
+        attrs=cdf_attrs.get_variable_attributes("event_num"),
+    )
 
     # Create the dataset to hold the data variables
+    if apid == CODICEAPID.COD_LO_PHA:
+        attrs = cdf_attrs.get_global_attributes("imap_codice_l1a_lo-pha")
+    elif apid == CODICEAPID.COD_HI_PHA:
+        attrs = cdf_attrs.get_global_attributes("imap_codice_l1a_hi-pha")
     dataset = xr.Dataset(
-        coords={
-            "epoch": epoch,
-        },
-        attrs=cdf_attrs.get_global_attributes(dataset_name),
+        coords={"epoch": epoch, "event_num": event_num},
+        attrs=attrs,
     )
 
+    # Create the CDF data variables for each Priority and Field
+    for i in range(num_priorities):
+        for field in cdf_fields:
+            variable_name = f"P{i}_{field}"
+            attrs = cdf_attrs.get_variable_attributes(variable_name)
+            if field in ["NumEvents", "DataQuality"]:
+                dims = ["epoch"]
+            else:
+                dims = ["epoch", "event_num"]
+            dataset[variable_name] = xr.DataArray(
+                np.array(data[variable_name]),
+                name=variable_name,
+                dims=dims,
+                attrs=attrs,
+            )
+
     return dataset
 
 
-def create_hskp_dataset(
-    packet: xr.Dataset,
-    data_version: str,
-) -> xr.Dataset:
+def create_hskp_dataset(packet: xr.Dataset) -> xr.Dataset:
     """
     Create dataset for each metadata field for housekeeping data.
 
@@ -629,8 +684,6 @@ def create_hskp_dataset(
     ----------
     packet : xarray.Dataset
         The packet to process.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -640,7 +693,6 @@ def create_hskp_dataset(
     cdf_attrs = ImapCdfAttributes()
     cdf_attrs.add_instrument_global_attrs("codice")
     cdf_attrs.add_instrument_variable_attrs("codice", "l1a")
-    cdf_attrs.add_global_attribute("Data_version", data_version)
 
     epoch = xr.DataArray(
         packet.epoch,
@@ -719,6 +771,69 @@ def get_params(dataset: xr.Dataset) -> tuple[int, int, int, int]:
     return table_id, plan_id, plan_step, view_id
 
 
+def group_data(packets: xr.Dataset) -> list[bytes]:
+    """
+    Organize continuation packets into appropriate groups.
+
+    Some packets are continuation packets, as in, they are packets that are
+    part of a group of packets. These packets are marked by the `seq_flgs` field
+    in the CCSDS header of the packet. For CoDICE, the values are defined as
+    follows:
+
+    3 = Packet is not part of a group
+    1 = Packet is the first packet of the group
+    0 = Packet is in the middle of the group
+    2 = Packet is the last packet of the group
+
+    For packets that are part of a group, the byte count associated with the
+    first packet of the group signifies the byte count for the entire group.
+
+    Parameters
+    ----------
+    packets : xarray.Dataset
+        Dataset containing the packets to group.
+
+    Returns
+    -------
+    grouped_data : list[bytes]
+        The packet data, converted to bytes and grouped appropriately.
+    """
+    grouped_data = []  # Holds the properly grouped data to be decompressed
+    current_group = bytearray()  # Temporary storage for current group
+    group_byte_count = None  # Temporary storage for current group byte count
+
+    for packet_data, group_code, byte_count in zip(
+        packets.event_data.data, packets.seq_flgs.data, packets.byte_count.data
+    ):
+        # If the group code is 3, this means the data is not part of a group
+        # and can be decompressed as-is
+        if group_code == 3:
+            values_to_decompress = packet_data[:byte_count]
+            grouped_data.append(values_to_decompress)
+
+        # If the group code is 1, this means the data is the first data in a
+        # group. Also, set the byte count for the group
+        elif group_code == 1:
+            group_byte_count = byte_count
+            current_group = packet_data
+
+        # If the group code is 0, this means the data is part of the middle of
+        # the group
+        elif group_code == 0:
+            current_group += packet_data
+
+        # If the group code is 2, this means the data is the last data in the
+        # group
+        elif group_code == 2:
+            current_group += packet_data
+            values_to_decompress = current_group[:group_byte_count]
+            grouped_data.append(values_to_decompress)
+            current_group = bytearray()
+            group_byte_count = None
+
+    return grouped_data
+
+
 def log_dataset_info(datasets: dict[int, xr.Dataset]) -> None:
     """
     Log info about the input data to help with tracking and/or debugging.
@@ -730,9 +845,9 @@ def log_dataset_info(datasets: dict[int, xr.Dataset]) -> None:
     """
     launch_time = np.datetime64("2010-01-01T00:01:06.184", "ns")
     logger.info("\nThis input file contains the following APIDs:\n")
-    for apid in datasets:
-        num_packets = len(datasets[apid].epoch.data)
-        time_deltas = [np.timedelta64(item, "ns") for item in datasets[apid].epoch.data]
+    for apid, ds in datasets.items():
+        num_packets = len(ds.epoch.data)
+        time_deltas = [np.timedelta64(item, "ns") for item in ds.epoch.data]
         times = [launch_time + delta for delta in time_deltas]
         start = np.datetime_as_string(times[0])
         end = np.datetime_as_string(times[-1])
@@ -741,7 +856,102 @@ def log_dataset_info(datasets: dict[int, xr.Dataset]) -> None:
         )
 
 
-def process_codice_l1a(file_path: Path, data_version: str) -> list[xr.Dataset]:
+def reshape_de_data(
+    packets: xr.Dataset, decompressed_data: list[list[int]], num_priorities: int
+) -> dict[str, np.ndarray]:
+    """
+    Reshape the decompressed direct event data into CDF-ready arrays.
+
+    Parameters
+    ----------
+    packets : xarray.Dataset
+        Dataset containing the packets, needed to determine priority order
+        and data quality.
+    decompressed_data : list[list[int]]
+        The decompressed data to reshape, in the format <epoch>[<priority>[<event>]].
+    num_priorities : int
+        The number of priorities in the data product (differs between CoDICE-Lo
+        and CoDICE-Hi).
+
+    Returns
+    -------
+    data : dict[str, numpy.ndarray]
+        The reshaped, CDF-ready arrays. The keys of the dictionary represent the
+        CDF variable names, and the values represent the data.
+    """
+    # Dictionary to hold all the (soon to be restructured) direct event data
+    data: dict[str, np.ndarray] = {}
+
+    # Determine the number of epochs to help with data array initialization
+    # There is one epoch per set of priorities
+    num_epochs = len(packets.epoch.data) // num_priorities
+
+    # Initialize data arrays for each priority and field to store the data
+    # We also need arrays to hold number of events and data quality
+    for priority_num in range(num_priorities):
+        for field in constants.LO_DE_BIT_STRUCTURE:
+            if field not in ["Priority", "Spare"]:
+                data[f"P{priority_num}_{field}"] = np.full(
+                    (num_epochs, 10000), 255, dtype=np.uint16
+                )
+        data[f"P{priority_num}_NumEvents"] = np.full(num_epochs, 255, dtype=np.uint16)
+        data[f"P{priority_num}_DataQuality"] = np.full(num_epochs, 255, dtype=np.uint16)
+
+    # decompressed_data is one large list of values of length
+    # (<number of epochs> * <8 priorities>)
+    # Chunk the data into each epoch
+    for epoch_index in range(num_epochs):
+        # Determine the starting and ending indices of the epoch
+        epoch_start = epoch_index * num_priorities
+        epoch_end = epoch_start + num_priorities
+
+        # Extract the data for the epoch
+        epoch_data = decompressed_data[epoch_start:epoch_end]
+
+        # The order of the priorities and data quality flags are unique to each
+        # epoch and can be gathered from the packet data
+        priority_order = packets.priority[epoch_start:epoch_end].data
+        data_quality = packets.suspect[epoch_start:epoch_end].data
+
+        # For each epoch/priority combo, iterate over each event
+        for i, priority_num in enumerate(priority_order):
+            priority_data = epoch_data[i]
+
+            # Number of events and data quality can be determined at this stage
+            num_events = len(priority_data) // num_priorities
+            data[f"P{priority_num}_NumEvents"][epoch_index] = num_events
+            data[f"P{priority_num}_DataQuality"][epoch_index] = data_quality[i]
+
+            # Iterate over each event
+            for event_index in range(num_events):
+                event_start = event_index * num_priorities
+                event_end = event_start + num_priorities
+                event = priority_data[event_start:event_end]
+                # Separate out each individual field from the bit string
+                # The fields are packed into the bit string in reverse order, so
+                # we need to back them out in reverse order
+                bit_string = (
+                    f"{int.from_bytes(event, byteorder='big'):0{len(event) * 8}b}"
+                )
+                bit_position = 0
+                for field_name, bit_length in reversed(
+                    constants.LO_DE_BIT_STRUCTURE.items()
+                ):
+                    if field_name in ["Priority", "Spare"]:
+                        bit_position += bit_length
+                        continue
+                    value = int(bit_string[bit_position : bit_position + bit_length], 2)
+                    data[f"P{priority_num}_{field_name}"][epoch_index, event_index] = (
+                        value
+                    )
+                    bit_position += bit_length
+
+    # TODO: Implement specific np.dtype and fill_val per field
+
+    return data
+
+
+def process_codice_l1a(file_path: Path) -> list[xr.Dataset]:
     """
     Will process CoDICE l0 data to create l1a data products.
 
@@ -749,8 +959,6 @@ def process_codice_l1a(file_path: Path, data_version: str) -> list[xr.Dataset]:
     ----------
     file_path : pathlib.Path | str
         Path to the CoDICE L0 file to process.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -774,14 +982,19 @@ def process_codice_l1a(file_path: Path, data_version: str) -> list[xr.Dataset]:
 
         # Housekeeping data
         if apid == CODICEAPID.COD_NHK:
-            processed_dataset = create_hskp_dataset(dataset, data_version)
+            processed_dataset = create_hskp_dataset(dataset)
             logger.info(f"\nFinal data product:\n{processed_dataset}\n")
 
         # Event data
-        elif apid in [CODICEAPID.COD_LO_PHA, CODICEAPID.COD_HI_PHA]:
-            processed_dataset = create_event_dataset(apid, dataset, data_version)
+        elif apid == CODICEAPID.COD_LO_PHA:
+            processed_dataset = create_direct_event_dataset(apid, dataset)
             logger.info(f"\nFinal data product:\n{processed_dataset}\n")
 
+        # TODO: Still need to implement
+        elif apid == CODICEAPID.COD_HI_PHA:
+            logger.info("\tStill need to properly implement")
+            processed_dataset = None
+
         # Everything else
         elif apid in constants.APIDS_FOR_SCIENCE_PROCESSING:
             # Extract the data
@@ -792,7 +1005,7 @@ def process_codice_l1a(file_path: Path, data_version: str) -> list[xr.Dataset]:
 
             # Run the pipeline to create a dataset for the product
             pipeline = CoDICEL1aPipeline(table_id, plan_id, plan_step, view_id)
-            pipeline.set_data_product_config(apid, dataset, data_version)
+            pipeline.set_data_product_config(apid, dataset)
             pipeline.decompress_data(science_values)
             pipeline.reshape_data()
             pipeline.define_coordinates()

imap_processing/codice/codice_l1b.py

@@ -1,194 +1,93 @@
 """
 Perform CoDICE l1b processing.
 
-This module processes CoDICE l1a files and creates L1a data products.
+This module processes CoDICE l1a files and creates L1b data products.
 
 Notes
 -----
-from imap_processing.codice.codice_l0 import decom_packets
 from imap_processing.codice.codice_l1b import process_codice_l1b
-dataset = process_codice_l1b(l1a_file)
+dataset = process_codice_l1b(l1a_filenanme)
 """
 
 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
+from imap_processing.codice import constants
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
-# TODO: Fix ISTP compliance issues (revealed in SKTEditor)
 
-
-def create_hskp_dataset(
-    l1a_dataset: xr.Dataset, cdf_attrs: ImapCdfAttributes
-) -> xr.Dataset:
-    """
-    Create an ``xarray`` dataset for the housekeeping data.
-
-    The dataset can then be written to a CDF file.
-
-    Parameters
-    ----------
-    l1a_dataset : xr.Dataset
-        The L1a dataset that is being processed.
-    cdf_attrs : ImapCdfAttributes
-        The CDF attributes for the dataset.
-
-    Returns
-    -------
-    l1b_dataset : xarray.Dataset
-        The ``xarray`` dataset containing the science data and supporting metadata.
-    """
-    epoch = l1a_dataset.coords["epoch"]
-    l1b_dataset = xr.Dataset(
-        coords={"epoch": epoch},
-        attrs=cdf_attrs.get_global_attributes("imap_codice_l1b_hskp"),
-    )
-    for variable_name in l1a_dataset:
-        # Get the data array from the L1a data product
-        values = l1a_dataset[variable_name].values
-
-        # Convert data array to "rates"
-        # TODO: For SIT-3, just convert value to float. Revisit after SIT-3.
-        variable_data_arr = values.astype(float)
-
-        # TODO: Change 'TBD' catdesc and fieldname
-        # Once packet definition files are re-generated, can get this info from
-        # something like this:
-        #    for key, value in (packet.header | packet.data).items():
-        #      fieldname = value.short_description
-        #      catdesc = value.short_description
-        # I am holding off making this change until I acquire updated housekeeping
-        # packets/validation data that match the latest telemetry definitions
-        attrs = cdf_attrs.get_variable_attributes("codice_support_attrs")
-        attrs["CATDESC"] = "TBD"
-        attrs["DEPEND_0"] = "epoch"
-        attrs["FIELDNAM"] = "TBD"
-        attrs["LABLAXIS"] = variable_name
-
-        # Put the new data array into the dataset
-        l1b_dataset[variable_name] = xr.DataArray(
-            variable_data_arr,
-            name=variable_name,
-            dims=["epoch"],
-            attrs=attrs,
-        )
-
-    return l1b_dataset
-
-
-def create_science_dataset(
-    l1a_dataset: xr.Dataset, cdf_attrs: ImapCdfAttributes, dataset_name: str
-) -> xr.Dataset:
-    """
-    Create an ``xarray`` dataset for the science data.
-
-    The dataset can then be written to a CDF file.
-
-    Parameters
-    ----------
-    l1a_dataset : xr.Dataset
-        The L1a dataset that is being processed.
-    cdf_attrs : ImapCdfAttributes
-        The CDF attributes for the dataset.
-    dataset_name : str
-        The name that is used to construct the data variable name and reference
-        the CDF attributes (e.g. ``imap_codice_l1b_hi_omni``).
-
-    Returns
-    -------
-    l1b_dataset : xarray.Dataset
-        The ``xarray`` dataset containing the science data and supporting metadata.
-    """
-    # Retrieve the coordinates from the l1a dataset
-    epoch = l1a_dataset.coords["epoch"]
-    energy = l1a_dataset.coords["energy"]
-    energy_label = l1a_dataset.coords["energy_label"]
-
-    # Create empty l1b dataset
-    l1b_dataset = xr.Dataset(
-        coords={"epoch": epoch, "energy": energy, "energy_label": energy_label},
-        attrs=cdf_attrs.get_global_attributes(dataset_name),
-    )
-
-    # Get the data variables from l1a dataset
-    for variable_name in l1a_dataset:
-        if variable_name == "esa_sweep_values":
-            values = l1a_dataset["esa_sweep_values"]
-            l1b_dataset["esa_sweep_values"] = xr.DataArray(
-                values,
-                dims=["energy"],
-                attrs=cdf_attrs.get_variable_attributes("esa_sweep_attrs"),
-            )
-
-        elif variable_name == "acquisition_times":
-            values = l1a_dataset["acquisition_times"]
-            l1b_dataset["acquisition_times"] = xr.DataArray(
-                values,
-                dims=["energy"],
-                attrs=cdf_attrs.get_variable_attributes("acquisition_times_attrs"),
-            )
-
-        else:
-            # Get the data array from the L1a data product
-            values = l1a_dataset[variable_name].values
-
-            # Convert data array to "rates"
-            # TODO: For SIT-3, just convert value to float. Revisit after SIT-3.
-            variable_data_arr = values.astype(float)
-
-            # Put the new data array into the dataset
-            cdf_attrs_key = (
-                f"{dataset_name.split('imap_codice_l1b_')[-1]}-{variable_name}"
-            )
-            l1b_dataset[variable_name] = xr.DataArray(
-                variable_data_arr,
-                name=variable_name,
-                dims=["epoch", "energy"],
-                attrs=cdf_attrs.get_variable_attributes(cdf_attrs_key),
-            )
-
-    return l1b_dataset
-
-
-def process_codice_l1b(l1a_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
+def process_codice_l1b(file_path: Path) -> xr.Dataset:
     """
     Will process CoDICE l1a data to create l1b data products.
 
     Parameters
     ----------
-    l1a_dataset : xarray.Dataset
-        CoDICE L1a dataset to process.
-    data_version : str
-        Version of the data product being created.
+    file_path : pathlib.Path
+        Path to the CoDICE L1a file to process.
 
     Returns
     -------
     l1b_dataset : xarray.Dataset
         The``xarray`` dataset containing the science data and supporting metadata.
     """
-    logger.info(f"\nProcessing {l1a_dataset.attrs['Logical_source']}.")
+    logger.info(f"\nProcessing {file_path}")
 
-    # Start constructing l1b dataset
+    # Open the l1a file
+    l1a_dataset = load_cdf(file_path)
+
+    # Use the logical source as a way to distinguish between data products and
+    # 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]
+
+    # Get the L1b CDF attributes
     cdf_attrs = ImapCdfAttributes()
     cdf_attrs.add_instrument_global_attrs("codice")
     cdf_attrs.add_instrument_variable_attrs("codice", "l1b")
-    cdf_attrs.add_global_attribute("Data_version", data_version)
 
-    dataset_name = (
-        l1a_dataset.attrs["Logical_source"].replace("-", "_").replace("l1a", "l1b")
-    )
+    # Use the L1a data product as a starting point for L1b
+    l1b_dataset = l1a_dataset.copy()
 
-    if "hskp" in dataset_name:
-        l1b_dataset = create_hskp_dataset(l1a_dataset, cdf_attrs)
+    # Update the global attributes
+    l1b_dataset.attrs = cdf_attrs.get_global_attributes(dataset_name)
 
+    # Determine which variables need to be converted from counts to rates
+    # TODO: Figure out exactly which hskp variables need to be converted
+    if descriptor == "hskp":
+        data_variables = []
+        support_variables = ["cmdexe", "cmdrjct"]
+        variables_to_convert = support_variables
     else:
-        l1b_dataset = create_science_dataset(l1a_dataset, cdf_attrs, dataset_name)
+        data_variables = getattr(
+            constants, f"{descriptor.upper().replace('-', '_')}_VARIABLE_NAMES"
+        )
+        support_variables = constants.DATA_PRODUCT_CONFIGURATIONS[apid][
+            "support_variables"
+        ]
+        variables_to_convert = data_variables + support_variables
+
+    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
+
+        # 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
+        l1b_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
+            cdf_attrs_key
+        )
 
-    # Write the dataset to CDF
     logger.info(f"\nFinal data product:\n{l1b_dataset}\n")
 
     return l1b_dataset