Vector.h

Go to the documentation of this file.

#ifndef included_AMP_Vector
#define included_AMP_Vector
 
#include "AMP/utils/Units.h"
#include "AMP/utils/Utilities.h"
#include "AMP/utils/enable_shared_from_this.h"
#include "AMP/vectors/Variable.h"
#include "AMP/vectors/data/VectorData.h"
#include "AMP/vectors/operations/VectorOperations.h"
 
#include <iosfwd>
#include <memory>
#include <string>
 
 
namespace AMP::Discretization {
class DOFManager;
}
namespace AMP::IO {
class RestartManager;
}
 
 
namespace AMP::LinearAlgebra {
 
 
class VectorSelector;
 
 
class Vector : public AMP::enable_shared_from_this<Vector>
{
 
public: // typedefs
    typedef std::shared_ptr<Vector> shared_ptr;
 
    typedef std::shared_ptr<const Vector> const_shared_ptr;
 
 
public: // Constructor/destructors
    Vector();
 
    explicit Vector( const std::string &name );
 
    Vector( std::shared_ptr<VectorData> data,
            std::shared_ptr<VectorOperations> ops,
            std::shared_ptr<Variable> var,
            std::shared_ptr<AMP::Discretization::DOFManager> DOFManager );
 
    Vector( const Vector & ) = delete;
 
    void operator=( const Vector & ) = delete;
 
    virtual ~Vector();
 
 
public: // Virtual functions
    virtual std::string type() const;
 
 
    virtual std::unique_ptr<Vector> rawClone() const;
 
    virtual void swapVectors( Vector &other );
 
    virtual Vector::shared_ptr selectInto( const VectorSelector &criterion );
 
    // This is the const version of selectInto.
    virtual Vector::const_shared_ptr selectInto( const VectorSelector &criterion ) const;
 
    virtual void copyVector( std::shared_ptr<const Vector> x )
    {
        AMP_ASSERT( x );
        if ( x.get() == this )
            return;
        d_VectorOps->copy( *( x->getVectorData() ), *d_VectorData );
    }
 
 
public: // the next set of functions defines the public math. interface for vectors
    void copy( const Vector &x );
 
    void zero();
 
    void setToScalar( const Scalar &alpha );
 
    void setRandomValues();
 
    void scale( const Scalar &alpha, const Vector &x );
 
    void scale( const Scalar &alpha );
 
    void add( const Vector &x, const Vector &y );
 
    void subtract( const Vector &x, const Vector &y );
 
    void multiply( const Vector &x, const Vector &y );
 
    void divide( const Vector &x, const Vector &y );
 
    void reciprocal( const Vector &x );
 
    void linearSum( const Scalar &alpha, const Vector &x, const Scalar &beta, const Vector &y );
 
    void axpy( const Scalar &alpha, const Vector &x, const Vector &y );
 
    void axpby( const Scalar &alpha, const Scalar &beta, const Vector &x );
 
    void abs( const Vector &x );
 
    void addScalar( const Vector &x, const Scalar &alpha );
 
    void setMax( const Scalar &val );
 
    void setMin( const Scalar &val );
 
    Scalar min() const;
 
    Scalar max() const;
 
    Scalar sum() const;
 
    Scalar mean() const;
 
    Scalar L1Norm() const;
 
    Scalar L2Norm() const;
 
    Scalar maxNorm() const;
    Scalar minQuotient( const Vector &x ) const;
 
    Scalar wrmsNorm( const Vector &x, const Vector &y ) const;
 
    Scalar wrmsNormMask( const Vector &x, const Vector &mask, const Vector &y ) const;
 
    Scalar dot( const Vector &x ) const;
 
    std::pair<Scalar, Scalar> L2NormAndDot( const Vector &x ) const;
 
    bool equals( const Vector &x, const Scalar &tol = 1e-6 ) const;
 
 
public: // Clone vectors
    std::shared_ptr<Vector> clone() const;
 
    std::shared_ptr<Vector> clone( const std::string &name ) const;
 
    std::shared_ptr<Vector> clone( const std::shared_ptr<Variable> name ) const;
 
 
public: // Up/down-cast vectors
    void copyCast( std::shared_ptr<const Vector> x );
 
public: // Get/Set data/variables/operations
    inline auto &getUnits() const { return d_units; }
 
    virtual void setUnits( AMP::Units );
 
    inline std::shared_ptr<AMP::Discretization::DOFManager> getDOFManager() const;
 
    std::shared_ptr<VectorData> getVectorData() { return d_VectorData; }
 
    std::shared_ptr<const VectorData> getVectorData() const { return d_VectorData; }
 
    std::shared_ptr<VectorOperations> getVectorOperations() { return d_VectorOps; }
 
    std::shared_ptr<const VectorOperations> getVectorOperations() const { return d_VectorOps; }
 
    void setVariable( const std::shared_ptr<Variable> name );
 
    const std::shared_ptr<Variable> getVariable() const;
 
