Pure Component Helmholtz EoS

Pure Component Helmholtz EoS#

The Helmholtz Equation of State (EoS) classes serve as a common core for pure component property packages where accurate and thermodynamically consistent pure component properties are required. New substances can be added by providing parameter and expression files. The Helmholtz EoS functions use ExternalFunction, so the IDAES binary extensions are required.

This page describes the standard HelmholtzParameterBlock and HelmholtzStateBlock. For more information on accessing property expressions using a function-like interface, or adding and modifying substance parameters see the following pages. There are also two modules available for backward compatibility iapws95 and swco2, which are the same as the general module, just with the pure component automatically set to "h2o" or "co2" respectively.

Defined Components#

If parameter and expression files are available for a component in the parameter file directory, they will be registered automatically. IDAES comes with some defined components and more can be added by users. Each component must have an equation of state model, while transport models for viscosity, thermal conductivity and surface tension are optional.

Functions listed in this section allow you to discover what components and models are available and get references for the models.

idaes.models.properties.general_helmholtz.registered_components()[source]#: Return a list of registered components

idaes.models.properties.general_helmholtz.viscosity_available(comp_str)[source]#

Return whether a viscosity model is available for a component.

Parameters:: comp_str (str) – component string
Returns:: True if viscosity model is available, False if not
Return type:: bool

idaes.models.properties.general_helmholtz.thermal_conductivity_available(comp_str)[source]#

Return whether a thermal conductivity model is available for a component.

Parameters:: comp_str (str) – component string
Returns:: True if thermal conductivity model is available, False if not
Return type:: bool

idaes.models.properties.general_helmholtz.surface_tension_available(comp_str)[source]#

Return whether a surface tension model is available for a component.

Parameters:: comp_str (str) – component string
Returns:: True if surface tension model is available, False if not
Return type:: bool

idaes.models.properties.general_helmholtz.component_registered(comp_str)[source]#

Return whether a component is registered.

Parameters:: comp_str (str) – component string
Returns:: True if component is available, False if not
Return type:: bool

idaes.models.properties.general_helmholtz.clear_component_registry()[source]#: Remove all components from registry

idaes.models.properties.general_helmholtz.eos_reference(comp_str)[source]#

Return the equation of state reference or None if not available

Parameters:: comp_str (str) – component string
Returns:: Equation of state reference
Return type:: (str|None)

idaes.models.properties.general_helmholtz.viscosity_reference(comp_str)[source]#

Return the viscosity reference or None if not available

Parameters:: comp_str (str) – component string
Returns:: Viscosity reference
Return type:: (str|None)

idaes.models.properties.general_helmholtz.thermal_conductivity_reference(comp_str)[source]#

Return the thermal conductivity reference or None if not available

Parameters:: comp_str (str) – component string
Returns:: Thermal conductivity reference
Return type:: (str|None)

idaes.models.properties.general_helmholtz.surface_tension_reference(comp_str)[source]#

Return the surface tension reference or None if not available

Parameters:: comp_str (str) – component string
Returns:: Surface tension reference
Return type:: (str|None)

Parameter File Location#

You can get or set the parameter path with the functions described below. When the parameter path is set components will automatically be registered based on the available parameter files.

idaes.models.properties.general_helmholtz.get_parameter_path()[source]#

Get the parameter file path

Parameters:: None
Returns:: path for parameter files
Return type:: str

idaes.models.properties.general_helmholtz.set_parameter_path(path)[source]#

Set the parameter file path, and register components found there.

Parameters:: path (str) – Parameter file path
Returns:: None

Classes#

The main class used to define a property method is the HelmholtzParameterBlock. Unit models usually create their own state blocks, but it may be useful to create state block objects apart from unit models.

class idaes.models.properties.general_helmholtz.HelmholtzParameterBlock(*args, **kwds)#

Parameters:

rule (function) – A rule function or None. Default rule calls build().
concrete (bool) – If True, make this a toplevel model. Default - False.
ctype (class) –
Pyomo ctype of the block. Default - pyomo.environ.Block

Config args

default_arguments
Default arguments to use with Property Package

pure_component
(str) Pure component for which to calculate properties

