#include <Well.hpp>

Public Member Functions
void	InputPerfo (const WellParam &well)
	Input the param of perforations.

void	Setup (const Grid &gd, const Bulk &bk, const vector< SolventINJ > &sols)
	Setup the well after Grid and Bulk finish setup.

void	InitBHP (const Bulk &myBulk)
	Initialize the Well BHP.

void	CalWI_Peaceman (const Bulk &myBulk)
	Calculate Well Index with Peaceman model.

void	CalTrans (const Bulk &myBulk)
	Calculate transmissibility for each phase in perforations.

void	CalFlux (const Bulk &myBulk, const OCP_BOOL ReCalXi=OCP_FALSE)
	Calculate the flux for each perforations.

OCP_DBL	CalInjRateMaxBHP (const Bulk &myBulk)
	calculate flow rate of moles of phases for injection well with maxBHP. More...

OCP_DBL	CalProdRateMinBHP (const Bulk &myBulk)
	calculate flow rate of moles of phases for production well with minBHP. More...

void	CalInjQj (const Bulk &myBulk, const OCP_DBL &dt)

void	CalProdQj (const Bulk &myBulk, const OCP_DBL &dt)

void	CaldG (const Bulk &myBulk)
	Calculate pressure difference between well and perforations. More...

void	CalInjdG (const Bulk &myBulk)
	Calculate pressure difference between well and perforations for Injection.

void	CalProddG (const Bulk &myBulk)
	Calculate pressure difference between well and perforations for Production.

void	CalProddG01 (const Bulk &myBulk)
	Calculate pressure difference between well and perforations for Production.

void	CalProddG02 (const Bulk &myBulk)
	Calculate pressure difference between well and perforations for Production.

void	CalProdWeight (const Bulk &myBulk) const
	Calculate the production weight.

void	CalReInjFluid (const Bulk &myBulk, vector< OCP_DBL > &myZi)
	Calculate the contribution of production well to reinjection defaulted.

void	CorrectBHP ()
	Correct BHP if opt mode is BHPMode.

void	CheckOptMode (const Bulk &myBulk)
	Check if well operation mode would be changed. More...

OCP_INT	CheckP (const Bulk &myBulk)
	Check if abnormal Pressure occurs.

OCP_INT	CheckCrossFlow (const Bulk &myBulk)
	Check if cross flow happens.

void	CalPerfP ()
	Update pressure in Perforation after well pressure updates.

void	ShowPerfStatus (const Bulk &myBulk) const
	Display operation mode of well and state of perforations.

USI	PerfNum () const

void	SetBHP (const OCP_DBL &p)

OCP_DBL	BHP () const

OCP_DBL	DG (const USI &p) const

OCP_DBL	ProdWeight (const USI &i) const

USI	OptMode () const

OCP_BOOL	IsOpen () const
	Return the state of the well, Open or Close.

USI	WellType () const
	Return the type of well, Inj or Prod.

vector< OCP_DBL >	InjZi () const

OCP_DBL	InjZi (const USI &i) const

OCP_DBL	MaxRate () const

OCP_DBL	MaxBHP () const

OCP_DBL	MinBHP () const

OCP_DBL	InjTemp () const

OCP_BOOL	PerfState (const USI &p) const

USI	PerfLocation (const USI &p) const

OCP_DBL	PerfWI (const USI &p) const

OCP_DBL	PerfMultiplier (const USI &p) const

OCP_DBL	PerfTransInj (const USI &p) const

OCP_DBL	PerfXi (const USI &p) const

OCP_DBL	PerfTransj (const USI &p, const USI &j) const

OCP_DBL	PerfQi_lbmol (const USI &p, const USI &i) const

OCP_DBL	PerfProdQj_ft3 (const USI &p, const USI &j) const

OCP_DBL	PerfInjQt_ft3 (const USI &p) const

OCP_DBL	Qi_lbmol (const USI &i) const

OCP_BOOL	IfUseUnweight () const

void	AssembleMatReinjection_IMPEC (const Bulk &myBulk, LinearSystem &myLS, const OCP_DBL &dt, const vector< Well > &allWell, const vector< USI > &injId) const

void	AssembleMatReinjection_FIM (const Bulk &myBulk, LinearSystem &myLS, const OCP_DBL &dt, const vector< Well > &allWell, const vector< USI > &injId) const

void	SetPolyhedronWell (const Grid &myGrid, OCPpolyhedron &mypol)

Protected Attributes
string	name
	well name

string	group
	group well belongs to, it should be moved to opt if necessary!!!

