pvlib 0.10.3__py3-none-any.whl → 0.10.5__py3-none-any.whl

pvlib/tests/test_pvsystem.py

@@ -12,7 +12,6 @@ from numpy.testing import assert_allclose
 import unittest.mock as mock
 
 from pvlib import inverter, pvsystem
-from pvlib import atmosphere
 from pvlib import iam as _iam
 from pvlib import irradiance
 from pvlib import spectrum
@@ -104,87 +103,62 @@ def test_PVSystem_get_iam_invalid(sapm_module_params, mocker):
         system.get_iam(45, iam_model='not_a_model')
 
 
-def test_retrieve_sam_raise_no_parameters():
+def test_retrieve_sam_raises_exceptions():
     """
-    Raise an exception if no parameters are provided to `retrieve_sam()`.
+    Raise an exception if an invalid parameter is provided to `retrieve_sam()`.
     """
-    with pytest.raises(ValueError) as error:
+    with pytest.raises(ValueError, match="Please provide either"):
         pvsystem.retrieve_sam()
-    assert 'A name or path must be provided!' == str(error.value)
-
-
-def test_retrieve_sam_cecmod():
-    """
-    Test the expected data is retrieved from the CEC module database. In
-    particular, check for a known module in the database and check for the
-    expected keys for that module.
-    """
-    data = pvsystem.retrieve_sam('cecmod')
-    keys = [
-        'BIPV',
-        'Date',
-        'T_NOCT',
-        'A_c',
-        'N_s',
-        'I_sc_ref',
-        'V_oc_ref',
-        'I_mp_ref',
-        'V_mp_ref',
-        'alpha_sc',
-        'beta_oc',
-        'a_ref',
-        'I_L_ref',
-        'I_o_ref',
-        'R_s',
-        'R_sh_ref',
-        'Adjust',
-        'gamma_r',
-        'Version',
-        'STC',
-        'PTC',
-        'Technology',
-        'Bifacial',
-        'Length',
-        'Width',
-    ]
-    module = 'Itek_Energy_LLC_iT_300_HE'
-    assert module in data
-    assert set(data[module].keys()) == set(keys)
-
+    with pytest.raises(ValueError, match="Please provide either.*, not both."):
+        pvsystem.retrieve_sam(name="this_surely_wont_work", path="wont_work")
+    with pytest.raises(KeyError, match="Invalid name"):
+        pvsystem.retrieve_sam(name="this_surely_wont_work")
+    with pytest.raises(FileNotFoundError):
+        pvsystem.retrieve_sam(path="this_surely_wont_work.csv")
+
+
+def test_retrieve_sam_databases():
+    """Test the expected keys are retrieved from each database."""
+    keys_per_database = {
+        "cecmod": {'Technology', 'Bifacial', 'STC', 'PTC', 'A_c', 'Length',
+                   'Width', 'N_s', 'I_sc_ref', 'V_oc_ref', 'I_mp_ref',
+                   'V_mp_ref', 'alpha_sc', 'beta_oc', 'T_NOCT', 'a_ref',
+                   'I_L_ref', 'I_o_ref', 'R_s', 'R_sh_ref', 'Adjust',
+                   'gamma_r', 'BIPV', 'Version', 'Date'},
+        "sandiamod": {'Vintage', 'Area', 'Material', 'Cells_in_Series',
+                      'Parallel_Strings', 'Isco', 'Voco', 'Impo', 'Vmpo',
+                      'Aisc', 'Aimp', 'C0', 'C1', 'Bvoco', 'Mbvoc', 'Bvmpo',
+                      'Mbvmp', 'N', 'C2', 'C3', 'A0', 'A1', 'A2', 'A3', 'A4',
+                      'B0', 'B1', 'B2', 'B3', 'B4', 'B5', 'DTC', 'FD', 'A',
+                      'B', 'C4', 'C5', 'IXO', 'IXXO', 'C6', 'C7', 'Notes'},
+        "adrinverter": {'Manufacturer', 'Model', 'Source', 'Vac', 'Vintage',
+                        'Pacmax', 'Pnom', 'Vnom', 'Vmin', 'Vmax',
+                        'ADRCoefficients', 'Pnt', 'Vdcmax', 'Idcmax',
+                        'MPPTLow', 'MPPTHi', 'TambLow', 'TambHi', 'Weight',
+                        'PacFitErrMax', 'YearOfData'},
+        "cecinverter": {'Vac', 'Paco', 'Pdco', 'Vdco', 'Pso', 'C0', 'C1', 'C2',
+                        'C3', 'Pnt', 'Vdcmax', 'Idcmax', 'Mppt_low',
+                        'Mppt_high', 'CEC_Date', 'CEC_Type'}
+    }  # fmt: skip
+    item_per_database = {
+        "cecmod": "Itek_Energy_LLC_iT_300_HE",
+        "sandiamod": "Canadian_Solar_CS6X_300M__2013_",
+        "adrinverter": "Sainty_Solar__SSI_4K4U_240V__CEC_2011_",
+        "cecinverter": "ABB__PVI_3_0_OUTD_S_US__208V_",
+    }
+    # duplicate the cecinverter items for sandiainverter, for backwards compat
+    keys_per_database["sandiainverter"] = keys_per_database["cecinverter"]
+    item_per_database["sandiainverter"] = item_per_database["cecinverter"]
 
