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

imap_processing/ultra/l1c/helio_pset.py

@@ -1,19 +1,45 @@
 """Calculate Pointing Set Grids."""
 
-import astropy_healpix.healpy as hp
+import logging
+
 import numpy as np
+import pandas as pd
 import xarray as xr
 
-from imap_processing.ultra.l1c.ultra_l1c_pset_bins import build_energy_bins
+from imap_processing.spice.repoint import get_pointing_times
+from imap_processing.spice.time import (
+    et_to_met,
+    met_to_ttj2000ns,
+    sct_to_et,
+    ttj2000ns_to_et,
+)
+from imap_processing.ultra.l1b.ultra_l1b_culling import get_de_rejection_mask
+from imap_processing.ultra.l1c.l1c_lookup_utils import (
+    calculate_pixels_within_scattering_threshold,
+    get_spacecraft_pointing_lookup_tables,
+)
+from imap_processing.ultra.l1c.ultra_l1c_pset_bins import (
+    build_energy_bins,
+    get_efficiencies_and_geometric_function,
+    get_helio_adjusted_data,
+    get_spacecraft_exposure_times,
+    get_spacecraft_histogram,
+)
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
+logger = logging.getLogger(__name__)
+
 
 def calculate_helio_pset(
     de_dataset: xr.Dataset,
     extendedspin_dataset: xr.Dataset,
     cullingmask_dataset: xr.Dataset,
+    rates_dataset: xr.Dataset,
+    params_dataset: xr.Dataset,
     name: str,
     ancillary_files: dict,
+    instrument_id: int,
+    species_id: int = 1,
 ) -> xr.Dataset:
     """
     Create dictionary with defined datatype for Pointing Set Grid Data.
@@ -26,27 +52,121 @@ def calculate_helio_pset(
         Dataset containing extendedspin data.
     cullingmask_dataset : xarray.Dataset
         Dataset containing cullingmask data.
+    rates_dataset : xarray.Dataset
+        Dataset containing image rates data.
+    params_dataset : xarray.Dataset
+        Dataset containing image parameters data.
     name : str
         Name of the dataset.
     ancillary_files : dict
         Ancillary files.
+    instrument_id : int
+        Instrument ID, either 45 or 90.
+    species_id : int
+        Species ID, default of 1 refers to Hydrogen.
 
     Returns
     -------
     dataset : xarray.Dataset
         Dataset containing the data.
     """
-    # TODO: Fill in the rest of this later.
     pset_dict: dict[str, np.ndarray] = {}
-    healpix = np.arange(hp.nside2npix(128))
-    _, _, energy_bin_geometric_means = build_energy_bins()
+    # Select only the species we are interested in.
+    indices = np.where(de_dataset["species"].values == species_id)[0]
+    species_dataset = de_dataset.isel(epoch=indices)
+
+    rejected = get_de_rejection_mask(
+        species_dataset["quality_scattering"].values,
+        species_dataset["quality_outliers"].values,
+    )
+    de_dataset = species_dataset.isel(epoch=~rejected)
+
+    v_mag_helio_spacecraft = np.linalg.norm(
+        species_dataset["velocity_dps_helio"].values, axis=1
+    )
+    vhat_dps_helio = (
+        species_dataset["velocity_dps_helio"].values
+        / v_mag_helio_spacecraft[:, np.newaxis]
+    )
+    intervals, _, energy_bin_geometric_means = build_energy_bins()
+    counts, latitude, longitude, n_pix = get_spacecraft_histogram(
+        vhat_dps_helio,
+        species_dataset["energy_heliosphere"].values,
+        intervals,
+        nside=128,
+    )
+
+    healpix = np.arange(n_pix)
 
