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

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(

imap_processing/glows/l1b/glows_l1b_data.py

@@ -681,7 +681,6 @@ class HistogramL1B:
     histogram: np.ndarray
     flight_software_version: str
     seq_count_in_pkts_file: int
-    # ancillary_data_files: np.ndarray TODO Add this
     first_spin_id: int
     last_spin_id: int
     flags_set_onboard: int  # TODO: this should be renamed in L1B
@@ -705,9 +704,7 @@ class HistogramL1B:
     imap_time_offset: np.double  # No conversion needed from l1a->l1b
     glows_start_time: np.double  # No conversion needed from l1a->l1b
     glows_time_offset: np.double  # No conversion needed from l1a->l1b
-    # unique_block_identifier: str = field(
-    #     init=False
-    # )  # Could be datetime TODO: Can't put a string in data
+    unique_block_identifier: str = field(init=False)
     imap_spin_angle_bin_cntr: np.ndarray = field(init=False)  # Same size as bins
     histogram_flag_array: np.ndarray = field(init=False)
     # These two are retrieved from spin data
@@ -724,10 +721,9 @@ class HistogramL1B:
     flags: np.ndarray = field(init=False)
     ancillary_exclusions: InitVar[AncillaryExclusions]
     ancillary_parameters: InitVar[AncillaryParameters]
+    pipeline_settings: InitVar[PipelineSettings]
     # TODO:
     # - Determine a good way to output flags as "human readable"
-    # - Add spice pieces
-    # - also unique identifiers
     # - Bad angle algorithm using SPICE locations
     # - Move ancillary file to AWS
 
@@ -739,6 +735,7 @@ class HistogramL1B:
         pulse_length_variance: np.double,
         ancillary_exclusions: AncillaryExclusions,
         ancillary_parameters: AncillaryParameters,
+        pipeline_settings: PipelineSettings,
     ) -> None:
         """
         Will process data.
@@ -759,6 +756,8 @@ class HistogramL1B:
             Ancillary exclusions data for bad-angle flag processing.
         ancillary_parameters : AncillaryParameters
             Ancillary parameters for decoding histogram data.
+        pipeline_settings : PipelineSettings
+            Pipeline settings for processing thresholds and flags.
         """
         # self.histogram_flag_array = np.zeros((2,))
         day = met_to_datetime64(self.imap_start_time)
@@ -804,9 +803,9 @@ class HistogramL1B:
         # is_inside_excluded_region, is_excluded_by_instr_team,
         # is_suspected_transient] x 3600 bins
         self.histogram_flag_array = self._compute_histogram_flag_array(day_exclusions)
-        # self.unique_block_identifier = np.datetime_as_string(
-        #     np.datetime64(int(self.imap_start_time), "ns"), "s"
-        # )
+        # Generate ISO datetime string using SPICE functions
+        datetime64_time = met_to_datetime64(self.imap_start_time)
+        self.unique_block_identifier = np.datetime_as_string(datetime64_time, "s")
         self.flags = np.ones((FLAG_LENGTH,), dtype=np.uint8)
 
     def update_spice_parameters(self) -> None:
@@ -852,7 +851,7 @@ class HistogramL1B:
             geometry.frame_transform(
                 time_range,
                 np.array([0, 0, 1]),
-                SpiceFrame.IMAP_DPS,
+                SpiceFrame.IMAP_SPACECRAFT,
                 SpiceFrame.ECLIPJ2000,
             )
         )
@@ -873,7 +872,7 @@ class HistogramL1B:
         )
         position = imap_state[:, :3]
         velocity = imap_state[:, 3:]
-        # averange and standard deviation over time (rows)
+        # average and standard deviation over time (rows)
         self.spacecraft_location_average = np.average(position, axis=0)
         self.spacecraft_location_std_dev = np.std(position, axis=0)
         self.spacecraft_velocity_average = np.average(velocity, axis=0)

imap_processing/hi/hi_l1c.py

