libmeshMesh.h

Go to the documentation of this file.

#ifndef included_AMP_LibMesh
#define included_AMP_LibMesh
 
#include "AMP/mesh/Mesh.h"
#include "AMP/mesh/libmesh/initializeLibMesh.h"
 
// LibMesh include
DISABLE_WARNINGS
#include "libmesh/libmesh_config.h"
#undef LIBMESH_ENABLE_REFERENCE_COUNTING
#include "libmesh/mesh.h"
#include "libmesh/node.h"
ENABLE_WARNINGS
 
 
namespace AMP::Mesh {
 
 
class libmeshMeshElement;
class libmeshElemIterator;
 
 
class libmeshMesh final : public Mesh
{
public:
    explicit libmeshMesh( std::shared_ptr<const MeshParameters> params );
 
    explicit libmeshMesh( std::shared_ptr<libMesh::Mesh> mesh,
                          const std::string &name,
                          std::shared_ptr<libMesh::Parallel::Communicator> libMeshComm = nullptr );
 
    virtual ~libmeshMesh();
 
 
    std::string meshClass() const override;
 
 
    std::unique_ptr<Mesh> clone() const override;
 
 
    static size_t estimateMeshSize( std::shared_ptr<const MeshParameters> params );
 
 
    static size_t maxProcs( std::shared_ptr<const MeshParameters> params );
 
 
    /* Return the number of local element of the given type
     * \param type   Geometric type
     */
    size_t numLocalElements( const GeomType type ) const override;
 
 
    /* Return the global number of elements of the given type
     * \param type   Geometric type
     */
    size_t numGlobalElements( const GeomType type ) const override;
 
 
    /* Return the number of ghost elements of the given type on the current processor
     * \param type   Geometric type
     * \param gcw    Desired ghost cell width
     */
    size_t numGhostElements( const GeomType type, const int gcw ) const override;
 
 
    bool operator==( const Mesh &mesh ) const override;
 
 
    MeshIterator getIterator( const GeomType type, const int gcw = 0 ) const override;
 
 
    virtual MeshIterator getSurfaceIterator( const GeomType type,
                                             const int gcw = 0 ) const override;
 
 
    std::vector<int> getBoundaryIDs() const override;
 
 
    virtual MeshIterator
    getBoundaryIDIterator( const GeomType type, const int id, const int gcw = 0 ) const override;
 
    std::vector<int> getBlockIDs() const override;
 
 
    virtual MeshIterator
    getBlockIDIterator( const GeomType type, const int id, const int gcw = 0 ) const override;
 
 
    std::unique_ptr<MeshElement> getElement( const MeshElementID &id ) const override;
 
 
    Mesh::Movable isMeshMovable() const override;
 
 
    uint64_t positionHash() const override;
 
 
    void displaceMesh( const std::vector<double> &x ) override;
 
 
    inline std::shared_ptr<libMesh::Mesh> getlibMesh() const { return d_libMesh; }
 
 
    void displaceMesh( std::shared_ptr<const AMP::LinearAlgebra::Vector> x ) override;
 
 
    void writeRestart( int64_t fid ) const override;
 
 
protected:
    std::vector<libMesh::Node *> getNeighborNodes( const MeshElementID & ) const;
 
 
private:
    // Friend functions to access protected functions
    friend class libmeshMeshElement;
 
    typedef std::shared_ptr<std::vector<libmeshMeshElement>> ElemListPtr;
 
 
private: // Functions use for initialization
    libmeshMesh(){};
    void initialize();
    ElemListPtr generateGhosts() const;
    ElemListPtr generateLocalElements( GeomType ) const;
    ElemListPtr generateGhostElements( GeomType ) const;
    void fillBoundaryElements();
    libmeshElemIterator localElements() const;
 
private:
    // Index indicating number of times the position has changed
    uint64_t d_pos_hash;
 
    // libMesh objects
    std::shared_ptr<libMesh::Mesh> d_libMesh;
    std::shared_ptr<libMesh::Parallel::Communicator> d_libMeshComm;
 
    // Some basic internal data
    std::vector<size_t> n_local, n_global, n_ghost;
    std::shared_ptr<initializeLibMesh> libmeshInit;
 
    // Data used to store the node neighbor lists
    std::vector<unsigned int> neighborNodeIDs;
    std::vector<std::vector<libMesh::Node *>> neighborNodes;
 
    // Data used to store elements that libmesh doesn't create
    ElemListPtr d_localElements[4];
    ElemListPtr d_ghostElements[4];
 
    // Data used to store the boundary elements
    std::map<std::pair<int, GeomType>, ElemListPtr> d_boundarySets;
 
    // Data used to store the surface elements
    std::vector<ElemListPtr> d_localSurfaceElements;
    std::vector<ElemListPtr> d_ghostSurfaceElements;
 
    // Data used to store block info
    std::vector<int> d_block_ids;
};
 
} // namespace AMP::Mesh
 
#endif