pvlib 0.9.4a1__py3-none-any.whl → 0.10.0__py3-none-any.whl

pvlib/tests/test_iam.py

@@ -42,7 +42,7 @@ def test_physical():
     expected = np.array([0, 0.8893998, 0.98797788, 0.99926198, 1, 0.99926198,
                          0.98797788, 0.8893998, 0, np.nan])
     iam = _iam.physical(aoi, 1.526, 0.002, 4)
-    assert_allclose(iam, expected, equal_nan=True)
+    assert_allclose(iam, expected, atol=1e-7, equal_nan=True)
 
     # GitHub issue 397
     aoi = pd.Series(aoi)
@@ -51,6 +51,34 @@ def test_physical():
     assert_series_equal(iam, expected)
 
 
+def test_physical_n1_L0():
+    aoi = np.array([0, 22.5, 45, 67.5, 90, 100, np.nan])
+    expected = np.array([1, 1, 1, 1, 0, 0, np.nan])
+    iam = _iam.physical(aoi, n=1, L=0)
+    assert_allclose(iam, expected, equal_nan=True)
+
+    aoi = pd.Series(aoi)
+    expected = pd.Series(expected)
+    iam = _iam.physical(aoi, n=1, L=0)
+    assert_series_equal(iam, expected)
+
+
+def test_physical_ar():
+    aoi = np.array([0, 22.5, 45, 67.5, 90, 100, np.nan])
+    expected = np.array([1, 0.99944171, 0.9917463, 0.91506158, 0, 0, np.nan])
+    iam = _iam.physical(aoi, n_ar=1.29)
+    assert_allclose(iam, expected, atol=1e-7, equal_nan=True)
+
+
+def test_physical_noar():
+    aoi = np.array([0, 22.5, 45, 67.5, 90, 100, np.nan])
+    expected = _iam.physical(aoi)
+    iam0 = _iam.physical(aoi, n_ar=1)
+    iam1 = _iam.physical(aoi, n_ar=1.526)
+    assert_allclose(iam0, expected, equal_nan=True)
+    assert_allclose(iam1, expected, equal_nan=True)
+
+
 def test_physical_scalar():
     aoi = -45.
     iam = _iam.physical(aoi, 1.526, 0.002, 4)
@@ -322,3 +350,48 @@ def test_marion_integrate_invalid():
 
     with pytest.raises(ValueError):
         _iam.marion_integrate(_iam.ashrae, 0, 'bad', 180)
+
+
+def test_schlick():
+    idx = pd.date_range('2019-01-01', freq='h', periods=9)
+    aoi = pd.Series([-180, -135, -90, -45, 0, 45, 90, 135, 180], idx)
+    expected = pd.Series([0, 0, 0, 0.99784451, 1.0, 0.99784451, 0, 0, 0], idx)
+
+    # scalars
+    for aoi_scalar, expected_scalar in zip(aoi, expected):
+        actual = _iam.schlick(aoi_scalar)
+        assert_allclose(expected_scalar, actual)
+
+    # numpy arrays
+    actual = _iam.schlick(aoi.values)
+    assert_allclose(expected.values, actual)
+
+    # pandas Series
+    actual = _iam.schlick(aoi)
+    assert_series_equal(expected, actual)
+
+
+def test_schlick_diffuse():
+    surface_tilt = np.array([0, 20, 70, 90])
+    # expected values calculated with marion_integrate and schlick
+    expected_sky = np.array([0.95238092, 0.96249934, 0.96228167, 0.95238094])
+    expected_ground = np.array([0, 0.62693858, 0.93218737, 0.95238094])
+
+    # numpy arrays
+    actual_sky, actual_ground = _iam.schlick_diffuse(surface_tilt)
+    assert_allclose(expected_sky, actual_sky)
+    assert_allclose(expected_ground, actual_ground, rtol=1e-6)
+
+    # scalars
+    for i in range(len(surface_tilt)):
+        actual_sky, actual_ground = _iam.schlick_diffuse(surface_tilt[i])
+        assert_allclose(expected_sky[i], actual_sky)
+        assert_allclose(expected_ground[i], actual_ground, rtol=1e-6)
+
+    # pandas Series
+    idx = pd.date_range('2019-01-01', freq='h', periods=len(surface_tilt))
+    actual_sky, actual_ground = _iam.schlick_diffuse(pd.Series(surface_tilt,
+                                                               idx))
+    assert_series_equal(pd.Series(expected_sky, idx), actual_sky)
+    assert_series_equal(pd.Series(expected_ground, idx), actual_ground,
+                        rtol=1e-6)

