pzmultiphase.h

Go to the documentation of this file.

//
//  pzmultiphase.h
//  PZ
//
//  Created by Omar Duran on 19/08/2013.
//  Copyright (c) 2012 LabMec-Unicamp. All rights reserved.
//

#ifndef PZ_pzmultiphase_h
#define PZ_pzmultiphase_h

#include "TPZMaterial.h"
#include "pzdiscgal.h"
#ifdef _AUTODIFF
#include "fad.h"
#endif
#include <iostream>
#include <fstream>
#include <string>

class TPZMultiphase : public TPZDiscontinuousGalerkin {
    
protected:
    
    int fDim;
    
    int fmatId; 
    
    REAL ff;
    
    REAL fxi;    
    
    enum EState { ELastState = 0, ECurrentState = 1 };
    EState gState;
    
#ifdef _AUTODIFF    
    
    typedef TFad<2, REAL> BFadREAL; 
    
#endif  
    
public:
    
    bool fnewWS;
    
    TPZMultiphase();
    
    TPZMultiphase(int matid, int dim);
    
    virtual ~TPZMultiphase();
    
    TPZMultiphase(const TPZMultiphase &copy);
    
    TPZMultiphase &operator=(const TPZMultiphase &copy);
    
    virtual void Print(std::ostream & out) override;
    
    virtual std::string Name()  override { return "TPZMultiphase"; }
    
    virtual int Dimension() const override;
    
    virtual int NStateVariables() const override;  
    
    virtual int MatId();
    
    
    virtual void Contribute(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ef) override;
    
    virtual void Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
    
    virtual void Contribute(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
    
    
    virtual void ContributeBC(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ef, TPZBndCond &bc) override;
    
    virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef, TPZBndCond &bc) override;
    
    virtual void ContributeBC(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override;
    
    
    virtual void ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
    
    virtual void ContributeInterface(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, TPZVec<TPZMaterialData> &dataright, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef) override;
    
    virtual void ContributeInterface(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, TPZVec<TPZMaterialData> &dataright, REAL weight, TPZFMatrix<STATE> &ef) override;
    
    virtual void ContributeInterface(TPZVec<TPZMaterialData> &datavec,TPZVec<TPZMaterialData> &dataleftvec,TPZVec<TPZMaterialData> &datarightvec,REAL weight,TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef) override;
    
    
    virtual void ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ef,TPZBndCond &bc) override;
    
    virtual void ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override;
    
    virtual void ContributeBCInterface(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleftvec, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef, TPZBndCond &bc) override;
    
