MixtureComp_8hpp_source.html

 #ifndef __MIXTURECOMP_HEADER__

 #define __MIXTURECOMP_HEADER__


 // Standard header files

 #include <algorithm>

 #include <math.h>

 #include <vector>


 // OpenCAEPoro header files

 #include "DenseMat.hpp"

 #include "Mixture.hpp"

 #include "OCPTable.hpp"


 using namespace std;


 class SSMparamSTA

 {

 public:

     USI      maxIt;

     OCP_DBL  tol;

     OCP_DBL  Ktol{1E-4};

     OCP_DBL  dYtol{1E-6};

     OCP_DBL  eYt{1E-8};

     OCP_DBL  tol2;

     OCP_DBL  realTol;

     OCP_BOOL conflag;

                         // test

     USI     curIt;

     OCP_DBL curSk;

 };


 class NRparamSTA

 {

 public:

     USI      maxIt;

     OCP_DBL  tol;

     OCP_DBL  tol2;

     OCP_DBL  realTol;

     OCP_BOOL conflag;

     // test

     USI curIt;

 };


 class SSMparamSP

 {

 public:

     USI      maxIt;

     OCP_DBL  tol;

     OCP_DBL  tol2;

     OCP_DBL  realTol;

     OCP_BOOL conflag;

     // test

     USI curIt;

 };


 class NRparamSP

 {

 public:

     USI      maxIt;

     OCP_DBL  tol;

     OCP_DBL  tol2;

     OCP_DBL  realTol;

     OCP_BOOL conflag;

     // test

     USI curIt;

 };


 class RRparam

 {

 public:

     USI     maxIt;

     OCP_DBL tol;

     OCP_DBL tol2;

     // test

     USI curIt;

 };


 class EoScontrol

 {

     friend class MixtureComp;


 private:

     SSMparamSTA SSMsta;

     NRparamSTA  NRsta;

     SSMparamSP  SSMsp;

     NRparamSP   NRsp;

     RRparam     RR;

 };


 class COMP

 {

 public:

     COMP() = default;

     COMP(const vector<string>& comp);


 public:

     string  name;

     OCP_DBL Pc;

     OCP_DBL Tc;

     OCP_DBL acf;

     OCP_DBL MW;

     OCP_DBL VcMW;

     OCP_DBL Vc;

     OCP_DBL OmegaA;

     OCP_DBL OmegaB;

     OCP_DBL Vshift;

 };


 class MixtureComp : public Mixture

 {


 public:

     OCP_DBL GetErrorPEC() override { return ePEC; }

     void    OutMixtureIters() const override;


 private:

     // total iters

     OCP_ULL itersSSMSTA{0};

     OCP_ULL itersNRSTA{0};

     OCP_ULL itersSSMSP{0};

     OCP_ULL itersNRSP{0};

     OCP_ULL itersRR{0};

     // total counts, one count may contain many iters

     OCP_ULL countsSSMSTA{0};

     OCP_ULL countsNRSTA{0};

     OCP_ULL countsSSMSP{0};

     OCP_ULL countsNRSP{0};

     OCP_ULL countsRR{0};


     OCP_ULL countsFailed{0};

     // phase equilibrium calculation error

     // if NP = 1, it's from phase stable analysis, if skiped, it's 0

     // if NP > 1, it's from phase spliting calculation

     OCP_DBL ePEC;


 public:

     MixtureComp() = default;


     MixtureComp(const ParamReservoir& rs_param, const USI& i)

         : MixtureComp(rs_param.comsParam, i)

     {

         // water property

         if (rs_param.PVTW_T.data.size() != 0) {

             PVTW.Setup(rs_param.PVTW_T.data[i]);

             if (rs_param.gravity.activity)

                 std_RhoW = RHOW_STD * rs_param.gravity.data[1];

             if (rs_param.density.activity) std_RhoW = RHOW_STD;

             data.resize(5);

             cdata.resize(5);

         }

     };


     MixtureComp(const ComponentParam& param, const USI& i);


     void InitPTZ(const OCP_DBL& Pin, const OCP_DBL& Tin, const OCP_DBL* Ziin)

     {

         P = Pin;

         T = Tin;

         Dcopy(NC, &zi[0], Ziin);

     }

     void InitPTN(const OCP_DBL& Pin, const OCP_DBL& Tin, const OCP_DBL* Niin)

     {

         P = Pin;

         T = Tin;

         Dcopy(numCom, &Ni[0], Niin);

         Nh = Dnorm1(NC, &Ni[0]);

         for (USI i = 0; i < NC; i++) zi[i] = Ni[i] / Nh;

     }


     void Flash(const OCP_DBL& Pin, const OCP_DBL& Tin, const OCP_DBL* Niin) override;


     void InitFlashIMPEC(const OCP_DBL& Pin,

                         const OCP_DBL& Pbbin,

                         const OCP_DBL& Tin,

                         const OCP_DBL* Sjin,

                         const OCP_DBL& Vpore,

                         const OCP_DBL* Ziin,

                         const OCP_USI& bId) override;


     void InitFlashFIM(const OCP_DBL& Pin,

                       const OCP_DBL& Pbbin,

                       const OCP_DBL& Tin,

                       const OCP_DBL* Sjin,

                       const OCP_DBL& Vpore,

                       const OCP_DBL* Ziin,

                       const OCP_USI& bId) override;


     void InitFlashFIMn(const OCP_DBL& Pin,

                        const OCP_DBL& Pbbin,

                        const OCP_DBL& Tin,

                        const OCP_DBL* Sjin,

                        const OCP_DBL& Vpore,

                        const OCP_DBL* Ziin,

                        const OCP_USI& bId) override;


     // ftype = 0, flash from single phase

     // ftype = 1, skip phase stability analysis and num of phase = 1

     // ftype = 1, skip phase stability analysis and num of phase = 2

     void FlashIMPEC(const OCP_DBL& Pin,

                     const OCP_DBL& Tin,

                     const OCP_DBL* Niin,

                     const USI&     lastNP,

                     const OCP_DBL* xijin,

                     const OCP_USI& bId) override;


     void CalFlash();


     void FlashFIM(const OCP_DBL& Pin,

                   const OCP_DBL& Tin,

                   const OCP_DBL* Niin,

                   const OCP_DBL* Sjin,

                   const USI&     lastNP,

                   const OCP_DBL* xijin,

                   const OCP_USI& bId) override;


     void FlashFIMn(const OCP_DBL& Pin,

                    const OCP_DBL& Tin,

                    const OCP_DBL* Niin,

                    const OCP_DBL* Sjin,

                    const OCP_DBL* xijin,

                    const OCP_DBL* njin,

                    const USI*     phaseExistin,

                    const USI&     lastNP,

                    const OCP_USI& bId) override;


     OCP_DBL

     XiPhase(const OCP_DBL& Pin,

             const OCP_DBL& Tin,

             const OCP_DBL* Ziin,

             const USI&     tarPhase) override;


     OCP_DBL

     RhoPhase(const OCP_DBL& Pin,

              const OCP_DBL& Pbb,

              const OCP_DBL& Tin,

              const OCP_DBL* Ziin,

              const USI&     tarPhase) override;


     // For Well

     void SetupWellOpt(WellOpt&                  opt,

                       const vector<SolventINJ>& sols,

                       const OCP_DBL&            Psurf,

                       const OCP_DBL&            Tsurf) override;

     void CalProdWeight(const OCP_DBL&         Pin,

                        const OCP_DBL&         Tin,

                        const OCP_DBL*         Niin,

                        const vector<OCP_DBL>& prodPhase,

                        vector<OCP_DBL>&       prodWeight) override;


     void CalProdRate(const OCP_DBL&   Pin,

                      const OCP_DBL&   Tin,

                      const OCP_DBL*   Niin,

                      vector<OCP_DBL>& prodRate) override;


     OCP_DBL CalInjWellEnthalpy(const OCP_DBL& Tin, const OCP_DBL* Ziin) override

     {

         OCP_ABORT("Can not be used in Compositional Model!");

     }


     void CallId();


 private:

     // Basic Components Informations

     vector<string>  Cname;

     vector<OCP_DBL> Tc;

     vector<OCP_DBL> Pc;

     vector<OCP_DBL> Vc;

     vector<OCP_DBL> MWC;

     vector<OCP_DBL> Acf;

     vector<OCP_DBL> OmegaA;

     vector<OCP_DBL> OmegaB;

     vector<OCP_DBL> Vshift;

     vector<OCP_DBL> Zc;

     // for viscosity calculation

     vector<OCP_DBL> Vcvis;

     vector<OCP_DBL> Zcvis;

     vector<OCP_DBL> LBCcoef;

     vector<OCP_DBL> BIC;


     // Initial properties

     USI             NC;

     USI             NPmax;

     OCP_DBL         P;

     OCP_DBL         T;

     vector<OCP_DBL> zi;

     vector<COMP>    comp;

     USI             lId;

     EoScontrol      EoSctrl;


     vector<OCP_DBL> Plist;

     vector<OCP_DBL> Tlist;

     vector<OCP_DBL> Ytlist;


 private:

     OCPTable        PVTW;

     OCP_DBL         std_RhoW;

     vector<OCP_DBL> data;

     vector<OCP_DBL> cdata;


 public:

     // EoS Function

     // Allocate memory for EoS

     void AllocateEoS();

     // Setup and Solve EoS for specified A,B

     void SolEoS(OCP_DBL& ZjT, const OCP_DBL& AjT, const OCP_DBL& BjT) const;

     // Calculate Ai and Bi

     void CalAiBi();

     // Calculate Aj and Bj with specified xj

     void CalAjBj(OCP_DBL& AjT, OCP_DBL& BjT, const vector<OCP_DBL>& xj) const;

     void CalAjBj(OCP_DBL& AjT, OCP_DBL& BjT, const OCP_DBL* xj) const;

     USI CubicRoot(const OCP_DBL&  a,

                   const OCP_DBL&  b,

                   const OCP_DBL&  c,

                   const OCP_BOOL& NTflag = OCP_FALSE) const;

     void PrintZtmp()

     {

         for (auto z : Ztmp) cout << z << "\t";

     }


 private:

     // EoS Variables

     vector<OCP_DBL>         Ai;

     vector<OCP_DBL>         Bi;

     vector<OCP_DBL>         Aj;

     vector<OCP_DBL>         Bj;

     vector<OCP_DBL>         Zj;

     mutable vector<OCP_DBL> Ztmp;


     // PR default

     OCP_DBL delta1 = 2.41421356237;

     OCP_DBL delta2 = -0.41421356237;

     OCP_DBL delta1P2;

     OCP_DBL delta1M2;

     OCP_DBL delta1T2;


 public:

     // Phase Function

     // Allocate memoery for phase variables

     void AllocatePhase();

     void

     CalFugPhi(vector<OCP_DBL>& phiT, vector<OCP_DBL>& fugT, const vector<OCP_DBL>& xj);

     void CalFugPhi(OCP_DBL* phiT, OCP_DBL* fugT, const OCP_DBL* xj);

     void CalFugPhi(OCP_DBL* fugT, const OCP_DBL* xj);

     void CalFugPhiAll();

     void CalMW();

     void CalVfXiRho();

     void CalSaturation();

     USI  FindMWmax();

     void x2n();

     void PrintX();


 private:

     // Phase Variables

     USI             lNP{0};

     USI             NP;

     USI             inputNP;

     OCP_DBL         Nh;

     vector<OCP_DBL> vC;

     vector<OCP_DBL>

         nu;

     vector<vector<OCP_DBL>>

         x;

     vector<vector<OCP_DBL>> phi;

     vector<vector<OCP_DBL>>

         fug;

     vector<vector<OCP_DBL>>

         n;

     vector<vector<OCP_DBL>> ln;

     OCP_DBL         GibbsEnergyB;

     OCP_DBL         GibbsEnergyE;

     vector<OCP_DBL> xiC;

     vector<OCP_DBL> rhoC;

     vector<OCP_DBL> MW;

     vector<USI>     phaseLabel;


 public:

     // Method Function

     // Allocate memoery for Method variables

     void     AllocateMethod();

     void     PhaseEquilibrium();

     void     CalKwilson();

     OCP_BOOL PhaseStable();

     OCP_BOOL StableSSM(const USI& Id);

     OCP_BOOL StableSSM01(const USI& Id);

     OCP_BOOL StableNR(const USI& Id);

     void     CalFugXSTA();

     void     AssembleJmatSTA();

     OCP_BOOL CheckSplit();

     void     PhaseSplit();

     void     SplitSSM(const OCP_BOOL& flag);

     void     SplitSSM2(const OCP_BOOL& flag);

     void     SplitSSM3(const OCP_BOOL& flag);

     void     RachfordRice2();

     void     RachfordRice2P();

     void     RachfordRice3();

     void     UpdateXRR();

     void     SplitBFGS();

     void     SplitNR();

     void     CalResSP();

     void     CalFugNAll(const OCP_BOOL& Znflag = OCP_TRUE);

     void     PrintFugN();

     void     AssembleJmatSP();

     OCP_DBL  CalStepNRsp();


 private:

     // Method Variables

     USI testPId;

     vector<vector<OCP_DBL>> Kw;

     vector<vector<OCP_DBL>> Ks;

     vector<OCP_DBL>         lKs;

     OCP_DBL                 Asta, Bsta, Zsta;

     vector<OCP_DBL> phiSta;

     vector<OCP_DBL> fugSta;

     // SSM in Stability Analysis

     vector<OCP_DBL> Y;

     OCP_DBL         Yt;

     vector<OCP_DBL> di;

     // NR in Stability Analysis

     vector<OCP_DBL>         resSTA;

     vector<OCP_DBL>         JmatSTA;

     vector<vector<OCP_DBL>> fugX;

     vector<OCP_DBL>         Ax;

     vector<OCP_DBL>         Bx;

     vector<OCP_DBL>         Zx;


     // SSM in Phase Split

     vector<OCP_DBL> resRR;

     // NR in Phase Split

     vector<OCP_DBL> lresSP;

     vector<OCP_DBL> resSP;

     vector<OCP_DBL> JmatSP;

     vector<vector<OCP_DBL>>

                     fugN;

     vector<OCP_DBL> An;

     vector<OCP_DBL> Bn;

     vector<vector<OCP_DBL>> Zn;

     // for linearsolve with lapack

     vector<OCP_INT> pivot;

     vector<OCP_DBL> JmatWork;

     OCP_INT         lJmatWork;

     char            uplo{'U'};


 public:

     // After Phase Equilibrium Calculation finishs, properties and some auxiliary

     // variables will be calculated.

     void AllocateOthers();

     void IdentifyPhase();

     void CopyPhase();

     void CalViscosity();

     void CalViscoLBC();

     void CalViscoHZYT();

     void CalFugXAll();

     void CalFugPAll(const OCP_BOOL& Zpflag = OCP_TRUE);


     void CalVjpVfpVfx_partial();

     void CalXiPNX_partial();

     void CalRhoPX_partial();

     void CalMuPX_partial();

     void CalMuPXLBC_partial();

     void CalXiRhoMuPN_pfullx();

     void CaldXsdXpAPI04();

     void CaldXsdXp04();


     void CalRhoPNX_full();


     void CalXiPNX_full01();

     void CalRhoPNX_full01();

     void CalMuPX_full01();

     void CalMuPXLBC_full01();

     void CalVfiVfp_full01();

     void AssembleMatVfiVfp_full01();

     void AssembleRhsVfiVfp_full01();

     void CaldXsdXp01();

     void CaldXsdXpAPI01();


     void CalXiPNX_full02();

     void CalVfiVfp_full02();

     void AssembleMatVfiVfp_full02();

     void AssembleRhsVfiVfp_full02();

     void CaldXsdXpAPI02();

     void CaldXsdXpAPI02p();


     void CalVjpVfpVfn_partial();

     void CalXiPn_partial();

     void CalRhoPn_partial();

     void CalMuPn_partial();

     void CalMuPnLBC_partial();

     void CalXiRhoMuPN_pfullxn(const OCP_BOOL& xflag = OCP_TRUE);


     void CaldXsdXpAPI03();

     void CaldXsdXp03();

     void CalVfiVfp_full03();


     void CalKeyDerx();

     void CalKeyDern();


 private:

     // Phase properties and auxiliary variables

     vector<OCP_DBL> muC;

     vector<vector<OCP_DBL>>

         muAux;

     vector<OCP_DBL>

         muAux1I;

     vector<OCP_DBL>         sqrtMWi;

     vector<vector<OCP_DBL>> fugP;

     vector<OCP_DBL>         Zp;


     vector<OCP_DBL> JmatTmp;

     vector<OCP_DBL> JmatDer;

     vector<OCP_DBL> rhsDer;


     vector<OCP_DBL> vjp;

     vector<vector<OCP_DBL>>

         vji;

     vector<OCP_DBL> xixC;

     vector<OCP_DBL> xiPC;

     vector<OCP_DBL> xiNC;

     vector<OCP_DBL> muN;

     vector<OCP_DBL> xiN;

     vector<OCP_DBL> rhoN;


     // Optional Features


 public:

     void SetupOptionalFeatures(OptionalFeatures& optFeatures,

                                const OCP_USI&    numBulk) override;


     // Accelerate PVT


 protected:

     void AllocateSkip();

     void CalPhiNSkip();

     void AssembleSkipMatSTA();

     void CalSkipForNextStep();

     void CalFtypeIMPEC() { ftype = skipSta->CalFtypeIMPEC(P, T, Nh, Ni, bulkId); }

     void CalFtypeFIM(const OCP_DBL* Sjin)

     {

         ftype = skipSta->CalFtypeFIM(P, T, Nh, Ni, Sjin, lNP, bulkId);

     }


 protected:

     SkipStaAnaly* skipSta;


     USI ftype{0};

     //  if ftype = 0 also, then new range should be calculated

     OCP_BOOL        flagSkip;

     vector<OCP_DBL> phiN;

     vector<OCP_SIN> skipMatSTA;

     //  Only the minimum eigen value will be used

     vector<OCP_SIN> eigenSkip;

     vector<OCP_SIN> eigenWork;


     // Miscible


 protected:

     void InputMiscibleParam(const ComponentParam& param, const USI& tarId);

     void CalSurfaceTension();


 protected:

     Miscible* misTerm;


     OCP_BOOL ifUseMiscible;


     OCP_DBL surTen;


     vector<OCP_DBL> parachor;

 };


 OCP_DBL signD(const OCP_DBL& d);


 OCP_DBL delta(const USI& i, const USI& j);


 void NTcubicroot(OCP_DBL& root, const OCP_DBL& a, const OCP_DBL& b, const OCP_DBL& c);


 #endif //__MIXTURECOMP_HEADER__

