Flash Namespace Reference

Classes
struct	ThetaEquation
struct	ThetaDerivativeEquation
struct	BrineCO2Data
struct	BrineCO2H2SData
struct	SaturatedPressureH2SEquation
struct	VolumeCO2Equation
struct	VolumeCO2DerivativeEquation
struct	VolumeH2SEquation
struct	VolumeH2SDerivativeEquation
Enumerations
enum	PhysicalState { LIQUID, GAS, SUPERCRITICAL }
Functions
double	ComputeTheta (double zNaCl, double zH2O, double A, double a, double b, double c)
void	FlashBrineCO2H2S (BrineCO2H2SData &data, const BrineCO2Data &co2BrineData, double T, double P, double zH2O, double zCO2, double zH2S)
void	ProgressiveFlashBrineCO2 (BrineCO2Data &data, double T, double P, double zNaCl, double zH2O, double zCO2, unsigned int numCorrections)
void	GeometricFlashBrineCO2 (BrineCO2Data &data, double T, double P, double zNaCl, double zH2O, double zCO2)
void	ProgressiveFlashBrineCO2H2S (BrineCO2H2SData &data, double T, double P, double zNaCl, double zH2O, double zCO2, double zH2S, unsigned int numCorrections)
void	GeometricFlashBrineCO2H2S (BrineCO2H2SData &data, double T, double P, double zNaCl, double zH2O, double zCO2, double zH2S)
std::ostream &	operator<< (std::ostream &out, BrineCO2Data &data)
std::ostream &	operator<< (std::ostream &out, BrineCO2H2SData &data)
double	aCO2 (double T)
double	koH2O (double T)
double	koCO2 (double T, PhysicalState stateCO2)
double	vCO2 (PhysicalState stateCO2)
double	lambdaCO2 (double T, double P)
double	zetaCO2 (double T, double P)
double	uRTH2S (double T, double P)
double	lambdaH2S (double T, double P)
double	ComputeSaturatedMolalityNaCl (double T, double P)
double	ComputeSaturatedPressureH2O (double T)
double	ComputeSaturatedPressureCO2 (double T)
double	ComputeSaturatedPressureH2S (double T)
PhysicalState	DeterminePhysicalStateCO2 (double T, double P)
PhysicalState	DeterminePhysicalStateH2S (double T, double P)
double	ComputeVolumeCO2 (double T, double P, PhysicalState stateCO2)
double	ComputeVolumeCO2 (double T, double P)
double	ComputeVolumeH2S (double T, double P, PhysicalState stateH2S)
double	ComputeFugacityH2O (double volumeCO2, double T, double P)
double	ComputeFugacityCO2 (double volumeCO2, double T, double P)
double	ComputeFugacityH2S (double volumeH2S, double T, double P)
template<typename Function , typename FunctionPrime >
double	NewtonRaphson (Function function, FunctionPrime derivative, double initialGuess, double tolerance=1.0E-4, unsigned maxIterations=100)
template<typename Function >
double	NewtonRaphson (Function function, double initialGuess, double tolerance=1.0E-4, unsigned maxIterations=100)
Variables
const double	TcH2O = 647.30
const double	PcH2O = 221.20
const double	TcCO2 = 304.20
const double	PcCO2 = 73.83
const double	TcH2S = 373.50
const double	PcH2S = 89.63
const double	R = 83.14472
const double	bCO2 = 27.80
const double	bH2O = 18.18
const double	aH2OCO2 = 7.89E7
const double	a1H2S = 5.2386075E-2
const double	a2H2S = -2.7463906E-1
const double	a3H2S = -9.6760173E-2
const double	a4H2S = 1.3618104E-2
const double	a5H2S = -8.8681753E-2
const double	a6H2S = 4.1176908E-2
const double	a7H2S = 3.6354018E-4
const double	a8H2S = 2.2719194E-3
const double	a9H2S = -7.6962514E-4
const double	a10H2S = -2.1948579E-5
const double	a11H2S = -1.1707631E-4
const double	a12H2S = 4.0756926E-5
const double	a13H2S = 5.7582260E-2
const double	a14H2S = 1.00
const double	a15H2S = 0.06
const double	Po = 1.0
const double	vH2O = 18.1
const double	zetaH2S = -1.0832589E-2
const double	toleranceVolumeH2SEquation = 1.0E-2

