Inheritance diagram for Backflow_ee< FT >:

Collaboration diagram for Backflow_ee< FT >:

Public Member Functions
	Backflow_ee (ParticleSet &ions, ParticleSet &els)

std::unique_ptr< BackflowFunctionBase >	makeClone (ParticleSet &tqp) const override

void	addFunc (int ia, int ib, std::unique_ptr< FT > rf)

void	registerData (WFBufferType &buf) override

void	reportStatus (std::ostream &os) override

void	resetParameters (const opt_variables_type &active) override

void	checkInVariables (opt_variables_type &active) override

void	checkOutVariables (const opt_variables_type &active) override

bool	isOptimizable () override

int	indexOffset () override

void	acceptMove (int iat, int UpdateMode) override

void	restore (int iat, int UpdateType) override

void	evaluate (const ParticleSet &P, ParticleSet &QP) override
	calculate quasi-particle coordinates only More...

void	evaluate (const ParticleSet &P, ParticleSet &QP, GradVector &Bmat, HessMatrix &Amat)

void	evaluate (const ParticleSet &P, ParticleSet &QP, GradMatrix &Bmat_full, HessMatrix &Amat) override
	calculate quasi-particle coordinates, Bmat and Amat More...

void	evaluatePbyP (const ParticleSet &P, ParticleSet::ParticlePos &newQP, const std::vector< int > &index) override
	calculate quasi-particle coordinates after pbyp move More...

void	evaluatePbyP (const ParticleSet &P, int iat, ParticleSet::ParticlePos &newQP) override
	calculate quasi-particle coordinates after pbyp move More...

void	evaluatePbyP (const ParticleSet &P, ParticleSet::ParticlePos &newQP, const std::vector< int > &index, HessMatrix &Amat) override
	calculate quasi-particle coordinates and Amat after pbyp move More...

void	evaluatePbyP (const ParticleSet &P, int iat, ParticleSet::ParticlePos &newQP, HessMatrix &Amat) override
	calculate quasi-particle coordinates and Amat after pbyp move More...

void	evaluatePbyP (const ParticleSet &P, ParticleSet::ParticlePos &newQP, const std::vector< int > &index, GradMatrix &Bmat, HessMatrix &Amat) override
	calculate quasi-particle coordinates and Amat after pbyp move More...

void	evaluatePbyP (const ParticleSet &P, int iat, ParticleSet::ParticlePos &newQP, GradMatrix &Bmat, HessMatrix &Amat) override
	calculate quasi-particle coordinates and Amat after pbyp move More...

void	evaluateBmatOnly (const ParticleSet &P, GradMatrix &Bmat_full) override
	calculate only Bmat This is used in pbyp moves, in updateBuffer() More...

void	evaluateWithDerivatives (const ParticleSet &P, ParticleSet &QP, GradMatrix &Bmat_full, HessMatrix &Amat, GradMatrix &Cmat, GradMatrix &Ymat, HessArray &Xmat) override
	calculate quasi-particle coordinates, Bmat and Amat calculate derivatives wrt to variational parameters More...

Public Member Functions inherited from BackflowFunctionBase
	BackflowFunctionBase (ParticleSet &ions, ParticleSet &els)

void	resize (int NT, int NC)

virtual	~BackflowFunctionBase ()

int	setParamIndex (int n)

void	updateBuffer (WFBufferType &buf)

void	copyFromBuffer (WFBufferType &buf)

Public Attributes
std::vector< FT * >	RadFun

std::vector< std::unique_ptr< FT > >	uniqueRadFun

std::vector< int >	offsetPrms

int	NumGroups

Matrix< int >	PairID

bool	first

Public Attributes inherited from BackflowFunctionBase
ParticleSet &	CenterSys
	Reference to the center. More...

int	NumCenters
	number of centers, e.g., ions More...

int	NumTargets
	number of quantum particles More...

int	numParams

int	indexOfFirstParam

std::vector< TinyVector< RealType, 3 > >	derivs

Matrix< PosType >	UIJ

Vector< PosType >	UIJ_temp

HessMatrix	AIJ

HessVector	AIJ_temp

GradMatrix	BIJ

GradVector	BIJ_temp

RealType *	FirstOfU

RealType *	LastOfU

RealType *	FirstOfA

RealType *	LastOfA

RealType *	FirstOfB

RealType *	LastOfB

bool	uniqueFunctions

opt_variables_type	myVars

Private Attributes
const int	myTableIndex_
	distance table index More...

Additional Inherited Members
Public Types inherited from BackflowFunctionBase
enum	{ DIM = OHMMS_DIM }

enum	{ ORB_PBYP_RATIO, ORB_PBYP_ALL, ORB_PBYP_PARTIAL, ORB_WALKER, ORB_ALLWALKER }
	enum for a update mode More...

using	Walker_t = ParticleSet::Walker_t

using	WFBufferType = Walker_t::WFBuffer_t

using	RealType = OHMMS_PRECISION

using	IndexType = int

using	PosType = TinyVector< RealType, DIM >

using	GradType = TinyVector< RealType, DIM >

using	HessType = Tensor< RealType, DIM >

using	IndexVector = Vector< IndexType >

using	GradVector = Vector< GradType >

using	GradMatrix = Matrix< GradType >

using	HessVector = Vector< HessType >

using	HessMatrix = Matrix< HessType >

using	HessArray = Array< HessType, 3 >

Detailed Description

template<class FT>
class qmcplusplus::Backflow_ee< FT >

Definition at line 26 of file Backflow_ee.h.

Constructor & Destructor Documentation

◆ Backflow_ee()

Backflow_ee	(	ParticleSet &	ions,
		ParticleSet &	els
	)

inline

Definition at line 41 of file Backflow_ee.h.

