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

imap_processing/ialirt/l0/parse_mag.py

@@ -1,6 +1,7 @@
 """Functions to support I-ALiRT MAG packet parsing."""
 
 import logging
+from typing import Union
 
 import numpy as np
 import xarray as xr
@@ -13,6 +14,13 @@ from imap_processing.ialirt.l0.mag_l0_ialirt_data import (
 )
 from imap_processing.ialirt.utils.grouping import find_groups
 from imap_processing.ialirt.utils.time import calculate_time
+from imap_processing.mag.l1a.mag_l1a_data import TimeTuple
+from imap_processing.mag.l1b.mag_l1b import (
+    calibrate_vector,
+    retrieve_matrix_from_l1b_calibration,
+    shift_time,
+)
+from imap_processing.spice.time import met_to_ttj2000ns
 
 logger = logging.getLogger(__name__)
 
@@ -132,7 +140,13 @@ def extract_magnetic_vectors(science_values: xr.DataArray) -> dict:
     return vectors
 
 
-def get_time(grouped_data: xr.Dataset, group: int, pkt_counter: xr.DataArray) -> dict:
+def get_time(
+    grouped_data: xr.Dataset,
+    group: int,
+    pkt_counter: xr.DataArray,
+    time_shift_mago: xr.DataArray,
+    time_shift_magi: xr.DataArray,
+) -> dict:
     """
     Get the time for the grouped data.
 
@@ -144,12 +158,22 @@ def get_time(grouped_data: xr.Dataset, group: int, pkt_counter: xr.DataArray) ->
         Group number.
     pkt_counter : xr.DataArray
         Packet counter.
+    time_shift_mago : xr.DataArray
+        Time shift value mago.
+    time_shift_magi : xr.DataArray
+        Time shift value magi.
 
     Returns
     -------
     time_data : dict
         Coarse and fine time for Primary and Secondary Sensors.
+
+    Notes
+    -----
+    Packet id 0 is course and fine time for the primary sensor PRI.
+    Packet id 2 is the course time for the secondary sensor SEC.
     """
+    # Get the coarse and fine time for the primary and secondary sensors.
     pri_coarsetm = grouped_data["mag_acq_tm_coarse"][
         (grouped_data["group"] == group).values
     ][pkt_counter == 0]
@@ -166,17 +190,102 @@ def get_time(grouped_data: xr.Dataset, group: int, pkt_counter: xr.DataArray) ->
         (grouped_data["group"] == group).values
     ][pkt_counter == 2]
 
