tpzquadrilateral.h

Go to the documentation of this file.

#ifndef PZTOPOLOGYTPZQUADRILATERAL_H
#define PZTOPOLOGYTPZQUADRILATERAL_H

#include "pzfmatrix.h"
#include "pzstack.h"
#include "pztrnsform.h"
#include "pzquad.h"
#include "pzeltype.h"
#include "pzaxestools.h"
#include "TPZTopologyUtils.h"

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

class TPZIntPoints;
class TPZIntQuad;
class TPZGraphElQ2dd;

class TPZCompEl;
class TPZGeoEl;
class TPZCompMesh;

namespace pztopology {
                class TPZQuadrilateral : public TPZSavable {
                public:

        friend void pztopology::GetPermutation<TPZQuadrilateral>(const int permute, TPZVec<int> &permutation);
                                enum {NSides = 9, NCornerNodes = 4, Dimension = 2, NFaces = 4, NPermutations = 8};
        int ClassId() const override;
            void Read(TPZStream &buf, void *context) override;
            void Write(TPZStream &buf, int withclassid) const override;

                
        TPZQuadrilateral() : TPZRegisterClassId(&TPZQuadrilateral::ClassId){
                                }
                                
                                virtual ~TPZQuadrilateral() {
                                }
                                
                                static int SideDimension(int side);
                                
                                static void LowerDimensionSides(int side,TPZStack<int> &smallsides);
                                static void LowerDimensionSides(int side,TPZStack<int> &smallsides, int DimTarget);
                                
                                static void HigherDimensionSides(int side, TPZStack<int> &high);
                                
                                static int NSideNodes(int side);
                                static int SideNodeLocId(int side, int node);

                                static int NumSides() {
                                                return NSides;
                                }
                                static int NumSides(int dimension);

                                static int NContainedSides(int side);
                                
                                static int ContainedSideLocId(int side, int c);


        static void Shape(TPZVec<REAL> &loc,TPZFMatrix<REAL> &phi,TPZFMatrix<REAL> &dphi){
            TShape(loc, phi, dphi);
        }
        template<class T>
        static void TShape(const TPZVec<T> &loc,TPZFMatrix<T> &phi,TPZFMatrix<T> &dphi);
        template<class T>
        static void BlendFactorForSide(const int &side, const TPZVec<T> &xi, T &blendFactor,
                                      TPZVec<T> &corrFactorDxi);
                                static void CenterPoint(int side, TPZVec<REAL> &center);
                                
                                static bool IsInParametricDomain(const TPZVec<REAL> &pt, REAL tol = pztopology::gTolerance);

        #ifdef _AUTODIFF

                                static bool IsInParametricDomain(const TPZVec<Fad<REAL>> &pt, REAL tol = pztopology::gTolerance){
                                    TPZVec<REAL> xi(pt.size());
                                    for(int i = 0; i < pt.size(); i++) xi[i]= pt[i].val();
                                    return IsInParametricDomain(xi,tol);
                                }
        #endif
        #ifdef _AUTODIFF
        template<typename T,
                typename std::enable_if<std::is_same<T,Fad<REAL>>::value>::type* = nullptr>
        static bool IsInParametricDomain(const TPZVec<T> &pt, REAL tol){
            TPZVec<REAL> qsiReal(pt.size(),-1);
            for(int i = 0; i < qsiReal.size(); i++) qsiReal[i] = pt[i].val();
            return IsInParametricDomain(qsiReal,tol);
        }
        #endif
        
        static void RandomPoint(TPZVec<REAL> &pt);

        template<class T>
        static bool CheckProjectionForSingularity(const int &side, const TPZVec<T> &xiInterior);

        template<class T>
        static void MapToSide(int side, TPZVec<T> &InternalPar, TPZVec<T> &SidePar, TPZFMatrix<T> &JacToSide);
        
        static void ParametricDomainNodeCoord(int node, TPZVec<REAL> &nodeCoord);

                                static MElementType Type();
                                
                                static MElementType Type(int side);
                                
                                static TPZTransform<> SideToSideTransform(int sidefrom, int sideto);
                                                                
                                static TPZTransform<> TransformSideToElement(int side);
                                static TPZTransform<> TransformElementToSide(int side);

                                static int GetTransformId(TPZVec<int64_t> &id);
                                
                                static int GetTransformId(int side, TPZVec<int64_t> &id);
        
        static void GetGatherPermute(int transformid, TPZVec<int> &permute);
                                
                                static TPZIntPoints * CreateSideIntegrationRule(int side, int order);
                                
                                typedef TPZIntQuad IntruleType;
                                typedef TPZGraphElQ2dd GraphElType;
                                
                                static void GetSideHDivPermutation(int transformid, TPZVec<int> &permgather);
                                
                                static constexpr REAL RefElVolume() { return 4.0L; }
        
        /* Given gradx the method returns directions needed for Hdiv space */
        static void ComputeDirections(int is, TPZFMatrix<REAL> &gradx, TPZFMatrix<REAL> &directions, TPZVec<int> &sidevectors);
        static void GetSideHDivDirections(TPZVec<int> &sides, TPZVec<int> &dir, TPZVec<int> &bilinearounao);
        static void GetSideHDivDirections(TPZVec<int> &sides, TPZVec<int> &dir, TPZVec<int> &bilinearounao, TPZVec<int> &sidevectors);
        
        
        template <class TVar>
        static void ComputeHDivDirections(TPZFMatrix<TVar> &gradx, TPZFMatrix<TVar> &directions);

        template <class TVar>
        static void ComputeHCurlDirections(TPZFMatrix<TVar> &gradx, TPZFMatrix<TVar> &directions, const TPZVec<int> &transformationIds);

        template <class TVar>
        static void ComputeHCurlFaceDirections(TPZVec<TVar> &v1, TPZVec<TVar> &v2, int transformationId);
        static int NBilinearSides();

        
        enum EHdivType {HdivConform = 0, HdivFull=1};

        static void SetHdivType(EHdivType val);
                protected:
        static int fPermutations [8][9];
        static REAL fTangentVectors [16][2];
        static int FaceNodes[1][4]; // Denise e Jose: dim =2
        static int SideNodes[4][2]; // Denise e Jose: dim = 1
                };
                
}

#endif