convert get_airmassabsolute to get_airmass. add a bunch of failing stub tests

Author: wholmgren

docs/sphinx/source/package_overview.rst

@@ -202,12 +202,12 @@ object to accomplish our modeling goal:
                                                wind_speed, temp_air)
         aoi = localized_system.get_aoi(solar_position['apparent_zenith'],
                                        solar_position['azimuth'])
-        am_rel = pvlib.atmosphere.relativeairmass(solar_position['apparent_zenith'])
-        am_abs = localized_system.get_absoluteairmass(am_rel)
+        airmass = localized_system.get_airmass(solar_position=solar_position)
         dc = localized_system.sapm(total_irrad['poa_direct'],
                                    total_irrad['poa_diffuse'],
                                    temps['temp_cell'],
-                                   am_abs, aoi)
+                                   airmass['airmass_absolute'],
+                                   aoi)
         ac = localized_system.snlinverter(dc['v_mp'], dc['p_mp'])
         annual_energy = ac.sum()
         energies[name] = annual_energy

pvlib/location.py

@@ -191,13 +191,55 @@ def get_clearsky(self, times, model='ineichen', **kwargs):
             raise ValueError('%s is not a valid clear sky model', model)
 
         return cs
+    
+    
+    def get_airmass(self, times=None, solar_position=None,
+                    model='kastenyoung1998'):
+        """
+        Calculate the relative and absolute airmass.
+        
+        Function will calculate the solar zenith and apparent zenith angles,
+        and choose the appropriate one.
+        
+        Parameters
+        ----------
+        times : None or DatetimeIndex
+            Only used if solar_position is not provided.
+        solar_position : None or DataFrame
+            DataFrame with with columns 'apparent_zenith', 'zenith'.
+        model : str
+            Relative airmass model
+        
+        Returns
+        -------
+        airmass : DataFrame
+            Columns are 'airmass_relative', 'airmass_absolute'
+        """
 
+        if solar_position is None:
+            solar_position = self.get_solarposition(times)
+
+        apparents = ['simple', 'kasten1966', 'kastenyoung1989',
+                     'gueymard1993', 'pickering2002']
+
+        trues = ['youngirvine1967', 'young1994']
+
+        if model in apparents:
+            zenith = solar_position['apparent_zenith']
+        elif model in trues:
+            zenith = solar_position['zenith']
+        else
+            raise ValueError('invalid model %s', model)
+
+        airmass_relative = atmosphere.relativeairmass(zenith, model)
 
-    def get_absoluteairmass(self, airmass_relative):
-        
         pressure = atmosphere.alt2pres(self.altitude)
-        am = atmosphere.absoluteairmass(airmass_relative, pressure)
-        
-        return am
+        airmass_absolute = atmosphere.absoluteairmass(airmass_relative,
+                                                      pressure)
+
+        airmass = pd.DataFrame()
+        airmass['airmass_relative'] = airmass_relative
+        airmass['airmass_absolute'] = airmass_absolute
 
+        return airmass
 

pvlib/modelchain.py

@@ -2,8 +2,6 @@
 Stub documentation for the module.
 """
 
-from pvlib import atmosphere
-
 class ModelChain(object):
     """
     A class that represents all of the modeling steps necessary for
@@ -108,40 +106,42 @@ def run_model(self, times=None, irradiance=None, weather=None):
         """
         solar_position = self.location.get_solarposition(times)
 
+        airmass = self.location.get_airmass(solar_position=solar_position,
+                                            model=self.airmass_model)
+
         if irradiance is None:
             irradiance = self.location.get_clearsky(solar_position.index,
-                                                    self.clearsky_model)
+                                                    self.clearsky_model,
+                                                    zenith_data=solar_position['apparent_zenith'],
+                                                    airmass_data=airmass['airmass_absolute'])
 
         total_irrad = self.system.get_irradiance(solar_position['apparent_zenith'],
                                                  solar_position['azimuth'],
                                                  irradiance['dni'],
                                                  irradiance['ghi'],
                                                  irradiance['dhi'],
                                                  model=self.transposition_model)
-                                                
+
         if weather is None:
             weather = {'wind_speed': 0, 'temp_air': 20}
 
         temps = self.system.sapm_celltemp(total_irrad['poa_global'],
                                           weather['wind_speed'],
                                           weather['temp_air'])
-        
+
         aoi = self.system.get_aoi(solar_position['apparent_zenith'],
                                   solar_position['azimuth'])
 
-        am_rel = atmosphere.relativeairmass(solar_position['apparent_zenith'],
-                                            self.airmass_model)
-        am_abs = self.location.get_absoluteairmass(am_rel)
-
         dc = self.system.sapm(total_irrad['poa_direct'],
                               total_irrad['poa_diffuse'],
                               temps['temp_cell'],
-                              am_abs, aoi)
+                              airmass['airmass_absolute'],
+                              aoi)
 
         ac = self.system.snlinverter(dc['v_mp'], dc['p_mp'])
 
         return dc, ac
-    
+
 
     def model_system(self):
         """

pvlib/test/test_location.py

@@ -1,6 +1,3 @@
-import logging
-pvl_logger = logging.getLogger('pvlib')
-
 import pytz
 from nose.tools import raises
 from pytz.exceptions import UnknownTimeZoneError
@@ -35,3 +32,15 @@ def test_location_print_pytz():
     tus = Location(32.2, -111, aztz, 700, 'Tucson')
     expected_str = 'Tucson: latitude=32.2, longitude=-111, tz=US/Arizona, altitude=700'
     assert tus.__str__() == expected_str
+
+def test_get_clearsky():
+    raise Exception('test me')
+
+def test_from_tmy():
+    raise Exception('test me')
+
+def test_get_solarposition():
+    raise Exception('test me')
+
+def test_get_airmass():
+    raise Exception('test me')

pvlib/test/test_modelchain.py

@@ -0,0 +1,24 @@
+
+
+from pvlib import modelchain
+
+
+def test_ModelChain_creation():
+    raise Exception('test me')
+
+
+def test_orientation_strategy():
+    # test for None, 'None', 'south_at_latitude_tilt', 'flat', ValueError
+    raise Exception('test me')
+
+
+def test_run_model():
+    raise Exception('test me')
+
+
+def test_run_model_with_irradiance():
+    raise Exception('test me')
+
+
+def test_run_model_with_weather():
+    raise Exception('test me')

pvlib/test/test_pvsystem.py

@@ -222,8 +222,32 @@ def test_PVSystem_creation():
     pv_system = pvsystem.PVSystem(module='blah', inverter='blarg')
 
 
+def test_PVSystem_get_aoi():
+    raise Exception('test me')
+
+
+def test_PVSystem_get_irradiance():
+    raise Exception('test me')
+
+
+def test_PVSystem_localize_with_location():
+    raise Exception('test me')
+
+
+def test_PVSystem_localize_with_latlon():
+    raise Exception('test me')
+
+
+# in principle, we should be retesting each of the models tested above
+# when they are attached to PVSystem
+
+
 def test_LocalizedPVSystem_creation():
     localized_pv_system = pvsystem.LocalizedPVSystem(latitude=30,
                                                      longitude=-110,
                                                      module='blah',
-                                                     inverter='blarg')
+                                                     inverter='blarg')
+
+
+def test_LocalizedPVSystem_do_stuff():
+    raise Exception('test me')