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

imap_processing/mag/l1c/mag_l1c.py

@@ -9,12 +9,14 @@ from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.mag import imap_mag_sdc_configuration_v001 as configuration
 from imap_processing.mag.constants import ModeFlags, VecSec
 from imap_processing.mag.l1c.interpolation_methods import InterpolationFunction
+from imap_processing.spice.time import et_to_ttj2000ns, str_to_et
 
 logger = logging.getLogger(__name__)
 
 
 def mag_l1c(
     first_input_dataset: xr.Dataset,
+    day_to_process: np.datetime64,
     second_input_dataset: xr.Dataset = None,
 ) -> xr.Dataset:
     """
@@ -27,6 +29,9 @@ def mag_l1c(
     first_input_dataset : xr.Dataset
         The first input dataset to process. This can be either burst or norm data, for
         mago or magi.
+    day_to_process : np.datetime64
+        The day to process, in np.datetime64[D] format. This is used to fill gaps at
+        the beginning or end of the day if needed.
     second_input_dataset : xr.Dataset, optional
         The second input dataset to process. This should be burst if first_input_dataset
         was norm, or norm if first_input_dataset was burst. It should match the
@@ -263,13 +268,15 @@ def process_mag_l1c(
     normal_mode_dataset: xr.Dataset,
     burst_mode_dataset: xr.Dataset,
     interpolation_function: InterpolationFunction,
+    day_to_process: np.datetime64 | None = None,
 ) -> np.ndarray:
     """
     Create MAG L1C data from L1B datasets.
 
     This function starts from the normal mode dataset and completes the following steps:
     1. find all the gaps in the dataset
-    2. generate a new timeline with the gaps filled
+    2. generate a new timeline with the gaps filled, including new timestamps to fill
+    out the rest of the day to +/- 15 minutes on either side
     3. fill the timeline with normal mode data (so, all the non-gap timestamps)
     4. interpolate the gaps using the burst mode data and the method specified in
         interpolation_function.
@@ -288,6 +295,10 @@ def process_mag_l1c(
         The burst mode dataset, which is used to fill in the gaps in the normal mode.
     interpolation_function : InterpolationFunction
         The interpolation function to use to fill in the gaps.
+    day_to_process : np.datetime64, optional
+        The day to process, in np.datetime64[D] format. This is used to fill
+        gaps at the beginning or end of the day if needed. If not included, these
+        gaps will not be filled.
 
     Returns
     -------
@@ -306,8 +317,23 @@ def process_mag_l1c(
     output_dataset["sample_interpolated"] = xr.DataArray(
         np.zeros(len(normal_mode_dataset))
     )
+    day_start_ns = None
+    day_end_ns = None
 
-    gaps = find_all_gaps(norm_epoch, normal_vecsec_dict)
+    if day_to_process is not None:
+        day_start = day_to_process.astype("datetime64[s]") - np.timedelta64(15, "m")
+
+        # get the end of the day plus 15 minutes
+        day_end = (
+            day_to_process.astype("datetime64[s]")
+            + np.timedelta64(1, "D")
+            + np.timedelta64(15, "m")
+        )
+
+        day_start_ns = et_to_ttj2000ns(str_to_et(str(day_start)))
+        day_end_ns = et_to_ttj2000ns(str_to_et(str(day_end)))
+
+    gaps = find_all_gaps(norm_epoch, normal_vecsec_dict, day_start_ns, day_end_ns)
 
     new_timeline = generate_timeline(norm_epoch, gaps)
     norm_filled = fill_normal_data(normal_mode_dataset, new_timeline)
@@ -319,7 +345,9 @@ def process_mag_l1c(
 
 
 def fill_normal_data(
-    normal_dataset: xr.Dataset, new_timeline: np.ndarray
+    normal_dataset: xr.Dataset,
+    new_timeline: np.ndarray,
+    day_to_process: np.datetime64 | None = None,
 ) -> np.ndarray:
     """
     Fill the new timeline with the normal mode data.
@@ -332,6 +360,10 @@ def fill_normal_data(
         The normal mode dataset.
     new_timeline : np.ndarray
         A 1D array of timestamps to fill.
+    day_to_process : np.datetime64, optional
+        The day to process, in np.datetime64[D] format. This is used to fill
+        gaps at the beginning or end of the day if needed. If not included, these
+        gaps will not be filled.
 
     Returns
     -------
@@ -341,12 +373,11 @@ def fill_normal_data(
         Indices: 0 - epoch, 1-4 - vector x, y, z, and range, 5 - generated flag,
         6-7 - compression flags.
     """
-    # TODO: fill with FILLVAL?
+    # TODO: fill with FILLVAL
     filled_timeline: np.ndarray = np.zeros((len(new_timeline), 8))
     filled_timeline[:, 0] = new_timeline
     # Flags, will also indicate any missed timestamps
     filled_timeline[:, 5] = ModeFlags.MISSING.value
-
     for index, timestamp in enumerate(normal_dataset["epoch"].data):
         timeline_index = np.searchsorted(new_timeline, timestamp)
         filled_timeline[timeline_index, 1:5] = normal_dataset["vectors"].data[index]
@@ -399,9 +430,11 @@ def interpolate_gaps(
         )
 
     for gap in gaps:
-        # TODO: we might need a few inputs before or after start/end
+        # TODO: we need extra data at the beginning and end of the gap
         burst_gap_start = (np.abs(burst_epochs - gap[0])).argmin()
         burst_gap_end = (np.abs(burst_epochs - gap[1])).argmin()
+        # if this gap is too big, we may be missing burst data at the start or end of
+        # the day and shouldn't use it here.
 
         # for the CIC filter, we need 2x normal mode cadence seconds
 
@@ -428,10 +461,6 @@ def interpolate_gaps(
         gap_timeline = filled_norm_timeline[
             (filled_norm_timeline > gap[0]) & (filled_norm_timeline < gap[1])
         ]
-        logger.info(
-            f"difference between gap start and burst start: "
-            f"{gap_timeline[0] - burst_epochs[burst_start]}"
-        )
 
         short = (gap_timeline >= burst_epochs[burst_start]) & (
             gap_timeline <= burst_epochs[burst_gap_end]
@@ -487,40 +516,46 @@ def generate_timeline(epoch_data: np.ndarray, gaps: np.ndarray) -> np.ndarray:
         The existing timeline data, in the shape (n,).
     gaps : numpy.ndarray
         An array of gaps to fill, with shape (n, 2) where n is the number of gaps.
-        The gap is specified as (start, end) where start and end both exist in the
-        timeline already.
+        The gap is specified as (start, end).
 
     Returns
     -------
     numpy.ndarray
         The new timeline, filled with the existing data and the generated gaps.
     """
-    full_timeline: np.ndarray = np.zeros(0)
-
-    # When we have our gaps, generate the full timeline
-    last_gap = 0
+    full_timeline: np.ndarray = np.array([])
+    last_index = 0
     for gap in gaps:
-        gap_start_index = np.where(epoch_data == gap[0])[0]
-        gap_end_index = np.where(epoch_data == gap[1])[0]
-        if gap_start_index.size != 1 or gap_end_index.size != 1:
-            raise ValueError("Gap start or end not found in input timeline")
-
+        epoch_start_index = np.searchsorted(epoch_data, gap[0], side="left")
         full_timeline = np.concatenate(
-            (
-                full_timeline,
-                epoch_data[last_gap : gap_start_index[0]],
-                generate_missing_timestamps(gap),
-            )
+            (full_timeline, epoch_data[last_index:epoch_start_index])
         )
-        last_gap = gap_end_index[0]
+        generated_timestamps = generate_missing_timestamps(gap)
+        if generated_timestamps.size == 0:
+            continue
+
+        # Remove any generated timestamps that are already in the timeline
+        # Use np.isin to check for exact matches
+        mask = ~np.isin(generated_timestamps, full_timeline)
+        generated_timestamps = generated_timestamps[mask]
+
+        if generated_timestamps.size == 0:
+            print("All generated timestamps already exist in timeline")
+            continue
 
-    full_timeline = np.concatenate((full_timeline, epoch_data[last_gap:]))
+        full_timeline = np.concatenate((full_timeline, generated_timestamps))
+        last_index = int(np.searchsorted(epoch_data, gap[1], side="left"))
+
+    full_timeline = np.concatenate((full_timeline, epoch_data[last_index:]))
 
     return full_timeline
 
 
 def find_all_gaps(
-    epoch_data: np.ndarray, vecsec_dict: dict | None = None
+    epoch_data: np.ndarray,
+    vecsec_dict: dict | None = None,
+    start_of_day_ns: float | None = None,
+    end_of_day_ns: float | None = None,
 ) -> np.ndarray:
     """
     Find all the gaps in the epoch data.
@@ -529,6 +564,9 @@ def find_all_gaps(
     it will assume a nominal 1/2 second gap. A gap is defined as missing data from the
     expected sequence as defined by vectors_per_second_attr.
 
+    If start_of_day_ns and end_of_day_ns are provided, gaps at the beginning and end of
+    the day will be added if the epoch_data does not cover the full day.
+
     Parameters
     ----------
     epoch_data : numpy.ndarray
@@ -537,6 +575,12 @@ def find_all_gaps(
         A dictionary of the form {start: vecsec, start: vecsec} where start is the time
         in nanoseconds and vecsec is the number of vectors per second. This will be
         used to find the gaps. If not provided, a 1/2 second gap is assumed.
+    start_of_day_ns : float, optional
+        The start of the day in nanoseconds since TTJ2000. If provided, a gap will be
+        added from this time to the first epoch if they don't match.
+    end_of_day_ns : float, optional
+        The end of the day in nanoseconds since TTJ2000. If provided, a gap will be
+        added from the last epoch to this time if they don't match.
 
     Returns
     -------
@@ -546,15 +590,23 @@ def find_all_gaps(
         timeline.
     """
     gaps: np.ndarray = np.zeros((0, 3))
-    if vecsec_dict is None:
-        # TODO: when we go back to the previous file, also retrieve expected
-        #  vectors per second
-        # If no vecsec is provided, assume 2 vectors per second
-        vecsec_dict = {0: VecSec.TWO_VECS_PER_S.value}
+
+    # TODO: when we go back to the previous file, also retrieve expected
+    #  vectors per second
+
+    vecsec_dict = {0: VecSec.TWO_VECS_PER_S.value} | (vecsec_dict or {})
 
     end_index = epoch_data.shape[0]
+
+    if start_of_day_ns is not None and epoch_data[0] > start_of_day_ns:
+        # Add a gap from the start of the day to the first timestamp
+        gaps = np.concatenate(
+            (gaps, np.array([[start_of_day_ns, epoch_data[0], vecsec_dict[0]]]))
+        )
+
     for start_time in reversed(sorted(vecsec_dict.keys())):
-        start_index = np.where(start_time == epoch_data)[0][0]
+        # Find the start index that is equal to or immediately after start_time
+        start_index = np.searchsorted(epoch_data, start_time, side="left")
         gaps = np.concatenate(
             (
                 find_gaps(
@@ -565,6 +617,11 @@ def find_all_gaps(
         )
         end_index = start_index
 
+    if end_of_day_ns is not None and epoch_data[-1] < end_of_day_ns:
+        gaps = np.concatenate(
+            (gaps, np.array([[epoch_data[-1], end_of_day_ns, vecsec_dict[start_time]]]))
+        )
+
     return gaps
 
 
@@ -592,11 +649,9 @@ def find_gaps(timeline_data: np.ndarray, vectors_per_second: int) -> np.ndarray:
     # Expected difference between timestamps in nanoseconds.
     expected_gap = 1 / vectors_per_second * 1e9
 
-    # TODO: timestamps can vary by a few ms. Per Alastair, this can be around 7.5% of
-    #  cadence without counting as a "gap".
     diffs = abs(np.diff(timeline_data))
-    # 3.5e7 == 7.5% of 0.5s in nanoseconds, a common gap. In the future, this number
-    # will be calculated from the expected gap.
+
+    # Gap can be up to 7.5% larger than expected vectors per second due to clock drift
     gap_index = np.asarray(diffs - expected_gap > expected_gap * 0.075).nonzero()[0]
     output: np.ndarray = np.zeros((len(gap_index), 3))
 
@@ -607,7 +662,6 @@ def find_gaps(timeline_data: np.ndarray, vectors_per_second: int) -> np.ndarray:
             vectors_per_second,
         ]
 
-    # TODO: How should I handle/find gaps at the end?
     return output
 
 
@@ -622,7 +676,8 @@ def generate_missing_timestamps(gap: np.ndarray) -> np.ndarray:
     ----------
     gap : numpy.ndarray
         Array of timestamps of shape (2,) containing n gaps with start_gap and
-        end_gap. Start_gap and end_gap both correspond to points in timeline_data.
+        end_gap. Start_gap and end_gap both correspond to points in timeline_data and
+        are included in the output timespan.
 
     Returns
     -------
@@ -630,9 +685,7 @@ def generate_missing_timestamps(gap: np.ndarray) -> np.ndarray:
         Completed timeline.
     """
     # Generated timestamps should always be 0.5 seconds apart
-    # TODO: is this in the configuration file?
     difference_ns = 0.5 * 1e9
-
     output: np.ndarray = np.arange(gap[0], gap[1], difference_ns)
     return output
 
@@ -657,8 +710,9 @@ def vectors_per_second_from_string(vecsec_string: str) -> dict:
     vecsec_dict = {}
     vecsec_segments = vecsec_string.split(",")
     for vecsec_segment in vecsec_segments:
-        start_time, vecsec = vecsec_segment.split(":")
-        vecsec_dict[int(start_time)] = int(vecsec)
+        if vecsec_segment:
+            start_time, vecsec = vecsec_segment.split(":")
+            vecsec_dict[int(start_time)] = int(vecsec)
 
     return vecsec_dict
 

imap_processing/spice/geometry.py

@@ -21,7 +21,7 @@ from numpy.typing import NDArray
 class SpiceBody(IntEnum):
     """Enum containing SPICE IDs for bodies that we use."""
 
-    # A subset of IMAP Specific bodies as defined in imap_001.tf
+    # A subset of IMAP Specific bodies as defined in imap_xxx.tf
     IMAP = -43
     IMAP_SPACECRAFT = -43000
     # IMAP Pointing Frame (Despun) as defined in imap_science_xxx.tf
@@ -58,7 +58,7 @@ class SpiceFrame(IntEnum):
     IMAP_CODICE = -43400
     IMAP_HIT = -43500
     IMAP_IDEX = -43700
-    IMAP_GLOWS = -43751
+    IMAP_GLOWS = -43750
 
     # IMAP Science Frames (new additions from imap_science_xxx.tf)
     IMAP_OMD = -43900
@@ -85,6 +85,8 @@ class SpiceFrame(IntEnum):
 
 BORESIGHT_LOOKUP = {
     SpiceFrame.IMAP_LO_BASE: np.array([0, -1, 0]),
+    SpiceFrame.IMAP_LO: np.array([0, -1, 0]),
+    SpiceFrame.IMAP_LO_STAR_SENSOR: np.array([0, -1, 0]),
     SpiceFrame.IMAP_HI_45: np.array([0, 1, 0]),
     SpiceFrame.IMAP_HI_90: np.array([0, 1, 0]),
     SpiceFrame.IMAP_ULTRA_45: np.array([0, 0, 1]),
@@ -160,7 +162,7 @@ def get_instrument_mounting_az_el(instrument: SpiceFrame) -> np.ndarray:
     # frame that is used to compute the s/c to instrument mounting.
     # Most of these vectors are the same as the instrument boresight vector.
     mounting_normal_vector = {
-        SpiceFrame.IMAP_LO_BASE: np.array([0, -1, 0]),
+        SpiceFrame.IMAP_LO_BASE: np.array([0, 0, -1]),
         SpiceFrame.IMAP_HI_45: np.array([0, 1, 0]),
         SpiceFrame.IMAP_HI_90: np.array([0, 1, 0]),
         SpiceFrame.IMAP_ULTRA_45: np.array([0, 0, 1]),
@@ -190,11 +192,16 @@ def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> fl
     """
     Get the spin phase offset from the spacecraft to the instrument.
 
-    For now, the offset is a fixed lookup based on `Table 1: Nominal Instrument
+    Nominal offset values were determined using `Table 1: Nominal Instrument
     to S/C CS Transformations` in document `7516-0011_drw.pdf`. That Table
-    defines the angle from the spacecraft y-axis. We add 90 and take the modulous
-    with 360 in order to get the angle from the spacecraft x-axis. These fixed
-    values will need to be updated based on calibration data.
+    defines the angle from the spacecraft y-axis. We add 90-degrees and take the
+    modulus with 360 to get the angle from the spacecraft x-axis. This math is
+    shown in the comments after each key value pair in the dictionary defined
+    in code. The true values differ slightly from the nominal values. True
+    values are derived from the frame definitions in the IMAP frames kernel
+    which uses ground calibration measurements to define the as-built mounting
+    of each instrument. The function in this module, `get_instrument_mounting_az_el`,
+    was used to retrieve the true azimuth angles from the IMAP frames kernel.
 
     Parameters
     ----------
@@ -207,19 +214,21 @@ def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> fl
         The spin phase offset from the spacecraft to the instrument.
     """
     phase_offset_lookup = {
-        SpiceFrame.IMAP_LO_BASE: 60 / 360,  # (330 + 90) % 360 = 60
-        SpiceFrame.IMAP_HI_45: 345 / 360,  # 255 + 90 = 345
-        SpiceFrame.IMAP_HI_90: 15 / 360,  # (285 + 90) % 360 = 15
-        SpiceFrame.IMAP_ULTRA_45: 123 / 360,  # 33 + 90 = 123
-        SpiceFrame.IMAP_ULTRA_90: 300 / 360,  # 210 + 90 = 300
+        # Phase offset values based on imap_100.tf frame kernel
+        # See docstring notes for details on how these values were determined.
+        SpiceFrame.IMAP_LO: 60 / 360,  # (330 + 90) % 360 = 60
+        SpiceFrame.IMAP_HI_45: 344.8264 / 360,  # 255 + 90 = 345
+        SpiceFrame.IMAP_HI_90: 15.1649 / 360,  # (285 + 90) % 360 = 15
+        SpiceFrame.IMAP_ULTRA_45: 122.8642 / 360,  # 33 + 90 = 123
+        SpiceFrame.IMAP_ULTRA_90: 299.9511 / 360,  # 210 + 90 = 300
         SpiceFrame.IMAP_SWAPI: 258 / 360,  # 168 + 90 = 258
-        SpiceFrame.IMAP_IDEX: 180 / 360,  # 90 + 90 = 180
-        SpiceFrame.IMAP_CODICE: 226 / 360,  # 136 + 90 = 226
-        SpiceFrame.IMAP_HIT: 120 / 360,  # 30 + 90 = 120
-        SpiceFrame.IMAP_SWE: 243 / 360,  # 153 + 90 = 243
-        SpiceFrame.IMAP_GLOWS: 217 / 360,  # 127 + 90 = 217
-        SpiceFrame.IMAP_MAG_I: 90 / 360,  # 0 + 90 = 90
-        SpiceFrame.IMAP_MAG_O: 90 / 360,  # 0 + 90 = 90
+        SpiceFrame.IMAP_IDEX: 179.9229 / 360,  # 90 + 90 = 180
+        SpiceFrame.IMAP_CODICE: 225.9086 / 360,  # 136 + 90 = 226
+        SpiceFrame.IMAP_HIT: 119.6452 / 360,  # 30 + 90 = 120
+        SpiceFrame.IMAP_SWE: 243.0155 / 360,  # 153 + 90 = 243
+        SpiceFrame.IMAP_GLOWS: 217.1384 / 360,  # 127 + 90 = 217
+        SpiceFrame.IMAP_MAG_I: 89.9709 / 360,  # 0 + 90 = 90
+        SpiceFrame.IMAP_MAG_O: 89.4077 / 360,  # 0 + 90 = 90
     }
     return phase_offset_lookup[instrument]
 

imap_processing/ultra/l1c/helio_pset.py

@@ -71,7 +71,7 @@ def calculate_helio_pset(
     """
     pset_dict: dict[str, np.ndarray] = {}
     # Select only the species we are interested in.
-    indices = np.where(np.isin(de_dataset["e_bin"].values, species_id))[0]
+    indices = np.where(np.isin(de_dataset["ebin"].values, species_id))[0]
     species_dataset = de_dataset.isel(epoch=indices)
 
     rejected = get_de_rejection_mask(
@@ -176,7 +176,7 @@ def calculate_helio_pset(
     pset_dict["latitude"] = latitude[np.newaxis, ...]
     pset_dict["longitude"] = longitude[np.newaxis, ...]
     pset_dict["energy_bin_geometric_mean"] = energy_bin_geometric_means
-    pset_dict["helio_exposure_factor"] = exposure_time
+    pset_dict["helio_exposure_factor"] = exposure_time[np.newaxis, ...]
     pset_dict["pixel_index"] = healpix
     pset_dict["energy_bin_delta"] = np.diff(intervals, axis=1).squeeze()[
         np.newaxis, ...

imap_processing/ultra/l1c/spacecraft_pset.py

@@ -72,7 +72,7 @@ def calculate_spacecraft_pset(
     pset_dict: dict[str, np.ndarray] = {}
 
     sensor = parse_filename_like(name)["sensor"][0:2]
-    indices = np.where(np.isin(de_dataset["e_bin"].values, species_id))[0]
+    indices = np.where(np.isin(de_dataset["ebin"].values, species_id))[0]
     species_dataset = de_dataset.isel(epoch=indices)
 
     # If there are no species return None.
@@ -184,7 +184,7 @@ def calculate_spacecraft_pset(
     pset_dict["longitude"] = longitude[np.newaxis, ...]
     pset_dict["energy_bin_geometric_mean"] = energy_bin_geometric_means
     pset_dict["background_rates"] = background_rates[np.newaxis, ...]
-    pset_dict["exposure_factor"] = exposure_pointing
+    pset_dict["exposure_factor"] = exposure_pointing[np.newaxis, ...]
     pset_dict["pixel_index"] = healpix
     pset_dict["energy_bin_delta"] = np.diff(intervals, axis=1).squeeze()[
         np.newaxis, ...
@@ -197,8 +197,11 @@ def calculate_spacecraft_pset(
     pset_dict["dead_time_ratio"] = deadtime_ratios
     pset_dict["spin_phase_step"] = np.arange(len(deadtime_ratios))
 
-    pset_dict["scatter_theta"] = scattering_theta
-    pset_dict["scatter_phi"] = scattering_phi
+    # Convert FWHM to gaussian uncertainty by dividing by 2.355
+    # See algorithm documentation (section 3.5.7, third bullet point) for more details
+    pset_dict["scatter_theta"] = scattering_theta / 2.355
+    pset_dict["scatter_phi"] = scattering_phi / 2.355
+
     pset_dict["scatter_threshold"] = scattering_thresholds
 
     # Add the energy delta plus/minus to the dataset

imap_processing/ultra/l2/ultra_l2.py

@@ -56,18 +56,18 @@ REQUIRED_L1C_VARIABLES_PUSH = [
 ]
 REQUIRED_L1C_VARIABLES_PULL = [
     "exposure_factor",
-    "sensitivity",
     "background_rates",
     "obs_date",
 ]
 # These variables are expected but not strictly required. In certain test scenarios,
 # they may be missing, in which case we will raise a warning and continue.
 # All psets must be consistent and either have these variables or not.
-EXPECTED_L1C_VARIABLES_PULL = [
+EXPECTED_L1C_POINTING_INDEPENDENT_VARIABLES_PULL = [
     "geometric_function",
-    "efficiency",
     "scatter_theta",
     "scatter_phi",
+    "sensitivity",
+    "efficiency",
 ]
 # These variables are projected to the map as the mean of pointing set pixels value,
 # weighted by that pointing set pixel's exposure and solid angle
@@ -75,10 +75,10 @@ VARIABLES_TO_WEIGHT_BY_POINTING_SET_EXPOSURE_TIMES_SOLID_ANGLE = [
     "sensitivity",
     "background_rates",
     "obs_date",
-    "geometric_function",
-    "efficiency",
     "scatter_theta",
     "scatter_phi",
+    "geometric_function",
+    "efficiency",
 ]
 
 # These variables are dropped after they are used to
@@ -148,7 +148,7 @@ def get_variable_attributes_optional_energy_dependence(
     return metadata
 
 
-def generate_ultra_healpix_skymap(
+def generate_ultra_healpix_skymap(  # noqa: PLR0912
     ultra_l1c_psets: list[str | xr.Dataset],
     output_map_structure: (
         ena_maps.RectangularSkyMap | ena_maps.HealpixSkyMap
@@ -160,7 +160,7 @@ def generate_ultra_healpix_skymap(
     This function combines IMAP Ultra L1C pointing sets into a single L2 HealpixSkyMap.
     It handles the projection of values from pointing sets to the map, applies necessary
     weighting and background subtraction, and calculates ena_intensity
-    and ena_intensity_stat_unc.
+    and ena_intensity_stat_uncert.
 
     Parameters
     ----------
@@ -251,23 +251,36 @@ def generate_ultra_healpix_skymap(
     # TODO remove this in the future once all test data includes these variables
     # Add expected but not required variables to the pull projection list
     # Log a warning if they are missing from any PSET but continue processing.
-    expected_present_vars = []
+    expected_present_vars_pointing_ind = []
     first_pset = (
         load_cdf(ultra_l1c_psets[0])
         if isinstance(ultra_l1c_psets[0], (str, Path))
         else ultra_l1c_psets[0]
     )
-    for var in EXPECTED_L1C_VARIABLES_PULL:
+
+    for var in EXPECTED_L1C_POINTING_INDEPENDENT_VARIABLES_PULL:
         if var not in first_pset.variables:
             logger.warning(
                 f"Expected variable {var} not found in the first L1C PSET. "
                 "This variable will not be projected to the map."
             )
         else:
-            expected_present_vars.append(var)
+            expected_present_vars_pointing_ind.append(var)
+
+    # Get existing variables that should be weighted by exposure and solid angle
+    existing_vars_to_weight = []
+    pointing_indep_vars = []
+    for var in VARIABLES_TO_WEIGHT_BY_POINTING_SET_EXPOSURE_TIMES_SOLID_ANGLE:
+        if var in first_pset:
+            existing_vars_to_weight.append(var)
+            if "epoch" not in first_pset[var].dims:
+                pointing_indep_vars.append(var)
 
     output_map_structure.values_to_pull_project = list(
-        set(output_map_structure.values_to_pull_project + expected_present_vars)
+        set(
+            output_map_structure.values_to_pull_project
+            + expected_present_vars_pointing_ind
+        )
     )
 
     all_pset_epochs = []
@@ -313,13 +326,12 @@ def generate_ultra_healpix_skymap(
         pointing_set.data["pointing_set_exposure_times_solid_angle"] = (
             pointing_set.data["exposure_factor"] * pointing_set.solid_angle
         )
-
-        # Get variables that should be weighted by exposure and solid angle
-        existing_vars_to_weight = []
-        for var in VARIABLES_TO_WEIGHT_BY_POINTING_SET_EXPOSURE_TIMES_SOLID_ANGLE:
-            if var in pointing_set.data:
-                existing_vars_to_weight.append(var)
-
+        # TODO add generalized code in ena_maps to handle this
+        # if the variable does not have an epoch dimension, add one temporarily
+        # to allow for correct broadcasting during weighting.
+        # Keep track of which variables were modified so we can revert them later.
+        for var in pointing_indep_vars:
+            pointing_set.data[var] = pointing_set.data[var].expand_dims("epoch", axis=0)
         # Initial processing for weighted quantities at PSET level
         # Weight the values by exposure and solid angle
         # Ensure only valid pointing set pixels contribute to the weighted mean.
@@ -348,6 +360,9 @@ def generate_ultra_healpix_skymap(
     skymap.data_1d[existing_vars_to_weight] /= skymap.data_1d[
         "pointing_set_exposure_times_solid_angle"
     ]
+    # Revert any pointing independent variables back to their original dims
+    for var in pointing_indep_vars:
+        skymap.data_1d[var] = skymap.data_1d[var].squeeze("epoch", drop=True)
 
     # Background rates must be scaled by the ratio of the solid angles of the
     # map pixel / pointing set pixel
@@ -376,7 +391,7 @@ def generate_ultra_healpix_skymap(
             skymap.data_1d["sensitivity"] * skymap.solid_angle * delta_energy
         )
 
-        skymap.data_1d["ena_intensity_stat_unc"] = (
+        skymap.data_1d["ena_intensity_stat_uncert"] = (
             skymap.data_1d["counts"].astype(float) ** 0.5
         ) / (
             skymap.data_1d["exposure_factor"]
@@ -413,7 +428,7 @@ def generate_ultra_healpix_skymap(
     return skymap, np.array(all_pset_epochs)
 
 
-def ultra_l2(  # noqa: PLR0912
+def ultra_l2(
     data_dict: dict[str, xr.Dataset | str | Path],
     output_map_structure: (
         ena_maps.RectangularSkyMap | ena_maps.HealpixSkyMap
@@ -592,9 +607,11 @@ def ultra_l2(  # noqa: PLR0912
     map_dataset = map_dataset.rename({"energy_bin_geometric_mean": "energy"})
 
     # Rename positional uncertainty variables if present
-    if "scatter_theta" in map_dataset and "scatter_phi" in map_dataset:
-        map_dataset = map_dataset.rename({"scatter_theta": "positional_uncert_theta"})
-        map_dataset = map_dataset.rename({"scatter_phi": "positional_uncert_phi"})
+    map_dataset = map_dataset.rename({"scatter_theta": "positional_uncert_theta"})
+    map_dataset = map_dataset.rename({"scatter_phi": "positional_uncert_phi"})
+
+    # Rename background rates to be compliant with the l2 map definitions
+    map_dataset = map_dataset.rename({"background_rates": "bg_rate"})
 
     # Add the defined attributes to the map's global attrs
     map_dataset.attrs.update(map_attrs)
@@ -613,7 +630,7 @@ def ultra_l2(  # noqa: PLR0912
     # Add systematic error as all zeros with shape matching statistical unc
     # TODO: update once we have information from the instrument team
     map_dataset["ena_intensity_sys_err"] = xr.zeros_like(
-        map_dataset["ena_intensity_stat_unc"],
+        map_dataset["ena_intensity_stat_uncert"],
     )
 
     # Add epoch_delta
@@ -635,7 +652,6 @@ def ultra_l2(  # noqa: PLR0912
         energy_delta_plus,
         dims=(CoordNames.ENERGY_L2.value,),
     )
-
     # Add variable specific attributes to the map's data_vars and coords
     for variable in map_dataset.data_vars:
         # Skip the subdivision depth variables, as these will only be
@@ -643,14 +659,25 @@ def ultra_l2(  # noqa: PLR0912
         if "subdivision_depth" in variable:
             continue
 
+        # Support variables do not have epoch as the first dimension
+        # skip schema check for support variables or choords
+        skip_schema_check = not (
+            "epoch" not in map_dataset[variable].dims  # Support data
+            or variable
+            in [
+                "longitude",
+                "latitude",
+                "longitude_delta",
+                "latitude_delta",
+            ]  # Coordinate vars
+        )
         # The longitude and latitude variables will be present only in Healpix tiled
         # map, and, as support_data, should not have schema validation
         map_dataset[variable].attrs.update(
             get_variable_attributes_optional_energy_dependence(
                 cdf_attrs=cdf_attrs,
                 variable_array=map_dataset[variable],
-                check_schema=variable
-                not in ["longitude", "latitude", "longitude_delta", "latitude_delta"],
+                check_schema=skip_schema_check,
             )
         )
     for coord_variable in map_dataset.coords: