VMCUpdatePbyP::RealType VMCUpdatePbyP::advanceWalkerForEE(Walker_t& w1, vector<PosType>& dR, vector<int>& iats, vector<int>& rs, vector<RealType>& ratios) { Walker_t::Buffer_t& w_buffer(w1.DataSet); W.loadWalker(w1,true); Psi.copyFromBuffer(W,w_buffer); vector<RealType> runningratio(3,1.0); int sh(0); int nshells(ratios.size()/3); vector<RealType> orb_ratios; // accumulate ratios on the way there for(int itz(0); itz<(iats.size()-1); itz++) { int iat=iats[itz]; W.makeMove(iat,dR[itz]); RealType ratio = Psi.ratioVector(W,iat,orb_ratios); runningratio[0]*=ratio; runningratio[1]*=orb_ratios[0]; runningratio[2]*=ratio/orb_ratios[0]; W.acceptMove(iat); Psi.acceptMove(W,iat); while(itz+1==rs[sh]) { ratios[sh]=runningratio[0]; ratios[nshells+sh]=runningratio[1]; ratios[nshells*2+sh++]=runningratio[2]; } } //we get to reject the last move { int iat=iats[iats.size()-1]; W.makeMove(iat,dR[iats.size()-1]); RealType ratio = Psi.ratioVector(W,iat,orb_ratios); runningratio[0]*=ratio; runningratio[1]*=orb_ratios[0]; runningratio[2]*=ratio/orb_ratios[0]; W.rejectMove(iat); Psi.rejectMove(iat); while(nshells*2+sh < ratios.size()) { ratios[sh]=runningratio[0]; ratios[nshells+sh]=runningratio[1]; ratios[nshells*2+sh++]=runningratio[2]; } } // put the particles back for(int itz(0); itz<iats.size(); itz++) dR[itz]*=-1; for(int itz(iats.size()-2); itz>=0; itz--) { int iat=iats[itz]; W.makeMove(iat,dR[itz]); RealType ratio = Psi.ratio(W,iat); W.acceptMove(iat); Psi.acceptMove(W,iat); } // Psi.updateBuffer(W,w_buffer,false); // W.saveWalker(thisWalker); return runningratio[0]; }
void VMCUpdatePbyP::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end) { while(it != it_end) { Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); W.R = thisWalker.R; w_buffer.rewind(); W.copyFromBuffer(w_buffer); Psi.copyFromBuffer(W,w_buffer); RealType psi_old = thisWalker.Properties(SIGN); RealType psi = psi_old; for(int iter=0; iter<nSubSteps; iter++) { makeGaussRandomWithEngine(deltaR,RandomGen); bool stucked=true; for(int iat=0; iat<W.getTotalNum(); iat++) { PosType dr = m_sqrttau*deltaR[iat]; PosType newpos = W.makeMove(iat,dr); RealType ratio = Psi.ratio(W,iat); RealType prob = std::min(1.0e0,ratio*ratio); if(RandomGen() < prob) { stucked=false; ++nAccept; W.acceptMove(iat); Psi.acceptMove(W,iat); } else { ++nReject; W.rejectMove(iat); Psi.rejectMove(iat); } } if(stucked) { ++nAllRejected; } } thisWalker.R = W.R; w_buffer.rewind(); W.updateBuffer(w_buffer); RealType logpsi = Psi.updateBuffer(W,w_buffer); //W.copyToBuffer(w_buffer); //RealType logpsi = Psi.evaluate(W,w_buffer); RealType eloc=H.evaluate(W); thisWalker.resetProperty(logpsi,Psi.getPhase(),eloc); H.saveProperty(thisWalker.getPropertyBase()); ++it; } }
void CSUpdateBase::updateCSWalkers(WalkerIter_t it, WalkerIter_t it_end) { int iw=0; while(it != it_end) { Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer((*it)->DataSet); w_buffer.rewind(); W.updateBuffer(**it,w_buffer); //evalaute the wavefunction and hamiltonian for(int ipsi=0; ipsi< nPsi; ipsi++) { //Need to modify the return value of OrbitalBase::registerData logpsi[ipsi]=Psi1[ipsi]->updateBuffer(W,(*it)->DataSet); Psi1[ipsi]->G=W.G; thisWalker.Properties(ipsi,LOGPSI)=logpsi[ipsi]; thisWalker.Properties(ipsi,LOCALENERGY)=H1[ipsi]->evaluate(W); H1[ipsi]->saveProperty(thisWalker.getPropertyBase(ipsi)); sumratio[ipsi]=1.0; } int indexij(0); RealType *rPtr=ratioIJ[iw]; for(int ipsi=0; ipsi< nPsi-1; ipsi++) { for(int jpsi=ipsi+1; jpsi< nPsi; jpsi++) { RealType r=std::exp(2.0*(logpsi[jpsi]-logpsi[ipsi])); rPtr[indexij++]=r*avgNorm[ipsi]/avgNorm[jpsi]; sumratio[ipsi] += r; sumratio[jpsi] += 1.0/r; } } //Re-use Multiplicity as the sumratio thisWalker.Multiplicity=sumratio[0]; for(int ipsi=0; ipsi< nPsi; ipsi++) { thisWalker.Properties(ipsi,UMBRELLAWEIGHT) = invsumratio[ipsi] =1.0/sumratio[ipsi]; } //DON't forget DRIFT!!! thisWalker.Drift=0.0; if(useDrift) { for(int ipsi=0; ipsi< nPsi; ipsi++) PAOps<RealType,DIM>::axpy(invsumratio[ipsi],Psi1[ipsi]->G,thisWalker.Drift); setScaledDrift(Tau,thisWalker.Drift); } ++it; ++iw; } }
void CompositeEstimatorSet::accumulate(MCWalkerConfiguration& W, MCWalkerConfiguration::iterator wit, MCWalkerConfiguration::iterator wit_end, RealType wgtnorm) { //initialize temporary data for(int i=0; i< Estimators.size(); i++) Estimators[i]->startAccumulate(); typedef MCWalkerConfiguration::Walker_t Walker_t; if(W.updatePbyP()) { while(wit != wit_end) { Walker_t& thisWalker(**wit); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); w_buffer.rewind(); W.copyFromBuffer(w_buffer); for(int i=0; i< Estimators.size(); i++) Estimators[i]->accumulate(W); ++wit; } } else { while(wit != wit_end) { Walker_t& thisWalker(**wit); W.R=thisWalker.R; W.update(); for(int i=0; i< Estimators.size(); i++) Estimators[i]->accumulate(W); ++wit; } } for(int i=0; i< Estimators.size(); i++) Estimators[i]->stopAccumulate(wgtnorm); //curSteps++; }
void VMCParticleByParticle::runBlockWithDrift() { IndexType step = 0; MCWalkerConfiguration::iterator it_end(W.end()); do { //advanceWalkerByWalker(); MCWalkerConfiguration::iterator it(W.begin()); while(it != it_end) { //MCWalkerConfiguration::WalkerData_t& w_buffer = *(W.DataSet[iwalker]); Walker_t& thisWalker(**it); Buffer_t& w_buffer(thisWalker.DataSet); W.R = thisWalker.R; w_buffer.rewind(); W.copyFromBuffer(w_buffer); Psi.copyFromBuffer(W,w_buffer); RealType psi_old = thisWalker.Properties(SIGN); RealType psi = psi_old; //create a 3N-Dimensional Gaussian with variance=1 makeGaussRandom(deltaR); bool moved = false; for(int iat=0; iat<W.getTotalNum(); iat++) { PosType dr = m_sqrttau*deltaR[iat]+thisWalker.Drift[iat]; PosType newpos = W.makeMove(iat,dr); //RealType ratio = Psi.ratio(W,iat); RealType ratio = Psi.ratio(W,iat,dG,dL); G = W.G+dG; //RealType forwardGF = exp(-0.5*dot(deltaR[iat],deltaR[iat])); //dr = (*it)->R[iat]-newpos-Tau*G[iat]; //RealType backwardGF = exp(-oneover2tau*dot(dr,dr)); RealType logGf = -0.5e0*dot(deltaR[iat],deltaR[iat]); RealType scale=getDriftScale(Tau,G); //COMPLEX WARNING //dr = thisWalker.R[iat]-newpos-scale*G[iat]; dr = thisWalker.R[iat]-newpos-scale*real(G[iat]); RealType logGb = -m_oneover2tau*dot(dr,dr); RealType prob = std::min(1.0e0,ratio*ratio*exp(logGb-logGf)); //alternatively if(Random() < prob) { moved = true; ++nAccept; W.acceptMove(iat); Psi.acceptMove(W,iat); W.G = G; W.L += dL; //thisWalker.Drift = scale*G; assignDrift(scale,G,thisWalker.Drift); } else { ++nReject; W.rejectMove(iat); Psi.rejectMove(iat); } } if(moved) { w_buffer.rewind(); W.copyToBuffer(w_buffer); psi = Psi.evaluate(W,w_buffer); thisWalker.R = W.R; RealType eloc=H.evaluate(W); thisWalker.resetProperty(log(abs(psi)), psi,eloc); H.saveProperty(thisWalker.getPropertyBase()); } else { ++nAllRejected; } ++it; } ++step;++CurrentStep; Estimators->accumulate(W); //if(CurrentStep%100 == 0) updateWalkers(); } while(step<nSteps); }
void VMCParticleByParticle::runBlockWithoutDrift() { IndexType step = 0; MCWalkerConfiguration::iterator it_end(W.end()); do { //advanceWalkerByWalker(); MCWalkerConfiguration::iterator it(W.begin()); while(it != it_end) { //MCWalkerConfiguration::WalkerData_t& w_buffer = *(W.DataSet[iwalker]); Walker_t& thisWalker(**it); Buffer_t& w_buffer(thisWalker.DataSet); W.R = thisWalker.R; w_buffer.rewind(); W.copyFromBuffer(w_buffer); Psi.copyFromBuffer(W,w_buffer); RealType psi_old = thisWalker.Properties(SIGN); RealType psi = psi_old; for(int iter=0; iter<nSubSteps; iter++) { makeGaussRandom(deltaR); bool stucked=true; for(int iat=0; iat<W.getTotalNum(); iat++) { PosType dr = m_sqrttau*deltaR[iat]; PosType newpos = W.makeMove(iat,dr); RealType ratio = Psi.ratio(W,iat); //RealType ratio = Psi.ratio(W,iat,dG,dL); RealType prob = std::min(1.0e0,ratio*ratio); //alternatively if(Random() < prob) { stucked=false; ++nAccept; W.acceptMove(iat); Psi.acceptMove(W,iat); //W.G+=dG; //W.L+=dL; } else { ++nReject; W.rejectMove(iat); Psi.rejectMove(iat); } } if(stucked) { ++nAllRejected; } } thisWalker.R = W.R; w_buffer.rewind(); W.updateBuffer(w_buffer); RealType logpsi = Psi.updateBuffer(W,w_buffer); //W.copyToBuffer(w_buffer); //RealType logpsi = Psi.evaluate(W,w_buffer); RealType eloc=H.evaluate(W); thisWalker.resetProperty(logpsi,Psi.getPhase(),eloc); H.saveProperty(thisWalker.getPropertyBase()); ++it; } ++step;++CurrentStep; Estimators->accumulate(W); } while(step<nSteps); }
bool DMCPeta::run() { resetUpdateEngine(); //estimator is ready to collect data Estimators->setCollectionMode(true); Estimators->start(nBlocks,true); Timer myclock; IndexType block = 0; IndexType numPtcls=W.getTotalNum(); RealType oneover2tau = 0.5/Tau; RealType sqrttau = std::sqrt(Tau); //temporary data to store differences ParticleSet::ParticlePos_t deltaR(numPtcls); ParticleSet::ParticleGradient_t G(numPtcls), dG(numPtcls); ParticleSet::ParticleLaplacian_t L(numPtcls), dL(numPtcls); CurrentStep = 0; typedef MCWalkerConfiguration::iterator WalkerIter_t; do // block { Mover->startBlock(nSteps); for(IndexType step=0; step< nSteps; step++, CurrentStep+=BranchInterval) { for(IndexType interval=0; interval<BranchInterval; ++interval) { for(WalkerIter_t it=W.begin();it != W.end(); ++it) { //MCWalkerConfiguration::WalkerData_t& w_buffer = *(W.DataSet[iwalker]); Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); W.R = thisWalker.R; w_buffer.rewind(); W.copyFromBuffer(w_buffer); Psi.copyFromBuffer(W,w_buffer); //create a 3N-Dimensional Gaussian with variance=1 makeGaussRandomWithEngine(deltaR,Random); int nAcceptTemp(0); int nRejectTemp(0); RealType eold(thisWalker.Properties(LOCALENERGY)); RealType enew(eold); RealType rr_proposed=0.0; RealType rr_accepted=0.0; //loop over particles for(int iat=0; iat<numPtcls; iat++) { PosType dr(sqrttau*deltaR[iat]+thisWalker.Drift[iat]); PosType newpos(W.makeMove(iat,dr)); RealType ratio=Psi.ratio(W,iat,dG,dL); RealType rr=dot(dr,dr); rr_proposed+=rr; if(branchEngine->phaseChanged(Psi.getPhaseDiff())) {//node crossing detected ++nRejectTemp; W.rejectMove(iat); Psi.rejectMove(iat); } else { G = W.G+dG; RealType logGf = -0.5*dot(deltaR[iat],deltaR[iat]); RealType scale=getDriftScale(Tau,G); dr = thisWalker.R[iat]-newpos-scale*real(G[iat]); RealType logGb = -oneover2tau*dot(dr,dr); RealType prob = std::min(1.0,ratio*ratio*std::exp(logGb-logGf)); if(Random() < prob) {//move is accepted ++nAcceptTemp; W.acceptMove(iat); Psi.acceptMove(W,iat); W.G = G; W.L += dL; assignDrift(scale,G,thisWalker.Drift); rr_accepted+=rr; } else { ++nRejectTemp; W.rejectMove(iat); Psi.rejectMove(iat); } } }//for(int iat=0; iat<NumPtcl; iat++) if(nAcceptTemp>0) {//need to overwrite the walker properties thisWalker.R = W.R; w_buffer.rewind(); W.copyToBuffer(w_buffer); //RealType psi = Psi.evaluate(W,w_buffer); RealType logpsi = Psi.evaluateLog(W,w_buffer); enew= H.evaluate(W); //thisWalker.resetProperty(std::log(abs(psi)),psi,enew,rr_accepted,rr_proposed,1.0); thisWalker.resetProperty(logpsi,Psi.getPhase(),enew,rr_accepted,rr_proposed,1.0 ); H.auxHevaluate(W,thisWalker); H.saveProperty(thisWalker.getPropertyBase()); } else { thisWalker.rejectedMove(); thisWalker.Age++; rr_accepted=0.0; enew=eold;//copy back old energy } thisWalker.Weight *= branchEngine->branchWeight(eold,enew); nAccept += nAcceptTemp; nReject += nRejectTemp; }//for(WalkerIter_t it=W.begin();it != W.end(); ++it) }//interval //calculate multiplicity based on the weights: see QMCUpdateBase::setMultiplicity Mover->setMultiplicity(W.begin(),W.end()); //time to branch: see SimpleFixedNodeBranch::branch branchEngine->branch(CurrentStep,W); if(storeConfigs && (CurrentStep%storeConfigs == 0)) { ForwardWalkingHistory.storeConfigsForForwardWalking(W); W.resetWalkerParents(); } }//steps ++block; Estimators->stopBlock(static_cast<RealType>(nAccept)/static_cast<RealType>(nAccept+nReject)); recordBlock(block); } while(block<nBlocks && myclock.elapsed()<MaxCPUSecs); Estimators->stop(); return finalize(block); }
void CSVMCUpdatePbyP::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure) { int iwalker=0; //only used locally vector<RealType> ratio(nPsi), uw(nPsi); while(it != it_end) { //Walkers loop Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); W.R = thisWalker.R; w_buffer.rewind(); // Copy walker info in W W.copyFromBuffer(w_buffer); for(int ipsi=0; ipsi<nPsi; ipsi++){ // Copy wave function info in W and Psi1 Psi1[ipsi]->copyFromBuffer(W,w_buffer); Psi1[ipsi]->G=W.G; Psi1[ipsi]->L=W.L; } makeGaussRandomWithEngine(deltaR,RandomGen); for(int ipsi=0; ipsi<nPsi; ipsi++) { uw[ipsi]= thisWalker.Properties(ipsi,UMBRELLAWEIGHT); } // Point to the correct walker in the ratioij buffer RealType* restrict ratioijPtr=ratioIJ[iwalker]; bool moved = false; for(int iat=0; iat<W.getTotalNum(); iat++) { //Particles loop PosType dr = m_sqrttau*deltaR[iat]; PosType newpos = W.makeMove(iat,dr); RealType ratio_check=1.0; for(int ipsi=0; ipsi<nPsi; ipsi++) { // Compute ratios before and after the move ratio_check *= ratio[ipsi] = Psi1[ipsi]->ratio(W,iat,*G1[ipsi],*L1[ipsi]); logpsi[ipsi]=std::log(ratio[ipsi]*ratio[ipsi]); // Compute Gradient in new position //*G1[ipsi]=Psi1[ipsi]->G + dG; // Initialize: sumratio[i]=(Psi[i]/Psi[i])^2=1.0 sumratio[ipsi]=1.0; } bool accept_move=false; if(ratio_check>1e-12)//if any ratio is too small, reject the move automatically { int indexij(0); // Compute new (Psi[i]/Psi[j])^2 and their sum for(int ipsi=0; ipsi< nPsi-1; ipsi++) { for(int jpsi=ipsi+1; jpsi < nPsi; jpsi++, indexij++) { // Ratio between norms is already included in ratioijPtr from initialize. RealType rji=std::exp(logpsi[jpsi]-logpsi[ipsi])*ratioijPtr[indexij]; instRij[indexij]=rji; //ratioij[indexij]=rji; sumratio[ipsi] += rji; sumratio[jpsi] += 1.0/rji; } } // Evaluate new Umbrella Weight for(int ipsi=0; ipsi< nPsi ;ipsi++) invsumratio[ipsi]=1.0/sumratio[ipsi]; RealType td=ratio[0]*ratio[0]*sumratio[0]/(*it)->Multiplicity; accept_move=Random()<std::min(1.0,td); } //RealType prob = std::min(1.0,td); //if(Random() < prob) if(accept_move) { /* Electron move is accepted. Update: -ratio (Psi[i]/Psi[j])^2 for this walker -Gradient and laplacian for each Psi1[i] -Drift -buffered info for each Psi1[i]*/ moved = true; ++nAccept; W.acceptMove(iat); // Update Buffer for (Psi[i]/Psi[j])^2 std::copy(instRij.begin(),instRij.end(),ratioijPtr); // copy new Umbrella weight for averages uw=invsumratio; // Store sumratio for next Accept/Reject step to Multiplicity //thisWalker.Properties(SUMRATIO)=sumratio[0]; thisWalker.Multiplicity=sumratio[0]; for(int ipsi=0; ipsi< nPsi; ipsi++) { //Update local Psi1[i] buffer for the next move Psi1[ipsi]->acceptMove(W,iat); //Update G and L in Psi1[i] //Psi1[ipsi]->G = *G1[ipsi]; Psi1[ipsi]->G += *G1[ipsi]; Psi1[ipsi]->L += *L1[ipsi]; thisWalker.Properties(ipsi,LOGPSI)+=std::log(abs(ratio[ipsi])); } } else { ++nReject; W.rejectMove(iat); for(int ipsi=0; ipsi< nPsi; ipsi++) Psi1[ipsi]->rejectMove(iat); } } if(moved) { /* The walker moved: Info are copied back to buffers: -copy (Psi[i]/Psi[j])^2 to ratioijBuffer -Gradient and laplacian for each Psi1[i] -Drift -buffered info for each Psi1[i] Physical properties are updated */ (*it)->Age=0; (*it)->R = W.R; w_buffer.rewind(); W.copyToBuffer(w_buffer); for(int ipsi=0; ipsi< nPsi; ipsi++){ W.G=Psi1[ipsi]->G; W.L=Psi1[ipsi]->L; //ValueType psi = Psi1[ipsi]->evaluate(W,w_buffer); ValueType logpsi = Psi1[ipsi]->evaluateLog(W,w_buffer); RealType et = H1[ipsi]->evaluate(W); //multiEstimator->updateSample(iwalker,ipsi,et,UmbrellaWeight[ipsi]); //Properties is used for UmbrellaWeight and UmbrellaEnergy thisWalker.Properties(ipsi,UMBRELLAWEIGHT)=uw[ipsi]; thisWalker.Properties(ipsi,LOCALENERGY)=et; H1[ipsi]->saveProperty(thisWalker.getPropertyBase(ipsi)); } } else { ++nAllRejected; } ++it; ++iwalker; } }
void VMCUpdatePbyPWithDrift::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end) { while(it != it_end) { Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); W.R = thisWalker.R; w_buffer.rewind(); W.copyFromBuffer(w_buffer); Psi.copyFromBuffer(W,w_buffer); RealType psi_old = thisWalker.Properties(SIGN); RealType psi = psi_old; //create a 3N-Dimensional Gaussian with variance=1 makeGaussRandomWithEngine(deltaR,RandomGen); bool moved = false; for(int iat=0; iat<W.getTotalNum(); iat++) { PosType dr = m_sqrttau*deltaR[iat]+thisWalker.Drift[iat]; PosType newpos = W.makeMove(iat,dr); //RealType ratio = Psi.ratio(W,iat); RealType ratio = Psi.ratio(W,iat,dG,dL); G = W.G+dG; //RealType forwardGF = exp(-0.5*dot(deltaR[iat],deltaR[iat])); //dr = (*it)->R[iat]-newpos-Tau*G[iat]; //RealType backwardGF = exp(-oneover2tau*dot(dr,dr)); RealType logGf = -0.5e0*dot(deltaR[iat],deltaR[iat]); RealType scale=getDriftScale(Tau,G); //COMPLEX WARNING //dr = thisWalker.R[iat]-newpos-scale*G[iat]; dr = thisWalker.R[iat]-newpos-scale*real(G[iat]); RealType logGb = -m_oneover2tau*dot(dr,dr); RealType prob = std::min(1.0e0,ratio*ratio*exp(logGb-logGf)); //alternatively if(RandomGen() < prob) { moved = true; ++nAccept; W.acceptMove(iat); Psi.acceptMove(W,iat); W.G = G; W.L += dL; //thisWalker.Drift = scale*G; assignDrift(scale,G,thisWalker.Drift); } else { ++nReject; W.rejectMove(iat); Psi.rejectMove(iat); } } if(moved) { w_buffer.rewind(); W.copyToBuffer(w_buffer); psi = Psi.evaluate(W,w_buffer); thisWalker.R = W.R; RealType eloc=H.evaluate(W); thisWalker.resetProperty(log(abs(psi)), psi,eloc); H.saveProperty(thisWalker.getPropertyBase()); } else { ++nAllRejected; } ++it; } }
bool DMCOMPOPT::run() { bool variablePop = (Reconfiguration == "no"); resetUpdateEngines(); //estimator does not need to collect data Estimators->setCollectionMode(true); Estimators->start(nBlocks); for(int ip=0; ip<NumThreads; ip++) Movers[ip]->startRun(nBlocks,false); Timer myclock; IndexType block = 0; IndexType updatePeriod=(QMCDriverMode[QMC_UPDATE_MODE])?Period4CheckProperties:(nBlocks+1)*nSteps; int nsampls(0); int g_nsampls(0); do // block { Estimators->startBlock(nSteps); for(int ip=0; ip<NumThreads; ip++) Movers[ip]->startBlock(nSteps); IndexType step = 0; for(IndexType step=0; step< nSteps; ++step, CurrentStep+=BranchInterval) { #pragma omp parallel { int ip=omp_get_thread_num(); int now=CurrentStep; MCWalkerConfiguration::iterator wit(W.begin()+wPerNode[ip]), wit_first(W.begin()+wPerNode[ip]), wit2(W.begin()+wPerNode[ip]), wit_end(W.begin()+wPerNode[ip+1]); for(int interval = 0; interval<BranchInterval-1; ++interval,++now) { Movers[ip]->advanceWalkers(wit,wit_end,false); while(wit2!=wit_end) { (**wit2).addPropertyHistoryPoint(Eindx,(**wit2).getPropertyBase()[LOCALENERGY]); wit2++; } wit2=wit_first; if (Period4WalkerDump&&((now+1)%myPeriod4WalkerDump==0)) { wClones[ip]->saveEnsemble(wit2,wit_end); #pragma omp master nsampls+=W.getActiveWalkers(); } } wClones[ip]->resetCollectables(); Movers[ip]->advanceWalkers(wit,wit_end,false); wit2=wit_first; while(wit2!=wit_end) { (**wit2).addPropertyHistoryPoint(Eindx,(**wit2).getPropertyBase()[LOCALENERGY]); wit2++; } wit2=wit_first; if (myPeriod4WalkerDump&&((now+1)%myPeriod4WalkerDump==0)) { wClones[ip]->saveEnsemble(wit2,wit_end); #pragma omp master nsampls+=W.getActiveWalkers(); } Movers[ip]->setMultiplicity(wit,wit_end); if(QMCDriverMode[QMC_UPDATE_MODE] && now%updatePeriod == 0) Movers[ip]->updateWalkers(wit, wit_end); }//#pragma omp parallel } // branchEngine->debugFWconfig(); #pragma omp parallel for for (int ip=0; ip<NumThreads; ++ip) { MCWalkerConfiguration::iterator wit(W.begin()+wPerNode[ip]), wit_end(W.begin()+wPerNode[ip+1]); while (wit!=wit_end) { Walker_t& thisWalker(**wit); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); wClones[ip]->loadWalker(thisWalker,true); psiClones[ip]->copyFromBuffer(*wClones[ip],w_buffer); vector<RealType> Dsaved(NumOptimizables,0); vector<RealType> HDsaved(NumOptimizables,0); psiClones[ip]->evaluateDerivatives(*wClones[ip],dummyOptVars[ip],Dsaved,HDsaved,true);//SH like deriv style #pragma omp critical fillComponentMatrices(Dsaved,HDsaved,thisWalker); wit++; } } branchEngine->branch(CurrentStep,W, branchClones); if(variablePop) FairDivideLow(W.getActiveWalkers(),NumThreads,wPerNode); Estimators->stopBlock(acceptRatio()); block++; recordBlock(block); g_nsampls=nsampls; myComm->allreduce(g_nsampls); } while(((block<nBlocks) || (g_nsampls<nTargetSamples)) && myclock.elapsed()<MaxCPUSecs); //for(int ip=0; ip<NumThreads; ip++) Movers[ip]->stopRun(); for(int ip=0; ip<NumThreads; ip++) *(RandomNumberControl::Children[ip])=*(Rng[ip]); // adding weight index MCWalkerConfiguration::iterator wit(W.begin()), wit_end(W.end()); while(wit!=wit_end) { (**wit).deletePropertyHistory(); wit++; } Estimators->stop(); return finalize(block); }
void VMCParticleByParticle::advanceWalkerByWalker() { MCWalkerConfiguration::iterator it(W.begin()),it_end(W.end()); while(it != it_end) { //MCWalkerConfiguration::WalkerData_t& w_buffer = *(W.DataSet[iwalker]); Walker_t& thisWalker(**it); Buffer_t& w_buffer(thisWalker.DataSet); W.R = thisWalker.R; w_buffer.rewind(); W.copyFromBuffer(w_buffer); Psi.copyFromBuffer(W,w_buffer); ValueType psi_old = thisWalker.Properties(SIGN); ValueType psi = psi_old; //create a 3N-Dimensional Gaussian with variance=1 makeGaussRandom(deltaR); bool moved = false; for(int iat=0; iat<W.getTotalNum(); iat++) { PosType dr = m_sqrttau*deltaR[iat]+thisWalker.Drift[iat]; PosType newpos = W.makeMove(iat,dr); //RealType ratio = Psi.ratio(W,iat); RealType ratio = Psi.ratio(W,iat,dG,dL); G = W.G+dG; //RealType forwardGF = exp(-0.5*dot(deltaR[iat],deltaR[iat])); //dr = (*it)->R[iat]-newpos-Tau*G[iat]; //RealType backwardGF = exp(-oneover2tau*dot(dr,dr)); RealType logGf = -0.5e0*dot(deltaR[iat],deltaR[iat]); ValueType vsq = Dot(G,G); ValueType scale = ((-1.0e0+sqrt(1.0e0+2.0e0*Tau*vsq))/vsq); dr = thisWalker.R[iat]-newpos-scale*G[iat]; //dr = (*it)->R[iat]-newpos-Tau*G[iat]; RealType logGb = -m_oneover2tau*dot(dr,dr); RealType prob = std::min(1.0e0,ratio*ratio*exp(logGb-logGf)); //alternatively if(Random() < prob) { moved = true; ++nAccept; W.acceptMove(iat); //Psi.update(W,iat); Psi.update2(W,iat); W.G = G; W.L += dL; //(*it)->Drift = Tau*G; thisWalker.Drift = scale*G; } else { ++nReject; Psi.restore(iat); } } if(moved) { w_buffer.rewind(); W.copyToBuffer(w_buffer); psi = Psi.evaluate(W,w_buffer); thisWalker.R = W.R; RealType eloc=H.evaluate(W); thisWalker.resetProperty(log(abs(psi)),psi,eloc); H.saveProperty(thisWalker.getPropertyBase()); } //Keep until everything is tested: debug routine // if(moved) { // //(*it)->Data.rewind(); // //W.copyToBuffer((*it)->Data); // //psi = Psi.evaluate(W,(*it)->Data); // DataSet[iwalker]->rewind(); // W.copyToBuffer(*DataSet[iwalker]); // psi = Psi.evaluate(W,*DataSet[iwalker]); // cout << "What is the ratio " << psi/psi_old << endl; // // std::cout << "Are they the same ratio=" << psi << endl; // RealType please = H.evaluate(W); // /**@note Debug the particle-by-particle move */ // G = W.G; // L = W.L; // DistanceTable::update(W); // ValueType psinew = Psi.evaluate(W); // ValueType dsum=pow(psi-psinew,2); // std::cout<< "Diff of updated and calculated gradients/laplacians" << endl; // for(int iat=0; iat<W.getTotalNum(); iat++) { // dsum += pow(G[iat][0]-W.G[iat][0],2)+pow(G[iat][1]-W.G[iat][1],2) // +pow(G[iat][2]-W.G[iat][2],2)+pow(L[iat]-W.L[iat],2); // std::cout << G[iat]-W.G[iat] << " " << L[iat]-W.L[iat] <<endl; // } // std::cout << "Are they the same ratio=" << psi << " eval=" << psinew << " " << sqrt(dsum) << endl; // std::cout << "============================ " << endl; // for(int i=0; i<W.getLocalNum(); i++) { // cout << W.G[i] << " " << W.L[i] << endl; // } // (*it)->Properties(PSISQ) = psi*psi; // (*it)->Properties(PSI) = psi; // (*it)->Properties(LOCALENERGY) = H.evaluate(W); // std::cout << "Energy " << please << " " << (*it)->Properties(LOCALENERGY) // << endl; // H.copy((*it)->getEnergyBase()); // ValueType vsq = Dot(W.G,W.G); // ValueType scale = ((-1.0+sqrt(1.0+2.0*Tau*vsq))/vsq); // (*it)->Drift = scale*W.G; // (*it)->R =W.R; // } else { ++nAllRejected; } ++it; } }
bool VMCPbyPMultiple::run() { useDrift = (useDriftOpt=="yes"); if(useDrift) app_log() << " VMCPbyPMultiple::run useDrift=yes" << endl; else app_log() << " VMCPbyPMultiple::run useDrift=no" << endl; //TEST CACHE //Estimators->reportHeader(AppendRun); //going to add routines to calculate how much we need bool require_register = W.createAuxDataSet(); vector<RealType>Norm(nPsi),tmpNorm(nPsi); if(equilBlocks > 0) { for(int ipsi=0; ipsi< nPsi; ipsi++) { Norm[ipsi]=1.0; tmpNorm[ipsi]=0.0; } } else { for(int ipsi=0; ipsi< nPsi; ipsi++) Norm[ipsi]=std::exp(branchEngine->LogNorm[ipsi]); } multiEstimator->initialize(W,H1,Psi1,Tau,Norm,require_register); //TEST CACHE //Estimators->reset(); Estimators->start(nBlocks); //TEST CACHE IndexType block = 0; m_oneover2tau = 0.5/Tau; m_sqrttau = std::sqrt(Tau); RealType nPsi_minus_one = nPsi-1; ParticleSet::ParticleGradient_t dG(W.getTotalNum()); IndexType nAcceptTot = 0; IndexType nRejectTot = 0; MCWalkerConfiguration::iterator it; MCWalkerConfiguration::iterator it_end(W.end()); do //Blocks loop { IndexType step = 0; nAccept = 0; nReject=0; IndexType nAllRejected = 0; Estimators->startBlock(nSteps); do //Steps loop { it = W.begin(); int iwalker=0; while(it != it_end) //Walkers loop { Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); W.R = thisWalker.R; w_buffer.rewind(); // Copy walker info in W W.copyFromBuffer(w_buffer); for(int ipsi=0; ipsi<nPsi; ipsi++) { // Copy wave function info in W and Psi1 Psi1[ipsi]->copyFromBuffer(W,w_buffer); Psi1[ipsi]->G=W.G; Psi1[ipsi]->L=W.L; } // Point to the correct walker in the ratioij buffer RealType *ratioijPtr=multiEstimator->RatioIJ[iwalker]; //This is not used //ValueType psi_old = thisWalker.Properties(SIGN); //ValueType psi = psi_old; //create a 3N-Dimensional Gaussian with variance=1 makeGaussRandom(deltaR); bool moved = false; for(int iat=0; iat<W.getTotalNum(); iat++) //Particles loop { PosType dr = m_sqrttau*deltaR[iat]; if(useDrift) dr += thisWalker.Drift[iat]; PosType newpos = W.makeMove(iat,dr); for(int ipsi=0; ipsi<nPsi; ipsi++) { // Compute ratios before and after the move ratio[ipsi] = Psi1[ipsi]->ratio(W,iat,dG,*dL[ipsi]); logpsi2[ipsi]=std::log(ratio[ipsi]*ratio[ipsi]); // Compute Gradient in new position *G[ipsi]=Psi1[ipsi]->G + dG; // Initialize: sumratio[i]=(Psi[i]/Psi[i])^2=1.0 sumratio[ipsi]=1.0; } // Compute new (Psi[i]/Psi[j])^2 and their sum int indexij(0); for(int ipsi=0; ipsi< nPsi_minus_one; ipsi++) { for(int jpsi=ipsi+1; jpsi < nPsi; jpsi++, indexij++) { // Ratio between norms is already included in ratioijPtr from initialize. RealType rji=std::exp(logpsi2[jpsi]-logpsi2[ipsi])*ratioijPtr[indexij]; ratioij[indexij]=rji; sumratio[ipsi] += rji; sumratio[jpsi] += 1.0/rji; } } // Evaluate new Umbrella Weight for(int ipsi=0; ipsi< nPsi ; ipsi++) { invsumratio[ipsi]=1.0/sumratio[ipsi]; } RealType td=ratio[0]*ratio[0]*sumratio[0]/(*it)->Multiplicity; if(useDrift) { // Evaluate new drift PAOps<RealType,DIM>::scale(invsumratio[0],Psi1[0]->G,drift); for(int ipsi=1; ipsi< nPsi ; ipsi++) { PAOps<RealType,DIM>::axpy(invsumratio[ipsi],Psi1[ipsi]->G,drift); } setScaledDrift(Tau,drift); RealType logGf = -0.5*dot(deltaR[iat],deltaR[iat]); dr = thisWalker.R[iat]-newpos-drift[iat]; RealType logGb = -m_oneover2tau*dot(dr,dr); td *=std::exp(logGb-logGf); } // td = Target Density ratio //RealType td=pow(ratio[0],2)*sumratio[0]/(*it)->Properties(SUMRATIO); //td=ratio[0]*ratio[0]*sumratio[0]/(*it)->Multiplicity; //RealType prob = std::min(1.0,td*exp(logGb-logGf)); RealType prob = std::min(1.0,td); if(Random() < prob) { /* Electron move is accepted. Update: -ratio (Psi[i]/Psi[j])^2 for this walker -Gradient and laplacian for each Psi1[i] -Drift -buffered info for each Psi1[i]*/ moved = true; ++nAccept; W.acceptMove(iat); // Update Buffer for (Psi[i]/Psi[j])^2 std::copy(ratioij.begin(),ratioij.end(),ratioijPtr); // Update Umbrella weight UmbrellaWeight=invsumratio; // Store sumratio for next Accept/Reject step to Multiplicity //thisWalker.Properties(SUMRATIO)=sumratio[0]; thisWalker.Multiplicity=sumratio[0]; for(int ipsi=0; ipsi< nPsi; ipsi++) { //Update local Psi1[i] buffer for the next move Psi1[ipsi]->acceptMove(W,iat); //Update G and L in Psi1[i] Psi1[ipsi]->G = *G[ipsi]; Psi1[ipsi]->L += *dL[ipsi]; thisWalker.Properties(ipsi,LOGPSI)+=std::log(abs(ratio[ipsi])); } // Update Drift if(useDrift) (*it)->Drift = drift; } else { ++nReject; W.rejectMove(iat); for(int ipsi=0; ipsi< nPsi; ipsi++) Psi1[ipsi]->rejectMove(iat); } } if(moved) { /* The walker moved: Info are copied back to buffers: -copy (Psi[i]/Psi[j])^2 to ratioijBuffer -Gradient and laplacian for each Psi1[i] -Drift -buffered info for each Psi1[i] Physical properties are updated */ (*it)->Age=0; (*it)->R = W.R; w_buffer.rewind(); W.copyToBuffer(w_buffer); for(int ipsi=0; ipsi< nPsi; ipsi++) { W.G=Psi1[ipsi]->G; W.L=Psi1[ipsi]->L; ValueType psi = Psi1[ipsi]->evaluate(W,w_buffer); RealType et = H1[ipsi]->evaluate(W); //multiEstimator->updateSample(iwalker,ipsi,et,UmbrellaWeight[ipsi]); //Properties is used for UmbrellaWeight and UmbrellaEnergy thisWalker.Properties(ipsi,UMBRELLAWEIGHT)=UmbrellaWeight[ipsi]; thisWalker.Properties(ipsi,LOCALENERGY)=et; H1[ipsi]->auxHevaluate(W); H1[ipsi]->saveProperty(thisWalker.getPropertyBase(ipsi)); } } else { ++nAllRejected; } ++it; ++iwalker; } ++step; ++CurrentStep; Estimators->accumulate(W); } while(step<nSteps); //Modify Norm. if(block < equilBlocks) { for(int ipsi=0; ipsi< nPsi; ipsi++) { tmpNorm[ipsi]+=multiEstimator->esum(ipsi,MultipleEnergyEstimator::WEIGHT_INDEX); } if(block==(equilBlocks-1) || block==(nBlocks-1)) { RealType SumNorm(0.e0); for(int ipsi=0; ipsi< nPsi; ipsi++) SumNorm+=tmpNorm[ipsi]; for(int ipsi=0; ipsi< nPsi; ipsi++) { Norm[ipsi]=tmpNorm[ipsi]/SumNorm; branchEngine->LogNorm[ipsi]=std::log(Norm[ipsi]); } } } Estimators->stopBlock(static_cast<RealType>(nAccept)/static_cast<RealType>(nAccept+nReject)); nAcceptTot += nAccept; nRejectTot += nReject; nAccept = 0; nReject = 0; ++block; //record the current configuration recordBlock(block); //re-evaluate the ratio and update the Norm multiEstimator->initialize(W,H1,Psi1,Tau,Norm,false); } while(block<nBlocks); ////Need MPI-IO //app_log() // << "Ratio = " // << static_cast<RealType>(nAcceptTot)/static_cast<RealType>(nAcceptTot+nRejectTot) // << endl; return finalize(block); }
/** advance all the walkers with killnode==no * @param nat number of particles to move * * When killnode==no, any move resulting in node-crossing is treated * as a normal rejection. */ void DMCNonLocalUpdatePbyP::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure) { for(; it!=it_end; ++it) { Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); RealType eold(thisWalker.Properties(LOCALENERGY)); RealType vqold(thisWalker.Properties(DRIFTSCALE)); //RealType emixed(eold), enew(eold); RealType enew(eold); W.R = thisWalker.R; w_buffer.rewind(); W.copyFromBuffer(w_buffer); Psi.copyFromBuffer(W,w_buffer); //create a 3N-Dimensional Gaussian with variance=1 makeGaussRandom(deltaR); bool notcrossed(true); int nAcceptTemp(0); int nRejectTemp(0); RealType rr_proposed=0.0; RealType rr_accepted=0.0; for(int iat=0; iat<NumPtcl; ++iat) { //PosType dr(m_sqrttau*deltaR[iat]+thisWalker.Drift[iat]); RealType sc=getDriftScale(Tau,W.G[iat]); PosType dr(m_sqrttau*deltaR[iat]+sc*real(W.G[iat])); //RealType rr=dot(dr,dr); RealType rr=Tau*dot(deltaR[iat],deltaR[iat]); rr_proposed+=rr; if(rr>m_r2max)//too big move { ++nRejectTemp; continue; } PosType newpos(W.makeMove(iat,dr)); RealType ratio=Psi.ratio(W,iat,dG,dL); //node is crossed reject the move if(Psi.getPhase() > numeric_limits<RealType>::epsilon()) { ++nRejectTemp; ++nNodeCrossing; W.rejectMove(iat); Psi.rejectMove(iat); } else { G = W.G+dG; RealType logGf = -0.5*dot(deltaR[iat],deltaR[iat]); //RealType scale=getDriftScale(Tau,G); RealType scale=getDriftScale(Tau,G[iat]); dr = thisWalker.R[iat]-newpos-scale*real(G[iat]); RealType logGb = -m_oneover2tau*dot(dr,dr); RealType prob = std::min(1.0,ratio*ratio*std::exp(logGb-logGf)); if(RandomGen() < prob) { ++nAcceptTemp; W.acceptMove(iat); Psi.acceptMove(W,iat); W.G = G; W.L += dL; //assignDrift(scale,G,thisWalker.Drift); rr_accepted+=rr; } else { ++nRejectTemp; W.rejectMove(iat); Psi.rejectMove(iat); } } }//end of drift+diffusion for all the particles of a walker nonLocalOps.reset(); if(nAcceptTemp>0) {//need to overwrite the walker properties thisWalker.R = W.R; w_buffer.rewind(); W.copyToBuffer(w_buffer); RealType psi = Psi.evaluate(W,w_buffer); enew= H.evaluate(W,nonLocalOps.Txy); thisWalker.resetProperty(std::log(abs(psi)),psi,enew,rr_accepted,rr_proposed,1.0); H.saveProperty(thisWalker.getPropertyBase()); thisWalker.Drift=W.G; } else { thisWalker.Age++; thisWalker.Properties(R2ACCEPTED)=0.0; ++nAllRejected; enew=eold;//copy back old energy } int ibar = nonLocalOps.selectMove(RandomGen()); //make a non-local move if(ibar) { int iat=nonLocalOps.id(ibar); PosType newpos(W.makeMove(iat, nonLocalOps.delta(ibar))); RealType ratio=Psi.ratio(W,iat,dG,dL); W.acceptMove(iat); Psi.acceptMove(W,iat); W.G += dG; W.L += dL; PAOps<RealType,OHMMS_DIM>::copy(W.G,thisWalker.Drift); thisWalker.R[iat]=W.R[iat]; w_buffer.rewind(); W.copyToBuffer(w_buffer); RealType psi = Psi.evaluate(W,w_buffer); ++NonLocalMoveAccepted; } thisWalker.Weight *= branchEngine->branchWeight(eold,enew); nAccept += nAcceptTemp; nReject += nRejectTemp; } }
/** advance all the walkers with killnode==no * @param nat number of particles to move * * When killnode==no, any move resulting in node-crossing is treated * as a normal rejection. */ void DMCUpdatePbyPWithRejection::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure) { myTimers[0]->start(); for(;it != it_end;++it) { //MCWalkerConfiguration::WalkerData_t& w_buffer = *(W.DataSet[iwalker]); Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); W.loadWalker(thisWalker,true); //W.R = thisWalker.R; //w_buffer.rewind(); //W.copyFromBuffer(w_buffer); Psi.copyFromBuffer(W,w_buffer); //create a 3N-Dimensional Gaussian with variance=1 makeGaussRandomWithEngine(deltaR,RandomGen); int nAcceptTemp(0); int nRejectTemp(0); //copy the old energy and scale factor of drift RealType eold(thisWalker.Properties(LOCALENERGY)); RealType vqold(thisWalker.Properties(DRIFTSCALE)); RealType enew(eold); RealType rr_proposed=0.0; RealType rr_accepted=0.0; RealType gf_acc=1.0; myTimers[1]->start(); for(int iat=0; iat<NumPtcl; ++iat) { PosType dr; //get the displacement //RealType sc=getDriftScale(m_tauovermass,W.G[iat]); //PosType dr(m_sqrttau*deltaR[iat]+sc*real(W.G[iat])); getScaledDrift(m_tauovermass,W.G[iat],dr); dr += m_sqrttau*deltaR[iat]; //RealType rr=dot(dr,dr); RealType rr=m_tauovermass*dot(deltaR[iat],deltaR[iat]); rr_proposed+=rr; if(rr>m_r2max) { ++nRejectTemp; continue; } //PosType newpos(W.makeMove(iat,dr)); if(!W.makeMoveAndCheck(iat,dr)) continue; PosType newpos(W.R[iat]); RealType ratio=Psi.ratio(W,iat,dG,dL); bool valid_move=false; //node is crossed reject the move //if(Psi.getPhase() > numeric_limits<RealType>::epsilon()) if(branchEngine->phaseChanged(Psi.getPhaseDiff())) { ++nRejectTemp; ++nNodeCrossing; W.rejectMove(iat); Psi.rejectMove(iat); } else { G = W.G+dG; RealType logGf = -0.5*dot(deltaR[iat],deltaR[iat]); //Use the force of the particle iat //RealType scale=getDriftScale(m_tauovermass,G[iat]); //dr = thisWalker.R[iat]-newpos-scale*real(G[iat]); getScaledDrift(m_tauovermass, G[iat], dr); dr = thisWalker.R[iat] - newpos - dr; RealType logGb = -m_oneover2tau*dot(dr,dr); RealType prob = ratio*ratio*std::exp(logGb-logGf); //this is useless //RealType prob = std::min(1.0,ratio*ratio*std::exp(logGb-logGf)); if(RandomGen() < prob) { valid_move=true; ++nAcceptTemp; W.acceptMove(iat); Psi.acceptMove(W,iat); W.G = G; W.L += dL; rr_accepted+=rr; gf_acc *=prob;//accumulate the ratio } else { ++nRejectTemp; W.rejectMove(iat); Psi.rejectMove(iat); } } } myTimers[1]->stop(); RealType nodecorr_old=thisWalker.Properties(DRIFTSCALE); RealType nodecorr=nodecorr_old; bool advanced=true; if(UseTMove) nonLocalOps.reset(); if(nAcceptTemp>0) {//need to overwrite the walker properties myTimers[2]->start(); thisWalker.Age=0; thisWalker.R = W.R; nodecorr=getNodeCorrection(W.G,drift); //w_buffer.rewind(); //W.copyToBuffer(w_buffer); RealType logpsi = Psi.evaluateLog(W,w_buffer); W.saveWalker(thisWalker); myTimers[2]->stop(); myTimers[3]->start(); if(UseTMove) enew= H.evaluate(W,nonLocalOps.Txy); else enew= H.evaluate(W); myTimers[3]->stop(); //thisWalker.resetProperty(std::log(abs(psi)),psi,enew,rr_accepted,rr_proposed,nodecorr); thisWalker.resetProperty(logpsi,Psi.getPhase(),enew,rr_accepted,rr_proposed,nodecorr ); H.auxHevaluate(W,thisWalker); H.saveProperty(thisWalker.getPropertyBase()); } else {//all moves are rejected: does not happen normally with reasonable wavefunctions advanced=false; H.rejectedMove(W,thisWalker); thisWalker.Age++; thisWalker.Properties(R2ACCEPTED)=0.0; ++nAllRejected; enew=eold;//copy back old energy gf_acc=1.0; } if(UseTMove) { //make a non-local move int ibar=nonLocalOps.selectMove(RandomGen()); if(ibar) { myTimers[2]->start(); int iat=nonLocalOps.id(ibar); PosType newpos(W.makeMove(iat, nonLocalOps.delta(ibar))); RealType ratio=Psi.ratio(W,iat,dG,dL); W.acceptMove(iat); Psi.acceptMove(W,iat); W.G += dG; W.L += dL; //PAOps<RealType,OHMMS_DIM>::copy(W.G,thisWalker.Drift); //thisWalker.R[iat]=W.R[iat]; //w_buffer.rewind(); //W.copyToBuffer(w_buffer); RealType logpsi = Psi.evaluateLog(W,w_buffer); W.saveWalker(thisWalker); ++NonLocalMoveAccepted; myTimers[2]->stop(); } } //2008-06-26: select any //bare green function by setting nodecorr=nodecorr_old=1.0 thisWalker.Weight *= branchEngine->branchWeight(enew,eold); //Filtering extreme energies //thisWalker.Weight *= branchEngine->branchWeight(eold,enew); //using the corrections: see QMCUpdateBase::getNodeCorrection //thisWalker.Weight *= branchEngine->branchWeight(enew,eold,nodecorr,nodecorr_old); //using the corrections: see QMCUpdateBase::getNodeCorrection including gf_acc //RealType odd=std::min(gf_acc,1.0) //thisWalker.Weight *= branchEngine->branchWeight(enew,eold,nodecorr,nodecorr_oldi,odd); nAccept += nAcceptTemp; nReject += nRejectTemp; } myTimers[0]->stop(); }
void VMCUpdateRenyiWithDriftFast::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure) { myTimers[0]->start(); WalkerIter_t begin(it); for (; it != it_end; ++it) { Walker_t& thisWalker(**it); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); W.loadWalker(thisWalker,true); Psi.copyFromBuffer(W,w_buffer); myTimers[1]->start(); bool moved = false; for (int iter=0; iter<nSubSteps; ++iter) { //create a 3N-Dimensional Gaussian with variance=1 makeGaussRandomWithEngine(deltaR,RandomGen); moved = false; for(int ig=0; ig<W.groups(); ++ig) //loop over species { RealType tauovermass = Tau*MassInvS[ig]; RealType oneover2tau = 0.5/(tauovermass); RealType sqrttau = std::sqrt(tauovermass); for (int iat=W.first(ig); iat<W.last(ig); ++iat) { GradType grad_now=Psi.evalGrad(W,iat), grad_new; PosType dr; getScaledDrift(tauovermass,grad_now,dr); dr += sqrttau*deltaR[iat]; if (!W.makeMoveAndCheck(iat,dr)) { ++nReject; continue; } //PosType newpos = W.makeMove(iat,dr); RealType ratio = Psi.ratioGrad(W,iat,grad_new); RealType prob = ratio*ratio; //zero is always rejected if (prob<numeric_limits<RealType>::epsilon()) { ++nReject; W.rejectMove(iat); Psi.rejectMove(iat); continue; } RealType logGf = -0.5e0*dot(deltaR[iat],deltaR[iat]); getScaledDrift(tauovermass,grad_new,dr); dr = thisWalker.R[iat]-W.R[iat]-dr; RealType logGb = -oneover2tau*dot(dr,dr); if (RandomGen() < prob*std::exp(logGb-logGf)) { moved = true; ++nAccept; W.acceptMove(iat); Psi.acceptMove(W,iat); } else { ++nReject; W.rejectMove(iat); Psi.rejectMove(iat); } } } //for subSteps must update thiswalker thisWalker.R=W.R; thisWalker.G=W.G; thisWalker.L=W.L; } myTimers[1]->stop(); //Always compute the energy //if(moved) { myTimers[2]->start(); //thisWalker.R = W.R; //w_buffer.rewind(); //W.updateBuffer(w_buffer); RealType logpsi = Psi.updateBuffer(W,w_buffer,false); W.saveWalker(thisWalker); myTimers[2]->stop(); myTimers[3]->start(); RealType eloc=H.evaluate(W); myTimers[3]->stop(); //thisWalker.resetProperty(std::log(abs(psi)), psi,eloc); thisWalker.resetProperty(logpsi,Psi.getPhase(), eloc); H.auxHevaluate(W,thisWalker); H.saveProperty(thisWalker.getPropertyBase()); } if(!moved) ++nAllRejected; //else //{ // ++nAllRejected; // H.rejectedMove(W,thisWalker); //} } myTimers[0]->stop(); }
void VMCUpdatePbyP::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end, bool measure) { myTimers[0]->start(); for (; it != it_end; ++it) { Walker_t& thisWalker(**it); W.loadWalker(thisWalker,true); Walker_t::Buffer_t& w_buffer(thisWalker.DataSet); Psi.copyFromBuffer(W,w_buffer); myTimers[1]->start(); for (int iter=0; iter<nSubSteps; ++iter) { makeGaussRandomWithEngine(deltaR,RandomGen); bool stucked=true; for(int ig=0; ig<W.groups(); ++ig) //loop over species { RealType sqrttau = std::sqrt(Tau*MassInvS[ig]); for (int iat=W.first(ig); iat<W.last(ig); ++iat) { PosType dr = sqrttau*deltaR[iat]; //replace makeMove by makeMoveAndCheck //PosType newpos = W.makeMove(iat,dr); if (W.makeMoveAndCheck(iat,dr)) { RealType ratio = Psi.ratio(W,iat); RealType prob = ratio*ratio; //RealType prob = std::min(1.0e0,ratio*ratio); if (RandomGen() < prob) { stucked=false; ++nAccept; W.acceptMove(iat); Psi.acceptMove(W,iat); } else { ++nReject; W.rejectMove(iat); Psi.rejectMove(iat); } } else //reject illegal moves ++nReject; } //iat }//ig for the species if (stucked) { ++nAllRejected; //H.rejectedMove(W,thisWalker); } thisWalker.R=W.R; } myTimers[1]->stop(); myTimers[2]->start(); //thisWalker.R = W.R; //PAOps<RealType,OHMMS_DIM>::copy(W.G,thisWalker.Drift); //w_buffer.rewind(); //W.updateBuffer(w_buffer); RealType logpsi = Psi.updateBuffer(W,w_buffer,false); W.saveWalker(thisWalker); //W.copyToBuffer(w_buffer); //RealType logpsi = Psi.evaluate(W,w_buffer); myTimers[2]->stop(); myTimers[3]->start(); RealType eloc=H.evaluate(W); myTimers[3]->stop(); thisWalker.resetProperty(logpsi,Psi.getPhase(),eloc); H.auxHevaluate(W,thisWalker); H.saveProperty(thisWalker.getPropertyBase()); } myTimers[0]->stop(); }