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

imap_processing/spice/pointing_frame.py

@@ -0,0 +1,257 @@
+"""Functions for retrieving repointing table data."""
+
+import logging
+import typing
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+
+import numpy as np
+import spiceypy
+from numpy.typing import NDArray
+
+from imap_processing.spice.kernels import ensure_spice
+from imap_processing.spice.time import met_to_sclkticks, sct_to_et
+
+logger = logging.getLogger(__name__)
+
+
+@contextmanager
+def open_spice_ck_file(pointing_frame_path: Path) -> Generator[int, None, None]:
+    """
+    Context manager for handling SPICE CK files.
+
+    Parameters
+    ----------
+    pointing_frame_path : str
+        Path to the CK file.
+
+    Yields
+    ------
+    handle : int
+        Handle to the opened CK file.
+    """
+    if pointing_frame_path.exists():
+        handle = spiceypy.dafopw(str(pointing_frame_path))
+    else:
+        handle = spiceypy.ckopn(str(pointing_frame_path), "CK", 0)
+    try:
+        yield handle
+    finally:
+        spiceypy.ckcls(handle)
+
+
+@typing.no_type_check
+@ensure_spice
+def create_pointing_frame(
+    pointing_frame_path: Path,
+    ck_path: Path,
+    repoint_start_met: NDArray,
+    repoint_end_met: NDArray,
+) -> None:
+    """
+    Create the pointing frame.
+
+    Parameters
+    ----------
+    pointing_frame_path : pathlib.Path
+        Location of pointing frame kernel.
+    ck_path : pathlib.Path
+        Location of the CK kernel.
+    repoint_start_met : numpy.ndarray
+        Start time of the repointing in MET.
+    repoint_end_met : numpy.ndarray
+        End time of the repointing in MET.
+
+    Notes
+    -----
+    Kernels required to be furnished:
+    "imap_science_0001.tf",
+    "imap_sclk_0000.tsc",
+    "imap_sim_ck_2hr_2secsampling_with_nutation.bc" or
+    "sim_1yr_imap_attitude.bc",
+    "imap_wkcp.tf",
+    "naif0012.tls"
+
+    Assumptions:
+    - The MOC has removed timeframe in which nutation/procession are present.
+    TODO: We may come back and have a check for this.
+    - The pointing frame kernel is made based on the most recent ck kernel.
+    In other words 1:1 ratio.
+    """
+    # Get IDs.
+    # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.gipool
+    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 = 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}")
+
+    id_imap_spacecraft = spiceypy.gipool("FRAME_IMAP_SPACECRAFT", 0, 1)
+
+    # Select only the pointings within the attitude coverage.
+    ck_cover = spiceypy.ckcov(
+        str(ck_path), int(id_imap_spacecraft), True, "INTERVAL", 0, "TDB"
+    )
+    num_intervals = spiceypy.wncard(ck_cover)
+    et_start, _ = spiceypy.wnfetd(ck_cover, 0)
+    _, et_end = spiceypy.wnfetd(ck_cover, num_intervals - 1)
+
+    sclk_ticks_start = met_to_sclkticks(repoint_start_met)
+    et_start_repoint = sct_to_et(sclk_ticks_start)
+    sclk_ticks_end = met_to_sclkticks(repoint_end_met)
+    et_end_repoint = sct_to_et(sclk_ticks_end)
+
+    valid_mask = (et_start_repoint >= et_start) & (et_end_repoint <= et_end)
+    et_start_repoint = et_start_repoint[valid_mask]
+    et_end_repoint = et_end_repoint[valid_mask]
+
+    with open_spice_ck_file(pointing_frame_path) as handle:
+        for i in range(len(repoint_start_met)):
+            # 1 spin/15 seconds; 10 quaternions / spin.
+            num_samples = (et_end_repoint[i] - et_start_repoint[i]) / 15 * 10
+            # There were rounding errors when using spiceypy.pxform
+            # so np.ceil and np.floor were used to ensure the start
+            # and end times were within the ck range.
+            et_times = np.linspace(
+                np.ceil(et_start_repoint[i] * 1e6) / 1e6,
+                np.floor(et_end_repoint[i] * 1e6) / 1e6,
+                int(num_samples),
+            )
+
+            # Create a rotation matrix
+            rotation_matrix = _create_rotation_matrix(et_times)
+
+            # Convert the rotation matrix to a quaternion.
+            # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.m2q
+            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 = 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
+            spiceypy.ckw02(
+                # Handle of an open CK file.
+                handle,
+                # Start time of the segment.
+                sclk_begtim,
+                # End time of the segment.
+                sclk_endtim,
+                # Pointing frame ID.
+                int(id_imap_dps),
+                # Reference frame.
+                "ECLIPJ2000",  # Reference frame
+                # Identifier.
+                "IMAP_DPS",
+                # Number of pointing intervals.
+                1,
+                # Start times of individual pointing records within segment.
+                # Since there is only a single record this is equal to sclk_begtim.
+                np.array([sclk_begtim]),
+                # End times of individual pointing records within segment.
+                # Since there is only a single record this is equal to sclk_endtim.
+                np.array([sclk_endtim]),  # Single stop time
+                # Average quaternion.
+                q_avg,
+                # 0.0 Angular rotation terms.
+                np.array([0.0, 0.0, 0.0]),
+                # Rates (seconds per tick) at which the quaternion and
+                # angular velocity change.
+                np.array([1.0]),
+            )
+
+
+@typing.no_type_check
+@ensure_spice
+def _average_quaternions(et_times: np.ndarray) -> NDArray:
+    """
+    Average the quaternions.
+
+    Parameters
+    ----------
+    et_times : numpy.ndarray
+        Array of times between et_start and et_end.
+
+    Returns
+    -------
+    q_avg : np.ndarray
+        Average quaternion.
+    """
+    aggregate = np.zeros((4, 4))
+    for tdb in et_times:
+        # we use a quick and dirty method here for grabbing the quaternions
+        # from the attitude kernel.  Depending on how well the kernel input
+        # data is built and sampled, there may or may not be aliasing with this
+        # approach.  If it turns out that we need to pull the quaternions
+        # directly from the CK there are several routines that exist to do this
+        # but it's not straight forward.  We'll revisit this if needed.
+
+        # Rotation matrix from IMAP spacecraft frame to ECLIPJ2000.
+        # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.pxform
+        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 = spiceypy.m2q(body_rots)
+
+        # Standardize the quaternion so that they may be compared.
+        body_quat = body_quat * np.sign(body_quat[0])
+        # Aggregate quaternions into a single matrix.
+        aggregate += np.outer(body_quat, body_quat)
+
+    # Reference: "On Averaging Rotations".
+    # Link: https://link.springer.com/content/pdf/10.1023/A:1011129215388.pdf
+    aggregate /= len(et_times)
+
+    # Compute eigen values and vectors of the matrix A
+    # Eigenvalues tell you how much "influence" each
+    # direction (eigenvector) has.
+    # The largest eigenvalue corresponds to the direction
+    # that has the most influence.
+    # The eigenvector corresponding to the largest
+    # eigenvalue points in the direction that has the most
+    # combined rotation influence.
+    eigvals, eigvecs = np.linalg.eig(aggregate)
+    # q0: The scalar part of the quaternion.
+    # q1, q2, q3: The vector part of the quaternion.
+    q_avg = eigvecs[:, np.argmax(eigvals)]
+
+    return q_avg
+
+
+def _create_rotation_matrix(et_times: np.ndarray) -> NDArray:
+    """
+    Create a rotation matrix.
+
+    Parameters
+    ----------
+    et_times : numpy.ndarray
+        Array of times between et_start and et_end.
+
+    Returns
+    -------
+    rotation_matrix : np.ndarray
+        Rotation matrix.
+    """
+    # Averaged quaternions.
+    q_avg = _average_quaternions(et_times)
+
+    # 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 = 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.
+    x_avg = np.cross(y_avg, z_avg)
+
+    # Construct the rotation matrix from x_avg, y_avg, z_avg
+    rotation_matrix = np.asarray([x_avg, y_avg, z_avg])
+
+    return rotation_matrix

