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

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,21 +99,14 @@ 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, 0.001)
+    assert_allclose(result, 35.203, atol=0.001)
 
 
 def test_faiman_kwargs():
     result = temperature.faiman(900, 20, wind_speed=5.0, u0=22.0, u1=6.)
-    assert_allclose(result, 37.308, 0.001)
+    assert_allclose(result, 37.308, atol=0.001)
 
 
 def test_faiman_list():
@@ -122,7 +115,7 @@ def test_faiman_list():
     winds = [10, 5, 0]
     result = temperature.faiman(irrads, temps, wind_speed=winds)
     expected = np.array([0.0, 18.446, 5.0])
-    assert_allclose(expected, result, 3)
+    assert_allclose(expected, result, atol=0.001)
 
 
 def test_faiman_ndarray():
@@ -131,7 +124,32 @@ def test_faiman_ndarray():
     winds = np.array([10, 5, 0])
     result = temperature.faiman(irrads, temps, wind_speed=winds)
     expected = np.array([0.0, 18.446, 5.0])
-    assert_allclose(expected, result, 3)
+    assert_allclose(expected, result, atol=0.001)
+
+
+def test_faiman_rad_no_ir():
+    expected = temperature.faiman(900, 20, 5)
+    result = temperature.faiman_rad(900, 20, 5)
+    assert_allclose(result, expected)
+
+
+def test_faiman_rad_ir():
+    ir_down = np.array([0, 100, 200, 315.6574, 400])
+    expected = [-11.111, -7.591, -4.071, -0.000, 2.969]
+    result = temperature.faiman_rad(0, 0, 0, ir_down)
+    assert_allclose(result, expected, atol=0.001)
+
+    sky_view = np.array([1.0, 0.5, 0.0])
+    expected = [-4.071, -2.036, 0.000]
+    result = temperature.faiman_rad(0, 0, 0, ir_down=200,
+                                    sky_view=sky_view)
+    assert_allclose(result, expected, atol=0.001)
+
+    emissivity = np.array([1.0, 0.88, 0.5, 0.0])
+    expected = [-4.626, -4.071, -2.313, 0.000]
+    result = temperature.faiman_rad(0, 0, 0, ir_down=200,
+                                    emissivity=emissivity)
+    assert_allclose(result, expected, atol=0.001)
 
 
 def test_ross():

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', [
@@ -45,6 +46,22 @@ def test__golden_sect_DataFrame_vector():
     v, x = tools._golden_sect_DataFrame(params, lower, upper,
                                         _obj_test_golden_sect)
     assert np.allclose(x, expected, atol=1e-8)
+    # some upper and lower bounds equal
+    params = {'c': np.array([1., 2., 1.]), 'n': np.array([1., 1., 1.])}
+    lower = np.array([0., 0.001, 1.])
+    upper = np.array([1., 1.2, 1.])
+    expected = np.array([0.5, 0.25, 1.0])  # x values for maxima
+    v, x = tools._golden_sect_DataFrame(params, lower, upper,
+                                        _obj_test_golden_sect)
+    assert np.allclose(x, expected, atol=1e-8)
+    # all upper and lower bounds equal, arrays of length 1
+    params = {'c': np.array([1.]), 'n': np.array([1.])}
+    lower = np.array([1.])
+    upper = np.array([1.])
+    expected = np.array([1.])  # x values for maxima
+    v, x = tools._golden_sect_DataFrame(params, lower, upper,
+                                        _obj_test_golden_sect)
+    assert np.allclose(x, expected, atol=1e-8)
 
 
 def test__golden_sect_DataFrame_nans():
@@ -79,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)

pvlib/tests/test_tracking.py

@@ -290,155 +290,6 @@ def test_low_sun_angles():
         assert_allclose(expected[k], v)
 
 
-def test_SingleAxisTracker_tracking():
-    with pytest.warns(pvlibDeprecationWarning):
-        system = tracking.SingleAxisTracker(max_angle=90, axis_tilt=30,
-                                            axis_azimuth=180, gcr=2.0/7.0,
-                                            backtrack=True)
-
-    apparent_zenith = pd.Series([30])
-    apparent_azimuth = pd.Series([135])
-
-    tracker_data = system.singleaxis(apparent_zenith, apparent_azimuth)
-
-    expect = pd.DataFrame({'aoi': 7.286245, 'surface_azimuth': 142.65730,
-                           'surface_tilt': 35.98741,
-                           'tracker_theta': -20.88121},
-                          index=[0], dtype=np.float64)
-    expect = expect[SINGLEAXIS_COL_ORDER]
-
-    assert_frame_equal(expect, tracker_data)
-
-    # results calculated using PVsyst
-    pvsyst_solar_azimuth = 7.1609
-    pvsyst_solar_height = 27.315
-    pvsyst_axis_tilt = 20.
-    pvsyst_axis_azimuth = 20.
-    with pytest.warns(pvlibDeprecationWarning):
-        pvsyst_system = tracking.SingleAxisTracker(
-            max_angle=60., axis_tilt=pvsyst_axis_tilt,
-            axis_azimuth=180+pvsyst_axis_azimuth, backtrack=False)
-    # the definition of azimuth is different from PYsyst
-    apparent_azimuth = pd.Series([180+pvsyst_solar_azimuth])
-    apparent_zenith = pd.Series([90-pvsyst_solar_height])
-    tracker_data = pvsyst_system.singleaxis(apparent_zenith, apparent_azimuth)
-    expect = pd.DataFrame({'aoi': 41.07852, 'surface_azimuth': 180-18.432,
-                           'surface_tilt': 24.92122,
-                           'tracker_theta': -15.18391},
-                          index=[0], dtype=np.float64)
-    expect = expect[SINGLEAXIS_COL_ORDER]
-
-    assert_frame_equal(expect, tracker_data)
-
-
-# see test_irradiance for more thorough testing
-def test_get_aoi():
-    with pytest.warns(pvlibDeprecationWarning):
-        system = tracking.SingleAxisTracker(max_angle=90, axis_tilt=30,
-                                            axis_azimuth=180, gcr=2.0/7.0,
-                                            backtrack=True)
-    surface_tilt = np.array([30, 0])
-    surface_azimuth = np.array([90, 270])
-    solar_zenith = np.array([70, 10])
-    solar_azimuth = np.array([100, 180])
-    out = system.get_aoi(surface_tilt, surface_azimuth,
-                         solar_zenith, solar_azimuth)
-    expected = np.array([40.632115, 10.])
-    assert_allclose(out, expected, atol=0.000001)
-
-
-def test_get_irradiance():
-    with pytest.warns(pvlibDeprecationWarning):
-        system = tracking.SingleAxisTracker(max_angle=90, axis_tilt=30,
-                                            axis_azimuth=180, gcr=2.0/7.0,
-                                            backtrack=True)
-    times = pd.date_range(start='20160101 1200-0700',
-                          end='20160101 1800-0700', freq='6H')
-    # latitude=32, longitude=-111
-    solar_position = pd.DataFrame(np.array(
-        [[55.36421554,  55.38851771,  34.63578446,  34.61148229,
-          172.32003763,  -3.44516534],
-         [96.50000401,  96.50000401,  -6.50000401,  -6.50000401,
-          246.91581654,  -3.56292888]]),
-        columns=['apparent_zenith', 'zenith', 'apparent_elevation',
-                 'elevation', 'azimuth', 'equation_of_time'],
-        index=times)
-    irrads = pd.DataFrame({'dni': [900, 0], 'ghi': [600, 0], 'dhi': [100, 0]},
-                          index=times)
-    solar_zenith = solar_position['apparent_zenith']
-    solar_azimuth = solar_position['azimuth']
-
-    # invalid warnings already generated in horizon test above,
-    # no need to clutter test output here
-    with np.errstate(invalid='ignore'):
-        tracker_data = system.singleaxis(solar_zenith, solar_azimuth)
-
-    # some invalid values in irradiance.py. not our problem here
-    with np.errstate(invalid='ignore'):
-        irradiance = system.get_irradiance(tracker_data['surface_tilt'],
-                                           tracker_data['surface_azimuth'],
-                                           solar_zenith,
-                                           solar_azimuth,
-                                           irrads['dni'],
-                                           irrads['ghi'],
-                                           irrads['dhi'])
-
-    expected = pd.DataFrame(data=np.array(
-        [[961.80070,   815.94490,   145.85580,   135.32820, 10.52757492],
-         [nan, nan, nan, nan, nan]]),
-                            columns=['poa_global', 'poa_direct',
-                                     'poa_diffuse', 'poa_sky_diffuse',
-                                     'poa_ground_diffuse'],
-                            index=times)
-
-    assert_frame_equal(irradiance, expected, check_less_precise=2)
-
-    # test with albedo as a Series
-    irrads['albedo'] = [0.5, 0.5]
-    with np.errstate(invalid='ignore'):
-        irradiance = system.get_irradiance(tracker_data['surface_tilt'],
-                                           tracker_data['surface_azimuth'],
-                                           solar_zenith,
-                                           solar_azimuth,
-                                           irrads['dni'],
-                                           irrads['ghi'],
-                                           irrads['dhi'],
-                                           albedo=irrads['albedo'])
-
-    expected = pd.Series(data=[21.05514984, nan], index=times,
-                         name='poa_ground_diffuse')
-
-    assert_series_equal(irradiance['poa_ground_diffuse'], expected,
-                        check_less_precise=2)
-
-
-
-def test_SingleAxisTracker___repr__():
-    with pytest.warns(pvlibDeprecationWarning):
-        system = tracking.SingleAxisTracker(
-            max_angle=45, gcr=.25, module='blah', inverter='blarg',
-            temperature_model_parameters={'a': -3.56})
-    expected = """SingleAxisTracker:
-  axis_tilt: 0
-  axis_azimuth: 0
-  max_angle: 45
-  backtrack: True
-  gcr: 0.25
-  cross_axis_tilt: 0.0
-  name: None
-  Array:
-    name: None
-    mount: SingleAxisTrackerMount(axis_tilt=0, axis_azimuth=0, max_angle=45, backtrack=True, gcr=0.25, cross_axis_tilt=0.0, racking_model=None, module_height=None)
-    module: blah
-    albedo: 0.25
-    module_type: None
-    temperature_model_parameters: {'a': -3.56}
-    strings: 1
-    modules_per_string: 1
-  inverter: blarg"""  # noqa: E501
-    assert system.__repr__() == expected
-
-
 def test_calc_axis_tilt():
     # expected values
     expected_axis_tilt = 2.239  # [degrees]

