SubsetMesh.h

Go to the documentation of this file.

#ifndef included_AMP_SubsetMesh
#define included_AMP_SubsetMesh
 
#include "AMP/mesh/Mesh.h"
 
#include <memory>
 
#include <map>
 
namespace AMP::Mesh {
 
 
class SubsetMesh : public Mesh
{
public:
    static std::shared_ptr<Mesh> create( std::shared_ptr<const Mesh> mesh,
                                         const AMP::Mesh::MeshIterator &iterator,
                                         bool isGlobal );
 
 
    virtual ~SubsetMesh();
 
 
    std::shared_ptr<Mesh> Subset( MeshID meshID ) const override;
 
 
    std::shared_ptr<Mesh> Subset( std::string name ) const override;
 
 
    std::string meshClass() const override;
 
 
    std::unique_ptr<Mesh> clone() const override;
 
 
    /* 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: depending on the mesh this routine may require global communication across the mesh.
     * \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;
 
 
    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;
 
 
    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;
 
 
    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;
 
 
    void writeRestart( int64_t fid ) const override;
 
 
    // Needed to prevent problems with virtual functions
    using Mesh::Subset;
 
 
protected:
    SubsetMesh( std::shared_ptr<const Mesh> mesh,
                const AMP::Mesh::MeshIterator &iterator,
                bool isGlobal );
 
 
protected:
    using ElementList    = std::vector<std::unique_ptr<MeshElement>>;
    using ElementListPtr = std::shared_ptr<ElementList>;
 
    // Data to store the id sets
    struct map_id_struct {
        int id;
        GeomType type;
        int gcw;
        inline bool operator==( const map_id_struct &rhs ) const
        {
            return id == rhs.id && type == rhs.type && gcw == rhs.gcw;
        }
        inline bool operator!=( const map_id_struct &rhs ) const
        {
            return id != rhs.id && type != rhs.type && gcw != rhs.gcw;
        }
        inline bool operator>=( const map_id_struct &rhs ) const
        {
            if ( id != rhs.id ) {
                return id > rhs.id;
            }
            if ( type != rhs.type ) {
                return type > rhs.type;
            }
            return gcw >= rhs.gcw;
        }
        inline bool operator>( const map_id_struct &rhs ) const
        {
            if ( id != rhs.id ) {
                return id > rhs.id;
            }
            if ( type != rhs.type ) {
                return type > rhs.type;
            }
            return gcw > rhs.gcw;
        }
        inline bool operator<( const map_id_struct &rhs ) const { return !operator>=( rhs ); }
        inline bool operator<=( const map_id_struct &rhs ) const { return !operator>( rhs ); }
    };
 
 
protected:                                               // Member data
    std::shared_ptr<const Mesh> d_parentMesh;            // Parent mesh for the subset
    MeshID d_parentMeshID;                               // Parent mesh id
    std::vector<size_t> N_global;                        // Number of global elements
    std::vector<std::vector<ElementListPtr>> d_elements; // Elements in the subset [type][gcw][elem]
    std::vector<std::vector<ElementListPtr>> d_surface; // Elements on the surface [type][gcw][elem]
    std::vector<int> d_boundaryIdSets;
    std::map<map_id_struct, ElementListPtr> d_boundarySets;
    std::vector<int> d_blockIdSets;
    std::map<map_id_struct, ElementListPtr> d_blockSets;
};
 
} // namespace AMP::Mesh
 
#endif