phase_presentation
Set the way phases are presented to models. The MIX option appears to the framework to be a mixed phase containing liquid and/or vapor. The mixed option can simplify calculations at the unit model level since it can be treated as a single phase, but unit models such as flash vessels will not be able to treat the phases independently. The LG option presents as two separate phases to the framework. The L or G options can be used if it is known for sure that only one phase is present. default - PhaseType.MIX Valid values: { PhaseType.MIX - Present a mixed phase with liquid and/or vapor, PhaseType.LG - Present a liquid and vapor phase, PhaseType.L - Assume only liquid can be present, PhaseType.G - Assume only vapor can be present}

state_vars
The set of state variables to use. Depending on the use, one state variable set or another may be better computationally. Usually pressure and enthalpy are the best choice because they are well behaved during a phase change. default - StateVars.PH Valid values: { StateVars.PH - Pressure-Enthalpy, StateVars.PS - Pressure-Entropy, StateVars.PU - Pressure-Internal Energy, StateVars.TPX - Temperature-Pressure-Quality}

amount_basis
The amount basis (mass or mole) for quantities default - AmountBasis.mole Valid values: { AmountBasis.mole - use mole units (mol), AmountBasis.mass - use mass units (kg)}
initialize (dict) – ProcessBlockData config for individual elements. Keys are BlockData indexes and values are dictionaries with config arguments as keys.
idx_map (function) – Function to take the index of a BlockData element and return the index in the initialize dict from which to read arguments. This can be provided to override the default behavior of matching the BlockData index exactly to the index in initialize.

Returns:

(HelmholtzParameterBlock) New instance

class idaes.models.properties.general_helmholtz.HelmholtzParameterBlockData(component)[source]#

This is a base class for Helmholtz equations of state using IDAES standard Helmholtz EOS external functions written in C++.

add_param(name, expr)[source]#

Add a parameter to the block.

Parameters:

name (str) – parameter name
expr (expression) – Pyomo expression for parameter value

available()[source]#: Returns True if the shared library is installed and loads properly otherwise returns False

build()[source]#: Populate the parameter block

classmethod define_metadata(obj)[source]#

Set all the metadata for properties and units.

This method should be implemented by subclasses. In the implementation, they should set information into the object provided as an argument.

Parameters:: pcm (PropertyClassMetadata) – Add metadata to this object.
Returns:: None

dome_data(amount_basis=None, pressure_unit=<pyomo.core.base.units_container._PyomoUnit object>, energy_unit=<pyomo.core.base.units_container._PyomoUnit object>, mass_unit=<pyomo.core.base.units_container._PyomoUnit object>, mol_unit=<pyomo.core.base.units_container._PyomoUnit object>, n=60)[source]#

Get data to plot the two-phase dome or saturation curve. This data can be used to plot the 2 phase dome for p-h and t-s diagrams and the saturation curve on the p-t diagram.

Parameters:

amount_bases (AmountBasis) – Mass or mole basis. Get from parameter block if None.
pressure_unit (PyomoUnit) – Pressure units of measure
energy_unit (PyomoUnit) – Energy units of measure
mass_unit (PyomoUnit) – Mass units of measure
mol_unit (PyomoUnit) – Mole unit of measure

Returns:

dictionary with the keys {‘T’, ‘tau’, ‘p’, ‘delta_liq’,: ’delta_vap’, ‘h_liq’, ‘h_vap’, ‘s_liq’, ‘s_vap’} each a list of numbers corresponding to states along the two-phase dome.

Return type:

dict

hp_diagram(ylim=None, xlim=None, points=None, figsize=None, dpi=None, isotherms=None, isotherms_line_format=None, isotherms_label=True)#

Create a enthalpy-pressure diagram using Matplotlib

Parameters:

ylim (tuple) – lower and upper limits for pressure axis
xlim (tuple) – lower and upper limits for enthalpy axis
points (dict) – dict of tuples points to label on the plot
figsize (tuple) – figure size
dpi (int) – figure dots per inch
isotherms (list|None) – list of temperatures for plotting isotherms
isotherms_line_format (str|None) – line format for isotherms
isotherms_label (bool) – if true label isotherms

Returns:

(figure, axis)

htpx(T=None, p=None, x=None, units=None, amount_basis=None, with_units=False)[source]#

