QMCPACK: Hamiltonian group

TraceRequest request_

whether traces are being collected

Definition: OperatorBase.h:531

std::string name_

name of this object

Definition: OperatorBase.h:527

qmcplusplus::CoulombPBCAA::madelung_constant_

void contribute_array(const std::string &name, bool default_quantity=false)

Definition: TraceManager.h:198

◆ createResource()

void createResource ( ResourceCollection & collection ) const

overridevirtual

initialize a shared resource and hand it to a collection

Reimplemented from OperatorBase.

Referenced by qmcplusplus::TEST_CASE(), and qmcplusplus::test_CoulombPBCAA_3p().

◆ deleteParticleQuantities()

void deleteParticleQuantities ( )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 186 of file CoulombPBCAA.cpp.

References OperatorBase::streaming_particles_, and CoulombPBCAA::V_sample.

 {
   if (streaming_particles_)
     delete V_sample;
 }

◆ evalConsts()

Return_t evalConsts ( bool report = true )

Referenced by CoulombPBCAA::initBreakup(), and qmcplusplus::TEST_CASE().

◆ evalLR()

Return_t evalLR ( ParticleSet & P )

Referenced by CoulombPBCAA::evalLRwithForces(), CoulombPBCAA::evaluate(), CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::updateSource().

◆ evalLRwithForces()

CoulombPBCAA::Return_t evalLRwithForces ( ParticleSet & P )

Definition at line 483 of file CoulombPBCAA.cpp.

References CoulombPBCAA::dAA, CoulombPBCAA::evalLR(), ForceBase::forces_, ParticleSet::getTotalNum(), CoulombPBCAA::NumSpecies, CoulombPBCAA::Zat, and CoulombPBCAA::Zspec.

Referenced by CoulombPBCAA::updateSource().

 {
   //  const StructFact& PtclRhoK(P.getSK());
   std::vector<TinyVector<RealType, DIM>> grad(P.getTotalNum());
   for (int spec2 = 0; spec2 < NumSpecies; spec2++)
   {
     RealType Z2 = Zspec[spec2];
     for (int iat = 0; iat < grad.size(); iat++)
       grad[iat] = TinyVector<RealType, DIM>(0.0);
     //AA->evaluateGrad(P, P, spec2, Zat, grad);
     dAA->evaluateGrad(P, P, spec2, Zat, grad);
     for (int iat = 0; iat < grad.size(); iat++)
       forces_[iat] += Z2 * grad[iat];
   } //spec2
   return evalLR(P);
 }

◆ evalPerParticleConsts()

void evalPerParticleConsts ( Vector< RealType > & pp_consts ) const

private

Compute the const part of the per particle coulomb self interaction potential.

Parameters

[out] pp_consts constant values for the particles self interaction

◆ evalSR()

Return_t evalSR ( ParticleSet & P )

Referenced by CoulombPBCAA::evaluate(), CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::updateSource().

◆ evalSRwithForces()

CoulombPBCAA::Return_t evalSRwithForces ( ParticleSet & P )

Definition at line 501 of file CoulombPBCAA.cpp.

References CoulombPBCAA::d_aa_ID, ForceBase::forces_, ParticleSet::getDistTableAA(), CoulombPBCAA::NumCenters, CoulombPBCAA::rVs, CoulombPBCAA::rVsforce, and CoulombPBCAA::Zat.

Referenced by CoulombPBCAA::updateSource().

 {
   const auto& d_aa(P.getDistTableAA(d_aa_ID));
   mRealType SR = 0.0;
   for (size_t ipart = 1; ipart < (NumCenters / 2 + 1); ipart++)
   {
     mRealType esum   = 0.0;
     const auto& dist = d_aa.getDistRow(ipart);
     const auto& dr   = d_aa.getDisplRow(ipart);
     for (size_t j = 0; j < ipart; ++j)
     {
       RealType V, rV, d_rV_dr, d2_rV_dr2;
       RealType rinv = 1.0 / dist[j];
       rV            = rVsforce->splint(dist[j], d_rV_dr, d2_rV_dr2);
       V             = rV * rinv;
       esum += Zat[j] * rVs->splint(dist[j]) * rinv;
 
       PosType grad = Zat[j] * Zat[ipart] * (d_rV_dr - V) * rinv * rinv * dr[j];
       forces_[ipart] += grad;
       forces_[j] -= grad;
     }
     SR += Zat[ipart] * esum;
 
     const size_t ipart_reverse = NumCenters - ipart;
     if (ipart == ipart_reverse)
       continue;
 
     esum              = 0.0;
     const auto& dist2 = d_aa.getDistRow(ipart_reverse);
     const auto& dr2   = d_aa.getDisplRow(ipart_reverse);
     for (size_t j = 0; j < ipart_reverse; ++j)
     {
       RealType V, rV, d_rV_dr, d2_rV_dr2;
       RealType rinv = 1.0 / dist2[j];
       rV            = rVsforce->splint(dist2[j], d_rV_dr, d2_rV_dr2);
       V             = rV * rinv;
       esum += Zat[j] * rVs->splint(dist2[j]) * rinv;
 
       PosType grad = Zat[j] * Zat[ipart_reverse] * (d_rV_dr - V) * rinv * rinv * dr2[j];
       forces_[ipart_reverse] += grad;
       forces_[j] -= grad;
     }
     SR += Zat[ipart_reverse] * esum;
   }
   return SR;
 }

◆ evaluate()

CoulombPBCAA::Return_t evaluate ( ParticleSet & P )

overridevirtual

Evaluate the local energy contribution of this component.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Implements OperatorBase.

Definition at line 201 of file CoulombPBCAA.cpp.

References CoulombPBCAA::evalLR(), CoulombPBCAA::evalSR(), CoulombPBCAA::evaluate_sp(), CoulombPBCAA::is_active, CoulombPBCAA::myConst, OperatorBase::streaming_particles_, and OperatorBase::value_.

Referenced by qmcplusplus::TEST_CASE().

 {
   if (is_active)
   {
 #if !defined(REMOVE_TRACEMANAGER)
     if (streaming_particles_)
       value_ = evaluate_sp(P);
     else
 #endif
       value_ = evalLR(P) + evalSR(P) + myConst;
   }
   return value_;
 }

◆ evaluate_sp()

CoulombPBCAA::Return_t evaluate_sp ( ParticleSet & P )

Definition at line 343 of file CoulombPBCAA.cpp.

References CoulombPBCAA::AA, qmcplusplus::abs(), APP_ABORT, qmcplusplus::app_log(), CoulombPBCAA::d_aa_ID, CoulombPBCAA::evalLR(), CoulombPBCAA::evalSR(), ParticleSet::getDistTableAA(), ParticleSet::getSimulationCell(), ParticleSet::getSK(), CoulombPBCAA::myConst, CoulombPBCAA::NumCenters, CoulombPBCAA::NumSpecies, CoulombPBCAA::rVs, qmcplusplus::Units::time::s, Array< T, D, ALLOC >::size(), Array< T, D, ALLOC >::sum(), qmcplusplus::SUPERCELL_SLAB, TraceManager::trace_tol, CoulombPBCAA::V_const, CoulombPBCAA::V_sample, OperatorBase::value_, CoulombPBCAA::Zat, and CoulombPBCAA::Zspec.

Referenced by CoulombPBCAA::checkoutParticleQuantities(), and CoulombPBCAA::evaluate().

 {
   mRealType Vsr              = 0.0;
   mRealType Vlr              = 0.0;
   mRealType& Vc              = myConst;
   Array<RealType, 1>& V_samp = *V_sample;
   V_samp                     = 0.0;
   {
     //SR
     const auto& d_aa(P.getDistTableAA(d_aa_ID));
     RealType z;
     for (int ipart = 1; ipart < NumCenters; ipart++)
     {
       z                = .5 * Zat[ipart];
       const auto& dist = d_aa.getDistRow(ipart);
       for (int jpart = 0; jpart < ipart; ++jpart)
       {
         RealType pairpot = z * Zat[jpart] * rVs->splint(dist[jpart]) / dist[jpart];
         V_samp(ipart) += pairpot;
         V_samp(jpart) += pairpot;
         Vsr += pairpot;
       }
     }
     Vsr *= 2.0;
   }
   {
     //LR
     const StructFact& PtclRhoK(P.getSK());
     if (PtclRhoK.SuperCellEnum == SUPERCELL_SLAB)
     {
       APP_ABORT("CoulombPBCAA::evaluate_sp single particle traces have not been implemented for slab geometry");
     }
     else
     {
       assert(PtclRhoK.isStorePerParticle()); // ensure this so we know eikr_r has been allocated
       //jtk mark: needs optimizations
       RealType v1; //single particle energy
       RealType z;
       for (int i = 0; i < NumCenters; i++)
       {
         z  = .5 * Zat[i];
         v1 = 0.0;
         for (int s = 0; s < NumSpecies; ++s)
           v1 += z * Zspec[s] *
               AA->evaluate(P.getSimulationCell().getKLists().kshell, PtclRhoK.rhok_r[s], PtclRhoK.rhok_i[s],
                            PtclRhoK.eikr_r[i], PtclRhoK.eikr_i[i]);
         V_samp(i) += v1;
         Vlr += v1;
       }
     }
   }
   for (int i = 0; i < V_samp.size(); ++i)
     V_samp(i) += V_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 Vsum   = V_samp.sum();
   RealType Vcsum  = V_const.sum();
   if (std::abs(Vsum - Vnow) > TraceManager::trace_tol)
   {
     app_log() << "accumtest: CoulombPBCAA::evaluate()" << std::endl;
     app_log() << "accumtest:   tot:" << Vnow << std::endl;
     app_log() << "accumtest:   sum:" << Vsum << std::endl;
     APP_ABORT("Trace check failed");
   }
   if (std::abs(Vcsum - Vcnow) > TraceManager::trace_tol)
   {
     app_log() << "accumtest: CoulombPBCAA::evalConsts()" << std::endl;
     app_log() << "accumtest:   tot:" << Vcnow << std::endl;
     app_log() << "accumtest:   sum:" << Vcsum << std::endl;
     APP_ABORT("Trace check failed");
   }
 #endif
   return value_;
 }

◆ evaluateWithIonDerivs()

CoulombPBCAA::Return_t evaluateWithIonDerivs	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_term,
		ParticleSet::ParticlePos &	pulay_term
	)

overridevirtual

Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase.

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Adds OperatorBase's contribution to Re [(dH)Psi]/Psi
pulay_terms	Adds OperatorBase's contribution to Re [(H-E_L)dPsi]/Psi

Returns: Contribution of OperatorBase to Local Energy.

Reimplemented from OperatorBase.

Definition at line 330 of file CoulombPBCAA.cpp.

References CoulombPBCAA::ComputeForces, ForceBase::forces_, CoulombPBCAA::is_active, and OperatorBase::value_.

Referenced by qmcplusplus::TEST_CASE().

 {
   if (ComputeForces and !is_active)
     hf_terms -= forces_;
   //No pulay term.
   return value_;
 }

◆ get()

bool get ( std::ostream & os ) const

inlineoverridevirtual

write about the class

Implements OperatorBase.

Definition at line 127 of file CoulombPBCAA.h.

References CoulombPBCAA::PtclRefName.

   {
     os << "CoulombPBCAA potential: " << PtclRefName;
     return true;
   }

◆ get_madelung_constant()

RealType get_madelung_constant ( ) const

inline

Definition at line 185 of file CoulombPBCAA.h.

References CoulombPBCAA::madelung_constant_.

Referenced by qmcplusplus::TEST_CASE(), and qmcplusplus::test_CoulombPBCAA_3p().

185 { return madelung_constant_; }

RealType madelung_constant_

Definition: CoulombPBCAA.h:188

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements OperatorBase.

Definition at line 96 of file CoulombPBCAA.h.

96 { return "CoulombPBCAA"; }

◆ informOfPerParticleListener()

void informOfPerParticleListener ( )

overridevirtual

Inform objects associated with this operator of per particle listeners.

i.e. turnOnPerParticleSK of particleset qp.

Reimplemented from OperatorBase.

Definition at line 193 of file CoulombPBCAA.cpp.

References OperatorBase::informOfPerParticleListener(), CoulombPBCAA::Ps, and ParticleSet::turnOnPerParticleSK().

Referenced by qmcplusplus::TEST_CASE().

 {
   // turnOnParticleSK is written so it can be called again and again.
   Ps.turnOnPerParticleSK();
   OperatorBase::informOfPerParticleListener();
 }

◆ initBreakup()

void initBreakup ( ParticleSet & P )

private

constructor code factored out

Definition at line 423 of file CoulombPBCAA.cpp.

References CoulombPBCAA::AA, qmcplusplus::app_log(), CoulombPBCAA::ChargeAttribIndx, CoulombPBCAA::ComputeForces, LRCoulombSingleton::createSpline4RbyVs(), CoulombPBCAA::dAA, CoulombPBCAA::evalConsts(), LRCoulombSingleton::getDerivHandler(), LRCoulombSingleton::getHandler(), ParticleSet::getLattice(), ParticleSet::getSpeciesSet(), ParticleSet::getTotalNum(), ParticleSet::GroupID, ParticleSet::groupsize(), CoulombPBCAA::myConst, CoulombPBCAA::myRcut, CoulombPBCAA::NofSpecies, CoulombPBCAA::NumCenters, CoulombPBCAA::NumSpecies, Array< T, D, ALLOC >::resize(), CoulombPBCAA::rVs, CoulombPBCAA::rVs_offload, CoulombPBCAA::rVsforce, LinearGrid< T, CT >::set(), CoulombPBCAA::SpeciesID, CoulombPBCAA::V_const, CoulombPBCAA::Zat, CoulombPBCAA::Zat_offload, and CoulombPBCAA::Zspec.

Referenced by CoulombPBCAA::CoulombPBCAA().

 {
   //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");
   NumCenters       = P.getTotalNum();
   NumSpecies       = tspecies.TotalNum;
 
 #if !defined(REMOVE_TRACEMANAGER)
   V_const.resize(NumCenters);
 #endif
 
   Zspec.resize(NumSpecies);
   NofSpecies.resize(NumSpecies);
   for (int spec = 0; spec < NumSpecies; spec++)
   {
     Zspec[spec]      = tspecies(ChargeAttribIndx, spec);
     NofSpecies[spec] = P.groupsize(spec);
   }
 
   SpeciesID.resize(NumCenters);
   Zat.resize(NumCenters);
   Zat_offload = std::make_shared<Vector<RealType, OffloadPinnedAllocator<RealType>>>(NumCenters);
   auto& Zat_ref(*Zat_offload);
   for (int iat = 0; iat < NumCenters; iat++)
   {
     SpeciesID[iat] = P.GroupID[iat];
     Zat[iat]       = Zspec[P.GroupID[iat]];
     Zat_ref[iat]   = Zat[iat];
   }
   Zat_ref.updateTo();
 
   AA = LRCoulombSingleton::getHandler(P);
   //AA->initBreakup(*PtclRef);
   myConst = evalConsts();
   myRcut  = AA->get_rc(); //Basis.get_rc();
 
   auto myGrid = LinearGrid<RealType>();
   int ng = P.getLattice().num_ewald_grid_points;
   app_log() << "    CoulombPBCAA::initBreakup\n  Setting a linear grid=[0,"
             << myRcut << ") number of grid points =" << ng << std::endl;
   myGrid.set(0, myRcut, ng);
 
   if (rVs == nullptr)
     rVs = LRCoulombSingleton::createSpline4RbyVs(AA.get(), myRcut, myGrid);
 
   rVs_offload = std::make_shared<const OffloadSpline>(*rVs);
 
   if (ComputeForces)
   {
     dAA = LRCoulombSingleton::getDerivHandler(P);
     if (rVsforce == nullptr)
     {
       rVsforce = LRCoulombSingleton::createSpline4RbyVs(dAA.get(), myRcut, myGrid);
     }
   }
 }

◆ makeClone()

std::unique_ptr<OperatorBase> makeClone	(	ParticleSet &	qp,
		TrialWaveFunction &	psi
	)

overridevirtual

Implements OperatorBase.

◆ mw_evalSR_offload()

static std::vector<Return_t> mw_evalSR_offload	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< ParticleSet > &	p_list
	)

static

Referenced by CoulombPBCAA::mw_evaluate().

◆ mw_evaluate()

void mw_evaluate	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list
	)		const

overridevirtual

Evaluate the contribution of this component of multiple walkers.

Take o_list and p_list update evaluation result variables in o_list? really should reduce vector of local_energies. matching the ordering and size of o list the this can be call for 1 or more QMCHamiltonians

Parameters

o_list
wf_list
p_list

Temporary raw omp pragma for simple thread parallelism ignoring the driver level concurrency

TODO: replace this with a proper abstraction. It should adequately describe the behavior and strictly limit the activation of this level concurrency to when it is intended. It is unlikely to belong in this function.

This implicitly depends on openmp work division logic. Essentially adhoc runtime crowds over which we have given up control of thread/global scope. How many walkers per thread? How to handle their data movement if any of these hamiltonians should be accelerated? We can neither reason about or describe it in C++

As I understand it it should only be required for as long as the AMD openmp offload compliler is incapable of running multiple threads. They should/must fix their compiler before delivery of frontier and it should be removed at that point at latest

If you want 16 threads of 1 walker that should be 16 crowds of 1 not one crowd of 16 with openmp thrown in at hamiltonian level. If this must be different from the other crowd batching. Make this a reasoned about and controlled level of concurency blocking at the driver level.

This is only thread safe only if each walker has a complete set of anything involved in an Operator.evaluate.

Reimplemented from OperatorBase.

Definition at line 215 of file CoulombPBCAA.cpp.

References RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), RefVectorWithLeader< T >::getLeader(), CoulombPBCAA::mw_evalSR_offload(), OperatorBase::mw_evaluate(), CoulombPBCAA::myConst, CoulombPBCAA::use_offload_, and OperatorBase::value_.

Referenced by qmcplusplus::test_CoulombPBCAA_3p().

 {
   auto& o_leader = o_list.getCastedLeader<CoulombPBCAA>();
   auto& p_leader = p_list.getLeader();
   assert(this == &o_list.getLeader());
 
   if (!o_leader.is_active)
     return;
 
   if (use_offload_)
   {
     if (o_leader.streaming_particles_)
       throw std::runtime_error("Streaming particles is not supported when offloading in CoulombPBCAA");
 
     auto short_range_results = mw_evalSR_offload(o_list, p_list);
 
     for (int iw = 0; iw < o_list.size(); iw++)
     {
       auto& coulomb_aa  = o_list.getCastedElement<CoulombPBCAA>(iw);
       coulomb_aa.value_ = coulomb_aa.evalLR(p_list[iw]) + short_range_results[iw] + myConst;
     }
   }
   else
     OperatorBase::mw_evaluate(o_list, wf_list, p_list);
 }

◆ mw_evaluatePerParticle()

void mw_evaluatePerParticle	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< ListenerVector< RealType >> &	listeners,
		const std::vector< ListenerVector< RealType >> &	ion_listeners
	)		const

overridevirtual

Evaluate the contribution of this component of multiple walkers per particle reporting to registered listeners from Estimators.

Reimplemented from OperatorBase.

Definition at line 243 of file CoulombPBCAA.cpp.

References APP_ABORT, RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), RefVectorWithLeader< T >::getLeader(), CoulombPBCAA::myConst, qmcplusplus::pset, qmcplusplus::Units::time::s, qmcplusplus::SUPERCELL_SLAB, and OperatorBase::value_.

Referenced by qmcplusplus::TEST_CASE().

 {
   auto& o_leader = o_list.getCastedLeader<CoulombPBCAA>();
   auto& p_leader = p_list.getLeader();
   assert(this == &o_list.getLeader());
 
   if (!o_leader.is_active)
     return;
 
   auto num_centers = p_leader.getTotalNum();
   auto name(o_leader.getName());
   Vector<RealType>& v_sample = o_leader.mw_res_handle_.getResource().v_sample;
   const auto& pp_consts      = o_leader.mw_res_handle_.getResource().pp_consts;
   auto num_species           = p_leader.getSpeciesSet().getTotalNum();
   v_sample.resize(num_centers);
   // This lambda is mostly about getting a handle on what is being touched by the per particle evaluation.
   auto evaluate_walker = [num_species, num_centers, name, &v_sample,
                           &pp_consts](const int walker_index, const CoulombPBCAA& cpbcaa, const ParticleSet& pset,
                                       const std::vector<ListenerVector<RealType>>& listeners) -> RealType {
     mRealType Vsr = 0.0;
     mRealType Vlr = 0.0;
     mRealType Vc  = cpbcaa.myConst;
     std::fill(v_sample.begin(), v_sample.end(), 0.0);
     {
       //SR
       const auto& d_aa(pset.getDistTableAA(cpbcaa.d_aa_ID));
       RealType z;
       for (int ipart = 1; ipart < num_centers; ipart++)
       {
         z                = .5 * cpbcaa.Zat[ipart];
         const auto& dist = d_aa.getDistRow(ipart);
         for (int jpart = 0; jpart < ipart; ++jpart)
         {
           RealType pairpot = z * cpbcaa.Zat[jpart] * cpbcaa.rVs->splint(dist[jpart]) / dist[jpart];
           v_sample[ipart] += pairpot;
           v_sample[jpart] += pairpot;
           Vsr += pairpot;
         }
       }
       Vsr *= 2.0;
     }
     {
       //LR
       const StructFact& PtclRhoK(pset.getSK());
       if (PtclRhoK.SuperCellEnum == SUPERCELL_SLAB)
       {
         APP_ABORT("CoulombPBCAA::evaluate_sp single particle traces have not been implemented for slab geometry");
       }
       else
       {
         assert(PtclRhoK.isStorePerParticle()); // ensure this so we know eikr_r has been allocated
         //jtk mark: needs optimizations
         RealType v1; //single particle energy
         RealType z;
         for (int i = 0; i < num_centers; i++)
         {
           z  = .5 * cpbcaa.Zat[i];
           v1 = 0.0;
           for (int s = 0; s < num_species; ++s)
             v1 += z * cpbcaa.Zspec[s] *
                 cpbcaa.AA->evaluate(pset.getSimulationCell().getKLists().kshell, PtclRhoK.rhok_r[s], PtclRhoK.rhok_i[s],
                                     PtclRhoK.eikr_r[i], PtclRhoK.eikr_i[i]);
           v_sample[i] += v1;
           Vlr += v1;
         }
       }
     }
     for (int i = 0; i < v_sample.size(); ++i)
       v_sample[i] += pp_consts[i];
     RealType value = Vsr + Vlr + Vc;
 
     for (const ListenerVector<RealType>& listener : listeners)
       listener.report(walker_index, name, v_sample);
     return value;
   };
 
   for (int iw = 0; iw < o_list.size(); iw++)
   {
     auto& coulomb_aa  = o_list.getCastedElement<CoulombPBCAA>(iw);
     coulomb_aa.value_ = evaluate_walker(iw, coulomb_aa, p_list[iw], listeners);
   }
 }

◆ put()

bool put ( xmlNodePtr cur )

inlineoverridevirtual

Do nothing.

Implements OperatorBase.

Definition at line 125 of file CoulombPBCAA.h.

125 { return true; }

◆ releaseResource()

void releaseResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< OperatorBase > &	o_list
	)		const

overridevirtual

return a shared resource to a collection

Reimplemented from OperatorBase.

◆ resetTargetParticleSet()

void resetTargetParticleSet ( ParticleSet & P )

overridevirtual

Reset the data with the target ParticleSet.

Parameters

P	new target ParticleSet

Implements OperatorBase.

Definition at line 161 of file CoulombPBCAA.cpp.

References CoulombPBCAA::AA, CoulombPBCAA::d_aa_ID, ParticleSet::getDistTable(), CoulombPBCAA::is_active, and CoulombPBCAA::PtclRefName.

 {
   if (is_active)
   {
     PtclRefName = P.getDistTable(d_aa_ID).getName();
     AA->resetTargetParticleSet(P);
   }
 }

◆ setObservables()

void setObservables ( PropertySetType & plist )

inlineoverridevirtual

Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_.

Parameters

plist RecordNameProperty

Reimplemented from OperatorBase.

Definition at line 159 of file CoulombPBCAA.h.

References CoulombPBCAA::ComputeForces, OperatorBase::setObservables(), and ForceBase::setObservablesF().

   {
     OperatorBase::setObservables(plist);
     if (ComputeForces)
       setObservablesF(plist);
   }

◆ setParticlePropertyList()

void setParticlePropertyList	(	PropertySetType &	plist,
		int	offset
	)

inlineoverridevirtual

Reimplemented from OperatorBase.

Definition at line 166 of file CoulombPBCAA.h.

References CoulombPBCAA::ComputeForces, OperatorBase::setParticlePropertyList(), and ForceBase::setParticleSetF().

   {
     OperatorBase::setParticlePropertyList(plist, offset);
     if (ComputeForces)
       setParticleSetF(plist, offset);
   }

◆ updateSource()

void updateSource ( ParticleSet & s )

overridevirtual

Update data associated with a particleset.

Default implementation does nothing. Only A-A interactions for s needs to implement its own method.

Parameters

s	source particle set

Reimplemented from OperatorBase.

Definition at line 144 of file CoulombPBCAA.cpp.

References CoulombPBCAA::ComputeForces, CoulombPBCAA::evalLR(), CoulombPBCAA::evalLRwithForces(), CoulombPBCAA::evalSR(), CoulombPBCAA::evalSRwithForces(), ForceBase::forces_, CoulombPBCAA::myConst, OperatorBase::new_value_, qmcplusplus::Units::time::s, and OperatorBase::value_.

Referenced by CoulombPBCAA::CoulombPBCAA().

 {
   mRealType eL(0.0), eS(0.0);
   if (ComputeForces)
   {
     forces_ = 0.0;
     eS      = evalSRwithForces(s);
     eL      = evalLRwithForces(s);
   }
   else
   {
     eL = evalLR(s);
     eS = evalSR(s);
   }
   new_value_ = value_ = eL + eS + myConst;
 }

Member Data Documentation

◆ AA

std::shared_ptr<LRHandlerType> AA

energy-optimized long range handle. Should be const LRHandlerType eventually

Definition at line 47 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::CoulombPBCAA(), CoulombPBCAA::evaluate_sp(), CoulombPBCAA::initBreakup(), and CoulombPBCAA::resetTargetParticleSet().

◆ ChargeAttribIndx

int ChargeAttribIndx

Definition at line 61 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::initBreakup().

◆ ComputeForces

bool ComputeForces

Flag for whether to compute forces or not.

Definition at line 79 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::addObservables(), CoulombPBCAA::CoulombPBCAA(), CoulombPBCAA::evaluateWithIonDerivs(), CoulombPBCAA::initBreakup(), CoulombPBCAA::setObservables(), CoulombPBCAA::setParticlePropertyList(), and CoulombPBCAA::updateSource().

◆ d_aa_ID

const int d_aa_ID

private

AA table ID.

Definition at line 193 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::CoulombPBCAA(), CoulombPBCAA::evalSRwithForces(), CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::resetTargetParticleSet().

◆ dAA

std::shared_ptr<const LRHandlerType> dAA

force-optimized long range handle

Definition at line 53 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::evalLRwithForces(), and CoulombPBCAA::initBreakup().

◆ del_eikr

Vector<ComplexType> del_eikr

Definition at line 77 of file CoulombPBCAA.h.

◆ dSR

Vector<RealType> dSR

Definition at line 76 of file CoulombPBCAA.h.

◆ evalLR_timer_

NewTimer& evalLR_timer_

private

Timer for long range.

Definition at line 195 of file CoulombPBCAA.h.

◆ evalSR_timer_

NewTimer& evalSR_timer_

private

Timer for long range.

Definition at line 197 of file CoulombPBCAA.h.

◆ FirstTime

bool FirstTime

Definition at line 58 of file CoulombPBCAA.h.

◆ is_active

bool is_active

Definition at line 57 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::checkoutParticleQuantities(), CoulombPBCAA::CoulombPBCAA(), CoulombPBCAA::evaluate(), CoulombPBCAA::evaluateWithIonDerivs(), and CoulombPBCAA::resetTargetParticleSet().

◆ madelung_constant_

RealType madelung_constant_

private

Definition at line 188 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::CoulombPBCAA(), and CoulombPBCAA::get_madelung_constant().

◆ MemberAttribIndx

int MemberAttribIndx

Definition at line 62 of file CoulombPBCAA.h.

◆ mw_res_handle_

ResourceHandle<CoulombPBCAAMultiWalkerResource> mw_res_handle_

private

Definition at line 202 of file CoulombPBCAA.h.

◆ myConst

Return_t myConst

Definition at line 64 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::evaluate(), CoulombPBCAA::evaluate_sp(), CoulombPBCAA::initBreakup(), CoulombPBCAA::mw_evaluate(), CoulombPBCAA::mw_evaluatePerParticle(), qmcplusplus::TEST_CASE(), and CoulombPBCAA::updateSource().

◆ myRcut

RealType myRcut

cutoff radius of the short-range part

Definition at line 66 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::initBreakup().

◆ NofSpecies

std::vector<int> NofSpecies

Definition at line 72 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::initBreakup().

◆ NumCenters

int NumCenters

Definition at line 63 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::CoulombPBCAA(), CoulombPBCAA::evalSRwithForces(), CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::initBreakup().

◆ NumSpecies

int NumSpecies

Definition at line 60 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::evalLRwithForces(), CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::initBreakup().

◆ offload_timer_

NewTimer& offload_timer_

private

Timer for offload part.

Definition at line 199 of file CoulombPBCAA.h.

◆ Ps

ParticleSet& Ps

Definition at line 88 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::checkoutParticleQuantities(), CoulombPBCAA::CoulombPBCAA(), and CoulombPBCAA::informOfPerParticleListener().

◆ PtclRefName

std::string PtclRefName

Definition at line 67 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::CoulombPBCAA(), CoulombPBCAA::get(), and CoulombPBCAA::resetTargetParticleSet().

◆ quasi2d

const bool quasi2d

Flag for whether to use quasi-2D Ewald.

Definition at line 81 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::CoulombPBCAA().

◆ rVs

std::shared_ptr<const RadFunctorType> rVs

energy-optimized short range pair potential

Definition at line 49 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::evalSRwithForces(), CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::initBreakup().

◆ rVs_offload

std::shared_ptr<const OffloadSpline> rVs_offload

the same as rVs but can be used inside OpenMP offload regions

Definition at line 51 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::initBreakup().

◆ rVsforce

std::shared_ptr<const RadFunctorType> rVsforce

force-optimized short range pair potential

Definition at line 55 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::evalSRwithForces(), and CoulombPBCAA::initBreakup().

◆ SourceID

int SourceID

Definition at line 59 of file CoulombPBCAA.h.

◆ SpeciesID

std::vector<int> SpeciesID

Definition at line 73 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::initBreakup().

◆ SR2

Matrix<RealType> SR2

Definition at line 75 of file CoulombPBCAA.h.

◆ use_offload_

const bool use_offload_

private

if true use offload

Definition at line 191 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::CoulombPBCAA(), and CoulombPBCAA::mw_evaluate().

◆ V_const

Array<TraceReal, 1> V_const

Definition at line 86 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::initBreakup().

◆ V_sample

Array<TraceReal, 1>* V_sample

Definition at line 85 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::checkoutParticleQuantities(), CoulombPBCAA::deleteParticleQuantities(), and CoulombPBCAA::evaluate_sp().

◆ Zat

std::vector<RealType> Zat

Definition at line 69 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::CoulombPBCAA(), CoulombPBCAA::evalLRwithForces(), CoulombPBCAA::evalSRwithForces(), CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::initBreakup().

◆ Zat_offload

std::shared_ptr<Vector<RealType, OffloadPinnedAllocator<RealType> > > Zat_offload

Definition at line 70 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::initBreakup().

◆ Zspec

std::vector<RealType> Zspec

Definition at line 69 of file CoulombPBCAA.h.

Referenced by CoulombPBCAA::evalLRwithForces(), CoulombPBCAA::evaluate_sp(), and CoulombPBCAA::initBreakup().

◆ qmcplusplus::CoulombPBCAB

class qmcplusplus::CoulombPBCAB

Calculates the AA Coulomb potential using PBCs.

Functionally identical to CoulombPBCAB but uses a templated version of LRHandler.

Definition at line 38 of file CoulombPBCAB.h.

Inheritance diagram for CoulombPBCAB:

Collaboration diagram for CoulombPBCAB:

Public Types
using	LRHandlerType = LRCoulombSingleton::LRHandlerType

using	GridType = LRCoulombSingleton::GridType

using	RadFunctorType = LRCoulombSingleton::RadFunctorType

using	mRealType = LRHandlerType::mRealType

Public Types inherited from OperatorBase
enum	EnergyDomains { KINETIC = 0, POTENTIAL, NO_ENERGY_DOMAIN }
	enum to denote energy domain of operators More...

enum	QuantumDomains { NO_QUANTUM_DOMAIN = 0, CLASSICAL, QUANTUM, CLASSICAL_CLASSICAL, QUANTUM_CLASSICAL, QUANTUM_QUANTUM }

enum	{ PRIMARY = 0, OPTIMIZABLE = 1, RATIOUPDATE = 2, PHYSICAL = 3, COLLECTABLE = 4, NONLOCAL = 5 }
	enum for update_mode More...

using	Return_t = FullPrecRealType
	type of return value of evaluate More...

using	ValueMatrix = SPOSet::ValueMatrix
	For fast derivative evaluation. More...

using	GradMatrix = SPOSet::GradMatrix

using	BufferType = ParticleSet::Buffer_t
	typedef for the serialized buffer More...

using	Walker_t = ParticleSet::Walker_t
	typedef for the walker More...

using	ParticleScalar = ParticleSet::Scalar_t
	typedef for the ParticleScalar More...

using	SPOMap = SPOSet::SPOMap
	typedef for SPOMap More...

Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...

using	PtclGrpIndexes = std::vector< std::pair< int, int > >

Public Types inherited from ForceBase
using	Real = QMCTraits::RealType
	cheat, need to use virtual inheriance to clean up More...

Public Member Functions
	CoulombPBCAB (ParticleSet &ions, ParticleSet &elns, bool computeForces=false)

	~CoulombPBCAB () override

void	resetTargetParticleSet (ParticleSet &P) override
	Reset the data with the target ParticleSet. More...

std::string	getClassName () const override
	return class name More...

void	contributeParticleQuantities () override

void	checkoutParticleQuantities (TraceManager &tm) override

Return_t	evaluate_sp (ParticleSet &P)

void	deleteParticleQuantities () override

Return_t	evaluate (ParticleSet &P) override
	Evaluate the local energy contribution of this component. More...

void	mw_evaluatePerParticle (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &ion_listeners) const override
	Evaluate the contribution of this component of multiple walkers per particle reporting to registered listeners from Estimators. More...

Return_t	evaluateWithIonDerivs (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_terms, ParticleSet::ParticlePos &pulay_terms) override
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

bool	put (xmlNodePtr cur) override
	Do nothing. More...

bool	get (std::ostream &os) const override
	write about the class More...

std::unique_ptr< OperatorBase >	makeClone (ParticleSet &qp, TrialWaveFunction &psi) override

Return_t	evalSR (ParticleSet &P)
	Computes the short-range contribution to the coulomb energy. More...

Return_t	evalLR (ParticleSet &P)
	Computes the long-range contribution to the coulomb energy. More...

Return_t	evalSRwithForces (ParticleSet &P)
	Computes the short-range contribution to the coulomb energy and forces. More...

Return_t	evalLRwithForces (ParticleSet &P)
	Computes the long-range contribution to the coulomb energy and forces. More...

Return_t	evalConsts (const ParticleSet &P, bool report=true)
	Evaluates madelung and background contributions to total energy. More...

void	add (int groupID, std::unique_ptr< RadFunctorType > &&ppot)
	Adds a local pseudopotential channel "ppot" to all source species of type "groupID". More...

void	addObservables (PropertySetType &plist, BufferType &collectables) override
	named values to the property list Default implementaton uses addValue(plist_) More...

void	setObservables (PropertySetType &plist) override
	Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_. More...

void	setParticlePropertyList (PropertySetType &plist, int offset) override

const ParticleSet &	getSourcePSet () const

void	createResource (ResourceCollection &collection) const override
	initialize a shared resource and hand it to a collection More...

void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const override
	acquire a shared resource from a collection More...

void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const override
	return a shared resource to a collection More...

void	informOfPerParticleListener () override
	Call to inform objects associated with this operator of per particle listeners. More...

Public Member Functions inherited from OperatorBase
	OperatorBase ()
	Construct a new Operator Base object Default and unique empty constructor. More...

virtual	~OperatorBase ()=default

virtual bool	dependsOnWaveFunction () const
	return true if this operator depends on a wavefunction More...

std::bitset< 8 > &	getUpdateMode () noexcept
	get update_mode_ reference More...

Return_t	getValue () const noexcept
	get a copy of value_ More...