+    # Get lookup table for FOR indices by spin phase step
+    (
+        for_indices_by_spin_phase,
+        theta_vals,
+        phi_vals,
+        ra_and_dec,
+        boundary_scale_factors,
+    ) = get_spacecraft_pointing_lookup_tables(ancillary_files, instrument_id)
+    # Check that the number of rows in the lookup table matches the number of pixels
+    if for_indices_by_spin_phase.shape[0] != n_pix:
+        logger.warning(
+            "The lookup table is expected to have the same number of rows as "
+            "the number of HEALPix pixels."
+        )
+
+    pixels_below_scattering = calculate_pixels_within_scattering_threshold(
+        for_indices_by_spin_phase, theta_vals, phi_vals, ancillary_files, instrument_id
+    )
+    # Calculate exposure
+    constant_exposure = ancillary_files["l1c-90sensor-dps-exposure"]
+    df_exposure = pd.read_csv(constant_exposure)
+    exposure_time, deadtime_ratios = get_spacecraft_exposure_times(
+        df_exposure,
+        rates_dataset,
+        params_dataset,
+        pixels_below_scattering,
+        boundary_scale_factors,
+    )
+    # calculate efficiency and geometric function as a function of energy
+    efficiencies, geometric_function = get_efficiencies_and_geometric_function(
+        pixels_below_scattering,
+        boundary_scale_factors,
+        theta_vals,
+        phi_vals,
+        n_pix,
+        ancillary_files,
+    )
+    # Get midpoint timestamp for pointing.
+    # TODO remove sct_to_et conversion
+    pointing_start, pointing_stop = get_pointing_times(
+        et_to_met(sct_to_et(species_dataset["event_times"].data[0]))
+    )
+    mid_time = ttj2000ns_to_et(met_to_ttj2000ns((pointing_start + pointing_stop) / 2))
+    exposure_time, efficiency, geometric_function = get_helio_adjusted_data(
+        mid_time,
+        exposure_time,
+        geometric_function,
+        efficiencies,
+        ra_and_dec[:, 0],
+        ra_and_dec[:, 1],
+    )
+    sensitivity = efficiencies * geometric_function
+
+    # For ISTP, epoch should be the center of the time bin.
     pset_dict["epoch"] = de_dataset.epoch.data[:1].astype(np.int64)
-    pset_dict["pixel_index"] = healpix
+    pset_dict["counts"] = counts[np.newaxis, ...]
+    pset_dict["latitude"] = latitude[np.newaxis, ...]
+    pset_dict["longitude"] = longitude[np.newaxis, ...]
     pset_dict["energy_bin_geometric_mean"] = energy_bin_geometric_means
