def test_solvers(options=None, argv=None):
"""
The is the function executed by the command
pyomo test-solvers [solver ...]
"""
global rootdir
rootdir = os.getcwd()
if argv is None:
if options.debug:
if len(options.solver) == 0:
print("Testing all solvers")
else:
print("Testing solver", options.solver[0])
# Over-ride the value of sys.argv, which is used by unittest.main()
sys.argv = ['test_solver']
else:
sys.argv = argv
# Create the tests defined in the YAML configuration file
autotest_options = Options()
autotest_options.testname_format = "%s_TEST_%s"
pyutilib.autotest.create_test_suites(filename=currdir + 'test_solvers.yml',
_globals=globals(),
options=autotest_options)
# Execute the tests, using a custom test runner
runner = SolverTestRunner()
runner.options = options
unittest.main(module=globals()['__name__'], testRunner=runner)
def __init__(self):
"""
Constructor
"""
self._info = None
self._data = None
self.options = Options()
self.options.ncolumns = 1
def __init__(self, options):
if options is None:
options = Options()
if options.runtime is None:
options.runtime = Options()
self.options = options
self.fileLogger = None
self.original = None
def help_environment():
info = Options()
#
info.python = Options()
info.python.version = '%d.%d.%d' % sys.version_info[:3]
info.python.executable = sys.executable
info.python.platform = sys.platform
try:
packages = []
import pip
for package in pip.get_installed_distributions():
packages.append(
Options(name=package.project_name, version=package.version))
info.python.packages = packages
except:
pass
#
info.environment = Options()
path = os.environ.get('PATH', None)
if not path is None:
info.environment['shell path'] = path.split(os.pathsep)
info.environment['python path'] = sys.path
#
print('#')
print('# Information About the Python and Shell Environment')
print('#')
print(str(info))
def convert(options=Options(), parser=None, model_format=None):
global _format
if not model_format is None:
_format = model_format
#
# Import plugins
#
import pyomo.environ
if options.model.save_file is None:
if _format == ProblemFormat.cpxlp:
options.model.save_file = 'unknown.lp'
else:
options.model.save_file = 'unknown.' + str(_format)
options.model.save_format = _format
data = Options(options=options)
model_data = None
try:
pyomo.scripting.util.setup_environment(data)
pyomo.scripting.util.apply_preprocessing(data, parser=parser)
if data.error:
return Container()
model_data = pyomo.scripting.util.create_model(data)
model_data.options = options
except:
# TBD: I should be able to call this function in the case of
# an exception to perform cleanup. However, as it stands
# calling finalize with its default keyword value for
# model(=None) results in an a different error related to
# task port values. Not sure how to interpret that.
pyomo.scripting.util.finalize(data,
model=ConcreteModel(),
instance=None,
results=None)
raise
else:
pyomo.scripting.util.finalize(data, model=model_data.model)
return model_data
def __init__(self, **kwds):
"""Pass kwds to update the options attribute after setting defaults"""
self.cache = {}
options = self.options = Options()
# defaults
options["graph"] = None
options["tear_set"] = None
options["select_tear_method"] = "mip"
options["run_first_pass"] = True
options["solve_tears"] = True
options["guesses"] = ComponentMap()
options["default_guess"] = None
options["almost_equal_tol"] = 1.0E-8
options["log_info"] = False
options["tear_method"] = "Direct"
options["iterLim"] = 40
options["tol"] = 1.0E-5
options["tol_type"] = "abs"
options["report_diffs"] = False
options["accel_min"] = -5
options["accel_max"] = 0
options["tear_solver"] = "cplex"
options["tear_solver_io"] = None
options["tear_solver_options"] = {}
options.update(kwds)
def __init__(self, **kwds):
#
# Call base class constructor
#
kwds['type'] = 'xpress'
ILMLicensedSystemCallSolver.__init__(self, **kwds)
self.is_mip = kwds.pop('is_mip', False)
#
# Define valid problem formats and associated results formats
#
self._valid_problem_formats = [ProblemFormat.cpxlp, ProblemFormat.mps]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.cpxlp] = [ResultsFormat.soln]
self._valid_result_formats[ProblemFormat.mps] = [ResultsFormat.soln]
self.set_problem_format(ProblemFormat.cpxlp)
#
# Cache the problem type - LP or MIP. Xpress needs to know this
# on the command-line, and it matters when reading the solution file.
#
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.quadratic_objective = True
self._capabilities.quadratic_constraint = True
self._capabilities.integer = True
self._capabilities.sos1 = True
self._capabilities.sos2 = True
def __init__(self, **kwargs):
configure_glpk()
#
# Call base constructor
#
kwargs['type'] = 'glpk'
SystemCallSolver.__init__(self, **kwargs)
self._rawfile = None
#
# Valid problem formats, and valid results for each format
#
self._valid_problem_formats = [
ProblemFormat.cpxlp, ProblemFormat.mps, ProblemFormat.mod
]
self._valid_result_formats = {
ProblemFormat.mod: ResultsFormat.soln,
ProblemFormat.cpxlp: ResultsFormat.soln,
ProblemFormat.mps: ResultsFormat.soln,
}
self.set_problem_format(ProblemFormat.cpxlp)
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = True
def __init__(self, **kwds):
#
# Call base class constructor
#
kwds['type'] = 'baron'
SystemCallSolver.__init__(self, **kwds)
self._tim_file = None
self._valid_problem_formats = [ProblemFormat.bar]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.bar] = [ResultsFormat.soln]
self.set_problem_format(ProblemFormat.bar)
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.quadratic_objective = True
self._capabilities.quadratic_constraint = True
self._capabilities.integer = True
self._capabilities.sos1 = False
self._capabilities.sos2 = False
# CLH: Coppied from cpxlp.py, the cplex file writer.
# Keven Hunter made a nice point about using %.16g in his attachment
# to ticket #4319. I am adjusting this to %.17g as this mocks the
# behavior of using %r (i.e., float('%r'%<number>) == <number>) with
# the added benefit of outputting (+/-). The only case where this
# fails to mock the behavior of %r is for large (long) integers (L),
# which is a rare case to run into and is probably indicative of
# other issues with the model.
# *** NOTE ***: If you use 'r' or 's' here, it will break code that
# relies on using '%+' before the formatting character
# and you will need to go add extra logic to output
# the number's sign.
self._precision_string = '.17g'
def __init__(self, **kwds):
#
# Call base class constructor
#
kwds['type'] = 'cplex'
ILMLicensedSystemCallSolver.__init__(self, **kwds)
# NOTE: eventually both of the following attributes should be migrated to a common base class.
# is the current solve warm-started? a transient data member to communicate state information
# across the _presolve, _apply_solver, and _postsolve methods.
self._warm_start_solve = False
# related to the above, the temporary name of the MST warm-start file (if any).
self._warm_start_file_name = None
#
# Define valid problem formats and associated results formats
#
self._valid_problem_formats = [ProblemFormat.cpxlp, ProblemFormat.mps]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.cpxlp] = [ResultsFormat.soln]
self._valid_result_formats[ProblemFormat.mps] = [ResultsFormat.soln]
self.set_problem_format(ProblemFormat.cpxlp)
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.quadratic_objective = True
self._capabilities.quadratic_constraint = True
self._capabilities.integer = True
self._capabilities.sos1 = True
self._capabilities.sos2 = True
def __init__(self, **kwds):
#
# Call base constructor
#
if not 'type' in kwds:
kwds["type"] = "asl"
SystemCallSolver.__init__(self, **kwds)
self._metasolver = True
#
# Setup valid problem formats, and valid results for each problem format.
# Also set the default problem and results formats.
#
self._valid_problem_formats=[ProblemFormat.nl]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.nl] = [ResultsFormat.sol]
self.set_problem_format(ProblemFormat.nl)
#
# Note: Undefined capabilities default to 'None'
#
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = True
self._capabilities.quadratic_objective = True
self._capabilities.quadratic_constraint = True
self._capabilities.sos1 = True
self._capabilities.sos2 = True
class PyomoDataCommands(object):
def __init__(self):
self._info = []
self.options = Options()
def available(self):
return True
def initialize(self, **kwds):
self.filename = kwds.pop('filename')
self.add_options(**kwds)
def add_options(self, **kwds):
self.options.update(kwds)
def open(self):
if self.filename is None: #pragma:nocover
raise IOError("No filename specified")
if not os.path.exists(self.filename): #pragma:nocover
raise IOError("Cannot find file '%s'" % self.filename)
def close(self):
pass
def read(self):
"""
This function does nothing, since executing Pyomo data commands
both reads and processes the data all at once.
"""
pass
def write(self, data): #pragma:nocover
"""
This function does nothing, because we cannot write to a *.dat file.
"""
pass
def process(self, model, data, default):
"""
Read Pyomo data commands and process the data.
"""
_process_include(['include', self.filename], model, data, default,
self.options)
def clear(self):
self._info = []
def results_schema():
if len(sys.argv) > 1:
print(
"results_schema - Print the predefined schema in a SolverResults object"
)
options = Options(schema=True)
r = SolverResults()
repn = r._repn_(options)
r.pprint(sys.stdout, options, repn=repn)
def initialize(**kwds):
obj = Options(**kwds)
#
# Set obj.available
#
try:
opt = SolverFactory(obj.name, solver_io=obj.io)
except:
opt = None
if opt is None or isinstance(opt, UnknownSolver):
obj.available = False
elif not opt.available(exception_flag=False):
obj.available = False
elif hasattr(opt, 'executable') and opt.executable() is None:
obj.available = False
elif not opt.license_is_valid() \
and obj.name not in licensed_solvers_with_demo_mode:
obj.available = False
else:
obj.available = True
#
# Set the limits for the solver's "demo" (unlicensed) mode:
# ( nVars, nCons, nNonZeros )
obj.demo_limits = (None, None, None)
if obj.available:
if obj.name == "baron" and not opt.license_is_valid():
obj.demo_limits = (10, 10, 50)
#
# Check capabilities, even if the solver is not available
#
if not (opt is None or isinstance(opt, UnknownSolver)):
for _c in obj.capabilities:
if not _c in opt._capabilities:
raise ValueError("Solver %s does not support capability %s!" %
(obj.name, _c))
#
# Get version
#
if obj.available:
obj.version = opt.version()
return obj
def test_t1(self):
# Run a simple model
model = ConcreteModel()
model.A = RangeSet(1, 4)
model.x = Var(model.A, bounds=(-1, 1))
def obj_rule(model):
return sum_product(model.x)
model.obj = Objective(rule=obj_rule)
def c_rule(model):
expr = 0
for i in model.A:
expr += i * model.x[i]
return expr == 0
model.c = Constraint(rule=c_rule)
#
data = Options()
data.suffixes = {}
data.solver_options = {}
data.warmstart_filename = None
data.filename = currdir + 't1.lp'
model.write(data['filename'])
INPUT = open(data['filename'], 'r')
data['file'] = INPUT.read()
INPUT.close()
data['opt'] = 'glpk'
data.kwds = {}
#
results = self.worker.process(data)
# Decode, evaluate and unpickle results
if using_pyro4:
# These two conversions are in place to unwrap
# the hacks placed in the pyro_mip_server
# before transmitting the results
# object. These hacks are put in place to
# avoid errors when transmitting the pickled
# form of the results object with the default Pyro4
# serializer (Serpent)
if six.PY3:
results = base64.decodebytes(ast.literal_eval(results))
else:
results = base64.decodestring(results)
results = pickle.loads(results)
#
results.write(filename=currdir + "t1.out", format='json')
self.assertMatchesJsonBaseline(currdir + "t1.out",
currdir + "t1.txt",
tolerance=1e-4)
self.assertEqual(results._smap_id, None)
os.remove(data['filename'])
def setUp(self, testcase, options):
global tmpdir
tmpdir = os.getcwd()
os.chdir(options.currdir)
pyutilib.services.TempfileManager.push()
pyutilib.services.TempfileManager.sequential_files(0)
pyutilib.services.TempfileManager.tempdir = options.currdir
#
if ':' in options.solver:
solver, sub_solver = options.solver.split(':')
if options.solver_options is None:
_options = Options()
else:
_options = options.solver_options
_options.solver = sub_solver
testcase.opt = pyomo.opt.SolverFactory(solver, options=_options)
else:
testcase.opt = pyomo.opt.SolverFactory(
options.solver, options=options.solver_options)
if testcase.opt is None or not testcase.opt.available(False):
testcase.skipTest('Solver %s is not available' % options.solver)
def initialize(**kwds):
obj = Options(**kwds)
#
# Set the limits for the solver's "demo" (unlicensed) mode:
# ( nVars, nCons, nNonZeros )
obj.demo_limits = (None, None, None)
if (obj.name == "baron") and \
(not BARONSHELL.license_is_valid()):
obj.demo_limits = (10, 10, 50)
#
#
# Set obj.available
#
opt = None
try:
opt = SolverFactory(obj.name, solver_io=obj.io)
except:
pass
if opt is None or isinstance(opt, UnknownSolver):
obj.available = False
elif (obj.name == "gurobi") and \
(not GUROBISHELL.license_is_valid()):
obj.available = False
elif (obj.name in {"mosek_direct", "mosek_persistent"}) and \
(not MOSEKDirect.license_is_valid()):
obj.available = False
else:
obj.available = \
(opt.available(exception_flag=False)) and \
((not hasattr(opt,'executable')) or \
(opt.executable() is not None))
#
# Check capabilities, even if the solver is not available
#
if not (opt is None or isinstance(opt, UnknownSolver)):
for _c in obj.capabilities:
if not _c in opt._capabilities:
raise ValueError("Solver %s does not support capability %s!" %
(obj.name, _c))
#
# Get version
#
if obj.available:
obj.version = opt.version()
return obj
def run_convert(options=Options(), parser=None):
from pyomo.scripting.convert import convert, convert_dakota
if options.model.save_format is None and options.model.save_file:
options.model.save_format = options.model.save_file.split('.')[-1]
#
_format = guess_format(options.model.save_format)
if options.model.save_format == 'dakota':
return convert_dakota(options, parser)
elif _format is None:
if options.model.save_format is None:
raise RuntimeError("Unspecified target conversion format!")
else:
raise RuntimeError("Unrecognized target conversion format (%s)!" %
(options.model.save_format, ))
else:
return convert(options, parser, _format)
def __init__(self, **kwds):
#
# Call base constructor
#
kwds['type'] = 'cbc'
super(CBCSHELL, self).__init__(**kwds)
# NOTE: eventually both of the following attributes should be migrated to a common base class.
# is the current solve warm-started? a transient data member to communicate state information
# across the _presolve, _apply_solver, and _postsolve methods.
self._warm_start_solve = False
# related to the above, the temporary name of the SOLN warm-start file (if any).
self._warm_start_file_name = None
#
# Set up valid problem formats and valid results for each problem format
#
self._valid_problem_formats = [ProblemFormat.cpxlp, ProblemFormat.mps]
if (_cbc_compiled_with_asl is not False) and \
(_cbc_old_version is not True):
self._valid_problem_formats.append(ProblemFormat.nl)
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.cpxlp] = [ResultsFormat.soln]
if (_cbc_compiled_with_asl is not False) and \
(_cbc_old_version is not True):
self._valid_result_formats[ProblemFormat.nl] = [ResultsFormat.sol]
self._valid_result_formats[ProblemFormat.mps] = [ResultsFormat.soln]
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = True
# The quadratic capabilities may be true but there is
# some weirdness in the solution file that this
# plugin does not handle correctly (extra variables
# added that are not in the symbol map?)
self._capabilities.quadratic_objective = False
self._capabilities.quadratic_constraint = False
# These flags are updated by the set_problem_format method
# as cbc can handle SOS constraints with the NL file format but
# currently not through the LP file format
self._capabilities.sos1 = False
self._capabilities.sos2 = False
self.set_problem_format(ProblemFormat.cpxlp)
def __init__(self, **kwds):
#
# Call base class constructor
#
kwds['type'] = 'glpk_direct'
OptSolver.__init__(self, **kwds)
# NOTE: eventually both of the following attributes should be migrated
# to a common base class. Is the current solve warm-started? A
# transient data member to communicate state information across the
# _presolve, _apply_solver, and _postsolve methods.
self.warm_start_solve = False
self._timelimit = None
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = True
def __init__(self, **kwds):
#
# Call base constructor
#
kwds["type"] = "pico"
SystemCallSolver.__init__(self, **kwds)
#
# Setup valid problem formats, and valid results for each problem format
#
self._valid_problem_formats = [
ProblemFormat.cpxlp, ProblemFormat.nl, ProblemFormat.mps
]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.cpxlp] = [ResultsFormat.soln]
self._valid_result_formats[ProblemFormat.nl] = [ResultsFormat.sol]
self._valid_result_formats[ProblemFormat.mps] = [ResultsFormat.soln]
self.set_problem_format(ProblemFormat.cpxlp)
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = True
def __init__(self, **kwds):
#
# Call base constructor
#
kwds["type"] = "ipopt"
super(IPOPT, self).__init__(**kwds)
#
# Setup valid problem formats, and valid results for each problem format
# Also set the default problem and results formats.
#
self._valid_problem_formats = [ProblemFormat.nl]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.nl] = [ResultsFormat.sol]
self.set_problem_format(ProblemFormat.nl)
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = False
self._capabilities.quadratic_objective = True
self._capabilities.quadratic_constraint = True
self._capabilities.sos1 = False
self._capabilities.sos2 = False
def configure_loggers(options=None, shutdown=False):
if shutdown:
options = Options()
options.runtime = Options()
options.runtime.logging = 'quiet'
if configure_loggers.fileLogger is not None:
logging.getLogger('pyomo').handlers = []
logging.getLogger('pyutilib').handlers = []
configure_loggers.fileLogger.close()
configure_loggers.fileLogger = None
# TBD: This seems dangerous in Windows, as the process will
# have multiple open file handles pointint to the same file.
reset_redirect()
#
# Configure the logger
#
if options.runtime is None:
options.runtime = Options()
if options.runtime.logging == 'quiet':
logging.getLogger('pyomo').setLevel(logging.ERROR)
elif options.runtime.logging == 'warning':
logging.getLogger('pyomo').setLevel(logging.WARNING)
elif options.runtime.logging == 'info':
logging.getLogger('pyomo').setLevel(logging.INFO)
logging.getLogger('pyutilib').setLevel(logging.INFO)
elif options.runtime.logging == 'verbose':
logging.getLogger('pyomo').setLevel(logging.DEBUG)
logging.getLogger('pyutilib').setLevel(logging.DEBUG)
elif options.runtime.logging == 'debug':
logging.getLogger('pyomo').setLevel(logging.DEBUG)
logging.getLogger('pyutilib').setLevel(logging.DEBUG)
if options.runtime.logfile:
configure_loggers.fileLogger \
= logging.FileHandler(options.runtime.logfile, 'w')
logging.getLogger('pyomo').handlers = []
logging.getLogger('pyutilib').handlers = []
logging.getLogger('pyomo').addHandler(configure_loggers.fileLogger)
logging.getLogger('pyutilib').addHandler(configure_loggers.fileLogger)
# TBD: This seems dangerous in Windows, as the process will
# have multiple open file handles pointint to the same file.
setup_redirect(options.runtime.logfile)
def run_test_scenarios(options):
logging.disable(logging.WARNING)
solvers = set(options.solver)
stat = {}
for key, test_case in test_scenarios():
model, solver, io = key
if len(solvers) > 0 and not solver in solvers:
continue
if test_case.status == 'skip':
continue
# Create the model test class
model_class = test_case.model()
# Create the model instance
model_class.generate_model()
model_class.warmstart_model()
# Solve
symbolic_labels = False
load_solutions = False
opt, results = model_class.solve(solver, io,
test_case.testcase.io_options, {},
symbolic_labels, load_solutions)
termination_condition = results['Solver'][0]['termination condition']
# Validate solution status
try:
model_class.post_solve_test_validation(None, results)
except:
if test_case.status == 'expected failure':
stat[key] = (True, "Expected failure")
else:
stat[key] = (False, "Unexpected termination condition: %s" %
str(termination_condition))
continue
if termination_condition == TerminationCondition.unbounded or \
termination_condition == TerminationCondition.infeasible:
# Unbounded or Infeasible
stat[key] = (True, "")
else:
# Validate the solution returned by the solver
if isinstance(model_class.model, IBlock):
model_class.model.load_solution(results.solution)
else:
model_class.model.solutions.load_from(
results,
default_variable_value=opt.default_variable_value())
rc = model_class.validate_current_solution(
suffixes=model_class.test_suffixes)
if test_case.status == 'expected failure':
if rc[0] is True:
stat[key] = (False, "Unexpected success")
else:
stat[key] = (True, "Expected failure")
else:
if rc[0] is True:
stat[key] = (True, "")
else:
stat[key] = (False, "Unexpected failure")
if options.verbose:
print("---------------")
print(" Test Failures")
print("---------------")
nfail = 0
#
# Summarize the runtime statistics, by solver
#
summary = {}
total = Options(NumEPass=0, NumEFail=0, NumUPass=0, NumUFail=0)
for key in stat:
model, solver, io = key
if not solver in summary:
summary[solver] = Options(NumEPass=0,
NumEFail=0,
NumUPass=0,
NumUFail=0)
_pass, _str = stat[key]
if _pass:
if _str == "Expected failure":
summary[solver].NumEFail += 1
else:
summary[solver].NumEPass += 1
else:
nfail += 1
if _str == "Unexpected failure":
summary[solver].NumUFail += 1
if options.verbose:
print("- Unexpected Test Failure: " +
", ".join((model, solver, io)))
else:
summary[solver].NumUPass += 1
if options.verbose:
print("- Unexpected Test Success: " +
", ".join((model, solver, io)))
if options.verbose:
if nfail == 0:
print("- NONE")
print("")
stream = sys.stdout
maxSolverNameLen = max([max(len(name) for name in summary), len("Solver")])
fmtStr = "{{0:<{0}}}| {{1:>8}} | {{2:>8}} | {{3:>10}} | {{4:>10}} | {{5:>13}}\n".format(
maxSolverNameLen + 2)
#
stream.write("\n")
stream.write("Solver Test Summary\n")
stream.write("=" * (maxSolverNameLen + 66) + "\n")
stream.write(
fmtStr.format("Solver", "# Pass", "# Fail", "# OK Fail", "# Bad Pass",
"% OK"))
stream.write("=" * (maxSolverNameLen + 66) + "\n")
#
for _solver in sorted(summary):
ans = summary[_solver]
total.NumEPass += ans.NumEPass
total.NumEFail += ans.NumEFail
total.NumUPass += ans.NumUPass
total.NumUFail += ans.NumUFail
stream.write(
fmtStr.format(
_solver, str(ans.NumEPass), str(ans.NumUFail),
str(ans.NumEFail), str(ans.NumUPass),
str(
int(100.0 * (ans.NumEPass + ans.NumEFail) /
(ans.NumEPass + ans.NumEFail + ans.NumUFail +
ans.NumUPass)))))
#
stream.write("=" * (maxSolverNameLen + 66) + "\n")
stream.write(
fmtStr.format(
"TOTALS", str(total.NumEPass), str(total.NumUFail),
str(total.NumEFail), str(total.NumUPass),
str(
int(100.0 * (total.NumEPass + total.NumEFail) /
(total.NumEPass + total.NumEFail + total.NumUFail +
total.NumUPass)))))
stream.write("=" * (maxSolverNameLen + 66) + "\n")
logging.disable(logging.NOTSET)
def __init__(self, **kwds):
OptSolver.__init__(self, **kwds)
self._pyomo_model = None
"""The pyomo model being solved."""
self._solver_model = None
"""The python instance of the solver model (e.g., the gurobipy Model instance)."""
self._symbol_map = SymbolMap()
"""A symbol map used to map between pyomo components and their names used with the solver."""
self._labeler = None
"""The labeler for creating names for the solver model components."""
self._pyomo_var_to_solver_var_map = ComponentMap()
self._solver_var_to_pyomo_var_map = dict()
"""A dictionary mapping pyomo Var's to the solver variables."""
self._pyomo_con_to_solver_con_map = dict()
self._solver_con_to_pyomo_con_map = dict()
"""A dictionary mapping pyomo constraints to solver constraints."""
self._vars_referenced_by_con = ComponentMap()
"""A dictionary mapping constraints to a ComponentSet containt the pyomo variables referenced by that
constraint. This is primarily needed for the persistent solvers. When a constraint is deleted, we need
to decrement the number of times those variables are referenced (see self._referenced_variables)."""
self._vars_referenced_by_obj = ComponentSet()
"""A set containing the pyomo variables referenced by that the objective.
This is primarily needed for the persistent solvers. When a the objective is deleted, we need
to decrement the number of times those variables are referenced (see self._referenced_variables)."""
self._objective = None
"""The pyomo Objective object currently being used with the solver."""
self.results = None
"""A results object return from the solve method."""
self._skip_trivial_constraints = False
"""A bool. If True, then any constraints with a constant body will not be added to the solver model.
Be careful with this. If a trivial constraint is skipped then that constraint cannot be removed from
a persistent solver (an error will be raised if a user tries to remove a non-existent constraint)."""
self._output_fixed_variable_bounds = False
"""A bool. If False then an error will be raised if a fixed variable is used in one of the solver constraints.
This is useful for catching bugs. Ordinarily a fixed variable should appear as a constant value in the
solver constraints. If True, then the error will not be raised."""
self._python_api_exists = False
"""A bool indicating whether or not the python api is available for the specified solver."""
self._version = None
"""The version of the solver."""
self._version_major = None
"""The major version of the solver. For example, if using Gurobi 7.0.2, then _version_major is 7."""
self._symbolic_solver_labels = False
"""A bool. If true then the solver components will be given names corresponding to the pyomo component names."""
self._capabilites = Options()
self._referenced_variables = ComponentMap()
"""dict: {var: count} where count is the number of constraints/objective referencing the var"""
self._keepfiles = False
"""A bool. If True, then the solver log will be saved."""
self._save_results = True
"""A bool. This is used for backwards compatability. If True, the solution will be loaded into the Solution
def _process_load(cmd, _model, _data, _default, options=None):
#print("LOAD %s" % cmd)
from pyomo.core import Set
_cmd_len = len(cmd)
_options = {}
_options['filename'] = cmd[1]
i = 2
while cmd[i] != ':':
_options[cmd[i]] = cmd[i + 2]
i += 3
i += 1
_Index = (None, [])
if type(cmd[i]) is tuple:
_Index = (None, cmd[i])
i += 1
elif i + 1 < _cmd_len and cmd[i + 1] == '=':
_Index = (cmd[i], cmd[i + 2])
i += 3
_smap = OrderedDict()
while i < _cmd_len:
if i + 2 < _cmd_len and cmd[i + 1] == '=':
_smap[cmd[i + 2]] = cmd[i]
i += 3
else:
_smap[cmd[i]] = cmd[i]
i += 1
if len(cmd) < 2:
raise IOError("The 'load' command must specify a filename")
options = Options(**_options)
for key in options:
if not key in [
'range', 'filename', 'format', 'using', 'driver', 'query',
'table', 'user', 'password', 'database'
]:
raise ValueError("Unknown load option '%s'" % key)
global Filename
Filename = options.filename
global Lineno
Lineno = 0
#
# TODO: process mapping info
#
if options.using is None:
tmp = options.filename.split(".")[-1]
data = DataManagerFactory(tmp)
if (data is None) or \
isinstance(data, UnknownDataManager):
raise ApplicationError("Data manager '%s' is not available." % tmp)
else:
try:
data = DataManagerFactory(options.using)
except:
data = None
if (data is None) or \
isinstance(data, UnknownDataManager):
raise ApplicationError("Data manager '%s' is not available." %
options.using)
set_name = None
#
# Create symbol map
#
symb_map = _smap
if len(symb_map) == 0:
raise IOError(
"Must specify at least one set or parameter name that will be loaded"
)
#
# Process index data
#
_index = None
index_name = _Index[0]
_select = None
#
# Set the 'set name' based on the format
#
_set = None
if options.format == 'set' or options.format == 'set_array':
if len(_smap) != 1:
raise IOError(
"A single set name must be specified when using format '%s'" %
options.format)
set_name = list(_smap.keys())[0]
_set = set_name
#
# Set the 'param name' based on the format
#
_param = None
if options.format == 'transposed_array' or options.format == 'array' or options.format == 'param':
if len(_smap) != 1:
raise IOError(
"A single parameter name must be specified when using format '%s'"
% options.format)
if options.format in ('transposed_array', 'array', 'param', None):
if _Index[0] is None:
_index = None
else:
_index = _Index[0]
_param = []
_select = list(_Index[1])
for key in _smap:
_param.append(_smap[key])
_select.append(key)
if options.format in ('transposed_array', 'array'):
_select = None
#print "YYY", _param, options
if not _param is None and len(
_param) == 1 and not _model is None and isinstance(
getattr(_model, _param[0]), Set):
_select = None
_set = _param[0]
_param = None
_index = None
#print "SELECT", _param, _select
#
data.initialize(model=options.model,
filename=options.filename,
index=_index,
index_name=index_name,
param_name=symb_map,
set=_set,
param=_param,
format=options.format,
range=options.range,
query=options.query,
using=options.using,
table=options.table,
select=_select,
user=options.user,
password=options.password,
database=options.database)
#
data.open()
try:
data.read()
except Exception:
data.close()
raise
data.close()
data.process(_model, _data, _default)
def _process_table(cmd, _model, _data, _default, options=None):
#print("TABLE %s" % cmd)
#
_options = {}
_set = OrderedDict()
_param = OrderedDict()
_labels = []
_cmd = cmd[1]
_cmd_len = len(_cmd)
name = None
i = 0
while i < _cmd_len:
try:
#print("CMD i=%s cmd=%s" % (i, _cmd[i:]))
#
# This should not be error prone, so we treat errors
# with a general exception
#
#
# Processing labels
#
if _cmd[i] == ':':
i += 1
while i < _cmd_len:
_labels.append(_cmd[i])
i += 1
continue
#
# Processing options
#
name = _cmd[i]
if i + 1 == _cmd_len:
_param[name] = []
_labels = ['Z']
i += 1
continue
if _cmd[i + 1] == '=':
if type(_cmd[i + 2]) is list:
_set[name] = _cmd[i + 2]
else:
_options[name] = _cmd[i + 2]
i += 3
continue
# This should be a parameter declaration
if not type(_cmd[i + 1]) is tuple:
raise IOError
if i + 2 < _cmd_len and _cmd[i + 2] == '=':
_param[name] = (_cmd[i + 1], _cmd[i + 3][0])
i += 4
else:
_param[name] = _cmd[i + 1]
i += 2
except:
raise IOError("Error parsing table options: %s" % name)
#print("_options %s" % _options)
#print("_set %s" % _set)
#print("_param %s" % _param)
#print("_labels %s" % _labels)
#
options = Options(**_options)
for key in options:
if not key in ['columns']:
raise ValueError("Unknown table option '%s'" % key)
#
ncolumns = options.columns
if ncolumns is None:
ncolumns = len(_labels)
if ncolumns == 0:
if not (len(_set) == 1 and len(_set[_set.keys()[0]]) == 0):
raise IOError(
"Must specify either the 'columns' option or column headers"
)
else:
ncolumns = 1
else:
ncolumns = int(ncolumns)
#
data = cmd[2]
Ldata = len(cmd[2])
#
cmap = {}
if len(_labels) == 0:
for i in range(ncolumns):
cmap[i + 1] = i
for label in _param:
ndx = cmap[_param[label][1]]
if ndx < 0 or ndx >= ncolumns:
raise IOError("Bad column value %s for data %s" %
(str(ndx), label))
cmap[label] = ndx
_param[label] = _param[label][0]
else:
i = 0
for label in _labels:
cmap[label] = i
i += 1
#print("CMAP %s" % cmap)
#
#print("_param %s" % _param)
#print("_set %s" % _set)
for sname in _set:
# Creating set sname
cols = _set[sname]
tmp = []
for col in cols:
if not col in cmap:
raise IOError(
"Unexpected table column '%s' for index set '%s'" %
(col, sname))
tmp.append(cmap[col])
if not sname in cmap:
cmap[sname] = tmp
cols = list(flatten_tuple(tmp))
#
_cmd = ['set', sname, ':=']
i = 0
while i < Ldata:
row = []
#print("COLS %s NCOLS %d" % (cols, ncolumns))
for col in cols:
#print("Y %s %s" % (i, col))
row.append(data[i + col])
if len(row) > 1:
_cmd.append(tuple(row))
else:
_cmd.append(row[0])
i += ncolumns
#print("_data %s" % _data)
_process_set(_cmd, _model, _data)
#
#print("CMAP %s" % cmap)
_i = 0
if ncolumns == 0:
raise IOError
for vname in _param:
_i += 1
# create value vname
cols = _param[vname]
tmp = []
for col in cols:
#print("COL %s" % col)
if not col in cmap:
raise IOError(
"Unexpected table column '%s' for table value '%s'" %
(col, vname))
tmp.append(cmap[col])
#print("X %s %s" % (len(cols), tmp))
cols = list(flatten_tuple(tmp))
#print("X %s" % len(cols))
#print("VNAME %s %s" % (vname, cmap[vname]))
if vname in cmap:
cols.append(cmap[vname])
else:
cols.append(ncolumns - 1 - (len(_param) - _i))
#print("X %s" % len(cols))
#
_cmd = ['param', vname, ':=']
i = 0
while i < Ldata:
#print("HERE %s %s %s" % (i, cols, ncolumns))
for col in cols:
_cmd.append(data[i + col])
i += ncolumns
#print("HERE %s" % _cmd)
#print("_data %s" % _data)
_process_param(_cmd, _model, _data, None, ncolumns=len(cols))
import sys
import pyomo.environ
from pyomo.opt import SolverFactory
from pyomo.common.collections import Options
from indexnonlin import model
model.pprint()
model.skip_canonical_repn = True # for nonlinear models
instance=model.create()
SolverName = "asl"
so = Options()
so.solver = "ipopt"
opt=SolverFactory(SolverName, options=so)
if opt is None:
print("Could not construct solver %s:%s" % (SolverName,so.solver))
sys.exit(1)
results=opt.solve(instance)
results.write()
instance.load(results) # put results in model
# because we know there is a variable named x
x_var = getattr(instance, "x")
# because we know there is an index named xAxis
x_val = x_var["xAxis"]()
def convert_dakota(options=Options(), parser=None):
#
# Import plugins
#
import pyomo.environ
model_file = os.path.basename(options.model.save_file)
model_file_no_ext = os.path.splitext(model_file)[0]
#
# Set options for writing the .nl and related files
#
# By default replace .py with .nl
if options.model.save_file is None:
options.model.save_file = model_file_no_ext + '.nl'
options.model.save_format = ProblemFormat.nl
# Dakota requires .row/.col files
options.model.symbolic_solver_labels = True
#
# Call the core converter
#
model_data = convert(options, parser)
#
# Generate Dakota input file fragments for the Vars, Objectives, Constraints
#
# TODO: the converted model doesn't expose the right symbol_map
# for only the vars active in the .nl
model = model_data.instance
# Easy way
#print "VARIABLE:"
#lines = open(options.save_model.replace('.nl','.col'),'r').readlines()
#for varName in lines:
# varName = varName.strip()
# var = model_data.symbol_map.getObject(varName)
# print "'%s': %s" % (varName, var)
# #print var.pprint()
# Hard way
variables = 0
var_descriptors = []
var_lb = []
var_ub = []
var_initial = []
tmpDict = model_data.symbol_map.getByObjectDictionary()
for var in model.component_data_objects(Var, active=True):
if id(var) in tmpDict:
variables += 1
var_descriptors.append(var.name)
# apply user bound, domain bound, or infinite
_lb, _ub = var.bounds
if _lb is not None:
var_lb.append(str(_lb))
else:
var_lb.append("-inf")
if _ub is not None:
var_ub.append(str(_ub))
else:
var_ub.append("inf")
try:
val = value(var)
except:
val = None
var_initial.append(str(val))
objectives = 0
obj_descriptors = []
for obj in model.component_data_objects(Objective, active=True):
objectives += 1
obj_descriptors.append(obj.name)
constraints = 0
cons_descriptors = []
cons_lb = []
cons_ub = []
for con in model.component_data_objects(Constraint, active=True):
constraints += 1
cons_descriptors.append(con.name)
if con.lower is not None:
cons_lb.append(str(con.lower))
else:
cons_lb.append("-inf")
if con.upper is not None:
cons_ub.append(str(con.upper))
else:
cons_ub.append("inf")
# Write the Dakota input file fragments
dakfrag = open(model_file_no_ext + ".dak", 'w')
dakfrag.write("#--- Dakota variables block ---#\n")
dakfrag.write("variables\n")
dakfrag.write(" continuous_design " + str(variables) + '\n')
dakfrag.write(" descriptors\n")
for vd in var_descriptors:
dakfrag.write(" '%s'\n" % vd)
dakfrag.write(" lower_bounds " + " ".join(var_lb) + '\n')
dakfrag.write(" upper_bounds " + " ".join(var_ub) + '\n')
dakfrag.write(" initial_point " + " ".join(var_initial) + '\n')
dakfrag.write("#--- Dakota interface block ---#\n")
dakfrag.write("interface\n")
dakfrag.write(" algebraic_mappings = '" + options.model.save_file + "'\n")
dakfrag.write("#--- Dakota responses block ---#\n")
dakfrag.write("responses\n")
dakfrag.write(" objective_functions " + str(objectives) + '\n')
if (constraints > 0):
dakfrag.write(" nonlinear_inequality_constraints " +
str(constraints) + '\n')
dakfrag.write(" lower_bounds " + " ".join(cons_lb) + '\n')
dakfrag.write(" upper_bounds " + " ".join(cons_ub) + '\n')
dakfrag.write(" descriptors\n")
for od in obj_descriptors:
dakfrag.write(" '%s'\n" % od)
if (constraints > 0):
for cd in cons_descriptors:
dakfrag.write(" '%s'\n" % cd)
# TODO: detect whether gradient information available in model
dakfrag.write(" analytic_gradients\n")
dakfrag.write(" no_hessians\n")
dakfrag.close()
sys.stdout.write("Dakota input fragment written to file '%s'\n" %
(model_file_no_ext + ".dak", ))
return model_data
case = MissingSuffixFailures[solver, io, _model.description]
if _solver_case.version is not None and\
case[0](_solver_case.version):
if type(case[1]) is dict:
exclude_suffixes.update(case[1])
else:
for x in case[1]:
exclude_suffixes[x] = (True, {})
msg = case[2]
# Return scenario dimensions and scenario information
yield (model, solver,
io), Options(status=status,
msg=msg,
model=_model,
solver=None,
testcase=_solver_case,
demo_limits=_solver_case.demo_limits,
exclude_suffixes=exclude_suffixes)
@unittest.nottest
def run_test_scenarios(options):
logging.disable(logging.WARNING)
solvers = set(options.solver)
stat = {}
for key, test_case in test_scenarios():
model, solver, io = key
if len(solvers) > 0 and not solver in solvers:
