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

imap_processing/lo/l1c/lo_l1c.py

@@ -4,12 +4,26 @@ from dataclasses import Field
 from enum import Enum
 
 import numpy as np
-import pandas as pd
 import xarray as xr
 from scipy.stats import binned_statistic_dd
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
-from imap_processing.spice.time import met_to_ttj2000ns
+from imap_processing.lo import lo_ancillary
+from imap_processing.spice.repoint import get_pointing_times
+from imap_processing.spice.spin import get_spin_number
+from imap_processing.spice.time import met_to_ttj2000ns, ttj2000ns_to_met
+
+N_ESA_ENERGY_STEPS = 7
+N_SPIN_ANGLE_BINS = 3600
+N_OFF_ANGLE_BINS = 40
+# 1 time, 7 energy steps, 3600 spin angle bins, and 40 off angle bins
+PSET_SHAPE = (1, N_ESA_ENERGY_STEPS, N_SPIN_ANGLE_BINS, N_OFF_ANGLE_BINS)
+PSET_DIMS = ["epoch", "esa_energy_step", "spin_angle", "off_angle"]
+ESA_ENERGY_STEPS = np.arange(N_ESA_ENERGY_STEPS) + 1  # 1 to 7 inclusive
+SPIN_ANGLE_BIN_EDGES = np.linspace(0, 360, N_SPIN_ANGLE_BINS + 1)
+SPIN_ANGLE_BIN_CENTERS = (SPIN_ANGLE_BIN_EDGES[:-1] + SPIN_ANGLE_BIN_EDGES[1:]) / 2
+OFF_ANGLE_BIN_EDGES = np.linspace(-2, 2, N_OFF_ANGLE_BINS + 1)
+OFF_ANGLE_BIN_CENTERS = (OFF_ANGLE_BIN_EDGES[:-1] + OFF_ANGLE_BIN_EDGES[1:]) / 2
 
 
 class FilterType(str, Enum):
