def set_instance(self, model):
saved_config = self.config
saved_update_config = self.update_config
self.__init__()
self.config = saved_config
self.update_config = saved_update_config
self._model = model
if self.config.symbolic_solver_labels:
self._var_labeler = TextLabeler()
self._con_labeler = TextLabeler()
self._param_labeler = TextLabeler()
else:
self._var_labeler = NumericLabeler('x')
self._con_labeler = NumericLabeler('c')
self._param_labeler = NumericLabeler('p')
self._writer = cmodel.NLWriter()
self.add_block(model)
if self._objective is None:
self.set_objective(None)
def test_negative_float_double_operator(self):
m = ConcreteModel()
m.x = Var()
m.y = Var()
m.z = Var(bounds=(0, 6))
m.c = Constraint(expr=(m.x * m.y * -2) == 0)
m.c2 = Constraint(expr=m.z**-1.5 == 0)
m.o = Objective(expr=m.z)
m.y.fix(-7)
m.x.fix(4)
lbl = NumericLabeler('x')
smap = SymbolMap(lbl)
tc = StorageTreeChecker(m)
self.assertEqual(expression_to_string(m.c.body, tc, smap=smap),
("4*(-7)*(-2)", False))
self.assertEqual(expression_to_string(m.c2.body, tc, smap=smap),
("x1 ** (-1.5)", False))
def test_fixed_var_to_string(self):
m = ConcreteModel()
m.x = Var()
m.y = Var()
m.z = Var()
m.z.fix(-3)
lbl = NumericLabeler('x')
smap = SymbolMap(lbl)
tc = StorageTreeChecker(m)
self.assertEqual(expression_to_string(
m.x + m.y - m.z, tc, lbl, smap=smap), ("x1 + x2 + 3", False))
m.z.fix(-400)
self.assertEqual(expression_to_string(
m.z + m.y - m.z, tc, smap=smap), ("(-400) + x2 + 400", False))
m.z.fix(8.8)
self.assertEqual(expression_to_string(
m.x + m.z - m.y, tc, smap=smap), ("x1 + 8.8 - x2", False))
m.z.fix(-8.8)
self.assertEqual(expression_to_string(
m.x * m.z - m.y, tc, smap=smap), ("x1*(-8.8) - x2", False))
def test_fixed_var_to_string(self):
m = ConcreteModel()
m.x = Var()
m.y = Var()
m.z = Var()
m.z.fix(-3)
lbl = NumericLabeler('x')
smap = SymbolMap(lbl)
self.assertEquals(
expression_to_string(m.x + m.y - m.z, lbl, smap=smap),
"x1 + x2 - (-3)")
m.z.fix(-400)
self.assertEquals(expression_to_string(m.z + m.y - m.z, smap=smap),
"(-400) + x2 - (-400)")
m.z.fix(8.8)
self.assertEquals(expression_to_string(m.x + m.z - m.y, smap=smap),
"x1 + (8.8) - x2")
m.z.fix(-8.8)
self.assertEquals(expression_to_string(m.x * m.z - m.y, smap=smap),
"x1*(-8.8) - x2")
def test_arcfcn_to_string(self):
m = ConcreteModel()
m.x = Var()
lbl = NumericLabeler('x')
smap = SymbolMap(lbl)
tc = StorageTreeChecker(m)
self.assertEqual(expression_to_string(asin(m.x), tc, lbl, smap=smap),
("arcsin(x1)", False))
self.assertEqual(expression_to_string(acos(m.x), tc, lbl, smap=smap),
("arccos(x1)", False))
self.assertEqual(expression_to_string(atan(m.x), tc, lbl, smap=smap),
("arctan(x1)", False))
with self.assertRaisesRegexp(
RuntimeError,
"GAMS files cannot represent the unary function asinh"):
expression_to_string(asinh(m.x), tc, lbl, smap=smap)
with self.assertRaisesRegexp(
RuntimeError,
"GAMS files cannot represent the unary function acosh"):
expression_to_string(acosh(m.x), tc, lbl, smap=smap)
with self.assertRaisesRegexp(
RuntimeError,
"GAMS files cannot represent the unary function atanh"):
expression_to_string(atanh(m.x), tc, lbl, smap=smap)
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:
# Note that the Var and Constraint labelers must use the
# same labeler, so that we can correctly detect name
# collisions (which can arise when we truncate the labels to
# the max allowable length. BARON requires all identifiers
# to start with a letter. We will (randomly) choose "s_"
# (for 'shortened')
v_labeler = c_labeler = ShortNameLabeler(15,
prefix='s_',
suffix='_',
caseInsensitive=True,
legalRegex='^[a-zA-Z]')
elif labeler is None:
v_labeler = NumericLabeler('x')
c_labeler = NumericLabeler('c')
else:
v_labeler = c_labeler = labeler
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 (value(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 = ftoa(var_data.value)
else:
var_data_lb = None
else:
var_data_lb = None
if var_data.has_lb():
var_data_lb = ftoa(var_data.lb)
if var_data_lb is not None:
name_to_output = symbol_map.getSymbol(var_data)
lbounds[name_to_output] = '%s: %s;\n' % (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 = ftoa(var_data.value)
else:
var_data_ub = None
else:
var_data_ub = None
if var_data.has_ub():
var_data_ub = ftoa(var_data.ub)
if var_data_ub is not None:
name_to_output = symbol_map.getSymbol(var_data)
ubounds[name_to_output] = '%s: %s;\n' % (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 = {}
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] = "%s: %s;\n" % (var_name, ftoa(starting_point))
output_file.write("".join(tmp[key] for key in sorted(tmp.keys())))
output_file.write('}\n\n')
output_file.close()
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)
# Skip writing constraints whose body section is
# fixed (i.e., no variables)
skip_trivial_constraints = \
io_options.pop("skip_trivial_constraints", False)
# Use full Pyomo component names in the LP file rather
# than shortened symbols (slower, but useful for debugging).
symbolic_solver_labels = \
io_options.pop("symbolic_solver_labels", False)
output_fixed_variable_bounds = \
io_options.pop("output_fixed_variable_bounds", False)
# If False, unused variables will not be included in
# the LP file. Otherwise, include all variables in
# the bounds sections.
include_all_variable_bounds = \
io_options.pop("include_all_variable_bounds", 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)
# user defined orderings for variable and constraint
# output
row_order = io_options.pop("row_order", None)
column_order = io_options.pop("column_order", None)
# make sure the ONE_VAR_CONSTANT variable appears in
# the objective even if the constant part of the
# objective is zero
force_objective_constant = \
io_options.pop("force_objective_constant", False)
if len(io_options):
raise ValueError(
"ProblemWriter_cpxlp 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("ProblemWriter_cpxlp: Using both the "
"'symbolic_solver_labels' and 'labeler' "
"I/O options is forbidden")
if symbolic_solver_labels:
labeler = TextLabeler()
elif labeler is None:
labeler = NumericLabeler('x')
# clear the collection of referenced variables.
self._referenced_variable_ids.clear()
if output_filename is None:
output_filename = model.name + ".lp"
# 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:
with open(output_filename, "w") as output_file:
symbol_map = self._print_model_LP(
model,
output_file,
solver_capability,
labeler,
output_fixed_variable_bounds=output_fixed_variable_bounds,
file_determinism=file_determinism,
row_order=row_order,
column_order=column_order,
skip_trivial_constraints=skip_trivial_constraints,
force_objective_constant=force_objective_constant,
include_all_variable_bounds=include_all_variable_bounds)
self._referenced_variable_ids.clear()
return output_filename, symbol_map
def compile_instance(self,
pyomo_instance,
symbolic_solver_labels=False,
output_fixed_variable_bounds=False,
skip_trivial_constraints=False):
from pyomo.core.base import Var, Constraint, SOSConstraint
from pyomo.repn import canonical_is_constant, LinearCanonicalRepn, canonical_degree
self._symbolic_solver_labels = symbolic_solver_labels
self._output_fixed_variable_bounds = output_fixed_variable_bounds
self._skip_trivial_constraints = skip_trivial_constraints
self._has_quadratic_constraints = False
self._has_quadratic_objective = False
self._active_cplex_instance = CPLEXDirect._cplex_module.Cplex()
if self._symbolic_solver_labels:
labeler = self._labeler = TextLabeler()
else:
labeler = self._labeler = NumericLabeler('x')
self._symbol_map = SymbolMap()
self._instance = pyomo_instance
if isinstance(pyomo_instance, IBlockStorage):
# BIG HACK
if not hasattr(pyomo_instance, "._symbol_maps"):
setattr(pyomo_instance, "._symbol_maps", {})
getattr(pyomo_instance, "._symbol_maps")[id(self._symbol_map)] = \
self._symbol_map
else:
pyomo_instance.solutions.add_symbol_map(self._symbol_map)
self._smap_id = id(self._symbol_map)
# we use this when iterating over the constraints because it
# will have a much smaller hash table, we also use this for
# the warm start code after it is cleaned to only contain
# variables referenced in the constraints
self._variable_symbol_map = SymbolMap()
# cplex wants the caller to set the problem type, which is (for
# current purposes) strictly based on variable type counts.
self._num_binary_variables = 0
self._num_integer_variables = 0
self._num_continuous_variables = 0
self._used_sos_constraints = False
#############################################
# populate the variables in the cplex model #
#############################################
var_names = []
var_lbs = []
var_ubs = []
var_types = []
self._referenced_variable_ids.clear()
# maps pyomo var data labels to the corresponding CPLEX variable id.
self._cplex_variable_ids.clear()
# cached in the loop below - used to update the symbol map
# immediately following loop termination.
var_label_pairs = []
for var_data in pyomo_instance.component_data_objects(Var, active=True):
if var_data.fixed and not self._output_fixed_variable_bounds:
# if a variable is fixed, and we're preprocessing
# fixed variables (as in not outputting them), there
# is no need to add them to the compiled model.
continue
var_name = self._symbol_map.getSymbol(var_data, labeler)
var_names.append(var_name)
var_label_pairs.append((var_data, var_name))
self._cplex_variable_ids[var_name] = len(self._cplex_variable_ids)
if not var_data.has_lb():
var_lbs.append(-CPLEXDirect._cplex_module.infinity)
else:
var_lbs.append(value(var_data.lb))
if not var_data.has_ub():
var_ubs.append(CPLEXDirect._cplex_module.infinity)
else:
var_ubs.append(value(var_data.ub))
if var_data.is_integer():
var_types.append(self._active_cplex_instance.variables.type.integer)
self._num_integer_variables += 1
elif var_data.is_binary():
var_types.append(self._active_cplex_instance.variables.type.binary)
self._num_binary_variables += 1
elif var_data.is_continuous():
var_types.append(self._active_cplex_instance.variables.type.continuous)
self._num_continuous_variables += 1
else:
raise TypeError("Invalid domain type for variable with name '%s'. "
"Variable is not continuous, integer, or binary.")
self._active_cplex_instance.variables.add(names=var_names,
lb=var_lbs,
ub=var_ubs,
types=var_types)
self._active_cplex_instance.variables.add(lb=[1],
ub=[1],
names=["ONE_VAR_CONSTANT"])
self._cplex_variable_ids["ONE_VAR_CONSTANT"] = len(self._cplex_variable_ids)
self._variable_symbol_map.addSymbols(var_label_pairs)
self._cplex_variable_names = self._active_cplex_instance.variables.get_names()
########################################################
# populate the standard constraints in the cplex model #
########################################################
expressions = []
senses = []
rhss = []
range_values = []
names = []
qexpressions = []
qlinears = []
qsenses = []
qrhss = []
qnames = []
for block in pyomo_instance.block_data_objects(active=True):
gen_con_canonical_repn = \
getattr(block, "_gen_con_canonical_repn", True)
# Get/Create the ComponentMap for the repn
if not hasattr(block,'_canonical_repn'):
block._canonical_repn = ComponentMap()
block_canonical_repn = block._canonical_repn
for con in block.component_data_objects(Constraint,
active=True,
descend_into=False):
if (not con.has_lb()) and \
(not con.has_ub()):
assert not con.equality
continue # not binding at all, don't bother
con_repn = None
if con._linear_canonical_form:
con_repn = con.canonical_form()
elif isinstance(con, LinearCanonicalRepn):
con_repn = con
else:
if gen_con_canonical_repn:
con_repn = generate_canonical_repn(con.body)
block_canonical_repn[con] = con_repn
else:
con_repn = block_canonical_repn[con]
# There are conditions, e.g., when fixing variables, under which
# a constraint block might be empty. Ignore these, for both
# practical reasons and the fact that the CPLEX LP format
# requires a variable in the constraint body. It is also
# possible that the body of the constraint consists of only a
# constant, in which case the "variable" of
if isinstance(con_repn, LinearCanonicalRepn):
if self._skip_trivial_constraints and \
((con_repn.linear is None) or \
(len(con_repn.linear) == 0)):
continue
else:
# we shouldn't come across a constant canonical repn
# that is not LinearCanonicalRepn
assert not canonical_is_constant(con_repn)
name = self._symbol_map.getSymbol(con, labeler)
expr = None
qexpr = None
quadratic = False
if isinstance(con_repn, LinearCanonicalRepn):
expr, offset = \
self._encode_constraint_body_linear_specialized(con_repn,
labeler,
use_variable_names=False,
cplex_variable_name_index_map=self._cplex_variable_ids)
else:
degree = canonical_degree(con_repn)
if degree == 2:
quadratic = True
elif (degree != 0) or (degree != 1):
raise ValueError(
"CPLEXPersistent plugin does not support general nonlinear "
"constraint expression (only linear or quadratic).\n"
"Constraint: %s" % (con.name))
expr, offset = self._encode_constraint_body_linear(con_repn,
labeler)
if quadratic:
if expr is None:
expr = CPLEXDirect._cplex_module.SparsePair(ind=[0],val=[0.0])
self._has_quadratic_constraints = True
qexpr = self._encode_constraint_body_quadratic(con_repn,labeler)
qnames.append(name)
if con.equality:
# equality constraint.
qsenses.append('E')
qrhss.append(self._get_bound(con.lower) - offset)
elif con.has_lb() and con.has_ub():
raise RuntimeError(
"The CPLEXDirect plugin can not translate range "
"constraints containing quadratic expressions.")
elif con.has_lb():
assert not con.has_ub()
qsenses.append('G')
qrhss.append(self._get_bound(con.lower) - offset)
else:
assert con.has_ub()
qsenses.append('L')
qrhss.append(self._get_bound(con.upper) - offset)
qlinears.append(expr)
qexpressions.append(qexpr)
else:
names.append(name)
expressions.append(expr)
if con.equality:
# equality constraint.
senses.append('E')
rhss.append(self._get_bound(con.lower) - offset)
range_values.append(0.0)
elif con.has_lb() and con.has_ub():
# ranged constraint.
senses.append('R')
lower_bound = self._get_bound(con.lower) - offset
upper_bound = self._get_bound(con.upper) - offset
rhss.append(lower_bound)
range_values.append(upper_bound - lower_bound)
elif con.has_lb():
senses.append('G')
rhss.append(self._get_bound(con.lower) - offset)
range_values.append(0.0)
else:
assert con.has_ub()
senses.append('L')
rhss.append(self._get_bound(con.upper) - offset)
range_values.append(0.0)
###################################################
# populate the SOS constraints in the cplex model #
###################################################
# SOS constraints - largely taken from cpxlp.py so updates there,
# should be applied here
# TODO: Allow users to specify the variables coefficients for custom
# branching/set orders - refer to cpxlp.py
sosn = self._capabilities.sosn
sos1 = self._capabilities.sos1
sos2 = self._capabilities.sos2
modelSOS = ModelSOS()
for soscondata in pyomo_instance.component_data_objects(SOSConstraint,
active=True):
level = soscondata.level
if (level == 1 and not sos1) or \
(level == 2 and not sos2) or \
(level > 2 and not sosn):
raise Exception("Solver does not support SOS level %s constraints"
% (level,))
modelSOS.count_constraint(self._symbol_map,
labeler,
self._variable_symbol_map,
soscondata)
if modelSOS.sosType:
for key in modelSOS.sosType:
self._active_cplex_instance.SOS.add(type = modelSOS.sosType[key],
name = modelSOS.sosName[key],
SOS = [modelSOS.varnames[key],
modelSOS.weights[key]])
self._referenced_variable_ids.update(modelSOS.varids[key])
self._used_sos_constraints = True
self._active_cplex_instance.linear_constraints.add(
lin_expr=expressions,
senses=senses,
rhs=rhss,
range_values=range_values,
names=names)
for index in xrange(len(qexpressions)):
self._active_cplex_instance.quadratic_constraints.add(
lin_expr=qlinears[index],
quad_expr=qexpressions[index],
sense=qsenses[index],
rhs=qrhss[index],
name=qnames[index])
#############################################
# populate the objective in the cplex model #
#############################################
self.compile_objective(pyomo_instance)
def __call__(self, model, output_filename, solver_capability, io_options):
"""
Write a model in the GAMS modeling language format.
Keyword Arguments
-----------------
output_filename: str
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: dict
- warmstart=True
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", True)
# 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(
"GAMS writer 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 and solver.upper() not in valid_solvers:
raise ValueError("GAMS writer 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("GAMS writer passed unrecognized "
"model type: %s" % mtype)
if (solver is not None
and mtype.upper() not in valid_solvers[solver.upper()]):
raise ValueError("GAMS writer 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("GAMS writer: Using both the "
"'symbolic_solver_labels' and 'labeler' "
"I/O options is forbidden")
if symbolic_solver_labels:
var_labeler = con_labeler = ShortNameLabeler(63, '_')
elif labeler is None:
var_labeler = NumericLabeler('x')
con_labeler = NumericLabeler('c')
else:
var_labeler = con_labeler = labeler
var_list = []
def var_recorder(obj):
ans = var_labeler(obj)
try:
if obj.is_variable_type():
var_list.append(ans)
except:
pass
return ans
def var_label(obj):
#if obj.is_fixed():
# return str(value(obj))
return symbolMap.getSymbol(obj, var_recorder)
symbolMap = SymbolMap(var_label)
# 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
class NLWriter(PersistentBase):
def __init__(self):
super(NLWriter, self).__init__()
self._config = WriterConfig()
self._writer = None
self._symbol_map = SymbolMap()
self._var_labeler = None
self._con_labeler = None
self._param_labeler = None
self._pyomo_var_to_solver_var_map = dict()
self._pyomo_con_to_solver_con_map = dict()
self._solver_var_to_pyomo_var_map = dict()
self._solver_con_to_pyomo_con_map = dict()
self._pyomo_param_to_solver_param_map = dict()
self._walker = PyomoToCModelWalker(
self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map)
@property
def config(self):
return self._config
@config.setter
def config(self, val: WriterConfig):
self._config = val
@property
def symbol_map(self):
return self._symbol_map
def set_instance(self, model):
saved_config = self.config
saved_update_config = self.update_config
self.__init__()
self.config = saved_config
self.update_config = saved_update_config
self._model = model
if self.config.symbolic_solver_labels:
self._var_labeler = TextLabeler()
self._con_labeler = TextLabeler()
self._param_labeler = TextLabeler()
else:
self._var_labeler = NumericLabeler('x')
self._con_labeler = NumericLabeler('c')
self._param_labeler = NumericLabeler('p')
self._writer = cmodel.NLWriter()
self.add_block(model)
if self._objective is None:
self.set_objective(None)
def _add_variables(self, variables: List[_GeneralVarData]):
cvars = cmodel.create_vars(len(variables))
for ndx, v in enumerate(variables):
cv = cvars[ndx]
cv.name = self._symbol_map.getSymbol(v, self._var_labeler)
if not v.is_continuous():
raise NotImplementedError(
'NLWriter currently only supports continuous variables')
lb = value(v.lb)
ub = value(v.ub)
if lb is not None:
cv.lb = lb
if ub is not None:
cv.ub = ub
if v.value is not None:
cv.value = v.value
if v.is_fixed():
cv.fixed = True
self._pyomo_var_to_solver_var_map[id(v)] = cv
self._solver_var_to_pyomo_var_map[cv] = v
def _add_params(self, params: List[_ParamData]):
cparams = cmodel.create_params(len(params))
for ndx, p in enumerate(params):
cp = cparams[ndx]
cp.name = self._symbol_map.getSymbol(p, self._param_labeler)
cp.value = p.value
self._pyomo_param_to_solver_param_map[id(p)] = cp
def _add_constraints(self, cons: List[_GeneralConstraintData]):
for c in cons:
cname = self._symbol_map.getSymbol(c, self._con_labeler)
repn = generate_standard_repn(c.body,
compute_values=False,
quadratic=False)
const = self._walker.dfs_postorder_stack(repn.constant)
lin_vars = [
self._pyomo_var_to_solver_var_map[id(i)]
for i in repn.linear_vars
]
lin_coef = [
self._walker.dfs_postorder_stack(i) for i in repn.linear_coefs
]
if repn.nonlinear_expr is None:
nonlin = self._walker.dfs_postorder_stack(0)
else:
nonlin = self._walker.dfs_postorder_stack(repn.nonlinear_expr)
cc = cmodel.NLConstraint(const, lin_coef, lin_vars, nonlin)
lb = c.lower
ub = c.upper
if lb is not None:
cc.lb = self._walker.dfs_postorder_stack(lb)
if ub is not None:
cc.ub = self._walker.dfs_postorder_stack(ub)
self._writer.add_constraint(cc)
self._pyomo_con_to_solver_con_map[c] = cc
self._solver_con_to_pyomo_con_map[cc] = c
def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError(
'NL writer does not support SOS constraints')
def _remove_constraints(self, cons: List[_GeneralConstraintData]):
for c in cons:
cc = self._pyomo_con_to_solver_con_map.pop(c)
self._writer.remove_constraint(cc)
self._symbol_map.removeSymbol(c)
self._con_labeler.remove_obj(c)
del self._solver_con_to_pyomo_con_map[cc]
def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError(
'NL writer does not support SOS constraints')
def _remove_variables(self, variables: List[_GeneralVarData]):
for v in variables:
cvar = self._pyomo_var_to_solver_var_map.pop(id(v))
del self._solver_var_to_pyomo_var_map[cvar]
self._symbol_map.removeSymbol(v)
self._var_labeler.remove_obj(v)
def _remove_params(self, params: List[_ParamData]):
for p in params:
del self._pyomo_param_to_solver_param_map[id(p)]
self._symbol_map.removeSymbol(p)
self._param_labeler.remove_obj(p)
def _update_variables(self, variables: List[_GeneralVarData]):
for v in variables:
cv = self._pyomo_var_to_solver_var_map[id(v)]
if not v.is_continuous():
raise NotImplementedError(
'NLWriter currently only supports continuous variables')
lb = value(v.lb)
ub = value(v.ub)
if lb is None:
cv.lb = -cmodel.inf
else:
cv.lb = lb
if ub is None:
cv.ub = cmodel.inf
else:
cv.ub = ub
if v.value is not None:
cv.value = v.value
if v.is_fixed():
cv.fixed = True
else:
cv.fixed = False
def update_params(self):
for p_id, p in self._params.items():
cp = self._pyomo_param_to_solver_param_map[p_id]
cp.value = p.value
def _set_objective(self, obj: _GeneralObjectiveData):
if obj is None:
const = cmodel.Constant(0)
lin_vars = list()
lin_coef = list()
nonlin = cmodel.Constant(0)
sense = 0
else:
repn = generate_standard_repn(obj.expr,
compute_values=False,
quadratic=False)
const = self._walker.dfs_postorder_stack(repn.constant)
lin_vars = [
self._pyomo_var_to_solver_var_map[id(i)]
for i in repn.linear_vars
]
lin_coef = [
self._walker.dfs_postorder_stack(i) for i in repn.linear_coefs
]
if repn.nonlinear_expr is None:
nonlin = cmodel.Constant(0)
else:
nonlin = self._walker.dfs_postorder_stack(repn.nonlinear_expr)
if obj.sense is minimize:
sense = 0
else:
sense = 1
cobj = cmodel.NLObjective(const, lin_coef, lin_vars, nonlin)
cobj.sense = sense
self._writer.objective = cobj
def write(self,
model: _BlockData,
filename: str,
timer: HierarchicalTimer = None):
if timer is None:
timer = HierarchicalTimer()
if model is not self._model:
timer.start('set_instance')
self.set_instance(model)
timer.stop('set_instance')
else:
timer.start('update')
self.update(timer=timer)
for cv, v in self._solver_var_to_pyomo_var_map.items():
if v.value is not None:
cv.value = v.value
timer.stop('update')
timer.start('write file')
self._writer.write(filename)
timer.stop('write file')
def get_ordered_vars(self):
return [
self._solver_var_to_pyomo_var_map[i]
for i in self._writer.get_solve_vars()
]
def get_ordered_cons(self):
return [
self._solver_con_to_pyomo_con_map[i]
for i in self._writer.get_solve_cons()
]
def get_active_objective(self):
return self._objective
class LPWriter(PersistentBase):
def __init__(self):
super(LPWriter, self).__init__()
self._config = WriterConfig()
self._writer = None
self._symbol_map = SymbolMap()
self._var_labeler = None
self._con_labeler = None
self._param_labeler = None
self._obj_labeler = None
self._pyomo_var_to_solver_var_map = dict()
self._pyomo_con_to_solver_con_map = dict()
self._solver_var_to_pyomo_var_map = dict()
self._solver_con_to_pyomo_con_map = dict()
self._pyomo_param_to_solver_param_map = dict()
self._walker = PyomoToCModelWalker(
self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map)
@property
def config(self):
return self._config
@config.setter
def config(self, val: WriterConfig):
self._config = val
def set_instance(self, model):
saved_config = self.config
saved_update_config = self.update_config
self.__init__()
self.config = saved_config
self.update_config = saved_update_config
self._model = model
if self.config.symbolic_solver_labels:
self._var_labeler = TextLabeler()
self._con_labeler = TextLabeler()
self._param_labeler = TextLabeler()
self._obj_labeler = TextLabeler()
else:
self._var_labeler = NumericLabeler('x')
self._con_labeler = NumericLabeler('c')
self._param_labeler = NumericLabeler('p')
self._obj_labeler = NumericLabeler('obj')
self._writer = cmodel.LPWriter()
self.add_block(model)
if self._objective is None:
self.set_objective(None)
def _add_variables(self, variables: List[_GeneralVarData]):
cvars = cmodel.create_vars(len(variables))
for ndx, v in enumerate(variables):
cv = cvars[ndx]
cv.name = self._symbol_map.getSymbol(v, self._var_labeler)
if v.is_binary():
cv.domain = 'binary'
elif v.is_integer():
cv.domain = 'integer'
else:
assert v.is_continuous(
), 'LP writer only supports continuous, binary, and integer variables'
cv.domain = 'continuous'
_, lb, ub, v_is_fixed, v_domain, v_value = self._vars[id(v)]
if lb is not None:
cv.lb = lb
if ub is not None:
cv.ub = ub
if v_value is not None:
cv.value = v_value
if v_is_fixed:
cv.fixed = True
self._pyomo_var_to_solver_var_map[id(v)] = cv
self._solver_var_to_pyomo_var_map[cv] = v
def _add_params(self, params: List[_ParamData]):
cparams = cmodel.create_params(len(params))
for ndx, p in enumerate(params):
cp = cparams[ndx]
cp.name = self._symbol_map.getSymbol(p, self._param_labeler)
cp.value = p.value
self._pyomo_param_to_solver_param_map[id(p)] = cp
def _add_constraints(self, cons: List[_GeneralConstraintData]):
cmodel.process_lp_constraints(cons, self)
def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError(
'LP writer does not yet support SOS constraints')
def _remove_constraints(self, cons: List[_GeneralConstraintData]):
for c in cons:
cc = self._pyomo_con_to_solver_con_map.pop(c)
self._writer.remove_constraint(cc)
self._symbol_map.removeSymbol(c)
self._con_labeler.remove_obj(c)
del self._solver_con_to_pyomo_con_map[cc]
def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError(
'LP writer does not yet support SOS constraints')
def _remove_variables(self, variables: List[_GeneralVarData]):
for v in variables:
cvar = self._pyomo_var_to_solver_var_map.pop(id(v))
del self._solver_var_to_pyomo_var_map[cvar]
self._symbol_map.removeSymbol(v)
self._var_labeler.remove_obj(v)
def _remove_params(self, params: List[_ParamData]):
for p in params:
del self._pyomo_param_to_solver_param_map[id(p)]
self._symbol_map.removeSymbol(p)
self._param_labeler.remove_obj(p)
def update_variables(self, variables: List[_GeneralVarData]):
for v in variables:
cv = self._pyomo_var_to_solver_var_map[id(v)]
if v.is_binary():
cv.domain = 'binary'
elif v.is_integer():
cv.domain = 'integer'
else:
assert v.is_continuous(
), 'LP writer only supports continuous, binary, and integer variables'
cv.domain = 'continuous'
lb = value(v.lb)
ub = value(v.ub)
if lb is None:
cv.lb = -cmodel.inf
else:
cv.lb = lb
if ub is None:
cv.ub = cmodel.inf
else:
cv.ub = ub
if v.value is not None:
cv.value = v.value
if v.is_fixed():
cv.fixed = True
else:
cv.fixed = False
def update_params(self):
for p_id, p in self._params.items():
cp = self._pyomo_param_to_solver_param_map[p_id]
cp.value = p.value
def _set_objective(self, obj: _GeneralObjectiveData):
if obj is None:
const = cmodel.Constant(0)
lin_coef = list()
lin_vars = list()
quad_coef = list()
quad_vars_1 = list()
quad_vars_2 = list()
sense = 0
else:
repn = generate_standard_repn(obj.expr,
compute_values=False,
quadratic=True)
const = self._walker.dfs_postorder_stack(repn.constant)
lin_coef = [
self._walker.dfs_postorder_stack(i) for i in repn.linear_coefs
]
lin_vars = [
self._pyomo_var_to_solver_var_map[id(i)]
for i in repn.linear_vars
]
quad_coef = [
self._walker.dfs_postorder_stack(i)
for i in repn.quadratic_coefs
]
quad_vars_1 = [
self._pyomo_var_to_solver_var_map[id(i[0])]
for i in repn.quadratic_vars
]
quad_vars_2 = [
self._pyomo_var_to_solver_var_map[id(i[1])]
for i in repn.quadratic_vars
]
if obj.sense is minimize:
sense = 0
else:
sense = 1
cobj = cmodel.LPObjective(const, lin_coef, lin_vars, quad_coef,
quad_vars_1, quad_vars_2)
cobj.sense = sense
if obj is None:
cname = 'objective'
else:
cname = self._symbol_map.getSymbol(obj, self._obj_labeler)
cobj.name = cname
self._writer.objective = cobj
def write(self,
model: _BlockData,
filename: str,
timer: HierarchicalTimer = None):
if timer is None:
timer = HierarchicalTimer()
if model is not self._model:
timer.start('set_instance')
self.set_instance(model)
timer.stop('set_instance')
else:
timer.start('update')
self.update(timer=timer)
timer.stop('update')
timer.start('write file')
self._writer.write(filename)
timer.stop('write file')
def get_vars(self):
return [
self._solver_var_to_pyomo_var_map[i]
for i in self._writer.get_solve_vars()
]
def get_ordered_cons(self):
return [
self._solver_con_to_pyomo_con_map[i]
for i in self._writer.get_solve_cons()
]
def get_active_objective(self):
return self._objective
@property
def symbol_map(self):
return self._symbol_map
class NLWriter(PersistentBase):
def __init__(self):
super(NLWriter, self).__init__()
self._config = WriterConfig()
self._writer = None
self._symbol_map = SymbolMap()
self._var_labeler = None
self._con_labeler = None
self._param_labeler = None
self._pyomo_var_to_solver_var_map = dict()
self._pyomo_con_to_solver_con_map = dict()
self._solver_var_to_pyomo_var_map = dict()
self._solver_con_to_pyomo_con_map = dict()
self._pyomo_param_to_solver_param_map = dict()
self._expr_types = None
@property
def config(self):
return self._config
@config.setter
def config(self, val: WriterConfig):
self._config = val
@property
def symbol_map(self):
return self._symbol_map
def set_instance(self, model):
saved_config = self.config
saved_update_config = self.update_config
self.__init__()
self.config = saved_config
self.update_config = saved_update_config
self._model = model
self._expr_types = cmodel.PyomoExprTypes()
if self.config.symbolic_solver_labels:
self._var_labeler = TextLabeler()
self._con_labeler = TextLabeler()
self._param_labeler = TextLabeler()
else:
self._var_labeler = NumericLabeler('x')
self._con_labeler = NumericLabeler('c')
self._param_labeler = NumericLabeler('p')
self._writer = cmodel.NLWriter()
self.add_block(model)
if self._objective is None:
self.set_objective(None)
self._set_pyomo_amplfunc_env()
def _add_variables(self, variables: List[_GeneralVarData]):
cmodel.process_pyomo_vars(self._expr_types, variables,
self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map,
self._vars,
self._solver_var_to_pyomo_var_map, False,
None, None, False)
def _add_params(self, params: List[_ParamData]):
cparams = cmodel.create_params(len(params))
for ndx, p in enumerate(params):
cp = cparams[ndx]
cp.name = self._symbol_map.getSymbol(p, self._param_labeler)
cp.value = p.value
self._pyomo_param_to_solver_param_map[id(p)] = cp
def _add_constraints(self, cons: List[_GeneralConstraintData]):
cmodel.process_nl_constraints(self._writer, self._expr_types, cons,
self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map,
self._active_constraints,
self._pyomo_con_to_solver_con_map,
self._solver_con_to_pyomo_con_map)
def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError(
'NL writer does not support SOS constraints')
def _remove_constraints(self, cons: List[_GeneralConstraintData]):
for c in cons:
cc = self._pyomo_con_to_solver_con_map.pop(c)
self._writer.remove_constraint(cc)
self._con_labeler.remove_obj(c)
del self._solver_con_to_pyomo_con_map[cc]
def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError(
'NL writer does not support SOS constraints')
def _remove_variables(self, variables: List[_GeneralVarData]):
for v in variables:
cvar = self._pyomo_var_to_solver_var_map.pop(id(v))
del self._solver_var_to_pyomo_var_map[cvar]
# self._symbol_map.removeSymbol(v)
self._var_labeler.remove_obj(v)
def _remove_params(self, params: List[_ParamData]):
for p in params:
del self._pyomo_param_to_solver_param_map[id(p)]
self._symbol_map.removeSymbol(p)
self._param_labeler.remove_obj(p)
def _update_variables(self, variables: List[_GeneralVarData]):
cmodel.process_pyomo_vars(self._expr_types, variables,
self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map,
self._vars,
self._solver_var_to_pyomo_var_map, False,
None, None, True)
def update_params(self):
for p_id, p in self._params.items():
cp = self._pyomo_param_to_solver_param_map[p_id]
cp.value = p.value
def _set_objective(self, obj: _GeneralObjectiveData):
if obj is None:
const = cmodel.Constant(0)
lin_vars = list()
lin_coef = list()
nonlin = cmodel.Constant(0)
sense = 0
else:
pyomo_expr_types = cmodel.PyomoExprTypes()
repn = generate_standard_repn(obj.expr,
compute_values=False,
quadratic=False)
const = cmodel.appsi_expr_from_pyomo_expr(
repn.constant, self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map, pyomo_expr_types)
lin_vars = [
self._pyomo_var_to_solver_var_map[id(i)]
for i in repn.linear_vars
]
lin_coef = [
cmodel.appsi_expr_from_pyomo_expr(
i, self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map, pyomo_expr_types)
for i in repn.linear_coefs
]
if repn.nonlinear_expr is None:
nonlin = cmodel.appsi_expr_from_pyomo_expr(
0, self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map, pyomo_expr_types)
else:
nonlin = cmodel.appsi_expr_from_pyomo_expr(
repn.nonlinear_expr, self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map, pyomo_expr_types)
if obj.sense is minimize:
sense = 0
else:
sense = 1
cobj = cmodel.NLObjective(const, lin_coef, lin_vars, nonlin)
cobj.sense = sense
self._writer.objective = cobj
def write(self,
model: _BlockData,
filename: str,
timer: HierarchicalTimer = None):
if timer is None:
timer = HierarchicalTimer()
if model is not self._model:
timer.start('set_instance')
self.set_instance(model)
timer.stop('set_instance')
else:
timer.start('update')
self.update(timer=timer)
for cv, v in self._solver_var_to_pyomo_var_map.items():
if v.value is not None:
cv.value = v.value
timer.stop('update')
timer.start('write file')
self._writer.write(filename)
timer.stop('write file')
def update(self, timer: HierarchicalTimer = None):
super(NLWriter, self).update(timer=timer)
self._set_pyomo_amplfunc_env()
def get_ordered_vars(self):
return [
self._solver_var_to_pyomo_var_map[i]
for i in self._writer.get_solve_vars()
]
def get_ordered_cons(self):
return [
self._solver_con_to_pyomo_con_map[i]
for i in self._writer.get_solve_cons()
]
def get_active_objective(self):
return self._objective
def _set_pyomo_amplfunc_env(self):
if self._external_functions:
external_Libs = OrderedSet()
for con, ext_funcs in self._external_functions.items():
external_Libs.update([i._fcn._library for i in ext_funcs])
set_pyomo_amplfunc_env(external_Libs)
elif "PYOMO_AMPLFUNC" in os.environ:
del os.environ["PYOMO_AMPLFUNC"]
from pyomo.core.base import SymbolMap, NumericLabeler
from pyomo.core.base import Constraint, Objective, Var
from pyomo.core.base import expr, var
from pyomo.core.base import param
from pyomo.core.base import numvalue
from pyomo.core.base import _ExpressionData
try:
long
intlist = [int, float, long]
except:
intlist = [int, float]
logger = logging.getLogger('pyomo.core')
labeler = NumericLabeler("x")
if FD_available:
try:
tanh = FuncDesigner.tanh
arcsinh = FuncDesigner.arcsinh
arccosh = FuncDesigner.arccosh
arctanh = FuncDesigner.arctanh
except:
import FuncDesignerExt
tanh = FuncDesignerExt.tanh
arcsinh = FuncDesignerExt.arcsinh
arccosh = FuncDesignerExt.arccosh
arctanh = FuncDesignerExt.arctanh
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
# TODO
#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 = AlphaNumTextLabeler()
elif labeler is None:
labeler = NumericLabeler('x')
symbol_map = SymbolMap()
sm_bySymbol = symbol_map.bySymbol
referenced_variable_ids = set()
#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,
active=True,
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
def _skip_trivial(constraint_data):
if skip_trivial_constraints:
if isinstance(constraint_data, LinearCanonicalRepn):
if constraint_data.variables is None:
return True
else:
if constraint_data.body.polynomial_degree() == 0:
return True
return False
#
# Check for active suffixes to export
#
r_o_eqns = []
c_eqns = []
l_eqns = []
branching_priorities_suffixes = []
for block in all_blocks_list:
for name, suffix in active_export_suffix_generator(block):
if name == 'branching_priorities':
branching_priorities_suffixes.append(suffix)
elif name == 'constraint_types':
for constraint_data, constraint_type in iteritems(suffix):
if not _skip_trivial(constraint_data):
if constraint_type.lower() == 'relaxationonly':
r_o_eqns.append(constraint_data)
elif constraint_type.lower() == 'convex':
c_eqns.append(constraint_data)
elif constraint_type.lower() == 'local':
l_eqns.append(constraint_data)
else:
raise ValueError(
"A suffix '%s' contained an invalid value: %s\n"
"Choices are: [relaxationonly, convex, local]"
% (suffix.name, constraint_type))
else:
raise ValueError(
"The BARON writer can not export suffix with name '%s'. "
"Either remove it from block '%s' or deactivate it." %
(block.name, name))
non_standard_eqns = r_o_eqns + c_eqns + l_eqns
# GAH 1/5/15: Substituting all non-alphanumeric characters for underscore
# in labeler so this manual update should no longer be needed
#
# If the text labeler is used, correct the labels to be
# baron-allowed variable names
# Change '(' and ')' to '__'
# This way, for simple variable names like 'x(1_2)' --> 'x__1_2__'
# FIXME: 7/21/14 This may break if users give variable names
# with two or more underscores together
#if symbolic_solver_labels:
# for key,label in iteritems(object_symbol_dictionary):
# label = label.replace('(','___')
# object_symbol_dictionary[key] = label.replace(')','__')
#
# 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 isinstance(var_data.domain, BooleanSet):
TypeList = BinVars
elif isinstance(var_data.domain, IntegerSet):
TypeList = IntVars
elif isinstance(var_data.domain, RealSet) and \
(var_data.lb is not None) and \
(var_data.lb >= 0):
TypeList = PosVars
else:
TypeList = Vars
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 var_data.fixed:
var_data_lb = var_data.value
else:
var_data_lb = var_data.lb
if var_data_lb == -infinity:
var_data_lb = None
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 var_data.fixed:
var_data_ub = var_data.value
else:
var_data_ub = var_data.ub
if var_data_ub == infinity:
var_data_ub = None
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 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")
#
# EQUATIONS
#
#Equation Declaration
n_roeqns = len(r_o_eqns)
n_ceqns = len(c_eqns)
n_leqns = len(l_eqns)
eqns = []
# Alias the constraints by declaration order since Baron does not
# include the constraint names in the solution file. It is important
# that this alias not clash with any real constraint labels, hence
# the use of the ".c<integer>" template. It is not possible to declare
# a component having this type of name when using standard syntax.
# There are ways to do it, but it is unlikely someone will.
order_counter = 0
alias_template = ".c%d"
output_file.write('EQUATIONS ')
output_file.write("c_e_FIX_ONE_VAR_CONST__")
order_counter += 1
for block in all_blocks_list:
for constraint_data in block.component_data_objects(
Constraint, active=True, sort=sorter, descend_into=False):
if (not _skip_trivial(constraint_data)) and \
(constraint_data not in non_standard_eqns):
eqns.append(constraint_data)
con_symbol = \
create_symbol_func(symbol_map, constraint_data, labeler)
assert not con_symbol.startswith('.')
assert con_symbol != "c_e_FIX_ONE_VAR_CONST__"
alias_symbol_func(symbol_map, constraint_data,
alias_template % order_counter)
output_file.write(", " + str(con_symbol))
order_counter += 1
output_file.write(";\n\n")
if n_roeqns > 0:
output_file.write('RELAXATION_ONLY_EQUATIONS ')
for i, constraint_data in enumerate(r_o_eqns):
con_symbol = create_symbol_func(symbol_map, constraint_data,
labeler)
assert not con_symbol.startswith('.')
assert con_symbol != "c_e_FIX_ONE_VAR_CONST__"
alias_symbol_func(symbol_map, constraint_data,
alias_template % order_counter)
if i == n_roeqns - 1:
output_file.write(str(con_symbol) + ';\n\n')
else:
output_file.write(str(con_symbol) + ', ')
order_counter += 1
if n_ceqns > 0:
output_file.write('CONVEX_EQUATIONS ')
for i, constraint_data in enumerate(c_eqns):
con_symbol = create_symbol_func(symbol_map, constraint_data,
labeler)
assert not con_symbol.startswith('.')
assert con_symbol != "c_e_FIX_ONE_VAR_CONST__"
alias_symbol_func(symbol_map, constraint_data,
alias_template % order_counter)
if i == n_ceqns - 1:
output_file.write(str(con_symbol) + ';\n\n')
else:
output_file.write(str(con_symbol) + ', ')
order_counter += 1
if n_leqns > 0:
output_file.write('LOCAL_EQUATIONS ')
for i, constraint_data in enumerate(l_eqns):
con_symbol = create_symbol_func(symbol_map, constraint_data,
labeler)
assert not con_symbol.startswith('.')
assert con_symbol != "c_e_FIX_ONE_VAR_CONST__"
alias_symbol_func(symbol_map, constraint_data,
alias_template % order_counter)
if i == n_leqns - 1:
output_file.write(str(con_symbol) + ';\n\n')
else:
output_file.write(str(con_symbol) + ', ')
order_counter += 1
# Create a dictionary of baron variable names to match to the
# strings that constraint.to_string() prints. An important
# note is that the variable strings are padded by spaces so
# that whole variable names are recognized, and simple
# variable names are not identified inside longer names.
# Example: ' x[1] ' -> ' x3 '
#FIXME: 7/18/14 CLH: This may cause mistakes if spaces in
# variable names are allowed
vstring_to_bar_dict = {}
pstring_to_bar_dict = {}
for block in all_blocks_list:
for var_data in active_components_data_var[id(block)]:
variable_stream = StringIO()
var_data.to_string(ostream=variable_stream, verbose=False)
variable_string = variable_stream.getvalue()
variable_string = ' ' + variable_string + ' '
vstring_to_bar_dict[variable_string] = \
' '+object_symbol_dictionary[id(var_data)]+' '
for param in block.component_objects(Param, active=True):
if param._mutable and param.is_indexed():
param_data_iter = \
(param_data for index, param_data in iteritems(param))
elif not param.is_indexed():
param_data_iter = iter([param])
else:
param_data_iter = iter([])
for param_data in param_data_iter:
param_stream = StringIO()
param.to_string(ostream=param_stream, verbose=False)
param_string = param_stream.getvalue()
param_string = ' ' + param_string + ' '
pstring_to_bar_dict[param_string] = ' ' + str(
param_data()) + ' '
# Equation Definition
string_template = '%' + self._precision_string
output_file.write('c_e_FIX_ONE_VAR_CONST__: ONE_VAR_CONST__ == 1;\n')
for constraint_data in itertools.chain(eqns, r_o_eqns, c_eqns, l_eqns):
#########################
#CLH: The section below is kind of a hack-y way to use
# the expr.to_string function to print
# expressions. A stream is created, writen to, and
# then the string is recovered and stored in
# eqn_body. Then the variable names are converted
# to match the variable names that are used in the
# bar file.
# Fill in the body of the equation
body_string_buffer = StringIO()
constraint_data.body.to_string(ostream=body_string_buffer,
verbose=False)
eqn_body = body_string_buffer.getvalue()
# First, pad the equation so that if there is a
# variable name at the start or end of the equation,
# it can still be identified as padded with spaces.
# Second, change pyomo's ** to baron's ^, also with
# padding so that variable can always be found with
# space around them
# Third, add more padding around multiplication. Pyomo
# already has spaces between variable on variable
# multiplication, but not for constants on variables
eqn_body = ' ' + eqn_body + ' '
eqn_body = eqn_body.replace('**', ' ^ ')
eqn_body = eqn_body.replace('*', ' * ')
#
# FIXME: The following block of code is extremely inefficient.
# We are looping through every parameter and variable in
# the model each time we write a constraint expression.
#
################################################
vnames = [(variable_string, bar_string) for variable_string,
bar_string in iteritems(vstring_to_bar_dict)
if variable_string in eqn_body]
for variable_string, bar_string in vnames:
eqn_body = eqn_body.replace(variable_string, bar_string)
for param_string, bar_string in iteritems(pstring_to_bar_dict):
eqn_body = eqn_body.replace(param_string, bar_string)
referenced_variable_ids.update(
id(sm_bySymbol[bar_string.strip()]())
for variable_string, bar_string in vnames)
################################################
if len(vnames) == 0:
assert not skip_trivial_constraints
eqn_body += "+ 0 * ONE_VAR_CONST__ "
# 7/29/14 CLH:
#FIXME: Baron doesn't handle many of the
# intrinsic_functions available in pyomo. The
# error message given by baron is also very
# weak. Either a function here to re-write
# unallowed expressions or a way to track solver
# capability by intrinsic_expression would be
# useful.
##########################
con_symbol = object_symbol_dictionary[id(constraint_data)]
output_file.write(str(con_symbol) + ': ')
# Fill in the left and right hand side (constants) of
# the equations
# Equality constraint
if constraint_data.equality:
eqn_lhs = ''
eqn_rhs = ' == ' + \
str(string_template
% self._get_bound(constraint_data.upper))
# Greater than constraint
elif constraint_data.upper is None:
eqn_rhs = ' >= ' + \
str(string_template
% self._get_bound(constraint_data.lower))
eqn_lhs = ''
# Less than constraint
elif constraint_data.lower is None:
eqn_rhs = ' <= ' + \
str(string_template
% self._get_bound(constraint_data.upper))
eqn_lhs = ''
# Double-sided constraint
elif (constraint_data.upper is not None) and \
(constraint_data.lower is not None):
eqn_lhs = str(string_template
% self._get_bound(constraint_data.lower)) + \
' <= '
eqn_rhs = ' <= ' + \
str(string_template
% self._get_bound(constraint_data.upper))
eqn_string = eqn_lhs + eqn_body + eqn_rhs + ';\n'
output_file.write(eqn_string)
#
# OBJECTIVE
#
output_file.write("\nOBJ: ")
n_objs = 0
for block in all_blocks_list:
for objective_data in block.component_data_objects(
Objective, active=True, sort=sorter, descend_into=False):
n_objs += 1
if n_objs > 1:
raise ValueError(
"The BARON writer has detected multiple active "
"objective functions on model %s, but "
"currently only handles a single objective." %
(model.name))
# create symbol
create_symbol_func(symbol_map, objective_data, labeler)
alias_symbol_func(symbol_map, objective_data,
"__default_objective__")
if objective_data.is_minimizing():
output_file.write("minimize ")
else:
output_file.write("maximize ")
#FIXME 7/18/14 See above, constraint writing
# section. Will cause problems if there
# are spaces in variables
# Similar to the constraints section above, the
# objective is generated from the expr.to_string
# function.
obj_stream = StringIO()
objective_data.expr.to_string(ostream=obj_stream,
verbose=False)
obj_string = ' ' + obj_stream.getvalue() + ' '
obj_string = obj_string.replace('**', ' ^ ')
obj_string = obj_string.replace('*', ' * ')
#
# FIXME: The following block of code is extremely inefficient.
# We are looping through every parameter and variable in
# the model each time we write an expression.
#
################################################
vnames = [(variable_string, bar_string) for variable_string,
bar_string in iteritems(vstring_to_bar_dict)
if variable_string in obj_string]
for variable_string, bar_string in vnames:
obj_string = obj_string.replace(variable_string,
bar_string)
for param_string, bar_string in iteritems(pstring_to_bar_dict):
obj_string = obj_string.replace(param_string, bar_string)
referenced_variable_ids.update(
id(sm_bySymbol[bar_string.strip()]())
for variable_string, bar_string in vnames)
################################################
output_file.write(obj_string + ";\n\n")
#
# 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)]:
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 _populate_gurobi_instance(self, pyomo_instance):
from pyomo.core.base import Var, Objective, Constraint, SOSConstraint
from pyomo.repn import LinearCanonicalRepn, canonical_degree
try:
grbmodel = Model(name=pyomo_instance.name)
except Exception:
e = sys.exc_info()[1]
msg = 'Unable to create Gurobi model. Have you installed the Python'\
'\n bindings for Gurobi?\n\n\tError message: %s'
raise Exception(msg % e)
if self._symbolic_solver_labels:
labeler = TextLabeler()
else:
labeler = NumericLabeler('x')
# cache to avoid dictionary getitem calls in the loops below.
self_symbol_map = self._symbol_map = SymbolMap()
pyomo_instance.solutions.add_symbol_map(self_symbol_map)
self._smap_id = id(self_symbol_map)
# we use this when iterating over the constraints because it
# will have a much smaller hash table, we also use this for
# the warm start code after it is cleaned to only contain
# variables referenced in the constraints
self_variable_symbol_map = self._variable_symbol_map = SymbolMap()
var_symbol_pairs = []
# maps _VarData labels to the corresponding Gurobi variable object
pyomo_gurobi_variable_map = {}
self._referenced_variable_ids.clear()
# cache to avoid dictionary getitem calls in the loop below.
grb_infinity = GRB.INFINITY
for var_value in pyomo_instance.component_data_objects(Var,
active=True):
lb = -grb_infinity
ub = grb_infinity
if (var_value.lb is not None) and (var_value.lb != -infinity):
lb = value(var_value.lb)
if (var_value.ub is not None) and (var_value.ub != infinity):
ub = value(var_value.ub)
# _VarValue objects will not be in the symbol map yet, so
# avoid some checks.
var_value_label = self_symbol_map.createSymbol(var_value, labeler)
var_symbol_pairs.append((var_value, var_value_label))
# be sure to impart the integer and binary nature of any variables
if var_value.is_integer():
var_type = GRB.INTEGER
elif var_value.is_binary():
var_type = GRB.BINARY
elif var_value.is_continuous():
var_type = GRB.CONTINUOUS
else:
raise TypeError(
"Invalid domain type for variable with name '%s'. "
"Variable is not continuous, integer, or binary.")
pyomo_gurobi_variable_map[var_value_label] = \
grbmodel.addVar(lb=lb, \
ub=ub, \
vtype=var_type, \
name=var_value_label)
self_variable_symbol_map.addSymbols(var_symbol_pairs)
grbmodel.update()
# The next loop collects the following component types from the model:
# - SOSConstraint
# - Objective
# - Constraint
sos1 = self._capabilities.sos1
sos2 = self._capabilities.sos2
modelSOS = ModelSOS()
objective_cntr = 0
# Track the range constraints and their associated variables added by gurobi
self._last_native_var_idx = grbmodel.NumVars - 1
range_var_idx = grbmodel.NumVars
_self_range_con_var_pairs = self._range_con_var_pairs = []
for block in pyomo_instance.block_data_objects(active=True):
gen_obj_canonical_repn = \
getattr(block, "_gen_obj_canonical_repn", True)
gen_con_canonical_repn = \
getattr(block, "_gen_con_canonical_repn", True)
# Get/Create the ComponentMap for the repn
if not hasattr(block, '_canonical_repn'):
block._canonical_repn = ComponentMap()
block_canonical_repn = block._canonical_repn
# SOSConstraints
for soscondata in block.component_data_objects(SOSConstraint,
active=True,
descend_into=False):
level = soscondata.level
if (level == 1 and not sos1) or \
(level == 2 and not sos2) or \
(level > 2):
raise RuntimeError(
"Solver does not support SOS level %s constraints" %
(level, ))
modelSOS.count_constraint(self_symbol_map, labeler,
self_variable_symbol_map,
pyomo_gurobi_variable_map,
soscondata)
# Objective
for obj_data in block.component_data_objects(Objective,
active=True,
descend_into=False):
if objective_cntr > 1:
raise ValueError(
"Multiple active objectives found on Pyomo instance '%s'. "
"Solver '%s' will only handle a single active objective" \
% (pyomo_instance.cname(True), self.type))
sense = GRB_MIN if (obj_data.is_minimizing()) else GRB_MAX
grbmodel.ModelSense = sense
obj_expr = LinExpr()
if gen_obj_canonical_repn:
obj_repn = generate_canonical_repn(obj_data.expr)
block_canonical_repn[obj_data] = obj_repn
else:
obj_repn = block_canonical_repn[obj_data]
if isinstance(obj_repn, LinearCanonicalRepn):
if obj_repn.constant != None:
obj_expr.addConstant(obj_repn.constant)
if obj_repn.linear != None:
for i in xrange(len(obj_repn.linear)):
var_coefficient = obj_repn.linear[i]
var_value = obj_repn.variables[i]
self._referenced_variable_ids.add(id(var_value))
label = self_variable_symbol_map.getSymbol(
var_value)
obj_expr.addTerms(var_coefficient,
pyomo_gurobi_variable_map[label])
else:
if 0 in obj_repn: # constant term
obj_expr.addConstant(obj_repn[0][None])
if 1 in obj_repn: # first-order terms
hash_to_variable_map = obj_repn[-1]
for var_hash, var_coefficient in iteritems(
obj_repn[1]):
vardata = hash_to_variable_map[var_hash]
self._referenced_variable_ids.add(id(vardata))
label = self_variable_symbol_map.getSymbol(vardata)
obj_expr.addTerms(var_coefficient,
pyomo_gurobi_variable_map[label])
if 2 in obj_repn:
obj_expr = QuadExpr(obj_expr)
hash_to_variable_map = obj_repn[-1]
for quad_repn, coef in iteritems(obj_repn[2]):
gurobi_expr = QuadExpr(coef)
for var_hash, exponent in iteritems(quad_repn):
vardata = hash_to_variable_map[var_hash]
self._referenced_variable_ids.add(id(vardata))
gurobi_var = pyomo_gurobi_variable_map\
[self_variable_symbol_map.\
getSymbol(vardata)]
gurobi_expr *= gurobi_var
if exponent == 2:
gurobi_expr *= gurobi_var
obj_expr += gurobi_expr
degree = canonical_degree(obj_repn)
if (degree is None) or (degree > 2):
raise ValueError(
"gurobi_direct plugin does not support general nonlinear "
"objective expressions (only linear or quadratic).\n"
"Objective: %s" % (obj_data.cname(True)))
# need to cache the objective label, because the
# GUROBI python interface doesn't track this.
# _ObjectiveData objects will not be in the symbol map
# yet, so avoid some checks.
self._objective_label = \
self_symbol_map.createSymbol(obj_data, labeler)
grbmodel.setObjective(obj_expr, sense=sense)
# Constraint
for constraint_data in block.component_data_objects(
Constraint, active=True, descend_into=False):
if (constraint_data.lower is None) and \
(constraint_data.upper is None):
continue # not binding at all, don't bother
con_repn = None
if isinstance(constraint_data, LinearCanonicalRepn):
con_repn = constraint_data
else:
if gen_con_canonical_repn:
con_repn = generate_canonical_repn(
constraint_data.body)
block_canonical_repn[constraint_data] = con_repn
else:
con_repn = block_canonical_repn[constraint_data]
offset = 0.0
# _ConstraintData objects will not be in the symbol
# map yet, so avoid some checks.
constraint_label = \
self_symbol_map.createSymbol(constraint_data, labeler)
trivial = False
if isinstance(con_repn, LinearCanonicalRepn):
#
# optimization (these might be generated on the fly)
#
constant = con_repn.constant
coefficients = con_repn.linear
variables = con_repn.variables
if constant is not None:
offset = constant
expr = LinExpr() + offset
if coefficients is not None:
linear_coefs = list()
linear_vars = list()
for i in xrange(len(coefficients)):
var_coefficient = coefficients[i]
var_value = variables[i]
self._referenced_variable_ids.add(id(var_value))
label = self_variable_symbol_map.getSymbol(
var_value)
linear_coefs.append(var_coefficient)
linear_vars.append(
pyomo_gurobi_variable_map[label])
expr += LinExpr(linear_coefs, linear_vars)
else:
trivial = True
else:
if 0 in con_repn:
offset = con_repn[0][None]
expr = LinExpr() + offset
if 1 in con_repn: # first-order terms
linear_coefs = list()
linear_vars = list()
hash_to_variable_map = con_repn[-1]
for var_hash, var_coefficient in iteritems(
con_repn[1]):
var = hash_to_variable_map[var_hash]
self._referenced_variable_ids.add(id(var))
label = self_variable_symbol_map.getSymbol(var)
linear_coefs.append(var_coefficient)
linear_vars.append(
pyomo_gurobi_variable_map[label])
expr += LinExpr(linear_coefs, linear_vars)
if 2 in con_repn: # quadratic constraint
if _GUROBI_VERSION_MAJOR < 5:
raise ValueError(
"The gurobi_direct plugin does not handle quadratic "
"constraint expressions for Gurobi major versions "
"< 5. Current version: Gurobi %s.%s%s" %
(gurobi.version()))
expr = QuadExpr(expr)
hash_to_variable_map = con_repn[-1]
for quad_repn, coef in iteritems(con_repn[2]):
gurobi_expr = QuadExpr(coef)
for var_hash, exponent in iteritems(quad_repn):
vardata = hash_to_variable_map[var_hash]
self._referenced_variable_ids.add(id(vardata))
gurobi_var = pyomo_gurobi_variable_map\
[self_variable_symbol_map.\
getSymbol(vardata)]
gurobi_expr *= gurobi_var
if exponent == 2:
gurobi_expr *= gurobi_var
expr += gurobi_expr
degree = canonical_degree(con_repn)
if (degree is None) or (degree > 2):
raise ValueError(
"gurobi_direct plugin does not support general nonlinear "
"constraint expressions (only linear or quadratic).\n"
"Constraint: %s" % (constraint_data.cname(True)))
if (not trivial) or (not self._skip_trivial_constraints):
if constraint_data.equality:
sense = GRB.EQUAL
bound = self._get_bound(constraint_data.lower)
grbmodel.addConstr(lhs=expr,
sense=sense,
rhs=bound,
name=constraint_label)
else:
# L <= body <= U
if (constraint_data.upper is not None) and \
(constraint_data.lower is not None):
grb_con = grbmodel.addRange(
expr, self._get_bound(constraint_data.lower),
self._get_bound(constraint_data.upper),
constraint_label)
_self_range_con_var_pairs.append(
(grb_con, range_var_idx))
range_var_idx += 1
# body <= U
elif constraint_data.upper is not None:
bound = self._get_bound(constraint_data.upper)
if bound < float('inf'):
grbmodel.addConstr(lhs=expr,
sense=GRB.LESS_EQUAL,
rhs=bound,
name=constraint_label)
# L <= body
else:
bound = self._get_bound(constraint_data.lower)
if bound > -float('inf'):
grbmodel.addConstr(lhs=expr,
sense=GRB.GREATER_EQUAL,
rhs=bound,
name=constraint_label)
if modelSOS.sosType:
for key in modelSOS.sosType:
grbmodel.addSOS(modelSOS.sosType[key], \
modelSOS.varnames[key], \
modelSOS.weights[key] )
self._referenced_variable_ids.update(modelSOS.varids[key])
for var_id in self._referenced_variable_ids:
varname = self._variable_symbol_map.byObject[var_id]
vardata = self._variable_symbol_map.bySymbol[varname]()
if vardata.fixed:
if not self._output_fixed_variable_bounds:
raise ValueError(
"Encountered a fixed variable (%s) inside an active objective "
"or constraint expression on model %s, which is usually indicative of "
"a preprocessing error. Use the IO-option 'output_fixed_variable_bounds=True' "
"to suppress this error and fix the variable by overwriting its bounds in "
"the Gurobi instance." % (
vardata.cname(True),
pyomo_instance.cname(True),
))
grbvar = pyomo_gurobi_variable_map[varname]
grbvar.setAttr(GRB.Attr.UB, vardata.value)
grbvar.setAttr(GRB.Attr.LB, vardata.value)
grbmodel.update()
self._gurobi_instance = grbmodel
self._pyomo_gurobi_variable_map = pyomo_gurobi_variable_map
def _convert_external_setup_without_cleanup(worker, scenario, output_directory,
firststage_var_suffix,
enforce_derived_nonanticipativity,
io_options):
import pyomo.environ
assert os.path.exists(output_directory)
io_options = dict(io_options)
scenario_tree = worker.scenario_tree
reference_model = scenario._instance
rootnode = scenario_tree.findRootNode()
firststage = scenario_tree.stages[0]
secondstage = scenario_tree.stages[1]
constraint_name_buffer = {}
objective_name_buffer = {}
variable_name_buffer = {}
all_constraints = list(con
for con in reference_model.component_data_objects(
Constraint, active=True, descend_into=True))
#
# Check for model annotations
#
stochastic_rhs = locate_annotations(reference_model,
StochasticConstraintBoundsAnnotation,
max_allowed=1)
if len(stochastic_rhs) == 0:
stochastic_rhs = None
stochastic_rhs_entries = {}
empty_rhs_annotation = False
else:
assert len(stochastic_rhs) == 1
stochastic_rhs = stochastic_rhs[0][1]
if stochastic_rhs.has_declarations:
empty_rhs_annotation = False
stochastic_rhs_entries = stochastic_rhs.expand_entries()
stochastic_rhs_entries.sort(
key=lambda x: x[0].getname(True, constraint_name_buffer))
if len(stochastic_rhs_entries) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Constraint "
"objects were recovered from those entries." %
(StochasticConstraintBoundsAnnotation.__name__))
else:
empty_rhs_annotation = True
stochastic_rhs_entries = tuple(
(con, stochastic_rhs.default) for con in all_constraints)
stochastic_matrix = locate_annotations(reference_model,
StochasticConstraintBodyAnnotation,
max_allowed=1)
if len(stochastic_matrix) == 0:
stochastic_matrix = None
stochastic_matrix_entries = {}
empty_matrix_annotation = False
else:
assert len(stochastic_matrix) == 1
stochastic_matrix = stochastic_matrix[0][1]
if stochastic_matrix.has_declarations:
empty_matrix_annotation = False
stochastic_matrix_entries = stochastic_matrix.expand_entries()
stochastic_matrix_entries.sort(
key=lambda x: x[0].getname(True, constraint_name_buffer))
if len(stochastic_matrix_entries) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Constraint "
"objects were recovered from those entries." %
(StochasticConstraintBoundsAnnotation.__name__))
else:
empty_matrix_annotation = True
stochastic_matrix_entries = tuple(
(con, stochastic_matrix.default) for con in all_constraints)
stochastic_constraint_ids = set()
stochastic_constraint_ids.update(
id(con) for con, _ in stochastic_rhs_entries)
stochastic_constraint_ids.update(
id(con) for con, _ in stochastic_matrix_entries)
stochastic_objective = locate_annotations(reference_model,
StochasticObjectiveAnnotation,
max_allowed=1)
if len(stochastic_objective) == 0:
stochastic_objective = None
else:
assert len(stochastic_objective) == 1
stochastic_objective = stochastic_objective[0][1]
stochastic_varbounds = locate_annotations(
reference_model, StochasticVariableBoundsAnnotation)
if len(stochastic_varbounds) > 0:
raise ValueError(
"The DDSIP writer does not currently support "
"stochastic variable bounds. Invalid annotation type: %s" %
(StochasticVariableBoundsAnnotation.__name__))
if (stochastic_rhs is None) and \
(stochastic_matrix is None) and \
(stochastic_objective is None):
raise RuntimeError("No stochastic annotations found. DDSIP "
"conversion requires at least one of the following "
"annotation types:\n - %s\n - %s\n - %s" %
(StochasticConstraintBoundsAnnotation.__name__,
StochasticConstraintBodyAnnotation.__name__,
StochasticObjectiveAnnotation.__name__))
assert not hasattr(reference_model, "_repn")
repn_cache = build_repns(reference_model)
assert hasattr(reference_model, "_repn")
assert not reference_model._gen_obj_repn
assert not reference_model._gen_con_repn
# compute values
for block_repns in repn_cache.values():
for repn in block_repns.values():
repn.constant = value(repn.constant)
repn.linear_coefs = [value(c) for c in repn.linear_coefs]
repn.quadratic_coefs = [value(c) for c in repn.quadratic_coefs]
#
# Write the LP file once to obtain the symbol map
#
output_filename = os.path.join(output_directory,
scenario.name + ".lp.setup")
with WriterFactory("lp") as writer:
assert 'column_order' not in io_options
assert 'row_order' not in io_options
output_fname, symbol_map = writer(reference_model, output_filename,
lambda x: True, io_options)
assert output_fname == output_filename
_safe_remove_file(output_filename)
StageToVariableMap = map_variable_stages(
scenario,
scenario_tree,
symbol_map,
enforce_derived_nonanticipativity=enforce_derived_nonanticipativity)
firststage_variable_ids = \
set(id(var) for symbol, var, scenario_tree_id
in StageToVariableMap[firststage.name])
secondstage_variable_ids = \
set(id(var) for symbol, var, scenario_tree_id
in StageToVariableMap[secondstage.name])
StageToConstraintMap = \
map_constraint_stages(
scenario,
scenario_tree,
symbol_map,
stochastic_constraint_ids,
firststage_variable_ids,
secondstage_variable_ids)
secondstage_constraint_ids = \
set(id(con) for symbols, con
in StageToConstraintMap[secondstage.name])
assert len(scenario_tree.stages) == 2
firststage = scenario_tree.stages[0]
secondstage = scenario_tree.stages[1]
#
# Make sure the objective references all first stage variables.
# We do this by directly modifying the _repn of the
# objective which the LP/MPS writer will reference next time we call
# it. In addition, make sure that the first second-stage variable
# in our column ordering also appears in the objective so that
# ONE_VAR_CONSTANT does not get identified as the first
# second-stage variable.
# ** Just do NOT preprocess again until we call the writer **
#
objective_object = scenario._instance_objective
assert objective_object is not None
objective_block = objective_object.parent_block()
objective_repn = repn_cache[id(objective_block)][objective_object]
#
# Create column (variable) ordering maps for LP/MPS files
#
column_order = ComponentMap()
firststage_variable_count = 0
secondstage_variable_count = 0
# first-stage variables
for column_index, (symbol, var, scenario_tree_id) \
in enumerate(StageToVariableMap[firststage.name]):
column_order[var] = column_index
firststage_variable_count += 1
# second-stage variables
for column_index, (symbol, var, scenario_tree_id) \
in enumerate(StageToVariableMap[secondstage.name],
len(column_order)):
column_order[var] = column_index
secondstage_variable_count += 1
# account for the ONE_VAR_CONSTANT second-stage variable
# added by the LP writer
secondstage_variable_count += 1
#
# Create row (constraint) ordering maps for LP/MPS files
#
firststage_constraint_count = 0
secondstage_constraint_count = 0
row_order = ComponentMap()
# first-stage constraints
for row_index, (symbols, con) \
in enumerate(StageToConstraintMap[firststage.name]):
row_order[con] = row_index
firststage_constraint_count += len(symbols)
# second-stage constraints
for row_index, (symbols, con) \
in enumerate(StageToConstraintMap[secondstage.name],
len(row_order)):
row_order[con] = row_index
secondstage_constraint_count += len(symbols)
# account for the ONE_VAR_CONSTANT = 1 second-stage constraint
# added by the LP writer
secondstage_constraint_count += 1
#
# Create a custom labeler that allows DDSIP to identify
# first-stage variables
#
if io_options.pop('symbolic_solver_labels', False):
_labeler = TextLabeler()
else:
_labeler = NumericLabeler('x')
labeler = lambda x: _labeler(x) + \
(""
if ((not isinstance(x, _VarData)) or \
(id(x) not in firststage_variable_ids)) else \
firststage_var_suffix)
#
# Write the ordered LP/MPS file
#
output_filename = os.path.join(output_directory, scenario.name + ".lp")
symbols_filename = os.path.join(output_directory,
scenario.name + ".lp.symbols")
with WriterFactory("lp") as writer:
assert 'column_order' not in io_options
assert 'row_order' not in io_options
assert 'labeler' not in io_options
assert 'force_objective_constant' not in io_options
io_options['column_order'] = column_order
io_options['row_order'] = row_order
io_options['force_objective_constant'] = True
io_options['labeler'] = labeler
output_fname, symbol_map = writer(reference_model, output_filename,
lambda x: True, io_options)
assert output_fname == output_filename
# write the lp file symbol paired with the scenario
# tree id for each variable in the root node
with open(symbols_filename, "w") as f:
st_symbol_map = reference_model._ScenarioTreeSymbolMap
lines = []
for id_ in sorted(rootnode._variable_ids):
var = st_symbol_map.bySymbol[id_]
if not var.is_expression_type():
lp_label = symbol_map.byObject[id(var)]
lines.append("%s %s\n" % (lp_label, id_))
f.writelines(lines)
# re-generate these maps as the LP/MPS symbol map
# is likely different
StageToVariableMap = map_variable_stages(
scenario,
scenario_tree,
symbol_map,
enforce_derived_nonanticipativity=enforce_derived_nonanticipativity)
StageToConstraintMap = map_constraint_stages(scenario, scenario_tree,
symbol_map,
stochastic_constraint_ids,
firststage_variable_ids,
secondstage_variable_ids)
# generate a few data structures that are used
# when writing the .sc files
constraint_symbols = ComponentMap(
(con, symbols) for stage_name in StageToConstraintMap
for symbols, con in StageToConstraintMap[stage_name])
#
# Write the body of the .sc files
#
modified_constraint_lb = ComponentMap()
modified_constraint_ub = ComponentMap()
#
# Stochastic RHS
#
# **NOTE: In the code that follows we assume the LP
# writer always moves constraint body
# constants to the rhs and that the lower part
# of any range constraints are written before
# the upper part.
#
stochastic_rhs_count = 0
with open(os.path.join(output_directory, scenario.name + ".rhs.sc.struct"),
'w') as f_rhs_struct:
with open(os.path.join(output_directory, scenario.name + ".rhs.sc"),
'w') as f_rhs:
scenario_probability = scenario.probability
rhs_struct_template = " %s\n"
rhs_template = " %.17g\n"
f_rhs.write("scen\n%.17g\n" %
(_no_negative_zero(scenario_probability)))
if stochastic_rhs is not None:
for con, include_bound in stochastic_rhs_entries:
assert isinstance(con, _ConstraintData)
if not empty_rhs_annotation:
# verify that this constraint was
# flagged by PySP or the user as second-stage
if id(con) not in secondstage_constraint_ids:
raise RuntimeError(
"The constraint %s has been declared "
"in the %s annotation but it was not identified as "
"a second-stage constraint. To correct this issue, "
"remove the constraint from this annotation." %
(con.name,
StochasticConstraintBoundsAnnotation.__name__)
)
constraint_repn = \
repn_cache[id(con.parent_block())][con]
if not constraint_repn.is_linear():
raise RuntimeError(
"Only linear constraints are "
"accepted for conversion to DDSIP format. "
"Constraint %s is not linear." % (con.name))
body_constant = constraint_repn.constant
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
constraint_repn.constant = 0
if body_constant is None:
body_constant = 0.0
symbols = constraint_symbols[con]
assert len(symbols) > 0
for con_label in symbols:
if con_label.startswith('c_e_') or \
con_label.startswith('c_l_'):
assert (include_bound is True) or \
(include_bound[0] is True)
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template %
(con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.lower) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_lb[con] = con.lower
con._lower = _deterministic_check_constant
if con_label.startswith('c_e_'):
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
elif con_label.startswith('r_l_'):
if (include_bound is True) or \
(include_bound[0] is True):
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template %
(con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.lower) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_lb[con] = con.lower
con._lower = _deterministic_check_constant
elif con_label.startswith('c_u_'):
assert (include_bound is True) or \
(include_bound[1] is True)
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template %
(con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.upper) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
elif con_label.startswith('r_u_'):
if (include_bound is True) or \
(include_bound[1] is True):
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template %
(con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.upper) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
else:
assert False
#
# Stochastic Matrix
#
stochastic_matrix_count = 0
with open(
os.path.join(output_directory,
scenario.name + ".matrix.sc.struct"),
'w') as f_mat_struct:
with open(os.path.join(output_directory, scenario.name + ".matrix.sc"),
'w') as f_mat:
scenario_probability = scenario.probability
matrix_struct_template = " %s %s\n"
matrix_template = " %.17g\n"
f_mat.write("scen\n")
if stochastic_matrix is not None:
for con, var_list in stochastic_matrix_entries:
assert isinstance(con, _ConstraintData)
if not empty_matrix_annotation:
# verify that this constraint was
# flagged by PySP or the user as second-stage
if id(con) not in secondstage_constraint_ids:
raise RuntimeError(
"The constraint %s has been declared "
"in the %s annotation but it was not identified as "
"a second-stage constraint. To correct this issue, "
"remove the constraint from this annotation." %
(con.name,
StochasticConstraintBodyAnnotation.__name__))
constraint_repn = \
repn_cache[id(con.parent_block())][con]
if not constraint_repn.is_linear():
raise RuntimeError(
"Only linear constraints are "
"accepted for conversion to DDSIP format. "
"Constraint %s is not linear." % (con.name))
assert len(constraint_repn.linear_vars) > 0
if var_list is None:
var_list = constraint_repn.linear_vars
assert len(var_list) > 0
symbols = constraint_symbols[con]
# sort the variable list by the column ordering
# so that we have deterministic output
var_list = list(var_list)
var_list.sort(key=lambda _v: column_order[_v])
new_coefs = list(constraint_repn.linear_coefs)
for var in var_list:
assert isinstance(var, _VarData)
assert not var.fixed
var_coef = None
for i, (_var, coef) in enumerate(
zip(constraint_repn.linear_vars,
constraint_repn.linear_coefs)):
if _var is var:
var_coef = coef
# We are going to rewrite with core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
new_coefs[i] = _deterministic_check_value
break
if var_coef is None:
raise RuntimeError(
"The coefficient for variable %s has "
"been marked as stochastic in constraint %s using "
"the %s annotation, but the variable does not appear"
" in the canonical constraint expression." %
(var.name, con.name,
StochasticConstraintBodyAnnotation.__name__))
var_label = symbol_map.byObject[id(var)]
for con_label in symbols:
stochastic_matrix_count += 1
f_mat_struct.write(matrix_struct_template %
(con_label, var_label))
f_mat.write(matrix_template %
(_no_negative_zero(value(var_coef))))
constraint_repn.linear_coefs = tuple(new_coefs)
#
# Stochastic Objective
#
stochastic_cost_count = 0
with open(
os.path.join(output_directory, scenario.name + ".cost.sc.struct"),
'w') as f_obj_struct:
with open(os.path.join(output_directory, scenario.name + ".cost.sc"),
'w') as f_obj:
obj_struct_template = " %s\n"
obj_template = " %.17g\n"
f_obj.write("scen\n")
if stochastic_objective is not None:
if stochastic_objective.has_declarations:
sorted_values = stochastic_objective.expand_entries()
assert len(sorted_values) <= 1
if len(sorted_values) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Objective "
"objects were recovered from those entries." %
(StochasticObjectiveAnnotation.__name__))
obj, (objective_variables, include_constant) = \
sorted_values[0]
assert obj is objective_object
else:
objective_variables, include_constant = \
stochastic_objective.default
if not objective_repn.is_linear():
raise RuntimeError(
"Only linear stochastic objectives are "
"accepted for conversion to DDSIP format. "
"Objective %s is not linear." %
(objective_object.name))
if objective_variables is None:
objective_variables = objective_repn.linear_vars
stochastic_objective_label = symbol_map.byObject[id(
objective_object)]
# sort the variable list by the column ordering
# so that we have deterministic output
objective_variables = list(objective_variables)
objective_variables.sort(key=lambda _v: column_order[_v])
assert (len(objective_variables) > 0) or include_constant
new_coefs = list(objective_repn.linear_coefs)
for var in objective_variables:
assert isinstance(var, _VarData)
var_coef = None
for i, (_var, coef) in enumerate(
zip(objective_repn.linear_vars,
objective_repn.linear_coefs)):
if _var is var:
var_coef = coef
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
new_coefs[i] = _deterministic_check_value
break
if var_coef is None:
raise RuntimeError(
"The coefficient for variable %s has "
"been marked as stochastic in objective %s using "
"the %s annotation, but the variable does not appear"
" in the canonical objective expression." %
(var.name, objective_object.name,
StochasticObjectiveAnnotation.__name__))
var_label = symbol_map.byObject[id(var)]
stochastic_cost_count += 1
f_obj_struct.write(obj_struct_template % (var_label))
f_obj.write(obj_template %
(_no_negative_zero(value(var_coef))))
objective_repn.linear_coefs = tuple(new_coefs)
if include_constant:
obj_constant = objective_repn.constant
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
objective_repn.constant = _deterministic_check_value
if obj_constant is None:
obj_constant = 0.0
stochastic_cost_count += 1
f_obj_struct.write(obj_struct_template %
("ONE_VAR_CONSTANT"))
f_obj.write(obj_template %
(_no_negative_zero(obj_constant)))
#
# Write the deterministic part of the LP/MPS-file to its own
# file for debugging purposes
#
reference_model_name = reference_model.name
reference_model._name = "ZeroStochasticData"
det_output_filename = os.path.join(output_directory,
scenario.name + ".lp.det")
with WriterFactory("lp") as writer:
output_fname, symbol_map = writer(reference_model, det_output_filename,
lambda x: True, io_options)
assert output_fname == det_output_filename
reference_model._name = reference_model_name
# reset bounds on any constraints that were modified
for con, lower in iteritems(modified_constraint_lb):
con._lower = as_numeric(lower)
for con, upper in iteritems(modified_constraint_ub):
con._upper = as_numeric(upper)
return (firststage_variable_count, secondstage_variable_count,
firststage_constraint_count, secondstage_constraint_count,
stochastic_cost_count, stochastic_rhs_count,
stochastic_matrix_count)
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
class LPWriter(PersistentBase):
def __init__(self):
super(LPWriter, self).__init__()
self._config = WriterConfig()
self._writer = None
self._symbol_map = SymbolMap()
self._var_labeler = None
self._con_labeler = None
self._param_labeler = None
self._obj_labeler = None
self._pyomo_var_to_solver_var_map = dict()
self._pyomo_con_to_solver_con_map = dict()
self._solver_var_to_pyomo_var_map = dict()
self._solver_con_to_pyomo_con_map = dict()
self._pyomo_param_to_solver_param_map = dict()
self._expr_types = None
@property
def config(self):
return self._config
@config.setter
def config(self, val: WriterConfig):
self._config = val
def set_instance(self, model):
saved_config = self.config
saved_update_config = self.update_config
self.__init__()
self.config = saved_config
self.update_config = saved_update_config
self._model = model
self._expr_types = cmodel.PyomoExprTypes()
if self.config.symbolic_solver_labels:
self._var_labeler = TextLabeler()
self._con_labeler = TextLabeler()
self._param_labeler = TextLabeler()
self._obj_labeler = TextLabeler()
else:
self._var_labeler = NumericLabeler('x')
self._con_labeler = NumericLabeler('c')
self._param_labeler = NumericLabeler('p')
self._obj_labeler = NumericLabeler('obj')
self._writer = cmodel.LPWriter()
self.add_block(model)
if self._objective is None:
self.set_objective(None)
def _add_variables(self, variables: List[_GeneralVarData]):
cmodel.process_pyomo_vars(self._expr_types, variables, self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map, self._vars,
self._solver_var_to_pyomo_var_map, True, self._symbol_map,
self._var_labeler, False)
def _add_params(self, params: List[_ParamData]):
cparams = cmodel.create_params(len(params))
for ndx, p in enumerate(params):
cp = cparams[ndx]
cp.name = self._symbol_map.getSymbol(p, self._param_labeler)
cp.value = p.value
self._pyomo_param_to_solver_param_map[id(p)] = cp
def _add_constraints(self, cons: List[_GeneralConstraintData]):
cmodel.process_lp_constraints(cons, self)
def _add_sos_constraints(self, cons: List[_SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError('LP writer does not yet support SOS constraints')
def _remove_constraints(self, cons: List[_GeneralConstraintData]):
for c in cons:
cc = self._pyomo_con_to_solver_con_map.pop(c)
self._writer.remove_constraint(cc)
self._symbol_map.removeSymbol(c)
self._con_labeler.remove_obj(c)
del self._solver_con_to_pyomo_con_map[cc]
def _remove_sos_constraints(self, cons: List[_SOSConstraintData]):
if len(cons) != 0:
raise NotImplementedError('LP writer does not yet support SOS constraints')
def _remove_variables(self, variables: List[_GeneralVarData]):
for v in variables:
cvar = self._pyomo_var_to_solver_var_map.pop(id(v))
del self._solver_var_to_pyomo_var_map[cvar]
self._symbol_map.removeSymbol(v)
self._var_labeler.remove_obj(v)
def _remove_params(self, params: List[_ParamData]):
for p in params:
del self._pyomo_param_to_solver_param_map[id(p)]
self._symbol_map.removeSymbol(p)
self._param_labeler.remove_obj(p)
def _update_variables(self, variables: List[_GeneralVarData]):
cmodel.process_pyomo_vars(self._expr_types, variables, self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map, self._vars,
self._solver_var_to_pyomo_var_map, False, None,
None, True)
def update_params(self):
for p_id, p in self._params.items():
cp = self._pyomo_param_to_solver_param_map[p_id]
cp.value = p.value
def _set_objective(self, obj: _GeneralObjectiveData):
cobj = cmodel.process_lp_objective(self._expr_types, obj, self._pyomo_var_to_solver_var_map,
self._pyomo_param_to_solver_param_map)
if obj is None:
sense = 0
cname = 'objective'
else:
cname = self._symbol_map.getSymbol(obj, self._obj_labeler)
if obj.sense is minimize:
sense = 0
else:
sense = 1
cobj.sense = sense
cobj.name = cname
self._writer.objective = cobj
def write(self, model: _BlockData, filename: str, timer: HierarchicalTimer = None):
if timer is None:
timer = HierarchicalTimer()
if model is not self._model:
timer.start('set_instance')
self.set_instance(model)
timer.stop('set_instance')
else:
timer.start('update')
self.update(timer=timer)
timer.stop('update')
timer.start('write file')
self._writer.write(filename)
timer.stop('write file')
def get_vars(self):
return [self._solver_var_to_pyomo_var_map[i] for i in self._writer.get_solve_vars()]
def get_ordered_cons(self):
return [self._solver_con_to_pyomo_con_map[i] for i in self._writer.get_solve_cons()]
def get_active_objective(self):
return self._objective
@property
def symbol_map(self):
return self._symbol_map
