MultiMesh.h

Go to the documentation of this file.

#ifndef included_AMP_MultiMesh
#define included_AMP_MultiMesh
 
#include "AMP/mesh/Mesh.h"
#include "AMP/mesh/loadBalance/loadBalanceSimulator.h"
 
namespace AMP::Mesh {
 
 
class MultiMesh final : public Mesh
{
public:
    explicit MultiMesh( std::shared_ptr<const MeshParameters> params );
 
 
    MultiMesh( const std::string &name,
               const AMP_MPI &comm,
               const std::vector<std::shared_ptr<Mesh>> &meshes,
               bool checkComm = true );
 
 
    virtual ~MultiMesh();
 
 
    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.
     * Note: for a multimesh this will require global communication.
     * To avoid this in the future we would need to cache the value, and register
     *  some type of listener to check if the value changed on any sub meshes.
     * \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
     */
    size_t numGhostElements( const GeomType type, const int gcw ) const override;
 
 
    std::shared_ptr<Mesh> Subset( MeshID meshID ) const override;
 
 
    virtual std::shared_ptr<Mesh> Subset( const MeshIterator &iterator,
                                          bool isGlobal = true ) const override;
 
 
    std::shared_ptr<Mesh> Subset( std::string name ) 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;
 
 
    bool isMember( const MeshElementID &id ) const override;
 
 
    MeshIterator isMember( const MeshIterator &it ) const override;
 
 
    MeshElementPtr getElement( const MeshElementID &id ) const override;
 
 
    virtual ElementListPtr getElementParents( const MeshElement &elem,
                                              const GeomType type ) const override;
 
 
    inline bool isBaseMesh() const override { return false; }
 
 
    bool operator==( const Mesh &mesh ) const override;
 
 
    std::vector<MeshID> getAllMeshIDs() const override;
 
 
    std::vector<MeshID> getBaseMeshIDs() const override;
 
 
    std::vector<MeshID> getLocalMeshIDs() const override;
 
 
    std::vector<MeshID> getLocalBaseMeshIDs() const override;
 
 
    bool containsElement( const MeshElementID &id ) const override;
 
 
    virtual std::vector<std::shared_ptr<AMP::Mesh::Mesh>> getMeshes();
 
 
    virtual std::vector<std::shared_ptr<const AMP::Mesh::Mesh>> getMeshes() const;
 
 
    Mesh::Movable isMeshMovable() const override;
 
 
    uint64_t positionHash() const override;
 
 
    void displaceMesh( const std::vector<double> &x ) override;
 
    void displaceMesh( std::shared_ptr<const AMP::LinearAlgebra::Vector> x ) override;
 
 
    // Needed to prevent problems with virtual functions
    using Mesh::Subset;
 
 
public: // Default constructors
    MultiMesh()                           = delete;
    explicit MultiMesh( MultiMesh &&rhs ) = default;
    explicit MultiMesh( const MultiMesh &rhs );
    MultiMesh &operator=( MultiMesh &&rhs ) = delete;
    MultiMesh &operator=( const MultiMesh &rhs ) = delete;
 
public: // Functions to help with load balancing
    static std::vector<AMP_MPI> createComms( const AMP_MPI &comm,
                                             const std::vector<std::vector<int>> &groups );
 
 
public:
    static std::vector<std::shared_ptr<AMP::Database>>
    createDatabases( std::shared_ptr<const AMP::Database> database );
 
 
public: // Write/read restart data
    void registerChildObjects( AMP::IO::RestartManager *manager ) const override;
    void writeRestart( int64_t ) const override;
    MultiMesh( int64_t, AMP::IO::RestartManager * );
 
 
private:
    void initialize();
 
private:
    std::vector<std::shared_ptr<Mesh>> d_meshes;       
    Mesh::Movable d_isMovable = Mesh::Movable::Deform; 
};
 
} // namespace AMP::Mesh
 
#endif