imap-processing 0.15.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

imap_processing/hit/l1b/hit_l1b.py

@@ -366,7 +366,8 @@ def subset_data_for_sectored_counts(
     A set of sectored data starts with hydrogen and ends with iron and correspond to
     the mod 10 values 0-9. The livetime values from the previous 10 minutes are used
     to calculate the rates for each set since those counts are transmitted 10 minutes
-    after they were collected.
+    after they were collected. Therefore, only complete sets of sectored counts where
+    livetime from the previous 10 minutes are available are included in the output.
 
     Parameters
     ----------
@@ -378,7 +379,7 @@ def subset_data_for_sectored_counts(
     Returns
     -------
     tuple[xr.Dataset, xr.DataArray]
-        Subsetted L1A counts dataset and corresponding livetime values.
+        Dataset of complete sectored counts and corresponding livetime values.
     """
     # Identify 10-minute intervals of complete sectored counts.
     bin_size = 10
@@ -392,16 +393,34 @@ def subset_data_for_sectored_counts(
     start_indices = np.where(matches)[0]
 
     # Filter out start indices that are less than or equal to the bin size
-    # since the previous 10 minutes are needed
-    start_indices = start_indices[start_indices > bin_size]
-    data_slice = slice(start_indices[0], start_indices[-1] + bin_size)
-
-    # Subset data to include only complete sets of sectored counts
-    l1b_sectored_rates_dataset = l1a_counts_dataset.isel(epoch=data_slice)
+    # since the previous 10 minutes are needed for calculating rates
+    if start_indices.size == 0:
+        logger.error(
+            "No data to process - valid start indices not found for "
+            "complete sectored counts."
+        )
+        raise ValueError("No valid start indices found for complete sectored counts.")
+    else:
+        start_indices = start_indices[start_indices >= bin_size]
+
+    # Subset data for complete sets of sectored counts.
+    # Each set of sectored counts is 10 minutes long, so we take the indices
+    # starting from the start indices and extend to the bin size of 10.
+    # This creates a 1D array of indices that correspond to the complete
+    # sets of sectored counts which is used to filter the L1A dataset and
+    # create the L1B sectored rates dataset.
+    data_indices = np.concatenate(
+        [np.arange(idx, idx + bin_size) for idx in start_indices]
+    )
+    l1b_sectored_rates_dataset = l1a_counts_dataset.isel(epoch=data_indices)
 
-    # Subset livetime staggered from sectored counts by 10 minutes
-    livetime_slice = slice(start_indices[0] - bin_size, start_indices[-1])
-    livetime = livetime[livetime_slice]
+    # Subset livetime values corresponding to the previous 10 minutes
+    # for each start index. This ensures the livetime data aligns correctly
+    # with the sectored counts for rate calculations.
+    livetime_indices = np.concatenate(
+        [np.arange(idx - bin_size, idx) for idx in start_indices]
+    )
+    livetime = livetime.isel(epoch=livetime_indices)
 
     return l1b_sectored_rates_dataset, livetime
 

imap_processing/ialirt/constants.py

@@ -0,0 +1,38 @@
+"""Module for constants and useful shared classes used in I-ALiRT processing."""
+
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class IalirtSwapiConstants:
+    """
+    Constants for I-ALiRT SWAPI which can be used across different levels or classes.
+
+    Attributes
+    ----------
+    BOLTZ: float
+        Boltzmann constant [J/K]
+    AT_MASS: float
+        Atomic mass [kg]
+    PROT_MASS: float
+        Mass of proton [kg]
+    EFF_AREA: float
+        Instrument effective area [m^2]
+    AZ_FOV: float
+        Azimuthal width of the field of view for solar wind [radians]
+    FWHM_WIDTH: float
+        Full Width at Half Maximum of energy width [unitless]
+    SPEED_EW: float
+        Speed width of energy passband [unitless]
+    """
+
+    # Scientific constants used in optimization model
+    boltz = 1.380649e-23  # Boltzmann constant, J/K
+    at_mass = 1.6605390666e-27  # atomic mass, kg
+    prot_mass = 1.007276466621 * at_mass  # mass of proton, kg
+    eff_area = 3.3e-5 * 1e-4  # effective area, meters squared
+    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

imap_processing/ialirt/l0/parse_mag.py

@@ -390,7 +390,7 @@ def process_packet(
             {
                 "apid": 478,
                 "met": int(met.values.min()),
-                "utc": met_to_utc(met.values.min()).split(".")[0],
+                "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)],

imap_processing/ialirt/l0/process_codice.py

@@ -0,0 +1,91 @@
+"""Functions to support I-ALiRT CoDICE processing."""
+
+import logging
+from decimal import Decimal
+from typing import Any
+
+import xarray as xr
+
+from imap_processing.codice import constants
+from imap_processing.ialirt.utils.time import calculate_time
+from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc
+
+logger = logging.getLogger(__name__)
+
+FILLVAL_FLOAT32 = Decimal(str(-1.0e31))
+
+
+def process_codice(
+    dataset: xr.Dataset,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """
+    Create final data products.
+
+    Parameters
+    ----------
+    dataset : xr.Dataset
+        Decommed L0 data.
+
+    Returns
+    -------
+    codice_data : list[dict]
+        Dictionary of final data product.
+
+    Notes
+    -----
+    This function is incomplete and will need to be updated to include the
+    necessary calculations and data products.
+    - Calculate rates (assume 4 minutes per group)
+    - Calculate L2 CoDICE pseudodensities (pg 37 of Algorithm Document)
+    - Calculate the public data products
+    """
+    # For I-ALiRT SIT, the test data being used has all zeros and thus no
+    # groups can be found, thus there is no data to process
+    # TODO: Once I-ALiRT test data is acquired that actually has data in it,
+    #       this can be turned back on
+    # codicelo_data = create_ialirt_dataset(CODICEAPID.COD_LO_IAL, dataset)
+    # codicehi_data = create_ialirt_dataset(CODICEAPID.COD_HI_IAL, dataset)
+
+    # TODO: calculate rates
+    #       This will be done in codice.codice_l1b
+
+    # TODO: calculate L2 CoDICE pseudodensities
+    #       This will be done in codice.codice_l2
+
+    # TODO: calculate the public data products
+    #       This will be done in this module
+
+    # Create mock dataset for I-ALiRT SIT
+    # TODO: Once I-ALiRT test data is acquired that actually has data in it,
+    #       we should be able to properly populate the I-ALiRT data, but for
+    #       now, just create lists of dicts with FILLVALs
+    cod_lo_data = []
+    cod_hi_data = []
+
+    for epoch in range(len(dataset.epoch.data)):
+        sc_sclk_sec = dataset.sc_sclk_sec.data[epoch]
+        sc_sclk_sub_sec = dataset.sc_sclk_sub_sec.data[epoch]
+        met = calculate_time(sc_sclk_sec, sc_sclk_sub_sec, 256)
+        utc = met_to_utc(met).split(".")[0]
+        ttj2000ns = int(met_to_ttj2000ns(met))
+
+        epoch_data = {
+            "apid": int(dataset.pkt_apid[epoch].data),
+            "met": met,
+            "met_to_utc": utc,
+            "ttj2000ns": ttj2000ns,
+        }
+
+        # Add in CoDICE-Lo specific data
+        cod_lo_epoch_data = epoch_data.copy()
+        for field in constants.CODICE_LO_IAL_DATA_FIELDS:
+            cod_lo_epoch_data[f"codicelo_{field}"] = FILLVAL_FLOAT32
+        cod_lo_data.append(cod_lo_epoch_data)
+
+        # Add in CoDICE-Hi specific data
+        cod_hi_epoch_data = epoch_data.copy()
+        for field in constants.CODICE_HI_IAL_DATA_FIELDS:
+            cod_hi_epoch_data[f"codicehi_{field}"] = FILLVAL_FLOAT32
+        cod_hi_data.append(cod_hi_epoch_data)
+
+    return cod_lo_data, cod_hi_data

imap_processing/ialirt/l0/process_hit.py

@@ -1,7 +1,6 @@
 """Functions to support HIT processing."""
 
 import logging
-from decimal import Decimal
 
 import numpy as np
 import xarray as xr
@@ -170,27 +169,19 @@ def process_hit(xarray_data: xr.Dataset) -> list[dict]:
             {
                 "apid": 478,
                 "met": int(met),
-                "utc": met_to_utc(met).split(".")[0],
+                "met_in_utc": met_to_utc(met).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met)),
-                "hit_e_a_side_low_en": Decimal(
-                    str(l1["IALRT_RATE_1"] + l1["IALRT_RATE_2"])
-                ),
-                "hit_e_a_side_med_en": Decimal(
-                    str(l1["IALRT_RATE_5"] + l1["IALRT_RATE_6"])
-                ),
-                "hit_e_a_side_high_en": Decimal(str(l1["IALRT_RATE_7"])),
-                "hit_e_b_side_low_en": Decimal(
-                    str(l1["IALRT_RATE_11"] + l1["IALRT_RATE_12"])
-                ),
-                "hit_e_b_side_med_en": Decimal(
-                    str(l1["IALRT_RATE_15"] + l1["IALRT_RATE_16"])
-                ),
-                "hit_e_b_side_high_en": Decimal(str(l1["IALRT_RATE_17"])),
-                "hit_h_omni_med_en": Decimal(str(l1["H_12_15"] + l1["H_15_70"])),
-                "hit_h_a_side_high_en": Decimal(str(l1["IALRT_RATE_8"])),
-                "hit_h_b_side_high_en": Decimal(str(l1["IALRT_RATE_18"])),
-                "hit_he_omni_low_en": Decimal(str(l1["HE4_06_08"])),
-                "hit_he_omni_high_en": Decimal(str(l1["HE4_15_70"])),
+                "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"]),
+                "hit_e_b_side_low_en": int(l1["IALRT_RATE_11"] + l1["IALRT_RATE_12"]),
+                "hit_e_b_side_med_en": int(l1["IALRT_RATE_15"] + l1["IALRT_RATE_16"]),
+                "hit_e_b_side_high_en": int(l1["IALRT_RATE_17"]),
+                "hit_h_omni_med_en": int(l1["H_12_15"] + l1["H_15_70"]),
+                "hit_h_a_side_high_en": int(l1["IALRT_RATE_8"]),
+                "hit_h_b_side_high_en": int(l1["IALRT_RATE_18"]),
+                "hit_he_omni_low_en": int(l1["HE4_06_08"]),
+                "hit_he_omni_high_en": int(l1["HE4_15_70"]),
             }
         )
 

imap_processing/ialirt/l0/process_swapi.py

@@ -1,20 +1,144 @@
 """Functions to support I-ALiRT SWAPI processing."""
 
 import logging
+from decimal import Decimal
+from typing import Optional
 
 import numpy as np
+import pandas as pd
 import xarray as xr
-from xarray import DataArray
+from scipy.optimize import curve_fit
+from scipy.special import erf
 
+from imap_processing import imap_module_directory
+from imap_processing.ialirt.constants import IalirtSwapiConstants as Consts
 from imap_processing.ialirt.utils.grouping import find_groups
-
-# from imap_processing.swapi.l1.swapi_l1 import process_sweep_data
-# from imap_processing.swapi.l2.swapi_l2 import TIME_PER_BIN
+from imap_processing.ialirt.utils.time import calculate_time
+from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc
+from imap_processing.swapi.l1.swapi_l1 import process_sweep_data
+from imap_processing.swapi.l2.swapi_l2 import TIME_PER_BIN
 
 logger = logging.getLogger(__name__)
 
 
-def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
+def count_rate(
+    energy_pass: float, speed: float, density: float, temp: float
+) -> float | np.ndarray:
+    """
+    Compute SWAPI count rate for provided energy passband, speed, density and temp.
+
+    This model for coincidence count rate was developed by the SWAPI instrument
+    science team, detailed on page 52 of the IMAP SWAPI Instrument Algorithms Document.
+
+    Parameters
+    ----------
+    energy_pass : float
+        Energy passband [eV].
+    speed : float
+        Bulk solar wind speed [km/s].
+    density : float
+        Proton density [cm^-3].
+    temp : float
+        Temperature [K].
+
+    Returns
+    -------
+    count_rate : float | np.ndarray
+        Particle coincidence count rate.
+    """
+    # thermal velocity of solar wind ions
+    thermal_velocity = np.sqrt(2 * Consts.boltz * temp / Consts.prot_mass)
+    beta = 1 / (thermal_velocity**2)
+    # convert energy to Joules
+    center_speed = np.sqrt(2 * energy_pass * 1.60218e-19 / Consts.prot_mass)
+    speed = speed * 1000  # convert km/s to m/s
+    density = density * 1e6  # convert 1/cm**3 to 1/m**3
+
+    return (
+        (density * Consts.eff_area * (beta / np.pi) ** (3 / 2))
+        * (np.exp(-beta * (center_speed**2 + speed**2 - 2 * center_speed * speed)))
+        * np.sqrt(np.pi / (beta * speed * center_speed))
+        * erf(np.sqrt(beta * speed * center_speed) * (Consts.az_fov / 2))
+        * (
+            center_speed**4
+            * Consts.speed_ew
+            * np.arcsin(thermal_velocity / center_speed)
+        )
+    )
+
+
+def optimize_pseudo_parameters(
+    count_rates: np.ndarray,
+    count_rate_error: np.ndarray,
+    energy_passbands: Optional[np.ndarray] = None,
+) -> (dict)[str, list[float]]:
+    """
+    Find the pseudo speed (u), density (n) and temperature (T) of solar wind particles.
+
+    Fit a curve to calculated count rate values as a function of energy passband.
+
+    Parameters
+    ----------
+    count_rates : np.ndarray
+        Particle coincidence count rates.
+    count_rate_error : np.ndarray
+        Standard deviation of the coincidence count rates parameter.
+    energy_passbands : np.ndarray, default None
+        Energy passbands, passed in only for testing purposes.
+
+    Returns
+    -------
+    solution_dict : dict
+        Dictionary containing the optimized speed, density, and temperature values for
+        each sweep included in the input count_rates array.
+    """
+    if not energy_passbands:
+        # 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"
+        )
+        energy_passbands = (
+            energy_data["Energy"][0:63]
+            .replace(",", "", regex=True)
+            .to_numpy()
+            .astype(float)
+        )
+
+    # Initial guess pulled from page 52 of the IMAP SWAPI Instrument Algorithms Document
+    initial_param_guess = np.array([550, 5.27, 1e5])
+    solution_dict = {  # type: ignore
+        "pseudo_speed": [],
+        "pseudo_density": [],
+        "pseudo_temperature": [],
+    }
+
+    for sweep in np.arange(count_rates.shape[0]):
+        current_sweep_count_rates = count_rates[sweep, :]
+        current_sweep_count_rate_errors = count_rate_error[sweep, :]
+        # Find the max count rate, and use the 6 points surrounding it (inclusive)
+        max_index = np.argmax(current_sweep_count_rates)
+        sol = curve_fit(
+            f=count_rate,
+            xdata=energy_passbands.take(
+                range(max_index - 3, max_index + 3), mode="wrap"
+            ),
+            ydata=current_sweep_count_rates.take(
+                range(max_index - 3, max_index + 3), mode="wrap"
+            ),
+            sigma=current_sweep_count_rate_errors.take(
+                range(max_index - 3, max_index + 3), mode="wrap"
+            ),
+            p0=initial_param_guess,
+        )
+        solution_dict["pseudo_speed"].append(sol[0][0])
+        solution_dict["pseudo_density"].append(sol[0][1])
+        solution_dict["pseudo_temperature"].append(sol[0][2])
+
+    return solution_dict
+
+
+def process_swapi_ialirt(unpacked_data: xr.Dataset) -> list[dict]:
     """
     Extract I-ALiRT variables and calculate coincidence count rate.
 
@@ -32,7 +156,21 @@ def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
 
     sci_dataset = unpacked_data.sortby("epoch", ascending=True)
 
-    grouped_dataset = find_groups(sci_dataset, (0, 11), "swapi_seq_number", "swapi_acq")
+    met = calculate_time(
+        sci_dataset["sc_sclk_sec"], sci_dataset["sc_sclk_sub_sec"], 256
+    )
+
+    # Add required parameters.
+    sci_dataset["met"] = met
+    met_values = []
+
+    grouped_dataset = find_groups(sci_dataset, (0, 11), "swapi_seq_number", "met")
+
+    if grouped_dataset.group.size == 0:
+        logger.warning(
+            "There was an issue with the SWAPI grouping process, returning empty data."
+        )
+        return [{}]
 
     for group in np.unique(grouped_dataset["group"]):
         # Sequence values for the group should be 0-11 with no duplicates.
@@ -40,6 +178,10 @@ def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
             (grouped_dataset["group"] == group)
         ]
 
+        met_values.append(
+            int(grouped_dataset["met"][(grouped_dataset["group"] == group).values][0])
+        )
+
         # Ensure no duplicates and all values from 0 to 11 are present
         if not np.array_equal(seq_values.astype(int), np.arange(12)):
             logger.info(
@@ -48,22 +190,29 @@ def process_swapi_ialirt(unpacked_data: xr.Dataset) -> dict[str, DataArray]:
             )
             continue
 
-    total_packets = len(grouped_dataset["swapi_seq_number"].data)
-
-    # It takes 12 sequence data to make one full SWAPI sweep
-    total_sequence = 12
-    total_full_sweeps = total_packets // total_sequence
-
-    met_values = grouped_dataset["swapi_shcoarse"].data.reshape(total_full_sweeps, 12)[
-        :, 0
-    ]
-
-    # raw_coin_count = process_sweep_data(grouped_dataset, "coin_cnt")
-    # raw_coin_rate = raw_coin_count / TIME_PER_BIN
-
-    swapi_data = {
-        "met": met_values
-        # more variables to go here
-    }
+    raw_coin_count = process_sweep_data(grouped_dataset, "swapi_coin_cnt")
+    raw_coin_rate = raw_coin_count / TIME_PER_BIN
+    count_rate_error = np.sqrt(raw_coin_count) / TIME_PER_BIN
+
+    solution = optimize_pseudo_parameters(raw_coin_rate, count_rate_error)
+
+    swapi_data = []
+
+    for entry in np.arange(0, len(solution["pseudo_speed"])):
+        swapi_data.append(
+            {
+                "apid": 478,
+                "met": met_values[entry],
+                "met_in_utc": met_to_utc(met_values[entry]).split(".")[0],
+                "ttj2000ns": int(met_to_ttj2000ns(met_values[entry])),
+                "swapi_pseudo_proton_speed": Decimal(solution["pseudo_speed"][entry]),
+                "swapi_pseudo_proton_density": Decimal(
+                    solution["pseudo_density"][entry]
+                ),
+                "swapi_pseudo_proton_temperature": Decimal(
+                    solution["pseudo_temperature"][entry]
+                ),
+            }
+        )
 
     return swapi_data

imap_processing/ialirt/l0/process_swe.py

@@ -1,7 +1,6 @@
 """Functions to support I-ALiRT SWE processing."""
 
 import logging
-from decimal import Decimal
 
 import numpy as np
 import pandas as pd
@@ -547,16 +546,10 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
             {
                 "apid": 478,
                 "met": int(grouped["met"].min()),
-                "utc": met_to_utc(grouped["met"].min()).split(".")[0],
+                "met_in_utc": met_to_utc(grouped["met"].min()).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(grouped["met"].min())),
-                **{
-                    f"swe_normalized_counts_half_1_esa_{i}": Decimal(str(val))
-                    for i, val in enumerate(summed_first)
-                },
-                **{
-                    f"swe_normalized_counts_half_2_esa_{i}": Decimal(str(val))
-                    for i, val in enumerate(summed_second)
-                },
+                "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),
             }
         )

