Operator.h

Go to the documentation of this file.

#ifndef included_AMP_Operator
#define included_AMP_Operator
 
#include <memory>
 
#include "AMP/operators/OperatorParameters.h"
 
#include "AMP/utils/Utilities.h"
 
#include "AMP/vectors/Variable.h"
#include "AMP/vectors/Vector.h"
 
#include <string>
 
 
namespace AMP::Operator {
 
 
class Operator
{
public:
    typedef std::shared_ptr<AMP::Operator::Operator> shared_ptr;
 
    Operator( void );
 
    explicit Operator( std::shared_ptr<const OperatorParameters> params );
 
    virtual ~Operator() {}
 
    virtual std::string type() const = 0;
 
    virtual void reset( std::shared_ptr<const OperatorParameters> params );
 
    virtual void apply( std::shared_ptr<const AMP::LinearAlgebra::Vector> u,
                        std::shared_ptr<AMP::LinearAlgebra::Vector> f ) = 0;
 
    virtual void residual( std::shared_ptr<const AMP::LinearAlgebra::Vector> f,
                           std::shared_ptr<const AMP::LinearAlgebra::Vector> u,
                           std::shared_ptr<AMP::LinearAlgebra::Vector> r );
 
    virtual std::shared_ptr<OperatorParameters>
    getParameters( const std::string &type,
                   std::shared_ptr<const AMP::LinearAlgebra::Vector> u,
                   std::shared_ptr<OperatorParameters> params = nullptr );
 
    AMP::Utilities::MemoryType getMemoryLocation() const { return d_memory_location; }
 
    virtual void setDebugPrintInfoLevel( int level ) { d_iDebugPrintInfoLevel = level; }
 
    virtual std::shared_ptr<AMP::LinearAlgebra::Variable> getOutputVariable() const
    {
        return nullptr;
    }
 
    virtual std::shared_ptr<AMP::LinearAlgebra::Variable> getInputVariable() const
    {
        return nullptr;
    }
 
    virtual std::shared_ptr<AMP::LinearAlgebra::Vector> createInputVector() const;
 
    virtual std::shared_ptr<AMP::LinearAlgebra::Vector> createOutputVector() const;
 
    virtual std::shared_ptr<AMP::LinearAlgebra::VectorSelector> selectOutputVector() const;
 
    virtual std::shared_ptr<AMP::LinearAlgebra::VectorSelector> selectInputVector() const;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector>
    subsetOutputVector( std::shared_ptr<AMP::LinearAlgebra::Vector> vec ) const;
 
    std::shared_ptr<const AMP::LinearAlgebra::Vector>
    subsetOutputVector( std::shared_ptr<const AMP::LinearAlgebra::Vector> vec ) const;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector>
    subsetInputVector( std::shared_ptr<AMP::LinearAlgebra::Vector> vec ) const;
 
    std::shared_ptr<const AMP::LinearAlgebra::Vector>
    subsetInputVector( std::shared_ptr<const AMP::LinearAlgebra::Vector> vec ) const;
 
    // default behavior is to return true;
    virtual bool isValidVector( std::shared_ptr<const AMP::LinearAlgebra::Vector> ) { return true; }
 
    std::shared_ptr<AMP::Mesh::Mesh> getMesh() { return d_Mesh; }
 
    std::shared_ptr<const AMP::Mesh::Mesh> getMesh() const { return d_Mesh; }
 
    virtual void makeConsistent( std::shared_ptr<AMP::LinearAlgebra::Vector> vec );
 
    virtual void reInitializeVector( std::shared_ptr<AMP::LinearAlgebra::Vector> ) {}
 
protected:
    void getBackendFromInput( std::shared_ptr<AMP::Database> db );
 
    virtual std::shared_ptr<OperatorParameters>
    getJacobianParameters( std::shared_ptr<const AMP::LinearAlgebra::Vector> )
    {
        return nullptr;
    }
 
    void setMemoryAndBackendParameters( std::shared_ptr<AMP::Database> db );
 
    int d_iDebugPrintInfoLevel = 0;
 
    int d_iObject_id;
 
    static int d_iInstance_id;
 
    std::shared_ptr<AMP::Mesh::Mesh> d_Mesh;
 
    AMP::Utilities::MemoryType d_memory_location = AMP::Utilities::MemoryType::none;
 
    AMP::Utilities::Backend d_backend = AMP::Utilities::Backend::Serial;
 
private:
};
} // namespace AMP::Operator
 
#endif