NonLocalECPComponent Class Reference

Contains a set of radial grid potentials around a center. More...

Inheritance diagram for NonLocalECPComponent:

Collaboration diagram for NonLocalECPComponent:

Public Member Functions
	NonLocalECPComponent ()
	NonLocalECPComponent (const NonLocalECPComponent &nl_ecpc, const ParticleSet &pset)
	Make a copy but have it associated with pset instead of nl_ecpc's pset. More...
	~NonLocalECPComponent ()
void	add (int l, RadialPotentialType *pp)
	add a new Non Local component More...
void	addknot (const PosType &xyz, RealType weight)
	add knots to the spherical grid More...
void	set_randomize_grid (bool do_randomize_grid_)
void	resize_warrays (int n, int m, int l)
void	rotateQuadratureGrid (const TensorType &rmat)
	Randomly rotate sgrid_m. More...
template<typename T >
void	rotateQuadratureGrid (std::vector< T > &sphere, const TensorType &rmat)
void	contributeTxy (int iel, std::vector< NonLocalData > &Txy) const
	contribute local non-local move data More...
RealType	evaluateOne (ParticleSet &W, int iat, TrialWaveFunction &Psi, int iel, RealType r, const PosType &dr, bool use_DLA)
	Evaluate the nonlocal pp contribution via randomized quadrature grid to total energy from ion "iat" and electron "iel". More...
RealType	evaluateOneWithForces (ParticleSet &W, int iat, TrialWaveFunction &Psi, int iel, RealType r, const PosType &dr, PosType &force_iat)
	Evaluate the nonlocal pp contribution via randomized quadrature grid to total energy from ion "iat" and electron "iel". More...
RealType	evaluateOneWithForces (ParticleSet &W, ParticleSet &ions, int iat, TrialWaveFunction &Psi, int iel, RealType r, const PosType &dr, PosType &force_iat, ParticleSet::ParticlePos &pulay_terms)
	Evaluate the nonlocal pp energy, Hellman-Feynman force, and "Pulay" force contribution via randomized quadrature grid from ion "iat" and electron "iel". More...
RealType	evaluateValueAndDerivatives (ParticleSet &P, int iat, TrialWaveFunction &psi, int iel, RealType r, const PosType &dr, const opt_variables_type &optvars, const Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	evaluate the non-local potential of the iat-th ionic center More...
void	evaluateOneBodyOpMatrixContribution (ParticleSet &P, const int iat, const TWFFastDerivWrapper &psi, const int iel, const RealType r, const PosType &dr, std::vector< ValueMatrix > &B)
	Evaluate contribution to B of election iel and ion iat. More...
void	evaluateOneBodyOpMatrixdRContribution (ParticleSet &P, ParticleSet &source, const int iat, const int iat_src, const TWFFastDerivWrapper &psi, const int iel, const RealType r, const PosType &dr, std::vector< std::vector< ValueMatrix >> &dB)
	Evaluate contribution to dB/dR of election iel and ion iat. More...
void	print (std::ostream &os)
void	initVirtualParticle (const ParticleSet &qp)
void	deleteVirtualParticle ()
void	setRmax (int rmax)
RealType	getRmax () const
int	getNknot () const
void	setLmax (int Lmax)
int	getLmax () const
const VirtualParticleSet *	getVP () const

Static Public Member Functions
static void	mw_evaluateOne (const RefVectorWithLeader< NonLocalECPComponent > &ecp_component_list, const RefVectorWithLeader< ParticleSet > &p_list, const RefVectorWithLeader< TrialWaveFunction > &psi_list, const RefVector< const NLPPJob< RealType >> &joblist, std::vector< RealType > &pairpots, ResourceCollection &collection, bool use_DLA)
	Evaluate the nonlocal pp contribution via randomized quadrature grid to total energy from ion "iat" and electron "iel" for a batch of walkers. More...

Private Types
using	SpherGridType = std::vector< PosType >
using	GridType = OneDimGridBase< RealType >
using	RadialPotentialType = OneDimCubicSpline< RealType >
using	ValueMatrix = SPOSet::ValueMatrix
	For fast derivative evaluation. More...
using	GradMatrix = SPOSet::GradMatrix

Private Member Functions
void	buildQuadraturePointDeltaPositions (RealType r, const PosType &dr, std::vector< PosType > &deltaV) const
	build QP position deltas from the reference electron using internally stored random grid points More...
RealType	calculateProjector (RealType r, const PosType &dr)
	finalize the calculation of ${V}{}$ More...

Private Attributes
int	lmax
	Non Local part: angular momentum, potential and grid. More...
int	nchannel
	the number of non-local channels More...
int	nknot
	the number of nknot More...
RealType	Rmax
	Maximum cutoff the non-local pseudopotential. More...
aligned_vector< int >	angpp_m
	Angular momentum map. More...
aligned_vector< RealType >	wgt_angpp_m
	Weight of the angular momentum. More...
RealType	Lfactor1 [8]
	Lfactor1[l]=(2*l+1)/(l+1) More...
RealType	Lfactor2 [8]
	Lfactor1[l]=(l)/(l+1) More...
std::vector< RadialPotentialType * >	nlpp_m
	Non-Local part of the pseudo-potential. More...
SpherGridType	sgridxyz_m
	fixed Spherical Grid for species More...
SpherGridType	rrotsgrid_m
	randomized spherical grid More...
std::vector< RealType >	sgridweight_m
	weight of the spherical grid More...
std::vector< ValueType >	wvec
	Working arrays. More...
std::vector< PosType >	deltaV
std::vector< RealType >	lpol
std::vector< RealType >	dlpol
std::vector< RealType >	vrad
std::vector< RealType >	dvrad
std::vector< ValueType >	psiratio
std::vector< PosType >	gradpsiratio
std::vector< PosType >	vgrad
std::vector< PosType >	cosgrad
std::vector< PosType >	wfngrad
std::vector< RealType >	knot_pots
Matrix< ValueType >	dratio
	scratch spaces used by evaluateValueAndDerivatives More...
Vector< ValueType >	dlogpsi_vp
std::vector< RealType >	WarpNorm
ParticleSet::ParticleGradient	dG
ParticleSet::ParticleLaplacian	dL
Matrix< PosType >	Gnew
	First index is knot, second is electron. More...
ParticleSet::ParticleGradient	Gion
	The gradient of the wave function w.r.t. the ion position. More...
VirtualParticleSet *	VP
	virtual particle set: delayed initialization More...
bool	do_randomize_grid_
	Can disable grid randomization for testing. More...

Friends
struct	ECPComponentBuilder
class	NonLocalECPotential_CUDA
class	testing::TestNonLocalECPotential
void	copyGridUnrotatedForTest (NonLocalECPComponent &nlpp)

Additional Inherited Members
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 > >

Detailed Description

Contains a set of radial grid potentials around a center.

Definition at line 38 of file NonLocalECPComponent.h.

Member Typedef Documentation

GradMatrix

using GradMatrix = SPOSet::GradMatrix

private

Definition at line 48 of file NonLocalECPComponent.h.

GridType

using GridType = OneDimGridBase<RealType>

private

Definition at line 42 of file NonLocalECPComponent.h.

RadialPotentialType

using RadialPotentialType = OneDimCubicSpline<RealType>

private

Definition at line 43 of file NonLocalECPComponent.h.

SpherGridType

using SpherGridType = std::vector<PosType>

private

Definition at line 41 of file NonLocalECPComponent.h.

ValueMatrix

using ValueMatrix = SPOSet::ValueMatrix

private

For fast derivative evaluation.

Definition at line 47 of file NonLocalECPComponent.h.

Constructor & Destructor Documentation

NonLocalECPComponent() [1/2]

NonLocalECPComponent

(

)

Definition at line 25 of file NonLocalECPComponent.cpp.

: lmax(0), nchannel(0), nknot(0), Rmax(-1), VP(nullptr), do_randomize_grid_(true) {}

NonLocalECPComponent() [2/2]

NonLocalECPComponent	(	const NonLocalECPComponent &	nl_ecpc,
		const ParticleSet &	pset
	)

Make a copy but have it associated with pset instead of nl_ecpc's pset.

Definition at line 29 of file NonLocalECPComponent.cpp.

References ParticleSet::getNumDistTables(), NonLocalECPComponent::nknot, NonLocalECPComponent::nlpp_m, qmcplusplus::pset, and NonLocalECPComponent::VP.

    : NonLocalECPComponent(nl_ecpc)
{
  for (int i = 0; i < nl_ecpc.nlpp_m.size(); ++i)
    nlpp_m[i] = nl_ecpc.nlpp_m[i]->makeClone();
  if (nl_ecpc.VP)
    VP = new VirtualParticleSet(pset, nknot, nl_ecpc.VP->getNumDistTables());
}

~NonLocalECPComponent()

~NonLocalECPComponent

(

)

Definition at line 38 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::nlpp_m, and NonLocalECPComponent::VP.

{
  for (int ip = 0; ip < nlpp_m.size(); ip++)
    delete nlpp_m[ip];
  if (VP)
    delete VP;
}

Member Function Documentation

add()

void add	(	int	l,
		RadialPotentialType *	pp
	)

add a new Non Local component

Definition at line 66 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::angpp_m, NonLocalECPComponent::nlpp_m, and NonLocalECPComponent::wgt_angpp_m.

{
  angpp_m.push_back(l);
  wgt_angpp_m.push_back(static_cast<RealType>(2 * l + 1));
  nlpp_m.push_back(pp);
}

addknot()

void addknot ( const PosType &  xyz, RealType  weight  )

inline

add knots to the spherical grid

Definition at line 139 of file NonLocalECPComponent.h.

References NonLocalECPComponent::sgridweight_m, and NonLocalECPComponent::sgridxyz_m.

  {
    sgridxyz_m.push_back(xyz);
    sgridweight_m.push_back(weight);
  }

buildQuadraturePointDeltaPositions()

void buildQuadraturePointDeltaPositions ( RealType  r, const PosType &  dr, std::vector< PosType > &  deltaV  ) const

private

build QP position deltas from the reference electron using internally stored random grid points

Definition at line 905 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::deltaV, NonLocalECPComponent::nknot, and NonLocalECPComponent::rrotsgrid_m.

Referenced by NonLocalECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), and NonLocalECPComponent::mw_evaluateOne().

