imap-processing 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

imap_processing/hi/hi_l2.py

@@ -11,14 +11,26 @@ from imap_processing.ena_maps.ena_maps import (
     HiPointingSet,
     RectangularSkyMap,
 )
-from imap_processing.ena_maps.utils.corrections import PowerLawFluxCorrector
+from imap_processing.ena_maps.utils.corrections import (
+    PowerLawFluxCorrector,
+    apply_compton_getting_correction,
+    interpolate_map_flux_to_helio_frame,
+)
 from imap_processing.ena_maps.utils.naming import MapDescriptor
 from imap_processing.hi.utils import CalibrationProductConfig
 
 logger = logging.getLogger(__name__)
 
+SC_FRAME_VARS_TO_PROJECT = {
+    "counts",
+    "exposure_factor",
+    "bg_rates",
+    "bg_rates_unc",
+    "obs_date",
+}
+HELIO_FRAME_VARS_TO_PROJECT = SC_FRAME_VARS_TO_PROJECT | {"energy_sc"}
 # TODO: is an exposure time weighted average for obs_date appropriate?
-VARS_TO_EXPOSURE_TIME_AVERAGE = ["bg_rates", "bg_rates_unc", "obs_date"]
+FULL_EXPOSURE_TIME_AVERAGE_SET = {"bg_rates", "bg_rates_unc", "obs_date", "energy_sc"}
 
 
 def hi_l2(
@@ -98,33 +110,74 @@ def generate_hi_map(
         The sky map with all the PSET data projected into the map.
     """
     output_map = descriptor.to_empty_map()
+    vars_to_bin = (
+        HELIO_FRAME_VARS_TO_PROJECT
+        if descriptor.frame_descriptor == "hf"
+        else SC_FRAME_VARS_TO_PROJECT
+    )
+    vars_to_exposure_time_average = FULL_EXPOSURE_TIME_AVERAGE_SET & vars_to_bin
 
     if not isinstance(output_map, RectangularSkyMap):
         raise NotImplementedError("Healpix map output not supported for Hi")
 
-    # TODO: Implement Compton-Getting correction
-    if descriptor.frame_descriptor != "sf":
-        raise NotImplementedError("CG correction not implemented for Hi")
+    cached_esa_steps = None
 
     for pset_path in psets:
         logger.info(f"Processing {pset_path}")
-        pset = HiPointingSet(pset_path, spin_phase=descriptor.spin_phase)
-
-        # Background rate and uncertainty are exposure time weighted means in
-        # the map.
-        for var in VARS_TO_EXPOSURE_TIME_AVERAGE:
-            pset.data[var] *= pset.data["exposure_factor"]
+        pset = HiPointingSet(pset_path)
+
+        # Store the first PSET esa_energy_step values and make sure every PSET
+        # contains the same set of esa_energy_step values.
+        # TODO: Correctly handle PSETs with different esa_energy_step values.
+        if cached_esa_steps is None:
+            cached_esa_steps = pset.data["esa_energy_step"].values.copy()
+            esa_ds = esa_energy_df(
+                l2_ancillary_path_dict["esa-energies"],
+                pset.data["esa_energy_step"].values,
+            ).to_xarray()
+            energy_kev = esa_ds["nominal_central_energy"]
+        if not np.array_equal(cached_esa_steps, pset.data["esa_energy_step"].values):
+            raise ValueError(
+                "All PSETs must have the same set of esa_energy_step values."
+            )
+
+        if descriptor.frame_descriptor == "hf":
+            # convert esa nominal central energy from keV to eV
+            esa_energy_ev = energy_kev * 1000
+            pset = apply_compton_getting_correction(pset, esa_energy_ev)
+
+        # Multiply variables that need to be exposure time weighted average by
+        # exposure factor.
+        for var in vars_to_exposure_time_average:
+            if var in pset.data:
+                pset.data[var] *= pset.data["exposure_factor"]
+
+        # Set the mask used to filter ram/anti-ram pixels
+        pset_valid_mask = None  # Default to no mask (full spin)
+        if descriptor.spin_phase == "ram":
+            pset_valid_mask = pset.data["ram_mask"]
+            logger.debug(
+                f"Using ram mask with shape: {pset_valid_mask.shape} "
+                f"containing {np.prod(pset_valid_mask.shape)} pixels,"
+                f"{np.sum(pset_valid_mask.values)} of which are True."
+            )
+        elif descriptor.spin_phase == "anti":
+            pset_valid_mask = ~pset.data["ram_mask"]
+            logger.debug(
+                f"Using anti-ram mask with shape: {pset_valid_mask.shape} "
+                f"containing {np.prod(pset_valid_mask.shape)} pixels,"
+                f"{np.sum(pset_valid_mask.values)} of which are True."
+            )
 
         # Project (bin) the PSET variables into the map pixels
         output_map.project_pset_values_to_map(
-            pset,
-            ["counts", "exposure_factor", "bg_rates", "bg_rates_unc", "obs_date"],
+            pset, list(vars_to_bin), pset_valid_mask=pset_valid_mask
         )
 
     # Finish the exposure time weighted mean calculation of backgrounds
     # Allow divide by zero to fill set pixels with zero exposure time to NaN
     with np.errstate(divide="ignore"):
-        for var in VARS_TO_EXPOSURE_TIME_AVERAGE:
+        for var in vars_to_exposure_time_average:
             output_map.data_1d[var] /= output_map.data_1d["exposure_factor"]
 
     output_map.data_1d.update(calculate_ena_signal_rates(output_map.data_1d))
@@ -138,30 +191,27 @@ def generate_hi_map(
     # TODO: Figure out how to compute obs_date_range (stddev of obs_date)
     output_map.data_1d["obs_date_range"] = xr.zeros_like(output_map.data_1d["obs_date"])
 
+    # Set the energy_step_delta values to the energy bandpass half-width-half-max
+    energy_delta = esa_ds["bandpass_fwhm"] / 2
+    output_map.data_1d["energy_delta_minus"] = energy_delta
+    output_map.data_1d["energy_delta_plus"] = energy_delta
+
     # Rename and convert coordinate from esa_energy_step energy
-    esa_df = esa_energy_df(
-        l2_ancillary_path_dict["esa-energies"],
-        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_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.assign_coords(energy=energy_kev.values)
 
     output_map.data_1d = output_map.data_1d.drop("esa_energy_step_label")
 
+    # Apply Compton-Getting interpolation for heliocentric frame maps
+    if descriptor.frame_descriptor == "hf":
+        esa_energy_ev = esa_energy_ev.rename({"esa_energy_step": "energy"})
+        esa_energy_ev = esa_energy_ev.assign_coords(energy=energy_kev.values)
+        output_map.data_1d = interpolate_map_flux_to_helio_frame(
+            output_map.data_1d,
+            output_map.data_1d["energy"] * 1000,  # Convert ESA energies to eV
+            esa_energy_ev,  # heliocentric energies (same as ESA energies)
+        )
+
     return output_map
 
 
@@ -420,7 +470,7 @@ def _calculate_improved_stat_variance(
 
 
 def esa_energy_df(
-    esa_energies_path: str | Path, esa_energy_steps: np.ndarray
+    esa_energies_path: str | Path, esa_energy_steps: np.ndarray | slice | None = None
 ) -> pd.DataFrame:
     """
     Lookup the nominal central energy values for given esa energy steps.
@@ -429,8 +479,9 @@ def esa_energy_df(
     ----------
     esa_energies_path : str or pathlib.Path
         Location of the calibration csv file containing the lookup data.
-    esa_energy_steps : numpy.ndarray
-        The ESA energy steps to get energies for.
+    esa_energy_steps : numpy.ndarray, slice, or None
+        The ESA energy steps to get energies for. If not provided (default is None),
+        the full dataframe is returned.
 
     Returns
     -------
@@ -438,6 +489,8 @@ def esa_energy_df(
         Full data frame from the csv file filtered to only include the
         esa_energy_steps input.
     """
+    if esa_energy_steps is None:
+        esa_energy_steps = slice(None)
     esa_energies_lut = pd.read_csv(
         esa_energies_path, comment="#", index_col="esa_energy_step"
     )

imap_processing/ialirt/calculate_ingest.py

@@ -9,7 +9,7 @@ from imap_processing.ialirt.constants import STATIONS
 logger = logging.getLogger(__name__)
 
 
-def find_tcp_connections(
+def find_tcp_connections(  # noqa: PLR0912
     start_file_creation: datetime,
     end_file_creation: datetime,
     lines: list,
@@ -35,8 +35,16 @@ def find_tcp_connections(
         Output dictionary with tcp connection info.
     """
     current_starts: dict[str, datetime | None] = {}
+    partners_opened = set()
 
     for line in lines:
+        # Note if this line appears.
+        if "Opened raw record file" in line:
+            station = line.split("Opened raw record file for ")[1].split(
+                " antenna_partner"
+            )[0]
+            partners_opened.add(station)
+
         if "antenna partner connection is" not in line:
             continue
 
@@ -84,6 +92,16 @@ def find_tcp_connections(
                 }
             )
 
+    # Handle stations with only "Opened raw record file" (no up/down)
+    for station in partners_opened:
+        if not realtime_summary["connection_times"][station]:
+            realtime_summary["connection_times"][station].append(
+                {
+                    "start": datetime.isoformat(start_file_creation),
+                    "end": datetime.isoformat(end_file_creation),
+                }
+            )
+
     # Filter out connection windows that are completely outside the time window
     for station in realtime_summary["connection_times"]:
         realtime_summary["connection_times"][station] = [

imap_processing/ialirt/constants.py

@@ -53,12 +53,6 @@ class StationProperties(NamedTuple):
 # Verified by Kiel and KSWC Observatory staff.
 # Notes: the KSWC station is not yet operational,
 # but will have the following properties:
-# "KSWC": StationProperties(
-#     longitude=126.2958,  # degrees East
-#     latitude=33.4273,  # degrees North
-#     altitude=0.1,  # approx 100 meters
-#     min_elevation_deg=5,  # 5 degrees is the requirement
-# ),
 STATIONS = {
     "Kiel": StationProperties(
         longitude=10.1808,  # degrees East
@@ -66,10 +60,22 @@ STATIONS = {
         altitude=0.1,  # approx 100 meters
         min_elevation_deg=5,  # 5 degrees is the requirement
     ),
+    "Korea": StationProperties(
+        longitude=126.2958,  # degrees East
+        latitude=33.4273,  # degrees North
+        altitude=0.1,  # approx 100 meters
+        min_elevation_deg=5,  # 5 degrees is the requirement
+    ),
     "Manaus": StationProperties(
         longitude=-59.969334,  # degrees East (negative = West)
         latitude=-2.891257,  # degrees North (negative = South)
         altitude=0.1,  # approx 100 meters
         min_elevation_deg=5,  # 5 degrees is the requirement
     ),
+    "SANSA": StationProperties(
+        longitude=27.714,  # degrees East (negative = West)
+        latitude=-25.888,  # degrees North (negative = South)
+        altitude=1.542,  # approx 1542 meters
+        min_elevation_deg=2,  # 5 degrees is the requirement
+    ),
 }

imap_processing/ialirt/generate_coverage.py

@@ -57,6 +57,9 @@ def generate_coverage(
 
     stations = {
         "Kiel": STATIONS["Kiel"],
+        "Korea": STATIONS["Korea"],
+        "Manaus": STATIONS["Manaus"],
+        "SANSA": STATIONS["SANSA"],
     }
     coverage_dict = {}
     outage_dict = {}
@@ -77,7 +80,9 @@ def generate_coverage(
                 dsn_outage_mask |= (time_range >= start_et) & (time_range <= end_et)
 
     for station_name, (lon, lat, alt, min_elevation) in stations.items():
-        _azimuth, elevation = calculate_azimuth_and_elevation(lon, lat, alt, time_range)
+        _azimuth, elevation = calculate_azimuth_and_elevation(
+            lon, lat, alt, time_range, obsref="IAU_EARTH"
+        )
         visible = elevation > min_elevation
 
         outage_mask = np.zeros(time_range.shape, dtype=bool)

imap_processing/ialirt/l0/parse_mag.py

@@ -710,6 +710,7 @@ def process_packet(
                 "met": int(met_all[i]),
                 "met_in_utc": met_to_utc(met_all[i]).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met_all[i])),
+                "instrument": "mag",
                 "mag_epoch": int(mago_times_all[i]),
                 "mag_B_GSE": [Decimal(str(v)) for v in gse_vector[i]],
                 "mag_B_GSM": [Decimal(str(v)) for v in gsm_vector[i]],

imap_processing/ialirt/l0/process_hit.py

@@ -171,6 +171,7 @@ def process_hit(xarray_data: xr.Dataset) -> list[dict]:
                 "met": int(met),
                 "met_in_utc": met_to_utc(met).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met)),
+                "instrument": "hit",
                 "hit_e_a_side_low_en": int(l1["IALRT_RATE_1"] + l1["IALRT_RATE_2"]),
                 "hit_e_a_side_med_en": int(l1["IALRT_RATE_5"] + l1["IALRT_RATE_6"]),
                 "hit_e_a_side_high_en": int(l1["IALRT_RATE_7"]),

imap_processing/ialirt/l0/process_swapi.py

@@ -226,6 +226,7 @@ def process_swapi_ialirt(
                 "met": int(met_values[entry]),
                 "met_in_utc": met_to_utc(met_values[entry]).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met_values[entry])),
+                "instrument": "swapi",
                 "swapi_pseudo_proton_speed": Decimal(solution["pseudo_speed"][entry]),
                 "swapi_pseudo_proton_density": Decimal(
                     solution["pseudo_density"][entry]

imap_processing/ialirt/l0/process_swe.py

@@ -553,6 +553,7 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
                 "met": met_first_half,
                 "met_in_utc": met_to_utc(met_first_half).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met_first_half)),
+                "instrument": "swe",
                 "swe_normalized_counts": [int(val) for val in summed_first],
                 "swe_counterstreaming_electrons": bde_first_half,
             },
@@ -563,6 +564,7 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
                 "met": met_second_half,
                 "met_in_utc": met_to_utc(met_second_half).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met_second_half)),
