pvlib 0.11.2__py3-none-any.whl → 0.12.0__py3-none-any.whl

pvlib/spa_c_files/README.md

@@ -1,81 +0,0 @@
-README
-------
-
-NREL provides a C implementation of the solar position algorithm described in
-[Reda, I.; Andreas, A. (2003). Solar Position Algorithm for Solar Radiation Applications. 55 pp.; NREL Report No. TP-560-34302](http://www.nrel.gov/docs/fy08osti/34302.pdf).
-
-This folder contains the files required to make SPA C code accessible
-to the `pvlib-python` package. We use the Cython package to wrap the NREL SPA 
-implementation. 
-
-** Due to licensing issues, the SPA C files can _not_ be distributed with
-`pvlib-python`. You must download the SPA C files from the
-[NREL website](https://midcdmz.nrel.gov/spa/). **
-
-Download the `spa.c` and `spa.h` files from NREL,  and copy them into the
-`pvlib/spa_c_files` directory. When the extension is built, the ``timezone``
-field in the SPA C files is replaced with `time_zone` to avoid a nameclash
-with the function `__timezone` that is redefined by Python>=3.5. This issue
-is [Python bug 24643](https://bugs.python.org/issue24643).
-
-There are a total of 5 files needed to compile the C code, described below:
-
-* `spa.c`: original C code from NREL 
-* `spa.h`: header file for spa.c
-* `cspa_py.pxd`: a cython header file which essentially tells cython which
-  parts of the main header file to pay attention to
-* `spa_py.pyx`: the cython code used to define both functions in the python
-  namespace. NOTE: It is possible to provide user access to other paramters of
-  the SPA algorithm through modifying this file 
-* `setup.py`: a distutils file which performs the compiling of the cython code
-
-The cython compilation process produces two files:
-* `spa_py.c`: an intermediate cython c file
-* `spa_py.so` or `spa_py.<cpyver-plat>.pyd`: the python module which
-  can be imported into a namespace
-
-To create the SPA Python extension, use the following shell command inside this
-folder:
-
-    $ python setup.py build_ext --inplace
-
-There are four optional keyword arguments `delta_ut1=0`, `slope=30.0`,
-`azm_rotation=-10`, `atmos_refract` that effect four optional return values
-`incidence`, `suntransit`, `sunrise`, and `sunset`. If not given, the defaults
-shown are used.
-
-There is an example in `spa_py_example.py` that contains a test function called
-`spa_calc_example` that users can use to check that the result is consistent
-with expected values:
-
-    >>> from spa_py_example import spa_calc_example
-    >>> r = spa_calc_example()
-    {
-        'year': 2004,
-        'month': 10,
-        'day': 17,
-        'hour': 12,
-        'minute': 30,
-        'second': 30.0,
-        'delta_ut1': 0.0,
-        'delta_t': 67.0,
-        'time_zone': -7.0,
-        'longitude': -105.1786,
-        'latitude': 39.742476,
-        'elevation': 1830.14,
-        'pressure': 820.0,
-        'temperature': 11.0,
-        'slope': 30.0,
-        'azm_rotation': -10.0,
-        'atmos_refract': 0.5667,
-        'function': 3,
-        'e0': 39.59209464796398,
-        'e': 39.60858878898177,
-        'zenith': 50.39141121101823,
-        'azimuth_astro': 14.311961805946808,
-        'azimuth': 194.3119618059468,
-        'incidence': 25.42168493680471,
-        'suntransit': 11.765833793714224,
-        'sunrise': 6.22578372122376,
-        'sunset': 17.320379610556166
-    }

pvlib/spa_c_files/cspa_py.pxd

@@ -1,43 +0,0 @@
-cdef extern from "spa.h":
-    ctypedef enum:
-        SPA_ZA, SPA_ZA_INC, SPA_ZA_RTS, SPA_ALL
-
-    ctypedef struct spa_data:
-        int year
-        int month
-        int day
-        int hour
-        int minute
-        double second
-        double delta_ut1
-        double delta_t
-        double time_zone
-        double longitude
-        double latitude
-
-        double elevation
-
-        double pressure
-
-        double temperature
-
-        double slope
-
-        double azm_rotation
-
-        double atmos_refract
-
-        int function
-
-        double e0
-        double e
-        double zenith
-        double azimuth_astro
-        double azimuth
-        double incidence
-
-        double suntransit
-        double sunrise
-        double sunset
-
-    int spa_calculate(spa_data *spa)

pvlib/spa_c_files/spa_py.pyx

@@ -1,30 +0,0 @@
-cimport cspa_py
-
-def spa_calc(year, month, day, hour, minute, second, time_zone, latitude,
-        longitude, elevation, pressure, temperature, delta_t,
-        delta_ut1=0, slope=30.0, azm_rotation=-10, atmos_refract=0.5667):
-
-    cdef cspa_py.spa_data spa
-
-    spa.year = year
-    spa.month = month
-    spa.day = day
-    spa.hour = hour
-    spa.minute = minute
-    spa.second = second
-    spa.time_zone = time_zone
-    spa.delta_ut1 = delta_ut1
-    spa.delta_t = delta_t
-    spa.longitude = longitude
-    spa.latitude = latitude
-    spa.elevation = elevation
-    spa.pressure = pressure
-    spa.temperature = temperature
-    spa.slope = slope
-    spa.azm_rotation = azm_rotation
-    spa.atmos_refract = atmos_refract
-    spa.function = cspa_py.SPA_ALL
-
-    err = cspa_py.spa_calculate(&spa)
-
-    return spa

pvlib/tests/bifacial/test_infinite_sheds.py

@@ -1,317 +0,0 @@
-"""
-test infinite sheds
-"""
-
-import numpy as np
-import pandas as pd
-from pvlib.bifacial import infinite_sheds
-from ..conftest import assert_series_equal
-
-import pytest
-
-
-@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']
-    pts = np.linspace(0, 1, num=3)
-    sqr3 = np.sqrt(3) / 4
-    # c_i,j = cos(angle from point i to edge of row j), j=0 is row = -1
-    # c_i,j = cos(angle from point i to edge of row j), j=0 is row = -1
-    c00 = (-2 - sqr3) / np.sqrt(1.25**2 + (2 + sqr3)**2)  # right edge row -1
-    c01 = -sqr3 / np.sqrt(1.25**2 + sqr3**2)  # right edge row 0
-    c02 = sqr3 / np.sqrt(0.75**2 + sqr3**2)  # left edge of row 0
-    c03 = (2 - sqr3) / np.sqrt(1.25**2 + (2 - sqr3)**2)  # right edge of row 1
-    vf_0 = 0.5 * (c03 - c02 + c01 - c00)  # vf at point 0
-    c10 = (-3 - sqr3) / np.sqrt(1.25**2 + (3 + sqr3)**2)  # right edge row -1
-    c11 = (-1 - sqr3) / np.sqrt(1.25**2 + (1 + sqr3)**2)  # right edge row 0
-    c12 = (-1 + sqr3) / np.sqrt(0.75**2 + (-1 + sqr3)**2)  # left edge row 0
-    c13 = (1 - sqr3) / np.sqrt(1.25**2 + (1 - sqr3)**2)  # right edge row
-    vf_1 = 0.5 * (c13 - c12 + c11 - c10)  # vf at point 1
-    c20 = -(4 + sqr3) / np.sqrt(1.25**2 + (4 + sqr3)**2)  # right edge row -1
-    c21 = (-2 + sqr3) / np.sqrt(0.75**2 + (-2 + sqr3)**2)  # left edge row 0
-    c22 = (-2 - sqr3) / np.sqrt(1.25**2 + (2 + sqr3)**2)  # right edge row 0
-    c23 = (0 - sqr3) / np.sqrt(1.25**2 + (0 - sqr3)**2)  # right edge row 1
-    vf_2 = 0.5 * (c23 - c22 + c21 - c20)  # vf at point 1
-    vfs_ground_sky = np.array([vf_0, vf_1, vf_2])
-    return syst, pts, vfs_ground_sky
-
-
-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(
-        poa_ground, f_gnd_beam, df, vf_gnd_sky)
-    expected = 300. * (0.5 * 0.5 + 0.5 * 0.2)
-    assert np.isclose(result, expected)
-    # vector inputs
-    poa_ground = np.array([300., 300.])
-    f_gnd_beam = np.array([0.5, 0.5])
-    df = np.array([0.5, 0.])
-    vf_gnd_sky = np.array([0.2, 0.2])
-    result = infinite_sheds._poa_ground_shadows(
-        poa_ground, f_gnd_beam, df, vf_gnd_sky)
-    expected_vec = np.array([expected, 300. * 0.5])
-    assert np.allclose(result, expected_vec)
-
-
-def test__shaded_fraction_floats():
-    result = infinite_sheds._shaded_fraction(
-        solar_zenith=60., solar_azimuth=180., surface_tilt=60.,
-        surface_azimuth=180., gcr=1.0)
-    assert np.isclose(result, 0.5)
-
-
-def test__shaded_fraction_array():
-    solar_zenith = np.array([0., 60., 90., 60.])
-    solar_azimuth = np.array([180., 180., 180., 180.])
-    surface_azimuth = np.array([180., 180., 180., 210.])
-    surface_tilt = np.array([30., 60., 0., 30.])
-    gcr = 1.0
-    result = infinite_sheds._shaded_fraction(
-        solar_zenith, solar_azimuth, surface_tilt, surface_azimuth, gcr)
-    x = 0.75 + np.sqrt(3) / 2
-    expected = np.array([0.0, 0.5, 0., (x - 1) / x])
-    assert np.allclose(result, expected)
-
-
-def test_get_irradiance_poa():
-    # singleton inputs
-    solar_zenith = 0.
-    solar_azimuth = 180.
-    surface_tilt = 0.
-    surface_azimuth = 180.
-    gcr = 0.5
-    height = 1.
-    pitch = 1
-    ghi = 1000
-    dhi = 300
-    dni = 700
-    albedo = 0
-    iam = 1.0
-    npoints = 100
-    res = infinite_sheds.get_irradiance_poa(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-        gcr, height, pitch, ghi, dhi, dni,
-        albedo, iam=iam, npoints=npoints)
-    expected_diffuse = np.array([300.])
-    expected_direct = np.array([700.])
-    expected_global = expected_diffuse + expected_direct
-    expected_shaded_fraction = np.array([0.])
-    assert np.isclose(res['poa_global'], expected_global)
-    assert np.isclose(res['poa_diffuse'], expected_diffuse)
-    assert np.isclose(res['poa_direct'], expected_direct)
-    assert np.isclose(res['shaded_fraction'], expected_shaded_fraction)
-    # vector inputs
-    surface_tilt = np.array([0., 0., 0., 0.])
-    height = 1.
-    surface_azimuth = np.array([180., 180., 180., 180.])
-    gcr = 0.5
-    pitch = 1
-    solar_zenith = np.array([0., 45., 45., 90.])
-    solar_azimuth = np.array([180., 180., 135., 180.])
-    expected_diffuse = np.array([300., 300., 300., 300.])
-    expected_direct = np.array(
-        [700., 350. * np.sqrt(2), 350. * np.sqrt(2), 0.])
-    expected_global = expected_diffuse + expected_direct
-    expected_shaded_fraction = np.array(
-        [0., 0., 0., 0.])
-    res = infinite_sheds.get_irradiance_poa(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-        gcr, height, pitch, ghi, dhi, dni,
-        albedo, iam=iam, npoints=npoints)
-    assert np.allclose(res['poa_global'], expected_global)
-    assert np.allclose(res['poa_diffuse'], expected_diffuse)
-    assert np.allclose(res['poa_direct'], expected_direct)
-    assert np.allclose(res['shaded_fraction'], expected_shaded_fraction)
-    # series inputs
-    surface_tilt = pd.Series(surface_tilt)
-    surface_azimuth = pd.Series(data=surface_azimuth, index=surface_tilt.index)
-    solar_zenith = pd.Series(solar_zenith, index=surface_tilt.index)
-    solar_azimuth = pd.Series(data=solar_azimuth, index=surface_tilt.index)
-    expected_diffuse = pd.Series(
-        data=expected_diffuse, index=surface_tilt.index)
-    expected_direct = pd.Series(
-        data=expected_direct, index=surface_tilt.index)
-    expected_global = expected_diffuse + expected_direct
-    expected_global.name = 'poa_global'  # to match output Series
-    expected_shaded_fraction = pd.Series(
-        data=expected_shaded_fraction, index=surface_tilt.index)
-    expected_shaded_fraction.name = 'shaded_fraction'  # to match output Series
-    res = infinite_sheds.get_irradiance_poa(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-        gcr, height, pitch, ghi, dhi, dni,
-        albedo, iam=iam, npoints=npoints)
-    assert isinstance(res, pd.DataFrame)
-    assert_series_equal(res['poa_global'], expected_global)
-    assert_series_equal(res['shaded_fraction'], expected_shaded_fraction)
-    assert all(k in res.columns for k in [
-        'poa_global', 'poa_diffuse', 'poa_direct', 'poa_ground_diffuse',
-        'poa_sky_diffuse', 'shaded_fraction'])
-
-
-def test__backside_tilt():
-    tilt = np.array([0., 30., 30., 180.])
-    system_azimuth = np.array([180., 150., 270., 0.])
-    back_tilt, back_az = infinite_sheds._backside(tilt, system_azimuth)
-    assert np.allclose(back_tilt, np.array([180., 150., 150., 0.]))
-    assert np.allclose(back_az, np.array([0., 330., 90., 180.]))
-
-
-@pytest.mark.parametrize("vectorize", [True, False])
-def test_get_irradiance(vectorize):
-    # singleton inputs
-    solar_zenith = 0.
-    solar_azimuth = 180.
-    surface_tilt = 0.
-    surface_azimuth = 180.
-    gcr = 0.5
-    height = 1.
-    pitch = 1.
-    ghi = 1000.
-    dhi = 300.
-    dni = 700.
-    albedo = 0.
-    iam_front = 1.0
-    iam_back = 1.0
-    npoints = 100
-    result = infinite_sheds.get_irradiance(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-        gcr, height, pitch, ghi, dhi, dni, albedo, iam_front, iam_back,
-        bifaciality=0.8, shade_factor=-0.02, transmission_factor=0,
-        npoints=npoints, vectorize=vectorize)
-    expected_front_diffuse = np.array([300.])
-    expected_front_direct = np.array([700.])
-    expected_front_global = expected_front_diffuse + expected_front_direct
-    expected_shaded_fraction_front = np.array([0.])
-    expected_shaded_fraction_back = np.array([0.])
-    assert np.isclose(result['poa_front'], expected_front_global)
-    assert np.isclose(result['poa_front_diffuse'], expected_front_diffuse)
-    assert np.isclose(result['poa_front_direct'], expected_front_direct)
-    assert np.isclose(result['poa_global'], result['poa_front'])
-    assert np.isclose(result['shaded_fraction_front'],
-                      expected_shaded_fraction_front)
-    assert np.isclose(result['shaded_fraction_back'],
-                      expected_shaded_fraction_back)
-    # series inputs
-    ghi = pd.Series([1000., 500., 500., np.nan])
-    dhi = pd.Series([300., 500., 500., 500.], index=ghi.index)
-    dni = pd.Series([700., 0., 0., 700.], index=ghi.index)
-    solar_zenith = pd.Series([0., 0., 0., 135.], index=ghi.index)
-    surface_tilt = pd.Series([0., 0., 90., 0.], index=ghi.index)
-    result = infinite_sheds.get_irradiance(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-        gcr, height, pitch, ghi, dhi, dni, albedo, iam_front, iam_back,
-        bifaciality=0.8, shade_factor=-0.02, transmission_factor=0,
-        npoints=npoints, vectorize=vectorize)
-    result_front = infinite_sheds.get_irradiance_poa(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-        gcr, height, pitch, ghi, dhi, dni,
-        albedo, iam=iam_front, vectorize=vectorize)
-    assert isinstance(result, pd.DataFrame)
-    expected_poa_global = pd.Series(
-        [1000., 500., result_front['poa_global'][2] * (1 + 0.8 * 0.98),
-         np.nan], index=ghi.index, name='poa_global')
-    expected_shaded_fraction = pd.Series(
-        result_front['shaded_fraction'], index=ghi.index,
-        name='shaded_fraction_front')
-    assert_series_equal(result['poa_global'], expected_poa_global)
-    assert_series_equal(result['shaded_fraction_front'],
-                        expected_shaded_fraction)
-
-
-def test_get_irradiance_limiting_gcr():
-    # test confirms that irradiance on widely spaced rows is approximately
-    # the same as for a single row array
-    solar_zenith = 0.
-    solar_azimuth = 180.
-    surface_tilt = 90.
-    surface_azimuth = 180.
-    gcr = 0.00001
-    height = 1.
-    pitch = 100.
-    ghi = 1000.
-    dhi = 300.
-    dni = 700.
-    albedo = 1.
-    iam_front = 1.0
-    iam_back = 1.0
-    npoints = 100
-    result = infinite_sheds.get_irradiance(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-        gcr, height, pitch, ghi, dhi, dni, albedo, iam_front, iam_back,
-        bifaciality=1., shade_factor=-0.00, transmission_factor=0.,
-        npoints=npoints)
-    expected_ground_diffuse = np.array([500.])
-    expected_sky_diffuse = np.array([150.])
-    expected_direct = np.array([0.])
-    expected_diffuse = expected_ground_diffuse + expected_sky_diffuse
-    expected_poa = expected_diffuse + expected_direct
-    expected_shaded_fraction_front = np.array([0.])
-    expected_shaded_fraction_back = np.array([0.])
-    assert np.isclose(result['poa_front'], expected_poa, rtol=0.01)
-    assert np.isclose(result['poa_front_diffuse'], expected_diffuse, rtol=0.01)
-    assert np.isclose(result['poa_front_direct'], expected_direct)
-    assert np.isclose(result['poa_front_sky_diffuse'], expected_sky_diffuse,
-                      rtol=0.01)
-    assert np.isclose(result['poa_front_ground_diffuse'],
-                      expected_ground_diffuse, rtol=0.01)
-    assert np.isclose(result['poa_front'], result['poa_back'])
-    assert np.isclose(result['poa_front_diffuse'], result['poa_back_diffuse'])
-    assert np.isclose(result['poa_front_direct'], result['poa_back_direct'])
-    assert np.isclose(result['poa_front_sky_diffuse'],
-                      result['poa_back_sky_diffuse'])
-    assert np.isclose(result['poa_front_ground_diffuse'],
-                      result['poa_back_ground_diffuse'])
-    assert np.isclose(result['shaded_fraction_front'],
-                      expected_shaded_fraction_front)
-    assert np.isclose(result['shaded_fraction_back'],
-                      expected_shaded_fraction_back)
-
-
-def test_get_irradiance_with_haydavies():
-    # singleton inputs
-    solar_zenith = 0.
-    solar_azimuth = 180.
-    surface_tilt = 0.
-    surface_azimuth = 180.
-    gcr = 0.5
-    height = 1.
-    pitch = 1.
-    ghi = 1000.
-    dhi = 300.
-    dni = 700.
-    albedo = 0.
-    dni_extra = 1413.
-    model = 'haydavies'
-    iam_front = 1.0
-    iam_back = 1.0
-    npoints = 100
-    result = infinite_sheds.get_irradiance(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-        gcr, height, pitch, ghi, dhi, dni, albedo, model, dni_extra,
-        iam_front, iam_back, bifaciality=0.8, shade_factor=-0.02,
-        transmission_factor=0, npoints=npoints)
-    expected_front_diffuse = np.array([151.38])
-    expected_front_direct = np.array([848.62])
-    expected_front_global = expected_front_diffuse + expected_front_direct
-    expected_shaded_fraction_front = np.array([0.])
-    expected_shaded_fraction_back = np.array([0.])
-    assert np.isclose(result['poa_front'], expected_front_global)
-    assert np.isclose(result['poa_front_diffuse'], expected_front_diffuse)
-    assert np.isclose(result['poa_front_direct'], expected_front_direct)
-    assert np.isclose(result['poa_global'], result['poa_front'])
-    assert np.isclose(result['shaded_fraction_front'],
-                      expected_shaded_fraction_front)
-    assert np.isclose(result['shaded_fraction_back'],
-                      expected_shaded_fraction_back)
-    # test for when dni_extra is not supplied
-    with pytest.raises(ValueError, match='supply dni_extra for haydavies'):
-        result = infinite_sheds.get_irradiance(
-            surface_tilt, surface_azimuth, solar_zenith, solar_azimuth,
-            gcr, height, pitch, ghi, dhi, dni, albedo, model, None,
-            iam_front, iam_back, bifaciality=0.8, shade_factor=-0.02,
-            transmission_factor=0, npoints=npoints)

pvlib/tests/bifacial/test_losses_models.py

@@ -1,54 +0,0 @@
-from pvlib import bifacial
-
-import pandas as pd
-import numpy as np
-from numpy.testing import assert_allclose
-
-
-def test_power_mismatch_deline():
-    """tests bifacial.power_mismatch_deline"""
-    premise_rmads = np.array([0.0, 0.05, 0.1, 0.15, 0.2, 0.25])
-    # test default model is for fixed tilt
-    expected_ft_mms = np.array([0.0, 0.0151, 0.0462, 0.0933, 0.1564, 0.2355])
-    result_def_mms = bifacial.power_mismatch_deline(premise_rmads)
-    assert_allclose(result_def_mms, expected_ft_mms, atol=1e-5)
-    assert np.all(np.diff(result_def_mms) > 0)  # higher RMADs => higher losses
-
-    # test custom coefficients, set model to 1+1*RMAD
-    # as Polynomial class
-    polynomial = np.polynomial.Polynomial([1, 1, 0])
-    result_custom_mms = bifacial.power_mismatch_deline(
-        premise_rmads, coefficients=polynomial
-    )
-    assert_allclose(result_custom_mms, 1 + premise_rmads)
-    # as list
-    result_custom_mms = bifacial.power_mismatch_deline(
-        premise_rmads, coefficients=[1, 1, 0]
-    )
-    assert_allclose(result_custom_mms, 1 + premise_rmads)
-
-    # test datatypes IO with Series
-    result_mms = bifacial.power_mismatch_deline(pd.Series(premise_rmads))
-    assert isinstance(result_mms, pd.Series)
-
-    # test fill_factor, fill_factor_reference
-    # default model + default fill_factor_reference
-    ff_ref_default = 0.79
-    ff_of_interest = 0.65
-    result_mms = bifacial.power_mismatch_deline(
-        premise_rmads, fill_factor=ff_of_interest
-    )
-    assert_allclose(
-        result_mms,
-        expected_ft_mms * ff_of_interest / ff_ref_default,
-        atol=1e-5,
-    )
-    # default model + custom fill_factor_reference
-    ff_of_interest = 0.65
-    ff_ref = 0.75
-    result_mms = bifacial.power_mismatch_deline(
-        premise_rmads, fill_factor=ff_of_interest, fill_factor_reference=ff_ref
-    )
-    assert_allclose(
-        result_mms, expected_ft_mms * ff_of_interest / ff_ref, atol=1e-5
-    )

pvlib/tests/bifacial/test_pvfactors.py

@@ -1,82 +0,0 @@
-import pandas as pd
-from datetime import datetime
-from pvlib.bifacial.pvfactors import pvfactors_timeseries
-from ..conftest import requires_pvfactors, assert_series_equal
-import pytest
-
-
-@pytest.fixture
-def example_values():
-    """
-    Example values from the pvfactors github repo README file:
-    https://github.com/SunPower/pvfactors/blob/master/README.rst#quick-start
-    """
-    inputs = dict(
-        timestamps=pd.DatetimeIndex([datetime(2017, 8, 31, 11),
-                                     datetime(2017, 8, 31, 12)]),
-        solar_zenith=[20., 10.],
-        solar_azimuth=[110., 140.],
-        surface_tilt=[10., 0.],
-        surface_azimuth=[90., 90.],
-        axis_azimuth=0.,
-        dni=[1000., 300.],
-        dhi=[50., 500.],
-        gcr=0.4,
-        pvrow_height=1.75,
-        pvrow_width=2.44,
-        albedo=0.2,
-        n_pvrows=3,
-        index_observed_pvrow=1,
-        rho_front_pvrow=0.03,
-        rho_back_pvrow=0.05,
-        horizon_band_angle=15.,
-    )
-    outputs = dict(
-        expected_ipoa_front=pd.Series([1034.95474708997, 795.4423259036623],
-                                      index=inputs['timestamps'],
-                                      name=('total_inc_front')),
-        expected_ipoa_back=pd.Series([92.12563846416197, 78.05831585685098],
-                                     index=inputs['timestamps'],
-                                     name=('total_inc_back')),
-    )
-    return inputs, outputs
-
-
-@requires_pvfactors
-def test_pvfactors_timeseries_list(example_values):
-    """Test basic pvfactors functionality with list inputs"""
-    inputs, outputs = example_values
-    ipoa_inc_front, ipoa_inc_back, _, _ = pvfactors_timeseries(**inputs)
-    assert_series_equal(ipoa_inc_front, outputs['expected_ipoa_front'])
-    assert_series_equal(ipoa_inc_back, outputs['expected_ipoa_back'])
-
-
-@requires_pvfactors
-def test_pvfactors_timeseries_pandas(example_values):
-    """Test basic pvfactors functionality with Series inputs"""
-
-    inputs, outputs = example_values
-    for key in ['solar_zenith', 'solar_azimuth', 'surface_tilt',
-                'surface_azimuth', 'dni', 'dhi']:
-        inputs[key] = pd.Series(inputs[key], index=inputs['timestamps'])
-
-    ipoa_inc_front, ipoa_inc_back, _, _ = pvfactors_timeseries(**inputs)
-    assert_series_equal(ipoa_inc_front, outputs['expected_ipoa_front'])
-    assert_series_equal(ipoa_inc_back, outputs['expected_ipoa_back'])
-
-
-@requires_pvfactors
-def test_pvfactors_scalar_orientation(example_values):
-    """test that surface_tilt and surface_azimuth inputs can be scalars"""
-    # GH 1127, GH 1332
-    inputs, outputs = example_values
-    inputs['surface_tilt'] = 10.
-    inputs['surface_azimuth'] = 90.
-    # the second tilt is supposed to be zero, so we need to
-    # update the expected irradiances too:
-    outputs['expected_ipoa_front'].iloc[1] = 800.6524022701132
-    outputs['expected_ipoa_back'].iloc[1] = 81.72135884745822
-
-    ipoa_inc_front, ipoa_inc_back, _, _ = pvfactors_timeseries(**inputs)
-    assert_series_equal(ipoa_inc_front, outputs['expected_ipoa_front'])
-    assert_series_equal(ipoa_inc_back, outputs['expected_ipoa_back'])