Inheritance diagram for LRHandlerTemp< Func, BreakupBasis >:

Collaboration diagram for LRHandlerTemp< Func, BreakupBasis >:

Public Types
using	ParticleLayout = ParticleSet::ParticleLayout

using	BreakupBasisType = BreakupBasis

Public Member Functions
	LRHandlerTemp (ParticleSet &ref, mRealType kc_in=-1.0)

	LRHandlerTemp (const LRHandlerTemp &aLR, ParticleSet &ref)
	"copy" constructor More...

LRHandlerBase *	makeClone (ParticleSet &ref) const override
	make clone More...

void	initBreakup (ParticleSet &ref) override

void	Breakup (ParticleSet &ref, mRealType rs_ext) override

void	resetTargetParticleSet (ParticleSet &ref) override

void	resetTargetParticleSet (ParticleSet &ref, mRealType rs)

mRealType	evaluate (mRealType r, mRealType rinv) const override

mRealType	srDf (mRealType r, mRealType rinv) const override
	evaluate the first derivative of the short range part at r More...

mRealType	evaluate_vlr_k (mRealType k) const override

mRealType	evaluateLR (mRealType r) const override
	evaluate the contribution from the long-range part for for spline More...

mRealType	lrDf (mRealType r) const override
	evaluate the contribution from the long-range part for for spline More...

mRealType	evaluateSR_k0 () const override
	evaluate $v_{s}(k=0) = \frac{4\pi}{V}\int_0^{r_c} r^2 v_s(r) dr$ More...

mRealType	evaluateLR_r0 () const override
	evaluate for the self-interaction term More...

Public Member Functions inherited from LRHandlerBase
	LRHandlerBase (mRealType kc)

virtual	~LRHandlerBase ()=default

mRealType	get_rc () const

mRealType	get_kc () const

mRealType	evaluate_w_sk (const std::vector< int > &kshell, const pRealType *restrict sk) const

mRealType	evaluate (const std::vector< int > &kshell, const pRealType restrict rk1_r, const pRealType restrict rk1_i, const pRealType restrict rk2_r, const pRealType restrict rk2_i) const
	evaluate $\sum_k F_{k} \rho^1_{-{\bf k}} \rho^2_{\bf k}$ More...

virtual mRealType	evaluate_slab (pRealType z, const std::vector< int > &kshell, const pRealType restrict rk1_r, const pRealType restrict rk1_i, const pRealType restrict rk2_r, const pRealType restrict rk2_i) const
	Evaluate the long-range potential with the open BC for the D-1 direction. More...

void	evaluateGrad (const ParticleSet &A, const ParticleSet &B, int specB, std::vector< pRealType > &Zat, std::vector< TinyVector< pRealType, OHMMS_DIM >> &grad1) const
	evaluate $\sum_k F_{k} \rho^1_{-{\bf k}} \rho^2_{\bf k}$ and $\sum_k F_{k} \rho^1_{-{\bf k}} \rho^2_{\bf k}$ More...

SymTensor< pRealType, OHMMS_DIM >	evaluateStress (const std::vector< int > &kshell, const pRealType rhokA_r, const pRealType rhokA_i, const pRealType rhokB_r, const pRealType rhokB_i) const
	FIX_PRECISION. More...

virtual SymTensor< mRealType, OHMMS_DIM >	evaluateLR_r0_dstrain () const
	These functions return the strain derivatives of all corresponding quantities in total energy. More...

virtual SymTensor< mRealType, OHMMS_DIM >	evaluateSR_k0_dstrain () const

virtual SymTensor< mRealType, OHMMS_DIM >	evaluateLR_dstrain (TinyVector< pRealType, OHMMS_DIM > k, pRealType kmag) const

virtual SymTensor< mRealType, OHMMS_DIM >	evaluateSR_dstrain (TinyVector< pRealType, OHMMS_DIM > r, pRealType rmag) const

Public Attributes
bool	FirstTime

mRealType	rs

BreakupBasisType	Basis

Func	myFunc

Public Attributes inherited from LRHandlerBase
DECLARE_COULOMB_TYPES int	MaxKshell
	Maxkimum Kshell for the given Kc. More...

mRealType	LR_kc
	Maximum k cutoff. More...

mRealType	LR_rc
	Maximum r cutoff. More...

Vector< mRealType >	Fk
	Fourier component for all the k-point. More...

Vector< mRealType >	Fkg
	Fourier component of the LR part, fit to optimize the gradients. More...

std::vector< SymTensor< mRealType, OHMMS_DIM > >	dFk_dstrain
	Fourier component of the LR part of strain tensor, by optimized breakup. More...

Vector< mRealType >	Fkgstrain
	Vector of df_k/dk, fit as to optimize strains. More...

Vector< mRealType >	Fk_symm
	Fourier component for each k-shell. More...

std::vector< mRealType >	coefs
	Fourier component for each k-shell Coefficient. More...

std::vector< mRealType >	gcoefs
	Coefficient for gradient fit. More...

std::vector< mRealType >	gstraincoefs
	Coefficient for strain fit. More...

Private Member Functions
mRealType	evalFk (mRealType k) const

mRealType	evalXk (mRealType k) const

void	InitBreakup (const ParticleLayout &ref, int NumFunctions)
	Initialise the basis and coefficients for the long-range beakup. More...

void	fillXk (std::vector< TinyVector< mRealType, 2 >> &KList)

void	fillFk (const KContainer &KList)

Additional Inherited Members
Protected Attributes inherited from LRHandlerBase
std::string	ClassName

Detailed Description

template<class Func, class BreakupBasis = LPQHIBasis>
class qmcplusplus::LRHandlerTemp< Func, BreakupBasis >

Definition at line 40 of file LRHandlerTemp.h.

Member Typedef Documentation

◆ BreakupBasisType

using BreakupBasisType = BreakupBasis

Definition at line 45 of file LRHandlerTemp.h.

◆ ParticleLayout

using ParticleLayout = ParticleSet::ParticleLayout

Definition at line 44 of file LRHandlerTemp.h.

Constructor & Destructor Documentation

◆ LRHandlerTemp() [1/2]

LRHandlerTemp	(	ParticleSet &	ref,
		mRealType	kc_in = `-1.0`
	)

inline

Definition at line 54 of file LRHandlerTemp.h.

References LRHandlerBase::ClassName, and LRHandlerTemp< Func, BreakupBasis >::myFunc.

                                                           : LRHandlerBase(kc_in), FirstTime(true), Basis(ref.getLRBox())
   {
     LRHandlerBase::ClassName = "LRHandlerTemp";
     myFunc.reset(ref);
   }

◆ LRHandlerTemp() [2/2]

LRHandlerTemp	(	const LRHandlerTemp< Func, BreakupBasis > &	aLR,
		ParticleSet &	ref
	)

inline

"copy" constructor

Parameters

aLR	LRHandlerTemp
ref	Particleset

Copy the content of aLR References to ParticleSet or ParticleLayoutout_t are not copied.

Definition at line 72 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::myFunc.

       : LRHandlerBase(aLR), FirstTime(true), Basis(aLR.Basis, ref.getLRBox())
   {
     myFunc.reset(ref);
   }

Member Function Documentation

◆ Breakup()

void Breakup	(	ParticleSet &	ref,
		mRealType	rs_ext
	)

inlineoverridevirtual

Implements LRHandlerBase.

Definition at line 90 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerTemp< Func, BreakupBasis >::fillFk(), ParticleSet::getLRBox(), ParticleSet::getSimulationCell(), LRHandlerTemp< Func, BreakupBasis >::InitBreakup(), LRHandlerBase::LR_rc, LRHandlerTemp< Func, BreakupBasis >::myFunc, and LRHandlerTemp< Func, BreakupBasis >::rs.

   {
     //ref.getLRBox().Volume=ref.getTotalNum()*4.0*M_PI/3.0*rs*rs*rs;
     rs = rs_ext;
     myFunc.reset(ref, rs);
     InitBreakup(ref.getLRBox(), 1);
     fillFk(ref.getSimulationCell().getKLists());
     LR_rc = Basis.get_rc();
   }

