tpzpoint.h

Go to the documentation of this file.

#ifndef PZTOPOLOGYTPZPOINT_H
#define PZTOPOLOGYTPZPOINT_H

#include "pzreal.h"
#include "pzfmatrix.h"
#include "pzvec.h"
#include "pztrnsform.h"
#include "pzeltype.h"
#include "pzstack.h"
#include "pzaxestools.h"
#include "TPZTopologyUtils.h"

class TPZIntPoints;
class TPZInt1Point;
class TPZGraphEl1dd;

class TPZCompEl;
class TPZGeoEl;
class TPZCompMesh;

namespace pztopology {
                class TPZPoint : public TPZSavable {
                public:

        friend void pztopology::GetPermutation<TPZPoint>(const int permute, TPZVec<int> &permutation);
                                enum {NCornerNodes = 1, NSides = 1, Dimension = 0, NFaces = 0, NPermutations = 1};

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

                
        TPZPoint() : TPZRegisterClassId(&TPZPoint::ClassId) {
                                }
                                virtual ~TPZPoint() {
                                }

        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 int SideDimension(int side) {
                                                return 0;
                                }

                                static void LowerDimensionSides(int side,TPZStack<int> &smallsides) {
                                }
                                static void LowerDimensionSides(int side,TPZStack<int> &smallsides, int targetdim) {
                                }
                                
                                static void HigherDimensionSides(int side, TPZStack<int> &high) {
                                }
                                static int NSideNodes(int side) {
                                                return 1;
                                }
                                static int SideNodeLocId(int side, int node) {
                                                return 0;
                                }

                                static int NumSides() { return 1; }
                                static int NumSides(int dimension) { return 0; };               

                                static int NContainedSides(int side) {
                                                return 1;
                                }
                                static int ContainedSideLocId(int side, int c) {
                                                return 0;
                                }

                                static void CenterPoint(int side, TPZVec<REAL> &center) {
                                }

                                static bool IsInParametricDomain(const TPZVec<REAL> &pt, REAL tol = 1e-6){
                                                return true;
                                }
        
        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) {
                                                TPZTransform<> result(0,0);
                                                return result;
                                }
                                static TPZTransform<> TransformSideToElement(int side) {
                                                TPZTransform<> result(0,0);
                                                return result;
                                }

                                static TPZTransform<> TransformElementToSide(int side){
                                                TPZTransform<> t(0,0);
                                                return t;
                                }
                                
                                static int GetTransformId(TPZVec<int64_t> &id);
                                
                                static int GetTransformId(int side, TPZVec<int64_t> &id);
                                
                                static TPZIntPoints *CreateSideIntegrationRule(int side, int order);
                                
                                typedef TPZInt1Point IntruleType;
                                
                                /* @} */
                                
                                static void GetSideHDivPermutation(int transformationid, TPZVec<int> &permgather)
                {
                                permgather[0] = 0;
                                return;
                }
                                
                                static constexpr REAL RefElVolume() {
                                                return 0.;
                                }
        
        /* Given side and gradx the method returns directions needed for Hdiv space */
        static void ComputeDirections(int side, TPZFMatrix<REAL> &gradx, TPZFMatrix<REAL> &directions, TPZVec<int> &sidevectors);
        static void GetSideHDivDirections(TPZVec<int> &sides, TPZVec<int> &dir, TPZVec<int> &bilinearounao)
        {
            sides[0] = 0;
            dir[0] = 0;
            bilinearounao[0] = 0;
        }

        static void GetSideHDivDirections(TPZVec<int> &sides, TPZVec<int> &dir, TPZVec<int> &bilinearounao, TPZVec<int> &sidevectors)
        {
            sides[0] = 0;
            dir[0] = 0;
            bilinearounao[0] = 0;
            sidevectors[0] = 0;
        }

        template <class TVar>
        static void ComputeHDivDirections(TPZFMatrix<TVar> &gradx, TPZFMatrix<TVar> &directions)
        {
        }
        

        static int NBilinearSides();
                protected:
        static int fPermutations [1][1];
                };
                
}

#endif