LocalCorePolPotential::LocalCorePolPotential(ParticleSet& ions,
ParticleSet& els):
FirstTime(true), eCoreCore(0.0), IonConfig(ions), d_ie(0), d_ii(0)
{
//set the distance tables
d_ie = DistanceTable::add(ions,els);
d_ii = DistanceTable::add(ions);
nCenters = ions.getTotalNum();
nParticles = els.getTotalNum();
InpCPP.resize(IonConfig.getSpeciesSet().getTotalNum(),0);
Centers.resize(nCenters,0);
CoreCoreDipole.resize(nCenters,0.0);
CoreElDipole.resize(nCenters,nParticles);
CoreElDipole = 0.0;
}
/*void StressPBCAA::acceptMove(int active)
{
if(is_active)
{
Return_t* restrict sr_ptr=SR2[active];
Return_t* restrict pr_ptr=SR2.data()+active;
for(int iat=0; iat<NumCenters; ++iat, ++sr_ptr,pr_ptr+=NumCenters)
*pr_ptr = *sr_ptr += dSR[iat];
Value=NewValue;
}
}
*/
void StressPBCAA::initBreakup(ParticleSet& P)
{
//SpeciesSet& tspecies(PtclRef->getSpeciesSet());
SpeciesSet& tspecies(P.getSpeciesSet());
//Things that don't change with lattice are done here instead of InitBreakup()
ChargeAttribIndx = tspecies.addAttribute("charge");
MemberAttribIndx = tspecies.addAttribute("membersize");
NumCenters = P.getTotalNum();
NumSpecies = tspecies.TotalNum;
// V_const.resize(NumCenters);
Zat.resize(NumCenters);
Zspec.resize(NumSpecies);
NofSpecies.resize(NumSpecies);
for(int spec=0; spec<NumSpecies; spec++)
{
Zspec[spec] = tspecies(ChargeAttribIndx,spec);
NofSpecies[spec] = static_cast<int>(tspecies(MemberAttribIndx,spec));
}
SpeciesID.resize(NumCenters);
for(int iat=0; iat<NumCenters; iat++)
{
SpeciesID[iat]=P.GroupID[iat];
Zat[iat] = Zspec[P.GroupID[iat]];
}
AA = LRCoulombSingleton::getDerivHandler(P);
//AA->initBreakup(*PtclRef);
myConst=evalConsts();
myRcut=AA->get_rc();//Basis.get_rc();
if(rVs==0)
{
rVs = LRCoulombSingleton::createSpline4RbyVs(AA,myRcut,myGrid);
}
}
LocalECPotential::LocalECPotential(const ParticleSet& ions, ParticleSet& els):
IonConfig(ions), d_table(0)
{
NumIons=ions.getTotalNum();
d_table = DistanceTable::add(ions,els);
//allocate null
PP.resize(NumIons,0);
Zeff.resize(NumIons,1.0);
}
RandomMomDist::RandomMomDist(ParticleSet& PtclSet, const Vector<PosType>& inGVectors,
PtclChoiceBase* pcb) : DirectMomDist(pcb, PtclSet.getTotalNum()) {
GVectors.resize(inGVectors.size());
for (IndexType i = 0; i < inGVectors.size(); i++) {
GVectors[i] = inGVectors[i];
}
NofK.resize(inGVectors.size());
MomDist.resize(inGVectors.size());
}
LocalECPotential::Return_t
LocalECPotential::registerData(ParticleSet& P, BufferType& buffer)
{
PPart.resize(P.getTotalNum());
NewValue=Value=evaluateForPbyP(P);
buffer.add(PPart.begin(),PPart.end());
buffer.add(Value);
return Value;
}
void NumericalDiffOrbital::resetTargetParticleSet(ParticleSet& P)
{
int nptcls=P.getTotalNum();
dg_p.resize(nptcls);
dl_p.resize(nptcls);
dg_m.resize(nptcls);
dl_m.resize(nptcls);
gradLogPsi.resize(nptcls);
lapLogPsi.resize(nptcls);
}
/*
* Three Dimensional Momentum Distribution. This will take displacements in three dimensions
* and produce a three dimensional n(k)
*/
ThreeDimMomDist::ThreeDimMomDist(ParticleSet& PtclSet, const Vector<IndexType>& DimSizes,
PtclChoiceBase* pcb) : FFTMomentumDist<3>(pcb, PtclSet.getTotalNum()) {
TinyVector<IndexType, 3> inNumPts;
TinyVector<RealType, 3> InvSpacing;
for (IndexType i = 0; i < 3; i++) {
inNumPts[i] = DimSizes[i];
InvSpacing = 1.0 / std::sqrt(dot(PtclSet.Lattice.a(i), PtclSet.Lattice.a(i)));
}
initialize(inNumPts, InvSpacing);
}
/*
* One Dimensional Averaged Momentum Distribution. This will take displacements in three dimensions
* and produce a one dimensional n(k)
*/
AveragedOneDimMomDist::AveragedOneDimMomDist(ParticleSet& PtclSet, const Vector<IndexType>& DimSizes,
PtclChoiceBase* pcb) : FFTMomentumDist<1>(pcb, PtclSet.getTotalNum()) {
TinyVector<IndexType, 1> inIndSize;
TinyVector<RealType, 1> InvSpacing;
for (IndexType i = 0; i < 1; i++) {
inIndSize[i] = DimSizes[i];
InvSpacing = 1.0 / std::sqrt(dot(PtclSet.Lattice.a(i), PtclSet.Lattice.a(i)));
}
initialize(inIndSize, InvSpacing);
}
LocalECPotential::LocalECPotential(const ParticleSet& ions, ParticleSet& els):
IonConfig(ions)
{
NumIons=ions.getTotalNum();
myTableIndex=els.addTable(ions);
//allocate null
PPset.resize(ions.getSpeciesSet().getTotalNum(),0);
PP.resize(NumIons,0);
Zeff.resize(NumIons,0.0);
gZeff.resize(ions.getSpeciesSet().getTotalNum(),0);
}
void AnalyticDiffOrbital::resetTargetParticleSet(ParticleSet& P)
{
if(MyIndex<0) return;
for(int i=0; i<refOrbital.size(); ++i) refOrbital[i]->resetTargetParticleSet(P);
int nptcls=P.getTotalNum();
if(gradLogPsi.size()!=nptcls)
{
gradLogPsi.resize(nptcls);
lapLogPsi.resize(nptcls);
}
}
/** constructor
*\param ions the positions of the ions
*\param els the positions of the electrons
*\param psi trial wavefunction
*/
NonLocalECPotential::NonLocalECPotential
(ParticleSet& ions, ParticleSet& els,
TrialWaveFunction& psi) :
IonConfig(ions), d_table(0), Psi(psi)
{
d_table = DistanceTable::add(ions,els);
NumIons=ions.getTotalNum();
//els.resizeSphere(NumIons);
PP.resize(NumIons,0);
PPset.resize(IonConfig.getSpeciesSet().getTotalNum(),0);
}
LRTwoBodyJastrow::LRTwoBodyJastrow(ParticleSet& p, HandlerType* inHandler):
NumPtcls(0), NumSpecies(0), skRef(0) {
Optimizable=true;
handler=inHandler;
NumSpecies=p.groups();
skRef=p.SK;
handler = LRJastrowSingleton::getHandler(p);
if(skRef) {
//Rs = Omega
OneOverCellVolume = 1.0 / p.Lattice.Volume;
Omega = std::pow(3.0/(4.0*M_PI)*p.Lattice.Volume/static_cast<RealType>(p.getTotalNum()),1.0/3.0);
//Rs=std::pow(3.0/4.0/M_PI*p.Lattice.Volume/static_cast<RealType>(p.getTotalNum()),1.0/3.0);
//Omega=std::sqrt(4.0*M_PI*static_cast<RealType>(p.getTotalNum())/p.Lattice.Volume);
OneOverOmega=1.0/Omega;
FourPiOmega=4.0*M_PI*Omega;
NumPtcls=p.getTotalNum();
NumKpts=skRef->KLists.numk;
NormConstant=FourPiOmega*NumPtcls*(NumPtcls-1)*0.5;
resize();
reset();
}
}
/** constructor
*\param ions the positions of the ions
*\param els the positions of the electrons
*\param psi trial wavefunction
*/
NonLocalECPotential::NonLocalECPotential(ParticleSet& ions, ParticleSet& els,
TrialWaveFunction& psi,
bool computeForces):
IonConfig(ions), d_table(0), Psi(psi),
ComputeForces(computeForces), ForceBase(ions,els)
{
d_table = DistanceTable::add(ions,els);
NumIons=ions.getTotalNum();
//els.resizeSphere(NumIons);
PP.resize(NumIons,0);
prefix="FNL";
PPset.resize(IonConfig.getSpeciesSet().getTotalNum(),0);
PulayTerm.resize(NumIons);
}
MomentumEstimator::Return_t MomentumEstimator::evaluate(ParticleSet& P)
{
const int np=P.getTotalNum();
nofK=0.0;
compQ=0.0;
//will use temp[i].r1 for the Compton profile
const vector<DistanceTableData::TempDistType>& temp(P.DistTables[0]->Temp);
Vector<RealType> tmpn_k(nofK);
for (int s=0; s<M; ++s)
{
PosType newpos;
for (int i=0; i<OHMMS_DIM; ++i) newpos[i]=myRNG();
//make it cartesian
newpos=Lattice.toCart(newpos);
P.makeVirtualMoves(newpos); //updated: temp[i].r1=|newpos-P.R[i]|, temp[i].dr1=newpos-P.R[i]
refPsi.get_ratios(P,psi_ratios);
// for (int i=0; i<np; ++i) app_log()<<i<<" "<<psi_ratios[i].real()<<" "<<psi_ratios[i].imag()<<endl;
P.rejectMove(0); //restore P.R[0] to the orginal position
for (int ik=0; ik < kPoints.size(); ++ik)
{
for (int i=0; i<np; ++i) kdotp[i]=dot(kPoints[ik],temp[i].dr1_nobox);
eval_e2iphi(np,kdotp.data(),phases.data());
RealType nofk_here(std::real(BLAS::dot(np,phases.data(),&psi_ratios[0])));//psi_ratios.data())));
nofK[ik]+= nofk_here;
tmpn_k[ik]=nofk_here;
}
for (int iq=0; iq < compQ.size(); ++iq)
for (int i=0; i<mappedQtonofK[iq].size(); ++i)
compQ[iq] += tmpn_k[mappedQtonofK[iq][i]];
}
for (int ik=0; ik<nofK.size(); ++ik) nofK[ik] *= norm_nofK;
for (int iq=0; iq<compQ.size(); ++iq) compQ[iq] *= mappedQnorms[iq];
if (hdf5_out)
{
int j=myIndex;
for (int ik=0; ik<nofK.size(); ++ik,++j) P.Collectables[j]+= nofK[ik];
for (int iq=0; iq<compQ.size(); ++iq,++j) P.Collectables[j]+= compQ[iq];
}
return 0.0;
}
RNDiracDeterminantBaseAlternate::RealType
RNDiracDeterminantBaseAlternate::registerData(ParticleSet& P, PooledData<RealType>& buf)
{
if (NP == 0) //first time, allocate once
{
//int norb = cols();
dpsiV.resize(NumOrbitals);
d2psiV.resize(NumOrbitals);
workV1.resize(NumOrbitals);
workV2.resize(NumOrbitals);
NP=P.getTotalNum();
myG.resize(NP);
myL.resize(NP);
myG_temp.resize(NP);
myL_temp.resize(NP);
myG_alternate.resize(NP);
myL_alternate.resize(NP);
FirstAddressOfG = &myG[0][0];
LastAddressOfG = FirstAddressOfG + NP*DIM;
FirstAddressOfdV = &(dpsiM(0,0)[0]); //(*dpsiM.begin())[0]);
LastAddressOfdV = FirstAddressOfdV + NumPtcls*NumOrbitals*DIM;
}
myG=0.0;
myL=0.0;
myG_alternate=0.0;
myL_alternate=0.0;
//ValueType x=evaluate(P,myG,myL);
evaluateLog(P,myG,myL);
P.G += myG;
P.L += myL;
//add the data: determinant, inverse, gradient and laplacians
buf.add(psiM.first_address(),psiM.last_address());
buf.add(FirstAddressOfdV,LastAddressOfdV);
buf.add(d2psiM.first_address(),d2psiM.last_address());
buf.add(myL.first_address(), myL.last_address());
buf.add(FirstAddressOfG,LastAddressOfG);
buf.add(LogValue);
buf.add(alternateLogValue);
buf.add(PhaseValue);
return LogValue;
}
void TrialWaveFunction::evaluateHessian(ParticleSet & P, HessVector_t& grad_grad_psi)
{
vector<OrbitalBase*>::iterator it(Z.begin());
vector<OrbitalBase*>::iterator it_end(Z.end());
grad_grad_psi.resize(P.getTotalNum());
for (int i=0; i<Z.size(); i++)
{
HessVector_t tmp_hess(grad_grad_psi);
tmp_hess=0.0;
Z[i]->evaluateHessian(P, tmp_hess);
grad_grad_psi+=tmp_hess;
// app_log()<<"TrialWavefunction::tmp_hess = "<<tmp_hess<<endl;
// app_log()<<endl<<endl;
}
// app_log()<<" TrialWavefunction::Hessian = "<<grad_grad_psi<<endl;
}
void SpinDensity::test(int moves,ParticleSet& P)
{
app_log()<<" SpinDensity test"<<endl;
RandomGenerator_t rng;
int particles = P.getTotalNum();
int pmin = numeric_limits<int>::max();
int pmax = numeric_limits<int>::min();
for(int m=0;m<moves;++m)
{
for(int p=0;p<particles;++p)
{
PosType u;
for(int d=0;d<DIM;++d)
u[d] = rng();
P.R[p] = P.Lattice.toCart(u);
}
test_evaluate(P,pmin,pmax);
}
app_log()<<" end SpinDensity test"<<endl;
APP_ABORT("SpinDensity::test test complete");
}
DiracDeterminantBase::ValueType DiracDeterminantBase::registerData(ParticleSet& P, PooledData<RealType>& buf) {
if(NP == 0) {//first time, allocate once
//int norb = cols();
dpsiV.resize(NumOrbitals);
d2psiV.resize(NumOrbitals);
workV1.resize(NumOrbitals);
workV2.resize(NumOrbitals);
NP=P.getTotalNum();
myG.resize(NP);
myL.resize(NP);
myG_temp.resize(NP);
myL_temp.resize(NP);
FirstAddressOfG = &myG[0][0];
LastAddressOfG = FirstAddressOfG + NP*DIM;
FirstAddressOfdV = &(dpsiM(0,0)[0]); //(*dpsiM.begin())[0]);
LastAddressOfdV = FirstAddressOfdV + NumPtcls*NumOrbitals*DIM;
}
//allocate once but each walker calls this
myG=0.0;
myL=0.0;
ValueType x=evaluate(P,myG,myL);
P.G += myG;
P.L += myL;
//add the data: determinant, inverse, gradient and laplacians
buf.add(psiM.first_address(),psiM.last_address());
buf.add(FirstAddressOfdV,LastAddressOfdV);
buf.add(d2psiM.first_address(),d2psiM.last_address());
buf.add(myL.first_address(), myL.last_address());
buf.add(FirstAddressOfG,LastAddressOfG);
buf.add(CurrentDet);
return CurrentDet;
}
CoulombPBCAB::Return_t
CoulombPBCAB::evaluateForPyP(ParticleSet& P)
{
Return_t res=myConst;
#if defined(USE_REAL_STRUCT_FACTOR)
APP_ABORT("CoulombPBCAB::evaluateForPyP(ParticleSet& P)");
#else
SRpart=0.0;
const DistanceTableData* d_ab=P.DistTables[myTableIndex];
for(int iat=0; iat<NptclA; ++iat)
{
RealType z=Zat[iat];
RadFunctorType* rVs=Vat[iat];
for(int nn=d_ab->M[iat], jat=0; nn<d_ab->M[iat+1]; nn++,jat++)
{
RealType e=z*Qat[jat]*d_ab->rinv(nn)*rVs->splint(d_ab->r(nn));
SRpart[jat]+=e;
res+=e;
}
}
LRpart=0.0;
const StructFact& RhoKA(*(PtclA.SK));
const StructFact& RhoKB(*(P.SK));
// const StructFact& RhoKB(*(PtclB->SK));
for(int i=0; i<NumSpeciesA; i++)
{
RealType z=Zspec[i];
for(int jat=0; jat<P.getTotalNum(); ++jat)
{
RealType e=z*Qat[jat]*AB->evaluate(RhoKA.KLists.kshell, RhoKA.rhok[i],RhoKB.eikr[jat]);
LRpart[jat]+=e;
res+=e;
}
}
#endif
return res;
}
void CoulombPBCAB::initBreakup(ParticleSet& P)
{
SpeciesSet& tspeciesA(PtclA.getSpeciesSet());
SpeciesSet& tspeciesB(P.getSpeciesSet());
int ChargeAttribIndxA = tspeciesA.addAttribute("charge");
int MemberAttribIndxA = tspeciesA.addAttribute("membersize");
int ChargeAttribIndxB = tspeciesB.addAttribute("charge");
int MemberAttribIndxB = tspeciesB.addAttribute("membersize");
NptclA = PtclA.getTotalNum();
NptclB = P.getTotalNum();
NumSpeciesA = tspeciesA.TotalNum;
NumSpeciesB = tspeciesB.TotalNum;
//Store information about charges and number of each species
Zat.resize(NptclA);
Zspec.resize(NumSpeciesA);
Qat.resize(NptclB);
Qspec.resize(NumSpeciesB);
NofSpeciesA.resize(NumSpeciesA);
NofSpeciesB.resize(NumSpeciesB);
for(int spec=0; spec<NumSpeciesA; spec++)
{
Zspec[spec] = tspeciesA(ChargeAttribIndxA,spec);
NofSpeciesA[spec] = static_cast<int>(tspeciesA(MemberAttribIndxA,spec));
}
for(int spec=0; spec<NumSpeciesB; spec++)
{
Qspec[spec] = tspeciesB(ChargeAttribIndxB,spec);
NofSpeciesB[spec] = static_cast<int>(tspeciesB(MemberAttribIndxB,spec));
}
RealType totQ=0.0;
for(int iat=0; iat<NptclA; iat++)
totQ+=Zat[iat] = Zspec[PtclA.GroupID[iat]];
for(int iat=0; iat<NptclB; iat++)
totQ+=Qat[iat] = Qspec[P.GroupID[iat]];
// if(totQ>numeric_limits<RealType>::epsilon())
// {
// LOGMSG("PBCs not yet finished for non-neutral cells");
// OHMMS::Controller->abort();
// }
////Test if the box sizes are same (=> kcut same for fixed dimcut)
kcdifferent = (std::abs(PtclA.Lattice.LR_kc - P.Lattice.LR_kc) > numeric_limits<RealType>::epsilon());
minkc = std::min(PtclA.Lattice.LR_kc,P.Lattice.LR_kc);
//AB->initBreakup(*PtclB);
//initBreakup is called only once
//AB = LRCoulombSingleton::getHandler(*PtclB);
AB = LRCoulombSingleton::getHandler(P);
myConst=evalConsts();
myRcut=AB->get_rc();//Basis.get_rc();
// create the spline function for the short-range part assuming pure potential
if(V0==0)
{
V0 = LRCoulombSingleton::createSpline4RbyVs(AB,myRcut,myGrid);
if(Vat.size())
{
app_log() << " Vat is not empty. Something is wrong" << endl;
OHMMS::Controller->abort();
}
Vat.resize(NptclA,V0);
Vspec.resize(NumSpeciesA,0);//prepare for PP to overwrite it
}
}
CoulombPBCAB::Return_t
CoulombPBCAB::spevaluate(ParticleSet& P)
{
RealType Vsr = 0.0;
RealType Vlr = 0.0;
RealType& Vc = myConst;
Array<RealType,1>& Ve_samp = *Ve_sample;
Array<RealType,1>& Vi_samp = *Vi_sample;
Ve_samp = 0.0;
Vi_samp = 0.0;
{
//SR
const DistanceTableData &d_ab(*P.DistTables[myTableIndex]);
RealType pairpot;
RealType z;
//Loop over distinct eln-ion pairs
for(int iat=0; iat<NptclA; iat++)
{
z = .5*Zat[iat];
RadFunctorType* rVs=Vat[iat];
for(int nn=d_ab.M[iat], jat=0; nn<d_ab.M[iat+1]; ++nn,++jat)
{
pairpot = z*Qat[jat]*d_ab.rinv(nn)*rVs->splint(d_ab.r(nn));
Vi_samp(iat)+=pairpot;
Ve_samp(jat)+=pairpot;
Vsr+=pairpot;
}
}
Vsr *= 2.0;
}
{
//LR
const StructFact& RhoKA(*(PtclA.SK));
const StructFact& RhoKB(*(P.SK));
if(RhoKA.SuperCellEnum==SUPERCELL_SLAB)
{
APP_ABORT("CoulombPBCAB::spevaluate single particle traces have not been implemented for slab geometry");
}
else
{
//jtk mark: needs optimizations for USE_REAL_STRUCT_FACTOR
// will likely require new function definitions
RealType v1; //single particle energy
RealType q;
for(int i=0; i<P.getTotalNum(); ++i)
{
q=.5*Qat[i];
v1=0.0;
for(int s=0; s<NumSpeciesA; s++)
#if defined(USE_REAL_STRUCT_FACTOR)
v1+=Zspec[s]*q*AB->evaluate(RhoKA.KLists.kshell,RhoKA.rhok_r[s],RhoKA.rhok_i[s],RhoKB.eikr_r[i],RhoKB.eikr_i[i]);
#else
v1+=Zspec[s]*q*AB->evaluate(RhoKA.KLists.kshell,RhoKA.rhok[s],RhoKB.eikr[i]);
#endif
Ve_samp(i)+=v1;
Vlr+=v1;
}
for(int i=0; i<PtclA.getTotalNum(); ++i)
{
q=.5*Zat[i];
v1=0.0;
for(int s=0; s<NumSpeciesB; s++)
#if defined(USE_REAL_STRUCT_FACTOR)
v1+=Qspec[s]*q*AB->evaluate(RhoKB.KLists.kshell,RhoKB.rhok_r[s],RhoKB.rhok_i[s],RhoKA.eikr_r[i],RhoKA.eikr_i[i]);
#else
v1+=Qspec[s]*q*AB->evaluate(RhoKB.KLists.kshell,RhoKB.rhok[s],RhoKA.eikr[i]);
#endif
Vi_samp(i)+=v1;
Vlr+=v1;
}
}
}
for(int i=0; i<Ve_samp.size(); ++i)
Ve_samp(i)+=Ve_const(i);
for(int i=0; i<Vi_samp.size(); ++i)
Vi_samp(i)+=Vi_const(i);
Value = Vsr + Vlr + Vc;
#if defined(TRACE_CHECK)
RealType Vlrnow = evalLR(P);
RealType Vsrnow = evalSR(P);
RealType Vcnow = myConst;
RealType Vnow = Vlrnow+Vsrnow+Vcnow;
RealType Vesum = Ve_samp.sum();
RealType Vecsum = Ve_const.sum();
RealType Visum = Vi_samp.sum();
RealType Vicsum = Vi_const.sum();
RealType Vsum = Vesum+Visum;
RealType Vcsum = Vecsum+Vicsum;
RealType Vsrold = evalSR_old(P);
RealType Vlrold = evalLR_old(P);
RealType Vcold = evalConsts_old(false);
RealType Vcorig = evalConsts_orig(false);
if(abs(Vsum-Vnow)>TraceManager::trace_tol)
{
app_log()<<"accumtest: CoulombPBCAA::evaluate()"<<endl;
app_log()<<"accumtest: tot:"<< Vnow <<endl;
app_log()<<"accumtest: sum:"<< Vsum <<endl;
APP_ABORT("Trace check failed");
}
if(abs(Vcsum-Vcnow)>TraceManager::trace_tol)
{
app_log()<<"accumtest: CoulombPBCAA::evalConsts()"<<endl;
app_log()<<"accumtest: tot:"<< Vcnow <<endl;
app_log()<<"accumtest: sum:"<< Vcsum <<endl;
APP_ABORT("Trace check failed");
}
if(abs(Vesum-Visum)>TraceManager::trace_tol)
{
app_log()<<"sharetest: CoulombPBCAB::evaluate()"<<endl;
app_log()<<"sharetest: e share:"<< Vesum <<endl;
app_log()<<"sharetest: i share:"<< Visum <<endl;
}
if(abs(Vecsum-Vicsum)>TraceManager::trace_tol)
{
app_log()<<"sharetest: CoulombPBCAB::evalConsts()"<<endl;
app_log()<<"sharetest: e share:"<< Vecsum <<endl;
app_log()<<"sharetest: i share:"<< Vicsum <<endl;
}
if(abs(Vsrold-Vsrnow)>TraceManager::trace_tol)
{
app_log()<<"versiontest: CoulombPBCAA::evalSR()"<<endl;
app_log()<<"versiontest: old:"<< Vsrold <<endl;
app_log()<<"versiontest: mod:"<< Vsrnow <<endl;
APP_ABORT("Trace check failed");
}
if(abs(Vlrold-Vlrnow)>TraceManager::trace_tol)
{
app_log()<<"versiontest: CoulombPBCAA::evalLR()"<<endl;
app_log()<<"versiontest: old:"<< Vlrold <<endl;
app_log()<<"versiontest: mod:"<< Vlrnow <<endl;
APP_ABORT("Trace check failed");
}
if(abs(Vcold-Vcorig)>TraceManager::trace_tol ||
abs(Vcnow-Vcorig)>TraceManager::trace_tol )
{
app_log()<<"versiontest: CoulombPBCAA::evalConsts()"<<endl;
app_log()<<"versiontest: old:"<< Vcold <<endl;
app_log()<<"versiontest: orig:"<< Vcorig <<endl;
app_log()<<"versiontest: mod:"<< Vcnow <<endl;
APP_ABORT("Trace check failed");
}
#endif
return Value;
}
void SlaterDetWithBackflow::testDerivGL(ParticleSet& P)
{
// testing derivatives of G and L
app_log() <<"testing derivatives of G and L \n";
opt_variables_type wfVars,wfvar_prime;
checkInVariables(wfVars);
checkOutVariables(wfVars);
int Nvars= wfVars.size();
wfvar_prime= wfVars;
wfVars.print(cout);
vector<RealType> dlogpsi;
vector<RealType> dhpsi;
dlogpsi.resize(Nvars);
dhpsi.resize(Nvars);
ParticleSet::ParticleGradient_t G0,G1,G2;
ParticleSet::ParticleLaplacian_t L0,L1,L2;
G0.resize(P.getTotalNum());
G1.resize(P.getTotalNum());
G2.resize(P.getTotalNum());
L0.resize(P.getTotalNum());
L1.resize(P.getTotalNum());
L2.resize(P.getTotalNum());
ValueType psi0 = 1.0;
ValueType psi1 = 1.0;
ValueType psi2 = 1.0;
double dh=0.00001;
for(int k=0; k<Dets.size(); k++) {
DiracDeterminantWithBackflow* Dets_ = (DiracDeterminantWithBackflow*) Dets[k];
Dets_->testGGG(P);
for( int i=0; i<Nvars; i++) {
Dets_->testDerivFjj(P,i);
Dets_->testDerivLi(P,i);
}
}
app_log() <<"Nvars: " <<Nvars <<endl;
for(int i=0; i<Nvars; i++) {
for (int j=0; j<Nvars; j++) wfvar_prime[j]=wfVars[j];
resetParameters(wfvar_prime);
BFTrans->evaluateDerivatives(P);
G0=0.0;G1=0.0;G2=0.0;
L0=0.0;L1=0.0;L2=0.0;
for(int k=0; k<Dets.size(); k++) {
DiracDeterminantWithBackflow* Dets_ = (DiracDeterminantWithBackflow*) Dets[k];
Dets_->evaluateDerivatives(P,wfVars,dlogpsi,dhpsi,&G0,&L0,i);
}
for (int j=0; j<Nvars; j++) wfvar_prime[j]=wfVars[j];
wfvar_prime[i] = wfVars[i]+ dh;
resetParameters(wfvar_prime);
BFTrans->evaluate(P);
for(int k=0; k<Dets.size(); k++) psi1 += Dets[k]->evaluateLog(P,G1,L1);
for (int j=0; j<Nvars; j++) wfvar_prime[j]=wfVars[j];
wfvar_prime[i] = wfVars[i]- dh;
resetParameters(wfvar_prime);
BFTrans->evaluate(P);
for(int k=0; k<Dets.size(); k++) psi2 += Dets[k]->evaluateLog(P,G2,L2);
ValueType tmp=0.0;
for(int q=0; q<P.getTotalNum(); q++) tmp+=(L1[q]-L2[q])/(2*dh);
app_log() <<i <<"\n"
<<"Ldiff : " <<L0[0] <<" " <<tmp
<<" " <<L0[0]-tmp <<endl;
for(int k=0; k<P.getTotalNum(); k++) {
app_log()<<G0[k] <<endl
<<(G1[k]-G2[k])/(2*dh) <<endl
<<"Gdiff: " <<G0[k]-(G1[k]-G2[k])/(2*dh) <<endl <<endl;
}
}
resetParameters(wfVars);
//APP_ABORT("Testing bF derivs \n");
}
void
ParticleSet::randomizeFromSource (ParticleSet &src)
{
SpeciesSet& srcSpSet(src.getSpeciesSet());
SpeciesSet& spSet(getSpeciesSet());
int srcChargeIndx = srcSpSet.addAttribute("charge");
int srcMemberIndx = srcSpSet.addAttribute("membersize");
int ChargeIndex = spSet.addAttribute("charge");
int MemberIndx = spSet.addAttribute("membersize");
int Nsrc = src.getTotalNum();
int Nptcl = getTotalNum();
int NumSpecies = spSet.TotalNum;
int NumSrcSpecies = srcSpSet.TotalNum;
//Store information about charges and number of each species
vector<int> Zat, Zspec, NofSpecies, NofSrcSpecies, CurElec;
Zat.resize(Nsrc);
Zspec.resize(NumSrcSpecies);
NofSpecies.resize(NumSpecies);
CurElec.resize(NumSpecies);
NofSrcSpecies.resize(NumSrcSpecies);
for(int spec=0; spec<NumSrcSpecies; spec++)
{
Zspec[spec] = (int)round(srcSpSet(srcChargeIndx,spec));
NofSrcSpecies[spec] = (int)round(srcSpSet(srcMemberIndx,spec));
}
for(int spec=0; spec<NumSpecies; spec++)
{
NofSpecies[spec] = (int)round(spSet(MemberIndx,spec));
CurElec[spec] = first(spec);
}
int totQ=0;
for(int iat=0; iat<Nsrc; iat++)
totQ+=Zat[iat] = Zspec[src.GroupID[iat]];
app_log() << " Total ion charge = " << totQ << endl;
totQ -= Nptcl;
app_log() << " Total system charge = " << totQ << endl;
// Now, loop over ions, attaching electrons to them to neutralize
// charge
int spToken = 0;
// This is decremented when we run out of electrons in each species
int spLeft = NumSpecies;
vector<PosType> gaussRand (Nptcl);
makeGaussRandom (gaussRand);
for (int iat=0; iat<Nsrc; iat++)
{
// Loop over electrons to add, selecting round-robin from the
// electron species
int z = Zat[iat];
while (z > 0 && spLeft)
{
int sp = spToken++ % NumSpecies;
if (NofSpecies[sp])
{
NofSpecies[sp]--;
z--;
int elec = CurElec[sp]++;
app_log() << " Assigning " << (sp ? "down" : "up ")
<< " electron " << elec << " to ion " << iat
<< " with charge " << z << endl;
double radius = 0.5* std::sqrt((double)Zat[iat]);
R[elec] = src.R[iat] + radius * gaussRand[elec];
}
else
spLeft--;
}
}
// Assign remaining electrons
int ion=0;
for (int sp=0; sp < NumSpecies; sp++)
{
for (int ie=0; ie<NofSpecies[sp]; ie++)
{
int iat = ion++ % Nsrc;
double radius = std::sqrt((double)Zat[iat]);
int elec = CurElec[sp]++;
R[elec] = src.R[iat] + radius * gaussRand[elec];
}
}
}
ThreeBodySM::ValueType ThreeBodySM::evaluateLog(ParticleSet& P, ParticleSet::ParticleGradient_t& G,
ParticleSet::ParticleLaplacian_t& L) {
LogValue=0.0;
RealType dudr, d2udr2;
int nc(CenterRef.getTotalNum()), nptcl(P.getTotalNum());
//first fill the matrix AA(i,j) where j is a composite index
for(int I=0; I<nc; I++) {
BasisType& a(*ieBasis[CenterRef.GroupID[I]]);
int offset(0);
for(int nn=dist_ie->M[I]; nn<dist_ie->M[I+1]; nn++) {
RealType sep(dist_ie->r(nn));
RealType rinv(dist_ie->rinv(nn));
int i(dist_ie->J[nn]);
int offset(ieBasisOffset[I]);
for(int k=0; k<a.size(); k++,offset++) {
AA(i,offset)=a[k]->evaluate(sep,dudr,d2udr2);
dudr *= rinv;
dAA(i,offset)=dudr*dist_ie->dr(nn);
d2AA(i,offset)=d2udr2+2.0*dudr;
}
}
}
for(int i=0; i<nptcl; i++) {
for(int nn=dist_ee->M[i]; nn<dist_ee->M[i]; nn++) {
int j(dist_ee->J[nn]);
RealType sep(dist_ee->r(nn));
RealType rinv(dist_ee->rinv(nn));
for(int m=0; m<eeBasis.size(); m++) {
RealType psum=0,lapmi=0,lapmj=0;
PosType grmi,grmj;
for(int I=0; I<nc; I++) {
const Matrix<RealType>& cblock(*C(m,CenterRef.GroupID[I]));
int offsetI(ieBasisOffSet[I]);
for(int k=0; k< ieBasisSize[I],kb=offsetI; k++,kb++) {
RealType vall=0,valk=AA(i,kb);
for(int l=0; l<ieBasisSize[I],lb=offsetI; l++,lb++) {
vall += cblock(k,l)*AA(j,lb);
grmj += valk*cblock(k,l)*dAA(j,lb);
lapmj += valk*cblock(k,l)*d2AA(j,lb);
}//l
psum += valk*vall;
grmi += dAA(i,kb)*vall;
lampi += d2AA(i,kb)*vall;
}//k
}//I
RealType bm =eeBasis[m]->evaluate(sep,dudr,d2udr2);
dudr *= rinv;
PosType dbm=dudr*dist_ee->dr(nn);
RealType d2bm=d2udr2+2.0*dudr;
LogValue += bm*psum;
G[i] += bm*grmi-dbm*psum;
G[j] += bm*grmj+dbm*psum;
L[i] += b2bm*psum+bm*lapi;
L[j] += b2bm*psum+bm*lapj;
}
}
}
return LogValue;
}
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;
}