+                "instrument": "swe",
                 "swe_normalized_counts": [int(val) for val in summed_second],
                 "swe_counterstreaming_electrons": bde_second_half,
             },

imap_processing/ialirt/process_ephemeris.py

@@ -72,6 +72,7 @@ def calculate_azimuth_and_elevation(
     altitude: float,
     observation_time: float | np.ndarray,
     target: str = SpiceBody.IMAP.name,
+    obsref: str = "ITRF93",
 ) -> tuple:
     """
     Calculate azimuth and elevation.
@@ -91,6 +92,9 @@ def calculate_azimuth_and_elevation(
         is to be computed. Expressed as ephemeris time, seconds past J2000 TDB.
     target : str (Optional)
         The target body. Default is "IMAP".
+    obsref : str (Optional)
+        Body-fixed, body-centered reference frame wrt
+        observer's center.
 
     Returns
     -------
@@ -120,7 +124,7 @@ def calculate_azimuth_and_elevation(
             elplsz=True,  # Elevation increases from the XY plane toward +Z
             obspos=ground_station_position_ecef,  # observer pos. to center of motion
             obsctr="EARTH",  # Name of the center of motion
-            obsref="IAU_EARTH",  # Body-fixed, body-centered reference frame wrt
+            obsref=obsref,  # Body-fixed, body-centered reference frame wrt
             # observer's center
         )
         azimuth.append(np.rad2deg(azel_results[0][1]))
@@ -223,7 +227,7 @@ def build_output(
 
     # For now, assume that kernel management will be handled by ensure_spice
     azimuth, elevation = calculate_azimuth_and_elevation(
-        longitude, latitude, altitude, time_range
+        longitude, latitude, altitude, time_range, obsref="ITRF93"
     )
 
     output_dict["time"] = et_to_utc(time_range, format_str="ISOC")

imap_processing/ialirt/utils/create_xarray.py

@@ -52,7 +52,7 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
         ["radial", "tangential", "normal"],
         name="RTN_component",
         dims=["RTN_component"],
-        attrs=cdf_manager.get_variable_attributes("RTN_componentt", check_schema=False),
+        attrs=cdf_manager.get_variable_attributes("RTN_component", check_schema=False),
     )
 
     esa_step = xr.DataArray(
@@ -85,7 +85,7 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
         name="codice_hi_h_spin_angle",
         dims=["codice_hi_h_spin_angle"],
         attrs=cdf_manager.get_variable_attributes(
-            "codice_hi_h_spin_anglen", check_schema=False
+            "codice_hi_h_spin_angle", check_schema=False
         ),
     )
 
@@ -156,6 +156,7 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
                 "sc_velocity_GSE",
                 "mag_hk_status",
                 "spice_kernels",
+                "instrument",
             ]:
                 continue
             elif key in ["mag_B_GSE", "mag_B_GSM", "mag_B_RTN"]:

imap_processing/lo/l1b/lo_l1b.py

@@ -19,6 +19,7 @@ from imap_processing.lo.l1b.tof_conversions import (
 from imap_processing.spice.geometry import (
     SpiceFrame,
     cartesian_to_latitudinal,
+    frame_transform,
     instrument_pointing,
 )
 from imap_processing.spice.repoint import get_pointing_times
@@ -760,8 +761,10 @@ def set_bad_or_goodtimes(
     # the bin_start and bin_end are 6 degree bins and need to be converted to
     # 0.1 degree bins to align with the spin_bins, so multiply by 60
     time_mask = (epochs[:, None] >= times_start) & (epochs[:, None] <= times_end)
+    # The ancillary file binning uses 0-59 for the 6 degree bins, so add 1 to bin_end
+    # so the upper bound is inclusive of the full bin range.
     bin_mask = (spin_bins[:, None] >= times_df["bin_start"].values * 60) & (
-        spin_bins[:, None] <= times_df["bin_end"].values * 60
+        spin_bins[:, None] < (times_df["bin_end"].values + 1) * 60
     )
 
     # Combined mask for epochs that fall within the time and bin ranges
@@ -853,8 +856,15 @@ def set_pointing_bin(l1b_de: xr.Dataset) -> xr.Dataset:
     x = l1b_de["hae_x"]
     y = l1b_de["hae_y"]
     z = l1b_de["hae_z"]
+    # Convert from HAE to DPS coordinates
+    dps_xyz = frame_transform(
+        ttj2000ns_to_et(l1b_de["epoch"]),
+        np.column_stack((x, y, z)),
+        SpiceFrame.IMAP_HAE,
+        SpiceFrame.IMAP_DPS,
+    )
     # convert the pointing direction to latitudinal coordinates
-    direction = cartesian_to_latitudinal(np.column_stack((x, y, z)))
+    direction = cartesian_to_latitudinal(dps_xyz)
     # first column: radius (Not needed)
     # second column: longitude
     lons = direction[:, 1]

imap_processing/lo/l1c/lo_l1c.py

@@ -295,14 +295,14 @@ def create_pset_counts(
     data = np.column_stack(
         (
             de_filtered["esa_step"],
-            de_filtered["pointing_bin_lon"],
-            de_filtered["pointing_bin_lat"],
+            de_filtered["spin_bin"],
+            de_filtered["off_angle_bin"],
         )
     )
     # Create the histogram with 3600 longitude bins, 40 latitude bins, and 7 energy bins
     lon_edges = np.arange(3601)
     lat_edges = np.arange(41)
-    energy_edges = np.arange(8)
+    energy_edges = np.arange(1, 9)
 
     hist, _edges = np.histogramdd(
         data,
@@ -341,7 +341,7 @@ def calculate_exposure_times(counts: xr.DataArray, l1b_de: xr.Dataset) -> xr.Dat
         The exposure times for the L1B Direct Event dataset.
     """
     data = np.column_stack(
-        (l1b_de["esa_step"], l1b_de["pointing_bin_lon"], l1b_de["pointing_bin_lat"])
+        (l1b_de["esa_step"], l1b_de["spin_bin"], l1b_de["off_angle_bin"])
     )
 
     result = binned_statistic_dd(

imap_processing/lo/l2/lo_l2.py

@@ -10,6 +10,7 @@ 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 AbstractSkyMap, RectangularSkyMap
+from imap_processing.ena_maps.utils.corrections import PowerLawFluxCorrector
 from imap_processing.ena_maps.utils.naming import MapDescriptor
 from imap_processing.lo import lo_ancillary
 from imap_processing.spice.time import et_to_datetime64, ttj2000ns_to_et
@@ -77,7 +78,13 @@ def lo_l2(
     logger.info("Step 4: Calculating rates and intensities")
 
     # Determine if corrections are needed and prepare oxygen data if required
-    sputtering_correction, bootstrap_correction, o_map_dataset = _prepare_corrections(
+    (
+        sputtering_correction,
+        bootstrap_correction,
+        flux_correction,
+        o_map_dataset,
+        flux_factors,
+    ) = _prepare_corrections(
         map_descriptor, descriptor, sci_dependencies, anc_dependencies
     )
 
@@ -85,7 +92,9 @@ def lo_l2(
         dataset,
         sputtering_correction=sputtering_correction,
         bootstrap_correction=bootstrap_correction,
+        flux_correction=flux_correction,
         o_map_dataset=o_map_dataset,
+        flux_factors=flux_factors,
     )
 
     logger.info("Step 5: Finalizing dataset with attributes")
@@ -100,7 +109,7 @@ def _prepare_corrections(
     descriptor: str,
     sci_dependencies: dict,
     anc_dependencies: list,
-) -> tuple[bool, bool, xr.Dataset | None]:
+) -> tuple[bool, bool, bool, xr.Dataset | None, Path | None]:
     """
     Determine what corrections are needed and prepare oxygen dataset if required.
 
@@ -130,7 +139,9 @@ def _prepare_corrections(
     # Default values - no corrections needed
     sputtering_correction = False
     bootstrap_correction = False
+    flux_correction = False
     o_map_dataset = None
+    flux_factors: None | Path = None
 
     # Sputtering and bootstrap corrections are only applied to hydrogen ENA data
     # Guard against recursion: don't process oxygen for oxygen maps
@@ -145,7 +156,24 @@ def _prepare_corrections(
         sputtering_correction = True
         bootstrap_correction = True
 
-    return sputtering_correction, bootstrap_correction, o_map_dataset
+    if "raw" not in map_descriptor.principal_data:
+        flux_correction = True
+        try:
+            flux_factors = next(
+                x for x in anc_dependencies if "esa-eta-fit-factors" in str(x)
+            )
+        except StopIteration:
+            raise ValueError(
+                "No flux correction factor file found in ancillary dependencies"
+            ) from None
+
+    return (
+        sputtering_correction,
+        bootstrap_correction,
+        flux_correction,
+        o_map_dataset,
+        flux_factors,
+    )
 
 
 # =============================================================================
@@ -664,7 +692,9 @@ def calculate_all_rates_and_intensities(
     dataset: xr.Dataset,
     sputtering_correction: bool = False,
     bootstrap_correction: bool = False,
+    flux_correction: bool = False,
     o_map_dataset: xr.Dataset | None = None,
+    flux_factors: Path | None = None,
 ) -> xr.Dataset:
     """
     Calculate rates and intensities with proper error propagation.
@@ -679,8 +709,13 @@ def calculate_all_rates_and_intensities(
     bootstrap_correction : bool, optional
         Whether to apply bootstrap corrections to intensities.
         Default is False.
+    flux_correction : bool, optional
+        Whether to apply flux corrections to intensities.
+        Default is False.
     o_map_dataset : xr.Dataset, optional
         Dataset specifically for oxygen, needed for sputtering corrections.
+    flux_factors : Path, optional
+        Path to flux factor file for flux corrections.
 
     Returns
     -------
@@ -705,7 +740,13 @@ def calculate_all_rates_and_intensities(
     if bootstrap_correction:
         dataset = calculate_bootstrap_corrections(dataset)
 
-    # Step 6: Clean up intermediate variables
+    # Optional Step 6: Calculate flux corrections
+    if flux_correction:
+        if flux_factors is None:
+            raise ValueError("Flux factors file must be provided for flux corrections")
+        dataset = calculate_flux_corrections(dataset, flux_factors)
+
+    # Step 7: Clean up intermediate variables
     dataset = cleanup_intermediate_variables(dataset)
 
     return dataset
@@ -938,8 +979,10 @@ def calculate_bootstrap_corrections(dataset: xr.Dataset) -> xr.Dataset:
         bootstrap_factor_array,
         dims=["energy_i", "energy_k"],
         coords={
-            "energy_i": list(range(7)),
-            "energy_k": list(range(8)),  # Include virtual channel 7 (index 7)
+            "energy_i": dataset["energy"].values,
+            # Add an extra coordinate for the virtual E8 channel, unused
+            # in the broadcasting calculations
+            "energy_k": np.concatenate([dataset["energy"].values, [np.nan]]),
         },
     )
 
@@ -1001,7 +1044,7 @@ def calculate_bootstrap_corrections(dataset: xr.Dataset) -> xr.Dataset:
         # NOTE: The paper uses 1-based indexing and we use 0-based indexing
         #       so there is an off-by-one difference in the indices.
         bootstrap_intensity_i[:] = (
-            j_c_prime_i - bootstrap_factor.sel(energy_i=i, energy_k=7) * j_8_b[0, ...]
+            j_c_prime_i - bootstrap_factor.isel(energy_i=i, energy_k=7) * j_8_b[0, ...]
         )
         # NOTE: We will square root at the end to get the uncertainty, but
         #       all equations are with variances
@@ -1013,7 +1056,7 @@ def calculate_bootstrap_corrections(dataset: xr.Dataset) -> xr.Dataset:
 
         # Get bootstrap factors for this i and the relevant k values
         # Rename energy_k dimension to energy for alignment with intensity
-        bootstrap_factors_k = bootstrap_factor.sel(
+        bootstrap_factors_k = bootstrap_factor.isel(
             energy_i=i, energy_k=k_indices
         ).rename({"energy_k": "energy"})
 
@@ -1082,6 +1125,56 @@ def calculate_bootstrap_corrections(dataset: xr.Dataset) -> xr.Dataset:
     return dataset
 
 
+def calculate_flux_corrections(dataset: xr.Dataset, flux_factors: Path) -> xr.Dataset:
+    """
+    Calculate flux corrections for intensities.
+
+    Uses the shared ena maps ``PowerLawFluxCorrector`` class to do the
+    correction calculations.
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        Dataset with count rates, geometric factors, and center energies.
+    flux_factors : Path
+        Path to the eta flux factor file to use for corrections. Read in as
+        an ancillary file in the preprocessing step.
+
+    Returns
+    -------
+    xr.Dataset
+        Dataset with calculated flux-corrected intensities and their
+        uncertainties for the specified species.
+    """
+    logger.info("Applying flux corrections")
+
+    # Flux correction
+    corrector = PowerLawFluxCorrector(flux_factors)
+    # FluxCorrector works on (energy, :) arrays, so we need to flatten the map
+    # spatial dimensions for the correction and then reshape back after.
+    input_shape = dataset["ena_intensity"].shape[1:]  # Exclude epoch dimension
+    intensity = dataset["ena_intensity"].values[0].reshape(len(dataset["energy"]), -1)
+    stat_uncert = (
+        dataset["ena_intensity_stat_uncert"]
+        .values[0]
+        .reshape(len(dataset["energy"]), -1)
+    )
+    corrected_intensity, corrected_stat_unc = corrector.apply_flux_correction(
+        intensity,
+        stat_uncert,
+        dataset["energy"].data,
+    )
+    # Add the size 1 epoch dimension back in to the corrected fluxes.
+    dataset["ena_intensity"].data = corrected_intensity.reshape(input_shape)[
+        np.newaxis, ...
+    ]
+    dataset["ena_intensity_stat_uncert"].data = corrected_stat_unc.reshape(input_shape)[
+        np.newaxis, ...
+    ]
+
+    return dataset
+
+
 def cleanup_intermediate_variables(dataset: xr.Dataset) -> xr.Dataset:
     """
     Remove intermediate variables that were only needed for calculations.

imap_processing/quality_flags.py

@@ -64,6 +64,7 @@ class ImapAttitudeUltraFlags(FlagNameMixin):
     AUXMISMATCH = 2**1  # bit 1 # aux packet does not match Universal Spin Table
     SPINPHASE = 2**2  # bit 2 # spin phase flagged by Universal Spin Table
     SPINPERIOD = 2**3  # bit 3 # spin period flagged by Universal Spin Table
+    DURINGREPOINT = 2**4  # bit 4 # spin during a repointing
 
 
 class ImapRatesUltraFlags(FlagNameMixin):