TPZCompElDisc.h

Go to the documentation of this file.

#ifndef ELCOMPDISCHPP
#define ELCOMPDISCHPP

#include <iostream>
#include "pzfmatrix.h"
#include "pzvec.h"
#include "pzcompel.h"
#include "pzinterpolationspace.h"
#include "pzgeoel.h"
#include "pzreal.h"
#include "TPZShapeDisc.h"
#include "tpzautopointer.h"
#include "pzquad.h"
#include "pzfunction.h"
#include "pzfmatrix.h"

struct TPZElementMatrix;
class TPZBndCond;
class TPZConnect;
class TPZMaterial;
class TPZGeoEl;
class TPZCompMesh;

class TPZCompElDisc : public TPZInterpolationSpace {
                
private:
                
                TPZAutoPointer<TPZIntPoints> CreateIntegrationRule() const;
                
protected:
                
                TPZAutoPointer<TPZIntPoints> fIntRule;
                
                pzshape::TPZShapeDisc::MShapeType fShapefunctionType;
                
public:
                
                static void SetTensorialShape(TPZCompMesh * cmesh);
                
                static void SetTotalOrderShape(TPZCompMesh * cmesh);
                
                void SetTensorialShape();
                
                void SetTotalOrderShape();
                
                void SetTensorialShapeFull();
                
                void SetTotalOrderShapeFull();
                
protected:
                
                int64_t fConnectIndex;
                
                REAL fConstC;
    
    bool fUseQsiEta;
                
                TPZAutoPointer<TPZFunction<STATE> > fExternalShape;
                
protected:
                
                TPZManVector<REAL,3> fCenterPoint;
                
                virtual int64_t CreateMidSideConnect();
                
public:
                
                void SetExternalShapeFunction(TPZAutoPointer<TPZFunction<STATE> > externalShapes);
                
                bool HasExternalShapeFunction();
                
                int GetMaterial( const TPZGeoElSide& gside );
                
                static TPZCompEl *CreateDisc(TPZGeoEl *geo, TPZCompMesh &mesh, int64_t &index);
                
                static void SetOrthogonalFunction(void (*orthogonal)(REAL C, REAL x0, REAL x,int degree, TPZFMatrix<REAL> & phi, TPZFMatrix<REAL> & dphi, int n)){
                                pzshape::TPZShapeDisc::fOrthogonal = orthogonal;
                }
                
                virtual void SetInnerRadius(REAL InnerRadius) {PZError << "TPZCompElDisc::SetInnerRadius - This method should never be called because the inner" << std::endl
                                << "radius is not stored in TPZCompElDisc. It is stored in TPZAgglomerateElement." << std::endl;}
                
                virtual void SetNInterfaces(int nfaces) {PZError << "TPZCompElDisc::SetNFaces - This method should never be called because the number of interfaces" << std::endl
                                << "is not stored in TPZCompElDisc. It is only stored by TPZAgglomerateElement." << std::endl;}
                
                virtual int NInterfaces();
                
                TPZCompElDisc();
                TPZCompElDisc(TPZCompMesh &mesh,TPZGeoEl *ref,int64_t &index);//original
                TPZCompElDisc(TPZCompMesh &mesh,int64_t &index);//construtor do aglomerado
                TPZCompElDisc(TPZCompMesh &mesh, const TPZCompElDisc &copy);

                TPZCompElDisc(TPZCompMesh &mesh,
                                                                  const TPZCompElDisc &copy,
                                                                  std::map<int64_t,int64_t> &gl2lcConMap,
                                                                  std::map<int64_t,int64_t> &gl2lcElMap);
                
                TPZCompElDisc(TPZCompMesh &mesh, const TPZCompElDisc &copy,int64_t &index);
                
                virtual void SetCreateFunctions(TPZCompMesh *mesh) override;
                
                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const override {
                                return new TPZCompElDisc(mesh,*this);
                }
                
                virtual TPZCompEl *Clone(TPZCompMesh &mesh,int64_t &index) const {
                                return new TPZCompElDisc(mesh,*this,index);
                }
                
                virtual TPZCompEl *ClonePatchEl(TPZCompMesh &mesh,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap) const  override {
                                return new TPZCompElDisc(mesh,*this,gl2lcConMap,gl2lcElMap);
                }
                virtual ~TPZCompElDisc();
                
                void Divide(int64_t index, TPZVec<int64_t> &subindex, int interpolate = 0) override;
                
                virtual void Shape(TPZVec<REAL> &qsi,TPZFMatrix<REAL> &phi,TPZFMatrix<REAL> &dphidxi) override;
                
                
protected:
                virtual void ComputeShape(TPZVec<REAL> &intpoint, TPZVec<REAL> &X, TPZFMatrix<REAL> &jacobian, TPZFMatrix<REAL> &axes, REAL &detjac, TPZFMatrix<REAL> &jacinv, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphi, TPZFMatrix<REAL> &dphidx) override;
    
    public:
    
    virtual void ComputeShape(TPZVec<REAL> &intpoint,TPZMaterialData &data) override;
                
                virtual void ShapeX(TPZVec<REAL> &X, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphi);
                
