TimeIntegrator.h

Go to the documentation of this file.

#ifndef included_AMP_TimeIntegrator
    #define included_AMP_TimeIntegrator
 
    #include "AMP/operators/Operator.h"
    #include "AMP/time_integrators/TimeIntegratorParameters.h"
    #include "AMP/utils/Database.h"
    #include "AMP/vectors/Vector.h"
 
    #include <cstdint>
    #include <memory>
    #include <string>
 
 
// Declare some classes
namespace AMP::IO {
class Writer;
class RestartManager;
} // namespace AMP::IO
 
 
namespace AMP::TimeIntegrator {
 
class TimeIntegrator
{
public:
    typedef std::shared_ptr<AMP::TimeIntegrator::TimeIntegrator> shared_ptr;
 
    explicit TimeIntegrator( std::shared_ptr<TimeIntegratorParameters> parameters );
 
    virtual ~TimeIntegrator();
 
    virtual std::string type() const;
 
    uint64_t getID() const;
 
    virtual void initialize( std::shared_ptr<TimeIntegratorParameters> parameters );
 
    virtual void reset( std::shared_ptr<const TimeIntegratorParameters> parameters ) = 0;
 
    virtual int advanceSolution( const double dt,
                                 const bool first_step,
                                 std::shared_ptr<AMP::LinearAlgebra::Vector> in,
                                 std::shared_ptr<AMP::LinearAlgebra::Vector> out ) = 0;
 
    virtual bool checkNewSolution( void ) = 0;
 
    virtual void updateSolution( void ) = 0;
 
    virtual std::shared_ptr<AMP::LinearAlgebra::Vector> getSolution( void )
    {
        return d_solution_vector;
    }
 
    virtual double getNextDt( const bool good_solution );
 
    virtual double getInitialTime() const;
 
    virtual double getFinalTime() const;
 
    virtual double getCurrentTime() const;
 
    virtual double getCurrentDt() const;
 
    virtual double getInitialDt() { return d_initial_dt; };
 
    virtual int getIntegratorStep() const;
 
    virtual int getMaxIntegratorSteps() const;
 
    virtual bool stepsRemaining() const;
 
    virtual void appendSolutionVector( [[maybe_unused]] AMP::LinearAlgebra::Vector::shared_ptr vec )
    {
    }
 
    virtual void appendRhsVector( [[maybe_unused]] AMP::LinearAlgebra::Vector::shared_ptr vec ) {}
 
    virtual void registerWriter( std::shared_ptr<AMP::IO::Writer> writer ) { d_writer = writer; }
 
    void printClassData( std::ostream &os ) const;
 
    void putToDatabase( std::shared_ptr<AMP::Database> db );
 
    virtual void registerOperator( std::shared_ptr<AMP::Operator::Operator> op )
    {
        d_operator = op;
    }
 
    std::shared_ptr<AMP::Operator::Operator> getOperator( void ) { return d_operator; }
 
    virtual int getTotalRejectedSteps() const { return d_total_steprejects; }
 
    virtual void setCurrentDt( const double dt ) { d_current_dt = dt; }
 
    virtual void setInitialDt( const double dt ) { d_initial_dt = dt; }
 
    virtual void setCurrentTime( const double t ) { d_current_time = t; }
 
    virtual void setInitialTime( const double t ) { d_initial_time = t; }
 
    virtual void setFinalTime( const double t ) { d_final_time = t; }
 
    virtual void printStatistics( std::ostream &os = AMP::pout );
 
    virtual void setSourceTerm( AMP::LinearAlgebra::Vector::shared_ptr src )
    {
        d_pSourceTerm = src;
    }
    virtual AMP::LinearAlgebra::Vector::shared_ptr getSourceTerm( void ) { return d_pSourceTerm; }
 
    virtual double getGamma( void ) { return d_current_dt; }
 
    virtual std::vector<double> getTimeHistoryScalings( void )
    {
        return std::vector<double>( 1, 1.0 );
    }
 
    /*
     * Returns the number of previous solutions that are stored
     */
    virtual size_t sizeOfTimeHistory() const { return 1; }
 
protected:
    /*
     * Read input data from specified database and initialize class members.
     * If run is from restart, a subset of the restart values may be replaced
     * with those read from input.
     *
     * When assertion checking is active, the database pointer must be non-null.
     */
    void getFromInput( std::shared_ptr<const AMP::Database> db );
 
    /*
     * Read object state from restart database and initialize class members.
     * Check that class and restart version numbers are the same.
     */
    void getFromRestart();
 
    /*
     * String used to identify specific class instantiation.
     */
    std::string d_object_name;
 
    std::shared_ptr<TimeIntegratorParameters> d_pParameters;
 
    /*
     * Initial conditions vector
     */
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_ic_vector = nullptr;
 
    /*
     * Solution vector advanced during the time integration process.
     */
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_solution_vector;
 
    std::shared_ptr<AMP::Operator::Operator> d_operator;
 
    std::shared_ptr<AMP::Operator::Operator> d_pMassOperator;
 
    /*
     * Source-sink vector, g,  when the time integration problem is of the form u_t = f(u)+g
     */
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_pSourceTerm;
 
    /*
     * Data members representing integrator times, time increments,
     * and step count information.
     */
    double d_initial_time = std::numeric_limits<double>::signaling_NaN();
    double d_final_time   = std::numeric_limits<double>::signaling_NaN();
    double d_current_time = std::numeric_limits<double>::signaling_NaN();
 
    double d_initial_dt = std::numeric_limits<double>::signaling_NaN();
    double d_current_dt = std::numeric_limits<double>::signaling_NaN();
    double d_old_dt     = std::numeric_limits<double>::signaling_NaN();
    double d_min_dt     = std::numeric_limits<double>::signaling_NaN();
 
    double d_max_dt = std::numeric_limits<double>::max();
 
    int d_iDebugPrintInfoLevel = 0;
    int d_integrator_step      = 0;
    int d_max_integrator_steps = 0;
 
    int d_total_steprejects = 0; 
 
    // Writer for internal data
    std::shared_ptr<AMP::IO::Writer> d_writer;
 
    TimeIntegrator() = default;
 
    bool d_initialized = false;
 
public: // Write/read restart data
    virtual void registerChildObjects( AMP::IO::RestartManager *manager ) const;
 
    virtual void writeRestart( int64_t fid ) const;
 
    TimeIntegrator( int64_t fid, AMP::IO::RestartManager *manager );
 
private:
    // The following are not implemented:
    explicit TimeIntegrator( const TimeIntegrator & ) = delete;
    void operator=( const TimeIntegrator & ) = delete;
};
 
} // namespace AMP::TimeIntegrator
 
#endif
 
#include "AMP/time_integrators/TimeIntegrator.I"