pvlib/tests/test_irradiance.py

@@ -246,6 +246,7 @@ def test_haydavies_components(irrad_data, ephem_data, dni_et):
     assert_allclose(result['horizon'], expected['horizon'][-1], atol=1e-4)
     assert isinstance(result, dict)
 
+
 def test_reindl(irrad_data, ephem_data, dni_et):
     result = irradiance.reindl(
         40, 180, irrad_data['dhi'], irrad_data['dni'], irrad_data['ghi'],
@@ -804,6 +805,38 @@ def test_erbs():
     assert_frame_equal(np.round(out, 0), np.round(expected, 0))
 
 
+def test_boland():
+    index = pd.DatetimeIndex(['20190101']*3 + ['20190620'])
+    ghi = pd.Series([0, 50, 1000, 1000], index=index)
+    zenith = pd.Series([120, 85, 10, 10], index=index)
+    expected = pd.DataFrame(np.array(
+        [[0.0,        0.0,        0.0],
+         [81.9448546, 42.8580353, 0.405723511],
+         [723.764990, 287.230626, 0.718132729],
+         [805.020419, 207.209650, 0.768214312]]),
+        columns=['dni', 'dhi', 'kt'], index=index)
+
+    out = irradiance.boland(ghi, zenith, index)
+
+    assert np.allclose(out, expected)
+
+
+def test_orgill_hollands():
+    index = pd.DatetimeIndex(['20190101']*3 + ['20190620'])
+    ghi = pd.Series([0, 50, 1000, 1000], index=index)
+    zenith = pd.Series([120, 85, 10, 10], index=index)
+    expected = pd.DataFrame(np.array(
+        [[0.0,        0.0,        0.0],
+         [108.731366, 40.5234370, 0.405723511],
+         [776.155771, 235.635779, 0.718132729],
+         [835.696102, 177.000000, 0.768214312]]),
+        columns=['dni', 'dhi', 'kt'], index=index)
+
+    out = irradiance.orgill_hollands(ghi, zenith, index)
+
+    assert np.allclose(out, expected)
+
+
 def test_erbs_min_cos_zenith_max_zenith():
     # map out behavior under difficult conditions with various
     # limiting kwargs settings
@@ -887,8 +920,12 @@ def test_dirindex(times):
     assert np.allclose(out, expected_out, rtol=tolerance, atol=0,
                        equal_nan=True)
     tol_dirint = 0.2
-    assert np.allclose(out.values, dirint_close_values, rtol=tol_dirint, atol=0,
-                       equal_nan=True)
+    assert np.allclose(
+        out.values,
+        dirint_close_values,
+        rtol=tol_dirint,
+        atol=0,
+        equal_nan=True)
 
 
 def test_dirindex_min_cos_zenith_max_zenith():
@@ -1187,3 +1224,20 @@ def test_complete_irradiance():
                                        dhi=None,
                                        dni=i.dni,
                                        dni_clear=clearsky.dni)
+
+
+def test_louche():
+
+    index = pd.DatetimeIndex(['20190101']*3 + ['20190620']*1)
+    ghi = pd.Series([0, 50, 1000, 1000], index=index)
+    zenith = pd.Series([91, 85, 10, 10], index=index)
+    expected = pd.DataFrame(np.array(
+        [[0, 0, 0],
+         [130.089669, 38.661938, 0.405724],
+         [828.498650, 184.088106, 0.718133],
+         [887.407348, 126.074364, 0.768214]]),
+        columns=['dni', 'dhi', 'kt'], index=index)
+
+    out = irradiance.louche(ghi, zenith, index)
+
+    assert_frame_equal(out, expected)

pvlib/tests/test_location.py

@@ -212,7 +212,7 @@ def test_get_clearsky_valueerror(times):
 def test_from_tmy_3():
     from pvlib.tests.iotools.test_tmy import TMY3_TESTFILE
     from pvlib.iotools import read_tmy3
-    data, meta = read_tmy3(TMY3_TESTFILE)
+    data, meta = read_tmy3(TMY3_TESTFILE, map_variables=True)
     loc = Location.from_tmy(meta, data)
     assert loc.name is not None
     assert loc.altitude != 0

pvlib/tests/test_modelchain.py

