pzgmesh.h

Go to the documentation of this file.

#ifndef PZGEOMESHH
#define PZGEOMESHH


#include "TPZSavable.h"
#include "pzreal.h"
#include "pzeltype.h"
#include "pzgnode.h"
#include "pzadmchunk.h"
#include "tpzautopointer.h"
#include "pzgeoel.h"

#include <iostream>
#include <string>
#include <map>
#include <list>

#define GMESHNOMATERIAL -9999

class TPZMaterial;
class TPZGeoNode;
class TPZCompMesh;
class TPZRefPattern;
class TPZRefPatternDataBase;

template<class T>
class TPZVec;

template <class TGeo> class TPZGeoElRefPattern;

class  TPZGeoMesh : public TPZSavable {
                
protected:
                std::string fName;
                
                TPZCompMesh     *fReference;
                
                TPZAdmChunkVector<TPZGeoEl *> fElementVec;
                
                TPZAdmChunkVector<TPZGeoNode> fNodeVec;
                
                int64_t fNodeMaxId;
                
                int64_t fElementMaxId;
    
    int fDim;
                
                typedef std::map<std::pair<int,int>, int> InterfaceMaterialsMap;
                
                InterfaceMaterialsMap fInterfaceMaterials;
                
public:
                TPZGeoMesh();
                
                TPZGeoMesh(const TPZGeoMesh &cp);
                
                TPZGeoMesh & operator= (const TPZGeoMesh &cp );
                
                virtual ~TPZGeoMesh();
                
                void CleanUp();
                
                void ResetConnectivities();
                
                public:
int ClassId() const override;

                
                void Read(TPZStream &buf, void *context) override;
                
                void Write(TPZStream &buf, int withclassid) const override;
                
                void SetNodeIdUsed(int64_t id) { fNodeMaxId = (id > fNodeMaxId) ? id : fNodeMaxId; }
                
                void SetElementIdUsed(int64_t id) { fElementMaxId = (id > fElementMaxId) ? id : fElementMaxId; }
                
                int64_t CreateUniqueNodeId() { return ++fNodeMaxId; }
                
                int64_t CreateUniqueElementId() { return ++fElementMaxId; }
                
                void SetMaxNodeId(int64_t id) { fNodeMaxId = (id > fNodeMaxId) ? id : fNodeMaxId; }
                
                void SetMaxElementId(int64_t id) { fElementMaxId = (id > fElementMaxId) ? id : fElementMaxId; }
                
                int64_t NNodes() const {return fNodeVec.NElements();}
                
                int64_t NElements() const {return fElementVec.NElements();}
                
                int64_t ReallyNEl() {return (fElementVec.NElements() - fElementVec.NFreeElements()) ; }
                
                void SetName(const std::string &nm);
                
                std::string &Name() { return fName; }
                
                TPZAdmChunkVector<TPZGeoEl *> &ElementVec() { return fElementVec; }
    TPZGeoEl * Element(int64_t iel) { return fElementVec[iel]; }
                TPZAdmChunkVector<TPZGeoNode> &NodeVec() { return fNodeVec; }
                const TPZAdmChunkVector<TPZGeoEl *> &ElementVec() const { return fElementVec; }
                const TPZAdmChunkVector<TPZGeoNode> &NodeVec() const { return fNodeVec; }

    REAL Area();
    
    REAL Area(int matid);
    
    REAL Area(std::set<int> &matids);
    
                void ResetReference();
                
                void RestoreReference(TPZCompMesh *cmesh);
                
                void SetReference(TPZCompMesh *ref)
                {
                                fReference = ref;
                }
                
                TPZCompMesh *Reference() const {return fReference;}
                
                virtual void Print(std::ostream & out = std::cout) const;
                virtual void PrintTopologicalInfo(std::ostream & out = std::cout) const;
                
                TPZGeoNode* FindNode(TPZVec<REAL> &co);
    
    TPZGeoNode* FindNode(TPZVec<REAL> &co, int &nodeFoundIndex);
    
    TPZGeoEl * FindElement(TPZVec<REAL> &x, TPZVec<REAL> & qsi, int64_t & InitialElIndex, int targetDim) const;
    
    TPZGeoEl * FindElementCaju(TPZVec<REAL> &x, TPZVec<REAL> & qsi, int64_t & InitialElIndex, int targetDim);
    
    TPZGeoEl *FindApproxElement(TPZVec<REAL> &x, TPZVec<REAL> & qsi, int64_t & InitialElIndex, int targetDim) const;
    
    TPZGeoEl * FindSubElement(TPZGeoEl * gel, TPZVec<REAL> &x, TPZVec<REAL> & qsi, int64_t & InitialElIndex) const;
                
    TPZGeoEl * FindCloseElement(TPZVec<REAL> &x, int64_t & InitialElIndex, int targetDim) const;
                
                void BuildConnectivityOld();
                
                void BuildConnectivity();
                
                void GetNodePtr(TPZVec<int64_t> &nos,TPZVec<TPZGeoNode *> &nodep);
                
                void GetBoundaryElements(int64_t IndexNodeFrom,int64_t IndexNodeTo,TPZStack<TPZGeoEl *> &ElementVec,TPZStack<int> &Sides);
                
                TPZGeoEl * FindElement(int64_t elid);
                
                int64_t ElementIndex(TPZGeoEl * gel);
                
                int64_t NodeIndex(TPZGeoNode * nod);

                virtual TPZGeoEl *CreateGeoElementMapped(MElementType type, TPZVec<int64_t>& nodeindexes, int matid, int64_t& index);

                virtual  TPZGeoEl *CreateGeoElement(MElementType type,TPZVec<int64_t> &cornerindexes,int matid,int64_t &index, int reftype = 1);
                
                virtual TPZGeoEl *CreateGeoBlendElement(MElementType type, TPZVec<int64_t>& nodeindexes, int matid, int64_t& index);
                
                void DeleteElement(TPZGeoEl *gel, int64_t index = -1);
                
                int AddInterfaceMaterial(int leftmaterial, int rightmaterial, int interfacematerial);
                
                int InterfaceMaterial(int leftmaterial, int rightmaterial);
                
                void ClearInterfaceMaterialsMap();
    
    void SetDimension(int dim){fDim = dim;}
    
    int Dimension(){return fDim;}
                
private:
                
                void BuildElementsAroundNode(int64_t currentnode,std::map<int64_t,TPZGeoEl *> &elmap);
                
                void FindElement(std::map<int64_t,TPZGeoEl *> &elmap,int64_t currentnode,TPZGeoEl* &candidate,int &candidateside);
};

#endif