EMM_IterativeTimeStep.h

Go to the documentation of this file.

#ifndef EMM_IterativeTimeStep_H
#define EMM_IterativeTimeStep_H

#include "EMM_RegularTimeStep.h"

#include "EMM_RealField.h"
#include "MATH_P4.h"
DEFINE_SPTR(EMM_IterativeTimeStep);
class EMM_IterativeTimeStep : public EMM_RegularTimeStep {
  
    SP_OBJECT(EMM_IterativeTimeStep);
    // ATTRIBUTES
    
public:

  
    
  
  
    static const tFlag INITIAL_TIME_AS_REGULAR;
    static const tFlag INITIAL_TIME_AS_OPTIMAL_AFFINE_H;
    static const tFlag INITIAL_TIME_AS_MAX_LINEAR_CONSTANT_H;
    
private:
    tReal mZoomOutFactor;
    tReal mZoomInFactor;
    tReal mMaxTimeStepGap;
    tReal mTimeStepBound;
    tReal mMinTimeStep;
    tUInteger mMaxEvaluationsNumber;

    tFlag mOrder;
    tFlag mInitialTimeType;
    tBoolean mIsInitialTimeStepReset;
    
    
    SP::EMM_RealField mGradH_GradF_F;
    SP::EMM_RealField mGradF_F;
    tReal mT[4];
    MATH_P4 mP4;
  
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_IterativeTimeStep(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~EMM_IterativeTimeStep(void);   
  
  
private:

public:
   
    
    // SET methods 

    inline void setMinTimeStep(const tReal& dt) {
        mMinTimeStep=dt;
    }
    
    inline void setInitialTimeType(const tFlag& t) {
        mInitialTimeType=t;
    }
    inline void setInitialTimeType(const tString& t) {
        if (t.compare("regular")==0) mInitialTimeType=INITIAL_TIME_AS_REGULAR;
        else if (t.compare("optimal-linear")==0) mInitialTimeType=INITIAL_TIME_AS_OPTIMAL_AFFINE_H;
        else  mInitialTimeType=INITIAL_TIME_AS_MAX_LINEAR_CONSTANT_H;
    }
    inline void resetInitialTimeStepToOptimalOne(const tBoolean& isReset) {
        mIsInitialTimeStepReset=isReset;
    }
    
    inline void setIntegrationOrder(const tFlag& order) {
        mOrder=order;
    }
 
    inline void setMaximumEvaluationsNumber(const tUInteger& n) {
        mMaxEvaluationsNumber=n;
    }
    inline void setZoomOutFactor(const tReal& z) {
        mZoomOutFactor=(z>1)?z:1.1;
    }
    inline void setZoomInFactor(const tReal& z) {
        mZoomInFactor=(z<1)?z:0.1;
    }
    inline void setMaxTimeStepGap(const tReal& dt) {
        mMaxTimeStepGap=dt;
    }
    inline void setTimeStepBound(const tReal& dt) {
        mTimeStepBound=dt;
    }


    
    
    
    // GET methods

    inline const tReal& getMinTimeStep() const {
        return mMinTimeStep;
    }

    inline const tFlag&  getInitialTimeType() const {
        return mInitialTimeType;
    }
    
    
    inline const tUInteger&  getMaximumEvaluationsNumber() const {
        return mMaxEvaluationsNumber;
    }
    inline const tReal&  getZoomOutFactor() const {
        return mZoomOutFactor;
    }
    inline const tReal&  getZoomInFactor() const {
        return mZoomInFactor;
    }
    inline const tFlag&  getIntegrationOrder() const {
        return mOrder;
    }
    inline const tReal&  getMaximumTimeStepGap() const {
        return mMaxTimeStepGap;
    }
    inline const tReal& getTimeStepBound() const {
        return mTimeStepBound;
    }
public:
    tReal computeInitialTimeStep();
protected:
    void computeOptimalTimeSteps(tReal& dt_c,tReal& dt_l);
    
public:
    virtual tBoolean computeNewTimeStep(tReal& dt,tUInteger& nEvaluations);

    tReal computeTimeFunction(const tReal& t);
    
    const tReal& computeTimeFunction() const;

    tReal computeTimeFunctionDerivative(const tReal& t,tReal& dF_dt);
    
    const tReal& computeTimeFunctionDerivative(tReal& dF_dt_0) const;
    

    

protected:
    virtual tBoolean optimizeTimeFunction(tReal& dt,const tReal& dt_bound,tUInteger& evaluationsNumber)=0;
    
    
public:
    // OTHERS methods

    virtual tString toString() const;
  
};

#endif