def test_category_blocks(self):
m = make_small_model()
time = m.time
t0 = time.first()
helper = DynamicBlock(
model=m,
time=time,
inputs=[m.flow_in[0]],
measurements=[m.conc[0,'A'], m.conc[0,'B']],
)
helper.construct()
# Test that NmpcVectors and category blocks behave
# as we expect
diff_vars = helper.vectors.differential
diff_var_set = helper.DIFFERENTIAL_SET*m.time
assert diff_vars.index_set() == diff_var_set
# And that they contain the same variables as the corresponding
# lists on our helper block.
for b, v in zip(helper.DIFFERENTIAL_BLOCK.values(),
helper.differential_vars):
assert b.var is v
helper.vectors.derivative.set_setpoint(0.0)
for var in helper.DERIVATIVE_BLOCK[:].var:
assert var.setpoint == 0.
for b, v in zip(helper.DERIVATIVE_BLOCK.values(),
helper.derivative_vars):
assert b.var is v
sp = [1,2,3]
helper.vectors.algebraic.set_setpoint(sp)
for i,j in zip(helper.ALGEBRAIC_SET, sp):
assert helper.ALGEBRAIC_BLOCK[i].var.setpoint == j
alg_vars = list(helper.component_objects(AlgVar))
pred_alg_vars = ComponentSet((
m.flow_out[t0],
m.rate[t0,'A'],
m.rate[t0,'B'],
))
assert len(pred_alg_vars) == len(alg_vars)
for var in alg_vars:
assert var[t0] in pred_alg_vars
for b, v in zip(helper.ALGEBRAIC_BLOCK.values(),
helper.algebraic_vars):
assert b.var is v
assert list(helper.vectors.algebraic.get_setpoint()) == sp
vals = (10, 11)
diff_vars.values = vals
for var, val in zip(helper.DIFFERENTIAL_BLOCK[:].var, vals):
for v in var[:]:
assert v.value == val
_slice = helper.DIFFERENTIAL_BLOCK[:].var
diff_var_vals = diff_vars.values
for var, vals in zip(_slice, diff_var_vals):
for v, vl in zip(var[:], vals):
assert v.value == vl
def test_init_simple(self):
model = make_model(horizon=1, nfe=2)
time = model.time
t0 = time.first()
inputs = [model.flow_in[t0]]
measurements = [model.conc[0,'A'], model.conc[0,'B']]
block = DynamicBlock(
model=model,
time=time,
inputs=inputs,
measurements=measurements,
)
# Assert that we have the correct type
assert type(block) is SimpleDynamicBlock
assert isinstance(block, DynamicBlock)
assert isinstance(block, _DynamicBlockData)
block.construct()
# Assert that we behave like a simple block
assert block[None] is block
assert all(b is block for b in block[:])
# Assert that input attributes have been processed correctly
assert block.mod is model
assert block.time is time
assert all(i1 is i2 for i1, i2 in zip(block._inputs, inputs))
assert all(i1 is i2 for i1, i2 in zip(block._measurements, measurements))
# Assert that utility attributes have been added
assert hasattr(block, 'category_dict')
assert hasattr(block, 'vardata_map')
assert hasattr(block, 'measurement_vars')
assert hasattr(block, 'differential_vars')
assert hasattr(block, 'algebraic_vars')
assert hasattr(block, 'derivative_vars')
assert hasattr(block, 'input_vars')
assert hasattr(block, 'fixed_vars')
subblocks = [
block.mod,
block.vectors,
block.DIFFERENTIAL_BLOCK,
block.ALGEBRAIC_BLOCK,
block.INPUT_BLOCK,
block.FIXED_BLOCK,
block.DERIVATIVE_BLOCK,
block.MEASUREMENT_BLOCK,
]
block_objects = ComponentSet(
block.component_objects(pyo.Block, descend_into=False))
# Assert that subblocks have been added
assert len(subblocks) == len(block_objects)
for b in subblocks:
assert b in block_objects
# Assert that we can add variables and constraints to the block
block.v = pyo.Var(initialize=3)
block.c = pyo.Constraint(expr=block.v==5)
assert block.v.value == 3
assert block.v in ComponentSet(identify_variables(block.c.expr))
def test_construct(self):
m = make_small_model()
time = m.time
t0 = time.first()
helper = DynamicBlock(
model=m,
time=time,
inputs=[m.flow_in[0]],
measurements=[m.conc[0,'A'], m.conc[0,'B']])
helper.construct()
assert hasattr(helper, 'category_dict')
assert hasattr(helper, 'vardata_map')
assert hasattr(helper, 'measurement_vars')
assert hasattr(helper, 'differential_vars')
assert hasattr(helper, 'algebraic_vars')
assert hasattr(helper, 'derivative_vars')
assert hasattr(helper, 'input_vars')
assert hasattr(helper, 'fixed_vars')
# Make sure category dict contains variables we expect
assert VariableCategory.DIFFERENTIAL in helper.category_dict
assert VariableCategory.ALGEBRAIC in helper.category_dict
assert VariableCategory.DERIVATIVE in helper.category_dict
assert VariableCategory.INPUT in helper.category_dict
assert VariableCategory.FIXED in helper.category_dict
pred_diff_vars = ComponentSet((
m.conc[t0,'A'],
m.conc[t0,'B'],
))
diff_vars = list(helper.component_objects(DiffVar))
assert len(pred_diff_vars) == len(diff_vars)
for var in diff_vars:
assert var[t0] in pred_diff_vars
pred_alg_vars = ComponentSet((
m.flow_out[t0],
m.rate[t0,'A'],
m.rate[t0,'B'],
))
alg_vars = list(helper.component_objects(AlgVar))
assert len(pred_alg_vars) == len(alg_vars)
for var in alg_vars:
assert var[t0] in pred_alg_vars
pred_input_vars = ComponentSet((
m.flow_in[t0],
))
input_vars = list(helper.component_objects(InputVar))
assert len(pred_input_vars) == len(input_vars)
for var in input_vars:
assert var[t0] in pred_input_vars
pred_fixed_vars = ComponentSet((
m.conc_in[t0,'A'],
m.conc_in[t0,'B'],
))
fixed_vars = list(helper.component_objects(FixedVar))
assert len(pred_fixed_vars) == len(fixed_vars)
for var in fixed_vars:
assert var[t0] in pred_fixed_vars
pred_deriv_vars = ComponentSet((
m.dcdt[t0,'A'],
m.dcdt[t0,'B'],
))
deriv_vars = list(helper.component_objects(DerivVar))
assert len(pred_deriv_vars) == len(deriv_vars)
for var in deriv_vars:
assert var[t0] in pred_deriv_vars