imap-processing 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

imap_processing/hi/l1a/science_direct_event.py

@@ -1,5 +1,6 @@
 """IMAP-Hi direct event processing."""
 
+import logging
 from collections import defaultdict
 
 import numpy as np
@@ -7,18 +8,20 @@ import numpy._typing as npt
 import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
-from imap_processing.spice.time import met_to_j2000ns
+from imap_processing.spice.time import met_to_ttj2000ns
 
-# TODO: read LOOKED_UP_DURATION_OF_TICK from
+# TODO: read DE_CLOCK_TICK_US from
 # instrument status summary later. This value
 # is rarely change but want to be able to change
 # it if needed. It stores information about how
 # fast the time was ticking. It is in microseconds.
-LOOKED_UP_DURATION_OF_TICK = 1999
+DE_CLOCK_TICK_US = 1999
+DE_CLOCK_TICK_S = DE_CLOCK_TICK_US / 1e6
+HALF_CLOCK_TICK_S = DE_CLOCK_TICK_S / 2
 
-SECOND_TO_NS = 1e9
-MILLISECOND_TO_NS = 1e6
-MICROSECOND_TO_NS = 1e3
+MILLISECOND_TO_S = 1e-3
+
+logger = logging.getLogger(__name__)
 
 
 def parse_direct_events(de_data: bytes) -> dict[str, npt.ArrayLike]:
@@ -100,23 +103,6 @@ def create_dataset(de_data_dict: dict[str, npt.ArrayLike]) -> xr.Dataset:
     dataset : xarray.Dataset
         Xarray dataset.
     """
-    # Compute the meta-event MET in nanoseconds
-    de_data_dict["meta_event_met"] = (
-        np.array(de_data_dict.pop("meta_seconds")) * SECOND_TO_NS
-        + np.array(de_data_dict.pop("meta_subseconds")) * MILLISECOND_TO_NS
-    )
-    # Compute the MET of each event in nanoseconds
-    # event MET = meta_event_met + de_clock + 1/2 de_clock_tick
-    # See Hi Algorithm Document section 2.2.5
-    half_tick_ns = LOOKED_UP_DURATION_OF_TICK / 2 * MICROSECOND_TO_NS
-    de_data_dict["event_met"] = (
-        de_data_dict["meta_event_met"]
-        + np.array(de_data_dict["de_tag"])
-        * LOOKED_UP_DURATION_OF_TICK
-        * MICROSECOND_TO_NS
-        + half_tick_ns
-    )
-
     # Load the CDF attributes
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs("hi")
@@ -125,19 +111,45 @@ def create_dataset(de_data_dict: dict[str, npt.ArrayLike]) -> xr.Dataset:
     # check_schema=False keeps DEPEND_0 = '' from being auto added
     epoch_attrs = attr_mgr.get_variable_attributes("epoch", check_schema=False)
     epoch_attrs["CATDESC"] = (
-        "Direct Event time, number of nanoseconds since J2000 with leap "
+        "CCSDS creation time, number of nanoseconds since J2000 with leap "
         "seconds included"
     )
     epoch = xr.DataArray(
-        met_to_j2000ns(de_data_dict["event_met"] / 1e9),
+        met_to_ttj2000ns(de_data_dict["ccsds_met"]),
         name="epoch",
         dims=["epoch"],
         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["meta_seconds"]).astype(np.float64)
+        + np.array(de_data_dict["meta_subseconds"]) * 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 = xr.DataArray(
+        event_met_array,
+        name="event_met",
+        dims=["event_met"],
+        attrs=event_met_attrs,
+    )
+
     de_global_attrs = attr_mgr.get_global_attributes("imap_hi_l1a_de_attrs")
     dataset = xr.Dataset(
-        coords={"epoch": epoch},
+        coords={"epoch": epoch, "event_met": event_met},
         attrs=de_global_attrs,
     )
 
@@ -148,12 +160,10 @@ def create_dataset(de_data_dict: dict[str, npt.ArrayLike]) -> xr.Dataset:
         dtype = attrs.pop("dtype")
         dataset[var_name] = xr.DataArray(
             np.array(data, dtype=np.dtype(dtype)),
-            dims="epoch",
+            dims=attrs["DEPEND_0"],
             attrs=attrs,
         )
 
-    # TODO: figure out how to store information about
-    # input data(one or more) it used to produce this dataset
     return dataset
 
 
@@ -179,32 +189,28 @@ def science_direct_event(packets_data: xr.Dataset) -> xr.Dataset:
     """
     de_data_dict: dict[str, list] = defaultdict(list)
 
