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

imap_processing/hit/l0/decom_hit.py

@@ -124,9 +124,9 @@ def parse_count_rates(sci_dataset: xr.Dataset) -> None:
         for dim in dims:
             if dim not in sci_dataset.coords:
                 sci_dataset.coords[dim] = xr.DataArray(
-                    np.arange(sci_dataset.sizes[dim], dtype=np.int16)
+                    np.arange(sci_dataset.sizes[dim], dtype=np.uint16)
                     if dim == "gain"
-                    else np.arange(sci_dataset.sizes[dim], dtype=np.int32),
+                    else np.arange(sci_dataset.sizes[dim], dtype=np.uint32),
                     dims=[dim],
                     name=dim,
                 )

imap_processing/hit/l1a/hit_l1a.py

@@ -245,6 +245,69 @@ def calculate_uncertainties(dataset: xr.Dataset) -> xr.Dataset:
     return dataset
 
 
+def add_cdf_attributes(
+    dataset: xr.Dataset, logical_source: str, attr_mgr: ImapCdfAttributes
+) -> xr.Dataset:
+    """
+    Add attributes to the dataset.
+
+    This function adds attributes to the dataset variables and dimensions.
+    It also adds dimension labels as coordinates to the dataset.The attributes
+    are defined in a YAML file and retrieved by the attribute manager.
+
+    Parameters
+    ----------
+    dataset : xarray.Dataset
+        The dataset to update.
+    logical_source : str
+        The logical source of the dataset.
+    attr_mgr : ImapCdfAttributes
+        The attribute manager to retrieve attributes.
+
+    Returns
+    -------
+    xarray.Dataset
+        The updated dataset with attributes and dimension labels.
+    """
+    dataset.attrs = attr_mgr.get_global_attributes(logical_source)
+
+    # Assign attributes and dimensions to each data array in the Dataset
+    for var in dataset.data_vars.keys():
+        try:
+            if "energy_delta" in var or var in {
+                "pkt_len",
+                "version",
+                "type",
+                "src_seq_ctr",
+                "seq_flgs",
+                "pkt_apid",
+                "sec_hdr_flg",
+            }:
+                # skip schema check to avoid DEPEND_0 being added unnecessarily
+                dataset[var].attrs = attr_mgr.get_variable_attributes(
+                    var, check_schema=False
+                )
+            else:
+                dataset[var].attrs = attr_mgr.get_variable_attributes(var)
+        except KeyError:
+            logger.warning(f"Field {var} not found in attribute manager.")
+
+    # check_schema=False to avoid attr_mgr adding stuff dimensions don't need
+    for dim in dataset.dims:
+        dataset[dim].attrs = attr_mgr.get_variable_attributes(dim, check_schema=False)
+        if dim != "epoch":
+            label_array = xr.DataArray(
+                dataset[dim].values.astype(str),
+                name=f"{dim}_label",
+                dims=[dim],
+                attrs=attr_mgr.get_variable_attributes(
+                    f"{dim}_label", check_schema=False
+                ),
+            )
+            dataset.coords[f"{dim}_label"] = label_array
+    return dataset
+
+
 def process_science(
     dataset: xr.Dataset, attr_mgr: ImapCdfAttributes
 ) -> list[xr.Dataset]:
