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)