-    pset_dict["exposure_factor"] = np.zeros(len(healpix), dtype=np.uint8)[
+    pset_dict["helio_exposure_factor"] = exposure_time
+    pset_dict["pixel_index"] = healpix
+    pset_dict["energy_bin_delta"] = np.diff(intervals, axis=1).squeeze()[
         np.newaxis, ...
     ]
+    pset_dict["sensitivity"] = sensitivity
+    pset_dict["efficiency"] = efficiencies
+    pset_dict["geometric_function"] = geometric_function
+    pset_dict["dead_time_ratio"] = deadtime_ratios
+    pset_dict["spin_phase_step"] = np.arange(len(deadtime_ratios))
 
     dataset = create_dataset(pset_dict, name, "l1c")
 

imap_processing/ultra/l1c/l1c_lookup_utils.py

@@ -0,0 +1,256 @@
+"""Contains tools for lookup tables for l1c."""
+
+import logging
+
+import numpy as np
+import pandas as pd
+from numpy._typing import NDArray
+
+from imap_processing.ultra.l1b.lookup_utils import (
+    get_scattering_coefficients,
+    get_scattering_thresholds,
+    load_scattering_lookup_tables,
+)
+from imap_processing.ultra.l1c.ultra_l1c_pset_bins import build_energy_bins
+
+logger = logging.getLogger(__name__)
+
+
+def mask_below_fwhm_scattering_threshold(
+    theta_coeffs: np.ndarray,
+    phi_coeffs: np.ndarray,
+    energy: np.ndarray,
+    scattering_thresholds: np.ndarray,
+) -> np.ndarray:
+    """
+    Determine indices of theta and phi values below the FWHM scattering threshold.
+
+    For each phi and theta, calculate the FWHM using the formula:
+    FWHM = A*E^g
+    If Phi FWHM or Theta FWHM > the scattering requirements from the table above,
+    mask the instrument frame pixel.
+
+    Parameters
+    ----------
+    theta_coeffs : NDArray
+        Coefficients for theta FWHM calculation (a and g) for each pixel.
+    phi_coeffs : NDArray
+        Coefficients for phi FWHM calculation (a and g) for each pixel.
+    energy : NDArray
+        Energy corresponding to each theta and phi val in keV.
+    scattering_thresholds : dict
+        Scattering thresholds corresponding to each energy.
+
+    Returns
+    -------
+    numpy.ndarray
+        Boolean array indicating indices below the scattering threshold.
+    """
+    # Calculate FWHM for all pixels and all energies
+    fwhm_theta = theta_coeffs[..., 0:1] * (
+        energy ** theta_coeffs[..., 1:2]
+    )  # (npix, energy.shape[1])
+    fwhm_phi = phi_coeffs[..., 0:1] * (
+        energy ** phi_coeffs[..., 1:2]
+    )  # (npix, energy.shape[1])
+
+    thresholds = scattering_thresholds[np.newaxis, :]  # (1, energy.shape[1])
+
+    # Combine conditions for both theta and phi.
+    # shape = (npix, energy.shape[1])
+    return np.logical_and(fwhm_theta <= thresholds, fwhm_phi <= thresholds)
+
+
+def calculate_pixels_within_scattering_threshold(
+    for_indices_by_spin_phase: np.ndarray,
+    theta_vals: np.ndarray,
+    phi_vals: np.ndarray,
+    ancillary_files: dict,
+    instrument_id: int,
+) -> list:
+    """
+    Calculate pixels within the FWHM scattering threshold for each spin phase step.
+
+    Parameters
+    ----------
+    for_indices_by_spin_phase : np.ndarray
+        A 2D boolean array where cols are spin phase steps are rows are HEALPix pixels.
+        True indicates pixels that are within the Field of Regard (FOR) at that
+        spin phase.
+    theta_vals : np.ndarray
+        A 2D array of theta values for each HEALPix pixel at each spin phase step.
+    phi_vals : np.ndarray
+         A 2D array of phi values for each HEALPix pixel at each spin phase step.
+    ancillary_files : dict
+        Dictionary containing ancillary files.
+    instrument_id : int,
+        Instrument ID, either 45 or 90.
+
+    Returns
+    -------
+    pixels_below_scattering : list
+        A Nested list of arrays indicating pixels within the scattering threshold.
+        The outer list indicates spin phase steps, the middle list indicates energy
+        bins, and the inner arrays contain indices indicating pixels that are below
+        the FWHM scattering threshold.
+    """
+    # Load scattering coefficient lookup table
+    scattering_luts = load_scattering_lookup_tables(ancillary_files, instrument_id)
+    pixels_below_scattering = []
+    # Get energy bin geometric means
+    energy_bin_geometric_means = build_energy_bins()[2]
+    # Load scattering thresholds for the energy bin geometric means
+    scattering_thresholds_for_energy_mean = get_scattering_thresholds_for_energy(
+        energy_bin_geometric_means, ancillary_files
+    )
+    steps = for_indices_by_spin_phase.shape[1]
+    energies = energy_bin_geometric_means[np.newaxis, :]
+    # The "for_indices_by_spin_phase" lookup table contains the boolean values of each
+    # pixel at each spin phase step, indicating whether the pixel is inside the FOR.
+    # It starts at Spin-phase = 0, and increments in fine steps (1 ms), spinning the
+    # spacecraft in the despun frame. At each iteration, query for the pixels in the
+    # FOR, and calculate whether the FWHM value is below the threshold at the energy.
+    for i in range(steps):
+        # Calculate spin phase for the current iteration
+        for_inds = for_indices_by_spin_phase[:, i]
+
+        # Skip if no pixels in FOR
+        if not np.any(for_inds):
+            logger.info(f"No pixels found in FOR at spin phase step {i}")
+            pixels_below_scattering.append(
+                [
+                    np.array([], dtype=int)
+                    for _ in range(len(energy_bin_geometric_means))
+                ]
+            )
+            continue
+        # Using the lookup table, get the indices of the pixels inside the FOR at
+        # the current spin phase step.
+        theta = theta_vals[for_inds, i]
+        phi = phi_vals[for_inds, i]
+        theta_coeffs, phi_coeffs = get_scattering_coefficients(
+            theta, phi, lookup_tables=scattering_luts
+        )
+        # Get a mask for pixels below the FWHM scattering threshold
+        scattering_mask = mask_below_fwhm_scattering_threshold(
+            theta_coeffs,
+            phi_coeffs,
+            energies,
+            scattering_thresholds=scattering_thresholds_for_energy_mean,
+        )
+        # Extract pixel indices for each energy
+        for_pixel_indices = np.where(for_inds)[0]
+        pixels_below_scattering_for_energy = []
+
+        for energy_idx in range(len(energy_bin_geometric_means)):
+            valid_pixels = scattering_mask[:, energy_idx]
+            pixels_below_scattering_for_energy.append(for_pixel_indices[valid_pixels])
+
+        pixels_below_scattering.append(pixels_below_scattering_for_energy)
+
+    return pixels_below_scattering
+
+
+def get_spacecraft_pointing_lookup_tables(
+    ancillary_files: dict, instrument_id: int
+) -> tuple[NDArray, NDArray, NDArray, NDArray, NDArray]:
+    """
+    Get indices of pixels in the nominal FOR as a function of spin phase.
+
+    This function also returns the theta / phi values in the instrument frame per spin
+    phase, right ascension / declination values in the SC frame, and boundary scale
+    factors for each pixel at each spin phase.
+
+    Parameters
+    ----------
+    ancillary_files : dict[Path]
+        Ancillary files.
+    instrument_id : int
+        Instrument ID, either 45 or 90.
+
+    Returns
+    -------
+    for_indices_by_spin_phase : NDArray
+        A 2D boolean array of shape (npix, n_spin_phase_steps).
+        True indicates pixels that are within the Field of Regard (FOR) at that
+        spin phase.
+    theta_vals : NDArray
+        A 2D array of theta values for each HEALPix pixel at each spin phase step.
+    phi_vals : NDArray
+         A 2D array of phi values for each HEALPix pixel at each spin phase step.
+    ra_and_dec : NDArray
+        A 2D array of right ascension and declination values for each HEALPix pixel.
+    boundary_scale_factors : NDArray
+        A 2D array of boundary scale factors for each HEALPix pixel at each spin phase
+        step.
+    """
+    theta_descriptor = f"l1c-{instrument_id}sensor-sc-pointing-theta-n32"
+    phi_descriptor = f"l1c-{instrument_id}sensor-sc-pointing-phi-n32"
+    index_descriptor = f"l1c-{instrument_id}sensor-sc-pointing-index-n32"
+    bsf_descriptor = f"l1c-{instrument_id}sensor-sc-pointing-bsf-n32"
+
+    theta_vals = pd.read_csv(
+        ancillary_files[theta_descriptor], header=None, skiprows=1
+    ).to_numpy(dtype=float)[:, 2:]
+    phi_vals = pd.read_csv(
+        ancillary_files[phi_descriptor], header=None, skiprows=1
+    ).to_numpy(dtype=float)[:, 2:]
+    index_grid = pd.read_csv(
+        ancillary_files[index_descriptor], header=None, skiprows=1
+    ).to_numpy(dtype=float)
+    boundary_scale_factors = pd.read_csv(
+        ancillary_files[bsf_descriptor], header=None, skiprows=1
+    ).to_numpy(dtype=float)[:, 2:]
+
+    ra_and_dec = index_grid[:, :2]  # Shape (npix, 2)
+    # This array indicates whether each pixel is in the nominal FOR at each spin phase
+    # step (15000 steps for a full rotation with 1 ms resolution).
+    for_indices_by_spin_phase = np.nan_to_num(index_grid[:, 2:], nan=0).astype(
+        bool
+    )  # Shape (npix, 15000)
+    return (
+        for_indices_by_spin_phase,
+        theta_vals,
+        phi_vals,
+        ra_and_dec,
+        boundary_scale_factors,
+    )
+
+
+def get_scattering_thresholds_for_energy(
+    energy: np.ndarray, ancillary_files: dict
+) -> np.ndarray:
+    """
+    Find the scattering thresholds for each energy bin.
+
+    Parameters
+    ----------
+    energy : np.ndarray
+        Array of energy values in keV.
+    ancillary_files : dict
+        Dictionary containing ancillary files.
+
+    Returns
+    -------
+    np.ndarray
+        Array of scattering thresholds for each energy bin.
+    """
+    scattering_thresholds = get_scattering_thresholds(ancillary_files)
+    # Get thresholds for all energies
+    thresholds = []
+    for e in energy:
+        try:
+            threshold = next(
+                threshold
+                for energy_range, threshold in scattering_thresholds.items()
+                if energy_range[0] <= e < energy_range[1]
+            )
+        except StopIteration:
+            logger.warning(
+                f"Energy {e} keV is out of bounds for scattering thresholds. Using"
+                f" zero for as threshold."
+            )
+
+            threshold = 0
+        thresholds.append(threshold)
+    return np.array(thresholds)

imap_processing/ultra/l1c/spacecraft_pset.py

@@ -1,25 +1,39 @@
 """Calculate Pointing Set Grids."""
 
+import logging
+
 import numpy as np
 import pandas as pd
 import xarray as xr
 
+from imap_processing.cdf.utils import parse_filename_like
+from imap_processing.ultra.l1b.ultra_l1b_culling import get_de_rejection_mask
+from imap_processing.ultra.l1c.l1c_lookup_utils import (
+    calculate_pixels_within_scattering_threshold,
+    get_spacecraft_pointing_lookup_tables,
+)
 from imap_processing.ultra.l1c.ultra_l1c_pset_bins import (
     build_energy_bins,
+    get_efficiencies_and_geometric_function,
     get_spacecraft_background_rates,
     get_spacecraft_exposure_times,
     get_spacecraft_histogram,
-    interpolate_sensitivity,
 )
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
+logger = logging.getLogger(__name__)
+
 
 def calculate_spacecraft_pset(
     de_dataset: xr.Dataset,
     extendedspin_dataset: xr.Dataset,
     cullingmask_dataset: xr.Dataset,
+    rates_dataset: xr.Dataset,
+    params_dataset: xr.Dataset,
     name: str,
     ancillary_files: dict,
+    instrument_id: int,
+    species_id: int = 1,
 ) -> xr.Dataset:
     """
     Create dictionary with defined datatype for Pointing Set Grid Data.
@@ -32,10 +46,18 @@ def calculate_spacecraft_pset(
         Dataset containing extendedspin data.
     cullingmask_dataset : xarray.Dataset
         Dataset containing cullingmask data.
+    rates_dataset : xarray.Dataset
+        Dataset containing image rates data.
+    params_dataset : xarray.Dataset
+        Dataset containing image parameters data.
     name : str
         Name of the dataset.
     ancillary_files : dict
         Ancillary files.
+    instrument_id : int
+        Instrument ID, either 45 or 90.
+    species_id : int
+        Species ID, default of 1 refers to Hydrogen.
 
     Returns
     -------
@@ -43,35 +65,83 @@ def calculate_spacecraft_pset(
         Dataset containing the data.
     """
     pset_dict: dict[str, np.ndarray] = {}
+    sensor = parse_filename_like(name)["sensor"][0:2]
+    # Select only the species we are interested in.
+    indices = np.where(de_dataset["species"].values == species_id)[0]
+    species_dataset = de_dataset.isel(epoch=indices)
+
+    # Before we use the de_dataset to calculate the pointing set grid we need to filter.
+    rejected = get_de_rejection_mask(
+        species_dataset["quality_scattering"].values,
+        species_dataset["quality_outliers"].values,
+    )
+    species_dataset = species_dataset.isel(epoch=~rejected)
 
-    v_mag_dps_spacecraft = np.linalg.norm(de_dataset["velocity_dps_sc"].values, axis=1)
+    v_mag_dps_spacecraft = np.linalg.norm(
+        species_dataset["velocity_dps_sc"].values, axis=1
+    )
     vhat_dps_spacecraft = (
-        de_dataset["velocity_dps_sc"].values / v_mag_dps_spacecraft[:, np.newaxis]
+        species_dataset["velocity_dps_sc"].values / v_mag_dps_spacecraft[:, np.newaxis]
     )
 
     intervals, _, energy_bin_geometric_means = build_energy_bins()
     counts, latitude, longitude, n_pix = get_spacecraft_histogram(
         vhat_dps_spacecraft,
-        de_dataset["energy_spacecraft"].values,
+        species_dataset["energy_spacecraft"].values,
         intervals,
         nside=128,
     )
     healpix = np.arange(n_pix)
 
-    # calculate background rates
-    background_rates = get_spacecraft_background_rates()
+    # Get lookup table for FOR indices by spin phase step
+    (
+        for_indices_by_spin_phase,
+        theta_vals,
+        phi_vals,
+        ra_and_dec,
+        boundary_scale_factors,
+    ) = get_spacecraft_pointing_lookup_tables(ancillary_files, instrument_id)
+    # Check that the number of rows in the lookup table matches the number of pixels
+    if for_indices_by_spin_phase.shape[0] != n_pix:
+        logger.warning(
+            "The lookup table is expected to have the same number of rows as "
+            "the number of HEALPix pixels."
+        )
 
-    efficiencies = ancillary_files["l1c-90sensor-efficiencies"]
-    geometric_function = ancillary_files["l1c-90sensor-gf"]
-
-    df_efficiencies = pd.read_csv(efficiencies)
-    df_geometric_function = pd.read_csv(geometric_function)
-    sensitivity = interpolate_sensitivity(df_efficiencies, df_geometric_function)
+    pixels_below_scattering = calculate_pixels_within_scattering_threshold(
+        for_indices_by_spin_phase, theta_vals, phi_vals, ancillary_files, instrument_id
+    )
+    # calculate efficiency and geometric function as a function of energy
+    efficiencies, geometric_function = get_efficiencies_and_geometric_function(
+        pixels_below_scattering,
+        boundary_scale_factors,
+        theta_vals,
+        phi_vals,
+        n_pix,
+        ancillary_files,
+    )
+    sensitivity = efficiencies * geometric_function
 
     # Calculate exposure
     constant_exposure = ancillary_files["l1c-90sensor-dps-exposure"]
     df_exposure = pd.read_csv(constant_exposure)
-    exposure_pointing = get_spacecraft_exposure_times(df_exposure)
+
+    exposure_pointing, deadtime_ratios = get_spacecraft_exposure_times(
+        df_exposure,
+        rates_dataset,
+        params_dataset,
+        pixels_below_scattering,
+        boundary_scale_factors,
+    )
+
+    # Calculate background rates
+    background_rates = get_spacecraft_background_rates(
+        rates_dataset,
+        sensor,
+        ancillary_files,
+        intervals,
+        cullingmask_dataset["spin_number"].values,
+    )
 
     # For ISTP, epoch should be the center of the time bin.
     pset_dict["epoch"] = de_dataset.epoch.data[:1].astype(np.int64)
@@ -80,12 +150,17 @@ def calculate_spacecraft_pset(
     pset_dict["longitude"] = longitude[np.newaxis, ...]
     pset_dict["energy_bin_geometric_mean"] = energy_bin_geometric_means
     pset_dict["background_rates"] = background_rates[np.newaxis, ...]
-    pset_dict["exposure_factor"] = exposure_pointing.to_numpy()[np.newaxis, ...]
+    pset_dict["exposure_factor"] = exposure_pointing
     pset_dict["pixel_index"] = healpix
     pset_dict["energy_bin_delta"] = np.diff(intervals, axis=1).squeeze()[
         np.newaxis, ...
     ]
-    pset_dict["sensitivity"] = sensitivity[np.newaxis, ...]
+
+    pset_dict["sensitivity"] = sensitivity
+    pset_dict["efficiency"] = efficiencies
+    pset_dict["geometric_function"] = geometric_function
+    pset_dict["dead_time_ratio"] = deadtime_ratios
+    pset_dict["spin_phase_step"] = np.arange(len(deadtime_ratios))
 
     dataset = create_dataset(pset_dict, name, "l1c")
 

imap_processing/ultra/l1c/ultra_l1c.py

@@ -50,8 +50,11 @@ def ultra_l1c(
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-de"],
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-extendedspin"],
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-cullingmask"],
+                data_dict[f"imap_ultra_l1a_{instrument_id}sensor-rates"],
+                data_dict[f"imap_ultra_l1a_{instrument_id}sensor-params"],
                 f"imap_ultra_l1c_{instrument_id}sensor-heliopset",
                 ancillary_files,
+                instrument_id,
             )
             output_datasets = [helio_pset]
         elif (
@@ -63,8 +66,11 @@ def ultra_l1c(
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-de"],
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-extendedspin"],
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-cullingmask"],
+                data_dict[f"imap_ultra_l1a_{instrument_id}sensor-rates"],
+                data_dict[f"imap_ultra_l1a_{instrument_id}sensor-params"],
                 f"imap_ultra_l1c_{instrument_id}sensor-spacecraftpset",
                 ancillary_files,
+                instrument_id,
             )
             output_datasets = [spacecraft_pset]
     if not output_datasets: