statmech_gpu.cu File Reference

Functions
template<typename TypeComplex >
magma_int_t	EigenValues (std::vector< double > &eigenvalue, magma_int_t const dim, matrix_gpu< TypeComplex > &dHamiltonian)
template<>
magma_int_t	EigenValues< magmaFloatComplex > (std::vector< double > &eigenvalue, magma_int_t const dim, matrix_gpu< magmaFloatComplex > &dHamiltonian)
template<>
magma_int_t	EigenValues< magmaDoubleComplex > (std::vector< double > &eigenvalue, magma_int_t const dim, matrix_gpu< magmaDoubleComplex > &dHamiltonian)
template<typename TypeComplex >
double	SpectralRange (double &OpMin, magma_int_t const dim, matrix_gpu< TypeComplex > &dHamiltonian)
template<>
double	SpectralRange< magmaFloatComplex > (double &OpMin, magma_int_t const dim, matrix_gpu< magmaFloatComplex > &dHamiltonian)
template<>
double	SpectralRange< magmaDoubleComplex > (double &OpMin, magma_int_t const dim, matrix_gpu< magmaDoubleComplex > &dHamiltonian)
template<typename TypeComplex >
magma_int_t	Diagonalize (magma_int_t const dim, matrix_gpu< TypeComplex > &dHamiltonian, std::vector< double > &eigenvalue_h)
template<>
magma_int_t	Diagonalize< magmaFloatComplex > (magma_int_t const dim, matrix_gpu< magmaFloatComplex > &dHamiltonian, std::vector< double > &eigenvalue_h)
template<>
magma_int_t	Diagonalize< magmaDoubleComplex > (magma_int_t const dim, matrix_gpu< magmaDoubleComplex > &dHamiltonian, std::vector< double > &eigenvalue_h)
template<typename TypeComplex >
magma_int_t	EigenMatrixElements (std::vector< double > &eigenvalue_h, magma_int_t const dim, matrix_gpu< TypeComplex > &dHamiltonian, matrix_gpu< TypeComplex > &dOperator, GPUconfig const &GPUconf)
template magma_int_t	EigenMatrixElements< magmaFloatComplex > (std::vector< double > &eigenvalue_h, magma_int_t const dim, matrix_gpu< magmaFloatComplex > &dHamiltonian, matrix_gpu< magmaFloatComplex > &dOperator, GPUconfig const &GPUconf)
template magma_int_t	EigenMatrixElements< magmaDoubleComplex > (std::vector< double > &eigenvalue_h, magma_int_t const dim, matrix_gpu< magmaDoubleComplex > &dHamiltonian, matrix_gpu< magmaDoubleComplex > &dOperator, GPUconfig const &GPUconf)
template<typename TypeComplex >
magma_int_t	EigenExpValue (std::vector< double > &EXPvalue_h, std::vector< double > &eigenvalue_h, magma_int_t const dim, matrix_gpu< TypeComplex > &dHamiltonian, matrix_gpu< TypeComplex > &dOperator, GPUconfig const &GPUconf)
template magma_int_t	EigenExpValue< magmaFloatComplex > (std::vector< double > &EXPvalue_h, std::vector< double > &eigenvalue_h, magma_int_t const dim, matrix_gpu< magmaFloatComplex > &dHamiltonian, matrix_gpu< magmaFloatComplex > &dOperator, GPUconfig const &GPUconf)
template magma_int_t	EigenExpValue< magmaDoubleComplex > (std::vector< double > &EXPvalue_h, std::vector< double > &eigenvalue_h, magma_int_t const dim, matrix_gpu< magmaDoubleComplex > &dHamiltonian, matrix_gpu< magmaDoubleComplex > &dOperator, GPUconfig const &GPUconf)

Function Documentation

Diagonalize()

template<typename TypeComplex >

magma_int_t Diagonalize	(	magma_int_t const	dim,
		matrix_gpu< TypeComplex > &	dHamiltonian,
		std::vector< double > &	eigenvalue_h
	)

Diagonalize< magmaDoubleComplex >()

