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

imap_processing/idex/idex_l1a.py

@@ -2,10 +2,19 @@
 Perform IDEX L1a Processing.
 
 This module processes decommutated IDEX packets and creates L1a data products.
+
+Examples
+--------
+.. code-block:: python
+
+    from imap_processing.idex.idex_l1a import PacketParser
+
+    l0_file = "imap_processing/tests/idex/imap_idex_l0_sci_20231214_v001.pkts"
+    l1a_data = PacketParser(l0_file, data_version)
+    l1a_data.write_l1a_cdf()
 """
 
 import logging
-from collections import namedtuple
 from enum import IntEnum
 from pathlib import Path
 from typing import Union
@@ -22,59 +31,6 @@ from imap_processing.utils import convert_to_binary_string
 
 logger = logging.getLogger(__name__)
 
-# TODO: Generate quicklook plots
-
-# Create a large dictionary of values from the FPGA header that need to be
-# captured into the CDF file.  They are lumped together because they share
-# similar attributes.
-# Notes about the variables are set here, acting as comments and will also be
-# placed into the CDF in the VAR_NOTES attribute.
-TRIGGER_DESCRIPTION = namedtuple(
-    "TRIGGER_DESCRIPTION",
-    ["name", "packet_name"],
-)
-TRIGGER_DESCRIPTION_DICT = {
-    trigger.name: trigger
-    for trigger in [
-        TRIGGER_DESCRIPTION("event_number", "IDX__TXHDREVTNUM"),
-        TRIGGER_DESCRIPTION("tof_high_trigger_level", "IDX__TXHDRHGTRIGLVL"),
-        TRIGGER_DESCRIPTION("tof_high_trigger_num_max_1_2", "IDX__TXHDRHGTRIGNMAX12"),
-        TRIGGER_DESCRIPTION("tof_high_trigger_num_min_1_2", "IDX__TXHDRHGTRIGNMIN12"),
-        TRIGGER_DESCRIPTION("tof_high_trigger_num_min_1", "IDX__TXHDRHGTRIGNMIN1"),
-        TRIGGER_DESCRIPTION("tof_high_trigger_num_max_1", "IDX__TXHDRHGTRIGNMAX1"),
-        TRIGGER_DESCRIPTION("tof_high_trigger_num_min_2", "IDX__TXHDRHGTRIGNMIN2"),
-        TRIGGER_DESCRIPTION("tof_high_trigger_num_max_2", "IDX__TXHDRHGTRIGNMAX2"),
-        TRIGGER_DESCRIPTION("tof_low_trigger_level", "IDX__TXHDRLGTRIGLVL"),
-        TRIGGER_DESCRIPTION("tof_low_trigger_num_max_1_2", "IDX__TXHDRLGTRIGNMAX12"),
-        TRIGGER_DESCRIPTION("tof_low_trigger_num_min_1_2", "IDX__TXHDRLGTRIGNMIN12"),
-        TRIGGER_DESCRIPTION("tof_low_trigger_num_min_1", "IDX__TXHDRLGTRIGNMIN1"),
-        TRIGGER_DESCRIPTION("tof_low_trigger_num_max_1", "IDX__TXHDRLGTRIGNMAX1"),
-        TRIGGER_DESCRIPTION("tof_low_trigger_num_min_2", "IDX__TXHDRLGTRIGNMIN2"),
-        TRIGGER_DESCRIPTION("tof_low_trigger_num_max_2", "IDX__TXHDRLGTRIGNMAX2"),
-        TRIGGER_DESCRIPTION("tof_mid_trigger_level", "IDX__TXHDRMGTRIGLVL"),
-        TRIGGER_DESCRIPTION("tof_mid_trigger_num_max_1_2", "IDX__TXHDRMGTRIGNMAX12"),
-        TRIGGER_DESCRIPTION("tof_mid_trigger_num_min_1_2", "IDX__TXHDRMGTRIGNMIN12"),
-        TRIGGER_DESCRIPTION("tof_mid_trigger_num_min_1", "IDX__TXHDRMGTRIGNMIN1"),
-        TRIGGER_DESCRIPTION("tof_mid_trigger_num_max_1", "IDX__TXHDRMGTRIGNMAX1"),
-        TRIGGER_DESCRIPTION("tof_mid_trigger_num_min_2", "IDX__TXHDRMGTRIGNMIN2"),
-        TRIGGER_DESCRIPTION("tof_mid_trigger_num_max_2", "IDX__TXHDRMGTRIGNMAX2"),
-        TRIGGER_DESCRIPTION("low_sample_coincidence_mode_blocks", "IDX__TXHDRLSTRIGCMBLOCKS"), # noqa
-        TRIGGER_DESCRIPTION("low_sample_trigger_polarity", "IDX__TXHDRLSTRIGPOL"),
-        TRIGGER_DESCRIPTION("low_sample_trigger_level", "IDX__TXHDRLSTRIGLVL"),
-        TRIGGER_DESCRIPTION("low_sample_trigger_num_min", "IDX__TXHDRLSTRIGNMIN"),
-        TRIGGER_DESCRIPTION("low_sample_trigger_mode", "IDX__TXHDRLSTRIGMODE"),
-        TRIGGER_DESCRIPTION("tof_low_trigger_mode", "IDX__TXHDRLSTRIGMODE"),
-        TRIGGER_DESCRIPTION("tof_mid_trigger_mode", "IDX__TXHDRMGTRIGMODE"),
-        TRIGGER_DESCRIPTION("tof_high_trigger_mode", "IDX__TXHDRHGTRIGMODE"),
-        TRIGGER_DESCRIPTION("detector_voltage", "IDX__TXHDRHVPSHKCH0"),
-        TRIGGER_DESCRIPTION("sensor_voltage", "IDX__TXHDRHVPSHKCH1"),
-        TRIGGER_DESCRIPTION("target_voltage", "IDX__TXHDRHVPSHKCH2"),
-        TRIGGER_DESCRIPTION("reflectron_voltage", "IDX__TXHDRHVPSHKCH3"),
-        TRIGGER_DESCRIPTION("rejection_voltage", "IDX__TXHDRHVPSHKCH4"),
-        TRIGGER_DESCRIPTION("detector_current", "IDX__TXHDRHVPSHKCH5"),
-    ]
-}  # fmt: skip
-
 
 class Scitype(IntEnum):
     """Define parameters for IDEX Science Type."""
@@ -102,15 +58,6 @@ class PacketParser:
         The path and filename to the L0 file to read.
     data_version : str
         The version of the data product being created.
-
-    Examples
-    --------
-    .. code-block:: python
-
-        from imap_processing.idex.idex_l1a import PacketParser
-        l0_file = "imap_processing/tests/idex/imap_idex_l0_sci_20230725_v001.pkts"
-        l1a_data = PacketParser(l0_file, data_version)
-        l1a_data.write_l1a_cdf()
     """
 
     def __init__(self, packet_file: Union[str, Path], data_version: str) -> None:
