pvlib 0.9.5__py3-none-any.whl → 0.10.0__py3-none-any.whl

pvlib/tests/test_shading.py

@@ -7,6 +7,34 @@ import pytest
 from pvlib import shading
 
 
+@pytest.fixture
+def test_system():
+    syst = {'height': 1.0,
+            'pitch': 2.,
+            'surface_tilt': 30.,
+            'surface_azimuth': 180.,
+            'rotation': -30.}  # rotation of right edge relative to horizontal
+    syst['gcr'] = 1.0 / syst['pitch']
+    return syst
+
+
+def test__ground_angle(test_system):
+    ts = test_system
+    x = np.array([0., 0.5, 1.0])
+    angles = shading.ground_angle(
+        ts['surface_tilt'], ts['gcr'], x)
+    expected_angles = np.array([0., 5.866738789543952, 9.896090638982903])
+    assert np.allclose(angles, expected_angles)
+
+
+def test__ground_angle_zero_gcr():
+    surface_tilt = 30.0
+    x = np.array([0.0, 0.5, 1.0])
+    angles = shading.ground_angle(surface_tilt, 0, x)
+    expected_angles = np.array([0, 0, 0])
+    assert np.allclose(angles, expected_angles)
+
+
 @pytest.fixture
 def surface_tilt():
     idx = pd.date_range('2019-01-01', freq='h', periods=3)

pvlib/tests/test_singlediode.py

@@ -8,6 +8,7 @@ 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 .conftest import DATA_DIR
 
@@ -25,22 +26,16 @@ def test_method_spr_e20_327(method, cec_module_spr_e20_327):
         I_L_ref=spr_e20_327['I_L_ref'], I_o_ref=spr_e20_327['I_o_ref'],
         R_sh_ref=spr_e20_327['R_sh_ref'], R_s=spr_e20_327['R_s'],
         EgRef=1.121, dEgdT=-0.0002677)
-    il, io, rs, rsh, nnsvt = x
     pvs = pvsystem.singlediode(*x, method='lambertw')
     out = pvsystem.singlediode(*x, method=method)
-    isc, voc, imp, vmp, pmp, ix, ixx = out.values()
-    assert np.isclose(pvs['i_sc'], isc)
-    assert np.isclose(pvs['v_oc'], voc)
-    # the singlediode method doesn't actually get the MPP correct
-    pvs_imp = pvsystem.i_from_v(rsh, rs, nnsvt, vmp, io, il, method='lambertw')
-    pvs_vmp = pvsystem.v_from_i(rsh, rs, nnsvt, imp, io, il, method='lambertw')
-    assert np.isclose(pvs_imp, imp)
-    assert np.isclose(pvs_vmp, vmp)
-    assert np.isclose(pvs['p_mp'], pmp)
-    assert np.isclose(pvs['i_x'], ix)
-    pvs_ixx = pvsystem.i_from_v(rsh, rs, nnsvt, (voc + vmp)/2, io, il,
-                                method='lambertw')
-    assert np.isclose(pvs_ixx, ixx)
+
+    assert np.isclose(pvs['i_sc'], out['i_sc'])
+    assert np.isclose(pvs['v_oc'], out['v_oc'])
+    assert np.isclose(pvs['i_mp'], out['i_mp'])
+    assert np.isclose(pvs['v_mp'], out['v_mp'])
+    assert np.isclose(pvs['p_mp'], out['p_mp'])
+    assert np.isclose(pvs['i_x'], out['i_x'])
+    assert np.isclose(pvs['i_xx'], out['i_xx'])
 
 
 @pytest.mark.parametrize('method', ['brentq', 'newton'])
@@ -53,23 +48,16 @@ def test_newton_fs_495(method, cec_module_fs_495):
         I_L_ref=fs_495['I_L_ref'], I_o_ref=fs_495['I_o_ref'],
         R_sh_ref=fs_495['R_sh_ref'], R_s=fs_495['R_s'],
         EgRef=1.475, dEgdT=-0.0003)
