pzgeoelside.h

Go to the documentation of this file.

#ifndef PZGEOELSIDEH
#define PZGEOELSIDEH

/*******       TPZGeoElSide       *******/


#include "pzvec.h"
#include "pzstack.h"
#include "pzfmatrix.h"
#include "pztrnsform.h"
#include "tpzintpoints.h"
#include <set>

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

class TPZCompElSide;

class TPZGeoElSide;
class TPZGeoMesh;
class TPZGeoEl;

class TPZGeoElSideIndex : public TPZSavable{
private:
                int64_t fGeoElIndex;
                int fSide;
                
public:
                ~TPZGeoElSideIndex();
                TPZGeoElSideIndex();
                TPZGeoElSideIndex(TPZGeoEl *gel,int side);
                
                TPZGeoElSideIndex(int64_t gelindex,int side);
                
                TPZGeoElSideIndex(const TPZGeoElSide &side);
                
                TPZGeoElSideIndex(const TPZGeoElSideIndex &cp);
                TPZGeoElSideIndex * Clone();
                TPZGeoElSideIndex &operator= (const TPZGeoElSideIndex &A );
                
    operator bool() const
    {
        return fGeoElIndex == -1 || fSide == -1;
    }
    
                int Side() const;
                
                void SetSide(int side);
                
                TPZGeoEl *Element(const TPZGeoMesh *mesh) const;
                
                void SetElement(TPZGeoEl* geoel);
                
                int64_t ElementIndex() const;
                
                void SetElementIndex(int64_t i);
                        int ClassId() const override;
        void Read(TPZStream &buf, void *context) override;
        void Write(TPZStream &buf, int withclassid) const override;
};

class TPZGeoElSide : public TPZSavable {
                
                TPZGeoEl *fGeoEl;
                int fSide;
public:
    
                int NSubElements();
    
                void GetSubElements2(TPZStack<TPZGeoElSide> &subelements);
    
                TPZGeoElSide StrictFather();
    
                TPZGeoElSide Father2() const;
    
                TPZCompElSide LowerLevelCompElementList2(int onlyinterpolated);
                
                bool IsRelative(TPZGeoElSide other);
                
                bool IsAncestor(TPZGeoElSide other);
                
                void X(TPZVec< REAL > &loc, TPZVec< REAL > &result) const;
    
    void QsiElement(TPZVec< REAL > &qsi_side, TPZVec< REAL > &qsi_element) const;
    
    void GradX(TPZVec<REAL> &loc, TPZFMatrix<REAL> &gradx) const;

    bool ResetBlendConnectivity(const int64_t &index);
                
#ifdef _AUTODIFF

    void X(TPZVec< Fad<REAL> > &loc, TPZVec< Fad<REAL> > &result) const;
    
    void GradX(TPZVec< Fad<REAL> > &loc, TPZFMatrix< Fad<REAL> > &gradx) const;
#endif

                void Jacobian(TPZVec<REAL> &param,TPZFMatrix<REAL> &jacobian,TPZFMatrix<REAL> &axes,REAL &detjac,TPZFMatrix<REAL> &jacinv) const;
    
    REAL Area();
                
                int NNeighbours();
                
                int NNeighboursButThisElem(TPZGeoEl *thisElem);
                
                TPZGeoElSide(){ fGeoEl = 0; fSide  = -1;}
                
                TPZGeoElSide(TPZGeoEl *gel,int side){  fGeoEl = gel; fSide = side;}
                
                TPZGeoElSide(TPZGeoEl *gel, std::set<int64_t> &sideCornerNodes);
                
                TPZGeoElSide(const TPZGeoElSideIndex &index, const TPZGeoMesh * mesh){
                                this->fSide = index.Side();
                                this->fGeoEl = index.Element(mesh);
                                if(fGeoEl == 0 && index.ElementIndex() != -1)
        {
                                    DebugStop();
        }
                }
    
    TPZGeoElSide(int zero) : fGeoEl(0), fSide(-1)
    {
        
    }
                
                TPZGeoEl *Element()const{return fGeoEl;}
                
                void SetElement(TPZGeoEl* geoel){ fGeoEl = geoel; }
    
    void Print(std::ostream &out) const;
                
                int Side() const {return fSide;}
                
                void SetSide(int side) { fSide = side; }
                
                bool IsLinearMapping() const;
                
                int Exists() const {return (fGeoEl != 0 && fSide > -1);}
                
                void CenterPoint(TPZVec<REAL> &center) const;
    
                void CenterX(TPZVec<REAL> &Xcenter) const;
    
    void Normal(TPZVec<REAL> &point, TPZGeoEl *left, TPZGeoEl *right, TPZVec<REAL> &normal) const;
    
    void Normal(TPZVec<REAL> &point, TPZVec<REAL> &normal) const;
    
    int NSides() const;
                
                TPZGeoElSide Neighbour() const;//return neighbour of the side fSide
                
                void AllNeighbours(TPZStack<TPZGeoElSide> &allneigh);
                
                void ComputeNeighbours(TPZStack<TPZGeoElSide> &compneigh);
                
                int64_t Id();
    
                int Dimension() const;
                
