VectorData.h

Go to the documentation of this file.

#ifndef included_AMP_VectorData
#define included_AMP_VectorData
 
#include "AMP/utils/AMP_MPI.h"
#include "AMP/utils/enable_shared_from_this.h"
#include "AMP/utils/typeid.h"
#include "AMP/vectors/Scalar.h"
#include "AMP/vectors/Variable.h"
#include "AMP/vectors/data/DataChangeFirer.h"
 
#include <memory>
 
 
namespace AMP::IO {
class RestartManager;
}
 
 
namespace AMP::LinearAlgebra {
 
 
// Forward declares
class CommunicationList;
template<typename TYPE>
class VectorDataIterator;
 
 
class VectorData : public DataChangeFirer, public AMP::enable_shared_from_this<VectorData>
{
public: // Get basic information
    virtual ~VectorData() {}
 
 
    virtual std::string VectorDataName() const = 0;
 
 
    virtual size_t numberOfDataBlocks() const = 0;
 
    virtual size_t sizeOfDataBlock( size_t i = 0 ) const = 0;
 
    inline size_t getLocalSize() const { return d_localSize; }
 
    inline size_t getGlobalSize() const { return d_globalSize; }
 
    inline size_t getLocalStartID() const { return d_localStart; }
 
    virtual std::vector<size_t> getLocalSizes() const;
 
    virtual size_t getGhostSize() const = 0;
 
    virtual bool hasGhosts() const = 0;
 
    virtual void fillGhosts( const Scalar &x ) = 0;
 
    virtual size_t getNumberOfComponents() const;
 
    virtual std::shared_ptr<VectorData> getComponent( size_t i = 0 );
 
    virtual std::shared_ptr<const VectorData> getComponent( size_t i = 0 ) const;
 
    virtual bool hasContiguousData() const { return true; }
 
public: // Get/Set data
    template<class TYPE>
    void putRawData( const TYPE *buf );
 
    template<class TYPE>
    void getRawData( TYPE *buf ) const;
 
    template<class TYPE>
    void setValuesByLocalID( size_t num, const size_t *indices, const TYPE *vals );
 
    template<class TYPE>
    void setGhostValuesByGlobalID( size_t num, const size_t *indices, const TYPE *vals );
 
    template<class TYPE>
    void setValuesByGlobalID( size_t num, const size_t *indices, const TYPE *vals );
 
    template<class TYPE>
    void addValuesByLocalID( size_t num, const size_t *indices, const TYPE *vals );
 
    template<class TYPE>
    void addValuesByGlobalID( size_t num, const size_t *indices, const TYPE *vals );
 
    template<class TYPE>
    void addGhostValuesByGlobalID( size_t num, const size_t *indices, const TYPE *vals );
 
 
    template<class TYPE>
    void getGhostAddValuesByGlobalID( size_t num, const size_t *indices, TYPE *vals ) const;
 
 
    template<class TYPE>
    void getValuesByLocalID( size_t num, const size_t *indices, TYPE *vals ) const;
 
    template<class TYPE>
    void getValuesByGlobalID( size_t num, const size_t *indices, TYPE *vals ) const;
 
    template<class TYPE>
    void getGhostValuesByGlobalID( size_t num, const size_t *indices, TYPE *vals ) const;
 
    template<class TYPE>
    size_t getAllGhostValues( TYPE *vals ) const;
 
 
public: // Advanced (virtual) get/set values
    virtual void putRawData( const void *buf, const typeID &id ) = 0;
 
    virtual void getRawData( void *buf, const typeID &id ) const = 0;
 
    virtual void
    setValuesByLocalID( size_t num, const size_t *indices, const void *vals, const typeID &id ) = 0;
 
    virtual void setGhostValuesByGlobalID( size_t num,
                                           const size_t *indices,
                                           const void *vals,
                                           const typeID &id ) = 0;
 
    virtual void
    addValuesByLocalID( size_t num, const size_t *indices, const void *vals, const typeID &id ) = 0;
 
    virtual void addGhostValuesByGlobalID( size_t num,
                                           const size_t *indices,
                                           const void *vals,
                                           const typeID &id ) = 0;
 
    virtual void getGhostAddValuesByGlobalID( size_t num,
                                              const size_t *indices,
                                              void *vals,
                                              const typeID &id ) const = 0;
 
 
    virtual void
    getValuesByLocalID( size_t num, const size_t *indices, void *vals, const typeID &id ) const = 0;
 
