ImplicitIntegrator.h

Go to the documentation of this file.

#ifndef included_AMP_ImplicitIntegrator
#define included_AMP_ImplicitIntegrator
 
#include <string>
 
#include "AMP/time_integrators/TimeIntegrator.h"
#include "AMP/time_integrators/TimeIntegratorParameters.h"
#include "AMP/time_integrators/TimeOperator.h"
#include "AMP/vectors/Scalar.h"
 
// Forward declares
namespace AMP {
class Database;
}
namespace AMP::Solver {
class SolverStrategy;
}
 
namespace AMP::TimeIntegrator {
 
class ImplicitIntegrator : public AMP::TimeIntegrator::TimeIntegrator
{
public:
    explicit ImplicitIntegrator(
        std::shared_ptr<AMP::TimeIntegrator::TimeIntegratorParameters> prm );
 
    ImplicitIntegrator() = delete;
 
    // The following are not implemented:
    ImplicitIntegrator( const ImplicitIntegrator & ) = delete;
    void operator=( const ImplicitIntegrator & ) = delete;
 
    virtual ~ImplicitIntegrator();
 
    void initialize( void );
 
    void reset( void );
 
    void reset(
        std::shared_ptr<const AMP::TimeIntegrator::TimeIntegratorParameters> parameters ) override;
 
    void registerOperator( std::shared_ptr<AMP::Operator::Operator> op ) override;
 
    int advanceSolution( const double dt,
                         const bool first_step,
                         std::shared_ptr<AMP::LinearAlgebra::Vector> in,
                         std::shared_ptr<AMP::LinearAlgebra::Vector> out ) override;
 
    bool checkNewSolution( void ) override;
 
    void updateSolution( void ) override;
 
    virtual double getNextDt( const bool good_solution ) override;
 
    bool stepsRemaining() const override { return d_integrator_step < d_max_integrator_steps; }
 
    virtual void printClassData( std::ostream &os ) const;
 
    const std::string &getObjectName() const { return d_object_name; }
 
    std::shared_ptr<AMP::Solver::SolverStrategy> getSolver( void ) { return d_solver; }
    void resetSolver( std::shared_ptr<AMP::Solver::SolverStrategy> solver = nullptr )
    {
        d_solver = solver;
    }
 
    using TimeIntegrator::initialize;
 
    void printStatistics( std::ostream &os = AMP::pout ) 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 );
 
    void setTimeScalingFunction( std::function<void( AMP::Scalar )> fnPtr )
    {
        d_fTimeScalingFnPtr = fnPtr;
    }
 
    void setComponentScalingFunction(
        std::function<void( std::shared_ptr<AMP::LinearAlgebra::Vector>,
                            std::shared_ptr<AMP::LinearAlgebra::Vector> )> fnPtr )
    {
        d_fComponentScalingFnPtr = fnPtr;
    }
 
    virtual std::shared_ptr<AMP::LinearAlgebra::Vector> getTimeHistorySourceTerm()
    {
        return nullptr;
    };
 
protected:
    virtual void setInitialGuess( const bool first_step,
                                  const double current_time,
                                  const double current_dt,
                                  const double old_dt );
 
    virtual void setTimeHistoryScalings() {}
 
    /*
     * Pointers to implicit equation and solver strategy objects and patch
     * hierarchy.  The strategies provide nonlinear equation and solver
     * routines for treating the nonlinear problem on the hierarchy.
     */
    std::shared_ptr<AMP::Solver::SolverStrategy> d_solver = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_solution_scaling;
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_function_scaling;
 
    /*
     * Data members representing integrator times, time increments,
     * and step count information.
     */
 
    int d_solver_retcode = 0; 
 
    bool d_first_step = true; 
 
    bool d_time_history_initialized = false;
 
    bool d_user_managed_time_operator = false;
 
    virtual int
    integratorSpecificAdvanceSolution( const double dt,
                                       const bool first_step,
                                       std::shared_ptr<AMP::LinearAlgebra::Vector> in,
                                       std::shared_ptr<AMP::LinearAlgebra::Vector> out );
 
    void createSolver( void );
 
    std::function<void( AMP::Scalar )> d_fTimeScalingFnPtr;
 
    std::function<void( std::shared_ptr<AMP::LinearAlgebra::Vector>,
                        std::shared_ptr<AMP::LinearAlgebra::Vector> )>
        d_fComponentScalingFnPtr;
 
public: // Write/read restart data
    void registerChildObjects( AMP::IO::RestartManager *manager ) const override;
 
    void writeRestart( int64_t fid ) const override;
 
    ImplicitIntegrator( int64_t fid, AMP::IO::RestartManager *manager );
 
private:
    virtual bool integratorSpecificCheckNewSolution( const int solver_retcode );
 
    virtual void integratorSpecificUpdateSolution( double time );
 
    virtual double integratorSpecificGetNextDt( const bool good_solution,
                                                const int solver_retcode );
 
    virtual void integratorSpecificInitialize( void );
};
 
} // namespace AMP::TimeIntegrator
 
#endif