pvlib 0.11.0__py3-none-any.whl → 0.11.1__py3-none-any.whl

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_atmosphere.py

@@ -131,3 +131,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

@@ -675,13 +675,18 @@ 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)
+        clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=60)
 
 
-def test_detect_clearsky_optimizer_failed(detect_clearsky_data):
+@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
-    with pytest.raises(RuntimeError, match='Optimizer exited unsuccessfully'):
-        clearsky.detect_clearsky(expected['GHI'], cs['ghi'], window_length=15)
+    clear_samples = clearsky.detect_clearsky(
+        expected["GHI"], cs["ghi"], window_length=window_length
+    )
+    assert isinstance(clear_samples, pd.Series)
 
 
 @pytest.fixture
@@ -749,6 +754,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 +765,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 +783,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 +822,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 +844,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

pvlib/tests/test_irradiance.py

@@ -59,7 +59,7 @@ def ephem_data(times):
 
 
 @pytest.fixture
-def dni_et(times):
+def dni_et():
     return np.array(
         [1321.1655834833093, 1321.1655834833093, 1321.1655834833093,
          1321.1655834833093])
@@ -106,7 +106,7 @@ def test_get_extra_radiation_epoch_year():
 @requires_numba
 def test_get_extra_radiation_nrel_numba(times):
     with warnings.catch_warnings():
-        # don't warn on method reload or num threads
+        # don't warn on method reload
         warnings.simplefilter("ignore")
         result = irradiance.get_extra_radiation(
             times, method='nrel', how='numba', numthreads=4)
@@ -603,11 +603,11 @@ def test_poa_components(irrad_data, ephem_data, dni_et, relative_airmass):
 
 @pytest.mark.parametrize('pressure,expected', [
     (93193,  [[830.46567,   0.79742,   0.93505],
-              [676.09497,   0.63776,   3.02102]]),
+              [676.18340,   0.63782,   3.02102]]),
     (None,   [[868.72425,   0.79742,   1.01664],
-              [680.66679,   0.63776,   3.28463]]),
+              [680.73800,   0.63782,   3.28463]]),
     (101325, [[868.72425,   0.79742,   1.01664],
-              [680.66679,   0.63776,   3.28463]])
+              [680.73800,   0.63782,   3.28463]])
 ])
 def test_disc_value(pressure, expected):
     # see GH 449 for pressure=None vs. 101325.
@@ -1080,7 +1080,7 @@ def test_dirindex(times):
                                             pressure=pressure,
                                             use_delta_kt_prime=True,
                                             temp_dew=tdew).values
-    expected_out = np.array([np.nan, 0., 748.31562753, 630.72592644])
+    expected_out = np.array([np.nan, 0., 748.31562800, 630.73752100])
 
     tolerance = 1e-8
     assert np.allclose(out, expected_out, rtol=tolerance, atol=0,

pvlib/tests/test_solarposition.py

@@ -139,7 +139,8 @@ def test_spa_python_numpy_physical_dst(expected_solpos, golden):
     assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
 
 
-def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
+@pytest.mark.parametrize('delta_t', [65.0, None, np.array([65, 65])])
+def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden, delta_t):
     # solution from NREL SAP web calculator
     south = Location(-35.0, 0.0, tz='UTC')
     times = pd.DatetimeIndex([datetime.datetime(1996, 7, 5, 0),
@@ -160,7 +161,7 @@ def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
 
     result = solarposition.sun_rise_set_transit_spa(times, south.latitude,
                                                     south.longitude,
-                                                    delta_t=65.0)
+                                                    delta_t=delta_t)
     result_rounded = pd.DataFrame(index=result.index)
     # need to iterate because to_datetime does not accept 2D data
     # the rounding fails on pandas < 0.17
@@ -172,7 +173,7 @@ def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
     # test for Golden, CO compare to NREL SPA
     result = solarposition.sun_rise_set_transit_spa(
         expected_rise_set_spa.index, golden.latitude, golden.longitude,
-        delta_t=65.0)
+        delta_t=delta_t)
 
     # round to nearest minute
     result_rounded = pd.DataFrame(index=result.index)
