imap-processing 0.19.0__py3-none-any.whl → 0.19.2__py3-none-any.whl

imap_processing/codice/codice_l1a.py

@@ -125,7 +125,7 @@ class CoDICEL1aPipeline:
         # orientation and the azimuth determine which spin sector the data
         # gets stored in.
         # TODO: All these nested for-loops are bad. Try to find a better
-        #       solution.
+        #       solution. See GitHub issue #2136.
         for i, epoch_data in enumerate(self.data):
             for energy_index in range(num_energies):
                 pixel_orientation = constants.PIXEL_ORIENTATIONS[energy_index]
@@ -345,7 +345,7 @@ class CoDICEL1aPipeline:
             # energy dimension
             # TODO: This bit of code may no longer be needed once I can figure
             #       out how to run hi-sectored product through the
-            #       create_binned_dataset function
+            #       create_binned_dataset function. See GitHub issue #2137.
             if self.config["dataset_name"] == "imap_codice_l1a_hi-sectored":
                 dims = [
                     f"energy_{variable_name}" if item == "esa_step" else item
@@ -367,7 +367,7 @@ class CoDICEL1aPipeline:
         # longer need the "esa_step" coordinate
         # TODO: This bit of code may no longer be needed once I can figure
         #       out how to run hi-sectored product through the
-        #       create_binned_dataset function
+        #       create_binned_dataset function. See GitHub issue #2137.
         if self.config["dataset_name"] == "imap_codice_l1a_hi-sectored":
             for species in self.config["energy_table"]:
                 dataset = self.define_energy_bins(dataset, species)
@@ -822,9 +822,6 @@ def group_ialirt_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"
@@ -880,7 +877,7 @@ def create_binned_dataset(
         Xarray dataset containing the final processed dataset.
     """
     # TODO: hi-sectored data product should be processed similar to hi-omni,
-    #       so I should be able to use this method.
+    #       so I should be able to use this method. See GitHub issue #2137.
 
     # Get the four "main" parameters for processing
     table_id, plan_id, plan_step, view_id = get_params(dataset)
@@ -901,7 +898,7 @@ def create_binned_dataset(
         attrs=pipeline.cdf_attrs.get_variable_attributes("epoch", check_schema=False),
     )
     # TODO: Figure out how to calculate epoch centers and deltas and store them
-    #       in variables here
+    #       in variables here. See GitHub issue #1501.
     dataset = xr.Dataset(
         coords={"epoch": coord},
         attrs=pipeline.cdf_attrs.get_global_attributes(pipeline.config["dataset_name"]),
@@ -941,7 +938,7 @@ def create_binned_dataset(
     return dataset
 
 
-def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
+def create_direct_event_dataset(apid: int, unpacked_dataset: xr.Dataset) -> xr.Dataset:
     """
     Create dataset for direct event data.
 
@@ -955,7 +952,7 @@ def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
     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,
+    the unpacked_dataset 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.
@@ -964,8 +961,8 @@ def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
     ----------
     apid : int
         The APID of the packet.
-    packets : xarray.Dataset
-        The packets to process.
+    unpacked_dataset : xarray.Dataset
+        The unpacked dataset to process.
 
     Returns
     -------
@@ -973,13 +970,13 @@ def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
         Xarray dataset containing the direct event data.
     """
     # Group and decompress the data
-    grouped_data = group_data(packets)
+    grouped_data = group_data(unpacked_dataset)
     decompressed_data = [
         decompress(group, CoDICECompression.LOSSLESS) for group in grouped_data
     ]
 
     # Reshape the packet data into CDF-ready variables
-    data = reshape_de_data(packets, decompressed_data, apid)
+    reshaped_de_data = reshape_de_data(unpacked_dataset, decompressed_data, apid)
 
     # Gather the CDF attributes
     cdf_attrs = ImapCdfAttributes()
@@ -989,11 +986,11 @@ def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
     # Determine the epochs to use in the dataset, which are the epochs whenever
     # there is a start of a segment and the priority is 0
     epoch_indices = np.where(
-        ((packets.seq_flgs.data == 3) | (packets.seq_flgs.data == 1))
-        & (packets.priority.data == 0)
+        ((unpacked_dataset.seq_flgs.data == 3) | (unpacked_dataset.seq_flgs.data == 1))
+        & (unpacked_dataset.priority.data == 0)
     )[0]
-    acq_start_seconds = packets.acq_start_seconds[epoch_indices]
-    acq_start_subseconds = packets.acq_start_subseconds[epoch_indices]
+    acq_start_seconds = unpacked_dataset.acq_start_seconds[epoch_indices]
+    acq_start_subseconds = unpacked_dataset.acq_start_subseconds[epoch_indices]
 
     # Calculate epoch variables
     epochs, epochs_delta_minus, epochs_delta_plus = calculate_epoch_values(
@@ -1051,20 +1048,19 @@ def create_direct_event_dataset(apid: int, packets: xr.Dataset) -> xr.Dataset:
     )
 
     # Create the CDF data variables for each Priority and Field
-    for i in range(constants.DE_DATA_PRODUCT_CONFIGURATIONS[apid]["num_priorities"]):
-        for field in constants.DE_DATA_PRODUCT_CONFIGURATIONS[apid]["cdf_fields"]:
-            variable_name = f"p{i}_{field}"
-            attrs = cdf_attrs.get_variable_attributes(variable_name)
-            if field in ["num_events", "data_quality"]:
-                dims = ["epoch"]
-            else:
-                dims = ["epoch", "event_num"]
-            dataset[variable_name] = xr.DataArray(
-                np.array(data[variable_name]),
-                name=variable_name,
-                dims=dims,
-                attrs=attrs,
-            )
+    for field in constants.DE_DATA_PRODUCT_CONFIGURATIONS[apid]["cdf_fields"]:
+        if field in ["num_events", "data_quality"]:
+            attrs = cdf_attrs.get_variable_attributes("de_2d_attrs")
+            dims = ["epoch", "priority"]
+        else:
+            attrs = cdf_attrs.get_variable_attributes("de_3d_attrs")
+            dims = ["epoch", "priority", "event_num"]
+        dataset[field] = xr.DataArray(
+            np.array(reshaped_de_data[field]),
+            name=field,
+            dims=dims,
+            attrs=attrs,
+        )
 
     return dataset
 
@@ -1490,7 +1486,7 @@ def reshape_de_data(
         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] = {}
+    de_data: dict[str, np.ndarray] = {}
 
     # Extract some useful variables
     num_priorities = constants.DE_DATA_PRODUCT_CONFIGURATIONS[apid]["num_priorities"]
@@ -1510,18 +1506,20 @@ def reshape_de_data(
 
     # 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 bit_structure:
-            if field not in ["Priority", "Spare"]:
-                data[f"p{priority_num}_{field}"] = np.full(
-                    (num_epochs, 10000),
-                    bit_structure[field]["fillval"],
-                    dtype=bit_structure[field]["dtype"],
-                )
-        data[f"p{priority_num}_num_events"] = np.full(
-            num_epochs, 65535, dtype=np.uint16
-        )
-        data[f"p{priority_num}_data_quality"] = np.full(num_epochs, 255, dtype=np.uint8)
+    for field in bit_structure:
+        # if these two, no need to store
+        if field not in ["Priority", "Spare"]:
+            de_data[f"{field}"] = np.full(
+                (num_epochs, num_priorities, 10000),
+                bit_structure[field]["fillval"],
+                dtype=bit_structure[field]["dtype"],
+            )
+    # Add other additional fields of l1a
+    de_data["num_events"] = np.full(
+        (num_epochs, num_priorities), 65535, dtype=np.uint16
+    )
+
+    de_data["data_quality"] = np.full((num_epochs, num_priorities), 255, dtype=np.uint8)
 
     # decompressed_data is one large list of values of length
     # (<number of epochs> * <number of priorities>)
@@ -1545,8 +1543,8 @@ def reshape_de_data(
 
             # Number of events and data quality can be determined at this stage
             num_events = num_events_arr[epoch_start:epoch_end][i]
-            data[f"p{priority_num}_num_events"][epoch_index] = num_events
-            data[f"p{priority_num}_data_quality"][epoch_index] = data_quality[i]
+            de_data["num_events"][epoch_index, priority_num] = num_events
+            de_data["data_quality"][epoch_index, priority_num] = data_quality[i]
 
             # Iterate over each event
             for event_index in range(num_events):
@@ -1577,12 +1575,12 @@ def reshape_de_data(
                     )
 
                     # Set the value into the data array
-                    data[f"p{priority_num}_{field_name}"][epoch_index, event_index] = (
+                    de_data[f"{field_name}"][epoch_index, priority_num, event_index] = (
                         value
                     )
                     bit_position += field_components["bit_length"]
 
-    return data
+    return de_data
 
 
 def process_codice_l1a(file_path: Path) -> list[xr.Dataset]:

imap_processing/codice/codice_l1b.py

@@ -9,18 +9,18 @@ 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 import imap_module_directory
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.cdf.utils import load_cdf
 from imap_processing.codice import constants
+from imap_processing.codice.utils import CODICEAPID
+from imap_processing.utils import packet_file_to_datasets
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -49,9 +49,6 @@ def convert_to_rates(
     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",
@@ -65,6 +62,13 @@ def convert_to_rates(
     ]:
         # Applying rate calculation described in section 10.2 of the algorithm
         # document
+        # In order to divide by acquisition times, we must reshape the acq
+        # time data array to match the data variable shape
+        dims = [1] * dataset[variable_name].data.ndim
+        dims[1] = 128
+        acq_times = dataset.acquisition_time_per_step.data.reshape(dims)
+
+        # Now perform the calculation
         rates_data = dataset[variable_name].data / (
             acq_times
             * 1e-6  # Converting from microseconds to seconds
@@ -83,10 +87,8 @@ def convert_to_rates(
         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
+            * constants.HI_ACQUISITION_TIME
         )
-    elif descriptor == "hskp":
-        rates_data = dataset[variable_name].data / acq_times
 
     return rates_data
 
@@ -131,35 +133,43 @@ def process_codice_l1b(file_path: Path) -> xr.Dataset:
     # 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
-    # Housekeeping and binned datasets are treated a bit differently since
-    # not all variables need to be converted
+    # TODO: This was thrown together quickly and should be double-checked
     if descriptor == "hskp":
-        # 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"]
+        xtce_filename = "codice_packet_definition.xml"
+        xtce_packet_definition = Path(
+            f"{imap_module_directory}/codice/packet_definitions/{xtce_filename}"
+        )
+        packet_file = (
+            imap_module_directory
+            / "tests"
+            / "codice"
+            / "data"
+            / "imap_codice_l0_raw_20241110_v001.pkts"
+        )
+        datasets: dict[int, xr.Dataset] = packet_file_to_datasets(
+            packet_file, xtce_packet_definition, use_derived_value=True
+        )
+        l1b_dataset = datasets[CODICEAPID.COD_NHK]
+
+        # TODO: Drop the same variables as we do in L1a? (see line 1103 in
+        #       codice_l1a.py
+
     else:
         variables_to_convert = getattr(
             constants, f"{descriptor.upper().replace('-', '_')}_VARIABLE_NAMES"
         )
 
-    # Apply the conversion to rates
-    for variable_name in variables_to_convert:
-        l1b_dataset[variable_name].data = convert_to_rates(
-            l1b_dataset, descriptor, variable_name
-        )
-
-        # Set the variable attributes
-        cdf_attrs_key = f"{descriptor}-{variable_name}"
-        l1b_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
-            cdf_attrs_key, check_schema=False
-        )
+        # Apply the conversion to rates
+        for variable_name in variables_to_convert:
+            l1b_dataset[variable_name].data = convert_to_rates(
+                l1b_dataset, descriptor, variable_name
+            )
+
+            # Set the variable attributes
+            cdf_attrs_key = f"{descriptor}-{variable_name}"
+            l1b_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
+                cdf_attrs_key, check_schema=False
+            )
 
     logger.info(f"\nFinal data product:\n{l1b_dataset}\n")
 

imap_processing/codice/codice_l2.py

@@ -12,10 +12,12 @@ 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
+from imap_processing.codice.constants import HALF_SPIN_LUT
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -54,6 +56,14 @@ def process_codice_l2(file_path: Path) -> xr.Dataset:
     cdf_attrs = ImapCdfAttributes()
     l2_dataset = add_dataset_attributes(l2_dataset, dataset_name, cdf_attrs)
 
+    # TODO: update list of datasets that need geometric factors (if needed)
+    # Compute geometric factors needed for intensity calculations
+    if dataset_name in [
+        "imap_codice_l2_lo-sw-species",
+        "imap_codice_l2_lo-nsw-species",
+    ]:
+        geometric_factors = compute_geometric_factors(l2_dataset)
+
     if dataset_name in [
         "imap_codice_l2_hi-counters-singles",
         "imap_codice_l2_hi-counters-aggregated",
@@ -63,6 +73,7 @@ def process_codice_l2(file_path: Path) -> xr.Dataset:
         "imap_codice_l2_lo-nsw-priority",
     ]:
         # No changes needed. Just save to an L2 CDF file.
+        # TODO: May not even need L2 files for these products
         pass
 
     elif dataset_name == "imap_codice_l2_hi-direct-events":
@@ -117,6 +128,8 @@ def process_codice_l2(file_path: Path) -> xr.Dataset:
         # Calculate the pickup ion sunward solar wind intensities using equation
         # described in section 11.2.4 of algorithm document.
         # Hopefully this can also apply to lo-ialirt
+        # TODO: WIP - needs to be completed
+        l2_dataset = process_lo_sw_species(l2_dataset, geometric_factors)
         pass
 
     elif dataset_name == "imap_codice_l2_lo-nsw-species":
@@ -132,14 +145,14 @@ def process_codice_l2(file_path: Path) -> xr.Dataset:
 
 
 def add_dataset_attributes(
-    l2_dataset: xr.Dataset, dataset_name: str, cdf_attrs: ImapCdfAttributes
+    dataset: xr.Dataset, dataset_name: str, cdf_attrs: ImapCdfAttributes
 ) -> xr.Dataset:
     """
     Add the global and variable attributes to the dataset.
 
     Parameters
     ----------
-    l2_dataset : xarray.Dataset
+    dataset : xarray.Dataset
         The dataset to update.
     dataset_name : str
         The name of the dataset.
@@ -155,12 +168,12 @@ def add_dataset_attributes(
     cdf_attrs.add_instrument_variable_attrs("codice", "l2")
 
     # Update the global attributes
-    l2_dataset.attrs = cdf_attrs.get_global_attributes(dataset_name)
+    dataset.attrs = cdf_attrs.get_global_attributes(dataset_name)
 
     # Set the variable attributes
-    for variable_name in l2_dataset.data_vars.keys():
+    for variable_name in dataset.data_vars.keys():
         try:
-            l2_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
+            dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
                 variable_name, check_schema=False
             )
         except KeyError:
@@ -169,7 +182,7 @@ def add_dataset_attributes(
             descriptor = dataset_name.split("imap_codice_l2_")[-1]
             cdf_attrs_key = f"{descriptor}-{variable_name}"
             try:
-                l2_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
+                dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
                     f"{cdf_attrs_key}", check_schema=False
                 )
             except KeyError:
@@ -177,4 +190,89 @@ def add_dataset_attributes(
                     f"Field '{variable_name}' and '{cdf_attrs_key}' not found in "
                     f"attribute manager."
                 )
-    return l2_dataset
+    return dataset
+
+
+def compute_geometric_factors(dataset: xr.Dataset) -> np.ndarray:
+    """
+    Calculate geometric factors needed for intensity calculations.
+
+    Geometric factors are determined by comparing the half-spin values per
+    esa_step in the HALF_SPIN_LUT to the rgfo_half_spin values in the provided
+    L2 dataset.
+
+    If the half-spin value is less than the corresponding rgfo_half_spin value,
+    the geometric factor is set to 0.75 (full mode); otherwise, it is set to 0.5
+    (reduced mode).
+
+    NOTE: Half spin values are associated with ESA steps which corresponds to the
+    index of the energy_per_charge dimension that is between 0 and 127.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        The L2 dataset containing rgfo_half_spin data variable.
+
+    Returns
+    -------
+    geometric_factors : np.ndarray
+        A 2D array of geometric factors with shape (epoch, esa_steps).
+    """
+    # Convert the HALF_SPIN_LUT to a reverse mapping of esa_step to half_spin
+    esa_step_to_half_spin_map = {
+        val: key for key, vals in HALF_SPIN_LUT.items() for val in vals
+    }
+
+    # Create a list of half_spin values corresponding to ESA steps (0 to 127)
+    half_spin_values = np.array(
+        [esa_step_to_half_spin_map[step] for step in range(128)]
+    )
+
+    # Expand dimensions to compare each rgfo_half_spin value against
+    # all half_spin_values
+    rgfo_half_spin = dataset.rgfo_half_spin.data[:, np.newaxis]  # Shape: (epoch, 1)
+
+    # Perform the comparison and calculate geometric factors
+    geometric_factors = np.where(half_spin_values < rgfo_half_spin, 0.75, 0.5)
+
+    return geometric_factors
+
+
+def process_lo_sw_species(
+    dataset: xr.Dataset, geometric_factors: np.ndarray
+) -> xr.Dataset:
+    """
+    Process the lo-sw-species L2 dataset to calculate species intensities.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        The L2 dataset to process.
+    geometric_factors : np.ndarray
+        The geometric factors array with shape (epoch, esa_steps).
+
+    Returns
+    -------
+    xarray.Dataset
+        The updated L2 dataset with species intensities calculated.
+    """
+    # TODO: WIP - implement intensity calculations
+    # valid_solar_wind_vars = [
+    #     "hplus",
+    #     "heplusplus",
+    #     "cplus4",
+    #     "cplus5",
+    #     "cplus6",
+    #     "oplus5",
+    #     "oplus6",
+    #     "oplus7",
+    #     "oplus8",
+    #     "ne",
+    #     "mg",
+    #     "si",
+    #     "fe_loq",
+    #     "fe_hiq",
+    # ]
+    # valid_pick_up_ion_vars = ["heplus", "cnoplus"]
+
+    return dataset

imap_processing/codice/constants.py

@@ -60,6 +60,7 @@ CODICEAPID_MAPPING = {
 # Numerical constants
 SPIN_PERIOD_CONVERSION = 0.00032
 K_FACTOR = 5.76  # This is used to convert voltages to energies in L2
+HI_ACQUISITION_TIME = 0.59916
 
 # CDF variable names used for lo data products
 LO_COUNTERS_SINGLES_VARIABLE_NAMES = ["apd_singles"]
@@ -172,8 +173,6 @@ 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
-#       underscores?
 LO_COUNTERS_AGGREGATED_ACTIVE_VARIABLES = {
     "tcr": True,
     "dcr": True,
@@ -438,7 +437,7 @@ DATA_PRODUCT_CONFIGURATIONS: dict[CODICEAPID | int, dict] = {
         "instrument": "hi",
         "num_counters": len(
             HI_COUNTERS_AGGREGATED_VARIABLE_NAMES
-        ),  # The number of counters depends on the number of active counters
+        ),  # The number of counters depends on the number of *active* counters
         "support_variables": ["data_quality", "spin_period"],
         "variable_names": HI_COUNTERS_AGGREGATED_VARIABLE_NAMES,
     },
@@ -527,7 +526,7 @@ DATA_PRODUCT_CONFIGURATIONS: dict[CODICEAPID | int, dict] = {
         "instrument": "lo",
         "num_counters": len(
             LO_COUNTERS_AGGREGATED_VARIABLE_NAMES
-        ),  # The number of counters depends on the number of active counters
+        ),  # The number of counters depends on the number of *active* counters
         "support_variables": [
             "energy_table",
             "acquisition_time_per_step",
@@ -689,9 +688,9 @@ L1B_DATA_PRODUCT_CONFIGURATIONS: dict[str, dict] = {
         "num_spin_sectors": 24,
         "num_spins": 4,
     },
-    "hi-priority": {  # TODO: Ask Joey to define these
-        "num_spin_sectors": 1,
-        "num_spins": 1,
+    "hi-priority": {
+        "num_spin_sectors": 24,
+        "num_spins": 16,
     },
     "hi-sectored": {
         "num_spin_sectors": 2,
@@ -849,7 +848,7 @@ DE_DATA_PRODUCT_CONFIGURATIONS: dict[Any, dict[str, Any]] = {
 }
 
 # Define the packet fields needed to be stored in segmented data and their
-# corresponding bit lengths for direct event data products
+# corresponding bit lengths for I-ALiRT data products
 IAL_BIT_STRUCTURE = {
     "SHCOARSE": 32,
     "PACKET_VERSION": 16,
@@ -1657,6 +1656,8 @@ PIXEL_ORIENTATIONS = {
 # processing. These are taken from the "Acq Time" column in the "Lo Stepping"
 # tab of the "*-SCI-LUT-*.xml" spreadsheet that largely defines CoDICE
 # processing.
+# TODO: Do away with this lookup table and instead calculate the acquisition
+#       times. See GitHub issue #1945.
 ACQUISITION_TIMES = {
     0: [
         578.70833333,
@@ -2179,3 +2180,44 @@ ACQUISITION_TIMES = {
         96.45138889,
     ],
 }
+
+# TODO: Update EFFICIENCY value when better information is available.
+# Constant for CoDICE Intensity calculations.
+EFFICIENCY = 1
+
+# Lookup table for mapping half-spin (keys) to esa steps (values)
+# This is used to determine geometry factors L2
+HALF_SPIN_LUT = {
+    0: [0],
+    1: [1],
+    2: [2],
+    3: [3],
+    4: [4, 5],
+    5: [6, 7],
+    6: [8, 9],
+    7: [10, 11],
+    8: [12, 13, 14],
+    9: [15, 16, 17],
+    10: [18, 19, 20],
+    11: [21, 22, 23],
+    12: [24, 25, 26, 27],
+    13: [28, 29, 30, 31],
+    14: [32, 33, 34, 35],
+    15: [36, 37, 38, 39],
+    16: [40, 41, 42, 43, 44],
+    17: [45, 46, 47, 48, 49],
+    18: [50, 51, 52, 53, 54],
+    19: [55, 56, 57, 58, 59],
+    20: [60, 61, 62, 63, 64],
+    21: [65, 66, 67, 68, 69],
+    22: [70, 71, 72, 73, 74],
+    23: [75, 76, 77, 78, 79],
+    24: [80, 81, 82, 83, 84, 85],
+    25: [86, 87, 88, 89, 90, 91],
+    26: [92, 93, 94, 95, 96, 97],
+    27: [98, 99, 100, 101, 102, 103],
+    28: [104, 105, 106, 107, 108, 109],
+    29: [110, 111, 112, 113, 114, 115],
+    30: [116, 117, 118, 119, 120, 121],
+    31: [122, 123, 124, 125, 126, 127],
+}

imap_processing/codice/data/lo_stepping_values.csv

@@ -1,4 +1,4 @@
-table_num,row_num,num_reps,store_data,e1,e2,e3,e4,e5,e6,e7,e8,acq_time
+table_num,half_spin_num,num_reps,store_data,e1,e2,e3,e4,e5,e6,e7,e8,acq_time
 0,0,1,12,0,-,-,-,-,-,-,-,578.708333
 0,1,1,12,1,-,-,-,-,-,-,-,578.708333
 0,2,1,12,2,-,-,-,-,-,-,-,578.708333