{
  for (int j = 0; j < nknot; j++)
    deltaV[j] = r * rrotsgrid_m[j] - dr;
}

calculateProjector()

NonLocalECPComponent::RealType calculateProjector ( RealType  r, const PosType &  dr  )

private

finalize the calculation of ${V}{}$

Definition at line 167 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::angpp_m, BLAS::cone, BLAS::czero, qmcplusplus::dot(), NonLocalECPComponent::knot_pots, NonLocalECPComponent::Lfactor1, NonLocalECPComponent::Lfactor2, NonLocalECPComponent::lmax, NonLocalECPComponent::lpol, NonLocalECPComponent::nchannel, NonLocalECPComponent::nknot, NonLocalECPComponent::nlpp_m, NonLocalECPComponent::psiratio, NonLocalECPComponent::rrotsgrid_m, NonLocalECPComponent::sgridweight_m, NonLocalECPComponent::vrad, and NonLocalECPComponent::wgt_angpp_m.

Referenced by NonLocalECPComponent::evaluateOne(), and NonLocalECPComponent::mw_evaluateOne().

{
  for (int j = 0; j < nknot; j++)
    psiratio[j] *= sgridweight_m[j];

  // Compute radial potential, multiplied by (2l+1) factor.
  for (int ip = 0; ip < nchannel; ip++)
    vrad[ip] = nlpp_m[ip]->splint(r) * wgt_angpp_m[ip];

  constexpr RealType czero(0);
  constexpr RealType cone(1);

  const RealType rinv = cone / r;
  RealType pairpot    = czero;
  // Compute spherical harmonics on grid
  for (int j = 0; j < nknot; j++)
  {
    RealType zz = dot(dr, rrotsgrid_m[j]) * rinv;
    // Forming the Legendre polynomials
    lpol[0]           = cone;
    RealType lpolprev = czero;
    for (int l = 0; l < lmax; l++)
    {
      lpol[l + 1] = (Lfactor1[l] * zz * lpol[l] - l * lpolprev) * Lfactor2[l];
      lpolprev    = lpol[l];
    }

    RealType lsum = 0.0;
    for (int l = 0; l < nchannel; l++)
      lsum += vrad[l] * lpol[angpp_m[l]];
    knot_pots[j] = lsum * std::real(psiratio[j]);
    pairpot += knot_pots[j];
  }

  return pairpot;
}

contributeTxy()

void contributeTxy	(	int	iel,
		std::vector< NonLocalData > &	Txy
	)		const

contribute local non-local move data

Parameters

iel	reference electron id.
Txy	nonlocal move data.

Definition at line 913 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::deltaV, NonLocalECPComponent::knot_pots, and NonLocalECPComponent::nknot.

{
  for (int j = 0; j < nknot; j++)
    Txy.push_back(NonLocalData(iel, knot_pots[j], deltaV[j]));
}

deleteVirtualParticle()

void deleteVirtualParticle

(

)

Definition at line 59 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::VP.

Referenced by qmcplusplus::TEST_CASE().

{
  if (VP)
    delete VP;
  VP = nullptr;
}

evaluateOne()

NonLocalECPComponent::RealType evaluateOne	(	ParticleSet &	W,
		int	iat,
		TrialWaveFunction &	Psi,
		int	iel,
		RealType	r,
		const PosType &	dr,
		bool	use_DLA
	)

Evaluate the nonlocal pp contribution via randomized quadrature grid to total energy from ion "iat" and electron "iel".

Parameters

W	electron particle set.
iat	index of ion.
Psi	trial wave function object
iel	index of electron
r	the distance between ion iat and electron iel.
dr	displacement from ion iat to electron iel.
use_DLA	if ture, use determinant localization approximation (DLA).

Returns

RealType Contribution to ${V}{}$ from ion iat and electron iel.

Definition at line 130 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::buildQuadraturePointDeltaPositions(), TrialWaveFunction::calcRatio(), NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::deltaV, TrialWaveFunction::evaluateRatios(), TrialWaveFunction::FERMIONIC, ParticleSet::makeMove(), VirtualParticleSet::makeMoves(), NonLocalECPComponent::nknot, NonLocalECPComponent::psiratio, ParticleSet::rejectMove(), TrialWaveFunction::resetPhaseDiff(), and NonLocalECPComponent::VP.

Referenced by qmcplusplus::TEST_CASE().

{
  buildQuadraturePointDeltaPositions(r, dr, deltaV);

  if (VP)
  {
    // Compute ratios with VP
    VP->makeMoves(W, iel, deltaV, true, iat);
    if (use_DLA)
      psi.evaluateRatios(*VP, psiratio, TrialWaveFunction::ComputeType::FERMIONIC);
    else
      psi.evaluateRatios(*VP, psiratio);
  }
  else
  {
    // Compute ratio of wave functions
    for (int j = 0; j < nknot; j++)
    {
      W.makeMove(iel, deltaV[j], false);
      if (use_DLA)
        psiratio[j] = psi.calcRatio(W, iel, TrialWaveFunction::ComputeType::FERMIONIC);
      else
        psiratio[j] = psi.calcRatio(W, iel);
      W.rejectMove(iel);
      psi.resetPhaseDiff();
    }
  }

  return calculateProjector(r, dr);
}

evaluateOneBodyOpMatrixContribution()

void evaluateOneBodyOpMatrixContribution	(	ParticleSet &	P,
		const int	iat,
		const TWFFastDerivWrapper &	psi,
		const int	iel,
		const RealType	r,
		const PosType &	dr,
		std::vector< ValueMatrix > &	B
	)

Evaluate contribution to B of election iel and ion iat.

Filippi scheme for computing fast derivatives. Sum over ions and electrons occurs at the NonLocalECPotential level.

Parameters

[in]	P,target	particle set (electrons)
[in]	iat,ion	ID
[in]	psi,Trial	Wavefunction wrapper for fast derivatives.
[in]	iel,electron	ID
[in]	r,distance	between iat and iel.
[in]	dr,displacement	vector between iat and iel.
[in,out]	B.	Adds the contribution of iel and iat to the B matrix. Dimensions: [group][particle][orb]

Returns

Void

Definition at line 604 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::angpp_m, B(), NonLocalECPComponent::buildQuadraturePointDeltaPositions(), BLAS::cone, BLAS::czero, NonLocalECPComponent::deltaV, qmcplusplus::dot(), TWFFastDerivWrapper::evaluateJastrowRatio(), ParticleSet::first(), ParticleSet::getGroupID(), TWFFastDerivWrapper::getRowM(), TWFFastDerivWrapper::getTWFGroupIndex(), NonLocalECPComponent::Lfactor1, NonLocalECPComponent::Lfactor2, NonLocalECPComponent::lmax, NonLocalECPComponent::lpol, ParticleSet::makeMove(), NonLocalECPComponent::nchannel, NonLocalECPComponent::nknot, NonLocalECPComponent::nlpp_m, TWFFastDerivWrapper::numOrbitals(), ParticleSet::rejectMove(), NonLocalECPComponent::rrotsgrid_m, NonLocalECPComponent::sgridweight_m, NonLocalECPComponent::vrad, and NonLocalECPComponent::wgt_angpp_m.

