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

imap_processing/hi/l1c/hi_l1c.py

@@ -42,7 +42,7 @@ SPIN_PHASE_BIN_CENTERS = (SPIN_PHASE_BIN_EDGES[:-1] + SPIN_PHASE_BIN_EDGES[1:])
 logger = logging.getLogger(__name__)
 
 
-def hi_l1c(dependencies: list, data_version: str) -> xr.Dataset:
+def hi_l1c(dependencies: list) -> list[xr.Dataset]:
     """
     High level IMAP-Hi l1c processing function.
 
@@ -56,10 +56,6 @@ def hi_l1c(dependencies: list, data_version: str) -> xr.Dataset:
     dependencies : list
         Input dependencies needed for l1c processing.
 
-    data_version : str
-        Data version to write to CDF files and the Data_version CDF attribute.
-        Should be in the format Vxxx.
-
     Returns
     -------
     l1c_dataset : xarray.Dataset
@@ -76,9 +72,7 @@ def hi_l1c(dependencies: list, data_version: str) -> xr.Dataset:
             "Input dependencies not recognized for l1c pset processing."
         )
 
-    # TODO: revisit this
-    l1c_dataset.attrs["Data_version"] = data_version
-    return l1c_dataset
+    return [l1c_dataset]
 
 
 def generate_pset_dataset(
@@ -108,14 +102,11 @@ def generate_pset_dataset(
     config_df = CalibrationProductConfig.from_csv(calibration_prod_config_path)
 
     pset_dataset = empty_pset_dataset(
+        de_dataset.epoch.data[0],
         de_dataset.esa_energy_step.data,
         config_df.cal_prod_config.number_of_products,
         logical_source_parts["sensor"],
     )
-    # For ISTP, epoch should be the center of the time bin.
-    pset_dataset.epoch.data[0] = np.mean(de_dataset.epoch.data[[0, -1]]).astype(
-        np.int64
-    )
     pset_et = ttj2000ns_to_et(pset_dataset.epoch.data[0])
     # Calculate and add despun_z, hae_latitude, and hae_longitude variables to
     # the pset_dataset
@@ -144,13 +135,15 @@ def generate_pset_dataset(
 
 
 def empty_pset_dataset(
-    l1b_energy_steps: np.ndarray, n_cal_prods: int, sensor_str: str
+    epoch_val: int, l1b_energy_steps: np.ndarray, n_cal_prods: int, sensor_str: str
 ) -> xr.Dataset:
     """
     Allocate an empty xarray.Dataset with appropriate pset coordinates.
 
     Parameters
     ----------
+    epoch_val : int
+        The starting epoch in J2000 TT nanoseconds for data in the PSET.
     l1b_energy_steps : np.ndarray
         The array of esa_energy_step data from the L1B DE product.
     n_cal_prods : int
