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

pvlib/spectrum/spectrl2.py

@@ -233,14 +233,14 @@ def spectrl2(apparent_zenith, aoi, surface_tilt, ground_albedo,
         input ``apparent_zenith``.  All values are spectral irradiance
         with units W/m^2/nm except for `wavelength`, which is in nanometers.
 
-            * wavelength
-            * dni_extra
-            * dhi
-            * dni
-            * poa_sky_diffuse
-            * poa_ground_diffuse
-            * poa_direct
-            * poa_global
+        * wavelength
+        * dni_extra
+        * dhi
+        * dni
+        * poa_sky_diffuse
+        * poa_ground_diffuse
+        * poa_direct
+        * poa_global
 
     Notes
     -----

pvlib/tests/iotools/test_psm3.py

@@ -196,21 +196,3 @@ def test_get_psm3_attribute_mapping(nrel_api_key):
     assert 'latitude' in meta.keys()
     assert 'longitude' in meta.keys()
     assert 'altitude' in meta.keys()
-
-
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_psm3_variable_map_deprecation_warning(nrel_api_key):
-    with pytest.warns(pvlibDeprecationWarning, match='names will be renamed'):
-        _ = psm3.read_psm3(MANUAL_TEST_DATA)
-
-
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_psm3_leap_day_deprecation_warning(nrel_api_key):
-    with pytest.warns(pvlibDeprecationWarning,
-                      match='default to leap_day=True'):
-        _, _ = psm3.get_psm3(LATITUDE, LONGITUDE, nrel_api_key, PVLIB_EMAIL,
-                             names=2019, interval=60,
-                             attributes=['ghi', 'wind_speed'],
-                             map_variables=True)

pvlib/tests/iotools/test_srml.py

@@ -4,8 +4,7 @@ import pytest
 
 from pvlib.iotools import srml
 from ..conftest import (DATA_DIR, RERUNS, RERUNS_DELAY, assert_index_equal,
-                        assert_frame_equal, fail_on_pvlib_version)
-from pvlib._deprecation import pvlibDeprecationWarning
+                        assert_frame_equal)
 
 srml_testfile = DATA_DIR / 'SRML-day-EUPO1801.txt'
 
@@ -88,47 +87,6 @@ def test_get_srml():
     assert_frame_equal(file_data, requested)
 
 
-@fail_on_pvlib_version('0.11')
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_read_srml_month_from_solardat():
-    url = 'http://solardata.uoregon.edu/download/Archive/EUPO1801.txt'
-    file_data = srml.read_srml(url)
-    with pytest.warns(pvlibDeprecationWarning, match='get_srml instead'):
-        requested = srml.read_srml_month_from_solardat('EU', 2018, 1)
-    assert file_data.equals(requested)
-
-
-@fail_on_pvlib_version('0.11')
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_15_minute_dt_index():
-    with pytest.warns(pvlibDeprecationWarning, match='get_srml instead'):
-        data = srml.read_srml_month_from_solardat('TW', 2019, 4, 'RQ')
-    start = pd.Timestamp('20190401 00:00')
-    start = start.tz_localize('Etc/GMT+8')
-    end = pd.Timestamp('20190430 23:45')
-    end = end.tz_localize('Etc/GMT+8')
-    assert data.index[0] == start
-    assert data.index[-1] == end
-    assert (data.index[3::4].minute == 45).all()
-
-
-@fail_on_pvlib_version('0.11')
-@pytest.mark.remote_data
-@pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
-def test_hourly_dt_index():
-    with pytest.warns(pvlibDeprecationWarning, match='get_srml instead'):
-        data = srml.read_srml_month_from_solardat('CD', 1986, 4, 'PH')
-    start = pd.Timestamp('19860401 00:00')
-    start = start.tz_localize('Etc/GMT+8')
-    end = pd.Timestamp('19860430 23:00')
-    end = end.tz_localize('Etc/GMT+8')
-    assert data.index[0] == start
-    assert data.index[-1] == end
-    assert (data.index.minute == 0).all()
-
-
 @pytest.mark.remote_data
 @pytest.mark.flaky(reruns=RERUNS, reruns_delay=RERUNS_DELAY)
 def test_get_srml_hourly():

pvlib/tests/test_albedo.py

