Merge pull request #51 from mikofski/pvlib_updates

[Python PVLIB-0.4.0](https://github.com/pvlib/pvlib-python/releases/tag/v0.4.0) updates
* new effective irradiance, Linke turbidity lookup and other methods
* fix return units bug
* needs more testing

Author: mikofski

carousel/core/formulas.py

@@ -127,21 +127,14 @@ def import_formulas(self):
         else:
             # autodetect formulas assuming first letter is f
             formulas = {f: getattr(mod, f) for f in dir(mod) if f[:2] == 'f_'}
+        if not len(formulas):
+            for f in dir(mod):
+                mod_attr = getattr(mod, f)
+                if inspect.isfunction(mod_attr):
+                    formulas[f] = mod_attr
         return formulas
 
 
-# methods for auto detecting functions in module
-# do it using types.FunctionType
-#             import types
-#             f = {f: getattr(mod, f)
-#                  for f in mod_attr
-#                  if isinstance(getattr(mod, f), types.FunctionType)}
-# do it using inspect.isfunction()
-#             import inspect
-#             f = {f: getattr(mod, f)
-#                  for f in mod_attr if inspect.isfunction(getattr(mod, f))}
-
-
 class NumericalExpressionImporter(FormulaImporter):
     """
     Import formulas from numerical expressions using Python Numexpr.
@@ -215,48 +208,57 @@ def __init__(self):
         self.units = {}
         #: constant arguments that are not included in covariance calculation
         self.isconstant = {}
+        # sequence of formulas, don't propagate uncertainty or units
+        for f in self.formulas:
+            self.islinear[f] = True
+            self.args[f] = inspect.getargspec(self.formulas[f]).args
         formula_param = self.parameters.get('formulas')  # formulas key
+        # if formulas is a list or if it can't be iterated as a dictionary
+        # then log warning and return
         try:
-            # formula dictionary
-            for k, v in formula_param.iteritems():
-                if not v:
-                    # skip formula if attributes are null or empty
-                    continue
-                # get islinear formula attribute
-                self.islinear[k] = v.get('islinear', True)
-                # get positional arguments
-                self.args[k] = v.get('args')
-                if self.args[k] is None:
-                    # use inspect if args not specified
-                    self.args[k] = inspect.getargspec(self.formulas[k]).args
-                # get constant arguments to exclude from covariance
-                self.isconstant[k] = v.get('isconstant')
+            formula_param_generator = formula_param.iteritems()
+        except AttributeError as err:
+            LOGGER.warning('Attribute Error: %s', err.message)
+            return
+        # formula dictionary
+        for k, v in formula_param_generator:
+            if not v:
+                # skip formula if attributes are null or empty
+                continue
+            # get islinear formula attribute
+            is_linear = v.get('islinear')
+            if is_linear is not None:
+                self.islinear[k] = is_linear
+            # get positional arguments
+            f_args = v.get('args')
+            if f_args is not None:
+                self.args[k] = f_args
+            # get constant arguments to exclude from covariance
+            self.isconstant[k] = v.get('isconstant')
+            if self.isconstant[k] is not None:
+                argn = [n for n, a in enumerate(self.args[k]) if a not in
+                        self.isconstant[k]]
+                LOGGER.debug('%s arg nums: %r', k, argn)
+                self.formulas[k] = unc_wrapper_args(*argn)(self.formulas[k])
+            # get units of returns and arguments
+            self.units[k] = v.get('units')
+            if self.units[k] is not None:
+                # append units for covariance and Jacobian if all args
+                # constant and more than one return output
                 if self.isconstant[k] is not None:
-                    argn = [n for n, a in enumerate(self.args[k]) if a not in
-                            self.isconstant[k]]
-                    LOGGER.debug('%s arg nums: %r', k, argn)
-                    self.formulas[k] = unc_wrapper_args(*argn)(self.formulas[k])
-                # get units of returns and arguments
-                self.units[k] = v.get('units')
-                if self.units[k] is not None:
-                    # append units for covariance and Jacobian if all args
-                    # constant and more than one return output
-                    if self.isconstant[k] is not None:
-                        if isinstance(self.units[k][0], basestring):
-                            self.units[k][0] = [self.units[k][0]]
-                        try:
-                            self.units[k][0] += [None, None]
-                        except TypeError:
-                            self.units[k][0] += (None, None)
-                    # wrap function with Pint's unit wrapper
-                    self.formulas[k] = UREG.wraps(*self.units[k])(
-                        self.formulas[k]
-                    )
-        except TypeError:
-            # sequence of formulas, don't propagate uncertainty or units
-            for f in self.formulas:
-                self.islinear[f] = True
-                self.args[f] = inspect.getargspec(self.formulas[f]).args
+                    # check if retval units is a string or None before adding
+                    # extra units for Jacobian and covariance
+                    ret_units = self.units[k][0]
+                    if isinstance(ret_units, basestring) or ret_units is None:
+                        self.units[k][0] = [ret_units]
+                    try:
+                        self.units[k][0] += [None, None]
+                    except TypeError:
+                        self.units[k][0] += (None, None)
+                # wrap function with Pint's unit wrapper
+                self.formulas[k] = UREG.wraps(*self.units[k])(
+                    self.formulas[k]
+                )
 
     def __getitem__(self, item):
         return self.formulas[item]

examples/PVPower/calculations/irradiance.json

@@ -10,17 +10,6 @@
       },
       "returns": ["timestamps"]
     },
-    {
-      "formula": "f_clearsky",
-      "args": {
-        "data": {
-          "latitude": "latitude", "longitude": "longitude",
-          "altitude": "elevation"
-        },
-        "outputs": {"times": "timestamps"}
-      },
-      "returns": ["dni", "ghi", "dhi"]
-    },
     {
       "formula": "f_solpos",
       "args": {
@@ -59,6 +48,27 @@
       },
       "returns": ["am_abs"]
     },
+    {
+      "formula": "f_linketurbidity",
+      "args": {
+        "data": {
+          "latitude": "latitude", "longitude": "longitude"
+        },
+        "outputs": {"times": "timestamps"}
+      },
+      "returns": ["tl"]
+    },
+    {
+      "formula": "f_clearsky",
+      "args": {
+        "data": {"altitude": "elevation"},
+        "outputs": {
+          "solar_zenith": "solar_zenith", "am_abs": "am_abs", "tl": "tl",
+          "dni_extra": "extraterrestrial"
+        }
+      },
+      "returns": ["dni", "ghi", "dhi"]
+    },
     {
       "formula": "f_total_irrad",
       "args": {

examples/PVPower/calculations/performance.json

@@ -4,8 +4,12 @@
     {
       "formula": "f_aoi",
       "args": {
-        "data": {"surface_tilt": "latitude", "surface_azimuth": "surface_azimuth"},
-        "outputs": {"solar_zenith": "solar_zenith", "solar_azimuth": "solar_azimuth"}
+        "data": {
+          "surface_tilt": "latitude", "surface_azimuth": "surface_azimuth"
+        },
+        "outputs": {
+          "solar_zenith": "solar_zenith", "solar_azimuth": "solar_azimuth"
+        }
       },
       "returns": ["aoi"]
     },
@@ -17,17 +21,26 @@
       },
       "returns": ["Tcell", "Tmod"]
     },
+    {
+      "formula": "f_effective_irradiance",
+      "args": {
+        "data": {"module": "module"},
+        "outputs": {
+          "poa_direct": "poa_direct", "poa_diffuse": "poa_diffuse",
+          "am_abs": "am_abs", "aoi": "aoi"
+        }
+      },
+      "returns": ["Ee"]
+    },
     {
       "formula": "f_dc_power",
       "args": {
         "data": {"module": "module"},
         "outputs": {
-          "times": "timestamps", "poa_direct": "poa_direct",
-          "poa_diffuse": "poa_diffuse", "cell_temp": "Tcell", "am_abs":
-          "am_abs", "aoi": "aoi"
+          "effective_irradiance": "Ee", "cell_temp": "Tcell"
         }
       },
-      "returns": ["Isc", "Imp", "Voc", "Vmp", "Pmp", "Ee"]
+      "returns": ["Isc", "Imp", "Voc", "Vmp", "Pmp"]
     },
     {
       "formula": "f_ac_power",

examples/PVPower/formulas/irradiance.json

@@ -2,14 +2,22 @@
   "module": ".irradiance",
   "package": "formulas",
   "formulas": {
-    "f_clearsky": {
-      "args": ["times", "latitude", "longitude", "altitude"],
-      "units": [["W/m**2", "W/m**2", "W/m**2"], [null, "deg", "deg", "m"]],
+    "f_linketurbidity": {
+      "args": ["times", "latitude", "longitude"],
+      "units": ["dimensionless", [null, "deg", "deg"]],
       "isconstant": ["times"]
     },
+    "f_clearsky": {
+      "args": ["solar_zenith", "am_abs", "tl", "dni_extra", "altitude"],
+      "units": [
+        ["W/m**2", "W/m**2", "W/m**2"],
+        ["deg", "dimensionless", "dimensionless", "W/m**2",  "m"]
+      ],
+      "isconstant": ["dni_extra"]
+    },
     "f_solpos": {
       "args": ["times", "latitude", "longitude"],
-      "units": [["deg", "deg"], [null, "deg", "deg"]],
+      "units": [["degree", "degree"], [null, "degree", "degree"]],
       "isconstant": ["times"]
     },
     "f_dni_extra": {"args": ["times"], "units": ["W/m**2", [null]]},

examples/PVPower/formulas/irradiance.py

@@ -6,20 +6,37 @@
 
 import pvlib
 import pandas as pd
-import numpy as np
 
 
-def f_clearsky(times, latitude, longitude, altitude):
+def f_linketurbidity(times, latitude, longitude):
     times = pd.DatetimeIndex(times)
     # latitude and longitude must be scalar or else linke turbidity lookup fails
     latitude, longitude = latitude.item(), longitude.item()
-    cs = pvlib.clearsky.ineichen(times, latitude, longitude, altitude)
+    tl = pvlib.clearsky.lookup_linke_turbidity(times, latitude, longitude)
+    return tl.values.reshape(1, -1)
+
+
+def f_clearsky(solar_zenith, am_abs, tl, dni_extra, altitude):
+    cs = pvlib.clearsky.ineichen(solar_zenith, am_abs, tl, dni_extra, altitude)
     return cs['dni'].values, cs['ghi'].values, cs['dhi'].values
 
 
 def f_solpos(times, latitude, longitude):
-    times = pd.DatetimeIndex(times)
+    """
+    Calculate solar position for lat/long at times.
+
+    :param times: Python :class:`datetime.datetime` object.
+    :type times: list
+    :param latitude: latitude [degrees]
+    :type latitude: float
+    :param longitude: longitude [degrees]
+    :type longitude: float
+    :returns: apparent zenith, azimuth
+    """
+    # pvlib converts Python datetime objects to pandas DatetimeIndex
     solpos = pvlib.solarposition.get_solarposition(times, latitude, longitude)
+    # solpos is a pandas DataFrame, so unpack the desired values
+    # return shape is (2, NOBS), so unc_wrapper sees 2 dependent variables
     return solpos['apparent_zenith'].values, solpos['azimuth'].values
 
 

examples/PVPower/formulas/performance.json

@@ -8,14 +8,17 @@
     },
     "f_dc_power": {
       "args": [
-        "times", "module", "poa_direct", "poa_diffuse", "cell_temp", "am_abs",
-        "aoi"
+        "effective_irradiance", "cell_temp", "module"
       ],
       "units": [
-        ["A", "A", "V", "V", "W", "suns"],
-        [null, null, "W/m**2", "W/m**2", "degC", "dimensionless", "deg"]
+        ["A", "A", "V", "V", "W"],
+        ["suns", "degC", null]
       ]
     },
+    "f_effective_irradiance": {
+      "args": ["poa_direct", "poa_diffuse", "am_abs", "aoi", "module"],
+      "units": ["suns", ["W/m**2", "W/m**2", "dimensionless", "deg", null]]
+    },
     "f_cell_temp": {
       "args": ["poa_global", "wind_speed", "air_temp"],
       "units": [["degC", "degC"], ["W/m**2", "m/s", "degC"]]

examples/PVPower/formulas/performance.py

@@ -5,7 +5,6 @@
 """
 
 import pvlib
-import pandas as pd
 
 
 def f_ac_power(inverter, v_mp, p_mp):
@@ -17,34 +16,37 @@ def f_ac_power(inverter, v_mp, p_mp):
     :param p_mp:
     :return: AC power [W]
     """
-    return pvlib.pvsystem.snlinverter(inverter, v_mp, p_mp).values
+    return pvlib.pvsystem.snlinverter(v_mp, p_mp, inverter).flatten()
 
 
-def f_dc_power(times, module, poa_direct, poa_diffuse, cell_temp, am_abs, aoi):
+def f_dc_power(effective_irradiance, cell_temp, module):
     """
-    Calculate DC power
+    Calculate DC power using Sandia Performance model
 
-    :param times: timestamps
+    :param effective_irradiance: effective irradiance [suns]
+    :param cell_temp: PV cell temperature [degC]
     :param module: PV module dictionary or pandas data frame
+    :returns: i_sc, i_mp, v_oc, v_mp, p_mp
+    """
+    dc = pvlib.pvsystem.sapm(effective_irradiance, cell_temp, module)
+    fields = ('i_sc', 'i_mp', 'v_oc', 'v_mp', 'p_mp')
+    return tuple(dc[field] for field in fields)
+
+
+def f_effective_irradiance(poa_direct, poa_diffuse, am_abs, aoi, module):
+    """
+    Calculate effective irradiance for Sandia Performance model
+
     :param poa_direct: plane of array direct irradiance [W/m**2]
     :param poa_diffuse: plane of array diffuse irradiance [W/m**2]
-    :param cell_temp: PV cell temperature [degC]
     :param am_abs: absolute air mass [dimensionless]
     :param aoi: angle of incidence [degrees]
-    :return: short circuit current (Isc) [A], max. power current (Imp) [A],
-        open circuit voltage (Voc) [V], max. power voltage (Vmp) [V],
-        max. power (Pmp) [W], effective irradiance (Ee) [suns]
+    :param module: PV module dictionary or pandas data frame
+    :return: effective irradiance (Ee) [suns]
     """
-    poa_direct = pd.Series(poa_direct, index=times)
-    poa_diffuse = pd.Series(poa_diffuse, index=times)
-    cell_temp = pd.Series(cell_temp, index=times)
-    am_abs = pd.Series(am_abs, index=times)
-    aoi = pd.Series(aoi, index=times)
-    dc = pvlib.pvsystem.sapm(
-        module, poa_direct, poa_diffuse, cell_temp, am_abs, aoi
-    )
-    fields = ('i_sc', 'i_mp', 'v_oc', 'v_mp', 'p_mp', 'effective_irradiance')
-    return tuple(dc[field].values for field in fields)
+    Ee = pvlib.pvsystem.sapm_effective_irradiance(poa_direct, poa_diffuse,
+                                                  am_abs, aoi, module)
+    return Ee.reshape(1, -1)
 
 
 def f_cell_temp(poa_global, wind_speed, air_temp):

examples/PVPower/outputs/irradiance.json

@@ -1,4 +1,8 @@
 {
+  "tl": {
+    "isconstant": true, "timeseries": "timestamps", "units": "dimensionless",
+    "size": 8761
+  },
   "poa_global": {
     "isconstant": true, "timeseries": "timestamps", "units": "W/m**2",
     "size": 8761

examples/PVPower/pvpower/sandia_perfmod_newstyle.py

@@ -1,3 +1,7 @@
 """
 Tests for pvpower demo
 """
+from pvpower import PROJ_PATH
+import os
+
+MODEL_PATH = os.path.join(PROJ_PATH, 'models')