pzgeoelrefless.h

Go to the documentation of this file.

#ifndef PZGEOELREFLESS_H
#define PZGEOELREFLESS_H

#include "pzgeoel.h"
#include "pzgeoelside.h"
#include "pzgeom_utility.h"

class TPZGeoElSide;
class TPZCompMesh;
class TPZGeoMesh;
class TPZCompEl;
template<class T,int N>
class TPZStack;

template <class TGeo>
class TPZGeoElRefLess : public TPZGeoEl  {
                //  int fSubElement;
protected:
                TGeo fGeo;
                //  int fNodeIndexes[TGeo::NNodes];
                TPZGeoElSideIndex fNeighbours[TGeo::NSides];
public:

virtual int ClassId() const override;

                virtual ~TPZGeoElRefLess();
                TPZGeoElRefLess();
                
                TPZGeoElRefLess(const TPZGeoElRefLess &gel);
                
                virtual TPZGeoEl *Clone(TPZGeoMesh &dest) const override
                {
                                return new TPZGeoElRefLess(dest,*this);
                }
                
                TPZGeoElRefLess(TPZGeoMesh &DestMesh, const TPZGeoElRefLess &cp);
    
    //virtual void ParametricDomainNodeCoord(int node, TPZVec<REAL> &nodeCoord);
                
                TPZGeoElRefLess(TPZGeoMesh &DestMesh,
                                                                                const TPZGeoElRefLess &cp,
                                                                                std::map<int64_t,int64_t> & gl2lcNdMap,
                                                                                std::map<int64_t,int64_t> & gl2lcElMap);
                
                TPZGeoEl *ClonePatchEl(TPZGeoMesh &destmesh,std::map<int64_t,int64_t> & gl2lcNdMap,
                                                                                                   std::map<int64_t,int64_t> & gl2lcElMap) const  override
                {
                                return new TPZGeoElRefLess(destmesh,*this,gl2lcNdMap, gl2lcElMap);
                }
                
                TPZGeoElRefLess(int64_t id,TPZVec<int64_t> &nodeindexes,int matind,TPZGeoMesh &mesh);
                
                TPZGeoElRefLess(TGeo &Geo, int matind,TPZGeoMesh &mesh);
                
                TPZGeoElRefLess(TPZVec<int64_t> &nodeindices,int matind,TPZGeoMesh &mesh);
    
                TPZGeoElRefLess(TPZVec<int64_t> &nodeindices,int matind,TPZGeoMesh &mesh,int64_t &index);
                
                virtual void Read(TPZStream &str, void *context) override;
                
                virtual void Write(TPZStream &str, int withclassid) const override;
                
                virtual void Initialize() override
                {
                                fGeo.Initialize(this);
                }
                
                
                static int main_refless();
                
                virtual void Divide(TPZVec < TPZGeoEl * > & pv) override {
                                DebugStop();
                }
                
                virtual  int HasSubElement() const  override {return 0;}//fSubEl[0]!=0;}
                
                virtual  TPZGeoElSide Neighbour(int side) override {
#ifdef PZDEBUG
        if (fNeighbours[side] < 0 || fNeighbours[side] >= this->Mesh()->NElements()) {
            DebugStop();
        }
#endif
        return TPZGeoElSide(fNeighbours[side],this->Mesh());
    }
                
                virtual int64_t NeighbourIndex(int side) const override{
#ifdef PZDEBUG
                if (fNeighbours[side] < 0 || fNeighbours[side] >= this->Mesh()->NElements()) {
                                DebugStop();
                }
#endif
                return this->fNeighbours[side].ElementIndex();
                }
                
                virtual  int64_t NodeIndex(int node) const override;
                
    void CornerCoordinates(TPZFMatrix<REAL> &coord) const;
                //HDiv
    
//    virtual void Directions(int side, TPZVec<REAL> &pt, TPZFMatrix<REAL> &directions, TPZVec<int> &vectorsides) override;

    virtual void HDivDirectionsMaster(TPZFMatrix<REAL> &directions) override;
    
    virtual void HDivDirections(TPZVec<REAL> &pt, TPZFMatrix<REAL> &directions, int ConstrainedFace = -1) override;
    

#ifdef _AUTODIFF
    virtual void HDivDirections(TPZVec<REAL> &pt, TPZFMatrix<Fad<REAL> > &directions, int ConstrainedFace = -1) override;
#endif
    
                //virtual void VecHdiv(TPZFMatrix<REAL> &normalvec ,TPZVec<int> &sidevector) override;

                
                virtual void HDivPermutation(int side, TPZVec<int> &permutegather) override;
                
                
                virtual  void SetNeighbour(int side,const TPZGeoElSide &neighbour) override {
                                fNeighbours[side]=neighbour;
                }
                
                virtual void Print(std::ostream &out) override
                {
                                TPZGeoEl::Print(out);
                                out << "fGeo:\n";
                                fGeo.Print(out);
                }
                virtual void PrintTopologicalInfo(std::ostream &out) override
                {
                                out << "Geo Element - fId " << fId << "\t Type " << fGeo.TypeName() << "\t";
                                fGeo.Print(out);
                                int i;
                                out << std::endl << "\t";
                                for (i = 0;i < NNodes();i++) out << NodePtr(i)->Id() << " ";
                }
                
                virtual  int64_t SideNodeIndex(int side,int node) const override;
                
                virtual  int SideNodeLocIndex(int side,int node) const override;
                
                virtual  void SetSideDefined(int side)  override { fNeighbours[side] = TPZGeoElSide(this,side); }
                
                virtual  void SetSubElement(int id, TPZGeoEl *el) override;


    void GetPermutation(const int& i, TPZVec<int> &permutation) const override;
                virtual  TPZIntPoints * CreateSideIntegrationRule(int side, int order) override;
                