std::string	getName () const noexcept
	getter a copy of my_name_, rvalue small string optimization More...

void	setName (const std::string name) noexcept
	Set my_name member, uses small string optimization (pass by value) More...

TraceRequest &	getRequest () noexcept
	Get request_ member. More...

virtual void	registerObservables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const
	add to observable descriptor for hdf5 The default implementation is to register a scalar for this->value_ More...

virtual void	registerCollectables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const

virtual void	setHistories (Walker_t &ThisWalker)

virtual Return_t	evaluateDeterministic (ParticleSet &P)
	Evaluate the local energy contribution of this component, deterministically based on current state. More...

virtual void	mw_evaluate (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluateWithParameterDerivatives (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< ParticleSet > &p_list, const opt_variables_type &optvars, const RecordArray< ValueType > &dlogpsi, RecordArray< ValueType > &dhpsioverpsi) const
	TODO: add docs. More...

virtual Return_t	rejectedMove (ParticleSet &P)
	TODO: add docs. More...

virtual Return_t	evaluateWithToperator (ParticleSet &P)
	Evaluate the local energy contribution of this component with Toperators updated if requested. More...

virtual void	mw_evaluateWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticleWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual Return_t	evaluateValueAndDerivatives (ParticleSet &P, const opt_variables_type &optvars, const Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	Evaluate value and derivatives wrt the optimizables. More...

virtual Return_t	evaluateWithIonDerivsDeterministic (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_term, ParticleSet::ParticlePos &pulay_term)
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

virtual void	evaluateOneBodyOpMatrix (ParticleSet &P, const TWFFastDerivWrapper &psi, std::vector< ValueMatrix > &B)
	Evaluate "B" matrix for observable. More...

virtual void	evaluateOneBodyOpMatrixForceDeriv (ParticleSet &P, ParticleSet &source, const TWFFastDerivWrapper &psi, const int iat, std::vector< std::vector< ValueMatrix >> &Bforce)
	Evaluate "dB/dR" matrices for observable. More...

virtual void	updateSource (ParticleSet &s)
	Update data associated with a particleset. More...

virtual Return_t	getEnsembleAverage ()
	Return an average value by collective operation. More...

virtual void	setRandomGenerator (RandomBase< FullPrecRealType > *rng)
	Set the Random Generator object TODO: add docs. More...

virtual void	add2Hamiltonian (ParticleSet &qp, TrialWaveFunction &psi, QMCHamiltonian &targetH)
	TODO: add docs. More...

virtual void	getRequiredTraces (TraceManager &tm)
	TODO: add docs. More...

bool	isClassical () const noexcept

bool	isQuantum () const noexcept

bool	isClassicalClassical () const noexcept

bool	isQuantumClassical () const noexcept

bool	isQuantumQuantum () const noexcept

bool	getMode (const int i) const noexcept
	Return the mode i. More...

bool	isNonLocal () const noexcept
	TODO: add docs. More...

bool	hasListener () const noexcept

void	contributeTraceQuantities ()
	Make trace quantities available. More...

void	checkoutTraceQuantities (TraceManager &tm)
	Checkout trace arrays Derived classes must guard individual checkouts using request info. More...

void	collectScalarTraces ()
	Collect scalar trace data. More...

void	deleteTraceQuantities ()
	delete trace arrays More...

Public Member Functions inherited from ForceBase
Real	g (Real r)

void	initVarReduction (Real rcut, int m, int numFuncs)

	ForceBase (ParticleSet &ions, ParticleSet &elns)

virtual	~ForceBase ()

void	registerObservablesF (std::vector< ObservableHelper > &h5list, hdf_archive &file) const

void	addObservablesF (QMCTraits::PropertySetType &plist)

void	addObservablesStress (QMCTraits::PropertySetType &plist)

void	setObservablesF (QMCTraits::PropertySetType &plist)

void	setObservablesStress (QMCTraits::PropertySetType &plist)

void	setParticleSetF (QMCTraits::PropertySetType &plist, int offset)

void	setParticleSetStress (QMCTraits::PropertySetType &plist, int offset)

bool	getAddIonIon () const noexcept

void	setAddIonIon (bool val) noexcept

const ParticleSet::ParticlePos &	getForces () const noexcept

void	setForces (const ParticleSet::ParticlePos &forces)

void	setForces (Real val)

const ParticleSet::ParticlePos &	getForcesIonIon () const noexcept

void	setForcesIonIon (const ParticleSet::ParticlePos &forces_ion_ion)

const SymTensor< Real, OHMMS_DIM > &	getStressIonIon () const noexcept

const SymTensor< Real, OHMMS_DIM > &	getStressEE () const noexcept

const SymTensor< Real, OHMMS_DIM > &	getStressEI () const noexcept

const SymTensor< Real, OHMMS_DIM > &	getStressKin () const noexcept

const SymTensor< Real, OHMMS_DIM > &	getStress () const noexcept

Public Attributes
std::shared_ptr< LRHandlerType >	AB
	long-range Handler. Should be const LRHandlerType eventually More...

std::shared_ptr< const LRHandlerType >	dAB
	long-range derivative handler More...

const int	myTableIndex
	locator of the distance table More...

int	NumSpeciesA
	number of species of A particle set More...

int	NumSpeciesB
	number of species of B particle set More...

int	NptclA
	number of particles of A More...

int	NptclB
	number of particles of B More...

Return_t	myConst
	const energy after breakup More...

RealType	myRcut
	cutoff radius of the short-range part More...

std::shared_ptr< const RadFunctorType >	V0
	Always mave a radial functor for the bare coulomb. More...

std::shared_ptr< const RadFunctorType >	fV0
	Radial functor for bare coulomb, optimized for forces. More...

std::shared_ptr< const RadFunctorType >	dfV0
	Radial functor for derivative of bare coulomb, optimized for forces. More...

bool	ComputeForces
	Flag for whether to compute forces or not. More...

std::vector< int >	NofSpeciesA
	number of particles per species of A More...

std::vector< int >	NofSpeciesB
	number of particles per species of B More...

std::vector< RealType >	Zat
	Zat[iat] charge for the iat-th particle of A. More...

std::vector< RealType >	Qat
	Qat[iat] charge for the iat-th particle of B. More...

std::vector< RealType >	Zspec
	Zspec[spec] charge for the spec-th species of A. More...

std::vector< RealType >	Qspec
	Qspec[spec] charge for the spec-th species of B. More...

std::vector< const RadFunctorType * >	Vat
	Short-range potential for each ion. More...

std::vector< std::shared_ptr< RadFunctorType > >	Vspec
	Short-range potential for each species. More...

std::vector< const RadFunctorType * >	fVat
	Short-range potential (r*V) and potential derivative d/dr(rV) derivative for each ion Required for force evaluations. More...

std::vector< const RadFunctorType * >	fdVat

std::vector< std::shared_ptr< const RadFunctorType > >	fVspec

std::vector< std::shared_ptr< const RadFunctorType > >	fdVspec

bool	kcdifferent

RealType	minkc

Array< TraceReal, 1 > *	Ve_sample

Array< TraceReal, 1 > *	Vi_sample

Array< TraceReal, 1 >	Ve_const

Array< TraceReal, 1 >	Vi_const

ParticleSet &	Peln


RealType	SRtmp
	short-range part for the moved particle More...

RealType	LRtmp
	long-range part for the moved particle More...

Vector< RealType >	SRpart
	short-range per particle More...

Vector< RealType >	LRpart
	long-range per particle More...

Protected Member Functions
void	initBreakup (ParticleSet &P)
	Creates the long-range handlers, then splines and stores it by particle and species for quick evaluation. More...

Protected Member Functions inherited from OperatorBase
virtual void	contributeScalarQuantities ()

virtual void	checkoutScalarQuantities (TraceManager &tm)

virtual void	collectScalarQuantities ()

virtual void	deleteScalarQuantities ()

virtual void	setComputeForces (bool compute)

void	setEnergyDomain (EnergyDomains edomain)
	Set the Energy Domain. More...

void	setQuantumDomain (QuantumDomains qdomain)
	set quantum domain More...

void	oneBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for one-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for two-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P1, const ParticleSet &P2)
	set quantum domain for two-body operator More...

void	addValue (PropertySetType &plist)
	named values to the property list More...

Private Member Functions
void	evalPerParticleConsts (Vector< RealType > &pp_consts_src, Vector< RealType > &pp_consts_trg) const
	Compute the const part of the per particle coulomb AB potential. More...

Private Attributes
ParticleSet &	pset_ions_
	source particle set More...

ResourceHandle< CoulombPBCABMultiWalkerResource >	mw_res_handle_

Additional Inherited Members
Protected Attributes inherited from OperatorBase
std::bitset< 8 >	update_mode_
	set the current update mode More...

Return_t	value_
	current value More...

std::string	name_
	name of this object More...

TraceRequest	request_
	whether traces are being collected More...

int	my_index_
	starting index of this object More...

Return_t	new_value_
	a new value for a proposed move More...

Walker_t *	t_walker_
	reference to the current walker More...

bool	streaming_particles_

bool	have_required_traces_

Protected Attributes inherited from ForceBase
int	first_force_index_

int	n_nuc_

int	n_el_

int	tries_

bool	first_time_

bool	add_ion_ion_
	Determines if ion-ion force will be added to electron-ion force in derived force estimators. If false, forces_ion_ion_=0.0. More...

ParticleSet &	ions_

ParticleSet::ParticlePos	forces_

ParticleSet::ParticlePos	forces_ion_ion_

SymTensor< Real, OHMMS_DIM >	stress_ion_ion_

SymTensor< Real, OHMMS_DIM >	stress_ee_

SymTensor< Real, OHMMS_DIM >	stress_ei_

SymTensor< Real, OHMMS_DIM >	stress_kin_

SymTensor< Real, OHMMS_DIM >	stress_

std::string	prefix_

std::string	pair_name_

Real	rcut_

int	m_

std::vector< Real >	ck_

Member Typedef Documentation

◆ GridType

using GridType = LRCoulombSingleton::GridType

Definition at line 42 of file CoulombPBCAB.h.

◆ LRHandlerType

using LRHandlerType = LRCoulombSingleton::LRHandlerType

Definition at line 41 of file CoulombPBCAB.h.

◆ mRealType

using mRealType = LRHandlerType::mRealType

Definition at line 44 of file CoulombPBCAB.h.

◆ RadFunctorType

using RadFunctorType = LRCoulombSingleton::RadFunctorType

Definition at line 43 of file CoulombPBCAB.h.

Constructor & Destructor Documentation

◆ CoulombPBCAB()

CoulombPBCAB	(	ParticleSet &	ions,
		ParticleSet &	elns,
		bool	computeForces = `false`
	)

Definition at line 43 of file CoulombPBCAB.cpp.

References CoulombPBCAB::AB, qmcplusplus::app_log(), CoulombPBCAB::ComputeForces, CoulombPBCAB::initBreakup(), CoulombPBCAB::myRcut, OperatorBase::POTENTIAL, ForceBase::prefix_, CoulombPBCAB::pset_ions_, OperatorBase::setEnergyDomain(), ParticleSet::turnOnPerParticleSK(), and OperatorBase::twoBodyQuantumDomain().

     : ForceBase(ions, elns),
       myTableIndex(elns.addTable(ions)),
       myConst(0.0),
       ComputeForces(computeForces),
       Peln(elns),
       pset_ions_(ions)
 {
   ReportEngine PRE("CoulombPBCAB", "CoulombPBCAB");
   setEnergyDomain(POTENTIAL);
   twoBodyQuantumDomain(ions, elns);
   if (ComputeForces)
     pset_ions_.turnOnPerParticleSK();
   initBreakup(elns);
   prefix_ = "Flocal";
   app_log() << "  Rcut                " << myRcut << std::endl;
   app_log() << "  Maximum K shell     " << AB->MaxKshell << std::endl;
   app_log() << "  Number of k vectors " << AB->Fk.size() << std::endl;
 }

◆ ~CoulombPBCAB()

~CoulombPBCAB ( )

overridedefault

Member Function Documentation

◆ acquireResource()

void acquireResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< OperatorBase > &	o_list
	)		const

overridevirtual

acquire a shared resource from a collection

Reimplemented from OperatorBase.

Definition at line 749 of file CoulombPBCAB.cpp.

References RefVectorWithLeader< T >::getCastedLeader(), ResourceCollection::lendResource(), and CoulombPBCAB::mw_res_handle_.

 {
   auto& o_leader          = o_list.getCastedLeader<CoulombPBCAB>();
   o_leader.mw_res_handle_ = collection.lendResource<CoulombPBCABMultiWalkerResource>();
 }

◆ add()

void add	(	int	groupID,
		std::unique_ptr< RadFunctorType > &&	ppot
	)

Adds a local pseudopotential channel "ppot" to all source species of type "groupID".

add a local pseudo potential

Parameters

groupID	species index
ppot	radial functor for $rV_{loc}$ on a grid

Definition at line 561 of file CoulombPBCAB.cpp.

References CoulombPBCAB::AB, qmcplusplus::app_log(), CoulombPBCAB::ComputeForces, OHMMS::Controller, CoulombPBCAB::dAB, qmcplusplus::Units::charge::e, CoulombPBCAB::fdVat, CoulombPBCAB::fdVspec, CoulombPBCAB::fVat, CoulombPBCAB::fVspec, ParticleSet::GroupID, omptarget::min(), CoulombPBCAB::myRcut, CoulombPBCAB::NptclA, CoulombPBCAB::pset_ions_, qmcplusplus::rank, LinearGrid< T, CT >::set(), CoulombPBCAB::V0, CoulombPBCAB::Vat, and CoulombPBCAB::Vspec.

 {
   //FIXME still using magic numbers in the local potential grid.
   const int MaxGridPoints = 10000;
   const size_t ng         = std::min(MaxGridPoints, static_cast<int>(myRcut / 1e-3) + 1);
   app_log() << "    CoulombPBCAB::add \n Setting a linear grid=[0," << myRcut << ") number of grid =" << ng
             << std::endl;
   auto agrid_local = LinearGrid<RealType>();
   agrid_local.set(0.0, myRcut, ng);
   RealType dr = agrid_local[1] - agrid_local[0];
   if (Vspec[groupID] == nullptr)
   {
     V0.reset();
 
     app_log() << "    Creating the short-range pseudopotential for species " << groupID << std::endl;
     std::vector<RealType> v(ng);
     for (int ig = 1; ig < ng - 2; ig++)
     {
       RealType r = agrid_local[ig];
       //need to multiply r for the LR
       v[ig] = -r * AB->evaluateLR(r) + ppot->splint(r);
     }
     v[0] = 2.0 * v[1] - v[2];
     //by construction, v has to go to zero at the boundary
     v[ng - 2]      = 0.0;
     v[ng - 1]      = 0.0;
     RealType deriv = (v[1] - v[0]) / dr;
     auto rfunc     = std::make_unique<RadFunctorType>(agrid_local.makeClone(), v);
     rfunc->spline(0, deriv, ng - 1, 0.0);
     for (int iat = 0; iat < NptclA; iat++)
     {
       if (pset_ions_.GroupID[iat] == groupID)
         Vat[iat] = rfunc.get();
     }
     Vspec[groupID] = std::move(rfunc);
   }
 
   if (ComputeForces && fVspec[groupID] == nullptr)
   {
     app_log() << "    Creating the short-range pseudopotential derivatives for species " << groupID << std::endl;
     //This is the value coming from optimized breakup for FORCES, not for energy.
     //Also.  Goal of this section is to create and store d/dr(rV), not d/dr(V)!!!
     std::vector<RealType> v(ng);
     std::vector<RealType> dv(ng);
 
     RealType ppot_val(0), ppot_deriv(0), ppot_2deriv(0);
     RealType lr_val(0), lr_deriv(0);
     for (int ig = 1; ig < ng - 2; ig++)
     {
       RealType r = agrid_local[ig];
       ppot_val   = ppot->splint(r, ppot_deriv, ppot_2deriv);
       lr_val     = dAB->evaluateLR(r);
       lr_deriv   = dAB->lrDf(r);
 
       v[ig]  = ppot_val - r * lr_val;
       dv[ig] = ppot_deriv - (lr_val + lr_deriv * r);
     }
     //This is a linear interpolation from v[2] and v[1] to v[0], assuming linear behavior.
     v[0]      = 2.0 * v[1] - v[2];
     v[ng - 2] = 0.0;
     v[ng - 1] = 0.0;
 
     dv[0]      = 2.0 * dv[1] - dv[2];
     dv[ng - 2] = 0;
     dv[ng - 1] = 0;
 
     auto ffunc  = std::make_unique<RadFunctorType>(agrid_local.makeClone(), v);
     auto fdfunc = std::make_unique<RadFunctorType>(agrid_local.makeClone(), dv);
 
     RealType fderiv = (dv[1] - dv[0]) / dr;
 
     ffunc->spline(0, dv[0], ng - 1, 0.0);
     fdfunc->spline(0, fderiv, ng - 1, 0.0);
 
     for (int iat = 0; iat < NptclA; iat++)
     {
       if (pset_ions_.GroupID[iat] == groupID)
       {
         fVat[iat]  = ffunc.get();
         fdVat[iat] = fdfunc.get();
       }
     }
     fVspec[groupID]  = std::move(ffunc);
     fdVspec[groupID] = std::move(fdfunc);
     //Done
   }
 
   if (ComputeForces)
   {
     if (OHMMS::Controller->rank() == 0)
     {
       FILE* fout = fopen("Vlocal.dat", "w");
       for (RealType r = 1.0e-8; r < myRcut; r += 1.0e-2)
       {
         RealType d_rV_dr, d2_rV_dr2;
         RealType Vr = Vat[0]->splint(r, d_rV_dr, d2_rV_dr2);
         Vr          = Vat[0]->splint(r);
         fprintf(fout, "%1.8e %1.12e %1.12e %1.12e\n", r, Vr, d_rV_dr, d2_rV_dr2);
       }
       fclose(fout);
     }
   }
 }

◆ addObservables()

void addObservables	(	PropertySetType &	plist,
		BufferType &	collectables
	)

overridevirtual

named values to the property list Default implementaton uses addValue(plist_)

Parameters

plist	RecordNameProperty
collectables	Observables that are accumulated by evaluate

Reimplemented from OperatorBase.

Definition at line 80 of file CoulombPBCAB.cpp.

References RecordNamedProperty< T >::add(), ForceBase::addObservablesF(), CoulombPBCAB::ComputeForces, OperatorBase::my_index_, and OperatorBase::name_.

 {
   my_index_ = plist.add(name_.c_str());
   if (ComputeForces)
     addObservablesF(plist);
 }

◆ checkoutParticleQuantities()

void checkoutParticleQuantities ( TraceManager & tm )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 91 of file CoulombPBCAB.cpp.

References TraceManager::checkout_real(), OperatorBase::name_, CoulombPBCAB::Peln, CoulombPBCAB::pset_ions_, OperatorBase::request_, TraceRequest::streaming_array(), OperatorBase::streaming_particles_, ParticleSet::turnOnPerParticleSK(), CoulombPBCAB::Ve_sample, and CoulombPBCAB::Vi_sample.

 {
   streaming_particles_ = request_.streaming_array(name_);
   if (streaming_particles_)
   {
     pset_ions_.turnOnPerParticleSK();
     Peln.turnOnPerParticleSK();
     Ve_sample = tm.checkout_real<1>(name_, Peln);
     Vi_sample = tm.checkout_real<1>(name_, pset_ions_);
   }
 }

◆ contributeParticleQuantities()

void contributeParticleQuantities ( )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 89 of file CoulombPBCAB.cpp.

References TraceRequest::contribute_array(), OperatorBase::name_, and OperatorBase::request_.

89 { request_.contribute_array(name_); }

TraceRequest request_

whether traces are being collected

Definition: OperatorBase.h:531

std::string name_

name of this object

Definition: OperatorBase.h:527

References CoulombPBCAB::AB, qmcplusplus::abs(), APP_ABORT, qmcplusplus::app_log(), CoulombPBCAB::evalLR(), CoulombPBCAB::evalSR(), ParticleSet::getDistTableAB(), ParticleSet::getSimulationCell(), ParticleSet::getSK(), ParticleSet::getTotalNum(), CoulombPBCAB::myConst, CoulombPBCAB::myTableIndex, CoulombPBCAB::NptclA, CoulombPBCAB::NptclB, CoulombPBCAB::NumSpeciesA, CoulombPBCAB::NumSpeciesB, CoulombPBCAB::pset_ions_, CoulombPBCAB::Qat, CoulombPBCAB::Qspec, qmcplusplus::Units::time::s, Array< T, D, ALLOC >::size(), Array< T, D, ALLOC >::sum(), qmcplusplus::SUPERCELL_SLAB, TraceManager::trace_tol, OperatorBase::value_, CoulombPBCAB::Vat, CoulombPBCAB::Ve_const, CoulombPBCAB::Ve_sample, CoulombPBCAB::Vi_const, CoulombPBCAB::Vi_sample, CoulombPBCAB::Zat, and CoulombPBCAB::Zspec.

void contribute_array(const std::string &name, bool default_quantity=false)

Definition: TraceManager.h:198

◆ createResource()

void createResource ( ResourceCollection & collection ) const

overridevirtual

initialize a shared resource and hand it to a collection

Reimplemented from OperatorBase.

Definition at line 742 of file CoulombPBCAB.cpp.

References ResourceCollection::addResource(), and CoulombPBCAB::evalPerParticleConsts().

Referenced by qmcplusplus::TEST_CASE().

 {
   auto new_res = std::make_unique<CoulombPBCABMultiWalkerResource>();
   evalPerParticleConsts(new_res->pp_consts_src, new_res->pp_consts_trg);
   auto resource_index = collection.addResource(std::move(new_res));
 }

◆ deleteParticleQuantities()

void deleteParticleQuantities ( )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 111 of file CoulombPBCAB.cpp.

References OperatorBase::streaming_particles_, CoulombPBCAB::Ve_sample, and CoulombPBCAB::Vi_sample.

 {
   if (streaming_particles_)
   {
     delete Ve_sample;
     delete Vi_sample;
   }
 }

◆ evalConsts()

CoulombPBCAB::Return_t evalConsts	(	const ParticleSet &	Peln,
		bool	report = `true`
	)

Evaluates madelung and background contributions to total energy.

Evaluate the background term.

Other constants are handled by AA potentials.

$V_{bg}^{AB}=-\sum_{\alpha}\sum_{\beta} N^{\alpha} N^{\beta} q^{\alpha} q^{\beta} v_s(k=0)$

Todo:: Here is where the charge system has to be handled.

Definition at line 390 of file CoulombPBCAB.cpp.

References CoulombPBCAB::AB, qmcplusplus::app_log(), ParticleSet::getTotalNum(), CoulombPBCAB::NofSpeciesA, CoulombPBCAB::NofSpeciesB, CoulombPBCAB::NumSpeciesA, CoulombPBCAB::NumSpeciesB, CoulombPBCAB::Peln, CoulombPBCAB::pset_ions_, CoulombPBCAB::Qat, CoulombPBCAB::Qspec, Array< T, D, ALLOC >::resize(), qmcplusplus::Units::time::s, CoulombPBCAB::Ve_const, CoulombPBCAB::Vi_const, CoulombPBCAB::Zat, and CoulombPBCAB::Zspec.

Referenced by CoulombPBCAB::initBreakup(), and qmcplusplus::TEST_CASE().

 {
   int nelns = Peln.getTotalNum();
   int nions = pset_ions_.getTotalNum();
 #if !defined(REMOVE_TRACEMANAGER)
   Ve_const.resize(nelns);
   Vi_const.resize(nions);
   Ve_const = 0.0;
   Vi_const = 0.0;
 #endif
   mRealType Consts = 0.0;
   mRealType vs_k0  = AB->evaluateSR_k0();
   mRealType v1; //single particle energy
   for (int i = 0; i < nelns; ++i)
   {
     v1 = 0.0;
     for (int s = 0; s < NumSpeciesA; s++)
       v1 += NofSpeciesA[s] * Zspec[s];
     v1 *= -.5 * Qat[i] * vs_k0;
 #if !defined(REMOVE_TRACEMANAGER)
     Ve_const(i) = v1;
 #endif
     Consts += v1;
   }
   for (int i = 0; i < nions; ++i)
   {
     v1 = 0.0;
     for (int s = 0; s < NumSpeciesB; s++)
       v1 += NofSpeciesB[s] * Qspec[s];
     v1 *= -.5 * Zat[i] * vs_k0;
 #if !defined(REMOVE_TRACEMANAGER)
     Vi_const(i) = v1;
 #endif
     Consts += v1;
   }
   if (report)
     app_log() << "   Constant of PBCAB " << Consts << std::endl;
   return Consts;
 }

◆ evalLR()

CoulombPBCAB::Return_t evalLR ( ParticleSet & P )

Computes the long-range contribution to the coulomb energy.

Definition at line 449 of file CoulombPBCAB.cpp.

References CoulombPBCAB::AB, ParticleSet::getSimulationCell(), ParticleSet::getSK(), CoulombPBCAB::NumSpeciesA, CoulombPBCAB::NumSpeciesB, CoulombPBCAB::pset_ions_, CoulombPBCAB::Qspec, qmcplusplus::SUPERCELL_SLAB, and CoulombPBCAB::Zspec.

Referenced by CoulombPBCAB::evalLRwithForces(), CoulombPBCAB::evaluate(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::evaluateWithIonDerivs().

 {
   mRealType res = 0.0;
   const StructFact& RhoKA(pset_ions_.getSK());
   const StructFact& RhoKB(P.getSK());
   if (RhoKA.SuperCellEnum == SUPERCELL_SLAB)
     throw std::runtime_error(
         "CoulombPBCAB::evalLR RhoKA.SuperCellEnum == SUPERCELL_SLAB case not implemented. There was an implementation "
         "with complex-valued storage that may be resurrected using real-valued storage.");
   else
   {
     for (int i = 0; i < NumSpeciesA; i++)
     {
       mRealType esum = 0.0;
       for (int j = 0; j < NumSpeciesB; j++)
         esum += Qspec[j] *
             AB->evaluate(pset_ions_.getSimulationCell().getKLists().kshell, RhoKA.rhok_r[i], RhoKA.rhok_i[i],
                          RhoKB.rhok_r[j], RhoKB.rhok_i[j]);
       res += Zspec[i] * esum;
     }
   } //specion
   return res;
 }

◆ evalLRwithForces()

CoulombPBCAB::Return_t evalLRwithForces ( ParticleSet & P )

Computes the long-range contribution to the coulomb energy and forces.

Definition at line 665 of file CoulombPBCAB.cpp.

References CoulombPBCAB::dAB, CoulombPBCAB::evalLR(), ForceBase::forces_, ParticleSet::getTotalNum(), CoulombPBCAB::NumSpeciesB, CoulombPBCAB::pset_ions_, CoulombPBCAB::Qspec, and CoulombPBCAB::Zat.

Referenced by CoulombPBCAB::evaluate(), and CoulombPBCAB::evaluateWithIonDerivs().

 {
   //  const StructFact& RhoKA(pset_ions_.getSK());
   //  const StructFact& RhoKB(P.getSK());
   std::vector<TinyVector<RealType, DIM>> grad(pset_ions_.getTotalNum());
   for (int j = 0; j < NumSpeciesB; j++)
   {
     for (int iat = 0; iat < grad.size(); iat++)
       grad[iat] = TinyVector<RealType, DIM>(0.0, 0.0, 0.0);
     dAB->evaluateGrad(pset_ions_, P, j, Zat, grad);
     for (int iat = 0; iat < grad.size(); iat++)
       forces_[iat] += Qspec[j] * grad[iat];
   } // electron species
   return evalLR(P);
 }

◆ evalPerParticleConsts()

void evalPerParticleConsts	(	Vector< RealType > &	pp_consts_src,
		Vector< RealType > &	pp_consts_trg
	)		const

private

Compute the const part of the per particle coulomb AB potential.

Parameters

[out]	pp_consts_src	constant values for the source particles aka ions aka A
[out]	pp_consts_trg	constant values for the target particles aka electrons aka B

Definition at line 715 of file CoulombPBCAB.cpp.

References CoulombPBCAB::AB, ParticleSet::getTotalNum(), CoulombPBCAB::NofSpeciesA, CoulombPBCAB::NofSpeciesB, CoulombPBCAB::NumSpeciesA, CoulombPBCAB::NumSpeciesB, CoulombPBCAB::Peln, CoulombPBCAB::pset_ions_, CoulombPBCAB::Qat, CoulombPBCAB::Qspec, Vector< T, Alloc >::resize(), qmcplusplus::Units::time::s, CoulombPBCAB::Zat, and CoulombPBCAB::Zspec.

Referenced by CoulombPBCAB::createResource().

 {
   int nelns = Peln.getTotalNum();
   int nions = pset_ions_.getTotalNum();
   pp_consts_trg.resize(nelns, 0.0);
   pp_consts_src.resize(nions, 0.0);
 
   RealType vs_k0 = AB->evaluateSR_k0();
   RealType v1; //single particle energy
   for (int i = 0; i < nelns; ++i)
   {
     v1 = 0.0;
     for (int s = 0; s < NumSpeciesA; s++)
       v1 += NofSpeciesA[s] * Zspec[s];
     v1 *= -.5 * Qat[i] * vs_k0;
     pp_consts_trg[i] = v1;
   }
   for (int i = 0; i < nions; ++i)
   {
     v1 = 0.0;
     for (int s = 0; s < NumSpeciesB; s++)
       v1 += NofSpeciesB[s] * Qspec[s];
     v1 *= -.5 * Zat[i] * vs_k0;
     pp_consts_src[i] = v1;
   }
 }

◆ evalSR()

CoulombPBCAB::Return_t evalSR ( ParticleSet & P )

Computes the short-range contribution to the coulomb energy.

Definition at line 431 of file CoulombPBCAB.cpp.

References BLAS::czero, ParticleSet::getDistTableAB(), CoulombPBCAB::myTableIndex, CoulombPBCAB::NptclA, CoulombPBCAB::NptclB, CoulombPBCAB::Qat, CoulombPBCAB::Vat, and CoulombPBCAB::Zat.

Referenced by CoulombPBCAB::evaluate(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::evaluateWithIonDerivs().

 {
   constexpr mRealType czero(0);
   const auto& d_ab(P.getDistTableAB(myTableIndex));
   mRealType res = czero;
   //can be optimized but not important enough
   for (size_t b = 0; b < NptclB; ++b)
   {
     const auto& dist = d_ab.getDistRow(b);
     mRealType esum   = czero;
     for (size_t a = 0; a < NptclA; ++a)
       esum += Zat[a] * Vat[a]->splint(dist[a]) / dist[a];
     res += esum * Qat[b];
   }
   return res;
 }

◆ evalSRwithForces()

CoulombPBCAB::Return_t evalSRwithForces ( ParticleSet & P )

Computes the short-range contribution to the coulomb energy and forces.

Definition at line 681 of file CoulombPBCAB.cpp.

References BLAS::czero, CoulombPBCAB::fdVat, ForceBase::forces_, CoulombPBCAB::fVat, ParticleSet::getDistTableAB(), CoulombPBCAB::myTableIndex, CoulombPBCAB::NptclA, CoulombPBCAB::NptclB, CoulombPBCAB::Qat, CoulombPBCAB::Vat, and CoulombPBCAB::Zat.

Referenced by CoulombPBCAB::evaluate(), and CoulombPBCAB::evaluateWithIonDerivs().

 {
   constexpr mRealType czero(0);
   const auto& d_ab(P.getDistTableAB(myTableIndex));
   mRealType res = czero;
   //Temporary variables for computing energy and forces.
   mRealType rV(0);
   mRealType frV(0), fdrV(0);
   mRealType rinv(1.0);
   //Magnitude of force.
   mRealType dvdr(0.0);
   for (size_t b = 0; b < NptclB; ++b)
   {
     const auto& dist = d_ab.getDistRow(b);
     const auto& dr   = d_ab.getDisplRow(b);
     mRealType esum   = czero;
     for (size_t a = 0; a < NptclA; ++a)
     {
       //Low hanging SIMD fruit here.  See J1/J2 grad computation.
       rinv = 1.0 / dist[a];
       rV   = Vat[a]->splint(dist[a]);
       frV  = fVat[a]->splint(dist[a]);
       fdrV = fdVat[a]->splint(dist[a]);
       dvdr = Qat[b] * Zat[a] * (fdrV - frV * rinv) * rinv;
       forces_[a][0] -= dvdr * dr[a][0] * rinv;
       forces_[a][1] -= dvdr * dr[a][1] * rinv;
       forces_[a][2] -= dvdr * dr[a][2] * rinv;
       esum += Zat[a] * rV * rinv; //Total energy accumulation
     }
     res += esum * Qat[b];
   }
   return res;
 }

◆ evaluate()

CoulombPBCAB::Return_t evaluate ( ParticleSet & P )

overridevirtual

Evaluate the local energy contribution of this component.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Implements OperatorBase.

Definition at line 122 of file CoulombPBCAB.cpp.

References CoulombPBCAB::ComputeForces, CoulombPBCAB::evalLR(), CoulombPBCAB::evalLRwithForces(), CoulombPBCAB::evalSR(), CoulombPBCAB::evalSRwithForces(), CoulombPBCAB::evaluate_sp(), ForceBase::forces_, CoulombPBCAB::myConst, OperatorBase::streaming_particles_, and OperatorBase::value_.

Referenced by qmcplusplus::TEST_CASE().

 {
   if (ComputeForces)
   {
     forces_ = 0.0;
     value_  = evalLRwithForces(P) + evalSRwithForces(P) + myConst;
   }
   else
 #if !defined(REMOVE_TRACEMANAGER)
       if (streaming_particles_)
     value_ = evaluate_sp(P);
   else
 #endif
     value_ = evalLR(P) + evalSR(P) + myConst;
   return value_;
 }

◆ evaluate_sp()

CoulombPBCAB::Return_t evaluate_sp ( ParticleSet & P )

Definition at line 158 of file CoulombPBCAB.cpp.

Referenced by CoulombPBCAB::evaluate().

 {
   RealType Vsr                = 0.0;
   RealType Vlr                = 0.0;
   mRealType& 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 auto& d_ab(P.getDistTableAB(myTableIndex));
     RealType z;
     //Loop over distinct eln-ion pairs
     for (size_t b = 0; b < NptclB; ++b)
     {
       z                = 0.5 * Qat[b];
       const auto& dist = d_ab.getDistRow(b);
       for (size_t a = 0; a < NptclA; ++a)
       {
         Return_t pairpot = z * Zat[a] * Vat[a]->splint(dist[a]) / dist[a];
         Vi_samp(a) += pairpot;
         Ve_samp(b) += pairpot;
         Vsr += pairpot;
       }
     }
     Vsr *= 2.0;
   }
   {
     //LR
     const StructFact& RhoKA(pset_ions_.getSK());
     const StructFact& RhoKB(P.getSK());
     if (RhoKA.SuperCellEnum == SUPERCELL_SLAB)
     {
       APP_ABORT("CoulombPBCAB::evaluate_sp single particle traces have not been implemented for slab geometry");
     }
     else
     {
       assert(RhoKA.isStorePerParticle()); // ensure this so we know eikr_r has been allocated
       assert(RhoKB.isStorePerParticle());
       //jtk mark: needs optimizations. 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++)
           v1 += Zspec[s] * q *
               AB->evaluate(pset_ions_.getSimulationCell().getKLists().kshell, RhoKA.rhok_r[s], RhoKA.rhok_i[s],
                            RhoKB.eikr_r[i], RhoKB.eikr_i[i]);
         Ve_samp(i) += v1;
         Vlr += v1;
       }
       for (int i = 0; i < pset_ions_.getTotalNum(); ++i)
       {
         q  = .5 * Zat[i];
         v1 = 0.0;
         for (int s = 0; s < NumSpeciesB; s++)
           v1 += Qspec[s] * q *
               AB->evaluate(P.getSimulationCell().getKLists().kshell, RhoKB.rhok_r[s], RhoKB.rhok_i[s], RhoKA.eikr_r[i],
                            RhoKA.eikr_i[i]);
         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;
   if (std::abs(Vsum - Vnow) > TraceManager::trace_tol)
   {
     app_log() << "accumtest: CoulombPBCAA::evaluate()" << std::endl;
     app_log() << "accumtest:   tot:" << Vnow << std::endl;
     app_log() << "accumtest:   sum:" << Vsum << std::endl;
     APP_ABORT("Trace check failed");
   }
   if (std::abs(Vcsum - Vcnow) > TraceManager::trace_tol)
   {
     app_log() << "accumtest: CoulombPBCAA::evalConsts()" << std::endl;
     app_log() << "accumtest:   tot:" << Vcnow << std::endl;
     app_log() << "accumtest:   sum:" << Vcsum << std::endl;
     APP_ABORT("Trace check failed");
   }
   if (std::abs(Vesum - Visum) > TraceManager::trace_tol)
   {
     app_log() << "sharetest: CoulombPBCAB::evaluate()" << std::endl;
     app_log() << "sharetest:   e share:" << Vesum << std::endl;
     app_log() << "sharetest:   i share:" << Visum << std::endl;
   }
   if (std::abs(Vecsum - Vicsum) > TraceManager::trace_tol)
   {
     app_log() << "sharetest: CoulombPBCAB::evalConsts()" << std::endl;
     app_log() << "sharetest:   e share:" << Vecsum << std::endl;
     app_log() << "sharetest:   i share:" << Vicsum << std::endl;
   }
 
 #endif
   return value_;
 }

◆ evaluateWithIonDerivs()

CoulombPBCAB::Return_t evaluateWithIonDerivs	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_term,
		ParticleSet::ParticlePos &	pulay_term
	)

overridevirtual

Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase.

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Adds OperatorBase's contribution to Re [(dH)Psi]/Psi
pulay_terms	Adds OperatorBase's contribution to Re [(H-E_L)dPsi]/Psi

Returns: Contribution of OperatorBase to Local Energy.

Reimplemented from OperatorBase.

Definition at line 139 of file CoulombPBCAB.cpp.

References CoulombPBCAB::ComputeForces, CoulombPBCAB::evalLR(), CoulombPBCAB::evalLRwithForces(), CoulombPBCAB::evalSR(), CoulombPBCAB::evalSRwithForces(), ForceBase::forces_, CoulombPBCAB::myConst, and OperatorBase::value_.

 {
   if (ComputeForces)
   {
     forces_ = 0.0;
     value_  = evalLRwithForces(P) + evalSRwithForces(P) + myConst;
     hf_terms -= forces_;
     //And no Pulay contribution.
   }
   else
     value_ = evalLR(P) + evalSR(P) + myConst;
   return value_;
 }

◆ get()

bool get ( std::ostream & os ) const

inlineoverridevirtual

write about the class

Implements OperatorBase.

Definition at line 165 of file CoulombPBCAB.h.

References OhmmsElementBase::getName(), and CoulombPBCAB::pset_ions_.

   {
     os << "CoulombPBCAB potential source: " << pset_ions_.getName();
     return true;
   }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements OperatorBase.

Definition at line 134 of file CoulombPBCAB.h.

134 { return "CoulombPBCAB"; }

◆ getSourcePSet()

const ParticleSet& getSourcePSet ( ) const

inline

Definition at line 202 of file CoulombPBCAB.h.

References CoulombPBCAB::pset_ions_.

202 { return pset_ions_; }

qmcplusplus::CoulombPBCAB::pset_ions_

ParticleSet & pset_ions_

source particle set

Definition: CoulombPBCAB.h:230

◆ informOfPerParticleListener()

void informOfPerParticleListener ( )

overridevirtual

Call to inform objects associated with this operator of per particle listeners.

should be called before createResources

Reimplemented from OperatorBase.

Definition at line 103 of file CoulombPBCAB.cpp.

References OperatorBase::informOfPerParticleListener(), CoulombPBCAB::Peln, CoulombPBCAB::pset_ions_, and ParticleSet::turnOnPerParticleSK().

 {
   // This is written so it can be called again and again.
   pset_ions_.turnOnPerParticleSK();
   Peln.turnOnPerParticleSK();
   OperatorBase::informOfPerParticleListener();
 }

◆ initBreakup()

void initBreakup ( ParticleSet & P )

protected

Creates the long-range handlers, then splines and stores it by particle and species for quick evaluation.

this is just constructor code factored out. It is called by the derived class CoulombPBCAB_CUDA

Definition at line 474 of file CoulombPBCAB.cpp.

References CoulombPBCAB::AB, qmcplusplus::abs(), SpeciesSet::addAttribute(), APP_ABORT, qmcplusplus::app_log(), CoulombPBCAB::ComputeForces, LRCoulombSingleton::createSpline4RbyVs(), LRCoulombSingleton::createSpline4RbyVsDeriv(), CoulombPBCAB::dAB, CoulombPBCAB::dfV0, CoulombPBCAB::evalConsts(), CoulombPBCAB::fdVat, CoulombPBCAB::fdVspec, qmcplusplus::for(), CoulombPBCAB::fV0, CoulombPBCAB::fVat, CoulombPBCAB::fVspec, LRCoulombSingleton::getDerivHandler(), LRCoulombSingleton::getHandler(), ParticleSet::getLattice(), ParticleSet::getSpeciesSet(), ParticleSet::getTotalNum(), ParticleSet::GroupID, ParticleSet::groupsize(), CoulombPBCAB::kcdifferent, omptarget::min(), CoulombPBCAB::minkc, CoulombPBCAB::myConst, CoulombPBCAB::myRcut, CoulombPBCAB::NofSpeciesA, CoulombPBCAB::NofSpeciesB, CoulombPBCAB::NptclA, CoulombPBCAB::NptclB, CoulombPBCAB::NumSpeciesA, CoulombPBCAB::NumSpeciesB, CoulombPBCAB::pset_ions_, CoulombPBCAB::Qat, CoulombPBCAB::Qspec, LinearGrid< T, CT >::set(), CoulombPBCAB::V0, CoulombPBCAB::Vat, CoulombPBCAB::Vspec, CoulombPBCAB::Zat, and CoulombPBCAB::Zspec.

Referenced by CoulombPBCAB::CoulombPBCAB().

 {
   // This is ridiculous so many uneeded convenience variables that also make the object invalid at construction.
   // Illustraction of the terrible API and convoluted use of species attributes.
   SpeciesSet& tspeciesA(pset_ions_.getSpeciesSet());
   SpeciesSet& tspeciesB(P.getSpeciesSet());
   // Actually finding the index, code further on makes no sense if there wasn't already a charge attribute.
   int ChargeAttribIndxA = tspeciesA.addAttribute("charge");
   int ChargeAttribIndxB = tspeciesB.addAttribute("charge");
   NptclA                = pset_ions_.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] = pset_ions_.groupsize(spec);
   }
   for (int spec = 0; spec < NumSpeciesB; spec++)
   {
     Qspec[spec]       = tspeciesB(ChargeAttribIndxB, spec);
     NofSpeciesB[spec] = P.groupsize(spec);
   }
   for (int iat = 0; iat < NptclA; iat++)
     Zat[iat] = Zspec[pset_ions_.GroupID[iat]];
   for (int iat = 0; iat < NptclB; iat++)
     Qat[iat] = Qspec[P.GroupID[iat]];
   //    if(totQ>std::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(pset_ions_.getLattice().LR_kc - P.getLattice().LR_kc) > std::numeric_limits<RealType>::epsilon());
   minkc = std::min(pset_ions_.getLattice().LR_kc, P.getLattice().LR_kc);
   //initBreakup is called only once
   AB      = LRCoulombSingleton::getHandler(P);
   myConst = evalConsts(P);
   myRcut  = AB->get_rc(); //Basis.get_rc();
   // create the spline function for the short-range part assuming pure potential
   auto myGrid  = LinearGrid<RealType>();
   const int ng = P.getLattice().num_ewald_grid_points;
   app_log() << "    CoulombPBCAB::initBreakup\n  Setting a linear grid=[0," << myRcut
             << ") number of grid points =" << ng << std::endl;
   myGrid.set(0, myRcut, ng);
   if (V0 == nullptr)
   {
     V0 = LRCoulombSingleton::createSpline4RbyVs(AB.get(), myRcut, myGrid);
     if (Vat.size())
     {
       APP_ABORT("CoulombPBCAB::initBreakup.  Vat is not empty\n");
     }
     Vat.resize(NptclA, V0.get());
     Vspec.resize(NumSpeciesA); //prepare for PP to overwrite it
   }
 
   //If ComputeForces is true, then we allocate space for the radial derivative functors.
   if (ComputeForces)
   {
     dAB = LRCoulombSingleton::getDerivHandler(P);
     if (fV0 == nullptr)
       fV0 = LRCoulombSingleton::createSpline4RbyVs(dAB.get(), myRcut, myGrid);
     if (dfV0 == nullptr)
       dfV0 = LRCoulombSingleton::createSpline4RbyVsDeriv(dAB.get(), myRcut, myGrid);
     if (fVat.size())
     {
       APP_ABORT("CoulombPBCAB::initBreakup.  Vat is not empty\n");
     }
     fVat.resize(NptclA, fV0.get());
     fdVat.resize(NptclA, dfV0.get());
     fVspec.resize(NumSpeciesA);
     fdVspec.resize(NumSpeciesA);
   }
 }