    std::shared_ptr<Variable> getVariable();
 
    size_t getNumberOfComponents() const;
 
    std::string getName() const;
 
    void setName( const std::string &name );
 
    virtual void rename( const std::string &src, const std::string &dst );
 
    virtual void reset();
 
public: // Subset/Select
    shared_ptr select( const VectorSelector &criterion );
 
    const_shared_ptr select( const VectorSelector &criterion ) const;
 
    Vector::shared_ptr subsetVectorForVariable( const std::string &name );
 
    Vector::const_shared_ptr subsetVectorForVariable( const std::string &name ) const;
 
    Vector::shared_ptr subsetVectorForVariable( std::shared_ptr<const Variable> var );
 
    Vector::const_shared_ptr subsetVectorForVariable( std::shared_ptr<const Variable> var ) const;
 
    Vector::shared_ptr subsetVectorForComponent( size_t index );
 
    Vector::const_shared_ptr subsetVectorForComponent( size_t index ) const;
 
    void swapVectors( Vector::shared_ptr other );
 
    template<typename VIEW_TYPE>
    std::shared_ptr<VIEW_TYPE> getView() const;
 
    template<typename VIEW_TYPE>
    bool hasView() const;
 
    template<typename VIEW_TYPE>
    void registerView( std::shared_ptr<VIEW_TYPE> v ) const;
 
 
public: // Iterators/Data
    template<class TYPE = double>
    inline VectorDataIterator<TYPE> begin()
    {
        return d_VectorData->begin<TYPE>();
    }
 
    template<class TYPE = double>
    inline VectorDataIterator<const TYPE> begin() const
    {
        return d_VectorData->begin<const TYPE>();
    }
 
    template<class TYPE = double>
    inline VectorDataIterator<const TYPE> constBegin() const
    {
        return d_VectorData->constBegin<const TYPE>();
    }
 
    template<class TYPE = double>
    inline VectorDataIterator<TYPE> end()
    {
        return d_VectorData->end<TYPE>();
    }
 
    template<class TYPE = double>
    inline VectorDataIterator<const TYPE> end() const
    {
        return d_VectorData->end<const TYPE>();
    }
 
    template<class TYPE = double>
    inline VectorDataIterator<const TYPE> constEnd() const
    {
        return d_VectorData->constEnd<const TYPE>();
    }
 
    template<typename RETURN_TYPE>
    inline RETURN_TYPE *getRawDataBlock( size_t i = 0 )
    {
        return d_VectorData->getRawDataBlock<RETURN_TYPE>( i );
    }
 
    template<typename RETURN_TYPE>
    inline const RETURN_TYPE *getRawDataBlock( size_t i = 0 ) const
    {
        return d_VectorData->getRawDataBlock<RETURN_TYPE>( i );
    }
 
 
public: // VectorData operations
    inline bool hasComm() const { return !d_VectorData->getComm().isNull(); }
    inline const AMP_MPI &getComm() const { return d_VectorData->getComm(); }
    inline std::string VectorDataName() const { return d_VectorData->VectorDataName(); }
    inline size_t numberOfDataBlocks() const { return d_VectorData->numberOfDataBlocks(); }
    inline size_t sizeOfDataBlock( size_t i = 0 ) const
    {
        return d_VectorData->sizeOfDataBlock( i );
    }
    template<class TYPE>
    inline void putRawData( const TYPE *buf )
    {
        d_VectorData->putRawData( buf );
    }
    template<class TYPE>
    inline void getRawData( TYPE *buf ) const
    {
        d_VectorData->getRawData( buf );
    }
    inline size_t getLocalSize() const { return d_VectorData->getLocalSize(); }
    inline size_t getGlobalSize() const { return d_VectorData->getGlobalSize(); }
    inline size_t getLocalStartID() const { return d_VectorData->getLocalStartID(); }
    template<class TYPE>
    inline void setValuesByLocalID( int num, size_t *indices, const TYPE *vals )
    {
        d_VectorData->setValuesByLocalID( num, indices, vals );
    }
    template<class TYPE>
    inline void addValuesByLocalID( int num, size_t *indices, const TYPE *vals )
    {
        d_VectorData->addValuesByLocalID( num, indices, vals );
    }
    inline uint64_t getDataID() const { return d_VectorData->getDataID(); }
    inline void *getRawDataBlockAsVoid( size_t i )
    {
        return d_VectorData->getRawDataBlockAsVoid( i );
    }
    inline const void *getRawDataBlockAsVoid( size_t i ) const
    {
        return d_VectorData->getRawDataBlockAsVoid( i );
    }
    inline size_t sizeofDataBlockType( size_t i ) const
    {
        return d_VectorData->sizeofDataBlockType( i );
    }
    template<typename TYPE>
    inline bool isType( size_t block ) const
    {
        constexpr auto type = getTypeID<TYPE>();
        return d_VectorData->isType( type, block );
    }
    inline void swapData( VectorData &rhs ) { d_VectorData->swapData( rhs ); }
    inline std::shared_ptr<VectorData> cloneData() const { return d_VectorData->cloneData(); }
    inline AMP::LinearAlgebra::UpdateState getUpdateStatus() const
    {
        return d_VectorData->getLocalUpdateStatus();
    }
    inline void setUpdateStatus( AMP::LinearAlgebra::UpdateState state )
    {
        d_VectorData->setUpdateStatus( state );
    }
    inline void makeConsistent() { d_VectorData->makeConsistent(); }
    inline void makeConsistent( AMP::LinearAlgebra::ScatterType t )
    {
        d_VectorData->makeConsistent( t );
    }
    inline std::shared_ptr<CommunicationList> getCommunicationList() const
    {
        return d_VectorData->getCommunicationList();
    }
    inline void setCommunicationList( std::shared_ptr<CommunicationList> comm )
    {
        d_VectorData->setCommunicationList( comm );
    }
    inline void dataChanged() { return d_VectorData->dataChanged(); }
 