Enumeration Type Documentation

enum Flash::PhysicalState

Enumerator:

LIQUID
GAS
SUPERCRITICAL

Definition at line 17 of file flashessential.h.

00017 { LIQUID, GAS, SUPERCRITICAL };

Function Documentation

double Flash::aCO2 ( double T ) [inline]

Definition at line 49 of file flashessential.h.

00049 { return 7.54E7 - 4.13E4 * T; };

double Flash::ComputeFugacityCO2	(	double	volumeCO2,
		double	T,
		double	P
	)			`[inline]`

Definition at line 334 of file flashessential.h.

00335 {
00336         // auxiliary variables for performance reasons
00337         double a1 = std::log(volumeCO2/(volumeCO2 - bCO2));
00338         double a2 = std::log(1 + bCO2/volumeCO2);
00339         double a3 = bCO2/(volumeCO2 + bCO2);
00340         double a4 = std::log((P * volumeCO2)/(R * T));
00341         double a5 = R * std::pow(T, 1.5);
00342         // compute the fugacity coefficient of CO2
00343         return std::exp(a1 + bCO2/(volumeCO2 - bCO2) - 2 * aCO2(T)/bCO2 * a2/a5 + aCO2(T)/bCO2 * (a2 - a3)/a5 - a4);
00344 }

double Flash::ComputeFugacityH2O	(	double	volumeCO2,
		double	T,
		double	P
	)			`[inline]`

Definition at line 321 of file flashessential.h.

00322 {
00323         // auxiliary variables for performance reasons
00324         double a1 = std::log(volumeCO2/(volumeCO2 - bCO2));
00325         double a2 = std::log(1 + bCO2/volumeCO2);
00326         double a3 = bCO2/(volumeCO2 + bCO2);
00327         double a4 = std::log((P * volumeCO2)/(R * T));
00328         double a5 = R * std::pow(T, 1.5);
00329         // compute the fugacity coefficient of H2O
00330         return std::exp(a1 + bH2O/(volumeCO2 - bCO2) - 2 * aH2OCO2/bCO2 * a2/a5 + (aCO2(T) * bH2O)/(bCO2 * bCO2) * (a2 - a3)/a5 - a4);
00331 }

double Flash::ComputeFugacityH2S	(	double	volumeH2S,
		double	T,
		double	P
	)			`[inline]`

Definition at line 347 of file flashessential.h.

00349 00350 00351 00352 00353 00354 00355 00356 00357 00358 00359 00360 00361 00362 00363 00364 00365 00366 00367 00368 00369 00370 00371 00372 00373 00374 00375 00376 }

