imap-processing 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

imap_processing/hi/{l2/hi_l2.py → hi_l2.py}

@@ -27,11 +27,11 @@ def hi_l2(
 
     Parameters
     ----------
-    psets : list of str or Path
+    psets : list of str or pathlib.Path
         List of input PSETs to make a map from.
-    geometric_factors_path : str or Path
+    geometric_factors_path : str or pathlib.Path
         Where to get the geometric factors from.
-    esa_energies_path : str or Path
+    esa_energies_path : str or pathlib.Path
         Where to get the energies from.
     descriptor : str
         Output filename descriptor. Contains full configuration for the options
@@ -39,7 +39,7 @@ def hi_l2(
 
     Returns
     -------
-    l2_dataset : list[xr.Dataset]
+    l2_dataset : list[xarray.Dataset]
         Level 2 IMAP-Hi dataset ready to be written to a CDF file.
     """
     # TODO: parse descriptor to determine map configuration
@@ -77,19 +77,19 @@ def generate_hi_map(
 
     Parameters
     ----------
-    psets : list of str or Path
+    psets : list of str or pathlib.Path
         List of input PSETs to make a map from.
-    geometric_factors_path : str or Path
+    geometric_factors_path : str or pathlib.Path
         Where to get the geometric factors from.
-    esa_energies_path : str or Path
+    esa_energies_path : str or pathlib.Path
         Where to get the energies from.
-    cg_corrected : bool, optional
+    cg_corrected : bool, Optional
         Whether to apply Compton-Getting correction to the energies. Defaults to
         False.
-    direction : str, optional
+    direction : str, Optional
         Apply filtering to PSET data include ram or anti-ram or full spin data.
         Defaults to "full".
-    map_spacing : int, optional
+    map_spacing : int, Optional
         Pixel spacing, in degrees, of the output map in degrees. Defaults to 4.
 
     Returns
@@ -209,11 +209,11 @@ def calculate_ena_intensity(
 
     Parameters
     ----------
-    map_ds : xr.Dataset
+    map_ds : xarray.Dataset
         Map dataset that has ena_signal_rate fields calculated.
-    geometric_factors_path : str or Path
+    geometric_factors_path : str or pathlib.Path
         Where to get the geometric factors from.
-    esa_energies_path : str or Path
+    esa_energies_path : str or pathlib.Path
         Where to get the energies from.
 
     Returns

imap_processing/hi/utils.py

@@ -116,15 +116,15 @@ def full_dataarray(
         Variable name.
     attrs : dict
         CDF variable attributes. Usually retrieved from ImapCdfAttributes.
-    coords : dict, optional
+    coords : dict, Optional
         Coordinate variables for the Dataset. This function will extract the
         sizes of each dimension defined by the attributes dictionary to determine
         the size of the DataArray to be created.
-    shape : int or tuple, optional
+    shape : int or tuple, Optional
         Shape of ndarray data array to instantiate in the xarray.DataArray. If
         shape is provided, the DataArray created will have this shape regardless
         of whether coordinates are provided or not.
-    fill_value : optional, float
+    fill_value : Optional, float
         Override the fill value that the DataArray will be filled with. If not
         supplied, the "FILLVAL" value from `attrs` will be used.
 
@@ -171,15 +171,15 @@ def create_dataset_variables(
     ----------
     variable_names : list[str]
         List of variable names to create.
-    variable_shape : int or sequence of int, optional
+    variable_shape : int or Sequence of int, Optional
         Shape of the new variables data ndarray. If not provided the shape will
         attempt to be derived from the coords dictionary.
-    coords : dict, optional
+    coords : dict, Optional
         Coordinate variables for the Dataset. If `variable_shape` is not provided
         the dataset variables created will use this dictionary along with variable
         attributes from the CdfAttributeManager to determine the shapes of the
         dataset variables created.
-    fill_value : optional, number
+    fill_value : Optional, float
         Value to fill the new variables data arrays with. If not supplied,
         the fill value is pulled from the CDF variable attributes "FILLVAL"
         attribute.

imap_processing/hit/l1b/hit_l1b.py

@@ -366,7 +366,8 @@ def subset_data_for_sectored_counts(
     A set of sectored data starts with hydrogen and ends with iron and correspond to
     the mod 10 values 0-9. The livetime values from the previous 10 minutes are used
     to calculate the rates for each set since those counts are transmitted 10 minutes
-    after they were collected.
+    after they were collected. Therefore, only complete sets of sectored counts where
+    livetime from the previous 10 minutes are available are included in the output.
 
     Parameters
     ----------
@@ -378,7 +379,7 @@ def subset_data_for_sectored_counts(
     Returns
     -------
     tuple[xr.Dataset, xr.DataArray]
-        Subsetted L1A counts dataset and corresponding livetime values.
+        Dataset of complete sectored counts and corresponding livetime values.
     """
     # Identify 10-minute intervals of complete sectored counts.
     bin_size = 10
@@ -392,16 +393,34 @@ def subset_data_for_sectored_counts(
     start_indices = np.where(matches)[0]
 
     # Filter out start indices that are less than or equal to the bin size
-    # since the previous 10 minutes are needed
-    start_indices = start_indices[start_indices > bin_size]
-    data_slice = slice(start_indices[0], start_indices[-1] + bin_size)
-
-    # Subset data to include only complete sets of sectored counts
-    l1b_sectored_rates_dataset = l1a_counts_dataset.isel(epoch=data_slice)
+    # since the previous 10 minutes are needed for calculating rates
+    if start_indices.size == 0:
+        logger.error(
+            "No data to process - valid start indices not found for "
+            "complete sectored counts."
+        )
+        raise ValueError("No valid start indices found for complete sectored counts.")
+    else:
+        start_indices = start_indices[start_indices >= bin_size]
+
+    # Subset data for complete sets of sectored counts.
+    # Each set of sectored counts is 10 minutes long, so we take the indices
+    # starting from the start indices and extend to the bin size of 10.
+    # This creates a 1D array of indices that correspond to the complete
+    # sets of sectored counts which is used to filter the L1A dataset and
+    # create the L1B sectored rates dataset.
+    data_indices = np.concatenate(
+        [np.arange(idx, idx + bin_size) for idx in start_indices]
+    )
+    l1b_sectored_rates_dataset = l1a_counts_dataset.isel(epoch=data_indices)
 
-    # Subset livetime staggered from sectored counts by 10 minutes
-    livetime_slice = slice(start_indices[0] - bin_size, start_indices[-1])
-    livetime = livetime[livetime_slice]
+    # Subset livetime values corresponding to the previous 10 minutes
+    # for each start index. This ensures the livetime data aligns correctly
+    # with the sectored counts for rate calculations.
+    livetime_indices = np.concatenate(
+        [np.arange(idx - bin_size, idx) for idx in start_indices]
+    )
+    livetime = livetime.isel(epoch=livetime_indices)
 
     return l1b_sectored_rates_dataset, livetime
 

imap_processing/ialirt/constants.py

@@ -0,0 +1,38 @@
+"""Module for constants and useful shared classes used in I-ALiRT processing."""
+
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class IalirtSwapiConstants:
+    """
+    Constants for I-ALiRT SWAPI which can be used across different levels or classes.
+
+    Attributes
+    ----------
+    BOLTZ: float
+        Boltzmann constant [J/K]
+    AT_MASS: float
+        Atomic mass [kg]
+    PROT_MASS: float
+        Mass of proton [kg]
+    EFF_AREA: float
+        Instrument effective area [m^2]
+    AZ_FOV: float
+        Azimuthal width of the field of view for solar wind [radians]
+    FWHM_WIDTH: float
+        Full Width at Half Maximum of energy width [unitless]
+    SPEED_EW: float
+        Speed width of energy passband [unitless]
+    """
+
+    # Scientific constants used in optimization model
+    boltz = 1.380649e-23  # Boltzmann constant, J/K
+    at_mass = 1.6605390666e-27  # atomic mass, kg
+    prot_mass = 1.007276466621 * at_mass  # mass of proton, kg
+    eff_area = 3.3e-5 * 1e-4  # effective area, meters squared
+    az_fov = np.deg2rad(30)  # azimuthal width of the field of view, radians
+    fwhm_width = 0.085  # FWHM of energy width
+    speed_ew = 0.5 * fwhm_width  # speed width of energy passband

imap_processing/ialirt/l0/parse_mag.py

@@ -390,7 +390,7 @@ def process_packet(
             {
                 "apid": 478,
                 "met": int(met.values.min()),
-                "utc": met_to_utc(met.values.min()).split(".")[0],
+                "met_in_utc": met_to_utc(met.values.min()).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met.values.min())),
                 "mag_4s_b_gse": [Decimal("0.0") for _ in range(3)],
                 "mag_4s_b_gsm": [Decimal("0.0") for _ in range(3)],

imap_processing/ialirt/l0/process_codice.py

@@ -0,0 +1,91 @@
+"""Functions to support I-ALiRT CoDICE processing."""
+
+import logging
+from decimal import Decimal
+from typing import Any
+
+import xarray as xr
+
+from imap_processing.codice import constants
+from imap_processing.ialirt.utils.time import calculate_time
+from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc
+
+logger = logging.getLogger(__name__)
+
+FILLVAL_FLOAT32 = Decimal(str(-1.0e31))
+
+
+def process_codice(
+    dataset: xr.Dataset,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """
+    Create final data products.
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        Decommed L0 data.
+
+    Returns
+    -------
+    codice_data : list[dict]
+        Dictionary of final data product.
+
+    Notes
+    -----
+    This function is incomplete and will need to be updated to include the
+    necessary calculations and data products.
+    - Calculate rates (assume 4 minutes per group)
+    - Calculate L2 CoDICE pseudodensities (pg 37 of Algorithm Document)
+    - Calculate the public data products
+    """
+    # For I-ALiRT SIT, the test data being used has all zeros and thus no
+    # groups can be found, thus there is no data to process
+    # TODO: Once I-ALiRT test data is acquired that actually has data in it,
+    #       this can be turned back on
+    # codicelo_data = create_ialirt_dataset(CODICEAPID.COD_LO_IAL, dataset)
+    # codicehi_data = create_ialirt_dataset(CODICEAPID.COD_HI_IAL, dataset)
+
+    # TODO: calculate rates
+    #       This will be done in codice.codice_l1b
+
+    # TODO: calculate L2 CoDICE pseudodensities
+    #       This will be done in codice.codice_l2
+
+    # TODO: calculate the public data products
+    #       This will be done in this module
+
+    # Create mock dataset for I-ALiRT SIT
+    # TODO: Once I-ALiRT test data is acquired that actually has data in it,
+    #       we should be able to properly populate the I-ALiRT data, but for
+    #       now, just create lists of dicts with FILLVALs
+    cod_lo_data = []
+    cod_hi_data = []
+
+    for epoch in range(len(dataset.epoch.data)):
+        sc_sclk_sec = dataset.sc_sclk_sec.data[epoch]
+        sc_sclk_sub_sec = dataset.sc_sclk_sub_sec.data[epoch]
+        met = calculate_time(sc_sclk_sec, sc_sclk_sub_sec, 256)
+        utc = met_to_utc(met).split(".")[0]
+        ttj2000ns = int(met_to_ttj2000ns(met))
+
+        epoch_data = {
+            "apid": int(dataset.pkt_apid[epoch].data),
+            "met": met,
+            "met_to_utc": utc,
+            "ttj2000ns": ttj2000ns,
+        }
+
+        # Add in CoDICE-Lo specific data
+        cod_lo_epoch_data = epoch_data.copy()
+        for field in constants.CODICE_LO_IAL_DATA_FIELDS:
+            cod_lo_epoch_data[f"codicelo_{field}"] = FILLVAL_FLOAT32
+        cod_lo_data.append(cod_lo_epoch_data)
+
+        # Add in CoDICE-Hi specific data
+        cod_hi_epoch_data = epoch_data.copy()
+        for field in constants.CODICE_HI_IAL_DATA_FIELDS:
+            cod_hi_epoch_data[f"codicehi_{field}"] = FILLVAL_FLOAT32
+        cod_hi_data.append(cod_hi_epoch_data)
+
+    return cod_lo_data, cod_hi_data

imap_processing/ialirt/l0/process_hit.py

@@ -1,7 +1,6 @@
 """Functions to support HIT processing."""
 
 import logging
-from decimal import Decimal
 
 import numpy as np
 import xarray as xr
@@ -170,27 +169,19 @@ def process_hit(xarray_data: xr.Dataset) -> list[dict]:
             {
                 "apid": 478,
                 "met": int(met),
-                "utc": met_to_utc(met).split(".")[0],
+                "met_in_utc": met_to_utc(met).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met)),
-                "hit_e_a_side_low_en": Decimal(
-                    str(l1["IALRT_RATE_1"] + l1["IALRT_RATE_2"])
-                ),
-                "hit_e_a_side_med_en": Decimal(
-                    str(l1["IALRT_RATE_5"] + l1["IALRT_RATE_6"])
-                ),
-                "hit_e_a_side_high_en": Decimal(str(l1["IALRT_RATE_7"])),
-                "hit_e_b_side_low_en": Decimal(
-                    str(l1["IALRT_RATE_11"] + l1["IALRT_RATE_12"])
-                ),
-                "hit_e_b_side_med_en": Decimal(
-                    str(l1["IALRT_RATE_15"] + l1["IALRT_RATE_16"])
-                ),
-                "hit_e_b_side_high_en": Decimal(str(l1["IALRT_RATE_17"])),
-                "hit_h_omni_med_en": Decimal(str(l1["H_12_15"] + l1["H_15_70"])),
-                "hit_h_a_side_high_en": Decimal(str(l1["IALRT_RATE_8"])),
-                "hit_h_b_side_high_en": Decimal(str(l1["IALRT_RATE_18"])),
-                "hit_he_omni_low_en": Decimal(str(l1["HE4_06_08"])),
-                "hit_he_omni_high_en": Decimal(str(l1["HE4_15_70"])),
+                "hit_e_a_side_low_en": int(l1["IALRT_RATE_1"] + l1["IALRT_RATE_2"]),
+                "hit_e_a_side_med_en": int(l1["IALRT_RATE_5"] + l1["IALRT_RATE_6"]),
+                "hit_e_a_side_high_en": int(l1["IALRT_RATE_7"]),
+                "hit_e_b_side_low_en": int(l1["IALRT_RATE_11"] + l1["IALRT_RATE_12"]),
+                "hit_e_b_side_med_en": int(l1["IALRT_RATE_15"] + l1["IALRT_RATE_16"]),
+                "hit_e_b_side_high_en": int(l1["IALRT_RATE_17"]),
+                "hit_h_omni_med_en": int(l1["H_12_15"] + l1["H_15_70"]),
+                "hit_h_a_side_high_en": int(l1["IALRT_RATE_8"]),
+                "hit_h_b_side_high_en": int(l1["IALRT_RATE_18"]),
+                "hit_he_omni_low_en": int(l1["HE4_06_08"]),
+                "hit_he_omni_high_en": int(l1["HE4_15_70"]),
             }
         )
 

imap_processing/ialirt/l0/process_swapi.py

@@ -1,20 +1,144 @@
 """Functions to support I-ALiRT SWAPI processing."""
 
 import logging
+from decimal import Decimal
+from typing import Optional
 
 import numpy as np
+import pandas as pd
 import xarray as xr
-from xarray import DataArray
+from scipy.optimize import curve_fit
+from scipy.special import erf
 
+from imap_processing import imap_module_directory
+from imap_processing.ialirt.constants import IalirtSwapiConstants as Consts
 from imap_processing.ialirt.utils.grouping import find_groups
-
-# from imap_processing.swapi.l1.swapi_l1 import process_sweep_data
-# from imap_processing.swapi.l2.swapi_l2 import TIME_PER_BIN
+from imap_processing.ialirt.utils.time import calculate_time
+from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc
+from imap_processing.swapi.l1.swapi_l1 import process_sweep_data
+from imap_processing.swapi.l2.swapi_l2 import TIME_PER_BIN
 
 logger = logging.getLogger(__name__)
 
 
-def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
+def count_rate(
+    energy_pass: float, speed: float, density: float, temp: float
+) -> float | np.ndarray:
+    """
+    Compute SWAPI count rate for provided energy passband, speed, density and temp.
+
+    This model for coincidence count rate was developed by the SWAPI instrument
+    science team, detailed on page 52 of the IMAP SWAPI Instrument Algorithms Document.
+
+    Parameters
+    ----------
+    energy_pass : float
+        Energy passband [eV].
+    speed : float
+        Bulk solar wind speed [km/s].
+    density : float
+        Proton density [cm^-3].
+    temp : float
+        Temperature [K].
+
+    Returns
+    -------
+    count_rate : float | np.ndarray
+        Particle coincidence count rate.
+    """
+    # thermal velocity of solar wind ions
+    thermal_velocity = np.sqrt(2 * Consts.boltz * temp / Consts.prot_mass)
+    beta = 1 / (thermal_velocity**2)
+    # convert energy to Joules
+    center_speed = np.sqrt(2 * energy_pass * 1.60218e-19 / Consts.prot_mass)
+    speed = speed * 1000  # convert km/s to m/s
+    density = density * 1e6  # convert 1/cm**3 to 1/m**3
+
+    return (
+        (density * Consts.eff_area * (beta / np.pi) ** (3 / 2))
+        * (np.exp(-beta * (center_speed**2 + speed**2 - 2 * center_speed * speed)))
+        * np.sqrt(np.pi / (beta * speed * center_speed))
+        * erf(np.sqrt(beta * speed * center_speed) * (Consts.az_fov / 2))
+        * (
+            center_speed**4
+            * Consts.speed_ew
+            * np.arcsin(thermal_velocity / center_speed)
+        )
+    )
+
+
+def optimize_pseudo_parameters(
+    count_rates: np.ndarray,
+    count_rate_error: np.ndarray,
+    energy_passbands: Optional[np.ndarray] = None,
+) -> (dict)[str, list[float]]:
+    """
+    Find the pseudo speed (u), density (n) and temperature (T) of solar wind particles.
+
+    Fit a curve to calculated count rate values as a function of energy passband.
+
+    Parameters
+    ----------
+    count_rates : np.ndarray
+        Particle coincidence count rates.
+    count_rate_error : np.ndarray
+        Standard deviation of the coincidence count rates parameter.
+    energy_passbands : np.ndarray, default None
+        Energy passbands, passed in only for testing purposes.
+
+    Returns
+    -------
+    solution_dict : dict
+        Dictionary containing the optimized speed, density, and temperature values for
+        each sweep included in the input count_rates array.
+    """
+    if not energy_passbands:
+        # Read in energy passbands
+        energy_data = pd.read_csv(
+            f"{imap_module_directory}/tests/swapi/lut/imap_swapi_esa-unit"
+            f"-conversion_20250211_v000.csv"
+        )
+        energy_passbands = (
+            energy_data["Energy"][0:63]
+            .replace(",", "", regex=True)
+            .to_numpy()
+            .astype(float)
+        )
+
+    # Initial guess pulled from page 52 of the IMAP SWAPI Instrument Algorithms Document
+    initial_param_guess = np.array([550, 5.27, 1e5])
+    solution_dict = {  # type: ignore
+        "pseudo_speed": [],
+        "pseudo_density": [],
+        "pseudo_temperature": [],
+    }
+
+    for sweep in np.arange(count_rates.shape[0]):
+        current_sweep_count_rates = count_rates[sweep, :]
+        current_sweep_count_rate_errors = count_rate_error[sweep, :]
+        # Find the max count rate, and use the 6 points surrounding it (inclusive)
+        max_index = np.argmax(current_sweep_count_rates)
+        sol = curve_fit(
+            f=count_rate,
+            xdata=energy_passbands.take(
+                range(max_index - 3, max_index + 3), mode="wrap"
+            ),
+            ydata=current_sweep_count_rates.take(
+                range(max_index - 3, max_index + 3), mode="wrap"
+            ),
+            sigma=current_sweep_count_rate_errors.take(
+                range(max_index - 3, max_index + 3), mode="wrap"
+            ),
+            p0=initial_param_guess,
+        )
+        solution_dict["pseudo_speed"].append(sol[0][0])
+        solution_dict["pseudo_density"].append(sol[0][1])
+        solution_dict["pseudo_temperature"].append(sol[0][2])
+
+    return solution_dict
+
+
+def process_swapi_ialirt(unpacked_data: xr.Dataset) -> list[dict]:
     """
     Extract I-ALiRT variables and calculate coincidence count rate.
 
@@ -32,7 +156,21 @@ def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
 
     sci_dataset = unpacked_data.sortby("epoch", ascending=True)
 
-    grouped_dataset = find_groups(sci_dataset, (0, 11), "swapi_seq_number", "swapi_acq")
+    met = calculate_time(
+        sci_dataset["sc_sclk_sec"], sci_dataset["sc_sclk_sub_sec"], 256
+    )
+
+    # Add required parameters.
+    sci_dataset["met"] = met
+    met_values = []
+
+    grouped_dataset = find_groups(sci_dataset, (0, 11), "swapi_seq_number", "met")
+
+    if grouped_dataset.group.size == 0:
+        logger.warning(
+            "There was an issue with the SWAPI grouping process, returning empty data."
+        )
+        return [{}]
 
     for group in np.unique(grouped_dataset["group"]):
         # Sequence values for the group should be 0-11 with no duplicates.
@@ -40,6 +178,10 @@ def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
             (grouped_dataset["group"] == group)
         ]
 
+        met_values.append(
+            int(grouped_dataset["met"][(grouped_dataset["group"] == group).values][0])
+        )
+
         # Ensure no duplicates and all values from 0 to 11 are present
         if not np.array_equal(seq_values.astype(int), np.arange(12)):
             logger.info(
@@ -48,22 +190,29 @@ def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
             )
             continue
 
-    total_packets = len(grouped_dataset["swapi_seq_number"].data)
-
-    # It takes 12 sequence data to make one full SWAPI sweep
-    total_sequence = 12
-    total_full_sweeps = total_packets // total_sequence
-
-    met_values = grouped_dataset["swapi_shcoarse"].data.reshape(total_full_sweeps, 12)[
-        :, 0
-    ]
-
-    # raw_coin_count = process_sweep_data(grouped_dataset, "coin_cnt")
-    # raw_coin_rate = raw_coin_count / TIME_PER_BIN
-
-    swapi_data = {
-        "met": met_values
-        # more variables to go here
-    }
+    raw_coin_count = process_sweep_data(grouped_dataset, "swapi_coin_cnt")
+    raw_coin_rate = raw_coin_count / TIME_PER_BIN
+    count_rate_error = np.sqrt(raw_coin_count) / TIME_PER_BIN
+
+    solution = optimize_pseudo_parameters(raw_coin_rate, count_rate_error)
+
+    swapi_data = []
+
+    for entry in np.arange(0, len(solution["pseudo_speed"])):
+        swapi_data.append(
+            {
+                "apid": 478,
+                "met": met_values[entry],
+                "met_in_utc": met_to_utc(met_values[entry]).split(".")[0],
+                "ttj2000ns": int(met_to_ttj2000ns(met_values[entry])),
+                "swapi_pseudo_proton_speed": Decimal(solution["pseudo_speed"][entry]),
+                "swapi_pseudo_proton_density": Decimal(
+                    solution["pseudo_density"][entry]
+                ),
+                "swapi_pseudo_proton_temperature": Decimal(
+                    solution["pseudo_temperature"][entry]
+                ),
+            }
+        )
 
     return swapi_data

imap_processing/ialirt/l0/process_swe.py

@@ -1,7 +1,6 @@
 """Functions to support I-ALiRT SWE processing."""
 
 import logging
-from decimal import Decimal
 
 import numpy as np
 import pandas as pd
@@ -547,16 +546,10 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
             {
                 "apid": 478,
                 "met": int(grouped["met"].min()),
-                "utc": met_to_utc(grouped["met"].min()).split(".")[0],
+                "met_in_utc": met_to_utc(grouped["met"].min()).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(grouped["met"].min())),
-                **{
-                    f"swe_normalized_counts_quarter_1_esa_{i}": Decimal(str(val))
-                    for i, val in enumerate(summed_first)
-                },
-                **{
-                    f"swe_normalized_counts_quarter_2_esa_{i}": Decimal(str(val))
-                    for i, val in enumerate(summed_second)
-                },
+                "swe_normalized_counts_half_1_esa": [int(val) for val in summed_first],
+                "swe_normalized_counts_half_2_esa": [int(val) for val in summed_second],
                 "swe_counterstreaming_electrons": max(bde_first_half, bde_second_half),
             }
         )