imap-processing 0.19.0__py3-none-any.whl → 0.19.2__py3-none-any.whl

imap_processing/ultra/l1b/goodtimes.py

@@ -0,0 +1,112 @@
+"""Calculate Goodtimes."""
+
+import numpy as np
+import xarray as xr
+
+from imap_processing.ultra.l1b.quality_flag_filters import SPIN_QUALITY_FLAG_FILTERS
+from imap_processing.ultra.utils.ultra_l1_utils import create_dataset, extract_data_dict
+
+FILLVAL_UINT16 = 65535
+FILLVAL_FLOAT32 = -1.0e31
+FILLVAL_FLOAT64 = -1.0e31
+FILLVAL_UINT32 = 4294967295
+
+
+def calculate_goodtimes(extendedspin_dataset: xr.Dataset, name: str) -> xr.Dataset:
+    """
+    Create dataset with defined datatype for Goodtimes Data.
+
+    Parameters
+    ----------
+    extendedspin_dataset : xarray.Dataset
+        Dataset containing the data.
+    name : str
+        Name of the dataset.
+
+    Returns
+    -------
+    goodtimes_dataset : xarray.Dataset
+        Dataset containing the extendedspin data that remains after culling.
+    """
+    n_bins = extendedspin_dataset.dims["energy_bin_geometric_mean"]
+    # If the spin rate was too high or low then the spin should be thrown out.
+    # If the rates at any energy level are too high then throw out the entire spin.
+    good_mask = (
+        (
+            extendedspin_dataset["quality_attitude"]
+            & sum(flag.value for flag in SPIN_QUALITY_FLAG_FILTERS["quality_attitude"])
+        )
+        == 0
+    ) & (
+        (
+            (
+                extendedspin_dataset["quality_ena_rates"]
+                & sum(
+                    flag.value
+                    for flag in SPIN_QUALITY_FLAG_FILTERS["quality_ena_rates"]
+                )
+            )
+            == 0
+        ).all(dim="energy_bin_geometric_mean")
+    )
+    filtered_dataset = extendedspin_dataset.sel(
+        spin_number=extendedspin_dataset["spin_number"][good_mask]
+    )
+
+    data_dict = extract_data_dict(filtered_dataset)
+
+    goodtimes_dataset = create_dataset(data_dict, name, "l1b")
+
+    if goodtimes_dataset["spin_number"].size == 0:
+        goodtimes_dataset = goodtimes_dataset.drop_dims("spin_number")
+        goodtimes_dataset = goodtimes_dataset.expand_dims(spin_number=[FILLVAL_UINT32])
+        goodtimes_dataset["spin_start_time"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT64], dtype="float64"), dims=["spin_number"]
+        )
+        goodtimes_dataset["spin_period"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT64], dtype="float64"), dims=["spin_number"]
+        )
+        goodtimes_dataset["spin_rate"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT64], dtype="float64"), dims=["spin_number"]
+        )
+        goodtimes_dataset["start_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["stop_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["coin_pulses_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_FLOAT32], dtype="float32"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["rejected_events_per_spin"] = xr.DataArray(
+            np.array([FILLVAL_UINT32], dtype="uint32"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["quality_attitude"] = xr.DataArray(
+            np.array([FILLVAL_UINT16], dtype="uint16"), dims=["spin_number"]
+        )
+        goodtimes_dataset["quality_hk"] = xr.DataArray(
+            np.array([FILLVAL_UINT16], dtype="uint16"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["quality_instruments"] = xr.DataArray(
+            np.array([FILLVAL_UINT16], dtype="uint16"),
+            dims=["spin_number"],
+        )
+        goodtimes_dataset["quality_ena_rates"] = (
+            ("energy_bin_geometric_mean", "spin_number"),
+            np.full((n_bins, 1), FILLVAL_UINT16, dtype="uint16"),
+        )
+        goodtimes_dataset["ena_rates"] = (
+            ("energy_bin_geometric_mean", "spin_number"),
+            np.full((n_bins, 1), FILLVAL_FLOAT64, dtype="float64"),
+        )
+        goodtimes_dataset["ena_rates_threshold"] = (
+            ("energy_bin_geometric_mean", "spin_number"),
+            np.full((n_bins, 1), FILLVAL_FLOAT32, dtype="float32"),
+        )
+
+    return goodtimes_dataset

imap_processing/ultra/l1b/lookup_utils.py

@@ -345,7 +345,7 @@ def load_scattering_lookup_tables(ancillary_files: dict, instrument_id: int) ->
     # TODO remove the line below when the 45 sensor scattering coefficients are
     #  delivered.
     instrument_id = 90
-    descriptor = f"l1b-{instrument_id}sensor-scattering-calibration"
+    descriptor = f"l1b-{instrument_id}sensor-scattering-calibration-data"
     theta_grid = pd.read_csv(
         ancillary_files[descriptor], header=None, skiprows=7, nrows=241
     ).to_numpy(dtype=float)

imap_processing/ultra/l1b/ultra_l1b.py

@@ -3,9 +3,9 @@
 import xarray as xr
 
 from imap_processing.ultra.l1b.badtimes import calculate_badtimes
-from imap_processing.ultra.l1b.cullingmask import calculate_cullingmask
 from imap_processing.ultra.l1b.de import calculate_de
 from imap_processing.ultra.l1b.extendedspin import calculate_extendedspin
+from imap_processing.ultra.l1b.goodtimes import calculate_goodtimes
 
 
 def ultra_l1b(data_dict: dict, ancillary_files: dict) -> list[xr.Dataset]:
@@ -29,7 +29,7 @@ def ultra_l1b(data_dict: dict, ancillary_files: dict) -> list[xr.Dataset]:
     General flow:
     1. l1a data products are created (upstream to this code)
     2. l1b de is created here and dropped in s3 kicking off processing again
-    3. l1b extended, culling, badtimes created here
+    3. l1b extended, goodtimes, badtimes created here
     """
     output_datasets = []
 
@@ -72,22 +72,22 @@ def ultra_l1b(data_dict: dict, ancillary_files: dict) -> list[xr.Dataset]:
             output_datasets.append(extendedspin_dataset)
         elif (
             f"imap_ultra_l1b_{instrument_id}sensor-extendedspin" in data_dict
-            and f"imap_ultra_l1b_{instrument_id}sensor-cullingmask" in data_dict
+            and f"imap_ultra_l1b_{instrument_id}sensor-goodtimes" in data_dict
         ):
             badtimes_dataset = calculate_badtimes(
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-extendedspin"],
-                data_dict[f"imap_ultra_l1b_{instrument_id}sensor-cullingmask"][
+                data_dict[f"imap_ultra_l1b_{instrument_id}sensor-goodtimes"][
                     "spin_number"
                 ].values,
                 f"imap_ultra_l1b_{instrument_id}sensor-badtimes",
             )
             output_datasets.append(badtimes_dataset)
         elif f"imap_ultra_l1b_{instrument_id}sensor-extendedspin" in data_dict:
-            cullingmask_dataset = calculate_cullingmask(
+            goodtimes_dataset = calculate_goodtimes(
                 data_dict[f"imap_ultra_l1b_{instrument_id}sensor-extendedspin"],
-                f"imap_ultra_l1b_{instrument_id}sensor-cullingmask",
+                f"imap_ultra_l1b_{instrument_id}sensor-goodtimes",
             )
-            output_datasets.append(cullingmask_dataset)
+            output_datasets.append(goodtimes_dataset)
     if not output_datasets:
         raise ValueError("Data dictionary does not contain the expected keys.")
 

imap_processing/ultra/l1b/ultra_l1b_culling.py

@@ -31,6 +31,7 @@ SPIN_DURATION = 15  # Default spin duration in seconds.
 RateResult = namedtuple(
     "RateResult",
     [
+        "unique_spins",
         "start_per_spin",
         "stop_per_spin",
         "coin_per_spin",
@@ -249,8 +250,8 @@ def flag_rates(
         Quality flags.
     spin : NDArray
         Spin data.
-    energy_midpoints : NDArray
-        Energy midpoint data.
+    energy_bin_geometric_mean : NDArray
+        Energy bin geometric mean.
     n_sigma_per_energy_reshape : NDArray
         N sigma per energy.
     """
@@ -264,7 +265,7 @@ def flag_rates(
     threshold = get_n_sigma(count_rates, duration, sigma=sigma)
 
     bin_edges = np.array(UltraConstants.CULLING_ENERGY_BIN_EDGES)
-    energy_midpoints = np.sqrt(bin_edges[:-1] * bin_edges[1:])
+    energy_bin_geometric_mean = np.sqrt(bin_edges[:-1] * bin_edges[1:])
     spin = np.unique(spin_number)
 
     # Indices where the counts exceed the threshold
@@ -275,7 +276,7 @@ def flag_rates(
     quality_flags[:, 0] |= ImapRatesUltraFlags.FIRSTSPIN.value
     quality_flags[:, -1] |= ImapRatesUltraFlags.LASTSPIN.value
 
-    return quality_flags, spin, energy_midpoints, threshold
+    return quality_flags, spin, energy_bin_geometric_mean, threshold
 
 
 def compare_aux_univ_spin_table(
@@ -424,6 +425,8 @@ def get_pulses_per_spin(rates: xr.Dataset) -> RateResult:
 
     Returns
     -------
+    unique_spins : NDArray
+        Unique spin numbers.
     start_per_spin : NDArray
         Total start pulses per spin.
     stop_per_spin : NDArray
@@ -474,6 +477,7 @@ def get_pulses_per_spin(rates: xr.Dataset) -> RateResult:
     coin_per_spin = np.bincount(spin_idx, weights=coin_pulses)
 
     return RateResult(
+        unique_spins=unique_spins,
         start_per_spin=start_per_spin,
         stop_per_spin=stop_per_spin,
         coin_per_spin=coin_per_spin,

imap_processing/ultra/l1b/ultra_l1b_extended.py

@@ -12,7 +12,9 @@ from numpy import ndarray
 from numpy.typing import NDArray
 from scipy.interpolate import LinearNDInterpolator, RegularGridInterpolator
 
+from imap_processing.quality_flags import ImapDEOutliersUltraFlags
 from imap_processing.spice.spin import get_spin_data
+from imap_processing.spice.time import sct_to_et
 from imap_processing.ultra.constants import UltraConstants
 from imap_processing.ultra.l1b.lookup_utils import (
     get_angular_profiles,
@@ -552,7 +554,7 @@ def get_de_velocity(
     v_hat = velocities / np.linalg.norm(velocities, axis=1)[:, None]
     r_hat = -v_hat
 
-    return velocities, v_hat, r_hat
+    return velocities, -v_hat, -r_hat
 
 
 def get_ssd_tof(
@@ -837,25 +839,16 @@ def get_ctof(
     return ctof, magnitude_v
 
 
-def determine_species(tof: np.ndarray, path_length: np.ndarray, type: str) -> NDArray:
+def determine_species(e_bin: np.ndarray, type: str) -> NDArray:
     """
     Determine the species for pulse-height events.
 
-    Species is determined from the particle velocity.
-    For velocity, the particle TOF is normalized with respect
-    to a fixed distance dmin between the front and back detectors.
-    The normalized TOF is termed the corrected TOF (ctof).
-    Particle species are determined from ctof using thresholds.
-
-    Further description is available on pages 42-44 of
-    IMAP-Ultra Flight Software Specification document.
+    Species is determined using the computed e_bin.
 
     Parameters
     ----------
-    tof : np.ndarray
-        Time of flight of the SSD event (tenths of a nanosecond).
-    path_length : np.ndarray
-        Path length (r) (hundredths of a millimeter).
+    e_bin : np.ndarray
+        Computed e_bin.
     type : str
         Type of data (PH or SSD).
 
@@ -864,11 +857,17 @@ def determine_species(tof: np.ndarray, path_length: np.ndarray, type: str) -> ND
     species_bin : np.array
         Species bin.
     """
-    # Event TOF normalization to Z axis
-    ctof, _ = get_ctof(tof, path_length, type)
-    # Assign Species 1 ("H") to bins
-    # TODO: this is a placeholder for future species assignments.
-    species_bin = np.full(len(ctof), 1, dtype=np.uint8)
+    if type == "PH":
+        species_groups = UltraConstants.TOFXPH_SPECIES_GROUPS
+    if type == "SSD":
+        species_groups = UltraConstants.TOFXE_SPECIES_GROUPS
+
+    non_proton_bins = species_groups["non_proton"]
+    proton_bins = species_groups["proton"]
+
+    species_bin = np.full(e_bin.shape, fill_value=2, dtype=int)
+    species_bin[np.isin(e_bin, non_proton_bins)] = 0
+    species_bin[np.isin(e_bin, proton_bins)] = 1
 
     return species_bin
 
@@ -984,9 +983,9 @@ def get_eventtimes(
     Returns
     -------
     event_times : np.ndarray
-        Event times.
+        Event times in et.
     spin_starts : np.ndarray
-        Spin start times.
+        Spin start times in et.
     spin_period_sec : np.ndarray
         Spin period in seconds.
 
@@ -1007,7 +1006,7 @@ def get_eventtimes(
 
     event_times = spin_starts + spin_period_sec * (phase_angle / 720)
 
-    return event_times, spin_starts, spin_period_sec
+    return sct_to_et(event_times), sct_to_et(spin_starts), spin_period_sec
 
 
 def interpolate_fwhm(
@@ -1375,54 +1374,91 @@ def is_coin_ph_valid(
     etof: NDArray,
     xc: NDArray,
     xb: NDArray,
+    stop_north_tdc: NDArray,
+    stop_south_tdc: NDArray,
+    stop_east_tdc: NDArray,
+    stop_west_tdc: NDArray,
     sensor: str,
     ancillary_files: dict,
+    quality_flags: NDArray,
 ) -> NDArray:
     """
-    Determine whether Coincidence-PH data are valid.
-
-    This is based on thresholds defined in the IMAP-Ultra Flight Software Specification
-    (see page 36).
+    Determine event validity.
 
     Parameters
     ----------
     etof : NDArray
-        Electron TOF (tenths of a nanosecond).
+        Time for the electrons to travel back to the coincidence
+        anode (tenths of a nanosecond).
     xc : NDArray
-        Coincidence X position (hundredths of a mm).
+        X coincidence position (hundredths of a millimeter).
     xb : NDArray
-        Back X position (hundredths of a mm).
+        Back positions in x direction (hundredths of a millimeter).
+    stop_north_tdc : NDArray
+        Stop North Time to Digital Converter.
+    stop_south_tdc : NDArray
+        Stop South Time to Digital Converter.
+    stop_east_tdc : NDArray
+        Stop East Time to Digital Converter.
+    stop_west_tdc : NDArray
+        Stop West Time to Digital Converter.
     sensor : str
         Sensor name: "ultra45" or "ultra90".
     ancillary_files : dict
         Ancillary files for lookup.
+    quality_flags : NDArray
+        Quality flag to set when there is an outlier.
 
     Returns
     -------
-    valid_mask : NDArray
-        Boolean array indicating Coin-PH validity.
+    combined_mask : NDArray
+        Boolean array indicating whether back TOF is valid.
 
     Notes
     -----
-    Logic derived from page 36 of the IMAP-Ultra Flight Software Specification document.
+    From page 36 of the IMAP-Ultra Flight Software Specification document.
     """
-    etof_min = get_image_params("eTOFMin", sensor, ancillary_files)
-    etof_max = get_image_params("eTOFMax", sensor, ancillary_files)
-
-    etof_valid = (etof >= etof_min) & (etof <= etof_max)
+    # Make certain etof is within range for tenths of a nanosecond.
+    etof_valid = (etof >= UltraConstants.ETOFMIN_EVENTFILTER) & (
+        etof <= UltraConstants.ETOFMAX_EVENTFILTER
+    )
 
+    # Hundredths of a mm.
     diff_x = xc - xb
-    etof_offset1 = get_image_params("eTOFOff1", sensor, ancillary_files)
-    etof_offset2 = get_image_params("eTOFOff2", sensor, ancillary_files)
-    etof_slope1 = get_image_params("eTOFSlope1", sensor, ancillary_files)
-    etof_slope2 = get_image_params("eTOFSlope2", sensor, ancillary_files)
 
-    t1 = (etof - etof_offset1) * etof_slope1 / 1024
-    t2 = (etof - etof_offset2) * etof_slope2 / 1024
+    t1 = (
+        (etof - UltraConstants.ETOFOFF1_EVENTFILTER)
+        * UltraConstants.ETOFSLOPE1_EVENTFILTER
+        / 1024
+    )
+    t2 = (
+        (etof - UltraConstants.ETOFOFF2_EVENTFILTER)
+        * UltraConstants.ETOFSLOPE2_EVENTFILTER
+        / 1024
+    )
 
     condition_1 = (diff_x >= t1) & (diff_x <= t2)
     condition_2 = (diff_x >= -t2) & (diff_x <= -t1)
 
     spatial_valid = condition_1 | condition_2
 
-    return etof_valid & spatial_valid
+    sp_n_norm = get_norm(stop_north_tdc, "SpN", sensor, ancillary_files)
+    sp_s_norm = get_norm(stop_south_tdc, "SpS", sensor, ancillary_files)
+    sp_e_norm = get_norm(stop_east_tdc, "SpE", sensor, ancillary_files)
+    sp_w_norm = get_norm(stop_west_tdc, "SpW", sensor, ancillary_files)
+
+    tofx = sp_n_norm + sp_s_norm
+    tofy = sp_e_norm + sp_w_norm
+
+    # Units in tenths of a nanosecond
+    delta_tof = tofy - tofx
+
+    delta_tof_mask = (delta_tof >= UltraConstants.TOFDIFFTPMIN_EVENTFILTER) & (
+        delta_tof <= UltraConstants.TOFDIFFTPMAX_EVENTFILTER
+    )
+
+    combined_mask = etof_valid & spatial_valid & delta_tof_mask
+
+    quality_flags[~combined_mask] |= ImapDEOutliersUltraFlags.COINPH.value
+
+    return combined_mask

imap_processing/ultra/l1c/helio_pset.py

@@ -2,25 +2,27 @@
 
 import logging
 
+import astropy_healpix.healpy as hp
 import numpy as np
-import pandas as pd
 import xarray as xr
 
+from imap_processing.quality_flags import ImapPSETUltraFlags
 from imap_processing.spice.repoint import get_pointing_times
 from imap_processing.spice.time import (
     et_to_met,
     met_to_ttj2000ns,
-    sct_to_et,
     ttj2000ns_to_et,
 )
 from imap_processing.ultra.l1b.ultra_l1b_culling import get_de_rejection_mask
 from imap_processing.ultra.l1c.l1c_lookup_utils import (
-    calculate_pixels_within_scattering_threshold,
+    calculate_fwhm_spun_scattering,
     get_spacecraft_pointing_lookup_tables,
 )
+from imap_processing.ultra.l1c.ultra_l1c_culling import compute_culling_mask
 from imap_processing.ultra.l1c.ultra_l1c_pset_bins import (
     build_energy_bins,
     get_efficiencies_and_geometric_function,
+    get_energy_delta_minus_plus,
     get_helio_adjusted_data,
     get_spacecraft_exposure_times,
     get_spacecraft_histogram,
@@ -32,15 +34,14 @@ logger = logging.getLogger(__name__)
 
 def calculate_helio_pset(
     de_dataset: xr.Dataset,
-    extendedspin_dataset: xr.Dataset,
-    cullingmask_dataset: xr.Dataset,
+    goodtimes_dataset: xr.Dataset,
     rates_dataset: xr.Dataset,
     params_dataset: xr.Dataset,
     name: str,
     ancillary_files: dict,
     instrument_id: int,
-    species_id: int = 1,
-) -> xr.Dataset:
+    species_id: list,
+) -> xr.Dataset | None:
     """
     Create dictionary with defined datatype for Pointing Set Grid Data.
 
@@ -48,10 +49,8 @@ def calculate_helio_pset(
     ----------
     de_dataset : xarray.Dataset
         Dataset containing de data.
-    extendedspin_dataset : xarray.Dataset
-        Dataset containing extendedspin data.
-    cullingmask_dataset : xarray.Dataset
-        Dataset containing cullingmask data.
+    goodtimes_dataset : xarray.Dataset
+        Dataset containing goodtimes data.
     rates_dataset : xarray.Dataset
         Dataset containing image rates data.
     params_dataset : xarray.Dataset
@@ -62,8 +61,8 @@ def calculate_helio_pset(
         Ancillary files.
     instrument_id : int
         Instrument ID, either 45 or 90.
-    species_id : int
-        Species ID, default of 1 refers to Hydrogen.
+    species_id : List
+        Species ID.
 
     Returns
     -------
@@ -72,14 +71,14 @@ def calculate_helio_pset(
     """
     pset_dict: dict[str, np.ndarray] = {}
     # Select only the species we are interested in.
-    indices = np.where(de_dataset["species"].values == species_id)[0]
+    indices = np.where(np.isin(de_dataset["e_bin"].values, species_id))[0]
     species_dataset = de_dataset.isel(epoch=indices)
 
     rejected = get_de_rejection_mask(
         species_dataset["quality_scattering"].values,
         species_dataset["quality_outliers"].values,
     )
-    de_dataset = species_dataset.isel(epoch=~rejected)
+    species_dataset = species_dataset.isel(epoch=~rejected)
 
     v_mag_helio_spacecraft = np.linalg.norm(
         species_dataset["velocity_dps_helio"].values, axis=1
@@ -89,15 +88,6 @@ def calculate_helio_pset(
         / v_mag_helio_spacecraft[:, np.newaxis]
     )
     intervals, _, energy_bin_geometric_means = build_energy_bins()
-    counts, latitude, longitude, n_pix = get_spacecraft_histogram(
-        vhat_dps_helio,
-        species_dataset["energy_heliosphere"].values,
-        intervals,
-        nside=128,
-    )
-
-    healpix = np.arange(n_pix)
-
     # Get lookup table for FOR indices by spin phase step
     (
         for_indices_by_spin_phase,
@@ -106,26 +96,39 @@ def calculate_helio_pset(
         ra_and_dec,
         boundary_scale_factors,
     ) = get_spacecraft_pointing_lookup_tables(ancillary_files, instrument_id)
-    # Check that the number of rows in the lookup table matches the number of pixels
-    if for_indices_by_spin_phase.shape[0] != n_pix:
-        logger.warning(
-            "The lookup table is expected to have the same number of rows as "
-            "the number of HEALPix pixels."
+
+    logger.info("calculating spun FWHM scattering values.")
+    pixels_below_scattering, scattering_theta, scattering_phi, scattering_thresholds = (
+        calculate_fwhm_spun_scattering(
+            for_indices_by_spin_phase,
+            theta_vals,
+            phi_vals,
+            ancillary_files,
+            instrument_id,
         )
+    )
 
-    pixels_below_scattering = calculate_pixels_within_scattering_threshold(
-        for_indices_by_spin_phase, theta_vals, phi_vals, ancillary_files, instrument_id
+    nside = hp.npix2nside(for_indices_by_spin_phase.shape[0])
+    counts, latitude, longitude, n_pix = get_spacecraft_histogram(
+        vhat_dps_helio,
+        species_dataset["energy_heliosphere"].values,
+        intervals,
+        nside=nside,
+    )
+    helio_pset_quality_flags = np.full(
+        n_pix, ImapPSETUltraFlags.NONE.value, dtype=np.uint16
     )
-    # Calculate exposure
-    constant_exposure = ancillary_files["l1c-90sensor-dps-exposure"]
-    df_exposure = pd.read_csv(constant_exposure)
+    healpix = np.arange(n_pix)
+
+    logger.info("Calculating spacecraft exposure times with deadtime correction.")
     exposure_time, deadtime_ratios = get_spacecraft_exposure_times(
-        df_exposure,
         rates_dataset,
         params_dataset,
         pixels_below_scattering,
         boundary_scale_factors,
+        n_pix=n_pix,
     )
+    logger.info("Calculating spun efficiencies and geometric function.")
     # calculate efficiency and geometric function as a function of energy
     efficiencies, geometric_function = get_efficiencies_and_geometric_function(
         pixels_below_scattering,
@@ -136,11 +139,12 @@ def calculate_helio_pset(
         ancillary_files,
     )
     # Get midpoint timestamp for pointing.
-    # TODO remove sct_to_et conversion
     pointing_start, pointing_stop = get_pointing_times(
-        et_to_met(sct_to_et(species_dataset["event_times"].data[0]))
+        et_to_met(species_dataset["event_times"].data[0])
     )
     mid_time = ttj2000ns_to_et(met_to_ttj2000ns((pointing_start + pointing_stop) / 2))
+
+    logger.info("Adjusting data for helio frame.")
     exposure_time, efficiency, geometric_function = get_helio_adjusted_data(
         mid_time,
         exposure_time,
@@ -148,11 +152,26 @@ def calculate_helio_pset(
         efficiencies,
         ra_and_dec[:, 0],
         ra_and_dec[:, 1],
+        nside=nside,
     )
     sensitivity = efficiencies * geometric_function
 
-    # For ISTP, epoch should be the center of the time bin.
-    pset_dict["epoch"] = de_dataset.epoch.data[:1].astype(np.int64)
+    start: float = np.min(species_dataset["event_times"].values)
+    end: float = np.max(species_dataset["event_times"].values)
+
+    # Time bins in 30 minute intervals
+    time_bins = np.arange(start, end + 1800, 1800)
+
+    # Compute mask for culling the Earth
+    compute_culling_mask(
+        time_bins,
+        6378.1,  # Earth radius
+        helio_pset_quality_flags,
+        nside=nside,
+    )
+    pointing_start = met_to_ttj2000ns(pointing_start)
+    # Epoch should be the start of the pointing
+    pset_dict["epoch"] = np.atleast_1d(pointing_start).astype(np.int64)
     pset_dict["counts"] = counts[np.newaxis, ...]
     pset_dict["latitude"] = latitude[np.newaxis, ...]
     pset_dict["longitude"] = longitude[np.newaxis, ...]
@@ -167,6 +186,16 @@ def calculate_helio_pset(
     pset_dict["geometric_function"] = geometric_function
     pset_dict["dead_time_ratio"] = deadtime_ratios
     pset_dict["spin_phase_step"] = np.arange(len(deadtime_ratios))
+    pset_dict["quality_flags"] = helio_pset_quality_flags[np.newaxis, ...]
+
+    pset_dict["scatter_theta"] = scattering_theta
+    pset_dict["scatter_phi"] = scattering_phi
+    pset_dict["scatter_threshold"] = scattering_thresholds
+
+    # Add the energy delta plus/minus to the dataset
+    energy_delta_minus, energy_delta_plus = get_energy_delta_minus_plus()
+    pset_dict["energy_delta_minus"] = energy_delta_minus
+    pset_dict["energy_delta_plus"] = energy_delta_plus
 
     dataset = create_dataset(pset_dict, name, "l1c")