{
  using ValueVector = SPOSet::ValueVector;
  //Some initial computation to find out the species and row number of electron.
  const IndexType gid        = W.getGroupID(iel);
  const IndexType sid        = psi.getTWFGroupIndex(gid);
  const IndexType firstIndex = W.first(gid);
  const IndexType thisIndex  = iel - firstIndex;

  const IndexType numOrbs = psi.numOrbitals(sid);
  ValueVector phi_row; //phi_0(r), phi_1(r), ...
  ValueVector temp_row;

  phi_row.resize(numOrbs);
  temp_row.resize(numOrbs);

  buildQuadraturePointDeltaPositions(r, dr, deltaV);


  constexpr RealType czero(0);
  constexpr RealType cone(1);

  const RealType rinv = cone / r;

  for (int ip = 0; ip < nchannel; ip++)
    vrad[ip] = nlpp_m[ip]->splint(r) * wgt_angpp_m[ip];

  for (int j = 0; j < nknot; j++)
  {
    W.makeMove(iel, deltaV[j], false); //Update distance tables.
    psi.getRowM(W, iel, phi_row);
    RealType jratio = psi.evaluateJastrowRatio(W, iel);
    W.rejectMove(iel);

    RealType zz = dot(dr, rrotsgrid_m[j]) * rinv;
    // Forming the Legendre polynomials
    lpol[0]           = cone;
    RealType lpolprev = czero;
    for (int l = 0; l < lmax; l++)
    {
      lpol[l + 1] = Lfactor2[l] * (Lfactor1[l] * zz * lpol[l] - l * lpolprev);
      lpolprev    = lpol[l];
    }

    ValueType lsum = 0.0;
    for (int l = 0; l < nchannel; l++)
    {
      temp_row = (vrad[l] * lpol[angpp_m[l]] * sgridweight_m[j]) * jratio * phi_row;
      for (int iorb = 0; iorb < numOrbs; iorb++)
        B[sid][thisIndex][iorb] += temp_row[iorb];
    }
  }
}

evaluateOneBodyOpMatrixdRContribution()

void evaluateOneBodyOpMatrixdRContribution	(	ParticleSet &	P,
		ParticleSet &	source,
		const int	iat,
		const int	iat_src,
		const TWFFastDerivWrapper &	psi,
		const int	iel,
		const RealType	r,
		const PosType &	dr,
		std::vector< std::vector< ValueMatrix >> &	dB
	)

Evaluate contribution to dB/dR of election iel and ion iat.

Filippi scheme for computing fast derivatives. Sum over ions and electrons occurs at the NonLocalECPotential level.

Parameters

[in]	P,target	particle set (electrons)
[in]	source,ion	particle set
[in]	iat,ion	ID
[in]	iat_src,this	is the ion ID w.r.t. which the ion derivatives are taken. NOT ALWAYS EQUAL TO IAT
[in]	psi,Trial	Wavefunction wrapper for fast derivatives.
[in]	iel,electron	ID
[in]	r,distance	between iat and iel.
[in]	dr,displacement	vector between iat and iel.
[in,out]	dB.	Adds the contribution of iel and iat to the dB/dR_iat_src matrix. Dimension [xyz_component][group][particle][orb]

Returns

Void

Definition at line 665 of file NonLocalECPComponent.cpp.

References qmcplusplus::abs(), ParticleSet::acceptMove(), NonLocalECPComponent::angpp_m, NonLocalECPComponent::buildQuadraturePointDeltaPositions(), TWFFastDerivWrapper::calcJastrowRatioGrad(), BLAS::cone, NonLocalECPComponent::cosgrad, BLAS::czero, NonLocalECPComponent::deltaV, NonLocalECPComponent::dlpol, qmcplusplus::dot(), NonLocalECPComponent::dvrad, TWFFastDerivWrapper::evaluateJastrowGradSource(), ParticleSet::first(), ParticleSet::getGroupID(), TWFFastDerivWrapper::getSPOSet(), TWFFastDerivWrapper::getTWFGroupIndex(), ParticleSet::last(), NonLocalECPComponent::Lfactor1, NonLocalECPComponent::Lfactor2, NonLocalECPComponent::lmax, NonLocalECPComponent::lpol, ParticleSet::makeMove(), NonLocalECPComponent::nchannel, NonLocalECPComponent::nknot, NonLocalECPComponent::nlpp_m, TWFFastDerivWrapper::numOrbitals(), OHMMS_DIM, ParticleSet::rejectMove(), NonLocalECPComponent::rrotsgrid_m, NonLocalECPComponent::sgridweight_m, qmcplusplus::sqrt(), NonLocalECPComponent::vgrad, NonLocalECPComponent::vrad, and NonLocalECPComponent::wgt_angpp_m.

{
  using ValueVector = SPOSet::ValueVector;
  using GradVector  = SPOSet::GradVector;
  constexpr RealType czero(0);
  constexpr RealType cone(1);

  //We check that our quadrature grid is valid.  Namely, that all points lie on the unit sphere.
  //We check this by seeing if |r|^2 = 1 to machine precision.
  for (int j = 0; j < nknot; j++)
    assert(std::abs(std::sqrt(dot(rrotsgrid_m[j], rrotsgrid_m[j])) - 1) <
           100 * std::numeric_limits<RealType>::epsilon());

  for (int j = 0; j < nknot; j++)
    deltaV[j] = r * rrotsgrid_m[j] - dr;

  // This is just a temporary variable to dump d2/dr2 into for spline evaluation.
  RealType secondderiv(0);

  const RealType rinv = cone / r;

  // Compute radial potential and its derivative times (2l+1)
  for (int ip = 0; ip < nchannel; ip++)
  {
    //fun fact.  NLPComponent stores v(r) as v(r), and not as r*v(r) like in other places.
    vrad[ip]  = nlpp_m[ip]->splint(r, dvrad[ip], secondderiv) * wgt_angpp_m[ip];
    vgrad[ip] = dvrad[ip] * dr * wgt_angpp_m[ip] * rinv;
  }

  const IndexType gid        = W.getGroupID(iel);
  const IndexType sid        = psi.getTWFGroupIndex(gid);
  const IndexType thisEIndex = iel - W.first(gid);
  const IndexType numptcls   = W.last(gid) - W.first(gid);
  const IndexType norbs      = psi.numOrbitals(sid);
  SPOSet& spo(*psi.getSPOSet(sid));

  RealType pairpot = 0;
  // Compute spherical harmonics on grid
  GradMatrix iongrad_phimat;
  GradVector iongrad_phi;
  ValueVector phi, laplphi;
  ValueMatrix phimat, laplphimat;
  GradMatrix gradphimat;
  GradVector gradphi;
  GradMatrix wfgradmat;

  //This stores all ion gradients of the Jastrow, evaluated on all quadrature points.
  //Has length nknot.
  ParticleSet::ParticleGradient jgrad_quad;
  jgrad_quad.resize(nknot);

  wfgradmat.resize(nknot, norbs);

  iongrad_phimat.resize(nknot, norbs);
  laplphimat.resize(nknot, norbs);

  phimat.resize(nknot, norbs);
  gradphimat.resize(nknot, norbs);
  iongrad_phi.resize(norbs);
  phi.resize(norbs);
  gradphi.resize(norbs);
  laplphi.resize(norbs);

  GradVector udotgradpsi, wfgradrow;
  GradMatrix udotgradpsimat;
  GradVector gpot, glpoly, gwfn;
  ValueVector nlpp_prefactor;
  GradVector dlpoly_prefactor;
  GradVector dvdr_prefactor;

  nlpp_prefactor.resize(nknot);
  dlpoly_prefactor.resize(nknot);
  dvdr_prefactor.resize(nknot);

  udotgradpsimat.resize(nknot, norbs);
  wfgradrow.resize(norbs);
  udotgradpsi.resize(norbs);
  gpot.resize(norbs);
  glpoly.resize(norbs);
  gwfn.resize(norbs);

  buildQuadraturePointDeltaPositions(r, dr, deltaV);
  //This is the ion gradient of J at the original (non quadrature) coordinate.
  GradType jigradref(0.0);

  jigradref = psi.evaluateJastrowGradSource(W, ions, iat_src);

  //Until we have a more efficient routine, we move to a quadrature point,
  //update distance tables, compute the ion gradient of J, then move the particle back.
  //At cost of distance table updates.  Not good, but works.
  for (int j = 0; j < nknot; j++)
  {
    W.makeMove(iel, deltaV[j], false);
    W.acceptMove(iel);
    jgrad_quad[j] = psi.evaluateJastrowGradSource(W, ions, iat_src);
    W.makeMove(iel, -deltaV[j], false);
    W.acceptMove(iel);
  }

  for (int j = 0; j < nknot; j++)
  {
    W.makeMove(iel, deltaV[j], false);
    iongrad_phi = 0.0;
    spo.evaluateGradSourceRow(W, iel, ions, iat_src, iongrad_phi);
    GradType jegrad(0.0);
    GradType jigrad(0.0);

    RealType jratio = psi.calcJastrowRatioGrad(W, iel, jegrad);
    jigrad          = psi.evaluateJastrowGradSource(W, ions, iat_src);

    spo.evaluateVGL(W, iel, phi, gradphi, laplphi);

    //Quick comment on the matrix elements being computed below.
    //For the no jastrow implementation, phimat, gradphimat, iongrad_phimat were straightforward containers storing phi_j(r_i), grad(phi_j), etc.
    //Generalizing to jastrows is straightforward if we replace phi_j(q) with exp(J(q))/exp(J(r))*phi(q).  Storing these in the phimat, gradphimat, etc.
    //data structures allows us to not modify the rather complicated expressions we have already derived.
    if (iat == iat_src)
    {
      for (int iorb = 0; iorb < norbs; iorb++)
      {
        //Treating exp(J(q))/exp(J(r))phi_j(q) as the fundamental block.
        phimat[j][iorb] = jratio * phi[iorb];
        //This is the electron gradient of the above expression.
        gradphimat[j][iorb] = jratio * (gradphi[iorb] + GradType(jegrad) * phi[iorb]);
        laplphimat[j][iorb] = laplphi[iorb]; //this is not used, so not including jastrow contribution.
      }
    }
    for (int iorb = 0; iorb < norbs; iorb++)
    {
      //This is the ion gradient of exp(J(q))/exp(J(r))phi_j(q).
      iongrad_phimat[j][iorb] = jratio * (iongrad_phi[iorb] + phi[iorb] * (GradType(jgrad_quad[j]) - jigradref));
    }
    W.rejectMove(iel);
  }

  for (int j = 0; j < nknot; j++)
  {
    RealType zz        = dot(dr, rrotsgrid_m[j]) * rinv;
    PosType uminusrvec = rrotsgrid_m[j] - zz * dr * rinv;

    cosgrad[j] = rinv * uminusrvec;

    // Forming the Legendre polynomials
    //P_0(x)=1; P'_0(x)=0.
    lpol[0]  = cone;
    dlpol[0] = czero;
    dlpol[1] = cone;

    RealType lpolprev  = czero;
    RealType dlpolprev = czero;

    for (int l = 0; l < lmax; l++)
    {
      //Legendre polynomial recursion formula.
      lpol[l + 1] = Lfactor1[l] * zz * lpol[l] - l * lpolprev;
      lpol[l + 1] *= Lfactor2[l];

      //and for the derivative...
      dlpol[l + 1] = Lfactor1[l] * (zz * dlpol[l] + lpol[l]) - l * dlpolprev;
      dlpol[l + 1] *= Lfactor2[l];

      lpolprev  = lpol[l];
      dlpolprev = dlpol[l];
    }

    for (int l = 0; l < nchannel; l++)
    {
      //Note.  Because we are computing "forces", there's a -1 difference between this and
      //direct finite difference calculations.

      nlpp_prefactor[j] += sgridweight_m[j] * vrad[l] * lpol[angpp_m[l]];
      dvdr_prefactor[j] += sgridweight_m[j] * vgrad[l] * lpol[angpp_m[l]];
      dlpoly_prefactor[j] += sgridweight_m[j] * vrad[l] * dlpol[angpp_m[l]] * cosgrad[j];
    }
  }


  for (int j = 0; j < nknot; j++)
    for (int iorb = 0; iorb < norbs; iorb++)
      gwfn[iorb] += nlpp_prefactor[j] * (iongrad_phimat[j][iorb]);

  if (iat == iat_src)
  {
    for (int j = 0; j < nknot; j++)
      for (int iorb = 0; iorb < norbs; iorb++)
      {
        //this is for diagonal case.
        //The GradType is necessary here, since rrotsgrid_m is real.  This dot() will only return the real part in this case.  
        //Does correct thing if both entries are complex.
        udotgradpsimat[j][iorb] = dot(gradphimat[j][iorb], GradType(rrotsgrid_m[j]));
        wfgradmat[j][iorb]      = gradphimat[j][iorb] - dr * (udotgradpsimat[j][iorb] * rinv);
        gpot[iorb] += dvdr_prefactor[j] * phimat[j][iorb];
        glpoly[iorb] += dlpoly_prefactor[j] * phimat[j][iorb];
        gwfn[iorb] += nlpp_prefactor[j] * (wfgradmat[j][iorb]);
      }
  }
  for (int idim = 0; idim < OHMMS_DIM; idim++)
    for (int iorb = 0; iorb < norbs; iorb++)
      dB[idim][sid][thisEIndex][iorb] += RealType(-1.0) * gpot[iorb][idim] - glpoly[iorb][idim] + gwfn[iorb][idim];
}