@@ -158,6 +105,23 @@ class PacketParser:
         idex_attrs = get_idex_attrs(data_version)
         self.data.attrs = idex_attrs.get_global_attributes("imap_idex_l1a_sci")
 
+        # NOTE: LABL_PTR_1 should be CDF_CHAR.
+        self.data["time_low_sr_label"] = xr.DataArray(
+            self.data.time_low_sr_dim.values.astype(str),
+            name="time_low_sr_label",
+            dims=["time_low_sr_label"],
+            attrs=idex_attrs.get_variable_attributes("time_low_sr_label"),
+        )
+
+        self.data["time_high_sr_label"] = xr.DataArray(
+            self.data.time_high_sr_dim.values.astype(str),
+            name="time_high_sr_label",
+            dims=["time_high_sr_label"],
+            attrs=idex_attrs.get_variable_attributes("time_high_sr_label"),
+        )
+
+        logger.info("IDEX L1A science data processing completed.")
+
 
 class RawDustEvent:
     """
@@ -246,13 +210,15 @@ class RawDustEvent:
         self.high_sample_trigger_time = 0
         self._set_sample_trigger_times(header_packet)
 
-        # Iterate through the trigger description dictionary and pull out the values
-        self.trigger_values = {
-            trigger.name: header_packet[trigger.packet_name].raw_value
-            for trigger in TRIGGER_DESCRIPTION_DICT.values()
+        # Iterate through every telemetry item not in the header and pull out the values
+        self.telemetry_items = {
+            key.lower(): val
+            for key, val in header_packet.items()
+            if key not in header_packet.header.keys()
         }
+
         logger.debug(
-            f"trigger_values:\n{self.trigger_values}"
+            f"telemetry_items:\n{self.telemetry_items}"
         )  # Log values here in case of error
 
         # Initialize the binary data received from future packets
@@ -353,12 +319,28 @@ class RawDustEvent:
         The header has information about the number of blocks before triggering,
         rather than the number of samples before triggering.
         """
-        # Retrieve the number of samples of high gain delay
-        high_gain_delay = packet["IDX__TXHDRADC0IDELAY"]
+        # Retrieve the number of samples for high gain delay
+
+        # packet['IDX__TXHDRSAMPDELAY'] is a 32-bit value, with the last 10 bits
+        # representing the high gain sample delay and the first 2 bits used for padding.
+        # To extract the high gain bits, the bitwise right shift (>> 20) moves the bits
+        # 20 positions to the right, and the mask (0b1111111111) keeps only the least
+        # significant 10 bits.
+        high_gain_delay = (packet["IDX__TXHDRSAMPDELAY"] >> 22) & 0b1111111111
+        n_blocks = packet["IDX__TXHDRBLOCKS"]
 
         # Retrieve number of low/high sample pre-trigger blocks
-        num_low_sample_pretrigger_blocks = packet["IDX__TXHDRLSPREBLOCKS"]
-        num_high_sample_pretrigger_blocks = packet["IDX__TXHDRHSPREBLOCKS"]
+
+        # packet['IDX__TXHDRBLOCKS'] is a 32-bit value:
+        # Bits 21-26 represent the number of low sampling pre-trigger blocks.
+        #   We can extract this by shifting right by 6 bits and applying a mask to keep
+        #   the last 6 bits.
+        # Bits 13-16 represent the number of high sampling pre-trigger blocks.
+        #   We can extract this by shifting right by 16 bits and applying a mask to keep
+        #   the last 4 bits.
+
+        num_low_sample_pretrigger_blocks = (n_blocks >> 6) & 0b111111
+        num_high_sample_pretrigger_blocks = (n_blocks >> 16) & 0b1111
 
         # Calculate the low and high sample trigger times based on the high gain delay
         # and the number of high sample/low sample pretrigger blocks
@@ -411,7 +393,7 @@ class RawDustEvent:
         Will process the low sample waveform.
 
         Parse a binary string representing a low sample waveform
-        Data arrives in 32 bit chunks, divided up into:
+        Data arrives in 32-bit chunks, divided up into:
             * 8 bits of padding
             * 2x12 bits of integer data.
 
