ParityTransSector< RealType > Class Template Reference

Translation invariant sector of a many-body Hilbert space. More...

#include <ParityTransSector.hpp>

Inheritance diagram for ParityTransSector< RealType >:

Collaboration diagram for ParityTransSector< RealType >:

Public Types
using	TotalSpace = ManyBodySpinSpace
Public Types inherited from SubSpace< TotalSpace_, ScalarType_ >
using	TotalSpace = TotalSpace_
using	Scalar = ScalarType_
using	Real = typename Eigen::NumTraits< ScalarType_ >::Real

Public Member Functions
__host__ __device__	ParityTransSector (int parity, ManyBodySpinSpace const &mbHSpace)
	Construct a ParityTransSector object from a ManyBodySpinSpace object.
__host__ __device__	ParityTransSector (int parity=0, int systemSize=0, int dimLoc=0)
	Default constructor.
__host__ __device__ constexpr int	momentum () const
__host__ __device__ constexpr int	parity () const
__host__ __device__ int	rep (int j, int trans=0) const
__host__ __device__ int	period (int j) const
Public Member Functions inherited from SubSpace< TotalSpace_, ScalarType_ >
__host__ __device__	SubSpace (TotalSpace const &totalSpace)
	Construct a SubSpace object by copying totalSpace to its member variable (m_totalSpace)
__host__ __device__	SubSpace (TotalSpace &&totalSpace)
	Construct a SubSpace object by moving totalSpace to its member variable (m_totalSpace)
__host__ __device__	SubSpace ()=default
	Default constructor.
__host__ __device__	SubSpace (SubSpace const &other)=default
	Copy constructor.
template<typename Scalar_ >
__host__ __device__	SubSpace (SubSpace< TotalSpace_, Scalar_ > const &other)
__host__ __device__	SubSpace (SubSpace &&other)=default
	Move constructor.
__host__ __device__	~SubSpace ()=default
	Destructor.
__host__ __device__ SubSpace &	operator= (SubSpace const &other)
	Copy assignment operator.
__host__ __device__ SubSpace &	operator= (SubSpace &&other)
	Move assignment operator.
__host__ __device__ bool	operator== (SubSpace const &other) const
	Equality operator.
__host__ __device__ Matrix_t &	basis ()
__host__ __device__ Matrix_t const &	basis () const
__host__ __device__ TotalSpace const &	totalSpace () const
__host__ __device__ int	dimTot () const
Public Member Functions inherited from HilbertSpace< Derived >
__host__ __device__ int	dim () const
__host__ __device__ bool	operator== (HilbertSpace const &other) const

Private Attributes
int	m_parity
int	m_numParityPairs = 0

Additional Inherited Members
Protected Types inherited from SubSpace< TotalSpace_, ScalarType_ >
using	Matrix_t = SparseCompressed< Scalar >
using	Matrix_t = Eigen::SparseMatrix< Scalar >
Protected Attributes inherited from SubSpace< TotalSpace_, ScalarType_ >
TotalSpace	m_totalSpace
Matrix_t	m_basisStates

Detailed Description

template<typename RealType = Real_t>
class ParityTransSector< RealType >

Translation invariant sector of a many-body Hilbert space.

Template Parameters

Scalar_t
int
Matrix

Member Typedef Documentation

TotalSpace

template<typename RealType = Real_t>

using ParityTransSector< RealType >::TotalSpace = ManyBodySpinSpace

Constructor & Destructor Documentation

ParityTransSector() [1/2]

template<typename RealType >

__host__ __device__ ParityTransSector< RealType >::ParityTransSector	(	int	parity,
		ManyBodySpinSpace const &	mbHSpace
	)

Construct a ParityTransSector object from a ManyBodySpinSpace object.

Parameters

