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

imap_processing/hit/hit_utils.py

@@ -66,14 +66,12 @@ def get_datasets_by_apid(
     return datasets_by_apid
 
 
-def get_attribute_manager(data_version: str, level: str) -> ImapCdfAttributes:
+def get_attribute_manager(level: str) -> ImapCdfAttributes:
     """
     Create an attribute manager for the HIT data products.
 
     Parameters
     ----------
-    data_version : str
-        Version of the data product being created.
     level : str
         Data level of the product being created.
 
@@ -86,7 +84,6 @@ def get_attribute_manager(data_version: str, level: str) -> ImapCdfAttributes:
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs(instrument="hit")
     attr_mgr.add_instrument_variable_attrs(instrument="hit", level=level)
-    attr_mgr.add_global_attribute("Data_version", data_version)
     return attr_mgr
 
 
@@ -159,7 +156,6 @@ def process_housekeeping_data(
     # Drop keys that are not CDF data variables
     drop_keys = [
         "pkt_apid",
-        "sc_tick",
         "version",
         "type",
         "sec_hdr_flg",
@@ -219,3 +215,237 @@ def process_housekeeping_data(
     dataset.epoch.attrs = attr_mgr.get_variable_attributes("epoch")
 
     return dataset
+
+
+def initialize_particle_data_arrays(
+    dataset: xr.Dataset,
+    particle: str,
+    num_energy_ranges: int,
+    epoch_size: int,
+) -> xr.Dataset:
+    """
+    Add empty data arrays for a given particle.
+
+    Valid particle names:
+        h
+        he3
+        he4
+        he
+        c
+        n
+        o
+        ne
+        na
+        mg
+        al
+        si
+        s
+        ar
+        ca
+        fe
+        ni
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        The dataset to add the data arrays to.
+    particle : str
+        The abbreviated particle name.
+    num_energy_ranges : int
+        Number of energy ranges for the particle.
+        Used to define the shape of the data arrays.
+    epoch_size : int
+        Used to define the shape of the data arrays.
+
+    Returns
+    -------
+    updated_ds : xr.Dataset
+        The updated dataset with the particle data arrays added.
+    """
+    updated_ds = dataset.copy()
+
+    updated_ds[f"{particle}"] = xr.DataArray(
+        data=np.zeros((epoch_size, num_energy_ranges), dtype=np.float32),
+        dims=["epoch", f"{particle}_energy_mean"],
+        name=f"{particle}",
+    )
+    updated_ds[f"{particle}_stat_uncert_minus"] = xr.DataArray(
+        data=np.zeros((epoch_size, num_energy_ranges), dtype=np.float32),
+        dims=["epoch", f"{particle}_energy_mean"],
+        name=f"{particle}_stat_uncert_minus",
+    )
+    updated_ds[f"{particle}_stat_uncert_plus"] = xr.DataArray(
+        data=np.zeros((epoch_size, num_energy_ranges), dtype=np.float32),
+        dims=["epoch", f"{particle}_energy_mean"],
+        name=f"{particle}_stat_uncert_plus",
+    )
+    updated_ds.coords[f"{particle}_energy_mean"] = xr.DataArray(
+        np.zeros(num_energy_ranges, dtype=np.int8),
+        dims=[f"{particle}_energy_mean"],
+        name=f"{particle}_energy_mean",
+    )
+
+    return updated_ds
+
+
+def sum_particle_data(
+    dataset: xr.Dataset, indices: dict
+) -> tuple[xr.DataArray, xr.DataArray, xr.DataArray]:
+    """
+    Sum particle data for a given energy range.
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        A dataset containing particle data to sum in the l2fgrates, l3fgrates,
+        penfgrates data variables. If it's an L1A dataset, these variables
+        contain particle counts. If it's an L1B dataset, these variables
+        contain particle rates.
+
+    indices : dict
+        A dictionary containing the indices for particle data to sum for a given
+        energy range. The dictionary should have the following keys:
+            R2 = indices for l2fgrates
+            R3 = indices for l3fgrates
+            R4 = indices for penfgrates
+
+    Returns
+    -------
+    summed_data : xr.DataArray
+        The summed data for the given energy range.
+
+    summed_uncertainty_minus : xr.DataArray
+        The summed data for delta minus statistical uncertainty.
+
+    summed_uncertainty_plus : xr.DataArray
+        The summed data for delta plus statistical uncertainty.
+    """
+    summed_data = (
+        dataset["l2fgrates"][:, indices["R2"]].sum(axis=1)
+        + dataset["l3fgrates"][:, indices["R3"]].sum(axis=1)
+        + dataset["penfgrates"][:, indices["R4"]].sum(axis=1)
+    )
+
+    summed_uncertainty_minus = (
+        dataset["l2fgrates_stat_uncert_minus"][:, indices["R2"]].sum(axis=1)
+        + dataset["l3fgrates_stat_uncert_minus"][:, indices["R3"]].sum(axis=1)
+        + dataset["penfgrates_stat_uncert_minus"][:, indices["R4"]].sum(axis=1)
+    )
+
+    summed_uncertainty_plus = (
+        dataset["l2fgrates_stat_uncert_plus"][:, indices["R2"]].sum(axis=1)
+        + dataset["l3fgrates_stat_uncert_plus"][:, indices["R3"]].sum(axis=1)
+        + dataset["penfgrates_stat_uncert_plus"][:, indices["R4"]].sum(axis=1)
+    )
+
+    return summed_data, summed_uncertainty_minus, summed_uncertainty_plus
+
+
+def add_energy_variables(
+    dataset: xr.Dataset,
+    particle: str,
+    energy_min_values: np.ndarray,
+    energy_max_values: np.ndarray,
+) -> xr.Dataset:
+    """
+    Add energy min and max variables to the dataset.
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        The dataset to add the energy variables to.
+    particle : str
+        The particle name.
+    energy_min_values : np.ndarray
+        The minimum energy values for each energy range.
+    energy_max_values : np.ndarray
+        The maximum energy values for each energy range.
+
+    Returns
+    -------
+    updated_ds : xr.Dataset
+        The updated dataset with the energy variables added.
+    """
+    updated_ds = dataset.copy()
+
+    energy_mean = np.mean(
+        np.array([energy_min_values, energy_max_values]), axis=0
+    ).astype(np.float32)
+
+    updated_ds[f"{particle}_energy_mean"] = xr.DataArray(
+        data=energy_mean,
+        dims=[f"{particle}_energy_mean"],
+        name=f"{particle}_energy_mean",
+    )
+    updated_ds[f"{particle}_energy_delta_minus"] = xr.DataArray(
+        data=np.array(energy_mean - np.array(energy_min_values), dtype=np.float32),
+        dims=[f"{particle}_energy_mean"],
+        name=f"{particle}_energy_delta_minus",
+    )
+    updated_ds[f"{particle}_energy_delta_plus"] = xr.DataArray(
+        data=np.array(energy_max_values - energy_mean, dtype=np.float32),
+        dims=[f"{particle}_energy_mean"],
+        name=f"{particle}_energy_delta_plus",
+    )
+    return updated_ds
+
+
+def add_summed_particle_data_to_dataset(
+    dataset: xr.Dataset,
+    source_dataset: xr.Dataset,
+    particle: str,
+    energy_ranges: list,
+) -> xr.Dataset:
+    """
+    Add summed particle data to the dataset.
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        The dataset to add the rates to (not modified in-place).
+    source_dataset : xr.Dataset
+        The dataset containing data to sum (counts or rates).
+    particle : str
+        The particle name.
+    energy_ranges : list
+        A list of energy range dictionaries for the particle.
+
+    Returns
+    -------
+    xr.Dataset
+        A new dataset with summed particle data added.
+    """
+    # Make a copy of the dataset to update
+    ds = dataset.copy()
+
+    # Initialize particle data arrays
+    ds = initialize_particle_data_arrays(
+        ds, particle, len(energy_ranges), source_dataset.sizes["epoch"]
+    )
+
+    # Initialize arrays for energy values
+    energy_min = np.zeros(len(energy_ranges), dtype=np.float32)
+    energy_max = np.zeros(len(energy_ranges), dtype=np.float32)
+
+    # Compute summed data and update the dataset
+    for i, energy_range_dict in enumerate(energy_ranges):
+        summed_data, summed_data_uncert_minus, summed_data_uncert_plus = (
+            sum_particle_data(source_dataset, energy_range_dict)
+        )
+
+        ds[f"{particle}"][:, i] = summed_data.astype(np.float32)
+        ds[f"{particle}_stat_uncert_minus"][:, i] = summed_data_uncert_minus.astype(
+            np.float32
+        )
+        ds[f"{particle}_stat_uncert_plus"][:, i] = summed_data_uncert_plus.astype(
+            np.float32
+        )
+
+        # Store energy range values
+        energy_min[i] = energy_range_dict["energy_min"]
+        energy_max[i] = energy_range_dict["energy_max"]
+
+    # Add energy variables
+    ds = add_energy_variables(ds, particle, energy_min, energy_max)
+
+    return ds

imap_processing/hit/l0/constants.py

@@ -6,16 +6,16 @@ import numpy as np
 
 # energy_units: MeV/n
 MOD_10_MAPPING = {
-    0: {"species": "H", "energy_min": 1.8, "energy_max": 3.6},
-    1: {"species": "H", "energy_min": 4, "energy_max": 6},
-    2: {"species": "H", "energy_min": 6, "energy_max": 10},
-    3: {"species": "He4", "energy_min": 4, "energy_max": 6},
-    4: {"species": "He4", "energy_min": 6, "energy_max": 12},
-    5: {"species": "CNO", "energy_min": 4, "energy_max": 6},
-    6: {"species": "CNO", "energy_min": 6, "energy_max": 12},
-    7: {"species": "NeMgSi", "energy_min": 4, "energy_max": 6},
-    8: {"species": "NeMgSi", "energy_min": 6, "energy_max": 12},
-    9: {"species": "Fe", "energy_min": 4, "energy_max": 12},
+    0: {"species": "h", "energy_min": 1.8, "energy_max": 3.6},
+    1: {"species": "h", "energy_min": 4, "energy_max": 6},
+    2: {"species": "h", "energy_min": 6, "energy_max": 10},
+    3: {"species": "he4", "energy_min": 4, "energy_max": 6},
+    4: {"species": "he4", "energy_min": 6, "energy_max": 12},
+    5: {"species": "cno", "energy_min": 4, "energy_max": 6},
+    6: {"species": "cno", "energy_min": 6, "energy_max": 12},
+    7: {"species": "nemgsi", "energy_min": 4, "energy_max": 6},
+    8: {"species": "nemgsi", "energy_min": 6, "energy_max": 12},
+    9: {"species": "fe", "energy_min": 4, "energy_max": 12},
 }
 
 # Structure to hold binary details for a
@@ -100,7 +100,7 @@ COUNTS_DATA_STRUCTURE = {
     "penfgrates": HITPacking(16, 528, (33,)),  # range 4 foreground rates
     "penbgrates": HITPacking(16, 240, (15,)),  # range 4 background rates
     "ialirtrates": HITPacking(16, 320, (20,)),  # ialirt rates
-    "sectorates": HITPacking(16, 1920, (8, 15)),  # sectored rates
+    "sectorates": HITPacking(16, 1920, (15, 8)),  # sectored rates
     "l4fgrates": HITPacking(16, 768, (48,)),  # all range foreground rates
     "l4bgrates": HITPacking(16, 384, (24,)),  # all range foreground rates
 }
@@ -116,3 +116,12 @@ FRAME_SIZE = len(FLAG_PATTERN)
 # decompressing data
 MANTISSA_BITS = 12
 EXPONENT_BITS = 4
+
+# Define sectorate angles
+DECLINATION_ANGLES = np.array(
+    [11.25, 33.75, 56.25, 78.75, 101.25, 123.75, 146.25, 168.75], dtype=np.float32
+)
+AZIMUTH_ANGLES = np.array(
+    [12, 36, 60, 84, 108, 132, 156, 180, 204, 228, 252, 276, 300, 324, 348],
+    dtype=np.float32,
+)

imap_processing/hit/l0/decom_hit.py

@@ -4,7 +4,9 @@ import numpy as np
 import xarray as xr
 
 from imap_processing.hit.l0.constants import (
+    AZIMUTH_ANGLES,
     COUNTS_DATA_STRUCTURE,
+    DECLINATION_ANGLES,
     EXPONENT_BITS,
     FLAG_PATTERN,
     FRAME_SIZE,
@@ -90,9 +92,20 @@ def parse_count_rates(sci_dataset: xr.Dataset) -> None:
         # Get dims for data variables (yaml file not created yet)
         if len(field_meta.shape) > 1:
             if "sectorates" in field:
-                # Reshape data to 8x15 for declination and azimuth look directions
+                # Reshape data to 15x8 for azimuth and declination look directions
                 parsed_data = np.array(parsed_data).reshape((-1, *field_meta.shape))
-                dims = ["epoch", "declination", "azimuth"]
+                dims = ["epoch", "azimuth", "declination"]
+                # Add angle values to coordinates
+                sci_dataset.coords["declination"] = xr.DataArray(
+                    data=DECLINATION_ANGLES,
+                    dims=["declination"],
+                    name="declination",
+                )
+                sci_dataset.coords["azimuth"] = xr.DataArray(
+                    data=AZIMUTH_ANGLES,
+                    dims=["azimuth"],
+                    name="azimuth",
+                )
             elif "sngrates" in field:
                 dims = ["epoch", "gain", f"{field}_index"]
         elif field_meta.shape[0] > 1:
@@ -100,13 +113,16 @@ def parse_count_rates(sci_dataset: xr.Dataset) -> None:
         else:
             dims = ["epoch"]
 
-        sci_dataset[field] = xr.DataArray(parsed_data, dims=dims, name=field)
+        sci_dataset[field] = xr.DataArray(
+            np.array(parsed_data, dtype=np.int64), dims=dims, name=field
+        )
         # Add dimensions to coordinates
-        # TODO: confirm that dtype int16 is correct
         for dim in dims:
             if dim not in sci_dataset.coords:
                 sci_dataset.coords[dim] = xr.DataArray(
-                    np.arange(sci_dataset.sizes[dim], dtype=np.int16),
+                    np.arange(sci_dataset.sizes[dim], dtype=np.int16)
+                    if dim == "gain"
+                    else np.arange(sci_dataset.sizes[dim], dtype=np.int32),
                     dims=[dim],
                     name=dim,
                 )

imap_processing/hit/l1a/hit_l1a.py

@@ -8,6 +8,7 @@ import xarray as xr
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.hit.hit_utils import (
     HitAPID,
+    add_energy_variables,
     get_attribute_manager,
     get_datasets_by_apid,
     process_housekeeping_data,
@@ -23,7 +24,7 @@ logger = logging.getLogger(__name__)
 fillval = -9223372036854775808
 
 
-def hit_l1a(packet_file: str, data_version: str) -> list[xr.Dataset]:
+def hit_l1a(packet_file: str) -> list[xr.Dataset]:
     """
     Will process HIT L0 data into L1A data products.
 
@@ -31,8 +32,6 @@ def hit_l1a(packet_file: str, data_version: str) -> list[xr.Dataset]:
     ----------
     packet_file : str
         Path to the CCSDS data packet file.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -43,7 +42,7 @@ def hit_l1a(packet_file: str, data_version: str) -> list[xr.Dataset]:
     datasets_by_apid = get_datasets_by_apid(packet_file)
 
     # Create the attribute manager for this data level
-    attr_mgr = get_attribute_manager(data_version, "l1a")
+    attr_mgr = get_attribute_manager("l1a")
 
     l1a_datasets = []
 
@@ -62,107 +61,106 @@ def hit_l1a(packet_file: str, data_version: str) -> list[xr.Dataset]:
     return l1a_datasets
 
 
-def subcom_sectorates(sci_dataset: xr.Dataset) -> None:
+def subcom_sectorates(sci_dataset: xr.Dataset) -> xr.Dataset:
     """
     Subcommutate sectorates data.
 
-    Sector rates data contains rates for 5 species and 10
-    energy ranges. This function subcommutates the sector
-    rates data by organizing the rates by species. Which
+    Sectored rates data contains raw counts for 5 species and 10
+    energy ranges. This function subcommutates the sectored
+    rates data by organizing the counts by species. Which
     species and energy range the data belongs to is determined
     by taking the mod 10 value of the corresponding header
     minute count value in the dataset. A mapping of mod 10
     values to species and energy ranges is provided in constants.py.
 
     MOD_10_MAPPING = {
-        0: {"species": "H", "energy_min": 1.8, "energy_max": 3.6},
-        1: {"species": "H", "energy_min": 4, "energy_max": 6},
-        2: {"species": "H", "energy_min": 6, "energy_max": 10},
-        3: {"species": "4He", "energy_min": 4, "energy_max": 6},
+        0: {"species": "h", "energy_min": 1.8, "energy_max": 3.6},
+        1: {"species": "h", "energy_min": 4, "energy_max": 6},
+        2: {"species": "h", "energy_min": 6, "energy_max": 10},
+        3: {"species": "he4", "energy_min": 4, "energy_max": 6},
         ...
-        9: {"species": "Fe", "energy_min": 4, "energy_max": 12}}
+        9: {"species": "fe", "energy_min": 4, "energy_max": 12}}
 
     The data is added to the dataset as new data fields named
     according to their species. They have 4 dimensions: epoch
-    energy index, declination, and azimuth. The energy index
+    energy mean, azimuth, and declination. The energy mean
     dimension is used to distinguish between the different energy
-    ranges the data belongs to. The energy min and max values for
-    each species are also added to the dataset as new data fields.
+    ranges the data belongs to. The energy deltas for each species
+    are also added to the dataset as new data fields.
 
     Parameters
     ----------
     sci_dataset : xarray.Dataset
         Xarray dataset containing parsed HIT science data.
+
+    Returns
+    -------
+    sci_dataset : xarray.Dataset
+        Xarray dataset with sectored rates data organized by species.
     """
+    updated_dataset = sci_dataset.copy()
+
     # Calculate mod 10 values
-    hdr_min_count_mod_10 = sci_dataset.hdr_minute_cnt.values % 10
+    hdr_min_count_mod_10 = updated_dataset.hdr_minute_cnt.values % 10
 
     # Reference mod 10 mapping to initialize data structure for species and
-    # energy ranges and add 8x15 arrays with fill values for each science frame.
+    # energy ranges and add 15x8 arrays with fill values for each science frame.
     num_frames = len(hdr_min_count_mod_10)
-    # TODO: add more specific dtype for rates (ex. int16) once this is defined by HIT
     data_by_species_and_energy_range = {
         key: {
             **value,
-            "rates": np.full((num_frames, 8, 15), fill_value=fillval, dtype=int),
+            "counts": np.full((num_frames, 15, 8), fill_value=fillval, dtype=np.int64),
         }
         for key, value in MOD_10_MAPPING.items()
     }
 
-    # Update rates for science frames where data is available
+    # Update counts for science frames where data is available
     for i, mod_10 in enumerate(hdr_min_count_mod_10):
-        data_by_species_and_energy_range[mod_10]["rates"][i] = sci_dataset[
+        data_by_species_and_energy_range[mod_10]["counts"][i] = updated_dataset[
             "sectorates"
         ].values[i]
 
     # H has 3 energy ranges, 4He, CNO, NeMgSi have 2, and Fe has 1.
-    # Aggregate sector rates and energy min/max values for each species.
+    # Aggregate sectored rates and energy min/max values for each species.
     # First, initialize dictionaries to store rates and min/max energy values by species
     data_by_species: dict = {
-        value["species"]: {"rates": [], "energy_min": [], "energy_max": []}
+        value["species"]: {"counts": [], "energy_min": [], "energy_max": []}
         for value in data_by_species_and_energy_range.values()
     }
 
     for value in data_by_species_and_energy_range.values():
         species = value["species"]
-        data_by_species[species]["rates"].append(value["rates"])
+        data_by_species[species]["counts"].append(value["counts"])
         data_by_species[species]["energy_min"].append(value["energy_min"])
         data_by_species[species]["energy_max"].append(value["energy_max"])
 
-    # Add sector rates by species to the dataset
-    for species_type, data in data_by_species.items():
-        # Rates data has shape: energy_index, epoch, declination, azimuth
+    # Add sectored rates by species to the dataset
+    for species, data in data_by_species.items():
+        # Rates data has shape: energy_mean, epoch, azimuth, declination
         # Convert rates to numpy array and transpose axes to get
-        # shape: epoch, energy_index, declination, azimuth
-        rates_data = np.transpose(np.array(data["rates"]), axes=(1, 0, 2, 3))
+        # shape: epoch, energy_mean, azimuth, declination
+        rates_data = np.transpose(np.array(data["counts"]), axes=(1, 0, 2, 3))
 
-        species = species_type.lower()
-        sci_dataset[f"{species}_counts_sectored"] = xr.DataArray(
+        updated_dataset[f"{species}_sectored_counts"] = xr.DataArray(
             data=rates_data,
-            dims=["epoch", f"{species}_energy_index", "declination", "azimuth"],
+            dims=["epoch", f"{species}_energy_mean", "azimuth", "declination"],
             name=f"{species}_counts_sectored",
         )
-        sci_dataset[f"{species}_energy_min"] = xr.DataArray(
-            data=np.array(data["energy_min"], dtype=np.int8),
-            dims=[f"{species}_energy_index"],
-            name=f"{species}_energy_min",
-        )
-        sci_dataset[f"{species}_energy_max"] = xr.DataArray(
-            data=np.array(data["energy_max"], dtype=np.int8),
-            dims=[f"{species}_energy_index"],
-            name=f"{species}_energy_max",
-        )
-        # add energy index coordinate to the dataset
-        sci_dataset.coords[f"{species}_energy_index"] = xr.DataArray(
-            np.arange(sci_dataset.sizes[f"{species}_energy_index"], dtype=np.int8),
-            dims=[f"{species}_energy_index"],
-            name=f"{species}_energy_index",
+
+        # Add energy mean and deltas for each species
+        updated_dataset = add_energy_variables(
+            updated_dataset,
+            species,
+            np.array(data["energy_min"]),
+            np.array(data["energy_max"]),
         )
 
+    return updated_dataset
+
 
 def calculate_uncertainties(dataset: xr.Dataset) -> xr.Dataset:
     """
-    Calculate uncertainties for each counts data variable in the dataset.
+    Calculate statistical uncertainties.
 
     Calculate the upper and lower uncertainties. The uncertainty for
     the raw Lev1A HIT data will be calculated as asymmetric Poisson
@@ -170,10 +168,10 @@ def calculate_uncertainties(dataset: xr.Dataset) -> xr.Dataset:
     See section 5.5 in the algorithm document for details.
 
     The upper uncertainty will be calculated as
-        DELTA_PLUS = sqrt(counts + 1) + 1
+        uncert_plus = sqrt(counts + 1) + 1
 
     The lower uncertainty will be calculated as
-        DELTA_MINUS = sqrt(counts)
+        uncert_minus = sqrt(counts)
 
     Parameters
     ----------
@@ -202,16 +200,16 @@ def calculate_uncertainties(dataset: xr.Dataset) -> xr.Dataset:
         "hdr_code_ok",
         "hdr_minute_cnt",
         "livetime_counter",
-        "h_energy_min",
-        "h_energy_max",
-        "he4_energy_min",
-        "he4_energy_max",
-        "cno_energy_min",
-        "cno_energy_max",
-        "nemgsi_energy_min",
-        "nemgsi_energy_max",
-        "fe_energy_min",
-        "fe_energy_max",
+        "h_energy_delta_minus",
+        "h_energy_delta_plus",
+        "he4_energy_delta_minus",
+        "he4_energy_delta_plus",
+        "cno_energy_delta_minus",
+        "cno_energy_delta_plus",
+        "nemgsi_energy_delta_minus",
+        "nemgsi_energy_delta_plus",
+        "fe_energy_delta_minus",
+        "fe_energy_delta_plus",
     ]
 
     # Counts data that need uncertainties calculated
@@ -226,13 +224,13 @@ def calculate_uncertainties(dataset: xr.Dataset) -> xr.Dataset:
         safe_values_plus = np.maximum(dataset[var] + 1, 0).astype(np.float32)
         safe_values_minus = np.maximum(dataset[var], 0).astype(np.float32)
 
-        dataset[f"{var}_delta_plus"] = xr.DataArray(
+        dataset[f"{var}_stat_uncert_plus"] = xr.DataArray(
             np.where(
                 mask, np.sqrt(safe_values_plus) + 1, dataset[var].astype(np.float32)
             ),
             dims=dataset[var].dims,
         )
-        dataset[f"{var}_delta_minus"] = xr.DataArray(
+        dataset[f"{var}_stat_uncert_minus"] = xr.DataArray(
             np.where(mask, np.sqrt(safe_values_minus), dataset[var].astype(np.float32)),
             dims=dataset[var].dims,
         )
@@ -269,8 +267,8 @@ def process_science(
     # Decommutate and decompress the science data
     sci_dataset = decom_hit(dataset)
 
-    # Organize sector rates by species type
-    subcom_sectorates(sci_dataset)
+    # Organize sectored rates by species type
+    sci_dataset = subcom_sectorates(sci_dataset)
 
     # Split the science data into count rates and event datasets
     pha_raw_dataset = xr.Dataset(
@@ -282,18 +280,18 @@ def process_science(
     count_rates_dataset = calculate_uncertainties(count_rates_dataset)
 
     # Logical sources for the two products.
-    logical_sources = ["imap_hit_l1a_count-rates", "imap_hit_l1a_pulse-height-events"]
+    logical_sources = ["imap_hit_l1a_counts", "imap_hit_l1a_direct-events"]
 
     datasets = []
     # Update attributes and dimensions
-    for dataset, logical_source in zip(
+    for ds, logical_source in zip(
         [count_rates_dataset, pha_raw_dataset], logical_sources
     ):
-        dataset.attrs = attr_mgr.get_global_attributes(logical_source)
+        ds.attrs = attr_mgr.get_global_attributes(logical_source)
 
         # TODO: Add CDF attributes to yaml once they're defined for L1A science data
         # Assign attributes and dimensions to each data array in the Dataset
-        for field in dataset.data_vars.keys():
+        for field in ds.data_vars.keys():
             try:
                 # Create a dict of dimensions using the DEPEND_I keys in the
                 # attributes
@@ -302,19 +300,17 @@ def process_science(
                     for key, value in attr_mgr.get_variable_attributes(field).items()
                     if "DEPEND" in key
                 }
-                dataset[field].attrs = attr_mgr.get_variable_attributes(field)
-                dataset[field].assign_coords(dims)
+                ds[field].attrs = attr_mgr.get_variable_attributes(field)
+                ds[field].assign_coords(dims)
             except KeyError:
                 print(f"Field {field} not found in attribute manager.")
                 logger.warning(f"Field {field} not found in attribute manager.")
 
         # Skip schema check for epoch to prevent attr_mgr from adding the
         # DEPEND_0 attribute which isn't required for epoch
-        dataset.epoch.attrs = attr_mgr.get_variable_attributes(
-            "epoch", check_schema=False
-        )
+        ds.epoch.attrs = attr_mgr.get_variable_attributes("epoch", check_schema=False)
 
-        datasets.append(dataset)
+        datasets.append(ds)
 
         logger.info(f"HIT L1A dataset created for {logical_source}")