IDATimeIntegrator.h

Go to the documentation of this file.

#ifndef included_AMP_IDATimeIntegrator
#define included_AMP_IDATimeIntegrator
 
#include <string>
 
 
#include "AMP/operators/LinearOperator.h"
#include "AMP/time_integrators/TimeIntegrator.h"
#include "AMP/time_integrators/sundials/IDATimeIntegratorParameters.h"
#include "AMP/time_integrators/sundials/IDATimeOperator.h"
#include "AMP/vectors/sundials/SundialsVector.h"
 
#ifdef AMP_USE_SUNDIALS
extern "C" {
    #include "ida/ida.h"
    #include "ida/ida_spgmr.h"
    #include "sundials/sundials_nvector.h"
    #include "sundials/sundials_types.h"
}
 
 
namespace AMP::TimeIntegrator {
 
 
class IDATimeIntegrator : public TimeIntegrator
{
public:
    explicit IDATimeIntegrator( std::shared_ptr<TimeIntegratorParameters> parameters );
 
    virtual ~IDATimeIntegrator();
 
    void initialize( std::shared_ptr<TimeIntegratorParameters> parameters ) override;
 
    void reset( std::shared_ptr<const TimeIntegratorParameters> parameters ) override;
 
    double getNextDt( const bool good_solution ) override;
 
    void setInitialGuess( const bool first_step,
                          const double current_time,
                          const double current_dt,
                          const double old_dt );
 
    int advanceSolution( const double dt,
                         const bool first_step,
                         std::shared_ptr<AMP::LinearAlgebra::Vector> in,
                         std::shared_ptr<AMP::LinearAlgebra::Vector> out ) override;
 
    void updateSolution( void ) override;
 
    void updateSourceTerm( void );
 
    bool checkNewSolution( void ) override;
 
    std::shared_ptr<IDATimeOperator> getIDATimeOperator() const; // BP, can go
 
    std::shared_ptr<LinearTimeOperator> getLinearTimeOperator() const;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> getResidualVector() const;
 
    bool getBoolManufacturedProblem( void ) { return d_bManufacturedProblem; }
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> getSourceTerm() override;
 
    inline std::shared_ptr<AMP::Solver::SolverStrategy> getPreconditioner( void )
    {
        return d_pNestedSolver;
    }
 
    inline void *getIDAMem( void ) { return d_ida_mem; }
 
    std::string type() const override { return "IDATimeIntegrator"; }
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_residual;
 
private:
    IDATimeIntegrator();
 
    void initializeIDA();
 
    void getFromInput( std::shared_ptr<AMP::Database> input_db ); // note that this was "protected"
                                                                  // (and not virtual) in
                                                                  // TimeIntegrator.h
    // and BackwardEulerTimeIntegrator has own its implementation of getFromInput - overridden...?
 
    // we definitely need this
    void setupVectors( void );
 
    static int IDAResTrial( realtype tt, N_Vector yy, N_Vector yp, N_Vector rr, void *user_data );
 
    static int IDAPrecSetup( realtype tt,
                             N_Vector yy,
                             N_Vector yp,
                             N_Vector rr,
                             realtype cj,
                             void *user_data,
                             N_Vector tmp1,
                             N_Vector tmp2,
                             N_Vector tmp3 );
 
    static int IDAPrecSolve( realtype tt,
                             N_Vector yy,
                             N_Vector yp,
                             N_Vector rr,
                             N_Vector rvec,
                             N_Vector zvec,
                             realtype cj,
                             realtype delta,
                             void *user_data,
                             N_Vector tmp );
 
    void *d_ida_mem;
 
    double d_relative_tolerance;
    double d_absolute_tolerance;
 
    int d_linear_solver_type;
 
    // flag to decide whether to call the IDA consistent IC calculation (default=false)
    bool d_bCallCalcIC;
 
    // flag to decide whether to create the linear operator internally
    bool d_createLinearOperatorInternally;
 
    // flag to use preconditioning
    bool d_bUsePreconditioner;
 
    bool d_bLinearMassOperator;
    bool d_bLinearRhsOperator;
    bool d_bManufacturedProblem;
 
    std::shared_ptr<IDATimeOperator> d_pIDATimeOperator; // BP, can go, but need to be careful
    std::shared_ptr<LinearTimeOperator> d_pLinearTimeOperator;
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_solution_prime;
 
    std::shared_ptr<AMP::Solver::SolverStrategy> d_pNestedSolver;
};
} // namespace AMP::TimeIntegrator
 
#endif
#endif