References ParticleSet::GroupID, ParticleSet::groups(), Backflow_ee< FT >::NumGroups, BackflowFunctionBase::NumTargets, Backflow_ee< FT >::offsetPrms, Backflow_ee< FT >::PairID, Backflow_ee< FT >::RadFun, Matrix< T, Alloc >::resize(), and BackflowFunctionBase::resize().

       : BackflowFunctionBase(ions, els),
         myTableIndex_(els.addTable(els, DTModes::NEED_TEMP_DATA_ON_HOST | DTModes::NEED_VP_FULL_TABLE_ON_HOST)),
         first(true)
   {
     resize(NumTargets, NumTargets);
     NumGroups = els.groups();
     PairID.resize(NumTargets, NumTargets);
     for (int i = 0; i < NumTargets; ++i)
       for (int j = 0; j < NumTargets; ++j)
         PairID(i, j) = els.GroupID[i] * NumGroups + els.GroupID[j];
     RadFun.resize(NumGroups * NumGroups, 0);
     offsetPrms.resize(NumGroups * NumGroups, 0);
   }

Member Function Documentation

◆ acceptMove()

void acceptMove	(	int	iat,
		int	UpdateMode
	)

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 151 of file Backflow_ee.h.

References BackflowFunctionBase::AIJ, BackflowFunctionBase::AIJ_temp, BackflowFunctionBase::BIJ, BackflowFunctionBase::BIJ_temp, BackflowFunctionBase::ORB_PBYP_ALL, BackflowFunctionBase::ORB_PBYP_PARTIAL, BackflowFunctionBase::ORB_PBYP_RATIO, Matrix< T, Alloc >::rows(), BackflowFunctionBase::UIJ, and BackflowFunctionBase::UIJ_temp.

   {
     int num;
     switch (UpdateMode)
     {
     case ORB_PBYP_RATIO:
       num = UIJ.rows();
       for (int i = 0; i < num; i++)
       {
         UIJ(iat, i) = UIJ_temp[i];
         UIJ(i, iat) = -1.0 * UIJ_temp[i];
       }
       break;
     case ORB_PBYP_PARTIAL:
       num = UIJ.rows();
       for (int i = 0; i < num; i++)
       {
         UIJ(iat, i) = UIJ_temp[i];
         UIJ(i, iat) = -1.0 * UIJ_temp[i];
       }
       num = AIJ.rows();
       for (int i = 0; i < num; i++)
       {
         AIJ(iat, i) = AIJ_temp[i];
         AIJ(i, iat) = AIJ_temp[i];
       }
       break;
     case ORB_PBYP_ALL:
       num = UIJ.rows();
       for (int i = 0; i < num; i++)
       {
         UIJ(iat, i) = UIJ_temp[i];
         UIJ(i, iat) = -1.0 * UIJ_temp[i];
       }
       num = AIJ.rows();
       for (int i = 0; i < num; i++)
       {
         AIJ(iat, i) = AIJ_temp[i];
         AIJ(i, iat) = AIJ_temp[i];
       }
       num = BIJ.rows();
       for (int i = 0; i < num; i++)
       {
         BIJ(iat, i) = BIJ_temp[i];
         BIJ(i, iat) = -1.0 * BIJ_temp[i];
       }
       break;
     default:
       num = UIJ.rows();
       for (int i = 0; i < num; i++)
       {
         UIJ(iat, i) = UIJ_temp[i];
         UIJ(i, iat) = -1.0 * UIJ_temp[i];
       }
       num = AIJ.rows();
       for (int i = 0; i < num; i++)
       {
         AIJ(iat, i) = AIJ_temp[i];
         AIJ(i, iat) = AIJ_temp[i];
       }
       num = BIJ.rows();
       for (int i = 0; i < num; i++)
       {
         BIJ(iat, i) = BIJ_temp[i];
         BIJ(i, iat) = -1.0 * BIJ_temp[i];
       }
       break;
     }
     UIJ_temp = 0.0;
     AIJ_temp = 0.0;
     BIJ_temp = 0.0;
   }

◆ addFunc()

void addFunc	(	int	ia,
		int	ib,
		std::unique_ptr< FT >	rf
	)

inline

Definition at line 87 of file Backflow_ee.h.

References Backflow_ee< FT >::first, Backflow_ee< FT >::NumGroups, Backflow_ee< FT >::RadFun, and Backflow_ee< FT >::uniqueRadFun.

   {
     if (first)
     {
       // initialize all with rf the first time
       for (int i = 0; i < RadFun.size(); i++)
         RadFun[i] = rf.get();
       first = false;
     }
     else
     {
       RadFun[ia * NumGroups + ib] = rf.get();
       RadFun[ib * NumGroups + ia] = rf.get();
     }
     uniqueRadFun.push_back(std::move(rf));
   }

◆ checkInVariables()

void checkInVariables ( opt_variables_type & active )

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 129 of file Backflow_ee.h.

References Backflow_ee< FT >::uniqueRadFun.

   {
     for (int i = 0; i < uniqueRadFun.size(); i++)
       uniqueRadFun[i]->checkInVariablesExclusive(active);
   }

◆ checkOutVariables()

void checkOutVariables ( const opt_variables_type & active )

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 135 of file Backflow_ee.h.

References Backflow_ee< FT >::uniqueRadFun.

   {
     for (int i = 0; i < uniqueRadFun.size(); i++)
       uniqueRadFun[i]->checkOutVariables(active);
   }

◆ evaluate() [1/3]

void evaluate	(	const ParticleSet &	P,
		ParticleSet &	QP
	)

inlineoverridevirtual

calculate quasi-particle coordinates only

Implements BackflowFunctionBase.

