imap-processing 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

imap_processing/idex/idex_variable_unpacking_and_eu_conversion.csv

@@ -1,33 +1,39 @@
-index,mnemonic,var_name,starting_bit,nbits_padding_before,unsigned_nbits,unit,c0,c1,c2,c3,c4,c5,c6,c7,convertAs,packetName
-1,current_1v_pol,idx__txhdrprochkch01,4,4,12,mA,0,0.9029253,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-2,current_1p9v_pol,idx__txhdrprochkch01,20,4,12,mA,0,0.9029253,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-3,temperature_1,idx__txhdrprochkch23,4,4,12,C,162.8276,-0.2668687,0.000332379,-2.43E-07,9.03E-11,-1.33E-14,0.00E+00,0.00E+00,UNSEGMENTED_POLY,IDEX_SCI
-4,temperature_2,idx__txhdrprochkch23,20,4,12,C,162.8276,-0.2668687,0.000332379,-2.43E-07,9.03E-11,-1.33E-14,0.00E+00,0.00E+00,UNSEGMENTED_POLY,IDEX_SCI
-5,voltage_1v_bus,idx__txhdrprochkch45,4,4,12,V,0,0.000805861,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-6,fpga_temperature,idx__txhdrprochkch45,20,4,12,C,358.31,-0.1187104,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-7,voltage_1p9v_bus,idx__txhdrprochkch67,4,4,12,V,0,0.000805861,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-8,voltage_3p3v_bus,idx__txhdrprochkch67,20,4,12,V,0,0.001611722,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-9,detector_voltage,idx__txhdrhvpshkch01,4,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-10,sensor_voltage,idx__txhdrhvpshkch01,20,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-11,target_voltage,idx__txhdrhvpshkch23,4,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-12,reflectron_voltage,idx__txhdrhvpshkch23,20,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-13,rejection_voltage,idx__txhdrhvpshkch45,4,4,12,V,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-14,current_hvps_sensor,idx__txhdrhvpshkch45,20,4,12,mA,0,7.33E-06,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-15,positive_current_hvps,idx__txhdrhvpshkch67,4,4,12,mA,0,2.43E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-16,negative_current_hvps,idx__txhdrhvpshkch67,20,4,12,mA,0,2.43E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-17,voltage_3p3_ref,idx__txhdrlvhk0ch01,4,4,12,V,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-18,voltage_3p3_op_ref,idx__txhdrlvhk0ch01,20,4,12,V,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-19,voltage_neg6v_bus,idx__txhdrlvhk0ch23,4,4,12,V,-33,0.00886447,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-20,voltage_pos6v_bus,idx__txhdrlvhk0ch23,20,4,12,V,0,0.00241758,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-21,voltage_pos16v_bus,idx__txhdrlvhk0ch45,4,4,12,V,0,0.00482711,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-22,voltage_pos3p3v_bus,idx__txhdrlvhk0ch45,20,4,12,V,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-23,voltage_neg5v_bus,idx__txhdrlvhk0ch67,4,4,12,V,-33,0.00886447,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-24,voltage_pos5v_bus,idx__txhdrlvhk0ch67,20,4,12,V,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-25,current_3p3_bus,idx__txhdrlvhk1ch01,4,4,12,A,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-26,current_16v_bus,idx__txhdrlvhk1ch01,20,4,12,A,0,0.000161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-27,current_6v_bus,idx__txhdrlvhk1ch23,4,4,12,A,0,8.06E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-28,current_neg6v_bus,idx__txhdrlvhk1ch23,20,4,12,A,0,-8.06E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-29,current_5v_bus,idx__txhdrlvhk1ch45,4,4,12,A,0,4.03E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-30,current_neg5v_bus,idx__txhdrlvhk1ch45,20,4,12,A,0,-2.01E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-31,current_2p5v_bus,idx__txhdrlvhk1ch67,4,4,12,A,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
-32,current_neg2p5v_bus,idx__txhdrlvhk1ch67,20,4,12,A,0,-4.03E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+index,mnemonic,var_name,starting_bit,nbits_padding_before,unsigned_nbits,unit,dn_range_start,dn_range_stop,c0,c1,c2,c3,c4,c5,c6,c7,convertAs,packetName
+1,current_1v_pol,idx__txhdrprochkch01,4,4,12,mA,,,0,0.9029253,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+2,current_1p9v_pol,idx__txhdrprochkch01,20,4,12,mA,,,0,0.9029253,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+3,temperature_1,idx__txhdrprochkch23,4,4,12,C,0,2063,162.8276,-0.2668687,0.000332379,-2.43E-07,9.03E-11,-1.33E-14,0,0,SEGMENTED_POLY,IDEX_SCI
+4,temperature_1,idx__txhdrprochkch23,4,4,12,C,2064,3853,714.2124,-1.194011,0.000859909,-3.15E-07,5.75E-11,-4.21E-15,0,0,SEGMENTED_POLY,IDEX_SCI
+5,temperature_1,idx__txhdrprochkch23,4,4,12,C,4854,4051,136881.2,-105.4644,0.02710281,-2.32E-06,0,0,0,0,SEGMENTED_POLY,IDEX_SCI
+6,temperature_1,idx__txhdrprochkch23,4,4,12,C,4052,4095,-100809.9,50.03809,-0.00621209,0,0,0,0,0,SEGMENTED_POLY,IDEX_SCI
+7,temperature_2,idx__txhdrprochkch23,20,4,12,C,0,2063,162.8276,-0.2668687,0.000332379,-2.43E-07,9.03E-11,-1.33E-14,0,0,SEGMENTED_POLY,IDEX_SCI
+8,temperature_2,idx__txhdrprochkch23,20,4,12,C,2064,3853,714.2124,-1.194011,0.000859909,-3.15E-07,5.75E-11,-4.21E-15,0,0,SEGMENTED_POLY,IDEX_SCI
+9,temperature_2,idx__txhdrprochkch23,20,4,12,C,4854,4051,136881.2,-105.4644,0.02710281,-2.32E-06,0,0,0,0,SEGMENTED_POLY,IDEX_SCI
+10,temperature_2,idx__txhdrprochkch23,20,4,12,C,4052,4095,-100809.9,50.03809,-0.00621209,0,0,0,0,0,SEGMENTED_POLY,IDEX_SCI
+11,voltage_1v_bus,idx__txhdrprochkch45,4,4,12,V,,,0,0.000805861,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+12,fpga_temperature,idx__txhdrprochkch45,20,4,12,C,,,358.31,-0.1187104,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+13,voltage_1p9v_bus,idx__txhdrprochkch67,4,4,12,V,,,0,0.000805861,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+14,voltage_3p3v_bus,idx__txhdrprochkch67,20,4,12,V,,,0,0.001611722,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+15,detector_voltage,idx__txhdrhvpshkch01,4,4,12,V,,,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+16,sensor_voltage,idx__txhdrhvpshkch01,20,4,12,V,,,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+17,target_voltage,idx__txhdrhvpshkch23,4,4,12,V,,,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+18,reflectron_voltage,idx__txhdrhvpshkch23,20,4,12,V,,,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+19,rejection_voltage,idx__txhdrhvpshkch45,4,4,12,V,,,0,1.4652,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+20,current_hvps_sensor,idx__txhdrhvpshkch45,20,4,12,mA,,,0,7.33E-06,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+21,positive_current_hvps,idx__txhdrhvpshkch67,4,4,12,mA,,,0,2.43E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+22,negative_current_hvps,idx__txhdrhvpshkch67,20,4,12,mA,,,0,2.43E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+23,voltage_3p3_ref,idx__txhdrlvhk0ch01,4,4,12,V,,,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+24,voltage_3p3_op_ref,idx__txhdrlvhk0ch01,20,4,12,V,,,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+25,voltage_neg6v_bus,idx__txhdrlvhk0ch23,4,4,12,V,,,-33,0.00886447,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+26,voltage_pos6v_bus,idx__txhdrlvhk0ch23,20,4,12,V,,,0,0.00241758,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+27,voltage_pos16v_bus,idx__txhdrlvhk0ch45,4,4,12,V,,,0,0.00482711,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+28,voltage_pos3p3v_bus,idx__txhdrlvhk0ch45,20,4,12,V,,,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+29,voltage_neg5v_bus,idx__txhdrlvhk0ch67,4,4,12,V,,,-33,0.00886447,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+30,voltage_pos5v_bus,idx__txhdrlvhk0ch67,20,4,12,V,,,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+31,current_3p3_bus,idx__txhdrlvhk1ch01,4,4,12,A,,,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+32,current_16v_bus,idx__txhdrlvhk1ch01,20,4,12,A,,,0,0.000161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+33,current_6v_bus,idx__txhdrlvhk1ch23,4,4,12,A,,,0,8.06E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+34,current_neg6v_bus,idx__txhdrlvhk1ch23,20,4,12,A,,,0,-8.06E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+35,current_5v_bus,idx__txhdrlvhk1ch45,4,4,12,A,,,0,4.03E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+36,current_neg5v_bus,idx__txhdrlvhk1ch45,20,4,12,A,,,0,-2.01E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+37,current_2p5v_bus,idx__txhdrlvhk1ch67,4,4,12,A,,,0,0.00161172,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI
+38,current_neg2p5v_bus,idx__txhdrlvhk1ch67,20,4,12,A,,,0,-4.03E-05,0,0,0,0,0,0,UNSEGMENTED_POLY,IDEX_SCI

