Mesh.h

Go to the documentation of this file.

#ifndef included_AMP_Mesh
#define included_AMP_Mesh
 
#include "AMP/mesh/MeshID.h"
#include "AMP/mesh/MeshIterator.h"
#include "AMP/mesh/MeshParameters.h"
#include "AMP/utils/AMP_MPI.h"
#include "AMP/utils/Database.h"
#include "AMP/utils/enable_shared_from_this.h"
 
#include <iostream>
#include <memory>
 
 
// Forward declarations
namespace AMP::Geometry {
class Geometry;
}
namespace AMP::LinearAlgebra {
class Vector;
}
namespace AMP::IO {
class RestartManager;
}
 
 
namespace AMP::Mesh {
 
 
class MeshElementVectorBase;
 
 
enum class SetOP { Union, Intersection, Complement };
 
 
class Mesh : public AMP::enable_shared_from_this<AMP::Mesh::Mesh>
{
public:
    typedef std::function<std::shared_ptr<Mesh>( std::shared_ptr<const MeshParameters> )>
        generatorType;
 
    using MeshElementPtr = std::unique_ptr<MeshElement>;
    using ElementListPtr = MeshElementVectorPtr;
 
    enum class Movable : uint8_t { Fixed = 0, Displace = 1, Deform = 2 };
 
 
    explicit Mesh( std::shared_ptr<const MeshParameters> params );
 
 
    Mesh( const std::shared_ptr<Mesh> &old_mesh, MeshIterator &iterator );
 
 
    inline auto getGeometry() { return d_geometry; }
 
 
    inline auto getGeometry() const { return d_geometry; }
 
 
    static size_t estimateMeshSize( std::shared_ptr<const MeshParameters> params );
 
 
    static size_t maxProcs( std::shared_ptr<const MeshParameters> params );
 
 
    virtual ~Mesh();
 
 
    virtual std::unique_ptr<Mesh> clone() const = 0;
 
 
    virtual std::string meshClass() const = 0;
 
 
    virtual std::shared_ptr<Mesh> Subset( MeshID meshID ) const;
 
 
    virtual std::shared_ptr<Mesh> Subset( std::string name ) const;
 
 
    virtual std::shared_ptr<Mesh> Subset( const MeshIterator &iterator,
                                          bool isGlobal = true ) const;
 
 
    virtual std::shared_ptr<Mesh> Subset( Mesh &mesh ) const;
 
 
    /* Return the number of local element of the given type
     * \param type   Geometric type
     */
    virtual size_t numLocalElements( const GeomType type ) const;
 
 
    /* Return the global number of elements of the given type
     * Note: depending on the mesh this routine may require global communication across the mesh.
     * \param type   Geometric type
     */
    virtual size_t numGlobalElements( const GeomType type ) const;
 
 
    /* Return the number of ghost elements of the given type on the current processor
     * \param type   Geometric type
     */
    virtual size_t numGhostElements( const GeomType type, const int gcw ) const;
 
 
    virtual MeshIterator getIterator( const GeomType type, const int gcw = 0 ) const;
 
 
    virtual MeshIterator getSurfaceIterator( const GeomType type, const int gcw = 0 ) const;
 
 
    virtual std::vector<int> getBoundaryIDs() const;
 
 
    virtual MeshIterator
    getBoundaryIDIterator( const GeomType type, const int id, const int gcw = 0 ) const;
 