@@ -0,0 +1,84 @@
+import numpy as np
+import pandas as pd
+import pytest
+from pvlib import albedo
+
+from .conftest import assert_series_equal
+from numpy.testing import assert_allclose
+
+
+def test_inland_water_dvoracek_default():
+    result = albedo.inland_water_dvoracek(solar_elevation=90,
+                                          color_coeff=0.13,
+                                          wave_roughness_coeff=0.29)
+    assert_allclose(result, 0.072, 0.001)
+
+
+def test_inland_water_dvoracek_negative_elevation():
+    result = albedo.inland_water_dvoracek(solar_elevation=-60,
+                                          color_coeff=0.13,
+                                          wave_roughness_coeff=0.29)
+    assert_allclose(result, 0.13, 0.01)
+
+
+def test_inland_water_dvoracek_string_surface_condition():
+    result = albedo.inland_water_dvoracek(solar_elevation=90,
+                                          surface_condition='clear_water_no_waves')   # noqa: E501
+    assert_allclose(result, 0.072, 0.001)
+
+
+def test_inland_water_dvoracek_ndarray():
+    solar_elevs = np.array([-50, 0, 20, 60, 90])
+    color_coeffs = np.array([0.1, 0.1, 0.2, 0.3, 0.4])
+    roughness_coeffs = np.array([0.3, 0.3, 0.8, 1.5, 2])
+    result = albedo.inland_water_dvoracek(solar_elevation=solar_elevs,
+                                          color_coeff=color_coeffs,
+                                          wave_roughness_coeff=roughness_coeffs)   # noqa: E501
+    expected = np.array([0.1, 0.1, 0.12875, 0.06278, 0.064])
+    assert_allclose(expected, result, atol=1e-5)
+
+
+def test_inland_water_dvoracek_series():
+    times = pd.date_range(start="2015-01-01 00:00", end="2015-01-02 00:00",
+                          freq="6h")
+    solar_elevs = pd.Series([-50, 0, 20, 60, 90], index=times)
+    color_coeffs = pd.Series([0.1, 0.1, 0.2, 0.3, 0.4], index=times)
+    roughness_coeffs = pd.Series([0.1, 0.3, 0.8, 1.5, 2], index=times)
+    result = albedo.inland_water_dvoracek(solar_elevation=solar_elevs,
+                                          color_coeff=color_coeffs,
+                                          wave_roughness_coeff=roughness_coeffs)   # noqa: E501
+    expected = pd.Series([0.1, 0.1, 0.12875, 0.06278, 0.064], index=times)
+    assert_series_equal(expected, result, atol=1e-5)
+
+
+def test_inland_water_dvoracek_series_mix_with_array():
+    times = pd.date_range(start="2015-01-01 00:00", end="2015-01-01 06:00",
+                          freq="6h")
+    solar_elevs = pd.Series([45, 60], index=times)
+    color_coeffs = 0.13
+    roughness_coeffs = 0.29
+    result = albedo.inland_water_dvoracek(solar_elevation=solar_elevs,
+                                          color_coeff=color_coeffs,
+                                          wave_roughness_coeff=roughness_coeffs)   # noqa: E501
+    expected = pd.Series([0.08555, 0.07787], index=times)
+    assert_series_equal(expected, result, atol=1e-5)
+
+
+def test_inland_water_dvoracek_invalid():
+    with pytest.raises(ValueError, match='Either a `surface_condition` has to '
+                       'be chosen or a combination of `color_coeff` and'
+                       ' `wave_roughness_coeff`.'):  # no surface info given
+        albedo.inland_water_dvoracek(solar_elevation=45)
+    with pytest.raises(KeyError, match='not_a_surface_type'):  # invalid type
+        albedo.inland_water_dvoracek(solar_elevation=45,
+                                     surface_condition='not_a_surface_type')
+    with pytest.raises(ValueError, match='Either a `surface_condition` has to '
+                       'be chosen or a combination of `color_coeff` and'
+                       ' `wave_roughness_coeff`.'):  # only one coeff given
+        albedo.inland_water_dvoracek(solar_elevation=45,
+                                     color_coeff=0.13)
+    with pytest.raises(ValueError, match='Either a `surface_condition` has to '
+                       'be chosen or a combination of `color_coeff` and'
+                       ' `wave_roughness_coeff`.'):  # only one coeff given
+        albedo.inland_water_dvoracek(solar_elevation=45,
+                                     wave_roughness_coeff=0.29)

