ManyBodySpaceBase< Derived > Class Template Reference

ManyBodySpinSpace \(\mathcal{H}\) defined by \(\mathcal{H} \coloneqq \mathcal{H}_{\mathrm{loc}}^{\otimes L}\), where. More...

#include <HilbertSpace.hpp>

Inheritance diagram for ManyBodySpaceBase< Derived >:

Collaboration diagram for ManyBodySpaceBase< Derived >:

Public Member Functions
__host__ __device__	ManyBodySpaceBase (int systemSize, LocSpace_t const &locSpace)
	Constructor1.
__host__ __device__	ManyBodySpaceBase (int systemSize, LocSpace_t &&locSpace)
	Constructor2.
template<typename... Args>
__host__ __device__	ManyBodySpaceBase (int systemSize, Args... args)
	Constructor3.
__host__ __device__	ManyBodySpaceBase ()=default
	Default constructor.
__host__ __device__	ManyBodySpaceBase (ManyBodySpaceBase const &other)
	Copy constructor.
__host__ __device__	ManyBodySpaceBase (ManyBodySpaceBase &&other)
	Move constructor.
__host__ __device__	~ManyBodySpaceBase ()=default
	Destructor.
Operator overloads
__host__ __device__ ManyBodySpaceBase &	operator= (ManyBodySpaceBase const &other)=delete
	Copy assignment operator (deleted)
__host__ __device__ Derived &	operator= (ManyBodySpaceBase &&other)
	Move assignment operator.
__host__ __device__ bool	operator== (ManyBodySpaceBase const &other) const
	Equality operator.
__host__ __device__ LocSpace_t const &	locSpace () const
__host__ __device__ int	sysSize () const
__host__ __device__ int	dimLoc () const
__host__ __device__ int	locState (int state, int pos) const
__host__ Derived const &	printInString (int basisNum) const
	Print a basis state specified by the input (basisNum) in a string of integers.
__host__ __device__ Eigen::RowVectorXi	ordinalToConfig (int basisNum) const
template<class EigenDerived >
__host__ __device__ int	configToOrdinal (Eigen::DenseBase< EigenDerived > &config) const
Parity operation
__host__ __device__ int	reverse (int state) const
	Reverse the input state.
__host__ __device__ Vector_t const &	parityPair () const
__host__ __device__ int	parityPair (int state) const
__host__ __device__ void	computeParityPair () const
Public Member Functions inherited from HilbertSpace< Derived >
__host__ __device__ int	dim () const
__host__ __device__ bool	operator== (HilbertSpace const &other) const

Protected Types
using	Vector_t = Eigen::VectorX< int >

Protected Attributes
int	m_systemSize = 0
LocSpace_t	m_locSpace
int	m_transEqDim = -1
Vector_t	m_transEqClassRep
Vector_t	m_transPeriod
Vector_t	m_stateToTransEqClass
Vector_t	m_parityPair

Private Types
using	LocSpace_t = typename HilbertSpaceTraits< Derived >::LocalSpace

Private Attributes
struct cudaFuncAttributes	attr
bool	gotKernelAttribute = false

Translation operation
__host__ __device__ int	translate (int state, int trans) const
	Translate the input state to the left by one.
template<class EigenDerived >
__host__ __device__ int	translate (int state, int trans, Eigen::DenseBase< EigenDerived > &work) const
__host__ __device__ int	transEqDim () const
__host__ __device__ Vector_t const &	transEqClassRep () const
__host__ __device__ int	transEqClassRep (int id) const
__host__ __device__ int	transEqClassRep (int id, int trans) const
__host__ __device__ Vector_t const &	transPeriod () const
__host__ __device__ int	transPeriod (int id) const
__host__ __device__ Vector_t const &	stateToTransEqClass () const
__host__ __device__ int	stateToTransEqClass (int state) const
__host__ __device__ int	stateToTransPeriod (int state) const
__host__ __device__ void	computeTransEqClass () const
void	setTransEqDim_kernel (ManyBodySpaceBase *, int)
void	copyTransEqClass_kernel (ManyBodySpaceBase *, int *, int *)

