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 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 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 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 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 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 __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 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 test_fixed_source_variable_sink(self): """Constraint test with a fixed source and a variable sink. """ bel = Bus(label='electricityBus') Source(label='wind', outputs={ bel: Flow(actual_value=[.43, .72, .29], nominal_value=10e5, fixed=True, fixed_costs=20) }) Sink(label='excess', inputs={bel: Flow(variable_costs=40)}) self.compare_lp_files('fixed_source_variable_sink.lp')
def add_district_heating_systems(table_collection, nodes): logging.debug("Add district heating systems to nodes dictionary.") dts = table_collection["demand_series"] for region in dts["district heating"].columns: if dts["district heating"][region].sum() > 0: bus_label = Label("bus", "heat", "district", region) if bus_label not in nodes: nodes[bus_label] = Bus(label=bus_label) heat_demand_label = Label("demand", "heat", "district", region) nodes[heat_demand_label] = Sink( label=heat_demand_label, inputs={ nodes[bus_label]: Flow( actual_value=dts["district heating", region], nominal_value=1, fixed=True, ) }, )
def add_electricity_demand(table_collection, nodes): logging.debug("Add local electricity demand to nodes dictionary.") dts = table_collection["demand_series"] dts.columns = dts.columns.swaplevel() for region in dts["electrical_load"].columns: if dts["electrical_load"][region].sum() > 0: bus_label = Label("bus", "electricity", "all", region) if bus_label not in nodes: nodes[bus_label] = Bus(label=bus_label) elec_demand_label = Label("demand", "electricity", "all", region) nodes[elec_demand_label] = Sink( label=elec_demand_label, inputs={ nodes[bus_label]: Flow( actual_value=dts["electrical_load", region], nominal_value=1, fixed=True, ) }, )
def test_bus_to_sink_outputs_in_results_dataframe(self): bus = Bus(uid="bus") source = FS( label="source", outputs={bus: Flow(nominal_value=1, actual_value=0.5, fixed=True)}) sink = Sink(label="sink", inputs={bus: Flow(nominal_value=1)}) es = self.es om = OM(es) es.results = om.results() es.results[bus][sink] = [0.7] rdf = RDF(energy_system=es) try: eq_( rdf.loc[(slice(None), slice(None), slice(None), "sink"), :].val[0], 0.7, "Output from bus to sink does not have the correct value.") except KeyError: self.failed = True if self.failed: ok_( False, "Output from bus to sink does not appear in results dataframe." ) es.results[bus][bus] = [-1] rdf = RDF(energy_system=es) try: eq_( rdf.loc[(slice(None), slice(None), slice(None), "sink"), :].val[0], 0.7, "Output from bus to sink does not have the correct value.") except KeyError: self.failed = True if self.failed: ok_( False, "Output from bus (with duals) to sink " + "does not appear in results dataframe.")
def test_issue_74(self): Storage.optimization_options.update({'investment': True}) bus = Bus(uid="bus") store = Storage(uid="store", inputs=[bus], outputs=[bus], c_rate_out=0.1, c_rate_in=0.1) sink = Sink(uid="sink", inputs=[bus], val=[1]) es = self.es om = OM(es) om.objective.set_value(-1) es.results = om.results() try: es.dump() except AttributeError as ae: self.failed = ae if self.failed: ok_( False, "EnergySystem#dump should not raise `AttributeError`: \n" + " Error message: " + str(self.failed))
def test_invest_source_fixed_sink(self): """Constraint test with a fixed sink and a dispatch invest source. """ bel = Bus(label='electricityBus') Source(label='pv', outputs={ bel: Flow(max=[45, 83, 65], fixed_costs=20, variable_costs=13, investment=Investment(ep_costs=123)) }) Sink(label='excess', inputs={ bel: Flow(actual_value=[.5, .8, .3], nominal_value=10e4, fixed=True) }) self.compare_lp_files('invest_source_fixed_sink.lp')
# set timeindex and create data periods = 20 datetimeindex = pd.date_range('1/1/2019', periods=periods, freq='H') step = 5 demand = np.arange(0, step * periods, step) # set up EnergySystem energysystem = EnergySystem(timeindex=datetimeindex) b_gas = Bus(label='gas', balanced=False) b_el = Bus(label='electricity') energysystem.add(b_gas, b_el) energysystem.add( Source(label='shortage', outputs={b_el: Flow(variable_costs=1e6)})) energysystem.add( Sink(label='demand', inputs={b_el: Flow(nominal_value=1, actual_value=demand, fixed=True)})) conv_func = lambda x: 0.01 * x**2 in_breakpoints = np.arange(0, 110, 25) pwltf = solph.custom.PiecewiseLinearTransformer( label='pwltf', inputs={b_gas: solph.Flow(nominal_value=100, variable_costs=1)}, outputs={b_el: solph.Flow()}, in_breakpoints=in_breakpoints, conversion_function=conv_func, pw_repn='CC') # 'CC', 'DCC', 'INC', 'MC' # DCC TODO: Solve problem in outputlib with DCC
epc_pv = economics.annuity(capex=1000, n=20, wacc=0.05) epc_storage = economics.annuity(capex=100, n=5, wacc=0.05) pv = Source(label='pv', outputs={ elbus: Flow(actual_value=data['pv'], nominal_value=None, fixed=True, investment=Investment(ep_costs=epc_pv, maximum=30)) }) demand_el = Sink(label='demand_el', inputs={ elbus: Flow(nominal_value=1, actual_value=data['demand_el'], fixed=True) }) demand_th = Sink(label='demand_th', inputs={ thbus: Flow(nominal_value=1, actual_value=data['demand_th'], fixed=True) }) excess_el = Sink(label='excess_el', inputs={elbus: Flow(variable_costs=-0.005)}) shortage_el = Source(label='shortage_el', outputs={elbus: Flow(variable_costs=1e10)})
def test_dispatch_example(solver='cbc', periods=24*5): """Create an energy system and optimize the dispatch at least costs.""" Node.registry = None filename = os.path.join(os.path.dirname(__file__), 'input_data.csv') data = pd.read_csv(filename, sep=",") # ######################### create energysystem components ################ # resource buses bcoal = Bus(label='coal', balanced=False) bgas = Bus(label='gas', balanced=False) boil = Bus(label='oil', balanced=False) blig = Bus(label='lignite', balanced=False) # electricity and heat bel = Bus(label='b_el') bth = Bus(label='b_th') # an excess and a shortage variable can help to avoid infeasible problems excess_el = Sink(label='excess_el', inputs={bel: Flow()}) # shortage_el = Source(label='shortage_el', # outputs={bel: Flow(variable_costs=200)}) # sources ep_wind = economics.annuity(capex=1000, n=20, wacc=0.05) wind = Source(label='wind', outputs={bel: Flow( fix=data['wind'], investment=Investment(ep_costs=ep_wind, existing=100))}) ep_pv = economics.annuity(capex=1500, n=20, wacc=0.05) pv = Source(label='pv', outputs={bel: Flow( fix=data['pv'], investment=Investment(ep_costs=ep_pv, existing=80))}) # demands (electricity/heat) demand_el = Sink(label='demand_elec', inputs={bel: Flow(nominal_value=85, fix=data['demand_el'])}) demand_th = Sink(label='demand_therm', inputs={bth: Flow(nominal_value=40, fix=data['demand_th'])}) # power plants pp_coal = Transformer(label='pp_coal', inputs={bcoal: Flow()}, outputs={bel: Flow(nominal_value=20.2, variable_costs=25)}, conversion_factors={bel: 0.39}) pp_lig = Transformer(label='pp_lig', inputs={blig: Flow()}, outputs={bel: Flow(nominal_value=11.8, variable_costs=19)}, conversion_factors={bel: 0.41}) pp_gas = Transformer(label='pp_gas', inputs={bgas: Flow()}, outputs={bel: Flow(nominal_value=41, variable_costs=40)}, conversion_factors={bel: 0.50}) pp_oil = Transformer(label='pp_oil', inputs={boil: Flow()}, outputs={bel: Flow(nominal_value=5, variable_costs=50)}, conversion_factors={bel: 0.28}) # combined heat and power plant (chp) pp_chp = Transformer(label='pp_chp', inputs={bgas: Flow()}, outputs={bel: Flow(nominal_value=30, variable_costs=42), bth: Flow(nominal_value=40)}, conversion_factors={bel: 0.3, bth: 0.4}) # heatpump with a coefficient of performance (COP) of 3 b_heat_source = Bus(label='b_heat_source') heat_source = Source(label='heat_source', outputs={b_heat_source: Flow()}) cop = 3 heat_pump = Transformer(label='el_heat_pump', inputs={bel: Flow(), b_heat_source: Flow()}, outputs={bth: Flow(nominal_value=10)}, conversion_factors={ bel: 1/3, b_heat_source: (cop-1)/cop}) datetimeindex = pd.date_range('1/1/2012', periods=periods, freq='H') energysystem = EnergySystem(timeindex=datetimeindex) energysystem.add(bcoal, bgas, boil, bel, bth, blig, excess_el, wind, pv, demand_el, demand_th, pp_coal, pp_lig, pp_oil, pp_gas, pp_chp, b_heat_source, heat_source, heat_pump) # ################################ optimization ########################### # create optimization model based on energy_system optimization_model = Model(energysystem=energysystem) # solve problem optimization_model.solve(solver=solver) # write back results from optimization object to energysystem optimization_model.results() # ################################ results ################################ # generic result object results = processing.results(om=optimization_model) # subset of results that includes all flows into and from electrical bus # sequences are stored within a pandas.DataFrames and scalars e.g. # investment values within a pandas.Series object. # in this case the entry data['scalars'] does not exist since no investment # variables are used data = views.node(results, 'b_el') # generate results to be evaluated in tests comp_results = data['sequences'].sum(axis=0).to_dict() comp_results['pv_capacity'] = results[(pv, bel)]['scalars'].invest comp_results['wind_capacity'] = results[(wind, bel)]['scalars'].invest test_results = { (('wind', 'b_el'), 'flow'): 9239, (('pv', 'b_el'), 'flow'): 1147, (('b_el', 'demand_elec'), 'flow'): 7440, (('b_el', 'excess_el'), 'flow'): 6261, (('pp_chp', 'b_el'), 'flow'): 477, (('pp_lig', 'b_el'), 'flow'): 850, (('pp_gas', 'b_el'), 'flow'): 934, (('pp_coal', 'b_el'), 'flow'): 1256, (('pp_oil', 'b_el'), 'flow'): 0, (('b_el', 'el_heat_pump'), 'flow'): 202, 'pv_capacity': 44, 'wind_capacity': 246, } for key in test_results.keys(): eq_(int(round(comp_results[key])), int(round(test_results[key])))
demand_timeseries[-5:] = 1 heat_feedin_timeseries = np.zeros(periods) heat_feedin_timeseries[:10] = 1 energysystem = EnergySystem(timeindex=datetimeindex) bus_heat = Bus(label='bus_heat') heat_source = Source( label='heat_source', outputs={bus_heat: Flow(nominal_value=1, fix=heat_feedin_timeseries)}) shortage = Source(label='shortage', outputs={bus_heat: Flow(variable_costs=1e6)}) excess = Sink(label='excess', inputs={bus_heat: Flow()}) heat_demand = Sink( label='heat_demand', inputs={bus_heat: Flow(nominal_value=1, fix=demand_timeseries)}) thermal_storage = facades.StratifiedThermalStorage( label='thermal_storage', bus=bus_heat, diameter=input_data[ 'diameter'], # TODO: setting to zero should give an error temp_h=input_data['temp_h'], temp_c=input_data['temp_c'], temp_env=input_data['temp_env'], u_value=u_value, expandable=True,
Flow(actual_value=data['wind'], nominal_value=66.3, fixed=True) }) pv = Source(label='pv', outputs={ bus_el: Flow(actual_value=data['pv'], nominal_value=65.3, fixed=True) }) # Electricity demand demand_el = Sink(label='demand_el', inputs={ bus_el: Flow(nominal_value=85, actual_value=data['demand_el'], fixed=True) }) # power plants pp_coal = Transformer( label='pp_coal', inputs={bus_coal: Flow()}, outputs={bus_el: Flow(nominal_value=40, emission_factor=0.335)}, conversion_factors={bus_el: 0.39}) storage_el = GenericStorage(label='storage_el', nominal_storage_capacity=1000, inputs={bus_el: Flow(nominal_value=200)}, outputs={bus_el: Flow(nominal_value=200)},
es.add( Source( label="gen_0", outputs={b_el0: Flow(nominal_value=100, variable_costs=50)}, ) ) es.add( Source( label="gen_1", outputs={b_el1: Flow(nominal_value=100, variable_costs=25)}, ) ) es.add(Sink(label="load", inputs={b_el2: Flow(nominal_value=100, fix=[1, 1])})) m = Model(energysystem=es) # m.write('lopf.lp', io_options={'symbolic_solver_labels': True}) m.solve(solver="cbc", solve_kwargs={"tee": True, "keepfiles": False}) m.results() graph = create_nx_graph(es) draw_graph( graph, plot=True,
# ######################### create energysystem components ################ # resource buses bcoal = Bus(label='coal', balanced=False) bgas = Bus(label='gas', balanced=False) boil = Bus(label='oil', balanced=False) blig = Bus(label='lignite', balanced=False) # electricity and heat bel = Bus(label='bel') bth = Bus(label='bth') energysystem.add(bcoal, bgas, boil, blig, bel, bth) # an excess and a shortage variable can help to avoid infeasible problems energysystem.add(Sink(label='excess_el', inputs={bel: Flow()})) # shortage_el = Source(label='shortage_el', # outputs={bel: Flow(variable_costs=200)}) # 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={
b_1: Flow(investment=Investment()), b_0: Flow(investment=Investment())}, conversion_factors={ (b_0, b_1): 0.95, (b_1, b_0): 0.9})) es.add(Source(label="gen_0", outputs={ b_0: Flow(nominal_value=100, variable_costs=50)})) es.add(Source(label="gen_1", outputs={ b_1: Flow(nominal_value=100, variable_costs=50)})) es.add(Sink(label="load_0", inputs={ b_0: Flow(nominal_value=150, actual_value=[0, 1], fixed=True)})) es.add(Sink(label="load_1", inputs={ b_1: Flow(nominal_value=150, actual_value=[1, 0], fixed=True)})) m = Model(energysystem=es) # m.write('transshipment.lp', io_options={'symbolic_solver_labels': True}) m.solve(solver='cbc', solve_kwargs={'tee': True, 'keepfiles': False}) m.results()
# set timeindex and create data periods = 20 datetimeindex = pd.date_range('1/1/2019', periods=periods, freq='H') step = 5 demand = np.arange(0, step * periods, step) # set up EnergySystem energysystem = EnergySystem(timeindex=datetimeindex) b_gas = Bus(label='gas', balanced=False) b_el = Bus(label='electricity') energysystem.add(b_gas, b_el) energysystem.add( Source(label='shortage', outputs={b_el: Flow(variable_costs=1e6)})) energysystem.add( Sink(label='demand', inputs={b_el: Flow(nominal_value=1, fix=demand, fixed=0)})) conv_func = lambda x: 0.01 * x**2 in_breakpoints = np.arange(0, 110, 25) pwltf = solph.custom.PiecewiseLinearTransformer( label='pwltf', inputs={b_gas: solph.Flow(nominal_value=100, variable_costs=1)}, outputs={b_el: solph.Flow()}, in_breakpoints=in_breakpoints, conversion_function=conv_func, pw_repn='CC') # 'CC', 'DCC', 'INC', 'MC' # DCC TODO: Solve problem in outputlib with DCC energysystem.add(pwltf)
'pp_bio': { 'epc': economics.annuity(capex=1000, n=10, wacc=0.05), 'var': 50 }, 'storage': { 'epc': economics.annuity(capex=1500, n=10, wacc=0.05), 'var': 0 } } ################################################################# # Create oemof object ################################################################# bel = Bus(label='micro_grid') Sink(label='excess', inputs={bel: Flow(variable_costs=10e3)}) Source(label='pp_wind', outputs={ bel: Flow(nominal_value=None, fixed=True, actual_value=timeseries['wind'], investment=Investment(ep_costs=costs['pp_wind']['epc'])) }) Source(label='pp_pv', outputs={ bel: Flow(nominal_value=None, fixed=True,
def run_add_constraints_example(solver='cbc', nologg=False): if not nologg: logging.basicConfig(level=logging.INFO) # ##### creating an oemof solph optimization model, nothing special here ## # create an energy system object for the oemof solph nodes es = EnergySystem(timeindex=pd.date_range('1/1/2017', periods=4, freq='H')) # add some nodes boil = Bus(label="oil", balanced=False) blig = Bus(label="lignite", balanced=False) b_el = Bus(label="b_el") es.add(boil, blig, b_el) sink = Sink(label="Sink", inputs={ b_el: Flow(nominal_value=40, actual_value=[0.5, 0.4, 0.3, 1], fixed=True) }) pp_oil = Transformer( label='pp_oil', inputs={boil: Flow()}, outputs={b_el: Flow(nominal_value=50, variable_costs=25)}, conversion_factors={b_el: 0.39}) pp_lig = Transformer( label='pp_lig', inputs={blig: Flow()}, outputs={b_el: Flow(nominal_value=50, variable_costs=10)}, conversion_factors={b_el: 0.41}) es.add(sink, pp_oil, pp_lig) # create the model om = Model(energysystem=es) # add specific emission values to flow objects if source is a commodity bus for s, t in om.flows.keys(): if s is boil: om.flows[s, t].emission_factor = 0.27 # t/MWh if s is blig: om.flows[s, t].emission_factor = 0.39 # t/MWh emission_limit = 60e3 # add the outflow share om.flows[(boil, pp_oil)].outflow_share = [1, 0.5, 0, 0.3] # Now we are going to add a 'sub-model' and add a user specific constraint # first we add a pyomo Block() instance that we can use to add our # constraints. Then, we add this Block to our previous defined # Model instance and add the constraints. myblock = po.Block() # create a pyomo set with the flows (i.e. list of tuples), # there will of course be only one flow inside this set, the one we used to # add outflow_share myblock.MYFLOWS = po.Set(initialize=[ k for (k, v) in om.flows.items() if hasattr(v, 'outflow_share') ]) # pyomo does not need a po.Set, we can use a simple list as well myblock.COMMODITYFLOWS = [ k for (k, v) in om.flows.items() if hasattr(v, 'emission_factor') ] # add the sub-model to the oemof Model instance om.add_component('MyBlock', myblock) def _inflow_share_rule(m, s, e, t): """pyomo rule definition: Here we can use all objects from the block or the om object, in this case we don't need anything from the block except the newly defined set MYFLOWS. """ expr = (om.flow[s, e, t] >= om.flows[s, e].outflow_share[t] * sum(om.flow[i, o, t] for (i, o) in om.FLOWS if o == e)) return expr myblock.inflow_share = po.Constraint(myblock.MYFLOWS, om.TIMESTEPS, rule=_inflow_share_rule) # add emission constraint myblock.emission_constr = po.Constraint( expr=(sum(om.flow[i, o, t] for (i, o) in myblock.COMMODITYFLOWS for t in om.TIMESTEPS) <= emission_limit)) # solve and write results to dictionary # you may print the model with om.pprint() om.solve(solver=solver) logging.info("Successfully finished.")
def diesel_only(mode, feedin, initial_batt_cap, cost, iterstatus=None, PV_source=True, storage_source=True, logger=False): if logger == 1: logger.define_logging() ##################################### Initialize the energy system################################################## # times = pd.DatetimeIndex(start='04/01/2017', periods=10, freq='H') times = feedin.index energysystem = EnergySystem(timeindex=times) # switch on automatic registration of entities of EnergySystem-object=energysystem Node.registry = energysystem # add components b_el = Bus(label='electricity') b_dc = Bus(label='electricity_dc') b_oil = Bus(label='diesel_source') demand_feedin = feedin['demand_el'] Sink(label='demand', inputs={ b_el: Flow(actual_value=demand_feedin, nominal_value=1, fixed=True) }) Sink(label='excess', inputs={b_el: Flow()}) Source(label='diesel', outputs={b_oil: Flow()}) generator1 = custom.DieselGenerator( label='pp_oil_1', fuel_input={b_oil: Flow(variable_costs=cost['pp_oil_1']['var'])}, electrical_output={ b_el: Flow(nominal_value=186, min=0.3, max=1, nonconvex=NonConvex(om_costs=cost['pp_oil_1']['o&m']), fixed_costs=cost['pp_oil_1']['fix']) }, fuel_curve={ '1': 42, '0.75': 33, '0.5': 22, '0.25': 16 }) generator2 = custom.DieselGenerator( label='pp_oil_2', fuel_input={b_oil: Flow(variable_costs=cost['pp_oil_2']['var'])}, electrical_output={ b_el: Flow(nominal_value=186, min=0.3, max=1, nonconvex=NonConvex(om_costs=cost['pp_oil_2']['o&m']), fixed_costs=cost['pp_oil_2']['fix'], variable_costs=0) }, fuel_curve={ '1': 42, '0.75': 33, '0.5': 22, '0.25': 16 }) generator3 = custom.DieselGenerator( label='pp_oil_3', fuel_input={b_oil: Flow(variable_costs=cost['pp_oil_3']['var'])}, electrical_output={ b_el: Flow(nominal_value=320, min=0.3, max=1, nonconvex=NonConvex(om_costs=cost['pp_oil_3']['o&m']), fixed_costs=cost['pp_oil_3']['fix'], variable_costs=0) }, fuel_curve={ '1': 73, '0.75': 57, '0.5': 38, '0.25': 27 }) # List all generators in a list called gen_set gen_set = [generator1, generator2, generator3] sim_params = get_sim_params(cost) if mode == 'simulation': nominal_cap_pv = sim_params['pv']['nominal_capacity'] inv_pv = None nominal_cap_batt = sim_params['storage']['nominal_capacity'] inv_batt = None elif mode == 'investment': nominal_cap_pv = None inv_pv = sim_params['pv']['investment'] nominal_cap_batt = None inv_batt = sim_params['storage']['investment'] else: raise ( UserWarning, 'Energysystem cant be build. Check if mode is spelled correctely. ' 'It can be either [simulation] or [investment]') if PV_source == 1: PV = Source(label='PV', outputs={ b_dc: Flow(nominal_value=nominal_cap_pv, fixed_costs=cost['pv']['fix'], actual_value=feedin['PV'], fixed=True, investment=inv_pv) }) else: PV = None if storage_source == 1: storage = components.GenericStorage( label='storage', inputs={b_dc: Flow()}, outputs={ b_dc: Flow(variable_costs=cost['storage']['var'], fixed_costs=cost['storage']['fix']) }, nominal_capacity=nominal_cap_batt, capacity_loss=0.00, initial_capacity=initial_batt_cap, nominal_input_capacity_ratio=0.546, nominal_output_capacity_ratio=0.546, inflow_conversion_factor=0.92, outflow_conversion_factor=0.92, capacity_min=0.5, capacity_max=1, investment=inv_batt, initial_iteration=iterstatus) else: storage = None if storage_source == 1 or PV_source == 1: inverter1 = add_inverter(b_dc, b_el, 'Inv_pv') ################################# optimization ############################ # create Optimization model based on energy_system logging.info("Create optimization problem") m = Model(energysystem) ################################# constraints ############################ sr_requirement = 0.2 sr_limit = demand_feedin * sr_requirement rm_requirement = 0.4 rm_limit = demand_feedin * rm_requirement constraints.spinning_reserve_constraint(m, sr_limit, groups=gen_set, storage=storage) # constraints.n1_constraint(m, demand_feedin, groups=gen_set) constraints.gen_order_constraint(m, groups=gen_set) constraints.rotating_mass_constraint(m, rm_limit, groups=gen_set, storage=storage) return [m, gen_set]
data = pd.read_csv(filename, sep=",") # ######################### create energysystem components ################ # resource buses bcoal = Bus(label="coal", balanced=False) bgas = Bus(label="gas", balanced=False) boil = Bus(label="oil", balanced=False) # electricity and heat bel = Bus(label="bel") energysystem.add(bcoal, bgas, boil, bel) # an excess and a shortage variable can help to avoid infeasible problems energysystem.add(Sink(label="excess_el", inputs={bel: Flow()})) shortage_el = Source(label='shortage_el', outputs={bel: Flow(variable_costs=20000)}, conversion_factors={bel: 0.33}) energysystem.add(shortage_el) # sources energysystem.add( Source(label="pv", outputs={bel: Flow(fix=data["pv"], nominal_value=256e3)})) # demands (electricity/heat) energysystem.add( Sink( label="demand_el",
energysystem = EnergySystem(timeindex=datetimeindex) bus_heat = Bus(label='bus_heat') heat_source = Source(label='heat_source', outputs={ bus_heat: Flow(nominal_value=1, actual_value=heat_feedin_timeseries, fixed=True) }) shortage = Source(label='shortage', outputs={bus_heat: Flow(variable_costs=1e6)}) excess = Sink(label='excess', inputs={bus_heat: Flow()}) heat_demand = Sink(label='heat_demand', inputs={ bus_heat: Flow(nominal_value=1, actual_value=demand_timeseries, fixed=True) }) thermal_storage = GenericStorage( label='thermal_storage', inputs={bus_heat: Flow(nominal_value=maximum_heat_flow_charging)}, outputs={ bus_heat: Flow(nominal_value=maximum_heat_flow_discharging,
conversion_factors={thbus: COP}) """ cop = 3 heat_pump = Transformer( label='heat_pump', inputs={elbus: Flow()}, outputs={thbus: Flow()}, conversion_factors={elbus: cop}) logging.info('Necessary components created') # Creating the demands eldemand = Sink(label='eldemand', inputs={elbus: Flow(nominal_value=85, actual_value=data['demand_el'], fixed=True)}) thdemand = Sink(label='thdemand', inputs={thbus: Flow(nominal_value=40, actual_value=data['demand_th'], fixed=True)}) # Creating the excess sink and the shortage source excess_el = Sink(label='excess_el', inputs={elbus: Flow()}) shortage_el = Source(label='shortage_el', outputs={elbus: Flow(variable_costs=1e20)}) # Adding all the components to the energy system es.add(excess_el, shortage_el, thdemand, eldemand, heat_pump, el_storage, chp_gas, pv, gas, gasbus, thbus, elbus) # Create the model for optimization and run the optimization
# resources bgas = Bus(label='bgas') rgas = Source(label='rgas', outputs={bgas: Flow()}) # heat bth = Bus(label='bth') # dummy source at high costs that serves the residual load source_th = Source(label='source_th', outputs={bth: Flow(variable_costs=1000)}) demand_th = Sink(label='demand_th', inputs={ bth: Flow(fixed=True, actual_value=data['demand_th'], nominal_value=200) }) # power bus and components bel = Bus(label='bel') demand_el = Sink(label='demand_el', inputs={ bel: Flow(fixed=True, actual_value=data['demand_el'], nominal_value=100) })