#include <ZN.hpp>

Inheritance diagram for Xped::Sym::ZN< Kind, N, Scalar_ >:

Collaboration diagram for Xped::Sym::ZN< Kind, N, Scalar_ >:

Public Types
typedef Scalar_	Scalar

typedef qarray< Nq >	qType

Public Types inherited from Xped::Sym::SymBase< Derived >
typedef SymTraits< Derived >::qType	qType

typedef SymTraits< Derived >::Scalar	Scalar

Public Member Functions
	ZN ()

Static Public Member Functions
static constexpr bool	IS_CHARGE_SU2 ()

static constexpr bool	IS_SPIN_SU2 ()

static constexpr bool	IS_SPIN_U1 ()

static constexpr bool	NO_SPIN_SYM ()

static constexpr bool	NO_CHARGE_SYM ()

static constexpr qType	qvacuum ()

static constexpr auto	lowest_qs ()

static std::string	name ()

static constexpr std::array< KIND, Nq >	kind ()

static qType	conj (const qType &q)

static int	degeneracy (const qType &)

static qType	random_q ()

static std::vector< qType >	basis_combine (const qType &ql, const qType &qr)

static std::size_t	multiplicity (const qType &q1, const qType &q2, const qType &q3)

static bool	triangle (const qType &q1, const qType &q2, const qType &q3)


static Scalar	coeff_dot (const qType &)

static Scalar	coeff_twist (const qType &q)

static Scalar	coeff_FS (const qType &)

template<typename PlainLib >
static PlainLib::template TType< Scalar_, 2 >	one_j_tensor (const qType &, const mpi::XpedWorld &world=mpi::getUniverse())

static Scalar	coeff_rightOrtho (const qType &, const qType &)

static Scalar	coeff_3j (const qType &q1, const qType &q2, const qType &q3, int, int, int)

template<typename PlainLib >
static PlainLib::template TType< Scalar_, 3 >	CGC (const qType &q1, const qType &q2, const qType &q3, const std::size_t, const mpi::XpedWorld &world=mpi::getUniverse())

static Scalar	coeff_turn (const qType &ql, const qType &qr, const qType &qf)

static Scalar	coeff_6j (const qType &q1, const qType &q2, const qType &q3, const qType &q4, const qType &q5, const qType &q6)

static Scalar	coeff_recouple (const qType &q1, const qType &q2, const qType &q3, const qType &Q, const qType &Q12, const qType &Q23)

static Scalar	coeff_9j (const qType &, const qType &, const qType &, const qType &, const qType &, const qType &, const qType &, const qType &, const qType &)

static Scalar	coeff_swap (const qType &ql, const qType &qr, const qType &qf)

Static Public Member Functions inherited from Xped::Sym::SymBase< Derived >
static std::vector< qType >	reduceSilent (const qType &ql, const qType &qr)

static std::vector< qType >	reduceSilent (const std::vector< qType > &ql, const qType &qr)

static std::set< qType >	reduceSilent (const std::vector< qType > &ql, const std::vector< qType > &qr)

static std::vector< qType >	reduceSilent (const qType &ql, const qType &qm, const qType &qr)

static std::set< qType >	reduceSilent (const std::set< qType > &ql, const std::vector< qType > &qr)

static std::set< qType >	reduceSilent (const std::unordered_set< qType > &ql, const std::vector< qType > &qr)

static Scalar	coeff_FS (const qType &q)

static Scalar	coeff_turn (const qType &ql, const qType &qr, const qType &qf)

template<std::size_t M>
static bool	compare (const std::array< qType, M > &q1, const std::array< qType, M > &q2)

static bool	compare (const qType &q1, const qType &q2)

static bool	triangle (const qType &q1, const qType &q2, const qType &q3)

Static Public Attributes
static constexpr size_t	Nq = 1

static constexpr std::array< bool, Nq >	HAS_MULTIPLICITIES = {false}

static constexpr std::array< bool, Nq >	NON_ABELIAN = {false}

static constexpr std::array< bool, Nq >	ABELIAN = {true}

static constexpr std::array< bool, Nq >	IS_TRIVIAL = {false}

static constexpr std::array< bool, Nq >	IS_MODULAR = {true}

static constexpr std::array< bool, Nq >	IS_FERMIONIC = {(Kind::name == KIND::FN)}

static constexpr std::array< bool, Nq >	IS_BOSONIC = {(Kind::name == KIND::N)}

