imap-processing 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

imap_processing/tests/codice/test_codice_l1a.py

@@ -1,7 +1,6 @@
 """Tests the L1a processing for decommutated CoDICE data"""
 
 import logging
-from pathlib import Path
 
 import numpy as np
 import pytest
@@ -10,139 +9,172 @@ import xarray as xr
 from imap_processing.cdf.utils import load_cdf, write_cdf
 from imap_processing.codice.codice_l1a import process_codice_l1a
 
-from .conftest import TEST_PACKETS, VALIDATION_DATA
+from .conftest import TEST_L0_FILE, VALIDATION_DATA
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
-# TODO: Add test that processes a file with multiple APIDs
-
 EXPECTED_ARRAY_SHAPES = [
-    (99,),  # hskp
-    (1, 1, 6, 1),  # hi-counters-aggregated  # TODO: Double check with Joey
-    (1, 1, 16, 1),  # hi-counters-singles  # TODO: Double check with Joey
-    (1, 15, 4, 1),  # hi-omni  # TODO: Double check with Joey
-    (1, 8, 12, 12),  # hi-sectored
-    (1, 1),  # hi-pha
-    (1, 6, 6, 128),  # lo-counters-aggregated
-    (1, 24, 6, 128),  # lo-counters-singles
-    (1, 5, 12, 128),  # lo-sw-angular
-    (1, 19, 12, 128),  # lo-nsw-angular
-    (1, 1, 12, 128),  # lo-sw-priority
-    (1, 1, 12, 128),  # lo-nsw-priority
-    (1, 1, 1, 128),  # lo-sw-species
-    (1, 1, 1, 128),  # lo-nsw-species
-    (1, 128),  # lo-pha
+    (),  # hi-ialirt  # TODO: Need to implement
+    (),  # lo-ialirt  # TODO: Need to implement
+    (31778,),  # hskp
+    (77, 128, 6, 6),  # lo-counters-aggregated
+    (77, 128, 24, 6),  # lo-counters-singles
+    (77, 128, 1, 12),  # lo-sw-priority
+    (77, 128, 1, 12),  # lo-nsw-priority
+    (77, 128, 1, 1),  # lo-sw-species
+    (77, 128, 1, 1),  # lo-nsw-species
+    (77, 128, 5, 12),  # lo-sw-angular
+    (77, 128, 19, 12),  # lo-nsw-angular
+    (77, 1, 6, 1),  # hi-counters-aggregated
+    (77, 1, 12, 1),  # hi-counters-singles
+    (77, 15, 4, 1),  # hi-omni
+    (77, 8, 12, 12),  # hi-sectored
+    (),  # hi-priority  # TODO: Need to implement
+    (),  # lo-pha  # TODO: Need to implement
+    (),  # hi-pha  # TODO: Need to implement
 ]