@@ -477,20 +478,20 @@ def test_get_solarposition_altitude(
 
 
 @pytest.mark.parametrize("delta_t, method", [
-    (None, 'nrel_numpy'),
-    pytest.param(
-        None, 'nrel_numba',
-        marks=[pytest.mark.xfail(
-            reason='spa.calculate_deltat not implemented for numba yet')]),
+    (None, 'nrel_numba'),
     (67.0, 'nrel_numba'),
+    (np.array([67.0, 67.0]), 'nrel_numba'),
+    # minimize reloads, with numpy being last
+    (None, 'nrel_numpy'),
     (67.0, 'nrel_numpy'),
-    ])
+    (np.array([67.0, 67.0]), 'nrel_numpy'),
+])
 def test_get_solarposition_deltat(delta_t, method, expected_solpos_multi,
                                   golden):
     times = pd.date_range(datetime.datetime(2003, 10, 17, 13, 30, 30),
                           periods=2, freq='D', tz=golden.tz)
     with warnings.catch_warnings():
-        # don't warn on method reload or num threads
+        # don't warn on method reload
         warnings.simplefilter("ignore")
         ephem_data = solarposition.get_solarposition(times, golden.latitude,
                                                      golden.longitude,
@@ -505,6 +506,21 @@ def test_get_solarposition_deltat(delta_t, method, expected_solpos_multi,
     assert_frame_equal(this_expected, ephem_data[this_expected.columns])
 
 
+@pytest.mark.parametrize("method", ['nrel_numba', 'nrel_numpy'])
+def test_spa_array_delta_t(method):
+    # make sure that time-varying delta_t produces different answers
+    times = pd.to_datetime(["2019-01-01", "2019-01-01"]).tz_localize("UTC")
+    expected = pd.Series([257.26969492, 257.2701359], index=times)
+    with warnings.catch_warnings():
+        # don't warn on method reload
+        warnings.simplefilter("ignore")
+        ephem_data = solarposition.get_solarposition(times, 40, -80,
+                                                     delta_t=np.array([67, 0]),
+                                                     method=method)
+
+    assert_series_equal(ephem_data['azimuth'], expected, check_names=False)
+
+
 def test_get_solarposition_no_kwargs(expected_solpos, golden):
     times = pd.date_range(datetime.datetime(2003, 10, 17, 13, 30, 30),
                           periods=1, freq='D', tz=golden.tz)
@@ -529,20 +545,22 @@ def test_get_solarposition_method_pyephem(expected_solpos, golden):
     assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
 
 
-def test_nrel_earthsun_distance():
+@pytest.mark.parametrize('delta_t', [64.0, None, np.array([64, 64])])
+def test_nrel_earthsun_distance(delta_t):
     times = pd.DatetimeIndex([datetime.datetime(2015, 1, 2),
                               datetime.datetime(2015, 8, 2)]
                              ).tz_localize('MST')
-    result = solarposition.nrel_earthsun_distance(times, delta_t=64.0)
+    result = solarposition.nrel_earthsun_distance(times, delta_t=delta_t)
     expected = pd.Series(np.array([0.983289204601, 1.01486146446]),
                          index=times)
     assert_series_equal(expected, result)
 
-    times = datetime.datetime(2015, 1, 2)
-    result = solarposition.nrel_earthsun_distance(times, delta_t=64.0)
-    expected = pd.Series(np.array([0.983289204601]),
-                         index=pd.DatetimeIndex([times, ]))
-    assert_series_equal(expected, result)
+    if np.size(delta_t) == 1:  # skip the array delta_t
+        times = datetime.datetime(2015, 1, 2)
+        result = solarposition.nrel_earthsun_distance(times, delta_t=delta_t)
+        expected = pd.Series(np.array([0.983289204601]),
+                             index=pd.DatetimeIndex([times, ]))
+        assert_series_equal(expected, result)
 
 
 def test_equation_of_time():
@@ -579,19 +597,20 @@ def test_declination():
 def test_analytical_zenith():
     times = pd.date_range(start="1/1/2015 0:00", end="12/31/2015 23:00",
                           freq="h").tz_localize('Etc/GMT+8')
+    times_utc = times.tz_convert('UTC')
     lat, lon = 37.8, -122.25
     lat_rad = np.deg2rad(lat)
     output = solarposition.spa_python(times, lat, lon, 100)
     solar_zenith = np.deg2rad(output['zenith'])  # spa
     # spencer
-    eot = solarposition.equation_of_time_spencer71(times.dayofyear)
+    eot = solarposition.equation_of_time_spencer71(times_utc.dayofyear)
     hour_angle = np.deg2rad(solarposition.hour_angle(times, lon, eot))
-    decl = solarposition.declination_spencer71(times.dayofyear)
+    decl = solarposition.declination_spencer71(times_utc.dayofyear)
     zenith_1 = solarposition.solar_zenith_analytical(lat_rad, hour_angle, decl)
     # pvcdrom and cooper
-    eot = solarposition.equation_of_time_pvcdrom(times.dayofyear)
+    eot = solarposition.equation_of_time_pvcdrom(times_utc.dayofyear)
     hour_angle = np.deg2rad(solarposition.hour_angle(times, lon, eot))
-    decl = solarposition.declination_cooper69(times.dayofyear)
+    decl = solarposition.declination_cooper69(times_utc.dayofyear)
     zenith_2 = solarposition.solar_zenith_analytical(lat_rad, hour_angle, decl)
     assert np.allclose(zenith_1, solar_zenith, atol=0.015)
     assert np.allclose(zenith_2, solar_zenith, atol=0.025)
@@ -600,22 +619,23 @@ def test_analytical_zenith():
 def test_analytical_azimuth():
     times = pd.date_range(start="1/1/2015 0:00", end="12/31/2015 23:00",
                           freq="h").tz_localize('Etc/GMT+8')
+    times_utc = times.tz_convert('UTC')
     lat, lon = 37.8, -122.25
     lat_rad = np.deg2rad(lat)
     output = solarposition.spa_python(times, lat, lon, 100)
     solar_azimuth = np.deg2rad(output['azimuth'])  # spa
     solar_zenith = np.deg2rad(output['zenith'])
     # spencer
-    eot = solarposition.equation_of_time_spencer71(times.dayofyear)
+    eot = solarposition.equation_of_time_spencer71(times_utc.dayofyear)
     hour_angle = np.deg2rad(solarposition.hour_angle(times, lon, eot))
-    decl = solarposition.declination_spencer71(times.dayofyear)
+    decl = solarposition.declination_spencer71(times_utc.dayofyear)
     zenith = solarposition.solar_zenith_analytical(lat_rad, hour_angle, decl)
     azimuth_1 = solarposition.solar_azimuth_analytical(lat_rad, hour_angle,
                                                        decl, zenith)
     # pvcdrom and cooper
-    eot = solarposition.equation_of_time_pvcdrom(times.dayofyear)
+    eot = solarposition.equation_of_time_pvcdrom(times_utc.dayofyear)
     hour_angle = np.deg2rad(solarposition.hour_angle(times, lon, eot))
-    decl = solarposition.declination_cooper69(times.dayofyear)
+    decl = solarposition.declination_cooper69(times_utc.dayofyear)
     zenith = solarposition.solar_zenith_analytical(lat_rad, hour_angle, decl)
     azimuth_2 = solarposition.solar_azimuth_analytical(lat_rad, hour_angle,
                                                        decl, zenith)
@@ -665,21 +685,45 @@ def test_hour_angle():
         '2015-01-02 12:04:44.6340'
     ]).tz_localize('Etc/GMT+7')
     eot = np.array([-3.935172, -4.117227, -4.026295])
-    hours = solarposition.hour_angle(times, longitude, eot)
+    hourangle = solarposition.hour_angle(times, longitude, eot)
     expected = (-70.682338, 70.72118825000001, 0.000801250)
     # FIXME: there are differences from expected NREL SPA calculator values
     # sunrise: 4 seconds, sunset: 48 seconds, transit: 0.2 seconds
     # but the differences may be due to other SPA input parameters
-    assert np.allclose(hours, expected)
+    assert np.allclose(hourangle, expected)
+
+    hours = solarposition._hour_angle_to_hours(
+        times, hourangle, longitude, eot)
+    result = solarposition._times_to_hours_after_local_midnight(times)
+    assert np.allclose(result, hours)
+
+    result = solarposition._local_times_from_hours_since_midnight(times, hours)
+    assert result.equals(times)
+
+    times = times.tz_convert(None)
+    with pytest.raises(ValueError):
+        solarposition.hour_angle(times, longitude, eot)
+    with pytest.raises(ValueError):
+        solarposition._hour_angle_to_hours(times, hourangle, longitude, eot)
+    with pytest.raises(ValueError):
+        solarposition._times_to_hours_after_local_midnight(times)
+    with pytest.raises(ValueError):
+        solarposition._local_times_from_hours_since_midnight(times, hours)
 
 
 def test_sun_rise_set_transit_geometric(expected_rise_set_spa, golden_mst):
     """Test geometric calculations for sunrise, sunset, and transit times"""
     times = expected_rise_set_spa.index
