Reservoir.hpp

Go to the documentation of this file.

 
#ifndef __RESERVOIR_HEADER__
#define __RESERVOIR_HEADER__
 
// OpenCAEPoro header files
#include "Bulk.hpp"
#include "BulkConn.hpp"
#include "Grid.hpp"
#include "ParamRead.hpp"
#include "AllWells.hpp"
 
class Reservoir
{
    friend class OCPControl;
    friend class Summary;
    friend class CriticalInfo;
    friend class DetailInfo;
 
    // temp
    friend class OCP_IMPEC;
    friend class OCP_FIM;
    friend class OCP_AIMs;
    friend class OCP_AIMt;
    friend class OCP_AIMc;
    friend class Solver;
 
    // General
 
public:
    void InputParam(ParamRead& param);
    void Setup();
    void ApplyControl(const USI& i);
    void PrepareWell();
    void CalWellFlux();
    void CalWellTrans();
    void CalVpore();
    void CalKrPc();
    void CalMaxChange();
    void CalIPRT(const OCP_DBL& dt);
    OCP_INT CheckP(const bool& bulkCheck = true, const bool& wellCheck = true);
    bool CheckNi();
    bool CheckVe(const OCP_DBL& Vlim) const;
    OCP_USI GetBulkNum() const { return bulk.GetBulkNum(); }
    OCP_USI GetMaxFIMBulk() const { return bulk.GetMaxFIMBulk(); }
    USI GetWellNum() const { return allWells.GetWellNum(); }
    USI GetComNum() const { return bulk.GetComNum(); }
    void SetupWellBulk() { allWells.SetupWellBulk(bulk); }
    void GetNTQT(const OCP_DBL& dt);
 
private:
    Grid      grid;      
    Bulk      bulk;      
    AllWells  allWells; 
    BulkConn  conn;      
 
    // IMPEC
 
public:
    void AllocateAuxIMPEC();
    void InitIMPEC();
    OCP_DBL CalCFL(const OCP_DBL& dt);
    void CalFLuxIMPEC();
    void CalConnFluxIMPEC();
    void MassConseveIMPEC(const OCP_DBL& dt);
    void CalFlashIMPEC();
    void UpdateLastStepIMPEC();
    void AllocateMatIMPEC(LinearSystem& myLS) const;
    void AssembleMatIMPEC(LinearSystem& myLS, const OCP_DBL& dt) const;
    void GetSolutionIMPEC(const vector<OCP_DBL>& u);
    void ResetWellIMPEC();
    void ResetVal01IMPEC();
    void ResetVal02IMPEC();
    void ResetVal03IMPEC();
 
private:
 
    OCP_DBL cfl; 
 
public:
    // FIM
 
    void AllocateAuxFIM();
    void InitFIM();
    void InitFIM_n();
    void CalFlashDerivFIM();
    void CalFlashDerivFIM_n();
    void CalKrPcDerivFIM();
    void UpdateLastStepFIM();
    void AllocateMatFIM(LinearSystem& myLS) const;
    void AssembleMatFIM(LinearSystem& myLS, const OCP_DBL& dt) const;
    void AssembleMatFIM_n(LinearSystem& myLS, const OCP_DBL& dt) const;
    void GetSolutionFIM(const vector<OCP_DBL>& u, const OCP_DBL& dPmax,
                        const OCP_DBL& dSmax);
    void GetSolutionFIM_n(const vector<OCP_DBL>& u, const OCP_DBL& dPmax,
        const OCP_DBL& dSmax);
    void GetSolution01FIM(const vector<OCP_DBL>& u);
    void CalResFIM(ResFIM& resFIM, const OCP_DBL& dt);
    void ResetFIM(const bool& flag);
    OCP_DBL GetNRdPmax(){ return bulk.GetNRdPmax(); }
    OCP_DBL GetNRdSmax(OCP_USI& index) { return bulk.CalNRdSmax(index); }
    OCP_DBL GetNRdNmax() { return bulk.GetNRdNmax(); }
    OCP_DBL GetNRdSmaxP() { return bulk.GetNRdSmaxP(); }
    void    PrintSolFIM(const string& outfile) const;
    void    ShowRes(const vector<OCP_DBL>& res) const;
 
    // AIMs, AIMt
 
public:
    void AllocateAuxAIMt();
    void AllocateMatAIMt(LinearSystem& myLS) const;
    void SetupFIMBulk(const bool& NRflag = false) { conn.SetupFIMBulk(bulk, NRflag); }
    void AddFIMBulk() { conn.AddFIMBulk(bulk); }
    void SetupFIMBulkBoundAIMs() { conn.SetupFIMBulkBoundAIMs(bulk); }
    
    void CalFlashDerivAIM(const bool& IfAIMs);
    void CalKrPcDerivAIM(const bool& IfAIMs);
    void CalResAIMt(ResFIM& resFIM, const OCP_DBL& dt);
    void AssembleMatAIMt(LinearSystem& myLS, const OCP_DBL& dt) const;
    void GetSolutionAIMt(const vector<OCP_DBL>& u, const OCP_DBL& dPmax,
        const OCP_DBL& dSmax);
 
    void AllocateAuxAIMs();
    void CalResAIMs(ResFIM& resFIM, const OCP_DBL& dt);
    void AssembleMatAIMs(LinearSystem& myLS, vector<OCP_DBL>& res, const OCP_DBL& dt) const;
    void GetSolutionAIMs(const vector<OCP_DBL>& u, const OCP_DBL& dPmax,
        const OCP_DBL& dSmax);
    void ResetValAIM();
    OCP_DBL CalCFLAIM(const OCP_DBL& dt);
    void UpdateLastStepAIM();
 
    void AllocateAuxAIMc();
    void AssembleMatAIMc(LinearSystem& myLS, const OCP_DBL& dt) const;
    void CalResAIMc(ResFIM& resFIM, const OCP_DBL& dt);
    void CalFlashAIMc();
    void CalFlashAIMc01();
    void CalKrPcAIMc();
    void CalFlashDerivAIMc();
    void CalKrPcDerivAIMc();
    void GetSolutionAIMc(const vector<OCP_DBL>& u, const OCP_DBL& dPmax,
        const OCP_DBL& dSmax);
    void InitAIMc();
    void UpdatePj() { bulk.UpdatePj(); }
    
};
 
#endif /* end if __RESERVOIR_HEADER__ */
 
/*----------------------------------------------------------------------------*/
/*  Brief Change History of This File                                         */
/*----------------------------------------------------------------------------*/
/*  Author              Date             Actions                              */
/*----------------------------------------------------------------------------*/
/*  Shizhe Li           Oct/01/2021      Create file                          */
/*  Chensong Zhang      Oct/15/2021      Format file                          */
/*----------------------------------------------------------------------------*/