-    # Because DE_TOF is a variable length data,
-    # I am using extend to add another list to the
-    # end of the list. This way, I don't need to flatten
-    # the list later.
+    # Add packet data to the dictionary, renaming some fields
+    # This is done first so that these variables are first in the CDF
+    for from_key, to_key in {
+        "shcoarse": "ccsds_met",
+        "src_seq_ctr": "src_seq_ctr",
+        "pkt_len": "pkt_len",
+        "last_spin_num": "last_spin_num",
+        "spin_invalids": "spin_invalids",
+        "esa_step_num": "esa_step",
+        "meta_seconds": "meta_seconds",
+        "meta_subseconds": "meta_subseconds",
+    }.items():
+        de_data_dict[to_key] = packets_data[from_key].data
+
+    # For each packet, parse the DE data and add it to the Pointing
+    # list of DE data usint `extend()`
     for i, data in enumerate(packets_data["de_tof"].data):
         parsed_de_data = parse_direct_events(data)
         for key, new_data in parsed_de_data.items():
             de_data_dict[key].extend(new_data)
-
-        # add packet data to keep_packet_data dictionary, repeating values
-        # for each direct event encoded in the current packet
-        for from_key, to_key in {
-            "shcoarse": "ccsds_met",
-            "src_seq_ctr": "src_seq_ctr",
-            "pkt_len": "pkt_len",
-            "last_spin_num": "last_spin_num",
-            "spin_invalids": "spin_invalids",
-            "esa_step_num": "esa_step",
-            "meta_seconds": "meta_seconds",
-            "meta_subseconds": "meta_subseconds",
-        }.items():
-            # Repeat the ith packet from_key value N times, where N is the
-            # number of events in the ith packet.
-            de_data_dict[to_key].extend(
-                [packets_data[from_key].data[i]] * len(parsed_de_data["de_tag"])
-            )
+        # Record the ccsds packet index for each DE
+        de_data_dict["ccsds_index"].extend([i] * len(parsed_de_data["de_tag"]))
 
     # create dataset
     return create_dataset(de_data_dict)

imap_processing/hi/l1b/hi_l1b.py