pvlib/tests/test_inverter.py

@@ -61,13 +61,13 @@ def test_sandia_float(cec_inverter_parameters):
     idcs = 5.5
     pdcs = idcs * vdcs
     pacs = inverter.sandia(vdcs, pdcs, cec_inverter_parameters)
-    assert_allclose(pacs, 132.004278, 5)
+    assert_allclose(pacs, 132.004278, 1e-5)
     # test at low power condition
     vdcs = 25.
     idcs = 0
     pdcs = idcs * vdcs
     pacs = inverter.sandia(vdcs, pdcs, cec_inverter_parameters)
-    assert_allclose(pacs, -1. * cec_inverter_parameters['Pnt'], 5)
+    assert_allclose(pacs, -1. * cec_inverter_parameters['Pnt'], 1e-5)
 
 
 def test_sandia_Pnt_micro():

pvlib/tests/test_irradiance.py

@@ -9,7 +9,7 @@ import pandas as pd
 import pytest
 from numpy.testing import (assert_almost_equal,
                            assert_allclose)
-from pvlib import irradiance
+from pvlib import irradiance, albedo
 
 from .conftest import (
     assert_frame_equal,
@@ -18,6 +18,7 @@ from .conftest import (
     requires_numba
 )
 
+from pvlib._deprecation import pvlibDeprecationWarning
 
 # fixtures create realistic test input data
 # test input data generated at Location(32.2, -111, 'US/Arizona', 700)
@@ -1053,7 +1054,7 @@ def test_erbs_all_scalar():
     out = irradiance.erbs(ghi, zenith, doy)
 
     for k, v in out.items():
-        assert_allclose(v, expected[k], 5)
+        assert_allclose(v, expected[k], 1e-2)
 
 
 def test_dirindex(times):
@@ -1406,3 +1407,35 @@ def test_louche():
     out = irradiance.louche(ghi, zenith, index)
 
     assert_frame_equal(out, expected)
+
+
+def test_SURFACE_ALBEDOS_deprecated():
+    with pytest.warns(pvlibDeprecationWarning, match='SURFACE_ALBEDOS has been'
+                      ' moved to the albedo module as of v0.11.0. Please use'
+                      ' pvlib.albedo.SURFACE_ALBEDOS.'):
+        irradiance.SURFACE_ALBEDOS
+
+
+@pytest.mark.filterwarnings("ignore:SURFACE_ALBEDOS")
+def test_SURFACE_ALBEDO_equals():
+    assert irradiance.SURFACE_ALBEDOS == albedo.SURFACE_ALBEDOS
+
+
+def test_diffuse_par_spitters():
+    solar_zenith, global_diffuse_fraction = np.meshgrid(
+        [90, 85, 75, 60, 40, 30, 10, 0], [0.01, 0.1, 0.3, 0.6, 0.8, 0.99]
+    )
+    solar_zenith = solar_zenith.ravel()
+    global_diffuse_fraction = global_diffuse_fraction.ravel()
+    result = irradiance.diffuse_par_spitters(
+        solar_zenith, global_diffuse_fraction
+    )
+    expected = np.array([
+        0.01300, 0.01290, 0.01226, 0.01118, 0.01125, 0.01189, 0.01293, 0.01300,
+        0.12970, 0.12874, 0.12239, 0.11174, 0.11236, 0.11868, 0.12905, 0.12970,
+        0.38190, 0.37931, 0.36201, 0.33273, 0.33446, 0.35188, 0.38014, 0.38190,
+        0.71520, 0.71178, 0.68859, 0.64787, 0.65033, 0.67472, 0.71288, 0.71520,
+        0.88640, 0.88401, 0.86755, 0.83745, 0.83931, 0.85746, 0.88478, 0.88640,
+        0.99591, 0.99576, 0.99472, 0.99270, 0.99283, 0.99406, 0.99581, 0.99591,
+    ])  # fmt: skip
+    assert_allclose(result, expected, atol=1e-5)

pvlib/tests/test_location.py

@@ -12,6 +12,7 @@ import pytz
 from pytz.exceptions import UnknownTimeZoneError
 
 import pvlib
+from pvlib import location
 from pvlib.location import Location, lookup_altitude
 from pvlib.solarposition import declination_spencer71
 from pvlib.solarposition import equation_of_time_spencer71
@@ -328,21 +329,28 @@ def test_extra_kwargs():
         Location(32.2, -111, arbitrary_kwarg='value')
 
 
-def test_lookup_altitude():
-    max_alt_error = 125
-    # location name, latitude, longitude, altitude
-    test_locations = [
-        ('Tucson, USA', 32.2540, -110.9742, 724),
-        ('Lusaka, Zambia', -15.3875, 28.3228, 1253),
-        ('Tokio, Japan', 35.6762, 139.6503, 40),
-        ('Canberra, Australia', -35.2802, 149.1310, 566),
-        ('Bogota, Colombia', 4.7110, -74.0721, 2555),
-        ('Dead Sea, West Bank', 31.525849, 35.449214, -415),
-        ('New Delhi, India', 28.6139, 77.2090, 214),
-        ('Null Island,  Atlantic Ocean', 0, 0, 0),
-    ]
-
-    for name, lat, lon, expected_alt in test_locations:
-        alt_found = lookup_altitude(lat, lon)
-        assert abs(alt_found - expected_alt) < max_alt_error, \
-            f'Max error exceded for {name} - e: {expected_alt} f: {alt_found}'
+@pytest.mark.parametrize('lat,lon,expected_alt', [
+    pytest.param(32.2540, -110.9742, 724, id='Tucson, USA'),
+    pytest.param(-15.3875, 28.3228, 1253, id='Lusaka, Zambia'),
+    pytest.param(35.6762, 139.6503, 40, id='Tokyo, Japan'),
+    pytest.param(-35.2802, 149.1310, 566, id='Canberra, Australia'),
+    pytest.param(4.7110, -74.0721, 2555, id='Bogota, Colombia'),
+    pytest.param(31.525849, 35.449214, -415, id='Dead Sea, West Bank'),
+    pytest.param(28.6139, 77.2090, 214, id='New Delhi, India'),
+    pytest.param(0, 0, 0, id='Null Island,  Atlantic Ocean'),
+])
+def test_lookup_altitude(lat, lon, expected_alt):
+    alt_found = lookup_altitude(lat, lon)
+    assert alt_found == pytest.approx(expected_alt, abs=125)
+
+
+def test_location_lookup_altitude(mocker):
+    mocker.spy(location, 'lookup_altitude')
+    tus = Location(32.2, -111, 'US/Arizona', 700, 'Tucson')
+    location.lookup_altitude.assert_not_called()
+    assert tus.altitude == 700
+    location.lookup_altitude.reset_mock()
+
+    tus = Location(32.2, -111, 'US/Arizona')
+    location.lookup_altitude.assert_called_once_with(32.2, -111)
+    assert tus.altitude == location.lookup_altitude(32.2, -111)

pvlib/tests/test_modelchain.py

@@ -1787,63 +1787,6 @@ def test_ModelChain_no_extra_kwargs(sapm_dc_snl_ac_system, location):
         ModelChain(sapm_dc_snl_ac_system, location, arbitrary_kwarg='value')
 
 
-def test_basic_chain_alt_az(sam_data, cec_inverter_parameters,
-                            sapm_temperature_cs5p_220m):
-    times = pd.date_range(start='20160101 1200-0700',
-                          end='20160101 1800-0700', freq='6h')
-    latitude = 32.2
-    longitude = -111
-    surface_tilt = 0
-    surface_azimuth = 0
-    modules = sam_data['sandiamod']
-    module_parameters = modules['Canadian_Solar_CS5P_220M___2009_']
-    temp_model_params = sapm_temperature_cs5p_220m.copy()
-    with pytest.warns(pvlibDeprecationWarning, match='with_pvwatts'):
-        dc, ac = modelchain.basic_chain(times, latitude, longitude,
-                                        surface_tilt, surface_azimuth,
-                                        module_parameters, temp_model_params,
-                                        cec_inverter_parameters)
-
-    expected = pd.Series(np.array([111.621405, -2.00000000e-02]),
-                         index=times)
-    assert_series_equal(ac, expected)
-
-
-def test_basic_chain_altitude_pressure(sam_data, cec_inverter_parameters,
-                                       sapm_temperature_cs5p_220m):
-    times = pd.date_range(start='20160101 1200-0700',
-                          end='20160101 1800-0700', freq='6h')
-    latitude = 32.2
-    longitude = -111
-    altitude = 700
-    surface_tilt = 0
-    surface_azimuth = 0
-    modules = sam_data['sandiamod']
-    module_parameters = modules['Canadian_Solar_CS5P_220M___2009_']
-    temp_model_params = sapm_temperature_cs5p_220m.copy()
-    with pytest.warns(pvlibDeprecationWarning, match='with_pvwatts'):
-        dc, ac = modelchain.basic_chain(times, latitude, longitude,
-                                        surface_tilt, surface_azimuth,
-                                        module_parameters, temp_model_params,
-                                        cec_inverter_parameters,
-                                        pressure=93194)
-
-    expected = pd.Series(np.array([113.190045, -2.00000000e-02]),
-                         index=times)
-    assert_series_equal(ac, expected)
-
-    with pytest.warns(pvlibDeprecationWarning, match='with_pvwatts'):
-        dc, ac = modelchain.basic_chain(times, latitude, longitude,
-                                        surface_tilt, surface_azimuth,
-                                        module_parameters, temp_model_params,
-                                        cec_inverter_parameters,
-                                        altitude=altitude)
-
-    expected = pd.Series(np.array([113.189814, -2.00000000e-02]),
-                         index=times)
-    assert_series_equal(ac, expected)
-
-
 def test_complete_irradiance_clean_run(sapm_dc_snl_ac_system, location):
     """The DataFrame should not change if all columns are passed"""
     mc = ModelChain(sapm_dc_snl_ac_system, location)

pvlib/tests/test_pvsystem.py

@@ -6,8 +6,7 @@ from numpy import nan, array
 import pandas as pd
 
 import pytest
-from .conftest import (
-    assert_series_equal, assert_frame_equal, fail_on_pvlib_version)
+from .conftest import assert_series_equal, assert_frame_equal
 from numpy.testing import assert_allclose
 import unittest.mock as mock
 
@@ -206,7 +205,7 @@ def test_PVSystem_sapm(sapm_module_params, mocker):
     out = system.sapm(effective_irradiance, temp_cell)
     pvsystem.sapm.assert_called_once_with(effective_irradiance, temp_cell,
                                           sapm_module_params)
-    assert_allclose(out['p_mp'], 100, atol=100)
+    assert_allclose(out['p_mp'], 100, 10)
 
 
 def test_PVSystem_multi_array_sapm(sapm_module_params):
@@ -487,7 +486,7 @@ def test_PVSystem_faiman_celltemp(mocker):
     winds = 1
     out = system.get_cell_temperature(irrads, temps, winds, model='faiman')
     temperature.faiman.assert_called_once_with(irrads, temps, winds, u0, u1)
-    assert_allclose(out, 56.4, atol=1)
+    assert_allclose(out, 56.4, atol=1e-1)
 
 
 def test_PVSystem_noct_celltemp(mocker):
@@ -1062,7 +1061,7 @@ def test_PVSystem_calcparams_desoto(cec_module_params, mocker):
         dEgdT=module_parameters['dEgdT']
     )
 
