pvlib 0.11.0a1__py3-none-any.whl → 0.11.2__py3-none-any.whl

pvlib/tests/spectrum/test_response.py

@@ -0,0 +1,124 @@
+import pytest
+import pandas as pd
+from numpy.testing import assert_allclose, assert_approx_equal, assert_equal
+import numpy as np
+from pvlib import spectrum
+
+
+def test_get_example_spectral_response():
+    # test that the sample sr is read and interpolated correctly
+    sr = spectrum.get_example_spectral_response()
+    assert_equal(len(sr), 185)
+    assert_equal(np.sum(sr.index), 136900)
+    assert_approx_equal(np.sum(sr), 107.6116)
+
+    wavelength = [270, 850, 950, 1200, 4001]
+    expected = [0.0, 0.92778, 1.0, 0.0, 0.0]
+
+    sr = spectrum.get_example_spectral_response(wavelength)
+    assert_equal(len(sr), len(wavelength))
+    assert_allclose(sr, expected, rtol=1e-5)
+
+
+@pytest.fixture
+def sr_and_eqe_fixture():
+    # Just some arbitrary data for testing the conversion functions
+    df = pd.DataFrame(
+        columns=("wavelength", "quantum_efficiency", "spectral_response"),
+        data=[
+            # nm, [0,1], A/W
+            [300, 0.85, 0.205671370402405],
+            [350, 0.86, 0.242772872514211],
+            [400, 0.87, 0.280680929019753],
+            [450, 0.88, 0.319395539919029],
+            [500, 0.89, 0.358916705212040],
+            [550, 0.90, 0.399244424898786],
+            [600, 0.91, 0.440378698979267],
+            [650, 0.92, 0.482319527453483],
+            [700, 0.93, 0.525066910321434],
+            [750, 0.94, 0.568620847583119],
+            [800, 0.95, 0.612981339238540],
+            [850, 0.90, 0.617014111207215],
+            [900, 0.80, 0.580719163489143],
+            [950, 0.70, 0.536358671833723],
+            [1000, 0.6, 0.483932636240953],
+            [1050, 0.4, 0.338752845368667],
+        ],
+    )
+    df.set_index("wavelength", inplace=True)
+    return df
+
+
+def test_sr_to_qe(sr_and_eqe_fixture):
+    # vector type
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"].values,
+        sr_and_eqe_fixture.index.values,  # wavelength, nm
+    )
+    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])
+    # pandas series type
+    # note: output Series' name should match the input
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"]
+    )
+    pd.testing.assert_series_equal(
+        qe, sr_and_eqe_fixture["quantum_efficiency"],
+        check_names=False
+    )
+    assert qe.name == "spectral_response"
+    # series normalization
+    qe = spectrum.sr_to_qe(
+        sr_and_eqe_fixture["spectral_response"] * 10, normalize=True
+    )
+    pd.testing.assert_series_equal(
+        qe,
+        sr_and_eqe_fixture["quantum_efficiency"]
+        / max(sr_and_eqe_fixture["quantum_efficiency"]),
+        check_names=False,
+    )
+    # error on lack of wavelength parameter if no pandas object is provided
+    with pytest.raises(TypeError, match="must have an '.index' attribute"):
+        _ = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"].values)
+
+
+def test_qe_to_sr(sr_and_eqe_fixture):
+    # vector type
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"].values,
+        sr_and_eqe_fixture.index.values,  # wavelength, nm
+    )
+    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
+    # pandas series type
+    # note: output Series' name should match the input
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"]
+    )
+    pd.testing.assert_series_equal(
+        sr, sr_and_eqe_fixture["spectral_response"],
+        check_names=False
+    )
+    assert sr.name == "quantum_efficiency"
+    # series normalization
+    sr = spectrum.qe_to_sr(
+        sr_and_eqe_fixture["quantum_efficiency"] * 10, normalize=True
+    )
+    pd.testing.assert_series_equal(
+        sr,
+        sr_and_eqe_fixture["spectral_response"]
+        / max(sr_and_eqe_fixture["spectral_response"]),
+        check_names=False,
+    )
+    # error on lack of wavelength parameter if no pandas object is provided
+    with pytest.raises(TypeError, match="must have an '.index' attribute"):
+        _ = spectrum.qe_to_sr(
+            sr_and_eqe_fixture["quantum_efficiency"].values
+        )
+
+
+def test_qe_and_sr_reciprocal_conversion(sr_and_eqe_fixture):
+    # test that the conversion functions are reciprocal
+    qe = spectrum.sr_to_qe(sr_and_eqe_fixture["spectral_response"])
+    sr = spectrum.qe_to_sr(qe)
+    assert_allclose(sr, sr_and_eqe_fixture["spectral_response"])
+    qe = spectrum.sr_to_qe(sr)
+    assert_allclose(qe, sr_and_eqe_fixture["quantum_efficiency"])

