C++QEDCore  v2 Milestone 10
a framework for simulating open quantum dynamics – core
Public Types | Public Member Functions | Static Public Attributes | Friends | List of all members
Composite< VA, IS_EX, IS_HA, IS_LI > Class Template Reference

Class representing a full-fledged composite quantum system defined by a network of interactions. More...

#include <Composite.h>

+ Inheritance diagram for Composite< VA, IS_EX, IS_HA, IS_LI >:
+ Collaboration diagram for Composite< VA, IS_EX, IS_HA, IS_LI >:

Public Types

typedef composite::Base< VA > Base
 
typedef mpl::if_c< IS_EX,composite::Exact< VA >, composite::EmptyBase< composite::Exact< VA > > >::type ExactBase
 
typedef mpl::if_c< IS_HA,composite::Hamiltonian< VA >, composite::EmptyBase< composite::Hamiltonian< VA > > >::type HamiltonianBase
 
typedef mpl::if_c< IS_LI,composite::Liouvillean< VA >, composite::EmptyBase< composite::Liouvillean< VA > > >::type LiouvilleanBase
 
typedef composite::Base< VA >::Frees Frees
 
- Public Types inherited from composite::Base< VA >
typedef boost::shared_ptr< const Base< VA > > Ptr
 
typedef VA Acts
 
typedef RankedBase< RANK > RBase
 
typedef structure::Averaged< RANK > Av_Base
 
typedef quantumdata::LazyDensityOperator< RANK > LazyDensityOperator
 
typedef Av_Base::Averages Averages
 
typedef RBase::Frees Frees
 
typedef RBase::Ordinals Ordinals
 
- Public Types inherited from composite::RankedBase< MaxRank< VA >::value+1 >
typedef boost::shared_ptr< const RankedBase< RANK > > Ptr
 
typedef blitz::TinyVector< SubSystemFree, RANK > Frees
 
typedef structure::QuantumSystem< RANK > QS_Base
 
typedef QS_Base::Dimensions Dimensions
 
typedef tmptools::Ordinals< RANK > Ordinals
 
- Public Types inherited from structure::QuantumSystem< N_RANK >
typedef boost::shared_ptr< const QuantumSystem > Ptr
 Many of the basic template classes in the framework act as template metafunctions returning a shared pointer to their own type. More...
 
typedef Base::Dimensions Dimensions
 
- Public Types inherited from DimensionsBookkeeper< RANK >
typedef ExtTiny< RANK > Dimensions
 The dimensions as a static vector of size N_RANK.
 
- Public Types inherited from structure::Averaged< MaxRank< VA >::value+1 >
typedef boost::shared_ptr< const Averaged > Ptr
 
typedef AveragedCommon::Averages Averages
 
typedef quantumdata::LazyDensityOperator< RANK > LazyDensityOperator
 
- Public Types inherited from quantumdata::Types< RANK, LiouvilleanAveragedCommonRanked< RANK > >
typedef CArray< RANK > StateVectorLow
 
typedef CArray< 2 *RANK > DensityOperatorLow
 
- Public Types inherited from structure::AveragedCommon
typedef boost::shared_ptr< const AveragedCommon > Ptr
 
typedef LiouvilleanAveragedCommon::DArray1D Averages
 The 1D real array storing the calculated quantum averages (perhaps in real-imaginary pairs if a given average is complex).
 

Public Member Functions

 Composite (const VA &acts)
 
 Composite (const Frees &frees, const VA &acts)
 
- Public Member Functions inherited from structure::QuantumSystem< N_RANK >
 QuantumSystem (const Dimensions &dimensions)
 Construction from a set of Dimensions.
 
double highestFrequency () const
 The fastest timescale of the system for ODE stepping.
 
std::ostream & displayParameters (std::ostream &os) const
 Communicating system parameters towards the user.
 
- Public Member Functions inherited from DimensionsBookkeeper< RANK >
 DimensionsBookkeeper (mpl::bool_< IS_CONST >=mpl::false_())
 Constructor usable only in the IS_CONST=false case. More...
 
 DimensionsBookkeeper (const Dimensions &dimensions)
 Standard constructor usable also in the IS_CONST=true case.
 
const Dimensions & getDimensions () const
 Get the Dimensions vector.
 
size_t getTotalDimension () const
 Get the total dimension of a system of arbitrary arity.
 
size_t getDimension (mpl::int_< RANK >=mpl::int_< 1 >()) const
 Get the (single) dimension for a unary system.
 
size_t getDimension (size_t i) const
 
void setDimensions (const Dimensions &dimensions)
 This will work only in the non-const case.
 
- Public Member Functions inherited from structure::AveragedCommon
void process (Averages &averages) const
 This function is a hook between LiouvilleanAveragedCommonRanked::average and display. More...
 
std::ostream & display (const Averages &averages, std::ostream &os, int precision) const
 Displays the system characteristics in a nicely tabulated format. More...
 

Static Public Attributes

static const int RANK =Base::RANK
 
- Static Public Attributes inherited from composite::Base< VA >
static const int RANK =MaxRank<VA>::value+1
 
- Static Public Attributes inherited from composite::RankedBase< MaxRank< VA >::value+1 >
static const int RANK
 
- Static Public Attributes inherited from DimensionsBookkeeper< RANK >
static const int N_RANK
 Arity of the Hilbert space.
 
static const int DIMESIONS_BOOKKEEPER_RANK
 Ditto (to break ambiguity if a class is derived from another base featuring N_RANK).
 
- Static Public Attributes inherited from structure::Averaged< MaxRank< VA >::value+1 >
static const int N_RANK
 

Friends

const composite::Base< VA >::Ptr composite::doMake (const VA &)
 

Additional Inherited Members

- Static Public Member Functions inherited from composite::Base< VA >
template<structure::LiouvilleanAveragedTag >
static std::ostream & displayKeyLA (std::ostream &, size_t &, const Frees &, const VA &acts)
 
template<structure::LiouvilleanAveragedTag >
static size_t nAvrLA (const Frees &frees, const VA &acts)
 
template<structure::LiouvilleanAveragedTag >
static const Averages averageLA (double t, const LazyDensityOperator &ldo, const Frees &frees, const VA &acts, size_t numberAvr)
 
- Protected Member Functions inherited from composite::Base< VA >
 Base (const Frees &frees, const VA &acts)
 
const VA & getActs () const
 
- Protected Member Functions inherited from composite::RankedBase< MaxRank< VA >::value+1 >
 RankedBase (const Frees &frees)
 
const Frees & getFrees () const
 

Detailed Description

template<typename VA, bool IS_EX = true, bool IS_HA = true, bool IS_LI = true>
class Composite< VA, IS_EX, IS_HA, IS_LI >

Class representing a full-fledged composite quantum system defined by a network of interactions.

Assume a system composed of harmonic-oscillator modes and particle motional degrees of freedom layed out in the following way – cf. userguide, the layout means which free-system quantum number corresponds to which index of the multi-array: (Free No. 0) mode (1) motional (2) mode (3) motional (4) mode (5) motional (6) mode (7) motional.

Assume further an interaction which couples two modes and two motional degrees of freedom. As a physical example, one might think about two resonator modes with orthogonal axes, and a polarizable particle moving in these two dimensions (the rest of the system can be another particle, and two more modes of the same resonators). Then, the particle may absorb a photon from one mode and suffer recoil in this direction, and emit the photon into the other mode, suffering recoil in that direction as well. Assume that the function 

void TwoModesParticle2D_Hamiltonian(const StateVector<4>&, StateVector<4>&);

implements this Hamiltonian. In the composite system, this is how we can act with this Hamiltonian between e.g. the indices (4) (0) (7) (1): 

void Hamiltonian(const StateVector<8>& psi, StateVector<8>& dpsidt)
{
  for_each(BASI_Range<Vector<4,0,7,1> >(psi),
           begin<Vector<4,0,7,1> >(dpsidt),
           TwoModesParticle2D_Hamiltonian);
}
Note
the names in this code snippet are approximative

It is the task of Composite to systematically keep track of the subsystems and perform the calculations on the necessary slices.

Consistency checks for Composite at compile time come on three levels:

  1. Composite itself only checks whether all the quantum numbers are addressed by a composite::_ instant. So this is e.g. not allowed: 

    composite::result_of::Make<composite::_<0,1>,composite::_<0,2>,composite::_<0,3>,composite::_<3,2,5,1> >::type

    because 4 is not addressed and hence the Composite object has no way to figure out what kind of structure::Free object is there.

  2. The instantiated slice iterators do some further checks for each composite::_ instant individually:
    • the total arity must be greater than or equal to the arity of composite::_
    • composite::_ must not “contain” duplicated “elements” (e.g. composite::_<3,2,3,1> not allowed)
    • each element in composite::_ must be smaller than the total arity
  3. Finally, tmptools::Vector checks for the non-negativity of each element (as it is supposed to be a non-negative compile-time vector).
Note
The last condition incidentally makes that the three checks performed under 2. by the slice interators for each composite::_ are redundant (the first condition follows from the last two plus the nonnegativity of tmptools::Vector). However, these checks are still necessary for the slice iterators because they accept classes other than tmptools::Vector for the specification of retained index positions.

This is followed by a check at runtime, when the actual elements become available, whether the legs of the composite::_ objects are consistent among each other. Cf. composite::FillFrees::Inner::operator().

Template Parameters
VAshould model a Boost.Fusion list of composite::_ objects
IS_EXgoverns whether the class should inherit from composite::Exact
IS_HAgoverns whether the class should inherit from composite::Hamiltonian
IS_LIgoverns whether the class should inherit from composite::Liouvillean

Definition at line 315 of file Composite.h.

The documentation for this class was generated from the following file: