def test_nodes_with_none_exclusion_old_name(self):
param_results = processing.parameter_as_dict(self.es,
exclude_none=True)
param_results = processing.convert_keys_to_strings(param_results,
keep_none_type=True)
assert_series_equal(
param_results[('storage', None)]['scalars'],
pandas.Series({
'balanced': True,
'initial_storage_level': 0,
'invest_relation_input_capacity': 1 / 6,
'invest_relation_output_capacity': 1 / 6,
'investment_ep_costs': 0.4,
'investment_existing': 0,
'investment_maximum': float('inf'),
'investment_minimum': 0,
'label': 'storage',
'inflow_conversion_factor': 1,
'loss_rate': 0,
'max_storage_level': 1,
'min_storage_level': 0,
'outflow_conversion_factor': 0.8,
}))
assert_frame_equal(param_results[('storage', None)]['sequences'],
pandas.DataFrame())
def test_flows_without_none_exclusion(self):
b_el2 = self.es.groups['b_el2']
demand = self.es.groups['demand_el']
param_results = processing.parameter_as_dict(self.es,
exclude_none=False)
scalar_attributes = {
'fixed': True,
'integer': None,
'investment': None,
'nominal_value': 1,
'nonconvex': None,
'summed_max': None,
'summed_min': None,
'max': 1,
'min': 0,
'negative_gradient_ub': None,
'negative_gradient_costs': 0,
'positive_gradient_ub': None,
'positive_gradient_costs': 0,
'variable_costs': 0
}
assert_series_equal(param_results[(b_el2, demand)]['scalars'],
pandas.Series(scalar_attributes))
sequences_attributes = {
'actual_value': self.demand_values,
}
default_sequences = ['actual_value']
for attr in default_sequences:
if attr not in sequences_attributes:
sequences_attributes[attr] = [None]
assert_frame_equal(param_results[(b_el2, demand)]['sequences'],
pandas.DataFrame(sequences_attributes))
def solve(self, with_duals=False, tee=True, logfile=None, solver=None):
logging.info("Optimising using {0}.".format(solver))
if with_duals:
self.model.receive_duals()
if self.debug:
filename = os.path.join(helpers.extend_basic_path("lp_files"),
"reegis.lp")
logging.info("Store lp-file in {0}.".format(filename))
self.model.write(filename,
io_options={"symbolic_solver_labels": True})
self.model.solve(solver=solver,
solve_kwargs={
"tee": tee,
"logfile": logfile
})
self.es.results["main"] = processing.results(self.model)
self.es.results["meta"] = processing.meta_results(self.model)
self.es.results["param"] = processing.parameter_as_dict(self.es)
self.es.results["meta"]["scenario"] = self.scenario_info(solver)
self.es.results["meta"]["in_location"] = self.location
self.es.results["meta"]["file_date"] = datetime.datetime.fromtimestamp(
os.path.getmtime(self.location))
self.es.results["meta"]["oemof_version"] = logger.get_version()
self.results = self.es.results["main"]
def test_parameter_with_node_view(self):
param_results = processing.parameter_as_dict(self.es,
exclude_none=True)
bel1 = views.node(param_results, 'b_el1')
eq_(bel1['scalars'][(('b_el1', 'storage'), 'variable_costs')], 3)
bel1_m = views.node(param_results, 'b_el1', multiindex=True)
eq_(bel1_m['scalars'].loc[('b_el1', 'storage', 'variable_costs')], 3)
def test_nodes_without_none_exclusion(self):
diesel = self.es.groups['diesel']
param_results = processing.parameter_as_dict(self.es,
exclude_none=False)
assert_series_equal(
param_results[(diesel, None)]['scalars'],
pandas.Series({
'label': 'diesel',
'conversion_factors_b_el1': 2,
'conversion_factors_b_diesel': 1,
}))
assert_frame_equal(param_results[(diesel, None)]['sequences'],
pandas.DataFrame())
def test_flows_with_none_exclusion(self):
b_el2 = self.es.groups['b_el2']
demand = self.es.groups['demand_el']
param_results = processing.parameter_as_dict(self.es,
exclude_none=True)
assert_series_equal(
param_results[(b_el2, demand)]['scalars'],
pandas.Series({
'fixed': True,
'nominal_value': 1,
'max': 1,
'min': 0,
'negative_gradient_costs': 0,
'positive_gradient_costs': 0,
'variable_costs': 0
}))
assert_frame_equal(
param_results[(b_el2, demand)]['sequences'],
pandas.DataFrame({'actual_value': self.demand_values}))
def setup(self):
self.results = processing.results(optimization_model)
self.param_results = processing.parameter_as_dict(optimization_model)
def run_model(params, wind_invest=False, pv_invest=False, storage_invest=False):
logging.info('Initialize the energy system')
energysystem = solph.EnergySystem(timeindex=date_time_index)
Node.registry = energysystem
logging.info('Create oemof objects')
bgas = solph.Bus(label="natural_gas")
bel = solph.Bus(label="electricity")
solph.Sink(label='excess_bel', inputs={bel: solph.Flow()})
solph.Source(label='rgas', outputs={bgas: solph.Flow(nominal_value=params['rgas_nom_val'],
summed_max=1)})
if wind_invest == True:
solph.Source(label='wind', outputs={bel: solph.Flow(
actual_value=data['wind'], fixed=True,
investment=solph.Investment(ep_costs=params['epc_wind']))})
else:
solph.Source(label='wind', outputs={bel: solph.Flow(
actual_value=data['wind'], nominal_value=params['wind_nom_val'], fixed=True)})
if pv_invest == True:
pv = solph.Source(label='pv', outputs={bel: solph.Flow(
actual_value=data['pv'], fixed=True,
investment=solph.Investment(ep_costs=params['epc_pv']))})
else:
solph.Source(label='pv', outputs={bel: solph.Flow(
actual_value=data['pv'], nominal_value=params['pv_nom_val'], fixed=True)})
solph.Sink(label='demand', inputs={bel: solph.Flow(
actual_value=data['demand_el'], fixed=True, nominal_value=1)})
solph.Transformer(
label="pp_gas",
inputs={bgas: solph.Flow()},
outputs={bel: solph.Flow(nominal_value=10e10, variable_costs=50)},
conversion_factors={bel: 0.58})
storage = solph.components.GenericStorage(
label='storage',
inputs={bel: solph.Flow(variable_costs=10e10)},
outputs={bel: solph.Flow(variable_costs=10e10)},
capacity_loss=0.00, initial_capacity=0,
nominal_input_capacity_ratio=1/6,
nominal_output_capacity_ratio=1/6,
inflow_conversion_factor=1, outflow_conversion_factor=0.8,
investment=solph.Investment(ep_costs=params['epc_storage']),
)
logging.info('Optimise the energy system')
om = solph.Model(energysystem)
test_var = 2
print(test_var)
logging.info('Solve the optimization problem')
om.solve(solver='cbc')
string_results = processing.convert_keys_to_strings(processing.results(om))
electricity_results = views.node(string_results, 'electricity')
param_dict = processing.convert_keys_to_strings(processing.parameter_as_dict(energysystem))
param_dict_scalars = {key: value['scalars'] for (key,value) in param_dict.items()}
print(string_results.keys())
print(string_results[('wind','electricity')]['scalars']['invest'])
print(string_results[('pv','electricity')]['scalars']['invest'])
def run_model_dessau(config_path, results_dir):
r"""
Create the energy system and run the optimisation model.
Parameters
----------
config_path : Path to experiment config
results_dir : Directory for results
Returns
-------
energysystem.results : Dict containing results
"""
abs_path = os.path.dirname(os.path.abspath(os.path.join(__file__, '..')))
with open(config_path, 'r') as ymlfile:
cfg = yaml.load(ymlfile)
# load input parameter
in_param = pd.read_csv(os.path.join(abs_path, cfg['input_parameter']), index_col=[1, 2])['var_value']
wacc = in_param['general', 'wacc']
# load timeseries
demand_heat_timeseries = pd.read_csv(os.path.join(results_dir, cfg['timeseries']['timeseries_demand_heat']),
index_col=0, names=['demand_heat'], sep=',')['demand_heat']
print(demand_heat_timeseries.head())
# create timeindex
if cfg['debug']:
number_timesteps = 200
else:
number_timesteps = 8760
date_time_index = pd.date_range('1/1/2017',
periods=number_timesteps,
freq='H')
logging.info('Initialize the energy system')
energysystem = solph.EnergySystem(timeindex=date_time_index)
#####################################################################
logging.info('Create oemof objects')
#####################################################################
bgas = solph.Bus(label="natural_gas", balanced=False)
bel = solph.Bus(label="electricity", balanced=False)
bth_prim = solph.Bus(label="heat_prim")
bth_sec = solph.Bus(label="heat_sec")
bth_end = solph.Bus(label="heat_end")
energysystem.add(bgas, bth_prim, bth_sec, bth_end, bel)
# energysystem.add(solph.Sink(label='excess_heat',
# inputs={bth: solph.Flow()}))
energysystem.add(solph.Source(label='shortage_heat',
outputs={bth_prim: solph.Flow(variable_costs=in_param['shortage_heat','var_costs'])}))
# energysystem.add(solph.Source(label='rgas',
# outputs={bgas: solph.Flow(
# variable_costs=0)}))
if cfg['investment']['invest_chp']:
energysystem.add(solph.Transformer(
label='ccgt',
inputs={bgas: solph.Flow(variable_costs=in_param['bgas','price_gas'])},
outputs={bth_prim: solph.Flow(
investment=solph.Investment(
ep_costs=economics.annuity(
capex=in_param['ccgt','capex'], n=in_param['ccgt','inv_period'], wacc=wacc)),
variable_costs=0)},
conversion_factors={bth_prim: 0.5}))
else:
energysystem.add(solph.Transformer(
label='ccgt',
inputs={bgas: solph.Flow(variable_costs=in_param['bgas','price_gas'])},
outputs={bth_prim: solph.Flow(
nominal_value=in_param['ccgt','nominal_value'],
variable_costs=0)},
conversion_factors={bth_prim: 0.5}))
if cfg['investment']['invest_pth']:
energysystem.add(solph.Transformer(
label='power_to_heat',
inputs={bel: solph.Flow(variable_costs=in_param['bel','price_el'])},
outputs={bth_prim: solph.Flow(
investment=solph.Investment(
ep_costs=economics.annuity(
capex=in_param['power_to_heat','capex'], n=in_param['power_to_heat','inv_period'], wacc=wacc)),
variable_costs=0)},
conversion_factors={bth_prim: 1}))
else:
energysystem.add(solph.Transformer(label='power_to_heat',
inputs={bel: solph.Flow(variable_costs=in_param['bel','price_el'])},
outputs={bth_prim: solph.Flow(
nominal_value=in_param['power_to_heat','nominal_value'],
variable_costs=0)},
conversion_factors={bth_prim: 1}))
energysystem.add(solph.Transformer(
label='dhn_prim',
inputs={bth_prim: solph.Flow()},
outputs={bth_sec: solph.Flow()},
conversion_factors={bth_sec: 1.}))
energysystem.add(solph.Transformer(
label='dhn_sec',
inputs={bth_sec: solph.Flow()},
outputs={bth_end: solph.Flow()},
conversion_factors={bth_end: 1.}))
energysystem.add(solph.Sink(
label='demand_heat',
inputs={bth_end: solph.Flow(
actual_value=demand_heat_timeseries,
fixed=True,
nominal_value=1.,
summed_min=1)}))
energysystem.add(solph.components.GenericStorage(
label='storage_heat',
nominal_capacity=in_param['storage_heat','nominal_capacity'],
inputs={bth_prim: solph.Flow(
variable_costs=0,
nominal_value=in_param['storage_heat','input_nominal_value'])},
outputs={bth_prim: solph.Flow(
nominal_value=in_param['storage_heat','output_nominal_value'])},
capacity_loss=in_param['storage_heat','capacity_loss'],
initial_capacity=in_param['storage_heat','initial_capacity'],
capacity_max=in_param['storage_heat','nominal_capacity'],
inflow_conversion_factor=1,
outflow_conversion_factor=1))
energysystem_graph = graph.create_nx_graph(energysystem)
graph_file_name = os.path.join(results_dir, 'energysystem_graph.pkl')
nx.readwrite.write_gpickle(G=energysystem_graph, path=graph_file_name)
#####################################################################
logging.info('Solve the optimization problem')
om = solph.Model(energysystem)
om.solve(solver=cfg['solver'], solve_kwargs={'tee': True})
if cfg['debug']:
filename = os.path.join(
oemof.tools.helpers.extend_basic_path('lp_files'),
'app_district_heating.lp')
logging.info('Store lp-file in {0}.'.format(filename))
om.write(filename, io_options={'symbolic_solver_labels': True})
#####################################################################
logging.info('Check the results')
#####################################################################
energysystem.results['main'] = processing.results(om)
energysystem.results['meta'] = processing.meta_results(om)
energysystem.results['param'] = processing.parameter_as_dict(om)
energysystem.dump(dpath=results_dir + '/optimisation_results', filename='es.dump')
return energysystem.results
