imap-processing 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

imap_processing/ena_maps/ena_maps.py

@@ -845,6 +845,7 @@ class AbstractSkyMap(ABC):
             raise KeyError(f"Value keys not found in pointing set: {missing_keys}")
 
         if pset_valid_mask is None:
+            logger.debug("No pset_valid_mask provided, using all pixels as valid.")
             pset_valid_mask = np.ones(pointing_set.num_points, dtype=bool)
 
         if index_match_method is IndexMatchMethod.PUSH:
@@ -906,7 +907,7 @@ class AbstractSkyMap(ABC):
                     stacked_valid_mask = pset_valid_mask.stack(
                         {CoordNames.GENERIC_PIXEL.value: pointing_set.spatial_coords}
                     )
-                    pset_valid_mask_bc, _ = xr.broadcast(data_bc, stacked_valid_mask)
+                    _, pset_valid_mask_bc = xr.broadcast(data_bc, stacked_valid_mask)
                     pset_valid_mask_values = pset_valid_mask_bc.values
                 else:
                     pset_valid_mask_values = pset_valid_mask

imap_processing/hi/hi_l1c.py

@@ -29,11 +29,12 @@ from imap_processing.spice.geometry import (
     frame_transform,
     frame_transform_az_el,
 )
+from imap_processing.spice.repoint import get_pointing_times
 from imap_processing.spice.spin import (
     get_instrument_spin_phase,
     get_spin_data,
 )
-from imap_processing.spice.time import ttj2000ns_to_et
+from imap_processing.spice.time import met_to_ttj2000ns, ttj2000ns_to_et
 
 N_SPIN_BINS = 3600
 SPIN_PHASE_BIN_EDGES = np.linspace(0, 1, N_SPIN_BINS + 1)
