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

imap_processing/hit/l2/hit_l2.py

@@ -2,22 +2,26 @@
 
 import logging
 from pathlib import Path
-from typing import NamedTuple
 
 import numpy as np
 import pandas as pd
 import xarray as xr
 
 from imap_processing.hit.hit_utils import (
-    add_energy_variables,
+    add_summed_particle_data_to_dataset,
     get_attribute_manager,
-    initialize_particle_data_arrays,
-    sum_particle_data,
 )
 from imap_processing.hit.l2.constants import (
+    FILLVAL_FLOAT32,
+    L2_SECTORED_ANCILLARY_PATH_PREFIX,
     L2_STANDARD_ANCILLARY_PATH_PREFIX,
     L2_SUMMED_ANCILLARY_PATH_PREFIX,
+    N_AZIMUTH,
+    SECONDS_PER_10_MIN,
+    SECONDS_PER_MIN,
     STANDARD_PARTICLE_ENERGY_RANGE_MAPPING,
+    VALID_SECTORED_SPECIES,
+    VALID_SPECIES,
 )
 
 logger = logging.getLogger(__name__)
@@ -27,7 +31,7 @@ logger = logging.getLogger(__name__)
 #  - determine where to pull ancillary data. Storing it locally for now
 
 
-def hit_l2(dependency: xr.Dataset, data_version: str) -> list[xr.Dataset]:
+def hit_l2(dependency: xr.Dataset) -> list[xr.Dataset]:
     """
     Will process HIT data to L2.
 
@@ -38,8 +42,6 @@ def hit_l2(dependency: xr.Dataset, data_version: str) -> list[xr.Dataset]:
     dependency : xr.Dataset
         L1B xarray science dataset that is either summed rates
         standard rates or sector rates.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -47,11 +49,9 @@ def hit_l2(dependency: xr.Dataset, data_version: str) -> list[xr.Dataset]:
         List of one L2 dataset.
     """
     logger.info("Creating HIT L2 science datasets")
-    # Create the attribute manager for this data level
-    attr_mgr = get_attribute_manager(data_version, "l2")
 
-    # TODO: Write functions to process sectored rates dataset
-    #       with logical source: "imap_hit_l2_macropixel-intensity"
+    # Create the attribute manager for this data level
+    attr_mgr = get_attribute_manager("l2")
 
     l2_datasets: dict = {}
 
@@ -68,6 +68,12 @@ def hit_l2(dependency: xr.Dataset, data_version: str) -> list[xr.Dataset]:
         )
         logger.info("HIT L2 standard intensity dataset created")
 
+    if "imap_hit_l1b_sectored-rates" in dependency.attrs["Logical_source"]:
+        l2_datasets["imap_hit_l2_macropixel-intensity"] = (
+            process_sectored_intensity_data(dependency)
+        )
+        logger.info("HIT L2 macropixel intensity dataset created")
+
     # Update attributes and dimensions
     for logical_source, dataset in l2_datasets.items():
         dataset.attrs = attr_mgr.get_global_attributes(logical_source)
@@ -102,149 +108,241 @@ def hit_l2(dependency: xr.Dataset, data_version: str) -> list[xr.Dataset]:
     return list(l2_datasets.values())
 
 
-class IntensityFactors(NamedTuple):
-    """A namedtuple to store factors for the intensity equation."""
+def calculate_intensities(
+    rates: xr.DataArray,
+    factors: xr.Dataset,
+) -> xr.DataArray:
+    """
+    Calculate the intensities for given rates and equation factors.
+
+    Uses vectorization to calculate the intensities for an array of rates
+    for all epochs.
+
+        This function uses equation 9 and 12 from the HIT algorithm document:
+        ((Summed L1B Rates) / (Delta Time * Delta E * Geometry Factor * Efficiency)) - b
+
+    Parameters
+    ----------
+    rates : xr.DataArray
+        The L1B rates to be converted to intensities.
+    factors : xr.Dataset
+        The ancillary data factors needed to calculate the intensity.
+        This includes delta_e, geometry_factor, efficiency, and b.
+
+    Returns
+    -------
+    xr.DataArray
+        The calculated intensities for all epochs.
+    """
+    # Calculate the intensity using vectorized operations
+    intensity = (
+        rates
+        / (
+            factors.delta_time
+            * factors.delta_e
+            * factors.geometry_factor
+            * factors.efficiency
+        )
+    ) - factors.b
+
+    # Apply intensity where rates are not equal to the fill value
+    intensity = xr.where(rates == FILLVAL_FLOAT32, FILLVAL_FLOAT32, intensity)
 
