def run_scenario(input_file, timesteps, scenario, result_dir, plot_periods={}): """ run an urbs model for given input, time steps and scenario Args: input_file: filename to an Excel spreadsheet for urbs.read_excel timesteps: a list of timesteps, e.g. range(0,8761) scenario: a scenario function that modifies the input data dict result_dir: directory name for result spreadsheet and plots Returns: the urbs model instance """ # scenario name, read and modify data for scenario sce = scenario.__name__ data = urbs.read_excel(input_file) data = scenario(data) # create model prob = urbs.create_model(data, timesteps) if PYOMO3: prob = prob.create() # refresh time stamp string and create filename for logfile now = prob.created log_filename = os.path.join(result_dir, '{}.log').format(sce) # solve model and read results optim = SolverFactory('glpk') # cplex, glpk, gurobi, ... optim = setup_solver(optim, logfile=log_filename) result = optim.solve(prob, tee=True) if PYOMO3: prob.load(result) else: prob.solutions.load_from(result) # copy input file in result directory cdir = os.getcwd() respath = os.path.join(cdir, result_dir) shutil.copy(input_file,respath) # write report to spreadsheet urbs.report( prob, os.path.join(result_dir, '{}.xlsx').format(sce), prob.com_demand, prob.sit) # store optimisation problem for later re-analysis urbs.save( prob, os.path.join(result_dir, '{}.pgz').format(sce)) urbs.result_figures( prob, os.path.join(result_dir, '{}'.format(sce)), plot_title_prefix=sce.replace('_', ' ').title(), periods=plot_periods) return prob
def run_scenario(input_file, timesteps, scenario, result_dir, plot_tuples=None, plot_periods=None, report_tuples=None): """ run an urbs model for given input, time steps and scenario Args: input_file: filename to an Excel spreadsheet for urbs.read_excel timesteps: a list of timesteps, e.g. range(0,8761) scenario: a scenario function that modifies the input data dict result_dir: directory name for result spreadsheet and plots plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures) plot_periods: (optional) dict of plot periods (c.f. urbs.result_figures) report_tuples: (optional) list of (sit, com) tuples (c.f. urbs.report) Returns: the urbs model instance """ # scenario name, read and modify data for scenario sce = scenario.__name__ data = urbs.read_excel(input_file) data = scenario(data) # create model prob = urbs.create_model(data, timesteps) # refresh time stamp string and create filename for logfile now = prob.created log_filename = os.path.join(result_dir, '{}.log').format(sce) # solve model and read results optim = SolverFactory('glpk') # cplex, glpk, gurobi, ... optim = setup_solver(optim, logfile=log_filename) result = optim.solve(prob, tee=True) # copy input file to result directory shutil.copyfile(input_file, os.path.join(result_dir, input_file)) # save problem solution (and input data) to HDF5 file urbs.save(prob, os.path.join(result_dir, '{}.h5'.format(sce))) # write report to spreadsheet urbs.report( prob, os.path.join(result_dir, '{}.xlsx').format(sce), report_tuples=report_tuples) # result plots urbs.result_figures( prob, os.path.join(result_dir, '{}'.format(sce)), plot_title_prefix=sce.replace('_', ' '), plot_tuples=plot_tuples, periods=plot_periods, figure_size=(24, 9)) return prob
def _check_available(name): from pyomo.opt.base import (UnknownSolver, SolverFactory) try: opt = SolverFactory(name) except: return False if opt is None or isinstance(opt, UnknownSolver): return False elif (name == "gurobi") and \ (not GUROBISHELL.license_is_valid()): return False elif (name == "baron") and \ (not BARONSHELL.license_is_valid()): return False else: return (opt.available(exception_flag=False)) and \ ((not hasattr(opt,'executable')) or \ (opt.executable() is not None))
def run_scenario(input_file, timesteps, scenario, result_dir, plot_periods={}): """ run an urbs model for given input, time steps and scenario Args: input_file: filename to an Excel spreadsheet for urbs.read_excel timesteps: a list of timesteps, e.g. range(0,8761) scenario: a scenario function that modifies the input data dict result_dir: directory name for result spreadsheet and plots Returns: the urbs model instance """ # scenario name, read and modify data for scenario sce = scenario.__name__ data = urbs.read_excel(input_file) data = scenario(data) # create model prob = urbs.create_model(data, timesteps) # refresh time stamp string and create filename for logfile now = prob.created log_filename = os.path.join(result_dir, "{}.log").format(sce) # solve model and read results optim = SolverFactory("glpk") # cplex, glpk, gurobi, ... optim = setup_solver(optim, logfile=log_filename) result = optim.solve(prob, tee=True) # copy input file to result directory shutil.copyfile(input_file, os.path.join(result_dir, input_file)) # write report to spreadsheet urbs.report(prob, os.path.join(result_dir, "{}.xlsx").format(sce), prob.com_demand, prob.sit) urbs.result_figures( prob, os.path.join(result_dir, "{}".format(sce)), plot_title_prefix=sce.replace("_", " ").title(), periods=plot_periods, ) return prob
def run_scenario(input_file, solver, timesteps, scenario, result_dir, dt, objective, plot_tuples=None, plot_sites_name=None, plot_periods=None, report_tuples=None, report_sites_name=None): """ run an urbs model for given input, time steps and scenario Args: input_file: filename to an Excel spreadsheet for urbs.read_excel timesteps: a list of timesteps, e.g. range(0,8761) scenario: a scenario function that modifies the input data dict result_dir: directory name for result spreadsheet and plots dt: length of each time step (unit: hours) plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures) plot_sites_name: (optional) dict of names for sites in plot_tuples plot_periods: (optional) dict of plot periods(c.f. urbs.result_figures) report_tuples: (optional) list of (sit, com) tuples (c.f. urbs.report) report_sites_name: (optional) dict of names for sites in report_tuples Returns: the urbs model instance """ # start time measurement t_start = time.time() # scenario name, read and modify data for scenario sce = scenario.__name__ data = read_excel(input_file) data = scenario(data) validate_input(data) # measure time to read file t_read = time.time() - t_start print("Time to read file: %.2f sec" % t_read) t = time.time() # create model prob = create_model(data, dt, timesteps, objective) # prob.write('model.lp', io_options={'symbolic_solver_labels':True}) # measure time to create model t_model = time.time() - t print("Time to create model: %.2f sec" % t_model) # refresh time stamp string and create filename for logfile # now = prob.created log_filename = os.path.join(result_dir, '{}.log').format(sce) t = time.time() # solve model and read results optim = SolverFactory(solver) # cplex, glpk, gurobi, ... optim = setup_solver(optim, logfile=log_filename) result = optim.solve(prob, tee=True) assert str(result.solver.termination_condition) == 'optimal' # measure time to solve t_solve = time.time() - t print("Time to solve model: %.2f sec" % t_solve) t = time.time() # save problem solution (and input data) to HDF5 file save(prob, os.path.join(result_dir, '{}.h5'.format(sce))) # # measure time to save solution # save_time = time.time() - t # print("Time to save solution in HDF5 file: %.2f sec" % save_time) # t = time.time() # write report to spreadsheet report( prob, os.path.join(result_dir, '{}.xlsx').format(sce), report_tuples=report_tuples, report_sites_name=report_sites_name) # result plots result_figures( prob, os.path.join(result_dir, '{}'.format(sce)), timesteps, plot_title_prefix=sce.replace('_', ' '), plot_tuples=plot_tuples, plot_sites_name=plot_sites_name, periods=plot_periods, figure_size=(24, 9)) t_repplot = time.time() - t print("Time to report and plot: %.2f sec" % t_repplot) # measure time to run scenario t_sce = time.time() - t_start print("Time to run scenario: %.2f sec" % t_sce) # write time measurements into file "timelog.txt" in result directory timelog = open(os.path.join(result_dir, "timelog.txt"), "a") timelog.write("%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%s\n" % (t_sce, t_read, t_model, t_solve, t_repplot, sce)) return prob
def _get_task_data(self, ah, *args, **kwds): opt = kwds.pop('solver', kwds.pop('opt', None)) if opt is None: raise ActionManagerError( "No solver passed to %s, use keyword option 'solver'" % (type(self).__name__)) deactivate_opt = False if isinstance(opt, six.string_types): deactivate_opt = True opt = SolverFactory(opt, solver_io=kwds.pop('solver_io', None)) # # The following block of code is taken from the OptSolver.solve() # method, which we do not directly invoke with this interface # # # If the inputs are models, then validate that they have been # constructed! Collect suffix names to try and import from solution. # for arg in args: if isinstance(arg, (Block, IBlockStorage)): if isinstance(arg, Block): if not arg.is_constructed(): raise RuntimeError( "Attempting to solve model=%s with unconstructed " "component(s)" % (arg.name)) # import suffixes must be on the top-level model if isinstance(arg, Block): model_suffixes = list(name for (name,comp) \ in pyomo.core.base.suffix.\ active_import_suffix_generator(arg)) else: assert isinstance(arg, IBlockStorage) model_suffixes = list(name for (name,comp) \ in pyomo.core.base.component_suffix.\ import_suffix_generator(arg, active=True, descend_into=False, return_key=True)) if len(model_suffixes) > 0: kwds_suffixes = kwds.setdefault('suffixes', []) for name in model_suffixes: if name not in kwds_suffixes: kwds_suffixes.append(name) # # Handle ephemeral solvers options here. These # will override whatever is currently in the options # dictionary, but we will reset these options to # their original value at the end of this method. # ephemeral_solver_options = {} ephemeral_solver_options.update(kwds.pop('options', {})) ephemeral_solver_options.update( OptSolver._options_string_to_dict(kwds.pop('options_string', ''))) # # Force pyomo.opt to ignore tests for availability, at least locally. # del_available = bool('available' not in kwds) kwds['available'] = True opt._presolve(*args, **kwds) problem_file_string = None with open(opt._problem_files[0], 'r') as f: problem_file_string = f.read() # # Delete this option, to ensure that the remote worker does the check for # availability. # if del_available: del kwds['available'] # # We can't pickle the options object itself - so extract a simple # dictionary of solver options and re-construct it on the other end. # solver_options = {} for key in opt.options: solver_options[key] = opt.options[key] solver_options.update(ephemeral_solver_options) # # NOTE: let the distributed node deal with the warm-start # pick up the warm-start file, if available. # warm_start_file_string = None warm_start_file_name = None if hasattr(opt, "_warm_start_solve"): if opt._warm_start_solve and \ (opt._warm_start_file_name is not None): warm_start_file_name = opt._warm_start_file_name with open(warm_start_file_name, 'r') as f: warm_start_file_string = f.read() data = pyutilib.misc.Bunch(opt=opt.type, \ file=problem_file_string, \ filename=opt._problem_files[0], \ warmstart_file=warm_start_file_string, \ warmstart_filename=warm_start_file_name, \ kwds=kwds, \ solver_options=solver_options, \ suffixes=opt._suffixes) self._args[ah.id] = args self._opt_data[ah.id] = (opt._smap_id, opt._load_solutions, opt._select_index, opt._default_variable_value) if deactivate_opt: opt.deactivate() return data
# read vertices and edges from shapefiles... vertex = geopandas.read_file(vertex_file) edge = geopandas.read_file(edge_file) # ... and set indices to agree with Excel format vertex.set_index(['Vertex'], inplace=True) edge.set_index(['Edge', 'Vertex1', 'Vertex2'], inplace=True) # at this point, rundh.py and rundhshp.py work identically! # dhmin.create_model must not rely on vertex/edge DataFrames to contain any # geometry information # get model # create instance # solver interface (GLPK) prob = dhmin.create_model(vertex, edge, params, timesteps) solver = SolverFactory('glpk') result = solver.solve(prob, timelimit=30, tee=True) prob.solutions.load_from(result) # use special-purpose function to plot power flows (works unchanged!) dhmintools.plot_flows_min(prob) # read time-independent variable values to DataFrame # (list all variables using dhmin.list_entities(instance, 'variables') caps = dhmin.get_entities(prob, ['Pmax', 'x']) costs = dhmin.get_entity(prob, 'costs') # remove Edge from index, so that edge and caps are both indexed on # (vertex, vertex) tuples, i.e. their indices match for identical edges edge.reset_index('Edge', inplace=True)
edge = pdshp.read_shp(edge_shapefile) edge = edge.set_index('Edge') edge = edge.join(total_area) edge = edge.fillna(0) # load nodes vertex = pdshp.read_shp(vertex_shapefile) # load spreadsheet data data = rivus.read_excel(data_spreadsheet) # create & solve model prob = rivus.create_model(data, vertex, edge) if PYOMO3: prob = prob.create() # no longer needed in Pyomo 4 optim = SolverFactory('glpk') optim = setup_solver(optim) result = optim.solve(prob, tee=True) if PYOMO3: prob.load(result) # no longer needed in Pyomo 4 # load results costs, Pmax, Kappa_hub, Kappa_process = rivus.get_constants(prob) source, flows, hub_io, proc_io, proc_tau = rivus.get_timeseries(prob) result_dir = os.path.join('result', os.path.basename(base_directory)) # create result directory if not existing already if not os.path.exists(result_dir): os.makedirs(result_dir)
def load(): DownloadFactory.register('gjh')(get_gjh) SolverFactory.register('contrib.gjh', doc='Interface to the AMPL GJH "solver"')(GJHSolver)
def test_df_insert_query(self): """Are the stored dataframes and the retrieved ones identical? - Comparison form of frames is *after* create_model. (index is set) - Comparison form expects that input dataframes only have meaningful columns. (See pull request #23) - Only implemented dataframes are tested. Note ---- Requires a ``config.json`` file in the root of rivus-repo with the database credentials. For Example: :: { "db" : { "user" : "postgres", "pass" : "postgres", "host" : "localhost", "base" : "rivus" } } """ conf_path = os.path.join(pdir(pdir(pdir(__file__))), 'config.json') config = [] with open(conf_path) as conf: config = json.load(conf) # DB connection _user = config['db']['user'] _pass = config['db']['pass'] _host = config['db']['host'] _base = config['db']['base'] engine_string = ('postgresql://{}:{}@{}/{}'.format( _user, _pass, _host, _base)) engine = create_engine(engine_string) proj_name = 'mnl' base_directory = os.path.join('data', proj_name) data_spreadsheet = os.path.join(base_directory, 'data.xlsx') data = read_excel(data_spreadsheet) # data_bup = data.copy() vertex, edge = square_grid() vert_init_commodities(vertex, ['Elec', 'Gas'], [('Elec', 0, 100000)]) extend_edge_data(edge) prob = create_model(data, vertex, edge) solver = SolverFactory(config['solver']) solver = setup_solver(solver, log_to_console=False) solver.solve(prob, tee=True) test_id = rdb.init_run(engine, runner='Unittest') rdb.store(engine, prob, run_id=test_id) this_df = None dfs = data.keys() for df in dfs: if df == 'hub': continue # is not implemented yet this_df = data[df] print(df) re_df = rdb.df_from_table(engine, df, test_id) self.assertTrue(all( this_df.fillna(0) == re_df.reindex(this_df.index).fillna(0)), msg=('{}: Original and retrieved frames' ' are not identical'.format(df))) # Add implemented result dataframes cost, pmax, kappa_hub, kappa_process = get_constants(prob) source, _, _, _, _, = get_timeseries(prob) results = dict(source=source, cost=cost, pmax=pmax, kappa_hub=kappa_hub, kappa_process=kappa_process) dfs = ['source', 'cost', 'pmax', 'kappa_hub', 'kappa_process'] for df in dfs: this_df = results[df] print(df) re_df = rdb.df_from_table(engine, df, test_id) self.assertTrue(all( this_df.fillna(0) == re_df.reindex(this_df.index).fillna(0)), msg=('{}: Original and retrieved frames' ' are not identical'.format(df)))
def run_scenario(input_file, timesteps, scenario, result_dir, dt, plot_tuples=None, plot_sites_name=None, plot_periods=None, report_tuples=None, report_sites_name=None): """ run an urbs model for given input, time steps and scenario Args: input_file: filename to an Excel spreadsheet for urbs.read_excel timesteps: a list of timesteps, e.g. range(0,8761) scenario: a scenario function that modifies the input data dict result_dir: directory name for result spreadsheet and plots dt: length of each time step (unit: hours) plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures) plot_sites_name: (optional) dict of names for sites in plot_tuples plot_periods: (optional) dict of plot periods(c.f. urbs.result_figures) report_tuples: (optional) list of (sit, com) tuples (c.f. urbs.report) report_sites_name: (optional) dict of names for sites in report_tuples Returns: the urbs model instance """ # scenario name, read and modify data for scenario sce = scenario.__name__ data = urbs.read_excel(input_file) data = scenario(data) urbs.validate_input(data) # create model prob = urbs.create_model(data, dt, timesteps) # refresh time stamp string and create filename for logfile now = prob.created log_filename = os.path.join(result_dir, '{}.log').format(sce) # solve model and read results optim = SolverFactory('glpk') # cplex, glpk, gurobi, ... optim = setup_solver(optim, logfile=log_filename) result = optim.solve(prob, tee=True) # save problem solution (and input data) to HDF5 file urbs.save(prob, os.path.join(result_dir, '{}.h5'.format(sce))) # write report to spreadsheet urbs.report(prob, os.path.join(result_dir, '{}.xlsx').format(sce), report_tuples=report_tuples, report_sites_name=report_sites_name) # result plots urbs.result_figures(prob, os.path.join(result_dir, '{}'.format(sce)), timesteps, plot_title_prefix=sce.replace('_', ' '), plot_tuples=plot_tuples, plot_sites_name=plot_sites_name, periods=plot_periods, figure_size=(24, 9)) return prob
def EFAlgorithmBuilder(options, scenario_tree): solution_writer_plugins = ExtensionPoint(ISolutionWriterExtension) for plugin in solution_writer_plugins: plugin.disable() solution_plugins = [] if len(options.solution_writer) > 0: for this_extension in options.solution_writer: if this_extension in sys.modules: print("User-defined EF solution writer module=" +this_extension+" already imported - skipping") else: print("Trying to import user-defined EF " "solution writer module="+this_extension) # make sure "." is in the PATH. original_path = list(sys.path) sys.path.insert(0,'.') pyutilib.misc.import_file(this_extension) print("Module successfully loaded") sys.path[:] = original_path # restore to what it was # now that we're sure the module is loaded, re-enable this # specific plugin. recall that all plugins are disabled # by default in phinit.py, for various reasons. if we want # them to be picked up, we need to enable them explicitly. import inspect module_to_find = this_extension if module_to_find.rfind(".py"): module_to_find = module_to_find.rstrip(".py") if module_to_find.find("/") != -1: module_to_find = module_to_find.split("/")[-1] for name, obj in inspect.getmembers(sys.modules[module_to_find], inspect.isclass): import pyomo.util # the second condition gets around goofyness related to issubclass returning # True when the obj is the same as the test class. if issubclass(obj, pyomo.util.plugin.SingletonPlugin) and name != "SingletonPlugin": for plugin in solution_writer_plugins(all=True): if isinstance(plugin, obj): plugin.enable() solution_plugins.append(plugin) ef_solver = SolverFactory(options.solver_type, solver_io=options.solver_io) if isinstance(ef_solver, UnknownSolver): raise ValueError("Failed to create solver of type="+ options.solver_type+ " for use in extensive form solve") if len(options.solver_options) > 0: print("Initializing ef solver with options=" +str(options.solver_options)) ef_solver.set_options("".join(options.solver_options)) if options.mipgap is not None: if (options.mipgap < 0.0) or (options.mipgap > 1.0): raise ValueError("Value of the mipgap parameter for the EF " "solve must be on the unit interval; " "value specified="+str(options.mipgap)) ef_solver.options.mipgap = float(options.mipgap) ef_solver_manager = SolverManagerFactory(options.solver_manager_type, host=options.pyro_host, port=options.pyro_port) if ef_solver_manager is None: raise ValueError("Failed to create solver manager of type=" +options.solver_type+ " for use in extensive form solve") binding_instance = CreateExtensiveFormInstance(options, scenario_tree) ef = ExtensiveFormAlgorithm(options, binding_instance, scenario_tree, ef_solver_manager, ef_solver, solution_plugins=solution_plugins) return ef
def construct_ef_writer_options_parser(usage_string): solver_list = SolverFactory.services() solver_list = sorted( filter(lambda x: '_' != x[0], solver_list) ) solver_help = \ "Specify the solver with which to solve the extensive form. The " \ "following solver types are currently supported: %s; Default: cplex" solver_help %= ', '.join( solver_list ) parser = OptionParser() parser.usage=usage_string inputOpts = OptionGroup( parser, 'Input Options' ) scenarioTreeOpts = OptionGroup( parser, 'Scenario Tree Options' ) efOpts = OptionGroup( parser, 'EF Options' ) ccOpts = OptionGroup( parser, 'Chance Constraint Options' ) solverOpts = OptionGroup( parser, 'Solver Options' ) outputOpts = OptionGroup( parser, 'Output Options' ) otherOpts = OptionGroup( parser, 'Other Options' ) parser.add_option_group( inputOpts ) parser.add_option_group( scenarioTreeOpts ) parser.add_option_group( efOpts ) parser.add_option_group( ccOpts ) parser.add_option_group( solverOpts ) parser.add_option_group( outputOpts ) parser.add_option_group( otherOpts ) inputOpts.add_option('-i','--instance-directory', help='The directory in which all instance (reference and scenario) definitions are stored. This option is required if no callback is found in the model file.', action='store', dest='instance_directory', type='string', default=None) inputOpts.add_option('-m','--model-directory', help='The directory in which all model (reference and scenario) definitions are stored. Default is ".".', action='store', dest='model_directory', type='string', default='.') def objective_sense_callback(option, opt_str, value, parser): if value in ('min','minimize',minimize): parser.values.objective_sense = minimize elif value in ('max','maximize',maximize): parser.values.objective_sense = maximize else: parser.values.objective_sense = None inputOpts.add_option('-o','--objective-sense-stage-based', help='The objective sense to use for the auto-generated scenario instance objective, which is equal to the ' 'sum of the scenario-tree stage costs. Default is None, indicating an Objective has been declared on the ' 'reference model.', action="callback", dest="objective_sense", type="choice", choices=[maximize,'max','maximize',minimize,'min','minimize',None], default=None, callback=objective_sense_callback) scenarioTreeOpts.add_option('--scenario-tree-seed', help="The random seed associated with manipulation operations on the scenario tree (e.g., down-sampling). Default is None, indicating unassigned.", action="store", dest="scenario_tree_random_seed", type="int", default=random.getrandbits(100)) scenarioTreeOpts.add_option('--scenario-tree-downsample-fraction', help="The proportion of the scenarios in the scenario tree that are actually used. Specific scenarios are selected at random. Default is 1.0, indicating no down-sampling.", action="store", dest="scenario_tree_downsample_fraction", type="float", default=1.0) efOpts.add_option('--cvar-weight', help='The weight associated with the CVaR term in the risk-weighted objective formulation. Default is 1.0. If the weight is 0, then *only* a non-weighted CVaR cost will appear in the EF objective - the expected cost component will be dropped.', action='store', dest='cvar_weight', type='float', default=1.0) efOpts.add_option('--generate-weighted-cvar', help='Add a weighted CVaR term to the primary objective', action='store_true', dest='generate_weighted_cvar', default=False) efOpts.add_option('--risk-alpha', help='The probability threshold associated with cvar (or any future) risk-oriented performance metrics. Default is 0.95.', action='store', dest='risk_alpha', type='float', default=0.95) ccOpts.add_option('--cc-alpha', help='The probability threshold associated with a chance constraint. The RHS will be one minus this value. Default is 0.', action='store', dest='cc_alpha', type='float', default=0.0) ccOpts.add_option('--cc-indicator-var', help='The name of the binary variable to be used to construct a chance constraint. Default is None, which indicates no chance constraint.', action='store', dest='cc_indicator_var', type='string', default=None) solverOpts.add_option('--mipgap', help='Specifies the mipgap for the EF solve.', action='store', dest='mipgap', type='float', default=None) solverOpts.add_option('--solve', help='Following write of the extensive form model, solve it.', action='store_true', dest='solve_ef', default=False) solverOpts.add_option('--solver', help=solver_help, action='store', dest='solver_type', type='string', default='cplex') solverOpts.add_option('--solver-io', help='The type of IO used to execute the solver. Different solvers support different types of IO, but the following are common options: lp - generate LP files, nl - generate NL files, python - direct Python interface, os - generate OSiL XML files.', action='store', dest='solver_io', default=None) solverOpts.add_option('--solver-manager', help='The type of solver manager used to coordinate scenario sub-problem solves. Default is serial.', action='store', dest='solver_manager_type', type='string', default='serial') solverOpts.add_option('--pyro-host', help="The hostname to bind on when searching for a Pyro nameserver.", action="store", dest="pyro_host", default=None) solverOpts.add_option('--pyro-port', help="The port to bind on when searching for a Pyro nameserver.", action="store", dest="pyro_port", type="int", default=None) solverOpts.add_option('--solver-options', help='Solver options for the extensive form problem.', action='append', dest='solver_options', type='string', default=[]) solverOpts.add_option('--disable-warmstarts', help="Disable warm-starts of EF solves. Default is False.", action="store_true", dest="disable_warmstarts", default=False) solverOpts.add_option('--shutdown-pyro', help="Shut down all Pyro-related components associated with the Pyro solver manager (if specified), including the dispatch server, name server, and any mip servers. Default is False.", action="store_true", dest="shutdown_pyro", default=False) solverOpts.add_option('--shutdown-pyro-workers', help="Shut down PH solver servers on exit, leaving dispatcher and nameserver running. Default is False.", action="store_true", dest="shutdown_pyro_workers", default=False) outputOpts.add_option('--output-file', help="The name of the extensive form output file (currently only LP and NL file formats are supported). If the option name does not end in '.lp' or '.nl', then the output format will be determined by the value of the --solver-io option, and the appropriate ending suffix will be added to the name. Default is 'efout'.", action='store', dest='output_file', type='string', default="efout") outputOpts.add_option('--symbolic-solver-labels', help='When interfacing with the solver, use symbol names derived from the model. For example, \"my_special_variable[1_2_3]\" instead of \"v1\". Useful for debugging. When using the ASL interface (--solver-io=nl), generates corresponding .row (constraints) and .col (variables) files. The ordering in these files provides a mapping from ASL index to symbolic model names.', action='store_true', dest='symbolic_solver_labels', default=False) outputOpts.add_option('--output-solver-log', help='Output solver log during the extensive form solve.', action='store_true', dest='output_solver_log', default=False) outputOpts.add_option('--solution-writer', help='The plugin invoked to write the scenario tree solution. Defaults to the empty list.', action='append', dest='solution_writer', type='string', default = []) outputOpts.add_option('--verbose', help='Generate verbose output, beyond the usual status output. Default is False.', action='store_true', dest='verbose', default=False) outputOpts.add_option('--output-times', help="Output timing statistics for various EF components", action="store_true", dest="output_times", default=False) outputOpts.add_option('--output-instance-construction-time', help="Output timing statistics for instance construction (client-side only when using PHPyro", action="store_true", dest="output_instance_construction_time", default=False) otherOpts.add_option('--disable-gc', help='Disable the python garbage collecter. Default is False.', action='store_true', dest='disable_gc', default=False) otherOpts.add_option('-k','--keep-solver-files', help='Retain temporary input and output files for solve.', action='store_true', dest='keep_solver_files', default=False) otherOpts.add_option('--profile', help='Enable profiling of Python code. The value of this option is the number of functions that are summarized.', action='store', dest='profile', type="int", default=0) otherOpts.add_option('--traceback', help='When an exception is thrown, show the entire call stack. Ignored if profiling is enabled. Default is False.', action='store_true', dest='traceback', default=False) otherOpts.add_option('--compile-scenario-instances', help="Replace all linear constraints on scenario instances with a more memory efficient sparse matrix representation. Default is False.", action="store_true", dest="compile_scenario_instances", default=False) return parser
def run_scenario(input_files, Solver, timesteps, scenario, result_dir, dt, objective, plot_tuples=None, plot_sites_name=None, plot_periods=None, report_tuples=None, report_sites_name=None): """ run an urbs model for given input, time steps and scenario Args: - input_files: filenames of input Excel spreadsheets - Solver: the user specified solver - timesteps: a list of timesteps, e.g. range(0,8761) - scenario: a scenario function that modifies the input data dict - result_dir: directory name for result spreadsheet and plots - dt: length of each time step (unit: hours) - objective: objective function chosen (either "cost" or "CO2") - plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures) - plot_sites_name: (optional) dict of names for sites in plot_tuples - plot_periods: (optional) dict of plot periods (c.f. urbs.result_figures) - report_tuples: (optional) list of (sit, com) tuples (c.f. urbs.report) - report_sites_name: (optional) dict of names for sites in report_tuples Returns: the urbs model instance """ # sets a modeled year for non-intertemporal problems #(necessary for consitency) year = date.today().year # scenario name, read and modify data for scenario sce = scenario.__name__ data = read_input(input_files,year) data = scenario(data) validate_input(data) # create model prob = create_model(data, dt, timesteps, objective) # prob.write('model.lp', io_options={'symbolic_solver_labels':True}) # refresh time stamp string and create filename for logfile log_filename = os.path.join(result_dir, '{}.log').format(sce) # solve model and read results optim = SolverFactory(Solver) # cplex, glpk, gurobi, ... optim = setup_solver(optim, logfile=log_filename) result = optim.solve(prob, tee=True) assert str(result.solver.termination_condition) == 'optimal' # save problem solution (and input data) to HDF5 file save(prob, os.path.join(result_dir, '{}.h5'.format(sce))) # write report to spreadsheet report( prob, os.path.join(result_dir, '{}.xlsx').format(sce), report_tuples=report_tuples, report_sites_name=report_sites_name) # result plots result_figures( prob, os.path.join(result_dir, '{}'.format(sce)), timesteps, plot_title_prefix=sce.replace('_', ' '), plot_tuples=plot_tuples, plot_sites_name=plot_sites_name, periods=plot_periods, figure_size=(24, 9)) return prob
def _get_task_data(self, ah, *args, **kwds): opt = kwds.pop('solver', kwds.pop('opt', None)) if opt is None: raise ActionManagerError( "No solver passed to %s, use keyword option 'solver'" % (type(self).__name__) ) deactivate_opt = False if isinstance(opt, six.string_types): deactivate_opt = True opt = SolverFactory(opt, solver_io=kwds.pop('solver_io', None)) # # The following block of code is taken from the OptSolver.solve() # method, which we do not directly invoke with this interface # # # If the inputs are models, then validate that they have been # constructed! Collect suffix names to try and import from solution. # for arg in args: if isinstance(arg, Block): if not arg.is_constructed(): raise RuntimeError( "Attempting to solve model=%s with unconstructed " "component(s)" % (arg.name,) ) model_suffixes = list(name for (name,comp) \ in active_import_suffix_generator(arg)) if len(model_suffixes) > 0: kwds_suffixes = kwds.setdefault('suffixes',[]) for name in model_suffixes: if name not in kwds_suffixes: kwds_suffixes.append(name) # # Handle ephemeral solvers options here. These # will override whatever is currently in the options # dictionary, but we will reset these options to # their original value at the end of this method. # ephemeral_solver_options = {} ephemeral_solver_options.update(kwds.pop('options', {})) ephemeral_solver_options.update( OptSolver._options_string_to_dict(kwds.pop('options_string', ''))) # # Force pyomo.opt to ignore tests for availability, at least locally. # del_available = bool('available' not in kwds) kwds['available'] = True opt._presolve(*args, **kwds) problem_file_string = None with open(opt._problem_files[0], 'r') as f: problem_file_string = f.read() # # Delete this option, to ensure that the remote worker does the check for # availability. # if del_available: del kwds['available'] # # We can't pickle the options object itself - so extract a simple # dictionary of solver options and re-construct it on the other end. # solver_options = {} for key in opt.options: solver_options[key]=opt.options[key] solver_options.update(ephemeral_solver_options) # # NOTE: let the distributed node deal with the warm-start # pick up the warm-start file, if available. # warm_start_file_string = None warm_start_file_name = None if hasattr(opt, "_warm_start_solve"): if opt._warm_start_solve and \ (opt._warm_start_file_name is not None): warm_start_file_name = opt._warm_start_file_name with open(warm_start_file_name, 'r') as f: warm_start_file_string = f.read() data = pyutilib.misc.Bunch(opt=opt.type, \ file=problem_file_string, \ filename=opt._problem_files[0], \ warmstart_file=warm_start_file_string, \ warmstart_filename=warm_start_file_name, \ kwds=kwds, \ solver_options=solver_options, \ suffixes=opt._suffixes) self._args[ah.id] = args self._opt_data[ah.id] = (opt._smap_id, opt._load_solutions, opt._select_index, opt._default_variable_value) if deactivate_opt: opt.deactivate() return data
def _perform_queue(self, ah, *args, **kwds): """ Perform the queue operation. This method returns the ActionHandle, and the ActionHandle status indicates whether the queue was successful. """ solver = kwds.pop('solver', kwds.pop('opt', None)) if solver is None: raise ActionManagerError( "No solver passed to %s, use keyword option 'solver'" % (type(self).__name__)) if not isinstance(solver, six.string_types): solver_name = solver.name if solver_name == 'asl': solver_name = \ os.path.basename(solver.executable()) else: solver_name = solver solver = None # # Handle ephemeral solvers options here. These # will override whatever is currently in the options # dictionary, but we will reset these options to # their original value at the end of this method. # user_solver_options = {} # make sure to transfer the options dict on the # solver plugin if the user does not use a string # to identify the neos solver. The ephemeral # options must also go after these. if solver is not None: user_solver_options.update(solver.options) user_solver_options.update(kwds.pop('options', {})) user_solver_options.update( OptSolver._options_string_to_dict(kwds.pop('options_string', ''))) opt = SolverFactory('_neos') opt._presolve(*args, **kwds) # # Map NEOS name, using lowercase convention in Pyomo # if len(self._solvers) == 0: for name in self.kestrel.solvers(): if name.endswith('AMPL'): self._solvers[name[:-5].lower()] = name[:-5] if solver_name not in self._solvers: raise ActionManagerError( "Solver '%s' is not recognized by NEOS. " "Solver names recognized:\n%s" % (solver_name, str(sorted(self._solvers.keys())))) # # Apply kestrel # # Set the kestrel_options environment # neos_sname = self._solvers[solver_name].lower() os.environ[ 'kestrel_options'] = 'solver=%s' % self._solvers[solver_name] # # Set the <solver>_options environment # solver_options = {} for key in opt.options: solver_options[key] = opt.options[key] solver_options.update(user_solver_options) options = opt._get_options_string(solver_options) if not options == "": os.environ[neos_sname + '_options'] = options # # Generate an XML string using these two environment variables # xml = self.kestrel.formXML(opt._problem_files[0]) (jobNumber, password) = self.kestrel.submit(xml) ah.job = jobNumber ah.password = password # # Cleanup # del os.environ['kestrel_options'] try: del os.environ[neos_sname + "_options"] except: pass # # Store action handle, and return # self._ah[jobNumber] = ah self._neos_log[jobNumber] = (0, "") self._opt_data[jobNumber] = (opt, opt._smap_id, opt._load_solutions, opt._select_index, opt._default_variable_value) self._args[jobNumber] = args return ah
edge = pdshp.read_shp(edge_shapefile) edge = edge.set_index('Edge') edge = edge.join(total_area) edge = edge.fillna(0) # load nodes vertex = pdshp.read_shp(vertex_shapefile) # load spreadsheet data data = rivus.read_excel(data_spreadsheet) # create and solve model prob = rivus.create_model(data, vertex, edge) if PYOMO3: prob = prob.create() # no longer needed in Pyomo 4< solver = SolverFactory('glpk') result = solver.solve(prob, tee=True) if PYOMO3: prob.load(result) #no longer needed in Pyomo 4< # load results costs, Pmax, Kappa_hub, Kappa_process = rivus.get_constants(prob) source, flows, hub_io, proc_io, proc_tau = rivus.get_timeseries(prob) result_dir = os.path.join('result', os.path.basename(base_directory)) # create result directory if not existing already if not os.path.exists(result_dir): os.makedirs(result_dir) rivus.save(prob, os.path.join(result_dir, 'prob.pgz'))
def run_scenario(input_files, Solver, timesteps, scenario, result_dir, dt, objective, plot_tuples=None, plot_sites_name=None, plot_periods=None, report_tuples=None, report_sites_name=None): """ run an urbs model for given input, time steps and scenario Args: - input_files: filenames of input Excel spreadsheets - Solver: the user specified solver - timesteps: a list of timesteps, e.g. range(0,8761) - scenario: a scenario function that modifies the input data dict - result_dir: directory name for result spreadsheet and plots - dt: length of each time step (unit: hours) - objective: objective function chosen (either "cost" or "CO2") - plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures) - plot_sites_name: (optional) dict of names for sites in plot_tuples - plot_periods: (optional) dict of plot periods (c.f. urbs.result_figures) - report_tuples: (optional) list of (sit, com) tuples (c.f. urbs.report) - report_sites_name: (optional) dict of names for sites in report_tuples Returns: the urbs model instance """ # sets a modeled year for non-intertemporal problems # (necessary for consitency) year = date.today().year # scenario name, read and modify data for scenario sce = scenario.__name__ data = read_input(input_files, year) data = scenario(data) validate_input(data) validate_dc_objective(data, objective) # create model prob = create_model(data, dt, timesteps, objective) # prob.write('model.lp', io_options={'symbolic_solver_labels':True}) # refresh time stamp string and create filename for logfile log_filename = os.path.join(result_dir, '{}.log').format(sce) # solve model and read results optim = SolverFactory(Solver) # cplex, glpk, gurobi, ... optim = setup_solver(optim, logfile=log_filename) result = optim.solve(prob, tee=True) assert str(result.solver.termination_condition) == 'optimal' # save problem solution (and input data) to HDF5 file save(prob, os.path.join(result_dir, '{}.h5'.format(sce))) # write report to spreadsheet report( prob, os.path.join(result_dir, '{}.xlsx').format(sce), report_tuples=report_tuples, report_sites_name=report_sites_name) # result plots result_figures( prob, os.path.join(result_dir, '{}'.format(sce)), timesteps, plot_title_prefix=sce.replace('_', ' '), plot_tuples=plot_tuples, plot_sites_name=plot_sites_name, periods=plot_periods, figure_size=(24, 9)) return prob
def _perform_queue(self, ah, *args, **kwds): """ Perform the queue operation. This method returns the ActionHandle, and the ActionHandle status indicates whether the queue was successful. """ solver = kwds.pop('solver', kwds.pop('opt', None)) if solver is None: raise ActionManagerError( "No solver passed to %s, use keyword option 'solver'" % (type(self).__name__) ) if not isinstance(solver, six.string_types): solver_name = solver.name if solver_name == 'asl': solver_name = \ os.path.basename(solver.executable()) else: solver_name = solver solver = None # # Handle ephemeral solvers options here. These # will override whatever is currently in the options # dictionary, but we will reset these options to # their original value at the end of this method. # user_solver_options = {} # make sure to transfer the options dict on the # solver plugin if the user does not use a string # to identify the neos solver. The ephemeral # options must also go after these. if solver is not None: user_solver_options.update(solver.options) user_solver_options.update( kwds.pop('options', {})) user_solver_options.update( OptSolver._options_string_to_dict(kwds.pop('options_string', ''))) opt = SolverFactory('_neos') opt._presolve(*args, **kwds) # # Map NEOS name, using lowercase convention in Pyomo # if len(self._solvers) == 0: for name in self.kestrel.solvers(): if name.endswith('AMPL'): self._solvers[ name[:-5].lower() ] = name[:-5] if solver_name not in self._solvers: raise ActionManagerError( "Solver '%s' is not recognized by NEOS. " "Solver names recognized:\n%s" % (solver_name, str(sorted(self._solvers.keys())))) # # Apply kestrel # # Set the kestrel_options environment # neos_sname = self._solvers[solver_name].lower() os.environ['kestrel_options'] = 'solver=%s' % self._solvers[solver_name] # # Set the <solver>_options environment # solver_options = {} for key in opt.options: solver_options[key]=opt.options[key] solver_options.update(user_solver_options) options = opt._get_options_string(solver_options) if not options == "": os.environ[neos_sname+'_options'] = options # # Generate an XML string using these two environment variables # xml = self.kestrel.formXML(opt._problem_files[0]) (jobNumber, password) = self.kestrel.submit(xml) ah.job = jobNumber ah.password = password # # Cleanup # del os.environ['kestrel_options'] try: del os.environ[neos_sname+"_options"] except: pass # # Store action handle, and return # self._ah[jobNumber] = ah self._neos_log[jobNumber] = (0, "") self._opt_data[jobNumber] = (opt, opt._smap_id, opt._load_solutions, opt._select_index, opt._default_variable_value) self._args[jobNumber] = args return ah
def process(self, data): self._worker_task_return_queue = self._current_task_client data = pyutilib.misc.Bunch(**data) if hasattr(data, 'action') and \ data.action == 'Pyomo_pyro_mip_server_shutdown': print("Received shutdown request") self._worker_shutdown = True return time_start = time.time() with pyutilib.services.TempfileManager.push(): # # Construct the solver on this end, based on the input # type stored in "data.opt". This is slightly more # complicated for asl-based solvers, whose real executable # name is stored in data.solver_options["solver"]. # with SolverFactory(data.opt) as opt: if opt is None: self._worker_error = True return TaskProcessingError( "Problem constructing solver `" + data.opt + "'") # here is where we should set any options required by # the solver, available as specific attributes of the # input data object. solver_options = data.solver_options del data.solver_options for key, value in solver_options.items(): setattr(opt.options, key, value) problem_filename_suffix = os.path.split(data.filename)[1] temp_problem_filename = \ pyutilib.services.TempfileManager.\ create_tempfile(suffix="."+problem_filename_suffix) with open(temp_problem_filename, 'w') as f: f.write(data.file) if data.warmstart_filename is not None: warmstart_filename_suffix = \ os.path.split(data.warmstart_filename)[1] temp_warmstart_filename = \ pyutilib.services.TempfileManager.\ create_tempfile(suffix="."+warmstart_filename_suffix) with open(temp_warmstart_filename, 'w') as f: f.write(data.warmstart_file) assert opt.warm_start_capable() assert (('warmstart' in data.kwds) and \ data.kwds['warmstart']) data.kwds['warmstart_file'] = temp_warmstart_filename now = datetime.datetime.now() if self._verbose: print( str(now) + ": Applying solver=" + data.opt + " to solve problem=" + temp_problem_filename) sys.stdout.flush() results = opt.solve(temp_problem_filename, **data.kwds) assert results._smap_id is None # NOTE: This results object contains solutions, # because no model is provided (just a model file). # Also, the results._smap_id value is None. results.pyomo_solve_time = time.time() - time_start now = datetime.datetime.now() if self._verbose: print( str(now) + ": Solve completed - number of solutions=" + str(len(results.solution))) sys.stdout.flush() # PYTHON3 / PYRO4 Fix # The default serializer in Pyro4 is not pickle and does not # support user defined types (e.g., the results object). # Therefore, we pickle the results object before sending it # over the wire so the user does not need to change the Pyro # serializer. results = pickle.dumps(results, protocol=pickle.HIGHEST_PROTOCOL) if using_pyro4: # # The standard bytes object returned by pickle.dumps must be # converted to base64 to avoid errors sending over the # wire with Pyro4. Also, the base64 bytes must be wrapped # in a str object to avoid a different set of Pyro4 errors # related to its default serializer (Serpent) if six.PY3: results = str(base64.encodebytes(results)) else: results = base64.encodestring(results) return results
def apply_optimizer(data, instance=None): """ Perform optimization with a concrete instance Required: instance: Problem instance. Returned: results: Optimization results. opt: Optimizer object. """ # if not data.options.runtime.logging == 'quiet': sys.stdout.write('[%8.2f] Applying solver\n' % (time.time() - start_time)) sys.stdout.flush() # # # Create Solver and Perform Optimization # solver = data.options.solvers[0].solver_name if solver is None: raise ValueError("Problem constructing solver: no solver specified") if len(data.options.solvers[0].suffixes) > 0: for suffix_name in data.options.solvers[0].suffixes: if suffix_name[0] in ['"', "'"]: suffix_name = suffix[1:-1] # Don't redeclare the suffix if it already exists suffix = getattr(instance, suffix_name, None) if suffix is None: setattr(instance, suffix_name, Suffix(direction=Suffix.IMPORT)) else: raise ValueError("Problem declaring solver suffix %s. A component "\ "with that name already exists on model %s." % (suffix_name, instance.name)) if getattr(data.options.solvers[0].options, 'timelimit', 0) == 0: data.options.solvers[0].options.timelimit = None # # Default results # results = None # # Figure out the type of solver manager # solver_mngr_name = None if data.options.solvers[0].manager is None: solver_mngr_name = 'serial' elif not data.options.solvers[0].manager in SolverManagerFactory: raise ValueError("Unknown solver manager %s" % data.options.solvers[0].manager) else: solver_mngr_name = data.options.solvers[0].manager # # Create the solver manager # solver_mngr_kwds = {} if data.options.solvers[0].pyro_host is not None: solver_mngr_kwds['host'] = data.options.solvers[0].pyro_host if data.options.solvers[0].pyro_port is not None: solver_mngr_kwds['port'] = data.options.solvers[0].pyro_port with SolverManagerFactory(solver_mngr_name, **solver_mngr_kwds) as solver_mngr: if solver_mngr is None: msg = "Problem constructing solver manager '%s'" raise ValueError(msg % str(data.options.solvers[0].manager)) # # Setup keywords for the solve # keywords = {} if (data.options.runtime.keep_files or \ data.options.postsolve.print_logfile): keywords['keepfiles'] = True if data.options.model.symbolic_solver_labels: keywords['symbolic_solver_labels'] = True if data.options.model.file_determinism != 1: keywords['file_determinism'] = data.options.model.file_determinism keywords['tee'] = data.options.runtime.stream_output keywords['timelimit'] = getattr(data.options.solvers[0].options, 'timelimit', 0) keywords['report_timing'] = data.options.runtime.report_timing # FIXME: solver_io and executable are not being used # in the case of a non-serial solver manager # # Call the solver # if solver_mngr_name == 'serial': # # If we're running locally, then we create the # optimizer and pass it into the solver manager. # sf_kwds = {} sf_kwds['solver_io'] = data.options.solvers[0].io_format if data.options.solvers[0].solver_executable is not None: sf_kwds['executable'] = data.options.solvers[ 0].solver_executable with SolverFactory(solver, **sf_kwds) as opt: if opt is None: raise ValueError("Problem constructing solver `%s`" % str(solver)) from pyomo.core.base.plugin import registered_callback for name in registered_callback: opt.set_callback(name, registered_callback[name]) if len(data.options.solvers[0].options) > 0: opt.set_options(data.options.solvers[0].options) #opt.set_options(" ".join("%s=%s" % (key, value) # for key, value in data.options.solvers[0].options.iteritems() # if not key == 'timelimit')) if not data.options.solvers[0].options_string is None: opt.set_options(data.options.solvers[0].options_string) # # Use the solver manager to call the optimizer # results = solver_mngr.solve(instance, opt=opt, **keywords) else: # # Get the solver option arguments # if len( data.options.solvers[0].options ) > 0 and not data.options.solvers[0].options_string is None: # If both 'options' and 'options_string' were specified, then create a # single options string that is passed to the solver. ostring = " ".join("%s=%s" % (key, value) for key, value in data.options.solvers[0].options.iteritems() if not value is None) keywords['options'] = ostring + ' ' + data.options.solvers[ 0].options_string elif len(data.options.solvers[0].options) > 0: keywords['options'] = data.options.solvers[0].options else: keywords['options'] = data.options.solvers[0].options_string # # If we're running remotely, then we pass the optimizer name to the solver # manager. # results = solver_mngr.solve(instance, opt=solver, **keywords) if (pympler_available is True) and \ (data.options.runtime.profile_memory >= 1): global memory_data mem_used = muppy.get_size(muppy.get_objects()) if mem_used > data.local.max_memory: data.local.max_memory = mem_used print(" Total memory = %d bytes following optimization" % mem_used) return pyutilib.misc.Options(results=results, opt=solver, local=data.local)
vert_init_commodities(vertex, ('Elec', 'Gas', 'Heat'), [('Elec', 0, 100000), ('Gas', 0, 5000)]) profile_log['grid_data'] = timenow() - extendgrid # Non spatial input data_spreadsheet = os.path.join(base_directory, 'data.xlsx') excelread = timenow() data = read_excel(data_spreadsheet) profile_log['excel_read'] = timenow() - excelread # Create and solve model rivusmain = timenow() prob = create_model(data, vertex, edge) profile_log['rivus_main'] = timenow() - rivusmain solver = SolverFactory(config['solver']) solver = setup_solver(solver) startsolver = timenow() result = solver.solve(prob, tee=True) profile_log['solver'] = timenow() - startsolver # Handling results if not os.path.exists(result_dir): os.makedirs(result_dir) if SAVE_PICKLE: print('Saving pickle...') rivuspickle = timenow() save(prob, os.path.join(result_dir, 'prob.pgz')) profile_log['save_data'] = timenow() - rivuspickle
def run_scenario(scenario): # scenario name sce = scenario.__name__ sce_nice_name = sce.replace('_', ' ').title() # prepare input data data = rivus.read_excel(data_spreadsheet) vertex = pdshp.read_shp(vertex_shapefile) edge = prepare_edge(edge_shapefile, building_shapefile) # apply scenario function to input data data, vertex, edge = scenario(data, vertex, edge) # create & solve model prob = rivus.create_model(data, vertex, edge) if PYOMO3: prob = prob.create() # no longer needed in Pyomo 4+ optim = SolverFactory('gurobi') optim = setup_solver(optim) result = optim.solve(prob, tee=True) if PYOMO3: prob.load(result) # no longer needed in Pyomo 4+ # create result directory if not existent result_dir = os.path.join('result', os.path.basename(base_directory)) if not os.path.exists(result_dir): os.makedirs(result_dir) # report rivus.report(prob, os.path.join(result_dir, 'report.xlsx')) # plots for com, plot_type in [('Elec', 'caps'), ('Heat', 'caps'), ('Gas', 'caps'), ('Elec', 'peak'), ('Heat', 'peak')]: # two plot variants for plot_annotations in [False, True]: # create plot fig = rivus.plot(prob, com, mapscale=False, tick_labels=False, plot_demand=(plot_type == 'peak'), annotations=plot_annotations) plt.title('') # save to file for ext, transp in [('png', True), ('png', False), ('pdf', True)]: transp_str = ('-transp' if transp and ext != 'pdf' else '') annote_str = ('-annote' if plot_annotations else '') # determine figure filename from scenario name, plot type, # commodity, transparency, annotations and extension fig_filename = '{}-{}-{}{}{}.{}'.format( sce, plot_type, com, transp_str, annote_str, ext) fig_filename = os.path.join(result_dir, fig_filename) fig.savefig(fig_filename, dpi=300, bbox_inches='tight', transparent=transp) return prob
def _perform_queue(self, ah, *args, **kwds): """ Perform the queue operation. This method returns the ActionHandle, and the ActionHandle status indicates whether the queue was successful. """ solver = kwds.pop('solver', kwds.pop('opt', None)) if solver is None: raise ActionManagerError( "No solver passed to %s, use keyword option 'solver'" % (type(self).__name__) ) if not isinstance(solver, six.string_types): solver = solver.name # # Handle ephemeral solvers options here. These # will override whatever is currently in the options # dictionary, but we will reset these options to # their original value at the end of this method. # ephemeral_solver_options = {} ephemeral_solver_options.update(kwds.pop('options', {})) ephemeral_solver_options.update( OptSolver._options_string_to_dict(kwds.pop('options_string', ''))) opt = SolverFactory('_neos') opt._presolve(*args, **kwds) # # Map NEOS name, using lowercase convention in Pyomo # if len(self._solvers) == 0: for name in self.kestrel.solvers(): if name.endswith('AMPL'): self._solvers[ name[:-5].lower() ] = name[:-5] if not solver in self._solvers: raise ActionManagerError("Solver '%s' is not recognized by NEOS" % solver) # # Apply kestrel # os.environ['kestrel_options'] = 'solver=%s' % self._solvers[solver] solver_options = {} for key in opt.options: solver_options[key]=opt.options[key] solver_options.update(ephemeral_solver_options) options = opt._get_options_string(solver_options) if not options == "": os.environ[self._solvers[solver].lower()+'_options'] = opt._get_options_string() xml = self.kestrel.formXML(opt._problem_files[0]) (jobNumber, password) = self.kestrel.submit(xml) ah.job = jobNumber ah.password = password # # Store action handle, and return # self._ah[jobNumber] = ah self._neos_log[jobNumber] = (0, "") self._opt_data[jobNumber] = (opt, opt._smap_id, opt._load_solutions, opt._select_index, opt._default_variable_value) self._args[jobNumber] = args return ah
# Equation 10 m.C2Constraint = Constraint(m.Tm, rule=C2_constraint_rule) # Equation 11 #m.dsmup2Constraint = Constraint(m.tm, rule=dsmup2_constraint_rule) # Power m.power1Constraint = Constraint(m.tm, rule=power1_constraint_rule) m.power2Constraint = Constraint(m.tm, rule=power2_constraint_rule) # Objective m.obj = Objective(rule=obj_expression_cost, sense=minimize) ############################################################################### # SOLVE # solve model and read results optim = SolverFactory('cbc') result = optim.solve(m, tee=False) # Check obj or var example print('Objective:', m.obj()) output(m) filename = os.path.join(os.path.dirname(__file__), './Comparisson/dsm_pyomo.lp') m.write(filename, io_options={'symbolic_solver_labels': True}) #import pdb; pdb.set_trace()
import pyomo.environ from pyomo.opt.base import SolverFactory # config data_file = 'mnl.xlsx' params = {'r_heat':0.07} # only specify changed values timesteps = [(1600,.8),(1040,.5)] # list of (duration [hours], scaling_factor) tuples # annual fulload hours = sum(t, duration[t]*sf[t]) = 1800 # read vertices and edges from Excel data_file # lines 2 and 3 are just a fancy way of writing # vertex = dfs['Vertex'] # edge = dfs['Edge'] # while scaling better when the number of spreadsheets increase data = dhmin.read_excel(data_file) vertex, edge = data['Vertex'], data['Edge'] # get model # create instance # solver interface (GLPK) prob = dhmin.create_model(vertex, edge, params, timesteps) optim = SolverFactory('glpk') prob.write('rundh.lp', io_options={'symbolic_solver_labels':True}) result = optim.solve(prob, timelimit=30, tee=True) prob.solutions.load_from(result) # use special-purpose function to plot power flows dhmintools.plot_flows_min(prob)
def run_scenario(input_file, timesteps, scenario, result_dir): """ run an urbs model for given input, time steps and scenario Args: input_file: filename to an Excel spreadsheet for urbs.read_excel timesteps: a list of timesteps, e.g. range(0,8761) scenario: a scenario function that modifies the input data dict result_dir: directory name for result spreadsheet and plots Returns: the urbs model instance """ # scenario name, read and modify data for scenario sce = scenario.__name__ data = urbs.read_excel(input_file) data = scenario(data) # create model, solve it, read results prob = urbs.create_model(data, timesteps) optim = SolverFactory('glpk') # cplex, glpk, gurobi, ... result = optim.solve(prob, tee=True) prob.solutions.load_from(result) # refresh time stamp string now = prob.created # write report to spreadsheet urbs.report( prob, os.path.join(result_dir, '{}-{}.xlsx').format(sce, now), prob.com_demand, prob.sit) # store optimisation problem for later re-analysis urbs.save( prob, os.path.join(result_dir, '{}-{}.pgz').format(sce, now)) # add or change plot colors my_colors = { 'Vled Haven': (230, 200, 200), 'Stryworf Key': (200, 230, 200), 'Qlyph Archipelago': (200, 200, 230), 'Jepid Island': (215,215,215)} for country, color in my_colors.items(): urbs.COLORS[country] = color # create timeseries plot for each demand (site, commodity) timeseries for sit, com in prob.demand.columns: # create figure fig = urbs.plot(prob, com, sit) # change the figure title ax0 = fig.get_axes()[0] nice_sce_name = sce.replace('_', ' ').title() new_figure_title = ax0.get_title().replace( 'Energy balance of ', '{}: '.format(nice_sce_name)) ax0.set_title(new_figure_title) # save plot to files for ext in ['png', 'pdf']: fig_filename = os.path.join( result_dir, '{}-{}-{}-{}.{}').format(sce, com, sit, now, ext) fig.savefig(fig_filename, bbox_inches='tight') return prob