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:

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.
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
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

VA	should model a Boost.Fusion list of composite::_ objects
IS_EX	governs whether the class should inherit from composite::Exact
IS_HA	governs whether the class should inherit from composite::Hamiltonian
IS_LI	governs 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:

composites/Composite.h

Public Types

Public Member Functions

Static Public Attributes

Friends

Additional Inherited Members

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 >

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