Convenience method to calculate enthalpy from temperature and either pressure or vapor fraction. This function can be used for inlet streams and initialization where temperature is known instead of enthalpy. User must provide values for one of these sets of values: {T, P}, {T, x}, or {P, x}.

Parameters:

T (float) – Temperature
P (float) – Pressure, None if saturated
x (float) – Vapor fraction [mol vapor/mol total] (between 0 and 1), None if superheated or sub-cooled
units (Units) – The units to report the result in, if None use the default units appropriate for the amount basis.
amount_basis (AmountBasis) – Whether to use a mass or mole basis
with_units (bool) – if True return an expression with units

Returns:

Specific or molar enthalpy

Return type:

float

initialize(*args, **kwargs)[source]#: No initialization required here. This method is included for compatibility.

isotherms(temperatures)[source]#

Get isotherm data for a P-H diagram.

Parameters:

temperatures – A list of temperatures

Returns:

The keys are temperatures the values are dicts with “p”, “h”,: ”s”, and “delta” data for the isotherm.

Return type:

dict

ph_diagram(ylim=None, xlim=None, points=None, figsize=None, dpi=None, isotherms=None, isotherms_line_format=None, isotherms_label=True)[source]#

Create a enthalpy-pressure diagram using Matplotlib

Parameters:

ylim (tuple) – lower and upper limits for pressure axis
xlim (tuple) – lower and upper limits for enthalpy axis
points (dict) – dict of tuples points to label on the plot
figsize (tuple) – figure size
dpi (int) – figure dots per inch
isotherms (list|None) – list of temperatures for plotting isotherms
isotherms_line_format (str|None) – line format for isotherms
isotherms_label (bool) – if true label isotherms

Returns:

(figure, axis)

pt_diagram(ylim=None, xlim=None, figsize=None, dpi=None)[source]#

Create a pressure-teperature diagram using Matplotlib

Parameters:

ylim (tuple) – lower and upper limits for pressure axis
xlim (tuple) – lower and upper limits for temperature axis
figsize (tuple) – figure size
dpi (int) – figure dots per inch

Returns:

(figure, axis)

st_diagram(ylim=None, xlim=None, points=None, figsize=None, dpi=None)#

Create a entropy-temperautre diagram using Matplotlib

Parameters:

ylim (tuple) – lower and upper limits for temperature axis
xlim (tuple) – lower and upper limits for entropy axis
points (dict) – dict of tuples points to label on the plot
figsize (tuple) – figure size
dpi (int) – figure dots per inch

Returns:

(figure, axis)

stpx(T=None, p=None, x=None, units=None, amount_basis=None, with_units=False)[source]#

Convenience method to calculate entropy from temperature and either pressure or vapor fraction. This function can be used for inlet streams and initialization where temperature is known instead of entropy. User must provide values for one of these sets of values: {T, P}, {T, x}, or {P, x}.

Parameters:

T (float) – Temperature
P (float) – Pressure, None if saturated
x (float) – Vapor fraction [mol vapor/mol total] (between 0 and 1), None if superheated or sub-cooled
units (Units) – The units to report the result in, if None use the default units appropriate for the amount basis.
amount_basis (AmountBasis) – Whether to use a mass or mole basis
with_units (bool) – if True return an expression with units

Returns:

Specific or molar entropy

Return type:

float

tp_diagram(ylim=None, xlim=None, figsize=None, dpi=None)#

Create a pressure-teperature diagram using Matplotlib

Parameters:

ylim (tuple) – lower and upper limits for pressure axis
xlim (tuple) – lower and upper limits for temperature axis
figsize (tuple) – figure size
dpi (int) – figure dots per inch

Returns:

(figure, axis)

ts_diagram(ylim=None, xlim=None, points=None, figsize=None, dpi=None)[source]#

Create a entropy-temperautre diagram using Matplotlib

Parameters:

ylim (tuple) – lower and upper limits for temperature axis
xlim (tuple) – lower and upper limits for entropy axis
points (dict) – dict of tuples points to label on the plot
figsize (tuple) – figure size
dpi (int) – figure dots per inch

Returns:

(figure, axis)

utpx(T=None, p=None, x=None, units=None, amount_basis=None, with_units=False)[source]#

Convenience method to calculate internal energy from temperature and either pressure or vapor fraction. This function can be used for inlet streams and initialization where temperature is known instead of internal energy. User must provide values for one of these sets of values: {T, P}, {T, x}, or {P, x}.

