def test_add_to_oemof_model(self):
sim_params = SimulationParameters({})
comp = PemElectrolyzer({
"bus_h2": "bus1",
"bus_el": "bus2",
"bus_th": "bus3",
"sim_params": sim_params
})
oemof_model = solph.EnergySystem(
timeindex=sim_params.date_time_index[0:1],
freq='{}min'.format(sim_params.interval_time)
)
comp.add_to_oemof_model({
"bus1": solph.Bus(label="bus1"),
"bus2": solph.Bus(label="bus2"),
"bus3": solph.Bus(label="bus3")
}, oemof_model)
assert comp.model_h2 is not None and comp.model_th is not None
assert type(comp.model_h2) == solph.custom.PiecewiseLinearTransformer
assert type(comp.model_th) == solph.custom.PiecewiseLinearTransformer
assert len(comp.model_h2.inputs) == 1
assert len(comp.model_h2.outputs) == 1
assert len(comp.model_th.inputs) == 1
assert len(comp.model_th.outputs) == 1
def elesplan_m(scenario_path,
year,
scenario,
solver='gurobi',
solver_options=None,
debug=False):
data_path = os.path.join(scenario_path, 'data')
# Instantiate model
model_2020 = ElesplanMOneYearModel(year=year,
debug=debug,
data_path=data_path)
# Load data
model_2020.load_csv(data_path, year, scenario)
# Create energy system
es = solph.EnergySystem(
timeindex=model_2020.table_collection['demand'].index)
# Create model & solve
model_2020.create_model(es)
model_2020.solve(solver=solver, solver_options=solver_options)
# Save results
results_path = os.path.join(scenario_path, 'results', 'raw')
if not os.path.isdir(results_path):
os.makedirs(results_path)
model_2020.dump_es(
os.path.join(results_path, 'results_{}.es'.format(scenario)))
def test_add_to_oemof_model(self):
ch2 = CompressorH2({
"bus_h2_in":
"bus1",
"bus_h2_out":
"bus2",
"bus_el":
"bus3",
"sim_params":
SimulationParameters({"interval_time": 15}),
"m_flow_max":
60
})
oemof_model = solph.EnergySystem()
component = ch2.add_to_oemof_model(
{
"bus1": solph.Bus(label="bus1"),
"bus2": solph.Bus(label="bus2"),
"bus3": solph.Bus(label="bus3"),
}, oemof_model)
assert type(component) == solph.Transformer
assert len(component.inputs) == 2
assert len(component.outputs) == 1
for k, v in component.inputs.items():
if str(k) == "bus1":
assert v.nominal_value == 15
def check_oemof_installation(silent=False):
date_time_index = pd.date_range('1/1/2012', periods=5, freq='H')
energysystem = solph.EnergySystem(timeindex=date_time_index)
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()})
solph.Sink(label='demand', inputs={bel: solph.Flow(
actual_value=[10, 20, 30, 40, 50], 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})
om = solph.Model(energysystem)
# check solvers
solver = dict()
for s in ['cbc', 'glpk', 'gurobi', 'cplex']:
try:
om.solve(solver=s)
solver[s] = "working"
except Exception:
solver[s] = "not working"
if not silent:
print("*********")
print('Solver installed with oemof:')
for s, t in solver.items():
print("{0}: {1}".format(s, t))
print("*********")
print("oemof successfully installed.")
def test_results_with_old_dump():
"""
Test again with a stored dump created with v0.3.2dev (896a6d50)
"""
energysystem = solph.EnergySystem()
energysystem.restore(dpath=os.path.dirname(os.path.realpath(__file__)),
filename='es_dump_test_3_2dev.oemof')
results = energysystem.results['main']
electricity_bus = views.node(results, 'electricity')
my_results = electricity_bus['sequences'].sum(axis=0).to_dict()
storage = energysystem.groups['storage']
my_results['storage_invest'] = results[(storage,
None)]['scalars']['invest']
stor_invest_dict = {
'storage_invest': 2040000,
(('electricity', 'demand'), 'flow'): 105867395,
(('electricity', 'excess_bel'), 'flow'): 211771291,
(('electricity', 'storage'), 'flow'): 2350931,
(('pp_gas', 'electricity'), 'flow'): 5148414,
(('pv', 'electricity'), 'flow'): 7488607,
(('storage', 'electricity'), 'flow'): 1880745,
(('wind', 'electricity'), 'flow'): 305471851
}
for key in stor_invest_dict.keys():
eq_(int(round(my_results[key])), int(round(stor_invest_dict[key])))
def test_add_to_oemof_model(self):
comp = GasEngineChpBiogas({
"power_max": 1,
"bus_bg": "bus1",
"bus_el": "bus2",
"bus_th": "bus3",
"sim_params": self.sim_params
})
oemof_model = solph.EnergySystem(
timeindex=self.sim_params.date_time_index[0:1],
freq='{}min'.format(self.sim_params.interval_time))
comp.add_to_oemof_model(
{
"bus1": solph.Bus(label="bus1"),
"bus2": solph.Bus(label="bus2"),
"bus3": solph.Bus(label="bus3")
}, oemof_model)
assert comp.model_el is not None and comp.model_th is not None
assert type(comp.model_el) == solph.custom.PiecewiseLinearTransformer
assert type(comp.model_th) == solph.custom.PiecewiseLinearTransformer
assert len(comp.model_el.inputs) == 1
assert len(comp.model_el.outputs) == 1
assert len(comp.model_th.inputs) == 1
assert len(comp.model_th.outputs) == 1
def restore_es(self, filename):
if self.es is None:
self.es = solph.EnergySystem()
d_path = os.path.dirname(filename)
d_fn = filename.split(os.path.sep)[-1]
self.es.restore(dpath=d_path, filename=d_fn)
self.results = self.es.results['main']
def test_something_else():
date_time_index = pd.date_range('1/1/2012', periods=5, freq='H')
energysystem = solph.EnergySystem(timeindex=date_time_index)
bel1 = solph.Bus(label='electricity1')
bel2 = solph.Bus(label='electricity2')
energysystem.add(bel1, bel2)
energysystem.add(
solph.Transformer(
label='powerline_1_2',
inputs={bel1: solph.Flow()},
outputs={
bel2: solph.Flow(investment=solph.Investment(ep_costs=20))
}))
energysystem.add(
solph.Transformer(
label='powerline_2_1',
inputs={bel2: solph.Flow()},
outputs={
bel1: solph.Flow(investment=solph.Investment(ep_costs=20))
}))
om = solph.Model(energysystem)
line12 = energysystem.groups['powerline_1_2']
line21 = energysystem.groups['powerline_2_1']
solph.constraints.equate_variables(om,
om.InvestmentFlow.invest[line12, bel2],
om.InvestmentFlow.invest[line21, bel1],
name="my_name")
def test_add_to_oemof_model():
s = Supply({"bus_out": "foo"})
model = s.add_to_oemof_model({"foo": solph.Bus(label="foo")},
solph.EnergySystem())
assert type(model) == solph.network.Source
assert len(model.inputs) == 0
assert len(model.outputs) == 1
def test_add_to_oemof_model(self):
fc_chp = FuelCellChp({
"bus_h2": "bus1",
"bus_el": "bus2",
"bus_th": "bus3",
"sim_params": self.sim_params
})
oemof_model = solph.EnergySystem(
timeindex=self.sim_params.date_time_index[0:1],
freq='{}min'.format(self.sim_params.interval_time))
fc_chp.add_to_oemof_model(
{
"bus1": solph.Bus(label="bus1"),
"bus2": solph.Bus(label="bus2"),
"bus3": solph.Bus(label="bus3")
}, oemof_model)
assert fc_chp.model_el is not None and fc_chp.model_th is not None
assert type(fc_chp.model_el) == solph.custom.PiecewiseLinearTransformer
assert type(fc_chp.model_th) == solph.custom.PiecewiseLinearTransformer
assert len(fc_chp.model_el.inputs) == 1
assert len(fc_chp.model_el.outputs) == 1
assert len(fc_chp.model_th.inputs) == 1
assert len(fc_chp.model_th.outputs) == 1
def initialize(dict_values):
"""
Initalization of oemof model
Parameters
----------
dict_values: dict
dictionary of simulation
Returns
-------
oemof energy model (oemof.solph.network.EnergySystem), dict_model which gathers the assets added to this model later.
"""
logging.info("Initializing oemof simulation.")
model = solph.EnergySystem(
timeindex=dict_values[SIMULATION_SETTINGS][TIME_INDEX])
# this dictionary will include all generated oemof objects
dict_model = {
OEMOF_BUSSES: {},
OEMOF_SINK: {},
OEMOF_SOURCE: {},
OEMOF_TRANSFORMER: {},
OEMOF_GEN_STORAGE: {},
}
return model, dict_model
def test_add_to_oemof_model(self):
h2_chp = H2Chp({
"power_max": 1,
"bus_h2": "bus1",
"bus_el": "bus2",
"bus_th": "bus3",
"sim_params": self.sim_params
})
oemof_model = solph.EnergySystem()
h2_chp.add_to_oemof_model(
{
"bus1": solph.Bus(label="bus1"),
"bus2": solph.Bus(label="bus2"),
"bus3": solph.Bus(label="bus3")
}, oemof_model)
assert h2_chp.model_el is not None and h2_chp.model_th is not None
assert len(oemof_model.entities) == 2
assert type(h2_chp.model_el) == solph.custom.PiecewiseLinearTransformer
assert type(h2_chp.model_th) == solph.custom.PiecewiseLinearTransformer
assert len(h2_chp.model_el.inputs) == 1
assert len(h2_chp.model_el.outputs) == 1
assert len(h2_chp.model_th.inputs) == 1
assert len(h2_chp.model_th.outputs) == 1
def test_add_to_oemof_model():
vg = VarGrid({"bus_out": "foo"})
model = solph.EnergySystem()
comp = vg.add_to_oemof_model({"foo": solph.Bus(label="foo")}, model)
assert len(model.entities) == 1
assert type(comp) == solph.network.Source
assert len(comp.inputs) == 0
assert len(comp.outputs) == 1
def initialise_energy_system(number_timesteps=192):
"""Create an energy system"""
logging.info('Initialize the energy system')
# create time index for 192 hours in May.
date_time_index = pd.date_range('5/5/2012', periods=number_timesteps,
freq='H')
return solph.EnergySystem(timeindex=date_time_index)
def create_esys(self):
# create esys
self.esys = solph.EnergySystem(
timeindex=pd.date_range(start=SIM_CFG['date_from'],
end=SIM_CFG['date_to'],
freq=SIM_CFG['freq']))
# create nodes from user scenario and add o energy system
self.esys.add(*create_nodes(**json.loads(self.session.user_scenario.data.data)))
def test_add_to_oemof_model():
s = Sink({"bus_in": "foo"})
oemof_model = solph.EnergySystem()
component = s.add_to_oemof_model({"foo": solph.Bus(label="foo")},
oemof_model)
assert type(component) == solph.network.Sink
assert len(component.inputs) == 1
assert len(component.outputs) == 0
def test_results_with_old_dump():
"""
Test again with a stored dump created with v0.2.1dev (896a6d50)
"""
energysystem = solph.EnergySystem()
error = None
try:
energysystem.restore(dpath=os.path.dirname(os.path.realpath(__file__)),
filename='es_dump_test_2_1dev.oemof')
except UnpicklingError as e:
error = e
# Just making sure, the right error is raised. If the error message
# changes, the test has to be changed accordingly.
eq_(len(str(error)), 431)
# **************************************************
# Test again with a stored dump created with v0.2.3dev (896a6d50)
energysystem = solph.EnergySystem()
energysystem.restore(dpath=os.path.dirname(os.path.realpath(__file__)),
filename='es_dump_test_2_3dev.oemof')
# Note: This internal attribute is new in v.0.3.0, so the dump doesn't
# contain it for obvious reasons. Setting it manually to the correct
# value prevents the test from erroring.
energysystem._first_ungrouped_node_index_ = len(energysystem.nodes)
results = energysystem.results['main']
electricity_bus = views.node(results, 'electricity')
my_results = electricity_bus['sequences'].sum(axis=0).to_dict()
storage = energysystem.groups['storage']
my_results['storage_invest'] = results[(storage,
None)]['scalars']['invest']
stor_invest_dict = {
'storage_invest': 2040000,
(('electricity', 'demand'), 'flow'): 105867395,
(('electricity', 'excess_bel'), 'flow'): 211771291,
(('electricity', 'storage'), 'flow'): 2350931,
(('pp_gas', 'electricity'), 'flow'): 5148414,
(('pv', 'electricity'), 'flow'): 7488607,
(('storage', 'electricity'), 'flow'): 1880745,
(('wind', 'electricity'), 'flow'): 305471851
}
for key in stor_invest_dict.keys():
eq_(int(round(my_results[key])), int(round(stor_invest_dict[key])))
def get_model():
""" Creates solph.EnergySystem model. """
time_index = pd.date_range(
start=pd.to_datetime("2018-01-01 00:00:00"),
end=pd.to_datetime("2018-12-31 23:00:00"),
freq="H",
)
yield solph.EnergySystem(timeindex=time_index)
def test_add_to_oemof_model(self):
b = Battery({
"bus_in_and_out": "foo",
})
oemof_model = solph.EnergySystem()
component = b.add_to_oemof_model({"foo": solph.Bus(label="foo")}, oemof_model)
assert type(component) == solph.components.GenericStorage
assert len(component.inputs) == 1
assert len(component.outputs) == 1
def define_energy_system(nodes_data: dict):
"""
Creates an energy system.
Creates an energy system with the parameters defined in the given
.xlsx-file. The file has to contain a sheet called "energysystem",
which has to be structured as follows:
+-------------------+-------------------+-------------------+
|start_date |end_date |temporal resolution|
+-------------------+-------------------+-------------------+
|YYYY-MM-DD hh:mm:ss|YYYY-MM-DD hh:mm:ss|h |
+-------------------+-------------------+-------------------+
:param nodes_data: dictionary containing data from excel scenario
file
:type nodes_data: dict
:return: - **esys** (oemof.Energysystem) - oemof energy system
Christian Klemm - [email protected]
"""
from oemof import solph
# Importing energysystem parameters from the scenario
ts = next(nodes_data['energysystem'].iterrows())[1]
temp_resolution = ts['temporal resolution']
start_date = ts['start date']
end_date = ts['end date']
# creates time index
datetime_index = pd.date_range(start_date, end_date, freq=temp_resolution)
# initialisation of the energy system
esys = solph.EnergySystem(timeindex=datetime_index)
# defines a time series
nodes_data['timeseries'].set_index('timestamp', inplace=True)
nodes_data['timeseries'].index = pd.to_datetime(
nodes_data['timeseries'].index.values, utc=True)
nodes_data['timeseries'].index = \
pd.to_datetime(
nodes_data['timeseries'].index).tz_convert("Europe/Berlin")
nodes_data['weather data'].set_index('timestamp', inplace=True)
nodes_data['weather data'].index = pd.to_datetime(
nodes_data['weather data'].index.values, utc=True)
nodes_data['weather data'].index = \
pd.to_datetime(
nodes_data['weather data'].index).tz_convert("Europe/Berlin")
# returns logging info
logging.info(
'Date time index successfully defined:\n start date: ' +
str(start_date) + ',\n end date: ' + str(end_date) +
',\n temporal resolution: ' + str(temp_resolution))
# returns oemof energy system as result of this function
return esys
def test_update_states(self):
# simulate one smooth iteration
oemof_model = solph.EnergySystem(
timeindex=self.sim_params.date_time_index[0:1],
freq='{}min'.format(self.sim_params.interval_time)
)
# build energy model with two batteries, not connected to anything
bus1 = solph.Bus(label="bus1")
bus2 = solph.Bus(label="bus2")
oemof_model.add(bus1, bus2)
# one battery with loss_rate
b1 = Battery({
"name": "bat1",
"bus_in_and_out": "bus1",
"soc_init": 1,
"loss_rate": 12, # 0.5/h
"sim_params": self.sim_params
})
b1.prepare_simulation(None)
b1.add_to_oemof_model({"bus1": bus1}, oemof_model)
# one battery without loss rate
b2 = Battery({
"name": "bat2",
"bus_in_and_out": "bus2",
"loss_rate": 0,
"sim_params": self.sim_params
})
b2.prepare_simulation(None)
b2.add_to_oemof_model({"bus2": bus2}, oemof_model)
model_to_solve = solph.Model(oemof_model)
# solve model
oemof_results = model_to_solve.solve(solver='cbc', solve_kwargs={'tee': False})
assert oemof_results["Solver"][0]["Status"] == "ok"
results = solph.processing.results(model_to_solve)
assert results is not None
# update battery states
for battery in [b1, b2]:
battery.update_flows(results)
battery.update_states(results)
battery.update_var_costs()
battery.update_var_emissions()
battery.generate_results()
assert hasattr(battery, "states")
assert "soc" in battery.states.keys()
assert len(battery.states["soc"]) == self.sim_params.n_intervals
assert battery.states["soc"][self.sim_params.i_interval] == battery.soc
assert battery.soc > battery.soc_min
# check loss rate
assert b1.soc == 0.5
assert b2.soc == b2.soc_init
def initialise_energy_system(self):
if calendar.isleap(self.year):
number_of_time_steps = 8784
else:
number_of_time_steps = 8760
date_time_index = pd.date_range('1/1/{0}'.format(self.year),
periods=number_of_time_steps,
freq='H')
return solph.EnergySystem(timeindex=date_time_index)
def test_main_secure_with_xls_file(self):
my_es = solph.EnergySystem(timeindex=self.date_time_index)
main.main(2013, "de02", csv=False, es=my_es)
assert os.path.isfile(
os.path.join(
self.base_path,
"deflex",
"2013",
"results_cbc",
"deflex_2013_de02.esys",
))
def test_add_to_oemof_model():
gate = TrailerGateCascade({"bus_in": "bus_in", "bus_out": "bus_out"})
comp = gate.add_to_oemof_model(
{
"bus_in": solph.Bus(label="bus_in"),
"bus_out": solph.Bus(label="bus_out"),
}, solph.EnergySystem())
assert type(comp) == solph.Transformer
assert len(comp.inputs) == 1
assert len(comp.outputs) == 1
def test_model_scenario(self):
ip = os.path.join(self.base_path, "deflex", "2013",
"deflex_2013_de02.xls")
my_es = solph.EnergySystem(timeindex=self.date_time_index)
main.model_scenario(xls_file=ip,
name="test_02",
rmap="de",
year=2025,
es=my_es)
assert os.path.isfile(
os.path.join(self.base_path, "deflex", "2013", "results_cbc",
"test_02.esys"))
def postprocess(config_path, results_dir):
# open config
abs_path = os.path.dirname(os.path.abspath(os.path.join(__file__, '..')))
with open(config_path, 'r') as ymlfile:
cfg = yaml.load(ymlfile)
# restore energysystem
energysystem = solph.EnergySystem()
energysystem.restore(dpath=results_dir + '/optimisation_results',
filename='es.dump')
print_summed_heat(energysystem)
get_param_as_dict(energysystem)
def test_add_to_oemof_model():
heater = ElectricHeater({"bus_th": "bus_el", "bus_el": "bus_th"})
model = solph.EnergySystem()
component = heater.add_to_oemof_model(
{
"bus_el": solph.Bus(label="bus_el"),
"bus_th": solph.Bus(label="bus_th"),
}, model)
assert type(component) == solph.Transformer
assert len(component.inputs) == 1
assert len(component.outputs) == 1
class TestUpdate:
sim_params = SimulationParameters({"interval_time": 30, "n_intervals": 2})
sim_params.i_interval = 0
oemof_model = solph.EnergySystem(timeindex=sim_params.date_time_index[0:1],
freq='{}min'.format(
sim_params.interval_time))
def test_update_states(self):
# simulate one smooth iteration
# simulate a single hydrogen storage, not connected to anything
bus_in = solph.Bus(label="foo")
bus_out = solph.Bus(label="bar")
self.oemof_model.add(bus_in)
self.oemof_model.add(bus_out)
s = StorageH2({
"bus_in": "bus_in",
"bus_out": "bus_out",
"sim_params": self.sim_params
})
storage_h2_model = s.add_to_oemof_model(
{
"bus_in": bus_in,
"bus_out": bus_out
}, self.oemof_model)
self.oemof_model.add(storage_h2_model)
model_to_solve = solph.Model(self.oemof_model)
# solve model
oemof_results = model_to_solve.solve(solver='cbc',
solve_kwargs={'tee': False})
assert oemof_results["Solver"][0]["Status"] == "ok"
results = solph.processing.results(model_to_solve)
assert results is not None
# update storage states
s.update_states(results)
s.update_var_costs()
s.update_var_emissions()
s.generate_results()
assert hasattr(s, "states")
assert "storage_level" in s.states.keys()
assert "pressure" in s.states.keys()
assert len(s.states["storage_level"]) == self.sim_params.n_intervals
assert len(s.states["pressure"]) == self.sim_params.n_intervals
assert s.states["storage_level"][
self.sim_params.i_interval] == s.storage_level
assert s.states["pressure"][self.sim_params.i_interval] == s.pressure
assert s.storage_level > s.storage_level_min
def test_solph_transformer_attributes_before_dump_and_after_restore():
""" dump/restore should preserve all attributes of `solph.Transformer`
"""
energysystem = solph.EnergySystem()
energysystem.restore()
trsf_attr_before_dump = sorted([x for x in dir(PP_GAS) if '__' not in x])
trsf_attr_after_restore = sorted(
[x for x in dir(energysystem.groups['pp_gas']) if '__' not in x])
# Compare attributes before dump and after restore
eq_(trsf_attr_before_dump, trsf_attr_after_restore)
def test_add_to_oemof_model():
trailer = TrailerH2Delivery({
"bus_in": "bus_in",
"bus_out": "bus_out"
})
comp = trailer.add_to_oemof_model({
"bus_in": solph.Bus(label="bus_in"),
"bus_out": solph.Bus(label="bus_out"),
}, solph.EnergySystem())
assert type(comp) == solph.Transformer
assert len(comp.inputs) == 1
assert len(comp.outputs) == 1
