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

imap_processing/cli.py

@@ -36,7 +36,10 @@ from imap_data_access.processing_input import (
 
 import imap_processing
 from imap_processing._version import __version__, __version_tuple__  # noqa: F401
-from imap_processing.ancillary.ancillary_dataset_combiner import MagAncillaryCombiner
+from imap_processing.ancillary.ancillary_dataset_combiner import (
+    GlowsAncillaryCombiner,
+    MagAncillaryCombiner,
+)
 from imap_processing.cdf.utils import load_cdf, write_cdf
 
 # TODO: change how we import things and also folder
@@ -59,7 +62,6 @@ from imap_processing.idex.idex_l1a import PacketParser
 from imap_processing.idex.idex_l1b import idex_l1b
 from imap_processing.idex.idex_l2a import idex_l2a
 from imap_processing.idex.idex_l2b import idex_l2b
-from imap_processing.idex.idex_l2c import idex_l2c
 from imap_processing.lo.l1a import lo_l1a
 from imap_processing.lo.l1b import lo_l1b
 from imap_processing.lo.l1c import lo_l1c
@@ -379,7 +381,7 @@ class ProcessInstrument(ABC):
         data_level: str,
         data_descriptor: str,
         dependency_str: str,
-        start_date: str | None,
+        start_date: str,
         repointing: str | None,
         version: str,
         upload_to_sdc: bool,
@@ -686,11 +688,58 @@ class Glows(ProcessInstrument):
             science_files = dependencies.get_file_paths(source="glows")
             if len(science_files) != 1:
                 raise ValueError(
-                    f"GLOWS L1A requires exactly one input science file, received: "
+                    f"GLOWS L1B requires exactly one input science file, received: "
                     f"{science_files}."
                 )
             input_dataset = load_cdf(science_files[0])
-            datasets = [glows_l1b(input_dataset)]
+            # TODO: Replace this by reading from AWS/ProcessingInputs
+
+            glows_ancillary_dir = Path(__file__).parent / "glows" / "ancillary"
+
+            # Create file lists for each ancillary type
+            excluded_regions_files = [
+                glows_ancillary_dir
+                / "imap_glows_map-of-excluded-regions_20250923_v002.dat"
+            ]
+            uv_sources_files = [
+                glows_ancillary_dir / "imap_glows_map-of-uv-sources_20250923_v002.dat"
+            ]
+            suspected_transients_files = [
+                glows_ancillary_dir
+                / "imap_glows_suspected-transients_20250923_v002.dat"
+            ]
+            exclusions_by_instr_team_files = [
+                glows_ancillary_dir
+                / "imap_glows_exclusions-by-instr-team_20250923_v002.dat"
+            ]
+
+            # Use end date buffer for ancillary data
+            current_day = np.datetime64(
+                f"{self.start_date[:4]}-{self.start_date[4:6]}-{self.start_date[6:]}"
+            )
+            day_buffer = current_day + np.timedelta64(3, "D")
+
+            # Create combiners for each ancillary dataset
+            excluded_regions_combiner = GlowsAncillaryCombiner(
+                excluded_regions_files, day_buffer
+            )
+            uv_sources_combiner = GlowsAncillaryCombiner(uv_sources_files, day_buffer)
+            suspected_transients_combiner = GlowsAncillaryCombiner(
+                suspected_transients_files, day_buffer
+            )
+            exclusions_by_instr_team_combiner = GlowsAncillaryCombiner(
+                exclusions_by_instr_team_files, day_buffer
+            )
+
+            datasets = [
+                glows_l1b(
+                    input_dataset,
+                    excluded_regions_combiner.combined_dataset,
+                    uv_sources_combiner.combined_dataset,
+                    suspected_transients_combiner.combined_dataset,
+                    exclusions_by_instr_team_combiner.combined_dataset,
+                )
+            ]
 
         if self.data_level == "l2":
             science_files = dependencies.get_file_paths(source="glows")
@@ -738,10 +787,18 @@ class Hi(ProcessInstrument):
         elif self.data_level == "l1b":
             l0_files = dependencies.get_file_paths(source="hi", descriptor="raw")
             if l0_files:
-                datasets = hi_l1b.hi_l1b(l0_files[0])
+                datasets = hi_l1b.housekeeping(l0_files[0])
             else:
-                l1a_files = dependencies.get_file_paths(source="hi", data_type="l1a")
-                datasets = hi_l1b.hi_l1b(load_cdf(l1a_files[0]))
+                l1a_de_file = dependencies.get_file_paths(
+                    source="hi", data_type="l1a", descriptor="de"
+                )[0]
+                l1b_hk_file = dependencies.get_file_paths(
+                    source="hi", data_type="l1b", descriptor="hk"
+                )[0]
+                esa_energies_csv = dependencies.get_file_paths(data_type="ancillary")[0]
+                datasets = hi_l1b.annotate_direct_events(
+                    load_cdf(l1a_de_file), load_cdf(l1b_hk_file), esa_energies_csv
+                )
         elif self.data_level == "l1c":
             science_paths = dependencies.get_file_paths(source="hi", data_type="l1b")
             if len(science_paths) != 1:
@@ -796,37 +853,41 @@ class Hit(ProcessInstrument):
 
         dependency_list = dependencies.processing_input
         if self.data_level == "l1a":
-            # 1 science files and 2 spice files
-            if len(dependency_list) > 3:
+            # Two inputs - L0 and SPICE
+            if len(dependency_list) > 2:
                 raise ValueError(
                     f"Unexpected dependencies found for HIT L1A:"
-                    f"{dependency_list}. Expected only one dependency."
+                    f"{dependency_list}. Expected only 2 dependencies, "
+                    f"L0 and time kernels."
                 )
             # process data to L1A products
             science_files = dependencies.get_file_paths(source="hit", descriptor="raw")
-            datasets = hit_l1a(science_files[0])
+            datasets = hit_l1a(science_files[0], self.start_date)
 
         elif self.data_level == "l1b":
-            data_dict = {}
-            # TODO: Sean removed the file number error handling to work with the
-            #  new SPICE dependencies for SIT-4. Need to review and make changes
-            #  if needed.
             l0_files = dependencies.get_file_paths(source="hit", descriptor="raw")
             l1a_files = dependencies.get_file_paths(source="hit", data_type="l1a")
-            if len(l0_files) > 0:
-                # Add path to CCSDS file to process housekeeping
-                data_dict["imap_hit_l0_raw"] = l0_files[0]
+            if len(l0_files) == 1:
+                # Path to CCSDS file to process housekeeping
+                dependency = l0_files[0]
             else:
+                # 1 science file
+                if len(l1a_files) > 1:
+                    raise ValueError(
+                        f"Unexpected dependencies found for HIT L1B:"
+                        f"{l1a_files}. Expected only one dependency."
+                    )
                 # Add L1A dataset to process science data
-                l1a_dataset = load_cdf(l1a_files[0])
-                data_dict[l1a_dataset.attrs["Logical_source"]] = l1a_dataset
+                dependency = load_cdf(l1a_files[0])
             # process data to L1B products
-            datasets = hit_l1b(data_dict)
+            datasets = [hit_l1b(dependency, self.descriptor)]
+
         elif self.data_level == "l2":
+            # 1 science files and 4 ancillary files
             if len(dependency_list) != 5:
                 raise ValueError(
                     f"Unexpected dependencies found for HIT L2:"
-                    f"{dependency_list}. Expected only one dependency."
+                    f"{dependency_list}. Expected only five dependencies."
                 )
             # Add L1B dataset to process science data
             science_files = dependencies.get_file_paths(
@@ -846,7 +907,7 @@ class Hit(ProcessInstrument):
                 )
             l1b_dataset = load_cdf(science_files[0])
             # process data to L2 products
-            datasets = hit_l2(l1b_dataset, ancillary_files)
+            datasets = [hit_l2(l1b_dataset, ancillary_files)]
 
         return datasets
 
@@ -895,14 +956,18 @@ class Idex(ProcessInstrument):
             dependency = load_cdf(science_files[0])
             datasets = [idex_l1b(dependency)]
         elif self.data_level == "l2a":
-            if len(dependency_list) != 1:
+            if len(dependency_list) != 3:
                 raise ValueError(
                     f"Unexpected dependencies found for IDEX L2A:"
-                    f"{dependency_list}. Expected only one dependency."
+                    f"{dependency_list}. Expected three dependencies."
                 )
             science_files = dependencies.get_file_paths(source="idex")
             dependency = load_cdf(science_files[0])
-            datasets = [idex_l2a(dependency)]
+            anc_paths = dependencies.get_file_paths(data_type="ancillary")
+            ancillary_files = {}
+            for path in anc_paths:
+                ancillary_files[path.stem.split("_")[2]] = path
+            datasets = [idex_l2a(dependency, ancillary_files)]
         elif self.data_level == "l2b":
             if len(dependency_list) < 3 or len(dependency_list) > 4:
                 raise ValueError(
@@ -916,16 +981,7 @@ class Idex(ProcessInstrument):
             hk_files = dependencies.get_file_paths(source="idex", descriptor="evt")
             # Remove duplicate housekeeping files
             hk_dependencies = [load_cdf(dep) for dep in list(set(hk_files))]
-            datasets = [idex_l2b(sci_dependencies, hk_dependencies)]
-        elif self.data_level == "l2c":
-            if len(dependency_list) != 1:
-                raise ValueError(
-                    f"Unexpected dependencies found for IDEX L2C:"
-                    f"{dependency_list}. Expected only one dependency."
-                )
-            sci_files = dependencies.get_file_paths(source="idex", descriptor="sci-1mo")
-            dependencies = [load_cdf(f) for f in sci_files]
-            datasets = [idex_l2c(dependencies)]
+            datasets = idex_l2b(sci_dependencies, hk_dependencies)
         return datasets
 
 
@@ -985,15 +1041,13 @@ class Lo(ProcessInstrument):
             data_dict = {}
             # TODO: Add ancillary descriptors when maps using them are
             #  implemented.
-            anc_dependencies = dependencies.get_file_paths(
-                source="lo",
-            )
+            anc_dependencies = []
             science_files = dependencies.get_file_paths(source="lo", descriptor="pset")
             psets = []
             for file in science_files:
                 psets.append(load_cdf(file))
             data_dict[psets[0].attrs["Logical_source"]] = psets
-            datasets = lo_l2.lo_l2(data_dict, anc_dependencies)
+            datasets = lo_l2.lo_l2(data_dict, anc_dependencies, self.descriptor)
         return datasets
 
 

imap_processing/codice/codice_l1a.py

@@ -54,6 +54,8 @@ class CoDICEL1aPipeline:
 
     Methods
     -------
+    apply_despinning()
+        Apply the despinning algorithm to lo- angular and priority products.
     decompress_data(science_values)
         Perform decompression on the data.
     define_coordinates()
@@ -87,6 +89,73 @@ class CoDICEL1aPipeline:
         self.plan_step = plan_step
         self.view_id = view_id
 
+    def apply_despinning(self) -> None:
+        """
+        Apply the despinning algorithm to lo- angular and priority products.
+
+        This only applies to CoDICE-Lo angular and priority data products. See
+        sections 9.3.4 and 9.3.5 of the algorithm document for more details.
+        """
+        # Determine the appropriate dimensions for the despun data
+        num_energies = self.config["dims"]["esa_step"]
+        num_spin_sectors = self.config["dims"]["spin_sector"]
+        num_spins = num_spin_sectors * 2
+        num_counters = self.config["num_counters"]
+        num_positions = self.config["dims"].get(
+            "inst_az"
+        )  # Defaults to None if not present
+
+        # The dimensions are dependent on the specific data product
+        if "angular" in self.config["dataset_name"]:
+            despun_dims: tuple[int, ...] = (
+                num_energies,
+                num_positions,
+                num_spins,
+                num_counters,
+            )
+        elif "priority" in self.config["dataset_name"]:
+            despun_dims = (num_energies, num_spins, num_counters)
+
+        # Placeholder for finalized despun data
+        self.data: list[np.ndarray]  # Needed to appease mypy
+        despun_data = [np.zeros(despun_dims) for _ in range(len(self.data))]
+
+        # Iterate over the energy and spin sector indices, and determine the
+        # appropriate pixel orientation. The combination of the pixel
+        # 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.
+        for i, epoch_data in enumerate(self.data):
+            for energy_index in range(num_energies):
+                pixel_orientation = constants.PIXEL_ORIENTATIONS[energy_index]
+                for spin_sector_index in range(num_spin_sectors):
+                    for azimuth_index in range(num_spins):
+                        if pixel_orientation == "A" and azimuth_index < 12:
+                            despun_spin_sector = spin_sector_index
+                        elif pixel_orientation == "A" and azimuth_index >= 12:
+                            despun_spin_sector = spin_sector_index + 12
+                        elif pixel_orientation == "B" and azimuth_index < 12:
+                            despun_spin_sector = spin_sector_index + 12
+                        elif pixel_orientation == "B" and azimuth_index >= 12:
+                            despun_spin_sector = spin_sector_index
+
+                        if "angular" in self.config["dataset_name"]:
+                            spin_data = epoch_data[
+                                energy_index, :, spin_sector_index, :
+                            ]  # (5, 4)
+                            despun_data[i][energy_index, :, despun_spin_sector, :] = (
+                                spin_data
+                            )
+                        elif "priority" in self.config["dataset_name"]:
+                            spin_data = epoch_data[energy_index, spin_sector_index, :]
+                            despun_data[i][energy_index, despun_spin_sector, :] = (
+                                spin_data
+                            )
+
+        # Replace original data
+        self.data = despun_data
+
     def decompress_data(self, science_values: list[NDArray[str]] | list[str]) -> None:
         """
         Perform decompression on the data.
@@ -122,7 +191,7 @@ class CoDICEL1aPipeline:
 
         else:
             for packet_data, byte_count in zip(
-                science_values, self.dataset.byte_count.data
+                science_values, self.dataset.byte_count.data, strict=False
             ):
                 # Convert from numpy array to byte object
                 values = packet_data[()]
@@ -134,11 +203,14 @@ class CoDICEL1aPipeline:
                 decompressed_values = decompress(values, compression_algorithm)
                 self.raw_data.append(decompressed_values)
 
-    def define_coordinates(self) -> None:
+    def define_coordinates(self) -> None:  # noqa: PLR0912 (too many branches)
         """
         Create ``xr.DataArrays`` for the coords needed in the final dataset.
 
         The coordinates for the dataset depend on the data product being made.
+
+        # TODO: Split this function up or simplify it to avoid too many branches
+        #       error.
         """
         self.coords = {}
 
@@ -169,13 +241,18 @@ class CoDICEL1aPipeline:
             if name in [
                 "esa_step",
                 "inst_az",
-                "spin_sector",
                 "spin_sector_pairs",
                 "spin_sector_index",
                 "ssd_index",
             ]:
                 values = np.arange(self.config["dims"][name])
                 dims = [name]
+            elif name == "spin_sector":
+                if self.config["dataset_name"] in constants.REQUIRES_DESPINNING:
+                    values = np.arange(24)
+                else:
+                    values = np.arange(self.config["dims"][name])
+                dims = [name]
             elif name == "spin_sector_pairs_label":
                 values = np.array(
                     [
@@ -197,7 +274,6 @@ class CoDICEL1aPipeline:
                     values = np.arange(self.config["dims"]["inst_az"]).astype(str)
                 dims = ["inst_az"]
             elif name in [
-                "spin_sector_label",
                 "esa_step_label",
                 "spin_sector_index_label",
                 "ssd_index_label",
@@ -205,6 +281,13 @@ class CoDICEL1aPipeline:
                 key = name.removesuffix("_label")
                 values = np.arange(self.config["dims"][key]).astype(str)
                 dims = [key]
+            elif name == "spin_sector_label":
+                key = name.removesuffix("_label")
+                dims = [key]
+                if self.config["dataset_name"] in constants.REQUIRES_DESPINNING:
+                    values = np.arange(24).astype(str)
+                else:
+                    values = np.arange(self.config["dims"][key]).astype(str)
 
             coord = xr.DataArray(
                 values,
@@ -243,7 +326,7 @@ class CoDICEL1aPipeline:
         # the num_counters dimension to isolate the data for each counter so
         # each counter's data can be placed in a separate CDF data variable.
         for counter, variable_name in zip(
-            range(all_data.shape[-1]), self.config["variable_names"]
+            range(all_data.shape[-1]), self.config["variable_names"], strict=False
         ):
             # Extract the counter data
             counter_data = all_data[..., counter]
@@ -313,7 +396,7 @@ class CoDICEL1aPipeline:
             ``xarray`` dataset for the data product, with added energy variables.
         """
         energy_bin_name = f"energy_{species}"
-        centers, deltas = self.get_hi_energy_table_data(
+        centers, deltas_minus, deltas_plus = self.get_hi_energy_table_data(
             energy_bin_name.split("energy_")[-1]
         )
 
@@ -326,11 +409,19 @@ class CoDICEL1aPipeline:
                 check_schema=False,
             ),
         )
-        dataset[f"{energy_bin_name}_delta"] = xr.DataArray(
-            deltas,
-            dims=[f"{energy_bin_name}_delta"],
+        dataset[f"{energy_bin_name}_minus"] = xr.DataArray(
+            deltas_minus,
+            dims=[f"{energy_bin_name}_minus"],
+            attrs=self.cdf_attrs.get_variable_attributes(
+                f"{self.config['dataset_name'].split('_')[-1]}-{energy_bin_name}_minus",
+                check_schema=False,
+            ),
+        )
+        dataset[f"{energy_bin_name}_plus"] = xr.DataArray(
+            deltas_plus,
+            dims=[f"{energy_bin_name}_plus"],
             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}_plus",
                 check_schema=False,
             ),
         )
