---

odenum.h

Go to the documentation of this file.

// FILE odenum.h


#ifndef  INCLUDED_ODENUM_H
#define  INCLUDED_ODENUM_H


#include "odeprobl.h"

#define DEFAULT_ABS_TOL 1e-12
#define DEFAULT_REL_TOL 1e-12


class ODE_NUMERIC : public ODE_PROBLEM
{

public:
  
  ODE_NUMERIC( int n, FCN fcn, const string & name );

  void SetTend( double tEnd );
  
  void SetAtol( double abstol );
  
  void SetRtol( double reltol );
  
  void SetTcur( double t );  
  
  void SetInitEncl( const INTERVAL_VECTOR & Y );
  
  void SetTightEncl( const INTERVAL_VECTOR & Y );
  
  void SetSolution( const PtrSolution Sol );
  
  double GetTend() const; 
  
  double GetAtol() const;
  
  double GetRtol() const; 
  
  double  GetTcur() const;

  double  GetTprev() const;
  
  const INTERVAL_VECTOR & GetInitEncl() const;
  
  const INTERVAL_VECTOR & GetTightEncl() const;
  
  const PtrSolution GetSolution() const ; 
  
  virtual void  LoadProblemParam( int ParamSet );
  
  void DisplaySolution( int comp, const char *file = 0 ) const ;
    
  void DisplayPhase( int comp1, int comp2, const char * file = 0 ) const ;
  
  virtual ~ODE_NUMERIC();
  
private:

  double atol;

  double rtol;

  double Tend;

  PtrSolution  Solution;  

};


typedef ODE_NUMERIC* PtrODENumeric;

template <class T>  
T * GetSolution( PtrODENumeric ODE )
{
  assert( NotNull(ODE) );
  return static_cast<T*>(ODE->GetSolution());
}


template <class T>  
void InitSolution( PtrODENumeric ODE )
{
  assert( NotNull(ODE) );
  assert( NotNull(ODE->GetSolution()) );

  *GetSolution<T>(ODE) = *ODE->GetPtrInitCond();
}


inline ODE_NUMERIC :: ODE_NUMERIC( int n, FCN fcn, const string & name )
  : ODE_PROBLEM( n, fcn, name ),
  atol(DEFAULT_ABS_TOL), 
  rtol(DEFAULT_REL_TOL)
{
  ;
}  


inline void ODE_NUMERIC :: SetTend( double tEnd )   
{ 
  assert( tEnd != GetT0() ||
          NotNull(Solution) && tEnd != Solution->GetTcur() );
  Tend = tEnd;
}


inline void ODE_NUMERIC :: SetAtol( double abstol )    
{ 
  assert(abstol>=0); 
  atol = abstol; 
}


inline void ODE_NUMERIC :: SetRtol( double reltol ) 
{ 
  assert(reltol>=0); 
  rtol = reltol; 
}


inline void ODE_NUMERIC :: SetTcur( double t ) 
{
  assert( NotNull(Solution) );
  assert( (GetTcur() <= t && t <= GetTend()) ||
          (GetTend() <= t && t <= GetTcur()) );
  
  Solution->SetTcur(t); 
}


inline void ODE_NUMERIC :: SetInitEncl( const INTERVAL_VECTOR & Y )
{
  assert( NotNull(Solution) );  
  assert( GetSize() == Dimension(Y) );
  Solution->SetInitEncl(Y); 
}


inline void ODE_NUMERIC :: SetTightEncl( const INTERVAL_VECTOR & Y )
{
  assert( NotNull(Solution) ); 
  assert( GetSize() == Dimension(Y) );
  Solution->SetTightEncl(Y); 
}   
  

inline void ODE_NUMERIC :: SetSolution( const PtrSolution Sol )
{
  assert( NotNull(Sol) && GetSize() == Sol->GetDim() );
  
  DELETE(Solution); 
  Solution = Sol; 
}


inline double ODE_NUMERIC :: GetTend() const 
{ 
  return Tend; 
}  


inline double ODE_NUMERIC :: GetRtol() const 
{ 
  return rtol;
}  


inline double ODE_NUMERIC :: GetAtol() const 
{ 
  return atol;
}  

inline double ODE_NUMERIC :: GetTcur() const
{
  assert( NotNull(Solution) );
  return Solution->GetTcur();
}


inline double ODE_NUMERIC :: GetTprev() const
{
  assert( NotNull(Solution) );
  return Solution->GetTprev();
}


inline const INTERVAL_VECTOR & ODE_NUMERIC :: GetTightEncl() const 
{
  assert( NotNull(Solution) );
  return Solution->GetTightEncl(); 
}


inline const INTERVAL_VECTOR & ODE_NUMERIC :: GetInitEncl() const 
{
  assert( NotNull(Solution) );
  return Solution->GetInitEncl(); 
}


inline const PtrSolution ODE_NUMERIC :: GetSolution() const 
{
  assert( NotNull(Solution) );
  return Solution; 
}


inline void ODE_NUMERIC :: LoadProblemParam( int )
{
  assert(0);
}


inline ODE_NUMERIC :: ~ODE_NUMERIC() 
{ 
  DELETE(Solution); 
}

#endif 

---