-    delta_e_factor: np.ndarray
-    geometry_factor: np.ndarray
-    efficiency: np.ndarray
-    b: np.ndarray
+    return intensity
 
 
-def get_intensity_factors(
-    energy_min: np.ndarray, species_ancillary_data: pd.DataFrame
-) -> IntensityFactors:
+def reshape_for_sectored(arr: np.ndarray) -> np.ndarray:
     """
-    Get the intensity factors for all energy bins of the given species ancillary data.
+    Reshape the ancillary data for sectored rates.
 
-    This function gets the factors needed for the equation to convert rates to
-    intensities for all energy bins for the given species.
+    Reshape the 3D arrays (epoch, energy, declination) to 4D arrays
+    (epoch, energy, azimuth, declination) by repeating the data
+    along the azimuth dimension. This is done to match the dimensions
+    of the sectored rates data to allow for proper calculation of
+    intensities.
 
     Parameters
     ----------
-    energy_min : np.ndarray
-        All energy min values for the species.
-    species_ancillary_data : pd.DataFrame
-        The subset of ancillary data for the given species.
+    arr : np.ndarray
+        The ancillary data array to reshape.
 
     Returns
     -------
-    IntensityFactors
-        The factors needed to convert rates to intensities for all energy bins
-        for the given species.
+    np.ndarray
+        The reshaped array.
     """