    inline size_t getGhostSize() const { return d_VectorData->getGhostSize(); }
    template<typename TYPE>
    inline void setGhostValuesByGlobalID( int num, const size_t *indices, const TYPE *vals )
    {
        d_VectorData->setGhostValuesByGlobalID( num, indices, vals );
    }
    template<typename TYPE>
    inline void addGhostValuesByGlobalID( int num, const size_t *indices, const TYPE *vals )
    {
        d_VectorData->addGhostValuesByGlobalID( num, indices, vals );
    }
    template<typename TYPE>
    inline void setValuesByGlobalID( int num, const size_t *indices, const TYPE *vals )
    {
        d_VectorData->setValuesByGlobalID( num, indices, vals );
    }
    template<typename TYPE>
    inline void addValuesByGlobalID( int num, const size_t *indices, const TYPE *vals )
    {
        d_VectorData->addValuesByGlobalID( num, indices, vals );
    }
    template<typename TYPE>
    inline void getValuesByGlobalID( int num, const size_t *indices, TYPE *vals ) const
    {
        d_VectorData->getValuesByGlobalID( num, indices, vals );
    }
    template<typename TYPE>
    inline void getGhostValuesByGlobalID( int num, const size_t *indices, TYPE *vals ) const
    {
        d_VectorData->getGhostValuesByGlobalID( num, indices, vals );
    }
    template<typename TYPE>
    inline void getValuesByLocalID( int num, const size_t *indices, TYPE *vals ) const
    {
        d_VectorData->getValuesByLocalID( num, indices, vals );
    }
 
    inline bool containsGlobalElement( size_t id )
    {
        return d_VectorData->containsGlobalElement( id );
    }
 
    inline void dumpOwnedData( std::ostream &out, size_t GIDoffset = 0, size_t LIDoffset = 0 ) const
    {
        d_VectorData->dumpOwnedData( out, GIDoffset, LIDoffset );
    }
    inline void dumpGhostedData( std::ostream &out, size_t offset = 0 ) const
    {
        d_VectorData->dumpGhostedData( out, offset );
    }
 
    inline void setNoGhosts() { d_VectorData->setNoGhosts(); }
 
    AMP::Utilities::MemoryType getMemoryLocation() const
    {
        return d_VectorData->getMemoryLocation();
    }
 
public: // Get values
    template<typename TYPE = double>
    TYPE getValueByGlobalID( size_t i ) const;
 
    template<typename TYPE = double>
    TYPE getLocalValueByGlobalID( size_t i ) const;
 
    template<typename TYPE = double>
    TYPE getGhostValueByGlobalID( size_t i ) const;
 
    template<typename TYPE = double>
    TYPE getValueByLocalID( size_t i ) const;
 
 
public: // Set values
    template<typename TYPE>
    void setValueByGlobalID( size_t i, TYPE v );
 
 
public:
    uint64_t getID() const;
 
 
public: // Write/read restart data
    virtual void registerChildObjects( AMP::IO::RestartManager *manager ) const;
 
    virtual void writeRestart( int64_t fid ) const;
 
    Vector( int64_t fid, AMP::IO::RestartManager *manager );
 
 
protected:                                                         // Internal data
    AMP::Units d_units;                                            // Optional units for the data
    std::shared_ptr<Variable> d_Variable;                          // Variable
    std::shared_ptr<AMP::Discretization::DOFManager> d_DOFManager; // The DOF_Manager
    std::shared_ptr<VectorData> d_VectorData;                      // Pointer to data
    std::shared_ptr<VectorOperations> d_VectorOps;                 // Pointer to a VectorOperations
    std::shared_ptr<std::vector<std::any>> d_Views;                // Views of the vector
};
 
 
std::ostream &operator<<( std::ostream &out, const Vector::shared_ptr );
std::ostream &operator<<( std::ostream &out, const Vector & );
 
 
} // namespace AMP::LinearAlgebra
 
#include "AMP/vectors/Vector.inline.h"
 
#endif