pvlib/tools.py

@@ -341,24 +341,18 @@ def _golden_sect_DataFrame(params, lower, upper, func, atol=1e-8):
     --------
     pvlib.singlediode._pwr_optfcn
     """
+    if np.any(upper - lower < 0.):
+        raise ValueError('upper >= lower is required')
 
     phim1 = (np.sqrt(5) - 1) / 2
 
-    df = params
+    df = params.copy()  # shallow copy to avoid modifying caller's dict
     df['VH'] = upper
     df['VL'] = lower
 
     converged = False
-    iterations = 0
 
-    # handle all NaN case gracefully
-    with warnings.catch_warnings():
-        warnings.filterwarnings(action='ignore',
-                                message='All-NaN slice encountered')
-        iterlimit = 1 + np.nanmax(
-            np.trunc(np.log(atol / (df['VH'] - df['VL'])) / np.log(phim1)))
-
-    while not converged and (iterations <= iterlimit):
+    while not converged:
 
         phi = phim1 * (df['VH'] - df['VL'])
         df['V1'] = df['VL'] + phi
@@ -373,22 +367,19 @@ def _golden_sect_DataFrame(params, lower, upper, func, atol=1e-8):
 
         err = abs(df['V2'] - df['V1'])
 
-        # works with single value because err is np.float64
-        converged = (err[~np.isnan(err)] < atol).all()
-        # err will be less than atol before iterations hit the limit
-        # but just to be safe
-        iterations += 1
-
-    if iterations > iterlimit:
-        raise Exception("Iterations exceeded maximum. Check that func",
-                        " is not NaN in (lower, upper)")  # pragma: no cover
+        # handle all NaN case gracefully
+        with warnings.catch_warnings():
+            warnings.filterwarnings(action='ignore',
+                                    message='All-NaN slice encountered')
+            converged = np.all(err[~np.isnan(err)] < atol)
 
-    try:
-        func_result = func(df, 'V1')
-        x = np.where(np.isnan(func_result), np.nan, df['V1'])
-    except KeyError:
-        func_result = np.full_like(upper, np.nan)
-        x = func_result.copy()
+    # best estimate of location of maximum
+    df['max'] = 0.5 * (df['V1'] + df['V2'])
+    func_result = func(df, 'max')
+    x = np.where(np.isnan(func_result), np.nan, df['max'])
+    if np.isscalar(df['max']):
+        # np.where always returns an ndarray, converting scalars to 0d-arrays
+        x = x.item()
 
     return func_result, x
 
@@ -470,3 +461,36 @@ def _degrees_to_index(degrees, coordinate):
         index = int(np.around(index))
 
     return index
+
+
+EPS = np.finfo('float64').eps  # machine precision NumPy-1.20
+DX = EPS**(1/3)  # optimal differential element
+
+
+def _first_order_centered_difference(f, x0, dx=DX, args=()):
+    # simple replacement for scipy.misc.derivative, which is scheduled for
+    # removal in scipy 1.12.0
+    df = f(x0+dx, *args) - f(x0-dx, *args)
+    return df / 2 / dx
+
+
+def get_pandas_index(*args):
+    """
+    Get the index of the first pandas DataFrame or Series in a list of
+    arguments.
+
+    Parameters
+    ----------
+    args: positional arguments
+        The numeric values to scan for a pandas index.
+
+    Returns
+    -------
+    A pandas index or None
+        None is returned if there are no pandas DataFrames or Series in the
+        args list.
+    """
+    return next(
+        (a.index for a in args if isinstance(a, (pd.DataFrame, pd.Series))),
+        None
+    )