-    # Get factors needed to convert rates to intensities for
-    # all energy bins for the given species ancillary data
-    intensity_factors = species_ancillary_data.set_index(
-        species_ancillary_data["lower energy (mev)"].astype(np.float32)
-    ).loc[energy_min]
-
-    return IntensityFactors(
-        delta_e_factor=intensity_factors["delta e (mev)"].values,
-        geometry_factor=intensity_factors["geometry factor (cm2 sr)"].values,
-        efficiency=intensity_factors["efficiency"].values,
-        b=intensity_factors["b"].values,
+    return np.repeat(
+        arr.reshape((arr.shape[0], arr.shape[1], arr.shape[2]))[:, :, np.newaxis, :],
+        N_AZIMUTH,
+        axis=2,
     )
 
 
-def calculate_intensities(
-    rate: xr.DataArray,
-    delta_e_factor: np.ndarray,
-    geometry_factor: np.ndarray,
-    efficiency: np.ndarray,
+def build_ancillary_dataset(
+    delta_e: np.ndarray,
+    geometry_factors: np.ndarray,
+    efficiencies: np.ndarray,
     b: np.ndarray,
-) -> xr.DataArray:
+    species_array: xr.DataArray,
+) -> xr.Dataset:
     """
-    Calculate the intensities for given arrays of rates and ancillary factors.
-
-    Uses vectorization to calculate the intensities for an array of rates
-    at an epoch.
+    Build a xarray Dataset containing ancillary data for calculating intensity.
 
-        This function uses equation 9 and 11 from the HIT algorithm document:
-        (Summed L1B Rates) / (60 * Delta E * Geometry Factor * Efficiency) - b
+    This function builds a dataset containing the factors needed for calculating
+    intensity for a given species. The dataset is built based on the dimensions
+    and coordinates of the species data to align data along the epoch dimension.
 
     Parameters
     ----------
-    rate : xr.DataArray
-        The L1B rates to be converted to intensities for an epoch.
-    delta_e_factor : np.ndarray
-        The energy bin width factors for an epoch.
-    geometry_factor : np.ndarray
-        The geometry factors for an epoch.
-    efficiency : np.ndarray
-        The efficiency factors for an epoch.
+    delta_e : np.ndarray
+        Delta E values which are energy bin widths.
+    geometry_factors : np.ndarray
+        Geometry factor values.
+    efficiencies : np.ndarray
+        Efficiency values.
     b : np.ndarray
-        The b factors for an epoch.
+        Background intensity values.
+    species_array : xr.Dataset
+        Data array for the species to extract coordinates from.
 
     Returns
     -------
-    xr.DataArray
-        The calculated intensities for an epoch.
+    ancillary_ds : xr.Dataset
+        A dataset containing all ancillary data variables and coordinates that
+        align with the L2 dataset.
     """
-    # Calculate the intensities for this energy bin using vectorization
-    return (rate / (60 * delta_e_factor * geometry_factor * efficiency)) - b
+    data_vars = {}
+
+    # Check if this is sectored data (i.e., has azimuth and declination dims)
+    is_sectored = (
+        "declination" in species_array.dims or "declination" in species_array.coords
+    )
+
+    # Build variables
+    data_vars["delta_e"] = (species_array.dims, delta_e)
+    data_vars["geometry_factor"] = (
+        species_array.dims,
+        geometry_factors,
+    )
+    data_vars["efficiency"] = (
+        species_array.dims,
+        efficiencies,
+    )
+    data_vars["b"] = (species_array.dims, b)
+    data_vars["delta_time"] = (
+        ["epoch"],
+        np.full(
+            len(species_array.epoch),
+            SECONDS_PER_10_MIN if is_sectored else SECONDS_PER_MIN,
+        ),
+    )
+
+    return xr.Dataset(data_vars, coords=species_array.coords)
 
 
 def calculate_intensities_for_a_species(
     species_variable: str, l2_dataset: xr.Dataset, ancillary_data_frames: dict
-) -> None:
+) -> xr.Dataset:
     """
     Calculate the intensity for a given species in the dataset.
 
+    This function orchestrates calculating the intensity for a given species
+    in the L2 dataset using ancillary data determined by the dynamic threshold
+    state (0-3).
+
+    The intensity is calculated using the equation:
+        (L1B Rates) / (Delta Time * Delta E * Geometry Factor * Efficiency) - b
+
+        where the equation factors are retrieved from the ancillary data for
+        the given species and dynamic threshold states.
+
     Parameters
     ----------
     species_variable : str
-        The species variable to calculate the intensity for which is either the species
-        or a statistical uncertainty. (i.e. "h", "h_delta_minus", or "h_delta_plus").
+        The species variable to calculate the intensity for, which is either the species
+        or a statistical uncertainty.
+        (i.e. "h", "h_stat_uncert_minus", or "h_stat_uncert_plus").
     l2_dataset : xr.Dataset
-        The L2 dataset containing the summed L1B rates to calculate the intensity.
+        The L2 dataset containing the L1B rates needed to calculate the intensity.
     ancillary_data_frames : dict
         Dictionary containing ancillary data for each dynamic threshold state where
         the key is the dynamic threshold state and the value is a pandas DataFrame
-        containing the ancillary data.
+        containing the ancillary data for all species.
+
+    Returns
+    -------
+    updated_ds : xr.Dataset
+        The updated dataset with intensities calculated for the given species.
     """