Parameters:

T (float) – Temperature
P (float) – Pressure, None if saturated
x (float) – Vapor fraction [mol vapor/mol total] (between 0 and 1), None if superheated or sub-cooled
units (Units) – The units to report the result in, if None use the default units appropriate for the amount basis.
amount_basis (AmountBasis) – Whether to use a mass or mole basis
with_units (bool) – if True return an expression with units

Returns:

Specific or molar internal energy

Return type:

float

class idaes.models.properties.general_helmholtz.HelmholtzStateBlock(*args, **kwds)#

Parameters:

rule (function) – A rule function or None. Default rule calls build().
concrete (bool) – If True, make this a toplevel model. Default - False.
ctype (class) –
Pyomo ctype of the block. Default - pyomo.environ.Block

Config args

parameters
A reference to an instance of the Property Parameter Block associated with this property package.

defined_state
Flag indicating whether the state should be considered fully defined, and thus whether constraints such as sum of mass/mole fractions should be included, default - False. Valid values: { True - state variables will be fully defined, False - state variables will not be fully defined.}

has_phase_equilibrium
Flag indicating whether phase equilibrium constraints should be constructed in this state block, default - True. Valid values: { True - StateBlock should calculate phase equilibrium, False - StateBlock should not calculate phase equilibrium.}
initialize (dict) – ProcessBlockData config for individual elements. Keys are BlockData indexes and values are dictionaries with config arguments as keys.
idx_map (function) – Function to take the index of a BlockData element and return the index in the initialize dict from which to read arguments. This can be provided to override the default behavior of matching the BlockData index exactly to the index in initialize.

Returns:

(HelmholtzStateBlock) New instance

class idaes.models.properties.general_helmholtz.HelmholtzStateBlockData(*args, **kwargs)[source]#

This is a base class for Helmholtz equations of state using IDAES standard Helmholtz EOS external functions written in C++.

build(*args)[source]#: Callable method for Block construction

default_energy_balance_type()[source]#: Get default energy balance type suggestion

default_material_balance_type()[source]#: Get default material balance type suggestion

define_display_vars()[source]#: Method used to specify components to use to generate stream tables and other outputs. Defaults to define_state_vars, and developers should overload as required.

define_state_vars()[source]#: Method that returns a dictionary of state variables used in property package. Implement a placeholder method which returns an Exception to force users to overload this.

extensive_state_vars()[source]#: Return the set of extensive variables

get_energy_density_terms(p)[source]#

Get energy density terms for phase

Parameters:: p (str) – phase
Returns:: Expression

get_enthalpy_flow_terms(p)[source]#

Get enthalpy flow terms for phase

Parameters:: p (str) – phase
Returns:: Expression

get_material_density_terms(p, j)[source]#

Get material density terms for phase

Parameters:: p (str) – phase
Returns:: Expression

get_material_flow_basis()[source]#: Method which returns an Enum indicating the basis of the material flow term.

get_material_flow_terms(p, j)[source]#

Get material flow terms for phase

Parameters:: p (str) – phase
Returns:: Expression

intensive_state_vars()[source]#: Return the set of intensive variables

model_check()[source]#: Currently doesn’t do anything, here for compatibility

class idaes.models.properties.general_helmholtz.StateVars(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]#

Enum, state variable set options.

PH: Pressure and enthalpy
PS: Pressure and entropy
PU: Pressure and internal energy
TPX: Temperature, pressure, and quality

class idaes.models.properties.general_helmholtz.PhaseType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]#

Enum, possible phases and presentation.

MIX: Two phase presented and a single phase to framework
LG: Two phases
L: Liquid only
G: Vapor only

class idaes.models.properties.general_helmholtz.AmountBasis(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]#

Enum, mass or mole basis

MOLE: Amount is measured in moles
MASS: Amount is measured in mass

Helper Function#

Since conditions may be difficult to specify for some choices of state variables, for example, fixing temperature and pressure of an inlet when the state variables are enthalpy and pressure, helper methods are provided by the Parameter block class. See the htpx(), stpx(), or uptx() documentation in the parameter block class above.

Example#

The Heater unit model example, provides a simple example for using water properties.