imap_processing/lo/l0/lo_science.py

@@ -410,6 +410,12 @@ def combine_segmented_packets(dataset: xr.Dataset) -> xr.Dataset:
     dataset.coords["epoch"] = dataset["epoch"].values[seg_starts]
     # drop any group of segmented epochs that aren't sequential
     dataset.coords["epoch"] = dataset["epoch"].values[valid_groups]
+    # Set met to the first segment start times for the valid groups.
+    # shcoarse will be retained as a per packet coordinate and met
+    # is used as the mission elapsed time for each segment
+    dataset["met"] = xr.DataArray(
+        dataset["shcoarse"].values[seg_starts][valid_groups], dims="epoch"
+    )
 
     return dataset
 

imap_processing/lo/l1a/lo_l1a.py

@@ -286,7 +286,6 @@ def add_dataset_attrs(
                 "seq_flgs",
                 "src_seq_ctr",
                 "pkt_len",
-                "shcoarse",
                 "data",
                 "events",
             ]

imap_processing/lo/l1b/lo_l1b.py

@@ -1,8 +1,8 @@
 """IMAP-Lo L1B Data Processing."""
 
-from collections import namedtuple
 from dataclasses import Field
 from pathlib import Path
+from typing import Any, Union
 
 import numpy as np
 import xarray as xr
