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

imap_processing/tests/idex/test_idex_l2a.py

@@ -1,24 +1,21 @@
 """Tests the L2a processing for IDEX data"""
 
-from unittest import mock
-
 import numpy as np
-import pytest
 import xarray as xr
 from scipy.stats import exponnorm
 
 from imap_processing.idex import idex_constants
-from imap_processing.idex.idex_l1b import idex_l1b
 from imap_processing.idex.idex_l2a import (
     BaselineNoiseTime,
     analyze_peaks,
     butter_lowpass_filter,
     calculate_kappa,
     calculate_snr,
+    chi_square,
     estimate_dust_mass,
     fit_impact,
-    idex_l2a,
     remove_signal_noise,
+    sine_fit,
     time_to_mass,
 )
 
@@ -29,30 +26,14 @@ def mock_microphonics_noise(time: np.ndarray) -> np.ndarray:
     phase_shift = 45
     amp = 10
     # Create a sine wave signal
-    sine_signal = amp * np.sin(2 * np.pi * noise_frequency * time + phase_shift)
+    sine_signal = sine_fit(time, amp, noise_frequency, phase_shift)
     # Combine the sine wave signals with a linear signal to create noise
     combined_sig = sine_signal + (time * 5)
 
     return combined_sig
 
 
-@pytest.fixture(scope="module")
-def l2a_dataset(decom_test_data: xr.Dataset) -> xr.Dataset:
-    """Return a ``xarray`` dataset containing test data.
-
-    Returns
-    -------
-    dataset : xr.Dataset
-        A ``xarray`` dataset containing the test data
-    """
-    with mock.patch("imap_processing.idex.idex_l1b.get_spice_data", return_value={}):
-        dataset = idex_l2a(
-            idex_l1b(decom_test_data, data_version="001"), data_version="001"
-        )
-    return dataset
-
-
-def test_l2a_cdf_filenames(l2a_dataset: xr.Dataset):
+def test_l2a_logical_source(l2a_dataset: xr.Dataset):
     """Tests that the ``idex_l2a`` function generates datasets
     with the expected logical source.
 
@@ -75,25 +56,31 @@ def test_l2a_cdf_variables(l2a_dataset: xr.Dataset):
         A ``xarray`` dataset containing the test data
     """
     expected_vars = [
-        "mass",
         "target_low_fit_parameters",
-        "target_low_fit_imapct_charge",
-        "target_low_fit_imapct_mass_estimate",
+        "target_low_fit_impact_charge",
+        "target_low_fit_impact_mass_estimate",
         "target_low_chi_squared",
         "target_low_reduced_chi_squared",
         "target_low_fit_results",
         "target_high_fit_parameters",
-        "target_high_fit_imapct_charge",
-        "target_high_fit_imapct_mass_estimate",
+        "target_high_fit_impact_charge",
+        "target_high_fit_impact_mass_estimate",
         "target_high_chi_squared",
         "target_high_reduced_chi_squared",
         "target_high_fit_results",
         "ion_grid_fit_parameters",
-        "ion_grid_fit_imapct_charge",
-        "ion_grid_fit_imapct_mass_estimate",
+        "ion_grid_fit_impact_charge",
+        "ion_grid_fit_impact_mass_estimate",
         "ion_grid_chi_squared",
         "ion_grid_reduced_chi_squared",
         "ion_grid_fit_results",
+        "tof_peak_fit_parameters",
+        "tof_peak_area_under_fit",
+        "tof_peak_chi_square",
+        "tof_peak_reduced_chi_square",
+        "tof_peak_kappa",
+        "tof_snr",
+        "mass",
     ]
 
     cdf_vars = l2a_dataset.variables
@@ -235,7 +222,9 @@ def test_analyze_peaks_warning(caplog):
     tof = np.ones_like(time)
     mass_scale = np.ones_like(time)
     with caplog.at_level("WARNING"):
-        fit_params, area_under_curve = analyze_peaks(tof, time, mass_scale, 0, peaks)
+        fit_params, area_under_curve, chisqr, redchi = analyze_peaks(
+            tof, time, mass_scale, 0, peaks
+        )
     assert any(
         "Failed to fit EMG curve" in message for message in caplog.text.splitlines()
     )
@@ -243,6 +232,9 @@ def test_analyze_peaks_warning(caplog):
     # The fit_params and area_under_curve arrays should be zero
     assert np.all(fit_params == 0)
     assert np.all(area_under_curve == 0)
+    # chi-square and reduced chi-square values should all be np.nan
+    np.testing.assert_array_equal(chisqr, np.nan)
+    np.testing.assert_array_equal(chisqr, np.nan)
 
 
 def test_analyze_peaks_perfect_fits():
@@ -269,7 +261,9 @@ def test_analyze_peaks_perfect_fits():
         gauss = exponnorm.pdf(time.data, k, mu, sigma)
         tof[peak - 5 : peak + 6] = gauss[peak - 5 : peak + 6]
 
-    fit_params, area_under_curve = analyze_peaks(tof, time, mass_scale, event, peaks)
+    fit_params, area_under_curve, chisqr, redchi = analyze_peaks(
+        tof, time, mass_scale, event, peaks
+    )
 
     for peak in peaks[event]:
         mu = peak - 0.4
@@ -278,6 +272,9 @@ def test_analyze_peaks_perfect_fits():
         assert np.allclose(fit_params[mass], np.asarray([mu, sigma, lam]), rtol=1e-12)
         # Test that there is a value greater than zero at this index
         assert area_under_curve[mass] > 0
+        # Test the goodness of fit
+        assert chisqr < 1e-20
+        assert redchi < 1e-20
 
 
 def test_estimate_dust_mass_no_noise_removal():