USI	I
	I-index of the well header.

USI	J
	J-index of the well header.

OCP_DBL	depth
	reference depth of well.

WellOpt	opt
	well control parameters, contains current control parameters.

vector< WellOpt >	optSet

USI	numPerf
	num of perforations belonging to this well.

vector< Perforation >	perf
	information of perforation belonging to this well.

vector< Mixture * >	flashCal
	from bulks's flashCal

OCP_DBL	numPhase
	num of phases

OCP_DBL	numCom
	num of components

OCP_DBL	Psurf {PRESSURE_STD}
	Well surface Pressure, psia.

OCP_DBL	Tsurf {TEMPERATURE_STD}
	Well surface Temperature, F.

USI	wOId

OCP_DBL	bhp
	Well pressure in reference depth.

vector< OCP_DBL >	dG
	difference of pressure between well and perforation: numPerf.

OCP_DBL	lbhp
	Last BHP.

vector< OCP_DBL >	ldG
	Last dG.

vector< OCP_DBL >	qi_lbmol
	flow rate of moles of component inflowing/outflowing

vector< OCP_DBL >	prodRate
	flow rate of volume of phase outflowing

vector< OCP_DBL >	prodWeight
	maybe only a num is needed

OCP_DBL	WOPR {0}
	well oil production rate.

OCP_DBL	WOPT {0}
	well total oil production.

OCP_DBL	WGPR {0}
	well gas production rate.

OCP_DBL	WGPT {0}
	well total gas production.

OCP_DBL	WWPR {0}
	well water production rate.

OCP_DBL	WWPT {0}
	well total water production.

OCP_DBL	WGIR {0}
	well gas injection rate.

OCP_DBL	WGIT {0}
	well total gas injection.

OCP_DBL	WWIR {0}
	well water injection rate.

OCP_DBL	WWIT {0}
	well total water injection.

OCP_BOOL	ifUseUnweight {OCP_FALSE}

Friends
class	AllWells

class	Out4RPT

class	MyMetisTest

Detailed Description

Well class defines well, and any operations referred to wells are in it. Well connects to the bulks by perforations, which serve as source and sink. Due to practical difficulties in production, a good treatment for well is important, excellent treatment will make the flow rate in well more stable.

Definition at line 44 of file Well.hpp.

Member Function Documentation

◆ AssembleMatReinjection_FIM()

void Well::AssembleMatReinjection_FIM	(	const Bulk &	myBulk,
		LinearSystem &	myLS,
		const OCP_DBL &	dt,
		const vector< Well > &	allWell,
		const vector< USI > &	injId
	)		const

Assemble matrix for Reinjection Well, used in production well when injection well is under RATE control