pvlib/tests/spectrum/test_spectrl2.py

@@ -0,0 +1,72 @@
+import pytest
+import pandas as pd
+import numpy as np
+from pvlib import spectrum
+from numpy.testing import assert_allclose
+
+
+def test_spectrl2(spectrl2_data):
+    # compare against output from solar_utils wrapper around NREL spectrl2_2.c
+    kwargs, expected = spectrl2_data
+    actual = spectrum.spectrl2(**kwargs)
+    assert_allclose(expected['wavelength'].values, actual['wavelength'])
+    assert_allclose(expected['specdif'].values, actual['dhi'].ravel(),
+                    atol=7e-5)
+    assert_allclose(expected['specdir'].values, actual['dni'].ravel(),
+                    atol=1.5e-4)
+    assert_allclose(expected['specetr'], actual['dni_extra'].ravel(),
+                    atol=2e-4)
+    assert_allclose(expected['specglo'], actual['poa_global'].ravel(),
+                    atol=1e-4)
+
+
+def test_spectrl2_array(spectrl2_data):
+    # test that supplying arrays instead of scalars works
+    kwargs, expected = spectrl2_data
+    kwargs = {k: np.array([v, v, v]) for k, v in kwargs.items()}
+    actual = spectrum.spectrl2(**kwargs)
+
+    assert actual['wavelength'].shape == (122,)
+
+    keys = ['dni_extra', 'dhi', 'dni', 'poa_sky_diffuse', 'poa_ground_diffuse',
+            'poa_direct', 'poa_global']
+    for key in keys:
+        assert actual[key].shape == (122, 3)
+
+
+def test_spectrl2_series(spectrl2_data):
+    # test that supplying Series instead of scalars works
+    kwargs, expected = spectrl2_data
+    kwargs.pop('dayofyear')
+    index = pd.to_datetime(['2020-03-15 10:45:59']*3)
+    kwargs = {k: pd.Series([v, v, v], index=index) for k, v in kwargs.items()}
+    actual = spectrum.spectrl2(**kwargs)
+
+    assert actual['wavelength'].shape == (122,)
+
+    keys = ['dni_extra', 'dhi', 'dni', 'poa_sky_diffuse', 'poa_ground_diffuse',
+            'poa_direct', 'poa_global']
+    for key in keys:
+        assert actual[key].shape == (122, 3)
+
+
+def test_dayofyear_missing(spectrl2_data):
+    # test that not specifying dayofyear with non-pandas inputs raises error
+    kwargs, expected = spectrl2_data
+    kwargs.pop('dayofyear')
+    with pytest.raises(ValueError, match='dayofyear must be specified'):
+        _ = spectrum.spectrl2(**kwargs)
+
+
+def test_aoi_gt_90(spectrl2_data):
+    # test that returned irradiance values are non-negative when aoi > 90
+    # see GH #1348
+    kwargs, _ = spectrl2_data
+    kwargs['apparent_zenith'] = 70
+    kwargs['aoi'] = 130
+    kwargs['surface_tilt'] = 60
+
+    spectra = spectrum.spectrl2(**kwargs)
+    for key in ['poa_direct', 'poa_global']:
+        message = f'{key} contains negative values for aoi>90'
+        assert np.all(spectra[key] >= 0), message

pvlib/tests/test__deprecation.py