k
mbHSpace

    : SubSpace< ManyBodySpinSpace, Complex_t<RealType> >{mbHSpace},
      m_parity((parity >= 0 ? +1 : -1)) {
    debug_constructor_printf(1);
    constexpr Complex_t<RealType> I = Complex_t<RealType>(0, 1);
    if(this->totalSpace().sysSize() == 0) { return; }
 
    this->totalSpace().computeTransEqClass();
    debug_printf("%s:\n\t this->totalSpace().dim()=%d, this->totalSpace().transEqDim()=%d, "
                 "this->totalSpace().transPeriod().sum()=%d\n",
                 __PRETTY_FUNCTION__, this->totalSpace().dim(), this->totalSpace().transEqDim(),
                 this->totalSpace().transPeriod().sum());
    assert(this->totalSpace().transPeriod().sum() == this->totalSpace().dim());
 
    int L            = this->totalSpace().sysSize();
    int dim          = 0;
    m_numParityPairs = 0;
    Eigen::ArrayX<bool> calculated;
    calculated = Eigen::ArrayX<bool>::Constant(this->totalSpace().transEqDim(), false);
    for(int eqClass = 0; eqClass < this->totalSpace().transEqDim(); ++eqClass) {
        if(calculated(eqClass)) continue;
        calculated(eqClass)  = true;
        auto repState        = this->totalSpace().transEqClassRep(eqClass);
        auto revState        = this->totalSpace().reverse(repState);
        auto reversed        = this->totalSpace().stateToTransEqClass(revState);
        calculated(reversed) = true;
        // std::cout << "reversed = " << reversed << std::endl;
        // std::cout << this->totalSpace().ordinalToConfig(repState) << std::endl;
        // std::cout << this->totalSpace().ordinalToConfig(revState) << "\n" << std::endl;
        if(eqClass != reversed) { m_numParityPairs += 1; }
        dim += 1;
    }
    if(m_parity == -1) dim = m_numParityPairs;
    std::cout << "m_parity = " << m_parity << ", dim = " << dim
              << ", m_numParityPairs = " << m_numParityPairs << std::endl;
 
#ifdef __CUDA_ARCH__
    this->basis().resize(this->totalSpace().dim(), dim, this->totalSpace().dim());
 
    int nonZeroId = 0, classIdx = 0;
    if(m_parity != -1) {
        calculated = Eigen::ArrayX<bool>::Constant(this->totalSpace().transEqDim(), false);
        for(int eqClass = 0; eqClass != this->totalSpace().transEqDim(); ++eqClass) {
            if(calculated(eqClass)) continue;
            calculated(eqClass)  = true;
            auto repState        = this->totalSpace().transEqClassRep(eqClass);
            auto revState        = this->totalSpace().reverse(repState);
            auto reversed        = this->totalSpace().stateToTransEqClass(revState);
            calculated(reversed) = true;
            if(eqClass != reversed) continue;
 
            this->basis().outerIndexPtr()[classIdx] = nonZeroId;
            for(int trans = 0; trans != this->totalSpace().transPeriod(eqClass); ++trans) {
                this->basis().innerIndexPtr()[nonZeroId]
                    = this->totalSpace().transEqClassRep(eqClass, trans);
                this->basis().valuePtr()[nonZeroId]
                    = 1.0 / RealType(sqrt(RealType(this->totalSpace().transPeriod(eqClass))));
                ++nonZeroId;
            }
            ++classIdx;
        }
    }
 
    calculated = Eigen::ArrayX<bool>::Constant(this->totalSpace().transEqDim(), false);
    for(int eqClass = 0; eqClass != this->totalSpace().transEqDim(); ++eqClass) {
        if(calculated(eqClass)) continue;
        calculated(eqClass)  = true;
        auto repState        = this->totalSpace().transEqClassRep(eqClass);
        auto revState        = this->totalSpace().reverse(repState);
        auto reversed        = this->totalSpace().stateToTransEqClass(revState);
        calculated(reversed) = true;
        if(eqClass == reversed) continue;
 
        this->basis().outerIndexPtr()[classIdx] = nonZeroId;
        for(int trans = 0; trans != this->totalSpace().transPeriod(eqClass); ++trans) {
            this->basis().innerIndexPtr()[nonZeroId]
                = this->totalSpace().transEqClassRep(eqClass, trans);
            this->basis().valuePtr()[nonZeroId]
                = 1.0 / RealType(sqrt(RealType(2 * this->totalSpace().transPeriod(eqClass))));
            ++nonZeroId;
        }
        for(int trans = 0; trans != this->totalSpace().transPeriod(eqClass); ++trans) {
            this->basis().innerIndexPtr()[nonZeroId]
                = this->totalSpace().transEqClassRep(reversed, trans);
            this->basis().valuePtr()[nonZeroId]
                = m_parity / RealType(sqrt(RealType(2 * this->totalSpace().transPeriod(reversed))));
            ++nonZeroId;
        }
        ++classIdx;
    }
    assert(dim == classIdx && "dim == classIdx");
    this->basis().outerIndexPtr()[dim] = nonZeroId;
    this->basis().setNonZeros(this->basis().outerIndexPtr()[dim]);
    for(int eqClass = 0; eqClass != dim; ++eqClass) {
        thrust::sort_by_key(
            thrust::seq, this->basis().innerIndexPtr() + this->basis().outerIndexPtr()[eqClass],
            this->basis().innerIndexPtr() + this->basis().outerIndexPtr()[eqClass + 1],
            this->basis().valuePtr() + this->basis().outerIndexPtr()[eqClass]);
    }
#else   // #ifdef __CUDA_ARCH__
    this->basis().resize(this->totalSpace().dim(), dim);
    this->basis().reserve(Eigen::VectorXi::Constant(dim, 2 * L));
 
    int classIdx = 0;
    if(m_parity != -1) {
        calculated = Eigen::ArrayX<bool>::Constant(this->totalSpace().transEqDim(), false);
        for(int eqClass = 0; eqClass != this->totalSpace().transEqDim(); ++eqClass) {
            if(calculated(eqClass)) continue;
            calculated(eqClass)  = true;
            auto repState        = this->totalSpace().transEqClassRep(eqClass);
            auto revState        = this->totalSpace().reverse(repState);
            auto reversed        = this->totalSpace().stateToTransEqClass(revState);
            calculated(reversed) = true;
            if(eqClass != reversed) continue;
 
            for(int trans = 0; trans != this->totalSpace().transPeriod(eqClass); ++trans) {
                auto state = this->totalSpace().transEqClassRep(eqClass, trans);
                this->basis().insert(state, classIdx)
                    = 1.0 / RealType(sqrt(RealType(this->totalSpace().transPeriod(eqClass))));
            }
            ++classIdx;
        }
    }
 
    calculated = Eigen::ArrayX<bool>::Constant(this->totalSpace().transEqDim(), false);
    for(int eqClass = 0; eqClass != this->totalSpace().transEqDim(); ++eqClass) {
        if(calculated(eqClass)) continue;
        calculated(eqClass)  = true;
        auto repState        = this->totalSpace().transEqClassRep(eqClass);
        auto revState        = this->totalSpace().reverse(repState);
        auto reversed        = this->totalSpace().stateToTransEqClass(revState);
        calculated(reversed) = true;
        if(eqClass == reversed) continue;
 
        for(int trans = 0; trans != this->totalSpace().transPeriod(eqClass); ++trans) {
            auto state = this->totalSpace().transEqClassRep(eqClass, trans);
            this->basis().insert(state, classIdx)
                = 1.0 / RealType(sqrt(RealType(2 * this->totalSpace().transPeriod(eqClass))));
        }
        for(int trans = 0; trans != this->totalSpace().transPeriod(reversed); ++trans) {
            auto state = this->totalSpace().transEqClassRep(reversed, trans);
            this->basis().insert(state, classIdx)
                = m_parity / RealType(sqrt(RealType(2 * this->totalSpace().transPeriod(reversed))));
        }
        ++classIdx;
    }
 
    this->basis().makeCompressed();
#endif  // #ifdef __CUDA_ARCH__
}

ParityTransSector() [2/2]

template<typename RealType = Real_t>

__host__ __device__ ParityTransSector< RealType >::ParityTransSector ( int  parity = 0, int  systemSize = 0, int  dimLoc = 0  )

inline

Default constructor.

Parameters

k
systemSize
dimLoc

            : ParityTransSector(parity, ManyBodySpinSpace(systemSize, dimLoc)) {
            debug_constructor_printf((Default));
        }

Member Function Documentation

momentum()

template<typename RealType = Real_t>

__host__ __device__ constexpr int ParityTransSector< RealType >::momentum ( ) const

inlineconstexpr

{ return 0; };

parity()

template<typename RealType = Real_t>

__host__ __device__ constexpr int ParityTransSector< RealType >::parity ( ) const

inlineconstexpr

{ return m_parity; };

period()

template<typename RealType = Real_t>

__host__ __device__ int ParityTransSector< RealType >::period ( int  j ) const

inline

                                                    {
            assert(j < this->dim() && "j < this->dim()");
            return this->basis().outerIndexPtr()[j + 1] - this->basis().outerIndexPtr()[j];
        };

rep()

template<typename RealType = Real_t>

__host__ __device__ int ParityTransSector< RealType >::rep ( int  j, int  trans = 0  ) const

inline

                                                                {
            int innerId = this->basis().outerIndexPtr()[j] + (trans % this->period(j));
            assert(innerId < this->basis().nonZeros() && "innerId < this->basis().nonZeros()");
            return this->basis().innerIndexPtr()[innerId];
        };

Member Data Documentation

m_numParityPairs

template<typename RealType = Real_t>

int ParityTransSector< RealType >::m_numParityPairs = 0

private

m_parity

template<typename RealType = Real_t>

int ParityTransSector< RealType >::m_parity

private

---

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

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