def initialize(self,
state_args=None,
solver=None,
optarg=None,
outlvl=idaeslog.NOTSET):
# TODO: Fix the inlets to the condenser to the vapor flow from
# the top tray or take it as an argument to this method.
init_log = idaeslog.getInitLogger(self.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(self.name, outlvl, tag="unit")
if self.config.temperature_spec == TemperatureSpec.customTemperature:
if degrees_of_freedom(self) != 0:
raise ConfigurationError(
"Degrees of freedom is not 0 during initialization. "
"Check if outlet temperature has been fixed in addition "
"to the other inputs required as customTemperature was "
"selected for temperature_spec config argument.")
solverobj = get_solver(solver, optarg)
if state_args is None:
state_args = {}
state_dict = (self.control_volume.properties_in[
self.flowsheet().time.first()].define_port_members())
for k in state_dict.keys():
if state_dict[k].is_indexed():
state_args[k] = {}
for m in state_dict[k].keys():
state_args[k][m] = value(state_dict[k][m])
else:
state_args[k] = value(state_dict[k])
if self.config.condenser_type == CondenserType.totalCondenser:
self.eq_total_cond_spec.deactivate()
# Initialize the inlet and outlet state blocks
flags = self.control_volume.initialize(state_args=state_args,
solver=solver,
optarg=optarg,
outlvl=outlvl,
hold_state=True)
# Activate the total condenser spec
if self.config.condenser_type == CondenserType.totalCondenser:
self.eq_total_cond_spec.activate()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solverobj.solve(self, tee=slc.tee)
init_log.info("Initialization Complete, {}.".format(
idaeslog.condition(res)))
if not check_optimal_termination(res):
raise InitializationError(
f"{self.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
self.control_volume.release_state(flags=flags)
def initialize(blk,
state_args=None,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None):
'''
This method calls the initialization method of the Feed state block.
Keyword Arguments:
state_args : a dict of arguments to be passed to the property
package(s) to provide an initial state for
initialization (see documentation of the specific
property package) (default = None).
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)
Returns:
None
'''
# ---------------------------------------------------------------------
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit")
if optarg is None:
optarg = {}
opt = get_solver(solver, optarg)
if state_args is None:
state_args = {}
# Initialize state block
blk.properties.initialize(outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=state_args)
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(blk, tee=slc.tee)
init_log.info("Initialization complete: {}.".format(
idaeslog.condition(res)))
if not check_optimal_termination(res):
raise InitializationError(
f"{blk.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
def initialize(self,
state_args_feed=None,
state_args_liq=None,
state_args_vap=None,
hold_state_liq=False,
hold_state_vap=False,
solver=None,
optarg=None,
outlvl=idaeslog.NOTSET):
# TODO:
# 1. Initialization for dynamic mode. Currently not supported.
# 2. Handle unfixed side split fraction vars
# 3. Better logic to handle and fix state vars.
init_log = idaeslog.getInitLogger(self.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(self.name, outlvl, tag="unit")
init_log.info("Begin initialization.")
solverobj = get_solver(solver, optarg)
if self.config.has_liquid_side_draw:
if not self.liq_side_sf.fixed:
raise ConfigurationError(
"Liquid side draw split fraction not fixed but "
"has_liquid_side_draw set to True.")
if self.config.has_vapor_side_draw:
if not self.vap_side_sf.fixed:
raise ConfigurationError(
"Vapor side draw split fraction not fixed but "
"has_vapor_side_draw set to True.")
# Create initial guess if not provided by using current values
if self.config.is_feed_tray and state_args_feed is None:
state_args_feed = {}
state_args_liq = {}
state_args_vap = {}
state_dict = (self.properties_in_feed[
self.flowsheet().time.first()].define_port_members())
for k in state_dict.keys():
if "flow" in k:
if state_dict[k].is_indexed():
state_args_feed[k] = {}
state_args_liq[k] = {}
state_args_vap[k] = {}
for m in state_dict[k].keys():
state_args_feed[k][m] = \
value(state_dict[k][m])
state_args_liq[k][m] = \
value(0.1 * state_dict[k][m])
state_args_vap[k][m] = \
value(0.1 * state_dict[k][m])
else:
state_args_feed[k] = value(state_dict[k])
state_args_liq[k] = 0.1 * value(state_dict[k])
state_args_vap[k] = 0.1 * value(state_dict[k])
else:
if state_dict[k].is_indexed():
state_args_feed[k] = {}
state_args_liq[k] = {}
state_args_vap[k] = {}
for m in state_dict[k].keys():
state_args_feed[k][m] = \
value(state_dict[k][m])
state_args_liq[k][m] = \
value(state_dict[k][m])
state_args_vap[k][m] = \
value(state_dict[k][m])
else:
state_args_feed[k] = value(state_dict[k])
state_args_liq[k] = value(state_dict[k])
state_args_vap[k] = value(state_dict[k])
# Create initial guess if not provided by using current values
if not self.config.is_feed_tray and state_args_liq is None:
state_args_liq = {}
state_dict = (self.properties_in_liq[
self.flowsheet().time.first()].define_port_members())
for k in state_dict.keys():
if state_dict[k].is_indexed():
state_args_liq[k] = {}
for m in state_dict[k].keys():
state_args_liq[k][m] = \
value(state_dict[k][m])
else:
state_args_liq[k] = value(state_dict[k])
# Create initial guess if not provided by using current values
if not self.config.is_feed_tray and state_args_vap is None:
state_args_vap = {}
state_dict = (self.properties_in_vap[
self.flowsheet().time.first()].define_port_members())
for k in state_dict.keys():
if state_dict[k].is_indexed():
state_args_vap[k] = {}
for m in state_dict[k].keys():
state_args_vap[k][m] = \
value(state_dict[k][m])
else:
state_args_vap[k] = value(state_dict[k])
if self.config.is_feed_tray:
feed_flags = self.properties_in_feed.initialize(
outlvl=outlvl,
solver=solver,
optarg=optarg,
hold_state=True,
state_args=state_args_feed,
state_vars_fixed=False)
liq_in_flags = self.properties_in_liq. \
initialize(outlvl=outlvl,
solver=solver,
optarg=optarg,
hold_state=True,
state_args=state_args_liq,
state_vars_fixed=False)
vap_in_flags = self.properties_in_vap. \
initialize(outlvl=outlvl,
solver=solver,
optarg=optarg,
hold_state=True,
state_args=state_args_vap,
state_vars_fixed=False)
# state args to initialize the mixed outlet state block
state_args_mixed = {}
if self.config.is_feed_tray:
# if feed tray, initialize the mixed state block at
# the same condition.
state_args_mixed = state_args_feed
else:
# if not feed tray, initialize mixed state block at average of
# vap/liq inlets except pressure. While this is crude, it
# will work for most combination of state vars.
state_dict = (self.properties_in_liq[
self.flowsheet().time.first()].define_port_members())
for k in state_dict.keys():
if k == "pressure":
# Take the lowest pressure and this is the liq inlet
state_args_mixed[k] = value(
self.properties_in_liq[0].component(
state_dict[k].local_name))
elif state_dict[k].is_indexed():
state_args_mixed[k] = {}
for m in state_dict[k].keys():
if "flow" in k:
state_args_mixed[k][m] = \
value(self.properties_in_liq[0].
component(state_dict[k].local_name)[m]) \
+ value(self.properties_in_vap[0].
component(state_dict[k].local_name)[m])
else:
state_args_mixed[k][m] = \
0.5 * (value(self.properties_in_liq[0].
component(state_dict[k].
local_name)[m]) +
value(self.properties_in_vap[0].
component(state_dict[k].local_name)[m]))
else:
if "flow" in k:
state_args_mixed[k] = \
value(self.properties_in_liq[0].
component(state_dict[k].local_name)) +\
value(self.properties_in_vap[0].
component(state_dict[k].local_name))
else:
state_args_mixed[k] = \
0.5 * (value(self.properties_in_liq[0].
component(state_dict[k].local_name)) +
value(self.properties_in_vap[0].
component(state_dict[k].local_name)))
# Initialize the mixed outlet state block
self.properties_out. \
initialize(outlvl=outlvl,
solver=solver,
optarg=optarg,
hold_state=False,
state_args=state_args_mixed,
state_vars_fixed=False)
# Deactivate energy balance
self.enthalpy_mixing_equations.deactivate()
# Try fixing the outlet temperature if else pass
# NOTE: if passed then there would probably be a degree of freedom
try:
self.properties_out[:].temperature.\
fix(state_args_mixed["temperature"])
except AttributeError:
init_log.warning("Trying to fix outlet temperature "
"during initialization but temperature attribute "
"unavailable in the state block. Initialization "
"proceeding with a potential degree of freedom.")
# Deactivate pressure balance
self.pressure_drop_equation.deactivate()
# Try fixing the outlet temperature if else pass
# NOTE: if passed then there would probably be a degree of freedom
try:
self.properties_out[:].pressure.\
fix(state_args_mixed["pressure"])
except AttributeError:
init_log.warning("Trying to fix outlet pressure "
"during initialization but pressure attribute "
"unavailable in the state block. Initialization "
"proceeding with a potential degree of freedom.")
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solverobj.solve(self, tee=slc.tee)
init_log.info("Mass balance solve {}.".format(idaeslog.condition(res)))
# Activate energy balance
self.enthalpy_mixing_equations.activate()
try:
self.properties_out[:].temperature.unfix()
except AttributeError:
pass
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solverobj.solve(self, tee=slc.tee)
init_log.info("Mass and energy balance solve {}.".format(
idaeslog.condition(res)))
# Activate pressure balance
self.pressure_drop_equation.activate()
try:
self.properties_out[:].pressure.unfix()
except AttributeError:
pass
if degrees_of_freedom(self) == 0:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solverobj.solve(self, tee=slc.tee)
init_log.info("Mass, energy and pressure balance solve {}.".format(
idaeslog.condition(res)))
else:
raise Exception("State vars fixed but degrees of freedom "
"for tray block is not zero during "
"initialization.")
if not check_optimal_termination(res):
raise InitializationError(
f"{self.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
init_log.info("Initialization complete, status {}.".format(
idaeslog.condition(res)))
if not self.config.is_feed_tray:
if not hold_state_vap:
self.properties_in_vap.release_state(flags=vap_in_flags,
outlvl=outlvl)
if not hold_state_liq:
self.properties_in_liq.release_state(flags=liq_in_flags,
outlvl=outlvl)
if hold_state_liq and hold_state_vap:
return liq_in_flags, vap_in_flags
elif hold_state_vap:
return vap_in_flags
elif hold_state_liq:
return liq_in_flags
else:
self.properties_in_liq.release_state(flags=liq_in_flags,
outlvl=outlvl)
self.properties_in_vap.release_state(flags=vap_in_flags,
outlvl=outlvl)
return feed_flags
def initialize(
self,
state_args_1=None,
state_args_2=None,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None,
duty=None,
):
"""
Heat exchanger initialization method.
Args:
state_args_1 : a dict of arguments to be passed to the property
initialization for the hot side (see documentation of the specific
property package) (default = {}).
state_args_2 : a dict of arguments to be passed to the property
initialization for the cold side (see documentation of the specific
property package) (default = {}).
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)
duty : an initial guess for the amount of heat transfered. This
should be a tuple in the form (value, units), (default
= (1000 J/s))
Returns:
None
"""
# Set solver options
init_log = idaeslog.getInitLogger(self.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(self.name, outlvl, tag="unit")
hot_side = getattr(self, self.config.hot_side_name)
cold_side = getattr(self, self.config.cold_side_name)
# Create solver
opt = get_solver(solver, optarg)
flags1 = hot_side.initialize(outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=state_args_1)
init_log.info_high("Initialization Step 1a (hot side) Complete.")
flags2 = cold_side.initialize(outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=state_args_2)
init_log.info_high("Initialization Step 1b (cold side) Complete.")
# ---------------------------------------------------------------------
# Solve unit without heat transfer equation
# if costing block exists, deactivate
if hasattr(self, "costing"):
self.costing.deactivate()
self.heat_transfer_equation.deactivate()
# Get side 1 and side 2 heat units, and convert duty as needed
s1_units = hot_side.heat.get_units()
s2_units = cold_side.heat.get_units()
if duty is None:
# Assume 1000 J/s and check for unitless properties
if s1_units is None and s2_units is None:
# Backwards compatability for unitless properties
s1_duty = -1000
s2_duty = 1000
else:
s1_duty = pyunits.convert_value(-1000,
from_units=pyunits.W,
to_units=s1_units)
s2_duty = pyunits.convert_value(1000,
from_units=pyunits.W,
to_units=s2_units)
else:
# Duty provided with explicit units
s1_duty = -pyunits.convert_value(
duty[0], from_units=duty[1], to_units=s1_units)
s2_duty = pyunits.convert_value(duty[0],
from_units=duty[1],
to_units=s2_units)
cold_side.heat.fix(s2_duty)
for i in hot_side.heat:
hot_side.heat[i].value = s1_duty
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(self, tee=slc.tee)
init_log.info_high("Initialization Step 2 {}.".format(
idaeslog.condition(res)))
cold_side.heat.unfix()
self.heat_transfer_equation.activate()
# ---------------------------------------------------------------------
# Solve unit
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(self, tee=slc.tee)
init_log.info_high("Initialization Step 3 {}.".format(
idaeslog.condition(res)))
# ---------------------------------------------------------------------
# Release Inlet state
hot_side.release_state(flags1, outlvl=outlvl)
cold_side.release_state(flags2, outlvl=outlvl)
init_log.info("Initialization Completed, {}".format(
idaeslog.condition(res)))
# if costing block exists, activate and initialize
if hasattr(self, "costing"):
self.costing.activate()
costing.initialize(self.costing)
if not check_optimal_termination(res):
raise InitializationError(
f"{self.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
def initialize(blk, state_args=None, outlvl=idaeslog.NOTSET,
solver=None, optarg=None):
'''
This is a general purpose initialization routine for simple unit
models. This method assumes a single ControlVolume block called
controlVolume, and first initializes this and then attempts to solve
the entire unit.
More complex models should overload this method with their own
initialization routines,
Keyword Arguments:
state_args : a dict of arguments to be passed to the property
package(s) to provide an initial state for
initialization (see documentation of the specific
property package) (default = {}).
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 IDAES solver)
Returns:
None
'''
if optarg is None:
optarg = {}
# Set solver options
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit")
opt = get_solver(solver, optarg)
# ---------------------------------------------------------------------
# Initialize control volume block
flags = blk.control_volume.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=state_args,
)
init_log.info_high('Initialization Step 1 Complete.')
# ---------------------------------------------------------------------
# Solve unit
# if costing block exists, deactivate
if hasattr(blk, "costing"):
blk.costing.deactivate()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
results = opt.solve(blk, tee=slc.tee)
init_log.info_high(
"Initialization Step 2 {}.".format(idaeslog.condition(results))
)
# if costing block exists, activate and initialize
if hasattr(blk, "costing"):
blk.costing.activate()
idaes.core.util.unit_costing.initialize(blk.costing)
# ---------------------------------------------------------------------
# Release Inlet state
blk.control_volume.release_state(flags, outlvl)
if not check_optimal_termination(results):
raise InitializationError(
f"{blk.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
init_log.info('Initialization Complete: {}'
.format(idaeslog.condition(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
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 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
outlvl : sets output level of initialization routine (default=idaeslog.NOTSET)
solver : Solver object to use during initialization if None is provided
it will use the default solver for IDAES (default = None)
optarg : solver options dictionary object (default=None)
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)
if not check_optimal_termination(results):
raise InitializationError(
'The property package failed to solve during initialization'
)
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 init_isentropic(blk, state_args, outlvl, solver, optarg):
"""
Initialization routine for isentropic pressure changers.
Keyword Arguments:
state_args : a dict of arguments to be passed to the property
package(s) to provide an initial state for
initialization (see documentation of the specific
property package) (default = {}).
outlvl : sets output level of initialization routine
optarg : solver options dictionary object (default={})
solver : str indicating which solver to use during
initialization (default = None)
Returns:
None
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit")
# Create solver
opt = get_solver(solver, optarg)
cv = blk.control_volume
t0 = blk.flowsheet().time.first()
state_args_out = {}
# performance curves exist and are active so initialize with them
activate_performance_curves = (hasattr(blk, "performance_curve") and
blk.performance_curve.has_constraints()
and blk.performance_curve.active)
if activate_performance_curves:
blk.performance_curve.deactivate()
# The performance curves will provide (maybe indirectly) efficency
# and/or pressure ratio. To get through the standard isentropic
# pressure changer init, we'll see if the user provided a guess for
# pressure ratio or isentropic efficency and fix them if need. If
# not fixed and no guess provided, fill in something reasonable
# until the performance curves are turned on.
unfix_eff = {}
unfix_ratioP = {}
for t in blk.flowsheet().time:
if not (blk.ratioP[t].fixed or blk.deltaP[t].fixed
or cv.properties_out[t].pressure.fixed):
if blk.config.compressor:
if not (value(blk.ratioP[t]) >= 1.01
and value(blk.ratioP[t]) <= 50):
blk.ratioP[t] = 1.8
else:
if not (value(blk.ratioP[t]) >= 0.01
and value(blk.ratioP[t]) <= 0.999):
blk.ratioP[t] = 0.7
blk.ratioP[t].fix()
unfix_ratioP[t] = True
if not blk.efficiency_isentropic[t].fixed:
if not (value(blk.efficiency_isentropic[t]) >= 0.05
and value(blk.efficiency_isentropic[t]) <= 1.0):
blk.efficiency_isentropic[t] = 0.8
blk.efficiency_isentropic[t].fix()
unfix_eff[t] = True
if state_args is None:
state_args = {}
state_dict = (cv.properties_in[t0].define_port_members())
for k in state_dict.keys():
if state_dict[k].is_indexed():
state_args[k] = {}
for m in state_dict[k].keys():
state_args[k][m] = state_dict[k][m].value
else:
state_args[k] = state_dict[k].value
# Get initialisation guesses for outlet and isentropic states
for k in state_args:
if k == "pressure" and k not in state_args_out:
# Work out how to estimate outlet pressure
if cv.properties_out[t0].pressure.fixed:
# Fixed outlet pressure, use this value
state_args_out[k] = value(cv.properties_out[t0].pressure)
elif blk.deltaP[t0].fixed:
state_args_out[k] = value(state_args[k] + blk.deltaP[t0])
elif blk.ratioP[t0].fixed:
state_args_out[k] = value(state_args[k] * blk.ratioP[t0])
else:
# Not obvious what to do, use inlet state
state_args_out[k] = state_args[k]
elif k not in state_args_out:
state_args_out[k] = state_args[k]
# Initialize state blocks
flags = cv.properties_in.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
hold_state=True,
state_args=state_args,
)
cv.properties_out.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
hold_state=False,
state_args=state_args_out,
)
init_log.info_high("Initialization Step 1 Complete.")
# ---------------------------------------------------------------------
# Initialize Isentropic block
blk.properties_isentropic.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=state_args_out,
)
init_log.info_high("Initialization Step 2 Complete.")
# ---------------------------------------------------------------------
# Solve for isothermal conditions
if isinstance(
blk.properties_isentropic[
blk.flowsheet().time.first()].temperature,
Var,
):
blk.properties_isentropic[:].temperature.fix()
elif isinstance(
blk.properties_isentropic[
blk.flowsheet().time.first()].enth_mol,
Var,
):
blk.properties_isentropic[:].enth_mol.fix()
elif isinstance(
blk.properties_isentropic[
blk.flowsheet().time.first()].temperature,
Expression,
):
def tmp_rule(b, t):
return blk.properties_isentropic[t].temperature == \
blk.control_volume.properties_in[t].temperature
blk.tmp_init_constraint = Constraint(blk.flowsheet().time,
rule=tmp_rule)
blk.isentropic.deactivate()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(blk, tee=slc.tee)
init_log.info_high("Initialization Step 3 {}.".format(
idaeslog.condition(res)))
if isinstance(
blk.properties_isentropic[
blk.flowsheet().time.first()].temperature,
Var,
):
blk.properties_isentropic[:].temperature.unfix()
elif isinstance(
blk.properties_isentropic[
blk.flowsheet().time.first()].enth_mol,
Var,
):
blk.properties_isentropic[:].enth_mol.unfix()
elif isinstance(
blk.properties_isentropic[
blk.flowsheet().time.first()].temperature,
Expression,
):
blk.del_component(blk.tmp_init_constraint)
blk.isentropic.activate()
# ---------------------------------------------------------------------
# Solve unit
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)))
if activate_performance_curves:
blk.performance_curve.activate()
for t, v in unfix_eff.items():
if v:
blk.efficiency_isentropic[t].unfix()
for t, v in unfix_ratioP.items():
if v:
blk.ratioP[t].unfix()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(blk, tee=slc.tee)
init_log.info_high(
f"Initialization Step 5 {idaeslog.condition(res)}.")
# ---------------------------------------------------------------------
# Release Inlet state
blk.control_volume.release_state(flags, outlvl)
if not check_optimal_termination(res):
raise InitializationError(
f"{blk.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
init_log.info(f"Initialization Complete: {idaeslog.condition(res)}")
def init_adiabatic(blk, state_args, outlvl, solver, optarg):
"""
Initialization routine for adiabatic pressure changers.
Keyword Arguments:
state_args : a dict of arguments to be passed to the property
package(s) to provide an initial state for
initialization (see documentation of the specific
property package) (default = {}).
outlvl : sets output level of initialization routine
optarg : solver options dictionary object (default={})
solver : str indicating which solver to use during
initialization (default = None)
Returns:
None
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit")
# Create solver
opt = get_solver(solver, optarg)
cv = blk.control_volume
t0 = blk.flowsheet().time.first()
state_args_out = {}
if state_args is None:
state_args = {}
state_dict = (cv.properties_in[t0].define_port_members())
for k in state_dict.keys():
if state_dict[k].is_indexed():
state_args[k] = {}
for m in state_dict[k].keys():
state_args[k][m] = state_dict[k][m].value
else:
state_args[k] = state_dict[k].value
# Get initialisation guesses for outlet and isentropic states
for k in state_args:
if k == "pressure" and k not in state_args_out:
# Work out how to estimate outlet pressure
if cv.properties_out[t0].pressure.fixed:
# Fixed outlet pressure, use this value
state_args_out[k] = value(cv.properties_out[t0].pressure)
elif blk.deltaP[t0].fixed:
state_args_out[k] = value(state_args[k] + blk.deltaP[t0])
elif blk.ratioP[t0].fixed:
state_args_out[k] = value(state_args[k] * blk.ratioP[t0])
else:
# Not obvious what to do, use inlet state
state_args_out[k] = state_args[k]
elif k not in state_args_out:
state_args_out[k] = state_args[k]
# Initialize state blocks
flags = cv.properties_in.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
hold_state=True,
state_args=state_args,
)
cv.properties_out.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
hold_state=False,
state_args=state_args_out,
)
init_log.info_high("Initialization Step 1 Complete.")
# ---------------------------------------------------------------------
# Solve unit
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(blk, tee=slc.tee)
init_log.info_high("Initialization Step 2 {}.".format(
idaeslog.condition(res)))
# ---------------------------------------------------------------------
# Release Inlet state
blk.control_volume.release_state(flags, outlvl)
if not check_optimal_termination(res):
raise InitializationError(
f"{blk.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
init_log.info(f"Initialization Complete: {idaeslog.condition(res)}")
def initialize(blk,
outlvl=idaeslog.NOTSET,
optarg=None,
solver=None,
hold_state=False):
"""
Initialization routine for mixer.
Keyword Arguments:
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. **Valid values:**
**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.
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit")
# Create solver
opt = get_solver(solver, optarg)
# Initialize inlet state blocks
flags = {}
inlet_list = blk.create_inlet_list()
i_block_list = []
for i in inlet_list:
i_block = getattr(blk, i + "_state")
i_block_list.append(i_block)
flags[i] = {}
flags[i] = i_block.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
hold_state=True,
)
# Initialize mixed state block
if blk.config.mixed_state_block is None:
mblock = blk.mixed_state
else:
mblock = blk.config.mixed_state_block
o_flags = {}
# Calculate initial guesses for mixed stream state
for t in blk.flowsheet().time:
# Iterate over state vars as defined by property package
s_vars = mblock[t].define_state_vars()
for s in s_vars:
i_vars = []
for k in s_vars[s]:
# Record whether variable was fixed or not
o_flags[t, s, k] = s_vars[s][k].fixed
# If fixed, use current value
# otherwise calculate guess from mixed state
if not s_vars[s][k].fixed:
for i in range(len(i_block_list)):
i_vars.append(
getattr(i_block_list[i][t],
s_vars[s].local_name))
if s == "pressure":
# If pressure, use minimum as initial guess
mblock[t].pressure.value = min(
i_block_list[i][t].pressure.value
for i in range(len(i_block_list)))
elif "flow" in s:
# If a "flow" variable (i.e. extensive), sum inlets
for k in s_vars[s]:
s_vars[s][k].value = sum(
i_vars[i][k].value
for i in range(len(i_block_list)))
else:
# Otherwise use average of inlets
for k in s_vars[s]:
s_vars[s][k].value = sum(
i_vars[i][k].value for i in range(
len(i_block_list))) / len(i_block_list)
mblock.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
hold_state=False,
)
res = None
# Revert fixed status of variables to what they were before
for t in blk.flowsheet().time:
s_vars = mblock[t].define_state_vars()
for s in s_vars:
for k in s_vars[s]:
s_vars[s][k].fixed = o_flags[t, s, k]
if blk.config.mixed_state_block is None:
if (hasattr(blk, "pressure_equality_constraints")
and blk.pressure_equality_constraints.active is True):
blk.pressure_equality_constraints.deactivate()
for t in blk.flowsheet().time:
sys_press = getattr(blk,
blk.create_inlet_list()[0] +
"_state")[t].pressure
blk.mixed_state[t].pressure.fix(sys_press.value)
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(blk, tee=slc.tee)
blk.pressure_equality_constraints.activate()
for t in blk.flowsheet().time:
blk.mixed_state[t].pressure.unfix()
else:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(blk, tee=slc.tee)
init_log.info("Initialization Complete: {}".format(
idaeslog.condition(res)))
else:
init_log.info("Initialization Complete.")
if res is not None and not check_optimal_termination(res):
raise InitializationError(
f"{blk.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
if hold_state is True:
return flags
else:
blk.release_state(flags, outlvl=outlvl)
def initialize(blk, liquid_state_args=None, vapor_state_args=None,
outlvl=idaeslog.NOTSET, solver=None, optarg=None):
'''
Initialization routine for solvent condenser unit model.
Keyword Arguments:
liquid_state_args : a dict of arguments to be passed to the
liquid property package to provide an initial state for
initialization (see documentation of the specific property
package) (default = none).
vapor_state_args : a dict of arguments to be passed to the
vapor property package to provide an initial state for
initialization (see documentation of the specific property
package) (default = none).
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 IDAES solver)
Returns:
None
'''
if optarg is None:
optarg = {}
# Check DOF
if degrees_of_freedom(blk) != 0:
raise InitializationError(
f"{blk.name} degrees of freedom were not 0 at the beginning "
f"of initialization. DoF = {degrees_of_freedom(blk)}")
# Set solver options
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit")
solverobj = get_solver(solver, optarg)
# ---------------------------------------------------------------------
# Initialize liquid phase control volume block
flags = blk.vapor_phase.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=vapor_state_args,
hold_state=True
)
init_log.info_high('Initialization Step 1 Complete.')
# ---------------------------------------------------------------------
# Initialize liquid phase state block
if liquid_state_args is None:
t_init = blk.flowsheet().time.first()
liquid_state_args = {}
liq_state_vars = blk.liquid_phase[t_init].define_state_vars()
vap_state = blk.vapor_phase.properties_out[t_init]
# Check for unindexed state variables
for sv in liq_state_vars:
if "flow" in sv:
# Flow varaible, assume 10% condensation
if "phase_comp" in sv:
# Flow is indexed by phase and component
liquid_state_args[sv] = {}
for p, j in liq_state_vars[sv]:
if j in vap_state.component_list:
liquid_state_args[sv][p, j] = 0.1*value(
getattr(vap_state, sv)[p, j])
else:
liquid_state_args[sv][p, j] = 1e-8
elif "comp" in sv:
# Flow is indexed by component
liquid_state_args[sv] = {}
for j in liq_state_vars[sv]:
if j in vap_state.component_list:
liquid_state_args[sv][j] = 0.1*value(
getattr(vap_state, sv)[j])
else:
liquid_state_args[sv][j] = 1e-8
elif "phase" in sv:
# Flow is indexed by phase
liquid_state_args[sv] = {}
for p in liq_state_vars[sv]:
liquid_state_args[sv][p] = 0.1*value(
getattr(vap_state, sv)["Vap"])
else:
liquid_state_args[sv] = 0.1*value(
getattr(vap_state, sv))
elif "mole_frac" in sv:
liquid_state_args[sv] = {}
if "phase" in sv:
# Variable is indexed by phase and component
for p, j in liq_state_vars[sv].keys():
if j in vap_state.component_list:
liquid_state_args[sv][p, j] = value(
vap_state.fug_phase_comp["Vap", j] /
vap_state.pressure)
else:
liquid_state_args[sv][p, j] = 1e-8
else:
for j in liq_state_vars[sv].keys():
if j in vap_state.component_list:
liquid_state_args[sv][j] = value(
vap_state.fug_phase_comp["Vap", j] /
vap_state.pressure)
else:
liquid_state_args[sv][j] = 1e-8
else:
liquid_state_args[sv] = value(
getattr(vap_state, sv))
blk.liquid_phase.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=liquid_state_args,
hold_state=False
)
init_log.info_high('Initialization Step 2 Complete.')
# ---------------------------------------------------------------------
# Solve unit model
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
results = solverobj.solve(blk, tee=slc.tee)
init_log.info_high(
"Initialization Step 3 {}.".format(idaeslog.condition(results))
)
# ---------------------------------------------------------------------
# Release Inlet state
blk.vapor_phase.release_state(flags, outlvl)
# TODO : This fails in the current model
# if not check_optimal_termination(results):
# raise InitializationError(
# f"{blk.name} failed to initialize successfully. Please check "
# f"the output logs for more information.")
init_log.info('Initialization Complete: {}'
.format(idaeslog.condition(results)))
def initialize(
self,
state_args=None,
hold_state=False,
state_vars_fixed=False,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None,
):
"""Initialisation routine for property package.
Key values for the state_args dict:
flow_mol_comp : value at which to initialize component flows
(default=27.5e3 mol/s)
pressure : value at which to initialize pressure
(default=2.97e7 Pa)
temperature : value at which to initialize temperature
(default=866.5 K)
Args:
outlvl: sets logging level
state_vars_fixed: Flag to denote state vars have been fixed.
- True - states have 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, 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(self.name, outlvl, tag="properties")
solve_log = idaeslog.getSolveLogger(self.name,
outlvl,
tag="properties")
# Create solver
opt = get_solver(solver, optarg)
if state_args is None:
state_args = {
"flow_mol_comp": {
"N2": 1.0,
"CO2": 1.0,
"NO": 1.0,
"O2": 1.0,
"H2O": 1.0,
"SO2": 1.0,
},
"pressure": 1e5,
"temperature": 495.0,
}
if state_vars_fixed is False:
flags = fix_state_vars(self, state_args)
# Check when the state vars are fixed already result in dof 0
for b in self.values():
if degrees_of_freedom(b) != 0:
raise InitializationError(
f"{self.name} State vars fixed but degrees of freedom not 0"
)
# ---------------------------------------------------------------------
# Solve 1st stage
for k, b in self.items():
deactivate_list = []
if hasattr(b, "enthalpy_correlation"):
deactivate_list.append(b.enthalpy_correlation)
if hasattr(b, "volumetric_flow_calculation"):
deactivate_list.append(b.volumetric_flow_calculation)
if hasattr(b, "entropy_correlation"):
deactivate_list.append(b.entropy_correlation)
for c in deactivate_list:
c.deactivate()
if number_activated_constraints(b) > 0:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(b, tee=slc.tee)
else:
res = "skipped"
init_log.info_high("Initialization Step 1 {}.".format(
idaeslog.condition(res)))
for c in deactivate_list:
c.activate()
if number_activated_constraints(b) > 0:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(b, tee=slc.tee)
else:
res = "skipped"
init_log.info_high("Initialization Step 2 {}.".format(
idaeslog.condition(res)))
if not res == "skipped" and not check_optimal_termination(res):
raise InitializationError(f"Solve failed {res}.")
init_log.info(f"Initialisation Complete, {idaeslog.condition(res)}.")
# ---------------------------------------------------------------------
# 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(self,
state_args=None,
solver=None,
optarg=None,
outlvl=idaeslog.NOTSET):
init_log = idaeslog.getInitLogger(self.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(self.name, outlvl, tag="unit")
solverobj = get_solver(solver, optarg)
# Initialize the inlet and outlet state blocks. Calling the state
# blocks initialize methods directly so that custom set of state args
# can be passed to the inlet and outlet state blocks as control_volume
# initialize method initializes the state blocks with the same
# state conditions.
flags = self.control_volume.properties_in. \
initialize(state_args=state_args,
solver=solver,
optarg=optarg,
outlvl=outlvl,
hold_state=True)
# Initialize outlet state block at same conditions of inlet except
# the temperature. Set the temperature to a temperature guess based
# on the desired boilup_ratio.
# Get index for bubble point temperature and and assume it
# will have only a single phase equilibrium pair. This is to
# support the generic property framework where the T_bubble
# is indexed by the phases_in_equilibrium. In distillation,
# the assumption is that there will only be a single pair
# i.e. vap-liq.
idx = next(
iter(self.control_volume.properties_in[0].temperature_bubble))
temp_guess = 0.5 * (
value(self.control_volume.properties_in[0].temperature_dew[idx]) -
value(self.control_volume.properties_in[0].
temperature_bubble[idx])) + \
value(self.control_volume.properties_in[0].temperature_bubble[idx])
state_args_outlet = {}
state_dict_outlet = (self.control_volume.properties_in[
self.flowsheet().time.first()].define_port_members())
for k in state_dict_outlet.keys():
if state_dict_outlet[k].is_indexed():
state_args_outlet[k] = {}
for m in state_dict_outlet[k].keys():
state_args_outlet[k][m] = value(state_dict_outlet[k][m])
else:
if k != "temperature":
state_args_outlet[k] = value(state_dict_outlet[k])
else:
state_args_outlet[k] = temp_guess
self.control_volume.properties_out.initialize(
state_args=state_args_outlet,
solver=solver,
optarg=optarg,
outlvl=outlvl,
hold_state=False)
if degrees_of_freedom(self) == 0:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solverobj.solve(self, tee=slc.tee)
init_log.info("Initialization Complete, {}.".format(
idaeslog.condition(res)))
else:
raise ConfigurationError(
"State vars fixed but degrees of freedom "
"for reboiler is not zero during "
"initialization. Please ensure that the boilup_ratio "
"or the outlet temperature is fixed.")
if not check_optimal_termination(res):
raise InitializationError(
f"{self.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
self.control_volume.properties_in.\
release_state(flags=flags, outlvl=outlvl)
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_pt(blk,
state_args=None,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None):
"""
Initialization routine for pass-through unit models.
Keyword Arguments:
state_args : a dict of arguments to be passed to the property
package(s) to provide an initial state for
initialization (see documentation of the specific
property package) (default = {}).
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 IDAES solver)
Returns:
None
"""
init_log = idaeslog.getInitLogger(blk.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(blk.name, outlvl, tag="unit")
solver_obj = get_solver(solver, optarg)
# Get initial guesses for inlet if none provided
if state_args is None:
state_args = {}
state_dict = blk.properties[
blk.flowsheet().time.first()].define_port_members()
for k in state_dict.keys():
if state_dict[k].is_indexed():
state_args[k] = {}
for m in state_dict[k].keys():
state_args[k][m] = state_dict[k][m].value
else:
state_args[k] = state_dict[k].value
# ---------------------------------------------------------------------
# Initialize control volume block
flags = blk.properties.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=state_args,
hold_state=True,
)
init_log.info_high("Initialization Step 1 Complete.")
# ---------------------------------------------------------------------
# Solve unit
if number_activated_constraints(blk) > 0:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
results = solver_obj.solve(blk, tee=slc.tee)
init_log.info_high("Initialization Step 2 {}.".format(
idaeslog.condition(results)))
# ---------------------------------------------------------------------
# Release Inlet state
blk.properties.release_state(flags, outlvl)
init_log.info("Initialization Complete: {}".format(
idaeslog.condition(results)))
if number_activated_constraints(blk) > 0 and not check_optimal_termination(
results):
raise InitializationError(
f"{blk.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
def initialize(
self,
shell_state_args=None,
tube_state_args=None,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None,
):
"""
Initialization routine for the unit.
Keyword Arguments:
state_args : a dict of arguments to be passed to the property
package(s) to provide an initial state for
initialization (see documentation of the specific
property package) (default = {}).
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)
Returns:
None
"""
init_log = idaeslog.getInitLogger(self.name, outlvl, tag="unit")
solve_log = idaeslog.getSolveLogger(self.name, outlvl, tag="unit")
# Create solver
opt = get_solver(solver, optarg)
# ---------------------------------------------------------------------
# Initialize shell block
flags_shell = self.shell.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=shell_state_args,
)
flags_tube = self.tube.initialize(
outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=tube_state_args,
)
init_log.info_high("Initialization Step 1 Complete.")
# ---------------------------------------------------------------------
# Solve unit
# Wall 0D
if self.config.has_wall_conduction == \
WallConductionType.zero_dimensional:
shell_units = self.config.shell_side.property_package.\
get_metadata().get_derived_units
for t in self.flowsheet().time:
for z in self.shell.length_domain:
self.temperature_wall[t, z].fix(
value(
0.5
* (
self.shell.properties[t, 0].temperature
+ pyunits.convert(
self.tube.properties[t, 0].temperature,
to_units=shell_units('temperature'))
)
)
)
self.tube.deactivate()
self.tube_heat_transfer_eq.deactivate()
self.wall_0D_model.deactivate()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(self, tee=slc.tee)
init_log.info_high(
"Initialization Step 2 {}.".format(idaeslog.condition(res))
)
self.tube.activate()
self.tube_heat_transfer_eq.activate()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(self, tee=slc.tee)
init_log.info_high(
"Initialization Step 3 {}.".format(idaeslog.condition(res))
)
self.wall_0D_model.activate()
self.temperature_wall.unfix()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = opt.solve(self, tee=slc.tee)
init_log.info_high(
"Initialization Step 4 {}.".format(idaeslog.condition(res))
)
else:
res = None
self.shell.release_state(flags_shell)
self.tube.release_state(flags_tube)
if res is not None and not check_optimal_termination(res):
raise InitializationError(
f"{self.name} failed to initialize successfully. Please check "
f"the output logs for more information.")
init_log.info("Initialization Complete.")