Struct PhaseEquilibrium 

pub struct PhaseEquilibrium<E, const P: usize, N: Dim = Dyn, D: DualNum<f64> + Copy = f64>
where
    DefaultAllocator: Allocator<N>,
{
    pub states: [State<E, N, D>; P],
    pub phase_fractions: [D; P],
    /* private fields */
}

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

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

Fields

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

phase_fractions: [D; P]

Implementations

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

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

Pure component phase equilibria

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

Calculate a phase equilibrium for a pure component.

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<N, D>, N: Gradients, D: DualNum<f64> + Copy> PhaseEquilibrium<E, 2, N, D>

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

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

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

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<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>, X: Composition<D, N>>( eos: &E, temperature_or_pressure: TP, liquid_molefracs: X, 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>, X: Composition<D, N>>( eos: &E, temperature_or_pressure: TP, vapor_molefracs: X, 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<N>, N: Gradients> PhaseEquilibrium<E, 2, N>

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

Flash calculations

pub fn tp_flash<X: Composition<f64, N>>( eos: &E, temperature: Temperature, pressure: Pressure, feed: X, initial_state: Option<&PhaseEquilibrium<E, 2, N>>, 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<U2, D>, D: DualNum<f64> + Copy> PhaseEquilibrium<E, 2, U2, D>

pub fn tp_flash_binary<X: Composition<D, U2>>( eos: &E, temperature: Temperature<D>, pressure: Pressure<D>, feed: X, options: SolverOptions, ) -> FeosResult<Self>

Perform a Tp-flash calculation for a binary mixture. Compared to the version of the algorithm for a generic number of components (tp_flash), this can be used in combination with automatic differentiation.

impl<E: Total<N, D>, N: Gradients + DimAdd<U2> + DimAdd<U3>, D: DualNum<f64> + Copy> PhaseEquilibrium<E, 2, N, D>

where DefaultAllocator: Allocator<N> + Allocator<N, N> + Allocator<<N as DimAdd<U3>>::Output> + Allocator<U1, <N as DimAdd<U3>>::Output> + Allocator<<N as DimAdd<U3>>::Output, <N as DimAdd<U3>>::Output> + Allocator<<N as DimAdd<U2>>::Output> + Allocator<U1, <N as DimAdd<U2>>::Output> + Allocator<<N as DimAdd<U2>>::Output, <N as DimAdd<U2>>::Output>, <N as DimAdd<U3>>::Output: Gradients, <N as DimAdd<U2>>::Output: Gradients,

pub fn ph_flash<X: Composition<D, N>>( eos: &E, pressure: Pressure<D>, molar_enthalpy: MolarEnergy<D>, feed: X, initial_temperature: Temperature, options: SolverOptions, ) -> FeosResult<Self>

Perform a ph-flash calculation. An initial temperature is required and the system needs to be in the two-phase region at that initial temperature.

based on Michelsen’s work State function based flash specifications

pub fn ps_flash<X: Composition<D, N>>( eos: &E, pressure: Pressure<D>, molar_entropy: MolarEntropy<D>, feed: X, initial_temperature: Temperature, options: SolverOptions, ) -> FeosResult<Self>

Perform a ps-flash calculation. An initial temperature is required and the system needs to be in the two-phase region at that initial temperature.

based on Michelsen’s work State function based flash specifications

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 + Subset> PhaseEquilibrium<E, 2>

Azeotrope detection

pub fn binary_azeotrope<TP: TemperatureOrPressure>( eos: &E, temperature_or_pressure: TP, ) -> FeosResult<Option<Self>>

Calculate the azeotropic state in a binary system. If no azeotrope is expected, the function returns None.

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>

pub fn vapor_phase_fraction(&self) -> 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, D>, N: Dim, D: DualNum<f64> + Copy> PhaseEquilibrium<E, 2, N, D>

where DefaultAllocator: Allocator<N>,

pub fn single_phase(state: State<E, N, D>) -> Self

pub fn two_phase(vapor: State<E, N, D>, liquid: State<E, N, D>) -> Self

pub fn with_vapor_phase_fraction( vapor: State<E, N, D>, liquid: State<E, N, D>, vapor_phase_fraction: D, total_moles: Option<Moles<D>>, ) -> Self

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

where DefaultAllocator: Allocator<N>,

pub fn new( vapor: State<E, N, D>, liquid1: State<E, N, D>, liquid2: State<E, N, D>, ) -> Self

impl<E: Residual<N, D>, N: Gradients, const P: usize, D: DualNum<f64> + Copy> PhaseEquilibrium<E, P, N, D>

where DefaultAllocator: Allocator<N>,

pub fn total_moles(&self) -> FeosResult<Moles<D>>

impl<E: Total<N, D>, N: Gradients, const P: usize, D: DualNum<f64> + Copy> PhaseEquilibrium<E, P, N, D>

where DefaultAllocator: Allocator<N>,

pub fn molar_enthalpy(&self) -> MolarEnergy<D>

pub fn enthalpy(&self) -> FeosResult<Energy<D>>

pub fn molar_entropy(&self) -> MolarEntropy<D>

pub fn entropy(&self) -> FeosResult<Entropy<D>>

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<N>, N: Dim, const P: usize> Display for PhaseEquilibrium<E, P, N>

where DefaultAllocator: Allocator<N>,

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

Formats the value using the given formatter.