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

imap_processing/ultra/l1b/de.py

@@ -13,22 +13,27 @@ from imap_processing.ultra.l1b.ultra_l1b_extended import (
     determine_species,
     get_coincidence_positions,
     get_ctof,
-    get_de_az_el,
     get_de_energy_kev,
     get_de_velocity,
     get_energy_pulse_height,
     get_energy_ssd,
+    get_eventtimes,
     get_front_x_position,
     get_front_y_position,
+    get_fwhm,
     get_path_length,
     get_ph_tof_and_back_positions,
+    get_phi_theta,
     get_ssd_back_position_and_tof_offset,
     get_ssd_tof,
 )
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
+FILLVAL_UINT8 = 255
+FILLVAL_FLOAT32 = -1.0e31
 
-def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dataset:
+
+def calculate_de(de_dataset: xr.Dataset, name: str) -> xr.Dataset:
     """
     Create dataset with defined datatypes for Direct Event Data.
 
@@ -38,8 +43,6 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
         L1a dataset containing direct event data.
     name : str
         Name of the l1a dataset.
-    data_version : str
-        Version of the data.
 
     Returns
     -------
@@ -49,55 +52,106 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
     de_dict = {}
     sensor = parse_filename_like(name)["sensor"][0:2]
 
-    # Drop events with invalid start type.
-    de_dataset = de_dataset.where(
-        de_dataset["START_TYPE"] != np.iinfo(np.int64).min, drop=True
+    # Define epoch and spin.
+    de_dict["epoch"] = de_dataset["epoch"].data
+    de_dict["spin"] = de_dataset["spin"].data
+
+    # Add already populated fields.
+    keys = [
+        "coincidence_type",
+        "start_type",
+        "event_type",
+        "de_event_met",
+        "phase_angle",
+        "spin",
+    ]
+    dataset_keys = [
+        "coin_type",
+        "start_type",
+        "stop_type",
+        "shcoarse",
+        "phase_angle",
+        "spin",
+    ]
+
+    de_dict.update(
+        {key: de_dataset[dataset_key] for key, dataset_key in zip(keys, dataset_keys)}
     )
 
-    # Instantiate arrays
-    yf = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    xb = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    yb = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    xc = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    d = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float64)
-    r = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    tof = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    etof = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    ctof = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    magnitude_v = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    energy = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-    species_bin = np.full(len(de_dataset["epoch"]), "UNKNOWN", dtype="U10")
-    t2 = np.full(len(de_dataset["epoch"]), np.nan, dtype=np.float32)
-
-    # Define epoch.
-    de_dict["epoch"] = de_dataset["epoch"].data
+    valid_mask = de_dataset["start_type"].data != FILLVAL_UINT8
+    ph_mask = np.isin(
+        de_dataset["stop_type"].data, [StopType.Top.value, StopType.Bottom.value]
+    )
+    ssd_mask = np.isin(de_dataset["stop_type"].data, [StopType.SSD.value])
+
+    valid_indices = np.nonzero(valid_mask)[0]
+    ph_indices = np.nonzero(valid_mask & ph_mask)[0]
+    ssd_indices = np.nonzero(valid_mask & ssd_mask)[0]
 
-    xf = get_front_x_position(
-        de_dataset["START_TYPE"].data,
-        de_dataset["START_POS_TDC"].data,
+    # Instantiate arrays
+    xf = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    yf = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    xb = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    yb = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    xc = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    d = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float64)
+    r = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    phi = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    theta = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    tof = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    etof = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    ctof = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    magnitude_v = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    energy = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    species_bin = np.full(len(de_dataset["epoch"]), FILLVAL_UINT8, dtype=np.uint8)
+    t2 = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float32)
+    event_times = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float64)
+    spin_starts = np.full(len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float64)
+    spin_period_sec = np.full(
+        len(de_dataset["epoch"]), FILLVAL_FLOAT32, dtype=np.float64
+    )
+    start_type = np.full(len(de_dataset["epoch"]), FILLVAL_UINT8, dtype=np.uint8)
+
+    xf[valid_indices] = get_front_x_position(
+        de_dataset["start_type"].data[valid_indices],
+        de_dataset["start_pos_tdc"].data[valid_indices],
+        f"ultra{sensor}",
+    )
+    start_type[valid_indices] = de_dataset["start_type"].data[valid_indices]
+
+    (
+        event_times[valid_indices],
+        spin_starts[valid_indices],
+        spin_period_sec[valid_indices],
+    ) = get_eventtimes(
+        de_dataset["spin"].data[valid_indices],
+        de_dataset["phase_angle"].data[valid_indices],
     )
 
     # Pulse height
-    ph_indices = np.nonzero(
-        np.isin(de_dataset["STOP_TYPE"], [StopType.Top.value, StopType.Bottom.value])
-    )[0]
     tof[ph_indices], t2[ph_indices], xb[ph_indices], yb[ph_indices] = (
         get_ph_tof_and_back_positions(de_dataset, xf, f"ultra{sensor}")
     )
     d[ph_indices], yf[ph_indices] = get_front_y_position(
-        de_dataset["START_TYPE"].data[ph_indices], yb[ph_indices]
+        de_dataset["start_type"].data[ph_indices], yb[ph_indices]
     )
     energy[ph_indices] = get_energy_pulse_height(
-        de_dataset["STOP_TYPE"].data[ph_indices],
-        de_dataset["ENERGY_PH"].data[ph_indices],
+        de_dataset["stop_type"].data[ph_indices],
+        de_dataset["energy_ph"].data[ph_indices],
         xb[ph_indices],
         yb[ph_indices],
+        f"ultra{sensor}",
     )
     r[ph_indices] = get_path_length(
         (xf[ph_indices], yf[ph_indices]),
         (xb[ph_indices], yb[ph_indices]),
         d[ph_indices],
     )
+    phi[ph_indices], theta[ph_indices] = get_phi_theta(
+        (xf[ph_indices], yf[ph_indices]),
+        (xb[ph_indices], yb[ph_indices]),
+        d[ph_indices],
+    )
     species_bin[ph_indices] = determine_species(tof[ph_indices], r[ph_indices], "PH")
     etof[ph_indices], xc[ph_indices] = get_coincidence_positions(
         de_dataset.isel(epoch=ph_indices), t2[ph_indices], f"ultra{sensor}"
@@ -107,14 +161,15 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
     )
 
     # SSD
-    ssd_indices = np.nonzero(np.isin(de_dataset["STOP_TYPE"], StopType.SSD.value))[0]
-    tof[ssd_indices] = get_ssd_tof(de_dataset, xf)
-    yb[ssd_indices], _, ssd_number = get_ssd_back_position_and_tof_offset(de_dataset)
+    tof[ssd_indices] = get_ssd_tof(de_dataset, xf, f"ultra{sensor}")
+    yb[ssd_indices], _, ssd_number = get_ssd_back_position_and_tof_offset(
+        de_dataset, f"ultra{sensor}"
+    )
     xc[ssd_indices] = np.zeros(len(ssd_indices))
     xb[ssd_indices] = np.zeros(len(ssd_indices))
     etof[ssd_indices] = np.zeros(len(ssd_indices))
     d[ssd_indices], yf[ssd_indices] = get_front_y_position(
-        de_dataset["START_TYPE"].data[ssd_indices], yb[ssd_indices]
+        de_dataset["start_type"].data[ssd_indices], yb[ssd_indices]
     )
     energy[ssd_indices] = get_energy_ssd(de_dataset, ssd_number)
     r[ssd_indices] = get_path_length(
@@ -122,6 +177,11 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
         (xb[ssd_indices], yb[ssd_indices]),
         d[ssd_indices],
     )
+    phi[ssd_indices], theta[ssd_indices] = get_phi_theta(
+        (xf[ssd_indices], yf[ssd_indices]),
+        (xb[ssd_indices], yb[ssd_indices]),
+        d[ssd_indices],
+    )
     species_bin[ssd_indices] = determine_species(
         tof[ssd_indices], r[ssd_indices], "SSD"
     )
@@ -131,6 +191,9 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
 
     # Combine ph_yb and ssd_yb along with their indices
     de_dict["x_front"] = xf.astype(np.float32)
+    de_dict["event_times"] = event_times
+    de_dict["spin_starts"] = spin_starts
+    de_dict["spin_period"] = spin_period_sec
     de_dict["y_front"] = yf
     de_dict["x_back"] = xb
     de_dict["y_back"] = yb
@@ -141,37 +204,27 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
     de_dict["velocity_magnitude"] = magnitude_v
     de_dict["front_back_distance"] = d
     de_dict["path_length"] = r
+    de_dict["phi"] = phi
+    de_dict["theta"] = theta
 
-    keys = [
-        "coincidence_type",
-        "start_type",
-        "event_type",
-        "de_event_met",
-        "event_times",
-    ]
-    dataset_keys = ["COIN_TYPE", "START_TYPE", "STOP_TYPE", "SHCOARSE", "EVENTTIMES"]
-
-    de_dict.update(
-        {key: de_dataset[dataset_key] for key, dataset_key in zip(keys, dataset_keys)}
-    )
-
-    v = get_de_velocity(
+    v, vhat, r = get_de_velocity(
         (de_dict["x_front"], de_dict["y_front"]),
         (de_dict["x_back"], de_dict["y_back"]),
         de_dict["front_back_distance"],
         de_dict["tof_start_stop"],
     )
     de_dict["direct_event_velocity"] = v.astype(np.float32)
+    de_dict["direct_event_unit_velocity"] = vhat.astype(np.float32)
+    de_dict["direct_event_unit_position"] = r.astype(np.float32)
 
     de_dict["tof_energy"] = get_de_energy_kev(v, species_bin)
-    de_dict["azimuth"], de_dict["elevation"] = get_de_az_el(v)
     de_dict["energy"] = energy
     de_dict["species"] = species_bin
 
     # Annotated Events.
     ultra_frame = getattr(SpiceFrame, f"IMAP_ULTRA_{sensor}")
     sc_velocity, sc_dps_velocity, helio_velocity = get_annotated_particle_velocity(
-        de_dataset.data_vars["EVENTTIMES"].values,
+        event_times,
         de_dict["direct_event_velocity"],
         ultra_frame,
         SpiceFrame.IMAP_DPS,
@@ -182,11 +235,17 @@ def calculate_de(de_dataset: xr.Dataset, name: str, data_version: str) -> xr.Dat
     de_dict["velocity_dps_sc"] = sc_dps_velocity
     de_dict["velocity_dps_helio"] = helio_velocity
 
-    # TODO: TBD.
-    de_dict["event_efficiency"] = np.full(
-        len(de_dataset["epoch"]), np.nan, dtype=np.float32
+    de_dict["energy_spacecraft"] = get_de_energy_kev(sc_dps_velocity, species_bin)
+    de_dict["energy_heliosphere"] = get_de_energy_kev(helio_velocity, species_bin)
+
+    de_dict["phi_fwhm"], de_dict["theta_fwhm"] = get_fwhm(
+        start_type,
+        f"ultra{sensor}",
+        de_dict["tof_energy"],
+        de_dict["phi"],
+        de_dict["theta"],
     )
 
-    dataset = create_dataset(de_dict, name, "l1b", data_version)
+    dataset = create_dataset(de_dict, name, "l1b")
 
     return dataset

imap_processing/ultra/l1b/extendedspin.py

@@ -1,58 +1,60 @@
 """Calculate Extended Spin."""
 
+import numpy as np
 import xarray as xr
 
 from imap_processing.ultra.l1b.ultra_l1b_culling import (
     flag_attitude,
     flag_spin,
     get_energy_histogram,
-    get_spin,
 )
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 
 def calculate_extendedspin(
-    hk_dataset: xr.Dataset,
-    rates_dataset: xr.Dataset,
-    de_dataset: xr.Dataset,
+    dict_datasets: dict[str, xr.Dataset],
     name: str,
-    data_version: str,
+    instrument_id: int,
 ) -> xr.Dataset:
     """
     Create dataset with defined datatypes for Extended Spin Data.
 
     Parameters
     ----------
