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

imap_processing/mag/l0/decom_mag.py

@@ -129,7 +129,9 @@ def generate_dataset(
         direction.astype(str),
         name="direction_label",
         dims=["direction_label"],
-        attrs=attribute_manager.get_variable_attributes("direction_label"),
+        attrs=attribute_manager.get_variable_attributes(
+            "direction_label", check_schema=False
+        ),
     )
 
     # TODO: Epoch here refers to the start of the sample. Confirm that this is
@@ -154,11 +156,10 @@ def generate_dataset(
         coords={
             "epoch": epoch_time,
             "direction": direction,
-            "direction_label": direction_label,
         },
         attrs=attribute_manager.get_global_attributes(logical_id),
     )
-
+    output["direction_label"] = direction_label
     output["raw_vectors"] = raw_vectors
 
     for key, value in support_data.items():

imap_processing/mag/l1a/mag_l1a.py

@@ -8,7 +8,6 @@ import numpy as np
 import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
-from imap_processing.cdf.utils import J2000_EPOCH
 from imap_processing.mag.constants import DataMode, PrimarySensor
 from imap_processing.mag.l0 import decom_mag
 from imap_processing.mag.l0.mag_l0_data import MagL0
@@ -17,7 +16,7 @@ from imap_processing.mag.l1a.mag_l1a_data import (
     MagL1aPacketProperties,
     TimeTuple,
 )
-from imap_processing.spice.time import met_to_j2000ns
+from imap_processing.spice.time import J2000_EPOCH, met_to_j2000ns
 
 logger = logging.getLogger(__name__)
 
@@ -158,7 +157,6 @@ def process_packets(
                 "timedelta64[ns]"
             )
         ).astype("datetime64[D]")