+    times_utc = times.tz_convert('UTC')
     latitude = golden_mst.latitude
     longitude = golden_mst.longitude
-    eot = solarposition.equation_of_time_spencer71(times.dayofyear)  # minutes
-    decl = solarposition.declination_spencer71(times.dayofyear)  # radians
+    eot = solarposition.equation_of_time_spencer71(
+        times_utc.dayofyear)  # minutes
+    decl = solarposition.declination_spencer71(times_utc.dayofyear)  # radians
+    with pytest.raises(ValueError):
+        solarposition.sun_rise_set_transit_geometric(
+            times.tz_convert(None), latitude=latitude, longitude=longitude,
+            declination=decl, equation_of_time=eot)
     sr, ss, st = solarposition.sun_rise_set_transit_geometric(
         times, latitude=latitude, longitude=longitude, declination=decl,
         equation_of_time=eot)
@@ -742,6 +786,7 @@ def test__datetime_to_unixtime_units(unit, tz):
 
 
 @requires_pandas_2_0
+@pytest.mark.parametrize('tz', [None, 'utc', 'US/Eastern'])
 @pytest.mark.parametrize('method', [
     'nrel_numpy',
     'ephemeris',
@@ -749,7 +794,6 @@ def test__datetime_to_unixtime_units(unit, tz):
     pytest.param('nrel_numba', marks=requires_numba),
     pytest.param('nrel_c', marks=requires_spa_c),
 ])
-@pytest.mark.parametrize('tz', [None, 'utc', 'US/Eastern'])
 def test_get_solarposition_microsecond_index(method, tz):
     # https://github.com/pvlib/pvlib-python/issues/1932
 
@@ -758,8 +802,12 @@ def test_get_solarposition_microsecond_index(method, tz):
     index_ns = pd.date_range(unit='ns', **kwargs)
     index_us = pd.date_range(unit='us', **kwargs)
 
-    sp_ns = solarposition.get_solarposition(index_ns, 40, -80, method=method)
-    sp_us = solarposition.get_solarposition(index_us, 40, -80, method=method)
+    with warnings.catch_warnings():
+        # don't warn on method reload
+        warnings.simplefilter("ignore")
+
+        sp_ns = solarposition.get_solarposition(index_ns, 0, 0, method=method)
+        sp_us = solarposition.get_solarposition(index_us, 0, 0, method=method)
 
     assert_frame_equal(sp_ns, sp_us, check_index_type=False)
 
@@ -781,7 +829,7 @@ def test_nrel_earthsun_distance_microsecond_index(tz):
 
 
 @requires_pandas_2_0
-@pytest.mark.parametrize('tz', [None, 'utc', 'US/Eastern'])
+@pytest.mark.parametrize('tz', ['utc', 'US/Eastern'])
 def test_hour_angle_microsecond_index(tz):
     # https://github.com/pvlib/pvlib-python/issues/1932
 
@@ -813,7 +861,7 @@ def test_rise_set_transit_spa_microsecond_index(tz):
 
 
 @requires_pandas_2_0
-@pytest.mark.parametrize('tz', [None, 'utc', 'US/Eastern'])
+@pytest.mark.parametrize('tz', ['utc', 'US/Eastern'])
 def test_rise_set_transit_geometric_microsecond_index(tz):
     # https://github.com/pvlib/pvlib-python/issues/1932
 
@@ -838,7 +886,7 @@ def test_spa_python_numba_physical(expected_solpos, golden_mst):
     times = pd.date_range(datetime.datetime(2003, 10, 17, 12, 30, 30),
                           periods=1, freq='D', tz=golden_mst.tz)
     with warnings.catch_warnings():
-        # don't warn on method reload or num threads
+        # don't warn on method reload
         # ensure that numpy is the most recently used method so that
         # we can use the warns filter below
         warnings.simplefilter("ignore")
@@ -865,7 +913,7 @@ def test_spa_python_numba_physical_dst(expected_solpos, golden):
                           periods=1, freq='D', tz=golden.tz)
 
     with warnings.catch_warnings():
-        # don't warn on method reload or num threads
+        # don't warn on method reload
         warnings.simplefilter("ignore")
         ephem_data = solarposition.spa_python(times, golden.latitude,
                                               golden.longitude, pressure=82000,

pvlib/tests/test_spa.py

@@ -234,7 +234,7 @@ class SpaBase:
 
     def test_solar_position(self):
         with warnings.catch_warnings():
-            # don't warn on method reload or num threads
+            # don't warn on method reload
             warnings.simplefilter("ignore")
             spa_out_0 = self.spa.solar_position(
                 unixtimes, lat, lon, elev, pressure, temp, delta_t,

pvlib/tools.py

@@ -206,8 +206,32 @@ def _pandas_to_doy(pd_object):
     Returns
     -------
     dayofyear
+
+    Notes
+    -----
+    Day of year is determined using UTC, since pandas uses local hour
+    """
+    return _pandas_to_utc(pd_object).dayofyear
+
+
+def _pandas_to_utc(pd_object):
     """
-    return pd_object.dayofyear
+    Converts a pandas datetime-like object to UTC, if localized.
+    Otherwise, assume UTC.
+
+    Parameters
+    ----------
+    pd_object : DatetimeIndex or Timestamp
+
+    Returns
+    -------
+    pandas object localized to or assumed to be UTC.
+    """
+    try:
+        pd_object_utc = pd_object.tz_convert('UTC')
+    except TypeError:
+        pd_object_utc = pd_object
+    return pd_object_utc
 
 
 def _doy_to_datetimeindex(doy, epoch_year=2014):
@@ -230,7 +254,7 @@ def _doy_to_datetimeindex(doy, epoch_year=2014):
 
 
 def _datetimelike_scalar_to_doy(time):
-    return pd.DatetimeIndex([pd.Timestamp(time)]).dayofyear
+    return _pandas_to_doy(_datetimelike_scalar_to_datetimeindex(time))
 
 
 def _datetimelike_scalar_to_datetimeindex(time):