-    il, io, rs, rsh, nnsvt = x
-    x += (101, )
     pvs = pvsystem.singlediode(*x, method='lambertw')
     out = pvsystem.singlediode(*x, method=method)
-    isc, voc, imp, vmp, pmp, ix, ixx, i, v = out.values()
-    assert np.isclose(pvs['i_sc'], isc)
-    assert np.isclose(pvs['v_oc'], voc)
-    # the singlediode method doesn't actually get the MPP correct
-    pvs_imp = pvsystem.i_from_v(rsh, rs, nnsvt, vmp, io, il, method='lambertw')
-    pvs_vmp = pvsystem.v_from_i(rsh, rs, nnsvt, imp, io, il, method='lambertw')
-    assert np.isclose(pvs_imp, imp)
-    assert np.isclose(pvs_vmp, vmp)
-    assert np.isclose(pvs['p_mp'], pmp)
-    assert np.isclose(pvs['i_x'], ix)
-    pvs_ixx = pvsystem.i_from_v(rsh, rs, nnsvt, (voc + vmp)/2, io, il,
-                                method='lambertw')
-    assert np.isclose(pvs_ixx, ixx)
+
+    assert np.isclose(pvs['i_sc'], out['i_sc'])
+    assert np.isclose(pvs['v_oc'], out['v_oc'])
+    assert np.isclose(pvs['i_mp'], out['i_mp'])
+    assert np.isclose(pvs['v_mp'], out['v_mp'])
+    assert np.isclose(pvs['p_mp'], out['p_mp'])
+    assert np.isclose(pvs['i_x'], out['i_x'])
+    assert np.isclose(pvs['i_xx'], out['i_xx'])
 
 
 def build_precise_iv_curve_dataframe(file_csv, file_json):
@@ -180,6 +168,19 @@ def test_singlediode_precision(method, precise_iv_curves):
     assert np.allclose(pc['i_xx'], outs['i_xx'], atol=1e-6, rtol=0)
 
 