Detailed Description

template<class Derived>
class ManyBodySpaceBase< Derived >

ManyBodySpinSpace \(\mathcal{H}\) defined by \(\mathcal{H} \coloneqq \mathcal{H}_{\mathrm{loc}}^{\otimes L}\), where.

• \(L\): System size
• \(\mathrm{dimLoc}\): Dimension of the local Hilbert space \(\mathcal{H}_{\mathrm{loc}}\)

  Note

  Now only a homogeneous tensor product of local Hilbert spaces is supported.

  Template Parameters

  int
  Container

Member Typedef Documentation

LocSpace_t

template<class Derived >

using ManyBodySpaceBase< Derived >::LocSpace_t = typename HilbertSpaceTraits<Derived>::LocalSpace

private

Vector_t

template<class Derived >

using ManyBodySpaceBase< Derived >::Vector_t = Eigen::VectorX<int>

protected

Constructor & Destructor Documentation

ManyBodySpaceBase() [1/6]

template<class Derived >

__host__ __device__ ManyBodySpaceBase< Derived >::ManyBodySpaceBase ( int  systemSize, LocSpace_t const &  locSpace  )

inline

Constructor1.

Parameters

systemSize
locSpace

Returns

host

            : m_systemSize{systemSize}, m_locSpace{locSpace} {
            debug_constructor_printf(1);
            debug_printf("\tlocSpace.dim() = %d\n\n", locSpace.dim());
        }

ManyBodySpaceBase() [2/6]

template<class Derived >

__host__ __device__ ManyBodySpaceBase< Derived >::ManyBodySpaceBase ( int  systemSize, LocSpace_t &&  locSpace  )

inline

Constructor2.

Parameters

systemSize
locSpace

Returns

host

            : m_systemSize{systemSize}, m_locSpace{std::move(locSpace)} {
            debug_constructor_printf(2);
            debug_printf("\tlocSpace.dim() = %d\n\n", locSpace.dim());
        }

ManyBodySpaceBase() [3/6]

template<class Derived >

template<typename... Args>

__host__ __device__ ManyBodySpaceBase< Derived >::ManyBodySpaceBase ( int  systemSize, Args...  args  )

inline

Constructor3.

Template Parameters

Args	Types of arguments for a constructor of LocSpace_t

Parameters

systemSize
args	Arguments for a constructor of LocSpace_t

            : ManyBodySpaceBase(systemSize, LocSpace_t(args...)) {
            debug_constructor_printf(3);
        }

ManyBodySpaceBase() [4/6]

template<class Derived >

__host__ __device__ ManyBodySpaceBase< Derived >::ManyBodySpaceBase ( )

default

Default constructor.

ManyBodySpaceBase() [5/6]

template<class Derived >

__host__ __device__ ManyBodySpaceBase< Derived >::ManyBodySpaceBase ( ManyBodySpaceBase< Derived > const &  other )

inline

Copy constructor.

Parameters

other

            : HilbertSpace<Derived>(other),
              m_systemSize(other.m_systemSize),
              m_locSpace(other.m_locSpace),
              m_transEqDim(other.m_transEqDim),
              m_transEqClassRep{other.m_transEqClassRep},
              m_transPeriod{other.m_transPeriod},
              m_stateToTransEqClass{other.m_stateToTransEqClass} {
            debug_constructor_printf((Copy));
        }

ManyBodySpaceBase() [6/6]

template<class Derived >

__host__ __device__ ManyBodySpaceBase< Derived >::ManyBodySpaceBase ( ManyBodySpaceBase< Derived > &&  other )

inline

Move constructor.

Parameters

