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

imap_processing/spice/geometry.py

@@ -11,20 +11,17 @@ 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."""
 
-    # A subset of IMAP Specific bodies as defined in imap_wkcp.tf
+    # A subset of IMAP Specific bodies as defined in imap_001.tf
     IMAP = -43
     IMAP_SPACECRAFT = -43000
     # IMAP Pointing Frame (Despun) as defined in imap_science_xxx.tf
@@ -36,7 +33,7 @@ class SpiceBody(IntEnum):
 
 
 class SpiceFrame(IntEnum):
-    """SPICE IDs for reference frames in imap_wkcp.tf and imap_science_xxx.tf."""
+    """SPICE IDs for reference frames in imap_###.tf and imap_science_xxx.tf."""
 
     # Standard SPICE Frames
     J2000 = spiceypy.irfnum("J2000")
@@ -44,7 +41,7 @@ class SpiceFrame(IntEnum):
     ITRF93 = 13000
     # IMAP Pointing Frame (Despun) as defined in imap_science_xxx.tf
     IMAP_DPS = -43901
-    # IMAP specific as defined in imap_wkcp.tf
+    # IMAP specific as defined in imap_###.tf
     IMAP_SPACECRAFT = -43000
     IMAP_LO_BASE = -43100
     IMAP_LO_STAR_SENSOR = -43103
@@ -53,13 +50,17 @@ class SpiceFrame(IntEnum):
     IMAP_HI_90 = -43160
     IMAP_ULTRA_45 = -43200
     IMAP_ULTRA_90 = -43210
-    IMAP_MAG = -43250
+    # TODO: remove IMAP_MAG frame once all usages have been removed
+    IMAP_MAG = -43999
+    IMAP_MAG_BOOM = -43250
+    IMAP_MAG_I = -43251
+    IMAP_MAG_O = -43252
     IMAP_SWE = -43300
     IMAP_SWAPI = -43350
     IMAP_CODICE = -43400
     IMAP_HIT = -43500
     IMAP_IDEX = -43700
-    IMAP_GLOWS = -43750
+    IMAP_GLOWS = -43751
 
     # IMAP Science Frames (new additions from imap_science_xxx.tf)
     IMAP_OMD = -43900
@@ -90,7 +91,8 @@ BORESIGHT_LOOKUP = {
     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([0, 0, 1]),
+    SpiceFrame.IMAP_MAG_I: np.array([0, 0, 1]),
+    SpiceFrame.IMAP_MAG_O: np.array([0, 0, 1]),
     SpiceFrame.IMAP_SWE: np.array([-1, 0, 0]),
     SpiceFrame.IMAP_SWAPI: np.array([0, 1, 0]),
     SpiceFrame.IMAP_CODICE: np.array([0, 0, 1]),
@@ -100,10 +102,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 +137,66 @@ 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_I: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_MAG_O: 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 +208,26 @@ 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_I: 90 / 360,  # 0 + 90 = 90
+        SpiceFrame.IMAP_MAG_O: 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 +301,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 +350,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 +389,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 +427,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 +600,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:
@@ -199,7 +195,7 @@ def calculate_pointing_attitude_segments(
 
     - Latest NAIF leapseconds kernel (naif0012.tls)
     - The latest IMAP sclk (imap_sclk_NNNN.tsc)
-    - The latest IMAP frame kernel (imap_wkcp.tf)
+    - The latest IMAP frame kernel (imap_###.tf)
     - IMAP DPS frame kernel (imap_science_100.tf)
     - IMAP historical attitude kernel from which the pointing frame kernel will
     be generated.
@@ -214,7 +210,9 @@ def calculate_pointing_attitude_segments(
     count = spiceypy.ktotal("ck")
     loaded_ck_kernel, _, _, _ = spiceypy.kdata(count - 1, "ck")
     if str(ck_path) != loaded_ck_kernel:
-        raise ValueError(f"Error: Expected CK kernel {ck_path}")
+        raise ValueError(
+            f"Error: Expected CK kernel {ck_path} but loaded {loaded_ck_kernel}"
+        )
 
     id_imap_spacecraft = spiceypy.gipool("FRAME_IMAP_SPACECRAFT", 0, 1)
 
@@ -292,8 +290,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,13 +3,14 @@
 import functools
 import logging
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 import pandas as pd
 from numpy import typing as npt
 
 from imap_processing.spice import config
+from imap_processing.spice.geometry import imap_state
+from imap_processing.spice.time import met_to_sclkticks, sct_to_et
 
 logger = logging.getLogger(__name__)
 
@@ -113,7 +114,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 +195,78 @@ 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
+
+
+def get_pointing_mid_time(met_time: float) -> float:
+    """
+    Get mid-point of the pointing for the given MET time.
+
+    Get the mid-point time between the end of one repoint and
+    start of the next. Input could be a MET time.
+
+    Parameters
+    ----------
+    met_time : float
+        The MET time in a repoint.
+
+    Returns
+    -------
+    repoint_mid_time : float
+        The mid MET time of the repoint maneuver.
+    """
+    pointing_start_met, pointing_end_met = get_pointing_times(met_time)
+    return (pointing_start_met + pointing_end_met) / 2
+
+
+def get_mid_point_state(met_time: float) -> npt.NDArray:
+    """
+    Get IMAP state for the mid-point.
+
+    Get IMAP state for the mid-point of the pointing in
+    reference frame, ECLIPJ2000 and observer, SUN.
+
+    Parameters
+    ----------
+    met_time : float
+        The MET time in a pointing.
+
+    Returns
+    -------
+    mid_point_state : numpy.ndarray
+        The mid state of the pointing maneuver.
+    """
+    # Get mid point time in ET
+    mid_point_time = get_pointing_mid_time(met_time)
+    mid_point_time_et = sct_to_et(met_to_sclkticks(mid_point_time))
+
+    # Convert mid point time to state
+    pointing_state = imap_state(mid_point_time_et)
+    return pointing_state

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"),
     )