solarwindpy 0.0.1.dev0__py3-none-any.whl → 0.1.0__py3-none-any.whl

tests/fitfunctions/test_plots.py

@@ -0,0 +1,258 @@
+import numpy as np
+import pytest
+from pathlib import Path
+
+from scipy.optimize import OptimizeResult
+
+import matplotlib.pyplot as plt
+
+from solarwindpy.fitfunctions.plots import FFPlot, AxesLabels, LogAxes
+from solarwindpy.fitfunctions.core import Observations, UsedRawObs
+
+
+class DummyTeX:
+    """Minimal TeXinfo replacement recording annotation calls."""
+
+    def __init__(self):
+        self.calls = 0
+
+    def annotate_info(self, ax, **kwargs):  # pragma: no cover - simple recorder
+        self.calls += 1
+        ax.text(0.0, 0.0, "info")
+
+
+class Label:
+    """Helper label providing a ``path`` attribute for testing ``FFPlot.path``."""
+
+    def __init__(self, label, path):
+        self.label = label
+        self.path = path
+
+    def __str__(self):
+        return self.label
+
+
+def make_observations(n):
+    """Build ``UsedRawObs`` with ``n`` raw points and every other point used."""
+
+    x = np.arange(float(n))
+    y = 2.0 * x + 1.0
+    w = np.ones_like(x)
+    mask = np.zeros_like(x, dtype=bool)
+    mask[::2] = True
+    raw = Observations(x, y, w)
+    used = Observations(x[mask], y[mask], w[mask])
+    return UsedRawObs(used, raw, mask), y
+
+
+def make_ffplot(n=5):
+    obs, y_fit = make_observations(n)
+    tex = DummyTeX()
+    fit_res = OptimizeResult(fun=y_fit[obs.tk_observed] - obs.used.y)
+    plot = FFPlot(obs, y_fit, tex, fit_res, fitfunction_name="dummy")
+    return plot, tex, obs, y_fit
+
+
+def test_str_returns_class_name():
+    """Ensure ``FFPlot.__str__`` yields the class name."""
+
+    plot, *_ = make_ffplot()
+    assert str(plot) == plot.__class__.__name__ == "FFPlot"
+
+
+def test_initial_properties_and_path():
+    plot, tex, obs, y_fit = make_ffplot()
+    assert plot.observations is obs
+    assert np.all(plot.y_fit == y_fit)
+    assert plot.TeX_info is tex
+    assert plot.labels == AxesLabels("x", "y")
+    assert plot.log == LogAxes(False, False)
+    expected = Path("FFPlot") / "dummy" / "x" / "y" / "linX_logY"
+    assert plot.path == expected
+
+    plot.set_labels(x=Label("X", "xp"), y=Label("Y", "yp"), z="Z")
+    plot.set_log(x=True, y=True)
+    plot.set_fitfunction_name("name")
+    expected = Path("FFPlot") / "name" / "xp" / "yp" / "Z" / "logX_logY"
+    assert plot.path == expected
+
+
+def test_setters():
+    plot, tex, obs, y_fit = make_ffplot()
+    plot.set_fitfunction_name("new")
+    assert plot.fitfunction_name == "new"
+
+    res = OptimizeResult(x=np.array([1.0]))
+    plot.set_fit_result(res)
+    assert plot.fit_result is res
+
+    obs2, y_fit2 = make_observations(6)
+    plot.set_observations(obs2, y_fit2)
+    assert plot.observations is obs2
+    assert np.all(plot.y_fit == y_fit2)
+
+
+def test_set_observations_mismatched_length():
+    plot, *_ = make_ffplot()
+    obs = plot.observations
+    bad_y_fit = np.ones(obs.raw.x.size + 1)
+    with pytest.raises(AssertionError):
+        plot.set_observations(obs, bad_y_fit)
+
+
+def test_set_observations_short_y_fit():
+    """Ensure shorter ``y_fit`` arrays trigger an assertion."""
+    plot, *_ = make_ffplot()
+    obs = plot.observations
+    bad_y_fit = np.ones(obs.raw.x.size - 1)
+    with pytest.raises(AssertionError):
+        plot.set_observations(obs, bad_y_fit)
+
+
+def test_estimate_markevery():
+    plot, *_ = make_ffplot(n=5)
+    assert plot._estimate_markevery() is None
+    plot_big, *_ = make_ffplot(n=1000)
+    assert plot_big._estimate_markevery() == 10
+
+
+def test_format_helpers():
+    plot, *_ = make_ffplot()
+    plot.set_labels(x="time", y="value")
+    plot.set_log(x=True, y=False)
+
+    fig, ax = plt.subplots()
+    plot._format_hax(ax)
+    assert ax.get_xlabel() == "time"
+    assert ax.get_ylabel() == "value"
+    assert ax.get_xscale() == "log"
+    assert ax.get_yscale() == "linear"
+
+    fig2, rax = plt.subplots()
+    plot._format_rax(rax, pct=True)
+    assert rax.get_ylabel() == r"$\mathrm{Residual} \; [\%]$"
+    assert rax.get_xscale() == "log"
+    assert rax.get_yscale() == "symlog"
+    assert rax.get_ylim() == (-100, 100)
+
+    fig3, rax2 = plt.subplots()
+    plot._format_rax(rax2, pct=False)
+    assert rax2.get_ylabel() == r"$\mathrm{Residual} \; [\#]$"
+
+
+def test_plot_methods_and_annotations(monkeypatch):
+    import solarwindpy.fitfunctions.plots as plots
+
+    plot, tex, *_ = make_ffplot()
+
+    calls = []
+    original = plots.plt.subplots
+
+    def fake_subplots(*args, **kwargs):  # pragma: no cover - small wrapper
+        calls.append((args, kwargs))
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(plots.plt, "subplots", fake_subplots)
+
+    ax, *_ = plot.plot_raw()
+    assert calls and isinstance(ax, plt.Axes)
+    calls.clear()
+
+    ax, *_ = plot.plot_used()
+    assert calls
+    calls.clear()
+
+    plot.plot_fit()
+    assert calls and tex.calls == 1
+    calls.clear()
+
+    plot.plot_fit(annotate=False)
+    assert tex.calls == 1
+
+    ax = plot.plot_raw_used_fit()
+    labels = {t.get_text() for t in ax.get_legend().get_texts()}
+    assert labels == {r"$\mathrm{Obs}$", r"$\mathrm{Used}$", r"$\mathrm{Fit}$"}
+
+    calls.clear()
+    plot.plot_residuals()
+    assert calls
+
+
+def test_plot_raw_used_fit_resid(monkeypatch):
+    import solarwindpy.fitfunctions.plots as plots
+
+    plot, tex, *_ = make_ffplot()
+
+    calls = []
+    original = plots.plt.subplots
+
+    def fake_subplots(*args, **kwargs):  # pragma: no cover - small wrapper
+        calls.append((args, kwargs))
+        return original(*args, **kwargs)
+
+    monkeypatch.setattr(plots.plt, "subplots", fake_subplots)
+
+    hax, rax = plot.plot_raw_used_fit_resid()
+    assert isinstance(hax, plt.Axes)
+    assert isinstance(rax, plt.Axes)
+    labels = {t.get_text() for t in hax.get_legend().get_texts()}
+    assert labels == {r"$\mathrm{Obs}$", r"$\mathrm{Used}$", r"$\mathrm{Fit}$"}
+    assert tex.calls == 1
+
+    plot.plot_raw_used_fit_resid(annotate=False)
+    assert tex.calls == 1
+
+
+def test_label_log_texinfo():
+    plot, tex, *_ = make_ffplot()
+    plot.set_labels(y="Y")
+    assert plot.labels == AxesLabels("x", "Y")
+    with pytest.raises(KeyError):
+        plot.set_labels(q="bad")
+
+    plot.set_log(x=True)
+    assert plot.log == LogAxes(True, False)
+
+    tex2 = DummyTeX()
+    plot.set_TeX_info(tex2)
+    assert plot.TeX_info is tex2
+
+
+def test_plot_residuals_simple_pct_false():
+    plot, *_ = make_ffplot()
+    ax = plot.plot_residuals(kind="simple", pct=False)
+    assert isinstance(ax, plt.Axes)
+    line = ax.get_lines()[0]
+    expected = plot.y_fit[plot.observations.tk_observed] - plot.observations.used.y
+    assert np.allclose(line.get_ydata(), expected)
+    assert ax.get_ylabel() == r"$\mathrm{Residual} \; [\#]$"
+    ax.legend()
+    labels = {t.get_text() for t in ax.get_legend().get_texts()}
+    assert labels == {r"$\mathrm{ \; Simple}$"}
+
+
+def test_plot_residuals_robust():
+    plot, *_ = make_ffplot()
+    ax = plot.plot_residuals(kind="robust")
+    assert isinstance(ax, plt.Axes)
+    line = ax.get_lines()[0]
+    y_fit_used = plot.y_fit[plot.observations.tk_observed]
+    expected = 100.0 * (plot.fit_result.fun / y_fit_used)
+    assert np.allclose(line.get_ydata(), expected)
+    ax.legend()
+    labels = {t.get_text() for t in ax.get_legend().get_texts()}
+    assert labels == {r"$\mathrm{ \; Robust}$"}
+    assert ax.get_ylabel() == r"$\mathrm{Residual} \; [\%]$"
+
+
+def test_plot_residuals_missing_fun_no_exception():
+    plot, *_ = make_ffplot()
+    plot.set_fit_result(OptimizeResult())
+    ax = plot.plot_residuals(kind="both")
+    assert isinstance(ax, plt.Axes)
+    lines = ax.get_lines()
+    assert len(lines) == 1
+    ax.legend()
+    labels = {t.get_text() for t in ax.get_legend().get_texts()}
+    assert labels == {r"$\mathrm{ \; Simple}$"}
+    assert ax.get_ylabel() == r"$\mathrm{Residual} \; [\%]$"

