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 _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 __init__(self, **kwargs):
""" Constructor """
executable = kwargs.pop('executable', None)
validate = kwargs.pop('validate', True)
OptSolver.__init__(self, **kwargs)
self._keepfiles = False
self._results_file = None
self._timer = ''
self._user_executable = None
# broadly useful for reporting, and in cases where
# a solver plugin may not report execution time.
self._last_solve_time = None
self._define_signal_handlers = None
if executable is not None:
self.set_executable(name=executable, validate=validate)
def available(self, exception_flag=False):
""" True if the solver is available """
if self._assert_available:
return True
if not OptSolver.available(self,exception_flag):
return False
try:
ans = self.executable()
except NotImplementedError:
ans = None
if ans is None:
if exception_flag:
msg = "No executable found for solver '%s'"
raise ApplicationError(msg % self.name)
return False
return True
def available(self, exception_flag=False):
""" True if the solver is available """
if self._assert_available:
return True
if not OptSolver.available(self, exception_flag):
return False
try:
# HACK: Suppress logged warnings about the executable not
# being found
cm = nullcontext() if exception_flag else LoggingIntercept()
with cm:
ans = self.executable()
except NotImplementedError:
ans = None
if ans is None:
if exception_flag:
msg = "No executable found for solver '%s'"
raise ApplicationError(msg % self.name)
return False
return True
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()
"""A dictionary mapping pyomo Var's to the solver variables."""
self._pyomo_con_to_solver_con_map = ComponentMap()
"""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 _postsolve(self):
return OptSolver._postsolve(self)
def _queue_object_solves(self,
object_type,
objects,
ephemeral_solver_options,
disable_warmstart):
if self.get_option("verbose"):
print("Queuing %s solves" % (object_type[:-1]))
assert object_type in ('bundles', 'scenarios')
solver_dict = None
instance_dict = None
modify_kwds_func = None
if object_type == 'bundles':
if objects is None:
objects = self.manager.scenario_tree._scenario_bundle_map
solver_dict = self._bundle_solvers
instance_dict = self.manager._bundle_binding_instance_map
for bundle_name in objects:
for scenario_name in self.manager.scenario_tree.\
get_bundle(bundle_name).\
scenario_names:
self.manager.scenario_tree.get_scenario(scenario_name).\
_instance_objective.deactivate()
if self.preprocessor is not None:
self.preprocessor.preprocess_bundles(bundles=objects)
modify_kwds_func = self.preprocessor.modify_bundle_solver_keywords
else:
if objects is None:
objects = self.manager.scenario_tree._scenario_map
solver_dict = self._scenario_solvers
instance_dict = self.manager._instances
if self.manager.scenario_tree.contains_bundles():
for scenario_name in objects:
self.manager.scenario_tree.get_scenario(scenario_name).\
_instance_objective.activate()
if self.preprocessor is not None:
self.preprocessor.preprocess_scenarios(scenarios=objects)
modify_kwds_func = self.preprocessor.modify_scenario_solver_keywords
assert solver_dict is not None
assert instance_dict is not None
# setup common solve keywords
common_kwds = {}
common_kwds['tee'] = self.get_option("output_solver_log")
common_kwds['keepfiles'] = self.get_option("keep_solver_files")
common_kwds['symbolic_solver_labels'] = \
self.get_option("symbolic_solver_labels")
# we always manually load solutions, so we can
# control error reporting and such
common_kwds['load_solutions'] = False
# Load solver options
solver_options = {}
if type(self.get_option("solver_options")) is tuple:
solver_options.update(
OptSolver._options_string_to_dict(
"".join(self.get_option("solver_options"))))
else:
solver_options.update(self.get_option("solver_options"))
common_kwds['options'] = solver_options
#
# override "persistent" values that are included from this
# classes registered options
#
if ephemeral_solver_options is not None:
common_kwds['options'].update(ephemeral_solver_options)
# maps action handles to subproblem names
action_handle_data = {}
for object_name in objects:
if modify_kwds_func is not None:
# be sure to modify a copy of the kwds
solve_kwds = modify_kwds_func(object_name, dict(common_kwds))
else:
solve_kwds = common_kwds
opt = solver_dict[object_name]
instance = instance_dict[object_name]
if (not self.get_option("disable_warmstart")) and \
(not disable_warmstart) and \
opt.warm_start_capable():
new_action_handle = \
self._solver_manager.queue(instance,
opt=opt,
warmstart=True,
**solve_kwds)
else:
new_action_handle = \
self._solver_manager.queue(instance,
opt=opt,
**solve_kwds)
action_handle_data[new_action_handle] = object_name
return self.manager.AsyncResult(
self._solver_manager,
action_handle_data=action_handle_data)
def _queue_object_solves(self,
object_type,
objects,
ephemeral_solver_options,
disable_warmstart):
if self.get_option("verbose"):
print("Queuing %s solves" % (object_type[:-1]))
assert object_type in ('bundles', 'scenarios')
solver_dict = None
instance_dict = None
modify_kwds_func = None
if object_type == 'bundles':
if objects is None:
objects = self.manager.scenario_tree._scenario_bundle_map
solver_dict = self._bundle_solvers
instance_dict = self.manager._bundle_binding_instance_map
for bundle_name in objects:
for scenario_name in self.manager.scenario_tree.\
get_bundle(bundle_name).\
scenario_names:
self.manager.scenario_tree.get_scenario(scenario_name).\
_instance_objective.deactivate()
if self.preprocessor is not None:
self.preprocessor.preprocess_bundles(bundles=objects)
modify_kwds_func = self.preprocessor.modify_bundle_solver_keywords
else:
if objects is None:
objects = self.manager.scenario_tree._scenario_map
solver_dict = self._scenario_solvers
instance_dict = self.manager._instances
if self.manager.scenario_tree.contains_bundles():
for scenario_name in objects:
self.manager.scenario_tree.get_scenario(scenario_name).\
_instance_objective.activate()
if self.preprocessor is not None:
self.preprocessor.preprocess_scenarios(scenarios=objects)
modify_kwds_func = self.preprocessor.modify_scenario_solver_keywords
assert solver_dict is not None
assert instance_dict is not None
# setup common solve keywords
common_kwds = {}
common_kwds['tee'] = self.get_option("output_solver_log")
common_kwds['keepfiles'] = self.get_option("keep_solver_files")
common_kwds['symbolic_solver_labels'] = \
self.get_option("symbolic_solver_labels")
# we always manually load solutions, so we can
# control error reporting and such
common_kwds['load_solutions'] = False
# Load solver options
solver_options = {}
if type(self.get_option("solver_options")) is tuple:
solver_options.update(
OptSolver._options_string_to_dict(
"".join(self.get_option("solver_options"))))
else:
solver_options.update(self.get_option("solver_options"))
common_kwds['options'] = solver_options
#
# override "persistent" values that are included from this
# classes registered options
#
if ephemeral_solver_options is not None:
common_kwds['options'].update(ephemeral_solver_options)
# maps action handles to subproblem names
action_handle_data = {}
for object_name in objects:
if modify_kwds_func is not None:
# be sure to modify a copy of the kwds
solve_kwds = modify_kwds_func(object_name, dict(common_kwds))
else:
solve_kwds = common_kwds
opt = solver_dict[object_name]
instance = instance_dict[object_name]
if (not self.get_option("disable_warmstart")) and \
(not disable_warmstart) and \
opt.warm_start_capable():
new_action_handle = \
self._solver_manager.queue(instance,
opt=opt,
warmstart=True,
**solve_kwds)
else:
new_action_handle = \
self._solver_manager.queue(instance,
opt=opt,
**solve_kwds)
action_handle_data[new_action_handle] = object_name
return self.manager.AsyncResult(
self._solver_manager,
action_handle_data=action_handle_data)
