def __call__(self,
model,
output_filename,
solver_capability,
io_options):
"""
output_filename:
Name of file to write GAMS model to. Optionally pass a file-like
stream and the model will be written to that instead.
io_options:
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. 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
GAMS 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 not to modify the user's dictionary,
# they may be reusing it outside of this call
io_options = dict(io_options)
# Use full Pyomo component names rather than
# shortened symbols (slower, but useful for debugging).
symbolic_solver_labels = io_options.pop("symbolic_solver_labels", False)
# Custom labeler option. Incompatible with symbolic_solver_labels.
labeler = io_options.pop("labeler", None)
# If None, GAMS will use default solver for model type.
solver = io_options.pop("solver", None)
# If None, will chose from lp, nlp, mip, and minlp.
mtype = io_options.pop("mtype", None)
# Lines to add before solve statement.
add_options = io_options.pop("add_options", None)
# Skip writing constraints whose body section is
# fixed (i.e., no variables)
skip_trivial_constraints = \
io_options.pop("skip_trivial_constraints", False)
# How much effort do we want to put into ensuring the
# GAMS 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)
file_determinism = io_options.pop("file_determinism", 1)
sorter_map = {0:SortComponents.unsorted,
1:SortComponents.deterministic,
2:SortComponents.sortBoth}
sort = sorter_map[file_determinism]
# Warmstart by initializing model's variables to their values.
warmstart = io_options.pop("warmstart", False)
# Filename for optionally writing solution values and marginals
# Set to True by GAMSSolver
put_results = io_options.pop("put_results", None)
if len(io_options):
raise ValueError(
"ProblemWriter_gams passed unrecognized io_options:\n\t" +
"\n\t".join("%s = %s"
% (k,v) for k,v in iteritems(io_options)))
if solver is not None:
if solver.upper() not in valid_solvers:
raise ValueError("ProblemWriter_gams passed unrecognized "
"solver: %s" % solver)
if mtype is not None:
valid_mtypes = set([
'lp', 'qcp', 'nlp', 'dnlp', 'rmip', 'mip', 'rmiqcp', 'rminlp',
'miqcp', 'minlp', 'rmpec', 'mpec', 'mcp', 'cns', 'emp'])
if mtype.lower() not in valid_mtypes:
raise ValueError("ProblemWriter_gams passed unrecognized "
"model type: %s" % mtype)
if (solver is not None and
mtype.upper() not in valid_solvers[solver.upper()]):
raise ValueError("ProblemWriter_gams passed solver (%s) "
"unsuitable for given model type (%s)"
% (solver, mtype))
if output_filename is None:
output_filename = model.name + ".gms"
if symbolic_solver_labels and (labeler is not None):
raise ValueError("ProblemWriter_gams: Using both the "
"'symbolic_solver_labels' and 'labeler' "
"I/O options is forbidden")
if symbolic_solver_labels:
var_labeler = con_labeler = AlphaNumericTextLabeler()
elif labeler is None:
var_labeler = NumericLabeler('x')
con_labeler = NumericLabeler('c')
else:
var_labeler = con_labeler = labeler
var_list = []
symbolMap = SymbolMap()
def var_recorder(obj):
ans = var_labeler(obj)
var_list.append(ans)
return ans
def var_label(obj):
if obj.is_fixed():
return str(value(obj))
return symbolMap.getSymbol(obj, var_recorder)
# when sorting, there are a non-trivial number of
# temporary objects created. these all yield
# non-circular references, so disable GC - the
# overhead is non-trivial, and because references
# are non-circular, everything will be collected
# immediately anyway.
with PauseGC() as pgc:
try:
if isinstance(output_filename, string_types):
output_file = open(output_filename, "w")
else:
# Support passing of stream such as a StringIO
# on which to write the model file
output_file = output_filename
self._write_model(
model=model,
output_file=output_file,
solver_capability=solver_capability,
var_list=var_list,
var_label=var_label,
symbolMap=symbolMap,
con_labeler=con_labeler,
sort=sort,
skip_trivial_constraints=skip_trivial_constraints,
warmstart=warmstart,
solver=solver,
mtype=mtype,
add_options=add_options,
put_results=put_results
)
finally:
if isinstance(output_filename, string_types):
output_file.close()
return output_filename, symbolMap
def __call__(self, model, output_filename, solver_capability, io_options):
# Make sure not to modify the user's dictionary, they may be
# reusing it outside of this call
io_options = dict(io_options)
# NOTE: io_options is a simple dictionary of keyword-value
# pairs specific to this writer.
symbolic_solver_labels = \
io_options.pop("symbolic_solver_labels", False)
labeler = io_options.pop("labeler", None)
# 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)
file_determinism = io_options.pop("file_determinism", 1)
sorter = SortComponents.unsorted
if file_determinism >= 1:
sorter = sorter | SortComponents.indices
if file_determinism >= 2:
sorter = sorter | SortComponents.alphabetical
output_fixed_variable_bounds = \
io_options.pop("output_fixed_variable_bounds", False)
# Skip writing constraints whose body section is fixed (i.e.,
# no variables)
skip_trivial_constraints = \
io_options.pop("skip_trivial_constraints", False)
# Note: Baron does not allow specification of runtime
# option outside of this file, so we add support
# for them here
solver_options = io_options.pop("solver_options", {})
if len(io_options):
raise ValueError(
"ProblemWriter_baron_writer passed unrecognized io_options:\n\t"
+ "\n\t".join("%s = %s" % (k, v)
for k, v in iteritems(io_options)))
if symbolic_solver_labels and (labeler is not None):
raise ValueError("Baron problem writer: Using both the "
"'symbolic_solver_labels' and 'labeler' "
"I/O options is forbidden")
if output_filename is None:
output_filename = model.name + ".bar"
output_file = open(output_filename, "w")
# Process the options. Rely on baron to catch
# and reset bad option values
output_file.write("OPTIONS {\n")
summary_found = False
if len(solver_options):
for key, val in iteritems(solver_options):
if (key.lower() == 'summary'):
summary_found = True
if key.endswith("Name"):
output_file.write(key + ": \"" + str(val) + "\";\n")
else:
output_file.write(key + ": " + str(val) + ";\n")
if not summary_found:
# The 'summary option is defaulted to 0, so that no
# summary file is generated in the directory where the
# user calls baron. Check if a user explicitly asked for
# a summary file.
output_file.write("Summary: 0;\n")
output_file.write("}\n\n")
if symbolic_solver_labels:
labeler = AlphaNumericTextLabeler()
elif labeler is None:
labeler = NumericLabeler('x')
symbol_map = SymbolMap()
sm_bySymbol = symbol_map.bySymbol
#cache frequently called functions
create_symbol_func = SymbolMap.createSymbol
create_symbols_func = SymbolMap.createSymbols
alias_symbol_func = SymbolMap.alias
# Cache the list of model blocks so we don't have to call
# model.block_data_objects() many many times, which is slow
# for indexed blocks
all_blocks_list = list(
model.block_data_objects(active=True,
sort=sorter,
descend_into=True))
active_components_data_var = {}
for block in all_blocks_list:
tmp = active_components_data_var[id(block)] = \
list(obj for obj in block.component_data_objects(Var,
sort=sorter,
descend_into=False))
create_symbols_func(symbol_map, tmp, labeler)
# GAH: Not sure this is necessary, and also it would break for
# non-mutable indexed params so I am commenting out for now.
#for param_data in active_components_data(block, Param, sort=sorter):
#instead of checking if param_data._mutable:
#if not param_data.is_constant():
# create_symbol_func(symbol_map, param_data, labeler)
symbol_map_variable_ids = set(symbol_map.byObject.keys())
object_symbol_dictionary = symbol_map.byObject
#
# Go through the objectives and constraints and generate
# the output so that we can obtain the set of referenced
# variables.
#
equation_section_stream = StringIO()
referenced_variable_ids, branching_priorities_suffixes = \
self._write_equations_section(
model,
equation_section_stream,
all_blocks_list,
active_components_data_var,
symbol_map,
labeler,
create_symbol_func,
create_symbols_func,
alias_symbol_func,
object_symbol_dictionary,
output_fixed_variable_bounds,
skip_trivial_constraints,
sorter)
#
# BINARY_VARIABLES, INTEGER_VARIABLES, POSITIVE_VARIABLES, VARIABLES
#
BinVars = []
IntVars = []
PosVars = []
Vars = []
for block in all_blocks_list:
for var_data in active_components_data_var[id(block)]:
if id(var_data) not in referenced_variable_ids:
continue
if var_data.is_continuous():
if var_data.has_lb() and \
(self._get_bound(var_data.lb) >= 0):
TypeList = PosVars
else:
TypeList = Vars
elif var_data.is_binary():
TypeList = BinVars
elif var_data.is_integer():
TypeList = IntVars
else:
assert False
var_name = object_symbol_dictionary[id(var_data)]
#if len(var_name) > 15:
# logger.warning(
# "Variable symbol '%s' for variable %s exceeds maximum "
# "character limit for BARON. Solver may fail"
# % (var_name, var_data.name))
TypeList.append(var_name)
if len(BinVars) > 0:
output_file.write('BINARY_VARIABLES ')
for var_name in BinVars[:-1]:
output_file.write(str(var_name) + ', ')
output_file.write(str(BinVars[-1]) + ';\n\n')
if len(IntVars) > 0:
output_file.write('INTEGER_VARIABLES ')
for var_name in IntVars[:-1]:
output_file.write(str(var_name) + ', ')
output_file.write(str(IntVars[-1]) + ';\n\n')
output_file.write('POSITIVE_VARIABLES ')
output_file.write('ONE_VAR_CONST__')
for var_name in PosVars:
output_file.write(', ' + str(var_name))
output_file.write(';\n\n')
if len(Vars) > 0:
output_file.write('VARIABLES ')
for var_name in Vars[:-1]:
output_file.write(str(var_name) + ', ')
output_file.write(str(Vars[-1]) + ';\n\n')
#
# LOWER_BOUNDS
#
LowerBoundHeader = False
for block in all_blocks_list:
for var_data in active_components_data_var[id(block)]:
if id(var_data) not in referenced_variable_ids:
continue
if var_data.fixed:
if output_fixed_variable_bounds:
var_data_lb = var_data.value
else:
var_data_lb = None
else:
var_data_lb = None
if var_data.has_lb():
var_data_lb = self._get_bound(var_data.lb)
if var_data_lb is not None:
if LowerBoundHeader is False:
output_file.write("LOWER_BOUNDS{\n")
LowerBoundHeader = True
name_to_output = object_symbol_dictionary[id(var_data)]
lb_string_template = '%s: %' + self._precision_string + ';\n'
output_file.write(lb_string_template %
(name_to_output, var_data_lb))
if LowerBoundHeader:
output_file.write("}\n\n")
#
# UPPER_BOUNDS
#
UpperBoundHeader = False
for block in all_blocks_list:
for var_data in active_components_data_var[id(block)]:
if id(var_data) not in referenced_variable_ids:
continue
if var_data.fixed:
if output_fixed_variable_bounds:
var_data_ub = var_data.value
else:
var_data_ub = None
else:
var_data_ub = None
if var_data.has_ub():
var_data_ub = self._get_bound(var_data.ub)
if var_data_ub is not None:
if UpperBoundHeader is False:
output_file.write("UPPER_BOUNDS{\n")
UpperBoundHeader = True
name_to_output = object_symbol_dictionary[id(var_data)]
ub_string_template = '%s: %' + self._precision_string + ';\n'
output_file.write(ub_string_template %
(name_to_output, var_data_ub))
if UpperBoundHeader:
output_file.write("}\n\n")
#
# BRANCHING_PRIORITIES
#
# Specifyig priorities requires that the pyomo model has established an
# EXTERNAL, float suffix called 'branching_priorities' on the model
# object, indexed by the relevant variable
BranchingPriorityHeader = False
for suffix in branching_priorities_suffixes:
for var_data, priority in iteritems(suffix):
if id(var_data) not in referenced_variable_ids:
continue
if priority is not None:
if not BranchingPriorityHeader:
output_file.write('BRANCHING_PRIORITIES{\n')
BranchingPriorityHeader = True
name_to_output = object_symbol_dictionary[id(var_data)]
output_file.write(name_to_output + ': ' + str(priority) +
';\n')
if BranchingPriorityHeader:
output_file.write("}\n\n")
#
# Now write the objective and equations section
#
output_file.write(equation_section_stream.getvalue())
#
# STARTING_POINT
#
output_file.write('STARTING_POINT{\nONE_VAR_CONST__: 1;\n')
string_template = '%s: %' + self._precision_string + ';\n'
for block in all_blocks_list:
for var_data in active_components_data_var[id(block)]:
if id(var_data) not in referenced_variable_ids:
continue
starting_point = var_data.value
if starting_point is not None:
var_name = object_symbol_dictionary[id(var_data)]
output_file.write(string_template %
(var_name, starting_point))
output_file.write('}\n\n')
output_file.close()
# Clean up the symbol map to only contain variables referenced
# in the active constraints
vars_to_delete = symbol_map_variable_ids - referenced_variable_ids
sm_byObject = symbol_map.byObject
for varid in vars_to_delete:
symbol = sm_byObject[varid]
del sm_byObject[varid]
del sm_bySymbol[symbol]
del symbol_map_variable_ids
del referenced_variable_ids
return output_filename, symbol_map
def __call__(self, model, output_filename, solver_capability, io_options):
# Make sure not to modify the user's dictionary, they may be
# reusing it outside of this call
io_options = dict(io_options)
# NOTE: io_options is a simple dictionary of keyword-value
# pairs specific to this writer.
symbolic_solver_labels = \
io_options.pop("symbolic_solver_labels", False)
labeler = io_options.pop("labeler", None)
# 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)
file_determinism = io_options.pop("file_determinism", 1)
sorter = SortComponents.unsorted
if file_determinism >= 1:
sorter = sorter | SortComponents.indices
if file_determinism >= 2:
sorter = sorter | SortComponents.alphabetical
output_fixed_variable_bounds = \
io_options.pop("output_fixed_variable_bounds", False)
# Skip writing constraints whose body section is fixed (i.e.,
# no variables)
skip_trivial_constraints = \
io_options.pop("skip_trivial_constraints", False)
# Note: Baron does not allow specification of runtime
# option outside of this file, so we add support
# for them here
solver_options = io_options.pop("solver_options", {})
if len(io_options):
raise ValueError(
"ProblemWriter_baron_writer passed unrecognized io_options:\n\t"
+ "\n\t".join("%s = %s" % (k, v)
for k, v in iteritems(io_options)))
if symbolic_solver_labels and (labeler is not None):
raise ValueError("Baron problem writer: Using both the "
"'symbolic_solver_labels' and 'labeler' "
"I/O options is forbidden")
# Make sure there are no strange ActiveComponents. The expression
# walker will handle strange things in constraints later.
model_ctypes = model.collect_ctypes(active=True)
invalids = set()
for t in (model_ctypes - valid_active_ctypes_minlp):
if issubclass(t, ActiveComponent):
invalids.add(t)
if len(invalids):
invalids = [t.__name__ for t in invalids]
raise RuntimeError(
"Unallowable active component(s) %s.\nThe BARON writer cannot "
"export models with this component type." %
", ".join(invalids))
if output_filename is None:
output_filename = model.name + ".bar"
output_file = open(output_filename, "w")
# Process the options. Rely on baron to catch
# and reset bad option values
output_file.write("OPTIONS {\n")
summary_found = False
if len(solver_options):
for key, val in iteritems(solver_options):
if (key.lower() == 'summary'):
summary_found = True
if key.endswith("Name"):
output_file.write(key + ": \"" + str(val) + "\";\n")
else:
output_file.write(key + ": " + str(val) + ";\n")
if not summary_found:
# The 'summary option is defaulted to 0, so that no
# summary file is generated in the directory where the
# user calls baron. Check if a user explicitly asked for
# a summary file.
output_file.write("Summary: 0;\n")
output_file.write("}\n\n")
if symbolic_solver_labels:
v_labeler = AlphaNumericTextLabeler()
c_labeler = AlphaNumericTextLabeler()
elif labeler is None:
v_labeler = NumericLabeler('x')
c_labeler = NumericLabeler('c')
symbol_map = SymbolMap()
symbol_map.default_labeler = v_labeler
#sm_bySymbol = symbol_map.bySymbol
# Cache the list of model blocks so we don't have to call
# model.block_data_objects() many many times, which is slow
# for indexed blocks
all_blocks_list = list(
model.block_data_objects(active=True,
sort=sorter,
descend_into=True))
active_components_data_var = {}
#for block in all_blocks_list:
# tmp = active_components_data_var[id(block)] = \
# list(obj for obj in block.component_data_objects(Var,
# sort=sorter,
# descend_into=False))
# create_symbols_func(symbol_map, tmp, labeler)
# GAH: Not sure this is necessary, and also it would break for
# non-mutable indexed params so I am commenting out for now.
#for param_data in active_components_data(block, Param, sort=sorter):
#instead of checking if param_data._mutable:
#if not param_data.is_constant():
# create_symbol_func(symbol_map, param_data, labeler)
#symbol_map_variable_ids = set(symbol_map.byObject.keys())
#object_symbol_dictionary = symbol_map.byObject
#
# Go through the objectives and constraints and generate
# the output so that we can obtain the set of referenced
# variables.
#
equation_section_stream = StringIO()
referenced_variable_ids, branching_priorities_suffixes = \
self._write_equations_section(
model,
equation_section_stream,
all_blocks_list,
active_components_data_var,
symbol_map,
c_labeler,
output_fixed_variable_bounds,
skip_trivial_constraints,
sorter)
#
# BINARY_VARIABLES, INTEGER_VARIABLES, POSITIVE_VARIABLES, VARIABLES
#
BinVars = []
IntVars = []
PosVars = []
Vars = []
for vid in referenced_variable_ids:
name = symbol_map.byObject[vid]
var_data = symbol_map.bySymbol[name]()
if var_data.is_continuous():
if var_data.has_lb() and \
(self._get_bound(var_data.lb) >= 0):
TypeList = PosVars
else:
TypeList = Vars
elif var_data.is_binary():
TypeList = BinVars
elif var_data.is_integer():
TypeList = IntVars
else:
assert False
TypeList.append(name)
if len(BinVars) > 0:
BinVars.sort()
output_file.write('BINARY_VARIABLES ')
output_file.write(", ".join(BinVars))
output_file.write(';\n\n')
if len(IntVars) > 0:
IntVars.sort()
output_file.write('INTEGER_VARIABLES ')
output_file.write(", ".join(IntVars))
output_file.write(';\n\n')
PosVars.append('ONE_VAR_CONST__')
PosVars.sort()
output_file.write('POSITIVE_VARIABLES ')
output_file.write(", ".join(PosVars))
output_file.write(';\n\n')
if len(Vars) > 0:
Vars.sort()
output_file.write('VARIABLES ')
output_file.write(", ".join(Vars))
output_file.write(';\n\n')
#
# LOWER_BOUNDS
#
lbounds = {}
for vid in referenced_variable_ids:
name = symbol_map.byObject[vid]
var_data = symbol_map.bySymbol[name]()
if var_data.fixed:
if output_fixed_variable_bounds:
var_data_lb = var_data.value
else:
var_data_lb = None
else:
var_data_lb = None
if var_data.has_lb():
var_data_lb = self._get_bound(var_data.lb)
if var_data_lb is not None:
name_to_output = symbol_map.getSymbol(var_data)
lb_string_template = '%s: %' + self._precision_string + ';\n'
lbounds[name_to_output] = lb_string_template % (name_to_output,
var_data_lb)
if len(lbounds) > 0:
output_file.write("LOWER_BOUNDS{\n")
output_file.write("".join(lbounds[key]
for key in sorted(lbounds.keys())))
output_file.write("}\n\n")
lbounds = None
#
# UPPER_BOUNDS
#
ubounds = {}
for vid in referenced_variable_ids:
name = symbol_map.byObject[vid]
var_data = symbol_map.bySymbol[name]()
if var_data.fixed:
if output_fixed_variable_bounds:
var_data_ub = var_data.value
else:
var_data_ub = None
else:
var_data_ub = None
if var_data.has_ub():
var_data_ub = self._get_bound(var_data.ub)
if var_data_ub is not None:
name_to_output = symbol_map.getSymbol(var_data)
ub_string_template = '%s: %' + self._precision_string + ';\n'
ubounds[name_to_output] = ub_string_template % (name_to_output,
var_data_ub)
if len(ubounds) > 0:
output_file.write("UPPER_BOUNDS{\n")
output_file.write("".join(ubounds[key]
for key in sorted(ubounds.keys())))
output_file.write("}\n\n")
ubounds = None
#
# BRANCHING_PRIORITIES
#
# Specifying priorities requires that the pyomo model has established an
# EXTERNAL, float suffix called 'branching_priorities' on the model
# object, indexed by the relevant variable
BranchingPriorityHeader = False
for suffix in branching_priorities_suffixes:
for var_data, priority in iteritems(suffix):
if id(var_data) not in referenced_variable_ids:
continue
if priority is not None:
if not BranchingPriorityHeader:
output_file.write('BRANCHING_PRIORITIES{\n')
BranchingPriorityHeader = True
name_to_output = symbol_map.getSymbol(var_data)
output_file.write(name_to_output + ': ' + str(priority) +
';\n')
if BranchingPriorityHeader:
output_file.write("}\n\n")
#
# Now write the objective and equations section
#
output_file.write(equation_section_stream.getvalue())
#
# STARTING_POINT
#
output_file.write('STARTING_POINT{\nONE_VAR_CONST__: 1;\n')
tmp = {}
string_template = '%s: %' + self._precision_string + ';\n'
for vid in referenced_variable_ids:
name = symbol_map.byObject[vid]
var_data = symbol_map.bySymbol[name]()
starting_point = var_data.value
if starting_point is not None:
var_name = symbol_map.getSymbol(var_data)
tmp[var_name] = string_template % (var_name, starting_point)
output_file.write("".join(tmp[key] for key in sorted(tmp.keys())))
output_file.write('}\n\n')
output_file.close()
if output_filename == "root_relaxation_baron":
return output_filename, symbol_map, referenced_variable_ids
else:
return output_filename, symbol_map