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

imap_processing/swe/l1b/swe_l1b_science.py

@@ -8,8 +8,11 @@ import pandas as pd
 import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
+from imap_processing.spice.time import met_to_ttj2000ns
+from imap_processing.swe.utils import swe_constants
 from imap_processing.swe.utils.swe_utils import (
-    ESA_VOLTAGE_ROW_INDEX_DICT,
+    calculate_data_acquisition_time,
+    combine_acquisition_time,
     read_lookup_table,
 )
 
@@ -157,18 +160,19 @@ def calculate_calibration_factor(
     Parameters
     ----------
     acquisition_times : numpy.ndarray
-        Data points to interpolate. Shape is (24, 30).
+        Data points to interpolate. Shape is (N_ESA_STEPS, N_ANGLE_SECTORS).
     cal_times : numpy.ndarray
         X-coordinates data points. Calibration times. Shape is (n,).
     cal_data : numpy.ndarray
         Y-coordinates data points. Calibration data of corresponding cal_times.
-        Shape is (n, 7).
+        Shape is (n, N_CEMS).
 
     Returns
     -------
     calibration_factor : numpy.ndarray
-        Calibration factor for each CEM detector. Shape is (24, 30, 7)
-        where last 7 dimension contains calibration factor for each CEM detector.
+        Calibration factor for each CEM detector. Shape is
+        (N_ESA_STEPS, N_ANGLE_SECTORS, N_CEMS) where last 7 dimension
+        contains calibration factor for each CEM detector.
     """
     # Raise error if there is no pre or post time in cal_times. SWE does not
     # want to extrapolate calibration data.
@@ -220,20 +224,23 @@ def apply_in_flight_calibration(
     Parameters
     ----------
     corrected_counts : numpy.ndarray
-        Corrected count of full cycle data. Data shape is (24, 30, 7).
+        Corrected count of full cycle data. Data shape is
+        (N_ESA_STEPS, N_ANGLE_SECTORS, N_CEMS).
     acquisition_time : numpy.ndarray
-        Acquisition time of full cycle data. Data shape is (24, 30).
+        Acquisition time of full cycle data. Data shape is
+        (N_ESA_STEPS, N_ANGLE_SECTORS).
 
     Returns
     -------
     corrected_counts : numpy.ndarray
         Corrected count of full cycle data after applying in-flight calibration.
-        Array shape is (24, 30, 7).
+        Array shape is (N_ESA_STEPS, N_ANGLE_SECTORS, N_CEMS).
     """
     # Read in in-flight calibration data
     in_flight_cal_df = read_in_flight_cal_data()
     # calculate calibration factor.
-    # return shape of calculate_calibration_factor is (24, 30, 7) where
+    # return shape of calculate_calibration_factor is
+    # (N_ESA_STEPS, N_ANGLE_SECTORS, N_CEMS) where
     # last 7 dimension contains calibration factor for each CEM detector.
     cal_factor = calculate_calibration_factor(
         acquisition_time,
@@ -270,31 +277,38 @@ def populate_full_cycle_data(
     # with information that esa step ramps up in even column and ramps down
     # in odd column every six steps.
     if esa_table_num == 0:
-        energy_steps = 24
-        angle = 30
-        cem_detectors = 7
         # create new full cycle data array
-        full_cycle_data = np.zeros((energy_steps, angle, cem_detectors))
+        full_cycle_data = np.zeros(
+            (
+                swe_constants.N_ESA_STEPS,
+                swe_constants.N_ANGLE_SECTORS,
+                swe_constants.N_CEMS,
+            )
+        )
         # SWE needs to store acquisition time of each count data point
         # to use in level 2 processing to calculate
         # spin phase. This is done below by using information from
         # science packet.
-        acquisition_times = np.zeros((energy_steps, angle))
+        acquisition_times = np.zeros(
+            (swe_constants.N_ESA_STEPS, swe_constants.N_ANGLE_SECTORS)
+        )
 
         # Store acquisition duration for later calculation in this function
-        acq_duration_arr = np.zeros((energy_steps, angle))
+        acq_duration_arr = np.zeros(
+            (swe_constants.N_ESA_STEPS, swe_constants.N_ANGLE_SECTORS)
+        )
 
         # Initialize esa_step_number and column_index.
         # esa_step_number goes from 0 to 719 range where
-        # 720 came from 24 x 30. full_cycle_data array has (24, 30)
-        # dimension.
+        # 720 came from 24 x 30. full_cycle_data array has
+        # (N_ESA_STEPS, N_ANGLE_SECTORS) dimension.
         esa_step_number = 0
         # column_index goes from 0 to 29 range where
         # 30 came from 30 column in full_cycle_data array
         column_index = -1
 
         # Go through four quarter cycle data packets
-        for index in range(4):
+        for index in range(swe_constants.N_QUARTER_CYCLES):
             decompressed_counts = l1a_data["science_data"].data[packet_index + index]
             # Do deadtime correction
             acq_duration = l1a_data["acq_duration"].data[packet_index + index]
@@ -304,11 +318,9 @@ def populate_full_cycle_data(
             # Each quarter cycle data should have same acquisition start time coarse
             # and fine value. We will use that as base time to calculate each
             # acquisition time for each count data.
-            #   base_quarter_cycle_acq_time = acq_start_coarse +
-            #                                 acq_start_fine / 1000000
-            base_quarter_cycle_acq_time = (
-                l1a_data["acq_start_coarse"].data[packet_index + index]
-                + l1a_data["acq_start_fine"].data[packet_index + index] / 1000000
+            base_quarter_cycle_acq_time = combine_acquisition_time(
+                l1a_data["acq_start_coarse"].data[packet_index + index],
+                l1a_data["acq_start_fine"].data[packet_index + index],
             )
 
             # Go through each quarter cycle's 180 ESA measurements
@@ -317,7 +329,9 @@ def populate_full_cycle_data(
                 # Get esa voltage value from esa lookup table and
                 # use that to get row index in full data array
                 esa_voltage_value = esa_lookup_table.loc[esa_step_number]["esa_v"]
-                esa_voltage_row_index = ESA_VOLTAGE_ROW_INDEX_DICT[esa_voltage_value]
+                esa_voltage_row_index = swe_constants.ESA_VOLTAGE_ROW_INDEX_DICT[
+                    esa_voltage_value
+                ]
 
                 # every six steps, increment column index
                 if esa_step_number % 6 == 0:
@@ -326,15 +340,14 @@ def populate_full_cycle_data(
                 full_cycle_data[esa_voltage_row_index][column_index] = corrected_counts[
                     step
                 ]
-                # Acquisition time (in seconds) of each count data point will be
-                # using this formula:
-                #   each_count_acq_time = base_quarter_cycle_acq_time +
-                #            (step * ( acq_duration + settle_duration) / 1000000 )
-                # where step goes from 0 to 179, acq_start_coarse is in seconds and
-                # acq_start_fine is in microseconds and acq_duration is in microseconds.
+                # Acquisition time (in seconds) of each count data point
                 acquisition_times[esa_voltage_row_index][column_index] = (
-                    base_quarter_cycle_acq_time
-                    + (step * (acq_duration + settle_duration) / 1000000)
+                    calculate_data_acquisition_time(
+                        base_quarter_cycle_acq_time,
+                        esa_step_number,
+                        acq_duration,
+                        settle_duration,
+                    )
                 )
                 # Store acquisition duration for later calculation
                 acq_duration_arr[esa_voltage_row_index][column_index] = acq_duration
@@ -352,13 +365,16 @@ def populate_full_cycle_data(
     calibrated_counts = apply_in_flight_calibration(full_cycle_data, acquisition_times)
 
     # Convert counts to rate
-    counts_rate = convert_counts_to_rate(calibrated_counts, acq_duration)
+    counts_rate = convert_counts_to_rate(
+        calibrated_counts, acq_duration_arr[:, :, np.newaxis]
+    )
 
-    # Store count data and acquisition times of full cycle data in xr.Dataset
+    # Store full cycle data in xr.Dataset for later use.
     full_cycle_ds = xr.Dataset(
         {
             "full_cycle_data": (["esa_step", "spin_sector", "cem_id"], counts_rate),
             "acquisition_time": (["esa_step", "spin_sector"], acquisition_times),
+            "acq_duration": (["esa_step", "spin_sector"], acq_duration_arr),
         }
     )
 
@@ -381,7 +397,7 @@ def find_cycle_starts(cycles: np.ndarray) -> npt.NDArray:
     first_quarter_indices : numpy.ndarray
         Array of indices of start cycle.
     """
-    if cycles.size < 4:
+    if cycles.size < swe_constants.N_QUARTER_CYCLES:
         return np.array([], np.int64)
 
     # calculate difference between consecutive cycles
@@ -422,7 +438,10 @@ def get_indices_of_full_cycles(quarter_cycle: np.ndarray) -> npt.NDArray:
     #   Eg. [[0, 1, 2, 3]]
     # then we add both of them together to get an array of shape(n, 4)
     #   Eg. [[3, 4, 5, 6], [8, 9, 10, 11]]
-    full_cycles_indices = indices_of_start[..., None] + np.arange(4)[None, ...]
+    full_cycles_indices = (
+        indices_of_start[..., None]
+        + np.arange(swe_constants.N_QUARTER_CYCLES)[None, ...]
+    )
     return full_cycles_indices.reshape(-1)
 
 
@@ -470,7 +489,9 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
     # Array to store list of table populated with data
     # of full cycles
     full_cycle_science_data = []
+    # These two are carried in l1b for level 2 and 3 processing
     full_cycle_acq_times = []
+    full_cycle_acq_duration = []
     packet_index = 0
     l1a_data_copy = l1a_data.copy(deep=True)
 
@@ -505,7 +526,7 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
             )
 
     # Go through each cycle and populate full cycle data
-    for packet_index in range(0, total_packets, 4):
+    for packet_index in range(0, total_packets, swe_constants.N_QUARTER_CYCLES):
         # get ESA lookup table information
         esa_table_num = l1a_data["esa_table_num"].data[packet_index]
 
@@ -524,6 +545,7 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
         # save full data array to file
         full_cycle_science_data.append(full_cycle_ds["full_cycle_data"].data)
         full_cycle_acq_times.append(full_cycle_ds["acquisition_time"].data)
+        full_cycle_acq_duration.append(full_cycle_ds["acq_duration"].data)
 
     # ------------------------------------------------------------------
     # Save data to dataset.
@@ -534,22 +556,32 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
     cdf_attrs.add_instrument_variable_attrs("swe", "l1b")
     cdf_attrs.add_global_attribute("Data_version", data_version)
 
-    # Get epoch time of full cycle data and then reshape it to
-    # (n, 4) where n = total number of full cycles and 4 = four
-    # quarter cycle data metadata. For epoch's data, we take the first element
-    # of each quarter cycle data metadata.
+    # One full cycle data combines four quarter cycles data.
+    # Epoch will store center of each science meansurement using
+    # third acquisition start time coarse and fine value
+    # of four quarter cycle data packets. For example, we want to
+    # get indices of 3rd quarter cycle data packet in each full cycle
+    # and use that to calculate center time of data acquisition time.
+    #   Quarter cycle indices: 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, ...
+    indices_of_center_time = np.arange(2, total_packets, swe_constants.N_QUARTER_CYCLES)
+
+    center_time = combine_acquisition_time(
+        full_cycle_l1a_data["acq_start_coarse"].data[indices_of_center_time],
+        full_cycle_l1a_data["acq_start_fine"].data[indices_of_center_time],
+    )
+
     epoch_time = xr.DataArray(
-        l1a_data["epoch"].data[full_cycle_data_indices].reshape(-1, 4)[:, 0],
+        met_to_ttj2000ns(center_time),
         name="epoch",
         dims=["epoch"],
-        attrs=cdf_attrs.get_variable_attributes("epoch"),
+        attrs=cdf_attrs.get_variable_attributes("epoch", check_schema=False),
     )
 
     esa_step = xr.DataArray(
-        np.arange(24),
+        np.arange(swe_constants.N_ESA_STEPS),
         name="esa_step",
         dims=["esa_step"],
-        attrs=cdf_attrs.get_variable_attributes("esa_step"),
+        attrs=cdf_attrs.get_variable_attributes("esa_step", check_schema=False),
     )
 
     # NOTE: LABL_PTR_1 should be CDF_CHAR.
@@ -557,14 +589,14 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
         esa_step.values.astype(str),
         name="esa_step_label",
         dims=["esa_step"],
-        attrs=cdf_attrs.get_variable_attributes("esa_step_label"),
+        attrs=cdf_attrs.get_variable_attributes("esa_step_label", check_schema=False),
     )
 
     spin_sector = xr.DataArray(
-        np.arange(30),
+        np.arange(swe_constants.N_ANGLE_SECTORS),
         name="spin_sector",
         dims=["spin_sector"],
-        attrs=cdf_attrs.get_variable_attributes("spin_sector"),
+        attrs=cdf_attrs.get_variable_attributes("spin_sector", check_schema=False),
     )
 
     # NOTE: LABL_PTR_2 should be CDF_CHAR.
@@ -572,21 +604,30 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
         spin_sector.values.astype(str),
         name="spin_sector_label",
         dims=["spin_sector"],
-        attrs=cdf_attrs.get_variable_attributes("spin_sector_label"),
+        attrs=cdf_attrs.get_variable_attributes(
+            "spin_sector_label", check_schema=False
+        ),
     )
 
     cycle = xr.DataArray(
-        np.arange(4),
+        np.arange(swe_constants.N_QUARTER_CYCLES),
         name="cycle",
         dims=["cycle"],
-        attrs=cdf_attrs.get_variable_attributes("cycle"),
+        attrs=cdf_attrs.get_variable_attributes("cycle", check_schema=False),
+    )
+
+    cycle_label = xr.DataArray(
+        cycle.values.astype(str),
+        name="cycle_label",
+        dims=["cycle"],
+        attrs=cdf_attrs.get_variable_attributes("cycle_label", check_schema=False),
     )
 
     cem_id = xr.DataArray(
-        np.arange(7, dtype=np.float64),
+        np.arange(swe_constants.N_CEMS, dtype=np.int8),
         name="cem_id",
         dims=["cem_id"],
-        attrs=cdf_attrs.get_variable_attributes("cem_id"),
+        attrs=cdf_attrs.get_variable_attributes("cem_id", check_schema=False),
     )
 
     # NOTE: LABL_PTR_3 should be CDF_CHAR.
@@ -594,7 +635,7 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
         cem_id.values.astype(str),
         name="cem_id_label",
         dims=["cem_id"],
-        attrs=cdf_attrs.get_variable_attributes("cem_id_label"),
+        attrs=cdf_attrs.get_variable_attributes("cem_id_label", check_schema=False),
     )
 
     # Add science data and it's associated metadata into dataset.
@@ -622,6 +663,7 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
             "esa_step_label": esa_step_label,
             "spin_sector_label": spin_sector_label,
             "cem_id_label": cem_id_label,
+            "cycle_label": cycle_label,
         },
         attrs=cdf_attrs.get_global_attributes("imap_swe_l1b_sci"),
     )
@@ -636,14 +678,19 @@ def swe_l1b_science(l1a_data: xr.Dataset, data_version: str) -> xr.Dataset:
         dims=["epoch", "esa_step", "spin_sector"],
         attrs=cdf_attrs.get_variable_attributes("acquisition_time"),
     )
+    dataset["acq_duration"] = xr.DataArray(
+        full_cycle_acq_duration,
+        dims=["epoch", "esa_step", "spin_sector"],
+        attrs=cdf_attrs.get_variable_attributes("acq_duration"),
+    )
 
     # create xarray dataset for each metadata field
     for key, value in full_cycle_l1a_data.items():
-        if key == "science_data":
+        if key in ["science_data", "acq_duration"]:
             continue
         metadata_field = key.lower()
         dataset[metadata_field] = xr.DataArray(
-            value.data.reshape(-1, 4),
+            value.data.reshape(-1, swe_constants.N_QUARTER_CYCLES),
             dims=["epoch", "cycle"],
             attrs=cdf_attrs.get_variable_attributes(metadata_field),
         )

imap_processing/swe/l2/swe_l2.py

@@ -11,34 +11,11 @@ import xarray as xr
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.spice.geometry import SpiceFrame
 from imap_processing.spice.spin import get_instrument_spin_phase, get_spin_angle
+from imap_processing.swe.utils import swe_constants
 from imap_processing.swe.utils.swe_utils import (
-    ESA_VOLTAGE_ROW_INDEX_DICT,
     read_lookup_table,
 )
 
-# TODO: add these to instrument status summary
-ENERGY_CONVERSION_FACTOR = 4.75
-# 7 CEMs geometric factors in cm^2 sr eV/eV units.
-GEOMETRIC_FACTORS = np.array(
-    [
-        435e-6,
-        599e-6,
-        808e-6,
-        781e-6,
-        876e-6,
-        548e-6,
-        432e-6,
-    ]
-)
-ELECTRON_MASS = 9.10938356e-31  # kg
-
-# See doc string of calculate_phase_space_density() for more details.
-VELOCITY_CONVERSION_FACTOR = 1.237e31
-# See doc string of calculate_flux() for more details.
-FLUX_CONVERSION_FACTOR = 6.187e30
-
-CEM_DETECTORS_ANGLE = np.array([-63, -42, -21, 0, 21, 42, 63])
-
 
 def get_particle_energy() -> npt.NDArray:
     """
@@ -57,7 +34,9 @@ def get_particle_energy() -> npt.NDArray:
     lookup_table = read_lookup_table()
 
     # Convert voltage to electron energy in eV by apply conversion factor.
-    lookup_table["energy"] = lookup_table["esa_v"].values * ENERGY_CONVERSION_FACTOR
+    lookup_table["energy"] = (
+        lookup_table["esa_v"].values * swe_constants.ENERGY_CONVERSION_FACTOR
+    )
     return lookup_table
 
 
@@ -117,14 +96,16 @@ def calculate_phase_space_density(l1b_dataset: xr.Dataset) -> xr.Dataset:
             for val in esa_table_nums
         ]
     )
-    particle_energy_data = particle_energy_data.reshape(-1, 24, 30)
+    particle_energy_data = particle_energy_data.reshape(
+        -1, swe_constants.N_ESA_STEPS, swe_constants.N_ANGLE_SECTORS
+    )
 
     # Calculate phase space density using formula:
     #   2 * (C/tau) / (G * 1.237e31 * eV^2)
     # See doc string for more details.
     density = (2 * l1b_dataset["science_data"]) / (
-        GEOMETRIC_FACTORS[np.newaxis, np.newaxis, np.newaxis, :]
-        * VELOCITY_CONVERSION_FACTOR
+        swe_constants.GEOMETRIC_FACTORS[np.newaxis, np.newaxis, np.newaxis, :]
+        * swe_constants.VELOCITY_CONVERSION_FACTOR
         * particle_energy_data[:, :, :, np.newaxis] ** 2
     )
 
@@ -194,7 +175,7 @@ def calculate_flux(l1b_dataset: xr.Dataset) -> npt.NDArray:
     """
     phase_space_density_ds = calculate_phase_space_density(l1b_dataset)
     flux = (
-        FLUX_CONVERSION_FACTOR
+        swe_constants.FLUX_CONVERSION_FACTOR
         * phase_space_density_ds["energy_in_eV"].data[:, :, :, np.newaxis]
         * phase_space_density_ds["phase_space_density"].data
     )
@@ -220,22 +201,32 @@ def put_data_into_angle_bins(
     Parameters
     ----------
     data : numpy.ndarray
-        Data to put in bins. Shape: (full_cycle_data, energy_step, angle_bin, 7).
+        Data to put in bins. Shape:
+        (full_cycle_data, N_ESA_STEPS, N_ANGLE_BINS, N_CEMS).
     angle_bin_indices : numpy.ndarray
         Indices of angle bins to put data in. Shape:
-        (full_cycle_data, energy_step, angle_bin).
+        (full_cycle_data, N_ESA_STEPS, N_ANGLE_BINS).
 
     Returns
     -------
     numpy.ndarray
-        Data in bins. Shape: (full_cycle_data, 24, 30, 7).
+        Data in bins. Shape:
+        (full_cycle_data, N_ESA_STEPS, N_ANGLE_BINS, N_CEMS).
     """
     # Initialize with zeros instead of NaN because np.add.at() does not
     # work with nan values. It results in nan + value = nan
-    binned_data = np.zeros((data.shape[0], 24, 30, 7), dtype=np.float64)
+    binned_data = np.zeros(
+        (
+            data.shape[0],
+            swe_constants.N_ESA_STEPS,
+            swe_constants.N_ANGLE_BINS,
+            swe_constants.N_CEMS,
+        ),
+        dtype=np.float64,
+    )
 
     time_indices = np.arange(data.shape[0])[:, None, None]
-    energy_indices = np.arange(24)[None, :, None]
+    energy_indices = np.arange(swe_constants.N_ESA_STEPS)[None, :, None]
 
     # Use np.add.at() to accumulate values into bins
     np.add.at(binned_data, (time_indices, energy_indices, angle_bin_indices), data)
@@ -335,45 +326,52 @@ def swe_l2(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
 
     # Energy values in eV.
     energy_xr = xr.DataArray(
-        np.array(list(ESA_VOLTAGE_ROW_INDEX_DICT.keys())) * ENERGY_CONVERSION_FACTOR,
+        np.array(list(swe_constants.ESA_VOLTAGE_ROW_INDEX_DICT.keys()))
+        * swe_constants.ENERGY_CONVERSION_FACTOR,
         name="energy",
         dims=["energy"],
-        attrs=cdf_attributes.get_variable_attributes("energy"),
+        attrs=cdf_attributes.get_variable_attributes("energy", check_schema=False),
     )
 
     energy_label = xr.DataArray(
-        np.array(list(ESA_VOLTAGE_ROW_INDEX_DICT.keys())).astype(str),
+        np.array(list(swe_constants.ESA_VOLTAGE_ROW_INDEX_DICT.keys())).astype(str),
         name="energy_label",
         dims=["energy"],
-        attrs=cdf_attributes.get_variable_attributes("energy_label"),
+        attrs=cdf_attributes.get_variable_attributes(
+            "energy_label", check_schema=False
+        ),
     )
 
     # Angle of each CEM detectors.
     inst_el_xr = xr.DataArray(
-        CEM_DETECTORS_ANGLE,
+        swe_constants.CEM_DETECTORS_ANGLE,
         name="inst_el",
         dims=["inst_el"],
-        attrs=cdf_attributes.get_variable_attributes("inst_el"),
+        attrs=cdf_attributes.get_variable_attributes("inst_el", check_schema=False),
     )
     inst_el_label = xr.DataArray(
-        CEM_DETECTORS_ANGLE.astype(str),
+        swe_constants.CEM_DETECTORS_ANGLE.astype(str),
         name="inst_el_label",
         dims=["inst_el"],
-        attrs=cdf_attributes.get_variable_attributes("inst_el_label"),
+        attrs=cdf_attributes.get_variable_attributes(
+            "inst_el_label", check_schema=False
+        ),
     )
 
     # Spin Angle bins storing bin center values.
     inst_az_xr = xr.DataArray(
-        np.arange(0, 360, 12) + 6,
+        np.arange(0, 360, 12, dtype=np.float32) + 6,
         name="inst_az",
         dims=["inst_az"],
-        attrs=cdf_attributes.get_variable_attributes("inst_az"),
+        attrs=cdf_attributes.get_variable_attributes("inst_az", check_schema=False),
     )
     inst_az_label = xr.DataArray(
         inst_az_xr.values.astype(str),
         name="inst_az_label",
         dims=["inst_az"],
-        attrs=cdf_attributes.get_variable_attributes("inst_az_label"),
+        attrs=cdf_attributes.get_variable_attributes(
+            "inst_az_label", check_schema=False
+        ),
     )
 
     dataset = xr.Dataset(
@@ -419,36 +417,33 @@ def swe_l2(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
 
     # Carry over acquisition times for L3 purposes.
     dataset["acquisition_time"] = l1b_dataset["acquisition_time"]
+    # Update the acquisition_time variable attributes.
+    dataset["acquisition_time"].attrs = cdf_attributes.get_variable_attributes(
+        "acquisition_time"
+    )
+    # Carry over acq_duration for L3 purposes.
+    dataset["acq_duration"] = l1b_dataset["acq_duration"]
+    # Update the acq_duration variable attributes.
+    dataset["acq_duration"].attrs = cdf_attributes.get_variable_attributes(
+        "acq_duration"
+    )
 
     # Calculate spin phase using SWE acquisition_time from the
     # L1B dataset. The L1B dataset stores acquisition_time with
-    # dimensions (epoch, esa_step, spin_sector). Use center time
-    # to calculate spin phase. This center time calculation is
-    # necessary to accurately determine the center angle of the data.
-    #
-    # To determine the center acquisition time, we adjust the
-    # recorded acquisition_time as follows:
-    #   acquisition_time + (acq_duration / 1000000) / 2
-    #
-    # Here, acq_duration is given in microseconds and is stored
-    # in the L1B dataset with dimensions (epoch, cycle). Since acq_duration
-    # remains the same for all quarter cycles within a full sweep,
-    # we use the first acq_duration value for each full sweep to perform
-    # this adjustment.
-
-    acq_duration = l1b_dataset["acq_duration"].data[:, 0] / 2000000
-    data_acq_time = (
-        l1b_dataset["acquisition_time"].data + acq_duration[:, np.newaxis, np.newaxis]
-    )
+    # dimensions (epoch, esa_step, spin_sector). acquisition_time is
+    # center time of acquisition time of each science measurement which
+    # is necessary to accurately determine the center angle of the data.
 
     # Calculate spin phase
     inst_spin_phase = get_instrument_spin_phase(
-        query_met_times=data_acq_time.ravel(),
+        query_met_times=l1b_dataset["acquisition_time"].data.ravel(),
         instrument=SpiceFrame.IMAP_SWE,
     )
 
     # Convert spin phase to spin angle in degrees.
-    inst_spin_angle = get_spin_angle(inst_spin_phase, degrees=True).reshape(-1, 24, 30)
+    inst_spin_angle = get_spin_angle(inst_spin_phase, degrees=True).reshape(
+        -1, swe_constants.N_ESA_STEPS, swe_constants.N_ANGLE_SECTORS
+    )
 
     # Save spin angle in dataset per SWE request.
     dataset["inst_az_spin_sector"] = xr.DataArray(