imap-processing 1.0.31__tar.gz → 1.0.32__tar.gz

{imap_processing-1.0.31 → imap_processing-1.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imap-processing
-Version: 1.0.31
+Version: 1.0.32
 Summary: IMAP Science Operations Center Processing
 License: MIT
 License-File: LICENSE

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/_version.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced later during substitution.
-__version__ = "1.0.31"
-__version_tuple__ = (1, 0, 31)
+__version__ = "1.0.32"
+__version_tuple__ = (1, 0, 32)

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/cdf/config/imap_codice_l1a_variable_attrs.yaml

@@ -902,6 +902,7 @@ de_2d_attrs:
   DEPEND_0: epoch
   DEPEND_1: priority
   DICT_KEY: SPASE>Support>SupportQuantity:Other
+  DISPLAY_TYPE: spectogram
   FIELDNAM: Direct Event Data
   FILLVAL: -9223372036854775808
   FORMAT: I5
@@ -919,6 +920,7 @@ de_3d_attrs:
   DEPEND_1: priority
   DEPEND_2: event_num
   DICT_KEY: SPASE>Support>SupportQuantity:Other
+  DISPLAY_TYPE: spectogram
   FIELDNAM: Direct Event Data
   FILLVAL: -9223372036854775808
   FORMAT: I{num_digits}

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/cli.py

@@ -87,6 +87,10 @@ from imap_processing.ultra.l1a import ultra_l1a
 from imap_processing.ultra.l1b import ultra_l1b
 from imap_processing.ultra.l1c import ultra_l1c
 from imap_processing.ultra.l2 import ultra_l2
+from imap_processing.utils import (
+    check_epochs_within_day_offsets,
+    filter_day_boundary_data,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -618,6 +622,8 @@ class Codice(ProcessInstrument):
         if self.data_level == "l1a":
             # process data
             datasets = codice_l1a.process_l1a(dependencies)
+            for i, ds in enumerate(datasets):
+                datasets[i] = filter_day_boundary_data(ds, self.start_date)
 
         if self.data_level == "l1b":
             science_files = dependencies.get_file_paths(source="codice")
@@ -1406,6 +1412,10 @@ class Mag(ProcessInstrument):
                     f"Timestamps for output file {ds.attrs['Logical_source']} are not "
                     f"monotonically increasing."
                 )
+
+        # Will raise an error if any timestamps are outside the current day
+        check_epochs_within_day_offsets(datasets, current_day)
+
         return datasets
 
     def post_processing(
@@ -1568,6 +1578,8 @@ class Swapi(ProcessInstrument):
 
             # process science or housekeeping data
             datasets = swapi_l1(dependencies, descriptor=self.descriptor)
+            for i, ds in enumerate(datasets):
+                datasets[i] = filter_day_boundary_data(ds, self.start_date)
         elif self.data_level == "l2":
             if len(dependency_list) != 3:
                 raise ValueError(
@@ -1624,6 +1636,8 @@ class Swe(ProcessInstrument):
                 )
             science_files = dependencies.get_file_paths(source="swe")
             datasets = swe_l1a(str(science_files[0]))
+            for i, ds in enumerate(datasets):
+                datasets[i] = filter_day_boundary_data(ds, self.start_date)
             # Right now, we only process science data. Therefore,
             # we expect only one dataset to be returned.
 

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/codice/codice_l1a.py

@@ -19,7 +19,6 @@ from imap_processing.codice.codice_l1a_hi_counters_singles import (
 from imap_processing.codice.codice_l1a_hi_omni import l1a_hi_omni
 from imap_processing.codice.codice_l1a_hi_priority import l1a_hi_priority
 from imap_processing.codice.codice_l1a_hi_sectored import l1a_hi_sectored
-from imap_processing.codice.codice_l1a_lo_angular import l1a_lo_angular
 from imap_processing.codice.codice_l1a_lo_counters_aggregated import (
     l1a_lo_counters_aggregated,
 )
@@ -83,17 +82,6 @@ def process_l1a(  # noqa: PLR0912
             datasets.append(
                 process_by_table_id(datasets_by_apid[apid], lut_file, l1a_lo_species)
             )
-        elif apid == CODICEAPID.COD_LO_NSW_SPECIES_COUNTS:
-            logger.info("Processing Lo NSW Species Counts")
-            datasets.append(
-                process_by_table_id(datasets_by_apid[apid], lut_file, l1a_lo_species)
-            )
-        elif apid == CODICEAPID.COD_LO_SW_ANGULAR_COUNTS:
-            logger.info("Processing Lo SW Angular Counts")
-            datasets.append(l1a_lo_angular(datasets_by_apid[apid], lut_file))
-        elif apid == CODICEAPID.COD_LO_NSW_ANGULAR_COUNTS:
-            logger.info("Processing Lo NSW Angular Counts")
-            datasets.append(l1a_lo_angular(datasets_by_apid[apid], lut_file))
         elif apid == CODICEAPID.COD_HI_OMNI_SPECIES_COUNTS:
             datasets.append(
                 process_by_table_id(datasets_by_apid[apid], lut_file, l1a_hi_omni)

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/codice/codice_l1a_lo_species.py

@@ -11,7 +11,6 @@ from imap_processing.codice import constants
 from imap_processing.codice.constants import (
     HALF_SPIN_FILLVAL,
     LO_IALIRT_VARIABLE_NAMES,
-    LO_NSW_SPECIES_VARIABLE_NAMES,
     LO_SW_SPECIES_VARIABLE_NAMES,
 )
 from imap_processing.codice.decompress import decompress
@@ -28,7 +27,7 @@ from imap_processing.spice.time import met_to_ttj2000ns
 logger = logging.getLogger(__name__)
 
 
-def l1a_lo_species(  # noqa: PLR0912
+def l1a_lo_species(
     group_ds: xr.Dataset,
     lut_file: Path,
     table_id: str,
@@ -73,7 +72,7 @@ def l1a_lo_species(  # noqa: PLR0912
         raise ValueError("Unsupported sensor ID for Lo species processing.")
 
     # ========= Decompress and Reshape Data ===========
-    # Lookup SW or NSW species based on APID
+    # Lookup SW species based on APID
     if view_tab_obj.apid == CODICEAPID.COD_LO_SW_SPECIES_COUNTS:
         actual_species_names = sci_lut_data["data_product_lo_tab"]["0"]["species"][
             "sw"
@@ -85,28 +84,6 @@ def l1a_lo_species(  # noqa: PLR0912
             + LO_SW_SPECIES_VARIABLE_NAMES
         )
         logical_source_id = "imap_codice_l1a_lo-sw-species"
-    elif view_tab_obj.apid == CODICEAPID.COD_LO_NSW_SPECIES_COUNTS:
-        actual_species_names = sci_lut_data["data_product_lo_tab"]["0"]["species"][
-            "nsw"
-        ]["species_names"]
-        desired_species_names = set(
-            sci_lut_data["data_product_lo_tab"]["0"]["species"]["nsw"][
-                "desired_species_names"
-            ]
-            + LO_NSW_SPECIES_VARIABLE_NAMES
-        )
-        logical_source_id = "imap_codice_l1a_lo-nsw-species"
-        # Rename "cnoplus" to "junk" if we are processing NSW angular data. Although
-        # cnoplus is in desired, and actual species name in the LUT, it is referencing
-        # different "cnoplus" data his is to handle the bug in which the spacecraft was
-        # sending data down "off by one" and getting mislabeled. The cnoplus data we
-        # are referencing is actually data that we want to toss out and fill with
-        # fill vals. This only affects data before the LUT was updated
-        # (table_id 3978152295).
-        if int(table_id) <= 3978152295:
-            actual_species_names = [
-                "junk" if name == "cnoplus" else name for name in actual_species_names
-            ]
     elif view_tab_obj.apid == CODICEAPID.COD_LO_IAL:
         actual_species_names = sci_lut_data["data_product_lo_tab"]["0"]["ialirt"]["sw"][
             "species_names"

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/codice/codice_l1b.py

@@ -67,8 +67,6 @@ def convert_to_rates(dataset: xr.Dataset, descriptor: str) -> np.ndarray:
     if descriptor in [
         "lo-counters-aggregated",
         "lo-counters-singles",
-        "lo-nsw-angular",
-        "lo-sw-angular",
         "lo-nsw-priority",
         "lo-sw-priority",
     ]:
@@ -93,7 +91,6 @@ def convert_to_rates(dataset: xr.Dataset, descriptor: str) -> np.ndarray:
         ]
         dataset = dataset.drop_vars(drop_variables)
     elif descriptor in [
-        "lo-nsw-species",
         "lo-sw-species",
         "lo-ialirt",
     ]:

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/codice/codice_l2.py

@@ -28,18 +28,13 @@ from imap_processing.codice.constants import (
     HI_OMNI_VARIABLE_NAMES,
     HI_SECTORED_VARIABLE_NAMES,
     L2_HI_SECTORED_ANGLE,
-    LO_NSW_ANGULAR_VARIABLE_NAMES,
-    LO_NSW_SPECIES_VARIABLE_NAMES,
     LO_POSITION_TO_ELEVATION_ANGLE,
-    LO_SW_ANGULAR_VARIABLE_NAMES,
     LO_SW_PICKUP_ION_SPECIES_VARIABLE_NAMES,
     LO_SW_SOLAR_WIND_SPECIES_VARIABLE_NAMES,
-    NSW_POSITIONS,
     PUI_POSITIONS,
     SOLAR_WIND_POSITIONS,
     SSD_ID_TO_ELEVATION,
     SSD_ID_TO_SPIN_ANGLE,
-    SW_POSITIONS,
 )
 from imap_processing.codice.utils import apply_replacements_to_attrs
 
@@ -571,156 +566,6 @@ def process_lo_species_intensity(
     return dataset
 
 
-def process_lo_angular_intensity(
-    dataset: xr.Dataset,
-    species_list: list,
-    geometric_factors: xr.DataArray,
-    efficiency: pd.DataFrame,
-    positions: list,
-) -> xr.Dataset:
-    """
-    Process the lo-species L2 dataset to calculate angular intensities.
-
-    Parameters
-    ----------
-    dataset : xarray.Dataset
-        The L2 dataset to process.
-    species_list : list
-        List of species variable names to calculate intensity.
-    geometric_factors : xarray.DataArray
-        The geometric factors array with shape (epoch, esa_steps).
-    efficiency : pandas.DataFrame
-        The efficiency lookup table.
-    positions : list
-        A list of position indices to select from the geometric factor and
-        efficiency lookup tables.
-
-    Returns
-    -------
-    xarray.Dataset
-        The updated L2 dataset with angular intensities calculated.
-    """
-    # Calculate the angular intensities using the provided geometric factors and
-    # efficiency.
-    dataset = calculate_intensity(
-        dataset,
-        species_list,
-        geometric_factors,
-        efficiency,
-        positions,
-        average_across_positions=False,
-    )
-
-    # transform positions to elevation angles
-    if positions == SW_POSITIONS:
-        pos_to_el = LO_POSITION_TO_ELEVATION_ANGLE["sw"]
-        position_index_to_adjust = 0
-        direction = "Sunward"
-    elif positions == NSW_POSITIONS:
-        pos_to_el = LO_POSITION_TO_ELEVATION_ANGLE["nsw"]
-        position_index_to_adjust = 9
-        direction = "Non-Sunward"
-    else:
-        raise ValueError("Unknown positions for elevation angle mapping.")
-
-    # Create a new coordinate for elevation_angle based on inst_az
-    dataset = dataset.assign_coords(
-        elevation_angle=(
-            "inst_az",
-            [pos_to_el[pos] for pos in dataset["inst_az"].data],
-        )
-    )
-    # add uncertainties to species list
-    species_list = species_list + [f"unc_{var}" for var in species_list]
-
-    # Take the mean across elevation angles and restore the original dimension order
-    dataset_converted = (
-        dataset[species_list]
-        .groupby("elevation_angle")
-        .sum(keep_attrs=True, skipna=False)  # One position should always contain zeros
-        # so sum is safe
-        # Restore original dimension order because groupby moves the grouped
-        # dimension to the front
-        .transpose("epoch", "esa_step", "spin_sector", "elevation_angle", ...)
-    )
-    # Create a new coordinate for spin angle based on spin_sector
-    # Use equation from section 11.2.2 of algorithm document
-    dataset = dataset.assign_coords(
-        spin_angle=("spin_sector", dataset["spin_sector"].data * 15.0 + 7.5)
-    )
-    dataset = dataset.drop_vars(species_list).merge(dataset_converted)
-
-    # Positions 0 and 10 only observe half of the 24 spins for each esa step.
-    # To account for this, we replicate the counts observed in position 0 and 10 for
-    # each esa step to either spin angles 0-11 or 12-23, depending on the pixel
-    # orientation (A/B). See section 11.2.2 of the CoDICE algorithm document
-    # Use the variable "half_spin_per_esa_step" to determine the pixel orientations.
-    # When the half spin number is even, the configuration is A and when the half spin
-    # is odd, the configuration is B.
-    # TODO handle when half_spin_per_esa_step changes in the middle of the dataset
-    half_spin_per_esa_step = dataset["half_spin_per_esa_step"].data[0]
-    # only consider valid half spin values
-    valid_half_spin = half_spin_per_esa_step != HALF_SPIN_FILLVAL
-    a_inds = np.nonzero(valid_half_spin & (half_spin_per_esa_step % 2 == 0))[0]
-    b_inds = np.nonzero(valid_half_spin & (half_spin_per_esa_step % 2 == 1))[0]
-
-    position_index = position_index_to_adjust
-    for species in species_list:
-        # Create a copy of the dataset to avoid modifying the original
-        species_data = dataset[species].data.copy()
-        # Determine the correct spin indices based on the position
-        spin_sectors = dataset["spin_sector"].data
-        spin_inds_1 = np.where(spin_sectors >= 12)[0]
-        spin_inds_2 = np.where(spin_sectors < 12)[0]
-
-        # if position_index is 9, swap the spin indices
-        if position_index == 9:
-            spin_inds_1, spin_inds_2 = spin_inds_2, spin_inds_1
-
-        # Assign the values to the correct positions and spin sectors
-        dataset[species].values[
-            :, a_inds[:, np.newaxis], spin_inds_1, position_index
-        ] = species_data[:, a_inds[:, np.newaxis], spin_inds_2, position_index]
-
-        dataset[species].values[
-            :, b_inds[:, np.newaxis], spin_inds_2, position_index
-        ] = species_data[:, b_inds[:, np.newaxis], spin_inds_1, position_index]
-    cdf_attrs = ImapCdfAttributes()
-    cdf_attrs.add_instrument_variable_attrs("codice", "l2-lo-angular")
-    species_attrs = cdf_attrs.get_variable_attributes("lo-angular-attrs")
-    unc_attrs = cdf_attrs.get_variable_attributes("lo-angular-unc-attrs")
-
-    # update species attrs
-    for species in species_list:
-        attrs = unc_attrs if "unc" in species else species_attrs
-        # Replace {species} and {direction} in attrs
-        attrs = apply_replacements_to_attrs(
-            attrs, {"species": species, "direction": direction}
-        )
-        dataset[species].attrs.update(attrs)
-
-    # make sure elevation_angle is a coordinate and has the right attrs
-    dataset["elevation_angle"].attrs.update(
-        cdf_attrs.get_variable_attributes("elevation_angle", check_schema=False)
-    )
-    dataset["elevation_angle_label"] = xr.DataArray(
-        dataset["elevation_angle"].data.astype(str),
-        dims=("elevation_angle",),
-        attrs=cdf_attrs.get_variable_attributes(
-            "elevation_angle_label", check_schema=False
-        ),
-    )
-    # update spin angle attributes
-    dataset["spin_angle"].attrs = cdf_attrs.get_variable_attributes(
-        "spin_angle", check_schema=False
-    )
-    # update spin sector attributes
-    dataset["spin_sector"].attrs = cdf_attrs.get_variable_attributes(
-        "spin_sector", check_schema=False
-    )
-    return dataset
-
-
 def process_hi_omni(dependencies: ProcessingInputCollection) -> xr.Dataset:
     """
     Process the hi-omni L1B dataset to calculate omni-directional intensities.
@@ -1517,9 +1362,6 @@ def process_codice_l2(
     # Compute geometric factors needed for intensity calculations
     if dataset_name in [
         "imap_codice_l2_lo-sw-species",
-        "imap_codice_l2_lo-nsw-species",
-        "imap_codice_l2_lo-nsw-angular",
-        "imap_codice_l2_lo-sw-angular",
     ]:
         cdf_attrs = ImapCdfAttributes()
         cdf_attrs.add_instrument_global_attrs("codice")
@@ -1556,57 +1398,6 @@ def process_codice_l2(
             l2_dataset.attrs.update(
                 cdf_attrs.get_global_attributes("imap_codice_l2_lo-sw-species")
             )
-        elif dataset_name == "imap_codice_l2_lo-nsw-species":
-            geometric_factors = compute_geometric_factors(
-                l2_dataset, geometric_factor_lookup
-            )
-            # Filter the efficiency lookup table for non-solar wind efficiencies
-            efficiencies = efficiency_lookup[efficiency_lookup["product"] == "nsw"]
-            # Calculate the non-sunward species intensities using equation
-            # described in section 11.2.3 of algorithm document.
-            l2_dataset = process_lo_species_intensity(
-                l2_dataset,
-                LO_NSW_SPECIES_VARIABLE_NAMES,
-                geometric_factors,
-                efficiencies,
-                NSW_POSITIONS,
-            )
-            l2_dataset.attrs.update(
-                cdf_attrs.get_global_attributes("imap_codice_l2_lo-nsw-species")
-            )
-        elif dataset_name == "imap_codice_l2_lo-sw-angular":
-            geometric_factors = compute_geometric_factors(
-                l2_dataset, geometric_factor_lookup, angular_product=True
-            )
-            efficiencies = efficiency_lookup[efficiency_lookup["product"] == "sw"]
-            # Calculate the sunward solar wind angular intensities using equation
-            # described in section 11.2.2 of algorithm document.
-            l2_dataset = process_lo_angular_intensity(
-                l2_dataset,
-                LO_SW_ANGULAR_VARIABLE_NAMES,
-                geometric_factors,
-                efficiencies,
-                SW_POSITIONS,
-            )
-            l2_dataset.attrs.update(
-                cdf_attrs.get_global_attributes("imap_codice_l2_lo-sw-angular")
-            )
-        if dataset_name == "imap_codice_l2_lo-nsw-angular":
-            geometric_factors = compute_geometric_factors(
-                l2_dataset, geometric_factor_lookup, angular_product=True
-            )
-            # Calculate the non sunward angular intensities
-            efficiencies = efficiency_lookup[efficiency_lookup["product"] == "nsw"]
-            l2_dataset = process_lo_angular_intensity(
-                l2_dataset,
-                LO_NSW_ANGULAR_VARIABLE_NAMES,
-                geometric_factors,
-                efficiencies,
-                NSW_POSITIONS,
-            )
-            l2_dataset.attrs.update(
-                cdf_attrs.get_global_attributes("imap_codice_l2_lo-nsw-angular")
-            )
 
     if dataset_name in [
         "imap_codice_l2_hi-counters-singles",

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/codice/constants.py

@@ -846,21 +846,12 @@ L1B_DATA_PRODUCT_CONFIGURATIONS: dict[str, dict] = {
     "lo-counters-singles": {
         "num_spin_sectors": 2,
     },
-    "lo-nsw-angular": {
-        "num_spin_sectors": 1,
-    },
-    "lo-sw-angular": {
-        "num_spin_sectors": 1,
-    },
     "lo-nsw-priority": {
         "num_spin_sectors": 1,
     },
     "lo-sw-priority": {
         "num_spin_sectors": 1,
     },
-    "lo-nsw-species": {
-        "num_spin_sectors": 12,
-    },
     "lo-sw-species": {
         "num_spin_sectors": 12,
     },
@@ -890,16 +881,6 @@ LO_SW_PICKUP_ION_SPECIES_VARIABLE_NAMES = [
     "heplus",
     "cnoplus",
 ]
-LO_NSW_SPECIES_VARIABLE_NAMES = [
-    "hplus",
-    "heplusplus",
-    "c",
-    "o",
-    "ne_si_mg",
-    "fe",
-    "heplus",
-    "cnoplus",
-]
 HI_OMNI_VARIABLE_NAMES = ["h", "he3", "he4", "c", "o", "ne_mg_si", "fe", "uh", "junk"]
 HI_SECTORED_VARIABLE_NAMES = ["h", "he3he4", "cno", "fe"]
 HI_PRIORITY_VARIABLE_NAMES = [

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/glows/l1a/glows_l1a.py

@@ -338,6 +338,25 @@ def generate_histogram_dataset(
         )
     hist_l1a_list = valid_hists
 
+    # Deduplicate by (imap_start_time, imap_time_offset), keeping the first occurrence.
+    seen_times: dict = {}
+    for hist in hist_l1a_list:
+        key = (
+            hist.imap_start_time.seconds,
+            hist.imap_start_time.subseconds,
+            hist.imap_time_offset.seconds,
+            hist.imap_time_offset.subseconds,
+        )
+        if key not in seen_times:
+            seen_times[key] = hist
+    dedup_hists = list(seen_times.values())
+    if len(dedup_hists) < len(hist_l1a_list):
+        logger.warning(
+            f"GLOWS: Filtered out {len(hist_l1a_list) - len(dedup_hists)} "
+            f"duplicate histogram(s) by imap_start_time and imap_time_offset."
+        )
+    hist_l1a_list = dedup_hists
+
     # Store timestamps for each HistogramL1A object.
     time_data: np.ndarray = np.zeros(len(hist_l1a_list), dtype=np.int64)
     # Data in lists, for each of the 25 time varying datapoints in HistogramL1A

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/ialirt/calculate_ingest.py

@@ -50,7 +50,7 @@ def packets_created(start_file_creation: datetime, lines: list) -> dict:
             # Handle end of year rollover
             prev = prev_doy[station]
 
-            if prev is not None and doy < prev:
+            if prev is not None and doy < prev and prev > 300 and doy < 30:
                 station_year[station] += 1
 
             prev_doy[station] = doy

{imap_processing-1.0.31 → imap_processing-1.0.32}/imap_processing/idex/idex_l2a.py

@@ -300,6 +300,48 @@ def idex_l2a(l1b_dataset: xr.Dataset, ancillary_files: dict) -> xr.Dataset:
             "target_fit_parameter_labels", check_schema=False
         ),
     )
+
+    # We're inserting a NaN block here for the 2026 June release while the
+    # IDEX science team works through validating the fitting routines and
+    # derived values.
+
+    # Ion Grid Fitting:
+    l2a_dataset["ion_grid_dust_mass_estimate"].data = np.full(
+        l2a_dataset["ion_grid_dust_mass_estimate"].shape, np.nan
+    )
+
+    l2a_dataset["ion_grid_velocity_estimate"].data = np.full(
+        l2a_dataset["ion_grid_velocity_estimate"].shape, np.nan
+    )
+
+    # TOF / Mass-spec Fitting
+    l2a_dataset["tof_peak_area_under_fit"].data = np.full(
+        l2a_dataset["tof_peak_area_under_fit"].shape, np.nan
+    )
+
+    l2a_dataset["tof_peak_chi_square"].data = np.full(
+        l2a_dataset["tof_peak_chi_square"].shape, np.nan
+    )
+
+    l2a_dataset["tof_peak_fit_parameters"].data = np.full(
+        l2a_dataset["tof_peak_fit_parameters"].shape, np.nan
+    )
+
+    l2a_dataset["tof_peak_kappa"].data = np.full(
+        l2a_dataset["tof_peak_kappa"].shape, np.nan
+    )
+
+    l2a_dataset["tof_peak_reduced_chi_square"].data = np.full(
+        l2a_dataset["tof_peak_reduced_chi_square"].shape, np.nan
+    )
+
+    l2a_dataset["tof_snr"].data = np.full(l2a_dataset["tof_snr"].shape, np.nan)
+
+    l2a_dataset["mass"].data = np.full(l2a_dataset["mass"].shape, np.nan)
+
+    l2a_dataset["mass_scale"].data = np.full(l2a_dataset["mass_scale"].shape, np.nan)
+    # End NaN block
+
     logger.info("IDEX L2A science data processing completed.")
     l2a_dataset.attrs.update(idex_attrs.get_global_attributes("imap_idex_l2a_sci"))
     return l2a_dataset
@@ -334,29 +376,66 @@ def calculate_velocity_and_mass(
     mass_est : float
         Estimated mass.
     """
+    v_est = invert_rise_time_to_velocity(t_rise, t_rise_params)
+    if not np.isfinite(v_est):
+        return np.nan, np.nan
+
+    log_a_y: float = float(yield_params[0])
+    yield_val = 10 ** log_smooth_powerlaw(np.log10(v_est), log_a_y, yield_params[1:])
+    sig_amp_coulombs = sig_amp * idex_constants.PICOCOULOMB_TO_COULOMB
+    mass_est = sig_amp_coulombs / yield_val
+
+    return v_est, mass_est
+
+
+def invert_rise_time_to_velocity(t_rise: float, t_rise_params: np.ndarray) -> float:
+    """
+    Invert the rise-time calibration to estimate impact velocity.
+
+    The rise-time calibration is defined in the forward direction as
+    rise_time = f(velocity). This helper numerically inverts that relation to recover
+    velocity from a fitted rise time.
+
+    Parameters
+    ----------
+    t_rise : float
+        Fitted target rise time in microseconds.
+    t_rise_params : np.ndarray
+        Calibration parameters for the forward rise-time curve
+        [A, a1, a2, a3, vb, vc, k, m].
+
+    Returns
+    -------
+    float
+        Estimated impact velocity in km/s, or NaN if the inversion fails.
+    """
+    if not np.isfinite(t_rise) or t_rise <= 0.0:
+        logger.error(
+            "Unable to calculate velocity estimate from rise time %.6g. "
+            "Rise time must be finite and positive. Returning nan.",
+            t_rise,
+        )
+        return np.nan
+
     log_a_t: float = float(t_rise_params[0])
+    target_log_t_rise = np.log10(t_rise)
     try:
         root = root_scalar(
-            lambda lv: (
-                log_smooth_powerlaw(lv, log_a_t, t_rise_params[1:]) - np.log10(t_rise)
+            lambda log_v: (
+                log_smooth_powerlaw(log_v, log_a_t, t_rise_params[1:])
+                - target_log_t_rise
             ),
             bracket=[-1, 2],
+            method="brentq",
         )
-        v_est = 10**root.root
+        return 10**root.root
     except Exception:
         logger.error(
-            "Unable to calculate velocity and mass estimate. "
-            "The root finding failed for power law function. "
-            "Returning nans for the estimate."
+            "Unable to calculate velocity estimate from rise time %.6g. "
+            "The rise-time calibration inversion failed. Returning nan.",
+            t_rise,
         )
-        return np.nan, np.nan
-
-    log_a_y: float = float(yield_params[0])
-    yield_val = 10 ** log_smooth_powerlaw(np.log10(v_est), log_a_y, yield_params[1:])
-    sig_amp_coulombs = sig_amp * idex_constants.PICOCOULOMB_TO_COULOMB
-    mass_est = sig_amp_coulombs / yield_val
-
-    return v_est, mass_est
+        return np.nan
 
 
 def log_smooth_powerlaw(log_v: float, log_a: float, params: np.ndarray) -> float:
@@ -364,15 +443,14 @@ def log_smooth_powerlaw(log_v: float, log_a: float, params: np.ndarray) -> float
     Define a smoothly transitioning power law used by the IDEX calibration curves.
 
     This helper is used in two ways:
-    - rise-time calibration: log10(rise_time [us]) to log10(velocity [km/s])
+    - rise-time calibration: log10(velocity [km/s]) to log10(rise_time [us])
     - yield calibration: log10(velocity [km/s]) to log10(charge_yield [C/kg])
 
     Parameters
     ----------
     log_v : float
         The log10 input to the calibration curve.
-        This is either log10(rise_time [us]) for the rise-time case or
-        Log10(velocity [km/s]) for the yield case.
+        This is log10(velocity [km/s]) for both the rise-time and yield cases.
     log_a : float
         Log10 of the calibration scale factor A.
     params : np.ndarray
@@ -383,7 +461,7 @@ def log_smooth_powerlaw(log_v: float, log_a: float, params: np.ndarray) -> float
     -------
     float
         The calibrated log10 output.
-        This is either log10(velocity [km/s]) for the rise-time case or
+        This is either log10(rise_time [us]) for the rise-time case or
         log10(charge_yield [C/kg]) for the yield case.
     """
     # Unpack the rest of the calibration parameters