+def test_singlediode_lambert_negative_voc():
+
+    # Those values result in a negative v_oc out of `_lambertw_v_from_i`
+    x = np.array([0., 1.480501e-11, 0.178, 8000., 1.797559])
+    outs = pvsystem.singlediode(*x, method='lambertw')
+    assert outs['v_oc'] == 0
+
+    # Testing for an array
+    x  = np.array([x, x]).T
+    outs = pvsystem.singlediode(*x, method='lambertw')
+    assert np.array_equal(outs['v_oc'], [0, 0])
+
+
 @pytest.mark.parametrize('method', ['lambertw'])
 def test_ivcurve_pnts_precision(method, precise_iv_curves):
     """
@@ -189,7 +190,10 @@ def test_ivcurve_pnts_precision(method, precise_iv_curves):
     x, pc = precise_iv_curves
     pc_i, pc_v = np.stack(pc['Currents']), np.stack(pc['Voltages'])
     ivcurve_pnts = len(pc['Currents'][0])
-    outs = pvsystem.singlediode(method=method, ivcurve_pnts=ivcurve_pnts, **x)
+
+    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)
@@ -421,3 +425,135 @@ def test_pvsyst_breakdown(method, brk_params, recomb_params, poa, temp_cell,
 
     vsc_88 = bishop88_v_from_i(isc_88, *x, **y, method=method)
     assert np.isclose(vsc_88, 0.0, *tol)
+
+
+@pytest.fixture
+def bishop88_arguments():
+    pvsyst_fs_495 = get_pvsyst_fs_495()
+    # evaluate PVSyst model with thin-film recombination loss current
+    # at reference conditions
+    x = pvsystem.calcparams_pvsyst(
+        effective_irradiance=pvsyst_fs_495['irrad_ref'],
+        temp_cell=pvsyst_fs_495['temp_ref'],
+        alpha_sc=pvsyst_fs_495['alpha_sc'],
+        gamma_ref=pvsyst_fs_495['gamma_ref'],
+        mu_gamma=pvsyst_fs_495['mu_gamma'], I_L_ref=pvsyst_fs_495['I_L_ref'],
+        I_o_ref=pvsyst_fs_495['I_o_ref'], R_sh_ref=pvsyst_fs_495['R_sh_ref'],
+        R_sh_0=pvsyst_fs_495['R_sh_0'], R_sh_exp=pvsyst_fs_495['R_sh_exp'],
+        R_s=pvsyst_fs_495['R_s'],
+        cells_in_series=pvsyst_fs_495['cells_in_series'],
+        EgRef=pvsyst_fs_495['EgRef']
+    )
+    y = dict(d2mutau=pvsyst_fs_495['d2mutau'],
+             NsVbi=VOLTAGE_BUILTIN*pvsyst_fs_495['cells_in_series'])
+    # Convert (*x, **y) in a bishop88_.* call to dict of arguments
+    args_dict = {
+        'photocurrent': x[0],
+        'saturation_current': x[1],
+        'resistance_series': x[2],
+        'resistance_shunt': x[3],
+        'nNsVth': x[4],
+    }
+    args_dict.update(y)
+    return args_dict
+
+
+@pytest.mark.parametrize('method, method_kwargs', [
+    ('newton', {
+        'tol': 1e-8,
+        'rtol': 1e-8,
+        'maxiter': 30,
+    }),
+    ('brentq', {
+        'xtol': 1e-8,
+        'rtol': 1e-8,
+        'maxiter': 30,
+    })
+])
+def test_bishop88_kwargs_transfer(method, method_kwargs, mocker,
+                                  bishop88_arguments):
+    """test method_kwargs modifying optimizer does not break anything"""
+    # patch method namespace at singlediode module namespace
+    optimizer_mock = mocker.patch('pvlib.singlediode.' + method)
+
+    # check kwargs passed to bishop_.* are a subset of the call args
+    # since they are called with more keyword arguments
+
+    bishop88_i_from_v(0, **bishop88_arguments, method=method,
+                      method_kwargs=method_kwargs)
+    _, kwargs = optimizer_mock.call_args
+    assert method_kwargs.items() <= kwargs.items()
+
+    bishop88_v_from_i(0, **bishop88_arguments, method=method,
+                      method_kwargs=method_kwargs)
+    _, kwargs = optimizer_mock.call_args
+    assert method_kwargs.items() <= kwargs.items()
+
+    bishop88_mpp(**bishop88_arguments, method=method,
+                 method_kwargs=method_kwargs)
+    _, kwargs = optimizer_mock.call_args
+    assert method_kwargs.items() <= kwargs.items()
+
+
+@pytest.mark.parametrize('method, method_kwargs', [
+    ('newton', {
+        'tol': 1e-4,
+        'rtol': 1e-4,
+        'maxiter': 20,
+        '_inexistent_param': "0.01"
+    }),
+    ('brentq', {
+        'xtol': 1e-4,
+        'rtol': 1e-4,
+        'maxiter': 20,
+        '_inexistent_param': "0.01"
+    })
+])
+def test_bishop88_kwargs_fails(method, method_kwargs, bishop88_arguments):
+    """test invalid method_kwargs passed onto the optimizer fail"""
+
+    pytest.raises(TypeError, bishop88_i_from_v,
+                  0, **bishop88_arguments, method=method,
+                  method_kwargs=method_kwargs)
+
+    pytest.raises(TypeError, bishop88_v_from_i,
+                  0, **bishop88_arguments, method=method,
+                  method_kwargs=method_kwargs)
+
+    pytest.raises(TypeError, bishop88_mpp,
+                  **bishop88_arguments, method=method,
+                  method_kwargs=method_kwargs)
+
+
+@pytest.mark.parametrize('method', ['newton', 'brentq'])
+def test_bishop88_full_output_kwarg(method, bishop88_arguments):
+    """test call to bishop88_.* with full_output=True return values are ok"""
+    method_kwargs = {'full_output': True}
+
+    ret_val = bishop88_i_from_v(0, **bishop88_arguments, method=method,
+                                method_kwargs=method_kwargs)
+    assert isinstance(ret_val, tuple)  # ret_val must be a tuple
+    assert len(ret_val) == 2  # of two elements
+    assert isinstance(ret_val[0], float)  # first one has bishop88 result
+    assert isinstance(ret_val[1], tuple)  # second is output from optimizer
+    # any root finder returns at least 2 elements with full_output=True
+    assert len(ret_val[1]) >= 2
+
+    ret_val = bishop88_v_from_i(0, **bishop88_arguments, method=method,
+                                method_kwargs=method_kwargs)
+    assert isinstance(ret_val, tuple)  # ret_val must be a tuple
+    assert len(ret_val) == 2  # of two elements
+    assert isinstance(ret_val[0], float)  # first one has bishop88 result
+    assert isinstance(ret_val[1], tuple)  # second is output from optimizer
+    # any root finder returns at least 2 elements with full_output=True
+    assert len(ret_val[1]) >= 2
+
+    ret_val = bishop88_mpp(**bishop88_arguments, method=method,
+                           method_kwargs=method_kwargs)
+    assert isinstance(ret_val, tuple)  # ret_val must be a tuple
+    assert len(ret_val) == 2  # of two elements
+    assert isinstance(ret_val[0], tuple)  # first one has bishop88 result
+    assert len(ret_val[0]) == 3  # of three elements (I,V,P)
+    assert isinstance(ret_val[1], tuple)  # second is output from optimizer
+    # any root finder returns at least 2 elements with full_output=True
+    assert len(ret_val[1]) >= 2

pvlib/tests/test_soiling.py

@@ -92,7 +92,7 @@ def test_hsu_no_cleaning(rainfall_input, expected_output):
     tilt = 0.
     expected_no_cleaning = expected_output
 
-    result = hsu(rainfall=rainfall, cleaning_threshold=10., tilt=tilt,
+    result = hsu(rainfall=rainfall, cleaning_threshold=10., surface_tilt=tilt,
                  pm2_5=pm2_5, pm10=pm10, depo_veloc=depo_veloc,
                  rain_accum_period=pd.Timedelta('1h'))
     assert_series_equal(result, expected_no_cleaning)
@@ -108,7 +108,7 @@ def test_hsu(rainfall_input, expected_output_2):
     tilt = 0.
 
     # three cleaning events at 4:00-6:00, 8:00-11:00, and 17:00-20:00
-    result = hsu(rainfall=rainfall, cleaning_threshold=0.5, tilt=tilt,
+    result = hsu(rainfall=rainfall, cleaning_threshold=0.5, surface_tilt=tilt,
                  pm2_5=pm2_5, pm10=pm10, depo_veloc=depo_veloc,
                  rain_accum_period=pd.Timedelta('3h'))
 
@@ -120,8 +120,8 @@ def test_hsu_defaults(rainfall_input, expected_output_1):
     Test Soiling HSU function with default deposition velocity and default rain
     accumulation period.
     """
