add timezone input to date range formula (#54)

* add tz as argument to d_daterange, fixes #29
* test uncertainty propagation
* use try-finally in tests package to close fid if find_module fails
* use Uncertainties wrapper to test propagated uncertainty in solar position calculations
* travis ci script YAML as list
* add uncertainties to requirements
* add test folder to pvpower demo

Author: mikofski

.travis.yml

@@ -7,8 +7,9 @@ before_install:
   - sudo apt-get install -y libatlas-dev liblapack-dev libblas-dev
   - sudo apt-get install -y libhdf5-serial-dev
 # command to run tests
-script: py.test
-script: python setup.py bdist_wheel
+script:
+  - py.test
+  - python setup.py bdist_wheel
 deploy:
   - provider: releases
     api_key:

carousel/tests/__init__.py

@@ -15,9 +15,11 @@
 PROJ_PATH = os.path.abspath(os.path.join(
     TESTS_DIR, '..', '..', 'examples', PROJECT
 ))
-sys.path.append(PROJ_PATH)
 
-fid, fn, info = imp.find_module(MODEL,
-                                [os.path.join(PROJ_PATH, PROJECT.lower())])
-pvpower_models = imp.load_module(MODEL, fid, fn, info)
-fid.close()
+sys.path.append(PROJ_PATH)
+try:
+    fid, fn, info = imp.find_module(MODEL,
+                                    [os.path.join(PROJ_PATH, PROJECT.lower())])
+    pvpower_models = imp.load_module(MODEL, fid, fn, info)
+finally:
+    fid.close()

carousel/tests/test_calcs.py

@@ -4,8 +4,14 @@
 
 from nose.tools import ok_, eq_
 from carousel.core.calculations import Calc
-from carousel.tests import PROJ_PATH
+from carousel.tests import PROJ_PATH, pvpower_models
 import os
+import uncertainties
+from pvlib.solarposition import get_solarposition as solpos
+import logging
+import numpy as np
+
+LOGGER = logging.getLogger(__name__)
 
 
 def test_calc_metaclass():
@@ -57,3 +63,57 @@ class CalcTest2(Calc):
     ok_(isinstance(calc_test2, Calc))
     for k, v in calc_test2.parameters.iteritems():
         eq_(calc_test1.parameters[k], v)
+
+
+def test_static_calc_unc():
+    """
+    Test uncertainty propagation in static calculations using Uncertainties.
+    """
+
+    # FIXME: this shouldn't have to run a model to test the uncertainty
+    test_model_file = os.path.join(PROJ_PATH, 'models',
+                                   'sandia_performance_model-Tuscon.json')
+    test_model = pvpower_models.SAPM(test_model_file)  # create model
+    test_model.command('start')  # start simulation
+    # get parameters from model
+    dt = test_model.outputs.reg['timestamps']  # timestamps
+    latitude = test_model.data.reg['latitude'].m  # latitude [degrees]
+    longitude = test_model.data.reg['longitude'].m  # longitude [degrees]
+    zenith = test_model.outputs.reg['solar_zenith'].m  # zenith [degrees]
+    s_ze_ze = test_model.outputs.reg.variance['solar_zenith']['solar_zenith']
+    azimuth = test_model.outputs.reg['solar_azimuth'].m  # azimuth [degrees]
+    s_az_az = test_model.outputs.reg.variance['solar_azimuth']['solar_azimuth']
+    # get uncertainties percentages in base units
+    lat_unc = test_model.data.reg.uncertainty['latitude']['latitude']
+    lat_unc = lat_unc.to_base_units().m
+    lon_unc = test_model.data.reg.uncertainty['longitude']['longitude']
+    lon_unc = lon_unc.to_base_units().m
+    # create ufloat Uncertainties from parameters
+    lat_unc = uncertainties.ufloat(latitude, np.abs(latitude * lat_unc))
+    lon_unc = uncertainties.ufloat(longitude, np.abs(longitude * lon_unc))
+    test_unc = []  # empty list to collect return values
+    for n in xrange(96):
+        # Uncertainties wrapped functions must return only scalar float
+        f_ze_unc = uncertainties.wrap(
+            lambda lat, lon: solpos(dt[n], lat, lon)['apparent_zenith'].item()
+        )
+        f_az_unc = uncertainties.wrap(
+            lambda lat, lon: solpos(dt[n], lat, lon)['azimuth'].item()
+        )
+        ze_unc, az_unc = f_ze_unc(lat_unc, lon_unc), f_az_unc(lat_unc, lon_unc)
+        LOGGER.debug(
+            '%s: ze = %g +/- %g%%, az = %g +/- %g%%', dt[n].isoformat(),
+            zenith[n], np.sqrt(s_ze_ze[n]) * 100,
+            azimuth[n], np.sqrt(s_az_az[n]) * 100
+        )
+        LOGGER.debug(
+            'Uncertainties test %2d: ze = %g +/- %g%%, az = %g +/- %g%%', n,
+            ze_unc.n, ze_unc.s / ze_unc.n * 100,
+            az_unc.n, az_unc.s / az_unc.n * 100
+        )
+        assert np.isclose(zenith[n], ze_unc.n)
+        assert np.isclose(np.sqrt(s_ze_ze[n]), ze_unc.s / ze_unc.n)
+        assert np.isclose(azimuth[n], az_unc.n)
+        assert np.isclose(np.sqrt(s_az_az[n]), az_unc.s / az_unc.n)
+        test_unc.append({'ze': ze_unc, 'az': az_unc})
+    return test_model, test_unc

examples/PVPower/calculations/irradiance.json

@@ -5,7 +5,7 @@
       "args": {
         "data": {
           "freq": "HOURLY", "dtstart": "timestamp_start",
-          "count": "timestamp_count"
+          "count": "timestamp_count", "tz": "timezone"
         }
       },
       "returns": ["timestamps"]

examples/PVPower/formulas/utils.py

@@ -8,9 +8,10 @@
 from scipy import constants as sc_const
 import itertools
 from dateutil import rrule
+import pytz
 
 
-def f_daterange(freq, *args, **kwargs):
+def f_daterange(freq, tz='UTC', *args, **kwargs):
     """
     Use ``dateutil.rrule`` to create a range of dates. The frequency must be a
     string in the following list: YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY,
@@ -22,14 +23,17 @@ def f_daterange(freq, *args, **kwargs):
 
     :param freq: One of the ``dateutil.rrule`` frequencies
     :type freq: str
+    :param tz: One of the ``pytz`` timezones, defaults to UTC
+    :type tz: str
     :param args: start date <datetime>, interval between each frequency <int>,
         max number of recurrences <int>, end date <datetime>
     :param kwargs: ``dtstart``, ``interval``, ``count``, ``until``
     :return: range of dates
     :rtype: list
     """
+    tz = pytz.timezone(tz)
     freq = getattr(rrule, freq.upper())  # get frequency enumeration from rrule
-    return list(rrule.rrule(freq, *args, **kwargs))
+    return [tz.localize(dt) for dt in rrule.rrule(freq, *args, **kwargs)]
 
 
 def f_energy(ac_power, times):

examples/PVPower/pvpower/tests/test_pvpower.py

@@ -15,10 +15,11 @@
 
 LOGGER = logging.getLogger(__name__)
 LOGGER.setLevel(logging.DEBUG)
-PST = pytz.timezone('US/Pacific')
+TZ = 'US/Pacific'
+PST = pytz.timezone(TZ)
 UTIL_FORMULAS = UtilityFormulas()
 IRRAD_FORMULAS = IrradianceFormulas()
-DTSTART = PST.localize(datetime(2007, 1, 1, 0, 0, 0))
+DTSTART = datetime(2007, 1, 1, 0, 0, 0)
 MONTHLY_ENERGY = [186000.0, 168000.0, 186000.0, 180000.0, 186000.0, 180000.0,
                   186000.0, 186000.0, 180000.0, 186000.0, 180000.0, 186000.0]
 ZENITH = [
@@ -36,9 +37,14 @@ def test_daterange():
     """
     Test date range.
     """
-    dates = UTIL_FORMULAS['f_daterange']('HOURLY', dtstart=DTSTART, count=12)
-    for hour in xrange(12):
-        assert dates[hour] == DTSTART + timedelta(hours=hour)
+    test_range = 12
+    dates = UTIL_FORMULAS['f_daterange'](
+        'HOURLY', TZ, dtstart=DTSTART, count=test_range
+    )
+    dtstart_local = PST.localize(DTSTART)
+    for hour in xrange(test_range):
+        assert dates[hour] == dtstart_local + timedelta(hours=hour)
+        assert dates[hour].tzinfo.zone == TZ
     return dates
 
 
@@ -48,7 +54,7 @@ def test_solarposition():
     """
     lat, lon = 38.0 * UREG.degrees, -122.0 * UREG.degrees
     times = UTIL_FORMULAS['f_daterange'](
-        'HOURLY', dtstart=(DTSTART + timedelta(hours=8)), count=9
+        'HOURLY', TZ, dtstart=(DTSTART + timedelta(hours=8)), count=9
     )
     cov = np.array([[0.0001, 0], [0, 0.0001]])
     solpos = IRRAD_FORMULAS['f_solpos'](times, lat, lon, __covariance__=cov)

examples/PVPower/tests/test_covariance_output_data.xlsx

@@ -13,3 +13,4 @@ uncertaintywrapper>=0.4.1
 django
 mock
 h5py
+uncertainties