bool JastrowBuilder::addOneBody(xmlNodePtr cur)
{
app_log() << " JastrowBuilder::addOneBody "<< endl;
if(sourceOpt == targetPtcl.getName())
{
app_warning() << " One-Body Jastrow Function needs a source different from " << targetPtcl.getName() << endl;
app_warning() << " Exit JastrowBuilder::addOneBody." << endl;
return false;
}
map<string,ParticleSet*>::iterator pa_it(ptclPool.find(sourceOpt));
if(pa_it == ptclPool.end()) {
app_warning() << " JastrowBuilder::addOneBody failed. " << sourceOpt << " does not exist" << endl;
return false;
}
ParticleSet* sourcePtcl= (*pa_it).second;
if(funcOpt == "any" || funcOpt == "poly")
{
OrbitalConstraintsBase* control=0;
if(funcOpt == "any")
control = new AnyConstraints(targetPtcl,targetPsi);
else
control = new PolyConstraints(targetPtcl,targetPsi,true);
control->put(cur);
OrbitalBase* j=control->createOneBody(*sourcePtcl);
if(j)
{
control->addOptimizables(targetPsi.VarList);
targetPsi.addOrbital(j);
Children.push_back(control);
return true;
}
else
{
delete control;
return false;
}
}
else
{
app_log() << "\n Using JABBuilder for one-body jatrow with analytic functions" << endl;
OrbitalBuilderBase* jb = new JABBuilder(targetPtcl,targetPsi,ptclPool);
Children.push_back(jb);
return jb->put(cur);
}
}
bool JastrowBuilder::put(xmlNodePtr cur) {
myNode=cur;
resetOptions();
OhmmsAttributeSet oAttrib;
oAttrib.add(typeOpt,"type");
oAttrib.add(nameOpt,"name");
oAttrib.add(funcOpt,"function");
oAttrib.add(transformOpt,"transform");
oAttrib.add(sourceOpt,"source");
oAttrib.add(spinOpt,"spin");
oAttrib.put(cur);
if(nameOpt[0] == '0')
{
app_warning() << " JastrowBuilder::put does not have name "<< endl;
return false;
}
if(typeOpt.find("One") < typeOpt.size())
return addOneBody(cur);
if(typeOpt.find("Two") < typeOpt.size())
return addTwoBody(cur);
if(typeOpt.find("Three") < typeOpt.size())
return addThreeBody(cur);
return false;
}
OrbitalBase* ProductOrbital::makeClone(ParticleSet& tpq) const
{
app_warning() << " ProductOrbital::makeClone for long-range breakup stuff won't work." << endl;
ProductOrbital* myclone=new ProductOrbital(*this);
for(int i=0; i<Psi.size(); ++i)
{
myclone->Psi[i]=Psi[i]->makeClone(tpq);
}
return myclone;
}
void ParticleSet::checkBoundBox(RealType rb)
{
if (UseBoundBox && rb>Lattice.SimulationCellRadius)
{
app_warning()
<< "ParticleSet::checkBoundBox "
<< rb << "> SimulationCellRadius=" << Lattice.SimulationCellRadius
<< "\n Using SLOW method for the sphere update. " <<endl;
UseSphereUpdate=false;
}
}
void
MCWalkerConfiguration::destroyWalkers(int nw) {
if(WalkerList.size() == 1 || nw >= WalkerList.size()) {
app_warning() << " Cannot remove walkers. Current Walkers = " << WalkerList.size() << endl;
return;
}
nw=WalkerList.size()-nw;
iterator it(WalkerList.begin()+nw),it_end(WalkerList.end());
while(it != it_end) {
delete *it++;
}
WalkerList.erase(WalkerList.begin()+nw,WalkerList.end());
}
/** process an xml element
* @param cur current xmlNodePtr
* @return true, if successful.
*
* Creating MCWalkerConfiguration for all the ParticleSet
* objects.
*/
bool ParticleSetPool::put(xmlNodePtr cur)
{
ReportEngine PRE("ParticleSetPool","put");
//const ParticleSet::ParticleLayout_t* sc=DistanceTable::getSimulationCell();
//ParticleSet::ParticleLayout_t* sc=0;
string id("e"), role("none");
OhmmsAttributeSet pAttrib;
pAttrib.add(id,"id"); pAttrib.add(id,"name");
pAttrib.add(role,"role");
pAttrib.put(cur);
//backward compatibility
if(id == "e" && role=="none") role="MC";
ParticleSet* pTemp = getParticleSet(id);
if(pTemp == 0)
{
app_log() << " Creating " << id << " particleset" << endl;
pTemp = new MCWalkerConfiguration;
//if(role == "MC")
// pTemp = new MCWalkerConfiguration;
//else
// pTemp = new ParticleSet;
if(SimulationCell)
{
app_log() << " Initializing the lattice of " << id << " by the global supercell" << endl;
pTemp->Lattice.copy(*SimulationCell);
}
myPool[id] = pTemp;
XMLParticleParser pread(*pTemp,TileMatrix);
bool success = pread.put(cur);
pTemp->setName(id);
app_log() << pTemp->getName() <<endl;
return success;
} else {
app_warning() << "particleset " << id << " is already created. Ignore this" << endl;
}
return true;
}
/** evaluate curData and mark the bad/good walkers
*/
int WalkerControlBase::sortWalkers(MCWalkerConfiguration& W) {
MCWalkerConfiguration::iterator it(W.begin());
vector<Walker_t*> bad,good_rn;
vector<int> ncopy_rn;
NumWalkers=0;
MCWalkerConfiguration::iterator it_end(W.end());
RealType esum=0.0,e2sum=0.0,wsum=0.0,ecum=0.0, w2sum=0.0, besum=0.0, bwgtsum=0.0;
RealType r2_accepted=0.0,r2_proposed=0.0;
int nrn(0),ncr(0);
while(it != it_end)
{
bool inFN=(((*it)->ReleasedNodeAge)==0);
if ((*it)->ReleasedNodeAge==1) ncr+=1;
int nc= std::min(static_cast<int>((*it)->Multiplicity),MaxCopy);
r2_accepted+=(*it)->Properties(R2ACCEPTED);
r2_proposed+=(*it)->Properties(R2PROPOSED);
RealType e((*it)->Properties(LOCALENERGY));
RealType bfe((*it)->Properties(ALTERNATEENERGY));
RealType rnwgt(0.0);
if (inFN)
rnwgt=((*it)->Properties(SIGN));
// RealType wgt((*it)->Weight);
RealType wgt(0.0);
if (inFN)
wgt=((*it)->Weight);
esum += wgt*e;
e2sum += wgt*e*e;
wsum += wgt;
w2sum += wgt*wgt;
ecum += e;
besum += bfe*rnwgt*wgt;
bwgtsum += rnwgt*wgt;
if((nc) && (inFN))
{
NumWalkers += nc;
good_w.push_back(*it);
ncopy_w.push_back(nc-1);
}
else if (nc)
{
NumWalkers += nc;
nrn+=nc;
good_rn.push_back(*it);
ncopy_rn.push_back(nc-1);
}
else
{
bad.push_back(*it);
}
++it;
}
//temp is an array to perform reduction operations
std::fill(curData.begin(),curData.end(),0);
//update curData
curData[ENERGY_INDEX]=esum;
curData[ENERGY_SQ_INDEX]=e2sum;
curData[WALKERSIZE_INDEX]=W.getActiveWalkers();
curData[WEIGHT_INDEX]=wsum;
curData[EREF_INDEX]=ecum;
curData[R2ACCEPTED_INDEX]=r2_accepted;
curData[R2PROPOSED_INDEX]=r2_proposed;
curData[FNSIZE_INDEX]=static_cast<RealType>(good_w.size());
curData[RNONESIZE_INDEX]=static_cast<RealType>(ncr);
curData[RNSIZE_INDEX]=nrn;
curData[B_ENERGY_INDEX]=besum;
curData[B_WGT_INDEX]=bwgtsum;
////this should be move
//W.EnsembleProperty.NumSamples=curData[WALKERSIZE_INDEX];
//W.EnsembleProperty.Weight=curData[WEIGHT_INDEX];
//W.EnsembleProperty.Energy=(esum/=wsum);
//W.EnsembleProperty.Variance=(e2sum/wsum-esum*esum);
//W.EnsembleProperty.Variance=(e2sum*wsum-esum*esum)/(wsum*wsum-w2sum);
//remove bad walkers empty the container
for(int i=0; i<bad.size(); i++) delete bad[i];
if (!WriteRN)
{
if(good_w.empty()) {
app_error() << "All the walkers have died. Abort. " << endl;
APP_ABORT("WalkerControlBase::sortWalkers");
}
int sizeofgood = good_w.size();
//check if the projected number of walkers is too small or too large
if(NumWalkers>Nmax) {
int nsub=0;
int nsub_target=(NumWalkers-nrn)-static_cast<int>(0.9*Nmax);
int i=0;
while(i< sizeofgood && nsub<nsub_target) {
if(ncopy_w[i]) {ncopy_w[i]--; nsub++;}
++i;
}
NumWalkers -= nsub;
} else if(NumWalkers < Nmin) {
int nadd=0;
int nadd_target = static_cast<int>(Nmin*1.1)-(NumWalkers-nrn);
if(nadd_target> sizeofgood) {
app_warning() << "The number of walkers is running low. Requested walkers "
<< nadd_target << " good walkers = " << sizeofgood << endl;
}
int i=0;
while(i< sizeofgood && nadd<nadd_target) {
ncopy_w[i]++; ++nadd;++i;
}
NumWalkers += nadd;
}
}
else
{
it=good_rn.begin(); it_end=good_rn.end();
int indy(0);
while(it!=it_end) {
good_w.push_back(*it);
ncopy_w.push_back(ncopy_rn[indy]);
it++,indy++;
}
}
return NumWalkers;
}
void QMCDriverFactory::createQMCDriver(xmlNodePtr cur)
{
///////////////////////////////////////////////
// get primaryPsi and primaryH
///////////////////////////////////////////////
TrialWaveFunction* primaryPsi= 0;
QMCHamiltonian* primaryH=0;
queue<TrialWaveFunction*> targetPsi;//FIFO
queue<QMCHamiltonian*> targetH;//FIFO
xmlNodePtr tcur=cur->children;
while(tcur != NULL)
{
if(xmlStrEqual(tcur->name,(const xmlChar*)"qmcsystem"))
{
const xmlChar* t= xmlGetProp(tcur,(const xmlChar*)"wavefunction");
if(t != NULL)
{
targetPsi.push(psiPool->getWaveFunction((const char*)t));
}
else
{
app_warning() << " qmcsystem does not have wavefunction. Assign 0" << endl;
targetPsi.push(0);
}
t= xmlGetProp(tcur,(const xmlChar*)"hamiltonian");
if(t != NULL)
{
targetH.push(hamPool->getHamiltonian((const char*)t));
}
else
{
app_warning() << " qmcsystem does not have hamiltonian. Assign 0" << endl;
targetH.push(0);
}
}
tcur=tcur->next;
}
//mark the first targetPsi and targetH as the primaries
if(targetH.empty())
{
primaryPsi=psiPool->getPrimary();
primaryH=hamPool->getPrimary();
}
else
{
primaryPsi=targetPsi.front();
targetPsi.pop();
primaryH=targetH.front();
targetH.pop();
}
//set primaryH->Primary
primaryH->setPrimary(true);
////flux is evaluated only with single-configuration VMC
//if(curRunType == VMC_RUN && !curQmcModeBits[MULTIPLE_MODE])
//{
// QMCHamiltonianBase* flux=primaryH->getHamiltonian("Flux");
// if(flux == 0) primaryH->addOperator(new ConservedEnergy,"Flux");
//}
//else
//{
// primaryH->remove("Flux");
//}
//(SPACEWARP_MODE,MULTIPE_MODE,UPDATE_MODE)
if(curRunType == VMC_RUN)
{
//VMCFactory fac(curQmcModeBits[UPDATE_MODE],cur);
VMCFactory fac(curQmcModeBits.to_ulong(),cur);
qmcDriver = fac.create(*qmcSystem,*primaryPsi,*primaryH,*ptclPool,*hamPool,*psiPool);
//TESTING CLONE
//TrialWaveFunction* psiclone=primaryPsi->makeClone(*qmcSystem);
//qmcDriver = fac.create(*qmcSystem,*psiclone,*primaryH,*ptclPool,*hamPool);
}
else if(curRunType == DMC_RUN)
{
DMCFactory fac(curQmcModeBits[UPDATE_MODE],
curQmcModeBits[GPU_MODE], cur);
qmcDriver = fac.create(*qmcSystem,*primaryPsi,*primaryH,*hamPool,*psiPool);
}
else if(curRunType == OPTIMIZE_RUN)
{
QMCOptimize *opt = new QMCOptimize(*qmcSystem,*primaryPsi,*primaryH,*hamPool,*psiPool);
//ZeroVarianceOptimize *opt = new ZeroVarianceOptimize(*qmcSystem,*primaryPsi,*primaryH );
opt->setWaveFunctionNode(psiPool->getWaveFunctionNode("psi0"));
qmcDriver=opt;
}
else if(curRunType == LINEAR_OPTIMIZE_RUN)
{
QMCFixedSampleLinearOptimize *opt = new QMCFixedSampleLinearOptimize(*qmcSystem,*primaryPsi,*primaryH,*hamPool,*psiPool);
//ZeroVarianceOptimize *opt = new ZeroVarianceOptimize(*qmcSystem,*primaryPsi,*primaryH );
opt->setWaveFunctionNode(psiPool->getWaveFunctionNode("psi0"));
qmcDriver=opt;
}
else if(curRunType == CS_LINEAR_OPTIMIZE_RUN)
{
#if defined(QMC_CUDA)
app_log() << "cslinear is not supported. Switch to linear method. " << endl;
QMCFixedSampleLinearOptimize *opt = new QMCFixedSampleLinearOptimize(*qmcSystem,*primaryPsi,*primaryH,*hamPool,*psiPool);
#else
QMCCorrelatedSamplingLinearOptimize *opt = new QMCCorrelatedSamplingLinearOptimize(*qmcSystem,*primaryPsi,*primaryH,*hamPool,*psiPool);
#endif
opt->setWaveFunctionNode(psiPool->getWaveFunctionNode("psi0"));
qmcDriver=opt;
}
else
{
WARNMSG("Testing wavefunctions. Creating WaveFunctionTester for testing");
qmcDriver = new WaveFunctionTester(*qmcSystem,*primaryPsi,*primaryH,
*ptclPool,*psiPool);
}
if(curQmcModeBits[MULTIPLE_MODE])
{
while(targetH.size())
{
qmcDriver->add_H_and_Psi(targetH.front(),targetPsi.front());
targetH.pop();
targetPsi.pop();
}
}
}
SPOSetBase*
PWOrbitalBuilder::createPW(xmlNodePtr cur, int spinIndex)
{
int nb=targetPtcl.last(spinIndex)-targetPtcl.first(spinIndex);
vector<int> occBand(nb);
for(int i=0;i<nb; i++) occBand[i]=i;
typedef PWBasis::GIndex_t GIndex_t;
GIndex_t nG(1);
bool transform2grid=false;
cur=cur->children;
while(cur != NULL)
{
string cname((const char*)(cur->name));
if(cname == "transform")
{
putContent(nG,cur);
transform2grid=true;
}
else if(cname == "occupation")
{
string occMode("ground");
int bandoffset(1);
OhmmsAttributeSet aAttrib;
aAttrib.add(spinIndex,"spindataset");
aAttrib.add(occMode,"mode");
aAttrib.add(bandoffset,"offset"); /* reserved for index offset */
aAttrib.put(cur);
if(occMode == "excited")
{
vector<int> occ;
vector<int> deleted, added;
putContent(occ,cur);
for(int i=0; i<occ.size(); i++)
{
if(occ[i]<0)
deleted.push_back(-occ[i]);
else
added.push_back(occ[i]);
}
if(deleted.size() != added.size())
{
app_error() << " Numbers of deleted and added bands are not identical." << endl;
OHMMS::Controller->abort();
}
for(int i=0; i<deleted.size(); i++)
{
occBand[deleted[i]-bandoffset]=added[i]-bandoffset;
}
app_log() << " mode=\"excited\" Occupied states: " << endl;
std::copy(occBand.begin(),occBand.end(),ostream_iterator<int>(app_log()," "));
app_log() << endl;
}
}
cur=cur->next;
}
string tname=myParam->getTwistName();
hid_t es_grp_id = H5Gopen(hfileID,myParam->eigTag.c_str());
hid_t twist_grp_id = H5Gopen(es_grp_id,tname.c_str());
//create a single-particle orbital set
SPOSetType* psi=new SPOSetType;
if(transform2grid)
{
nb=myParam->numBands;
occBand.resize(nb);
for(int i=0;i<nb; i++) occBand[i]=i;
}
//going to take care of occ
psi->resize(myBasisSet,nb,true);
if(myParam->hasComplexData(hfileID))//input is complex
{
app_log() << " PW coefficients are complex." << endl;
typedef std::vector<complex<RealType> > TempVecType;
TempVecType coefs(myBasisSet->inputmap.size());
HDFAttribIO<TempVecType> hdfobj_coefs(coefs);
int ib=0;
while(ib<nb)
{
string bname(myParam->getBandName(occBand[ib],spinIndex));
app_log() << " Reading " << myParam->eigTag << "/" << tname <<"/"<< bname << endl;
hid_t band_grp_id = H5Gopen(twist_grp_id,bname.c_str());
hdfobj_coefs.read(band_grp_id,myParam->eigvecTag.c_str());
psi->addVector(coefs,ib);
H5Gclose(band_grp_id);
++ib;
}
}
else
{
app_log() << " PW coefficients are real." << endl;
typedef std::vector<RealType> TempVecType;
TempVecType coefs(myBasisSet->inputmap.size());
HDFAttribIO<TempVecType> hdfobj_coefs(coefs);
int ib=0;
while(ib<nb)
{
string bname(myParam->getBandName(occBand[ib],spinIndex));
app_log() << " Reading " << myParam->eigTag << "/" << tname <<"/"<< bname << endl;
hid_t band_grp_id = H5Gopen(twist_grp_id,bname.c_str());
hdfobj_coefs.read(band_grp_id,myParam->eigvecTag.c_str());
psi->addVector(coefs,ib);
H5Gclose(band_grp_id);
++ib;
}
}
H5Gclose(twist_grp_id);
H5Gclose(es_grp_id);
#if defined(QMC_COMPLEX)
if(transform2grid)
{
app_warning() << " Going to transform on grid " << endl;
transform2GridData(nG,spinIndex,*psi);
}
#endif
return psi;
}
bool JastrowBuilder::addThreeBody(xmlNodePtr cur)
{
if(sourceOpt == targetPtcl.getName())
{
app_warning() << " Three-Body Jastrow Function needs a source different from " << targetPtcl.getName() << endl;
app_warning() << " Exit JastrowBuilder::addOneBody." << endl;
return false;
}
PtclPoolType::iterator pit(ptclPool.find(sourceOpt));
if(pit == ptclPool.end()) {
app_error() << " JastrowBuilder::addThreeBody requires a center. " << sourceOpt << " is invalid " << endl;
return false;
}
app_log() << " JastrowBuilder::addThreeBody source="<< sourceOpt << endl;
xmlNodePtr basisPtr=NULL;
xmlNodePtr coeffPtr=NULL;
cur = cur->xmlChildrenNode;
string diagOnly("no");
while(cur != NULL) {
string cname((const char*)(cur->name));
if(cname == basisset_tag)
{
basisPtr=cur;
}
else if(cname.find("coeff")<cname.size())
{
coeffPtr=cur;
OhmmsAttributeSet oAttrib;
oAttrib.add(diagOnly,"diagonal");
oAttrib.put(cur);
}
cur=cur->next;
}
if(basisPtr == NULL)
{
app_error() << " JastrowBuilder::addThreeBody exit. Missing <basisset/>"<< endl;
return false;
}
ParticleSet* sourcePtcl=(*pit).second;
JastrowBasisBuilder* basisBuilder =
new JastrowBasisBuilder(targetPtcl,*sourcePtcl,funcOpt,transformOpt == "yes");
basisBuilder->put(basisPtr);
if(diagOnly == "yes")
{
app_log() << "\n creating Three-Body Jastrow function using only diagnoal blocks." << endl;
ThreeBodyBlockSparse* J3 = new ThreeBodyBlockSparse(*sourcePtcl, targetPtcl);
J3->setBasisSet(basisBuilder->myBasisSet);
J3->put(coeffPtr,targetPsi.VarList);
J3->setBlocks(basisBuilder->SizeOfBasisPerCenter);
targetPsi.addOrbital(J3);
}
else
{
app_log() << "\n creating Three-Body Jastrow function using a complete Geminal matrix." << endl;
ThreeBodyGeminal* J3 = new ThreeBodyGeminal(*sourcePtcl, targetPtcl);
J3->setBasisSet(basisBuilder->myBasisSet);
J3->put(coeffPtr,targetPsi.VarList);
targetPsi.addOrbital(J3);
}
//if(jbuilder)
//{
// jbuilder->put(cur);
// Children.push_back(jbuilder);
// return true;
//}
// } else if (jasttype == "Three-Body-Pade") {
// app_log() << "\n creating Three-Body-Pade Jastrow function " << endl;
// string source_name("i");
// const xmlChar* iptr = xmlGetProp(cur, (const xmlChar *)"source");
// //if(iptr != NULL) source_name=(const char*)iptr;
// PtclPoolType::iterator pit(ptclPool.find(source_name));
// if(pit != ptclPool.end()) {
// jbuilder = new ThreeBodyPadeBuilder(*targetPtcl,*targetPsi,*((*pit).second));
// }
// }
return true;
}
bool JastrowBuilder::addTwoBody(xmlNodePtr cur)
{
app_log() << " JastrowBuilder::addTwoBody "<< endl;
bool success=false;
bool useSpline = (targetPtcl.Lattice.BoxBConds[0] && transformOpt == "yes");
bool ignoreSpin = (spinOpt == "no");
OrbitalConstraintsBase* control=0;
if(funcOpt == "any")
{
app_log() << " Using generic Jastrow Function Builder " <<endl;
control=new AnyConstraints(targetPtcl,targetPsi);
}
else if(funcOpt == "pade")
{
app_log() << " Using analytic Pade Jastrow Functor " <<endl;
control = new PadeConstraints(targetPtcl,targetPsi,ignoreSpin);
}
else if(funcOpt == "rpa")
{
if(targetPtcl.Lattice.SuperCellEnum == SUPERCELL_OPEN)
{
app_warning() << " RPA is requested for an open system. Please choose other functors." << endl;
return false;
}
else
control = new RPAPBCConstraints(targetPtcl,targetPsi,ignoreSpin);
}
else if(funcOpt == "poly")
{
app_log() << " Using analytic Polynomial expansion Jastrow Functor " <<endl;
control = new PolyConstraints(targetPtcl,targetPsi,ignoreSpin);
}
else if(funcOpt == "scaledpade")
{
app_log() << " Using analytic Scaled Pade Jastrow Functor " <<endl;
control = new ScaledPadeConstraints(targetPtcl,targetPsi,ignoreSpin);
}
else //known analytic function
{
OrbitalBuilderBase* jbuilder=0;
jbuilder = new JAABuilder(targetPtcl,targetPsi);
Children.push_back(jbuilder);
return jbuilder->put(cur);
}
success=control->put(cur);
if(!success) {
app_error() << " Failed to buld " << nameOpt << " Jastrow function " << endl;
delete control;
return false;
}
OrbitalBase* j2=control->createTwoBody();
if(j2== 0) {
app_error() << " JastrowBuilder::addTwoBody failed to create a two body Jastrow" << endl;
delete control;
}
enum {MULTIPLE=0, LONGRANGE, ONEBODY, TWOBODY, THREEBODY, FOURBODY};
if(control->JComponent[MULTIPLE])
{
//create a combo orbital
ComboOrbital* jcombo=new ComboOrbital(control);
jcombo->Psi.push_back(j2);
if(control->JComponent[ONEBODY] && sourceOpt != targetPtcl.getName())
{
app_log() << " Adding one-body Jastrow function dependent upon two-body " << funcOpt << endl;
map<string,ParticleSet*>::iterator pa_it(ptclPool.find(sourceOpt));
if(pa_it != ptclPool.end())
{
OrbitalBase* j1=control->createOneBody(*((*pa_it).second));
if(j1) jcombo->Psi.push_back(j1);
}
}
if(control->JComponent[LONGRANGE])
{
app_log() << " Adding long-range component of " << funcOpt << " Jastrow function "<< endl;
control->addExtra2ComboOrbital(jcombo);
}
targetPsi.addOrbital(jcombo);
}
else
{
targetPsi.addOrbital(j2);
}
control->addOptimizables(targetPsi.VarList);
Children.push_back(control);
return success;
}
/** evaluate curData and mark the bad/good walkers
*/
void WalkerControlBase::sortWalkers(MCWalkerConfiguration& W) {
MCWalkerConfiguration::iterator it(W.begin());
vector<Walker_t*> bad;
NumWalkers=0;
MCWalkerConfiguration::iterator it_end(W.end());
RealType esum=0.0,e2sum=0.0,wsum=0.0,ecum=0.0, w2sum=0.0;
RealType r2_accepted=0.0,r2_proposed=0.0;
//RealType sigma=std::max(5.0*targetVar,targetEnergyBound);
//RealType ebar= targetAvg;
while(it != it_end)
{
r2_accepted+=(*it)->Properties(R2ACCEPTED);
r2_proposed+=(*it)->Properties(R2PROPOSED);
RealType e((*it)->Properties(LOCALENERGY));
int nc= std::min(static_cast<int>((*it)->Multiplicity),MaxCopy);
/// HACK HACK HACK
//RealType wgt((*it)->Weight);
RealType wgt = (RealType)nc;
esum += wgt*e;
e2sum += wgt*e*e;
wsum += wgt;
w2sum += wgt*wgt;
ecum += e;
if(nc)
{
NumWalkers += nc;
good_w.push_back(*it);
ncopy_w.push_back(nc-1);
} else {
bad.push_back(*it);
}
++it;
}
//temp is an array to perform reduction operations
std::fill(curData.begin(),curData.end(),0);
//evaluate variance of this block
//curVar=(e2sum-esum*esum/wsum)/wsum;
//THIS IS NOT USED ANYMORE:BELOW
//if(curVar>sigma) {
// app_error() << "Unphysical block variance is detected. Stop simulations." << endl;
// Write2XYZ(W);
// //Does not work some reason
// //OHMMS::Controller->abort();
//#if defined(HAVE_MPI)
// OOMPI_COMM_WORLD.Abort();
//#else
// abort();
//#endif
// }
//THIS IS NOT USED ANYMORE:ABOVE
//update curData
curData[ENERGY_INDEX]=esum;
curData[ENERGY_SQ_INDEX]=e2sum;
curData[WALKERSIZE_INDEX]=W.getActiveWalkers();
curData[WEIGHT_INDEX]=wsum;
curData[EREF_INDEX]=ecum;
curData[R2ACCEPTED_INDEX]=r2_accepted;
curData[R2PROPOSED_INDEX]=r2_proposed;
////this should be move
//W.EnsembleProperty.NumSamples=curData[WALKERSIZE_INDEX];
//W.EnsembleProperty.Weight=curData[WEIGHT_INDEX];
//W.EnsembleProperty.Energy=(esum/=wsum);
//W.EnsembleProperty.Variance=(e2sum/wsum-esum*esum);
//W.EnsembleProperty.Variance=(e2sum*wsum-esum*esum)/(wsum*wsum-w2sum);
//remove bad walkers empty the container
for(int i=0; i<bad.size(); i++) delete bad[i];
if(good_w.empty()) {
app_error() << "All the walkers have died. Abort. " << endl;
APP_ABORT("WalkerControlBase::sortWalkers");
}
int sizeofgood = good_w.size();
//check if the projected number of walkers is too small or too
//large
if(NumWalkers>Nmax) {
int nsub=0;
int nsub_target=NumWalkers-static_cast<int>(0.9*Nmax);
int i=0;
while(i< sizeofgood && nsub<nsub_target) {
if(ncopy_w[i]) {
ncopy_w[i]--;
nsub++;
}
++i;
}
NumWalkers -= nsub;
} else if(NumWalkers < Nmin) {
int nadd=0;
int nadd_target = static_cast<int>(Nmin*1.1)-NumWalkers;
if(nadd_target> sizeofgood) {
app_warning() << "The number of walkers is running low. Requested walkers "
<< nadd_target << " good walkers = " << sizeofgood << endl;
}
int i=0;
while(i< sizeofgood && nadd<nadd_target) {
ncopy_w[i]++;
++nadd;
++i;
}
NumWalkers += nadd;
}
}
void QMCDriverFactory::createQMCDriver(xmlNodePtr cur)
{
///////////////////////////////////////////////
// get primaryPsi and primaryH
///////////////////////////////////////////////
TrialWaveFunction* primaryPsi= 0;
QMCHamiltonian* primaryH=0;
queue<TrialWaveFunction*> targetPsi;//FIFO
queue<QMCHamiltonian*> targetH;//FIFO
xmlNodePtr tcur=cur->children;
while(tcur != NULL)
{
if(xmlStrEqual(tcur->name,(const xmlChar*)"qmcsystem"))
{
const xmlChar* t= xmlGetProp(tcur,(const xmlChar*)"wavefunction");
if(t != NULL)
{
targetPsi.push(psiPool->getWaveFunction((const char*)t));
}
else
{
app_warning() << " qmcsystem does not have wavefunction. Assign 0" << endl;
targetPsi.push(0);
}
t= xmlGetProp(tcur,(const xmlChar*)"hamiltonian");
if(t != NULL)
{
targetH.push(hamPool->getHamiltonian((const char*)t));
}
else
{
app_warning() << " qmcsystem does not have hamiltonian. Assign 0" << endl;
targetH.push(0);
}
}
tcur=tcur->next;
}
//mark the first targetPsi and targetH as the primaries
if(targetH.empty())
{
primaryPsi=psiPool->getPrimary();
primaryH=hamPool->getPrimary();
}
else
{
primaryPsi=targetPsi.front(); targetPsi.pop();
primaryH=targetH.front();targetH.pop();
}
//set primaryH->Primary
primaryH->setPrimary(true);
//flux is evaluated only with single-configuration VMC
if(curRunType == VMC_RUN && !curQmcModeBits[MULTIPLE_MODE])
{
QMCHamiltonianBase* flux=primaryH->getHamiltonian("Flux");
if(flux == 0) primaryH->addOperator(new ConservedEnergy,"Flux");
}
else
{
primaryH->remove("Flux");
}
//(SPACEWARP_MODE,MULTIPE_MODE,UPDATE_MODE)
if(curRunType == VMC_RUN)
{
//VMCFactory fac(curQmcModeBits[UPDATE_MODE],cur);
VMCFactory fac(curQmcModeBits.to_ulong(),cur);
qmcDriver = fac.create(*qmcSystem,*primaryPsi,*primaryH,*ptclPool,*hamPool);
}
else if(curRunType == DMC_RUN)
{
DMCFactory fac(curQmcModeBits[UPDATE_MODE],cur);
qmcDriver = fac.create(*qmcSystem,*primaryPsi,*primaryH,*hamPool);
}
else if(curRunType == RMC_RUN)
{
#if defined(QMC_COMPLEX)
qmcDriver = new RQMCMultiple(*qmcSystem,*primaryPsi,*primaryH);
#else
if(curQmcModeBits[SPACEWARP_MODE])
qmcDriver = new RQMCMultiWarp(*qmcSystem,*primaryPsi,*primaryH, *ptclPool);
else
qmcDriver = new RQMCMultiple(*qmcSystem,*primaryPsi,*primaryH);
#endif
}
else if(curRunType == OPTIMIZE_RUN)
{
QMCOptimize *opt = new QMCOptimize(*qmcSystem,*primaryPsi,*primaryH,*hamPool);
opt->setWaveFunctionNode(psiPool->getWaveFunctionNode("null"));
qmcDriver=opt;
}
else
{
WARNMSG("Testing wavefunctions. Creating WaveFunctionTester for testing")
qmcDriver = new WaveFunctionTester(*qmcSystem,*primaryPsi,*primaryH);
}
if(curQmcModeBits[MULTIPLE_MODE])
{
while(targetH.size())
{
qmcDriver->add_H_and_Psi(targetH.front(),targetPsi.front());
targetH.pop();
targetPsi.pop();
}
}
}
