TimeOperator.h

Go to the documentation of this file.

#ifndef included_AMP_TimeOperator
#define included_AMP_TimeOperator
 
#include "AMP/operators/Operator.h"
#include "AMP/operators/OperatorParameters.h"
#include "AMP/utils/Utilities.h"
#include "AMP/vectors/Vector.h"
#include <memory>
 
 
namespace AMP::TimeIntegrator {
 
class TimeOperator : public virtual AMP::Operator::Operator
{
public:
    explicit TimeOperator( std::shared_ptr<const AMP::Operator::OperatorParameters> params );
 
    virtual ~TimeOperator();
 
    std::string type() const override { return "TimeOperator"; }
 
    void reset( std::shared_ptr<const AMP::Operator::OperatorParameters> params ) override;
 
    void registerRhsOperator( std::shared_ptr<AMP::Operator::Operator> op ) { d_pRhsOperator = op; }
 
    void registerMassOperator( std::shared_ptr<AMP::Operator::Operator> op )
    {
        d_pMassOperator = op;
    }
 
    void registerAlgebraicVariable( std::shared_ptr<AMP::LinearAlgebra::Variable> var )
    {
        d_pAlgebraicVariable = var;
    }
 
    std::shared_ptr<AMP::Operator::Operator> getRhsOperator( void ) { return d_pRhsOperator; }
 
    std::shared_ptr<AMP::Operator::Operator> getMassOperator( void ) { return d_pMassOperator; }
 
    void setDt( double dt ) { d_dCurrentDt = dt; }
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> getOutputVariable() const override
    {
        return d_pRhsOperator->getOutputVariable();
    }
 
    void apply( AMP::LinearAlgebra::Vector::const_shared_ptr u,
                AMP::LinearAlgebra::Vector::shared_ptr r ) override;
 
    virtual void applyRhs( std::shared_ptr<const AMP::LinearAlgebra::Vector> x,
                           std::shared_ptr<AMP::LinearAlgebra::Vector> f );
 
    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 ) override;
 
    virtual void setTimeOperatorScaling( const double gamma ) { d_dGamma = gamma; }
    virtual double getGamma( void ) const { return d_dGamma; }
 
    std::shared_ptr<AMP::Operator::OperatorParameters>
    getParameters( const std::string &type,
                   AMP::LinearAlgebra::Vector::const_shared_ptr u,
                   std::shared_ptr<AMP::Operator::OperatorParameters> params = nullptr ) override;
 
    // and nonlinear function for correct solution of the implicit problem
    // each timestep. The first vector is for solution scaling, the second for function
    void setComponentScalings( std::shared_ptr<AMP::LinearAlgebra::Vector> s,
                               std::shared_ptr<AMP::LinearAlgebra::Vector> f )
    {
        d_pSolutionScaling = s;
        d_pFunctionScaling = f;
    }
 
    void makeConsistent( std::shared_ptr<AMP::LinearAlgebra::Vector> vec ) override
    {
        AMP_ASSERT( d_pRhsOperator );
        d_pRhsOperator->makeConsistent( vec );
    }
 
    void reInitializeVector( std::shared_ptr<AMP::LinearAlgebra::Vector> v ) override
    {
        AMP_ASSERT( d_pRhsOperator );
        d_pRhsOperator->reInitializeVector( v );
    }
 
    bool isValidVector( std::shared_ptr<const AMP::LinearAlgebra::Vector> u ) override
    {
        AMP_ASSERT( d_pRhsOperator );
        return d_pRhsOperator->isValidVector( u );
    }
 
protected:
    TimeOperator();
 
    void getFromInput( std::shared_ptr<AMP::Database> db );
 
    bool d_bLinearMassOperator;
 
    bool d_bLinearRhsOperator;
 
    bool d_bAlgebraicComponent;
 
    double d_dCurrentDt;
 
    std::shared_ptr<AMP::Operator::Operator> d_pRhsOperator;
 
    std::shared_ptr<AMP::Operator::Operator> d_pMassOperator;
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> d_pAlgebraicVariable;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_pScratchSolVector;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_pScratchVector;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_pSourceTerm;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_pSolutionScaling;
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_pFunctionScaling;
 
    double d_dGamma = 0.0;
 
private:
};
} // namespace AMP::TimeIntegrator
 
#endif