static constexpr std::array< bool, Nq >	IS_SPIN = {(Kind::name == KIND::M)}

static constexpr std::array< int, Nq >	MOD_N = {N}

static constexpr bool	ANY_HAS_MULTIPLICITIES = HAS_MULTIPLICITIES[0]

static constexpr bool	ANY_NON_ABELIAN = NON_ABELIAN[0]

static constexpr bool	ANY_ABELIAN = ABELIAN[0]

static constexpr bool	ANY_IS_TRIVIAL = IS_TRIVIAL[0]

static constexpr bool	ANY_IS_MODULAR = IS_MODULAR[0]

static constexpr bool	ANY_IS_FERMIONIC = IS_FERMIONIC[0]

static constexpr bool	ANY_IS_BOSONIC = IS_BOSONIC[0]

static constexpr bool	ANY_IS_SPIN = IS_SPIN[0]

static constexpr bool	ALL_HAS_MULTIPLICITIES = HAS_MULTIPLICITIES[0]

static constexpr bool	ALL_NON_ABELIAN = NON_ABELIAN[0]

static constexpr bool	ALL_ABELIAN = ABELIAN[0]

static constexpr bool	ALL_IS_TRIVIAL = IS_TRIVIAL[0]

static constexpr bool	ALL_IS_MODULAR = IS_MODULAR[0]

static constexpr bool	ALL_IS_FERMIONIC = IS_FERMIONIC[0]

static constexpr bool	ALL_IS_BOSONIC = IS_BOSONIC[0]

static constexpr bool	ALL_IS_SPIN = IS_SPIN[0]

Detailed Description

template<typename Kind, std::size_t N, typename Scalar_ = double>
class Xped::Sym::ZN< Kind, N, Scalar_ >

Class for handling a Z(N) symmetry of a Hamiltonian.

\describe_Scalar

Member Typedef Documentation

◆ qType

template<typename Kind , std::size_t N, typename Scalar_ = double>

typedef qarray<Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::qType

◆ Scalar

template<typename Kind , std::size_t N, typename Scalar_ = double>

typedef Scalar_ Xped::Sym::ZN< Kind, N, Scalar_ >::Scalar

Constructor & Destructor Documentation

◆ ZN()

template<typename Kind , std::size_t N, typename Scalar_ = double>

Xped::Sym::ZN< Kind, N, Scalar_ >::ZN ( )

inline

Member Function Documentation

◆ basis_combine()

template<typename Kind , std::size_t N, typename Scalar_ >

std::vector< typename ZN< Kind, N, Scalar_ >::qType > Xped::Sym::ZN< Kind, N, Scalar_ >::basis_combine	(	const qType &	ql,
		const qType &	qr
	)

static

Calculate the irreps of the tensor product of ql and qr.

◆ CGC()

template<typename Kind , std::size_t N, typename Scalar_ >

template<typename PlainLib >

PlainLib::template TType< Scalar_, 3 > Xped::Sym::ZN< Kind, N, Scalar_ >::CGC	(	const qType &	q1,
		const qType &	q2,
		const qType &	q3,
		const std::size_t	,
		const mpi::XpedWorld &	world = `mpi::getUniverse()`
	)

static

◆ coeff_3j()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_3j	(	const qType &	q1,
		const qType &	q2,
		const qType &	q3,
		int	,
		int	,
		int
	)

inlinestatic

Here is the call graph for this function:

◆ coeff_6j()

template<typename Kind , std::size_t N, typename Scalar_ >

Scalar_ Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_6j	(	const qType &	q1,
		const qType &	q2,
		const qType &	q3,
		const qType &	q4,
		const qType &	q5,
		const qType &	q6
	)

inlinestatic

Here is the caller graph for this function:

◆ coeff_9j()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_9j	(	const qType &	,
		const qType &	,
		const qType &	,
		const qType &	,
		const qType &	,
		const qType &	,
		const qType &	,
		const qType &	,
		const qType &
	)

inlinestatic

◆ coeff_dot()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_dot ( const qType & )

inlinestatic

Various coeffecients, all resulting from contractions or traces of the Clebsch-Gordon coefficients.

Note: All coefficients are trivial for U(1) and could be represented by a bunch of Kronecker deltas. Here we return simply 1, because the algorithm only allows valid combinations of quantumnumbers, for which the Kronecker deltas are not necessary.

◆ coeff_FS()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_FS ( const qType & )

inlinestatic