-EXPECTED_LOGICAL_SOURCE = [
+
+EXPECTED_LOGICAL_SOURCES = [
+    "imap_codice_l1a_hi-ialirt",
+    "imap_codice_l1a_lo-ialirt",
     "imap_codice_l1a_hskp",
-    "imap_codice_l1a_hi-counters-aggregated",
-    "imap_codice_l1a_hi-counters-singles",
-    "imap_codice_l1a_hi-omni",
-    "imap_codice_l1a_hi-sectored",
-    "imap_codice_l1a_hi-pha",
     "imap_codice_l1a_lo-counters-aggregated",
     "imap_codice_l1a_lo-counters-singles",
-    "imap_codice_l1a_lo-sw-angular",
-    "imap_codice_l1a_lo-nsw-angular",
     "imap_codice_l1a_lo-sw-priority",
     "imap_codice_l1a_lo-nsw-priority",
     "imap_codice_l1a_lo-sw-species",
     "imap_codice_l1a_lo-nsw-species",
+    "imap_codice_l1a_lo-sw-angular",
+    "imap_codice_l1a_lo-nsw-angular",
+    "imap_codice_l1a_hi-counters-aggregated",
+    "imap_codice_l1a_hi-counters-singles",
+    "imap_codice_l1a_hi-omni",
+    "imap_codice_l1a_hi-sectored",
+    "imap_codice_l1a_hi-priority",
     "imap_codice_l1a_lo-pha",
+    "imap_codice_l1a_hi-pha",
 ]
+
 EXPECTED_NUM_VARIABLES = [
-    129,  # hskp
-    1,  # hi-counters-aggregated
-    3,  # hi-counters-singles
-    8,  # hi-omni
-    4,  # hi-sectored
-    0,  # hi-pha
+    0,  # hi-ialirt  # TODO: Need to implement
+    0,  # lo-ialirt  # TODO: Need to implement
+    148,  # hskp
     3,  # lo-counters-aggregated
     3,  # lo-counters-singles
-    6,  # lo-sw-angular
-    3,  # lo-nsw-angular
     7,  # lo-sw-priority
     4,  # lo-nsw-priority
     18,  # lo-sw-species
     10,  # lo-nsw-species
-    0,  # lo-pha
+    6,  # lo-sw-angular
+    3,  # lo-nsw-angular
+    1,  # hi-counters-aggregated
+    3,  # hi-counters-singles
+    8,  # hi-omni
+    4,  # hi-sectored
+    0,  # hi-priority  # TODO: Need to implement
+    0,  # lo-pha  # TODO: Need to implement
+    0,  # hi-pha  # TODO: Need to implement
 ]
 
 
-@pytest.fixture(params=TEST_PACKETS)
-def test_l1a_data(request) -> xr.Dataset:
+@pytest.fixture(scope="session")
+def test_l1a_data() -> xr.Dataset:
     """Return a ``xarray`` dataset containing test data.
 
     Returns
     -------
-    dataset : xarray.Dataset
-        A ``xarray`` dataset containing the test data
+    processed_datasets : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
     """
 
-    dataset = process_codice_l1a(file_path=request.param, data_version="001")
+    processed_datasets = process_codice_l1a(file_path=TEST_L0_FILE, data_version="001")
+
+    return processed_datasets
+
+
+@pytest.mark.parametrize("index", range(len(EXPECTED_ARRAY_SHAPES)))
+def test_l1a_data_array_shape(test_l1a_data, index):
+    """Tests that the data arrays in the generated CDFs have the expected shape.
+
+    Parameters
+    ----------
+    test_l1a_data : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
+    index : int
+        The index of the list to test
+    """
+
+    processed_dataset = test_l1a_data[index]
+    expected_shape = EXPECTED_ARRAY_SHAPES[index]
+
+    # Mark currently broken/unsupported datasets as expected to fail
+    # TODO: Remove these once they are supported
+    if index in [0, 1, 15, 16, 17]:
+        pytest.xfail("Data product is currently unsupported")
 
-    # Write the dataset to a CDF so it can be manually inspected as well
-    file_path = write_cdf(dataset)
-    logger.info(f"CDF file written to {file_path}")
+    for variable in processed_dataset:
+        if variable in ["energy_table", "acquisition_time_per_step"]:
+            assert processed_dataset[variable].data.shape == (128,)
+        else:
+            assert processed_dataset[variable].data.shape == expected_shape
 
-    return dataset
 
+@pytest.mark.parametrize("index", range(len(EXPECTED_LOGICAL_SOURCES)))
+def test_l1a_logical_sources(test_l1a_data, index):
+    """Tests that the Logical source of the dataset is what is expected.
 
-@pytest.mark.xfail(reason="Epoch variable data needs to monotonically increase")
-@pytest.mark.parametrize(
-    "test_l1a_data, expected_logical_source",
-    list(zip(TEST_PACKETS, EXPECTED_LOGICAL_SOURCE)),
-    indirect=["test_l1a_data"],
-)
-def test_l1a_cdf_filenames(test_l1a_data: xr.Dataset, expected_logical_source: str):
-    """Tests that the ``process_codice_l1a`` function generates datasets
-    with the expected logical source.
+    Since the logical source gets set by ``write_cdf``, this also tests that
+    the dataset can be written to a file.
 
     Parameters
     ----------
-    test_l1a_data : xarray.Dataset
-        A ``xarray`` dataset containing the test data
-    expected_logical_source : str
-        The expected CDF filename
+    test_l1a_data : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
+    index : int
+        The index of the list to test
     """
 
-    dataset = test_l1a_data
-    assert dataset.attrs["Logical_source"] == expected_logical_source
+    processed_dataset = test_l1a_data[index]
+    expected_logical_source = EXPECTED_LOGICAL_SOURCES[index]
 
+    # Mark currently broken/unsupported datasets as expected to fail
+    # TODO: Remove these once they are supported
+    if index in [0, 1, 2, 15, 16, 17]:
+        pytest.xfail("Data product is currently unsupported")
 
-@pytest.mark.xfail(reason="Epoch variable data needs to monotonically increase")
-@pytest.mark.parametrize(
-    "test_l1a_data, expected_shape",
-    list(zip(TEST_PACKETS, EXPECTED_ARRAY_SHAPES)),
-    indirect=["test_l1a_data"],
-)
-def test_l1a_data_array_shape(test_l1a_data: xr.Dataset, expected_shape: tuple):
-    """Tests that the data arrays in the generated CDFs have the expected shape.
+    # Write the dataset to a file to set the logical source attribute
+    _ = write_cdf(processed_dataset)
+
+    assert processed_dataset.attrs["Logical_source"] == expected_logical_source
+
+
+@pytest.mark.parametrize("index", range(len(EXPECTED_NUM_VARIABLES)))
+def test_l1a_num_variables(test_l1a_data, index):
+    """Tests that the data arrays in the generated CDFs have the expected number
+    of variables.
 
     Parameters
     ----------
-    test_l1a_data : xarray.Dataset
-        A ``xarray`` dataset containing the test data
-    expected_shape : tuple
-        The expected shape of the data array
+    test_l1a_data : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
+    index : int
+        The index of the list to test
     """
 
-    dataset = test_l1a_data
-    for variable in dataset:
-        if variable in ["energy_table", "acquisition_time_per_step"]:
-            assert dataset[variable].data.shape == (128,)
-        else:
-            assert dataset[variable].data.shape == expected_shape
+    processed_dataset = test_l1a_data[index]
+
+    # Mark currently broken/unsupported datasets as expected to fail
+    # TODO: Remove these once they are supported
+    if index in [0, 1, 15, 16, 17]:
+        pytest.xfail("Data product is currently unsupported")
+
+    assert len(processed_dataset) == EXPECTED_NUM_VARIABLES[index]
 
 
 @pytest.mark.skip("Awaiting validation data")
-@pytest.mark.parametrize(
-    "test_l1a_data, validation_data",
-    list(zip(TEST_PACKETS, VALIDATION_DATA)),
-    indirect=["test_l1a_data"],
-)
-def test_l1a_data_array_values(test_l1a_data: xr.Dataset, validation_data: Path):
+@pytest.mark.parametrize("index", range(len(VALIDATION_DATA)))
+def test_l1a_data_array_values(test_l1a_data: xr.Dataset, index):
     """Tests that the generated L1a CDF contents are valid.
 
     Once proper validation files are acquired, this test function should point
@@ -151,40 +183,28 @@ def test_l1a_data_array_values(test_l1a_data: xr.Dataset, validation_data: Path)
 
     Parameters
     ----------
-    test_l1a_data : xarray.Dataset
-        A ``xarray`` dataset containing the test data
-    validataion_data : pathlib.Path
-        The path to the file containing the validation data
+    test_l1a_data : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
+    index : int
+        The index of the list to test
     """
 
     generated_dataset = test_l1a_data
-    validation_dataset = load_cdf(validation_data)
+    validation_dataset = load_cdf(VALIDATION_DATA[index])
 
     # Ensure the processed data matches the validation data
     for variable in validation_dataset:
         assert variable in generated_dataset
         if variable != "epoch":
             np.testing.assert_array_equal(
-                validation_data[variable].data, generated_dataset[variable].data[0]
+                validation_dataset[variable].data, generated_dataset[variable].data[0]
             )
 
 
-@pytest.mark.xfail(reason="Epoch variable data needs to monotonically increase")
-@pytest.mark.parametrize(
-    "test_l1a_data, expected_num_variables",
-    list(zip(TEST_PACKETS, EXPECTED_NUM_VARIABLES)),
-    indirect=["test_l1a_data"],
-)
-def test_l1a_num_variables(test_l1a_data: xr.Dataset, expected_num_variables: int):
-    """Tests that the data arrays in the generated CDFs have the expected size.
+def test_l1a_multiple_packets():
+    """Tests that an input L0 file containing multiple APIDs can be processed."""
 
-    Parameters
-    ----------
-    test_l1a_data : xarray.Dataset
-        A ``xarray`` dataset containing the test data
-    expected_num_variables : int
-        The expected number of data variables in the CDF
-    """
+    processed_datasets = process_codice_l1a(file_path=TEST_L0_FILE, data_version="001")
 
-    dataset = test_l1a_data
-    assert len(dataset) == expected_num_variables
+    # TODO: Could add some more checks here?
+    assert len(processed_datasets) == 18

imap_processing/tests/codice/test_codice_l1b.py

@@ -39,6 +39,7 @@ def test_l1b_data(request) -> xr.Dataset:
     return dataset
 
 
+@pytest.mark.skip("Awaiting proper implementation of L1B")
 @pytest.mark.parametrize(
     "test_l1b_data, expected_logical_source",
     list(zip(TEST_L1A_FILES, EXPECTED_LOGICAL_SOURCE)),

imap_processing/tests/codice/test_decompress.py

@@ -10,14 +10,14 @@ from imap_processing.codice.utils import CoDICECompression
 
 # Test the algorithms using input value of 234 (picked randomly)
 lzma_bytes = lzma.compress((234).to_bytes(1, byteorder="big"))
-LZMA_EXAMPLE = "".join(format(byte, "08b") for byte in lzma_bytes)
+# LZMA_EXAMPLE = "".join(format(byte, "08b") for byte in lzma_bytes)
 TEST_DATA = [
-    ("11101010", CoDICECompression.NO_COMPRESSION, [234]),
-    ("11101010", CoDICECompression.LOSSY_A, [221184]),
-    ("11101010", CoDICECompression.LOSSY_B, [1441792]),
-    (LZMA_EXAMPLE, CoDICECompression.LOSSLESS, [234]),
-    (LZMA_EXAMPLE, CoDICECompression.LOSSY_A_LOSSLESS, [221184]),
-    (LZMA_EXAMPLE, CoDICECompression.LOSSY_B_LOSSLESS, [1441792]),
+    (b"\xea", CoDICECompression.NO_COMPRESSION, [234]),
+    (b"\xea", CoDICECompression.LOSSY_A, [212992]),
+    (b"\xea", CoDICECompression.LOSSY_B, [1310720]),
+    (lzma_bytes, CoDICECompression.LOSSLESS, [234]),
+    (lzma_bytes, CoDICECompression.LOSSY_A_LOSSLESS, [212992]),
+    (lzma_bytes, CoDICECompression.LOSSY_B_LOSSLESS, [1310720]),
 ]
 
 

imap_processing/tests/conftest.py

@@ -46,45 +46,48 @@ def _autoclear_spice():
 
 
 @pytest.fixture(scope="session")
-def _download_de440s(spice_test_data_path):
-    """This fixture downloads the de440s.bsp kernel into the
-    tests/spice/test_data directory if it does not already exist there. The
+def _download_external_kernels(spice_test_data_path):
+    """This fixture downloads the de440s.bsp and pck00011.tpc kernels into the
+    tests/spice/test_data directory if they do not already exist there. The
     fixture is not intended to be used directly. It is automatically added to
     tests marked with "external_kernel" in the hook below."""
     logger = logging.getLogger(__name__)
-    kernel_url = (
-        "https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/de440s.bsp"
-    )
-    kernel_name = kernel_url.split("/")[-1]
-    local_filepath = spice_test_data_path / kernel_name
-
-    if local_filepath.exists():
-        return
-    allowed_attempts = 3
-    for attempt_number in range(allowed_attempts):
-        try:
-            with requests.get(kernel_url, stream=True, timeout=30) as r:
-                r.raise_for_status()
-                with open(local_filepath, "wb") as f:
-                    for chunk in r.iter_content(chunk_size=8192):
-                        f.write(chunk)
-            logger.info("Cached kernel file to %s", local_filepath)
-            break
-        except requests.exceptions.RequestException as error:
-            logger.info(f"Request failed. {error}")
-            if attempt_number < allowed_attempts:
-                logger.info(
-                    f"Trying again, retries left "
-                    f"{allowed_attempts - attempt_number}, "
-                    f"Exception: {error}"
-                )
-                time.sleep(1)
-            else:
-                logger.error(
-                    f"Failed to download file after {allowed_attempts} "
-                    f"attempts, Final Error: {error}"
-                )
-                raise
+    kernel_urls = [
+        "https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/de440s.bsp",
+        "https://naif.jpl.nasa.gov/pub/naif/generic_kernels/pck/pck00011.tpc",
+    ]
+
+    for kernel_url in kernel_urls:
+        kernel_name = kernel_url.split("/")[-1]
+        local_filepath = spice_test_data_path / kernel_name
+
+        if local_filepath.exists():
+            continue
+        allowed_attempts = 3
+        for attempt_number in range(allowed_attempts):
+            try:
+                with requests.get(kernel_url, stream=True, timeout=30) as r:
+                    r.raise_for_status()
+                    with open(local_filepath, "wb") as f:
+                        for chunk in r.iter_content(chunk_size=8192):
+                            f.write(chunk)
+                logger.info("Cached kernel file to %s", local_filepath)
+                continue
+            except requests.exceptions.RequestException as error:
+                logger.info(f"Request failed. {error}")
+                if attempt_number < allowed_attempts:
+                    logger.info(
+                        f"Trying again, retries left "
+                        f"{allowed_attempts - attempt_number}, "
+                        f"Exception: {error}"
+                    )
+                    time.sleep(1)
+                else:
+                    logger.error(
+                        f"Failed to download file {kernel_name} after "
+                        f"{allowed_attempts} attempts, Final Error: {error}"
+                    )
+                    raise
 
 
 def pytest_collection_modifyitems(items):
@@ -93,12 +96,12 @@ def pytest_collection_modifyitems(items):
     been collected. In this case, it automatically adds fixtures based on the
     following table:
 
-    +---------------------+---------------------+
-    | pytest mark         | fixture added       |
-    +=====================+=====================+
-    | external_kernel     | _download_de440s    |
-    | use_test_metakernel | use_test_metakernel |
-    +---------------------+---------------------+
+    +---------------------+----------------------------+
+    | pytest mark         | fixture added              |
+    +=====================+============================+
+    | external_kernel     | _download_external_kernels |
+    | use_test_metakernel | use_test_metakernel        |
+    +---------------------+----------------------------+
 
     Notes
     -----
@@ -108,7 +111,7 @@ def pytest_collection_modifyitems(items):
     """
     for item in items:
         if item.get_closest_marker("external_kernel") is not None:
-            item.fixturenames.append("_download_de440s")
+            item.fixturenames.append("_download_external_kernels")
         if item.get_closest_marker("use_test_metakernel") is not None:
             item.fixturenames.append("use_test_metakernel")
 
@@ -297,19 +300,55 @@ def _unset_metakernel_path(monkeypatch):
 
 
 @pytest.fixture()
-def _set_spin_data_filepath(monkeypatch, tmpdir, generate_spin_data):
-    """Set the SPIN_DATA_FILEPATH environment variable"""
-    # SWE test data time minus 56120 seconds to get mid-night time
-    start_time = 453051323.0 - 56120
-    spin_df = generate_spin_data(start_time)
-    spin_csv_file_path = tmpdir / "spin_data.spin.csv"
-    spin_df.to_csv(spin_csv_file_path, index=False)
-    monkeypatch.setenv("SPIN_DATA_FILEPATH", str(spin_csv_file_path))
+def use_test_spin_data_csv(monkeypatch):
+    """Sets the SPIN_DATA_FILEPATH environment variable to input path."""
+
+    def wrapped_set_spin_data_filepath(path: Path):
+        monkeypatch.setenv("SPIN_DATA_FILEPATH", str(path))
+
+    return wrapped_set_spin_data_filepath
+
+
+@pytest.fixture()
+def use_fake_spin_data_for_time(
+    request, use_test_spin_data_csv, tmpdir, generate_spin_data
+):
+    """
+    Generate and use fake spin data for testing.
+
+    Returns
+    -------
+    callable
+        Returns a callable function that takes start_met and optionally end_met
+        as inputs, generates fake spin data, writes the data to a csv file,
+        and sets the SPIN_DATA_FILEPATH environment variable to point to the
+        fake spin data file.
+    """
+
+    def wrapped_set_spin_data_filepath(
+        start_met: float, end_met: Optional[int] = None
+    ) -> pd.DataFrame:
+        """
+        Generate and use fake spin data for testing.
+        Parameters
+        ----------
+        start_met : int
+            Provides the start time in Mission Elapsed Time (MET).
+        end_met : int
+            Provides the end time in MET. If not provided, default to one day
+            from start time.
+        """
+        spin_df = generate_spin_data(start_met, end_met=end_met)
+        spin_csv_file_path = tmpdir / "spin_data.spin.csv"
+        spin_df.to_csv(spin_csv_file_path, index=False)
+        use_test_spin_data_csv(spin_csv_file_path)
+
+    return wrapped_set_spin_data_filepath
 
 
 @pytest.fixture()
 def generate_spin_data():
-    def make_data(start_met: int, end_met: Optional[int] = None) -> pd.DataFrame:
+    def make_data(start_met: float, end_met: Optional[float] = None) -> pd.DataFrame:
         """
         Generate a spin table CSV covering one or more days.
         Spin table contains the following fields:
@@ -324,14 +363,14 @@ def generate_spin_data():
             thruster_firing
             )
         This function creates spin data using start MET and end MET time.
-        Each spin start data uses the nominal 15 second spin period. The spins that
+        Each spin start data uses the nominal 15-second spin period. The spins that
         occur from 00:00(Mid-night) to 00:10 UTC are marked with flags for
         thruster firing, invalid spin period, and invalid spin phase.
         Parameters
         ----------
-        start_met : int
+        start_met : float
             Provides the start time in Mission Elapsed Time (MET).
-        end_met : int
+        end_met : float
             Provides the end time in MET. If not provided, default to one day
             from start time.
         Returns
@@ -344,7 +383,8 @@ def generate_spin_data():
             end_met = start_met + 86400
 
         # Create spin start second data of 15 seconds increment
-        spin_start_sec = np.arange(start_met, end_met + 1, 15)
+        spin_start_sec = np.arange(np.floor(start_met), end_met + 1, 15)
+        spin_start_subsec = int((start_met - spin_start_sec[0]) * 1000)
 
         nspins = len(spin_start_sec)
 
@@ -352,7 +392,9 @@ def generate_spin_data():
             {
                 "spin_number": np.arange(nspins, dtype=np.uint32),
                 "spin_start_sec": spin_start_sec,
-                "spin_start_subsec": np.zeros(nspins, dtype=np.uint32),
+                "spin_start_subsec": np.full(
+                    nspins, spin_start_subsec, dtype=np.uint32
+                ),
                 "spin_period_sec": np.full(nspins, 15.0, dtype=np.float32),
                 "spin_period_valid": np.ones(nspins, dtype=np.uint8),
                 "spin_phase_valid": np.ones(nspins, dtype=np.uint8),
@@ -362,7 +404,7 @@ def generate_spin_data():
         )
 
         # Convert spin_start_sec to datetime to set repointing times flags
-        spin_start_dates = met_to_j2000ns(spin_start_sec)
+        spin_start_dates = met_to_j2000ns(spin_start_sec + spin_start_subsec / 1000)
         spin_start_dates = cdflib.cdfepoch.to_datetime(spin_start_dates)
 
         # Convert DatetimeIndex to Series for using .dt accessor

imap_processing/tests/glows/conftest.py

@@ -6,6 +6,7 @@ import pytest
 from imap_processing.glows.l0 import decom_glows
 from imap_processing.glows.l1a.glows_l1a import glows_l1a, process_de_l0
 from imap_processing.glows.l1a.glows_l1a_data import HistogramL1A
+from imap_processing.glows.l1b.glows_l1b import glows_l1b
 
 
 @pytest.fixture()
@@ -40,3 +41,8 @@ def l1a_test_data(decom_test_data):
 @pytest.fixture()
 def l1a_dataset(packet_path):
     return glows_l1a(packet_path, "v001")
+
+
+@pytest.fixture()
+def l1b_hist_dataset(l1a_dataset):
+    return glows_l1b(l1a_dataset[0], "v001")

imap_processing/tests/glows/test_glows_l1b.py

@@ -318,23 +318,23 @@ def test_glows_l1b(de_dataset, hist_dataset):
         "imap_spin_angle_bin_cntr",
         "histogram_flag_array",
         "filter_temperature_average",
-        "filter_temperature_variance",
+        "filter_temperature_std_dev",
         "hv_voltage_average",
-        "hv_voltage_variance",
+        "hv_voltage_std_dev",
         "spin_period_average",
-        "spin_period_variance",
+        "spin_period_std_dev",
         "pulse_length_average",
-        "pulse_length_variance",
+        "pulse_length_std_dev",
         "spin_period_ground_average",
-        "spin_period_ground_variance",
+        "spin_period_ground_std_dev",
         "position_angle_offset_average",
-        "position_angle_offset_variance",
-        "spin_axis_orientation_variance",
+        "position_angle_offset_std_dev",
+        "spin_axis_orientation_std_dev",
         "spin_axis_orientation_average",
         "spacecraft_location_average",
-        "spacecraft_location_variance",
+        "spacecraft_location_std_dev",
         "spacecraft_velocity_average",
-        "spacecraft_velocity_variance",
+        "spacecraft_velocity_std_dev",
         "flags",
     ]