MatrixData.h

Go to the documentation of this file.

#ifndef included_AMP_MatrixData_h
#define included_AMP_MatrixData_h
 
#include <memory>
 
#include "AMP/matrices/MatrixParametersBase.h"
#include "AMP/utils/AMP_MPI.h"
#include "AMP/utils/Utilities.h"
#include "AMP/utils/enable_shared_from_this.h"
#include "AMP/utils/typeid.h"
#include "AMP/vectors/CommunicationList.h"
#include "AMP/vectors/Scalar.h"
#include "AMP/vectors/Variable.h"
 
namespace AMP::IO {
class RestartManager;
}
 
namespace AMP::Discretization {
class DOFManager;
}
 
namespace AMP::LinearAlgebra {
 
class Vector;
 
class MatrixData : public AMP::enable_shared_from_this<MatrixData>
{
public:
    explicit MatrixData( std::shared_ptr<MatrixParametersBase> params );
 
    virtual ~MatrixData();
 
    MatrixData();
 
    MatrixData( const MatrixData & ) = delete;
 
    virtual std::shared_ptr<MatrixData> cloneMatrixData() const = 0;
 
    virtual std::shared_ptr<MatrixData> transpose() const = 0;
 
    virtual void removeRange( AMP::Scalar bnd_lo, AMP::Scalar bnd_up ) = 0;
 
    virtual std::string type() const = 0;
 
    virtual std::uint16_t mode() const { return std::numeric_limits<std::uint16_t>::max(); }
 
    template<class TYPE>
    void addValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              const TYPE *values );
 
    template<class TYPE>
    void setValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              const TYPE *values );
 
    template<class TYPE>
    void getValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              TYPE *values ) const;
 
    virtual void getRowByGlobalID( size_t row,
                                   std::vector<size_t> &cols,
                                   std::vector<double> &values ) const = 0;
 
    virtual void addValuesByGlobalID( size_t num_rows,
                                      size_t num_cols,
                                      const size_t *rows,
                                      const size_t *cols,
                                      const void *values,
                                      const typeID &id ) = 0;
 
    virtual void setValuesByGlobalID( size_t num_rows,
                                      size_t num_cols,
                                      const size_t *rows,
                                      const size_t *cols,
                                      const void *values,
                                      const typeID &id ) = 0;
 
    virtual void getValuesByGlobalID( size_t num_rows,
                                      size_t num_cols,
                                      const size_t *rows,
                                      const size_t *cols,
                                      void *values,
                                      const typeID &id ) const = 0;
 
    virtual size_t numberColumnIDs( size_t row ) const = 0;
 
    virtual std::vector<size_t> getColumnIDs( size_t row ) const = 0;
 
    virtual void makeConsistent( AMP::LinearAlgebra::ScatterType t ) = 0;
 
    virtual std::shared_ptr<Discretization::DOFManager> getRightDOFManager() const = 0;
 
    virtual std::shared_ptr<Discretization::DOFManager> getLeftDOFManager() const = 0;
 
    virtual std::shared_ptr<Variable> getRightVariable() const
    {
        return d_pParameters->getRightVariable();
    }
 
    virtual std::shared_ptr<Variable> getLeftVariable() const
    {
        return d_pParameters->getLeftVariable();
    }
 
    virtual size_t numLocalRows() const;
 
    virtual size_t numGlobalRows() const;
 
    virtual size_t numLocalColumns() const;
 
    virtual size_t numGlobalColumns() const;
 
    virtual size_t beginRow() const;
 
    virtual size_t endRow() const;
 
    virtual size_t beginCol() const;
 
    virtual size_t endCol() const;
 
    inline virtual AMP_MPI getComm() const
    {
        AMP_ASSERT( d_pParameters );
        return d_pParameters->getComm();
    }
 
    inline virtual AMP::Utilities::Backend getBackend() const
    {
        AMP_ASSERT( d_pParameters );
        return d_pParameters->d_backend;
    }
 
    inline virtual void setBackend( AMP::Utilities::Backend backend )
    {
        AMP_ASSERT( d_pParameters );
        d_pParameters->d_backend = backend;
    }
 
    virtual typeID getCoeffType() const = 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;
 
    MatrixData( int64_t fid, AMP::IO::RestartManager *manager );
 
protected:
    std::shared_ptr<MatrixParametersBase> d_pParameters;
 
    // unique hash to identify this object
    uint64_t d_hash = 0;
};
 
} // namespace AMP::LinearAlgebra
 
#include "AMP/matrices/data/MatrixData.hpp"
 
#endif