void Write2XYZ(MCWalkerConfiguration& W)
{
ofstream fout("bad.xyz");
MCWalkerConfiguration::iterator it(W.begin());
MCWalkerConfiguration::iterator it_end(W.end());
int nptcls(W.getTotalNum());
while(it != it_end) {
fout << nptcls << endl
<< "# E = " << (*it)->Properties(LOCALENERGY)
<< " Wgt= " << (*it)->Weight << endl;
for(int i=0; i<nptcls; i++)
fout << "H " << (*it)->R[i] << endl;
++it;
}
}
bool
HDFWalkerInputCollect::read(MCWalkerConfiguration& W, int firstConf, int lastConf) {
int myID = OHMMS::Controller->mycontext();
hid_t mastercf = H5Gopen(fileID,"config_collection");
char confName[128];
char coordName[128];
#if H5_VERS_RELEASE < 4
hssize_t offset[3];
#else
hsize_t offset[3];
#endif
hsize_t dimIn[3],dimTot[3];
offset[0]=0;
offset[1]=0;
offset[2]=0;
typedef MCWalkerConfiguration::PosType PosType;
vector<PosType> pos;
int nwRead=0;
for(int iconf=firstConf; iconf<lastConf; iconf++) {
sprintf(coordName,"config%04d/coord",iconf);
hid_t dataset = H5Dopen(mastercf,coordName);
hid_t dataspace = H5Dget_space(dataset);
int rank = H5Sget_simple_extent_ndims(dataspace);
int status_n = H5Sget_simple_extent_dims(dataspace, dimTot, NULL);
if(CollectMode) {
distribute(dimTot[0]);
} else {
OffSet[myID]=0;
OffSet[myID+1]=dimTot[0];
}
//get the input dimension
dimIn[0]=OffSet[myID+1]-OffSet[myID];
dimIn[1]=dimTot[1];
dimIn[2]=dimTot[2];
offset[0]=OffSet[myID];
vector<PosType> posIn(dimIn[0]*dimIn[1]);
hid_t memspace = H5Screate_simple(3, dimIn, NULL);
herr_t status = H5Sselect_hyperslab(dataspace,H5S_SELECT_SET, offset,NULL,dimIn,NULL);
status = H5Dread(dataset, H5T_NATIVE_DOUBLE, memspace, dataspace, H5P_DEFAULT, &(posIn[0][0]));
H5Sclose(memspace);
H5Dclose(dataset);
H5Sclose(dataspace);
pos.insert(pos.end(), posIn.begin(), posIn.end());
nwRead += dimIn[0];
}
H5Gclose(mastercf);
int curWalker = W.getActiveWalkers();
int nptcl=W.getTotalNum();
if(curWalker) {
W.createWalkers(nwRead);
} else {
W.resize(nwRead,nptcl);
}
MCWalkerConfiguration::iterator it = W.begin()+curWalker;
int ii=0;
for(int iw=0; iw<nwRead; iw++) {
//std::copy(Post_temp[iw],Post_temp[iw+1], (*it)->R.begin());
for(int iat=0; iat < nptcl; iat++,ii++) {
(*it)->R(iat) = pos[ii];
}
++it;
}
return true;
}
int main(int argc, char **argv) {
using namespace ohmmsqmc;
xmlDocPtr m_doc;
xmlNodePtr m_root;
xmlXPathContextPtr m_context;
enum {SourceIndex = DistanceTableData::SourceIndex};
OHMMS::Controller->initialize(argc,argv);
OhmmsInfo welcome(argc,argv,OHMMS::Controller->mycontext());
///project description
OHMMS::ProjectData myProject;
///random number controller
OHMMS::RandomNumberControl myRandomControl;
if(argc>1) {
// build an XML tree from a the file;
LOGMSG("Opening file " << argv[1])
m_doc = xmlParseFile(argv[1]);
if (m_doc == NULL) {
ERRORMSG("File " << argv[1] << " is invalid")
xmlFreeDoc(m_doc);
return 1;
}
// Check the document is of the right kind
m_root = xmlDocGetRootElement(m_doc);
if (m_root == NULL) {
ERRORMSG("Empty document");
xmlFreeDoc(m_doc);
return 1;
}
} else {
WARNMSG("No argument is given. Assume that does not need an input file")
}
m_context = xmlXPathNewContext(m_doc);
xmlXPathObjectPtr result
= xmlXPathEvalExpression((const xmlChar*)"//project",m_context);
if(xmlXPathNodeSetIsEmpty(result->nodesetval)) {
WARNMSG("Project is not defined")
myProject.reset();
} else {
myProject.put(result->nodesetval->nodeTab[0]);
}
xmlXPathFreeObject(result);
//initialize the random number generator
xmlNodePtr rptr = myRandomControl.initialize(m_context);
if(rptr) {
xmlAddChild(m_root,rptr);
}
///the ions
ParticleSet ion;
MCWalkerConfiguration el;
el.setName("e");
int iu = el.Species.addSpecies("u");
int id = el.Species.addSpecies("d");
int icharge = el.Species.addAttribute("charge");
el.Species(icharge,iu) = -1;
el.Species(icharge,id) = -1;
bool init_els = determineNumOfElectrons(el,m_context);
result
= xmlXPathEvalExpression((const xmlChar*)"//particleset",m_context);
xmlNodePtr el_ptr=NULL, ion_ptr=NULL;
for(int i=0; i<result->nodesetval->nodeNr; i++) {
xmlNodePtr cur=result->nodesetval->nodeTab[i];
xmlChar* aname= xmlGetProp(cur,(const xmlChar*)"name");
if(aname) {
char fc = aname[0];
if(fc == 'e') {
el_ptr=cur;
}
else if(fc == 'i') {
ion_ptr=cur;
}
}
}
bool donotresize = false;
if(init_els) {
el.setName("e");
XMLReport("The configuration for electrons is already determined by the wave function")
donotresize = true;
}
if(el_ptr) {
XMLParticleParser pread(el,donotresize);
pread.put(el_ptr);
}
if(ion_ptr) {
XMLParticleParser pread(ion);
pread.put(ion_ptr);
}
xmlXPathFreeObject(result);
if(!ion.getTotalNum()) {
ion.setName("i");
ion.create(1);
ion.R[0] = 0.0;
}
//The ion-ion distance-table
DistanceTableData* d_ii = DistanceTable::getTable(DistanceTable::add(ion));
d_ii->create(1);
d_ii->evaluate(ion);
vector<double> Cut, Core;
int Centers = ion.getTotalNum();
//attribute id for cut
int icut = ion.Species.addAttribute("cut");
//store the max distance from atom
Cut.resize(Centers);
for(int iat=0; iat<Centers; iat++) {
int id = ion.GroupID[iat];
Cut[iat] = ion.Species(icut,id);
}
int icore = ion.Species.addAttribute("core");
//store the max distance from atom
Core.resize(Centers);
for(int iat=0; iat<Centers; iat++) {
Core[iat]=ion.Species(icore,ion.GroupID[iat]);
}
//3N-dimensional Gaussian
ParticleSet::ParticlePos_t chi(el.getTotalNum());
makeGaussRandom(chi);
//determine if odd or even number of particles
int irem = el.getTotalNum()%2;
int ihalf = el.getTotalNum()/2;
//assign the core
int ncore(0);
for(int iat=0; iat<Centers; iat++) {
double sep=0.8*Cut[iat];
for(int iel=0; iel<Core[iat]/2; iel++,ncore++) {
el.R[ncore]=ion.R[iat]+sep*chi[ncore];
el.R[ncore+ihalf]=ion.R[iat]+sep*chi[ncore+ihalf];
}
}
int ipart = ncore;
int isave_iat=0;
for(int iat=0; iat<Centers; iat++) {
for(int nn=d_ii->M[iat]; nn<d_ii->M[iat+1]; nn++) {
double bondlength = d_ii->r(nn);
int jat = d_ii->J[nn];
//only assign if the half bond-length < cutoff
if(bondlength < Cut[iat]+Cut[jat]) {
if(ipart < ihalf) {
XMLReport("Assigning particles = " << ipart << " and " << ipart+ihalf)
/*place 2 electrons (an up and a down) at half
the bond-length plus a random number multiplied
by 10% of the bond-length*/
el.R[ipart] = ion.R[iat]+0.5*d_ii->dr(nn)+0.1*bondlength*chi[ipart];
el.R[ipart+ihalf] = ion.R[iat]+0.5*d_ii->dr(nn)+0.1*bondlength*chi[ipart+ihalf];
ipart++;
isave_iat = iat;
}
}
}
}
//assign the last particle (if odd number of particles)
int flag = 1;
ipart = el.getTotalNum()-1;
if(irem) {
XMLReport("Assigning last particle.")
for(int iat = isave_iat+1; iat<Centers; iat++) {
for(int nn=d_ii->M[iat]; nn<d_ii->M[iat+1]; nn++) {
double bondlength = d_ii->r(nn);
if((0.5*bondlength < Cut[iat]) && flag) {
XMLReport("Assigning particle = " << ipart)
el.R[ipart] = ion.R[iat]+0.5*d_ii->dr(nn)+0.1*bondlength*chi[ipart];
flag = 0;
}
}
}
}
cout << "Ionic configuration : " << ion.getName() << endl;
ion.get(cout);
cout << "Electronic configuration : " << el.getName() << endl;
el.get(cout);
string newxml(myProject.CurrentRoot());
newxml.append(".ptcl.xml");
ofstream ptcl_out(newxml.c_str());
/*
ofstream molmol("assign.xyz");
molmol << Centers+el.getTotalNum() << endl;
molmol << endl;
for(int iat=0; iat<Centers; iat++)
molmol << ion.Species.speciesName[ion.GroupID[iat]] << 0.5292*ion.R[iat] << endl;
for(int ipart=0; ipart<el.getTotalNum(); ipart++)
molmol << "He" << 0.5292*el.R[ipart] << endl;
molmol.close();
*/
xmlXPathFreeContext(m_context);
xmlFreeDoc(m_doc);
int nup = el.last(0);
int ndown = el.last(1)-el.last(0);
ptcl_out << "<?xml version=\"1.0\"?>" << endl;
ptcl_out << "<particleset name=\"e\">" << endl;
ptcl_out << "<group name=\"u\" size=\"" << nup << "\">" << endl;
ptcl_out << "<parameter name=\"charge\">-1</parameter>" << endl;
ptcl_out << "<attrib name=\"position\" datatype=\"posArray\">" << endl;
for (int ipart=0; ipart<nup; ++ipart)
ptcl_out << el.R[ipart] << endl;
ptcl_out << "</attrib>" << endl;
ptcl_out << "</group>" << endl;
ptcl_out << "<group name=\"d\" size=\"" << ndown << "\">" << endl;
ptcl_out << "<parameter name=\"charge\">-1</parameter>" << endl;
ptcl_out << "<attrib name=\"position\" datatype=\"posArray\">" << endl;
for (int ipart=nup; ipart<el.getTotalNum(); ++ipart)
ptcl_out << el.R[ipart] << endl;
ptcl_out << "</attrib>" << endl;
ptcl_out << "</group>" << endl;
ptcl_out << "</particleset>" << endl;
OHMMS::Controller->finalize();
return 0;
}
ParticleSet* ParticleSetPool::createESParticleSet(xmlNodePtr cur, const string& target)
{
TinyVector<int,OHMMS_DIM> tilefactor;
Tensor<int,OHMMS_DIM> tilematrix(1,0,0,0,1,0,0,0,1);
double lr_cut=10;
string h5name;
string source("i");
string bc("p p p");
OhmmsAttributeSet attribs;
attribs.add(h5name, "href");
attribs.add(tilefactor, "tile");
attribs.add(tilematrix, "tilematrix");
attribs.add(source, "source");
attribs.add(bc, "bconds");
attribs.add(lr_cut, "LR_dim_cutoff");
attribs.put(cur);
ParticleSet* ions=getParticleSet(source);
if(ions==0)
{
ions=new MCWalkerConfiguration;
ions->setName(source);
}
//set the boundary condition
ions->Lattice.LR_dim_cutoff=lr_cut;
std::istringstream is(bc);
char c;
int idim=0;
while(!is.eof() && idim<OHMMS_DIM)
{
if(is>>c) ions->Lattice.BoxBConds[idim++]=(c=='p');
}
//initialize ions from hdf5
hid_t h5=-1;
if(myComm->rank()==0)
h5 = H5Fopen(h5name.c_str(),H5F_ACC_RDONLY,H5P_DEFAULT);
ESHDFIonsParser ap(*ions,h5,myComm);
ap.put(cur);
ap.expand(tilematrix);
if(h5>-1) H5Fclose(h5);
//failed to initialize the ions
if(ions->getTotalNum() == 0) return 0;
typedef ParticleSet::SingleParticleIndex_t SingleParticleIndex_t;
vector<SingleParticleIndex_t> grid(OHMMS_DIM,SingleParticleIndex_t(1));
ions->Lattice.reset();
ions->Lattice.makeGrid(grid);
if(SimulationCell==0)
{
SimulationCell = new ParticleSet::ParticleLayout_t(ions->Lattice);
}
//create the electrons
MCWalkerConfiguration* qp = new MCWalkerConfiguration;
qp->setName(target);
qp->Lattice.copy(ions->Lattice);
//qp->Lattice.reset();
//qp->Lattice.makeGrid(grid);
app_log() << " Simulation cell radius = " << qp->Lattice.SimulationCellRadius << endl;
app_log() << " Wigner-Seitz radius = " << qp->Lattice.WignerSeitzRadius << endl;
SimulationCell->print(app_log());
myPool[target]=qp;
myPool[source]=ions;
//addParticleSet(qp);
//addParticleSet(ions);
{//get the number of electrons per spin
vector<int> num_spin;
xmlNodePtr cur1=cur->children;
while(cur1!=NULL)
{
string cname1((const char*)cur1->name);
if(cname1 == OrbitalBuilderBase::sd_tag)
{
num_spin.clear();
xmlNodePtr cur2=cur1->children;
while(cur2!=NULL)
{
string cname2((const char*)cur2->name);
if(cname2 == OrbitalBuilderBase::det_tag)
{
int n=0;
OhmmsAttributeSet a;
a.add(n,"size");
a.put(cur2);
if(num_spin.size()<2) num_spin.push_back(n);
}
cur2=cur2->next;
}
}
cur1=cur1->next;
}
//create species
SpeciesSet& species=qp->getSpeciesSet();
//add up and down
species.addSpecies("u");
if(num_spin.size()>1) species.addSpecies("d");
int chid=species.addAttribute("charge");
for(int i=0; i<num_spin.size(); ++i) species(chid,i)=-1.0;
int mid=species.addAttribute("membersize");
for(int i=0; i<num_spin.size(); ++i) species(mid,i)=num_spin[i];
mid=species.addAttribute("mass");
for(int i=0; i<num_spin.size(); ++i) species(mid,i)=1.0;
qp->create(num_spin);
}
//name it with the target
qp->setName(target);
//assign non-trivial positions for the quanmtum particles
if(qp->Lattice.SuperCellEnum)
{
makeUniformRandom(qp->R);
qp->R.setUnit(PosUnit::LatticeUnit);
qp->convert2Cart(qp->R);
qp->createSK();
}
else
{
InitMolecularSystem mole(this);
if(ions->getTotalNum()>1)
mole.initMolecule(ions,qp);
else
mole.initAtom(ions,qp);
}
//for(int i=0; i<qp->getTotalNum(); ++i)
// cout << qp->GroupID[i] << " " << qp->R[i] << endl;
if(qp->getTotalNum() == 0 || ions->getTotalNum() == 0)
{
delete qp;
delete ions;
APP_ABORT("ParticleSetPool failed to create particlesets for the electron structure calculation");
return 0;
}
return qp;
}
// 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;
}
}
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;
}
}
int main(int argc, char **argv) {
int nblocks = 10;
int nsteps = 10000;
int nup = 1;
int ndown = 1;
int nw = 1;
RealType Tau = 0.01;
int iargc = 0;
while(iargc<argc) {
if(!strcmp(argv[iargc],"--blocks")) {
nblocks = atoi(argv[++iargc]);
} else if(!strcmp(argv[iargc],"--steps")) {
nsteps = atoi(argv[++iargc]);
} else if(!strcmp(argv[iargc],"--walkers")) {
nw = atoi(argv[++iargc]);
} else if(!strcmp(argv[iargc],"--up")) {
nup = atoi(argv[++iargc]);
} else if(!strcmp(argv[iargc],"--down")) {
ndown = atoi(argv[++iargc]);
} else if(!strcmp(argv[iargc],"--tau")) {
Tau = atof(argv[++iargc]);
}
iargc++;
}
Random.init(0,1,0);
DOMProcessor reader(argv[1]);
MCWalkerConfiguration el;
initQuantumParticle(el,reader);
///create ions
ParticleBase ion;
ion.create(1);
ion.R[0] = 0.0;
IndexType iee = DistanceTable::add(el,"ee");
IndexType iei = DistanceTable::add(ion,el,"ie");
///create a trial wave function
TrialWaveFunction Psi;
initTrialWaveFunction(Psi,reader);
nup = el.last(0);
QMCHamiltonian H;
DistanceTableData* d_ee = DistanceTable::getTable(iee);
DistanceTableData* d_ei = DistanceTable::getTable(iei);
H.add(new CoulombPotential(el.getTotalNum()), d_ei);
H.add(new HartreePotential, d_ee);
H.add(new BareKineticEnergy, NULL);
EstimatorManager Estimators;
Estimators.reset("vmc");
VMC vmc(el,Psi,H,Estimators);
vmc.initialize(nw);
vmc.run(nblocks,nsteps,Tau);
/*
Estimators.reset("dmc");
DMC dmc(el,Psi,H,Estimators);
dmc.run(nblocks,nsteps,Tau);
*/
}