template<>

magma_int_t Diagonalize< magmaDoubleComplex >	(	magma_int_t const	dim,
		matrix_gpu< magmaDoubleComplex > &	dHamiltonian,
		std::vector< double > &	eigenvalue_h
	)

                                                                                        {
    return magma_heevd_wrapper(MagmaVec, dim, dHamiltonian, eigenvalue_h);
}

Diagonalize< magmaFloatComplex >()

template<>

magma_int_t Diagonalize< magmaFloatComplex >	(	magma_int_t const	dim,
		matrix_gpu< magmaFloatComplex > &	dHamiltonian,
		std::vector< double > &	eigenvalue_h
	)

                                                                                      {
    std::vector<float> S_eigenvalue(dim, 0);
    magma_int_t        itemp, info = magma_heevd_wrapper(MagmaVec, dim, dHamiltonian, S_eigenvalue);
    magma_int_t const  CONST_ONE = 1;
    lapackf77_slag2d(&CONST_ONE, &dim, &*S_eigenvalue.begin(), &CONST_ONE, &*eigenvalue_h.begin(),
                     &CONST_ONE, &itemp);
    return info;
}

EigenExpValue()

template<typename TypeComplex >

magma_int_t EigenExpValue	(	std::vector< double > &	EXPvalue_h,
		std::vector< double > &	eigenvalue_h,
		magma_int_t const	dim,
		matrix_gpu< TypeComplex > &	dHamiltonian,
		matrix_gpu< TypeComplex > &	dOperator,
		GPUconfig const &	GPUconf
	)

                                                                                        {
    debug_print("# " << __func__ << "_gpu: dim=" << dim);
    magma_int_t info = EigenMatrixElements(eigenvalue_h, dim, dHamiltonian, dOperator, GPUconf);
 
    std::vector<TypeComplex> vector(dim);
    magma_getvector(dim, sizeof(TypeComplex), dOperator.ptr(), dOperator.LD() + 1, &*vector.begin(),
                    1, GPUconf.queue());
 
#pragma omp parallel for
    for(size_t i = 0; i < dim; ++i) {
        EXPvalue_h[i] = (double)real(vector[i]);
        if(isnan(EXPvalue_h[i])) {
#pragma omp critical
            std::cerr << "Error(" << __func__ << "): EXPvalue_h[" << i << "] = NaN." << std::endl;
        }
    }
    return info;
}

EigenExpValue< magmaDoubleComplex >()

template magma_int_t EigenExpValue< magmaDoubleComplex >	(	std::vector< double > &	EXPvalue_h,
		std::vector< double > &	eigenvalue_h,
		magma_int_t const	dim,
		matrix_gpu< magmaDoubleComplex > &	dHamiltonian,
		matrix_gpu< magmaDoubleComplex > &	dOperator,
		GPUconfig const &	GPUconf
	)

EigenExpValue< magmaFloatComplex >()

template magma_int_t EigenExpValue< magmaFloatComplex >	(	std::vector< double > &	EXPvalue_h,
		std::vector< double > &	eigenvalue_h,
		magma_int_t const	dim,
		matrix_gpu< magmaFloatComplex > &	dHamiltonian,
		matrix_gpu< magmaFloatComplex > &	dOperator,
		GPUconfig const &	GPUconf
	)

EigenMatrixElements()

template<typename TypeComplex >

magma_int_t EigenMatrixElements	(	std::vector< double > &	eigenvalue_h,
		magma_int_t const	dim,
		matrix_gpu< TypeComplex > &	dHamiltonian,
		matrix_gpu< TypeComplex > &	dOperator,
		GPUconfig const &	GPUconf
	)

                                                                                              {
    debug_print("# " << __func__ << "_gpu: dim=" << dim);
    magma_int_t const LD   = dHamiltonian.LD();
    magma_int_t const LDT  = magma_roundup(dim, 32);
    magma_int_t       info = Diagonalize(dim, dHamiltonian, eigenvalue_h);
    if(info != 0) return info;
 
    matrix_gpu<TypeComplex> ztemp(LDT, dim);
    matrixProduct_hemm(MagmaLeft, MagmaLower, dim, dim, dOperator, dHamiltonian, ztemp, GPUconf);
    matrixProduct_gemm(MagmaConjTrans, MagmaNoTrans, dim, dim, dim, dHamiltonian, ztemp, dOperator,
                       GPUconf);
    return info;
}