◆ makeClone()

std::unique_ptr< OperatorBase > makeClone	(	ParticleSet &	qp,
		TrialWaveFunction &	psi
	)

overridevirtual

Implements OperatorBase.

Definition at line 63 of file CoulombPBCAB.cpp.

 {
   return std::make_unique<CoulombPBCAB>(*this);
 }

◆ mw_evaluatePerParticle()

void mw_evaluatePerParticle	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< ListenerVector< RealType >> &	listeners,
		const std::vector< ListenerVector< RealType >> &	ion_listeners
	)		const

overridevirtual

Evaluate the contribution of this component of multiple walkers per particle reporting to registered listeners from Estimators.

Reimplemented from OperatorBase.

Definition at line 273 of file CoulombPBCAB.cpp.

References APP_ABORT, RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), RefVectorWithLeader< T >::getLeader(), OperatorBase::name_, CoulombPBCAB::NptclA, CoulombPBCAB::NptclB, qmcplusplus::pset, Vector< T, Alloc >::resize(), qmcplusplus::Units::time::s, qmcplusplus::SUPERCELL_SLAB, and OperatorBase::value_.

Referenced by qmcplusplus::TEST_CASE().

 {
   auto& o_leader = o_list.getCastedLeader<CoulombPBCAB>();
   auto& p_leader = p_list.getLeader();
   assert(this == &o_list.getLeader());
 
   auto num_centers            = p_leader.getTotalNum();
   auto& name                  = o_leader.name_;
   auto& mw_res                = o_leader.mw_res_handle_.getResource();
   Vector<RealType>& ve_sample = mw_res.pp_samples_trg;
   Vector<RealType>& vi_sample = mw_res.pp_samples_src;
   const auto& ve_consts       = mw_res.pp_consts_trg;
   const auto& vi_consts       = mw_res.pp_consts_src;
   auto num_species            = p_leader.getSpeciesSet().getTotalNum();
   ve_sample.resize(NptclB);
   vi_sample.resize(NptclA);
 
   // This lambda is mostly about getting a handle on what is being touched by the per particle evaluation.
   auto evaluate_walker = [name, &ve_sample, &vi_sample, &ve_consts,
                           &vi_consts](const int walker_index, const CoulombPBCAB& cpbcab, const ParticleSet& pset,
                                       const std::vector<ListenerVector<RealType>>& listeners,
                                       const std::vector<ListenerVector<RealType>>& ion_listeners) -> RealType {
     RealType Vsr = 0.0;
     RealType Vlr = 0.0;
     RealType Vc  = cpbcab.myConst;
     std::fill(ve_sample.begin(), ve_sample.end(), 0.0);
     std::fill(vi_sample.begin(), vi_sample.end(), 0.0);
     auto& pset_source = cpbcab.getSourcePSet();
     {
       //SR
       const auto& d_ab(pset.getDistTableAB(cpbcab.myTableIndex));
       RealType z;
       //Loop over distinct eln-ion pairs
       for (size_t b = 0; b < pset.getTotalNum(); ++b)
       {
         z                = 0.5 * cpbcab.Qat[b];
         const auto& dist = d_ab.getDistRow(b);
         for (size_t a = 0; a < pset_source.getTotalNum(); ++a)
         {
           Return_t pairpot = z * cpbcab.Zat[a] * cpbcab.Vat[a]->splint(dist[a]) / dist[a];
           vi_sample[a] += pairpot;
           ve_sample[b] += pairpot;
           Vsr += pairpot;
         }
       }
       Vsr *= 2.0;
     }
     {
       //LR
       // pset_ions_ is a smelly reference to the ion particle set.
       const StructFact& RhoKA(pset_source.getSK());
       const StructFact& RhoKB(pset.getSK());
       if (RhoKA.SuperCellEnum == SUPERCELL_SLAB)
       {
         APP_ABORT("CoulombPBCAB::evaluate_sp single particle traces have not been implemented for slab geometry");
       }
       else
       {
         assert(RhoKA.isStorePerParticle()); // ensure this so we know eikr_r has been allocated
         assert(RhoKB.isStorePerParticle());
         //jtk mark: needs optimizations. will likely require new function definitions
         RealType v1; //single particle energy
         RealType q;
         int num_species_source = pset_source.getSpeciesSet().size();
         for (int i = 0; i < pset.getTotalNum(); ++i)
         {
           q  = .5 * cpbcab.Qat[i];
           v1 = 0.0;
           for (int s = 0; s < num_species_source; s++)
             v1 += cpbcab.Zspec[s] * q *
                 cpbcab.AB->evaluate(pset_source.getSimulationCell().getKLists().kshell, RhoKA.rhok_r[s],
                                     RhoKA.rhok_i[s], RhoKB.eikr_r[i], RhoKB.eikr_i[i]);
           ve_sample[i] += v1;
           Vlr += v1;
         }
         int num_species_target = pset.getSpeciesSet().size();
         for (int i = 0; i < pset_source.getTotalNum(); ++i)
         {
           q  = .5 * cpbcab.Zat[i];
           v1 = 0.0;
           for (int s = 0; s < num_species_target; s++)
             v1 += cpbcab.Qspec[s] * q *
                 cpbcab.AB->evaluate(pset.getSimulationCell().getKLists().kshell, RhoKB.rhok_r[s], RhoKB.rhok_i[s],
                                     RhoKA.eikr_r[i], RhoKA.eikr_i[i]);
           vi_sample[i] += v1;
           Vlr += v1;
         }
       }
     }
     for (int i = 0; i < ve_sample.size(); ++i)
       ve_sample[i] += ve_consts[i];
     for (int i = 0; i < vi_sample.size(); ++i)
       vi_sample[i] += vi_consts[i];
     RealType value = Vsr + Vlr + Vc;
     for (const ListenerVector<RealType>& listener : listeners)
       listener.report(walker_index, name, ve_sample);
     for (const ListenerVector<RealType>& ion_listener : ion_listeners)
       ion_listener.report(walker_index, name, vi_sample);
     return value;
   };
 
   for (int iw = 0; iw < o_list.size(); iw++)
   {
     auto& coulomb_ab  = o_list.getCastedElement<CoulombPBCAB>(iw);
     coulomb_ab.value_ = evaluate_walker(iw, coulomb_ab, p_list[iw], listeners, ion_listeners);
   }
 }

◆ put()

bool put ( xmlNodePtr cur )

inlineoverridevirtual

Do nothing.

Implements OperatorBase.

Definition at line 163 of file CoulombPBCAB.h.

163 { return true; }

◆ releaseResource()

void releaseResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< OperatorBase > &	o_list
	)		const

overridevirtual

return a shared resource to a collection

Reimplemented from OperatorBase.

Definition at line 756 of file CoulombPBCAB.cpp.

References RefVectorWithLeader< T >::getCastedLeader(), and ResourceCollection::takebackResource().

 {
   auto& o_leader = o_list.getCastedLeader<CoulombPBCAB>();
   collection.takebackResource(o_leader.mw_res_handle_);
 }

◆ resetTargetParticleSet()

void resetTargetParticleSet ( ParticleSet & P )

overridevirtual

Reset the data with the target ParticleSet.

Parameters

P	new target ParticleSet

Implements OperatorBase.

Definition at line 70 of file CoulombPBCAB.cpp.

References CoulombPBCAB::AB, ParticleSet::addTable(), APP_ABORT, CoulombPBCAB::myTableIndex, and CoulombPBCAB::pset_ions_.

 {
   int tid = P.addTable(pset_ions_);
   if (tid != myTableIndex)
   {
     APP_ABORT("CoulombPBCAB::resetTargetParticleSet found inconsistent table index");
   }
   AB->resetTargetParticleSet(P);
 }

◆ setObservables()

void setObservables ( PropertySetType & plist )

inlineoverridevirtual

Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_.

Parameters

plist RecordNameProperty

Reimplemented from OperatorBase.

Definition at line 188 of file CoulombPBCAB.h.

References CoulombPBCAB::ComputeForces, OperatorBase::setObservables(), and ForceBase::setObservablesF().

   {
     OperatorBase::setObservables(plist);
     if (ComputeForces)
       setObservablesF(plist);
   }

◆ setParticlePropertyList()

void setParticlePropertyList	(	PropertySetType &	plist,
		int	offset
	)

inlineoverridevirtual

Reimplemented from OperatorBase.

Definition at line 195 of file CoulombPBCAB.h.

References CoulombPBCAB::ComputeForces, OperatorBase::setParticlePropertyList(), and ForceBase::setParticleSetF().

   {
     OperatorBase::setParticlePropertyList(plist, offset);
     if (ComputeForces)
       setParticleSetF(plist, offset);
   }

Member Data Documentation

◆ AB

std::shared_ptr<LRHandlerType> AB

long-range Handler. Should be const LRHandlerType eventually

Definition at line 47 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::CoulombPBCAB(), CoulombPBCAB::evalConsts(), CoulombPBCAB::evalLR(), CoulombPBCAB::evalPerParticleConsts(), CoulombPBCAB::evaluate_sp(), CoulombPBCAB::initBreakup(), and CoulombPBCAB::resetTargetParticleSet().

◆ ComputeForces

bool ComputeForces

Flag for whether to compute forces or not.

Definition at line 71 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::addObservables(), CoulombPBCAB::CoulombPBCAB(), CoulombPBCAB::evaluate(), CoulombPBCAB::evaluateWithIonDerivs(), CoulombPBCAB::initBreakup(), CoulombPBCAB::setObservables(), and CoulombPBCAB::setParticlePropertyList().

◆ dAB

std::shared_ptr<const LRHandlerType> dAB

long-range derivative handler

Definition at line 49 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::evalLRwithForces(), and CoulombPBCAB::initBreakup().

◆ dfV0

std::shared_ptr<const RadFunctorType> dfV0

Radial functor for derivative of bare coulomb, optimized for forces.

Definition at line 69 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::initBreakup().

◆ fdVat

std::vector<const RadFunctorType*> fdVat

Definition at line 92 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::evalSRwithForces(), and CoulombPBCAB::initBreakup().

◆ fdVspec

std::vector<std::shared_ptr<const RadFunctorType> > fdVspec

Definition at line 95 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), and CoulombPBCAB::initBreakup().

◆ fV0

std::shared_ptr<const RadFunctorType> fV0

Radial functor for bare coulomb, optimized for forces.

Definition at line 67 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::initBreakup().

◆ fVat

std::vector<const RadFunctorType*> fVat

Short-range potential (r*V) and potential derivative d/dr(rV) derivative for each ion Required for force evaluations.

Definition at line 91 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::evalSRwithForces(), and CoulombPBCAB::initBreakup().

◆ fVspec

std::vector<std::shared_ptr<const RadFunctorType> > fVspec

Definition at line 94 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), and CoulombPBCAB::initBreakup().

◆ kcdifferent

bool kcdifferent

Definition at line 110 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::initBreakup().

◆ LRpart

Vector<RealType> LRpart

long-range per particle

Definition at line 106 of file CoulombPBCAB.h.

◆ LRtmp

RealType LRtmp

long-range part for the moved particle

Definition at line 102 of file CoulombPBCAB.h.

◆ minkc

RealType minkc

Definition at line 111 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::initBreakup().

◆ mw_res_handle_

ResourceHandle<CoulombPBCABMultiWalkerResource> mw_res_handle_

private

Definition at line 232 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::acquireResource().

◆ myConst

Return_t myConst

const energy after breakup

Definition at line 61 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evaluate(), CoulombPBCAB::evaluate_sp(), CoulombPBCAB::evaluateWithIonDerivs(), CoulombPBCAB::initBreakup(), and qmcplusplus::TEST_CASE().

◆ myRcut

RealType myRcut

cutoff radius of the short-range part

Definition at line 63 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::CoulombPBCAB(), and CoulombPBCAB::initBreakup().

◆ myTableIndex

const int myTableIndex

locator of the distance table

Definition at line 51 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalSR(), CoulombPBCAB::evalSRwithForces(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::resetTargetParticleSet().

◆ NofSpeciesA

std::vector<int> NofSpeciesA

number of particles per species of A

Definition at line 74 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), CoulombPBCAB::evalPerParticleConsts(), and CoulombPBCAB::initBreakup().

◆ NofSpeciesB

std::vector<int> NofSpeciesB

number of particles per species of B

Definition at line 76 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), CoulombPBCAB::evalPerParticleConsts(), and CoulombPBCAB::initBreakup().

◆ NptclA

int NptclA

number of particles of A

Definition at line 57 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::evalSR(), CoulombPBCAB::evalSRwithForces(), CoulombPBCAB::evaluate_sp(), CoulombPBCAB::initBreakup(), and CoulombPBCAB::mw_evaluatePerParticle().

◆ NptclB

int NptclB

number of particles of B

Definition at line 59 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalSR(), CoulombPBCAB::evalSRwithForces(), CoulombPBCAB::evaluate_sp(), CoulombPBCAB::initBreakup(), and CoulombPBCAB::mw_evaluatePerParticle().

◆ NumSpeciesA

int NumSpeciesA

number of species of A particle set

Definition at line 53 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), CoulombPBCAB::evalLR(), CoulombPBCAB::evalPerParticleConsts(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::initBreakup().

◆ NumSpeciesB

int NumSpeciesB

number of species of B particle set

Definition at line 55 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), CoulombPBCAB::evalLR(), CoulombPBCAB::evalLRwithForces(), CoulombPBCAB::evalPerParticleConsts(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::initBreakup().

◆ Peln

ParticleSet& Peln

Definition at line 123 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::checkoutParticleQuantities(), CoulombPBCAB::evalConsts(), CoulombPBCAB::evalPerParticleConsts(), and CoulombPBCAB::informOfPerParticleListener().

◆ pset_ions_

ParticleSet& pset_ions_

private

source particle set

Definition at line 230 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::checkoutParticleQuantities(), CoulombPBCAB::CoulombPBCAB(), CoulombPBCAB::evalConsts(), CoulombPBCAB::evalLR(), CoulombPBCAB::evalLRwithForces(), CoulombPBCAB::evalPerParticleConsts(), CoulombPBCAB::evaluate_sp(), CoulombPBCAB::get(), CoulombPBCAB::getSourcePSet(), CoulombPBCAB::informOfPerParticleListener(), CoulombPBCAB::initBreakup(), and CoulombPBCAB::resetTargetParticleSet().

◆ Qat

std::vector<RealType> Qat

Qat[iat] charge for the iat-th particle of B.

Definition at line 80 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), CoulombPBCAB::evalPerParticleConsts(), CoulombPBCAB::evalSR(), CoulombPBCAB::evalSRwithForces(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::initBreakup().

◆ Qspec

std::vector<RealType> Qspec

Qspec[spec] charge for the spec-th species of B.

Definition at line 84 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), CoulombPBCAB::evalLR(), CoulombPBCAB::evalLRwithForces(), CoulombPBCAB::evalPerParticleConsts(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::initBreakup().

◆ SRpart

Vector<RealType> SRpart

short-range per particle

Definition at line 104 of file CoulombPBCAB.h.

◆ SRtmp

RealType SRtmp

short-range part for the moved particle

Definition at line 100 of file CoulombPBCAB.h.

◆ V0

std::shared_ptr<const RadFunctorType> V0

Always mave a radial functor for the bare coulomb.

Definition at line 65 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), and CoulombPBCAB::initBreakup().

◆ Vat

std::vector<const RadFunctorType*> Vat

Short-range potential for each ion.

Definition at line 86 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), CoulombPBCAB::evalSR(), CoulombPBCAB::evalSRwithForces(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::initBreakup().

◆ Ve_const

Array<TraceReal, 1> Ve_const

Definition at line 117 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), and CoulombPBCAB::evaluate_sp().

◆ Ve_sample

Array<TraceReal, 1>* Ve_sample

Definition at line 115 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::checkoutParticleQuantities(), CoulombPBCAB::deleteParticleQuantities(), and CoulombPBCAB::evaluate_sp().

◆ Vi_const

Array<TraceReal, 1> Vi_const

Definition at line 118 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), and CoulombPBCAB::evaluate_sp().

◆ Vi_sample

Array<TraceReal, 1>* Vi_sample

Definition at line 116 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::checkoutParticleQuantities(), CoulombPBCAB::deleteParticleQuantities(), and CoulombPBCAB::evaluate_sp().

◆ Vspec

std::vector<std::shared_ptr<RadFunctorType> > Vspec

Short-range potential for each species.

Definition at line 88 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::add(), and CoulombPBCAB::initBreakup().

◆ Zat

std::vector<RealType> Zat

Zat[iat] charge for the iat-th particle of A.