@@ -381,3 +378,22 @@ def test_remove_signal_noise_no_sine_wave(caplog):
     filtered_sig = remove_signal_noise(time, signal, mask)
     # Test that the filtered signal is close to zero
     assert np.allclose(filtered_sig, np.zeros_like(filtered_sig), rtol=1e-24)
+
+
+def test_chi_square():
+    """
+    Test that chi_square() function calculates the expected values for an array of given
+    residuals.
+    """
+    residual = 3
+    nparams = 2
+    exp = np.array([16, 18, 16, 14, 12, 12])
+    obs = exp + residual
+
+    expected_chi_square = np.square(residual) * len(exp)
+    expected_red_chi_square = expected_chi_square / (len(exp) - nparams)
+
+    chisqr, redchi = chi_square(obs, exp, nparams)
+
+    assert chisqr == expected_chi_square
+    assert redchi == expected_red_chi_square

imap_processing/tests/idex/test_idex_l2b.py

@@ -0,0 +1,93 @@
+"""Tests the L2b processing for IDEX data"""
+
+import numpy as np
+import pytest
+import xarray as xr
+from numpy.testing import assert_array_equal
+
+from imap_processing.idex.idex_l2b import idex_l2b, round_spin_phases
+
+
+@pytest.fixture
+def l2b_dataset(l2a_dataset: xr.Dataset) -> xr.Dataset:
+    """Return a ``xarray`` dataset containing test data.
+
+    Returns
+    -------
+    dataset : xr.Dataset
+        A ``xarray`` dataset containing the test data
+    """
+    dataset = idex_l2b(l2a_dataset)
+    return dataset
+
+
+def test_l2b_logical_source(l2b_dataset: xr.Dataset):
+    """Tests that the ``idex_l2b`` function generates datasets
+    with the expected logical source.
+
+    Parameters
+    ----------
+    l2b_dataset : xr.Dataset
+        A ``xarray`` dataset containing the test data
+    """
+    expected_src = "imap_idex_l2b_sci"
+    assert l2b_dataset.attrs["Logical_source"] == expected_src
+
+
+def test_l2a_cdf_variables(l2b_dataset: xr.Dataset):
+    """Tests that the ``idex_l2a`` function generates datasets
+    with the expected variables.
+
+    Parameters
+    ----------
+    l2b_dataset : xr.Dataset
+        A ``xarray`` dataset containing the test data
+    """
+    expected_vars = [
+        "epoch",
+        "impact_day_of_year",
+        "spin_phase_quadrants",
+        "target_low_fit_impact_charge",
+        "target_low_fit_impact_mass_estimate",
+        "target_high_fit_impact_charge",
+        "target_high_fit_impact_mass_estimate",
+        "ion_grid_fit_impact_charge",
+        "ion_grid_fit_impact_mass_estimate",
+    ]
+
+    cdf_vars = l2b_dataset.variables
+    for var in expected_vars:
+        assert var in cdf_vars
+
+
+def test_round_spin_phases():
+    """Tests that round_spin_phases() produces expected results."""
+    spin_phase_angles = xr.DataArray([90, 1, 10, 200, 359, 179, 100])
+    expected_quadrants = [90, 0, 0, 180, 0, 180, 90]
+
+    spin_quadrants = round_spin_phases(spin_phase_angles)
+    assert_array_equal(spin_quadrants, expected_quadrants)
+
+    # Test with a larger number of random values
+    spin_phase_angles = np.random.randint(0, 360, 1000)
+    spin_quadrants = round_spin_phases(spin_phase_angles)
+    unique_quadrants = np.unique(spin_quadrants)
+    assert set(unique_quadrants) == {0, 90, 180, 270}
+
+    # Test values that are exactly halfway between quadrants
+    spin_quadrants = round_spin_phases(np.array([45, 135, 225, 315]))
+    assert_array_equal(spin_quadrants, [90, 180, 270, 0])
+
+
+def test_round_spin_phases_warning(caplog):
+    """Tests that round_spin_phases() logs expected out of range warning."""
+    # The last value in the array should trigger a warning since it is >=360.
+    spin_phase_angles = xr.DataArray([90, 1, 10, 200, 360])
+
+    with caplog.at_level("WARNING"):
+        round_spin_phases(spin_phase_angles)
+
+    assert (
+        f"Spin phase angles, {spin_phase_angles.data} "
+        f"are outside of the expected spin phase angle range, [0, 360)."
+    ) in caplog.text

imap_processing/tests/lo/test_lo_l1a.py

@@ -15,7 +15,7 @@ def test_lo_l1a():
         "imap_lo_l1a_histogram",
         "imap_lo_l1a_de",
     ]
-    output_dataset = lo_l1a(dependency, "001")
+    output_dataset = lo_l1a(dependency)
 
     # Assert
     for dataset, logical_source in zip(output_dataset, expected_logical_source):
@@ -56,7 +56,7 @@ def test_lo_l1a_dataset():
     hist_fields_lower = [field.lower() for field in histogram_fields]
 
     # Act
-    output_datasets = lo_l1a(dependency, "001")
+    output_datasets = lo_l1a(dependency)
 
     # Assert
     np.testing.assert_array_equal(hist_fields_lower, output_datasets[1].data_vars)
@@ -108,7 +108,7 @@ def test_validate_spin_data():
             validation_data = validation_data.drop(matching_columns, axis=1)
 
     # Act
-    output_dataset = lo_l1a(dependency, "001")
+    output_dataset = lo_l1a(dependency)
 
     # Assert
     for field in spin_fields: