ParamReservoir.hpp

Go to the documentation of this file.

 
#ifndef __PARAMRESERVOIR_HEADER__
#define __PARAMRESERVOIR_HEADER__
 
// Standard header files
#include <fstream>
#include <vector>
 
// OpenCAEPoro header files
#include "OCPConst.hpp"
#include "UtilInput.hpp"
 
using namespace std;
 
class TableSet
{
public:
    void DisplayTable() const; 
 
public:
    string                          name;    
    USI                             colNum;  
    vector<string>                  refName; 
    vector<OCP_DBL>                 refData; 
    vector<vector<vector<OCP_DBL>>> data;    
};
 
class Dimens
{
public:
    USI nx; 
    USI ny; 
    USI nz; 
};
 
class HLoss
{
public:
    OCP_BOOL ifHLoss{OCP_FALSE}; 
    OCP_DBL  obC;                
    OCP_DBL  obK;                
    OCP_DBL  ubC;                
    OCP_DBL  ubK;                
};
 
class RockParam
{
public:
    string   type{"LINEAR"}; 
    OCP_DBL  Pref{14.7};     
    OCP_DBL  Tref{60};       
    OCP_DBL  cp1{3.406E-6};  
    OCP_DBL  cp2{0};         
    OCP_DBL  ct{0};          
    OCP_DBL  cpt{0};         
    OCP_BOOL ConstRock{OCP_TRUE}; 
    OCP_DBL HCP1{35}; 
    OCP_DBL HCP2{0};  
};
 
template <typename T>
class Type_A_r
{
public:
    OCP_BOOL  activity{OCP_FALSE}; 
    vector<T> data;                
};
 
class ComponentParam
{
public:
    // Basic params
    void Init();
    void InputCOMPONENTS(ifstream& ifs, const string& keyword);
    Type_A_r<vector<OCP_DBL>>* FindPtr01(const string& varName);
    void InputRefPR(ifstream& ifs, const string& keyword);
    vector<OCP_DBL>* FindPtr02(const string& varName);
    void InputCNAMES(ifstream& ifs);
    void InputLBCCOEF(ifstream& ifs);
    void InputBIC(ifstream& ifs);
    void InputVISCTAB(ifstream& ifs);
    // Method params
    void InputSSMSTA(ifstream& ifs);
    void InputNRSTA(ifstream& ifs);
    void InputSSMSP(ifstream& ifs);
    void InputNRSP(ifstream& ifs);
    void InputRR(ifstream& ifs);
 
public:
    USI            NTPVT{1};       
    USI            numCom{0};      
    USI            numPhase{2};    
    vector<string> Cname;          
    Type_A_r<vector<OCP_DBL>> Tc;  
    Type_A_r<vector<OCP_DBL>> Pc;  
    Type_A_r<vector<OCP_DBL>> Vc;  
    Type_A_r<vector<OCP_DBL>> Zc;  
    Type_A_r<vector<OCP_DBL>> MW;  
    Type_A_r<vector<OCP_DBL>> Acf; 
    Type_A_r<vector<OCP_DBL>> OmegaA;   
    Type_A_r<vector<OCP_DBL>> OmegaB;   
    Type_A_r<vector<OCP_DBL>> Vshift;   
    Type_A_r<vector<OCP_DBL>> Parachor; 
    // for viscosity calculation
    Type_A_r<vector<OCP_DBL>>
        Vcvis; 
    Type_A_r<vector<OCP_DBL>>
                    Zcvis; 
    vector<OCP_DBL> LBCcoef;     
    vector<vector<OCP_DBL>> BIC; 
    // ifThermal only
    Type_A_r<vector<OCP_DBL>> molden; 
    Type_A_r<vector<OCP_DBL>> cp;     
    Type_A_r<vector<OCP_DBL>> ct1;  
    Type_A_r<vector<OCP_DBL>> ct2;  
    Type_A_r<vector<OCP_DBL>> cpt;  
    Type_A_r<vector<OCP_DBL>> cpl1; 
    Type_A_r<vector<OCP_DBL>> cpl2; 
    Type_A_r<vector<OCP_DBL>> cpl3; 
    Type_A_r<vector<OCP_DBL>> cpl4; 
    Type_A_r<vector<OCP_DBL>> cpg1; 
    Type_A_r<vector<OCP_DBL>> cpg2; 
    Type_A_r<vector<OCP_DBL>> cpg3; 
    Type_A_r<vector<OCP_DBL>> cpg4; 
    Type_A_r<vector<OCP_DBL>>
        hvapr; 
    Type_A_r<vector<OCP_DBL>>
        hvr; 
    Type_A_r<vector<OCP_DBL>>
        ev; 
    Type_A_r<vector<OCP_DBL>>
        avisc; 
    Type_A_r<vector<OCP_DBL>>
        bvisc; 
    Type_A_r<vector<OCP_DBL>>
        avg; 
    Type_A_r<vector<OCP_DBL>>
        bvg; 
    TableSet viscTab;
 
    vector<OCP_DBL> Pref; 
    vector<OCP_DBL> Tref; 
 
    // Miscibility
    OCP_BOOL miscible{OCP_FALSE}; 
 
    vector<string> SSMparamSTA; 
    vector<string> NRparamSTA;  
    vector<string> SSMparamSP;  
    vector<string> NRparamSP;   
    vector<string> RRparam;     
};
 
class Miscstr
{
public:
    vector<OCP_DBL> surTenRef;
    // 0th entry: reference surface tension - flow is immiscible when the surface
    // tension is greater than or equal to this value. 1th entry: maximum surface
    // tension expected, it should be greater than surTenRef. 2th entry: maximum surface
    // tension used to scale the input capillary pressure curves.
};
 
class ParamReservoir
{
 
public:
    // Grid
    // Cartesian
    Dimens  dimens;  
    OCP_USI numGrid; 
    vector<OCP_DBL> tops; 
    vector<OCP_DBL> dx;   
    vector<OCP_DBL> dy;   
    vector<OCP_DBL> dz;   
 
    // Corner point geometry
    vector<OCP_DBL> coord; 
    vector<OCP_DBL> zcorn; 
 
    // RockParam
    vector<OCP_DBL>   ntg;     
    vector<OCP_DBL>   poro;    
    vector<OCP_DBL>   permX;   
    vector<OCP_DBL>   permY;   
    vector<OCP_DBL>   permZ;   
    vector<OCP_DBL>   thconr;  
    OCP_DBL           rsTemp;  
    vector<RockParam> rockSet; 
    HLoss             hLoss;   
    Miscstr           miscstr; 
 
    // If P and Ni are given, then calculation of initial equilibration is unneeded.
    vector<OCP_DBL> P;    
    vector<OCP_DBL> Ni;   
    vector<OCP_DBL> Swat; 
    OCP_BOOL        ScalePcow{OCP_FALSE}; 
 
    // phase property
    Type_A_r<OCP_DBL> density; 
    Type_A_r<OCP_DBL> gravity; 
    OCP_DBL           thcono{24}; 
    OCP_DBL           thcong{24}; 
    OCP_DBL           thconw{24}; 
 
    // Models
    OCP_BOOL blackOil{OCP_FALSE}; 
    OCP_BOOL comps{OCP_FALSE};    
    OCP_BOOL thermal{OCP_FALSE};  
    OCP_BOOL oil{OCP_FALSE};      
    OCP_BOOL gas{OCP_FALSE};      
    OCP_BOOL water{OCP_FALSE};    
    OCP_BOOL disGas{OCP_FALSE}; 
 
    ComponentParam comsParam; 
 
    // SAT Region & PVT Region
    USI               NTSFUN{1}; 
    USI               NTPVT{1};  
    USI               NTROOC{1}; 
    Type_A_r<OCP_DBL> SATNUM;    
    Type_A_r<OCP_DBL> PVTNUM;    
    Type_A_r<OCP_DBL> ACTNUM;    
    Type_A_r<OCP_DBL> ROCKNUM;   
 
    // Saturation tables & bubble point pressure
    TableSet SWFN_T; 
    TableSet SWOF_T; 
    TableSet SGFN_T; 
    TableSet SGOF_T; 
    TableSet SOF3_T; 
    TableSet PBVD_T; 
    // initial zi vs depth
    TableSet        ZMFVD_T;  
    TableSet        TEMPVD_T; 
    vector<OCP_DBL> EQUIL;    
 
    // PVT properties
    USI numPhase; 
    USI numCom; 
    TableSet PVCO_T; 
    TableSet PVDO_T; 
    TableSet PVDG_T; 
    TableSet PVTW_T; 
 
    vector<OCP_DBL>* FindPtr(const string& varName);
 
    TableSet* FindPtr_T(const string& varName);
 
    void Init();
 
    void InitTable();
 
    template <typename T>
    void setVal(vector<T>& obj, const T& val, const vector<USI>& index);
 
    template <typename T>
    void CopyVal(vector<T>& obj, const vector<T>& src, const vector<USI>& index);
 
    void
    MultiplyVal(vector<OCP_DBL>& obj, const OCP_DBL& val, const vector<USI>& index);
 
    void InputCOMPS(ifstream& ifs);
 
    void InputDIMENS(ifstream& ifs);
 
    void DisplayDIMENS();
 
    void InputRTEMP(ifstream& ifs);
 
    void InputEQUALS(ifstream& ifs);
 
    void InputGRID(ifstream& ifs, string& keyword);
 
    void InputCOPY(ifstream& ifs);
 
    void InputMULTIPLY(ifstream& ifs);
 
    void InputTABLE(ifstream& ifs, const string& tabName);
 
    void InputROCK(ifstream& ifs);
    void InputROCKT(ifstream& ifs);
    void InputHLOSS(ifstream& ifs);
 
    void InputMISCSTR(ifstream& ifs);
 
    void InputGRAVITY(ifstream& ifs);
 
    void InputDENSITY(ifstream& ifs);
 
    void InputTHCON(ifstream& ifs, const string& keyword);
 
    void InputEQUIL(ifstream& ifs);
 
    // SATNUM & PVTNUM  -- Region
    void InputTABDIMS(ifstream& ifs);
 
    void InputRegion(ifstream& ifs, const string& keyword);
 
    // Input ComponentParam
    // Basic params
    void InputCNAMES(ifstream& ifs) { comsParam.InputCNAMES(ifs); };
    void InputCOMPONENTS(ifstream& ifs, const string& keyword)
    {
        comsParam.InputCOMPONENTS(ifs, keyword);
    }
    void InputLBCCOEF(ifstream& ifs) { comsParam.InputLBCCOEF(ifs); }
    void InputBIC(ifstream& ifs) { comsParam.InputBIC(ifs); };
    void InputVISCTAB(ifstream& ifs) { comsParam.InputVISCTAB(ifs); }
    void InputRefPR(ifstream& ifs, const string& keyword)
    {
        comsParam.InputRefPR(ifs, keyword);
    };
 
    // Method params
    void InputSSMSTA(ifstream& ifs) { comsParam.InputSSMSTA(ifs); };
    void InputNRSTA(ifstream& ifs) { comsParam.InputNRSTA(ifs); };
    void InputSSMSP(ifstream& ifs) { comsParam.InputSSMSP(ifs); };
    void InputNRSP(ifstream& ifs) { comsParam.InputNRSP(ifs); };
    void InputRR(ifstream& ifs) { comsParam.InputRR(ifs); };
 
    // check
    void CheckParam();
 
    void CheckGrid();
 
    void CheckRock();
 
    void CheckEQUIL() const;
 
    void CheckDenGra() const;
 
    void CheckPhase() const;
 
    void CheckPhaseTab() const;
 
    void CheckRegion() const;
 
    void CheckEqlRegion() const;
};
 
#endif /* end if __PARAMRESERVOIR_HEADER__ */
 
/*----------------------------------------------------------------------------*/
/*  Brief Change History of This File                                         */
/*----------------------------------------------------------------------------*/
/*  Author              Date             Actions                              */
/*----------------------------------------------------------------------------*/
/*  Shizhe Li           Oct/01/2021      Create file                          */
/*  Chensong Zhang      Oct/15/2021      Format file                          */
/*  Chensong Zhang      Jan/09/2022      Update Doxygen                       */
/*----------------------------------------------------------------------------*/