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

pvlib/tests/test_irradiance.py

@@ -1,1487 +0,0 @@
-import datetime
-from collections import OrderedDict
-import warnings
-
-import numpy as np
-from numpy import array, nan
-import pandas as pd
-
-import pytest
-from numpy.testing import (assert_almost_equal,
-                           assert_allclose)
-from pvlib import irradiance, albedo
-
-from .conftest import (
-    assert_frame_equal,
-    assert_series_equal,
-    requires_ephem,
-    requires_numba,
-    fail_on_pvlib_version,
-)
-
-from pvlib._deprecation import pvlibDeprecationWarning
-
-# fixtures create realistic test input data
-# test input data generated at Location(32.2, -111, 'US/Arizona', 700)
-# test input data is hard coded to avoid dependencies on other parts of pvlib
-
-
-@pytest.fixture
-def times():
-    # must include night values
-    return pd.date_range(start='20140624', freq='6h', periods=4,
-                         tz='US/Arizona')
-
-
-@pytest.fixture
-def irrad_data(times):
-    return pd.DataFrame(np.array(
-        [[0.,    0.,    0.],
-         [79.73860422,  316.1949056,   40.46149818],
-         [1042.48031487,  939.95469881,  118.45831879],
-         [257.20751138,  646.22886049,   62.03376265]]),
-        columns=['ghi', 'dni', 'dhi'], index=times)
-
-
-@pytest.fixture
-def ephem_data(times):
-    return pd.DataFrame(np.array(
-        [[124.0390863, 124.0390863, -34.0390863, -34.0390863,
-          352.69550699,  -2.36677158],
-         [82.85457044,  82.97705621,   7.14542956,   7.02294379,
-          66.71410338,  -2.42072165],
-         [10.56413562,  10.56725766,  79.43586438,  79.43274234,
-          144.76567754,  -2.47457321],
-         [72.41687122,  72.46903556,  17.58312878,  17.53096444,
-          287.04104128,  -2.52831909]]),
-        columns=['apparent_zenith', 'zenith', 'apparent_elevation',
-                 'elevation', 'azimuth', 'equation_of_time'],
-        index=times)
-
-
-@pytest.fixture
-def dni_et():
-    return np.array(
-        [1321.1655834833093, 1321.1655834833093, 1321.1655834833093,
-         1321.1655834833093])
-
-
-@pytest.fixture
-def relative_airmass(times):
-    return pd.Series([np.nan, 7.58831596, 1.01688136, 3.27930443], times)
-
-
-# setup for et rad test. put it here for readability
-timestamp = pd.Timestamp('20161026')
-dt_index = pd.DatetimeIndex([timestamp])
-doy = timestamp.dayofyear
-dt_date = timestamp.date()
-dt_datetime = datetime.datetime.combine(dt_date, datetime.time(0))
-dt_np64 = np.datetime64(dt_datetime)
-value = 1383.636203
-
-
-@pytest.mark.parametrize('testval, expected', [
-    (doy, value),
-    (np.float64(doy), value),
-    (dt_date, value),
-    (dt_datetime, value),
-    (dt_np64, value),
-    (np.array([doy]), np.array([value])),
-    (pd.Series([doy]), np.array([value])),
-    (dt_index, pd.Series([value], index=dt_index)),
-    (timestamp, value)
-])
-@pytest.mark.parametrize('method', [
-    'asce', 'spencer', 'nrel', pytest.param('pyephem', marks=requires_ephem)])
-def test_get_extra_radiation(testval, expected, method):
-    out = irradiance.get_extra_radiation(testval, method=method)
-    assert_allclose(out, expected, atol=10)
-
-
-def test_get_extra_radiation_epoch_year():
-    out = irradiance.get_extra_radiation(doy, method='nrel', epoch_year=2012)
-    assert_allclose(out, 1382.4926804890767, atol=0.1)
-
-
-@requires_numba
-def test_get_extra_radiation_nrel_numba(times):
-    with warnings.catch_warnings():
-        # don't warn on method reload
-        warnings.simplefilter("ignore")
-        result = irradiance.get_extra_radiation(
-            times, method='nrel', how='numba', numthreads=4)
-        # and reset to no-numba state
-        irradiance.get_extra_radiation(times, method='nrel')
-    assert_allclose(result,
-                    [1322.332316, 1322.296282, 1322.261205, 1322.227091])
-
-
-def test_get_extra_radiation_invalid():
-    with pytest.raises(ValueError):
-        irradiance.get_extra_radiation(300, method='invalid')
-
-
-def test_get_ground_diffuse_simple_float():
-    result = irradiance.get_ground_diffuse(40, 900)
-    assert_allclose(result, 26.32000014911496)
-
-
-def test_get_ground_diffuse_simple_series(irrad_data):
-    ground_irrad = irradiance.get_ground_diffuse(40, irrad_data['ghi'])
-    assert ground_irrad.name == 'diffuse_ground'
-
-
-def test_get_ground_diffuse_albedo_0(irrad_data):
-    ground_irrad = irradiance.get_ground_diffuse(
-        40, irrad_data['ghi'], albedo=0)
-    assert (0 == ground_irrad).all()
-
-
-def test_get_ground_diffuse_albedo_series(times):
-    albedo = pd.Series(0.2, index=times)
-    ground_irrad = irradiance.get_ground_diffuse(
-        45, pd.Series(1000, index=times), albedo)
-    expected = albedo * 0.5 * (1 - np.sqrt(2) / 2.) * 1000
-    expected.name = 'diffuse_ground'
-    assert_series_equal(ground_irrad, expected)
-
-
-def test_grounddiffuse_albedo_invalid_surface(irrad_data):
-    with pytest.raises(KeyError):
-        irradiance.get_ground_diffuse(
-            40, irrad_data['ghi'], surface_type='invalid')
-
-
-def test_get_ground_diffuse_albedo_surface(irrad_data):
-    result = irradiance.get_ground_diffuse(40, irrad_data['ghi'],
-                                           surface_type='sand')
-    assert_allclose(result, [0, 3.731058, 48.778813, 12.035025], atol=1e-4)
-
-
-def test_isotropic_float():
-    result = irradiance.isotropic(40, 100)
-    assert_allclose(result, 88.30222215594891)
-
-
-def test_isotropic_series(irrad_data):
-    result = irradiance.isotropic(40, irrad_data['dhi'])
-    assert_allclose(result, [0, 35.728402, 104.601328, 54.777191], atol=1e-4)
-
-
-def test_klucher_series_float():
-    # klucher inputs
-    surface_tilt, surface_azimuth = 40.0, 180.0
-    dhi, ghi = 100.0, 900.0
-    solar_zenith, solar_azimuth = 20.0, 180.0
-    # expect same result for floats and pd.Series
-    expected = irradiance.klucher(
-        surface_tilt, surface_azimuth,
-        pd.Series(dhi), pd.Series(ghi),
-        pd.Series(solar_zenith), pd.Series(solar_azimuth)
-    )  # 94.99429931664851
-    result = irradiance.klucher(
-        surface_tilt, surface_azimuth, dhi, ghi, solar_zenith, solar_azimuth
-    )
-    assert_allclose(result, expected[0])
-
-
-def test_klucher_series(irrad_data, ephem_data):
-    result = irradiance.klucher(40, 180, irrad_data['dhi'], irrad_data['ghi'],
-                                ephem_data['apparent_zenith'],
-                                ephem_data['azimuth'])
-    # pvlib matlab 1.4 does not contain the max(cos_tt, 0) correction
-    # so, these values are different
-    assert_allclose(result, [0., 36.789794, 109.209347, 56.965916], atol=1e-4)
-    # expect same result for np.array and pd.Series
-    expected = irradiance.klucher(
-        40, 180, irrad_data['dhi'].values, irrad_data['ghi'].values,
-        ephem_data['apparent_zenith'].values, ephem_data['azimuth'].values
-    )
-    assert_allclose(result, expected, atol=1e-4)
-
-
-def test_haydavies(irrad_data, ephem_data, dni_et):
-    result = irradiance.haydavies(
-        40, 180, irrad_data['dhi'], irrad_data['dni'], dni_et,
-        ephem_data['apparent_zenith'], ephem_data['azimuth'])
-    # values from matlab 1.4 code
-    assert_allclose(result, [0, 27.1775, 102.9949, 33.1909], atol=1e-4)
-
-
-def test_haydavies_components(irrad_data, ephem_data, dni_et):
-    expected = pd.DataFrame(np.array(
-        [[0, 27.1775, 102.9949, 33.1909],
-         [0, 27.1775, 30.1818, 27.9837],
-         [0, 0, 72.8130, 5.2071],
-         [0, 0, 0, 0]]).T,
-        columns=['sky_diffuse', 'isotropic', 'circumsolar', 'horizon'],
-        index=irrad_data.index
-    )
-    # pandas
-    result = irradiance.haydavies(
-        40, 180, irrad_data['dhi'], irrad_data['dni'], dni_et,
-        ephem_data['apparent_zenith'], ephem_data['azimuth'],
-        return_components=True)
-    assert_frame_equal(result, expected, check_less_precise=4)
-    # numpy
-    result = irradiance.haydavies(
-        40, 180, irrad_data['dhi'].values, irrad_data['dni'].values, dni_et,
-        ephem_data['apparent_zenith'].values, ephem_data['azimuth'].values,
-        return_components=True)
-    assert_allclose(result['sky_diffuse'], expected['sky_diffuse'], atol=1e-4)
-    assert_allclose(result['isotropic'], expected['isotropic'], atol=1e-4)
-    assert_allclose(result['circumsolar'], expected['circumsolar'], atol=1e-4)
-    assert_allclose(result['horizon'], expected['horizon'], atol=1e-4)
-    assert isinstance(result, dict)
-    # scalar
-    result = irradiance.haydavies(
-        40, 180, irrad_data['dhi'].values[-1], irrad_data['dni'].values[-1],
-        dni_et[-1], ephem_data['apparent_zenith'].values[-1],
-        ephem_data['azimuth'].values[-1], return_components=True)
-    assert_allclose(result['sky_diffuse'], expected['sky_diffuse'].iloc[-1],
-                    atol=1e-4)
-    assert_allclose(result['isotropic'], expected['isotropic'].iloc[-1],
-                    atol=1e-4)
-    assert_allclose(result['circumsolar'], expected['circumsolar'].iloc[-1],
-                    atol=1e-4)
-    assert_allclose(result['horizon'], expected['horizon'].iloc[-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'],
-        dni_et, ephem_data['apparent_zenith'], ephem_data['azimuth'])
-    # values from matlab 1.4 code
-    assert_allclose(result, [0., 27.9412, 104.1317, 34.1663], atol=1e-4)
-
-
-def test_king(irrad_data, ephem_data):
-    result = irradiance.king(40, irrad_data['dhi'], irrad_data['ghi'],
-                             ephem_data['apparent_zenith'])
-    assert_allclose(result, [0, 44.629352, 115.182626, 79.719855], atol=1e-4)
-
-
-def test_perez(irrad_data, ephem_data, dni_et, relative_airmass):
-    dni = irrad_data['dni'].copy()
-    dni.iloc[2] = np.nan
-    out = irradiance.perez(40, 180, irrad_data['dhi'], dni,
-                           dni_et, ephem_data['apparent_zenith'],
-                           ephem_data['azimuth'], relative_airmass)
-    expected = pd.Series(np.array(
-        [0.,   31.46046871,  np.nan,   45.45539877]),
-        index=irrad_data.index)
-    assert_series_equal(out, expected, check_less_precise=2)
-
-
-def test_perez_driesse(irrad_data, ephem_data, dni_et, relative_airmass):
-    dni = irrad_data['dni'].copy()
-    dni.iloc[2] = np.nan
-    out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni,
-                                   dni_et, ephem_data['apparent_zenith'],
-                                   ephem_data['azimuth'], relative_airmass)
-    expected = pd.Series(np.array(
-        [0.,   29.991,  np.nan,   47.397]),
-        index=irrad_data.index)
-    assert_series_equal(out, expected, check_less_precise=2)
-
-
-def test_perez_driesse_airmass(irrad_data, ephem_data, dni_et):
-    dni = irrad_data['dni'].copy()
-    dni.iloc[2] = np.nan
-    out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni,
-                                   dni_et, ephem_data['apparent_zenith'],
-                                   ephem_data['azimuth'], airmass=None)
-    print(out)
-    expected = pd.Series(np.array(
-        [0.,   29.991,  np.nan,   47.397]),
-        index=irrad_data.index)
-    assert_series_equal(out, expected, check_less_precise=2)
-
-
-def test_perez_components(irrad_data, ephem_data, dni_et, relative_airmass):
-    dni = irrad_data['dni'].copy()
-    dni.iloc[2] = np.nan
-    out = irradiance.perez(40, 180, irrad_data['dhi'], dni,
-                           dni_et, ephem_data['apparent_zenith'],
-                           ephem_data['azimuth'], relative_airmass,
-                           return_components=True)
-    expected = pd.DataFrame(np.array(
-        [[0.,   31.46046871,  np.nan,   45.45539877],
-         [0.,  26.84138589,          np.nan,  31.72696071],
-         [0.,  0.,         np.nan,  4.47966439],
-         [0.,  4.62212181,         np.nan,  9.25316454]]).T,
-        columns=['sky_diffuse', 'isotropic', 'circumsolar', 'horizon'],
-        index=irrad_data.index
-    )
-    expected_for_sum = expected['sky_diffuse'].copy()
-    expected_for_sum.iloc[2] = 0
-    sum_components = out.iloc[:, 1:].sum(axis=1)
-    sum_components.name = 'sky_diffuse'
-
-    assert_frame_equal(out, expected, check_less_precise=2)
-    assert_series_equal(sum_components, expected_for_sum, check_less_precise=2)
-
-
-def test_perez_driesse_components(irrad_data, ephem_data, dni_et,
-                                  relative_airmass):
-    dni = irrad_data['dni'].copy()
-    dni.iloc[2] = np.nan
-    out = irradiance.perez_driesse(40, 180, irrad_data['dhi'], dni,
-                                   dni_et, ephem_data['apparent_zenith'],
-                                   ephem_data['azimuth'], relative_airmass,
-                                   return_components=True)
-
-    expected = pd.DataFrame(np.array(
-        [[0., 29.991, np.nan, 47.397],
-         [0., 25.806, np.nan, 33.181],
-         [0.,  0.000, np.nan,  4.197],
-         [0.,  4.184, np.nan, 10.018]]).T,
-        columns=['sky_diffuse', 'isotropic', 'circumsolar', 'horizon'],
-        index=irrad_data.index
-    )
-    expected_for_sum = expected['sky_diffuse'].copy()
-    expected_for_sum.iloc[2] = 0
-    sum_components = out.iloc[:, 1:].sum(axis=1)
-    sum_components.name = 'sky_diffuse'
-
-    assert_frame_equal(out, expected, check_less_precise=2)
-    assert_series_equal(sum_components, expected_for_sum, check_less_precise=2)
-
-
-def test_perez_negative_horizon():
-    times = pd.date_range(start='20190101 11:30:00', freq='1h',
-                          periods=5, tz='US/Central')
-
-    # Avoid test dependencies on functionality not being tested by hard-coding
-    # the inputs. This data corresponds to Goodwin Creek in the afternoon on
-    # 1/1/2019.
-    # dni_e is slightly rounded from irradiance.get_extra_radiation
-    # airmass from atmosphere.get_relative_airmas
-    inputs = pd.DataFrame(np.array(
-        [[158,         19,          1,          0,          0],
-         [249,        165,        136,         93,         50],
-         [57.746951,  57.564205,  60.813841,  66.989435,  75.353368],
-         [171.003315, 187.346924, 202.974357, 216.725599, 228.317233],
-         [1414,       1414,       1414,       1414,       1414],
-         [1.869315,   1.859981,   2.044429,   2.544943,   3.900136]]).T,
-        columns=['dni', 'dhi', 'solar_zenith',
-                 'solar_azimuth', 'dni_extra', 'airmass'],
-        index=times
-    )
-
-    out = irradiance.perez(34, 180, inputs['dhi'], inputs['dni'],
-                           inputs['dni_extra'], inputs['solar_zenith'],
-                           inputs['solar_azimuth'], inputs['airmass'],
-                           model='allsitescomposite1990',
-                           return_components=True)
-
-    # sky_diffuse can be less than isotropic under certain conditions as
-    # horizon goes negative
-    expected = pd.DataFrame(np.array(
-        [[281.410185, 152.20879, 123.867898, 82.836412, 43.517015],
-         [166.785419, 142.24475, 119.173875, 83.525150, 45.725931],
-         [113.548755,  16.09757,   9.956174,  3.142467,  0],
-         [1.076010,  -6.13353,  -5.262151, -3.831230, -2.208923]]).T,
-        columns=['sky_diffuse', 'isotropic', 'circumsolar', 'horizon'],
-        index=times
-    )
-
-    expected_for_sum = expected['sky_diffuse'].copy()
-    sum_components = out.iloc[:, 1:].sum(axis=1)
-    sum_components.name = 'sky_diffuse'
-
-    assert_frame_equal(out, expected, check_less_precise=2)
-    assert_series_equal(sum_components, expected_for_sum, check_less_precise=2)
-
-
-def test_perez_arrays(irrad_data, ephem_data, dni_et, relative_airmass):
-    dni = irrad_data['dni'].copy()
-    dni.iloc[2] = np.nan
-    out = irradiance.perez(40, 180, irrad_data['dhi'].values, dni.values,
-                           dni_et, ephem_data['apparent_zenith'].values,
-                           ephem_data['azimuth'].values,
-                           relative_airmass.values)
-    expected = np.array(
-        [0.,   31.46046871,  np.nan,   45.45539877])
-    assert_allclose(out, expected, atol=1e-2)
-    assert isinstance(out, np.ndarray)
-
-
-def test_perez_driesse_arrays(irrad_data, ephem_data, dni_et,
-                              relative_airmass):
-    dni = irrad_data['dni'].copy()
-    dni.iloc[2] = np.nan
-    out = irradiance.perez_driesse(40, 180, irrad_data['dhi'].values,
-                                   dni.values, dni_et,
-                                   ephem_data['apparent_zenith'].values,
-                                   ephem_data['azimuth'].values,
-                                   relative_airmass.values)
-    expected = np.array(
-        [0.,   29.990,  np.nan,   47.396])
-    assert_allclose(out, expected, atol=1e-2)
-    assert isinstance(out, np.ndarray)
-
-
-def test_perez_scalar():
-    # copied values from fixtures
-    out = irradiance.perez(40, 180, 118.45831879, 939.95469881,
-                           1321.1655834833093, 10.56413562, 144.76567754,
-                           1.01688136)
-    # this will fail. out is ndarry with ndim == 0. fix in future version.
-    # assert np.isscalar(out)
-    assert_allclose(out, 109.084332)
-
-
-def test_perez_driesse_scalar():
-    # copied values from fixtures
-    out = irradiance.perez_driesse(40, 180, 118.458, 939.954,
-                                   1321.165, 10.564, 144.765, 1.016)
-    # this will fail. out is ndarry with ndim == 0. fix in future version.
-    # assert np.isscalar(out)
-    assert_allclose(out, 110.341, atol=1e-2)
-
-
-@pytest.mark.parametrize('model', ['isotropic', 'klucher', 'haydavies',
-                                   'reindl', 'king', 'perez', 'perez-driesse'])
-def test_sky_diffuse_zenith_close_to_90(model):
-    # GH 432
-    sky_diffuse = irradiance.get_sky_diffuse(
-        30, 180, 89.999, 230,
-        dni=10, ghi=51, dhi=50, dni_extra=1360, airmass=12, model=model)
-    assert sky_diffuse < 100
-
-
-def test_get_sky_diffuse_model_invalid():
-    with pytest.raises(ValueError):
-        irradiance.get_sky_diffuse(
-            30, 180, 0, 180, 1000, 1100, 100, dni_extra=1360, airmass=1,
-            model='invalid')
-
-
-def test_get_sky_diffuse_missing_dni_extra():
-    msg = 'dni_extra is required'
-    with pytest.raises(ValueError, match=msg):
-        irradiance.get_sky_diffuse(
-            30, 180, 0, 180, 1000, 1100, 100, airmass=1,
-            model='haydavies')
-
-
-def test_get_sky_diffuse_missing_airmass(irrad_data, ephem_data, dni_et):
-    # test assumes location is Tucson, AZ
-    # calculated airmass should be the equivalent to fixture airmass
-    dni = irrad_data['dni'].copy()
-    dni.iloc[2] = np.nan
-    out = irradiance.get_sky_diffuse(
-        40, 180, ephem_data['apparent_zenith'], ephem_data['azimuth'], dni,
-        irrad_data['ghi'], irrad_data['dhi'], dni_et,  model='perez')
-    expected = pd.Series(np.array(
-        [0., 31.46046871, np.nan, 45.45539877]),
-        index=irrad_data.index)
-    assert_series_equal(out, expected, check_less_precise=2)
-
-
-def test_campbell_norman():
-    expected = pd.DataFrame(np.array(
-        [[863.859736967, 653.123094076, 220.65905025]]),
-        columns=['ghi', 'dni', 'dhi'],
-        index=[0])
-    out = irradiance.campbell_norman(
-        pd.Series([10]), pd.Series([0.5]), pd.Series([109764.21013135818]),
-        dni_extra=1400)
-    assert_frame_equal(out, expected)
-
-
-def test_get_total_irradiance(irrad_data, ephem_data, dni_et,
-                              relative_airmass):
-    models = ['isotropic', 'klucher',
-              'haydavies', 'reindl', 'king', 'perez', 'perez-driesse']
-
-    for model in models:
-        total = irradiance.get_total_irradiance(
-            32, 180,
-            ephem_data['apparent_zenith'], ephem_data['azimuth'],
-            dni=irrad_data['dni'], ghi=irrad_data['ghi'],
-            dhi=irrad_data['dhi'],
-            dni_extra=dni_et, airmass=relative_airmass,
-            model=model,
-            surface_type='urban')
-
-        assert total.columns.tolist() == ['poa_global', 'poa_direct',
-                                          'poa_diffuse', 'poa_sky_diffuse',
-                                          'poa_ground_diffuse']
-
-
-@pytest.mark.parametrize('model', ['isotropic', 'klucher',
-                                   'haydavies', 'reindl', 'king',
-                                   'perez', 'perez-driesse'])
-def test_get_total_irradiance_albedo(
-        irrad_data, ephem_data, dni_et, relative_airmass, model):
-    albedo = pd.Series(0.2, index=ephem_data.index)
-    total = irradiance.get_total_irradiance(
-        32, 180,
-        ephem_data['apparent_zenith'], ephem_data['azimuth'],
-        dni=irrad_data['dni'], ghi=irrad_data['ghi'],
-        dhi=irrad_data['dhi'],
-        dni_extra=dni_et, airmass=relative_airmass,
-        model=model,
-        albedo=albedo)
-
-    assert total.columns.tolist() == ['poa_global', 'poa_direct',
-                                      'poa_diffuse', 'poa_sky_diffuse',
-                                      'poa_ground_diffuse']
-
-
-@pytest.mark.parametrize('model', ['isotropic', 'klucher',
-                                   'haydavies', 'reindl', 'king',
-                                   'perez', 'perez-driesse'])
-def test_get_total_irradiance_scalars(model):
-    total = irradiance.get_total_irradiance(
-        32, 180,
-        10, 180,
-        dni=1000, ghi=1100,
-        dhi=100,
-        dni_extra=1400, airmass=1,
-        model=model,
-        surface_type='urban')
-
-    assert list(total.keys()) == ['poa_global', 'poa_direct',
-                                  'poa_diffuse', 'poa_sky_diffuse',
-                                  'poa_ground_diffuse']
-    # test that none of the values are nan
-    assert np.isnan(np.array(list(total.values()))).sum() == 0
-
-
-def test_get_total_irradiance_missing_dni_extra():
-    msg = 'dni_extra is required'
-    with pytest.raises(ValueError, match=msg):
-        irradiance.get_total_irradiance(
-            32, 180,
-            10, 180,
-            dni=1000, ghi=1100,
-            dhi=100,
-            model='haydavies')
-
-
-def test_get_total_irradiance_missing_airmass():
-    total = irradiance.get_total_irradiance(
-        32, 180,
-        10, 180,
-        dni=1000, ghi=1100,
-        dhi=100,
-        dni_extra=1400,
-        model='perez')
-    assert list(total.keys()) == ['poa_global', 'poa_direct',
-                                  'poa_diffuse', 'poa_sky_diffuse',
-                                  'poa_ground_diffuse']
-
-
-def test_poa_components(irrad_data, ephem_data, dni_et, relative_airmass):
-    aoi = irradiance.aoi(40, 180, ephem_data['apparent_zenith'],
-                         ephem_data['azimuth'])
-    gr_sand = irradiance.get_ground_diffuse(40, irrad_data['ghi'],
-                                            surface_type='sand')
-    diff_perez = irradiance.perez(
-        40, 180, irrad_data['dhi'], irrad_data['dni'], dni_et,
-        ephem_data['apparent_zenith'], ephem_data['azimuth'], relative_airmass)
-    out = irradiance.poa_components(
-        aoi, irrad_data['dni'], diff_perez, gr_sand)
-    expected = pd.DataFrame(np.array(
-        [[0.,  -0.,   0.,   0.,
-            0.],
-         [35.19456561,   0.,  35.19456561,  31.4635077,
-            3.73105791],
-         [956.18253696, 798.31939281, 157.86314414, 109.08433162,
-          48.77881252],
-         [90.99624896,  33.50143401,  57.49481495,  45.45978964,
-          12.03502531]]),
-        columns=['poa_global', 'poa_direct', 'poa_diffuse', 'poa_sky_diffuse',
-                 'poa_ground_diffuse'],
-        index=irrad_data.index)
-    assert_frame_equal(out, expected)
-
-
-@pytest.mark.parametrize('pressure,expected', [
-    (93193,  [[830.46567,   0.79742,   0.93505],
-              [676.18340,   0.63782,   3.02102]]),
-    (None,   [[868.72425,   0.79742,   1.01664],
-              [680.73800,   0.63782,   3.28463]]),
-    (101325, [[868.72425,   0.79742,   1.01664],
-              [680.73800,   0.63782,   3.28463]])
-])
-def test_disc_value(pressure, expected):
-    # see GH 449 for pressure=None vs. 101325.
-    columns = ['dni', 'kt', 'airmass']
-    times = pd.DatetimeIndex(['2014-06-24T1200', '2014-06-24T1800'],
-                             tz='America/Phoenix')
-    ghi = pd.Series([1038.62, 254.53], index=times)
-    zenith = pd.Series([10.567, 72.469], index=times)
-    out = irradiance.disc(ghi, zenith, times, pressure=pressure)
-    expected_values = np.array(expected)
-    expected = pd.DataFrame(expected_values, columns=columns, index=times)
-    # check the pandas dataframe. check_less_precise is weird
-    assert_frame_equal(out, expected, check_less_precise=True)
-    # use np.assert_allclose to check values more clearly
-    assert_allclose(out.values, expected_values, atol=1e-5)
-
-
-def test_disc_overirradiance():
-    columns = ['dni', 'kt', 'airmass']
-    ghi = np.array([3000])
-    solar_zenith = np.full_like(ghi, 0)
-    times = pd.date_range(start='2016-07-19 12:00:00', freq='1s',
-                          periods=len(ghi), tz='America/Phoenix')
-    out = irradiance.disc(ghi=ghi, solar_zenith=solar_zenith,
-                          datetime_or_doy=times)
-    expected = pd.DataFrame(np.array(
-        [[8.72544336e+02, 1.00000000e+00, 9.99493933e-01]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-
-def test_disc_min_cos_zenith_max_zenith():
-    # map out behavior under difficult conditions with various
-    # limiting kwargs settings
-    columns = ['dni', 'kt', 'airmass']
-    times = pd.DatetimeIndex(['2016-07-19 06:11:00'], tz='America/Phoenix')
-    out = irradiance.disc(ghi=1.0, solar_zenith=89.99, datetime_or_doy=times)
-    expected = pd.DataFrame(np.array(
-        [[0.00000000e+00, 1.16046346e-02, 12.0]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # max_zenith and/or max_airmass keep these results reasonable
-    out = irradiance.disc(ghi=1.0, solar_zenith=89.99, datetime_or_doy=times,
-                          min_cos_zenith=0)
-    expected = pd.DataFrame(np.array(
-        [[0.00000000e+00, 1.0, 12.0]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # still get reasonable values because of max_airmass=12 limit
-    out = irradiance.disc(ghi=1.0, solar_zenith=89.99, datetime_or_doy=times,
-                          max_zenith=100)
-    expected = pd.DataFrame(np.array(
-        [[0., 1.16046346e-02, 12.0]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # still get reasonable values because of max_airmass=12 limit
-    out = irradiance.disc(ghi=1.0, solar_zenith=89.99, datetime_or_doy=times,
-                          min_cos_zenith=0, max_zenith=100)
-    expected = pd.DataFrame(np.array(
-        [[277.50185968, 1.0, 12.0]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # max_zenith keeps this result reasonable
-    out = irradiance.disc(ghi=1.0, solar_zenith=89.99, datetime_or_doy=times,
-                          min_cos_zenith=0, max_airmass=100)
-    expected = pd.DataFrame(np.array(
-        [[0.00000000e+00, 1.0, 36.39544757]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # allow zenith to be close to 90 and airmass to be infinite
-    # and we get crazy values
-    out = irradiance.disc(ghi=1.0, solar_zenith=89.99, datetime_or_doy=times,
-                          max_zenith=100, max_airmass=100)
-    expected = pd.DataFrame(np.array(
-        [[6.68577449e+03, 1.16046346e-02, 3.63954476e+01]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # allow min cos zenith to be 0, zenith to be close to 90,
-    # and airmass to be very big and we get even higher DNI values
-    out = irradiance.disc(ghi=1.0, solar_zenith=89.99, datetime_or_doy=times,
-                          min_cos_zenith=0, max_zenith=100, max_airmass=100)
-    expected = pd.DataFrame(np.array(
-        [[7.21238390e+03, 1., 3.63954476e+01]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-
-def test_dirint_value():
-    times = pd.DatetimeIndex(['2014-06-24T12-0700', '2014-06-24T18-0700'])
-    ghi = pd.Series([1038.62, 254.53], index=times)
-    zenith = pd.Series([10.567, 72.469], index=times)
-    pressure = 93193.
-    dirint_data = irradiance.dirint(ghi, zenith, times, pressure=pressure)
-    assert_almost_equal(dirint_data.values,
-                        np.array([868.8,  699.7]), 1)
-
-
-def test_dirint_nans():
-    times = pd.date_range(start='2014-06-24T12-0700', periods=5, freq='6h')
-    ghi = pd.Series([np.nan, 1038.62, 1038.62, 1038.62, 1038.62], index=times)
-    zenith = pd.Series([10.567, np.nan, 10.567, 10.567, 10.567], index=times)
-    pressure = pd.Series([93193., 93193., np.nan, 93193., 93193.], index=times)
-    temp_dew = pd.Series([10, 10, 10, np.nan, 10], index=times)
-    dirint_data = irradiance.dirint(ghi, zenith, times, pressure=pressure,
-                                    temp_dew=temp_dew)
-    assert_almost_equal(dirint_data.values,
-                        np.array([np.nan, np.nan, np.nan, np.nan, 893.1]), 1)
-
-
-def test_dirint_tdew():
-    times = pd.DatetimeIndex(['2014-06-24T12-0700', '2014-06-24T18-0700'])
-    ghi = pd.Series([1038.62, 254.53], index=times)
-    zenith = pd.Series([10.567, 72.469], index=times)
-    pressure = 93193.
-    dirint_data = irradiance.dirint(ghi, zenith, times, pressure=pressure,
-                                    temp_dew=10)
-    assert_almost_equal(dirint_data.values,
-                        np.array([882.1,  672.6]), 1)
-
-
-def test_dirint_no_delta_kt():
-    times = pd.DatetimeIndex(['2014-06-24T12-0700', '2014-06-24T18-0700'])
-    ghi = pd.Series([1038.62, 254.53], index=times)
-    zenith = pd.Series([10.567, 72.469], index=times)
-    pressure = 93193.
-    dirint_data = irradiance.dirint(ghi, zenith, times, pressure=pressure,
-                                    use_delta_kt_prime=False)
-    assert_almost_equal(dirint_data.values,
-                        np.array([861.9,  670.4]), 1)
-
-
-def test_dirint_coeffs():
-    coeffs = irradiance._get_dirint_coeffs()
-    assert coeffs[0, 0, 0, 0] == 0.385230
-    assert coeffs[0, 1, 2, 1] == 0.229970
-    assert coeffs[3, 2, 6, 3] == 1.032260
-
-
-def test_dirint_min_cos_zenith_max_zenith():
-    # map out behavior under difficult conditions with various
-    # limiting kwargs settings
-    # times don't have any physical relevance
-    times = pd.DatetimeIndex(['2014-06-24T12-0700', '2014-06-24T18-0700'])
-    ghi = pd.Series([0, 1], index=times)
-    solar_zenith = pd.Series([90, 89.99], index=times)
-
-    out = irradiance.dirint(ghi, solar_zenith, times)
-    expected = pd.Series([0.0, 0.0], index=times, name='dni')
-    assert_series_equal(out, expected)
-
-    out = irradiance.dirint(ghi, solar_zenith, times, min_cos_zenith=0)
-    expected = pd.Series([0.0, 0.0], index=times, name='dni')
-    assert_series_equal(out, expected)
-
-    out = irradiance.dirint(ghi, solar_zenith, times, max_zenith=90)
-    expected = pd.Series([0.0, 0.0], index=times, name='dni')
-    assert_series_equal(out, expected, check_less_precise=True)
-
-    out = irradiance.dirint(ghi, solar_zenith, times, min_cos_zenith=0,
-                            max_zenith=90)
-    expected = pd.Series([0.0, 144.264507], index=times, name='dni')
-    assert_series_equal(out, expected, check_less_precise=True)
-
-    out = irradiance.dirint(ghi, solar_zenith, times, min_cos_zenith=0,
-                            max_zenith=100)
-    expected = pd.Series([0.0, 144.264507], index=times, name='dni')
-    assert_series_equal(out, expected, check_less_precise=True)
-
-
-def test_ghi_from_poa_driesse(mocker):
-    # inputs copied from test_gti_dirint
-    times = pd.DatetimeIndex(
-        ['2014-06-24T06-0700', '2014-06-24T09-0700', '2014-06-24T12-0700'])
-    poa_global = np.array([20, 300, 1000])
-    zenith = np.array([80, 45, 20])
-    azimuth = np.array([90, 135, 180])
-    surface_tilt = 30
-    surface_azimuth = 180
-
-    # test core function
-    output = irradiance.ghi_from_poa_driesse_2023(
-        surface_tilt, surface_azimuth, zenith, azimuth,
-        poa_global, dni_extra=1366.1)
-
-    expected = [22.089, 304.088, 931.143]
-    assert_allclose(expected, output, atol=0.001)
-
-    # test series output
-    poa_global = pd.Series([20, 300, 1000], index=times)
-
-    output = irradiance.ghi_from_poa_driesse_2023(
-        surface_tilt, surface_azimuth, zenith, azimuth,
-        poa_global, dni_extra=1366.1)
-
-    assert isinstance(output, pd.Series)
-
-    # test full_output option and special cases
-    poa_global = np.array([0, 1500, np.nan])
-
-    ghi, conv, niter = irradiance.ghi_from_poa_driesse_2023(
-        surface_tilt, surface_azimuth, zenith, azimuth,
-        poa_global, dni_extra=1366.1, full_output=True)
-
-    expected = [0, np.nan, np.nan]
-    assert_allclose(expected, ghi, atol=0.001)
-
-    expected = [True, False, False]
-    assert_allclose(expected, conv)
-
-    expected = [0, -1, 0]
-    assert_allclose(expected, niter)
-
-    # test xtol argument
-    poa_global = pd.Series([20, 300, 1000], index=times)
-    # test exception
-    xtol = -3.14159  # negative value raises exception in scipy.optimize.bisect
-    with pytest.raises(ValueError, match=rf"xtol too small \({xtol:g} <= 0\)"):
-        output = irradiance.ghi_from_poa_driesse_2023(
-            surface_tilt, surface_azimuth, zenith, azimuth,
-            poa_global, dni_extra=1366.1, xtol=xtol)
-    # test propagation
-    xtol = 3.141592
-    bisect_spy = mocker.spy(irradiance, "bisect")
-    output = irradiance.ghi_from_poa_driesse_2023(
-        surface_tilt, surface_azimuth, zenith, azimuth,
-        poa_global, dni_extra=1366.1, xtol=xtol)
-    assert bisect_spy.call_args[1]["xtol"] == xtol
-
-
-def test_gti_dirint():
-    times = pd.DatetimeIndex(
-        ['2014-06-24T06-0700', '2014-06-24T09-0700', '2014-06-24T12-0700'])
-    poa_global = np.array([20, 300, 1000])
-    aoi = np.array([100, 70, 10])
-    zenith = np.array([80, 45, 20])
-    azimuth = np.array([90, 135, 180])
-    surface_tilt = 30
-    surface_azimuth = 180
-
-    # test defaults
-    output = irradiance.gti_dirint(
-        poa_global, aoi, zenith, azimuth, times, surface_tilt, surface_azimuth)
-
-    expected_col_order = ['ghi', 'dni', 'dhi']
-    expected = pd.DataFrame(array(
-        [[21.05796198,    0.,   21.05796198],
-         [291.40037163,   63.41290679,  246.56067523],
-         [931.04078010,  695.94965324,  277.06172442]]),
-        columns=expected_col_order, index=times)
-
-    assert_frame_equal(output, expected)
-
-    # test ignore calculate_gt_90
-    output = irradiance.gti_dirint(
-        poa_global, aoi, zenith, azimuth, times, surface_tilt, surface_azimuth,
-        calculate_gt_90=False)
-
-    expected_no_90 = expected.copy()
-    expected_no_90.iloc[0, :] = np.nan
-
-    assert_frame_equal(output, expected_no_90)
-
-    # test pressure input
-    pressure = 93193.
-    output = irradiance.gti_dirint(
-        poa_global, aoi, zenith, azimuth, times, surface_tilt, surface_azimuth,
-        pressure=pressure)
-
-    expected = pd.DataFrame(array(
-        [[21.05796198,    0.,   21.05796198],
-         [293.21310935,   63.27500913,  248.47092131],
-         [932.46756378,  648.05001357,  323.49974813]]),
-        columns=expected_col_order, index=times)
-
-    assert_frame_equal(output, expected)
-
-    # test albedo input
-    albedo = 0.05
-    output = irradiance.gti_dirint(
-        poa_global, aoi, zenith, azimuth, times, surface_tilt, surface_azimuth,
-        albedo=albedo)
-
-    expected = pd.DataFrame(array(
-        [[21.3592591,    0.,   21.3592591],
-         [294.4985420,   66.25848451,  247.64671830],
-         [941.7943404,  727.50552952,  258.16276278]]),
-        columns=expected_col_order, index=times)
-
-    assert_frame_equal(output, expected)
-
-    # test with albedo as a Series
-    albedo = pd.Series(0.05, index=times)
-    output = irradiance.gti_dirint(
-        poa_global, aoi, zenith, azimuth, times, surface_tilt, surface_azimuth,
-        albedo=albedo)
-
-    assert_frame_equal(output, expected)
-
-    # test temp_dew input
-    temp_dew = np.array([70, 80, 20])
-    output = irradiance.gti_dirint(
-        poa_global, aoi, zenith, azimuth, times, surface_tilt, surface_azimuth,
-        temp_dew=temp_dew)
-
-    expected = pd.DataFrame(array(
-        [[21.05796198,    0.,           21.05796198],
-         [295.06070190,   38.20346345,  268.0467738],
-         [931.79627208,  689.81549269,  283.5817439]]),
-        columns=expected_col_order, index=times)
-
-    assert_frame_equal(output, expected)
-
-
-def test_erbs():
-    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.00000000e+00, 0.00000000e+00, 0.00000000e+00],
-         [9.67192672e+01, 4.15703604e+01, 4.05723511e-01],
-         [7.94205651e+02, 2.17860117e+02, 7.18132729e-01],
-         [8.42001578e+02, 1.70790318e+02, 7.68214312e-01]]),
-        columns=['dni', 'dhi', 'kt'], index=index)
-
-    out = irradiance.erbs(ghi, zenith, index)
-
-    assert_frame_equal(np.round(out, 0), np.round(expected, 0))
-
-
-def test_erbs_driesse():
-    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 values are the same as for erbs original test
-    expected = pd.DataFrame(np.array(
-        [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
-         [9.67192672e+01, 4.15703604e+01, 4.05723511e-01],
-         [7.94205651e+02, 2.17860117e+02, 7.18132729e-01],
-         [8.42001578e+02, 1.70790318e+02, 7.68214312e-01]]),
-        columns=['dni', 'dhi', 'kt'], index=index)
-
-    out = irradiance.erbs_driesse(ghi, zenith, index)
-
-    assert_frame_equal(np.round(out, 0), np.round(expected, 0))
-
-    # test with the new optional dni_extra argument
-    dni_extra = irradiance.get_extra_radiation(index)
-
-    out = irradiance.erbs_driesse(ghi, zenith, dni_extra=dni_extra)
-
-    assert_frame_equal(np.round(out, 0), np.round(expected, 0))
-
-    # test for required inputs
-    with pytest.raises(ValueError):
-        irradiance.erbs_driesse(ghi, zenith)
-
-
-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
-    columns = ['dni', 'dhi', 'kt']
-    times = pd.DatetimeIndex(['2016-07-19 06:11:00'], tz='America/Phoenix')
-
-    # max_zenith keeps these results reasonable
-    out = irradiance.erbs(ghi=1.0, zenith=89.99999,
-                          datetime_or_doy=times, min_cos_zenith=0)
-    expected = pd.DataFrame(np.array(
-        [[0., 1., 1.]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # 4-5 9s will produce bad behavior without max_zenith limit
-    out = irradiance.erbs(ghi=1.0, zenith=89.99999,
-                          datetime_or_doy=times, max_zenith=100)
-    expected = pd.DataFrame(np.array(
-        [[6.00115286e+03, 9.98952601e-01, 1.16377640e-02]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # 1-2 9s will produce bad behavior without either limit
-    out = irradiance.erbs(ghi=1.0, zenith=89.99, datetime_or_doy=times,
-                          min_cos_zenith=0, max_zenith=100)
-    expected = pd.DataFrame(np.array(
-        [[4.78419761e+03, 1.65000000e-01, 1.00000000e+00]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-    # check default behavior under hardest condition
-    out = irradiance.erbs(ghi=1.0, zenith=90, datetime_or_doy=times)
-    expected = pd.DataFrame(np.array(
-        [[0., 1., 0.01163776]]),
-        columns=columns, index=times)
-    assert_frame_equal(out, expected)
-
-
-def test_erbs_all_scalar():
-    ghi = 1000
-    zenith = 10
-    doy = 180
-
-    expected = OrderedDict()
-    expected['dni'] = 8.42358014e+02
-    expected['dhi'] = 1.70439297e+02
-    expected['kt'] = 7.68919470e-01
-
-    out = irradiance.erbs(ghi, zenith, doy)
-
-    for k, v in out.items():
-        assert_allclose(v, expected[k], 1e-2)
-
-
-def test_dirindex(times):
-    ghi = pd.Series([0, 0, 1038.62, 254.53], index=times)
-    ghi_clearsky = pd.Series(
-        np.array([0., 79.73860422, 1042.48031487, 257.20751138]),
-        index=times
-    )
-    dni_clear = pd.Series(
-        np.array([0., 316.1949056, 939.95469881, 646.22886049]),
-        index=times
-    )
-    zenith = pd.Series(
-        np.array([124.0390863, 82.85457044, 10.56413562, 72.41687122]),
-        index=times
-    )
-    pressure = 93193.
-    tdew = 10.
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear,
-                              zenith, times, pressure=pressure,
-                              temp_dew=tdew)
-    dirint_close_values = irradiance.dirint(ghi, zenith, times,
-                                            pressure=pressure,
-                                            use_delta_kt_prime=True,
-                                            temp_dew=tdew).values
-    expected_out = np.array([np.nan, 0., 748.31562800, 630.73752100])
-
-    tolerance = 1e-8
-    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)
-
-
-@fail_on_pvlib_version("0.13")
-def test_dirindex_ghi_clearsky_deprecation():
-    times = pd.DatetimeIndex(['2014-06-24T18-1200'])
-    ghi = pd.Series([1038.62], index=times)
-    ghi_clearsky = pd.Series([1042.48031487], index=times)
-    dni_clearsky = pd.Series([939.95469881], index=times)
-    zenith = pd.Series([10.56413562], index=times)
-    pressure, tdew = 93193, 10
-    with pytest.warns(pvlibDeprecationWarning, match='ghi_clear'):
-        irradiance.dirindex(
-            ghi=ghi, ghi_clearsky=ghi_clearsky, dni_clear=dni_clearsky,
-            zenith=zenith, times=times, pressure=pressure, temp_dew=tdew)
-
-
-def test_dirindex_min_cos_zenith_max_zenith():
-    # map out behavior under difficult conditions with various
-    # limiting kwargs settings
-    # times don't have any physical relevance
-    times = pd.DatetimeIndex(['2014-06-24T12-0700', '2014-06-24T18-0700'])
-    ghi = pd.Series([0, 1], index=times)
-    ghi_clearsky = pd.Series([0, 1], index=times)
-    dni_clear = pd.Series([0, 5], index=times)
-    solar_zenith = pd.Series([90, 89.99], index=times)
-
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear, solar_zenith,
-                              times)
-    expected = pd.Series([nan, nan], index=times)
-    assert_series_equal(out, expected)
-
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear, solar_zenith,
-                              times, min_cos_zenith=0)
-    expected = pd.Series([nan, nan], index=times)
-    assert_series_equal(out, expected)
-
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear, solar_zenith,
-                              times, max_zenith=90)
-    expected = pd.Series([nan, nan], index=times)
-    assert_series_equal(out, expected)
-
-    out = irradiance.dirindex(ghi, ghi_clearsky, dni_clear, solar_zenith,
-                              times, min_cos_zenith=0, max_zenith=100)
-    expected = pd.Series([nan, 5.], index=times)
-    assert_series_equal(out, expected)
-
-
-@fail_on_pvlib_version("0.13")
-def test_dirindex_dni_clearsky_deprecation():
-    times = pd.DatetimeIndex(['2014-06-24T12-0700', '2014-06-24T18-0700'])
-    ghi = pd.Series([0, 1], index=times)
-    ghi_clearsky = pd.Series([0, 1], index=times)
-    dni_clear = pd.Series([0, 5], index=times)
-    solar_zenith = pd.Series([90, 89.99], index=times)
-    with pytest.warns(pvlibDeprecationWarning, match='dni_clear'):
-        irradiance.dirindex(ghi, ghi_clearsky, dni_clearsky=dni_clear,
-                            zenith=solar_zenith, times=times,
-                            min_cos_zenith=0)
-
-
-def test_dni():
-    ghi = pd.Series([90, 100, 100, 100, 100])
-    dhi = pd.Series([100, 90, 50, 50, 50])
-    zenith = pd.Series([80, 100, 85, 70, 85])
-    dni_clear = pd.Series([50, 50, 200, 50, 300])
-
-    dni = irradiance.dni(ghi, dhi, zenith,
-                         dni_clear=dni_clear, clearsky_tolerance=2)
-    assert_series_equal(dni,
-                        pd.Series([float('nan'), float('nan'), 400,
-                                   146.190220008, 573.685662283]))
-
-    dni = irradiance.dni(ghi, dhi, zenith)
-    assert_series_equal(dni,
-                        pd.Series([float('nan'), float('nan'), 573.685662283,
-                                   146.190220008, 573.685662283]))
-
-
-@fail_on_pvlib_version("0.13")
-def test_dni_dni_clearsky_deprecation():
-    ghi = pd.Series([90, 100, 100, 100, 100])
-    dhi = pd.Series([100, 90, 50, 50, 50])
-    zenith = pd.Series([80, 100, 85, 70, 85])
-    dni_clear = pd.Series([50, 50, 200, 50, 300])
-    with pytest.warns(pvlibDeprecationWarning, match='dni_clear'):
-        irradiance.dni(ghi, dhi, zenith,
-                       clearsky_dni=dni_clear, clearsky_tolerance=2)
-
-
-@pytest.mark.parametrize(
-    'surface_tilt,surface_azimuth,solar_zenith,' +
-    'solar_azimuth,aoi_expected,aoi_proj_expected',
-    [(0, 0, 0, 0, 0, 1),
-     (30, 180, 30, 180, 0, 1),
-     (30, 180, 150, 0, 180, -1),
-     (90, 0, 30, 60, 75.5224878, 0.25),
-     (90, 0, 30, 170, 119.4987042, -0.4924038)])
-def test_aoi_and_aoi_projection(surface_tilt, surface_azimuth, solar_zenith,
-                                solar_azimuth, aoi_expected,
-                                aoi_proj_expected):
-    aoi = irradiance.aoi(surface_tilt, surface_azimuth, solar_zenith,
-                         solar_azimuth)
-    assert_allclose(aoi, aoi_expected, atol=1e-5)
-
-    aoi_projection = irradiance.aoi_projection(
-        surface_tilt, surface_azimuth, solar_zenith, solar_azimuth)
-    assert_allclose(aoi_projection, aoi_proj_expected, atol=1e-6)
-
-
-def test_aoi_projection_precision():
-    # GH 1185 -- test that aoi_projection does not exceed 1.0, and when
-    # given identical inputs, the returned projection is very close to 1.0
-
-    # scalars
-    zenith = 89.26778228223463
-    azimuth = 60.932028605997004
-    projection = irradiance.aoi_projection(zenith, azimuth, zenith, azimuth)
-    assert projection <= 1
-    assert np.isclose(projection, 1)
-
-    # arrays
-    zeniths = np.array([zenith])
-    azimuths = np.array([azimuth])
-    projections = irradiance.aoi_projection(zeniths, azimuths,
-                                            zeniths, azimuths)
-    assert all(projections <= 1)
-    assert all(np.isclose(projections, 1))
-    assert projections.dtype == np.dtype('float64')
-
-
-@pytest.fixture
-def airmass_kt():
-    # disc algorithm stopped at am=12. test am > 12 for out of range behavior
-    return np.array([1, 5, 12, 20])
-
-
-def test_kt_kt_prime_factor(airmass_kt):
-    out = irradiance._kt_kt_prime_factor(airmass_kt)
-    expected = np.array([0.999971,  0.723088,  0.548811,  0.471068])
-    assert_allclose(out, expected, atol=1e-5)
-
-
-def test_clearsky_index():
-    ghi = np.array([-1., 0., 1., 500., 1000., np.nan])
-    ghi_measured, ghi_modeled = np.meshgrid(ghi, ghi)
-    # default max_clearsky_index
-    with np.errstate(invalid='ignore', divide='ignore'):
-        out = irradiance.clearsky_index(ghi_measured, ghi_modeled)
-    expected = np.array(
-        [[1., 0., 0., 0., 0., np.nan],
-         [0., 0., 0., 0., 0., np.nan],
-         [0., 0., 1., 2., 2., np.nan],
-         [0., 0., 0.002, 1., 2., np.nan],
-         [0., 0., 0.001, 0.5, 1., np.nan],
-         [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]])
-    assert_allclose(out, expected, atol=0.001)
-    # specify max_clearsky_index
-    with np.errstate(invalid='ignore', divide='ignore'):
-        out = irradiance.clearsky_index(ghi_measured, ghi_modeled,
-                                        max_clearsky_index=1.5)
-    expected = np.array(
-        [[1., 0., 0., 0., 0., np.nan],
-         [0., 0., 0., 0., 0., np.nan],
-         [0., 0., 1., 1.5, 1.5, np.nan],
-         [0., 0., 0.002, 1., 1.5, np.nan],
-         [0., 0., 0.001, 0.5, 1., np.nan],
-         [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]])
-    assert_allclose(out, expected, atol=0.001)
-    # scalars
-    out = irradiance.clearsky_index(10, 1000)
-    expected = 0.01
-    assert_allclose(out, expected, atol=0.001)
-    # series
-    times = pd.date_range(start='20180601', periods=2, freq='12h')
-    ghi_measured = pd.Series([100,  500], index=times)
-    ghi_modeled = pd.Series([500, 1000], index=times)
-    out = irradiance.clearsky_index(ghi_measured, ghi_modeled)
-    expected = pd.Series([0.2, 0.5], index=times)
-    assert_series_equal(out, expected)
-
-
-@fail_on_pvlib_version("0.13")
-def test_clearsky_index_clearsky_ghi_deprecation():
-    with pytest.warns(pvlibDeprecationWarning, match='ghi_clear'):
-        ghi, clearsky_ghi = 200, 300
-        irradiance.clearsky_index(ghi, clearsky_ghi=clearsky_ghi)
-
-
-def test_clearness_index():
-    ghi = np.array([-1, 0, 1, 1000])
-    solar_zenith = np.array([180, 90, 89.999, 0])
-    ghi, solar_zenith = np.meshgrid(ghi, solar_zenith)
-    # default min_cos_zenith
-    out = irradiance.clearness_index(ghi, solar_zenith, 1370)
-    # np.set_printoptions(precision=3, floatmode='maxprec', suppress=True)
-    expected = np.array(
-        [[0., 0., 0.011, 2.],
-         [0., 0., 0.011, 2.],
-         [0., 0., 0.011, 2.],
-         [0., 0., 0.001, 0.73]])
-    assert_allclose(out, expected, atol=0.001)
-    # specify min_cos_zenith
-    with np.errstate(invalid='ignore', divide='ignore'):
-        out = irradiance.clearness_index(ghi, solar_zenith, 1400,
-                                         min_cos_zenith=0)
-    expected = np.array(
-        [[0.,   nan, 2., 2.],
-         [0., 0., 2., 2.],
-         [0., 0., 2., 2.],
-         [0., 0., 0.001, 0.714]])
-    assert_allclose(out, expected, atol=0.001)
-    # specify max_clearness_index
-    out = irradiance.clearness_index(ghi, solar_zenith, 1370,
-                                     max_clearness_index=0.82)
-    expected = np.array(
-        [[0.,  0.,  0.011,  0.82],
-         [0.,  0.,  0.011,  0.82],
-         [0.,  0.,  0.011,  0.82],
-         [0.,  0.,  0.001,  0.73]])
-    assert_allclose(out, expected, atol=0.001)
-    # specify min_cos_zenith and max_clearness_index
-    with np.errstate(invalid='ignore', divide='ignore'):
-        out = irradiance.clearness_index(ghi, solar_zenith, 1400,
-                                         min_cos_zenith=0,
-                                         max_clearness_index=0.82)
-    expected = np.array(
-        [[0.,    nan,  0.82,  0.82],
-         [0.,  0.,  0.82,  0.82],
-         [0.,  0.,  0.82,  0.82],
-         [0.,  0.,  0.001,  0.714]])
-    assert_allclose(out, expected, atol=0.001)
-    # scalars
-    out = irradiance.clearness_index(1000, 10, 1400)
-    expected = 0.725
-    assert_allclose(out, expected, atol=0.001)
-    # series
-    times = pd.date_range(start='20180601', periods=2, freq='12h')
-    ghi = pd.Series([0, 1000], index=times)
-    solar_zenith = pd.Series([90, 0], index=times)
-    extra_radiation = pd.Series([1360, 1400], index=times)
-    out = irradiance.clearness_index(ghi, solar_zenith, extra_radiation)
-    expected = pd.Series([0, 0.714285714286], index=times)
-    assert_series_equal(out, expected)
-
-
-def test_clearness_index_zenith_independent(airmass_kt):
-    clearness_index = np.array([-1, 0, .1, 1])
-    clearness_index, airmass_kt = np.meshgrid(clearness_index, airmass_kt)
-    out = irradiance.clearness_index_zenith_independent(clearness_index,
-                                                        airmass_kt)
-    expected = np.array(
-        [[0., 0., 0.1, 1.],
-         [0., 0., 0.138, 1.383],
-         [0., 0., 0.182, 1.822],
-         [0., 0., 0.212, 2.]])
-    assert_allclose(out, expected, atol=0.001)
-    # test max_clearness_index
-    out = irradiance.clearness_index_zenith_independent(
-        clearness_index, airmass_kt, max_clearness_index=0.82)
-    expected = np.array(
-        [[0.,  0.,  0.1,  0.82],
-         [0.,  0.,  0.138,  0.82],
-         [0.,  0.,  0.182,  0.82],
-         [0.,  0.,  0.212,  0.82]])
-    assert_allclose(out, expected, atol=0.001)
-    # scalars
-    out = irradiance.clearness_index_zenith_independent(.4, 2)
-    expected = 0.443
-    assert_allclose(out, expected, atol=0.001)
-    # series
-    times = pd.date_range(start='20180601', periods=2, freq='12h')
-    clearness_index = pd.Series([0, .5], index=times)
-    airmass = pd.Series([np.nan, 2], index=times)
-    out = irradiance.clearness_index_zenith_independent(clearness_index,
-                                                        airmass)
-    expected = pd.Series([np.nan, 0.553744437562], index=times)
-    assert_series_equal(out, expected)
-
-
-def test_complete_irradiance():
-    # Generate dataframe to test on
-    times = pd.date_range('2010-07-05 7:00:00-0700', periods=2, freq='h')
-    i = pd.DataFrame({'ghi': [372.103976116, 497.087579068],
-                      'dhi': [356.543700, 465.44400],
-                      'dni': [49.63565561689957, 62.10624908037814]},
-                     index=times)
-    # Define the solar position and clearsky dataframe
-    solar_position = pd.DataFrame({'apparent_zenith': [71.7303262449161,
-                                                       59.369],
-                                   'zenith': [71.7764, 59.395]},
-                                  index=pd.DatetimeIndex([
-                                      '2010-07-05 07:00:00-0700',
-                                      '2010-07-05 08:00:00-0700']))
-    clearsky = pd.DataFrame({'dni': [625.5254880160008, 778.7766443075865],
-                             'ghi': [246.3508023804681, 469.461381740857],
-                             'dhi': [50.25488725346631, 72.66909939636372]},
-                            index=pd.DatetimeIndex([
-                                '2010-07-05 07:00:00-0700',
-                                '2010-07-05 08:00:00-0700']))
-    # Test scenario where DNI is generated via component sum equation
-    complete_df = irradiance.complete_irradiance(
-        solar_position.apparent_zenith,
-        ghi=i.ghi,
-        dhi=i.dhi,
-        dni=None,
-        dni_clear=clearsky.dni)
-    # Assert that the ghi, dhi, and dni series match the original dataframe
-    # values
-    assert_frame_equal(complete_df, i)
-    # Test scenario where GHI is generated via component sum equation
-    complete_df = irradiance.complete_irradiance(
-        solar_position.apparent_zenith,
-        ghi=None,
-        dhi=i.dhi,
-        dni=i.dni,
-        dni_clear=clearsky.dni)
-    # Assert that the ghi, dhi, and dni series match the original dataframe
-    # values
-    assert_frame_equal(complete_df, i)
-    # Test scenario where DHI is generated via component sum equation
-    complete_df = irradiance.complete_irradiance(
-        solar_position.apparent_zenith,
-        ghi=i.ghi,
-        dhi=None,
-        dni=i.dni,
-        dni_clear=clearsky.dni)
-    # Assert that the ghi, dhi, and dni series match the original dataframe
-    # values
-    assert_frame_equal(complete_df, i)
-    # Test scenario where all parameters are passed (throw error)
-    with pytest.raises(ValueError):
-        irradiance.complete_irradiance(solar_position.apparent_zenith,
-                                       ghi=i.ghi,
-                                       dhi=i.dhi,
-                                       dni=i.dni,
-                                       dni_clear=clearsky.dni)
-    # Test scenario where only one parameter is passed (throw error)
-    with pytest.raises(ValueError):
-        irradiance.complete_irradiance(solar_position.apparent_zenith,
-                                       ghi=None,
-                                       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)
-
-
-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)