def compute(es=None, **arguments): """Creates the optimization model, solves it and writes back results to energy system object Parameters ---------- es : :class:`oemof.solph.network.EnergySystem` object Energy system holding nodes, grouping functions and other important information. **arguments : key word arguments Arguments passed from command line """ if es.temporal is not None: m = Model(es, objective_weighting=es.temporal['weighting']) else: m = Model(es) logging.info('Model creation time: ' + stopwatch()) m.receive_duals() if arguments['--debug']: filename = 'renpass_model.lp' logging.info('Writing lp-file to {}.'.format(filename)) m.write(filename, io_options={'symbolic_solver_labels': True}) m.solve(solver=arguments['--solver'], solve_kwargs={'tee': True}) logging.info('Optimization time: ' + stopwatch()) return m
def optimize(input_data_dir, results_data_dir, solver='cbc', debug=False): r""" Takes the specified datapackage, creates an energysystem and solves the optimization problem. """ # create energy system object logging.info("Creating EnergySystem from datapackage") es = EnergySystem.from_datapackage( os.path.join(input_data_dir, "datapackage.json"), attributemap={}, typemap=TYPEMAP, ) # create model from energy system (this is just oemof.solph) logging.info("Creating the optimization model") m = Model(es) # if you want dual variables / shadow prices uncomment line below # m.receive_duals() # save lp file together with optimization results if debug: lp_file_dir = os.path.join(results_data_dir, 'model.lp') logging.info(f"Saving the lp-file to {lp_file_dir}") m.write(lp_file_dir, io_options={'symbolic_solver_labels': True}) # select solver 'gurobi', 'cplex', 'glpk' etc logging.info(f'Solving the problem using {solver}') m.solve(solver=solver) # get the results from the the solved model(still oemof.solph) es.results = m.results() es.params = outputlib.processing.parameter_as_dict(es) # now we use the write results method to write the results in oemof-tabular # format logging.info(f'Writing the results to {results_data_dir}') es.dump(results_data_dir)
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) # create and solve the optimization model optimization_model = Model(energysystem) optimization_model.write('/home/jann/Desktop/my_model.lp', io_options={'symbolic_solver_labels': True}) optimization_model.solve(solver=solver, solve_kwargs={ 'tee': False, 'keepfiles': False }) results = outputlib.processing.results(optimization_model) string_results = outputlib.processing.convert_keys_to_strings(results) df = outputlib.processing.create_dataframe(optimization_model) sequences = {k: v['sequences'] for k, v in string_results.items()} df = pd.concat(sequences, axis=1) df[('efficiency', None, None)] = df[('pwltf', 'electricity', 'flow')].divide(df[('gas', 'pwltf', 'flow')])
ext = fc.ExtractionTurbine(label='ext', carrier=gas, tech='ext', commitable=False, electricity_bus=el1, heat_bus=heat, capacity=10, thermal_efficiency=0.4, electric_efficiency=0.4, condensing_efficiency=0.5) conv = fc.Conversion('conv', from_bus=el2, to_bus=heat, efficiency=0.95, capacity=2) load = fc.Load('load', bus=el1, amount=1000, profile=[0.005, 0.00034, 0.0434]) # Connection conn = fc.Connection('conn', from_bus=el1, to_bus=el2, loss=0.07, capacity=100) es.add(el1, el2, heat, biomass, bp, st, wind, sto, conv, load, conn, gas, ext) m = Model(es) m.pprint() m.write('model.lp', io_options={'symbolic_solver_labels': True})
es = EnergySystem() el0 = elec.ElectricalBus('el0') el1 = elec.ElectricalBus('el1') el2 = elec.ElectricalBus('el2') line0 = elec.Line(from_bus=el0, to_bus=el1, capacity=60, reactance=0.0001) line1 = elec.Line(from_bus=el1, to_bus=el2, capacity=60, reactance=0.0001) line2 = elec.Line(from_bus=el2, to_bus=el0, capacity=60, reactance=0.0001) gen0 = fc.Dispatchable("gen0", capacity=100, bus=el0, marginal_cost=50, carrier='coal') gen1 = fc.Dispatchable("gen1", capacity=100, bus=el1, marginal_cost=25, carrier='gas') load0 = fc.Load("load0", bus=el2, amount=100, profile=[1]) es.add(el0, el1, el2, line0, line1, line2, gen0, gen1, load0) m = Model(es) m.solve() m.write('lopf-model.lp')
nominal_storage_capacity=nominal_storage_capacity, min_storage_level=input_data['min_storage_level'], max_storage_level=input_data['max_storage_level'], loss_rate=loss_rate, fixed_losses_relative=fixed_losses_relative, fixed_losses_absolute=fixed_losses_absolute, inflow_conversion_factor=1.0, outflow_conversion_factor=1.0, ) energysystem.add(bus_heat, heat_source, shortage, excess, heat_demand, thermal_storage) # create and solve the optimization model optimization_model = Model(energysystem) optimization_model.write('storage_model.lp', io_options={'symbolic_solver_labels': True}) optimization_model.solve(solver=solver, solve_kwargs={ 'tee': False, 'keepfiles': False }) # get results results = outputlib.processing.results(optimization_model) string_results = outputlib.processing.convert_keys_to_strings(results) sequences = {k: v['sequences'] for k, v in string_results.items()} df = pd.concat(sequences, axis=1) # plot results fig, (ax1, ax2) = plt.subplots(2, 1) df[[('shortage', 'bus_heat', 'flow'), ('heat_source', 'bus_heat', 'flow'),
fname = os.path.join('data', 'sequences', f) df = pd.read_csv(fname, sep=';') df = df.iloc[:timesteps] df.to_csv(fname, index=False, sep=';') config = building.read_build_config('config.toml') es = EnergySystem.from_datapackage( "datapackage.json", attributemap={}, typemap=facades.TYPEMAP, ) m = Model(es) m.write('tmp.lp', io_options={"symbolic_solver_labels": True}) m.receive_duals() m.solve('gurobi') m.results = m.results() if os.path.exists('results'): shutil.rmtree('results') os.mkdir('results') pp.write_results(m, 'results', scalars=False) # create short summary supply_sum = (pp.supply_results(
es.add( fc.Excess(label="excess_heat_SDE", bus=heat_bus_SDE, tech="grid", carrier="heat", marginal_cost=costs.at["vom", "excess_heat"])) print("Demand data have been read.") # OEMoF Model Creation m = Model(es) print("OSeEM-DE is ready to solve.") # LP File m.write(os.path.join(results_path, "investment.lp"), io_options={"symbolic_solver_labels": True}) # Shadow Price m.receive_duals() # Solve m.solve("cbc") m.results = m.results() print("OSeEM-DE solved the optimization problem. :)") # Results pp.write_results(m, results_path) print("Results have been written. Results are available in {}.".format( results_path))
label='powerplant_2', outputs={ el_bus: Flow( nominal_value=12.5, variable_costs=10 ) } ) es.add(el_bus, demand, pp1, pp2) om = Model(es) lp_file_dir = 'dispatch.lp' om.write(lp_file_dir, io_options={'symbolic_solver_labels': True}) om.solve() results = om.results() string_results = outputlib.processing.convert_keys_to_strings(results) string_results = outputlib.processing.convert_keys_to_strings(results) # collect all timeseries in a DataFrame sequences = {k: v['sequences'] for k, v in string_results.items()} sequences = pd.concat(sequences, axis=1) print(sequences)
class Scenario: """ Definition of a deflex scenario object. """ def __init__(self, **kwargs): """ Parameters ---------- kwargs """ self.name = kwargs.get("name", "unnamed_scenario") self.table_collection = kwargs.get("table_collection", {}) self.year = kwargs.get("year", None) self.ignore_errors = kwargs.get("ignore_errors", False) self.round_values = kwargs.get("round_values", 0) self.model = kwargs.get("model", None) self.es = kwargs.get("es", None) self.results = None self.results_fn = kwargs.get("results_fn", None) self.debug = kwargs.get("debug", None) self.location = None self.map = None self.meta = kwargs.get("meta", None) def initialise_energy_system(self): if self.debug is True: number_of_time_steps = 3 else: try: if calendar.isleap(self.year): number_of_time_steps = 8784 else: number_of_time_steps = 8760 except TypeError: msg = ("You cannot create an EnergySystem with self.year={0}, " "of type {1}.") raise TypeError(msg.format(self.year, type(self.year))) date_time_index = pd.date_range("1/1/{0}".format(self.year), periods=number_of_time_steps, freq="H") return EnergySystem(timeindex=date_time_index) def load_excel(self, filename=None): """Load scenario from an excel-file.""" if filename is not None: self.location = filename xls = pd.ExcelFile(self.location) for sheet in xls.sheet_names: self.table_collection[sheet] = xls.parse(sheet, index_col=[0], header=[0, 1]) return self def load_csv(self, path=None): """Load scenario from a csv-collection.""" if path is not None: self.location = path for file in os.listdir(self.location): if file[-4:] == ".csv": filename = os.path.join(self.location, file) self.table_collection[file[:-4]] = pd.read_csv(filename, index_col=[0], header=[0, 1]) return self def to_excel(self, filename): """Dump scenario into an excel-file.""" # create path if it does not exist os.makedirs(os.path.dirname(filename), exist_ok=True) writer = pd.ExcelWriter(filename) for name, df in sorted(self.table_collection.items()): df.to_excel(writer, name) writer.save() logging.info("Scenario saved as excel file to {0}".format(filename)) def to_csv(self, path): """Dump scenario into a csv-collection.""" if os.path.isdir(path): shutil.rmtree(os.path.join(path)) os.makedirs(path) for name, df in self.table_collection.items(): name = name.replace(" ", "_") + ".csv" filename = os.path.join(path, name) df.to_csv(filename) logging.info("Scenario saved as csv-collection to {0}".format(path)) def check_table(self, table_name): if self.table_collection[table_name].isnull().values.any(): c = [] for column in self.table_collection[table_name].columns: if self.table_collection[table_name][column].isnull().any(): c.append(column) msg = "Nan Values in the {0} table (columns: {1})." raise ValueError(msg.format(table_name, c)) return self def create_nodes(self): pass def initialise_es(self, year=None): if year is not None: self.year = year self.es = self.initialise_energy_system() return self def add_nodes(self, nodes): """ Parameters ---------- nodes : dict Dictionary with a unique key and values of type oemof.network.Node. Returns ------- self """ if self.es is None: self.initialise_es() self.es.add(*nodes.values()) return self def table2es(self): if self.es is None: self.es = self.initialise_energy_system() nodes = self.create_nodes() self.es.add(*nodes.values()) return self def create_model(self): self.model = Model(self.es) return self def dump_es(self, filename): os.makedirs(os.path.dirname(filename), exist_ok=True) f = open(filename, "wb") if self.meta is None: if self.es.results is not None and "Meta" in self.es.results: self.meta = self.es.results["meta"] pickle.dump(self.meta, f) pickle.dump(self.es.__dict__, f) f.close() logging.info("Results dumped to {0}.".format(filename)) def restore_es(self, filename=None): if filename is None: filename = self.results_fn else: self.results_fn = filename if self.es is None: self.es = EnergySystem() f = open(filename, "rb") self.meta = pickle.load(f) self.es.__dict__ = pickle.load(f) f.close() self.results = self.es.results["main"] logging.info("Results restored from {0}.".format(filename)) def scenario_info(self, solver_name): sc_info = { "name": self.name, "datetime": datetime.datetime.now(), "year": self.year, "solver": solver_name, } return sc_info def solve(self, with_duals=False, tee=True, logfile=None, solver=None): logging.info("Optimising using {0}.".format(solver)) if with_duals: self.model.receive_duals() if self.debug: filename = os.path.join(helpers.extend_basic_path("lp_files"), "reegis.lp") logging.info("Store lp-file in {0}.".format(filename)) self.model.write(filename, io_options={"symbolic_solver_labels": True}) self.model.solve(solver=solver, solve_kwargs={ "tee": tee, "logfile": logfile }) self.es.results["main"] = processing.results(self.model) self.es.results["meta"] = processing.meta_results(self.model) self.es.results["param"] = processing.parameter_as_dict(self.es) self.es.results["meta"]["scenario"] = self.scenario_info(solver) self.es.results["meta"]["in_location"] = self.location self.es.results["meta"]["file_date"] = datetime.datetime.fromtimestamp( os.path.getmtime(self.location)) self.es.results["meta"]["oemof_version"] = logger.get_version() self.results = self.es.results["main"] def plot_nodes(self, show=None, filename=None, **kwargs): rm_nodes = kwargs.get("remove_nodes_with_substrings") g = graph.create_nx_graph(self.es, filename=filename, remove_nodes_with_substrings=rm_nodes) if show is True: draw_graph(g, **kwargs) return g