Well.hpp

Go to the documentation of this file.

 
#ifndef __WELL_HEADER__
#define __WELL_HEADER__
 
// Standard header files
#include <cassert>
 
// OpenCAEPoro header files
#include "Bulk.hpp"
#include "DenseMat.hpp"
#include "Grid.hpp"
#include "LinearSystem.hpp"
#include "OCPConst.hpp"
#include "OCPStructure.hpp"
#include "ParamWell.hpp"
#include "WellOpt.hpp"
#include "WellPerf.hpp"
 
using namespace std;
 
// General Well Error Type
 
const int WELL_SUCCESS           = 10;
const int WELL_NEGATIVE_PRESSURE = -11;
const int WELL_SWITCH_TO_BHPMODE = -12;
const int WELL_CROSSFLOW         = -13;
 
class Well
{
    friend class AllWells;
    friend class Out4RPT;
 
    // temp
    friend class MyMetisTest;
 
public:
    Well() = default;
 
    // Input Param and Setup
 
public:
    void InputPerfo(const WellParam& well);
    void Setup(const Grid& gd, const Bulk& bk, const vector<SolventINJ>& sols);
 
    // Basic Well information
 
protected:
    string  name;  
    string  group; 
    USI     I;     
    USI     J;     
    OCP_DBL depth; 
    WellOpt opt;   
    vector<WellOpt> optSet;      
    USI                 numPerf; 
    vector<Perforation> perf;    
 
    vector<Mixture*> flashCal; 
 
    OCP_DBL numPhase; 
    OCP_DBL numCom;   
 
    OCP_DBL Psurf{PRESSURE_STD};    
    OCP_DBL Tsurf{TEMPERATURE_STD}; 
 
    USI wOId; 
 
public:
    void InitBHP(const Bulk& myBulk) { bhp = myBulk.P[perf[0].location]; }
    void CalWI_Peaceman(const Bulk& myBulk);
    void CalTrans(const Bulk& myBulk);
    void CalFlux(const Bulk& myBulk, const OCP_BOOL ReCalXi = OCP_FALSE);
    OCP_DBL CalInjRateMaxBHP(const Bulk& myBulk);
    OCP_DBL CalProdRateMinBHP(const Bulk& myBulk);
    void CalInjQj(const Bulk& myBulk, const OCP_DBL& dt);
    void CalProdQj(const Bulk& myBulk, const OCP_DBL& dt);
    void CaldG(const Bulk& myBulk);
    void CalInjdG(const Bulk& myBulk);
    void CalProddG(const Bulk& myBulk);
    void CalProddG01(const Bulk& myBulk);
    void CalProddG02(const Bulk& myBulk);
    void CalProdWeight(const Bulk& myBulk) const;
    void CalReInjFluid(const Bulk& myBulk, vector<OCP_DBL>& myZi);
    void CorrectBHP();
    void CheckOptMode(const Bulk& myBulk);
    OCP_INT CheckP(const Bulk& myBulk);
    OCP_INT CheckCrossFlow(const Bulk& myBulk);
    void CalPerfP()
    {
        for (USI p = 0; p < numPerf; p++) perf[p].P = bhp + dG[p];
    }
    void ShowPerfStatus(const Bulk& myBulk) const;
 
    USI     PerfNum() const { return numPerf; }
    void    SetBHP(const OCP_DBL& p) { bhp = p; }
    OCP_DBL BHP() const { return bhp; }
    OCP_DBL DG(const USI& p) const { return dG[p]; }
    OCP_DBL ProdWeight(const USI& i) const { return prodWeight[i]; }
 