@@ -294,30 +357,7 @@ def process_science(
 
     # Update attributes and dimensions
     for logical_source, ds in l1a_datasets.items():
-        ds.attrs = attr_mgr.get_global_attributes(logical_source)
-
-        # Assign attributes and dimensions to each data array in the Dataset
-        for field in ds.data_vars.keys():
-            try:
-                ds[field].attrs = attr_mgr.get_variable_attributes(field)
-            except KeyError:
-                print(f"Field {field} not found in attribute manager.")
-                logger.warning(f"Field {field} not found in attribute manager.")
-
-        # check_schema=False to avoid attr_mgr adding stuff dimensions don't need
-        for dim in ds.dims:
-            ds[dim].attrs = attr_mgr.get_variable_attributes(dim, check_schema=False)
-            # TODO: should labels be added as coordinates? Check with SPDF
-            if dim != "epoch":
-                label_array = xr.DataArray(
-                    ds[dim].values.astype(str),
-                    name=f"{dim}_label",
-                    dims=[dim],
-                    attrs=attr_mgr.get_variable_attributes(
-                        f"{dim}_label", check_schema=False
-                    ),
-                )
-                ds.coords[f"{dim}_label"] = label_array
+        l1a_datasets[logical_source] = add_cdf_attributes(ds, logical_source, attr_mgr)
 
         logger.info(f"HIT L1A dataset created for {logical_source}")
 

imap_processing/hit/l1b/constants.py

@@ -4,6 +4,11 @@
 # This is used to calculate the fractional livetime
 LIVESTIM_PULSES = 270
 
+# A factor used to find the count rate for sectored data that
+# accounts for the fact that a single spacecraft rotation is
+# split into 15 inclination ranges.
+SECTORS = 15
+
 # Fill values for missing data
 FILLVAL_FLOAT32 = -1.00e31
 FILLVAL_INT64 = -9223372036854775808

imap_processing/hit/l1b/hit_l1b.py

@@ -17,6 +17,7 @@ from imap_processing.hit.l1b.constants import (
     FILLVAL_FLOAT32,
     FILLVAL_INT64,
     LIVESTIM_PULSES,
+    SECTORS,
     SUMMED_PARTICLE_ENERGY_RANGE_MAPPING,
 )
 
@@ -106,16 +107,17 @@ def process_science_data(
     livetime = livetime.rename("livetime")
 
     # Process counts data to L1B datasets
-    l1b_datasets: dict = {}
-    l1b_datasets["imap_hit_l1b_standard-rates"] = process_standard_rates_data(
-        l1a_counts_dataset, livetime
-    )
-    l1b_datasets["imap_hit_l1b_summed-rates"] = process_summed_rates_data(
-        l1a_counts_dataset, livetime
-    )
-    l1b_datasets["imap_hit_l1b_sectored-rates"] = process_sectored_rates_data(
-        l1a_counts_dataset, livetime
-    )
+    l1b_datasets: dict = {
+        "imap_hit_l1b_standard-rates": process_standard_rates_data(
+            l1a_counts_dataset, livetime
+        ),
+        "imap_hit_l1b_summed-rates": process_summed_rates_data(
+            l1a_counts_dataset, livetime
+        ),
+        "imap_hit_l1b_sectored-rates": process_sectored_rates_data(
+            l1a_counts_dataset, livetime
+        ),
+    }
 
     # Update attributes and dimensions
     for logical_source, dataset in l1b_datasets.items():
@@ -444,7 +446,10 @@ def process_sectored_rates_data(
 
     Sectored counts data is transmitted 10 minutes after they are collected.
     To calculate rates, the sectored counts over 10 minutes need to be divided by
-    the sum of livetime values from the previous 10 minutes.
+    the sum of livetime values from the previous 10 minutes multiplied by a factor
+    15 to account for the different inclination sectors (a single spacecraft
+    rotation is split into 15 inclination ranges). See equation 11 in the algorithm
+    document.
 
     Parameters
     ----------
@@ -460,10 +465,7 @@ def process_sectored_rates_data(
     xr.Dataset
         The processed L1B sectored rates dataset.
     """
-    # TODO
-    #  -filter by epoch values in day being processed.
-    #   middle epoch (or mod 5 value for 6th frame)
-    #  -consider refactoring calculate_rates function to handle sectored rates
+    # TODO - consider refactoring calculate_rates function to handle sectored rates
 
     # Define particles and coordinates
     particles = ["h", "he4", "cno", "nemgsi", "fe"]
@@ -520,7 +522,7 @@ def process_sectored_rates_data(
             rates = xr.DataArray(
                 np.where(
                     counts != FILLVAL_INT64,
-                    (counts / livetime_10min_reshaped).astype(np.float32),
+                    (counts / (SECTORS * livetime_10min_reshaped)).astype(np.float32),
                     FILLVAL_FLOAT32,
                 ),
                 dims=l1a_counts_dataset[var].dims,

imap_processing/hit/l2/constants.py

@@ -169,7 +169,7 @@ STANDARD_PARTICLE_ENERGY_RANGE_MAPPING = {
         {"energy_min": 5.0, "energy_max": 6.0, "R2": [59], "R3": [], "R4": []},
         {"energy_min": 6.0, "energy_max": 8.0, "R2": [60], "R3": [63], "R4": []},
         {"energy_min": 8.0, "energy_max": 10.0, "R2": [61], "R3": [64], "R4": []},
-        {"energy_min": 10.0, "energy_max": 12.0, "R2": [], "R3": [65], "R4": []},
+        {"energy_min": 10.0, "energy_max": 12.0, "R2": [62], "R3": [65], "R4": []},
         {"energy_min": 12.0, "energy_max": 15.0, "R2": [], "R3": [66], "R4": []},
         {"energy_min": 15.0, "energy_max": 21.0, "R2": [], "R3": [67], "R4": []},
         {"energy_min": 21.0, "energy_max": 27.0, "R2": [], "R3": [68], "R4": []},

imap_processing/hit/l2/hit_l2.py

@@ -95,11 +95,11 @@ def add_cdf_attributes(
 
     Parameters
     ----------
-    dataset : xr.Dataset
+    dataset : xarray.Dataset
         The dataset to update.
     logical_source : str
         The logical source of the dataset.
-    attr_mgr : AttributeManager
+    attr_mgr : ImapCdfAttributes
         The attribute manager to retrieve attributes.
 
     Returns
@@ -132,12 +132,11 @@ def add_cdf_attributes(
     # check_schema=False to avoid attr_mgr adding stuff dimensions don't need
     for dim in dataset.dims:
         dataset[dim].attrs = attr_mgr.get_variable_attributes(dim, check_schema=False)
-        # TODO: should labels be added as coordinates? Check with SPDF
         if dim != "epoch":
             label_array = xr.DataArray(
                 dataset[dim].values.astype(str),
                 name=f"{dim}_label",
-                dims=[f"{dim}_label"],
+                dims=[dim],
                 attrs=attr_mgr.get_variable_attributes(
                     f"{dim}_label", check_schema=False
                 ),
@@ -633,7 +632,7 @@ def process_summed_intensity(
             summed_intensity_dataset = add_total_uncertainties(
                 summed_intensity_dataset, var
             )
-            # Expand the variable name to include standard intensity
+            # Expand the variable name to include summed intensity
             summed_intensity_dataset = summed_intensity_dataset.rename(
                 {var: f"{var}_summed_intensity"}
             )

imap_processing/ialirt/constants.py

@@ -1,6 +1,7 @@
 """Module for constants and useful shared classes used in I-ALiRT processing."""
 
 from dataclasses import dataclass
+from typing import NamedTuple
 
 import numpy as np
 
@@ -36,3 +37,23 @@ class IalirtSwapiConstants:
     az_fov = np.deg2rad(30)  # azimuthal width of the field of view, radians
     fwhm_width = 0.085  # FWHM of energy width
     speed_ew = 0.5 * fwhm_width  # speed width of energy passband
+
+
+class StationProperties(NamedTuple):
+    """Class that represents properties of ground stations."""
+
+    longitude: float  # longitude in degrees
+    latitude: float  # latitude in degrees
+    altitude: float  # altitude in kilometers
+    min_elevation_deg: float  # minimum elevation angle in degrees
+
+
+# Verified by Kiel Observatory staff.
+STATIONS = {
+    "Kiel": StationProperties(
+        longitude=10.1808,  # degrees East
+        latitude=54.2632,  # degrees North
+        altitude=0.1,  # approx 100 meters
+        min_elevation_deg=5,  # 5 degrees is the requirement
+    )
+}

imap_processing/ialirt/generate_coverage.py

@@ -0,0 +1,188 @@
+"""Coverage time for each station."""
+
+import logging
+
+import numpy as np
+
+from imap_processing.ialirt.constants import STATIONS
+from imap_processing.ialirt.process_ephemeris import calculate_azimuth_and_elevation
+from imap_processing.spice.time import et_to_utc, str_to_et
+
+# Logger setup
+logger = logging.getLogger(__name__)
+
+# TODO: get a list of all potential DSN stations.
+ALL_STATIONS = [*STATIONS.keys(), "DSS-55", "DSS-56", "DSS-74", "DSS-75"]
+
+
+def generate_coverage(
+    start_time: str,
+    outages: dict | None = None,
+    dsn: dict | None = None,
+) -> tuple[dict, dict]:
+    """
+    Build the output dictionary containing coverage and outage time for each station.
+
+    Parameters
+    ----------
+    start_time : str
+        Start time in UTC.
+    outages : dict, optional
+        Dictionary of outages for each station.
+    dsn : dict, optional
+        Dictionary of Deep Space Network (DSN) stations.
+
+    Returns
+    -------
+    coverage_dict : dict
+        Visibility times per station.
+    outage_dict : dict
+        Outage times per station.
+    """
+    duration_seconds = 24 * 60 * 60  # 86400 seconds in 24 hours
+    time_step = 3600  # 1 hr in seconds
+
+    stations = {
+        "Kiel": STATIONS["Kiel"],
+    }
+    coverage_dict = {}
+    outage_dict = {}
+
+    start_et_input = str_to_et(start_time)
+    stop_et_input = start_et_input + duration_seconds
+
+    time_range = np.arange(start_et_input, stop_et_input, time_step)
+    total_visible_mask = np.zeros(time_range.shape, dtype=bool)
+
+    # Precompute DSN outage mask for non-DSN stations
+    dsn_outage_mask = np.zeros(time_range.shape, dtype=bool)
+    if dsn:
+        for dsn_contacts in dsn.values():
+            for start, end in dsn_contacts:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                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)
+        visible = elevation > min_elevation
+
+        outage_mask = np.zeros(time_range.shape, dtype=bool)
+        if outages and station_name in outages:
+            for start, end in outages[station_name]:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                outage_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+        visible[outage_mask] = False
+        # DSN contacts block other stations
+        visible[dsn_outage_mask] = False
+        total_visible_mask |= visible
+
+        coverage_dict[station_name] = et_to_utc(time_range[visible], format_str="ISOC")
+        outage_dict[station_name] = et_to_utc(
+            time_range[outage_mask], format_str="ISOC"
+        )
+
+    # --- DSN Stations ---
+    if dsn:
+        for dsn_station, contacts in dsn.items():
+            dsn_visible_mask = np.zeros(time_range.shape, dtype=bool)
+            for start, end in contacts:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                dsn_visible_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+            # Apply DSN outages if present
+            outage_mask = np.zeros(time_range.shape, dtype=bool)
+            if outages and dsn_station in outages:
+                for start, end in outages[dsn_station]:
+                    start_et = str_to_et(start)
+                    end_et = str_to_et(end)
+                    outage_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+            dsn_visible_mask[outage_mask] = False
+            total_visible_mask |= dsn_visible_mask
+
+            coverage_dict[f"{dsn_station}"] = et_to_utc(
+                time_range[dsn_visible_mask], format_str="ISOC"
+            )
+            outage_dict[f"{dsn_station}"] = et_to_utc(
+                time_range[outage_mask], format_str="ISOC"
+            )
+
+    # Total coverage percentage
+    total_coverage_percent = (
+        np.count_nonzero(total_visible_mask) / time_range.size
+    ) * 100
+    coverage_dict["total_coverage_percent"] = total_coverage_percent
+
+    # Ensure all stations are present in both dicts
+    for station in ALL_STATIONS:
+        coverage_dict.setdefault(station, np.array([], dtype="<U23"))
+        outage_dict.setdefault(station, np.array([], dtype="<U23"))
+
+    return coverage_dict, outage_dict
+
+
+def format_coverage_summary(
+    coverage_dict: dict, outage_dict: dict, start_time: str
+) -> dict:
+    """
+    Build the output dictionary containing coverage time for each station.
+
+    Parameters
+    ----------
+    coverage_dict : dict
+        Coverage for each station, keyed by station name with arrays of UTC times.
+    outage_dict : dict
+        Outage times for each station, keyed by station name with arrays of UTC times.
+    start_time : str
+        Start time in UTC.
+
+    Returns
+    -------
+    output_dict : dict
+        Formatted coverage summary.
+    """
+    # Include all known stations,
+    # plus any new ones that appear in coverage_dict.
+    all_stations = ALL_STATIONS + [
+        station
+        for station in coverage_dict.keys()
+        if station not in ALL_STATIONS and station != "total_coverage_percent"
+    ]
+
+    duration_seconds = 24 * 60 * 60  # 86400 seconds in 24 hours
+    time_step = 3600  # 1 hr in seconds
+
+    start_et_input = str_to_et(start_time)
+    stop_et_input = start_et_input + duration_seconds
+
+    time_range = np.arange(start_et_input, stop_et_input, time_step)
+    all_times = et_to_utc(time_range, format_str="ISOC")
+
+    data_rows = []
+    for time in all_times:
+        row = {"time": time}
+        for station in all_stations:
+            visible_times = coverage_dict.get(station, [])
+            outage_times = outage_dict.get(station, [])
+            if time in outage_times:
+                row[station] = "X"
+            elif time in visible_times:
+                row[station] = "1"
+            else:
+                row[station] = "0"
+        data_rows.append(row)
+
+    output_dict = {
+        "summary": "I-ALiRT Coverage Summary",
+        "generated": start_time,
+        "time_format": "UTC (ISOC)",
+        "stations": all_stations,
+        "total_coverage_percent": round(coverage_dict["total_coverage_percent"], 1),
+        "data": data_rows,
+    }
+
+    return output_dict

imap_processing/ialirt/l0/parse_mag.py

@@ -20,6 +20,8 @@ from imap_processing.mag.l1b.mag_l1b import (
     calibrate_vector,
     shift_time,
 )
+from imap_processing.mag.l1d.mag_l1d_data import MagL1d
+from imap_processing.mag.l2.mag_l2_data import MagL2L1dBase
 from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc
 
 logger = logging.getLogger(__name__)
@@ -286,6 +288,56 @@ def calculate_l1b(
     return updated_vector_mago, updated_vector_magi, time_data
 
 
+def calibrate_and_offset_vectors(
+    vectors: np.ndarray,
+    range_vals: np.ndarray,
+    calibration: np.ndarray,
+    offsets: np.ndarray,
+    is_magi: bool = False,
+) -> np.ndarray:
+    """
+    Apply calibration and offsets to magnetic vectors.
+
+    Parameters
+    ----------
+    vectors : np.ndarray
+        Raw magnetic vectors, shape (n, 3).
+    range_vals : np.ndarray
+        Range indices for each vector, shape (n). Values 0–3.
+    calibration : np.ndarray
+        Calibration matrix, shape (3, 3, 4).
+    offsets : np.ndarray
+        Offsets array, shape (2, 4, 3) where:
+        - index 0 = MAGo, 1 = MAGi
+        - second index = range (0–3)
+        - third index = axis (x, y, z)
+    is_magi : bool, optional
+        True if applying to MAGi data, False for MAGo.
+
+    Returns
+    -------
+    calibrated_and_offset_vectors : np.ndarray
+        Calibrated and offset vectors, shape (n, 3).
+    """
+    # Append range as 4th column
+    vec_plus_range = np.concatenate((vectors, range_vals[:, np.newaxis]), axis=1)
+
+    # Apply calibration matrix -> (n,4)
+    calibrated = MagL2L1dBase.apply_calibration(vec_plus_range, calibration)
+
+    # Apply offsets per vector
+    # vec shape (4)
+    # offsets shape (2, 4, 3) where first index is 0 for MAGo and 1 for MAGi
+    calibrated = np.array(
+        [
+            MagL1d.apply_calibration_offset_single_vector(vec, offsets, is_magi=is_magi)
+            for vec in calibrated
+        ]
+    )
+
+    return calibrated[:, :3]
+
+
 def process_packet(
     accumulated_data: xr.Dataset, calibration_dataset: xr.Dataset
 ) -> tuple[list[dict], list[dict]]:
@@ -392,11 +444,16 @@ def process_packet(
                 "met": int(met.values.min()),
                 "met_in_utc": met_to_utc(met.values.min()).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met.values.min())),
-                "mag_4s_b_gse": [Decimal("0.0") for _ in range(3)],
-                "mag_4s_b_gsm": [Decimal("0.0") for _ in range(3)],
-                "mag_4s_b_rtn": [Decimal("0.0") for _ in range(3)],
-                "mag_phi_4s_b_gsm": Decimal("0.0"),
-                "mag_theta_4s_b_gsm": Decimal("0.0"),
+                # TODO: Placeholder for mag_epoch
+                "mag_epoch": int(met.values.min()),
+                "mag_B_GSE": [Decimal("0.0") for _ in range(3)],
+                "mag_B_GSM": [Decimal("0.0") for _ in range(3)],
+                "mag_B_RTN": [Decimal("0.0") for _ in range(3)],
+                "mag_B_magnitude": Decimal("0.0"),
+                "mag_phi_B_GSM": Decimal("0.0"),
+                "mag_theta_B_GSM": Decimal("0.0"),
+                "mag_phi_B_GSE": Decimal("0.0"),
+                "mag_theta_B_GSE": Decimal("0.0"),
             }
         )
 

imap_processing/ialirt/l0/process_swapi.py

@@ -96,7 +96,7 @@ def optimize_pseudo_parameters(
         # Read in energy passbands
         energy_data = pd.read_csv(
             f"{imap_module_directory}/tests/swapi/lut/imap_swapi_esa-unit"
-            f"-conversion_20250211_v000.csv"
+            f"-conversion_20250626_v001.csv"
         )
         energy_passbands = (
             energy_data["Energy"][0:63]

imap_processing/ialirt/l0/process_swe.py

@@ -542,16 +542,32 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
         summed_first = normalized_first_half.sum(axis=(1, 2))
         summed_second = normalized_second_half.sum(axis=(1, 2))
 
+        met_first_half = int(
+            grouped["met"].where(grouped["swe_seq"] == 0, drop=True).values[0]
+        )
+        met_second_half = int(
+            grouped["met"].where(grouped["swe_seq"] == 30, drop=True).values[0]
+        )
+
+        swe_data.append(
+            {
+                "apid": 478,
+                "met": met_first_half,
+                "met_in_utc": met_to_utc(met_first_half).split(".")[0],
+                "ttj2000ns": int(met_to_ttj2000ns(met_first_half)),
+                "swe_normalized_counts": [int(val) for val in summed_first],
+                "swe_counterstreaming_electrons": bde_first_half,
+            },
+        )
         swe_data.append(
             {
                 "apid": 478,
-                "met": int(grouped["met"].min()),
-                "met_in_utc": met_to_utc(grouped["met"].min()).split(".")[0],
-                "ttj2000ns": int(met_to_ttj2000ns(grouped["met"].min())),
-                "swe_normalized_counts_half_1_esa": [int(val) for val in summed_first],
-                "swe_normalized_counts_half_2_esa": [int(val) for val in summed_second],
-                "swe_counterstreaming_electrons": max(bde_first_half, bde_second_half),
-            }
+                "met": met_second_half,
+                "met_in_utc": met_to_utc(met_second_half).split(".")[0],
+                "ttj2000ns": int(met_to_ttj2000ns(met_second_half)),
+                "swe_normalized_counts": [int(val) for val in summed_second],
+                "swe_counterstreaming_electrons": bde_second_half,
+            },
         )
 
     return swe_data

imap_processing/ialirt/utils/constants.py

@@ -2,19 +2,19 @@
 
 IALIRT_KEYS = [
     # H intensities in 15 energy ranges and binned into 4 azimuths and 4 spin angle bins
-    "codicehi_h",
+    "codice_hi_h",
     # C/O abundance ratio
-    "codicelo_c_over_o_abundance",
+    "codice_lo_c_over_o_abundance",
     # Mg/O abundance ratio
-    "codicelo_mg_over_o_abundance",
+    "codice_lo_mg_over_o_abundance",
     # Fe/O abundance ratio
-    "codicelo_fe_over_o_abundance",
+    "codice_lo_fe_over_o_abundance",
     # C+6/C+5 charge state ratio
-    "codicelo_c_plus_6_over_c_plus_5_ratio",
+    "codice_lo_c_plus_6_over_c_plus_5_ratio",
     # O+7/O+6 charge state ratio
-    "codicelo_o_plus_7_over_o_plus_6_ratio",
+    "codice_lo_o_plus_7_over_o_plus_6_ratio",
     # Fe low/Fe high charge state ratio
-    "codicelo_fe_low_over_fe_high_ratio",
+    "codice_lo_fe_low_over_fe_high_ratio",
     # Low energy (~300 keV) electrons (A-side)
     "hit_e_a_side_low_en",
     # Medium energy (~3 MeV) electrons (A-side)
@@ -37,26 +37,32 @@ IALIRT_KEYS = [
     "hit_he_omni_low_en",
     # High energy (15 to 70 MeV/nuc) He (Omnidirectional)
     "hit_he_omni_high_en",
+    # MAG instrument epoch
+    "mag_epoch",
     # Magnetic field vector in GSE coordinates
-    "mag_4s_b_gse",
+    "mag_B_GSE",
     # Magnetic field vector in GSM coordinates
-    "mag_4s_b_gsm",
+    "mag_B_GSM",
     # Magnetic field vector in RTN coordinates
-    "mag_4s_b_rtn",
+    "mag_B_RTN",
+    # Magnitude of the magnetic field vector
+    "mag_B_magnitude",
     # Azimuth angle (φ) of the magnetic field in GSM coordinates
-    "mag_phi_4s_b_gsm",
+    "mag_phi_B_GSM",
     # Elevation angle (θ) of the magnetic field in GSM coordinates
-    "mag_theta_4s_b_gsm",
+    "mag_theta_B_GSM",
+    # Azimuth angle (φ) of the magnetic field in GSE coordinates
+    "mag_phi_B_GSE",
+    # Elevation angle (θ) of the magnetic field in GSE coordinates
+    "mag_theta_B_GSE",
     # Pseudo density of solar wind protons
     "swapi_pseudo_proton_density",
     # Pseudo speed of solar wind protons in solar inertial frame
     "swapi_pseudo_proton_speed",
     # Pseudo temperature of solar wind protons in plasma frame
     "swapi_pseudo_proton_temperature",
-    # SWE Normalized Counts - Half Cycle 1
-    "swe_normalized_counts_half_1",
-    # SWE Normalized Counts - Half Cycle 2
-    "swe_normalized_counts_half_2",
+    # SWE Normalized Counts
+    "swe_normalized_counts",
     # SWE Counterstreaming flag
     "swe_counterstreaming_electrons",
 ]