Definition at line 78 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), CoulombPBCAB::evalLRwithForces(), CoulombPBCAB::evalPerParticleConsts(), CoulombPBCAB::evalSR(), CoulombPBCAB::evalSRwithForces(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::initBreakup().

◆ Zspec

std::vector<RealType> Zspec

Zspec[spec] charge for the spec-th species of A.

Definition at line 82 of file CoulombPBCAB.h.

Referenced by CoulombPBCAB::evalConsts(), CoulombPBCAB::evalLR(), CoulombPBCAB::evalPerParticleConsts(), CoulombPBCAB::evaluate_sp(), and CoulombPBCAB::initBreakup().

◆ qmcplusplus::L2Potential

struct qmcplusplus::L2Potential

Evaluate the L2 potentials around each ion.

Definition at line 57 of file L2Potential.h.

Inheritance diagram for L2Potential:

Collaboration diagram for L2Potential:

Public Member Functions
	L2Potential (const ParticleSet &ions, ParticleSet &els, TrialWaveFunction &psi)

bool	dependsOnWaveFunction () const override
	return true if this operator depends on a wavefunction More...

std::string	getClassName () const override
	return class name More...

void	resetTargetParticleSet (ParticleSet &P) override
	Reset the data with the target ParticleSet. More...

Return_t	evaluate (ParticleSet &P) override
	Evaluate the local energy contribution of this component. More...

void	evaluateDK (ParticleSet &P, int iel, TensorType &D, PosType &K)

void	evaluateD (ParticleSet &P, int iel, TensorType &D)

bool	put (xmlNodePtr cur) override
	Read the input parameter. More...

bool	get (std::ostream &os) const override
	write about the class More...

std::unique_ptr< OperatorBase >	makeClone (ParticleSet &qp, TrialWaveFunction &psi) final

void	add (int groupID, std::unique_ptr< L2RadialPotential > &&ppot)
	Add a RadialPotentialType of a species. More...

Public Member Functions inherited from OperatorBase
	OperatorBase ()
	Construct a new Operator Base object Default and unique empty constructor. More...

virtual	~OperatorBase ()=default

std::bitset< 8 > &	getUpdateMode () noexcept
	get update_mode_ reference More...

Return_t	getValue () const noexcept
	get a copy of value_ More...

std::string	getName () const noexcept
	getter a copy of my_name_, rvalue small string optimization More...

void	setName (const std::string name) noexcept
	Set my_name member, uses small string optimization (pass by value) More...

TraceRequest &	getRequest () noexcept
	Get request_ member. More...

virtual void	addObservables (PropertySetType &plist, BufferType &collectables)
	named values to the property list Default implementaton uses addValue(plist_) More...

virtual void	registerObservables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const
	add to observable descriptor for hdf5 The default implementation is to register a scalar for this->value_ More...

virtual void	registerCollectables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const

virtual void	setObservables (PropertySetType &plist)
	Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_. More...

virtual void	setParticlePropertyList (PropertySetType &plist, int offset)

virtual void	setHistories (Walker_t &ThisWalker)

virtual Return_t	evaluateDeterministic (ParticleSet &P)
	Evaluate the local energy contribution of this component, deterministically based on current state. More...

virtual void	mw_evaluate (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticle (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual void	mw_evaluateWithParameterDerivatives (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< ParticleSet > &p_list, const opt_variables_type &optvars, const RecordArray< ValueType > &dlogpsi, RecordArray< ValueType > &dhpsioverpsi) const
	TODO: add docs. More...

virtual Return_t	rejectedMove (ParticleSet &P)
	TODO: add docs. More...

virtual Return_t	evaluateWithToperator (ParticleSet &P)
	Evaluate the local energy contribution of this component with Toperators updated if requested. More...

virtual void	mw_evaluateWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticleWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual Return_t	evaluateValueAndDerivatives (ParticleSet &P, const opt_variables_type &optvars, const Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	Evaluate value and derivatives wrt the optimizables. More...

virtual Return_t	evaluateWithIonDerivs (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_term, ParticleSet::ParticlePos &pulay_term)
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

virtual Return_t	evaluateWithIonDerivsDeterministic (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_term, ParticleSet::ParticlePos &pulay_term)
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

virtual void	evaluateOneBodyOpMatrix (ParticleSet &P, const TWFFastDerivWrapper &psi, std::vector< ValueMatrix > &B)
	Evaluate "B" matrix for observable. More...

virtual void	evaluateOneBodyOpMatrixForceDeriv (ParticleSet &P, ParticleSet &source, const TWFFastDerivWrapper &psi, const int iat, std::vector< std::vector< ValueMatrix >> &Bforce)
	Evaluate "dB/dR" matrices for observable. More...

virtual void	updateSource (ParticleSet &s)
	Update data associated with a particleset. More...

virtual Return_t	getEnsembleAverage ()
	Return an average value by collective operation. More...

virtual void	createResource (ResourceCollection &collection) const
	Initialize a shared resource and hand it to a collection. More...

virtual void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const
	Acquire a shared resource from a collection. More...

virtual void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const
	Return a shared resource to a collection. More...

virtual void	setRandomGenerator (RandomBase< FullPrecRealType > *rng)
	Set the Random Generator object TODO: add docs. More...

virtual void	add2Hamiltonian (ParticleSet &qp, TrialWaveFunction &psi, QMCHamiltonian &targetH)
	TODO: add docs. More...

virtual void	getRequiredTraces (TraceManager &tm)
	TODO: add docs. More...

virtual void	informOfPerParticleListener ()

bool	isClassical () const noexcept

bool	isQuantum () const noexcept

bool	isClassicalClassical () const noexcept

bool	isQuantumClassical () const noexcept

bool	isQuantumQuantum () const noexcept

bool	getMode (const int i) const noexcept
	Return the mode i. More...

bool	isNonLocal () const noexcept
	TODO: add docs. More...

bool	hasListener () const noexcept

void	contributeTraceQuantities ()
	Make trace quantities available. More...

void	checkoutTraceQuantities (TraceManager &tm)
	Checkout trace arrays Derived classes must guard individual checkouts using request info. More...

void	collectScalarTraces ()
	Collect scalar trace data. More...

void	deleteTraceQuantities ()
	delete trace arrays More...

Public Attributes
const ParticleSet &	IonConfig
	reference to the ionic configuration More...

int	NumIons
	the number of ions More...

int	myTableIndex
	distance table index More...

std::vector< std::unique_ptr< L2RadialPotential > >	PPset
	unique set of L2 PP to cleanup More...

std::vector< L2RadialPotential * >	PP
	PP[iat] is the L2 potential for the iat-th particle. More...

TrialWaveFunction *	psi_ref
	Associated trial wavefunction. More...

Additional Inherited Members
Public Types inherited from OperatorBase
enum	EnergyDomains { KINETIC = 0, POTENTIAL, NO_ENERGY_DOMAIN }
	enum to denote energy domain of operators More...

enum	QuantumDomains { NO_QUANTUM_DOMAIN = 0, CLASSICAL, QUANTUM, CLASSICAL_CLASSICAL, QUANTUM_CLASSICAL, QUANTUM_QUANTUM }

enum	{ PRIMARY = 0, OPTIMIZABLE = 1, RATIOUPDATE = 2, PHYSICAL = 3, COLLECTABLE = 4, NONLOCAL = 5 }
	enum for update_mode More...

using	Return_t = FullPrecRealType
	type of return value of evaluate More...

using	ValueMatrix = SPOSet::ValueMatrix
	For fast derivative evaluation. More...

using	GradMatrix = SPOSet::GradMatrix

using	BufferType = ParticleSet::Buffer_t
	typedef for the serialized buffer More...

using	Walker_t = ParticleSet::Walker_t
	typedef for the walker More...

using	ParticleScalar = ParticleSet::Scalar_t
	typedef for the ParticleScalar More...

using	SPOMap = SPOSet::SPOMap
	typedef for SPOMap More...

Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...

using	PtclGrpIndexes = std::vector< std::pair< int, int > >

Protected Member Functions inherited from OperatorBase
virtual void	contributeScalarQuantities ()

virtual void	checkoutScalarQuantities (TraceManager &tm)

virtual void	collectScalarQuantities ()

virtual void	deleteScalarQuantities ()

virtual void	contributeParticleQuantities ()

virtual void	checkoutParticleQuantities (TraceManager &tm)

virtual void	deleteParticleQuantities ()

virtual void	setComputeForces (bool compute)

void	setEnergyDomain (EnergyDomains edomain)
	Set the Energy Domain. More...

void	setQuantumDomain (QuantumDomains qdomain)
	set quantum domain More...

void	oneBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for one-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for two-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P1, const ParticleSet &P2)
	set quantum domain for two-body operator More...

void	addValue (PropertySetType &plist)
	named values to the property list More...

Protected Attributes inherited from OperatorBase
std::bitset< 8 >	update_mode_
	set the current update mode More...

Return_t	value_
	current value More...

std::string	name_
	name of this object More...

TraceRequest	request_
	whether traces are being collected More...

int	my_index_
	starting index of this object More...

Return_t	new_value_
	a new value for a proposed move More...

Walker_t *	t_walker_
	reference to the current walker More...

bool	streaming_particles_

bool	have_required_traces_

Constructor & Destructor Documentation

◆ L2Potential()

L2Potential	(	const ParticleSet &	ions,
		ParticleSet &	els,
		TrialWaveFunction &	psi
	)

Definition at line 20 of file L2Potential.cpp.

References ParticleSet::addTable(), ParticleSet::getSpeciesSet(), SpeciesSet::getTotalNum(), ParticleSet::getTotalNum(), L2Potential::myTableIndex, qmcplusplus::Units::time::ns, L2Potential::NumIons, OperatorBase::POTENTIAL, L2Potential::PP, L2Potential::PPset, L2Potential::psi_ref, OperatorBase::setEnergyDomain(), and OperatorBase::twoBodyQuantumDomain().

                                                                                           : IonConfig(ions)
 {
   setEnergyDomain(POTENTIAL);
   twoBodyQuantumDomain(ions, els);
   NumIons      = ions.getTotalNum();
   myTableIndex = els.addTable(ions);
   size_t ns    = ions.getSpeciesSet().getTotalNum();
   PPset.resize(ns);
   PP.resize(NumIons, nullptr);
   psi_ref = &psi;
 }

Member Function Documentation

◆ add()

void add	(	int	groupID,
		std::unique_ptr< L2RadialPotential > &&	ppot
	)

Add a RadialPotentialType of a species.

Parameters

groupID	index of the ion species
ppot	L2 pseudopotential

Definition at line 42 of file L2Potential.cpp.

References ParticleSet::GroupID, L2Potential::IonConfig, L2Potential::PP, and L2Potential::PPset.

 {
   for (int iat = 0; iat < PP.size(); iat++)
     if (IonConfig.GroupID[iat] == groupID)
       PP[iat] = ppot.get();
   PPset[groupID] = std::move(ppot);
 }

◆ dependsOnWaveFunction()

bool dependsOnWaveFunction ( ) const

inlineoverridevirtual

return true if this operator depends on a wavefunction

Reimplemented from OperatorBase.

Definition at line 74 of file L2Potential.h.

74 { return true; }

◆ evaluate()

L2Potential::Return_t evaluate ( ParticleSet & P )

overridevirtual

Evaluate the local energy contribution of this component.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Implements OperatorBase.

Definition at line 51 of file L2Potential.cpp.

References QMCTraits::DIM, TrialWaveFunction::evaluateHessian(), ParticleSet::G, ParticleSet::getDistTableAB(), ParticleSet::getTotalNum(), ParticleSet::L, L2Potential::myTableIndex, qmcplusplus::Units::force::N, qmcplusplus::n, L2Potential::NumIons, L2Potential::PP, L2Potential::psi_ref, and OperatorBase::value_.

 {
   // compute the Hessian
   TrialWaveFunction::HessVector D2;
   // evaluateHessian gives the Hessian(log(Psi))
   psi_ref->evaluateHessian(P, D2);
   // add gradient terms to get (Hessian(Psi))/Psi instead
   const size_t N = P.getTotalNum();
   for (size_t n = 0; n < N; n++)
     for (size_t i = 0; i < DIM; i++)
       for (size_t j = 0; j < DIM; j++)
         D2[n](i, j) += P.G[n][i] * P.G[n][j];
 
   // compute v_L2(r)*L^2 for all electron-ion pairs
   const auto& d_table(P.getDistTableAB(myTableIndex));
   value_             = 0.0;
   const size_t Nelec = P.getTotalNum();
   for (size_t iel = 0; iel < Nelec; ++iel)
   {
     const auto Le    = P.L[iel];
     const auto& ge   = P.G[iel];
     const auto& D2e  = D2[iel];
     const auto& dist = d_table.getDistRow(iel);
     const auto& disp = d_table.getDisplRow(iel);
     Return_t esum    = 0.0;
     for (size_t iat = 0; iat < NumIons; ++iat)
     {
       RealType r = dist[iat];
       if (PP[iat] != nullptr && r < PP[iat]->rcut)
       {
         PosType rv = disp[iat]; //SoA rv is r_I-r_e
         RealType v = -r * r * std::real(Le);
         for (int i = 0; i < DIM; ++i)
           v += -r * r * std::real(ge[i] * ge[i]) - 2 * rv[i] * std::real(ge[i]);
         for (int i = 0; i < DIM; ++i)
           for (int j = 0; j < DIM; ++j)
             v += rv[i] * std::real(D2e(i, j)) * rv[j];
         esum += v * PP[iat]->evaluate(dist[iat]);
       }
     }
     value_ += esum;
   }
   return value_;
 }

◆ evaluateD()

void evaluateD	(	ParticleSet &	P,
		int	iel,
		TensorType &	D
	)

Definition at line 126 of file L2Potential.cpp.

References Tensor< T, D >::diagonal(), QMCTraits::DIM, L2RadialPotential::evaluate(), ParticleSet::getDistTableAB(), L2Potential::myTableIndex, L2Potential::NumIons, and L2Potential::PP.

Referenced by QMCHamiltonian::computeL2D().

 {
   D = 0.0;
   D.diagonal(1.0);
 
   const auto& d_table(P.getDistTableAB(myTableIndex));
 
   for (int iat = 0; iat < NumIons; iat++)
   {
     L2RadialPotential* ppot = PP[iat];
     if (ppot == nullptr)
       continue;
     RealType r = d_table.getTempDists()[iat];
     if (r < ppot->rcut)
     {
       PosType rv   = d_table.getTempDispls()[iat];
       RealType vL2 = ppot->evaluate(r);
       for (int i = 0; i < DIM; ++i)
         D(i, i) += 2 * vL2 * r * r;
       for (int i = 0; i < DIM; ++i)
         for (int j = 0; j < DIM; ++j)
           D(i, j) -= 2 * vL2 * rv[i] * rv[j];
     }
   }
 }

◆ evaluateDK()

void evaluateDK	(	ParticleSet &	P,
		int	iel,
		TensorType &	D,
		PosType &	K
	)

Definition at line 97 of file L2Potential.cpp.

References Tensor< T, D >::diagonal(), QMCTraits::DIM, L2RadialPotential::evaluate(), ParticleSet::getDistTableAB(), qmcplusplus::Units::energy::K, L2Potential::myTableIndex, L2Potential::NumIons, and L2Potential::PP.

Referenced by QMCHamiltonian::computeL2DK().

 {
   K = 0.0;
   D = 0.0;
   D.diagonal(1.0);
 
   const auto& d_table(P.getDistTableAB(myTableIndex));
 
   for (int iat = 0; iat < NumIons; iat++)
   {
     L2RadialPotential* ppot = PP[iat];
     if (ppot == nullptr)
       continue;
     RealType r = d_table.getTempDists()[iat];
     if (r < ppot->rcut)
     {
       PosType rv   = -1 * d_table.getTempDispls()[iat];
       RealType vL2 = ppot->evaluate(r);
       K += 2 * rv * vL2;
       for (int i = 0; i < DIM; ++i)
         D(i, i) += 2 * vL2 * r * r;
       for (int i = 0; i < DIM; ++i)
         for (int j = 0; j < DIM; ++j)
           D(i, j) -= 2 * vL2 * rv[i] * rv[j];
     }
   }
 }

◆ get()

bool get ( std::ostream & os ) const

inlineoverridevirtual

write about the class

Implements OperatorBase.

Definition at line 86 of file L2Potential.h.

References OhmmsElementBase::getName(), and L2Potential::IonConfig.

   {
     os << "L2Potential: " << IonConfig.getName();
     return true;
   }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements OperatorBase.

Definition at line 75 of file L2Potential.h.

75 { return "L2Potential"; }

◆ makeClone()

std::unique_ptr< OperatorBase > makeClone	(	ParticleSet &	qp,
		TrialWaveFunction &	psi
	)

finalvirtual

Implements OperatorBase.

Definition at line 153 of file L2Potential.cpp.

References L2Potential::IonConfig, and L2Potential::PPset.

 {
   std::unique_ptr<L2Potential> myclone = std::make_unique<L2Potential>(IonConfig, qp, psi);
   for (int ig = 0; ig < PPset.size(); ++ig)
   {
     if (PPset[ig])
     {
       myclone->add(ig, std::unique_ptr<L2RadialPotential>(PPset[ig]->makeClone()));
     }
   }
   return myclone;
 }

◆ put()

bool put ( xmlNodePtr cur )

inlineoverridevirtual

Read the input parameter.

Parameters

cur	xml node for a OperatorBase object

Implements OperatorBase.

Definition at line 84 of file L2Potential.h.

84 { return true; }

◆ resetTargetParticleSet()

void resetTargetParticleSet ( ParticleSet & P )

overridevirtual

Reset the data with the target ParticleSet.

Parameters

P	new target ParticleSet

Implements OperatorBase.

Definition at line 32 of file L2Potential.cpp.

References ParticleSet::addTable(), APP_ABORT, L2Potential::IonConfig, and L2Potential::myTableIndex.

 {
   int tid = P.addTable(IonConfig);
   if (tid != myTableIndex)
   {
     APP_ABORT("  L2Potential::resetTargetParticleSet found a different distance table index.");
   }
 }

Member Data Documentation

◆ IonConfig

const ParticleSet& IonConfig

reference to the ionic configuration

Definition at line 60 of file L2Potential.h.

Referenced by L2Potential::add(), L2Potential::get(), L2Potential::makeClone(), and L2Potential::resetTargetParticleSet().

◆ myTableIndex

int myTableIndex

distance table index

Definition at line 64 of file L2Potential.h.

Referenced by L2Potential::evaluate(), L2Potential::evaluateD(), L2Potential::evaluateDK(), L2Potential::L2Potential(), and L2Potential::resetTargetParticleSet().

◆ NumIons

int NumIons

the number of ions

Definition at line 62 of file L2Potential.h.

Referenced by L2Potential::evaluate(), L2Potential::evaluateD(), L2Potential::evaluateDK(), and L2Potential::L2Potential().

◆ PP

std::vector<L2RadialPotential*> PP

PP[iat] is the L2 potential for the iat-th particle.

Definition at line 68 of file L2Potential.h.

Referenced by L2Potential::add(), L2Potential::evaluate(), L2Potential::evaluateD(), L2Potential::evaluateDK(), and L2Potential::L2Potential().

◆ PPset

std::vector<std::unique_ptr<L2RadialPotential> > PPset

unique set of L2 PP to cleanup

Definition at line 66 of file L2Potential.h.

Referenced by L2Potential::add(), L2Potential::L2Potential(), and L2Potential::makeClone().

◆ psi_ref

TrialWaveFunction* psi_ref

Associated trial wavefunction.

Definition at line 70 of file L2Potential.h.

Referenced by L2Potential::evaluate(), and L2Potential::L2Potential().

◆ qmcplusplus::LocalECPotential

struct qmcplusplus::LocalECPotential

Evaluate the local potentials (either pseudo or full core) around each ion.

Definition at line 33 of file LocalECPotential.h.

Inheritance diagram for LocalECPotential:

Collaboration diagram for LocalECPotential:

Public Types
using	GridType = OneDimGridBase< RealType >

using	RadialPotentialType = OneDimCubicSpline< RealType >

Public Types inherited from OperatorBase
enum	EnergyDomains { KINETIC = 0, POTENTIAL, NO_ENERGY_DOMAIN }
	enum to denote energy domain of operators More...

enum	QuantumDomains { NO_QUANTUM_DOMAIN = 0, CLASSICAL, QUANTUM, CLASSICAL_CLASSICAL, QUANTUM_CLASSICAL, QUANTUM_QUANTUM }

enum	{ PRIMARY = 0, OPTIMIZABLE = 1, RATIOUPDATE = 2, PHYSICAL = 3, COLLECTABLE = 4, NONLOCAL = 5 }
	enum for update_mode More...

using	Return_t = FullPrecRealType
	type of return value of evaluate More...

using	ValueMatrix = SPOSet::ValueMatrix
	For fast derivative evaluation. More...

using	GradMatrix = SPOSet::GradMatrix

using	BufferType = ParticleSet::Buffer_t
	typedef for the serialized buffer More...

using	Walker_t = ParticleSet::Walker_t
	typedef for the walker More...

using	ParticleScalar = ParticleSet::Scalar_t
	typedef for the ParticleScalar More...

using	SPOMap = SPOSet::SPOMap
	typedef for SPOMap More...

Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...

using	PtclGrpIndexes = std::vector< std::pair< int, int > >

Public Member Functions
	LocalECPotential (const ParticleSet &ions, ParticleSet &els)

std::string	getClassName () const override
	return class name More...

void	resetTargetParticleSet (ParticleSet &P) override
	Reset the data with the target ParticleSet. More...

void	contributeParticleQuantities () override

void	checkoutParticleQuantities (TraceManager &tm) override

Return_t	evaluate_sp (ParticleSet &P)

void	deleteParticleQuantities () override

Return_t	evaluate (ParticleSet &P) override
	Evaluate the local energy contribution of this component. More...

Return_t	evaluateWithIonDerivs (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_terms, ParticleSet::ParticlePos &pulay_terms) override
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

Return_t	evaluate_orig (ParticleSet &P)

bool	put (xmlNodePtr cur) override
	Read the input parameter. More...

bool	get (std::ostream &os) const override
	write about the class More...

std::unique_ptr< OperatorBase >	makeClone (ParticleSet &qp, TrialWaveFunction &psi) override

void	add (int groupID, std::unique_ptr< RadialPotentialType > &&ppot, RealType z)
	Add a RadialPotentialType of a species. More...

Public Member Functions inherited from OperatorBase
	OperatorBase ()
	Construct a new Operator Base object Default and unique empty constructor. More...

virtual	~OperatorBase ()=default

virtual bool	dependsOnWaveFunction () const
	return true if this operator depends on a wavefunction More...

std::bitset< 8 > &	getUpdateMode () noexcept
	get update_mode_ reference More...

Return_t	getValue () const noexcept
	get a copy of value_ More...

std::string	getName () const noexcept
	getter a copy of my_name_, rvalue small string optimization More...

void	setName (const std::string name) noexcept
	Set my_name member, uses small string optimization (pass by value) More...

TraceRequest &	getRequest () noexcept
	Get request_ member. More...

virtual void	addObservables (PropertySetType &plist, BufferType &collectables)
	named values to the property list Default implementaton uses addValue(plist_) More...

virtual void	registerObservables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const
	add to observable descriptor for hdf5 The default implementation is to register a scalar for this->value_ More...

virtual void	registerCollectables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const

virtual void	setObservables (PropertySetType &plist)
	Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_. More...

virtual void	setParticlePropertyList (PropertySetType &plist, int offset)

virtual void	setHistories (Walker_t &ThisWalker)

virtual Return_t	evaluateDeterministic (ParticleSet &P)
	Evaluate the local energy contribution of this component, deterministically based on current state. More...

virtual void	mw_evaluate (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticle (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual void	mw_evaluateWithParameterDerivatives (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< ParticleSet > &p_list, const opt_variables_type &optvars, const RecordArray< ValueType > &dlogpsi, RecordArray< ValueType > &dhpsioverpsi) const
	TODO: add docs. More...

virtual Return_t	rejectedMove (ParticleSet &P)
	TODO: add docs. More...

virtual Return_t	evaluateWithToperator (ParticleSet &P)
	Evaluate the local energy contribution of this component with Toperators updated if requested. More...

virtual void	mw_evaluateWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticleWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual Return_t	evaluateValueAndDerivatives (ParticleSet &P, const opt_variables_type &optvars, const Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	Evaluate value and derivatives wrt the optimizables. More...

virtual Return_t	evaluateWithIonDerivsDeterministic (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_term, ParticleSet::ParticlePos &pulay_term)
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

virtual void	evaluateOneBodyOpMatrix (ParticleSet &P, const TWFFastDerivWrapper &psi, std::vector< ValueMatrix > &B)
	Evaluate "B" matrix for observable. More...

virtual void	evaluateOneBodyOpMatrixForceDeriv (ParticleSet &P, ParticleSet &source, const TWFFastDerivWrapper &psi, const int iat, std::vector< std::vector< ValueMatrix >> &Bforce)
	Evaluate "dB/dR" matrices for observable. More...

virtual void	updateSource (ParticleSet &s)
	Update data associated with a particleset. More...

virtual Return_t	getEnsembleAverage ()
	Return an average value by collective operation. More...

virtual void	createResource (ResourceCollection &collection) const
	Initialize a shared resource and hand it to a collection. More...

virtual void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const
	Acquire a shared resource from a collection. More...

virtual void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const
	Return a shared resource to a collection. More...

virtual void	setRandomGenerator (RandomBase< FullPrecRealType > *rng)
	Set the Random Generator object TODO: add docs. More...

virtual void	add2Hamiltonian (ParticleSet &qp, TrialWaveFunction &psi, QMCHamiltonian &targetH)
	TODO: add docs. More...

virtual void	getRequiredTraces (TraceManager &tm)
	TODO: add docs. More...

virtual void	informOfPerParticleListener ()

bool	isClassical () const noexcept

bool	isQuantum () const noexcept

bool	isClassicalClassical () const noexcept

bool	isQuantumClassical () const noexcept

bool	isQuantumQuantum () const noexcept

bool	getMode (const int i) const noexcept
	Return the mode i. More...

bool	isNonLocal () const noexcept
	TODO: add docs. More...

bool	hasListener () const noexcept

void	contributeTraceQuantities ()
	Make trace quantities available. More...

void	checkoutTraceQuantities (TraceManager &tm)
	Checkout trace arrays Derived classes must guard individual checkouts using request info. More...

void	collectScalarTraces ()
	Collect scalar trace data. More...

void	deleteTraceQuantities ()
	delete trace arrays More...

Public Attributes
const ParticleSet &	IonConfig
	reference to the ionic configuration More...

int	NumIons
	the number of ioncs More...

int	myTableIndex
	distance table index More...

RealType	PPtmp
	temporary energy per particle for pbyp move More...

std::vector< std::unique_ptr< RadialPotentialType > >	PPset
	unique set of local ECP to cleanup More...

std::vector< RadialPotentialType * >	PP
	PP[iat] is the local potential for the iat-th particle. More...

std::vector< RealType >	Zeff
	effective charge per ion More...

std::vector< RealType >	gZeff
	effective charge per species More...

Vector< RealType >	PPart
	energy per particle More...

Array< TraceReal, 1 > *	Ve_sample
	single particle trace samples More...

Array< TraceReal, 1 > *	Vi_sample

const ParticleSet &	Peln

const ParticleSet &	Pion

Additional Inherited Members
Protected Member Functions inherited from OperatorBase
virtual void	contributeScalarQuantities ()

virtual void	checkoutScalarQuantities (TraceManager &tm)

virtual void	collectScalarQuantities ()

virtual void	deleteScalarQuantities ()

virtual void	setComputeForces (bool compute)

void	setEnergyDomain (EnergyDomains edomain)
	Set the Energy Domain. More...

void	setQuantumDomain (QuantumDomains qdomain)
	set quantum domain More...

void	oneBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for one-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for two-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P1, const ParticleSet &P2)
	set quantum domain for two-body operator More...

void	addValue (PropertySetType &plist)
	named values to the property list More...

Protected Attributes inherited from OperatorBase
std::bitset< 8 >	update_mode_
	set the current update mode More...

Return_t	value_
	current value More...

std::string	name_
	name of this object More...

TraceRequest	request_
	whether traces are being collected More...

int	my_index_
	starting index of this object More...

Return_t	new_value_
	a new value for a proposed move More...

Walker_t *	t_walker_
	reference to the current walker More...

bool	streaming_particles_

bool	have_required_traces_

Member Typedef Documentation

◆ GridType

using GridType = OneDimGridBase<RealType>

Definition at line 35 of file LocalECPotential.h.

◆ RadialPotentialType

using RadialPotentialType = OneDimCubicSpline<RealType>

Definition at line 36 of file LocalECPotential.h.

Constructor & Destructor Documentation

◆ LocalECPotential()

LocalECPotential	(	const ParticleSet &	ions,
		ParticleSet &	els
	)

Definition at line 24 of file LocalECPotential.cpp.

References ParticleSet::addTable(), ParticleSet::getSpeciesSet(), SpeciesSet::getTotalNum(), ParticleSet::getTotalNum(), LocalECPotential::gZeff, LocalECPotential::myTableIndex, LocalECPotential::NumIons, OperatorBase::POTENTIAL, LocalECPotential::PP, LocalECPotential::PPset, OperatorBase::setEnergyDomain(), OperatorBase::twoBodyQuantumDomain(), and LocalECPotential::Zeff.

                                                                             : IonConfig(ions), Peln(els), Pion(ions)
 {
   setEnergyDomain(POTENTIAL);
   twoBodyQuantumDomain(ions, els);
   NumIons      = ions.getTotalNum();
   myTableIndex = els.addTable(ions);
   //allocate null
   PPset.resize(ions.getSpeciesSet().getTotalNum());
   PP.resize(NumIons, nullptr);
   Zeff.resize(NumIons, 0.0);
   gZeff.resize(ions.getSpeciesSet().getTotalNum(), 0);
 }

Member Function Documentation

◆ add()

void add	(	int	groupID,
		std::unique_ptr< RadialPotentialType > &&	ppot,
		RealType	z
	)

Add a RadialPotentialType of a species.

Parameters

groupID	index of the ion species
ppot	local pseudopotential
z	effective charge of groupID particle

Definition at line 46 of file LocalECPotential.cpp.

References ParticleSet::GroupID, LocalECPotential::gZeff, LocalECPotential::IonConfig, LocalECPotential::PP, LocalECPotential::PPset, and LocalECPotential::Zeff.

 {
   for (int iat = 0; iat < PP.size(); iat++)
   {
     if (IonConfig.GroupID[iat] == groupID)
     {
       PP[iat]   = ppot.get();
       Zeff[iat] = z;
     }
   }
   PPset[groupID] = std::move(ppot);
   gZeff[groupID] = z;
 }

◆ checkoutParticleQuantities()

void checkoutParticleQuantities ( TraceManager & tm )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 63 of file LocalECPotential.cpp.

References TraceManager::checkout_real(), OperatorBase::name_, LocalECPotential::Peln, LocalECPotential::Pion, OperatorBase::request_, TraceRequest::streaming_array(), OperatorBase::streaming_particles_, LocalECPotential::Ve_sample, and LocalECPotential::Vi_sample.

 {
   streaming_particles_ = request_.streaming_array(name_);
   if (streaming_particles_)
   {
     Ve_sample = tm.checkout_real<1>(name_, Peln);
     Vi_sample = tm.checkout_real<1>(name_, Pion);
   }
 }

◆ contributeParticleQuantities()

void contributeParticleQuantities ( )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 61 of file LocalECPotential.cpp.

References TraceRequest::contribute_array(), OperatorBase::name_, and OperatorBase::request_.

61 { request_.contribute_array(name_); }

TraceRequest request_

whether traces are being collected

Definition: OperatorBase.h:531

std::string name_

name of this object

Definition: OperatorBase.h:527

References ParticleSet::addTable(), ParticleSet::getSpeciesSet(), SpeciesSet::getTotalNum(), ParticleSet::getTotalNum(), ParticleSet::groups(), ParticleSet::groupsize(), NonLocalECPotential::IonConfig, NonLocalECPotential::myTableIndex, NonLocalECPotential::nlpp_jobs, OperatorBase::NONLOCAL, NonLocalECPotential::NumIons, OperatorBase::POTENTIAL, NonLocalECPotential::PP, NonLocalECPotential::PPset, ForceBase::prefix_, NonLocalECPotential::PulayTerm, Vector< T, Alloc >::resize(), OperatorBase::setEnergyDomain(), OperatorBase::twoBodyQuantumDomain(), and OperatorBase::update_mode_.

void contribute_array(const std::string &name, bool default_quantity=false)

Definition: TraceManager.h:198

◆ deleteParticleQuantities()

void deleteParticleQuantities ( )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 73 of file LocalECPotential.cpp.

References OperatorBase::streaming_particles_, LocalECPotential::Ve_sample, and LocalECPotential::Vi_sample.

 {
   if (streaming_particles_)
   {
     delete Ve_sample;
     delete Vi_sample;
   }
 }

◆ evaluate()

LocalECPotential::Return_t evaluate ( ParticleSet & P )

overridevirtual

Evaluate the local energy contribution of this component.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Implements OperatorBase.

Definition at line 84 of file LocalECPotential.cpp.

References LocalECPotential::evaluate_sp(), ParticleSet::getDistTableAB(), ParticleSet::getTotalNum(), LocalECPotential::myTableIndex, LocalECPotential::NumIons, LocalECPotential::PP, OperatorBase::streaming_particles_, OperatorBase::value_, and LocalECPotential::Zeff.

 {
 #if !defined(REMOVE_TRACEMANAGER)
   if (streaming_particles_)
     value_ = evaluate_sp(P);
   else
 #endif
   {
     const auto& d_table(P.getDistTableAB(myTableIndex));
     value_             = 0.0;
     const size_t Nelec = P.getTotalNum();
     for (size_t iel = 0; iel < Nelec; ++iel)
     {
       const auto& dist = d_table.getDistRow(iel);
       Return_t esum(0);
       for (size_t iat = 0; iat < NumIons; ++iat)
         if (PP[iat] != nullptr)
           esum += PP[iat]->splint(dist[iat]) * Zeff[iat] / dist[iat];
       value_ -= esum;
     }
   }
   return value_;
 }

◆ evaluate_orig()

LocalECPotential::Return_t evaluate_orig ( ParticleSet & P )

Definition at line 203 of file LocalECPotential.cpp.

References ParticleSet::getDistTableAB(), ParticleSet::getTotalNum(), LocalECPotential::myTableIndex, LocalECPotential::NumIons, LocalECPotential::PP, OperatorBase::value_, and LocalECPotential::Zeff.

Referenced by LocalECPotential::evaluate_sp().

 {
   const auto& d_table(P.getDistTableAB(myTableIndex));
   value_             = 0.0;
   const size_t Nelec = P.getTotalNum();
   for (size_t iel = 0; iel < Nelec; ++iel)
   {
     const auto& dist = d_table.getDistRow(iel);
     Return_t esum(0);
     for (size_t iat = 0; iat < NumIons; ++iat)
       if (PP[iat] != nullptr)
         esum += PP[iat]->splint(dist[iat]) * Zeff[iat] / dist[iat];
     value_ -= esum;
   }
   return value_;
 }

◆ evaluate_sp()

LocalECPotential::Return_t evaluate_sp ( ParticleSet & P )

Definition at line 144 of file LocalECPotential.cpp.

References qmcplusplus::abs(), APP_ABORT, qmcplusplus::app_log(), LocalECPotential::evaluate_orig(), ParticleSet::getDistTableAB(), ParticleSet::getTotalNum(), LocalECPotential::myTableIndex, LocalECPotential::NumIons, LocalECPotential::PP, Array< T, D, ALLOC >::sum(), TraceManager::trace_tol, OperatorBase::value_, LocalECPotential::Ve_sample, LocalECPotential::Vi_sample, and LocalECPotential::Zeff.

Referenced by LocalECPotential::evaluate().

 {
   const auto& d_table(P.getDistTableAB(myTableIndex));
   value_                      = 0.0;
   Array<RealType, 1>& Ve_samp = *Ve_sample;
   Array<RealType, 1>& Vi_samp = *Vi_sample;
   Ve_samp                     = 0.0;
   Vi_samp                     = 0.0;
 
   const size_t Nelec = P.getTotalNum();
   for (size_t iel = 0; iel < Nelec; ++iel)
   {
     const auto& dist = d_table.getDistRow(iel);
     Return_t esum(0), pairpot;
     for (size_t iat = 0; iat < NumIons; ++iat)
       if (PP[iat] != nullptr)
       {
         pairpot = -0.5 * PP[iat]->splint(dist[iat]) * Zeff[iat] / dist[iat];
         Vi_samp(iat) += pairpot;
         Ve_samp(iel) += pairpot;
         esum += pairpot;
       }
     value_ += esum;
   }
   value_ *= 2.0;
 
 #if defined(TRACE_CHECK)
   RealType Vnow  = Value;
   RealType Visum = Vi_samp.sum();
   RealType Vesum = Ve_samp.sum();
   RealType Vsum  = Vesum + Visum;
   RealType Vorig = evaluate_orig(P);
   if (std::abs(Vsum - Vnow) > TraceManager::trace_tol)
   {
     app_log() << "accumtest: LocalECPotential::evaluate()" << std::endl;
     app_log() << "accumtest:   tot:" << Vnow << std::endl;
     app_log() << "accumtest:   sum:" << Vsum << std::endl;
     APP_ABORT("Trace check failed");
   }
   if (std::abs(Vesum - Visum) > TraceManager::trace_tol)
   {
     app_log() << "sharetest: LocalECPotential::evaluate()" << std::endl;
     app_log() << "sharetest:   e share:" << Vesum << std::endl;
     app_log() << "sharetest:   i share:" << Visum << std::endl;
     APP_ABORT("Trace check failed");
   }
   if (std::abs(Vorig - Vnow) > TraceManager::trace_tol)
   {
     app_log() << "versiontest: LocalECPotential::evaluate()" << std::endl;
     app_log() << "versiontest:   orig:" << Vorig << std::endl;
     app_log() << "versiontest:    mod:" << Vnow << std::endl;
     APP_ABORT("Trace check failed");
   }
 #endif
   return value_;
 }

◆ evaluateWithIonDerivs()

LocalECPotential::Return_t evaluateWithIonDerivs	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_term,
		ParticleSet::ParticlePos &	pulay_term
	)

overridevirtual

Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase.

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Adds OperatorBase's contribution to Re [(dH)Psi]/Psi
pulay_terms	Adds OperatorBase's contribution to Re [(H-E_L)dPsi]/Psi

Returns: Contribution of OperatorBase to Local Energy.

Reimplemented from OperatorBase.

Definition at line 108 of file LocalECPotential.cpp.

References ParticleSet::getDistTableAB(), ParticleSet::getTotalNum(), LocalECPotential::myTableIndex, LocalECPotential::NumIons, LocalECPotential::PP, OperatorBase::value_, and LocalECPotential::Zeff.

 {
   const auto& d_table(P.getDistTableAB(myTableIndex));
   value_             = 0.0;
   const size_t Nelec = P.getTotalNum();
   for (size_t iel = 0; iel < Nelec; ++iel)
   {
     const auto& dist = d_table.getDistRow(iel);
     const auto& dr   = d_table.getDisplRow(iel);
     Return_t esum(0);
     //value, radial derivative, and 2nd derivative of spline r*V.
     RealType v(0.0), dv(0.0), d2v(0.0);
     //radial derivative dV/dr
     RealType dvdr(0.0);
     RealType rinv(1.0);
     for (size_t iat = 0; iat < NumIons; ++iat)
     {
       if (PP[iat] != nullptr)
       {
         rinv = 1.0 / dist[iat];
         v    = PP[iat]->splint(dist[iat], dv, d2v);
         dvdr = -Zeff[iat] * (dv - v * rinv) * rinv; //the minus is because of charge of electron.
         hf_terms[iat] += dvdr * dr[iat] * rinv;
         esum += -Zeff[iat] * v * rinv;
       }
     }
     value_ += esum;
   }
   return value_;
 }

◆ get()

bool get ( std::ostream & os ) const

inlineoverridevirtual

write about the class

Implements OperatorBase.

Definition at line 89 of file LocalECPotential.h.

References OhmmsElementBase::getName(), and LocalECPotential::IonConfig.

   {
     os << "LocalECPotential: " << IonConfig.getName();
     return true;
   }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements OperatorBase.

Definition at line 66 of file LocalECPotential.h.

66 { return "LocalECPotential"; }

◆ makeClone()

std::unique_ptr< OperatorBase > makeClone	(	ParticleSet &	qp,
		TrialWaveFunction &	psi
	)

overridevirtual

Implements OperatorBase.

Definition at line 220 of file LocalECPotential.cpp.

References LocalECPotential::gZeff, LocalECPotential::IonConfig, and LocalECPotential::PPset.

 {
   std::unique_ptr<LocalECPotential> myclone = std::make_unique<LocalECPotential>(IonConfig, qp);
 
   for (int ig = 0; ig < PPset.size(); ++ig)
   {
     if (PPset[ig])
     {
       myclone->add(ig, std::unique_ptr<RadialPotentialType>(PPset[ig]->makeClone()), gZeff[ig]);
     }
   }
   return myclone;
 }

◆ put()

bool put ( xmlNodePtr cur )

inlineoverridevirtual

Read the input parameter.

Parameters

cur	xml node for a OperatorBase object

Implements OperatorBase.

Definition at line 87 of file LocalECPotential.h.

87 { return true; }

◆ resetTargetParticleSet()

void resetTargetParticleSet ( ParticleSet & P )

overridevirtual

Reset the data with the target ParticleSet.

Parameters

P	new target ParticleSet

Implements OperatorBase.

Definition at line 37 of file LocalECPotential.cpp.

References ParticleSet::addTable(), APP_ABORT, LocalECPotential::IonConfig, and LocalECPotential::myTableIndex.

 {
   int tid = P.addTable(IonConfig);
   if (tid != myTableIndex)
   {
     APP_ABORT("  LocalECPotential::resetTargetParticleSet found a different distance table index.");
   }
 }

Member Data Documentation

◆ gZeff

std::vector<RealType> gZeff

effective charge per species

Definition at line 53 of file LocalECPotential.h.

Referenced by LocalECPotential::add(), LocalECPotential::LocalECPotential(), and LocalECPotential::makeClone().

◆ IonConfig

const ParticleSet& IonConfig

reference to the ionic configuration

Definition at line 39 of file LocalECPotential.h.

Referenced by LocalECPotential::add(), LocalECPotential::get(), LocalECPotential::makeClone(), and LocalECPotential::resetTargetParticleSet().

◆ myTableIndex

int myTableIndex

distance table index

Definition at line 43 of file LocalECPotential.h.

Referenced by LocalECPotential::evaluate(), LocalECPotential::evaluate_orig(), LocalECPotential::evaluate_sp(), LocalECPotential::evaluateWithIonDerivs(), LocalECPotential::LocalECPotential(), and LocalECPotential::resetTargetParticleSet().

◆ NumIons

int NumIons

the number of ioncs

Definition at line 41 of file LocalECPotential.h.

Referenced by LocalECPotential::evaluate(), LocalECPotential::evaluate_orig(), LocalECPotential::evaluate_sp(), LocalECPotential::evaluateWithIonDerivs(), and LocalECPotential::LocalECPotential().

◆ Peln

const ParticleSet& Peln

Definition at line 61 of file LocalECPotential.h.

Referenced by LocalECPotential::checkoutParticleQuantities().

◆ Pion

const ParticleSet& Pion

Definition at line 62 of file LocalECPotential.h.

Referenced by LocalECPotential::checkoutParticleQuantities().

◆ PP

std::vector<RadialPotentialType*> PP

PP[iat] is the local potential for the iat-th particle.

Definition at line 49 of file LocalECPotential.h.

Referenced by LocalECPotential::add(), LocalECPotential::evaluate(), LocalECPotential::evaluate_orig(), LocalECPotential::evaluate_sp(), LocalECPotential::evaluateWithIonDerivs(), and LocalECPotential::LocalECPotential().

◆ PPart

Vector<RealType> PPart

energy per particle

Definition at line 55 of file LocalECPotential.h.

◆ PPset

std::vector<std::unique_ptr<RadialPotentialType> > PPset

unique set of local ECP to cleanup

Definition at line 47 of file LocalECPotential.h.

Referenced by LocalECPotential::add(), LocalECPotential::LocalECPotential(), and LocalECPotential::makeClone().

◆ PPtmp

RealType PPtmp

temporary energy per particle for pbyp move

Definition at line 45 of file LocalECPotential.h.

◆ Ve_sample

Array<TraceReal, 1>* Ve_sample

single particle trace samples

Definition at line 58 of file LocalECPotential.h.

Referenced by LocalECPotential::checkoutParticleQuantities(), LocalECPotential::deleteParticleQuantities(), and LocalECPotential::evaluate_sp().

◆ Vi_sample

Array<TraceReal, 1>* Vi_sample

Definition at line 59 of file LocalECPotential.h.

Referenced by LocalECPotential::checkoutParticleQuantities(), LocalECPotential::deleteParticleQuantities(), and LocalECPotential::evaluate_sp().

◆ Zeff

std::vector<RealType> Zeff

effective charge per ion

Definition at line 51 of file LocalECPotential.h.

Referenced by LocalECPotential::add(), LocalECPotential::evaluate(), LocalECPotential::evaluate_orig(), LocalECPotential::evaluate_sp(), LocalECPotential::evaluateWithIonDerivs(), and LocalECPotential::LocalECPotential().

◆ qmcplusplus::MPC

class qmcplusplus::MPC

Calculates the Model Periodic Coulomb potential using PBCs.

Definition at line 33 of file MPC.h.

Inheritance diagram for MPC:

Collaboration diagram for MPC:

Public Member Functions
	MPC (ParticleSet &ref, double cutoff)

	~MPC () override
	copy constructor More...

std::string	getClassName () const override
	return class name More...

void	resetTargetParticleSet (ParticleSet &P) override
	Reset the data with the target ParticleSet. More...

Return_t	evaluate (ParticleSet &P) override
	Evaluate the local energy contribution of this component. More...

bool	put (xmlNodePtr cur) override
	Do nothing. More...

bool	get (std::ostream &os) const override
	write about the class More...

std::unique_ptr< OperatorBase >	makeClone (ParticleSet &qp, TrialWaveFunction &psi) override

Public Member Functions inherited from OperatorBase
	OperatorBase ()
	Construct a new Operator Base object Default and unique empty constructor. More...

virtual	~OperatorBase ()=default

virtual bool	dependsOnWaveFunction () const
	return true if this operator depends on a wavefunction More...

std::bitset< 8 > &	getUpdateMode () noexcept
	get update_mode_ reference More...

Return_t	getValue () const noexcept
	get a copy of value_ More...

std::string	getName () const noexcept
	getter a copy of my_name_, rvalue small string optimization More...

void	setName (const std::string name) noexcept
	Set my_name member, uses small string optimization (pass by value) More...

TraceRequest &	getRequest () noexcept
	Get request_ member. More...

virtual void	addObservables (PropertySetType &plist, BufferType &collectables)
	named values to the property list Default implementaton uses addValue(plist_) More...

virtual void	registerObservables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const
	add to observable descriptor for hdf5 The default implementation is to register a scalar for this->value_ More...

virtual void	registerCollectables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const

virtual void	setObservables (PropertySetType &plist)
	Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_. More...

virtual void	setParticlePropertyList (PropertySetType &plist, int offset)

virtual void	setHistories (Walker_t &ThisWalker)

virtual Return_t	evaluateDeterministic (ParticleSet &P)
	Evaluate the local energy contribution of this component, deterministically based on current state. More...

virtual void	mw_evaluate (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticle (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual void	mw_evaluateWithParameterDerivatives (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< ParticleSet > &p_list, const opt_variables_type &optvars, const RecordArray< ValueType > &dlogpsi, RecordArray< ValueType > &dhpsioverpsi) const
	TODO: add docs. More...

virtual Return_t	rejectedMove (ParticleSet &P)
	TODO: add docs. More...

virtual Return_t	evaluateWithToperator (ParticleSet &P)
	Evaluate the local energy contribution of this component with Toperators updated if requested. More...

virtual void	mw_evaluateWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticleWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual Return_t	evaluateValueAndDerivatives (ParticleSet &P, const opt_variables_type &optvars, const Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	Evaluate value and derivatives wrt the optimizables. More...

virtual Return_t	evaluateWithIonDerivs (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_term, ParticleSet::ParticlePos &pulay_term)
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

virtual Return_t	evaluateWithIonDerivsDeterministic (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_term, ParticleSet::ParticlePos &pulay_term)
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

virtual void	evaluateOneBodyOpMatrix (ParticleSet &P, const TWFFastDerivWrapper &psi, std::vector< ValueMatrix > &B)
	Evaluate "B" matrix for observable. More...

virtual void	evaluateOneBodyOpMatrixForceDeriv (ParticleSet &P, ParticleSet &source, const TWFFastDerivWrapper &psi, const int iat, std::vector< std::vector< ValueMatrix >> &Bforce)
	Evaluate "dB/dR" matrices for observable. More...

virtual void	updateSource (ParticleSet &s)
	Update data associated with a particleset. More...

virtual Return_t	getEnsembleAverage ()
	Return an average value by collective operation. More...

virtual void	createResource (ResourceCollection &collection) const
	Initialize a shared resource and hand it to a collection. More...

virtual void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const
	Acquire a shared resource from a collection. More...

virtual void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const
	Return a shared resource to a collection. More...

virtual void	setRandomGenerator (RandomBase< FullPrecRealType > *rng)
	Set the Random Generator object TODO: add docs. More...

virtual void	add2Hamiltonian (ParticleSet &qp, TrialWaveFunction &psi, QMCHamiltonian &targetH)
	TODO: add docs. More...

virtual void	getRequiredTraces (TraceManager &tm)
	TODO: add docs. More...

virtual void	informOfPerParticleListener ()

bool	isClassical () const noexcept

bool	isQuantum () const noexcept

bool	isClassicalClassical () const noexcept

bool	isQuantumClassical () const noexcept

bool	isQuantumQuantum () const noexcept

bool	getMode (const int i) const noexcept
	Return the mode i. More...

bool	isNonLocal () const noexcept
	TODO: add docs. More...

bool	hasListener () const noexcept

void	contributeTraceQuantities ()
	Make trace quantities available. More...

void	checkoutTraceQuantities (TraceManager &tm)
	Checkout trace arrays Derived classes must guard individual checkouts using request info. More...

void	collectScalarTraces ()
	Collect scalar trace data. More...

void	deleteTraceQuantities ()
	delete trace arrays More...

Public Attributes
std::vector< ComplexType >	RhoAvg_G

std::vector< RealType >	f_G

double	f_0

bool	FirstTime

int	NumSpecies

int	ChargeAttribIndx

int	MemberAttribIndx

int	NParticles

RealType	myConst

RealType	myRcut

std::vector< RealType >	Zat

std::vector< RealType >	Zspec

std::vector< int >	NofSpecies

Protected Member Functions
void	initBreakup (const ParticleSet &ptcl)

void	compute_g_G (const ParticleSet &ptcl, double &g_0_N, std::vector< double > &g_G_N, int N)

void	init_gvecs (const ParticleSet &ptcl)

void	init_f_G (const ParticleSet &ptcl)

void	init_spline (const ParticleSet &ptcl)

Return_t	evalSR (ParticleSet &P) const

Return_t	evalLR (ParticleSet &P) const

Protected Member Functions inherited from OperatorBase
virtual void	contributeScalarQuantities ()

virtual void	checkoutScalarQuantities (TraceManager &tm)

virtual void	collectScalarQuantities ()

virtual void	deleteScalarQuantities ()

virtual void	contributeParticleQuantities ()

virtual void	checkoutParticleQuantities (TraceManager &tm)

virtual void	deleteParticleQuantities ()

virtual void	setComputeForces (bool compute)

void	setEnergyDomain (EnergyDomains edomain)
	Set the Energy Domain. More...

void	setQuantumDomain (QuantumDomains qdomain)
	set quantum domain More...

void	oneBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for one-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for two-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P1, const ParticleSet &P2)
	set quantum domain for two-body operator More...

void	addValue (PropertySetType &plist)
	named values to the property list More...

Protected Attributes
std::shared_ptr< UBspline_3d_d >	VlongSpline

double	Vconst

double	Ecut

std::vector< TinyVector< int, OHMMS_DIM > >	Gints

std::vector< PosType >	Gvecs

std::vector< ComplexType >	Rho_G

std::array< size_t, OHMMS_DIM >	SplineDim

int	MaxDim

const int	d_aa_ID

Protected Attributes inherited from OperatorBase
std::bitset< 8 >	update_mode_
	set the current update mode More...

Return_t	value_
	current value More...

std::string	name_
	name of this object More...

TraceRequest	request_
	whether traces are being collected More...

int	my_index_
	starting index of this object More...

Return_t	new_value_
	a new value for a proposed move More...

Walker_t *	t_walker_
	reference to the current walker More...

bool	streaming_particles_

bool	have_required_traces_

Additional Inherited Members
Public Types inherited from OperatorBase
enum	EnergyDomains { KINETIC = 0, POTENTIAL, NO_ENERGY_DOMAIN }
	enum to denote energy domain of operators More...

enum	QuantumDomains { NO_QUANTUM_DOMAIN = 0, CLASSICAL, QUANTUM, CLASSICAL_CLASSICAL, QUANTUM_CLASSICAL, QUANTUM_QUANTUM }

enum	{ PRIMARY = 0, OPTIMIZABLE = 1, RATIOUPDATE = 2, PHYSICAL = 3, COLLECTABLE = 4, NONLOCAL = 5 }
	enum for update_mode More...

using	Return_t = FullPrecRealType
	type of return value of evaluate More...

using	ValueMatrix = SPOSet::ValueMatrix
	For fast derivative evaluation. More...

using	GradMatrix = SPOSet::GradMatrix

using	BufferType = ParticleSet::Buffer_t
	typedef for the serialized buffer More...

using	Walker_t = ParticleSet::Walker_t
	typedef for the walker More...

using	ParticleScalar = ParticleSet::Scalar_t
	typedef for the ParticleScalar More...

using	SPOMap = SPOSet::SPOMap
	typedef for SPOMap More...

Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...

using	PtclGrpIndexes = std::vector< std::pair< int, int > >

Constructor & Destructor Documentation

◆ MPC()

MPC	(	ParticleSet &	ref,
		double	cutoff
	)

Definition at line 35 of file MPC.cpp.

References MPC::initBreakup(), and qmcplusplus::NEED_FULL_TABLE_ON_HOST_AFTER_DONEPBYP.

     : Ecut(cutoff), d_aa_ID(ptcl.addTable(ptcl, DTModes::NEED_FULL_TABLE_ON_HOST_AFTER_DONEPBYP)), FirstTime(true)
 {
   initBreakup(ptcl);
 }

◆ ~MPC()

~MPC ( )

overridedefault

copy constructor

Member Function Documentation

◆ compute_g_G()

void compute_g_G	(	const ParticleSet &	ptcl,
		double &	g_0_N,
		std::vector< double > &	g_G_N,
		int	N
	)

protected

Definition at line 78 of file MPC.cpp.

References Array< T, D, ALLOC >::data(), ParticleSet::getLattice(), MPC::Gints, qmcplusplus::Units::force::N, norm(), OHMMS_DIM, qmcplusplus::real(), and qmcplusplus::sqrt().

Referenced by MPC::init_f_G().

 {
   double L     = ptcl.getLattice().WignerSeitzRadius;
   double Linv  = 1.0 / L;
   double Linv3 = Linv * Linv * Linv;
   // create an FFTW plan
   Array<std::complex<double>, 3> rBox(N, N, N);
   Array<std::complex<double>, 3> GBox(N, N, N);
   // app_log() << "Doing " << N << " x " << N << " x " << N << " FFT.\n";
   //create BC handler
   DTD_BConds<RealType, 3, SUPERCELL_BULK> mybc(ptcl.getLattice());
   // Fill the real-space array with f(r)
   double Ninv = 1.0 / (double)N;
   TinyVector<RealType, 3> u, r;
   for (int ix = 0; ix < N; ix++)
   {
     u[0] = Ninv * ix;
     for (int iy = 0; iy < N; iy++)
     {
       u[1] = Ninv * iy;
       for (int iz = 0; iz < N; iz++)
       {
         u[2] = Ninv * iz;
         r    = ptcl.getLattice().toCart(u);
         //DTD_BConds<double,3,SUPERCELL_BULK>::apply (ptcl.getLattice(), r);
         //double rmag = std::sqrt(dot(r,r));
         double rmag = std::sqrt(mybc.apply_bc(r));
         if (rmag < L)
           rBox(ix, iy, iz) = -0.5 * rmag * rmag * Linv3 + 1.5 * Linv;
         else
           rBox(ix, iy, iz) = 1.0 / rmag;
       }
     }
   }
   fftw_plan fft = fftw_plan_dft_3d(N, N, N, (fftw_complex*)rBox.data(), (fftw_complex*)GBox.data(), 1, FFTW_ESTIMATE);
   fftw_execute(fft);
   fftw_destroy_plan(fft);
   // Now, copy data into output, and add on analytic part
   double norm = Ninv * Ninv * Ninv;
   int numG    = Gints.size();
   for (int iG = 0; iG < numG; iG++)
   {
     TinyVector<int, OHMMS_DIM> gint = Gints[iG];
     for (int j = 0; j < OHMMS_DIM; j++)
       gint[j] = (gint[j] + N) % N;
     g_G[iG] = norm * real(GBox(gint[0], gint[1], gint[2]));
   }
   g_0 = norm * real(GBox(0, 0, 0));
 }

◆ evalLR()

MPC::Return_t evalLR ( ParticleSet & P ) const

protected

Definition at line 338 of file MPC.cpp.

References qmcplusplus::floor(), ParticleSet::getLattice(), MPC::NParticles, OHMMS_DIM, ParticleSet::R, and MPC::VlongSpline.

Referenced by MPC::evaluate().

 {
   RealType LR = 0.0;
   double val;
   for (int i = 0; i < NParticles; i++)
   {
     //PosType r = P.R[i];
     //PosType u = P.getLattice().toUnit(r);
     PosType u = P.getLattice().toUnit(P.R[i]);
     for (int j = 0; j < OHMMS_DIM; j++)
       u[j] -= std::floor(u[j]);
     eval_UBspline_3d_d(VlongSpline.get(), u[0], u[1], u[2], &val);
     LR += val;
   }
   return LR;
 }

◆ evalSR()

MPC::Return_t evalSR ( ParticleSet & P ) const

protected

Definition at line 322 of file MPC.cpp.

References BLAS::cone, MPC::d_aa_ID, ParticleSet::getDistTableAA(), and MPC::NParticles.

Referenced by MPC::evaluate().

 {
   const auto& d_aa = P.getDistTableAA(d_aa_ID);
   RealType SR      = 0.0;
   const RealType cone(1);
   for (size_t ipart = 0; ipart < NParticles; ipart++)
   {
     RealType esum(0);
     const auto& dist = d_aa.getDistRow(ipart);
     for (size_t j = 0; j < ipart; ++j)
       esum += cone / dist[j];
     SR += esum;
   }
   return SR;
 }

◆ evaluate()

MPC::Return_t evaluate ( ParticleSet & P )

overridevirtual

Evaluate the local energy contribution of this component.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Implements OperatorBase.

Definition at line 355 of file MPC.cpp.

References MPC::evalLR(), MPC::evalSR(), OperatorBase::value_, and MPC::Vconst.

 {
   value_ = evalSR(P) + evalLR(P) + Vconst;
   return value_;
 }

◆ get()

bool get ( std::ostream & os ) const

inlineoverridevirtual

write about the class

Implements OperatorBase.

Definition at line 88 of file MPC.h.

   {
     //os << "MPC potential: " << PtclRef->getName();
     return true;
   }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements OperatorBase.

Definition at line 80 of file MPC.h.

80 { return "MPC"; }

◆ init_f_G()

void init_f_G ( const ParticleSet & ptcl )

protected

Definition at line 165 of file MPC.cpp.

References qmcplusplus::abs(), qmcplusplus::app_log(), MPC::compute_g_G(), qmcplusplus::cos(), qmcplusplus::dot(), qmcplusplus::extrap(), MPC::f_0, MPC::f_G, ParticleSet::getLattice(), MPC::Gints, MPC::Gvecs, MPC::MaxDim, qmcplusplus::Units::force::N, qmcplusplus::sin(), and qmcplusplus::sqrt().

Referenced by MPC::initBreakup().

 {
   int numG = Gints.size();
   f_G.resize(numG);
   int N = std::max(64, 2 * MaxDim + 1);
   std::vector<double> g_G_N(numG), g_G_2N(numG), g_G_4N(numG);
   double g_0_N, g_0_2N, g_0_4N;
   compute_g_G(ptcl, g_0_N, g_G_N, 1 * N);
   compute_g_G(ptcl, g_0_2N, g_G_2N, 2 * N);
   compute_g_G(ptcl, g_0_4N, g_G_4N, 4 * N);
   // fprintf (stderr, "g_G_1N[0]      = %18.14e\n", g_G_N[0]);
   // fprintf (stderr, "g_G_2N[0]      = %18.14e\n", g_G_2N[0]);
   // fprintf (stderr, "g_G_4N[0]      = %18.14e\n", g_G_4N[0]);
   double volInv = 1.0 / ptcl.getLattice().Volume;
   double L      = ptcl.getLattice().WignerSeitzRadius;
   TinyVector<double, 2> g0_12(g_0_2N, g_0_4N);
   TinyVector<double, 3> g0_124(g_0_N, g_0_2N, g_0_4N);
   f_0 = extrap(N, g0_124);
   app_log().precision(12);
   app_log() << "    Linear extrap    = " << std::scientific << extrap(2 * N, g0_12) << std::endl;
   app_log() << "    Quadratic extrap = " << std::scientific << f_0 << std::endl;
   f_0 += 0.4 * M_PI * L * L * volInv;
   // std::cerr << "f_0 = " << f_0/volInv << std::endl;
   double worst = 0.0, worstLin = 0.0, worstQuad = 0.0;
   for (int iG = 0; iG < numG; iG++)
   {
     TinyVector<double, 2> g_12(g_G_2N[iG], g_G_4N[iG]);
     TinyVector<double, 3> g_124(g_G_N[iG], g_G_2N[iG], g_G_4N[iG]);
     double linearExtrap = extrap(2 * N, g_12);
     double quadExtrap   = extrap(N, g_124);
     double diff         = std::abs(linearExtrap - quadExtrap);
     if (diff > worst)
     {
       worst     = diff;
       worstLin  = linearExtrap;
       worstQuad = quadExtrap;
     }
     f_G[iG]   = quadExtrap;
     double G2 = dot(Gvecs[iG], Gvecs[iG]);
     double G  = std::sqrt(G2);
     f_G[iG] += volInv * M_PI * (4.0 / G2 + 12.0 / (L * L * G2 * G2) * (std::cos(G * L) - std::sin(G * L) / (G * L)));
     // std::cerr << "f_G = " << f_G[iG]/volInv << std::endl;
     // std::cerr << "f_G - 4*pi/G2= " << f_G[iG]/volInv - 4.0*M_PI/G2 << std::endl;
   }
   std::array<char, 1000> buff;
   int length = std::snprintf(buff.data(), buff.size(),
                              "    Worst MPC discrepancy:\n"
                              "      Linear Extrap   : %18.14e\n"
                              "      Quadratic Extrap: %18.14e\n",
                              worstLin, worstQuad);
   if (length < 0)
     throw std::runtime_error("Error generating buffer string");
   app_log() << std::string_view(buff.data(), length);
 }

◆ init_gvecs()

void init_gvecs ( const ParticleSet & ptcl )

protected

Definition at line 43 of file MPC.cpp.

References qmcplusplus::abs(), qmcplusplus::app_log(), ParticleSet::Density_G, ParticleSet::DensityReducedGvecs, qmcplusplus::dot(), MPC::Ecut, ParticleSet::getLattice(), MPC::Gints, MPC::Gvecs, MPC::MaxDim, OHMMS_DIM, MPC::Rho_G, and MPC::SplineDim.

Referenced by MPC::initBreakup().

 {
   TinyVector<int, OHMMS_DIM> maxIndex(0);
   PosType b[OHMMS_DIM];
   for (int j = 0; j < OHMMS_DIM; j++)
     b[j] = static_cast<RealType>(2.0 * M_PI) * ptcl.getLattice().b(j);
   int numG1 = ptcl.Density_G.size();
   int numG2 = ptcl.DensityReducedGvecs.size();
   assert(ptcl.Density_G.size() == ptcl.DensityReducedGvecs.size());
   // Loop through all the G-vectors, and find the largest
   // indices in each direction with energy less than the cutoff
   for (int iG = 0; iG < ptcl.DensityReducedGvecs.size(); iG++)
   {
     TinyVector<int, OHMMS_DIM> gint = ptcl.DensityReducedGvecs[iG];
     PosType G                       = (double)gint[0] * b[0];
     for (int j = 1; j < OHMMS_DIM; j++)
       G += (double)gint[j] * b[j];
     if (0.5 * dot(G, G) < Ecut)
     {
       for (int j = 0; j < OHMMS_DIM; j++)
         maxIndex[j] = std::max(maxIndex[j], std::abs(gint[j]));
       Gvecs.push_back(G);
       Gints.push_back(gint);
       Rho_G.push_back(ptcl.Density_G[iG]);
     }
   }
   for (int idim = 0; idim < OHMMS_DIM; idim++)
     SplineDim[idim] = 4 * maxIndex[idim];
   MaxDim = std::max(maxIndex[0], std::max(maxIndex[1], maxIndex[2]));
   app_log() << "  Using " << Gvecs.size() << " G-vectors for MPC interaction.\n";
   app_log() << "   Using real-space box of size [" << SplineDim[0] << "," << SplineDim[1] << "," << SplineDim[2]
             << "] for MPC spline.\n";
 }

◆ init_spline()

void init_spline ( const ParticleSet & ptcl )

protected

Definition at line 221 of file MPC.cpp.

References qmcplusplus::app_log(), Array< T, D, ALLOC >::data(), qmcplusplus::dot(), MPC::f_0, MPC::f_G, ParticleSet::getLattice(), MPC::Gints, MPC::Gvecs, norm(), OHMMS_DIM, qmcplusplus::real(), MPC::Rho_G, MPC::SplineDim, MPC::Vconst, and MPC::VlongSpline.

Referenced by MPC::initBreakup().

 {
   Array<std::complex<double>, 3> rBox(SplineDim), GBox(SplineDim);
   Array<double, 3> splineData(SplineDim);
   GBox   = std::complex<double>();
   Vconst = 0.0;
   // Now fill in elements of GBox
   const RealType vol     = ptcl.getLattice().Volume;
   const RealType volInv  = 1.0 / ptcl.getLattice().Volume;
   const RealType halfvol = vol / 2.0;
   for (int iG = 0; iG < Gvecs.size(); iG++)
   {
     TinyVector<int, OHMMS_DIM> gint = Gints[iG];
     PosType G                       = Gvecs[iG];
     double G2                       = dot(G, G);
     TinyVector<int, OHMMS_DIM> index;
     for (int j = 0; j < OHMMS_DIM; j++)
       index[j] = (gint[j] + SplineDim[j]) % SplineDim[j];
 
     const RealType xxx(vol * (4.0 * M_PI * volInv / G2 - f_G[iG]));
     if (!(index[0] == 0 && index[1] == 0 && index[2] == 0))
     {
       GBox(index[0], index[1], index[2]) = xxx * Rho_G[iG];
       Vconst -= halfvol * xxx * norm(Rho_G[iG]);
       //GBox(index[0], index[1], index[2]) = vol *
       //                                     Rho_G[iG] * (4.0*M_PI*volInv/G2 - f_G[iG]);
       //Vconst -= 0.5 * vol * vol * norm(Rho_G[iG])
       //          * (4.0*M_PI*volInv/G2 - f_G[iG]);
     }
   }
   // G=0 component calculated separately
   //GBox(0,0,0) = -vol * f_0 * Rho_G[0];
   //Vconst += 0.5 * vol * vol * f_0 * norm(Rho_G[0]);
   const RealType volf = vol * f_0;
   GBox(0, 0, 0)       = -volf * Rho_G[0];
   Vconst += halfvol * volf * norm(Rho_G[0]);
 
   app_log() << "  Constant potential = " << Vconst << std::endl;
   fftw_plan fft = fftw_plan_dft_3d(SplineDim[0], SplineDim[1], SplineDim[2], (fftw_complex*)GBox.data(),
                                    (fftw_complex*)rBox.data(), -1, FFTW_ESTIMATE);
   fftw_execute(fft);
   fftw_destroy_plan(fft);
   for (int i0 = 0; i0 < SplineDim[0]; i0++)
     for (int i1 = 0; i1 < SplineDim[1]; i1++)
       for (int i2 = 0; i2 < SplineDim[2]; i2++)
         splineData(i0, i1, i2) = real(rBox(i0, i1, i2));
   BCtype_d bc0, bc1, bc2;
   Ugrid grid0, grid1, grid2;
   grid0.start = 0.0;
   grid0.end   = 1.0;
   grid0.num   = SplineDim[0];
   grid1.start = 0.0;
   grid1.end   = 1.0;
   grid1.num   = SplineDim[1];
   grid2.start = 0.0;
   grid2.end   = 1.0;
   grid2.num   = SplineDim[2];
   bc0.lCode = bc0.rCode = PERIODIC;
   bc1.lCode = bc1.rCode = PERIODIC;
   bc2.lCode = bc2.rCode = PERIODIC;
   VlongSpline =
       std::shared_ptr<UBspline_3d_d>(create_UBspline_3d_d(grid0, grid1, grid2, bc0, bc1, bc2, splineData.data()),
                                      destroy_Bspline);
   //     grid0.num = ptcl.Density_r.size(0);
   //     grid1.num = ptcl.Density_r.size(1);
   //     grid2.num = ptcl.Density_r.size(2);
   //     DensitySpline = create_UBspline_3d_d (grid0, grid1, grid2, bc0, bc1, bc2,
   //            ptcl.Density_r.data());
 }

◆ initBreakup()

void initBreakup ( const ParticleSet & ptcl )

protected

Definition at line 291 of file MPC.cpp.

References qmcplusplus::app_log(), ParticleSet::getTotalNum(), MPC::init_f_G(), MPC::init_gvecs(), MPC::init_spline(), and MPC::NParticles.

Referenced by MPC::MPC().

 {
   NParticles = ptcl.getTotalNum();
   app_log() << "\n  === Initializing MPC interaction === " << std::endl;
   init_gvecs(ptcl);
   init_f_G(ptcl);
   init_spline(ptcl);
   // FILE *fout = fopen ("MPC.dat", "w");
   // double vol = ptcl.getLattice().Volume;
   // PosType r0 (0.0, 0.0, 0.0);
   // PosType r1 (10.26499236, 10.26499236, 10.26499236);
   // int nPoints=1001;
   // for (int i=0; i<nPoints; i++) {
   //   double s = (double)i/(double)(nPoints-1);
   //   PosType r = (1.0-s)*r0 + s*r1;
   //   PosType u = ptcl.getLattice().toUnit(r);
   //   double V, rho(0.0);
   //   eval_UBspline_3d_d (VlongSpline, u[0], u[1], u[2], &V);
   //   // eval_UBspline_3d_d (DensitySpline, u[0], u[1], u[2], &rho);
   //   fprintf (fout, "%6.4f %14.10e %14.10e\n", s, V, rho);
   // }
   // fclose(fout);
   app_log() << "  === MPC interaction initialized === \n\n";
 }

◆ makeClone()

std::unique_ptr< OperatorBase > makeClone	(	ParticleSet &	qp,
		TrialWaveFunction &	psi
	)

overridevirtual

Implements OperatorBase.

Definition at line 316 of file MPC.cpp.

 {
   auto newMPC = std::make_unique<MPC>(*this);
   return newMPC;
 }

◆ put()

bool put ( xmlNodePtr cur )

overridevirtual

Do nothing.

Implements OperatorBase.

Definition at line 361 of file MPC.cpp.

References OhmmsAttributeSet::add(), qmcplusplus::app_log(), MPC::Ecut, and OhmmsAttributeSet::put().

 {
   Ecut = -1.0;
   OhmmsAttributeSet attribs;
   attribs.add(Ecut, "cutoff");
   attribs.put(cur);
   if (Ecut < 0.0)
   {
     Ecut = 30.0;
     app_log() << "    MPC cutoff not found.  Set using \"cutoff\" attribute.\n"
               << "    Setting to default value of " << Ecut << std::endl;
   }
   return true;
 }

◆ resetTargetParticleSet()

void resetTargetParticleSet ( ParticleSet & P )

overridevirtual

Reset the data with the target ParticleSet.

Parameters

P	new target ParticleSet

Implements OperatorBase.

Definition at line 33 of file MPC.cpp.

33 {}

Member Data Documentation

◆ ChargeAttribIndx

int ChargeAttribIndx

Definition at line 65 of file MPC.h.

◆ d_aa_ID

const int d_aa_ID

protected

Definition at line 46 of file MPC.h.

Referenced by MPC::evalSR().

◆ Ecut

double Ecut

protected

Definition at line 39 of file MPC.h.

Referenced by MPC::init_gvecs(), and MPC::put().

◆ f_0

double f_0

Definition at line 61 of file MPC.h.

Referenced by MPC::init_f_G(), and MPC::init_spline().

◆ f_G

std::vector<RealType> f_G

Definition at line 59 of file MPC.h.

Referenced by MPC::init_f_G(), and MPC::init_spline().

◆ FirstTime

bool FirstTime

Definition at line 63 of file MPC.h.

◆ Gints

std::vector<TinyVector<int, OHMMS_DIM> > Gints

protected

Definition at line 40 of file MPC.h.

Referenced by MPC::compute_g_G(), MPC::init_f_G(), MPC::init_gvecs(), and MPC::init_spline().

◆ Gvecs

std::vector<PosType> Gvecs

protected

Definition at line 41 of file MPC.h.

Referenced by MPC::init_f_G(), MPC::init_gvecs(), and MPC::init_spline().

◆ MaxDim

int MaxDim

protected

Definition at line 44 of file MPC.h.

Referenced by MPC::init_f_G(), and MPC::init_gvecs().

◆ MemberAttribIndx

int MemberAttribIndx

Definition at line 66 of file MPC.h.

◆ myConst

RealType myConst

Definition at line 68 of file MPC.h.

◆ myRcut

RealType myRcut

Definition at line 69 of file MPC.h.

◆ NofSpecies

std::vector<int> NofSpecies

Definition at line 71 of file MPC.h.

◆ NParticles

int NParticles

Definition at line 67 of file MPC.h.

Referenced by MPC::evalLR(), MPC::evalSR(), and MPC::initBreakup().

◆ NumSpecies

int NumSpecies

Definition at line 64 of file MPC.h.

◆ Rho_G

std::vector<ComplexType> Rho_G

protected

Definition at line 42 of file MPC.h.

Referenced by MPC::init_gvecs(), and MPC::init_spline().

◆ RhoAvg_G

std::vector<ComplexType> RhoAvg_G

Definition at line 58 of file MPC.h.

◆ SplineDim

std::array<size_t, OHMMS_DIM> SplineDim

protected

Definition at line 43 of file MPC.h.

Referenced by MPC::init_gvecs(), and MPC::init_spline().

◆ Vconst

double Vconst

protected

Definition at line 38 of file MPC.h.

Referenced by MPC::evaluate(), and MPC::init_spline().

◆ VlongSpline

std::shared_ptr<UBspline_3d_d> VlongSpline

protected

Definition at line 36 of file MPC.h.

Referenced by MPC::evalLR(), and MPC::init_spline().

◆ Zat

std::vector<RealType> Zat

Definition at line 70 of file MPC.h.

◆ Zspec

std::vector<RealType> Zspec

Definition at line 70 of file MPC.h.

◆ qmcplusplus::NonLocalECPotential

class qmcplusplus::NonLocalECPotential

Evaluate the semi local potentials.

Definition at line 39 of file NonLocalECPotential.h.

Inheritance diagram for NonLocalECPotential:

Collaboration diagram for NonLocalECPotential:

Public Member Functions
	NonLocalECPotential (ParticleSet &ions, ParticleSet &els, TrialWaveFunction &psi, bool computeForces, bool enable_DLA)
	constructor More...

	~NonLocalECPotential () override

bool	dependsOnWaveFunction () const override
	return true if this operator depends on a wavefunction More...

std::string	getClassName () const override
	return class name More...

void	resetTargetParticleSet (ParticleSet &P) override
	Reset the data with the target ParticleSet. More...

void	contributeParticleQuantities () override

void	checkoutParticleQuantities (TraceManager &tm) override

void	deleteParticleQuantities () override

Return_t	evaluate (ParticleSet &P) override
	Evaluate the local energy contribution of this component. More...

Return_t	evaluateDeterministic (ParticleSet &P) override
	Evaluate the local energy contribution of this component, deterministically based on current state. More...

void	mw_evaluate (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const override
	Evaluate the contribution of this component of multiple walkers. More...

Return_t	evaluateWithToperator (ParticleSet &P) override
	Evaluate the local energy contribution of this component with Toperators updated if requested. More...

void	mw_evaluateWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const override
	Evaluate the contribution of this component of multiple walkers. More...

void	mw_evaluatePerParticle (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< Real >> &listeners, const std::vector< ListenerVector< Real >> &listeners_ions) const override

void	mw_evaluatePerParticleWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< Real >> &listeners, const std::vector< ListenerVector< Real >> &listeners_ions) const override

Return_t	evaluateWithIonDerivs (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_terms, ParticleSet::ParticlePos &pulay_terms) override
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

Return_t	evaluateWithIonDerivsDeterministic (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_terms, ParticleSet::ParticlePos &pulay_terms) override
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

void	evaluateOneBodyOpMatrix (ParticleSet &P, const TWFFastDerivWrapper &psi, std::vector< ValueMatrix > &B) override
	Evaluate "B" matrix for observable. More...

void	evaluateOneBodyOpMatrixForceDeriv (ParticleSet &P, ParticleSet &source, const TWFFastDerivWrapper &psi, const int iat, std::vector< std::vector< ValueMatrix >> &Bforce) override
	Evaluate "dB/dR" matrices for observable. More...

void	setNonLocalMoves (xmlNodePtr cur)
	set non local moves options More...

void	setNonLocalMoves (const std::string &non_local_move_option, const double tau, const double alpha, const double gamma)

int	makeNonLocalMovesPbyP (ParticleSet &P)
	make non local moves with particle-by-particle moves More...

Return_t	evaluateValueAndDerivatives (ParticleSet &P, const opt_variables_type &optvars, const Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi) override

bool	put (xmlNodePtr cur) override
	Do nothing. More...

bool	get (std::ostream &os) const override
	write about the class More...

void	createResource (ResourceCollection &collection) const override
	initialize a shared resource and hand it to a collection More...

void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const override
	acquire a shared resource from a collection More...

void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const override
	return a shared resource to a collection More...

std::unique_ptr< OperatorBase >	makeClone (ParticleSet &qp, TrialWaveFunction &psi) override

void	addComponent (int groupID, std::unique_ptr< NonLocalECPComponent > &&pp)

void	setRandomGenerator (RandomBase< FullPrecRealType > *rng) override
	set the internal RNG pointer as the given pointer More...

void	addObservables (PropertySetType &plist, BufferType &collectables) override
	named values to the property list Default implementaton uses addValue(plist_) More...

void	setObservables (PropertySetType &plist) override
	Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_. More...

void	setParticlePropertyList (PropertySetType &plist, int offset) override

void	registerObservables (std::vector< ObservableHelper > &h5list, hdf_archive &file) const override
	add to observable descriptor for hdf5 The default implementation is to register a scalar for this->value_ More...

void	setComputeForces (bool val) override
	Set the flag whether to compute forces or not. More...

Public Member Functions inherited from OperatorBase
	OperatorBase ()
	Construct a new Operator Base object Default and unique empty constructor. More...

virtual	~OperatorBase ()=default

std::bitset< 8 > &	getUpdateMode () noexcept
	get update_mode_ reference More...

Return_t	getValue () const noexcept
	get a copy of value_ More...

std::string	getName () const noexcept
	getter a copy of my_name_, rvalue small string optimization More...

void	setName (const std::string name) noexcept
	Set my_name member, uses small string optimization (pass by value) More...

TraceRequest &	getRequest () noexcept
	Get request_ member. More...

virtual void	registerCollectables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const

virtual void	setHistories (Walker_t &ThisWalker)

virtual void	mw_evaluatePerParticle (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual void	mw_evaluateWithParameterDerivatives (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< ParticleSet > &p_list, const opt_variables_type &optvars, const RecordArray< ValueType > &dlogpsi, RecordArray< ValueType > &dhpsioverpsi) const
	TODO: add docs. More...

virtual Return_t	rejectedMove (ParticleSet &P)
	TODO: add docs. More...

virtual void	mw_evaluatePerParticleWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual Return_t	evaluateValueAndDerivatives (ParticleSet &P, const opt_variables_type &optvars, const Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	Evaluate value and derivatives wrt the optimizables. More...

virtual void	updateSource (ParticleSet &s)
	Update data associated with a particleset. More...

virtual Return_t	getEnsembleAverage ()
	Return an average value by collective operation. More...

virtual void	add2Hamiltonian (ParticleSet &qp, TrialWaveFunction &psi, QMCHamiltonian &targetH)
	TODO: add docs. More...

virtual void	getRequiredTraces (TraceManager &tm)
	TODO: add docs. More...

virtual void	informOfPerParticleListener ()

bool	isClassical () const noexcept

bool	isQuantum () const noexcept

bool	isClassicalClassical () const noexcept

bool	isQuantumClassical () const noexcept

bool	isQuantumQuantum () const noexcept

bool	getMode (const int i) const noexcept
	Return the mode i. More...

bool	isNonLocal () const noexcept
	TODO: add docs. More...

bool	hasListener () const noexcept

void	contributeTraceQuantities ()
	Make trace quantities available. More...

void	checkoutTraceQuantities (TraceManager &tm)
	Checkout trace arrays Derived classes must guard individual checkouts using request info. More...

void	collectScalarTraces ()
	Collect scalar trace data. More...

void	deleteTraceQuantities ()
	delete trace arrays More...

Public Member Functions inherited from ForceBase
Real	g (Real r)

void	initVarReduction (Real rcut, int m, int numFuncs)

	ForceBase (ParticleSet &ions, ParticleSet &elns)

virtual	~ForceBase ()

void	registerObservablesF (std::vector< ObservableHelper > &h5list, hdf_archive &file) const

void	addObservablesF (QMCTraits::PropertySetType &plist)

void	addObservablesStress (QMCTraits::PropertySetType &plist)

void	setObservablesF (QMCTraits::PropertySetType &plist)

void	setObservablesStress (QMCTraits::PropertySetType &plist)

void	setParticleSetF (QMCTraits::PropertySetType &plist, int offset)

void	setParticleSetStress (QMCTraits::PropertySetType &plist, int offset)

bool	getAddIonIon () const noexcept

void	setAddIonIon (bool val) noexcept

const ParticleSet::ParticlePos &	getForces () const noexcept

void	setForces (const ParticleSet::ParticlePos &forces)

void	setForces (Real val)

const ParticleSet::ParticlePos &	getForcesIonIon () const noexcept

void	setForcesIonIon (const ParticleSet::ParticlePos &forces_ion_ion)

const SymTensor< Real, OHMMS_DIM > &	getStressIonIon () const noexcept

const SymTensor< Real, OHMMS_DIM > &	getStressEE () const noexcept

const SymTensor< Real, OHMMS_DIM > &	getStressEI () const noexcept

const SymTensor< Real, OHMMS_DIM > &	getStressKin () const noexcept

const SymTensor< Real, OHMMS_DIM > &	getStress () const noexcept

Static Protected Member Functions
static void	mw_evaluateImpl (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, bool Tmove, std::optional< ListenerOption< Real >> listeners, bool keepGrid=false)
	the actual implementation for batched walkers, used by mw_evaluate, mw_evaluateWithToperator mw_evaluatePerPaticleWithToperator More...

Protected Attributes
RandomBase< FullPrecRealType > *	myRNG
	random number generator More...

std::vector< NonLocalECPComponent * >	PP
	the set of local-potentials (one for each ion) More...

std::vector< std::unique_ptr< NonLocalECPComponent > >	PPset
	unique NonLocalECPComponent to remove More...

ParticleSet &	IonConfig
	reference to the center ion More...

TrialWaveFunction &	Psi
	target TrialWaveFunction More...

bool	ComputeForces
	true if we should compute forces More...

bool	use_DLA
	true, determinant localization approximation(DLA) is enabled More...

Protected Attributes inherited from OperatorBase
std::bitset< 8 >	update_mode_
	set the current update mode More...

Return_t	value_
	current value More...

std::string	name_
	name of this object More...

TraceRequest	request_
	whether traces are being collected More...

int	my_index_
	starting index of this object More...

Return_t	new_value_
	a new value for a proposed move More...

Walker_t *	t_walker_
	reference to the current walker More...

bool	streaming_particles_

bool	have_required_traces_

Protected Attributes inherited from ForceBase
int	first_force_index_

int	n_nuc_

int	n_el_

int	tries_

bool	first_time_

bool	add_ion_ion_
	Determines if ion-ion force will be added to electron-ion force in derived force estimators. If false, forces_ion_ion_=0.0. More...

ParticleSet &	ions_

ParticleSet::ParticlePos	forces_

ParticleSet::ParticlePos	forces_ion_ion_

SymTensor< Real, OHMMS_DIM >	stress_ion_ion_

SymTensor< Real, OHMMS_DIM >	stress_ee_

SymTensor< Real, OHMMS_DIM >	stress_ei_

SymTensor< Real, OHMMS_DIM >	stress_kin_

SymTensor< Real, OHMMS_DIM >	stress_

std::string	prefix_

std::string	pair_name_

Real	rcut_

int	m_

std::vector< Real >	ck_

Private Types
using	Real = QMCTraits::RealType

Private Member Functions
void	evaluateImpl (ParticleSet &P, bool Tmove, bool keepGrid=false)
	the actual implementation, used by evaluate and evaluateWithToperator More...

void	evalIonDerivsImpl (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_terms, ParticleSet::ParticlePos &pulay_terms, bool keepGrid=false)

void	computeOneElectronTxy (ParticleSet &P, const int ref_elec)
	compute the T move transition probability for a given electron member variable nonLocalOps.Txy is updated More...

void	markAffectedElecs (const DistanceTableAB &myTable, int iel)
	mark all the electrons affected by Tmoves and update ElecNeighborIons and IonNeighborElecs More...

Private Attributes
int	NumIons
	number of ions More...

int	myTableIndex
	index of distance table for the ion-el pair More...

ParticleSet &	Peln
	reference to the electrons More...

NeighborLists	ElecNeighborIons
	neighborlist of electrons More...

NeighborLists	IonNeighborElecs
	neighborlist of ions More...

int	UseTMove
	use T-moves More...

std::vector< bool >	elecTMAffected
	ture if an electron is affected by other electrons moved by T-moves More...

NonLocalTOperator	nonLocalOps
	non local operator More...

ParticleSet::ParticlePos	PulayTerm
	Pulay force vector. More...

std::vector< NonLocalData >	tmove_xy_

Array< TraceReal, 1 > *	Ve_sample
	single particle trace samples More...

Array< TraceReal, 1 > *	Vi_sample

std::vector< std::vector< NLPPJob< Real > > >	nlpp_jobs
	NLPP job list of ion-electron pairs by spin group. More...

ResourceHandle< NonLocalECPotentialMultiWalkerResource >	mw_res_handle_
	mult walker shared resource More...

Friends
class	testing::TestNonLocalECPotential

Additional Inherited Members
Public Types inherited from OperatorBase
enum	EnergyDomains { KINETIC = 0, POTENTIAL, NO_ENERGY_DOMAIN }
	enum to denote energy domain of operators More...

enum	QuantumDomains { NO_QUANTUM_DOMAIN = 0, CLASSICAL, QUANTUM, CLASSICAL_CLASSICAL, QUANTUM_CLASSICAL, QUANTUM_QUANTUM }

enum	{ PRIMARY = 0, OPTIMIZABLE = 1, RATIOUPDATE = 2, PHYSICAL = 3, COLLECTABLE = 4, NONLOCAL = 5 }
	enum for update_mode More...

using	Return_t = FullPrecRealType
	type of return value of evaluate More...

using	ValueMatrix = SPOSet::ValueMatrix
	For fast derivative evaluation. More...

using	GradMatrix = SPOSet::GradMatrix

using	BufferType = ParticleSet::Buffer_t
	typedef for the serialized buffer More...

using	Walker_t = ParticleSet::Walker_t
	typedef for the walker More...

using	ParticleScalar = ParticleSet::Scalar_t
	typedef for the ParticleScalar More...

using	SPOMap = SPOSet::SPOMap
	typedef for SPOMap More...

Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...

using	PtclGrpIndexes = std::vector< std::pair< int, int > >

Public Types inherited from ForceBase
using	Real = QMCTraits::RealType
	cheat, need to use virtual inheriance to clean up More...

Protected Member Functions inherited from OperatorBase
virtual void	contributeScalarQuantities ()

virtual void	checkoutScalarQuantities (TraceManager &tm)

virtual void	collectScalarQuantities ()

virtual void	deleteScalarQuantities ()

void	setEnergyDomain (EnergyDomains edomain)
	Set the Energy Domain. More...

void	setQuantumDomain (QuantumDomains qdomain)
	set quantum domain More...

void	oneBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for one-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for two-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P1, const ParticleSet &P2)
	set quantum domain for two-body operator More...

void	addValue (PropertySetType &plist)
	named values to the property list More...

Member Typedef Documentation

◆ Real

using Real = QMCTraits::RealType

private

Definition at line 41 of file NonLocalECPotential.h.

Constructor & Destructor Documentation

◆ NonLocalECPotential()

NonLocalECPotential	(	ParticleSet &	ions,
		ParticleSet &	els,
		TrialWaveFunction &	psi,
		bool	computeForces,
		bool	enable_DLA
	)

constructor

Parameters

ions	the positions of the ions
els	the positions of the electrons
psi	trial wavefunction

Definition at line 54 of file NonLocalECPotential.cpp.

     : ForceBase(ions, els),
       myRNG(nullptr),
       IonConfig(ions),
       Psi(psi),
       ComputeForces(computeForces),
       use_DLA(enable_DLA),
       Peln(els),
       ElecNeighborIons(els),
       IonNeighborElecs(ions),
       UseTMove(TMOVE_OFF)
 {
   setEnergyDomain(POTENTIAL);
   twoBodyQuantumDomain(ions, els);
   myTableIndex = els.addTable(ions);
   NumIons      = ions.getTotalNum();
   //els.resizeSphere(NumIons);
   PP.resize(NumIons, nullptr);
   prefix_ = "FNL";
   PPset.resize(IonConfig.getSpeciesSet().getTotalNum());
   PulayTerm.resize(NumIons);
   update_mode_.set(NONLOCAL, 1);
   nlpp_jobs.resize(els.groups());
   for (size_t ig = 0; ig < els.groups(); ig++)
   {
     // this should be enough in most calculations assuming that every electron cannot be in more than two pseudo regions.
     nlpp_jobs[ig].reserve(2 * els.groupsize(ig));
   }
 }

◆ ~NonLocalECPotential()

~NonLocalECPotential ( )

overridedefault

Member Function Documentation

◆ acquireResource()

void acquireResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< OperatorBase > &	o_list
	)		const

overridevirtual

acquire a shared resource from a collection

Reimplemented from OperatorBase.

Definition at line 780 of file NonLocalECPotential.cpp.

References RefVectorWithLeader< T >::getCastedLeader(), ResourceCollection::lendResource(), and NonLocalECPotential::mw_res_handle_.

 {
   auto& O_leader          = o_list.getCastedLeader<NonLocalECPotential>();
   O_leader.mw_res_handle_ = collection.lendResource<NonLocalECPotentialMultiWalkerResource>();
 }

◆ addComponent()

void addComponent	(	int	groupID,
		std::unique_ptr< NonLocalECPComponent > &&	pp
	)

Definition at line 759 of file NonLocalECPotential.cpp.

References ParticleSet::GroupID, NonLocalECPotential::IonConfig, NonLocalECPotential::PP, and NonLocalECPotential::PPset.

Referenced by qmcplusplus::TEST_CASE().

 {
   for (int iat = 0; iat < PP.size(); iat++)
     if (IonConfig.GroupID[iat] == groupID)
       PP[iat] = ppot.get();
   PPset[groupID] = std::move(ppot);
 }

◆ addObservables()

void addObservables	(	PropertySetType &	plist,
		BufferType &	collectables
	)

overridevirtual

named values to the property list Default implementaton uses addValue(plist_)

Parameters

plist	RecordNameProperty
collectables	Observables that are accumulated by evaluate

Reimplemented from OperatorBase.

Definition at line 805 of file NonLocalECPotential.cpp.

References RecordNamedProperty< T >::add(), OperatorBase::addValue(), NonLocalECPotential::ComputeForces, ForceBase::first_force_index_, ForceBase::n_nuc_, OHMMS_DIM, and RecordNamedProperty< T >::size().

 {
   OperatorBase::addValue(plist);
   if (ComputeForces)
   {
     if (first_force_index_ < 0)
       first_force_index_ = plist.size();
     for (int iat = 0; iat < n_nuc_; iat++)
     {
       for (int x = 0; x < OHMMS_DIM; x++)
       {
         std::ostringstream obsName1, obsName2;
         obsName1 << "FNL"
                  << "_" << iat << "_" << x;
         plist.add(obsName1.str());
         //        obsName2 << "FNL_Pulay" << "_" << iat << "_" << x;
         //        plist.add(obsName2.str());
       }
     }
   }
 }

◆ checkoutParticleQuantities()

void checkoutParticleQuantities ( TraceManager & tm )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 93 of file NonLocalECPotential.cpp.

References TraceManager::checkout_real(), NonLocalECPotential::IonConfig, OperatorBase::name_, NonLocalECPotential::Peln, OperatorBase::request_, TraceRequest::streaming_array(), OperatorBase::streaming_particles_, NonLocalECPotential::Ve_sample, and NonLocalECPotential::Vi_sample.

 {
   streaming_particles_ = request_.streaming_array(name_);
   if (streaming_particles_)
   {
     Ve_sample = tm.checkout_real<1>(name_, Peln);
     Vi_sample = tm.checkout_real<1>(name_, IonConfig);
   }
 }

◆ computeOneElectronTxy()

void computeOneElectronTxy	(	ParticleSet &	P,
		const int	ref_elec
	)

private

compute the T move transition probability for a given electron member variable nonLocalOps.Txy is updated

Parameters

P	particle set
ref_elec	reference electron id

Definition at line 537 of file NonLocalECPotential.cpp.

References NonLocalECPotential::ElecNeighborIons, ParticleSet::getDistTableAB(), NeighborLists::getNeighborList(), NonLocalECPotential::myTableIndex, NonLocalECPotential::PP, NonLocalECPotential::Psi, NonLocalECPotential::tmove_xy_, and NonLocalECPotential::use_DLA.

Referenced by NonLocalECPotential::makeNonLocalMovesPbyP().

 {
   tmove_xy_.clear();
   const auto& myTable                  = P.getDistTableAB(myTableIndex);
   const std::vector<int>& NeighborIons = ElecNeighborIons.getNeighborList(ref_elec);
 
   const auto& dist  = myTable.getDistRow(ref_elec);
   const auto& displ = myTable.getDisplRow(ref_elec);
   for (int atom_index = 0; atom_index < NeighborIons.size(); atom_index++)
   {
     const int iat = NeighborIons[atom_index];
     PP[iat]->evaluateOne(P, iat, Psi, ref_elec, dist[iat], -displ[iat], use_DLA);
     PP[iat]->contributeTxy(ref_elec, tmove_xy_);
   }
 }

◆ contributeParticleQuantities()

void contributeParticleQuantities ( )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 91 of file NonLocalECPotential.cpp.

References TraceRequest::contribute_array(), OperatorBase::name_, and OperatorBase::request_.

91 { request_.contribute_array(name_); }

TraceRequest request_

whether traces are being collected

Definition: OperatorBase.h:531

std::string name_

name of this object

Definition: OperatorBase.h:527

References B(), NonLocalECPotential::ElecNeighborIons, ParticleSet::first(), qmcplusplus::generateRandomRotationMatrix(), ParticleSet::getDistTableAB(), NeighborLists::getNeighborList(), ParticleSet::getTotalNum(), ParticleSet::groups(), NonLocalECPotential::IonNeighborElecs, ParticleSet::last(), NonLocalECPotential::myRNG, NonLocalECPotential::myTableIndex, NonLocalECPotential::NumIons, NonLocalECPotential::PP, and NonLocalECPotential::PPset.

void contribute_array(const std::string &name, bool default_quantity=false)

Definition: TraceManager.h:198

◆ createResource()

void createResource ( ResourceCollection & collection ) const

overridevirtual

initialize a shared resource and hand it to a collection

Reimplemented from OperatorBase.

Definition at line 767 of file NonLocalECPotential.cpp.

References ResourceCollection::addResource(), and NonLocalECPotential::PPset.

Referenced by qmcplusplus::TEST_CASE().

 {
   auto new_res = std::make_unique<NonLocalECPotentialMultiWalkerResource>();
   for (int ig = 0; ig < PPset.size(); ++ig)
     if (PPset[ig] && PPset[ig]->getVP()) // H pp doesn't contain non-local channels and PPset[ig] can be nullptr
     {
       PPset[ig]->getVP()->createResource(new_res->collection);
       // the VP of the first NonLocalECPComponent is responsible for creating the shared resource.
       break;
     }
   auto resource_index = collection.addResource(std::move(new_res));
 }

◆ deleteParticleQuantities()

void deleteParticleQuantities ( )

overridevirtual

Reimplemented from OperatorBase.

Definition at line 103 of file NonLocalECPotential.cpp.

References OperatorBase::streaming_particles_, NonLocalECPotential::Ve_sample, and NonLocalECPotential::Vi_sample.

 {
   if (streaming_particles_)
   {
     delete Ve_sample;
     delete Vi_sample;
   }
 }

◆ dependsOnWaveFunction()

bool dependsOnWaveFunction ( ) const

inlineoverridevirtual

return true if this operator depends on a wavefunction

Reimplemented from OperatorBase.

Definition at line 49 of file NonLocalECPotential.h.

49 { return true; }

◆ evalIonDerivsImpl()

void evalIonDerivsImpl	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_terms,
		ParticleSet::ParticlePos &	pulay_terms,
		bool	keepGrid = `false`
	)

private

Definition at line 461 of file NonLocalECPotential.cpp.

Referenced by NonLocalECPotential::evaluateWithIonDerivs(), and NonLocalECPotential::evaluateWithIonDerivsDeterministic().

 {
   //We're going to ignore psi and use the internal Psi.
   //
   //Dummy vector for now.  Tmoves not implemented
   bool Tmove = false;
 
   forces_   = 0;
   PulayTerm = 0;
 
   value_ = 0.0;
   if (!keepGrid)
   {
     for (int ipp = 0; ipp < PPset.size(); ipp++)
       if (PPset[ipp])
         PPset[ipp]->rotateQuadratureGrid(generateRandomRotationMatrix(*myRNG));
   }
   //loop over all the ions
   const auto& myTable = P.getDistTableAB(myTableIndex);
   // clear all the electron and ion neighbor lists
   for (int iat = 0; iat < NumIons; iat++)
     IonNeighborElecs.getNeighborList(iat).clear();
   for (int jel = 0; jel < P.getTotalNum(); jel++)
     ElecNeighborIons.getNeighborList(jel).clear();
 
   for (int ig = 0; ig < P.groups(); ++ig) //loop over species
   {
     Psi.prepareGroup(P, ig);
     for (int jel = P.first(ig); jel < P.last(ig); ++jel)
     {
       const auto& dist               = myTable.getDistRow(jel);
       const auto& displ              = myTable.getDisplRow(jel);
       std::vector<int>& NeighborIons = ElecNeighborIons.getNeighborList(jel);
       for (int iat = 0; iat < NumIons; iat++)
         if (PP[iat] != nullptr && dist[iat] < PP[iat]->getRmax())
         {
           value_ +=
               PP[iat]->evaluateOneWithForces(P, ions, iat, Psi, jel, dist[iat], -displ[iat], forces_[iat], PulayTerm);
           if (Tmove)
             PP[iat]->contributeTxy(jel, tmove_xy_);
           NeighborIons.push_back(iat);
           IonNeighborElecs.getNeighborList(iat).push_back(jel);
         }
     }
   }
 
   hf_terms -= forces_;
   pulay_terms -= PulayTerm;
 }

◆ evaluate()

NonLocalECPotential::Return_t evaluate ( ParticleSet & P )

overridevirtual

Evaluate the local energy contribution of this component.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Implements OperatorBase.

Definition at line 113 of file NonLocalECPotential.cpp.

References NonLocalECPotential::evaluateImpl(), and OperatorBase::value_.

 {
   evaluateImpl(P, false);
   return value_;
 }

◆ evaluateDeterministic()

NonLocalECPotential::Return_t evaluateDeterministic ( ParticleSet & P )

overridevirtual

Evaluate the local energy contribution of this component, deterministically based on current state.

The correct behavior of this routine requires estimators with non-deterministic components in their evaluate() function to override this function.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Reimplemented from OperatorBase.

Definition at line 119 of file NonLocalECPotential.cpp.

References NonLocalECPotential::evaluateImpl(), and OperatorBase::value_.

 {
   evaluateImpl(P, false, true);
   return value_;
 }

◆ evaluateImpl()

void evaluateImpl	(	ParticleSet &	P,
		bool	Tmove,
		bool	keepGrid = `false`
	)

private

the actual implementation, used by evaluate and evaluateWithToperator

Parameters

P	particle set
Tmove	whether Txy for Tmove is updated
keepGrid.	If true, does not randomize the quadrature grid before evaluation.

Definition at line 175 of file NonLocalECPotential.cpp.

Referenced by NonLocalECPotential::evaluate(), NonLocalECPotential::evaluateDeterministic(), and NonLocalECPotential::evaluateWithToperator().

 {
   if (Tmove)
     tmove_xy_.clear();
 
   value_ = 0.0;
 #if !defined(REMOVE_TRACEMANAGER)
   auto& Ve_samp = *Ve_sample;
   auto& Vi_samp = *Vi_sample;
   if (streaming_particles_)
   {
     Ve_samp = 0.0;
     Vi_samp = 0.0;
   }
 #endif
   for (int ipp = 0; ipp < PPset.size(); ipp++)
     if (PPset[ipp])
       if (!keep_grid)
         PPset[ipp]->rotateQuadratureGrid(generateRandomRotationMatrix(*myRNG));
 
   //loop over all the ions
   const auto& myTable = P.getDistTableAB(myTableIndex);
   // clear all the electron and ion neighbor lists
   for (int iat = 0; iat < NumIons; iat++)
     IonNeighborElecs.getNeighborList(iat).clear();
   for (int jel = 0; jel < P.getTotalNum(); jel++)
     ElecNeighborIons.getNeighborList(jel).clear();
 
   if (ComputeForces)
   {
     forces_ = 0;
     for (int ig = 0; ig < P.groups(); ++ig) //loop over species
     {
       Psi.prepareGroup(P, ig);
       for (int jel = P.first(ig); jel < P.last(ig); ++jel)
       {
         const auto& dist               = myTable.getDistRow(jel);
         const auto& displ              = myTable.getDisplRow(jel);
         std::vector<int>& NeighborIons = ElecNeighborIons.getNeighborList(jel);
         for (int iat = 0; iat < NumIons; iat++)
           if (PP[iat] != nullptr && dist[iat] < PP[iat]->getRmax())
           {
             Real pairpot = PP[iat]->evaluateOneWithForces(P, iat, Psi, jel, dist[iat], -displ[iat], forces_[iat]);
             if (Tmove)
               PP[iat]->contributeTxy(jel, tmove_xy_);
             value_ += pairpot;
             NeighborIons.push_back(iat);
             IonNeighborElecs.getNeighborList(iat).push_back(jel);
           }
       }
     }
   }
   else
   {
     for (int ig = 0; ig < P.groups(); ++ig) //loop over species
     {
       Psi.prepareGroup(P, ig);
       for (int jel = P.first(ig); jel < P.last(ig); ++jel)
       {
         const auto& dist               = myTable.getDistRow(jel);
         const auto& displ              = myTable.getDisplRow(jel);
         std::vector<int>& NeighborIons = ElecNeighborIons.getNeighborList(jel);
         for (int iat = 0; iat < NumIons; iat++)
           if (PP[iat] != nullptr && dist[iat] < PP[iat]->getRmax())
           {
             Real pairpot = PP[iat]->evaluateOne(P, iat, Psi, jel, dist[iat], -displ[iat], use_DLA);
             if (Tmove)
               PP[iat]->contributeTxy(jel, tmove_xy_);
 
             value_ += pairpot;
             NeighborIons.push_back(iat);
             IonNeighborElecs.getNeighborList(iat).push_back(jel);
 
             if (streaming_particles_)
             {
               Ve_samp(jel) += 0.5 * pairpot;
               Vi_samp(iat) += 0.5 * pairpot;
             }
           }
       }
     }
   }
 
 #if !defined(TRACE_CHECK)
   if (streaming_particles_)
   {
     Return_t Vnow = value_;
     Real Visum    = Vi_sample->sum();
     Real Vesum    = Ve_sample->sum();
     Real Vsum     = Vesum + Visum;
     if (std::abs(Vsum - Vnow) > TraceManager::trace_tol)
     {
       app_log() << "accumtest: NonLocalECPotential::evaluate()" << std::endl;
       app_log() << "accumtest:   tot:" << Vnow << std::endl;
       app_log() << "accumtest:   sum:" << Vsum << std::endl;
       APP_ABORT("Trace check failed");
     }
     if (std::abs(Vesum - Visum) > TraceManager::trace_tol)
     {
       app_log() << "sharetest: NonLocalECPotential::evaluate()" << std::endl;
       app_log() << "sharetest:   e share:" << Vesum << std::endl;
       app_log() << "sharetest:   i share:" << Visum << std::endl;
       APP_ABORT("Trace check failed");
     }
   }
 #endif
 }

◆ evaluateOneBodyOpMatrix()

void evaluateOneBodyOpMatrix	(	ParticleSet &	P,
		const TWFFastDerivWrapper &	psi,
		std::vector< ValueMatrix > &	B
	)

overridevirtual

Evaluate "B" matrix for observable.

Filippi scheme for computing fast derivatives.

Parameters

[in]	P	target particle set (electrons)
[in]	psi,Trial	Wavefunction wrapper for fast derivatives.
[in,out]	B.	List of B matrices for each species.

Returns: Void

Reimplemented from OperatorBase.

Definition at line 553 of file NonLocalECPotential.cpp.

 {
   bool keepGrid = true;
   for (int ipp = 0; ipp < PPset.size(); ipp++)
     if (PPset[ipp])
       if (!keepGrid)
         PPset[ipp]->rotateQuadratureGrid(generateRandomRotationMatrix(*myRNG));
 
   //loop over all the ions
   const auto& myTable = P.getDistTableAB(myTableIndex);
   // clear all the electron and ion neighbor lists
   for (int iat = 0; iat < NumIons; iat++)
     IonNeighborElecs.getNeighborList(iat).clear();
   for (int jel = 0; jel < P.getTotalNum(); jel++)
     ElecNeighborIons.getNeighborList(jel).clear();
 
   for (int ig = 0; ig < P.groups(); ++ig) //loop over species
   {
     for (int jel = P.first(ig); jel < P.last(ig); ++jel)
     {
       const auto& dist   = myTable.getDistRow(jel);
       const auto& displ  = myTable.getDisplRow(jel);
       auto& NeighborIons = ElecNeighborIons.getNeighborList(jel);
       for (int iat = 0; iat < NumIons; iat++)
         if (PP[iat] != nullptr && dist[iat] < PP[iat]->getRmax())
         {
           PP[iat]->evaluateOneBodyOpMatrixContribution(P, iat, psi, jel, dist[iat], -displ[iat], B);
           NeighborIons.push_back(iat);
           IonNeighborElecs.getNeighborList(iat).push_back(jel);
         }
     }
   }
 }

◆ evaluateOneBodyOpMatrixForceDeriv()

void evaluateOneBodyOpMatrixForceDeriv	(	ParticleSet &	P,
		ParticleSet &	source,
		const TWFFastDerivWrapper &	psi,
		const int	iat,
		std::vector< std::vector< ValueMatrix >> &	Bforce
	)

overridevirtual

Evaluate "dB/dR" matrices for observable.

Filippi scheme for computing fast derivatives.

Parameters

[in]	P,target	particle set (electrons)
[in]	source,ion	particle set
[in]	psi,Trial	Wavefunction wrapper for fast derivatives.
[in]	iat

Reimplemented from OperatorBase.

Definition at line 589 of file NonLocalECPotential.cpp.

References NonLocalECPotential::ElecNeighborIons, ParticleSet::first(), qmcplusplus::generateRandomRotationMatrix(), ParticleSet::getDistTableAB(), NeighborLists::getNeighborList(), ParticleSet::getTotalNum(), ParticleSet::groups(), NonLocalECPotential::IonNeighborElecs, ParticleSet::last(), NonLocalECPotential::myRNG, NonLocalECPotential::myTableIndex, NonLocalECPotential::NumIons, NonLocalECPotential::PP, and NonLocalECPotential::PPset.

 {
   bool keepGrid = true;
   for (int ipp = 0; ipp < PPset.size(); ipp++)
     if (PPset[ipp])
       if (!keepGrid)
         PPset[ipp]->rotateQuadratureGrid(generateRandomRotationMatrix(*myRNG));
 
   //loop over all the ions
   const auto& myTable = P.getDistTableAB(myTableIndex);
   // clear all the electron and ion neighbor lists
   for (int iat = 0; iat < NumIons; iat++)
     IonNeighborElecs.getNeighborList(iat).clear();
   for (int jel = 0; jel < P.getTotalNum(); jel++)
     ElecNeighborIons.getNeighborList(jel).clear();
 
   for (int ig = 0; ig < P.groups(); ++ig) //loop over species
   {
     for (int jel = P.first(ig); jel < P.last(ig); ++jel)
     {
       const auto& dist   = myTable.getDistRow(jel);
       const auto& displ  = myTable.getDisplRow(jel);
       auto& NeighborIons = ElecNeighborIons.getNeighborList(jel);
       for (int iat = 0; iat < NumIons; iat++)
         if (PP[iat] != nullptr && dist[iat] < PP[iat]->getRmax())
         {
           PP[iat]->evaluateOneBodyOpMatrixdRContribution(P, source, iat, iat_source, psi, jel, dist[iat], -displ[iat],
                                                          Bforce);
           NeighborIons.push_back(iat);
           IonNeighborElecs.getNeighborList(iat).push_back(jel);
         }
     }
   }
 }

◆ evaluateValueAndDerivatives()

NonLocalECPotential::Return_t evaluateValueAndDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		const Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi
	)

override

Definition at line 22 of file NonLocalECPotential.deriv.cpp.

References qmcplusplus::generateRandomRotationMatrix(), DistanceTableAB::getDistRow(), ParticleSet::getDistTableAB(), ParticleSet::getTotalNum(), NonLocalECPotential::myRNG, NonLocalECPotential::myTableIndex, NonLocalECPotential::NumIons, NonLocalECPotential::PP, NonLocalECPotential::PPset, NonLocalECPotential::Psi, and OperatorBase::value_.

 {
   value_ = 0.0;
   for (int ipp = 0; ipp < PPset.size(); ipp++)
     if (PPset[ipp])
       PPset[ipp]->rotateQuadratureGrid(generateRandomRotationMatrix(*myRNG));
 
   /* evaluating TWF ratio values requires calling prepareGroup
    * In evaluate() we first loop over species and call prepareGroup before looping over all the electrons of a species
    * Here it is not necessary because TWF::evaluateLog has been called and precomputed data is up-to-date
    */
   const auto& myTable = P.getDistTableAB(myTableIndex);
   for (int jel = 0; jel < P.getTotalNum(); jel++)
   {
     const auto& dist  = myTable.getDistRow(jel);
     const auto& displ = myTable.getDisplRow(jel);
     for (int iat = 0; iat < NumIons; iat++)
       if (PP[iat] != nullptr && dist[iat] < PP[iat]->getRmax())
         value_ += PP[iat]->evaluateValueAndDerivatives(P, iat, Psi, jel, dist[iat], -displ[iat], optvars, dlogpsi,
                                                        dhpsioverpsi);
   }
   return value_;
 }

◆ evaluateWithIonDerivs()

NonLocalECPotential::Return_t evaluateWithIonDerivs	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_term,
		ParticleSet::ParticlePos &	pulay_term
	)

overridevirtual

Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase.

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Adds OperatorBase's contribution to Re [(dH)Psi]/Psi
pulay_terms	Adds OperatorBase's contribution to Re [(H-E_L)dPsi]/Psi

Returns: Contribution of OperatorBase to Local Energy.

Reimplemented from OperatorBase.

Definition at line 516 of file NonLocalECPotential.cpp.

References NonLocalECPotential::evalIonDerivsImpl(), and OperatorBase::value_.

 {
   evalIonDerivsImpl(P, ions, psi, hf_terms, pulay_terms);
   return value_;
 }

◆ evaluateWithIonDerivsDeterministic()

NonLocalECPotential::Return_t evaluateWithIonDerivsDeterministic	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_term,
		ParticleSet::ParticlePos &	pulay_term
	)

overridevirtual

Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase.

If there's no stochastic component, defaults to evaluateWithIonDerivs. If not otherwise specified, this defaults to evaluate().

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Adds OperatorBase's contribution to Re [(dH)Psi]/Psi
pulay_terms	Adds OperatorBase's contribution to Re [(H-E_L)dPsi]/Psi

Returns: Contribution of OperatorBase to Local Energy.

Reimplemented from OperatorBase.

Definition at line 526 of file NonLocalECPotential.cpp.

References NonLocalECPotential::evalIonDerivsImpl(), and OperatorBase::value_.

 {
   evalIonDerivsImpl(P, ions, psi, hf_terms, pulay_terms, true);
   return value_;
 }

◆ evaluateWithToperator()

NonLocalECPotential::Return_t evaluateWithToperator ( ParticleSet & P )

overridevirtual

Evaluate the local energy contribution of this component with Toperators updated if requested.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Reimplemented from OperatorBase.

Definition at line 132 of file NonLocalECPotential.cpp.

References NonLocalECPotential::evaluateImpl(), qmcplusplus::TMOVE_V0, qmcplusplus::TMOVE_V3, NonLocalECPotential::UseTMove, and OperatorBase::value_.

 {
   if (UseTMove == TMOVE_V0 || UseTMove == TMOVE_V3)
     evaluateImpl(P, true);
   else
     evaluateImpl(P, false);
   return value_;
 }

◆ get()

bool get ( std::ostream & os ) const

inlineoverridevirtual

write about the class

Implements OperatorBase.

Definition at line 130 of file NonLocalECPotential.h.

References OhmmsElementBase::getName(), and NonLocalECPotential::IonConfig.

   {
     os << "NonLocalECPotential: " << IonConfig.getName();
     return true;
   }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements OperatorBase.

Definition at line 50 of file NonLocalECPotential.h.

50 { return "NonLocalECPotential"; }

◆ makeClone()

std::unique_ptr< OperatorBase > makeClone	(	ParticleSet &	qp,
		TrialWaveFunction &	psi
	)

overridevirtual

Implements OperatorBase.

Definition at line 794 of file NonLocalECPotential.cpp.

References NonLocalECPotential::ComputeForces, NonLocalECPotential::IonConfig, NonLocalECPotential::PPset, and NonLocalECPotential::use_DLA.

Referenced by qmcplusplus::TEST_CASE().

 {
   std::unique_ptr<NonLocalECPotential> myclone =
       std::make_unique<NonLocalECPotential>(IonConfig, qp, psi, ComputeForces, use_DLA);
   for (int ig = 0; ig < PPset.size(); ++ig)
     if (PPset[ig])
       myclone->addComponent(ig, std::make_unique<NonLocalECPComponent>(*PPset[ig], qp));
   return myclone;
 }

◆ makeNonLocalMovesPbyP()

int makeNonLocalMovesPbyP ( ParticleSet & P )

make non local moves with particle-by-particle moves

Parameters

P	particle set

Returns: the number of accepted moves

Definition at line 627 of file NonLocalECPotential.cpp.

Referenced by QMCHamiltonian::makeNonLocalMoves(), and QMCHamiltonian::mw_makeNonLocalMoves().

 {
   int NonLocalMoveAccepted = 0;
   auto& RandomGen(*myRNG);
   if (UseTMove == TMOVE_V0)
   {
     const NonLocalData* oneTMove = nonLocalOps.selectMove(RandomGen(), tmove_xy_);
     //make a non-local move
     if (oneTMove)
     {
       const int iat = oneTMove->PID;
       Psi.prepareGroup(P, P.getGroupID(iat));
       GradType grad_iat;
       if (P.makeMoveAndCheck(iat, oneTMove->Delta) && Psi.calcRatioGrad(P, iat, grad_iat) != ValueType(0))
       {
         Psi.acceptMove(P, iat, true);
         P.acceptMove(iat);
         NonLocalMoveAccepted++;
       }
     }
   }
   else if (UseTMove == TMOVE_V1)
   {
     GradType grad_iat;
     //make a non-local move per particle
     for (int ig = 0; ig < P.groups(); ++ig) //loop over species
     {
       Psi.prepareGroup(P, ig);
       for (int iat = P.first(ig); iat < P.last(ig); ++iat)
       {
         computeOneElectronTxy(P, iat);
         const NonLocalData* oneTMove = nonLocalOps.selectMove(RandomGen(), tmove_xy_);
         if (oneTMove)
         {
           if (P.makeMoveAndCheck(iat, oneTMove->Delta) && Psi.calcRatioGrad(P, iat, grad_iat) != ValueType(0))
           {
             Psi.acceptMove(P, iat, true);
             P.acceptMove(iat);
             NonLocalMoveAccepted++;
           }
         }
       }
     }
   }
   else if (UseTMove == TMOVE_V3)
   {
     elecTMAffected.assign(P.getTotalNum(), false);
     nonLocalOps.groupByElectron(P.getTotalNum(), tmove_xy_);
     GradType grad_iat;
     //make a non-local move per particle
     for (int ig = 0; ig < P.groups(); ++ig) //loop over species
     {
       Psi.prepareGroup(P, ig);
       for (int iat = P.first(ig); iat < P.last(ig); ++iat)
       {
         const NonLocalData* oneTMove;
         if (elecTMAffected[iat])
         {
           // recompute Txy for the given electron effected by Tmoves
           computeOneElectronTxy(P, iat);
           oneTMove = nonLocalOps.selectMove(RandomGen(), tmove_xy_);
         }
         else
           oneTMove = nonLocalOps.selectMove(RandomGen(), iat);
         if (oneTMove)
         {
           if (P.makeMoveAndCheck(iat, oneTMove->Delta) && Psi.calcRatioGrad(P, iat, grad_iat) != ValueType(0))
           {
             Psi.acceptMove(P, iat, true);
             // mark all affected electrons
             markAffectedElecs(P.getDistTableAB(myTableIndex), iat);
             P.acceptMove(iat);
             NonLocalMoveAccepted++;
           }
         }
       }
     }
   }
 
   if (NonLocalMoveAccepted > 0)
   {
     Psi.completeUpdates();
     // this step also updates electron positions on the device.
     P.donePbyP(true);
   }
 
   return NonLocalMoveAccepted;
 }

◆ markAffectedElecs()

void markAffectedElecs	(	const DistanceTableAB &	myTable,
		int	iel
	)

private

mark all the electrons affected by Tmoves and update ElecNeighborIons and IonNeighborElecs

Parameters

myTable	electron ion distance table
iel	reference electron Note this function should be called before acceptMove for a Tmove

Definition at line 716 of file NonLocalECPotential.cpp.

References NonLocalECPotential::ElecNeighborIons, NonLocalECPotential::elecTMAffected, DistanceTableAB::getDistRow(), NeighborLists::getNeighborList(), DistanceTableAB::getTempDists(), NonLocalECPotential::IonNeighborElecs, NonLocalECPotential::NumIons, and NonLocalECPotential::PP.

Referenced by NonLocalECPotential::makeNonLocalMovesPbyP().

 {
   std::vector<int>& NeighborIons = ElecNeighborIons.getNeighborList(iel);
   for (int iat = 0; iat < NumIons; iat++)
   {
     if (PP[iat] == nullptr)
       continue;
     Real old_distance = 0.0;
     Real new_distance = 0.0;
     old_distance      = myTable.getDistRow(iel)[iat];
     new_distance      = myTable.getTempDists()[iat];
     bool moved        = false;
     // move out
     if (old_distance < PP[iat]->getRmax() && new_distance >= PP[iat]->getRmax())
     {
       moved                           = true;
       std::vector<int>& NeighborElecs = IonNeighborElecs.getNeighborList(iat);
       auto iter_at                    = std::find(NeighborIons.begin(), NeighborIons.end(), iat);
       auto iter_el                    = std::find(NeighborElecs.begin(), NeighborElecs.end(), iel);
       *iter_at                        = NeighborIons.back();
       *iter_el                        = NeighborElecs.back();
       NeighborIons.pop_back();
       NeighborElecs.pop_back();
       elecTMAffected[iel] = true;
     }
     // move in
     if (old_distance >= PP[iat]->getRmax() && new_distance < PP[iat]->getRmax())
     {
       moved                           = true;
       std::vector<int>& NeighborElecs = IonNeighborElecs.getNeighborList(iat);
       NeighborElecs.push_back(iel);
       NeighborIons.push_back(iat);
     }
     // move around
     if (moved || (old_distance < PP[iat]->getRmax() && new_distance < PP[iat]->getRmax()))
     {
       std::vector<int>& NeighborElecs = IonNeighborElecs.getNeighborList(iat);
       for (int jel = 0; jel < NeighborElecs.size(); ++jel)
         elecTMAffected[NeighborElecs[jel]] = true;
     }
   }
 }

◆ mw_evaluate()

void mw_evaluate	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list
	)		const

overridevirtual

Evaluate the contribution of this component of multiple walkers.

Take o_list and p_list update evaluation result variables in o_list? really should reduce vector of local_energies. matching the ordering and size of o list the this can be call for 1 or more QMCHamiltonians

Parameters

o_list
wf_list
p_list

Temporary raw omp pragma for simple thread parallelism ignoring the driver level concurrency

TODO: replace this with a proper abstraction. It should adequately describe the behavior and strictly limit the activation of this level concurrency to when it is intended. It is unlikely to belong in this function.

This implicitly depends on openmp work division logic. Essentially adhoc runtime crowds over which we have given up control of thread/global scope. How many walkers per thread? How to handle their data movement if any of these hamiltonians should be accelerated? We can neither reason about or describe it in C++

As I understand it it should only be required for as long as the AMD openmp offload compliler is incapable of running multiple threads. They should/must fix their compiler before delivery of frontier and it should be removed at that point at latest

If you want 16 threads of 1 walker that should be 16 crowds of 1 not one crowd of 16 with openmp thrown in at hamiltonian level. If this must be different from the other crowd batching. Make this a reasoned about and controlled level of concurency blocking at the driver level.

This is only thread safe only if each walker has a complete set of anything involved in an Operator.evaluate.

Reimplemented from OperatorBase.

Definition at line 125 of file NonLocalECPotential.cpp.

References NonLocalECPotential::mw_evaluateImpl().

 {
   mw_evaluateImpl(o_list, wf_list, p_list, false, std::nullopt);
 }

◆ mw_evaluateImpl()

void mw_evaluateImpl	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		bool	Tmove,
		std::optional< ListenerOption< Real >>	listeners,
		bool	keepGrid = `false`
	)

