def test_error_raising(self): source = os.path.join(os.path.dirname(__file__), '../example/data', 'example_power_curves.csv') self.test_turbine_data = { 'hub_height': 100, 'rotor_diameter': 80, 'name': 'turbine_not_in_file', 'fetch_curve': 'power_curve', 'data_source': source } # Raise system exit due to turbine type not in file with pytest.raises(SystemExit): WindTurbine(**self.test_turbine_data) # Raise ValueError due to invalid parameter `fetch_curve` self.test_turbine_data['fetch_curve'] = 'misspelling' self.test_turbine_data['name'] = 'DUMMY 3' with pytest.raises(ValueError): WindTurbine(**self.test_turbine_data) # Raise KeyError due to turbine type not in oedb self.test_turbine_data['fetch_curve'] = 'power_curve' self.test_turbine_data['data_source'] = 'oedb' with pytest.raises(KeyError): WindTurbine(**self.test_turbine_data)
def test_wrongly_defined_to_group_method(self): example_turbine = { 'hub_height': 100, 'rotor_diameter': 70, 'turbine_type': 'DUMMY 3', 'path': self.source } e_t_1 = WindTurbine(**example_turbine) with pytest.raises(ValueError, match="The 'number' and the 'total_capacity' " "parameter are mutually exclusive."): e_t_1.to_group(5, 3000)
def test_wrongly_defined_to_group_method(self): example_turbine = { "hub_height": 100, "rotor_diameter": 70, "turbine_type": "DUMMY 3", "path": self.source, } e_t_1 = WindTurbine(**example_turbine) with pytest.raises( ValueError, match="The 'number' and the 'total_capacity' " "parameter are mutually exclusive.", ): e_t_1.to_group(5, 3000)
def feedin_windpowerlib(weather, turbine, installed_capacity=1): """Use the windpowerlib to generate normalised feedin time series. Parameters ---------- turbine : dict Parameters of the wind turbine (hub height, diameter of the rotor, identifier of the turbine to get cp-series, nominal power). weather : pandas.DataFrame Weather data set. See module header. installed_capacity : float Overall installed capacity for the given wind turbine. The installed capacity is set to 1 by default for normalised time series. Returns ------- pandas.DataFrame """ wpp = WindTurbine(**turbine) modelchain_data = cfg.get_dict('windpowerlib') mc = ModelChain(wpp, **modelchain_data) mcwpp = mc.run_model(weather) return mcwpp.power_output.div( turbine['nominal_power']).multiply(installed_capacity)
def check_data_integrity(filename, min_pc_length=5): data = pd.read_csv(filename.format("turbine_data"), index_col=[0]) for data_set in data.iterrows(): wt_type = data_set[0] turbine_data_set = { "turbine_type": "{0}".format(wt_type), "hub_height": 135, } with warnings.catch_warnings(): warnings.simplefilter("ignore") wt = WindTurbine(**turbine_data_set) if wt.power_curve is None and data_set[1].has_power_curve is True: logging.warning( "{0}: No power curve but has_power_curve=True.".format( wt_type)) if (wt.power_coefficient_curve is None and data_set[1].has_cp_curve is True): logging.warning( "{0}: No cp-curve but has_cp_curve=True.".format(wt_type)) if wt.power_curve is not None: if len(wt.power_curve) < min_pc_length: logging.warning( "{0}: power_curve is too short ({1} values),".format( wt_type, len(wt.power_curve))) return data
def windpower(wind_instance, tmy): """ Returns: wind.power == wind power time series according using windpowerlib chain Inputs: wind class TMY dataframe (converted to windpowerlib API using _prepare_wind_data) """ from windpowerlib.modelchain import ModelChain from windpowerlib.wind_turbine import WindTurbine wind = wind_instance #### prepare wind data wind_df = _prepare_wind_data(tmy, wind) #### setup turbine turbinespec = { "turbine_type": "E-126/4200", # turbine type as in oedb turbine library "hub_height": 135, # in m } # initialize WindTurbine object turbine = WindTurbine(**turbinespec) #### Run wind ModelChain # wind speed : Hellman # temperature : linear gradient # density : ideal gass # power output : power curve modelchain_data = { "wind_speed_model": "logarithmic", # 'logarithmic' (default), # 'hellman' or # 'interpolation_extrapolation' "density_model": "ideal_gas", # 'barometric' (default), 'ideal_gas' # or 'interpolation_extrapolation' "temperature_model": "linear_gradient", # 'linear_gradient' (def.) or # 'interpolation_extrapolation' "power_output_model": "power_curve", # 'power_curve' (default) or # 'power_coefficient_curve' "density_correction": True, # False (default) or True "obstacle_height": 0, # default: 0 "hellman_exp": None, } # None (default) or None # initialize ModelChain with own specifications and use run_model method to # calculate power output mc = ModelChain(turbine, **modelchain_data).run_model(wind_df) # write power output time series to wind object power = mc.power_output / mc.power_output.max() * wind.installed if hasattr(wind, "transport_efficiency"): power *= wind.transport_efficiency power.index = wind.state.index return power
def summarized_pc(plot=False): enerconE70 = { 'object_name': 'ENERCON E 70 2300', 'hub_height': 64, 'rotor_diameter': 71 } enerconE66 = { 'object_name': 'ENERCON E 66 1800', 'hub_height': 65, 'rotor_diameter': 70 } vestasV126 = { 'object_name': 'VESTAS V 126 3300', 'hub_height': 117, 'rotor_diameter': 126 } e70 = WindTurbine(**enerconE70) e66 = WindTurbine(**enerconE66) v126 = WindTurbine(**vestasV126) parameters = { 'wind_turbine_fleet': [{ 'wind_turbine': e70, 'number_of_turbines': 13 }, { 'wind_turbine': e66, 'number_of_turbines': 4 }, { 'wind_turbine': v126, 'number_of_turbines': 2 }], 'smoothing': True, 'density_correction': False, 'roughness_length': 0.4 } power_curve_exp = 2 summarized_power_curve_df = summarized_power_curve(**parameters) if plot: plt.plot(summarized_power_curve_df['wind_speed'], summarized_power_curve_df['power']) plt.show() plt.close() return summarized_power_curve_df
def test_warning(self, recwarn): test_turbine_data = { 'hub_height': 100, 'rotor_diameter': 80, 'turbine_type': 'turbine_not_in_file', 'path': self.source } assert (WindTurbine(**test_turbine_data).power_curve is None) assert recwarn.pop(WindpowerlibUserWarning)
def run(self): print("Thread " + str(self.input_file)) weather = get_weather_data(filename="weather" + str(self.input_file) + ".csv") #print(weather[['wind_speed', 'temperature', 'pressure']][0:3]) # initialize WindTurbine object t = WindTurbine(**self.turbine) # initialize ModelChain with own specifications and use run_model method to # calculate power output mc_t = ModelChain(t, **self.modelchain_data).run_model(weather) # write power output time series to WindTurbine object t.power_output = mc_t.power_output power_file = open("power" + str(self.input_file) + ".csv", "w") power_file.write(t.power_output.to_csv()) print("Thread " + str(self.input_file) + " finished")
def test_warning(self, recwarn): test_turbine_data = { "hub_height": 100, "rotor_diameter": 80, "turbine_type": "turbine_not_in_file", "path": self.source, } assert WindTurbine(**test_turbine_data).power_curve is None assert recwarn.pop(WindpowerlibUserWarning)
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_create_unphysical_turbine(self): err_msg = "1/2rotor_diameter cannot be greater than hub_height" char = { "hub_height": 80, "rotor_diameter": 160, "turbine_type": "DUMMY 3", "path": self.source, } with pytest.raises(ValueError, match=err_msg): WindTurbine(**char)
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 wind_farm_power(self): # specification of wind turbine where # power coefficient curve and nominal # power is provided in an own csv file if self.multiplier == 0: data = np.zeros(8760) df = pd.DataFrame(data, columns=['wind_farm']) return df csv_path = os.path.join(os.path.dirname(__file__), "..", "data", 'oedb') myTurbine = { 'turbine_type': self.turbine_name, # turbine type as in file 'hub_height': self.hub_height, # in m 'rotor_diameter': self.rotor_diameter, # in m 'path': csv_path # using power_curve csv } # initialise WindTurbine object siemens = WindTurbine(**myTurbine) # specification of wind farm data farm = { 'name': 'example_farm', 'wind_turbine_fleet': [{ 'wind_turbine': siemens, 'number_of_turbines': self.multiplier }], 'efficiency': self.wind_farm_efficiency } # initialize WindFarm object farm_obj = WindFarm(**farm) weather = self.weather_data() # power output calculation for example_farm # initialize TurbineClusterModelChain with default parameters and use # run_model method to calculate power output mc_farm = TurbineClusterModelChain(farm_obj).run_model(weather) # write power output time series to WindFarm object farm_obj.power_output = mc_farm.power_output # units in kWh # times by 0.5 to correct for MEERA dataset series = (farm_obj.power_output * 0.5 / 1000).round(2) df = series.to_frame() df.columns = ['wind_farm'] return df
def test_feedin_windpowerlib(): fn = os.path.join( os.path.dirname(__file__), os.pardir, "tests", "data", "test_coastdat_weather.csv", ) weather = pd.read_csv(fn, header=[0, 1])["1126088"] turbine = {"hub_height": 135, "turbine_type": "E-141/4200"} data_height = cfg.get_dict("coastdat_data_height") wind_weather = coastdat.adapt_coastdat_weather_to_windpowerlib( weather, data_height) # doctest: +SKIP assert int(feedin.feedin_windpowerlib(wind_weather, turbine).sum()) == 2164 turbine = WindTurbine(**turbine) assert int(feedin.feedin_windpowerlib(wind_weather, turbine).sum()) == 2164
def feedin_windpowerlib_test(): fn = os.path.join(os.path.dirname(__file__), os.pardir, 'tests', 'data', 'test_coastdat_weather.csv') weather = pd.read_csv(fn, header=[0, 1])['1126088'] turbine = { 'hub_height': 135, 'rotor_diameter': 127, 'name': 'E-141/4200', 'nominal_power': 4200000, 'fetch_curve': 'power_coefficient_curve' } data_height = cfg.get_dict('coastdat_data_height') wind_weather = coastdat.adapt_coastdat_weather_to_windpowerlib( weather, data_height) # doctest: +SKIP eq_(int(feedin.feedin_windpowerlib(wind_weather, turbine).sum()), 1737) turbine = WindTurbine(**turbine) eq_(int(feedin.feedin_windpowerlib(wind_weather, turbine).sum()), 1737)
def test_to_group_method(self): example_turbine = { 'hub_height': 100, 'rotor_diameter': 70, 'turbine_type': 'DUMMY 3', 'path': self.source } e_t_1 = WindTurbine(**example_turbine) assert (isinstance(e_t_1.to_group(), WindTurbineGroup)) assert (e_t_1.to_group(5).number_of_turbines == 5) assert (e_t_1.to_group(number_turbines=5).number_of_turbines == 5) assert (e_t_1.to_group(total_capacity=3e6).number_of_turbines == 2.0)
def test_to_group_method(self): example_turbine = { "hub_height": 100, "rotor_diameter": 70, "turbine_type": "DUMMY 3", "path": self.source, } e_t_1 = WindTurbine(**example_turbine) assert isinstance(e_t_1.to_group(), WindTurbineGroup) assert e_t_1.to_group(5).number_of_turbines == 5 assert e_t_1.to_group(number_turbines=5).number_of_turbines == 5 assert e_t_1.to_group(total_capacity=3e6).number_of_turbines == 2.0
def user_power(self): """wind power output for user-defined turbine inputs weather and turbine spec initialises the wind turbine object runs model calculates power output Returns: pandas df -- hourly year power output """ if self.multiplier == 0: data = np.zeros(8760) df = pd.DataFrame(data, columns=['wind_user']) return df multi = self.multiplier # this returns dict which contains all the info for the windturbine myTurbine = { 'name': self.turbine_name, 'nominal_power': self.nominal_power, 'hub_height': self.hub_height, 'rotor_diameter': self.rotor_diameter, 'power_curve': self.power_curve } # input weather data weather = self.weather_data() # initialises a wind turbine object using # the WindTurbine class from windpowerlib UserTurbine = WindTurbine(**myTurbine) mc_my_turbine = ModelChain1(UserTurbine).run_model(weather) # 1000 factor to make it into kW, # and the multi to give number of wind turbines # multiply by 0.5 to correct MEERA dataset if needed series = (mc_my_turbine.power_output * multi / 1000.).round(2) df = series.to_frame() df.columns = ['wind_user'] df = df.reset_index(drop=True) return df
def feedin_windpowerlib(weather, turbine, installed_capacity=1): """Use the windpowerlib to generate normalised feedin time series. Parameters ---------- turbine : dict or windpowerlib.wind_turbine.WindTurbine Parameters of the wind turbine (hub height, diameter of the rotor, identifier of the turbine to get cp-series, nominal power). weather : pandas.DataFrame Weather data set. See module header. installed_capacity : float Overall installed capacity for the given wind turbine. The installed capacity is set to 1 by default for normalised time series. Returns ------- pandas.DataFrame Examples -------- >>> from reegis import coastdat >>> fn=os.path.join(os.path.dirname(__file__), os.pardir, 'tests', ... 'data', 'test_coastdat_weather.csv') >>> weather=pd.read_csv(fn, header=[0, 1])['1126088'] >>> turbine={ ... 'hub_height': 135, ... 'rotor_diameter': 127, ... 'name': 'E-82/2300', ... 'nominal_power': 4200000, ... 'fetch_curve': 'power_coefficient_curve'} >>> data_height=cfg.get_dict('coastdat_data_height') >>> wind_weather=coastdat.adapt_coastdat_weather_to_windpowerlib( ... weather, data_height) # doctest: +SKIP >>> int(feedin_windpowerlib(wind_weather, turbine).sum()) # doctest: +SKIP 1737 """ if not isinstance(turbine, WindTurbine): turbine = WindTurbine(**turbine) modelchain_data = cfg.get_dict("windpowerlib") mc = ModelChain(turbine, **modelchain_data) mcwpp = mc.run_model(weather) return mcwpp.power_output.div( turbine.nominal_power).multiply(installed_capacity)
def normalised_feedin_for_each_data_set(year, wind=True, solar=True, overwrite=False): """ Loop over all weather data sets (regions) and calculate a normalised time series for each data set with the given parameters of the power plants. This file could be more elegant and shorter but it will be rewritten soon with the new feedinlib features. year : int The year of the weather data set to use. wind : boolean Set to True if you want to create wind feed-in time series. solar : boolean Set to True if you want to create solar feed-in time series. Returns ------- """ # Get coordinates of the coastdat data points. data_points = pd.read_csv( os.path.join( cfg.get("paths", "geometry"), cfg.get("coastdat", "coastdatgrid_centroid"), ), index_col="gid", ) pv_sets = None wind_sets = None # Open coastdat-weather data hdf5 file for the given year or try to # download it if the file is not found. weather_file_name = os.path.join( cfg.get("paths", "coastdat"), cfg.get("coastdat", "file_pattern").format(year=year), ) if not os.path.isfile(weather_file_name): download_coastdat_data(year=year, filename=weather_file_name) weather = pd.HDFStore(weather_file_name, mode="r") # Fetch coastdat data heights from ini file. data_height = cfg.get_dict("coastdat_data_height") # Create basic file and path pattern for the resulting files coastdat_path = os.path.join(cfg.get("paths_pattern", "coastdat")) feedin_file = os.path.join(coastdat_path, cfg.get("feedin", "file_pattern")) # Fetch coastdat region-keys from weather file. key_file_path = coastdat_path.format(year="", type="")[:-2] key_file = os.path.join(key_file_path, "coastdat_keys.csv") if not os.path.isfile(key_file): coastdat_keys = weather.keys() if not os.path.isdir(key_file_path): os.makedirs(key_file_path) pd.Series(coastdat_keys).to_csv(key_file) else: coastdat_keys = pd.read_csv(key_file, index_col=[0], squeeze=True, header=None) txt_create = "Creating normalised {0} feedin time series for {1}." hdf = {"wind": {}, "solar": {}} if solar: logging.info(txt_create.format("solar", year)) # Add directory if not present os.makedirs(coastdat_path.format(year=year, type="solar"), exist_ok=True) # Create the pv-sets defined in the solar.ini pv_sets = feedin.create_pvlib_sets() # Open a file for each main set (subsets are stored in columns) for pv_key, pv_set in pv_sets.items(): filename = feedin_file.format(type="solar", year=year, set_name=pv_key) if not os.path.isfile(filename) or overwrite: hdf["solar"][pv_key] = pd.HDFStore(filename, mode="w") if wind: logging.info(txt_create.format("wind", year)) # Add directory if not present os.makedirs(coastdat_path.format(year=year, type="wind"), exist_ok=True) # Create the pv-sets defined in the wind.ini wind_sets = feedin.create_windpowerlib_sets() # Open a file for each main set (subsets are stored in columns) for wind_key, wind_set in wind_sets.items(): for subset_key, subset in wind_set.items(): wind_sets[wind_key][subset_key] = WindTurbine(**subset) filename = feedin_file.format(type="wind", year=year, set_name=wind_key) if not os.path.isfile(filename) or overwrite: hdf["wind"][wind_key] = pd.HDFStore(filename, mode="w") # Define basic variables for time logging remain = len(coastdat_keys) done = 0 start = datetime.datetime.now() # Loop over all regions for coastdat_key in coastdat_keys: # Get weather data set for one location local_weather = weather[coastdat_key] # Adapt the coastdat weather format to the needs of pvlib. # The expression "len(list(hdf['solar'].keys()))" returns the number # of open hdf5 files. If no file is open, there is nothing to do. if solar and len(list(hdf["solar"].keys())) > 0: # Get coordinates for the weather location local_point = data_points.loc[int(coastdat_key[2:])] # Create a pvlib Location object location = pvlib.location.Location(latitude=local_point["lat"], longitude=local_point["lon"]) # Adapt weather data to the needs of the pvlib local_weather_pv = adapt_coastdat_weather_to_pvlib( local_weather, location) # Create one DataFrame for each pv-set and store into the file for pv_key, pv_set in pv_sets.items(): if pv_key in hdf["solar"]: hdf["solar"][pv_key][coastdat_key] = feedin.feedin_pv_sets( local_weather_pv, location, pv_set) # Create one DataFrame for each wind-set and store into the file if wind and len(list(hdf["wind"].keys())) > 0: local_weather_wind = adapt_coastdat_weather_to_windpowerlib( local_weather, data_height) for wind_key, wind_set in wind_sets.items(): if wind_key in hdf["wind"]: hdf["wind"][wind_key][ coastdat_key] = feedin.feedin_wind_sets( local_weather_wind, wind_set) # Start- time logging ******* remain -= 1 done += 1 if divmod(remain, 10)[1] == 0: elapsed_time = (datetime.datetime.now() - start).seconds remain_time = elapsed_time / done * remain end_time = datetime.datetime.now() + datetime.timedelta( seconds=remain_time) msg = "Actual time: {:%H:%M}, estimated end time: {:%H:%M}, " msg += "done: {0}, remain: {1}".format(done, remain) logging.info(msg.format(datetime.datetime.now(), end_time)) # End - time logging ******** for k1 in hdf.keys(): for k2 in hdf[k1].keys(): hdf[k1][k2].close() weather.close() logging.info("All feedin time series for {0} are stored in {1}".format( year, coastdat_path.format(year=year, type="")))
def database_power(self): """wind turbine database power output power output calculation initialise ModelChain with default parameters and use run_model method to calculate power output Returns: pandas df -- hourly year of power output """ if self.multiplier == 0: data = np.zeros(8760) df = pd.DataFrame(data, columns=['wind_database']) return df multi = self.multiplier # specification of wind turbine where # power coefficient curve and nominal # power is provided in an own csv file csv_path = os.path.join(os.path.dirname(__file__), "..", "data", 'oedb') #, 'power_curves.csv') myTurbine = { 'turbine_type': self.turbine_name, # turbine type as in file 'hub_height': self.hub_height, # in m 'rotor_diameter': self.rotor_diameter, # in m 'path': csv_path # using power_curve csv } # own specifications for ModelChain setup modelchain_data = { 'wind_speed_model': 'logarithmic', # 'logarithmic' (default), # 'hellman' or # 'interpolation_extrapolation' 'density_model': 'barometric', # 'barometric' (default), 'ideal_gas' or # 'interpolation_extrapolation' 'temperature_model': 'linear_gradient', # 'linear_gradient' (def.) or # 'interpolation_extrapolation' 'power_output_model': 'power_curve', # 'power_curve' (default) or # 'power_coefficient_curve' 'density_correction': False, # False (default) or True 'obstacle_height': 0, # default: 0 'hellman_exp': None } # None (default) or None # initialise WindTurbine object turbineObj = WindTurbine(**myTurbine) weather = self.weather_data() mc_my_turbine = ModelChain1(turbineObj, **modelchain_data).run_model(weather) # write power output timeseries to WindTurbine object # divide by 1000 to keep in kW # multply by 0.5 for correcting reanalysis dataset series = (mc_my_turbine.power_output * multi * 0.5 / 1000).round(2) df = series.to_frame() df.columns = ['wind_database'] df = df.reset_index(drop=True) return df
def preprocess_wind(df, target, features): # Convert to standard indexing structure (ref_datetime, valid_datetime) df.index.name = 'valid_datetime' idx_ref_datetime = df.index.hour == 1 df.loc[idx_ref_datetime, 'ref_datetime'] = df.index[idx_ref_datetime] df.loc[:, 'ref_datetime'] = df.loc[:, 'ref_datetime'].fillna(method='ffill') df = df.set_index('ref_datetime', append=True, drop=True)[df.columns.levels[0][:-1]] df.index = df.index.reorder_levels(['ref_datetime', 'valid_datetime']) df = df.sort_index() # Remove hidden ref_datetime column from multiindex columns = [ df.columns.levels[0][:-1].values, df.columns.levels[1][:-1].values ] df.columns = pd.MultiIndex.from_product(columns) for farm in df.columns.levels[0]: df_features = pd.DataFrame(index=df.index) df_features.loc[:, 'Utot10'] = np.sqrt(df.loc[:, (farm, 'U10')]**2 + df.loc[:, (farm, 'V10')]**2) df_features.loc[:, 'Theta10'] = np.angle(df.loc[:, (farm, 'U10')] + df.loc[:, (farm, 'V10')] * 1j, deg=True) df_features.loc[:, 'Utot100'] = np.sqrt(df.loc[:, (farm, 'U100')]**2 + df.loc[:, (farm, 'V100')]**2) df_features.loc[:, 'Theta100'] = np.angle( df.loc[:, (farm, 'U100')] + df.loc[:, (farm, 'V100')] * 1j, deg=True) df_features.loc[:, 'Utot10_Acc'] = df_features.loc[:, 'Utot10'].diff(1) df_features.loc[:, 'Utot100_Acc'] = df_features.loc[:, 'Utot100'].diff(1) df_features.loc[:, 'Utot310'] = df_features.loc[:, 'Utot10']**3 df_features.loc[:, 'Utot3100'] = df_features.loc[:, 'Utot100']**3 df_features.loc[:, 'Utotdiff'] = df_features.loc[:, 'Utot100'] - df_features.loc[:, 'Utot10'] for feature in df_features.columns: df.loc[:, (farm, feature)] = df_features[feature] for farm in df.columns.levels[0]: df_features = pd.DataFrame(index=df.index) df_features.loc[:, 'O_UTot100_Mean'] = df.loc[:, pd. IndexSlice[:, 'Utot100']].mean( axis=1) df_features.loc[:, 'O_UTot100_Std'] = df.loc[:, pd. IndexSlice[:, 'Utot100']].std( axis=1) df_features.loc[:, 'O_UTot100_Min'] = df.loc[:, pd. IndexSlice[:, 'Utot100']].min( axis=1) df_features.loc[:, 'O_UTot100_Max'] = df.loc[:, pd. IndexSlice[:, 'Utot100']].max( axis=1) df_features.loc[:, 'O_Theta100_Mean'] = df.loc[:, pd. IndexSlice[:, 'Theta100']].mean( axis=1) df_features.loc[:, 'O_Theta100_Std'] = df.loc[:, pd. IndexSlice[:, 'Theta100']].std( axis=1) df_features.loc[:, 'O_Theta100_Min'] = df.loc[:, pd. IndexSlice[:, 'Theta100']].min( axis=1) df_features.loc[:, 'O_Theta100_Max'] = df.loc[:, pd. IndexSlice[:, 'Theta100']].max( axis=1) df_features.loc[:, 'O_UTot100_Acc_Mean'] = df.loc[:, pd. IndexSlice[:, 'Utot100_Acc']].mean( axis=1) df_features.loc[:, 'O_UTot100_Acc_Std'] = df.loc[:, pd. IndexSlice[:, 'Utot100_Acc']].std( axis=1) df_features.loc[:, 'O_UTot100_Acc_Min'] = df.loc[:, pd. IndexSlice[:, 'Utot100_Acc']].min( axis=1) df_features.loc[:, 'O_UTot100_Acc_Max'] = df.loc[:, pd. IndexSlice[:, 'Utot100_Acc']].max( axis=1) #other_farms = df.columns.levels[0].difference([farm]) for ofarm in df.columns.levels[0]: df_features.loc[:, 'O_UTot100_' + ofarm] = df.loc[:, pd.IndexSlice[ofarm, 'Utot100']].values for ofarm in df.columns.levels[0]: df_features.loc[:, 'O_Theta100_' + ofarm] = df.loc[:, pd.IndexSlice[ofarm, 'Theta100']].values for feature in df_features.columns: df.loc[:, (farm, feature)] = df_features[feature] # Physical forecast columns = [df.columns.levels[0], ['wind_speed'], [10, 100]] df_weather = pd.DataFrame(columns=pd.MultiIndex.from_product(columns)) for farm, height in itertools.product(columns[0], columns[2]): df_weather.loc[:, (farm, 'wind_speed', height)] = df.loc[:, (farm, 'Utot' + str(height))] for farm in df.columns.levels[0]: df_weather.loc[:, (farm, 'roughness_length', 0)] = 0.03 wt = WindTurbine(turbine_type='E-126/4200', hub_height=135, rotor_diameter=127) wf = WindFarm(name='GEFCom2014', wind_turbine_fleet=[{ 'wind_turbine': wt, 'number_of_turbines': 30 }]) wf.efficiency = 1.0 mc = TurbineClusterModelChain(wf, wake_losses_model=None) for farm in df_weather.columns.levels[0]: power = mc.run_model(df_weather[farm]).power_output del mc.power_output power_norm = power / wf.nominal_power df.loc[:, (farm, 'P_out')] = power_norm # Select only features specified in parameter file df_temp = pd.DataFrame(index=df.index, columns=pd.MultiIndex.from_product( [df.columns.levels[0], [target] + features])) df_temp.loc[:, pd.IndexSlice[:, [target] + features]] = df.loc[:, pd.IndexSlice[:, [target] + features]] # Add custom weights for farm in df_temp.columns.levels[0]: df_temp.loc[:, (farm, 'weights')] = 0.5 return df_temp
print(turbines[turbines["turbine_id"].str.contains("ENERCON")]) # specification of own wind turbine (Note: power coefficient values and # nominal power have to be in Watt) myTurbine = { 'name': 'myTurbine', 'nominal_power': 3e6, # in W 'hub_height': 105, # in m 'rotor_diameter': 90, # in m 'power_curve': pd.DataFrame( data={'power': [p * 1000 for p in [ 0.0, 26.0, 180.0, 1500.0, 3000.0, 3000.0]], # in W 'wind_speed': [0.0, 3.0, 5.0, 10.0, 15.0, 25.0]}) # in m/s } # initialise WindTurbine object my_turbine = WindTurbine(**myTurbine) # specification of wind turbine where power curve is provided # if you want to use the power coefficient curve change the value of # 'fetch_curve' to 'power_coefficient_curve' enerconE126 = { 'name': 'ENERCON E 126 7500', # turbine name as in register 'hub_height': 135, # in m 'rotor_diameter': 127, # in m 'fetch_curve': 'power_curve' # fetch power curve } # initialise WindTurbine object e126 = WindTurbine(**enerconE126) # power output calculation for my_turbine # initialise ModelChain with default parameters and use run_model
def test_string_representation_of_wind_turbine(self): assert "Wind turbine: ['hub height=120 m'" in repr(WindTurbine(120))
df = wt.get_turbine_types(print_out=False) # find all Enercons print(df[df["manufacturer"].str.contains("Enercon")]) print(df[df["turbine_type"].str.contains("E-101")]) # specification of wind turbine where power curve is provided in the # oedb turbine library enercon_e126 = { 'turbine_type': 'E-126/4200', # turbine type as in oedb turbine library 'hub_height': 135 # in m } # initialize WindTurbine object e126 = WindTurbine(**enercon_e126) # power output calculation for e126 # own specifications for ModelChain setup modelchain_data = { 'wind_speed_model': 'logarithmic', # 'logarithmic' (default), # 'hellman' or # 'interpolation_extrapolation' 'density_model': 'ideal_gas', # 'barometric' (default), 'ideal_gas' # or 'interpolation_extrapolation' 'temperature_model': 'linear_gradient', # 'linear_gradient' (def.) or # 'interpolation_extrapolation' 'power_output_model': 'power_curve', # 'power_curve' (default) or # 'power_coefficient_curve' 'density_correction': True, # False (default) or True