-    hk_dataset : xarray.Dataset
-        Dataset containing l1a hk data.
-    rates_dataset : xarray.Dataset
-        Dataset containing l1a rates data.
-    de_dataset : xarray.Dataset
-        Dataset containing l1b de data.
+    dict_datasets : dict
+        Dictionary containing all the datasets.
     name : str
         Name of the dataset.
-    data_version : str
-        Version of the data.
+    instrument_id : int
+        Instrument ID.
 
     Returns
     -------
     extendedspin_dataset : xarray.Dataset
         Dataset containing the data.
     """
+    aux_dataset = dict_datasets[f"imap_ultra_l1a_{instrument_id}sensor-aux"]
+    de_dataset = dict_datasets[f"imap_ultra_l1b_{instrument_id}sensor-de"]
+
     extendedspin_dict = {}
     rates_qf, spin, energy_midpoints, n_sigma_per_energy = flag_spin(
-        de_dataset["event_times"].values,
+        de_dataset["spin"].values,
         de_dataset["energy"].values,
     )
-    spin_number = get_spin(de_dataset["event_times"].values)
     count_rates, _, counts, _ = get_energy_histogram(
-        spin_number, de_dataset["energy"].values
+        de_dataset["spin"].values, de_dataset["energy"].values
     )
     attitude_qf, spin_rates, spin_period, spin_starttime = flag_attitude(
-        de_dataset["event_times"].values
+        de_dataset["spin"].values, aux_dataset
     )
+    # Get the first epoch for each spin.
+    mask = xr.DataArray(np.isin(de_dataset["spin"], spin), dims="epoch")
+    filtered_dataset = de_dataset.where(mask, drop=True)
+    _, first_indices = np.unique(filtered_dataset["spin"].values, return_index=True)
+    first_epochs = filtered_dataset["epoch"].values[first_indices]
 
     # These will be the coordinates.
+    extendedspin_dict["epoch"] = first_epochs
     extendedspin_dict["spin_number"] = spin
     extendedspin_dict["energy_bin_geometric_mean"] = energy_midpoints
 
@@ -64,6 +66,6 @@ def calculate_extendedspin(
     extendedspin_dict["quality_attitude"] = attitude_qf
     extendedspin_dict["quality_ena_rates"] = rates_qf
 
-    extendedspin_dataset = create_dataset(extendedspin_dict, name, "l1b", data_version)
+    extendedspin_dataset = create_dataset(extendedspin_dict, name, "l1b")
 
     return extendedspin_dataset

imap_processing/ultra/l1b/lookup_utils.py

@@ -23,7 +23,21 @@ _BACK_POS_DF_ULTRA90 = pd.read_csv(
     BASE_PATH / "ultra90_back-pos-luts.csv", index_col="Index_offset"
 )
 _ENERGY_NORM_DF = pd.read_csv(BASE_PATH / "EgyNorm.mem.csv")
-_IMAGE_PARAMS_DF = pd.read_csv(BASE_PATH / "FM45_Startup1_ULTRA_IMGPARAMS_20240719.csv")
+_IMAGE_PARAMS_DF = {
+    "ultra45": pd.read_csv(BASE_PATH / "FM45_Startup1_ULTRA_IMGPARAMS_20240719.csv"),
+    "ultra90": pd.read_csv(BASE_PATH / "FM90_Startup1_ULTRA_IMGPARAMS_20240719.csv"),
+}
+
+_FWHM_TABLES = {
+    ("left", "ultra45"): pd.read_csv(BASE_PATH / "Angular_Profiles_FM45_LeftSlit.csv"),
+    ("right", "ultra45"): pd.read_csv(
+        BASE_PATH / "Angular_Profiles_FM45_RightSlit.csv"
+    ),
+    ("left", "ultra90"): pd.read_csv(BASE_PATH / "Angular_Profiles_FM90_LeftSlit.csv"),
+    ("right", "ultra90"): pd.read_csv(
+        BASE_PATH / "Angular_Profiles_FM90_RightSlit.csv"
+    ),
+}
 
 
 def get_y_adjust(dy_lut: np.ndarray) -> npt.NDArray:
@@ -32,7 +46,7 @@ def get_y_adjust(dy_lut: np.ndarray) -> npt.NDArray:
 
     Instead of using trigonometry, this function utilizes a 256-element lookup table
     to find the Y adjustment. For more details, refer to pages 37-38 of the
-    IMAP-Ultra Flight Software Specification document (7523-9009_Rev_-.pdf).
+    IMAP-Ultra Flight Software Specification document.
 
     Parameters
     ----------
@@ -56,7 +70,7 @@ def get_norm(dn: xr.DataArray, key: str, file_label: str) -> npt.NDArray:
     using lookup tables.
 
     Further description is available on pages 31-32 of the IMAP-Ultra Flight Software
-    Specification document (7523-9009_Rev_-.pdf). This will work for both Tp{key}Norm,
+    Specification document. This will work for both Tp{key}Norm,
     Bt{key}Norm. This is for getStopNorm and getCoinNorm.
 
     Parameters
@@ -92,7 +106,7 @@ def get_back_position(back_index: np.ndarray, key: str, file_label: str) -> npt.
     instead of linear equations is necessary. The computation will use different
     tables to accommodate variations between the top and bottom anodes.
     Further description is available on page 32 of the
-    IMAP-Ultra Flight Software Specification document (7523-9009_Rev_-.pdf).
+    IMAP-Ultra Flight Software Specification document.
 
     Parameters
     ----------
@@ -122,8 +136,8 @@ def get_energy_norm(ssd: np.ndarray, composite_energy: np.ndarray) -> npt.NDArra
     Normalize composite energy per SSD using a lookup table.
 
     Further description is available on page 41 of the
-    IMAP-Ultra Flight Software Specification document
-    (7523-9009_Rev_-.pdf). Note : There are 8 SSDs containing
+    IMAP-Ultra Flight Software Specification document.
+    Note : There are 8 SSDs containing
     4096 composite energies each.
 
     Parameters
@@ -143,23 +157,72 @@ def get_energy_norm(ssd: np.ndarray, composite_energy: np.ndarray) -> npt.NDArra
     return _ENERGY_NORM_DF["NormEnergy"].iloc[row_number]
 
 
-def get_image_params(image: str) -> np.float64:
+def get_image_params(image: str, sensor: str) -> np.float64:
     """
     Lookup table for image parameters.
 
     Further description is available starting on
     page 30 of the IMAP-Ultra Flight Software