-    assert_allclose(IL, np.array([0.0, 6.036]), atol=1)
+    assert_allclose(IL, np.array([0.0, 6.036]), atol=1e-1)
     assert_allclose(I0, np.array([2.0e-9, 2.0e-9]), atol=1.0e-9)
     assert_allclose(Rs, np.array([0.1, 0.1]), atol=0.1)
     assert_allclose(Rsh, np.array([np.inf, 20]), atol=1)
@@ -1568,27 +1567,21 @@ def test_singlediode_floats():
             assert_allclose(v, expected[k], atol=1e-6)
 
 
-def test_singlediode_floats_ivcurve():
-    with pytest.warns(pvlibDeprecationWarning, match='ivcurve_pnts'):
-        out = pvsystem.singlediode(7., 6e-7, .1, 20., .5, ivcurve_pnts=3,
-                                   method='lambertw')
+def test_singlediode_floats_expected():
+    out = pvsystem.singlediode(7., 6e-7, .1, 20., .5, method='lambertw')
     expected = {'i_xx': 4.264060478,
                 'i_mp': 6.136267360,
                 'v_oc': 8.106300147,
                 'p_mp': 38.19421055,
                 'i_x': 6.7558815684,
                 'i_sc': 6.965172322,
-                'v_mp': 6.224339375,
-                'i': np.array([
-                    6.965172322, 6.755881568, 2.664535259e-14]),
-                'v': np.array([
-                    0., 4.053150073, 8.106300147])}
+                'v_mp': 6.224339375}
     assert isinstance(out, dict)
     for k, v in out.items():
         assert_allclose(v, expected[k], atol=1e-6)
 
 
