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

imap_processing/hi/hi_l1a.py

@@ -0,0 +1,447 @@
+"""IMAP-HI L1A processing module."""
+
+import logging
+from collections import defaultdict
+from pathlib import Path
+from typing import Union
+
+import numpy as np
+import xarray as xr
+from numpy import _typing as npt
+from numpy._typing import NDArray
+
+from imap_processing import imap_module_directory
+from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
+from imap_processing.hi.utils import HIAPID
+from imap_processing.spice.time import met_to_ttj2000ns
+from imap_processing.utils import packet_file_to_datasets
+
+# TODO: read DE_CLOCK_TICK_US from
+# instrument status summary later. This value
+# is rarely change but want to be able to change
+# it if needed. It stores information about how
+# fast the time was ticking. It is in microseconds.
+DE_CLOCK_TICK_US = 1999
+DE_CLOCK_TICK_S = DE_CLOCK_TICK_US / 1e6
+HALF_CLOCK_TICK_S = DE_CLOCK_TICK_S / 2
+
+MILLISECOND_TO_S = 1e-3
+
+# define the names of the 24 counter arrays
+# contained in the histogram packet
+QUALIFIED_COUNTERS = (
+    "ab_qualified",
+    "c1c2_qualified",
+    "ac1_qualified",
+    "bc1_qualified",
+    "abc1_qualified",
+    "ac1c2_qualified",
+    "bc1c2_qualified",
+    "abc1c2_qualified",
+)
+LONG_COUNTERS = (
+    "a_first_only",
+    "b_first_only",
+    "c_first_only",
+    "ab_long",
+    "c1c2_long",
+    "ac1_long",
+    "bc1_long",
+    "abc1_long",
+    "ac1c2_long",
+    "bc1c2_long",
+    "abc1c2_long",
+)
+TOTAL_COUNTERS = ("a_total", "b_total", "c_total", "fee_de_recd", "fee_de_sent")
+
+logger = logging.getLogger(__name__)
+
+
+def hi_l1a(packet_file_path: Union[str, Path]) -> list[xr.Dataset]:
+    """
+    Will process IMAP raw data to l1a.
+
+    Parameters
+    ----------
+    packet_file_path : str
+        Data packet file path.
+
+    Returns
+    -------
+    processed_data : list[xarray.Dataset]
+        List of processed xarray dataset.
+    """
+    datasets_by_apid = hi_packet_file_to_datasets(packet_file_path)
+
+    # Process science to l1a.
+    processed_data = []
+    for apid in datasets_by_apid:
+        try:
+            apid_enum = HIAPID(apid)
+        except ValueError as err:
+            raise RuntimeError(f"Encountered unexpected APID [{apid}]") from err
+
+        logger.info(f"Processing IMAP-Hi data for {apid_enum.name} packets")
+
+        if apid_enum in [HIAPID.H45_SCI_CNT, HIAPID.H90_SCI_CNT]:
+            data = finish_hist_dataset(datasets_by_apid[apid])
+            gattr_key = "imap_hi_l1a_hist_attrs"
+        elif apid_enum in [HIAPID.H45_SCI_DE, HIAPID.H90_SCI_DE]:
+            data = finish_de_dataset(datasets_by_apid[apid])
+            gattr_key = "imap_hi_l1a_de_attrs"
+        elif apid_enum in [HIAPID.H45_APP_NHK, HIAPID.H90_APP_NHK]:
+            data = datasets_by_apid[apid]
+            gattr_key = "imap_hi_l1a_hk_attrs"
+        elif apid_enum in [HIAPID.H45_DIAG_FEE, HIAPID.H90_DIAG_FEE]:
+            data = datasets_by_apid[apid]
+            gattr_key = "imap_hi_l1a_diagfee_attrs"
+
+        # Update dataset global attributes
+        attr_mgr = ImapCdfAttributes()
+        attr_mgr.add_instrument_global_attrs("hi")
+        data.attrs.update(attr_mgr.get_global_attributes(gattr_key))
+
+        # set the sensor string in Logical_source
+        sensor_str = apid_enum.sensor
+        data.attrs["Logical_source"] = data.attrs["Logical_source"].format(
+            sensor=sensor_str
+        )
+        processed_data.append(data)
+    return processed_data
+
+
+def hi_packet_file_to_datasets(
+    packet_file_path: Union[str, Path], use_derived_value: bool = False
+) -> dict[int, xr.Dataset]:
+    """
+    Extract hi datasets from packet file.
+
+    Parameters
+    ----------
+    packet_file_path : str
+        L0 packet file path.
+    use_derived_value : bool
+        Whether to use the derived value from the XTCE definition. Default is False.
+
+    Returns
+    -------
+    datasets : dict[int, xarray.Dataset]
+        Dictionary of xarray datasets keyed by APID.
+    """
+    packet_def_file = (
+        imap_module_directory / "hi/packet_definitions/TLM_HI_COMBINED_SCI.xml"
+    )
+    datasets_by_apid = packet_file_to_datasets(
+        packet_file=packet_file_path,
+        xtce_packet_definition=packet_def_file,
+        use_derived_value=use_derived_value,
+    )
+    return datasets_by_apid
+
+
+def finish_de_dataset(packets_data: xr.Dataset) -> xr.Dataset:
+    """
+    Unpack IMAP-Hi direct event data.
+
+    Processing step:
+
+    |    1. Break binary stream data into unit of 48-bits
+    |    2. Parse direct event data
+    |    5. Save the data into xarray dataset.
+
+    Parameters
+    ----------
+    packets_data : xarray.Dataset
+        Packets extracted into a dataset.
+
+    Returns
+    -------
+    dataset : xarray.Dataset
+        Xarray dataset.
+    """
+    de_data_dict: dict[str, list] = defaultdict(list)
+
+    # Add packet data to the dictionary, renaming some fields
+    # This is done first so that these variables are first in the CDF
+    for from_key, to_key in {
+        "shcoarse": "ccsds_met",
+        "src_seq_ctr": "src_seq_ctr",
+        "pkt_len": "pkt_len",
+        "last_spin_num": "last_spin_num",
+        "spin_invalids": "spin_invalids",
+        "esa_step_num": "esa_step",
+        "meta_seconds": "meta_seconds",
+        "meta_subseconds": "meta_subseconds",
+    }.items():
+        de_data_dict[to_key] = packets_data[from_key].data
+
+    # For each packet, parse the DE data and add it to the Pointing
+    # list of DE data usint `extend()`
+    for i, data in enumerate(packets_data["de_tof"].data):
+        parsed_de_data = parse_direct_events(data)
+        for key, new_data in parsed_de_data.items():
+            de_data_dict[key].extend(new_data)
+        # Record the ccsds packet index for each DE
+        de_data_dict["ccsds_index"].extend([i] * len(parsed_de_data["de_tag"]))
+
+    # create dataset
+    return create_de_dataset(de_data_dict)
+
+
+def create_de_dataset(de_data_dict: dict[str, npt.ArrayLike]) -> xr.Dataset:
+    """
+    Create Hi L1A direct event xarray dataset.
+
+    Parameters
+    ----------
+    de_data_dict : Dict[list]
+        Dictionary of packet telemetry and direct event data lists.
+
+    Returns
+    -------
+    dataset : xarray.Dataset
+        Xarray dataset.
+    """
+    # Load the CDF attributes
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs("hi")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
+
+    # check_schema=False keeps DEPEND_0 = '' from being auto added
+    epoch_attrs = attr_mgr.get_variable_attributes("epoch", check_schema=False)
+    epoch_attrs["CATDESC"] = (
+        "CCSDS creation time, number of nanoseconds since J2000 with leap "
+        "seconds included"
+    )
+    epoch = xr.DataArray(
+        met_to_ttj2000ns(de_data_dict["ccsds_met"]),
+        name="epoch",
+        dims=["epoch"],
+        attrs=epoch_attrs,
+    )
+
+    event_met_attrs = attr_mgr.get_variable_attributes(
+        "hi_de_event_met", check_schema=False
+    )
+    # For L1A DE, event_met is its own dimension, so we remove the DEPEND_0 attribute
+    _ = event_met_attrs.pop("DEPEND_0")
+
+    # Compute the meta-event MET in seconds
+    meta_event_met = (
+        np.array(de_data_dict["meta_seconds"]).astype(np.float64)
+        + np.array(de_data_dict["meta_subseconds"]) * MILLISECOND_TO_S
+    )
+    # Compute the MET of each event in seconds
+    # event MET = meta_event_met + de_clock
+    # See Hi Algorithm Document section 2.2.5
+    event_met_array = np.array(
+        meta_event_met[de_data_dict["ccsds_index"]]
+        + np.array(de_data_dict["de_tag"]) * DE_CLOCK_TICK_S,
+        dtype=event_met_attrs.pop("dtype"),
+    )
+    event_met = xr.DataArray(
+        event_met_array,
+        name="event_met",
+        dims=["event_met"],
+        attrs=event_met_attrs,
+    )
+
+    dataset = xr.Dataset(
+        coords={"epoch": epoch, "event_met": event_met},
+    )
+
+    for var_name, data in de_data_dict.items():
+        attrs = attr_mgr.get_variable_attributes(
+            f"hi_de_{var_name}", check_schema=False
+        ).copy()
+        dtype = attrs.pop("dtype")
+        dataset[var_name] = xr.DataArray(
+            np.array(data, dtype=np.dtype(dtype)),
+            dims=attrs["DEPEND_0"],
+            attrs=attrs,
+        )
+
+    return dataset
+
+
+def parse_direct_events(de_data: bytes) -> dict[str, npt.ArrayLike]:
+    """
+    Parse event data from a binary blob.
+
+    IMAP-Hi direct event data information is stored in
+    48-bits as follows:
+
+    |        Read 48-bits into 16, 2, 10, 10, 10, bits. Each of these breaks
+    |        down as:
+    |
+    |            de_tag - 16 bits
+    |            start_bitmask_data - 2 bits (tA=1, tB=2, tC1=3)
+    |            tof_1 - 10 bit counter
+    |            tof_2 - 10 bit counter
+    |            tof_3 - 10 bit counter
+
+    There are at most total of 664 of 48-bits in each data packet.
+    This data packet is of variable length. If there is one event, then
+    DE_TOF will contain 48-bits. If there are 664 events, then
+    DE_TOF will contain 664 x 48-bits. If there is no event, then
+    DE_TOF will contain 0-bits.
+
+    There should be two data packets per ESA. Each packet contains meta-event
+    data that is identical between the two packets for a common ESA.
+    If there is no event record for certain ESA step, then both packets will
+    contain 0-bits in DE_TOF.
+
+    Parameters
+    ----------
+    de_data : bytes
+        Binary blob from de_tag field of SCI_DE packet. Must be an integer
+        multiple of 48-bits of data.
+
+    Returns
+    -------
+    Dict[str, list]
+        Parsed event data.
+    """
+    # The de_data is a binary blob with Nx6 bytes of data where N = number of
+    # direct events encoded into the binary blob. Interpreting the data as
+    # big-endian uint16 data and reshaping into a (3, -1) ndarray results
+    # in an array with shape (3, N). Indexing the first axis of that array
+    # (e.g. data_uint16[i]) gives the ith 2-bytes of data for each of the N
+    # direct events.
+    # Considering the 6-bytes of data for each DE as 3 2-byte words,
+    # each word contains the following:
+    # word_0: full 16-bits is the de_tag
+    # word_1: 2-bits of Trigger ID, 10-bits tof_1, upper 4-bits of tof_2
+    # word_2: lower 6-bits of tof_2, 10-bits of tof_3
+    data_uint16 = np.reshape(
+        np.frombuffer(de_data, dtype=">u2"), (3, -1), order="F"
+    ).astype(np.uint16)
+
+    de_dict = dict()
+    de_dict["de_tag"] = data_uint16[0]
+    de_dict["trigger_id"] = (data_uint16[1] >> 14).astype(np.uint8)
+    de_dict["tof_1"] = (data_uint16[1] & int(b"00111111_11110000", 2)) >> 4
+    de_dict["tof_2"] = ((data_uint16[1] & int(b"00000000_00001111", 2)) << 6) + (
+        data_uint16[2] >> 10
+    )
+    de_dict["tof_3"] = data_uint16[2] & int(b"00000011_11111111", 2)
+
+    return de_dict
+
+
+def finish_hist_dataset(input_ds: xr.Dataset) -> xr.Dataset:
+    """
+    Create dataset for a number of Hi Histogram packets.
+
+    Parameters
+    ----------
+    input_ds : xarray.Dataset
+        Dataset of packets generated using the
+        `imap_processing.utils.packet_file_to_datasets` function.
+
+    Returns
+    -------
+    dataset : xarray.Dataset
+        Dataset with all metadata field data in xr.DataArray.
+    """
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs(instrument="hi")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
+
+    # Rename shcoarse variable (do this first since it copies the input_ds)
+    dataset = input_ds.rename_vars({"shcoarse": "ccsds_met"})
+
+    dataset.epoch.attrs.update(
+        attr_mgr.get_variable_attributes("epoch"),
+    )
+    # Add the hist_angle coordinate
+    # Histogram data is binned in 90, 4-degree bins
+    attrs = attr_mgr.get_variable_attributes("hi_hist_angle")
+    dataset.coords.update(
+        {
+            "angle": xr.DataArray(
+                np.arange(2, 360, 4),
+                name="angle",
+                dims=["angle"],
+                attrs=attrs,
+            )
+        }
+    )
+    # Update existing variable attributes
+    for var_name in [
+        "version",
+        "type",
+        "sec_hdr_flg",
+        "pkt_apid",
+        "seq_flgs",
+        "src_seq_ctr",
+        "pkt_len",
+        "ccsds_met",
+        "esa_step",
+        "num_of_spins",
+        "cksum",
+    ]:
+        attrs = attr_mgr.get_variable_attributes(f"hi_hist_{var_name}")
+        dataset.data_vars[var_name].attrs.update(attrs)
+
+    new_vars = dict()
+    # Populate 90-element histogram counters
+    default_counter_attrs = attr_mgr.get_variable_attributes("hi_hist_counters")
+    for counter_name in (*QUALIFIED_COUNTERS, *LONG_COUNTERS, *TOTAL_COUNTERS):
+        # Inject counter name into generic counter attributes
+        counter_attrs = default_counter_attrs.copy()
+        for key, val in counter_attrs.items():
+            if isinstance(val, str) and "{counter_name}" in val:
+                counter_attrs[key] = val.format(counter_name=counter_name)
+        # Instantiate the counter DataArray
+        new_vars[counter_name] = xr.DataArray(
+            data=unpack_hist_counter(input_ds[counter_name].data.sum()),
+            dims=["epoch", "angle"],
+            attrs=counter_attrs,
+        )
+
+    # Generate label variable for angle coordinate
+    new_vars["angle_label"] = xr.DataArray(
+        dataset.coords["angle"].values.astype(str),
+        name="angle_label",
+        dims=["angle"],
+        attrs=attr_mgr.get_variable_attributes(
+            "hi_hist_angle_label", check_schema=False
+        ),
+    )
+
+    dataset.update(new_vars)
+
+    return dataset
+
+
+def unpack_hist_counter(counter_bytes: bytes) -> NDArray[np.uint16]:
+    """
+    Unpack Hi SCI_CNT counter data for a single counter.
+
+    Parameters
+    ----------
+    counter_bytes : bytes
+        Sum individual bytes for all epochs of a Hi SCI_CNT counter.
+
+    Returns
+    -------
+    output_array : numpy.ndarray[numpy.uint16]
+        The unpacked 12-bit unsigned integers for the input bytes. The
+        output array has a shape of (n, 90) where n is the number of SCI_CNT
+        packets in the input dataset.
+    """
+    # Interpret bytes for all epochs of current counter as uint8 array
+    counter_uint8 = np.frombuffer(counter_bytes, dtype=np.uint8)
+    # Split into triplets of upper-byte, split-byte and lower-byte arrays
+    upper_uint8, split_unit8, lower_uint8 = np.reshape(
+        counter_uint8, (3, -1), order="F"
+    ).astype(np.uint16)
+    # Compute even indexed uint12 values from upper-byte and first 4-bits of
+    # split-byte
+    even_uint12 = (upper_uint8 << 4) + (split_unit8 >> 4)
+    # Compute odd indexed uint12 values from lower 4-bits of split-byte and
+    # lower-byte
+    odd_uint12 = ((split_unit8 & (2**4 - 1)) << 8) + lower_uint8
+    output_array = np.column_stack((even_uint12, odd_uint12)).reshape(-1, 90)
+    return output_array