imap_processing/spice/repoint.py

@@ -0,0 +1,149 @@
+"""Functions for retrieving repointing table data."""
+
+import logging
+import os
+from pathlib import Path
+from typing import Union
+
+import numpy as np
+import pandas as pd
+from numpy import typing as npt
+
+logger = logging.getLogger(__name__)
+
+
+def get_repoint_data() -> pd.DataFrame:
+    """
+    Read repointing file using environment variable and return as dataframe.
+
+    Pointing and repointing nomenclature can be confusing. In this case,
+    repoint is taken to mean a repoint maneuver. Thus, repoint_start and repoint_end
+    are the times that bound when the spacecraft is performing a repointing maneuver.
+    This is different from a pointing which is the time between repointing maneuvers.
+
+    REPOINT_DATA_FILEPATH environment variable should point to a local
+    file where the repointing csv file is located.
+
+    Returns
+    -------
+    repoint_df : pandas.DataFrame
+        The repointing csv loaded into a pandas dataframe. The dataframe will
+        contain the following columns:
+
+            * `repoint_start_sec_sclk`: Starting MET seconds of repoint maneuver.
+            * `repoint_start_subsec_sclk`: Starting MET microseconds of repoint
+              maneuver.
+            * `repoint_start_met`: Floating point MET of repoint maneuver start time.
+              Derived from `repoint_start_sec_sclk` and `repoint_start_subsec_sclk`.
+            * `repoint_start_utc`: UTC time of repoint maneuver start time.
+            * `repoint_end_sec_sclk`: Ending MET seconds of repoint maneuver.
+            * `repoint_end_subsec_sclk`: Ending MET microseconds of repoint maneuver.
+            * `repoint_end_met`: Floating point MET of repoint maneuver end time.
+              Derived from `repoint_end_sec_sclk` and `repoint_end_subsec_sclk`.
+            * `repoint_end_utc`: UTC time of repoint maneuver end time.
+            * `repoint_id`: Unique ID number of each repoint maneuver.
+    """
+    repoint_data_filepath = os.getenv("REPOINT_DATA_FILEPATH")
+    if repoint_data_filepath is not None:
+        path_to_spin_file = Path(repoint_data_filepath)
+    else:
+        # Handle the case where the environment variable is not set
+        raise ValueError("REPOINT_DATA_FILEPATH environment variable is not set.")
+
+    logger.info(f"Reading repointing data from {path_to_spin_file}")
+    repoint_df = pd.read_csv(path_to_spin_file, comment="#")
+
+    # Compute times by combining seconds and subseconds fields
+    repoint_df["repoint_start_met"] = (
+        repoint_df["repoint_start_sec_sclk"]
+        + repoint_df["repoint_start_subsec_sclk"] / 1e6
+    )
+    repoint_df["repoint_end_met"] = (
+        repoint_df["repoint_end_sec_sclk"] + repoint_df["repoint_end_subsec_sclk"] / 1e6
+    )
+
+    return repoint_df
+
+
+def interpolate_repoint_data(
+    query_met_times: Union[float, npt.NDArray],
+) -> pd.DataFrame:
+    """
+    Interpolate repointing data to the queried MET times.
+
+    In addition to the repoint start, end, and id values that come directly from
+    the universal repointing table, a column is added to the output dataframe
+    which indicates whether each query met time occurs during a repoint maneuver
+    i.e. between the repoint start and end times of a row in the repointing
+    table.
+
+    Query times that are more than 24-hours after that last repoint start time
+    in the repoint table will cause an error to be raised. The assumption here
+    is that we shouldn't be processing data that occurs that close to the next
+    expected repoint start time before getting an updated repoint table.
+
+    Parameters
+    ----------
+    query_met_times : float or np.ndarray
+        Query times in Mission Elapsed Time (MET).
+
+    Returns
+    -------
+    repoint_df : pandas.DataFrame
+        Repoint table data interpolated such that there is one row
+        for each of the queried MET times. Output columns are:
+
+            * `repoint_start_sec_sclk`
+            * `repoint_start_subsec_sclk`
+            * `repoint_start_met`
+            * `repoint_end_sec_sclk`
+            * `repoint_end_subsec_sclk`
+            * `repoint_end_met`
+            * `repoint_id`
+            * `repoint_in_progress`
+
+    Raises
+    ------
+    ValueError : If any of the query_met_times are before the first repoint
+        start time or after the last repoint start time plus 24-hours.
+    """
+    repoint_df = get_repoint_data()
+
+    # Ensure query_met_times is an array
+    query_met_times = np.atleast_1d(query_met_times)
+
+    # Make sure no query times are before the first repoint in the dataframe.
+    repoint_df_start_met = repoint_df["repoint_start_met"].values[0]
+    if np.any(query_met_times < repoint_df_start_met):
+        bad_times = query_met_times[query_met_times < repoint_df_start_met]
+        raise ValueError(
+            f"{bad_times.size} query times are before the first repoint start "
+            f" time in the repoint table. {bad_times=}, {repoint_df_start_met=}"
+        )
+    # Make sure that no query times are after the valid range of the dataframe.
+    # We approximate the end time of the table by adding 24 hours to the last
+    # known repoint start time.
+    repoint_df_end_met = repoint_df["repoint_start_met"].values[-1] + 24 * 60 * 60
+    if np.any(query_met_times >= repoint_df_end_met):
+        bad_times = query_met_times[query_met_times >= repoint_df_end_met]
+        raise ValueError(
+            f"{bad_times.size} query times are after the valid time of the "
+            f"pointing table. The valid end time is 24-hours after the last "
+            f"repoint_start_time. {bad_times=}, {repoint_df_end_met=}"
+        )
+
+    # Find the row index for each queried MET time such that:
+    # repoint_start_time[i] <= MET < repoint_start_time[i+1]
+    row_indices = (
+        np.searchsorted(repoint_df["repoint_start_met"], query_met_times, side="right")
+        - 1
+    )
+    out_df = repoint_df.iloc[row_indices]
+
+    # Add a column indicating if the query time is during a repoint or not.
+    # The table already has the correct row for each query time, so we
+    # only need to check if the query time is less than the repoint end time to
+    # get the same result as `repoint_start_time <= query_met_times < repoint_end_time`.
+    out_df["repoint_in_progress"] = query_met_times < out_df["repoint_end_met"].values
+
+    return out_df

