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_transmission_lines_between_electricity_nodes(table_collection, nodes): logging.debug("Add transmission lines to nodes dictionary.") power_lines = table_collection["transmission"]["electrical"] for idx, values in power_lines.iterrows(): b1, b2 = idx.split("-") lines = [(b1, b2), (b2, b1)] for line in lines: line_label = Label("line", "electricity", line[0], line[1]) bus_label_in = Label("bus", "electricity", "all", line[0]) bus_label_out = Label("bus", "electricity", "all", line[1]) if bus_label_in not in nodes: raise ValueError( "Bus {0} missing for power line from {0} to {1}".format( bus_label_in, bus_label_out)) if bus_label_out not in nodes: raise ValueError( "Bus {0} missing for power line from {0} to {1}".format( bus_label_out, bus_label_in)) if values.capacity != float("inf"): logging.debug("Line {0} has a capacity of {1}".format( line_label, values.capacity)) nodes[line_label] = Transformer( label=line_label, inputs={nodes[bus_label_in]: Flow()}, outputs={ nodes[bus_label_out]: Flow(nominal_value=values.capacity) }, conversion_factors={ nodes[bus_label_out]: values.efficiency }, ) else: logging.debug( "Line {0} has no capacity limit".format(line_label)) nodes[line_label] = Transformer( label=line_label, inputs={nodes[bus_label_in]: Flow()}, outputs={nodes[bus_label_out]: Flow()}, conversion_factors={ nodes[bus_label_out]: values.efficiency }, )
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 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 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 add_inverter(i, o, name, eta=1): return Transformer(label=name, inputs={i: Flow()}, outputs={o: Flow()}, conversion_factors={o: eta})
# Creating the necessary buses elbus = Bus(label='electricity') gasbus = Bus(label='gas') thbus = Bus(label='heat') logging.info('Necessary buses for the system created') # Now creating the necessary components for the system gas = Source(label='gas_com', outputs={gasbus: Flow()}) pv = Source(label='pv', outputs={elbus: Flow(nominal_value=65, fixed=True, actual_value=data['pv'])}) chp_gas = Transformer(label='chp_gas', inputs={gasbus: Flow()}, outputs={elbus: Flow(nominal_value=55), thbus: Flow(nominal_value=55)}, conversion_factors={elbus: 0.3, thbus: 0.4}) el_storage = GenericStorage(label='el_storage', nominal_storage_capacity=1000, inputs={elbus: Flow(nominal_value=9)}, outputs={elbus: Flow(nominal_value=9)}, loss_rate=0.01, initial_storage_level=0, max_storage_level=0.9, inflow_conversion_factor=0.9, outflow_conversion_factor=0.9) """ COP = np.random.uniform(low=3.0, high=5.0, size=(8760,))
shortage = Source(label='shortage_el', outputs={bus_el: Flow(variable_costs=1e12)}) # create demand demand_el = Sink(label='demand_el', inputs={bus_el: Flow(nominal_value=1, actual_value=data['demand_el'], fixed=True)}) epc_coal = economics.annuity(capex=1500000, n=50, wacc=0.05) epc_gas = economics.annuity(capex=900000, n=20, wacc=0.05) # create power plants pp_coal = Transformer(label='pp_coal', inputs={bus_coal: Flow()}, outputs={bus_el: Flow(nominal_value=5000, variable_costs=25)}, conversion_factors={bus_el: 0.39}) pp_gas = Transformer(label='pp_gas', inputs={bus_gas: Flow()}, outputs={bus_el: Flow(nominal_value=2000, variable_costs=40)}, conversion_factors={bus_el: 0.50}) # add all components to energysystem energysystem.add(bus_coal, bus_gas, bus_el, wind, pv, excess, shortage, demand_el, pp_coal, pp_gas)
inputs={ bel: Flow(nominal_value=85, actual_value=data['demand_el'], fixed=True) })) energysystem.add( Sink(label='demand_th', inputs={ bth: Flow(nominal_value=40, actual_value=data['demand_th'], fixed=True) })) # power plants energysystem.add( Transformer(label='pp_coal', inputs={bcoal: Flow()}, outputs={bel: Flow(nominal_value=20.2, variable_costs=25)}, conversion_factors={bel: 0.39})) energysystem.add( Transformer(label='pp_lig', inputs={blig: Flow()}, outputs={bel: Flow(nominal_value=11.8, variable_costs=19)}, conversion_factors={bel: 0.41})) energysystem.add( Transformer(label='pp_gas', inputs={bgas: Flow()}, outputs={bel: Flow(nominal_value=41, variable_costs=40)}, conversion_factors={bel: 0.50})) energysystem.add(
return bcoal, bgas, bel, energysystem bcoal, bgas, bel, energysystem = initialize_basic_energysystem() # power plants energysystem.add( solph.Transformer( label='pp_coal', inputs={bcoal: Flow()}, outputs={bel: Flow(nominal_value=20.2, variable_costs=25)}, conversion_factors={bel: 0.5})) energysystem.add( Transformer(label='pp_gas', inputs={bgas: Flow()}, outputs={bel: Flow(nominal_value=41, variable_costs=40)}, conversion_factors={bel: 0.50})) energysystem.add( solph.custom.OffsetTransformer(label='ostf', inputs={ bgas: solph.Flow(nominal_value=60, min=0.5, max=1.0, nonconvex=solph.NonConvex()) }, outputs={bel: solph.Flow()}, coefficients={(bgas, bel): [20, 0.5]})) # create the model
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])))
def add_power_and_heat_plants(table_collection, nodes, extra_regions): trsf = table_collection["transformer"] cs = table_collection["commodity_source"]["DE"] for region in trsf.columns.get_level_values(0).unique(): bus_heat = Label("bus", "heat", "district", region) bus_elec = Label("bus", "electricity", "all", region) for fuel in trsf[region].columns: # Connect to global fuel bus if not defined as extra region if region in extra_regions: bus_fuel = Label("bus", "commodity", fuel.replace(" ", "_"), region) create_fuel_bus_with_source(nodes, fuel, region, cs) else: bus_fuel = Label("bus", "commodity", fuel.replace(" ", "_"), "DE") if bus_fuel not in nodes: create_fuel_bus_with_source(nodes, fuel.replace(" ", "_"), "DE", cs) params = trsf[region, fuel] # Create power plants as 1x1 Transformer if params.capacity > 0: # Define output flow with or without summed_max attribute if params.limit_elec_pp == float("inf"): outflow = Flow(nominal_value=params.capacity) else: smax = params.limit_elec_pp / params.capacity outflow = Flow(nominal_value=params.capacity, summed_max=smax) trsf_label = Label("trsf", "pp", fuel.replace(" ", "_"), region) nodes[trsf_label] = Transformer( label=trsf_label, inputs={nodes[bus_fuel]: Flow()}, outputs={nodes[bus_elec]: outflow}, conversion_factors={nodes[bus_elec]: params.efficiency}, ) # Create chp plants as 1x2 Transformer if params.capacity_heat_chp > 0: trsf_label = Label("trsf", "chp", fuel.replace(" ", "_"), region) smax = (params.limit_heat_chp / params.efficiency_heat_chp) / ( params.capacity_heat_chp / params.efficiency_heat_chp) nodes[trsf_label] = Transformer( label=trsf_label, inputs={ nodes[bus_fuel]: Flow( nominal_value=(params.capacity_heat_chp / params.efficiency_heat_chp), summed_max=smax, ) }, outputs={ nodes[bus_elec]: Flow(), nodes[bus_heat]: Flow(), }, conversion_factors={ nodes[bus_elec]: params.efficiency_elec_chp, nodes[bus_heat]: params.efficiency_heat_chp, }, ) # Create heat plants as 1x1 Transformer if params.capacity_hp > 0: trsf_label = Label("trsf", "hp", fuel.replace(" ", "_"), region) smax = params.limit_hp / params.capacity_hp nodes[trsf_label] = Transformer( label=trsf_label, inputs={nodes[bus_fuel]: Flow()}, outputs={ nodes[bus_heat]: Flow(nominal_value=params.capacity_hp, summed_max=smax) }, conversion_factors={nodes[bus_heat]: params.efficiency_hp}, )
Sink, Source, Transformer, Bus, Flow, GenericStorage, ) from oemof_visio import ESGraphRenderer es = EnergySystem() bus_ac = Bus(label="AC") bus_dc = Bus(label="DC") wind = Source(label="wind", outputs={bus_ac: Flow()}) pv = Source(label="pv", outputs={bus_dc: Flow()}) demand_el = Sink(label="demand_el", inputs={bus_ac: Flow()}) storage_el = GenericStorage( label="storage_el", inputs={bus_ac: Flow()}, outputs={bus_ac: Flow()}, ) pv_converter = Transformer(label="chp_gas", inputs={bus_dc: Flow()}, outputs={bus_ac: Flow()}) excess_el = Sink(label="excess_el", inputs={bus_ac: Flow()}) es.add(bus_ac, bus_dc, wind, pv, demand_el, storage_el, excess_el, pv_converter) gr = ESGraphRenderer(energy_system=es, filepath="energy_system", img_format="png") gr.view()
# Create oemof objects ########################################################################## bel = Bus(label="bel") bgas = Bus(label="bgas") bth = Bus(label="bth") Source(label="gas", outputs={bgas: Flow(variable_costs=35)}) Transformer(label='boiler', inputs={bgas: Flow()}, outputs={ bth: Flow(nominal_value=500, variable_cost=50, nonconvex=NonConvex()) }, conversion_factors={bth: 0.9}) Transformer(label='chp', inputs={bgas: Flow()}, outputs={ bel: Flow(nominal_value=300, min=0.5, nonconvex=NonConvex()), bth: Flow() }, conversion_factors={ bth: 0.3, bel: 0.45 })
def run_basic_energysystem(args): n_val_wind = args[0] n_val_solar = args[1] start = time.time() # initialize and provide data 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=n_val_wind, fixed=True) })) energysystem.add( Source(label='pv', outputs={ bel: Flow(actual_value=data['pv'], nominal_value=n_val_solar, 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=65, actual_value=data['demand_el'], fixed=True) })) # power plants energysystem.add( Transformer(label='pp_coal', inputs={bcoal: Flow()}, outputs={bel: Flow(nominal_value=20.2, variable_costs=25)}, conversion_factors={bel: 0.39})) energysystem.add( Transformer(label='pp_gas', inputs={bgas: Flow()}, outputs={bel: Flow(nominal_value=41, variable_costs=40)}, conversion_factors={bel: 0.50})) # create optimization model based on energy_system optimization_model = Model(energysystem=energysystem) # solve problem optimization_model.solve(solver=solver, solve_kwargs={ 'tee': False, 'keepfiles': False }) results = outputlib.processing.results(optimization_model) results_el = outputlib.views.node(results, 'electricity') el_sequences = results_el['sequences'] el_prod = el_sequences[[(('wind', 'electricity'), 'flow'), (('pv', 'electricity'), 'flow'), (('pp_coal', 'electricity'), 'flow'), (('pp_gas', 'electricity'), 'flow'), (('shortage_el', 'electricity'), 'flow')]] inputs = outputlib.processing.convert_keys_to_strings( outputlib.processing.parameter_as_dict(optimization_model)) nom_vals = [[key, value['scalars']['nominal_value']] for key, value in inputs.items() if 'nominal_value' in value['scalars']] nom_vals = pd.DataFrame(nom_vals, columns=['flow', 'nominal_value']) summed_flows = [ (key, value['sequences'].sum()[0]) for key, value in outputlib.processing.convert_keys_to_strings( results).items() ] summed_flows = pd.DataFrame(summed_flows, columns=['flow', 'summed_flows']) end = time.time() print('simulation lasted: ', end - start, 'sec') return el_prod
bgas = Bus(label='bgas') Source(label='gas', outputs={ bgas: Flow()}) Sink(label='demand_th', inputs={ bth: Flow(actual_value=timeseries['demand_th'], fixed=True, nominal_value=100)}) Transformer(label='pth', inputs={ bel: Flow()}, outputs={ bth: Flow(nominal_value=30)}, conversion_factors={bth: 0.99}) Transformer(label='chp', inputs={ bgas: Flow(variable_costs=80)}, outputs={ bel: Flow(nominal_value=40), bth: Flow()}, conversion_factors={bel: 0.4, bth: 0.4}) Source(label='boiler_bio', outputs={ bth: Flow(nominal_value=100,
x = np.arange(0, periods, 1) demand_ts = 0.5 * np.cos(x) + 1 pv_ts = 0.5 * np.sin(x) + 0.5 es = EnergySystem(timeindex=timeindex) bus_el = Bus(label='electricity_bus') bus_gas = Bus(label='gas_bus') source_gas = Source(label='gas_source', outputs={bus_gas: Flow(variable_costs=100)}) gas_pp = Transformer(label='powerplant', inputs={bus_gas: Flow()}, outputs={bus_el: Flow(nominal_value=10)}) pv = Source(label='pv', outputs={bus_el: Flow(nominal_value=5, fixed=True, actual_value=pv_ts)}) demand_el = Sink(label='electricity_demand', inputs={bus_el: Flow(nominal_value=2, fixed=True, actual_value=demand_ts)}) curtailment = Sink(label='curtailment', inputs={bus_el: Flow(nominal_value=5, max=pv_ts)})
def test_connect_invest(): date_time_index = pd.date_range('1/1/2012', periods=24 * 7, freq='H') energysystem = EnergySystem(timeindex=date_time_index) network.Node.registry = energysystem # Read data file full_filename = os.path.join(os.path.dirname(__file__), 'connect_invest.csv') data = pd.read_csv(full_filename, sep=",") logging.info('Create oemof objects') # create electricity bus bel1 = Bus(label="electricity1") bel2 = Bus(label="electricity2") # create excess component for the electricity bus to allow overproduction Sink(label='excess_bel', inputs={bel2: Flow()}) Source(label='shortage', outputs={bel2: Flow(variable_costs=50000)}) # create fixed source object representing wind power plants Source(label='wind', outputs={bel1: Flow(fix=data['wind'], nominal_value=1000000)}) # create simple sink object representing the electrical demand Sink(label='demand', inputs={bel1: Flow(fix=data['demand_el'], nominal_value=1)}) storage = components.GenericStorage( label='storage', inputs={bel1: Flow(variable_costs=10e10)}, outputs={bel1: 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=0.2), ) line12 = Transformer( label="line12", inputs={bel1: Flow()}, outputs={bel2: Flow(investment=Investment(ep_costs=20))}) line21 = Transformer( label="line21", inputs={bel2: Flow()}, outputs={bel1: Flow(investment=Investment(ep_costs=20))}) om = Model(energysystem) constraints.equate_variables(om, om.InvestmentFlow.invest[line12, bel2], om.InvestmentFlow.invest[line21, bel1], 2) constraints.equate_variables( om, om.InvestmentFlow.invest[line12, bel2], om.GenericInvestmentStorageBlock.invest[storage]) # if tee_switch is true solver messages will be displayed logging.info('Solve the optimization problem') om.solve(solver='cbc') # check if the new result object is working for custom components results = processing.results(om) my_results = dict() my_results['line12'] = float(views.node(results, 'line12')['scalars']) my_results['line21'] = float(views.node(results, 'line21')['scalars']) stor_res = views.node(results, 'storage')['scalars'] my_results['storage_in'] = stor_res[(('electricity1', 'storage'), 'invest')] my_results['storage'] = stor_res[(('storage', 'None'), 'invest')] my_results['storage_out'] = stor_res[(('storage', 'electricity1'), 'invest')] connect_invest_dict = { 'line12': 814705, 'line21': 1629410, 'storage': 814705, 'storage_in': 135784, 'storage_out': 135784 } for key in connect_invest_dict.keys(): eq_(int(round(my_results[key])), int(round(connect_invest_dict[key])))
inputs={ bus_el: Flow(nominal_value=1, actual_value=data['demand_el'], fixed=True) }) epc_coal = economics.annuity(capex=1500000, n=50, wacc=0.05) epc_gas = economics.annuity(capex=900000, n=20, wacc=0.05) # create power plants pp_coal = Transformer(label='pp_coal', inputs={bus_coal: Flow()}, outputs={ bus_el: Flow(investment=Investment(ep_costs=epc_coal, maximum=5e9, existing=0), variable_costs=25) }, conversion_factors={bus_el: 0.39}) pp_gas = Transformer(label='pp_gas', inputs={bus_gas: Flow()}, outputs={ bus_el: Flow(investment=Investment(ep_costs=epc_gas, maximum=5e9, existing=0), variable_costs=40) }, conversion_factors={bus_el: 0.50})
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)}, loss_rate=0.01, initial_storage_level=0, max_storage_level=0.9, inflow_conversion_factor=0.9, outflow_conversion_factor=0.9) # an excess and a shortage variable can help to avoid infeasible problems excess_el = Sink(label='excess_el', inputs={bus_el: Flow()})
el_storage = GenericStorage(label='el_storage', inputs={elbus: Flow(variable_costs=0.0001)}, outputs={elbus: Flow()}, loss_rate=0.00, initial_storage_level=0.5, invest_relation_input_capacity=1 / 6, invest_relation_output_capacity=1 / 6, inflow_conversion_factor=0.9, outflow_conversion_factor=0.9, investment=Investment(ep_costs=epc_storage)) cop = 3 es.add( Transformer(label='heat_pump', inputs={elbus: Flow()}, outputs={thbus: Flow(nominal_value=10)}, conversion_factors={elbus: 1 / cop})) th_storage = GenericStorage(label='th_storage', nominal_storage_capacity=1000, inputs={thbus: Flow(nominal_value=20)}, outputs={thbus: Flow(nominal_value=20)}, loss_rate=0.01, initial_storage_level=0, max_storage_level=0.9, inflow_conversion_factor=0.9, outflow_conversion_factor=0.9) # Adding all the components to the energy system es.add(excess_el, demand_el, el_storage, th_storage, pv, shortage_el, elbus,
def test_dispatch_one_time_step(solver='cbc', periods=1): """Create an energy system and optimize the dispatch at least costs.""" # ######################### create energysystem components ################ Node.registry = None # resource buses bgas = Bus(label='gas', 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()}) # sources wind = Source( label='wind', outputs={bel: Flow(actual_value=0.5, nominal_value=66.3, fixed=True)}) # demands (electricity/heat) demand_el = Sink( label='demand_elec', inputs={bel: Flow(nominal_value=85, actual_value=0.3, fixed=True)}) demand_th = Sink( label='demand_therm', inputs={bth: Flow(nominal_value=40, actual_value=0.2, fixed=True)}) # 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='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 }) energysystem = EnergySystem(timeindex=[1]) energysystem.add(bgas, bel, bth, excess_el, wind, demand_el, demand_th, pp_chp, b_heat_source, heat_source, heat_pump) # ################################ optimization ########################### # create optimization model based on energy_system optimization_model = Model(energysystem=energysystem, timeincrement=1) # solve problem optimization_model.solve(solver=solver) # write back results from optimization object to energysystem optimization_model.results() # ################################ results ################################ data = views.node(processing.results(om=optimization_model), 'b_el') # generate results to be evaluated in tests results = data['sequences'].sum(axis=0).to_dict() test_results = { (('wind', 'b_el'), 'flow'): 33, (('b_el', 'demand_elec'), 'flow'): 26, (('b_el', 'excess_el'), 'flow'): 5, (('b_el', 'heat_pump'), 'flow'): 3, } for key in test_results.keys(): eq_(int(round(results[key])), int(round(test_results[key])))
energysystem.add( Source(label="pv", outputs={bel: Flow(fix=data["pv"], nominal_value=256e3)})) # demands (electricity/heat) energysystem.add( Sink( label="demand_el", inputs={bel: Flow(nominal_value=1e3, fix=data["demand_el"])}, )) # power plants energysystem.add( Transformer( label="pp_coal", inputs={bcoal: Flow()}, outputs={bel: Flow(nominal_value=14e6, variable_costs=40.7)}, conversion_factors={bel: 0.35}, )) energysystem.add( Transformer( label="pp_gas", inputs={bgas: Flow()}, outputs={bel: Flow(nominal_value=30e6, variable_costs=23.2)}, conversion_factors={bel: 0.38}, )) energysystem.add( Transformer( label="pp_oil", inputs={boil: Flow()},