tests/fitfunctions/test_power_laws.py

@@ -0,0 +1,365 @@
+"""Tests for power law fit functions."""
+
+import inspect
+import numpy as np
+import pytest
+
+from solarwindpy.fitfunctions.power_laws import (
+    PowerLaw,
+    PowerLawPlusC,
+    PowerLawOffCenter,
+)
+
+
+@pytest.mark.parametrize(
+    "cls, expected_params, sample_args, input_x",
+    [
+        (PowerLaw, ("x", "A", "b"), (2.0, 3.0, 1.5), 2.0),
+        (PowerLawPlusC, ("x", "A", "b", "c"), (2.0, 3.0, 1.5, 1.0), 2.0),
+        (PowerLawOffCenter, ("x", "A", "b", "x0"), (2.0, 3.0, 1.5, 0.5), 2.0),
+    ],
+)
+def test_function_signature_and_output(cls, expected_params, sample_args, input_x):
+    """Test function signatures and basic output for power law classes."""
+    x = np.array([1.0, 2.0, 3.0])
+    y = np.array([1.0, 4.0, 9.0])
+    obj = cls(x, y)
+
+    # Test function signature
+    sig = inspect.signature(obj.function)
+    assert tuple(sig.parameters.keys()) == expected_params
+
+    # Test function call with positive arguments
+    result = obj.function(*sample_args)
+    assert np.isfinite(result)
+    assert result > 0  # Should be positive for positive inputs
+
+
+@pytest.fixture
+def power_law_data():
+    """Generate synthetic power law data for testing."""
+    np.random.seed(42)
+    x = np.linspace(0.5, 5.0, 20)  # Avoid x=0 for power laws
+    A, b = 2.0, -1.5
+    noise = np.random.normal(0, 0.1, size=x.shape)
+    y = A * x**b + noise
+    # Ensure y stays positive for log stability
+    y = np.maximum(y, 0.01)
+    w = np.ones_like(x)
+    return x, y, w
+
+
+@pytest.mark.parametrize("cls", [PowerLaw, PowerLawPlusC, PowerLawOffCenter])
+def test_p0_zero_size_input(cls):
+    """Test p0 behavior with zero-size input arrays."""
+    x = np.array([])
+    y = np.array([])
+    obj = cls(x, y)
+
+    with pytest.raises((ValueError, AssertionError)):
+        _ = obj.p0
+
+
+def test_power_law_p0_estimation(power_law_data):
+    """Test initial parameter estimation for PowerLaw class."""
+    x, y, w = power_law_data
+    obj = PowerLaw(x, y)
+
+    p0 = obj.p0
+    assert len(p0) == 2
+    assert isinstance(p0[0], (int, float))  # A
+    assert isinstance(p0[1], (int, float))  # b
+
+
+def test_power_law_plus_c_p0_estimation(power_law_data):
+    """Test initial parameter estimation for PowerLawPlusC class."""
+    x, y, w = power_law_data
+    # Add constant offset
+    y_offset = y + 0.5
+    obj = PowerLawPlusC(x, y_offset)
+
+    p0 = obj.p0
+    assert len(p0) == 3
+    assert isinstance(p0[0], (int, float))  # A
+    assert isinstance(p0[1], (int, float))  # b
+    assert isinstance(p0[2], (int, float))  # c
+
+
+def test_power_law_off_center_p0_estimation(power_law_data):
+    """Test initial parameter estimation for PowerLawOffCenter class."""
+    x, y, w = power_law_data
+    obj = PowerLawOffCenter(x, y)
+
+    p0 = obj.p0
+    assert len(p0) == 3
+    assert isinstance(p0[0], (int, float))  # A
+    assert isinstance(p0[1], (int, float))  # b
+    assert isinstance(p0[2], (int, float))  # x0
+
+
+@pytest.mark.parametrize(
+    "cls, expected_tex",
+    [
+        (PowerLaw, r"f(x)=A x^b"),
+        (PowerLawPlusC, r"f(x)=A x^b + c"),
+        (PowerLawOffCenter, r"f(x)=A (x-x_0)^b"),
+    ],
+)
+def test_TeX_function_strings(cls, expected_tex):
+    """Test TeX function representation strings."""
+    x = np.array([1.0, 2.0, 4.0])
+    y = np.array([2.0, 1.0, 0.5])
+    obj = cls(x, y)
+    assert obj.TeX_function == expected_tex
+
+
+@pytest.mark.parametrize("cls", [PowerLaw, PowerLawPlusC, PowerLawOffCenter])
+def test_make_fit_success(cls, power_law_data):
+    """Test successful fitting for power law classes."""
+    x, y, w = power_law_data
+    obj = cls(x, y)
+
+    # Test fitting succeeds
+    obj.make_fit()
+
+    # Test fit results are available
+    assert obj.popt is not None
+    assert obj.pcov is not None
+    assert obj.chisq_dof is not None
+
+    # Test output shapes
+    assert len(obj.popt) == len(obj.p0)
+
+
+@pytest.mark.parametrize("cls", [PowerLaw, PowerLawPlusC, PowerLawOffCenter])
+def test_make_fit_insufficient_data(cls):
+    """Test fitting failure with insufficient data."""
+    x = np.array([1.0])  # Single point
+    y = np.array([1.0])
+    obj = cls(x, y)
+
+    # By default, make_fit returns exceptions rather than raising them
+    result = obj.make_fit()
+    assert isinstance(result, ValueError)
+    assert "insufficient data" in str(result).lower()
+
+
+def test_power_law_perfect_fit():
+    """Test PowerLaw with perfect power law data."""
+    x = np.array([1.0, 2.0, 4.0, 8.0])
+    A, b = 16.0, -2.0
+    y = A * x**b  # Perfect power law: 16, 4, 1, 0.25
+
+    obj = PowerLaw(x, y)
+    obj.make_fit()
+
+    # Should recover true parameters accurately
+    assert abs(obj.popt["A"] - A) < 1e-10  # A
+    assert abs(obj.popt["b"] - b) < 1e-10  # b
+
+    # Predicted values should match
+    y_pred = obj(x)
+    assert np.allclose(y_pred, y, rtol=1e-12)
+
+
+def test_power_law_plus_c_perfect_fit():
+    """Test PowerLawPlusC with perfect data."""
+    x = np.array([1.0, 2.0, 4.0, 8.0])
+    A, b, c = 16.0, -2.0, 2.0
+    y = A * x**b + c  # 18, 6, 3, 2.25
+
+    obj = PowerLawPlusC(x, y)
+    obj.make_fit()
+
+    # Should recover parameters accurately
+    assert abs(obj.popt["A"] - A) < 1e-10  # A
+    assert abs(obj.popt["b"] - b) < 1e-10  # b
+    assert abs(obj.popt["c"] - c) < 1e-10  # c
+
+    y_pred = obj(x)
+    assert np.allclose(y_pred, y, rtol=1e-12)
+
+
+def test_power_law_off_center_perfect_fit():
+    """Test PowerLawOffCenter with perfect data."""
+    x = np.array([2.0, 3.0, 5.0, 9.0])
+    A, b, x0 = 4.0, 2.0, 1.0
+    y = A * (x - x0) ** b  # 4*1^2, 4*2^2, 4*4^2, 4*8^2 = 4, 16, 64, 256
+
+    obj = PowerLawOffCenter(x, y)
+    obj.make_fit()
+
+    # Should recover parameters
+    assert abs(obj.popt["A"] - A) < 1e-10  # A
+    assert abs(obj.popt["b"] - b) < 1e-10  # b
+    assert abs(obj.popt["x0"] - x0) < 1e-10  # x0
+
+    y_pred = obj(x)
+    assert np.allclose(y_pred, y, rtol=1e-12)
+
+
+def test_power_law_numerical_stability():
+    """Test power law functions handle extreme values."""
+    x = np.array([0.1, 1.0, 10.0])
+    y = np.array([10.0, 1.0, 0.1])
+
+    obj = PowerLaw(x, y)
+
+    # Test with extreme parameters
+    result1 = obj.function(0.1, 1.0, -10.0)  # Very negative exponent
+    assert np.isfinite(result1)
+    assert result1 > 0
+
+    result2 = obj.function(10.0, 1.0, 0.1)  # Very small exponent
+    assert np.isfinite(result2)
+    assert result2 > 0
+
+
+def test_power_law_zero_handling():
+    """Test power law behavior with zero and near-zero values."""
+    x = np.array([0.01, 1.0, 100.0])  # Avoid exactly zero
+    y = np.array([1.0, 1.0, 1.0])
+
+    obj = PowerLaw(x, y)
+
+    # Test function behavior near zero
+    result = obj.function(0.01, 1.0, 1.0)
+    assert np.isfinite(result)
+
+    # Test with zero exponent (should give constant)
+    result_zero_exp = obj.function(2.0, 5.0, 0.0)
+    assert abs(result_zero_exp - 5.0) < 1e-10
+
+
+def test_power_law_off_center_centering():
+    """Test that PowerLawOffCenter properly handles centering."""
+    x = np.array([2.0, 3.0, 4.0, 5.0])
+    x0 = 1.5
+
+    obj = PowerLawOffCenter(x, np.ones_like(x))
+
+    # Test that centering works correctly
+    result = obj.function(x, 2.0, 1.0, x0)
+    expected = 2.0 * (x - x0) ** 1.0
+    assert np.allclose(result, expected)
+
+
+@pytest.mark.parametrize("cls", [PowerLaw, PowerLawPlusC, PowerLawOffCenter])
+def test_str_and_call_methods(cls, power_law_data):
+    """Test string representation and callable interface."""
+    x, y, w = power_law_data
+    obj = cls(x, y)
+    obj.make_fit()
+
+    # Test string representation
+    str_repr = str(obj)
+    assert cls.__name__ in str_repr
+
+    # Test callable interface
+    x_test = np.array([1.0, 2.0, 3.0])
+    y_pred = obj(x_test)
+    assert y_pred.shape == x_test.shape
+    assert np.all(np.isfinite(y_pred))
+    assert np.all(y_pred > 0)  # Power laws should be positive
+
+
+def test_power_law_with_weights(power_law_data):
+    """Test power law fitting with observation weights."""
+    x, y, w = power_law_data
+
+    # Create varying weights
+    w_varied = np.linspace(0.5, 2.0, len(x))
+
+    obj = PowerLaw(x, y, weights=w_varied)
+    obj.make_fit()
+
+    # Should complete successfully
+    assert obj.popt is not None
+    assert len(obj.popt) == 2
+
+
+def test_power_law_scaling_behavior():
+    """Test that PowerLaw exhibits proper scaling behavior."""
+    x = np.array([1.0, 2.0, 4.0, 8.0])
+    A, b = 2.0, -1.0
+    y = A * x**b
+
+    obj = PowerLaw(x, y)
+    obj.make_fit()
+
+    # Test scaling: if x doubles, y should change by factor of 2^b
+    x1, x2 = 2.0, 4.0
+    y1, y2 = obj(x1), obj(x2)
+    scaling_factor = y2 / y1
+    expected_factor = (x2 / x1) ** b
+
+    assert abs(scaling_factor - expected_factor) < 1e-8  # More realistic tolerance
+
+
+@pytest.mark.parametrize("cls", [PowerLaw, PowerLawPlusC, PowerLawOffCenter])
+def test_property_access_before_fit(cls):
+    """Test accessing properties before fitting."""
+    x = np.array([1.0, 2.0, 3.0])
+    y = np.array([2.0, 1.0, 0.5])
+    obj = cls(x, y)
+
+    # These should work before fitting
+    assert obj.TeX_function is not None
+    assert obj.p0 is not None
+
+    # These should raise AttributeError before fitting
+    with pytest.raises(AttributeError):
+        _ = obj.popt
+    with pytest.raises(AttributeError):
+        _ = obj.pcov
+
+
+def test_power_law_negative_x_handling():
+    """Test power law behavior with negative x values."""
+    # Only test with even exponents to avoid complex numbers
+    x = np.array([-2.0, -1.0, 1.0, 2.0])
+
+    obj = PowerLaw(x, np.ones_like(x))
+
+    # Test with even exponent
+    result_even = obj.function(x, 1.0, 2.0)  # x^2
+    assert np.all(np.isfinite(result_even))
+    assert np.all(result_even > 0)
+
+    # Test symmetry for even powers
+    assert abs(result_even[0] - result_even[3]) < 1e-10  # (-2)^2 = 2^2
+    assert abs(result_even[1] - result_even[2]) < 1e-10  # (-1)^2 = 1^2
+
+
+def test_power_law_integer_vs_float_exponents():
+    """Test that integer and float exponents give consistent results."""
+    x = np.array([1.0, 2.0, 3.0])
+    A = 2.0
+
+    obj = PowerLaw(x, np.ones_like(x))
+
+    # Test integer vs float exponent
+    result_int = obj.function(x, A, 2)  # Integer exponent
+    result_float = obj.function(x, A, 2.0)  # Float exponent
+
+    assert np.allclose(result_int, result_float, rtol=1e-15)
+
+
+def test_power_law_edge_case_exponents():
+    """Test power laws with edge case exponent values."""
+    x = np.array([1.0, 2.0, 4.0])
+    obj = PowerLaw(x, np.ones_like(x))
+
+    # Test with b = 1 (linear)
+    result_linear = obj.function(x, 3.0, 1.0)
+    expected_linear = 3.0 * x
+    assert np.allclose(result_linear, expected_linear)
+
+    # Test with b = 0 (constant)
+    result_constant = obj.function(x, 5.0, 0.0)
+    assert np.all(result_constant == 5.0)
+
+    # Test with b = -1 (inverse)
+    result_inverse = obj.function(x, 2.0, -1.0)
+    expected_inverse = 2.0 / x
+    assert np.allclose(result_inverse, expected_inverse)