evaluateOneWithForces() [1/2]

NonLocalECPComponent::RealType evaluateOneWithForces	(	ParticleSet &	W,
		int	iat,
		TrialWaveFunction &	Psi,
		int	iel,
		RealType	r,
		const PosType &	dr,
		PosType &	force_iat
	)

Evaluate the nonlocal pp contribution via randomized quadrature grid to total energy from ion "iat" and electron "iel".

Parameters

W	electron particle set.
iat	index of ion.
Psi	trial wave function object
iel	index of electron
r	the distance between ion iat and electron iel.
dr	displacement from ion iat to electron iel.
force_iat	3d vector for Hellman-Feynman contribution. This gets modified.

Returns

RealType Contribution to ${V}{}$ from ion iat and electron iel.

Definition at line 282 of file NonLocalECPComponent.cpp.

References qmcplusplus::abs(), NonLocalECPComponent::angpp_m, APP_ABORT, TrialWaveFunction::calcRatioGrad(), BLAS::cone, qmcplusplus::convertToReal(), NonLocalECPComponent::cosgrad, BLAS::czero, NonLocalECPComponent::deltaV, NonLocalECPComponent::dlpol, qmcplusplus::dot(), NonLocalECPComponent::dvrad, TrialWaveFunction::evaluateRatios(), NonLocalECPComponent::gradpsiratio, NonLocalECPComponent::knot_pots, NonLocalECPComponent::Lfactor1, NonLocalECPComponent::Lfactor2, NonLocalECPComponent::lmax, NonLocalECPComponent::lpol, ParticleSet::makeMove(), VirtualParticleSet::makeMoves(), NonLocalECPComponent::nchannel, NonLocalECPComponent::nknot, NonLocalECPComponent::nlpp_m, NonLocalECPComponent::psiratio, ParticleSet::rejectMove(), TrialWaveFunction::resetPhaseDiff(), NonLocalECPComponent::rrotsgrid_m, NonLocalECPComponent::sgridweight_m, qmcplusplus::sqrt(), NonLocalECPComponent::vgrad, NonLocalECPComponent::VP, NonLocalECPComponent::vrad, NonLocalECPComponent::wfngrad, and NonLocalECPComponent::wgt_angpp_m.

Referenced by qmcplusplus::TEST_CASE().

{
  constexpr RealType czero(0);
  constexpr RealType cone(1);

  //We check that our quadrature grid is valid.  Namely, that all points lie on the unit sphere.
  //We check this by seeing if |r|^2 = 1 to machine precision.
  for (int j = 0; j < nknot; j++)
    assert(std::abs(std::sqrt(dot(rrotsgrid_m[j], rrotsgrid_m[j])) - 1) <
           100 * std::numeric_limits<RealType>::epsilon());


  for (int j = 0; j < nknot; j++)
    deltaV[j] = r * rrotsgrid_m[j] - dr;

  GradType gradtmp_(0);
  PosType realgradtmp_(0);

  //Pseudopotential derivative w.r.t. ions can be split up into 3 contributions:
  // term coming from the gradient of the radial potential
  PosType gradpotterm_(0);
  // term coming from gradient of legendre polynomial
  PosType gradlpolyterm_(0);
  // term coming from dependence of quadrature grid on ion position.
  PosType gradwfnterm_(0);

  if (VP)
  {
    APP_ABORT("NonLocalECPComponent::evaluateOneWithForces(...): Forces not implemented with virtual particle moves\n");
    // Compute ratios with VP
    VP->makeMoves(W, iel, deltaV, true, iat);
    psi.evaluateRatios(*VP, psiratio);
  }
  else
  {
    // Compute ratio of wave functions
    for (int j = 0; j < nknot; j++)
    {
      W.makeMove(iel, deltaV[j], false);
      psiratio[j] = psi.calcRatioGrad(W, iel, gradtmp_);
      //QMCPACK spits out $\nabla\Psi(q)/\Psi(q)$.
      //Multiply times $\Psi(q)/\Psi(r)$ to get
      // $\nabla\Psi(q)/\Psi(r)
      gradtmp_ *= psiratio[j];
#if defined(QMC_COMPLEX)
      //And now we take the real part and save it.
      convertToReal(gradtmp_, gradpsiratio[j]);
#else
      //Real nonlocalpp forces seem to differ from those in the complex build.  Since
      //complex build has been validated against QE, that indicates there's a bug for the real build.
      gradpsiratio[j] = gradtmp_;
#endif
      W.rejectMove(iel);
      psi.resetPhaseDiff();
      //psi.rejectMove(iel);
    }
  }

  for (int j = 0; j < nknot; j++)
    psiratio[j] *= sgridweight_m[j];

  // This is just a temporary variable to dump d2/dr2 into for spline evaluation.
  RealType secondderiv(0);

  const RealType rinv = cone / r;

  // Compute radial potential and its derivative times (2l+1)
  for (int ip = 0; ip < nchannel; ip++)
  {
    //fun fact.  NLPComponent stores v(r) as v(r), and not as r*v(r) like in other places.
    vrad[ip]  = nlpp_m[ip]->splint(r, dvrad[ip], secondderiv) * wgt_angpp_m[ip];
    vgrad[ip] = dvrad[ip] * dr * wgt_angpp_m[ip] * rinv;
  }

  RealType pairpot = 0;
  // Compute spherical harmonics on grid
  for (int j = 0; j < nknot; j++)
  {
    RealType zz        = dot(dr, rrotsgrid_m[j]) * rinv;
    PosType uminusrvec = rrotsgrid_m[j] - zz * dr * rinv;

    cosgrad[j] = rinv * uminusrvec;

    RealType udotgradpsi = dot(gradpsiratio[j], rrotsgrid_m[j]);
    wfngrad[j]           = gradpsiratio[j] - dr * (udotgradpsi * rinv);
    wfngrad[j] *= sgridweight_m[j];

    // Forming the Legendre polynomials
    //P_0(x)=1; P'_0(x)=0.
    lpol[0]  = cone;
    dlpol[0] = czero;

    RealType lpolprev  = czero;
    RealType dlpolprev = czero;

    for (int l = 0; l < lmax; l++)
    {
      //Legendre polynomial recursion formula.
      lpol[l + 1] = (Lfactor1[l] * zz * lpol[l] - l * lpolprev) * Lfactor2[l];

      //and for the derivative...
      dlpol[l + 1] = (Lfactor1[l] * (zz * dlpol[l] + lpol[l]) - l * dlpolprev) * Lfactor2[l];

      lpolprev  = lpol[l];
      dlpolprev = dlpol[l];
    }

    RealType lsum = czero;
    // Now to compute the forces:
    gradpotterm_   = 0;
    gradlpolyterm_ = 0;
    gradwfnterm_   = 0;

    for (int l = 0; l < nchannel; l++)
    {
      lsum += vrad[l] * lpol[angpp_m[l]];
      gradpotterm_ += vgrad[l] * lpol[angpp_m[l]] * std::real(psiratio[j]);
      gradlpolyterm_ += vrad[l] * dlpol[angpp_m[l]] * cosgrad[j] * std::real(psiratio[j]);
      gradwfnterm_ += vrad[l] * lpol[angpp_m[l]] * wfngrad[j];
    }
    knot_pots[j] = lsum * std::real(psiratio[j]);
    pairpot += knot_pots[j];
    force_iat += gradpotterm_ + gradlpolyterm_ - gradwfnterm_;
  }

  return pairpot;
}

