def test_revert_state_vars_fixed_guesses(model): # Note that flow_mol_phase_comp is labled as compoennt_flow # in define_state_vars model.fs.sb.flow_mol_phase_comp["p1", "c1"].fix(10) model.fs.sb.pressure.fix(1.5e5) state_args = { "component_flow_phase": { ("p1", "c1"): 1, ("p1", "c2"): 2, ("p2", "c1"): 3, ("p2", "c2"): 4 }, "pressure": 2e5, "temperature": 500 } flags = fix_state_vars(model.fs.sb, state_args) revert_state_vars(model.fs.sb, flags) # Pressure and componet_flow[p1, c1] should still be fixed assert model.fs.sb.flow_mol_phase_comp[("p1", "c1")].fixed assert model.fs.sb.flow_mol_phase_comp[("p1", "c1")].value == 10 assert not model.fs.sb.flow_mol_phase_comp[("p1", "c2")].fixed assert model.fs.sb.flow_mol_phase_comp[("p1", "c2")].value == 2 assert not model.fs.sb.flow_mol_phase_comp[("p2", "c1")].fixed assert model.fs.sb.flow_mol_phase_comp[("p2", "c1")].value == 3 assert not model.fs.sb.flow_mol_phase_comp[("p2", "c2")].fixed assert model.fs.sb.flow_mol_phase_comp[("p2", "c2")].value == 4 assert model.fs.sb.pressure.fixed assert model.fs.sb.pressure.value == 1.5e5 assert not model.fs.sb.temperature.fixed assert model.fs.sb.temperature.value == 500
def test_revert_state_vars_guesses(model): # Note that flow_mol_phase_comp is labled as compoennt_flow # in define_state_vars state_args = { "component_flow_phase": { ("p1", "c1"): 1, ("p1", "c2"): 2, ("p2", "c1"): 3, ("p2", "c2"): 4 }, "pressure": 2e5, "temperature": 500 } flags = fix_state_vars(model.fs.sb, state_args) revert_state_vars(model.fs.sb, flags) assert not model.fs.sb.flow_mol_phase_comp[("p1", "c1")].fixed assert model.fs.sb.flow_mol_phase_comp[("p1", "c1")].value == 1 assert not model.fs.sb.flow_mol_phase_comp[("p1", "c2")].fixed assert model.fs.sb.flow_mol_phase_comp[("p1", "c2")].value == 2 assert not model.fs.sb.flow_mol_phase_comp[("p2", "c1")].fixed assert model.fs.sb.flow_mol_phase_comp[("p2", "c1")].value == 3 assert not model.fs.sb.flow_mol_phase_comp[("p2", "c2")].fixed assert model.fs.sb.flow_mol_phase_comp[("p2", "c2")].value == 4 assert not model.fs.sb.pressure.fixed assert model.fs.sb.pressure.value == 2e5 assert not model.fs.sb.temperature.fixed assert model.fs.sb.temperature.value == 500
def calculate_chemical_scaling_factors(unit, thermo_params, rxn_params, state_args, output_jac=False): calculate_chemical_scaling_factors_for_equilibrium_log_reactions(unit, rxn_params) calculate_chemical_scaling_factors_for_energy_balances(unit) calculate_chemical_scaling_factors_for_material_balances(unit) flags = fix_state_vars(unit.control_volume.properties_out, state_args) revert_state_vars(unit.control_volume.properties_out, flags)
def release_state(blk, flags, outlvl=idaeslog.NOTSET): # Method to release states only if explicitly called if flags is None: return # Unfix state variables revert_state_vars(blk, flags) init_log.info('State Released.')
def test_revert_state_vars_flag_mismatch(model): flags = {(None, 'component_flow_phase', ('p1', 'c1')): False, (None, 'component_flow_phase', ('p1', 'c2')): False, (None, 'component_flow_phase', ('p2', 'c1')): False, (None, 'pressure', None): False} with pytest.raises(ConfigurationError): revert_state_vars(model.fs.sb, flags)
def initialize(blk, state_args_water_steam={}, outlvl=0, solver='ipopt', optarg={'tol': 1e-6}): ''' Drum initialization routine. Keyword Arguments: state_args : a dict of arguments to be passed to the property package(s) for the control_volume of the model to provide an initial state for initialization (see documentation of the specific property package) (default = None). outlvl : sets output level of initialisation routine * 0 = no output (default) * 1 = return solver state for each step in routine * 2 = return solver state for each step in subroutines * 3 = include solver output infomation (tee=True) optarg : solver options dictionary object (default={'tol': 1e-6}) solver : str indicating whcih solver to use during initialization (default = 'ipopt') Returns: None ''' init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit") solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit") opt = SolverFactory(solver) opt.options = optarg init_log.info_low("Starting initialization...") # fix FeedWater Inlet flags_fw = fix_state_vars(blk.mixed_state, state_args_water_steam) blk.mixed_state.initialize() # initialize outlet states for t in blk.flowsheet().config.time: blk.vap_state[t].flow_mol = value(blk.mixed_state[t].flow_mol * blk.mixed_state[t].vapor_frac) blk.vap_state[t].enth_mol = value( blk.mixed_state[t].enth_mol_phase["Vap"]) blk.vap_state[t].pressure = value(blk.mixed_state[t].pressure) blk.vap_state[t].vapor_frac = 1 blk.liq_state[t].flow_mol = value( blk.mixed_state[t].flow_mol * (1 - blk.mixed_state[t].vapor_frac)) blk.liq_state[t].enth_mol = value( blk.mixed_state[t].enth_mol_phase["Liq"]) blk.liq_state[t].pressure = value(blk.mixed_state[t].pressure) blk.liq_state[t].vapor_frac = 0 # unfix variables revert_state_vars(blk.mixed_state, flags_fw) init_log.info_low("Initialization Complete.")
def test_revert_state_vars_basic(model): flags = fix_state_vars(model.fs.sb) revert_state_vars(model.fs.sb, flags) for i in model.fs.sb.flow_mol_phase_comp: assert not model.fs.sb.flow_mol_phase_comp[i].fixed assert model.fs.sb.flow_mol_phase_comp[i].value == 2 assert not model.fs.sb.pressure.fixed assert model.fs.sb.pressure.value == 1e5 assert not model.fs.sb.temperature.fixed assert model.fs.sb.temperature.value == 300
def release_state(blk, flags, outlvl=idaeslog.NOTSET): ''' Method to relase state variables fixed during initialization. Keyword Arguments: flags : dict containing information of which state variables were fixed during initialization, and should now be unfixed. This dict is returned by initialize if hold_state=True. outlvl : sets output level of initialization routine ''' revert_state_vars(blk, flags) init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties") init_log.info_high("State released.")
def initialize_system(m): prtrt = m.fs.pretreatment desal = m.fs.desalination psttrt = m.fs.posttreatment # initialize feed solve(m.fs.feed) # initialize pretreatment propagate_state(m.fs.s_feed) flags = fix_state_vars(prtrt.intake.properties) solve(prtrt) revert_state_vars(prtrt.intake.properties, flags) # initialize desalination propagate_state(m.fs.s_prtrt_tb) m.fs.tb_prtrt_desal.properties_out[0].flow_mass_phase_comp["Liq", "H2O"] = value( m.fs.tb_prtrt_desal.properties_in[0].flow_mass_comp["H2O"] ) m.fs.tb_prtrt_desal.properties_out[0].flow_mass_phase_comp["Liq", "TDS"] = value( m.fs.tb_prtrt_desal.properties_in[0].flow_mass_comp["tds"] ) desal.RO.feed_side.properties_in[0].flow_mass_phase_comp["Liq", "H2O"] = value( m.fs.feed.properties[0].flow_mass_comp["H2O"] ) desal.RO.feed_side.properties_in[0].flow_mass_phase_comp["Liq", "TDS"] = value( m.fs.feed.properties[0].flow_mass_comp["tds"] ) desal.RO.feed_side.properties_in[0].temperature = value( m.fs.tb_prtrt_desal.properties_out[0].temperature ) desal.RO.feed_side.properties_in[0].pressure = value( desal.P1.control_volume.properties_out[0].pressure ) desal.RO.initialize() propagate_state(m.fs.s_tb_desal) if m.erd_type == "pressure_exchanger": flags = fix_state_vars(desal.S1.mixed_state) solve(desal) revert_state_vars(desal.S1.mixed_state, flags) elif m.erd_type == "pump_as_turbine": flags = fix_state_vars(desal.P1.control_volume.properties_in) solve(desal) revert_state_vars(desal.P1.control_volume.properties_in, flags) # initialize posttreatment propagate_state(m.fs.s_desal_tb) m.fs.tb_desal_psttrt.properties_out[0].flow_mass_comp["H2O"] = value( m.fs.tb_desal_psttrt.properties_in[0].flow_mass_phase_comp["Liq", "H2O"] ) m.fs.tb_desal_psttrt.properties_out[0].flow_mass_comp["tds"] = value( m.fs.tb_desal_psttrt.properties_in[0].flow_mass_phase_comp["Liq", "TDS"] ) propagate_state(m.fs.s_tb_psttrt) flags = fix_state_vars(psttrt.storage_tank_2.properties) solve(psttrt) revert_state_vars(psttrt.storage_tank_2.properties, flags)
def release_state(self, flags, outlvl=idaeslog.NOTSET): """ Method to release state variables fixed during initialisation. Keyword Arguments: flags : dict containing information of which state variables were fixed during initialization, and should now be unfixed. This dict is returned by initialize if hold_state=True. outlvl : sets output level of of logging """ # Unfix state variables init_log = idaeslog.getInitLogger(self.name, outlvl, tag="properties") revert_state_vars(self, flags) init_log.info_high("{} State Released.".format(self.name))
def initialize(blk, state_args_water_steam=None, outlvl=idaeslog.NOTSET, solver=None, optarg=None): ''' Drum initialization routine. Keyword Arguments: state_args_water_steam : a dict of arguments to be passed to the property package(s) for the control_volume of the model to provide an initial state for initialization (see documentation of the specific property package) (default = None). outlvl : sets output level of initialisation routine optarg : solver options dictionary object (default=None, use default solver options) solver : str indicating which solver to use during initialization (default = None, use default solver) Returns: None ''' init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit") init_log.info_low("Starting initialization...") # fix FeedWater Inlet flags_fw = fix_state_vars(blk.mixed_state, state_args_water_steam) blk.mixed_state.initialize(solver=solver, optarg=optarg, outlvl=outlvl) # initialize outlet states for t in blk.flowsheet().time: blk.vap_state[t].flow_mol = value(blk.mixed_state[t].flow_mol * blk.mixed_state[t].vapor_frac) blk.vap_state[t].enth_mol = value( blk.mixed_state[t].enth_mol_phase["Vap"]) blk.vap_state[t].pressure = value(blk.mixed_state[t].pressure) blk.vap_state[t].vapor_frac = 1 blk.liq_state[t].flow_mol = value( blk.mixed_state[t].flow_mol * (1 - blk.mixed_state[t].vapor_frac)) blk.liq_state[t].enth_mol = value( blk.mixed_state[t].enth_mol_phase["Liq"]) blk.liq_state[t].pressure = value(blk.mixed_state[t].pressure) blk.liq_state[t].vapor_frac = 0 # unfix variables revert_state_vars(blk.mixed_state, flags_fw) init_log.info_low("Initialization Complete.")
def release_state(blk, flags, outlvl=0): ''' Method to relase state variables fixed during initialisation. Keyword Arguments: flags : dict containing information of which state variables were fixed during initialization, and should now be unfixed. This dict is returned by initialize if hold_state=True. outlvl : sets output level of of logging ''' # Unfix state variables revert_state_vars(blk, flags) if outlvl > 0: if outlvl > 0: _log.info('{} State Released.'.format(blk.name))
def release_state(blk, flags, outlvl=0): ''' Method to relase state variables fixed during initialization. Keyword Arguments: flags : dict containing information of which state variables were fixed during initialization, and should now be unfixed. This dict is returned by initialize if hold_state=True. outlvl : sets output level of of logging ''' init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties") if flags is None: init_log.debug("No flags passed to release_state().") return # Unfix state variables revert_state_vars(blk, flags) init_log.info_high("State Released.")
def release_state(blk, flags, outlvl=idaeslog.NOTSET): ''' Method to release state variables fixed during initialization. Keyword Arguments: flags : dict containing information of which state variables were fixed during initialization, and should now be unfixed. This dict is returned by initialize if hold_state=True. outlvl : sets output level of of logging ''' init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties") # Reactivate sum of mole fractions constraint for k in blk.keys(): if blk[k].config.defined_state is False: blk[k].mole_fraction_constraint.activate() if flags is not None: # Unfix state variables revert_state_vars(blk, flags) init_log.info_high("State Released.")
def calculate_RO_area(unit=None, water_recovery=0.5, solver=None): """ determine RO membrane area required to achieve the specified water recovery: unit: the RO unit model, e.g. m.fs.RO, it should have its inlet feed state block initiated to the correct values (default=None) water_recovery: the mass-based fraction of inlet H2O that becomes permeate (default=0.5) solver: solver object to be used (default=None) """ # fix inlet conditions flags = fix_state_vars(unit.feed_side.properties_in) # fix unit water recovery unit.feed_side.properties_out[0].flow_mass_phase_comp['Liq', 'H2O'].fix( unit.feed_side.properties_in[0].flow_mass_phase_comp['Liq', 'H2O'].value * (1 - water_recovery)) # solve for unit area check_dof(unit) solve(unit, solver=solver) # unfix variables revert_state_vars(unit.feed_side.properties_in, flags) unit.feed_side.properties_out[0].flow_mass_phase_comp['Liq', 'H2O'].unfix() return unit.area.value
def test_revert_state_vars_fixed_no_guesses(model): # Note that flow_mol_phase_comp is labled as compoennt_flow # in define_state_vars model.fs.sb.flow_mol_phase_comp["p1", "c1"].fix(10) model.fs.sb.pressure.fix(1.5e5) flags = fix_state_vars(model.fs.sb) revert_state_vars(model.fs.sb, flags) # Pressure and componet_flow[p1, c1] should still be fixed assert model.fs.sb.flow_mol_phase_comp[("p1", "c1")].fixed assert model.fs.sb.flow_mol_phase_comp[("p1", "c1")].value == 10 assert not model.fs.sb.flow_mol_phase_comp[("p1", "c2")].fixed assert model.fs.sb.flow_mol_phase_comp[("p1", "c2")].value == 2 assert not model.fs.sb.flow_mol_phase_comp[("p2", "c1")].fixed assert model.fs.sb.flow_mol_phase_comp[("p2", "c1")].value == 2 assert not model.fs.sb.flow_mol_phase_comp[("p2", "c2")].fixed assert model.fs.sb.flow_mol_phase_comp[("p2", "c2")].value == 2 assert model.fs.sb.pressure.fixed assert model.fs.sb.pressure.value == 1.5e5 assert not model.fs.sb.temperature.fixed assert model.fs.sb.temperature.value == 300
def release_state(blk, flags, outlvl=idaeslog.NOTSET): """ Method to relase state variables fixed during initialization. Keyword Arguments: flags : dict containing information of which state variables were fixed during initialization, and should now be unfixed. This dict is returned by initialize if hold_state=True. outlvl : sets output level of of logging """ if flags is None: return # Unfix state variables revert_state_vars(blk, flags) # Activate state variable related constraints for k in blk.keys(): if blk[k].config.defined_state is False: blk[k].sum_component_eqn.activate() init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties") init_log.info_high('States released.')
def release_state(blk, flags, outlvl=idaeslog.NOTSET): ''' Method to relase state variables fixed during initialization. Keyword Arguments: flags : dict containing information of which state variables were fixed during initialization, and should now be unfixed. This dict is returned by initialize if hold_state=True. outlvl : sets output level of of logging ''' init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties") # Reactivate conc_water_eqn for k in blk.keys(): if not blk[k].config.defined_state: blk[k].conc_water_eqn.activate() if flags is None: return # Unfix state variables revert_state_vars(blk, flags) init_log.info('State Released.')
def run_case2(xA, xB, xAB=1e-25, scaling=True, rxn_config=None, state="FpcTP"): print("==========================================================================") print( "Case 2 (log form): A and B are aqueous, AB is solid that forms from reaction" ) print("xA = " + str(xA)) print("xB = " + str(xB)) print("xAB = " + str(xAB)) print("scaling = " + str(scaling)) print("including water = " + str(True)) print() model = ConcreteModel() model.fs = FlowsheetBlock(default={"dynamic": False}) if state == "FpcTP": case1_thermo_config["state_definition"] = FpcTP elif state == "FTPx": case1_thermo_config["state_definition"] = FTPx case1_thermo_config["state_bounds"]["flow_mol"] = (0, 50, 100) else: print("Error! Undefined state...") assert False model.fs.thermo_params = GenericParameterBlock(default=case1_thermo_config) model.fs.rxn_params = GenericReactionParameterBlock( default={"property_package": model.fs.thermo_params, **rxn_config} ) model.fs.unit = EquilibriumReactor( default={ "property_package": model.fs.thermo_params, "reaction_package": model.fs.rxn_params, "has_rate_reactions": False, "has_equilibrium_reactions": True, "has_heat_transfer": False, "has_heat_of_reaction": False, "has_pressure_change": False, "energy_balance_type": EnergyBalanceType.none, } ) total_flow_mol = 10 # Set flow_mol_phase_comp if case1_thermo_config["state_definition"] == FpcTP: model.fs.unit.inlet.flow_mol_phase_comp[0, "Liq", "A"].fix(xA * total_flow_mol) model.fs.unit.inlet.flow_mol_phase_comp[0, "Liq", "B"].fix(xB * total_flow_mol) model.fs.unit.inlet.flow_mol_phase_comp[0, "Sol", "AB"].fix( xAB * total_flow_mol ) model.fs.unit.inlet.flow_mol_phase_comp[0, "Liq", "H2O"].fix( (1 - xA - xB - xAB) * total_flow_mol ) if case1_thermo_config["state_definition"] == FTPx: model.fs.unit.inlet.mole_frac_comp[0, "A"].fix(xA) model.fs.unit.inlet.mole_frac_comp[0, "B"].fix(xB) model.fs.unit.inlet.mole_frac_comp[0, "AB"].fix(xAB) model.fs.unit.inlet.mole_frac_comp[0, "H2O"].fix((1 - xA - xB - xAB)) model.fs.unit.inlet.flow_mol.fix(total_flow_mol) model.fs.unit.inlet.pressure.fix(101325.0) model.fs.unit.inlet.temperature.fix(298.0) model.fs.unit.outlet.temperature.fix(298.0) assert degrees_of_freedom(model) == 0 assert_units_consistent(model) # Scaling _set_eps_vals(model.fs.rxn_params, rxn_config) _set_equ_rxn_scaling(model.fs.unit, rxn_config) if case1_thermo_config["state_definition"] == FpcTP: _set_mat_bal_scaling_FpcTP(model.fs.unit) if case1_thermo_config["state_definition"] == FTPx: _set_mat_bal_scaling_FTPx(model.fs.unit) iscale.calculate_scaling_factors(model.fs.unit) assert isinstance(model.fs.unit.control_volume.scaling_factor, Suffix) # Initialize model if case1_thermo_config["state_definition"] == FpcTP: state_args = { "flow_mol_phase_comp": { ("Liq", "H2O"): model.fs.unit.inlet.flow_mol_phase_comp[ 0, "Liq", "H2O" ].value, ("Liq", "A"): model.fs.unit.inlet.flow_mol_phase_comp[ 0, "Liq", "A" ].value, ("Liq", "B"): model.fs.unit.inlet.flow_mol_phase_comp[ 0, "Liq", "B" ].value, ("Sol", "AB"): model.fs.unit.inlet.flow_mol_phase_comp[ 0, "Sol", "AB" ].value, }, "pressure": 101325, "temperature": 298, "flow_mol": 10, } if case1_thermo_config["state_definition"] == FTPx: state_args = { "mole_frac_comp": { "H2O": model.fs.unit.inlet.mole_frac_comp[0, "H2O"].value, "A": model.fs.unit.inlet.mole_frac_comp[0, "A"].value, "B": model.fs.unit.inlet.mole_frac_comp[0, "B"].value, "AB": model.fs.unit.inlet.mole_frac_comp[0, "AB"].value, }, "pressure": 101325, "temperature": 298, "flow_mol": 10, } flags = fix_state_vars(model.fs.unit.control_volume.properties_out, state_args) revert_state_vars(model.fs.unit.control_volume.properties_out, flags) model.fs.unit.initialize(optarg=solver.options, outlvl=idaeslog.DEBUG) assert degrees_of_freedom(model) == 0 results = solver.solve(model, tee=True) assert results.solver.termination_condition == TerminationCondition.optimal assert results.solver.status == SolverStatus.ok print("comp\toutlet.tot_molfrac") for i in model.fs.unit.control_volume.properties_out[0.0].mole_frac_comp: print( str(i) + "\t" + str( value( model.fs.unit.control_volume.properties_out[0.0].mole_frac_comp[i] ) ) ) print() # NOTE: Changed all to mole fraction for i in model.fs.unit.control_volume.properties_out[0.0].mole_frac_phase_comp: print( str(i) + "\t" + str( value( model.fs.unit.control_volume.properties_out[ 0.0 ].mole_frac_phase_comp[i] ) ) ) A = value( model.fs.unit.control_volume.properties_out[0.0].mole_frac_phase_comp[ "Liq", "A" ] ) B = value( model.fs.unit.control_volume.properties_out[0.0].mole_frac_phase_comp[ "Liq", "B" ] ) Ksp = value(model.fs.unit.control_volume.reactions[0.0].k_eq["AB_Ksp"].expr) print() if Ksp * 1.01 >= A * B: print("Constraint is satisfied!") else: print("Constraint is VIOLATED!") print("\tRelative error: " + str(Ksp / A / B) + ">=1") assert False print("Ksp =\t" + str(Ksp)) print("A*B =\t" + str(A * B)) print("==========================================================================") return model
def initialize(blk, state_args_feedwater={}, state_args_water_steam={}, outlvl=idaeslog.NOTSET, solver='ipopt', optarg={'tol': 1e-6}): ''' Drum initialization routine. Keyword Arguments: state_args : a dict of arguments to be passed to the property package(s) for the control_volume of the model to provide an initial state for initialization (see documentation of the specific property package) (default = None). outlvl : sets output level of initialisation routine * 0 = no output (default) * 1 = return solver state for each step in routine * 2 = return solver state for each step in subroutines * 3 = include solver output infomation (tee=True) optarg : solver options dictionary object (default={'tol': 1e-6}) solver : str indicating whcih solver to use during initialization (default = 'ipopt') Returns: None ''' init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit") solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit") opt = SolverFactory(solver) opt.options = optarg init_log.info_low("Starting initialization...") # fix FeedWater Inlet flags_fw = fix_state_vars(blk.mixer.FeedWater_state, state_args_feedwater) # expecting 2 DOF due to pressure driven constraint if degrees_of_freedom(blk) != 2: raise Exception(degrees_of_freedom(blk)) blk.flash.initialize(state_args_water_steam=state_args_water_steam, outlvl=outlvl, optarg=optarg, solver=solver) init_log.info("Initialization Step 1 Complete.") blk.mixer.SaturatedWater.flow_mol[:].fix(blk.flash.liq_outlet. flow_mol[0].value) blk.mixer.SaturatedWater.pressure[:].fix(blk.flash.liq_outlet. pressure[0].value) blk.mixer.SaturatedWater.enth_mol[:].fix(blk.flash.liq_outlet. enth_mol[0].value) blk.mixer.initialize(outlvl=outlvl, optarg=optarg, solver=solver) init_log.info("Initialization Step 2 Complete.") blk.control_volume.initialize(outlvl=outlvl, optarg=optarg, solver=solver, hold_state=False) init_log.info("Initialization Step 3 Complete.") # fix flash Inlet flags_steam = fix_state_vars(blk.flash.mixed_state, state_args_water_steam) # unfix inlets (connected with arc) blk.mixer.SaturatedWater.flow_mol[:].unfix() blk.mixer.SaturatedWater.enth_mol[:].unfix() blk.mixer.SaturatedWater.pressure[:].unfix() blk.mixer.FeedWater.pressure[0].unfix() # solve model with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc: res = opt.solve(blk, tee=slc.tee) init_log.info_high( "Initialization Step 4 {}.".format(idaeslog.condition(res)) ) revert_state_vars(blk.mixer.FeedWater_state, flags_fw) revert_state_vars(blk.flash.mixed_state, flags_steam) init_log.info("Initialization Complete.")
def initialize(blk, outlvl=idaeslog.NOTSET, optarg={}, solver=None): ''' Initialisation routine for reaction package. Keyword Arguments: outlvl : sets output level of initialization routine optarg : solver options dictionary object (default={}) solver : str indicating whcih solver to use during initialization (default = None, use default solver) Returns: None ''' init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="reactions") solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="reactions") init_log.info_high('Starting initialization') # TODO - Update in the future as needed # Get a single representative block for getting config arguments for k in blk.keys(): break # Fix state variables if not already fixed # Fix state variables of the primary (solid) state block state_var_flags = fix_state_vars(blk[k].config.solid_state_block) # Fix values of secondary (gas) state block variables if not fixed, # as well as the solid density variable. # This is done to keep the initialization problem square Cflag = {} # Gas concentration flag Dflag = {} # Solid density flag for k in blk.keys(): for j in blk[k]._params.gas_component_list: if blk[k].gas_state_ref.dens_mol_comp[j].fixed is True: Cflag[k, j] = True else: Cflag[k, j] = False blk[k].gas_state_ref.dens_mol_comp[j].fix( blk[k].gas_state_ref.dens_mol_comp[j].value) if blk[k].solid_state_ref.dens_mass_skeletal.fixed is True: Dflag[k] = True else: Dflag[k] = False blk[k].solid_state_ref.dens_mass_skeletal.fix( blk[k].solid_state_ref.dens_mass_skeletal.value) # Create solver opt = get_solver(solver, optarg) # Initialise values for k in blk.keys(): if hasattr(blk[k], "OC_conv_eqn"): calculate_variable_from_constraint(blk[k].OC_conv, blk[k].OC_conv_eqn) if hasattr(blk[k], "OC_conv_temp_eqn"): calculate_variable_from_constraint(blk[k].OC_conv_temp, blk[k].OC_conv_temp_eqn) for j in blk[k]._params.rate_reaction_idx: if hasattr(blk[k], "rate_constant_eqn"): calculate_variable_from_constraint( blk[k].k_rxn[j], blk[k].rate_constant_eqn[j]) if hasattr(blk[k], "gen_rate_expression"): calculate_variable_from_constraint( blk[k].reaction_rate[j], blk[k].gen_rate_expression[j]) # Solve property block if non-empty free_vars = 0 for k in blk.keys(): free_vars += number_unfixed_variables_in_activated_equalities( blk[k]) if free_vars > 0: with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc: res = solve_indexed_blocks(opt, [blk], tee=slc.tee) else: res = "" init_log.info_high("reactions initialization complete {}.".format( idaeslog.condition(res))) # --------------------------------------------------------------------- # Revert state vars and other variables to pre-initialization states # Revert state variables of the primary (solid) state block revert_state_vars(blk[k].config.solid_state_block, state_var_flags) for k in blk.keys(): for j in blk[k]._params.gas_component_list: if Cflag[k, j] is False: blk[k].gas_state_ref.dens_mol_comp[j].unfix() if Dflag[k] is False: blk[k].solid_state_ref.dens_mass_skeletal.unfix() init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="reactions") init_log.info_high('States released.')