Mixture.hpp

Go to the documentation of this file.

 
#ifndef __MIXTURE_HEADER__
#define __MIXTURE_HEADER__
 
// Standard header files
#include <iostream>
#include <vector>
 
// OpenCAEPoro header files
#include "OCPConst.hpp"
#include "ParamReservoir.hpp"
 
using namespace std;
 
class Mixture
{
    friend class Bulk;
    friend class Well;
    friend class AllWells;
 
public:
    Mixture() = default;
    virtual ~Mixture(){};
    void Allocate()
    {
        Ni.resize(numCom);
        phaseExist.resize(numPhase);
        v.resize(numPhase);
        S.resize(numPhase);      
        xi.resize(numPhase);
        nj.resize(numPhase);
        xij.resize(numPhase * numCom);
        rho.resize(numPhase);
        mu.resize(numPhase);
        vfi.resize(numCom);
        vji.resize(numPhase);
        for (auto& v : vji) {
            v.resize(numCom, 0);
        }
        vjp.resize(numPhase, 0);
        // Derivatives for FIM
        rhoP.resize(numPhase);
        xiP.resize(numPhase);
        muP.resize(numPhase);
        rhoN.resize(numPhase * numCom);
        xiN.resize(numPhase * numCom);
        muN.resize(numPhase * numCom);
        rhox.resize(numPhase * numCom);
        xix.resize(numPhase * numCom);
        mux.resize(numPhase * numCom);
        dXsdXp.resize((numCom + 1) * (numPhase + numPhase * numCom));
        pEnumCom.resize(numPhase);
        res.resize(numPhase + numPhase * numCom + 1); // a precomputed value stored in last position
        // water not in hydrocarbon, hydrocarbon not in water
        keyDer.resize((numCom + 1) * ((numPhase - 1) * (numCom - 1) + 1));
        
    };
    virtual void SetPVTW(){};
    USI GetType() const { return mixtureType; }
    virtual bool IsEmpty_PVDG() const { return true; };
    virtual void InitFlash(const OCP_DBL& Pin, const OCP_DBL& Pbbin, const OCP_DBL& Tin,
                          const OCP_DBL* Sjin, const OCP_DBL& Vpore,
                          const OCP_DBL* Ziin) = 0;
    virtual void InitFlashDer(const OCP_DBL& Pin, const OCP_DBL& Pbbin,
                              const OCP_DBL& Tin, const OCP_DBL* Sjin,
                              const OCP_DBL& Vpore, const OCP_DBL* Ziin) = 0;
    virtual void InitFlashDer_n(const OCP_DBL& Pin, const OCP_DBL& Pbbin,
                              const OCP_DBL& Tin, const OCP_DBL* Sjin,
                              const OCP_DBL& Vpore, const OCP_DBL* Ziin) = 0;
    virtual void Flash(const OCP_DBL& Pin, const OCP_DBL& Tin,
        const OCP_DBL* Niin, const USI& ftype, const USI& lastNP,
        const OCP_DBL* lastKs) = 0;
    virtual void FlashDeriv(const OCP_DBL& Pin, const OCP_DBL& Tin,
        const OCP_DBL* Niin, const USI& ftype, const USI& lastNP,
        const OCP_DBL* lastKs) = 0;
    virtual void FlashDeriv_n(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& ftype, const USI* phaseExistin, 
        const USI& lastNP, const OCP_DBL* lastKs) = 0;
    virtual OCP_DBL XiPhase(const OCP_DBL& Pin, const OCP_DBL& Tin,
                            const OCP_DBL* Ziin) = 0;
 
    virtual OCP_DBL RhoPhase(const OCP_DBL& Pin, const OCP_DBL& Tin,
                             const OCP_DBL* Ziin) = 0;
 
    virtual OCP_DBL GammaPhaseO(const OCP_DBL& Pin, const OCP_DBL& Pbbin) = 0;
    virtual OCP_DBL GammaPhaseW(const OCP_DBL& Pin) = 0;
    virtual OCP_DBL GammaPhaseG(const OCP_DBL& Pin) = 0;
    virtual OCP_DBL GammaPhaseOG(const OCP_DBL& Pin, const OCP_DBL& Tin,
                                 const OCP_DBL* Ziin) = 0;
 
    void CheckNi(const OCP_DBL* Ni)
    {
        bool flag = true;
        for (USI i = 0; i < numCom; i++) {
            if (Ni[i] < 0) {
                cout << "Ni[" << i << "] = " << Ni[i] << endl;
                flag = false;
                break; // skip the rest checks
            }
        }
        if (!flag) OCP_ABORT("Ni is negative!");
    }
    // used in Compositional Model
    virtual USI GetFtype() = 0;
    virtual OCP_SIN GetMinEigenSkip() = 0;
    virtual bool GetFlagSkip() = 0; 
    virtual OCP_DBL GetSurTen() = 0;
 
    virtual OCP_DBL GetErrorPEC() = 0;
    virtual OCP_ULL GetSSMSTAiters() = 0;
    virtual OCP_ULL GetNRSTAiters() = 0;
    virtual OCP_ULL GetSSMSPiters() = 0; 
    virtual OCP_ULL GetNRSPiters() = 0;
    virtual OCP_ULL GetRRiters() = 0;
    virtual OCP_ULL GetSSMSTAcounts() = 0;
    virtual OCP_ULL GetNRSTAcounts() = 0;
    virtual OCP_ULL GetSSMSPcounts() = 0;
    virtual OCP_ULL GetNRSPcounts() = 0;
    virtual OCP_ULL GetRRcounts() = 0;
 
protected:
    USI mixtureType; 
 
    USI     numPhase; 
    USI     numCom;   
    OCP_DBL P;        
    OCP_DBL T;        
 
    vector<OCP_DBL> Ni;         
    vector<bool>    phaseExist; 
    vector<OCP_DBL> S;          
    vector<OCP_DBL> rho;        
    vector<OCP_DBL> xi;         
    vector<OCP_DBL> xij; 
    vector<OCP_DBL> nj;  
    vector<OCP_DBL> mu;  
    vector<OCP_DBL> v;   
 
    OCP_DBL vf; 
    OCP_DBL Nt; 
 
    // Derivatives
 
    vector<vector<OCP_DBL>> vji; 
    vector<OCP_DBL> vjp; 
 
    OCP_DBL vfp; 
    vector<OCP_DBL> vfi; 
 
    vector<OCP_DBL> muP;  
    vector<OCP_DBL> xiP;  
    vector<OCP_DBL> rhoP; 
    vector<OCP_DBL> muN;  
    vector<OCP_DBL> xiN;  
    vector<OCP_DBL> rhoN; 
    vector<OCP_DBL> mux;  
    vector<OCP_DBL> xix;  
    vector<OCP_DBL> rhox; 
 
    vector<OCP_DBL> dXsdXp; 
    vector<USI>     pEnumCom; 
    vector<OCP_DBL> res;     
    OCP_DBL         resPc;    
    
    vector<OCP_DBL> keyDer; 
};
 
#endif /* end if __MIXTURE_HEADER__ */
 
/*----------------------------------------------------------------------------*/
/*  Brief Change History of This File                                         */
/*----------------------------------------------------------------------------*/
/*  Author              Date             Actions                              */
/*----------------------------------------------------------------------------*/
/*  Shizhe Li           Oct/01/2021      Create file                          */
/*  Chensong Zhang      Oct/15/2021      Format file                          */
/*----------------------------------------------------------------------------*/