-    result = hsu(rainfall=rainfall_input, cleaning_threshold=0.5, tilt=0.0,
-                 pm2_5=1.0e-2, pm10=2.0e-2)
+    result = hsu(rainfall=rainfall_input, cleaning_threshold=0.5,
+                 surface_tilt=0.0, pm2_5=1.0e-2, pm10=2.0e-2)
     assert np.allclose(result.values, expected_output_1)
 
 
@@ -138,7 +138,7 @@ def test_hsu_variable_time_intervals(rainfall_input, expected_output_3):
     rain['new_time'] = rain.index + rain['mins_added']
     rain_var_times = rain.set_index('new_time').iloc[:, 0]
     result = hsu(
-        rainfall=rain_var_times, cleaning_threshold=0.5, tilt=50.0,
+        rainfall=rain_var_times, cleaning_threshold=0.5, surface_tilt=50.0,
         pm2_5=1, pm10=2, depo_veloc=depo_veloc,
         rain_accum_period=pd.Timedelta('2h'))
     assert np.allclose(result, expected_output_3)
@@ -147,8 +147,9 @@ def test_hsu_variable_time_intervals(rainfall_input, expected_output_3):
 @pytest.fixture
 def greensboro_rain():
     # get TMY3 data with rain
-    greensboro, _ = read_tmy3(DATA_DIR / '723170TYA.CSV', coerce_year=1990)
-    return greensboro.Lprecipdepth
+    greensboro, _ = read_tmy3(DATA_DIR / '723170TYA.CSV', coerce_year=1990,
+                              map_variables=True)
+    return greensboro['Lprecip depth (mm)']
 
 
 @pytest.fixture