@@ -9,6 +9,7 @@ import xarray as xr
 from imap_processing import imap_module_directory
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.cdf.utils import parse_filename_like
+from imap_processing.hi.l1a.science_direct_event import HALF_CLOCK_TICK_S
 from imap_processing.hi.utils import (
     HIAPID,
     HiConstants,
@@ -17,11 +18,13 @@ from imap_processing.hi.utils import (
 )
 from imap_processing.spice.geometry import (
     SpiceFrame,
+    instrument_pointing,
+)
+from imap_processing.spice.spin import (
     get_instrument_spin_phase,
     get_spacecraft_spin_phase,
-    instrument_pointing,
 )
-from imap_processing.spice.time import j2000ns_to_j2000s
+from imap_processing.spice.time import met_to_sclkticks, sct_to_et
 from imap_processing.utils import convert_raw_to_eu
 
 
@@ -120,19 +123,30 @@ def annotate_direct_events(l1a_dataset: xr.Dataset) -> xr.Dataset:
         L1B direct event data.
     """
     l1b_dataset = l1a_dataset.copy()
+    l1b_dataset.update(de_esa_energy_step(l1b_dataset))
     l1b_dataset.update(compute_coincidence_type_and_time_deltas(l1b_dataset))
     l1b_dataset.update(de_nominal_bin_and_spin_phase(l1b_dataset))
     l1b_dataset.update(compute_hae_coordinates(l1b_dataset))
-    l1b_dataset.update(de_esa_energy_step(l1b_dataset))
     l1b_dataset.update(
         create_dataset_variables(
             ["quality_flag"],
-            l1b_dataset["epoch"].size,
+            l1b_dataset["event_met"].size,
             att_manager_lookup_str="hi_de_{0}",
         )
     )
     l1b_dataset = l1b_dataset.drop_vars(
-        ["tof_1", "tof_2", "tof_3", "de_tag", "ccsds_met", "meta_event_met"]
+        [
+            "src_seq_ctr",
+            "pkt_len",
+            "last_spin_num",
+            "spin_invalids",
+            "meta_seconds",
+            "meta_subseconds",
+            "tof_1",
+            "tof_2",
+            "tof_3",
+            "de_tag",
+        ]
     )
 
     de_global_attrs = ATTR_MGR.get_global_attributes("imap_hi_l1b_de_attrs")
@@ -169,20 +183,19 @@ def compute_coincidence_type_and_time_deltas(
             "delta_t_bc1",
             "delta_t_c1c2",
         ],
-        len(dataset.epoch),
+        len(dataset.event_met),
         att_manager_lookup_str="hi_de_{0}",
     )
-    out_ds = dataset.assign(new_vars)
 
     # compute masks needed for coincidence type and delta t calculations
-    a_first = out_ds.trigger_id.values == TriggerId.A
-    b_first = out_ds.trigger_id.values == TriggerId.B
-    c_first = out_ds.trigger_id.values == TriggerId.C
+    a_first = dataset.trigger_id.values == TriggerId.A
+    b_first = dataset.trigger_id.values == TriggerId.B
+    c_first = dataset.trigger_id.values == TriggerId.C
 
-    tof1_valid = np.isin(out_ds.tof_1.values, HiConstants.TOF1_BAD_VALUES, invert=True)
-    tof2_valid = np.isin(out_ds.tof_2.values, HiConstants.TOF2_BAD_VALUES, invert=True)
+    tof1_valid = np.isin(dataset.tof_1.values, HiConstants.TOF1_BAD_VALUES, invert=True)
+    tof2_valid = np.isin(dataset.tof_2.values, HiConstants.TOF2_BAD_VALUES, invert=True)
     tof1and2_valid = tof1_valid & tof2_valid
-    tof3_valid = np.isin(out_ds.tof_3.values, HiConstants.TOF3_BAD_VALUES, invert=True)
+    tof3_valid = np.isin(dataset.tof_3.values, HiConstants.TOF3_BAD_VALUES, invert=True)
 
     # Table denoting how hit-first mask and valid TOF masks are used to set
     # coincidence type bitmask
@@ -193,12 +206,12 @@ def compute_coincidence_type_and_time_deltas(
     # |      2      |      B      |     A,B     |     B,C1    |    C1,C2    |
     # |      3      |      C1     |     A,C1    |     B,C1    |    C1,C2    |
     # Set coincidence type bitmask
-    new_vars["coincidence_type"][a_first | tof1_valid] |= CoincidenceBitmap.A
+    new_vars["coincidence_type"][a_first | tof1_valid] |= np.uint8(CoincidenceBitmap.A)
     new_vars["coincidence_type"][
         b_first | (a_first & tof1_valid) | (c_first & tof2_valid)
-    ] |= CoincidenceBitmap.B
-    new_vars["coincidence_type"][c_first | tof2_valid] |= CoincidenceBitmap.C1
-    new_vars["coincidence_type"][tof3_valid] |= CoincidenceBitmap.C2
+    ] |= np.uint8(CoincidenceBitmap.B)
+    new_vars["coincidence_type"][c_first | tof2_valid] |= np.uint8(CoincidenceBitmap.C1)
+    new_vars["coincidence_type"][tof3_valid] |= np.uint8(CoincidenceBitmap.C2)
 
     # Table denoting how TOF is interpreted for each Trigger ID
     # -----------------------------------------------------------------------
@@ -209,9 +222,9 @@ def compute_coincidence_type_and_time_deltas(
     # |      3      |      C      |  t_a - t_c1 | t_b  - t_c1 | t_c2 - t_c1 |
 
     # Prepare for delta_t calculations by converting TOF values to nanoseconds
-    tof_1_ns = (out_ds.tof_1.values * HiConstants.TOF1_TICK_DUR).astype(np.int32)
-    tof_2_ns = (out_ds.tof_2.values * HiConstants.TOF2_TICK_DUR).astype(np.int32)
-    tof_3_ns = (out_ds.tof_3.values * HiConstants.TOF3_TICK_DUR).astype(np.int32)
+    tof_1_ns = (dataset.tof_1.values * HiConstants.TOF1_TICK_DUR).astype(np.int32)
+    tof_2_ns = (dataset.tof_2.values * HiConstants.TOF2_TICK_DUR).astype(np.int32)
+    tof_3_ns = (dataset.tof_3.values * HiConstants.TOF3_TICK_DUR).astype(np.int32)
 
     # # ********** delta_t_ab = (t_b - t_a) **********
     # Table: row 1, column 1
@@ -281,24 +294,23 @@ def de_nominal_bin_and_spin_phase(dataset: xr.Dataset) -> dict[str, xr.DataArray
             "spin_phase",
             "nominal_bin",
         ],
-        len(dataset.epoch),
+        len(dataset.event_met),
         att_manager_lookup_str="hi_de_{0}",
     )
 
     # 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
     # spacecraft spin-phase, not instrument spin-phase, so the same is done here.
-    met_query_times = j2000ns_to_j2000s(dataset.event_met.values)
-    imap_spin_phase = get_spacecraft_spin_phase(met_query_times)
+    # We have to add 1/2 clock tick to MET time before getting spin phase
+    met_seconds = dataset.event_met.values + HALF_CLOCK_TICK_S
+    imap_spin_phase = get_spacecraft_spin_phase(met_seconds)
     new_vars["nominal_bin"].values = np.asarray(imap_spin_phase * 360 / 4).astype(
         np.uint8
     )
 
     sensor_number = parse_sensor_number(dataset.attrs["Logical_source"])
     new_vars["spin_phase"].values = np.asarray(
-        get_instrument_spin_phase(
-            met_query_times, SpiceFrame[f"IMAP_HI_{sensor_number}"]
-        )
+        get_instrument_spin_phase(met_seconds, SpiceFrame[f"IMAP_HI_{sensor_number}"])
     ).astype(np.float32)
     return new_vars
 
@@ -326,10 +338,13 @@ def compute_hae_coordinates(dataset: xr.Dataset) -> dict[str, xr.DataArray]:
             "hae_latitude",
             "hae_longitude",
         ],
-        len(dataset.epoch),
+        len(dataset.event_met),
         att_manager_lookup_str="hi_de_{0}",
     )
-    et = j2000ns_to_j2000s(dataset.epoch.values)
+    # 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)
+    et = sct_to_et(sclk_ticks)
     sensor_number = parse_sensor_number(dataset.attrs["Logical_source"])
     # TODO: For now, we are using SPICE to compute the look direction for each
     #   direct event. This will eventually be replaced by the algorithm Paul

imap_processing/hi/l1c/hi_l1c.py

@@ -1,13 +1,23 @@
 """IMAP-HI l1c processing module."""
 
+from __future__ import annotations
+
 import logging
+from pathlib import Path
 
 import numpy as np
+import pandas as pd
 import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.cdf.utils import parse_filename_like
-from imap_processing.hi.utils import full_dataarray
+from imap_processing.hi.utils import create_dataset_variables, full_dataarray
+from imap_processing.spice.geometry import (
+    SpiceFrame,
+    frame_transform,
+    frame_transform_az_el,
+)
+from imap_processing.spice.time import ttj2000ns_to_et
 
 logger = logging.getLogger(__name__)
 
@@ -39,8 +49,8 @@ def hi_l1c(dependencies: list, data_version: str) -> xr.Dataset:
 
     # TODO: I am not sure what the input for Goodtimes will be so for now,
     #    If the input is an xarray Dataset, do pset processing
-    if len(dependencies) == 1 and isinstance(dependencies[0], xr.Dataset):
-        l1c_dataset = generate_pset_dataset(dependencies[0])
+    if len(dependencies) == 2 and isinstance(dependencies[0], xr.Dataset):
+        l1c_dataset = generate_pset_dataset(*dependencies)
     else:
         raise NotImplementedError(
             "Input dependencies not recognized for l1c pset processing."
@@ -51,39 +61,78 @@ def hi_l1c(dependencies: list, data_version: str) -> xr.Dataset:
     return l1c_dataset
 
 
-def generate_pset_dataset(de_dataset: xr.Dataset) -> xr.Dataset:
+def generate_pset_dataset(
+    de_dataset: xr.Dataset, calibration_prod_config_path: Path
+) -> xr.Dataset:
     """
-    Will process IMAP-Hi l1b product into a l1c pset xarray dataset.
+    Generate IMAP-Hi l1c pset xarray dataset from l1b product.
 
     Parameters
     ----------
     de_dataset : xarray.Dataset
         IMAP-Hi l1b de product.
+    calibration_prod_config_path : Path
+        Calibration product configuration file.
 
     Returns
     -------
     pset_dataset : xarray.Dataset
         Ready to be written to CDF.
     """
+    logger.info(
+        f"Generating IMAP-Hi l1c pset dataset for product "
+        f"{de_dataset.attrs['Logical_file_id']}"
+    )
     logical_source_parts = parse_filename_like(de_dataset.attrs["Logical_source"])
-    n_esa_step = de_dataset.esa_step.data.size
-    pset_dataset = allocate_pset_dataset(n_esa_step, logical_source_parts["sensor"])
-    # TODO: Stored epoch value needs to be consistent across ENA instruments.
-    #    SPDF says this should be the center of the time bin, but instrument
-    #    teams may disagree.
-    pset_dataset.epoch.data[0] = de_dataset.epoch.data[0]
+    # read calibration product configuration file
+    config_df = CalibrationProductConfig.from_csv(calibration_prod_config_path)
+
+    pset_dataset = empty_pset_dataset(
+        de_dataset.esa_energy_step.data,
+        config_df.cal_prod_config.number_of_products,
+        logical_source_parts["sensor"],
+    )
+    # For ISTP, epoch should be the center of the time bin.
+    pset_dataset.epoch.data[0] = np.mean(de_dataset.epoch.data[[0, -1]]).astype(
+        np.int64
+    )
+    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_dataset.update(pset_geometry(pset_et, logical_source_parts["sensor"]))
+
+    # TODO: The following section will go away as PSET algorithms to populate
+    #    these variables are written.
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs("hi")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
+    for var_name in [
+        "counts",
+        "exposure_times",
+        "background_rates",
+        "background_rates_uncertainty",
+    ]:
+        pset_dataset[var_name] = full_dataarray(
+            var_name,
+            attr_mgr.get_variable_attributes(f"hi_pset_{var_name}", check_schema=False),
+            pset_dataset.coords,
+        )
 
     return pset_dataset
 
 
-def allocate_pset_dataset(n_esa_steps: int, sensor_str: str) -> xr.Dataset:
+def empty_pset_dataset(
+    l1b_energy_steps: np.ndarray, n_cal_prods: int, sensor_str: str
+) -> xr.Dataset:
     """
-    Allocate an empty xarray.Dataset.
+    Allocate an empty xarray.Dataset with appropriate pset coordinates.
 
     Parameters
     ----------
-    n_esa_steps : int
-        Number of Electrostatic Analyzer steps to allocate.
+    l1b_energy_steps : np.ndarray
+        The array of esa_energy_step data from the L1B DE product.
+    n_cal_prods : int
+        Number of calibration products to allocate.
     sensor_str : str
         '45sensor' or '90sensor'.
 
@@ -99,32 +148,36 @@ def allocate_pset_dataset(n_esa_steps: int, sensor_str: str) -> xr.Dataset:
     # preallocate coordinates xr.DataArrays
     coords = dict()
     # epoch coordinate has only 1 entry for pointing set
+    epoch_attrs = attr_mgr.get_variable_attributes("epoch")
+    epoch_attrs.update(
+        attr_mgr.get_variable_attributes("hi_pset_epoch", check_schema=False)
+    )
     coords["epoch"] = xr.DataArray(
         np.empty(1, dtype=np.int64),  # TODO: get dtype from cdf attrs?
         name="epoch",
         dims=["epoch"],
-        attrs=attr_mgr.get_variable_attributes("epoch"),
+        attrs=epoch_attrs,
     )
+    # Create the esa_energy_step coordinate
     attrs = attr_mgr.get_variable_attributes(
         "hi_pset_esa_energy_step", check_schema=False
     ).copy()
     dtype = attrs.pop("dtype")
+    # Find the unique, non-zero esa_energy_steps from the L1B data
+    esa_energy_steps = np.array(sorted(set(l1b_energy_steps) - {0}), dtype=dtype)
     coords["esa_energy_step"] = xr.DataArray(
-        np.full(n_esa_steps, attrs["FILLVAL"], dtype=dtype),
+        esa_energy_steps,
         name="esa_energy_step",
         dims=["esa_energy_step"],
         attrs=attrs,
     )
-    # TODO: define calibration product number to coincidence type mapping and
-    #     use the number of calibration products here. I believe it will be 5
-    #     0 for any, 1-4, for the number of detector hits.
-    n_calibration_prod = 5
+
     attrs = attr_mgr.get_variable_attributes(
         "hi_pset_calibration_prod", check_schema=False
     ).copy()
     dtype = attrs.pop("dtype")
     coords["calibration_prod"] = xr.DataArray(
-        np.arange(n_calibration_prod, dtype=dtype),
+        np.arange(n_cal_prods, dtype=dtype),
         name="calibration_prod",
         dims=["calibration_prod"],
         attrs=attrs,
@@ -141,27 +194,8 @@ def allocate_pset_dataset(n_esa_steps: int, sensor_str: str) -> xr.Dataset:
         attrs=attrs,
     )
 
-    # Allocate the variables
+    # Allocate the coordinate label variables
     data_vars = dict()
-    # despun_z is a 1x3 unit vector that does not have a DEPEND_1.
-    # Define this dict to override the shape produced in full_dataarray
-    var_shapes = {"despun_z": (1, 3)}
-    for var_name in [
-        "despun_z",
-        "hae_latitude",
-        "hae_longitude",
-        "counts",
-        "exposure_times",
-        "background_rates",
-        "background_rates_uncertainty",
-    ]:
-        data_vars[var_name] = full_dataarray(
-            var_name,
-            attr_mgr.get_variable_attributes(f"hi_pset_{var_name}", check_schema=False),
-            coords,
-            shape=var_shapes.get(var_name, None),
-        )
-
     # Generate label variables
     data_vars["esa_energy_step_label"] = xr.DataArray(
         coords["esa_energy_step"].values.astype(str),
@@ -202,3 +236,152 @@ def allocate_pset_dataset(n_esa_steps: int, sensor_str: str) -> xr.Dataset:
     )
     dataset = xr.Dataset(data_vars=data_vars, coords=coords, attrs=pset_global_attrs)
     return dataset
+
+
+def pset_geometry(pset_et: float, sensor_str: str) -> dict[str, xr.DataArray]:
+    """
+    Calculate PSET geometry variables.
+
+    Parameters
+    ----------
+    pset_et : float
+        Pointing set ephemeris time for which to calculate PSET geometry.
+    sensor_str : str
+        '45sensor' or '90sensor'.
+
+    Returns
+    -------
+    geometry_vars : dict[str, xarray.DataArray]
+        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}"
+    )
+    despun_z = frame_transform(
+        pset_et,
+        np.array([0, 0, 1]),
+        SpiceFrame.IMAP_DPS,
+        SpiceFrame.ECLIPJ2000,
+    )
+    geometry_vars["despun_z"].values = despun_z[np.newaxis, :].astype(np.float32)
+
+    # Calculate hae_latitude and hae_longitude of the spin bins
+    # define the azimuth/elevation coordinates in the Pointing Frame (DPS)
+    # TODO: get the sensor's true elevation using SPICE?
+    el = 0 if "90" in sensor_str else -45
+    dps_az_el = np.array(
+        [
+            np.arange(0.05, 360, 0.1),
+            np.full(3600, el),
+        ]
+    ).T
+    hae_az_el = frame_transform_az_el(
+        pset_et, dps_az_el, SpiceFrame.IMAP_DPS, SpiceFrame.ECLIPJ2000, degrees=True
+    )
+
+    geometry_vars.update(
+        create_dataset_variables(
+            ["hae_latitude", "hae_longitude"],
+            (1, 3600),
+            att_manager_lookup_str="hi_pset_{0}",
+        )
+    )
+    geometry_vars["hae_longitude"].values = hae_az_el[:, 0].astype(np.float32)[
+        np.newaxis, :
+    ]
+    geometry_vars["hae_latitude"].values = hae_az_el[:, 1].astype(np.float32)[
+        np.newaxis, :
+    ]
+    return geometry_vars
+
+
+@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",
+    )
+    required_columns = (
+        "coincidence_type_list",
+        "tof_ab_low",
+        "tof_ab_high",
+        "tof_ac1_low",
+        "tof_ac1_high",
+        "tof_bc1_low",
+        "tof_bc1_high",
+        "tof_c1c2_low",
+        "tof_c1c2_high",
+    )
+
+    def __init__(self, pandas_obj: pd.DataFrame) -> None:
+        self._validate(pandas_obj)
+        self._obj = pandas_obj
+
+    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
+
+    @classmethod
+    def from_csv(cls, path: Path) -> pd.DataFrame:
+        """
+        Read configuration CSV file into a pandas.DataFrame.
+
+        Parameters
+        ----------
+        path : Path
+            Location of the Calibration Product configuration CSV file.
+
+        Returns
+        -------
+        dataframe : pandas.DataFrame
+            Validated calibration product configuration data frame.
+        """
+        return pd.read_csv(
+            path,
+            index_col=cls.index_columns,
+            converters={"coincidence_type_list": lambda s: s.split("|")},
+            comment="#",
+        )
+
+    @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"))