EnsembleMCWF.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)
#ifndef CPPQEDCORE_QUANTUMTRAJECTORY_ENSEMBLEMCWF_H_INCLUDED
#define CPPQEDCORE_QUANTUMTRAJECTORY_ENSEMBLEMCWF_H_INCLUDED

#include "EnsembleMCWFFwd.h"

#include "DO_Display.h"
#include "MCWF_Trajectory.h"
#include "DensityOperator.h"

#include "Conversions.h"
#include "SmartPtr.h"


namespace quantumtrajectory {


namespace ensemble {

using namespace mcwf;

#define STATE_VECTORS(r) boost::ptr_vector<quantumdata::StateVector<r> >

#define BASE_class trajectory::Ensemble< quantumdata::DensityOperator<RANK>&, const quantumdata::StateVector<RANK>& >

template<int RANK>
class Base
  : private boost::base_from_member<STATE_VECTORS(RANK) >,
    public BASE_class
{
private:
  typedef STATE_VECTORS(RANK) StateVectors;

#undef  STATE_VECTORS

protected:
  typedef BASE_class Ensemble;

#undef  BASE_class

private:
  typedef typename Ensemble::Impl Trajectories;

  typedef boost::base_from_member<StateVectors> StateVectorsBase;

  typedef MCWF_Trajectory<RANK> Single;

public:
  typedef typename Single::StateVector    StateVector   ;
  typedef typename Single::StateVectorLow StateVectorLow; 

  typedef typename structure::QuantumSystem<RANK>::Ptr QuantumSystemPtr;

protected:
  Base(
       const StateVector& psi, 
       QuantumSystemPtr sys, 
       const Pars& p, 
       const StateVectorLow& =StateVectorLow()
       );

  const QuantumSystemPtr getQS() const {return qs_;}

private:
  virtual std::ostream& logOnEnd_v(std::ostream& os) const final;
  
  // static helpers to constructor
  static std::auto_ptr<StateVectors> stateVectors(const StateVector& psi, size_t nTraj);
  static std::auto_ptr<Trajectories> trajectories(StateVectors& psis, QuantumSystemPtr qs, const Pars& p, const StateVectorLow& scaleAbs);

  
  virtual quantumdata::DensityOperator<RANK>& getInitializedDensityOperator_v() const final {rho_=0; return rho_;}

  mutable quantumdata::DensityOperator<RANK> rho_;

  const QuantumSystemPtr qs_;

  const size_t nBins_, nJumpsPerBin_;

};

} // ensemble



template<int RANK, typename V>
class EnsembleMCWF : public ensemble::Base<RANK>
{
private:
  typedef ensemble::Base<RANK> Base;

  typedef display_densityoperator::_<RANK,V> DO_Display;

public:
  typedef typename Base::StateVectorLow StateVectorLow; 

  typedef typename Base::Ensemble Ensemble;

  typedef typename Base      ::    StateVector     StateVector;
  typedef typename DO_Display::DensityOperator DensityOperator;


  template<typename SYS>
  EnsembleMCWF(
               const StateVector& psi, 
               const SYS& sys, 
               const mcwf::Pars& p, 
               bool negativity, 
               const StateVectorLow& scaleAbs=StateVectorLow() 
               )
    : Base(psi,cpputils::sharedPointerize(sys),p,scaleAbs), doDisplay_(structure::qsa<RANK>(this->getQS()),negativity) {}

private:
  virtual std::ostream& display_v   (std::ostream& os, int precision) const final {return doDisplay_.display   (this->getTime(),this->toBeAveraged(),os,precision);}
  virtual std::ostream& displayKey_v(std::ostream& os, size_t& i    ) const final {return doDisplay_.displayKey(os,i);}

  const DO_Display doDisplay_;

};


} // quantumtrajectory

namespace trajectory { namespace ensemble {


template<int RANK>
class Base<quantumdata::DensityOperator<RANK>&>
{
public:
  quantumdata::DensityOperator<RANK>& getInitializedDensityOperator() const {return getInitializedDensityOperator_v();}

private:
  virtual quantumdata::DensityOperator<RANK>& getInitializedDensityOperator_v() const = 0;
  
};


template<int RANK>
class Traits<quantumdata::DensityOperator<RANK>&, const quantumdata::StateVector<RANK>&>
{
public:
  typedef Ensemble<quantumdata::DensityOperator<RANK>&, const quantumdata::StateVector<RANK>&> EnsembleType;

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

  static const ToBeAveragedType averageInRange(typename Impl::const_iterator begin, typename Impl::const_iterator end, const EnsembleType& et)
  {
    ToBeAveragedType res(et.getInitializedDensityOperator());
    
    for (auto i=begin; i!=end; i++) i->toBeAveraged().addTo(res);

    return res/=size2Double(end-begin);

  }


};

 
} } // trajectory::ensemble

#endif // CPPQEDCORE_QUANTUMTRAJECTORY_ENSEMBLEMCWF_H_INCLUDED