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

imap_processing/ena_maps/ena_maps.py

@@ -768,6 +768,7 @@ class AbstractSkyMap(ABC):
         pointing_set: PointingSet,
         value_keys: list[str] | None = None,
         index_match_method: IndexMatchMethod = IndexMatchMethod.PUSH,
+        pset_valid_mask: NDArray | None = None,
     ) -> None:
         """
         Project a pointing set's values to the map grid.
@@ -789,6 +790,10 @@ class AbstractSkyMap(ABC):
         index_match_method : IndexMatchMethod, optional
             The method of index matching to use for all values.
             Default is IndexMatchMethod.PUSH.
+        pset_valid_mask : NDArray, optional
+            A boolean mask of shape (number of pointing set pixels,) indicating
+            which pixels in the pointing set should be considered valid for projection.
+            If None, all pixels are considered valid. Default is None.
 
         Raises
         ------
@@ -801,6 +806,9 @@ class AbstractSkyMap(ABC):
             if value_key not in pointing_set.data.data_vars:
                 raise ValueError(f"Value key {value_key} not found in pointing set.")
 
+        if pset_valid_mask is None:
+            pset_valid_mask = np.ones(pointing_set.num_points, dtype=bool)
+
         if index_match_method is IndexMatchMethod.PUSH:
             # Determine the indices of the sky map grid that correspond to
             # each pixel in the pointing set.
@@ -860,22 +868,32 @@ class AbstractSkyMap(ABC):
                     value_array=raveled_pset_data,
                     projection_grid_shape=self.binning_grid_shape,
                     projection_indices=matched_indices_push,
+                    input_valid_mask=pset_valid_mask,
                 )
+                # TODO: we may need to allow for unweighted/weighted means here by
+                # dividing pointing_projected_values by some binned weights.
+                # For unweighted means, we could use the number of pointing set pixels
+                # that correspond to each map pixel as the weights.
+                self.data_1d[value_key] += pointing_projected_values
             elif index_match_method is IndexMatchMethod.PULL:
+                valid_map_mask = pset_valid_mask[matched_indices_pull]
                 # We know that there will only be one value per sky map pixel,
                 # so we can use the matched indices directly
-                pointing_projected_values = raveled_pset_data[..., matched_indices_pull]
+                pointing_projected_values = raveled_pset_data[
+                    ..., matched_indices_pull[valid_map_mask]
+                ]
+                # TODO: we may need to allow for unweighted/weighted means here by
+                # dividing pointing_projected_values by some binned weights.
+                # For unweighted means, we could use the number of pointing set pixels
+                # that correspond to each map pixel as the weights.
+                self.data_1d[value_key].values[..., valid_map_mask] += (
+                    pointing_projected_values
+                )
             else:
                 raise NotImplementedError(
                     "Only PUSH and PULL index matching methods are supported."
                 )
 
-            # TODO: we may need to allow for unweighted/weighted means here by
-            # dividing pointing_projected_values by some binned weights.
-            # For unweighted means, we could use the number of pointing set pixels
-            # that correspond to each map pixel as the weights.
-            self.data_1d[value_key] += pointing_projected_values
-
         # TODO: The max epoch needs to include the pset duration. Right now it
         #     is just capturing the start epoch. See issue #1747
         self.min_epoch = min(self.min_epoch, pointing_set.epoch)
@@ -1169,6 +1187,10 @@ class RectangularSkyMap(AbstractSkyMap):
         # Rewrap each data array in the data_1d to the original 2D grid shape
         rewrapped_data = {}
         for key in self.data_1d.data_vars:
+            # Don't rewrap non-spatial variables
+            if CoordNames.GENERIC_PIXEL.value not in self.data_1d[key].coords:
+                rewrapped_data[key] = self.data_1d[key]
+                continue
             # drop pixel dim from the end, and add the spatial coords as dims
             rewrapped_dims = [
                 dim
@@ -1274,18 +1296,17 @@ class RectangularSkyMap(AbstractSkyMap):
                     name=f"{coord_name}_delta",
                     dims=[coord_name],
                 )
-            # Add energy delta_minus and delta_plus variables
             elif coord_name == CoordNames.ENERGY_L2.value:
-                cdf_ds[f"{coord_name}_delta_minus"] = xr.DataArray(
-                    xr.full_like(cdf_ds[coord_name], np.nan),
-                    name=f"{coord_name}_delta",
-                    dims=[coord_name],
-                )
-                cdf_ds[f"{coord_name}_delta_plus"] = xr.DataArray(
-                    xr.full_like(cdf_ds[coord_name], np.nan),
-                    name=f"{coord_name}_delta",
-                    dims=[coord_name],
-                )
+                if f"{coord_name}_delta_minus" not in cdf_ds:
+                    raise KeyError(
+                        f"Required variable '{coord_name}_delta_minus' "
+                        f"not found in cdf Dataset."
+                    )
+                if f"{coord_name}_delta_plus" not in cdf_ds:
+                    raise KeyError(
+                        f"Required variable '{coord_name}_delta_plus' "
+                        f"not found in cdf Dataset."
+                    )
 
         # Object which holds CDF attributes for the map
         cdf_attrs = ImapCdfAttributes()

imap_processing/ena_maps/utils/corrections.py

@@ -0,0 +1,291 @@
+"""L2 corrections common to multiple IMAP ENA instruments."""
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from numpy.polynomial import Polynomial
+
+
+class PowerLawFluxCorrector:
+    """
+    IMAP-Lo flux correction algorithm implementation.
+
+    Based on Section 5 of the Mapping Algorithm Document. Applies corrections for
+    ESA transmission integration over energy bandpass using iterative
+    predictor-corrector scheme to estimate source fluxes from observed fluxes.
+
+    Parameters
+    ----------
+    coeffs_file : str or Path
+        Location of CSV file containing ESA transmission coefficients.
+    """
+
+    def __init__(self, coeffs_file: str | Path):
+        """Initialize PowerLawFluxCorrector."""
+        # Load the csv file
+        eta_coeffs_df = pd.read_csv(coeffs_file, index_col="esa_step")
+        # Create a lookup dictionary to get the correct np.polynomial.Polynomial
+        # for a given esa_step
+        coeff_columns = ["M0", "M1", "M2", "M3", "M4", "M5"]
+        self.polynomial_lookup = {
+            row.name: Polynomial(row[coeff_columns].values)
+            for _, row in eta_coeffs_df.iterrows()
+        }
+
+    def eta_esa(self, k: np.ndarray, gamma: np.ndarray) -> np.ndarray:
+        """
+        Calculate ESA transmission scale factor η_esa,k(γ) for each energy level.
+
+        Parameters
+        ----------
+        k : np.ndarray
+            Energy levels.
+        gamma : np.ndarray
+            Power-law slopes.
+
+        Returns
+        -------
+        np.ndarray
+            ESA transmission scale factors.
+        """
+        k = np.atleast_1d(k)
+        gamma = np.atleast_1d(gamma)
+        eta = np.empty_like(gamma)
+        for i, esa_step in enumerate(k):
+            eta[i] = self.polynomial_lookup[esa_step](gamma[i])
+            # Negative transmissions get set to 1
+            if eta[i] < 0:
+                eta[i] = 1
+
+        return eta
+
+    @staticmethod
+    def estimate_power_law_slope(
+        fluxes: np.ndarray,
+        energies: np.ndarray,
+        uncertainties: np.ndarray | None = None,
+    ) -> tuple[np.ndarray, np.ndarray | None]:
+        """
+        Estimate power-law slopes γ_k for each energy level using vectorized operations.
+
+        Implements equations (36)-(41) from the Mapping Algorithm Document v7
+        with proper boundary handling. Uses extended arrays with repeated
+        endpoints for unified calculation, and handles zero fluxes by falling
+        back to linear differencing or returning NaN where both central and
+        linear differencing fail.
+
+        Parameters
+        ----------
+        fluxes : np.ndarray
+            Array of differential fluxes [J_1, J_2, ..., J_7].
+        energies : np.ndarray
+            Array of energy levels [E_1, E_2, ..., E_7].
+        uncertainties : np.ndarray, optional
+            Array of flux uncertainties [δJ_1, δJ_2, ..., δJ_7].
+
+        Returns
+        -------
+        gamma : np.ndarray
+            Array of power-law slopes.
+        delta_gamma : np.ndarray or None
+            Array of uncertainty slopes (if uncertainties provided).
+        """
+        n_levels = len(fluxes)
+        gamma = np.full(n_levels, 0, dtype=float)
+        delta_gamma = (
+            np.full(n_levels, 0, dtype=float) if uncertainties is not None else None
+        )
+
+        # Create an array of indices that can be used to create a padded array where
+        # the padding duplicates the first element on the front and the last element
+        # on the end of the array
+        extended_inds = np.pad(np.arange(n_levels), 1, mode="edge")
+
+        # Compute logs, setting non-positive fluxes to NaN
+        log_fluxes = np.log(np.where(fluxes > 0, fluxes, np.nan))
+        log_energies = np.log(energies)
+        # Create extended arrays by repeating first and last values. This allows
+        # for linear differencing to be used on the ends and central differencing
+        # to be used on the interior of the array with a single vectorized equation.
+        # Interior points use central differencing equation:
+        #     gamma_k = ln(J_{k+1}/J_{k-1}) / ln(E_{k+1}/E_{k-1})
+        # Left boundary uses linear forward differencing:
+        #     gamma_k = ln(J_{k+1}/J_{k}) / ln(E_{k+1}/E_{k})
+        # Right boundary uses linear backward differencing:
+        #     gamma_k = ln(J_{k}/J_{k-1}) / ln(E_{k}/E_{k-1})
+        log_extended_fluxes = log_fluxes[extended_inds]
+        log_extended_energies = log_energies[extended_inds]
+
+        # Extract the left and right log values to use in slope calculation
+        left_log_fluxes = log_extended_fluxes[:-2]  # indices 0 to n_levels-1
+        right_log_fluxes = log_extended_fluxes[2:]  # indices 2 to n_levels+1
+        left_log_energies = log_extended_energies[:-2]
+        right_log_energies = log_extended_energies[2:]
+
+        # Compute power-law slopes for valid indices
+        central_valid = np.isfinite(left_log_fluxes) & np.isfinite(right_log_fluxes)
+        gamma[central_valid] = (
+            (right_log_fluxes - left_log_fluxes)
+            / (right_log_energies - left_log_energies)
+        )[central_valid]
+
+        # Compute uncertainty slopes
+        if uncertainties is not None:
+            with np.errstate(divide="ignore"):
+                rel_unc_sq = (uncertainties / fluxes) ** 2
+            extended_rel_unc_sq = rel_unc_sq[extended_inds]
+            delta_gamma = np.sqrt(
+                extended_rel_unc_sq[:-2] + extended_rel_unc_sq[2:]
+            ) / (log_extended_energies[2:] - log_extended_energies[:-2])
+            delta_gamma[~central_valid] = 0
+
+        # Handle one-sided differencing for points where central differencing failed
+        need_fallback = ~central_valid & np.isfinite(log_fluxes)
+        # Exclude first and last points since they already use the correct
+        # one-sided differencing
+        interior_fallback = np.zeros_like(need_fallback, dtype=bool)
+        interior_fallback[1:-1] = need_fallback[1:-1]
+
+        if np.any(interior_fallback):
+            indices = np.where(interior_fallback)[0]
+
+            for k in indices:
+                # For interior points: try forward first, then backward
+                if k < n_levels - 1 and np.isfinite(log_fluxes[k + 1]):
+                    gamma[k] = (log_fluxes[k + 1] - log_fluxes[k]) / (
+                        log_energies[k + 1] - log_energies[k]
+                    )
+
+                    # Compute uncertainty slope using same differencing
+                    if isinstance(delta_gamma, np.ndarray):
+                        delta_gamma[k] = np.sqrt(rel_unc_sq[k + 1] + rel_unc_sq[k]) / (
+                            log_energies[k + 1] - log_energies[k]
+                        )
+
+                elif k > 0 and np.isfinite(log_fluxes[k - 1]):
+                    gamma[k] = (log_fluxes[k] - log_fluxes[k - 1]) / (
+                        log_energies[k] - log_energies[k - 1]
+                    )
+
+                    # Compute uncertainty slope using same differencing
+                    if isinstance(delta_gamma, np.ndarray):
+                        delta_gamma[k] = np.sqrt(rel_unc_sq[k] + rel_unc_sq[k - 1]) / (
+                            log_energies[k] - log_energies[k - 1]
+                        )
+
+        return gamma, delta_gamma
+
+    def predictor_corrector_iteration(
+        self,
+        observed_fluxes: np.ndarray,
+        observed_uncertainties: np.ndarray,
+        energies: np.ndarray,
+        max_iterations: int = 20,
+        convergence_threshold: float = 0.005,
+    ) -> tuple[np.ndarray, np.ndarray, int]:
+        """
+        Estimate source fluxes using iterative predictor-corrector scheme.
+
+        Implements the algorithm from Appendix A of the Mapping Algorithm Document.
+
+        Parameters
+        ----------
+        observed_fluxes : np.ndarray
+            Array of observed fluxes.
+        observed_uncertainties : numpy.ndarray
+            Array of observed uncertainties.
+        energies : np.ndarray
+            Array of energy levels.
+        max_iterations : int, optional
+            Maximum number of iterations, by default 20.
+        convergence_threshold : float, optional
+            RMS convergence criterion, by default 0.005 (0.5%).
+
+        Returns
+        -------
+        source_fluxes : np.ndarray
+            Final estimate of source fluxes.
+        source_uncertainties : np.ndarray
+            Final estimate of source uncertainties.
+        n_iterations : int
+            Number of iterations run.
+        """
+        n_levels = len(observed_fluxes)
+        energy_levels = np.arange(n_levels) + 1
+
+        # Initial power-law estimate from observed fluxes
+        gamma_initial, _ = self.estimate_power_law_slope(observed_fluxes, energies)
+
+        # Initial source flux estimate
+        eta_initial = self.eta_esa(energy_levels, gamma_initial)
+        source_fluxes_n = observed_fluxes / eta_initial
+
+        for _iteration in range(max_iterations):
+            # Store previous iteration
+            source_fluxes_prev = source_fluxes_n.copy()
+
+            # Predictor step
+            gamma_pred, _ = self.estimate_power_law_slope(source_fluxes_n, energies)
+            gamma_half = 0.5 * (gamma_initial + gamma_pred)
+
+            # Predictor source flux estimate
+            eta_half = self.eta_esa(energy_levels, gamma_half)
+            source_fluxes_half = observed_fluxes / eta_half
+
+            # Corrector step
+            gamma_corr, _ = self.estimate_power_law_slope(source_fluxes_half, energies)
+            gamma_n = 0.5 * (gamma_pred + gamma_corr)
+
+            # Final source flux estimate for this iteration
+            eta_final = self.eta_esa(energy_levels, gamma_n)
+            source_fluxes_n = observed_fluxes / eta_final
+            source_uncertainties = observed_uncertainties / eta_final
+
+            # Check convergence
+            ratios_sq = (source_fluxes_n / source_fluxes_prev) ** 2
+            chi_n = np.sqrt(np.mean(ratios_sq)) - 1
+
+            if chi_n < convergence_threshold:
+                break
+
+        return source_fluxes_n, source_uncertainties, _iteration + 1
+
+    def apply_flux_correction(
+        self, flux: np.ndarray, flux_stat_unc: np.ndarray, energies: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Apply flux correction to observed fluxes.
+
+        Iterative predictor-corrector scheme is run on each spatial pixel
+        individually to correct fluxes and statistical uncertainties. This method
+        is intended to be used with the unwrapped data in the ena_maps.AbstractSkyMap
+        class or child classes.
+
+        Parameters
+        ----------
+        flux : numpy.ndarray
+            Input flux with shape (n_energy, n_spatial_pixels).
+        flux_stat_unc : np.ndarray
+            Statistical uncertainty for input fluxes. Shape must match the shape
+            of flux.
+        energies : numpy.ndarray
+            Array of energy levels in units of eV or keV.
+
+        Returns
+        -------
+        tuple[numpy.ndarray, numpy.ndarray]
+            Corrected fluxes and flux uncertainties.
+        """
+        corrected_flux = np.empty_like(flux)
+        corrected_flux_stat_unc = np.empty_like(flux_stat_unc)
+
+        # loop over spatial pixels (last dimension)
+        for i_pixel in range(flux.shape[-1]):
+            corrected_flux[:, i_pixel], corrected_flux_stat_unc[:, i_pixel], _ = (
+                self.predictor_corrector_iteration(
+                    flux[:, i_pixel], flux_stat_unc[:, i_pixel], energies
+                )
+            )
+
+        return corrected_flux, corrected_flux_stat_unc

imap_processing/ena_maps/utils/map_utils.py

@@ -15,6 +15,7 @@ def bin_single_array_at_indices(
     projection_grid_shape: tuple[int, ...],
     projection_indices: NDArray,
     input_indices: NDArray | None = None,
+    input_valid_mask: NDArray | None = None,
 ) -> NDArray:
     """
     Bin an array of values at the given indices.
@@ -39,6 +40,9 @@ def bin_single_array_at_indices(
         1 dimensional. May be non-unique, depending on the projection method.
         If None (default), an arange of the same length as the
         final axis of value_array is used.
+    input_valid_mask : NDArray, optional
+        Boolean mask array for valid values in input grid.
+        If None, all pixels are considered valid. Default is None.
 
     Returns
     -------
@@ -55,6 +59,8 @@ def bin_single_array_at_indices(
     """
     if input_indices is None:
         input_indices = np.arange(value_array.shape[-1])
+    if input_valid_mask is None:
+        input_valid_mask = np.ones(value_array.shape[-1], dtype=bool)
 
     # Both sets of indices must be 1D with the same number of elements
     if input_indices.ndim != 1 or projection_indices.ndim != 1:
@@ -69,20 +75,25 @@ def bin_single_array_at_indices(
             " projection indices."
         )
 
+    input_valid_mask = np.asarray(input_valid_mask, dtype=bool)
+    mask_idx = input_valid_mask[input_indices]
+
     num_projection_indices = np.prod(projection_grid_shape)
 
