Struct PhaseEquilibrium 

pub struct PhaseEquilibrium<E, const P: usize, N: Dim = Dyn, D: DualNum<f64> + Copy = f64>(pub [State<E, N, D>; P])
where
    DefaultAllocator: Allocator<N>;

A thermodynamic equilibrium state.

The struct is parametrized over the number of phases with most features being implemented for the two phase vapor/liquid or liquid/liquid case.

Contents

• Bubble and dew point calculations
• Heteroazeotropes
• Flash calculations
• Pure component phase equilibria
• Utility functions

Tuple Fields

0: [State<E, N, D>; P]

Implementations

impl<E: Residual<N, D>, N: Gradients, D: DualNum<f64> + Copy> PhaseEquilibrium<E, 2, N, D>

where DefaultAllocator: Allocator<N> + Allocator<N, N> + Allocator<U1, N>,

Bubble and dew point calculations

pub fn bubble_point<TP: TemperatureOrPressure<D>>( eos: &E, temperature_or_pressure: TP, liquid_molefracs: &OVector<D, N>, tp_init: Option<TP::Other>, vapor_molefracs: Option<&OVector<f64, N>>, options: (SolverOptions, SolverOptions), ) -> FeosResult<Self>

Calculate a phase equilibrium for a given temperature or pressure and composition of the liquid phase.

pub fn dew_point<TP: TemperatureOrPressure<D>>( eos: &E, temperature_or_pressure: TP, vapor_molefracs: &OVector<D, N>, tp_init: Option<TP::Other>, liquid_molefracs: Option<&OVector<f64, N>>, options: (SolverOptions, SolverOptions), ) -> FeosResult<Self>

Calculate a phase equilibrium for a given temperature or pressure and composition of the vapor phase.

impl<E: Residual> PhaseEquilibrium<E, 3>

Heteroazeotropes

pub fn heteroazeotrope<TP: TemperatureOrPressure>( eos: &E, temperature_or_pressure: TP, x_init: (f64, f64), tp_init: Option<TP::Other>, options: SolverOptions, bubble_dew_options: (SolverOptions, SolverOptions), ) -> FeosResult<Self>

Calculate a heteroazeotrope (three phase equilbrium) for a binary system and given temperature or pressure.

impl<E: Residual> PhaseEquilibrium<E, 2>

Flash calculations

pub fn tp_flash( eos: &E, temperature: Temperature, pressure: Pressure, feed: &Moles<DVector<f64>>, initial_state: Option<&PhaseEquilibrium<E, 2>>, options: SolverOptions, non_volatile_components: Option<Vec<usize>>, ) -> FeosResult<Self>

Perform a Tp-flash calculation. If no initial values are given, the solution is initialized using a stability analysis.

The algorithm can be use to calculate phase equilibria of systems containing non-volatile components (e.g. ions).

impl<E: Residual> PhaseEquilibrium<E, 2>

Pure component phase equilibria

pub fn pure<TP: TemperatureOrPressure>( eos: &E, temperature_or_pressure: TP, initial_state: Option<&Self>, options: SolverOptions, ) -> FeosResult<Self>

Calculate a phase equilibrium for a pure component.

impl<E: Residual<N, D>, N: Gradients, D: DualNum<f64> + Copy> PhaseEquilibrium<E, 2, N, D>

where DefaultAllocator: Allocator<N>,

pub fn pure_t( eos: &E, temperature: Temperature<D>, initial_state: Option<&Self>, options: SolverOptions, ) -> FeosResult<(Pressure<D>, [Density<D>; 2])>

Calculate a phase equilibrium for a pure component and given temperature.

impl<E: Residual + Subset> PhaseEquilibrium<E, 2>

pub fn vapor_pressure( eos: &E, temperature: Temperature, ) -> Vec<Option<Pressure>>

Calculate the pure component vapor pressures of all components in the system for the given temperature.

pub fn boiling_temperature( eos: &E, pressure: Pressure, ) -> Vec<Option<Temperature>>

Calculate the pure component boiling temperatures of all components in the system for the given pressure.

pub fn vle_pure_comps<TP: TemperatureOrPressure>( eos: &E, temperature_or_pressure: TP, ) -> Vec<Option<PhaseEquilibrium<E, 2>>>

Calculate the pure component phase equilibria of all components in the system.

impl<E: Residual, const P: usize> PhaseEquilibrium<E, P>

pub fn _repr_markdown_(&self) -> String

impl<E: Residual<N, D>, N: Dim, D: DualNum<f64> + Copy> PhaseEquilibrium<E, 2, N, D>

where DefaultAllocator: Allocator<N>,

pub fn vapor(&self) -> &State<E, N, D>

pub fn liquid(&self) -> &State<E, N, D>

impl<E> PhaseEquilibrium<E, 3>

pub fn vapor(&self) -> &State<E>

pub fn liquid1(&self) -> &State<E>

pub fn liquid2(&self) -> &State<E>

impl<E: Residual<N>, N: Dim> PhaseEquilibrium<E, 2, N>

where DefaultAllocator: Allocator<N>,

pub fn new_xpt( eos: &E, temperature: Temperature, pressure: Pressure, vapor_molefracs: &OVector<f64, N>, liquid_molefracs: &OVector<f64, N>, ) -> FeosResult<Self>

Creates a new PhaseEquilibrium that contains two states at the specified temperature, pressure and molefracs.

The constructor can be used in custom phase equilibrium solvers or, e.g., to generate initial guesses for an actual VLE solver. In general, the two states generated are NOT in an equilibrium.

impl<E: Residual<N>, N: Dim> PhaseEquilibrium<E, 2, N>

where DefaultAllocator: Allocator<N>,

Utility functions

pub fn is_trivial_solution(state1: &State<E, N>, state2: &State<E, N>) -> bool

Check if the two states form a trivial solution

Trait Implementations

impl<E: Clone, const P: usize, N: Clone + Dim, D: Clone + DualNum<f64> + Copy> Clone for PhaseEquilibrium<E, P, N, D>

where DefaultAllocator: Allocator<N>,

fn clone(&self) -> PhaseEquilibrium<E, P, N, D>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: Debug, const P: usize, N: Debug + Dim, D: Debug + DualNum<f64> + Copy> Debug for PhaseEquilibrium<E, P, N, D>

where DefaultAllocator: Allocator<N>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E: Residual, const P: usize> Display for PhaseEquilibrium<E, P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.