Merge pull request #66 from wind-python/concat_without_sorting

Delete sort parameter

Author: birgits

setup.py

@@ -20,7 +20,7 @@ def read(fname):
       long_description=read('README.rst'),
       long_description_content_type='text/x-rst',
       zip_safe=False,
-      install_requires=['pandas >= 0.19.1, < 0.25',
+      install_requires=['pandas >= 0.20.0, < 0.26',
                         'requests < 3.0'],
       extras_require={
           'dev': ['pytest', 'jupyter', 'sphinx_rtd_theme', 'nbformat',

tests/test_modelchain.py

@@ -21,7 +21,9 @@ def setup_class(self):
         """Setup default values"""
         self.test_turbine = {'hub_height': 100,
                              'turbine_type': 'E-126/4200',
-                             'power_curve': True}
+                             'power_curve': pd.DataFrame(
+                                 data={'value': [0.0, 4200 * 1000],
+                                       'wind_speed': [0.0, 25.0]})}
 
         temperature_2m = np.array([[267], [268]])
         temperature_10m = np.array([[267], [266]])
@@ -303,3 +305,40 @@ def test_missing_p_values(self):
             test_mc = mc.ModelChain(wt.WindTurbine(**test_turbine),
                                     **test_modelchain)
             test_mc.run_model(self.weather_df)
+
+    def test_modelchain_with_power_curve_as_dict(self):
+        """Test power curves as dict"""
+        my_turbine = {'nominal_power': 3e6, 'hub_height': 105,
+                      'rotor_diameter': 70,
+                      'power_curve': {
+                          'value': [p * 1000 for p in [
+                              0.0, 26.0, 180.0, 1500.0, 3000.0, 3000.0]],
+                          'wind_speed': [0.0, 3.0, 5.0, 10.0, 15.0, 25.0]},
+                      'power_coefficient_curve': {
+                          'value': [0.0, 0.43, 0.45, 0.35, 0.12, 0.03],
+                          'wind_speed': [0.0, 3.0, 5.0, 10.0, 15.0, 25.0]}}
+        power_output_exp = pd.Series(data=[919055.54840,
+                                           1541786.60559],
+                                     name='feedin_power_plant')
+        test_mc = mc.ModelChain(wt.WindTurbine(**my_turbine))
+        test_mc.run_model(self.weather_df)
+        assert_series_equal(test_mc.power_output, power_output_exp)
+
+    def test_modelchain_with_power_coefficient_curve_as_dict(self):
+        """Test power coefficient curves as dict"""
+        my_turbine = {'nominal_power': 3e6, 'hub_height': 105,
+                      'rotor_diameter': 70,
+                      'power_curve': {
+                          'value': [p * 1000 for p in [
+                              0.0, 26.0, 180.0, 1500.0, 3000.0, 3000.0]],
+                          'wind_speed': [0.0, 3.0, 5.0, 10.0, 15.0, 25.0]},
+                      'power_coefficient_curve': {
+                          'value': [0.0, 0.43, 0.45, 0.35, 0.12, 0.03],
+                          'wind_speed': [0.0, 3.0, 5.0, 10.0, 15.0, 25.0]}}
+        power_output_exp = pd.Series(data=[469518.35104,
+                                           901794.28532],
+                                     name='feedin_power_plant')
+        test_mc = mc.ModelChain(wt.WindTurbine(**my_turbine),
+                                power_output_model='power_coefficient_curve')
+        test_mc.run_model(self.weather_df)
+        assert_series_equal(test_mc.power_output, power_output_exp)

tests/test_turbine_cluster_modelchain.py

@@ -40,8 +40,7 @@ def setup_class(self):
         self.test_turbine_2 = {'hub_height': 90,
                                'rotor_diameter': 60,
                                'turbine_type': 'V90/2000',
-                               'nominal_power': 2000000.0
-                               }
+                               'nominal_power': 2000000.0}
         self.test_farm = {'wind_turbine_fleet': [
                               {'wind_turbine':
                                   wt.WindTurbine(**self.test_turbine),
@@ -191,17 +190,18 @@ def test_error_raising(self):
 
         # Raise ValueError when aggregated wind farm power curve needs to be
         # calculated but turbine does not have a power curve
-        test_turbine = {
+        test_turbine_data = {
             'hub_height': 100,
             'rotor_diameter': 98,
-            'turbine_type': 'V90/2000',
-            'power_curve': True}
+            'turbine_type': 'V90/2000'}
+        test_turbine = wt.WindTurbine(**test_turbine_data)
+        test_turbine.power_curve = True
         test_farm = {'wind_turbine_fleet':
                          [{'wind_turbine':
                                wt.WindTurbine(**self.test_turbine),
                            'number_of_turbines': 3},
                           {'wind_turbine':
-                               wt.WindTurbine(**test_turbine),
+                               test_turbine,
                            'number_of_turbines': 3}]}
         test_tc_mc = tc_mc.TurbineClusterModelChain(
             power_plant=wf.WindFarm(**test_farm))
@@ -244,3 +244,26 @@ def test_wind_turbine_cluster_repr_without_name(self):
                                        wf.WindFarm(**self.test_farm_2)]}
         assert 'Wind turbine cluster with:' in repr(
             wtc.WindTurbineCluster(**test_cluster))
+
+    def test_tc_modelchain_with_power_curve_as_dict(self):
+        """Test power curves as dict in TurbineClusterModelChain.run_model()"""
+        my_turbine = {'nominal_power': 3e6, 'hub_height': 105,
+                      'power_curve': {
+                          'value': [p * 1000 for p in [
+                              0.0, 26.0, 180.0, 1500.0, 3000.0, 3000.0]],
+                          'wind_speed': [0.0, 3.0, 5.0, 10.0, 15.0, 25.0]}}
+        my_farm = {'wind_turbine_fleet':
+                       [{'wind_turbine': wt.WindTurbine(**my_turbine),
+                         'number_of_turbines': 3},
+                        {'wind_turbine': wt.WindTurbine(**self.test_turbine),
+                         'number_of_turbines': 3}]}
+        my_cluster =  {'wind_farms': [wf.WindFarm(**my_farm),
+                                      wf.WindFarm(**self.test_farm)]}
+        power_output_exp = pd.Series(data=[10853277.966972714,
+                                           21731814.593688786],
+                                     name='feedin_power_plant')
+        # run model with my_cluster
+        test_tc_mc = tc_mc.TurbineClusterModelChain(
+            power_plant=wtc.WindTurbineCluster(**my_cluster))
+        test_tc_mc.run_model(self.weather_df)
+        assert_series_equal(test_tc_mc.power_output, power_output_exp)

tests/test_wind_turbine.py

@@ -42,11 +42,29 @@ def test_get_turbine_types(self, capsys):
 
     def test_wrong_url_load_turbine_data(self):
         """Load turbine data from oedb."""
-
         with pytest.raises(ConnectionError,
                            match="Database connection not successful"):
             load_turbine_data_from_oedb('wrong_schema')
 
     @pytest.mark.filterwarnings("ignore:The WindTurbine")
     def test_string_representation_of_wind_turbine(self):
         assert "Wind turbine: ['hub height=120 m'" in repr(WindTurbine(120))
+
+    def test_power_curve_is_of_wrong_type(self):
+        """Error raising due to wrong type of WindTurbine.power_curve."""
+        test_turbine_data = {'hub_height': 100,
+                             'rotor_diameter': 80,
+                             'turbine_type': 'test_type',
+                             'power_curve': 'string'}
+        with pytest.raises(TypeError):
+            WindTurbine(**test_turbine_data)
+
+    def test_power_coefficient_curve_is_of_wrong_type(self):
+        """Error raising due to wrong type of
+        WindTurbine.power_coefficient_curve."""
+        test_turbine_data = {'hub_height': 100,
+                             'rotor_diameter': 80,
+                             'turbine_type': 'test_type',
+                             'power_coefficient_curve': 'string'}
+        with pytest.raises(TypeError):
+            WindTurbine(**test_turbine_data)

windpowerlib/modelchain.py

@@ -127,8 +127,7 @@ class ModelChain(object):
     >>> enerconE126 = {
     ...    'hub_height': 135,
     ...    'rotor_diameter': 127,
-    ...    'turbine_type': 'E-126/4200',
-    ...    'power_curve': True}
+    ...    'turbine_type': 'E-126/4200'}
     >>> e126 = wind_turbine.WindTurbine(**enerconE126)
     >>> modelchain_data = {'density_model': 'ideal_gas'}
     >>> e126_mc = modelchain.ModelChain(e126, **modelchain_data)

windpowerlib/wind_farm.py

@@ -362,14 +362,13 @@ def assign_power_curve(self, wake_losses_model='wind_farm_efficiency',
                     power_curve = pd.concat(
                         [pd.DataFrame(data={
                             'value': [0.0], 'wind_speed': [0.0]}),
-                         power_curve], sort=True)
+                            power_curve], join='inner')
                 if power_curve.iloc[-1]['value'] != 0.0:
                     power_curve = pd.concat(
                         [power_curve, pd.DataFrame(data={
-                            'value': [0.0], 'wind_speed': [
-                                power_curve['wind_speed'].loc[
-                                    power_curve.index[-1]] + 0.5]})],
-                        sort=True)
+                            'wind_speed': [power_curve['wind_speed'].loc[
+                                               power_curve.index[-1]] + 0.5],
+                            'value': [0.0]})], join='inner')
             # Add power curves of all turbine types to data frame
             # (multiplied by turbine amount)
             df = pd.concat(
@@ -379,7 +378,7 @@ def assign_power_curve(self, wake_losses_model='wind_farm_efficiency',
         wind_farm_power_curve = pd.DataFrame(
             df.interpolate(method='index').sum(axis=1))
         wind_farm_power_curve.columns = ['value']
-        wind_farm_power_curve.reset_index('wind_speed', inplace=True)
+        wind_farm_power_curve.reset_index(inplace=True)
         # Apply power curve smoothing and consideration of wake losses
         # after the summation
         if smoothing and smoothing_order == 'wind_farm_power_curves':

windpowerlib/wind_turbine.py

@@ -172,6 +172,28 @@ def __init__(self, hub_height, nominal_power=None, path='oedb',
                    " Check if the turbine type {0} is in your database file"
                    " or if you passed a valid curve.")
             warnings.warn(msg.format(turbine_type), WindpowerlibUserWarning)
+        else:
+            # power (coefficient) curve to pd.DataFrame in case of being dict
+            if isinstance(self.power_curve, dict):
+                self.power_curve = pd.DataFrame(self.power_curve)
+            if isinstance(self.power_coefficient_curve, dict):
+                self.power_coefficient_curve = pd.DataFrame(
+                    self.power_coefficient_curve)
+            # sort power (coefficient) curve by wind speed
+            if isinstance(self.power_curve, pd.DataFrame):
+                self.power_curve.sort_values(by='wind_speed')
+            elif self.power_curve is not None:
+                msg = "Type of power curve of {} is {} but should be " \
+                      "pd.DataFrame or dict."
+                raise TypeError(msg.format(self.__repr__(),
+                                           type(self.power_curve)))
+            if isinstance(self.power_coefficient_curve, pd.DataFrame):
+                self.power_coefficient_curve.sort_values(by='wind_speed')
+            elif self.power_coefficient_curve is not None:
+                msg = "Type of power coefficient curve of {} is {} but " \
+                      "should be pd.DataFrame or dict."
+                raise TypeError(msg.format(self.__repr__(),
+                                           type(self.power_coefficient_curve)))
 
     def __repr__(self):
         info = []

windpowerlib/wind_turbine_cluster.py

@@ -222,6 +222,6 @@ def assign_power_curve(self, wake_losses_model='wind_farm_efficiency',
             df.interpolate(method='index').sum(axis=1))
         cluster_power_curve.columns = ['value']
         # Return wind speed (index) to a column of the data frame
-        cluster_power_curve.reset_index('wind_speed', inplace=True)
+        cluster_power_curve.reset_index(inplace=True)
         self.power_curve = cluster_power_curve
         return self