+    # Only valid values are summed into bins.
     if value_array.ndim == 1:
+        values = value_array[input_indices]
         binned_values = np.bincount(
-            projection_indices,
-            weights=value_array[input_indices],
+            projection_indices[mask_idx],
+            weights=values[mask_idx],
             minlength=num_projection_indices,
         )
     elif value_array.ndim >= 2:
         # Apply bincount to each row independently
         binned_values = np.apply_along_axis(
             lambda x: np.bincount(
-                projection_indices,
-                weights=x[..., input_indices],
+                projection_indices[mask_idx],
+                weights=x[..., input_indices][mask_idx],
                 minlength=num_projection_indices,
             ),
             axis=-1,
@@ -96,6 +107,7 @@ def bin_values_at_indices(
     projection_grid_shape: tuple[int, ...],
     projection_indices: NDArray,
     input_indices: NDArray | None = None,
+    input_valid_mask: NDArray | None = None,
 ) -> dict[str, NDArray]:
     """
     Project values from input grid to projection grid based on matched indices.
@@ -118,6 +130,9 @@ def bin_values_at_indices(
         Ordered indices for input grid, corresponding to indices in projection grid.
         1 dimensional. May be non-unique, depending on the projection method.
         If None (default), behavior is determined by bin_single_array_at_indices.
+    input_valid_mask : NDArray, optional
+        Boolean mask array for valid values in input grid.
+        If None, all pixels are considered valid. Default is None.
 
     Returns
     -------
@@ -137,6 +152,7 @@ def bin_values_at_indices(
             projection_grid_shape=projection_grid_shape,
             projection_indices=projection_indices,
             input_indices=input_indices,
+            input_valid_mask=input_valid_mask,
         )
 
     return binned_values_dict

imap_processing/glows/l1b/glows_l1b.py

@@ -14,7 +14,9 @@ from imap_processing.glows.l1b.glows_l1b_data import (
     AncillaryParameters,
     DirectEventL1B,
     HistogramL1B,
+    PipelineSettings,
 )
+from imap_processing.spice.time import et_to_datetime64, ttj2000ns_to_et
 
 
 def glows_l1b(
@@ -23,6 +25,7 @@ def glows_l1b(
     uv_sources: xr.Dataset,
     suspected_transients: xr.Dataset,
     exclusions_by_instr_team: xr.Dataset,
+    pipeline_settings_dataset: xr.Dataset,
 ) -> xr.Dataset:
     """
     Will process the GLOWS L1B data and format the output datasets.
@@ -43,6 +46,9 @@ def glows_l1b(
     exclusions_by_instr_team : xr.Dataset
         Dataset containing manual exclusions by instrument team with time-based masks.
         This is the output from GlowsAncillaryCombiner.
+    pipeline_settings_dataset : xr.Dataset
+        Dataset containing pipeline settings, including the L1B conversion table and
+        other ancillary parameters.
 
     Returns
     -------
@@ -53,6 +59,8 @@ def glows_l1b(
     cdf_attrs.add_instrument_global_attrs("glows")
     cdf_attrs.add_instrument_variable_attrs("glows", "l1b")
 
+    day = et_to_datetime64(ttj2000ns_to_et(input_dataset["epoch"].data[0]))
+
     # Create ancillary exclusions object from passed-in datasets
     ancillary_exclusions = AncillaryExclusions(
         excluded_regions=excluded_regions,
@@ -60,6 +68,9 @@ def glows_l1b(
         suspected_transients=suspected_transients,
         exclusions_by_instr_team=exclusions_by_instr_team,
     )
+    pipeline_settings = PipelineSettings(
+        pipeline_settings_dataset.sel(epoch=day, method="nearest"),
+    )
 
     with open(
         Path(__file__).parents[1] / "ancillary" / "l1b_conversion_table_v001.json"
@@ -73,8 +84,11 @@ def glows_l1b(
     )
 
     if "hist" in logical_source:
+        output_dataarrays = process_histogram(
+            input_dataset, ancillary_exclusions, ancillary_parameters, pipeline_settings
+        )
         output_dataset = create_l1b_hist_output(
-            input_dataset, cdf_attrs, ancillary_parameters, ancillary_exclusions
+            output_dataarrays, input_dataset["epoch"], input_dataset["bins"], cdf_attrs
         )
 
     elif "de" in logical_source:
@@ -158,6 +172,7 @@ def process_histogram(
     l1a: xr.Dataset,
     ancillary_exclusions: AncillaryExclusions,
     ancillary_parameters: AncillaryParameters,
+    pipeline_settings: PipelineSettings,
 ) -> xr.Dataset:
     """
     Will process the histogram data from the L1A dataset and return the L1B dataset.
@@ -176,6 +191,8 @@ def process_histogram(
         The ancillary exclusions data for bad-angle flag processing.
     ancillary_parameters : AncillaryParameters
         The ancillary parameters for decoding histogram data.
+    pipeline_settings : PipelineSettings
+        The pipeline settings including flag activation.
 
     Returns
     -------
@@ -231,7 +248,7 @@ def process_histogram(
             Tuple of processed L1B data arrays from HistogramL1B.output_data().
         """
         return HistogramL1B(  # type: ignore[call-arg]
-            *args, ancillary_exclusions, ancillary_parameters
+            *args, ancillary_exclusions, ancillary_parameters, pipeline_settings
         ).output_data()
 
     l1b_fields = xr.apply_ufunc(
@@ -248,37 +265,39 @@ def process_histogram(
 
 
 def create_l1b_hist_output(
-    input_dataset: xr.Dataset,
+    l1b_dataarrays: tuple[xr.DataArray],
+    epoch: xr.DataArray,
+    bin_coord: xr.DataArray,
     cdf_attrs: ImapCdfAttributes,
-    ancillary_parameters: AncillaryParameters,
-    ancillary_exclusions: AncillaryExclusions,
 ) -> xr.Dataset:
     """
     Create the output dataset for the L1B histogram data.
 
-    This function processes the input dataset and creates a new dataset with the
-    appropriate attributes and data variables. It uses the `process_histogram` function
-    to process the histogram data.
+    This function takes in the output from `process_histogram`, which is a tuple of
+    DataArrays matching the output L1B data variables, and assembles them into a
+    Dataset with the appropriate coordinates.
 
     Parameters
     ----------
-    input_dataset : xr.Dataset
-        The input L1A GLOWS Histogram dataset to process.
+    l1b_dataarrays : tuple[xr.DataArray]
+        The DataArrays for each variable in the L1B dataset. These align with the
+        fields in the HistogramL1B dataclass, which also describes each variable.
+    epoch : xr.DataArray
+        The epoch DataArray to use as a coordinate in the output dataset. Generally
+        equal to the L1A epoch.
+    bin_coord : xr.DataArray
+        An arange DataArray for the bins coordinate. Nominally expected to be equal to
+        `xr.DataArray(np.arange(number_of_bins_per_histogram), name="bins",
+        dims=["bins"])`. Pulled up from L1A.
     cdf_attrs : ImapCdfAttributes
         The CDF attributes to use for the output dataset.
-    ancillary_parameters : AncillaryParameters
-        The ancillary parameters to use for the output dataset. Generated from the
-        l1b conversion table and pipeline setting ancillary files.
-    ancillary_exclusions : AncillaryExclusions
-        The ancillary exclusions to use for the output dataset. Generated from
-        ancillary files.
 
     Returns
     -------
     output_dataset : xr.Dataset
         The output dataset with the processed histogram data and all attributes.
     """
-    data_epoch = input_dataset["epoch"]
+    data_epoch = epoch
     data_epoch.attrs = cdf_attrs.get_variable_attributes("epoch", check_schema=False)
 
     flag_data = xr.DataArray(
@@ -318,7 +337,7 @@ def create_l1b_hist_output(
     )
 
     bin_data = xr.DataArray(
-        input_dataset["bins"].data,
+        bin_coord.data,
         name="bins",
         dims=["bins"],
         attrs=cdf_attrs.get_variable_attributes("bins_attrs", check_schema=False),
@@ -331,10 +350,6 @@ def create_l1b_hist_output(
         attrs=cdf_attrs.get_variable_attributes("bins_label", check_schema=False),
     )
 
-    output_dataarrays = process_histogram(
-        input_dataset, ancillary_exclusions, ancillary_parameters
-    )
-
     output_dataset = xr.Dataset(
         coords={
             "epoch": data_epoch,
@@ -352,7 +367,7 @@ def create_l1b_hist_output(
     # HistogramL1B dataclass, we can use dataclasses.fields to get the field names.
 
     fields = dataclasses.fields(HistogramL1B)
-    for index, dataarray in enumerate(output_dataarrays):
+    for index, dataarray in enumerate(l1b_dataarrays):
         # Dataarray is already an xr.DataArray type, so we can just assign it
         output_dataset[fields[index].name] = dataarray
         output_dataset[fields[index].name].attrs = cdf_attrs.get_variable_attributes(