staticprotected

the actual implementation for batched walkers, used by mw_evaluate, mw_evaluateWithToperator mw_evaluatePerPaticleWithToperator

Parameters

o_list	the list of NonLocalECPotential in a walker batch
wf_list	the list of TrialWaveFunction in a walker batch
p_list	the list of ParticleSet in a walker batch
Tmove	whether Txy for Tmove is updated
listeners	optional listeners which allow per particle and reduced to share impl

Definition at line 283 of file NonLocalECPotential.cpp.

References qmcplusplus::abs(), APP_ABORT, qmcplusplus::Units::charge::e, qmcplusplus::generateRandomRotationMatrix(), RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), RefVectorWithLeader< T >::getLeader(), NonLocalECPComponent::mw_evaluateOne(), TrialWaveFunction::mw_prepareGroup(), NonLocalECPotential::nlpp_jobs, NonLocalECPotential::Psi, ListenerVector< T >::report, and NonLocalECPotential::tmove_xy_.

Referenced by NonLocalECPotential::mw_evaluate(), TestNonLocalECPotential::mw_evaluateImpl(), NonLocalECPotential::mw_evaluatePerParticle(), NonLocalECPotential::mw_evaluatePerParticleWithToperator(), and NonLocalECPotential::mw_evaluateWithToperator().

 {
   auto& O_leader           = o_list.getCastedLeader<NonLocalECPotential>();
   ParticleSet& pset_leader = p_list.getLeader();
   const size_t nw          = o_list.size();
 
   if (O_leader.ComputeForces)
     APP_ABORT("NonLocalECPotential::mw_evaluateImpl(): Forces not imlpemented\n");
 
   for (size_t iw = 0; iw < nw; iw++)
   {
     auto& O = o_list.getCastedElement<NonLocalECPotential>(iw);
     const ParticleSet& P(p_list[iw]);
 
     if (Tmove)
       O.tmove_xy_.clear();
 
     if (!keep_grid)
       for (int ipp = 0; ipp < O.PPset.size(); ipp++)
         if (O.PPset[ipp])
           O.PPset[ipp]->rotateQuadratureGrid(generateRandomRotationMatrix(*O.myRNG));
 
     //loop over all the ions
     const auto& myTable = P.getDistTableAB(O.myTableIndex);
     // clear all the electron and ion neighbor lists
     for (int iat = 0; iat < O.NumIons; iat++)
       O.IonNeighborElecs.getNeighborList(iat).clear();
     for (int jel = 0; jel < P.getTotalNum(); jel++)
       O.ElecNeighborIons.getNeighborList(jel).clear();
 
     for (int ig = 0; ig < P.groups(); ++ig) //loop over species
     {
       auto& joblist = O.nlpp_jobs[ig];
       joblist.clear();
 
       for (int jel = P.first(ig); jel < P.last(ig); ++jel)
       {
         const auto& dist               = myTable.getDistRow(jel);
         const auto& displ              = myTable.getDisplRow(jel);
         std::vector<int>& NeighborIons = O.ElecNeighborIons.getNeighborList(jel);
         for (int iat = 0; iat < O.NumIons; iat++)
           if (O.PP[iat] != nullptr && dist[iat] < O.PP[iat]->getRmax())
           {
             NeighborIons.push_back(iat);
             O.IonNeighborElecs.getNeighborList(iat).push_back(jel);
             joblist.emplace_back(iat, jel, dist[iat], -displ[iat]);
           }
       }
     }
 
     O.value_ = 0.0;
   }
 
   if (listeners)
   {
     auto& ve_samples = O_leader.mw_res_handle_.getResource().ve_samples;
     auto& vi_samples = O_leader.mw_res_handle_.getResource().vi_samples;
     ve_samples.resize(nw, pset_leader.getTotalNum());
     vi_samples.resize(nw, O_leader.IonConfig.getTotalNum());
   }
 
   // the VP of the first NonLocalECPComponent is responsible for holding the shared resource.
   auto pp_component = std::find_if(O_leader.PPset.begin(), O_leader.PPset.end(), [](auto& ptr) { return bool(ptr); });
   assert(pp_component != std::end(O_leader.PPset));
 
   RefVector<NonLocalECPotential> ecp_potential_list;
   RefVectorWithLeader<NonLocalECPComponent> ecp_component_list(**pp_component);
   RefVectorWithLeader<ParticleSet> pset_list(pset_leader);
   RefVectorWithLeader<TrialWaveFunction> psi_list(O_leader.Psi);
   // we are moving away from internally stored Psi, double check before Psi gets finally removed.
   assert(&O_leader.Psi == &wf_list.getLeader());
   for (size_t iw = 0; iw < nw; iw++)
     assert(&o_list.getCastedElement<NonLocalECPotential>(iw).Psi == &wf_list[iw]);
 
   RefVector<const NLPPJob<Real>> batch_list;
   std::vector<Real> pairpots(nw);
 
   ecp_potential_list.reserve(nw);
   ecp_component_list.reserve(nw);
   pset_list.reserve(nw);
   psi_list.reserve(nw);
   batch_list.reserve(nw);
 
   for (int ig = 0; ig < pset_leader.groups(); ++ig) //loop over species
   {
     TrialWaveFunction::mw_prepareGroup(wf_list, p_list, ig);
 
     // find the max number of jobs of all the walkers
     size_t max_num_jobs = 0;
     for (size_t iw = 0; iw < nw; iw++)
     {
       const auto& O = o_list.getCastedElement<NonLocalECPotential>(iw);
       max_num_jobs  = std::max(max_num_jobs, O.nlpp_jobs[ig].size());
     }
 
     for (size_t jobid = 0; jobid < max_num_jobs; jobid++)
     {
       ecp_potential_list.clear();
       ecp_component_list.clear();
       pset_list.clear();
       psi_list.clear();
       batch_list.clear();
       for (size_t iw = 0; iw < nw; iw++)
       {
         auto& O = o_list.getCastedElement<NonLocalECPotential>(iw);
         if (jobid < O.nlpp_jobs[ig].size())
         {
           const auto& job = O.nlpp_jobs[ig][jobid];
           ecp_potential_list.push_back(O);
           ecp_component_list.push_back(*O.PP[job.ion_id]);
           pset_list.push_back(p_list[iw]);
           psi_list.push_back(wf_list[iw]);
           batch_list.push_back(job);
         }
       }
 
       NonLocalECPComponent::mw_evaluateOne(ecp_component_list, pset_list, psi_list, batch_list, pairpots,
                                            O_leader.mw_res_handle_.getResource().collection, O_leader.use_DLA);
 
       // Right now this is just over walker but could and probably should be over a set
       // larger than the walker count.  The easiest way to not complicate the per particle
       // reporting code would be to add the crowd walker index to the nlpp job meta data.
       for (size_t j = 0; j < ecp_potential_list.size(); j++)
       {
         ecp_potential_list[j].get().value_ += pairpots[j];
         if (Tmove)
           ecp_component_list[j].contributeTxy(batch_list[j].get().electron_id, ecp_potential_list[j].get().tmove_xy_);
 
         if (listeners)
         {
           auto& ve_samples = O_leader.mw_res_handle_.getResource().ve_samples;
           auto& vi_samples = O_leader.mw_res_handle_.getResource().vi_samples;
           // CAUTION! This may not be so simple in the future
           int iw = j;
           ve_samples(iw, batch_list[j].get().electron_id) += pairpots[j];
           vi_samples(iw, batch_list[j].get().ion_id) += pairpots[j];
         }
 
 #ifdef DEBUG_NLPP_BATCHED
         Real check_value =
             ecp_component_list[j].evaluateOne(pset_list[j], batch_list[j].get().ion_id, psi_list[j],
                                               batch_list[j].get().electron_id, batch_list[j].get().ion_elec_dist,
                                               batch_list[j].get().ion_elec_displ, O_leader.use_DLA);
         if (std::abs(check_value - pairpots[j]) > 1e-5)
           std::cout << "check " << check_value << " wrong " << pairpots[j] << " diff "
                     << std::abs(check_value - pairpots[j]) << std::endl;
 #endif
       }
     }
   }
 
   if (listeners)
   {
     // Motivation for this repeated definition is to make factoring this listener code out easy
     // and making it ignorable when reading this function.
     auto& ve_samples  = O_leader.mw_res_handle_.getResource().ve_samples;
     auto& vi_samples  = O_leader.mw_res_handle_.getResource().vi_samples;
     int num_electrons = pset_leader.getTotalNum();
     for (int iw = 0; iw < nw; ++iw)
     {
       Vector<Real> ve_sample(ve_samples.begin(iw), num_electrons);
       Vector<Real> vi_sample(vi_samples.begin(iw), O_leader.NumIons);
       for (const ListenerVector<Real>& listener : listeners->electron_values)
         listener.report(iw, O_leader.getName(), ve_sample);
       for (const ListenerVector<Real>& listener : listeners->ion_values)
         listener.report(iw, O_leader.getName(), vi_sample);
     }
     ve_samples = 0.0;
     vi_samples = 0.0;
   }
 }

