class HeatExchangerData(UnitModelBlockData):
"""
Simple 0D heat exchange unit.
Unit model to transfer heat from one material to another.
"""
CONFIG = UnitModelBlockData.CONFIG()
_make_heat_exchanger_config(CONFIG)
def set_scaling_factor_energy(self, f):
"""
This function sets scaling_factor_energy for both side_1 and side_2.
This factor multiplies the energy balance and heat transfer equations
in the heat exchnager. The value of this factor should be about
1/(expected heat duty).
Args:
f: Energy balance scaling factor
"""
self.side_1.scaling_factor_energy.value = f
self.side_2.scaling_factor_energy.value = f
def build(self):
"""
Building model
Args:
None
Returns:
None
"""
# Call UnitModel.build to setup dynamics
super().build()
config = self.config
# Add variables
self.overall_heat_transfer_coefficient = Var(
self.flowsheet().config.time,
domain=PositiveReals,
initialize=100,
doc="Overall heat transfer coefficient")
self.overall_heat_transfer_coefficient.latex_symbol = "U"
self.area = Var(domain=PositiveReals,
initialize=1000,
doc="Heat exchange area")
self.area.latex_symbol = "A"
if config.flow_pattern == HeatExchangerFlowPattern.crossflow:
self.crossflow_factor = Var(
self.flowsheet().config.time,
initialize=1,
doc="Factor to adjust coutercurrent flow heat transfer "
"calculation for cross flow.")
if config.delta_temperature_rule == delta_temperature_underwood2_rule:
# Define a cube root function that return the real negative root
# for the cube root of a negative number.
self.cbrt = ExternalFunction(library=functions_lib(),
function="cbrt")
# Add Control Volumes
_make_heater_control_volume(self,
"side_1",
config.side_1,
dynamic=config.dynamic,
has_holdup=config.has_holdup)
_make_heater_control_volume(self,
"side_2",
config.side_2,
dynamic=config.dynamic,
has_holdup=config.has_holdup)
# Add Ports
self.add_inlet_port(name="inlet_1", block=self.side_1)
self.add_inlet_port(name="inlet_2", block=self.side_2)
self.add_outlet_port(name="outlet_1", block=self.side_1)
self.add_outlet_port(name="outlet_2", block=self.side_2)
# Add convienient references to heat duty.
add_object_reference(self, "heat_duty", self.side_2.heat)
self.side_1.heat.latex_symbol = "Q_1"
self.side_2.heat.latex_symbol = "Q_2"
@self.Expression(self.flowsheet().config.time,
doc="Temperature difference at the side 1 inlet end")
def delta_temperature_in(b, t):
if b.config.flow_pattern == \
HeatExchangerFlowPattern.countercurrent:
return b.side_1.properties_in[t].temperature -\
b.side_2.properties_out[t].temperature
elif b.config.flow_pattern == HeatExchangerFlowPattern.cocurrent:
return b.side_1.properties_in[t].temperature -\
b.side_2.properties_in[t].temperature
elif b.config.flow_pattern == HeatExchangerFlowPattern.crossflow:
return b.side_1.properties_in[t].temperature -\
b.side_2.properties_out[t].temperature
else:
raise ConfigurationError(
"Flow pattern {} not supported".format(
b.config.flow_pattern))
@self.Expression(self.flowsheet().config.time,
doc="Temperature difference at the side 1 outlet end")
def delta_temperature_out(b, t):
if b.config.flow_pattern == \
HeatExchangerFlowPattern.countercurrent:
return b.side_1.properties_out[t].temperature -\
b.side_2.properties_in[t].temperature
elif b.config.flow_pattern == HeatExchangerFlowPattern.cocurrent:
return b.side_1.properties_out[t].temperature -\
b.side_2.properties_out[t].temperature
elif b.config.flow_pattern == HeatExchangerFlowPattern.crossflow:
return b.side_1.properties_out[t].temperature -\
b.side_2.properties_in[t].temperature
# Add a unit level energy balance
def unit_heat_balance_rule(b, t):
return 0 == self.side_1.heat[t] + self.side_2.heat[t]
self.unit_heat_balance = Constraint(self.flowsheet().config.time,
rule=unit_heat_balance_rule)
# Add heat transfer equation
self.delta_temperature = Expression(
self.flowsheet().config.time,
rule=config.delta_temperature_rule,
doc="Temperature difference driving force for heat transfer")
self.delta_temperature.latex_symbol = "\\Delta T"
if config.flow_pattern == HeatExchangerFlowPattern.crossflow:
self.heat_transfer_equation = Constraint(
self.flowsheet().config.time,
rule=_cross_flow_heat_transfer_rule)
else:
self.heat_transfer_equation = Constraint(
self.flowsheet().config.time, rule=_heat_transfer_rule)
def initialize(self,
state_args_1=None,
state_args_2=None,
outlvl=0,
solver='ipopt',
optarg={'tol': 1e-6},
duty=1000):
"""
Heat exchanger initialization method.
Args:
state_args_1 : a dict of arguments to be passed to the property
initialization for side_1 (see documentation of the specific
property package) (default = {}).
state_args_2 : a dict of arguments to be passed to the property
initialization for side_2 (see documentation of the specific
property package) (default = {}).
outlvl : sets output level of initialisation routine
* 0 = no output (default)
* 1 = return solver state for each step in routine
* 2 = return solver state for each step in subroutines
* 3 = include solver output infomation (tee=True)
optarg : solver options dictionary object (default={'tol': 1e-6})
solver : str indicating which solver to use during
initialization (default = 'ipopt')
duty : an initial guess for the amount of heat transfered
(default = 10000)
Returns:
None
"""
# Set solver options
tee = True if outlvl >= 3 else False
opt = SolverFactory(solver)
opt.options = optarg
flags1 = self.side_1.initialize(outlvl=outlvl - 1,
optarg=optarg,
solver=solver,
state_args=state_args_1)
if outlvl > 0:
_log.info('{} Initialization Step 1a (side_1) Complete.'.format(
self.name))
flags2 = self.side_2.initialize(outlvl=outlvl - 1,
optarg=optarg,
solver=solver,
state_args=state_args_2)
if outlvl > 0:
_log.info('{} Initialization Step 1b (side_2) Complete.'.format(
self.name))
# ---------------------------------------------------------------------
# Solve unit without heat transfer equation
self.heat_transfer_equation.deactivate()
self.side_2.heat.fix(duty)
results = opt.solve(self, tee=tee, symbolic_solver_labels=True)
if outlvl > 0:
if results.solver.termination_condition == \
TerminationCondition.optimal:
_log.info('{} Initialization Step 2 Complete.'.format(
self.name))
else:
_log.warning('{} Initialization Step 2 Failed.'.format(
self.name))
self.side_2.heat.unfix()
self.heat_transfer_equation.activate()
# ---------------------------------------------------------------------
# Solve unit
results = opt.solve(self, tee=tee, symbolic_solver_labels=True)
if outlvl > 0:
if results.solver.termination_condition == \
TerminationCondition.optimal:
_log.info('{} Initialization Step 3 Complete.'.format(
self.name))
else:
_log.warning('{} Initialization Step 3 Failed.'.format(
self.name))
# ---------------------------------------------------------------------
# Release Inlet state
self.side_1.release_state(flags1, outlvl - 1)
self.side_2.release_state(flags2, outlvl - 1)
if outlvl > 0:
_log.info('{} Initialization Complete.'.format(self.name))
class CondenserData(UnitModelBlockData):
"""
Condenser unit for distillation model.
Unit model to condense (total/partial) the vapor from the top tray of
the distillation column.
"""
CONFIG = UnitModelBlockData.CONFIG()
CONFIG.declare(
"condenser_type",
ConfigValue(
default=CondenserType.totalCondenser,
domain=In(CondenserType),
description="Type of condenser flag",
doc="""Indicates what type of condenser should be constructed,
**default** - CondenserType.totalCondenser.
**Valid values:** {
**CondenserType.totalCondenser** - Incoming vapor from top tray is condensed
to all liquid,
**CondenserType.partialCondenser** - Incoming vapor from top tray is
partially condensed to a vapor and liquid stream.}"""))
CONFIG.declare(
"temperature_spec",
ConfigValue(default=None,
domain=In(TemperatureSpec),
description="Temperature spec for the condenser",
doc="""Temperature specification for the condenser,
**default** - TemperatureSpec.none
**Valid values:** {
**TemperatureSpec.none** - No spec is selected,
**TemperatureSpec.atBubblePoint** - Condenser temperature set at
bubble point i.e. total condenser,
**TemperatureSpec.customTemperature** - Condenser temperature at
user specified temperature.}"""))
CONFIG.declare(
"material_balance_type",
ConfigValue(
default=MaterialBalanceType.useDefault,
domain=In(MaterialBalanceType),
description="Material balance construction flag",
doc="""Indicates what type of mass balance should be constructed,
**default** - MaterialBalanceType.componentPhase.
**Valid values:** {
**MaterialBalanceType.none** - exclude material balances,
**MaterialBalanceType.componentPhase** - use phase component balances,
**MaterialBalanceType.componentTotal** - use total component balances,
**MaterialBalanceType.elementTotal** - use total element balances,
**MaterialBalanceType.total** - use total material balance.}"""))
CONFIG.declare(
"energy_balance_type",
ConfigValue(
default=EnergyBalanceType.useDefault,
domain=In(EnergyBalanceType),
description="Energy balance construction flag",
doc="""Indicates what type of energy balance should be constructed,
**default** - EnergyBalanceType.enthalpyTotal.
**Valid values:** {
**EnergyBalanceType.none** - exclude energy balances,
**EnergyBalanceType.enthalpyTotal** - single enthalpy balance for material,
**EnergyBalanceType.enthalpyPhase** - enthalpy balances for each phase,
**EnergyBalanceType.energyTotal** - single energy balance for material,
**EnergyBalanceType.energyPhase** - energy balances for each phase.}"""))
CONFIG.declare(
"momentum_balance_type",
ConfigValue(
default=MomentumBalanceType.pressureTotal,
domain=In(MomentumBalanceType),
description="Momentum balance construction flag",
doc="""Indicates what type of momentum balance should be constructed,
**default** - MomentumBalanceType.pressureTotal.
**Valid values:** {
**MomentumBalanceType.none** - exclude momentum balances,
**MomentumBalanceType.pressureTotal** - single pressure balance for material,
**MomentumBalanceType.pressurePhase** - pressure balances for each phase,
**MomentumBalanceType.momentumTotal** - single momentum balance for material,
**MomentumBalanceType.momentumPhase** - momentum balances for each phase.}"""))
CONFIG.declare(
"has_pressure_change",
ConfigValue(
default=False,
domain=In([True, False]),
description="Pressure change term construction flag",
doc="""Indicates whether terms for pressure change should be
constructed,
**default** - False.
**Valid values:** {
**True** - include pressure change terms,
**False** - exclude pressure change terms.}"""))
CONFIG.declare(
"property_package",
ConfigValue(
default=useDefault,
domain=is_physical_parameter_block,
description="Property package to use for control volume",
doc=
"""Property parameter object used to define property calculations,
**default** - useDefault.
**Valid values:** {
**useDefault** - use default package from parent model or flowsheet,
**PropertyParameterObject** - a PropertyParameterBlock object.}"""))
CONFIG.declare(
"property_package_args",
ConfigBlock(
implicit=True,
description="Arguments to use for constructing property packages",
doc=
"""A ConfigBlock with arguments to be passed to a property block(s)
and used when constructing these,
**default** - None.
**Valid values:** {
see property package for documentation.}"""))
def build(self):
"""Build the model.
Args:
None
Returns:
None
"""
# Setup model build logger
model_log = idaeslog.getModelLogger(self.name, tag="unit")
# Call UnitModel.build to setup dynamics
super(CondenserData, self).build()
# Check config arguments
if self.config.temperature_spec is None:
raise ConfigurationError("temperature_spec config argument "
"has not been specified. Please select "
"a valid option.")
if (self.config.condenser_type == CondenserType.partialCondenser) and \
(self.config.temperature_spec ==
TemperatureSpec.atBubblePoint):
raise ConfigurationError("condenser_type set to partial but "
"temperature_spec set to atBubblePoint. "
"Select customTemperature and specify "
"outlet temperature.")
# Add Control Volume for the condenser
self.control_volume = ControlVolume0DBlock(
default={
"dynamic": self.config.dynamic,
"has_holdup": self.config.has_holdup,
"property_package": self.config.property_package,
"property_package_args": self.config.property_package_args
})
self.control_volume.add_state_blocks(has_phase_equilibrium=True)
self.control_volume.add_material_balances(
balance_type=self.config.material_balance_type,
has_phase_equilibrium=True)
self.control_volume.add_energy_balances(
balance_type=self.config.energy_balance_type,
has_heat_transfer=True)
self.control_volume.add_momentum_balances(
balance_type=self.config.momentum_balance_type,
has_pressure_change=self.config.has_pressure_change)
# Get liquid and vapor phase objects from the property package
# to be used below. Avoids repition.
_liquid_list = []
_vapor_list = []
for p in self.config.property_package.phase_list:
pobj = self.config.property_package.get_phase(p)
if pobj.is_vapor_phase():
_vapor_list.append(p)
elif pobj.is_liquid_phase():
_liquid_list.append(p)
else:
_liquid_list.append(p)
model_log.warning(
"A non-liquid/non-vapor phase was detected but will "
"be treated as a liquid.")
# Create a pyomo set for indexing purposes. This set is appended to
# model otherwise results in an abstract set.
self._liquid_set = Set(initialize=_liquid_list)
self._vapor_set = Set(initialize=_vapor_list)
self._make_ports()
if self.config.condenser_type == CondenserType.totalCondenser:
self._make_splits_total_condenser()
if (self.config.temperature_spec == TemperatureSpec.atBubblePoint):
# Option 1: if true, condition for total condenser
# (T_cond = T_bubble)
# Option 2: if this is false, then user has selected
# custom temperature spec and needs to fix an outlet
# temperature.
def rule_total_cond(self, t):
return self.control_volume.properties_out[t].\
temperature == self.control_volume.properties_out[t].\
temperature_bubble
self.eq_total_cond_spec = Constraint(self.flowsheet().time,
rule=rule_total_cond)
else:
self._make_splits_partial_condenser()
# Add object reference to variables of the control volume
# Reference to the heat duty
self.heat_duty = Reference(self.control_volume.heat[:])
# Reference to the pressure drop (if set to True)
if self.config.has_pressure_change:
self.deltaP = Reference(self.control_volume.deltaP[:])
def _make_ports(self):
# Add Ports for the condenser
# Inlet port (the vapor from the top tray)
self.add_inlet_port()
# Outlet ports that always exist irrespective of condenser type
self.reflux = Port(noruleinit=True,
doc="Reflux stream that is"
" returned to the top tray.")
self.distillate = Port(noruleinit=True,
doc="Distillate stream that is"
" the top product.")
if self.config.condenser_type == CondenserType.partialCondenser:
self.vapor_outlet = Port(noruleinit=True,
doc="Vapor outlet port from a "
"partial condenser")
# Add codnenser specific variables
self.reflux_ratio = Var(initialize=1,
doc="Reflux ratio for the condenser")
def _make_splits_total_condenser(self):
# Get dict of Port members and names
member_list = self.control_volume.\
properties_out[0].define_port_members()
# Create references and populate the reflux, distillate ports
for k in member_list:
# Create references and populate the intensive variables
if "flow" not in k:
if not member_list[k].is_indexed():
var = self.control_volume.properties_out[:].\
component(member_list[k].local_name)
else:
var = self.control_volume.properties_out[:].\
component(member_list[k].local_name)[...]
# add the reference and variable name to the reflux port
self.reflux.add(Reference(var), k)
# add the reference and variable name to the distillate port
self.distillate.add(Reference(var), k)
elif "flow" in k:
# Create references and populate the extensive variables
# This is for vars that are not indexed
if not member_list[k].is_indexed():
# Expression for reflux flow and relation to the
# reflux_ratio variable
def rule_reflux_flow(self, t):
return self.control_volume.properties_out[t].\
component(member_list[k].local_name) * \
(self.reflux_ratio / (1 + self.reflux_ratio))
self.e_reflux_flow = Expression(self.flowsheet().time,
rule=rule_reflux_flow)
self.reflux.add(self.e_reflux_flow, k)
# Expression for distillate flow and relation to the
# reflux_ratio variable
def rule_distillate_flow(self, t):
return self.control_volume.properties_out[t].\
component(member_list[k].local_name) / \
(1 + self.reflux_ratio)
self.e_distillate_flow = Expression(
self.flowsheet().time, rule=rule_distillate_flow)
self.distillate.add(self.e_distillate_flow, k)
else:
# Create references and populate the extensive variables
# This is for vars that are indexed by phase, comp or both.
index_set = member_list[k].index_set()
def rule_reflux_flow(self, t, *args):
return self.control_volume.properties_out[t].\
component(member_list[k].local_name)[args] * \
(self.reflux_ratio / (1 + self.reflux_ratio))
self.e_reflux_flow = Expression(self.flowsheet().time,
index_set,
rule=rule_reflux_flow)
self.reflux.add(self.e_reflux_flow, k)
def rule_distillate_flow(self, t, *args):
return self.control_volume.properties_out[t].\
component(member_list[k].local_name)[args] / \
(1 + self.reflux_ratio)
self.e_distillate_flow = Expression(
self.flowsheet().time,
index_set,
rule=rule_distillate_flow)
self.distillate.add(self.e_distillate_flow, k)
else:
raise PropertyNotSupportedError(
"Unrecognized names for flow variables encountered while "
"building the condenser ports.")
def _make_splits_partial_condenser(self):
# Get dict of Port members and names
member_list = self.control_volume.\
properties_out[0].define_port_members()
# Create references and populate the reflux, distillate ports
for k in member_list:
# Create references and populate the intensive variables
if "flow" not in k and "frac" not in k and "enth" not in k:
if not member_list[k].is_indexed():
var = self.control_volume.properties_out[:].\
component(member_list[k].local_name)
else:
var = self.control_volume.properties_out[:].\
component(member_list[k].local_name)[...]
# add the reference and variable name to the reflux port
self.reflux.add(Reference(var), k)
# add the reference and variable name to the distillate port
self.distillate.add(Reference(var), k)
# add the reference and variable name to the
# vapor outlet port
self.vapor_outlet.add(Reference(var), k)
elif "frac" in k:
# Mole/mass frac is typically indexed
index_set = member_list[k].index_set()
# if state var is not mole/mass frac by phase
if "phase" not in k:
if "mole" in k: # check mole basis/mass basis
# The following conditionals are required when a
# mole frac or mass frac is a state var i.e. will be
# a port member. This gets a bit tricky when handling
# non-conventional systems when you have more than one
# liquid or vapor phase. Hence, the logic here is that
# the mole frac that should be present in the liquid or
# vapor port should be computed by accounting for
# multiple liquid or vapor phases if present. For the
# classical VLE system, this holds too.
if hasattr(self.control_volume.properties_out[0],
"mole_frac_phase_comp") and \
hasattr(self.control_volume.properties_out[0],
"flow_mol_phase"):
flow_phase_comp = False
local_name_frac = "mole_frac_phase_comp"
local_name_flow = "flow_mol_phase"
elif hasattr(self.control_volume.properties_out[0],
"flow_mol_phase_comp"):
flow_phase_comp = True
local_name_flow = "flow_mol_phase_comp"
else:
raise PropertyNotSupportedError(
"No mole_frac_phase_comp or flow_mol_phase or"
" flow_mol_phase_comp variables encountered "
"while building ports for the condenser. ")
elif "mass" in k:
if hasattr(self.control_volume.properties_out[0],
"mass_frac_phase_comp") and \
hasattr(self.control_volume.properties_out[0],
"flow_mass_phase"):
flow_phase_comp = False
local_name_frac = "mass_frac_phase_comp"
local_name_flow = "flow_mass_phase"
elif hasattr(self.control_volume.properties_out[0],
"flow_mass_phase_comp"):
flow_phase_comp = True
local_name_flow = "flow_mass_phase_comp"
else:
raise PropertyNotSupportedError(
"No mass_frac_phase_comp or flow_mass_phase or"
" flow_mass_phase_comp variables encountered "
"while building ports for the condenser.")
else:
raise PropertyNotSupportedError(
"No mass frac or mole frac variables encountered "
" while building ports for the condenser. "
"phase_frac as a state variable is not "
"supported with distillation unit models.")
# Rule for liquid phase mole fraction
def rule_liq_frac(self, t, i):
if not flow_phase_comp:
sum_flow_comp = sum(
self.control_volume.properties_out[t].
component(local_name_frac)[p, i] *
self.control_volume.properties_out[t].
component(local_name_flow)[p]
for p in self._liquid_set)
return sum_flow_comp / sum(
self.control_volume.properties_out[t].
component(local_name_flow)[p]
for p in self._liquid_set)
else:
sum_flow_comp = sum(
self.control_volume.properties_out[t].
component(local_name_flow)[p, i]
for p in self._liquid_set)
return sum_flow_comp / sum(
self.control_volume.properties_out[t].
component(local_name_flow)[p, i]
for p in self._liquid_set for i in
self.config.property_package.component_list)
self.e_liq_frac = Expression(self.flowsheet().time,
index_set,
rule=rule_liq_frac)
# Rule for vapor phase mass/mole fraction
def rule_vap_frac(self, t, i):
if not flow_phase_comp:
sum_flow_comp = sum(
self.control_volume.properties_out[t].
component(local_name_frac)[p, i] *
self.control_volume.properties_out[t].
component(local_name_flow)[p]
for p in self._vapor_set)
return sum_flow_comp / sum(
self.control_volume.properties_out[t].
component(local_name_flow)[p]
for p in self._vapor_set)
else:
sum_flow_comp = sum(
self.control_volume.properties_out[t].
component(local_name_flow)[p, i]
for p in self._vapor_set)
return sum_flow_comp / sum(
self.control_volume.properties_out[t].
component(local_name_flow)[p, i]
for p in self._vapor_set for i in
self.config.property_package.component_list)
self.e_vap_frac = Expression(self.flowsheet().time,
index_set,
rule=rule_vap_frac)
# add the reference and variable name to the reflux port
self.reflux.add(self.e_liq_frac, k)
# add the reference and variable name to the
# distillate port
self.distillate.add(self.e_liq_frac, k)
# add the reference and variable name to the
# vapor port
self.vapor_outlet.add(self.e_vap_frac, k)
else:
# Assumes mole_frac_phase or mass_frac_phase exist as
# state vars in the port and therefore access directly
# from the state block.
var = self.control_volume.properties_out[:].\
component(member_list[k].local_name)[...]
# add the reference and variable name to the reflux port
self.reflux.add(Reference(var), k)
# add the reference and variable name to the distillate port
self.distillate.add(Reference(var), k)
elif "flow" in k:
if "phase" not in k:
# Assumes that here the var is total flow or component
# flow. However, need to extract the flow by phase from
# the state block. Expects to find the var
# flow_mol_phase or flow_mass_phase in the state block.
# Check if it is not indexed by component list and this
# is total flow
if not member_list[k].is_indexed():
# if state var is not flow_mol/flow_mass by phase
local_name = str(member_list[k].local_name) + \
"_phase"
# Rule for vap phase flow
def rule_vap_flow(self, t):
return sum(self.control_volume.properties_out[t].
component(local_name)[p]
for p in self._vapor_set)
self.e_vap_flow = Expression(self.flowsheet().time,
rule=rule_vap_flow)
# Rule to link the liq phase flow to the reflux
def rule_reflux_flow(self, t):
return sum(self.control_volume.properties_out[t].
component(local_name)[p]
for p in self._liquid_set) * \
(self.reflux_ratio / (1 + self.reflux_ratio))
self.e_reflux_flow = Expression(self.flowsheet().time,
rule=rule_reflux_flow)
# Rule to link the liq flow to the distillate
def rule_distillate_flow(self, t):
return sum(self.control_volume.properties_out[t].
component(local_name)[p]
for p in self._liquid_set) / \
(1 + self.reflux_ratio)
self.e_distillate_flow = Expression(
self.flowsheet().time, rule=rule_distillate_flow)
else:
# when it is flow comp indexed by component list
str_split = \
str(member_list[k].local_name).split("_")
if len(str_split) == 3 and str_split[-1] == "comp":
local_name = str_split[0] + "_" + \
str_split[1] + "_phase_" + "comp"
# Get the indexing set i.e. component list
index_set = member_list[k].index_set()
# Rule for vap phase flow to the vapor outlet
def rule_vap_flow(self, t, i):
return sum(self.control_volume.properties_out[t].
component(local_name)[p, i]
for p in self._vapor_set)
self.e_vap_flow = Expression(self.flowsheet().time,
index_set,
rule=rule_vap_flow)
# Rule to link the liq flow to the reflux
def rule_reflux_flow(self, t, i):
return sum(self.control_volume.properties_out[t].
component(local_name)[p, i]
for p in self._liquid_set) * \
(self.reflux_ratio / (1 + self.reflux_ratio))
self.e_reflux_flow = Expression(self.flowsheet().time,
index_set,
rule=rule_reflux_flow)
# Rule to link the liq flow to the distillate
def rule_distillate_flow(self, t, i):
return sum(self.control_volume.properties_out[t].
component(local_name)[p, i]
for p in self._liquid_set) / \
(1 + self.reflux_ratio)
self.e_distillate_flow = Expression(
self.flowsheet().time,
index_set,
rule=rule_distillate_flow)
# add the reference and variable name to the reflux port
self.reflux.add(self.e_reflux_flow, k)
# add the reference and variable name to the
# distillate port
self.distillate.add(self.e_distillate_flow, k)
# add the reference and variable name to the
# distillate port
self.vapor_outlet.add(self.e_vap_flow, k)
elif "enth" in k:
if "phase" not in k:
# assumes total mixture enthalpy (enth_mol or enth_mass)
# and hence should not be indexed by phase
if not member_list[k].is_indexed():
# if state var is not enth_mol/enth_mass
# by phase, add _phase string to extract the right
# value from the state block
local_name = str(member_list[k].local_name) + \
"_phase"
else:
raise PropertyPackageError(
"Enthalpy is indexed but the variable "
"name does not reflect the presence of an index. "
"Please follow the naming convention outlined "
"in the documentation for state variables.")
# NOTE:pass phase index when generating expression only
# when multiple liquid or vapor phases detected
# else ensure consistency with state vars and do not
# add phase index to the port members. Hence, the check
# for length of local liq and vap phase sets.
# Rule for vap enthalpy. Setting the enthalpy to the
# enth_mol_phase['Vap'] value from the state block
def rule_vap_enth(self, t):
return sum(
self.control_volume.properties_out[t].component(
local_name)[p] for p in self._vapor_set)
self.e_vap_enth = Expression(self.flowsheet().time,
rule=rule_vap_enth)
# Rule to link the liq enthalpy to the reflux.
# Setting the enthalpy to the
# enth_mol_phase['Liq'] value from the state block
def rule_reflux_enth(self, t):
return sum(
self.control_volume.properties_out[t].component(
local_name)[p] for p in self._liquid_set)
self.e_reflux_enth = Expression(self.flowsheet().time,
rule=rule_reflux_enth)
# Rule to link the liq flow to the distillate.
# Setting the enthalpy to the
# enth_mol_phase['Liq'] value from the state block
def rule_distillate_enth(self, t):
return sum(
self.control_volume.properties_out[t].component(
local_name)[p] for p in self._liquid_set)
self.e_distillate_enth = Expression(
self.flowsheet().time, rule=rule_distillate_enth)
# add the reference and variable name to the reflux port
self.reflux.add(self.e_reflux_enth, k)
# add the reference and variable name to the
# distillate port
self.distillate.add(self.e_distillate_enth, k)
# add the reference and variable name to the
# distillate port
self.vapor_outlet.add(self.e_vap_enth, k)
elif "phase" in k:
# assumes enth_mol_phase or enth_mass_phase.
# This is an intensive property, you create a direct
# reference irrespective of the reflux, distillate and
# vap_outlet
# Rule for vap flow
if not member_list[k].is_indexed():
var = self.control_volume.properties_out[:].\
component(member_list[k].local_name)
else:
var = self.control_volume.properties_out[:].\
component(member_list[k].local_name)[...]
# add the reference and variable name to the reflux port
self.reflux.add(Reference(var), k)
# add the reference and variable name to the distillate port
self.distillate.add(Reference(var), k)
# add the reference and variable name to the
# vapor outlet port
self.vapor_outlet.add(Reference(var), k)
else:
raise PropertyNotSupportedError(
"Unrecognized enthalpy state variable encountered "
"while building ports for the condenser. Only total "
"mixture enthalpy or enthalpy by phase are supported.")
def initialize(self, solver=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.")
if self.config.condenser_type == CondenserType.totalCondenser:
self.eq_total_cond_spec.deactivate()
# Initialize the inlet and outlet state blocks
self.control_volume.initialize(outlvl=outlvl)
# Activate the total condenser spec
if self.config.condenser_type == CondenserType.totalCondenser:
self.eq_total_cond_spec.activate()
if solver is not None:
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solver.solve(self, tee=slc.tee)
init_log.info("Initialization Complete, {}.".format(
idaeslog.condition(res)))
else:
init_log.warning(
"Solver not provided during initialization, proceeding"
" with deafult solver in idaes.")
solver = get_default_solver()
with idaeslog.solver_log(solve_log, idaeslog.DEBUG) as slc:
res = solver.solve(self, tee=slc.tee)
init_log.info("Initialization Complete, {}.".format(
idaeslog.condition(res)))
def _get_performance_contents(self, time_point=0):
var_dict = {}
if hasattr(self, "heat_duty"):
var_dict["Heat Duty"] = self.heat_duty[time_point]
if hasattr(self, "deltaP"):
var_dict["Pressure Change"] = self.deltaP[time_point]
return {"vars": var_dict}
def _get_stream_table_contents(self, time_point=0):
stream_attributes = {}
if self.config.condenser_type == CondenserType.totalCondenser:
stream_dict = {
"Inlet": "inlet",
"Reflux": "reflux",
"Distillate": "distillate"
}
else:
stream_dict = {
"Inlet": "inlet",
"Vapor Outlet": "vapor_outlet",
"Reflux": "reflux",
"Distillate": "distillate"
}
for n, v in stream_dict.items():
port_obj = getattr(self, v)
stream_attributes[n] = {}
for k in port_obj.vars:
for i in port_obj.vars[k].keys():
if isinstance(i, float):
stream_attributes[n][k] = value(
port_obj.vars[k][time_point])
else:
if len(i) == 2:
kname = str(i[1])
else:
kname = str(i[1:])
stream_attributes[n][k + " " + kname] = \
value(port_obj.vars[k][time_point, i[1:]])
return DataFrame.from_dict(stream_attributes, orient="columns")
class PlateHeatExchangerData(HeatExchangerNTUData):
"""Plate Heat Exchanger(PHE) Unit Model."""
CONFIG = HeatExchangerNTUData.CONFIG()
CONFIG.declare(
"passes",
ConfigValue(
default=4,
domain=Integer,
description="Number of passes",
doc="""Number of passes of the fluids through the heat exchanger"""
))
CONFIG.declare(
"channels_per_pass",
ConfigValue(
default=12,
domain=Integer,
description="Number of channels for each pass",
doc="""Number of channels to be used in each pass where a channel
is the space between two plates with a flowing fluid"""))
CONFIG.declare(
"number_of_divider_plates",
ConfigValue(
default=0,
domain=Integer,
description="Number of divider plates in heat exchanger",
doc="""Divider plates are used to create separate partitions in the
unit. Each pass can be separated by a divider plate"""))
# Update config block setting for pressure change to always be true
CONFIG.hot_side.has_pressure_change = True
CONFIG.hot_side.get("has_pressure_change").set_domain(In([True]))
CONFIG.hot_side.get("has_pressure_change")._description = (
"Pressure change term construction flag - must be True")
CONFIG.hot_side.get("has_pressure_change")._doc = (
"Plate Heat Exchanger model includes correlations for pressure drop "
"thus has_pressure_change must be True")
CONFIG.cold_side.has_pressure_change = True
CONFIG.cold_side.get("has_pressure_change").set_domain(In([True]))
CONFIG.cold_side.get("has_pressure_change")._description = (
"Pressure change term construction flag - must be True")
CONFIG.cold_side.get("has_pressure_change")._doc = (
"Plate Heat Exchanger model includes correlations for pressure drop "
"thus has_pressure_change must be True")
def build(self):
# Call super.build to setup model
# This will create the control volumes, ports and basic equations
super().build()
# Units will be based on hot side properties
units_meta = self.config.hot_side.property_package.get_metadata(
).get_derived_units
# ---------------------------------------------------------------------
# Plate design variables and parameter
self.number_of_passes = Param(initialize=self.config.passes,
units=pyunits.dimensionless,
domain=PositiveIntegers,
doc="Number of hot/cold fluid passes",
mutable=True)
# Assuming number of channels is equal in all plates
self.channels_per_pass = Param(
initialize=self.config.channels_per_pass,
units=pyunits.dimensionless,
domain=PositiveIntegers,
doc="Number of channels in each pass",
mutable=True)
self.number_of_divider_plates = Param(
initialize=self.config.number_of_divider_plates,
units=pyunits.dimensionless,
domain=NonNegativeIntegers,
doc="Number of divider plates in heat exchanger",
mutable=True)
self.plate_length = Var(initialize=1.6925,
units=units_meta("length"),
domain=PositiveReals,
doc="Length of heat exchanger plate")
self.plate_width = Var(initialize=0.6135,
units=units_meta("length"),
domain=PositiveReals,
doc="Width of heat exchanger plate")
self.plate_thickness = Var(initialize=0.0006,
units=units_meta("length"),
domain=PositiveReals,
doc="Thickness of heat exchanger plate")
self.plate_pact_length = Var(initialize=0.381,
units=units_meta("length"),
domain=PositiveReals,
doc="Compressed plate pact length")
self.port_diameter = Var(initialize=0.2045,
units=units_meta("length"),
domain=PositiveReals,
doc="Port diamter")
self.plate_therm_cond = Var(
initialize=16.2,
units=units_meta("thermal_conductivity"),
domain=PositiveReals,
doc="Thermal conductivity heat exchanger plates")
# Set default value of total heat transfer area
self.area.set_value(114.3)
# ---------------------------------------------------------------------
# Derived geometric quantities
total_plates = (2 * self.channels_per_pass * self.number_of_passes +
1 + self.number_of_divider_plates)
total_active_plates = (
2 * self.channels_per_pass * self.number_of_passes -
(1 + self.number_of_divider_plates))
self.plate_gap = Expression(
expr=self.plate_pact_length / total_plates - self.plate_thickness)
self.plate_area = Expression(expr=self.area / total_active_plates,
doc='Heat transfer area of single plate')
self.surface_enlargement_factor = Expression(
expr=self.plate_area / (self.plate_length * self.plate_width))
# Channel equivalent diameter
self.channel_diameter = Expression(expr=2 * self.plate_gap /
self.surface_enlargement_factor,
doc="Channel equivalent diameter")
# ---------------------------------------------------------------------
# Fluid velocities
def rule_port_vel_hot(blk, t):
return (4 * blk.hot_side.properties_in[t].flow_vol /
(Constants.pi * blk.port_diameter**2))
self.hot_port_velocity = Expression(self.flowsheet().time,
rule=rule_port_vel_hot,
doc='Hot side port velocity')
def rule_port_vel_cold(blk, t):
return (4 *
pyunits.convert(blk.cold_side.properties_in[t].flow_vol,
to_units=units_meta("flow_vol")) /
(Constants.pi * blk.port_diameter**2))
self.cold_port_velocity = Expression(self.flowsheet().time,
rule=rule_port_vel_cold,
doc='Cold side port velocity')
def rule_channel_vel_hot(blk, t):
return (blk.hot_side.properties_in[t].flow_vol /
(blk.channels_per_pass * blk.plate_width * blk.plate_gap))
self.hot_channel_velocity = Expression(self.flowsheet().time,
rule=rule_channel_vel_hot,
doc='Hot side channel velocity')
def rule_channel_vel_cold(blk, t):
return (pyunits.convert(blk.cold_side.properties_in[t].flow_vol,
to_units=units_meta("flow_vol")) /
(blk.channels_per_pass * blk.plate_width * blk.plate_gap))
self.cold_channel_velocity = Expression(
self.flowsheet().time,
rule=rule_channel_vel_cold,
doc='Cold side channel velocity')
# ---------------------------------------------------------------------
# Reynolds & Prandtl numbers
# Density cancels out of Reynolds number if mass flow rate is used
def rule_Re_h(blk, t):
return (blk.hot_side.properties_in[t].flow_mass *
blk.channel_diameter /
(blk.channels_per_pass * blk.plate_width * blk.plate_gap *
blk.hot_side.properties_in[t].visc_d_phase["Liq"]))
self.Re_hot = Expression(self.flowsheet().time,
rule=rule_Re_h,
doc='Hot side Reynolds number')
def rule_Re_c(blk, t):
return (pyunits.convert(
blk.cold_side.properties_in[t].flow_mass /
blk.cold_side.properties_in[t].visc_d_phase["Liq"],
to_units=units_meta("length")) * blk.channel_diameter /
(blk.channels_per_pass * blk.plate_width * blk.plate_gap))
self.Re_cold = Expression(self.flowsheet().time,
rule=rule_Re_c,
doc='Cold side Reynolds number')
def rule_Pr_h(blk, t):
return (blk.hot_side.properties_in[t].cp_mol /
blk.hot_side.properties_in[t].mw *
blk.hot_side.properties_in[t].visc_d_phase["Liq"] /
blk.hot_side.properties_in[t].therm_cond_phase["Liq"])
self.Pr_hot = Expression(self.flowsheet().time,
rule=rule_Pr_h,
doc='Hot side Prandtl number')
def rule_Pr_c(blk, t):
return (blk.cold_side.properties_in[t].cp_mol /
blk.cold_side.properties_in[t].mw *
blk.cold_side.properties_in[t].visc_d_phase["Liq"] /
blk.cold_side.properties_in[t].therm_cond_phase["Liq"])
self.Pr_cold = Expression(self.flowsheet().time,
rule=rule_Pr_c,
doc='Cold side Prandtl number')
# ---------------------------------------------------------------------
# Heat transfer coefficients
# Parameters for Nusselt number correlation
self.Nusselt_param_a = Param(initialize=0.4,
domain=PositiveReals,
units=pyunits.dimensionless,
mutable=True,
doc='Nusselt parameter A')
self.Nusselt_param_b = Param(initialize=0.663,
domain=PositiveReals,
units=pyunits.dimensionless,
mutable=True,
doc='Nusselt parameter B')
self.Nusselt_param_c = Param(initialize=0.333,
domain=PositiveReals,
units=pyunits.dimensionless,
mutable=True,
doc='Nusselt parameter C')
# Film heat transfer coefficients
def rule_hotside_transfer_coeff(blk, t):
return (blk.hot_side.properties_in[t].therm_cond_phase["Liq"] /
blk.channel_diameter * blk.Nusselt_param_a *
blk.Re_hot[t]**blk.Nusselt_param_b *
blk.Pr_hot[t]**blk.Nusselt_param_c)
self.heat_transfer_coefficient_hot_side = Expression(
self.flowsheet().time,
rule=rule_hotside_transfer_coeff,
doc='Hot side heat transfer coefficient')
def rule_coldside_transfer_coeff(blk, t):
return (pyunits.convert(
blk.cold_side.properties_in[t].therm_cond_phase["Liq"],
to_units=units_meta("thermal_conductivity")) /
blk.channel_diameter * blk.Nusselt_param_a *
blk.Re_cold[t]**blk.Nusselt_param_b *
blk.Pr_cold[t]**blk.Nusselt_param_c)
self.heat_transfer_coefficient_cold_side = Expression(
self.flowsheet().time,
rule=rule_coldside_transfer_coeff,
doc='Cold side heat transfer coefficient')
# Overall heat transfer coefficient
def rule_U(blk, t):
return blk.heat_transfer_coefficient[t] == (
1.0 / (1.0 / blk.heat_transfer_coefficient_hot_side[t] +
blk.plate_gap / blk.plate_therm_cond +
1.0 / blk.heat_transfer_coefficient_cold_side[t]))
self.overall_heat_transfer_eq = Constraint(
self.flowsheet().time,
rule=rule_U,
doc='Calculations of overall heat transfer coefficient')
# Effectiveness based on sub-heat exchangers
# Divide NTU by number of channels per pass
def rule_Ecf(blk, t):
if blk.number_of_passes.value % 2 == 0:
return (
blk.effectiveness[t] ==
(1 - exp(-blk.NTU[t] / blk.channels_per_pass *
(1 - blk.Cratio[t]))) /
(1 -
blk.Cratio[t] * exp(-blk.NTU[t] / blk.channels_per_pass *
(1 - blk.Cratio[t]))))
elif blk.pass_num.value % 2 == 1:
return (blk.effectiveness[t] ==
(1 - exp(-blk.NTU[t] / blk.channels_per_pass *
(1 + blk.Cratio[t]))) / (1 + blk.Cratio[t]))
self.effectiveness_correlation = Constraint(
self.flowsheet().time,
rule=rule_Ecf,
doc='Correlation for effectiveness factor')
# ---------------------------------------------------------------------
# Pressure drop correlations
# Friction factor calculation
self.friction_factor_param_a = Param(initialize=0.0,
units=pyunits.dimensionless,
doc='Friction factor parameter A',
mutable=True)
self.friction_factor_param_b = Param(initialize=18.29,
units=pyunits.dimensionless,
doc='Friction factor parameter B',
mutable=True)
self.friction_factor_param_c = Param(initialize=-0.652,
units=pyunits.dimensionless,
doc='Friction factor parameter C',
mutable=True)
def rule_fric_h(blk, t):
return (blk.friction_factor_param_a + blk.friction_factor_param_b *
blk.Re_hot[t]**(blk.friction_factor_param_c))
self.friction_factor_hot = Expression(self.flowsheet().time,
rule=rule_fric_h,
doc='Hot side friction factor')
def rule_fric_c(blk, t):
return (blk.friction_factor_param_a + blk.friction_factor_param_b *
blk.Re_cold[t]**(blk.friction_factor_param_c))
self.friction_factor_cold = Expression(self.flowsheet().time,
rule=rule_fric_c,
doc='Cold side friction factor')
def rule_hotside_dP(blk, t):
return blk.hot_side.deltaP[t] == -(
(2 * blk.friction_factor_hot[t] *
(blk.plate_length + blk.port_diameter) *
blk.number_of_passes * blk.hot_channel_velocity[t]**2 *
blk.hot_side.properties_in[t].dens_mass /
blk.channel_diameter) +
(0.7 * blk.number_of_passes * blk.hot_port_velocity[t]**2 *
blk.hot_side.properties_in[t].dens_mass) +
(blk.hot_side.properties_in[t].dens_mass *
pyunits.convert(Constants.acceleration_gravity,
to_units=units_meta("acceleration")) *
(blk.plate_length + blk.port_diameter)))
self.hot_side_deltaP_eq = Constraint(self.flowsheet().time,
rule=rule_hotside_dP)
def rule_coldside_dP(blk, t):
return blk.cold_side.deltaP[t] == -(
(2 * blk.friction_factor_cold[t] *
(blk.plate_length + blk.port_diameter) *
blk.number_of_passes * blk.cold_channel_velocity[t]**2 *
pyunits.convert(blk.cold_side.properties_in[t].dens_mass,
to_units=units_meta("density_mass")) /
blk.channel_diameter) +
(0.7 * blk.number_of_passes * blk.cold_port_velocity[t]**2 *
pyunits.convert(blk.cold_side.properties_in[t].dens_mass,
to_units=units_meta("density_mass"))) +
(pyunits.convert(blk.cold_side.properties_in[t].dens_mass,
to_units=units_meta("density_mass")) *
pyunits.convert(Constants.acceleration_gravity,
to_units=units_meta("acceleration")) *
(blk.plate_length + blk.port_diameter)))
self.cold_side_deltaP_eq = Constraint(self.flowsheet().time,
rule=rule_coldside_dP)
def initialize(
self,
hot_side_state_args=None,
cold_side_state_args=None,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None,
duty=None,
):
"""
Heat exchanger initialization method.
Args:
hot_side_state_args : a dict of arguments to be passed to the
property initialization for the hot side (see documentation of
the specific property package) (default = None).
cold_side_state_args : a dict of arguments to be passed to the
property initialization for the cold side (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)
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 = self.hot_side
cold_side = self.cold_side
# Create solver
opt = get_solver(solver, optarg)
flags1 = hot_side.initialize(outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=hot_side_state_args)
init_log.info_high("Initialization Step 1a (hot side) Complete.")
flags2 = cold_side.initialize(outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=cold_side_state_args)
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.energy_balance_constraint.deactivate()
self.effectiveness_correlation.deactivate()
self.effectiveness.fix(0.68)
# 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.energy_balance_constraint.activate()
for t in self.effectiveness:
calculate_variable_from_constraint(
self.effectiveness[t], self.effectiveness_correlation[t])
# ---------------------------------------------------------------------
# Solve unit with new effectiveness factor
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.effectiveness_correlation.activate()
self.effectiveness.unfix()
# ---------------------------------------------------------------------
# Final solve of full modelr
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)))
# ---------------------------------------------------------------------
# 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)
class HeatExchangerNTUData(UnitModelBlockData):
"""Heat Exchanger Unit Model using NTU method."""
CONFIG = UnitModelBlockData.CONFIG()
# Configuration template for fluid specific arguments
_SideCONFIG = ConfigBlock()
_SideCONFIG.declare(
"material_balance_type",
ConfigValue(
default=MaterialBalanceType.useDefault,
domain=In(MaterialBalanceType),
description="Material balance construction flag",
doc="""Indicates what type of mass balance should be constructed,
**default** - MaterialBalanceType.useDefault.
**Valid values:** {
**MaterialBalanceType.useDefault - refer to property package for default
balance type
**MaterialBalanceType.none** - exclude material balances,
**MaterialBalanceType.componentPhase** - use phase component balances,
**MaterialBalanceType.componentTotal** - use total component balances,
**MaterialBalanceType.elementTotal** - use total element balances,
**MaterialBalanceType.total** - use total material balance.}"""))
_SideCONFIG.declare(
"energy_balance_type",
ConfigValue(
default=EnergyBalanceType.useDefault,
domain=In(EnergyBalanceType),
description="Energy balance construction flag",
doc="""Indicates what type of energy balance should be constructed,
**default** - EnergyBalanceType.useDefault.
**Valid values:** {
**EnergyBalanceType.useDefault - refer to property package for default
balance type
**EnergyBalanceType.none** - exclude energy balances,
**EnergyBalanceType.enthalpyTotal** - single enthalpy balance for material,
**EnergyBalanceType.enthalpyPhase** - enthalpy balances for each phase,
**EnergyBalanceType.energyTotal** - single energy balance for material,
**EnergyBalanceType.energyPhase** - energy balances for each phase.}"""))
_SideCONFIG.declare(
"momentum_balance_type",
ConfigValue(
default=MomentumBalanceType.pressureTotal,
domain=In(MomentumBalanceType),
description="Momentum balance construction flag",
doc="""Indicates what type of momentum balance should be constructed,
**default** - MomentumBalanceType.pressureTotal.
**Valid values:** {
**MomentumBalanceType.none** - exclude momentum balances,
**MomentumBalanceType.pressureTotal** - single pressure balance for material,
**MomentumBalanceType.pressurePhase** - pressure balances for each phase,
**MomentumBalanceType.momentumTotal** - single momentum balance for material,
**MomentumBalanceType.momentumPhase** - momentum balances for each phase.}"""))
_SideCONFIG.declare(
"has_pressure_change",
ConfigValue(
default=False,
domain=Bool,
description="Pressure change term construction flag",
doc="""Indicates whether terms for pressure change should be
constructed,
**default** - False.
**Valid values:** {
**True** - include pressure change terms,
**False** - exclude pressure change terms.}"""))
_SideCONFIG.declare(
"property_package",
ConfigValue(
default=useDefault,
domain=is_physical_parameter_block,
description="Property package to use ",
doc="""Property parameter object used to define property calculations
**default** - useDefault.
**Valid values:** {
**useDefault** - use default package from parent model or flowsheet,
**PhysicalParameterObject** - a PhysicalParameterBlock object.}"""))
_SideCONFIG.declare(
"property_package_args",
ConfigBlock(
implicit=True,
description="Arguments to use for constructing property package",
doc="""A ConfigBlock with arguments to be passed to
property block(s) and used when constructing these,
**default** - None.
**Valid values:** {
see property package for documentation.}"""))
# Create individual config blocks for hot and cold sides
CONFIG.declare("hot_side", _SideCONFIG(doc="Hot fluid config arguments"))
CONFIG.declare("cold_side", _SideCONFIG(doc="Cold fluid config arguments"))
def build(self):
# Call UnitModel.build to setup model
super().build()
# ---------------------------------------------------------------------
# Build hot-side control volume
self.hot_side = ControlVolume0DBlock(
default={
"dynamic": self.config.dynamic,
"has_holdup": self.config.has_holdup,
"property_package": self.config.hot_side.property_package,
"property_package_args":
self.config.hot_side.property_package_args
})
# TODO : Add support for phase equilibrium?
self.hot_side.add_state_blocks(has_phase_equilibrium=False)
self.hot_side.add_material_balances(
balance_type=self.config.hot_side.material_balance_type,
has_phase_equilibrium=False)
self.hot_side.add_energy_balances(
balance_type=self.config.hot_side.energy_balance_type,
has_heat_transfer=True)
self.hot_side.add_momentum_balances(
balance_type=self.config.hot_side.momentum_balance_type,
has_pressure_change=self.config.hot_side.has_pressure_change)
# ---------------------------------------------------------------------
# Build cold-side control volume
self.cold_side = ControlVolume0DBlock(
default={
"dynamic":
self.config.dynamic,
"has_holdup":
self.config.has_holdup,
"property_package":
self.config.cold_side.property_package,
"property_package_args":
self.config.cold_side.property_package_args
})
self.cold_side.add_state_blocks(has_phase_equilibrium=False)
self.cold_side.add_material_balances(
balance_type=self.config.cold_side.material_balance_type,
has_phase_equilibrium=False)
self.cold_side.add_energy_balances(
balance_type=self.config.cold_side.energy_balance_type,
has_heat_transfer=True)
self.cold_side.add_momentum_balances(
balance_type=self.config.cold_side.momentum_balance_type,
has_pressure_change=self.config.cold_side.has_pressure_change)
# ---------------------------------------------------------------------
# Add Ports to control volumes
self.add_inlet_port(name="hot_inlet",
block=self.hot_side,
doc='Hot side inlet port')
self.add_outlet_port(name="hot_outlet",
block=self.hot_side,
doc='Hot side outlet port')
self.add_inlet_port(name="cold_inlet",
block=self.cold_side,
doc='Cold side inlet port')
self.add_outlet_port(name="cold_outlet",
block=self.cold_side,
doc='Cold side outlet port')
# ---------------------------------------------------------------------
# Add unit level References
# Set references to balance terms at unit level
self.heat_duty = Reference(self.cold_side.heat[:])
# ---------------------------------------------------------------------
# Add performance equations
# All units of measurement will be based on hot side
hunits = self.config.hot_side.property_package.get_metadata(
).get_derived_units
# Common heat exchanger variables
self.area = Var(initialize=1,
units=hunits("area"),
domain=PositiveReals,
doc="Heat transfer area")
self.heat_transfer_coefficient = Var(
self.flowsheet().time,
initialize=1,
units=hunits("heat_transfer_coefficient"),
domain=PositiveReals,
doc="Overall heat transfer coefficient")
# Overall energy balance
def rule_energy_balance(blk, t):
return blk.hot_side.heat[t] == -pyunits.convert(
blk.cold_side.heat[t], to_units=hunits("power"))
self.energy_balance_constraint = Constraint(self.flowsheet().time,
rule=rule_energy_balance)
# Add e-NTU variables
self.effectiveness = Var(self.flowsheet().time,
initialize=1,
units=pyunits.dimensionless,
domain=PositiveReals,
doc="Effectiveness factor for NTU method")
# Minimum heat capacitance ratio for e-NTU method
self.eps_cmin = Param(initialize=1e-3,
mutable=True,
units=hunits("power") / hunits("temperature"),
doc="Epsilon parameter for smooth Cmin and Cmax")
# TODO : Support both mass and mole based flows
def rule_Cmin(blk, t):
caph = (blk.hot_side.properties_in[t].flow_mol *
blk.hot_side.properties_in[t].cp_mol)
capc = pyunits.convert(blk.cold_side.properties_in[t].flow_mol *
blk.cold_side.properties_in[t].cp_mol,
to_units=hunits("power") /
hunits("temperature"))
return smooth_min(caph, capc, eps=blk.eps_cmin)
self.Cmin = Expression(self.flowsheet().time,
rule=rule_Cmin,
doc='Minimum heat capacitance rate')
def rule_Cmax(blk, t):
caph = (blk.hot_side.properties_in[t].flow_mol *
blk.hot_side.properties_in[t].cp_mol)
capc = pyunits.convert(blk.cold_side.properties_in[t].flow_mol *
blk.cold_side.properties_in[t].cp_mol,
to_units=hunits("power") /
hunits("temperature"))
return smooth_max(caph, capc, eps=blk.eps_cmin)
self.Cmax = Expression(self.flowsheet().time,
rule=rule_Cmax,
doc='Maximum heat capacitance rate')
# Heat capacitance ratio
def rule_Cratio(blk, t):
return blk.Cmin[t] / blk.Cmax[t]
self.Cratio = Expression(self.flowsheet().time,
rule=rule_Cratio,
doc='Heat capacitance ratio')
def rule_NTU(blk, t):
return blk.heat_transfer_coefficient[t] * blk.area / blk.Cmin[t]
self.NTU = Expression(self.flowsheet().time,
rule=rule_NTU,
doc='Number of heat transfer units')
# Heat transfer by e-NTU method
def rule_entu(blk, t):
return blk.hot_side.heat[t] == -(
blk.effectiveness[t] * blk.Cmin[t] *
(blk.hot_side.properties_in[t].temperature -
pyunits.convert(blk.cold_side.properties_in[t].temperature,
to_units=hunits("temperature"))))
self.heat_duty_constraint = Constraint(self.flowsheet().time,
rule=rule_entu)
# TODO : Add scaling methods
def initialize(
self,
hot_side_state_args=None,
cold_side_state_args=None,
outlvl=idaeslog.NOTSET,
solver=None,
optarg=None,
duty=None,
):
"""
Heat exchanger initialization method.
Args:
hot_side_state_args : a dict of arguments to be passed to the
property initialization for the hot side (see documentation of
the specific property package) (default = None).
cold_side_state_args : a dict of arguments to be passed to the
property initialization for the cold side (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)
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 = self.hot_side
cold_side = self.cold_side
# Create solver
opt = get_solver(solver, optarg)
flags1 = hot_side.initialize(outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=hot_side_state_args)
init_log.info_high("Initialization Step 1a (hot side) Complete.")
flags2 = cold_side.initialize(outlvl=outlvl,
optarg=optarg,
solver=solver,
state_args=cold_side_state_args)
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.energy_balance_constraint.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.energy_balance_constraint.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)
def _get_stream_table_contents(self, time_point=0):
return create_stream_table_dataframe(
{
"Hot Inlet": self.hot_inlet,
"Hot Outlet": self.hot_outlet,
"Cold Inlet": self.cold_inlet,
"Cold Outlet": self.cold_outlet,
},
time_point=time_point,
)
def get_costing(self, module=costing, year=None, **kwargs):
if not hasattr(self.flowsheet(), "costing"):
self.flowsheet().get_costing(year=year)
self.costing = Block()
module.hx_costing(self.costing, **kwargs)
