def test_nested_blocks(self):
"""Test with nested blocks."""
m = ConcreteModel()
m.b = Block()
m.inactive_b = Block()
m.inactive_b.deactivate()
m.b.x = Var()
m.b.x2 = Var(domain=Binary)
m.b.x3 = Var(domain=Integers)
m.inactive_b.x = Var()
m.b.c = Constraint(expr=m.b.x == m.b.x2)
m.inactive_b.c = Constraint(expr=m.b.x == 1)
m.inactive_b.c2 = Constraint(expr=m.inactive_b.x == 15)
model_size = build_model_size_report(m)
self.assertEqual(model_size.activated.variables, 2)
self.assertEqual(model_size.overall.variables, 4)
self.assertEqual(model_size.activated.binary_variables, 1)
self.assertEqual(model_size.overall.binary_variables, 1)
self.assertEqual(model_size.activated.integer_variables, 0)
self.assertEqual(model_size.overall.integer_variables, 1)
self.assertEqual(model_size.activated.constraints, 1)
self.assertEqual(model_size.overall.constraints, 3)
self.assertEqual(model_size.activated.disjuncts, 0)
self.assertEqual(model_size.overall.disjuncts, 0)
self.assertEqual(model_size.activated.disjunctions, 0)
self.assertEqual(model_size.overall.disjunctions, 0)
def setup_results_object(solve_data, config):
"""Record problem statistics for original model."""
# Create the solver results object
res = solve_data.results
prob = res.problem
res.problem.name = solve_data.original_model.name
res.problem.number_of_nonzeros = None # TODO
# TODO work on termination condition and message
res.solver.termination_condition = None
res.solver.message = None
res.solver.user_time = None
res.solver.system_time = None
res.solver.wallclock_time = None
res.solver.termination_message = None
num_of = build_model_size_report(solve_data.original_model)
# Get count of constraints and variables
prob.number_of_constraints = num_of.activated.constraints
prob.number_of_disjunctions = num_of.activated.disjunctions
prob.number_of_variables = num_of.activated.variables
prob.number_of_binary_variables = num_of.activated.binary_variables
prob.number_of_continuous_variables = num_of.activated.continuous_variables
prob.number_of_integer_variables = num_of.activated.integer_variables
config.logger.info(
"Original model has %s constraints (%s nonlinear) "
"and %s disjunctions, "
"with %s variables, of which %s are binary, %s are integer, "
"and %s are continuous." %
(num_of.activated.constraints, num_of.activated.nonlinear_constraints,
num_of.activated.disjunctions, num_of.activated.variables,
num_of.activated.binary_variables, num_of.activated.integer_variables,
num_of.activated.continuous_variables))
def test_nine_process(self):
"""Test with the nine process problem model."""
exfile = import_file(join(exdir, 'nine_process', 'small_process.py'))
simple_model = exfile.build_model()
simple_model_size = build_model_size_report(simple_model)
self.assertEqual(simple_model_size.overall.variables, 34)
self.assertEqual(simple_model_size.activated.variables, 34)
def compute_model_stats():
models_loaded_from_cache = _load_from_model_stats_cache()
_failed_model_names = []
for test_model in models.values():
if test_model.name in models_loaded_from_cache:
continue
build_start_time = monotonic()
try:
pyomo_model = test_model.build_function()
except Exception as err:
print(
f"Failed to build {test_model.name} due to exception: {err}.")
print("Temporarily removing model from library.")
_failed_model_names.append(test_model.name)
continue
build_end_time = monotonic()
test_model.build_time = int(ceil(build_end_time - build_start_time))
size_report = build_model_size_report(pyomo_model)
# update test_model object with information from model size report
test_model.update(size_report.activated)
if test_model.model_type is None:
test_model.model_type = _infer_model_type(test_model)
# Determine objective sense
active_obj = next(
pyomo_model.component_data_objects(pyo.Objective, active=True))
test_model.objective_sense = 'minimize' if active_obj.sense == pyo.minimize else 'maximize'
for failed_model in _failed_model_names:
del models[failed_model]
# Cache the model stats
_cache_model_stats()
def test_deactivated_variables(self):
m = ConcreteModel()
m.x = Var()
m.y = Var()
m.c = Constraint(expr=m.x >= 1)
m.c2 = Constraint(expr=m.y <= 6)
m.c2.deactivate()
model_size = build_model_size_report(m)
self.assertEqual(model_size.activated.variables, 1)
self.assertEqual(model_size.overall.variables, 2)
def test_unassociated_disjunct(self):
m = ConcreteModel()
m.x = Var(domain=Integers)
m.d = Disjunct()
m.d.c = Constraint(expr=m.x == 1)
m.d2 = Disjunct()
m.d2.c = Constraint(expr=m.x == 5)
m.disj = Disjunction(expr=[m.d2])
model_size = build_model_size_report(m)
self.assertEqual(model_size.warning.unassociated_disjuncts, 1)
def test_nonlinear(self):
"""Test nonlinear constraint detection."""
m = ConcreteModel()
m.x = Var()
m.y = Var()
m.z = Var()
m.z.fix(3)
m.c = Constraint(expr=m.x ** 2 == 4)
m.c2 = Constraint(expr=m.x / m.y == 3)
m.c3 = Constraint(expr=m.x * m.z == 5)
m.c4 = Constraint(expr=m.x * m.y == 5)
m.c4.deactivate()
model_size = build_model_size_report(m)
self.assertEqual(model_size.activated.nonlinear_constraints, 2)
self.assertEqual(model_size.overall.nonlinear_constraints, 3)
def test_disjunctive_model(self):
from pyomo.gdp.tests.models import makeNestedDisjunctions
m = makeNestedDisjunctions()
model_size = build_model_size_report(m)
self.assertEqual(model_size.activated.variables, 10)
self.assertEqual(model_size.overall.variables, 10)
self.assertEqual(model_size.activated.binary_variables, 7)
self.assertEqual(model_size.overall.binary_variables, 7)
self.assertEqual(model_size.activated.integer_variables, 0)
self.assertEqual(model_size.overall.integer_variables, 0)
self.assertEqual(model_size.activated.constraints, 6)
self.assertEqual(model_size.overall.constraints, 6)
self.assertEqual(model_size.activated.disjuncts, 7)
self.assertEqual(model_size.overall.disjuncts, 7)
self.assertEqual(model_size.activated.disjunctions, 3)
self.assertEqual(model_size.overall.disjunctions, 3)
def test_constrained_layout(self):
"""Test with the constrained layout GDP model."""
exfile = import_file(join(
exdir, 'constrained_layout', 'cons_layout_model.py'))
model = exfile.build_constrained_layout_model()
model_size = build_model_size_report(model)
self.assertEqual(model_size.activated.variables, 30)
self.assertEqual(model_size.overall.variables, 30)
self.assertEqual(model_size.activated.binary_variables, 18)
self.assertEqual(model_size.overall.binary_variables, 18)
self.assertEqual(model_size.activated.integer_variables, 0)
self.assertEqual(model_size.overall.integer_variables, 0)
self.assertEqual(model_size.activated.constraints, 48)
self.assertEqual(model_size.overall.constraints, 48)
self.assertEqual(model_size.activated.disjuncts, 18)
self.assertEqual(model_size.overall.disjuncts, 18)
self.assertEqual(model_size.activated.disjunctions, 6)
self.assertEqual(model_size.overall.disjunctions, 6)
def test_eight_process(self):
"""Test with the eight process problem model."""
exfile = import_file(
join(exdir, 'eight_process', 'eight_proc_model.py'))
eight_process = exfile.build_eight_process_flowsheet()
model_size = build_model_size_report(eight_process)
self.assertEqual(model_size.activated.variables, 44)
self.assertEqual(model_size.overall.variables, 44)
self.assertEqual(model_size.activated.binary_variables, 12)
self.assertEqual(model_size.overall.binary_variables, 12)
self.assertEqual(model_size.activated.integer_variables, 0)
self.assertEqual(model_size.overall.integer_variables, 0)
self.assertEqual(model_size.activated.constraints, 52)
self.assertEqual(model_size.overall.constraints, 52)
self.assertEqual(model_size.activated.disjuncts, 12)
self.assertEqual(model_size.overall.disjuncts, 12)
self.assertEqual(model_size.activated.disjunctions, 5)
self.assertEqual(model_size.overall.disjunctions, 5)
def compute_model_stats(only_models: Set[str] = ()):
models_loaded_from_cache = _load_from_model_stats_cache()
_failed_model_names = []
uncached_models = False
for test_model in models.values():
if test_model.name in models_loaded_from_cache:
continue
if only_models and test_model.name not in only_models:
continue
# Model is not already in the cache. Compute its statistics.
print(f"Model '{test_model.name}' is not in the cache. "
"Building the model and computing its statistics now. "
"This may take some time for larger models.")
uncached_models = True
build_start_time = monotonic()
try:
pyomo_model = test_model.build_function()
except Exception as err:
print(f"Failed to build {test_model.name} due to exception: {err}.")
print("Temporarily removing model from library.")
_failed_model_names.append(test_model.name)
continue
build_end_time = monotonic()
test_model.build_time = int(ceil(build_end_time - build_start_time))
size_report = build_model_size_report(pyomo_model)
# update test_model object with information from model size report
test_model.update(size_report.activated)
if test_model.model_type is None:
test_model.model_type = _infer_model_type(test_model)
# Determine objective sense
active_obj = next(pyomo_model.component_data_objects(pyo.Objective, active=True))
test_model.objective_sense = 'minimize' if active_obj.sense == pyo.minimize else 'maximize'
for failed_model in _failed_model_names:
del models[failed_model]
# Cache the model stats
if uncached_models:
_cache_model_stats()
def setup_results_object(self, solve_data, model, config):
solve_data.results.solver.name = 'GDPbb - %s' % (str(config.solver))
num_of = build_model_size_report(model)
prob = solve_data.results.problem
prob.name = model.name
prob.number_of_constraints = num_of.activated.constraints
prob.number_of_disjunctions = num_of.activated.disjunctions
prob.number_of_variables = num_of.activated.variables
prob.number_of_binary_variables = num_of.activated.binary_variables
prob.number_of_continuous_variables = num_of.activated.continuous_variables
prob.number_of_integer_variables = num_of.activated.integer_variables
config.logger.info(
"Original model has %s constraints (%s nonlinear) "
"and %s disjunctions, "
"with %s variables, of which %s are binary, %s are integer, "
"and %s are continuous." %
(num_of.activated.constraints,
num_of.activated.nonlinear_constraints,
num_of.activated.disjunctions, num_of.activated.variables,
num_of.activated.binary_variables,
num_of.activated.integer_variables,
num_of.activated.continuous_variables))
def setup_results_object(solve_data, config):
"""Record problem statistics for original model."""
# Create the solver results object
res = solve_data.results
prob = res.problem
res.problem.name = solve_data.original_model.name
res.problem.number_of_nonzeros = None # TODO
# TODO work on termination condition and message
res.solver.termination_condition = None
res.solver.message = None
res.solver.user_time = None
res.solver.system_time = None
res.solver.wallclock_time = None
res.solver.termination_message = None
num_of = build_model_size_report(solve_data.original_model)
# Get count of constraints and variables
prob.number_of_constraints = num_of.activated.constraints
prob.number_of_disjunctions = num_of.activated.disjunctions
prob.number_of_variables = num_of.activated.variables
prob.number_of_binary_variables = num_of.activated.binary_variables
prob.number_of_continuous_variables = num_of.activated.continuous_variables
prob.number_of_integer_variables = num_of.activated.integer_variables
config.logger.info(
"Original model has %s constraints (%s nonlinear) "
"and %s disjunctions, "
"with %s variables, of which %s are binary, %s are integer, "
"and %s are continuous." %
(num_of.activated.constraints,
num_of.activated.nonlinear_constraints,
num_of.activated.disjunctions,
num_of.activated.variables,
num_of.activated.binary_variables,
num_of.activated.integer_variables,
num_of.activated.continuous_variables))
def test_empty_model(self):
"""Test with an empty model."""
empty_model = ConcreteModel()
model_size = build_model_size_report(empty_model)
for obj in model_size.activated.values():
self.assertEqual(obj, 0)