Definition at line 233 of file Backflow_ee.h.

References APP_ABORT.

   {
     APP_ABORT("Backflow_ee.h::evaluate(P,QP) not implemented for SoA\n");
     //RealType du, d2u;
     //const auto& myTable = P.getDistTableAA(myTableIndex_);
     //for (int i = 0; i < myTable.sources(); i++)
     //{
     //  for (int nn = myTable.M[i]; nn < myTable.M[i + 1]; nn++)
     //  {
     //    int j        = myTable.J[nn];
     //    RealType uij = RadFun[PairID(i, j)]->evaluate(myTable.r(nn), du, d2u);
     //    PosType u    = uij * myTable.dr(nn);
     //    QP.R[i] -= u; // dr(ij) = r_j-r_i
     //    QP.R[j] += u;
     //    UIJ(j, i) = u;
     //    UIJ(i, j) = -1.0 * u;
     //  }
     //}
   }

◆ evaluate() [2/3]

void evaluate	(	const ParticleSet &	P,
		ParticleSet &	QP,
		GradVector &	Bmat,
		HessMatrix &	Amat
	)

inline

Definition at line 253 of file Backflow_ee.h.

References APP_ABORT.

   {
     APP_ABORT("This shouldn't be called: Backflow_ee::evaluate(Bmat)");
     PosType du, d2u, temp;
     APP_ABORT("Backflow_ee.h::evaluate(P,QP,Bmat_vec,Amat) not implemented for SoA\n");
     //    const auto& myTable = P.getDistTableAA(myTableIndex_);
     //    for (int i = 0; i < myTable.sources(); i++)
     //    {
     //      for (int nn = myTable.M[i]; nn < myTable.M[i + 1]; nn++)
     //      {
     //        int j        = myTable.J[nn];
     //        RealType uij = RadFun[PairID(i, j)]->evaluate(myTable.r(nn), du, d2u);
     //        PosType u    = uij * myTable.dr(nn);
     //        // UIJ = eta(r) * (r_i - r_j)
     //        UIJ(j, i) = u;
     //        UIJ(i, j) = -1.0 * u;
     //        du *= myTable.rinv(nn);
     //        QP.R[i] -= u;
     //        QP.R[j] += u;
     ////          Amat(i,j) -= du*(outerProduct(myTable.dr(nn),myTable.dr(nn)));
     //#if OHMMS_DIM == 3
     //        Amat(i, j)[0] -= uij;
     //        Amat(i, j)[4] -= uij;
     //        Amat(i, j)[8] -= uij;
     //#elif OHMMS_DIM == 2
     //        Amat(i, j)[0] -= uij;
     //        Amat(i, j)[3] -= uij;
     //#endif
     //        Amat(j, i) += Amat(i, j);
     //        Amat(i, i) -= Amat(i, j);
     //        Amat(j, j) -= Amat(i, j);
     //        // this will create problems with QMC_COMPLEX, because Bmat is ValueType and dr is RealType
     //        u = 2.0 * (d2u + (OHMMS_DIM + 1.0) * du) * myTable.dr(nn);
     //        Bmat[i] -= u;
     //        Bmat[j] += u;
     //      }
     //    }
   }

◆ evaluate() [3/3]

void evaluate	(	const ParticleSet &	P,
		ParticleSet &	QP,
		GradMatrix &	Bmat_full,
		HessMatrix &	Amat
	)

inlineoverridevirtual

calculate quasi-particle coordinates, Bmat and Amat

Implements BackflowFunctionBase.

Definition at line 295 of file Backflow_ee.h.

References BackflowFunctionBase::AIJ, BackflowFunctionBase::BIJ, ParticleSet::first(), DistanceTableAA::getDistRow(), ParticleSet::getDistTableAA(), ParticleSet::last(), Backflow_ee< FT >::myTableIndex_, Backflow_ee< FT >::NumGroups, OHMMS_DIM, qmcplusplus::outerProduct(), Backflow_ee< FT >::PairID, ParticleSet::R, Backflow_ee< FT >::RadFun, and BackflowFunctionBase::UIJ.

   {
     RealType du, d2u;
     const auto& myTable = P.getDistTableAA(myTableIndex_);
     for (int ig = 0; ig < NumGroups; ++ig)
     {
       for (int iat = P.first(ig), last = P.last(ig); iat < last; ++iat)
       {
         const auto& dist  = myTable.getDistRow(iat);
         const auto& displ = myTable.getDisplRow(iat);
         for (int jat = 0; jat < iat; ++jat)
         {
           if (dist[jat] > 0)
           {
             RealType uij = RadFun[PairID(iat, jat)]->evaluate(dist[jat], du, d2u);
             du /= dist[jat];
             PosType u     = uij * displ[jat];
             UIJ(jat, iat) = u;
             UIJ(iat, jat) = -1.0 * u;
             QP.R[iat] -= u;
             QP.R[jat] += u;
             HessType& hess = AIJ(iat, jat);
             hess           = du * outerProduct(displ[jat], displ[jat]);
 #if OHMMS_DIM == 3
             hess[0] += uij;
             hess[4] += uij;
             hess[8] += uij;
 #elif OHMMS_DIM == 2
             hess[0] += uij;
             hess[3] += uij;
 #endif
             AIJ(jat, iat) = hess;
             Amat(iat, iat) += hess;
             Amat(jat, jat) += hess;
             Amat(iat, jat) -= hess;
             Amat(jat, iat) -= hess;
             GradType& grad = BIJ(jat, iat); // dr = r_j - r_i
             grad           = (d2u + (OHMMS_DIM + 1) * du) * displ[jat];
             BIJ(iat, jat)  = -1.0 * grad;
             Bmat_full(iat, iat) -= grad;
             Bmat_full(jat, jat) += grad;
             Bmat_full(iat, jat) += grad;
             Bmat_full(jat, iat) -= grad;
           }
         }
       }
     }
   }