import pyomo.environ as pe # Pyomo environment
from idaes.core import FlowsheetBlock, MaterialBalanceType
from idaes.models.unit_models import Heater
from idaes.models.properties.general_helmholtz import (
    HelmholtzParameterBlock,
    PhaseType,
    StateVars,
)

# Create an empty flowsheet and steam property parameter block.
model = pe.ConcreteModel()
model.fs = FlowsheetBlock(dynamic=False)
model.fs.properties = HelmholtzParameterBlock(
  pure_component="h2o",
  phase_presentation=PhaseType.LG,
  state_vars=StateVars.PH
)

# Add a Heater model to the flowsheet.
model.fs.heater = Heater(
  property_package=model.fs.properties,
  material_balance_type=MaterialBalanceType.componentTotal
)

# Setup the heater model by fixing the inputs and heat duty
model.fs.heater.inlet[:].enth_mol.fix(4000)
model.fs.heater.inlet[:].flow_mol.fix(100)
model.fs.heater.inlet[:].pressure.fix(101325)
model.fs.heater.heat_duty[:].fix(100*20000)

# Initialize the model.
model.fs.heater.initialize()

Since all properties except the state variables are Pyomo Expressions in the water properties module, after solving the problem any property can be calculated in any state block. Continuing from the heater example, to get the viscosity of both phases, the lines below could be added.

mu_l = pe.value(model.fs.heater.control_volume.properties_out[0].visc_d_phase["Liq"])
mu_v = pe.value(model.fs.heater.control_volume.properties_out[0].visc_d_phase["Vap"])

For more information about how StateBlocks and PropertyParameterBlocks work see the StateBlock documentation.

Units#

SI units are used for property variables and expressions (J, Pa, kg, mol, m, s, W).

Phase Presentation#

The property package wrapper can present fluid phase information to the IDAES framework in different ways. The PhaseType.MIX option causes the modeling framework to view liquid and vapor as a single mixed liquid and vapor phase. This generally reduces model complexity. Phase equilibrium is still calculated and vapor_frac and individual phase properties are available, just as they would be with the two-phase presentation. The mixed-phase presentation can be used with most standard unit models that do not provide phase separation. If phase separation is required, either use the two-phase presentation or create a custom model.

Warning

The “has_phase_equilibrium” argument is ignored when constructing Helmholtz property packages using mixed phase presentation. However, setting this to True may cause errors in unit models as it is not possible to construct phase equilibrium transfer terms with only one phase present.

The PhaseType.LG option appears to the IDAES framework to be two phases “Vap” and “Liq”. This option requires one of two unit model options to be set. You can use the total material balance option for unit models, to specify that only one material balance equation should be written not one per phase. The other possible option is to specify has_phase_equlibrium=True. This will write a material balance per phase, but will add a phase generation term to the model. For Helmholtz EoS packages, it is generally recommended that specifying total material balances is best because it results in a problem with fewer variables, and phase equilibrium is always calculated by the property package.

There are two single phase options PhaseType.L and PhaseType.G; these present a single phase “Liq” or “Vap” to the framework. The vapor fraction will also always return 0 or 1 as appropriate. These options can be used when the phase of a fluid is known for certain to only be liquid or only be vapor. For the temperature-pressure-vapor fraction formulation, this eliminates the complementarity constraint, but for the enthalpy-pressure formulation, where the vapor fraction is always calculated, the single phase options probably do not provide any real benefit over mixed phase.

State Variables#

There is a choice of state variables, pressure-enthalpy, pressure-entropy, pressure-internal energy and temperature-pressure-vapor fraction. In general the enthalpy-pressure form is preferable. Both the pressure and enthalpy variables are smooth and sufficient to define the fluid state. For systems where two-phases may be present, it is expected that pressure-enthalpy is the best choice of state variables.

The temperature-pressure-vapor fraction form is more convenient, since temperature is directly measurable and more familiar than enthalpy. Complementarity constraints are used to deal with the vapor fraction variable, but the additional complimentary constraints may make the problem less robust. Temperature-pressure is often a good choice of state variables where there is only a single known phase.

Pressure-Enthalpy, Entropy, or Internal Energy Formulation#