◆ evalFk()

mRealType evalFk ( mRealType k ) const

inlineprivate

Definition at line 183 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerBase::coefs, LRHandlerTemp< Func, BreakupBasis >::myFunc, and qmcplusplus::n.

Referenced by LRHandlerTemp< Func, BreakupBasis >::evaluate_vlr_k(), and LRHandlerTemp< Func, BreakupBasis >::fillFk().

   {
     //FatK = 4.0*M_PI/(Basis.get_CellVolume()*k*k)* std::cos(k*Basis.get_rc());
     mRealType FatK = myFunc.Fk(k, Basis.get_rc());
     for (int n = 0; n < Basis.NumBasisElem(); n++)
       FatK += coefs[n] * Basis.c(n, k);
     return FatK;
   }

◆ evaluate()

mRealType evaluate	(	mRealType	r,
		mRealType	rinv
	)		const

inlineoverridevirtual

Implements LRHandlerBase.

Definition at line 104 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerBase::coefs, LRHandlerBase::LR_rc, LRHandlerTemp< Func, BreakupBasis >::myFunc, and qmcplusplus::n.

Referenced by qmcplusplus::TEST_CASE().

   {
     mRealType v = 0.0;
     if (r >= LR_rc)
       return v;
     v = myFunc(r, rinv);
     for (int n = 0; n < coefs.size(); n++)
       v -= coefs[n] * Basis.h(n, r);
     return v;
   }

◆ evaluate_vlr_k()

mRealType evaluate_vlr_k ( mRealType k ) const

inlineoverridevirtual

Implements LRHandlerBase.

Definition at line 133 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::evalFk().

133 { return evalFk(k); }

qmcplusplus::LRHandlerTemp::evalFk

mRealType evalFk(mRealType k) const

Definition: LRHandlerTemp.h:183

◆ evaluateLR()

mRealType evaluateLR ( mRealType r ) const

inlineoverridevirtual

evaluate the contribution from the long-range part for for spline

Implements LRHandlerBase.

Definition at line 138 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerBase::coefs, LRHandlerBase::LR_rc, LRHandlerTemp< Func, BreakupBasis >::myFunc, and qmcplusplus::n.

Referenced by qmcplusplus::TEST_CASE().

   {
     mRealType v = 0.0;
     if (r >= LR_rc)
       return myFunc(r, 1. / r);
     for (int n = 0; n < coefs.size(); n++)
       v += coefs[n] * Basis.h(n, r);
     return v;
   }

◆ evaluateLR_r0()

mRealType evaluateLR_r0 ( ) const

inlineoverridevirtual

evaluate $ v_s(r=0) $ for the self-interaction term

Reimplemented from LRHandlerBase.

Definition at line 174 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerBase::coefs, and qmcplusplus::n.

   {
     mRealType v0 = 0.0;
     for (int n = 0; n < coefs.size(); n++)
       v0 += coefs[n] * Basis.h(n, 0.0);
     return v0;
   }

◆ evaluateSR_k0()

mRealType evaluateSR_k0 ( ) const

inlineoverridevirtual

evaluate $v_{s}(k=0) = \frac{4\pi}{V}\int_0^{r_c} r^2 v_s(r) dr$

Reimplemented from LRHandlerBase.

Definition at line 166 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerBase::coefs, LRHandlerTemp< Func, BreakupBasis >::myFunc, and qmcplusplus::n.

   {
     mRealType v0 = myFunc.integrate_r2(Basis.get_rc());
     for (int n = 0; n < coefs.size(); n++)
       v0 -= coefs[n] * Basis.hintr2(n);
     return v0 * 2.0 * TWOPI / Basis.get_CellVolume();
   }

◆ evalXk()

mRealType evalXk ( mRealType k ) const

inlineprivate

Definition at line 191 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::Basis, and LRHandlerTemp< Func, BreakupBasis >::myFunc.