    virtual std::vector<int> getBlockIDs() const;
 
 
    virtual MeshIterator
    getBlockIDIterator( const GeomType type, const int id, const int gcw = 0 ) const;
 
 
    static MeshIterator getIterator( SetOP OP, const MeshIterator &A, const MeshIterator &B );
    static MeshIterator getIterator( SetOP OP, const MeshIterator &, MeshIteratorEnd );
    static MeshIterator getIterator( SetOP OP, MeshIteratorEnd, const MeshIterator & );
    static MeshIterator getIterator( SetOP OP, MeshIteratorEnd, MeshIteratorEnd );
 
 
    virtual bool isMember( const MeshElementID &id ) const;
 
 
    virtual MeshIterator isMember( const MeshIterator &it ) const;
 
 
    virtual MeshElementPtr getElement( const MeshElementID &id ) const;
 
 
    virtual ElementListPtr getElementParents( const MeshElement &elem, const GeomType type ) const;
 
 
    inline GeomType getGeomType() const { return GeomDim; }
 
 
    inline uint8_t getDim() const { return PhysicalDim; }
 
 
    inline const AMP_MPI &getComm() const { return d_comm; }
 
 
    inline uint8_t getMaxGhostWidth() const { return d_max_gcw; }
 
 
    inline MeshID meshID() const { return d_meshID; }
 
 
    virtual bool isBaseMesh() const;
 
 
    virtual bool operator==( const Mesh &mesh ) const = 0;
 
 
    inline bool operator!=( const Mesh &mesh ) const { return !operator==( mesh ); }
 
 
    virtual std::vector<MeshID> getAllMeshIDs() const;
 
 
    virtual std::vector<MeshID> getBaseMeshIDs() const;
 
 
    virtual std::vector<MeshID> getLocalMeshIDs() const;
 
 
    virtual std::vector<MeshID> getLocalBaseMeshIDs() const;
 
 
    virtual bool containsElement( const MeshElementID &id ) const;
 
 
    virtual inline std::string getName() const { return d_name; }
 
 
    virtual inline void setName( std::string name ) { d_name = name; }
 
 
    inline const auto &getBoundingBox() const { return d_box; }
 
 
    inline const auto &getLocalBoundingBox() const { return d_box_local; }
 
 
    virtual Movable isMeshMovable() const = 0;
 
 
    virtual uint64_t positionHash() const = 0;
 
 
    virtual void displaceMesh( const std::vector<double> &x ) = 0;
 
 
    virtual void displaceMesh( std::shared_ptr<const AMP::LinearAlgebra::Vector> x ) = 0;
 
 
    virtual std::shared_ptr<AMP::LinearAlgebra::Vector>
    getPositionVector( std::string name, const int gcw = 0 ) const;
 
 
    static std::shared_ptr<Mesh> createView( const Mesh &mesh, const AMP::Database &db );
 
 
    static void printMeshHierarchy( const Mesh &mesh,
                                    std::ostream &out         = std::cout,
                                    const std::string &prefix = "" );
 
 
public:
    struct CompareResult {
        bool equal;         
        bool nodes;         
        bool surface;       
        bool block;         
        bool domain;        
        bool geometry;      
        int result() const; 
        CompareResult( int state = 0 );
        bool operator==( const CompareResult & ) const;
    };
 
    static CompareResult compare( const Mesh &a, const Mesh &b );
 
 
public: // Write/read restart data
    virtual void registerChildObjects( AMP::IO::RestartManager *manager ) const;
 
    virtual void writeRestart( int64_t fid ) const;
 
protected:
    Mesh( int64_t fid, AMP::IO::RestartManager *manager );
 
    static std::vector<double> reduceBox( const std::vector<double> &, const AMP_MPI & );
 
    void setMeshID();
 
protected:
    Mesh();
 
    // Private copy constructor
    explicit Mesh( const Mesh &old );
 
    // Private assigment operator
    Mesh &operator=( const Mesh &old ) = delete;
 
protected:
    GeomType GeomDim;                
    uint8_t PhysicalDim;             
    uint8_t d_max_gcw;               
    MeshID d_meshID;                 
    AMP_MPI d_comm;                  
    std::string d_name;              
    std::vector<double> d_box;       
    std::vector<double> d_box_local; 
    std::shared_ptr<Geometry::Geometry> d_geometry; 
};
 
} // namespace AMP::Mesh
 
#endif