    USI OptMode() const { return opt.optMode; }
    OCP_BOOL IsOpen() const { return opt.state; }
    USI             WellType() const { return opt.type; }
    vector<OCP_DBL> InjZi() const
    {
        OCP_ASSERT(opt.type == INJ, "Wrong Call");
        return opt.injZi;
    }
    OCP_DBL InjZi(const USI& i) const
    {
        OCP_ASSERT(opt.type == INJ, "Wrong Call");
        return opt.injZi[i];
    }
    OCP_DBL MaxRate() const { return opt.maxRate; }
    OCP_DBL MaxBHP() const
    {
        OCP_ASSERT(opt.type == INJ, "Wrong Call");
        return opt.maxBHP;
    }
    OCP_DBL MinBHP() const
    {
        OCP_ASSERT(opt.type == PROD, "Wrong Call");
        return opt.minBHP;
    }
    OCP_DBL InjTemp() const
    {
        OCP_ASSERT(opt.type == INJ, "Wrong Call");
        return opt.injTemp;
    }
 
    OCP_BOOL PerfState(const USI& p) const { return perf[p].state; }
    USI      PerfLocation(const USI& p) const { return perf[p].location; }
    OCP_DBL  PerfWI(const USI& p) const { return perf[p].WI; }
    OCP_DBL  PerfMultiplier(const USI& p) const { return perf[p].multiplier; }
    OCP_DBL  PerfTransInj(const USI& p) const { return perf[p].transINJ; }
    OCP_DBL  PerfXi(const USI& p) const { return perf[p].xi; }
    OCP_DBL  PerfTransj(const USI& p, const USI& j) const { return perf[p].transj[j]; }
    OCP_DBL  PerfQi_lbmol(const USI& p, const USI& i) const
    {
        return perf[p].qi_lbmol[i];
    }
    OCP_DBL PerfProdQj_ft3(const USI& p, const USI& j) const
    {
        OCP_ASSERT(opt.type == PROD, "Wrong Call");
        return perf[p].qj_ft3[j];
    }
    OCP_DBL PerfInjQt_ft3(const USI& p) const
    {
        OCP_ASSERT(opt.type == INJ, "Wrong Call");
        return perf[p].qt_ft3;
    }
    OCP_DBL  Qi_lbmol(const USI& i) const { return qi_lbmol[i]; }
    OCP_BOOL IfUseUnweight() const { return ifUseUnweight; }
 
protected:
    // Well Physical information
 
    mutable OCP_DBL bhp; 
    vector<OCP_DBL>
        dG; 
 
    // Last time step
    OCP_DBL         lbhp; 
    vector<OCP_DBL> ldG;  
 
    // PROD/INJ Rate
    vector<OCP_DBL> qi_lbmol; 
    vector<OCP_DBL> prodRate; 
    mutable vector<OCP_DBL> prodWeight; 
 
    OCP_DBL WOPR{0}; 
    OCP_DBL WOPT{0}; 
    OCP_DBL WGPR{0}; 
    OCP_DBL WGPT{0}; 
    OCP_DBL WWPR{0}; 
    OCP_DBL WWPT{0}; 
    OCP_DBL WGIR{0}; 
    OCP_DBL WGIT{0}; 
    OCP_DBL WWIR{0}; 
    OCP_DBL WWIT{0}; 
 
    OCP_BOOL ifUseUnweight{OCP_FALSE};
    // IMPEC
 
public:
    void AssembleMatReinjection_IMPEC(const Bulk&         myBulk,
                                      LinearSystem&       myLS,
                                      const OCP_DBL&      dt,
                                      const vector<Well>& allWell,
                                      const vector<USI>&  injId) const;
 
    // FIM
 
public:
    void AssembleMatReinjection_FIM(const Bulk&         myBulk,
                                    LinearSystem&       myLS,
                                    const OCP_DBL&      dt,
                                    const vector<Well>& allWell,
                                    const vector<USI>&  injId) const;
 
    // for output
    void SetPolyhedronWell(const Grid& myGrid, OCPpolyhedron& mypol);
};
 
#endif /* end if __WELL_HEADER__ */
 
/*----------------------------------------------------------------------------*/
/*  Brief Change History of This File                                         */
/*----------------------------------------------------------------------------*/
/*  Author              Date             Actions                              */
/*----------------------------------------------------------------------------*/
/*  Shizhe Li           Oct/01/2021      Create file                          */
/*  Chensong Zhang      Oct/15/2021      Format file                          */
/*----------------------------------------------------------------------------*/