Referenced by LRHandlerTemp< Func, BreakupBasis >::fillXk().

   {
     //RealType FatK;
     //FatK = -4.0*M_PI/(Basis.get_CellVolume()*k*k)* std::cos(k*Basis.get_rc());
     //return (FatK);
     return myFunc.Xk(k, Basis.get_rc());
   }

◆ fillFk()

void fillFk ( const KContainer & KList )

inlineprivate

Definition at line 268 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::evalFk(), LRHandlerBase::Fk, LRHandlerBase::Fk_symm, KContainer::kpts_cart, KContainer::kshell, KContainer::ksq, LRHandlerBase::MaxKshell, Vector< T, Alloc >::resize(), Vector< T, Alloc >::size(), and qmcplusplus::sqrt().

Referenced by LRHandlerTemp< Func, BreakupBasis >::Breakup(), and LRHandlerTemp< Func, BreakupBasis >::initBreakup().

   {
     Fk.resize(KList.kpts_cart.size());
     const std::vector<int>& kshell(KList.kshell);
     if (MaxKshell >= kshell.size())
       MaxKshell = kshell.size() - 1;
     Fk_symm.resize(MaxKshell);
     for (int ks = 0, ki = 0; ks < Fk_symm.size(); ks++)
     {
       mRealType uk = evalFk(std::sqrt(KList.ksq[ki]));
       Fk_symm[ks]  = uk;
       while (ki < KList.kshell[ks + 1] && ki < Fk.size())
         Fk[ki++] = uk;
     }
     //for(int ki=0; ki<KList.kpts_cart.size(); ki++){
     //  RealType k=dot(KList.kpts_cart[ki],KList.kpts_cart[ki]);
     //  k=std::sqrt(k);
     //  Fk[ki] = evalFk(k); //Call derived fn.
     //}
   }

◆ fillXk()

void fillXk ( std::vector< TinyVector< mRealType, 2 >> & KList )

inlineprivate

Definition at line 258 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::evalXk(), LRHandlerBase::Fk, and Vector< T, Alloc >::resize().

Referenced by LRHandlerTemp< Func, BreakupBasis >::InitBreakup().

   {
     Fk.resize(KList.size());
     for (int ki = 0; ki < KList.size(); ki++)
     {
       mRealType k = KList[ki][0];
       Fk[ki]      = evalXk(k); //Call derived fn.
     }
   }

◆ initBreakup()

void initBreakup ( ParticleSet & ref )

inlineoverridevirtual

Implements LRHandlerBase.

Definition at line 83 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerTemp< Func, BreakupBasis >::fillFk(), ParticleSet::getLRBox(), ParticleSet::getSimulationCell(), LRHandlerTemp< Func, BreakupBasis >::InitBreakup(), and LRHandlerBase::LR_rc.

Referenced by qmcplusplus::TEST_CASE().

   {
     InitBreakup(ref.getLRBox(), 1);
     fillFk(ref.getSimulationCell().getKLists());
     LR_rc = Basis.get_rc();
   }

◆ InitBreakup()

void InitBreakup	(	const ParticleLayout &	ref,
		int	NumFunctions
	)

inlineprivate

Initialise the basis and coefficients for the long-range beakup.

We loocally create a breakup handler and pass in the basis that has been initialised here. We then discard the handler, leaving basis and coefs in a usable state. This method can be re-called later if lattice changes shape.

Definition at line 206 of file LRHandlerTemp.h.

References qmcplusplus::app_log(), LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerBase::coefs, Vector< T, Alloc >::data(), LRBreakup< BreakupBasis >::DoBreakup(), LRHandlerTemp< Func, BreakupBasis >::fillXk(), LRHandlerTemp< Func, BreakupBasis >::FirstTime, LRHandlerBase::Fk, LRBreakup< BreakupBasis >::KList, LRHandlerBase::LR_kc, LRHandlerBase::MaxKshell, qmcplusplus::pow(), and LRBreakup< BreakupBasis >::SetupKVecs().