imap_processing/hi/{l1b/hi_l1b.py → hi_l1b.py}

@@ -11,7 +11,7 @@ import xarray as xr
 from imap_processing import imap_module_directory
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.cdf.utils import parse_filename_like
-from imap_processing.hi.l1a.science_direct_event import HALF_CLOCK_TICK_S
+from imap_processing.hi.hi_l1a import HALF_CLOCK_TICK_S
 from imap_processing.hi.utils import (
     HIAPID,
     CoincidenceBitmap,

imap_processing/hi/{l1c/hi_l1c.py → hi_l1c.py}

@@ -14,7 +14,7 @@ from numpy._typing import NDArray
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.cdf.utils import parse_filename_like
-from imap_processing.hi.l1a.science_direct_event import (
+from imap_processing.hi.hi_l1a import (
     DE_CLOCK_TICK_S,
     HALF_CLOCK_TICK_S,
 )
@@ -57,7 +57,7 @@ def hi_l1c(
     ----------
     de_dataset : xarray.Dataset
         IMAP-Hi l1b de product.
-    calibration_prod_config_path : Path
+    calibration_prod_config_path : pathlib.Path
         Calibration product configuration file.
 
     Returns
@@ -84,7 +84,7 @@ def generate_pset_dataset(
     ----------
     de_dataset : xarray.Dataset
         IMAP-Hi l1b de product.
-    calibration_prod_config_path : Path
+    calibration_prod_config_path : pathlib.Path
         Calibration product configuration file.
 
     Returns
@@ -306,16 +306,16 @@ def pset_counts(
 
     Parameters
     ----------
-    pset_coords : dict[str, xr.DataArray]
-        The PSET coordinates from the xr.Dataset.
-    config_df : pd.DataFrame
+    pset_coords : dict[str, xarray.DataArray]
+        The PSET coordinates from the xarray.Dataset.
+    config_df : pandas.DataFrame
         The calibration product configuration dataframe.
-    l1b_de_dataset : xr.Dataset
+    l1b_de_dataset : xarray.Dataset
         The L1B dataset for the pointing being processed.
 
     Returns
     -------
-    dict[str, xr.DataArray]
+    dict[str, xarray.DataArray]
         Dictionary containing new exposure_times DataArray to be added to the PSET
         dataset.
     """
@@ -396,10 +396,10 @@ def get_tof_window_mask(
 
     Parameters
     ----------
-    de_df : pd.DataFrame
+    de_df : pandas.DataFrame
         The Direct Event dataframe for the DEs to filter based on the TOF
         windows.
-    prod_config_row : namedtuple
+    prod_config_row : NamedTuple
         A single row of the prod config dataframe represented as a named tuple.
     fill_vals : dict
         A dictionary containing the fill values used in the input DE TOF
@@ -438,12 +438,12 @@ def pset_backgrounds(pset_coords: dict[str, xr.DataArray]) -> dict[str, xr.DataA
 
     Parameters
     ----------
-    pset_coords : dict[str, xr.DataArray]
-        The PSET coordinates from the xr.Dataset.
+    pset_coords : dict[str, xarray.DataArray]
+        The PSET coordinates from the xarray.Dataset.
 
     Returns
     -------
-    dict[str, xr.DataArray]
+    dict[str, xarray.DataArray]
         Dictionary containing background_rates and background_rates_unc DataArrays
         to be added to the PSET dataset.
     """
@@ -475,14 +475,14 @@ def pset_exposure(
 
     Parameters
     ----------
-    pset_coords : dict[str, xr.DataArray]
-        The PSET coordinates from the xr.Dataset.
-    l1b_de_dataset : xr.Dataset
+    pset_coords : dict[str, xarray.DataArray]
+        The PSET coordinates from the xarray.Dataset.
+    l1b_de_dataset : xarray.Dataset
         The L1B dataset for the pointing being processed.
 
     Returns
     -------
-    dict[str, xr.DataArray]
+    dict[str, xarray.DataArray]
         Dictionary containing new exposure_times DataArray to be added to the PSET
         dataset.
     """
@@ -552,12 +552,12 @@ def find_second_de_packet_data(l1b_dataset: xr.Dataset) -> xr.Dataset:
 
     Parameters
     ----------
-    l1b_dataset : xr.Dataset
+    l1b_dataset : xarray.Dataset
         The L1B Direct Event Dataset for the current pointing.
 
     Returns
     -------
-    reduced_dataset : xr.Dataset
+    reduced_dataset : xarray.Dataset
         A dataset containing only the entries for the second packet at an ESA step.
     """
     epoch_dataset = l1b_dataset.drop_dims("event_met")
@@ -606,7 +606,7 @@ def get_de_clock_ticks_for_esa_step(
     ----------
     ccsds_met : float
         The CCSDS MET of the second packet in a DE packet pair.
-    spin_df : pd.DataFrame
+    spin_df : pandas.DataFrame
         Universal spin table dataframe.
 
     Returns
@@ -760,7 +760,7 @@ class CalibrationProductConfig:
 
         Parameters
         ----------
-        path : Path
+        path : pathlib.Path
             Location of the Calibration Product configuration CSV file.
 
         Returns

imap_processing/hi/{l2/hi_l2.py → hi_l2.py}

@@ -27,11 +27,11 @@ def hi_l2(
 
     Parameters
     ----------
-    psets : list of str or Path
+    psets : list of str or pathlib.Path
         List of input PSETs to make a map from.
-    geometric_factors_path : str or Path
+    geometric_factors_path : str or pathlib.Path
         Where to get the geometric factors from.
-    esa_energies_path : str or Path
+    esa_energies_path : str or pathlib.Path
         Where to get the energies from.
     descriptor : str
         Output filename descriptor. Contains full configuration for the options
@@ -39,7 +39,7 @@ def hi_l2(
 
     Returns
     -------
-    l2_dataset : list[xr.Dataset]
+    l2_dataset : list[xarray.Dataset]
         Level 2 IMAP-Hi dataset ready to be written to a CDF file.
     """
     # TODO: parse descriptor to determine map configuration
@@ -77,19 +77,19 @@ def generate_hi_map(
 
     Parameters
     ----------
-    psets : list of str or Path
+    psets : list of str or pathlib.Path
         List of input PSETs to make a map from.
-    geometric_factors_path : str or Path
+    geometric_factors_path : str or pathlib.Path
         Where to get the geometric factors from.
-    esa_energies_path : str or Path
+    esa_energies_path : str or pathlib.Path
         Where to get the energies from.
-    cg_corrected : bool, optional
+    cg_corrected : bool, Optional
         Whether to apply Compton-Getting correction to the energies. Defaults to
         False.
-    direction : str, optional
+    direction : str, Optional
         Apply filtering to PSET data include ram or anti-ram or full spin data.
         Defaults to "full".
-    map_spacing : int, optional
+    map_spacing : int, Optional
         Pixel spacing, in degrees, of the output map in degrees. Defaults to 4.
 
     Returns
@@ -209,11 +209,11 @@ def calculate_ena_intensity(
 
     Parameters
     ----------
-    map_ds : xr.Dataset
+    map_ds : xarray.Dataset
         Map dataset that has ena_signal_rate fields calculated.
-    geometric_factors_path : str or Path
+    geometric_factors_path : str or pathlib.Path
         Where to get the geometric factors from.
-    esa_energies_path : str or Path
+    esa_energies_path : str or pathlib.Path
         Where to get the energies from.
 
     Returns

imap_processing/hi/utils.py

@@ -64,9 +64,10 @@ class HiConstants:
     TOF3_TICK_DUR = 0.5  # 0.5 ns
 
     # These values are stored in the TOF telemetry when the TOF timer
-    # does not have valid data.
-    TOF1_BAD_VALUES = (511, 1023)
-    TOF2_BAD_VALUES = (1023,)
+    # does not have valid data. See IMAP-Hi Algorithm Document Section
+    # 2.2.5 Annotated Direct Events
+    TOF1_BAD_VALUES = (511,)
+    TOF2_BAD_VALUES = (511,)
     TOF3_BAD_VALUES = (1023,)
 
 
@@ -116,15 +117,15 @@ def full_dataarray(
         Variable name.
     attrs : dict
         CDF variable attributes. Usually retrieved from ImapCdfAttributes.
-    coords : dict, optional
+    coords : dict, Optional
         Coordinate variables for the Dataset. This function will extract the
         sizes of each dimension defined by the attributes dictionary to determine
         the size of the DataArray to be created.
-    shape : int or tuple, optional
+    shape : int or tuple, Optional
         Shape of ndarray data array to instantiate in the xarray.DataArray. If
         shape is provided, the DataArray created will have this shape regardless
         of whether coordinates are provided or not.
-    fill_value : optional, float
+    fill_value : Optional, float
         Override the fill value that the DataArray will be filled with. If not
         supplied, the "FILLVAL" value from `attrs` will be used.
 
@@ -171,15 +172,15 @@ def create_dataset_variables(
     ----------
     variable_names : list[str]
         List of variable names to create.
-    variable_shape : int or sequence of int, optional
+    variable_shape : int or Sequence of int, Optional
         Shape of the new variables data ndarray. If not provided the shape will
         attempt to be derived from the coords dictionary.
-    coords : dict, optional
+    coords : dict, Optional
         Coordinate variables for the Dataset. If `variable_shape` is not provided
         the dataset variables created will use this dictionary along with variable
         attributes from the CdfAttributeManager to determine the shapes of the
         dataset variables created.
-    fill_value : optional, number
+    fill_value : Optional, float
         Value to fill the new variables data arrays with. If not supplied,
         the fill value is pulled from the CDF variable attributes "FILLVAL"
         attribute.