imap_processing/spice/spin.py

@@ -22,20 +22,21 @@ def get_spin_data() -> pd.DataFrame:
     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. The DataFrame will have the following columns:
+
+            * `spin_number`: Unique integer spin number.
+            * `spin_start_sec_sclk`: MET seconds of spin start time.
+            * `spin_start_subsec_sclk`: MET microseconds of spin start time.
+            * `spin_start_met`: Floating point MET seconds of spin start.
+            * `spin_start_utc`: UTC string of spin start time.
+            * `spin_period_sec`: Floating point spin period in seconds.
+            * `spin_period_valid`: Boolean indicating whether spin period is valid.
+            * `spin_phase_valid`: Boolean indicating whether spin phase is valid.
+            * `spin_period_source`: Source used for determining spin period.
+            * `thruster_firing`: Boolean indicating whether thruster is firing.
     """
     spin_data_filepath = os.getenv("SPIN_DATA_FILEPATH")
     if spin_data_filepath is not None:
@@ -44,11 +45,24 @@ def get_spin_data() -> pd.DataFrame:
         # 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
+    spin_df = pd.read_csv(
+        path_to_spin_file,
+        comment="#",
+        dtype={
+            "spin_number": int,
+            "spin_start_sec_sclk": int,
+            "spin_start_subsec_sclk": int,
+            "spin_start_utc": str,
+            "spin_period_sec": float,
+            "spin_period_valid": bool,
+            "spin_period_source": int,
+            "thruster_firing": bool,
+        },
+    )
+    # Combine spin_start_sec_sclk and spin_start_subsec_sclk to get the spin start
+    # time in seconds. The spin start subseconds are in microseconds.
+    spin_df["spin_start_met"] = (
+        spin_df["spin_start_sec_sclk"] + spin_df["spin_start_subsec_sclk"] / 1e6
     )
 
     return spin_df
@@ -71,18 +85,9 @@ def interpolate_spin_data(query_met_times: Union[float, npt.NDArray]) -> pd.Data
     Returns
     -------
     spin_df : pandas.DataFrame
-        Spin table data with the spin-phase column added and one row
-        interpolated for each queried MET time. Output columns are:
-        * spin_number
-        * spin_start_sec
-        * spin_start_subsec
-        * spin_period_sec
-        * spin_period_valid
-        * spin_phase_valid
-        * spin_period_source
-        * thruster_firing
-        * spin_start_met
-        * sc_spin_phase
+        Spin table data interpolated for each queried MET time. In addition to
+        the columns output from :py:func:`get_spin_data`, the `sc_spin_phase`
+        column is added and is uniquely computed for each queried MET time.
     """
     spin_df = get_spin_data()
 
@@ -95,9 +100,9 @@ def interpolate_spin_data(query_met_times: Union[float, npt.NDArray]) -> pd.Data
         query_met_times = np.atleast_1d(query_met_times)
 
     # Make sure input times are within the bounds of spin data
-    spin_df_start_time = spin_df["spin_start_time"].values[0]
+    spin_df_start_time = spin_df["spin_start_met"].values[0]
     spin_df_end_time = (
-        spin_df["spin_start_time"].values[-1] + spin_df["spin_period_sec"].values[-1]
+        spin_df["spin_start_met"].values[-1] + spin_df["spin_period_sec"].values[-1]
     )
     input_start_time = query_met_times.min()
     input_end_time = query_met_times.max()
@@ -115,13 +120,13 @@ def interpolate_spin_data(query_met_times: Union[float, npt.NDArray]) -> pd.Data
     # >>> 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
+        np.searchsorted(spin_df["spin_start_met"], query_met_times, side="right") - 1
     )
     # Generate a dataframe with one row per query time
     out_df = spin_df.iloc[last_spin_indices]
 
     # Calculate spin phase
-    spin_phases = (query_met_times - out_df["spin_start_time"].values) / out_df[
+    spin_phases = (query_met_times - out_df["spin_start_met"].values) / out_df[
         "spin_period_sec"
     ].values
 
@@ -185,7 +190,7 @@ def get_spacecraft_spin_phase(
     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
+        spin_phase = (query_met_times - spin_start_met) / spin_period_sec
 
     Parameters
     ----------

imap_processing/spice/time.py

@@ -2,6 +2,7 @@
 
 import typing
 from collections.abc import Collection, Iterable
+from datetime import datetime
 from typing import Union
 
 import numpy as np
@@ -297,3 +298,26 @@ def et_to_utc(
         UTC time(s).
     """
     return spiceypy.et2utc(et, format_str, precision, utclen)
+
+
+def epoch_to_doy(epoch: np.ndarray) -> npt.NDArray:
+    """
+    Convert epoch times to day of year (1-365/366).
+
+    Parameters
+    ----------
+    epoch : xarray.DataArray
+        Time, number of nanoseconds since J2000 with leap seconds included.
+
+    Returns
+    -------
+    day_of_year : numpy.ndarray
+        Day of year (1-365/366) for each epoch value.
+    """
+    et = ttj2000ns_to_et(epoch.data)
+    # Get UTC time strings in ISO calendar format
+    time_strings = et_to_utc(et, "ISOC")
+    # Extract DOY from datetime
+    return np.array(
+        [datetime.fromisoformat(date).timetuple().tm_yday for date in time_strings]
+    )

imap_processing/swapi/l1/swapi_l1.py

@@ -72,8 +72,7 @@ def filter_good_data(full_sweep_sci: xr.Dataset) -> npt.NDArray:
         f"{full_sweep_sci['sweep_table'].data[bad_cycle_indices]}"
     )
     logger.debug(
-        "Plan ID should be same: "
-        f"{full_sweep_sci['plan_id'].data[bad_cycle_indices]}"
+        f"Plan ID should be same: {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]}"
@@ -426,7 +425,7 @@ def process_sweep_data(full_sweep_sci: xr.Dataset, cem_prefix: str) -> xr.Datase
 
 
 def process_swapi_science(
-    sci_dataset: xr.Dataset, hk_dataset: xr.Dataset, data_version: str
+    sci_dataset: xr.Dataset, hk_dataset: xr.Dataset
 ) -> xr.Dataset:
     """
     Will process SWAPI science data and create CDF file.
@@ -437,8 +436,6 @@ def process_swapi_science(
         L0 data.
     hk_dataset : xarray.Dataset
         Housekeeping data.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -509,6 +506,10 @@ def process_swapi_science(
     # since we are not processing in real-time, the ground processing
     # algorithm should use the closest timestamp HK packet to fill in
     # the data quality for the SCI data per SWAPI team.
+
+    # Drop duplicate epoch values in HK data. Otherwise, the nearest
+    # method will not work as expected because .sel requires unique values.
+    hk_dataset = hk_dataset.drop_duplicates("epoch")
     good_sweep_times = good_sweep_sci["epoch"].data
     good_sweep_hk_data = hk_dataset.sel({"epoch": good_sweep_times}, method="nearest")
 
@@ -582,8 +583,6 @@ def process_swapi_science(
     )
 
     # Add other global attributes
-    # TODO: add others like below once add_global_attribute is fixed
-    cdf_manager.add_global_attribute("Data_version", data_version)
     l1_global_attrs = cdf_manager.get_global_attributes("imap_swapi_l1_sci")
     l1_global_attrs["Apid"] = f"{sci_dataset['pkt_apid'].data[0]}"
 
@@ -628,6 +627,18 @@ def process_swapi_science(
         dims=["epoch"],
         attrs=cdf_manager.get_variable_attributes("plan_id"),
     )
+    # Add ESA_LVL5 for L2 and L3 purposes.
+    # We need to store ESA_LVL5 at SEQ_NUMBER==11
+    # which is 71 energy step's ESA_LVL5 value. ESA_LVL5 gets
+    # updated every 6th step. This is used in L2 to calculate last 9 fine
+    # energy steps.
+    dataset["esa_lvl5"] = xr.DataArray(
+        good_sweep_sci["esa_lvl5"].data.reshape(total_full_sweeps, 12)[:, 11],
+        name="esa_lvl5",
+        dims=["epoch"],
+        attrs=cdf_manager.get_variable_attributes("esa_lvl5"),
+    )
+
     # Add these additional housekeeping support data
     #   SWP_HK.LUT_CHOICE - Which LUT is in use
     #   SWP_HK.FPGA_TYPE - Type number of the FPGA
@@ -699,7 +710,7 @@ def process_swapi_science(
     return dataset
 
 
-def swapi_l1(dependencies: list, data_version: str) -> xr.Dataset:
+def swapi_l1(dependencies: list) -> xr.Dataset:
     """
     Will process SWAPI level 0 data to level 1.
 
@@ -707,8 +718,6 @@ def swapi_l1(dependencies: list, data_version: str) -> xr.Dataset:
     ----------
     dependencies : list
         Input dependencies needed for L1 processing.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -740,7 +749,7 @@ def swapi_l1(dependencies: list, data_version: str) -> xr.Dataset:
     ):
         # process science data
         sci_dataset = process_swapi_science(
-            l0_unpacked_dict[SWAPIAPID.SWP_SCI], l1_hk_ds, data_version
+            l0_unpacked_dict[SWAPIAPID.SWP_SCI], l1_hk_ds
         )
         processed_data.append(sci_dataset)
 
@@ -749,7 +758,6 @@ def swapi_l1(dependencies: list, data_version: str) -> xr.Dataset:
         # Add HK datalevel attrs
         imap_attrs = ImapCdfAttributes()
         imap_attrs.add_instrument_global_attrs("swapi")
-        imap_attrs.add_global_attribute("Data_version", data_version)
         imap_attrs.add_instrument_variable_attrs(instrument="swapi", level=None)
         hk_ds.attrs.update(imap_attrs.get_global_attributes("imap_swapi_l1_hk"))
         hk_common_attrs = imap_attrs.get_variable_attributes("hk_attrs")