BDFIntegrator.h

Go to the documentation of this file.

#ifndef included_BDFIntegrator_h_
#define included_BDFIntegrator_h_
 
#include <limits>
#include <list>
 
#include "AMP/time_integrators/ImplicitIntegrator.h"
 
#ifdef ENABLE_RESTART
class RestartData;
#endif
 
namespace AMP {
class Database;
namespace Operator {
class Operator;
}
 
namespace TimeIntegrator {
 
using DataManagerCallBack = std::function<void( std::shared_ptr<AMP::LinearAlgebra::Vector> )>;
 
class BDFIntegrator : public AMP::TimeIntegrator::ImplicitIntegrator
{
public:
    explicit BDFIntegrator( AMP::TimeIntegrator::TimeIntegratorParameters::shared_ptr );
    ~BDFIntegrator();
 
    static std::unique_ptr<AMP::TimeIntegrator::TimeIntegrator> createTimeIntegrator(
        std::shared_ptr<AMP::TimeIntegrator::TimeIntegratorParameters> parameters );
 
    int getNumberOfStepRejections( void ) { return d_total_steprejects; }
 
    double getTimeOperatorScaling( void );
 
    void setInitialGuess( const bool first_step,
                          const double current_time,
                          const double current_dt,
                          const double old_dt ) override;
 
    void setIsNewTimeStep( bool bval ) { d_is_new_timestep = bval; }
 
    void initializeVariables( bool is_from_restart );
 
    void setRegridStatus( bool is_after_regrid );
 
    void setIterationCounts( const int nli, const int li );
 
    int getFunctionEvaluationCount( void ) { return d_evaluatefunction_count; }
    void reset(
        std::shared_ptr<const AMP::TimeIntegrator::TimeIntegratorParameters> parameters ) override;
 
    void printStatistics( std::ostream &os = AMP::pout ) override;
 
    int
    integratorSpecificAdvanceSolution( const double dt,
                                       const bool first_step,
                                       std::shared_ptr<AMP::LinearAlgebra::Vector> in,
                                       std::shared_ptr<AMP::LinearAlgebra::Vector> out ) override;
 
    void registerDataManagerCallback( DataManagerCallBack callBackFn )
    {
        d_registerVectorForManagement = callBackFn;
    }
 
    void registerVectorsForMemoryManagement( void );
 
    double getGamma( void ) override;
 
    std::vector<double> getTimeHistoryScalings( void ) override;
 
    size_t sizeOfTimeHistory() const override { return d_max_integrator_index + 1; }
 
    const auto &getTimeHistoryVectors() { return d_prev_solutions; }
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> getTimeHistorySourceTerm() override
    {
        return d_integrator_source_vector;
    }
 
    std::string type() const override { return "BDFIntegrator"; }
 
public: // Write/read restart data
    void registerChildObjects( AMP::IO::RestartManager *manager ) const override;
 
    void writeRestart( int64_t fid ) const override;
 
    BDFIntegrator( int64_t fid, AMP::IO::RestartManager *manager );
 
protected:
    /*
     * Helper functions.
     */
 
    void getFromInput( std::shared_ptr<AMP::Database> input_db );
 
    double integratorSpecificGetNextDt( const bool good_solution,
                                        const int solver_retcode ) override;
 
    double getNextDtTruncationError( const bool good_solution, const int solver_retcode );
    double getNextDtPredefined( const bool good_solution, const int solver_retcode );
    double getNextDtConstant( const bool good_solution, const int solver_retcode );
    double getNextDtFinalConstant( const bool good_solution, const int solver_retcode );
 
    void integratorSpecificInitialize( void ) override;
 
    //  int integratorSpecificAdvanceSolution( const double dt, const bool first_step ) override;
 
    bool integratorSpecificCheckNewSolution( const int solver_retcode ) override;
 
    void integratorSpecificUpdateSolution( const double new_time ) override;
 
    void computeIntegratorSourceTerm( void );
 
    double estimateDtWithTruncationErrorEstimates( double current_dt, bool good_solution );
 
    void estimateFrontSpeed();
 
    void evaluatePredictor( void );
 
    void evaluateAB2Predictor( void );
 
    void evaluateLeapFrogPredictor( void );
 
    void evaluateBDFInterpolantPredictor( void );
 
    void evaluateForwardEulerPredictor( void );
 
    void estimateBDF2TimeDerivative( void );
 
    void estimateCNTimeDerivative( void );
 
    void estimateBETimeDerivative( void );
 
    void estimateTimeDerivative( void );
 
    double calculateLTEScalingFactor( void );
 
    void calculateScaledLTENorm( std::shared_ptr<AMP::LinearAlgebra::Vector> x,
                                 std::shared_ptr<AMP::LinearAlgebra::Vector> y,
                                 std::vector<double> &norms );
    void calculateTemporalTruncationError( void );
 
