pvlib 0.10.5__py3-none-any.whl → 0.11.0a1__py3-none-any.whl

pvlib/tests/test_shading.py

@@ -2,11 +2,12 @@ import numpy as np
 import pandas as pd
 
 from pandas.testing import assert_series_equal
-from numpy.testing import assert_allclose
+from numpy.testing import assert_allclose, assert_approx_equal
 import pytest
 from datetime import timezone, timedelta
 
 from pvlib import shading
+from pvlib.tools import atand
 
 
 @pytest.fixture
@@ -223,3 +224,168 @@ def test_projected_solar_zenith_angle_datatypes(
     )
     psz = psz_func(sun_apparent_zenith, axis_azimuth, axis_tilt, axis_azimuth)
     assert isinstance(psz, cast_type)
+
+
+@pytest.fixture
+def sf1d_premises_and_expected():
+    """Data comprised of solar position, rows parameters and terrain slope
+    with respective shade fractions (sf). Returns a 2-tuple with the premises
+    to be used directly in shaded_fraction1d(...) in the first element and
+    the expected shaded fractions in the second element.
+    See [1] in shaded_fraction1d()
+    Test data sourced from http://doi.org/10.5281/zenodo.10513987
+    """
+    test_data = pd.DataFrame(
+        columns=["x_L", "z_L", "theta_L", "x_R", "z_R", "theta_R", "z_0", "l",
+                 "theta_s", "f_s"],
+        data=(
+            (1, 0.2,  50, 0,   0,  25,    0, 0.5,  80, 1),
+            (1, 0.1,  50, 0,   0,  25, 0.05, 0.5,  80, 0.937191),
+            (1,   0,  50, 0, 0.1,  25,    0, 0.5,  80, 0.30605),
+            (1,   0,  50, 0, 0.2,  25,    0, 0.5,  80, 0),
+            (1, 0.2, -25, 0,   0, -50,    0, 0.5, -80, 0),
+            (1, 0.1, -25, 0,   0, -50,    0, 0.5, -80, 0.30605),
+            (1,   0, -25, 0, 0.1, -50,  0.1, 0.5, -80, 0.881549),
+            (1,   0, -25, 0, 0.2, -50,    0, 0.5, -80, 1),
+            (1, 0.2,   5, 0,   0,  25, 0.05, 0.5,  80, 0.832499),
+            (1, 0.2, -25, 0,   0,  25, 0.05, 0.5,  80, 0.832499),
+            (1, 0.2,   5, 0,   0, -45, 0.05, 0.5,  80, 0.832499),
+            (1, 0.2, -25, 0,   0, -45, 0.05, 0.5,  80, 0.832499),
+            (1,   0, -25, 0, 0.2,  25, 0.05, 0.5, -80, 0.832499),
+            (1,   0, -25, 0, 0.2,  -5, 0.05, 0.5, -80, 0.832499),
+            (1,   0,  45, 0, 0.2,  25, 0.05, 0.5, -80, 0.832499),
+            (1,   0,  45, 0, 0.2,  -5, 0.05, 0.5, -80, 0.832499),
+        ),
+    )  # fmt: skip
+
+    test_data["cross_axis_slope"] = atand(
+        (test_data["z_R"] - test_data["z_L"])
+        / (test_data["x_L"] - test_data["x_R"])
+    )
+    test_data["pitch"] = test_data["x_L"] - test_data["x_R"]
+    # switch Left/Right rows if needed to make the right one the shaded
+    where_switch = test_data["theta_s"] >= 0
+    test_data["theta_L"], test_data["theta_R"] = np.where(
+        where_switch,
+        (test_data["theta_L"], test_data["theta_R"]),
+        (test_data["theta_R"], test_data["theta_L"]),
+    )
+    test_data.rename(
+        columns={
+            "theta_L": "shading_row_rotation",
+            "theta_R": "shaded_row_rotation",
+            "z_0": "surface_to_axis_offset",
+            "l": "collector_width",
+            "theta_s": "solar_zenith",  # for the projected solar zenith angle
+            "f_s": "shaded_fraction",
+        },
+        inplace=True,
+    )
+    test_data.drop(columns=["x_L", "z_L", "x_R", "z_R"], inplace=True)
+    # for the projected solar zenith angle
+    # this returns the same psz angle as test_data["solar_zenith"]
+    test_data["solar_azimuth"], test_data["axis_azimuth"] = 180, 90
+
+    # return 1st: premises dataframe first and 2nd: shaded fraction series
+    return (
+        test_data.drop(columns=["shaded_fraction"]),
+        test_data["shaded_fraction"],
+    )
+
+
+def test_shaded_fraction1d(sf1d_premises_and_expected):
+    """Tests shaded_fraction1d"""
+    # unwrap sf_premises_and_expected values premises and expected results
+    premises, expected_sf_array = sf1d_premises_and_expected
+    # test scalar input
+    expected_result = expected_sf_array.iloc[0]
+    sf = shading.shaded_fraction1d(**premises.iloc[0])
+    assert_approx_equal(sf, expected_result)
+    assert isinstance(sf, float)
+
+    # test Series inputs
+    sf_vec = shading.shaded_fraction1d(**premises)
+    assert_allclose(sf_vec, expected_sf_array, atol=1e-6)
+    assert isinstance(sf_vec, pd.Series)
+
+
+def test_shaded_fraction1d_unprovided_shading_row_rotation():
+    """Tests shaded_fraction1d without providing shading_row_rotation"""
+    test_data = pd.DataFrame(
+        columns=[
+            "shaded_row_rotation", "surface_to_axis_offset", "collector_width",
+            "solar_zenith", "cross_axis_slope", "pitch", "solar_azimuth",
+            "axis_azimuth", "expected_sf",
+        ],
+        data=[
+            (30, 0, 5.7735, 60, 0, 5, 90, 180, 0),
+            (30, 0, 5.7735, 79, 0, 5, 90, 180, 0.5),
+            (30, 0, 5.7735, 90, 0, 5, 90, 180, 1),
+        ],
+    )  # fmt: skip
+    expected_sf = test_data["expected_sf"]
+    premises = test_data.drop(columns=["expected_sf"])
+    sf = shading.shaded_fraction1d(**premises)
+    assert_allclose(sf, expected_sf, atol=1e-2)
+
+
+@pytest.fixture
+def direct_martinez_Table2():
+    """
+    Original data used in [1] (see pvlib.shading.direct_martinez) to validate
+    the model. Some of the data is provided in Table 2.
+    Returns tuple with (input: pandas.DataFrame, output: pandas.Series)
+    Output is power loss: 1 - (P_shaded / P_unshaded)
+    """
+    test_data = pd.DataFrame(
+        columns=[
+            "F_GS-H",
+            "F_GS-V",
+            "shaded_blocks",
+            "poa_direct",
+            "poa_diffuse",
+            "power_loss_model",
+        ],
+        data=[
+            # F-H, F-V, Nsb, direct, diffuse, power_loss
+            # original data sourced from researchers
+            [1.00, 0.09, 16, 846.59, 59.42, 0.8844],
+            [1.00, 0.18, 16, 841.85, 59.69, 0.8888],
+            [1.00, 0.36, 16, 843.38, 59.22, 0.8994],
+            [0.04, 0.64,  1, 851.90, 59.40, 0.0783],
+            [0.17, 0.45,  3, 862.86, 58.40, 0.2237],
+            [0.29, 0.27,  5, 864.14, 58.11, 0.3282],
+            [0.50, 0.09,  8, 863.23, 58.31, 0.4634],
+            [0.13, 1.00,  2, 870.14, 58.02, 0.2137],
+            [0.25, 1.00,  4, 876.57, 57.98, 0.4000],
+            [0.38, 1.00,  6, 866.86, 58.89, 0.5577],
+            [0.50, 1.00,  8, 874.58, 58.44, 0.6892],
+            [0.58, 0.82, 10, 876.80, 58.16, 0.7359],
+            [0.75, 0.73, 12, 866.89, 58.73, 0.8113],
+            [0.92, 0.64, 15, 861.48, 59.66, 0.8894],
+            # custom edge cases
+            [0.00, 0.00,  0, 800.00, 50.00, 0.0000],
+            [1.00, 1.00, 16, 900.00, 00.00, 1.0000],
+            [0.00, 1.00, 16, 000.00, 00.00, np.nan],
+            [1.00, 0.00,  0, 000.00, 00.00, np.nan],
+            [1.00, 0.00,  0, -50.00, 50.00, np.nan],  # zero poa_global
+            [1.00, 0.00,  0, 50.00, -50.00, np.nan],  # zero poa_global
+        ]
+    )  # fmt: skip
+    test_data["total_blocks"] = 16  # total blocks is 16 for all cases
+    test_data["shaded_fraction"] = test_data["F_GS-H"] * test_data["F_GS-V"]
+    test_data["poa_global"] = (
+        test_data["poa_direct"] + test_data["poa_diffuse"]
+    )
+    test_data = test_data.drop(columns=["F_GS-H", "F_GS-V", "poa_diffuse"])
+    return (
+        test_data.drop(columns="power_loss_model"),
+        test_data["power_loss_model"],
+    )
+
+
+def test_direct_martinez(direct_martinez_Table2):
+    """Tests pvlib.shading.direct_martinez"""
+    test_data, power_losses_expected = direct_martinez_Table2
+    power_losses = shading.direct_martinez(**test_data)
+    assert_allclose(power_losses, power_losses_expected, atol=5e-3)