-
         primary_packet_properties = MagL1aPacketProperties(
             mag_l0.SHCOARSE,
             primary_start_time,
@@ -284,9 +282,7 @@ def generate_dataset(
 
     # TODO: Just leave time in datetime64 type with vector as dtype object to avoid this
     # Get the timestamp from the end of the vector
-    time_data = single_file_l1a.vectors[:, 4].astype(
-        np.dtype("datetime64[ns]"), copy=False
-    )
+    time_data = single_file_l1a.vectors[:, 4]
 
     compression = xr.DataArray(
         np.arange(2),
@@ -326,17 +322,21 @@ def generate_dataset(
     )
 
     direction_label = xr.DataArray(
-        direction.astype(str),
+        direction.values.astype(str),
         name="direction_label",
         dims=["direction_label"],
-        attrs=attribute_manager.get_variable_attributes("direction_label"),
+        attrs=attribute_manager.get_variable_attributes(
+            "direction_label", check_schema=False
+        ),
     )
 
     compression_label = xr.DataArray(
-        compression.astype(str),
+        compression.values.astype(str),
         name="compression_label",
         dims=["compression_label"],
-        attrs=attribute_manager.get_variable_attributes("compression_label"),
+        attrs=attribute_manager.get_variable_attributes(
+            "compression_label", check_schema=False
+        ),
     )
 
     output = xr.Dataset(
@@ -344,12 +344,11 @@ def generate_dataset(
             "epoch": epoch_time,
             "direction": direction,
             "compression": compression,
-            "direction_label": direction_label,
-            "compression_label": compression_label,
         },
         attrs=attribute_manager.get_global_attributes(logical_file_id),
     )
-
+    output["direction_label"] = direction_label
+    output["compression_label"] = compression_label
     output["vectors"] = vectors
     output["compression_flags"] = compression_flags
 

imap_processing/mag/l1a/mag_l1a_data.py

@@ -9,7 +9,6 @@ from math import floor
 import numpy as np
 import numpy.typing as npt
 
-from imap_processing.cdf.utils import J2000_EPOCH
 from imap_processing.mag.constants import (
     AXIS_COUNT,
     FIBONACCI_SEQUENCE,
@@ -17,7 +16,7 @@ from imap_processing.mag.constants import (
     MAX_FINE_TIME,
     RANGE_BIT_WIDTH,
 )
-from imap_processing.spice.time import met_to_j2000ns
+from imap_processing.spice.time import J2000_EPOCH, met_to_j2000ns
 
 
 @dataclass

imap_processing/mag/l1b/mag_l1b.py

@@ -64,9 +64,11 @@ def mag_l1b_processing(input_dataset: xr.Dataset) -> xr.Dataset:
     """
     # TODO: There is a time alignment step that will add a lot of complexity.
     # This needs to be done once we have some SPICE time data.
+    mag_attributes = ImapCdfAttributes()
+    mag_attributes.add_instrument_variable_attrs("mag", "l1")
 
-    dims = [["direction"]]
-    new_dims = [["direction"]]
+    dims = [["direction"], ["compression"]]
+    new_dims = [["direction"], ["compression"]]
     # TODO: This should definitely be loaded from AWS
     calibration_dataset = load_cdf(
         Path(__file__).parent / "imap_calibration_mag_20240229_v01.cdf"
@@ -78,8 +80,9 @@ def mag_l1b_processing(input_dataset: xr.Dataset) -> xr.Dataset:
         calibration_matrix = calibration_dataset["MFITOURFI"]
 
     l1b_fields = xr.apply_ufunc(
-        calibrate,
+        update_vector,
         input_dataset["vectors"],
+        input_dataset["compression_flags"],
         input_core_dims=dims,
         output_core_dims=new_dims,
         vectorize=True,
@@ -88,13 +91,93 @@ def mag_l1b_processing(input_dataset: xr.Dataset) -> xr.Dataset:
     )
 
     output_dataset = input_dataset.copy()
-    output_dataset["vectors"] = l1b_fields
+    output_dataset["vectors"].data = l1b_fields[0].data
+
+    output_dataset["epoch"].attrs = mag_attributes.get_variable_attributes("epoch")
+    output_dataset["direction"].attrs = mag_attributes.get_variable_attributes(
+        "direction_attrs"
+    )
+    output_dataset["compression"].attrs = mag_attributes.get_variable_attributes(
+        "compression_attrs"
+    )
+    output_dataset["direction_label"].attrs = mag_attributes.get_variable_attributes(
+        "direction_label", check_schema=False
+    )
+    output_dataset["compression_label"].attrs = mag_attributes.get_variable_attributes(
+        "compression_label", check_schema=False
+    )
 
-    # TODO add/update attributes
     return output_dataset
 
 
-def calibrate(
+def update_vector(
+    input_vector: np.ndarray,
+    input_compression: np.ndarray,
+    calibration_matrix: xr.DataArray,
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Apply calibration and compression scaling to vector.
+
+    This calls, in sequence, calibrate_vector and rescale_vector to apply L1B processing
+    to the input vector.
+
+    Parameters
+    ----------
+    input_vector : numpy.ndarray
+        One input vector to update, looking like (x, y, z, range).
+    input_compression : numpy.ndarray
+        Compression flags corresponding to the vector, looking like (is_compressed,
+        compression_width).
+    calibration_matrix : xr.DataArray
+        DataArray containing the full set of calibration matrices, for each range.
+        Size is ((3, 3, 4)).
+
+    Returns
+    -------
+    tuple[numpy.ndarray, numpy.ndarray]
+        Updated vector and the same compression flags.
+    """
+    vector = calibrate_vector(input_vector, calibration_matrix)
+    return rescale_vector(vector, input_compression), input_compression
+
+
+def rescale_vector(
+    input_vector: np.ndarray, compression_flags: np.ndarray
+) -> np.ndarray:
+    """
+    Rescale vector based on compression flags.
+
+    If the first value of compression_flags is zero, this just returns the input_vector
+    unchanged. Otherwise, the vector is scaled using the compression width, which is
+    the second part of compression_flags.
+
+    The vector is scaled using the following equation:
+    M = 2 ^ (16-width)
+    output_vector = input_vector * M
+
+    Therefore, for a 16 bit width, the same vector is returned.
+
+    Parameters
+    ----------
+    input_vector : numpy.ndarray
+        One input vector to update, looking like (x, y, z, range).
+    compression_flags : numpy.ndarray
+        Compression flags corresponding to the vector, looking like (is_compressed,
+        compression_width).
+
+    Returns
+    -------
+    output_vector : numpy.ndarray
+        Updated vector.
+    """
+    if not compression_flags[0]:
+        return input_vector
+    else:
+        factor = np.float_power(2, (16 - compression_flags[1]))
+        return input_vector * factor  # type: ignore
+
+
+def calibrate_vector(
     input_vector: np.ndarray, calibration_matrix: xr.DataArray = None
 ) -> np.ndarray:
     """
@@ -119,7 +202,7 @@ def calibrate(
     updated_vector = input_vector.copy()
 
     updated_vector[:3] = np.matmul(
-        input_vector[:3], calibration_matrix.values[:, :, int(input_vector[3])]
+        calibration_matrix.values[:, :, int(input_vector[3])], input_vector[:3]
     )
 
     return updated_vector

imap_processing/spice/geometry.py

@@ -19,6 +19,7 @@ import numpy as np
 import numpy.typing as npt
 import pandas as pd
 import spiceypy as spice
+from numpy.typing import NDArray
 
 from imap_processing.spice.kernels import ensure_spice
 
@@ -63,8 +64,6 @@ class SpiceFrame(IntEnum):
     IMAP_GLOWS = -43750
 
 
-# TODO: Update boresight for in-situ instruments
-# TODO: Confirm ENA boresight vectors
 BORESIGHT_LOOKUP = {
     SpiceFrame.IMAP_LO: np.array([0, -1, 0]),
     SpiceFrame.IMAP_HI_45: np.array([0, 1, 0]),
@@ -72,12 +71,12 @@ BORESIGHT_LOOKUP = {
     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_SWE: np.array([0, 0, 1]),
-    SpiceFrame.IMAP_SWAPI: 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]),
-    SpiceFrame.IMAP_HIT: np.array([0, 0, 1]),
-    SpiceFrame.IMAP_IDEX: np.array([0, 0, 1]),
-    SpiceFrame.IMAP_GLOWS: np.array([0, 0, 1]),
+    SpiceFrame.IMAP_HIT: np.array([0, 1, 0]),
+    SpiceFrame.IMAP_IDEX: np.array([0, 1, 0]),
+    SpiceFrame.IMAP_GLOWS: np.array([0, 0, -1]),
 }
 
 
@@ -303,8 +302,6 @@ def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> fl
     return offset_lookup[instrument]
 
 
-@typing.no_type_check
-@ensure_spice
 def frame_transform(
     et: Union[float, npt.NDArray],
     position: npt.NDArray,
@@ -327,8 +324,11 @@ def frame_transform(
         Ephemeris time(s) corresponding to position(s).
     position : np.ndarray
         <x, y, z> vector or array of vectors in reference frame `from_frame`.
-        A single position vector may be provided for multiple `et` query times
-        but only a single position vector can be provided for a single `et`.
+        There are several possible shapes for the input position and et:
+        1. A single position vector may be provided for multiple `et` query times
+        2. A single `et` may be provided for multiple position vectors,
+        3. The same number of `et` and position vectors may be provided.
+        But it is not allowed to have n position vectors and m `et`, where n != m.
     from_frame : SpiceFrame
         Reference frame of input vector(s).
     to_frame : SpiceFrame
@@ -350,11 +350,14 @@ def frame_transform(
                 f"Invalid position shape: {position.shape}. "
                 f"Each input position vector must have 3 elements."
             )
-        if not len(position) == len(et):
-            raise ValueError(
-                "Mismatch in number of position vectors and Ephemeris times provided."
-                f"Position has {len(position)} elements and et has {len(et)} elements."
-            )
+        if not len(position) == np.asarray(et).size:
+            if np.asarray(et).size != 1:
+                raise ValueError(
+                    "Mismatch in number of position vectors and "
+                    "Ephemeris times provided."
+                    f"Position has {len(position)} elements and et has "
+                    f"{np.asarray(et).size} elements."
+                )
 
     # rotate will have shape = (3, 3) or (n, 3, 3)
     # position will have shape = (3,) or (n, 3)
@@ -369,6 +372,8 @@ def frame_transform(
     return result
 
 
+@typing.no_type_check
+@ensure_spice
 def get_rotation_matrix(
     et: Union[float, npt.NDArray],
     from_frame: SpiceFrame,
@@ -443,3 +448,138 @@ def instrument_pointing(
     if isinstance(et, typing.Collection):
         return np.rad2deg([spice.reclat(vec)[1:] for vec in pointing])
     return np.rad2deg(spice.reclat(pointing)[1:])
+
+
+def basis_vectors(
+    et: Union[float, npt.NDArray],
+    from_frame: SpiceFrame,
+    to_frame: SpiceFrame,
+) -> npt.NDArray:
+    """
+    Get the basis vectors of the `from_frame` expressed in the `to_frame`.
+
+    The rotation matrix defining a frame transform are the basis vectors of
+    the `from_frame` expressed in the `to_frame`. This function just transposes
+    each rotation matrix retrieved from the `get_rotation_matrix` function so
+    that basis vectors can be indexed 0 for x, 1 for y, and 2 for z.
+
+    Parameters
+    ----------
+    et : float or np.ndarray
+        Ephemeris time(s) for which to get the rotation matrices.
+    from_frame : SpiceFrame
+        Reference frame to transform from.
+    to_frame : SpiceFrame
+        Reference frame to transform to.
+
+    Returns
+    -------
+    basis_vectors : np.ndarray
+        If `et` is a float, the returned basis vector matrix is of shape `(3, 3)`. If
+        `et` is a np.ndarray, the returned basis vector matrix is of shape `(n, 3, 3)`
+        where `n` matches the number of elements in et and basis vectors are the rows
+        of the 3 by 3 matrices.
+
+    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)
+    ... basis_vectors = basis_vectors(
+    ...     et, SpiceFrame.IMAP_SPACECRAFT, SpiceFrame.ECLIPJ2000
+    ... )
+    ... spacecraft_x = basis_vectors[:, 0]
+    ... spacecraft_y = basis_vectors[:, 1]
+    ... spacecraft_z = basis_vectors[:, 2]
+    """
+    return np.moveaxis(get_rotation_matrix(et, from_frame, to_frame), -1, -2)
+
+
+def cartesian_to_spherical(
+    v: NDArray,
+    degrees: bool = True,
+) -> NDArray:
+    """
+    Convert cartesian coordinates to spherical coordinates.
+
+    Parameters
+    ----------
+    v : np.ndarray
+        A NumPy array with shape (n, 3) where each
+        row represents a vector
+        with x, y, z-components.
+    degrees : bool
+        If True, the azimuth and elevation angles are returned in degrees.
+        Defaults to True.
+
+    Returns
+    -------
+    spherical_coords : np.ndarray
+        A NumPy array with shape (n, 3), where each row contains
+        the spherical coordinates (r, azimuth, elevation):
+
+        - r : Distance of the point from the origin.
+        - azimuth : angle in the xy-plane
+          In degrees if degrees parameter is True (by default):
+          output range=[0, 360],
+          otherwise in radians if degrees parameter is False:
+          output range=[0, 2*pi].
+        - elevation : angle from the z-axis
+          In degrees if degrees parameter is True (by default):
+          output range=[0, 180],
+          otherwise in radians if degrees parameter is False:
+          output range=[-pi/2, pi/2].
+    """
+    # Magnitude of the velocity vector
+    magnitude_v = np.linalg.norm(v, axis=-1, keepdims=True)
+
+    vhat = v / magnitude_v
+
+    # Elevation angle (angle from the z-axis, range: [-pi/2, pi/2])
+    el = np.arcsin(vhat[..., 2])
+
+    # Azimuth angle (angle in the xy-plane, range: [0, 2*pi])
+    az = np.arctan2(vhat[..., 1], vhat[..., 0])
+
+    # Ensure azimuth is from 0 to 2PI
+    az = az % (2 * np.pi)
+
+    if degrees:
+        az = np.degrees(az)
+        el = np.degrees(el)
+
+    spherical_coords = np.stack((np.squeeze(magnitude_v), az, el), axis=-1)
+
+    return spherical_coords
+
+
+def spherical_to_cartesian(spherical_coords: NDArray) -> NDArray:
+    """
+    Convert spherical coordinates to Cartesian coordinates.
+
+    Parameters
+    ----------
+    spherical_coords : np.ndarray
+        A NumPy array with shape (n, 3), where each row contains
+        the spherical coordinates (r, azimuth, elevation):
+
+        - 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].
+
+    Returns
+    -------
+    cartesian_coords : np.ndarray
+        Cartesian coordinates.
+    """
+    r = spherical_coords[..., 0]
+    azimuth = spherical_coords[..., 1]
+    elevation = spherical_coords[..., 2]
+
+    x = r * np.cos(elevation) * np.cos(azimuth)
+    y = r * np.cos(elevation) * np.sin(azimuth)
+    z = r * np.sin(elevation)
+
+    cartesian_coords = np.stack((x, y, z), axis=-1)
+
+    return cartesian_coords

imap_processing/spice/time.py

@@ -1,7 +1,7 @@
 """Time conversion functions that rely on SPICE."""
 
 import typing
-from collections.abc import Collection
+from collections.abc import Collection, Iterable
 from typing import Union
 
 import numpy as np
@@ -13,6 +13,32 @@ from imap_processing.spice.kernels import ensure_spice
 
 TICK_DURATION = 2e-5  # 20 microseconds as defined in imap_sclk_0000.tsc
 
+# Hard code the J2000 epoch. This allows for CDF epoch to be converted without
+# use of SPICE though it should be noted that this results in a 5-second error
+# due to the occurrence of 5 leap-seconds since the J2000 epoch.
+# TODO: Implement a function for converting CDF epoch to UTC correctly.
+#     see github ticket #1208
+# The UTC string was generated by:
+# >>> spiceypy.et2utc(0, "ISOC", 9)
+J2000_EPOCH = np.datetime64("2000-01-01T11:58:55.816072737", "ns")
+
+
+def met_to_sclkticks(met: npt.ArrayLike) -> npt.NDArray[float]:
+    """
+    Convert Mission Elapsed Time (MET) to floating point spacecraft clock ticks.
+
+    Parameters
+    ----------
+    met : float, numpy.ndarray
+        Number of seconds since epoch according to the spacecraft clock.
+
+    Returns
+    -------
+    numpy.ndarray[float]
+        The mission elapsed time converted to nanoseconds since the J2000 epoch.
+    """
+    return np.asarray(met, dtype=float) / TICK_DURATION
+
 
 def met_to_j2000ns(
     met: npt.ArrayLike,
@@ -40,7 +66,7 @@ def met_to_j2000ns(
     "tick" which is defined to be 20 microseconds, according to the sclk kernel,
     it is preferable to use the higher accuracy method.
     """
-    sclk_ticks = np.asarray(met, dtype=float) / TICK_DURATION
+    sclk_ticks = met_to_sclkticks(met)
     return np.asarray(_sct2e_wrapper(sclk_ticks) * 1e9, dtype=np.int64)
 
 
@@ -64,6 +90,53 @@ def j2000ns_to_j2000s(j2000ns: npt.ArrayLike) -> npt.NDArray[float]:
     return np.asarray(j2000ns, dtype=np.float64) / 1e9
 
 
+@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.
+
+    Parameters
+    ----------
+    met : float, numpy.ndarray
+        Number of seconds since epoch according to the spacecraft clock.
+    precision : int
+        The number of digits of precision to which fractional seconds
+        are to be computed.
+
+    Returns
+    -------
+    numpy.ndarray[str]
+        The mission elapsed time converted to UTC string. The UTC string(s)
+        returned will be of the form '1987-04-12T16:31:12.814' with the
+        fractional seconds precision as specified by the precision keyword.
+    """
+    sclk_ticks = met_to_sclkticks(met)
+    et = _sct2e_wrapper(sclk_ticks)
+    return spice.et2utc(et, "ISOC", prec=precision)
+
+
+def met_to_datetime64(
+    met: npt.ArrayLike,
+) -> Union[np.datetime64, npt.NDArray[np.datetime64]]:
+    """
+    Convert mission elapsed time (MET) to datetime.datetime.
+
+    Parameters
+    ----------
+    met : float, numpy.ndarray
+        Number of seconds since epoch according to the spacecraft clock.
+
+    Returns
+    -------
+    numpy.ndarray[str]
+        The mission elapsed time converted to UTC string.
+    """
+    if isinstance(met, typing.Iterable):
+        return np.asarray([np.datetime64(utc) for utc in met_to_utc(met)])
+    return np.datetime64(met_to_utc(met))
+
+
 @typing.no_type_check
 @ensure_spice
 def _sct2e_wrapper(
@@ -90,3 +163,72 @@ def _sct2e_wrapper(
         return np.array([spice.sct2e(IMAP_SC_ID, s) for s in sclk_ticks])
     else:
         return spice.sct2e(IMAP_SC_ID, sclk_ticks)
+
+
+@typing.no_type_check
+@ensure_spice
+def str_to_et(
+    time_str: Union[str, Iterable[str]],
+) -> Union[float, np.ndarray]:
+    """
+    Convert string to ephemeris time.
+
+    Decorated wrapper for spiceypy.str2et that vectorizes the function in addition
+    to wrapping with the @ensure_spice automatic kernel furnishing functionality.
+    https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.str2et
+
+    Parameters
+    ----------
+    time_str : str or Iterable[str]
+        Input string(s) to be converted to ephemeris time.
+
+    Returns
+    -------
+    ephemeris_time: np.ndarray
+        Ephemeris time, seconds past J2000.
+    """
+    if isinstance(time_str, str):
+        return spice.str2et(time_str)
+    else:
+        return np.array([spice.str2et(t) for t in time_str])
+
+
+@typing.no_type_check
+@ensure_spice
+def et_to_utc(
+    et: Union[float, Iterable[float]],
+    format_str: str = "ISOC",
+    precision: int = 3,
+    utclen: int = 24,
+) -> Union[str, np.ndarray]:
+    """
+    Convert ephemeris time to UTC.
+
+    Decorated wrapper for spiceypy.et2utc that vectorizes the function in addition
+    to wrapping with the @ensure_spice automatic kernel furnishing functionality.
+    https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.et2utc
+
+    Parameters
+    ----------
+    et : float or Iterable[float]
+        Input ephemeris time(s) to be converted to UTC.
+    format_str : str
+        Format of the output time string. Default is "ISOC". All options:
+        "C" Calendar format, UTC.
+        "D" Day-of-Year format, UTC.
+        "J" Julian Date format, UTC.
+        "ISOC" ISO Calendar format, UTC.
+        "ISOD" ISO Day-of-Year format, UTC.
+    precision : int
+        Digits of precision in fractional seconds or days. Default is 3.
+    utclen : int
+        The length of the output string. Default is 24 (to accommodate the
+        "YYYY-MM-DDT00:00:00.000" format + 1). From the NAIF docs: if the output string
+        is expected to have `x` characters, utclen` must be x + 1.
+
+    Returns
+    -------
+    utc_time : str or np.ndarray
+        UTC time(s).
+    """
+    return spice.et2utc(et, format_str, precision, utclen)

imap_processing/swapi/l1/swapi_l1.py

@@ -39,7 +39,7 @@ def filter_good_data(full_sweep_sci: xr.Dataset) -> npt.NDArray:
     """
     # PLAN_ID for current sweep should all be one value and
     # SWEEP_TABLE should all be one value.
-    plan_id = full_sweep_sci["plan_id_science"].data.reshape(-1, 12)
+    plan_id = full_sweep_sci["plan_id"].data.reshape(-1, 12)
     sweep_table = full_sweep_sci["sweep_table"].data.reshape(-1, 12)
 
     mode = full_sweep_sci["mode"].data.reshape(-1, 12)
@@ -72,7 +72,7 @@ def filter_good_data(full_sweep_sci: xr.Dataset) -> npt.NDArray:
     )
     logger.debug(
         "Plan ID should be same: "
-        f"{full_sweep_sci['plan_id_science'].data[bad_cycle_indices]}"
+        f"{full_sweep_sci['plan_id'].data[bad_cycle_indices]}"
     )
     logger.debug(
         f"Mode Id should be 3(HVSCI): {full_sweep_sci['mode'].data[bad_cycle_indices]}"
@@ -480,7 +480,7 @@ def process_swapi_science(
     # ====================================================
     cdf_manager = ImapCdfAttributes()
     cdf_manager.add_instrument_global_attrs("swapi")
-    cdf_manager.load_variable_attributes("imap_swapi_variable_attrs.yaml")
+    cdf_manager.add_instrument_variable_attrs(instrument="swapi", level=None)
 
     # ===================================================================
     # Quality flags
@@ -615,7 +615,7 @@ def process_swapi_science(
         attrs=cdf_manager.get_variable_attributes("sweep_table"),
     )
     dataset["plan_id"] = xr.DataArray(
-        good_sweep_sci["plan_id_science"].data.reshape(total_full_sweeps, 12)[:, 0],
+        good_sweep_sci["plan_id"].data.reshape(total_full_sweeps, 12)[:, 0],
         name="plan_id",
         dims=["epoch"],
         attrs=cdf_manager.get_variable_attributes("plan_id"),

imap_processing/swapi/l2/swapi_l2.py

@@ -43,7 +43,7 @@ def swapi_l2(l1_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
     # Load the CDF attributes
     cdf_manager = ImapCdfAttributes()
     cdf_manager.add_instrument_global_attrs("swapi")
-    cdf_manager.load_variable_attributes("imap_swapi_variable_attrs.yaml")
+    cdf_manager.add_instrument_variable_attrs(instrument="swapi", level=None)
 
     # Copy over only certain variables from L1 to L2 dataset
     l1_data_keys = [