-    species = (
+    updated_ds = l2_dataset.copy()
+    dynamic_threshold_states = updated_ds["dynamic_threshold_state"].values
+    unique_states = np.unique(dynamic_threshold_states)
+    species_name = (
         species_variable.split("_")[0]
-        if "_delta_" in species_variable
+        if "_uncert_" in species_variable
         else species_variable
     )
-    energy_min = (
-        l2_dataset[f"{species}_energy_mean"].values
-        - l2_dataset[f"{species}_energy_delta_minus"].values
+
+    # Subset ancillary data for this species
+    species_ancillary_by_state = {
+        state: get_species_ancillary_data(state, ancillary_data_frames, species_name)
+        for state in unique_states
+    }
+
+    # Extract parameters - 3D arrays (num_states, energy bins, values)
+    delta_e = np.stack(
+        [
+            species_ancillary_by_state[state]["delta_e"]
+            for state in dynamic_threshold_states
+        ]
+    )
+    geometry_factors = np.stack(
+        [
+            species_ancillary_by_state[state]["geometry_factor"]
+            for state in dynamic_threshold_states
+        ]
+    )
+    efficiencies = np.stack(
+        [
+            species_ancillary_by_state[state]["efficiency"]
+            for state in dynamic_threshold_states
+        ]
+    )
+    b = np.stack(
+        [species_ancillary_by_state[state]["b"] for state in dynamic_threshold_states]
     )
-    # TODO: Add check for energy max after ancillary file is updated
-    #  to fix errors
-
-    # Calculate the intensity for each epoch and energy bin since the
-    # dynamic threshold state can vary by epoch and that determines the
-    # ancillary data to use.
-    for epoch in range(l2_dataset[species_variable].shape[0]):
-        # Get ancillary data using the dynamic threshold state for this epoch
-        species_ancillary_data = get_species_ancillary_data(
-            int(l2_dataset["dynamic_threshold_state"][epoch].values),
-            ancillary_data_frames,
-            species,
-        )
 
-        # Calculate the intensity for this energy bin using vectorization
-        # and replace rates with intensities in the dataset
-        factors: IntensityFactors = get_intensity_factors(
-            energy_min, species_ancillary_data
-        )
-        rates: xr.DataArray = l2_dataset[species_variable][epoch]
-
-        l2_dataset[species_variable][epoch] = calculate_intensities(
-            rates,
-            factors.delta_e_factor,
-            factors.geometry_factor,
-            factors.efficiency,
-            factors.b,
-        )
+    # Reshape parameters for sectored rates to 4D arrays
+    if "declination" in updated_ds[species_variable].dims:
+        delta_e = reshape_for_sectored(delta_e)
+        geometry_factors = reshape_for_sectored(geometry_factors)
+        efficiencies = reshape_for_sectored(efficiencies)
+        b = reshape_for_sectored(b)
+
+    # Reshape parameters for summed and standard rates to 2D arrays
+    # by removing last dimension of size one, (n, n, 1)
+    else:
+        delta_e = np.squeeze(delta_e, axis=-1)
+        geometry_factors = np.squeeze(geometry_factors, axis=-1)
+        efficiencies = np.squeeze(efficiencies, axis=-1)
+        b = np.squeeze(b, axis=-1)
+
+    # Build ancillary xarray dataset
+    ancillary_ds = build_ancillary_dataset(
+        delta_e, geometry_factors, efficiencies, b, l2_dataset[species_name]
+    )
+
+    # Calculate intensities
+    updated_ds[species_variable] = calculate_intensities(
+        updated_ds[species_variable], ancillary_ds
+    )
+
+    return updated_ds
 
 
 def calculate_intensities_for_all_species(
-    l2_dataset: xr.Dataset, ancillary_data_frames: dict
-) -> None:
+    l2_dataset: xr.Dataset, ancillary_data_frames: dict, valid_data_variables: list
+) -> xr.Dataset:
     """
     Calculate the intensity for each species in the dataset.
 
@@ -256,39 +354,28 @@ def calculate_intensities_for_all_species(
         Dictionary containing ancillary data for each dynamic threshold state
         where the key is the dynamic threshold state and the value is a pandas
         DataFrame containing the ancillary data.
+    valid_data_variables : list
+        A list of valid data variables to calculate intensity for.
+
+    Returns
+    -------
+    updated_ds : xr.Dataset
+        The updated dataset with the intensity calculated for each species.
     """
-    # TODO: update to also calculate intensity for sectorates?
-    # List of valid species data variables to calculate intensity for
-    valid_data_variables = [
-        "h",
-        "he3",
-        "he4",
-        "he",
-        "c",
-        "n",
-        "o",
-        "ne",
-        "na",
-        "mg",
-        "al",
-        "si",
-        "s",
-        "ar",
-        "ca",
-        "fe",
-        "ni",
-    ]
+    updated_ds = l2_dataset.copy()
 
     # Add statistical uncertainty variables to the list of valid variables
-    valid_data_variables += [f"{var}_delta_minus" for var in valid_data_variables] + [
-        f"{var}_delta_plus" for var in valid_data_variables
-    ]
+    data_variables = (
+        valid_data_variables
+        + [f"{var}_stat_uncert_minus" for var in valid_data_variables]
+        + [f"{var}_stat_uncert_plus" for var in valid_data_variables]
+    )
 
     # Calculate the intensity for each valid data variable
-    for species_variable in valid_data_variables:
-        if species_variable in l2_dataset.data_vars:
-            calculate_intensities_for_a_species(
-                species_variable, l2_dataset, ancillary_data_frames
+    for species_variable in data_variables:
+        if species_variable in updated_ds.data_vars:
+            updated_ds = calculate_intensities_for_a_species(
+                species_variable, updated_ds, ancillary_data_frames
             )
         else:
             logger.warning(
@@ -296,10 +383,10 @@ def calculate_intensities_for_all_species(
                 f"Skipping intensity calculation."
             )
 
+    return updated_ds
 
-def add_systematic_uncertainties(
-    dataset: xr.Dataset, particle: str, energy_bins: int
-) -> None:
+
+def add_systematic_uncertainties(dataset: xr.Dataset, particle: str) -> xr.Dataset:
     """
     Add systematic uncertainties to the dataset.
 
@@ -309,94 +396,83 @@ def add_systematic_uncertainties(
     Parameters
     ----------
     dataset : xr.Dataset
-        The dataset to add the systematic uncertainties to.
+        The dataset to add the systematic uncertainties to
+        which contain the particle data variables.
     particle : str
         The particle name.
-    energy_bins : int
-        Number of energy bins for the particle.
+
+    Returns
+    -------
+    updated_ds : xr.Dataset
+        The dataset with the systematic uncertainties added.
     """
-    dataset[f"{particle}_sys_delta_minus"] = xr.DataArray(
-        data=np.zeros(energy_bins, dtype=np.float32),
-        dims=[f"{particle}_energy_mean"],
-        name=f"{particle}_sys_delta_minus",
+    updated_ds = dataset.copy()
+
+    updated_ds[f"{particle}_sys_err_minus"] = xr.DataArray(
+        data=np.zeros(updated_ds[particle].shape, dtype=np.float32),
+        dims=updated_ds[particle].dims,
+        name=f"{particle}_sys_err_minus",
     )
-    dataset[f"{particle}_sys_delta_plus"] = xr.DataArray(
-        data=np.zeros(energy_bins, dtype=np.float32),
-        dims=[f"{particle}_energy_mean"],
-        name=f"{particle}_sys_delta_plus",
+    updated_ds[f"{particle}_sys_err_plus"] = xr.DataArray(
+        data=np.zeros(updated_ds[particle].shape, dtype=np.float32),
+        dims=updated_ds[particle].dims,
+        name=f"{particle}_sys_err_plus",
     )
 
+    return updated_ds
 
-def add_standard_particle_rates_to_dataset(
-    l2_standard_intensity_dataset: xr.Dataset,
-    l1b_standard_rates_dataset: xr.Dataset,
-    particle: str,
-    energy_ranges: list,
-) -> None:
+
+def add_total_uncertainties(dataset: xr.Dataset, particle: str) -> xr.Dataset:
     """
-    Add summed standard particle rates to the dataset.
+    Add total uncertainties to the dataset.
 
-    This function performs the following steps:
-      1) sum the standard rates, including statistical uncertainties,
-         from the l2fgrates, l3fgrates, and penfgrates data variables in the L1B
-         standard rates data.
-      2) add the summed rates to the L2 standard intensity dataset by particle type
-         and energy range.
+    This function calculates the total uncertainties for a given particle
+    by combining the statistical uncertainties and systematic uncertainties.
+
+    The total uncertainties are calculated as the square root of the sum
+    of the squares of the statistical and systematic uncertainties.
 
     Parameters
     ----------
-    l2_standard_intensity_dataset : xr.Dataset
-        The L2 standard intensity dataset to add the rates to.
-    l1b_standard_rates_dataset : xr.Dataset
-        The L1B standard rates dataset containing rates to sum.
+    dataset : xr.Dataset
+        The dataset to add the total uncertainties to.
     particle : str
         The particle name.
-    energy_ranges : list
-        A list of energy range dictionaries for the particle.
-        For example:
-        {'energy_min': 1.8, 'energy_max': 2.2, "R2": [1], "R3": [], "R4": []}.
-    """
-    # Initialize arrays to store summed rates and statistical uncertainties
-    l2_standard_intensity_dataset = initialize_particle_data_arrays(
-        l2_standard_intensity_dataset,
-        particle,
-        len(energy_ranges),
-        l1b_standard_rates_dataset.sizes["epoch"],
-    )
-
-    # initialize arrays to store energy min and max values
-    energy_min = np.zeros(len(energy_ranges), dtype=np.float32)
-    energy_max = np.zeros(len(energy_ranges), dtype=np.float32)
 
-    # Sum particle rates and statistical uncertainties for each energy range
-    # and add them to the dataset
-    for i, energy_range_dict in enumerate(energy_ranges):
-        summed_rates, summed_rates_delta_minus, summed_rates_delta_plus = (
-            sum_particle_data(l1b_standard_rates_dataset, energy_range_dict)
-        )
-
-        l2_standard_intensity_dataset[f"{particle}"][:, i] = summed_rates.astype(
-            np.float32
-        )
-        l2_standard_intensity_dataset[f"{particle}_delta_minus"][:, i] = (
-            summed_rates_delta_minus.astype(np.float32)
-        )
-        l2_standard_intensity_dataset[f"{particle}_delta_plus"][:, i] = (
-            summed_rates_delta_plus.astype(np.float32)
-        )
+    Returns
+    -------
+    updated_ds : xr.Dataset
+        The dataset with the total uncertainties added.
+    """
+    updated_ds = dataset.copy()
 
-        # Fill energy min and max values for each energy range
-        energy_min[i] = energy_range_dict["energy_min"]
-        energy_max[i] = energy_range_dict["energy_max"]
+    # Calculate the total uncertainties
+    total_minus = np.sqrt(
+        np.square(updated_ds[f"{particle}_stat_uncert_minus"])
+        + np.square(updated_ds[f"{particle}_sys_err_minus"])
+    )
+    total_plus = np.sqrt(
+        np.square(updated_ds[f"{particle}_stat_uncert_plus"])
+        + np.square(updated_ds[f"{particle}_sys_err_plus"])
+    )
 
-    l2_standard_intensity_dataset = add_energy_variables(
-        l2_standard_intensity_dataset, particle, energy_min, energy_max
+    updated_ds[f"{particle}_total_uncert_minus"] = xr.DataArray(
+        data=total_minus.astype(np.float32),
+        dims=updated_ds[particle].dims,
+        name=f"{particle}_total_uncert_minus",
     )
+    updated_ds[f"{particle}_total_uncert_plus"] = xr.DataArray(
+        data=total_plus.astype(np.float32),
+        dims=updated_ds[particle].dims,
+        name=f"{particle}_total_uncert_plus",
+    )
+
+    return updated_ds
 
 
 def get_species_ancillary_data(
     dynamic_threshold_state: int, ancillary_data_frames: dict, species: str
-) -> pd.DataFrame:
+) -> dict:
     """
     Get the ancillary data for a given species and dynamic threshold state.
 
@@ -413,14 +489,25 @@ def get_species_ancillary_data(
 
     Returns
     -------
-    pd.DataFrame
+    dict
         The ancillary data for the species and dynamic threshold state.
     """
-    ancillary_data = ancillary_data_frames[dynamic_threshold_state]
-
-    # Get the ancillary data for the species
-    species_ancillary_data = ancillary_data[ancillary_data["species"] == species]
-    return species_ancillary_data
+    ancillary_df = ancillary_data_frames[dynamic_threshold_state]
+
+    # Remove any trailing spaces from all values in the DataFrame
+    ancillary_df = ancillary_df.map(lambda x: x.strip() if isinstance(x, str) else x)
+
+    # Get the ancillary data for the species and group by lower energy
+    species_ancillary_df = ancillary_df[ancillary_df["species"] == species]
+    grouped = species_ancillary_df.groupby("lower energy (mev)")
+    return {
+        "delta_e": np.array(grouped["delta e (mev)"].apply(list).tolist()),
+        "geometry_factor": np.array(
+            grouped["geometry factor (cm2 sr)"].apply(list).tolist()
+        ),
+        "efficiency": np.array(grouped["efficiency"].apply(list).tolist()),
+        "b": np.array(grouped["b"].apply(list).tolist()),
+    }
 
 
 def load_ancillary_data(dynamic_threshold_states: set, path_prefix: Path) -> dict:
@@ -488,51 +575,21 @@ def process_summed_intensity_data(l1b_summed_rates_dataset: xr.Dataset) -> xr.Da
         L2_SUMMED_ANCILLARY_PATH_PREFIX,
     )
 
-    # Add systematic uncertainties and energy variables to the dataset
-    for var in l2_summed_intensity_dataset.data_vars:
-        if "_" not in var:
-            particle = str(var)
-            # Add systematic uncertainties to the dataset. These will not have the
-            # intensity calculation applied to them and values will be zeros
-            add_systematic_uncertainties(
-                l2_summed_intensity_dataset,
-                particle,
-                l2_summed_intensity_dataset[var].shape[1],
-            )
+    # Calculate the intensity for each species
+    l2_summed_intensity_dataset = calculate_intensities_for_all_species(
+        l2_summed_intensity_dataset, ancillary_data_frames, VALID_SPECIES
+    )
 
-            # TODO: remove this code after L1B is updated to have energy mean and deltas
-            #       instead of energy index, min, and max
-            # Add energy variables to the dataset (energy mean and deltas)
-            l2_summed_intensity_dataset = add_energy_variables(
-                l2_summed_intensity_dataset,
-                particle,
-                l2_summed_intensity_dataset[f"{particle}_energy_min"].values,
-                l2_summed_intensity_dataset[f"{particle}_energy_max"].values,
+    # Add total and systematic uncertainties to the dataset
+    for var in l2_summed_intensity_dataset.data_vars:
+        if var in VALID_SPECIES:
+            l2_summed_intensity_dataset = add_systematic_uncertainties(
+                l2_summed_intensity_dataset, var
             )
-
-            # Replace energy index with energy mean as a coordinate
-            l2_summed_intensity_dataset = l2_summed_intensity_dataset.assign_coords(
-                {
-                    f"{particle}_energy_mean": (
-                        f"{particle}_energy_index",
-                        l2_summed_intensity_dataset[f"{particle}_energy_mean"].values,
-                    )
-                }
-            ).swap_dims({f"{particle}_energy_index": f"{particle}_energy_mean"})
-
-            # Drop energy min, max, and index variables
-            l2_summed_intensity_dataset = l2_summed_intensity_dataset.drop_vars(
-                [
-                    f"{particle}_energy_min",
-                    f"{particle}_energy_max",
-                    f"{particle}_energy_index",
-                ]
+            l2_summed_intensity_dataset = add_total_uncertainties(
+                l2_summed_intensity_dataset, var
             )
 
-    calculate_intensities_for_all_species(
-        l2_summed_intensity_dataset, ancillary_data_frames
-    )
-
     return l2_summed_intensity_dataset
 
 
@@ -554,9 +611,9 @@ def process_standard_intensity_data(
     STANDARD_PARTICLE_ENERGY_RANGE_MAPPING dictionary are included in this
     product.
 
-    Intensity is then calculated from the summed rates using the following equation:
+    Intensity is then calculated from the summed standard rates:
 
-        Equation 10 from the HIT algorithm document:
+        Equation 9 from the HIT algorithm document:
         Standard Intensity = (Summed L1B Standard Rates) /
                              (60 * Delta E * Geometry Factor * Efficiency) - b
 
@@ -582,9 +639,6 @@ def process_standard_intensity_data(
     l2_standard_intensity_dataset["dynamic_threshold_state"] = (
         l1b_standard_rates_dataset["dynamic_threshold_state"]
     )
-    l2_standard_intensity_dataset[
-        "dynamic_threshold_state"
-    ].attrs = l1b_standard_rates_dataset["dynamic_threshold_state"].attrs
 
     # Load ancillary data for each dynamic threshold state into a dictionary
     ancillary_data_frames = load_ancillary_data(
@@ -592,23 +646,78 @@ def process_standard_intensity_data(
         L2_STANDARD_ANCILLARY_PATH_PREFIX,
     )
 
-    # Process each particle type and energy range and add rates and uncertainties
-    # to the dataset
+    # Process each particle type and add rates and uncertainties to the dataset
     for particle, energy_ranges in STANDARD_PARTICLE_ENERGY_RANGE_MAPPING.items():
-        # Add systematic uncertainties to the dataset. These will not have the intensity
-        # calculation applied to them and values will be zeros
-        add_systematic_uncertainties(
-            l2_standard_intensity_dataset, particle, len(energy_ranges)
-        )
         # Add standard particle rates and statistical uncertainties to the dataset
-        add_standard_particle_rates_to_dataset(
+        l2_standard_intensity_dataset = add_summed_particle_data_to_dataset(
             l2_standard_intensity_dataset,
             l1b_standard_rates_dataset,
             particle,
             energy_ranges,
         )
-    calculate_intensities_for_all_species(
-        l2_standard_intensity_dataset, ancillary_data_frames
+
+    l2_standard_intensity_dataset = calculate_intensities_for_all_species(
+        l2_standard_intensity_dataset, ancillary_data_frames, VALID_SPECIES
     )
 
+    # Add total and systematic uncertainties to the dataset
+    for particle in STANDARD_PARTICLE_ENERGY_RANGE_MAPPING.keys():
+        l2_standard_intensity_dataset = add_systematic_uncertainties(
+            l2_standard_intensity_dataset, particle
+        )
+        l2_standard_intensity_dataset = add_total_uncertainties(
+            l2_standard_intensity_dataset, particle
+        )
+
     return l2_standard_intensity_dataset
+
+
+def process_sectored_intensity_data(
+    l1b_sectored_rates_dataset: xr.Dataset,
+) -> xr.Dataset:
+    """
+    Will process L2 HIT sectored intensity data from L1B sectored rates data.
+
+    This function converts the L1B sectored rates to L2 sectored intensities
+    using ancillary tables containing factors needed to calculate the
+    intensity (energy bin width, geometry factor, efficiency, and b).
+
+    Equation 12 from the HIT algorithm document:
+    Sectored Intensity = (Summed L1B Sectored Rates) /
+                       (600 * Delta E * Geometry Factor * Efficiency) - b
+
+    Parameters
+    ----------
+    l1b_sectored_rates_dataset : xr.Dataset
+        The L1B sectored rates dataset.
+
+    Returns
+    -------
+    xr.Dataset
+        The processed L2 sectored intensity dataset.
+    """
+    # Create a new dataset to store the L2 sectored intensity data
+    l2_sectored_intensity_dataset = l1b_sectored_rates_dataset.copy(deep=True)
+
+    # Load ancillary data for each dynamic threshold state into a dictionary
+    ancillary_data_frames = load_ancillary_data(
+        set(l2_sectored_intensity_dataset["dynamic_threshold_state"].values),
+        L2_SECTORED_ANCILLARY_PATH_PREFIX,
+    )
+
+    # Calculate the intensity for each species
+    l2_sectored_intensity_dataset = calculate_intensities_for_all_species(
+        l2_sectored_intensity_dataset, ancillary_data_frames, VALID_SECTORED_SPECIES
+    )
+
+    # Add total and systematic uncertainties to the dataset
+    for var in l2_sectored_intensity_dataset.data_vars:
+        if var in VALID_SECTORED_SPECIES:
+            l2_sectored_intensity_dataset = add_systematic_uncertainties(
+                l2_sectored_intensity_dataset, var
+            )
+            l2_sectored_intensity_dataset = add_total_uncertainties(
+                l2_sectored_intensity_dataset, var
+            )
+
+    return l2_sectored_intensity_dataset