Referenced by LRHandlerTemp< Func, BreakupBasis >::Breakup(), and LRHandlerTemp< Func, BreakupBasis >::initBreakup().

   {
     //First we send the new Lattice to the Basis, in case it has been updated.
     Basis.set_Lattice(ref);
     //Compute RC from box-size - in constructor?
     //No here...need update if box changes
     int NumKnots(15);
     Basis.set_NumKnots(NumKnots);
     Basis.set_rc(ref.LR_rc);
     //Initialise the breakup - pass in basis.
     LRBreakup<BreakupBasis> breakuphandler(Basis);
     //Find size of basis from cutoffs
     mRealType kc = (LR_kc < 0) ? ref.LR_kc : LR_kc;
     LR_kc        = kc; // set internal kc
     //RealType kc(ref.LR_kc); //User cutoff parameter...
     //kcut is the cutoff for switching to approximate k-point degeneracies for
     //better performance in making the breakup. A good bet is 30*K-spacing so that
     //there are 30 "boxes" in each direction that are treated with exact degeneracies.
     //Assume orthorhombic cell just for deriving this cutoff - should be insensitive.
     //K-Spacing = (kpt_vol)**1/3 = 2*pi/(cellvol**1/3)
     mRealType kcut = 60 * M_PI * std::pow(Basis.get_CellVolume(), -1.0 / 3.0);
     //Use 3000/LMax here...==6000/rc for non-ortho cells
     mRealType kmax(6000.0 / ref.LR_rc);
     MaxKshell = static_cast<int>(breakuphandler.SetupKVecs(kc, kcut, kmax));
     if (FirstTime)
     {
       app_log() << " finding kc:  " << ref.LR_kc << " , " << LR_kc << std::endl;
       app_log() << "  LRBreakp parameter Kc =" << kc << std::endl;
       app_log() << "    Continuum approximation in k = [" << kcut << "," << kmax << ")" << std::endl;
       FirstTime = false;
     }
     //Set up x_k
     //This is the FT of -V(r) from r_c to infinity.
     //This is the only data that the breakup handler needs to do the breakup.
     //We temporarily store it in Fk, which is replaced with the full FT (0->inf)
     //of V_l(r) after the breakup has been done.
     fillXk(breakuphandler.KList);
     //Allocate the space for the coefficients.
     coefs.resize(Basis.NumBasisElem()); //This must be after SetupKVecs.
 
     mRealType chisqr(0.0);
     chisqr = breakuphandler.DoBreakup(Fk.data(), coefs.data()); //Fill array of coefficients.
     //I want this in scientific notation, but I don't want to mess up formatting flags elsewhere.
     //Save stream state.
     std::ios_base::fmtflags app_log_flags(app_log().flags());
     app_log() << std::scientific;
     app_log().precision(5);
     app_log() << "\n   LR Breakup chi^2 = " << chisqr << std::endl;
 
     app_log().flags(app_log_flags);
   }

◆ lrDf()

mRealType lrDf ( mRealType r ) const

inlineoverridevirtual

evaluate the contribution from the long-range part for for spline

Reimplemented from LRHandlerBase.

Definition at line 150 of file LRHandlerTemp.h.

References APP_ABORT, LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerBase::coefs, LRHandlerBase::gcoefs, LRHandlerBase::LR_rc, LRHandlerTemp< Func, BreakupBasis >::myFunc, and qmcplusplus::n.

   {
     APP_ABORT("LRHandlerTemp::lrDF not implemented (missing gcoefs)");
     mRealType dv = 0.0;
     if (r < LR_rc)
     {
       for (int n = 0; n < coefs.size(); n++)
         dv += gcoefs[n] * Basis.dh_dr(n, r);
     }
     else
       dv = myFunc.df(r);
 
     return dv;
   }

◆ makeClone()

LRHandlerBase* makeClone ( ParticleSet & ref ) const

inlineoverridevirtual

make clone

Implements LRHandlerBase.