-    Specification document (7523-9009_Rev_-.pdf).
+    Specification document.
 
     Parameters
     ----------
     image : str
         The column name to lookup in the CSV file, e.g., 'XFTLTOFF' or 'XFTRTOFF'.
+    sensor : str
+        Sensor name: "ultra45" or "ultra90".
 
     Returns
     -------
     value : np.float64
         Image parameter value from the CSV file.
     """
-    value: np.float64 = _IMAGE_PARAMS_DF[image].values[0]
+    lookup_table = _IMAGE_PARAMS_DF[sensor]
+    value: np.float64 = lookup_table[image].values[0]
     return value
+
+
+def get_angular_profiles(start_type: str, sensor: str) -> pd.DataFrame:
+    """
+    Lookup table for FWHM for theta and phi.
+
+    Further description is available starting on
+    page 18 of the Algorithm Document.
+
+    Parameters
+    ----------
+    start_type : str
+       Start Type: Left, Right.
+    sensor : str
+        Sensor name: "ultra45" or "ultra90".
+
+    Returns
+    -------
+    lookup_table : DataFrame
+        Angular profile lookup table for a given start_type and sensor.
+    """
+    lookup_table = _FWHM_TABLES[(start_type.lower(), sensor)]
+
+    return lookup_table
+
+
+def get_energy_efficiencies() -> pd.DataFrame:
+    """
+    Lookup table for efficiencies for theta and phi.
+
+    Further description is available starting on
+    page 18 of the Algorithm Document.
+
+    Returns
+    -------
+    lookup_table : DataFrame
+        Efficiencies lookup table for a given sensor.
+    """
+    # TODO: Move this out of tests directory once we have the aux api
+    # TODO: ultra90 efficiencies
+    path = imap_module_directory / "tests" / "ultra" / "data" / "l1"
+    lookup_table = pd.read_csv(
+        path / "Ultra_efficiencies_45_combined_logistic_interpolation.csv"
+    )
+
+    return lookup_table

imap_processing/ultra/l1b/ultra_l1b.py

@@ -8,7 +8,7 @@ from imap_processing.ultra.l1b.de import calculate_de
 from imap_processing.ultra.l1b.extendedspin import calculate_extendedspin
 
 
-def ultra_l1b(data_dict: dict, data_version: str) -> list[xr.Dataset]:
+def ultra_l1b(data_dict: dict) -> list[xr.Dataset]:
     """
     Will process ULTRA L1A data into L1B CDF files at output_filepath.
 