-def test_singlediode_series_ivcurve(cec_module_params):
+def test_singlediode_series_expected(cec_module_params):
     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(
@@ -1603,9 +1596,7 @@ def test_singlediode_series_ivcurve(cec_module_params):
                                   EgRef=1.121,
                                   dEgdT=-0.0002677)
 
-    with pytest.warns(pvlibDeprecationWarning, match='ivcurve_pnts'):
-        out = pvsystem.singlediode(IL, I0, Rs, Rsh, nNsVth, ivcurve_pnts=3,
-                                   method='lambertw')
+    out = pvsystem.singlediode(IL, I0, Rs, Rsh, nNsVth, method='lambertw')
 
     expected = OrderedDict([('i_sc', array([0., 3.01079860, 6.00726296])),
                             ('v_oc', array([0., 9.96959733, 10.29603253])),
@@ -1613,41 +1604,22 @@ def test_singlediode_series_ivcurve(cec_module_params):
                             ('v_mp', array([0., 8.321092255, 8.409413795])),
                             ('p_mp', array([0., 22.10320053, 44.49021934])),
                             ('i_x', array([0., 2.884132006, 5.746202281])),
-                            ('i_xx', array([0., 2.052691562, 3.909673879])),
-                            ('v', array([[0., 0., 0.],
-                                         [0., 4.984798663, 9.969597327],
-                                         [0., 5.148016266, 10.29603253]])),
-                            ('i', array([[0., 0., 0.],
-                                         [3.0107985972, 2.8841320056, 0.],
-                                         [6.0072629615, 5.7462022810, 0.]]))])
+                            ('i_xx', array([0., 2.052691562, 3.909673879]))])
 
     for k, v in out.items():
         assert_allclose(v, expected[k], atol=1e-2)
 