◆ mw_evaluatePerParticle()

void mw_evaluatePerParticle	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< ListenerVector< Real >> &	listeners,
		const std::vector< ListenerVector< Real >> &	listeners_ions
	)		const

override

Definition at line 151 of file NonLocalECPotential.cpp.

References NonLocalECPotential::mw_evaluateImpl().

 {
   std::optional<ListenerOption<Real>> l_opt(std::in_place, listeners, listeners_ions);
   mw_evaluateImpl(o_list, wf_list, p_list, false, l_opt);
 }

◆ mw_evaluatePerParticleWithToperator()

void mw_evaluatePerParticleWithToperator	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< ListenerVector< Real >> &	listeners,
		const std::vector< ListenerVector< Real >> &	listeners_ions
	)		const

override

Definition at line 161 of file NonLocalECPotential.cpp.

References NonLocalECPotential::mw_evaluateImpl(), qmcplusplus::TMOVE_V0, qmcplusplus::TMOVE_V3, and NonLocalECPotential::UseTMove.

 {
   std::optional<ListenerOption<Real>> l_opt(std::in_place, listeners, listeners_ions);
   if (UseTMove == TMOVE_V0 || UseTMove == TMOVE_V3)
     mw_evaluateImpl(o_list, wf_list, p_list, true, l_opt);
   else
     mw_evaluateImpl(o_list, wf_list, p_list, false, l_opt);
 }

