DenseSerialMatrixData.h

Go to the documentation of this file.

#ifndef included_AMP_DenseSerialMatrixData
#define included_AMP_DenseSerialMatrixData
 
#include "AMP/discretization/DOF_Manager.h"
#include "AMP/matrices/Matrix.h"
#include "AMP/vectors/Vector.h"
 
#include <memory>
 
class DenseSerialMatrix;
class DenseSerialMatrixOperations;
 
namespace AMP::LinearAlgebra {
 
 
class DenseSerialMatrixData : public MatrixData
{
public:
    explicit DenseSerialMatrixData( std::shared_ptr<MatrixParametersBase> params );
 
    DenseSerialMatrixData()                                           = delete;
    DenseSerialMatrixData( const DenseSerialMatrixData & )            = delete;
    DenseSerialMatrixData &operator=( const DenseSerialMatrixData & ) = delete;
 
    virtual ~DenseSerialMatrixData();
 
    std::string type() const override { return "DenseSerialMatrixData"; }
 
    std::shared_ptr<MatrixData> cloneMatrixData() const override;
 
    std::shared_ptr<MatrixData> transpose() const override;
 
    void removeRange( AMP::Scalar, AMP::Scalar ) override { AMP_ERROR( "Not implemented" ); }
 
    void addValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              const void *values,
                              const typeID &id ) override;
 
    void setValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              const void *values,
                              const typeID &id ) override;
 
    void getValuesByGlobalID( size_t num_rows,
                              size_t num_cols,
                              const size_t *rows,
                              const size_t *cols,
                              void *values,
                              const typeID &id ) const override;
 
 
    void getRowByGlobalID( size_t row,
                           std::vector<size_t> &cols,
                           std::vector<double> &values ) const override;
 
    size_t numberColumnIDs( size_t row ) const override;
 
    std::vector<size_t> getColumnIDs( size_t row ) const override;
 
    void makeConsistent( AMP::LinearAlgebra::ScatterType ) override {}
 
    std::shared_ptr<Discretization::DOFManager> getRightDOFManager() const override;
 
    std::shared_ptr<Discretization::DOFManager> getLeftDOFManager() const override;
 
    size_t numLocalRows() const override { return d_rows; }
 
    size_t numGlobalRows() const override { return d_rows; }
 
    size_t numLocalColumns() const override { return d_cols; }
 
    size_t numGlobalColumns() const override { return d_cols; }
 
    typeID getCoeffType() const override
    {
        constexpr auto type = getTypeID<double>();
        return type;
    }
 
protected:
    // AMP variables and DOFManagers for the left and right vectors
    std::shared_ptr<AMP::Discretization::DOFManager> d_DOFManagerLeft;
    std::shared_ptr<AMP::Discretization::DOFManager> d_DOFManagerRight;
 
    // Data for the matrix
    size_t d_rows;
    size_t d_cols;
    double *d_M = nullptr;
 
    friend class DenseSerialMatrix;
    friend class DenseSerialMatrixOperations;
};
} // namespace AMP::LinearAlgebra
 
 
#endif