DenseMat.hpp
Operations about small dense mat.

Dnorm1
double Dnorm1(const int &N, double *x)
Computes the L1-norm of a vector.
Definition: DenseMat.cpp:49

Dcopy
void Dcopy(const int &N, double *dst, const double *src)
Calculate the minimal eigenvalue for symmetric matrix with mkl lapack.
Definition: DenseMat.cpp:36

signD
OCP_DBL signD(const OCP_DBL &d)
Return the sign of double di.
Definition: MixtureComp.cpp:5059

Mixture.hpp
Mixture class declaration.

USI
unsigned int USI
Generic unsigned integer.
Definition: OCPConst.hpp:23

OCP_DBL
double OCP_DBL
Double precision.
Definition: OCPConst.hpp:27

RHOW_STD
const OCP_DBL RHOW_STD
Water density at surface cond: lb/ft3.
Definition: OCPConst.hpp:57

OCP_USI
unsigned int OCP_USI
Long unsigned integer.
Definition: OCPConst.hpp:25

OCP_INT
int OCP_INT
Long integer.
Definition: OCPConst.hpp:26

OCP_BOOL
unsigned int OCP_BOOL
OCP_BOOL in OCP.
Definition: OCPConst.hpp:29

OCP_ULL
unsigned long long OCP_ULL
Long long unsigned integer.
Definition: OCPConst.hpp:24