    void printVectorComponentNorms( const std::shared_ptr<AMP::LinearAlgebra::Vector> &vec,
                                    const std::string &prefix,
                                    const std::string &postfix,
                                    const std::string &norm );
 
    void setTimeHistoryScalings() override;
 
    void setPredictorType( const std::string &predictor = "" );
 
    void setMultiPhysicsScalings( void );
 
    DataManagerCallBack d_registerVectorForManagement;
 
#ifdef ENABLE_RESTART
    std::shared_ptr<RestartData> d_restart_data;
#endif
 
    std::vector<std::shared_ptr<AMP::LinearAlgebra::Vector>> d_prev_solutions;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_integrator_source_vector = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_predictor_vector = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_timederivative_vector = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_scratch_vector = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_scratch_function_vector = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_current_function_vector = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_prev_function_vector = nullptr;
 
    std::shared_ptr<AMP::LinearAlgebra::Vector> d_old_td_vector = nullptr;
 
    std::vector<int> d_nonlinearIterations;
 
    std::vector<int> d_linearIterations;
 
    std::vector<int> d_step_accepted;
 
    std::vector<std::vector<double>> d_LTE;
 
    std::vector<double> d_timesteps;
 
    std::vector<double> d_times;
 
    std::vector<double> d_integrator_order;
 
    std::vector<double> d_integrator_steps;
 
    std::vector<std::string> d_integrator_names;
 
    std::vector<std::string> d_vector_names;
 
    std::vector<std::string> d_var_names;
 
    std::vector<double> d_a;
 
    std::string d_timeTruncationErrorNormType = "l2Norm";
 
    std::string d_implicit_integrator = "BDF2";
 
    std::string d_bdf_starting_integrator = "CN";
 
    std::string d_timestep_strategy = "truncationErrorStrategy";
 
    std::string d_pi_controller_type = "PC.4.7";
 
    std::string d_time_error_scaling = "fixed_scaling";
 
    std::string d_predictor_type = "leapfrog";
 
    std::string d_initial_predictor_type = "forward_euler";
 
    std::list<double> d_l2errorNorms_E;
    std::list<double> d_l2errorNorms_T;
 
    std::vector<double> d_problem_scales;
 
    double d_new_time = std::numeric_limits<double>::signaling_NaN();
 
    double d_first_initial_dt = 0.0;
 
    double d_alpha = 1.0;
 
    double d_DtCutLowerBound = std::numeric_limits<double>::signaling_NaN();
 
    double d_DtGrowthUpperBound = std::numeric_limits<double>::signaling_NaN();
 
    double d_time_atol = std::numeric_limits<double>::signaling_NaN();
 
    double d_time_rtol = std::numeric_limits<double>::signaling_NaN();
 
    double d_prevTimeTruncationErrorEstimate = 1.0;
 
    double d_timeTruncationErrorEstimate = 1.0;
 
    double d_timeErrorEstimateRatio = 1.0;
 
    double d_target_relative_change = 0.1;
 
    double d_gamma = 0.0;
 
    size_t d_max_integrator_index = static_cast<size_t>( -1 );
 
    size_t d_integrator_index = 0;
 
    int d_timesteps_after_regrid = 0;
 
    int d_enable_picontrol_regrid_steps = 0;
 
    int d_bdf1_eps_regrid_steps = 0;
 
    int d_current_steprejects = 0;
 
    int d_current_stepaccepts = 0;
 
    int d_solver_converged_reason = -1;
 
    int d_nonlinear_iterations = 0;
 
    int d_linear_iterations = 0;
 
    int d_evaluatefunction_count = 0;
 
    int d_number_of_time_intervals = -1;
 
    int d_number_initial_fixed_steps = 0;
 
    bool d_auto_component_scaling = false;
 
    int d_final_constant_timestep_current_step = 1;
 
    bool d_log_statistics = true;
 
    bool d_is_after_regrid = false;
 
    bool d_is_new_timestep = true;
 
    bool d_combine_timestep_estimators = false;
 
    bool d_control_timestep_variation = false;
 
    bool d_use_predictor = true;
 
    bool d_use_initial_predictor = true;
 
    bool d_use_bdf1_estimator_on_regrid = true;
 
    bool d_prevSuccessiveRejects = false;
 
    bool d_use_constant_time_interpolation = false;
 
    bool d_use_pi_controller = true;
 
    bool d_calculateTimeTruncError = false;
 
    bool d_reset_after_restart = false;
 
    bool d_vectors_registered_for_mgmt = false;
};
 
} // namespace TimeIntegrator
} // namespace AMP
 
#endif