    // Contribution for each state variable
    virtual void ApplyUxD       (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    virtual void ApplyUyD       (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    virtual void ApplySigmaN    (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    virtual void ApplyQnD       (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    virtual void ApplyPN        (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    virtual void ApplySin       (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    virtual void ApplySout      (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    virtual void ApplySin       (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    virtual void ApplySout      (TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, REAL weight, TPZFMatrix<STATE> &ef,TPZBndCond &bc);
    
    virtual void FillDataRequirements(TPZVec<TPZMaterialData > &datavec) override;
    
    virtual void FillBoundaryConditionDataRequirement(int type,TPZVec<TPZMaterialData > &datavec) override;
    
    
    virtual int VariableIndex(const std::string &name) override;
    
    virtual int NSolutionVariables(int var) override;
    
    virtual void Solution(TPZVec<TPZMaterialData> &datavec, int var, TPZVec<STATE> &Solout) override;
    
    
    virtual void Solution(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleftvec, TPZVec<TPZMaterialData> &datarightvec, int var, TPZVec<STATE> &Solout, TPZCompEl * Left, TPZCompEl * Right) override
    {
        TPZDiscontinuousGalerkin::Solution(data,dataleftvec,datarightvec,var,Solout,Left,Right);
    }
    
    
    // Here is needed to spefify which models are used in this bi-phasic model see Advanced-Petroleum-Reservoir-Simulation M. Rafiqul Islam
    
    REAL fLref; 
    
    REAL fKref;
    
    REAL fQref;    
    
    REAL fPref;
    
    REAL fRhoref;
    
    REAL fEtaref;
    
    
    TPZStack< TPZFMatrix<REAL> > fKabsoluteMap; 

    int fPlaneStress;
    
    bool fYorN;
    
    REAL fDeltaT;
    
    REAL fTime;
    
    REAL fTheta;
    
    REAL fGamma;    
    
    void SetXiBalance(REAL xi){ this->fxi = xi;}
        
    void SetTimeStep(REAL timestep){ this->fDeltaT = timestep;}
    
    void SetTime(REAL time){ this->fTime = time;}
    
    void SetTScheme(REAL timegamma, REAL timetheta){ this->fTheta = timetheta; this->fGamma = timegamma;}
    
    void SetLastState(){ gState = ELastState;}
    
    void SetCurrentState(){ gState = ECurrentState;}
    
    void SetYorN(bool dummybool){ this->fYorN = dummybool;}     
    
    STATE LameLambda();

    STATE LameLambdaU();
    
    STATE LameMu();

    STATE BiotAlpha();

    STATE Se();
    
    
    void SetKMap(TPZStack< TPZFMatrix<REAL> > KabsoluteMap)
    {
        fKabsoluteMap = KabsoluteMap;
    }   
    
    void CapillaryPressure(REAL So, REAL &pc, REAL &DpcDSo);
    
    void Kro(REAL Sw, REAL &Kro, REAL &dKroDSw);
    
    void Krw(REAL Sw, REAL &Krw, REAL &dKrwSo);
    
    void SWaterstar(REAL &Swstar, REAL &Po, REAL &Sw); 
    
    void fWaterstar(REAL &fWstar, REAL Pw, REAL Sw, REAL &dfWstarDPw, REAL &dfWstarDSw);

    void fOilstar(REAL &fOstar, REAL Pw, REAL Sw, REAL &dfOstarDPw, REAL &dfOstarDSw);    

    void fstar(REAL &fStar, REAL Pw, REAL Sw, REAL Gdotn, REAL &dfstarDPw, REAL &dfstarDSw);      
    
    void Porosity(REAL po, REAL &poros, REAL &dPorosDp);
    
    void RhoOil(REAL po, REAL &RhoOil, REAL &dRhoOilDpo);
    
    void RhoWater(REAL pw, REAL &RhoWater, REAL &dRhoWaterDpo);
    
    void OilViscosity(REAL po, REAL &OilViscosity, REAL &dOilViscosityDpo);
    
    void WaterViscosity(REAL po, REAL &WaterViscosity, REAL &dWaterViscosityDpo);
    
    void OilLabmda(REAL &OilLabmda, REAL Po, REAL Sw, REAL &dOilLabmdaDPo, REAL &dOilLabmdaDSw);
    
    void WaterLabmda(REAL &WaterLabmda, REAL Pw, REAL Sw, REAL &dWaterLabmdaDPw, REAL &dWaterLabmdaDSw);
    
    void Labmda(REAL &Labmda, REAL Pw, REAL Sw, REAL &dLabmdaDPw, REAL &dLabmdaDSw);
    
    void fOil(REAL &fOil, REAL Pw, REAL Sw, REAL &dfOilDPw, REAL &dfOilDSw);
    
    void fWater(REAL &fWater, REAL Pw, REAL Sw, REAL &dfWaterDPw, REAL &dfWaterDSw);
    
#ifdef _AUTODIFF    
    
    // Fad Methods ///////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void CapillaryPressure(BFadREAL So, BFadREAL &pc);  
    
    void Kro(BFadREAL Sw, BFadREAL &Kro);
    
    void Krw(BFadREAL Sw, BFadREAL &Krw);
    
    void Porosity(BFadREAL po, BFadREAL &poros);    
    
    void RhoOil(BFadREAL po, BFadREAL &RhoOil); 
    
    void RhoWater(BFadREAL pw, BFadREAL &RhoWater);     
    
    void OilViscosity(BFadREAL po, BFadREAL &OilViscosity); 
    
    void WaterViscosity(BFadREAL po, BFadREAL &WaterViscosity); 
    
    void OilLabmda(BFadREAL OilLabmda, BFadREAL Po, BFadREAL &Sw);  
    
    void WaterLabmda(BFadREAL WaterLabmda, BFadREAL Pw, BFadREAL &Sw);  
    
    
    void Labmda(BFadREAL Labmda, BFadREAL Pw, BFadREAL &Sw);    
    
    void fOil(BFadREAL fOil, BFadREAL Pw, BFadREAL &Sw);    
    
    
    void fWater(BFadREAL fWater, BFadREAL Pw, BFadREAL &Sw);        
    
#endif  
    
    // Fad Methods ///////////////////////////////////////////////////////////////////////////////////////////////////////  
    

    void SetLreference(REAL &Lref){ fLref = Lref;}
    
    void SetKreference(REAL &Kref){ fKref = Kref;}
    
    void SetPreference(REAL &Pref){ fPref = Pref;}
    
    void SetQreference(REAL &Qref){ fQref = Qref;}     
    
    void SetRhoSCreference(REAL &Densityref){ fRhoref = Densityref;}
    
    void SetEtaSCreference(REAL &Viscosityref){ fEtaref = Viscosityref;}
    
    REAL RhoOilSC();
    
    REAL RhoWaterSC();
    
    TPZFMatrix<REAL> Gravity();
    
    void K(TPZFMatrix<REAL> &Kab);
    
    TPZFMatrix<REAL>  Kinv(TPZFMatrix<REAL> &Kab);  
    
    void LoadKMap(std::string MaptoRead);   
    
    public:
virtual int ClassId() const override;

};

#endif