@@ -0,0 +1,97 @@
+"""
+Test the _deprecation module.
+"""
+
+import pytest
+
+from pvlib import _deprecation
+from .conftest import fail_on_pvlib_version
+
+import warnings
+
+
+@pytest.mark.xfail(strict=True,
+                   reason='fail_on_pvlib_version should cause test to fail')
+@fail_on_pvlib_version('0.0')
+def test_fail_on_pvlib_version():
+    pass  # pragma: no cover
+
+
+@fail_on_pvlib_version('100000.0')
+def test_fail_on_pvlib_version_pass():
+    pass
+
+
+@pytest.mark.xfail(strict=True, reason='ensure that the test is called')
+@fail_on_pvlib_version('100000.0')
+def test_fail_on_pvlib_version_fail_in_test():
+    raise Exception
+
+
+# set up to test using fixtures with function decorated with
+# conftest.fail_on_pvlib_version
+@pytest.fixture
+def some_data():
+    return "some data"
+
+
+def alt_func(*args):
+    return args
+
+
+@pytest.fixture
+def deprec_func():
+    return _deprecation.deprecated(
+        "350.8", alternative="alt_func", name="deprec_func", removal="350.9"
+    )(alt_func)
+
+
+@fail_on_pvlib_version('350.9')
+def test_use_fixture_with_decorator(some_data, deprec_func):
+    # test that the correct data is returned by the some_data fixture
+    assert some_data == "some data"
+    with pytest.warns(_deprecation.pvlibDeprecationWarning):
+        # test for custom deprecation warning provided by pvlib
+        deprec_func(some_data)
+
+
+@pytest.fixture
+def renamed_kwarg_func():
+    """Returns a function decorated by renamed_kwarg_warning.
+    This function is called 'func' and has a docstring equal to 'docstring'.
+    """
+
+    @_deprecation.renamed_kwarg_warning(
+        "0.1.0", "old_kwarg", "new_kwarg", "0.2.0"
+    )
+    def func(new_kwarg):
+        """docstring"""
+        return new_kwarg
+
+    return func
+
+
+def test_renamed_kwarg_warning(renamed_kwarg_func):
+    # assert decorated function name and docstring are unchanged
+    assert renamed_kwarg_func.__name__ == "func"
+    assert renamed_kwarg_func.__doc__ == "docstring"
+
+    # assert no warning is raised when using the new kwarg
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        assert renamed_kwarg_func(new_kwarg=1) == 1  # as keyword argument
+        assert renamed_kwarg_func(1) == 1  # as positional argument
+
+    # assert a warning is raised when using the old kwarg
+    with pytest.warns(Warning, match="Parameter 'old_kwarg' has been renamed"):
+        assert renamed_kwarg_func(old_kwarg=1) == 1
+
+    # assert an error is raised when using both the old and new kwarg
+    with pytest.raises(ValueError, match="they refer to the same parameter."):
+        renamed_kwarg_func(old_kwarg=1, new_kwarg=2)
+
+    # assert when not providing any of them
+    with pytest.raises(
+        TypeError, match="missing 1 required positional argument"
+    ):
+        renamed_kwarg_func()

pvlib/tests/test_atmosphere.py

@@ -88,6 +88,153 @@ def test_gueymard94_pw():
     assert_allclose(pws, expected, atol=0.01)
 
 