@@ -28,35 +28,187 @@ def lo_l1b(dependencies: dict, data_version: str) -> list[Path]:
         Location of created CDF files.
     """
     # create the attribute manager for this data level
-    attr_mgr = ImapCdfAttributes()
-    attr_mgr.add_instrument_global_attrs(instrument="lo")
-    attr_mgr.add_instrument_variable_attrs(instrument="lo", level="l1b")
-    attr_mgr.add_global_attribute("Data_version", data_version)
+    attr_mgr_l1b = ImapCdfAttributes()
+    attr_mgr_l1b.add_instrument_global_attrs(instrument="lo")
+    attr_mgr_l1b.add_instrument_variable_attrs(instrument="lo", level="l1b")
+    attr_mgr_l1b.add_global_attribute("Data_version", data_version)
+    # create the attribute manager to access L1A fillval attributes
+    attr_mgr_l1a = ImapCdfAttributes()
+    attr_mgr_l1a.add_instrument_variable_attrs(instrument="lo", level="l1a")
 
     # if the dependencies are used to create Annotated Direct Events
-
     if "imap_lo_l1a_de" in dependencies and "imap_lo_l1a_spin" in dependencies:
         logical_source = "imap_lo_l1b_de"
-        # TODO: TEMPORARY. Need to update to use the L1B data class once that exists
-        #  and I have sample data.
-        data_field_tup = namedtuple("data_field_tup", ["name"])
-        data_fields = [
-            data_field_tup("ESA_STEP"),
-            data_field_tup("MODE"),
-            data_field_tup("TOF0"),
-            data_field_tup("TOF1"),
-            data_field_tup("TOF2"),
-            data_field_tup("TOF3"),
-            data_field_tup("COINCIDENCE_TYPE"),
-            data_field_tup("POS"),
-            data_field_tup("COINCIDENCE"),
-            data_field_tup("BADTIME"),
-            data_field_tup("DIRECTION"),
-        ]
+        # get the dependency dataset for l1b direct events
+        l1a_de = dependencies["imap_lo_l1a_de"]
+        spin_data = dependencies["imap_lo_l1a_spin"]
 
-    dataset: list[Path] = create_datasets(attr_mgr, logical_source, data_fields)  # type: ignore[arg-type]
-    # TODO Remove once data_fields is removed from create_datasets
-    return dataset
+        # Initialize the L1B DE dataset
+        l1b_de = initialize_l1b_de(l1a_de, attr_mgr_l1b, logical_source)
+        # Get the start and end times for each spin epoch
+        acq_start, acq_end = convert_start_end_acq_times(spin_data)
+        # Get the average spin durations for each epoch
+        avg_spin_durations = get_avg_spin_durations(acq_start, acq_end)  # noqa: F841
+        # get spin angle (0 - 360 degrees) for each DE
+        spin_angle = get_spin_angle(l1a_de)
+        # calculate and set the spin bin based on the spin angle
+        # spin bins are 0 - 60 bins
+        l1b_de = set_spin_bin(l1b_de, spin_angle)
+
+    return [l1b_de]
+
+
+def initialize_l1b_de(
+    l1a_de: xr.Dataset, attr_mgr_l1b: ImapCdfAttributes, logical_source: str
+) -> xr.Dataset:
+    """
+    Initialize the L1B DE dataset.
+
+    Create an empty L1B DE dataset and copy over fields from the L1A DE that will
+    not change during L1B processing.
+
+    Parameters
+    ----------
+    l1a_de : xarray.Dataset
+        The L1A DE dataset.
+    attr_mgr_l1b : ImapCdfAttributes
+        Attribute manager used to get the global attributes for the L1B DE dataset.
+    logical_source : str
+        The logical source of the direct event product.
+
+    Returns
+    -------
+    l1b_de : xarray.Dataset
+        The initialized L1B DE dataset.
+    """
+    l1b_de = xr.Dataset(
+        attrs=attr_mgr_l1b.get_global_attributes(logical_source),
+    )
+
+    # Copy over fields from L1A DE that will not change in L1B processing
+    l1b_de["pos"] = xr.DataArray(
+        l1a_de["pos"].values,
+        dims=["epoch"],
+        # TODO: Add pos to YAML file
+        # attrs=attr_mgr.get_variable_attributes("pos"),
+    )
+    l1b_de["mode"] = xr.DataArray(
+        l1a_de["mode"].values,
+        dims=["epoch"],
+        # TODO: Add mode to YAML file
+        # attrs=attr_mgr.get_variable_attributes("mode"),
+    )
+    l1b_de["absent"] = xr.DataArray(
+        l1a_de["coincidence_type"].values,
+        dims=["epoch"],
+        # TODO: Add absent to YAML file
+        # attrs=attr_mgr.get_variable_attributes("absent"),
+    )
+    l1b_de["esa_step"] = xr.DataArray(
+        l1a_de["esa_step"].values,
+        dims=["epoch"],
+        # TODO: Add esa_step to YAML file
+        # attrs=attr_mgr.get_variable_attributes("esa_step"),
+    )
+
+    return l1b_de
+
+
+def convert_start_end_acq_times(
+    spin_data: xr.Dataset,
+) -> tuple[xr.DataArray, xr.DataArray]:
+    """
+    Convert the start and end times from the spin data.
+
+    The L1A spin data start and end acquisition times are stored in seconds and
+    subseconds (microseconds). This function converts them to a single time in seconds.
+
+    Parameters
+    ----------
+    spin_data : xarray.Dataset
+        The L1A Spin dataset containing the start and end acquisition times.
+
+    Returns
+    -------
+    tuple[xr.DataArray, xr.DataArray]
+        A tuple containing the start and end acquisition times as xarray DataArrays.
+    """
+    # Convert subseconds from microseconds to seconds
+    acq_start = spin_data["acq_start_sec"] + spin_data["acq_start_subsec"] * 1e-6
+    acq_end = spin_data["acq_end_sec"] + spin_data["acq_end_subsec"] * 1e-6
+    return (acq_start, acq_end)
+
+
+def get_avg_spin_durations(
+    acq_start: xr.DataArray, acq_end: xr.DataArray
+) -> xr.DataArray:
+    """
+    Get the average spin duration for each spin epoch.
+
+    Parameters
+    ----------
+    acq_start : xarray.DataArray
+        The start acquisition times for each spin epoch.
+    acq_end : xarray.DataArray
+        The end acquisition times for each spin epoch.
+
+    Returns
+    -------
+    avg_spin_durations : xarray.DataArray
+        The average spin duration for each spin epoch.
+    """
+    # Get the avg spin duration for each spin epoch
+    # There are 28 spins per epoch (1 aggregated science cycle)
+    avg_spin_durations = (acq_end - acq_start) / 28
+    return avg_spin_durations
+
+
+def get_spin_angle(l1a_de: xr.Dataset) -> Union[np.ndarray[np.float64], Any]:
+    """
+    Get the spin angle (0 - 360 degrees) for each DE.
+
+    Parameters
+    ----------
+    l1a_de : xarray.Dataset
+        The L1A DE dataset.
+
+    Returns
+    -------
+    spin_angle : np.ndarray
+        The spin angle for each DE.
+    """
+    de_times = l1a_de["de_time"].values
+    # DE Time is 12 bit DN. The max possible value is 4096
+    spin_angle = np.array(de_times / 4096 * 360, dtype=np.float64)
+    return spin_angle
+
+
+def set_spin_bin(l1b_de: xr.Dataset, spin_angle: np.ndarray) -> xr.Dataset:
+    """
+    Set the spin bin (0 - 60 bins) for each Direct Event where each bin is 6 degrees.
+
+    Parameters
+    ----------
+    l1b_de : xarray.Dataset
+        The L1B Direct Event dataset.
+    spin_angle : np.ndarray
+        The spin angle (0-360 degrees) for each Direct Event.
+
+    Returns
+    -------
+    l1b_de : xarray.Dataset
+        The L1B DE dataset with the spin bin added.
+    """
+    # Get the spin bin for each DE
+    # Spin bins are 0 - 60 where each bin is 6 degrees
+    spin_bin = (spin_angle // 6).astype(int)
+    l1b_de["spin_bin"] = xr.DataArray(
+        spin_bin,
+        dims=["epoch"],
+        # TODO: Add spin angle to YAML file
+        # attrs=attr_mgr.get_variable_attributes("spin_bin"),
+    )
+    return l1b_de
 
 
 # TODO: This is going to work differently when I sample data.

imap_processing/mag/constants.py

@@ -59,6 +59,14 @@ class PrimarySensor(Enum):
     MAGI = 1
 
 
+class ModeFlags(Enum):
+    """Enum for MAG mode flags: burst and normal (BURST + NORM)."""
+
+    NORM = 0
+    BURST = 1
+    MISSING = -1
+
+
 FIBONACCI_SEQUENCE = [
     1,
     2,

imap_processing/mag/imap_mag_sdc-configuration_v001.yaml

@@ -0,0 +1,6 @@
+# This file describes configuration changes that are not expected to change often,
+# but may change.
+
+# interpolation method used in L1C processing
+L1C_interpolation_method: "linear"
+

imap_processing/mag/l0/decom_mag.py

@@ -164,12 +164,19 @@ def generate_dataset(
 
     for key, value in support_data.items():
         # Time varying values
-        if key not in ["SHCOARSE", "VECTORS"]:
-            output[key] = xr.DataArray(
+        if key not in [
+            "SHCOARSE",
+            "VECTORS",
+            "PUS_SPARE1",
+            "PUS_SPARE2",
+            "SPARE1",
+            "SPARE2",
+        ]:
+            output[key.lower()] = xr.DataArray(
                 value,
                 name=key.lower(),
                 dims=["epoch"],
-                attrs=attribute_manager.get_variable_attributes(key),
+                attrs=attribute_manager.get_variable_attributes(key.lower()),
             )
 
     return output

imap_processing/mag/l1a/mag_l1a.py

@@ -50,7 +50,7 @@ def mag_l1a(packet_filepath: Path, data_version: str) -> list[xr.Dataset]:
     # Create attribute manager and add MAG L1A attributes and global variables
     attribute_manager = ImapCdfAttributes()
     attribute_manager.add_instrument_global_attrs("mag")
-    attribute_manager.add_instrument_variable_attrs("mag", "l1")
+    attribute_manager.add_instrument_variable_attrs("mag", "l1a")
 
     attribute_manager.add_global_attribute("Data_version", data_version)
     attribute_manager.add_global_attribute("Input_files", str(input_files))
@@ -276,11 +276,6 @@ def generate_dataset(
     dataset : xarray.Dataset
         One xarray dataset with proper CDF attributes and shape containing MAG L1A data.
     """
