StochasticTrajectory.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_STOCHASTICTRAJECTORY_H_INCLUDED
#define CPPQEDCORE_UTILS_STOCHASTICTRAJECTORY_H_INCLUDED


#include "StochasticTrajectoryFwd.h"

#include "Trajectory.h"
#include "Randomized.h"


#include <boost/ptr_container/ptr_vector.hpp>


namespace trajectory {



template<typename T> 
class Averageable : public virtual Trajectory
{
public:
  virtual ~Averageable() {}

  const T toBeAveraged() const {return toBeAveraged_v();} 

private:
  virtual const T toBeAveraged_v() const = 0;

};



template<typename A, typename T>
class Stochastic : public Adaptive<A>, public Averageable<T>
{
public:
  virtual ~Stochastic() {}

private:
  typedef Adaptive<A> Base;

  typedef typename Base::Evolved Evolved;

  typedef randomized::Randomized::Ptr RandomizedPtr;

protected:

  Stochastic(A&, typename Evolved::Derivs, double dtInit, 
             double epsRel, double epsAbs, const A& scaleAbs, 
             const evolved::Maker<A>&,
             unsigned long seed,
             bool noise,
             const randomized::Maker&); 

  Stochastic(A&, typename Evolved::Derivs, double dtInit,
             const A& scaleAbs, const ParsStochastic&,
             const evolved::Maker<A>&,
             const randomized::Maker&); 

  

  const RandomizedPtr getRandomized() const {return randomized_;}
  bool                isNoisy      () const {return isNoisy_   ;}
  
  std::ostream& displayParameters_v(std::ostream&) const override;
  

  cpputils::iarchive&  readStateMore_v(cpputils::iarchive& iar)       override {return iar & *randomized_;}
  cpputils::oarchive& writeStateMore_v(cpputils::oarchive& oar) const override {return oar & *randomized_;}
  
private:
  const unsigned long seed_ ;
  const bool          isNoisy_;

  const RandomizedPtr randomized_;

};



namespace ensemble {

template<typename T>
class Base {};

} // ensemble




template<typename T, typename T_ELEM>
class Ensemble : public Averageable<T>, public ensemble::Base<T>
{
private:
  typedef Averageable<T     > Base;
  
public:
  typedef Averageable<T_ELEM> Elem;


  typedef boost::ptr_vector<Elem> Impl;
  
  typedef T ToBeAveragedType;


  const ToBeAveragedType averageInRange(size_t begin, size_t n) const;

  virtual ~Ensemble() {}

protected:
  typedef std::auto_ptr<Impl> Ptr;
  
  Ensemble(Ptr trajs, 
           bool displayProgress 
          ) : trajs_(trajs), displayProgress_(displayProgress) {}

  const Impl& getTrajectories() const {return trajs_;}

#define FOR_EACH_function(f) for_each(trajs_,bind(&Elem::f,_1,boost::ref(ios))); return ios;
  

  virtual cpputils::iarchive&  readState_v(cpputils::iarchive& ios)       final {FOR_EACH_function( readState)}
  virtual cpputils::oarchive& writeState_v(cpputils::oarchive& ios) const final {FOR_EACH_function(writeState)}
  
private:
  std::ostream& logOnEnd_v(std::ostream& ios) const override {FOR_EACH_function(logOnEnd)}

#undef FOR_EACH_function
  
  virtual void evolve_v(double deltaT) final;

  virtual double getTime_v() const final {return trajs_.front().getTime();}

  virtual std::ostream& displayParameters_v(std::ostream&) const final;

  virtual double getDtDid_v() const final;
  // An average of getDtDid()-s from individual trajectories.

  virtual const ToBeAveragedType toBeAveraged_v() const final {return averageInRange(0,trajs_.size());}

  Impl trajs_; // cannot be const because ptr_vector “propagates constness” (very correctly)

  const bool displayProgress_;

};


namespace ensemble {


template<typename T, typename T_ELEM>
class Traits
{
public:
  typedef Ensemble<T,T_ELEM> EnsembleType;

  typedef typename EnsembleType::Elem             Elem            ;
  typedef typename EnsembleType::Impl             Impl            ;
  typedef typename EnsembleType::ToBeAveragedType ToBeAveragedType;

  static const ToBeAveragedType averageInRange(typename Impl::const_iterator, typename Impl::const_iterator, const EnsembleType&);

};

} // ensemble


} // trajectory


#endif // CPPQEDCORE_UTILS_STOCHASTICTRAJECTORY_H_INCLUDED