◆ evaluateBmatOnly()

void evaluateBmatOnly	(	const ParticleSet &	P,
		GradMatrix &	Bmat_full
	)

inlineoverridevirtual

calculate only Bmat This is used in pbyp moves, in updateBuffer()

Implements BackflowFunctionBase.

Definition at line 608 of file Backflow_ee.h.

References APP_ABORT.

   {
     APP_ABORT("Backflow_ee.h::evaluateBmatOnly(P,QP,Bmat_full) not implemented for SoA\n");
     //RealType du, d2u;
     //const auto& myTable = P.getDistTableAA(myTableIndex_);
     //for (int i = 0; i < myTable.sources(); i++)
     //{
     //  for (int nn = myTable.M[i]; nn < myTable.M[i + 1]; nn++)
     //  {
     //    int j        = myTable.J[nn];
     //    RealType uij = RadFun[PairID(i, j)]->evaluate(myTable.r(nn), du, d2u);
     //    PosType u    = (d2u + (OHMMS_DIM + 1) * du * myTable.rinv(nn)) * myTable.dr(nn);
     //    Bmat_full(i, i) -= u;
     //    Bmat_full(j, j) += u;
     //    Bmat_full(i, j) += u;
     //    Bmat_full(j, i) -= u;
     //  }
     //}
   }

◆ evaluatePbyP() [1/6]

void evaluatePbyP	(	const ParticleSet &	P,
		ParticleSet::ParticlePos &	newQP,
		const std::vector< int > &	index
	)

inlineoverridevirtual

calculate quasi-particle coordinates after pbyp move

Implements BackflowFunctionBase.

Definition at line 346 of file Backflow_ee.h.

References APP_ABORT.

   {
     APP_ABORT("Backflow_ee.h::evaluatePbyP(P,QP,index_vec) not implemented for SoA\n");
     //RealType du, d2u;
     //const auto& myTable = P.getDistTableAA(myTableIndex_);
     //int maxI            = index.size();
     //int iat             = index[0];
     //for (int i = 1; i < maxI; i++)
     //{
     //  int j        = index[i];
     //  RealType uij = RadFun[PairID(iat, j)]->evaluate(myTable.Temp[j].r1, du, d2u);
     //  PosType u    = (UIJ_temp[j] = uij * myTable.Temp[j].dr1) - UIJ(iat, j);
     //  newQP[iat] += u;
     //  newQP[j] -= u;
     //}
   }

◆ evaluatePbyP() [2/6]

void evaluatePbyP	(	const ParticleSet &	P,
		int	iat,
		ParticleSet::ParticlePos &	newQP
	)

inlineoverridevirtual

calculate quasi-particle coordinates after pbyp move

Implements BackflowFunctionBase.

Definition at line 367 of file Backflow_ee.h.

References ParticleSet::getDistTableAA(), Backflow_ee< FT >::myTableIndex_, BackflowFunctionBase::NumTargets, Backflow_ee< FT >::PairID, Backflow_ee< FT >::RadFun, BackflowFunctionBase::UIJ, and BackflowFunctionBase::UIJ_temp.

   {
     RealType du, d2u;
     const auto& myTable = P.getDistTableAA(myTableIndex_);
     for (int i = 0; i < iat; i++)
     {
       // Temp[j].dr1 = (ri - rj)
       RealType uij = RadFun[PairID(iat, i)]->evaluate(myTable.getTempDists()[i], du, d2u);
       PosType u    = (UIJ_temp[i] = -uij * myTable.getTempDispls()[i]) - UIJ(iat, i);
       newQP[iat] += u;
       newQP[i] -= u;
     }
     for (int i = iat + 1; i < NumTargets; i++)
     {
       // Temp[j].dr1 = (ri - rj)
       RealType uij = RadFun[PairID(iat, i)]->evaluate(myTable.getTempDists()[i], du, d2u);
       PosType u    = (UIJ_temp[i] = -uij * myTable.getTempDispls()[i]) - UIJ(iat, i);
       newQP[iat] += u;
       newQP[i] -= u;
     }
   }

◆ evaluatePbyP() [3/6]

void evaluatePbyP	(	const ParticleSet &	P,
		ParticleSet::ParticlePos &	newQP,
		const std::vector< int > &	index,
		HessMatrix &	Amat
	)

inlineoverridevirtual

calculate quasi-particle coordinates and Amat after pbyp move

Implements BackflowFunctionBase.

Definition at line 391 of file Backflow_ee.h.

References APP_ABORT.

   {
     APP_ABORT("Backflow_ee.h::evaluatePbyP(P,QP,index_vec,Amat) not implemented for SoA\n");
     //    RealType du, d2u;
     //    const auto& myTable = P.getDistTableAA(myTableIndex_);
     //    int maxI            = index.size();
     //    int iat             = index[0];
     //    for (int i = 1; i < maxI; i++)
     //    {
     //      int j        = index[i];
     //      RealType uij = RadFun[PairID(iat, j)]->evaluate(myTable.Temp[j].r1, du, d2u);
     //      PosType u    = (UIJ_temp[j] = uij * myTable.Temp[j].dr1) - UIJ(iat, j);
     //      newQP[iat] += u;
     //      newQP[j] -= u;
     //      HessType& hess = AIJ_temp[j];
     //      hess           = (du * myTable.Temp[j].rinv1) * outerProduct(myTable.Temp[j].dr1, myTable.Temp[j].dr1);
     //#if OHMMS_DIM == 3
     //      hess[0] += uij;
     //      hess[4] += uij;
     //      hess[8] += uij;
     //#elif OHMMS_DIM == 2
     //      hess[0] += uij;
     //      hess[3] += uij;
     //#endif
     //      HessType dA = hess - AIJ(iat, j);
     //      Amat(iat, iat) += dA;
     //      Amat(j, j) += dA;
     //      Amat(iat, j) -= dA;
     //      Amat(j, iat) -= dA;
     //    }
   }

