EpetraVectorData.h

Go to the documentation of this file.

#ifndef included_AMP_EpetraVectorData
#define included_AMP_EpetraVectorData
 
#include "AMP/vectors/data/GhostDataHelper.hpp"
#include "AMP/vectors/data/VectorData.h"
 
DISABLE_WARNINGS
#include <Epetra_Map.h>
#include <Epetra_Vector.h>
ENABLE_WARNINGS
 
 
namespace AMP::LinearAlgebra {
 
class EpetraVectorEngineParameters
{
public:
    EpetraVectorEngineParameters( size_t N_local,
                                  const AMP_MPI &comm,
                                  std::shared_ptr<CommunicationList> commList );
 
    virtual ~EpetraVectorEngineParameters();
 
    Epetra_Map &getEpetraMap();
 
    inline size_t getLocalSize() const { return d_end - d_begin; }
 
    inline size_t getGlobalSize() const { return d_global; }
 
    inline size_t beginDOF() const { return d_begin; }
 
    inline AMP_MPI getComm() const { return d_comm; }
 
    std::shared_ptr<CommunicationList> d_CommList = nullptr;
 
private:
    size_t d_begin  = 0;                          // Starting DOF
    size_t d_end    = 0;                          // Ending DOF
    size_t d_global = 0;                          // Number of global DOFs
    AMP_MPI d_comm;                               // Comm
    std::shared_ptr<Epetra_Map> d_emap = nullptr; // Epetra map
};
 
class EpetraVectorData : public GhostDataHelper<double>
{
 
public: // Virtual functions
    virtual ~EpetraVectorData() {}
    static std::shared_ptr<EpetraVectorData>
    create( std::shared_ptr<EpetraVectorEngineParameters> alias, std::shared_ptr<VectorData> buf );
 
    std::string VectorDataName() const override { return "EpetraVectorData"; }
    size_t numberOfDataBlocks() const override { return 1; }
    size_t sizeOfDataBlock( size_t i ) const override { return i == 0 ? d_localSize : 0; }
    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 putRawData( const void *in, const typeID &id ) override;
    void getRawData( void *out, const typeID &id ) const override;
    uint64_t getDataID() const override
    {
        return reinterpret_cast<uint64_t>( getRawDataBlockAsVoid( 0 ) );
    }
    void *getRawDataBlockAsVoid( size_t i ) override;
    const void *getRawDataBlockAsVoid( size_t i ) const override;
    size_t sizeofDataBlockType( size_t ) const override { return sizeof( double ); }
    typeID getType( size_t ) const override { return getTypeID<double>(); }
    void swapData( VectorData & ) override;
    std::shared_ptr<VectorData> cloneData( const std::string &name = "" ) const override;
 
    inline Epetra_Vector &getEpetra_Vector() { return d_epetraVector; }
 
    inline const Epetra_Vector &getEpetra_Vector() const { return d_epetraVector; }
 
    EpetraVectorData( std::shared_ptr<EpetraVectorEngineParameters> alias,
                      Epetra_DataAccess,
                      const Epetra_BlockMap &,
                      std::shared_ptr<VectorData>,
                      int,
                      int,
                      int );
 
protected:
    Epetra_Vector d_epetraVector;
 
    std::shared_ptr<VectorData> d_buf_scope;
};
 
 
} // namespace AMP::LinearAlgebra
 
 
#endif