LiouvilleanAveragedCommon.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_STRUCTURE_LIOUVILLEANAVERAGEDCOMMON_H_INCLUDED
#define   CPPQEDCORE_STRUCTURE_LIOUVILLEANAVERAGEDCOMMON_H_INCLUDED

#include "LiouvilleanAveragedCommonFwd.h"

#include "Types.h"

#include "BlitzArray.h"
#include "BlitzArrayExtensions.h"
#include "Exception.h"

#include <boost/shared_ptr.hpp>

namespace structure {

enum LiouvilleanAveragedTag {
  LA_Li, 
  LA_Av  
};

template<LiouvilleanAveragedTag>
struct LiouvilleanAveragedTag_ {LiouvilleanAveragedTag_() {}};

typedef LiouvilleanAveragedTag_<LA_Li> LA_Li_tagType;
typedef LiouvilleanAveragedTag_<LA_Av> LA_Av_tagType;

const LA_Li_tagType LA_Li_tag;
const LA_Av_tagType LA_Av_tag;


class LiouvilleanAveragedCommon
{
public:
  typedef boost::shared_ptr<const LiouvilleanAveragedCommon> Ptr;

  typedef DArray<1> DArray1D; 

  virtual ~LiouvilleanAveragedCommon() {}


  std::ostream& displayKey(std::ostream& o,
                           size_t& i 
                          ) const {return displayKey_v(o,i);}


  size_t nAvr() const {return nAvr_v();}
  
private:
  virtual std::ostream& displayKey_v(std::ostream&, size_t&) const = 0;
  virtual size_t        nAvr_v      (                      ) const = 0;


};


struct AveragesNumberMismatchException : cpputils::Exception
{
  AveragesNumberMismatchException(int size, size_t nAvr) {std::cerr<<size<<' '<<nAvr<<std::endl;}
  
};


struct InfiniteDetectedException : cpputils::Exception {};



template<int RANK>
class LiouvilleanAveragedCommonRanked : public LiouvilleanAveragedCommon
{
public:
  typedef boost::shared_ptr<const LiouvilleanAveragedCommonRanked> Ptr;
  
  typedef typename LiouvilleanAveragedCommon::DArray1D DArray1D;

  typedef quantumdata::LazyDensityOperator<RANK> LazyDensityOperator;

  virtual ~LiouvilleanAveragedCommonRanked() {}


  const DArray1D average(double t, 
                         const LazyDensityOperator& matrix 
                        ) const
  {
    const DArray1D averages(average_v(t,matrix));
    if (size_t(averages.size())!=nAvr()) throw AveragesNumberMismatchException(averages.size(),nAvr()); 
    if (!all(blitzplusplus::isfinite(averages))) throw InfiniteDetectedException(); 

    return averages;
  }

private:
  virtual const DArray1D average_v(double, const LazyDensityOperator&) const = 0;
  
};


} // structure



#endif // CPPQEDCORE_STRUCTURE_LIOUVILLEANAVERAGEDCOMMON_H_INCLUDED