def test_var_bound_propagate_revert(self):
"""Test to make sure bound propagation revert works."""
m = ConcreteModel()
m.v1 = Var(initialize=1, bounds=(1, 3))
m.v2 = Var(initialize=2, bounds=(0, 8))
m.v3 = Var(initialize=3, bounds=(2, 4))
m.v4 = Var(initialize=4, bounds=(0, 5))
m.c1 = Constraint(expr=m.v1 == m.v2)
m.c2 = Constraint(expr=m.v2 == m.v3)
m.c3 = Constraint(expr=m.v3 == m.v4)
xfrm = TransformationFactory('contrib.propagate_eq_var_bounds')
xfrm.apply_to(m, tmp=True)
self.assertEquals(value(m.v1.lb), 2)
self.assertEquals(value(m.v1.lb), value(m.v2.lb))
self.assertEquals(value(m.v1.lb), value(m.v3.lb))
self.assertEquals(value(m.v1.lb), value(m.v4.lb))
self.assertEquals(value(m.v1.ub), 3)
self.assertEquals(value(m.v1.ub), value(m.v2.ub))
self.assertEquals(value(m.v1.ub), value(m.v3.ub))
self.assertEquals(value(m.v1.ub), value(m.v4.ub))
xfrm.revert(m)
self.assertEquals(value(m.v1.lb), 1)
self.assertEquals(value(m.v2.lb), 0)
self.assertEquals(value(m.v3.lb), 2)
self.assertEquals(value(m.v4.lb), 0)
self.assertEquals(value(m.v1.ub), 3)
self.assertEquals(value(m.v2.ub), 8)
self.assertEquals(value(m.v3.ub), 4)
self.assertEquals(value(m.v4.ub), 5)
def test_fixed_var_revert(self):
"""Test for reversion of fixed variables."""
m = ConcreteModel()
m.v1 = Var(initialize=1)
m.v2 = Var(initialize=2)
m.v1.setub(2)
m.v1.setlb(2)
xfrm = TransformationFactory('contrib.detect_fixed_vars')
xfrm.apply_to(m, tmp=True)
self.assertTrue(m.v1.fixed)
self.assertFalse(m.v2.fixed)
xfrm.revert(m)
self.assertFalse(m.v1.fixed)
self.assertEqual(value(m.v1), 1)
def test_deactivate_trivial_constraints_revert(self):
"""Test for reversion of trivial constraint deactivation."""
m = ConcreteModel()
m.v1 = Var(initialize=1)
m.v2 = Var(initialize=2)
m.v3 = Var(initialize=3)
m.c = Constraint(expr=m.v1 <= m.v2)
m.c2 = Constraint(expr=m.v2 >= m.v3)
m.c3 = Constraint(expr=m.v1 <= 5)
m.v1.fix()
xfrm = TransformationFactory(
'contrib.deactivate_trivial_constraints')
xfrm.apply_to(m, tmp=True)
self.assertTrue(m.c.active)
self.assertTrue(m.c2.active)
self.assertFalse(m.c3.active)
xfrm.revert(m)
self.assertTrue(m.c3.active)
def test_var_fix_revert(self):
"""Test to make sure that variable fixing reversion works."""
m = ConcreteModel()
m.v1 = Var(initialize=1)
m.v2 = Var(initialize=2)
m.v3 = Var(initialize=3)
m.v4 = Var(initialize=4)
m.c1 = Constraint(expr=m.v1 == m.v2)
m.c2 = Constraint(expr=m.v2 == m.v3)
m.c3 = Constraint(expr=m.v3 == m.v4)
m.v2.fix()
fvp = TransformationFactory('contrib.propagate_fixed_vars')
fvp.apply_to(m, tmp=True)
self.assertTrue(m.v1.fixed)
self.assertTrue(m.v2.fixed)
self.assertTrue(m.v3.fixed)
self.assertTrue(m.v4.fixed)
fvp.revert(m)
self.assertFalse(m.v1.fixed)
self.assertTrue(m.v2.fixed)
self.assertFalse(m.v3.fixed)
self.assertFalse(m.v4.fixed)
def test_var_fix_revert(self):
"""Test to make sure that variable fixing reversion works."""
m = ConcreteModel()
m.v1 = Var(initialize=1)
m.v2 = Var(initialize=2)
m.v3 = Var(initialize=3)
m.v4 = Var(initialize=4)
m.c1 = Constraint(expr=m.v1 == m.v2)
m.c2 = Constraint(expr=m.v2 == m.v3)
m.c3 = Constraint(expr=m.v3 == m.v4)
m.v2.fix()
fvp = TransformationFactory('contrib.propagate_fixed_vars')
fvp.apply_to(m, tmp=True)
self.assertTrue(m.v1.fixed)
self.assertTrue(m.v2.fixed)
self.assertTrue(m.v3.fixed)
self.assertTrue(m.v4.fixed)
fvp.revert(m)
self.assertFalse(m.v1.fixed)
self.assertTrue(m.v2.fixed)
self.assertFalse(m.v3.fixed)
self.assertFalse(m.v4.fixed)
def test_no_strip_domain(self):
"""Test bounds stripping without domain change."""
m = ConcreteModel()
m.v0 = Var(bounds=(2, 4))
m.v1 = Var(domain=NonNegativeReals)
m.v2 = Var(domain=PositiveReals)
m.v3 = Var(bounds=(-1, 1))
m.v4 = Var(domain=Binary)
m.v5 = Var(domain=Integers, bounds=(15, 16))
xfrm = TransformationFactory('contrib.strip_var_bounds')
xfrm.apply_to(m, strip_domains=False, reversible=True)
self.assertEqual(m.v0.bounds, (None, None))
self.assertEqual(m.v1.bounds, (0, None))
self.assertEqual(m.v2.bounds, (0, None))
self.assertEqual(m.v3.bounds, (None, None))
self.assertEqual(m.v4.bounds, (0, 1))
self.assertEqual(m.v5.bounds, (None, None))
self.assertEqual(m.v0.domain, Reals)
self.assertEqual(m.v1.domain, NonNegativeReals)
self.assertEqual(m.v2.domain, PositiveReals)
self.assertEqual(m.v3.domain, Reals)
self.assertEqual(m.v4.domain, Binary)
self.assertEqual(m.v5.domain, Integers)
xfrm.revert(m)
self.assertEqual(m.v0.bounds, (2, 4))
self.assertEqual(m.v1.bounds, (0, None))
self.assertEqual(m.v2.bounds, (0, None))
self.assertEqual(m.v3.bounds, (-1, 1))
self.assertEqual(m.v4.bounds, (0, 1))
self.assertEqual(m.v5.bounds, (15, 16))
self.assertEqual(m.v0.domain, Reals)
self.assertEqual(m.v1.domain, NonNegativeReals)
self.assertEqual(m.v2.domain, PositiveReals)
self.assertEqual(m.v3.domain, Reals)
self.assertEqual(m.v4.domain, Binary)
self.assertEqual(m.v5.domain, Integers)
class SquareSolveContext(object):
"""
Utility class to prepare DynamicBlock for a square solve.
"""
def __init__(
self,
dynamic_block,
samples=None,
strip_var_bounds=True,
input_option=InputOption.CURRENT,
):
"""
Parameters
----------
dynamic_block: A _DynamicBlockData object
samples: A list of integers corresponding to the samples that
will be solved
"""
self.block = dynamic_block
self.samples = samples
self.strip_var_bounds = strip_var_bounds
self.input_option = input_option
# Get indices for the time points where we need to fix inputs.
if samples is None:
# Assume we need to fix inputs for all non-initial time
self.time_indices = range(2, len(dynamic_block.time) + 1)
else:
# Get the indices of all time points in the samples specified
sample_points = dynamic_block.sample_points
time = dynamic_block.time
time_indices = []
already_visited = set()
for s in samples:
# s is an integer in range(1, len(sample_points)+1)
# the ith sample is the interval (ts_{i-1}, ts_i]
t0 = sample_points[s - 1]
ts = sample_points[s]
idx_0 = time.find_nearest_index(t0)
idx_s = time.find_nearest_index(ts)
for i in range(idx_0 + 1,
idx_s + 1): # Pyomo sets are 1-indexed
if i not in already_visited:
# Want to make sure each index gets added at most
# once in the case of repeated samples...
time_indices.append(i)
already_visited.add(i)
self.time_indices = time_indices
def __enter__(self):
# Strip bounds:
if self.strip_var_bounds:
self.strip_bounds = TransformationFactory(
'contrib.strip_var_bounds')
self.strip_bounds.apply_to(self.block.mod, reversible=True)
# Fix inputs:
time = self.block.time
t0 = time.first()
time_indices = self.time_indices
input_vars = self.block.input_vars
input_option = self.input_option
if input_option is InputOption.CURRENT:
input_vals = [None for _ in input_vars]
elif input_option is InputOption.INITIAL:
input_vals = [v[t0] for v in input_vars]
elif input_option is InputOption.SETPOINT:
input_vals = [v.setpoint for v in input_vars]
else:
raise NotImplementedError('Unrecognized input option')
for var, val in zip(input_vars, input_vals):
for i in time_indices:
t = time[i]
if val is None:
var[t].fix()
else:
var[t].fix(val)
# Model should now be square and bound-free
return self
def __exit__(self, ex_type, ex_val, ex_tb):
# Unfix inputs:
time = self.block.time
time_indices = self.time_indices
input_vars = self.block.input_vars
for var in input_vars:
for i in time_indices:
t = time[i]
var[t].unfix()
if self.strip_var_bounds:
self.strip_bounds.revert(self.block.mod)