@@ -101,14 +102,14 @@ def generate_pset_dataset(
     config_df = CalibrationProductConfig.from_csv(calibration_prod_config_path)
 
     pset_dataset = empty_pset_dataset(
-        de_dataset.epoch.data[0],
+        de_dataset.ccsds_met.data.mean(),
         de_dataset.esa_energy_step,
         config_df.cal_prod_config.number_of_products,
         logical_source_parts["sensor"],
     )
-    pset_et = ttj2000ns_to_et(pset_dataset.epoch.data[0])
     # Calculate and add despun_z, hae_latitude, and hae_longitude variables to
     # the pset_dataset
+    pset_et = ttj2000ns_to_et(pset_dataset.epoch.data[0])
     pset_dataset.update(pset_geometry(pset_et, logical_source_parts["sensor"]))
     # Bin the counts into the spin-bins
     pset_dataset.update(pset_counts(pset_dataset.coords, config_df, de_dataset))
@@ -121,15 +122,16 @@ def generate_pset_dataset(
 
 
 def empty_pset_dataset(
-    epoch_val: int, l1b_energy_steps: xr.DataArray, n_cal_prods: int, sensor_str: str
+    l1b_met: float, l1b_energy_steps: xr.DataArray, n_cal_prods: int, sensor_str: str
 ) -> xr.Dataset:
     """
     Allocate an empty xarray.Dataset with appropriate pset coordinates.
 
     Parameters
     ----------
-    epoch_val : int
-        The starting epoch in J2000 TT nanoseconds for data in the PSET.
+    l1b_met : float
+        Any met from the input L1B DE dataset. This is used to query the
+        repoint-table data to get the start and end times of the pointing.
     l1b_energy_steps : xarray.DataArray
         The array of esa_energy_step data from the L1B DE product.
     n_cal_prods : int
@@ -148,13 +150,18 @@ def empty_pset_dataset(
 
     # preallocate coordinates xr.DataArrays
     coords = dict()
+
+    # Get the Pointing start and end times
+    pointing_mets = get_pointing_times(l1b_met)
+    epochs = met_to_ttj2000ns(np.asarray(pointing_mets))
+
     # epoch coordinate has only 1 entry for pointing set
     epoch_attrs = attr_mgr.get_variable_attributes("epoch", check_schema=False)
     epoch_attrs.update(
         attr_mgr.get_variable_attributes("hi_pset_epoch", check_schema=False)
     )
     coords["epoch"] = xr.DataArray(
-        np.array([epoch_val], dtype=np.int64),  # TODO: get dtype from cdf attrs?
+        np.array([epochs[0]], dtype=np.int64),
         name="epoch",
         dims=["epoch"],
         attrs=epoch_attrs,
@@ -201,6 +208,15 @@ def empty_pset_dataset(
 
     # Allocate the coordinate label variables
     data_vars = dict()
+    # Generate the epoch_delta variable
+    data_vars["epoch_delta"] = xr.DataArray(
+        np.diff(epochs),
+        name="epoch_delta",
+        dims=["epoch"],
+        attrs=attr_mgr.get_variable_attributes(
+            "hi_pset_epoch_delta", check_schema=False
+        ),
+    )
     # Generate label variables
     data_vars["esa_energy_step_label"] = xr.DataArray(
         coords["esa_energy_step"].values.astype(str),
@@ -257,7 +273,7 @@ def pset_geometry(pset_et: float, sensor_str: str) -> dict[str, xr.DataArray]:
     Returns
     -------
     geometry_vars : dict[str, xarray.DataArray]
-        Keys are variable names and values are data arrays.
+        Keys are variable names, and values are data arrays.
     """
     geometry_vars = create_dataset_variables(
         ["despun_z"], (1, 3), att_manager_lookup_str="hi_pset_{0}"

imap_processing/hi/hi_l2.py

@@ -156,8 +156,18 @@ def generate_hi_map(
         pset_valid_mask = None  # Default to no mask (full spin)
         if descriptor.spin_phase == "ram":
             pset_valid_mask = pset.data["ram_mask"]
+            logger.debug(
+                f"Using ram mask with shape: {pset_valid_mask.shape} "
+                f"containing {np.prod(pset_valid_mask.shape)} pixels,"
+                f"{np.sum(pset_valid_mask.values)} of which are True."
+            )
         elif descriptor.spin_phase == "anti":
             pset_valid_mask = ~pset.data["ram_mask"]
+            logger.debug(
+                f"Using anti-ram mask with shape: {pset_valid_mask.shape} "
+                f"containing {np.prod(pset_valid_mask.shape)} pixels,"
+                f"{np.sum(pset_valid_mask.values)} of which are True."
+            )
 
         # Project (bin) the PSET variables into the map pixels
         output_map.project_pset_values_to_map(

imap_processing/ialirt/calculate_ingest.py

@@ -9,7 +9,7 @@ from imap_processing.ialirt.constants import STATIONS
 logger = logging.getLogger(__name__)
 
 
-def find_tcp_connections(
+def find_tcp_connections(  # noqa: PLR0912
     start_file_creation: datetime,
     end_file_creation: datetime,
     lines: list,
@@ -35,8 +35,16 @@ def find_tcp_connections(
         Output dictionary with tcp connection info.
     """
     current_starts: dict[str, datetime | None] = {}
+    partners_opened = set()
 
     for line in lines:
+        # Note if this line appears.
+        if "Opened raw record file" in line:
+            station = line.split("Opened raw record file for ")[1].split(
+                " antenna_partner"
+            )[0]
+            partners_opened.add(station)
+
         if "antenna partner connection is" not in line:
             continue
 
@@ -84,6 +92,16 @@ def find_tcp_connections(
                 }
             )
 
+    # Handle stations with only "Opened raw record file" (no up/down)
+    for station in partners_opened:
+        if not realtime_summary["connection_times"][station]:
+            realtime_summary["connection_times"][station].append(
+                {
+                    "start": datetime.isoformat(start_file_creation),
+                    "end": datetime.isoformat(end_file_creation),
+                }
+            )
+
     # Filter out connection windows that are completely outside the time window
     for station in realtime_summary["connection_times"]:
         realtime_summary["connection_times"][station] = [

imap_processing/ialirt/constants.py

@@ -53,12 +53,6 @@ class StationProperties(NamedTuple):
 # Verified by Kiel and KSWC Observatory staff.
 # Notes: the KSWC station is not yet operational,
 # but will have the following properties:
-# "KSWC": StationProperties(
-#     longitude=126.2958,  # degrees East
-#     latitude=33.4273,  # degrees North
-#     altitude=0.1,  # approx 100 meters
-#     min_elevation_deg=5,  # 5 degrees is the requirement
-# ),
 STATIONS = {
     "Kiel": StationProperties(
         longitude=10.1808,  # degrees East
@@ -66,10 +60,22 @@ STATIONS = {
         altitude=0.1,  # approx 100 meters
         min_elevation_deg=5,  # 5 degrees is the requirement
     ),
+    "Korea": StationProperties(
+        longitude=126.2958,  # degrees East
+        latitude=33.4273,  # degrees North
+        altitude=0.1,  # approx 100 meters
+        min_elevation_deg=5,  # 5 degrees is the requirement
+    ),
     "Manaus": StationProperties(
         longitude=-59.969334,  # degrees East (negative = West)
         latitude=-2.891257,  # degrees North (negative = South)
         altitude=0.1,  # approx 100 meters
         min_elevation_deg=5,  # 5 degrees is the requirement
     ),
+    "SANSA": StationProperties(
+        longitude=27.714,  # degrees East (negative = West)
+        latitude=-25.888,  # degrees North (negative = South)
+        altitude=1.542,  # approx 1542 meters
+        min_elevation_deg=2,  # 5 degrees is the requirement
+    ),
 }

imap_processing/ialirt/generate_coverage.py

@@ -57,6 +57,9 @@ def generate_coverage(
 
     stations = {
         "Kiel": STATIONS["Kiel"],
+        "Korea": STATIONS["Korea"],
+        "Manaus": STATIONS["Manaus"],
+        "SANSA": STATIONS["SANSA"],
     }
     coverage_dict = {}
     outage_dict = {}

imap_processing/lo/l1b/lo_l1b.py

@@ -19,6 +19,7 @@ from imap_processing.lo.l1b.tof_conversions import (
 from imap_processing.spice.geometry import (
     SpiceFrame,
     cartesian_to_latitudinal,
+    frame_transform,
     instrument_pointing,
 )
 from imap_processing.spice.repoint import get_pointing_times
@@ -760,8 +761,10 @@ def set_bad_or_goodtimes(
     # the bin_start and bin_end are 6 degree bins and need to be converted to
     # 0.1 degree bins to align with the spin_bins, so multiply by 60
     time_mask = (epochs[:, None] >= times_start) & (epochs[:, None] <= times_end)
+    # The ancillary file binning uses 0-59 for the 6 degree bins, so add 1 to bin_end
+    # so the upper bound is inclusive of the full bin range.
     bin_mask = (spin_bins[:, None] >= times_df["bin_start"].values * 60) & (
-        spin_bins[:, None] <= times_df["bin_end"].values * 60
+        spin_bins[:, None] < (times_df["bin_end"].values + 1) * 60
     )
 
     # Combined mask for epochs that fall within the time and bin ranges
@@ -853,8 +856,15 @@ def set_pointing_bin(l1b_de: xr.Dataset) -> xr.Dataset:
     x = l1b_de["hae_x"]
     y = l1b_de["hae_y"]
     z = l1b_de["hae_z"]
+    # Convert from HAE to DPS coordinates
+    dps_xyz = frame_transform(
+        ttj2000ns_to_et(l1b_de["epoch"]),
+        np.column_stack((x, y, z)),
+        SpiceFrame.IMAP_HAE,
+        SpiceFrame.IMAP_DPS,
+    )
     # convert the pointing direction to latitudinal coordinates
-    direction = cartesian_to_latitudinal(np.column_stack((x, y, z)))
+    direction = cartesian_to_latitudinal(dps_xyz)
     # first column: radius (Not needed)
     # second column: longitude
     lons = direction[:, 1]

imap_processing/lo/l1c/lo_l1c.py

@@ -295,8 +295,8 @@ def create_pset_counts(
     data = np.column_stack(
         (
             de_filtered["esa_step"],
-            de_filtered["pointing_bin_lon"],
-            de_filtered["pointing_bin_lat"],
+            de_filtered["spin_bin"],
+            de_filtered["off_angle_bin"],
         )
     )
     # Create the histogram with 3600 longitude bins, 40 latitude bins, and 7 energy bins
@@ -341,7 +341,7 @@ def calculate_exposure_times(counts: xr.DataArray, l1b_de: xr.Dataset) -> xr.Dat
         The exposure times for the L1B Direct Event dataset.
     """
     data = np.column_stack(
-        (l1b_de["esa_step"], l1b_de["pointing_bin_lon"], l1b_de["pointing_bin_lat"])
+        (l1b_de["esa_step"], l1b_de["spin_bin"], l1b_de["off_angle_bin"])
     )
 
     result = binned_statistic_dd(

imap_processing/lo/l2/lo_l2.py

@@ -10,6 +10,7 @@ import xarray as xr
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.ena_maps import ena_maps
 from imap_processing.ena_maps.ena_maps import AbstractSkyMap, RectangularSkyMap
+from imap_processing.ena_maps.utils.corrections import PowerLawFluxCorrector
 from imap_processing.ena_maps.utils.naming import MapDescriptor
 from imap_processing.lo import lo_ancillary
 from imap_processing.spice.time import et_to_datetime64, ttj2000ns_to_et
@@ -77,7 +78,13 @@ def lo_l2(
     logger.info("Step 4: Calculating rates and intensities")
 
     # Determine if corrections are needed and prepare oxygen data if required
-    sputtering_correction, bootstrap_correction, o_map_dataset = _prepare_corrections(
+    (
+        sputtering_correction,
+        bootstrap_correction,
+        flux_correction,
+        o_map_dataset,
+        flux_factors,
+    ) = _prepare_corrections(
         map_descriptor, descriptor, sci_dependencies, anc_dependencies
     )
 
@@ -85,7 +92,9 @@ def lo_l2(
         dataset,
         sputtering_correction=sputtering_correction,
         bootstrap_correction=bootstrap_correction,
+        flux_correction=flux_correction,
         o_map_dataset=o_map_dataset,
+        flux_factors=flux_factors,
     )
 
     logger.info("Step 5: Finalizing dataset with attributes")
@@ -100,7 +109,7 @@ def _prepare_corrections(
     descriptor: str,
     sci_dependencies: dict,
     anc_dependencies: list,
-) -> tuple[bool, bool, xr.Dataset | None]:
+) -> tuple[bool, bool, bool, xr.Dataset | None, Path | None]:
     """
     Determine what corrections are needed and prepare oxygen dataset if required.
 
@@ -130,7 +139,9 @@ def _prepare_corrections(
     # Default values - no corrections needed
     sputtering_correction = False
     bootstrap_correction = False
+    flux_correction = False
     o_map_dataset = None
+    flux_factors: None | Path = None
 
     # Sputtering and bootstrap corrections are only applied to hydrogen ENA data
     # Guard against recursion: don't process oxygen for oxygen maps
@@ -145,7 +156,24 @@ def _prepare_corrections(
         sputtering_correction = True
         bootstrap_correction = True
 
-    return sputtering_correction, bootstrap_correction, o_map_dataset
+    if "raw" not in map_descriptor.principal_data:
+        flux_correction = True
+        try:
+            flux_factors = next(
+                x for x in anc_dependencies if "esa-eta-fit-factors" in str(x)
+            )
+        except StopIteration:
+            raise ValueError(
+                "No flux correction factor file found in ancillary dependencies"
+            ) from None
+
+    return (
+        sputtering_correction,
+        bootstrap_correction,
+        flux_correction,
+        o_map_dataset,
+        flux_factors,
+    )
 
 
 # =============================================================================
@@ -664,7 +692,9 @@ def calculate_all_rates_and_intensities(
     dataset: xr.Dataset,
     sputtering_correction: bool = False,
     bootstrap_correction: bool = False,
+    flux_correction: bool = False,
     o_map_dataset: xr.Dataset | None = None,
+    flux_factors: Path | None = None,
 ) -> xr.Dataset:
     """
     Calculate rates and intensities with proper error propagation.
@@ -679,8 +709,13 @@ def calculate_all_rates_and_intensities(
     bootstrap_correction : bool, optional
         Whether to apply bootstrap corrections to intensities.
         Default is False.
+    flux_correction : bool, optional
+        Whether to apply flux corrections to intensities.
+        Default is False.
     o_map_dataset : xr.Dataset, optional
         Dataset specifically for oxygen, needed for sputtering corrections.
+    flux_factors : Path, optional
+        Path to flux factor file for flux corrections.
 
     Returns
     -------
@@ -705,7 +740,13 @@ def calculate_all_rates_and_intensities(
     if bootstrap_correction:
         dataset = calculate_bootstrap_corrections(dataset)
 
-    # Step 6: Clean up intermediate variables
+    # Optional Step 6: Calculate flux corrections
+    if flux_correction:
+        if flux_factors is None:
+            raise ValueError("Flux factors file must be provided for flux corrections")
+        dataset = calculate_flux_corrections(dataset, flux_factors)
+
+    # Step 7: Clean up intermediate variables
     dataset = cleanup_intermediate_variables(dataset)
 
     return dataset
@@ -1084,6 +1125,56 @@ def calculate_bootstrap_corrections(dataset: xr.Dataset) -> xr.Dataset:
     return dataset
 
 
+def calculate_flux_corrections(dataset: xr.Dataset, flux_factors: Path) -> xr.Dataset:
+    """
+    Calculate flux corrections for intensities.
+
+    Uses the shared ena maps ``PowerLawFluxCorrector`` class to do the
+    correction calculations.
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        Dataset with count rates, geometric factors, and center energies.
+    flux_factors : Path
+        Path to the eta flux factor file to use for corrections. Read in as
+        an ancillary file in the preprocessing step.
+
+    Returns
+    -------
+    xr.Dataset
+        Dataset with calculated flux-corrected intensities and their
+        uncertainties for the specified species.
+    """
+    logger.info("Applying flux corrections")
+
+    # Flux correction
+    corrector = PowerLawFluxCorrector(flux_factors)
+    # FluxCorrector works on (energy, :) arrays, so we need to flatten the map
+    # spatial dimensions for the correction and then reshape back after.
+    input_shape = dataset["ena_intensity"].shape[1:]  # Exclude epoch dimension
+    intensity = dataset["ena_intensity"].values[0].reshape(len(dataset["energy"]), -1)
+    stat_uncert = (
+        dataset["ena_intensity_stat_uncert"]
+        .values[0]
+        .reshape(len(dataset["energy"]), -1)
+    )
+    corrected_intensity, corrected_stat_unc = corrector.apply_flux_correction(
+        intensity,
+        stat_uncert,
+        dataset["energy"].data,
+    )
+    # Add the size 1 epoch dimension back in to the corrected fluxes.
+    dataset["ena_intensity"].data = corrected_intensity.reshape(input_shape)[
+        np.newaxis, ...
+    ]
+    dataset["ena_intensity_stat_uncert"].data = corrected_stat_unc.reshape(input_shape)[
+        np.newaxis, ...
+    ]
+
+    return dataset
+
+
 def cleanup_intermediate_variables(dataset: xr.Dataset) -> xr.Dataset:
     """
     Remove intermediate variables that were only needed for calculations.

imap_processing/ultra/l1c/helio_pset.py

@@ -128,8 +128,8 @@ def calculate_helio_pset(
     healpix = np.arange(n_pix)
 
     # Get midpoint timestamp for pointing.
-    pointing_start, pointing_stop = get_pointing_times(
-        et_to_met(species_dataset["event_times"].data[0])
+    pointing_range_met = get_pointing_times(
+        et_to_met(species_dataset["event_times"].mean())
     )
     logger.info("Calculating spacecraft exposure times with deadtime correction.")
     exposure_time, deadtime_ratios = get_spacecraft_exposure_times(
@@ -137,8 +137,7 @@ def calculate_helio_pset(
         params_dataset,
         pixels_below_scattering,
         boundary_scale_factors,
-        pointing_start,
-        pointing_stop,
+        pointing_range_met,
         n_pix=n_pix,
     )
     logger.info("Calculating spun efficiencies and geometric function.")
@@ -164,7 +163,7 @@ def calculate_helio_pset(
         nside=nside,
     )
 
-    mid_time = ttj2000ns_to_et(met_to_ttj2000ns((pointing_start + pointing_stop) / 2))
+    mid_time = ttj2000ns_to_et(met_to_ttj2000ns((np.sum(pointing_range_met)) / 2))
 
     logger.info("Adjusting data for helio frame.")
     exposure_time, _efficiency, geometric_function = get_helio_adjusted_data(
@@ -191,9 +190,13 @@ def calculate_helio_pset(
         helio_pset_quality_flags,
         nside=nside,
     )
-    pointing_start = met_to_ttj2000ns(pointing_start)
+    # Convert pointing start and end time to ttj2000ns
+    pointing_range_ns = met_to_ttj2000ns(pointing_range_met)
     # Epoch should be the start of the pointing
-    pset_dict["epoch"] = np.atleast_1d(pointing_start).astype(np.int64)
+    pset_dict["epoch"] = np.atleast_1d(pointing_range_ns[0]).astype(np.int64)
+    pset_dict["epoch_delta"] = np.atleast_1d(np.diff(pointing_range_ns)).astype(
+        np.int64
+    )
     pset_dict["counts"] = counts[np.newaxis, ...]
     pset_dict["latitude"] = latitude[np.newaxis, ...]
     pset_dict["longitude"] = longitude[np.newaxis, ...]

imap_processing/ultra/l1c/spacecraft_pset.py

@@ -138,8 +138,8 @@ def calculate_spacecraft_pset(
     sensitivity = efficiencies * geometric_function
 
     # Get the start and stop times of the pointing period
-    pointing_start, pointing_stop = get_pointing_times(
-        float(et_to_met(species_dataset["event_times"].data[0]))
+    pointing_range_met = get_pointing_times(
+        float(et_to_met(species_dataset["event_times"].mean()))
     )
     # Calculate exposure times
     logger.info("Calculating spacecraft exposure times with deadtime correction.")
@@ -148,8 +148,7 @@ def calculate_spacecraft_pset(
         params_dataset,
         pixels_below_scattering,
         boundary_scale_factors,
-        pointing_start,
-        pointing_stop,
+        pointing_range_met,
         n_pix=n_pix,
     )
     logger.info("Calculating background rates.")
@@ -179,10 +178,13 @@ def calculate_spacecraft_pset(
         spacecraft_pset_quality_flags,
         nside=nside,
     )
-    # Convert pointing start time to ttj2000ns
-    pointing_start = met_to_ttj2000ns(pointing_start)
+    # Convert pointing start and end time to ttj2000ns
+    pointing_range_ns = met_to_ttj2000ns(pointing_range_met)
     # Epoch should be the start of the pointing
-    pset_dict["epoch"] = np.atleast_1d(pointing_start).astype(np.int64)
+    pset_dict["epoch"] = np.atleast_1d(pointing_range_ns[0]).astype(np.int64)
+    pset_dict["epoch_delta"] = np.atleast_1d(np.diff(pointing_range_ns)).astype(
+        np.int64
+    )
     pset_dict["counts"] = counts[np.newaxis, ...]
     pset_dict["latitude"] = latitude[np.newaxis, ...]
     pset_dict["longitude"] = longitude[np.newaxis, ...]

imap_processing/ultra/l1c/ultra_l1c_pset_bins.py

@@ -415,8 +415,7 @@ def get_spacecraft_exposure_times(
     params_dataset: xr.Dataset,
     pixels_below_scattering: list[list],
     boundary_scale_factors: NDArray,
-    pointing_start_met: float,
-    pointing_stop_met: float,
+    pointing_range_met: tuple[float, float],
     n_pix: int,
 ) -> tuple[NDArray, NDArray]:
     """
@@ -435,10 +434,8 @@ def get_spacecraft_exposure_times(
         below the FWHM scattering threshold.
     boundary_scale_factors : np.ndarray
         Boundary scale factors for each pixel at each spin phase.
-    pointing_start_met : float
-        Start time of the pointing period in mission elapsed time.
-    pointing_stop_met : float
-        Stop time of the pointing period in mission elapsed time.
+    pointing_range_met : tuple
+        Start and stop time of the pointing period in mission elapsed time.
     n_pix : int
         Number of HEALPix pixels.
 
@@ -465,8 +462,8 @@ def get_spacecraft_exposure_times(
     spin_data = get_spin_data()
     # Filter for spins only in pointing
     spin_data = spin_data[
-        (spin_data["spin_start_met"] >= pointing_start_met)
-        & (spin_data["spin_start_met"] <= pointing_stop_met)
+        (spin_data["spin_start_met"] >= pointing_range_met[0])
+        & (spin_data["spin_start_met"] <= pointing_range_met[1])
     ]
     # Get only valid spin data
     valid_mask = (spin_data["spin_phase_valid"].values == 1) & (

imap_processing/ultra/utils/ultra_l1_utils.py

@@ -102,6 +102,12 @@ def create_dataset(  # noqa: PLR0912
             "spin_phase_step",
         ]:
             continue
+        elif key == "epoch_delta":
+            dataset[key] = xr.DataArray(
+                data,
+                dims=["epoch"],
+                attrs=cdf_manager.get_variable_attributes(key, check_schema=False),
+            )
         elif key in velocity_keys:
             dataset[key] = xr.DataArray(
                 data,

{imap_processing-1.0.2.dist-info → imap_processing-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imap-processing
-Version: 1.0.2
+Version: 1.0.3
 Summary: IMAP Science Operations Center Processing
 License: MIT
 Keywords: IMAP,SDC,SOC,Science Operations