OCPTable.hpp
OCPTable class declaration.

OCP_ABORT
#define OCP_ABORT(msg)
Abort if critical error happens.
Definition: UtilError.hpp:47

COMP
Definition: MixtureComp.hpp:107

COMP::MW
OCP_DBL MW
Molecular Weight.
Definition: MixtureComp.hpp:117

COMP::OmegaA
OCP_DBL OmegaA
Param A of Components.
Definition: MixtureComp.hpp:120

COMP::Vc
OCP_DBL Vc
VcMW * MW.
Definition: MixtureComp.hpp:119

COMP::VcMW
OCP_DBL VcMW
Critical Volume / MW.
Definition: MixtureComp.hpp:118

COMP::acf
OCP_DBL acf
Acentric Factor.
Definition: MixtureComp.hpp:116

COMP::Tc
OCP_DBL Tc
Critical Temperature.
Definition: MixtureComp.hpp:115

COMP::OmegaB
OCP_DBL OmegaB
Param B of Components.
Definition: MixtureComp.hpp:121

COMP::Vshift
OCP_DBL Vshift
shift volume
Definition: MixtureComp.hpp:122

COMP::Pc
OCP_DBL Pc
Critical Pressure.
Definition: MixtureComp.hpp:114

COMP::name
string name
Name of components.
Definition: MixtureComp.hpp:113