@@ -19,7 +19,7 @@ from imap_processing.hi.hi_l1a import (
     HALF_CLOCK_TICK_S,
 )
 from imap_processing.hi.utils import (
-    CoincidenceBitmap,
+    CalibrationProductConfig,
     create_dataset_variables,
     full_dataarray,
     parse_sensor_number,
@@ -378,8 +378,9 @@ def pset_counts(
                 filtered_de_df["spin_phase"].to_numpy() * N_SPIN_BINS
             ).astype(int)
             # When iterating over rows of a dataframe, the names of the multi-index
-            # are not preserved. Below, `config_row.Index[0]` gets the cal_prod_num
-            # value from the namedtuple representing the dataframe row.
+            # are not preserved. Below, `config_row.Index[0]` gets the
+            # calibration_prod value from the namedtuple representing the
+            # dataframe row.
             np.add.at(
                 counts_var["counts"].data[0, i_esa, config_row.Index[0]],
                 spin_bin_indices,
@@ -684,109 +685,3 @@ def good_time_and_phase_mask(
     """
     # TODO: Implement this once we have Goodtimes data product defined.
     return np.full_like(tick_mets, True, dtype=bool)
-
-
-@pd.api.extensions.register_dataframe_accessor("cal_prod_config")
-class CalibrationProductConfig:
-    """
-    Register custom accessor for calibration product configuration DataFrames.
-
-    Parameters
-    ----------
-    pandas_obj : pandas.DataFrame
-        Object to run validation and use accessor functions on.
-    """
-
-    index_columns = (
-        "cal_prod_num",
-        "esa_energy_step",
-    )
-    tof_detector_pairs = ("ab", "ac1", "bc1", "c1c2")
-    required_columns = (
-        "coincidence_type_list",
-        *[
-            f"tof_{det_pair}_{limit}"
-            for det_pair in tof_detector_pairs
-            for limit in ["low", "high"]
-        ],
-    )
-
-    def __init__(self, pandas_obj: pd.DataFrame) -> None:
-        self._validate(pandas_obj)
-        self._obj = pandas_obj
-        self._add_coincidence_values_column()
-
-    def _validate(self, df: pd.DataFrame) -> None:
-        """
-        Validate the current configuration.
-
-        Parameters
-        ----------
-        df : pandas.DataFrame
-            Object to validate.
-
-        Raises
-        ------
-        AttributeError : If the dataframe does not pass validation.
-        """
-        for index_name in self.index_columns:
-            if index_name in df.index:
-                raise AttributeError(
-                    f"Required index {index_name} not present in dataframe."
-                )
-        # Verify that the Dataframe has all the required columns
-        for col in self.required_columns:
-            if col not in df.columns:
-                raise AttributeError(f"Required column {col} not present in dataframe.")
-        # TODO: Verify that the same ESA energy steps exist in all unique calibration
-        #   product numbers
-
-    def _add_coincidence_values_column(self) -> None:
-        """Generate and add the coincidence_type_values column to the dataframe."""
-        # Add a column that consists of the coincidence type strings converted
-        # to integer values
-        self._obj["coincidence_type_values"] = self._obj.apply(
-            lambda row: tuple(
-                CoincidenceBitmap.detector_hit_str_to_int(entry)
-                for entry in row["coincidence_type_list"]
-            ),
-            axis=1,
-        )
-
-    @classmethod
-    def from_csv(cls, path: Path) -> pd.DataFrame:
-        """
-        Read configuration CSV file into a pandas.DataFrame.
-
-        Parameters
-        ----------
-        path : pathlib.Path
-            Location of the Calibration Product configuration CSV file.
-
-        Returns
-        -------
-        dataframe : pandas.DataFrame
-            Validated calibration product configuration data frame.
-        """
-        df = pd.read_csv(
-            path,
-            index_col=cls.index_columns,
-            converters={"coincidence_type_list": lambda s: tuple(s.split("|"))},
-            comment="#",
-        )
-        # Force the _init_ method to run by using the namespace
-        _ = df.cal_prod_config.number_of_products
-        return df
-
-    @property
-    def number_of_products(self) -> int:
-        """
-        Get the number of calibration products in the current configuration.
-
-        Returns
-        -------
-        number_of_products : int
-            The maximum number of calibration products defined in the list of
-            calibration product definitions.
-        """
-        return len(self._obj.index.unique(level="cal_prod_num"))

imap_processing/hi/hi_l2.py

@@ -13,6 +13,7 @@ from imap_processing.ena_maps.ena_maps import (
     RectangularSkyMap,
 )
 from imap_processing.ena_maps.utils.naming import MapDescriptor
+from imap_processing.hi.utils import CalibrationProductConfig
 
 logger = logging.getLogger(__name__)
 
@@ -153,14 +154,25 @@ def generate_hi_map(
     output_map.data_1d["obs_date_range"] = xr.zeros_like(output_map.data_1d["obs_date"])
 
     # Rename and convert coordinate from esa_energy_step energy
-    esa_energies = esa_energy_lookup(
+    esa_df = esa_energy_df(
         esa_energies_path, output_map.data_1d["esa_energy_step"].data
     )
     output_map.data_1d = output_map.data_1d.rename({"esa_energy_step": "energy"})
-    output_map.data_1d = output_map.data_1d.assign_coords(energy=esa_energies)
-    # Set the energy_step_delta values
-    # TODO: get the correct energy delta values (they are set to NaN) in
-    #    output_map.build_cdf_dataset()
+    output_map.data_1d = output_map.data_1d.assign_coords(
+        energy=esa_df["nominal_central_energy"].values
+    )
+    # Set the energy_step_delta values to the energy bandpass half-width-half-max
+    energy_delta = esa_df["bandpass_fwhm"].values / 2
+    output_map.data_1d["energy_delta_minus"] = xr.DataArray(
+        energy_delta,
+        name="energy_delta_minus",
+        dims=["energy"],
+    )
+    output_map.data_1d["energy_delta_plus"] = xr.DataArray(
+        energy_delta,
+        name="energy_delta_plus",
+        dims=["energy"],
+    )
 
     output_map.data_1d = output_map.data_1d.drop("esa_energy_step_label")
 
@@ -223,25 +235,26 @@ def calculate_ena_intensity(
     geometric_factors_path : str or pathlib.Path
         Where to get the geometric factors from.
     esa_energies_path : str or pathlib.Path
-        Where to get the energies from.
+        Where to get the esa energies, energy deltas, and geometric factors.
 
     Returns
     -------
     intensity_vars : dict[str, xarray.DataArray]
         ENA Intensity with statistical and systematic uncertainties.
     """
-    # TODO: Implement geometric factor lookup
-    if geometric_factors_path:
-        raise NotImplementedError
-    geometric_factor = xr.DataArray(
-        np.ones((map_ds["esa_energy_step"].size, map_ds["calibration_prod"].size)),
-        coords=[map_ds["esa_energy_step"], map_ds["calibration_prod"]],
+    # read calibration product configuration file
+    cal_prod_df = CalibrationProductConfig.from_csv(geometric_factors_path)
+    # reindex_like removes esa_energy_steps and calibration products not in the
+    # map_ds esa_energy_step and calibration_product coordinates
+    geometric_factor = cal_prod_df.to_xarray().reindex_like(map_ds)["geometric_factor"]
+    geometric_factor = geometric_factor.transpose(
+        *[coord for coord in map_ds.coords if coord in geometric_factor.coords]
     )
-
-    esa_energy = esa_energy_lookup(esa_energies_path, map_ds["esa_energy_step"].data)
+    energy_df = esa_energy_df(esa_energies_path, map_ds["esa_energy_step"].data)
+    esa_energy = energy_df.to_xarray()["nominal_central_energy"]
 
     # Convert ENA Signal Rate to Flux
-    flux_conversion_divisor = geometric_factor * esa_energy[:, np.newaxis]
+    flux_conversion_divisor = geometric_factor * esa_energy
     intensity_vars = {
         "ena_intensity": map_ds["ena_signal_rates"] / flux_conversion_divisor,
         "ena_intensity_stat_unc": map_ds["ena_signal_rate_stat_unc"]
@@ -267,9 +280,9 @@ def calculate_ena_intensity(
     return intensity_vars
 
 
-def esa_energy_lookup(
+def esa_energy_df(
     esa_energies_path: str | Path, esa_energy_steps: np.ndarray
-) -> np.ndarray:
+) -> pd.DataFrame:
     """
     Lookup the nominal central energy values for given esa energy steps.
 
@@ -282,13 +295,11 @@ def esa_energy_lookup(
 
     Returns
     -------
-    esa_energies: numpy.ndarray
-        The nominal central energy for the given esa energy steps.
+    esa_energies_df: pandas.DataFrame
+        Full data frame from the csv file filtered to only include the
+        esa_energy_steps input.
     """
     esa_energies_lut = pd.read_csv(
         esa_energies_path, comment="#", index_col="esa_energy_step"
     )
-    esa_energies = esa_energies_lut.loc[esa_energy_steps][
-        "nominal_central_energy"
-    ].values
-    return esa_energies
+    return esa_energies_lut.loc[esa_energy_steps]

imap_processing/hi/utils.py

@@ -1,9 +1,12 @@
 """IMAP-Hi utils functions."""
 
+from __future__ import annotations
+
 import re
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
 from enum import IntEnum
+from pathlib import Path
 
 import numpy as np
 import pandas as pd
@@ -392,3 +395,109 @@ class EsaEnergyStepLookupTable:
             return results.astype(self._esa_energy_step_dtype)[0]
         else:
             return results.astype(self._esa_energy_step_dtype)
+
+
+@pd.api.extensions.register_dataframe_accessor("cal_prod_config")
+class CalibrationProductConfig:
+    """
+    Register custom accessor for calibration product configuration DataFrames.
+
+    Parameters
+    ----------
+    pandas_obj : pandas.DataFrame
+        Object to run validation and use accessor functions on.
+    """
+
+    index_columns = (
+        "calibration_prod",
+        "esa_energy_step",
+    )
+    tof_detector_pairs = ("ab", "ac1", "bc1", "c1c2")
+    required_columns = (
+        "coincidence_type_list",
+        *[
+            f"tof_{det_pair}_{limit}"
+            for det_pair in tof_detector_pairs
+            for limit in ["low", "high"]
+        ],
+    )
+
+    def __init__(self, pandas_obj: pd.DataFrame) -> None:
+        self._validate(pandas_obj)
+        self._obj = pandas_obj
+        self._add_coincidence_values_column()
+
+    def _validate(self, df: pd.DataFrame) -> None:
+        """
+        Validate the current configuration.
+
+        Parameters
+        ----------
+        df : pandas.DataFrame
+            Object to validate.
+
+        Raises
+        ------
+        AttributeError : If the dataframe does not pass validation.
+        """
+        for index_name in self.index_columns:
+            if index_name in df.index:
+                raise AttributeError(
+                    f"Required index {index_name} not present in dataframe."
+                )
+        # Verify that the Dataframe has all the required columns
+        for col in self.required_columns:
+            if col not in df.columns:
+                raise AttributeError(f"Required column {col} not present in dataframe.")
+        # TODO: Verify that the same ESA energy steps exist in all unique calibration
+        #   product numbers
+
+    def _add_coincidence_values_column(self) -> None:
+        """Generate and add the coincidence_type_values column to the dataframe."""
+        # Add a column that consists of the coincidence type strings converted
+        # to integer values
+        self._obj["coincidence_type_values"] = self._obj.apply(
+            lambda row: tuple(
+                CoincidenceBitmap.detector_hit_str_to_int(entry)
+                for entry in row["coincidence_type_list"]
+            ),
+            axis=1,
+        )
+
+    @classmethod
+    def from_csv(cls, path: str | Path) -> pd.DataFrame:
+        """
+        Read configuration CSV file into a pandas.DataFrame.
+
+        Parameters
+        ----------
+        path : str or pathlib.Path
+            Location of the Calibration Product configuration CSV file.
+
+        Returns
+        -------
+        dataframe : pandas.DataFrame
+            Validated calibration product configuration data frame.
+        """
+        df = pd.read_csv(
+            path,
+            index_col=cls.index_columns,
+            converters={"coincidence_type_list": lambda s: tuple(s.split("|"))},
+            comment="#",
+        )
+        # Force the _init_ method to run by using the namespace
+        _ = df.cal_prod_config.number_of_products
+        return df
+
+    @property
+    def number_of_products(self) -> int:
+        """
+        Get the number of calibration products in the current configuration.
+
+        Returns
+        -------
+        number_of_products : int
+            The maximum number of calibration products defined in the list of
+            calibration product definitions.
+        """
+        return len(self._obj.index.unique(level="calibration_prod"))