+def test_tdew_to_rh_to_tdew():
+
+    # dewpoint temp calculated with wmo and aekr coefficients
+    dewpoint_original = pd.Series([
+        15.0, 20.0, 25.0, 12.0, 8.0
+    ])
+
+    temperature_ambient = pd.Series([20.0, 25.0, 30.0, 15.0, 10.0])
+
+    # Calculate relative humidity using pandas series as input
+    relative_humidity = atmosphere.rh_from_tdew(
+        temp_air=temperature_ambient,
+        temp_dew=dewpoint_original
+    )
+
+    dewpoint_calculated = atmosphere.tdew_from_rh(
+        temp_air=temperature_ambient,
+        relative_humidity=relative_humidity
+    )
+
+    # test
+    pd.testing.assert_series_equal(
+        dewpoint_original,
+        dewpoint_calculated,
+        check_names=False
+    )
+
+
+def test_rh_from_tdew():
+
+    dewpoint = pd.Series([
+        15.0, 20.0, 25.0, 12.0, 8.0
+    ])
+
+    # relative humidity calculated with wmo and aekr coefficients
+    relative_humidity_wmo = pd.Series([
+        72.95185312581116, 73.81500029087906, 74.6401272083123,
+        82.27063889868842, 87.39018119185337
+    ])
+    relative_humidity_aekr = pd.Series([
+        72.93876680928582, 73.8025121880607, 74.62820502423823,
+        82.26135295757305, 87.38323744820416
+    ])
+
+    temperature_ambient = pd.Series([20.0, 25.0, 30.0, 15.0, 10.0])
+
+    # Calculate relative humidity using pandas series as input
+    rh_series = atmosphere.rh_from_tdew(
+        temp_air=temperature_ambient,
+        temp_dew=dewpoint
+    )
+
+    pd.testing.assert_series_equal(
+        rh_series,
+        relative_humidity_wmo,
+        check_names=False
+    )
+
+    # Calulate relative humidity using pandas series as input
+    # with AEKR coefficients
+    rh_series_aekr = atmosphere.rh_from_tdew(
+        temp_air=temperature_ambient,
+        temp_dew=dewpoint,
+        coeff=(6.1094, 17.625, 243.04)
+    )
+
+    pd.testing.assert_series_equal(
+        rh_series_aekr,
+        relative_humidity_aekr,
+        check_names=False
+    )
+
+    # Calculate relative humidity using array as input
+    rh_array = atmosphere.rh_from_tdew(
+        temp_air=temperature_ambient.to_numpy(),
+        temp_dew=dewpoint.to_numpy()
+    )
+
+    np.testing.assert_allclose(rh_array, relative_humidity_wmo.to_numpy())
+
+    # Calculate relative humidity using float as input
+    rh_float = atmosphere.rh_from_tdew(
+        temp_air=temperature_ambient.iloc[0],
+        temp_dew=dewpoint.iloc[0]
+    )
+
+    assert np.isclose(rh_float, relative_humidity_wmo.iloc[0])
+
+
+# Unit tests
+def test_tdew_from_rh():
+
+    dewpoint = pd.Series([
+        15.0, 20.0, 25.0, 12.0, 8.0
+    ])
+
+    # relative humidity calculated with wmo and aekr coefficients
+    relative_humidity_wmo = pd.Series([
+        72.95185312581116, 73.81500029087906, 74.6401272083123,
+        82.27063889868842, 87.39018119185337
+    ])
+    relative_humidity_aekr = pd.Series([
+        72.93876680928582, 73.8025121880607, 74.62820502423823,
+        82.26135295757305, 87.38323744820416
+    ])
+
+    temperature_ambient = pd.Series([20.0, 25.0, 30.0, 15.0, 10.0])
+
+    # test as series
+    dewpoint_series = atmosphere.tdew_from_rh(
+        temp_air=temperature_ambient,
+        relative_humidity=relative_humidity_wmo
+    )
+
+    pd.testing.assert_series_equal(
+        dewpoint_series, dewpoint, check_names=False
+    )
+
+    # test as series with AEKR coefficients
+    dewpoint_series_aekr = atmosphere.tdew_from_rh(
+        temp_air=temperature_ambient,
+        relative_humidity=relative_humidity_aekr,
+        coeff=(6.1094, 17.625, 243.04)
+    )
+
+    pd.testing.assert_series_equal(
+        dewpoint_series_aekr, dewpoint,
+        check_names=False
+    )
+
+    # test as numpy array
+    dewpoint_array = atmosphere.tdew_from_rh(
+        temp_air=temperature_ambient.to_numpy(),
+        relative_humidity=relative_humidity_wmo.to_numpy()
+    )
+
+    np.testing.assert_allclose(dewpoint_array, dewpoint.to_numpy())
+
+    # test as float
+    dewpoint_float = atmosphere.tdew_from_rh(
+        temp_air=temperature_ambient.iloc[0],
+        relative_humidity=relative_humidity_wmo.iloc[0]
+    )
+
+    assert np.isclose(dewpoint_float, dewpoint.iloc[0])
+
+
 def test_first_solar_spectral_correction_deprecated():
     with pytest.warns(pvlibDeprecationWarning,
                       match='Use pvlib.spectrum.spectral_factor_firstsolar'):
@@ -131,3 +278,74 @@ def test_bird_hulstrom80_aod_bb():
     aod380, aod500 = 0.22072480948195175, 0.1614279181106312
     bird_hulstrom = atmosphere.bird_hulstrom80_aod_bb(aod380, aod500)
     assert np.isclose(0.11738229553812768, bird_hulstrom)
+
+
+@pytest.fixture
+def windspeeds_data_powerlaw():
+    data = pd.DataFrame(
+        index=pd.date_range(start="2015-01-01 00:00", end="2015-01-01 05:00",
+                            freq="1h"),
+        columns=["wind_ref", "height_ref", "height_desired", "wind_calc"],
+        data=[
+            (10, -2, 5, np.nan),
+            (-10, 2, 5, np.nan),
+            (5, 4, 5, 5.067393209486324),
+            (7, 6, 10, 7.2178684911195905),
+            (10, 8, 20, 10.565167835216586),
+            (12, 10, 30, 12.817653329393977)
+        ]
+    )
+    return data
+
+
+def test_windspeed_powerlaw_ndarray(windspeeds_data_powerlaw):
+    # test wind speed estimation by passing in surface_type
+    result_surface = atmosphere.windspeed_powerlaw(
+        windspeeds_data_powerlaw["wind_ref"].to_numpy(),
+        windspeeds_data_powerlaw["height_ref"],
+        windspeeds_data_powerlaw["height_desired"],
+        surface_type='unstable_air_above_open_water_surface')
+    assert_allclose(windspeeds_data_powerlaw["wind_calc"].to_numpy(),
+                    result_surface)
+    # test wind speed estimation by passing in the exponent corresponding
+    # to the surface_type above
+    result_exponent = atmosphere.windspeed_powerlaw(
+        windspeeds_data_powerlaw["wind_ref"].to_numpy(),
+        windspeeds_data_powerlaw["height_ref"],
+        windspeeds_data_powerlaw["height_desired"],
+        exponent=0.06)
+    assert_allclose(windspeeds_data_powerlaw["wind_calc"].to_numpy(),
+                    result_exponent)
+
+
+def test_windspeed_powerlaw_series(windspeeds_data_powerlaw):
+    result = atmosphere.windspeed_powerlaw(
+        windspeeds_data_powerlaw["wind_ref"],
+        windspeeds_data_powerlaw["height_ref"],
+        windspeeds_data_powerlaw["height_desired"],
+        surface_type='unstable_air_above_open_water_surface')
+    assert_series_equal(windspeeds_data_powerlaw["wind_calc"],
+                        result, check_names=False)
+
+
+def test_windspeed_powerlaw_invalid():
+    with pytest.raises(ValueError, match="Either a 'surface_type' or an "
+                       "'exponent' parameter must be given"):
+        # no exponent or surface_type given
+        atmosphere.windspeed_powerlaw(wind_speed_reference=10,
+                                      height_reference=5,
+                                      height_desired=10)
+    with pytest.raises(ValueError, match="Either a 'surface_type' or an "
+                       "'exponent' parameter must be given"):
+        # no exponent or surface_type given
+        atmosphere.windspeed_powerlaw(wind_speed_reference=10,
+                                      height_reference=5,
+                                      height_desired=10,
+                                      exponent=1.2,
+                                      surface_type="surf")
+    with pytest.raises(KeyError, match='not_an_exponent'):
+        # invalid surface_type
+        atmosphere.windspeed_powerlaw(wind_speed_reference=10,
+                                      height_reference=5,
+                                      height_desired=10,
+                                      surface_type='not_an_exponent')

pvlib/tests/test_clearsky.py

@@ -674,14 +674,25 @@ def test_detect_clearsky_missing_index(detect_clearsky_data):
 
 def test_detect_clearsky_not_enough_data(detect_clearsky_data):
     expected, cs = detect_clearsky_data
-    with pytest.raises(ValueError, match='have at least'):
-       clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=60)
+    with pytest.raises(ValueError, match='times has only'):
+        clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=60)
 
 
-def test_detect_clearsky_optimizer_failed(detect_clearsky_data):
+def test_detect_clearsky_window_too_short(detect_clearsky_data):
     expected, cs = detect_clearsky_data
-    with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'):
-        clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=15)
+    with pytest.raises(ValueError, match="Samples per window of "):
+        clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=2)
+
+
+@pytest.mark.parametrize("window_length", [5, 10, 15, 20, 25])
+def test_detect_clearsky_optimizer_not_failed(
+    detect_clearsky_data, window_length
+):
+    expected, cs = detect_clearsky_data
+    clear_samples = clearsky.detect_clearsky(
+        expected["GHI"], cs["ghi"], window_length=window_length
+    )
+    assert isinstance(clear_samples, pd.Series)
 
 
 @pytest.fixture
@@ -749,6 +760,7 @@ def test_bird():
     tz = -7  # test timezone
     gmt_tz = pytz.timezone('Etc/GMT%+d' % -(tz))
     times = times.tz_localize(gmt_tz)  # set timezone
+    times_utc = times.tz_convert('UTC')
     # match test data from BIRD_08_16_2012.xls
     latitude = 40.
     longitude = -105.
@@ -759,9 +771,9 @@ def test_bird():
     aod_380nm = 0.15
     b_a = 0.85
     alb = 0.2
-    eot = solarposition.equation_of_time_spencer71(times.dayofyear)
+    eot = solarposition.equation_of_time_spencer71(times_utc.dayofyear)
     hour_angle = solarposition.hour_angle(times, longitude, eot) - 0.5 * 15.
-    declination = solarposition.declination_spencer71(times.dayofyear)
+    declination = solarposition.declination_spencer71(times_utc.dayofyear)
     zenith = solarposition.solar_zenith_analytical(
         np.deg2rad(latitude), np.deg2rad(hour_angle), declination
     )
@@ -777,32 +789,35 @@ def test_bird():
     Eb, Ebh, Gh, Dh = (irrads[_] for _ in field_names)
     data_path = DATA_DIR / 'BIRD_08_16_2012.csv'
     testdata = pd.read_csv(data_path, usecols=range(1, 26), header=1).dropna()