◆ evaluatePbyP() [4/6]

void evaluatePbyP	(	const ParticleSet &	P,
		int	iat,
		ParticleSet::ParticlePos &	newQP,
		HessMatrix &	Amat
	)

inlineoverridevirtual

calculate quasi-particle coordinates and Amat after pbyp move

Implements BackflowFunctionBase.

Definition at line 428 of file Backflow_ee.h.

References BackflowFunctionBase::AIJ, BackflowFunctionBase::AIJ_temp, ParticleSet::getDistTableAA(), Backflow_ee< FT >::myTableIndex_, BackflowFunctionBase::NumTargets, qmcplusplus::outerProduct(), Backflow_ee< FT >::PairID, Backflow_ee< FT >::RadFun, BackflowFunctionBase::UIJ, and BackflowFunctionBase::UIJ_temp.

   {
     RealType du, d2u;
     const auto& myTable = P.getDistTableAA(myTableIndex_);
     for (int j = 0; j < iat; j++)
     {
       if (myTable.getTempDists()[j] > 0)
       {
         RealType uij = RadFun[PairID(iat, j)]->evaluate(myTable.getTempDists()[j], du, d2u);
         PosType u    = (UIJ_temp[j] = -uij * myTable.getTempDispls()[j]) - UIJ(iat, j);
         newQP[iat] += u;
         newQP[j] -= u;
         HessType& hess = AIJ_temp[j];
         hess = (du / myTable.getTempDists()[j]) * outerProduct(myTable.getTempDispls()[j], myTable.getTempDispls()[j]);
 #if OHMMS_DIM == 3
         hess[0] += uij;
         hess[4] += uij;
         hess[8] += uij;
 #elif OHMMS_DIM == 2
         hess[0] += uij;
         hess[3] += uij;
 #endif
         HessType dA = hess - AIJ(iat, j);
         Amat(iat, iat) += dA;
         Amat(j, j) += dA;
         Amat(iat, j) -= dA;
         Amat(j, iat) -= dA;
       }
     }
     for (int j = iat + 1; j < NumTargets; j++)
     {
       if (myTable.getTempDists()[j] > 0)
       {
         RealType uij = RadFun[PairID(iat, j)]->evaluate(myTable.getTempDists()[j], du, d2u);
         PosType u    = (UIJ_temp[j] = -uij * myTable.getTempDispls()[j]) - UIJ(iat, j);
         newQP[iat] += u;
         newQP[j] -= u;
         HessType& hess = AIJ_temp[j];
         hess = (du / myTable.getTempDists()[j]) * outerProduct(myTable.getTempDispls()[j], myTable.getTempDispls()[j]);
 #if OHMMS_DIM == 3
         hess[0] += uij;
         hess[4] += uij;
         hess[8] += uij;
 #elif OHMMS_DIM == 2
         hess[0] += uij;
         hess[3] += uij;
 #endif
         HessType dA = hess - AIJ(iat, j);
         Amat(iat, iat) += dA;
         Amat(j, j) += dA;
         Amat(iat, j) -= dA;
         Amat(j, iat) -= dA;
       }
     }
   }

◆ evaluatePbyP() [5/6]

void evaluatePbyP	(	const ParticleSet &	P,
		ParticleSet::ParticlePos &	newQP,
		const std::vector< int > &	index,
		GradMatrix &	Bmat,
		HessMatrix &	Amat
	)

inlineoverridevirtual

calculate quasi-particle coordinates and Amat after pbyp move

Implements BackflowFunctionBase.

Definition at line 486 of file Backflow_ee.h.

References APP_ABORT.

   {
     APP_ABORT("Backflow_ee.h::evaluatePbyP(P,QP,index_vec,Bmat,Amat) not implemented for SoA\n");
     //    RealType du, d2u;
     //    const auto& myTable                                     = P.getDistTableAA(myTableIndex_);
     //    int maxI                                                = index.size();
     //    int iat                                                 = index[0];
     //    const std::vector<DistanceTable::TempDistType>& TMP = myTable.Temp;
     //    for (int i = 1; i < maxI; i++)
     //    {
     //      int j        = index[i];
     //      RealType uij = RadFun[PairID(iat, j)]->evaluate(TMP[j].r1, du, d2u);
     //      PosType u    = (UIJ_temp[j] = uij * TMP[j].dr1) - UIJ(iat, j);
     //      newQP[iat] += u;
     //      newQP[j] -= u;
     //      du *= TMP[j].rinv1;
     //      HessType& hess = AIJ_temp[j];
     //      hess           = du * outerProduct(TMP[j].dr1, TMP[j].dr1);
     //#if OHMMS_DIM == 3
     //      hess[0] += uij;
     //      hess[4] += uij;
     //      hess[8] += uij;
     //#elif OHMMS_DIM == 2
     //      hess[0] += uij;
     //      hess[3] += uij;
     //#endif
     //      HessType dA = hess - AIJ(iat, j);
     //      Amat(iat, iat) += dA;
     //      Amat(j, j) += dA;
     //      Amat(iat, j) -= dA;
     //      Amat(j, iat) -= dA;
     //      GradType& grad = BIJ_temp[j]; // dr = r_iat - r_j
     //      grad           = (d2u + (OHMMS_DIM + 1) * du) * TMP[j].dr1;
     //      GradType dg    = grad - BIJ(iat, j);
     //      Bmat(iat, iat) += dg;
     //      Bmat(j, j) -= dg;
     //      Bmat(iat, j) -= dg;
     //      Bmat(j, iat) += dg;
     //    }
   }

◆ evaluatePbyP() [6/6]

void evaluatePbyP	(	const ParticleSet &	P,
		int	iat,
		ParticleSet::ParticlePos &	newQP,
		GradMatrix &	Bmat,
		HessMatrix &	Amat
	)

inlineoverridevirtual

calculate quasi-particle coordinates and Amat after pbyp move

Implements BackflowFunctionBase.

Definition at line 533 of file Backflow_ee.h.

References APP_ABORT.

   {
     APP_ABORT("Backflow_ee.h::evaluatePbyP(P,iat,QP,Bmat,Amat) not implemented for SoA\n");
     //    RealType du, d2u;
     //    const auto& myTable                                     = P.getDistTableAA(myTableIndex_);
     //    const std::vector<DistanceTable::TempDistType>& TMP = myTable.Temp;
     //    for (int j = 0; j < iat; j++)
     //    {
     //      RealType uij = RadFun[PairID(iat, j)]->evaluate(TMP[j].r1, du, d2u);
     //      PosType u    = (UIJ_temp[j] = uij * TMP[j].dr1) - UIJ(iat, j);
     //      newQP[iat] += u;
     //      newQP[j] -= u;
     //      du *= TMP[j].rinv1;
     //      HessType& hess = AIJ_temp[j];
     //      hess           = du * outerProduct(TMP[j].dr1, TMP[j].dr1);
     //#if OHMMS_DIM == 3
     //      hess[0] += uij;
     //      hess[4] += uij;
     //      hess[8] += uij;
     //#elif OHMMS_DIM == 2
     //      hess[0] += uij;
     //      hess[3] += uij;
     //#endif
     //      HessType dA = hess - AIJ(iat, j);
     //      Amat(iat, iat) += dA;
     //      Amat(j, j) += dA;
     //      Amat(iat, j) -= dA;
     //      Amat(j, iat) -= dA;
     //      GradType& grad = BIJ_temp[j]; // dr = r_iat - r_j
     //      grad           = (d2u + (OHMMS_DIM + 1) * du) * TMP[j].dr1;
     //      GradType dg    = grad - BIJ(iat, j);
     //      Bmat(iat, iat) += dg;
     //      Bmat(j, j) -= dg;
     //      Bmat(iat, j) -= dg;
     //      Bmat(j, iat) += dg;
     //    }
     //    for (int j = iat + 1; j < NumTargets; j++)
     //    {
     //      RealType uij = RadFun[PairID(iat, j)]->evaluate(TMP[j].r1, du, d2u);
     //      PosType u    = (UIJ_temp[j] = uij * TMP[j].dr1) - UIJ(iat, j);
     //      newQP[iat] += u;
     //      newQP[j] -= u;
     //      du *= TMP[j].rinv1;
     //      HessType& hess = AIJ_temp[j];
     //      hess           = du * outerProduct(TMP[j].dr1, TMP[j].dr1);
     //#if OHMMS_DIM == 3
     //      hess[0] += uij;
     //      hess[4] += uij;
     //      hess[8] += uij;
     //#elif OHMMS_DIM == 2
     //      hess[0] += uij;
     //      hess[3] += uij;
     //#endif
     //      HessType dA = hess - AIJ(iat, j);
     //      Amat(iat, iat) += dA;
     //      Amat(j, j) += dA;
     //      Amat(iat, j) -= dA;
     //      Amat(j, iat) -= dA;
     //      GradType& grad = BIJ_temp[j]; // dr = r_iat - r_j
     //      grad           = (d2u + (OHMMS_DIM + 1) * du) * TMP[j].dr1;
     //      GradType dg    = grad - BIJ(iat, j);
     //      Bmat(iat, iat) += dg;
     //      Bmat(j, j) -= dg;
     //      Bmat(iat, j) -= dg;
     //      Bmat(j, iat) += dg;
     //    }
   }

◆ evaluateWithDerivatives()

void evaluateWithDerivatives	(	const ParticleSet &	P,
		ParticleSet &	QP,
		GradMatrix &	Bmat_full,
		HessMatrix &	Amat,
		GradMatrix &	Cmat,
		GradMatrix &	Ymat,
		HessArray &	Xmat
	)

inlineoverridevirtual

calculate quasi-particle coordinates, Bmat and Amat calculate derivatives wrt to variational parameters

Implements BackflowFunctionBase.

Definition at line 631 of file Backflow_ee.h.