The advantage of this choice of state variables is that it is more robust when phase changes occur, and is especially useful when it is not known if a phase change will occur. The disadvantage of this choice of state variables is that for equations like heat transfer that are highly dependent on temperature, a model could be harder to solve near regions with phase change. Temperature is a non-smooth function with non-smoothness when transitioning from the single-phase to the two-phase region. Temperature also has a zero derivative with respect to enthalpy in the two-phase region, so near the two-phase region solving a constraint that specifies a specific temperature may be difficult.

When a mass basis is used the variables in these forms are flow_mass (kg/s), pressure (Pa), and one of enth_mass (J/kg), entr_mass (J/kg/K), or energy_ineternal_mass (J/kg).

When a mass basis is used the variables in these forms are flow_mol (mol/s), pressure (Pa), and one of enth_mol (J/mol), entr_mol (J/mol/K), or energy_ineternal_mole (J/mol).

Since temperature and vapor fraction are not state variables in this formulation, they are provided by expressions, and cannot be fixed. For example, to set a temperature to a specific value, a constraint could be added which says the temperature expression equals a fixed value.

Temperature-Pressure-Vapor Fraction#

This formulation uses temperature (K), pressure (Pa), and vapor fraction as state variables. When a single phase option is given, the vapor fraction does not need to be specified and is instead an expression with the appropriate value.

A complementarity constraint is required for the T-P-x formulation when two-phases may be present. First, two expressions are defined below where \(P^-\) is pressure under saturation pressure and \(P^+\) is pressure over saturation pressure. The \(\max()\) function is provided as an IDAES utility which provides a smooth max expression.

\[P^- = \max(0, P_{\text{sat}} - P)\]

\[P^+ = \max(0, P - P_{\text{sat}})\]

With the “pressure over” and “pressure under” expressions a complementarity constraint can be written. If the pressure under saturation is more than zero, only vapor exists. If the pressure over saturation is greater than zero only a liquid exists. If both are about zero two phases can exist. The saturation pressure function maxes out at the critical pressure and any temperature above the critical temperature will yield a saturation pressure that is the critical pressure, so supercritical fluids will be classified as liquids as is the convention for this property package.

\[0 = xP^+ - (1 - x)P^-\]

Assuming the vapor fraction (\(x\)) is positive and noting that only one of \(P^+\) and \(P^-\) can be nonzero (approximately), the complementarity equation above requires \(x\) to be 0 when \(P^+\) is not zero (liquid) or \(x\) to be 1 when \(P^-`\) is not zero (vapor). When both \(P^+\) and \(P^-`\) are about 0, the complementarity constraint says nothing about x, but it basically reduces another constraint, that \(P=P_{\text{sat}}\). When two phases are present \(x\) is found by the unit model energy balance, where the temperature will be \(T_{\text{sat}}\) (because \(P=P_{\text{sat}}\)).

An alternative approach is sometimes useful to simplify the problem when it is certain that there are two phases. The complementarity constraint can be deactivated and a \(P=P_{\text{sat}}\) or \(T=T_{\text{sat}}\) constraint can be added.

Using the T-P-x formulation requires better initial guesses than the P-H form. It is not strictly necessary but it is best to try to get an initial guess that is in the correct phase region for the expected result.

Non-Existent Phases#

This section describes the behavior of specific phase property calculations where that phase does not exist.

Liquid phase properties calculated where a liquid does not exist will solve for the density root smoothly extending from the saturation curve into the vapor region. Once the temperature corresponding to the density root becomes higher than the critical temperature the vapor density root is used.

Vapor phase properties calculated where a vapor does not exist will solve for the density root smoothly extending from the saturation curve into the liquid region. Once the pressure corresponding to the density root becomes higher than the critical pressure the liquid density root is used.

This method for non-existing phase properties should provide a smooth buffer when solving equations. It also returns properties for superheated liquids or sub-cooled vapor. It also ensures that both the liquid and vapor phase properties are the same for the supercritical region.

Variables#

Variables are listed in the table below. What is a variable and what is an expression depends on the selected state variables and amount basis. Pressure is always a variable.