other

            : HilbertSpace<Derived>(other),
              m_systemSize(other.m_systemSize),
              m_locSpace(other.m_locSpace),
              m_transEqDim(other.m_transEqDim),
              m_transEqClassRep{std::move(other.m_transEqClassRep)},
              m_transPeriod{std::move(other.m_transPeriod)},
              m_stateToTransEqClass{std::move(other.m_stateToTransEqClass)} {
            debug_constructor_printf((Move));
        }

~ManyBodySpaceBase()

template<class Derived >

__host__ __device__ ManyBodySpaceBase< Derived >::~ManyBodySpaceBase ( )

default

Destructor.

Member Function Documentation

computeParityPair()

template<class Derived >

__host__ __device__ void ManyBodySpaceBase< Derived >::computeParityPair

                                                                             {
    m_parityPair.resize(this->dim());
    for(auto j = 0; j != this->dim(); ++j) {
        auto reversed          = this->reverse(j);
        m_parityPair(j)        = reversed;
        m_parityPair(reversed) = j;
    }
}

computeTransEqClass()

template<class Derived >

__host__ void ManyBodySpaceBase< Derived >::computeTransEqClass

                                                                    {
    debug_printf("%s:\n\tComputing trans equivalent class... (this->dim()=%d, m_transEqDim=%d)\n",
                 __PRETTY_FUNCTION__, this->dim(), m_transEqDim);
    if(m_transEqDim != -1) {
        debug_printf("%s:\tTrans equivalent class is already computed. m_transEqDim=%d\n", __func__,
                     m_transEqDim);
        return;
    }
    if(this->dim() <= 0) {
        debug_printf("%s:\tDimension of the space is ZERO (this->dim() = %d)\n", __func__,
                     this->dim());
        return;
    }
    int                 translated;
    int                 period     = 0;
    Eigen::ArrayX<bool> calculated = Eigen::ArrayX<bool>::Zero(this->dim());
    m_transEqDim                   = 0;
    for(int basis = 0; basis < this->dim(); ++basis) {
        if(calculated(basis)) continue;
        calculated(basis) = true;
        for(period = 1; period < this->sysSize(); ++period) {
            translated = this->translate(basis, period);
            if(basis == translated) break;
            calculated(translated) = true;
        }
        m_transEqDim += 1;
    }
 
    m_transEqClassRep.resize(m_transEqDim);
    m_transPeriod.resize(m_transEqDim);
    m_stateToTransEqClass.resize(this->dim());
    int num    = 0;
    calculated = Eigen::ArrayX<bool>::Zero(this->dim());
    for(int basis = 0; basis < this->dim(); ++basis) {
        if(calculated(basis)) continue;
        calculated(basis)            = true;
        m_stateToTransEqClass(basis) = num;
 
        for(period = 1; period < this->sysSize(); ++period) {
            translated = this->translate(basis, period);
            if(basis == translated) break;
            calculated(translated)            = true;
            m_stateToTransEqClass(translated) = num;
        }
        m_transEqClassRep(num) = basis;
        m_transPeriod(num)     = period;
        num += 1;
    }
    debug_printf("\t(END) Computed trans equivalent classes (m_transEqDim=%d)\n\n", m_transEqDim);
}

configToOrdinal()

template<class Derived >

template<class EigenDerived >

__host__ __device__ int ManyBodySpaceBase< Derived >::configToOrdinal ( Eigen::DenseBase< EigenDerived > &  config ) const

inline

                                                                                            {
            return static_cast<Derived const*>(this)->configToOrdinal_impl(config);
        }

dimLoc()

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::dimLoc ( ) const

inline

{ return m_locSpace.dim(); }

locSpace()

template<class Derived >

__host__ __device__ LocSpace_t const & ManyBodySpaceBase< Derived >::locSpace ( ) const

inline

{ return m_locSpace; }

locState()

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::locState ( int  state, int  pos  ) const

inline

                                                                                 {
                          return static_cast<Derived const*>(this)->locState_impl(state, pos);
        }

