ode_base.h

Go to the documentation of this file.

 
#ifndef ODE_BASE_H_
#define ODE_BASE_H_
 
#include <string>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cmath>
 
#include "ode_io.h"
#include "ode_util.h"
 
namespace ode {
 
 
class OdeBase {
 
    public:
 
        OdeBase (unsigned long neq, bool need_jac);
        virtual ~OdeBase ();
 
        //-------------------
        //getters and setters
 
        const char *get_name () { return(name_.c_str()); }
        const char *get_method () { return(method_.c_str()); }
        const char *get_dirout () { return(dirout_.c_str()); }
        bool get_quiet () { return(quiet_); }
        bool get_silent_snap () { return(silent_snap_); }
        unsigned long get_neq () { return(neq_); }
 
        double get_t () { return(t_); }
        double get_dt () { return(dt_); }
        double *get_sol () { return(sol_); }
 
        double get_sol (unsigned long i) { return(sol_[i]); }
        long unsigned get_nstep () { return(nstep_); }
        long unsigned get_neval () { return(neval_); }
        long unsigned get_icheck () { return(icheck_); }
        long unsigned get_nJac () { return(nJac_); }
 
 
        void set_t (double t) { t_ = t; }
 
        void set_sol (unsigned long i, double x) { sol_[i] = x; }
 
        void set_sol (double *sol) { for(unsigned long i=0; i<neq_; i++) sol_[i] = sol[i]; }
        void set_name (std::string name) { name_ = name; }
        void set_name (const char *name) { name_ = name; }
        void set_quiet (bool quiet) { quiet_ = quiet; }
        void set_silent_snap (bool silent_snap) { silent_snap_ = silent_snap; }
        void set_icheck (unsigned long icheck) { icheck_ = icheck; }
 
        //----------------
        //solver functions
 
        void step (double dt, bool extra=true);
 
 
        void solve_fixed (double tint, double dt, bool extras=true);
 
 
        void solve_fixed (double tint, double dt, const char *dirout, int inter=1);
 
 
        void solve_fixed (double tint, double dt, unsigned long nsnap, const char *dirout);
 
 
        void solve_fixed (double dt, double *tsnap, unsigned long nsnap, const char *dirout);
 
 
        void reset (double t, double *sol);
 
    protected:
 
 
        void solve_fixed_ (double tint, double dt, bool extra=true);
 
        //----------------------
        //basic solver variables
 
        std::string name_;
        std::string method_;
        std::string dirout_;
        bool quiet_;
        bool silent_snap_;
        unsigned long neq_;
        double t_;
        double dt_;
        double *sol_;
        long unsigned nstep_;
        long unsigned neval_;
        long unsigned icheck_;
        double **Jac_;
        long unsigned nJac_;
        double absjacdel_;
        double reljacdel_;
 
        //---------------------------
        //essential virtual functions
 
 
        virtual void ode_fun (double *solin, double *fout) = 0;
 
 
        virtual void ode_jac (double *solin, double **Jout);
 
 
        virtual void step_ (double dt) = 0;
 
        //---------------------------------------
        //wrappers of essential virtual functions
 
 
        void ode_fun_ (double *solin, double *fout);
 
        void ode_jac_ (double *solin, double **Jout);
 
        //------
        //extras
 
        virtual void before_solve ();
 
        virtual void after_step (double t);
 
        virtual void after_capture (double t);
 
        virtual void after_snap (std::string dirout, long isnap, double t);
 
        virtual void after_solve ();
 
        //--------------
        //solver support
 
 
        void snap (std::string dirout, long isnap, double tsnap);
 
 
        bool solve_done (double dt, double tend);
 
        void check_sol_integrity ();
 
 
        void check_pre_solve (double tint, double dt);
 
 
        void check_pre_snaps (double dt, double *tsnap, unsigned long nsnap);
 
    private:
 
        //flag for whether the Jacobian is being used
        bool need_jac_;
        //arrays for evaluating numerical jacobian
        double *f_, *g_;
};
 
} // namespace ode
 
#endif