imap-processing 0.19.3__py3-none-any.whl → 0.19.4__py3-none-any.whl

imap_processing/cli.py

@@ -51,7 +51,7 @@ from imap_processing.cdf.utils import load_cdf, write_cdf
 #   call cdf.utils.write_cdf
 from imap_processing.codice import codice_l1a, codice_l1b, codice_l2
 from imap_processing.glows.l1a.glows_l1a import glows_l1a
-from imap_processing.glows.l1b.glows_l1b import glows_l1b
+from imap_processing.glows.l1b.glows_l1b import glows_l1b, glows_l1b_de
 from imap_processing.glows.l2.glows_l2 import glows_l2
 from imap_processing.hi import hi_l1a, hi_l1b, hi_l1c, hi_l2
 from imap_processing.hit.l1a.hit_l1a import hit_l1a
@@ -682,55 +682,60 @@ class Glows(ProcessInstrument):
                     f"{science_files}."
                 )
             input_dataset = load_cdf(science_files[0])
+            if "hist" in self.descriptor:
+                # Create file lists for each ancillary type
+                excluded_regions_files = dependencies.get_processing_inputs(
+                    descriptor="map-of-excluded-regions"
+                )[0]
+                uv_sources_files = dependencies.get_processing_inputs(
+                    descriptor="map-of-uv-sources"
+                )[0]
+                suspected_transients_files = dependencies.get_processing_inputs(
+                    descriptor="suspected-transients"
+                )[0]
+                exclusions_by_instr_team_files = dependencies.get_processing_inputs(
+                    descriptor="exclusions-by-instr-team"
+                )[0]
+                pipeline_settings = dependencies.get_processing_inputs(
+                    descriptor="pipeline-settings"
+                )[0]
 
-            # Create file lists for each ancillary type
-            excluded_regions_files = dependencies.get_processing_inputs(
-                descriptor="map-of-excluded-regions"
-            )[0]
-            uv_sources_files = dependencies.get_processing_inputs(
-                descriptor="map-of-uv-sources"
-            )[0]
-            suspected_transients_files = dependencies.get_processing_inputs(
-                descriptor="suspected-transients"
-            )[0]
-            exclusions_by_instr_team_files = dependencies.get_processing_inputs(
-                descriptor="exclusions-by-instr-team"
-            )[0]
-            pipeline_settings = dependencies.get_processing_inputs(
-                descriptor="pipeline-settings"
-            )[0]
-
-            # Use end date buffer for ancillary data
-            current_day = np.datetime64(
-                f"{self.start_date[:4]}-{self.start_date[4:6]}-{self.start_date[6:]}"
-            )
-            day_buffer = current_day + np.timedelta64(3, "D")
-
-            # Create combiners for each ancillary dataset
-            excluded_regions_combiner = GlowsAncillaryCombiner(
-                excluded_regions_files, day_buffer
-            )
-            uv_sources_combiner = GlowsAncillaryCombiner(uv_sources_files, day_buffer)
-            suspected_transients_combiner = GlowsAncillaryCombiner(
-                suspected_transients_files, day_buffer
-            )
-            exclusions_by_instr_team_combiner = GlowsAncillaryCombiner(
-                exclusions_by_instr_team_files, day_buffer
-            )
-            pipeline_settings_combiner = GlowsAncillaryCombiner(
-                pipeline_settings, day_buffer
-            )
+                # Use end date buffer for ancillary data
+                current_day = np.datetime64(
+                    f"{self.start_date[:4]}-{self.start_date[4:6]}-{self.start_date[6:]}"
+                )
+                day_buffer = current_day + np.timedelta64(3, "D")
 
-            datasets = [
-                glows_l1b(
-                    input_dataset,
-                    excluded_regions_combiner.combined_dataset,
-                    uv_sources_combiner.combined_dataset,
-                    suspected_transients_combiner.combined_dataset,
-                    exclusions_by_instr_team_combiner.combined_dataset,
-                    pipeline_settings_combiner.combined_dataset,
+                # Create combiners for each ancillary dataset
+                excluded_regions_combiner = GlowsAncillaryCombiner(
+                    excluded_regions_files, day_buffer
+                )
+                uv_sources_combiner = GlowsAncillaryCombiner(
+                    uv_sources_files, day_buffer
+                )
+                suspected_transients_combiner = GlowsAncillaryCombiner(
+                    suspected_transients_files, day_buffer
+                )
+                exclusions_by_instr_team_combiner = GlowsAncillaryCombiner(
+                    exclusions_by_instr_team_files, day_buffer
+                )
+                pipeline_settings_combiner = GlowsAncillaryCombiner(
+                    pipeline_settings, day_buffer
                 )
-            ]
+
+                datasets = [
+                    glows_l1b(
+                        input_dataset,
+                        excluded_regions_combiner.combined_dataset,
+                        uv_sources_combiner.combined_dataset,
+                        suspected_transients_combiner.combined_dataset,
+                        exclusions_by_instr_team_combiner.combined_dataset,
+                        pipeline_settings_combiner.combined_dataset,
+                    )
+                ]
+            else:
+                # Direct events
+                datasets = [glows_l1b_de(input_dataset)]
 
         if self.data_level == "l2":
             science_files = dependencies.get_file_paths(source="glows")
@@ -804,13 +809,26 @@ class Hi(ProcessInstrument):
             datasets = hi_l1c.hi_l1c(load_cdf(science_paths[0]), anc_paths[0])
         elif self.data_level == "l2":
             science_paths = dependencies.get_file_paths(source="hi", data_type="l1c")
-            # TODO get ancillary paths
-            geometric_factors_path = ""
-            esa_energies_path = ""
+            anc_dependencies = dependencies.get_processing_inputs(data_type="ancillary")
+            if len(anc_dependencies) != 3:
+                raise ValueError(
+                    f"Expected three ancillary dependencies for L2 processing including"
+                    f"cal-prod, esa-energies, and esa-eta-fit-factors."
+                    f"Got {[anc_dep.descriptor for anc_dep in anc_dependencies]}"
+                    "."
+                )
+            # Get individual L2 ancillary dependencies
+            # Strip the "45sensor" or "90sensor" off the ancillary descriptor and
+            # create a mapping from descriptor to path
+            l2_ancillary_path_dict = {
+                "-".join(dep.descriptor.split("-")[1:]): dep.imap_file_paths[
+                    0
+                ].construct_path()
+                for dep in anc_dependencies
+            }
             datasets = hi_l2.hi_l2(
                 science_paths,
-                geometric_factors_path,
-                esa_energies_path,
+                l2_ancillary_path_dict,
                 self.descriptor,
             )
         else:
@@ -1119,9 +1137,9 @@ class Mag(ProcessInstrument):
             input_data = [load_cdf(dep) for dep in science_files]
             # Input datasets can be in any order, and are validated within mag_l1c
             if len(input_data) == 1:
-                datasets = [mag_l1c(input_data[0])]
+                datasets = [mag_l1c(input_data[0], current_day)]
             elif len(input_data) == 2:
-                datasets = [mag_l1c(input_data[0], input_data[1])]
+                datasets = [mag_l1c(input_data[0], current_day, input_data[1])]
             else:
                 raise ValueError(
                     f"Invalid dependencies found for MAG L1C:"

imap_processing/codice/codice_l1a.py

@@ -325,11 +325,23 @@ class CoDICEL1aPipeline:
         # different depending on the data product). In any case, iterate over
         # the num_counters dimension to isolate the data for each counter so
         # each counter's data can be placed in a separate CDF data variable.
+        # For Lo SW species, all_data has shape (9, 16, 128, 1) -> (epochs,
+        # num_counters, num_energy_steps, num_spin_sectors)
+        if self._is_lo_species_dataset():
+            # For Lo species datasets, counters are the second dimension (index 1)
+            num_counters = all_data.shape[1]
+        else:
+            # For all other datasets, counters are the last dimension
+            num_counters = all_data.shape[-1]
+
         for counter, variable_name in zip(
-            range(all_data.shape[-1]), self.config["variable_names"], strict=False
+            range(num_counters), self.config["variable_names"], strict=False
         ):
             # Extract the counter data
-            counter_data = all_data[..., counter]
+            if self._is_lo_species_dataset():
+                counter_data = all_data[:, counter, :, :]
+            else:
+                counter_data = all_data[..., counter]
 
             # Get the CDF attributes
             descriptor = self.config["dataset_name"].split("imap_codice_l1a_")[-1]
@@ -708,10 +720,18 @@ class CoDICEL1aPipeline:
 
         # Reshape the data based on how it is written to the data array of
         # the packet data. The number of counters is the last dimension / axis.
-        reshape_dims = (
-            *self.config["dims"].values(),
-            self.config["num_counters"],
-        )
+        if self._is_lo_species_dataset():
+            # For Lo species datasets, counters are the first dimension
+            reshape_dims = (
+                self.config["num_counters"],
+                *self.config["dims"].values(),
+            )
+        else:
+            # For all other datasets, counters are the last dimension
+            reshape_dims = (
+                *self.config["dims"].values(),
+                self.config["num_counters"],
+            )
         for packet_data in self.raw_data:
             reshaped_packet_data = np.array(packet_data, dtype=np.uint32).reshape(
                 reshape_dims
@@ -725,6 +745,24 @@ class CoDICEL1aPipeline:
         # No longer need to keep the raw data around
         del self.raw_data
 
+    def _is_lo_species_dataset(self) -> bool:
+        """
+        Check if the current dataset is a Lo species dataset.
+
+        Lo species datasets have a different data structure where counters are the
+        second dimension (index 1) instead of the last dimension.
+
+        Returns
+        -------
+        bool
+            True if the dataset is a Lo species dataset
+            (lo-sw-species or lo-nsw-species), False otherwise.
+        """
+        return self.config["dataset_name"] in [
+            "imap_codice_l1a_lo-sw-species",
+            "imap_codice_l1a_lo-nsw-species",
+        ]
+
     def set_data_product_config(self, apid: int, dataset: xr.Dataset) -> None:
         """
         Set the various settings for defining the data products.

imap_processing/codice/codice_l1b.py

@@ -56,8 +56,6 @@ def convert_to_rates(
         "lo-sw-angular",
         "lo-nsw-priority",
         "lo-sw-priority",
-        "lo-nsw-species",
-        "lo-sw-species",
         "lo-ialirt",
     ]:
         # Applying rate calculation described in section 10.2 of the algorithm
@@ -66,14 +64,35 @@ def convert_to_rates(
         # time data array to match the data variable shape
         dims = [1] * dataset[variable_name].data.ndim
         dims[1] = 128
-        acq_times = dataset.acquisition_time_per_step.data.reshape(dims)
-
+        acq_times = dataset.acquisition_time_per_step.data.reshape(dims)  # (128)
         # Now perform the calculation
         rates_data = dataset[variable_name].data / (
             acq_times
-            * 1e-6  # Converting from microseconds to seconds
+            * 1e-3  # Converting from milliseconds to seconds
             * constants.L1B_DATA_PRODUCT_CONFIGURATIONS[descriptor]["num_spin_sectors"]
         )
+    elif descriptor in [
+        "lo-nsw-species",
+        "lo-sw-species",
+    ]:
+        # Applying rate calculation described in section 10.2 of the algorithm
+        # document
+        # In order to divide by acquisition times, we must reshape the acq
+        # time data array to match the data variable shape (epoch, esa_step, sector)
+        dims = [1] * dataset[variable_name].data.ndim
+        dims[1] = 128
+        acq_times = dataset.acquisition_time_per_step.data.reshape(dims)  # (128)
+        # acquisition time have an array of shape (128,). We match n_sector to that.
+        # Per CoDICE, fill first 127 with default value of 12. Then fill last with 11.
+        n_sector = np.full(128, 12, dtype=int)
+        n_sector[-1] = 11
+
+        # Now perform the calculation
+        rates_data = dataset[variable_name].data / (
+            acq_times
+            * 1e-3  # Converting from milliseconds to seconds
+            * n_sector[:, np.newaxis]  # Spin sectors
+        )
     elif descriptor in [
         "hi-counters-aggregated",
         "hi-counters-singles",
@@ -164,13 +183,23 @@ def process_codice_l1b(file_path: Path) -> xr.Dataset:
             l1b_dataset[variable_name].data = convert_to_rates(
                 l1b_dataset, descriptor, variable_name
             )
-
             # Set the variable attributes
             cdf_attrs_key = f"{descriptor}-{variable_name}"
             l1b_dataset[variable_name].attrs = cdf_attrs.get_variable_attributes(
                 cdf_attrs_key, check_schema=False
             )
 
+        if descriptor in ["lo-sw-species", "lo-nsw-species"]:
+            # Do not carry these variable attributes from L1a to L1b
+            drop_variables = [
+                "k_factor",
+                "nso_half_spin",
+                "sw_bias_gain_mode",
+                "st_bias_gain_mode",
+                "spin_period",
+            ]
+            l1b_dataset = l1b_dataset.drop_vars(drop_variables)
+
     logger.info(f"\nFinal data product:\n{l1b_dataset}\n")
 
     return l1b_dataset

imap_processing/codice/constants.py

@@ -214,17 +214,17 @@ HI_COUNTERS_AGGREGATED_ACTIVE_VARIABLES = {
     "spo": True,
     "reserved1": False,
     "mst": True,
-    "reserved2": False,
-    "reserved3": False,
+    "ssdo": True,
+    "stssd": True,
     "reserved4": False,
     "reserved5": False,
-    "low_tof_cutoff": False,
+    "low_tof_cutoff": True,
     "reserved6": False,
     "reserved7": False,
     "asic1_flag_invalid": True,
     "asic2_flag_invalid": True,
-    "asic1_channel_invalid": False,
-    "asic_2_channel_invalid": False,
+    "asic1_channel_invalid": True,
+    "asic2_channel_invalid": True,
 }
 HI_COUNTERS_AGGREGATED_VARIABLE_NAMES = [
     name
@@ -961,7 +961,11 @@ ESA_SWEEP_TABLE_ID_LOOKUP = {
 # use. Currently, LO Stepping table 0 is used for every plan_id/plan_step
 # combination, but may change in the future. These are defined in the "Lo
 # Stepping" tab of the "*-SCI-LUT-*.xml" spreadsheet that largely defines CoDICE
-# processing.
+# processing. Eg.
+#   (plan_id, plan_step) -> id of acquisition time
+#   (0, 0) -> 0
+
+
 LO_STEPPING_TABLE_ID_LOOKUP = {
     (0, 0): 0,
     (0, 1): 0,

imap_processing/ena_maps/ena_maps.py

@@ -1222,7 +1222,6 @@ class RectangularSkyMap(AbstractSkyMap):
         self,
         instrument: str,
         level: str,
-        frame: str,
         descriptor: str,
         sensor: str | None = None,
     ) -> xr.Dataset:
@@ -1235,8 +1234,6 @@ class RectangularSkyMap(AbstractSkyMap):
             Instrument name. "hi", "lo", "ultra".
         level : str
             Product level. "l2" or "l3".
-        frame : str
-            Map frame. "sf", "hf" or "hk".
         descriptor : str
             Descriptor for filename.
         sensor : str, optional
@@ -1318,16 +1315,14 @@ class RectangularSkyMap(AbstractSkyMap):
         )
 
         # Now set global attributes
-        map_attrs = cdf_attrs.get_global_attributes(
-            f"imap_{instrument}_{level}_enamap-{frame}"
-        )
+        map_attrs = cdf_attrs.get_global_attributes(f"imap_{instrument}_{level}_enamap")
         map_attrs["Spacing_degrees"] = str(self.spacing_deg)
         for key in ["Data_type", "Logical_source", "Logical_source_description"]:
             map_attrs[key] = map_attrs[key].format(
                 descriptor=descriptor,
                 sensor=sensor,
             )
-            # Always add the following attributes to the map
+        # Always add the following attributes to the map
         map_attrs.update(
             {
                 "Sky_tiling_type": self.tiling_type.value,

imap_processing/glows/l1b/glows_l1b.py

@@ -28,12 +28,12 @@ def glows_l1b(
     pipeline_settings_dataset: xr.Dataset,
 ) -> xr.Dataset:
     """
-    Will process the GLOWS L1B data and format the output datasets.
+    Will process the histogram GLOWS L1B data and format the output datasets.
 
     Parameters
     ----------
     input_dataset : xr.Dataset
-        Dataset of input values.
+        Dataset of input values for L1A histogram data.
     excluded_regions : xr.Dataset
         Dataset containing excluded sky regions with ecliptic coordinates. This
         is the output from GlowsAncillaryCombiner.
@@ -77,29 +77,37 @@ def glows_l1b(
     ) as f:
         ancillary_parameters = AncillaryParameters(json.loads(f.read()))
 
-    logical_source = (
-        input_dataset.attrs["Logical_source"][0]
-        if isinstance(input_dataset.attrs["Logical_source"], list)
-        else input_dataset.attrs["Logical_source"]
+    output_dataarrays = process_histogram(
+        input_dataset, ancillary_exclusions, ancillary_parameters, pipeline_settings
+    )
+    output_dataset = create_l1b_hist_output(
+        output_dataarrays, input_dataset["epoch"], input_dataset["bins"], cdf_attrs
     )
 
-    if "hist" in logical_source:
-        output_dataarrays = process_histogram(
-            input_dataset, ancillary_exclusions, ancillary_parameters, pipeline_settings
-        )
-        output_dataset = create_l1b_hist_output(
-            output_dataarrays, input_dataset["epoch"], input_dataset["bins"], cdf_attrs
-        )
+    return output_dataset
 
-    elif "de" in logical_source:
-        output_dataset = create_l1b_de_output(input_dataset, cdf_attrs)
 
-    else:
-        raise ValueError(
-            f"Logical_source {input_dataset.attrs['Logical_source']} for input file "
-            f"does not match histogram "
-            "('hist') or direct event ('de')."
-        )
+def glows_l1b_de(
+    input_dataset: xr.Dataset,
+) -> xr.Dataset:
+    """
+    Process GLOWS L1B direct events data.
+
+    Parameters
+    ----------
+    input_dataset : xr.Dataset
+        The input dataset to process.
+
+    Returns
+    -------
+    xr.Dataset
+        The processed L1B direct events dataset.
+    """
+    cdf_attrs = ImapCdfAttributes()
+    cdf_attrs.add_instrument_global_attrs("glows")
+    cdf_attrs.add_instrument_variable_attrs("glows", "l1b")
+
+    output_dataset = create_l1b_de_output(input_dataset, cdf_attrs)
 
     return output_dataset
 

imap_processing/hi/hi_l1a.py

@@ -57,23 +57,23 @@ TOTAL_COUNTERS = ("a_total", "b_total", "c_total", "fee_de_recd", "fee_de_sent")
 # This is a mapping of variable name to index when the dump_data in the
 # HVSCI MEMDMP packet is interpreted as an array of uint32 values.
 MEMDMP_DATA_INDS = {
-    "lastbin_shorten": 9,
+    "lastbin_shorten": 10,
     "coinc_length": 60,
     "de_timetag": 65,
-    "ab_min": 67,
-    "ab_max": 68,
-    "ac_min": 69,
-    "ac_max": 70,
-    "ba_min": 71,
-    "ba_max": 72,
-    "bc_min": 73,
-    "bc_max": 74,
-    "ca_min": 75,
-    "ca_max": 76,
-    "cb_min": 77,
-    "cb_max": 78,
-    "cc_min": 79,
-    "cc_max": 80,
+    "ab_max": 67,
+    "ab_min": 68,
+    "ac_max": 69,
+    "ac_min": 70,
+    "ba_max": 71,
+    "ba_min": 72,
+    "bc_max": 73,
+    "bc_min": 74,
+    "ca_max": 75,
+    "ca_min": 76,
+    "cb_max": 77,
+    "cb_min": 78,
+    "cc_max": 79,
+    "cc_min": 80,
     "cfd_dac_a": 82,
     "cfd_dac_b": 83,
     "cfd_dac_c": 84,
@@ -264,25 +264,40 @@ def create_de_dataset(de_data_dict: dict[str, npt.ArrayLike]) -> xr.Dataset:
         attrs=epoch_attrs,
     )
 
-    event_met_attrs = attr_mgr.get_variable_attributes(
-        "hi_de_event_met", check_schema=False
-    )
-    # For L1A DE, event_met is its own dimension, so we remove the DEPEND_0 attribute
-    _ = event_met_attrs.pop("DEPEND_0")
-
     # Compute the meta-event MET in seconds
     meta_event_met = (
         np.array(de_data_dict["esa_step_seconds"]).astype(np.float64)
         + np.array(de_data_dict["esa_step_milliseconds"]) * MILLISECOND_TO_S
     )
-    # Compute the MET of each event in seconds
-    # event MET = meta_event_met + de_clock
-    # See Hi Algorithm Document section 2.2.5
-    event_met_array = np.array(
-        meta_event_met[de_data_dict["ccsds_index"]]
-        + np.array(de_data_dict["de_tag"]) * DE_CLOCK_TICK_S,
-        dtype=event_met_attrs.pop("dtype"),
+
+    event_met_attrs = attr_mgr.get_variable_attributes(
+        "hi_de_event_met", check_schema=False
     )
+    # For L1A DE, event_met is its own dimension, so we remove the DEPEND_0 attribute
+    _ = event_met_attrs.pop("DEPEND_0")
+    event_met_dtype = event_met_attrs.pop("dtype")
+
+    # If there are no events, add a single event with fill values
+    if len(de_data_dict["de_tag"]) == 0:
+        logger.warning(
+            "No direct events found in SCIDE packets. "
+            "Creating a false DE entry with fill values."
+        )
+        for key in ["de_tag", "trigger_id", "tof_1", "tof_2", "tof_3", "ccsds_index"]:
+            attrs = attr_mgr.get_variable_attributes(f"hi_de_{key}", check_schema=False)
+            de_data_dict[key] = [attrs["FILLVAL"]]
+        event_met_array = np.array([event_met_attrs["FILLVAL"]], dtype=event_met_dtype)
+    else:
+        # Compute the MET of each event in seconds
+        # event MET = meta_event_met + de_clock
+        # See Hi Algorithm Document section 2.2.5
+        event_met_array = np.array(
+            meta_event_met[de_data_dict["ccsds_index"]]
+            + np.array(de_data_dict["de_tag"]) * DE_CLOCK_TICK_S,
+            dtype=event_met_dtype,
+        )
+
+    # Create the event_met coordinate
     event_met = xr.DataArray(
         event_met_array,
         name="event_met",
@@ -290,10 +305,12 @@ def create_de_dataset(de_data_dict: dict[str, npt.ArrayLike]) -> xr.Dataset:
         attrs=event_met_attrs,
     )
 
+    # Create a dataset with only coordinates
     dataset = xr.Dataset(
         coords={"epoch": epoch, "event_met": event_met},
     )
 
+    # Add variable to the dataset
     for var_name, data in de_data_dict.items():
         attrs = attr_mgr.get_variable_attributes(
             f"hi_de_{var_name}", check_schema=False
@@ -557,9 +574,12 @@ def finish_memdmp_dataset(input_ds: xr.Dataset) -> xr.Dataset:
         # offset index with a stride of the number of bytes in the dump
         # data divided by 4 (32-bit values).
         new_vars[new_var] = xr.DataArray(
-            data=full_uint32_data[offset::index_stride],
+            data=full_uint32_data[offset::index_stride].astype(np.uint32),
             dims=["epoch"],
         )
+        # Need to add one to de_timetag value
+        if new_var == "de_timetag":
+            new_vars[new_var].data += 1
 
     # Remove binary memory dump data and add parsed variables
     dataset = dataset.drop("dump_data")

imap_processing/hi/hi_l1b.py

@@ -158,6 +158,27 @@ def annotate_direct_events(
     return [l1b_de_dataset]
 
 
+def any_good_direct_events(dataset: xr.Dataset) -> bool:
+    """
+    Test dataset to see if there are any good direct events.
+
+    Datasets can have no good direct events when there were no DEs in a pointing.
+    In this case, due to restrictions with cdflib, we have to write a single
+    bad DE in the CDF.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        Run the check on this dataset.
+
+    Returns
+    -------
+    any_good_events : bool
+        True if there is at least one good direct event. False otherwise.
+    """
+    return bool(np.any(dataset["trigger_id"] != dataset["trigger_id"].attrs["FILLVAL"]))
+
+
 def compute_coincidence_type_and_tofs(
     dataset: xr.Dataset,
 ) -> dict[str, xr.DataArray]:
@@ -190,6 +211,9 @@ def compute_coincidence_type_and_tofs(
         len(dataset.event_met),
         att_manager_lookup_str="hi_de_{0}",
     )
+    # Check for no valid direct events.
+    if not any_good_direct_events(dataset):
+        return new_vars
 
     # compute masks needed for coincidence type and ToF calculations
     a_first = dataset.trigger_id.values == TriggerId.A
@@ -301,6 +325,9 @@ def de_nominal_bin_and_spin_phase(dataset: xr.Dataset) -> dict[str, xr.DataArray
         len(dataset.event_met),
         att_manager_lookup_str="hi_de_{0}",
     )
+    # Check for no valid direct events.
+    if not any_good_direct_events(dataset):
+        return new_vars
 
     # nominal_bin is the index number of the 90 4-degree bins that each DE would
     # be binned into in the histogram packet. The Hi histogram data is binned by
@@ -345,6 +372,10 @@ def compute_hae_coordinates(dataset: xr.Dataset) -> dict[str, xr.DataArray]:
         len(dataset.event_met),
         att_manager_lookup_str="hi_de_{0}",
     )
+    # Check for no valid direct events.
+    if not any_good_direct_events(dataset):
+        return new_vars
+
     # Per Section 2.2.5 of Algorithm Document, add 1/2 of tick duration
     # to MET before computing pointing.
     sclk_ticks = met_to_sclkticks(dataset.event_met.values + HALF_CLOCK_TICK_S)
@@ -387,6 +418,9 @@ def de_esa_energy_step(
         len(l1b_de_ds.epoch),
         att_manager_lookup_str="hi_de_{0}",
     )
+    # Check for no valid direct events.
+    if not any_good_direct_events(l1b_de_ds):
+        return new_vars
 
     # Get the LUT object using the HK data and esa-energies ancillary csv
     esa_energies_lut = pd.read_csv(esa_energies_anc, comment="#")