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

imap_processing/tests/swe/test_swe_l2.py

@@ -6,6 +6,7 @@ import pytest
 import xarray as xr
 
 from imap_processing import imap_module_directory
+from imap_processing.cdf.utils import write_cdf
 from imap_processing.swe.l1a.swe_l1a import swe_l1a
 from imap_processing.swe.l1b.swe_l1b import swe_l1b
 from imap_processing.swe.l2.swe_l2 import (
@@ -13,7 +14,9 @@ from imap_processing.swe.l2.swe_l2 import (
     VELOCITY_CONVERSION_FACTOR,
     calculate_flux,
     calculate_phase_space_density,
+    find_angle_bin_indices,
     get_particle_energy,
+    put_data_into_angle_bins,
     swe_l2,
 )
 from imap_processing.swe.utils.swe_utils import read_lookup_table
@@ -108,18 +111,158 @@ def test_calculate_flux():
     assert type(flux) == np.ndarray
 
 
+def test_find_angle_bin_indices():
+    """Test find_angle_bin_indices function."""
+    spin_angle_bin_center = np.arange(6, 360, 12)
+
+    # List with various start, middle, end angles or
+    # far left or far right edge angles
+    start_angles = [0, 0.11, 3, 6, 11.99, 12, 355]
+    expected_angle_bin_indices = np.array([0, 0, 0, 0, 0, 1, 29])
+    angle_bin_indices = find_angle_bin_indices(start_angles)
+    np.testing.assert_array_equal(angle_bin_indices, expected_angle_bin_indices)
+    # Test that angle bin indices lands in correct center bin
+    np.testing.assert_array_equal(
+        spin_angle_bin_center[angle_bin_indices],
+        np.array([6, 6, 6, 6, 6, 18, 354]),
+    )
+
+    # Test for angles that are outside the range
+    with pytest.raises(
+        ValueError, match=r"Input angle values must be in the range \[0, 360\)"
+    ):
+        find_angle_bin_indices(np.array([-1]))
+
+    with pytest.raises(
+        ValueError, match=r"Input angle values must be in the range \[0, 360\)"
+    ):
+        find_angle_bin_indices(np.array([360]))
+
+
+def test_put_data_into_angle_bins():
+    """Test put_data_into_angle_bins function."""
+    num_cycles = 1
+    num_esa_step = 24
+    num_angle_bins = 30
+    num_cems = 7
+    # Create test counts data to test
+    # Find all even numbers in the range 0 to 30
+    even_numbers = np.arange(0, 30, 2)
+    # repeat it twice now to get:
+    # [0, 0, 2, 2, ...., 28, 28]
+    example_data = np.repeat(even_numbers, 2)
+    energy_angle_test_data = np.tile(example_data, (num_cycles, num_esa_step, 1))
+    # Expand to include 7 CEMs by repeating across last dimension
+    test_data = np.repeat(energy_angle_test_data[..., np.newaxis], num_cems, axis=-1)
+
+    # Took this example from intermediate output from actual data
+    angle_bins_example = [
+        12,
+        14,
+        14,
+        16,
+        16,
+        18,
+        18,
+        20,
+        20,
+        22,
+        22,
+        24,
+        24,
+        26,
+        26,
+        28,
+        28,
+        0,
+        0,
+        2,
+        2,
+        4,
+        4,
+        6,
+        6,
+        8,
+        8,
+        10,
+        10,
+        12,
+    ]
+    # Now data with every row to be same as angle_bins_example
+    test_angle_bin_indices_data = np.full(
+        (num_cycles, num_esa_step, num_angle_bins), angle_bins_example
+    )
+
+    binned_data = put_data_into_angle_bins(test_data, test_angle_bin_indices_data)
+    assert binned_data.shape == (num_cycles, num_esa_step, num_angle_bins, num_cems)
+
+    # Test that the binned data has correct values in correct bins by
+    # checking that odd number columns are filled with nan
+    expected_binned_data = np.full(
+        (num_cycles, num_esa_step, num_angle_bins, num_cems), np.nan
+    )
+    np.testing.assert_array_equal(
+        binned_data[0, 0, 1::2, 0], expected_binned_data[0, 0, 1::2, 0]
+    )
+
+    # Now check that mean calculation is correct
+    even_col_mean_data = binned_data[0, 0, 0::2, 0]
+    # Expected mean of even columns is below
+    expected_mean_data = np.array(
+        [
+            17.0,
+            19.0,
+            21.0,
+            23.0,
+            25.0,
+            27.0,
+            14.0,
+            1.0,
+            3.0,
+            5.0,
+            7.0,
+            9.0,
+            11.0,
+            13.0,
+            15.0,
+        ]
+    )
+    np.testing.assert_array_equal(even_col_mean_data, expected_mean_data)
+
+
+@patch(
+    "imap_processing.swe.l1b.swe_l1b_science.read_in_flight_cal_data",
+    return_value=pd.DataFrame(
+        {
+            "met_time": [453050300, 453077900],
+            "cem1": [1, 1],
+            "cem2": [1, 1],
+            "cem3": [1, 1],
+            "cem4": [1, 1],
+            "cem5": [1, 1],
+            "cem6": [1, 1],
+            "cem7": [1, 1],
+        }
+    ),
+)
 @pytest.mark.usefixtures("use_fake_spin_data_for_time")
-def test_swe_l2(use_fake_spin_data_for_time):
+def test_swe_l2(mock_read_in_flight_cal_data, use_fake_spin_data_for_time):
     """Test L2 processing."""
     data_start_time = 453051293.099714
-    data_end_time = 453066734
+    data_end_time = 453070000.0
     use_fake_spin_data_for_time(data_start_time, data_end_time)
 
     test_data_path = "tests/swe/l0_data/2024051010_SWE_SCIENCE_packet.bin"
     l1a_datasets = swe_l1a(imap_module_directory / test_data_path, "002")
 
-    l1b_dataset = swe_l1b(l1a_datasets, "002")
-    l2_dataset = swe_l2(l1b_dataset, "002")
+    l1b_dataset = swe_l1b(l1a_datasets[0], "002")
+    l2_dataset = swe_l2(l1b_dataset[0], "002")
 
     assert type(l2_dataset) == xr.Dataset
-    assert l2_dataset["spin_phase"].shape == (6, 24, 30, 7)
+    assert l2_dataset["phase_space_density_spin_sector"].shape == (6, 24, 30, 7)
+    assert l2_dataset["flux_spin_sector"].shape == (6, 24, 30, 7)
+    assert l2_dataset["acquisition_time"].shape == (6, 24, 30)
+
+    # Write L2 to CDF
+    l2_cdf_filepath = write_cdf(l2_dataset)
+    assert l2_cdf_filepath.name == "imap_swe_l2_sci_20240510_v002.cdf"

imap_processing/tests/test_cli.py

@@ -6,7 +6,7 @@ from unittest import mock
 import pytest
 import xarray as xr
 
-from imap_processing.cli import Codice, Hi, Hit, Ultra, _validate_args, main
+from imap_processing.cli import Codice, Hi, Hit, Swe, Ultra, _validate_args, main
 
 
 @pytest.fixture()
@@ -101,7 +101,9 @@ def test_codice(mock_codice_l1a, mock_instrument_dependencies):
         "'start_date': '20230822'"
         "}]"
     )
