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

imap_processing/lo/l0/lo_science.py

@@ -37,28 +37,28 @@ HistPacking = namedtuple(
 
 HIST_DATA_META = {
     # field: bit_length, section_length, shape
-    "start_a": HistPacking(12, 504, (6, 7)),
-    "start_c": HistPacking(12, 504, (6, 7)),
-    "stop_b0": HistPacking(12, 504, (6, 7)),
-    "stop_b3": HistPacking(12, 504, (6, 7)),
-    "tof0_count": HistPacking(8, 336, (6, 7)),
-    "tof1_count": HistPacking(8, 336, (6, 7)),
-    "tof2_count": HistPacking(8, 336, (6, 7)),
-    "tof3_count": HistPacking(8, 336, (6, 7)),
-    "tof0_tof1": HistPacking(8, 3360, (60, 7)),
-    "tof0_tof2": HistPacking(8, 3360, (60, 7)),
-    "tof1_tof2": HistPacking(8, 3360, (60, 7)),
-    "silver": HistPacking(8, 3360, (60, 7)),
-    "disc_tof0": HistPacking(8, 336, (6, 7)),
-    "disc_tof1": HistPacking(8, 336, (6, 7)),
-    "disc_tof2": HistPacking(8, 336, (6, 7)),
-    "disc_tof3": HistPacking(8, 336, (6, 7)),
-    "pos0": HistPacking(12, 504, (6, 7)),
-    "pos1": HistPacking(12, 504, (6, 7)),
-    "pos2": HistPacking(12, 504, (6, 7)),
-    "pos3": HistPacking(12, 504, (6, 7)),
-    "hydrogen": HistPacking(8, 3360, (60, 7)),
-    "oxygen": HistPacking(8, 3360, (60, 7)),
+    "start_a": HistPacking(12, 504, (7, 6)),
+    "start_c": HistPacking(12, 504, (7, 6)),
+    "stop_b0": HistPacking(12, 504, (7, 6)),
+    "stop_b3": HistPacking(12, 504, (7, 6)),
+    "tof0_count": HistPacking(8, 336, (7, 6)),
+    "tof1_count": HistPacking(8, 336, (7, 6)),
+    "tof2_count": HistPacking(8, 336, (7, 6)),
+    "tof3_count": HistPacking(8, 336, (7, 6)),
+    "tof0_tof1": HistPacking(8, 3360, (7, 60)),
+    "tof0_tof2": HistPacking(8, 3360, (7, 60)),
+    "tof1_tof2": HistPacking(8, 3360, (7, 60)),
+    "silver": HistPacking(8, 3360, (7, 60)),
+    "disc_tof0": HistPacking(8, 336, (7, 6)),
+    "disc_tof1": HistPacking(8, 336, (7, 6)),
+    "disc_tof2": HistPacking(8, 336, (7, 6)),
+    "disc_tof3": HistPacking(8, 336, (7, 6)),
+    "pos0": HistPacking(12, 504, (7, 6)),
+    "pos1": HistPacking(12, 504, (7, 6)),
+    "pos2": HistPacking(12, 504, (7, 6)),
+    "pos3": HistPacking(12, 504, (7, 6)),
+    "hydrogen": HistPacking(8, 3360, (7, 60)),
+    "oxygen": HistPacking(8, 3360, (7, 60)),
 }
 
 
@@ -399,7 +399,7 @@ def combine_segmented_packets(dataset: xr.Dataset) -> xr.Dataset:
     # Combine the segmented packets into a single binary string
     dataset["events"] = [
         "".join(dataset["data"].values[start : end + 1])
-        for start, end in zip(seg_starts, seg_ends)
+        for start, end in zip(seg_starts, seg_ends, strict=False)
     ]
 
     # drop any group of segmented packets that aren't sequential
@@ -441,7 +441,8 @@ def find_valid_groups(
     """
     # Check if the sequence counters from the CCSDS header are sequential
     grouped_seq_ctrs = [
-        np.array(seq_ctrs[start : end + 1]) for start, end in zip(seg_starts, seg_ends)
+        np.array(seq_ctrs[start : end + 1])
+        for start, end in zip(seg_starts, seg_ends, strict=False)
     ]
     valid_groups = [is_sequential(seq_ctrs) for seq_ctrs in grouped_seq_ctrs]
     return valid_groups

imap_processing/lo/l1a/lo_l1a.py

@@ -45,6 +45,11 @@ def lo_l1a(dependency: Path) -> list[xr.Dataset]:
         xtce_packet_definition=xtce_file.resolve(),
         use_derived_value=False,
     )
+    datasets_by_apid_derived = packet_file_to_datasets(
+        packet_file=dependency.resolve(),
+        xtce_packet_definition=xtce_file.resolve(),
+        use_derived_value=True,
+    )
 
     # create the attribute manager for this data level
     attr_mgr = ImapCdfAttributes()
@@ -101,6 +106,45 @@ def lo_l1a(dependency: Path) -> list[xr.Dataset]:
         ds = process_star_sensor(ds)
         ds = add_dataset_attrs(ds, attr_mgr, logical_source)
         datasets_to_return.append(ds)
+    if LoAPID.ILO_DIAG_PCC in datasets_by_apid:
+        logger.info(
+            f"\nProcessing {LoAPID(LoAPID.ILO_DIAG_PCC).name} "
+            f"packet (APID: {LoAPID.ILO_DIAG_PCC.value})"
+        )
+        logical_source = "imap_lo_l1a_pcc"
+        ds = datasets_by_apid[LoAPID.ILO_DIAG_PCC]
+        ds = add_dataset_attrs(ds, attr_mgr, logical_source)
+        datasets_to_return.append(ds)
+    if LoAPID.ILO_APP_NHK in datasets_by_apid:
+        logger.info(
+            f"\nProcessing {LoAPID(LoAPID.ILO_APP_NHK).name} "
+            f"packet (APID: {LoAPID.ILO_APP_NHK.value})"
+        )
+        logical_source = "imap_lo_l1a_nhk"
+        ds = datasets_by_apid[LoAPID.ILO_APP_NHK]
+        ds = add_dataset_attrs(ds, attr_mgr, logical_source)
+        datasets_to_return.append(ds)
+
+        # Engineering units conversion
+        logical_source = "imap_lo_l1b_nhk"
+        ds = datasets_by_apid_derived[LoAPID.ILO_APP_NHK]
+        ds = add_dataset_attrs(ds, attr_mgr, logical_source)
+        datasets_to_return.append(ds)
+    if LoAPID.ILO_APP_SHK in datasets_by_apid:
+        logger.info(
+            f"\nProcessing {LoAPID(LoAPID.ILO_APP_SHK).name} "
+            f"packet (APID: {LoAPID.ILO_APP_SHK.value})"
+        )
+        logical_source = "imap_lo_l1a_shk"
+        ds = datasets_by_apid[LoAPID.ILO_APP_SHK]
+        ds = add_dataset_attrs(ds, attr_mgr, logical_source)
+        datasets_to_return.append(ds)
+
+        # Engineering units conversion
+        logical_source = "imap_lo_l1b_shk"
+        ds = datasets_by_apid_derived[LoAPID.ILO_APP_SHK]
+        ds = add_dataset_attrs(ds, attr_mgr, logical_source)
+        datasets_to_return.append(ds)
 
     logger.info(f"Returning [{len(datasets_to_return)}] datasets")
     return datasets_to_return

imap_processing/lo/l1b/lo_l1b.py

@@ -3,7 +3,7 @@
 import logging
 from dataclasses import Field
 from pathlib import Path
-from typing import Any, Union
+from typing import Any
 
 import numpy as np
 import xarray as xr
@@ -204,7 +204,7 @@ def get_avg_spin_durations_per_cycle(
     return avg_spin_durations_per_cycle
 
 
-def get_spin_angle(l1a_de: xr.Dataset) -> Union[np.ndarray[np.float64], Any]:
+def get_spin_angle(l1a_de: xr.Dataset) -> np.ndarray[np.float64] | Any:
     """
     Get the spin angle (0 - 360 degrees) for each DE.
 
@@ -587,7 +587,7 @@ def convert_tofs_to_eu(
     tof_conversions = [TOF0_CONV, TOF1_CONV, TOF2_CONV, TOF3_CONV]
 
     # Loop through the TOF fields and convert them to engineering units
-    for tof, conv in zip(tof_fields, tof_conversions):
+    for tof, conv in zip(tof_fields, tof_conversions, strict=False):
         # Get the fill value for the L1A and L1B TOF
         fillval_1a = attr_mgr_l1a.get_variable_attributes(tof)["FILLVAL"]
         fillval_1b = attr_mgr_l1b.get_variable_attributes(tof)["FILLVAL"]

imap_processing/lo/l1c/lo_l1c.py

@@ -4,12 +4,26 @@ from dataclasses import Field
 from enum import Enum
 
 import numpy as np
-import pandas as pd
 import xarray as xr
 from scipy.stats import binned_statistic_dd
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
-from imap_processing.spice.time import met_to_ttj2000ns
+from imap_processing.lo import lo_ancillary
+from imap_processing.spice.repoint import get_pointing_times
+from imap_processing.spice.spin import get_spin_number
+from imap_processing.spice.time import met_to_ttj2000ns, ttj2000ns_to_met
+
+N_ESA_ENERGY_STEPS = 7
+N_SPIN_ANGLE_BINS = 3600
+N_OFF_ANGLE_BINS = 40
+# 1 time, 7 energy steps, 3600 spin angle bins, and 40 off angle bins
+PSET_SHAPE = (1, N_ESA_ENERGY_STEPS, N_SPIN_ANGLE_BINS, N_OFF_ANGLE_BINS)
+PSET_DIMS = ["epoch", "esa_energy_step", "spin_angle", "off_angle"]
+ESA_ENERGY_STEPS = np.arange(N_ESA_ENERGY_STEPS) + 1  # 1 to 7 inclusive
+SPIN_ANGLE_BIN_EDGES = np.linspace(0, 360, N_SPIN_ANGLE_BINS + 1)
+SPIN_ANGLE_BIN_CENTERS = (SPIN_ANGLE_BIN_EDGES[:-1] + SPIN_ANGLE_BIN_EDGES[1:]) / 2
+OFF_ANGLE_BIN_EDGES = np.linspace(-2, 2, N_OFF_ANGLE_BINS + 1)
+OFF_ANGLE_BIN_CENTERS = (OFF_ANGLE_BIN_EDGES[:-1] + OFF_ANGLE_BIN_EDGES[1:]) / 2
 
 
 class FilterType(str, Enum):
@@ -52,10 +66,45 @@ def lo_l1c(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
     if "imap_lo_l1b_de" in sci_dependencies:
         logical_source = "imap_lo_l1c_pset"
         l1b_de = sci_dependencies["imap_lo_l1b_de"]
-
         l1b_goodtimes_only = filter_goodtimes(l1b_de, anc_dependencies)
         pset = initialize_pset(l1b_goodtimes_only, attr_mgr, logical_source)
         full_counts = create_pset_counts(l1b_goodtimes_only)
+
+        # Set the pointing start and end times based on the first epoch
+        pointing_start_met, pointing_end_met = get_pointing_times(
+            ttj2000ns_to_met(l1b_goodtimes_only["epoch"][0].item())
+        )
+
+        pset["pointing_start_met"] = xr.DataArray(
+            np.array([pointing_start_met]),
+            dims="epoch",
+            attrs=attr_mgr.get_variable_attributes("pointing_start_met"),
+        )
+        pset["pointing_end_met"] = xr.DataArray(
+            np.array([pointing_end_met]),
+            dims="epoch",
+            attrs=attr_mgr.get_variable_attributes("pointing_end_met"),
+        )
+
+        # Set the epoch to the start of the pointing
+        pset["epoch"] = xr.DataArray(
+            met_to_ttj2000ns(pset["pointing_start_met"].values),
+            attrs=attr_mgr.get_variable_attributes("epoch"),
+        )
+
+        # Get the start and end spin numbers based on the pointing start and end MET
+        pset["start_spin_number"] = xr.DataArray(
+            [get_spin_number(pset["pointing_start_met"].item())],
+            dims="epoch",
+            attrs=attr_mgr.get_variable_attributes("start_spin_number"),
+        )
+        pset["end_spin_number"] = xr.DataArray(
+            [get_spin_number(pset["pointing_end_met"].item())],
+            dims="epoch",
+            attrs=attr_mgr.get_variable_attributes("end_spin_number"),
+        )
+
+        # Set the counts
         pset["triples_counts"] = create_pset_counts(
             l1b_goodtimes_only, FilterType.TRIPLES
         )
@@ -64,19 +113,18 @@ def lo_l1c(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
         )
         pset["h_counts"] = create_pset_counts(l1b_goodtimes_only, FilterType.HYDROGEN)
         pset["o_counts"] = create_pset_counts(l1b_goodtimes_only, FilterType.OXYGEN)
+
+        # Set the exposure time
         pset["exposure_time"] = calculate_exposure_times(
             full_counts, l1b_goodtimes_only
         )
     pset.attrs = attr_mgr.get_global_attributes(logical_source)
-    # TODO: Temp fix before adding attribute variables.
-    #  CDF won't open if DEPEND_0 is not deleted currently.
-    del pset["epoch"].attrs["DEPEND_0"]
 
     pset = pset.assign_coords(
         {
-            "energy": np.arange(1, 8),
-            "longitude": np.arange(3600),
-            "latitude": np.arange(40),
+            "esa_energy_step": ESA_ENERGY_STEPS,
+            "spin_angle": SPIN_ANGLE_BIN_CENTERS,
+            "off_angle": OFF_ANGLE_BIN_CENTERS,
         }
     )
 
@@ -141,7 +189,7 @@ def filter_goodtimes(l1b_de: xr.Dataset, anc_dependencies: list) -> xr.Dataset:
         Filtered L1B Direct Event dataset.
     """
     # the goodtimes are currently the only ancillary file needed for L1C processing
-    goodtimes_table_df = pd.read_csv(anc_dependencies[0])
+    goodtimes_table_df = lo_ancillary.read_ancillary_file(anc_dependencies[0])
 
     # convert goodtimes from MET to TTJ2000
     goodtimes_start = met_to_ttj2000ns(goodtimes_table_df["GoodTime_strt"])
@@ -151,7 +199,7 @@ def filter_goodtimes(l1b_de: xr.Dataset, anc_dependencies: list) -> xr.Dataset:
     goodtimes_mask = np.zeros_like(l1b_de["epoch"], dtype=bool)
 
     # Iterate over the good times and create a mask
-    for start, end in zip(goodtimes_start, goodtimes_end):
+    for start, end in zip(goodtimes_start, goodtimes_end, strict=False):
         goodtimes_mask |= (l1b_de["epoch"] >= start) & (l1b_de["epoch"] < end)
 
     # Filter the dataset using the mask
@@ -249,7 +297,7 @@ def create_pset_counts(
 
     counts = xr.DataArray(
         data=hist.astype(np.int16),
-        dims=["epoch", "energy", "longitude", "latitude"],
+        dims=PSET_DIMS,
     )
 
     return counts
@@ -275,11 +323,6 @@ def calculate_exposure_times(counts: xr.DataArray, l1b_de: xr.Dataset) -> xr.Dat
     exposure_time : xarray.DataArray
         The exposure times for the L1B Direct Event dataset.
     """
-    # Create bin edges
-    lon_edges = np.arange(3601)
-    lat_edges = np.arange(41)
-    energy_edges = np.arange(8)
-
     data = np.column_stack(
         (l1b_de["esa_step"], l1b_de["pointing_bin_lon"], l1b_de["pointing_bin_lat"])
     )
@@ -289,14 +332,19 @@ def calculate_exposure_times(counts: xr.DataArray, l1b_de: xr.Dataset) -> xr.Dat
         # exposure time equation from Lo Alg Document 10.1.1.4
         4 * l1b_de["avg_spin_durations"].to_numpy() / 3600,
         statistic="mean",
-        bins=[energy_edges, lon_edges, lat_edges],
+        # NOTE: The l1b pointing_bin_lon is bin number, not actual angle
+        bins=[
+            np.arange(N_ESA_ENERGY_STEPS + 1),
+            np.arange(N_SPIN_ANGLE_BINS + 1),
+            np.arange(N_OFF_ANGLE_BINS + 1),
+        ],
     )
 
     stat = result.statistic[np.newaxis, :, :, :]
 
     exposure_time = xr.DataArray(
         data=stat.astype(np.float16),
-        dims=["epoch", "energy", "longitude", "latitude"],
+        dims=PSET_DIMS,
     )
 
     return exposure_time
@@ -328,8 +376,6 @@ def create_datasets(
     #  can be used direction
     epoch_converted_time = [1]
 
-    # Create a data array for the epoch time
-    # TODO: might need to update the attrs to use new YAML file
     epoch_time = xr.DataArray(
         data=epoch_converted_time,
         name="epoch",
@@ -338,38 +384,54 @@ def create_datasets(
     )
 
     if logical_source == "imap_lo_l1c_pset":
-        esa_step = xr.DataArray(
-            data=[1, 2, 3, 4, 5, 6, 7],
-            name="esa_step",
-            dims=["esa_step"],
-            attrs=attr_mgr.get_variable_attributes("esa_step"),
-        )
-        pointing_bins = xr.DataArray(
-            data=np.arange(3600),
-            name="pointing_bins",
-            dims=["pointing_bins"],
-            attrs=attr_mgr.get_variable_attributes("pointing_bins"),
+        esa_energy_step = xr.DataArray(
+            data=ESA_ENERGY_STEPS,
+            name="esa_energy_step",
+            dims=["esa_energy_step"],
+            attrs=attr_mgr.get_variable_attributes("esa_energy_step"),
         )
-
-        esa_step_label = xr.DataArray(
-            esa_step.values.astype(str),
+        esa_energy_step_label = xr.DataArray(
+            esa_energy_step.values.astype(str),
             name="esa_step_label",
             dims=["esa_step_label"],
             attrs=attr_mgr.get_variable_attributes("esa_step_label"),
         )
-        pointing_bins_label = xr.DataArray(
-            pointing_bins.values.astype(str),
-            name="pointing_bins_label",
-            dims=["pointing_bins_label"],
-            attrs=attr_mgr.get_variable_attributes("pointing_bins_label"),
+
+        spin_angle = xr.DataArray(
+            data=SPIN_ANGLE_BIN_CENTERS,
+            name="spin_angle",
+            dims=["spin_angle"],
+            attrs=attr_mgr.get_variable_attributes("spin_angle"),
+        )
+        spin_angle_label = xr.DataArray(
+            spin_angle.values.astype(str),
+            name="spin_angle_label",
+            dims=["spin_angle_label"],
+            attrs=attr_mgr.get_variable_attributes("spin_angle_label"),
+        )
+
+        off_angle = xr.DataArray(
+            data=OFF_ANGLE_BIN_CENTERS,
+            name="off_angle",
+            dims=["off_angle"],
+            attrs=attr_mgr.get_variable_attributes("off_angle"),
+        )
+        off_angle_label = xr.DataArray(
+            off_angle.values.astype(str),
+            name="off_angle_label",
+            dims=["off_angle_label"],
+            attrs=attr_mgr.get_variable_attributes("off_angle_label"),
         )
+
         dataset = xr.Dataset(
             coords={
                 "epoch": epoch_time,
-                "pointing_bins": pointing_bins,
-                "pointing_bins_label": pointing_bins_label,
-                "esa_step": esa_step,
-                "esa_step_label": esa_step_label,
+                "esa_energy_step": esa_energy_step,
+                "esa_energy_step_label": esa_energy_step_label,
+                "spin_angle": spin_angle,
+                "spin_angle_label": spin_angle_label,
+                "off_angle": off_angle,
+                "off_angle_label": off_angle_label,
             },
             attrs=attr_mgr.get_global_attributes(logical_source),
         )
@@ -389,30 +451,34 @@ def create_datasets(
 
         # Create a data array for the current field and add it to the dataset
         # TODO: TEMPORARY. need to update to use l1b data once that's available.
-        if field in ["pointing_start", "pointing_end", "mode", "pivot_angle"]:
+        if field in [
+            "pointing_start_met",
+            "pointing_end_met",
+            "esa_mode",
+            "pivot_angle",
+        ]:
             dataset[field] = xr.DataArray(
                 data=[1],
                 dims=dims,
                 attrs=attr_mgr.get_variable_attributes(field),
             )
         # TODO: This is temporary.
-        #  The data type will be set in the data class when that's created
         elif field == "exposure_time":
             dataset[field] = xr.DataArray(
-                data=np.ones((1, 7), dtype=np.float16),
+                data=np.ones((1, 7, 3600, 40), dtype=np.float16),
                 dims=dims,
                 attrs=attr_mgr.get_variable_attributes(field),
             )
 
-        elif "rate" in field:
+        elif "rates" in field:
             dataset[field] = xr.DataArray(
-                data=np.ones((1, 3600, 7), dtype=np.float16),
+                data=np.ones(PSET_SHAPE, dtype=np.float16),
                 dims=dims,
                 attrs=attr_mgr.get_variable_attributes(field),
             )
         else:
             dataset[field] = xr.DataArray(
-                data=np.ones((1, 3600, 7), dtype=np.int16),
+                data=np.ones(PSET_SHAPE, dtype=np.int16),
                 dims=dims,
                 attrs=attr_mgr.get_variable_attributes(field),
             )

imap_processing/lo/l2/lo_l2.py

@@ -5,12 +5,13 @@ import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.ena_maps import ena_maps
-from imap_processing.ena_maps.ena_maps import RectangularSkyMap
-from imap_processing.spice import geometry
-from imap_processing.spice.geometry import SpiceFrame
+from imap_processing.ena_maps.ena_maps import AbstractSkyMap, RectangularSkyMap
+from imap_processing.ena_maps.utils.naming import MapDescriptor
 
 
-def lo_l2(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
+def lo_l2(
+    sci_dependencies: dict, anc_dependencies: list, descriptor: str
+) -> list[xr.Dataset]:
     """
     Will process IMAP-Lo L1C data into Le CDF data products.
 
@@ -20,6 +21,8 @@ def lo_l2(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
         Dictionary of datasets needed for L2 data product creation in xarray Datasets.
     anc_dependencies : list
         Ancillary files needed for L2 data product creation.
+    descriptor : str
+        The map descriptor to be produced.
 
     Returns
     -------
@@ -37,18 +40,19 @@ def lo_l2(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
         logical_source = "imap_lo_l2_l090-ena-h-sf-nsp-ram-hae-6deg-3mo"
         psets = sci_dependencies["imap_lo_l1c_pset"]
 
-        # Create the rectangular sky map from the pointing set.
-        lo_rect_map = project_pset_to_rect_map(
-            psets, spacing_deg=6, spice_frame=geometry.SpiceFrame.ECLIPJ2000
-        )
+        # Create an AbstractSkyMap (Rectangular or HEALPIX) from the pointing set
+        lo_sky_map = project_pset_to_sky_map(psets, descriptor)
+        if not isinstance(lo_sky_map, RectangularSkyMap):
+            raise NotImplementedError("HEALPix map output not supported for Lo")
+
         # Add the hydrogen rates to the rectangular map dataset.
-        lo_rect_map.data_1d["h_rate"] = calculate_rates(
-            lo_rect_map.data_1d["h_counts"], lo_rect_map.data_1d["exposure_time"]
+        lo_sky_map.data_1d["h_rate"] = calculate_rates(
+            lo_sky_map.data_1d["h_counts"], lo_sky_map.data_1d["exposure_time"]
         )
         # Add the hydrogen flux to the rectangular map dataset.
-        lo_rect_map.data_1d["h_flux"] = calculate_fluxes(lo_rect_map.data_1d["h_rate"])
+        lo_sky_map.data_1d["h_flux"] = calculate_fluxes(lo_sky_map.data_1d["h_rate"])
         # Create the dataset from the rectangular map.
-        lo_rect_map_ds = lo_rect_map.to_dataset()
+        lo_rect_map_ds = lo_sky_map.to_dataset()
         # Add the attributes to the dataset.
         lo_rect_map_ds = add_attributes(
             lo_rect_map_ds, attr_mgr, logical_source=logical_source
@@ -57,41 +61,37 @@ def lo_l2(sci_dependencies: dict, anc_dependencies: list) -> list[xr.Dataset]:
     return [lo_rect_map_ds]
 
 
-def project_pset_to_rect_map(
-    psets: list[xr.Dataset], spacing_deg: int, spice_frame: SpiceFrame
-) -> RectangularSkyMap:
+def project_pset_to_sky_map(psets: list[xr.Dataset], descriptor: str) -> AbstractSkyMap:
     """
-    Project the pointing set to a rectangular sky map.
+    Project the pointing set to a sky map.
 
-    This function is used to create a rectangular sky map from the pointing set
+    This function is used to create a sky map from the pointing set
     data in the L1C dataset.
 
     Parameters
     ----------
     psets : list[xr.Dataset]
         List of pointing sets in xarray Dataset format.
-    spacing_deg : int
-        The spacing in degrees for the rectangular sky map.
-    spice_frame : SpiceFrame
-        The SPICE frame to use for the rectangular sky map projection.
+    descriptor : str
+        The map descriptor for the map to be produced,
+        contains details about the map projection.
 
     Returns
     -------
-    RectangularSkyMap
-        The rectangular sky map created from the pointing set data.
+    AbstractSkyMap
+        The sky map created from the pointing set data.
     """
-    lo_rect_map = ena_maps.RectangularSkyMap(
-        spacing_deg=spacing_deg,
-        spice_frame=spice_frame,
-    )
+    map_descriptor = MapDescriptor.from_string(descriptor)
+    output_map = map_descriptor.to_empty_map()
+
     for pset in psets:
         lo_pset = ena_maps.LoPointingSet(pset)
-        lo_rect_map.project_pset_values_to_map(
+        output_map.project_pset_values_to_map(
             pointing_set=lo_pset,
             value_keys=["h_counts", "exposure_time"],
             index_match_method=ena_maps.IndexMatchMethod.PUSH,
         )
-    return lo_rect_map
+    return output_map
 
 
 def calculate_rates(counts: xr.DataArray, exposure_time: xr.DataArray) -> xr.DataArray:

imap_processing/lo/lo_ancillary.py

@@ -0,0 +1,55 @@
+"""Ancillary file reading for IMAP-Lo processing."""
+
+from pathlib import Path
+
+import pandas as pd
+
+# convert the YYYYDDD datetime format directly upon reading
+_CONVERTERS = {
+    "YYYYDDD": lambda x: pd.to_datetime(str(x), format="%Y%j"),
+    "#YYYYDDD": lambda x: pd.to_datetime(str(x), format="%Y%j"),
+    "YYYYDDD_strt": lambda x: pd.to_datetime(str(x), format="%Y%j"),
+    "YYYYDDD_end": lambda x: pd.to_datetime(str(x), format="%Y%j"),
+}
+
+# Columns in the csv files to rename for consistency
+_RENAME_COLUMNS = {
+    "YYYYDDD": "Date",
+    "#YYYYDDD": "Date",
+    "#Comments": "Comments",
+    "YYYYDDD_strt": "StartDate",
+    "YYYYDDD_end": "EndDate",
+}
+
+
+def read_ancillary_file(ancillary_file: str | Path) -> pd.DataFrame:
+    """
+    Read a generic ancillary CSV file into a pandas DataFrame.
+
+    Parameters
+    ----------
+    ancillary_file : str or Path
+        Path to the ancillary CSV file.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame containing the ancillary data.
+    """
+    skiprows = None
+    if "esa-mode-lut" in str(ancillary_file):
+        # skip the first row which is a comment
+        skiprows = [0]
+    elif "geometric-factor" in str(ancillary_file):
+        # skip the rows with comment headers indicating Hi_Res and Hi_Thr
+        skiprows = [1, 38]
+    df = pd.read_csv(ancillary_file, converters=_CONVERTERS, skiprows=skiprows)
+    df = df.rename(columns=_RENAME_COLUMNS)
+
+    if "geometric-factor" in str(ancillary_file):
+        # Add an ESA mode column based on the known structure of the file.
+        # The first 36 rows are ESA mode 0 (HiRes), the second 36 are ESA mode 1 (HiThr)
+        df["esa_mode"] = 0
+        df.loc[36:, "esa_mode"] = 1
+
+    return df