pvlib/tests/test_spa.py

@@ -154,13 +154,12 @@ class SpaBase:
     def test_moon_ascending_longitude(self):
         assert_almost_equal(X4, self.spa.moon_ascending_longitude(JCE), 6)
 
-    def test_longitude_nutation(self):
-        assert_almost_equal(dPsi, self.spa.longitude_nutation(
-            JCE, X0, X1, X2, X3, X4), 6)
-
-    def test_obliquity_nutation(self):
-        assert_almost_equal(dEpsilon, self.spa.obliquity_nutation(
-            JCE, X0, X1, X2, X3, X4), 6)
+    def test_longitude_obliquity_nutation(self):
+        out = np.empty((2,))
+        self.spa.longitude_obliquity_nutation(JCE, X0, X1, X2, X3, X4, out)
+        _dPsi, _dEpsilon = out[0], out[1]
+        assert_almost_equal(dPsi, _dPsi, 6)
+        assert_almost_equal(dEpsilon, _dEpsilon, 6)
 
     def test_mean_ecliptic_obliquity(self):
         assert_almost_equal(epsilon0, self.spa.mean_ecliptic_obliquity(JME), 6)

pvlib/tests/test_spectrum.py

@@ -4,7 +4,7 @@ import pandas as pd
 import numpy as np
 from pvlib import spectrum
 
-from .conftest import DATA_DIR
+from .conftest import DATA_DIR, assert_series_equal
 
 SPECTRL2_TEST_DATA = DATA_DIR / 'spectrl2_example_spectra.csv'
 
@@ -171,3 +171,147 @@ def test_calc_spectral_mismatch_field(spectrl2_data):
     mm = spectrum.calc_spectral_mismatch_field(sr, e_sun=e_sun)
     assert mm.index is e_sun.index
     assert_allclose(mm, expected, rtol=1e-6)
