def test_bus_to_sink_outputs_in_results_dataframe(self): bus = Bus(uid="bus") source = FS(uid="source", outputs=[bus], val=[0.5], out_max=[1]) sink = Sink(uid="sink", inputs=[bus], val=[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 optimize(self, om=None): """Start optimizing the energy system using solph. Parameters ---------- om : :class:`OptimizationModel <oemof.solph.optimization_model.OptimizationModel>`, optional The optimization model used to optimize the :class:`EnergySystem`. If not given, an :class:`OptimizationModel <oemof.solph.optimization_model.OptimizationModel>` instance local to this method is created using the current :class:`EnergySystem` instance as an argument. You only need to supply this if you want to observe any side effects that solving has on the `om`. Returns ------- self : :class:`EnergySystem` """ if om is None: om = OM(energysystem=self) om.solve(solver=self.simulation.solver, debug=self.simulation.debug, verbose=self.simulation.verbose, duals=self.simulation.duals, solve_kwargs=self.simulation.solve_kwargs) self.results = om.results() return self
def optimize(self): if self.optimization_model is None: self.optimization_model = OM(energysystem=self) self.optimization_model.solve( solver=self.simulation.solver, debug=self.simulation.debug, tee=self.simulation.stream_solver_output )
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))
class EnergySystem: r""" """ def __init__(self, **kwargs): "" for attribute in ["regions", "entities", "simulation"]: setattr(self, attribute, kwargs.get(attribute, {})) self.optimization_model = kwargs.get("optimization_model", None) # TODO: Condense signature (use Buse) def connect(self, code1, code2, media, in_max, out_max, eta, transport_class): "" if not transport_class == transport.Simple: raise ( TypeError( "Sorry, `EnergySystem.connect` currently only works with" + "a `transport_class` argument of" + str(transport.Simple) ) ) for reg_out, reg_in in [(code1, code2), (code2, code1)]: logging.debug("Creating simple {2} from {0} to {1}".format(reg_out, reg_in, transport_class)) uid = "_".join([reg_out, reg_in, media]) self.connections[uid] = transport_class( uid=uid, outputs=[self.regions[reg_out].buses["_".join(["b", reg_out, media])]], inputs=[self.regions[reg_in].buses["_".join(["b", reg_in, media])]], out_max={"_".join(["b", reg_out, media]): out_max}, in_max={"_".join(["b", reg_in, media]): in_max}, eta=[eta], ) def optimize(self): if self.optimization_model is None: self.optimization_model = OM(energysystem=self) self.optimization_model.solve( solver=self.simulation.solver, debug=self.simulation.debug, tee=self.simulation.stream_solver_output )
buses = [bcoal, bgas, boil, blig, b_el, b_th] # group components transformers = [pp_coal, pp_lig, pp_gas, pp_oil, pp_chp] renew_sources = [pv, wind_on] sinks = [demand_th, demand_el] components = transformers + renew_sources + sinks entities = components + buses simulation = es.Simulation(solver='glpk', timesteps=timesteps, stream_solver_output=True, objective_name='minimize_costs') energysystem = es.EnergySystem(entities=entities, simulation=simulation) om = OptimizationModel(energysystem=energysystem) om.solve(solver='gurobi', debug=True, tee=True, duals=False) pp.results_to_objects(om) components = transformers + renew_sources if __name__ == "__main__": def plot_dispatch(bus_to_plot): # plotting: later as multiple pdf with pie-charts and topology? import numpy as np import matplotlib as mpl import matplotlib.cm as cm plot_data = renew_sources+transformers
out_max=[40, 30], eta=[0.4, 0.3], opex_fix=0, opex_var=50, co2_var=em_gas) # group busses buses = [bcoal, bgas, boil, blig, b_el, b_th] # group components transformers = [pp_coal, pp_lig, pp_gas, pp_oil, pp_chp] renew_sources = [pv, wind_on] sinks = [demand_th, demand_el] components = transformers + renew_sources + sinks entities = components + buses om = OptimizationModel(energysystem=energy_system) # om.solve(solve_kwargs={'tee':True, 'keepfiles':False}, solver_cmdline_options={'min':''}) energy_system.results = om.results() es_df = tpd.EnergySystemDataFrame(energy_system=energy_system) # plot es_df.plot_bus(bus_uid="b_el", bus_type="el", type="input", date_from="2012-01-01 00:00:00", date_to="2012-01-31 00:00:00", kind='bar', title="January 2016", xlabel="Power in MW", ylabel="Date", tick_distance=24*7, df_plot_kwargs={'stacked':True ,'width':1, 'lw':0.2})
else: Regions.connect(ebus_from, ebus_export, in_max=capacity, out_max=capacity, eta=eta_trans, transport_class=transport.Simple) ############################################################################## ############################### FINAL STEPS ################################## # change uid tuples to strings for entity in Regions.entities: entity.uid = str(entity.uid) # create optimisation model from Regions instance om = OptimizationModel(energysystem=Regions) # add constraints constraints = hlsb.get_constraint_values(conn_oedb, scenario) Export_Regions = ('MV', 'ST', 'SN', 'KJ', 'BE') hlsb.add_constraint_export_minimum(om, Export_Regions, constraints) hlsb.add_constraint_import_berlin(om, constraints) hlsb.add_constraint_co2_emissions(om, co2_emissions, constraints) hlsb.add_constraint_entities_BE(om) # write LP file #om.write_lp_file() # solve problem om.solve() # save results to Regions instance Regions.results = om.results()
# demand demand_el = sink.Simple(uid="demand_el", inputs=[b_el], val=[30, 10, 20, 40, 45, 50, 35, 25, 5, 12]) # Simple Transformer for b_el pp_coal = transformer.Simple(uid='pp_lig', inputs=[bcoal], outputs=[b_el], in_max=[None], out_max=[10], eta=[0.41], opex_fix=2, opex_var=40) pp_gas = transformer.Simple(uid='pp_gas', inputs=[bgas], outputs=[b_el], in_max=[None], out_max=[41], eta=[0.45], opex_var=40) # create optimization model om = OptimizationModel(energysystem=energy_system) # energy_system.optimize(om) # # use outputlib to plot esplot = tpd.DataFramePlot(energy_system=energy_system) esplot.slice_unstacked(bus_uid="b_el", type="input") esplot.plot(title="January 2016 Low coal costs", stacked=True, width=1, lw=0.1, kind='bar') plt.show() # update variable costs and objective, solve again!