class="fragment">00348 { // static auxiliary variables static double Z; // PV/RT static double Tr1; // 1/Tr = Tc/T, where Tc is critical temperature static double Tr2; // 1/Tr^2 static double Tr3; // 1/Tr^3 static double Vr1; // 1/Vr = R·Tc/V·Pc, where Pc is critical pressure static double Vr2; // 1/Vr^2 static double Vr4; // 1/Vr^4 static double Vr5; // 1/Vr^5 Z = (P * volumeH2S)/(R * T); Tr1 = TcH2S/T; Tr2 = Tr1 * Tr1; Tr3 = Tr2 * Tr1; Vr1 = (R * TcH2S)/(volumeH2S * PcH2S); Vr2 = Vr1 * Vr1; Vr4 = Vr2 * Vr2; Vr5 = Vr4 * Vr1; return std::exp(Z - 1.0 - std::log(Z) + Vr1 * (a1H2S + a2H2S * Tr2 + a3H2S * Tr3) + Vr2 * (a4H2S + a5H2S * Tr2 + a6H2S * Tr3) * 0.50 + Vr4 * (a7H2S + a8H2S * Tr2 + a9H2S * Tr3) * 0.25 + Vr5 * (a10H2S + a11H2S * Tr2 + a12H2S * Tr3) * 0.20 + a13H2S/a15H2S * Tr3 * 0.50 * (a14H2S + 1.0 - (a14H2S + 1.0 + a15H2S * Vr2) * std::exp(-a15H2S * Vr2)));

double Flash::ComputeSaturatedMolalityNaCl	(	double	T,
		double	P
	)			`[inline]`

Definition at line 123 of file flashessential.h.

00123 { return std::exp( 2.86623 - 571.361/T + 77128/(T*T) + 4.0479E-4 * P - 7.445E-7 * (P*P) + 6.209E-10 * (P*P*P) ); }

double Flash::ComputeSaturatedPressureCO2 ( double T ) [inline]

Definition at line 138 of file flashessential.h.

00139 {
00140         double x = 1.0 - T/TcCO2;
00141         return PcCO2 * std::exp(1.0/(1 - x) * (-6.95626 * x + 1.19695 * std::pow(x, 1.5) - 3.12614 * std::pow(x, 3) + 2.99448 * std::pow(x, 6))); 
00142 }

double Flash::ComputeSaturatedPressureH2O ( double T ) [inline]

Definition at line 131 of file flashessential.h.

00132 {
00133         double x = 1.0 - T/TcH2O;
00134         return PcH2O * std::exp(1.0/(1 - x) * (-7.76451 * x + 1.45838 * std::pow(x, 1.5) - 2.77580 * std::pow(x, 3) - 1.23303 * std::pow(x, 6))); 
00135 }

double Flash::ComputeSaturatedPressureH2S ( double T ) [inline]

Definition at line 152 of file flashessential.h.

00153 {
00154         // start value for the nonlinear solver
00155         double Psat0 = 20.0; // vapor pressure near 300K
00156         // the nonlinear equation
00157         static SaturatedPressureH2SEquation equation;
00158         // setting the parameters of the equation
00159         equation.T = T;
00160         // solving the nonlinear equation
00161         return NewtonRaphson(equation, Psat0);
00162 }

double Flash::ComputeTheta	(	double	zNaCl,
		double	zH2O,
		double	A,
		double	a,
		double	b,
		double	c
	)

Definition at line 31 of file flash.cpp.

00035 {
00036         // start value for the nonlinear solver
00037         double theta0 = zNaCl/zH2O;
00038         // the nonlinear equation
00039         ThetaEquation function;
00040         // the derivative of the nonlinear function representing the equation
00041         ThetaDerivativeEquation derivative;
00042         // setting the parameters of the equation and its derivative
00043         function.zNaCl = zNaCl; derivative.zNaCl = zNaCl;
00044         function.zH2O = zH2O;   derivative.zH2O = zH2O;
00045         function.A = A;         derivative.A = A;
00046         function.a = a;         derivative.a = a;
00047         function.b = b;         derivative.b = b;
00048         function.c = c;         derivative.c = c;

double Flash::ComputeVolumeCO2	(	double	T,
		double	P
	)			`[inline]`

Definition at line 219 of file flashessential.h.

00220 {
00221   PhysicalState stateCO2=DeterminePhysicalStateCO2(T,P);
00222 
00223         // start value for the nonlinear solver
00224         double V0 = (stateCO2 == GAS || stateCO2 == SUPERCRITICAL) ? (R * T/P) : 59.22; // vCO2 = 59.22 mol/cm^3 at 25 °C and 80.0 bar
00225 
00226         // the nonlinear equation
00227         static VolumeCO2Equation equation;
00228         // the derivative of the nonlinear equation
00229         static VolumeCO2DerivativeEquation derivative;
00230         // setting the parameters of the equation
00231         equation.T = T; derivative.T = T;
00232         equation.P = P; derivative.P = P;
00233 
00234         double result=NewtonRaphson(equation, derivative, V0);
00235         assert(result>=0.0);
00236         return result;
00237 }

double Flash::ComputeVolumeCO2	(	double	T,
		double	P,
		PhysicalState	stateCO2
	)			`[inline]`

Definition at line 201 of file flashessential.h.

00202 {
00203         // start value for the nonlinear solver
00204         double V0 = (stateCO2 == GAS || stateCO2 == SUPERCRITICAL) ? (R * T/P) : 59.22; // vCO2 = 59.22 mol/cm^3 at 25 °C and 80.0 bar
00205 
00206         // the nonlinear equation
00207         static VolumeCO2Equation equation;
00208         // the derivative of the nonlinear equation
00209         static VolumeCO2DerivativeEquation derivative;
00210         // setting the parameters of the equation
00211         equation.T = T; derivative.T = T;
00212         equation.P = P; derivative.P = P;
00213 
00214         // solving the nonlinear equation
00215         return NewtonRaphson(equation, derivative, V0);
00216 }

double Flash::ComputeVolumeH2S	(	double	T,
		double	P,
		PhysicalState	stateH2S
	)			`[inline]`

Definition at line 300 of file flashessential.h.

00301 {
00302         // start value for the nonlinear solver
00303         double V0 = (stateH2S == GAS || stateH2S == SUPERCRITICAL) ? (R * T/P) :  44.60; // vH2S = 44.60 mol/cm^3 at 60.0°C and 300.0 bar
00304         // the nonlinear equation
00305         static VolumeH2SEquation equation;
00306         // the derivative of the nonlinear equation
00307         static VolumeH2SDerivativeEquation derivative;
00308         // setting the parameters of the equation
00309         equation.T = T; derivative.T = T;
00310         equation.P = P; derivative.P = P;
00311         // solving the nonlinear equation
00312         return NewtonRaphson(equation, derivative, V0, toleranceVolumeH2SEquation);
00313 }

PhysicalState Flash::DeterminePhysicalStateCO2	(	double	T,
		double	P
	)			`[inline]`

Definition at line 170 of file flashessential.h.

00171 {
00172         return (T < TcCO2) ? ( (P > ComputeSaturatedPressureCO2(T)) ? LIQUID : GAS ) : ( (P > PcCO2) ? SUPERCRITICAL : GAS );
00173 }

PhysicalState Flash::DeterminePhysicalStateH2S	(	double	T,
		double	P
	)			`[inline]`

Definition at line 176 of file flashessential.h.

00177 {
00178         return (T < TcH2S) ? ( (P > ComputeSaturatedPressureH2S(T)) ? LIQUID : GAS ) : ( (P > PcH2S) ? SUPERCRITICAL : GAS );
00179 }

void Flash::FlashBrineCO2H2S	(	BrineCO2H2SData &	data,
		const BrineCO2Data &	co2BrineData,
		double	T,
		double	P,
		double	zH2O,
		double	zCO2,
		double	zH2S
	)

Definition at line 50 of file flash.cpp.

00054 {
00055         // determine the state of the CO2 and H2S
00056         data.stateCO2 = co2BrineData.stateCO2;
00057         data.stateH2S = DeterminePhysicalStateH2S(T, P);
00058 
00059         // auxiliary variable to determine if the H2S is fully solubilized in the aqueous phase
00060         bool isH2SFullySolubilized;
00061 
00062         // verify the existence of an aqueous phase
00063         bool isThereAqueousPhase = (co2BrineData.betaA != 0.0);
00064 
00065         // compute the molar fractions in the aqueous phase
00066         if(isThereAqueousPhase)
00067         {
00068                 // compute the NaCl molality in the aqueous phase
00069                 double mNaCl = 55.508 * co2BrineData.xNaCl/co2BrineData.xH2O;
00070 
00071                 // compute the CO2 molality in the aqueous phase
00072                 double mCO2 = 55.508 * co2BrineData.xCO2/co2BrineData.xH2O;
00073 
00074                 // compute the saturated H2S molality
00075                 double saturatedMolalityH2S = (P - ComputeSaturatedPressureH2O(T))/std::exp(uRTH2S(T, P) - std::log(ComputeFugacityH2S(ComputeVolumeH2S(T, P, data.stateH2S), T, P)) + 2 * lambdaH2S(T, P) * mNaCl + zetaH2S * mNaCl * mNaCl);
00076 
00077                 // compute the H2S molality assuming fully solubilization
00078                 double mH2SFullySolubilized = 55.508 * zH2S/zH2O;
00079 
00080                 // auxiliary variable for the H2S molality in the aqueous phase
00081                 double mH2S;
00082 
00083                 // compute the H2S molality in the aqueous phase and also determine if the H2S is fully solubilized
00084                 if(mH2SFullySolubilized < saturatedMolalityH2S)
00085                 {
00086                         mH2S = mH2SFullySolubilized;
00087                         isH2SFullySolubilized = true;
00088                 }
00089                 else
00090                 {
00091                         mH2S = saturatedMolalityH2S;
00092                         isH2SFullySolubilized = false;
00093                 }
00094 
00095                 // compute the molar fractions in the aqueous phase
00096                 data.xH2O  = 55.508/(55.508 + mNaCl + mCO2 + mH2S);
00097                 data.xNaCl = data.xH2O * mNaCl/55.508;
00098                 data.xCO2  = data.xH2O * mCO2/55.508;
00099                 data.xH2S  = 1 - data.xNaCl - data.xH2O - data.xCO2;
00100         }
00101         else
00102         {
00103                 // the molar fractions in the aqueous phase are all zero
00104                 data.xH2O  = 0.0;
00105                 data.xNaCl = 0.0;
00106                 data.xCO2  = 0.0;
00107                 data.xH2S  = 0.0;
00108 
00109                 // verify if H2S is fully solubilized in the aqueous phase
00110                 isH2SFullySolubilized = false;
00111         }
00112 
00113         // verify the existence of a CO2-rich phase
00114         bool isThereCO2RichPhase = (co2BrineData.betaC != 0.0);
00115 
00116         // verify the existence of a H2S-rich phase (CO2 or H2S has to be in the liquid state and H2S cannot be fully solubilized in the aqueous phase)
00117         bool isThereH2SRichPhase = (data.stateCO2 == LIQUID || data.stateH2S == LIQUID) && !isH2SFullySolubilized;
00118 
00119         // compute the phase molar fractions
00120         data.betaS = co2BrineData.betaS * (1.0 - zH2S);
00121         data.betaA = co2BrineData.betaA * (1.0 - zH2S)/(1 - data.xH2S);
00122 
00123         if(isThereH2SRichPhase)
00124         {
00125                 data.betaC = co2BrineData.betaC * (1.0 - zH2S);
00126                 data.betaH = 1.0 - data.betaS - data.betaA - data.betaC;
00127         }
00128         else
00129         {
00130                 data.betaC = 1.0 - data.betaS - data.betaA;
00131                 data.betaH = 0.0;
00132         }
00133 
00134         // compute the molar fractions in the CO2-rich phase
00135         if(isThereCO2RichPhase)
00136         {
00137                 data.yH2S = (isThereH2SRichPhase) ? 0.0 : (zH2S - data.xH2S * data.betaA)/data.betaC;
00138                 data.yCO2 = (zCO2 - data.xCO2 * data.betaA)/data.betaC;
00139                 data.yH2O = 1 - data.yCO2 - data.yH2S;
00140         }
00141         else
00142         {
00143                 data.yH2S = 0.0;
00144                 data.yCO2 = 0.0;

void Flash::GeometricFlashBrineCO2	(	BrineCO2Data &	data,
		double	T,
		double	P,
		double	zNaCl,
		double	zH2O,
		double	zCO2
	)

void Flash::GeometricFlashBrineCO2H2S	(	BrineCO2H2SData &	data,
		double	T,
		double	P,
		double	zNaCl,
		double	zH2O,
		double	zCO2,
		double	zH2S
	)

double Flash::koCO2	(	double	T,
		PhysicalState	stateCO2
	)			`[inline]`

Definition at line 78 of file flashessential.h.

00079 { 
00080         T = T - 273.15; 
00081         return (stateCO2 == GAS || stateCO2 == SUPERCRITICAL) ? 
00082                 std::pow(10.0, 1.189 + 1.304E-2 * T - 5.446E-5 * T*T) : 
00083                 std::pow(10.0, 1.169 + 1.368E-2 * T - 5.380E-5 * T*T); 
00084 }

double Flash::koH2O ( double T ) [inline]

Definition at line 72 of file flashessential.h.

00073 { 
00074         T = T - 273.15;
00075         return std::pow(10.0, -2.209 + 3.097E-2 * T - 1.098E-4 * T*T + 2.048E-7 * T*T*T); 
00076 }

double Flash::lambdaCO2	(	double	T,
		double	P
	)			`[inline]`

Definition at line 94 of file flashessential.h.

00095 { 
00096         return -0.411370585 + 6.07632013E-4 * T + 97.5347708/T - 0.0237622469 * P/T + 0.0170656236 * P/(630.0 - T) + 1.41335834E-5 * T * std::log(P); 
00097 }

double Flash::lambdaH2S	(	double	T,
		double	P
	)			`[inline]`

Definition at line 110 of file flashessential.h.

00111 { 
00112         return 8.5004999E-2 + 3.5330378E-5 * T - 1.5882605/T + 1.1894926E-5 * P;
00113 }

template<typename Function >

double Flash::NewtonRaphson	(	Function	function,
		double	initialGuess,
		double	tolerance = `1.0E-4`,
		unsigned	maxIterations = `100`
	)			`[inline]`

Definition at line 28 of file newtonraphson.h.

00029 {
00030         // Auxiliary variables.
00031         double xNew = 0.0;
00032         double xOld = initialGuess;
00033         const double epsilon = 1.0E-6;
00034 
00035         for(unsigned iter = 0; iter < maxIterations; ++iter)
00036         {
00037                 xNew = xOld - 2.0 * epsilon * function(xOld) / (function(xOld + epsilon) - function(xOld - epsilon));
00038 
00039                 if(fabsf(xNew - xOld)/xNew < tolerance) break;
00040 
00041                 xOld = xNew;
00042         }
00043 
00044         return xNew;
00045 }

template<typename Function , typename FunctionPrime >

double Flash::NewtonRaphson	(	Function	function,
		FunctionPrime	derivative,
		double	initialGuess,
		double	tolerance = `1.0E-4`,
		unsigned	maxIterations = `100`
	)			`[inline]`

Definition at line 8 of file newtonraphson.h.

00009 {
00010         // Auxiliary variables.
00011         double xNew = 0.0;
00012         double xOld = initialGuess;
00013 
00014         for(unsigned iter = 0; iter < maxIterations; ++iter)
00015         {
00016                 xNew = xOld - function(xOld) / derivative(xOld);
00017 
00018                 if(fabsf(xNew - xOld)/xNew < tolerance) break;
00019 
00020                 xOld = xNew;
00021         }
00022 
00023         return xNew;
00024 }

std::ostream & Flash::operator<<	(	std::ostream &	out,
		BrineCO2H2SData &	data
	)

std::ostream & Flash::operator<<	(	std::ostream &	out,
		BrineCO2Data &	data
	)

void Flash::ProgressiveFlashBrineCO2	(	BrineCO2Data &	data,
		double	T,
		double	P,
		double	zNaCl,
		double	zH2O,
		double	zCO2,
		unsigned int	numCorrections
	)

void Flash::ProgressiveFlashBrineCO2H2S	(	BrineCO2H2SData &	data,
		double	T,
		double	P,
		double	zNaCl,
		double	zH2O,
		double	zCO2,
		double	zH2S,
		unsigned int	numCorrections
	)

double Flash::uRTH2S	(	double	T,
		double	P
	)			`[inline]`

Definition at line 105 of file flashessential.h.

00106 { 
00107         return 42.564957 - 8.6260377E-2 * T - 6084.3775/T + 6.8714437E-5 * (T*T) - 102.76849/(680 - T) + 8.4482895E-4 * P - 1.0590768 * P/(680 - T) + 3.5665902E-3 * (P*P)/T; 
00108 }

double Flash::vCO2 ( PhysicalState stateCO2 ) [inline]

Definition at line 91 of file flashessential.h.

00091 { return (stateCO2 == GAS || stateCO2 == SUPERCRITICAL) ? 32.6 : 32.0; }

double Flash::zetaCO2	(	double	T,
		double	P
	)			`[inline]`

Definition at line 99 of file flashessential.h.

00100 { 
00101         return 3.36389723E-4 - 1.98298980E-5 * T + 2.12220830E-3 * P/T - 5.24873303E-3 * P/(630.0 - T);
00102 }

Variable Documentation

const double Flash::a10H2S = -2.1948579E-5

Definition at line 64 of file flashessential.h.

const double Flash::a11H2S = -1.1707631E-4

Definition at line 65 of file flashessential.h.

const double Flash::a12H2S = 4.0756926E-5

Definition at line 66 of file flashessential.h.

const double Flash::a13H2S = 5.7582260E-2

Definition at line 67 of file flashessential.h.

const double Flash::a14H2S = 1.00

Definition at line 68 of file flashessential.h.

const double Flash::a15H2S = 0.06

Definition at line 69 of file flashessential.h.

const double Flash::a1H2S = 5.2386075E-2

Definition at line 55 of file flashessential.h.

const double Flash::a2H2S = -2.7463906E-1

Definition at line 56 of file flashessential.h.

const double Flash::a3H2S = -9.6760173E-2

Definition at line 57 of file flashessential.h.

const double Flash::a4H2S = 1.3618104E-2

Definition at line 58 of file flashessential.h.

const double Flash::a5H2S = -8.8681753E-2

Definition at line 59 of file flashessential.h.

const double Flash::a6H2S = 4.1176908E-2

Definition at line 60 of file flashessential.h.

const double Flash::a7H2S = 3.6354018E-4

Definition at line 61 of file flashessential.h.

const double Flash::a8H2S = 2.2719194E-3

Definition at line 62 of file flashessential.h.

const double Flash::a9H2S = -7.6962514E-4

Definition at line 63 of file flashessential.h.

const double Flash::aH2OCO2 = 7.89E7

Definition at line 52 of file flashessential.h.

const double Flash::bCO2 = 27.80

Definition at line 50 of file flashessential.h.

const double Flash::bH2O = 18.18

Definition at line 51 of file flashessential.h.

const double Flash::PcCO2 = 73.83

Definition at line 30 of file flashessential.h.

const double Flash::PcH2O = 221.20

Definition at line 26 of file flashessential.h.

const double Flash::PcH2S = 89.63

Definition at line 34 of file flashessential.h.

const double Flash::Po = 1.0

Definition at line 87 of file flashessential.h.

const double Flash::R = 83.14472

Definition at line 41 of file flashessential.h.

const double Flash::TcCO2 = 304.20

Definition at line 29 of file flashessential.h.

const double Flash::TcH2O = 647.30

Definition at line 25 of file flashessential.h.

const double Flash::TcH2S = 373.50

Definition at line 33 of file flashessential.h.

const double Flash::toleranceVolumeH2SEquation = 1.0E-2

Definition at line 297 of file flashessential.h.

const double Flash::vH2O = 18.1

Definition at line 90 of file flashessential.h.

const double Flash::zetaH2S = -1.0832589E-2

Definition at line 115 of file flashessential.h.

Flash Namespace Reference

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

Function Documentation

Variable Documentation