-    with pytest.warns(pvlibDeprecationWarning, match='ivcurve_pnts'):
-        out = pvsystem.singlediode(IL, I0, Rs, Rsh, nNsVth, ivcurve_pnts=3)
+    out = pvsystem.singlediode(IL, I0, Rs, Rsh, nNsVth)
 
     expected['i_mp'] = pvsystem.i_from_v(out['v_mp'], IL, I0, Rs, Rsh, nNsVth,
                                          method='lambertw')
     expected['v_mp'] = pvsystem.v_from_i(out['i_mp'], IL, I0, Rs, Rsh, nNsVth,
                                          method='lambertw')
-    expected['i'] = pvsystem.i_from_v(out['v'].T, IL, I0, Rs, Rsh, nNsVth,
-                                      method='lambertw').T
-    expected['v'] = pvsystem.v_from_i(out['i'].T, IL, I0, Rs, Rsh, nNsVth,
-                                      method='lambertw').T
 
     for k, v in out.items():
         assert_allclose(v, expected[k], atol=1e-6)
 
 
-@fail_on_pvlib_version('0.11')
-@pytest.mark.parametrize('method', ['lambertw', 'brentq', 'newton'])
-def test_singlediode_ivcurvepnts_deprecation_warning(method):
-    with pytest.warns(pvlibDeprecationWarning, match='ivcurve_pnts'):
-        pvsystem.singlediode(7., 6e-7, .1, 20., .5, ivcurve_pnts=3,
-                             method=method)
-
-
 def test_scale_voltage_current_power():
     data = pd.DataFrame(
         np.array([[2, 1.5, 10, 8, 12, 0.5, 1.5]]),