+
+
+@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]])),
+    ('monosi', np.array(
+        [[ 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]])),
+    ('cigs', np.array(
+        [[ 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]]))
+])
+def test_spectral_factor_firstsolar(module_type, expect):
+    ams = np.array([1, 3, 5])
+    pws = np.array([1, 3, 5])
+    ams, pws = np.meshgrid(ams, pws)
+    out = spectrum.spectral_factor_firstsolar(pws, ams, module_type)
+    assert_allclose(out, expect, atol=0.001)
+
+
+def test_spectral_factor_firstsolar_supplied():
+    # use the cdte coeffs
+    coeffs = (0.87102, -0.040543, -0.00929202, 0.10052, 0.073062, -0.0034187)
+    out = spectrum.spectral_factor_firstsolar(1, 1, coefficients=coeffs)
+    expected = 0.99134828
+    assert_allclose(out, expected, atol=1e-3)
+
+
+def test_spectral_factor_firstsolar_ambiguous():
+    with pytest.raises(TypeError):
+        spectrum.spectral_factor_firstsolar(1, 1)
+
+
+def test_spectral_factor_firstsolar_ambiguous_both():
+    # use the cdte coeffs
+    coeffs = (0.87102, -0.040543, -0.00929202, 0.10052, 0.073062, -0.0034187)
+    with pytest.raises(TypeError):
+        spectrum.spectral_factor_firstsolar(1, 1, 'cdte', coefficients=coeffs)
+
+
+def test_spectral_factor_firstsolar_large_airmass():
+    # test that airmass > 10 is treated same as airmass==10
+    m_eq10 = spectrum.spectral_factor_firstsolar(1, 10, 'monosi')
+    m_gt10 = spectrum.spectral_factor_firstsolar(1, 15, 'monosi')
+    assert_allclose(m_eq10, m_gt10)
+
+
+def test_spectral_factor_firstsolar_low_airmass():
+    with pytest.warns(UserWarning, match='Exceptionally low air mass'):
+        _ = spectrum.spectral_factor_firstsolar(1, 0.1, 'monosi')
+
+
+def test_spectral_factor_firstsolar_range():
+    with pytest.warns(UserWarning, match='Exceptionally high pw values'):
+        out = spectrum.spectral_factor_firstsolar(np.array([.1, 3, 10]),
+                                                  np.array([1, 3, 5]),
+                                                  module_type='monosi')
+    expected = np.array([0.96080878, 1.03055092, np.nan])
+    assert_allclose(out, expected, atol=1e-3)
+    with pytest.warns(UserWarning, match='Exceptionally high pw values'):
+        out = spectrum.spectral_factor_firstsolar(6, 1.5,
+                                                  max_precipitable_water=5,
+                                                  module_type='monosi')
+    with pytest.warns(UserWarning, match='Exceptionally low pw values'):
+        out = spectrum.spectral_factor_firstsolar(np.array([0, 3, 8]),
+                                                  np.array([1, 3, 5]),
+                                                  module_type='monosi')
+    expected = np.array([0.96080878, 1.03055092, 1.04932727])
+    assert_allclose(out, expected, atol=1e-3)
+    with pytest.warns(UserWarning, match='Exceptionally low pw values'):
+        out = spectrum.spectral_factor_firstsolar(0.2, 1.5,
+                                                  min_precipitable_water=1,
+                                                  module_type='monosi')
+
+
+@pytest.mark.parametrize('airmass,expected', [
+    (1.5, 1.00028714375),
+    (np.array([[10, np.nan]]), np.array([[0.999535, 0]])),
+    (pd.Series([5]), pd.Series([1.0387675]))
+])
+def test_spectral_factor_sapm(sapm_module_params, airmass, expected):
+
+    out = spectrum.spectral_factor_sapm(airmass, sapm_module_params)
+
+    if isinstance(airmass, pd.Series):
+        assert_series_equal(out, expected, check_less_precise=4)
+    else:
+        assert_allclose(out, expected, atol=1e-4)
+
+
+@pytest.mark.parametrize("module_type,expected", [
+    ('asi', np.array([0.9108, 0.9897, 0.9707, 1.0265, 1.0798, 0.9537])),
+    ('perovskite', np.array([0.9422, 0.9932, 0.9868, 1.0183, 1.0604, 0.9737])),
+    ('cdte', np.array([0.9824, 1.0000, 1.0065, 1.0117, 1.042, 0.9979])),
+    ('multisi', np.array([0.9907, 0.9979, 1.0203, 1.0081, 1.0058, 1.019])),
+    ('monosi', np.array([0.9935, 0.9987, 1.0264, 1.0074, 0.9999, 1.0263])),
+    ('cigs', np.array([1.0014, 1.0011, 1.0270, 1.0082, 1.0029, 1.026])),
+])
+def test_spectral_factor_caballero(module_type, expected):
+    ams = np.array([3.0, 1.5, 3.0, 1.5, 1.5, 3.0])
+    aods = np.array([1.0, 1.0, 0.02, 0.02, 0.08, 0.08])
+    pws = np.array([1.42, 1.42, 1.42, 1.42, 4.0, 1.0])
+    out = spectrum.spectral_factor_caballero(pws, ams, aods,
+                                             module_type=module_type)
+    assert np.allclose(expected, out, atol=1e-3)
+
+
+def test_spectral_factor_caballero_supplied():
+    # use the cdte coeffs
+    coeffs = (
+        1.0044, 0.0095, -0.0037, 0.0002, 0.0000, -0.0046,
+        -0.0182, 0, 0.0095, 0.0068, 0, 1)
+    out = spectrum.spectral_factor_caballero(1, 1, 1, coefficients=coeffs)
+    expected = 1.0021964
+    assert_allclose(out, expected, atol=1e-3)
+
+
+def test_spectral_factor_caballero_supplied_redundant():
+    # Error when specifying both module_type and coefficients
+    coeffs = (
+        1.0044, 0.0095, -0.0037, 0.0002, 0.0000, -0.0046,
+        -0.0182, 0, 0.0095, 0.0068, 0, 1)
+    with pytest.raises(ValueError):
+        spectrum.spectral_factor_caballero(1, 1, 1, module_type='cdte',
+                                           coefficients=coeffs)
+
+
+def test_spectral_factor_caballero_supplied_ambiguous():
+    # Error when specifying neither module_type nor coefficients
+    with pytest.raises(ValueError):
+        spectrum.spectral_factor_caballero(1, 1, 1, module_type=None,
+                                           coefficients=None)

