ODEIntegrator.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstMath/ODEEventDetectorList.hpp"
#include "AstMath/ODEStateObserverList.hpp"
#include "AstMath/ODEInnerStateObserver.hpp"
#include "AstMath/OrdinaryDifferentialEquation.hpp"
#include "AstUtil/Object.hpp"
#include "AstUtil/ObjectNamed.hpp"
#include <vector>
#include <type_traits>
 
AST_NAMESPACE_BEGIN
 
class ODEEventDetector;
 
class AST_MATH_API IODEIntegrator: public ObjectNamed
{
public:
    IODEIntegrator() = default;
    virtual ~IODEIntegrator() {};
    IODEIntegrator(const IODEIntegrator&) = delete;
    IODEIntegrator& operator=(const IODEIntegrator&) = delete;
 
    virtual errc_t initialize(ODE& ode) = 0;
 
 
    virtual errc_t integrate(ODE& ode, double* y,double& t, double tf) = 0;
 
 
    virtual errc_t integrateOneStep(ODE& ode, double* y, double& t, double tf) = 0;
 
    virtual errc_t singleStep(ODE& ode, double* y, double t0, double step) = 0;
};
 
 
class AST_MATH_API ODEIntegrator : public IODEIntegrator
{
public:
    ODEIntegrator() = default;
    ~ODEIntegrator() override;
 
    using IODEIntegrator::integrate;
 
    errc_t initialize(ODE& ode) override;
 
 
    errc_t integrate(
        ODE& ode, double* y, double& t, double tf,
        std::vector<double>& xlist, std::vector<std::vector<double>>& ylist
    );
 
    template<typename Func>
    errc_t integrate(int ndim, Func func, double* y, double& t, double tf)
    {
        auto ode = make_ode(ndim, func);
        return integrate(ode, y, t, tf);
    }
 
    void addEventDetector(ODEEventDetector* detector);
 
    template<typename Func>
    typename std::enable_if<!std::is_base_of<ODEEventDetector, typename std::remove_pointer<Func>::type>::value, ODEEventDetector*>::type
    addEventDetector(Func func) {
        ODEEventDetector* detector = new ODEEventDetectorGeneric<Func>(std::move(func));
        addEventDetector(detector);
        return detector;
    }
 
    void removeEventDetector(ODEEventDetector* detector);
 
    void clearEventDetectors();
 
    void clearStateObservers();
 
    void addStateObserver(ODEStateObserver* observer);
 
 
    template<typename Func>
    typename std::enable_if<!std::is_base_of<ODEStateObserver, typename std::remove_pointer<Func>::type>::value, ODEStateObserver*>::type
    addStateObserver(Func func) {
        auto observer = new ODEStateObserverGeneric<Func>(func);
        addStateObserver(observer);
        return observer;
    }
 
    void removeStateObserver(ODEStateObserver* observer);
 
    ODE* getODE() { return ode_; }
 
    double* stateAtStepStart() { return stateAtStepStart_; }
   
    double* stateAtStepEnd() { return stateAtStepEnd_; }
    
    double& timeAtStepStart() { return timeAtStepStart_; }
    
    double& timeAtStepEnd() { return timeAtStepEnd_; }
 
    double* stateTemp() { return stateTemp_; }
protected:
    errc_t integrateOneFixedStep(ODE& ode, double absStepSize, double* y, double& t, double tf);
    errc_t integrateFixedStep(ODE& ode, double absStepSize, double* y, double& t, double tf, int* pNumSteps=nullptr);
protected:
    friend class ODEInnerStateObserver;
    void initWorkStateObserver();
    A_DISABLE_COPY(ODEIntegrator);
protected:
    ODE* ode_{nullptr};                                     
    ODEStateObserver* workStateObserver_{nullptr};          
    ODEEventDetectorList eventDetectorList_{};               
    ODEStateObserverList stateObserverList_{};               
    ODEInnerStateObserver* innerStateObserver_{nullptr};    
    double* stateAtStepStart_{nullptr};                     
    double* stateAtStepEnd_{nullptr};                       
    double* stateTemp_{nullptr};                            
    double timeAtStepStart_{0.0};                           
    double timeAtStepEnd_{0.0};                             
};
 
 
AST_NAMESPACE_END