-    instrument = Codice("l1a", dependency_str, "20230822", "20230822", "v001", True)
+    instrument = Codice(
+        "l1a", "hskp", dependency_str, "20230822", "20230822", "v001", True
+    )
     instrument.process()
     assert mocks["mock_query"].call_count == 1
     assert mocks["mock_download"].call_count == 1
@@ -134,7 +136,7 @@ def test_hi_l1(mock_instrument_dependencies, data_level, n_prods):
             "}]"
         )
         instrument = Hi(
-            data_level, dependency_str, "20231212", "20231213", "v005", True
+            data_level, "sci", dependency_str, "20231212", "20231213", "v005", True
         )
         instrument.process()
         assert mocks["mock_query"].call_count == 1
@@ -161,7 +163,9 @@ def test_ultra_l1a(mock_ultra_l1a, mock_instrument_dependencies):
         "'start_date': '20240207'"
         "}]"
     )
-    instrument = Ultra("l1a", dependency_str, "20240207", "20240208", "v001", True)
+    instrument = Ultra(
+        "l1a", "raw", dependency_str, "20240207", "20240208", "v001", True
+    )
     instrument.process()
     assert mocks["mock_query"].call_count == 1
     assert mocks["mock_download"].call_count == 1
@@ -178,7 +182,7 @@ def test_ultra_l1b(mock_ultra_l1b, mock_instrument_dependencies):
     mock_ultra_l1b.return_value = ["l1b_dataset0", "l1b_dataset1"]
     mocks["mock_write_cdf"].side_effect = ["/path/to/product0", "/path/to/product1"]
 