    virtual void getGhostValuesByGlobalID( size_t num,
                                           const size_t *indices,
                                           void *vals,
                                           const typeID &id ) const = 0;
    virtual size_t getAllGhostValues( void *vals, const typeID &id ) const = 0;
 
 
public: // Advanced functions
    virtual uint64_t getDataID() const = 0;
 
    virtual void *getRawDataBlockAsVoid( size_t i ) = 0;
 
    virtual const void *getRawDataBlockAsVoid( size_t i ) const = 0;
 
    virtual size_t sizeofDataBlockType( size_t i ) const = 0;
 
    virtual typeID getType( size_t block ) const = 0;
 
    inline bool isType( const typeID &id, size_t block ) const;
 
    virtual void swapData( VectorData &rhs ) = 0;
 
    virtual std::shared_ptr<VectorData> cloneData( const std::string &name = "" ) const = 0;
 
    virtual bool isAnAliasOf( const VectorData &rhs ) const;
 
    virtual void reset();
 
public:
    virtual void
    dumpOwnedData( std::ostream &out, size_t GIDoffset = 0, size_t LIDoffset = 0 ) const;
 
    virtual void dumpGhostedData( std::ostream &out, size_t offset = 0 ) const = 0;
 
public: // Virtual functions dealing with the update status
    virtual UpdateState getLocalUpdateStatus() const = 0;
 
 
    UpdateState getGlobalUpdateStatus() const;
 
 
    virtual void setUpdateStatus( UpdateState state ) = 0;
 
    virtual void makeConsistent( ScatterType t ) = 0;
 
    virtual void makeConsistent();
 
    virtual const AMP_MPI &getComm() const = 0;
 
    virtual std::shared_ptr<CommunicationList> getCommunicationList() const = 0;
 
    virtual void setCommunicationList( std::shared_ptr<CommunicationList> comm ) = 0;
 
    virtual void setNoGhosts();
 
    virtual AMP::Utilities::MemoryType getMemoryLocation() const
    {
        return AMP::Utilities::MemoryType::host;
    }
 
    virtual void
    print( std::ostream &os, const std::string &name = "A", const std::string &prefix = "" ) const;
 
public: // Non-virtual functions
    template<class TYPE = double>
    inline VectorDataIterator<TYPE> begin();
 
    template<class TYPE = double>
    inline VectorDataIterator<const TYPE> begin() const;
 
    template<class TYPE = double>
    inline VectorDataIterator<const TYPE> constBegin() const;
 
    template<class TYPE = double>
    inline VectorDataIterator<TYPE> end();
 
    template<class TYPE = double>
    inline VectorDataIterator<const TYPE> end() const;
 
    template<class TYPE = double>
    inline VectorDataIterator<const TYPE> constEnd() const;
 
    template<typename RETURN_TYPE>
    RETURN_TYPE *getRawDataBlock( size_t i = 0 );
 
    template<typename RETURN_TYPE>
    const RETURN_TYPE *getRawDataBlock( size_t i = 0 ) const;
 
    template<typename TYPE>
    bool isType() const;
 
    template<typename TYPE>
    bool isBlockType( size_t i = 0 ) const;
 
    virtual void copyGhostValues( const VectorData &rhs ) = 0;
 
 
public:
    virtual void dataChanged() = 0;
 
    /* \brief  Returns true if this vector has this element
     * \param[in]  GID  The global ID of the element
     */
    virtual bool containsGlobalElement( size_t GID ) const = 0;
 
    virtual void assemble() {}
 
 
public: // update status
    virtual std::shared_ptr<UpdateState> getUpdateStatusPtr() const = 0;
 
    virtual void setUpdateStatusPtr( std::shared_ptr<UpdateState> rhs ) = 0;
 
 
public: // Non virtual functions
    uint64_t getID() const;
 
 
public: // Write/read restart data
    virtual void registerChildObjects( AMP::IO::RestartManager *manager ) const;
 
    virtual void writeRestart( int64_t fid ) const;
 
    VectorData( int64_t fid, AMP::IO::RestartManager *manager );
 
protected:                   // Internal data
    size_t d_localSize  = 0; 
    size_t d_globalSize = 0; 
    size_t d_localStart = 0; 
 
    // Friends
    friend class VectorOperations;
 
 
public:
    VectorData()                     = default;
    VectorData( const VectorData & ) = delete;
};
 
 
} // namespace AMP::LinearAlgebra
 
 
#include "AMP/vectors/data/VectorData.inline.h"
 
 
#endif