◆ mw_evaluateWithToperator()

void mw_evaluateWithToperator	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list
	)		const

overridevirtual

Evaluate the contribution of this component of multiple walkers.

Parameters

o_list
wf_list
p_list

Reimplemented from OperatorBase.

Definition at line 141 of file NonLocalECPotential.cpp.

References NonLocalECPotential::mw_evaluateImpl(), qmcplusplus::TMOVE_V0, qmcplusplus::TMOVE_V3, and NonLocalECPotential::UseTMove.

 {
   if (UseTMove == TMOVE_V0 || UseTMove == TMOVE_V3)
     mw_evaluateImpl(o_list, wf_list, p_list, true, std::nullopt);
   else
     mw_evaluateImpl(o_list, wf_list, p_list, false, std::nullopt);
 }

◆ put()

bool put ( xmlNodePtr cur )

inlineoverridevirtual

Do nothing.

Implements OperatorBase.

Definition at line 128 of file NonLocalECPotential.h.

128 { return true; }

◆ registerObservables()

void registerObservables	(	std::vector< ObservableHelper > &	h5desc,
		hdf_archive &	file
	)		const

overridevirtual

add to observable descriptor for hdf5 The default implementation is to register a scalar for this->value_

Parameters

h5desc	contains a set of hdf5 descriptors for a scalar observable
gid	hdf5 group to which the observables belong

Reimplemented from OperatorBase.

Definition at line 827 of file NonLocalECPotential.cpp.

References NonLocalECPotential::ComputeForces, ForceBase::first_force_index_, ForceBase::n_nuc_, OHMMS_DIM, OperatorBase::registerObservables(), and qmcplusplus::Units::time::s.

 {
   using namespace std::string_literals;
 
   OperatorBase::registerObservables(h5list, file);
   if (ComputeForces)
   {
     std::vector<int> ndim(2);
     ndim[0] = n_nuc_;
     ndim[1] = OHMMS_DIM;
     h5list.push_back({{"FNL"s}});
     auto& h5o1 = h5list.back();
     h5o1.set_dimensions(ndim, first_force_index_);
   }
 }

◆ releaseResource()

void releaseResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< OperatorBase > &	o_list
	)		const

overridevirtual

return a shared resource to a collection

Reimplemented from OperatorBase.

Definition at line 787 of file NonLocalECPotential.cpp.

References RefVectorWithLeader< T >::getCastedLeader(), and ResourceCollection::takebackResource().

 {
   auto& O_leader = o_list.getCastedLeader<NonLocalECPotential>();
   collection.takebackResource(O_leader.mw_res_handle_);
 }

◆ resetTargetParticleSet()

void resetTargetParticleSet ( ParticleSet & P )

overridevirtual

Reset the data with the target ParticleSet.

Parameters

P	new target ParticleSet

Implements OperatorBase.

Definition at line 47 of file NonLocalECPotential.cpp.

47 {}

◆ setComputeForces()

void setComputeForces ( bool val )

inlineoverridevirtual

Set the flag whether to compute forces or not.

Parameters

val	The boolean value for computing forces

Reimplemented from OperatorBase.

Definition at line 168 of file NonLocalECPotential.h.

References NonLocalECPotential::ComputeForces.

168 { ComputeForces = val; }

qmcplusplus::NonLocalECPotential::ComputeForces

bool ComputeForces

true if we should compute forces

Definition: NonLocalECPotential.h:197

◆ setNonLocalMoves() [1/2]

void setNonLocalMoves ( xmlNodePtr cur )

inline

set non local moves options

Parameters

cur	the xml input

Definition at line 107 of file NonLocalECPotential.h.

References NonLocalECPotential::nonLocalOps, NonLocalTOperator::put(), and NonLocalECPotential::UseTMove.

Referenced by QMCHamiltonian::setNonLocalMoves().

107 { UseTMove = nonLocalOps.put(cur); }

qmcplusplus::NonLocalECPotential::UseTMove

int UseTMove

use T-moves

Definition: NonLocalECPotential.h:213

qmcplusplus::NonLocalECPotential::nonLocalOps

NonLocalTOperator nonLocalOps

non local operator

Definition: NonLocalECPotential.h:217

qmcplusplus::NonLocalTOperator::put

int put(xmlNodePtr cur)

initialize the parameters

Definition: NonLocalTOperator.cpp:30

◆ setNonLocalMoves() [2/2]

void setNonLocalMoves	(	const std::string &	non_local_move_option,
		const double	tau,
		const double	alpha,
		const double	gamma
	)

inline

Definition at line 109 of file NonLocalECPotential.h.

References NonLocalECPotential::nonLocalOps, NonLocalTOperator::thingsThatShouldBeInMyConstructor(), and NonLocalECPotential::UseTMove.

   {
     UseTMove = nonLocalOps.thingsThatShouldBeInMyConstructor(non_local_move_option, tau, alpha, gamma);
   }

◆ setObservables()

void setObservables ( QMCTraits::PropertySetType & plist )

overridevirtual

Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_.

Parameters

plist RecordNameProperty

Reimplemented from OperatorBase.

Definition at line 843 of file NonLocalECPotential.cpp.

References NonLocalECPotential::ComputeForces, ForceBase::first_force_index_, ForceBase::forces_, ForceBase::n_nuc_, OHMMS_DIM, and OperatorBase::setObservables().

 {
   OperatorBase::setObservables(plist);
   if (ComputeForces)
   {
     int index = first_force_index_;
     for (int iat = 0; iat < n_nuc_; iat++)
     {
       for (int x = 0; x < OHMMS_DIM; x++)
       {
         plist[index++] = forces_[iat][x];
         //    plist[index++] = PulayTerm[iat][x];
       }
     }
   }
 }

◆ setParticlePropertyList()

void setParticlePropertyList	(	QMCTraits::PropertySetType &	plist,
		int	offset
	)

overridevirtual

Reimplemented from OperatorBase.

Definition at line 861 of file NonLocalECPotential.cpp.

References NonLocalECPotential::ComputeForces, ForceBase::first_force_index_, ForceBase::forces_, ForceBase::n_nuc_, OHMMS_DIM, and OperatorBase::setParticlePropertyList().

 {
   OperatorBase::setParticlePropertyList(plist, offset);
   if (ComputeForces)
   {
     int index = first_force_index_ + offset;
     for (int iat = 0; iat < n_nuc_; iat++)
     {
       for (int x = 0; x < OHMMS_DIM; x++)
       {
         plist[index++] = forces_[iat][x];
         //        plist[index++] = PulayTerm[iat][x];
       }
     }
   }
 }

◆ setRandomGenerator()

void setRandomGenerator ( RandomBase< FullPrecRealType > * rng )

inlineoverridevirtual

set the internal RNG pointer as the given pointer

Parameters

rng	input RNG pointer

Reimplemented from OperatorBase.

Definition at line 155 of file NonLocalECPotential.h.

References NonLocalECPotential::myRNG.

Referenced by QMCHamiltonian::setRandomGenerator(), and qmcplusplus::TEST_CASE().

155 { myRNG = rng; }

qmcplusplus::NonLocalECPotential::myRNG

RandomBase< FullPrecRealType > * myRNG

random number generator

Definition: NonLocalECPotential.h:187

Friends And Related Function Documentation

◆ testing::TestNonLocalECPotential

friend class testing::TestNonLocalECPotential

friend

Definition at line 260 of file NonLocalECPotential.h.

Member Data Documentation

◆ ComputeForces

bool ComputeForces

protected

true if we should compute forces

Definition at line 197 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::addObservables(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::makeClone(), NonLocalECPotential::registerObservables(), NonLocalECPotential::setComputeForces(), NonLocalECPotential::setObservables(), and NonLocalECPotential::setParticlePropertyList().

◆ ElecNeighborIons

NeighborLists ElecNeighborIons

private

neighborlist of electrons

Definition at line 209 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::computeOneElectronTxy(), NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::evaluateOneBodyOpMatrix(), NonLocalECPotential::evaluateOneBodyOpMatrixForceDeriv(), and NonLocalECPotential::markAffectedElecs().

◆ elecTMAffected

std::vector<bool> elecTMAffected

private

ture if an electron is affected by other electrons moved by T-moves

Definition at line 215 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::makeNonLocalMovesPbyP(), and NonLocalECPotential::markAffectedElecs().

◆ IonConfig

ParticleSet& IonConfig

protected

reference to the center ion

Definition at line 193 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::addComponent(), NonLocalECPotential::checkoutParticleQuantities(), NonLocalECPotential::get(), NonLocalECPotential::makeClone(), and NonLocalECPotential::NonLocalECPotential().

◆ IonNeighborElecs

NeighborLists IonNeighborElecs

private

neighborlist of ions

Definition at line 211 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::evaluateOneBodyOpMatrix(), NonLocalECPotential::evaluateOneBodyOpMatrixForceDeriv(), and NonLocalECPotential::markAffectedElecs().

◆ mw_res_handle_

ResourceHandle<NonLocalECPotentialMultiWalkerResource> mw_res_handle_

private

mult walker shared resource

Definition at line 231 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::acquireResource().

◆ myRNG

RandomBase<FullPrecRealType>* myRNG

protected

random number generator

Definition at line 187 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::evaluateOneBodyOpMatrix(), NonLocalECPotential::evaluateOneBodyOpMatrixForceDeriv(), NonLocalECPotential::evaluateValueAndDerivatives(), NonLocalECPotential::makeNonLocalMovesPbyP(), and NonLocalECPotential::setRandomGenerator().

◆ myTableIndex

int myTableIndex

private

index of distance table for the ion-el pair

Definition at line 205 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::computeOneElectronTxy(), NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::evaluateOneBodyOpMatrix(), NonLocalECPotential::evaluateOneBodyOpMatrixForceDeriv(), NonLocalECPotential::evaluateValueAndDerivatives(), NonLocalECPotential::makeNonLocalMovesPbyP(), and NonLocalECPotential::NonLocalECPotential().

◆ nlpp_jobs

std::vector<std::vector<NLPPJob<Real> > > nlpp_jobs

private

NLPP job list of ion-electron pairs by spin group.

Definition at line 229 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::mw_evaluateImpl(), and NonLocalECPotential::NonLocalECPotential().

◆ nonLocalOps

NonLocalTOperator nonLocalOps

private

non local operator

Definition at line 217 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::makeNonLocalMovesPbyP(), and NonLocalECPotential::setNonLocalMoves().

◆ NumIons

int NumIons

private

number of ions

Definition at line 203 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::evaluateOneBodyOpMatrix(), NonLocalECPotential::evaluateOneBodyOpMatrixForceDeriv(), NonLocalECPotential::evaluateValueAndDerivatives(), NonLocalECPotential::markAffectedElecs(), and NonLocalECPotential::NonLocalECPotential().

◆ Peln

ParticleSet& Peln

private

reference to the electrons

Definition at line 207 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::checkoutParticleQuantities().

◆ PP

std::vector<NonLocalECPComponent*> PP

protected

the set of local-potentials (one for each ion)

Definition at line 189 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::addComponent(), NonLocalECPotential::computeOneElectronTxy(), NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::evaluateOneBodyOpMatrix(), NonLocalECPotential::evaluateOneBodyOpMatrixForceDeriv(), NonLocalECPotential::evaluateValueAndDerivatives(), NonLocalECPotential::markAffectedElecs(), and NonLocalECPotential::NonLocalECPotential().

◆ PPset

std::vector<std::unique_ptr<NonLocalECPComponent> > PPset

protected

unique NonLocalECPComponent to remove

Definition at line 191 of file NonLocalECPotential.h.

◆ Psi

TrialWaveFunction& Psi

protected

target TrialWaveFunction

Definition at line 195 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::computeOneElectronTxy(), NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::evaluateValueAndDerivatives(), NonLocalECPotential::makeNonLocalMovesPbyP(), and NonLocalECPotential::mw_evaluateImpl().

◆ PulayTerm

ParticleSet::ParticlePos PulayTerm

private

Pulay force vector.

Definition at line 219 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::evalIonDerivsImpl(), and NonLocalECPotential::NonLocalECPotential().

◆ tmove_xy_

std::vector<NonLocalData> tmove_xy_

private

Definition at line 221 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::computeOneElectronTxy(), NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), NonLocalECPotential::makeNonLocalMovesPbyP(), and NonLocalECPotential::mw_evaluateImpl().

◆ use_DLA

bool use_DLA

protected

true, determinant localization approximation(DLA) is enabled

Definition at line 199 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::computeOneElectronTxy(), NonLocalECPotential::evaluateImpl(), and NonLocalECPotential::makeClone().

◆ UseTMove

int UseTMove

private

use T-moves

Definition at line 213 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::evaluateWithToperator(), NonLocalECPotential::makeNonLocalMovesPbyP(), NonLocalECPotential::mw_evaluatePerParticleWithToperator(), NonLocalECPotential::mw_evaluateWithToperator(), and NonLocalECPotential::setNonLocalMoves().

◆ Ve_sample

Array<TraceReal, 1>* Ve_sample

private

single particle trace samples

Definition at line 225 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::checkoutParticleQuantities(), NonLocalECPotential::deleteParticleQuantities(), and NonLocalECPotential::evaluateImpl().

◆ Vi_sample

Array<TraceReal, 1>* Vi_sample

private

Definition at line 226 of file NonLocalECPotential.h.

Referenced by NonLocalECPotential::checkoutParticleQuantities(), NonLocalECPotential::deleteParticleQuantities(), and NonLocalECPotential::evaluateImpl().

◆ qmcplusplus::OperatorBase

class qmcplusplus::OperatorBase

An abstract class for Local Energy operators.

Return_t is defined as RealTye. The types should be checked when using complex wave functions.

Definition at line 59 of file OperatorBase.h.

Inheritance diagram for OperatorBase:

Collaboration diagram for OperatorBase:

Public Types
enum	EnergyDomains { KINETIC = 0, POTENTIAL, NO_ENERGY_DOMAIN }
	enum to denote energy domain of operators More...

enum	QuantumDomains { NO_QUANTUM_DOMAIN = 0, CLASSICAL, QUANTUM, CLASSICAL_CLASSICAL, QUANTUM_CLASSICAL, QUANTUM_QUANTUM }

enum	{ PRIMARY = 0, OPTIMIZABLE = 1, RATIOUPDATE = 2, PHYSICAL = 3, COLLECTABLE = 4, NONLOCAL = 5 }
	enum for update_mode More...

using	Return_t = FullPrecRealType
	type of return value of evaluate More...

using	ValueMatrix = SPOSet::ValueMatrix
	For fast derivative evaluation. More...

using	GradMatrix = SPOSet::GradMatrix

using	BufferType = ParticleSet::Buffer_t
	typedef for the serialized buffer More...

using	Walker_t = ParticleSet::Walker_t
	typedef for the walker More...

using	ParticleScalar = ParticleSet::Scalar_t
	typedef for the ParticleScalar More...

using	SPOMap = SPOSet::SPOMap
	typedef for SPOMap More...

Public Types inherited from QMCTraits
enum	{ DIM = OHMMS_DIM, DIM_VGL = OHMMS_DIM + 2 }

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

using	PropertySetType = RecordNamedProperty< FullPrecRealType >
	define PropertyList_t More...

using	PtclGrpIndexes = std::vector< std::pair< int, int > >

Public Member Functions
	OperatorBase ()
	Construct a new Operator Base object Default and unique empty constructor. More...

virtual	~OperatorBase ()=default

virtual bool	dependsOnWaveFunction () const
	return true if this operator depends on a wavefunction More...

std::bitset< 8 > &	getUpdateMode () noexcept
	get update_mode_ reference More...

Return_t	getValue () const noexcept
	get a copy of value_ More...

std::string	getName () const noexcept
	getter a copy of my_name_, rvalue small string optimization More...

virtual std::string	getClassName () const =0
	return class name More...

void	setName (const std::string name) noexcept
	Set my_name member, uses small string optimization (pass by value) More...

TraceRequest &	getRequest () noexcept
	Get request_ member. More...

virtual void	resetTargetParticleSet (ParticleSet &P)=0
	Reset the data with the target ParticleSet. More...

virtual Return_t	evaluate (ParticleSet &P)=0
	Evaluate the local energy contribution of this component. More...

virtual bool	get (std::ostream &os) const =0
	write about the class More...

virtual std::unique_ptr< OperatorBase >	makeClone (ParticleSet &qp, TrialWaveFunction &psi)=0

virtual void	addObservables (PropertySetType &plist, BufferType &collectables)
	named values to the property list Default implementaton uses addValue(plist_) More...

virtual void	registerObservables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const
	add to observable descriptor for hdf5 The default implementation is to register a scalar for this->value_ More...

virtual void	registerCollectables (std::vector< ObservableHelper > &h5desc, hdf_archive &file) const

virtual void	setObservables (PropertySetType &plist)
	Set the values evaluated by this object to plist Default implementation is to assign Value which is updated by evaluate function using my_index_. More...

virtual void	setParticlePropertyList (PropertySetType &plist, int offset)

virtual void	setHistories (Walker_t &ThisWalker)

virtual Return_t	evaluateDeterministic (ParticleSet &P)
	Evaluate the local energy contribution of this component, deterministically based on current state. More...

virtual void	mw_evaluate (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticle (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual void	mw_evaluateWithParameterDerivatives (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< ParticleSet > &p_list, const opt_variables_type &optvars, const RecordArray< ValueType > &dlogpsi, RecordArray< ValueType > &dhpsioverpsi) const
	TODO: add docs. More...

virtual Return_t	rejectedMove (ParticleSet &P)
	TODO: add docs. More...

virtual Return_t	evaluateWithToperator (ParticleSet &P)
	Evaluate the local energy contribution of this component with Toperators updated if requested. More...

virtual void	mw_evaluateWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	Evaluate the contribution of this component of multiple walkers. More...

virtual void	mw_evaluatePerParticleWithToperator (const RefVectorWithLeader< OperatorBase > &o_list, const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< ListenerVector< RealType >> &listeners, const std::vector< ListenerVector< RealType >> &listeners_ions) const
	Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators. More...

virtual Return_t	evaluateValueAndDerivatives (ParticleSet &P, const opt_variables_type &optvars, const Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	Evaluate value and derivatives wrt the optimizables. More...

virtual Return_t	evaluateWithIonDerivs (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_term, ParticleSet::ParticlePos &pulay_term)
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

virtual Return_t	evaluateWithIonDerivsDeterministic (ParticleSet &P, ParticleSet &ions, TrialWaveFunction &psi, ParticleSet::ParticlePos &hf_term, ParticleSet::ParticlePos &pulay_term)
	Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase. More...

virtual void	evaluateOneBodyOpMatrix (ParticleSet &P, const TWFFastDerivWrapper &psi, std::vector< ValueMatrix > &B)
	Evaluate "B" matrix for observable. More...

virtual void	evaluateOneBodyOpMatrixForceDeriv (ParticleSet &P, ParticleSet &source, const TWFFastDerivWrapper &psi, const int iat, std::vector< std::vector< ValueMatrix >> &Bforce)
	Evaluate "dB/dR" matrices for observable. More...

virtual void	updateSource (ParticleSet &s)
	Update data associated with a particleset. More...

virtual Return_t	getEnsembleAverage ()
	Return an average value by collective operation. More...

virtual void	createResource (ResourceCollection &collection) const
	Initialize a shared resource and hand it to a collection. More...

virtual void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const
	Acquire a shared resource from a collection. More...

virtual void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< OperatorBase > &o_list) const
	Return a shared resource to a collection. More...

virtual void	setRandomGenerator (RandomBase< FullPrecRealType > *rng)
	Set the Random Generator object TODO: add docs. More...

virtual void	add2Hamiltonian (ParticleSet &qp, TrialWaveFunction &psi, QMCHamiltonian &targetH)
	TODO: add docs. More...

virtual void	getRequiredTraces (TraceManager &tm)
	TODO: add docs. More...

virtual void	informOfPerParticleListener ()

bool	isClassical () const noexcept

bool	isQuantum () const noexcept

bool	isClassicalClassical () const noexcept

bool	isQuantumClassical () const noexcept

bool	isQuantumQuantum () const noexcept

bool	getMode (const int i) const noexcept
	Return the mode i. More...

bool	isNonLocal () const noexcept
	TODO: add docs. More...

bool	hasListener () const noexcept

void	contributeTraceQuantities ()
	Make trace quantities available. More...

void	checkoutTraceQuantities (TraceManager &tm)
	Checkout trace arrays Derived classes must guard individual checkouts using request info. More...

void	collectScalarTraces ()
	Collect scalar trace data. More...

void	deleteTraceQuantities ()
	delete trace arrays More...

Protected Member Functions
virtual bool	put (xmlNodePtr cur)=0
	Read the input parameter. More...

virtual void	contributeScalarQuantities ()

virtual void	checkoutScalarQuantities (TraceManager &tm)

virtual void	collectScalarQuantities ()

virtual void	deleteScalarQuantities ()

virtual void	contributeParticleQuantities ()

virtual void	checkoutParticleQuantities (TraceManager &tm)

virtual void	deleteParticleQuantities ()

virtual void	setComputeForces (bool compute)

void	setEnergyDomain (EnergyDomains edomain)
	Set the Energy Domain. More...

void	setQuantumDomain (QuantumDomains qdomain)
	set quantum domain More...

void	oneBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for one-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P)
	set quantum domain for two-body operator More...

void	twoBodyQuantumDomain (const ParticleSet &P1, const ParticleSet &P2)
	set quantum domain for two-body operator More...

void	addValue (PropertySetType &plist)
	named values to the property list More...

Protected Attributes
std::bitset< 8 >	update_mode_
	set the current update mode More...

Return_t	value_
	current value More...

std::string	name_
	name of this object More...

TraceRequest	request_
	whether traces are being collected More...

int	my_index_
	starting index of this object More...

Return_t	new_value_
	a new value for a proposed move More...

Walker_t *	t_walker_
	reference to the current walker More...

bool	streaming_particles_

bool	have_required_traces_

Private Member Functions
bool	energyDomainValid (EnergyDomains edomain) const noexcept
	return whether the energy domain is valid More...

bool	quantumDomainValid (QuantumDomains qdomain) const noexcept
	return whether the quantum domain is valid More...

Private Attributes
bool	streaming_scalars_

Array< RealType, 1 > *	value_sample_
	array to store sample value More...

bool	has_listener_ = false
	Is there a per particle listener sadly this is necessary due to state machines. More...

QuantumDomains	quantum_domain_
	quantum_domain_ of the (particle) operator, default = no_quantum_domain More...

EnergyDomains	energy_domain_
	energy domain of the operator (kinetic/potential), default = no_energy_domain More...

Member Typedef Documentation

◆ BufferType

using BufferType = ParticleSet::Buffer_t

typedef for the serialized buffer

PooledData<RealType> is used to serialized an anonymous buffer

Definition at line 75 of file OperatorBase.h.

◆ GradMatrix

using GradMatrix = SPOSet::GradMatrix

Definition at line 69 of file OperatorBase.h.

◆ ParticleScalar

using ParticleScalar = ParticleSet::Scalar_t

typedef for the ParticleScalar

Definition at line 81 of file OperatorBase.h.

◆ Return_t

using Return_t = FullPrecRealType

type of return value of evaluate

Definition at line 64 of file OperatorBase.h.

◆ SPOMap

using SPOMap = SPOSet::SPOMap

typedef for SPOMap

Definition at line 84 of file OperatorBase.h.

◆ ValueMatrix

using ValueMatrix = SPOSet::ValueMatrix

For fast derivative evaluation.

Definition at line 68 of file OperatorBase.h.

◆ Walker_t

using Walker_t = ParticleSet::Walker_t

typedef for the walker

Definition at line 78 of file OperatorBase.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

enum for update_mode

Enumerator
PRIMARY
OPTIMIZABLE
RATIOUPDATE
PHYSICAL
COLLECTABLE
NONLOCAL

Definition at line 105 of file OperatorBase.h.

   {
     PRIMARY     = 0,
     OPTIMIZABLE = 1,
     RATIOUPDATE = 2,
     PHYSICAL    = 3,
     COLLECTABLE = 4,
     NONLOCAL    = 5,
   };

◆ EnergyDomains

enum EnergyDomains

enum to denote energy domain of operators

Enumerator
KINETIC
POTENTIAL
NO_ENERGY_DOMAIN

Definition at line 87 of file OperatorBase.h.

   {
     KINETIC = 0,
     POTENTIAL,
     NO_ENERGY_DOMAIN
   };

◆ QuantumDomains

enum QuantumDomains

Enumerator
NO_QUANTUM_DOMAIN
CLASSICAL
QUANTUM
CLASSICAL_CLASSICAL
QUANTUM_CLASSICAL
QUANTUM_QUANTUM

Definition at line 94 of file OperatorBase.h.

   {
     NO_QUANTUM_DOMAIN = 0,
     CLASSICAL,
     QUANTUM,
     CLASSICAL_CLASSICAL,
     QUANTUM_CLASSICAL,
     QUANTUM_QUANTUM
   };

Constructor & Destructor Documentation

◆ OperatorBase()

OperatorBase ( )

Construct a new Operator Base object Default and unique empty constructor.

Initializes with default values.

Definition at line 28 of file OperatorBase.cpp.

References OperatorBase::PRIMARY, and OperatorBase::update_mode_.

     : value_(0.0),
       my_index_(-1),
       t_walker_(0),
 #if !defined(REMOVE_TRACEMANAGER)
       streaming_particles_(false),
       have_required_traces_(false),
       streaming_scalars_(false),
 #endif
       quantum_domain_(NO_QUANTUM_DOMAIN),
       energy_domain_(NO_ENERGY_DOMAIN)
 {
   update_mode_.set(PRIMARY, 1);
 }

◆ ~OperatorBase()

virtual ~OperatorBase ( )

virtualdefault

Member Function Documentation

◆ acquireResource()

void acquireResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< OperatorBase > &	o_list
	)		const