-    testdata.index = times[1:48]
-    assert np.allclose(testdata['DEC'], np.rad2deg(declination[1:48]))
-    assert np.allclose(testdata['EQT'], eot[1:48], rtol=1e-4)
-    assert np.allclose(testdata['Hour Angle'], hour_angle[1:48])
-    assert np.allclose(testdata['Zenith Ang'], zenith[1:48])
+    testdata[['DEC', 'EQT']] = testdata[['DEC', 'EQT']].shift(tz)
+    testdata = testdata[:tz]
+    end = 48 + tz
+    testdata.index = times[1:end]
+    assert np.allclose(testdata['DEC'], np.rad2deg(declination[1:end]))
+    assert np.allclose(testdata['EQT'], eot[1:end], rtol=1e-4)
+    assert np.allclose(testdata['Hour Angle'], hour_angle[1:end], rtol=1e-2)
+    assert np.allclose(testdata['Zenith Ang'], zenith[1:end], rtol=1e-2)
     dawn = zenith < 88.
     dusk = testdata['Zenith Ang'] < 88.
     am = pd.Series(np.where(dawn, airmass, 0.), index=times).fillna(0.0)
     assert np.allclose(
-        testdata['Air Mass'].where(dusk, 0.), am[1:48], rtol=1e-3
+        testdata['Air Mass'].where(dusk, 0.), am[1:end], rtol=1e-3
     )
     direct_beam = pd.Series(np.where(dawn, Eb, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata['Direct Beam'].where(dusk, 0.), direct_beam[1:48], rtol=1e-3
+        testdata['Direct Beam'].where(dusk, 0.), direct_beam[1:end], rtol=1e-3
     )
     direct_horz = pd.Series(np.where(dawn, Ebh, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata['Direct Hz'].where(dusk, 0.), direct_horz[1:48], rtol=1e-3
+        testdata['Direct Hz'].where(dusk, 0.), direct_horz[1:end], rtol=1e-3
     )
     global_horz = pd.Series(np.where(dawn, Gh, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata['Global Hz'].where(dusk, 0.), global_horz[1:48], rtol=1e-3
+        testdata['Global Hz'].where(dusk, 0.), global_horz[1:end], rtol=1e-3
     )
     diffuse_horz = pd.Series(np.where(dawn, Dh, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata['Dif Hz'].where(dusk, 0.), diffuse_horz[1:48], rtol=1e-3
+        testdata['Dif Hz'].where(dusk, 0.), diffuse_horz[1:end], rtol=1e-3
     )
     # repeat test with albedo as a Series
     alb_series = pd.Series(0.2, index=times)
@@ -813,19 +828,19 @@ def test_bird():
     Eb, Ebh, Gh, Dh = (irrads[_] for _ in field_names)
     direct_beam = pd.Series(np.where(dawn, Eb, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata['Direct Beam'].where(dusk, 0.), direct_beam[1:48], rtol=1e-3
+        testdata['Direct Beam'].where(dusk, 0.), direct_beam[1:end], rtol=1e-3
     )
     direct_horz = pd.Series(np.where(dawn, Ebh, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata['Direct Hz'].where(dusk, 0.), direct_horz[1:48], rtol=1e-3
+        testdata['Direct Hz'].where(dusk, 0.), direct_horz[1:end], rtol=1e-3
     )
     global_horz = pd.Series(np.where(dawn, Gh, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata['Global Hz'].where(dusk, 0.), global_horz[1:48], rtol=1e-3
+        testdata['Global Hz'].where(dusk, 0.), global_horz[1:end], rtol=1e-3
     )
     diffuse_horz = pd.Series(np.where(dawn, Dh, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata['Dif Hz'].where(dusk, 0.), diffuse_horz[1:48], rtol=1e-3
+        testdata['Dif Hz'].where(dusk, 0.), diffuse_horz[1:end], rtol=1e-3
     )
 
     # test keyword parameters
@@ -835,22 +850,25 @@ def test_bird():
     Eb2, Ebh2, Gh2, Dh2 = (irrads2[_] for _ in field_names)
     data_path = DATA_DIR / 'BIRD_08_16_2012_patm.csv'
     testdata2 = pd.read_csv(data_path, usecols=range(1, 26), header=1).dropna()
-    testdata2.index = times[1:48]
+    testdata2[['DEC', 'EQT']] = testdata2[['DEC', 'EQT']].shift(tz)
+    testdata2 = testdata2[:tz]
+    testdata2.index = times[1:end]
     direct_beam2 = pd.Series(np.where(dawn, Eb2, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata2['Direct Beam'].where(dusk, 0.), direct_beam2[1:48], rtol=1e-3
+        testdata2['Direct Beam'].where(dusk, 0.), direct_beam2[1:end],
+        rtol=1e-3
     )
     direct_horz2 = pd.Series(np.where(dawn, Ebh2, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata2['Direct Hz'].where(dusk, 0.), direct_horz2[1:48], rtol=1e-3
+        testdata2['Direct Hz'].where(dusk, 0.), direct_horz2[1:end], rtol=1e-3
     )
     global_horz2 = pd.Series(np.where(dawn, Gh2, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata2['Global Hz'].where(dusk, 0.), global_horz2[1:48], rtol=1e-3
+        testdata2['Global Hz'].where(dusk, 0.), global_horz2[1:end], rtol=1e-3
     )
     diffuse_horz2 = pd.Series(np.where(dawn, Dh2, 0.), index=times).fillna(0.)
     assert np.allclose(
-        testdata2['Dif Hz'].where(dusk, 0.), diffuse_horz2[1:48], rtol=1e-3
+        testdata2['Dif Hz'].where(dusk, 0.), diffuse_horz2[1:end], rtol=1e-3
     )
     # test scalars just at noon
     # XXX: calculations start at 12am so noon is at index = 12