MatrixParametersBase.h

Go to the documentation of this file.

#ifndef included_AMP_MatrixParametersBase
#define included_AMP_MatrixParametersBase
 
#include "AMP/utils/AMP_MPI.h"
#include "AMP/utils/Utilities.h"
#include "AMP/vectors/Variable.h"
 
namespace AMP::LinearAlgebra {
 
 
class MatrixParametersBase
{
public:
    MatrixParametersBase() = delete;
 
    MatrixParametersBase( const MatrixParametersBase &other ) = default;
 
    explicit MatrixParametersBase( const AMP_MPI &comm )
        : d_comm( comm ),
          d_VariableLeft( std::make_shared<Variable>( "MatrixParametersBase_default" ) ),
          d_VariableRight( std::make_shared<Variable>( "MatrixParametersBase_default" ) ),
          d_backend( AMP::Utilities::Backend::Serial ),
          d_hash( reinterpret_cast<uint64_t>( this ) )
    {
    }
 
    explicit MatrixParametersBase( const AMP_MPI &comm, AMP::Utilities::Backend backend )
        : d_comm( comm ),
          d_VariableLeft( std::make_shared<Variable>( "MatrixParametersBase_default" ) ),
          d_VariableRight( std::make_shared<Variable>( "MatrixParametersBase_default" ) ),
          d_backend( backend ),
          d_hash( reinterpret_cast<uint64_t>( this ) )
    {
    }
 
    explicit MatrixParametersBase( const AMP_MPI &comm,
                                   std::shared_ptr<Variable> varLeft,
                                   std::shared_ptr<Variable> varRight )
        : d_comm( comm ),
          d_VariableLeft( varLeft ),
          d_VariableRight( varRight ),
          d_backend( AMP::Utilities::Backend::Serial ),
          d_hash( reinterpret_cast<uint64_t>( this ) )
    {
    }
 
    explicit MatrixParametersBase( const AMP_MPI &comm,
                                   std::shared_ptr<Variable> varLeft,
                                   std::shared_ptr<Variable> varRight,
                                   AMP::Utilities::Backend backend )
        : d_comm( comm ),
          d_VariableLeft( varLeft ),
          d_VariableRight( varRight ),
          d_backend( backend ),
          d_hash( reinterpret_cast<uint64_t>( this ) )
    {
    }
 
    virtual ~MatrixParametersBase() = default;
 
    uint64_t getID() const { return d_hash; }
 
    virtual std::string type() const { return "MatrixParametersBase"; }
 
    AMP::AMP_MPI &getComm() { return d_comm; }
 
    void setLeftVariable( std::shared_ptr<Variable> var ) { d_VariableLeft = var; }
 
    void setRightVariable( std::shared_ptr<Variable> var ) { d_VariableRight = var; }
 
    std::shared_ptr<Variable> getLeftVariable() const { return d_VariableLeft; }
 
    std::shared_ptr<Variable> getRightVariable() const { return d_VariableRight; }
 
public: // Write/read restart data
    virtual void registerChildObjects( AMP::IO::RestartManager *manager ) const;
 
    virtual void writeRestart( int64_t fid ) const;
 
    MatrixParametersBase( int64_t fid, AMP::IO::RestartManager *manager );
 
protected:
    // The comm of the matrix
    AMP_MPI d_comm;
 
    std::shared_ptr<Variable> d_VariableLeft;
 
    std::shared_ptr<Variable> d_VariableRight;
 
public:
    // The backend used for cpus and/or gpu acceleration
    AMP::Utilities::Backend d_backend = AMP::Utilities::Backend::Serial;
 
    // unique hash to identify this object
    uint64_t d_hash = 0;
};
} // namespace AMP::LinearAlgebra
 
#endif