evaluateOneWithForces() [2/2]

NonLocalECPComponent::RealType evaluateOneWithForces	(	ParticleSet &	W,
		ParticleSet &	ions,
		int	iat,
		TrialWaveFunction &	Psi,
		int	iel,
		RealType	r,
		const PosType &	dr,
		PosType &	force_iat,
		ParticleSet::ParticlePos &	pulay_terms
	)

Evaluate the nonlocal pp energy, Hellman-Feynman force, and "Pulay" force contribution via randomized quadrature grid from ion "iat" and electron "iel".

Parameters

W	electron particle set.
ions	ion particle set.
iat	index of ion.
Psi	trial wave function object
iel	index of electron
r	the distance between ion iat and electron iel.
dr	displacement from ion iat to electron iel.
force_iat	3d vector for Hellman-Feynman contribution. This gets modified.
pulay_terms	Nion x 3 object, holding a contribution for each ionic gradient from .

Returns

RealType Contribution to ${V}{}$ from ion iat and electron iel.

Definition at line 416 of file NonLocalECPComponent.cpp.

References qmcplusplus::abs(), ParticleSet::acceptMove(), TrialWaveFunction::acceptMove(), NonLocalECPComponent::angpp_m, APP_ABORT, TrialWaveFunction::calcRatio(), TrialWaveFunction::calcRatioGrad(), BLAS::cone, qmcplusplus::convertToReal(), NonLocalECPComponent::cosgrad, BLAS::czero, NonLocalECPComponent::deltaV, NonLocalECPComponent::dlpol, qmcplusplus::dot(), NonLocalECPComponent::dvrad, TrialWaveFunction::evalGradSource(), TrialWaveFunction::evaluateRatios(), ParticleSet::getTotalNum(), NonLocalECPComponent::gradpsiratio, NonLocalECPComponent::knot_pots, NonLocalECPComponent::Lfactor1, NonLocalECPComponent::Lfactor2, NonLocalECPComponent::lmax, NonLocalECPComponent::lpol, ParticleSet::makeMove(), VirtualParticleSet::makeMoves(), NonLocalECPComponent::nchannel, NonLocalECPComponent::nknot, NonLocalECPComponent::nlpp_m, NonLocalECPComponent::psiratio, ParticleSet::rejectMove(), TrialWaveFunction::resetPhaseDiff(), Vector< T, Alloc >::resize(), NonLocalECPComponent::rrotsgrid_m, NonLocalECPComponent::sgridweight_m, qmcplusplus::sqrt(), NonLocalECPComponent::vgrad, NonLocalECPComponent::VP, NonLocalECPComponent::vrad, NonLocalECPComponent::wfngrad, and NonLocalECPComponent::wgt_angpp_m.

{
  constexpr RealType czero(0);
  constexpr RealType cone(1);

  //We check that our quadrature grid is valid.  Namely, that all points lie on the unit sphere.
  //We check this by seeing if |r|^2 = 1 to machine precision.
  for (int j = 0; j < nknot; j++)
    assert(std::abs(std::sqrt(dot(rrotsgrid_m[j], rrotsgrid_m[j])) - 1) <
           100 * std::numeric_limits<RealType>::epsilon());

  for (int j = 0; j < nknot; j++)
    deltaV[j] = r * rrotsgrid_m[j] - dr;

  GradType gradtmp_(0);
  PosType realgradtmp_(0);

  //Pseudopotential derivative w.r.t. ions can be split up into 3 contributions:
  // term coming from the gradient of the radial potential
  PosType gradpotterm_(0);
  // term coming from gradient of legendre polynomial
  PosType gradlpolyterm_(0);
  // term coming from dependence of quadrature grid on ion position.
  PosType gradwfnterm_(0);

  //Now for the Pulay specific stuff...
  // $\nabla_I \Psi(...r...)/\Psi(...r...)$
  ParticleSet::ParticlePos pulay_ref;
  ParticleSet::ParticlePos pulaytmp_;
  // $\nabla_I \Psi(...q...)/\Psi(...r...)$ for each quadrature point.
  std::vector<ParticleSet::ParticlePos> pulay_quad(nknot);

  //A working array for pulay stuff.
  GradType iongradtmp_(0);
  //resize everything.
  pulay_ref.resize(ions.getTotalNum());
  pulaytmp_.resize(ions.getTotalNum());
  for (size_t j = 0; j < nknot; j++)
    pulay_quad[j].resize(ions.getTotalNum());

  if (VP)
  {
    APP_ABORT("NonLocalECPComponent::evaluateOneWithForces(...): Forces not implemented with virtual particle moves\n");
    // Compute ratios with VP
    VP->makeMoves(W, iel, deltaV, true, iat);
    psi.evaluateRatios(*VP, psiratio);
  }
  else
  {
    // Compute ratio of wave functions
    for (int j = 0; j < nknot; j++)
    {
      W.makeMove(iel, deltaV[j], false);
      psiratio[j] = psi.calcRatioGrad(W, iel, gradtmp_);
      //QMCPACK spits out $\nabla\Psi(q)/\Psi(q)$.
      //Multiply times $\Psi(q)/\Psi(r)$ to get
      // $\nabla\Psi(q)/\Psi(r)
      gradtmp_ *= psiratio[j];
#if defined(QMC_COMPLEX)
      //And now we take the real part and save it.
      convertToReal(gradtmp_, gradpsiratio[j]);
#else
      //Real nonlocalpp forces seem to differ from those in the complex build.  Since
      //complex build has been validated against QE, that indicates there's a bug for the real build.
      gradpsiratio[j] = gradtmp_;
#endif
      W.rejectMove(iel);
      psi.resetPhaseDiff();
      //psi.rejectMove(iel);
    }
  }

  for (int j = 0; j < nknot; j++)
    psiratio[j] *= sgridweight_m[j];

  // This is just a temporary variable to dump d2/dr2 into for spline evaluation.
  RealType secondderiv(0);

  const RealType rinv = cone / r;

  // Compute radial potential and its derivative times (2l+1)
  for (int ip = 0; ip < nchannel; ip++)
  {
    //fun fact.  NLPComponent stores v(r) as v(r), and not as r*v(r) like in other places.
    vrad[ip]  = nlpp_m[ip]->splint(r, dvrad[ip], secondderiv) * wgt_angpp_m[ip];
    vgrad[ip] = dvrad[ip] * dr * wgt_angpp_m[ip] * rinv;
  }

  //Now to construct the 3N dimensional ionic wfn derivatives for pulay terms.
  //This is going to be slow an painful for now.
  for (size_t jat = 0; jat < ions.getTotalNum(); jat++)
  {
    convertToReal(psi.evalGradSource(W, ions, jat), pulay_ref[jat]);
    gradpotterm_ = 0;
    for (size_t j = 0; j < nknot; j++)
    {
      deltaV[j] = r * rrotsgrid_m[j] - dr;
      //This sequence is necessary to update the distance tables and make the
      //inverse matrix available for force computation.  Move the particle to
      //quadrature point...
      W.makeMove(iel, deltaV[j]);
      psi.calcRatio(W, iel);
      psi.acceptMove(W, iel);
      W.acceptMove(iel); // it only updates the jel-th row of e-e table
      //Done with the move.  Ready for force computation.

      iongradtmp_ = psi.evalGradSource(W, ions, jat);
      iongradtmp_ *= psiratio[j];
      convertToReal(iongradtmp_, pulay_quad[j][jat]);
      //And move the particle back.
      deltaV[j] = dr - r * rrotsgrid_m[j];

      // mirror the above in reverse order
      W.makeMove(iel, deltaV[j]);
      psi.calcRatio(W, iel);
      psi.acceptMove(W, iel);
      W.acceptMove(iel);
    }
  }

  RealType pairpot = 0;
  // Compute spherical harmonics on grid
  for (int j = 0; j < nknot; j++)
  {
    RealType zz        = dot(dr, rrotsgrid_m[j]) * rinv;
    PosType uminusrvec = rrotsgrid_m[j] - zz * dr * rinv;

    cosgrad[j] = rinv * uminusrvec;

    RealType udotgradpsi = dot(gradpsiratio[j], rrotsgrid_m[j]);
    wfngrad[j]           = gradpsiratio[j] - dr * (udotgradpsi * rinv);
    wfngrad[j] *= sgridweight_m[j];

    // Forming the Legendre polynomials
    //P_0(x)=1; P'_0(x)=0.
    lpol[0]  = cone;
    dlpol[0] = czero;

    RealType lpolprev  = czero;
    RealType dlpolprev = czero;

    for (int l = 0; l < lmax; l++)
    {
      //Legendre polynomial recursion formula.
      lpol[l + 1] = (Lfactor1[l] * zz * lpol[l] - l * lpolprev) * Lfactor2[l];

      //and for the derivative...
      dlpol[l + 1] = (Lfactor1[l] * (zz * dlpol[l] + lpol[l]) - l * dlpolprev) * Lfactor2[l];

      lpolprev  = lpol[l];
      dlpolprev = dlpol[l];
    }

    RealType lsum = czero;
    // Now to compute the forces:
    gradpotterm_   = 0;
    gradlpolyterm_ = 0;
    gradwfnterm_   = 0;
    pulaytmp_      = 0;

    for (int l = 0; l < nchannel; l++)
    {
      //Note.  Because we are computing "forces", there's a -1 difference between this and
      //direct finite difference calculations.
      lsum += vrad[l] * lpol[angpp_m[l]];
      gradpotterm_ += vgrad[l] * lpol[angpp_m[l]] * std::real(psiratio[j]);
      gradlpolyterm_ += vrad[l] * dlpol[angpp_m[l]] * cosgrad[j] * std::real(psiratio[j]);
      gradwfnterm_ += vrad[l] * lpol[angpp_m[l]] * wfngrad[j];
      pulaytmp_ -= vrad[l] * lpol[angpp_m[l]] * pulay_quad[j];
    }
    knot_pots[j] = lsum * std::real(psiratio[j]);
    pulaytmp_ += knot_pots[j] * pulay_ref;
    pairpot += knot_pots[j];
    force_iat += gradpotterm_ + gradlpolyterm_ - gradwfnterm_;
    pulay_terms += pulaytmp_;
  }

  return pairpot;
}