operator=() [1/2]

template<class Derived >

__host__ __device__ Derived & ManyBodySpaceBase< Derived >::operator= ( ManyBodySpaceBase< Derived > &&  other )

inline

Move assignment operator.

Parameters

other

Returns

*this

                                                                          {
            debug_printf("%s:\n\tMove assignment operator.\n\n", __PRETTY_FUNCTION__);
            m_systemSize          = other.m_systemSize;
            m_locSpace            = other.m_locSpace;
            m_transEqDim          = other.m_transEqDim;
            m_transEqClassRep     = std::move(other.m_transEqClassRep);
            m_transPeriod         = std::move(other.m_transPeriod);
            m_stateToTransEqClass = std::move(other.m_stateToTransEqClass);
            return *static_cast<Derived*>(this);
        }

operator=() [2/2]

template<class Derived >

__host__ __device__ ManyBodySpaceBase & ManyBodySpaceBase< Derived >::operator= ( ManyBodySpaceBase< Derived > const &  other )

delete

Copy assignment operator (deleted)

Parameters

other

Returns

*this

operator==()

template<class Derived >

__host__ __device__ bool ManyBodySpaceBase< Derived >::operator== ( ManyBodySpaceBase< Derived > const &  other ) const

inline

Equality operator.

Parameters

other

Returns

bool

                                                                                  {
            return m_locSpace == other.locSpace() && m_systemSize == other.sysSize();
        }

ordinalToConfig()

template<class Derived >

__host__ __device__ Eigen::RowVectorXi ManyBodySpaceBase< Derived >::ordinalToConfig ( int  basisNum ) const

inline

                                                                                 {
            return static_cast<Derived const*>(this)->ordinalToConfig_impl(basisNum);
        }

parityPair() [1/2]

template<class Derived >

__host__ __device__ Vector_t const & ManyBodySpaceBase< Derived >::parityPair ( ) const

inline

{ return m_parityPair; }

parityPair() [2/2]

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::parityPair ( int  state ) const

inline

{ return m_parityPair[state]; }

printInString()

template<class Derived >

__host__ Derived const & ManyBodySpaceBase< Derived >::printInString ( int  basisNum ) const

inline

Print a basis state specified by the input (basisNum) in a string of integers.

Parameters

basisNum

Returns

A const reference to itself

                                                                  {
            Eigen::RowVectorXi config = this->ordinalToConfig(basisNum);
            for(int l = 0; l != this->sysSize(); ++l) std::cout << " " << config(l);
            std::cout << std::endl;
            return static_cast<Derived const&>(*this);
        }

reverse()

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::reverse ( int  state ) const

inline

Reverse the input state.

Parameters

[in]	state
[in]	trans

Returns

int

                                                         {
            return static_cast<Derived const*>(this)->reverse_impl(state);
        }

stateToTransEqClass() [1/2]

template<class Derived >

__host__ __device__ Vector_t const & ManyBodySpaceBase< Derived >::stateToTransEqClass ( ) const

inline

                                                                        {
            return m_stateToTransEqClass;
        }

stateToTransEqClass() [2/2]

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::stateToTransEqClass ( int  state ) const

inline

                                                                     {
            return m_stateToTransEqClass[state];
        };

stateToTransPeriod()

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::stateToTransPeriod ( int  state ) const

inline

                                                                    {
            auto eqClass = this->stateToTransEqClass(state);
            return this->transPeriod(eqClass);
        };

sysSize()

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::sysSize ( ) const

inline

{ return m_systemSize; }

transEqClassRep() [1/3]

template<class Derived >

__host__ __device__ Vector_t const & ManyBodySpaceBase< Derived >::transEqClassRep ( ) const

inline

{ return m_transEqClassRep; }

transEqClassRep() [2/3]

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::transEqClassRep ( int  id ) const

inline

{ return m_transEqClassRep[id]; }

transEqClassRep() [3/3]

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::transEqClassRep ( int  id, int  trans  ) const