-    # TODO: add:
-    # gaps_in_data global attr
-    # magl1avectordefinition data
-
-    # TODO: Just leave time in datetime64 type with vector as dtype object to avoid this
     # Get the timestamp from the end of the vector
     time_data = single_file_l1a.vectors[:, 4]
 
@@ -288,14 +283,18 @@ def generate_dataset(
         np.arange(2),
         name="compression",
         dims=["compression"],
-        attrs=attribute_manager.get_variable_attributes("compression_attrs"),
+        attrs=attribute_manager.get_variable_attributes(
+            "compression_attrs", check_schema=False
+        ),
     )
 
     direction = xr.DataArray(
         np.arange(4),
         name="direction",
         dims=["direction"],
-        attrs=attribute_manager.get_variable_attributes("direction_attrs"),
+        attrs=attribute_manager.get_variable_attributes(
+            "direction_attrs", check_schema=False
+        ),
     )
 
     # TODO: Epoch here refers to the start of the sample. Confirm that this is
@@ -338,6 +337,19 @@ def generate_dataset(
             "compression_label", check_schema=False
         ),
     )
+    global_attributes = attribute_manager.get_global_attributes(logical_file_id)
+    # TODO: this method won't work because these values are not in the schema.
+    global_attributes["is_mago"] = str(bool(single_file_l1a.is_mago))
+    global_attributes["is_active"] = str(bool(single_file_l1a.is_active))
+    global_attributes["vectors_per_second"] = (
+        single_file_l1a.vectors_per_second_attribute()
+    )
+    # empty arrays are removed in cdflib
+    global_attributes["missing_sequences"] = (
+        single_file_l1a.missing_sequences
+        if single_file_l1a.missing_sequences
+        else "None"
+    )
 
     output = xr.Dataset(
         coords={
@@ -345,13 +357,12 @@ def generate_dataset(
             "direction": direction,
             "compression": compression,
         },
-        attrs=attribute_manager.get_global_attributes(logical_file_id),
+        attrs=global_attributes,
     )
+
     output["direction_label"] = direction_label
     output["compression_label"] = compression_label
     output["vectors"] = vectors
     output["compression_flags"] = compression_flags
 
-    # TODO: Put is_mago and active in the header
-
     return output

imap_processing/mag/l1a/mag_l1a_data.py

@@ -240,6 +240,7 @@ class MagL1a:
     decode_fib_zig_zag()
     twos_complement()
     update_compression_array()
+    vectors_per_second_attribute()
     """
 
     is_mago: bool
@@ -285,7 +286,8 @@ class MagL1a:
         vector_sequence = packet_properties.src_seq_ctr
 
         self.vectors = np.concatenate([self.vectors, additional_vectors])
-        self.packet_definitions[self.start_time] = packet_properties
+        start_time = np.int64(met_to_ttj2000ns(packet_properties.shcoarse))
+        self.packet_definitions[start_time] = packet_properties
 
         # Every additional packet should be the next one in the sequence, if not, add
         # the missing sequence(s) to the gap data
@@ -349,9 +351,7 @@ class MagL1a:
             cdf.utils.met_to_j2000ns.
         """
         timedelta = np.timedelta64(int(1 / vectors_per_sec * 1e9), "ns")
-        # TODO: From finetime and coarsetime, depends per packet
         start_time_ns = start_time.to_j2000ns()
-
         # Calculate time skips for each vector in ns
         times = np.reshape(
             np.arange(
@@ -1092,3 +1092,28 @@ class MagL1a:
         value = int((value >> 1) ^ (-(value & 1)))
 
         return value
+
+    def vectors_per_second_attribute(self) -> str:
+        """
+        Generate a string describing the vectors per second.
+
+        Format is {start time}:{vectors per second},{start time}:{vectors per second}
+        where it's only included if vectors per second changes.
+
+        Returns
+        -------
+        output_str : str
+            Output string describing the vectors per second in all the packets.
+        """
+        output_str = ""
+        last_vectors_per_second = None
+        for start_time, packet in self.packet_definitions.items():
+            vecsec = packet.vectors_per_second
+            if vecsec != last_vectors_per_second:
+                if output_str == "":
+                    output_str = f"{start_time}:{vecsec}"
+                else:
+                    output_str += f",{start_time}:{vecsec}"
+                last_vectors_per_second = vecsec
+
+        return output_str