EigenExpValue_gpu.cu File Reference

Functions
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

                                {
    if(argc != 2) {
        std::cerr << "Usage: EigenExpValue 1.InFile" << std::endl;
        std::exit(EX_USAGE);
    }
    std::string   InFName(argv[1]);
    std::ifstream Infs(InFName);
    Infs.exceptions(std::ios::badbit | std::ios::eofbit | std::ios::failbit);
        if( !Infs.is_open() ) {
            std::cerr << "Can't open a file \"" << InFName << "\"" << std::endl;
            std::exit(EX_NOINPUT);
        }
    try { skip_header(Infs); }
    catch(std::exception& e) {
        std::cerr << "Error(skip_header): " << e.what() << std::endl;
        std::cerr << "File: \"" << InFName << "\" is empty." << std::endl;
        std::exit(EX_NOINPUT);
    }
    Infs.exceptions(std::ifstream::badbit);
 
    std::cout << "########## Input ##########" << std::endl;
    bool dimFlag = false;
    Integer_t dim = 0;
    matrix<Complex_t<double>> Hamiltonian, Operator;
    std::vector<double> ExpValue, Eigenvalue;
    std::string      str;
    std::stringstream ss;
    auto oldPos = Infs.tellg();
    while( std::getline(Infs, str) ){
        ss.str(str); ss.clear(std::stringstream::goodbit);
        ss >> str;
        if(str.find("dim") != std::string::npos) {
                ss >> str;
                dim = std::atoi(str.c_str());
                dimFlag=true;
        } else if(str.find("Hamiltonian") != std::string::npos) {
                if(dimFlag == false) {
                    std::cerr << "Error: Invalid data format." << std::endl; std::exit(EX_DATAERR);
                }
                Infs.seekg(oldPos);
                std::cout << "dim = " << dim << std::endl;
                Hamiltonian.resize(dim,dim);
                readMatrix(Infs, dim, Hamiltonian);
                #ifndef NDEBUG
                    std::cout << "Hamiltonian:" << std::endl;
                    Hamiltonian.print(dim,dim);
                #endif
        } else if(str.find("Operator") != std::string::npos) {
                if(dimFlag == false) {
                    std::cerr << "Error: Invalid data format." << std::endl; std::exit(EX_DATAERR);
                }
                Infs.seekg(oldPos);
                Operator.resize(dim,dim);
                readMatrix(Infs, dim, Operator);
                #ifndef NDEBUG
                    std::cout << "Operator:" << std::endl;
                    Operator.print(dim,dim);
                #endif
        } else if(str.find("ExpValue") != std::string::npos) {
                if(dimFlag == false) {
                    std::cerr << "Error: Invalid data format." << std::endl; std::exit(EX_DATAERR);
                }
                // Infs.seekg(oldPos);
        } else if(str.find("Eigenvalue") != std::string::npos) {
                if(dimFlag == false) {
                    std::cerr << "Error: Invalid data format." << std::endl; std::exit(EX_DATAERR);
                }
                // Infs.seekg(oldPos);
        }
        oldPos = Infs.tellg();
    }
 
    std::cout << "\n" << "########## Result ##########" << std::endl;
    magma_init();
    magma_int_t    dev = 0;
    magma_queue_t queue=NULL;
    magma_queue_create( dev, &queue );
    matrix_gpu<Complex_t<double>> dHamiltonian(dim,dim);
    matrix_gpu<Complex_t<double>> dOperator(dim,dim);
    magma_zsetmatrix(dim,dim, &*Hamiltonian.begin(), dim, dHamiltonian.ptr(), dim, queue);
    magma_zsetmatrix(dim,dim, &*Operator.begin(),    dim, dOperator.ptr(),    dim, queue);
 
    std::vector<double> ResEXPvalue(dim);
    std::vector<double> ResEigenvalue(dim);
    EigenExpValue(ResEXPvalue, ResEigenvalue, dim, dHamiltonian, dOperator, queue);
    std::cout << "ResEXPvalue:"   << std::endl; print(ResEXPvalue,dim);
    std::cout << "ResEigenvalue:" << std::endl; print(ResEigenvalue,dim);
 
    magma_finalize();
    return 0;
}