ComponentParam
ComponentParam contains information of components.
Definition: ParamReservoir.hpp:88

EoScontrol
Definition: MixtureComp.hpp:95

Miscible
Definition: PhasePermeability.hpp:28

MixtureComp
Definition: MixtureComp.hpp:126

MixtureComp::CalFtypeIMPEC
void CalFtypeIMPEC()
Calculate Flash type for IMPEC.
Definition: MixtureComp.hpp:568

MixtureComp::CalFtypeFIM
void CalFtypeFIM(const OCP_DBL *Sjin)
Calculate Flash type for FIM.
Definition: MixtureComp.hpp:570

MixtureComp::parachor
vector< OCP_DBL > parachor
Parachor params of hydrocarbon components.
Definition: MixtureComp.hpp:605

MixtureComp::skipMatSTA
vector< OCP_SIN > skipMatSTA
Definition: MixtureComp.hpp:583

MixtureComp::flagSkip
OCP_BOOL flagSkip
If ture, then skipping could be try,.
Definition: MixtureComp.hpp:581

MixtureComp::phiN
vector< OCP_DBL > phiN
d ln phi[i][j] / d n[k][j]
Definition: MixtureComp.hpp:582

MixtureComp::misTerm
Miscible * misTerm
Miscible term pointing to OptionalFeature.
Definition: MixtureComp.hpp:598

MixtureComp::skipSta
SkipStaAnaly * skipSta
Skip analysis Term pointing to OptionalFeature.
Definition: MixtureComp.hpp:576

MixtureComp::ifUseMiscible
OCP_BOOL ifUseMiscible
Definition: MixtureComp.hpp:600

MixtureComp::eigenWork
vector< OCP_SIN > eigenWork
work space for computing eigenvalues with ssyevd_
Definition: MixtureComp.hpp:587

MixtureComp::eigenSkip
vector< OCP_SIN > eigenSkip
eigen values of matrix for skipping Skip Stability Analysis.
Definition: MixtureComp.hpp:586

MixtureComp::PrintZtmp
void PrintZtmp()
test
Definition: MixtureComp.hpp:335

MixtureComp::surTen
OCP_DBL surTen
Surface tension between hydrocarbons phases.
Definition: MixtureComp.hpp:603

Mixture
Definition: Mixture.hpp:31

NRparamSP
Params for NR in Phase Split.
Definition: MixtureComp.hpp:72

NRparamSP::curIt
USI curIt
current Iters
Definition: MixtureComp.hpp:80

NRparamSP::tol2
OCP_DBL tol2
tol*tol
Definition: MixtureComp.hpp:76

NRparamSP::maxIt
USI maxIt
Max Iteration.
Definition: MixtureComp.hpp:74

NRparamSP::tol
OCP_DBL tol
Tolerance.
Definition: MixtureComp.hpp:75

NRparamSP::conflag
OCP_BOOL conflag
convergence flag, if converges, conflag = OCP_TRUE
Definition: MixtureComp.hpp:78

NRparamSP::realTol
OCP_DBL realTol
Real tol.
Definition: MixtureComp.hpp:77

NRparamSTA
Params for NR in Phase Stability Analysis.
Definition: MixtureComp.hpp:46

NRparamSTA::conflag
OCP_BOOL conflag
convergence flag, if converges, conflag = OCP_TRUE
Definition: MixtureComp.hpp:52

NRparamSTA::tol
OCP_DBL tol
Tolerance.
Definition: MixtureComp.hpp:49

NRparamSTA::realTol
OCP_DBL realTol
Real tol.
Definition: MixtureComp.hpp:51

NRparamSTA::curIt
USI curIt
current Iters
Definition: MixtureComp.hpp:54

NRparamSTA::maxIt
USI maxIt
Max Iteration.
Definition: MixtureComp.hpp:48

NRparamSTA::tol2
OCP_DBL tol2
tol*tol
Definition: MixtureComp.hpp:50

OCPTable
Definition: OCPTable.hpp:27

OptionalFeatures
Definition: OptionalFeatures.hpp:19

ParamReservoir
Definition: ParamReservoir.hpp:210

ParamReservoir::comsParam
ComponentParam comsParam
information for components
Definition: ParamReservoir.hpp:260

ParamReservoir::density
Type_A_r< OCP_DBL > density
Density of oil, water, gas in standard conditions.
Definition: ParamReservoir.hpp:245

ParamReservoir::gravity
Type_A_r< OCP_DBL > gravity
Gravity of oil, water, gas in standard conditions.
Definition: ParamReservoir.hpp:246

ParamReservoir::PVTW_T
TableSet PVTW_T
Table set of PVTW.
Definition: ParamReservoir.hpp:290

RRparam
Param for Solving Rachford-Rice Equations.
Definition: MixtureComp.hpp:85

RRparam::tol2
OCP_DBL tol2
tol*tol
Definition: MixtureComp.hpp:89

RRparam::maxIt
USI maxIt
Max Iteration.
Definition: MixtureComp.hpp:87

RRparam::curIt
USI curIt
current Iters
Definition: MixtureComp.hpp:91

RRparam::tol
OCP_DBL tol
Tolerance.
Definition: MixtureComp.hpp:88

SSMparamSP
Params for SSM in Phase Split.
Definition: MixtureComp.hpp:59

SSMparamSP::curIt
USI curIt
current Iters
Definition: MixtureComp.hpp:67

SSMparamSP::tol
OCP_DBL tol
Tolerance.
Definition: MixtureComp.hpp:62

SSMparamSP::conflag
OCP_BOOL conflag
convergence flag, if converges, conflag = OCP_TRUE
Definition: MixtureComp.hpp:65

SSMparamSP::tol2
OCP_DBL tol2
tol*tol
Definition: MixtureComp.hpp:63

SSMparamSP::realTol
OCP_DBL realTol
Real tol.
Definition: MixtureComp.hpp:64

SSMparamSP::maxIt
USI maxIt
Max Iteration.
Definition: MixtureComp.hpp:61

SSMparamSTA
Params for SSM in Phase Stability Analysis.
Definition: MixtureComp.hpp:29

SSMparamSTA::realTol
OCP_DBL realTol
Real tol.
Definition: MixtureComp.hpp:37

SSMparamSTA::curIt
USI curIt
current Iterations
Definition: MixtureComp.hpp:40

SSMparamSTA::tol2
OCP_DBL tol2
tol*tol
Definition: MixtureComp.hpp:36

SSMparamSTA::tol
OCP_DBL tol
Tolerance.
Definition: MixtureComp.hpp:32

SSMparamSTA::conflag
OCP_BOOL conflag
convergence flag, if converges, conflag = OCP_TRUE
Definition: MixtureComp.hpp:38

SSMparamSTA::maxIt
USI maxIt
Max Iteration.
Definition: MixtureComp.hpp:31

SkipStaAnaly
Definition: AcceleratePVT.hpp:26

TableSet::data
vector< vector< vector< OCP_DBL > > > data
All table with the same name.
Definition: ParamReservoir.hpp:37

Type_A_r::activity
OCP_BOOL activity
If OCP_FALSE, this param is not given.
Definition: ParamReservoir.hpp:82

Type_A_r::data
vector< T > data
Data of param.
Definition: ParamReservoir.hpp:83

WellOpt
Definition: WellOpt.hpp:27