@@ -6,7 +6,6 @@ import pandas as pd
 from pvlib import iam, modelchain, pvsystem, temperature, inverter
 from pvlib.modelchain import ModelChain
 from pvlib.pvsystem import PVSystem
-from pvlib.tracking import SingleAxisTracker
 from pvlib.location import Location
 from pvlib._deprecation import pvlibDeprecationWarning
 
@@ -753,50 +752,6 @@ def test_run_model_with_weather_noct_sam_temp(sapm_dc_snl_ac_system, location,
         'model': 'noct_sam'}
 
 
-def test_run_model_tracker(sapm_dc_snl_ac_system, location, weather, mocker):
-    with pytest.warns(pvlibDeprecationWarning):
-        system = SingleAxisTracker(
-            module_parameters=sapm_dc_snl_ac_system.arrays[0].module_parameters,  # noqa: E501
-            temperature_model_parameters=(
-                sapm_dc_snl_ac_system.arrays[0].temperature_model_parameters
-            ),
-            inverter_parameters=sapm_dc_snl_ac_system.inverter_parameters)
-    mocker.spy(system, 'singleaxis')
-    mc = ModelChain(system, location)
-    mc.run_model(weather)
-    assert system.singleaxis.call_count == 1
-    assert (mc.results.tracking.columns == ['tracker_theta',
-                                            'aoi',
-                                            'surface_azimuth',
-                                            'surface_tilt']).all()
-    assert mc.results.ac[0] > 0
-    assert np.isnan(mc.results.ac[1])
-    assert isinstance(mc.results.dc, pd.DataFrame)
-
-
-def test_run_model_tracker_list(
-        sapm_dc_snl_ac_system, location, weather, mocker):
-    with pytest.warns(pvlibDeprecationWarning):
-        system = SingleAxisTracker(
-            module_parameters=sapm_dc_snl_ac_system.arrays[0].module_parameters,  # noqa: E501
-            temperature_model_parameters=(
-                sapm_dc_snl_ac_system.arrays[0].temperature_model_parameters
-            ),
-            inverter_parameters=sapm_dc_snl_ac_system.inverter_parameters)
-    mocker.spy(system, 'singleaxis')
-    mc = ModelChain(system, location)
-    mc.run_model([weather])
-    assert system.singleaxis.call_count == 1
-    assert (mc.results.tracking.columns == ['tracker_theta',
-                                            'aoi',
-                                            'surface_azimuth',
-                                            'surface_tilt']).all()
-    assert mc.results.ac[0] > 0
-    assert np.isnan(mc.results.ac[1])
-    assert isinstance(mc.results.dc, tuple)
-    assert len(mc.results.dc) == 1
-
-
 def test__assign_total_irrad(sapm_dc_snl_ac_system, location, weather,
                              total_irrad):
     data = pd.concat([weather, total_irrad], axis=1)
@@ -1047,27 +1002,6 @@ def test_run_model_from_poa_arrays_solar_position_weather(
     assert_series_equal(m.call_args[1]['pressure'], data['pressure'])
 
 
-def test_run_model_from_poa_tracking(sapm_dc_snl_ac_system, location,
-                                     total_irrad):
-    with pytest.warns(pvlibDeprecationWarning):
-        system = SingleAxisTracker(
-            module_parameters=sapm_dc_snl_ac_system.arrays[0].module_parameters,  # noqa: E501
-            temperature_model_parameters=(
-                sapm_dc_snl_ac_system.arrays[0].temperature_model_parameters
-            ),
-            inverter_parameters=sapm_dc_snl_ac_system.inverter_parameters)
-    mc = ModelChain(system, location, aoi_model='no_loss',
-                    spectral_model='no_loss')
-    ac = mc.run_model_from_poa(total_irrad).results.ac
-    assert (mc.results.tracking.columns == ['tracker_theta',
-                                            'aoi',
-                                            'surface_azimuth',
-                                            'surface_tilt']).all()
-    expected = pd.Series(np.array([149.280238, 96.678385]),
-                         index=total_irrad.index)
-    assert_series_equal(ac, expected)
-
-
 @pytest.mark.parametrize("input_type", [lambda x: x[0], tuple, list])
 def test_run_model_from_effective_irradiance(sapm_dc_snl_ac_system, location,
                                              weather, total_irrad, input_type):
@@ -1798,16 +1732,6 @@ def test_ModelChain_no_extra_kwargs(sapm_dc_snl_ac_system, location):
         ModelChain(sapm_dc_snl_ac_system, location, arbitrary_kwarg='value')
 
 
-@fail_on_pvlib_version('0.10')
-def test_ModelChain_attributes_deprecated_10(sapm_dc_snl_ac_system, location):
-    match = 'Use ModelChain.results'
-    mc = ModelChain(sapm_dc_snl_ac_system, location)
-    with pytest.warns(pvlibDeprecationWarning, match=match):
-        mc.aoi
-    with pytest.warns(pvlibDeprecationWarning, match=match):
-        mc.aoi = 5
-
-
 def test_basic_chain_alt_az(sam_data, cec_inverter_parameters,
                             sapm_temperature_cs5p_220m):
     times = pd.date_range(start='20160101 1200-0700',
@@ -2063,3 +1987,36 @@ def test__irrad_for_celltemp():
     assert len(poa) == 2
     assert_series_equal(poa[0], effect_irrad)
     assert_series_equal(poa[1], effect_irrad)
+
+
+def test_ModelChain___repr__(sapm_dc_snl_ac_system, location):
+
+    mc = ModelChain(sapm_dc_snl_ac_system, location,
+                    name='my mc')
+
+    expected = '\n'.join([
+        'ModelChain: ',
+        '  name: my mc',
+        '  clearsky_model: ineichen',
+        '  transposition_model: haydavies',
+        '  solar_position_method: nrel_numpy',
+        '  airmass_model: kastenyoung1989',
+        '  dc_model: sapm',
+        '  ac_model: sandia_inverter',
+        '  aoi_model: sapm_aoi_loss',
+        '  spectral_model: sapm_spectral_loss',
+        '  temperature_model: sapm_temp',
+        '  losses_model: no_extra_losses'
+    ])
+
+    assert mc.__repr__() == expected
+
+
+def test_ModelChainResult___repr__(sapm_dc_snl_ac_system, location, weather):
+    mc = ModelChain(sapm_dc_snl_ac_system, location)
+    mc.run_model(weather)
+    mcres = mc.results.__repr__()
+    mc_attrs = dir(mc.results)
+    mc_attrs = [a for a in mc_attrs if not a.startswith('_')]
+    assert all([a in mcres for a in mc_attrs])
+    

pvlib/tests/test_pvarray.py

@@ -0,0 +1,46 @@
+import numpy as np
+from numpy.testing import assert_allclose
+
+from pvlib import pvarray
+
+
+def test_pvefficiency_adr():
+    g = [1000, 200, 1000, 200, 1000, 200, 0.0, np.nan]
+    t = [25, 25, 50, 50, 75, 75, 25, 25]
+    params = [1.0, -6.651460, 0.018736, 0.070679, 0.054170]
+
+    # the expected values were calculated using the new function itself
+    # hence this test is primarily a regression test
+    eta = [1.0, 0.949125, 0.928148, 0.876472, 0.855759, 0.803281, 0.0, np.nan]
+
+    result = pvarray.pvefficiency_adr(g, t, *params)
+    assert_allclose(result, eta, atol=1e-6)
+
+
+def test_fit_pvefficiency_adr():
+    g = [1000, 200, 1000, 200, 1000, 200]
+    t = [25, 25, 50, 50, 75, 75]
+    eta = [1.0, 0.949125, 0.928148, 0.876472, 0.855759, 0.803281]
+
+    # the expected values were calculated using the new function itself
+    # hence this test is primarily a regression test
+    params = [1.0, -6.651460, 0.018736, 0.070679, 0.054170]
+
+    result = pvarray.fit_pvefficiency_adr(g, t, eta, dict_output=False)
+    # the fitted parameters vary somewhat by platform during the testing
+    # so the tolerance is higher on the parameters than on the efficiencies
+    # in the other tests
+    assert_allclose(result, params, rtol=1e-3)
+
+    result = pvarray.fit_pvefficiency_adr(g, t, eta, dict_output=True)
+    assert 'k_a' in result
+
+
+def test_pvefficiency_adr_round_trip():
+    g = [1000, 200, 1000, 200, 1000, 200]
+    t = [25, 25, 50, 50, 75, 75]
+    eta = [1.0, 0.949125, 0.928148, 0.876472, 0.855759, 0.803281]
+
+    params = pvarray.fit_pvefficiency_adr(g, t, eta, dict_output=False)
+    result = pvarray.pvefficiency_adr(g, t, *params)
+    assert_allclose(result, eta, atol=1e-6)