-    instrument = Ultra("l1b", "[]", "20240207", "20240208", "v001", True)
+    instrument = Ultra("l1b", "de", "[]", "20240207", "20240208", "v001", True)
     instrument.process()
     assert mocks["mock_query"].call_count == 0
     assert mocks["mock_download"].call_count == 0
@@ -195,7 +199,7 @@ def test_ultra_l1c(mock_ultra_l1c, mock_instrument_dependencies):
     mock_ultra_l1c.return_value = ["l1c_dataset0", "l1c_dataset1"]
     mocks["mock_write_cdf"].side_effect = ["/path/to/product0", "/path/to/product1"]
 
-    instrument = Ultra("l1c", "[]", "20240207", "20240208", "v001", True)
+    instrument = Ultra("l1c", "pset", "[]", "20240207", "20240208", "v001", True)
     instrument.process()
     assert mocks["mock_query"].call_count == 0
     assert mocks["mock_download"].call_count == 0
@@ -221,9 +225,37 @@ def test_hit_l1a(mock_hit_l1a, mock_instrument_dependencies):
         "'start_date': '20100105'"
         "}]"
     )
-    instrument = Hit("l1a", dependency_str, "20100105", "20100101", "v001", True)
+    instrument = Hit("l1a", "raw", dependency_str, "20100105", "20100101", "v001", True)
     instrument.process()
     assert mocks["mock_query"].call_count == 1
     assert mocks["mock_download"].call_count == 1
     assert mock_hit_l1a.call_count == 1
     assert mocks["mock_upload"].call_count == 2
+
+
+@mock.patch("imap_processing.cli.swe_l1a")
+def test_post_processing(mock_swe_l1a, mock_instrument_dependencies):
+    """Test coverage for post processing"""
+    mocks = mock_instrument_dependencies
+    mocks["mock_query"].return_value = [{"file_path": "/path/to/file0"}]
+    mocks["mock_download"].return_value = "dependency0"
+    # Return empty list to simulate no data to write
+    mock_swe_l1a.return_value = []
+
+    dependency_str = (
+        "[{"
+        "'instrument': 'hit',"
+        "'data_level': 'l0',"
+        "'descriptor': 'raw',"
+        "'version': 'v001',"
+        "'start_date': '20100105'"
+        "}]"
+    )
+    instrument = Swe("l1a", "raw", dependency_str, "20100105", "20100101", "v001", True)
+
+    # This function calls both the instrument.do_processing() and
+    # instrument.post_processing()
+    instrument.process()
+    assert mock_swe_l1a.call_count == 1
+    # This test is testing that no upload happened
+    assert mocks["mock_upload"].call_count == 0

imap_processing/tests/test_quality_flags.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from imap_processing.quality_flags import HitFlags, ImapLoFlags, ImapUltraFlags
+from imap_processing.quality_flags import HitFlags, ImapHkUltraFlags, ImapLoFlags
 
 
 def test_quality_flags():
@@ -10,30 +10,30 @@ def test_quality_flags():
 
     # Test individual flags
     assert HitFlags.NONE == 0x0
-    assert ImapUltraFlags.NONE == 0x0
+    assert ImapHkUltraFlags.NONE == 0x0
     assert ImapLoFlags.NONE == 0x0
     assert HitFlags.INF == 2**0
-    assert ImapUltraFlags.INF == 2**0
+    assert ImapHkUltraFlags.INF == 2**0
     assert ImapLoFlags.INF == 2**0
     assert HitFlags.NEG == 2**1
-    assert ImapUltraFlags.NEG == 2**1
+    assert ImapHkUltraFlags.NEG == 2**1
     assert ImapLoFlags.NEG == 2**1
-    assert ImapUltraFlags.BADSPIN == 2**2
+    assert ImapHkUltraFlags.BADSPIN == 2**2
     assert ImapLoFlags.BADSPIN == 2**2
-    assert ImapUltraFlags.FLAG1 == 2**3
+    assert ImapHkUltraFlags.FLAG1 == 2**3
     assert ImapLoFlags.FLAG2 == 2**3
     assert HitFlags.FLAG3 == 2**2
 
     # Test combined flags for Ultra
     flag = (
-        ImapUltraFlags.INF
-        | ImapUltraFlags.NEG
-        | ImapUltraFlags.BADSPIN
-        | ImapUltraFlags.FLAG1
+        ImapHkUltraFlags.INF
+        | ImapHkUltraFlags.NEG
+        | ImapHkUltraFlags.BADSPIN
+        | ImapHkUltraFlags.FLAG1
     )
-    assert flag & ImapUltraFlags.INF
-    assert flag & ImapUltraFlags.BADSPIN
-    assert flag & ImapUltraFlags.FLAG1
+    assert flag & ImapHkUltraFlags.INF
+    assert flag & ImapHkUltraFlags.BADSPIN
+    assert flag & ImapHkUltraFlags.FLAG1
     assert flag.name == "INF|NEG|BADSPIN|FLAG1"
     assert flag.value == 15
 
@@ -56,16 +56,16 @@ def test_quality_flags():
     data = np.array([-6, np.inf, 2, 3])
     quality = np.array(
         [
-            ImapUltraFlags.INF | ImapUltraFlags.NEG,
-            ImapUltraFlags.INF,
-            ImapUltraFlags.NONE,
-            ImapUltraFlags.NONE,
+            ImapHkUltraFlags.INF | ImapHkUltraFlags.NEG,
+            ImapHkUltraFlags.INF,
+            ImapHkUltraFlags.NONE,
+            ImapHkUltraFlags.NONE,
         ]
     )
     # Select data without INF flags
-    non_inf_mask = (quality & ImapUltraFlags.INF.value) == 0
+    non_inf_mask = (quality & ImapHkUltraFlags.INF.value) == 0
     np.array_equal(data[non_inf_mask], np.array([-6, 2, 3]))
 
     # Select data without NEG or INF flags
-    non_neg_mask = (quality & ImapUltraFlags.NEG.value) == 0
+    non_neg_mask = (quality & ImapHkUltraFlags.NEG.value) == 0
     np.array_equal(data[non_inf_mask & non_neg_mask], np.array([2, 3]))

imap_processing/tests/test_utils.py

@@ -90,7 +90,8 @@ def test_packet_file_to_datasets(use_derived_value, expected_mode):
     datasets_by_apid = utils.packet_file_to_datasets(
         packet_files, packet_definition, use_derived_value=use_derived_value
     )
-    # 3 apids in the test data
+    # 2 apids in the SWAPI test data that we decommutate
+    # (2 others are not included in the XTCE definition, but are in the raw packet file)
     assert len(datasets_by_apid) == 2
     data = datasets_by_apid[1188]
     assert data["sec_hdr_flg"].dtype == np.uint8
@@ -99,7 +100,7 @@ def test_packet_file_to_datasets(use_derived_value, expected_mode):
 
 
 def test_packet_file_to_datasets_flat_definition():
-    test_file = "tests/idex/imap_idex_l0_raw_20231214_v001.pkts"
+    test_file = "tests/idex/test_data/imap_idex_l0_raw_20231214_v001.pkts"
     packet_files = imap_module_directory / test_file
     packet_definition = (
         imap_module_directory / "idex/packet_definitions/idex_packet_definition.xml"