MultiVectorData.h

Go to the documentation of this file.

#ifndef included_AMP_MultiVectorData
#define included_AMP_MultiVectorData
 
#include "AMP/discretization/DOF_Manager.h"
#include "AMP/discretization/MultiDOFHelper.h"
#include "AMP/vectors/data/DataChangeListener.h"
#include "AMP/vectors/data/VectorData.h"
 
#include <cstddef>
 
 
namespace AMP::Discretization {
class multiDOFManager;
}
 
 
namespace AMP::LinearAlgebra {
 
 
class MultiVectorData : public VectorData, public DataChangeListener
{
 
public: // Virtual functions
    virtual ~MultiVectorData() {}
 
 
    std::string VectorDataName() const override { return "MultiVectorData"; }
 
 
public: // Basic virtual functions
    size_t numberOfDataBlocks() const override;
    size_t sizeOfDataBlock( size_t i = 0 ) const override;
    void putRawData( const void *buf, const typeID &id ) override;
    void getRawData( void *buf, const typeID &id ) const override;
    void setValuesByLocalID( size_t, const size_t *, const void *, const typeID & ) override;
    void addValuesByLocalID( size_t, const size_t *, const void *, const typeID & ) override;
    void getValuesByLocalID( size_t, const size_t *, void *, const typeID & ) const override;
    void setGhostValuesByGlobalID( size_t, const size_t *, const void *, const typeID & ) override;
    void addGhostValuesByGlobalID( size_t, const size_t *, const void *, const typeID & ) override;
    void getGhostValuesByGlobalID( size_t, const size_t *, void *, const typeID & ) const override;
    void
    getGhostAddValuesByGlobalID( size_t, const size_t *, void *, const typeID & ) const override;
    size_t getAllGhostValues( void *, const typeID & ) const override;
    size_t getGhostSize() const override;
    void fillGhosts( const Scalar & ) override;
    void makeConsistent() override;
    void makeConsistent( ScatterType t ) override;
    UpdateState getLocalUpdateStatus() const override;
    void setUpdateStatus( UpdateState state ) override;
    size_t getNumberOfComponents() const override;
    std::shared_ptr<VectorData> getComponent( size_t i = 0 ) override;
    std::shared_ptr<const VectorData> getComponent( size_t i = 0 ) const override;
    bool hasContiguousData() const override { return ( numberOfDataBlocks() <= 1 ); }
    std::vector<size_t> getLocalSizes() const override;
 
public:
    std::shared_ptr<CommunicationList> getCommunicationList() const override;
    void setCommunicationList( std::shared_ptr<CommunicationList> comm ) override;
    void dataChanged() override;
    void setUpdateStatusPtr( std::shared_ptr<UpdateState> rhs ) override;
    std::shared_ptr<UpdateState> getUpdateStatusPtr() const override;
    bool containsGlobalElement( size_t ) const override;
    void copyGhostValues( const VectorData &rhs ) override;
    void setNoGhosts() override;
    bool hasGhosts() const override;
 
public: // Advanced virtual functions
    uint64_t getDataID() const override;
 
    void *getRawDataBlockAsVoid( size_t i ) override;
 
    const void *getRawDataBlockAsVoid( size_t i ) const override;
 
    size_t sizeofDataBlockType( size_t i ) const override;
 
    typeID getType( size_t block ) const override;
 
    void swapData( VectorData &rhs ) override;
 
    std::shared_ptr<VectorData> cloneData( const std::string &name = "" ) const override;
 
    AMP::Utilities::MemoryType getMemoryLocation() const override;
 
    void
    dumpOwnedData( std::ostream &out, size_t GIDoffset = 0, size_t LIDoffset = 0 ) const override;
    void dumpGhostedData( std::ostream &out, size_t offset = 0 ) const override;
 
    VectorData *getVectorData( size_t i );
    const VectorData *getVectorData( size_t i ) const;
 
    size_t getVectorDataSize() const { return d_data.size(); }
 
    const AMP_MPI &getComm() const override { return d_comm; }
 
    void assemble() override;
 
 
public:
    void receiveDataChanged() override { fireDataChange(); }
 
    explicit MultiVectorData( const AMP::AMP_MPI &comm ) : d_comm( comm ) {}
 
    explicit MultiVectorData( VectorData *data,
                              const AMP::Discretization::DOFManager *manager = nullptr );
 
    void resetMultiVectorData( const AMP::Discretization::DOFManager *manager,
                               const std::vector<VectorData *> &data );
 
public: // Write/read restart data
    void registerChildObjects( AMP::IO::RestartManager *manager ) const override;
 
    void writeRestart( int64_t fid ) const override;
 
    MultiVectorData( int64_t fid, AMP::IO::RestartManager *manager );
 
 
protected:
    void partitionGlobalValues( const int num,
                                const size_t *indices,
                                const void *vals,
                                const size_t bytes,
                                std::vector<std::vector<size_t>> &out_indices,
                                std::vector<std::vector<std::byte>> &out_vals,
                                std::vector<std::vector<int>> *remap = nullptr ) const;
 
    void partitionLocalValues( const int num,
                               const size_t *indices,
                               const void *vals,
                               const size_t bytes,
                               std::vector<std::vector<size_t>> &out_indices,
                               std::vector<std::vector<std::byte>> &out_vals,
                               std::vector<std::vector<int>> *remap = nullptr ) const;
 
    // Get all ghost values
    template<class TYPE>
    size_t getAllGhostValues( TYPE * ) const;
 
 
protected:
    // Internal data
    AMP::AMP_MPI d_comm;
    std::vector<VectorData *> d_data;
    AMP::Discretization::multiDOFHelper d_dofMap;
    std::shared_ptr<UpdateState> d_UpdateState;
};
 
 
} // namespace AMP::LinearAlgebra
 
 
#endif