@@ -170,12 +163,12 @@ def empty_pset_dataset(
     # preallocate coordinates xr.DataArrays
     coords = dict()
     # epoch coordinate has only 1 entry for pointing set
-    epoch_attrs = attr_mgr.get_variable_attributes("epoch")
+    epoch_attrs = attr_mgr.get_variable_attributes("epoch", check_schema=False)
     epoch_attrs.update(
         attr_mgr.get_variable_attributes("hi_pset_epoch", check_schema=False)
     )
     coords["epoch"] = xr.DataArray(
-        np.empty(1, dtype=np.int64),  # TODO: get dtype from cdf attrs?
+        np.array([epoch_val], dtype=np.int64),  # TODO: get dtype from cdf attrs?
         name="epoch",
         dims=["epoch"],
         attrs=epoch_attrs,
@@ -526,6 +519,9 @@ def pset_exposure(
         )[0]
         exposure_var["exposure_times"].values[:, i_esa] += new_exposure_times
 
+    # Convert exposure clock ticks to seconds
+    exposure_var["exposure_times"].values *= DE_CLOCK_TICK_S
+
     return exposure_var
 
 
@@ -604,7 +600,7 @@ def get_de_clock_ticks_for_esa_step(
     # The CCSDS packet gets created just AFTER the final spin in the 8-spin
     # ESA step group so this match is the end time. The start time is
     # 8-spins earlier.
-    spin_start_mets = spin_df.spin_start_time.to_numpy()
+    spin_start_mets = spin_df.spin_start_met.to_numpy()
     # CCSDS MET has one second resolution, add one to it to make sure it is
     # greater than the spin start time it ended on.
     end_time_ind = np.flatnonzero(ccsds_met + 1 >= spin_start_mets).max()

imap_processing/hit/ancillary/imap_hit_l1b-to-l2-sector-dt0-factors_20250219_v002.csv

@@ -0,0 +1,81 @@
+Species, Sector, Lower Energy (MeV), Upper Energy (MeV), Delta E (MeV), Geometry Factor (cm2 sr), Efficiency, b
+H      ,0,1.8,4,2.2,0.41686,1,0
+H      ,1,1.8,4,2.2,0.49253,1,0
+H      ,2,1.8,4,2.2,0.45156,1,0
+H      ,3,1.8,4,2.2,0.35599,1,0
+H      ,4,1.8,4,2.2,0.33312,1,0
+H      ,5,1.8,4,2.2,0.47444,1,0
+H      ,6,1.8,4,2.2,0.49253,1,0
+H      ,7,1.8,4,2.2,0.41686,1,0
+H      ,0,4,6,2,0.42008,1,0
+H      ,1,4,6,2,0.49746,1,0
+H      ,2,4,6,2,0.45515,1,0
+H      ,3,4,6,2,0.35921,1,0
+H      ,4,4,6,2,0.33619,1,0
+H      ,5,4,6,2,0.47817,1,0
+H      ,6,4,6,2,0.49746,1,0
+H      ,7,4,6,2,0.42008,1,0
+H      ,0,6,10,4,0.39177,1,0
+H      ,1,6,10,4,0.47095,1,0
+H      ,2,6,10,4,0.42764,1,0
+H      ,3,6,10,4,0.33171,1,0
+H      ,4,6,10,4,0.31091,1,0
+H      ,5,6,10,4,0.44844,1,0
+H      ,6,6,10,4,0.47095,1,0
+H      ,7,6,10,4,0.39177,1,0
+He4    ,0,4,6,2,0.41995,1,0
+He4    ,1,4,6,2,0.49964,1,0
+He4    ,2,4,6,2,0.45649,1,0
+He4    ,3,4,6,2,0.3584,1,0
+He4    ,4,4,6,2,0.33563,1,0
+He4    ,5,4,6,2,0.47925,1,0
+He4    ,6,4,6,2,0.49964,1,0
+He4    ,7,4,6,2,0.41995,1,0
+He4    ,0,6,12,6,0.42404,1,0
+He4    ,1,6,12,6,0.5045,1,0
+He4    ,2,6,12,6,0.45897,1,0
+He4    ,3,6,12,6,0.36098,1,0
+He4    ,4,6,12,6,0.33793,1,0
+He4    ,5,6,12,6,0.48202,1,0
+He4    ,6,6,12,6,0.5045,1,0
+He4    ,7,6,12,6,0.42404,1,0
+CNO    ,0,4,6,2,0.41976,1,0
+CNO    ,1,4,6,2,0.49594,1,0
+CNO    ,2,4,6,2,0.45356,1,0
+CNO    ,3,4,6,2,0.35698,1,0
+CNO    ,4,4,6,2,0.33409,1,0
+CNO    ,5,4,6,2,0.47645,1,0
+CNO    ,6,4,6,2,0.49594,1,0
+CNO    ,7,4,6,2,0.41976,1,0
+CNO    ,0,6,12,6,0.42026,1,0
+CNO    ,1,6,12,6,0.49871,1,0
+CNO    ,2,6,12,6,0.45567,1,0
+CNO    ,3,6,12,6,0.35809,1,0
+CNO    ,4,6,12,6,0.3351,1,0
+CNO    ,5,6,12,6,0.47866,1,0
+CNO    ,6,6,12,6,0.49871,1,0
+CNO    ,7,6,12,6,0.42026,1,0
+NeMgSi ,0,4,6,2,0.37544,1,0
+NeMgSi ,1,4,6,2,0.43535,1,0
+NeMgSi ,2,4,6,2,0.40251,1,0
+NeMgSi ,3,4,6,2,0.32308,1,0
+NeMgSi ,4,4,6,2,0.30221,1,0
+NeMgSi ,5,4,6,2,0.42339,1,0
+NeMgSi ,6,4,6,2,0.43535,1,0
+NeMgSi ,7,4,6,2,0.37544,1,0
+NeMgSi ,0,6,12,6,0.42046,1,0
+NeMgSi ,1,6,12,6,0.49714,1,0
+NeMgSi ,2,6,12,6,0.45432,1,0
+NeMgSi ,3,6,12,6,0.35764,1,0
+NeMgSi ,4,6,12,6,0.33475,1,0
+NeMgSi ,5,6,12,6,0.47721,1,0
+NeMgSi ,6,6,12,6,0.49714,1,0
+NeMgSi ,7,6,12,6,0.42046,1,0
+Fe     ,0,4,12,8,0.2752,1,0
+Fe     ,1,4,12,8,0.31996,1,0
+Fe     ,2,4,12,8,0.29577,1,0
+Fe     ,3,4,12,8,0.23669,1,0
+Fe     ,4,4,12,8,0.2213,1,0
+Fe     ,5,4,12,8,0.31118,1,0
+Fe     ,6,4,12,8,0.31996,1,0
+Fe     ,7,4,12,8,0.2752,1,0

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
 
 
@@ -227,7 +224,7 @@ def initialize_particle_data_arrays(
     epoch_size: int,
 ) -> xr.Dataset:
     """
-    Create empty data arrays for a given particle.
+    Add empty data arrays for a given particle.
 
     Valid particle names:
         h
@@ -252,44 +249,43 @@ def initialize_particle_data_arrays(
     ----------
     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
     -------
-    dataset : xr.Dataset
-        The dataset with the added empty data arrays.
+    updated_ds : xr.Dataset
+        The updated dataset with the particle data arrays added.
     """
-    dataset[f"{particle}"] = xr.DataArray(
+    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}",
     )
-    dataset[f"{particle}_delta_minus"] = xr.DataArray(
+    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}_delta_minus",
+        name=f"{particle}_stat_uncert_minus",
     )
-    dataset[f"{particle}_delta_plus"] = xr.DataArray(
+    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}_delta_plus",
+        name=f"{particle}_stat_uncert_plus",
     )
