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 add_transmission_lines_between_electricity_nodes(table_collection, nodes): """ Parameters ---------- table_collection nodes Returns ------- """ logging.debug("Add transmission lines to nodes dictionary.") power_lines = table_collection["power lines"] 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 %s has a capacity of %s", line_label, values.capacity ) nodes[line_label] = solph.Transformer( label=line_label, inputs={nodes[bus_label_in]: solph.Flow()}, outputs={ nodes[bus_label_out]: solph.Flow( nominal_value=values.capacity ) }, conversion_factors={ nodes[bus_label_out]: values.efficiency }, ) else: logging.debug("Line %s has no capacity limit", line_label) nodes[line_label] = solph.Transformer( label=line_label, inputs={nodes[bus_label_in]: solph.Flow()}, outputs={nodes[bus_label_out]: solph.Flow()}, conversion_factors={ nodes[bus_label_out]: values.efficiency }, )
def test_that_the_transformer_warnings_actually_get_raised(): """ Transformer doesn't warn about potentially erroneous usage. """ look_out = network.Bus() msg = "`Transformer` 'no input' constructed without `inputs`." with warnings.catch_warnings(record=True) as w: solph.Transformer(label='no input', outputs={look_out: "No inputs!"}) ok_(len(w) == 1) eq_(msg, str(w[-1].message)) msg = "`Transformer` 'no output' constructed without `outputs`." with warnings.catch_warnings(record=True) as w: solph.Transformer(label='no output', inputs={look_out: "No outputs!"}) ok_(len(w) == 1) eq_(msg, str(w[-1].message))
def test_transformer_class(): transf = solph.Transformer() ok_(isinstance(transf.conversion_factors, dict)) eq_(len(transf.conversion_factors.keys()), 0) bus = solph.Bus() transf = solph.Transformer(inputs={bus: solph.Flow()}) eq_(transf.conversion_factors[bus][2], 1) transf = solph.Transformer(inputs={bus: solph.Flow()}, conversion_factors={bus: 2}) eq_(transf.conversion_factors[bus][6], 2) transf = solph.Transformer(inputs={bus: solph.Flow()}, conversion_factors={bus: [2]}) eq_(len(transf.conversion_factors[bus]), 1) with assert_raises(IndexError): eq_(transf.conversion_factors[bus][6], 2)
def test_transformer(self): """Constraint test of a LinearN1Transformer without Investment. """ bgas = solph.Bus(label='gasBus') bbms = solph.Bus(label='biomassBus') bel = solph.Bus(label='electricityBus') bth = solph.Bus(label='thermalBus') solph.Transformer(label='powerplantGasCoal', inputs={ bbms: solph.Flow(), bgas: solph.Flow() }, outputs={ bel: solph.Flow(variable_costs=50), bth: solph.Flow(nominal_value=5e10, variable_costs=20) }, conversion_factors={ bgas: 0.4, bbms: 0.1, bel: 0.3, bth: 0.5 }) self.compare_lp_files('transformer.lp')
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 auxiliary_transformer(label, input_bus, output_bus): r""" Get auxiliary transformer for Generic Model energy system. Parameters ---------- label : str Spezific label to reference transformer. input_bus : solph.Bus Spezific input bus to reference transformer. output_bus : solph.Bus Spezific output bus to reference transformer. Note ---- Auxiliary transformers are used to represent more complex networks. In solph individual busses have to be connected by a componente, in this case by 'auxiliary transformer'. In the Generic Model, these are used for the solar thermal and storage strand. The flow is not transformed, but transferred in an auxiliary way to make the calculation feasible. """ auxiliary_transformer = solph.Transformer( label=label, inputs={input_bus: solph.Flow()}, outputs={output_bus: solph.Flow(nominal_value=1, max=inf, min=0.0)}, conversion_factors={output_bus: 1}) return auxiliary_transformer
def test_transformer_invest_with_existing(self): """Constraint test of a LinearN1Transformer with Investment. """ bgas = solph.Bus(label='gasBus') bcoal = solph.Bus(label='coalBus') bel = solph.Bus(label='electricityBus') bth = solph.Bus(label='thermalBus') solph.Transformer(label='powerplant_gas_coal', inputs={ bgas: solph.Flow(), bcoal: solph.Flow() }, outputs={ bel: solph.Flow(variable_costs=50, investment=solph.Investment( maximum=1000, ep_costs=20, existing=200)), bth: solph.Flow(variable_costs=20) }, conversion_factors={ bgas: 0.58, bcoal: 0.2, bel: 0.3, bth: 0.5 }) self.compare_lp_files('transformer_invest_with_existing.lp')
def test_linear_transformer_chp_invest(self): """Constraint test of a Transformer with Investment (two outputs). """ bgas = solph.Bus(label='gasBus') bheat = solph.Bus(label='heatBus') bel = solph.Bus(label='electricityBus') solph.Transformer(label='chp_powerplant_gas', inputs={ bgas: solph.Flow(variable_costs=50, investment=solph.Investment( maximum=1000, ep_costs=20)) }, outputs={ bel: solph.Flow(), bheat: solph.Flow() }, conversion_factors={ bel: 0.4, bheat: 0.5 }) self.compare_lp_files('linear_transformer_chp_invest.lp')
def add_to_oemof_model(self, busses, model): """Creates an oemof Transformer component using the information given in the CompressorH2 class, to be used in the oemof model :param busses: virtual buses used in the energy system :type busses: dict :param model: current oemof model :type model: oemof model :return: oemof component """ compressor = solph.Transformer( label=self.name, inputs={ busses[self.bus_h2_in]: solph.Flow(nominal_value=self.m_flow_max * self.sim_params.interval_time / 60), busses[self.bus_el]: solph.Flow() }, outputs={busses[self.bus_h2_out]: solph.Flow()}, conversion_factors={ busses[self.bus_h2_in]: 1, busses[self.bus_el]: self.spec_compression_energy, busses[self.bus_h2_out]: 1 }) model.add(compressor) return compressor
def add_power_plants(table_collection, nodes): """ Parameters ---------- table_collection nodes Returns ------- """ pp = table_collection["power plants"] check_in_out_buses(nodes, pp, table_collection) for idx, params in pp.iterrows(): region = idx[0] # Create label for in and out bus: fuel_bus = Label( "bus", "commodity", params.fuel, params["source region"] ) bus_elec = Label("bus", "electricity", "all", region) # Create power plants as 1x1 Transformer if capacity > 0 if params.capacity > 0: # if downtime_factor is in the parameters, use it if hasattr(params, "downtime_factor"): params.capacity *= 1 - params["downtime_factor"] # Define output flow with or without summed_max attribute if params.get("annual_limit_electricity", float("inf")) == float( "inf" ): outflow = solph.Flow(nominal_value=params.capacity) else: smax = params.annual_limit_electricity / params.capacity outflow = solph.Flow( nominal_value=params.capacity, summed_max=smax ) # if variable costs are defined add them to the outflow if hasattr(params, "variable_costs"): vc = params.variable_costs outflow.variable_costs = solph.sequence(vc) plant_name = idx[1].replace(" - ", "_").replace(".", "") trsf_label = Label("trsf", "pp", plant_name, region) nodes[trsf_label] = solph.Transformer( label=trsf_label, inputs={nodes[fuel_bus]: solph.Flow()}, outputs={nodes[bus_elec]: outflow}, conversion_factors={nodes[bus_elec]: params.efficiency}, )
def add_mobility(table_collection, nodes): """ Parameters ---------- table_collection nodes Returns ------- """ mseries = table_collection["mobility demand series"] mtable = table_collection["mobility"] for region in mseries.columns.get_level_values(0).unique(): for fuel in mseries[region].columns: source = mtable.loc[(region, fuel), "source"] source_region = mtable.loc[(region, fuel), "source region"] if mseries[region, fuel].sum() > 0: fuel_transformer = Label("process", "fuel", fuel, region) fuel_demand = Label("demand", "mobility", fuel, region) bus_label = Label("bus", "mobility", fuel, region) if fuel != "electricity": com_bus_label = Label( "bus", "commodity", source, source_region ) else: com_bus_label = Label( "bus", "electricity", "all", source_region ) if bus_label not in nodes: nodes[bus_label] = solph.Bus(label=bus_label) if com_bus_label not in nodes: nodes[com_bus_label] = solph.Bus(label=com_bus_label) cf = mtable.loc[(region, fuel), "efficiency"] nodes[fuel_transformer] = solph.Transformer( label=fuel_transformer, inputs={nodes[com_bus_label]: solph.Flow()}, outputs={nodes[bus_label]: solph.Flow()}, conversion_factors={nodes[bus_label]: cf}, ) fix_value = mseries[region, fuel] nodes[fuel_demand] = solph.Sink( label=fuel_demand, inputs={ nodes[bus_label]: solph.Flow( nominal_value=1, fix=fix_value ) }, ) return nodes
def test_linear_transformer(self): """Constraint test of a Transformer without Investment. """ bgas = solph.Bus(label='gas') bel = solph.Bus(label='electricity') solph.Transformer( label='powerplantGas', inputs={bgas: solph.Flow()}, outputs={bel: solph.Flow(nominal_value=10e10, variable_costs=50)}, conversion_factors={bel: 0.58}) self.compare_lp_files('linear_transformer.lp')
def test_linear_transformer_chp(self): """Constraint test of a Transformer without Investment (two outputs). """ bgas = solph.Bus(label='gasBus') bheat = solph.Bus(label='heatBus') bel = solph.Bus(label='electricityBus') solph.Transformer( label='CHPpowerplantGas', inputs={bgas: solph.Flow(nominal_value=10e10, variable_costs=50)}, outputs={bel: solph.Flow(), bheat: solph.Flow()}, conversion_factors={bel: 0.4, bheat: 0.5}) self.compare_lp_files('linear_transformer_chp.lp')
def connect_electricity_buses(bus1, bus2, es): label = berlin_hp.Label nodes = deflex.scenario_tools.NodeDict() lines = [(bus1, bus2), (bus2, bus1)] 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]) b_in = es.groups[str(bus_label_in)] b_out = es.groups[str(bus_label_out)] nodes[line_label] = solph.Transformer( label=line_label, inputs={b_in: solph.Flow(variable_costs=0.0000001)}, outputs={b_out: solph.Flow()}, ) return nodes
def add_to_oemof_model(self, busses, model): """Creates an oemof Transformer component from the information given in the TrailerH2Delivery class, to be used in the oemof model. :param busses: virtual buses used in the energy system :type busses: dict :param model: current oemof model :type model: oemof model :return: oemof component """ trailer = solph.Transformer( label=self.name, outputs={busses[self.bus_out]: solph.Flow(variable_costs=self.current_ac)}, inputs={busses[self.bus_in]: solph.Flow(nominal_value=self.hydrogen_needed)}) model.add(trailer) return trailer
def add_to_oemof_model(self, busses, model): """Creates an oemof Transformer component from the information given in the BiogasConverter class, to be used in the oemof model :param busses: virtual buses used in the energy system :type busses: dict :param model: current oemof model :type model: oemof model :return: oemof component """ biogas_converter = solph.Transformer( label=self.name, inputs={busses[self.bg_in]: solph.Flow()}, outputs={busses[self.bg_out]: solph.Flow()}, conversion_factors={busses[self.bg_out]: self.conv}) model.add(biogas_converter) return biogas_converter
def create_oemof_model(self, busses, _): compressor = solph.Transformer( label=self.name, inputs={ busses[self.bus_h2_in]: solph.Flow(nominal_value=self.m_flow_max * self.sim_params.interval_time / 60), busses[self.bus_el]: solph.Flow() }, outputs={busses[self.bus_h2_out]: solph.Flow()}, conversion_factors={ busses[self.bus_h2_in]: 1, busses[self.bus_el]: self.spec_compression_energy, busses[self.bus_h2_out]: 1 }) return compressor
def add_to_oemof_model(self, busses, model): """Creates an oemof Transformer component from the information given in the TrailerGateCascade class, to be used in the oemof model. :param busses: virtual buses used in the energy system :type busses: dict :param model: current oemof model :type model: oemof model :return: oemof component """ trailer_gate_cascade = solph.Transformer( label=self.name, inputs={ busses[self.bus_in]: solph.Flow(nominal_value=self.max_input) }, outputs={busses[self.bus_out]: solph.Flow()}) model.add(trailer_gate_cascade) return trailer_gate_cascade
def check_oemof_installation(silent=False): logging.disable(logging.CRITICAL) 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(fix=[10, 20, 30, 40, 50], 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("*****************************") print("Solver installed with oemof:") print() for s, t in solver.items(): print("{0}: {1}".format(s, t)) print() print("*****************************") print("oemof successfully installed.") print("*****************************")
def add_to_oemof_model(self, busses, model): """Creates an oemof Transformer component from the information given in the ElectricHeater class, to be used in the oemof model :param busses: virtual buses used in the energy system :type busses: dict :param model: current oemof model :type model: oemof model :return: oemof component """ electric_heater = solph.Transformer( label=self.name, inputs={busses[self.bus_el]: solph.Flow()}, outputs={ busses[self.bus_th]: solph.Flow(nominal_value=self.power_max) }, conversion_factors={busses[self.bus_th]: self.efficiency}) model.add(electric_heater) return electric_heater
def run_model(params, wind_invest=False, pv_invest=False, storage_invest=False): logging.info('Initialize the energy system') energysystem = solph.EnergySystem(timeindex=date_time_index) Node.registry = energysystem logging.info('Create oemof objects') 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(nominal_value=params['rgas_nom_val'], summed_max=1)}) solph.Source(label='wind', outputs={bel: solph.Flow( actual_value=data['wind'], nominal_value=params['wind_nom_val'], fixed=True)}) solph.Source(label='pv', outputs={bel: solph.Flow( actual_value=data['pv'], nominal_value=params['pv_nom_val'], fixed=True)}) solph.Sink(label='demand', inputs={bel: solph.Flow( actual_value=data['demand_el'], 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}) logging.info('Optimise the energy system') om = solph.Model(energysystem) logging.info('Solve the optimization problem') om.solve(solver='cbc') energysystem.results['main'] = processing.convert_keys_to_strings(processing.results(om)) energysystem.results['param'] = processing.convert_keys_to_strings(processing.param_results(energysystem)) return energysystem, om
def add_to_oemof_model(self, busses, model): """Creates an oemof Transformer component from information given in the Gate class, to be used in the oemof model :param busses: virtual buses used in the energy system :type busses: dict :param model: current oemof model :type model: oemof model :return: oemof component """ gate = solph.Transformer( label=self.name, inputs={ busses[self.bus_in]: solph.Flow(variable_costs=self.artificial_costs, nominal_value=self.max_input) }, outputs={busses[self.bus_out]: solph.Flow()}, conversion_factors={busses[self.bus_out]: self.efficiency}) model.add(gate) return gate
def add_to_oemof_model(self, busses, model): """Creates an oemof Transformer component from information given in the AirSourceHeatPump class, to be used in the oemof model :param busses: virtual buses used in the energy system :type busses: dict :param model: current oemof model :type model: oemof model :return: oemof component """ air_source_heat_pump = solph.Transformer( label=self.name, inputs={busses[self.bus_el]: solph.Flow(variable_costs=0)}, outputs={ busses[self.bus_th]: solph.Flow(nominal_value=self.power_max, variable_costs=0) }, conversion_factors={ busses[self.bus_th]: self.cops[self.sim_params.i_interval] }) model.add(air_source_heat_pump) return air_source_heat_pump
def add_to_oemof_model(self, busses, model): """Creates an oemof Transformer component using the information given in the BiogasSteamReformer class, to be used in the oemof model :param busses: buses used in the energy system :type busses: dict :param model: current oemof model :type model: oemof model :return: oemof component """ biogas_smr_psa = solph.Transformer( label=self.name, inputs={ busses[self.bus_bg]: solph.Flow(variable_costs=0), busses[self.bus_el]: solph.Flow(variable_costs=0) }, outputs={busses[self.bus_h2]: solph.Flow()}, conversion_factors={ busses[self.bus_h2]: self.smr_psa_eff, busses[self.bus_el]: self.energy_cnsmp_1kg_bg }) model.add(biogas_smr_psa) return biogas_smr_psa
nominal_value=600000) }) # create simple sink object representing the electrical demand demand = solph.Sink(label='demand', inputs={ bel: solph.Flow(actual_value=data['demand_el'], fixed=True, nominal_value=1) }) # create simple transformer object representing a gas power plant pp_gas = solph.Transformer( label="pp_gas", inputs={bgas: solph.Flow()}, outputs={bel: solph.Flow(nominal_value=10e10, variable_costs=0)}, conversion_factors={bel: 0.58}) # create storage object representing a battery storage = solph.components.GenericStorage( label='storage', inputs={bel: solph.Flow(variable_costs=0.0001)}, outputs={bel: solph.Flow()}, 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=solph.Investment(ep_costs=epc_storage),
param_value['eta_solar_th'] * 0.000001), # [MWh/m²] nominal_value=param_value['area_solar_th'] * 10000, # [m²] fixed=True) })) # Combined heat and power plant if param_value['number_of_chps'] > 0: energysystem.add( solph.Transformer( label='chp', inputs={bgas: solph.Flow()}, outputs={ bth: solph.Flow(nominal_value=param_value['number_of_chps'] * param_value['chp_heat_output']), # [MW] bel: solph.Flow() }, conversion_factors={ bth: param_value['conversion_factor_bth_chp'], bel: param_value['conversion_factor_bel_chp'] })) # Boiler if param_value['number_of_boilers'] > 0: energysystem.add( solph.Transformer( label='boiler', inputs={bgas: solph.Flow()}, outputs={ bth:
outputs={ bel: solph.Flow(nominal_value=100, variable_costs=10, emission_factor=0.01, actual_value=[0.1, 0.2, 0.3], fixed=True)})) energysystem.add(solph.Source(label='gas-source', outputs={ bel: solph.Flow(variable_costs=10, emission_factor=0.2)})) energysystem.add(solph.Transformer( label="pp_gas", inputs={ bgas: solph.Flow()}, outputs={ bel: solph.Flow(nominal_value=200)}, conversion_factors={ bel: 0.58})) model = solph.Model(energysystem) # add the emission constraint constraints.emission_limit(model, limit=100) model.total_emissions.pprint() model.solve() print(model.total_emissions())
temp_threshold_icing = 2 # Pre-Calculate COPs cops_ASHP = cmpr_hp_chiller.calc_cops( temp_high=[40], temp_low=data['ambient_temperature'], quality_grade=0.4, mode='heat_pump', consider_icing=True, temp_threshold_icing=temp_threshold_icing, factor_icing=0.8) # Air-Source Heat Pump energysystem.add(solph.Transformer( label="ASHP", inputs={b_el: solph.Flow()}, outputs={b_heat: solph.Flow(nominal_value=25, variable_costs=5)}, conversion_factors={b_heat: cops_ASHP})) model = solph.Model(energysystem) model.solve(solver=solver, solve_kwargs={'tee': solver_verbose}) energysystem.results['main'] = outputlib.processing.results(model) energysystem.results['meta'] = outputlib.processing.meta_results(model) energysystem.dump(dpath=None, filename=None) # **************************************************************************** # ********** PART 2 - Processing the results ********************************* # ****************************************************************************
def run_model_thermal(config_path, var_number): with open(config_path, 'r') as ymlfile: cfg = yaml.load(ymlfile) if cfg['debug']: number_of_time_steps = 3 else: number_of_time_steps = cfg['number_timesteps'] solver = cfg['solver'] debug = cfg['debug'] solver_verbose = cfg['solver_verbose'] # show/hide solver output ### Read data and parameters ### # define the used directories abs_path = os.path.dirname(os.path.abspath(os.path.join(__file__, '..'))) results_path = abs_path + '/results' data_ts_path = abs_path + '/data/data_confidential/' data_param_path = abs_path + '/data/data_public/' # Read parameter values from parameter file filename_param = data_param_path + cfg['parameters_file_name'][var_number] param_df = pd.read_csv(filename_param, index_col=1, sep=';') # uses second column of csv-file for indexing param_value = param_df['value'] # Import PV and demand data data = pd.read_csv((data_ts_path + cfg['time_series_file_name']), sep=';') # redefine ep_costs_function: def ep_costs_f(capex, n, opex): return ep_costs_func(capex, n, opex, param_value['wacc']) # initiate the logger logger.define_logging(logfile='Oman_thermal_{0}_{1}.log'.format(cfg['exp_number'], var_number), logpath=results_path + '/logs', screen_level=logging.INFO, file_level=logging.DEBUG) date_time_index = pd.date_range('1/1/2017', periods=(2 if debug is True else number_of_time_steps), freq='H') # Initialise the energysystem logging.info('Initialize the energy system') energysystem = solph.EnergySystem(timeindex=date_time_index) ####################### # Build up the system # ####################### # Busses bth = solph.Bus(label='thermal') bco = solph.Bus(label="cool") bwh = solph.Bus(label="waste") bel = solph.Bus(label="electricity") bga = solph.Bus(label="gas") bam = solph.Bus(label="ambient") energysystem.add(bth, bco, bwh, bel, bga, bam) # Sinks and sources ambience = solph.Sink(label='ambience', inputs={bam: solph.Flow()}) grid_ga = solph.Source(label='naturalgas', outputs={bga: solph.Flow(variable_costs=param_value['price_gas'])}) grid_el = solph.Source(label='grid_el', outputs={bel: solph.Flow(variable_costs=param_value['price_electr'])}) collector = solph.Source(label='collector', outputs={bth: solph.Flow( fixed=True, actual_value=data['solar gain kWprom2'], investment=solph.Investment(ep_costs=ep_costs_f(param_value['invest_costs_collect_output_th'], param_value['lifetime_collector'], param_value['opex_collector'])))}) # Has to be developed pv = solph.Source(label='pv', outputs={bel: solph.Flow( fixed=True, actual_value=data['solar gain relativ'], investment=solph.Investment(ep_costs=ep_costs_f(param_value['invest_costs_pv_output_th'], param_value['lifetime_pv'], param_value['opex_pv'])))}) # Einheit: 0,7616 kWpeak demand = solph.Sink(label='demand', inputs={bco: solph.Flow( fixed=True, actual_value=data['Cooling load kW'], nominal_value=1)}) excess = solph.Sink(label='excess_thermal', inputs={bth: solph.Flow()}) excess_el = solph.Sink(label='excess_el', inputs={bel: solph.Flow()}) energysystem.add(ambience, grid_ga, grid_el, collector, pv, demand, excess, excess_el) # Transformers if param_value['nominal_value_boiler_output_thermal'] == 0: boil = solph.Transformer( label='boiler', inputs={bga: solph.Flow()}, outputs={bth: solph.Flow(investment=solph.Investment( ep_costs=ep_costs_f(param_value['invest_costs_boiler_output_th'], param_value['lifetime_boiler'], param_value['opex_boiler'])))}, conversion_factors={bth: param_value['conv_factor_boiler_output_thermal']}) else: boil = solph.Transformer( label='boiler', inputs={bga: solph.Flow()}, outputs={bth: solph.Flow(nominal_value=param_value['nominal_value_boiler_output_thermal'])}, conversion_factors={bth: param_value['conv_factor_boiler_output_thermal']}) chil = solph.Transformer( label='absorption_chiller', inputs={bth: solph.Flow()}, outputs={bco: solph.Flow(investment=solph.Investment( ep_costs=ep_costs_f(param_value['invest_costs_absorption_output_cool'], param_value['lifetime_absorption'], param_value['opex_absorption']))), bwh: solph.Flow()}, conversion_factors={bco: param_value['conv_factor_absorption_output_cool'], bwh: param_value['conv_factor_absorption_output_waste']}) aqui = solph.Transformer( label='aquifer', inputs={bwh: solph.Flow(investment=solph.Investment( ep_costs=ep_costs_f(param_value['invest_costs_aqui_input_th'], param_value['lifetime_aqui'], param_value['opex_aqui']))), bel: solph.Flow()}, outputs={bam: solph.Flow()}, conversion_factors={bwh: param_value['conv_factor_aquifer_input_waste'], bel: param_value['conv_factor_aquifer_input_el']}) towe = solph.Transformer( label='cooling_tower', inputs={bwh: solph.Flow(investment=solph.Investment( ep_costs=ep_costs_f(param_value['invest_costs_tower_input_th'], param_value['lifetime_tower'], param_value['opex_tower']))), bel: solph.Flow()}, outputs={bam: solph.Flow()}, conversion_factors={bwh: param_value['conv_factor_tower_input_waste'], bel: param_value['conv_factor_tower_input_el']}) energysystem.add(chil, boil, aqui, towe) # storages if param_value['nominal_capacitiy_stor_cool'] == 0: stor_co = solph.components.GenericStorage( label='storage_cool', inputs={bco: solph.Flow()}, outputs={bco: solph.Flow()}, capacity_loss=param_value['capac_loss_stor_cool'], # invest_relation_input_capacity=1 / 6, # invest_relation_output_capacity=1 / 6, inflow_conversion_factor=param_value['conv_factor_stor_cool_input'], outflow_conversion_factor=param_value['conv_factor_stor_cool_output'], investment=solph.Investment( ep_costs=ep_costs_f(param_value['invest_costs_stor_cool_capacity'], param_value['lifetime_stor_cool'], param_value['opex_stor_cool']))) else: stor_co = solph.components.GenericStorage( label='storage_cool', inputs={bco: solph.Flow()}, outputs={bco: solph.Flow()}, capacity_loss=param_value['capac_loss_stor_cool'], # invest_relation_input_capacity=1 / 6, # invest_relation_output_capacity=1 / 6, inflow_conversion_factor=param_value['conv_factor_stor_cool_input'], outflow_conversion_factor=param_value['conv_factor_stor_cool_output'], nominal_capacity=param_value['nominal_capacitiy_stor_cool']) if param_value['nominal_capacitiy_stor_thermal'] == 0: stor_th = solph.components.GenericStorage( label='storage_thermal', inputs={bth: solph.Flow()}, outputs={bth: solph.Flow()}, capacity_loss=param_value['capac_loss_stor_thermal'], # invest_relation_input_capacity=1 / 6, # invest_relation_output_capacity=1 / 6, inflow_conversion_factor=param_value['conv_factor_stor_thermal_input'], outflow_conversion_factor=param_value['conv_factor_stor_thermal_output'], investment=solph.Investment( ep_costs=ep_costs_f(param_value['invest_costs_stor_thermal_capacity'], param_value['lifetime_stor_thermal'], param_value['opex_stor_thermal']))) else: stor_th = solph.components.GenericStorage( label='storage_thermal', inputs={bth: solph.Flow()}, outputs={bth: solph.Flow()}, capacity_loss=param_value['capac_loss_stor_thermal'], # invest_relation_input_capacity=1 / 6, # invest_relation_output_capacity=1 / 6, inflow_conversion_factor=param_value['conv_factor_stor_thermal_input'], outflow_conversion_factor=param_value['conv_factor_stor_thermal_output'], nominal_capacity=param_value['nominal_capacitiy_stor_thermal']) if param_value['nominal_capacitiy_stor_el'] == 0: stor_el = solph.components.GenericStorage( label='storage_electricity', inputs={bel: solph.Flow()}, outputs={bel: solph.Flow()}, capacity_loss=param_value['capac_loss_stor_el'], # invest_relation_input_capacity=1 / 6, # invest_relation_output_capacity=1 / 6, inflow_conversion_factor=param_value['conv_factor_stor_el_input'], outflow_conversion_factor=param_value['conv_factor_stor_el_output'], investment=solph.Investment( ep_costs=ep_costs_f(param_value['invest_costs_stor_el_capacity'], param_value['lifetime_stor_el'], param_value['opex_stor_el']))) else: stor_el = solph.components.GenericStorage( label='storage_electricity', inputs={bel: solph.Flow()}, outputs={bel: solph.Flow()}, capacity_loss=param_value['capac_loss_stor_el'], # invest_relation_input_capacity=1 / 6, # invest_relation_output_capacity=1 / 6, inflow_conversion_factor=param_value['conv_factor_stor_el_input'], outflow_conversion_factor=param_value['conv_factor_stor_el_output'], nominal_capacity=param_value['nominal_capacitiy_stor_el']) energysystem.add(stor_co, stor_th, stor_el) ######################################## # Create a model and solve the problem # ######################################## # Initialise the operational model (create the problem) with constrains model = solph.Model(energysystem) logging.info('Solve the optimization problem') model.solve(solver=solver, solve_kwargs={'tee': solver_verbose}) if cfg['debug']: filename = results_path + '/lp_files/' + 'Oman_thermal_{0}_{1}.lp'.format(cfg['exp_number'], var_number) logging.info('Store lp-file in {0}.'.format(filename)) model.write(filename, io_options={'symbolic_solver_labels': True}) logging.info('Store the energy system with the results.') energysystem.results['main'] = outputlib.processing.results(model) energysystem.results['meta'] = outputlib.processing.meta_results(model) energysystem.results['param'] = outputlib.processing.parameter_as_dict(model) energysystem.dump(dpath=(results_path + '/dumps'), filename='oman_thermal_{0}_{1}.oemof'.format(cfg['exp_number'], var_number))