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

imap_processing/spice/geometry.py

@@ -11,15 +11,12 @@ Paradigms for developing this module:
 
 import typing
 from enum import IntEnum
-from typing import Union
 
 import numpy as np
 import numpy.typing as npt
 import spiceypy
 from numpy.typing import NDArray
 
-from imap_processing.spice.kernels import ensure_spice
-
 
 class SpiceBody(IntEnum):
     """Enum containing SPICE IDs for bodies that we use."""
@@ -100,10 +97,8 @@ BORESIGHT_LOOKUP = {
 }
 
 
-@typing.no_type_check
-@ensure_spice
 def imap_state(
-    et: Union[np.ndarray, float],
+    et: np.ndarray | float,
     ref_frame: SpiceFrame = SpiceFrame.ECLIPJ2000,
     abcorr: str = "NONE",
     observer: SpiceBody = SpiceBody.SUN,
@@ -137,14 +132,65 @@ def imap_state(
     return np.asarray(state)
 
 
+def get_instrument_mounting_az_el(instrument: SpiceFrame) -> np.ndarray:
+    """
+    Calculate the azimuth and elevation angle of instrument mounting.
+
+    Azimuth and elevation to instrument mounting in the spacecraft frame.
+    Azimuth is measured in degrees from the spacecraft x-axis. Elevation is measured
+    in degrees from the spacecraft x-y plane.
+
+    Parameters
+    ----------
+    instrument : SpiceFrame
+        Instrument to get the azimuth and elevation angles for.
+
+    Returns
+    -------
+    instrument_mounting_az_el : np.ndarray
+        2-element array containing azimuth and elevation of the instrument
+        mounting in the spacecraft frame. Azimuth is measured in degrees from
+        the spacecraft x-axis. Elevation is measured in degrees from the
+        spacecraft x-y plane.
+    """
+    # Each instrument can have a unique basis vector in the instrument
+    # frame that is used to compute the s/c to instrument mounting.
+    # Most of these vectors are the same as the instrument boresight vector.
+    mounting_normal_vector = {
+        SpiceFrame.IMAP_LO_BASE: np.array([0, -1, 0]),
+        SpiceFrame.IMAP_HI_45: np.array([0, 1, 0]),
+        SpiceFrame.IMAP_HI_90: np.array([0, 1, 0]),
+        SpiceFrame.IMAP_ULTRA_45: np.array([0, 0, 1]),
+        SpiceFrame.IMAP_ULTRA_90: np.array([0, 0, 1]),
+        SpiceFrame.IMAP_MAG: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_SWE: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_SWAPI: np.array([0, 0, -1]),
+        SpiceFrame.IMAP_CODICE: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_HIT: np.array([0, 1, 0]),
+        SpiceFrame.IMAP_IDEX: np.array([0, 1, 0]),
+        SpiceFrame.IMAP_GLOWS: np.array([0, 0, -1]),
+    }
+
+    # Get the instrument mounting normal vector expressed in the spacecraft frame
+    # The reference frames are fixed, so the et argument can be fixed at 0
+    instrument_normal_sc = frame_transform(
+        0, mounting_normal_vector[instrument], instrument, SpiceFrame.IMAP_SPACECRAFT
+    )
+    # Convert the cartesian coordinate to azimuth/elevation angles in degrees
+    return np.rad2deg(
+        spiceypy.recazl(instrument_normal_sc, azccw=True, elplsz=True)[1:]
+    )
+
+
 def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> float:
     """
     Get the spin phase offset from the spacecraft to the instrument.
 
     For now, the offset is a fixed lookup based on `Table 1: Nominal Instrument
-    to S/C CS Transformations` in document `7516-0011_drw.pdf`. These fixed
-    values will need to be updated based on calibration data or retrieved using
-    SPICE and the latest IMAP frame kernel.
+    to S/C CS Transformations` in document `7516-0011_drw.pdf`. That Table
+    defines the angle from the spacecraft y-axis. We add 90 and take the modulous
+    with 360 in order to get the angle from the spacecraft x-axis. These fixed
+    values will need to be updated based on calibration data.
 
     Parameters
     ----------
@@ -156,26 +202,25 @@ def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> fl
     spacecraft_to_instrument_spin_phase_offset : float
         The spin phase offset from the spacecraft to the instrument.
     """
-    # TODO: Implement retrieval from SPICE?
-    offset_lookup = {
-        SpiceFrame.IMAP_LO_BASE: 330 / 360,
-        SpiceFrame.IMAP_HI_45: 255 / 360,
-        SpiceFrame.IMAP_HI_90: 285 / 360,
-        SpiceFrame.IMAP_ULTRA_45: 33 / 360,
-        SpiceFrame.IMAP_ULTRA_90: 210 / 360,
-        SpiceFrame.IMAP_SWAPI: 168 / 360,
-        SpiceFrame.IMAP_IDEX: 90 / 360,
-        SpiceFrame.IMAP_CODICE: 136 / 360,
-        SpiceFrame.IMAP_HIT: 30 / 360,
-        SpiceFrame.IMAP_SWE: 153 / 360,
-        SpiceFrame.IMAP_GLOWS: 127 / 360,
-        SpiceFrame.IMAP_MAG: 0 / 360,
+    phase_offset_lookup = {
+        SpiceFrame.IMAP_LO_BASE: 60 / 360,  # (330 + 90) % 360 = 60
+        SpiceFrame.IMAP_HI_45: 345 / 360,  # 255 + 90 = 345
+        SpiceFrame.IMAP_HI_90: 15 / 360,  # (285 + 90) % 360 = 15
+        SpiceFrame.IMAP_ULTRA_45: 123 / 360,  # 33 + 90 = 123
+        SpiceFrame.IMAP_ULTRA_90: 300 / 360,  # 210 + 90 = 300
+        SpiceFrame.IMAP_SWAPI: 258 / 360,  # 168 + 90 = 258
+        SpiceFrame.IMAP_IDEX: 180 / 360,  # 90 + 90 = 180
+        SpiceFrame.IMAP_CODICE: 226 / 360,  # 136 + 90 = 226
+        SpiceFrame.IMAP_HIT: 120 / 360,  # 30 + 90 = 120
+        SpiceFrame.IMAP_SWE: 243 / 360,  # 153 + 90 = 243
+        SpiceFrame.IMAP_GLOWS: 217 / 360,  # 127 + 90 = 217
+        SpiceFrame.IMAP_MAG: 90 / 360,  # 0 + 90 = 90
     }
-    return offset_lookup[instrument]
+    return phase_offset_lookup[instrument]
 
 
 def frame_transform(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     position: npt.NDArray,
     from_frame: SpiceFrame,
     to_frame: SpiceFrame,
@@ -249,7 +294,7 @@ def frame_transform(
 
 
 def frame_transform_az_el(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     az_el: npt.NDArray,
     from_frame: SpiceFrame,
     to_frame: SpiceFrame,
@@ -298,10 +343,8 @@ def frame_transform_az_el(
     return to_frame_az_el[..., 1:3]
 
 
-@typing.no_type_check
-@ensure_spice
 def get_rotation_matrix(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     from_frame: SpiceFrame,
     to_frame: SpiceFrame,
 ) -> npt.NDArray:
@@ -339,7 +382,7 @@ def get_rotation_matrix(
 
 
 def instrument_pointing(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     instrument: SpiceFrame,
     to_frame: SpiceFrame,
     cartesian: bool = False,
@@ -377,7 +420,7 @@ def instrument_pointing(
 
 
 def basis_vectors(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     from_frame: SpiceFrame,
     to_frame: SpiceFrame,
 ) -> npt.NDArray:
@@ -550,9 +593,9 @@ def cartesian_to_latitudinal(coords: NDArray, degrees: bool = True) -> NDArray:
 
 
 def solar_longitude(
-    et: Union[np.ndarray, float],
+    et: np.ndarray | float,
     degrees: bool = True,
-) -> Union[float, npt.NDArray]:
+) -> float | npt.NDArray:
     """
     Compute the solar longitude of the Imap Spacecraft.
 

imap_processing/spice/pointing_frame.py

@@ -1,7 +1,6 @@
 """Functions for retrieving repointing table data."""
 
 import logging
-import typing
 from collections.abc import Generator
 from contextlib import contextmanager
 from datetime import datetime, timezone
@@ -13,7 +12,6 @@ from imap_data_access import SPICEFilePath
 from numpy.typing import NDArray
 
 from imap_processing.spice.geometry import SpiceFrame
-from imap_processing.spice.kernels import ensure_spice
 from imap_processing.spice.repoint import get_repoint_data
 from imap_processing.spice.time import (
     TICK_DURATION,
@@ -164,8 +162,6 @@ def write_pointing_frame_ck(
             )
 
 
-@typing.no_type_check
-@ensure_spice
 def calculate_pointing_attitude_segments(
     ck_path: Path,
 ) -> NDArray:
@@ -292,8 +288,6 @@ def calculate_pointing_attitude_segments(
     return pointing_segments
 
 
-@typing.no_type_check
-@ensure_spice
 def _average_quaternions(et_times: np.ndarray) -> NDArray:
     """
     Average the quaternions.

imap_processing/spice/repoint.py

@@ -3,7 +3,6 @@
 import functools
 import logging
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -113,7 +112,7 @@ def _load_repoint_data_with_cache(csv_path: Path) -> pd.DataFrame:
 
 
 def interpolate_repoint_data(
-    query_met_times: Union[float, npt.NDArray],
+    query_met_times: float | npt.NDArray,
 ) -> pd.DataFrame:
     """
     Interpolate repointing data to the queried MET times.
@@ -194,3 +193,31 @@ def interpolate_repoint_data(
     out_df["repoint_in_progress"] = query_met_times < out_df["repoint_end_met"].values
 
     return out_df
+
+
+def get_pointing_times(met_time: float) -> tuple[float, float]:
+    """
+    Get the start and end MET times for the pointing that contains the query MET time.
+
+    Parameters
+    ----------
+    met_time : float
+        The MET time in a pointing.
+
+    Returns
+    -------
+    pointing_start_time : float
+        The MET time of the repoint maneuver that ends before the query MET time.
+    pointing_end_time : float
+        The MET time of the repoint maneuver that starts after the query MET time.
+    """
+    # Find the pointing start time by finding the repoint end time
+    repoint_df = interpolate_repoint_data(met_time)
+    pointing_start_met = repoint_df["repoint_end_met"].item()
+    # Find the pointing end time by finding the next repoint start time
+    repoint_df = get_repoint_data()
+    pointing_idx = repoint_df.index[
+        repoint_df["repoint_end_met"] == pointing_start_met
+    ][0]
+    pointing_end_met = repoint_df["repoint_start_met"].iloc[pointing_idx + 1].item()
+    return pointing_start_met, pointing_end_met

imap_processing/spice/spin.py

@@ -4,7 +4,6 @@ import functools
 import logging
 from functools import reduce
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -129,7 +128,7 @@ def _load_spin_data_with_cache(csv_paths: tuple[Path]) -> pd.DataFrame:
     return combined_df
 
 
-def interpolate_spin_data(query_met_times: Union[float, npt.NDArray]) -> pd.DataFrame:
+def interpolate_spin_data(query_met_times: float | npt.NDArray) -> pd.DataFrame:
     """
     Interpolate spin table data to the queried MET times.
 
@@ -213,10 +212,31 @@ def interpolate_spin_data(query_met_times: Union[float, npt.NDArray]) -> pd.Data
     return out_df
 
 
+def get_spin_number(met_time: float) -> int:
+    """
+    Get the spin number for the input query time.
+
+    The spin number is the index of the spin table row that contains the
+    spin data for the input query time.
+
+    Parameters
+    ----------
+    met_time : float
+        Query time in Mission Elapsed Time (MET).
+
+    Returns
+    -------
+    spin_number : int
+        Spin number for the input query time.
+    """
+    spin_df = interpolate_spin_data(met_time)
+    return spin_df["spin_number"].item()
+
+
 def get_spin_angle(
-    spin_phases: Union[float, npt.NDArray],
+    spin_phases: float | npt.NDArray,
     degrees: bool = False,
-) -> Union[float, npt.NDArray]:
+) -> float | npt.NDArray:
     """
     Convert spin_phases to radians or degrees.
 
@@ -249,8 +269,8 @@ def get_spin_angle(
 
 
 def get_spacecraft_spin_phase(
-    query_met_times: Union[float, npt.NDArray],
-) -> Union[float, npt.NDArray]:
+    query_met_times: float | npt.NDArray,
+) -> float | npt.NDArray:
     """
     Get the spacecraft spin phase for the input query times.
 
@@ -274,8 +294,8 @@ def get_spacecraft_spin_phase(
 
 
 def get_instrument_spin_phase(
-    query_met_times: Union[float, npt.NDArray], instrument: SpiceFrame
-) -> Union[float, npt.NDArray]:
+    query_met_times: float | npt.NDArray, instrument: SpiceFrame
+) -> float | npt.NDArray:
     """
     Get the instrument spin phase for the input query times.
 

imap_processing/spice/time.py

@@ -3,14 +3,12 @@
 import typing
 from collections.abc import Collection, Iterable
 from datetime import datetime
-from typing import Union
 
 import numpy as np
 import numpy.typing as npt
 import spiceypy
 
 from imap_processing.spice import IMAP_SC_ID
-from imap_processing.spice.kernels import ensure_spice
 
 TICK_DURATION = 2e-5  # 20 microseconds as defined in imap_sclk_0000.tsc
 
@@ -103,7 +101,6 @@ def met_to_ttj2000ns(
 
 
 @typing.no_type_check
-@ensure_spice
 def ttj2000ns_to_et(tt_ns: npt.ArrayLike) -> npt.NDArray[float]:
     """
     Convert TT J2000 epoch nanoseconds to TDB J2000 epoch seconds.
@@ -131,7 +128,6 @@ def ttj2000ns_to_et(tt_ns: npt.ArrayLike) -> npt.NDArray[float]:
 
 
 @typing.no_type_check
-@ensure_spice
 def et_to_ttj2000ns(et: npt.ArrayLike) -> npt.NDArray[float]:
     """
     Convert TDB J2000 epoch seconds to TT J2000 epoch nanoseconds.
@@ -157,7 +153,6 @@ def et_to_ttj2000ns(et: npt.ArrayLike) -> npt.NDArray[float]:
 
 
 @typing.no_type_check
-@ensure_spice(time_kernels_only=True)
 def met_to_utc(met: npt.ArrayLike, precision: int = 9) -> npt.NDArray[str]:
     """
     Convert mission elapsed time (MET) to UTC.
@@ -184,7 +179,7 @@ def met_to_utc(met: npt.ArrayLike, precision: int = 9) -> npt.NDArray[str]:
 
 def met_to_datetime64(
     met: npt.ArrayLike,
-) -> Union[np.datetime64, npt.NDArray[np.datetime64]]:
+) -> np.datetime64 | npt.NDArray[np.datetime64]:
     """
     Convert mission elapsed time (MET) to datetime.datetime.
 
@@ -203,7 +198,7 @@ def met_to_datetime64(
 
 def et_to_datetime64(
     et: npt.ArrayLike,
-) -> Union[np.datetime64, npt.NDArray[np.datetime64]]:
+) -> np.datetime64 | npt.NDArray[np.datetime64]:
     """
     Convert ET to numpy datetime64.
 
@@ -221,10 +216,9 @@ def et_to_datetime64(
 
 
 @typing.no_type_check
-@ensure_spice
 def et_to_met(
-    et: Union[float, Collection[float]],
-) -> Union[float, np.ndarray]:
+    et: float | Collection[float],
+) -> float | np.ndarray:
     """
     Convert ephemeris time to mission elapsed time (MET).
 
@@ -272,10 +266,9 @@ def ttj2000ns_to_met(
 
 
 @typing.no_type_check
-@ensure_spice
 def sct_to_et(
-    sclk_ticks: Union[float, Collection[float]],
-) -> Union[float, np.ndarray]:
+    sclk_ticks: float | Collection[float],
+) -> float | np.ndarray:
     """
     Convert encoded spacecraft clock "ticks" to ephemeris time.
 
@@ -298,10 +291,9 @@ def sct_to_et(
 
 
 @typing.no_type_check
-@ensure_spice
 def sct_to_ttj2000s(
-    sclk_ticks: Union[float, Iterable[float]],
-) -> Union[float, np.ndarray]:
+    sclk_ticks: float | Iterable[float],
+) -> float | np.ndarray:
     """
     Convert encoded spacecraft clock "ticks" to terrestrial time (TT).
 
@@ -330,10 +322,9 @@ def sct_to_ttj2000s(
 
 
 @typing.no_type_check
-@ensure_spice
 def str_to_et(
-    time_str: Union[str, Iterable[str]],
-) -> Union[float, np.ndarray]:
+    time_str: str | Iterable[str],
+) -> float | np.ndarray:
     """
     Convert string to ephemeris time.
 
@@ -356,13 +347,12 @@ def str_to_et(
 
 
 @typing.no_type_check
-@ensure_spice
 def et_to_utc(
-    et: Union[float, Iterable[float]],
+    et: float | Iterable[float],
     format_str: str = "ISOC",
     precision: int = 3,
     utclen: int = 24,
-) -> Union[str, np.ndarray]:
+) -> str | np.ndarray:
     """
     Convert ephemeris time to UTC.
 

imap_processing/swapi/l1/swapi_l1.py

@@ -138,7 +138,7 @@ def decompress_count(
 
     # SWAPI suggested using big value to indicate overflow.
     new_count[compressed_indices & (count_data == 0xFFFF)] = np.iinfo(np.int32).max
-    return new_count
+    return (new_count).astype(np.float32)
 
 
 def find_sweep_starts(packets: xr.Dataset) -> npt.NDArray:
@@ -474,6 +474,12 @@ def process_swapi_science(
     swp_scem_counts = decompress_count(raw_scem_count, scem_compression_flags)
     swp_coin_counts = decompress_count(raw_coin_count, coin_compression_flags)
 
+    # Fill first index of 72 steps with nan value per
+    # SWAPI team's instruction. nan helps with plotting.
+    swp_pcem_counts[:, 0] = np.nan
+    swp_scem_counts[:, 0] = np.nan
+    swp_coin_counts[:, 0] = np.nan
+
     # ====================================================
     # Load the CDF attributes
     # ====================================================
@@ -600,17 +606,17 @@ def process_swapi_science(
     )
 
     dataset["swp_pcem_counts"] = xr.DataArray(
-        np.array(swp_pcem_counts, dtype=np.uint16),
+        swp_pcem_counts,
         dims=["epoch", "esa_step"],
         attrs=cdf_manager.get_variable_attributes("pcem_counts"),
     )
     dataset["swp_scem_counts"] = xr.DataArray(
-        np.array(swp_scem_counts, dtype=np.uint16),
+        swp_scem_counts,
         dims=["epoch", "esa_step"],
         attrs=cdf_manager.get_variable_attributes("scem_counts"),
     )
     dataset["swp_coin_counts"] = xr.DataArray(
-        np.array(swp_coin_counts, dtype=np.uint16),
+        swp_coin_counts,
         dims=["epoch", "esa_step"],
         attrs=cdf_manager.get_variable_attributes("coin_counts"),
     )

imap_processing/swapi/l2/swapi_l2.py

@@ -12,7 +12,7 @@ from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 logger = logging.getLogger(__name__)
 
 
-TIME_PER_BIN = 0.167  # seconds
+SWAPI_LIVETIME = 0.145  # seconds
 
 
 def solve_full_sweep_energy(
@@ -66,7 +66,7 @@ def solve_full_sweep_energy(
 
     first_63_energies = []
 
-    for time, sweep_id in zip(data_time, sweep_table):
+    for time, sweep_id in zip(data_time, sweep_table, strict=False):
         # Find the sweep's ESA data for the given time and sweep_id
         subset = esa_table_df[
             (esa_table_df["timestamp"] <= time) & (esa_table_df["Sweep #"] == sweep_id)
@@ -159,14 +159,12 @@ def swapi_l2(
 
     To process science data to L2, we need to:
     - convert counts to rates. This is done by dividing the counts by the
-        TIME_PER_BIN time. TIME_PER_BIN is the exposure time per energy bin which is
-        obtained by dividing the time for one complete sweep
-        (12 s, coarse + fine sweep) by the total energy steps (72),
-        i.e., TIME_PER_BIN = 12/72 = 0.167 s. This will be constant.
+        SWAPI_LIVETIME time. LIVETIME is data acquisition time. It will
+        be constant, SWAPI_LIVETIME = 0.145 s.
 
     - update uncertainty. Calculate new uncertainty value using
-        SWP_PCEM_ERR data from level one and divide by TIME_PER_BIN. Eg.
-            SWP_PCEM_UNC = SWP_PCEM_ERR / TIME_PER_BIN
+        SWP_PCEM_ERR data from level one and divide by SWAPI_LIVETIME. Eg.
+            SWP_PCEM_UNC = SWP_PCEM_ERR / SWAPI_LIVETIME
         Do the same for SCEM and COIN data.
 
     Parameters
@@ -233,9 +231,9 @@ def swapi_l2(
     ]
 
     # convert counts to rate
-    l2_dataset["swp_pcem_rate"] = l1_dataset["swp_pcem_counts"] / TIME_PER_BIN
-    l2_dataset["swp_scem_rate"] = l1_dataset["swp_scem_counts"] / TIME_PER_BIN
-    l2_dataset["swp_coin_rate"] = l1_dataset["swp_coin_counts"] / TIME_PER_BIN
+    l2_dataset["swp_pcem_rate"] = l1_dataset["swp_pcem_counts"] / SWAPI_LIVETIME
+    l2_dataset["swp_scem_rate"] = l1_dataset["swp_scem_counts"] / SWAPI_LIVETIME
+    l2_dataset["swp_coin_rate"] = l1_dataset["swp_coin_counts"] / SWAPI_LIVETIME
     # update attrs
     l2_dataset["swp_pcem_rate"].attrs = cdf_manager.get_variable_attributes("pcem_rate")
     l2_dataset["swp_scem_rate"].attrs = cdf_manager.get_variable_attributes("scem_rate")
@@ -243,22 +241,22 @@ def swapi_l2(
 
     # update uncertainty
     l2_dataset["swp_pcem_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_pcem_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_pcem_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_pcem_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_pcem_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_pcem_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_scem_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_scem_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_scem_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_scem_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_scem_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_scem_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_coin_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_coin_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_coin_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_coin_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_coin_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_coin_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     # update attrs
     l2_dataset[

imap_processing/swe/l1b/swe_l1b.py

@@ -2,7 +2,6 @@
 
 import logging
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 import numpy.typing as npt
@@ -51,7 +50,7 @@ def get_esa_dataframe(esa_table_number: int) -> pd.DataFrame:
 
 
 def deadtime_correction(
-    counts: np.ndarray, acq_duration: Union[int, npt.NDArray]
+    counts: np.ndarray, acq_duration: int | npt.NDArray
 ) -> npt.NDArray:
     """
     Calculate deadtime correction.

imap_processing/ultra/constants.py

@@ -51,7 +51,6 @@ class UltraConstants:
     Z_DSTOP: float = 2.6 / 2  # Position of stop foil on Z axis [mm]
     Z_DS: float = 46.19 - (2.6 / 2)  # Position of slit on Z axis [mm]
     DF: float = 3.39  # Distance from slit to foil [mm]
-
     # Derived constants
     DMIN_PH_CTOF: float = (
         Z_DS - (2**0.5) * DF
@@ -79,52 +78,30 @@ class UltraConstants:
     CULLING_RPM_MIN = 2.0
     CULLING_RPM_MAX = 6.0
 
-    # Thresholds for culling based on counts.
+    # Thresholds for culling based on counts (keV).
     CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [
         3.385,
         4.13722222222222,
-        4.13722222222222,
-        5.05660493827161,
         5.05660493827161,
         6.18029492455419,
-        6.18029492455419,
-        7.55369379667734,
         7.55369379667734,
         9.23229241816119,
-        9.23229241816119,
         11.2839129555303,
-        11.2839129555303,
-        13.7914491678704,
         13.7914491678704,
         16.8562156496194,
-        16.8562156496194,
         20.6020413495348,
-        20.6020413495348,
-        25.1802727605426,
         25.1802727605426,
         30.775888929552,
-        30.775888929552,
         37.6149753583414,
-        37.6149753583414,
-        45.9738587713061,
         45.9738587713061,
         56.1902718315964,
-        56.1902718315964,
         68.6769989052845,
-        68.6769989052845,
-        83.93855421757,
         83.93855421757,
         102.591566265919,
-        102.591566265919,
         125.38969210279,
-        125.38969210279,
-        153.254068125632,
         153.254068125632,
         187.310527709106,
-        187.310527709106,
         228.93508942224,
-        228.93508942224,
-        279.809553738294,
         279.809553738294,
         341.989454569026,
         1e5,