Variable	Description
`pressure`	Pressure (Pa)
`flow_mass`	Mass flow (kg/s), if `amount_basis=AmountBasis.MASS`; otherwise, expression
`flow_mol`	Mole flow (mol/s) if `amount_basis=AmountBasis.MOLE`; otherwise, expression
`temperature`	Temperature (K), is a variable in T-P-x formulation
`vapor_frac`	Vapor fraction (dimensionless), is a variable in T-P-x two phase formulation
`enth_mass`	Specific enthalpy (J/kg), is a variable in P-H formulation with mass basis
`enth_mol`	Molar enthalpy (J/mol), is a variable in P-H formulation with mole basis
`entr_mass`	Specific enthalpy (J/kg/K), is a variable in P-S formulation with mole basis
`entr_mol`	Molar enthalpy (J/mol/K), is a variable in P-S formulation with mole basis
`energy_internal_mass`	Specific internal energy (J/kg), is a variable in P-U formulation with mass basis
`energy_internal_mol`	Molar internal energy (J/mol), is a variable in P-U formulation with mole basis

Expressions#

Unless otherwise noted, the property expressions are common to both the T-P-x and P-H formulations. For phase specific properties, valid phase indexes are "Liq" and "Vap". Even when using the mixed phase version of the property package, both liquid and vapor properties are available.

Expression	Description
`flow_mass`	Mass flow (kg/s), variable if `amount_basis=AmountBasis.MASS`
`flow_mol`	Mole flow (mol/s) variable if `amount_basis=AmountBasis.MOLE`
`temperature`	Temperature (K), is a variable in T-P-x formulation
`vapor_frac`	Vapor fraction (dimensionless), is a variable in T-P-x two phase formulation
`enth_mass`	Specific enthalpy (J/kg), is a variable in P-H formulation with mass basis
`enth_mol`	Molar enthalpy (J/mol), is a variable in P-H formulation with mole basis
`entr_mass`	Specific enthalpy (J/kg/K), is a variable in P-S formulation with mole basis
`entr_mol`	Molar enthalpy (J/mol/K), is a variable in P-S formulation with mole basis
`energy_internal_mass`	Specific internal energy (J/kg), is a variable in P-U formulation with mass basis
`energy_internal_mol`	Molar internal energy (J/mol), is a variable in P-U formulation with mole basis
`mw`	Molecular weight (kg/mol)
`mole_frac_comp[comp]`	Mole fraction of component (dimensionless), since pure component, returns 1
`mole_frac_phase_comp[phase][comp]`	Mole fraction of component in phase (dimensionless), since pure component, returns 1
`temperature_crit`	Critical temperature (K)
`temperature_star`	Reducing temperature \(\tau=\frac{T^*}{T}\) (K)
`pressure_crit`	Critical pressure (Pa)
`dens_mass_crit`	Critical mass density (kg/m³)
`dens_mass_star`	Reducing mass density \(\delta=\frac{\rho}{\rho^*}\) (kg/m³)
`dens_mol_crit`	Critical mole density (mol/m³)
`dens_mol_star`	Reducing mole density \(\delta=\frac{\rho}{\rho^*}\) (kg/m³)
`temperature_sat`	Saturation temperature (K), if supercritical, Tsat=Tcrit
`pressure_sat`	Saturation pressure (Pa), if supercritical, Psat=Pcrit
`enth_mass_sat_phase[phase]`	Saturation specific enthalpy of phase (J/kg)
`enth_mol_sat_phase[phase]`	Saturation molar enthalpy of phase (J/mol)
`entr_mass_sat_phase[phase]`	Saturation specific entropy of phase (J/kg/K)
`entr_mol_sat_phase[phase]`	Saturation molar entropy of phase (J/mol/K)
`energy_internal_mass_sat_phase[phase]`	Saturation specific internal energy of phase (J/kg)
`energy_internal_mol_sat_phase[phase]`	Saturation molar internal energy of phase (J/mol)
`volume_mass_sat_phase[phase]`	Saturation specific volume of phase (m³/kg)
`volume_mol_sat_phase[phase]`	Saturation molar volume of phase (m³/mol)
`dh_vap_mass`	Specific enthalpy of vaporization at P (J/kg)
`dh_vap_mol`	Molar enthalpy of vaporization at P (J/mol)
`ds_vap_mass`	Specific entropy of vaporization at P (J/kg/K)
`ds_vap_mol`	Molar entropy of vaporization at P (J/mol/K)
`du_vap_mass`	Specific internal energy of vaporization at P (J/kg)
`du_vap_mol`	Molar internal energy of vaporization at P (J/mol)
`phase_frac[phase]`	Phase fraction (dimensionless) mole and mass fraction same for pure
`enthalpy_mass_phase[phase]`	Specific enthalpy of phase (J/kg)
`enthalpy_mol_phase[phase]`	Molar enthalpy of phase (J/mol)
`entropy_mass_phase[phase]`	Specific entropy of phase (J/kg/K)
`entropy_mol_phase[phase]`	Molar entropy of phase (J/mol/K)
`energy_internal_mass_phase[phase]`	Specific internal energy of phase (J/kg)
`energy_internal_mol_phase[phase]`	Molar internal energy of phase (J/mol)
`cp_mass_phase[phase]`	Specific isobaric heat capacity for phase (J/kg)
`cp_mol_phase[phase]`	Molar isobaric heat capacity for phase (J/mol)
`cv_mass_phase[phase]`	Specific isochoric heat capacity for phase (J/kg)
`cv_mol_phase[phase]`	Molar isochoric heat capacity for phase (J/mol)
`speed_sound_phase[phase]`	Speed of sound in phase (m/s)
`vol_mass_phase[phase]`	Specific volume of phase (m³/kg)
`vol_mol_phase[phase]`	Molar volume of phase (m³/mol)
`dens_mass_phase[phase]`	Mass density of phase (kg/m³)
`dens_mol_phase[phase]`	Mole density of phase (mol/m³)
`flow_mass_comp[comp]`	Same as total mass flow since pure (kg/s)
`flow_mol_comp[comp]`	Same as total mole flow since pure (mol/s)
`cp_mass`	Specific isobaric heat capacity for mixed phase (J/kg)
`cp_mol`	Molar isobaric heat capacity for mixed phase (J/mol)
`cv_mass`	Specific isochoric heat capacity for mixed phase (J/kg)
`cv_mol`	Molar isochoric heat capacity for mixed phase (J/mol)
`dens_mass`	Mass density of mixed phase (kg/m³)
`dens_mol`	Mole density of mixed phase (mol/m³)
`flow_vol`	Total mixed phase volumetric flow (m³/s)
`heat_capacity_ratio`	Mixed phase cp/cv (dimensionless)
`visc_d_phase[phase]`	Dynamic viscosity (Pa*s), depending on substance, may not be available
`visc_k_phase[phase]`	Kinematic viscosity (m²/s), depending on substance, may not be available
`therm_cond_phase[phase]`	Thermal conductivity of phase (W/m/s), depending on substance, may not be available
`surface_tension`	Surface tension (N/m), depending on substance, may not be available
`P_under_sat`	Pressure under saturation pressure (Pa)
`P_over_sat`	Pressure over saturation pressure (Pa)

