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) }