@@ -52,10 +66,45 @@ def lo_l1c(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
     if "imap_lo_l1b_de" in sci_dependencies:
         logical_source = "imap_lo_l1c_pset"
         l1b_de = sci_dependencies["imap_lo_l1b_de"]
-
         l1b_goodtimes_only = filter_goodtimes(l1b_de, anc_dependencies)
         pset = initialize_pset(l1b_goodtimes_only, attr_mgr, logical_source)
         full_counts = create_pset_counts(l1b_goodtimes_only)
+
+        # Set the pointing start and end times based on the first epoch
+        pointing_start_met, pointing_end_met = get_pointing_times(
+            ttj2000ns_to_met(l1b_goodtimes_only["epoch"][0].item())
+        )
+
+        pset["pointing_start_met"] = xr.DataArray(
+            np.array([pointing_start_met]),
+            dims="epoch",
+            attrs=attr_mgr.get_variable_attributes("pointing_start_met"),
+        )
+        pset["pointing_end_met"] = xr.DataArray(
+            np.array([pointing_end_met]),
+            dims="epoch",
+            attrs=attr_mgr.get_variable_attributes("pointing_end_met"),
+        )
+
+        # Set the epoch to the start of the pointing
+        pset["epoch"] = xr.DataArray(
+            met_to_ttj2000ns(pset["pointing_start_met"].values),
+            attrs=attr_mgr.get_variable_attributes("epoch"),
+        )
+
+        # Get the start and end spin numbers based on the pointing start and end MET
+        pset["start_spin_number"] = xr.DataArray(
+            [get_spin_number(pset["pointing_start_met"].item())],
+            dims="epoch",
+            attrs=attr_mgr.get_variable_attributes("start_spin_number"),
+        )
+        pset["end_spin_number"] = xr.DataArray(
+            [get_spin_number(pset["pointing_end_met"].item())],
+            dims="epoch",
+            attrs=attr_mgr.get_variable_attributes("end_spin_number"),
+        )
+
+        # Set the counts
         pset["triples_counts"] = create_pset_counts(
             l1b_goodtimes_only, FilterType.TRIPLES
         )
@@ -64,19 +113,18 @@ def lo_l1c(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
         )
         pset["h_counts"] = create_pset_counts(l1b_goodtimes_only, FilterType.HYDROGEN)
         pset["o_counts"] = create_pset_counts(l1b_goodtimes_only, FilterType.OXYGEN)
+
+        # Set the exposure time
         pset["exposure_time"] = calculate_exposure_times(
             full_counts, l1b_goodtimes_only
         )
     pset.attrs = attr_mgr.get_global_attributes(logical_source)
-    # TODO: Temp fix before adding attribute variables.
-    #  CDF won't open if DEPEND_0 is not deleted currently.
-    del pset["epoch"].attrs["DEPEND_0"]
 
     pset = pset.assign_coords(
         {
-            "energy": np.arange(1, 8),
-            "longitude": np.arange(3600),
-            "latitude": np.arange(40),
+            "esa_energy_step": ESA_ENERGY_STEPS,
+            "spin_angle": SPIN_ANGLE_BIN_CENTERS,
+            "off_angle": OFF_ANGLE_BIN_CENTERS,
         }
     )
 
@@ -141,7 +189,7 @@ def filter_goodtimes(l1b_de: xr.Dataset, anc_dependencies: list) -> xr.Dataset:
         Filtered L1B Direct Event dataset.
     """
     # the goodtimes are currently the only ancillary file needed for L1C processing
-    goodtimes_table_df = pd.read_csv(anc_dependencies[0])
+    goodtimes_table_df = lo_ancillary.read_ancillary_file(anc_dependencies[0])
 
     # convert goodtimes from MET to TTJ2000
     goodtimes_start = met_to_ttj2000ns(goodtimes_table_df["GoodTime_strt"])
@@ -151,7 +199,7 @@ def filter_goodtimes(l1b_de: xr.Dataset, anc_dependencies: list) -> xr.Dataset:
     goodtimes_mask = np.zeros_like(l1b_de["epoch"], dtype=bool)
 
     # Iterate over the good times and create a mask
-    for start, end in zip(goodtimes_start, goodtimes_end):
+    for start, end in zip(goodtimes_start, goodtimes_end, strict=False):
         goodtimes_mask |= (l1b_de["epoch"] >= start) & (l1b_de["epoch"] < end)
 
     # Filter the dataset using the mask
@@ -249,7 +297,7 @@ def create_pset_counts(
 
     counts = xr.DataArray(
         data=hist.astype(np.int16),
-        dims=["epoch", "energy", "longitude", "latitude"],
+        dims=PSET_DIMS,
     )
 
     return counts
@@ -275,11 +323,6 @@ def calculate_exposure_times(counts: xr.DataArray, l1b_de: xr.Dataset) -> xr.Dat
     exposure_time : xarray.DataArray
         The exposure times for the L1B Direct Event dataset.
     """
-    # Create bin edges
-    lon_edges = np.arange(3601)
-    lat_edges = np.arange(41)
-    energy_edges = np.arange(8)
-
     data = np.column_stack(
         (l1b_de["esa_step"], l1b_de["pointing_bin_lon"], l1b_de["pointing_bin_lat"])
     )
@@ -289,14 +332,19 @@ def calculate_exposure_times(counts: xr.DataArray, l1b_de: xr.Dataset) -> xr.Dat
         # exposure time equation from Lo Alg Document 10.1.1.4
         4 * l1b_de["avg_spin_durations"].to_numpy() / 3600,
         statistic="mean",
-        bins=[energy_edges, lon_edges, lat_edges],
+        # NOTE: The l1b pointing_bin_lon is bin number, not actual angle
+        bins=[
+            np.arange(N_ESA_ENERGY_STEPS + 1),
+            np.arange(N_SPIN_ANGLE_BINS + 1),
+            np.arange(N_OFF_ANGLE_BINS + 1),
+        ],
     )
 
     stat = result.statistic[np.newaxis, :, :, :]
 
     exposure_time = xr.DataArray(
         data=stat.astype(np.float16),
-        dims=["epoch", "energy", "longitude", "latitude"],
+        dims=PSET_DIMS,
     )
 
     return exposure_time
