def solve(self, *args, **kwds):
"""
Solve a model via the GAMS Python API.
Keyword Arguments
-----------------
tee=False: bool
Output GAMS log to stdout.
logfile=None: str
Filename to output GAMS log to a file.
load_solutions=True: bool
Load solution into model. If False, the results
object will contain the solution data.
keepfiles=False: bool
Keep temporary files. Equivalent of DebugLevel.KeepFiles.
Summary of temp files can be found in _gams_py_gjo0.pf
tmpdir=None: str
Specify directory path for storing temporary files.
A directory will be created if one of this name doesn't exist.
By default uses the system default temporary path.
report_timing=False: bool
Print timing reports for presolve, solver, postsolve, etc.
io_options: dict
Options that get passed to the writer.
See writer in pyomo.repn.plugins.gams_writer for details.
Updated with any other keywords passed to solve method.
"""
# Make sure available() doesn't crash
self.available()
from gams import GamsWorkspace, DebugLevel
from gams.workspace import GamsExceptionExecution
if len(args) != 1:
raise ValueError('Exactly one model must be passed '
'to solve method of GAMSSolver.')
model = args[0]
# self.options are default for each run, overwritten by kwds
options = dict()
options.update(self.options)
options.update(kwds)
load_solutions = options.pop("load_solutions", True)
tee = options.pop("tee", False)
logfile = options.pop("logfile", None)
keepfiles = options.pop("keepfiles", False)
tmpdir = options.pop("tmpdir", None)
report_timing = options.pop("report_timing", False)
io_options = options.pop("io_options", {})
# Pass remaining keywords to writer, which will handle
# any unrecognized arguments
io_options.update(options)
initial_time = time.time()
####################################################################
# Presolve
####################################################################
# Create StringIO stream to pass to gams_writer, on which the
# model file will be written. The writer also passes this StringIO
# back, but output_file is defined in advance for clarity.
output_file = StringIO()
if isinstance(model, IBlock):
# Kernel blocks have slightly different write method
smap_id = model.write(filename=output_file,
format=ProblemFormat.gams,
_called_by_solver=True,
**io_options)
symbolMap = getattr(model, "._symbol_maps")[smap_id]
else:
(_, smap_id) = model.write(filename=output_file,
format=ProblemFormat.gams,
io_options=io_options)
symbolMap = model.solutions.symbol_map[smap_id]
presolve_completion_time = time.time()
if report_timing:
print(" %6.2f seconds required for presolve" %
(presolve_completion_time - initial_time))
####################################################################
# Apply solver
####################################################################
# IMPORTANT - only delete the whole tmpdir if the solver was the one
# that made the directory. Otherwise, just delete the files the solver
# made, if not keepfiles. That way the user can select a directory
# they already have, like the current directory, without having to
# worry about the rest of the contents of that directory being deleted.
newdir = True
if tmpdir is not None and os.path.exists(tmpdir):
newdir = False
ws = GamsWorkspace(
debug=DebugLevel.KeepFiles if keepfiles else DebugLevel.Off,
working_directory=tmpdir)
t1 = ws.add_job_from_string(output_file.getvalue())
try:
with OutputStream(tee=tee, logfile=logfile) as output_stream:
t1.run(output=output_stream)
except GamsExceptionExecution as e:
try:
if e.rc == 3:
# Execution Error
check_expr_evaluation(model, symbolMap, 'direct')
finally:
# Always name working directory or delete files,
# regardless of any errors.
if keepfiles:
print("\nGAMS WORKING DIRECTORY: %s\n" %
ws.working_directory)
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
t1 = rec = rec_lo = rec_hi = None
file_removal_gams_direct(tmpdir, newdir)
raise
except:
# Catch other errors and remove files first
if keepfiles:
print("\nGAMS WORKING DIRECTORY: %s\n" % ws.working_directory)
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
t1 = rec = rec_lo = rec_hi = None
file_removal_gams_direct(tmpdir, newdir)
raise
solve_completion_time = time.time()
if report_timing:
print(" %6.2f seconds required for solver" %
(solve_completion_time - presolve_completion_time))
####################################################################
# Postsolve
####################################################################
# import suffixes must be on the top-level model
if isinstance(model, IBlock):
model_suffixes = list(comp.storage_key for comp \
in pyomo.core.kernel.suffix.\
import_suffix_generator(model,
active=True,
descend_into=False))
else:
model_suffixes = list(name for (name,comp) \
in pyomo.core.base.suffix.\
active_import_suffix_generator(model))
extract_dual = ('dual' in model_suffixes)
extract_rc = ('rc' in model_suffixes)
results = SolverResults()
results.problem.name = t1.name
results.problem.lower_bound = t1.out_db["OBJEST"].find_record().value
results.problem.upper_bound = t1.out_db["OBJEST"].find_record().value
results.problem.number_of_variables = \
t1.out_db["NUMVAR"].find_record().value
results.problem.number_of_constraints = \
t1.out_db["NUMEQU"].find_record().value
results.problem.number_of_nonzeros = \
t1.out_db["NUMNZ"].find_record().value
results.problem.number_of_binary_variables = None
# Includes binary vars:
results.problem.number_of_integer_variables = \
t1.out_db["NUMDVAR"].find_record().value
results.problem.number_of_continuous_variables = \
t1.out_db["NUMVAR"].find_record().value \
- t1.out_db["NUMDVAR"].find_record().value
results.problem.number_of_objectives = 1 # required by GAMS writer
obj = list(model.component_data_objects(Objective, active=True))
assert len(obj) == 1, 'Only one objective is allowed.'
obj = obj[0]
objctvval = t1.out_db["OBJVAL"].find_record().value
if obj.is_minimizing():
results.problem.sense = ProblemSense.minimize
results.problem.upper_bound = objctvval
else:
results.problem.sense = ProblemSense.maximize
results.problem.lower_bound = objctvval
results.solver.name = "GAMS " + str(self.version())
# Init termination condition to None to give preference to this first
# block of code, only set certain TC's below if it's still None
results.solver.termination_condition = None
results.solver.message = None
solvestat = t1.out_db["SOLVESTAT"].find_record().value
if solvestat == 1:
results.solver.status = SolverStatus.ok
elif solvestat == 2:
results.solver.status = SolverStatus.ok
results.solver.termination_condition = TerminationCondition.maxIterations
elif solvestat == 3:
results.solver.status = SolverStatus.ok
results.solver.termination_condition = TerminationCondition.maxTimeLimit
elif solvestat == 5:
results.solver.status = SolverStatus.ok
results.solver.termination_condition = TerminationCondition.maxEvaluations
elif solvestat == 7:
results.solver.status = SolverStatus.aborted
results.solver.termination_condition = TerminationCondition.licensingProblems
elif solvestat == 8:
results.solver.status = SolverStatus.aborted
results.solver.termination_condition = TerminationCondition.userInterrupt
elif solvestat == 10:
results.solver.status = SolverStatus.error
results.solver.termination_condition = TerminationCondition.solverFailure
elif solvestat == 11:
results.solver.status = SolverStatus.error
results.solver.termination_condition = TerminationCondition.internalSolverError
elif solvestat == 4:
results.solver.status = SolverStatus.warning
results.solver.message = "Solver quit with a problem (see LST file)"
elif solvestat in (9, 12, 13):
results.solver.status = SolverStatus.error
elif solvestat == 6:
results.solver.status = SolverStatus.unknown
results.solver.return_code = 0
# Not sure if this value is actually user time
# "the elapsed time it took to execute a solve statement in total"
results.solver.user_time = t1.out_db["ETSOLVE"].find_record().value
results.solver.system_time = None
results.solver.wallclock_time = None
results.solver.termination_message = None
soln = Solution()
modelstat = t1.out_db["MODELSTAT"].find_record().value
if modelstat == 1:
results.solver.termination_condition = TerminationCondition.optimal
soln.status = SolutionStatus.optimal
elif modelstat == 2:
results.solver.termination_condition = TerminationCondition.locallyOptimal
soln.status = SolutionStatus.locallyOptimal
elif modelstat in [3, 18]:
results.solver.termination_condition = TerminationCondition.unbounded
soln.status = SolutionStatus.unbounded
elif modelstat in [4, 5, 6, 10, 19]:
results.solver.termination_condition = TerminationCondition.infeasible
soln.status = SolutionStatus.infeasible
elif modelstat == 7:
results.solver.termination_condition = TerminationCondition.feasible
soln.status = SolutionStatus.feasible
elif modelstat == 8:
# 'Integer solution model found'
results.solver.termination_condition = TerminationCondition.optimal
soln.status = SolutionStatus.optimal
elif modelstat == 9:
results.solver.termination_condition = TerminationCondition.intermediateNonInteger
soln.status = SolutionStatus.other
elif modelstat == 11:
# Should be handled above, if modelstat and solvestat both
# indicate a licensing problem
if results.solver.termination_condition is None:
results.solver.termination_condition = TerminationCondition.licensingProblems
soln.status = SolutionStatus.error
elif modelstat in [12, 13]:
if results.solver.termination_condition is None:
results.solver.termination_condition = TerminationCondition.error
soln.status = SolutionStatus.error
elif modelstat == 14:
if results.solver.termination_condition is None:
results.solver.termination_condition = TerminationCondition.noSolution
soln.status = SolutionStatus.unknown
elif modelstat in [15, 16, 17]:
# Having to do with CNS models,
# not sure what to make of status descriptions
results.solver.termination_condition = TerminationCondition.optimal
soln.status = SolutionStatus.unsure
else:
# This is just a backup catch, all cases are handled above
soln.status = SolutionStatus.error
soln.gap = abs(results.problem.upper_bound \
- results.problem.lower_bound)
for sym, ref in iteritems(symbolMap.bySymbol):
obj = ref()
if isinstance(model, IBlock):
# Kernel variables have no 'parent_component'
if obj.ctype is IObjective:
soln.objective[sym] = {'Value': objctvval}
if obj.ctype is not IVariable:
continue
else:
if obj.parent_component().type() is Objective:
soln.objective[sym] = {'Value': objctvval}
if obj.parent_component().type() is not Var:
continue
rec = t1.out_db[sym].find_record()
# obj.value = rec.level
soln.variable[sym] = {"Value": rec.level}
if extract_rc and not math.isnan(rec.marginal):
# Do not set marginals to nan
# model.rc[obj] = rec.marginal
soln.variable[sym]['rc'] = rec.marginal
if extract_dual:
for c in model.component_data_objects(Constraint, active=True):
if c.body.is_fixed() or \
(not (c.has_lb() or c.has_ub())):
# the constraint was not sent to GAMS
continue
sym = symbolMap.getSymbol(c)
if c.equality:
rec = t1.out_db[sym].find_record()
if not math.isnan(rec.marginal):
# model.dual[c] = rec.marginal
soln.constraint[sym] = {'dual': rec.marginal}
else:
# Solver didn't provide marginals,
# nothing else to do here
break
else:
# Inequality, assume if 2-sided that only
# one side's marginal is nonzero
# Negate marginal for _lo equations
marg = 0
if c.lower is not None:
rec_lo = t1.out_db[sym + '_lo'].find_record()
marg -= rec_lo.marginal
if c.upper is not None:
rec_hi = t1.out_db[sym + '_hi'].find_record()
marg += rec_hi.marginal
if not math.isnan(marg):
# model.dual[c] = marg
soln.constraint[sym] = {'dual': marg}
else:
# Solver didn't provide marginals,
# nothing else to do here
break
results.solution.insert(soln)
if keepfiles:
print("\nGAMS WORKING DIRECTORY: %s\n" % ws.working_directory)
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
t1 = rec = rec_lo = rec_hi = None
file_removal_gams_direct(tmpdir, newdir)
####################################################################
# Finish with results
####################################################################
results._smap_id = smap_id
results._smap = None
if isinstance(model, IBlock):
if len(results.solution) == 1:
results.solution(0).symbol_map = \
getattr(model, "._symbol_maps")[results._smap_id]
results.solution(0).default_variable_value = \
self._default_variable_value
if load_solutions:
model.load_solution(results.solution(0))
else:
assert len(results.solution) == 0
# see the hack in the write method
# we don't want this to stick around on the model
# after the solve
assert len(getattr(model, "._symbol_maps")) == 1
delattr(model, "._symbol_maps")
del results._smap_id
if load_solutions and \
(len(results.solution) == 0):
logger.error("No solution is available")
else:
if load_solutions:
model.solutions.load_from(results)
results._smap_id = None
results.solution.clear()
else:
results._smap = model.solutions.symbol_map[smap_id]
model.solutions.delete_symbol_map(smap_id)
postsolve_completion_time = time.time()
if report_timing:
print(" %6.2f seconds required for postsolve" %
(postsolve_completion_time - solve_completion_time))
print(" %6.2f seconds required total" %
(postsolve_completion_time - initial_time))
return results
def solve(self, *args, **kwds):
"""
Uses GAMS Python API. For installation help visit:
https://www.gams.com/latest/docs/apis/examples_python/index.html
tee=False:
Output GAMS log to stdout.
load_solutions=True:
Does not support load_solutions=False.
keepfiles=False:
Keep temporary files. Equivalent of DebugLevel.KeepFiles.
Summary of temp files can be found in _gams_py_gjo0.pf
tmpdir=None:
Specify directory path for storing temporary files.
A directory will be created if one of this name doesn't exist.
io_options:
Updated with additional keywords passed to solve()
warmstart=False:
Warmstart by initializing model's variables to their values.
symbolic_solver_labels=False:
Use full Pyomo component names rather than
shortened symbols (slower, but useful for debugging).
labeler=None:
Custom labeler option. Incompatible with symbolic_solver_labels.
solver=None:
If None, GAMS will use default solver for model type.
mtype=None:
Model type. If None, will chose from lp, nlp, mip, and minlp.
add_options=None:
List of additional lines to write directly
into model file before the solve statement.
For model attributes, <model name> is GAMS_MODEL.
skip_trivial_constraints=False:
Skip writing constraints whose body section is fixed
file_determinism=1:
How much effort do we want to put into ensuring the
LP file is written deterministically for a Pyomo model:
0 : None
1 : sort keys of indexed components (default)
2 : sort keys AND sort names (over declaration order)
put_results=None:
Filename for optionally writing solution values and
marginals to (put_results).dat, and solver statuses
to (put_results + 'stat').dat.
"""
# Make sure available() doesn't crash
self.available()
from gams import GamsWorkspace, DebugLevel
from gams.workspace import GamsExceptionExecution
if len(args) != 1:
raise ValueError('Exactly one model must be passed '
'to solve method of GAMSSolver.')
model = args[0]
load_solutions = kwds.pop("load_solutions", True)
tee = kwds.pop("tee", False)
keepfiles = kwds.pop("keepfiles", False)
tmpdir = kwds.pop("tmpdir", None)
io_options = kwds.pop("io_options", {})
if len(kwds):
# Pass remaining keywords to writer, which will handle
# any unrecognized arguments
io_options.update(kwds)
####################################################################
# Presolve
####################################################################
# Create StringIO stream to pass to gams_writer, on which the
# model file will be written. The writer also passes this StringIO
# back, but output_file is defined in advance for clarity.
output_file = StringIO()
if isinstance(model, IBlockStorage):
# Kernel blocks have slightly different write method
smap_id = model.write(filename=output_file,
format=ProblemFormat.gams,
_called_by_solver=True,
**io_options)
symbolMap = getattr(model, "._symbol_maps")[smap_id]
else:
(_, smap_id) = model.write(filename=output_file,
format=ProblemFormat.gams,
io_options=io_options)
symbolMap = model.solutions.symbol_map[smap_id]
####################################################################
# Apply solver
####################################################################
# IMPORTANT - only delete the whole tmpdir if the solver was the one
# that made the directory. Otherwise, just delete the files the solver
# made, if not keepfiles. That way the user can select a directory
# they already have, like the current directory, without having to
# worry about the rest of the contents of that directory being deleted.
newdir = True
if tmpdir is not None and os.path.exists(tmpdir):
newdir = False
ws = GamsWorkspace(
debug=DebugLevel.KeepFiles if keepfiles else DebugLevel.Off,
working_directory=tmpdir)
t1 = ws.add_job_from_string(output_file.getvalue())
try:
t1.run(output=sys.stdout if tee else None)
except GamsExceptionExecution:
try:
check_expr_evaluation(model, symbolMap, 'direct')
finally:
# Always name working directory or delete files,
# regardless of any errors.
if keepfiles:
print("\nGAMS WORKING DIRECTORY: %s\n" %
ws.working_directory)
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
t1 = rec = rec_lo = rec_hi = None
file_removal_gams_direct(tmpdir, newdir)
raise
except:
# Catch other errors and remove files first
if keepfiles:
print("\nGAMS WORKING DIRECTORY: %s\n" % ws.working_directory)
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
t1 = rec = rec_lo = rec_hi = None
file_removal_gams_direct(tmpdir, newdir)
raise
####################################################################
# Postsolve
####################################################################
# import suffixes must be on the top-level model
if isinstance(model, IBlockStorage):
model_suffixes = list(name for (name,comp) \
in pyomo.core.kernel.component_suffix.\
import_suffix_generator(model,
active=True,
descend_into=False,
return_key=True))
else:
model_suffixes = list(name for (name,comp) \
in pyomo.core.base.suffix.\
active_import_suffix_generator(model))
extract_dual = ('dual' in model_suffixes)
extract_rc = ('rc' in model_suffixes)
results = SolverResults()
results.problem.name = t1.name
results.problem.lower_bound = t1.out_db["OBJEST"].find_record().value
results.problem.upper_bound = t1.out_db["OBJEST"].find_record().value
results.problem.number_of_variables = \
t1.out_db["NUMVAR"].find_record().value
results.problem.number_of_constraints = \
t1.out_db["NUMEQU"].find_record().value
results.problem.number_of_nonzeros = \
t1.out_db["NUMNZ"].find_record().value
results.problem.number_of_binary_variables = None
# Includes binary vars:
results.problem.number_of_integer_variables = \
t1.out_db["NUMDVAR"].find_record().value
results.problem.number_of_continuous_variables = \
t1.out_db["NUMVAR"].find_record().value \
- t1.out_db["NUMDVAR"].find_record().value
results.problem.number_of_objectives = 1 # required by GAMS writer
obj = list(model.component_data_objects(Objective, active=True))
assert len(obj) == 1, 'Only one objective is allowed.'
obj = obj[0]
objctvval = t1.out_db["OBJVAL"].find_record().value
if obj.is_minimizing():
results.problem.sense = ProblemSense.minimize
results.problem.upper_bound = objctvval
else:
results.problem.sense = ProblemSense.maximize
results.problem.lower_bound = objctvval
results.solver.name = "GAMS " + str(self.version())
# Init termination condition to None to give preference to this first
# block of code, only set certain TC's below if it's still None
results.solver.termination_condition = None
results.solver.message = None
solvestat = t1.out_db["SOLVESTAT"].find_record().value
if solvestat == 1:
results.solver.status = SolverStatus.ok
elif solvestat == 2:
results.solver.status = SolverStatus.ok
results.solver.termination_condition = TerminationCondition.maxIterations
elif solvestat == 3:
results.solver.status = SolverStatus.ok
results.solver.termination_condition = TerminationCondition.maxTimeLimit
elif solvestat == 5:
results.solver.status = SolverStatus.ok
results.solver.termination_condition = TerminationCondition.maxEvaluations
elif solvestat == 7:
results.solver.status = SolverStatus.aborted
results.solver.termination_condition = TerminationCondition.licensingProblems
elif solvestat == 8:
results.solver.status = SolverStatus.aborted
results.solver.termination_condition = TerminationCondition.userInterrupt
elif solvestat == 10:
results.solver.status = SolverStatus.error
results.solver.termination_condition = TerminationCondition.solverFailure
elif solvestat == 11:
results.solver.status = SolverStatus.error
results.solver.termination_condition = TerminationCondition.internalSolverError
elif solvestat == 4:
results.solver.status = SolverStatus.warning
results.solver.message = "Solver quit with a problem (see LST file)"
elif solvestat in (9, 12, 13):
results.solver.status = SolverStatus.error
elif solvestat == 6:
results.solver.status = SolverStatus.unknown
results.solver.return_code = 0
# Not sure if this value is actually user time
# "the elapsed time it took to execute a solve statement in total"
results.solver.user_time = t1.out_db["ETSOLVE"].find_record().value
results.solver.system_time = None
results.solver.wallclock_time = None
results.solver.termination_message = None
soln = Solution()
modelstat = t1.out_db["MODELSTAT"].find_record().value
if modelstat == 1:
results.solver.termination_condition = TerminationCondition.optimal
soln.status = SolutionStatus.optimal
elif modelstat == 2:
results.solver.termination_condition = TerminationCondition.locallyOptimal
soln.status = SolutionStatus.locallyOptimal
elif modelstat in [3, 18]:
results.solver.termination_condition = TerminationCondition.unbounded
soln.status = SolutionStatus.unbounded
elif modelstat in [4, 5, 6, 10, 19]:
results.solver.termination_condition = TerminationCondition.infeasible
soln.status = SolutionStatus.infeasible
elif modelstat == 7:
results.solver.termination_condition = TerminationCondition.feasible
soln.status = SolutionStatus.feasible
elif modelstat == 8:
# 'Integer solution model found'
results.solver.termination_condition = TerminationCondition.optimal
soln.status = SolutionStatus.optimal
elif modelstat == 9:
results.solver.termination_condition = TerminationCondition.intermediateNonInteger
soln.status = SolutionStatus.other
elif modelstat == 11:
# Should be handled above, if modelstat and solvestat both
# indicate a licensing problem
if results.solver.termination_condition is None:
results.solver.termination_condition = TerminationCondition.licensingProblems
soln.status = SolutionStatus.error
elif modelstat in [12, 13]:
if results.solver.termination_condition is None:
results.solver.termination_condition = TerminationCondition.error
soln.status = SolutionStatus.error
elif modelstat == 14:
if results.solver.termination_condition is None:
results.solver.termination_condition = TerminationCondition.noSolution
soln.status = SolutionStatus.unknown
elif modelstat in [15, 16, 17]:
# Having to do with CNS models,
# not sure what to make of status descriptions
results.solver.termination_condition = TerminationCondition.optimal
soln.status = SolutionStatus.unsure
else:
# This is just a backup catch, all cases are handled above
soln.status = SolutionStatus.error
soln.gap = abs(results.problem.upper_bound \
- results.problem.lower_bound)
for sym, ref in iteritems(symbolMap.bySymbol):
obj = ref()
if isinstance(model, IBlockStorage):
# Kernel variables have no 'parent_component'
if obj.ctype is Objective:
soln.objective[sym] = {'Value': objctvval}
if obj.ctype is not Var:
continue
else:
if obj.parent_component().type() is Objective:
soln.objective[sym] = {'Value': objctvval}
if obj.parent_component().type() is not Var:
continue
rec = t1.out_db[sym].find_record()
# obj.value = rec.level
soln.variable[sym] = {"Value": rec.level}
if extract_rc and not math.isnan(rec.marginal):
# Do not set marginals to nan
# model.rc[obj] = rec.marginal
soln.variable[sym]['rc'] = rec.marginal
if extract_dual:
for c in model.component_data_objects(Constraint, active=True):
if c.body.is_fixed():
continue
sym = symbolMap.getSymbol(c)
if c.equality:
rec = t1.out_db[sym].find_record()
if not math.isnan(rec.marginal):
# model.dual[c] = rec.marginal
soln.constraint[sym] = {'dual': rec.marginal}
else:
# Solver didn't provide marginals,
# nothing else to do here
break
else:
# Inequality, assume if 2-sided that only
# one side's marginal is nonzero
# Negate marginal for _lo equations
marg = 0
if c.lower is not None:
rec_lo = t1.out_db[sym + '_lo'].find_record()
marg -= rec_lo.marginal
if c.upper is not None:
rec_hi = t1.out_db[sym + '_hi'].find_record()
marg += rec_hi.marginal
if not math.isnan(marg):
# model.dual[c] = marg
soln.constraint[sym] = {'dual': marg}
else:
# Solver didn't provide marginals,
# nothing else to do here
break
results.solution.insert(soln)
if keepfiles:
print("\nGAMS WORKING DIRECTORY: %s\n" % ws.working_directory)
elif tmpdir is not None:
# Garbage collect all references to t1.out_db
# So that .gdx file can be deleted
t1 = rec = rec_lo = rec_hi = None
file_removal_gams_direct(tmpdir, newdir)
####################################################################
# Finish with results
####################################################################
results._smap_id = smap_id
results._smap = None
if isinstance(model, IBlockStorage):
if len(results.solution) == 1:
results.solution(0).symbol_map = \
getattr(model, "._symbol_maps")[results._smap_id]
results.solution(0).default_variable_value = \
self._default_variable_value
if load_solutions:
model.load_solution(results.solution(0))
results.solution.clear()
else:
assert len(results.solution) == 0
# see the hack in the write method
# we don't want this to stick around on the model
# after the solve
assert len(getattr(model, "._symbol_maps")) == 1
delattr(model, "._symbol_maps")
del results._smap_id
else:
if load_solutions:
model.solutions.load_from(results)
results._smap_id = None
results.solution.clear()
else:
results._smap = model.solutions.symbol_map[smap_id]
model.solutions.delete_symbol_map(smap_id)
return results