-    time_data = {
-        "pri_coarsetm": int(pri_coarsetm),
-        "pri_fintm": int(pri_fintm),
-        "sec_coarsetm": int(sec_coarsetm),
-        "sec_fintm": int(sec_fintm),
+    time_data: dict[str, Union[int, float]] = {
+        "pri_coarsetm": int(pri_coarsetm.item()),
+        "pri_fintm": int(pri_fintm.item()),
+        "sec_coarsetm": int(sec_coarsetm.item()),
+        "sec_fintm": int(sec_fintm.item()),
     }
 
+    primary_time = TimeTuple(int(pri_coarsetm.item()), int(pri_fintm.item()))
+    secondary_time = TimeTuple(int(sec_coarsetm.item()), int(sec_fintm.item()))
+    time_data_pri_met = primary_time.to_seconds()
+    time_data_primary_ttj2000ns = met_to_ttj2000ns(time_data_pri_met)
+    time_data["primary_epoch"] = shift_time(
+        time_data_primary_ttj2000ns, time_shift_mago
+    )
+    time_data_sec_met = secondary_time.to_seconds()
+    time_data_secondary_ttj2000ns = met_to_ttj2000ns(time_data_sec_met)
+    time_data["secondary_epoch"] = shift_time(
+        time_data_secondary_ttj2000ns, time_shift_magi
+    )
+
     return time_data
 
 
-def parse_packet(accumulated_data: xr.Dataset) -> list[dict]:
+def calculate_l1b(
+    grouped_data: xr.Dataset,
+    group: int,
+    pkt_counter: xr.DataArray,
+    science_data: dict,
+    status_data: dict,
+    calibration_dataset: xr.Dataset,
+) -> tuple[np.ndarray, np.ndarray, dict]:
+    """
+    Calculate equivalent of l1b data product.
+
+    Parameters
+    ----------
+    grouped_data : xr.Dataset
+        Grouped data.
+    group : int
+        Group number.
+    pkt_counter : xr.DataArray
+        Packet counter.
+    science_data : dict
+        Science data.
+    status_data : dict
+        Status data.
+    calibration_dataset : xr.Dataset
+        Calibration dataset.
+
+    Returns
+    -------
+    updated_vector_mago : numpy.ndarray
+        Calibrated mago vector.
+    updated_vector_magi : numpy.ndarray
+        Calibrated magi vector.
+    time_data : dict
+        Time data.
+    """
+    calibration_matrix_mago, time_shift_mago = retrieve_matrix_from_l1b_calibration(
+        calibration_dataset, is_mago=True
+    )
+    calibration_matrix_magi, time_shift_magi = retrieve_matrix_from_l1b_calibration(
+        calibration_dataset, is_mago=False
+    )
+
+    # Get time values for each group.
+    time_data = get_time(
+        grouped_data, group, pkt_counter, time_shift_mago, time_shift_magi
+    )
+
+    input_vector_mago = np.array(
+        [
+            science_data["pri_x"],
+            science_data["pri_y"],
+            science_data["pri_z"],
+            status_data["fob_range"],
+        ]
+    )
+    input_vector_magi = np.array(
+        [
+            science_data["sec_x"],
+            science_data["sec_y"],
+            science_data["sec_z"],
+            status_data["fib_range"],
+        ]
+    )
+
+    updated_vector_mago = calibrate_vector(input_vector_mago, calibration_matrix_mago)
+    updated_vector_magi = calibrate_vector(input_vector_magi, calibration_matrix_magi)
+
+    return updated_vector_mago, updated_vector_magi, time_data
+
+
+def process_packet(
+    accumulated_data: xr.Dataset, calibration_dataset: xr.Dataset
+) -> list[dict]:
     """
     Parse the MAG packets.
 
@@ -184,6 +293,8 @@ def parse_packet(accumulated_data: xr.Dataset) -> list[dict]:
     ----------
     accumulated_data : xr.Dataset
         Packets dataset accumulated over 1 min.
+    calibration_dataset : xr.Dataset
+        Calibration dataset.
 
     Returns
     -------
@@ -237,9 +348,26 @@ def parse_packet(accumulated_data: xr.Dataset) -> list[dict]:
             (grouped_data["group"] == group).values
         ]
         science_data = extract_magnetic_vectors(science_values)
-
-        # Get time values for each group.
-        time_data = get_time(grouped_data, group, pkt_counter)
+        updated_vector_mago, updated_vector_magi, time_data = calculate_l1b(
+            grouped_data,
+            group,
+            pkt_counter,
+            science_data,
+            status_data,
+            calibration_dataset,
+        )
+
+        # Note: primary = MAGo, secondary = MAGi.
+        science_data.update(
+            {
+                "calibrated_pri_x": updated_vector_mago[0],
+                "calibrated_pri_y": updated_vector_mago[1],
+                "calibrated_pri_z": updated_vector_mago[2],
+                "calibrated_sec_x": updated_vector_magi[0],
+                "calibrated_sec_y": updated_vector_magi[1],
+                "calibrated_sec_z": updated_vector_magi[2],
+            }
+        )
 
         mag_data.append({**status_data, **science_data, **time_data})
 

imap_processing/ialirt/l0/process_swapi.py

@@ -0,0 +1,69 @@
+"""Functions to support I-ALiRT SWAPI processing."""
+
+import logging
+
+import numpy as np
+import xarray as xr
+from xarray import DataArray
+
+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
+
+logger = logging.getLogger(__name__)
+
+
+def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
+    """
+    Extract I-ALiRT variables and calculate coincidence count rate.
+
+    Parameters
+    ----------
+    unpacked_data : xr.Dataset
+        SWAPI I-ALiRT data that has been parsed from the spacecraft packet.
+
+    Returns
+    -------
+    swapi_data : dict
+        Dictionary containing all data variables for SWAPI I-ALiRT product.
+    """
+    logger.info("Processing SWAPI.")
+
+    sci_dataset = unpacked_data.sortby("epoch", ascending=True)
+
+    grouped_dataset = find_groups(sci_dataset, (0, 11), "swapi_seq_number", "swapi_acq")
+
+    for group in np.unique(grouped_dataset["group"]):
+        # Sequence values for the group should be 0-11 with no duplicates.
+        seq_values = grouped_dataset["swapi_seq_number"][
+            (grouped_dataset["group"] == group)
+        ]
+
+        # 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(
+                f"SWAPI group {group} does not contain all sequence values from 0 to "
+                f"11 without duplicates."
+            )
+            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
+    }
+
+    return swapi_data

imap_processing/ialirt/l0/process_swe.py

@@ -1,4 +1,4 @@
-"""Functions to support I-ALiRT SWE packet parsing."""
+"""Functions to support I-ALiRT SWE processing."""
 
 import logging
 
@@ -9,7 +9,7 @@ from numpy.typing import NDArray
 
 from imap_processing.ialirt.utils.grouping import find_groups
 from imap_processing.swe.l1a.swe_science import decompressed_counts
-from imap_processing.swe.l1b.swe_l1b_science import (
+from imap_processing.swe.l1b.swe_l1b import (
     deadtime_correction,
     read_in_flight_cal_data,
 )
@@ -22,6 +22,16 @@ from imap_processing.swe.utils.swe_utils import combine_acquisition_time
 
 logger = logging.getLogger(__name__)
 
+# Energy bin lookup table (indexed by quarter cycle)
+ENERGY_BINS = np.array(
+    [
+        [1, 5, 7, 3],  # 0 to 14 (Q1)
+        [2, 6, 4, 0],  # 15 to 29 (Q2)
+        [3, 7, 5, 1],  # 30 to 44 (Q3)
+        [0, 4, 6, 2],  # 45 to 59 (Q4)
+    ]
+)
+
 
 def decompress_counts(raw_counts: NDArray) -> NDArray:
     """
@@ -36,6 +46,10 @@ def decompress_counts(raw_counts: NDArray) -> NDArray:
     -------
     counts : np.ndarray
         Array of decompressed counts with the same shape as raw_counts.
+
+    Notes
+    -----
+    CEM is channel electron multiplier.
     """
     decompression_table = np.array([decompressed_counts(i) for i in range(256)])
 
@@ -100,19 +114,9 @@ def prepare_raw_counts(grouped: xr.Dataset, cem_number: int = N_CEMS) -> NDArray
     )
     phi_bins = phi_to_bin(phi_values).astype(int)  # Get phi bin indices
 
-    # Energy bin lookup table (indexed by quarter cycle)
-    energy_bins = np.array(
-        [
-            [1, 5, 7, 3],  # 0-14 (first quarter cycle)
-            [2, 6, 4, 0],  # 15-29 (second quarter cycle)
-            [3, 7, 5, 1],  # 30-44 (third quarter cycle)
-            [0, 4, 6, 2],  # 45-59 (fourth quarter cycle)
-        ]
-    )
-
     # The first 15 seconds is the first quarter cycle, etc.
     quarter_cycles = np.floor(grouped["swe_seq"] / 15).astype(int)
-    e_bins = energy_bins[quarter_cycles]
+    e_bins = ENERGY_BINS[quarter_cycles]
 
     # Populate raw_counts
     for cem in range(1, cem_number + 1):  # 7 CEMs
@@ -168,21 +172,283 @@ def normalize_counts(counts: NDArray, latest_cal: pd.Series) -> NDArray:
     latest_cal = latest_cal.to_numpy()
 
     # Norm counts where counts are non-negative
-    # TODO: confirm fv is counts with Ruth
     norm_counts = counts * (latest_cal / GEOMETRIC_FACTORS)[:, np.newaxis]
     norm_counts[norm_counts < 0] = 0
 
     return norm_counts
 
 
-def process_swe(accumulated_data: xr.Dataset) -> list[dict]:
+def find_bin_offsets(
+    peak_bins: NDArray, offsets: tuple[int, int]
+) -> tuple[NDArray, NDArray]:
+    """
+    Find the bins with offsets from the peak bins.
+
+    Parameters
+    ----------
+    peak_bins : np.ndarray
+        Bins that correspond to the maximum counts at each energy.
+    offsets : tuple[int, int]
+        Offset values for the bins.
+
+    Returns
+    -------
+    bin_0 : np.ndarray
+        First bin used for the average.
+    bin_1 : np.ndarray
+        Second bin used for the average.
+    """
+    # Azimuth has 30 values.
+    # Therefore, anything greater than 30 should be wrapped around.
+    bin_0, bin_1 = (peak_bins + offsets[0]) % 30, (peak_bins + offsets[1]) % 30
+
+    return bin_0, bin_1
+
+
+def average_counts(
+    peak_bins: NDArray, summed_half_cycle: NDArray, offsets: tuple[int, int]
+) -> NDArray:
+    """
+    Get the counts value for the offset bins at each energy level and average them.
+
+    Parameters
+    ----------
+    peak_bins : np.ndarray
+        Bins that corresponds to the maximum counts at each energy.
+    summed_half_cycle : np.ndarray
+        Counts summed over the 7 CEM detectors.
+    offsets : tuple
+        Offset values for the bins.
+        Offsets +6 and +8 correspond to +90 degrees.
+        Offsets +14 and +16 correspond to 180 degrees.
+        Offsets -6 and -8 correspond to -90 degrees.
+
+    Returns
+    -------
+    avg_counts : np.ndarray
+        Average counts of offset bin.
+    """
+    # Find the bins with offsets from the peak bins.
+    bin_0, bin_1 = find_bin_offsets(peak_bins, offsets)
+
+    # Get the counts value for the offset bins at each energy level and average them.
+    row_idx = np.arange(len(peak_bins))
+    avg_counts = (
+        summed_half_cycle[row_idx, bin_0] + summed_half_cycle[row_idx, bin_1]
+    ) / 2
+
+    return avg_counts
+
+
+def find_min_counts(
+    summed_half_cycle: NDArray,
+) -> tuple[NDArray, NDArray, tuple[NDArray, NDArray, NDArray]]:
+    """
+    Find min counts (cmin), defined as the minimum of counts_180 and counts_90.
+
+    Parameters
+    ----------
+    summed_half_cycle : np.ndarray
+        Counts summed over the 7 CEM detectors.
+
+    Returns
+    -------
+    cpeak : np.ndarray
+        Maximum counts for each energy level.
+    cmin : np.ndarray
+        Minimum of counts_neg_90, counts_90, counts_180.
+    counts : tuple[np.ndarray, np.ndarray, np.ndarray]
+        Counts at +/- 90 and 180 degrees from peak.
+    """
+    # Find the maximum counts for each energy level
+    cpeak = np.max(summed_half_cycle, axis=1)
+
+    # Find the bin that corresponds to the maximum counts at each energy
+    peak_bin = np.argmax(summed_half_cycle, axis=1)
+
+    # Find the counts in each offset bins.
+    # Offsets +6 and +8 correspond to +90 degrees.
+    counts_90 = average_counts(peak_bin, summed_half_cycle, (6, 8))
+
+    # Find the counts in each offset bins.
+    # Offsets +14 and +16 correspond to 180 degrees.
+    counts_180 = average_counts(peak_bin, summed_half_cycle, (14, 16))
+
+    # Find the counts in each offset bins.
+    # Offsets -6 and -8 correspond to -90 degrees.
+    counts_neg_90 = average_counts(peak_bin, summed_half_cycle, (-6, -8))
+
+    counts_stacked = np.hstack(
+        [
+            counts_90[:, np.newaxis],
+            counts_180[:, np.newaxis],
+            counts_neg_90[:, np.newaxis],
+        ]
+    )
+
+    # Find the minimum value for each energy level
+    cmin = np.min(counts_stacked, axis=1)
+
+    return cpeak, cmin, (counts_neg_90, counts_90, counts_180)
+
+
+def determine_streaming(
+    numerator_1: NDArray,
+    numerator_2: NDArray,
+    denominator: NDArray,
+    threshold: float = 1.75,
+) -> NDArray:
+    """
+    Determine if any energy level satisfies the bidirectional streaming condition.
+
+    Parameters
+    ----------
+    numerator_1 : np.ndarray
+        For the first streaming check : cpeak.
+        For the second streaming check : ccem_1.
+    numerator_2 : np.ndarray
+        For the first streaming check : counts_180.
+        For the second streaming check : ccem_7.
+    denominator : np.ndarray
+        For both streaming checks: cmin.
+    threshold : float (optional)
+        Threshold value for the streaming condition.
+
+    Returns
+    -------
+    streaming_flag : np.ndarray
+        Array of 1s and 0s indicating if the condition is satisfied.
+    """
+    ratio_1 = numerator_1 / denominator
+    ratio_2 = numerator_2 / denominator
+
+    return ((ratio_1 > threshold) & (ratio_2 > threshold)).astype(int)
+
+
+def compute_bidirectional(
+    streaming_first_half: NDArray,
+    streaming_second_half: NDArray,
+    min_esa_steps: int = 3,
+) -> tuple[int, int]:
+    """
+    Compute the Bidirectional Electron parameter (BDE).
+
+    Parameters
+    ----------
+    streaming_first_half : np.ndarray
+        Array of 1s and 0s indicating bidirectional streaming for first half-cycle.
+    streaming_second_half : np.ndarray
+        Array of 1s and 0s indicating bidirectional streaming for second half-cycle.
+    min_esa_steps : int (optional)
+        Minimum number of ESA steps for bidirectional streaming.
+        If either of the half cycles has bidirectional streaming for
+        3/8 energies then bde = 1.
+
+    Returns
+    -------
+    bde : tuple
+        Indicator for counter-streaming.
+    """
+    count_first: int = int(np.sum(streaming_first_half))
+    count_second: int = int(np.sum(streaming_second_half))
+
+    return int(count_first >= min_esa_steps), int(count_second >= min_esa_steps)
+
+
+def azimuthal_check_counterstreaming(
+    summed_first_half: NDArray, summed_second_half: NDArray
+) -> tuple[int, int]:
+    """
+    Check if counterstreaming is observed in azimuthal angle direction.
+
+    Parameters
+    ----------
+    summed_first_half : np.ndarray
+        Counts summed over the 7 CEM detectors for first half-cycle.
+    summed_second_half : np.ndarray
+        Counts summed over the 7 CEM detectors for second half-cycle.
+
+    Returns
+    -------
+    bde : tuple
+        Indicator for counter-streaming.
+    """
+    # Find peaks, cmin, counts (-90, 90, 180)
+    cpeak_first_half, cmin_first_half, counts_first_half = find_min_counts(
+        summed_first_half
+    )
+    cpeak_second_half, cmin_second_half, counts_second_half = find_min_counts(
+        summed_second_half
+    )
+
+    # First search for counter-streaming
+    streaming_first_half = determine_streaming(
+        cpeak_first_half, counts_first_half[2], cmin_first_half
+    )
+    streaming_second_half = determine_streaming(
+        cpeak_second_half, counts_second_half[2], cmin_second_half
+    )
+
+    # If either of the half cycles has bidirectional streaming
+    # for 3/8 energies then bde = 1
+    bde_first_search = compute_bidirectional(
+        streaming_first_half, streaming_second_half
+    )
+
+    return bde_first_search
+
+
+def polar_check_counterstreaming(
+    summed_first_half: NDArray, summed_second_half: NDArray
+) -> tuple[int, int]:
     """
-    Create L1 data dictionary..
+    Check if counterstreaming is observed in the polar angle direction.
+
+    Parameters
+    ----------
+    summed_first_half : np.ndarray
+        Counts summed over the azimuth for first half-cycle.
+    summed_second_half : np.ndarray
+        Counts summed over the azimuth for second half-cycle.
+
+    Returns
+    -------
+    bde : tuple
+        Indicator for counter-streaming.
+    """
+    # Cmin is the average of the counts in CEMs 3, 4, and 5
+    cmin_first_half = summed_first_half[:, 2:5].mean(axis=1)
+    cmin_second_half = summed_second_half[:, 2:5].mean(axis=1)
+
+    # Determine if streaming is observed.
+    # Note: Bidirectional electron streaming at a given ESA step
+    # is identified if both c_cem1/cmin and c_cem7/cmin are > 1.75.
+    streaming_first_half = determine_streaming(
+        summed_first_half[:, 0], summed_first_half[:, 6], cmin_first_half
+    )
+    streaming_second_half = determine_streaming(
+        summed_second_half[:, 0], summed_second_half[:, 6], cmin_second_half
+    )
+
+    # If either of the half cycles has bidirectional streaming
+    # for 3/8 energies then bde = 1
+    bde_second_search = compute_bidirectional(
+        streaming_first_half, streaming_second_half
+    )
+
+    return bde_second_search
+
+
+def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list[dict]:
+    """
+    Create L1 data dictionary.
 
     Parameters
     ----------
     accumulated_data : xr.Dataset
         Packets dataset accumulated over 1 min.
+    in_flight_cal_files : list
+        List of path to the in-flight calibration files.
 
     Returns
     -------
@@ -209,7 +475,7 @@ def process_swe(accumulated_data: xr.Dataset) -> list[dict]:
 
         # Ensure no duplicates and all values from 0 to 59 are present
         if not np.array_equal(seq_values, np.arange(60)):
-            logger.warning(
+            logger.info(
                 f"Group {group} does not contain all values from 0 to "
                 f"59 without duplicates."
             )
@@ -237,16 +503,46 @@ def process_swe(accumulated_data: xr.Dataset) -> list[dict]:
         corrected_second_half = deadtime_correction(counts_second_half, 80 * 10**3)
 
         # Grab the latest calibration factor
-        in_flight_cal_df = read_in_flight_cal_data()
+        in_flight_cal_df = read_in_flight_cal_data(in_flight_cal_files)
         latest_cal = in_flight_cal_df.sort_values("met_time").iloc[-1][1::]
 
         normalized_first_half = normalize_counts(corrected_first_half, latest_cal)
         normalized_second_half = normalize_counts(corrected_second_half, latest_cal)
 
         # Sum over the 7 detectors
-        summed_first_half = np.sum(normalized_first_half, axis=1)  # noqa: F841
-        summed_second_half = np.sum(normalized_second_half, axis=1)  # noqa: F841
-
-        # TODO: will continue here
+        summed_first_half_cem = np.sum(normalized_first_half, axis=1)
+        summed_second_half_cem = np.sum(normalized_second_half, axis=1)
+        bde_first_search = azimuthal_check_counterstreaming(
+            summed_first_half_cem, summed_second_half_cem
+        )
+        # Sum over azimuth.
+        summed_first_half_az = np.sum(normalized_first_half, axis=2)
+        summed_second_half_az = np.sum(normalized_second_half, axis=2)
+        bde_second_search = polar_check_counterstreaming(
+            summed_first_half_az, summed_second_half_az
+        )
+
+        # BDE value
+        bde_first_half = max(bde_first_search[0], bde_second_search[0])
+        bde_second_half = max(bde_first_search[1], bde_second_search[1])
+
+        # For normalized counts each ESA step is summed
+        # over both azimuthal and polar angles
+        # Sum over CEMs (axis=1) and azimuths (axis=2)
+        summed_first = normalized_first_half.sum(axis=(1, 2))
+        summed_second = normalized_second_half.sum(axis=(1, 2))
+        times = np.unique(grouped["time_seconds"].values)
+
+        swe_data.append(
+            {
+                # Select times corresponding to energy level.
+                "met_first_half_cycle": times[[1, 0] * 4],
+                "met_second_half_cycle": times[[3, 2] * 4],
+                "normalized_counts_first_half_cycle": summed_first,
+                "normalized_counts_second_half_cycle": summed_second,
+                "bde_first_half_cycle": np.full(summed_first.shape, bde_first_half),
+                "bde_second_half_cycle": np.full(summed_second.shape, bde_second_half),
+            }
+        )
 
     return swe_data