dkist-processing-common 10.5.4__py3-none-any.whl → 12.1.0rc1__py3-none-any.whl

dkist_processing_common/tests/test_quality_mixin.py

@@ -3,13 +3,21 @@ import json
 from io import StringIO
 from typing import Any
 
+import astropy.units as u
 import numpy as np
 import pandas
 import pytest
+from lmfit.minimizer import MinimizerResult
+from pydantic import ValidationError
+from solar_wavelength_calibration.fitter.wavelength_fitter import FitResult
+from solar_wavelength_calibration.fitter.wavelength_fitter import WavelengthParameters
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.json import json_encoder
 from dkist_processing_common.codecs.quality import QualityValueEncoder
+from dkist_processing_common.models.metric_code import MetricCode
+from dkist_processing_common.models.quality import Plot2D
+from dkist_processing_common.models.quality import VerticalMultiPanePlot2D
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import WorkflowTaskBase
 from dkist_processing_common.tasks.mixin.quality import QualityMixin
@@ -21,7 +29,7 @@ class Task(WorkflowTaskBase, QualityMixin):
 
 
 @pytest.fixture
-def quality_task(tmp_path, recipe_run_id):
+def quality_task(tmp_path, recipe_run_id) -> Task:
     with Task(
         recipe_run_id=recipe_run_id,
         workflow_name="workflow_name",
@@ -39,9 +47,9 @@ def quality_task(tmp_path, recipe_run_id):
 @pytest.fixture
 def plot_data():
     datetimes_a = ["2021-01-01T01:01:01", "2021-01-01T02:01:01"]
-    values_a = [3, 4]
+    values_a = [0.1, 0.2]
     datetimes_b = ["2020-01-01T01:01:01", "2020-01-01T02:01:01"]
-    values_b = [1, 2]
+    values_b = [0.15, 0.25]
     return datetimes_a, values_a, datetimes_b, values_b
 
 
@@ -106,6 +114,7 @@ def test_create_2d_plot_with_datetime_metric(quality_task):
         "facet",
         "statement",
         "plot_data",
+        "multi_plot_data",
         "histogram_data",
         "table_data",
         "modmat_data",
@@ -198,8 +207,9 @@ def test_store_ao_status_and_fried_parameter(quality_task, ao_values):
     """
     task = quality_task
     datetimes = ["2020-01-01T01:01:01", "2020-01-01T02:01:01"]
-    fried_values = [3.0, 4.0]
-    combined_values = [[ao, r0] for ao, r0 in zip(ao_values, fried_values)]
+    fried_values = [0.1, 0.2]
+    oob_values = [25, 50]
+    combined_values = [[ao, r0, oob] for ao, r0, oob in zip(ao_values, fried_values, oob_values)]
     task.quality_store_ao_status_and_fried_parameter(datetimes=datetimes, values=combined_values)
     path = list(task.read(tags=Tag.quality("AO_STATUS")))
     assert len(path) == 1
@@ -220,10 +230,11 @@ def test_store_ao_status_and_fried_parameter(quality_task, ao_values):
 @pytest.mark.parametrize(
     "combined_values",
     [
-        pytest.param([[True, 1], [None, 2]], id="AO_some_none"),
-        pytest.param([[True, 1], [True, None]], id="Fried_some_none"),
-        pytest.param([[None, 1], [None, 2]], id="AO_all_none"),
-        pytest.param([[True, None], [True, None]], id="Fried_all_none"),
+        pytest.param([[True, 0.1, 25], [None, 0.2, 25]], id="AO_some_none"),
+        pytest.param([[True, 0.1, 25], [True, None, 25]], id="Fried_some_none"),
+        pytest.param([[None, 0.1, 25], [None, 0.2, 25]], id="AO_all_none"),
+        pytest.param([[True, None, 25], [True, None, 25]], id="Fried_all_none"),
+        pytest.param([[True, 0.1, None], [True, 0.2, None]], id="Out_of_bounds_all_none"),
     ],
 )
 def test_store_ao_status_and_fried_parameter_with_nones(quality_task, combined_values):
@@ -231,13 +242,14 @@ def test_store_ao_status_and_fried_parameter_with_nones(quality_task, combined_v
     datetimes = ["2020-01-01T01:01:01", "2020-01-01T02:01:01"]
     task.quality_store_ao_status_and_fried_parameter(datetimes=datetimes, values=combined_values)
     path = list(task.read(tags=Tag.quality("AO_STATUS")))
-    ao_values = [ao for ao, r0 in combined_values]
-    fried_values = [r0 for ao, r0 in combined_values]
+    ao_values = [ao for ao, r0, oob in combined_values]
+    fried_values = [r0 for ao, r0, oob in combined_values]
+    ao_out_of_bounds = [oob for ao, r0, oob in combined_values]
     if not all(ao is None for ao in ao_values):
         assert len(path) == 1
         with path[0].open() as f:
             data = json.load(f)
-            assert len(data) == sum(1 for ao, r0 in combined_values if ao is not None)
+            assert len(data) == sum(1 for ao, r0, oob in combined_values if ao is not None)
     else:
         assert len(path) == 0
     path = list(task.read(tags=Tag.quality("FRIED_PARAMETER")))
@@ -246,7 +258,7 @@ def test_store_ao_status_and_fried_parameter_with_nones(quality_task, combined_v
         with path[0].open() as f:
             data = json.load(f)
             assert len(data["y_values"]) == sum(
-                1 for ao, r0 in combined_values if ao is True and r0 is not None
+                1 for ao, r0, oob in combined_values if ao is True and r0 is not None
             )
     else:
         assert len(path) == 0
@@ -263,7 +275,8 @@ def test_build_ao_status(quality_task, plot_data):
     datetimes = datetimes_a + datetimes_b
     fried_values = values_a + values_b
     ao_values = [False, True, True, True]
-    combined_values = [[ao, r0] for ao, r0 in zip(ao_values, fried_values)]
+    oob_values = [25, 50, None, 50]
+    combined_values = [[ao, r0, oob] for ao, r0, oob in zip(ao_values, fried_values, oob_values)]
     task.quality_store_ao_status_and_fried_parameter(datetimes=datetimes, values=combined_values)
     metric = task.quality_build_ao_status()
     assert metric["name"] == "Adaptive Optics Status"
@@ -284,9 +297,15 @@ def test_build_fried_parameter(quality_task, plot_data):
     task = quality_task
     datetimes_a, fried_values_a, datetimes_b, fried_values_b = plot_data
     ao_values_a = [True, True]
-    combined_values_a = [[ao, r0] for ao, r0 in zip(ao_values_a, fried_values_a)]
+    oob_values_a = [25, 50]
+    combined_values_a = [
+        [ao, r0, oob] for ao, r0, oob in zip(ao_values_a, fried_values_a, oob_values_a)
+    ]
     ao_values_b = [True, True]
-    combined_values_b = [[ao, r0] for ao, r0 in zip(ao_values_b, fried_values_b)]
+    oob_values_b = [25, 50]
+    combined_values_b = [
+        [ao, r0, oob] for ao, r0, oob in zip(ao_values_b, fried_values_b, oob_values_b)
+    ]
     task.quality_store_ao_status_and_fried_parameter(
         datetimes=datetimes_a, values=combined_values_a
     )
@@ -307,14 +326,14 @@ def test_build_fried_parameter(quality_task, plot_data):
             "2021-01-01T02:01:01",
         ]
     ]
-    assert metric["plot_data"]["series_data"][""][1] == [1, 2, 3, 4]
+    assert metric["plot_data"]["series_data"][""][1] == [0.15, 0.25, 0.1, 0.2]
     assert metric["name"] == "Fried Parameter"
     assert metric["metric_code"] == "FRIED_PARAMETER"
     assert metric["facet"] is None
     assert metric["warnings"] is None
     assert (
         metric["statement"]
-        == "Average valid Fried Parameter measurements for L1 dataset: 2.5 ± 1.12 m"
+        == "Average valid Fried Parameter measurements for L1 dataset: 0.18 ± 0.06 m"
     )
 
 
@@ -340,12 +359,12 @@ def test_build_light_level(quality_task, plot_data):
             "2021-01-01T02:01:01",
         ]
     ]
-    assert metric["plot_data"]["series_data"][""][1] == [1, 2, 3, 4]
+    assert metric["plot_data"]["series_data"][""][1] == [0.15, 0.25, 0.1, 0.2]
     assert metric["name"] == "Light Level"
     assert metric["metric_code"] == "LIGHT_LEVEL"
     assert metric["facet"] is None
     assert metric["warnings"] is None
-    assert metric["statement"] == f"Average Light Level for L1 dataset: 2.5 ± 1.12 adu"
+    assert metric["statement"] == f"Average Light Level for L1 dataset: 0.18 ± 0.06 adu"
 
 
 def test_build_frame_average(quality_task, plot_data):
@@ -461,7 +480,7 @@ def test_build_noise(quality_task, plot_data):
             "2021-01-01T02:01:01",
         ]
     ]
-    assert metric["plot_data"]["series_data"]["I"][1] == [1, 2, 3, 4]
+    assert metric["plot_data"]["series_data"]["I"][1] == [0.15, 0.25, 0.1, 0.2]
     assert metric["name"] == "Noise Estimation"
     assert metric["metric_code"] == "NOISE"
     assert metric["facet"] is None
@@ -493,7 +512,7 @@ def test_build_sensitivity(quality_task, plot_data):
             "2021-01-01T02:01:01",
         ]
     ]
-    assert metric["plot_data"]["series_data"]["I"][1] == [1, 2, 3, 4]
+    assert metric["plot_data"]["series_data"]["I"][1] == [0.15, 0.25, 0.1, 0.2]
     assert metric["name"] == f"Sensitivity"
     assert metric["metric_code"] == "SENSITIVITY"
     assert metric["facet"] is None
@@ -692,7 +711,7 @@ def test_build_report(quality_task, plot_data):
     task.quality_store_task_type_counts(task_type="dark", total_frames=100, frames_not_used=7)
     task.quality_store_task_type_counts(task_type="gain", total_frames=100, frames_not_used=0)
     task.quality_store_ao_status_and_fried_parameter(
-        datetimes=datetimes, values=[[True, values[0]], [True, values[1]]]
+        datetimes=datetimes, values=[[True, values[0], values[0]], [True, values[1], values[1]]]
     )
     task.quality_store_light_level(datetimes=datetimes, values=values)
     task.quality_store_frame_average(
@@ -1175,6 +1194,189 @@ def test_avg_noise_nan_values(quality_task, array_shape):
     assert not np.isnan(result)
 
 
+@pytest.fixture(scope="session")
+def wavecal_input_wavelength() -> u.Quantity:
+    return np.arange(100) * u.nm
+
+
+@pytest.fixture(scope="session")
+def wavecal_input_spectrum(wavecal_input_wavelength) -> np.ndarray:
+    spec = (wavecal_input_wavelength.value - wavecal_input_wavelength.size // 2) ** 2 + 10.0
+    spec[spec.size // 2] = np.nan
+    return spec
+
+
+@pytest.fixture(scope="session")
+def wavecal_weights(wavecal_input_wavelength) -> np.ndarray:
+    weights = np.arange(wavecal_input_wavelength.size, dtype=float)
+    weights[0] = np.inf
+    return weights
+
+
+@pytest.fixture(scope="session")
+def wavecal_fit_result(wavecal_input_wavelength, wavecal_input_spectrum) -> FitResult:
+    wavelength_params = WavelengthParameters(
+        crpix=1, crval=10.0, dispersion=1, grating_constant=1, order=1, incident_light_angle=0
+    )
+
+    residuals = np.random.random(wavecal_input_wavelength.size)
+    residuals[-1] = np.nan
+    minimizer_result = MinimizerResult(residual=residuals)
+    return FitResult(
+        wavelength_parameters=wavelength_params,
+        minimizer_result=minimizer_result,
+        input_wavelength_vector=wavecal_input_wavelength,
+        input_spectrum=wavecal_input_spectrum,
+    )
+
+
+@pytest.mark.parametrize(
+    "use_weights",
+    [pytest.param(True, id="custom_weights"), pytest.param(False, id="default_weights")],
+)
+def test_wavecal_store_results(
+    quality_task,
+    wavecal_input_wavelength,
+    wavecal_input_spectrum,
+    wavecal_fit_result,
+    wavecal_weights,
+    use_weights,
+):
+    """
+    Given: A task with the QualityMixin and the results of a wavecal fit
+    When: Storing the wavecal metric
+    Then: The correct metric json files are written and their contents contain the correct types of data
+    """
+    quality_task.quality_store_wavecal_results(
+        input_wavelength=wavecal_input_wavelength,
+        input_spectrum=wavecal_input_spectrum,
+        fit_result=wavecal_fit_result,
+        weights=wavecal_weights if use_weights else None,
+    )
+
+    wavecal_quality_files = list(quality_task.read(tags=[Tag.quality(MetricCode.wavecal_fit)]))
+    assert len(wavecal_quality_files) == 1
+    with open(wavecal_quality_files[0], "r") as f:
+        results_dict = json.load(f)
+        assert sorted(results_dict.keys()) == sorted(
+            [
+                "input_wavelength_nm",
+                "input_spectrum",
+                "best_fit_wavelength_nm",
+                "best_fit_atlas",
+                "normalized_residuals",
+                "weights",
+            ]
+        )
+        for k, v in results_dict.items():
+            if k != "weights" or use_weights:
+                assert isinstance(v, list)
+                assert len(v) == len(results_dict["input_wavelength_nm"])
+        if not use_weights:
+            assert results_dict["weights"] is None
+
+
+@pytest.fixture(
+    scope="session",
+    params=[pytest.param([0, 1.0, 0.8, 0.0], id="weights"), pytest.param(None, id="no_weights")],
+)
+def wavecal_data_json(request) -> dict:
+    weights = request.param
+    return {
+        "input_wavelength_nm": [1001.0, 1002.0, 1003.0, 1004.0],
+        "input_spectrum": [1.0, 1.0, 0.5, 1.0],
+        "best_fit_wavelength_nm": [1001.5, 1002.6, 1003.7, 1004.8],
+        "best_fit_atlas": [1.0, 1.0, 0.4, 1.0],
+        "normalized_residuals": [0.0, 0.0, 0.1, 0.0],
+        "weights": weights,
+    }
+
+
+def test_build_wavecal_results(quality_task, wavecal_data_json):
+    """
+    Given: A task with the QualityMixin
+    When: Building the wavecal results quality metric
+    Then: The correct metric model is returned
+    """
+    weights_included = wavecal_data_json["weights"] is not None
+    quality_task.write(
+        data=wavecal_data_json,
+        tags=[Tag.quality(MetricCode.wavecal_fit)],
+        encoder=json_encoder,
+        allow_nan=False,
+        cls=QualityValueEncoder,
+    )
+    metric = quality_task.quality_build_wavecal_results()
+
+    assert metric["name"] == "Wavelength Calibration Results"
+    assert metric["description"] == (
+        "These plots show the wavelength solution computed based on fits to a Solar FTS atlas. "
+        "The top plot shows the input and best-fit spectra along with the best-fit atlas, which is "
+        "a combination of Solar and Telluric spectra. The bottom plot shows the fit residuals."
+    )
+    assert metric["metric_code"] == MetricCode.wavecal_fit.value
+    assert metric["facet"] is None
+    assert metric["statement"] is None
+    assert metric["plot_data"] is None
+    assert metric["histogram_data"] is None
+    assert metric["table_data"] is None
+    assert metric["modmat_data"] is None
+    assert metric["efficiency_data"] is None
+    assert metric["raincloud_data"] is None
+    assert metric["warnings"] is None
+
+    multi_plot_data = metric["multi_plot_data"]
+    assert multi_plot_data["match_x_axes"] is True
+    assert multi_plot_data["no_gap"] is True
+    assert (
+        multi_plot_data["top_to_bottom_height_ratios"] == [1.5, 1, 1]
+        if weights_included
+        else [1.5, 1]
+    )
+    plot_list = multi_plot_data["top_to_bottom_plot_list"]
+    assert isinstance(plot_list, list)
+    assert len(plot_list) == 3 if weights_included else 3
+
+    fit_plot = plot_list[0]
+    assert fit_plot["sort_series"] is False
+    assert fit_plot["xlabel"] == "Wavelength [nm]"
+    assert fit_plot["ylabel"] == "Signal"
+    assert fit_plot["series_data"] == {
+        "Input Spectrum": [[1001.0, 1002.0, 1003.0, 1004.0], [1.0, 1.0, 0.5, 1.0]],
+        "Best Fit Observations": [[1001.5, 1002.6, 1003.7, 1004.8], [1.0, 1.0, 0.5, 1.0]],
+        "Best Fit Atlas": [[1001.5, 1002.6, 1003.7, 1004.8], [1.0, 1.0, 0.4, 1.0]],
+    }
+    assert fit_plot["plot_kwargs"] == {
+        "Input Spectrum": {"ls": "-", "alpha": 0.4, "ms": 0, "color": "#1E317A", "zorder": 2.1},
+        "Best Fit Observations": {
+            "ls": "-",
+            "lw": 4,
+            "alpha": 0.8,
+            "ms": 0,
+            "color": "#FAA61C",
+            "zorder": 2.0,
+        },
+        "Best Fit Atlas": {"color": "k", "ls": "-", "ms": 0, "zorder": 2.2},
+    }
+
+    residuals_plot = plot_list[1]
+    assert residuals_plot["xlabel"] == "Wavelength [nm]"
+    assert residuals_plot["ylabel"] == r"$\frac{\mathrm{Obs - Atlas}}{\mathrm{Obs}}$"
+    assert residuals_plot["series_data"] == {
+        "Residuals": [[1001.5, 1002.6, 1003.7, 1004.8], [0.0, 0.0, 0.1, 0.0]]
+    }
+    assert residuals_plot["plot_kwargs"] == {"Residuals": {"ls": "-", "color": "k", "ms": 0}}
+
+    if weights_included:
+        weights_plot = plot_list[2]
+        assert weights_plot["xlabel"] == "Wavelength [nm]"
+        assert weights_plot["ylabel"] == "Fit Weights"
+        assert weights_plot["series_data"] == {
+            "Weights": [[1001.5, 1002.6, 1003.7, 1004.8], [0.0, 1.0, 0.8, 0.0]]
+        }
+        assert weights_plot["plot_kwargs"] == {"Weights": {"ls": "-", "color": "k", "ms": 0}}
+
+
 @pytest.mark.parametrize(
     "bin_strs, sampled_bins, expected_bin_str, expected_sample_str",
     [
@@ -1245,3 +1447,33 @@ def test_format_facet(label: str | Any, expected_result: str):
     Then: the label is properly formatted
     """
     assert QualityMixin._format_facet(label) == expected_result
+
+
+def test_validate_vertical_multi_pane_plot_model():
+    """
+    Given: A `VerticalMultiPanePlot2D` model and some `Plot2D` models
+    When: Instantiating the `VerticalMultiPanePlot2D` with various parameters
+    Then: The `top_to_bottom_plot_ratios` property is correctly populated
+    """
+    plot2d = Plot2D(xlabel="X", ylabel="Y", series_data={"Foo": [[1.0], [2.0]]})
+
+    # Test given ratios valid case
+    _ = VerticalMultiPanePlot2D(
+        top_to_bottom_plot_list=[plot2d, plot2d], top_to_bottom_height_ratios=[1.0, 2.0]
+    )
+
+    # Test None ratios
+    vertical_plots = VerticalMultiPanePlot2D(
+        top_to_bottom_plot_list=[plot2d, plot2d], top_to_bottom_height_ratios=None
+    )
+    assert vertical_plots.top_to_bottom_height_ratios == [1.0, 1.0]
+
+    # Test invalid case
+    with pytest.raises(
+        ValidationError,
+        match="The number of items in `top_to_bottom_height_ratios` list \(3\) is not "
+        "the same as the number of plots \(2\)",
+    ):
+        _ = VerticalMultiPanePlot2D(
+            top_to_bottom_plot_list=[plot2d, plot2d], top_to_bottom_height_ratios=[1.0, 2.0, 3.0]
+        )

dkist_processing_common/tests/test_scratch.py

@@ -1,14 +1,15 @@
 """
 Tests for the workflow file system wrapper
 """
+
 from pathlib import Path
 from typing import Callable
 from uuid import uuid4
 
 import pytest
 
-from dkist_processing_common._util.scratch import _flatten_list
 from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common._util.scratch import _flatten_list
 
 
 @pytest.fixture(