imap-processing 0.14.0__py3-none-any.whl → 0.15.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
@@ -743,7 +757,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 +765,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 +858,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 +879,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 +928,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 +953,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

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,89 @@
+"""
+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 numpy as np
+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.
+
+    # Workaround to fix monitomically increasing epoch issue
+    epoch_attrs = cdf_attrs.get_variable_attributes("epoch", check_schema=False)
+    new_epoch_values = np.array([843543730220584064 + i for i in range(113)])
+    l2_dataset = l2_dataset.assign_coords(
+        epoch=("epoch", new_epoch_values, epoch_attrs)
+    )
+
+    logger.info(f"\nFinal data product:\n{l2_dataset}\n")
+
+    return l2_dataset

imap_processing/codice/constants.py

@@ -207,13 +207,13 @@ HI_COUNTERS_AGGREGATED_ACTIVE_VARIABLES = {
     "Reserved3": False,
     "Reserved4": False,
     "Reserved5": False,
-    "LowTOFCutoff": False,
-    "Reserved6": False,
-    "Reserved7": False,
+    "LowTOFCutoff": True,
+    "Reserved6": True,
+    "Reserved7": True,
     "ASIC1FlagInvalid": True,
     "ASIC2FlagInvalid": True,
-    "ASIC1ChannelInvalid": False,
-    "ASIC2ChannelInvalid": False,
+    "ASIC1ChannelInvalid": True,
+    "ASIC2ChannelInvalid": True,
 }
 HI_COUNTERS_AGGREGATED_VARIABLE_NAMES = [
     name
@@ -663,6 +663,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]] = {

imap_processing/ena_maps/ena_maps.py

@@ -620,6 +620,42 @@ class HiPointingSet(PointingSet):
         self.spatial_coords = ("spin_angle_bin",)
 
 
+class LoPointingSet(PointingSet):
+    """
+    PointingSet object specific to Lo L1C PSet data.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        Lo L1C pointing set data loaded in an xarray.DataArray.
+    """
+
+    def __init__(self, dataset: xr.Dataset):
+        super().__init__(dataset, spice_reference_frame=geometry.SpiceFrame.IMAP_DPS)
+        # TODO: Use spatial_utils.az_el_grid instead of
+        #  manually creating the lon/lat values
+        inferred_spacing_deg = 360 / dataset.longitude.size
+        longitude_bin_centers = np.arange(
+            0 + inferred_spacing_deg / 2, 360, inferred_spacing_deg
+        )
+        latitude_bin_centers = np.arange(
+            -2 + inferred_spacing_deg / 2, 2, inferred_spacing_deg
+        )
+
+        # Could be wrong about the order here
+        longitude_grid, latitude_grid = np.meshgrid(
+            longitude_bin_centers,
+            latitude_bin_centers,
+            indexing="ij",
+        )
+
+        longitude = longitude_grid.ravel()
+        latitude = latitude_grid.ravel()
+
+        self.az_el_points = np.column_stack((longitude, latitude))
+        self.spatial_coords = ("longitude", "latitude")
+
+
 # Define the Map classes
 class AbstractSkyMap(ABC):
     """
@@ -1119,7 +1155,7 @@ class RectangularSkyMap(AbstractSkyMap):
             )
         # Add the solid angle variable to the data_1d Dataset
         self.data_1d["solid_angle"] = xr.DataArray(
-            self.solid_angle_points[np.newaxis, :],
+            self.solid_angle_points[np.newaxis, :].astype(np.float32),
             name="solid_angle",
             dims=[CoordNames.TIME.value, CoordNames.GENERIC_PIXEL.value],
         )
@@ -1423,6 +1459,12 @@ class HealpixSkyMap(AbstractSkyMap):
                 {},
                 coords={**self.spatial_coords},
             )
+        # Add the solid angle variable to the data_1d Dataset
+        self.data_1d["solid_angle"] = xr.DataArray(
+            self.solid_angle_points[np.newaxis, :].astype(np.float32),
+            name="solid_angle",
+            dims=[CoordNames.TIME.value, CoordNames.GENERIC_PIXEL.value],
+        )
         # return the data_1d as is, but with the pixel coordinate
         # renamed to CoordNames.HEALPIX_INDEX.value
         return self.data_1d.rename(

imap_processing/glows/l2/glows_l2_data.py

@@ -34,8 +34,6 @@ class DailyLightcurve:
         ecliptic latitude of bin centers [deg]
     number_of_bins : int
         number of bins in lightcurve
-    raw_uncertainties : numpy.ndarray
-        statistical uncertainties for raw histograms (sqrt of self.raw_histograms)
     l1b_data : xarray.Dataset
         L1B data filtered by good times, good angles, and good bins.
     """
@@ -52,7 +50,6 @@ class DailyLightcurve:
     ecliptic_lon: np.ndarray = field(init=False)
     ecliptic_lat: np.ndarray = field(init=False)
     number_of_bins: int = field(init=False)
-    raw_uncertainties: np.ndarray = field(init=False)
     l1b_data: InitVar[xr.Dataset]
 
     def __post_init__(self, l1b_data: xr.Dataset) -> None:
@@ -76,14 +73,14 @@ class DailyLightcurve:
         self.exposure_times = self.calculate_exposure_times(
             l1b_data, exposure_times_per_timestamp
         )
-        self.raw_uncertainties = np.sqrt(self.raw_histograms)
+        raw_uncertainties = np.sqrt(self.raw_histograms)
         self.photon_flux = np.zeros(len(self.raw_histograms))
         self.flux_uncertainties = np.zeros(len(self.raw_histograms))
 
         # TODO: Only where exposure counts != 0
         if len(self.exposure_times) != 0:
             self.photon_flux = self.raw_histograms / self.exposure_times
-            self.flux_uncertainties = self.raw_uncertainties / self.exposure_times
+            self.flux_uncertainties = raw_uncertainties / self.exposure_times
 
         # TODO: Average this, or should they all be the same?
         self.spin_angle = np.average(l1b_data["imap_spin_angle_bin_cntr"].data, axis=0)
@@ -135,7 +132,7 @@ class DailyLightcurve:
             Sum of valid histograms across all timestamps.
         """
         histograms[histograms == -1] = 0
-        return np.sum(histograms, axis=0)
+        return np.sum(histograms, axis=0, dtype=np.int64)
 
 
 @dataclass

imap_processing/ialirt/l0/process_swe.py

@@ -550,11 +550,11 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
                 "utc": met_to_utc(grouped["met"].min()).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(grouped["met"].min())),
                 **{
-                    f"swe_normalized_counts_quarter_1_esa_{i}": Decimal(str(val))
+                    f"swe_normalized_counts_half_1_esa_{i}": Decimal(str(val))
                     for i, val in enumerate(summed_first)
                 },
                 **{
-                    f"swe_normalized_counts_quarter_2_esa_{i}": Decimal(str(val))
+                    f"swe_normalized_counts_half_2_esa_{i}": Decimal(str(val))
                     for i, val in enumerate(summed_second)
                 },
                 "swe_counterstreaming_electrons": max(bde_first_half, bde_second_half),

imap_processing/ialirt/utils/constants.py

@@ -0,0 +1,48 @@
+"""Keys for I-ALiRT data products."""
+
+IALIRT_KEYS = [
+    # Low energy (~300 keV) electrons (A-side)
+    "hit_e_a_side_low_en",
+    # Medium energy (~3 MeV) electrons (A-side)
+    "hit_e_a_side_med_en",
+    # High energy (>3 MeV) electrons (A-side)
+    "hit_e_a_side_high_en",
+    # Low energy (~300 keV) electrons (B-side)
+    "hit_e_b_side_low_en",
+    # Medium energy (~3 MeV) electrons (B-side)
+    "hit_e_b_side_med_en",
+    # High energy (>3 MeV) electrons (B-side)
+    "hit_e_b_side_high_en",
+    # Medium energy (12 to 70 MeV) protons (Omnidirectional)
+    "hit_h_omni_med_en",
+    # High energy (>70 MeV) protons (A-side)
+    "hit_h_a_side_high_en",
+    # High energy (>70 MeV) protons (B-side)
+    "hit_h_b_side_high_en",
+    # Low energy (6 to 8 MeV/nuc) He (Omnidirectional)
+    "hit_he_omni_low_en",
+    # High energy (15 to 70 MeV/nuc) He (Omnidirectional)
+    "hit_he_omni_high_en",
+    # Magnetic field vector in GSE coordinates
+    "mag_4s_b_gse",
+    # Magnetic field vector in GSM coordinates
+    "mag_4s_b_gsm",
+    # Magnetic field vector in RTN coordinates
+    "mag_4s_b_rtn",
+    # Azimuth angle (φ) of the magnetic field in GSM coordinates
+    "mag_phi_4s_b_gsm",
+    # Elevation angle (θ) of the magnetic field in GSM coordinates
+    "mag_theta_4s_b_gsm",
+    # Pseudo density of solar wind protons
+    "swapi_pseudo_proton_density",
+    # Pseudo speed of solar wind protons in solar inertial frame
+    "swapi_pseudo_proton_speed",
+    # Pseudo temperature of solar wind protons in plasma frame
+    "swapi_pseudo_proton_temperature",
+    # SWE Normalized Counts - Half Cycle 1
+    *[f"swe_normalized_counts_half_1_esa_{i}" for i in range(8)],
+    # SWE Normalized Counts - Half Cycle 2
+    *[f"swe_normalized_counts_half_2_esa_{i}" for i in range(8)],
+    # SWE Counterstreaming flag
+    "swe_counterstreaming_electrons",
+]