pvlib/tests/test_singlediode.py

@@ -8,7 +8,6 @@ import scipy
 from pvlib import pvsystem
 from pvlib.singlediode import (bishop88_mpp, estimate_voc, VOLTAGE_BUILTIN,
                                bishop88, bishop88_i_from_v, bishop88_v_from_i)
-from pvlib._deprecation import pvlibDeprecationWarning
 import pytest
 from numpy.testing import assert_array_equal
 from .conftest import DATA_DIR
@@ -188,24 +187,6 @@ def test_singlediode_lambert_negative_voc(mocker):
     assert_array_equal(outs["v_oc"], [0, 0])
 
 
-@pytest.mark.parametrize('method', ['lambertw'])
-def test_ivcurve_pnts_precision(method, precise_iv_curves):
-    """
-    Tests the accuracy of the IV curve points calcuated by singlediode. Only
-    methods of singlediode that linearly spaced points are tested.
-    """
-    x, pc = precise_iv_curves
-    pc_i, pc_v = np.stack(pc['Currents']), np.stack(pc['Voltages'])
-    ivcurve_pnts = len(pc['Currents'][0])
-
-    with pytest.warns(pvlibDeprecationWarning, match='ivcurve_pnts'):
-        outs = pvsystem.singlediode(method=method, ivcurve_pnts=ivcurve_pnts,
-                                    **x)
-
-    assert np.allclose(pc_i, outs['i'], atol=1e-10, rtol=0)
-    assert np.allclose(pc_v, outs['v'], atol=1e-10, rtol=0)
-
-
 @pytest.mark.parametrize('method', ['lambertw', 'brentq', 'newton'])
 def test_v_from_i_i_from_v_precision(method, precise_iv_curves):
     """

pvlib/tests/test_spectrum.py

@@ -3,11 +3,13 @@ from numpy.testing import assert_allclose, assert_approx_equal, assert_equal
 import pandas as pd
 import numpy as np
 from pvlib import spectrum
+from pvlib._deprecation import pvlibDeprecationWarning
 
-from .conftest import DATA_DIR, assert_series_equal
+from .conftest import DATA_DIR, assert_series_equal, fail_on_pvlib_version
 
 SPECTRL2_TEST_DATA = DATA_DIR / 'spectrl2_example_spectra.csv'
 
+
 @pytest.fixture
 def spectrl2_data():
     # reference spectra generated with solar_utils==0.3
@@ -123,24 +125,75 @@ def test_get_example_spectral_response():
     assert_allclose(sr, expected, rtol=1e-5)
 
 
+@fail_on_pvlib_version('0.12')
 def test_get_am15g():
     # test that the reference spectrum is read and interpolated correctly
-    e = spectrum.get_am15g()
+    with pytest.warns(pvlibDeprecationWarning,
+                      match="get_reference_spectra instead"):
+        e = spectrum.get_am15g()
     assert_equal(len(e), 2002)
     assert_equal(np.sum(e.index), 2761442)
     assert_approx_equal(np.sum(e), 1002.88, significant=6)
 
-    wavelength = [270, 850, 950, 1200, 4001]
-    expected = [0.0, 0.893720, 0.147260, 0.448250, 0.0]
+    wavelength = [270, 850, 950, 1200, 1201.25, 4001]
+    expected = [0.0, 0.893720, 0.147260, 0.448250, 0.4371025, 0.0]
 
-    e = spectrum.get_am15g(wavelength)
+    with pytest.warns(pvlibDeprecationWarning,
+                      match="get_reference_spectra instead"):
+        e = spectrum.get_am15g(wavelength)
     assert_equal(len(e), len(wavelength))
     assert_allclose(e, expected, rtol=1e-6)
 
 
+@pytest.mark.parametrize(
+    "reference_identifier,expected_sums",
+    [
+        (
+            "ASTM G173-03",  # reference_identifier
+            {  # expected_sums
+                "extraterrestrial": 1356.15,
+                "global": 1002.88,
+                "direct": 887.65,
+            },
+        ),
+    ],
+)
+def test_get_reference_spectra(reference_identifier, expected_sums):
+    # test reading of a standard spectrum
+    standard = spectrum.get_reference_spectra(standard=reference_identifier)
+    assert set(standard.columns) == expected_sums.keys()
+    assert standard.index.name == "wavelength"
+    assert standard.index.is_monotonic_increasing is True
+    expected_sums = pd.Series(expected_sums)  # convert prior to comparison
+    assert_series_equal(np.sum(standard, axis=0), expected_sums, atol=1e-2)
+
+
+def test_get_reference_spectra_custom_wavelengths():
+    # test that the spectrum is interpolated correctly when custom wavelengths
+    # are specified
+    # only checked for ASTM G173-03 reference spectrum
+    wavelength = [270, 850, 951.634, 1200, 4001]
+    expected_sums = pd.Series(
+        {"extraterrestrial": 2.23266, "global": 1.68952, "direct": 1.58480}
+    )  # for given ``wavelength``
+    standard = spectrum.get_reference_spectra(
+        wavelength, standard="ASTM G173-03"
+    )
+    assert_equal(len(standard), len(wavelength))
+    # check no NaN values were returned
+    assert not standard.isna().any().any()  # double any to return one value
+    assert_series_equal(np.sum(standard, axis=0), expected_sums, atol=1e-4)
+
+
+def test_get_reference_spectra_invalid_reference():
+    # test that an invalid reference identifier raises a ValueError
+    with pytest.raises(ValueError, match="Invalid standard identifier"):
+        spectrum.get_reference_spectra(standard="invalid")
+
+
 def test_calc_spectral_mismatch_field(spectrl2_data):
     # test that the mismatch is calculated correctly with
-    # - default and custom reference sepctrum
+    # - default and custom reference spectrum
     # - single or multiple sun spectra
 
     # sample data
@@ -148,7 +201,7 @@ def test_calc_spectral_mismatch_field(spectrl2_data):
     e_sun = e_sun.set_index('wavelength')
     e_sun = e_sun.transpose()
 
-    e_ref = spectrum.get_am15g()
+    e_ref = spectrum.get_reference_spectra(standard='ASTM G173-03')["global"]
     sr = spectrum.get_example_spectral_response()
 
     # test with single sun spectrum, same as ref spectrum
@@ -175,25 +228,25 @@ def test_calc_spectral_mismatch_field(spectrl2_data):
 
 @pytest.mark.parametrize("module_type,expect", [
     ('cdte', np.array(
-        [[ 0.99051020, 0.97640320, 0.93975028],
-         [ 1.02928735, 1.01881074, 0.98578821],
-         [ 1.04750335, 1.03814456, 1.00623986]])),
+        [[0.99051020, 0.97640320, 0.93975028],
+         [1.02928735, 1.01881074, 0.98578821],
+         [1.04750335, 1.03814456, 1.00623986]])),
     ('monosi', np.array(
-        [[ 0.97769770, 1.02043409, 1.03574032],
-         [ 0.98630905, 1.03055092, 1.04736262],
-         [ 0.98828494, 1.03299036, 1.05026561]])),
+        [[0.97769770, 1.02043409, 1.03574032],
+         [0.98630905, 1.03055092, 1.04736262],
+         [0.98828494, 1.03299036, 1.05026561]])),
     ('polysi', np.array(
-        [[ 0.97704080, 1.01705849, 1.02613202],
-         [ 0.98992828, 1.03173953, 1.04260662],
-         [ 0.99352435, 1.03588785, 1.04730718]])),
+        [[0.97704080, 1.01705849, 1.02613202],
+         [0.98992828, 1.03173953, 1.04260662],
+         [0.99352435, 1.03588785, 1.04730718]])),
     ('cigs', np.array(
-        [[ 0.97459190, 1.02821696, 1.05067895],
-         [ 0.97529378, 1.02967497, 1.05289307],
-         [ 0.97269159, 1.02730558, 1.05075651]])),
+        [[0.97459190, 1.02821696, 1.05067895],
+         [0.97529378, 1.02967497, 1.05289307],
+         [0.97269159, 1.02730558, 1.05075651]])),
     ('asi', np.array(
-        [[ 1.05552750, 0.87707583, 0.72243772],
-         [ 1.11225204, 0.93665901, 0.78487953],
-         [ 1.14555295, 0.97084011, 0.81994083]]))
+        [[1.05552750, 0.87707583, 0.72243772],
+         [1.11225204, 0.93665901, 0.78487953],
+         [1.14555295, 0.97084011, 0.81994083]]))
 ])
 def test_spectral_factor_firstsolar(module_type, expect):
     ams = np.array([1, 3, 5])
@@ -315,3 +368,211 @@ def test_spectral_factor_caballero_supplied_ambiguous():
     with pytest.raises(ValueError):
         spectrum.spectral_factor_caballero(1, 1, 1, module_type=None,
                                            coefficients=None)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('asi', np.array([1.15534029, 1.1123772, 1.08286684, 1.01915462])),
+    ('fs-2', np.array([1.0694323, 1.04948777, 1.03556288, 0.9881471])),
+    ('fs-4', np.array([1.05234725, 1.037771, 1.0275516, 0.98820533])),
+    ('multisi', np.array([1.03310403, 1.02391703, 1.01744833, 0.97947605])),
+    ('monosi', np.array([1.03225083, 1.02335353, 1.01708734, 0.97950110])),
+    ('cigs', np.array([1.01475834, 1.01143927, 1.00909094, 0.97852966])),
+])
+def test_spectral_factor_pvspec(module_type, expected):
+    ams = np.array([1.0, 1.5, 2.0, 1.5])
+    kcs = np.array([0.4, 0.6, 0.8, 1.4])
+    out = spectrum.spectral_factor_pvspec(ams, kcs,
+                                          module_type=module_type)
+    assert np.allclose(expected, out, atol=1e-8)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('asi', pd.Series([1.15534029, 1.1123772, 1.08286684, 1.01915462])),
+    ('fs-2', pd.Series([1.0694323, 1.04948777, 1.03556288, 0.9881471])),
+    ('fs-4', pd.Series([1.05234725, 1.037771, 1.0275516, 0.98820533])),
+    ('multisi', pd.Series([1.03310403, 1.02391703, 1.01744833, 0.97947605])),
+    ('monosi', pd.Series([1.03225083, 1.02335353, 1.01708734, 0.97950110])),
+    ('cigs', pd.Series([1.01475834, 1.01143927, 1.00909094, 0.97852966])),
+])
+def test_spectral_factor_pvspec_series(module_type, expected):
+    ams = pd.Series([1.0, 1.5, 2.0, 1.5])
+    kcs = pd.Series([0.4, 0.6, 0.8, 1.4])
+    out = spectrum.spectral_factor_pvspec(ams, kcs,
+                                          module_type=module_type)
+    assert isinstance(out, pd.Series)
+    assert np.allclose(expected, out, atol=1e-8)
+
+
+def test_spectral_factor_pvspec_supplied():
+    # use the multisi coeffs
+    coeffs = (0.9847, -0.05237, 0.03034)
+    out = spectrum.spectral_factor_pvspec(1.5, 0.8, coefficients=coeffs)
+    expected = 1.00860641
+    assert_allclose(out, expected, atol=1e-8)
+
+
+def test_spectral_factor_pvspec_supplied_redundant():
+    # Error when specifying both module_type and coefficients
+    coeffs = (0.9847, -0.05237, 0.03034)
+    with pytest.raises(ValueError, match='supply only one of'):
+        spectrum.spectral_factor_pvspec(1.5, 0.8, module_type='multisi',
+                                        coefficients=coeffs)
+
+
+def test_spectral_factor_pvspec_supplied_ambiguous():
+    # Error when specifying neither module_type nor coefficients
+    with pytest.raises(ValueError, match='No valid input provided'):
+        spectrum.spectral_factor_pvspec(1.5, 0.8, module_type=None,
+                                        coefficients=None)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('multisi', np.array([1.06129, 1.03098, 1.01155, 0.99849])),
+    ('cdte', np.array([1.09657,  1.05594, 1.02763, 0.97740])),
+])
+def test_spectral_factor_jrc(module_type, expected):
+    ams = np.array([1.0, 1.5, 2.0, 1.5])
+    kcs = np.array([0.4, 0.6, 0.8, 1.4])
+    out = spectrum.spectral_factor_jrc(ams, kcs,
+                                       module_type=module_type)
+    assert np.allclose(expected, out, atol=1e-4)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('multisi', np.array([1.06129, 1.03098, 1.01155, 0.99849])),
+    ('cdte', np.array([1.09657,  1.05594, 1.02763, 0.97740])),
+])
+def test_spectral_factor_jrc_series(module_type, expected):
+    ams = pd.Series([1.0, 1.5, 2.0, 1.5])
+    kcs = pd.Series([0.4, 0.6, 0.8, 1.4])
+    out = spectrum.spectral_factor_jrc(ams, kcs,
+                                       module_type=module_type)
+    assert isinstance(out, pd.Series)
+    assert np.allclose(expected, out, atol=1e-4)
+
+
+def test_spectral_factor_jrc_supplied():
+    # use the multisi coeffs
+    coeffs = (0.494, 0.146, 0.00103)
+    out = spectrum.spectral_factor_jrc(1.0, 0.8, coefficients=coeffs)
+    expected = 1.01052106
+    assert_allclose(out, expected, atol=1e-4)
+
+
+def test_spectral_factor_jrc_supplied_redundant():
+    # Error when specifying both module_type and coefficients
+    coeffs = (0.494, 0.146, 0.00103)
+    with pytest.raises(ValueError, match='supply only one of'):
+        spectrum.spectral_factor_jrc(1.0, 0.8, module_type='multisi',
+                                     coefficients=coeffs)
+
+
+def test_spectral_factor_jrc_supplied_ambiguous():
+    # Error when specifying neither module_type nor coefficients
+    with pytest.raises(ValueError, match='No valid input provided'):
+        spectrum.spectral_factor_jrc(1.0, 0.8, module_type=None,
+                                     coefficients=None)
+
+
+@pytest.fixture
+def sr_and_eqe_fixture():
+    # Just some arbitrary data for testing the conversion functions
+    df = pd.DataFrame(
+        columns=("wavelength", "quantum_efficiency", "spectral_response"),
+        data=[
+            # nm, [0,1], A/W
+            [300, 0.85, 0.205671370402405],
+            [350, 0.86, 0.242772872514211],
+            [400, 0.87, 0.280680929019753],
+            [450, 0.88, 0.319395539919029],
+            [500, 0.89, 0.358916705212040],
+            [550, 0.90, 0.399244424898786],
+            [600, 0.91, 0.440378698979267],
+            [650, 0.92, 0.482319527453483],
+            [700, 0.93, 0.525066910321434],
+            [750, 0.94, 0.568620847583119],
+            [800, 0.95, 0.612981339238540],
+            [850, 0.90, 0.617014111207215],
+            [900, 0.80, 0.580719163489143],
+            [950, 0.70, 0.536358671833723],
+            [1000, 0.6, 0.483932636240953],
+            [1050, 0.4, 0.338752845368667],
+        ],
+    )
+    df.set_index("wavelength", inplace=True)
+    return df
+
+
+def test_sr_to_qe(sr_and_eqe_fixture):
+    # vector type
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"].values,
+        sr_and_eqe_fixture.index.values,  # wavelength, nm
+    )
+    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])
+    # pandas series type
+    # note: output Series' name should match the input
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"]
+    )
+    pd.testing.assert_series_equal(
+        qe, sr_and_eqe_fixture["quantum_efficiency"],
+        check_names=False
+    )
+    assert qe.name == "spectral_response"
+    # series normalization
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"] * 10, normalize=True
+    )
+    pd.testing.assert_series_equal(
+        qe,
+        sr_and_eqe_fixture["quantum_efficiency"]
+        / max(sr_and_eqe_fixture["quantum_efficiency"]),
+        check_names=False,
+    )
+    # error on lack of wavelength parameter if no pandas object is provided
+    with pytest.raises(TypeError, match="must have an '.index' attribute"):
+        _ = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"].values)
+
+
+def test_qe_to_sr(sr_and_eqe_fixture):
+    # vector type
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"].values,
+        sr_and_eqe_fixture.index.values,  # wavelength, nm
+    )
+    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
+    # pandas series type
+    # note: output Series' name should match the input
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"]
+    )
+    pd.testing.assert_series_equal(
+        sr, sr_and_eqe_fixture["spectral_response"],
+        check_names=False
+    )
+    assert sr.name == "quantum_efficiency"
+    # series normalization
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"] * 10, normalize=True
+    )
+    pd.testing.assert_series_equal(
+        sr,
+        sr_and_eqe_fixture["spectral_response"]
+        / max(sr_and_eqe_fixture["spectral_response"]),
+        check_names=False,
+    )
+    # error on lack of wavelength parameter if no pandas object is provided
+    with pytest.raises(TypeError, match="must have an '.index' attribute"):
+        _ = spectrum.qe_to_sr(
+            sr_and_eqe_fixture["quantum_efficiency"].values
+        )
+
+
+def test_qe_and_sr_reciprocal_conversion(sr_and_eqe_fixture):
+    # test that the conversion functions are reciprocal
+    qe = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"])
+    sr = spectrum.qe_to_sr(qe)
+    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
+    qe = spectrum.sr_to_qe(sr)
+    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])

pvlib/tests/test_temperature.py

@@ -20,13 +20,13 @@ def sapm_default():
 def test_sapm_cell(sapm_default):
     default = temperature.sapm_cell(900, 20, 5, sapm_default['a'],
                                     sapm_default['b'], sapm_default['deltaT'])
-    assert_allclose(default, 43.509, 3)
+    assert_allclose(default, 43.509, 1e-3)
 
 
 def test_sapm_module(sapm_default):
     default = temperature.sapm_module(900, 20, 5, sapm_default['a'],
                                       sapm_default['b'])
-    assert_allclose(default, 40.809, 3)
+    assert_allclose(default, 40.809, 1e-3)
 
 
 def test_sapm_cell_from_module(sapm_default):
@@ -47,8 +47,8 @@ def test_sapm_ndarray(sapm_default):
                                            sapm_default['b'])
     expected_cell = np.array([0., 23.06066166, 5.])
     expected_module = np.array([0., 21.56066166, 5.])
-    assert_allclose(expected_cell, cell_temps, 3)
-    assert_allclose(expected_module, module_temps, 3)
+    assert_allclose(expected_cell, cell_temps, 1e-3)
+    assert_allclose(expected_module, module_temps, 1e-3)
 
 
 def test_sapm_series(sapm_default):
@@ -84,8 +84,8 @@ def test_pvsyst_cell_ndarray():
     irrads = np.array([0, 500, 0])
     winds = np.array([10, 5, 0])
     result = temperature.pvsyst_cell(irrads, temps, wind_speed=winds)
-    expected = np.array([0.0, 23.96551, 5.0])
-    assert_allclose(expected, result, 3)
+    expected = np.array([0.0, 23.965517, 5.0])
+    assert_allclose(expected, result)
 
 
 def test_pvsyst_cell_series():
@@ -95,7 +95,7 @@ def test_pvsyst_cell_series():
     winds = pd.Series([10, 5, 0], index=times)
 
     result = temperature.pvsyst_cell(irrads, temps, wind_speed=winds)
-    expected = pd.Series([0.0, 23.96551, 5.0], index=times)
+    expected = pd.Series([0.0, 23.965517, 5.0], index=times)
     assert_series_equal(expected, result)
 
 

pvlib/tests/test_tools.py

@@ -3,6 +3,7 @@ import pytest
 from pvlib import tools
 import numpy as np
 import pandas as pd
+from numpy.testing import assert_allclose
 
 
 @pytest.mark.parametrize('keys, input_dict, expected', [
@@ -120,3 +121,26 @@ def test_get_pandas_index(args, args_idx):
         assert index is None
     else:
         pd.testing.assert_index_equal(args[args_idx].index, index)
+
+
+@pytest.mark.parametrize('data_in,expected', [
+    (np.array([1, 2, 3, 4, 5]),
+     np.array([0.2, 0.4, 0.6, 0.8, 1])),
+    (np.array([[0, 1, 2], [0, 3, 6]]),
+     np.array([[0, 0.5, 1], [0, 0.5, 1]])),
+    (pd.Series([1, 2, 3, 4, 5]),
+     pd.Series([0.2, 0.4, 0.6, 0.8, 1])),
+    (pd.DataFrame({"a": [0, 1, 2], "b": [0, 2, 8]}),
+     pd.DataFrame({"a": [0, 0.5, 1], "b": [0, 0.25, 1]})),
+    # test with NaN and all zeroes
+    (pd.DataFrame({"a": [0, np.nan, 1], "b": [0, 0, 0]}),
+     pd.DataFrame({"a": [0, np.nan, 1], "b": [np.nan]*3})),
+    # test with negative values
+    (np.array([1, 2, -3, 4, -5]),
+     np.array([0.2, 0.4, -0.6, 0.8, -1])),
+    (pd.Series([-2, np.nan, 1]),
+     pd.Series([-1, np.nan, 0.5])),
+])
+def test_normalize_max2one(data_in, expected):
+    result = tools.normalize_max2one(data_in)
+    assert_allclose(result, expected)