def test_referent(self):
m = ConcreteModel()
m.v0 = Var()
m.v2 = Var([1, 2, 3], ['a', 'b'])
varlist = [m.v2[1, 'a'], m.v2[1, 'b']]
vardict = {
0: m.v0,
1: m.v2[1, 'a'],
2: m.v2[2, 'a'],
3: m.v2[3, 'a'],
}
scalar_ref = Reference(m.v0)
self.assertIs(scalar_ref.referent, m.v0)
sliced_ref = Reference(m.v2[:, 'a'])
referent = sliced_ref.referent
self.assertIs(type(referent), IndexedComponent_slice)
self.assertEqual(len(referent._call_stack), 1)
call, info = referent._call_stack[0]
self.assertEqual(call, IndexedComponent_slice.slice_info)
self.assertIs(info[0], m.v2)
self.assertEqual(info[1], {1: 'a'}) # Fixed
self.assertEqual(info[2], {0: slice(None)}) # Sliced
self.assertIs(info[3], None) # Ellipsis
list_ref = Reference(varlist)
self.assertIs(list_ref.referent, varlist)
dict_ref = Reference(vardict)
self.assertIs(dict_ref.referent, vardict)
def test_insert_var(self):
m = ConcreteModel()
m.T = Set(initialize=[1, 5])
m.x = Var(m.T, initialize=lambda m, i: i)
@m.Block(m.T)
def b(b, i):
b.y = Var(initialize=lambda b: 10 * b.index())
ref_x = Reference(m.x[:])
ref_y = Reference(m.b[:].y)
self.assertEqual(len(m.x), 2)
self.assertEqual(len(ref_x), 2)
self.assertEqual(len(m.b), 2)
self.assertEqual(len(ref_y), 2)
self.assertEqual(value(ref_x[1]), 1)
self.assertEqual(value(ref_x[5]), 5)
self.assertEqual(value(ref_y[1]), 10)
self.assertEqual(value(ref_y[5]), 50)
m.T.add(2)
_x = ref_x[2]
self.assertEqual(len(m.x), 3)
self.assertIs(_x, m.x[2])
self.assertEqual(value(_x), 2)
self.assertEqual(value(m.x[2]), 2)
self.assertEqual(value(ref_x[2]), 2)
_y = ref_y[2]
self.assertEqual(len(m.b), 3)
self.assertIs(_y, m.b[2].y)
self.assertEqual(value(_y), 20)
self.assertEqual(value(ref_y[2]), 20)
self.assertEqual(value(m.b[2].y), 20)
def test_reference_to_sparse(self):
m = ConcreteModel()
m.I = RangeSet(3)
m.x = Var(m.I, m.I, dense=False)
m.xx = Reference(m.x[...], ctype=Var)
self.assertEqual(len(m.x), 0)
self.assertNotIn((1, 1), m.x)
self.assertNotIn((1, 1), m.xx)
self.assertIn((1, 1), m.x.index_set())
self.assertIn((1, 1), m.xx.index_set())
self.assertEqual(len(m.x), 0)
m.xx[1, 2]
self.assertEqual(len(m.x), 1)
self.assertIs(m.xx[1, 2], m.x[1, 2])
self.assertEqual(len(m.x), 1)
m.xx[1, 3] = 5
self.assertEqual(len(m.x), 2)
self.assertIs(m.xx[1, 3], m.x[1, 3])
self.assertEqual(len(m.x), 2)
self.assertEqual(value(m.x[1, 3]), 5)
m.xx.add((1, 1))
self.assertEqual(len(m.x), 3)
self.assertIs(m.xx[1, 1], m.x[1, 1])
self.assertEqual(len(m.x), 3)
def test_nested_reference_multidim_set(self):
m = ConcreteModel()
m.I = Set(initialize=[1, 2])
m.J = Set(initialize=[(3, 3), (4, 4)])
@m.Block(m.I)
def b(b, i):
b.x = Var(b.model().J, bounds=(i, None))
m.r = Reference(m.b[:].x[:, :])
self.assertIs(m.r.ctype, Var)
self.assertIsInstance(m.r.index_set(), SetProduct)
self.assertIs(m.r.index_set().set_tuple[0], m.I)
self.assertIs(m.r.index_set().set_tuple[1], m.J)
self.assertEqual(len(m.r), 2 * 2)
self.assertEqual(m.r[1, 3, 3].lb, 1)
self.assertEqual(m.r[2, 4, 4].lb, 2)
self.assertIn((1, 3, 3), m.r)
self.assertIn((2, 4, 4), m.r)
self.assertNotIn(0, m.r)
self.assertNotIn((1, 0), m.r)
self.assertNotIn((1, 3, 0), m.r)
self.assertNotIn((1, 3, 3, 0), m.r)
with self.assertRaises(KeyError):
m.r[0]
def test_is_reference(self):
m = ConcreteModel()
m.v0 = Var()
m.v1 = Var([1, 2, 3])
m.ref0 = Reference(m.v0)
m.ref1 = Reference(m.v1)
self.assertFalse(m.v0.is_reference())
self.assertFalse(m.v1.is_reference())
self.assertTrue(m.ref0.is_reference())
self.assertTrue(m.ref1.is_reference())
unique_vars = list(v for v in m.component_objects(Var)
if not v.is_reference())
self.assertEqual(len(unique_vars), 2)
def test_reference_to_set(self):
m = ConcreteModel()
m.I = Set(initialize=[1, 3, 5])
m.r = Reference(m.I)
self.assertEqual(len(m.r), 1)
self.assertEqual(list(m.r.keys()), [None])
self.assertEqual(list(m.r.values()), [m.I])
self.assertIs(m.r[None], m.I)
# Test that a referent Set containing None doesn't break the
# None index
m = ConcreteModel()
m.I = Set(initialize=[1, 3, None, 5])
m.r = Reference(m.I)
self.assertEqual(len(m.r), 1)
self.assertEqual(list(m.r.keys()), [None])
self.assertEqual(list(m.r.values()), [m.I])
self.assertIs(m.r[None], m.I)
def test_component_reference(self):
m = ConcreteModel()
m.x = Var()
m.r = Reference(m.x)
self.assertIs(m.r.ctype, Var)
self.assertIsNot(m.r.index_set(), m.x.index_set())
self.assertIs(m.x.index_set(), UnindexedComponent_set)
self.assertIs(type(m.r.index_set()), OrderedSetOf)
self.assertEqual(len(m.r), 1)
self.assertTrue(m.r.is_indexed())
self.assertIn(None, m.r)
self.assertNotIn(1, m.r)
self.assertIs(m.r[None], m.x)
with self.assertRaises(KeyError):
m.r[1]
m.s = Reference(m.x[:])
self.assertIs(m.s.ctype, Var)
self.assertIsNot(m.s.index_set(), m.x.index_set())
self.assertIs(m.x.index_set(), UnindexedComponent_set)
self.assertIs(type(m.s.index_set()), OrderedSetOf)
self.assertEqual(len(m.s), 1)
self.assertTrue(m.s.is_indexed())
self.assertIn(None, m.s)
self.assertNotIn(1, m.s)
self.assertIs(m.s[None], m.x)
with self.assertRaises(KeyError):
m.s[1]
m.y = Var([1, 2])
m.t = Reference(m.y)
self.assertIs(m.t.ctype, Var)
self.assertIs(m.t.index_set(), m.y.index_set())
self.assertEqual(len(m.t), 2)
self.assertTrue(m.t.is_indexed())
self.assertNotIn(None, m.t)
self.assertIn(1, m.t)
self.assertIn(2, m.t)
self.assertIs(m.t[1], m.y[1])
with self.assertRaises(KeyError):
m.t[3]
def test_nested_reference_to_sparse(self):
m = ConcreteModel()
m.I = Set(initialize=[1])
@m.Block(m.I)
def b(b, i):
b.x = Var(b.model().I, dense=False)
m.xx = Reference(m.b[:].x[:], ctype=Var)
m.I.add(2)
m.I.add(3)
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 0)
self.assertIn(1, m.b)
self.assertNotIn((1, 1), m.xx)
self.assertIn(1, m.b[1].x.index_set())
self.assertIn((1, 1), m.xx.index_set())
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 0)
m.xx[1, 2]
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 1)
self.assertIs(m.xx[1, 2], m.b[1].x[2])
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 1)
m.xx[1, 3] = 5
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 2)
self.assertIs(m.xx[1, 3], m.b[1].x[3])
self.assertEqual(value(m.b[1].x[3]), 5)
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 2)
m.xx.add((1, 1))
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 3)
self.assertIs(m.xx[1, 1], m.b[1].x[1])
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 3)
# While (2,2) appears to be a valid member of the slice, because
# 2 was not in the Set when the Block rule fired, there is no
# m.b[2] block data. Accessing m.xx[2,1] will construct the
# b[2] block data, fire the rule, and then add the new value to
# the Var x.
self.assertEqual(len(m.xx), 3)
m.xx[2, 2] = 10
self.assertEqual(len(m.b), 2)
self.assertEqual(len(list(m.b[2].component_objects())), 1)
self.assertEqual(len(m.xx), 4)
self.assertIs(m.xx[2, 2], m.b[2].x[2])
self.assertEqual(value(m.b[2].x[2]), 10)
def test_nested_scalars(self):
m = ConcreteModel()
m.b = Block()
m.b.x = Var()
m.r = Reference(m.b[:].x[:])
self.assertEqual(len(m.r), 1)
self.assertEqual(m.r.index_set().dimen, 2)
base_sets = list(m.r.index_set().subsets())
self.assertEqual(len(base_sets), 2)
self.assertIs(type(base_sets[0]), OrderedSetOf)
self.assertIs(type(base_sets[1]), OrderedSetOf)
def test_reference_indexedcomponent_pprint(self):
m = ConcreteModel()
m.x = Var([1, 2], initialize={1: 4, 2: 8})
m.r = Reference(m.x, ctype=IndexedComponent)
buf = StringIO()
m.r.pprint(ostream=buf)
self.assertEqual(
buf.getvalue(), """r : Size=2, Index=x_index, ReferenceTo=x
Key : Object
1 : <class 'pyomo.core.base.var._GeneralVarData'>
2 : <class 'pyomo.core.base.var._GeneralVarData'>
""")
m.s = Reference(m.x[:, ...], ctype=IndexedComponent)
buf = StringIO()
m.s.pprint(ostream=buf)
self.assertEqual(
buf.getvalue(), """s : Size=2, Index=x_index, ReferenceTo=x[:, ...]
Key : Object
1 : <class 'pyomo.core.base.var._GeneralVarData'>
2 : <class 'pyomo.core.base.var._GeneralVarData'>
""")
def test_reference_var_pprint(self):
m = ConcreteModel()
m.x = Var([1, 2], initialize={1: 4, 2: 8})
m.r = Reference(m.x)
buf = StringIO()
m.r.pprint(ostream=buf)
self.assertEqual(
buf.getvalue(), """r : Size=2, Index=x_index, ReferenceTo=x
Key : Lower : Value : Upper : Fixed : Stale : Domain
1 : None : 4 : None : False : False : Reals
2 : None : 8 : None : False : False : Reals
""")
m.s = Reference(m.x[:, ...])
buf = StringIO()
m.s.pprint(ostream=buf)
self.assertEqual(
buf.getvalue(), """s : Size=2, Index=x_index, ReferenceTo=x[:, ...]
Key : Lower : Value : Upper : Fixed : Stale : Domain
1 : None : 4 : None : False : False : Reals
2 : None : 8 : None : False : False : Reals
""")
def test_nested_reference_to_sparse(self):
m = ConcreteModel()
m.I = Set(initialize=[1])
@m.Block(m.I)
def b(b, i):
b.x = Var(b.model().I, dense=False)
m.xx = Reference(m.b[:].x[:], ctype=Var)
m.I.add(2)
m.I.add(3)
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 0)
self.assertIn(1, m.b)
self.assertNotIn((1, 1), m.xx)
self.assertIn(1, m.b[1].x.index_set())
self.assertIn((1, 1), m.xx.index_set())
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 0)
m.xx[1, 2]
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 1)
self.assertIs(m.xx[1, 2], m.b[1].x[2])
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 1)
m.xx[1, 3] = 5
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 2)
self.assertIs(m.xx[1, 3], m.b[1].x[3])
self.assertEqual(value(m.b[1].x[3]), 5)
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 2)
m.xx.add((1, 1))
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 3)
self.assertIs(m.xx[1, 1], m.b[1].x[1])
self.assertEqual(len(m.b), 1)
self.assertEqual(len(m.b[1].x), 3)
# While (2,1) appears to be a valid member of the slice, because 2
# was not in the Set when the Block rule fired, there is no
# m.b[2] block data. Attempting to add m.xx[2,1] will correctly
# instantiate the block and then promptly fail because we don't
# automatically fire rules after construction.
with self.assertRaisesRegexp(
AttributeError, "'_BlockData' object has no attribute 'x'"):
m.xx.add((2, 1))
self.assertEqual(len(m.b), 2)
self.assertEqual(len(list(m.b[2].component_objects())), 0)
def test_UnknownSetDimen(self):
# Replicate the bug reported in #1928
m = ConcreteModel()
m.thinga = Set(initialize=['e1', 'e2', 'e3'])
m.thingb = Set(initialize=[])
m.v = Var(m.thinga | m.thingb)
self.assertIs(m.v.dim(), UnknownSetDimen)
with self.assertRaisesRegex(
IndexError,
'Slicing components relies on knowing the underlying '
'set dimensionality'):
Reference(m.v)
def create_subsystem_block(constraints, variables=None, include_fixed=False):
""" This function creates a block to serve as a subsystem with the
specified variables and constraints. To satisfy certain writers, other
variables that appear in the constraints must be added to the block as
well. We call these the "input vars." They may be thought of as
parameters in the subsystem, but we do not fix them here as it is not
obvious that this is desired.
Arguments
---------
constraints: List
List of Pyomo constraint data objects
variables: List
List of Pyomo var data objects
include_fixed: Bool
Indicates whether fixed variables should be attached to the block.
This is useful if they may be unfixed at some point.
Returns
-------
Block containing references to the specified constraints and variables,
as well as other variables present in the constraints
"""
if variables is None:
variables = []
block = Block(concrete=True)
block.vars = Reference(variables)
block.cons = Reference(constraints)
var_set = ComponentSet(variables)
input_vars = []
for con in constraints:
for var in identify_variables(con.expr, include_fixed=include_fixed):
if var not in var_set:
input_vars.append(var)
var_set.add(var)
block.input_vars = Reference(input_vars)
add_local_external_functions(block)
return block
def get_numeric_incidence_matrix(variables, constraints):
"""
This function gets the numeric incidence matrix (Jacobian) of Pyomo
constraints with respect to variables.
"""
# NOTE: There are several ways to get a numeric incidence matrix
# from a Pyomo model. This function implements a somewhat roundabout
# method, which is to construct a dummy Block with the necessary
# variables and constraints, then construct a PyNumero PyomoNLP
# from the block and have PyNumero evaluate the desired Jacobian
# via ASL.
comps = list(variables) + list(constraints)
_check_unindexed(comps)
M, N = len(constraints), len(variables)
_block = Block()
_block.construct()
_block.obj = Objective(expr=0)
_block.vars = Reference(variables)
_block.cons = Reference(constraints)
var_set = ComponentSet(variables)
other_vars = []
for con in constraints:
for var in identify_variables(con.body, include_fixed=False):
# Fixed vars will be ignored by the nl file write, so
# there is no point to including them here.
# A different method of assembling this matrix, e.g.
# Pyomo's automatic differentiation, could support taking
# derivatives with respect to fixed variables.
if var not in var_set:
other_vars.append(var)
var_set.add(var)
# These variables are necessary due to the nl writer's philosophy
# about what constitutes a model. Note that we take derivatives with
# respect to them even though this is not necessary. We could fix them
# here to avoid doing this extra work, but that would alter the user's
# model, which we would rather not do.
_block.other_vars = Reference(other_vars)
_nlp = PyomoNLP(_block)
return _nlp.extract_submatrix_jacobian(variables, constraints)
def test_pprint_nonfinite_sets(self):
# test issue #2039
self.maxDiff = None
m = ConcreteModel()
m.v = Var(NonNegativeIntegers, dense=False)
m.ref = Reference(m.v)
buf = StringIO()
m.pprint(ostream=buf)
self.assertEqual(
buf.getvalue().strip(), """
1 Var Declarations
v : Size=0, Index=NonNegativeIntegers
Key : Lower : Value : Upper : Fixed : Stale : Domain
1 IndexedComponent Declarations
ref : Size=0, Index=ref_index, ReferenceTo=v
Key : Object
1 SetOf Declarations
ref_index : Dimen=0, Size=0, Bounds=(None, None)
Key : Ordered : Members
None : False : ReferenceSet(v[...])
3 Declarations: v ref_index ref
""".strip())
m.v[3]
m.ref[5]
buf = StringIO()
m.pprint(ostream=buf)
self.assertEqual(
buf.getvalue().strip(), """
1 Var Declarations
v : Size=2, Index=NonNegativeIntegers
Key : Lower : Value : Upper : Fixed : Stale : Domain
3 : None : None : None : False : True : Reals
5 : None : None : None : False : True : Reals
1 IndexedComponent Declarations
ref : Size=2, Index=ref_index, ReferenceTo=v
Key : Object
3 : <class 'pyomo.core.base.var._GeneralVarData'>
5 : <class 'pyomo.core.base.var._GeneralVarData'>
1 SetOf Declarations
ref_index : Dimen=1, Size=2, Bounds=(3, 5)
Key : Ordered : Members
None : False : ReferenceSet(v[...])
3 Declarations: v ref_index ref
""".strip())
def test_contains_with_nonflattened(self):
# test issue #1800
_old_flatten = normalize_index.flatten
try:
normalize_index.flatten = False
m = ConcreteModel()
m.d1 = Set(initialize=[1, 2])
m.d2 = Set(initialize=[('a', 1), ('b', 2)])
m.v = Var(m.d2, m.d1)
m.ref = Reference(m.v[:, 1])
self.assertIn(('a', 1), m.ref)
self.assertNotIn(('a', 10), m.ref)
finally:
normalize_index.flatten = _old_flatten
def test_component_data_reference_clone(self):
m = ConcreteModel()
m.b = Block()
m.b.x = Var([1, 2])
m.c = Block()
m.c.r = Reference(m.b.x[2])
self.assertIs(m.c.r[None], m.b.x[2])
m.d = m.c.clone()
self.assertIs(m.d.r[None], m.b.x[2])
i = m.clone()
self.assertIs(i.c.r[None], i.b.x[2])
self.assertIsNot(i.c.r[None], m.b.x[2])
self.assertIs(i.d.r[None], i.b.x[2])
def test_ctype_detection(self):
m = ConcreteModel()
m.js = Set(initialize=[1, (2, 3)], dimen=None)
m.b = Block([1, 2])
m.b[1].x = Var(m.js)
m.b[1].y = Var()
m.b[1].z = Var([1, 2])
m.b[2].x = Param(initialize=0)
m.b[2].y = Var()
m.b[2].z = Var([1, 2])
m.x = Reference(m.b[:].x[...])
self.assertIs(type(m.x), IndexedComponent)
m.y = Reference(m.b[:].y[...])
self.assertIs(type(m.y), IndexedVar)
self.assertIs(m.y.ctype, Var)
m.y1 = Reference(m.b[:].y[...], ctype=None)
self.assertIs(type(m.y1), IndexedComponent)
self.assertIs(m.y1.ctype, IndexedComponent)
m.z = Reference(m.b[:].z)
self.assertIs(type(m.z), IndexedComponent)
self.assertIs(m.z.ctype, IndexedComponent)
def test_component_data_reference(self):
m = ConcreteModel()
m.y = Var([1, 2])
m.r = Reference(m.y[2])
self.assertIs(m.r.ctype, Var)
self.assertIsNot(m.r.index_set(), m.y.index_set())
self.assertIs(m.y.index_set(), m.y_index)
self.assertIs(type(m.r.index_set()), OrderedSetOf)
self.assertEqual(len(m.r), 1)
self.assertTrue(m.r.is_indexed())
self.assertIn(None, m.r)
self.assertNotIn(1, m.r)
self.assertIs(m.r[None], m.y[2])
with self.assertRaises(KeyError):
m.r[2]
def test_single_reference(self):
m = ConcreteModel()
m.b = Block([1, 2])
m.b[1].x = Var(bounds=(1, None))
m.b[2].x = Var(bounds=(2, None))
m.r = Reference(m.b[:].x)
self.assertIs(m.r.ctype, Var)
self.assertIs(m.r.index_set(), m.b.index_set())
self.assertEqual(len(m.r), 2)
self.assertEqual(m.r[1].lb, 1)
self.assertEqual(m.r[2].lb, 2)
self.assertIn(1, m.r)
self.assertIn(2, m.r)
self.assertNotIn(3, m.r)
with self.assertRaises(KeyError):
m.r[3]
def find_component_on(self, block):
"""
Return the (unique) component in the block. If the CUID contains
a wildcard in the last component, then returns that component. If
there are wildcards elsewhere (or the last component was a partial
slice), then returns a reference. See also list_components below.
"""
obj = self._resolve_cuid(block)
if isinstance(obj, IndexedComponent_slice):
# Suppress slice iteration exceptions
obj.key_errors_generate_exceptions = False
obj.attribute_errors_generate_exceptions = False
obj = Reference(obj)
try:
next(iter(obj))
except StopIteration:
obj = None
return obj
def test_reference_to_list(self):
m = ConcreteModel()
m.x = Var()
m.y = Var([1, 2, 3])
m.r = Reference([m.x, m.y[2], m.y[1]])
self.assertTrue(m.r.index_set().isordered())
self.assertEqual(len(m.r), 3)
self.assertEqual(list(m.r.keys()), [0, 1, 2])
self.assertEqual(list(m.r.values()), [m.x, m.y[2], m.y[1]])
# You can delete something from the reference
del m.r[1]
self.assertEqual(len(m.r), 2)
self.assertEqual(list(m.r.keys()), [0, 2])
self.assertEqual(list(m.r.values()), [m.x, m.y[1]])
# But not add it back
with self.assertRaisesRegex(
KeyError, "Index '1' is not valid for indexed component 'r'"):
m.r[1] = m.x
def test_pprint_nested(self):
m = ConcreteModel()
@m.Block([1, 2])
def b(b, i):
b.x = Var([3, 4], bounds=(i, None))
m.r = Reference(m.b[:].x[:])
buf = StringIO()
m.r.pprint(ostream=buf)
self.assertEqual(
buf.getvalue().strip(), """
r : Size=4, Index=r_index, ReferenceTo=b[:].x[:]
Key : Lower : Value : Upper : Fixed : Stale : Domain
(1, 3) : 1 : None : None : False : True : Reals
(1, 4) : 1 : None : None : False : True : Reals
(2, 3) : 2 : None : None : False : True : Reals
(2, 4) : 2 : None : None : False : True : Reals
""".strip())
def test_reference_to_dict(self):
m = ConcreteModel()
m.x = Var()
m.y = Var([1, 2, 3])
m.r = Reference({1: m.x, 'a': m.y[2], 3: m.y[1]})
self.assertFalse(m.r.index_set().isordered())
self.assertEqual(len(m.r), 3)
self.assertEqual(set(m.r.keys()), {1, 3, 'a'})
self.assertEqual(ComponentSet(m.r.values()),
ComponentSet([m.x, m.y[2], m.y[1]]))
# You can delete something from the reference
del m.r[1]
self.assertEqual(len(m.r), 2)
self.assertEqual(set(m.r.keys()), {3, 'a'})
self.assertEqual(ComponentSet(m.r.values()),
ComponentSet([m.y[2], m.y[1]]))
# But not add it back
with self.assertRaisesRegex(
KeyError, "Index '1' is not valid for indexed component 'r'"):
m.r[1] = m.x
def test_nested_reference_nondimen_set(self):
m = ConcreteModel()
m.I = Set(initialize=[1,2])
m.J = Set(initialize=[3,4], dimen=None)
@m.Block(m.I)
def b(b,i):
b.x = Var(b.model().J, bounds=(i,None))
m.r = Reference(m.b[:].x[:])
self.assertIs(m.r.ctype, Var)
self.assertIs(type(m.r.index_set()), UnorderedSetOf)
self.assertEqual(len(m.r), 2*2)
self.assertEqual(m.r[1,3].lb, 1)
self.assertEqual(m.r[2,4].lb, 2)
self.assertIn((1,3), m.r)
self.assertIn((2,4), m.r)
self.assertNotIn(0, m.r)
self.assertNotIn((1,0), m.r)
self.assertNotIn((1,3,0), m.r)
with self.assertRaises(KeyError):
m.r[0]
def test_nested_reference_nonuniform_index_size(self):
m = ConcreteModel()
m.I = Set(initialize=[1, 2])
m.J = Set(initialize=[3, 4])
m.b = Block(m.I)
m.b[1].x = Var([(3, 3), (3, 4), (4, 3), (4, 4)], bounds=(1, None))
m.b[2].x = Var(m.J, m.J, bounds=(2, None))
m.r = Reference(m.b[:].x[:, :])
self.assertIs(m.r.ctype, Var)
self.assertIs(type(m.r.index_set()), FiniteSetOf)
self.assertEqual(len(m.r), 2 * 2 * 2)
self.assertEqual(m.r[1, 3, 3].lb, 1)
self.assertEqual(m.r[2, 4, 3].lb, 2)
self.assertIn((1, 3, 3), m.r)
self.assertIn((2, 4, 4), m.r)
self.assertNotIn(0, m.r)
self.assertNotIn((1, 0), m.r)
self.assertNotIn((1, 3, 0), m.r)
self.assertNotIn((1, 3, 3, 0), m.r)
with self.assertRaises(KeyError):
m.r[0]
def test_nested_reference_partial_multidim_set(self):
m = ConcreteModel()
m.I = Set(initialize=[1, 2])
m.J = Set(initialize=[(3, 3), (4, 4)])
@m.Block(m.I)
def b(b, i):
b.x = Var(b.model().J, bounds=(i, None))
m.r = Reference(m.b[:].x[3, :])
self.assertIs(m.r.ctype, Var)
self.assertIs(type(m.r.index_set()), FiniteSetOf)
self.assertEqual(len(m.r), 2 * 1)
self.assertEqual(m.r[1, 3].lb, 1)
self.assertEqual(m.r[2, 3].lb, 2)
self.assertIn((1, 3), m.r)
self.assertNotIn((2, 4), m.r)
self.assertNotIn(0, m.r)
self.assertNotIn((1, 0), m.r)
self.assertNotIn((1, 3, 0), m.r)
with self.assertRaises(KeyError):
m.r[0]
def set_external_model(
self,
external_grey_box_model,
inputs=None,
outputs=None,
):
"""
Parameters
----------
external_grey_box_model: ExternalGreyBoxModel
The external model that will be interfaced to in this block
inputs: List of VarData objects
If provided, these VarData will be used as inputs into the
external model.
outputs: List of VarData objects
If provided, these VarData will be used as outputs from the
external model.
"""
self._ex_model = ex_model = external_grey_box_model
if ex_model is None:
self._input_names = self._output_names = None
self.inputs = self.outputs = None
return
# Shouldn't need input names if we provide input vars, but
# no reason to remove this.
# _could_ make inputs a reference-to-mapping
self._input_names = ex_model.input_names()
if self._input_names is None or len(self._input_names) == 0:
raise ValueError(
'No input_names specified for external_grey_box_model.'
' Must specify at least one input.')
self._input_names_set = Set(initialize=self._input_names, ordered=True)
if inputs is None:
self.inputs = Var(self._input_names_set)
else:
if ex_model.n_inputs() != len(inputs):
raise ValueError(
"Dimension mismatch in provided input vars for external "
"model.\nExpected %s input vars, got %s." %
(ex_model.n_inputs(), len(inputs)))
self.inputs = Reference(inputs)
self._equality_constraint_names = ex_model.equality_constraint_names()
self._output_names = ex_model.output_names()
self._output_names_set = Set(initialize=self._output_names,
ordered=True)
if outputs is None:
self.outputs = Var(self._output_names_set)
else:
if ex_model.n_outputs() != len(outputs):
raise ValueError(
"Dimension mismatch in provided output vars for external "
"model.\nExpected %s output vars, got %s." %
(ex_model.n_outputs(), len(outputs)))
self.outputs = Reference(outputs)
# call the callback so the model can set initialization, bounds, etc.
external_grey_box_model.finalize_block_construction(self)