Initialization#

The Helmholtz EoS state blocks provide initialization functions for general compatibility with the IDAES framework, but as long as the state variables are specified to some reasonable value, initialization is not required. All required solves are handled by external functions.

However, in order to support a general hierarchical initialization for unit models which use Helmholtz equation of state properties, a custom Initializer for these property packages is available.

class idaes.models.properties.general_helmholtz.helmholtz_state.HelmholtzEoSInitializer(**kwargs)[source]#

Initializer object for Helmholtz EoS packages using external functions.

Due to the use of external functions, Helmholtz EoS StateBlocks have no constraints, thus there is nothing to initialize. This Initializer replaces the general initialize method with a no-op.

constraint_tolerance: Tolerance for checking constraint convergence
output_level: Set output level for logging messages

initialize(model, output_level=None)[source]#

Initialize method for Helmholtz EoS state blocks. This is a no-op.

Parameters:

model (Block) – model to be initialized
output_level – (optional) output level to use during initialization run (overrides global setting).

Returns:

InitializationStatus.Ok

Pure Component Helmholtz EoS

Contents

Pure Component Helmholtz EoS#

Defined Components#

Parameter File Location#

Classes#

Helper Function#

Example#

Units#

Phase Presentation#

State Variables#

Pressure-Enthalpy, Entropy, or Internal Energy Formulation#

Temperature-Pressure-Vapor Fraction#

Non-Existent Phases#

Variables#

Expressions#

Initialization#