def test_init_rule(self):
block_set = pyo.Set(initialize=range(3))
block_set.construct()
# Create same maps as before
horizon_map = {0: 1, 1: 3, 2: 5}
nfe_map = {0: 2, 1: 6, 2: 10}
model_map = {
i: make_model(horizon=horizon_map[i], nfe=nfe_map[i])
for i in block_set
}
# Create rule to construct DynamicBlock with
def dynamic_block_rule(b, i):
model = model_map[i]
time = model.time
t0 = time.first()
inputs = [model.flow_in[t0]]
measurements = [model.conc[0,'A'], model.conc[0,'B']]
# Won't be obvious that these attrs need to be set if
# constructing from a rule
b.mod = model
super(_BlockData, b).__setattr__('time', time)
b._inputs = inputs
b._measurements = measurements
# Create DynamicBlock from a rule
block = DynamicBlock(block_set, rule=dynamic_block_rule)
assert type(block) is IndexedDynamicBlock
assert isinstance(block, DynamicBlock)
block.construct()
# Make sure iterating over block.values works as expected
assert all(b.parent_component() is block for b in block.values())
# Make sure __contains__ works
for i in block_set:
assert i in block
# Assert correct attributes and subblocks
for i, b in block.items():
assert b.mod is model_map[i]
assert b.time is model_map[i].time
t0 = b.time.first()
assert all(i1 is i2 for i1, i2 in zip(b._inputs,
[model_map[i].flow_in[t0]]))
assert all(i1 is i2 for i1, i2 in zip(b._measurements,
[model_map[i].conc[t0,'A'], model_map[i].conc[t0,'B']]))
assert hasattr(b, 'category_dict')
assert hasattr(b, 'vardata_map')
assert hasattr(b, 'measurement_vars')
assert hasattr(b, 'differential_vars')
assert hasattr(b, 'algebraic_vars')
assert hasattr(b, 'derivative_vars')
assert hasattr(b, 'input_vars')
assert hasattr(b, 'fixed_vars')
subblocks = [
b.mod,
b.vectors,
b.DIFFERENTIAL_BLOCK,
b.ALGEBRAIC_BLOCK,
b.INPUT_BLOCK,
b.FIXED_BLOCK,
b.DERIVATIVE_BLOCK,
b.MEASUREMENT_BLOCK,
]
block_objects = ComponentSet(
b.component_objects(pyo.Block, descend_into=False))
assert len(subblocks) == len(block_objects)
for sb in subblocks:
assert sb in block_objects
b.v = pyo.Var(initialize=3)
b.c = pyo.Constraint(expr=b.v==5)
assert b.v.value == 3
assert b.v in ComponentSet(identify_variables(b.c.expr))
def test_init_indexed(self):
block_set = pyo.Set(initialize=[0,1,2])
block_set.construct()
horizon_map = {0: 1., 1: 3., 2: 5.}
nfe_map = {0: 2, 1: 6, 2: 10}
model_map = {i: make_model(horizon_map[i], nfe_map[i])
for i in block_set}
time_map = {i: model_map[i].time for i in block_set}
inputs_map = {i: [model_map[i].flow_in[0]] for i in block_set}
measurements_map = {
i: [model_map[i].conc[0,'A'], model_map[i].conc[0,'B']]
for i in block_set
}
# Construct block with a dict for each of its arguments
block = DynamicBlock(
block_set,
model=model_map,
time=time_map,
inputs=inputs_map,
measurements=measurements_map,
)
# Make sure we have the right type
assert type(block) is IndexedDynamicBlock
assert isinstance(block, DynamicBlock)
block.construct()
assert all(b.parent_component() is block for b in block.values())
# Check __contains__
for i in block_set:
assert i in block
# Check attributes and subblocks of each data object
for i, b in block.items():
assert b.mod is model_map[i]
assert b.time is time_map[i]
assert all(i1 is i2 for i1, i2 in zip(b._inputs, inputs_map[i]))
assert all(i1 is i2 for i1, i2 in
zip(b._measurements, measurements_map[i]))
assert hasattr(b, 'category_dict')
assert hasattr(b, 'vardata_map')
assert hasattr(b, 'measurement_vars')
assert hasattr(b, 'differential_vars')
assert hasattr(b, 'algebraic_vars')
assert hasattr(b, 'derivative_vars')
assert hasattr(b, 'input_vars')
assert hasattr(b, 'fixed_vars')
subblocks = [
b.mod,
b.vectors,
b.DIFFERENTIAL_BLOCK,
b.ALGEBRAIC_BLOCK,
b.INPUT_BLOCK,
b.FIXED_BLOCK,
b.DERIVATIVE_BLOCK,
b.MEASUREMENT_BLOCK,
]
block_objects = ComponentSet(
b.component_objects(pyo.Block, descend_into=False))
assert len(subblocks) == len(block_objects)
for sb in subblocks:
assert sb in block_objects
b.v = pyo.Var(initialize=3)
b.c = pyo.Constraint(expr=b.v==5)
assert b.v.value == 3
assert b.v in ComponentSet(identify_variables(b.c.expr))