VectorSelector.h

Go to the documentation of this file.

#ifndef included_AMP_VectorSelector_h
#define included_AMP_VectorSelector_h
 
#include "AMP/mesh/Mesh.h"
#include "AMP/mesh/MeshIterator.h"
#include "AMP/vectors/Vector.h"
 
 
namespace AMP::LinearAlgebra {
 
 
class VectorSelector
{
public:
    virtual ~VectorSelector();
 
    virtual bool isSelected( const Vector &vec ) const = 0;
 
    virtual AMP_MPI communicator( const Vector &vec ) const;
 
    virtual std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const = 0;
 
    std::shared_ptr<const Vector> subset( std::shared_ptr<const Vector> vec ) const;
 
 
    static std::shared_ptr<VectorSelector>
    create( const std::vector<std::shared_ptr<VectorSelector>> &selectors );
};
 
 
class VS_ByVariableName : public VectorSelector
{
protected:
    std::string d_VecName;
 
public:
    VS_ByVariableName( std::string name );
 
    const std::string &getName() const { return d_VecName; };
 
public: // Functions inherited from VectorSelector
    virtual bool isSelected( const Vector &v ) const override;
    virtual std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const override;
    using VectorSelector::subset;
};
 
 
class VS_Stride : public VectorSelector
{
public:
    explicit VS_Stride( size_t offset, size_t length );
 
public: // Functions inherited from VectorSelector
    virtual bool isSelected( const Vector &v ) const override;
    virtual std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const override;
    using VectorSelector::subset;
 
protected:
    size_t d_Offset; // Offset to start striding on
    size_t d_Stride; // The stride to use
};
 
 
class VS_Components : public VectorSelector
{
public:
    VS_Components( size_t index );
 
    explicit VS_Components( std::vector<size_t> index );
 
    inline const auto &getIndices() const { return d_index; }
 
public: // Functions inherited from VectorSelector
    virtual bool isSelected( const Vector &v ) const override;
    virtual std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const override;
    using VectorSelector::subset;
 
protected:
    std::vector<size_t> d_index; // Index to select
};
 
 
class VS_Comm : public VectorSelector
{
public:
    explicit VS_Comm( const AMP_MPI &comm );
 
public: // Functions inherited from VectorSelector
    virtual bool isSelected( const Vector &v ) const override;
    virtual std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const override;
    using VectorSelector::subset;
    virtual AMP_MPI communicator( const Vector &vec ) const override;
 
protected:
    std::string d_Name; //  The name of this subset
    AMP_MPI d_comm;     // The new desired comm
};
 
 
class VS_Mesh : public VectorSelector
{
public:
    explicit VS_Mesh( std::shared_ptr<const AMP::Mesh::Mesh> mesh, bool useMeshComm = true );
 
public: // Functions inherited from VectorSelector
    virtual bool isSelected( const Vector &v ) const override;
    virtual std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const override;
    using VectorSelector::subset;
    virtual AMP_MPI communicator( const Vector &vec ) const override;
 
protected:
    bool d_useMeshComm;                            // Use the comm of the mesh
    std::shared_ptr<const AMP::Mesh::Mesh> d_mesh; // Mesh
};
 
 
class VS_MeshIterator : public VectorSelector
{
public:
    explicit VS_MeshIterator( const AMP::Mesh::MeshIterator &iterator, const AMP::AMP_MPI &comm );
 
public: // Functions inherited from VectorSelector
    virtual bool isSelected( const Vector &v ) const override;
    virtual std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const override;
    using VectorSelector::subset;
 
protected:
    const AMP_MPI d_comm;                // comm for the subset
    const Mesh::MeshIterator d_iterator; //  MeshIterator
};
 
 
class NullSelector : public VectorSelector
{
public:
    bool isSelected( const Vector & ) const override { return true; }
    std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const override { return vec; }
};
 
 
class MultiSelector : public VectorSelector
{
public:
    MultiSelector( const std::vector<std::shared_ptr<VectorSelector>> &selectors );
    bool isSelected( const Vector & ) const override;
    std::shared_ptr<Vector> subset( std::shared_ptr<Vector> vec ) const override;
    using VectorSelector::subset;
 
private:
    std::vector<std::shared_ptr<VectorSelector>> d_selectors;
};
 
 
} // namespace AMP::LinearAlgebra
 
 
#endif