def test_initialize(self, model):
# Fix state
model.props[1].flow_mol.fix(1)
model.props[1].temperature.fix(85.00)
model.props[1].pressure.fix(101325)
model.props[1].mole_frac_comp["nitrogen"].fix(1 / 3)
model.props[1].mole_frac_comp["argon"].fix(1 / 3)
model.props[1].mole_frac_comp["oxygen"].fix(1 / 3)
assert degrees_of_freedom(model.props[1]) == 0
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
model.props.initialize(optarg={'tol': 1e-6})
assert degrees_of_freedom(model) == 0
fin_fixed_vars = fixed_variables_set(model)
fin_act_consts = activated_constraints_set(model)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def test_initialize(self, water_stoich):
m = water_stoich
orig_fixed_vars = fixed_variables_set(m)
orig_act_consts = activated_constraints_set(m)
# Manually fix the unknown inlet and force unfix the known outlets
# This customization is REQUIRED for StoichiometricReactor
# since IDAES assumes that inlets are knowns during a solve
m.fs.unit.inlet.mole_frac_comp[0, "Ca(OH)2"].fix(0.0000006)
m.fs.unit.outlet.mole_frac_comp[0, "Ca(OH)2"].unfix()
m.fs.unit.outlet.mole_frac_comp[0, "Ca(HCO3)2"].unfix()
m.fs.unit.outlet.mole_frac_comp[0, "Mg(HCO3)2"].unfix()
m.fs.unit.initialize(optarg=solver.options, outlvl=idaeslog.DEBUG)
# Undo the fixing we just did and return all values to there
# original states
m.fs.unit.outlet.mole_frac_comp[0, "Ca(OH)2"].fix(0.0000003)
m.fs.unit.inlet.mole_frac_comp[0, "Ca(OH)2"].unfix()
m.fs.unit.outlet.mole_frac_comp[0, "Ca(HCO3)2"].fix(0.000015)
m.fs.unit.outlet.mole_frac_comp[0, "Mg(HCO3)2"].fix(0.000015)
fin_fixed_vars = fixed_variables_set(m)
fin_act_consts = activated_constraints_set(m)
print(value(m.fs.unit.outlet.temperature[0]))
assert degrees_of_freedom(m) == 0
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
def test_initialize_state_block(model):
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
flags = model.fs.state.initialize(hold_state=True)
assert degrees_of_freedom(model) == 0
inter_fixed_vars = fixed_variables_set(model)
for v in inter_fixed_vars:
assert v.name in [
"fs.state[0].flow_mass_comp[H2O]",
"fs.state[0].flow_mass_comp[A]",
"fs.state[0].flow_mass_comp[B]",
"fs.state[0].flow_mass_comp[C]",
]
model.fs.state.release_state(flags)
fin_fixed_vars = fixed_variables_set(model)
fin_act_consts = activated_constraints_set(model)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def test_initialize_temperature(self, methane):
orig_fixed_vars = fixed_variables_set(methane)
orig_act_consts = activated_constraints_set(methane)
methane.fs.unit.initialize(optarg={'tol': 1e-6},
state_args={
'temperature': 2844.38,
'pressure': 101325.0,
'flow_mol': 251.05,
'mole_frac_comp': {
'CH4': 1e-5,
'CO': 0.0916,
'CO2': 0.0281,
'H2': 0.1155,
'H2O': 0.1633,
'N2': 0.5975,
'NH3': 1e-5,
'O2': 0.0067
}
})
assert degrees_of_freedom(methane) == 0
fin_fixed_vars = fixed_variables_set(methane)
fin_act_consts = activated_constraints_set(methane)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def test_initialize_duty(self, methane):
methane.fs.unit.outlet.temperature[0].unfix()
methane.fs.unit.heat_duty.fix(161882.303661)
assert degrees_of_freedom(methane) == 0
orig_fixed_vars = fixed_variables_set(methane)
orig_act_consts = activated_constraints_set(methane)
methane.fs.unit.initialize(
optarg={'tol': 1e-6},
state_args={'temperature': 2844.38,
'pressure': 101325.0,
'flow_mol_comp': {'CH4': 1e-5,
'CO': 23.0,
'CO2': 7.05,
'H2': 29.0,
'H2O': 41.0,
'N2': 150.0,
'NH3': 1e-5,
'O2': 1.0}})
assert degrees_of_freedom(methane) == 0
fin_fixed_vars = fixed_variables_set(methane)
fin_act_consts = activated_constraints_set(methane)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def test_initialize_equilibrium(self, equilibrium_reactions_config):
model = equilibrium_reactions_config
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
model.fs.unit.initialize(optarg=solver.options)
fin_fixed_vars = fixed_variables_set(model)
fin_act_consts = activated_constraints_set(model)
assert degrees_of_freedom(model) == 0
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
def test_initialize(self, chlorination_obj):
model = chlorination_obj
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
model.fs.unit.initialize(optarg=solver.options, outlvl=idaeslog.DEBUG)
fin_fixed_vars = fixed_variables_set(model)
fin_act_consts = activated_constraints_set(model)
assert degrees_of_freedom(model) == 0
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
def test_SFIL3(self, model):
model.props[1].flow_mol.fix(1)
model.props[1].temperature.fix(92.88)
model.props[1].pressure.fix(353140)
model.props[1].mole_frac_comp["nitrogen"].fix(0.6653)
model.props[1].mole_frac_comp["argon"].fix(0.0140)
model.props[1].mole_frac_comp["oxygen"].fix(0.3207)
assert degrees_of_freedom(model.props[1]) == 0
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
model.props.initialize(optarg={'tol': 1e-6})
assert degrees_of_freedom(model) == 0
results = solver.solve(model)
# Check for optimal solution
assert results.solver.termination_condition == \
TerminationCondition.optimal
assert results.solver.status == SolverStatus.ok
assert model.props[1].mole_frac_phase_comp["Liq", "nitrogen"].value == \
pytest.approx(0.6653, abs=1e-3)
assert model.props[1].phase_frac["Vap"].value == \
pytest.approx(0.0, abs=1e-3)
assert value(model.props[1].enth_mol_phase["Liq"]) == \
pytest.approx(-11662.4, abs=1e1)
def test_initialize(self, model):
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
model.props.initialize(hold_state=False)
fin_fixed_vars = fixed_variables_set(model)
fin_act_consts = activated_constraints_set(model)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def test_SF0(self, model):
model.props[1].flow_mol.fix(1)
model.props[1].temperature.fix(300.00)
model.props[1].pressure.fix(353140)
model.props[1].mole_frac_comp["nitrogen"].fix(0.7800)
model.props[1].mole_frac_comp["argon"].fix(0.0100)
model.props[1].mole_frac_comp["oxygen"].fix(0.2100)
assert degrees_of_freedom(model.props[1]) == 0
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
model.props.initialize(optarg={'tol': 1e-6})
assert degrees_of_freedom(model) == 0
results = solver.solve(model)
# Check for optimal solution
assert check_optimal_termination(results)
assert model.props[1].mole_frac_phase_comp["Vap", "nitrogen"].value == \
pytest.approx(0.7800, abs=1e-3)
assert model.props[1].phase_frac["Vap"].value == \
pytest.approx(1.0, abs=1e-3)
assert value(model.props[1].enth_mol_phase["Vap"]) == \
pytest.approx(25.7, abs=1e1)
def test_initialize(self, model):
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
model.props.initialize(optarg={'tol': 1e-6})
assert degrees_of_freedom(model) == 0
fin_fixed_vars = fixed_variables_set(model)
fin_act_consts = activated_constraints_set(model)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def test_initialize(self, sapon):
orig_fixed_vars = fixed_variables_set(sapon)
orig_act_consts = activated_constraints_set(sapon)
sapon.fs.unit.initialize(optarg={'tol': 1e-6})
assert degrees_of_freedom(sapon) == 0
fin_fixed_vars = fixed_variables_set(sapon)
fin_act_consts = activated_constraints_set(sapon)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def test_initialize(self, model):
# Fix state
model.props[1].flow_mol.fix(1)
model.props[1].temperature.fix(295.00)
model.props[1].pressure.fix(1e5)
model.props[1].mole_frac_comp["hydrogen"].fix(0.077)
model.props[1].mole_frac_comp["methane"].fix(0.077)
model.props[1].mole_frac_comp["ethane"].fix(0.077)
model.props[1].mole_frac_comp["propane"].fix(0.077)
model.props[1].mole_frac_comp["nbutane"].fix(0.077)
model.props[1].mole_frac_comp["ibutane"].fix(0.077)
model.props[1].mole_frac_comp["ethylene"].fix(0.077)
model.props[1].mole_frac_comp["propene"].fix(0.077)
model.props[1].mole_frac_comp["butene"].fix(0.077)
model.props[1].mole_frac_comp["pentene"].fix(0.077)
model.props[1].mole_frac_comp["hexene"].fix(0.077)
model.props[1].mole_frac_comp["heptene"].fix(0.077)
model.props[1].mole_frac_comp["octene"].fix(0.076)
assert degrees_of_freedom(model.props[1]) == 0
orig_fixed_vars = fixed_variables_set(model)
orig_act_consts = activated_constraints_set(model)
model.props.initialize(optarg={'tol': 1e-6})
assert degrees_of_freedom(model) == 0
fin_fixed_vars = fixed_variables_set(model)
fin_act_consts = activated_constraints_set(model)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def test_initialize(self, btx_ftpz, btx_fctp):
orig_fixed_vars = fixed_variables_set(btx_ftpz)
orig_act_consts = activated_constraints_set(btx_ftpz)
btx_ftpz.fs.unit.initialize(solver=solver)
assert degrees_of_freedom(btx_ftpz) == 0
fin_fixed_vars = fixed_variables_set(btx_ftpz)
fin_act_consts = activated_constraints_set(btx_ftpz)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
orig_fixed_vars = fixed_variables_set(btx_fctp)
orig_act_consts = activated_constraints_set(btx_fctp)
btx_fctp.fs.unit.initialize(solver=solver)
assert degrees_of_freedom(btx_fctp) == 0
fin_fixed_vars = fixed_variables_set(btx_fctp)
fin_act_consts = activated_constraints_set(btx_fctp)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
def initialization_tester(m, dof=0, unit=None, **init_kwargs):
"""
A method to test initialization methods on IDAES models. This method is
designed to be used as part of the tests for most models.
This method checks that the initialization methods runs as expceted
and that the state of the model (active/deactive and fixed/unfixed)
remains the same.
This method also add some dummy constraitns to the model and deactivates
them to make sure that the initialization does not affect their status.
Args:
m: a Concrete mdoel which contains a flowsheet and a model named unit
(i.e. m.fs.unit) which will be initialized
dof: expected degrees of freedom during initialization, default=0
unit: unit object to test, if None assume m.fs.unit, default='None'
init_kwargs: model specific arguments to pass to initialize method
(e.g. initial guesses for states)
Returns:
None
Raises:
AssertionErrors if an issue is found
"""
if unit is None:
unit = m.fs.unit
# Add some extra constraints and deactivate them to make sure
# they remain deactivated
# Test both indexed and unindexed constraints
unit.__dummy_var = Var()
unit.__dummy_equality = Constraint(expr=unit.__dummy_var == 5)
unit.__dummy_inequality = Constraint(expr=unit.__dummy_var <= 10)
def deq_idx(b, i):
return unit.__dummy_var == 5
unit.__dummy_equality_idx = Constraint([1], rule=deq_idx)
def dieq_idx(b, i):
return unit.__dummy_var <= 10
unit.__dummy_inequality_idx = Constraint([1], rule=dieq_idx)
unit.__dummy_equality.deactivate()
unit.__dummy_inequality.deactivate()
unit.__dummy_equality_idx[1].deactivate()
unit.__dummy_inequality_idx[1].deactivate()
orig_fixed_vars = fixed_variables_set(m)
orig_act_consts = activated_constraints_set(m)
unit.initialize(**init_kwargs)
print(degrees_of_freedom(m))
assert degrees_of_freedom(m) == dof
fin_fixed_vars = fixed_variables_set(m)
fin_act_consts = activated_constraints_set(m)
assert len(fin_act_consts) == len(orig_act_consts)
assert len(fin_fixed_vars) == len(orig_fixed_vars)
for c in fin_act_consts:
assert c in orig_act_consts
for v in fin_fixed_vars:
assert v in orig_fixed_vars
# Check dummy constraints and clean up
assert not unit.__dummy_equality.active
assert not unit.__dummy_inequality.active
assert not unit.__dummy_equality_idx[1].active
assert not unit.__dummy_inequality_idx[1].active
unit.del_component(unit.__dummy_inequality)
unit.del_component(unit.__dummy_equality)
unit.del_component(unit.__dummy_inequality_idx)
unit.del_component(unit.__dummy_equality_idx)
unit.del_component(unit.__dummy_var)
def _collect_data_to_check(m):
return {
fixed_variables_set: fixed_variables_set(m),
activated_constraints_set: activated_constraints_set(m)
}
