TrialWaveFunction::RealType TrialWaveFunction::registerData(ParticleSet& P, PooledData<RealType>& buf)
{
delta_G.resize(P.getTotalNum());
delta_L.resize(P.getTotalNum());
P.G = 0.0;
P.L = 0.0;
//save the current position
BufferCursor=buf.current();
ValueType logpsi(0.0);
PhaseValue=0.0;
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
for (; it!=it_end; ++it)
{
logpsi += (*it)->registerData(P,buf);
PhaseValue += (*it)->PhaseValue;
}
convert(logpsi,LogValue);
//LogValue=real(logpsi);
//append current gradients and laplacians to the buffer
NumPtcls = P.getTotalNum();
TotalDim = PosType::Size*NumPtcls;
buf.add(PhaseValue);
buf.add(LogValue);
buf.add(&(P.G[0][0]), &(P.G[0][0])+TotalDim);
buf.add(&(P.L[0]), &(P.L[P.getTotalNum()]));
return LogValue;
}
TrialWaveFunction::RealType
TrialWaveFunction::registerData(ParticleSet& P, PooledData<RealType>& buf) {
delta_G.resize(P.getTotalNum());
delta_L.resize(P.getTotalNum());
P.G = 0.0;
P.L = 0.0;
ValueType logpsi(0.0);
PhaseValue=0.0;
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
for(;it!=it_end; ++it)
{
logpsi += (*it)->registerData(P,buf);
PhaseValue += (*it)->PhaseValue;
}
LogValue=real(logpsi);
//append current gradients and laplacians to the buffer
NumPtcls = P.getTotalNum();
TotalDim = PosType::Size*NumPtcls;
buf.add(&(P.G[0][0]), &(P.G[0][0])+TotalDim);
buf.add(&(P.L[0]), &(P.L[P.getTotalNum()]));
return LogValue;
// cout << "Registering gradients and laplacians " << endl;
// for(int i=0; i<P.getLocalNum(); i++) {
// cout << P.G[i] << " " << P.L[i] << endl;
// }
}
TrialWaveFunction::RealType TrialWaveFunction::evaluateDeltaLog(ParticleSet& P, PooledData<RealType>& buf)
{
P.G = 0.0;
P.L = 0.0;
ValueType logpsi(0.0);
PhaseValue=0.0;
buf.rewind();
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
for (; it!=it_end; ++it)
{
// mmorales: I don't remember if I did this, but eliminating the "if ((*it)->Optimizable)"
// forces everything to be evaluated. This was probably done because for optm with the
// nonlocal component in the cost function, the slater determinant might not be optimizable
// but this must be called anyway to load the inverse. CHECK CHECK CHECK, FIX FIX FIX
if ((*it)->Optimizable)
{
logpsi += (*it)->evaluateLog(P, P.G, P.L,buf,false);
PhaseValue += (*it)->PhaseValue;
}
else
// ValueType x = (*it)->evaluateLog(P, P.G, P.L,buf,false);
(*it)->copyFromDerivativeBuffer(P,buf);//keep buffer synched
}
convert(logpsi,LogValue);
return LogValue;
//return LogValue=real(logpsi);
}
/** advance all the walkers with killnode==yes
*/
void WFMCUpdateAllWithReweight::advanceWalkers(WalkerIter_t it
, WalkerIter_t it_end, bool measure)
{
for (; it != it_end; ++it)
{
Walker_t& thisWalker(**it);
W.loadWalker(thisWalker,false);
setScaledDriftPbyPandNodeCorr(m_tauovermass,W.G,drift);
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandomWithEngine(deltaR,RandomGen);
//reject illegal positions or big displacement
if (!W.makeMoveWithDrift(thisWalker,drift,deltaR, m_sqrttau))
{
H.rejectedMove(W,thisWalker);
H.auxHevaluate(W,thisWalker);
continue;
}
///W.R = m_sqrttau*deltaR + thisWalker.Drift;
///W.R += thisWalker.R;
///W.update();
//save old local energy
RealType eold = thisWalker.Properties(LOCALENERGY);
RealType enew = eold;
//evaluate wave function
RealType logpsi(Psi.evaluateLog(W));
bool accepted=false;
enew=H.evaluate(W);
RealType logGf = -0.5*Dot(deltaR,deltaR);
setScaledDriftPbyPandNodeCorr(m_tauovermass,W.G,drift);
deltaR = thisWalker.R - W.R - drift;
RealType logGb = -m_oneover2tau*Dot(deltaR,deltaR);
RealType prob= std::min(std::exp(logGb-logGf +2.0*(logpsi-thisWalker.Properties(LOGPSI))),1.0);
if (RandomGen() > prob)
{
enew=eold;
thisWalker.Age++;
// thisWalker.Properties(R2ACCEPTED)=0.0;
// thisWalker.Properties(R2PROPOSED)=rr_proposed;
H.rejectedMove(W,thisWalker);
}
else
{
thisWalker.Age=0;
accepted=true;
W.saveWalker(thisWalker);
// rr_accepted = rr_proposed;
// thisWalker.resetProperty(logpsi,Psi.getPhase(),enew,rr_accepted,rr_proposed,nodecorr);
thisWalker.resetProperty(logpsi,Psi.getPhase(),enew);
H.auxHevaluate(W,thisWalker);
H.saveProperty(thisWalker.getPropertyBase());
}
thisWalker.Weight *= std::exp(-Tau*(enew -thisWalker.PropertyHistory[Eindex][Elength]));
thisWalker.addPropertyHistoryPoint(Eindex,enew);
if (accepted)
++nAccept;
else
++nReject;
}
}
///initialize polymers
void ReptationMC::initReptile() {
//overwrite the number of cuts for Bounce algorithm
if(UseBounce) NumCuts = 1;
app_log() << "Moving " << NumCuts << " for each reptation step" << endl;
//Reptile is NOT allocated. Create one.
if(Reptile == 0) {
MCWalkerConfiguration::iterator it(W.begin());
Walker_t* cur(*it);
cur->Weight=1.0;
W.R = cur->R;
//DistanceTable::update(W);
W.update();
RealType logpsi(Psi.evaluateLog(W));
RealType eloc_cur = H.evaluate(W);
cur->resetProperty(logpsi,Psi.getPhase(),eloc_cur);
H.saveProperty(cur->getPropertyBase());
cur->Drift = W.G;
Reptile = new PolymerChain(cur,PolymerLength,NumCuts);
Reptile->resizeArrays(1);
}
//If ClonePolyer==false, generate configuration using diffusion
//Not so useful
if(!ClonePolymer) {
Walker_t* cur((*Reptile)[0]);
RealType g = std::sqrt(Tau);
for(int i=0; i<NumCuts-1; i++ ) {
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandom(deltaR);
W.R = cur->R + g*deltaR + Tau*cur->Drift;
//update the distance table associated with W
//DistanceTable::update(W);
W.update();
//evaluate wave function
RealType logpsic(Psi.evaluateLog(W));
RealType e0=H.evaluate(W);
cur = (*Reptile)[i+1];
cur->resetProperty(logpsic,Psi.getPhase(),e0);
H.saveProperty(cur->getPropertyBase());
cur->R = W.R;
cur->Drift = W.G;
}
}
}
/** evaluate the log value of a many-body wave function
* @param P input configuration containing N particles
* @param needratio users request ratio evaluation
* @param buf anonymous storage for the reusable data
* @return the value of \f$ \log( \Pi_i \Psi_i) \f$ many-body wave function
*
* @if needratio == true
* need to update the data from buf, since external objects need to evaluate ratios, e.g., non-local pseudopotentials
* @else
* evaluate the value only
*
* Upon return, the gradient and laplacian operators are added by the components.
* Each OrbitalBase evaluates PhaseValue and LogValue = log(abs(psi_i))
* Jastrow functions always have PhaseValue=1.
*/
TrialWaveFunction::RealType
TrialWaveFunction::evaluateDeltaLog(ParticleSet& P) {
P.G = 0.0;
P.L = 0.0;
ValueType logpsi(0.0);
PhaseValue=0.0;
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
for(; it!=it_end; ++it)
{
if((*it)->Optimizable) {
logpsi += (*it)->evaluateLog(P, P.G, P.L);
PhaseValue += (*it)->PhaseValue;
}
}
return LogValue=real(logpsi);
}
/** return log(|psi|)
*
* PhaseValue is the phase for the complex wave function
*/
TrialWaveFunction::RealType
TrialWaveFunction::evaluateLog(ParticleSet& P) {
P.G = 0.0;
P.L = 0.0;
ValueType logpsi(0.0);
PhaseValue=0.0;
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
//WARNING: multiplication for PhaseValue is not correct, fix this!!
for(; it!=it_end; ++it)
{
logpsi += (*it)->evaluateLog(P, P.G, P.L);
PhaseValue += (*it)->PhaseValue;
}
return LogValue=real(logpsi);
}
/** return log(|psi|)
*
* PhaseValue is the phase for the complex wave function
*/
TrialWaveFunction::RealType
TrialWaveFunction::evaluateLogOnly(ParticleSet& P)
{
//TAU_PROFILE("TrialWaveFunction::evaluateLogOnly","ParticleSet& P", TAU_USER);
tempP->R=P.R;
tempP->L=0.0;
tempP->G=0.0;
ValueType logpsi(0.0);
PhaseValue=0.0;
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
//WARNING: multiplication for PhaseValue is not correct, fix this!!
for (; it!=it_end; ++it)
{
logpsi += (*it)->evaluateLog(*tempP, tempP->G, tempP->L);
PhaseValue += (*it)->PhaseValue;
}
convert(logpsi,LogValue);
return LogValue;
//return LogValue=real(logpsi);
}
TrialWaveFunction::RealType
TrialWaveFunction::updateBuffer(ParticleSet& P, PooledData<RealType>& buf,
bool fromscratch) {
P.G = 0.0;
P.L = 0.0;
ValueType logpsi(0.0);
PhaseValue=0.0;
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
for(int ii=1; it!=it_end; ++it,ii+=TIMER_SKIP)
{
myTimers[ii]->start();
logpsi += (*it)->updateBuffer(P,buf,fromscratch);
PhaseValue += (*it)->PhaseValue;
myTimers[ii]->stop();
}
LogValue=real(logpsi);
buf.put(&(P.G[0][0]), &(P.G[0][0])+TotalDim);
buf.put(&(P.L[0]), &(P.L[0])+NumPtcls);
return LogValue;
}
bool DummyQMC::run()
{
m_oneover2tau = 0.5/Tau;
m_sqrttau = sqrt(Tau);
cout << "Lattice of ParticleSet " << endl;
W.Lattice.print(cout);
//property container to hold temporary properties, such as a local energy
//MCWalkerConfiguration::PropertyContainer_t Properties;
MCWalkerConfiguration::Walker_t& thisWalker(**W.begin());
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandom(deltaR);
//new poosition
W.R = m_sqrttau*deltaR + thisWalker.R + thisWalker.Drift;
//apply boundary condition: put everything back to a unit cell
W.applyBC(W.R);
//update the distance table associated with W
W.update();
//evaluate wave function
//update the properties: note that we are getting \f$\sum_i \ln(|psi_i|)\f$ and catching the sign separately
ValueType logpsi(Psi.evaluateLog(W));
RealType eloc=H.evaluate(W);
return true;
}
TrialWaveFunction::RealType TrialWaveFunction::updateBuffer(ParticleSet& P
, PooledData<RealType>& buf, bool fromscratch)
{
//TAU_PROFILE("TrialWaveFunction::updateBuffer","(P,..)", TAU_USER);
P.G = 0.0;
P.L = 0.0;
buf.rewind(BufferCursor);
ValueType logpsi(0.0);
PhaseValue=0.0;
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
for (; it!=it_end; ++it)
{
logpsi += (*it)->updateBuffer(P,buf,fromscratch);
PhaseValue += (*it)->PhaseValue;
}
convert(logpsi,LogValue);
//LogValue=real(logpsi);
buf.put(PhaseValue);
buf.put(LogValue);
buf.put(&(P.G[0][0]), &(P.G[0][0])+TotalDim);
buf.put(&(P.L[0]), &(P.L[0])+NumPtcls);
return LogValue;
}
bool FWSingleOMP::run()
{
hdf_WGT_data.setFileName(xmlrootName);
hdf_OBS_data.setFileName(xmlrootName);
if (doWeights==1)
{
fillIDMatrix();
hdf_WGT_data.makeFile();
hdf_WGT_data.openFile();
hdf_WGT_data.addFW(0);
for (int i=0;i<Weights.size();i++) hdf_WGT_data.addStep(i,Weights[i]);
hdf_WGT_data.closeFW();
hdf_WGT_data.closeFile();
for(int ill=1;ill<weightLength;ill++)
{
transferParentsOneGeneration();
FWOneStep();
// WeightHistory.push_back(Weights);
hdf_WGT_data.openFile();
hdf_WGT_data.addFW(ill);
for (int i=0;i<Weights.size();i++) hdf_WGT_data.addStep(i,Weights[i]);
hdf_WGT_data.closeFW();
hdf_WGT_data.closeFile();
}
}
else
{
fillIDMatrix();
// find weight length from the weight file
hid_t f_file = H5Fopen(hdf_WGT_data.getFileName().c_str(),H5F_ACC_RDONLY,H5P_DEFAULT);
hsize_t numGrps = 0;
H5Gget_num_objs(f_file, &numGrps);
weightLength = static_cast<int> (numGrps)-1;
if (H5Fclose(f_file)>-1) f_file=-1;
if (verbose>0) app_log()<<" weightLength "<<weightLength<<endl;
}
if (verbose>0) app_log()<<" Done Computing Weights"<<endl;
if (doObservables==1)
{
int nprops = H.sizeOfObservables();//local energy, local potnetial and all hamiltonian elements
int FirstHamiltonian = H.startIndex();
// vector<vector<vector<RealType> > > savedValues;
int nelectrons = W[0]->R.size();
int nfloats=OHMMS_DIM*nelectrons;
// W.clearEnsemble();
makeClones(W,Psi,H);
vector<ForwardWalkingData* > FWvector;
for(int ip=0; ip<NumThreads; ip++) FWvector.push_back(new ForwardWalkingData(nelectrons));
if (myComm->rank()==0) hdf_OBS_data.makeFile();
hdf_float_data.openFile(fname.str());
for(int step=0;step<numSteps;step++)
{
hdf_float_data.setStep(step);
vector<RealType> stepObservables(walkersPerBlock[step]*(nprops+2), 0);
for(int wstep=0; wstep<walkersPerBlock[step];)
{
vector<float> ThreadsCoordinate(NumThreads*nfloats);
int nwalkthread = hdf_float_data.getFloat(wstep*nfloats, (wstep+NumThreads)*nfloats, ThreadsCoordinate) / nfloats;
// for(int j=0;j<ThreadsCoordinate.size();j++)cout<<ThreadsCoordinate[j]<<" ";
// cout<<endl;
#pragma omp parallel for
for(int ip=0; ip<nwalkthread; ip++)
{
vector<float> SINGLEcoordinate(0);
vector<float>::iterator TCB1(ThreadsCoordinate.begin()+ip*nfloats), TCB2(ThreadsCoordinate.begin()+(1+ip)*nfloats);
SINGLEcoordinate.insert(SINGLEcoordinate.begin(),TCB1,TCB2);
FWvector[ip]->fromFloat(SINGLEcoordinate);
wClones[ip]->R=FWvector[ip]->Pos;
wClones[ip]->update();
RealType logpsi(psiClones[ip]->evaluateLog(*wClones[ip]));
RealType eloc=hClones[ip]->evaluate( *wClones[ip] );
hClones[ip]->auxHevaluate(*wClones[ip]);
int indx=(wstep+ip)*(nprops+2);
stepObservables[indx]= eloc;
stepObservables[indx+1]= hClones[ip]->getLocalPotential();
for(int i=0;i<nprops;i++) stepObservables[indx+i+2] = hClones[ip]->getObservable(i) ;
}
wstep+=nwalkthread;
for(int ip=0; ip<NumThreads; ip++) wClones[ip]->resetCollectables();
}
hdf_OBS_data.openFile();
hdf_OBS_data.addStep(step, stepObservables);
hdf_OBS_data.closeFile();
// savedValues.push_back(stepObservables);
hdf_float_data.endStep();
if (verbose >1) cout<<"Done with step: "<<step<<endl;
}
}
if(doDat>=1)
{
vector<int> Dimensions(4);
hdf_WGT_data.openFile();
hdf_OBS_data.openFile();
Estimators->start(weightLength,1);
int nprops;
if (doObservables==1) nprops = H.sizeOfObservables()+2;
else
{
int Noo = hdf_OBS_data.numObsStep(0);
int Nwl = hdf_WGT_data.numWgtStep(0);
nprops = Noo/Nwl;
}
for(int ill=0;ill<weightLength;ill++)
{
Dimensions[0]=ill;
Dimensions[1]= nprops ;
Dimensions[2]=numSteps;
Dimensions[3]=startStep;
Estimators->startBlock(1);
Estimators->accumulate(hdf_OBS_data,hdf_WGT_data,Dimensions);
Estimators->stopBlock(getNumberOfSamples(ill));
}
hdf_OBS_data.closeFile();
hdf_WGT_data.closeFile();
Estimators->stop();
}
return true;
}
void
ReptationMC::moveReptile(){
//RealType oneovertau = 1.0/Tau;
//RealType oneover2tau = 0.5*oneovertau;
RealType tauover2 = 0.5*Tau;
RealType g = std::sqrt(Tau);
typedef MCWalkerConfiguration::PropertyContainer_t PropertyContainer_t;
if(!UseBounce && Random()<0.5) {
Reptile->flip();
NumTurns++;
}
Walker_t* anchor = Reptile->makeEnds();
//save the local energies of the anchor and tails
//eloc_xp = the energy of the front
//eloc_yp = the energy of the proposed move
//eloc_x = the energy of the tail
//eloc_y = the energy of the tail-1
RealType eloc_xp = anchor->Properties(LOCALENERGY);
RealType eloc_x = Reptile->tails[0]->Properties(LOCALENERGY);
RealType eloc_y = Reptile->tails[1]->Properties(LOCALENERGY);
NumCuts = Reptile->NumCuts;
RealType Wpolymer=0.0;
for(int i=0; i<NumCuts; ) {
Walker_t* head=Reptile->heads[i];
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandom(deltaR);
W.R = anchor->R + g*deltaR + Tau* anchor->Drift;
//update the distance table associated with W
//DistanceTable::update(W);
W.update();
//evaluate wave function
RealType logpsi(Psi.evaluateLog(W));
//update the properties of the front chain
//RealType eloc_yp = head->Properties(LOCALENERGY) = H.evaluate(W);
//H.copy(head->getEnergyBase());
//head->Properties(LOCALPOTENTIAL) = H.getLocalPotential();
RealType eloc_yp = H.evaluate(W);
head->resetProperty(logpsi,Psi.getPhase(),eloc_yp);
H.saveProperty(head->getPropertyBase());
head->R = W.R;
//ValueType vsq = Dot(W.G,W.G);
//ValueType scale = ((-1.0+sqrt(1.0+2.0*Tau*vsq))/vsq);
//head->Drift = scale*W.G;
head->Drift = W.G;
//\f${x-y-\tau\nabla \ln \Psi_{T}(y))\f$
//deltaR = anchor->R - W.R - heads[i]->Drift;
//Gdrift *= exp(-oneover2tau*Dot(deltaR,deltaR));
/*
\f$ X= \{R_0, R_1, ... , R_M\}\f$
\f$ X' = \{R_1, .., R_M, R_{M+1}\}\f$
\f[ G_B(R_{M+1}\leftarrow R_{M}, \tau)/G_B(R_{0}\leftarrow R_{1}, \tau)
= exp\(-\tau/2[E_L(R_{M+1})+E_L(R_M)-E_L(R_1)-E_L(R_0)]\)\f]
*
- eloc_yp = \f$E_L(R_{M+1})\f$
- eloc_xp = \f$E_L(R_{M})\f$
- eloc_y = \f$E_L(R_{1})\f$
- eloc_x = \f$E_L(R_{0})\f$
*/
//Wpolymer *= exp(-oneover2tau*(eloc_yp+eloc_xp-eloc_x-eloc_y));
Wpolymer +=(eloc_yp+eloc_xp-eloc_x-eloc_y);
//move the anchor and swap the local energies for Wpolymer
anchor=head;
//increment the index
i++;
if(i<NumCuts) {
eloc_xp = eloc_yp;
eloc_x = eloc_y;
eloc_y = Reptile->tails[i+1]->Properties(LOCALENERGY);
}
}
Wpolymer = std::exp(-tauover2*Wpolymer);
double accept = std::min(1.0,Wpolymer);
if(Random() < accept){//move accepted
Reptile->updateEnds();
++nAccept;
} else {
++nReject;
if(UseBounce) {
NumTurns++;
Reptile->flip();
}
}
//RealType Bounce = UseBounce ? 1.0-accept: 0.5;
//if(Random()<Bounce) {
// Reptile->flip();
// LogOut->getStream() << "Bounce = " << Bounce << " " << NumTurns << " " << polymer.MoveHead << endl;
// NumTurns++;//increase the number of turns
//}
}
void
DMCWOS::advanceWalkerByWalker(BRANCHER& Branch) {
//Pooma::Clock timer;
RealType oneovertau = 1.0/Tau;
RealType oneover2tau = 0.5*oneovertau;
RealType g = sqrt(Tau);
RealType vwos;
//MCWalkerConfiguration::PropertyContainer_t Properties;
int nh = H.size()+1;
// extract the WOS potential
//WOSPotential* wos = dynamic_cast<WOSPotential*>(H.getHamiltonian("wos"));
MCWalkerConfiguration::iterator it = W.begin();
MCWalkerConfiguration::iterator it_end = W.end();
while(it != it_end) {
(*it)->Properties(WEIGHT) = 1.0;
(*it)->Properties(MULTIPLICITY) = 1.0;
//copy the properties of the working walker
W.Properties = (*it)->Properties;
//save old local energy
ValueType eold = W.Properties(LOCALENERGY);
/*
If doing WOS then we have to redo the old calculation for ROld to
calculate G(Rold,Rnew). So we extract wos from the Hamiltonian and
re-evaluate it.
*/
ValueType emixed = eold;
if(wos_ref) {
W.R = (*it)->R;
DistanceTable::update(W);
ValueType psi(Psi.evaluateLog(W));//not used anyway
eold = H.evaluate(W);
emixed += 0.5*W.Properties(WOSVAR)*Tau_var;
}
//ValueType emixed = eold + 0.5*W.Properties(WOSVAR)*Tau;
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandom(deltaR);
W.R = g*deltaR + (*it)->R + (*it)->Drift;
//update the distance table associated with W
DistanceTable::update(W);
//evaluate wave function
ValueType logpsi(Psi.evaluateLog(W));
//update the properties
W.Properties(LOCALENERGY) = H.evaluate(W);
W.Properties(LOGPSI) =logpsi;
W.Properties(SIGN) = Psi.getSign();
bool accepted=false;
//deltaR = W.R - (*it)->R - (*it)->Drift;
//RealType forwardGF = exp(-oneover2tau*Dot(deltaR,deltaR));
//RealType forwardGF = exp(-0.5*Dot(deltaR,deltaR));
RealType logGf = -0.5*Dot(deltaR,deltaR);
//scale the drift term to prevent persistent cofigurations
ValueType vsq = Dot(W.G,W.G);
//converting gradients to drifts, D = tau*G (reuse G)
// W.G *= Tau;//original implementation with bare drift
ValueType scale = ((-1.0+sqrt(1.0+2.0*Tau*vsq))/vsq);
drift = scale*W.G;
deltaR = (*it)->R - W.R - drift;
//RealType backwardGF = exp(-oneover2tau*Dot(deltaR,deltaR));
RealType logGb = -oneover2tau*Dot(deltaR,deltaR);
//set acceptance probability
//RealType prob= std::min(backwardGF/forwardGF*W.Properties(PSISQ)/(*it)->Properties(PSISQ),1.0);
//RealType prob= std::min(exp(logGb-logGf)*W.Properties(PSISQ)/(*it)->Properties(PSISQ),1.0);
RealType prob= std::min(exp(logGb-logGf +2.0*(W.Properties(LOGPSI)-(*it)->Properties(LOGPSI))),1.0);
if(Random() > prob){
(*it)->Properties(AGE)++;
emixed += emixed;
} else {
accepted=true;
W.Properties(AGE) = 0;
(*it)->R = W.R;
(*it)->Drift = drift;
(*it)->Properties = W.Properties;
H.copy((*it)->getEnergyBase());
emixed += W.Properties(LOCALENERGY) + 0.5*W.Properties(WOSVAR)*Tau_var;
}
//calculate the weight and multiplicity
ValueType M = Branch.branchGF(Tau,emixed*0.5,1.0-prob);
if((*it)->Properties(AGE) > 3.0) M = min(0.5,M);
if((*it)->Properties(AGE) > 0.9) M = min(1.0,M);
(*it)->Properties(WEIGHT) = M;
(*it)->Properties(MULTIPLICITY) = M + Random();
//node-crossing: kill it for the time being
if(Branch(W.Properties(SIGN),(*it)->Properties(SIGN))) {
accepted=false;
(*it)->Properties(WEIGHT) = 0.0;
(*it)->Properties(MULTIPLICITY) = 0.0;
}
/*
if(Branch(W.Properties(PSI),(*it)->Properties(PSI))) {
accepted=false;
(*it)->Properties(WEIGHT) = 0.0;
(*it)->Properties(MULTIPLICITY) = 0.0;
} else {
RealType logGf = -0.5*Dot(deltaR,deltaR);
ValueType vsq = Dot(W.G,W.G);
ValueType scale = ((-1.0+sqrt(1.0+2.0*Tau*vsq))/vsq);
drift = scale*W.G;
deltaR = (*it)->R - W.R - drift;
RealType logGb = -oneover2tau*Dot(deltaR,deltaR);
RealType prob
= std::min(exp(logGb-logGf)*W.Properties(PSISQ)/(*it)->Properties(PSISQ),1.0);
if(Random() > prob){
(*it)->Properties(AGE)++;
emixed += emixed;
} else {
accepted=true;
W.Properties(AGE) = 0;
(*it)->R = W.R;
(*it)->Drift = drift;
(*it)->Properties = W.Properties;
// H.update(W.Energy[(*it)->ID]);
//H.get((*it)->E);
H.copy((*it)->getEnergyBase());
emixed += W.Properties(LOCALENERGY) + 0.5*W.Properties(WOSVAR)*Tau_var;
}
//calculate the weight and multiplicity
ValueType M = Branch.branchGF(Tau,emixed*0.5,1.0-prob);
if((*it)->Properties(AGE) > 3.0) M = min(0.5,M);
if((*it)->Properties(AGE) > 0.9) M = min(1.0,M);
(*it)->Properties(WEIGHT) = M;
(*it)->Properties(MULTIPLICITY) = M + Random();
}
*/
if(accepted)
++nAccept;
else
++nReject;
++it;
}
}
bool FWSingle::run()
{
Estimators->start(weightLength,1);
fillIDMatrix();
//we do this once because we only want to link parents to parents if we need to
// if (verbose>1) app_log()<<" getting weights for generation "<<gensTransferred<<endl;
vector<vector<vector<int> > > WeightHistory;
WeightHistory.push_back(Weights);
for(int ill=1; ill<weightLength; ill++)
{
transferParentsOneGeneration();
FWOneStep();
WeightHistory.push_back(Weights);
}
if (verbose>0)
app_log()<<" Done Computing Weights"<<endl;
int nprops = H.sizeOfObservables();//local energy, local potnetial and all hamiltonian elements
int FirstHamiltonian = H.startIndex();
vector<vector<vector<RealType> > > savedValues;
int nelectrons = W[0]->R.size();
int nfloats=OHMMS_DIM*nelectrons;
ForwardWalkingData fwer;
fwer.resize(nelectrons);
// MCWalkerConfiguration* savedW = new MCWalkerConfiguration(W);
for(int step=0; step<numSteps; step++)
{
vector<float> ALLcoordinates;
readInFloat(step,ALLcoordinates);
vector<float> SINGLEcoordinate(nfloats);
vector<float>::iterator fgg(ALLcoordinates.begin()), fgg2(ALLcoordinates.begin()+nfloats);
W.resetCollectables();
vector<vector<RealType> > stepObservables;
for(int wstep=0; wstep<walkersPerBlock[step]; wstep++)
{
std::copy( fgg,fgg2,SINGLEcoordinate.begin());
fwer.fromFloat(SINGLEcoordinate);
W.R=fwer.Pos;
fgg+=nfloats;
fgg2+=nfloats;
W.update();
RealType logpsi(Psi.evaluateLog(W));
RealType eloc=H.evaluate( W );
// (*W[0]).resetProperty(logpsi,1,eloc);
H.auxHevaluate(W);
H.saveProperty(W.getPropertyBase());
vector<RealType> walkerObservables(nprops+2,0);
walkerObservables[0]= eloc;
walkerObservables[1]= H.getLocalPotential();
const RealType* restrict ePtr = W.getPropertyBase();
for(int i=0; i<nprops; i++)
walkerObservables[i+2] = ePtr[FirstHamiltonian+i] ;
stepObservables.push_back(walkerObservables);
}
savedValues.push_back(stepObservables);
}
for(int ill=0; ill<weightLength; ill++)
{
Estimators->startBlock(1);
Estimators->accumulate(savedValues,WeightHistory[ill],getNumberOfSamples(ill));
Estimators->stopBlock(getNumberOfSamples(ill));
}
Estimators->stop();
return true;
}
void
RQMCEstimator
::initialize(MCWalkerConfiguration& W, vector<ParticleSet*>& WW,
SpaceWarp& Warp,
vector<QMCHamiltonian*>& h,
vector<TrialWaveFunction*>& psi,
RealType tau,vector<RealType>& Norm,
bool require_register) {
NumWalkers = W.getActiveWalkers();
int numPtcls(W.getTotalNum());
RatioIJ.resize(NumWalkers,NumCopies*(NumCopies-1)/2);
vector<RealType> invsumratio(NumCopies);
MCWalkerConfiguration::ParticlePos_t drift(numPtcls);
MCWalkerConfiguration::iterator it(W.begin());
MCWalkerConfiguration::iterator it_end(W.end());
vector<RealType> sumratio(NumCopies), logpsi(NumCopies);
vector<RealType> Jacobian(NumCopies);
int jindex=W.addProperty("Jacobian");
int iw(0);
int DataSetSize((*it)->DataSet.size());
while(it != it_end) {
Walker_t& thisWalker(**it);
(*it)->DataSet.rewind();
//NECESSARY SINCE THE DISTANCE TABLE OF W ARE USED TO WARP
if(require_register) {
W.registerData(thisWalker,(*it)->DataSet);
} else {
W.R = thisWalker.R;
W.update();
if(DataSetSize) W.updateBuffer((*it)->DataSet);
}
for(int ipsi=0; ipsi<NumCopies; ipsi++) Jacobian[ipsi]=1.e0;
for(int iptcl=0; iptcl< numPtcls; iptcl++){
Warp.warp_one(iptcl,0);
for(int ipsi=0; ipsi<NumCopies; ipsi++){
WW[ipsi]->R[iptcl]=W.R[iptcl]+Warp.get_displacement(iptcl,ipsi);
Jacobian[ipsi]*=Warp.get_Jacobian(iptcl,ipsi);
}
if(require_register || DataSetSize) Warp.update_one_ptcl_Jacob(iptcl);
}
for(int ipsi=0; ipsi<NumCopies; ipsi++){
thisWalker.Properties(ipsi,jindex)=Jacobian[ipsi];
}
//update distance table and bufferize it if necessary
if(require_register) {
for(int ipsi=0; ipsi<NumCopies; ipsi++){
WW[ipsi]->registerData((*it)->DataSet);
}
Warp.registerData(WW,(*it)->DataSet);
} else {
for(int ipsi=0; ipsi<NumCopies; ipsi++){
WW[ipsi]->update();
if(DataSetSize) WW[ipsi]->updateBuffer((*it)->DataSet);
}
if(DataSetSize) Warp.updateBuffer((*it)->DataSet);
}
//evalaute the wavefunction and hamiltonian
for(int ipsi=0; ipsi< NumCopies;ipsi++) {
psi[ipsi]->G.resize(numPtcls);
psi[ipsi]->L.resize(numPtcls);
//Need to modify the return value of OrbitalBase::registerData
if(require_register) {
logpsi[ipsi]=psi[ipsi]->registerData(*WW[ipsi],(*it)->DataSet);
}else{
if(DataSetSize)logpsi[ipsi]=psi[ipsi]->updateBuffer(*WW[ipsi],(*it)->DataSet);
else logpsi[ipsi]=psi[ipsi]->evaluateLog(*WW[ipsi]);
}
psi[ipsi]->G=WW[ipsi]->G;
thisWalker.Properties(ipsi,LOGPSI)=logpsi[ipsi];
thisWalker.Properties(ipsi,LOCALENERGY)=h[ipsi]->evaluate(*WW[ipsi]);
h[ipsi]->saveProperty(thisWalker.getPropertyBase(ipsi));
sumratio[ipsi]=1.0;
}
//Check SIMONE's note
//Compute the sum over j of Psi^2[j]/Psi^2[i] for each i
int indexij(0);
RealType *rPtr=RatioIJ[iw];
for(int ipsi=0; ipsi< NumCopies-1; ipsi++) {
for(int jpsi=ipsi+1; jpsi< NumCopies; jpsi++){
RealType r= std::exp(2.0*(logpsi[jpsi]-logpsi[ipsi]))*Norm[ipsi]/Norm[jpsi];
//BEWARE: RatioIJ DOES NOT INCLUDE THE JACOBIANS!
rPtr[indexij++]=r;
r*=(Jacobian[jpsi]/Jacobian[ipsi]);
sumratio[ipsi] += r;
sumratio[jpsi] += 1.0/r;
}
}
//Re-use Multiplicity as the sumratio
thisWalker.Multiplicity=sumratio[0];
/*START COMMENT
QMCTraits::PosType WarpDrift;
RealType denom(0.e0),wgtpsi;
thisWalker.Drift=0.e0;
for(int ipsi=0; ipsi< NumCopies; ipsi++) {
wgtpsi=1.e0/sumratio[ipsi];
thisWalker.Properties(ipsi,UMBRELLAWEIGHT)=wgtpsi;
denom += wgtpsi;
for(int iptcl=0; iptcl< numPtcls; iptcl++){
WarpDrift=dot( psi[ipsi]->G[iptcl], Warp.get_Jacob_matrix(iptcl,ipsi) )
+5.0e-1*Warp.get_grad_ln_Jacob(iptcl,ipsi) ;
thisWalker.Drift[iptcl] += (wgtpsi*WarpDrift);
}
}
//Drift = denom*Drift;
thisWalker.Drift *= (tau/denom);
END COMMENT*/
for(int ipsi=0; ipsi< NumCopies ;ipsi++){
invsumratio[ipsi]=1.0/sumratio[ipsi];
thisWalker.Properties(ipsi,UMBRELLAWEIGHT)=invsumratio[ipsi];
}
setScaledDrift(tau,psi[0]->G,drift);
thisWalker.Drift=invsumratio[0]*drift;
for(int ipsi=1; ipsi< NumCopies ;ipsi++) {
setScaledDrift(tau,psi[ipsi]->G,drift);
thisWalker.Drift += (invsumratio[ipsi]*drift);
}
++it;++iw;
}
}
// old ones
void
RQMCEstimator
::initialize(MCWalkerConfiguration& W,
vector<QMCHamiltonian*>& h,
vector<TrialWaveFunction*>& psi,
RealType tau,vector<RealType>& Norm,
bool require_register) {
NumWalkers = W.getActiveWalkers();
//allocate UmbrellaEnergy
int numPtcls(W.getTotalNum());
RatioIJ.resize(NumWalkers,NumCopies*(NumCopies-1)/2);
MCWalkerConfiguration::iterator it(W.begin());
MCWalkerConfiguration::iterator it_end(W.end());
vector<RealType> sumratio(NumCopies), logpsi(NumCopies);
int iw(0);
int DataSetSize((*it)->DataSet.size());
while(it != it_end) {
Walker_t& thisWalker(**it);
(*it)->DataSet.rewind();
if(require_register) {
W.registerData(thisWalker,(*it)->DataSet);
} else {
W.R = thisWalker.R;
W.update();
if(DataSetSize) W.updateBuffer((*it)->DataSet);
}
//evalaute the wavefunction and hamiltonian
for(int ipsi=0; ipsi< NumCopies;ipsi++) {
psi[ipsi]->G.resize(numPtcls);
psi[ipsi]->L.resize(numPtcls);
//Need to modify the return value of OrbitalBase::registerData
if(require_register) {
logpsi[ipsi]=psi[ipsi]->registerData(W,(*it)->DataSet);
} else {
if(DataSetSize)logpsi[ipsi]=psi[ipsi]->updateBuffer(W,(*it)->DataSet);
else logpsi[ipsi]=psi[ipsi]->evaluateLog(W);
}
psi[ipsi]->G=W.G;
thisWalker.Properties(ipsi,LOGPSI)=logpsi[ipsi];
thisWalker.Properties(ipsi,LOCALENERGY)=h[ipsi]->evaluate(W);
h[ipsi]->saveProperty(thisWalker.getPropertyBase(ipsi));
sumratio[ipsi]=1.0;
}
//Check SIMONE's note
//Compute the sum over j of Psi^2[j]/Psi^2[i] for each i
int indexij(0);
RealType *rPtr=RatioIJ[iw];
for(int ipsi=0; ipsi< NumCopies-1; ipsi++) {
for(int jpsi=ipsi+1; jpsi< NumCopies; jpsi++){
RealType r= std::exp(2.0*(logpsi[jpsi]-logpsi[ipsi]));
rPtr[indexij++]=r*Norm[ipsi]/Norm[jpsi];
sumratio[ipsi] += r;
sumratio[jpsi] += 1.0/r;
}
}
//Re-use Multiplicity as the sumratio
thisWalker.Multiplicity=sumratio[0];
//DON't forget DRIFT!!!
thisWalker.Drift=0.0;
for(int ipsi=0; ipsi< NumCopies; ipsi++) {
RealType wgt=1.0/sumratio[ipsi];
thisWalker.Properties(ipsi,UMBRELLAWEIGHT)=wgt;
//thisWalker.Drift += wgt*psi[ipsi]->G;
PAOps<RealType,DIM>::axpy(wgt,psi[ipsi]->G,thisWalker.Drift);
}
thisWalker.Drift *= tau;
++it;++iw;
}
}
/** 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 DMCNonLocalUpdate::advanceWalkers(WalkerIter_t it, WalkerIter_t it_end,
bool measure)
{
//RealType plusFactor(Tau*Gamma);
//RealType minusFactor(-Tau*(1.0-Alpha*(1.0+Gamma)));
for(; it!=it_end; ++it)
{
Walker_t& thisWalker(**it);
//save old local energy
RealType eold = thisWalker.Properties(LOCALENERGY);
RealType signold = thisWalker.Properties(SIGN);
RealType enew = eold;
//create a 3N-Dimensional Gaussian with variance=1
makeGaussRandomWithEngine(deltaR,RandomGen);
W.R = m_sqrttau*deltaR + thisWalker.R + thisWalker.Drift;
//update the distance table associated with W
//DistanceTable::update(W);
W.update();
//evaluate wave function
RealType logpsi(Psi.evaluateLog(W));
nonLocalOps.reset();
bool accepted=false;
if(branchEngine->phaseChanged(Psi.getPhase(),thisWalker.Properties(SIGN)))
{
thisWalker.Age++;
++nReject;
}
else
{
//RealType enew(H.evaluate(W,nonLocalOps.Txy));
enew=H.evaluate(W,nonLocalOps.Txy);
RealType logGf = -0.5*Dot(deltaR,deltaR);
setScaledDrift(Tau,W.G,drift);
deltaR = (*it)->R - W.R - drift;
RealType logGb = -m_oneover2tau*Dot(deltaR,deltaR);
RealType prob= std::min(std::exp(logGb-logGf +2.0*(logpsi-thisWalker.Properties(LOGPSI))),1.0);
if(RandomGen() > prob){
thisWalker.Age++;
++nReject;
enew=eold;
} else {
accepted=true;
thisWalker.R = W.R;
thisWalker.Drift = drift;
thisWalker.resetProperty(logpsi,Psi.getPhase(),enew);
H.saveProperty(thisWalker.getPropertyBase());
//emixed = (emixed+enew)*0.5;
//eold=enew;
++nAccept;
}
}
int ibar=nonLocalOps.selectMove(RandomGen());
//make a non-local move
if(ibar) {
int iat=nonLocalOps.id(ibar);
W.R[iat] += nonLocalOps.delta(ibar);
W.update();
logpsi=Psi.evaluateLog(W);
setScaledDrift(Tau,W.G,thisWalker.Drift);
thisWalker.resetProperty(logpsi,Psi.getPhase(),eold);
thisWalker.R[iat] = W.R[iat];
++NonLocalMoveAccepted;
}
thisWalker.Weight *= branchEngine->branchWeight(eold,enew);
//branchEngine->accumulate(eold,1);
}
}