evaluateValueAndDerivatives()

NonLocalECPComponent::RealType evaluateValueAndDerivatives	(	ParticleSet &	W,
		int	iat,
		TrialWaveFunction &	psi,
		int	iel,
		RealType	r,
		const PosType &	dr,
		const opt_variables_type &	optvars,
		const Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi
	)

evaluate the non-local potential of the iat-th ionic center

Parameters

W	electron configuration
iat	ionic index
psi	trial wavefunction
optvars	optimizables
dlogpsi	derivatives of the wavefunction at W.R
hdpsioverpsi	derivatives of Vpp
return	the non-local component

This is a temporary solution which uses TrialWaveFunction::evaluateDerivatives assuming that the distance tables are fully updated for each ratio computation.

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

References ParticleSet::acceptMove(), TrialWaveFunction::acceptMove(), NonLocalECPComponent::angpp_m, Vector< T, Alloc >::begin(), TrialWaveFunction::calcRatio(), Matrix< T, Alloc >::data(), Vector< T, Alloc >::data(), NonLocalECPComponent::deltaV, NonLocalECPComponent::dlogpsi_vp, qmcplusplus::dot(), NonLocalECPComponent::dratio, Vector< T, Alloc >::end(), TrialWaveFunction::evaluateDerivativesWF(), TrialWaveFunction::evaluateDerivRatios(), BLAS::gemv(), NonLocalECPComponent::Lfactor1, NonLocalECPComponent::Lfactor2, NonLocalECPComponent::lmax, NonLocalECPComponent::lpol, ParticleSet::makeMove(), VirtualParticleSet::makeMoves(), NonLocalECPComponent::nchannel, NonLocalECPComponent::nknot, NonLocalECPComponent::nlpp_m, VariableSet::num_active_vars, NonLocalECPComponent::psiratio, ParticleSet::R, Matrix< T, Alloc >::resize(), Vector< T, Alloc >::resize(), NonLocalECPComponent::rrotsgrid_m, NonLocalECPComponent::sgridweight_m, Vector< T, Alloc >::size(), NonLocalECPComponent::VP, NonLocalECPComponent::vrad, NonLocalECPComponent::wgt_angpp_m, and NonLocalECPComponent::wvec.

Referenced by qmcplusplus::TEST_CASE().

{
  const size_t num_vars = optvars.num_active_vars;
  dratio.resize(nknot, num_vars);
  dlogpsi_vp.resize(dlogpsi.size());

  deltaV.resize(nknot);

  //displacements wrt W.R[iel]
  for (int j = 0; j < nknot; j++)
    deltaV[j] = r * rrotsgrid_m[j] - dr;

  if (VP)
  {
    // Compute ratios with VP
    VP->makeMoves(W, iel, deltaV, true, iat);
    psi.evaluateDerivRatios(*VP, optvars, psiratio, dratio);
  }
  else
  {
    for (int j = 0; j < nknot; j++)
    {
      PosType pos_now = W.R[iel];
      W.makeMove(iel, deltaV[j]);
      psiratio[j] = psi.calcRatio(W, iel);
      psi.acceptMove(W, iel);
      W.acceptMove(iel);

      //use existing methods
      std::fill(dlogpsi_vp.begin(), dlogpsi_vp.end(), 0.0);
      psi.evaluateDerivativesWF(W, optvars, dlogpsi_vp);
      for (int v = 0; v < dlogpsi_vp.size(); ++v)
        dratio(j, v) = dlogpsi_vp[v] - dlogpsi[v];

      W.makeMove(iel, -deltaV[j]);
      psi.calcRatio(W, iel);
      psi.acceptMove(W, iel);
      W.acceptMove(iel);
    }
  }

  for (int j = 0; j < nknot; ++j)
    psiratio[j] *= sgridweight_m[j];

  for (int ip = 0; ip < nchannel; ip++)
    vrad[ip] = nlpp_m[ip]->splint(r) * wgt_angpp_m[ip];

  RealType pairpot(0);
  const RealType rinv = RealType(1) / r;
  // Compute spherical harmonics on grid
  for (int j = 0, jl = 0; j < nknot; j++)
  {
    RealType zz = dot(dr, rrotsgrid_m[j]) * rinv;
    // Forming the Legendre polynomials
    lpol[0]           = 1.0;
    RealType lpolprev = 0.0;
    for (int l = 0; l < lmax; l++)
    {
      lpol[l + 1] = (Lfactor1[l] * zz * lpol[l] - l * lpolprev) * Lfactor2[l];
      lpolprev    = lpol[l];
    }

    RealType lsum = 0.0;
    for (int l = 0; l < nchannel; l++)
      lsum += vrad[l] * lpol[angpp_m[l]];

    wvec[j] = lsum * psiratio[j];
    pairpot += std::real(wvec[j]);
  }

  BLAS::gemv('N', num_vars, nknot, 1.0, dratio.data(), num_vars, wvec.data(), 1, 1.0, dhpsioverpsi.data(), 1);

  return pairpot;
}

getLmax()

int getLmax ( ) const

inline

Definition at line 313 of file NonLocalECPComponent.h.

References NonLocalECPComponent::lmax.

{ return lmax; }

getNknot()

int getNknot ( ) const

inline

Definition at line 311 of file NonLocalECPComponent.h.

References NonLocalECPComponent::nknot.

Referenced by NonLocalECPComponent::mw_evaluateOne().

{ return nknot; }

getRmax()

RealType getRmax ( ) const

inline

Definition at line 310 of file NonLocalECPComponent.h.

References NonLocalECPComponent::Rmax.

Referenced by qmcplusplus::TEST_CASE().

{ return Rmax; }

getVP()

const VirtualParticleSet* getVP ( ) const

inline

Definition at line 314 of file NonLocalECPComponent.h.

References NonLocalECPComponent::VP.

{ return VP; };

initVirtualParticle()

void initVirtualParticle

(

const ParticleSet &

qp

)

Definition at line 51 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::nknot, outputManager, OutputManagerClass::pause(), OutputManagerClass::resume(), and NonLocalECPComponent::VP.