virtual

Acquire a shared resource from a collection.

Parameters

collection
o_list

Reimplemented in CoulombPBCAB, CoulombPBCAA, BareKineticEnergy, NonLocalECPotential, and SOECPotential.

Definition at line 205 of file OperatorBase.cpp.

207 {}

◆ add2Hamiltonian()

void add2Hamiltonian	(	ParticleSet &	qp,
		TrialWaveFunction &	psi,
		QMCHamiltonian &	targetH
	)

virtual

TODO: add docs.

Parameters

qp
psi
targetH

Reimplemented in ACForce.

Definition at line 215 of file OperatorBase.cpp.

References QMCHamiltonian::addOperator(), OperatorBase::makeClone(), OperatorBase::name_, OperatorBase::PHYSICAL, and OperatorBase::update_mode_.

 {
   std::unique_ptr<OperatorBase> myclone = makeClone(qp, psi);
   if (myclone)
   {
     targetH.addOperator(std::move(myclone), name_, update_mode_[PHYSICAL]);
   }
 }

◆ addObservables()

void addObservables	(	PropertySetType &	plist,
		BufferType &	collectables
	)

virtual

named values to the property list Default implementaton uses addValue(plist_)

Parameters

plist	RecordNameProperty
collectables	Observables that are accumulated by evaluate

Reimplemented in OrbitalImages, CoulombPBCAB, DensityMatrices1B, CoulombPBCAA, NonLocalECPotential, CoulombPotential< T >, StressPBC, ForceChiesaPBCAA, ForwardWalking, ForceCeperley, ACForce, LatticeDeviationEstimator, SpinDensity, PairCorrEstimator, SelfHealingOverlapLegacy, StaticStructureFactor, SkAllEstimator, SpeciesKineticEnergy, BareForce, DensityEstimator, SkEstimator, EnergyDensityEstimator, and MomentumEstimator.

Definition at line 56 of file OperatorBase.cpp.

References OperatorBase::addValue().

56 { addValue(plist); }

qmcplusplus::OperatorBase::addValue

void addValue(PropertySetType &plist)

named values to the property list

Definition: OperatorBase.cpp:355

◆ addValue()

void addValue ( PropertySetType & plist )

protected

named values to the property list

Parameters

plist RecordNameProperty

Previously addObservables but it is renamed and a non-virtial function.

Definition at line 355 of file OperatorBase.cpp.

References RecordNamedProperty< T >::add(), OperatorBase::COLLECTABLE, OperatorBase::my_index_, OperatorBase::name_, and OperatorBase::update_mode_.

Referenced by CoulombPotential< T >::addObservables(), CoulombPBCAA::addObservables(), NonLocalECPotential::addObservables(), and OperatorBase::addObservables().

 {
   if (!update_mode_[COLLECTABLE])
     my_index_ = plist.add(name_.c_str());
 }

◆ checkoutParticleQuantities()

void checkoutParticleQuantities ( TraceManager & tm )

protectedvirtual

Reimplemented in CoulombPBCAA, CoulombPBCAB, CoulombPotential< T >, LocalECPotential, BareKineticEnergy, HarmonicExternalPotential, NonLocalECPotential, and GridExternalPotential.

Definition at line 297 of file OperatorBase.cpp.

Referenced by OperatorBase::checkoutTraceQuantities().

297 {};

◆ checkoutScalarQuantities()

void checkoutScalarQuantities ( TraceManager & tm )

protectedvirtual

Reimplemented in DensityMatrices1B, and EnergyDensityEstimator.

Definition at line 277 of file OperatorBase.cpp.

References TraceManager::checkout_real(), OperatorBase::name_, OperatorBase::request_, TraceRequest::streaming_scalar(), OperatorBase::streaming_scalars_, and OperatorBase::value_sample_.

Referenced by OperatorBase::checkoutTraceQuantities().

 {
   streaming_scalars_ = request_.streaming_scalar(name_);
   if (streaming_scalars_)
     value_sample_ = tm.checkout_real<1>(name_);
 }

◆ checkoutTraceQuantities()

void checkoutTraceQuantities ( TraceManager & tm )

Checkout trace arrays Derived classes must guard individual checkouts using request info.

Parameters

tm

Definition at line 254 of file OperatorBase.cpp.

References OperatorBase::checkoutParticleQuantities(), and OperatorBase::checkoutScalarQuantities().

 {
   checkoutScalarQuantities(tm);
   checkoutParticleQuantities(tm);
 }

◆ collectScalarQuantities()

void collectScalarQuantities ( )

protectedvirtual

Reimplemented in DensityMatrices1B, and EnergyDensityEstimator.

Definition at line 284 of file OperatorBase.cpp.

References OperatorBase::streaming_scalars_, and OperatorBase::value_.

Referenced by OperatorBase::collectScalarTraces().

 {
   if (streaming_scalars_)
     (*value_sample_)(0) = value_;
 }

◆ collectScalarTraces()

void collectScalarTraces ( )

Collect scalar trace data.

Definition at line 260 of file OperatorBase.cpp.

References OperatorBase::collectScalarQuantities().

260 { collectScalarQuantities(); }

qmcplusplus::OperatorBase::collectScalarQuantities

virtual void collectScalarQuantities()

Definition: OperatorBase.cpp:284

◆ contributeParticleQuantities()

void contributeParticleQuantities ( )

protectedvirtual

Reimplemented in CoulombPBCAA, CoulombPBCAB, CoulombPotential< T >, LocalECPotential, BareKineticEnergy, HarmonicExternalPotential, NonLocalECPotential, and GridExternalPotential.

Definition at line 296 of file OperatorBase.cpp.

Referenced by OperatorBase::contributeTraceQuantities().

296 {};

◆ contributeScalarQuantities()

void contributeScalarQuantities ( )

protectedvirtual

Reimplemented in DensityMatrices1B, and EnergyDensityEstimator.

Definition at line 275 of file OperatorBase.cpp.

References TraceRequest::contribute_scalar(), OperatorBase::name_, and OperatorBase::request_.

Referenced by OperatorBase::contributeTraceQuantities().

275 { request_.contribute_scalar(name_); }

TraceRequest request_

whether traces are being collected

Definition: OperatorBase.h:531

qmcplusplus::TraceRequest::contribute_scalar

std::string name_

name of this object

Definition: OperatorBase.h:527

void contribute_scalar(const std::string &name, bool default_quantity=false)

Definition: TraceManager.h:189

◆ contributeTraceQuantities()

void contributeTraceQuantities ( )

Make trace quantities available.

Definition at line 248 of file OperatorBase.cpp.

References OperatorBase::contributeParticleQuantities(), and OperatorBase::contributeScalarQuantities().

 {
   contributeScalarQuantities();
   contributeParticleQuantities();
 }

◆ createResource()

void createResource ( ResourceCollection & collection ) const

virtual

Initialize a shared resource and hand it to a collection.

Parameters

collection

Reimplemented in CoulombPBCAB, CoulombPBCAA, BareKineticEnergy, NonLocalECPotential, and SOECPotential.

Definition at line 203 of file OperatorBase.cpp.

203 {}

◆ deleteParticleQuantities()

void deleteParticleQuantities ( )

protectedvirtual

Reimplemented in CoulombPBCAA, CoulombPBCAB, CoulombPotential< T >, LocalECPotential, HarmonicExternalPotential, BareKineticEnergy, NonLocalECPotential, and GridExternalPotential.

Definition at line 298 of file OperatorBase.cpp.

Referenced by OperatorBase::deleteTraceQuantities().

298 {};

◆ deleteScalarQuantities()

void deleteScalarQuantities ( )

protectedvirtual

Reimplemented in DensityMatrices1B, and EnergyDensityEstimator.

Definition at line 290 of file OperatorBase.cpp.

References OperatorBase::streaming_scalars_, and OperatorBase::value_sample_.

Referenced by OperatorBase::deleteTraceQuantities().

 {
   if (streaming_scalars_)
     delete value_sample_;
 }

◆ deleteTraceQuantities()

void deleteTraceQuantities ( )

delete trace arrays

Definition at line 262 of file OperatorBase.cpp.

References OperatorBase::deleteParticleQuantities(), OperatorBase::deleteScalarQuantities(), OperatorBase::have_required_traces_, OperatorBase::request_, TraceRequest::reset(), OperatorBase::streaming_particles_, and OperatorBase::streaming_scalars_.

 {
   deleteScalarQuantities();
   deleteParticleQuantities();
   streaming_scalars_    = false;
   streaming_particles_  = false;
   have_required_traces_ = false;
   request_.reset();
 }

◆ dependsOnWaveFunction()

virtual bool dependsOnWaveFunction ( ) const

inlinevirtual

return true if this operator depends on a wavefunction

Reimplemented in DensityMatrices1B, L2Potential, BareKineticEnergy, Pressure, NonLocalECPotential, ACForce, SOECPotential, and MomentumEstimator.

Definition at line 124 of file OperatorBase.h.

Referenced by OperatorBase::evaluateValueAndDerivatives().

124 { return false; }

◆ energyDomainValid()

bool energyDomainValid ( EnergyDomains edomain ) const

privatenoexcept

return whether the energy domain is valid

Definition at line 362 of file OperatorBase.cpp.

Referenced by OperatorBase::setEnergyDomain().

362 { return edomain != NO_ENERGY_DOMAIN; }

qmcplusplus::OperatorBase::NO_ENERGY_DOMAIN

Definition: OperatorBase.h:91

◆ evaluate()

virtual Return_t evaluate ( ParticleSet & P )

pure virtual

Evaluate the local energy contribution of this component.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Implemented in CoulombPotential< T >, OrbitalImages, DensityMatrices1B, CoulombPBCAB, CoulombPBCAA, MPC, L2Potential, LocalECPotential, ACForce, StressPBC, ForceChiesaPBCAA, BareKineticEnergy, NonLocalECPotential, HarmonicExternalPotential, Pressure, LatticeDeviationEstimator, SpinDensity, ForceCeperley, SelfHealingOverlapLegacy, ForwardWalking, StaticStructureFactor, GridExternalPotential, PairCorrEstimator, SOECPotential, SkAllEstimator, DensityEstimator, EnergyDensityEstimator, SkEstimator, SkPot, SpeciesKineticEnergy, BareForce, ChiesaCorrection, and MomentumEstimator.

Referenced by OperatorBase::evaluateDeterministic(), OperatorBase::evaluateValueAndDerivatives(), OperatorBase::evaluateWithIonDerivs(), OperatorBase::evaluateWithToperator(), OperatorBase::mw_evaluate(), and qmcplusplus::test_hcpBe_rotation().

◆ evaluateDeterministic()

OperatorBase::Return_t evaluateDeterministic ( ParticleSet & P )

virtual

Evaluate the local energy contribution of this component, deterministically based on current state.

The correct behavior of this routine requires estimators with non-deterministic components in their evaluate() function to override this function.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Reimplemented in NonLocalECPotential, and SOECPotential.

Definition at line 79 of file OperatorBase.cpp.

References OperatorBase::evaluate().

79 { return evaluate(P); }

qmcplusplus::OperatorBase::evaluate

virtual Return_t evaluate(ParticleSet &P)=0

Evaluate the local energy contribution of this component.

◆ evaluateOneBodyOpMatrix()

virtual void evaluateOneBodyOpMatrix	(	ParticleSet &	P,
		const TWFFastDerivWrapper &	psi,
		std::vector< ValueMatrix > &	B
	)

inlinevirtual

Evaluate "B" matrix for observable.

Filippi scheme for computing fast derivatives.

Parameters

[in]	P	target particle set (electrons)
[in]	psi,Trial	Wavefunction wrapper for fast derivatives.
[in,out]	B.	List of B matrices for each species.

Returns: Void

Reimplemented in BareKineticEnergy, and NonLocalECPotential.

Definition at line 387 of file OperatorBase.h.

Referenced by qmcplusplus::TEST_CASE().

390 {}

◆ evaluateOneBodyOpMatrixForceDeriv()

virtual void evaluateOneBodyOpMatrixForceDeriv	(	ParticleSet &	P,
		ParticleSet &	source,
		const TWFFastDerivWrapper &	psi,
		const int	iat,
		std::vector< std::vector< ValueMatrix >> &	Bforce
	)

inlinevirtual

Evaluate "dB/dR" matrices for observable.

Filippi scheme for computing fast derivatives.

Parameters

[in]	P,target	particle set (electrons)
[in]	source,ion	particle set
[in]	psi,Trial	Wavefunction wrapper for fast derivatives.
[in]	iat

Reimplemented in BareKineticEnergy, and NonLocalECPotential.

Definition at line 402 of file OperatorBase.h.

Referenced by qmcplusplus::TEST_CASE().

407 {}

◆ evaluateValueAndDerivatives()

OperatorBase::Return_t evaluateValueAndDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		const Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi
	)

virtual

Evaluate value and derivatives wrt the optimizables.

Default uses evaluate.

Parameters

P
optvars
dlogpsi
dhpsioverpsi

Returns: Return_t

Reimplemented in SOECPotential.

Definition at line 168 of file OperatorBase.cpp.

References OperatorBase::dependsOnWaveFunction(), OperatorBase::evaluate(), and OperatorBase::getClassName().

 {
   if (dependsOnWaveFunction())
     throw std::logic_error("Bug!! " + getClassName() +
                            "::evaluateValueAndDerivatives"
                            "must be overloaded when the OperatorBase depends on a wavefunction.");
 
   return evaluate(P);
 }

◆ evaluateWithIonDerivs()

OperatorBase::Return_t evaluateWithIonDerivs	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_term,
		ParticleSet::ParticlePos &	pulay_term
	)

virtual

Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase.

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Adds OperatorBase's contribution to Re [(dH)Psi]/Psi
pulay_terms	Adds OperatorBase's contribution to Re [(H-E_L)dPsi]/Psi

Returns: Contribution of OperatorBase to Local Energy.

Reimplemented in CoulombPotential< T >, CoulombPBCAB, BareKineticEnergy, CoulombPBCAA, NonLocalECPotential, and LocalECPotential.

Definition at line 181 of file OperatorBase.cpp.

References OperatorBase::evaluate().

Referenced by OperatorBase::evaluateWithIonDerivsDeterministic().

 {
   return evaluate(P);
 }

◆ evaluateWithIonDerivsDeterministic()

OperatorBase::Return_t evaluateWithIonDerivsDeterministic	(	ParticleSet &	P,
		ParticleSet &	ions,
		TrialWaveFunction &	psi,
		ParticleSet::ParticlePos &	hf_term,
		ParticleSet::ParticlePos &	pulay_term
	)

virtual

Evaluate contribution to local energy and derivatives w.r.t ionic coordinates from OperatorBase.

If there's no stochastic component, defaults to evaluateWithIonDerivs. If not otherwise specified, this defaults to evaluate().

Parameters

P	target particle set (electrons)
ions	source particle set (ions)
psi	Trial wave function
hf_terms	Adds OperatorBase's contribution to Re [(dH)Psi]/Psi
pulay_terms	Adds OperatorBase's contribution to Re [(H-E_L)dPsi]/Psi

Returns: Contribution of OperatorBase to Local Energy.

Reimplemented in NonLocalECPotential.

Definition at line 190 of file OperatorBase.cpp.

References OperatorBase::evaluateWithIonDerivs().

 {
   return evaluateWithIonDerivs(P, ions, psi, hf_term, pulay_term);
 }

◆ evaluateWithToperator()

OperatorBase::Return_t evaluateWithToperator ( ParticleSet & P )

virtual

Evaluate the local energy contribution of this component with Toperators updated if requested.

Parameters

P	input configuration containing N particles

Returns: the value of the Hamiltonian component

Reimplemented in NonLocalECPotential.

Definition at line 143 of file OperatorBase.cpp.

References OperatorBase::evaluate().

143 { return evaluate(P); }

qmcplusplus::OperatorBase::evaluate

virtual Return_t evaluate(ParticleSet &P)=0

Evaluate the local energy contribution of this component.

◆ get()

virtual bool get ( std::ostream & os ) const

pure virtual

◆ getClassName()

virtual std::string getClassName ( ) const

pure virtual

◆ getEnsembleAverage()

OperatorBase::Return_t getEnsembleAverage ( )

virtual

Return an average value by collective operation.

Definition at line 201 of file OperatorBase.cpp.

201 { return 0.0; }

◆ getMode()

bool getMode ( const int i ) const

noexcept

Return the mode i.

Parameters

i	index among PRIMARY, OPTIMIZABLE, RATIOUPDATE, PHYSICAL

Definition at line 240 of file OperatorBase.cpp.

240 { return update_mode_[i]; }

qmcplusplus::OperatorBase::update_mode_

std::bitset< 8 > update_mode_

set the current update mode

Definition: OperatorBase.h:521

◆ getName()

std::string getName ( ) const

noexcept

getter a copy of my_name_, rvalue small string optimization

Returns: std::string copy of my_name_ member

Definition at line 47 of file OperatorBase.cpp.

References OperatorBase::name_.

Referenced by QMCHamiltonian::initialize_traces(), and QMCHamiltonian::updateComponent().

47 { return name_; }

std::string name_

name of this object

Definition: OperatorBase.h:527

◆ getRequest()

TraceRequest & getRequest ( )

noexcept

Get request_ member.

Returns: TraceRequest& reference to request_

Definition at line 52 of file OperatorBase.cpp.

References OperatorBase::request_.

52 { return request_; }

qmcplusplus::OperatorBase::update_mode_

TraceRequest request_

whether traces are being collected

Definition: OperatorBase.h:531

◆ getRequiredTraces()

void getRequiredTraces ( TraceManager & tm )

virtual

TODO: add docs.

Parameters

tm

Reimplemented in DensityMatrices1B, and EnergyDensityEstimator.

Definition at line 225 of file OperatorBase.cpp.

225 {};

◆ getUpdateMode()

std::bitset< 8 > & getUpdateMode ( )

noexcept

get update_mode_ reference

Returns: std::bitset<8>& reference of get_update_mode_

Definition at line 43 of file OperatorBase.cpp.

References OperatorBase::update_mode_.

43 { return update_mode_; }

std::bitset< 8 > update_mode_

set the current update mode

Definition: OperatorBase.h:521

◆ getValue()

OperatorBase::Return_t getValue ( ) const

noexcept

get a copy of value_

Returns: Return_t copy of value_

Definition at line 45 of file OperatorBase.cpp.

References OperatorBase::value_.

Referenced by TestSOECPotential::evalFast(), qmcplusplus::TEST_CASE(), qmcplusplus::test_CoulombPBCAA_3p(), and QMCHamiltonian::updateComponent().

45 { return value_; }

qmcplusplus::OperatorBase::value_

Return_t value_

current value

Definition: OperatorBase.h:524

◆ hasListener()

bool hasListener ( ) const

noexcept

Definition at line 244 of file OperatorBase.cpp.

References OperatorBase::has_listener_.

244 { return has_listener_; }

qmcplusplus::OperatorBase::has_listener_

bool has_listener_

Is there a per particle listener sadly this is necessary due to state machines.

Definition: OperatorBase.h:612

◆ informOfPerParticleListener()

virtual void informOfPerParticleListener ( )

inlinevirtual

Reimplemented in CoulombPBCAB, and CoulombPBCAA.

Definition at line 471 of file OperatorBase.h.

References OperatorBase::has_listener_.

Referenced by CoulombPBCAA::informOfPerParticleListener(), and CoulombPBCAB::informOfPerParticleListener().

471 { has_listener_ = true; }

qmcplusplus::OperatorBase::has_listener_

bool has_listener_

Is there a per particle listener sadly this is necessary due to state machines.

Definition: OperatorBase.h:612

◆ isClassical()

bool isClassical ( ) const

noexcept

Definition at line 230 of file OperatorBase.cpp.

References OperatorBase::CLASSICAL, and OperatorBase::quantum_domain_.

qmcplusplus::OperatorBase::CLASSICAL

230 { return quantum_domain_ == CLASSICAL; }

Definition: OperatorBase.h:97

QuantumDomains quantum_domain_

quantum_domain_ of the (particle) operator, default = no_quantum_domain

Definition: OperatorBase.h:615

◆ isClassicalClassical()

bool isClassicalClassical ( ) const

noexcept

Definition at line 234 of file OperatorBase.cpp.

References OperatorBase::CLASSICAL_CLASSICAL, and OperatorBase::quantum_domain_.

qmcplusplus::OperatorBase::CLASSICAL_CLASSICAL

234 { return quantum_domain_ == CLASSICAL_CLASSICAL; }

Definition: OperatorBase.h:99

qmcplusplus::OperatorBase::NONLOCAL

QuantumDomains quantum_domain_

quantum_domain_ of the (particle) operator, default = no_quantum_domain

Definition: OperatorBase.h:615

◆ isNonLocal()

bool isNonLocal ( ) const

noexcept

TODO: add docs.

Returns: true; false

Definition at line 242 of file OperatorBase.cpp.

References OperatorBase::NONLOCAL, and OperatorBase::update_mode_.

242 { return update_mode_[NONLOCAL]; }

Definition: OperatorBase.h:112

qmcplusplus::OperatorBase::update_mode_

std::bitset< 8 > update_mode_

set the current update mode

Definition: OperatorBase.h:521

◆ isQuantum()

bool isQuantum ( ) const

noexcept

Definition at line 232 of file OperatorBase.cpp.

References OperatorBase::QUANTUM, and OperatorBase::quantum_domain_.

qmcplusplus::OperatorBase::QUANTUM

232 { return quantum_domain_ == QUANTUM; }

Definition: OperatorBase.h:98

QuantumDomains quantum_domain_

quantum_domain_ of the (particle) operator, default = no_quantum_domain

Definition: OperatorBase.h:615

◆ isQuantumClassical()

bool isQuantumClassical ( ) const

noexcept

Definition at line 236 of file OperatorBase.cpp.

References OperatorBase::QUANTUM_CLASSICAL, and OperatorBase::quantum_domain_.

qmcplusplus::OperatorBase::QUANTUM_CLASSICAL

236 { return quantum_domain_ == QUANTUM_CLASSICAL; }

Definition: OperatorBase.h:100

QuantumDomains quantum_domain_

quantum_domain_ of the (particle) operator, default = no_quantum_domain

Definition: OperatorBase.h:615

◆ isQuantumQuantum()

bool isQuantumQuantum ( ) const

noexcept

Definition at line 238 of file OperatorBase.cpp.

References OperatorBase::quantum_domain_, and OperatorBase::QUANTUM_QUANTUM.

qmcplusplus::OperatorBase::QUANTUM_QUANTUM

238 { return quantum_domain_ == QUANTUM_QUANTUM; }

Definition: OperatorBase.h:101

qmcplusplus::OperatorBase::NO_QUANTUM_DOMAIN

QuantumDomains quantum_domain_

quantum_domain_ of the (particle) operator, default = no_quantum_domain

Definition: OperatorBase.h:615

◆ makeClone()

virtual std::unique_ptr<OperatorBase> makeClone	(	ParticleSet &	qp,
		TrialWaveFunction &	psi
	)

pure virtual

◆ mw_evaluate()

void mw_evaluate	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list
	)		const

virtual

Evaluate the contribution of this component of multiple walkers.

Take o_list and p_list update evaluation result variables in o_list? really should reduce vector of local_energies. matching the ordering and size of o list the this can be call for 1 or more QMCHamiltonians

Parameters

o_list
wf_list
p_list

Temporary raw omp pragma for simple thread parallelism ignoring the driver level concurrency

TODO: replace this with a proper abstraction. It should adequately describe the behavior and strictly limit the activation of this level concurrency to when it is intended. It is unlikely to belong in this function.

This implicitly depends on openmp work division logic. Essentially adhoc runtime crowds over which we have given up control of thread/global scope. How many walkers per thread? How to handle their data movement if any of these hamiltonians should be accelerated? We can neither reason about or describe it in C++

As I understand it it should only be required for as long as the AMD openmp offload compliler is incapable of running multiple threads. They should/must fix their compiler before delivery of frontier and it should be removed at that point at latest

If you want 16 threads of 1 walker that should be 16 crowds of 1 not one crowd of 16 with openmp thrown in at hamiltonian level. If this must be different from the other crowd batching. Make this a reasoned about and controlled level of concurency blocking at the driver level.

This is only thread safe only if each walker has a complete set of anything involved in an Operator.evaluate.

Reimplemented in CoulombPBCAA, NonLocalECPotential, and SOECPotential.

Definition at line 81 of file OperatorBase.cpp.

References OperatorBase::evaluate(), and RefVectorWithLeader< T >::getLeader().

Referenced by CoulombPBCAA::mw_evaluate(), OperatorBase::mw_evaluatePerParticle(), BareKineticEnergy::mw_evaluateWithParameterDerivatives(), and OperatorBase::mw_evaluateWithToperator().

 {
   assert(this == &o_list.getLeader());
 /**  Temporary raw omp pragma for simple thread parallelism
    *   ignoring the driver level concurrency
    *   
    *  TODO: replace this with a proper abstraction. It should adequately describe the behavior
    *  and strictly limit the activation of this level concurrency to when it is intended.
    *  It is unlikely to belong in this function.
    *  
    *  This implicitly depends on openmp work division logic. Essentially adhoc runtime
    *  crowds over which we have given up control of thread/global scope.
    *  How many walkers per thread? How to handle their data movement if any of these
    *  hamiltonians should be accelerated? We can neither reason about or describe it in C++
    *
    *  As I understand it it should only be required for as long as the AMD openmp offload 
    *  compliler is incapable of running multiple threads. They should/must fix their compiler
    *  before delivery of frontier and it should be removed at that point at latest
    *
    *  If you want 16 threads of 1 walker that should be 16 crowds of 1
    *  not one crowd of 16 with openmp thrown in at hamiltonian level.
    *  If this must be different from the other crowd batching. Make this a reasoned about
    *  and controlled level of concurency blocking at the driver level.
    *
    *  This is only thread safe only if each walker has a complete
    *  set of anything involved in an Operator.evaluate.
    */
 #pragma omp parallel for
   for (int iw = 0; iw < o_list.size(); iw++)
     o_list[iw].evaluate(p_list[iw]);
 }

◆ mw_evaluatePerParticle()

void mw_evaluatePerParticle	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< ListenerVector< RealType >> &	listeners,
		const std::vector< ListenerVector< RealType >> &	listeners_ions
	)		const

virtual

Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators.

Base class implementation decays to the mw_evaluate so if not overridden the estimator doesn't hear from this operator.

specialized versions of this should take advantage of multiwalker resources to reduce the resource cost of collecting these values.

Reimplemented in CoulombPBCAB, and CoulombPBCAA.

Definition at line 115 of file OperatorBase.cpp.

References OperatorBase::mw_evaluate().

 {
   mw_evaluate(o_list, wf_list, p_list);
 }

◆ mw_evaluatePerParticleWithToperator()

void mw_evaluatePerParticleWithToperator	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< ListenerVector< RealType >> &	listeners,
		const std::vector< ListenerVector< RealType >> &	listeners_ions
	)		const

virtual

Evaluate the contribution of this component of multiple walkers per particle and report to registerd listeners from objects in Estimators.

default implementation decays to the mw_evaluatePerParticle.

specialized versions of this should take advantage of multiwalker resources to reduce the resource cost of collecting these values.

Definition at line 155 of file OperatorBase.cpp.

References OperatorBase::mw_evaluateWithToperator().

 {
   // This may or may not be what is expected.
   // It the responsibility of the derived type to override this if the
   // desired behavior is instead to call mw_evaluatePerParticle
   mw_evaluateWithToperator(o_list, wf_list, p_list);
 }

◆ mw_evaluateWithParameterDerivatives()

void mw_evaluateWithParameterDerivatives	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const opt_variables_type &	optvars,
		const RecordArray< ValueType > &	dlogpsi,
		RecordArray< ValueType > &	dhpsioverpsi
	)		const

virtual

TODO: add docs.

Parameters

o_list
p_list
optvars
dlogpsi
dhpsioverpsi

Definition at line 125 of file OperatorBase.cpp.

References RecordArray< T >::getNumOfParams().

 {
   const int nparam = dlogpsi.getNumOfParams();
   for (int iw = 0; iw < o_list.size(); iw++)
   {
     const Vector<ValueType> dlogpsi_record_view(const_cast<ValueType*>(dlogpsi[iw]), nparam);
     Vector<ValueType> dhpsioverpsi_record_view(dhpsioverpsi[iw], nparam);
 
     o_list[iw].evaluateValueAndDerivatives(p_list[iw], optvars, dlogpsi_record_view, dhpsioverpsi_record_view);
   }
 }

◆ mw_evaluateWithToperator()

void mw_evaluateWithToperator	(	const RefVectorWithLeader< OperatorBase > &	o_list,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list
	)		const

virtual

Evaluate the contribution of this component of multiple walkers.

Parameters

o_list
wf_list
p_list

Reimplemented in NonLocalECPotential.

Definition at line 145 of file OperatorBase.cpp.

References OperatorBase::mw_evaluate().

Referenced by OperatorBase::mw_evaluatePerParticleWithToperator().

 {
   // Only in NLPP evaluateWithToperator doesn't decay to evaluate. All other derived classes don't
   // provide evaluateWithToperator specialization but may provide mw_evaluate optimization.
   // Thus decaying to mw_evaluate is better than decalying to a loop over evaluateWithToperator
   mw_evaluate(o_list, wf_list, p_list);
 }

◆ oneBodyQuantumDomain()

void oneBodyQuantumDomain ( const ParticleSet & P )

protected

set quantum domain for one-body operator

Definition at line 319 of file OperatorBase.cpp.

References APP_ABORT, OperatorBase::CLASSICAL, ParticleSet::is_classical(), ParticleSet::is_quantum(), OperatorBase::QUANTUM, and OperatorBase::quantum_domain_.

Referenced by BareKineticEnergy::BareKineticEnergy(), GridExternalPotential::GridExternalPotential(), and HarmonicExternalPotential::HarmonicExternalPotential().

 {
   if (P.is_classical())
     quantum_domain_ = CLASSICAL;
   else if (P.is_quantum())
     quantum_domain_ = QUANTUM;
   else
     APP_ABORT("OperatorBase::oneBodyQuantumDomain\n  quantum domain of input particles is invalid");
 }

◆ put()

virtual bool put ( xmlNodePtr cur )

protectedpure virtual

Read the input parameter.

Parameters

cur	xml node for a OperatorBase object

Implemented in CoulombPotential< T >, OrbitalImages, CoulombPBCAB, DensityMatrices1B, BareKineticEnergy, NonLocalECPotential, CoulombPBCAA, ForceChiesaPBCAA, StressPBC, LocalECPotential, MPC, L2Potential, ForceCeperley, Pressure, SOECPotential, PairCorrEstimator, HarmonicExternalPotential, SpinDensity, BareForce, ForwardWalking, LatticeDeviationEstimator, SkAllEstimator, SelfHealingOverlapLegacy, DensityEstimator, SkEstimator, EnergyDensityEstimator, StaticStructureFactor, ACForce, GridExternalPotential, SkPot, MomentumEstimator, ChiesaCorrection, and SpeciesKineticEnergy.

◆ quantumDomainValid()

bool quantumDomainValid ( QuantumDomains qdomain ) const

privatenoexcept

return whether the quantum domain is valid

Definition at line 364 of file OperatorBase.cpp.

Referenced by OperatorBase::setQuantumDomain().

364 { return qdomain != NO_QUANTUM_DOMAIN; }

Definition: OperatorBase.h:96

◆ registerCollectables()

void registerCollectables	(	std::vector< ObservableHelper > &	h5desc,
		hdf_archive &	file
	)		const

virtual

Reimplemented in OrbitalImages, DensityMatrices1B, LatticeDeviationEstimator, SpinDensity, PairCorrEstimator, SelfHealingOverlapLegacy, SpeciesKineticEnergy, StaticStructureFactor, SkAllEstimator, DensityEstimator, SkEstimator, EnergyDensityEstimator, and MomentumEstimator.

Definition at line 71 of file OperatorBase.cpp.

71 {}

◆ registerObservables()

void registerObservables	(	std::vector< ObservableHelper > &	h5desc,
		hdf_archive &	file
	)		const

virtual

add to observable descriptor for hdf5 The default implementation is to register a scalar for this->value_

Parameters

h5desc	contains a set of hdf5 descriptors for a scalar observable
gid	hdf5 group to which the observables belong

Reimplemented in NonLocalECPotential, StressPBC, ForceChiesaPBCAA, ForceCeperley, and BareForce.

Definition at line 58 of file OperatorBase.cpp.

References OperatorBase::COLLECTABLE, OperatorBase::my_index_, OperatorBase::name_, qmcplusplus::oh, ObservableHelper::set_dimensions(), and OperatorBase::update_mode_.

Referenced by NonLocalECPotential::registerObservables().

 {
   const bool collect = update_mode_.test(COLLECTABLE);
   //exclude collectables
   if (!collect)
   {
     h5desc.emplace_back(hdf_path{name_});
     auto& oh = h5desc.back();
     std::vector<int> onedim(1, 1);
     oh.set_dimensions(onedim, my_index_);
   }
 }

◆ rejectedMove()

OperatorBase::Return_t rejectedMove ( ParticleSet & P )

virtual

TODO: add docs.

Parameters

P

Returns: Return_t

Reimplemented in ForwardWalking.

Definition at line 141 of file OperatorBase.cpp.

141 { return 0; }

◆ releaseResource()

void releaseResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< OperatorBase > &	o_list
	)		const

virtual

Return a shared resource to a collection.

Parameters

collection
o_list

Reimplemented in CoulombPBCAB, CoulombPBCAA, BareKineticEnergy, NonLocalECPotential, and SOECPotential.

Definition at line 209 of file OperatorBase.cpp.

211 {}

◆ resetTargetParticleSet()

virtual void resetTargetParticleSet ( ParticleSet & P )

pure virtual

Reset the data with the target ParticleSet.

Parameters

P	new target ParticleSet

Implemented in CoulombPotential< T >, OrbitalImages, DensityMatrices1B, CoulombPBCAB, ForceChiesaPBCAA, CoulombPBCAA, StressPBC, MPC, L2Potential, LocalECPotential, LatticeDeviationEstimator, ForceCeperley, BareKineticEnergy, SpinDensity, ACForce, Pressure, SelfHealingOverlapLegacy, NonLocalECPotential, StaticStructureFactor, HarmonicExternalPotential, PairCorrEstimator, SOECPotential, ForwardWalking, SpeciesKineticEnergy, EnergyDensityEstimator, SkAllEstimator, DensityEstimator, GridExternalPotential, SkEstimator, SkPot, BareForce, ChiesaCorrection, and MomentumEstimator.

◆ setComputeForces()

void setComputeForces ( bool compute )

protectedvirtual

Reimplemented in NonLocalECPotential.

Definition at line 301 of file OperatorBase.cpp.

301 {}

◆ setEnergyDomain()

void setEnergyDomain ( EnergyDomains edomain )

protected

Set the Energy Domain.

Parameters

edomain

Definition at line 303 of file OperatorBase.cpp.

References APP_ABORT, OperatorBase::energy_domain_, and OperatorBase::energyDomainValid().

Referenced by BareKineticEnergy::BareKineticEnergy(), CoulombPBCAA::CoulombPBCAA(), CoulombPBCAB::CoulombPBCAB(), CoulombPotential< T >::CoulombPotential(), GridExternalPotential::GridExternalPotential(), HarmonicExternalPotential::HarmonicExternalPotential(), L2Potential::L2Potential(), LocalECPotential::LocalECPotential(), NonLocalECPotential::NonLocalECPotential(), and SOECPotential::SOECPotential().

 {
   if (energyDomainValid(edomain))
     energy_domain_ = edomain;
   else
     APP_ABORT("QMCHamiltonainBase::setEnergyDomain\n  input energy domain is invalid");
 }

◆ setHistories()

void setHistories ( Walker_t & ThisWalker )

virtual

Definition at line 77 of file OperatorBase.cpp.

References OperatorBase::t_walker_.

Referenced by qmcplusplus::TEST_CASE().

77 { t_walker_ = &(ThisWalker); }

qmcplusplus::OperatorBase::t_walker_

Walker_t * t_walker_

reference to the current walker

Definition: OperatorBase.h:541

◆ setName()

void setName ( const std::string name )

noexcept

Set my_name member, uses small string optimization (pass by value)

Parameters

name input

Definition at line 49 of file OperatorBase.cpp.

Referenced by ACForce::ACForce().

49 { name_ = name; }