@@ -488,7 +579,7 @@ class CoDICEL1aPipeline:
 
     def get_hi_energy_table_data(
         self, species: str
-    ) -> tuple[NDArray[float], NDArray[float]]:
+    ) -> tuple[NDArray[float], NDArray[float], NDArray[float]]:
         """
         Retrieve energy table data for CoDICE-Hi products.
 
@@ -506,22 +597,25 @@ class CoDICEL1aPipeline:
         -------
         centers : NDArray[float]
             An array whose values represent the centers of the energy bins.
-        deltas : NDArray[float]
-            An array whose values represent the deltas of the energy bins.
+        deltas_minus : NDArray[float]
+            An array whose values represent the minus deltas of the energy bins.
+        deltas_plus : NDArray[float]
+            An array whose values represent the plus deltas of the energy bins.
         """
         data_product = self.config["dataset_name"].split("-")[-1].upper()
-        energy_table = getattr(constants, f"{data_product}_ENERGY_TABLE")[species]
-
-        # Find the centers and deltas of the energy bins
-        centers = np.array(
-            [
-                (energy_table[i] + energy_table[i + 1]) / 2
-                for i in range(len(energy_table) - 1)
-            ]
+        energy_table = np.array(
+            getattr(constants, f"{data_product}_ENERGY_TABLE")[species]
         )
-        deltas = energy_table[1:] - centers
 
-        return centers, deltas
+        # Find the geometric centers and deltas of the energy bins
+        # The delta minus is the difference between the center of the bin
+        # and the 'left edge' of the bin. The delta plus is the difference
+        # between the 'right edge' of the bin and the center of the bin
+        centers = np.sqrt(energy_table[:-1] * energy_table[1:])
+        deltas_minus = centers - energy_table[:-1]
+        deltas_plus = energy_table[1:] - centers
+
+        return centers, deltas_minus, deltas_plus
 
     def reshape_binned_data(self, dataset: xr.Dataset) -> dict[str, list]:
         """
@@ -624,6 +718,10 @@ class CoDICEL1aPipeline:
             )
             self.data.append(reshaped_packet_data)
 
+        # Apply despinning if necessary
+        if self.config["dataset_name"] in constants.REQUIRES_DESPINNING:
+            self.apply_despinning()
+
         # No longer need to keep the raw data around
         del self.raw_data
 
@@ -955,9 +1053,9 @@ 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}"
+            variable_name = f"p{i}_{field}"
             attrs = cdf_attrs.get_variable_attributes(variable_name)
-            if field in ["NumEvents", "DataQuality"]:
+            if field in ["num_events", "data_quality"]:
                 dims = ["epoch"]
             else:
                 dims = ["epoch", "event_num"]
@@ -1415,13 +1513,15 @@ def reshape_de_data(
     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(
+                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}_NumEvents"] = np.full(num_epochs, 65535, dtype=np.uint16)
-        data[f"P{priority_num}_DataQuality"] = np.full(num_epochs, 255, dtype=np.uint8)
+        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)
 
     # decompressed_data is one large list of values of length
     # (<number of epochs> * <number of priorities>)
@@ -1445,8 +1545,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}_NumEvents"][epoch_index] = num_events
-            data[f"P{priority_num}_DataQuality"][epoch_index] = data_quality[i]
+            data[f"p{priority_num}_num_events"][epoch_index] = num_events
+            data[f"p{priority_num}_data_quality"][epoch_index] = data_quality[i]
 
             # Iterate over each event
             for event_index in range(num_events):
@@ -1477,7 +1577,7 @@ def reshape_de_data(
                     )
 
                     # Set the value into the data array
-                    data[f"P{priority_num}_{field_name}"][epoch_index, event_index] = (
+                    data[f"p{priority_num}_{field_name}"][epoch_index, event_index] = (
                         value
                     )
                     bit_position += field_components["bit_length"]

imap_processing/codice/codice_l2.py

@@ -52,6 +52,105 @@ def process_codice_l2(file_path: Path) -> xr.Dataset:
 
     # Get the L2 CDF attributes
     cdf_attrs = ImapCdfAttributes()
+    l2_dataset = add_dataset_attributes(l2_dataset, dataset_name, cdf_attrs)
+
+    if dataset_name in [
+        "imap_codice_l2_hi-counters-singles",
+        "imap_codice_l2_hi-counters-aggregated",
+        "imap_codice_l2_lo-counters-singles",
+        "imap_codice_l2_lo-counters-aggregated",
+        "imap_codice_l2_lo-sw-priority",
+        "imap_codice_l2_lo-nsw-priority",
+    ]:
+        # No changes needed. Just save to an L2 CDF file.
+        pass
+
+    elif dataset_name == "imap_codice_l2_hi-direct-events":
+        # Convert the following data variables to physical units using
+        # calibration data:
+        #    - ssd_energy
+        #    - tof
+        #    - elevation_angle
+        #    - spin_angle
+        # These converted variables are *in addition* to the existing L1 variables
+        # The other data variables require no changes
+        # See section 11.1.2 of algorithm document
+        pass
+
+    elif dataset_name == "imap_codice_l2_hi-sectored":
+        # Convert the sectored count rates using equation described in section
+        # 11.1.3 of algorithm document.
+        pass
+
+    elif dataset_name == "imap_codice_l2_hi-omni":
+        # Calculate the omni-directional intensity for each species using
+        # equation described in section 11.1.4 of algorithm document
+        # hopefully this can also apply to hi-ialirt
+        pass
+
+    elif dataset_name == "imap_codice_l2_lo-direct-events":
+        # Convert the following data variables to physical units using
+        # calibration data:
+        #    - apd_energy
+        #    - elevation_angle
+        #    - tof
+        #    - spin_sector
+        #    - esa_step
+        # These converted variables are *in addition* to the existing L1 variables
+        # The other data variables require no changes
+        # See section 11.1.2 of algorithm document
+        pass
+
+    elif dataset_name == "imap_codice_l2_lo-sw-angular":
+        # Calculate the sunward angular intensities using equation described in
+        # section 11.2.3 of algorithm document.
+        pass
+
+    elif dataset_name == "imap_codice_l2_lo-nsw-angular":
+        # Calculate the non-sunward angular intensities using equation described
+        # in section 11.2.3 of algorithm document.
+        pass
+
+    elif dataset_name == "imap_codice_l2_lo-sw-species":
+        # Calculate the sunward solar wind species intensities using equation
+        # described in section 11.2.4 of algorithm document.
+        # 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
+        pass
+
+    elif dataset_name == "imap_codice_l2_lo-nsw-species":
+        # Calculate the non-sunward solar wind species intensities using
+        # equation described in section 11.2.4 of algorithm document.
+        # Calculate the pickup ion non-sunward solar wind intensities using
+        # equation described in section 11.2.4 of algorithm document.
+        pass
+
+    logger.info(f"\nFinal data product:\n{l2_dataset}\n")
+
+    return l2_dataset
+
+
+def add_dataset_attributes(
+    l2_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
+        The dataset to update.
+    dataset_name : str
+        The name of the dataset.
+    cdf_attrs : ImapCdfAttributes
+        The attribute manager for CDF attributes.
+
+    Returns
+    -------
+    xarray.Dataset
+        The updated dataset.
+    """
     cdf_attrs.add_instrument_global_attrs("codice")
     cdf_attrs.add_instrument_variable_attrs("codice", "l2")
 
@@ -59,14 +158,23 @@ def process_codice_l2(file_path: Path) -> xr.Dataset:
     l2_dataset.attrs = cdf_attrs.get_global_attributes(dataset_name)
 
     # Set the variable attributes
-    for variable_name in l2_dataset:
-        l2_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
-            variable_name, check_schema=False
-        )
-
-    # TODO: Add L2-specific algorithms/functionality here. For SIT-4, we can
-    #       just keep the data as-is.
-
-    logger.info(f"\nFinal data product:\n{l2_dataset}\n")
-
+    for variable_name in l2_dataset.data_vars.keys():
+        try:
+            l2_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
+                variable_name, check_schema=False
+            )
+        except KeyError:
+            # Some variables may have a product descriptor prefix in the
+            # cdf attributes key if they are common to multiple products.
+            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(
+                    f"{cdf_attrs_key}", check_schema=False
+                )
+            except KeyError:
+                logger.error(
+                    f"Field '{variable_name}' and '{cdf_attrs_key}' not found in "
+                    f"attribute manager."
+                )
     return l2_dataset