@@ -514,55 +496,54 @@ class RawDustEvent:
         dataset : xarray.Dataset
             A Dataset object containing the data from a single impact.
         """
-        # Create object for CDF attrs
+        # Create an object for CDF attrs
         idex_attrs = self.cdf_attrs
 
-        # Gather the huge number of trigger info metadata
+        # Gather the huge amount of metadata info
         trigger_vars = {}
-        for var, value in self.trigger_values.items():
-            trigger_desc = TRIGGER_DESCRIPTION_DICT[var]
+        for var, value in self.telemetry_items.items():
             trigger_vars[var] = xr.DataArray(
                 name=var,
                 data=[value],
                 dims=("epoch"),
-                attrs=idex_attrs.get_variable_attributes(trigger_desc.name),
+                attrs=idex_attrs.get_variable_attributes(var),
             )
 
         # Process the 6 primary data variables
         tof_high_xr = xr.DataArray(
             name="TOF_High",
             data=[self._parse_high_sample_waveform(self.TOF_High_bits)],
-            dims=("epoch", "time_high_ssr_dim"),
+            dims=("epoch", "time_high_sr_dim"),
             attrs=idex_attrs.get_variable_attributes("tof_high_attrs"),
         )
         tof_low_xr = xr.DataArray(
             name="TOF_Low",
             data=[self._parse_high_sample_waveform(self.TOF_Low_bits)],
-            dims=("epoch", "time_high_sr"),
+            dims=("epoch", "time_high_sr_dim"),
             attrs=idex_attrs.get_variable_attributes("tof_low_attrs"),
         )
         tof_mid_xr = xr.DataArray(
             name="TOF_Mid",
             data=[self._parse_high_sample_waveform(self.TOF_Mid_bits)],
-            dims=("epoch", "time_high_sr"),
+            dims=("epoch", "time_high_sr_dim"),
             attrs=idex_attrs.get_variable_attributes("tof_mid_attrs"),
         )
         target_high_xr = xr.DataArray(
             name="Target_High",
             data=[self._parse_low_sample_waveform(self.Target_High_bits)],
-            dims=("epoch", "time_low_sr"),
+            dims=("epoch", "time_low_sr_dim"),
             attrs=idex_attrs.get_variable_attributes("target_high_attrs"),
         )
         target_low_xr = xr.DataArray(
             name="Target_Low",
             data=[self._parse_low_sample_waveform(self.Target_Low_bits)],
-            dims=("epoch", "time_low_sr"),
+            dims=("epoch", "time_low_sr_dim"),
             attrs=idex_attrs.get_variable_attributes("target_low_attrs"),
         )
         ion_grid_xr = xr.DataArray(
             name="Ion_Grid",
             data=[self._parse_low_sample_waveform(self.Ion_Grid_bits)],
-            dims=("epoch", "time_low_sr"),
+            dims=("epoch", "time_low_sr_dim"),
             attrs=idex_attrs.get_variable_attributes("ion_grid_attrs"),
         )
 

imap_processing/idex/idex_l1b.py

@@ -0,0 +1,192 @@
+"""
+Perform IDEX L1b Processing.
+
+Examples
+--------
+.. code-block:: python
+
+    from imap_processing.idex.idex_l1a import PacketParser
+    from imap_processing.idex.idex_l1b import idex_l1b
+
+    l0_file = "imap_processing/tests/idex/imap_idex_l0_sci_20231214_v001.pkts"
+    l1a_data = PacketParser(l0_file, data_version)
+    l1b_data = idex_l1b(l1a_data, data_version)
+    write_cdf(l1b_data)
+"""
+
+import logging
+from enum import Enum
+
+import pandas as pd
+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 convert_raw_to_eu
+
+logger = logging.getLogger(__name__)
+
+
+class ConversionFactors(float, Enum):
+    """Enum class for conversion factor values."""
+
+    TOF_High = 2.89e-4
+    TOF_Low = 5.14e-4
+    TOF_Mid = 1.13e-2
+    Target_Low = 1.58e1
+    Target_High = 1.63e-1
+    Ion_Grid = 7.46e-4
+
+
+def idex_l1b(l1a_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
+    """
+    Will process IDEX l1a data to create l1b data products.
+
+    Parameters
+    ----------
+    l1a_dataset : xarray.Dataset
+        IDEX L1a dataset to process.
+    data_version : str
+        Version of the data product being created.
+
+    Returns
+    -------
+    l1b_dataset : xarray.Dataset
+        The``xarray`` dataset containing the science data and supporting metadata.
+    """
+    logger.info(
+        f"Running IDEX L1B processing on dataset: {l1a_dataset.attrs['Logical_source']}"
+    )
+
+    # create the attribute manager for this data level
+    idex_attrs = ImapCdfAttributes()
+    idex_attrs.add_instrument_global_attrs(instrument="idex")
+    idex_attrs.add_instrument_variable_attrs(instrument="idex", level="l1b")
+    idex_attrs.add_global_attribute("Data_version", data_version)
+
+    var_information_path = (
+        f"{imap_module_directory}/idex/idex_variable_unpacking_and_eu_conversion.csv"
+    )
+    # Read in csv that contains instrument variable setting information
+    var_information_df = pd.read_csv(var_information_path)
+
+    processed_vars = unpack_instrument_settings(
+        l1a_dataset, var_information_df, idex_attrs
+    )
+
+    waveforms_converted = convert_waveforms(l1a_dataset, idex_attrs)
+
+    epoch_da = xr.DataArray(
+        l1a_dataset["epoch"],
+        name="epoch",
+        dims=["epoch"],
+        attrs=idex_attrs.get_variable_attributes("epoch"),
+    )
+    # Create l1b Dataset
+    l1b_dataset = xr.Dataset(
+        coords={"epoch": epoch_da},
+        data_vars=processed_vars | waveforms_converted,
+        attrs=idex_attrs.get_global_attributes("imap_idex_l1b_sci"),
+    )
+    # Convert variables
+    l1b_dataset = convert_raw_to_eu(
+        l1b_dataset,
+        conversion_table_path=var_information_path,
+        packet_name="IDEX_SCI",
+    )
+    vars_to_copy = [
+        "shcoarse",
+        "shfine",
+        "time_high_sr",
+        "time_low_sr",
+        "time_high_sr_label",
+        "time_low_sr_label",
+    ]
+    # Copy arrays from the l1a_dataset that do not need l1b processing
+    for var in vars_to_copy:
+        l1b_dataset[var] = l1a_dataset[var].copy()
+
+    # TODO: Add TriggerMode and TriggerLevel attr
+    # TODO: Spice data?
+
+    logger.info("IDEX L1B science data processing completed.")
+
+    return l1b_dataset
+
+
+def unpack_instrument_settings(
+    l1a_dataset: xr.Dataset,
+    var_information_df: pd.DataFrame,
+    idex_attrs: ImapCdfAttributes,
+) -> dict[str, xr.DataArray]:
+    """
+    Unpack raw telemetry data from the l1a dataset into individual variables.
+
+    Parameters
+    ----------
+    l1a_dataset : xarray.Dataset
+        IDEX L1a dataset containing the 6 waveform arrays.
+    var_information_df : pd.DataFrame
+        Pandas data frame that contains information about each variable
+        (e.g., bit-size, starting bit, and padding). This is used to unpack raw
+        telemetry data from the input dataset (`l1a_dataset`).
+    idex_attrs : ImapCdfAttributes
+        CDF attribute manager object.
+
+    Returns
+    -------
+    telemetry_data : dict
+        A dictionary where the keys are the instrument setting array names and the
+        values are the unpacked xr.DataArrays.
+    """
+    telemetry_data = {}
+
+    for _, row in var_information_df.iterrows():
+        unpacked_name = row["mnemonic"]
+
+        # Create binary mask of the size of the variable in bits
+        mask = (1 << row["unsigned_nbits"]) - 1
+        # Determine the number of bits to shift
+        shift = row["starting_bit"] - row["nbits_padding_before"]
+        # Get the unpacked value by shifting the data to align the desired bits with
+        # the least significant bits and applying the mask to isolate the target bits
+        unpacked_val = (l1a_dataset[row["var_name"]].data >> shift) & mask
+
+        telemetry_data[unpacked_name] = xr.DataArray(
+            name=unpacked_name,
+            data=unpacked_val,
+            dims=("epoch"),
+            attrs=idex_attrs.get_variable_attributes(unpacked_name),
+        )
+
+    return telemetry_data
+
+
+def convert_waveforms(
+    l1a_dataset: xr.Dataset, idex_attrs: ImapCdfAttributes
+) -> dict[str, xr.DataArray]:
+    """
+    Apply transformation from raw DN to picocoulombs (pC) for each of the six waveforms.
+
+    Parameters
+    ----------
+    l1a_dataset : xarray.Dataset
+        IDEX L1a dataset containing the six waveform arrays.
+    idex_attrs : ImapCdfAttributes
+        CDF attribute manager object.
+
+    Returns
+    -------
+    waveforms_converted : dict
+        A dictionary where the keys are the waveform array names and the values are
+        xr.DataArrays representing the waveforms transformed into picocoulombs.
+    """
+    waveforms_pc = {}
+
+    for var in ConversionFactors:
+        waveforms_pc[var.name] = l1a_dataset[var.name] * var.value
+        waveforms_pc[var.name].attrs = idex_attrs.get_variable_attributes(
+            var.name.lower()
+        )
+
+    return waveforms_pc

imap_processing/idex/idex_variable_unpacking_and_eu_conversion.csv

@@ -0,0 +1,33 @@
+index,mnemonic,var_name,starting_bit,nbits_padding_before,unsigned_nbits,unit,c0,c1,c2,c3,c4,c5,c6,c7,convertAs,packetName
+1,current_1v_pol,idx__txhdrprochkch01,4,4,12,mA,0,0.9029253,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+2,current_1p9v_pol,idx__txhdrprochkch01,20,4,12,mA,0,0.9029253,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+3,temperature_1,idx__txhdrprochkch23,4,4,12,C,162.8276,-0.2668687,0.000332379,-2.43E-07,9.03E-11,-1.33E-14,0.00E+00,0.00E+00,UNSEGMENTED_POLY,IDEX_SCI
+4,temperature_2,idx__txhdrprochkch23,20,4,12,C,162.8276,-0.2668687,0.000332379,-2.43E-07,9.03E-11,-1.33E-14,0.00E+00,0.00E+00,UNSEGMENTED_POLY,IDEX_SCI
+5,voltage_1v_bus,idx__txhdrprochkch45,4,4,12,V,0,0.000805861,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+6,fpga_temperature,idx__txhdrprochkch45,20,4,12,C,358.31,-0.1187104,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+7,voltage_1p9v_bus,idx__txhdrprochkch67,4,4,12,V,0,0.000805861,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+8,voltage_3p3v_bus,idx__txhdrprochkch67,20,4,12,V,0,0.001611722,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+9,detector_voltage,idx__txhdrhvpshkch01,4,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+10,sensor_voltage,idx__txhdrhvpshkch01,20,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+11,target_voltage,idx__txhdrhvpshkch23,4,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+12,reflectron_voltage,idx__txhdrhvpshkch23,20,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+13,rejection_voltage,idx__txhdrhvpshkch45,4,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+14,current_hvps_sensor,idx__txhdrhvpshkch45,20,4,12,mA,0,7.33E-06,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+15,positive_current_hvps,idx__txhdrhvpshkch67,4,4,12,mA,0,2.43E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+16,negative_current_hvps,idx__txhdrhvpshkch67,20,4,12,mA,0,2.43E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+17,voltage_3p3_ref,idx__txhdrlvhk0ch01,4,4,12,V,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+18,voltage_3p3_op_ref,idx__txhdrlvhk0ch01,20,4,12,V,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+19,voltage_neg6v_bus,idx__txhdrlvhk0ch23,4,4,12,V,-33,0.00886447,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+20,voltage_pos6v_bus,idx__txhdrlvhk0ch23,20,4,12,V,0,0.00241758,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+21,voltage_pos16v_bus,idx__txhdrlvhk0ch45,4,4,12,V,0,0.00482711,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+22,voltage_pos3p3v_bus,idx__txhdrlvhk0ch45,20,4,12,V,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+23,voltage_neg5v_bus,idx__txhdrlvhk0ch67,4,4,12,V,-33,0.00886447,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+24,voltage_pos5v_bus,idx__txhdrlvhk0ch67,20,4,12,V,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+25,current_3p3_bus,idx__txhdrlvhk1ch01,4,4,12,A,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+26,current_16v_bus,idx__txhdrlvhk1ch01,20,4,12,A,0,0.000161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+27,current_6v_bus,idx__txhdrlvhk1ch23,4,4,12,A,0,8.06E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+28,current_neg6v_bus,idx__txhdrlvhk1ch23,20,4,12,A,0,-8.06E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+29,current_5v_bus,idx__txhdrlvhk1ch45,4,4,12,A,0,4.03E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+30,current_neg5v_bus,idx__txhdrlvhk1ch45,20,4,12,A,0,-2.01E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+31,current_2p5v_bus,idx__txhdrlvhk1ch67,4,4,12,A,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+32,current_neg2p5v_bus,idx__txhdrlvhk1ch67,20,4,12,A,0,-4.03E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI