From 009a8f849f8f38b72d1540d4a5c8c7dee7c8e800 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Fri, 9 Sep 2016 15:01:32 -0600 Subject: [PATCH 01/14] Added calculate_deltaT function into spa.py based on the equations given by http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html --- pvlib/spa.py | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/pvlib/spa.py b/pvlib/spa.py index 80aae7c24b..44dec0855d 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1297,3 +1297,74 @@ def earthsun_distance(unixtime, delta_t, numthreads): 0, numthreads, esd=True)[0] return R + + +def calculate_deltaT(year, month): + + if year > 3000 or year < -500: pvl_logger.warning('Delta T' + ' is unknown for years before -1999 and after 3000.' + ' DeltaT values will be calculated, but the calculations' + ' are not intended to be used for these years.') + + #Taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html + + y = year + (month - 0.5)/12 + + + if year < -500: + delta_t = -20+32*((y-1820)/100)**2 + + elif -500 <= year < 500: + delta_t = 10583.6-1014.41*(y/100)+33.78311*(y/100)**2-5.952053*(y/100)**3- \ + 0.1798452*(y/100)**4+0.022174192*(y/100)**5+0.0090316521*(y/100)**6 + + elif 500 <= year < 1600: + delta_t = 1574.2-556.01*((y-1000)/100)+71.23472*((y-1000)/100)**2+ \ + 0.319781*((y-1000)/100)**3-0.8503463 *((y-1000)/100)**4- \ + 0.005050998*((y-1000)/100)**5+0.0083572073*((y-1000)/100)**6 + + elif 1600 <= year < 1700: + delta_t = 120-0.9808*(y-1600)-0.01532*(y-1600)**2+(y-1600)**3/7129 + + elif 1700 <= year < 1800: + delta_t = 8.83+0.1603*(y-1700)-0.0059285*(y-1700)**2+0.00013336*(y-1700)**3- \ + (y-1700)**4/1174000 + + elif 1800 <= year < 1860: + delta_t = 13.72-0.332447*(y-1800)+0.0068612*(y-1800)**2+0.0041116*(y-1800)**3- \ + 0.00037436*(y-1800)**4+0.0000121272*(y-1800)**5-0.0000001699*(y-1800)**6+ \ + 0.000000000875*(y-1800)**7 + + elif 1860 <= year < 1900: + delta_t = 7.6+0.5737*(y-1860)-0.251754*(y-1860)**2+0.01680668*(y-1860)**3- \ + 0.0004473624*(y-1860)**4+(y-1860)**5/233174 + + elif 1900 <= year < 1920: + delta_t = -2.79+1.494119*(y-1900)-0.0598939*(y-1900)**2+0.0061966*(y-1900)**3- \ + 0.000197*(y-1900)**4 + + elif 1920 <= year < 1941: + delta_t = 21.20+0.84493*(y-1920)-0.076100*(y-1920)**2+0.0020936*(y-1920)**3 + + elif 1941 <= year < 1961: + delta_t = 29.07+0.407*(y-1950)-(y-1950)**2/233+(y-1950)**3/2547 + + elif 1961 <= year < 1986: + delta_t = 45.45+1.067*(y-1975)-(y-1975)**2/260-(y-1975)**3/718 + + elif 1986 <= year < 2005: + delta_t = 63.86+0.3345*(y-2000)-0.060374*(y-2000)**2+0.0017275*(y-2000)**3+ \ + 0.000651814*(y-2000)**4+0.00002373599*(y-2000)**5 + + elif 2005 <= year < 2050: + delta_t = 62.92+0.32217*(y-2000)+0.005589*(y-2000)**2 + + elif 2050 <= year < 2150: + delta_t = -20+32*((y-1820)/100)**2-0.5628*(2150-y) + + elif year > 2150: + delta_t = -20+32*((y-1820)/100)**2 + + return delta_t + + From ce21344adcc6bfd594c4363a5e941e763ea8d536 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Tue, 27 Sep 2016 11:41:50 -0600 Subject: [PATCH 02/14] Replaced elsif with np.where, brought down to 1 function --- pvlib/spa.py | 112 ++++++++++++++++++++++++----------------- pvlib/test/test_spa.py | 27 +++++++++- 2 files changed, 92 insertions(+), 47 deletions(-) diff --git a/pvlib/spa.py b/pvlib/spa.py index 44dec0855d..d95bf3f347 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1299,72 +1299,92 @@ def earthsun_distance(unixtime, delta_t, numthreads): return R -def calculate_deltaT(year, month): +def calculate_deltat(year, month): - if year > 3000 or year < -500: pvl_logger.warning('Delta T' - ' is unknown for years before -1999 and after 3000.' - ' DeltaT values will be calculated, but the calculations' - ' are not intended to be used for these years.') + plw = 'Delta is unknown for years before -1999 and after 3000.'\ + +' DeltaT values will be calculated, but the calculations'\ + +' are not intended to be used for these years.' - #Taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html + try: + if np.any((year > 3000) | (year < -500)): + pvl_logger.warning(plw) + except ValueError: + if (year > 3000) | (year < -500): + pvl_logger.warning(plw) - y = year + (month - 0.5)/12 + #Equations taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html + y = year + (month - 0.5)/12 - if year < -500: - delta_t = -20+32*((y-1820)/100)**2 + deltat = np.where(year < -500, + + -20+32*((y-1820)/100)**2, + + np.where((-500 <= year) & (year < 500), - elif -500 <= year < 500: - delta_t = 10583.6-1014.41*(y/100)+33.78311*(y/100)**2-5.952053*(y/100)**3- \ - 0.1798452*(y/100)**4+0.022174192*(y/100)**5+0.0090316521*(y/100)**6 + 10583.6-1014.41*(y/100)+33.78311*(y/100)**2-5.952053*(y/100)**3- \ + 0.1798452*(y/100)**4+0.022174192*(y/100)**5+0.0090316521*(y/100)**6, - elif 500 <= year < 1600: - delta_t = 1574.2-556.01*((y-1000)/100)+71.23472*((y-1000)/100)**2+ \ + np.where((500 <= year) & (year < 1600), + + 1574.2-556.01*((y-1000)/100)+71.23472*((y-1000)/100)**2+ \ 0.319781*((y-1000)/100)**3-0.8503463 *((y-1000)/100)**4- \ - 0.005050998*((y-1000)/100)**5+0.0083572073*((y-1000)/100)**6 + 0.005050998*((y-1000)/100)**5+0.0083572073*((y-1000)/100)**6, + + np.where((1600 <= year) & (year < 1700), - elif 1600 <= year < 1700: - delta_t = 120-0.9808*(y-1600)-0.01532*(y-1600)**2+(y-1600)**3/7129 + 120-0.9808*(y-1600)-0.01532*(y-1600)**2+(y-1600)**3/7129, - elif 1700 <= year < 1800: - delta_t = 8.83+0.1603*(y-1700)-0.0059285*(y-1700)**2+0.00013336*(y-1700)**3- \ - (y-1700)**4/1174000 + np.where((1700 <= year) & (year < 1800), - elif 1800 <= year < 1860: - delta_t = 13.72-0.332447*(y-1800)+0.0068612*(y-1800)**2+0.0041116*(y-1800)**3- \ + 8.83+0.1603*(y-1700)-0.0059285*(y-1700)**2+0.00013336*(y-1700)**3- \ + (y-1700)**4/1174000, + + np.where((1800 <= year) & (year < 1860), + + 13.72-0.332447*(y-1800)+0.0068612*(y-1800)**2+0.0041116*(y-1800)**3- \ 0.00037436*(y-1800)**4+0.0000121272*(y-1800)**5-0.0000001699*(y-1800)**6+ \ - 0.000000000875*(y-1800)**7 + 0.000000000875*(y-1800)**7, + + np.where((1860 <= year) & (year < 1900), + + 7.6+0.5737*(y-1860)-0.251754*(y-1860)**2+0.01680668*(y-1860)**3- \ + 0.0004473624*(y-1860)**4+(y-1860)**5/233174, + + np.where((1900 <= year) & (year < 1920), + + -2.79+1.494119*(y-1900)-0.0598939*(y-1900)**2+0.0061966*(y-1900)**3- \ + 0.000197*(y-1900)**4, + + np.where(( 1920 <= year) & (year < 1941), + + 21.20+0.84493*(y-1920)-0.076100*(y-1920)**2+0.0020936*(y-1920)**3, + + np.where((1941 <= year) & (year < 1961), + + 29.07+0.407*(y-1950)-(y-1950)**2/233+(y-1950)**3/2547, + + np.where((1961 <= year) & (year < 1986), - elif 1860 <= year < 1900: - delta_t = 7.6+0.5737*(y-1860)-0.251754*(y-1860)**2+0.01680668*(y-1860)**3- \ - 0.0004473624*(y-1860)**4+(y-1860)**5/233174 + 45.45+1.067*(y-1975)-(y-1975)**2/260-(y-1975)**3/718, - elif 1900 <= year < 1920: - delta_t = -2.79+1.494119*(y-1900)-0.0598939*(y-1900)**2+0.0061966*(y-1900)**3- \ - 0.000197*(y-1900)**4 + np.where((1986 <= year) & (year < 2005), - elif 1920 <= year < 1941: - delta_t = 21.20+0.84493*(y-1920)-0.076100*(y-1920)**2+0.0020936*(y-1920)**3 + 63.86+0.3345*(y-2000)-0.060374*(y-2000)**2+0.0017275*(y-2000)**3+ \ + 0.000651814*(y-2000)**4+0.00002373599*(y-2000)**5, - elif 1941 <= year < 1961: - delta_t = 29.07+0.407*(y-1950)-(y-1950)**2/233+(y-1950)**3/2547 + np.where((2005 <= year) & (year < 2050), - elif 1961 <= year < 1986: - delta_t = 45.45+1.067*(y-1975)-(y-1975)**2/260-(y-1975)**3/718 + 62.92+0.32217*(y-2000)+0.005589*(y-2000)**2, - elif 1986 <= year < 2005: - delta_t = 63.86+0.3345*(y-2000)-0.060374*(y-2000)**2+0.0017275*(y-2000)**3+ \ - 0.000651814*(y-2000)**4+0.00002373599*(y-2000)**5 + np.where((2050 <= year) & (year < 2150), - elif 2005 <= year < 2050: - delta_t = 62.92+0.32217*(y-2000)+0.005589*(y-2000)**2 + -20+32*((y-1820)/100)**2-0.5628*(2150-y), + np.where( year > 2150, - elif 2050 <= year < 2150: - delta_t = -20+32*((y-1820)/100)**2-0.5628*(2150-y) + -20+32*((y-1820)/100)**2, 0))))))))))))))) - elif year > 2150: - delta_t = -20+32*((y-1820)/100)**2 - - return delta_t + deltat = np.asscalar(deltat) if np.isscalar(year) & np.isscalar(month) else deltat + return deltat diff --git a/pvlib/test/test_spa.py b/pvlib/test/test_spa.py index 46f665f0e3..90f73fbc72 100644 --- a/pvlib/test/test_spa.py +++ b/pvlib/test/test_spa.py @@ -76,7 +76,19 @@ theta0 = 90 - e0 Gamma = 14.340241 Phi = 194.340241 - +year = 1985 +month = 2 +year_array = np.array([-499, 500, 1000, 1500, 1800, 1900, 1950, 1970, 1985, 1990, 2000, 2005]) +month_array = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) +dt_actual = 54.413442486 +dt_actual_array = np.array([1.7184831e+04, 5.7088051e+03, 1.5730419e+03, + 1.9801820e+02, 1.3596506e+01, -2.1171894e+00, + 2.9289261e+01, 4.0824887e+01, 5.4724581e+01, + 5.7426651e+01, 6.4108015e+01, 6.5038015e+01]) +mix_year_array = np.full((10), year) +mix_month_array = np.full((10), month) +mix_year_actual = np.full((10), dt_actual) +mix_month_actual = mix_year_actual class SpaBase(object): """Test functions common to numpy and numba spa""" @@ -316,6 +328,19 @@ def test_earthsun_distance(self): result = self.spa.earthsun_distance(unixtimes, 64.0, 1) assert_almost_equal(R, result, 6) + def test_calculate_deltat(self): + result_mix_year = self.spa.calculate_deltat(mix_year_array, month) + assert_almost_equal(mix_year_actual, result_mix_year) + + result_mix_month = self.spa.calculate_deltat(year, mix_month_array) + assert_almost_equal(mix_month_actual, result_mix_month) + + result_array = self.spa.calculate_deltat(year_array, month_array) + assert_almost_equal(dt_actual_array, result_array, 3) + + result_scalar = self.spa.calculate_deltat(year,month) + assert_almost_equal(dt_actual, result_scalar) + class NumpySpaTest(unittest.TestCase, SpaBase): """Import spa without compiling to numba then run tests""" @classmethod From e0f2d6cce20fae7c2afc61514ee29140a8f3eb69 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Tue, 27 Sep 2016 11:50:15 -0600 Subject: [PATCH 03/14] removed a space --- pvlib/spa.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pvlib/spa.py b/pvlib/spa.py index d95bf3f347..db031b485c 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1301,8 +1301,8 @@ def earthsun_distance(unixtime, delta_t, numthreads): def calculate_deltat(year, month): - plw = 'Delta is unknown for years before -1999 and after 3000.'\ - +' DeltaT values will be calculated, but the calculations'\ + plw = 'Delta is unknown for years before -1999 and after 3000.'\ + +' Delta values will be calculated, but the calculations'\ +' are not intended to be used for these years.' try: From 004107b17126c371959c059bef69ea07977509cc Mon Sep 17 00:00:00 2001 From: VolkrB Date: Tue, 27 Sep 2016 11:51:49 -0600 Subject: [PATCH 04/14] typo --- pvlib/spa.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pvlib/spa.py b/pvlib/spa.py index db031b485c..8434dddf78 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1301,7 +1301,7 @@ def earthsun_distance(unixtime, delta_t, numthreads): def calculate_deltat(year, month): - plw = 'Delta is unknown for years before -1999 and after 3000.'\ + plw = ' Deltat is unknown for years before -1999 and after 3000.'\ +' Delta values will be calculated, but the calculations'\ +' are not intended to be used for these years.' From 5e6c8f3e897b7afd7b0e0f396f297f2da7f7081b Mon Sep 17 00:00:00 2001 From: VolkrB Date: Tue, 27 Sep 2016 11:56:28 -0600 Subject: [PATCH 05/14] another typo --- pvlib/spa.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pvlib/spa.py b/pvlib/spa.py index 8434dddf78..812283805e 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1306,10 +1306,10 @@ def calculate_deltat(year, month): +' are not intended to be used for these years.' try: - if np.any((year > 3000) | (year < -500)): + if np.any((year > 3000) | (year < -1999)): pvl_logger.warning(plw) except ValueError: - if (year > 3000) | (year < -500): + if (year > 3000) | (year < -1999): pvl_logger.warning(plw) #Equations taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html From 5af1bd1f419a6f1ab1e1dfa59792b7c9e36bb461 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Wed, 28 Sep 2016 09:35:08 -0600 Subject: [PATCH 06/14] added recursive deltat for clarity --- pvlib/spa.py | 59 ++++++++++++++++++++++++++-------------------------- 1 file changed, 30 insertions(+), 29 deletions(-) diff --git a/pvlib/spa.py b/pvlib/spa.py index 812283805e..ce744e691e 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1318,71 +1318,72 @@ def calculate_deltat(year, month): deltat = np.where(year < -500, - -20+32*((y-1820)/100)**2, + -20+32*((y-1820)/100)**2, 0) - np.where((-500 <= year) & (year < 500), + deltat = np.where((-500 <= year) & (year < 500), 10583.6-1014.41*(y/100)+33.78311*(y/100)**2-5.952053*(y/100)**3- \ - 0.1798452*(y/100)**4+0.022174192*(y/100)**5+0.0090316521*(y/100)**6, + 0.1798452*(y/100)**4+0.022174192*(y/100)**5+0.0090316521*(y/100)**6, deltat) - np.where((500 <= year) & (year < 1600), + deltat = np.where((500 <= year) & (year < 1600), 1574.2-556.01*((y-1000)/100)+71.23472*((y-1000)/100)**2+ \ 0.319781*((y-1000)/100)**3-0.8503463 *((y-1000)/100)**4- \ - 0.005050998*((y-1000)/100)**5+0.0083572073*((y-1000)/100)**6, + 0.005050998*((y-1000)/100)**5+0.0083572073*((y-1000)/100)**6, deltat) - np.where((1600 <= year) & (year < 1700), + deltat = np.where((1600 <= year) & (year < 1700), - 120-0.9808*(y-1600)-0.01532*(y-1600)**2+(y-1600)**3/7129, + 120-0.9808*(y-1600)-0.01532*(y-1600)**2+(y-1600)**3/7129, deltat) - np.where((1700 <= year) & (year < 1800), + deltat = np.where((1700 <= year) & (year < 1800), 8.83+0.1603*(y-1700)-0.0059285*(y-1700)**2+0.00013336*(y-1700)**3- \ - (y-1700)**4/1174000, + (y-1700)**4/1174000, deltat) - np.where((1800 <= year) & (year < 1860), + deltat = np.where((1800 <= year) & (year < 1860), 13.72-0.332447*(y-1800)+0.0068612*(y-1800)**2+0.0041116*(y-1800)**3- \ 0.00037436*(y-1800)**4+0.0000121272*(y-1800)**5-0.0000001699*(y-1800)**6+ \ - 0.000000000875*(y-1800)**7, + 0.000000000875*(y-1800)**7, deltat) - np.where((1860 <= year) & (year < 1900), + deltat = np.where((1860 <= year) & (year < 1900), 7.6+0.5737*(y-1860)-0.251754*(y-1860)**2+0.01680668*(y-1860)**3- \ - 0.0004473624*(y-1860)**4+(y-1860)**5/233174, + 0.0004473624*(y-1860)**4+(y-1860)**5/233174, deltat) - np.where((1900 <= year) & (year < 1920), + deltat = np.where((1900 <= year) & (year < 1920), -2.79+1.494119*(y-1900)-0.0598939*(y-1900)**2+0.0061966*(y-1900)**3- \ - 0.000197*(y-1900)**4, + 0.000197*(y-1900)**4, deltat) - np.where(( 1920 <= year) & (year < 1941), + deltat = np.where(( 1920 <= year) & (year < 1941), - 21.20+0.84493*(y-1920)-0.076100*(y-1920)**2+0.0020936*(y-1920)**3, + 21.20+0.84493*(y-1920)-0.076100*(y-1920)**2+0.0020936*(y-1920)**3, deltat) - np.where((1941 <= year) & (year < 1961), + deltat = np.where((1941 <= year) & (year < 1961), - 29.07+0.407*(y-1950)-(y-1950)**2/233+(y-1950)**3/2547, + 29.07+0.407*(y-1950)-(y-1950)**2/233+(y-1950)**3/2547, deltat) - np.where((1961 <= year) & (year < 1986), + deltat = np.where((1961 <= year) & (year < 1986), - 45.45+1.067*(y-1975)-(y-1975)**2/260-(y-1975)**3/718, + 45.45+1.067*(y-1975)-(y-1975)**2/260-(y-1975)**3/718, deltat) - np.where((1986 <= year) & (year < 2005), + deltat = np.where((1986 <= year) & (year < 2005), 63.86+0.3345*(y-2000)-0.060374*(y-2000)**2+0.0017275*(y-2000)**3+ \ - 0.000651814*(y-2000)**4+0.00002373599*(y-2000)**5, + 0.000651814*(y-2000)**4+0.00002373599*(y-2000)**5, deltat) - np.where((2005 <= year) & (year < 2050), + deltat = np.where((2005 <= year) & (year < 2050), - 62.92+0.32217*(y-2000)+0.005589*(y-2000)**2, + 62.92+0.32217*(y-2000)+0.005589*(y-2000)**2, deltat) - np.where((2050 <= year) & (year < 2150), + deltat = np.where((2050 <= year) & (year < 2150), - -20+32*((y-1820)/100)**2-0.5628*(2150-y), - np.where( year > 2150, + -20+32*((y-1820)/100)**2-0.5628*(2150-y), deltat) + + deltat = np.where( year > 2150, - -20+32*((y-1820)/100)**2, 0))))))))))))))) + -20+32*((y-1820)/100)**2, deltat) deltat = np.asscalar(deltat) if np.isscalar(year) & np.isscalar(month) else deltat From 970b9761145444196aa12b658f39be62f3c2fc4f Mon Sep 17 00:00:00 2001 From: VolkrB Date: Mon, 3 Oct 2016 16:28:09 -0600 Subject: [PATCH 07/14] Added delta_t,format,1test --- pvlib/solarposition.py | 19 +++++- pvlib/spa.py | 105 ++++++++++++++++++++----------- pvlib/test/test_solarposition.py | 10 +++ 3 files changed, 95 insertions(+), 39 deletions(-) diff --git a/pvlib/solarposition.py b/pvlib/solarposition.py index eb3568a3f8..27d923b8b3 100644 --- a/pvlib/solarposition.py +++ b/pvlib/solarposition.py @@ -261,6 +261,9 @@ def spa_python(time, latitude, longitude, temperature : int or float, optional avg. yearly air temperature in degrees C. delta_t : float, optional + If delta_t is None, uses spa.calculate_deltat + using time.year and time.month from pandas.DatetimeIndex. + For most simulations specifing delta_t is sufficient. Difference between terrestrial time and UT1. The USNO has historical and forecasted delta_t [3]. atmos_refrac : float, optional @@ -308,7 +311,7 @@ def spa_python(time, latitude, longitude, lon = longitude elev = altitude pressure = pressure / 100 # pressure must be in millibars for calculation - delta_t = delta_t or 67.0 + atmos_refract = atmos_refract or 0.5667 if not isinstance(time, pd.DatetimeIndex): @@ -321,6 +324,8 @@ def spa_python(time, latitude, longitude, spa = _spa_python_import(how) + delta_t = delta_t or spa.calculate_deltat(time.year, time.month) + app_zenith, zenith, app_elevation, elevation, azimuth, eot = spa.solar_position( unixtime, lat, lon, elev, pressure, temperature, delta_t, atmos_refract, numthreads) @@ -353,6 +358,9 @@ def get_sun_rise_set_transit(time, latitude, longitude, how='numpy', latitude : float longitude : float delta_t : float, optional + If delta_t is None, uses spa.calculate_deltat + using time.year and time.month from pandas.DatetimeIndex. + For most simulations specifing delta_t is sufficient. Difference between terrestrial time and UT1. By default, use USNO historical data and predictions how : str, optional @@ -380,7 +388,6 @@ def get_sun_rise_set_transit(time, latitude, longitude, how='numpy', lat = latitude lon = longitude - delta_t = delta_t or 67.0 if not isinstance(time, pd.DatetimeIndex): try: @@ -394,6 +401,8 @@ def get_sun_rise_set_transit(time, latitude, longitude, how='numpy', spa = _spa_python_import(how) + delta_t = delta_t or spa.calculate_deltat(time.year, time.month) + transit, sunrise, sunset = spa.transit_sunrise_sunset( unixtime, lat, lon, delta_t, numthreads) @@ -788,6 +797,9 @@ def nrel_earthsun_distance(time, how='numpy', delta_t=None, numthreads=4): to machine code and run them multithreaded. delta_t : float, optional + If delta_t is None, uses spa.calculate_deltat + using time.year and time.month from pandas.DatetimeIndex. + For most simulations specifing delta_t is sufficient. Difference between terrestrial time and UT1. By default, use USNO historical data and predictions @@ -805,7 +817,6 @@ def nrel_earthsun_distance(time, how='numpy', delta_t=None, numthreads=4): radiation applications. Technical report: NREL/TP-560- 34302. Golden, USA, http://www.nrel.gov. """ - delta_t = delta_t or 67.0 if not isinstance(time, pd.DatetimeIndex): try: @@ -817,6 +828,8 @@ def nrel_earthsun_distance(time, how='numpy', delta_t=None, numthreads=4): spa = _spa_python_import(how) + delta_t = delta_t or spa.calculate_deltat(time.year, time.month) + R = spa.earthsun_distance(unixtime, delta_t, numthreads) R = pd.Series(R, index=time) diff --git a/pvlib/spa.py b/pvlib/spa.py index ce744e691e..048fb0fce6 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1302,8 +1302,8 @@ def earthsun_distance(unixtime, delta_t, numthreads): def calculate_deltat(year, month): plw = ' Deltat is unknown for years before -1999 and after 3000.'\ - +' Delta values will be calculated, but the calculations'\ - +' are not intended to be used for these years.' + + ' Delta values will be calculated, but the calculations'\ + + ' are not intended to be used for these years.' try: if np.any((year > 3000) | (year < -1999)): @@ -1311,81 +1311,114 @@ def calculate_deltat(year, month): except ValueError: if (year > 3000) | (year < -1999): pvl_logger.warning(plw) + except TypeError: + return 0 - #Equations taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html + # Equations taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html y = year + (month - 0.5)/12 - deltat = np.where(year < -500, - - -20+32*((y-1820)/100)**2, 0) - + deltat = np.where(year < -500, + + -20+32*((y-1820)/100)**2, 0) + deltat = np.where((-500 <= year) & (year < 500), - 10583.6-1014.41*(y/100)+33.78311*(y/100)**2-5.952053*(y/100)**3- \ - 0.1798452*(y/100)**4+0.022174192*(y/100)**5+0.0090316521*(y/100)**6, deltat) + 10583.6-1014.41*(y/100) + + 33.78311*(y/100)**2 + - 5.952053*(y/100)**3 + - 0.1798452*(y/100)**4 + + 0.022174192*(y/100)**5 + + 0.0090316521*(y/100)**6, deltat) deltat = np.where((500 <= year) & (year < 1600), - - 1574.2-556.01*((y-1000)/100)+71.23472*((y-1000)/100)**2+ \ - 0.319781*((y-1000)/100)**3-0.8503463 *((y-1000)/100)**4- \ - 0.005050998*((y-1000)/100)**5+0.0083572073*((y-1000)/100)**6, deltat) + + 1574.2-556.01*((y-1000)/100) + + 71.23472*((y-1000)/100)**2 + + 0.319781*((y-1000)/100)**3 + - 0.8503463*((y-1000)/100)**4 + - 0.005050998*((y-1000)/100)**5 + + 0.0083572073*((y-1000)/100)**6, deltat) deltat = np.where((1600 <= year) & (year < 1700), - 120-0.9808*(y-1600)-0.01532*(y-1600)**2+(y-1600)**3/7129, deltat) + 120-0.9808*(y-1600) + - 0.01532*(y-1600)**2 + + (y-1600)**3/7129, deltat) deltat = np.where((1700 <= year) & (year < 1800), - 8.83+0.1603*(y-1700)-0.0059285*(y-1700)**2+0.00013336*(y-1700)**3- \ - (y-1700)**4/1174000, deltat) + 8.83+0.1603*(y-1700) + - 0.0059285*(y-1700)**2 + + 0.00013336*(y-1700)**3 + - (y-1700)**4/1174000, deltat) deltat = np.where((1800 <= year) & (year < 1860), - 13.72-0.332447*(y-1800)+0.0068612*(y-1800)**2+0.0041116*(y-1800)**3- \ - 0.00037436*(y-1800)**4+0.0000121272*(y-1800)**5-0.0000001699*(y-1800)**6+ \ - 0.000000000875*(y-1800)**7, deltat) + 13.72-0.332447*(y-1800) + + 0.0068612*(y-1800)**2 + + 0.0041116*(y-1800)**3 + - 0.00037436*(y-1800)**4 + + 0.0000121272*(y-1800)**5 + - 0.0000001699*(y-1800)**6 + + 0.000000000875*(y-1800)**7, deltat) deltat = np.where((1860 <= year) & (year < 1900), - 7.6+0.5737*(y-1860)-0.251754*(y-1860)**2+0.01680668*(y-1860)**3- \ - 0.0004473624*(y-1860)**4+(y-1860)**5/233174, deltat) + 7.6+0.5737*(y-1860) + - 0.251754*(y-1860)**2 + + 0.01680668*(y-1860)**3 + - 0.0004473624*(y-1860)**4 + + (y-1860)**5/233174, deltat) deltat = np.where((1900 <= year) & (year < 1920), - -2.79+1.494119*(y-1900)-0.0598939*(y-1900)**2+0.0061966*(y-1900)**3- \ - 0.000197*(y-1900)**4, deltat) + -2.79+1.494119*(y-1900) + - 0.0598939*(y-1900)**2 + + 0.0061966*(y-1900)**3 + - 0.000197*(y-1900)**4, deltat) - deltat = np.where(( 1920 <= year) & (year < 1941), + deltat = np.where((1920 <= year) & (year < 1941), - 21.20+0.84493*(y-1920)-0.076100*(y-1920)**2+0.0020936*(y-1920)**3, deltat) + 21.20+0.84493*(y-1920) + - 0.076100*(y-1920)**2 + + 0.0020936*(y-1920)**3, deltat) deltat = np.where((1941 <= year) & (year < 1961), - 29.07+0.407*(y-1950)-(y-1950)**2/233+(y-1950)**3/2547, deltat) + 29.07+0.407*(y-1950) + - (y-1950)**2/233 + + (y-1950)**3/2547, deltat) deltat = np.where((1961 <= year) & (year < 1986), - 45.45+1.067*(y-1975)-(y-1975)**2/260-(y-1975)**3/718, deltat) + 45.45+1.067*(y-1975) + - (y-1975)**2/260 + - (y-1975)**3/718, deltat) deltat = np.where((1986 <= year) & (year < 2005), - 63.86+0.3345*(y-2000)-0.060374*(y-2000)**2+0.0017275*(y-2000)**3+ \ - 0.000651814*(y-2000)**4+0.00002373599*(y-2000)**5, deltat) + 63.86+0.3345*(y-2000) + - 0.060374*(y-2000)**2 + + 0.0017275*(y-2000)**3 + + 0.000651814*(y-2000)**4 + + 0.00002373599*(y-2000)**5, deltat) deltat = np.where((2005 <= year) & (year < 2050), - 62.92+0.32217*(y-2000)+0.005589*(y-2000)**2, deltat) + 62.92+0.32217*(y-2000) + + 0.005589*(y-2000)**2, deltat) deltat = np.where((2050 <= year) & (year < 2150), - -20+32*((y-1820)/100)**2-0.5628*(2150-y), deltat) - - deltat = np.where( year > 2150, + -20+32*((y-1820)/100)**2 + - 0.5628*(2150-y), deltat) - -20+32*((y-1820)/100)**2, deltat) + deltat = np.where(year > 2150, - deltat = np.asscalar(deltat) if np.isscalar(year) & np.isscalar(month) else deltat + -20+32*((y-1820)/100)**2, deltat) - return deltat + deltat = np.asscalar(deltat) if np.isscalar(year) & np.isscalar(month)\ + else deltat + return deltat diff --git a/pvlib/test/test_solarposition.py b/pvlib/test/test_solarposition.py index af39e77332..b22d99f14f 100644 --- a/pvlib/test/test_solarposition.py +++ b/pvlib/test/test_solarposition.py @@ -76,6 +76,16 @@ def test_spa_python_numpy_physical(expected_solpos): expected_solpos.index = times assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns]) + times = pd.date_range(datetime.datetime(2003,10,17,12,30,30), + periods=1, freq='D', tz=golden_mst.tz) + 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') + expected_solpos.index = times + assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns]) def test_spa_python_numpy_physical_dst(expected_solpos): times = pd.date_range(datetime.datetime(2003,10,17,13,30,30), From bad54779f815c5fa9675511e18cbf4ab77214a61 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Mon, 3 Oct 2016 16:29:21 -0600 Subject: [PATCH 08/14] typo --- pvlib/test/test_solarposition.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pvlib/test/test_solarposition.py b/pvlib/test/test_solarposition.py index b22d99f14f..bea67a4ad9 100644 --- a/pvlib/test/test_solarposition.py +++ b/pvlib/test/test_solarposition.py @@ -81,7 +81,7 @@ def test_spa_python_numpy_physical(expected_solpos): ephem_data = solarposition.spa_python(times, golden_mst.latitude, golden_mst.longitude, pressure=82000, - temperature=11, delta_t=67, + temperature=11, atmos_refract=0.5667, how='numpy') expected_solpos.index = times From 5131a1adc5f02d71596f65d22d0d88a983cf5233 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Tue, 11 Oct 2016 11:40:36 -0600 Subject: [PATCH 09/14] added deltat solarposition test --- pvlib/test/test_solarposition.py | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/pvlib/test/test_solarposition.py b/pvlib/test/test_solarposition.py index bea67a4ad9..3e9707694c 100644 --- a/pvlib/test/test_solarposition.py +++ b/pvlib/test/test_solarposition.py @@ -63,7 +63,6 @@ def test_spa_c_physical_dst(expected_solpos): expected_solpos.index = times assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns]) - def test_spa_python_numpy_physical(expected_solpos): times = pd.date_range(datetime.datetime(2003,10,17,12,30,30), periods=1, freq='D', tz=golden_mst.tz) @@ -76,17 +75,6 @@ def test_spa_python_numpy_physical(expected_solpos): expected_solpos.index = times assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns]) - times = pd.date_range(datetime.datetime(2003,10,17,12,30,30), - periods=1, freq='D', tz=golden_mst.tz) - ephem_data = solarposition.spa_python(times, golden_mst.latitude, - golden_mst.longitude, - pressure=82000, - temperature=11, - atmos_refract=0.5667, - how='numpy') - expected_solpos.index = times - assert_frame_equal(expected_solpos, ephem_data[expected_solpos.columns]) - def test_spa_python_numpy_physical_dst(expected_solpos): times = pd.date_range(datetime.datetime(2003,10,17,13,30,30), periods=1, freq='D', tz=golden.tz) @@ -322,6 +310,26 @@ def test_get_solarposition_altitude(altitude, expected): assert_frame_equal(this_expected, ephem_data[this_expected.columns]) +@pytest.mark.parametrize( + "delta_t, expected", [ + (None, expected_solpos()), + (67.0, expected_solpos()) + ]) +def test_get_solarposition_deltat(delta_t,expected): + 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, + pressure=82000, + delta_t=delta_t, + temperature=11) + this_expected = expected.copy() + this_expected.index = times + this_expected = np.round(this_expected, 5) + ephem_data = np.round(ephem_data, 5) + assert_frame_equal(this_expected, ephem_data[this_expected.columns]) + + def test_get_solarposition_no_kwargs(expected_solpos): times = pd.date_range(datetime.datetime(2003,10,17,13,30,30), periods=1, freq='D', tz=golden.tz) From aeae799a0e88d5e4ae7f2d3edfc3756a8586df36 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Fri, 14 Oct 2016 16:21:33 -0600 Subject: [PATCH 10/14] added atol=1e-4 to several tests --- pvlib/test/test_irradiance.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pvlib/test/test_irradiance.py b/pvlib/test/test_irradiance.py index 573ae40f57..83750cb6e2 100644 --- a/pvlib/test/test_irradiance.py +++ b/pvlib/test/test_irradiance.py @@ -98,7 +98,7 @@ def test_grounddiffuse_albedo_invalid_surface(): def test_grounddiffuse_albedo_surface(): result = irradiance.grounddiffuse(40, ghi, surface_type='sand') - assert_allclose(result, [0, 3.731058, 48.778813, 12.035025]) + assert_allclose(result, [0, 3.731058, 48.778813, 12.035025], atol=1e-4) def test_isotropic_float(): @@ -108,7 +108,7 @@ def test_isotropic_float(): def test_isotropic_series(): result = irradiance.isotropic(40, irrad_data['dhi']) - assert_allclose(result, [0, 35.728402, 104.601328, 54.777191]) + assert_allclose(result, [0, 35.728402, 104.601328, 54.777191], atol=1e-4) def test_klucher_series_float(): @@ -120,7 +120,7 @@ def test_klucher_series(): result = irradiance.klucher(40, 180, irrad_data['dhi'], irrad_data['ghi'], ephem_data['apparent_zenith'], ephem_data['azimuth']) - assert_allclose(result, [0, 37.446276, 109.209347, 56.965916]) + assert_allclose(result, [0, 37.446276, 109.209347, 56.965916], atol=1e-4) def test_haydavies(): @@ -128,7 +128,7 @@ def test_haydavies(): dni_et, ephem_data['apparent_zenith'], ephem_data['azimuth']) - assert_allclose(result, [0, 14.967008, 102.994862, 33.190865]) + assert_allclose(result, [0, 14.967008, 102.994862, 33.190865], atol=1e-4) def test_reindl(): @@ -136,13 +136,13 @@ def test_reindl(): irrad_data['ghi'], dni_et, ephem_data['apparent_zenith'], ephem_data['azimuth']) - assert_allclose(result, [np.nan, 15.730664, 104.131724, 34.166258]) + assert_allclose(result, [np.nan, 15.730664, 104.131724, 34.166258], atol=1e-4) def test_king(): result = irradiance.king(40, irrad_data['dhi'], irrad_data['ghi'], ephem_data['apparent_zenith']) - assert_allclose(result, [0, 44.629352, 115.182626, 79.719855]) + assert_allclose(result, [0, 44.629352, 115.182626, 79.719855], atol=1e-4) def test_perez(): From d8cd47b39a2a0c19d783b22a4e2f0862ad841203 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Tue, 18 Oct 2016 15:21:13 -0600 Subject: [PATCH 11/14] Added some docstrings to spa module. Added xfail. --- pvlib/spa.py | 13 +++++++++++-- pvlib/test/test_irradiance.py | 1 + 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/pvlib/spa.py b/pvlib/spa.py index 048fb0fce6..9a1b59b0e0 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1109,6 +1109,9 @@ def solar_position(unixtime, lat, lon, elev, pressure, temp, delta_t, avg. yearly temperature at location in degrees C; used for atmospheric correction delta_t : float, optional + If delta_t is None, uses spa.calculate_deltat + using time.year and time.month from pandas.DatetimeIndex. + For most simulations specifing delta_t is sufficient. Difference between terrestrial time and UT1. By default, use USNO historical data and predictions atmos_refrac : float, optional @@ -1300,6 +1303,14 @@ def earthsun_distance(unixtime, delta_t, numthreads): def calculate_deltat(year, month): + """Calculate the difference between Terrestrial Dynamical Time (TD) + and Universal Time (UT). + + Note: This function is not yet compatible for calculations using + Numba. + + Equations taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html + """ plw = ' Deltat is unknown for years before -1999 and after 3000.'\ + ' Delta values will be calculated, but the calculations'\ @@ -1314,8 +1325,6 @@ def calculate_deltat(year, month): except TypeError: return 0 - # Equations taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html - y = year + (month - 0.5)/12 deltat = np.where(year < -500, diff --git a/pvlib/test/test_irradiance.py b/pvlib/test/test_irradiance.py index 83750cb6e2..5649cfcf23 100644 --- a/pvlib/test/test_irradiance.py +++ b/pvlib/test/test_irradiance.py @@ -61,6 +61,7 @@ def test_extraradiation(input, expected, method): @requires_numba +@pytest.mark.xfail(raises=ValueError, reason = 'spa.calculate_deltat not implemented for numba yet') def test_extraradiation_nrel_numba(): result = irradiance.extraradiation(times, method='nrel', how='numba', numthreads=8) assert_allclose(result, [1322.332316, 1322.296282, 1322.261205, 1322.227091]) From 92abe833a06a3e7788f781432e566669d9740af5 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Thu, 20 Oct 2016 11:33:08 -0600 Subject: [PATCH 12/14] Set delta_t=67 in solarposition.py, docstrings --- docs/sphinx/source/whatsnew/v0.4.2.txt | 4 +++- pvlib/solarposition.py | 12 +++++++++--- pvlib/spa.py | 2 ++ 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/docs/sphinx/source/whatsnew/v0.4.2.txt b/docs/sphinx/source/whatsnew/v0.4.2.txt index 9569a42db8..c27fd9b70f 100644 --- a/docs/sphinx/source/whatsnew/v0.4.2.txt +++ b/docs/sphinx/source/whatsnew/v0.4.2.txt @@ -16,15 +16,17 @@ API Changes ~~~~~~~~~~~ * The run_model method of the ModelChain will use the weather parameter of all weather data instead of splitting it to irradiation and weather. The irradiation parameter still works but will be removed soon.(:issue:`239`) +* delta_t kwarg is now 67.0 instead of None. IMPORTANT: Setting delta_t as None will break the code for Numba calculation. This will be fixed in a future version. (:issue:`165`) Enhancements ~~~~~~~~~~~~ * Adding a complete_irradiance method to the ModelChain to make it possible to calculate missing irradiation data from the existing columns [beta] (:issue:`239`) - +* Added calculate_deltat method to the spa module to calculate the time difference between terrestrial time and UT1. Specfiying a scalar is sufficient for most calculations. (:issue:`165`) Code Contributors ~~~~~~~~~~~~~~~~~ * Uwe Krien +* Volker Beutner diff --git a/pvlib/solarposition.py b/pvlib/solarposition.py index 406aa6d117..276a469650 100644 --- a/pvlib/solarposition.py +++ b/pvlib/solarposition.py @@ -238,7 +238,7 @@ def _spa_python_import(how): def spa_python(time, latitude, longitude, - altitude=0, pressure=101325, temperature=12, delta_t=None, + altitude=0, pressure=101325, temperature=12, delta_t=67.0, atmos_refract=None, how='numpy', numthreads=4, **kwargs): """ Calculate the solar position using a python implementation of the @@ -265,6 +265,8 @@ def spa_python(time, latitude, longitude, using time.year and time.month from pandas.DatetimeIndex. For most simulations specifing delta_t is sufficient. Difference between terrestrial time and UT1. + *Note: delta_t = None will break code using nrel_numba, + this will be fixed in a future version. The USNO has historical and forecasted delta_t [3]. atmos_refrac : float, optional The approximate atmospheric refraction (in degrees) @@ -340,7 +342,7 @@ def spa_python(time, latitude, longitude, def get_sun_rise_set_transit(time, latitude, longitude, how='numpy', - delta_t=None, + delta_t=67.0, numthreads=4): """ Calculate the sunrise, sunset, and sun transit times using the @@ -362,6 +364,8 @@ def get_sun_rise_set_transit(time, latitude, longitude, how='numpy', using time.year and time.month from pandas.DatetimeIndex. For most simulations specifing delta_t is sufficient. Difference between terrestrial time and UT1. + *Note: delta_t = None will break code using nrel_numba, + this will be fixed in a future version. By default, use USNO historical data and predictions how : str, optional Options are 'numpy' or 'numba'. If numba >= 0.17.0 @@ -782,7 +786,7 @@ def pyephem_earthsun_distance(time): return pd.Series(earthsun, index=time) -def nrel_earthsun_distance(time, how='numpy', delta_t=None, numthreads=4): +def nrel_earthsun_distance(time, how='numpy', delta_t=67.0, numthreads=4): """ Calculates the distance from the earth to the sun using the NREL SPA algorithm described in [1]. @@ -801,6 +805,8 @@ def nrel_earthsun_distance(time, how='numpy', delta_t=None, numthreads=4): using time.year and time.month from pandas.DatetimeIndex. For most simulations specifing delta_t is sufficient. Difference between terrestrial time and UT1. + *Note: delta_t = None will break code using nrel_numba, + this will be fixed in a future version. By default, use USNO historical data and predictions numthreads : int, optional diff --git a/pvlib/spa.py b/pvlib/spa.py index 9a1b59b0e0..770ad110e8 100644 --- a/pvlib/spa.py +++ b/pvlib/spa.py @@ -1113,6 +1113,8 @@ def solar_position(unixtime, lat, lon, elev, pressure, temp, delta_t, using time.year and time.month from pandas.DatetimeIndex. For most simulations specifing delta_t is sufficient. Difference between terrestrial time and UT1. + *Note: delta_t = None will break code using nrel_numba, + this will be fixed in a future version. By default, use USNO historical data and predictions atmos_refrac : float, optional The approximate atmospheric refraction (in degrees) From 364d7be8aac5622b76354a4f90f38a5b29a00834 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Thu, 20 Oct 2016 14:23:40 -0600 Subject: [PATCH 13/14] rm/add xfail, added test fixture in solarpos, typo --- docs/sphinx/source/whatsnew/v0.4.2.txt | 2 +- pvlib/test/test_irradiance.py | 1 - pvlib/test/test_solarposition.py | 24 ++++++++++++++++++------ 3 files changed, 19 insertions(+), 8 deletions(-) diff --git a/docs/sphinx/source/whatsnew/v0.4.2.txt b/docs/sphinx/source/whatsnew/v0.4.2.txt index c27fd9b70f..0b12a564ed 100644 --- a/docs/sphinx/source/whatsnew/v0.4.2.txt +++ b/docs/sphinx/source/whatsnew/v0.4.2.txt @@ -23,7 +23,7 @@ Enhancements ~~~~~~~~~~~~ * Adding a complete_irradiance method to the ModelChain to make it possible to calculate missing irradiation data from the existing columns [beta] (:issue:`239`) -* Added calculate_deltat method to the spa module to calculate the time difference between terrestrial time and UT1. Specfiying a scalar is sufficient for most calculations. (:issue:`165`) +* Added calculate_deltat method to the spa module to calculate the time difference between terrestrial time and UT1. Specifying a scalar is sufficient for most calculations. (:issue:`165`) Code Contributors ~~~~~~~~~~~~~~~~~ diff --git a/pvlib/test/test_irradiance.py b/pvlib/test/test_irradiance.py index 5649cfcf23..83750cb6e2 100644 --- a/pvlib/test/test_irradiance.py +++ b/pvlib/test/test_irradiance.py @@ -61,7 +61,6 @@ def test_extraradiation(input, expected, method): @requires_numba -@pytest.mark.xfail(raises=ValueError, reason = 'spa.calculate_deltat not implemented for numba yet') def test_extraradiation_nrel_numba(): result = irradiance.extraradiation(times, method='nrel', how='numba', numthreads=8) assert_allclose(result, [1322.332316, 1322.296282, 1322.261205, 1322.227091]) diff --git a/pvlib/test/test_solarposition.py b/pvlib/test/test_solarposition.py index 3e9707694c..699224a1e9 100644 --- a/pvlib/test/test_solarposition.py +++ b/pvlib/test/test_solarposition.py @@ -36,6 +36,14 @@ def expected_solpos(): 'apparent_elevation': 39.888378}, index=['2003-10-17T12:30:30Z']) +@pytest.fixture() +def expected_solpos_multi(): + return pd.DataFrame({'elevation': [39.872046, 39.505196], + 'apparent_zenith': [50.111622, 50.478260], + 'azimuth': [194.340241, 194.311132], + 'apparent_elevation': [39.888378, 39.521740]}, + index=[['2003-10-17T12:30:30Z', '2003-10-18T12:30:30Z']]) + # the physical tests are run at the same time as the NREL SPA test. # pyephem reproduces the NREL result to 2 decimal places. # this doesn't mean that one code is better than the other. @@ -310,19 +318,23 @@ def test_get_solarposition_altitude(altitude, expected): assert_frame_equal(this_expected, ephem_data[this_expected.columns]) +@pytest.mark.xfail(raises=ValueError, reason = 'spa.calculate_deltat not implemented for numba yet') @pytest.mark.parametrize( - "delta_t, expected", [ - (None, expected_solpos()), - (67.0, expected_solpos()) + "delta_t, method, expected", [ + (None, 'nrel_numpy', expected_solpos_multi()), + (67.0, 'nrel_numpy', expected_solpos_multi()), + (None, 'nrel_numba', expected_solpos_multi()), + (67.0, 'nrel_numba', expected_solpos_multi()) ]) -def test_get_solarposition_deltat(delta_t,expected): +def test_get_solarposition_deltat(delta_t, method, expected): times = pd.date_range(datetime.datetime(2003,10,17,13,30,30), - periods=1, freq='D', tz=golden.tz) + periods=2, freq='D', tz=golden.tz) ephem_data = solarposition.get_solarposition(times, golden.latitude, golden.longitude, pressure=82000, delta_t=delta_t, - temperature=11) + temperature=11, + method=method) this_expected = expected.copy() this_expected.index = times this_expected = np.round(this_expected, 5) From 83c7e4d8fb8e63bc6ba5e117f8012bf0423b1469 Mon Sep 17 00:00:00 2001 From: VolkrB Date: Thu, 20 Oct 2016 15:03:51 -0600 Subject: [PATCH 14/14] Moved xfail into parametrize decorator --- pvlib/test/test_solarposition.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pvlib/test/test_solarposition.py b/pvlib/test/test_solarposition.py index 699224a1e9..c4dc5c1200 100644 --- a/pvlib/test/test_solarposition.py +++ b/pvlib/test/test_solarposition.py @@ -318,12 +318,12 @@ def test_get_solarposition_altitude(altitude, expected): assert_frame_equal(this_expected, ephem_data[this_expected.columns]) -@pytest.mark.xfail(raises=ValueError, reason = 'spa.calculate_deltat not implemented for numba yet') @pytest.mark.parametrize( "delta_t, method, expected", [ (None, 'nrel_numpy', expected_solpos_multi()), (67.0, 'nrel_numpy', expected_solpos_multi()), - (None, 'nrel_numba', expected_solpos_multi()), + pytest.mark.xfail(raises=ValueError, reason = 'spa.calculate_deltat not implemented for numba yet') + ((None, 'nrel_numba', expected_solpos_multi())), (67.0, 'nrel_numba', expected_solpos_multi()) ]) def test_get_solarposition_deltat(delta_t, method, expected):