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

imap_processing/lo/l1b/tof_conversions.py

@@ -0,0 +1,11 @@
+"""Lo TOF EU Conversions."""
+
+from collections import namedtuple
+
+tof_conv = namedtuple("tof_conv", ["C0", "C1"])
+# TOF conversion coefficients from Lo's TOF Conversion_annotated.docx
+# TODO: Ask Lo to put these in the algorithm document for better reference
+TOF0_CONV = tof_conv(C0=5.52524e-01, C1=1.68374e-01)
+TOF1_CONV = tof_conv(C0=-7.20181e-01, C1=1.65124e-01)
+TOF2_CONV = tof_conv(C0=3.74422e-01, C1=1.66409e-01)
+TOF3_CONV = tof_conv(C0=4.41970e-01, C1=1.72024e-01)

imap_processing/lo/l1c/lo_l1c.py

@@ -11,7 +11,7 @@ from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.spice.time import met_to_ttj2000ns
 
 
-def lo_l1c(dependencies: dict, data_version: str) -> list[Path]:
+def lo_l1c(dependencies: dict) -> list[Path]:
     """
     Will process IMAP-Lo L1B data into L1C CDF data products.
 
@@ -19,8 +19,6 @@ def lo_l1c(dependencies: dict, data_version: str) -> list[Path]:
     ----------
     dependencies : dict
         Dictionary of datasets needed for L1C data product creation in xarray Datasets.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
@@ -31,7 +29,6 @@ def lo_l1c(dependencies: dict, data_version: str) -> list[Path]:
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs(instrument="lo")
     attr_mgr.add_instrument_variable_attrs(instrument="lo", level="l1c")
-    attr_mgr.add_global_attribute("Data_version", data_version)
 
     # if the dependencies are used to create Annotated Direct Events
     if "imap_lo_l1b_de" in dependencies:

imap_processing/mag/constants.py

@@ -59,6 +59,31 @@ class PrimarySensor(Enum):
     MAGI = 1
 
 
+class VecSec(Enum):
+    """Enum for all valid vector rates (Vectors per second)."""
+
+    ONE_VEC_PER_S = 1
+    TWO_VECS_PER_S = 2
+    FOUR_VECS_PER_S = 4
+    EIGHT_VECS_PER_S = 8
+    SIXTEEN_VECS_PER_S = 16
+    THIRTY_TWO_VECS_PER_S = 32
+    SIXTY_FOUR_VECS_PER_S = 64
+    ONE_TWENTY_EIGHT_VECS_PER_S = 128
+
+
+# Possible sensor rates
+POSSIBLE_RATES = [e.value for e in VecSec]
+
+
+class ModeFlags(Enum):
+    """Enum for MAG mode flags: burst and normal (BURST + NORM)."""
+
+    NORM = 0
+    BURST = 1
+    MISSING = -1
+
+
 FIBONACCI_SEQUENCE = [
     1,
     2,
@@ -106,3 +131,29 @@ MAX_FINE_TIME = np.iinfo(np.uint16).max  # maximum 16 bit unsigned int
 AXIS_COUNT = 3
 RANGE_BIT_WIDTH = 2
 MAX_COMPRESSED_VECTOR_BITS = 60
+
+
+def vectors_per_second_from_string(vecsec_string: str) -> dict:
+    """
+    Extract the vectors per second from a string into a dictionary.
+
+    Dictionary format: {start_time: vecsec, start_time: vecsec}.
+
+    Parameters
+    ----------
+    vecsec_string : str
+        A string of the form "start:vecsec,start:vecsec" where start is the time in
+        nanoseconds and vecsec is the number of vectors per second.
+
+    Returns
+    -------
+    dict
+        A dictionary of the form {start_time: vecsec, start_time: vecsec}.
+    """
+    vecsec_dict = {}
+    vecsec_segments = vecsec_string.split(",")
+    for vecsec_segment in vecsec_segments:
+        start_time, vecsec = vecsec_segment.split(":")
+        vecsec_dict[int(start_time)] = int(vecsec)
+
+    return vecsec_dict

imap_processing/mag/imap_mag_sdc_configuration_v001.py

@@ -0,0 +1,8 @@
+"""File describing configuration changes that are not expected to change often."""
+
+# interpolation method used in L1C processing
+L1C_INTERPOLATION_METHOD = "linear_filtered"
+
+# Setting for L2 output
+# if this setting is updated, the dependency settings for L2 will also need to change.
+ALWAYS_OUTPUT_MAGO = True

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

@@ -24,7 +24,7 @@ from imap_processing.spice.time import (
 logger = logging.getLogger(__name__)
 
 
-def mag_l1a(packet_filepath: Path, data_version: str) -> list[xr.Dataset]:
+def mag_l1a(packet_filepath: Path) -> list[xr.Dataset]:
     """
     Will process MAG L0 data into L1A CDF files at cdf_filepath.
 
@@ -32,8 +32,6 @@ def mag_l1a(packet_filepath: Path, data_version: str) -> list[xr.Dataset]:
     ----------
     packet_filepath : pathlib.Path
         Packet files for processing.
-    data_version : str
-        Data version to write to CDF files.
 
     Returns
     -------
@@ -50,9 +48,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_global_attribute("Data_version", data_version)
+    attribute_manager.add_instrument_variable_attrs("mag", "l1a")
     attribute_manager.add_global_attribute("Input_files", str(input_files))
     attribute_manager.add_global_attribute(
         "Generation_date",
@@ -179,7 +175,7 @@ def process_packets(
         # each sensor, we can calculate how much data is in this packet and where the
         # byte boundaries are.
         primary_vectors, secondary_vectors = MagL1a.process_vector_data(
-            mag_l0.VECTORS,  # type: ignore
+            mag_l0.VECTORS,
             primary_packet_properties.total_vectors,
             secondary_packet_data.total_vectors,
             mag_l0.COMPRESSION,
@@ -276,11 +272,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,18 +279,20 @@ 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
-    # what mag is expecting, and if it is, CATDESC needs to be updated.
     epoch_time = xr.DataArray(
         time_data,
         name="epoch",
@@ -338,6 +331,18 @@ def generate_dataset(
             "compression_label", check_schema=False
         ),
     )
+    global_attributes = attribute_manager.get_global_attributes(logical_file_id)
+    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 +350,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(
@@ -368,7 +368,7 @@ class MagL1a:
 
     @staticmethod
     def process_vector_data(
-        vector_data: np.ndarray,
+        vector_data: np.ndarray | bytes,
         primary_count: int,
         secondary_count: int,
         compression: int,
@@ -679,10 +679,9 @@ class MagL1a:
                             primary_boundaries[-1] - primary_boundaries[-4]
                             > MAX_COMPRESSED_VECTOR_BITS
                         )
-                        or (
-                            vector_count == 2
-                            and primary_boundaries[-1] > MAX_COMPRESSED_VECTOR_BITS
-                        )
+                    ) or (
+                        vector_count == 2
+                        and primary_boundaries[-1] > MAX_COMPRESSED_VECTOR_BITS
                     ):
                         # Since we know how long each uncompressed vector is,
                         # we can determine the end of the primary vectors.
@@ -792,7 +791,7 @@ class MagL1a:
         return primary_vectors, secondary_vectors
 
     @staticmethod
-    def _process_vector_section(  # noqa: PLR0913
+    def _process_vector_section(
         vector_bits: np.ndarray,
         split_bits: list,
         last_index: int,
@@ -998,7 +997,7 @@ class MagL1a:
         """
         if np.any(vector_data > 1):
             raise ValueError(
-                "unpack_one_vector method is expecting an array of bits as" "input."
+                "unpack_one_vector method is expecting an array of bits as input."
             )
 
         if len(vector_data) != width * AXIS_COUNT + RANGE_BIT_WIDTH * has_range:
@@ -1092,3 +1091,29 @@ 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 _, packet in self.packet_definitions.items():
+            vecsec = packet.vectors_per_second
+            time: np.int64 = packet.start_time.to_j2000ns().astype(np.int64)
+            if vecsec != last_vectors_per_second:
+                if output_str == "":
+                    output_str = f"{time}:{vecsec}"
+                else:
+                    output_str += f",{time}:{vecsec}"
+                last_vectors_per_second = vecsec
+
+        return output_str