Definition at line 78 of file LRHandlerTemp.h.

   {
     return new LRHandlerTemp<Func, BreakupBasis>(*this, ref);
   }

◆ resetTargetParticleSet() [1/2]

void resetTargetParticleSet ( ParticleSet & ref )

inlineoverridevirtual

Implements LRHandlerBase.

Definition at line 100 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::myFunc.

100 { myFunc.reset(ref); }

qmcplusplus::LRHandlerTemp::myFunc

Func myFunc

Definition: LRHandlerTemp.h:50

◆ resetTargetParticleSet() [2/2]

void resetTargetParticleSet	(	ParticleSet &	ref,
		mRealType	rs
	)

inline

Definition at line 102 of file LRHandlerTemp.h.

References LRHandlerTemp< Func, BreakupBasis >::myFunc, and LRHandlerTemp< Func, BreakupBasis >::rs.

102 { myFunc.reset(ref, rs); }

qmcplusplus::LRHandlerTemp::rs

mRealType rs

Definition: LRHandlerTemp.h:48

qmcplusplus::LRHandlerTemp::myFunc

Func myFunc

Definition: LRHandlerTemp.h:50

◆ srDf()

mRealType srDf	(	mRealType	r,
		mRealType	rinv
	)		const

inlineoverridevirtual

evaluate the first derivative of the short range part at r

Parameters

r	radius
rinv	1/r

Implements LRHandlerBase.

Definition at line 120 of file LRHandlerTemp.h.

References APP_ABORT, LRHandlerTemp< Func, BreakupBasis >::Basis, LRHandlerBase::coefs, LRHandlerBase::gcoefs, LRHandlerBase::LR_rc, LRHandlerTemp< Func, BreakupBasis >::myFunc, and qmcplusplus::n.

   {
     APP_ABORT("LRHandlerTemp::srDF not implemented (missing gcoefs)");
     mRealType df = 0.0;
     if (r >= LR_rc)
       return df;
     df = myFunc.df(r);
     //RealType df = myFunc.df(r, rinv);
     for (int n = 0; n < coefs.size(); n++)
       df -= gcoefs[n] * Basis.dh_dr(n, r);
     return df;
   }

Member Data Documentation

◆ Basis

BreakupBasisType Basis

Definition at line 49 of file LRHandlerTemp.h.

◆ FirstTime

bool FirstTime

Definition at line 47 of file LRHandlerTemp.h.

Referenced by LRHandlerTemp< Func, BreakupBasis >::InitBreakup().

◆ myFunc

Func myFunc

Definition at line 50 of file LRHandlerTemp.h.

◆ rs

mRealType rs

Definition at line 48 of file LRHandlerTemp.h.

Referenced by LRHandlerTemp< Func, BreakupBasis >::Breakup(), and LRHandlerTemp< Func, BreakupBasis >::resetTargetParticleSet().

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

/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Particle/LongRange/LRHandlerTemp.h

Public Types

Public Member Functions

Public Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

template<class Func, class BreakupBasis = LPQHIBasis> class qmcplusplus::LRHandlerTemp< Func, BreakupBasis >

Member Typedef Documentation

◆ BreakupBasisType

◆ ParticleLayout

Constructor & Destructor Documentation

◆ LRHandlerTemp() [1/2]

◆ LRHandlerTemp() [2/2]

Member Function Documentation

◆ Breakup()

◆ evalFk()

◆ evaluate()

◆ evaluate_vlr_k()

◆ evaluateLR()

◆ evaluateLR_r0()

◆ evaluateSR_k0()

◆ evalXk()

◆ fillFk()

◆ fillXk()

◆ initBreakup()

◆ InitBreakup()

◆ lrDf()

◆ makeClone()

◆ resetTargetParticleSet() [1/2]

◆ resetTargetParticleSet() [2/2]

◆ srDf()

Member Data Documentation

◆ Basis

◆ FirstTime

◆ myFunc

◆ rs

template<class Func, class BreakupBasis = LPQHIBasis>
class qmcplusplus::LRHandlerTemp< Func, BreakupBasis >