AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

solver.h

Go to the documentation of this file.

#ifndef ANIMAL_INTEGRATION_SOLVER_H
#define ANIMAL_INTEGRATION_SOLVER_H

#include <pending/animal/numerics.hpp>
#include <animal/io.h>



namespace animal { namespace integration {



// /** \class SolverBase 
//  Base class for all time differential equation solvers.

//  A SolverBase integrates a function of time over a given time step. Contrary with a Stepper, a Solver can NOT decide to subdivide the given time step for purposes of accuracy.
    

//*/

//class SolverBase {

//  /// Destructor does nothing
//  virtual ~Solver(){}

//};





// ----------------------------------
//  
//  
// ----------------------------------

template 
<
  class DerivativeF,
  class StepF,
  class TraitsT
>

struct Solver
{

  typedef TraitsT                     Traits;

  typedef typename Traits::Real       Real;

  typedef typename Traits::State      State;

  typedef typename Traits::CopyState      CopyState;

  typedef typename Traits::Derivative Derivative;

  typedef typename Traits::SizeType   SizeType;



  Traits       traits;

    DerivativeF  writeDerivative;

  StepF        applyStep;


  

  Solver
    (
        const DerivativeF& df = DerivativeF(), 
        const StepF& sf = StepF(), 
        const Traits& tr = Traits()
    )
  : traits( tr )
    , writeDerivative(df)
    , applyStep(sf)
  {}
  
  virtual ~Solver(){}

  

  virtual void doStep
    (
          const State& initial_S,
          State& final_S,
          const Derivative& initial_D,
          const Real t, 
            const Real h
    )
    = 0;    // pure virtual method
    
    

    template< class S >
    void operator()
    (
        const State& initial_S,
        S& final_S,
        const Real t, 
        const Real h
    )
  {
        //cout<<"write derivative:"<<endl;
    writeDerivative( initial_S, D1, t );
    //cout<<"Euler, D1 = "; print(D1);
    doStep( initial_S, final_S, D1, t, h );
  }
    
    
    template< class S >
  void operator ()
    (
        S& s,
        const Real t, 
        const Real h
    )
  {
    operator()( s, s, t, h );
  }



  void resize( const SizeType size )
    { 
        traits.resize( D1, size );
        setSize( size );
    }

    
protected:

    Derivative D1;
    
    virtual void setSize( const SizeType size ) = 0;

};


// \example solver_basic.cpp
//  Time integration of the cos(t) function  
//
// \example solver_dimN.cpp
//  Time integration of an n-dimensional function of time  


//============================================================================

// An example of a different CopyStateT is given in example solver_big.cpp
 
template <
  class StateT,
  class DerivativeT,
    class CopyStateT = StateT,
  class RealT = double,
  class NumTraitsT = animal::Numerics<RealT>,
    class SizeTypeT = unsigned int
>

struct Solver_Traits
{
  typedef RealT Real;
  
  typedef StateT State;
    
    typedef CopyStateT CopyState;
  
  typedef DerivativeT Derivative;
  
  typedef  NumTraitsT Numerics;
  
  typedef  SizeTypeT SizeType;

  void average( const State& s1, const State& s2, State& result ) const 
  {
      result = (s1 + s2)/2;
  }

  void rk4Step ( 
      const Derivative& d1,
      const Derivative& d2,
      const Derivative& d3,
      const Derivative& d4,
      Derivative& sum
  )
  const
  {
      sum = d1 + (d2 + d3)*2 + d4;
  }

  void copy( 
      const State& s,
      CopyState& cs
  )
  const
  {
      cs = s;
  }

  template <class Container>
  void resize ( Container& , const unsigned int) const{}

};




//==============================================================================


template <
  class StateT,
  class DerivativeT,
    class CopyStateT = StateT,
  class RealT = double,
  class NumTraitsT = animal::Numerics<RealT>,
    class SizeTypeT = unsigned int
>

struct Solver_Traits_M
{
  typedef RealT Real;
  
  typedef StateT State;
    
    typedef CopyStateT CopyState;
  
  typedef DerivativeT Derivative;
  
  typedef  NumTraitsT Numerics;
  
  typedef  SizeTypeT SizeType;

  template <class Container>
  void resize ( Container& c, const unsigned int size ) const
  {
      c.resize( size );
  }     

  void average( const State& s1, const State& s2, State& result ) const 
  {
      typename State::const_iterator is1=s1.begin(), end=s1.end();
      typename State::const_iterator is2=s2.begin();
      typename State::iterator r=result.begin();
      for( ; is1!=end; ++is1, ++is2, ++r )
          *r = (*is1 + *is2) *0.5;
  }

  void rk4Step ( 
      const Derivative& d1,
      const Derivative& d2,
      const Derivative& d3,
      const Derivative& d4,
      Derivative& sum
  )
  const
  {
      typename Derivative::const_iterator id1 = d1.begin(), end=d1.end();
      typename Derivative::const_iterator id2 = d2.begin();
      typename Derivative::const_iterator id3 = d3.begin();
      typename Derivative::const_iterator id4 = d4.begin();
      typename Derivative::iterator s = sum.begin();
      for( ; id1!=end; ++id1, ++id2, ++id3, ++id4, ++s )
          *s = *id1 + (*id2 + *id3)*2 + *id4;
  }

  void copy( 
      const State& s,
      CopyState& cs
  )
  const
  {
      cs = s;
  }
    
};
// \example solver_big.cpp
//  Customization of Solver_Traits so that we avoid copying irrelevant data.




template <class TraitsT>

struct Derivative_Function
{
  typedef typename TraitsT::Real       Real;       
  typedef typename TraitsT::State      State;      
  typedef typename TraitsT::Derivative Derivative; 
  typedef typename TraitsT::Numerics   Numerics;   
  
  virtual void operator()
    (
        const State& S,
        Derivative& D,
        const Real t
    ) 
    const
    = 0;
    
};



template <class TraitsT>

struct Step_Function
{
  typedef typename TraitsT::Real       Real;        
  typedef typename TraitsT::State      State;       
  typedef typename TraitsT::Derivative Derivative;  
  typedef typename TraitsT::Numerics   Numerics;    
  
  virtual void operator()
    (
        const State& initial_S,
        State& final_S,
        const Derivative& D,
        const Real h
    ) 
    const
    = 0;
    
};

} // end namespace integration
} // end namespace animal



#endif // ANIMAL_INTEGRATION_SOLVER_H

---