Evolved.h

Go to the documentation of this file.

// Copyright András Vukics 2006–2014. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.txt)
// -*- C++ -*-
#ifndef CPPQEDCORE_UTILS_EVOLVED_H_INCLUDED
#define CPPQEDCORE_UTILS_EVOLVED_H_INCLUDED

#include "EvolvedFwd.h"

#include "core_config.h"

#include <boost/shared_ptr.hpp> // instead of std::tr1::shared_ptr
#include <boost/function.hpp>   // instead of std::tr1::function
#include <boost/utility.hpp>

#ifndef DO_NOT_USE_BOOST_SERIALIZATION
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/split_member.hpp>
#endif // DO_NOT_USE_BOOST_SERIALIZATION


namespace evolved {



enum SteppingFunction {SF_RKCK, SF_RK8PD};


std::ostream& operator<<(std::ostream&, SteppingFunction);
std::istream& operator>>(std::istream&, SteppingFunction&);



class TimeStepBookkeeper
{
public:

  double getTime(        ) const {return t_;}
  void   setTime(double t)       {t_=t;}

  double getDtDid() const {return dtDid_;} 

  double getDtTry(            ) const {return dtTry_;} 


  void   setDtTry(double dtTry)       {dtTry_=dtTry;}


  double getEpsRel() const {return epsRel_;} 
  double getEpsAbs() const {return epsAbs_;} 


  void update(double t, double dtTry);

  TimeStepBookkeeper& operator=(const TimeStepBookkeeper&); 

protected:
  TimeStepBookkeeper(double dtInit, 
                     double epsRel, 
                     double epsAbs  
                    );

private:
#ifndef DO_NOT_USE_BOOST_SERIALIZATION
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive& ar, const unsigned int) {ar & t_ & dtDid_ & dtTry_;}
#endif // DO_NOT_USE_BOOST_SERIALIZATION

  double t_, dtTry_, dtDid_;

  const double epsRel_, epsAbs_;

};



template<typename A>
class EvolvedIO : public TimeStepBookkeeper, private boost::noncopyable
{
public:
  typedef boost::shared_ptr<EvolvedIO>            Ptr;
  typedef boost::shared_ptr<const EvolvedIO> ConstPtr;

  EvolvedIO(A&, double dtInit, double epsRel, double epsAbs);

  using TimeStepBookkeeper::operator=;

  A      & getA()       {return this->a_;}
  A const& getA() const {return this->a_;}

  virtual ~EvolvedIO() {} 

private:

#ifndef DO_NOT_USE_BOOST_SERIALIZATION


  friend class boost::serialization::access;
  template<class Archive>
  void save(Archive& ar, const unsigned int) const
  {A temp(a_); ar & temp & boost::serialization::base_object<TimeStepBookkeeper>(*this);}

  template<class Archive>
  void load(Archive& ar, const unsigned int)
  {A temp; ar & temp & boost::serialization::base_object<TimeStepBookkeeper>(*this); a_.reference(temp);}

  BOOST_SERIALIZATION_SPLIT_MEMBER()

#endif // DO_NOT_USE_BOOST_SERIALIZATION

  A& a_;

};




template<typename A>
class Evolved : public EvolvedIO<A>
{
public:
  typedef boost::function<void(double, const A&, A&)> Derivs; 

  typedef boost::shared_ptr<      Evolved>      Ptr;
  typedef boost::shared_ptr<const Evolved> ConstPtr;
  
  Evolved(A&, Derivs, double dtInit, double epsRel, double epsAbs);

  using TimeStepBookkeeper::operator=;
  using EvolvedIO<A>::getA;

  virtual ~Evolved() {}

  void step(double deltaT 
            );

  std::ostream& displayParameters(std::ostream& os) const {return displayParameters_v(os);} 


  const Derivs getDerivs() const {return derivs_;}

  size_t nFailedSteps() const {return nFailedSteps_v();} 

private:
  virtual void step_v(double deltaT) = 0;
  virtual std::ostream& displayParameters_v(std::ostream&) const = 0;
  virtual size_t nFailedSteps_v() const = 0;


  Derivs derivs_;

};




template<typename E>
void evolve(E&, double deltaT);


template<typename E>
void evolveTo(E& e, double t)
{
  evolve(e,t-e.getTime());
}




template<typename A>
class Maker
{
public:
  typedef typename Evolved<A>::Ptr Ptr;
  typedef typename Evolved<A>::Derivs Derivs;
  
  const Ptr operator()(A& array, Derivs derivs, double dtInit, double epsRel, double epsAbs,
                       const A& scaleAbs 
                      ) const {return make(array,derivs,dtInit,epsRel,epsAbs,scaleAbs);}

  virtual ~Maker() {}
  
private:
  virtual const Ptr make(A&, Derivs, double dtInit, double epsRel, double epsAbs, const A& scaleAbs) const = 0;

};



} // evolved


#endif // CPPQEDCORE_UTILS_EVOLVED_H_INCLUDED