@@ -16,47 +16,67 @@ def ultra_l1b(data_dict: dict, data_version: str) -> list[xr.Dataset]:
     ----------
     data_dict : dict
         The data itself and its dependent data.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
     output_datasets : list[xarray.Dataset]
         List of xarray.Dataset.
+
+    Notes
+    -----
+    General flow:
+    1. l1a data products are created (upstream to this code)
+    2. l1b de is created here and dropped in s3 kicking off processing again
+    3. l1b extended, culling, badtimes created here
     """
     output_datasets = []
     instrument_id = 45 if any("45" in key for key in data_dict.keys()) else 90
 
-    if (
-        f"imap_ultra_l1a_{instrument_id}sensor-hk" in data_dict
-        and f"imap_ultra_l1a_{instrument_id}sensor-de" in data_dict
-        and f"imap_ultra_l1a_{instrument_id}sensor-rates" in data_dict
-    ):
+    # L1b de data will be created if L1a de data is available
+    if f"imap_ultra_l1a_{instrument_id}sensor-de" in data_dict:
         de_dataset = calculate_de(
             data_dict[f"imap_ultra_l1a_{instrument_id}sensor-de"],
             f"imap_ultra_l1b_{instrument_id}sensor-de",
-            data_version,
         )
+        output_datasets.append(de_dataset)
+    # L1b extended data will be created if L1a hk, rates,
+    # aux, params, and l1b de data are available
+    elif (
+        f"imap_ultra_l1a_{instrument_id}sensor-hk" in data_dict
+        and f"imap_ultra_l1b_{instrument_id}sensor-de" in data_dict
+        and f"imap_ultra_l1a_{instrument_id}sensor-rates" in data_dict
+        and f"imap_ultra_l1a_{instrument_id}sensor-aux" in data_dict
+        and f"imap_ultra_l1a_{instrument_id}sensor-params" in data_dict
+    ):
         extendedspin_dataset = calculate_extendedspin(
-            data_dict[f"imap_ultra_l1a_{instrument_id}sensor-hk"],
-            data_dict[f"imap_ultra_l1a_{instrument_id}sensor-rates"],
-            de_dataset,
+            {
+                f"imap_ultra_l1a_{instrument_id}sensor-aux": data_dict[
+                    f"imap_ultra_l1a_{instrument_id}sensor-aux"
+                ],
+                f"imap_ultra_l1a_{instrument_id}sensor-hk": data_dict[
+                    f"imap_ultra_l1a_{instrument_id}sensor-hk"
+                ],
+                f"imap_ultra_l1a_{instrument_id}sensor-rates": data_dict[
+                    f"imap_ultra_l1a_{instrument_id}sensor-rates"
+                ],
+                f"imap_ultra_l1b_{instrument_id}sensor-de": data_dict[
+                    f"imap_ultra_l1b_{instrument_id}sensor-de"
+                ],
+            },
             f"imap_ultra_l1b_{instrument_id}sensor-extendedspin",
-            data_version,
+            instrument_id,
         )
         cullingmask_dataset = calculate_cullingmask(
             extendedspin_dataset,
             f"imap_ultra_l1b_{instrument_id}sensor-cullingmask",
-            data_version,
         )
         badtimes_dataset = calculate_badtimes(
             extendedspin_dataset,
             cullingmask_dataset["spin_number"].values,
             f"imap_ultra_l1b_{instrument_id}sensor-badtimes",
-            data_version,
         )
         output_datasets.extend(
-            [de_dataset, extendedspin_dataset, cullingmask_dataset, badtimes_dataset]
+            [extendedspin_dataset, cullingmask_dataset, badtimes_dataset]
         )
     else:
         raise ValueError("Data dictionary does not contain the expected keys.")