void dmrg(double sweep_tol) { double last_fe = 10.e6; double last_be = 10.e6; double old_fe = 0.; double old_be = 0.; SweepParams sweepParams; int old_states=sweepParams.get_keep_states(); int new_states; double old_error=0.0; double old_energy=0.0; // warm up sweep ... bool dodiis = false; int domoreIter = 0; bool direction; //this is regular dmrg calculation if(!dmrginp.setStateSpecific()) { sweepParams.current_root() = -1; last_fe = Sweep::do_one(sweepParams, true, true, false, 0); direction = false; while ((fabs(last_fe - old_fe) > sweep_tol) || (fabs(last_be - old_be) > sweep_tol) || (dmrginp.algorithm_method() == TWODOT_TO_ONEDOT && dmrginp.twodot_to_onedot_iter()+1 >= sweepParams.get_sweep_iter()) ) { old_fe = last_fe; old_be = last_be; if(dmrginp.max_iter() <= sweepParams.get_sweep_iter()) break; last_be = Sweep::do_one(sweepParams, false, false, false, 0); direction = true; pout << "\t\t\t Finished Sweep Iteration "<<sweepParams.get_sweep_iter()<<endl; if(dmrginp.max_iter() <= sweepParams.get_sweep_iter()) break; //For obtaining the extrapolated energy old_states=sweepParams.get_keep_states(); new_states=sweepParams.get_keep_states_ls(); last_fe = Sweep::do_one(sweepParams, false, true, false, 0); direction = false; new_states=sweepParams.get_keep_states(); pout << "\t\t\t Finished Sweep Iteration "<<sweepParams.get_sweep_iter()<<endl; if (domoreIter == 2) { dodiis = true; break; } } } else { //this is state specific calculation const int nroots = dmrginp.nroots(); bool direction=true; int restartsize; //sweepParams.restorestate(direction, restartsize); //sweepParams.set_sweep_iter() = 0; //sweepParams.set_restart_iter() = 0; algorithmTypes atype; pout << "STARTING STATE SPECIFIC CALCULATION "<<endl; for (int i=0; i<nroots; i++) { atype = dmrginp.algorithm_method(); dmrginp.set_algorithm_method() = ONEDOT; sweepParams.current_root() = i; p1out << "RUNNING GENERATE BLOCKS FOR STATE "<<i<<endl; if (mpigetrank()==0) { Sweep::InitializeStateInfo(sweepParams, direction, i); Sweep::InitializeStateInfo(sweepParams, !direction, i); Sweep::CanonicalizeWavefunction(sweepParams, direction, i); Sweep::CanonicalizeWavefunction(sweepParams, !direction, i); Sweep::CanonicalizeWavefunction(sweepParams, direction, i); Sweep::InitializeStateInfo(sweepParams, direction, i); Sweep::InitializeStateInfo(sweepParams, !direction, i); } for (int j=0; j<i ; j++) { int integralIndex = 0; Sweep::InitializeOverlapSpinBlocks(sweepParams, direction, i, j, integralIndex); Sweep::InitializeOverlapSpinBlocks(sweepParams, !direction, i, j, integralIndex); } dmrginp.set_algorithm_method() = atype; p1out << "RUNNING GENERATE BLOCKS FOR STATE "<<i<<endl; SweepGenblock::do_one(sweepParams, false, !direction, false, 0, i, i); sweepParams.set_sweep_iter() = 0; sweepParams.set_restart_iter() = 0; sweepParams.savestate(!direction, restartsize); pout << "STATE SPECIFIC CALCULATION FOR STATE: "<<i<<endl; dmrg_stateSpecific(sweep_tol, i); pout << "STATE SPECIFIC CALCULATION FOR STATE: "<<i<<" FINSIHED"<<endl; } pout << "ALL STATE SPECIFIC CALCUALTIONS FINISHED"<<endl; } }
void responseSweep(double sweep_tol, int targetState, vector<int>& projectors, vector<int>& baseStates) { double last_fe = 1.e6; double last_be = 1.e6; double old_fe = 0.; double old_be = 0.; SweepParams sweepParams; bool direction, warmUp, restart; int restartSize=0; direction = true; //forward warmUp = true; //startup sweep restart = false; //not a restart sweepParams.current_root() = -1; algorithmTypes atype = dmrginp.algorithm_method(); dmrginp.set_algorithm_method() = ONEDOT; //the baseState is the initial guess for the targetState if (FULLRESTART) { sweepParams.restorestate(direction, restartSize); direction = !direction; dmrginp.setGuessState() = targetState; last_fe = SweepResponse::do_one(sweepParams, warmUp, direction, restart, restartSize, targetState, projectors, baseStates); bool tempdirection; sweepParams.restorestate(tempdirection, restartSize); sweepParams.calc_niter(); sweepParams.set_sweep_iter() = 0; sweepParams.set_restart_iter() = 0; sweepParams.savestate(tempdirection, restartSize); } else if (RESTART) { dmrginp.set_algorithm_method() = atype; warmUp = false; restart = true; sweepParams.restorestate(direction, restartSize); last_fe = SweepResponse::do_one(sweepParams, warmUp, direction, restart, restartSize, targetState, projectors, baseStates); } else last_fe = SweepResponse::do_one(sweepParams, warmUp, direction, restart, restartSize, targetState, projectors, baseStates); dmrginp.set_algorithm_method() = atype; restart = false; restartSize = 0; warmUp = false; while ( true) { old_fe = last_fe; old_be = last_be; if(dmrginp.max_iter() <= sweepParams.get_sweep_iter()) break; last_be = SweepResponse::do_one(sweepParams, warmUp, !direction, restart, restartSize, targetState, projectors, baseStates); p1out << "\t\t\t Finished Sweep Iteration "<<sweepParams.get_sweep_iter()<<endl; if(dmrginp.max_iter() <= sweepParams.get_sweep_iter()) break; last_fe = SweepResponse::do_one(sweepParams, warmUp, direction, restart, restartSize, targetState, projectors, baseStates); pout << "\t\t\t Finished Sweep Iteration "<<sweepParams.get_sweep_iter()<<endl; } }
void restart(double sweep_tol, bool reset_iter) { double last_fe = 100.; double last_be = 100.; double old_fe = 0.; double old_be = 0.; bool direction; int restartsize; SweepParams sweepParams; bool dodiis = false; int domoreIter = 2; sweepParams.restorestate(direction, restartsize); if (!dmrginp.setStateSpecific()) { if(reset_iter) { //this is when you restart from the start of the sweep sweepParams.set_sweep_iter() = 0; sweepParams.set_restart_iter() = 0; } if (restartwarm) last_fe = Sweep::do_one(sweepParams, true, direction, true, restartsize); else last_fe = Sweep::do_one(sweepParams, false, direction, true, restartsize); while ((fabs(last_fe - old_fe) > sweep_tol) || (fabs(last_be - old_be) > sweep_tol) || (dmrginp.algorithm_method() == TWODOT_TO_ONEDOT && dmrginp.twodot_to_onedot_iter()+1 >= sweepParams.get_sweep_iter()) ) { old_fe = last_fe; old_be = last_be; if(dmrginp.max_iter() <= sweepParams.get_sweep_iter()) break; last_be = Sweep::do_one(sweepParams, false, !direction, false, 0); if(dmrginp.max_iter() <= sweepParams.get_sweep_iter()) break; last_fe = Sweep::do_one(sweepParams, false, direction, false, 0); } } else { //this is state specific calculation const int nroots = dmrginp.nroots(); bool direction; int restartsize; sweepParams.restorestate(direction, restartsize); //initialize state and canonicalize all wavefunctions int currentRoot = sweepParams.current_root(); for (int i=0; i<nroots; i++) { sweepParams.current_root() = i; if (mpigetrank()==0) { Sweep::InitializeStateInfo(sweepParams, direction, i); Sweep::InitializeStateInfo(sweepParams, !direction, i); Sweep::CanonicalizeWavefunction(sweepParams, direction, i); Sweep::CanonicalizeWavefunction(sweepParams, !direction, i); Sweep::CanonicalizeWavefunction(sweepParams, direction, i); } } //now generate overlaps with all the previous wavefunctions for (int i=0; i<currentRoot; i++) { sweepParams.current_root() = i; if (mpigetrank()==0) { for (int j=0; j<i; j++) { int integralIndex = 0; Sweep::InitializeOverlapSpinBlocks(sweepParams, !direction, i, j, integralIndex); Sweep::InitializeOverlapSpinBlocks(sweepParams, direction, i, j, integralIndex); } } } sweepParams.current_root() = currentRoot; if (sweepParams.current_root() <0) { p1out << "This is most likely not a restart calculation and should be done without the restart command!!"<<endl; p1out << "Aborting!!"<<endl; exit(0); } pout << "RESTARTING STATE SPECIFIC CALCULATION OF STATE "<<sweepParams.current_root()<<" AT SWEEP ITERATION "<<sweepParams.get_sweep_iter()<<endl; //this is so that the iteration is not one ahead after generate block for restart --sweepParams.set_sweep_iter(); sweepParams.savestate(direction, restartsize); for (int i=sweepParams.current_root(); i<nroots; i++) { sweepParams.current_root() = i; p1out << "RUNNING GENERATE BLOCKS FOR STATE "<<i<<endl; if (mpigetrank()==0) { Sweep::InitializeStateInfo(sweepParams, direction, i); Sweep::InitializeStateInfo(sweepParams, !direction, i); Sweep::CanonicalizeWavefunction(sweepParams, direction, i); Sweep::CanonicalizeWavefunction(sweepParams, !direction, i); Sweep::CanonicalizeWavefunction(sweepParams, direction, i); for (int j=0; j<i ; j++) { int integralIndex = 0; Sweep::InitializeOverlapSpinBlocks(sweepParams, direction, i, j, integralIndex); Sweep::InitializeOverlapSpinBlocks(sweepParams, !direction, i, j, integralIndex); } } SweepGenblock::do_one(sweepParams, false, !direction, false, 0, i, i); p1out << "STATE SPECIFIC CALCULATION FOR STATE: "<<i<<endl; dmrg_stateSpecific(sweep_tol, i); p1out << "STATE SPECIFIC CALCULATION FOR STATE: "<<i<<" FINSIHED"<<endl; sweepParams.set_sweep_iter() = 0; sweepParams.set_restart_iter() = 0; sweepParams.savestate(!direction, restartsize); } p1out << "ALL STATE SPECIFIC CALCUALTIONS FINISHED"<<endl; } if(dmrginp.max_iter() <= sweepParams.get_sweep_iter()){ pout << "\n\t\t\t Maximum sweep iterations achieved " << std::endl; } }