◆ coeff_recouple()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_recouple	(	const qType &	q1,
		const qType &	q2,
		const qType &	q3,
		const qType &	Q,
		const qType &	Q12,
		const qType &	Q23
	)

inlinestatic

Here is the call graph for this function:

◆ coeff_rightOrtho()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_rightOrtho	(	const qType &	,
		const qType &
	)

inlinestatic

◆ coeff_swap()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_swap	(	const qType &	ql,
		const qType &	qr,
		const qType &	qf
	)

inlinestatic

Here is the call graph for this function:

◆ coeff_turn()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_turn	(	const qType &	ql,
		const qType &	qr,
		const qType &	qf
	)

inlinestatic

Here is the call graph for this function:

◆ coeff_twist()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static Scalar Xped::Sym::ZN< Kind, N, Scalar_ >::coeff_twist ( const qType & q )

inlinestatic

◆ conj()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static qType Xped::Sym::ZN< Kind, N, Scalar_ >::conj ( const qType & q )

inlinestatic

Here is the caller graph for this function:

◆ degeneracy()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static int Xped::Sym::ZN< Kind, N, Scalar_ >::degeneracy ( const qType & )

inlinestatic

◆ IS_CHARGE_SU2()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::IS_CHARGE_SU2 ( )

inlinestaticconstexpr

◆ IS_SPIN_SU2()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::IS_SPIN_SU2 ( )

inlinestaticconstexpr

◆ IS_SPIN_U1()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::IS_SPIN_U1 ( )

inlinestaticconstexpr

◆ kind()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static constexpr std::array< KIND, Nq > Xped::Sym::ZN< Kind, N, Scalar_ >::kind ( )

inlinestaticconstexpr

◆ lowest_qs()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static constexpr auto Xped::Sym::ZN< Kind, N, Scalar_ >::lowest_qs ( )

inlinestaticconstexpr

◆ multiplicity()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static std::size_t Xped::Sym::ZN< Kind, N, Scalar_ >::multiplicity	(	const qType &	q1,
		const qType &	q2,
		const qType &	q3
	)

inlinestatic

Here is the call graph for this function:

◆ name()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static std::string Xped::Sym::ZN< Kind, N, Scalar_ >::name ( )

inlinestatic

◆ NO_CHARGE_SYM()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::NO_CHARGE_SYM ( )

inlinestaticconstexpr

◆ NO_SPIN_SYM()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::NO_SPIN_SYM ( )

inlinestaticconstexpr

◆ one_j_tensor()

template<typename Kind , std::size_t N, typename Scalar_ = double>

template<typename PlainLib >

static PlainLib::template TType< Scalar_, 2 > Xped::Sym::ZN< Kind, N, Scalar_ >::one_j_tensor	(	const qType &	,
		const mpi::XpedWorld &	world = `mpi::getUniverse()`
	)

inlinestatic

◆ qvacuum()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static constexpr qType Xped::Sym::ZN< Kind, N, Scalar_ >::qvacuum ( )

inlinestaticconstexpr

◆ random_q()

template<typename Kind , std::size_t N, typename Scalar_ = double>

static qType Xped::Sym::ZN< Kind, N, Scalar_ >::random_q ( )

inlinestatic

Here is the call graph for this function:

◆ triangle()

template<typename Kind , std::size_t N, typename Scalar_ >

bool Xped::Sym::ZN< Kind, N, Scalar_ >::triangle	(	const qType &	q1,
		const qType &	q2,
		const qType &	q3
	)

static

Here is the caller graph for this function:

Member Data Documentation

◆ ABELIAN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<bool, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::ABELIAN = {true}

staticconstexpr

◆ ALL_ABELIAN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ALL_ABELIAN = ABELIAN[0]

staticconstexpr

◆ ALL_HAS_MULTIPLICITIES

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ALL_HAS_MULTIPLICITIES = HAS_MULTIPLICITIES[0]

staticconstexpr

◆ ALL_IS_BOSONIC

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ALL_IS_BOSONIC = IS_BOSONIC[0]

staticconstexpr

◆ ALL_IS_FERMIONIC

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ALL_IS_FERMIONIC = IS_FERMIONIC[0]

staticconstexpr

◆ ALL_IS_MODULAR

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ALL_IS_MODULAR = IS_MODULAR[0]

staticconstexpr

◆ ALL_IS_SPIN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ALL_IS_SPIN = IS_SPIN[0]

staticconstexpr

◆ ALL_IS_TRIVIAL

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ALL_IS_TRIVIAL = IS_TRIVIAL[0]

