pzpoisson3d.h

Go to the documentation of this file.

#ifndef MATPOISSON3DH
#define MATPOISSON3DH

#include <iostream>
#include "pzdiscgal.h"
#include "pzfmatrix.h"


#ifdef _AUTODIFF
#include "fadType.h"
#endif


class TPZMatPoisson3d : public TPZDiscontinuousGalerkin {
                
                protected :
                
                STATE fXf;
                
                int fDim;
                
                STATE fK;
                                
                REAL fC;
                
                REAL fConvDir[3];
                
                REAL fSymmetry;
                
                STATE fSD;
                
                enum EPenaltyType {ENoPenalty = 0, EFluxPenalty = 1, ESolutionPenalty, EBoth};
                
                EPenaltyType fPenaltyType;
    
    bool fShapeHdiv;
   
                
public:
                
                REAL fPenaltyConstant;
                
                void SetNoPenalty(){ this->fPenaltyType = ENoPenalty;}
                
                void SetFluxPenalty(){ this->fPenaltyType = EFluxPenalty; }
                
                void SetSolutionPenalty(){ this->fPenaltyType = ESolutionPenalty; }
                
                void SetBothPenalty(){ this->fPenaltyType = EBoth; }
                
                static STATE gAlfa;
     bool fNeumann;
                
                TPZMatPoisson3d(int nummat, int dim);
    
    TPZMatPoisson3d(int matid) : TPZRegisterClassId(&TPZMatPoisson3d::ClassId),
    TPZDiscontinuousGalerkin(matid), fXf(0.), fDim(-1), fK(0.), fC(0.), fSymmetry(0.), fSD(0.)
        ,fPenaltyType(ENoPenalty)
    {
    
    }
                
                TPZMatPoisson3d();
                
                TPZMatPoisson3d(const TPZMatPoisson3d &copy);
                
                virtual ~TPZMatPoisson3d();
                
                TPZMatPoisson3d &operator=(const TPZMatPoisson3d &copy);
                
                void SetSymmetric(){
                                this->fSymmetry = -1.0;
                }
    void SetTrueFShapeHdiv(){
        fShapeHdiv=true;
    }
    
    void SetNeumannProblem(){
        fNeumann=true;
    }
    
                
                void SetNonSymmetric() {
                                this->fSymmetry = +1.0;
                }
                
                bool IsSymetric(){
                                if (fSymmetry == -1.0) return true;
                                if (fSymmetry == +1.0) return false;
                                PZError << __PRETTY_FUNCTION__ << "\n Comparacao de numeros reais da errado\n";
                                return false;
                }
                
                virtual TPZMaterial * NewMaterial() override {
                                return new TPZMatPoisson3d(*this);
                }
    
    virtual void FillDataRequirements(TPZMaterialData &data) override
    {
        data.SetAllRequirements(false);
    }
                    
    virtual void FillBoundaryConditionDataRequirement(int type,TPZMaterialData &data) override
    {
        data.SetAllRequirements(false);
        if (type == 50) {
            data.fNeedsSol = true;
        }
        if (type == 3) {
            data.fNeedsNormal = true;
        }
    }
    
                
                int Dimension() const override{ return fDim;}
                
                virtual int NStateVariables() const override
    {
        return 1;
    }
                
                virtual void SetParameters(STATE diff, REAL conv, TPZVec<REAL> &convdir);
                
                void GetParameters(STATE &diff, REAL &conv, TPZVec<REAL> &convdir);
    
    void SetDimension(int dim)
    {
        if(dim<0 || dim >3)
        {
            DebugStop();
        }
        fDim = dim;
    }
                
                void SetInternalFlux(STATE flux)
                {
                                fXf = flux;
                }
                
                void SetSD(STATE sd)
                {
                                fSD = sd;
                }
                
                
                virtual void Print(std::ostream & out) override;
                
                virtual std::string Name() override { return "TPZMatPoisson3d"; }

                virtual void Contribute(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ef) override {
                                TPZDiscontinuousGalerkin::Contribute(data,weight,ef);
                }
                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 {
        TPZDiscontinuousGalerkin::Contribute(datavec,weight,ek,ef);
    }
                
