Ensemble.cuh File Reference

Classes
class	SubSpaceManager
class	ScalableOperator< MatrixType >
class	HamiltonianEnsemble
class	ObservableEnsemble

Typedefs
using	RealScalar = Real_t
using	Scalar = Complex_t< RealScalar >

Functions
template<class Derived1 , class Derived2 , class TotalSpace , typename Scalar >
__global__ void	construct_globalOp_kernel (Eigen::MatrixBase< Derived1 > *dTotMat, Eigen::MatrixBase< Derived2 > const *dLocMat, SubSpace< TotalSpace, Scalar > const *subSpace)
template<class Derived1 , class Derived2 , class TotalSpace >
__global__ void	ObservableEnsemble_sample_kernel (Eigen::MatrixBase< Derived1 > *resPtr, Eigen::MatrixBase< Derived2 > const *opTotPtr, SubSpace< TotalSpace, typename Derived1::Scalar > const *subSpacePtr)

Variables
int	g_dimLoc = 2
int	g_momentum = 0

Typedef Documentation

RealScalar

using RealScalar = Real_t

Scalar

using Scalar = Complex_t<RealScalar>

Function Documentation

construct_globalOp_kernel()

template<class Derived1 , class Derived2 , class TotalSpace , typename Scalar >

__global__ void construct_globalOp_kernel	(	Eigen::MatrixBase< Derived1 > *	dTotMat,
		Eigen::MatrixBase< Derived2 > const *	dLocMat,
		SubSpace< TotalSpace, Scalar > const *	subSpace
	)

                                                                                        {
    int const idx = blockIdx.x * blockDim.x + threadIdx.x;
    int const idy = blockIdx.y * blockDim.y + threadIdx.y;
    if(idx >= dTotMat->rows() || idy >= dTotMat->cols()) return;
    if(idx < idy) return;
 
    int const dimLoc = dLocMat->cols();
    int const dimTot = subSpace->basis().outerIndexPtr()[dTotMat->rows()];
 
    (*dTotMat)(idx, idy) = {0, 0};
    int innerX, innerY, locIdX, locIdY;
    for(auto valuePosX = subSpace->basis().outerIndexPtr()[idx];
        valuePosX != subSpace->basis().outerIndexPtr()[idx + 1]; ++valuePosX) {
        innerX          = subSpace->basis().innerIndexPtr()[valuePosX];
        auto conjCoeffX = conj(subSpace->basis().valuePtr()[valuePosX]);
 
        for(auto valuePosY = subSpace->basis().outerIndexPtr()[idy];
            valuePosY != subSpace->basis().outerIndexPtr()[idy + 1]; ++valuePosY) {
            innerY      = subSpace->basis().innerIndexPtr()[valuePosY];
            auto CoeffY = subSpace->basis().valuePtr()[valuePosY];
 
            if(innerX / dimLoc != innerY / dimLoc) continue;
            locIdX = innerX % dimLoc;
            locIdY = innerY % dimLoc;
            (*dTotMat)(idx, idy) += conjCoeffX * (*dLocMat)(locIdX, locIdY) * CoeffY;
        }
    }
 
    if(idx == idy) { (*dTotMat)(idx, idy) = real((*dTotMat)(idx, idy)); }
    else { (*dTotMat)(idy, idx) = conj((*dTotMat)(idx, idy)); }
    // printf("LDT=%d, id=(%d,%d), val=%+f%+f*i\t %s is yet to be tested.\n", LDT, idx, idy,
    //        real(dTotMat[idx + LDT * idy]), imag(dTotMat[idx + LDT * idy]), __func__);
    // printf("\t id=(%d,%d)\n", idx, idy);
    return;
}

ObservableEnsemble_sample_kernel()

template<class Derived1 , class Derived2 , class TotalSpace >

__global__ void ObservableEnsemble_sample_kernel	(	Eigen::MatrixBase< Derived1 > *	resPtr,
		Eigen::MatrixBase< Derived2 > const *	opTotPtr,
		SubSpace< TotalSpace, typename Derived1::Scalar > const *	subSpacePtr
	)

                                                                        {
    int const idx   = blockIdx.x * blockDim.x + threadIdx.x;
    int const idy   = blockIdx.y * blockDim.y + threadIdx.y;
    auto&     basis = subSpacePtr->basis();
    if(idx >= resPtr->rows() || idy >= resPtr->cols()) return;
    if(idx > idy) return;
 
    (*resPtr)(idx, idy) = {0, 0};
    int innerX, innerY;
    for(auto valuePosX = basis.outerIndexPtr()[idx]; valuePosX != basis.outerIndexPtr()[idx + 1];
        ++valuePosX) {
        innerX          = basis.innerIndexPtr()[valuePosX];
        auto conjCoeffX = conj(basis.valuePtr()[valuePosX]);
 
        for(auto valuePosY = basis.outerIndexPtr()[idy];
            valuePosY != basis.outerIndexPtr()[idy + 1]; ++valuePosY) {
            innerY      = basis.innerIndexPtr()[valuePosY];
            auto CoeffY = basis.valuePtr()[valuePosY];
 
            (*resPtr)(idx, idy) += conjCoeffX * (*opTotPtr)(innerX, innerY) * CoeffY;
        }
    }
 
    if(idx == idy) (*resPtr)(idy, idx) = real((*resPtr)(idy, idx));
 
    (*resPtr)(idy, idx) = conj((*resPtr)(idx, idy));
}

Variable Documentation

g_dimLoc

int g_dimLoc = 2

g_momentum

int g_momentum = 0