pvlib 0.9.4a1__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)
@@ -45,6 +73,13 @@ def test_masking_angle_scalar(surface_tilt, masking_angle):
         assert np.isclose(masking_angle_actual, angle)
 
 
+def test_masking_angle_zero_gcr(surface_tilt):
+    # scalar inputs and outputs, including zero
+    for tilt in surface_tilt:
+        masking_angle_actual = shading.masking_angle(tilt, 0, 0.25)
+        assert np.isclose(masking_angle_actual, 0)
+
+
 def test_masking_angle_passias_series(surface_tilt, average_masking_angle):
     # pandas series inputs and outputs
     masking_angle_actual = shading.masking_angle_passias(surface_tilt, 0.5)

pvlib/tests/test_singlediode.py

@@ -3,10 +3,14 @@ testing single-diode methods using JW Bishop 1988
 """
 
 import numpy as np
+import pandas as pd
+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
 
 POA = 888
 TCELL = 55
@@ -22,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'])
@@ -50,23 +48,170 @@ 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):
+    """
+    Reads a precise IV curve parameter set CSV and JSON to create a DataFrame.
+    The CSV contains the parameters of the single diode equation which are used
+    to generate the JSON data. The data are calculated using [1]_ with 40
+    decimal digits of precision in order have at least 16 decimal digits of
+    precision when they are stored in JSON. The precision is sufficient for the
+    difference between the left and right side of the single diode equation to
+    be less than :math:`1 \times 10^{-16}` when the numbers from the JSON are
+    read as mpmath floats. The code to generate these IV curve data is from
+    [2]_. The data and tests that use this function were added in :pull:`1573`.
+
+    Parameters
+    ----------
+    file_csv: str
+        Path to a CSV file of IV curve parameter sets.
+
+    file_json: str
+        Path to a JSON file of precise IV curves.
+
+    Returns
+    -------
+        A DataFrame with these columns: ``Index``, ``photocurrent``,
+        ``saturation_current``, ``resistance_series``, ``resistance_shunt``,
+        ``n``, ``cells_in_series``, ``Voltages``, ``Currents``,
+        ``diode_voltage``, ``v_oc``, ``i_sc``, ``v_mp``, ``i_mp``, ``p_mp``,
+        ``i_x``, ``i_xx`, ``Temperature``, ``Irradiance``, ``Sweep Direction``,
+        ``Datetime``, ``Boltzmann``, ``Elementary Charge``, and ``Vth``. The
+        columns ``Irradiance``, ``Sweep Direction`` are None or empty strings.
+
+    References
+    ----------
+    .. [1] The mpmath development team. (2023). mpmath: a Python library for
+       arbitrary-precision floating-point arithmetic (version 1.2.1).
+       `mpmath <mpmath.org>`_
+
+    .. [2] The ivcurves development team. (2022). Code to generate precise
+       solutions to the single diode equation.
+       `ivcurves <github.com/cwhanse/ivcurves>`_
+    """
+    params = pd.read_csv(file_csv)
+    curves_metadata = pd.read_json(file_json)
+    curves = pd.DataFrame(curves_metadata['IV Curves'].values.tolist())
+    curves['cells_in_series'] = curves_metadata['cells_in_series']
+    joined = params.merge(curves, on='Index', how='inner',
+                          suffixes=(None, '_drop'), validate='one_to_one')
+    joined = joined[(c for c in joined.columns if not c.endswith('_drop'))]
+
+    # parse strings to np.float64
+    is_array = ['Currents', 'Voltages', 'diode_voltage']
+    joined[is_array] = joined[is_array].applymap(
+        lambda a: np.asarray(a, dtype=np.float64)
+    )
+    is_number = ['v_oc', 'i_sc', 'v_mp', 'i_mp', 'p_mp', 'i_x', 'i_xx',
+                 'Temperature']
+    joined[is_number] = joined[is_number].applymap(np.float64)
+
+    joined['Boltzmann'] = scipy.constants.Boltzmann
+    joined['Elementary Charge'] = scipy.constants.elementary_charge
+    joined['Vth'] = (
+        joined['Boltzmann'] * joined['Temperature']
+        / joined['Elementary Charge']
+    )
+
+    return joined
+
+
+@pytest.fixture(scope='function', params=[
+    {
+        'csv': f'{DATA_DIR}/precise_iv_curves_parameter_sets1.csv',
+        'json': f'{DATA_DIR}/precise_iv_curves1.json'
+    },
+    {
+        'csv': f'{DATA_DIR}/precise_iv_curves_parameter_sets2.csv',
+        'json': f'{DATA_DIR}/precise_iv_curves2.json'
+    }
+], ids=[1, 2])
+def precise_iv_curves(request):
+    file_csv, file_json = request.param['csv'], request.param['json']
+    pc = build_precise_iv_curve_dataframe(file_csv, file_json)
+    params = ['photocurrent', 'saturation_current', 'resistance_series',
+              'resistance_shunt']
+    singlediode_params = pc.loc[:, params]
+    singlediode_params['nNsVth'] = pc['n'] * pc['cells_in_series'] * pc['Vth']
+    return singlediode_params, pc
+
+
+@pytest.mark.parametrize('method', ['lambertw', 'brentq', 'newton'])
+def test_singlediode_precision(method, precise_iv_curves):
+    """
+    Tests the accuracy of singlediode. ivcurve_pnts is not tested.
+    """
+    x, pc = precise_iv_curves
+    outs = pvsystem.singlediode(method=method, **x)
+
+    assert np.allclose(pc['i_sc'], outs['i_sc'], atol=1e-10, rtol=0)
+    assert np.allclose(pc['v_oc'], outs['v_oc'], atol=1e-10, rtol=0)
+    assert np.allclose(pc['i_mp'], outs['i_mp'], atol=7e-8, rtol=0)
+    assert np.allclose(pc['v_mp'], outs['v_mp'], atol=1e-6, rtol=0)
+    assert np.allclose(pc['p_mp'], outs['p_mp'], atol=1e-10, rtol=0)
+    assert np.allclose(pc['i_x'], outs['i_x'], atol=1e-10, rtol=0)
+
+    # This test should pass with atol=9e-8 on MacOS and Windows.
+    # The atol was lowered to pass on Linux when the vectorized umath module
+    # introduced in NumPy 1.22.0 is used.
+    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):
+    """
+    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):
+    """
+    Tests the accuracy of pvsystem.v_from_i and pvsystem.i_from_v.
+    """
+    x, pc = precise_iv_curves
+    pc_i, pc_v = pc['Currents'], pc['Voltages']
+    for i, v, (_, x_one_curve) in zip(pc_i, pc_v, x.iterrows()):
+        out_i = pvsystem.i_from_v(voltage=v, method=method, **x_one_curve)
+        out_v = pvsystem.v_from_i(current=i, method=method, **x_one_curve)
+
+        assert np.allclose(i, out_i, atol=1e-10, rtol=0)
+        assert np.allclose(v, out_v, atol=1e-10, rtol=0)
 
 
 def get_pvsyst_fs_495():
@@ -280,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_snow.py

@@ -6,6 +6,8 @@ from .conftest import assert_series_equal
 from pvlib import snow
 from pvlib.tools import sind
 
+import pytest
+
 
 def test_fully_covered_nrel():
     dt = pd.date_range(start="2019-1-1 12:00:00", end="2019-1-1 18:00:00",
@@ -108,6 +110,7 @@ def test__townsend_effective_snow():
 
 
 def test_loss_townsend():
+    # hand-calculated solution
     snow_total = np.array([25.4, 25.4, 12.7, 2.54, 0, 0, 0, 0, 0, 0, 12.7,
                            25.4])
     snow_events = np.array([2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 2, 3])
@@ -118,6 +121,7 @@ def test_loss_townsend():
     poa_global = np.array([350000, 350000, 350000, 350000, 350000, 350000,
                            350000, 350000, 350000, 350000, 350000, 350000])
     angle_of_repose = 40
+    string_factor = 1.0
     slant_height = 2.54
     lower_edge_height = 0.254
     expected = np.array([0.07696253, 0.07992262, 0.06216201, 0.01715392, 0, 0,
@@ -125,5 +129,84 @@ def test_loss_townsend():
     actual = snow.loss_townsend(snow_total, snow_events, surface_tilt,
                                 relative_humidity, temp_air,
                                 poa_global, slant_height,
-                                lower_edge_height, angle_of_repose)
+                                lower_edge_height, string_factor,
+                                angle_of_repose)
     np.testing.assert_allclose(expected, actual, rtol=1e-05)
+
+
+@pytest.mark.parametrize(
+    'poa_global,surface_tilt,slant_height,lower_edge_height,string_factor,expected',  # noQA: E501
+    [
+        (np.asarray(
+            [60., 80., 100., 125., 175., 225., 225., 210., 175., 125., 90.,
+             60.], dtype=float) * 1000.,
+         2.,
+         79. / 39.37,
+         3. / 39.37,
+         1.0,
+         np.asarray(
+            [44, 34, 20, 9, 3, 1, 0, 0, 0, 2, 6, 25], dtype=float)
+         ),
+        (np.asarray(
+            [60., 80., 100., 125., 175., 225., 225., 210., 175., 125., 90.,
+             60.], dtype=float) * 1000.,
+         5.,
+         316 / 39.37,
+         120. / 39.37,
+         0.75,
+         np.asarray(
+            [22, 16, 9, 4, 1, 0, 0, 0, 0, 1, 2, 12], dtype=float)
+         ),
+        (np.asarray(
+            [60., 80., 100., 125., 175., 225., 225., 210., 175., 125., 90.,
+             60.], dtype=float) * 1000.,
+         23.,
+         158 / 39.27,
+         12 / 39.37,
+         0.75,
+         np.asarray(
+            [28, 21, 13, 6, 2, 0, 0, 0, 0, 1, 4, 16], dtype=float)
+         ),
+        (np.asarray(
+            [80., 100., 125., 150., 225., 300., 300., 275., 225., 150., 115.,
+             80.], dtype=float) * 1000.,
+         52.,
+         39.5 / 39.37,
+         34. / 39.37,
+         0.75,
+         np.asarray(
+             [7, 5, 3, 1, 0, 0, 0, 0, 0, 0, 1, 4], dtype=float)
+         ),
+        (np.asarray(
+            [80., 100., 125., 150., 225., 300., 300., 275., 225., 150., 115.,
+             80.], dtype=float) * 1000.,
+         60.,
+         39.5 / 39.37,
+         25. / 39.37,
+         1.,
+         np.asarray(
+             [7, 5, 3, 1, 0, 0, 0, 0, 0, 0, 1, 3], dtype=float)
+         )
+    ]
+)
+def test_loss_townsend_cases(poa_global, surface_tilt, slant_height,
+                             lower_edge_height, string_factor, expected):
+    # test cases from Townsend, 1/27/2023, addeed by cwh
+    # snow_total in inches, convert to cm for pvlib
+    snow_total = np.asarray(
+        [20, 15, 10, 4, 1.5, 0, 0, 0, 0, 1.5, 4, 15], dtype=float) * 2.54
+    # snow events are an average for each month
+    snow_events = np.asarray(
+        [5, 4.2, 2.8, 1.3, 0.8, 0, 0, 0, 0, 0.5, 1.5, 4.5], dtype=float)
+    # air temperature in C
+    temp_air = np.asarray(
+        [-6., -2., 1., 4., 7., 10., 13., 16., 14., 12., 7., -3.], dtype=float)
+    # relative humidity in %
+    relative_humidity = np.asarray(
+        [78., 80., 75., 65., 60., 55., 55., 55., 50., 55., 60., 70.],
+        dtype=float)
+    actual = snow.loss_townsend(
+        snow_total, snow_events, surface_tilt, relative_humidity, temp_air,
+        poa_global, slant_height, lower_edge_height, string_factor)
+    actual = np.around(actual * 100)
+    assert np.allclose(expected, actual)

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_solarposition.py

@@ -163,7 +163,7 @@ def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
     result_rounded = pd.DataFrame(index=result.index)
     # need to iterate because to_datetime does not accept 2D data
     # the rounding fails on pandas < 0.17
-    for col, data in result.iteritems():
+    for col, data in result.items():
         result_rounded[col] = data.dt.round('1s')
 
     assert_frame_equal(frame, result_rounded)
@@ -176,7 +176,7 @@ def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
     # round to nearest minute
     result_rounded = pd.DataFrame(index=result.index)
     # need to iterate because to_datetime does not accept 2D data
-    for col, data in result.iteritems():
+    for col, data in result.items():
         result_rounded[col] = data.dt.round('s').tz_convert('MST')
 
     assert_frame_equal(expected_rise_set_spa, result_rounded)
@@ -191,7 +191,7 @@ def test_sun_rise_set_transit_ephem(expected_rise_set_ephem, golden):
         temperature=11, horizon='-0:34')
     # round to nearest minute
     result_rounded = pd.DataFrame(index=result.index)
-    for col, data in result.iteritems():
+    for col, data in result.items():
         result_rounded[col] = data.dt.round('min').tz_convert('MST')
     assert_frame_equal(expected_rise_set_ephem, result_rounded)
 
@@ -227,7 +227,7 @@ def test_sun_rise_set_transit_ephem(expected_rise_set_ephem, golden):
                                                       horizon='-0:34')
     # round to nearest minute
     result_rounded = pd.DataFrame(index=result.index)
-    for col, data in result.iteritems():
+    for col, data in result.items():
         result_rounded[col] = data.dt.round('min').tz_convert('MST')
     assert_frame_equal(expected, result_rounded)
 
@@ -259,14 +259,14 @@ def test_sun_rise_set_transit_ephem(expected_rise_set_ephem, golden):
         altitude=golden.altitude, pressure=0, temperature=11, horizon='-0:34')
     # round to nearest minute
     result_rounded = pd.DataFrame(index=result.index)
-    for col, data in result.iteritems():
+    for col, data in result.items():
         result_rounded[col] = data.dt.round('min').tz_convert('MST')
     assert_frame_equal(expected, result_rounded)
 
     # test with different timezone
     times = times.tz_convert('UTC')
     expected = expected.tz_convert('UTC')  # resuse result from previous
-    for col, data in expected.iteritems():
+    for col, data in expected.items():
         expected[col] = data.dt.tz_convert('UTC')
     result = solarposition.sun_rise_set_transit_ephem(
         times,
@@ -274,7 +274,7 @@ def test_sun_rise_set_transit_ephem(expected_rise_set_ephem, golden):
         altitude=golden.altitude, pressure=0, temperature=11, horizon='-0:34')
     # round to nearest minute
     result_rounded = pd.DataFrame(index=result.index)
-    for col, data in result.iteritems():
+    for col, data in result.items():
         result_rounded[col] = data.dt.round('min').tz_convert(times.tz)
     assert_frame_equal(expected, result_rounded)
 

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)