Referenced by qmcplusplus::TEST_CASE().

{
  assert(VP == 0);
  outputManager.pause();
  VP = new VirtualParticleSet(qp, nknot);
  outputManager.resume();
}

mw_evaluateOne()

void mw_evaluateOne ( const RefVectorWithLeader< NonLocalECPComponent > &  ecp_component_list, const RefVectorWithLeader< ParticleSet > &  p_list, const RefVectorWithLeader< TrialWaveFunction > &  psi_list, const RefVector< const NLPPJob< RealType >> &  joblist, std::vector< RealType > &  pairpots, ResourceCollection &  collection, bool  use_DLA  )

static

Evaluate the nonlocal pp contribution via randomized quadrature grid to total energy from ion "iat" and electron "iel" for a batch of walkers.

Parameters

ecp_component_list	a list of ECP components
p_list	a list of electron particle set.
psi_list	a list of trial wave function object
joblist	a list of ion-electron pairs
pairpots	a list of contribution to ${V}{}$ from ion iat and electron iel.
use_DLA	if ture, use determinant localization approximation (DLA).

Note: ecp_component_list allows including different NLPP component for different walkers. electrons in iel_list must be of the same group (spin)

Definition at line 204 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::buildQuadraturePointDeltaPositions(), TrialWaveFunction::calcRatio(), NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::deltaV, NLPPJob< T >::electron_id, TrialWaveFunction::FERMIONIC, RefVectorWithLeader< T >::getLeader(), NonLocalECPComponent::getNknot(), NLPPJob< T >::ion_elec_displ, NLPPJob< T >::ion_elec_dist, ParticleSet::makeMove(), TrialWaveFunction::mw_evaluateRatios(), VirtualParticleSet::mw_makeMoves(), NonLocalECPComponent::psiratio, ParticleSet::rejectMove(), TrialWaveFunction::resetPhaseDiff(), and NonLocalECPComponent::VP.

Referenced by NonLocalECPotential::mw_evaluateImpl().

{
  auto& ecp_component_leader = ecp_component_list.getLeader();
  if (ecp_component_leader.VP)
  {
    // Compute ratios with VP
    RefVectorWithLeader<VirtualParticleSet> vp_list(*ecp_component_leader.VP);
    RefVectorWithLeader<const VirtualParticleSet> const_vp_list(*ecp_component_leader.VP);
    RefVector<const std::vector<PosType>> deltaV_list;
    RefVector<std::vector<ValueType>> psiratios_list;
    vp_list.reserve(ecp_component_list.size());
    const_vp_list.reserve(ecp_component_list.size());
    deltaV_list.reserve(ecp_component_list.size());
    psiratios_list.reserve(ecp_component_list.size());

    for (size_t i = 0; i < ecp_component_list.size(); i++)
    {
      NonLocalECPComponent& component(ecp_component_list[i]);
      const NLPPJob<RealType>& job = joblist[i];

      component.buildQuadraturePointDeltaPositions(job.ion_elec_dist, job.ion_elec_displ, component.deltaV);

      vp_list.push_back(*component.VP);
      const_vp_list.push_back(*component.VP);
      deltaV_list.push_back(component.deltaV);
      psiratios_list.push_back(component.psiratio);
    }

    ResourceCollectionTeamLock<VirtualParticleSet> vp_res_lock(collection, vp_list);

    VirtualParticleSet::mw_makeMoves(vp_list, p_list, deltaV_list, joblist, true);

    if (use_DLA)
      TrialWaveFunction::mw_evaluateRatios(psi_list, const_vp_list, psiratios_list,
                                           TrialWaveFunction::ComputeType::FERMIONIC);
    else
      TrialWaveFunction::mw_evaluateRatios(psi_list, const_vp_list, psiratios_list);
  }
  else
  {
    // Compute ratios without VP. This is working but very slow code path.
    for (size_t i = 0; i < p_list.size(); i++)
    {
      NonLocalECPComponent& component(ecp_component_list[i]);
      ParticleSet& W(p_list[i]);
      TrialWaveFunction& psi(psi_list[i]);
      const NLPPJob<RealType>& job = joblist[i];

      component.buildQuadraturePointDeltaPositions(job.ion_elec_dist, job.ion_elec_displ, component.deltaV);

      // Compute ratio of wave functions
      for (int j = 0; j < component.getNknot(); j++)
      {
        W.makeMove(job.electron_id, component.deltaV[j], false);
        if (use_DLA)
          component.psiratio[j] = psi.calcRatio(W, job.electron_id, TrialWaveFunction::ComputeType::FERMIONIC);
        else
          component.psiratio[j] = psi.calcRatio(W, job.electron_id);
        W.rejectMove(job.electron_id);
        psi.resetPhaseDiff();
      }
    }
  }

  for (size_t i = 0; i < p_list.size(); i++)
  {
    NonLocalECPComponent& component(ecp_component_list[i]);
    const NLPPJob<RealType>& job = joblist[i];
    pairpots[i]                  = component.calculateProjector(job.ion_elec_dist, job.ion_elec_displ);
  }
}

print()

void print

(

std::ostream &

os

)

Definition at line 114 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::angpp_m, HIGH, OutputManagerClass::isActive(), NonLocalECPComponent::lmax, NonLocalECPComponent::nchannel, NonLocalECPComponent::nknot, outputManager, NonLocalECPComponent::Rmax, NonLocalECPComponent::sgridweight_m, and NonLocalECPComponent::sgridxyz_m.

{
  os << "    Maximum angular momentum = " << lmax << std::endl;
  os << "    Number of non-local channels = " << nchannel << std::endl;
  for (int l = 0; l < nchannel; l++)
    os << "       l(" << l << ")=" << angpp_m[l] << std::endl;
  os << "    Cutoff radius = " << Rmax << std::endl;
  os << "    Number of spherical integration grid points = " << nknot << std::endl;
  if (outputManager.isActive(Verbosity::HIGH))
  {
    os << "    Spherical grid and weights: " << std::endl;
    for (int ik = 0; ik < nknot; ik++)
      os << "       " << sgridxyz_m[ik] << std::setw(20) << sgridweight_m[ik] << std::endl;
  }
}

resize_warrays()

void resize_warrays	(	int	n,
		int	m,
		int	l
	)

Definition at line 73 of file NonLocalECPComponent.cpp.

References APP_ABORT, NonLocalECPComponent::cosgrad, NonLocalECPComponent::deltaV, NonLocalECPComponent::dlpol, NonLocalECPComponent::dvrad, NonLocalECPComponent::gradpsiratio, NonLocalECPComponent::knot_pots, NonLocalECPComponent::Lfactor1, NonLocalECPComponent::Lfactor2, NonLocalECPComponent::lmax, NonLocalECPComponent::lpol, qmcplusplus::Units::distance::m, qmcplusplus::n, NonLocalECPComponent::nchannel, NonLocalECPComponent::nknot, NonLocalECPComponent::nlpp_m, NonLocalECPComponent::psiratio, NonLocalECPComponent::rrotsgrid_m, NonLocalECPComponent::sgridxyz_m, NonLocalECPComponent::vgrad, NonLocalECPComponent::vrad, NonLocalECPComponent::wfngrad, and NonLocalECPComponent::wvec.

{
  psiratio.resize(n);
  gradpsiratio.resize(n);
  deltaV.resize(n);
  cosgrad.resize(n);
  wfngrad.resize(n);
  knot_pots.resize(n);
  vrad.resize(m);
  dvrad.resize(m);
  vgrad.resize(m);
  wvec.resize(n);
  lpol.resize(l + 1, 1.0);
  //dlpol needs two data points to do a recursive construction.  Also is only nontrivial for l>1.
  //This +2 guards against l=0 case.
  dlpol.resize(l + 2, 0.0);
  rrotsgrid_m.resize(n);
  nchannel = nlpp_m.size();
  nknot    = sgridxyz_m.size();

  //Now we inititalize the quadrature grid rrotsgrid_m to the unrotated grid.
  rrotsgrid_m = sgridxyz_m;

  //This is just to check
  //for(int nl=1; nl<nlpp_m.size(); nl++) nlpp_m[nl]->setGridManager(false);
  if (lmax)
  {
    if (lmax > 7)
    {
      APP_ABORT("Increase the maximum angular momentum implemented.");
    }
    //Lfactor1.resize(lmax);
    //Lfactor2.resize(lmax);
    for (int nl = 0; nl < lmax; nl++)
    {
      Lfactor1[nl] = static_cast<RealType>(2 * nl + 1);
      Lfactor2[nl] = 1.0e0 / static_cast<RealType>(nl + 1);
    }
  }
}

rotateQuadratureGrid() [1/2]

void rotateQuadratureGrid

(

const TensorType &

rmat

)

Randomly rotate sgrid_m.

Definition at line 875 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::do_randomize_grid_, qmcplusplus::dot(), NonLocalECPComponent::rrotsgrid_m, and NonLocalECPComponent::sgridxyz_m.

{
  for (int i = 0; i < sgridxyz_m.size(); i++)
    if (do_randomize_grid_)
      rrotsgrid_m[i] = dot(rmat, sgridxyz_m[i]);
    else
      rrotsgrid_m[i] = sgridxyz_m[i];
}

