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

imap_processing/ialirt/generate_coverage.py

@@ -0,0 +1,201 @@
+"""Coverage time for each station."""
+
+import logging
+
+import numpy as np
+
+from imap_processing.ialirt.constants import STATIONS
+from imap_processing.ialirt.process_ephemeris import calculate_azimuth_and_elevation
+from imap_processing.spice.time import et_to_utc, str_to_et
+
+# Logger setup
+logger = logging.getLogger(__name__)
+
+ALL_STATIONS = [
+    *STATIONS.keys(),
+    "DSS-24",
+    "DSS-25",
+    "DSS-26",
+    "DSS-34",
+    "DSS-35",
+    "DSS-36",
+    "DSS-53",
+    "DSS-54",
+    "DSS-55",
+    "DSS-56",
+    "DSS-74",
+    "DSS-75",
+]
+
+
+def generate_coverage(
+    start_time: str,
+    outages: dict | None = None,
+    dsn: dict | None = None,
+) -> tuple[dict, dict]:
+    """
+    Build the output dictionary containing coverage and outage time for each station.
+
+    Parameters
+    ----------
+    start_time : str
+        Start time in UTC.
+    outages : dict, optional
+        Dictionary of outages for each station.
+    dsn : dict, optional
+        Dictionary of Deep Space Network (DSN) stations.
+
+    Returns
+    -------
+    coverage_dict : dict
+        Visibility times per station.
+    outage_dict : dict
+        Outage times per station.
+    """
+    duration_seconds = 24 * 60 * 60  # 86400 seconds in 24 hours
+    time_step = 3600  # 1 hr in seconds
+
+    stations = {
+        "Kiel": STATIONS["Kiel"],
+    }
+    coverage_dict = {}
+    outage_dict = {}
+
+    start_et_input = str_to_et(start_time)
+    stop_et_input = start_et_input + duration_seconds
+
+    time_range = np.arange(start_et_input, stop_et_input, time_step)
+    total_visible_mask = np.zeros(time_range.shape, dtype=bool)
+
+    # Precompute DSN outage mask for non-DSN stations
+    dsn_outage_mask = np.zeros(time_range.shape, dtype=bool)
+    if dsn:
+        for dsn_contacts in dsn.values():
+            for start, end in dsn_contacts:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                dsn_outage_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+    for station_name, (lon, lat, alt, min_elevation) in stations.items():
+        azimuth, elevation = calculate_azimuth_and_elevation(lon, lat, alt, time_range)
+        visible = elevation > min_elevation
+
+        outage_mask = np.zeros(time_range.shape, dtype=bool)
+        if outages and station_name in outages:
+            for start, end in outages[station_name]:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                outage_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+        visible[outage_mask] = False
+        # DSN contacts block other stations
+        visible[dsn_outage_mask] = False
+        total_visible_mask |= visible
+
+        coverage_dict[station_name] = et_to_utc(time_range[visible], format_str="ISOC")
+        outage_dict[station_name] = et_to_utc(
+            time_range[outage_mask], format_str="ISOC"
+        )
+
+    # --- DSN Stations ---
+    if dsn:
+        for dsn_station, contacts in dsn.items():
+            dsn_visible_mask = np.zeros(time_range.shape, dtype=bool)
+            for start, end in contacts:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                dsn_visible_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+            # Apply DSN outages if present
+            outage_mask = np.zeros(time_range.shape, dtype=bool)
+            if outages and dsn_station in outages:
+                for start, end in outages[dsn_station]:
+                    start_et = str_to_et(start)
+                    end_et = str_to_et(end)
+                    outage_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+            dsn_visible_mask[outage_mask] = False
+            total_visible_mask |= dsn_visible_mask
+
+            coverage_dict[f"{dsn_station}"] = et_to_utc(
+                time_range[dsn_visible_mask], format_str="ISOC"
+            )
+            outage_dict[f"{dsn_station}"] = et_to_utc(
+                time_range[outage_mask], format_str="ISOC"
+            )
+
+    # Total coverage percentage
+    total_coverage_percent = (
+        np.count_nonzero(total_visible_mask) / time_range.size
+    ) * 100
+    coverage_dict["total_coverage_percent"] = total_coverage_percent
+
+    # Ensure all stations are present in both dicts
+    for station in ALL_STATIONS:
+        coverage_dict.setdefault(station, np.array([], dtype="<U23"))
+        outage_dict.setdefault(station, np.array([], dtype="<U23"))
+
+    return coverage_dict, outage_dict
+
+
+def format_coverage_summary(
+    coverage_dict: dict, outage_dict: dict, start_time: str
+) -> dict:
+    """
+    Build the output dictionary containing coverage time for each station.
+
+    Parameters
+    ----------
+    coverage_dict : dict
+        Coverage for each station, keyed by station name with arrays of UTC times.
+    outage_dict : dict
+        Outage times for each station, keyed by station name with arrays of UTC times.
+    start_time : str
+        Start time in UTC.
+
+    Returns
+    -------
+    output_dict : dict
+        Formatted coverage summary.
+    """
+    # Include all known stations,
+    # plus any new ones that appear in coverage_dict.
+    all_stations = ALL_STATIONS + [
+        station
+        for station in coverage_dict.keys()
+        if station not in ALL_STATIONS and station != "total_coverage_percent"
+    ]
+
+    duration_seconds = 24 * 60 * 60  # 86400 seconds in 24 hours
+    time_step = 3600  # 1 hr in seconds
+
+    start_et_input = str_to_et(start_time)
+    stop_et_input = start_et_input + duration_seconds
+
+    time_range = np.arange(start_et_input, stop_et_input, time_step)
+    all_times = et_to_utc(time_range, format_str="ISOC")
+
+    data_rows = []
+    for time in all_times:
+        row = {"time": time}
+        for station in all_stations:
+            visible_times = coverage_dict.get(station, [])
+            outage_times = outage_dict.get(station, [])
+            if time in outage_times:
+                row[station] = "X"
+            elif time in visible_times:
+                row[station] = "1"
+            else:
+                row[station] = "0"
+        data_rows.append(row)
+
+    output_dict = {
+        "summary": "I-ALiRT Coverage Summary",
+        "generated": start_time,
+        "time_format": "UTC (ISOC)",
+        "stations": all_stations,
+        "total_coverage_percent": round(coverage_dict["total_coverage_percent"], 1),
+        "data": data_rows,
+    }
+
+    return output_dict

