EpetraMatrixData.h

Go to the documentation of this file.

#ifndef included_AMP_EpetraMatrixData
#define included_AMP_EpetraMatrixData
 
#include "AMP/matrices/data/MatrixData.h"
 
 
// Forward declare
class Epetra_Map;
class Epetra_CrsMatrix;
 
namespace AMP::LinearAlgebra {
 
class Vector;
 
class EpetraMatrixData : public MatrixData
{
private:
    EpetraMatrixData() = delete;
 
protected:
    Epetra_CrsMatrix *d_epetraMatrix;
 
    std::shared_ptr<Epetra_Map> d_RangeMap;
 
    std::shared_ptr<Epetra_Map> d_DomainMap;
 
    bool d_DeleteMatrix;
 
    std::map<int, std::map<int, double>> d_OtherData;
 
    void setOtherData();
 
 
    void VerifyEpetraReturn( int err, const char *func ) const;
 
public:
    explicit EpetraMatrixData( std::shared_ptr<MatrixParametersBase> params );
 
    EpetraMatrixData( const EpetraMatrixData &rhs );
 
    explicit EpetraMatrixData( Epetra_CrsMatrix *inMatrix, bool dele = false );
 
    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 setEpetraMaps( std::shared_ptr<Vector> range, std::shared_ptr<Vector> domain );
 
    EpetraMatrixData &operator=( const EpetraMatrixData & ) = delete;
 
    virtual ~EpetraMatrixData();
 
    std::string type() const override { return "EpetraMatrixData"; }
 
    virtual Epetra_CrsMatrix &getEpetra_CrsMatrix();
 
    virtual const Epetra_CrsMatrix &getEpetra_CrsMatrix() const;
 
    static std::shared_ptr<EpetraMatrixData> createView( std::shared_ptr<MatrixData> p );
 
    void fillComplete();
 
    void createValuesByGlobalID( size_t, const std::vector<size_t> & );
    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 t ) override;
    size_t numLocalRows() const override;
    size_t numGlobalRows() const override;
    size_t numLocalColumns() const override;
    size_t numGlobalColumns() const override;
    AMP::AMP_MPI getComm() const override;
    std::shared_ptr<Discretization::DOFManager> getRightDOFManager() const override;
    std::shared_ptr<Discretization::DOFManager> getLeftDOFManager() const override;
    std::shared_ptr<Vector> createInputVector() const;
    std::shared_ptr<Vector> createOutputVector() const;
 
    typeID getCoeffType() const override
    {
        // Epetra matrix are double only for the moment
        constexpr auto type = getTypeID<double>();
        return type;
    }
};
 
 
} // namespace AMP::LinearAlgebra
 
 
#endif