@@ -328,8 +376,6 @@ def create_datasets(
     #  can be used direction
     epoch_converted_time = [1]
 
-    # Create a data array for the epoch time
-    # TODO: might need to update the attrs to use new YAML file
     epoch_time = xr.DataArray(
         data=epoch_converted_time,
         name="epoch",
@@ -338,38 +384,54 @@ def create_datasets(
     )
 
     if logical_source == "imap_lo_l1c_pset":
-        esa_step = xr.DataArray(
-            data=[1, 2, 3, 4, 5, 6, 7],
-            name="esa_step",
-            dims=["esa_step"],
-            attrs=attr_mgr.get_variable_attributes("esa_step"),
-        )
-        pointing_bins = xr.DataArray(
-            data=np.arange(3600),
-            name="pointing_bins",
-            dims=["pointing_bins"],
-            attrs=attr_mgr.get_variable_attributes("pointing_bins"),
+        esa_energy_step = xr.DataArray(
+            data=ESA_ENERGY_STEPS,
+            name="esa_energy_step",
+            dims=["esa_energy_step"],
+            attrs=attr_mgr.get_variable_attributes("esa_energy_step"),
         )
-
-        esa_step_label = xr.DataArray(
-            esa_step.values.astype(str),
+        esa_energy_step_label = xr.DataArray(
+            esa_energy_step.values.astype(str),
             name="esa_step_label",
             dims=["esa_step_label"],
             attrs=attr_mgr.get_variable_attributes("esa_step_label"),
         )
-        pointing_bins_label = xr.DataArray(
-            pointing_bins.values.astype(str),
-            name="pointing_bins_label",
-            dims=["pointing_bins_label"],
-            attrs=attr_mgr.get_variable_attributes("pointing_bins_label"),
+
+        spin_angle = xr.DataArray(
+            data=SPIN_ANGLE_BIN_CENTERS,
+            name="spin_angle",
+            dims=["spin_angle"],
+            attrs=attr_mgr.get_variable_attributes("spin_angle"),
+        )
+        spin_angle_label = xr.DataArray(
+            spin_angle.values.astype(str),
+            name="spin_angle_label",
+            dims=["spin_angle_label"],
+            attrs=attr_mgr.get_variable_attributes("spin_angle_label"),
+        )
+
+        off_angle = xr.DataArray(
+            data=OFF_ANGLE_BIN_CENTERS,
+            name="off_angle",
+            dims=["off_angle"],
+            attrs=attr_mgr.get_variable_attributes("off_angle"),
+        )
+        off_angle_label = xr.DataArray(
+            off_angle.values.astype(str),
+            name="off_angle_label",
+            dims=["off_angle_label"],
+            attrs=attr_mgr.get_variable_attributes("off_angle_label"),
         )
+
         dataset = xr.Dataset(
             coords={
                 "epoch": epoch_time,
-                "pointing_bins": pointing_bins,
-                "pointing_bins_label": pointing_bins_label,
-                "esa_step": esa_step,
-                "esa_step_label": esa_step_label,
+                "esa_energy_step": esa_energy_step,
+                "esa_energy_step_label": esa_energy_step_label,
+                "spin_angle": spin_angle,
+                "spin_angle_label": spin_angle_label,
+                "off_angle": off_angle,
+                "off_angle_label": off_angle_label,
             },
             attrs=attr_mgr.get_global_attributes(logical_source),
         )
@@ -389,30 +451,34 @@ def create_datasets(
 
         # Create a data array for the current field and add it to the dataset
         # TODO: TEMPORARY. need to update to use l1b data once that's available.
-        if field in ["pointing_start", "pointing_end", "mode", "pivot_angle"]:
+        if field in [
+            "pointing_start_met",
+            "pointing_end_met",
+            "esa_mode",
+            "pivot_angle",
+        ]:
             dataset[field] = xr.DataArray(
                 data=[1],
                 dims=dims,
                 attrs=attr_mgr.get_variable_attributes(field),
             )
         # TODO: This is temporary.
-        #  The data type will be set in the data class when that's created
         elif field == "exposure_time":
             dataset[field] = xr.DataArray(
-                data=np.ones((1, 7), dtype=np.float16),
+                data=np.ones((1, 7, 3600, 40), dtype=np.float16),
                 dims=dims,
                 attrs=attr_mgr.get_variable_attributes(field),
             )
 
-        elif "rate" in field:
+        elif "rates" in field:
             dataset[field] = xr.DataArray(
-                data=np.ones((1, 3600, 7), dtype=np.float16),
+                data=np.ones(PSET_SHAPE, dtype=np.float16),
                 dims=dims,
                 attrs=attr_mgr.get_variable_attributes(field),
             )
         else:
             dataset[field] = xr.DataArray(
-                data=np.ones((1, 3600, 7), dtype=np.int16),
+                data=np.ones(PSET_SHAPE, dtype=np.int16),
                 dims=dims,
                 attrs=attr_mgr.get_variable_attributes(field),
             )

imap_processing/lo/l2/lo_l2.py

@@ -5,12 +5,13 @@ import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.ena_maps import ena_maps
-from imap_processing.ena_maps.ena_maps import RectangularSkyMap
-from imap_processing.spice import geometry
-from imap_processing.spice.geometry import SpiceFrame
+from imap_processing.ena_maps.ena_maps import AbstractSkyMap, RectangularSkyMap
+from imap_processing.ena_maps.utils.naming import MapDescriptor
 
 
-def lo_l2(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
+def lo_l2(
+    sci_dependencies: dict, anc_dependencies: list, descriptor: str
+) -> list[xr.Dataset]:
     """
     Will process IMAP-Lo L1C data into Le CDF data products.
 
@@ -20,6 +21,8 @@ def lo_l2(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
         Dictionary of datasets needed for L2 data product creation in xarray Datasets.
     anc_dependencies : list
         Ancillary files needed for L2 data product creation.
+    descriptor : str
+        The map descriptor to be produced.
 
     Returns
     -------
@@ -37,18 +40,19 @@ def lo_l2(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
         logical_source = "imap_lo_l2_l090-ena-h-sf-nsp-ram-hae-6deg-3mo"
         psets = sci_dependencies["imap_lo_l1c_pset"]
 
-        # Create the rectangular sky map from the pointing set.
-        lo_rect_map = project_pset_to_rect_map(
-            psets, spacing_deg=6, spice_frame=geometry.SpiceFrame.ECLIPJ2000
-        )
+        # Create an AbstractSkyMap (Rectangular or HEALPIX) from the pointing set
+        lo_sky_map = project_pset_to_sky_map(psets, descriptor)
+        if not isinstance(lo_sky_map, RectangularSkyMap):
+            raise NotImplementedError("HEALPix map output not supported for Lo")
+
         # Add the hydrogen rates to the rectangular map dataset.
-        lo_rect_map.data_1d["h_rate"] = calculate_rates(
-            lo_rect_map.data_1d["h_counts"], lo_rect_map.data_1d["exposure_time"]
+        lo_sky_map.data_1d["h_rate"] = calculate_rates(
+            lo_sky_map.data_1d["h_counts"], lo_sky_map.data_1d["exposure_time"]
         )
         # Add the hydrogen flux to the rectangular map dataset.
-        lo_rect_map.data_1d["h_flux"] = calculate_fluxes(lo_rect_map.data_1d["h_rate"])
+        lo_sky_map.data_1d["h_flux"] = calculate_fluxes(lo_sky_map.data_1d["h_rate"])
         # Create the dataset from the rectangular map.
-        lo_rect_map_ds = lo_rect_map.to_dataset()
+        lo_rect_map_ds = lo_sky_map.to_dataset()
         # Add the attributes to the dataset.
         lo_rect_map_ds = add_attributes(
             lo_rect_map_ds, attr_mgr, logical_source=logical_source
@@ -57,41 +61,37 @@ def lo_l2(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
     return [lo_rect_map_ds]
 
 
-def project_pset_to_rect_map(
-    psets: list[xr.Dataset], spacing_deg: int, spice_frame: SpiceFrame
-) -> RectangularSkyMap:
+def project_pset_to_sky_map(psets: list[xr.Dataset], descriptor: str) -> AbstractSkyMap:
     """
-    Project the pointing set to a rectangular sky map.
+    Project the pointing set to a sky map.
 
-    This function is used to create a rectangular sky map from the pointing set
+    This function is used to create a sky map from the pointing set
     data in the L1C dataset.
 
     Parameters
     ----------
     psets : list[xr.Dataset]
         List of pointing sets in xarray Dataset format.
-    spacing_deg : int
-        The spacing in degrees for the rectangular sky map.
-    spice_frame : SpiceFrame
-        The SPICE frame to use for the rectangular sky map projection.
+    descriptor : str
+        The map descriptor for the map to be produced,
+        contains details about the map projection.
 
     Returns
     -------
-    RectangularSkyMap
-        The rectangular sky map created from the pointing set data.
+    AbstractSkyMap
+        The sky map created from the pointing set data.
     """
-    lo_rect_map = ena_maps.RectangularSkyMap(
-        spacing_deg=spacing_deg,
-        spice_frame=spice_frame,
-    )
+    map_descriptor = MapDescriptor.from_string(descriptor)
+    output_map = map_descriptor.to_empty_map()
+
     for pset in psets:
         lo_pset = ena_maps.LoPointingSet(pset)
-        lo_rect_map.project_pset_values_to_map(
+        output_map.project_pset_values_to_map(
             pointing_set=lo_pset,
             value_keys=["h_counts", "exposure_time"],
             index_match_method=ena_maps.IndexMatchMethod.PUSH,
         )
-    return lo_rect_map
+    return output_map
 
 
 def calculate_rates(counts: xr.DataArray, exposure_time: xr.DataArray) -> xr.DataArray:

imap_processing/lo/lo_ancillary.py

@@ -0,0 +1,55 @@
+"""Ancillary file reading for IMAP-Lo processing."""
+
+from pathlib import Path
+
+import pandas as pd
+
+# convert the YYYYDDD datetime format directly upon reading
+_CONVERTERS = {
+    "YYYYDDD": lambda x: pd.to_datetime(str(x), format="%Y%j"),
+    "#YYYYDDD": lambda x: pd.to_datetime(str(x), format="%Y%j"),
+    "YYYYDDD_strt": lambda x: pd.to_datetime(str(x), format="%Y%j"),
+    "YYYYDDD_end": lambda x: pd.to_datetime(str(x), format="%Y%j"),
+}
+
+# Columns in the csv files to rename for consistency
+_RENAME_COLUMNS = {
+    "YYYYDDD": "Date",
+    "#YYYYDDD": "Date",
+    "#Comments": "Comments",
+    "YYYYDDD_strt": "StartDate",
+    "YYYYDDD_end": "EndDate",
+}
+
+
+def read_ancillary_file(ancillary_file: str | Path) -> pd.DataFrame:
+    """
+    Read a generic ancillary CSV file into a pandas DataFrame.
+
+    Parameters
+    ----------
+    ancillary_file : str or Path
+        Path to the ancillary CSV file.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame containing the ancillary data.
+    """
+    skiprows = None
+    if "esa-mode-lut" in str(ancillary_file):
+        # skip the first row which is a comment
+        skiprows = [0]
+    elif "geometric-factor" in str(ancillary_file):
+        # skip the rows with comment headers indicating Hi_Res and Hi_Thr
+        skiprows = [1, 38]
+    df = pd.read_csv(ancillary_file, converters=_CONVERTERS, skiprows=skiprows)
+    df = df.rename(columns=_RENAME_COLUMNS)
+
+    if "geometric-factor" in str(ancillary_file):
+        # Add an ESA mode column based on the known structure of the file.
+        # The first 36 rows are ESA mode 0 (HiRes), the second 36 are ESA mode 1 (HiThr)
+        df["esa_mode"] = 0
+        df.loc[36:, "esa_mode"] = 1
+
+    return df

imap_processing/mag/l1a/mag_l1a.py

@@ -328,6 +328,7 @@ def generate_dataset(
     global_attributes = attribute_manager.get_global_attributes(logical_file_id)
     global_attributes["is_mago"] = str(bool(single_file_l1a.is_mago))
     global_attributes["is_active"] = str(bool(single_file_l1a.is_active))
+    global_attributes["all_vectors_primary"] = single_file_l1a.all_vectors_primary()
     global_attributes["vectors_per_second"] = (
         single_file_l1a.vectors_per_second_attribute()
     )

imap_processing/mag/l1a/mag_l1a_data.py

@@ -15,6 +15,7 @@ from imap_processing.mag.constants import (
     MAX_COMPRESSED_VECTOR_BITS,
     MAX_FINE_TIME,
     RANGE_BIT_WIDTH,
+    PrimarySensor,
 )
 from imap_processing.spice.time import met_to_ttj2000ns
 
@@ -241,6 +242,7 @@ class MagL1a:
     twos_complement()
     update_compression_array()
     vectors_per_second_attribute()
+    all_vectors_primary()
     """
 
     is_mago: bool
@@ -1117,3 +1119,27 @@ class MagL1a:
                 last_vectors_per_second = vecsec
 
         return output_str
+
+    def all_vectors_primary(self) -> bool:
+        """
+        Check if all vectors in the file are from the primary sensor.
+
+        For MAGO datasets, this checks if MAGO was consistently the primary sensor
+        across all packets. For MAGI datasets, this checks if MAGI was consistently
+        the primary sensor across all packets.
+
+        Returns
+        -------
+        bool
+            True if all vectors are from the primary sensor across all packets,
+            False otherwise.
+        """
+        expected_primary_value = (
+            PrimarySensor.MAGO.value if self.is_mago else PrimarySensor.MAGI.value
+        )
+
+        for _, packet in self.packet_definitions.items():
+            if packet.mago_is_primary != expected_primary_value:
+                return False
+
+        return True

imap_processing/mag/l1b/mag_l1b.py

@@ -74,7 +74,6 @@ def mag_l1b(
     calibration_matrix, time_shift = retrieve_matrix_from_l1b_calibration(
         calibration_dataset, day_to_process, is_mago
     )
-    print(f"Using calibration matrix: {calibration_matrix}")
 
     output_dataset = mag_l1b_processing(
         input_dataset, calibration_matrix, time_shift, mag_attributes, source
@@ -182,6 +181,9 @@ def mag_l1b_processing(
     try:
         global_attributes["is_mago"] = input_dataset.attrs["is_mago"]
         global_attributes["is_active"] = input_dataset.attrs["is_active"]
+        global_attributes["all_vectors_primary"] = input_dataset.attrs[
+            "all_vectors_primary"
+        ]
         global_attributes["vectors_per_second"] = timeshift_vectors_per_second(
             input_dataset.attrs["vectors_per_second"], time_shift
         )
@@ -245,7 +247,6 @@ def retrieve_matrix_from_l1b_calibration(
         The calibration matrix and time shift. These can be passed directly into
         update_vector, calibrate_vector, and shift_time.
     """
-    print(f"Finding data for day {day}")
     if is_mago:
         calibration_matrix = calibration_dataset.sel(epoch=day)["MFOTOURFO"]
         time_shift = calibration_dataset.sel(epoch=day)["OTS"]

imap_processing/mag/l1c/interpolation_methods.py

@@ -3,7 +3,6 @@
 
 import logging
 from enum import Enum
-from typing import Optional
 
 import numpy as np
 from scipy.interpolate import make_interp_spline
@@ -44,8 +43,8 @@ def linear(
     input_vectors: np.ndarray,
     input_timestamps: np.ndarray,
     output_timestamps: np.ndarray,
-    input_rate: Optional[VecSec] = None,
-    output_rate: Optional[VecSec] = None,
+    input_rate: VecSec | None = None,
+    output_rate: VecSec | None = None,
 ) -> np.ndarray:
     """
     Linear interpolation of input vectors to output timestamps.
@@ -80,8 +79,8 @@ def quadratic(
     input_vectors: np.ndarray,
     input_timestamps: np.ndarray,
     output_timestamps: np.ndarray,
-    input_rate: Optional[VecSec] = None,
-    output_rate: Optional[VecSec] = None,
+    input_rate: VecSec | None = None,
+    output_rate: VecSec | None = None,
 ) -> np.ndarray:
     """
     Quadratic interpolation of input vectors to output timestamps.
@@ -115,8 +114,8 @@ def cubic(
     input_vectors: np.ndarray,
     input_timestamps: np.ndarray,
     output_timestamps: np.ndarray,
-    input_rate: Optional[VecSec] = None,
-    output_rate: Optional[VecSec] = None,
+    input_rate: VecSec | None = None,
+    output_rate: VecSec | None = None,
 ) -> np.ndarray:
     """
     Cubic interpolation of input vectors to output timestamps.
@@ -175,8 +174,8 @@ def cic_filter(
     input_vectors: np.ndarray,
     input_timestamps: np.ndarray,
     output_timestamps: np.ndarray,
-    input_rate: Optional[VecSec],
-    output_rate: Optional[VecSec],
+    input_rate: VecSec | None,
+    output_rate: VecSec | None,
 ):
     """
     Apply CIC filter to data before interpolating.
@@ -242,8 +241,8 @@ def linear_filtered(
     input_vectors: np.ndarray,
     input_timestamps: np.ndarray,
     output_timestamps: np.ndarray,
-    input_rate: Optional[VecSec] = None,
-    output_rate: Optional[VecSec] = None,
+    input_rate: VecSec | None = None,
+    output_rate: VecSec | None = None,
 ) -> np.ndarray:
     """
     Linear filtered interpolation of input vectors to output timestamps.
@@ -281,8 +280,8 @@ def quadratic_filtered(
     input_vectors: np.ndarray,
     input_timestamps: np.ndarray,
     output_timestamps: np.ndarray,
-    input_rate: Optional[VecSec] = None,
-    output_rate: Optional[VecSec] = None,
+    input_rate: VecSec | None = None,
+    output_rate: VecSec | None = None,
 ) -> np.ndarray:
     """
     Quadratic filtered interpolation of input vectors to output timestamps.
@@ -320,8 +319,8 @@ def cubic_filtered(
     input_vectors: np.ndarray,
     input_timestamps: np.ndarray,
     output_timestamps: np.ndarray,
-    input_rate: Optional[VecSec] = None,
-    output_rate: Optional[VecSec] = None,
+    input_rate: VecSec | None = None,
+    output_rate: VecSec | None = None,
 ) -> np.ndarray:
     """
     Cubic filtered interpolation of input vectors to output timestamps.