Definition at line 1145 of file Well.cpp.

 {
     // find Open injection well under Rate control
     vector<OCP_USI> tarId;
     for (auto& w : injId) {
         if (allWell[w].IsOpen() && allWell[w].opt.optMode != BHP_MODE)
             tarId.push_back(allWell[w].wOId + myBulk.numBulk);
     }
  
     USI tlen = tarId.size();
     if (tlen > 0) {
         // All inj well has the same factor
         const OCP_DBL factor = allWell[injId[0]].opt.reInjFactor;
         const OCP_USI prodId = wOId + myBulk.numBulk;
  
         const USI ncol   = numCom + 1;
         const USI ncol2  = numPhase * numCom + numPhase;
         const USI bsize  = ncol * ncol;
         const USI bsize2 = ncol * ncol2;
  
         OCP_DBL xij, xi, mu, muP, xiP, dP, transIJ, tmp;
         OCP_USI n_np_j;
  
         vector<OCP_DBL> bmat(bsize, 0);
         vector<OCP_DBL> bmat2(bsize, 0);
         vector<OCP_DBL> tmpMat(bsize, 0);
         vector<OCP_DBL> dQdXpB(bsize, 0);
         vector<OCP_DBL> dQdXpW(bsize, 0);
         vector<OCP_DBL> dQdXsB(bsize2, 0);
  
         for (USI p = 0; p < numPerf; p++) {
             const OCP_USI n = perf[p].location;
             fill(dQdXpB.begin(), dQdXpB.end(), 0.0);
             fill(dQdXpW.begin(), dQdXpW.end(), 0.0);
             fill(dQdXsB.begin(), dQdXsB.end(), 0.0);
  
             for (USI j = 0; j < numPhase; j++) {
                 n_np_j = n * numPhase + j;
                 if (!myBulk.phaseExist[n_np_j]) continue;
  
                 dP  = myBulk.Pj[n_np_j] - bhp - dG[p];
                 xi  = myBulk.xi[n_np_j];
                 mu  = myBulk.mu[n_np_j];
                 muP = myBulk.muP[n_np_j];
                 xiP = myBulk.xiP[n_np_j];
  
                 for (USI i = 0; i < numCom; i++) {
                     xij = myBulk.xij[n_np_j * numCom + i];
                     // dQ / dP
                     transIJ = perf[p].transj[j] * xi * xij;
                     dQdXpB[(i + 1) * ncol] += transIJ * (1 - dP * muP / mu) +
                                               dP * perf[p].transj[j] * xij * xiP;
                     dQdXpW[(i + 1) * ncol] += -transIJ;
  
                     // dQ / dS
                     for (USI k = 0; k < numPhase; k++) {
                         tmp = CONV1 * perf[p].WI * perf[p].multiplier * dP / mu * xi *
                               xij * myBulk.dKr_dS[n_np_j * numPhase + k];
                         // capillary pressure
                         tmp += transIJ * myBulk.dPcj_dS[n_np_j * numPhase + k];
                         dQdXsB[(i + 1) * ncol2 + k] += tmp;
                     }
                     // dQ / dCij
                     for (USI k = 0; k < numCom; k++) {
                         tmp = dP * perf[p].transj[j] * xij *
                               (myBulk.xix[n_np_j * numCom + k] -
                                xi / mu * myBulk.mux[n_np_j * numCom + k]);
                         if (k == i) {
                             tmp += perf[p].transj[j] * xi * dP;
                         }
                         dQdXsB[(i + 1) * ncol2 + numPhase + j * numCom + k] += tmp;
                     }
                 }
             }
  
             // for Prod Well
             for (USI i = 0; i < numCom; i++) {
                 tmpMat[0] += dQdXpW[(i + 1) * ncol] * factor;
             }
  
             // for Perf(bulk) of Prod Well
             bmat = dQdXpB;
             DaABpbC(ncol, ncol, ncol2, 1, dQdXsB.data(), &myBulk.dSec_dPri[n * bsize2],
                     1, bmat.data());
             fill(bmat2.begin(), bmat2.end(), 0.0);
             for (USI i = 0; i < numCom; i++) {
                 // becareful '-' before factor
                 Daxpy(ncol, -factor, bmat.data() + (i + 1) * ncol, bmat2.data());
             }
  
             // Insert bulk val into equations in ascending order
             for (USI t = 0; t < tlen; t++) {
                 myLS.NewOffDiag(tarId[t], n, bmat2);
             }
         }
         // prod well
         for (USI t = 0; t < tlen; t++) {
             myLS.NewOffDiag(tarId[t], prodId, tmpMat);
         }
     }
 }

References bhp, BHP_MODE, CONV1, DaABpbC(), Daxpy(), dG, Bulk::dKr_dS, Bulk::dPcj_dS, Bulk::dSec_dPri, IsOpen(), Bulk::mu, Bulk::muP, Bulk::mux, LinearSystem::NewOffDiag(), Bulk::numBulk, numCom, numPerf, numPhase, opt, perf, Bulk::phaseExist, Bulk::Pj, wOId, Bulk::xi, Bulk::xij, Bulk::xiP, and Bulk::xix.

◆ AssembleMatReinjection_IMPEC()

void Well::AssembleMatReinjection_IMPEC	(	const Bulk &	myBulk,
		LinearSystem &	myLS,
		const OCP_DBL &	dt,
		const vector< Well > &	allWell,
		const vector< USI > &	injId
	)		const

Assemble matrix for Reinjection Well, used in production well when injection well is under RATE control

Definition at line 1096 of file Well.cpp.

 {
     // find Open injection well under Rate control
     vector<OCP_USI> tarId;
     for (auto& w : injId) {
         if (allWell[w].IsOpen() && allWell[w].opt.optMode != BHP_MODE)
             tarId.push_back(allWell[w].wOId + myBulk.numBulk);
     }
  
     USI tlen = tarId.size();
     if (tlen > 0) {
         // All inj well has the same factor
         const OCP_DBL factor = allWell[injId[0]].opt.reInjFactor * dt;
         const OCP_USI prodId = wOId + myBulk.numBulk;
         OCP_USI       n, bId;
         OCP_DBL       tmp, valb;
         OCP_DBL       valw = 0;
         OCP_DBL       rhsw = 0;
         for (USI p = 0; p < numPerf; p++) {
             n    = perf[p].location;
             valb = 0;
  
             for (USI j = 0; j < numPhase; j++) {
                 bId = n * numPhase + j;
                 if (myBulk.phaseExist[bId]) {
                     tmp = perf[p].transj[j] * myBulk.xi[bId];
                     valb += tmp;
                     rhsw += tmp * (myBulk.Pc[bId] - dG[p]);
                 }
             }
             valb *= factor;
             for (USI t = 0; t < tlen; t++) {
                 myLS.NewOffDiag(tarId[t], n, -valb);
             }
             valw += valb;
         }
         rhsw *= factor;
         // rhs and prod well
         for (USI t = 0; t < tlen; t++) {
             myLS.AddRhs(tarId[t], rhsw);
             myLS.NewOffDiag(tarId[t], prodId, valw);
         }
     }
 }

References LinearSystem::AddRhs(), BHP_MODE, dG, IsOpen(), LinearSystem::NewOffDiag(), Bulk::numBulk, numPerf, numPhase, opt, Bulk::Pc, perf, Bulk::phaseExist, wOId, and Bulk::xi.

◆ CaldG()

void Well::CaldG ( const Bulk & myBulk )

Calculate pressure difference between well and perforations.

It calculates pressure difference between perforations iteratively. This function can be used in both black oil model and compositional model. stability of this method shoule be tested.

Definition at line 357 of file Well.cpp.

 {
     OCP_FUNCNAME;
  
     if (opt.type == INJ)
         CalInjdG(myBulk);
     else
         CalProddG01(myBulk);
 }

References CalInjdG(), CalProddG01(), INJ, OCP_FUNCNAME, and opt.

◆ CalInjQj()

void Well::CalInjQj	(	const Bulk &	myBulk,
		const OCP_DBL &	dt
	)

Calculate flow rate of moles of phases for injection well with calculated qi_lbmol.

Definition at line 322 of file Well.cpp.

 {
     OCP_FUNCNAME;
  
     OCP_DBL qj = 0;
  
     for (USI i = 0; i < numCom; i++) {
         qj += qi_lbmol[i];
     }
     if (opt.fluidType == "WAT") {
         WWIR = -qj / opt.factorINJ;
         WWIT += WWIR * dt;
     } else {
         WGIR = -qj / opt.factorINJ; // Mscf or lbmol -> Mscf
         WGIT += WGIR * dt;
     }
 }

References numCom, OCP_FUNCNAME, opt, qi_lbmol, WGIR, WGIT, WWIR, and WWIT.

◆ CalInjRateMaxBHP()

OCP_DBL Well::CalInjRateMaxBHP ( const Bulk & myBulk )

calculate flow rate of moles of phases for injection well with maxBHP.

Pressure in injection well equals maximum ones in injection well, which is input by users. this function is used to check if operation mode of well shoubld be swtched.

Definition at line 263 of file Well.cpp.

 {
     OCP_FUNCNAME;
  
     OCP_DBL qj    = 0;
     OCP_DBL Pwell = opt.maxBHP;
  
     for (USI p = 0; p < numPerf; p++) {
  
         OCP_DBL Pperf = Pwell + dG[p];
         OCP_USI k     = perf[p].location;
  
         USI     pvtnum = myBulk.PVTNUM[k];
         OCP_DBL xi = myBulk.flashCal[pvtnum]->XiPhase(Pperf, opt.injTemp, &opt.injZi[0],
                                                       opt.injProdPhase);
  
         OCP_DBL dP = Pperf - myBulk.P[k];
         qj += perf[p].transINJ * xi * dP;
     }
     return qj;
 }

References dG, Bulk::flashCal, numPerf, OCP_FUNCNAME, opt, Bulk::P, perf, and Bulk::PVTNUM.

◆ CalProdQj()

void Well::CalProdQj	(	const Bulk &	myBulk,
		const OCP_DBL &	dt
	)

Calculate flow rate of moles of phases for production well with calculated qi_lbmol.

Definition at line 340 of file Well.cpp.

 {
  
     flashCal[0]->CalProdRate(Psurf, Tsurf, &qi_lbmol[0], prodRate);
     USI iter = 0;
     if (myBulk.oil) WOPR = prodRate[iter++];
     if (myBulk.gas) WGPR = prodRate[iter++];
     if (myBulk.water) WWPR = prodRate[iter++];
  
     WOPT += WOPR * dt;
     WGPT += WGPR * dt;
     WWPT += WWPR * dt;
 }

