def __init__(self, *args, **kwargs):
super().__init__(*args,
**kwargs,
_facade_requires_=['from_bus', 'to_bus'])
self.capacity = kwargs.get('capacity')
self.loss = kwargs.get('loss', 0)
self.capacity_cost = kwargs.get('capacity_cost')
investment = self._investment()
self.inputs.update({self.from_bus: Flow(), self.to_bus: Flow()})
self.outputs.update({
self.from_bus:
Flow(nominal_value=self.capacity, investment=investment),
self.to_bus:
Flow(nominal_value=self.capacity, investment=investment)
})
self.conversion_factors.update({
(self.from_bus, self.to_bus):
sequence((1 - self.loss)),
(self.to_bus, self.from_bus):
sequence((1 - self.loss))
})
def __init__(self, *args, **kwargs):
super().__init__(*args,
**kwargs,
_facade_requires_=['from_bus', 'to_bus'])
self.capacity = kwargs.get('capacity')
self.efficiency = kwargs.get('efficiency', 1)
self.marginal_cost = kwargs.get('marginal_cost', 0)
self.capacity_cost = kwargs.get('capacity_cost')
self.input_edge_parameters = kwargs.get('input_edge_parameters', {})
self.output_edge_parameters = kwargs.get('output_edge_parameters', {})
self.conversion_factors.update({
self.from_bus: sequence(1),
self.to_bus: sequence(self.efficiency)
})
self.inputs.update({self.from_bus: Flow(**self.input_edge_parameters)})
self.outputs.update({
self.to_bus:
Flow(nominal_value=self.capacity,
variable_costs=self.marginal_cost,
investment=self._investment(),
**self.output_edge_parameters)
})
def test_linear_n1transformer_invest(self):
"""Constraint test of a LinearN1Transformer with Investment.
"""
bgas = Bus(label='gasBus')
bcoal = Bus(label='coalBus')
bel = Bus(label='electricityBus')
LinearN1Transformer(label='powerplant_gas_coal',
inputs={
bgas: Flow(),
bcoal: Flow()
},
outputs={
bel:
Flow(variable_costs=50,
investment=Investment(maximum=1000,
ep_costs=20))
},
conversion_factors={
bgas: 0.58,
bcoal: 0.2
})
self.compare_lp_files('linear_n1_transformer_invest.lp')
def test_fixed_source_invest_sink(self):
""" Wrong constraints for fixed source + invest sink w. `summed_max`.
"""
bel = Bus(label='electricityBus')
Source(label='wind',
outputs={
bel:
Flow(actual_value=[12, 16, 14],
nominal_value=1000000,
fixed=True,
fixed_costs=20)
})
Sink(label='excess',
inputs={
bel:
Flow(summed_max=2.3,
variable_costs=25,
max=0.8,
investment=Investment(ep_costs=500, maximum=10e5))
})
self.compare_lp_files('fixed_source_invest_sink.lp')
def test_linear_transformer_chp_invest(self):
"""Constraint test of a LinearTransformer with Investment (two outputs).
"""
bgas = Bus(label='gasBus')
bheat = Bus(label='heatBus')
bel = Bus(label='electricityBus')
LinearTransformer(label='chp_powerplant_gas',
inputs={
bgas:
Flow(variable_costs=50,
investment=Investment(maximum=1000,
ep_costs=20))
},
outputs={
bel: Flow(),
bheat: Flow()
},
conversion_factors={
bel: 0.4,
bheat: 0.5
})
self.compare_lp_files('linear_transformer_chp_invest.lp')
def build_solph_components(self):
"""
"""
if self.expandable:
raise NotImplementedError(
"Investment for reservoir class is not implemented.")
inflow = Source(
label=self.label + "-inflow",
outputs={
self:
Flow(nominal_value=self.aperture_area,
max=self.collectors_heat)
},
)
self.conversion_factors.update({
self.electrical_bus:
sequence(self.electrical_consumption *
(1 - self.additional_losses)),
self.heat_bus:
sequence(1 - self.additional_losses),
inflow:
sequence(1)
})
self.inputs.update({self.electrical_bus: Flow()})
self.outputs.update({self.heat_bus: Flow()})
self.subnodes = (inflow, )
def build_solph_components(self):
"""
"""
if self.expandable:
raise NotImplementedError(
"Investment for solar thermal collector facade has not been implemented yet."
)
inflow = Source(
label=self.label + "-inflow",
outputs={
self:
Flow(nominal_value=self.aperture_area,
max=self.collectors_heat)
},
)
self.conversion_factors.update({
self.electricity_in_bus:
sequence(self.electrical_consumption *
(1 - self.peripheral_losses)),
self.heat_out_bus:
sequence(1 - self.peripheral_losses),
inflow:
sequence(1)
})
self.inputs.update({self.electricity_in_bus: Flow()})
self.outputs.update({self.heat_out_bus: Flow()})
self.subnodes = (inflow, )
def build_solph_components(self):
"""
"""
self.conversion_factors.update({
self.fuel_bus:
sequence(1),
self.electricity_bus:
sequence(self.electric_efficiency),
self.heat_bus:
sequence(self.thermal_efficiency),
})
self.inputs.update({
self.fuel_bus:
Flow(variable_costs=self.carrier_cost, **self.input_parameters)
})
self.outputs.update({
self.electricity_bus:
Flow(
nominal_value=self._nominal_value(),
investment=self._investment(),
),
self.heat_bus:
Flow(),
})
def add_decentralised_heating_systems(table_collection, nodes, extra_regions):
logging.debug("Add decentralised_heating_systems to nodes dictionary.")
cs = table_collection["commodity_source"]["DE"]
dts = table_collection["demand_series"]
dh = table_collection["decentralised_heat"]
demand_regions = list({"DE_demand"}.union(set(extra_regions)))
for d_region in demand_regions:
region_name = d_region.replace("_demand", "")
if region_name not in dh:
data_name = "DE_demand"
else:
data_name = d_region
fuels = [f for f in dh[data_name].columns if f in dts[d_region]]
for fuel in fuels:
src = dh.loc["source", (data_name, fuel)]
bus_label = Label("bus", "commodity", src.replace(" ", "_"),
region_name)
# Check if source bus exists
if bus_label not in nodes:
create_fuel_bus_with_source(nodes, src, region_name, cs)
# Create heating bus as Bus
heat_bus_label = Label("bus", "heat", fuel.replace(" ", "_"),
region_name)
nodes[heat_bus_label] = Bus(label=heat_bus_label)
# Create heating system as Transformer
trsf_label = Label("trsf", "heat", fuel.replace(" ", "_"),
region_name)
efficiency = float(dh.loc["efficiency", (data_name, fuel)])
nodes[trsf_label] = Transformer(
label=trsf_label,
inputs={nodes[bus_label]: Flow()},
outputs={nodes[heat_bus_label]: Flow()},
conversion_factors={nodes[heat_bus_label]: efficiency},
)
# Create demand as Sink
d_heat_demand_label = Label("demand", "heat",
fuel.replace(" ", "_"), region_name)
nodes[d_heat_demand_label] = Sink(
label=d_heat_demand_label,
inputs={
nodes[heat_bus_label]:
Flow(
actual_value=dts[d_region, fuel],
nominal_value=1,
fixed=True,
)
},
)
def test_generic_storage_with_convex_invest_offset():
"""Offset value is given and nonconvex is False."""
with pytest.raises(AttributeError,
match=r"If `nonconvex` is `False`, the `offset`"):
bel = Bus()
components.GenericStorage(label='storage6',
inputs={bel: Flow()},
outputs={bel: Flow()},
invest_relation_input_capacity=1 / 6,
invest_relation_output_capacity=1 / 6,
investment=Investment(offset=10))
def add_shortage_excess(nodes):
bus_keys = [key for key in nodes.keys() if "bus" in key.cat]
for key in bus_keys:
excess_label = Label("excess", key.tag, key.subtag, key.region)
nodes[excess_label] = Sink(label=excess_label,
inputs={nodes[key]: Flow()})
shortage_label = Label("shortage", key.tag, key.subtag, key.region)
nodes[shortage_label] = Source(
label=shortage_label,
outputs={nodes[key]: Flow(variable_costs=900)},
)
def test_generic_storage_with_non_convex_invest_maximum():
"""No investment maximum at nonconvex investment."""
with pytest.raises(AttributeError,
match=r"Please provide an maximum investment value"):
bel = Bus()
components.GenericStorage(label='storage6',
inputs={bel: Flow()},
outputs={bel: Flow()},
invest_relation_input_capacity=1 / 6,
invest_relation_output_capacity=1 / 6,
investment=Investment(nonconvex=True))
def test_generic_storage_3():
"""Nominal value defined with investment model."""
bel = Bus()
components.GenericStorage(
label='storage4',
nominal_storage_capacity=45,
inputs={bel: Flow(nominal_value=23, variable_costs=10e10)},
outputs={bel: Flow(nominal_value=7.5, variable_costs=10e10)},
loss_rate=0.00,
initial_storage_level=0,
inflow_conversion_factor=1,
outflow_conversion_factor=0.8)
def test_generic_storage_with_non_convex_investment():
"""Tests error if `offset` and `existing` attribute are given."""
with pytest.raises(AttributeError,
match=r"Values for 'offset' and 'existing' are given"):
bel = Bus()
components.GenericStorage(label='storage4',
inputs={bel: Flow()},
outputs={bel: Flow()},
invest_relation_input_capacity=1 / 6,
invest_relation_output_capacity=1 / 6,
investment=Investment(nonconvex=True,
existing=5,
maximum=25))
def setUpClass(cls):
cls.period = 24
cls.es = EnergySystem(timeindex=pandas.date_range(
'2016-01-01', periods=cls.period, freq='H'))
# BUSSES
b_el1 = Bus(label="b_el1")
b_el2 = Bus(label="b_el2")
b_diesel = Bus(label='b_diesel', balanced=False)
cls.es.add(b_el1, b_el2, b_diesel)
# TEST DIESEL:
dg = Transformer(
label='diesel',
inputs={b_diesel: Flow(variable_costs=2)},
outputs={
b_el1: Flow(variable_costs=1,
investment=Investment(ep_costs=0.5))
},
conversion_factors={b_el1: 2},
)
batt = GenericStorage(
label='storage',
inputs={b_el1: Flow(variable_costs=3)},
outputs={b_el2: Flow(variable_costs=2.5)},
capacity_loss=0.00,
initial_capacity=0,
invest_relation_input_capacity=1 / 6,
invest_relation_output_capacity=1 / 6,
inflow_conversion_factor=1,
outflow_conversion_factor=0.8,
fixed_costs=35,
investment=Investment(ep_costs=0.4),
)
cls.demand_values = [100] * 8760
cls.demand_values[0] = 0.0
demand = Sink(label="demand_el",
inputs={
b_el2:
Flow(nominal_value=1,
actual_value=cls.demand_values,
fixed=True)
})
cls.es.add(dg, batt, demand)
cls.om = Model(cls.es)
cls.om.receive_duals()
cls.om.solve()
cls.mod = Model(cls.es)
cls.mod.solve()
def test_linear_transformer(self):
"""Constraint test of a LinearTransformer without Investment.
"""
bgas = Bus(label='gas')
bel = Bus(label='electricity')
LinearTransformer(
label='powerplantGas',
inputs={bgas: Flow()},
outputs={bel: Flow(nominal_value=10e10, variable_costs=50)},
conversion_factors={bel: 0.58})
self.compare_lp_files('linear_transformer.lp')
def __init__(self, *args, **kwargs):
super().__init__(*args,
**kwargs,
_facade_requires_=['bus', 'inflow', 'efficiency'])
self.storage_capacity = kwargs.get('storage_capacity')
self.capacity = kwargs.get('capacity')
self.efficiency = kwargs.get('efficiency')
self.nominal_capacity = self.storage_capacity
self.capacity_cost = kwargs.get('capacity_cost')
self.storage_capacity_cost = kwargs.get('storage_capacity_cost')
self.spillage = kwargs.get('spillage', True)
self.input_edge_parameters = kwargs.get('input_edge_parameters', {})
self.output_edge_parameters = kwargs.get('output_edge_parameters', {})
investment = self._investment()
reservoir_bus = Bus(label="reservoir-bus-" + self.label)
inflow = Source(label="inflow" + self.label,
outputs={
reservoir_bus:
Flow(nominal_value=1,
actual_value=self.inflow,
fixed=True)
})
if self.spillage:
f = Flow()
else:
f = Flow(actual_value=0, fixed=True)
spillage = Sink(label="spillage" + self.label,
inputs={reservoir_bus: f})
self.inputs.update({reservoir_bus: Flow(**self.input_edge_parameters)})
self.outputs.update({
self.bus:
Flow(investment=investment, **self.output_edge_parameters)
})
self.subnodes = (reservoir_bus, inflow, spillage)
def __init__(self, *args, **kwargs):
super().__init__(conversion_factor_full_condensation={},
*args,
**kwargs,
_facade_requires_=[
'carrier', 'electricity_bus', 'heat_bus',
'thermal_efficiency', 'electric_efficiency',
'condensing_efficiency'
])
self.carrier = kwargs.get('carrier')
self.carrier_cost = kwargs.get('carrier_cost', 0)
self.capacity = kwargs.get('capacity')
self.condensing_efficiency = sequence(self.condensing_efficiency)
self.marginal_cost = kwargs.get('marginal_cost', 0)
self.capacity_cost = kwargs.get('capacity_cost')
self.electricity_bus = kwargs.get('electricity_bus')
self.heat_bus = kwargs.get('heat_bus')
self.conversion_factors.update({
self.carrier:
sequence(1),
self.electricity_bus:
sequence(self.electric_efficiency),
self.heat_bus:
sequence(self.thermal_efficiency)
})
self.inputs.update(
{self.carrier: Flow(variable_cost=self.carrier_cost)})
self.outputs.update({
self.electricity_bus:
Flow(nominal_value=self.capacity,
variable_costs=self.marginal_cost,
investment=self._investment()),
self.heat_bus:
Flow()
})
self.conversion_factor_full_condensation.update(
{self.electricity_bus: self.condensing_efficiency})
def test_generic_storage_1():
"""Duplicate definition inflow."""
bel = Bus()
with pytest.raises(AttributeError, match="Overdetermined."):
components.GenericStorage(label='storage1',
inputs={bel: Flow(variable_costs=10e10)},
outputs={bel: Flow(variable_costs=10e10)},
loss_rate=0.00,
initial_storage_level=0,
invest_relation_input_output=1,
invest_relation_output_capacity=1,
invest_relation_input_capacity=1,
investment=Investment(),
inflow_conversion_factor=1,
outflow_conversion_factor=0.8)
def test_generic_storage_2():
"""Nominal value defined with investment model."""
bel = Bus()
with pytest.raises(AttributeError, match="If an investment object"):
components.GenericStorage(label='storage3',
nominal_storage_capacity=45,
inputs={bel: Flow(variable_costs=10e10)},
outputs={bel: Flow(variable_costs=10e10)},
loss_rate=0.00,
initial_storage_level=0,
invest_relation_input_capacity=1 / 6,
invest_relation_output_capacity=1 / 6,
inflow_conversion_factor=1,
outflow_conversion_factor=0.8,
investment=Investment(ep_costs=23))
def add_inverter(i, o, name, eta=1):
"""
The function returns an inverter with defined input i and output o flows a certain
label/name and an assigned efficiency Transfromer object
:param cost: i input flows
o output flows
name label of inverter as str
eta efficiency takes float values from 0-1
:return: sim_params dict parameter inputs for the energy system model
"""
return Transformer( label=name,
inputs={i: Flow()},
outputs={o: Flow()},
conversion_factors={o: eta} )
def test_max_source_min_sink(self):
"""
"""
bel = Bus(label='electricityBus')
Source(label='wind',
outputs={bel: Flow(nominal_value=54, max=(.85, .95, .61))})
Sink(label='minDemand',
inputs={
bel:
Flow(nominal_value=54, min=(.84, .94, .59), variable_costs=14)
})
self.compare_lp_files('max_source_min_sink.lp')
def initialize_basic_energysystem():
# initialize and provide data
datetimeindex = pd.date_range('1/1/2016', periods=24, freq='H')
filename = 'input_data.csv'
data = pd.read_csv(filename, sep=",")
energysystem = EnergySystem(timeindex=datetimeindex)
# buses
bcoal = Bus(label='coal', balanced=False)
bgas = Bus(label='gas', balanced=False)
bel = Bus(label='electricity')
energysystem.add(bcoal, bgas, bel)
# sources
energysystem.add(
Source(label='wind',
outputs={
bel:
Flow(actual_value=data['wind'],
nominal_value=66.3,
fixed=True)
}))
energysystem.add(
Source(label='pv',
outputs={
bel:
Flow(actual_value=data['pv'],
nominal_value=65.3,
fixed=True)
}))
# excess and shortage to avoid infeasibilies
energysystem.add(Sink(label='excess_el', inputs={bel: Flow()}))
energysystem.add(
Source(label='shortage_el', outputs={bel: Flow(variable_costs=200)}))
# demands (electricity/heat)
energysystem.add(
Sink(label='demand_el',
inputs={
bel:
Flow(nominal_value=85,
actual_value=data['demand_el'],
fixed=True)
}))
return bcoal, bgas, bel, energysystem
def __init__(self, *args, **kwargs):
super().__init__(*args,
**kwargs,
_facade_requires_=['bus', 'carrier', 'tech'])
self.carrier = kwargs.get('carrier')
self.profile = kwargs.get('profile')
self.capacity = kwargs.get('capacity')
self.capacity_potential = kwargs.get('capacity_potential')
self.marginal_cost = kwargs.get('marginal_cost', 0)
self.capacity_cost = kwargs.get('capacity_cost')
self.edge_parameters = kwargs.get('edge_parameters', {})
f = Flow(nominal_value=self.capacity,
variable_costs=self.marginal_cost,
actual_value=self.profile,
investment=self._investment(),
fixed=True,
**self.edge_parameters)
self.outputs.update({self.bus: f})
def add_conventional_mobility(table_collection, nodes):
"""
Parameters
----------
table_collection
nodes
Returns
-------
"""
mileage = table_collection["mobility_mileage"]["DE"]
spec_demand = table_collection["mobility_spec_demand"]["DE"]
energy_content = table_collection["mobility_energy_content"]["DE"]
energy_tp = mileage.mul(spec_demand).mul(energy_content.iloc[0]) / 10**6
energy = energy_tp.sum()
idx = table_collection["demand_series"].index
oil_key = Label("bus", "commodity", "oil", "DE")
for fuel in ["diesel", "petrol"]:
fix_value = pd.Series(energy / len(idx), index=idx, dtype=float)
fuel_label = Label("Usage", "mobility", fuel, "DE")
nodes[fuel_label] = Sink(
label=fuel_label,
inputs={nodes[oil_key]: Flow(actual_value=fix_value)},
)
return nodes
def build_solph_components(self):
"""
"""
self.nominal_storage_capacity = self.storage_capacity
self.inflow_conversion_factor = sequence(self.efficiency)
self.outflow_conversion_factor = sequence(self.efficiency)
# make it investment but don't set costs (set below for flow (power))
self.investment = self._investment()
if self.investment:
self.invest_relation_input_output = 1
for attr in ["invest_relation_input_output"]:
if getattr(self, attr) is None:
raise AttributeError(
("You need to set attr "
"`{}` "
"for component {}").format(attr, self.label))
# set capacity costs at one of the flows
fi = Flow(investment=Investment(
ep_costs=self.capacity_cost,
maximum=self.capacity_potential,
existing=self.capacity,
),
**self.input_parameters)
# set investment, but no costs (as relation input / output = 1)
fo = Flow(investment=Investment(),
variable_costs=self.marginal_cost,
**self.output_parameters)
# required for correct grouping in oemof.solph.components
self._invest_group = True
else:
fi = Flow(nominal_value=self._nominal_value(),
**self.input_parameters)
fo = Flow(nominal_value=self._nominal_value(),
variable_costs=self.marginal_cost,
**self.output_parameters)
self.inputs.update({self.bus: fi})
self.outputs.update({self.bus: fo})
self._set_flows()
def build_solph_components(self):
"""
"""
self.conversion_factors.update({
self.from_bus: sequence(1),
self.to_bus: sequence(self.efficiency),
})
self.inputs.update({self.from_bus: Flow(**self.input_parameters)})
self.outputs.update({
self.to_bus:
Flow(nominal_value=self._nominal_value(),
variable_costs=self.marginal_cost,
investment=self._investment(),
**self.output_parameters)
})
def test_storage(self):
"""
"""
bel = Bus(label='electricityBus')
Storage(label='storage',
inputs={bel: Flow(variable_costs=56)},
outputs={bel: Flow(variable_costs=24)},
nominal_capacity=10e4,
capacity_loss=0.13,
nominal_input_capacity_ratio=1 / 6,
nominal_output_capacity_ratio=1 / 6,
inflow_conversion_factor=0.97,
outflow_conversion_factor=0.86,
fixed_costs=35)
self.compare_lp_files('storage.lp')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs, _facade_requires_=['bus'])
self.bus = kwargs.get('bus')
self.marginal_cost = kwargs.get('marginal_cost')
self.inputs.update({self.bus: Flow(variable_costs=self.marginal_cost)})
def __init__(self, *args, **kwargs):
super().__init__(_facade_requires_=["bus"], *args, **kwargs)
self.bus = kwargs.get("bus")
self.marginal_cost = kwargs.get("marginal_cost")
self.inputs.update({self.bus: Flow(variable_costs=self.marginal_cost)})