inline

                                                                         {
            return this->translate(m_transEqClassRep[id], trans);
        }

transEqDim()

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::transEqDim ( ) const

inline

{ return m_transEqDim; }

translate() [1/2]

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::translate ( int  state, int  trans  ) const

inline

Translate the input state to the left by one.

Parameters

[in]	state
[in]	trans

Returns

int

                                                                      {
            return static_cast<Derived const*>(this)->translate_impl(state, trans);
        }

translate() [2/2]

template<class Derived >

template<class EigenDerived >

__host__ __device__ int ManyBodySpaceBase< Derived >::translate ( int  state, int  trans, Eigen::DenseBase< EigenDerived > &  work  ) const

inline

                                                                                    {
            return static_cast<Derived const*>(this)->translate_impl(state, trans, work);
        }

transPeriod() [1/2]

template<class Derived >

__host__ __device__ Vector_t const & ManyBodySpaceBase< Derived >::transPeriod ( ) const

inline

{ return m_transPeriod; }

transPeriod() [2/2]

template<class Derived >

__host__ __device__ int ManyBodySpaceBase< Derived >::transPeriod ( int  id ) const

inline

{ return m_transPeriod[id]; }

Friends And Related Symbol Documentation

copyTransEqClass_kernel

template<class Derived >

void copyTransEqClass_kernel ( ManyBodySpaceBase< Derived > *  obj, int *  srcTransEqClassRep, int *  srcTransPeriod  )

friend

                                                             {
    int const idx = blockIdx.x * blockDim.x + threadIdx.x;
    if(idx >= obj->transEqDim()) return;
    obj->m_transEqClassRep(idx) = srcTransEqClassRep[idx];
    obj->m_transPeriod(idx)     = srcTransPeriod[idx];
    for(auto trans = 0; trans != srcTransPeriod[idx]; ++trans) {
        auto translated                        = obj->translate(srcTransEqClassRep[idx], trans);
        obj->m_stateToTransEqClass(translated) = idx;
    }
}

setTransEqDim_kernel

template<class Derived >

void setTransEqDim_kernel ( ManyBodySpaceBase< Derived > *  obj, int  transEqDim  )

friend

                                                                                      {
    debug_printf("%s\n\ttransEqDim=%d\n", __PRETTY_FUNCTION__, transEqDim);
    obj->m_transEqDim = transEqDim;
    obj->m_transEqClassRep.resize(transEqDim);
    obj->m_transPeriod.resize(transEqDim);
    obj->m_stateToTransEqClass.resize(obj->dim());
}

Member Data Documentation

attr

template<class Derived >

struct cudaFuncAttributes ManyBodySpaceBase< Derived >::attr

private

gotKernelAttribute

template<class Derived >

bool ManyBodySpaceBase< Derived >::gotKernelAttribute = false

mutableprivate

m_locSpace

template<class Derived >

LocSpace_t ManyBodySpaceBase< Derived >::m_locSpace

protected

m_parityPair

template<class Derived >

Vector_t ManyBodySpaceBase< Derived >::m_parityPair

mutableprotected

m_stateToTransEqClass

template<class Derived >

Vector_t ManyBodySpaceBase< Derived >::m_stateToTransEqClass

mutableprotected

m_systemSize

template<class Derived >

int ManyBodySpaceBase< Derived >::m_systemSize = 0

protected

m_transEqClassRep

template<class Derived >

Vector_t ManyBodySpaceBase< Derived >::m_transEqClassRep

mutableprotected

m_transEqDim

template<class Derived >

int ManyBodySpaceBase< Derived >::m_transEqDim = -1

mutableprotected

m_transPeriod

template<class Derived >

Vector_t ManyBodySpaceBase< Derived >::m_transPeriod

mutableprotected

---

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

• /Users/shoki/GitHub/Locality/Headers/HilbertSpace/HilbertSpace.hpp