pvlib/tests/test_temperature.py

@@ -99,13 +99,6 @@ def test_pvsyst_cell_series():
     assert_series_equal(expected, result)
 
 
-def test_pvsyst_cell_eta_m_deprecated():
-    with pytest.warns(pvlibDeprecationWarning):
-        result = temperature.pvsyst_cell(900, 20, wind_speed=5.0, u_c=23.5,
-                                         u_v=6.25, eta_m=0.1)
-        assert_allclose(result, 33.315, 0.001)
-
-
 def test_faiman_default():
     result = temperature.faiman(900, 20, 5)
     assert_allclose(result, 35.203, atol=0.001)

pvlib/tests/test_tools.py

@@ -2,6 +2,7 @@ import pytest
 
 from pvlib import tools
 import numpy as np
+import pandas as pd
 
 
 @pytest.mark.parametrize('keys, input_dict, expected', [
@@ -95,3 +96,27 @@ def test_degrees_to_index_1():
     'latitude' or 'longitude' is passed."""
     with pytest.raises(IndexError):  # invalid value for coordinate argument
         tools._degrees_to_index(degrees=22.0, coordinate='width')
+
+
+@pytest.mark.parametrize('args, args_idx', [
+    # no pandas.Series or pandas.DataFrame args
+    ((1,), None),
+    (([1],), None),
+    ((np.array(1),), None),
+    ((np.array([1]),), None),
+    # has pandas.Series or pandas.DataFrame args
+    ((pd.DataFrame([1], index=[1]),), 0),
+    ((pd.Series([1], index=[1]),), 0),
+    ((1, pd.Series([1], index=[1]),), 1),
+    ((1, pd.DataFrame([1], index=[1]),), 1),
+    # first pandas.Series or pandas.DataFrame is used
+    ((1, pd.Series([1], index=[1]), pd.DataFrame([2], index=[2]),), 1),
+    ((1, pd.DataFrame([1], index=[1]), pd.Series([2], index=[2]),), 1),
+])
+def test_get_pandas_index(args, args_idx):
+    index = tools.get_pandas_index(*args)
+
+    if args_idx is None:
+        assert index is None
+    else:
+        pd.testing.assert_index_equal(args[args_idx].index, index)