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 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);
}
}
ParticleSet::ParticleSet(const ParticleSet& p)
: UseBoundBox(p.UseBoundBox), UseSphereUpdate(p.UseSphereUpdate),IsGrouped(p.IsGrouped)
, ThreadID(0), mySpecies(p.getSpeciesSet()),SK(0), ParentTag(p.tag())
{
initBase();
initParticleSet();
assign(p); //obly the base is copied, assumes that other properties are not assignable
//need explicit copy:
Mass=p.Mass;
Z=p.Z;
ostringstream o;
o<<p.getName()<<ObjectTag;
this->setName(o.str());
app_log() << " Copying a particle set " << p.getName() << " to " << this->getName() << " groups=" << groups() << endl;
PropertyList.Names=p.PropertyList.Names;
PropertyList.Values=p.PropertyList.Values;
PropertyHistory=p.PropertyHistory;
Collectables=p.Collectables;
//construct the distance tables with the same order
//first is always for this-this paier
for (int i=1; i<p.DistTables.size(); ++i)
addTable(p.DistTables[i]->origin());
if(p.SK)
{
R.InUnit=p.R.InUnit;
createSK();
SK->DoUpdate=p.SK->DoUpdate;
}
if (p.Sphere.size())
resizeSphere(p.Sphere.size());
add_p_timer(myTimers);
myTwist=p.myTwist;
}
LocalECPotential_CUDA::LocalECPotential_CUDA
(ParticleSet& ions, ParticleSet& elns) :
LocalECPotential(ions,elns),
ElecRef(elns), IonRef(ions),
SumGPU("LocalECPotential::SumGPU"),
IGPU("LocalECPotential::IGPU")
{
SpeciesSet &sSet = ions.getSpeciesSet();
NumIonSpecies = sSet.getTotalNum();
NumIons = ions.getTotalNum();
NumElecs = elns.getTotalNum();
#ifdef QMC_CUDA
// Copy center positions to GPU, sorting by GroupID
gpu::host_vector<CUDA_PRECISION> I_host(OHMMS_DIM*NumIons);
int index=0;
for (int cgroup=0; cgroup<NumIonSpecies; cgroup++)
{
IonFirst.push_back(index);
for (int i=0; i<NumIons; i++)
{
if (ions.GroupID[i] == cgroup)
{
for (int dim=0; dim<OHMMS_DIM; dim++)
I_host[OHMMS_DIM*index+dim] = ions.R[i][dim];
SortedIons.push_back(ions.R[i]);
index++;
}
}
IonLast.push_back(index-1);
}
IGPU = I_host;
SRSplines.resize(NumIonSpecies,0);
#endif
}
CoulombPBCAB_CUDA::CoulombPBCAB_CUDA
(ParticleSet& ions, ParticleSet& elns, bool cloning) :
CoulombPBCAB(ions,elns,cloning),
ElecRef(elns), IonRef(ions),
SumGPU("CoulombPBCABTemp::SumGPU"),
IGPU("CoulombPBCABTemp::IGPU"),
L("CoulombPBCABTemp::L"),
Linv("CoulombPBCABTemp::Linv"),
kpointsGPU("CoulombPBCABTemp::kpointsGPU"),
kshellGPU("CoulombPBCABTemp::kshellGPU"),
FkGPU("CoulombPBCABTemp::FkGPU"),
RhoklistGPU("CoulombPBCABTemp::RhoklistGPU"),
RhokElecGPU("CoulombPBCABTemp::RhokElecGPU")
{
MaxGridPoints = 8191;
SpeciesSet &sSet = ions.getSpeciesSet();
NumIonSpecies = sSet.getTotalNum();
NumIons = ions.getTotalNum();
NumElecs = elns.getTotalNum();
#ifdef QMC_CUDA
gpu::host_vector<CUDA_PRECISION> LHost(9), LinvHost(9);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
{
LHost[3*i+j] = elns.Lattice.a(j)[i];
LinvHost[3*i+j] = elns.Lattice.b(i)[j];
}
L = LHost;
Linv = LinvHost;
// Copy center positions to GPU, sorting by GroupID
gpu::host_vector<CUDA_PRECISION> I_host(OHMMS_DIM*NumIons);
int index=0;
for (int cgroup=0; cgroup<NumIonSpecies; cgroup++)
{
IonFirst.push_back(index);
for (int i=0; i<NumIons; i++)
{
if (ions.GroupID[i] == cgroup)
{
for (int dim=0; dim<OHMMS_DIM; dim++)
I_host[OHMMS_DIM*index+dim] = ions.R[i][dim];
SortedIons.push_back(ions.R[i]);
index++;
}
}
IonLast.push_back(index-1);
}
IGPU = I_host;
SRSplines.resize(NumIonSpecies,0);
setupLongRangeGPU();
#endif
}
SpinDensity::SpinDensity(ParticleSet& P)
{
// get particle information
SpeciesSet& species = P.getSpeciesSet();
nspecies = species.size();
int isize = species.addAttribute("membersize");
if(isize==species.numAttributes())
APP_ABORT("StaticStructureFactor(P) Species set does not have the required attribute 'membersize'");
for(int s=0;s<nspecies;++s)
species_size.push_back(species(isize,s));
for(int s=0;s<nspecies;++s)
species_name.push_back(species.speciesName[s]);
reset();
Ptmp = &P;
}
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
}
}
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];
}
}
}