-def test_retrieve_sam_cecinverter():
-    """
-    Test the expected data is retrieved from the CEC inverter database. In
-    particular, check for a known inverter in the database and check for the
-    expected keys for that inverter.
-    """
-    data = pvsystem.retrieve_sam('cecinverter')
-    keys = [
-        'Vac',
-        'Paco',
-        'Pdco',
-        'Vdco',
-        'Pso',
-        'C0',
-        'C1',
-        'C2',
-        'C3',
-        'Pnt',
-        'Vdcmax',
-        'Idcmax',
-        'Mppt_low',
-        'Mppt_high',
-        'CEC_Date',
-        'CEC_Type',
-    ]
-    inverter = 'Yaskawa_Solectria_Solar__PVI_5300_208__208V_'
-    assert inverter in data
-    assert set(data[inverter].keys()) == set(keys)
+    for database in keys_per_database.keys():
+        data = pvsystem.retrieve_sam(database)
+        assert set(data.index) == keys_per_database[database]
+        assert item_per_database[database] in data.columns
 
 
 def test_sapm(sapm_module_params):
 
-    times = pd.date_range(start='2015-01-01', periods=5, freq='12H')
+    times = pd.date_range(start='2015-01-01', periods=5, freq='12h')
     effective_irradiance = pd.Series([-1000, 500, 1100, np.nan, 1000],
                                      index=times)
     temp_cell = pd.Series([10, 25, 50, 25, np.nan], index=times)
@@ -192,16 +166,14 @@ def test_sapm(sapm_module_params):
     out = pvsystem.sapm(effective_irradiance, temp_cell, sapm_module_params)
 
     expected = pd.DataFrame(np.array(
-      [[  -5.0608322 ,   -4.65037767,           nan,           nan,
-                  nan,   -4.91119927,   -4.15367716],
-       [   2.545575  ,    2.28773882,   56.86182059,   47.21121608,
-         108.00693168,    2.48357383,    1.71782772],
-       [   5.65584763,    5.01709903,   54.1943277 ,   42.51861718,
-         213.32011294,    5.52987899,    3.48660728],
-       [          nan,           nan,           nan,           nan,
-                  nan,           nan,           nan],
-       [          nan,           nan,           nan,           nan,
-                  nan,           nan,           nan]]),
+        [[-5.0608322, -4.65037767, np.nan, np.nan, np.nan,
+          -4.91119927, -4.16721569],
+         [2.545575, 2.28773882, 56.86182059, 47.21121608, 108.00693168,
+          2.48357383, 1.71782772],
+         [5.65584763, 5.01709903, 54.1943277, 42.51861718, 213.32011294,
+          5.52987899, 3.46796463],
+         [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan],
+         [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]]),
         columns=['i_sc', 'i_mp', 'v_oc', 'v_mp', 'p_mp', 'i_x', 'i_xx'],
         index=times)
 
