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

imap_processing/spice/geometry.py

@@ -1,5 +1,5 @@
 """
-Functions for computing geometry, many of which use SPICE.
+Functions for computing geometry, many of which use SPICEYPY.
 
 Paradigms for developing this module:
 
@@ -9,16 +9,13 @@ Paradigms for developing this module:
 * Always return numpy arrays for vectorized calls.
 """
 
-import os
 import typing
 from enum import IntEnum
-from pathlib import Path
 from typing import Union
 
 import numpy as np
 import numpy.typing as npt
-import pandas as pd
-import spiceypy as spice
+import spiceypy
 from numpy.typing import NDArray
 
 from imap_processing.spice.kernels import ensure_spice
@@ -33,17 +30,18 @@ class SpiceBody(IntEnum):
     # IMAP Pointing Frame (Despun) as defined in imap_science_0001.tf
     IMAP_DPS = -43901
     # Standard NAIF bodies
-    SOLAR_SYSTEM_BARYCENTER = spice.bodn2c("SOLAR_SYSTEM_BARYCENTER")
-    SUN = spice.bodn2c("SUN")
-    EARTH = spice.bodn2c("EARTH")
+    SOLAR_SYSTEM_BARYCENTER = spiceypy.bodn2c("SOLAR_SYSTEM_BARYCENTER")
+    SUN = spiceypy.bodn2c("SUN")
+    EARTH = spiceypy.bodn2c("EARTH")
 
 
 class SpiceFrame(IntEnum):
     """Enum containing SPICE IDs for reference frames, defined in imap_wkcp.tf."""
 
     # Standard SPICE Frames
-    J2000 = spice.irfnum("J2000")
-    ECLIPJ2000 = spice.irfnum("ECLIPJ2000")
+    J2000 = spiceypy.irfnum("J2000")
+    ECLIPJ2000 = spiceypy.irfnum("ECLIPJ2000")
+    ITRF93 = 13000
     # IMAP Pointing Frame (Despun) as defined in imap_science_0001.tf
     IMAP_DPS = -43901
     # IMAP specific as defined in imap_wkcp.tf
@@ -85,6 +83,7 @@ BORESIGHT_LOOKUP = {
 def imap_state(
     et: Union[np.ndarray, float],
     ref_frame: SpiceFrame = SpiceFrame.ECLIPJ2000,
+    abcorr: str = "NONE",
     observer: SpiceBody = SpiceBody.SUN,
 ) -> np.ndarray:
     """
@@ -96,10 +95,12 @@ def imap_state(
     ----------
     et : np.ndarray or float
         Epoch time(s) [J2000 seconds] to get the IMAP state for.
-    ref_frame : SpiceFrame
+    ref_frame : SpiceFrame (Optional)
         Reference frame which the IMAP state is expressed in. Default is
         SpiceFrame.ECLIPJ2000.
-    observer : SpiceBody
+    abcorr : str (Optional)
+        Aberration correction flag. Default is "NONE".
+    observer : SpiceBody (Optional)
         Observing body. Default is SpiceBody.SUN.
 
     Returns
@@ -108,163 +109,12 @@ def imap_state(
      The Cartesian state vector representing the position and velocity of the
      IMAP spacecraft.
     """
-    state, _ = spice.spkezr(
-        SpiceBody.IMAP.name, et, ref_frame.name, "NONE", observer.name
+    state, _ = spiceypy.spkezr(
+        SpiceBody.IMAP.name, et, ref_frame.name, abcorr, observer.name
     )
     return np.asarray(state)
 
 
-def get_spin_data() -> pd.DataFrame:
-    """
-    Read spin file using environment variable and return spin data.
-
-    SPIN_DATA_FILEPATH environment variable would be a fixed value.
-    It could be s3 filepath that can be used to download the data
-    through API or it could be path EFS or Batch volume mount path.
-
-    Spin data should contain the following fields:
-        * spin_number
-        * spin_start_sec
-        * spin_start_subsec
-        * spin_period_sec
-        * spin_period_valid
-        * spin_phase_valid
-        * spin_period_source
-        * thruster_firing
-
-    Returns
-    -------
-    spin_data : pandas.DataFrame
-        Spin data.
-    """
-    spin_data_filepath = os.getenv("SPIN_DATA_FILEPATH")
-    if spin_data_filepath is not None:
-        path_to_spin_file = Path(spin_data_filepath)
-    else:
-        # Handle the case where the environment variable is not set
-        raise ValueError("SPIN_DATA_FILEPATH environment variable is not set.")
-
-    spin_df = pd.read_csv(path_to_spin_file, comment="#")
-    # Combine spin_start_sec and spin_start_subsec to get the spin start
-    # time in seconds. The spin start subseconds are in milliseconds.
-    spin_df["spin_start_time"] = (
-        spin_df["spin_start_sec"] + spin_df["spin_start_subsec"] / 1e3
-    )
-
-    return spin_df
-
-
-def get_spacecraft_spin_phase(
-    query_met_times: Union[float, npt.NDArray],
-) -> Union[float, npt.NDArray]:
-    """
-    Get the spacecraft spin phase for the input query times.
-
-    Formula to calculate spin phase:
-        spin_phase = (query_met_times - spin_start_time) / spin_period_sec
-
-    Parameters
-    ----------
-    query_met_times : float or np.ndarray
-        Query times in Mission Elapsed Time (MET).
-
-    Returns
-    -------
-    spin_phase : float or np.ndarray
-        Spin phase for the input query times.
-    """
-    spin_df = get_spin_data()
-
-    # Ensure query_met_times is an array
-    query_met_times = np.asarray(query_met_times)
-    is_scalar = query_met_times.ndim == 0
-    if is_scalar:
-        # Force scalar to array because np.asarray() will not
-        # convert scalar to array
-        query_met_times = np.atleast_1d(query_met_times)
-    # Empty array check
-    if query_met_times.size == 0:
-        return query_met_times
-
-    # Create an empty array to store spin phase results
-    spin_phases = np.zeros_like(query_met_times)
-
-    # Find all spin time that are less or equal to query_met_times.
-    # To do that, use side right, a[i-1] <= v < a[i], in the searchsorted.
-    # Eg.
-    # >>> df['a']
-    # array([0, 15, 30, 45, 60])
-    # >>> np.searchsorted(df['a'], [0, 13, 15, 32, 70], side='right')
-    # array([1, 1, 2, 3, 5])
-    last_spin_indices = (
-        np.searchsorted(spin_df["spin_start_time"], query_met_times, side="right") - 1
-    )
-    # Make sure input times are within the bounds of spin data
-    spin_df_start_time = spin_df["spin_start_time"].values[0]
-    spin_df_end_time = (
-        spin_df["spin_start_time"].values[-1] + spin_df["spin_period_sec"].values[-1]
-    )
-    input_start_time = query_met_times.min()
-    input_end_time = query_met_times.max()
-    if input_start_time < spin_df_start_time or input_end_time >= spin_df_end_time:
-        raise ValueError(
-            f"Query times, {query_met_times} are outside of the spin data range, "
-            f"{spin_df_start_time, spin_df_end_time}."
-        )
-
-    # Calculate spin phase
-    spin_phases = (
-        query_met_times - spin_df["spin_start_time"].values[last_spin_indices]
-    ) / spin_df["spin_period_sec"].values[last_spin_indices]
-
-    # Check for invalid spin phase using below checks:
-    # 1. Check that the spin phase is in valid range, [0, 1).
-    # 2. Check invalid spin phase using spin_phase_valid,
-    #   spin_period_valid columns.
-    invalid_spin_phase_range = (spin_phases < 0) | (spin_phases >= 1)
-
-    invalid_spins = (spin_df["spin_phase_valid"].values[last_spin_indices] == 0) | (
-        spin_df["spin_period_valid"].values[last_spin_indices] == 0
-    )
-    bad_spin_phases = invalid_spin_phase_range | invalid_spins
-    spin_phases[bad_spin_phases] = np.nan
-
-    if is_scalar:
-        return spin_phases[0]
-    return spin_phases
-
-
-def get_instrument_spin_phase(
-    query_met_times: Union[float, npt.NDArray],
-    instrument: SpiceFrame,
-) -> Union[float, npt.NDArray]:
-    """
-    Get the instrument spin phase for the input query times.
-
-    Formula to calculate spin phase:
-        instrument_spin_phase = (spacecraft_spin_phase + instrument_spin_offset) % 1
-
-    Parameters
-    ----------
-    query_met_times : float or np.ndarray
-        Query times in Mission Elapsed Time (MET).
-    instrument : SpiceFrame
-        Instrument frame to calculate spin phase for.
-
-    Returns
-    -------
-    spin_phase : float or np.ndarray
-        Instrument spin phase for the input query times. Spin phase is a
-        floating point number in the range [0, 1) corresponding to the
-        spin angle / 360.
-    """
-    spacecraft_spin_phase = get_spacecraft_spin_phase(query_met_times)
-    instrument_spin_phase_offset = get_spacecraft_to_instrument_spin_phase_offset(
-        instrument
-    )
-    return (spacecraft_spin_phase + instrument_spin_phase_offset) % 1
-
-
 def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> float:
     """
     Get the spin phase offset from the spacecraft to the instrument.
@@ -314,9 +164,9 @@ def frame_transform(
     This function is a vectorized equivalent to performing the following SPICE
     calls for each input time and position vector to perform the transform.
     The matrix multiplication step is done using `numpy.matmul` rather than
-    `spice.mxv`.
-    >>> rotation_matrix = spice.pxform(from_frame, to_frame, et)
-    ... result = spice.mxv(rotation_matrix, position)
+    `spiceypy.mxv`.
+    >>> rotation_matrix = spiceypy.pxform(from_frame, to_frame, et)
+    ... result = spiceypy.mxv(rotation_matrix, position)
 
     Parameters
     ----------
@@ -339,6 +189,10 @@ def frame_transform(
     result : np.ndarray
         3d Cartesian position vector(s) in reference frame `to_frame`.
     """
+    # If from_frame and to_frame are the same, no rotation needed
+    if from_frame == to_frame:
+        return position
+
     if position.ndim == 1:
         if not len(position) == 3:
             raise ValueError(
@@ -372,6 +226,56 @@ def frame_transform(
     return result
 
 
+def frame_transform_az_el(
+    et: Union[float, npt.NDArray],
+    az_el: npt.NDArray,
+    from_frame: SpiceFrame,
+    to_frame: SpiceFrame,
+    degrees: bool = True,
+) -> npt.NDArray:
+    """
+    Transform azimuth and elevation coordinates between reference frames.
+
+    Parameters
+    ----------
+    et : float or np.ndarray
+        Ephemeris time(s) corresponding to position(s).
+    az_el :  np.ndarray
+        <azimuth, elevation> vector or array of vectors in reference frame `from_frame`.
+        There are several possible shapes for the input az_el and et:
+        1. A single az_el vector may be provided for multiple `et` query times
+        2. A single `et` may be provided for multiple az_el vectors,
+        3. The same number of `et` and az_el vectors may be provided.
+        It is not allowed to have n az_el vectors and m `et`, where n != m.
+    from_frame : SpiceFrame
+        Reference frame of input coordinates.
+    to_frame : SpiceFrame
+        Reference frame of output coordinates.
+    degrees : bool
+        If True, azimuth and elevation input and output will be in degrees.
+
+    Returns
+    -------
+    to_frame_az_el : np.ndarray
+        Azimuth/elevation coordinates in reference frame `to_frame`. This
+        output coordinate vector will have shape (2,) if a single `az_el` position
+        vector and single `et` time are input. Otherwise, it will have shape (n, 2)
+        where n is the number of input position vector or ephemeris times. The last
+        axis of the output vector contains azimuth in the 0th position and elevation
+        in the 1st position.
+    """
+    # Convert input az/el to Cartesian vectors
+    spherical_coords_in = np.array(
+        [np.ones_like(az_el[..., 0]), az_el[..., 0], az_el[..., 1]]
+    ).T
+    from_frame_cartesian = spherical_to_cartesian(spherical_coords_in, degrees=degrees)
+    # Transform to to_frame
+    to_frame_cartesian = frame_transform(et, from_frame_cartesian, from_frame, to_frame)
+    # Convert to spherical and extract azimuth/elevation
+    to_frame_az_el = cartesian_to_spherical(to_frame_cartesian, degrees=degrees)
+    return to_frame_az_el[..., 1:3]
+
+
 @typing.no_type_check
 @ensure_spice
 def get_rotation_matrix(
@@ -404,7 +308,7 @@ def get_rotation_matrix(
         where `n` matches the number of elements in et.
     """
     vec_pxform = np.vectorize(
-        spice.pxform,
+        spiceypy.pxform,
         excluded=["fromstr", "tostr"],
         signature="(),(),()->(3,3)",
         otypes=[np.float64],
@@ -446,8 +350,8 @@ def instrument_pointing(
     if cartesian:
         return pointing
     if isinstance(et, typing.Collection):
-        return np.rad2deg([spice.reclat(vec)[1:] for vec in pointing])
-    return np.rad2deg(spice.reclat(pointing)[1:])
+        return np.rad2deg([spiceypy.reclat(vec)[1:] for vec in pointing])
+    return np.rad2deg(spiceypy.reclat(pointing)[1:])
 
 
 def basis_vectors(
@@ -483,8 +387,8 @@ def basis_vectors(
     Examples
     --------
     >>> from imap_processing.spice.geometry import basis_vectors
-    ... from imap_processing.spice.time import j2000ns_to_j2000s
-    ... et = j2000ns_to_j2000s(dataset.epoch.values)
+    ... from imap_processing.spice.time import ttj2000ns_to_et
+    ... et = ttj2000ns_to_et(dataset.epoch.values)
     ... basis_vectors = basis_vectors(
     ...     et, SpiceFrame.IMAP_SPACECRAFT, SpiceFrame.ECLIPJ2000
     ... )
@@ -524,7 +428,7 @@ def cartesian_to_spherical(
           output range=[0, 360],
           otherwise in radians if degrees parameter is False:
           output range=[0, 2*pi].
-        - elevation : angle from the z-axis
+        - elevation : angle from the xy-plane
           In degrees if degrees parameter is True (by default):
           output range=[0, 180],
           otherwise in radians if degrees parameter is False:
@@ -535,7 +439,7 @@ def cartesian_to_spherical(
 
     vhat = v / magnitude_v
 
-    # Elevation angle (angle from the z-axis, range: [-pi/2, pi/2])
+    # Elevation angle (angle from the xy-plane, range: [-pi/2, pi/2])
     el = np.arcsin(vhat[..., 2])
 
     # Azimuth angle (angle in the xy-plane, range: [0, 2*pi])
@@ -553,7 +457,7 @@ def cartesian_to_spherical(
     return spherical_coords
 
 
-def spherical_to_cartesian(spherical_coords: NDArray) -> NDArray:
+def spherical_to_cartesian(spherical_coords: NDArray, degrees: bool = False) -> NDArray:
     """
     Convert spherical coordinates to Cartesian coordinates.
 
@@ -565,7 +469,10 @@ def spherical_to_cartesian(spherical_coords: NDArray) -> NDArray:
 
         - r : Distance of the point from the origin.
         - azimuth : angle in the xy-plane in radians [0, 2*pi].
-        - elevation : angle from the z-axis in radians [-pi/2, pi/2].
+        - elevation : angle from the xy-plane in radians [-pi/2, pi/2].
+    degrees : bool
+        Set to True if input azimuth and elevation angles are in degrees.
+        Defaults to False.
 
     Returns
     -------
@@ -576,6 +483,10 @@ def spherical_to_cartesian(spherical_coords: NDArray) -> NDArray:
     azimuth = spherical_coords[..., 1]
     elevation = spherical_coords[..., 2]
 
+    if degrees:
+        azimuth = np.radians(azimuth)
+        elevation = np.radians(elevation)
+
     x = r * np.cos(elevation) * np.cos(azimuth)
     y = r * np.cos(elevation) * np.sin(azimuth)
     z = r * np.sin(elevation)
@@ -583,3 +494,64 @@ def spherical_to_cartesian(spherical_coords: NDArray) -> NDArray:
     cartesian_coords = np.stack((x, y, z), axis=-1)
 
     return cartesian_coords
+
+
+def cartesian_to_latitudinal(coords: NDArray, degrees: bool = False) -> NDArray:
+    """
+    Convert cartesian coordinates to latitudinal coordinates in radians.
+
+    This is a vectorized wrapper around `spiceypy.reclat`
+    "Convert from rectangular coordinates to latitudinal coordinates."
+    https://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/reclat_c.html
+
+    Parameters
+    ----------
+    coords : np.ndarray
+        Either shape (n, 3) or (3) where the last dimension represents a vector
+        with x, y, z-components.
+    degrees : bool
+        If True, the longitude and latitude coords are returned in degrees.
+        Defaults to False.
+
+    Returns
+    -------
+    np.ndarray
+        A NumPy array with shape (n, 3) or (3), where the last dimension contains
+        the latitudinal coordinates (radius, longitude, latitude).
+    """
+    # If coords is 1d, add another dimension
+    while coords.ndim < 2:
+        coords = np.expand_dims(coords, axis=0)
+    latitudinal_coords = np.array([spiceypy.reclat(vec) for vec in coords])
+
+    if degrees:
+        latitudinal_coords[..., 1:] = np.degrees(latitudinal_coords[..., 1:])
+    # Return array of latitudinal and remove the first dimension if it is 1.
+    return np.squeeze(latitudinal_coords)
+
+
+def solar_longitude(
+    et: Union[np.ndarray, float],
+    degrees: bool = False,
+) -> Union[float, npt.NDArray]:
+    """
+    Compute the solar longitude of the Imap Spacecraft.
+
+    Parameters
+    ----------
+    et : float or np.ndarray
+        Ephemeris time(s) to at which to compute solar longitude.
+    degrees : bool
+        If True, the longitude is returned in degrees.
+        Defaults to False.
+
+    Returns
+    -------
+    float or np.ndarray
+        The solar longitude at the specified times.
+    """
+    # Get position of IMAP in ecliptic frame
+    imap_pos = imap_state(et, observer=SpiceBody.SUN)[..., 0:3]
+    lat_coords = cartesian_to_latitudinal(imap_pos, degrees=degrees)[..., 1]
+
+    return float(lat_coords) if lat_coords.size == 1 else lat_coords

imap_processing/spice/kernels.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import Any, Callable, Optional, Union, overload
 
 import numpy as np
-import spiceypy as spice
+import spiceypy
 from numpy.typing import NDArray
 from spiceypy.utils.exceptions import SpiceyError
 
@@ -145,7 +145,7 @@ def ensure_spice(
                     # Step 2.
                     if os.getenv("SPICE_METAKERNEL"):
                         metakernel_path = os.getenv("SPICE_METAKERNEL")
-                        spice.furnsh(metakernel_path)
+                        spiceypy.furnsh(metakernel_path)
                     else:
                         furnish_time_kernel()
                 except KeyError:
@@ -200,13 +200,13 @@ def open_spice_ck_file(pointing_frame_path: Path) -> Generator[int, None, None]:
     # and how that will affect appending to the pointing
     # frame kernel.
     if pointing_frame_path.exists():
-        handle = spice.dafopw(str(pointing_frame_path))
+        handle = spiceypy.dafopw(str(pointing_frame_path))
     else:
-        handle = spice.ckopn(str(pointing_frame_path), "CK", 0)
+        handle = spiceypy.ckopn(str(pointing_frame_path), "CK", 0)
     try:
         yield handle
     finally:
-        spice.ckcls(handle)
+        spiceypy.ckcls(handle)
 
 
 @ensure_spice
@@ -245,12 +245,12 @@ def create_pointing_frame(pointing_frame_path: Path, ck_path: Path) -> None:
     """
     # Get IDs.
     # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.gipool
-    id_imap_dps = spice.gipool("FRAME_IMAP_DPS", 0, 1)
-    id_imap_sclk = spice.gipool("CK_-43000_SCLK", 0, 1)
+    id_imap_dps = spiceypy.gipool("FRAME_IMAP_DPS", 0, 1)
+    id_imap_sclk = spiceypy.gipool("CK_-43000_SCLK", 0, 1)
 
     # Verify that only ck_path kernel is loaded.
-    count = spice.ktotal("ck")
-    loaded_ck_kernel, _, _, _ = spice.kdata(count - 1, "ck")
+    count = spiceypy.ktotal("ck")
+    loaded_ck_kernel, _, _, _ = spiceypy.kdata(count - 1, "ck")
 
     if count != 1 or str(ck_path) != loaded_ck_kernel:
         raise ValueError(f"Error: Expected CK kernel {ck_path}")
@@ -258,28 +258,28 @@ def create_pointing_frame(pointing_frame_path: Path, ck_path: Path) -> None:
     # If the pointing frame kernel already exists, find the last time.
     if pointing_frame_path.exists():
         # Get the last time in the pointing frame kernel.
-        pointing_cover = spice.ckcov(
+        pointing_cover = spiceypy.ckcov(
             str(pointing_frame_path), int(id_imap_dps), True, "SEGMENT", 0, "TDB"
         )
-        num_segments = spice.wncard(pointing_cover)
-        _, et_end_pointing_frame = spice.wnfetd(pointing_cover, num_segments - 1)
+        num_segments = spiceypy.wncard(pointing_cover)
+        _, et_end_pointing_frame = spiceypy.wnfetd(pointing_cover, num_segments - 1)
     else:
         et_end_pointing_frame = None
 
     # TODO: Query for .csv file to get the pointing start and end times.
     # TODO: Remove next four lines once query is added.
-    id_imap_spacecraft = spice.gipool("FRAME_IMAP_SPACECRAFT", 0, 1)
-    ck_cover = spice.ckcov(
+    id_imap_spacecraft = spiceypy.gipool("FRAME_IMAP_SPACECRAFT", 0, 1)
+    ck_cover = spiceypy.ckcov(
         str(ck_path), int(id_imap_spacecraft), True, "INTERVAL", 0, "TDB"
     )
-    num_intervals = spice.wncard(ck_cover)
+    num_intervals = spiceypy.wncard(ck_cover)
 
     with open_spice_ck_file(pointing_frame_path) as handle:
         # TODO: this will change to the number of pointings.
         for i in range(num_intervals):
             # Get the coverage window
             # TODO: this will change to pointing start and end time.
-            et_start, et_end = spice.wnfetd(ck_cover, i)
+            et_start, et_end = spiceypy.wnfetd(ck_cover, i)
             et_times = _get_et_times(et_start, et_end)
 
             # TODO: remove after query is added.
@@ -294,16 +294,16 @@ def create_pointing_frame(pointing_frame_path: Path, ck_path: Path) -> None:
 
             # Convert the rotation matrix to a quaternion.
             # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.m2q
-            q_avg = spice.m2q(rotation_matrix)
+            q_avg = spiceypy.m2q(rotation_matrix)
 
             # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.sce2c
             # Convert start and end times to SCLK.
-            sclk_begtim = spice.sce2c(int(id_imap_sclk), et_times[0])
-            sclk_endtim = spice.sce2c(int(id_imap_sclk), et_times[-1])
+            sclk_begtim = spiceypy.sce2c(int(id_imap_sclk), et_times[0])
+            sclk_endtim = spiceypy.sce2c(int(id_imap_sclk), et_times[-1])
 
             # Create the pointing frame kernel.
             # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.ckw02
-            spice.ckw02(
+            spiceypy.ckw02(
                 # Handle of an open CK file.
                 handle,
                 # Start time of the segment.
@@ -355,7 +355,7 @@ def _get_et_times(et_start: float, et_end: float) -> NDArray[np.float64]:
 
     # 1 spin/15 seconds; 10 quaternions / spin.
     num_samples = (et_end - et_start) / 15 * 10
-    # There were rounding errors when using spice.pxform so np.ceil and np.floor
+    # There were rounding errors when using spiceypy.pxform so np.ceil and np.floor
     # were used to ensure the start and end times were included in the array.
     et_times = np.linspace(
         np.ceil(et_start * 1e6) / 1e6, np.floor(et_end * 1e6) / 1e6, int(num_samples)
@@ -390,10 +390,10 @@ def _average_quaternions(et_times: np.ndarray) -> NDArray:
 
         # Rotation matrix from IMAP spacecraft frame to ECLIPJ2000.
         # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.pxform
-        body_rots = spice.pxform("IMAP_SPACECRAFT", "ECLIPJ2000", tdb)
+        body_rots = spiceypy.pxform("IMAP_SPACECRAFT", "ECLIPJ2000", tdb)
         # Convert rotation matrix to quaternion.
         # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.m2q
-        body_quat = spice.m2q(body_rots)
+        body_quat = spiceypy.m2q(body_rots)
 
         # Standardize the quaternion so that they may be compared.
         body_quat = body_quat * np.sign(body_quat[0])
@@ -440,7 +440,7 @@ def _create_rotation_matrix(et_times: np.ndarray) -> NDArray:
     # Converts the averaged quaternion (q_avg) into a rotation matrix
     # and get inertial z axis.
     # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.q2m
-    z_avg = spice.q2m(list(q_avg))[:, 2]
+    z_avg = spiceypy.q2m(list(q_avg))[:, 2]
     # y_avg is perpendicular to both z_avg and the standard Z-axis.
     y_avg = np.cross(z_avg, [0, 0, 1])
     # x_avg is perpendicular to y_avg and z_avg.
@@ -459,5 +459,5 @@ def furnish_time_kernel() -> None:
     # TODO: we need to load these kernels from EFS volumen that is
     # mounted to batch volume and extend this to generate metakernell
     # which is TBD.
-    spice.furnsh(str(spice_test_data_path / "imap_sclk_0000.tsc"))
-    spice.furnsh(str(spice_test_data_path / "naif0012.tls"))
+    spiceypy.furnsh(str(spice_test_data_path / "imap_sclk_0000.tsc"))
+    spiceypy.furnsh(str(spice_test_data_path / "naif0012.tls"))