-
-    dataset.coords[f"{particle}_energy_mean"] = xr.DataArray(
+    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 dataset
+
+    return updated_ds
 
 
 def sum_particle_data(
@@ -318,10 +314,10 @@ def sum_particle_data(
     summed_data : xr.DataArray
         The summed data for the given energy range.
 
-    summed_uncertainty_delta_minus : xr.DataArray
+    summed_uncertainty_minus : xr.DataArray
         The summed data for delta minus statistical uncertainty.
 
-    summed_uncertainty_delta_plus : xr.DataArray
+    summed_uncertainty_plus : xr.DataArray
         The summed data for delta plus statistical uncertainty.
     """
     summed_data = (
@@ -330,19 +326,19 @@ def sum_particle_data(
         + dataset["penfgrates"][:, indices["R4"]].sum(axis=1)
     )
 
-    summed_uncertainty_delta_minus = (
-        dataset["l2fgrates_delta_minus"][:, indices["R2"]].sum(axis=1)
-        + dataset["l3fgrates_delta_minus"][:, indices["R3"]].sum(axis=1)
-        + dataset["penfgrates_delta_minus"][:, 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_delta_plus = (
-        dataset["l2fgrates_delta_plus"][:, indices["R2"]].sum(axis=1)
-        + dataset["l3fgrates_delta_plus"][:, indices["R3"]].sum(axis=1)
-        + dataset["penfgrates_delta_plus"][:, 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_delta_minus, summed_uncertainty_delta_plus
+    return summed_data, summed_uncertainty_minus, summed_uncertainty_plus
 
 
 def add_energy_variables(
@@ -367,27 +363,89 @@ def add_energy_variables(
 
     Returns
     -------
-    xr.Dataset
-        The dataset with the added energy variables.
+    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)
 
-    dataset[f"{particle}_energy_mean"] = xr.DataArray(
+    updated_ds[f"{particle}_energy_mean"] = xr.DataArray(
         data=energy_mean,
         dims=[f"{particle}_energy_mean"],
         name=f"{particle}_energy_mean",
     )
-    dataset[f"{particle}_energy_delta_minus"] = xr.DataArray(
+    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",
     )
-    dataset[f"{particle}_energy_delta_plus"] = xr.DataArray(
+    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
 
-    return dataset
+
+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/decom_hit.py

@@ -113,7 +113,9 @@ 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
         for dim in dims:
             if dim not in sci_dataset.coords:

imap_processing/hit/l1a/hit_l1a.py

@@ -24,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.
 
@@ -32,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
     -------
@@ -44,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 = []
 
@@ -63,7 +61,7 @@ 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.
 
@@ -94,9 +92,16 @@ def subcom_sectorates(sci_dataset: xr.Dataset) -> None:
     ----------
     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 15x8 arrays with fill values for each science frame.
@@ -111,7 +116,7 @@ def subcom_sectorates(sci_dataset: xr.Dataset) -> None:
 
     # 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]["counts"][i] = sci_dataset[
+        data_by_species_and_energy_range[mod_10]["counts"][i] = updated_dataset[
             "sectorates"
         ].values[i]
 
@@ -136,24 +141,26 @@ def subcom_sectorates(sci_dataset: xr.Dataset) -> None:
         # shape: epoch, energy_mean, azimuth, declination
         rates_data = np.transpose(np.array(data["counts"]), axes=(1, 0, 2, 3))
 
-        sci_dataset[f"{species}_sectored_counts"] = xr.DataArray(
+        updated_dataset[f"{species}_sectored_counts"] = xr.DataArray(
             data=rates_data,
             dims=["epoch", f"{species}_energy_mean", "azimuth", "declination"],
             name=f"{species}_counts_sectored",
         )
 
         # Add energy mean and deltas for each species
-        sci_dataset = add_energy_variables(
-            sci_dataset,
+        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
@@ -161,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
     ----------
@@ -217,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,
         )
@@ -261,7 +268,7 @@ def process_science(
     sci_dataset = decom_hit(dataset)
 
     # Organize sectored rates by species type
-    subcom_sectorates(sci_dataset)
+    sci_dataset = subcom_sectorates(sci_dataset)
 
     # Split the science data into count rates and event datasets
     pha_raw_dataset = xr.Dataset(
@@ -277,14 +284,14 @@ def process_science(
 
     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
@@ -293,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}")
 

imap_processing/hit/l1b/constants.py

@@ -2,7 +2,11 @@
 
 # Expected number of livestim pulses per integration time.
 # This is used to calculate the fractional livetime
-livestim_pulses = 270
+LIVESTIM_PULSES = 270
+
+# Fill values for missing data
+FILLVAL_FLOAT32 = -1.00e31
+FILLVAL_INT64 = -9223372036854775808
 
 # For the L1B summed rates product, counts are summed by particle type,
 # energy range, and detector penetration range (Range 2, Range 3, and Range 4).
@@ -20,7 +24,7 @@ livestim_pulses = 270
 # R4 = Indices for Range 4 (PENFGRATES)
 # energy_units: MeV/n
 
-PARTICLE_ENERGY_RANGE_MAPPING = {
+SUMMED_PARTICLE_ENERGY_RANGE_MAPPING = {
     "h": [
         {
             "energy_min": 1.8,