References BackflowFunctionBase::AIJ, BackflowFunctionBase::BIJ, ParticleSet::first(), DistanceTableAA::getDistRow(), ParticleSet::getDistTableAA(), BackflowFunctionBase::indexOfFirstParam, ParticleSet::last(), Backflow_ee< FT >::myTableIndex_, Backflow_ee< FT >::NumGroups, Backflow_ee< FT >::offsetPrms, OHMMS_DIM, qmcplusplus::outerProduct(), Backflow_ee< FT >::PairID, ParticleSet::R, Backflow_ee< FT >::RadFun, and BackflowFunctionBase::UIJ.

   {
     RealType du, d2u;
     const auto& myTable = P.getDistTableAA(myTableIndex_);
     for (int ig = 0; ig < NumGroups; ++ig)
     {
       for (int iat = P.first(ig), last = P.last(ig); iat < last; ++iat)
       {
         const auto& dist  = myTable.getDistRow(iat);
         const auto& displ = myTable.getDisplRow(iat);
         for (int jat = 0; jat < iat; ++jat)
         {
           if (dist[jat] > 0)
           {
             RealType uij = RadFun[PairID(iat, jat)]->evaluate(dist[jat], du, d2u);
             //for(int q=0; q<derivs.size(); q++) derivs[q]=0.0; // I believe this is necessary
             //           std::fill(derivs.begin(),derivs.end(),0.0);
             int numParamJU = RadFun[PairID(iat, jat)]->NumParams;
             std::vector<TinyVector<RealType, 3>> derivsju(numParamJU);
             RadFun[PairID(iat, jat)]->evaluateDerivatives(dist[jat], derivsju);
             du /= dist[jat];
             PosType u     = uij * displ[jat];
             UIJ(jat, iat) = u;
             UIJ(iat, jat) = -1.0 * u;
             QP.R[iat] -= u;
             QP.R[jat] += u;
             HessType op    = outerProduct(displ[jat], displ[jat]);
             HessType& hess = AIJ(iat, jat);
             hess           = du * op;
 #if OHMMS_DIM == 3
             hess[0] += uij;
             hess[4] += uij;
             hess[8] += uij;
 #elif OHMMS_DIM == 2
             hess[0] += uij;
             hess[3] += uij;
 #endif
             Amat(iat, iat) += hess;
             Amat(jat, jat) += hess;
             Amat(iat, jat) -= hess;
             Amat(jat, iat) -= hess;
             // this will create problems with QMC_COMPLEX, because Bmat is ValueType and dr is RealType
             // d2u + (ndim+1)*du
             GradType& grad = BIJ(jat, iat); // dr = r_j - r_i
             grad           = (d2u + (OHMMS_DIM + 1) * du) * displ[jat];
             BIJ(iat, jat)  = -1.0 * grad;
             Bmat_full(iat, iat) -= grad;
             Bmat_full(jat, jat) += grad;
             Bmat_full(iat, jat) += grad;
             Bmat_full(jat, iat) -= grad;
             for (int prm = 0, la = indexOfFirstParam + offsetPrms[PairID(iat, jat)]; prm < numParamJU; prm++, la++)
             {
               PosType uk = displ[jat] * derivsju[prm][0];
               Cmat(la, iat) -= uk;
               Cmat(la, jat) += uk;
               Xmat(la, iat, jat) -= (derivsju[prm][1] / dist[jat]) * op;
 #if OHMMS_DIM == 3
               Xmat(la, iat, jat)[0] -= derivsju[prm][0];
               Xmat(la, iat, jat)[4] -= derivsju[prm][0];
               Xmat(la, iat, jat)[8] -= derivsju[prm][0];
 #elif OHMMS_DIM == 2
               Xmat(la, iat, jat)[0] -= derivsju[prm][0];
               Xmat(la, iat, jat)[3] -= derivsju[prm][0];
 #endif
               Xmat(la, jat, iat) += Xmat(la, iat, jat);
               Xmat(la, iat, iat) -= Xmat(la, iat, jat);
               Xmat(la, jat, jat) -= Xmat(la, iat, jat);
               uk = 2.0 * (derivsju[prm][2] + (OHMMS_DIM + 1) * derivsju[prm][1] / dist[jat]) * displ[jat];
               Ymat(la, iat) -= uk;
               Ymat(la, jat) += uk;
             }
           }
         }
       }
     }
   }

◆ indexOffset()

int indexOffset ( )

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 149 of file Backflow_ee.h.

References Backflow_ee< FT >::RadFun.

149 { return RadFun[0]->myVars.where(0); }

qmcplusplus::Backflow_ee::RadFun

std::vector< FT * > RadFun

Definition: Backflow_ee.h:34

◆ isOptimizable()

bool isOptimizable ( )

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 141 of file Backflow_ee.h.

References Backflow_ee< FT >::uniqueRadFun.

   {
     for (int i = 0; i < uniqueRadFun.size(); i++)
       if (uniqueRadFun[i]->isOptimizable())
         return true;
     return false;
   }

◆ makeClone()

std::unique_ptr<BackflowFunctionBase> makeClone ( ParticleSet & tqp ) const

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 56 of file Backflow_ee.h.

References APP_ABORT, qmcplusplus::clone, BackflowFunctionBase::derivs, BLAS::done, BackflowFunctionBase::numParams, BackflowFunctionBase::NumTargets, Backflow_ee< FT >::offsetPrms, Backflow_ee< FT >::RadFun, and Backflow_ee< FT >::uniqueRadFun.

   {
     auto clone   = std::make_unique<Backflow_ee<FT>>(tqp, tqp);
     clone->first = false;
     clone->resize(NumTargets, NumTargets);
     clone->offsetPrms = offsetPrms;
     clone->numParams  = numParams;
     clone->derivs     = derivs;
     clone->offsetPrms = offsetPrms;
     clone->uniqueRadFun.resize(uniqueRadFun.size());
     clone->RadFun.resize(RadFun.size());
     for (int i = 0; i < uniqueRadFun.size(); i++)
       clone->uniqueRadFun[i] = std::make_unique<FT>(*(uniqueRadFun[i]));
     for (int i = 0; i < RadFun.size(); i++)
     {
       bool done = false;
       for (int k = 0; k < uniqueRadFun.size(); k++)
         if (RadFun[i] == uniqueRadFun[k].get())
         {
           done             = true;
           clone->RadFun[i] = clone->uniqueRadFun[k].get();
           break;
         }
       if (!done)
       {
         APP_ABORT("Error cloning Backflow_ee object. \n");
       }
     }
     return clone;
   }

◆ registerData()

void registerData ( WFBufferType & buf )

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 104 of file Backflow_ee.h.

