pvlib 0.9.5__py3-none-any.whl → 0.10.0__py3-none-any.whl

pvlib/spectrum/__init__.py

@@ -1,3 +1,9 @@
 from pvlib.spectrum.spectrl2 import spectrl2  # noqa: F401
-from pvlib.spectrum.mismatch import (get_example_spectral_response, get_am15g,
-                                     calc_spectral_mismatch_field)
+from pvlib.spectrum.mismatch import (  # noqa: F401
+    calc_spectral_mismatch_field,
+    get_am15g,
+    get_example_spectral_response,
+    spectral_factor_caballero,
+    spectral_factor_firstsolar,
+    spectral_factor_sapm,
+)

pvlib/spectrum/mismatch.py

@@ -8,6 +8,8 @@ import pandas as pd
 from scipy.interpolate import interp1d
 import os
 
+from warnings import warn
+
 
 def get_example_spectral_response(wavelength=None):
     '''
@@ -235,3 +237,336 @@ def calc_spectral_mismatch_field(sr, e_sun, e_ref=None):
         smm = pd.Series(smm, index=e_sun.index)
 
     return smm
+
+
+def spectral_factor_firstsolar(precipitable_water, airmass_absolute,
+                               module_type=None, coefficients=None,
+                               min_precipitable_water=0.1,
+                               max_precipitable_water=8):
+    r"""
+    Spectral mismatch modifier based on precipitable water and absolute
+    (pressure-adjusted) airmass.
+
+    Estimates a spectral mismatch modifier :math:`M` representing the effect on
+    module short circuit current of variation in the spectral
+    irradiance. :math:`M`  is estimated from absolute (pressure currected) air
+    mass, :math:`AM_a`, and precipitable water, :math:`Pw`, using the following
+    function:
+
+    .. math::
+
+        M = c_1 + c_2 AM_a  + c_3 Pw  + c_4 AM_a^{0.5}
+            + c_5 Pw^{0.5} + c_6 \frac{AM_a} {Pw^{0.5}}
+
+    Default coefficients are determined for several cell types with
+    known quantum efficiency curves, by using the Simple Model of the
+    Atmospheric Radiative Transfer of Sunshine (SMARTS) [1]_. Using
+    SMARTS, spectrums are simulated with all combinations of AMa and
+    Pw where:
+
+       * :math:`0.5 \textrm{cm} <= Pw <= 5 \textrm{cm}`
+       * :math:`1.0 <= AM_a <= 5.0`
+       * Spectral range is limited to that of CMP11 (280 nm to 2800 nm)
+       * spectrum simulated on a plane normal to the sun
+       * All other parameters fixed at G173 standard
+
+    From these simulated spectra, M is calculated using the known
+    quantum efficiency curves. Multiple linear regression is then
+    applied to fit Eq. 1 to determine the coefficients for each module.
+
+    Based on the PVLIB Matlab function ``pvl_FSspeccorr`` by Mitchell
+    Lee and Alex Panchula of First Solar, 2016 [2]_.
+
+    Parameters
+    ----------
+    precipitable_water : numeric
+        atmospheric precipitable water. [cm]
+
+    airmass_absolute : numeric
+        absolute (pressure-adjusted) airmass. [unitless]
+
+    module_type : str, optional
+        a string specifying a cell type. Values of 'cdte', 'monosi', 'xsi',
+        'multisi', and 'polysi' (can be lower or upper case). If provided,
+        module_type selects default coefficients for the following modules:
+
+            * 'cdte' - First Solar Series 4-2 CdTe module.
+            * 'monosi', 'xsi' - First Solar TetraSun module.
+            * 'multisi', 'polysi' - anonymous multi-crystalline silicon module.
+            * 'cigs' - anonymous copper indium gallium selenide module.
+            * 'asi' - anonymous amorphous silicon module.
+
+        The module used to calculate the spectral correction
+        coefficients corresponds to the Multi-crystalline silicon
+        Manufacturer 2 Model C from [3]_. The spectral response (SR) of CIGS
+        and a-Si modules used to derive coefficients can be found in [4]_
+
+    coefficients : array-like, optional
+        Allows for entry of user-defined spectral correction
+        coefficients. Coefficients must be of length 6. Derivation of
+        coefficients requires use of SMARTS and PV module quantum
+        efficiency curve. Useful for modeling PV module types which are
+        not included as defaults, or to fine tune the spectral
+        correction to a particular PV module. Note that the parameters for
+        modules with very similar quantum efficiency should be similar,
+        in most cases limiting the need for module specific coefficients.
+
+    min_precipitable_water : float, default 0.1
+        minimum atmospheric precipitable water. Any ``precipitable_water``
+        value lower than ``min_precipitable_water``
+        is set to ``min_precipitable_water`` to avoid model divergence. [cm]
+
+    max_precipitable_water : float, default 8
+        maximum atmospheric precipitable water. Any ``precipitable_water``
+        value greater than ``max_precipitable_water``
+        is set to ``np.nan`` to avoid model divergence. [cm]
+
+    Returns
+    -------
+    modifier: array-like
+        spectral mismatch factor (unitless) which can be multiplied
+        with broadband irradiance reaching a module's cells to estimate
+        effective irradiance, i.e., the irradiance that is converted to
+        electrical current.
+
+    References
+    ----------
+    .. [1] Gueymard, Christian. SMARTS2: a simple model of the atmospheric
+       radiative transfer of sunshine: algorithms and performance
+       assessment. Cocoa, FL: Florida Solar Energy Center, 1995.
+    .. [2] Lee, Mitchell, and Panchula, Alex. "Spectral Correction for
+       Photovoltaic Module Performance Based on Air Mass and Precipitable
+       Water." IEEE Photovoltaic Specialists Conference, Portland, 2016
+    .. [3] Marion, William F., et al. User's Manual for Data for Validating
+       Models for PV Module Performance. National Renewable Energy
+       Laboratory, 2014. http://www.nrel.gov/docs/fy14osti/61610.pdf
+    .. [4] Schweiger, M. and Hermann, W, Influence of Spectral Effects
+       on Energy Yield of Different PV Modules: Comparison of Pwat and
+       MMF Approach, TUV Rheinland Energy GmbH report 21237296.003,
+       January 2017
+    """
+
+    # --- Screen Input Data ---
+
+    # *** Pw ***
+    # Replace Pw Values below 0.1 cm with 0.1 cm to prevent model from
+    # diverging"
+    pw = np.atleast_1d(precipitable_water)
+    pw = pw.astype('float64')
+    if np.min(pw) < min_precipitable_water:
+        pw = np.maximum(pw, min_precipitable_water)
+        warn('Exceptionally low pw values replaced with '
+             f'{min_precipitable_water} cm to prevent model divergence')
+
+    # Warn user about Pw data that is exceptionally high
+    if np.max(pw) > max_precipitable_water:
+        pw[pw > max_precipitable_water] = np.nan
+        warn('Exceptionally high pw values replaced by np.nan: '
+             'check input data.')
+
+    # *** AMa ***
+    # Replace Extremely High AM with AM 10 to prevent model divergence
+    # AM > 10 will only occur very close to sunset
+    if np.max(airmass_absolute) > 10:
+        airmass_absolute = np.minimum(airmass_absolute, 10)
+
+    # Warn user about AMa data that is exceptionally low
+    if np.min(airmass_absolute) < 0.58:
+        warn('Exceptionally low air mass: ' +
+             'model not intended for extra-terrestrial use')
+        # pvl_absoluteairmass(1,pvl_alt2pres(4340)) = 0.58 Elevation of
+        # Mina Pirquita, Argentian = 4340 m. Highest elevation city with
+        # population over 50,000.
+
+    _coefficients = {}
+    _coefficients['cdte'] = (
+        0.86273, -0.038948, -0.012506, 0.098871, 0.084658, -0.0042948)
+    _coefficients['monosi'] = (
+        0.85914, -0.020880, -0.0058853, 0.12029, 0.026814, -0.0017810)
+    _coefficients['xsi'] = _coefficients['monosi']
+    _coefficients['polysi'] = (
+        0.84090, -0.027539, -0.0079224, 0.13570, 0.038024, -0.0021218)
+    _coefficients['multisi'] = _coefficients['polysi']
+    _coefficients['cigs'] = (
+        0.85252, -0.022314, -0.0047216, 0.13666, 0.013342, -0.0008945)
+    _coefficients['asi'] = (
+        1.12094, -0.047620, -0.0083627, -0.10443, 0.098382, -0.0033818)
+
+    if module_type is not None and coefficients is None:
+        coefficients = _coefficients[module_type.lower()]
+    elif module_type is None and coefficients is not None:
+        pass
+    elif module_type is None and coefficients is None:
+        raise TypeError('No valid input provided, both module_type and ' +
+                        'coefficients are None')
+    else:
+        raise TypeError('Cannot resolve input, must supply only one of ' +
+                        'module_type and coefficients')
+
+    # Evaluate Spectral Shift
+    coeff = coefficients
+    ama = airmass_absolute
+    modifier = (
+        coeff[0] + coeff[1]*ama + coeff[2]*pw + coeff[3]*np.sqrt(ama) +
+        coeff[4]*np.sqrt(pw) + coeff[5]*ama/np.sqrt(pw))
+
+    return modifier
+
+
+def spectral_factor_sapm(airmass_absolute, module):
+    """
+    Calculates the SAPM spectral loss coefficient, F1.
+
+    Parameters
+    ----------
+    airmass_absolute : numeric
+        Absolute airmass
+
+    module : dict-like
+        A dict, Series, or DataFrame defining the SAPM performance
+        parameters. See the :py:func:`sapm` notes section for more
+        details.
+
+    Returns
+    -------
+    F1 : numeric
+        The SAPM spectral loss coefficient.
+
+    Notes
+    -----
+    nan airmass values will result in 0 output.
+    """
+
+    am_coeff = [module['A4'], module['A3'], module['A2'], module['A1'],
+                module['A0']]
+
+    spectral_loss = np.polyval(am_coeff, airmass_absolute)
+
+    spectral_loss = np.where(np.isnan(spectral_loss), 0, spectral_loss)
+
+    spectral_loss = np.maximum(0, spectral_loss)
+
+    if isinstance(airmass_absolute, pd.Series):
+        spectral_loss = pd.Series(spectral_loss, airmass_absolute.index)
+
+    return spectral_loss
+
+
+def spectral_factor_caballero(precipitable_water, airmass_absolute, aod500,
+                              module_type=None, coefficients=None):
+    r"""
+    Estimate a technology-specific spectral mismatch modifier from
+    airmass, aerosol optical depth, and atmospheric precipitable water,
+    using the Caballero model.
+
+    The model structure was motivated by examining the effect of these three
+    atmospheric parameters on simulated irradiance spectra and spectral
+    modifiers.  However, the coefficient values reported in [1]_ and
+    available here via the ``module_type`` parameter were determined
+    by fitting the model equations to spectral factors calculated from
+    global tilted spectral irradiance measurements taken in the city of
+    Jaén, Spain.  See [1]_ for details.
+
+    Parameters
+    ----------
+    precipitable_water : numeric
+        atmospheric precipitable water. [cm]
+
+    airmass_absolute : numeric
+        absolute (pressure-adjusted) airmass. [unitless]
+
+    aod500 : numeric
+        atmospheric aerosol optical depth at 500 nm. [unitless]
+
+    module_type : str, optional
+        One of the following PV technology strings from [1]_:
+
+        * ``'cdte'`` - anonymous CdTe module.
+        * ``'monosi'``, - anonymous sc-si module.
+        * ``'multisi'``, - anonymous mc-si- module.
+        * ``'cigs'`` - anonymous copper indium gallium selenide module.
+        * ``'asi'`` - anonymous amorphous silicon module.
+        * ``'perovskite'`` - anonymous pervoskite module.
+
+    coefficients : array-like, optional
+        user-defined coefficients, if not using one of the default coefficient
+        sets via the ``module_type`` parameter.
+
+    Returns
+    -------
+    modifier: numeric
+        spectral mismatch factor (unitless) which is multiplied
+        with broadband irradiance reaching a module's cells to estimate
+        effective irradiance, i.e., the irradiance that is converted to
+        electrical current.
+
+    References
+    ----------
+    .. [1] Caballero, J.A., Fernández, E., Theristis, M.,
+        Almonacid, F., and Nofuentes, G. "Spectral Corrections Based on
+        Air Mass, Aerosol Optical Depth and Precipitable Water
+        for PV Performance Modeling."
+        IEEE Journal of Photovoltaics 2018, 8(2), 552-558.
+        :doi:`10.1109/jphotov.2017.2787019`
+    """
+
+    if module_type is None and coefficients is None:
+        raise ValueError('Must provide either `module_type` or `coefficients`')
+    if module_type is not None and coefficients is not None:
+        raise ValueError('Only one of `module_type` and `coefficients` should '
+                         'be provided')
+
+    # Experimental coefficients from [1]_.
+    # The extra 0/1 coefficients at the end are used to enable/disable
+    # terms to match the different equation forms in Table 1.
+    _coefficients = {}
+    _coefficients['cdte'] = (
+        1.0044, 0.0095, -0.0037, 0.0002, 0.0000, -0.0046,
+        -0.0182, 0, 0.0095, 0.0068, 0, 1)
+    _coefficients['monosi'] = (
+        0.9706, 0.0377, -0.0123, 0.0025, -0.0002, 0.0159,
+        -0.0165, 0, -0.0016, -0.0027, 1, 0)
+    _coefficients['multisi'] = (
+        0.9836, 0.0254, -0.0085, 0.0016, -0.0001, 0.0094,
+        -0.0132, 0, -0.0002, -0.0011, 1, 0)
+    _coefficients['cigs'] = (
+        0.9801, 0.0283, -0.0092, 0.0019, -0.0001, 0.0117,
+        -0.0126, 0, -0.0011, -0.0019, 1, 0)
+    _coefficients['asi'] = (
+        1.1060, -0.0848, 0.0302, -0.0076, 0.0006, -0.1283,
+        0.0986, -0.0254, 0.0156, 0.0146, 1, 0)
+    _coefficients['perovskite'] = (
+        1.0637, -0.0491, 0.0180, -0.0047, 0.0004, -0.0773,
+        0.0583, -0.0159, 0.01251, 0.0109, 1, 0)
+
+    if module_type is not None:
+        coeff = _coefficients[module_type]
+    else:
+        coeff = coefficients
+
+    # Evaluate spectral correction factor
+    ama = airmass_absolute
+    aod500_ref = 0.084
+    pw_ref = 1.4164
+
+    f_AM = (
+        coeff[0]
+        + coeff[1] * ama
+        + coeff[2] * ama**2
+        + coeff[3] * ama**3
+        + coeff[4] * ama**4
+    )
+    # Eq 6, with Table 1
+    f_AOD = (aod500 - aod500_ref) * (
+        coeff[5]
+        + coeff[10] * coeff[6] * ama
+        + coeff[11] * coeff[6] * np.log(ama)
+        + coeff[7] * ama**2
+    )
+    # Eq 7, with Table 1
+    f_PW = (precipitable_water - pw_ref) * (
+        coeff[8]
+        + coeff[9] * np.log(ama)
+    )
+    modifier = f_AM + f_AOD + f_PW  # Eq 5
+    return modifier

pvlib/temperature.py

@@ -291,7 +291,7 @@ def sapm_cell_from_module(module_temperature, poa_global, deltaT,
 
 
 def pvsyst_cell(poa_global, temp_air, wind_speed=1.0, u_c=29.0, u_v=0.0,
-                eta_m=None, module_efficiency=0.1, alpha_absorption=0.9):
+                module_efficiency=0.1, alpha_absorption=0.9):
     r"""
     Calculate cell temperature using an empirical heat loss factor model
     as implemented in PVsyst.
@@ -321,8 +321,6 @@ def pvsyst_cell(poa_global, temp_air, wind_speed=1.0, u_c=29.0, u_v=0.0,
         in :eq:`pvsyst`.
         :math:`\left[ \frac{\text{W}/\text{m}^2}{\text{C}\ \left( \text{m/s} \right)} \right]`
 
-    eta_m : numeric, default None (deprecated, use module_efficiency instead)
-
     module_efficiency : numeric, default 0.1
         Module external efficiency as a fraction. Parameter :math:`\eta_{m}`
         in :eq:`pvsyst`. Calculate as
@@ -378,11 +376,6 @@ def pvsyst_cell(poa_global, temp_air, wind_speed=1.0, u_c=29.0, u_v=0.0,
     37.93103448275862
     """  # noQA: E501
 
-    if eta_m:
-        warn_deprecated(
-            since='v0.9', message='eta_m overwriting module_efficiency',
-            name='eta_m', alternative='module_efficiency', removal='v0.10')
-        module_efficiency = eta_m
     total_loss_factor = u_c + u_v * wind_speed
     heat_input = poa_global * alpha_absorption * (1 - module_efficiency)
     temp_difference = heat_input / total_loss_factor

pvlib/tests/bifacial/test_infinite_sheds.py

@@ -5,7 +5,6 @@ test infinite sheds
 import numpy as np
 import pandas as pd
 from pvlib.bifacial import infinite_sheds
-from pvlib.tools import cosd
 from ..conftest import assert_series_equal
 
 import pytest
@@ -42,116 +41,6 @@ def test_system():
     return syst, pts, vfs_ground_sky
 
 
-@pytest.mark.parametrize("vectorize", [True, False])
-def test__vf_ground_sky_integ(test_system, vectorize):
-    ts, pts, vfs_gnd_sky = test_system
-    # pass rotation here since max_rows=1 for the hand-solved case in
-    # the fixture test_system, which means the ground-to-sky view factor
-    # isn't summed over enough rows for symmetry to hold.
-    vf_integ = infinite_sheds._vf_ground_sky_integ(
-        ts['rotation'], ts['surface_azimuth'],
-        ts['gcr'], ts['height'], ts['pitch'],
-        max_rows=1, npoints=3, vectorize=vectorize)
-    expected_vf_integ = np.trapz(vfs_gnd_sky, pts)
-    assert np.isclose(vf_integ, expected_vf_integ, rtol=0.1)
-
-
-def test__vf_row_sky_integ(test_system):
-    ts, _, _ = test_system
-    gcr = ts['gcr']
-    surface_tilt = ts['surface_tilt']
-    f_x = np.array([0., 0.5, 1.])
-    shaded = []
-    noshade = []
-    for x in f_x:
-        s, ns = infinite_sheds._vf_row_sky_integ(
-            x, surface_tilt, gcr, npoints=100)
-        shaded.append(s)
-        noshade.append(ns)
-
-    def analytic(gcr, surface_tilt, x):
-        c = cosd(surface_tilt)
-        a = 1. / gcr
-        dx = np.sqrt(a**2 - 2 * a * c * x + x**2)
-        return - a * (c**2 - 1) * np.arctanh((x - a * c) / dx) - c * dx
-
-    expected_shade = 0.5 * (f_x * cosd(surface_tilt)
-                            - analytic(gcr, surface_tilt, 1 - f_x)
-                            + analytic(gcr, surface_tilt, 1.))
-    expected_noshade = 0.5 * ((1 - f_x) * cosd(surface_tilt)
-                              + analytic(gcr, surface_tilt, 1. - f_x)
-                              - analytic(gcr, surface_tilt, 0.))
-    shaded = np.array(shaded)
-    noshade = np.array(noshade)
-    assert np.allclose(shaded, expected_shade)
-    assert np.allclose(noshade, expected_noshade)
-
-
-def test__poa_sky_diffuse_pv():
-    dhi = np.array([np.nan, 0.0, 500.])
-    f_x = np.array([0.2, 0.2, 0.5])
-    vf_shade_sky_integ = np.array([1.0, 0.5, 0.2])
-    vf_noshade_sky_integ = np.array([0.0, 0.5, 0.8])
-    poa = infinite_sheds._poa_sky_diffuse_pv(
-        f_x, dhi, vf_shade_sky_integ, vf_noshade_sky_integ)
-    expected_poa = np.array([np.nan, 0.0, 500 * (0.5 * 0.2 + 0.5 * 0.8)])
-    assert np.allclose(poa, expected_poa, equal_nan=True)
-
-
-def test__ground_angle(test_system):
-    ts, _, _ = test_system
-    x = np.array([0., 0.5, 1.0])
-    angles = infinite_sheds._ground_angle(
-        x, ts['surface_tilt'], ts['gcr'])
-    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 = infinite_sheds._ground_angle(x, surface_tilt, 0)
-    expected_angles = np.array([0, 0, 0])
-    assert np.allclose(angles, expected_angles)
-
-
-def test__vf_row_ground(test_system):
-    ts, _, _ = test_system
-    x = np.array([0., 0.5, 1.0])
-    sqr3 = np.sqrt(3)
-    vfs = infinite_sheds._vf_row_ground(
-        x, ts['surface_tilt'], ts['gcr'])
-    expected_vfs = np.array([
-        0.5 * (1. - sqr3 / 2),
-        0.5 * ((4 + sqr3 / 2) / np.sqrt(17 + 4 * sqr3) - sqr3 / 2),
-        0.5 * ((4 + sqr3) / np.sqrt(20 + 8 * sqr3) - sqr3 / 2)])
-    assert np.allclose(vfs, expected_vfs)
-
-
-def test__vf_row_ground_integ(test_system):
-    ts, _, _ = test_system
-    gcr = ts['gcr']
-    surface_tilt = ts['surface_tilt']
-    f_x = np.array([0., 0.5, 1.0])
-    shaded, noshade = infinite_sheds._vf_row_ground_integ(
-        f_x, surface_tilt, gcr)
-
-    def analytic(x, surface_tilt, gcr):
-        c = cosd(surface_tilt)
-        a = 1. / gcr
-        dx = np.sqrt(a**2 + 2 * a * c * x + x**2)
-        return c * dx - a * (c**2 - 1) * np.arctanh((a * c + x) / dx)
-
-    expected_shade = 0.5 * (analytic(f_x, surface_tilt, gcr)
-                            - analytic(0., surface_tilt, gcr)
-                            - f_x * cosd(surface_tilt))
-    expected_noshade = 0.5 * (analytic(1., surface_tilt, gcr)
-                              - analytic(f_x, surface_tilt, gcr)
-                              - (1. - f_x) * cosd(surface_tilt))
-    assert np.allclose(shaded, expected_shade)
-    assert np.allclose(noshade, expected_noshade)
-
-
 def test__poa_ground_shadows():
     poa_ground, f_gnd_beam, df, vf_gnd_sky = (300., 0.5, 0.5, 0.2)
     result = infinite_sheds._poa_ground_shadows(

pvlib/tests/bifacial/test_utils.py

@@ -4,6 +4,8 @@ test bifical.utils
 import numpy as np
 import pytest
 from pvlib.bifacial import utils
+from pvlib.shading import masking_angle, ground_angle
+from pvlib.tools import cosd
 
 
 @pytest.fixture
@@ -79,10 +81,105 @@ def test__unshaded_ground_fraction(
 def test__vf_ground_sky_2d(test_system_fixed_tilt):
     # vector input
     ts, pts, vfs_gnd_sky = test_system_fixed_tilt
-    vfs = utils._vf_ground_sky_2d(pts, ts['rotation'], ts['gcr'],
-                                  ts['pitch'], ts['height'], max_rows=1)
+    vfs = utils.vf_ground_sky_2d(ts['rotation'], ts['gcr'], pts,
+                                 ts['pitch'], ts['height'], max_rows=1)
     assert np.allclose(vfs, vfs_gnd_sky, rtol=0.1)  # middle point vf is off
     # test with singleton x
-    vf = utils._vf_ground_sky_2d(pts[0], ts['rotation'], ts['gcr'],
-                                 ts['pitch'], ts['height'], max_rows=1)
+    vf = utils.vf_ground_sky_2d(ts['rotation'], ts['gcr'], pts[0],
+                                ts['pitch'], ts['height'], max_rows=1)
     assert np.isclose(vf, vfs_gnd_sky[0])
+
+
+@pytest.mark.parametrize("vectorize", [True, False])
+def test_vf_ground_sky_2d_integ(test_system_fixed_tilt, vectorize):
+    ts, pts, vfs_gnd_sky = test_system_fixed_tilt
+    # pass rotation here since max_rows=1 for the hand-solved case in
+    # the fixture test_system, which means the ground-to-sky view factor
+    # isn't summed over enough rows for symmetry to hold.
+    vf_integ = utils.vf_ground_sky_2d_integ(
+        ts['rotation'], ts['gcr'], ts['height'], ts['pitch'],
+        max_rows=1, npoints=3, vectorize=vectorize)
+    expected_vf_integ = np.trapz(vfs_gnd_sky, pts, axis=0)
+    assert np.isclose(vf_integ, expected_vf_integ, rtol=0.1)
+
+
+def test_vf_row_sky_2d(test_system_fixed_tilt):
+    ts, _, _ = test_system_fixed_tilt
+    # with float input, fx at top of row
+    vf = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], 1.)
+    expected = 0.5 * (1 + cosd(ts['surface_tilt']))
+    assert np.isclose(vf, expected)
+    # with array input
+    fx = np.array([0., 0.5, 1.])
+    vf = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], fx)
+    phi = masking_angle(ts['surface_tilt'], ts['gcr'], fx)
+    expected = 0.5 * (1 + cosd(ts['surface_tilt'] + phi))
+    assert np.allclose(vf, expected)
+
+
+def test_vf_row_sky_2d_integ(test_system_fixed_tilt):
+    ts, _, _ = test_system_fixed_tilt
+    # with float input, check end position
+    vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'], 1., 1.)
+    expected = utils.vf_row_sky_2d(ts['surface_tilt'], ts['gcr'], 1.)
+    assert np.isclose(vf, expected)
+    # with array input
+    fx0 = np.array([0., 0.5])
+    fx1 = np.array([0., 0.8])
+    vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'], fx0, fx1)
+    phi = masking_angle(ts['surface_tilt'], ts['gcr'], fx0[0])
+    y0 = 0.5 * (1 + cosd(ts['surface_tilt'] + phi))
+    x = np.arange(fx0[1], fx1[1], 1e-4)
+    phi_y = masking_angle(ts['surface_tilt'], ts['gcr'], x)
+    y = 0.5 * (1 + cosd(ts['surface_tilt'] + phi_y))
+    y1 = np.trapz(y, x) / (fx1[1] - fx0[1])
+    expected = np.array([y0, y1])
+    assert np.allclose(vf, expected, rtol=1e-3)
+    # with defaults (0, 1)
+    vf = utils.vf_row_sky_2d_integ(ts['surface_tilt'], ts['gcr'])
+    x = np.arange(0, 1, 1e-4)
+    phi_y = masking_angle(ts['surface_tilt'], ts['gcr'], x)
+    y = 0.5 * (1 + cosd(ts['surface_tilt'] + phi_y))
+    y1 = np.trapz(y, x) / (1 - 0)
+    assert np.allclose(vf, y1, rtol=1e-3)
+
+
+def test_vf_row_ground_2d(test_system_fixed_tilt):
+    ts, _, _ = test_system_fixed_tilt
+    # with float input, fx at bottom of row
+    vf = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], 0.)
+    expected = 0.5 * (1. - cosd(ts['surface_tilt']))
+    assert np.isclose(vf, expected)
+    # with array input
+    fx = np.array([0., 0.5, 1.0])
+    vf = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], fx)
+    phi = ground_angle(ts['surface_tilt'], ts['gcr'], fx)
+    expected = 0.5 * (1 - cosd(phi - ts['surface_tilt']))
+    assert np.allclose(vf, expected)
+
+
+def test_vf_ground_2d_integ(test_system_fixed_tilt):
+    ts, _, _ = test_system_fixed_tilt
+    # with float input, check end position
+    vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'], 0., 0.)
+    expected = utils.vf_row_ground_2d(ts['surface_tilt'], ts['gcr'], 0.)
+    assert np.isclose(vf, expected)
+    # with array input
+    fx0 = np.array([0., 0.5])
+    fx1 = np.array([0., 0.8])
+    vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'], fx0, fx1)
+    phi = ground_angle(ts['surface_tilt'], ts['gcr'], fx0[0])
+    y0 = 0.5 * (1 - cosd(phi - ts['surface_tilt']))
+    x = np.arange(fx0[1], fx1[1], 1e-4)
+    phi_y = ground_angle(ts['surface_tilt'], ts['gcr'], x)
+    y = 0.5 * (1 - cosd(phi_y - ts['surface_tilt']))
+    y1 = np.trapz(y, x) / (fx1[1] - fx0[1])
+    expected = np.array([y0, y1])
+    assert np.allclose(vf, expected, rtol=1e-2)
+    # with defaults (0, 1)
+    vf = utils.vf_row_ground_2d_integ(ts['surface_tilt'], ts['gcr'], 0, 1)
+    x = np.arange(0, 1, 1e-4)
+    phi_y = ground_angle(ts['surface_tilt'], ts['gcr'], x)
+    y = 0.5 * (1 - cosd(phi_y - ts['surface_tilt']))
+    y1 = np.trapz(y, x) / (1 - 0)
+    assert np.allclose(vf, y1, rtol=1e-2)

pvlib/tests/conftest.py

@@ -141,23 +141,6 @@ def has_numba():
 
 requires_numba = pytest.mark.skipif(not has_numba(), reason="requires numba")
 
-try:
-    import siphon
-    has_siphon = True
-except ImportError:
-    has_siphon = False
-
-requires_siphon = pytest.mark.skipif(not has_siphon,
-                                     reason='requires siphon')
-
-try:
-    import netCDF4  # noqa: F401
-    has_netCDF4 = True
-except ImportError:
-    has_netCDF4 = False
-
-requires_netCDF4 = pytest.mark.skipif(not has_netCDF4,
-                                      reason='requires netCDF4')
 
 try:
     import pvfactors  # noqa: F401
@@ -178,20 +161,6 @@ except ImportError:
 requires_pysam = pytest.mark.skipif(not has_pysam, reason="requires PySAM")
 
 
-try:
-    import cftime  # noqa: F401
-
-    has_recent_cftime = parse_version(cftime.__version__) > parse_version(
-        "1.1.0"
-    )
-except ImportError:
-    has_recent_cftime = False
-
-requires_recent_cftime = pytest.mark.skipif(
-    not has_recent_cftime, reason="requires cftime > 1.1.0"
-)
-
-
 @pytest.fixture()
 def golden():
     return Location(39.742476, -105.1786, 'America/Denver', 1830.14)