EigenExpValue.cpp File Reference

Classes
class	IOManager

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

Detailed Description

Author

Shoki Sugimoto (sugim.nosp@m.oto@.nosp@m.cat.p.nosp@m.hys..nosp@m.s.u-t.nosp@m.okyo.nosp@m..ac.j.nosp@m.o)

Version

2.0

Date

2022-10-03

Copyright

Copyright (c) 2022

Input: Ensemble.hpp

• class HamiltonianEnsemble
  • sample(void) -> class ScalableOperator
    Returns an instance of class ScalableOperator
    Class ScalableOperator must provide the method "construct_globalOp(size_t L) -> Eigen::MatrixX"
    
  • discard(size_t n) -> void
    Discards n samples
    
  • [class method] dataname(size_t rep) -> std::string
    Returns the name of the directory for a given Hamitonian
    
  • [class method] usage(size_t nargs) -> std::string
    
  • [class method] nargs(void) -> size_t
    
  • [typedef] EigenSolver
• class ObservableEnsemble
  
  • sample(void) -> class MatrixType
    
  • reset(void) -> void
    Reset the internal state of the random number generator
  • discard(size_t n) -> void
    Discards n samples
    
  • [class method] dataname(size_t rep) -> std::string
    Returns the name of the directory for a given Hamitonian
    
  • [class method] usage(size_t nargs) -> std::string
    
  • [class method] nargs(void) -> size_t
    
  • [typedef] EigenSolver

Output: A file that contains eigenstate expectation values of an observable sampled randomly from the random matrix ensemble defined in Ensemble.hpp

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

                                {
    constexpr size_t nargs = 8;
    if(argc != nargs + HamiltonianEnsemble::nargs() + ObservableEnsemble::nargs()) {
        std::cerr << "Usage: 0.(This) 1.(LMax) 2.(LMin) 3.(hRepMin) 4.(hRepMax) 5.(opRepMin) "
                     "6.(opRepMax) 7.(OutDir)\n";
        size_t arg_count = nargs;
        std::cerr << "       " << HamiltonianEnsemble::usage(arg_count) << "\n";
        arg_count += HamiltonianEnsemble::nargs();
        std::cerr << "       " << ObservableEnsemble::usage(arg_count) << "\n";
        std::cerr << "argc = " << argc << std::endl;
        std::exit(EXIT_FAILURE);
    }
    size_t const LMax     = std::atoi(argv[1]);
    size_t const LMin     = std::atoi(argv[2]);
    size_t const hRepMin  = std::atoi(argv[3]);
    size_t const hRepMax  = std::atoi(argv[4]);
    size_t const opRepMin = std::atoi(argv[5]);
    size_t const opRepMax = std::atoi(argv[6]);
    IOManager    data_writer(argv[7]);
 
    size_t arg_count = nargs;
    auto&  hEnsemble = HamiltonianEnsemble::get_instance(argv + arg_count);
    arg_count += HamiltonianEnsemble::nargs();
    std::vector<ObservableEnsemble> obsEnsembles(LMax + 1);
    for(size_t L = LMin; L <= LMax; ++L) {
        obsEnsembles[L] = ObservableEnsemble(L, argv + arg_count);
    }
 
    hEnsemble.discard(hRepMin);
    for(size_t hRep = hRepMin; hRep <= hRepMax; ++hRep) {
        // Sample a Hamiltonian
        auto loc_hamiltonian = hEnsemble.sample();
 
        for(size_t L = LMin; L <= LMax; ++L) {
            auto hamiltonian = loc_hamiltonian.construct_globalOp(L);
            // Diagonalize a Hamiltonian to get eigenvalues and eigenvectors
            HamiltonianEnsemble::EigenSolver eigSolver(std::move(hamiltonian));
            data_writer.save_ResultsToFile(eigSolver.eigenvalues(), hRep, L);
 
            auto& opEnsemble = obsEnsembles[L];
            opEnsemble.reset();
            opEnsemble.discard(opRepMin);
            for(size_t opRep = opRepMin; opRep <= opRepMax; ++opRep) {
                std::cout << "hRep = " << hRep << ", L = " << L << ", opRep = " << opRep
                          << std::endl;
                // Sample an observable
                auto observable = opEnsemble.sample();
                auto eev        = EigenExpValues(eigSolver.eigenvectors(), observable);
 
                ObservableEnsemble::EigenSolver op_EigSolver(std::move(observable),
                                                             Eigen::EigenvaluesOnly);
                data_writer.save_ResultsToFile(op_EigSolver.eigenvalues(), eev, hRep, L, opRep);
            }
        }
    }
    return EXIT_SUCCESS;
}