def solve(self, model, timer: HierarchicalTimer = None): self.available(exception_flag=True) if timer is None: timer = HierarchicalTimer() try: TempfileManager.push() if self.config.filename is None: self._filename = TempfileManager.create_tempfile() else: self._filename = self.config.filename TempfileManager.add_tempfile(self._filename + '.lp', exists=False) TempfileManager.add_tempfile(self._filename + '.soln', exists=False) TempfileManager.add_tempfile(self._filename + '.log', exists=False) timer.start('write lp file') self._writer.write(model, self._filename + '.lp', timer=timer) timer.stop('write lp file') res = self._apply_solver(timer) if self.config.report_timing: logger.info('\n' + str(timer)) return res finally: # finally, clean any temporary files registered with the # temp file manager, created/populated *directly* by this # plugin. TempfileManager.pop(remove=not self.config.keepfiles) if not self.config.keepfiles: self._filename = None if self.config.report_timing: print(timer)
def test_clear(self): """Test clear logic""" TempfileManager.push() OUTPUT = open(tempdir + 'pushpop2', 'w') OUTPUT.write('tempfile\n') OUTPUT.close() os.mkdir(tempdir + 'pushpopdir2') TempfileManager.add_tempfile(tempdir + 'pushpop2') TempfileManager.add_tempfile(tempdir + 'pushpopdir2') TempfileManager.push() OUTPUT = open(tempdir + 'pushpop2a', 'w') OUTPUT.write('tempfile\n') OUTPUT.close() os.mkdir(tempdir + 'pushpopdir2a') TempfileManager.add_tempfile(tempdir + 'pushpop2a') TempfileManager.add_tempfile(tempdir + 'pushpopdir2a') TempfileManager.clear_tempfiles() if os.path.exists(tempdir + 'pushpop2a'): self.fail("clear_tempfiles() failed to clean out files") if os.path.exists(tempdir + 'pushpopdir2a'): self.fail("clear_tempfiles() failed to clean out directories") if os.path.exists(tempdir + 'pushpop2'): self.fail("clear_tempfiles() failed to clean out files") if os.path.exists(tempdir + 'pushpopdir2'): self.fail("clear_tempfiles() failed to clean out directories")
def test_open_tempfile_windows(self): TempfileManager.push() fname = TempfileManager.create_tempfile() f = open(fname) try: _orig = tempfiles.deletion_errors_are_fatal tempfiles.deletion_errors_are_fatal = True with self.assertRaisesRegex(WindowsError, ".*process cannot access the file"): TempfileManager.pop() finally: tempfiles.deletion_errors_are_fatal = _orig f.close() os.remove(fname) TempfileManager.push() fname = TempfileManager.create_tempfile() f = open(fname) log = StringIO() try: _orig = tempfiles.deletion_errors_are_fatal tempfiles.deletion_errors_are_fatal = False with LoggingIntercept(log, 'pyomo.common'): TempfileManager.pop() self.assertIn("Unable to delete temporary file", log.getvalue()) finally: tempfiles.deletion_errors_are_fatal = _orig f.close() os.remove(fname)
def test_deprecated_tempdir(self): TempfileManager.push() try: tmpdir = TempfileManager.create_tempdir() _orig = pyutilib_mngr.tempdir pyutilib_mngr.tempdir = tmpdir TempfileManager.tempdir = None log = StringIO() with LoggingIntercept(log, 'pyomo'): fname = TempfileManager.create_tempfile() self.assertIn( "The use of the PyUtilib TempfileManager.tempdir " "to specify the default location for Pyomo " "temporary files", log.getvalue().replace("\n", " ")) log = StringIO() with LoggingIntercept(log, 'pyomo'): dname = TempfileManager.create_tempdir() self.assertIn( "The use of the PyUtilib TempfileManager.tempdir " "to specify the default location for Pyomo " "temporary directories", log.getvalue().replace("\n", " ")) finally: TempfileManager.pop() pyutilib_mngr.tempdir = _orig
def _presolve(self, *args, **kwds): """ Peform presolves. """ TempfileManager.push() self._keepfiles = kwds.pop("keepfiles", False) self._define_signal_handlers = kwds.pop('use_signal_handling', None) OptSolver._presolve(self, *args, **kwds) # # Verify that the input problems exists # for filename in self._problem_files: if not os.path.exists(filename): msg = 'Solver failed to locate input problem file: %s' raise ValueError(msg % filename) # # Create command line # self._command = self.create_command_line(self.executable(), self._problem_files) self._log_file = self._command.log_file # # The pre-cleanup is probably unncessary, but also not harmful. # if (self._log_file is not None) and \ os.path.exists(self._log_file): os.remove(self._log_file) if (self._soln_file is not None) and \ os.path.exists(self._soln_file): os.remove(self._soln_file)
def solve(self, model, timer: HierarchicalTimer = None): avail = self.available() if not avail: raise PyomoException( f'Solver {self.__class__} is not available ({avail}).') if self._last_results_object is not None: self._last_results_object.solution_loader.invalidate() if timer is None: timer = HierarchicalTimer() try: TempfileManager.push() if self.config.filename is None: self._filename = TempfileManager.create_tempfile() else: self._filename = self.config.filename TempfileManager.add_tempfile(self._filename + '.lp', exists=False) TempfileManager.add_tempfile(self._filename + '.log', exists=False) timer.start('write lp file') self._writer.write(model, self._filename + '.lp', timer=timer) timer.stop('write lp file') res = self._apply_solver(timer) self._last_results_object = res if self.config.report_timing: logger.info('\n' + str(timer)) return res finally: # finally, clean any temporary files registered with the # temp file manager, created/populated *directly* by this # plugin. TempfileManager.pop(remove=not self.config.keepfiles) if not self.config.keepfiles: self._filename = None
def solve(self, sp, *args, **kwds): """ Solve a stochastic program. See the 'solve' method on the base class for additional keyword documentation. Args: sp: The stochastic program to solve. keep_solver_files (bool): Retain temporary solver input and output files after the solve completes. *args: Passed to the derived solver class (see the _solve_impl method). **kwds: Passed to the derived solver class (see the _solve_impl method). Returns: A results object with information about the solution. """ self._files.clear() assert self.executable is not None keep_solver_files = kwds.pop("keep_solver_files", False) TempfileManager.push() try: return super(SPSolverShellCommand, self).solve(sp, *args, **kwds) finally: # cleanup TempfileManager.pop(remove=not keep_solver_files) if keep_solver_files: logger.info("Retaining the following solver files:\n" + pprint.pformat(self.files))
def test_pushpop1_dir(self): """Test pushpop logic with directories""" TempfileManager.push() os.mkdir(tempdir + 'pushpop1') TempfileManager.add_tempfile(tempdir + 'pushpop1') TempfileManager.pop() if os.path.exists(tempdir + 'pushpop1'): self.fail("pop() failed to clean out directories")
def do_setup(self, flag): TempfileManager.push() if flag: if not cplexamp_available: self.skipTest("The 'cplexamp' command is not available") self.asl = SolverFactory('asl:cplexamp') else: self.asl = SolverFactory('_mock_asl:cplexamp')
def _presolve(self, *args, **kwds): # create a context in the temporary file manager for # this plugin - is "pop"ed in the _postsolve method. TempfileManager.push() # if the first argument is a string (representing a filename), # then we don't have an instance => the solver is being applied # to a file. self._warm_start_solve = kwds.pop('warmstart', False) self._warm_start_file_name = kwds.pop('warmstart_file', None) user_warmstart = False if self._warm_start_file_name is not None: user_warmstart = True # the input argument can currently be one of two things: an # instance or a filename. if a filename is provided and a # warm-start is indicated, we go ahead and create the temporary # file - assuming that the user has already, via some external # mechanism, invoked warm_start() with a instance to create the # warm start file. if self._warm_start_solve and \ isinstance(args[0], str): # we assume the user knows what they are doing... pass elif self._warm_start_solve and \ (not isinstance(args[0], str)): # assign the name of the warm start file *before* calling # the base class presolve - the base class method ends up # creating the command line, and the warm start file-name is # (obviously) needed there. if self._warm_start_file_name is None: assert not user_warmstart self._warm_start_file_name = TempfileManager.create_tempfile( suffix='.gurobi.mst') # let the base class handle any remaining keywords/actions. ILMLicensedSystemCallSolver._presolve(self, *args, **kwds) # NB: we must let the base class presolve run first so that the # symbol_map is actually constructed! if (len(args) > 0) and (not isinstance(args[0], str)): if len(args) != 1: raise ValueError( "GUROBI _presolve method can only handle a single " "problem instance - %s were supplied" % (len(args), )) # write the warm-start file - currently only supports MIPs. # we only know how to deal with a single problem instance. if self._warm_start_solve and (not user_warmstart): start_time = time.time() self._warm_start(args[0]) end_time = time.time() if self._report_timing is True: print("Warm start write time=%.2f seconds" % (end_time - start_time))
def _run_ipopt_with_stats(model, solver, max_iter=500, max_cpu_time=120): """ Run the solver (must be ipopt) and return the convergence statistics Parameters ---------- model : Pyomo model The pyomo model to be solved solver : Pyomo solver The pyomo solver to use - it must be ipopt, but with whichever options are preferred max_iter : int The maximum number of iterations to allow for ipopt max_cpu_time : int The maximum cpu time to allow for ipopt (in seconds) Returns ------- Returns a tuple with (solve status object, bool (solve successful or not), number of iters, solve time) """ # ToDo: Check that the "solver" is, in fact, IPOPT TempfileManager.push() tempfile = TempfileManager.create_tempfile(suffix='ipopt_out', text=True) opts = { 'output_file': tempfile, 'max_iter': max_iter, 'max_cpu_time': max_cpu_time } status_obj = solver.solve(model, options=opts, tee=True) solved = True if status_obj.solver.termination_condition != TerminationCondition.optimal: solved = False iters = 0 time = 0 # parse the output file to get the iteration count, solver times, etc. with open(tempfile, 'r') as f: for line in f: if line.startswith('Number of Iterations....:'): tokens = line.split() iters = int(tokens[3]) elif line.startswith( 'Total CPU secs in IPOPT (w/o function evaluations) ='): tokens = line.split() time += float(tokens[9]) elif line.startswith( 'Total CPU secs in NLP function evaluations ='): tokens = line.split() time += float(tokens[8]) TempfileManager.pop(remove=True) return status_obj, solved, iters, time
def test_pushpop1(self): """Test pushpop logic""" TempfileManager.push() OUTPUT = open(tempdir + 'pushpop1', 'w') OUTPUT.write('tempfile\n') OUTPUT.close() TempfileManager.add_tempfile(tempdir + 'pushpop1') TempfileManager.pop() if os.path.exists(tempdir + 'pushpop1'): self.fail("pop() failed to clean out files")
def __enter__(self): self._cwd = os.getcwd() # Add a new context TempfileManager.push() # Create a new tempdir in this context self._tempdir = TempfileManager.create_tempdir( suffix=self._suffix, prefix=self._prefix, dir=self._dir, ) os.chdir(self._tempdir)
def setUp(self): if not scip_available: self.skipTest("The 'scipampl' command is not available") TempfileManager.push() self.scip = SolverFactory('scip', solver_io='nl') m = self.model = ConcreteModel() m.v = Var() m.o = Objective(expr=m.v) m.c = Constraint(expr=m.v >= 1)
def _presolve(self, **kwds): warmstart_flag = kwds.pop('warmstart', False) self._keepfiles = kwds.pop('keepfiles', False) self._save_results = kwds.pop('save_results', True) self._integer_only_warmstarts = kwds.pop('integer_only_warmstarts', False) # create a context in the temporary file manager for # this plugin - is "pop"ed in the _postsolve method. TempfileManager.push() self.results = None model = self._pyomo_model # this implies we have a custom solution "parser", # preventing the OptSolver _presolve method from # creating one self._results_format = ResultsFormat.soln # use the base class _presolve to consume the # important keywords OptSolver._presolve(self, **kwds) # *********************************************************** # The following code is only needed for backwards compatability of load_solutions=False. # If we ever only want to support the load_vars, load_duals, etc. methods, then this can be deleted. if self._save_results: self._smap_id = id(self._symbol_map) if isinstance(self._pyomo_model, IBlock): # BIG HACK (see pyomo.core.kernel write function) if not hasattr(self._pyomo_model, "._symbol_maps"): setattr(self._pyomo_model, "._symbol_maps", {}) getattr(self._pyomo_model, "._symbol_maps")[self._smap_id] = self._symbol_map else: self._pyomo_model.solutions.add_symbol_map(self._symbol_map) # *********************************************************** if warmstart_flag: if self.warm_start_capable(): self._warm_start() else: raise ValueError( '{0} solver plugin is not capable of warmstart.'.format( type(self))) if self._log_file is None: self._log_file = TempfileManager.create_tempfile(suffix='.log')
def setUp(self): if not ipopt_available: self.skipTest("The 'ipopt' command is not available") TempfileManager.push() self.asl = pyomo.opt.SolverFactory('asl:ipopt', keepfiles=True) self.ipopt = pyomo.opt.SolverFactory('ipopt', keepfiles=True) # The sisser CUTEr instance # Formulated in Pyomo by Carl D. Laird, Daniel P. Word, Brandon # C. Barrera and Saumyajyoti Chaudhuri # Taken from: # Source: # F.S. Sisser, # "Elimination of bounds in optimization problems by transforming # variables", # Mathematical Programming 20:110-121, 1981. # See also Buckley#216 (p. 91) # SIF input: Ph. Toint, Dec 1989. # classification OUR2-AN-2-0 sisser_instance = ConcreteModel() sisser_instance.N = RangeSet(1, 2) sisser_instance.xinit = Param(sisser_instance.N, initialize={ 1: 1.0, 2: 0.1 }) def fa(model, i): return value(model.xinit[i]) sisser_instance.x = Var(sisser_instance.N, initialize=fa) def f(model): return 3 * model.x[1]**4 - 2 * (model.x[1] * model.x[2])**2 + 3 * model.x[2]**4 sisser_instance.f = Objective(rule=f, sense=minimize) self.sisser_instance = sisser_instance
def generate_scenario_tree_image(options): with ScenarioTreeInstanceFactory( options.model_location, options.scenario_tree_location) as factory: scenario_tree = factory.generate_scenario_tree( downsample_fraction=options.scenario_tree_downsample_fraction, bundles=options.scenario_bundle_specification, random_bundles=options.create_random_bundles, random_seed=options.scenario_tree_random_seed, verbose=options.verbose) with TempfileManager.push(): tmpdotfile = TempfileManager.create_tempfile(suffix=".dot") scenario_tree.save_to_dot(tmpdotfile) os.system('dot -Tpdf -o %s %s' % (options.output_file, tmpdotfile)) print("Output Saved To: %s" % (options.output_file))
def setUp(self): TempfileManager.push() self.mock_model = self.get_mock_model() self.mock_cplex_shell = self.get_mock_cplex_shell(self.mock_model) self.mock_cplex_shell._priorities_file_name = TempfileManager.create_tempfile( suffix=".cplex.ord")
def setUp(self): TempfileManager.push()
def test_warm_start(self): m = ConcreteModel() m.x = Var() m.z = Var(domain=Integers) m.w = Var(domain=Boolean) m.c = Constraint(expr=m.x + m.z + m.w >= 0) m.o = Objective(expr=m.x + m.z + m.w) TempfileManager.push() tempdir = os.path.dirname(TempfileManager.create_tempfile()) TempfileManager.pop() sameDrive = os.path.splitdrive(tempdir)[0] == \ os.path.splitdrive(os.getcwd())[0] # At the moment, CBC does not cleanly handle windows-style drive # names in the MIPSTART file name (though at least 2.10.5). # # See https://github.com/coin-or/Cbc/issues/32 # The problematic source is https://github.com/coin-or/Cbc/blob/3dcedb27664ae458990e9d4d50bc11c2c55917a0/src/CbcSolver.cpp#L9445-L9459 # # We will try two different situations: running from the current # directory (which may or may not be on the same drive), and # then from the tempdir (which will be on the same drive). # Set some initial values for warm start. m.x.set_value(10) m.z.set_value(5) m.w.set_value(1) with SolverFactory("cbc") as opt, capture_output() as output: opt.solve(m, tee=True, warmstart=True, options={ 'sloglevel': 2, 'loglevel': 2}) log = output.getvalue() # Check if CBC loaded the warmstart file. self.assertIn('opening mipstart file', log) if sameDrive: # Only integer and binary variables are considered by CBC. self.assertIn('MIPStart values read for 2 variables.', log) # m.x is ignored because it is continuous, so cost should be 5+1 self.assertIn('MIPStart provided solution with cost 6', log) else: self.assertNotIn('MIPStart values read', log) # Set some initial values for warm start. m.x.set_value(10) m.z.set_value(5) m.w.set_value(1) try: _origDir = os.getcwd() os.chdir(tempdir) with SolverFactory("cbc") as opt, capture_output() as output: opt.solve(m, tee=True, warmstart=True, options={ 'sloglevel': 2, 'loglevel': 2}) finally: os.chdir(_origDir) log = output.getvalue() # Check if CBC loaded the warmstart file. self.assertIn('opening mipstart file', log) # Only integer and binary variables are considered by CBC. self.assertIn('MIPStart values read for 2 variables.', log) # m.x is ignored because it is continuous, so cost should be 5+1 self.assertIn('MIPStart provided solution with cost 6', log)
def _presolve(self, *args, **kwds): # create a context in the temporary file manager for # this plugin - is "pop"ed in the _postsolve method. TempfileManager.push() # if the first argument is a string (representing a filename), # then we don't have an instance => the solver is being applied # to a file. self._warm_start_solve = kwds.pop('warmstart', False) self._warm_start_file_name = kwds.pop('warmstart_file', None) user_warmstart = False if self._warm_start_file_name is not None: user_warmstart = True # the input argument can currently be one of two things: an # instance or a filename. if a filename is provided and a # warm-start is indicated, we go ahead and create the temporary # file - assuming that the user has already, via some external # mechanism, invoked warm_start() with a instance to create the # warm start file. if self._warm_start_solve and isinstance(args[0], str): # we assume the user knows what they are doing... pass elif self._warm_start_solve and (not isinstance(args[0], str)): # assign the name of the warm start file *before* calling # the base class presolve - the base class method ends up # creating the command line, and the warm start file-name is # (obviously) needed there. if self._warm_start_file_name is None: assert not user_warmstart self._warm_start_file_name = TempfileManager.create_tempfile( suffix='.cbc.soln') # CBC does not cleanly handle windows-style drive names in the # MIPSTART file name (though at least 2.10.5). # # See https://github.com/coin-or/Cbc/issues/32 # The problematic source is https://github.com/coin-or/Cbc/blob/3dcedb27664ae458990e9d4d50bc11c2c55917a0/src/CbcSolver.cpp#L9445-L9459 if self._warm_start_file_name is not None: _drive, _path = os.path.splitdrive(self._warm_start_file_name) if _drive: _cwd_drive = os.path.splitdrive(os.getcwd())[0] if _cwd_drive.lower() == _drive.lower(): self._warm_start_file_name = _path else: logger.warning( "warmstart_file points to a file on a drive " "different from the current working directory. " "CBC is likely to (silently) ignore the warmstart.") # let the base class handle any remaining keywords/actions. # let the base class handle any remaining keywords/actions. super(CBCSHELL, self)._presolve(*args, **kwds) # NB: we must let the base class presolve run first so that the # symbol_map is actually constructed! if (len(args) > 0) and (not isinstance(args[0], str)): if len(args) != 1: raise ValueError( "CBCplugin _presolve method can only handle a single " "problem instance - %s were supplied" % (len(args), )) # write the warm-start file - currently only supports MIPs. # we only know how to deal with a single problem instance. if self._warm_start_solve and (not user_warmstart): start_time = time.time() self._warm_start(args[0]) end_time = time.time() if self._report_timing is True: print("Warm start write time=%.2f seconds" % (end_time - start_time))
def setUp(self): TempfileManager.tempdir = tempdir TempfileManager.push() if os.path.exists(tempdir): shutil.rmtree(tempdir) os.mkdir(tempdir)
def setUp(self): global tempdir tempdir = tempfile.mkdtemp() + os.sep TempfileManager.tempdir = tempdir TempfileManager.push()
def run_command(command=None, parser=None, args=None, name='unknown', data=None, options=None): """ Execute a function that processes command-line arguments and then calls a command-line driver. This function provides a generic facility for executing a command function is rather generic. This function is segregated from the driver to enable profiling of the command-line execution. Required: command: The name of a function that will be executed to perform process the command-line options with a parser object. parser: The parser object that is used by the command-line function. Optional: options: If this is not None, then ignore the args option and use this to specify command options. args: Command-line arguments that are parsed. If this value is `None`, then the arguments in `sys.argv` are used to parse the command-line. name: Specifying the name of the command-line (for error messages). data: A container of labeled data. Returned: retval: Return values from the command-line execution. errorcode: 0 if Pyomo ran successfully """ # # # Parse command-line options # # retval = None errorcode = 0 if options is None: try: if type(args) is argparse.Namespace: _options = args else: _options = parser.parse_args(args=args) # Replace the parser options object with a pyutilib.misc.Options object options = Options() for key in dir(_options): if key[0] != '_': val = getattr(_options, key) if not isinstance(val, types.MethodType): options[key] = val except SystemExit: # the parser throws a system exit if "-h" is specified - catch # it to exit gracefully. return Container(retval=retval, errorcode=errorcode) # # Configure loggers # configure_loggers(options=options) # # Call the main Pyomo runner with profiling # TempfileManager.push() pcount = options.runtime.profile_count if pcount > 0: # Defer import of profiling packages until we know that they # are needed try: try: import cProfile as profile except ImportError: import profile import pstats except ImportError: configure_loggers(shutdown=True) raise ValueError( "Cannot use the 'profile' option: the Python " "'profile' or 'pstats' package cannot be imported!") tfile = TempfileManager.create_tempfile(suffix=".profile") tmp = profile.runctx( command.__name__ + '(options=options,parser=parser)', command.__globals__, locals(), tfile) p = pstats.Stats(tfile).strip_dirs() p.sort_stats('time', 'cumulative') p = p.print_stats(pcount) p.print_callers(pcount) p.print_callees(pcount) p = p.sort_stats('cumulative', 'calls') p.print_stats(pcount) p.print_callers(pcount) p.print_callees(pcount) p = p.sort_stats('calls') p.print_stats(pcount) p.print_callers(pcount) p.print_callees(pcount) retval = tmp else: # # Call the main Pyomo runner without profiling # TempfileManager.push() try: retval = command(options=options, parser=parser) except SystemExit: err = sys.exc_info()[1] # # If debugging is enabled or the 'catch' option is specified, then # exit. Otherwise, print an "Exiting..." message. # if __debug__ and (options.runtime.logging == 'debug' or options.runtime.catch_errors): configure_loggers(shutdown=True) sys.exit(0) print('Exiting %s: %s' % (name, str(err))) errorcode = err.code except Exception: err = sys.exc_info()[1] # # If debugging is enabled or the 'catch' option is specified, then # pass the exception up the chain (to pyomo_excepthook) # if __debug__ and (options.runtime.logging == 'debug' or options.runtime.catch_errors): configure_loggers(shutdown=True) TempfileManager.pop(remove=not options.runtime.keep_files) raise if not options.model is None and not options.model.save_file is None: model = "model " + options.model.save_file else: model = "model" global filter_excepthook if filter_excepthook: action = "loading" else: action = "running" msg = "Unexpected exception while %s %s:\n " % (action, model) # # This handles the case where the error is propagated by a KeyError. # KeyError likes to pass raw strings that don't handle newlines # (they translate "\n" to "\\n"), as well as tacking on single # quotes at either end of the error message. This undoes all that. # errStr = str(err) if type(err) == KeyError and errStr != "None": errStr = str(err).replace(r"\n", "\n")[1:-1] logger.error(msg + errStr) errorcode = 1 configure_loggers(shutdown=True) if options.runtime.disable_gc: gc.enable() TempfileManager.pop(remove=not options.runtime.keep_files) return Container(retval=retval, errorcode=errorcode)
def __init__(self, pyomo_model): """ Pyomo nonlinear program interface Parameters ---------- pyomo_model: pyomo.environ.ConcreteModel Pyomo concrete model """ TempfileManager.push() try: # get the temp file names for the nl file nl_file = TempfileManager.create_tempfile( suffix='pynumero.nl') # The current AmplInterface code only supports a single # objective function Therefore, we throw an error if there # is not one (and only one) active objective function. This # is better than adding a dummy objective that the user does # not know about (since we do not have a good place to # remove this objective later) # # TODO: extend the AmplInterface and the AslNLP to correctly # handle this # # This currently addresses issue #1217 objectives = list(pyomo_model.component_data_objects( ctype=pyo.Objective, active=True, descend_into=True)) if len(objectives) != 1: raise NotImplementedError( 'The ASL interface and PyomoNLP in PyNumero currently ' 'only support single objective problems. Deactivate ' 'any extra objectives you may have, or add a dummy ' 'objective (f(x)=0) if you have a square problem.') self._objective = objectives[0] # write the nl file for the Pyomo model and get the symbolMap fname, symbolMap = WriterFactory('nl')( pyomo_model, nl_file, lambda x:True, {}) # create component maps from vardata to idx and condata to idx self._vardata_to_idx = vdidx = ComponentMap() self._condata_to_idx = cdidx = ComponentMap() # TODO: Are these names totally consistent? for name, obj in six.iteritems(symbolMap.bySymbol): if name[0] == 'v': vdidx[obj()] = int(name[1:]) elif name[0] == 'c': cdidx[obj()] = int(name[1:]) # The NL writer advertises the external function libraries # through the PYOMO_AMPLFUNC environment variable; merge it # with any preexisting AMPLFUNC definitions amplfunc = "\n".join( val for val in ( os.environ.get('AMPLFUNC', ''), os.environ.get('PYOMO_AMPLFUNC', ''), ) if val) with CtypesEnviron(AMPLFUNC=amplfunc): super(PyomoNLP, self).__init__(nl_file) # keep pyomo model in cache self._pyomo_model = pyomo_model # Create ComponentMap corresponding to equality constraint indices # This must be done after the call to super-init. full_to_equality = self._con_full_eq_map equality_mask = self._con_full_eq_mask self._condata_to_eq_idx = ComponentMap( (con, full_to_equality[i]) for con, i in six.iteritems(self._condata_to_idx) if equality_mask[i] ) full_to_inequality = self._con_full_ineq_map inequality_mask = self._con_full_ineq_mask self._condata_to_ineq_idx = ComponentMap( (con, full_to_inequality[i]) for con, i in six.iteritems(self._condata_to_idx) if inequality_mask[i] ) finally: # delete the nl file TempfileManager.pop()
def run_command(command=None, parser=None, args=None, name='unknown', data=None, options=None): """ Execute a function that processes command-line arguments and then calls a command-line driver. This function provides a generic facility for executing a command function is rather generic. This function is segregated from the driver to enable profiling of the command-line execution. Required: command: The name of a function that will be executed to perform process the command-line options with a parser object. parser: The parser object that is used by the command-line function. Optional: options: If this is not None, then ignore the args option and use this to specify command options. args: Command-line arguments that are parsed. If this value is `None`, then the arguments in `sys.argv` are used to parse the command-line. name: Specifying the name of the command-line (for error messages). data: A container of labeled data. Returned: retval: Return values from the command-line execution. errorcode: 0 if Pyomo ran successfully """ # # # Parse command-line options # # if options is None: try: if type(args) is argparse.Namespace: _options = args else: _options = parser.parse_args(args=args) # Replace the parser options object with a # pyomo.common.collections.Options object options = Bunch() for key in dir(_options): if key[0] != '_': val = getattr(_options, key) if not isinstance(val, types.MethodType): options[key] = val except SystemExit: # the parser throws a system exit if "-h" is specified - catch # it to exit gracefully. return Bunch(retval=None, errorcode=0) # # Configure loggers # TempfileManager.push() try: with PyomoCommandLogContext(options): retval, errorcode = _run_command_impl(command, parser, args, name, data, options) finally: if options.runtime.disable_gc: gc.enable() TempfileManager.pop(remove=not options.runtime.keep_files) return Bunch(retval=retval, errorcode=errorcode)
def setUp(self): if not 'glpk' in solvers: self.skipTest("GLPK is not installed") TempfileManager.push()
def setUp(self): TempfileManager.push() TempfileManager.tempdir = currdir