staticconstexpr

◆ ALL_NON_ABELIAN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ALL_NON_ABELIAN = NON_ABELIAN[0]

staticconstexpr

◆ ANY_ABELIAN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ANY_ABELIAN = ABELIAN[0]

staticconstexpr

◆ ANY_HAS_MULTIPLICITIES

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ANY_HAS_MULTIPLICITIES = HAS_MULTIPLICITIES[0]

staticconstexpr

◆ ANY_IS_BOSONIC

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ANY_IS_BOSONIC = IS_BOSONIC[0]

staticconstexpr

◆ ANY_IS_FERMIONIC

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ANY_IS_FERMIONIC = IS_FERMIONIC[0]

staticconstexpr

◆ ANY_IS_MODULAR

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ANY_IS_MODULAR = IS_MODULAR[0]

staticconstexpr

◆ ANY_IS_SPIN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ANY_IS_SPIN = IS_SPIN[0]

staticconstexpr

◆ ANY_IS_TRIVIAL

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ANY_IS_TRIVIAL = IS_TRIVIAL[0]

staticconstexpr

◆ ANY_NON_ABELIAN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr bool Xped::Sym::ZN< Kind, N, Scalar_ >::ANY_NON_ABELIAN = NON_ABELIAN[0]

staticconstexpr

◆ HAS_MULTIPLICITIES

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<bool, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::HAS_MULTIPLICITIES = {false}

staticconstexpr

◆ IS_BOSONIC

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<bool, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::IS_BOSONIC = {(Kind::name == KIND::N)}

staticconstexpr

◆ IS_FERMIONIC

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<bool, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::IS_FERMIONIC = {(Kind::name == KIND::FN)}

staticconstexpr

◆ IS_MODULAR

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<bool, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::IS_MODULAR = {true}

staticconstexpr

◆ IS_SPIN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<bool, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::IS_SPIN = {(Kind::name == KIND::M)}

staticconstexpr

◆ IS_TRIVIAL

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<bool, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::IS_TRIVIAL = {false}

staticconstexpr

◆ MOD_N

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<int, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::MOD_N = {N}

staticconstexpr

◆ NON_ABELIAN

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr std::array<bool, Nq> Xped::Sym::ZN< Kind, N, Scalar_ >::NON_ABELIAN = {false}

staticconstexpr

◆ Nq

template<typename Kind , std::size_t N, typename Scalar_ = double>

constexpr size_t Xped::Sym::ZN< Kind, N, Scalar_ >::Nq = 1

staticconstexpr

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

include/Xped/Symmetry/ZN.hpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ qType

◆ Scalar

Constructor & Destructor Documentation

◆ ZN()

Member Function Documentation

◆ basis_combine()

◆ CGC()

◆ coeff_3j()

◆ coeff_6j()

◆ coeff_9j()

◆ coeff_dot()

◆ coeff_FS()

◆ coeff_recouple()

◆ coeff_rightOrtho()

◆ coeff_swap()

◆ coeff_turn()

◆ coeff_twist()

◆ conj()

◆ degeneracy()

◆ IS_CHARGE_SU2()

◆ IS_SPIN_SU2()

◆ IS_SPIN_U1()

◆ kind()

◆ lowest_qs()

◆ multiplicity()

◆ name()

◆ NO_CHARGE_SYM()

◆ NO_SPIN_SYM()

◆ one_j_tensor()

◆ qvacuum()

◆ random_q()

◆ triangle()

Member Data Documentation

◆ ABELIAN

◆ ALL_ABELIAN

◆ ALL_HAS_MULTIPLICITIES

◆ ALL_IS_BOSONIC

◆ ALL_IS_FERMIONIC

◆ ALL_IS_MODULAR

◆ ALL_IS_SPIN

◆ ALL_IS_TRIVIAL

◆ ALL_NON_ABELIAN

◆ ANY_ABELIAN

◆ ANY_HAS_MULTIPLICITIES

◆ ANY_IS_BOSONIC

◆ ANY_IS_FERMIONIC

◆ ANY_IS_MODULAR

◆ ANY_IS_SPIN

◆ ANY_IS_TRIVIAL

◆ ANY_NON_ABELIAN

◆ HAS_MULTIPLICITIES

◆ IS_BOSONIC

◆ IS_FERMIONIC

◆ IS_MODULAR

◆ IS_SPIN

◆ IS_TRIVIAL

◆ MOD_N

◆ NON_ABELIAN

◆ Nq