def test_solve_indexed_block_IndexedBlock():
# Create an indexed block and try to solve it
m = ConcreteModel()
m.s = Set(initialize=[1, 2, 3])
def block_rule(b, x):
b.v = Var(initialize=1.0)
b.c = Constraint(expr=b.v == 2.0)
m.b = Block(m.s, rule=block_rule)
solve_indexed_blocks(solver=solver, blocks=m.b)
for i in m.s:
assert value(m.b[i].v == 2.0)
def calculate_operating_pressure(
feed_state_block=None,
over_pressure=0.15,
water_recovery=0.5,
NaCl_passage=0.01,
solver=None,
):
"""
estimate operating pressure for RO unit model given the following arguments:
Arguments:
feed_state_block: the state block of the RO feed that has the non-pressure state
variables initialized to their values (default=None)
over_pressure: the amount of operating pressure above the brine osmotic pressure
represented as a fraction (default=0.15)
water_recovery: the mass-based fraction of inlet H2O that becomes permeate
(default=0.5)
NaCl_passage: the mass-based fraction of inlet NaCl that becomes permeate
(default=0.01)
solver: solver object to be used (default=None)
"""
t = ConcreteModel() # create temporary model
prop = feed_state_block.config.parameters
t.brine = prop.build_state_block([0], default={})
# specify state block
t.brine[0].flow_mass_phase_comp["Liq", "H2O"].fix(
value(feed_state_block.flow_mass_phase_comp["Liq", "H2O"])
* (1 - water_recovery)
)
t.brine[0].flow_mass_phase_comp["Liq", "NaCl"].fix(
value(feed_state_block.flow_mass_phase_comp["Liq", "NaCl"]) * (1 - NaCl_passage)
)
t.brine[0].pressure.fix(
101325
) # valid when osmotic pressure is independent of hydraulic pressure
t.brine[0].temperature.fix(value(feed_state_block.temperature))
# calculate osmotic pressure
# since properties are created on demand, we must touch the property to create it
t.brine[0].pressure_osm
# solve state block
results = solve_indexed_blocks(solver, [t.brine])
assert_optimal_termination(results)
return value(t.brine[0].pressure_osm) * (1 + over_pressure)
def initialize(blk,
flow_mol=None,
mole_frac=None,
temperature=None,
pressure=None,
hold_state=False,
outlvl=0,
solver='ipopt',
optarg={'tol': 1e-8}):
"""
Initialisation routine for property package.
Keyword Arguments:
flow_mol_comp : value at which to initialize component flows
(default=None)
pressure : value at which to initialize pressure (default=None)
temperature : value at which to initialize temperature
(default=None)
outlvl : sets output level of initialisation routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default=None)
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
# Fix state variables if not already fixed
Fflag = {}
Xflag = {}
Pflag = {}
Tflag = {}
for k in blk.keys():
if blk[k].flow_mol.fixed is True:
Fflag[k] = True
else:
Fflag[k] = False
if flow_mol is None:
blk[k].flow_mol.fix(1.0)
else:
blk[k].flow_mol.fix(flow_mol)
for j in blk[k]._params.component_list:
if blk[k].mole_frac[j].fixed is True:
Xflag[k, j] = True
else:
Xflag[k, j] = False
if mole_frac is None:
blk[k].mole_frac[j].fix(
1 / len(blk[k]._params.component_list))
else:
blk[k].mole_frac[j].fix(mole_frac[j])
if blk[k].pressure.fixed is True:
Pflag[k] = True
else:
Pflag[k] = False
if pressure is None:
blk[k].pressure.fix(0.101325)
else:
blk[k].pressure.fix(pressure)
if blk[k].temperature.fixed is True:
Tflag[k] = True
else:
Tflag[k] = False
if temperature is None:
blk[k].temperature.fix(3.25)
else:
blk[k].temperature.fix(temperature)
# Set solver options
if outlvl > 1:
stee = True
else:
stee = False
if optarg is None:
sopt = {'tol': 1e-8}
else:
sopt = optarg
opt = SolverFactory('ipopt')
opt.options = sopt
# ---------------------------------------------------------------------
for k in blk.keys():
blk[k].eq_total.deactivate()
blk[k].eq_comp.deactivate()
if (blk[k].config.defined_state is False):
blk[k].eq_mol_frac_out.deactivate()
if (blk[k].config.has_phase_equilibrium) or \
(blk[k].config.parameters.config.valid_phase ==
('Liq', 'Vap')) or \
(blk[k].config.parameters.config.valid_phase ==
('Vap', 'Liq')):
blk[k].eq_Keq.deactivate()
blk[k].eq_sum_mol_frac.deactivate()
if (blk[k].config.has_phase_equilibrium) or \
(blk[k].config.parameters.config.valid_phase ==
('Liq', 'Vap')) or \
(blk[k].config.parameters.config.valid_phase ==
('Vap', 'Liq')):
results = solve_indexed_blocks(opt, [blk], tee=stee)
if outlvl > 0:
if results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info("Initialisation step 1 for "
"{} completed".format(blk.name))
else:
_log.warning("Initialisation step 1 for "
"{} failed".format(blk.name))
else:
if outlvl > 0:
_log.info("Initialisation step 1 for "
"{} skipped".format(blk.name))
for k in blk.keys():
blk[k].eq_total.activate()
blk[k].eq_comp.activate()
if (blk[k].config.has_phase_equilibrium) or \
(blk[k].config.parameters.config.valid_phase ==
('Liq', 'Vap')) or \
(blk[k].config.parameters.config.valid_phase ==
('Vap', 'Liq')):
blk[k].eq_Keq.activate()
blk[k].eq_sum_mol_frac.activate()
results = solve_indexed_blocks(opt, [blk], tee=stee)
if outlvl > 0:
if results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info("Initialisation step 2 for "
"{} completed".format(blk.name))
else:
_log.warning("Initialisation step 2 for "
"{} failed".format(blk.name))
for k in blk.keys():
if (blk[k].config.defined_state is False):
blk[k].eq_mol_frac_out.activate()
# ---------------------------------------------------------------------
# If input block, return flags, else release state
flags = {
"Fflag": Fflag,
"Xflag": Xflag,
"Pflag": Pflag,
"Tflag": Tflag
}
if hold_state is True:
return flags
else:
blk.release_state(flags)
if outlvl > 0:
if outlvl > 0:
_log.info('{} Initialisation Complete.'.format(blk.name))
def initialize(blk,
state_args=None,
hold_state=False,
state_vars_fixed=False,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None):
"""
Initialization routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered
through the control volume, and if initial guesses
were not provided at the unit model level, the
control volume passes the inlet values as initial
guess.
Keys for the state_args dictionary are:
flow_mass, temperature, and mass_frac_comp
outlvl : sets output level of initialization 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)
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="properties")
init_log.info_high('Starting initialization')
# Deactivate the constraints specific for outlet block i.e.
# when defined state is False
for k in blk.keys():
if blk[k].config.defined_state is False:
blk[k].sum_component_eqn.deactivate()
# Fix state variables if not already fixed
if state_vars_fixed is False:
flags = fix_state_vars(blk, state_args)
else:
# Check when the state vars are fixed already result in dof 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
# Create solver
opt = get_solver(solver, optarg)
# ---------------------------------------------------------------------
# Initialise values
for k in blk.keys():
if hasattr(blk[k], "density_skeletal_constraint"):
calculate_variable_from_constraint(
blk[k].dens_mass_skeletal,
blk[k].density_skeletal_constraint)
if hasattr(blk[k], "mixture_heat_capacity_eqn"):
calculate_variable_from_constraint(
blk[k].cp_mass, blk[k].mixture_heat_capacity_eqn)
if hasattr(blk[k], "mixture_enthalpy_eqn"):
calculate_variable_from_constraint(blk[k].enth_mass,
blk[k].mixture_enthalpy_eqn)
for j in blk[k]._params.component_list:
if hasattr(blk[k], "cp_shomate_eqn"):
calculate_variable_from_constraint(
blk[k].cp_mol_comp[j], blk[k].cp_shomate_eqn[j])
if hasattr(blk[k], "enthalpy_shomate_eqn"):
calculate_variable_from_constraint(
blk[k].enth_mol_comp[j],
blk[k].enthalpy_shomate_eqn[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("Initialization complete {}.".format(
idaeslog.condition(res)))
# ---------------------------------------------------------------------
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
blk.release_state(flags)
def initialize(blk, state_args=None,
state_vars_fixed=False,
hold_state=False, outlvl=idaeslog.NOTSET,
solver=None, optarg=None):
"""
Initialization routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered through
the control volume, and if initial guesses were not
provided at the unit model level, the control volume
passes the inlet values as initial guess.Keys for the
state_args dictionary are: flow_mol, temperature,
pressure and mole_frac_comp.
outlvl : sets output level of initialization routine
optarg : solver options dictionary object (default=None, use
default solver options)
solver : str indicating which solver to use during
initialization (default = None)
hold_state :
flag indicating whether the initialization routine
should unfix any state variables fixed during initialization
(default=False).
valid options:
True :
states varaibles are not unfixed, and a dict of returned
containing flags for which states were fixed during
initialization.
False :
state variables are unfixed after initialization by
calling the relase_state method
Returns:
If hold_states is True, returns a dict containing flags for which
states were fixed during initialization.
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="properties")
init_log.info('Starting Vapor phase properties initialization')
# Deactivate the constraints specific for non-inlet blocks i.e.
# when defined state is False
for k in blk.keys():
if blk[k].config.defined_state is False:
blk[k].sum_component_eqn.deactivate()
# Fix state variables if not already fixed
if state_vars_fixed is False:
flags = fix_state_vars(blk, state_args)
for k in blk.keys():
dof = degrees_of_freedom(blk[k])
if dof != 0:
raise RuntimeError(
"{} - degrees of freedom for state block is not zero "
"during initialization. DoF = {}".format(blk.name, dof))
# Create solver
opt = get_solver(solver, optarg)
# ---------------------------------------------------------------------
# Initialise values
for k in blk.keys():
for j in blk[k].component_list:
if hasattr(blk[k], "cp_mol_comp_eqn"):
calculate_variable_from_constraint(blk[k].cp_mol_comp[j],
blk[k].cp_mol_comp_eqn[j])
if hasattr(blk[k], "flow_mol_comp_eqn"):
calculate_variable_from_constraint(blk[k].flow_mol_comp[j],
blk[k].flow_mol_comp_eqn[j])
if hasattr(blk[k], "cp_mol_comp_mean_eqn"):
calculate_variable_from_constraint(blk[k].cp_mol_comp_mean[j],
blk[k].cp_mol_comp_mean_eqn[j])
if hasattr(blk[k], "cp_mol_eqn"):
calculate_variable_from_constraint(blk[k].cp_mol,
blk[k].cp_mol_eqn)
if hasattr(blk[k], "cp_mol_mean_eqn"):
calculate_variable_from_constraint(blk[k].cp_mol_mean,
blk[k].cp_mol_mean_eqn)
if hasattr(blk[k], "enth_mean_eqn"):
calculate_variable_from_constraint(blk[k].enth_mean,
blk[k].enth_mean_eqn)
# Solve property block if non-empty
free_vars = 0
for k in blk.keys():
free_vars += number_unfixed_variables(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("Vapor properties initialization complete {}.".format(
idaeslog.condition(res)))
# ----------------------------------------------------------------------
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
blk.release_state(flags)
def calculate_state(self,
var_args=None,
hold_state=False,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None):
"""
Solves state blocks given a set of variables and their values. These variables can
be state variables or properties. This method is typically used before
initialization to solve for state variables because non-state variables (i.e. properties)
cannot be fixed in initialization routines.
Keyword Arguments:
var_args : dictionary with variables and their values, they can be state variables or properties
{(VAR_NAME, INDEX): VALUE}
hold_state : flag indicating whether all of the state variables should be fixed after calculate state.
True - State variables will be fixed.
False - State variables will remain unfixed, unless already fixed.
outlvl : idaes logger object that sets output level of solve call (default=idaeslog.NOTSET)
solver : solver name string if None is provided the default solver
for IDAES will be used (default = None)
optarg : solver options dictionary object (default={})
Returns:
results object from state block solve
"""
# Get logger
solve_log = idaeslog.getSolveLogger(self.name,
level=outlvl,
tag="properties")
# Initialize at current state values (not user provided)
self.initialize(solver=solver, optarg=optarg, outlvl=outlvl)
# Set solver and options
opt = get_solver(solver, optarg)
# Fix variables and check degrees of freedom
flags = {
} # dictionary noting which variables were fixed and their previous state
for k in self.keys():
sb = self[k]
for (v_name, ind), val in var_args.items():
var = getattr(sb, v_name)
if iscale.get_scaling_factor(var[ind]) is None:
_log.warning(
"While using the calculate_state method on {sb_name}, variable {v_name} "
"was provided as an argument in var_args, but it does not have a scaling "
"factor. This suggests that the calculate_scaling_factor method has not been "
"used or the variable was created on demand after the scaling factors were "
"calculated. It is recommended to touch all relevant variables (i.e. call "
"them or set an initial value) before using the calculate_scaling_factor "
"method.".format(v_name=v_name, sb_name=sb.name))
if var[ind].is_fixed():
flags[(k, v_name, ind)] = True
if value(var[ind]) != val:
raise ConfigurationError(
"While using the calculate_state method on {sb_name}, {v_name} was "
"fixed to a value {val}, but it was already fixed to value {val_2}. "
"Unfix the variable before calling the calculate_state "
"method or update var_args."
"".format(sb_name=sb.name,
v_name=var.name,
val=val,
val_2=value(var[ind])))
else:
flags[(k, v_name, ind)] = False
var[ind].fix(val)
if degrees_of_freedom(sb) != 0:
raise RuntimeError(
"While using the calculate_state method on {sb_name}, the degrees "
"of freedom were {dof}, but 0 is required. Check var_args and ensure "
"the correct fixed variables are provided."
"".format(sb_name=sb.name, dof=degrees_of_freedom(sb)))
# Solve
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
results = solve_indexed_blocks(opt, [self], tee=slc.tee)
solve_log.info_high("Calculate state: {}.".format(
idaeslog.condition(results)))
if not check_optimal_termination(results):
_log.warning(
"While using the calculate_state method on {sb_name}, the solver failed "
"to converge to an optimal solution. This suggests that the user provided "
"infeasible inputs, or that the model is poorly scaled, poorly initialized, "
"or degenerate.")
# unfix all variables fixed with var_args
for (k, v_name, ind), previously_fixed in flags.items():
if not previously_fixed:
var = getattr(self[k], v_name)
var[ind].unfix()
# fix state variables if hold_state
if hold_state:
fix_state_vars(self)
return results
def initialize(
self,
state_args=None,
state_vars_fixed=False,
hold_state=False,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None,
):
"""
Initialization routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered
through the control volume, and if initial guesses
were not provided at the unit model level, the
control volume passes the inlet values as initial
guess.The keys for the state_args dictionary are:
flow_mass_phase_comp : value at which to initialize
phase component flows
pressure : value at which to initialize pressure
temperature : value at which to initialize temperature
outlvl : sets output level of initialization routine (default=idaeslog.NOTSET)
optarg : solver options dictionary object (default=None)
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
solver : Solver object to use during initialization if None is provided
it will use the default solver for IDAES (default = None)
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states variables are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
release_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
# Get loggers
init_log = idaeslog.getInitLogger(self.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(self.name,
outlvl,
tag="properties")
# Set solver and options
opt = get_solver(solver, optarg)
# Fix state variables
flags = fix_state_vars(self, state_args)
# Check when the state vars are fixed already result in dof 0
for k in self.keys():
dof = degrees_of_freedom(self[k])
if dof != 0:
raise PropertyPackageError(
"\nWhile initializing {sb_name}, the degrees of freedom "
"are {dof}, when zero is required. \nInitialization assumes "
"that the state variables should be fixed and that no other "
"variables are fixed. \nIf other properties have a "
"predetermined value, use the calculate_state method "
"before using initialize to determine the values for "
"the state variables and avoid fixing the property variables."
"".format(sb_name=self.name, dof=dof))
# ---------------------------------------------------------------------
skip_solve = True # skip solve if only state variables are present
for k in self.keys():
if number_unfixed_variables(self[k]) != 0:
skip_solve = False
if not skip_solve:
# Initialize properties
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
results = solve_indexed_blocks(opt, [self], tee=slc.tee)
init_log.info_high("Property initialization: {}.".format(
idaeslog.condition(results)))
# ---------------------------------------------------------------------
# If input block, return flags, else release state
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
self.release_state(flags)
def initialize(blk,
state_args=None,
state_vars_fixed=False,
hold_state=False,
outlvl=1,
solver='ipopt',
optarg={'tol': 1e-8}):
"""
Initialisation routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered
through the control volume, and if initial guesses
were not provied at the unit model level, the
control volume passes the inlet values as initial
guess.The keys for the state_args dictionary are:
flow_mol : value at which to initialize component
flows
pressure : value at which to initialize pressure
temperature : value at which to initialize temperature
mole_frac_comp: value at which to initialize the
component mixture mole fraction
outlvl : sets output level of initialisation routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default=None)
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
_log.info('Starting {} initialisation'.format(blk.name))
# Deactivate the constraints specific for outlet block i.e.
# when defined state is False
for k in blk.keys():
if blk[k].config.defined_state is False:
blk[k].sum_mole_frac_out.deactivate()
# Fix state variables if not already fixed
if state_vars_fixed is False:
Fflag = {}
Xflag = {}
Pflag = {}
Tflag = {}
for k in blk.keys():
if blk[k].flow_mol.fixed is True:
Fflag[k] = True
else:
Fflag[k] = False
if state_args is None:
blk[k].flow_mol.fix(1.0)
else:
blk[k].flow_mol.fix(state_args["flow_mol"])
for j in blk[k]._params.component_list:
if blk[k].mole_frac_comp[j].fixed is True:
Xflag[k, j] = True
else:
Xflag[k, j] = False
if state_args is None:
blk[k].mole_frac_comp[j].fix(
1 / len(blk[k]._params.component_list))
else:
blk[k].mole_frac_comp[j].fix(
state_args["mole_frac_comp"][j])
if blk[k].pressure.fixed is True:
Pflag[k] = True
else:
Pflag[k] = False
if state_args is None:
blk[k].pressure.fix(101325.0)
else:
blk[k].pressure.fix(state_args["pressure"])
if blk[k].temperature.fixed is True:
Tflag[k] = True
else:
Tflag[k] = False
if state_args is None:
blk[k].temperature.fix(325)
else:
blk[k].temperature.fix(state_args["temperature"])
# ---------------------------------------------------------------------
# If input block, return flags, else release state
flags = {
"Fflag": Fflag,
"Xflag": Xflag,
"Pflag": Pflag,
"Tflag": Tflag
}
else:
# Check when the state vars are fixed already result in dof 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
# Set solver options
if outlvl > 1:
stee = True
else:
stee = False
if optarg is None:
sopt = {'tol': 1e-8}
else:
sopt = optarg
opt = SolverFactory('ipopt')
opt.options = sopt
# ---------------------------------------------------------------------
# If present, initialize bubble and dew point calculations
for k in blk.keys():
if hasattr(blk[k], "eq_temperature_bubble"):
calculate_variable_from_constraint(
blk[k].temperature_bubble, blk[k].eq_temperature_bubble)
if hasattr(blk[k], "eq_temperature_dew"):
calculate_variable_from_constraint(blk[k].temperature_dew,
blk[k].eq_temperature_dew)
if hasattr(blk[k], "eq_pressure_bubble"):
calculate_variable_from_constraint(blk[k].pressure_bubble,
blk[k].eq_pressure_bubble)
if hasattr(blk[k], "eq_pressure_dew"):
calculate_variable_from_constraint(blk[k].pressure_dew,
blk[k].eq_pressure_dew)
if outlvl > 0:
_log.info("Dew and bubble points initialization for "
"{} completed".format(blk.name))
# ---------------------------------------------------------------------
# If flash, initialize T1 and Teq
for k in blk.keys():
if blk[k].config.has_phase_equilibrium:
blk[k]._t1.value = max(blk[k].temperature.value,
blk[k].temperature_bubble.value)
blk[k]._teq.value = min(blk[k]._t1.value,
blk[k].temperature_dew.value)
if outlvl > 0:
_log.info("Equilibrium temperature initialization for "
"{} completed".format(blk.name))
# ---------------------------------------------------------------------
# Initialize flow rates and compositions
# TODO : This will need ot be generalised more when we move to a
# modular implementation
for k in blk.keys():
if blk[k]._params.config.valid_phase == "Liq":
blk[k].flow_mol_phase['Liq'].value = \
blk[k].flow_mol.value
for j in blk[k]._params.component_list:
blk[k].mole_frac_phase_comp['Liq', j].value = \
blk[k].mole_frac_comp[j].value
elif blk[k]._params.config.valid_phase == "Vap":
blk[k].flow_mol_phase['Vap'].value = \
blk[k].flow_mol.value
for j in blk[k]._params.component_list:
blk[k].mole_frac_phase_comp['Vap', j].value = \
blk[k].mole_frac_comp[j].value
else:
# Seems to work best with default values for phase flows
for j in blk[k]._params.component_list:
blk[k].mole_frac_phase_comp['Vap', j].value = \
blk[k].mole_frac_comp[j].value
blk[k].mole_frac_phase_comp['Liq', j].value = \
blk[k].mole_frac_comp[j].value
calculate_variable_from_constraint(
blk[k].pressure_sat[j], blk[k].eq_pressure_sat[j])
# ---------------------------------------------------------------------
# Solve phase equilibrium constraints
for k in blk.keys():
for c in blk[k].component_objects(Constraint):
# Deactivate all property constraints
if c.local_name not in ("total_flow_balance",
"component_flow_balances",
"equilibrium_constraint",
"sum_mole_frac", "_t1_constraint",
"_teq_constraint", "eq_pressure_dew",
"eq_pressure_bubble",
"eq_temperature_dew",
"eq_temperature_bubble",
"eq_pressure_sat"):
c.deactivate()
results = solve_indexed_blocks(opt, [blk], tee=stee)
if outlvl > 0:
if results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info("Phase state initialization for "
"{} completed".format(blk.name))
else:
_log.warning("Phase state initialization for "
"{} failed".format(blk.name))
# ---------------------------------------------------------------------
# Initialize other properties
for k in blk.keys():
for c in blk[k].component_objects(Constraint):
# Activate all constraints except sum_mole_frac_out
if c.local_name not in ("sum_mole_frac_out"):
c.activate()
if outlvl > 0:
if results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info("Property initialization for "
"{} completed".format(blk.name))
else:
_log.warning("Property initialization for "
"{} failed".format(blk.name))
# ---------------------------------------------------------------------
# Return state to initial conditions
for k in blk.keys():
if (blk[k].config.defined_state is False):
blk[k].sum_mole_frac_out.activate()
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
blk.release_state(flags)
if outlvl > 0:
_log.info("Initialisation completed for {}".format(blk.name))
def initialize(blk,
state_args=None,
hold_state=False,
outlvl=0,
solver='ipopt',
optarg={'tol': 1e-8}):
"""
Initialisation routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered
through the control volume, and if initial guesses
were not provied at the unit model level, the
control volume passes the inlet values as initial
guess.The keys for the state_args dictionary are:
flow_mol : value at which to initialize component
flows
pressure : value at which to initialize pressure
temperature : value at which to initialize temperature
mole_frac_comp: value at which to initialize the component
mixture mole fraction
outlvl : sets output level of initialisation routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default=None)
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
# Fix state variables if not already fixed
flags = fix_state_vars(blk, state_args)
# Set solver options
if outlvl > 1:
stee = True
else:
stee = False
if optarg is None:
sopt = {'tol': 1e-8}
else:
sopt = optarg
opt = SolverFactory('ipopt')
opt.options = sopt
# ---------------------------------------------------------------------
for k in blk.keys():
blk[k].eq_total.deactivate()
blk[k].eq_comp.deactivate()
if (blk[k].config.defined_state is False):
blk[k].eq_mol_frac_out.deactivate()
if (blk[k].config.has_phase_equilibrium) or \
(blk[k].config.parameters.config.valid_phase ==
('Liq', 'Vap')) or \
(blk[k].config.parameters.config.valid_phase ==
('Vap', 'Liq')):
blk[k].eq_Keq.deactivate()
blk[k].eq_sum_mol_frac.deactivate()
if (blk[k].config.has_phase_equilibrium) or \
(blk[k].config.parameters.config.valid_phase ==
('Liq', 'Vap')) or \
(blk[k].config.parameters.config.valid_phase ==
('Vap', 'Liq')):
results = solve_indexed_blocks(opt, [blk], tee=stee)
if outlvl > 0:
if results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info("Initialisation step 1 for "
"{} completed".format(blk.name))
else:
_log.warning("Initialisation step 1 for "
"{} failed".format(blk.name))
else:
if outlvl > 0:
_log.info("Initialisation step 1 for "
"{} skipped".format(blk.name))
for k in blk.keys():
blk[k].eq_total.activate()
blk[k].eq_comp.activate()
if (blk[k].config.has_phase_equilibrium) or \
(blk[k].config.parameters.config.valid_phase ==
('Liq', 'Vap')) or \
(blk[k].config.parameters.config.valid_phase ==
('Vap', 'Liq')):
blk[k].eq_Keq.activate()
blk[k].eq_sum_mol_frac.activate()
results = solve_indexed_blocks(opt, [blk], tee=stee)
if outlvl > 0:
if results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info("Initialisation step 2 for "
"{} completed".format(blk.name))
else:
_log.warning("Initialisation step 2 for "
"{} failed".format(blk.name))
for k in blk.keys():
if (blk[k].config.defined_state is False):
blk[k].eq_mol_frac_out.activate()
# ---------------------------------------------------------------------
# If input block, return flags, else release state
if hold_state is True:
return flags
else:
blk.release_state(flags)
if outlvl > 0:
if outlvl > 0:
_log.info('{} Initialisation Complete.'.format(blk.name))
def initialize(blk,
state_args={},
state_vars_fixed=False,
hold_state=False,
outlvl=idaeslog.NOTSET,
solver='ipopt',
optarg={'tol': 1e-8}):
"""
Initialization routine for property package.
Keyword Arguments:
state_args : a dict of initial values for the state variables
defined by the property package.
outlvl : sets output level of initialization routine
optarg : solver options dictionary object (default=None)
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
solver : str indicating which solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states variables are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="properties")
init_log.info('Starting initialization')
for k in blk.keys():
# Deactivate the constraints specific for outlet block i.e.
# when defined state is False
if blk[k].config.defined_state is False:
try:
blk[k].sum_mole_frac_out.deactivate()
except AttributeError:
pass
# Fix state variables if not already fixed
if state_vars_fixed is False:
flag_dict = fix_state_vars(blk, state_args)
# Confirm DoF for sanity
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise BurntToast("Degrees of freedom were not zero "
"after trying to fix state variables. "
"Something broke in the generic property "
"package code - please inform the IDAES "
"developers.")
else:
# When state vars are fixed, check that DoF is 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of "
"freedom for state block is not zero "
"during initialization.")
# Set solver options
if optarg is None:
sopt = {'tol': 1e-8}
else:
sopt = optarg
opt = SolverFactory('ipopt')
opt.options = sopt
# ---------------------------------------------------------------------
# If present, initialize bubble and dew point calculations
for k in blk.keys():
# Bubble temperature initialization
if hasattr(blk[k], "_mole_frac_tbub"):
# Use lowest component critical temperature as starting point
# Starting high and moving down generally works better,
# as it under-predicts next step due to exponential form of
# Psat.
# Subtract 1 to avoid potential singularities at Tcrit
Tbub0 = min(blk[k]._params.temperature_crit_comp[j]
for j in blk[k]._params.component_list) - 1
err = 1
counter = 0
# Newton solver with step limiter to prevent overshoot
# Tolerance only needs to be ~1e-1
# Iteration limit of 30
while err > 1e-1 and counter < 30:
f = value(
sum(blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp(blk[k], j, Tbub0) *
blk[k].mole_frac_comp[j]
for j in blk[k]._params.component_list) -
blk[k].pressure)
df = value(
sum(blk[k].mole_frac_comp[j] *
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp_dT(blk[k], j, Tbub0)
for j in blk[k]._params.component_list))
# Limit temperature step to avoid excessive overshoot
# Only limit positive steps due to non-linearity
if f / df < -50:
Tbub1 = Tbub0 + 50
else:
Tbub1 = Tbub0 - f / df
err = abs(Tbub1 - Tbub0)
Tbub0 = Tbub1
counter += 1
blk[k].temperature_bubble.value = Tbub0
for j in blk[k]._params.component_list:
blk[k]._mole_frac_tbub[j].value = value(
blk[k].mole_frac_comp[j] * blk[k].pressure /
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp(blk[k], j, Tbub0))
# Bubble temperature initialization
if hasattr(blk[k], "_mole_frac_tdew"):
if hasattr(blk[k], "_mole_frac_tbub"):
# If Tbub has been calculated above, use this as the
# starting point
Tdew0 = blk[k].temperature_bubble.value
else:
# Otherwise, use lowest component critical temperature as
# starting point
# Subtract 1 to avoid potential singularities at Tcrit
Tdew0 = min(blk[k]._params.temperature_crit_comp[j]
for j in blk[k]._params.component_list) - 1
err = 1
counter = 0
# Newton solver with step limiter to prevent overshoot
# Tolerance only needs to be ~1e-1
# Iteration limit of 30
while err > 1e-1 and counter < 30:
f = value(blk[k].pressure * sum(
blk[k].mole_frac_comp[j] / blk[k]._params.config.
pressure_sat_comp.pressure_sat_comp(blk[k], j, Tdew0)
for j in blk[k]._params.component_list) - 1)
df = -value(blk[k].pressure *
sum(blk[k].mole_frac_comp[j] /
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp(blk[k], j, Tdew0)**2 *
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp_dT(blk[k], j, Tdew0)
for j in blk[k]._params.component_list))
# Limit temperature step to avoid excessive overshoot
if f / df < -50:
Tdew1 = Tdew0 + 50
else:
Tdew1 = Tdew0 - f / df
err = abs(Tdew1 - Tdew0)
Tdew0 = Tdew1
counter += 1
blk[k].temperature_dew.value = Tdew0
for j in blk[k]._params.component_list:
blk[k]._mole_frac_tdew[j].value = value(
blk[k].mole_frac_comp[j] * blk[k].pressure /
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp(blk[k], j, Tdew0))
# Bubble pressure initialization
if hasattr(blk[k], "_mole_frac_pbub"):
blk[k].pressure_bubble.value = value(
sum(blk[k].mole_frac_comp[j] *
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp(blk[k], j, blk[k].temperature)
for j in blk[k]._params.component_list))
for j in blk[k]._params.component_list:
blk[k]._mole_frac_pbub[j].value = value(
blk[k].mole_frac_comp[j] *
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp(blk[k], j, blk[k].temperature) /
blk[k].pressure_bubble)
# Dew pressure initialization
if hasattr(blk[k], "_mole_frac_pdew"):
blk[k].pressure_dew.value = value(
sum(1 / (blk[k].mole_frac_comp[j] /
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp(blk[k], j, blk[k].temperature))
for j in blk[k]._params.component_list))
for j in blk[k]._params.component_list:
blk[k]._mole_frac_pdew[j].value = value(
blk[k].mole_frac_comp[j] * blk[k].pressure_bubble /
blk[k]._params.config.pressure_sat_comp.
pressure_sat_comp(blk[k], j, blk[k].temperature))
# Solve bubble and dew point constraints
for c in blk[k].component_objects(Constraint):
# Deactivate all constraints not associated wtih bubble and dew
# points
if c.local_name not in ("eq_pressure_dew",
"eq_pressure_bubble",
"eq_temperature_dew",
"eq_temperature_bubble",
"_sum_mole_frac_tbub",
"_sum_mole_frac_tdew",
"_sum_mole_frac_pbub",
"_sum_mole_frac_pdew"):
c.deactivate()
# If StateBlock has active constraints (i.e. has bubble and/or dew
# point calculations), solve the block to converge these
n_cons = 0
for k in blk:
n_cons += number_activated_constraints(blk[k])
if n_cons > 0:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solve_indexed_blocks(opt, [blk], tee=slc.tee)
init_log.info("Dew and bubble point initialization: {}.".format(
idaeslog.condition(res)))
# ---------------------------------------------------------------------
# If StateBlock is using a smooth VLE, calculate _T1 and _Teq
eq_check = 0
for k in blk.keys():
if hasattr(blk[k], "_t1"):
blk[k]._t1.value = max(blk[k].temperature.value,
blk[k].temperature_bubble.value)
blk[k]._teq.value = min(blk[k]._t1.value,
blk[k].temperature_dew.value)
eq_check += 1
if eq_check > 0:
init_log.info("Equilibrium temperature initialization completed.")
# ---------------------------------------------------------------------
# Initialize flow rates and compositions
for k in blk.keys():
blk[k]._params.config.state_definition.state_initialization(blk[k])
if outlvl > 0:
init_log.info("State variable initialization completed.")
# ---------------------------------------------------------------------
if (blk[k]._params.config.phase_equilibrium_formulation is not None
and (not blk[k].config.defined_state or blk[k].always_flash)):
blk[k]._params.config.phase_equilibrium_formulation \
.phase_equil_initialization(blk[k])
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solve_indexed_blocks(opt, [blk], tee=slc.tee)
init_log.info("Phase equilibrium initialization: {}.".format(
idaeslog.condition(res)))
# ---------------------------------------------------------------------
# Initialize other properties
for k in blk.keys():
for c in blk[k].component_objects(Constraint):
# Activate all constraints except flagged do_not_initialize
if c.local_name not in (blk[k]._params.config.state_definition.
do_not_initialize):
c.activate()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solve_indexed_blocks(opt, [blk], tee=slc.tee)
init_log.info("Property initialization: {}.".format(
idaeslog.condition(res)))
# ---------------------------------------------------------------------
# Return constraints to initial state
for k in blk.keys():
for c in blk[k].component_objects(Constraint):
if c.local_name in (blk[k]._params.config.state_definition.
do_not_initialize):
c.activate()
if state_vars_fixed is False:
if hold_state is True:
return flag_dict
else:
blk.release_state(flag_dict)
init_log.info("Property package initialization: {}.".format(
idaeslog.condition(res)))
def initialize(blk,
state_args=None,
outlvl=idaeslog.NOTSET,
hold_state=False,
state_vars_fixed=False,
solver=None,
optarg=None):
"""
Declare initialisation routine.
Keyword Arguments:
state_args = to be used if state block initialized independent of
control volume initialize
outlvl : sets output level of initialisation routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default=None)
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
# Fix state variables if not already fixed by the control volume block
if state_vars_fixed is False:
# Fix state variables if not already fixed
flags = fix_state_vars(blk, state_args)
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
else:
# Check when the state vars are fixed already result in dof 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
opt = get_solver(solver, optarg)
# ---------------------------------------------------------------------
# Solve property correlation
results = solve_indexed_blocks(opt, [blk])
if results.solver.termination_condition \
== TerminationCondition.optimal:
init_log.info('{} Initialisation Step 1 Complete.'.format(
blk.name))
else:
init_log.warning('{} Initialisation Step 1 Failed.'.format(
blk.name))
init_log.info('Initialization Step 1 Complete.')
# ---------------------------------------------------------------------
if state_vars_fixed is False:
# release state vars fixed during initialization if control
# volume didn't fix the state vars
if hold_state is True:
return flags
else:
blk.release_state(flags)
init_log.info('Initialization Complete.')
def initialize(blk,
state_args={},
state_vars_fixed=False,
hold_state=False,
outlvl=1,
solver='ipopt',
optarg={'tol': 1e-8}):
"""
Initialization routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered
through the control volume, and if initial guesses
were not provied at the unit model level, the
control volume passes the inlet values as initial
guess.The keys for the state_args dictionary are:
flow_mol_phase_comp : value at which to initialize
phase component flows
pressure : value at which to initialize pressure
temperature : value at which to initialize temperature
outlvl : sets output level of initialization routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default=None)
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
_log.info('Starting {} initialization'.format(blk.name))
# Fix state variables if not already fixed
if state_vars_fixed is False:
flags = fix_state_vars(blk, state_args)
else:
# Check when the state vars are fixed already result in dof 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
# Set solver options
if outlvl > 1:
stee = True
else:
stee = False
if optarg is None:
sopt = {'tol': 1e-8}
else:
sopt = optarg
opt = SolverFactory('ipopt')
opt.options = sopt
# ---------------------------------------------------------------------
# Initialize flow rates and compositions
free_vars = 0
for k in blk.keys():
free_vars += number_unfixed_variables(blk[k])
if free_vars > 0:
try:
results = solve_indexed_blocks(opt, [blk], tee=stee)
except:
results = None
else:
results = None
if outlvl > 0:
if results is None or results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info("Property initialization for "
"{} completed".format(blk.name))
else:
_log.warning("Property initialization for "
"{} failed".format(blk.name))
# ---------------------------------------------------------------------
# Return state to initial conditions
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
blk.release_state(flags)
if outlvl > 0:
_log.info("Initialization completed for {}".format(blk.name))
def initialize(
self,
state_args=None,
state_vars_fixed=False,
hold_state=False,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None,
):
"""
Initialization routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered
through the control volume, and if initial guesses
were not provided at the unit model level, the
control volume passes the inlet values as initial
guess.The keys for the state_args dictionary are:
flow_mass_phase_comp : value at which to initialize
phase component flows
pressure : value at which to initialize pressure
temperature : value at which to initialize temperature
outlvl : sets output level of initialization routine
optarg : solver options dictionary object (default={})
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
solver : Solver object to use during initialization if None is provided
it will use the default solver for IDAES (default = None)
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states variables are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
release_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
# Get loggers
init_log = idaeslog.getInitLogger(self.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(self.name,
outlvl,
tag="properties")
# Set solver and options
opt = get_solver(solver, optarg)
# Fix state variables
flags = fix_state_vars(self, state_args)
# Check when the state vars are fixed already result in dof 0
for k in self.keys():
dof = degrees_of_freedom(self[k])
if dof != 0:
raise PropertyPackageError("State vars fixed but degrees of "
"freedom for state block is not "
"zero during initialization.")
# ---------------------------------------------------------------------
# Initialize properties
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
results = solve_indexed_blocks(opt, [self], tee=slc.tee)
init_log.info("Property initialization: {}.".format(
idaeslog.condition(results)))
if not check_optimal_termination(results):
raise InitializationError(
f"{self.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
# ---------------------------------------------------------------------
# If input block, return flags, else release state
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
self.release_state(flags)
def initialize(blk,
flow_mol=None,
temperature=None,
pressure=None,
vapor_frac=None,
outlvl=0,
hold_state=False,
state_vars_fixed=False,
solver='ipopt',
optarg={'tol': 1e-8}):
"""
Declare initialisation routine.
Keyword Arguments:
state_args = to be used if state block initialized independent of
control volume initialize
outlvl : sets output level of initialisation routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default=None)
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
# Fix state variables if not already fixed by the control volume block
if state_vars_fixed is False:
Fflag = {}
Pflag = {}
Tflag = {}
vfflag = {}
for k in blk.keys():
if blk[k].flow_mol.fixed is True:
Fflag[k] = True
else:
Fflag[k] = False
if flow_mol is None:
blk[k].flow_mol.fix(1.0)
else:
blk[k].flow_mol.fix(flow_mol)
if blk[k].pressure.fixed is True:
Pflag[k] = True
else:
Pflag[k] = False
if pressure is None:
blk[k].pressure.fix(101325.0)
else:
blk[k].pressure.fix(pressure)
if blk[k].temperature.fixed is True:
Tflag[k] = True
else:
Tflag[k] = False
if temperature is None:
blk[k].temperature.fix(300.0)
else:
blk[k].temperature.fix(temperature)
if blk[k].vapor_frac.fixed is True:
vfflag[k] = True
else:
vfflag[k] = False
if vapor_frac is None:
blk[k].vapor_frac.fix(300.0)
else:
blk[k].vapor_frac.fix(temperature)
flags = {
"Fflag": Fflag,
"Pflag": Pflag,
"Tflag": Tflag,
"vfflag": vfflag
}
else:
# Check when the state vars are fixed already result in dof 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
# Set solver options
if outlvl > 1:
stee = True
else:
stee = False
opt = SolverFactory(solver)
opt.options = optarg
# ---------------------------------------------------------------------
# Solve property correlation
results = solve_indexed_blocks(opt, [blk], tee=stee)
if outlvl > 0:
if results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info('{} Initialisation Step 1 Complete.'.format(
blk.name))
else:
_log.warning('{} Initialisation Step 1 Failed.'.format(
blk.name))
# ---------------------------------------------------------------------
if state_vars_fixed is False:
# release state vars fixed during initialization if control
# volume didn't fix the state vars
if hold_state is True:
return flags
else:
blk.release_state(flags)
if outlvl > 0:
if outlvl > 0:
_log.info('{} Initialisation Complete.'.format(blk.name))
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.')
def initialize(self, state_args={}, state_vars_fixed=False,
hold_state=False, outlvl=idaeslog.NOTSET,
temperature_bounds=(260, 616),
solver=None, optarg=None):
'''
Initialization routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered
through the control volume, and if initial guesses
were not provied at the unit model level, the
control volume passes the inlet values as initial
guess.The keys for the state_args dictionary are:
flow_mol_comp : value at which to initialize component
flows (default=None)
pressure : value at which to initialize pressure
(default=None)
temperature : value at which to initialize temperature
(default=None)
outlvl : sets output level of initialization routine
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed and
initialization does not need to worry
about fixing and unfixing variables.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
optarg : solver options dictionary object (default=None)
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
'''
init_log = idaeslog.getInitLogger(self.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(self.name, outlvl,
tag="properties")
if state_vars_fixed is False:
# Fix state variables if not already fixed
flags = fix_state_vars(self, state_args)
else:
# Check when the state vars are fixed already result in dof 0
for k in self.keys():
if degrees_of_freedom(self[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
opt = get_solver(solver=solver, options=optarg)
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solve_indexed_blocks(opt, [self], tee=slc.tee)
init_log.info("Initialization Step 1 {}.".
format(idaeslog.condition(res)))
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
self.release_state(flags)
init_log.info('Initialization Complete.')
def initialize(blk,
flow_mol_comp=None,
temperature=None,
pressure=None,
hold_state=False,
outlvl=0,
state_vars_fixed=False,
solver='ipopt',
optarg={'tol': 1e-8}):
'''
Initialisation routine for property package.
Keyword Arguments:
flow_mol_comp : value at which to initialize component flows
(default=None)
pressure : value at which to initialize pressure (default=None)
temperature : value at which to initialize temperature
(default=None)
outlvl : sets output level of initialisation routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
optarg : solver options dictionary object (default=None)
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
'''
if state_vars_fixed is False:
# Fix state variables if not already fixed
Fcflag = {}
Pflag = {}
Tflag = {}
for k in blk.keys():
for j in blk[k]._params.component_list:
if blk[k].flow_mol_comp[j].fixed is True:
Fcflag[k, j] = True
else:
Fcflag[k, j] = False
if flow_mol_comp is None:
blk[k].flow_mol_comp[j].fix(1.0)
else:
blk[k].flow_mol_comp[j].fix(flow_mol_comp[j])
if blk[k].pressure.fixed is True:
Pflag[k] = True
else:
Pflag[k] = False
if pressure is None:
blk[k].pressure.fix(101325.0)
else:
blk[k].pressure.fix(pressure)
if blk[k].temperature.fixed is True:
Tflag[k] = True
else:
Tflag[k] = False
if temperature is None:
blk[k].temperature.fix(1500.0)
else:
blk[k].temperature.fix(temperature)
for j in blk[k]._params.component_list:
blk[k].mole_frac[j] = \
(value(blk[k].flow_mol_comp[j]) /
sum(value(blk[k].flow_mol_comp[i])
for i in blk[k]._params.component_list))
# If input block, return flags, else release state
flags = {"Fcflag": Fcflag, "Pflag": Pflag, "Tflag": Tflag}
else:
# Check when the state vars are fixed already result in dof 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
# Set solver options
if outlvl > 1:
stee = True
else:
stee = False
opt = SolverFactory(solver)
opt.options = optarg
# ---------------------------------------------------------------------
# Initialise values
for k in blk.keys():
for j in blk[k]._params.component_list:
if hasattr(blk[k], "cp_shomate_eqn"):
calculate_variable_from_constraint(
blk[k].cp_mol_comp[j], blk[k].cp_shomate_eqn[j])
if hasattr(blk[k], "enthalpy_shomate_eqn"):
calculate_variable_from_constraint(
blk[k].enth_mol_phase_comp["Vap", j],
blk[k].enthalpy_shomate_eqn[j])
if hasattr(blk[k], "entropy_shomate_eqn"):
calculate_variable_from_constraint(
blk[k].entr_mol_phase_comp["Vap", j],
blk[k].entropy_shomate_eqn[j])
if hasattr(blk[k], "partial_gibbs_energy_eqn"):
calculate_variable_from_constraint(
blk[k].gibbs_mol_phase_comp["Vap", j],
blk[k].partial_gibbs_energy_eqn[j])
if hasattr(blk[k], "ideal_gas"):
calculate_variable_from_constraint(
blk[k].dens_mol_phase["Vap"], blk[k].ideal_gas)
if hasattr(blk[k], "mixture_heat_capacity_eqn"):
calculate_variable_from_constraint(
blk[k].cp_mol, blk[k].mixture_heat_capacity_eqn)
if hasattr(blk[k], "mixture_enthalpy_eqn"):
calculate_variable_from_constraint(blk[k].enth_mol,
blk[k].mixture_enthalpy_eqn)
if hasattr(blk[k], "mixture_entropy_eqn"):
calculate_variable_from_constraint(blk[k].entr_mol,
blk[k].mixture_entropy_eqn)
if hasattr(blk[k], "total_flow_eqn"):
calculate_variable_from_constraint(blk[k].flow_mol,
blk[k].total_flow_eqn)
if hasattr(blk[k], "mixture_gibbs_eqn"):
calculate_variable_from_constraint(blk[k].gibbs_mol,
blk[k].mixture_gibbs_eqn)
results = solve_indexed_blocks(opt, blk, tee=stee)
if outlvl > 0:
if results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info('{} Initialisation Step 1 Complete.'.format(
blk.name))
else:
_log.warning('{} Initialisation Step 1 Failed.'.format(
blk.name))
# ---------------------------------------------------------------------
if outlvl > 0:
if outlvl > 0:
_log.info('{} Initialisation Complete.'.format(blk.name))
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
blk.release_state(flags)
def initialize(blk,
state_args={},
state_vars_fixed=False,
hold_state=False,
outlvl=idaeslog.NOTSET,
solver='ipopt',
optarg={'tol': 1e-8}):
"""
Initialization routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. Note that if this method is triggered
through the control volume, and if initial guesses
were not provied at the unit model level, the
control volume passes the inlet values as initial
guess.The keys for the state_args dictionary are:
flow_mol_phase_comp : value at which to initialize
phase component flows
pressure : value at which to initialize pressure
temperature : value at which to initialize temperature
outlvl : sets output level of initialization routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default=None)
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="properties")
# Fix state variables if not already fixed
if state_vars_fixed is False:
flags = fix_state_vars(blk, state_args)
else:
# Check when the state vars are fixed already result in dof 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
# Set solver options
if optarg is None:
sopt = {"tol": 1e-8}
else:
sopt = optarg
opt = SolverFactory('ipopt')
opt.options = sopt
# ---------------------------------------------------------------------
# If present, initialize bubble and dew point calculations
for k in blk.keys():
if hasattr(blk[k], "eq_temperature_dew"):
calculate_variable_from_constraint(blk[k].temperature_dew,
blk[k].eq_temperature_dew)
if hasattr(blk[k], "eq_pressure_dew"):
calculate_variable_from_constraint(blk[k].pressure_dew,
blk[k].eq_pressure_dew)
init_log.info_high("Initialization Step 1 - Dew and bubble points "
"calculation completed.")
# ---------------------------------------------------------------------
# If flash, initialize T1 and Teq
for k in blk.keys():
if (blk[k].config.has_phase_equilibrium
and not blk[k].config.defined_state):
blk[k]._t1.value = max(blk[k].temperature.value,
blk[k].temperature_bubble.value)
blk[k]._teq.value = min(blk[k]._t1.value,
blk[k].temperature_dew.value)
init_log.info_high("Initialization Step 2 - Equilibrium temperature "
" calculation completed.")
# ---------------------------------------------------------------------
# Initialize flow rates and compositions
# TODO : This will need to be generalised more when we move to a
# modular implementation
for k in blk.keys():
# Deactivate equilibrium constraints, as state is fixed
if hasattr(blk[k], 'equilibrium_constraint'):
blk[k].equilibrium_constraint.deactivate()
free_vars = 0
for k in blk.keys():
free_vars += number_unfixed_variables(blk[k])
if free_vars > 0:
try:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solve_indexed_blocks(opt, [blk], tee=slc.tee)
except:
res = None
else:
res = None
for k in blk.keys():
# Reactivate equilibrium constraints
if hasattr(blk[k], 'equilibrium_constraint'):
blk[k].equilibrium_constraint.activate()
# ---------------------------------------------------------------------
# Return state to initial conditions
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
blk.release_state(flags)
init_log.info("Initialization Complete")
def test_solve_indexed_block_error():
# Try solve_indexed_block on non-block object
with pytest.raises(TypeError):
solve_indexed_blocks(solver=None, blocks=[1, 2, 3])
def initialize_system(m, solver_dict=None):
solver_str = solver_dict['solver_str']
solver_opt = solver_dict['solver_opt']
solver = solver_dict['solver']
# ---initialize feed block---
m.fs.feed.initialize(solver=solver_str, optarg=solver_opt)
# ---initialize splitter and pressure exchanger---
# pressure exchanger high pressure inlet
propagate_state(
m.fs.s06) # propagate to PXR high pressure inlet from RO retentate
m.fs.PXR.high_pressure_side.properties_in.initialize(solver=solver_str,
optarg=solver_opt)
# splitter inlet
propagate_state(m.fs.s01) # propagate to splitter inlet from feed
m.fs.S1.mixed_state[
0].mass_frac_phase_comp # touch property, so that it is built and can be solved for
m.fs.S1.mixed_state.initialize(solver=solver_str, optarg=solver_opt)
# splitter outlet to PXR, enforce same flow_vol as PXR high pressure inlet
m.fs.S1.PXR_state[0].pressure.fix(value(m.fs.S1.mixed_state[0].pressure))
m.fs.S1.PXR_state[0].temperature.fix(
value(m.fs.S1.mixed_state[0].temperature))
m.fs.S1.PXR_state[0].flow_vol_phase['Liq'].fix(
value(m.fs.PXR.high_pressure_side.properties_in[0].
flow_vol_phase['Liq']))
m.fs.S1.PXR_state[0].mass_frac_phase_comp['Liq', 'NaCl'].fix(
value(m.fs.S1.mixed_state[0].mass_frac_phase_comp['Liq', 'NaCl']))
check_dof(m.fs.S1.PXR_state[0])
results = solve_indexed_blocks(solver, [m.fs.S1.PXR_state])
check_solve(results)
# unfix PXR_state state variables and properties
m.fs.S1.PXR_state[0].pressure.unfix()
m.fs.S1.PXR_state[0].temperature.unfix()
m.fs.S1.PXR_state[0].flow_vol_phase['Liq'].unfix()
m.fs.S1.PXR_state[0].mass_frac_phase_comp['Liq', 'NaCl'].unfix()
m.fs.S1.PXR_state[0].flow_mass_phase_comp['Liq', 'NaCl'].fix()
# splitter initialization
m.fs.S1.initialize(solver=solver_str, optarg=solver_opt)
m.fs.S1.PXR_state[0].flow_mass_phase_comp['Liq', 'NaCl'].unfix()
# pressure exchanger low pressure inlet
propagate_state(m.fs.s08)
# pressure exchanger initialization
m.fs.PXR.initialize(solver=solver_str, optarg=solver_opt)
# ---initialize pump 1---
propagate_state(m.fs.s02)
m.fs.P1.initialize(solver=solver_str, optarg=solver_opt)
# ---initialize pump 2---
propagate_state(m.fs.s09)
m.fs.P2.control_volume.properties_out[0].pressure.fix(
value(m.fs.P2.control_volume.properties_out[0].pressure))
m.fs.P2.initialize(solver=solver_str, optarg=solver_opt)
m.fs.P2.control_volume.properties_out[0].pressure.unfix()
# ---initialize mixer---
propagate_state(m.fs.s03)
propagate_state(m.fs.s10)
m.fs.M1.initialize(solver=solver_str,
optarg=solver_opt,
outlvl=idaeslog.INFO)
def initialize(blk,
flow_mol_phase_comp=None,
temperature=None,
pressure=None,
state_vars_fixed=False,
hold_state=False,
outlvl=1,
solver='ipopt',
optarg={'tol': 1e-8}):
"""
Initialisation routine for property package.
Keyword Arguments:
flow_mol_phase_comp : value at which to initialize phase-component
flows (default=None)
pressure : value at which to initialize pressure (default=None)
temperature : value at which to initialize temperature
(default=None)
outlvl : sets output level of initialisation routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default=None)
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
solver : str indicating whcih solver to use during
initialization (default = 'ipopt')
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
_log.info('Starting {} initialisation'.format(blk.name))
# Fix state variables if not already fixed
if state_vars_fixed is False:
Fflag = {}
Pflag = {}
Tflag = {}
for k in blk.keys():
for p in blk[k]._params.phase_list:
for j in blk[k]._params.component_list:
if blk[k].flow_mol_phase_comp[p, j].fixed is True:
Fflag[k, p, j] = True
else:
Fflag[k, p, j] = False
if flow_mol_phase_comp is None:
blk[k].flow_mol_phase_comp[p, j].fix(
1 / len(blk[k]._params.component_list))
else:
blk[k].flow_mol_phase_comp[p, j].fix(
flow_mol_phase_comp[p, j])
if blk[k].pressure.fixed is True:
Pflag[k] = True
else:
Pflag[k] = False
if pressure is None:
blk[k].pressure.fix(101325.0)
else:
blk[k].pressure.fix(pressure)
if blk[k].temperature.fixed is True:
Tflag[k] = True
else:
Tflag[k] = False
if temperature is None:
blk[k].temperature.fix(325)
else:
blk[k].temperature.fix(temperature)
# -----------------------------------------------------------------
# If input block, return flags, else release state
flags = {"Fflag": Fflag, "Pflag": Pflag, "Tflag": Tflag}
else:
# Check when the state vars are fixed already result in dof 0
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
# Set solver options
if outlvl > 1:
stee = True
else:
stee = False
if optarg is None:
sopt = {'tol': 1e-8}
else:
sopt = optarg
opt = SolverFactory('ipopt')
opt.options = sopt
# ---------------------------------------------------------------------
# If present, initialize bubble and dew point calculations
for k in blk.keys():
if hasattr(blk[k], "eq_temperature_dew"):
calculate_variable_from_constraint(blk[k].temperature_dew,
blk[k].eq_temperature_dew)
if hasattr(blk[k], "eq_pressure_dew"):
calculate_variable_from_constraint(blk[k].pressure_dew,
blk[k].eq_pressure_dew)
if outlvl > 0:
_log.info("Dew and bubble points initialization for "
"{} completed".format(blk.name))
# ---------------------------------------------------------------------
# If flash, initialize T1 and Teq
for k in blk.keys():
if (blk[k].config.has_phase_equilibrium
and not blk[k].config.defined_state):
blk[k]._t1.value = max(blk[k].temperature.value,
blk[k].temperature_bubble.value)
blk[k]._teq.value = min(blk[k]._t1.value,
blk[k].temperature_dew.value)
if outlvl > 0:
_log.info("Equilibrium temperature initialization for "
"{} completed".format(blk.name))
# ---------------------------------------------------------------------
# Initialize flow rates and compositions
# TODO : This will need ot be generalised more when we move to a
# modular implementation
for k in blk.keys():
# Deactivate equilibrium constraints, as state is fixed
if hasattr(blk[k], 'equilibrium_constraint'):
blk[k].equilibrium_constraint.deactivate()
free_vars = 0
for k in blk.keys():
free_vars += number_unfixed_variables(blk[k])
if free_vars > 0:
try:
results = solve_indexed_blocks(opt, [blk], tee=stee)
except:
results = None
else:
results = None
for k in blk.keys():
# Reactivate equilibrium constraints
if hasattr(blk[k], 'equilibrium_constraint'):
blk[k].equilibrium_constraint.activate()
if outlvl > 0:
if results is None or results.solver.termination_condition \
== TerminationCondition.optimal:
_log.info("Property initialization for "
"{} completed".format(blk.name))
else:
_log.warning("Property initialization for "
"{} failed".format(blk.name))
# ---------------------------------------------------------------------
# Return state to initial conditions
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
blk.release_state(flags)
if outlvl > 0:
_log.info("Initialisation completed for {}".format(blk.name))
def initialize(blk, state_args={}, state_vars_fixed=False,
hold_state=False, outlvl=idaeslog.NOTSET,
solver=None, optarg=None):
"""
Initialization routine for property package.
Keyword Arguments:
state_args : Dictionary with initial guesses for the state vars
chosen. The keys for the state_args dictionary are:
flow_mol : value at which to initialize flow rate
mole_frac_comp : dict of values to use when
initializing mole fractions
pressure : value at which to initialize pressure
temperature : value at which to initialize temperature
outlvl : sets logger output level for initialization routine
optarg : solver options dictionary object (default=None)
state_vars_fixed: Flag to denote if state vars have already been
fixed.
- True - states have already been fixed by the
control volume 1D. Control volume 0D
does not fix the state vars, so will
be False if this state block is used
with 0D blocks.
- False - states have not been fixed. The state
block will deal with fixing/unfixing.
solver : str indicating whcih solver to use during
initialization (default = None, use default solver)
hold_state : flag indicating whether the initialization routine
should unfix any state variables fixed during
initialization (default=False).
- True - states varaibles are not unfixed, and
a dict of returned containing flags for
which states were fixed during
initialization.
- False - state variables are unfixed after
initialization by calling the
relase_state method
Returns:
If hold_states is True, returns a dict containing flags for
which states were fixed during initialization.
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="properties")
# Fix state variables if not already fixed
if state_vars_fixed is False:
flags = fix_state_vars(blk, state_args)
else:
pass
# Deactivate sum of mole fractions constraint
for k in blk.keys():
if blk[k].config.defined_state is False:
blk[k].mole_fraction_constraint.deactivate()
# Check that degrees of freedom are zero after fixing state vars
for k in blk.keys():
if degrees_of_freedom(blk[k]) != 0:
raise Exception("State vars fixed but degrees of freedom "
"for state block is not zero during "
"initialization.")
# Set solver options
if optarg is None:
optarg = {"tol": 1e-8}
opt = get_solver(solver, optarg)
# ---------------------------------------------------------------------
# Initialize property calculations
# Check that there is something to solve for
free_vars = 0
for k in blk.keys():
free_vars += number_unfixed_variables(blk[k])
if free_vars > 0:
# If there are free variables, call the solver to initialize
try:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solve_indexed_blocks(opt, [blk], tee=slc.tee)
except:
res = None
else:
res = None
init_log.info("Properties Initialized {}.".format(
idaeslog.condition(res)))
# ---------------------------------------------------------------------
# Return state to initial conditions
if state_vars_fixed is False:
if hold_state is True:
return flags
else:
blk.release_state(flags)
init_log.info("Initialization Complete")