imap_processing/ialirt/utils/constants.py

@@ -1,6 +1,20 @@
 """Keys for I-ALiRT data products."""
 
 IALIRT_KEYS = [
+    # H intensities in 15 energy ranges and binned into 4 azimuths and 4 spin angle bins
+    "codicehi_h",
+    # C/O abundance ratio
+    "codicelo_c_over_o_abundance",
+    # Mg/O abundance ratio
+    "codicelo_mg_over_o_abundance",
+    # Fe/O abundance ratio
+    "codicelo_fe_over_o_abundance",
+    # C+6/C+5 charge state ratio
+    "codicelo_c_plus_6_over_c_plus_5_ratio",
+    # O+7/O+6 charge state ratio
+    "codicelo_o_plus_7_over_o_plus_6_ratio",
+    # Fe low/Fe high charge state ratio
+    "codicelo_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)
@@ -40,9 +54,9 @@ IALIRT_KEYS = [
     # Pseudo temperature of solar wind protons in plasma frame
     "swapi_pseudo_proton_temperature",
     # SWE Normalized Counts - Half Cycle 1
-    *[f"swe_normalized_counts_half_1_esa_{i}" for i in range(8)],
+    "swe_normalized_counts_half_1",
     # SWE Normalized Counts - Half Cycle 2
-    *[f"swe_normalized_counts_half_2_esa_{i}" for i in range(8)],
+    "swe_normalized_counts_half_2",
     # SWE Counterstreaming flag
     "swe_counterstreaming_electrons",
 ]

imap_processing/ialirt/utils/create_xarray.py

@@ -7,7 +7,7 @@ from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.ialirt.utils.constants import IALIRT_KEYS
 
 
-def create_xarray_from_records(records: list[dict]) -> xr.Dataset:
+def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0912
     """
     Create dataset from a list of records.
 
@@ -39,16 +39,51 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:
         data=ttj2000ns_values,
         name="epoch",
         dims=["epoch"],
-        attrs=cdf_manager.get_variable_attributes("epoch"),
+        attrs=cdf_manager.get_variable_attributes("epoch", check_schema=False),
     )
     component = xr.DataArray(
         ["x", "y", "z"],
         name="component",
         dims=["component"],
-        attrs=cdf_manager.get_variable_attributes("component"),
+        attrs=cdf_manager.get_variable_attributes("component", check_schema=False),
     )
 
-    coords = {"epoch": epoch, "component": component}
+    esa_step = xr.DataArray(
+        data=np.arange(8, dtype=np.uint8),
+        name="esa_step",
+        dims=["esa_step"],
+        attrs=cdf_manager.get_variable_attributes("esa_step", check_schema=False),
+    )
+
+    energy_ranges = xr.DataArray(
+        data=np.arange(15, dtype=np.uint8),
+        name="energy_ranges",
+        dims=["energy_ranges"],
+        attrs=cdf_manager.get_variable_attributes("energy_ranges", check_schema=False),
+    )
+
+    azimuth = xr.DataArray(
+        data=np.arange(4, dtype=np.uint8),
+        name="azimuth",
+        dims=["azimuth"],
+        attrs=cdf_manager.get_variable_attributes("azimuth", check_schema=False),
+    )
+
+    spin_angle_bin = xr.DataArray(
+        data=np.arange(4, dtype=np.uint8),
+        name="spin_angle_bin",
+        dims=["spin_angle_bin"],
+        attrs=cdf_manager.get_variable_attributes("spin_angle_bin", check_schema=False),
+    )
+
+    coords = {
+        "epoch": epoch,
+        "component": component,
+        "esa_step": esa_step,
+        "energy_ranges": energy_ranges,
+        "azimuth": azimuth,
+        "spin_angle_bin": spin_angle_bin,
+    }
     dataset = xr.Dataset(
         coords=coords,
         attrs=cdf_manager.get_global_attributes("imap_ialirt_l1_realtime"),
@@ -56,17 +91,25 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:
 
     # Create empty dataset for each key.
     for key in instrument_keys:
-        attrs = cdf_manager.get_variable_attributes(key)
+        attrs = cdf_manager.get_variable_attributes(key, check_schema=False)
         fillval = attrs.get("FILLVAL")
         if key.startswith("mag"):
             data = np.full((n, 3), fillval, dtype=np.float32)
             dims = ["epoch", "component"]
             dataset[key] = xr.DataArray(data, dims=dims, attrs=attrs)
+        elif key.startswith("codicehi"):
+            data = np.full((n, 15, 4, 4), fillval, dtype=np.float32)
+            dims = ["epoch", "energy", "azimuth", "spin_angle_bin"]
+            dataset[key] = xr.DataArray(data, dims=dims, attrs=attrs)
         elif key == "swe_counterstreaming_electrons":
             data = np.full(n, fillval, dtype=np.uint8)
             dims = ["epoch"]
             dataset[key] = xr.DataArray(data, dims=dims, attrs=attrs)
-        elif key.startswith(("hit", "swe")):
+        elif key.startswith("swe"):
+            data = np.full((n, 8), fillval, dtype=np.uint32)
+            dims = ["epoch", "esa_step"]
+            dataset[key] = xr.DataArray(data, dims=dims, attrs=attrs)
+        elif key.startswith("hit"):
             data = np.full(n, fillval, dtype=np.uint32)
             dims = ["epoch"]
             dataset[key] = xr.DataArray(data, dims=dims, attrs=attrs)
@@ -77,11 +120,16 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:
 
     # Populate the dataset variables
     for i, record in enumerate(records):
-        for key in record.keys():
-            val = record[key]
-            if key.startswith("mag"):
-                dataset[key].data[i] = [direction for direction in val]
-            elif key in instrument_keys:
+        for key, val in record.items():
+            if key in ["apid", "met", "met_in_utc", "ttj2000ns"]:
+                continue
+            elif key.startswith("mag"):
+                dataset[key].data[i, :] = val
+            elif key.startswith("swe_normalized_counts"):
+                dataset[key].data[i, :] = val
+            elif key.startswith("codicehi"):
+                dataset[key].data[i, :, :, :] = val
+            else:
                 dataset[key].data[i] = val
 
     return dataset