    virtual void ContributeBC(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override {
        TPZDiscontinuousGalerkin::ContributeBC(datavec,weight,ek,ef,bc);
    }

    
                virtual void ContributeBCHDiv(TPZMaterialData &data,REAL weight,
                                                                                                                                  TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc);
                virtual void ContributeHDiv(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef);
   virtual void LocalNeumanContribute(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef);
                
#ifdef _AUTODIFF

                void ContributeEnergy(TPZVec<REAL> &x,
                                                                                                  TPZVec<FADFADREAL> &sol,
                                                                                                  TPZVec<FADFADREAL> &dsol,
                                                                                                  FADFADREAL &U,
                                                                                                  REAL weight);
#endif
                
                virtual void ContributeBC(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override {
                                TPZDiscontinuousGalerkin::ContributeBC(data,weight,ef,bc);
                }
                virtual void ContributeBC(TPZMaterialData &data,REAL weight,
                                                                                                                  TPZFMatrix<STATE> &ek,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 ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight,
                                                                                                                                                 TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef) override;
                
                virtual void ContributeBCInterface(TPZMaterialData &data,TPZMaterialData &dataleft,REAL weight,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override
                {
                                TPZDiscontinuousGalerkin::ContributeBCInterface(data,dataleft,weight,ef,bc);
                }
                
                virtual void ContributeInterface(TPZMaterialData &data,TPZMaterialData &dataleft,TPZMaterialData &dataright,REAL weight,
                                                                                                                                                 TPZFMatrix<STATE> &ef) override
                {
                                TPZDiscontinuousGalerkin::ContributeInterface(data,dataleft,dataright,weight,ef);
                }

#ifdef _AUTODIFF
                virtual void ContributeBCEnergy(TPZVec<REAL> &x,TPZVec<FADFADREAL> &sol, FADFADREAL &U,
                                                                                                                                                REAL weight, TPZBndCond &bc);
#endif

                virtual int VariableIndex(const std::string &name) override;
                
                virtual int NSolutionVariables(int var) override;
                
                virtual int NFluxes() override { return 3;}
                
protected:
    virtual void Solution(TPZVec<TPZMaterialData> &datavec, int var, TPZVec<STATE> &Solout) override {
        TPZDiscontinuousGalerkin::Solution(datavec,var,Solout);
    }
    
    virtual void FillDataRequirements(TPZVec<TPZMaterialData > &datavec)  override {
        TPZDiscontinuousGalerkin::FillDataRequirements(datavec);
    }
    
                virtual void Solution(TPZVec<STATE> &Sol,TPZFMatrix<STATE> &DSol,TPZFMatrix<REAL> &axes,int var,TPZVec<STATE> &Solout) override;
public:
                
                virtual void Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout) override;
                
                virtual void Flux(TPZVec<REAL> &x, TPZVec<STATE> &Sol, TPZFMatrix<STATE> &DSol, TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux) override;
                
                virtual void Errors(TPZVec<REAL> &x,TPZVec<STATE> &u,
                                                                TPZFMatrix<STATE> &dudx, TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux,
                                                                TPZVec<STATE> &u_exact,TPZFMatrix<STATE> &du_exact,TPZVec<REAL> &values) override;
    
    virtual void Errors(TPZVec<TPZMaterialData> &data, TPZVec<STATE> &u_exact, TPZFMatrix<STATE> &du_exact, TPZVec<REAL> &errors) override {
        TPZDiscontinuousGalerkin::Errors(data,u_exact,du_exact,errors);
    }
    
                void ErrorsHdiv(TPZMaterialData &data,TPZVec<STATE> &u_exact,TPZFMatrix<STATE> &du_exact,TPZVec<REAL> &values) override;
                
                
                virtual int NEvalErrors()  override {return 6;}
                
                virtual REAL ComputeSquareResidual(TPZVec<REAL>& X, TPZVec<STATE> &sol, TPZFMatrix<STATE> &dsol) override;
                
                
                void InterfaceErrors(TPZVec<REAL> &/*x*/,
                                                                                                 TPZVec<STATE> &leftu, TPZFMatrix<STATE> &leftdudx, /* TPZFMatrix<REAL> &leftaxes,*/
                                                                                                 TPZVec<STATE> &rightu, TPZFMatrix<STATE> &rightdudx, /* TPZFMatrix<REAL> &rightaxes,*/
                                                                                                 TPZVec<STATE> &/*flux*/,
                                                                                                 TPZVec<STATE> &u_exact,TPZFMatrix<STATE> &du_exact,TPZVec<REAL> &values,
                                                                                                 TPZVec<STATE> normal, STATE elsize);
                
                virtual void BCInterfaceJump(TPZVec<REAL> &x, TPZSolVec &leftu,TPZBndCond &bc,TPZSolVec & jump) override;
                
                virtual int IsInterfaceConservative() override { return 1;}
                
        public:
virtual int ClassId() const override;

                
                virtual void Write(TPZStream &buf, int withclassid) const override;
                
                virtual void Read(TPZStream &buf, void *context) override;

};

#endif