References PooledMemory< T_scalar, Alloc >::add(), BackflowFunctionBase::AIJ, BackflowFunctionBase::BIJ, BackflowFunctionBase::FirstOfA, BackflowFunctionBase::FirstOfB, BackflowFunctionBase::FirstOfU, BackflowFunctionBase::LastOfA, BackflowFunctionBase::LastOfB, BackflowFunctionBase::LastOfU, BackflowFunctionBase::NumTargets, OHMMS_DIM, and BackflowFunctionBase::UIJ.

   {
     FirstOfU = &(UIJ(0, 0)[0]);
     LastOfU  = FirstOfU + OHMMS_DIM * NumTargets * NumTargets;
     FirstOfA = &(AIJ(0, 0)[0]);
     LastOfA  = FirstOfA + OHMMS_DIM * OHMMS_DIM * NumTargets * NumTargets;
     FirstOfB = &(BIJ(0, 0)[0]);
     LastOfB  = FirstOfB + OHMMS_DIM * NumTargets * NumTargets;
     buf.add(FirstOfU, LastOfU);
     buf.add(FirstOfA, LastOfA);
     buf.add(FirstOfB, LastOfB);
   }

◆ reportStatus()

void reportStatus ( std::ostream & os )

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 117 of file Backflow_ee.h.

References Backflow_ee< FT >::uniqueRadFun.

   {
     for (int i = 0; i < uniqueRadFun.size(); i++)
       uniqueRadFun[i]->reportStatus(os);
   }

◆ resetParameters()

void resetParameters ( const opt_variables_type & active )

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 123 of file Backflow_ee.h.

References Backflow_ee< FT >::uniqueRadFun.

   {
     for (int i = 0; i < uniqueRadFun.size(); i++)
       uniqueRadFun[i]->resetParametersExclusive(active);
   }

◆ restore()

void restore	(	int	iat,
		int	UpdateType
	)

inlineoverridevirtual

Implements BackflowFunctionBase.

Definition at line 224 of file Backflow_ee.h.

References BackflowFunctionBase::AIJ_temp, BackflowFunctionBase::BIJ_temp, and BackflowFunctionBase::UIJ_temp.

   {
     UIJ_temp = 0.0;
     AIJ_temp = 0.0;
     BIJ_temp = 0.0;
   }

Member Data Documentation

◆ first

bool first

Definition at line 39 of file Backflow_ee.h.

Referenced by Backflow_ee< FT >::addFunc().

◆ myTableIndex_

const int myTableIndex_

private

distance table index

Definition at line 30 of file Backflow_ee.h.

Referenced by Backflow_ee< FT >::evaluate(), Backflow_ee< FT >::evaluatePbyP(), and Backflow_ee< FT >::evaluateWithDerivatives().

◆ NumGroups

int NumGroups

Definition at line 37 of file Backflow_ee.h.

Referenced by Backflow_ee< FT >::addFunc(), Backflow_ee< FT >::Backflow_ee(), Backflow_ee< FT >::evaluate(), and Backflow_ee< FT >::evaluateWithDerivatives().

◆ offsetPrms

std::vector<int> offsetPrms

Definition at line 36 of file Backflow_ee.h.

Referenced by Backflow_ee< FT >::Backflow_ee(), Backflow_ee< FT >::evaluateWithDerivatives(), and Backflow_ee< FT >::makeClone().

◆ PairID

Matrix<int> PairID

Definition at line 38 of file Backflow_ee.h.

Referenced by Backflow_ee< FT >::Backflow_ee(), Backflow_ee< FT >::evaluate(), Backflow_ee< FT >::evaluatePbyP(), and Backflow_ee< FT >::evaluateWithDerivatives().

◆ RadFun

std::vector<FT*> RadFun

Definition at line 34 of file Backflow_ee.h.

Referenced by Backflow_ee< FT >::addFunc(), Backflow_ee< FT >::Backflow_ee(), Backflow_ee< FT >::evaluate(), Backflow_ee< FT >::evaluatePbyP(), Backflow_ee< FT >::evaluateWithDerivatives(), Backflow_ee< FT >::indexOffset(), and Backflow_ee< FT >::makeClone().

◆ uniqueRadFun

std::vector<std::unique_ptr<FT> > uniqueRadFun

Definition at line 35 of file Backflow_ee.h.

Referenced by Backflow_ee< FT >::addFunc(), Backflow_ee< FT >::checkInVariables(), Backflow_ee< FT >::checkOutVariables(), Backflow_ee< FT >::isOptimizable(), Backflow_ee< FT >::makeClone(), Backflow_ee< FT >::reportStatus(), and Backflow_ee< FT >::resetParameters().

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

/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCWaveFunctions/Fermion/Backflow_ee.h

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

template<class FT> class qmcplusplus::Backflow_ee< FT >

Constructor & Destructor Documentation

◆ Backflow_ee()

Member Function Documentation

◆ acceptMove()

◆ addFunc()

◆ checkInVariables()

◆ checkOutVariables()

◆ evaluate() [1/3]

◆ evaluate() [2/3]

◆ evaluate() [3/3]

◆ evaluateBmatOnly()

◆ evaluatePbyP() [1/6]

◆ evaluatePbyP() [2/6]

◆ evaluatePbyP() [3/6]

◆ evaluatePbyP() [4/6]

◆ evaluatePbyP() [5/6]

◆ evaluatePbyP() [6/6]

◆ evaluateWithDerivatives()

◆ indexOffset()

◆ isOptimizable()

◆ makeClone()

◆ registerData()

◆ reportStatus()

◆ resetParameters()

◆ restore()

Member Data Documentation

◆ first

◆ myTableIndex_

◆ NumGroups

◆ offsetPrms

◆ PairID

◆ RadFun

◆ uniqueRadFun

template<class FT>
class qmcplusplus::Backflow_ee< FT >