def test_simplified_solis_dni_extra():
expected = pd.DataFrame(np.array([[963.555414, 1069.33637, 129.693603]]),
columns=['dni', 'ghi', 'dhi'])
expected = expected[['ghi', 'dni', 'dhi']]
out = clearsky.simplified_solis(80, dni_extra=pd.Series(1370))
assert_frame_equal(expected, out)
def test_ineichen_series():
times = pd.date_range(start='2014-06-24',
end='2014-06-25',
freq='3h',
tz='America/Phoenix')
apparent_zenith = pd.Series(np.array([
124.0390863, 113.38779941, 82.85457044, 46.0467599, 10.56413562,
34.86074109, 72.41687122, 105.69538659, 124.05614124
]),
index=times)
am = pd.Series(np.array([
nan, nan, 6.97935524, 1.32355476, 0.93527685, 1.12008114, 3.01614096,
nan, nan
]),
index=times)
expected = pd.DataFrame(
np.array([[0., 0., 0.], [0., 0., 0.],
[65.49426624, 321.16092181, 25.54562017],
[704.6968125, 888.90147035, 87.73601277],
[1044.1230677, 953.24925854, 107.03109696],
[853.02065704, 922.06124712, 96.42909484],
[251.99427693, 655.44925241, 53.9901349], [0., 0., 0.],
[0., 0., 0.]]),
columns=['ghi', 'dni', 'dhi'],
index=times)
out = clearsky.ineichen(apparent_zenith, am, 3)
assert_frame_equal(expected, out)
def test_simplified_solis_series_elevation():
expected = pd.DataFrame(np.array([[959.335463, 1064.653145, 129.125602]]),
columns=['dni', 'ghi', 'dhi'])
expected = expected[['ghi', 'dni', 'dhi']]
out = clearsky.simplified_solis(pd.Series(80))
assert_frame_equal(expected, out)
def test_ineichen_dni_extra():
expected = pd.DataFrame(np.array(
[[1042.72590228, 946.35279683, 110.75033088]]),
columns=['ghi', 'dni', 'dhi'])
out = clearsky.ineichen(10, 1, 3, dni_extra=pd.Series(1370))
assert_frame_equal(expected, out)
def test_ineichen_altitude():
expected = pd.DataFrame(np.array(
[[1134.24312405, 994.95377835, 154.40492924]]),
columns=['ghi', 'dni', 'dhi'])
out = clearsky.ineichen(10, 1, 3, altitude=pd.Series(2000))
assert_frame_equal(expected, out)
def test_axis_azimuth():
apparent_zenith = pd.Series([30])
apparent_azimuth = pd.Series([90])
tracker_data = tracking.singleaxis(apparent_zenith, apparent_azimuth,
axis_tilt=0, axis_azimuth=90,
max_angle=90, backtrack=True,
gcr=2.0/7.0)
expect = pd.DataFrame({'aoi': 30, 'surface_azimuth': 180,
'surface_tilt': 0, 'tracker_theta': 0},
index=[0], dtype=np.float64)
expect = expect[SINGLEAXIS_COL_ORDER]
assert_frame_equal(expect, tracker_data)
apparent_zenith = pd.Series([30])
apparent_azimuth = pd.Series([180])
tracker_data = tracking.singleaxis(apparent_zenith, apparent_azimuth,
axis_tilt=0, axis_azimuth=90,
max_angle=90, backtrack=True,
gcr=2.0/7.0)
expect = pd.DataFrame({'aoi': 0, 'surface_azimuth': 180,
'surface_tilt': 30, 'tracker_theta': 30},
index=[0], dtype=np.float64)
expect = expect[SINGLEAXIS_COL_ORDER]
assert_frame_equal(expect, tracker_data)
def test_nans():
apparent_zenith = np.array([10, np.nan, 10])
apparent_azimuth = np.array([180, 180, np.nan])
with np.errstate(invalid='ignore'):
tracker_data = tracking.singleaxis(apparent_zenith, apparent_azimuth,
axis_tilt=0, axis_azimuth=0,
max_angle=90, backtrack=True,
gcr=2.0/7.0)
expect = {'tracker_theta': np.array([0, nan, nan]),
'aoi': np.array([10, nan, nan]),
'surface_azimuth': np.array([90, nan, nan]),
'surface_tilt': np.array([0, nan, nan])}
for k, v in expect.items():
assert_allclose(tracker_data[k], v, atol=1e-7)
# repeat with Series because nans can differ
apparent_zenith = pd.Series(apparent_zenith)
apparent_azimuth = pd.Series(apparent_azimuth)
with np.errstate(invalid='ignore'):
tracker_data = tracking.singleaxis(apparent_zenith, apparent_azimuth,
axis_tilt=0, axis_azimuth=0,
max_angle=90, backtrack=True,
gcr=2.0/7.0)
expect = pd.DataFrame(np.array(
[[ 0., 10., 90., 0.],
[nan, nan, nan, nan],
[nan, nan, nan, nan]]),
columns=['tracker_theta', 'aoi', 'surface_azimuth', 'surface_tilt'])
assert_frame_equal(tracker_data, expect)
def test_PVSystem_get_irradiance():
system = pvsystem.PVSystem(surface_tilt=32, surface_azimuth=135)
times = pd.date_range(start='20160101 1200-0700',
end='20160101 1800-0700',
freq='6H')
location = Location(latitude=32, longitude=-111)
solar_position = location.get_solarposition(times)
irrads = pd.DataFrame({
'dni': [900, 0],
'ghi': [600, 0],
'dhi': [100, 0]
},
index=times)
irradiance = system.get_irradiance(solar_position['apparent_zenith'],
solar_position['azimuth'],
irrads['dni'], irrads['ghi'],
irrads['dhi'])
expected = pd.DataFrame(data=np.array(
[[883.65494055, 745.86141676, 137.79352379, 126.397131, 11.39639279],
[0., -0., 0., 0., 0.]]),
columns=[
'poa_global', 'poa_direct', 'poa_diffuse',
'poa_sky_diffuse', 'poa_ground_diffuse'
],
index=times)
assert_frame_equal(irradiance, expected, check_less_precise=2)
def test_axis_tilt():
apparent_zenith = pd.Series([30])
apparent_azimuth = pd.Series([135])
tracker_data = tracking.singleaxis(apparent_zenith, apparent_azimuth,
axis_tilt=30, axis_azimuth=180,
max_angle=90, backtrack=True,
gcr=2.0/7.0)
expect = pd.DataFrame({'aoi': 7.286245, 'surface_azimuth': 142.65730,
'surface_tilt': 35.98741,
'tracker_theta': -20.88121},
index=[0], dtype=np.float64)
expect = expect[SINGLEAXIS_COL_ORDER]
assert_frame_equal(expect, tracker_data)
tracker_data = tracking.singleaxis(apparent_zenith, apparent_azimuth,
axis_tilt=30, axis_azimuth=0,
max_angle=90, backtrack=True,
gcr=2.0/7.0)
expect = pd.DataFrame({'aoi': 47.6632, 'surface_azimuth': 50.96969,
'surface_tilt': 42.5152, 'tracker_theta': 31.6655},
index=[0], dtype=np.float64)
expect = expect[SINGLEAXIS_COL_ORDER]
assert_frame_equal(expect, tracker_data)
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
# ensure that numpy is the most recently used method so that
# we can use the warns filter below
warnings.simplefilter("ignore")
ephem_data = solarposition.spa_python(times,
golden_mst.latitude,
golden_mst.longitude,
pressure=82000,
temperature=11,
delta_t=67,
atmos_refract=0.5667,
how='numpy',
numthreads=1)
with pytest.warns(UserWarning):
ephem_data = solarposition.spa_python(times,
golden_mst.latitude,
golden_mst.longitude,
pressure=82000,
temperature=11,
delta_t=67,
atmos_refract=0.5667,
how='numba',
numthreads=1)
expected_solpos.index = times
assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
def test_spa_python_numba_physical_dst(expected_solpos, golden):
times = pd.date_range(datetime.datetime(2003, 10, 17, 13, 30, 30),
periods=1,
freq='D',
tz=golden.tz)
with warnings.catch_warnings():
# don't warn on method reload or num threads
warnings.simplefilter("ignore")
ephem_data = solarposition.spa_python(times,
golden.latitude,
golden.longitude,
pressure=82000,
temperature=11,
delta_t=67,
atmos_refract=0.5667,
how='numba',
numthreads=1)
expected_solpos.index = times
assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
with pytest.warns(UserWarning):
# test that we get a warning when reloading to use numpy only
ephem_data = solarposition.spa_python(times,
golden.latitude,
golden.longitude,
pressure=82000,
temperature=11,
delta_t=67,
atmos_refract=0.5667,
how='numpy',
numthreads=1)
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_read_crn(testfile, columns, dtypes):
index = pd.DatetimeIndex([
'2019-01-01 16:10:00', '2019-01-01 16:15:00', '2019-01-01 16:20:00',
'2019-01-01 16:25:00'
],
freq=None).tz_localize('UTC')
values = np.array([[
53131, 20190101, 1610, 20190101, 910, 3, -111.17, 32.24, nan, 0.0,
296.0, 0, 4.4, 'C', 0, 90.0, 0, nan, nan, 24, 0, 0.78, 0
],
[
53131, 20190101, 1615, 20190101, 915, 3, -111.17,
32.24, 3.3, 0.0, 183.0, 0, 4.0, 'C', 0, 87.0, 0,
nan, nan, 1182, 0, 0.36, 0
],
[
53131, 20190101, 1620, 20190101, 920, 3, -111.17,
32.24, 3.5, 0.0, 340.0, 0, 4.3, 'C', 0, 83.0, 0,
nan, nan, 1183, 0, 0.53, 0
],
[
53131, 20190101, 1625, 20190101, 925, 3, -111.17,
32.24, 4.0, 0.0, 393.0, 0, 4.8, 'C', 0, 81.0, 0,
nan, nan, 1223, 0, 0.64, 0
]])
expected = pd.DataFrame(values, columns=columns, index=index)
for (col, _dtype) in zip(expected.columns, dtypes):
expected[col] = expected[col].astype(_dtype)
out = crn.read_crn(testfile)
assert_frame_equal(out, expected)
def test_ineichen_series_perez_enhancement():
times = pd.date_range(start='2014-06-24',
end='2014-06-25',
freq='3h',
tz='America/Phoenix')
apparent_zenith = pd.Series(np.array([
124.0390863, 113.38779941, 82.85457044, 46.0467599, 10.56413562,
34.86074109, 72.41687122, 105.69538659, 124.05614124
]),
index=times)
am = pd.Series(np.array([
nan, nan, 6.97935524, 1.32355476, 0.93527685, 1.12008114, 3.01614096,
nan, nan
]),
index=times)
expected = pd.DataFrame(
np.array([[0., 0., 0.], [0., 0., 0.],
[91.1249279, 321.16092171, 51.17628184],
[716.46580547, 888.9014706, 99.50500553],
[1053.42066073, 953.24925905, 116.3286895],
[863.54692748, 922.06124652, 106.9553658],
[271.06382275, 655.44925213, 73.05968076], [0., 0., 0.],
[0., 0., 0.]]),
columns=['ghi', 'dni', 'dhi'],
index=times)
out = clearsky.ineichen(apparent_zenith, am, 3, perez_enhancement=True)
assert_frame_equal(expected, out)
def test_get_solarposition(expected_solpos, golden_mst):
times = pd.date_range(datetime.datetime(2003, 10, 17, 12, 30, 30),
periods=1, freq='D', tz=golden_mst.tz)
ephem_data = golden_mst.get_solarposition(times, temperature=11)
ephem_data = np.round(ephem_data, 3)
expected_solpos.index = times
expected_solpos = np.round(expected_solpos, 3)
assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
def test_from_epw():
from test_epw import epw_testfile
from pvlib.iotools import read_epw
data, meta = read_epw(epw_testfile)
loc = Location.from_epw(meta, data)
assert loc.name is not None
assert loc.altitude != 0
assert loc.tz != 'UTC'
assert_frame_equal(loc.weather, data)
def test_get_irradiance():
system = tracking.SingleAxisTracker(max_angle=90,
axis_tilt=30,
axis_azimuth=180,
gcr=2.0 / 7.0,
backtrack=True)
times = pd.date_range(start='20160101 1200-0700',
end='20160101 1800-0700',
freq='6H')
# latitude=32, longitude=-111
solar_position = pd.DataFrame(np.array([[
55.36421554, 55.38851771, 34.63578446, 34.61148229, 172.32003763,
-3.44516534
],
[
96.50000401, 96.50000401,
-6.50000401, -6.50000401,
246.91581654, -3.56292888
]]),
columns=[
'apparent_zenith', 'zenith',
'apparent_elevation', 'elevation',
'azimuth', 'equation_of_time'
],
index=times)
irrads = pd.DataFrame({
'dni': [900, 0],
'ghi': [600, 0],
'dhi': [100, 0]
},
index=times)
solar_zenith = solar_position['apparent_zenith']
solar_azimuth = solar_position['azimuth']
# invalid warnings already generated in horizon test above,
# no need to clutter test output here
with np.errstate(invalid='ignore'):
tracker_data = system.singleaxis(solar_zenith, solar_azimuth)
# some invalid values in irradiance.py. not our problem here
with np.errstate(invalid='ignore'):
irradiance = system.get_irradiance(tracker_data['surface_tilt'],
tracker_data['surface_azimuth'],
solar_zenith, solar_azimuth,
irrads['dni'], irrads['ghi'],
irrads['dhi'])
expected = pd.DataFrame(data=np.array(
[[961.80070, 815.94490, 145.85580, 135.32820, 10.52757492],
[nan, nan, nan, nan, nan]]),
columns=[
'poa_global', 'poa_direct', 'poa_diffuse',
'poa_sky_diffuse', 'poa_ground_diffuse'
],
index=times)
assert_frame_equal(irradiance, expected, check_less_precise=2)
def test_get_clearsky_haurwitz(times):
tus = Location(32.2, -111, 'US/Arizona', 700, 'Tucson')
clearsky = tus.get_clearsky(times, model='haurwitz')
expected = pd.DataFrame(data=np.array([[0.],
[242.30085588], [559.38247117],
[384.6873791], [0.]]),
columns=['ghi'],
index=times)
assert_frame_equal(expected, clearsky)
def test_from_tmy_2():
from test_tmy import TMY2_TESTFILE
from pvlib.iotools import read_tmy2
data, meta = read_tmy2(TMY2_TESTFILE)
loc = Location.from_tmy(meta, data)
assert loc.name is not None
assert loc.altitude != 0
assert loc.tz != 'UTC'
assert_frame_equal(loc.weather, data)
def test_liujordan():
expected = pd.DataFrame(np.array(
[[863.859736967, 653.123094076, 220.65905025]]),
columns=['ghi', 'dni', 'dhi'],
index=[0])
out = irradiance.liujordan(pd.Series([10]),
pd.Series([0.5]),
pd.Series([1.1]),
dni_extra=1400)
assert_frame_equal(out, expected)
def test_prepare_inputs_from_poa(sapm_dc_snl_ac_system, location, weather,
total_irrad):
data = weather.copy()
data[['poa_global', 'poa_diffuse', 'poa_direct']] = total_irrad
mc = ModelChain(sapm_dc_snl_ac_system, location)
mc.prepare_inputs_from_poa(data)
# weather attribute
assert_frame_equal(mc.weather, weather)
# total_irrad attribute
assert_frame_equal(mc.total_irrad, total_irrad)
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_clearsky_simplified_solis(times):
tus = Location(32.2, -111, 'US/Arizona', 700, 'Tucson')
clearsky = tus.get_clearsky(times, model='simplified_solis')
expected = pd.DataFrame(data=np.array(
[[0., 0., 0.], [70.00146271, 638.01145669, 236.71136245],
[101.69729217, 852.51950946, 577.1117803],
[86.1679965, 755.98048017, 385.59586091], [0., 0., 0.]]),
columns=['dhi', 'dni', 'ghi'],
index=times)
expected = expected[['ghi', 'dni', 'dhi']]
assert_frame_equal(expected, clearsky, check_less_precise=2)
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)
ephem_data = solarposition.get_solarposition(times, golden.latitude,
golden.longitude)
expected_solpos.index = times
expected_solpos = np.round(expected_solpos, 2)
ephem_data = np.round(ephem_data, 2)
assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
def test_scale_voltage_current_power():
data = pd.DataFrame(
np.array([[2, 1.5, 10, 8, 12, 0.5, 1.5]]),
columns=['i_sc', 'i_mp', 'v_oc', 'v_mp', 'p_mp', 'i_x', 'i_xx'],
index=[0])
expected = pd.DataFrame(
np.array([[6, 4.5, 20, 16, 72, 1.5, 4.5]]),
columns=['i_sc', 'i_mp', 'v_oc', 'v_mp', 'p_mp', 'i_x', 'i_xx'],
index=[0])
out = pvsystem.scale_voltage_current_power(data, voltage=2, current=3)
assert_frame_equal(out, expected, check_less_precise=5)
def test_simplified_solis_pressure():
expected = pd.DataFrame(np.array(
[[964.26930718, 1067.96543669, 127.22841797],
[961.88811874, 1066.36847963, 128.1402539],
[959.58112234, 1064.81837558, 129.0304193]]),
columns=['dni', 'ghi', 'dhi'])
expected = expected[['ghi', 'dni', 'dhi']]
out = clearsky.simplified_solis(80,
pressure=pd.Series([95000, 98000, 101000]))
assert_frame_equal(expected, out)
def test_spa_c_physical_dst(expected_solpos, golden):
times = pd.date_range(datetime.datetime(2003, 10, 17, 13, 30, 30),
periods=1,
freq='D',
tz=golden.tz)
ephem_data = solarposition.spa_c(times,
golden.latitude,
golden.longitude,
pressure=82000,
temperature=11)
expected_solpos.index = times
assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
def test_sun_rise_set_transit_spa(expected_rise_set_spa, golden):
# solution from NREL SAP web calculator
south = Location(-35.0, 0.0, tz='UTC')
times = pd.DatetimeIndex(
[datetime.datetime(1996, 7, 5, 0),
datetime.datetime(2004, 12, 4, 0)]).tz_localize('UTC')
sunrise = pd.DatetimeIndex([
datetime.datetime(1996, 7, 5, 7, 8, 15),
datetime.datetime(2004, 12, 4, 4, 38, 57)
]).tz_localize('UTC').tolist()
sunset = pd.DatetimeIndex([
datetime.datetime(1996, 7, 5, 17, 1, 4),
datetime.datetime(2004, 12, 4, 19, 2, 3)
]).tz_localize('UTC').tolist()
transit = pd.DatetimeIndex([
datetime.datetime(1996, 7, 5, 12, 4, 36),
datetime.datetime(2004, 12, 4, 11, 50, 22)
]).tz_localize('UTC').tolist()
frame = pd.DataFrame(
{
'sunrise': sunrise,
'sunset': sunset,
'transit': transit
},
index=times)
result = solarposition.sun_rise_set_transit_spa(times,
south.latitude,
south.longitude,
delta_t=65.0)
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
for col, data in result.iteritems():
result_rounded[col] = data.dt.round('1s')
assert_frame_equal(frame, result_rounded)
# 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)
# round to nearest minute
result_rounded = pd.DataFrame(index=result.index)
# need to iterate because to_datetime does not accept 2D data
for col, data in result.iteritems():
result_rounded[col] = data.dt.round('s').tz_convert('MST')
assert_frame_equal(expected_rise_set_spa, result_rounded)
def test_ephemeris_physical_no_tz(expected_solpos, golden_mst):
times = pd.date_range(datetime.datetime(2003, 10, 17, 19, 30, 30),
periods=1,
freq='D')
ephem_data = solarposition.ephemeris(times,
golden_mst.latitude,
golden_mst.longitude,
pressure=82000,
temperature=11)
expected_solpos.index = times
expected_solpos = np.round(expected_solpos, 2)
ephem_data = np.round(ephem_data, 2)
assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns])
def test_pyephem_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)
ephem_data = solarposition.pyephem(times,
golden_mst.latitude,
golden_mst.longitude,
pressure=82000,
temperature=11)
expected_solpos.index = times
assert_frame_equal(expected_solpos.round(2),
ephem_data[expected_solpos.columns].round(2))
