def test_help_solvers(self): with capture_output() as OUT: help_solvers() OUT = OUT.getvalue() self.assertTrue(re.search('Pyomo Solvers and Solver Managers', OUT)) self.assertTrue(re.search('Serial Solver', OUT)) # Test known solvers and metasolver flags # ASL is a metasolver self.assertTrue(re.search(r'\n \*asl ', OUT)) # MindtPY is bundled with Pyomo so should always be available self.assertTrue(re.search(r'\n \+mindtpy ', OUT)) for solver in ('ipopt', 'cbc', 'glpk'): s = SolverFactory(solver) if s.available(): self.assertTrue( re.search(r"\n \+%s " % solver, OUT), "' +%s' not found in help --solvers" % solver) else: self.assertTrue( re.search(r"\n %s " % solver, OUT), "' %s' not found in help --solvers" % solver) for solver in ('baron', ): s = SolverFactory(solver) if s.license_is_valid(): self.assertTrue( re.search(r"\n \+%s " % solver, OUT), "' +%s' not found in help --solvers" % solver) elif s.available(): self.assertTrue( re.search(r"\n \-%s " % solver, OUT), "' -%s' not found in help --solvers" % solver) else: self.assertTrue( re.search(r"\n %s " % solver, OUT), "' %s' not found in help --solvers" % solver)
def select_tear_mip(self, G, solver, solver_io=None, solver_options={}): """ This finds optimal sets of tear edges based on two criteria. The primary objective is to minimize the maximum number of times any cycle is broken. The seconday criteria is to minimize the number of tears. This function creates a MIP problem in Pyomo with a doubly weighted objective and solves it with the solver arguments. """ model, bin_list = self.select_tear_mip_model(G) from pyomo.environ import SolverFactory opt = SolverFactory(solver, solver_io=solver_io) if not opt.available(exception_flag=False): raise ValueError( "Solver '%s' (solver_io=%r) is not available, please pass a " "different solver" % (solver, solver_io)) opt.solve(model, **solver_options) # collect final list by adding every edge with a "True" binary var tset = [] for i in range(len(bin_list)): if bin_list[i].value == 1: tset.append(i) return tset
def select_tear_mip(self, G, solver, solver_io=None, solver_options={}): """ This finds optimal sets of tear edges based on two criteria. The primary objective is to minimize the maximum number of times any cycle is broken. The seconday criteria is to minimize the number of tears. This function creates a MIP problem in Pyomo with a doubly weighted objective and solves it with the solver arguments. """ model, bin_list = self.select_tear_mip_model(G) from pyomo.environ import SolverFactory opt = SolverFactory(solver, solver_io=solver_io) if not opt.available(exception_flag=False): raise ValueError("Solver '%s' (solver_io=%r) is not available, please pass a " "different solver" % (solver, solver_io)) opt.solve(model, **solver_options) # collect final list by adding every edge with a "True" binary var tset = [] for i in range(len(bin_list)): if bin_list[i].value == 1: tset.append(i) return tset
def has_cplex_lp(): from pyomo.environ import SolverFactory try: cplex = SolverFactory('cplex',keepFiles=True) available = (not cplex.executable() is None) and cplex.available(False) return available except pyutilib.common.ApplicationError: return False
def __init__(self, k_aug=None, dot_sens=None): # The user may want to use their own k_aug/dot_sens solver # objects, i.e. with custom options or executable. if k_aug is None: k_aug = SolverFactory("k_aug") # TODO: Remove this if/when we support RH mode. k_aug.options["dsdp_mode"] = "" if dot_sens is None: dot_sens = SolverFactory("dot_sens") # TODO: Remove this if/when we support RH mode. dot_sens.options["dsdp_mode"] = "" if k_aug.available(): self._k_aug = k_aug else: raise RuntimeError("k_aug is not available.") if dot_sens.available(): self._dot_sens = dot_sens else: raise RuntimeError("dot_sens is not available") self.data = {fname: None for fname in known_files}
def test_help_solvers(self): with capture_output() as OUT: help_solvers() OUT = OUT.getvalue() self.assertTrue(re.search('Pyomo Solvers and Solver Managers', OUT)) self.assertTrue(re.search('Serial Solver', OUT)) # Test known solvers and metasolver flags # ASL is a metasolver self.assertTrue(re.search('asl +\+', OUT)) # PS is bundles with Pyomo so should always be available self.assertTrue(re.search('ps +\*', OUT)) for solver in ('ipopt','baron','cbc','glpk'): s = SolverFactory(solver) if s.available(): self.assertTrue(re.search("%s +\* [a-zA-Z]" % solver, OUT)) else: self.assertTrue(re.search("%s +[a-zA-Z]" % solver, OUT))
def pyomo_multi_stage(data, prob=None): """ Perform multi-stage optimization with PySP. Required: prob: Problem instance """ # # Error Checking # solvername = get_solvername(prob) prob_name = prob.getProblemOption('name',0) con_name = prob.getProblemOption('constraint', prob_name) if len(con_name) > 1: raise RuntimeError, "We don't know how to handle side-constraints within PySP" else: con_name = con_name[0] aggr_name = prob.getProblemOption('aggregate', prob_name) goal_name = prob.getConstraintOption('goal', con_name) if lower(goal_name) != 'ns': cost_name = prob.getCostOption('cost file', goal_name) if not cost_name is None: raise RuntimeError, "Cannot use a cost constraint goal with the %s solver" % solvername if aggr_name is not None: raise RuntimeError, "Cannot use a aggregation with the %s solver" % solvername # # Create the Pyomo data files # create_multistage_data(prob, data) # # Setup the PySP command-line # solvername = get_solvername(prob) # seed = prob.getSolverOption('seed') if solvername == 'ef': cmd = ['runef'] cmd.append('--output-solver-log') elif solvername == 'ph': cmd = ['runph'] cmd.append('-r') cmd.append('1.0') cmd.append('--solver') # # TODO: add an 'ef' solver option that specifies a sub-solver name # opt = SolverFactory('pico') if opt.available(False) and (not opt.executable() is None): cmd.append('pico') else: opt = SolverFactory('cbc') if opt.available(False) and (not opt.executable() is None): cmd.append('cbc') else: opt = SolverFactory('glpk') if opt.available(False) and (not opt.executable() is None): cmd.append('glpk') # cmd.append('-m') cmd.append('%s/multistage' % modeldir) cmd.append('-i') cmd.append('%s' % data.datadir) if not seed is None: cmd.append('--scenario-tree-seed') cmd.append(str(seed)) cmd.append('--solution-writer=pywst.sp.pyspsolutionwriter') cmd.append('--traceback') if solvername == 'ef': cmd.append('--solve') else: cmd.append('--linearize-nonbinary-penalty-terms=5') data.command_line = ' '.join(cmd) # # Run the solver # print "Running command ..." print ' '.join(cmd) rc, output = pyutilib.subprocess.run(cmd, tee=True) if rc != 0: print "ERROR executing the '%s' command" % solvername print output raise RuntimeError, "Bad return code for multi-stage solver: %d\n%s" % (rc, output) # # Read the JSON file # INPUT = open(solvername+'.json','r') results = json.load(INPUT) INPUT.close() stage2 = {} soln = [] for i in results: for j in results[i]: for k in results[i][j]: for l in results[i][j][k]: #print i,j,k,l val = results[i][j][k][l] if i == 'FirstStage' and j == 'RootNode' and k == 'Stage1Sensors' and val == 1.0: soln.append( eval(l) ) elif i == 'SecondStage': if not j in stage2: stage2[ j ] = [] if k == 'Stage2Sensors' and val == 1.0: loc = eval(l) if not loc in soln: stage2[ j ].append( loc ) data.solutions = [soln] data.stage2_solutions = stage2 # # Remove the data directory # if not prob.getConfigureOption('keepfiles'): shutil.rmtree(data.datadir)
# ___________________________________________________________________________ # # Pyomo: Python Optimization Modeling Objects # Copyright 2017 National Technology and Engineering Solutions of Sandia, LLC # Under the terms of Contract DE-NA0003525 with National Technology and # Engineering Solutions of Sandia, LLC, the U.S. Government retains certain # rights in this software. # This software is distributed under the 3-clause BSD License. # ___________________________________________________________________________ from pyomo.environ import SolverFactory, ConcreteModel, Var, Constraint, Objective, Integers, Boolean import pyutilib.th as unittest from pyomo.common.tee import capture_output opt_cbc = SolverFactory('cbc') cbc_available = opt_cbc.available(exception_flag=False) class CBCTests(unittest.TestCase): @unittest.skipIf(not cbc_available, "The CBC solver is not available") 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) # Set some initial values for warm start. m.x.set_value(10)
def get_solver_availability(): logging.disable(logging.WARNING) available = {} try: opt = SolverFactory('pico') available['pico'] = opt.available(False) and ( not opt.executable() is None) del opt except pyutilib.common.ApplicationError: available['pico'] = False try: opt = SolverFactory('cplex') available['cplex'] = opt.available(False) and ( not opt.executable() is None) del opt except pyutilib.common.ApplicationError: available['cplex'] = False try: opt = SolverFactory('cplex_direct') available['cplex_direct'] = opt.available(False) and ( not opt.executable() is None) del opt except pyutilib.common.ApplicationError: available['cplex_direct'] = False try: opt = SolverFactory('gurobi') available['gurobi'] = opt.available(False) and ( not opt.executable() is None) del opt except pyutilib.common.ApplicationError: available['gurobi'] = False try: opt = SolverFactory('gurobi_direct') available['gurobi_direct'] = opt.available(False) and ( not opt.executable() is None) del opt except pyutilib.common.ApplicationError: available['gurobi_direct'] = False try: opt = SolverFactory('glpk') available['glpk'] = opt.available(False) and ( not opt.executable() is None) del opt except pyutilib.common.ApplicationError: available['glpk'] = False try: opt = SolverFactory('cbc') available['cbc'] = opt.available(False) and ( not opt.executable() is None) del opt except pyutilib.common.ApplicationError: available['cbc'] = False try: opt = SolverFactory('xpress') available['xpress'] = opt.available(False) and ( not opt.executable() is None) del opt except pyutilib.common.ApplicationError: available['xpress'] = False logging.disable(logging.NOTSET) return available