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