EigenMatrixElements< magmaDoubleComplex >()

template magma_int_t EigenMatrixElements< magmaDoubleComplex >	(	std::vector< double > &	eigenvalue_h,
		magma_int_t const	dim,
		matrix_gpu< magmaDoubleComplex > &	dHamiltonian,
		matrix_gpu< magmaDoubleComplex > &	dOperator,
		GPUconfig const &	GPUconf
	)

EigenMatrixElements< magmaFloatComplex >()

template magma_int_t EigenMatrixElements< magmaFloatComplex >	(	std::vector< double > &	eigenvalue_h,
		magma_int_t const	dim,
		matrix_gpu< magmaFloatComplex > &	dHamiltonian,
		matrix_gpu< magmaFloatComplex > &	dOperator,
		GPUconfig const &	GPUconf
	)

EigenValues()

template<typename TypeComplex >

magma_int_t EigenValues	(	std::vector< double > &	eigenvalue,
		magma_int_t const	dim,
		matrix_gpu< TypeComplex > &	dHamiltonian
	)

EigenValues< magmaDoubleComplex >()

template<>

magma_int_t EigenValues< magmaDoubleComplex >	(	std::vector< double > &	eigenvalue,
		magma_int_t const	dim,
		matrix_gpu< magmaDoubleComplex > &	dHamiltonian
	)

                                                                                          {
    eigenvalue.resize(dim);
    return magma_heevd_wrapper(MagmaNoVec, dim, dHamiltonian, eigenvalue);
}

EigenValues< magmaFloatComplex >()

template<>

magma_int_t EigenValues< magmaFloatComplex >	(	std::vector< double > &	eigenvalue,
		magma_int_t const	dim,
		matrix_gpu< magmaFloatComplex > &	dHamiltonian
	)

                                                                                        {
    eigenvalue.resize(dim);
    std::vector<float> s_eigenvalue(dim);
    magma_int_t itemp, info = magma_heevd_wrapper(MagmaNoVec, dim, dHamiltonian, s_eigenvalue);
    constexpr magma_int_t CONST_ONE = 1;
    lapackf77_slag2d(&CONST_ONE, &dim, &*s_eigenvalue.begin(), &CONST_ONE, &*eigenvalue.begin(),
                     &CONST_ONE, &itemp);
    return info;
}

SpectralRange()

template<typename TypeComplex >

double SpectralRange	(	double &	OpMin,
		magma_int_t const	dim,
		matrix_gpu< TypeComplex > &	dHamiltonian
	)

SpectralRange< magmaDoubleComplex >()

template<>

double SpectralRange< magmaDoubleComplex >	(	double &	OpMin,
		magma_int_t const	dim,
		matrix_gpu< magmaDoubleComplex > &	dHamiltonian
	)

                                                                                       {
    std::vector<double> eigenvalue_h(dim);
    magma_heevd_wrapper(MagmaNoVec, dim, dHamiltonian, eigenvalue_h);
    OpMin = (double)eigenvalue_h[0];
    return (double)(eigenvalue_h[dim - 1] - eigenvalue_h[0]);
}

SpectralRange< magmaFloatComplex >()

template<>

double SpectralRange< magmaFloatComplex >	(	double &	OpMin,
		magma_int_t const	dim,
		matrix_gpu< magmaFloatComplex > &	dHamiltonian
	)

                                                                                     {
    std::vector<float> eigenvalue_h(dim);
    magma_heevd_wrapper(MagmaNoVec, dim, dHamiltonian, eigenvalue_h);
    OpMin = (double)eigenvalue_h[0];
    return (double)(eigenvalue_h[dim - 1] - eigenvalue_h[0]);
}