                int operator==(const TPZGeoElSide &other) const {
                                return fGeoEl == other.fGeoEl && fSide == other.fSide;
                }
                int operator!=(const TPZGeoElSide &other) const {
                                return fGeoEl != other.fGeoEl || fSide != other.fSide;
                }
                
                int operator<(const TPZGeoElSide &other) const {
                                return (fGeoEl < other.fGeoEl || (fGeoEl == other.fGeoEl && fSide < other.fSide));
                }
                
                int operator>(const TPZGeoElSide &other) const {
                                return (fGeoEl > other.fGeoEl || (fGeoEl == other.fGeoEl && fSide > other.fSide));
                }
    
    operator bool() const
    {
        return fGeoEl != 0;
    }
                
                void SideTransform3(TPZGeoElSide neighbour,TPZTransform<> &t);
                
                void SetConnectivity(const TPZGeoElSide &neighbour) const;
    
                void InsertConnectivity(TPZGeoElSide &neighbour);
                
                void RemoveConnectivity();
                
                static void BuildConnectivities(TPZVec<TPZGeoElSide> &elvec, TPZVec<TPZGeoElSide> &neighvec);
                
                void SetNeighbour(const TPZGeoElSide &neighbour) const;
                
                TPZTransform<REAL> NeighbourSideTransform(const TPZGeoElSide &neighbour);
                
                TPZTransform<REAL> SideToSideTransform(TPZGeoElSide &higherdimensionside);
    
    TPZGeoElSide LowestFatherSide();
    
    virtual void GetAllSiblings(TPZStack<TPZGeoElSide> &unrefinedSons);
    virtual void YoungestChildren(TPZStack<TPZGeoElSide> &unrefinedSons);

                TPZCompElSide Reference() const;
                int HasSubElement();
                
                /* @brief Return the number of nodes for a particular side*/
                int NSideNodes() const;
                
                int64_t SideNodeIndex(int nodenum) const;
                
                int64_t SideNodeLocIndex(int nodenum) const;
    
                
                int NeighbourExists(const TPZGeoElSide &neighbour) const;
                
                void EqualorHigherCompElementList2(TPZStack<TPZCompElSide> &celside, int onlyinterpolated, int removeduplicates);
    
                void HigherDimensionElementList(TPZStack<TPZCompElSide> &elsidevec, int onlyinterpolated);
                
                void HigherLevelCompElementList2(TPZStack<TPZCompElSide> &elsidevec, int onlyinterpolated, int removeduplicates);
                
                void ConnectedCompElementList(TPZStack<TPZCompElSide> &elsidevec,int onlyinterpolated, int removeduplicates);
                
                void EqualLevelCompElementList(TPZStack<TPZCompElSide> &elsidevec,              int onlyinterpolated, int removeduplicates);
    
                void EqualorHigherCompElementList3(TPZStack<TPZCompElSide> &celside, int onlymultiphysicelement, int removeduplicates);
    
                void EqualLevelCompElementList3(TPZStack<TPZCompElSide> &elsidevec,             int onlymultiphysicelement, int removeduplicates);
    
                void HigherLevelCompElementList3(TPZStack<TPZCompElSide> &elsidevec, int onlymultiphysicelement, int removeduplicates);


    /* @brief Creates an integration rule for the topology of this side */
                TPZIntPoints * CreateIntegrationRule(int order);

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

std::ostream  &operator << (std::ostream & out,const TPZGeoElSide &geoside);

inline void TPZGeoElSide::AllNeighbours(TPZStack<TPZGeoElSide> &allneigh) {
                TPZGeoElSide neigh = Neighbour();
#ifndef NODEBUG
                if(! Exists() || ! neigh.Exists()) 
    {
                                std::cout << "TPZGeoElSide AllNeighbours inconsistent\n";
                                return;
    }
#endif
                while(neigh != *this)
    {
                                allneigh.Push(neigh);
                                neigh = neigh.Neighbour();
    }
}


inline TPZGeoElSideIndex::~TPZGeoElSideIndex(){
                //nothing to be done here
}

inline TPZGeoElSideIndex::TPZGeoElSideIndex(){
    this->fSide = -1;
    this->fGeoElIndex = -1;
}

inline TPZGeoElSideIndex::TPZGeoElSideIndex(int64_t gelindex,int side){  
    this->fGeoElIndex = gelindex;
    this->fSide = side;
}

inline TPZGeoElSideIndex::TPZGeoElSideIndex(const TPZGeoElSideIndex &cp){
    this->operator =(cp);
}

inline TPZGeoElSideIndex * TPZGeoElSideIndex::Clone(){
    return new TPZGeoElSideIndex(*this);
}

inline TPZGeoElSideIndex & TPZGeoElSideIndex::operator= (const TPZGeoElSideIndex &A ){
    this->fGeoElIndex = A.fGeoElIndex;
    this->fSide = A.fSide;
    return *this;
}

inline int TPZGeoElSideIndex::Side() const{
    if (this->fSide == -1 || this->fGeoElIndex == -1){
                                return -1;
    }
    return this->fSide;
}

inline void TPZGeoElSideIndex::SetSide(int side){
    this->fSide = side;
}  

inline int64_t TPZGeoElSideIndex::ElementIndex() const{
    return this->fGeoElIndex;
}

inline void TPZGeoElSideIndex::SetElementIndex(int64_t i){
    this->fGeoElIndex = i;
}

#endif