MultiVector.h

Go to the documentation of this file.

#ifndef included_AMP_MultiVector
#define included_AMP_MultiVector
 
 
#include "AMP/vectors/Vector.h"
 
 
namespace AMP::LinearAlgebra {
 
 
class MultiVector final : public Vector
{
public: // Create and view functions
    static std::shared_ptr<MultiVector> create( std::shared_ptr<Variable> name,
                                                const AMP_MPI &comm );
 
    static std::shared_ptr<MultiVector> create( const std::string &name, const AMP_MPI &comm );
 
    static std::shared_ptr<MultiVector> create( std::shared_ptr<Variable> name,
                                                const AMP_MPI &comm,
                                                const std::vector<Vector::shared_ptr> &vecs );
 
    static std::shared_ptr<MultiVector> create( const std::string &name,
                                                const AMP_MPI &comm,
                                                const std::vector<Vector::shared_ptr> &vecs );
 
    static std::shared_ptr<const MultiVector>
    const_create( std::shared_ptr<Variable> name,
                  const AMP_MPI &comm,
                  const std::vector<Vector::const_shared_ptr> &vecs );
 
    static std::shared_ptr<const MultiVector>
    const_create( const std::string &name,
                  const AMP_MPI &comm,
                  const std::vector<Vector::const_shared_ptr> &vecs );
 
    static std::shared_ptr<MultiVector> view( Vector::shared_ptr vec,
                                              const AMP_MPI &comm = AMP_COMM_NULL );
 
    static std::shared_ptr<const MultiVector> constView( Vector::const_shared_ptr vec,
                                                         const AMP_MPI &comm = AMP_COMM_NULL );
 
 
public:
    inline auto begin() { return d_vVectors.begin(); }
 
    inline auto begin() const { return d_vVectors.begin(); }
 
    inline auto end() { return d_vVectors.end(); }
 
    inline auto end() const { return d_vVectors.end(); }
 
    inline const std::vector<std::shared_ptr<Vector>> &getVecs() { return d_vVectors; }
 
    std::vector<std::shared_ptr<const Vector>> getVecs() const;
 
 
    bool containsPointer( const Vector::shared_ptr p ) const;
 
 
    virtual void replaceSubVector( Vector::shared_ptr oldVec, Vector::shared_ptr newVec );
 
    virtual void addVector( Vector::shared_ptr vec );
 
    virtual void addVector( std::vector<Vector::shared_ptr> vec );
 
    virtual void eraseVector( Vector::shared_ptr vec );
 
    virtual Vector::shared_ptr getVector( size_t i );
 
    virtual Vector::const_shared_ptr getVector( size_t i ) const;
 
    size_t getNumberOfSubvectors() const;
 
    std::string type() const override;
 
    std::unique_ptr<Vector> rawClone() const override;
 
    void swapVectors( Vector &other ) override;
 
    void reset() override;
 
public: // Write/read restart data
    void registerChildObjects( AMP::IO::RestartManager *manager ) const override;
 
    void writeRestart( int64_t fid ) const override;
 
    MultiVector( int64_t fid, AMP::IO::RestartManager *manager );
 
 
public: // public constructor/destructors
    explicit MultiVector( const std::string &name, const AMP_MPI &comm );
 
    explicit MultiVector( const std::string &name,
                          const AMP_MPI &comm,
                          const std::vector<Vector::shared_ptr> &vecs );
 
    explicit MultiVector( std::shared_ptr<Vector> vec );
 
 
public: // default constructor/destructors
    MultiVector()                      = default;
    MultiVector( MultiVector && )      = delete;
    MultiVector( const MultiVector & ) = delete;
    MultiVector &operator=( MultiVector && ) = delete;
    MultiVector &operator=( const MultiVector & ) = delete;
    virtual ~MultiVector();
 
 
protected:
    Vector::shared_ptr selectInto( const VectorSelector & ) override;
    Vector::const_shared_ptr selectInto( const VectorSelector &criterion ) const override;
 
    const Vector::shared_ptr &getVector( const Vector &vec, size_t which ) const;
 
    Vector::shared_ptr &getVector( Vector &vec, size_t which ) const;
 
 
protected:
    std::vector<Vector::shared_ptr> d_vVectors;
 
 
private:
    // Helper function to add a vector without updating the DOF manager
    void addVectorHelper( Vector::shared_ptr vec );
 
    // Helper function to reset the vector data
    inline void resetVectorData();
 
    // Helper function to reset the vector operations
    inline void resetVectorOperations();
};
 
 
} // namespace AMP::LinearAlgebra
 
 
#endif