@@ -210,13 +182,13 @@ def test_sapm(sapm_module_params):
     out = pvsystem.sapm(1000, 25, sapm_module_params)
 
     expected = OrderedDict()
-    expected['i_sc'] = 5.09115
-    expected['i_mp'] = 4.5462909092579995
-    expected['v_oc'] = 59.260800000000003
-    expected['v_mp'] = 48.315600000000003
-    expected['p_mp'] = 219.65677305534581
-    expected['i_x'] = 4.9759899999999995
-    expected['i_xx'] = 3.1880204359100004
+    expected['i_sc'] = sapm_module_params['Isco']
+    expected['i_mp'] = sapm_module_params['Impo']
+    expected['v_oc'] = sapm_module_params['Voco']
+    expected['v_mp'] = sapm_module_params['Vmpo']
+    expected['p_mp'] = sapm_module_params['Impo'] * sapm_module_params['Vmpo']
+    expected['i_x'] = sapm_module_params['IXO']
+    expected['i_xx'] = sapm_module_params['IXXO']
 
     for k, v in expected.items():
         assert_allclose(out[k], v, atol=1e-4)
@@ -536,7 +508,7 @@ def test_PVSystem_noct_celltemp(mocker):
                                       np.array(wind_speed), model='noct_sam')
     assert_allclose(out, expected)
     dr = pd.date_range(start='2020-01-01 12:00:00', end='2020-01-01 13:00:00',
-                       freq='1H')
+                       freq='1h')
     out = system.get_cell_temperature(pd.Series(index=dr, data=poa_global),
                                       pd.Series(index=dr, data=temp_air),
                                       pd.Series(index=dr, data=wind_speed),
@@ -566,7 +538,7 @@ def test_PVSystem_noct_celltemp_error():
 @pytest.mark.parametrize("model",
                          ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
 def test_PVSystem_multi_array_celltemp_functions(model, two_array_system):
-    times = pd.date_range(start='2020-08-25 11:00', freq='H', periods=3)
+    times = pd.date_range(start='2020-08-25 11:00', freq='h', periods=3)
     irrad_one = pd.Series(1000, index=times)
     irrad_two = pd.Series(500, index=times)
     temp_air = pd.Series(25, index=times)
@@ -580,7 +552,7 @@ def test_PVSystem_multi_array_celltemp_functions(model, two_array_system):
 @pytest.mark.parametrize("model",
                          ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
 def test_PVSystem_multi_array_celltemp_multi_temp(model, two_array_system):
-    times = pd.date_range(start='2020-08-25 11:00', freq='H', periods=3)
+    times = pd.date_range(start='2020-08-25 11:00', freq='h', periods=3)
     irrad = pd.Series(1000, index=times)
     temp_air_one = pd.Series(25, index=times)
     temp_air_two = pd.Series(5, index=times)
@@ -605,7 +577,7 @@ def test_PVSystem_multi_array_celltemp_multi_temp(model, two_array_system):
 @pytest.mark.parametrize("model",
                          ['faiman', 'pvsyst', 'sapm', 'fuentes', 'noct_sam'])
 def test_PVSystem_multi_array_celltemp_multi_wind(model, two_array_system):
-    times = pd.date_range(start='2020-08-25 11:00', freq='H', periods=3)
+    times = pd.date_range(start='2020-08-25 11:00', freq='h', periods=3)
     irrad = pd.Series(1000, index=times)
     temp_air = pd.Series(25, index=times)
     wind_speed_one = pd.Series(1, index=times)
@@ -933,7 +905,7 @@ def test_calcparams_pvsyst_all_scalars(pvsyst_module_params):
 
 
 def test_calcparams_desoto(cec_module_params):
-    times = pd.date_range(start='2015-01-01', periods=3, freq='12H')
+    times = pd.date_range(start='2015-01-01', periods=3, freq='12h')
     df = pd.DataFrame({
         'effective_irradiance': [0.0, 800.0, 800.0],
         'temp_cell': [25, 25, 50]
@@ -965,7 +937,7 @@ def test_calcparams_desoto(cec_module_params):
 
 
 def test_calcparams_cec(cec_module_params):
-    times = pd.date_range(start='2015-01-01', periods=3, freq='12H')
+    times = pd.date_range(start='2015-01-01', periods=3, freq='12h')
     df = pd.DataFrame({
         'effective_irradiance': [0.0, 800.0, 800.0],
         'temp_cell': [25, 25, 50]
@@ -1008,7 +980,7 @@ def test_calcparams_cec_extra_params_propagation(cec_module_params, mocker):
     checks that the latter is called with the expected parameters instead of
     some default values.
     """
-    times = pd.date_range(start='2015-01-01', periods=3, freq='12H')
+    times = pd.date_range(start='2015-01-01', periods=3, freq='12h')
     effective_irradiance = pd.Series([0.0, 800.0, 800.0], index=times)
     temp_cell = pd.Series([25, 25, 50], index=times)
     extra_parameters = dict(
@@ -1035,7 +1007,7 @@ def test_calcparams_cec_extra_params_propagation(cec_module_params, mocker):
 
 
 def test_calcparams_pvsyst(pvsyst_module_params):
-    times = pd.date_range(start='2015-01-01', periods=2, freq='12H')
+    times = pd.date_range(start='2015-01-01', periods=2, freq='12h')
     df = pd.DataFrame({
         'effective_irradiance': [0.0, 800.0],
         'temp_cell': [25, 50]
@@ -1527,7 +1499,7 @@ def test_mpp_series():
 
 
 def test_singlediode_series(cec_module_params):
-    times = pd.date_range(start='2015-01-01', periods=2, freq='12H')
+    times = pd.date_range(start='2015-01-01', periods=2, freq='12h')
     effective_irradiance = pd.Series([0.0, 800.0], index=times)
     IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto(
         effective_irradiance,
@@ -1617,7 +1589,7 @@ def test_singlediode_floats_ivcurve():
 
 
 def test_singlediode_series_ivcurve(cec_module_params):
-    times = pd.date_range(start='2015-06-01', periods=3, freq='6H')
+    times = pd.date_range(start='2015-06-01', periods=3, freq='6h')
     effective_irradiance = pd.Series([0.0, 400.0, 800.0], index=times)
     IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto(
                                   effective_irradiance,
@@ -1911,7 +1883,7 @@ def test_PVSystem_multiple_array_get_aoi():
 @pytest.fixture
 def solar_pos():
     times = pd.date_range(start='20160101 1200-0700',
-                          end='20160101 1800-0700', freq='6H')
+                          end='20160101 1800-0700', freq='6h')
     location = Location(latitude=32, longitude=-111)
     return location.get_solarposition(times)
 
@@ -2369,10 +2341,10 @@ def test_PVSystem_single_array():
 
 
 def test_combine_loss_factors():
-    test_index = pd.date_range(start='1990/01/01T12:00', periods=365, freq='D')
+    test_index = pd.date_range(start='1990/01/01T12:00', periods=365, freq='d')
     loss_1 = pd.Series(.10, index=test_index)
     loss_2 = pd.Series(.05, index=pd.date_range(start='1990/01/01T12:00',
-                                                periods=365*2, freq='D'))
+                                                periods=365*2, freq='d'))
     loss_3 = pd.Series(.02, index=pd.date_range(start='1990/01/01',
                                                 periods=12, freq='MS'))
     expected = pd.Series(.1621, index=test_index)

pvlib/tests/test_shading.py

@@ -2,28 +2,31 @@ import numpy as np
 import pandas as pd
 
 from pandas.testing import assert_series_equal
+from numpy.testing import assert_allclose
 import pytest
+from datetime import timezone, timedelta
 
 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']
+    syst = {
+        "height": 1.0,
+        "pitch": 2.0,
+        "surface_tilt": 30.0,
+        "surface_azimuth": 180.0,
+        "rotation": -30.0,
+    }  # 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])
+    x = np.array([0.0, 0.5, 1.0])
+    angles = shading.ground_angle(ts["surface_tilt"], ts["gcr"], x)
+    expected_angles = np.array([0.0, 5.866738789543952, 9.896090638982903])
     assert np.allclose(angles, expected_angles)
 
 
@@ -37,7 +40,7 @@ def test__ground_angle_zero_gcr():
 
 @pytest.fixture
 def surface_tilt():
-    idx = pd.date_range('2019-01-01', freq='h', periods=3)
+    idx = pd.date_range("2019-01-01", freq="h", periods=3)
     return pd.Series([0, 20, 90], index=idx)
 
 
@@ -104,3 +107,119 @@ def test_sky_diffuse_passias_scalar(average_masking_angle, shading_loss):
     for angle, loss in zip(average_masking_angle, shading_loss):
         actual_loss = shading.sky_diffuse_passias(angle)
         assert np.isclose(loss, actual_loss)
+
+
+@pytest.fixture
+def true_tracking_angle_and_inputs_NREL():
+    # data from NREL 'Slope-Aware Backtracking for Single-Axis Trackers'
+    # doi.org/10.2172/1660126 ; Accessed on 2023-11-06.
+    tzinfo = timezone(timedelta(hours=-5))
+    axis_tilt_angle = 9.666  # deg
+    axis_azimuth_angle = 195.0  # deg
+    timedata = pd.DataFrame(
+        columns=("Apparent Elevation", "Solar Azimuth", "True-Tracking"),
+        data=(
+            (2.404287, 122.791770, -84.440),
+            (11.263058, 133.288729, -72.604),
+            (18.733558, 145.285552, -59.861),
+            (24.109076, 158.939435, -45.578),
+            (26.810735, 173.931802, -28.764),
+            (26.482495, 189.371536, -8.475),
+            (23.170447, 204.136810, 15.120),
+            (17.296785, 217.446538, 39.562),
+            (9.461862, 229.102218, 61.587),
+            (0.524817, 239.330401, 79.530),
+        ),
+    )
+    timedata.index = pd.date_range(
+        "2019-01-01T08", "2019-01-01T17", freq="1h", tz=tzinfo
+    )
+    timedata["Apparent Zenith"] = 90.0 - timedata["Apparent Elevation"]
+    return (axis_tilt_angle, axis_azimuth_angle, timedata)
+
+
+@pytest.fixture
+def projected_solar_zenith_angle_edge_cases():
+    premises_and_result_matrix = pd.DataFrame(
+        data=[
+            # s_zen | s_azm | ax_tilt | ax_azm | psza
+            [   0,       0,      0,        0,      0],
+            [   0,     180,      0,        0,      0],
+            [   0,       0,      0,      180,      0],
+            [   0,     180,      0,      180,      0],
+            [  45,       0,      0,      180,      0],
+            [  45,      90,      0,      180,    -45],
+            [  45,     270,      0,      180,     45],
+            [  45,      90,     90,      180,    -90],
+            [  45,     270,     90,      180,     90],
+            [  45,      90,     90,        0,     90],
+            [  45,     270,     90,        0,    -90],
+            [  45,      45,     90,      180,   -135],
+            [  45,     315,     90,      180,    135],
+        ],
+        columns=["solar_zenith", "solar_azimuth", "axis_tilt", "axis_azimuth",
+                 "psza"],
+    )
+    return premises_and_result_matrix
+
+
+def test_projected_solar_zenith_angle_numeric(
+    true_tracking_angle_and_inputs_NREL,
+    projected_solar_zenith_angle_edge_cases
+):
+    psza_func = shading.projected_solar_zenith_angle
+    axis_tilt, axis_azimuth, timedata = true_tracking_angle_and_inputs_NREL
+    # test against data provided by NREL
+    psz = psza_func(
+        timedata["Apparent Zenith"],
+        timedata["Solar Azimuth"],
+        axis_tilt,
+        axis_azimuth,
+    )
+    assert_allclose(psz, timedata["True-Tracking"], atol=1e-3)
+    # test by changing axis azimuth and tilt
+    psza = psza_func(
+        timedata["Apparent Zenith"],
+        timedata["Solar Azimuth"],
+        -axis_tilt,
+        axis_azimuth - 180,
+    )
+    assert_allclose(psza, -timedata["True-Tracking"], atol=1e-3)
+
+    # test edge cases
+    solar_zenith, solar_azimuth, axis_tilt, axis_azimuth, psza_expected = (
+        v for _, v in projected_solar_zenith_angle_edge_cases.items()
+    )
+    psza = psza_func(
+        solar_zenith,
+        solar_azimuth,
+        axis_tilt,
+        axis_azimuth,
+    )
+    assert_allclose(psza, psza_expected, atol=1e-9)
+
+
+@pytest.mark.parametrize(
+    "cast_type, cast_func",
+    [
+        (float, lambda x: float(x)),
+        (np.ndarray, lambda x: np.array([x])),
+        (pd.Series, lambda x: pd.Series(data=[x])),
+    ],
+)
+def test_projected_solar_zenith_angle_datatypes(
+    cast_type, cast_func, true_tracking_angle_and_inputs_NREL
+):
+    psz_func = shading.projected_solar_zenith_angle
+    axis_tilt, axis_azimuth, timedata = true_tracking_angle_and_inputs_NREL
+    sun_apparent_zenith = timedata["Apparent Zenith"].iloc[0]
+    sun_azimuth = timedata["Solar Azimuth"].iloc[0]
+
+    axis_tilt, axis_azimuth, sun_apparent_zenith, sun_azimuth = (
+        cast_func(sun_apparent_zenith),
+        cast_func(sun_azimuth),
+        cast_func(axis_tilt),
+        cast_func(axis_azimuth),
+    )
+    psz = psz_func(sun_apparent_zenith, axis_azimuth, axis_tilt, axis_azimuth)
+    assert isinstance(psz, cast_type)

pvlib/tests/test_singlediode.py

@@ -10,6 +10,7 @@ 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
 
 POA = 888
@@ -167,17 +168,24 @@ 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
+def test_singlediode_lambert_negative_voc(mocker):
+    """Tests approximation to zero of v_oc when it is negative and small.
+    See singlediode.py:_lambertw > comment 'Set small elements <0 in v_oc to 0'
+    """
+    # Next values should result in a negative v_oc out of `_lambertw_v_from_i`
+    # however, we can't ensure that the output belongs to (-1e-12, 0), so we
+    # mock it. It depends on the platform and Python distro. See issue #2000.
+    patcher = mocker.patch("pvlib.singlediode._lambertw_v_from_i")
+    x = np.array([0.0, 1.480501e-11, 0.178, 8000.0, 1.797559])
+    patcher.return_value = -9.999e-13
+    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])
+    patcher.return_value = np.array([-9.999e-13, -1.001e-13])
+    x = np.array([x, x]).T
+    outs = pvsystem.singlediode(*x, method="lambertw")
+    assert_array_equal(outs["v_oc"], [0, 0])
 
 
 @pytest.mark.parametrize('method', ['lambertw'])
@@ -347,7 +355,7 @@ def test_pvsyst_recombination_loss(method, poa, temp_cell, expected, tol):
         # other conditions with breakdown model on and recombination model off
         (
             (1.e-4, -5.5, 3.28),
-            (0., np.Inf),
+            (0., np.inf),
             POA,
             TCELL,
             {
@@ -567,3 +575,53 @@ def test_bishop88_pdSeries_len_one(method, bishop88_arguments):
     bishop88_i_from_v(pd.Series([0]), **bishop88_arguments, method=method)
     bishop88_v_from_i(pd.Series([0]), **bishop88_arguments, method=method)
     bishop88_mpp(**bishop88_arguments, method=method)
+
+
+def _sde_check_solution(i, v, il, io, rs, rsh, a, d2mutau=0., NsVbi=np.inf):
+    vd = v + rs * i
+    return il - io*np.expm1(vd/a) - vd/rsh - il*d2mutau/(NsVbi - vd) - i
+
+
+@pytest.mark.parametrize('method', ['newton', 'brentq'])
+def test_bishop88_init_cond(method):
+    # GH 2013
+    p = {'alpha_sc': 0.0012256,
+         'gamma_ref': 1.2916241612804187,
+         'mu_gamma': 0.00047308959960937403,
+         'I_L_ref': 3.068717040806731,
+         'I_o_ref': 2.2691248021217617e-11,
+         'R_sh_ref': 7000,
+         'R_sh_0': 7000,
+         'R_s': 4.602,
+         'cells_in_series': 268,
+         'R_sh_exp': 5.5,
+         'EgRef': 1.5}
+    NsVbi = 268 * 0.9
+    d2mutau = 1.4
+    irrad = np.arange(20, 1100, 20)
+    tc = np.arange(-25, 74, 1)
+    weather = np.array(np.meshgrid(irrad, tc)).T.reshape(-1, 2)
+    # with the above parameters and weather conditions, a few combinations
+    # result in voc_est > NsVbi, which causes failure of brentq and newton
+    # when the recombination parameters NsVbi and d2mutau are used.
+    sde_params = pvsystem.calcparams_pvsyst(weather[:, 0], weather[:, 1], **p)
+    # test _mpp
+    result = bishop88_mpp(*sde_params, d2mutau=d2mutau, NsVbi=NsVbi)
+    imp, vmp, pmp = result
+    err = np.abs(_sde_check_solution(
+        imp, vmp, sde_params[0], sde_params[1], sde_params[2], sde_params[3],
+        sde_params[4], d2mutau=d2mutau, NsVbi=NsVbi))
+    bad_results = np.isnan(pmp) | (pmp < 0) | (err > 0.00001)  # 0.01mA error
+    assert not bad_results.any()
+    # test v_from_i
+    vmp2 = bishop88_v_from_i(imp, *sde_params, d2mutau=d2mutau, NsVbi=NsVbi)
+    err = np.abs(_sde_check_solution(imp, vmp2, *sde_params, d2mutau=d2mutau,
+                                     NsVbi=NsVbi))
+    bad_results = np.isnan(vmp2) | (vmp2 < 0) | (err > 0.00001)
+    assert not bad_results.any()
+    # test v_from_i
+    imp2 = bishop88_i_from_v(vmp, *sde_params, d2mutau=d2mutau, NsVbi=NsVbi)
+    err = np.abs(_sde_check_solution(imp2, vmp, *sde_params, d2mutau=d2mutau,
+                                     NsVbi=NsVbi))
+    bad_results = np.isnan(imp2) | (imp2 < 0) | (err > 0.00001)
+    assert not bad_results.any()

pvlib/tests/test_snow.py

@@ -42,7 +42,7 @@ def test_coverage_nrel_subhourly():
     surface_tilt = 45
     slide_amount_coefficient = 0.197
     dt = pd.date_range(start="2019-1-1 11:00:00", end="2019-1-1 14:00:00",
-                       freq='15T')
+                       freq='15min')
     poa_irradiance = pd.Series([400, 200, 100, 1234, 134, 982, 100, 100, 100,
                                 100, 100, 100, 0],
                                index=dt)