                virtual  MElementType Type() const override {
                                return TGeo::Type();
                }
                
                virtual  MElementType Type(int side) const override {
                                return TGeo::Type(side);
                }
                
    virtual std::string TypeName() const override
    {
                                return fGeo.TypeName();
    }
                
                virtual  int NNodes() const override;
                
                virtual  int NCornerNodes() const override;
                
                virtual  int NSides() const override;

    virtual int NPermutations() const override;
                
                virtual  int SideNodeLocId(int side, int node) const;
                
                virtual  REAL RefElVolume() override;
                
                virtual  int NSideNodes(int side) const override;
                
                virtual  void MidSideNodeIndex(int side,int64_t &index) const override;
                
                virtual  int SideIsUndefined(int side) override;
                
                virtual  int NSubElements() const override;
                
                virtual  int NSideSubElements(int side) const override;
                
                virtual  TPZGeoEl *CreateBCGeoEl(int side, int bc) override;
                
                virtual TPZGeoEl *CreateBCGeoBlendEl(int side, int bc);

                virtual TPZGeoEl *CreateGeoElement(MElementType type,
                                                                                                                                                   TPZVec<int64_t>& nodeindexes,
                                                                                                                                                   int matid,
                                                                                                                                                   int64_t& index) override;
                
                virtual  void SetNodeIndex(int i,int64_t nodeindex) override;
                
                virtual  TPZTransform<> SideToSideTransform(int sidefrom,int sideto) override;
                
                virtual  TPZGeoEl *SubElement(int is) const override;
                
                virtual  int SideDimension(int side) const override;
                
                virtual int Dimension() const override;
                
                virtual  TPZGeoElSide HigherDimensionSides(int side,int targetdimension);
                
                virtual  void AllHigherDimensionSides(int side,int targetdimension,TPZStack<TPZGeoElSide> &elsides) override;
                
                virtual  void LowerDimensionSides(int side,TPZStack<int> &smallsides) const override;
                
                virtual  void BuildTransform(int side, TPZGeoEl *father,TPZTransform<> &t);
                
                virtual  TPZTransform<> BuildTransform2(int side, TPZGeoEl *father,TPZTransform<> &t) override;
                
    virtual  void X(TPZVec<REAL> &coordinate,TPZVec<REAL> &result) const override;
    
    virtual void GradX(TPZVec<REAL> &coordinate, TPZFMatrix<REAL> &gradx) const override;
    
#ifdef _AUTODIFF

    virtual  void X(TPZVec<Fad<REAL> > &coordinate,TPZVec<Fad<REAL> > &result) const override;
    
    virtual void GradX(TPZVec<Fad<REAL> > &coordinate, TPZFMatrix<Fad<REAL> > &gradx) const override;
#endif
    
                virtual bool IsLinearMapping( int side) const override;
                virtual bool IsGeoBlendEl() const override;

    bool ResetBlendConnectivity(const int64_t &side, const int64_t &index) override;
                TGeo &Geom() { return fGeo; }
                
                virtual  TPZTransform<> GetTransform(int side,int son) override;
                
                virtual void CenterPoint(int side, TPZVec<REAL> &masscent) const override;
                
                virtual TPZGeoElSide Father2(int side) const override;
                
                virtual int FatherSide(int side, int son)  override {
                                return side;
                }
                
                virtual void GetSubElements2(int side, TPZStack<TPZGeoElSide> &subel) const override;
                
                virtual void ResetSubElements() override {
                                DebugStop();
                }
                
                virtual void SetNeighbourInfo(int side, TPZGeoElSide &neigh, TPZTransform<> &trans) override
                {
                                Geom().SetNeighbourInfo(side,neigh,trans);
                }
                
    virtual void RandomPoint(TPZVec<REAL> &pt) override
    {
        Geom().RandomPoint(pt);
    }
    
                virtual bool IsInParametricDomain(const TPZVec<REAL> &pt, REAL tol = 1e-6) override;
                
                virtual int ProjectInParametricDomain(TPZVec<REAL> &qsi, TPZVec<REAL> &qsiInDomain) override;
    
    virtual int ProjectBissectionInParametricDomain(TPZVec<REAL> &qsi, TPZVec<REAL> &qsiInDomain) override;
};

template<class TGeo>
inline
bool TPZGeoElRefLess<TGeo>::IsInParametricDomain(const TPZVec<REAL> &pt, REAL tol){
                const bool result = fGeo.IsInParametricDomain(pt,tol);
                return result;
}

template<class TGeo>
inline
int TPZGeoElRefLess<TGeo>::ProjectInParametricDomain(TPZVec<REAL> &pt, TPZVec<REAL> &ptInDomain){
    const int side = ::ProjectInParametricDomain<TGeo>(pt, ptInDomain);
                return side;
}

template<class TGeo>
inline
int TPZGeoElRefLess<TGeo>::ProjectBissectionInParametricDomain(TPZVec<REAL> &pt, TPZVec<REAL> &ptInDomain){
    const int side = ::ProjectBissectionInParametricDomain<TGeo>(pt, ptInDomain);
                return side;
}

template<class TGeo>
int TPZGeoElRefLess<TGeo>::ClassId() const{
    return Hash("TPZGeoElRefLess") ^ TPZGeoEl::ClassId() << 1 ^ TGeo().ClassId() << 2;
}

//template<class TGeo>
//inline
//void TPZGeoElRefLess<TGeo>::ParametricDomainNodeCoord(int node, TPZVec<REAL> &nodeCoord)
//{
//    fGeo.ParametricDomainNodeCoord(node, nodeCoord);
//}

#include "pzgeoelrefless.h.h"

#endif