                void AppendExternalShapeFunctions(TPZVec<REAL> &X, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphi);
                
                virtual const TPZIntPoints &GetIntegrationRule() const override;
                
                virtual TPZIntPoints &GetIntegrationRule() override;
                
                virtual MElementType Type()  override {return EDiscontinuous;}
                
                REAL ConstC() const {return fConstC;}
                
                void SetConstC(REAL c){fConstC = c;}
    
    void SetTrueUseQsiEta(){
#ifdef PZDEBUG
        if(!Reference()) DebugStop();
#endif
        fUseQsiEta = true;
        fCenterPoint.Fill(0.);
        fConstC = 1.;

        TPZGeoEl *gel = Reference();
        if (gel)
        {
            int ns = Reference()->NSides();
            fCenterPoint.resize(gel->Dimension());
            this->Reference()->CenterPoint(ns-1, fCenterPoint);
        }
    }

    void SetFalseUseQsiEta(){
#ifdef PZDEBUG
        if(!Reference()) DebugStop();
#endif
        fUseQsiEta = false;
        TPZManVector<REAL,3> csi(Reference()->Dimension(),0.);
        Reference()->CenterPoint(Reference()->NSides()-1,csi);
        Reference()->X(csi,fCenterPoint);
        fConstC = NormalizeConst();
    }

                void InternalPoint(TPZVec<REAL> &point);
                
                virtual void Print(std::ostream & out = std::cout) const override;
                
                virtual int Degree() const;
                
                virtual void SetDegree(int degree);
                virtual int NConnects() const override;
                
                int NCornerConnects() const { return Reference()->NNodes();}
    
    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override;
                
                int Dimension() const  override { return Reference()->Dimension();}
                
                virtual REAL NormalizeConst();
                
                int64_t ConnectIndex(int side = 0) const override;
                void  SetConnectIndex(int /*inode*/, int64_t index)  override {fConnectIndex = index;}
    
    virtual int NSideConnects(int iside) const override
    {
        return NConnects();
    }

    virtual int SideConnectLocId(int icon,int is) const override
    {
#ifdef PZDEBUG
        if (icon != 0) {
            DebugStop();
        }
#endif
        return 0;
    }

                
                virtual int NShapeF() const override;
                
                virtual int MaxOrder() override;
                
                int MaxOrderExceptExternalShapes();
                
                virtual int NConnectShapeF(int inod, int order) const override;
                
                REAL CenterPoint(int index) const {return fCenterPoint[index];}
                
                virtual void CenterPoint(TPZVec<REAL> &center);
                
                void SetCenterPoint(int i,REAL x){fCenterPoint[i] = x;}
                
                REAL SizeOfElement();
                
                virtual  REAL VolumeOfEl() override { return Reference()->Volume(); }
                
                void CreateGraphicalElement(TPZGraphMesh &grmesh, int dimension) override;
                
                void SolutionX(TPZVec<REAL> &x,TPZVec<STATE> &uh);
                
    public:
                virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZSolVec &sol, TPZGradSolVec &dsol,TPZFMatrix<REAL> & axes) override;
    
public:
    
    virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZMaterialData &data) override;
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphix,
                                                                                                                                 const TPZFMatrix<REAL> &axes, TPZSolVec &sol, TPZGradSolVec &dsol) override;
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZVec<REAL> &normal,
                                                                                                                                 TPZSolVec &leftsol, TPZGradSolVec &dleftsol,TPZFMatrix<REAL> &leftaxes,
                                                                                                                                 TPZSolVec &rightsol, TPZGradSolVec &drightsol,TPZFMatrix<REAL> &rightaxes) override;
                
                virtual void AccumulateIntegrationRule(int degree, TPZStack<REAL> &point, TPZStack<REAL> &weight);
                
                virtual void AccumulateVertices(TPZStack<TPZGeoNode *> &nodes);
                
                int NSides();
                
                void BuildTransferMatrix(TPZCompElDisc &coarsel, TPZTransfer<STATE> &transfer);
                
                public:
int ClassId() const override;

                void Write(TPZStream &buf, int withclassid) const override;
                
                void Read(TPZStream &buf, void *context) override;
                
                virtual void SetPreferredOrder ( int order ) override { SetDegree( order ); }
                
                virtual void PRefine ( int order ) override { SetDegree( order ); }
                
                static REAL EvaluateSquareResidual2D(TPZInterpolationSpace *cel);
                
                static void EvaluateSquareResidual2D(TPZCompMesh &cmesh, TPZVec<REAL> &error, bool verbose = false);
    
                
};

inline TPZCompEl *TPZCompElDisc::CreateDisc(TPZGeoEl *geo, TPZCompMesh &mesh, int64_t &index) {
                if(!geo->Reference() && geo->NumInterfaces() == 0)
                                return new TPZCompElDisc(mesh,geo,index);
                return NULL;
}
//Exemplo do quadrilatero:
//acessar com -> TPZGeoElement<TPZShapeQuad,TPZGeoQuad,TPZRefQuad>::SetCreateFunction(TPZCompElDisc::CreateDisc);

#endif