imap_processing/ialirt/l0/ialirt_spice.py

@@ -56,7 +56,10 @@ def get_rotation_matrix(axis: NDArray, angle: NDArray) -> NDArray:
     """
     angle_rad = np.radians(angle)
     rot_matrices = np.array(
-        [spice.axisar(z, float(phase)) for z, phase in zip(axis, angle_rad)]
+        [
+            spice.axisar(z, float(phase))
+            for z, phase in zip(axis, angle_rad, strict=False)
+        ]
     )
 
     return rot_matrices
@@ -185,7 +188,7 @@ def transform_instrument_vectors_to_inertial(
     vectors = np.array(
         [
             spice.mxv(rot.T.copy(), vec)
-            for rot, vec in zip(total_rotations, instrument_vectors)
+            for rot, vec in zip(total_rotations, instrument_vectors, strict=False)
         ]
     )
 

imap_processing/ialirt/l0/parse_mag.py

@@ -2,11 +2,13 @@
 
 import logging
 from decimal import Decimal
-from typing import Union
 
 import numpy as np
 import xarray as xr
 
+from imap_processing.ialirt.l0.ialirt_spice import (
+    transform_instrument_vectors_to_inertial,
+)
 from imap_processing.ialirt.l0.mag_l0_ialirt_data import (
     Packet0,
     Packet1,
@@ -20,7 +22,15 @@ from imap_processing.mag.l1b.mag_l1b import (
     calibrate_vector,
     shift_time,
 )
-from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc
+from imap_processing.mag.l1d.mag_l1d_data import MagL1d
+from imap_processing.mag.l2.mag_l2_data import MagL2L1dBase
+from imap_processing.spice.geometry import (
+    SpiceFrame,
+    cartesian_to_spherical,
+    frame_transform,
+    spherical_to_cartesian,
+)
+from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc, ttj2000ns_to_et
 
 logger = logging.getLogger(__name__)
 
@@ -193,7 +203,7 @@ def get_time(
         (grouped_data["group"] == group).values
     ][pkt_counter == 2]
 
-    time_data: dict[str, Union[int, float]] = {
+    time_data: dict[str, int | float] = {
         "pri_coarsetm": int(pri_coarsetm.item()),
         "pri_fintm": int(pri_fintm.item()),
         "sec_coarsetm": int(sec_coarsetm.item()),
@@ -286,9 +296,238 @@ def calculate_l1b(
     return updated_vector_mago, updated_vector_magi, time_data
 
 
+def calibrate_and_offset_vectors(
+    vectors: np.ndarray,
+    calibration: np.ndarray,
+    offsets: np.ndarray,
+    is_magi: bool = False,
+) -> np.ndarray:
+    """
+    Apply calibration and offsets to magnetic vectors.
+
+    Parameters
+    ----------
+    vectors : np.ndarray
+        Raw magnetic vectors, shape (n, 4).
+    calibration : np.ndarray
+        Calibration matrix, shape (3, 3, 4).
+    offsets : np.ndarray
+        Offsets array, shape (2, 4, 3) where:
+        - index 0 = MAGo, 1 = MAGi
+        - second index = range (0–3)
+        - third index = axis (x, y, z)
+    is_magi : bool, optional
+        True if applying to MAGi data, False for MAGo.
+
+    Returns
+    -------
+    calibrated_and_offset_vectors : np.ndarray
+        Calibrated and offset vectors, shape (n, 3).
+    """
+    # Apply calibration matrix -> (n,4)
+    # apply_calibration_offset_single_vector
+    calibrated = MagL2L1dBase.apply_calibration(vectors.reshape(1, 4), calibration)
+
+    # Apply offsets per vector
+    # vec shape (4)
+    # offsets shape (2, 4, 3) where first index is 0 for MAGo and 1 for MAGi
+    calibrated = np.array(
+        [
+            MagL1d.apply_calibration_offset_single_vector(vec, offsets, is_magi=is_magi)
+            for vec in calibrated
+        ]
+    )
+
+    return calibrated[:, :3]
+
+
+def apply_gradiometry_correction(
+    mago_vectors_eclipj2000: np.ndarray,
+    mago_time_data: np.ndarray,
+    magi_vectors_eclipj2000: np.ndarray,
+    magi_time_data: np.ndarray,
+    gradiometer_factor: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Align MAGi to MAGo timestamps and apply gradiometry correction.
+
+    Parameters
+    ----------
+    mago_vectors_eclipj2000 : np.ndarray
+        MAGo vectors in inertial frame, shape (N, 3).
+    mago_time_data : np.ndarray
+        Time for primary sensor, shape (N, 3).
+    magi_vectors_eclipj2000 : np.ndarray
+        MAGi vectors in inertial frame, shape (M, 3).
+    magi_time_data : np.ndarray
+        Time for secondary sensor, shape (N, 3).
+    gradiometer_factor : np.ndarray
+        A (3,3) element matrix to scale and rotate the gradiometer offsets.
+
+    Returns
+    -------
+    mago_corrected : np.ndarray
+        Corrected MAGo vectors in inertial frame, shape (N, 3).
+    magnitude : np.ndarray
+        Magnitude of corrected MAGo vectors, shape (N,).
+    """
+    gradiometry_offsets = MagL1d.calculate_gradiometry_offsets(
+        mago_vectors_eclipj2000,
+        mago_time_data,
+        magi_vectors_eclipj2000,
+        magi_time_data,
+    )
+    mago_corrected = MagL1d.apply_gradiometry_offsets(
+        gradiometry_offsets, mago_vectors_eclipj2000, gradiometer_factor
+    )
+    magnitude = np.linalg.norm(mago_corrected, axis=-1).squeeze()
+
+    return mago_corrected, magnitude
+
+
+def transform_to_inertial(
+    sc_spin_phase_rad: np.ndarray,
+    sc_inertial_right: np.ndarray,
+    sc_inertial_decline: np.ndarray,
+    attitude_time: np.ndarray,
+    target_time: float,
+    mag_vector: np.ndarray,
+) -> np.ndarray:
+    """
+    Transform vector to ECLIPJ2000.
+
+    Parameters
+    ----------
+    sc_spin_phase_rad : numpy.ndarray
+        Spin phase for 4 packets 0 to 2π radians, shape (4).
+    sc_inertial_right : numpy.ndarray
+        Inertial right ascension for 4 packets 0 to 2π radians, shape (4).
+    sc_inertial_decline : numpy.ndarray
+        Inertial declination for 4 packets -π/2 to π/2 radians, shape (4).
+    attitude_time : np.ndarray
+        Timestamps for the 4 packets.
+        Example: test_met = grouped_data["met"][
+                 (grouped_data["group"] == group).values].
+        ttj2000ns = met_to_ttj2000ns(test_met.values).
+    target_time : float
+        Time at which to apply the transformation.
+        Will be primary_epoch (mago vector) or secondary_epoch (magi vector).
+        Example: time_data['primary_epoch'].
+    mag_vector : numpy.ndarray
+        Vector, shape (3).
+
+    Returns
+    -------
+    inertial_vector : np.ndarray
+        Transformed vector in the ECLIPJ2000 frame, shape (3,).
+
+    Notes
+    -----
+    The MAG vectors are calculated based on 4 packets,
+    each of which contains its own spin phase,
+    inertial right ascension, and inertial decline.
+    """
+    if target_time < attitude_time.min() or target_time > attitude_time.max():
+        logger.warning(
+            f"target_time {target_time} is outside attitude_time bounds "
+            f"[{attitude_time.min()}, {attitude_time.max()}]; using edge values."
+        )
+
+    # Get sort order based on attitude_time
+    sort_idx = np.argsort(attitude_time)
+
+    # Sort all arrays accordingly
+    attitude_time = attitude_time[sort_idx]
+    sc_spin_phase_rad = sc_spin_phase_rad[sort_idx]
+    sc_inertial_right = sc_inertial_right[sort_idx]
+    sc_inertial_decline = sc_inertial_decline[sort_idx]
+
+    # Interpolate spin phase, RA, and Dec at target_time
+    # Convert RA/Dec to unit cartesian vectors
+    spherical_coords = np.stack(
+        [
+            np.ones_like(sc_inertial_right),
+            np.degrees(sc_inertial_right),
+            np.degrees(sc_inertial_decline),
+        ],
+        axis=-1,
+    )
+    vecs = spherical_to_cartesian(spherical_coords)
+
+    # Interpolate in Cartesian space
+    vx = np.interp(target_time, attitude_time, vecs[:, 0])
+    vy = np.interp(target_time, attitude_time, vecs[:, 1])
+    vz = np.interp(target_time, attitude_time, vecs[:, 2])
+    v_interp = np.array([vx, vy, vz])
+    # Normalize vector so that its magnitude is 1.
+    v_interp /= np.linalg.norm(v_interp)
+
+    # Convert back to spherical
+    ra_dec = cartesian_to_spherical(v_interp)
+    ra_deg = ra_dec[1]
+    dec_deg = ra_dec[2]
+
+    # Account for discontinuities in spin phase.
+    spin_phase_unwrapped = np.unwrap(sc_spin_phase_rad)
+    spin_phase_interp = np.interp(target_time, attitude_time, spin_phase_unwrapped)
+    spin_phase_deg = np.degrees(spin_phase_interp) % 360
+
+    # Transform each into ECLIPJ2000
+    inertial_vector = transform_instrument_vectors_to_inertial(
+        np.asarray(mag_vector).reshape(1, 3),
+        np.array([spin_phase_deg]),
+        np.array([ra_deg]),
+        np.array([dec_deg]),
+    )[0]
+
+    return inertial_vector
+
+
+def transform_to_frames(
+    target_time: np.ndarray,
+    inertial_vector: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Transform vector to different frames.
+
+    Parameters
+    ----------
+    target_time : np.ndarray
+        Time at which to apply the transformation.
+        Will be primary_epoch (mago vector).
+        Example: time_data['primary_epoch'].
+    inertial_vector : np.ndarray
+        Transformed vector in the ECLIPJ2000 frame, shape (3,).
+
+    Returns
+    -------
+    gse_vector : np.ndarray
+        Transformed vector in the GSE frame, shape (3,).
+    gsm_vector : np.ndarray
+        Transformed vector in the GSM frame, shape (3,).
+    rtn_vector : np.ndarray
+        Transformed vector in the RTN frame, shape (3,).
+    """
+    et_target_time = ttj2000ns_to_et(target_time)
+
+    gse_vector = frame_transform(
+        et_target_time, inertial_vector, SpiceFrame.ECLIPJ2000, SpiceFrame.IMAP_GSE
+    )
+    gsm_vector = frame_transform(
+        et_target_time, inertial_vector, SpiceFrame.ECLIPJ2000, SpiceFrame.IMAP_GSM
+    )
+    rtn_vector = frame_transform(
+        et_target_time, inertial_vector, SpiceFrame.ECLIPJ2000, SpiceFrame.IMAP_RTN
+    )
+
+    return gse_vector, gsm_vector, rtn_vector
+
+
 def process_packet(
-    accumulated_data: xr.Dataset, calibration_dataset: xr.Dataset
-) -> tuple[list[dict], list[dict]]:
+    accumulated_data: xr.Dataset,
+    engineering_calibration_dataset: xr.Dataset,
+    l1d_calibration_dataset: xr.Dataset,
+) -> list[dict]:
     """
     Parse the MAG packets.
 
@@ -296,8 +535,10 @@ def process_packet(
     ----------
     accumulated_data : xr.Dataset
         Packets dataset accumulated over 1 min.
-    calibration_dataset : xr.Dataset
-        Calibration dataset.
+    engineering_calibration_dataset : xr.Dataset
+        Engineering calibration dataset.
+    l1d_calibration_dataset : xr.Dataset
+        L1D calibration dataset.
 
     Returns
     -------
@@ -323,8 +564,12 @@ def process_packet(
     grouped_data = find_groups(accumulated_data, (0, 3), "pkt_counter", "met")
 
     unique_groups = np.unique(grouped_data["group"])
-    l1b_data = []
     mag_data = []
+    met_all = []
+    mago_vectors_all = []
+    mago_times_all = []
+    magi_vectors_all = []
+    magi_times_all = []
 
     for group in unique_groups:
         # Get status values for each group.
@@ -360,7 +605,7 @@ def process_packet(
             pkt_counter,
             science_data,
             status_data,
-            calibration_dataset,
+            engineering_calibration_dataset,
         )
 
         # Note: primary = MAGo, secondary = MAGi.
@@ -371,36 +616,99 @@ def process_packet(
         if status_data["sec_isvalid"] == 0:
             updated_vector_magi = np.full(4, -32768)
 
-        science_data.update(
-            {
-                "calibrated_pri_x": updated_vector_mago[0],
-                "calibrated_pri_y": updated_vector_mago[1],
-                "calibrated_pri_z": updated_vector_mago[2],
-                "calibrated_sec_x": updated_vector_magi[0],
-                "calibrated_sec_y": updated_vector_magi[1],
-                "calibrated_sec_z": updated_vector_magi[2],
-            }
+        mago_calibration = l1d_calibration_dataset["URFTOORFO"][0]
+        magi_calibration = l1d_calibration_dataset["URFTOORFI"][0]
+        offsets = l1d_calibration_dataset["offsets"][0]
+
+        mago_out = calibrate_and_offset_vectors(
+            updated_vector_mago, mago_calibration, offsets, is_magi=False
+        )
+        magi_out = calibrate_and_offset_vectors(
+            updated_vector_magi, magi_calibration, offsets, is_magi=True
         )
+        sc_spin_phase_rad = grouped_data["sc_spin_phase"][
+            (grouped_data["group"] == group).values
+        ]
+        sc_inertial_right = grouped_data["sc_inertial_right"][
+            (grouped_data["group"] == group).values
+        ]
+        sc_inertial_decline = grouped_data["sc_inertial_decline"][
+            (grouped_data["group"] == group).values
+        ]
 
-        l1b_data.append({**status_data, **science_data, **time_data})
+        attitude_time = met_to_ttj2000ns(
+            grouped_data["met"][(grouped_data["group"] == group).values]
+        )
+
+        # Convert to ECLIPJ2000 frame.
+        mago_inertial_vector = transform_to_inertial(
+            sc_spin_phase_rad.values,
+            sc_inertial_right.values,
+            sc_inertial_decline.values,
+            attitude_time,
+            time_data["primary_epoch"],
+            mago_out,
+        )
+        magi_inertial_vector = transform_to_inertial(
+            sc_spin_phase_rad.values,
+            sc_inertial_right.values,
+            sc_inertial_decline.values,
+            attitude_time,
+            time_data["secondary_epoch"],
+            magi_out,
+        )
 
-        # Placeholder for real data.
         met = grouped_data["met"][(grouped_data["group"] == group).values]
+        met_all.append(met.values[0])
+        mago_times_all.append(time_data["primary_epoch"])
+        mago_vectors_all.append(mago_inertial_vector)
+        magi_vectors_all.append(magi_inertial_vector)
+        magi_times_all.append(time_data["secondary_epoch"])
+
+    mago_corrected, magnitude = apply_gradiometry_correction(
+        np.array(mago_vectors_all),
+        np.array(mago_times_all),
+        np.array(magi_vectors_all),
+        np.array(magi_times_all),
+        l1d_calibration_dataset["gradiometer_factor"].values.squeeze(),
+    )
+
+    gse_vector, gsm_vector, rtn_vector = transform_to_frames(
+        np.array(mago_times_all), mago_corrected
+    )
+
+    spherical = cartesian_to_spherical(gsm_vector)
+    phi_gsm = spherical[:, 1]
+    theta_gsm = spherical[:, 2]
+
+    spherical = cartesian_to_spherical(gse_vector)
+    phi_gse = spherical[:, 1]
+    theta_gse = spherical[:, 2]
+
+    # Omit the first value since we expect it to be extrapolated.
+    for i in range(len(mago_corrected)):
+        if i == 0:
+            continue
+
         mag_data.append(
             {
                 "apid": 478,
-                "met": int(met.values.min()),
-                "met_in_utc": met_to_utc(met.values.min()).split(".")[0],
-                "ttj2000ns": int(met_to_ttj2000ns(met.values.min())),
-                "mag_4s_b_gse": [Decimal("0.0") for _ in range(3)],
-                "mag_4s_b_gsm": [Decimal("0.0") for _ in range(3)],
-                "mag_4s_b_rtn": [Decimal("0.0") for _ in range(3)],
-                "mag_phi_4s_b_gsm": Decimal("0.0"),
-                "mag_theta_4s_b_gsm": Decimal("0.0"),
+                "met": int(met_all[i]),
+                "met_in_utc": met_to_utc(met_all[i]).split(".")[0],
+                "ttj2000ns": int(met_to_ttj2000ns(met_all[i])),
+                "mag_epoch": int(mago_times_all[i]),
+                "mag_B_GSE": [Decimal(str(v)) for v in gse_vector[i]],
+                "mag_B_GSM": [Decimal(str(v)) for v in gsm_vector[i]],
+                "mag_B_RTN": [Decimal(str(v)) for v in rtn_vector[i]],
+                "mag_B_magnitude": Decimal(str(magnitude[i])),
+                "mag_phi_B_GSM": Decimal(str(phi_gsm[i])),
+                "mag_theta_B_GSM": Decimal(str(theta_gsm[i])),
+                "mag_phi_B_GSE": Decimal(str(phi_gse[i])),
+                "mag_theta_B_GSE": Decimal(str(theta_gse[i])),
             }
         )
 
-    return mag_data, l1b_data
+    return mag_data
 
 
 def retrieve_matrix_from_single_l1b_calibration(

imap_processing/ialirt/l0/process_hit.py

@@ -91,18 +91,20 @@ def create_l1(
     fast_rate_1_dict = {
         prefix: value
         for prefix, value in zip(
-            HIT_PREFIX_TO_RATE_TYPE["FAST_RATE_1"], fast_rate_1.data
+            HIT_PREFIX_TO_RATE_TYPE["FAST_RATE_1"], fast_rate_1.data, strict=False
         )
     }
     fast_rate_2_dict = {
         prefix: value
         for prefix, value in zip(
-            HIT_PREFIX_TO_RATE_TYPE["FAST_RATE_2"], fast_rate_2.data
+            HIT_PREFIX_TO_RATE_TYPE["FAST_RATE_2"], fast_rate_2.data, strict=False
         )
     }
     slow_rate_dict = {
         prefix: value
-        for prefix, value in zip(HIT_PREFIX_TO_RATE_TYPE["SLOW_RATE"], slow_rate.data)
+        for prefix, value in zip(
+            HIT_PREFIX_TO_RATE_TYPE["SLOW_RATE"], slow_rate.data, strict=False
+        )
     }
 
     l1 = {**fast_rate_1_dict, **fast_rate_2_dict, **slow_rate_dict}