References flashCal, Bulk::gas, Bulk::oil, prodRate, Psurf, qi_lbmol, Tsurf, Bulk::water, WGPR, WGPT, WOPR, WOPT, WWPR, and WWPT.

◆ CalProdRateMinBHP()

OCP_DBL Well::CalProdRateMinBHP ( const Bulk & myBulk )

calculate flow rate of moles of phases for production well with minBHP.

Pressure in production well equals minial ones in production well, which is input by users. this function is used to check if operation mode of well shoubld be swtched.

Definition at line 288 of file Well.cpp.

 {
     OCP_FUNCNAME;
  
     OCP_DBL qj    = 0;
     OCP_DBL Pwell = opt.minBHP;
  
     vector<OCP_DBL> tmpQi_lbmol(numCom, 0);
     vector<OCP_DBL> tmpQj(numPhase, 0);
  
     for (USI p = 0; p < numPerf; p++) {
  
         OCP_DBL Pperf = Pwell + dG[p];
         OCP_USI k     = perf[p].location;
  
         for (USI j = 0; j < numPhase; j++) {
             OCP_USI id = k * numPhase + j;
             if (myBulk.phaseExist[id]) {
                 OCP_DBL dP   = myBulk.Pj[id] - Pperf;
                 OCP_DBL temp = perf[p].transj[j] * myBulk.xi[id] * dP;
                 for (USI i = 0; i < numCom; i++) {
                     tmpQi_lbmol[i] += myBulk.xij[id * numCom + i] * temp;
                 }
             }
         }
     }
     flashCal[0]->CalProdRate(Psurf, Tsurf, &tmpQi_lbmol[0], tmpQj);
     for (USI j = 0; j < numPhase; j++) {
         qj += tmpQj[j] * opt.prodPhaseWeight[j];
     }
  
     return qj;
 }

References dG, flashCal, numCom, numPerf, numPhase, OCP_FUNCNAME, opt, perf, Bulk::phaseExist, Bulk::Pj, Psurf, Tsurf, Bulk::xi, and Bulk::xij.

◆ CheckOptMode()

void Well::CheckOptMode ( const Bulk & myBulk )

Check if well operation mode would be changed.

Constant well pressure would be applied if flow rate is too large. Constant flow rate would be applied if well pressure is outranged.

Definition at line 893 of file Well.cpp.

 {
     OCP_FUNCNAME;
     if (opt.initOptMode == BHP_MODE) {
         if (opt.type == INJ) {
             OCP_DBL q = CalInjRateMaxBHP(myBulk);
             // for INJ well, maxRate has been switch to lbmols
             OCP_DBL tarRate = opt.maxRate;
             if (opt.reInj) {
                 if (opt.reInjPhase == GAS)
                     tarRate = WGIR;
                 else if (opt.reInjPhase == WATER)
                     tarRate = WWIR;
             }
             if (q > tarRate) {
                 opt.optMode = RATE_MODE;
             } else {
                 opt.optMode = BHP_MODE;
                 bhp         = opt.maxBHP;
             }
         } else {
             opt.optMode = BHP_MODE;
             bhp         = opt.minBHP;
         }
     } else {
         if (opt.type == INJ) {
             OCP_DBL q = CalInjRateMaxBHP(myBulk);
             // for INJ well, maxRate has been switch to lbmols
             OCP_DBL tarRate = opt.maxRate;
             if (opt.reInj) {
                 if (opt.reInjPhase == GAS)
                     tarRate = WGIR;
                 else if (opt.reInjPhase == WATER)
                     tarRate = WWIR;
             }
  
             if (q > tarRate) {
                 opt.optMode = opt.initOptMode;
             } else {
                 opt.optMode = BHP_MODE;
                 bhp         = opt.maxBHP;
             }
         } else {
             OCP_DBL q = CalProdRateMinBHP(myBulk);
             // cout << q << endl;
             if (q > opt.maxRate) {
                 opt.optMode = opt.initOptMode;
             } else {
                 opt.optMode = BHP_MODE;
                 bhp         = opt.minBHP;
             }
         }
     }
 }

References bhp, BHP_MODE, CalInjRateMaxBHP(), CalProdRateMinBHP(), GAS, INJ, OCP_FUNCNAME, opt, RATE_MODE, WATER, WGIR, and WWIR.

Member Data Documentation

◆ optSet

vector<WellOpt> Well::optSet

protected

well control parameters set, contains control parameters in all critical time.

Definition at line 76 of file Well.hpp.

◆ wOId

USI Well::wOId