rotateQuadratureGrid() [2/2]

void rotateQuadratureGrid	(	std::vector< T > &	sphere,
		const TensorType &	rmat
	)

Definition at line 885 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::do_randomize_grid_, qmcplusplus::dot(), OHMMS_DIM, NonLocalECPComponent::rrotsgrid_m, and NonLocalECPComponent::sgridxyz_m.

{
  SpherGridType::iterator it(sgridxyz_m.begin());
  SpherGridType::iterator it_end(sgridxyz_m.end());
  SpherGridType::iterator jt(rrotsgrid_m.begin());
  while (it != it_end)
  {
    if (do_randomize_grid_)
      *jt = dot(rmat, *it);
    else
      *jt = *it;
    ++it;
    ++jt;
  }
  //copy the randomized grid to sphere
  for (int i = 0; i < rrotsgrid_m.size(); i++)
    for (int j = 0; j < OHMMS_DIM; j++)
      sphere[OHMMS_DIM * i + j] = rrotsgrid_m[i][j];
}

set_randomize_grid()

void set_randomize_grid

(

bool

do_randomize_grid_

)

Definition at line 46 of file NonLocalECPComponent.cpp.

References NonLocalECPComponent::do_randomize_grid_.

{
  do_randomize_grid_ = do_randomize_grid;
}

setLmax()

void setLmax ( int  Lmax )

inline

Definition at line 312 of file NonLocalECPComponent.h.

References NonLocalECPComponent::lmax.

{ lmax = Lmax; }

setRmax()

void setRmax ( int  rmax )

inline

Definition at line 309 of file NonLocalECPComponent.h.

References NonLocalECPComponent::Rmax.

{ Rmax = rmax; }

Friends And Related Function Documentation

copyGridUnrotatedForTest

void copyGridUnrotatedForTest ( NonLocalECPComponent &  nlpp )

friend

Definition at line 153 of file test_ecp.cpp.

{ nlpp.rrotsgrid_m = nlpp.sgridxyz_m; }

ECPComponentBuilder

friend struct ECPComponentBuilder

friend

Definition at line 319 of file NonLocalECPComponent.h.

NonLocalECPotential_CUDA

friend class NonLocalECPotential_CUDA

friend

Definition at line 321 of file NonLocalECPComponent.h.

testing::TestNonLocalECPotential

friend class testing::TestNonLocalECPotential

friend

Definition at line 324 of file NonLocalECPComponent.h.

Member Data Documentation

angpp_m

aligned_vector<int> angpp_m

private

Angular momentum map.

Definition at line 59 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::add(), NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::print().

cosgrad

std::vector<PosType> cosgrad

private

Definition at line 95 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), and NonLocalECPComponent::resize_warrays().

deltaV

std::vector<PosType> deltaV

private

Definition at line 78 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::buildQuadraturePointDeltaPositions(), NonLocalECPComponent::contributeTxy(), NonLocalECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::mw_evaluateOne(), and NonLocalECPComponent::resize_warrays().

dG

ParticleSet::ParticleGradient dG

private

Definition at line 107 of file NonLocalECPComponent.h.

dL

ParticleSet::ParticleLaplacian dL

private

Definition at line 108 of file NonLocalECPComponent.h.

dlogpsi_vp

Vector<ValueType> dlogpsi_vp

private

Definition at line 103 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateValueAndDerivatives().

dlpol

std::vector<RealType> dlpol

private

Definition at line 82 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), and NonLocalECPComponent::resize_warrays().

do_randomize_grid_

bool do_randomize_grid_

private

Can disable grid randomization for testing.

Definition at line 125 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::rotateQuadratureGrid(), and NonLocalECPComponent::set_randomize_grid().

dratio

Matrix<ValueType> dratio

private

scratch spaces used by evaluateValueAndDerivatives

Definition at line 102 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateValueAndDerivatives().

dvrad

std::vector<RealType> dvrad

private

Definition at line 86 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), and NonLocalECPComponent::resize_warrays().

Gion

ParticleSet::ParticleGradient Gion

private

The gradient of the wave function w.r.t. the ion position.

Definition at line 112 of file NonLocalECPComponent.h.

Gnew

Matrix<PosType> Gnew

private

First index is knot, second is electron.

Definition at line 110 of file NonLocalECPComponent.h.

gradpsiratio

std::vector<PosType> gradpsiratio

private

Definition at line 91 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateOneWithForces(), and NonLocalECPComponent::resize_warrays().

knot_pots

std::vector<RealType> knot_pots

private

Definition at line 99 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::contributeTxy(), NonLocalECPComponent::evaluateOneWithForces(), and NonLocalECPComponent::resize_warrays().

Lfactor1

RealType Lfactor1[8]

private

Lfactor1[l]=(2*l+1)/(l+1)

Definition at line 63 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::resize_warrays().

Lfactor2

RealType Lfactor2[8]

private

Lfactor1[l]=(l)/(l+1)

Definition at line 65 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::resize_warrays().

lmax

int lmax

private

Non Local part: angular momentum, potential and grid.

Definition at line 51 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::getLmax(), NonLocalECPComponent::print(), NonLocalECPComponent::resize_warrays(), and NonLocalECPComponent::setLmax().

lpol

std::vector<RealType> lpol

private

Definition at line 80 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::resize_warrays().

nchannel

int nchannel

private

the number of non-local channels

Definition at line 53 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::print(), and NonLocalECPComponent::resize_warrays().

nknot

int nknot

private

the number of nknot

Definition at line 55 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::buildQuadraturePointDeltaPositions(), NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::contributeTxy(), NonLocalECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::getNknot(), NonLocalECPComponent::initVirtualParticle(), NonLocalECPComponent::NonLocalECPComponent(), NonLocalECPComponent::print(), and NonLocalECPComponent::resize_warrays().

nlpp_m

std::vector<RadialPotentialType*> nlpp_m

private

Non-Local part of the pseudo-potential.

Definition at line 67 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::add(), NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::NonLocalECPComponent(), NonLocalECPComponent::resize_warrays(), and NonLocalECPComponent::~NonLocalECPComponent().

psiratio

std::vector<ValueType> psiratio

private

Definition at line 88 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::mw_evaluateOne(), and NonLocalECPComponent::resize_warrays().

Rmax

RealType Rmax

private

Maximum cutoff the non-local pseudopotential.

Definition at line 57 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::getRmax(), NonLocalECPComponent::print(), and NonLocalECPComponent::setRmax().

rrotsgrid_m

SpherGridType rrotsgrid_m

private

randomized spherical grid

Definition at line 71 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::buildQuadraturePointDeltaPositions(), NonLocalECPComponent::calculateProjector(), qmcplusplus::copyGridUnrotatedForTest(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::resize_warrays(), and NonLocalECPComponent::rotateQuadratureGrid().

sgridweight_m

std::vector<RealType> sgridweight_m

private

weight of the spherical grid

Definition at line 73 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::addknot(), NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::print().

sgridxyz_m

SpherGridType sgridxyz_m

private

fixed Spherical Grid for species

Definition at line 69 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::addknot(), qmcplusplus::copyGridUnrotatedForTest(), NonLocalECPComponent::print(), NonLocalECPComponent::resize_warrays(), and NonLocalECPComponent::rotateQuadratureGrid().

vgrad

std::vector<PosType> vgrad

private

Definition at line 93 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), and NonLocalECPComponent::resize_warrays().

VP

VirtualParticleSet* VP

private

virtual particle set: delayed initialization

Definition at line 115 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::deleteVirtualParticle(), NonLocalECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::getVP(), NonLocalECPComponent::initVirtualParticle(), NonLocalECPComponent::mw_evaluateOne(), NonLocalECPComponent::NonLocalECPComponent(), and NonLocalECPComponent::~NonLocalECPComponent().

vrad

std::vector<RealType> vrad

private

Definition at line 84 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::resize_warrays().

WarpNorm

std::vector<RealType> WarpNorm

private

Definition at line 106 of file NonLocalECPComponent.h.

wfngrad

std::vector<PosType> wfngrad

private

Definition at line 97 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateOneWithForces(), and NonLocalECPComponent::resize_warrays().

wgt_angpp_m

aligned_vector<RealType> wgt_angpp_m

private

Weight of the angular momentum.

Definition at line 61 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::add(), NonLocalECPComponent::calculateProjector(), NonLocalECPComponent::evaluateOneBodyOpMatrixContribution(), NonLocalECPComponent::evaluateOneBodyOpMatrixdRContribution(), NonLocalECPComponent::evaluateOneWithForces(), and NonLocalECPComponent::evaluateValueAndDerivatives().

wvec

std::vector<ValueType> wvec

private

Working arrays.

Definition at line 75 of file NonLocalECPComponent.h.

Referenced by NonLocalECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::resize_warrays().

---

The documentation for this class was generated from the following files:

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCHamiltonians/NonLocalECPComponent.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCHamiltonians/NonLocalECPComponent.cpp
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCHamiltonians/NonLocalECPotential.deriv.cpp