Inheritance diagram for CountingJastrow< RegionType >:

Collaboration diagram for CountingJastrow< RegionType >:

Public Member Functions
	CountingJastrow (ParticleSet &P, std::unique_ptr< RegionType > c, const Matrix< RealType > &f, bool opt_C_flag, bool opt_F_flag)

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

bool	isOptimizable () const override
	if true, this contains optimizable components More...

void	extractOptimizableObjectRefs (UniqueOptObjRefs &opt_obj_refs) override
	extract underlying OptimizableObject references More...

void	checkInVariablesExclusive (opt_variables_type &active) final
	check in variational parameters to the global list of parameters used by the optimizer. More...

void	checkOutVariables (const opt_variables_type &active) override
	check out variational optimizable variables More...

void	resetParametersExclusive (const opt_variables_type &active) override
	reset the parameters during optimizations. More...

void	initialize ()

void	reportStatus (std::ostream &os) override
	print the state, e.g., optimizables More...

LogValue	evaluateLog (const ParticleSet &P, ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L) override
	evaluate the value of the WaveFunctionComponent from scratch More...

void	recompute (const ParticleSet &P) override
	recompute the value of the WaveFunctionComponents which require critical accuracy. More...

void	evaluateExponents (const ParticleSet &P)

void	evaluateExponents_print (std::ostream &os, const ParticleSet &P)

void	evaluateTempExponents (ParticleSet &P, int iat)

void	evaluateTempExponents_print (std::ostream &os, ParticleSet &P, int iat)

GradType	evalGrad (ParticleSet &P, int iat) override
	return the current gradient for the iat-th particle More...

PsiValue	ratioGrad (ParticleSet &P, int iat, GradType &grad_iat) override
	evaluate the ratio of the new to old WaveFunctionComponent value and the new gradient More...

void	acceptMove (ParticleSet &P, int iat, bool safe_to_delay=false) override
	a move for iat-th particle is accepted. More...

void	restore (int iat) override
	If a move for iat-th particle is rejected, restore to the content. More...

PsiValue	ratio (ParticleSet &P, int iat) override
	evaluate the ratio of the new to old WaveFunctionComponent value More...

void	registerData (ParticleSet &P, WFBufferType &buf) override
	For particle-by-particle move. More...

LogValue	updateBuffer (ParticleSet &P, WFBufferType &buf, bool fromscratch=false) override
	For particle-by-particle move. More...

void	copyFromBuffer (ParticleSet &P, WFBufferType &buf) override
	For particle-by-particle move. More...

std::unique_ptr< WaveFunctionComponent >	makeClone (ParticleSet &tqp) const override
	make clone More...

void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &active, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi) override

void	addDebug (bool debug_flag, int seqlen, int period)

Public Member Functions inherited from WaveFunctionComponent
const LogValue &	get_log_value () const

	WaveFunctionComponent (const std::string &obj_name="")
	default constructor More...

virtual	~WaveFunctionComponent ()
	default destructor More...

virtual void	checkSanity () const
	Validate the internal consistency of the object. More...

const std::string &	getName () const
	return object name More...

PsiValue	getValue () const
	assembles the full value More...

virtual bool	isFermionic () const
	true, if this component is fermionic More...

virtual bool	isMultiDet () const
	true, if this component is multi-determinant More...

virtual void	registerTWFFastDerivWrapper (const ParticleSet &P, TWFFastDerivWrapper &twf) const
	Register the component with the TWFFastDerivWrapper wrapper. More...

virtual void	mw_evaluateLog (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, const RefVector< ParticleSet::ParticleGradient > &G_list, const RefVector< ParticleSet::ParticleLaplacian > &L_list) const
	evaluate from scratch the same type WaveFunctionComponent of multiple walkers More...

virtual void	mw_recompute (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< bool > &recompute) const

virtual void	evaluateHessian (ParticleSet &P, HessVector &grad_grad_psi_all)

virtual void	prepareGroup (ParticleSet &P, int ig)
	Prepare internal data for updating WFC correspond to a particle group It should be called before moving particles of a given group. More...

virtual void	mw_prepareGroup (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int ig) const

virtual GradType	evalGradWithSpin (ParticleSet &P, int iat, ComplexType &spingrad)
	return the current spin gradient for the iat-th particle Default implementation assumes that WaveFunctionComponent does not explicitly depend on Spin. More...

template<CoordsType CT>
void	mw_evalGrad (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, const int iat, TWFGrads< CT > &grads_now) const
	compute the current gradients for the iat-th particle of multiple walkers More...

virtual void	mw_evalGrad (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, std::vector< GradType > &grad_now) const
	compute the current gradients for the iat-th particle of multiple walkers More...

virtual GradType	evalGradSource (ParticleSet &P, ParticleSet &source, int iat)
	return the logarithmic gradient for the iat-th particle of the source particleset More...

virtual GradType	evalGradSource (ParticleSet &P, ParticleSet &source, int iat, TinyVector< ParticleSet::ParticleGradient, OHMMS_DIM > &grad_grad, TinyVector< ParticleSet::ParticleLaplacian, OHMMS_DIM > &lapl_grad)
	Adds the gradient w.r.t. More...

virtual PsiValue	ratioGradWithSpin (ParticleSet &P, int iat, GradType &grad_iat, ComplexType &spingrad_iat)
	evaluate the ratio of the new to old WaveFunctionComponent value and the new spin gradient Default implementation assumes that WaveFunctionComponent does not explicitly depend on Spin. More...

template<CoordsType CT>
void	mw_ratioGrad (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, std::vector< PsiValue > &ratios, TWFGrads< CT > &grad_new) const

virtual void	mw_ratioGrad (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, std::vector< PsiValue > &ratios, std::vector< GradType > &grad_new) const
	compute the ratio of the new to old WaveFunctionComponent value and the new gradient of multiple walkers More...

virtual void	mw_accept_rejectMove (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, const std::vector< bool > &isAccepted, bool safe_to_delay=false) const
	moves of the iat-th particle on some walkers in a batch is accepted. More...

virtual void	completeUpdates ()
	complete all the delayed or asynchronous operations before leaving the p-by-p move region. More...

virtual void	mw_completeUpdates (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list) const
	complete all the delayed or asynchronous operations for all the walkers in a batch before leaving the p-by-p move region. More...

virtual void	mw_calcRatio (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, std::vector< PsiValue > &ratios) const
	compute the ratio of the new to old WaveFunctionComponent value of multiple walkers More...

virtual LogValue	evaluateGL (const ParticleSet &P, ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L, bool fromscratch)
	compute gradients and laplacian of the TWF with respect to each particle. More...

virtual void	mw_evaluateGL (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, const RefVector< ParticleSet::ParticleGradient > &G_list, const RefVector< ParticleSet::ParticleLaplacian > &L_list, bool fromscratch) const
	evaluate gradients and laplacian of the same type WaveFunctionComponent of multiple walkers More...

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

virtual void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< WaveFunctionComponent > &wfc_list) const
	acquire a shared resource from a collection More...

virtual void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< WaveFunctionComponent > &wfc_list) const
	return a shared resource to a collection More...

virtual RealType	KECorrection ()
	Return the Chiesa kinetic energy correction. More...

virtual void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)=0
	Compute the derivatives of both the log of the wavefunction and kinetic energy with respect to optimizable parameters. More...

virtual void	evaluateDerivativesWF (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi)
	Compute the derivatives of the log of the wavefunction with respect to optimizable parameters. More...

virtual void	evaluateGradDerivatives (const ParticleSet::ParticleGradient &G_in, std::vector< ValueType > &dgradlogpsi)
	Calculates the derivatives of $\nabla \textnormal{log} \psi_f$ with respect to the optimizable parameters, and the dot product of this is then performed with the passed-in G_in gradient vector. More...

virtual void	finalizeOptimization ()

virtual void	evaluateRatiosAlltoOne (ParticleSet &P, std::vector< ValueType > &ratios)
	evaluate the ratios of one virtual move with respect to all the particles More...

virtual void	evaluateRatios (const VirtualParticleSet &VP, std::vector< ValueType > &ratios)
	evaluate ratios to evaluate the non-local PP More...

virtual void	evaluateSpinorRatios (const VirtualParticleSet &VP, const std::pair< ValueVector, ValueVector > &spinor_multiplier, std::vector< ValueType > &ratios)
	Used by SOECPComponent for faster SOC evaluation. More...

virtual void	mw_evaluateRatios (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< const VirtualParticleSet > &vp_list, std::vector< std::vector< ValueType >> &ratios) const
	evaluate ratios to evaluate the non-local PP multiple walkers More...

virtual void	evaluateDerivRatios (const VirtualParticleSet &VP, const opt_variables_type &optvars, std::vector< ValueType > &ratios, Matrix< ValueType > &dratios)
	evaluate ratios to evaluate the non-local PP More...

virtual void	mw_evalGradWithSpin (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, std::vector< GradType > &grad_now, std::vector< ComplexType > &spingrad_now) const
	compute the current gradients and spin gradients for the iat-th particle of multiple walkers More...

virtual void	mw_ratioGradWithSpin (const RefVectorWithLeader< WaveFunctionComponent > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, std::vector< PsiValue > &ratios, std::vector< GradType > &grad_new, std::vector< ComplexType > &spingrad_new) const
	compute the ratio of the new to old WaveFunctionComponent value and the new gradient/spingradient of multiple walkers More...

Public Member Functions inherited from OptimizableObject
	OptimizableObject (const std::string &name)

const std::string &	getName () const

bool	isOptimized () const

void	setOptimization (bool state)

virtual void	writeVariationalParameters (hdf_archive &hout)
	Write the variational parameters for this object to the VP HDF file. More...

virtual void	readVariationalParameters (hdf_archive &hin)
	Read the variational parameters for this object from the VP HDF file. More...

Protected Types
enum	opt_var { OPT_F, NUM_OPT_VAR }

Protected Attributes
int	num_els

int	num_regions

bool	debug = false

int	debug_seqlen

int	debug_period

Matrix< RealType >	F

std::unique_ptr< RegionType >	C

bool	opt_F

bool	opt_C

std::vector< RealType >	FCsum

Matrix< PosType >	FCgrad

Matrix< RealType >	FClap

std::vector< RealType >	FCggsum

std::vector< RealType >	FClapsum

std::vector< RealType >	FCsum_t

std::vector< PosType >	FCgrad_t

std::vector< RealType >	FClap_t

RealType	Jval

std::vector< PosType >	Jgrad

std::vector< RealType >	Jlap

RealType	Jval_t

std::vector< PosType >	Jgrad_t

std::vector< RealType >	Jlap_t

Matrix< RealType >	dCsum

Matrix< RealType >	dCggsum

Matrix< RealType >	dClapsum

std::vector< RealType >	dCsum_t

std::vector< RealType >	dCFCggsum

std::vector< int >	dCindex

std::array< std::vector< int >, NUM_OPT_VAR >	opt_index

std::array< std::vector< std::string >, NUM_OPT_VAR >	opt_id

Protected Attributes inherited from WaveFunctionComponent
const std::string	my_name_
	Name of the object It is required to be different for objects of the same derived type like multiple J1. More...

LogValue	log_value_
	Current $\log\phi$ . More...

Additional Inherited Members
Public Types inherited from WaveFunctionComponent
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	BufferType = Walker_t::Buffer_t

using	RealMatrix_t = OrbitalSetTraits< RealType >::ValueMatrix

using	ValueVector = OrbitalSetTraits< ValueType >::ValueVector

using	ValueMatrix = OrbitalSetTraits< ValueType >::ValueMatrix

using	GradMatrix = OrbitalSetTraits< ValueType >::GradMatrix

using	HessType = OrbitalSetTraits< ValueType >::HessType

using	HessVector = OrbitalSetTraits< ValueType >::HessVector

using	LogValue = std::complex< QTFull::RealType >

using	PsiValue = QTFull::ValueType

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

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

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

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

Public Attributes inherited from WaveFunctionComponent
int	UpdateMode
	current update mode More...

opt_variables_type	myVars
	list of variables this WaveFunctionComponent handles More...

size_t	Bytes_in_WFBuffer
	Bytes in WFBuffer. More...

Detailed Description

template<class RegionType>
class qmcplusplus::CountingJastrow< RegionType >

Definition at line 23 of file CountingJastrow.h.

Member Enumeration Documentation

◆ opt_var

enum opt_var

protected

Enumerator
OPT_F
NUM_OPT_VAR

Definition at line 80 of file CountingJastrow.h.

   {
     OPT_F,
     //OPT_G,
     NUM_OPT_VAR
   };

Constructor & Destructor Documentation

◆ CountingJastrow()

CountingJastrow	(	ParticleSet &	P,
		std::unique_ptr< RegionType >	c,
		const Matrix< RealType > &	f,
		bool	opt_C_flag,
		bool	opt_F_flag
	)

inline

Definition at line 94 of file CountingJastrow.h.

References ParticleSet::getTotalNum(), and CountingJastrow< RegionType >::num_els.

       : OptimizableObject("countingjas"), F(f), C(std::move(c)), opt_F(opt_F_flag), opt_C(opt_C_flag)
   {
     num_els = P.getTotalNum();
   }

Member Function Documentation

◆ acceptMove()

void acceptMove	(	ParticleSet &	P,
		int	iat,
		bool	safe_to_delay = `false`
	)

inlineoverridevirtual

a move for iat-th particle is accepted.

Update the current content.

Parameters

P	target ParticleSet
iat	index of the particle whose new position was proposed
safe_to_delay	if true, delayed accept is safe.

Implements WaveFunctionComponent.

Definition at line 395 of file CountingJastrow.h.

Referenced by qmcplusplus::TEST_CASE().

   {
     C->acceptMove(P, iat);
     // update values for C, FC to those at proposed position
     // copy over temporary values
     for (int I = 0; I < num_regions; ++I)
     {
       FCsum[I]       = FCsum_t[I];
       FCgrad(I, iat) = FCgrad_t[I];
       FClap(I, iat)  = FClap_t[I];
     }
     // update exponent values to that at proposed position
     Jval       = Jval_t;
     log_value_ = Jval;
     for (int i = 0; i < num_els; ++i)
     {
       Jgrad[i] = Jgrad_t[i];
       Jlap[i]  = Jlap_t[i];
     }
   }

◆ addDebug()

void addDebug	(	bool	debug_flag,
		int	seqlen,
		int	period
	)

inline

Definition at line 680 of file CountingJastrow.h.

References CountingJastrow< RegionType >::debug, CountingJastrow< RegionType >::debug_period, and CountingJastrow< RegionType >::debug_seqlen.

   {
     debug        = debug_flag;
     debug_seqlen = seqlen;
     debug_period = period;
   }

◆ checkInVariablesExclusive()

void checkInVariablesExclusive ( opt_variables_type & active )

inlinefinalvirtual

check in variational parameters to the global list of parameters used by the optimizer.

Parameters

active a super set of optimizable variables

The existing checkInVariables implementation in WFC/SPO/.. are inclusive and it calls checkInVariables of its members class A: public SPOSet {} class B: public WFC { A objA; checkInVariables() { objA.checkInVariables(); } };

With OptimizableObject, class A: public OptimizableObject {} class B: public OptimizableObject { A objA; checkInVariablesExclusive() { // should not call objA.checkInVariablesExclusive() if objA has been extracted; } }; A vector of OptimizableObject, will be created by calling extractOptimizableObjects(). All the checkInVariablesExclusive() will be called through this vector and thus checkInVariablesExclusive implementation should only handle non-OptimizableObject members.

Implements OptimizableObject.

Definition at line 110 of file CountingJastrow.h.

References CountingJastrow< RegionType >::C, and WaveFunctionComponent::myVars.

Referenced by qmcplusplus::TEST_CASE().

   {
     active.insertFrom(myVars);
     C->checkInVariables(active);
   }

◆ checkOutVariables()

void checkOutVariables ( const opt_variables_type & active )

inlineoverridevirtual

check out variational optimizable variables

Parameters

active a super set of optimizable variables

Reimplemented from WaveFunctionComponent.

Definition at line 116 of file CountingJastrow.h.

References CountingJastrow< RegionType >::C, VariableSet::getIndex(), and WaveFunctionComponent::myVars.

Referenced by qmcplusplus::TEST_CASE().

   {
     myVars.getIndex(active);
     C->checkOutVariables(active);
   }

◆ copyFromBuffer()

void copyFromBuffer	(	ParticleSet &	P,
		WFBufferType &	buf
	)

inlineoverridevirtual

For particle-by-particle move.

Copy data or attach memory from a walker buffer to the objects of this class. The log value, P.G and P.L contribution from the objects of this class are also added.

Parameters

P	particle set
buf	Anonymous storage

Implements WaveFunctionComponent.

Definition at line 453 of file CountingJastrow.h.

References PooledMemory< T_scalar, Alloc >::current(), DEBUG_PSIBUFFER, PooledMemory< T_scalar, Alloc >::get(), CountingJastrow< RegionType >::Jgrad, CountingJastrow< RegionType >::Jlap, and CountingJastrow< RegionType >::Jval.

   {
     RealType* Jlap_begin  = &Jlap[0];
     RealType* Jlap_end    = Jlap_begin + Jlap.size();
     RealType* Jgrad_begin = &Jgrad[0][0];
     RealType* Jgrad_end   = Jgrad_begin + Jgrad.size() * 3;
     DEBUG_PSIBUFFER(" CountingJastrow::copyFromBuffer ", buf.current());
     buf.get(&Jval, &Jval);
     buf.get(Jlap_begin, Jlap_end);
     buf.get(Jgrad_begin, Jgrad_end);
     DEBUG_PSIBUFFER(" CountingJastrow::copyFromBuffer ", buf.current());
     return;
   }

◆ evalGrad()

GradType evalGrad	(	ParticleSet &	P,
		int	iat
	)

inlineoverridevirtual

return the current gradient for the iat-th particle

Parameters

P	quantum particle set
iat	particle index

Returns: the gradient of the iat-th particle

Reimplemented from WaveFunctionComponent.

Definition at line 381 of file CountingJastrow.h.

References CountingJastrow< RegionType >::evaluateExponents(), CountingJastrow< RegionType >::Jgrad, CountingJastrow< RegionType >::Jval, and WaveFunctionComponent::log_value_.

Referenced by qmcplusplus::TEST_CASE().

   {
     evaluateExponents(P);
     log_value_ = Jval;
     return Jgrad[iat];
   }

◆ evaluateDerivatives()

void evaluateDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	active,
		Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi
	)

inlineoverride

Definition at line 475 of file CountingJastrow.h.

Referenced by qmcplusplus::TEST_CASE().

   {
 #ifdef QMC_COMPLEX
     APP_ABORT("CountingJastrow::evaluateDerivatives is not available on complex builds.");
 #else
     evaluateExponents(P);
     // evaluate derivatives of F
     static int deriv_print_index = 0;
     if (opt_F)
     {
       for (int oi = 0; oi < opt_index[OPT_F].size(); ++oi)
       {
         std::string id = opt_id[OPT_F][oi];
         int ia         = myVars.getIndex(id);
         if (ia == -1)
           continue; // ignore inactive parameters
         int IJ = opt_index[OPT_F][oi];
         int I  = IJ / num_regions;
         int J  = IJ % num_regions;
         // coefficient due to symmetry of F: \sum\limits_{I} F_{II} C_I^2 + \sum\limits_{J > I} 2 F_{IJ}*C_I*C_J
         RealType x       = (I == J) ? 1 : 2;
         RealType dJF_val = C->sum[I] * C->sum[J] * x;
         RealType dJF_gg = 0, dJF_lap = 0;
         for (int i = 0; i < num_els; ++i)
         {
           PosType grad_i(P.G[i]);
           dJF_gg += x * (dot(C->grad(I, i), grad_i) * C->sum[J] + C->sum[I] * dot(C->grad(J, i), grad_i));
           dJF_lap += x * (C->lap(I, i) * C->sum[J] + 2 * dot(C->grad(I, i), C->grad(J, i)) + C->lap(J, i) * C->sum[I]);
         }
         dlogpsi[ia] += dJF_val;
         dhpsioverpsi[ia] += -0.5 * dJF_lap - dJF_gg;
         if (debug && deriv_print_index < debug_seqlen)
         {
           app_log() << "  dJ/dF[" << I << "][" << J << "]; ia: " << ia << ",  dlogpsi: " << dlogpsi[ia]
                     << ", dhpsioverpsi: " << dhpsioverpsi[ia] << std::endl;
         }
       }
     }
 
     //  // evaluate partial derivatives of C
     if (opt_C)
     {
       // containers for CountingRegions' evaluateDerivatives calculations
       // blocks of dimension n_p x n_C
       // ex: dNsum = \sum\limits_k [ [dC1 / dp1] [dC2 / dp1] .. ]
       // Where each [dCi / dpj] block is n_p x 1 vector of derivatives of parameters
       //   for counting region j as summed over electron coordinate k
 
       // exception: dNFN ggsum is an n_p x 1 vector since it is an evaluation of a quadratic form:
       // \sum\limits_{kI} [\nabla_k dC_I/dpj] dot [ (F \nabla_k C)_I ]
       // since we have the premultiplied (F\nabla_k C) vector on hand.
       // make a lambda function FCgrad(I,i) which gives the appropriate element of FCgrad[iI]
 
       // clear some vectors
       std::fill(FCggsum.begin(), FCggsum.end(), 0);
       std::fill(FClapsum.begin(), FClapsum.end(), 0);
 
       // evaluate FCggsum
       for (int I = 0; I < num_regions; ++I)
       {
         for (int i = 0; i < num_els; ++i)
         {
           PosType grad_i(P.G[i]);
           FCggsum[I] += dot(FCgrad(I, i), grad_i);
           FClapsum[I] += FClap(I, i);
         }
       }
       // pointer to C->C[I]->myVars.Index
       // for pI in { 0 .. C->num_derivs(I) }
       //   dCindex->[pI]  is the index that corresponds to this parameter in active.
       //   i.e., active[dCindex->[pI]] <=> C->C[I]->myVars.Index[pI]
 
       // external print block
       if (debug && deriv_print_index < debug_seqlen)
       {
         app_log() << std::endl << "=== evaluateDerivatives ===" << std::endl;
         app_log() << "== print current exponent values ==" << std::endl;
         evaluateExponents_print(app_log(), P);
         app_log() << "== additional counting function terms ==" << std::endl;
         app_log() << "P.G: ";
         std::copy(P.G.begin(), P.G.end(), std::ostream_iterator<PosType>(app_log(), ", "));
         app_log() << std::endl << "FCgrad: ";
         std::copy(FCgrad.begin(), FCgrad.end(), std::ostream_iterator<PosType>(app_log(), ", "));
         app_log() << std::endl << "FClap: ";
         std::copy(FClap.begin(), FClap.end(), std::ostream_iterator<RealType>(app_log(), ", "));
         app_log() << std::endl << "FCggsum: ";
         std::copy(FCggsum.begin(), FCggsum.end(), std::ostream_iterator<RealType>(app_log(), ", "));
         app_log() << std::endl << "FClapsum: ";
         std::copy(FClapsum.begin(), FClapsum.end(), std::ostream_iterator<RealType>(app_log(), ", "));
         app_log() << std::endl;
       }
 
       for (int I = 0; I < num_regions; ++I)
       {
         // get the number of active parameters for the Ith counting region
         opt_variables_type I_vars = C->getVars(I);
         int I_num_derivs          = I_vars.size();
         // clear arrays before each evaluate
         std::fill(dCsum.begin(), dCsum.end(), 0);
         std::fill(dCggsum.begin(), dCggsum.end(), 0);
         std::fill(dClapsum.begin(), dClapsum.end(), 0);
         std::fill(dCFCggsum.begin(), dCFCggsum.end(), 0);
         // evaluate all derivatives for the Ith counting function
         C->evaluateDerivatives(P, I, FCgrad, dCsum, dCggsum, dClapsum, dCFCggsum);
         if (debug && deriv_print_index < debug_seqlen)
         {
           // print out current index information
           app_log() << std::endl;
           app_log() << "  == evaluateDerivatives for counting region " << I << ", num_derivs: " << I_num_derivs
                     << " ==" << std::endl;
           app_log() << "  Indices: ";
           std::copy(I_vars.Index.begin(), I_vars.Index.end(), std::ostream_iterator<int>(app_log(), ", "));
           app_log() << std::endl << "  Names: ";
           for (auto it = I_vars.NameAndValue.begin(); it != I_vars.NameAndValue.end(); ++it)
             app_log() << (*it).first << ", ";
           app_log() << std::endl << "  Values: ";
           for (auto it = I_vars.NameAndValue.begin(); it != I_vars.NameAndValue.end(); ++it)
             app_log() << (*it).second << ", ";
           // print out values from evaluate derivatives
           app_log() << std::endl << "  dCsum: ";
           std::copy(dCsum.begin(), dCsum.end(), std::ostream_iterator<RealType>(app_log(), ", "));
           app_log() << std::endl << "  dCggsum: ";
           std::copy(dCggsum.begin(), dCggsum.end(), std::ostream_iterator<RealType>(app_log(), ", "));
           app_log() << std::endl << "  dClapsum: ";
           std::copy(dClapsum.begin(), dClapsum.end(), std::ostream_iterator<RealType>(app_log(), ", "));
           app_log() << std::endl << "  dCFCggsum: ";
           std::copy(dCFCggsum.begin(), dCFCggsum.end(), std::ostream_iterator<RealType>(app_log(), ", "));
           app_log() << std::endl;
         }
         // loop over parameters for the Ith counting function
         for (int pI = 0; pI < I_num_derivs; ++pI)
         {
           // index for active optimizable variables
           int ia = I_vars.Index[pI];
           if (ia == -1)
             continue; // ignore inactive
           // middle laplacian term:
           dhpsioverpsi[ia] += -0.5 * (4.0 * dCFCggsum[pI]);
           if (debug && deriv_print_index < debug_seqlen)
           {
             app_log() << "    == evaluateDerivatives calculations ==" << std::endl;
             app_log() << "    pI: " << pI << ", name: " << I_vars.name(pI) << ", ia: " << ia << std::endl;
             app_log() << "    dCFCggsum: " << dCFCggsum[pI] << std::endl;
           }
           for (int J = 0; J < num_regions; ++J)
           {
             dlogpsi[ia] += dCsum(J, pI) * (2 * FCsum[J]);
             // grad dot grad terms
             dhpsioverpsi[ia] += -1.0 * (dCggsum(J, pI) * (2.0 * FCsum[J]) + dCsum(J, pI) * 2.0 * FCggsum[J]);
             // outer laplacian terms
             dhpsioverpsi[ia] += -0.5 * (2.0 * dCsum(J, pI) * FClapsum[J] + dClapsum(J, pI) * (2.0 * FCsum[J]));
             if (debug && deriv_print_index < debug_seqlen)
             {
               app_log() << "      J: " << J << std::endl;
               app_log() << "      dlogpsi term          : " << dCsum(J, pI) * (2 * FCsum[J]) << std::endl;
               app_log() << "      dhpsi/psi, graddotgrad: "
                         << -1.0 * (dCggsum(J, pI) * (2.0 * FCsum[J]) + dCsum(J, pI) * 2.0 * FCggsum[J]) << std::endl;
               app_log() << "      dhpsi/psi, laplacian  : "
                         << -0.5 * (2.0 * dCsum(J, pI) * FClapsum[J] + dClapsum(J, pI) * (2.0 * FCsum[J])) << std::endl;
             }
           }
         }
       }
 
     } // end opt_C
     // increment and modulo deriv_print_index
     if (debug)
     {
       app_log() << "Final derivatives: " << std::endl;
       app_log() << "  F derivatives: " << std::endl;
       for (int oi = 0; oi < opt_index[OPT_F].size(); ++oi)
       {
         std::string id = opt_id[OPT_F][oi];
         int ia         = myVars.getIndex(id);
         if (ia == -1)
           continue; // ignore inactive parameters
         app_log() << "    ia: " << ia << ",  dlogpsi: " << dlogpsi[ia] << ", dhpsioverpsi: " << dhpsioverpsi[ia]
                   << std::endl;
       }
       app_log() << "  C derivatives: " << std::endl;
       for (int I = 0; I < num_regions; ++I)
       {
         app_log() << "    C[" << I << "] derivs: " << std::endl;
         // get the number of active parameters for the Ith counting region
         opt_variables_type I_vars = C->getVars(I);
         int I_num_derivs          = I_vars.size();
         for (int pI = 0; pI < I_num_derivs; ++pI)
         {
           // index for active optimizable variables
           int ia = I_vars.Index[pI];
           if (ia == -1)
             continue; // ignore inactive
           app_log() << "      ia: " << ia << ",  dlogpsi: " << dlogpsi[ia] << ", dhpsioverpsi: " << dhpsioverpsi[ia]
                     << std::endl;
         }
       }
       deriv_print_index = deriv_print_index % debug_period;
       deriv_print_index++;
     }
 #endif
   }

◆ evaluateExponents()

void evaluateExponents ( const ParticleSet & P )

inline

Definition at line 242 of file CountingJastrow.h.

Referenced by CountingJastrow< RegionType >::evalGrad(), CountingJastrow< RegionType >::evaluateDerivatives(), CountingJastrow< RegionType >::evaluateLog(), and CountingJastrow< RegionType >::recompute().

   {
     // evaluate counting regions
     C->evaluate(P);
     std::fill(FCsum.begin(), FCsum.end(), 0);
     std::fill(FCgrad.begin(), FCgrad.end(), 0);
     std::fill(FClap.begin(), FClap.end(), 0);
     Jval = 0;
     std::fill(Jgrad.begin(), Jgrad.end(), 0);
     std::fill(Jlap.begin(), Jlap.end(), 0);
 
     // evaluate FC products
     for (int I = 0; I < num_regions; ++I)
     {
       for (int J = 0; J < num_regions; ++J)
       {
         FCsum[I] += F(I, J) * C->sum[J]; // MV
         for (int i = 0; i < num_els; ++i)
         {
           FCgrad(I, i) += F(I, J) * C->grad(J, i); // 3*nels*MV
           FClap(I, i) += F(I, J) * C->lap(J, i);   // nels*MV
         }
       }
     }
     // evaluate components of J
     for (int I = 0; I < num_regions; ++I)
     {
       Jval += FCsum[I] * C->sum[I]; // VV
       for (int i = 0; i < num_els; ++i)
       {
         Jgrad[i] += 2 * FCsum[I] * C->grad(I, i);                                      // 3*nels*VV
         Jlap[i] += 2 * FCsum[I] * C->lap(I, i) + 2 * dot(FCgrad(I, i), C->grad(I, i)); // nels*VV
       }
     }
     // print out results every so often
     if (debug)
     {
       static int exp_print_index = 0;
       if (exp_print_index < debug_seqlen)
         evaluateExponents_print(app_log(), P);
       ++exp_print_index;
       exp_print_index = exp_print_index % debug_period;
     }
   }

◆ evaluateExponents_print()

void evaluateExponents_print	(	std::ostream &	os,
		const ParticleSet &	P
	)

inline

Definition at line 288 of file CountingJastrow.h.

References qmcplusplus::app_log(), Matrix< T, Alloc >::begin(), CountingJastrow< RegionType >::C, copy(), Matrix< T, Alloc >::end(), CountingJastrow< RegionType >::FCgrad, CountingJastrow< RegionType >::FClap, CountingJastrow< RegionType >::FCsum, CountingJastrow< RegionType >::Jgrad, CountingJastrow< RegionType >::Jlap, and CountingJastrow< RegionType >::Jval.

Referenced by CountingJastrow< RegionType >::evaluateDerivatives(), and CountingJastrow< RegionType >::evaluateExponents().

   {
     // print counting regions
     C->evaluate_print(app_log(), P);
     // FCsum, FCgrad, FClap
     os << "CountingJastrow::evaluateExponents_print: ";
     os << std::endl << "FCsum: ";
     std::copy(FCsum.begin(), FCsum.end(), std::ostream_iterator<RealType>(os, ", "));
     os << std::endl << "FCgrad: ";
     std::copy(FCgrad.begin(), FCgrad.end(), std::ostream_iterator<PosType>(os, ", "));
     os << std::endl << "FClap: ";
     std::copy(FClap.begin(), FClap.end(), std::ostream_iterator<RealType>(os, ", "));
     // Jval, Jgrad, Jlap
     os << std::endl << "Jval: " << Jval;
     os << std::endl << "Jgrad: ";
     std::copy(Jgrad.begin(), Jgrad.end(), std::ostream_iterator<PosType>(os, ", "));
     os << std::endl << "Jlap:  ";
     std::copy(Jlap.begin(), Jlap.end(), std::ostream_iterator<RealType>(os, ", "));
     os << std::endl << std::endl;
   }

◆ evaluateLog()

LogValue evaluateLog	(	const ParticleSet &	P,
		ParticleSet::ParticleGradient &	G,
		ParticleSet::ParticleLaplacian &	L
	)

inlineoverridevirtual

evaluate the value of the WaveFunctionComponent from scratch

Parameters

[in]	P	active ParticleSet
[out]	G	Gradients, $\nabla\ln\Psi$
[out]	L	Laplacians, $\nabla^2\ln\Psi$

Returns: the log value

Mainly for walker-by-walker move. The initial stage of particle-by-particle move also uses this. causes complete state update in WFC's

Implements WaveFunctionComponent.

Definition at line 221 of file CountingJastrow.h.

References CountingJastrow< RegionType >::evaluateExponents(), CountingJastrow< RegionType >::Jgrad, CountingJastrow< RegionType >::Jlap, CountingJastrow< RegionType >::Jval, WaveFunctionComponent::log_value_, and CountingJastrow< RegionType >::num_els.

Referenced by CountingJastrow< RegionType >::registerData(), qmcplusplus::TEST_CASE(), and CountingJastrow< RegionType >::updateBuffer().

   {
     evaluateExponents(P);
     for (int i = 0; i < num_els; ++i)
     {
       G[i] += Jgrad[i];
       L[i] += Jlap[i];
     }
     log_value_ = Jval;
     return log_value_;
   }

◆ evaluateTempExponents()

void evaluateTempExponents	(	ParticleSet &	P,
		int	iat
	)

inline

Definition at line 310 of file CountingJastrow.h.

Referenced by CountingJastrow< RegionType >::ratio(), and CountingJastrow< RegionType >::ratioGrad().

   {
     // evaluate temporary counting regions
     C->evaluateTemp(P, iat);
     Jval_t = 0;
     std::fill(Jgrad_t.begin(), Jgrad_t.end(), 0);
     std::fill(Jlap_t.begin(), Jlap_t.end(), 0);
     std::fill(FCsum_t.begin(), FCsum_t.end(), 0);
     std::fill(FCgrad_t.begin(), FCgrad_t.end(), 0);
     std::fill(FClap_t.begin(), FClap_t.end(), 0);
 
     // evaluate temp FC arrays
     for (int I = 0; I < num_regions; ++I)
     {
       for (int J = 0; J < num_regions; ++J)
       {
         FCsum_t[I] += F(I, J) * C->sum_t[J];
         FCgrad_t[I] += F(I, J) * C->grad_t[J];
         FClap_t[I] += F(I, J) * C->lap_t[J];
       }
     }
     // evaluate components of the exponent
     for (int I = 0; I < num_regions; ++I)
     {
       Jval_t += C->sum_t[I] * FCsum_t[I];
       for (int i = 0; i < num_els; ++i)
       {
         if (i == iat)
         {
           Jgrad_t[i] += C->grad_t[I] * 2 * FCsum_t[I];
           Jlap_t[i] += C->lap_t[I] * 2 * FCsum_t[I] + 2 * dot(C->grad_t[I], FCgrad_t[I]);
         }
         else
         {
           Jgrad_t[i] += C->grad(I, i) * 2 * FCsum_t[I];
           Jlap_t[i] += C->lap(I, i) * 2 * FCsum_t[I] + 2 * dot(C->grad(I, i), FCgrad(I, i));
         }
       }
     }
     // print out results every so often
     if (debug)
     {
       static int expt_print_index = 0;
       if (expt_print_index < debug_seqlen)
         evaluateTempExponents_print(app_log(), P, iat);
       ++expt_print_index;
       expt_print_index = expt_print_index % debug_period;
     }
   }

◆ evaluateTempExponents_print()

void evaluateTempExponents_print	(	std::ostream &	os,
		ParticleSet &	P,
		int	iat
	)

inline

Definition at line 360 of file CountingJastrow.h.

References qmcplusplus::app_log(), CountingJastrow< RegionType >::C, copy(), CountingJastrow< RegionType >::FCgrad_t, CountingJastrow< RegionType >::FClap_t, CountingJastrow< RegionType >::FCsum_t, CountingJastrow< RegionType >::Jgrad_t, CountingJastrow< RegionType >::Jlap_t, and CountingJastrow< RegionType >::Jval_t.

Referenced by CountingJastrow< RegionType >::evaluateTempExponents().

   {
     // print counting regions
     C->evaluateTemp_print(app_log(), P);
     // FCsum, FCgrad, FClap
     os << "CountingJastrow::evaluateTempExponents_print: iat: " << iat;
     os << std::endl << "FCsum_t: ";
     std::copy(FCsum_t.begin(), FCsum_t.end(), std::ostream_iterator<RealType>(os, ", "));
     os << std::endl << "FCgrad_t: ";
     std::copy(FCgrad_t.begin(), FCgrad_t.end(), std::ostream_iterator<PosType>(os, ", "));
     os << std::endl << "FClap_t: ";
     std::copy(FClap_t.begin(), FClap_t.end(), std::ostream_iterator<RealType>(os, ", "));
     // Jval, Jgrad, Jlap
     os << std::endl << "Jval_t: " << Jval_t;
     os << std::endl << "Jgrad_t: ";
     std::copy(Jgrad_t.begin(), Jgrad_t.end(), std::ostream_iterator<PosType>(os, ", "));
     os << std::endl << "Jlap_t:  ";
     std::copy(Jlap_t.begin(), Jlap_t.end(), std::ostream_iterator<RealType>(os, ", "));
     os << std::endl << std::endl;
   }

◆ extractOptimizableObjectRefs()

void extractOptimizableObjectRefs ( UniqueOptObjRefs & opt_obj_refs )

inlineoverridevirtual

extract underlying OptimizableObject references

Parameters

opt_obj_refs aggregated list of optimizable object references

Reimplemented from WaveFunctionComponent.

Definition at line 108 of file CountingJastrow.h.

References UniqueOptObjRefs::push_back().

108 { opt_obj_refs.push_back(*this); }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements WaveFunctionComponent.

Definition at line 104 of file CountingJastrow.h.

104 { return "CountingJastrow"; }

◆ initialize()

void initialize ( )

inline

Definition at line 150 of file CountingJastrow.h.

   {
     // allocate memory and assign variables
     num_regions = C->size();
 
     FCsum.resize(num_regions);
     FCgrad.resize(num_regions, num_els);
     FClap.resize(num_regions, num_els);
 
     FCggsum.resize(num_regions);
     FClapsum.resize(num_regions);
 
     FCsum_t.resize(num_regions);
     FCgrad_t.resize(num_regions);
     FClap_t.resize(num_regions);
 
     Jgrad.resize(num_els);
     Jlap.resize(num_els);
 
     Jgrad_t.resize(num_els);
     Jlap_t.resize(num_els);
 
     // check that F, C dimensions match
     if (F.size() != num_regions * num_regions)
     {
       std::ostringstream err;
       err << "CountingJastrow::initialize: F, C dimension mismatch: F: " << F.size() << ", C: " << num_regions
           << std::endl;
       APP_ABORT(err.str());
     }
 
     // for CountingRegion optimization: don't allocate every evalDeriv call
     int max_num_derivs = C->max_num_derivs();
     dCsum.resize(max_num_derivs, num_regions);
     dCggsum.resize(max_num_derivs, num_regions);
     dClapsum.resize(max_num_derivs, num_regions);
     dCFCggsum.resize(max_num_derivs);
     // register optimizable parameters
     std::ostringstream os;
     std::string id_F;
     for (int I = 0; I < num_regions; ++I)
       for (int J = I, IJ = I * num_regions + I; J < num_regions; ++J, ++IJ)
       {
         os.str("");
         os << "F_" << I << "_" << J;
         id_F = os.str();
         myVars.insert(id_F, F(IJ), (opt_F && I < (num_regions - 1)));
         opt_index[OPT_F].push_back(IJ);
         opt_id[OPT_F].push_back(id_F);
       }
     myVars.resetIndex();
   }

◆ isOptimizable()

bool isOptimizable ( ) const

inlineoverridevirtual

if true, this contains optimizable components

Reimplemented from WaveFunctionComponent.

Definition at line 106 of file CountingJastrow.h.

References CountingJastrow< RegionType >::opt_C, and CountingJastrow< RegionType >::opt_F.

106 { return opt_C || opt_F; }

qmcplusplus::CountingJastrow::opt_C

bool opt_C

Definition: CountingJastrow.h:45

qmcplusplus::CountingJastrow::opt_F

bool opt_F

Definition: CountingJastrow.h:43

◆ makeClone()

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

inlineoverridevirtual

make clone

Parameters

tqp	target Quantum ParticleSet
deepcopy	if true, make a decopy

If not true, return a proxy class

Reimplemented from WaveFunctionComponent.

Definition at line 467 of file CountingJastrow.h.

References CountingJastrow< RegionType >::C, CountingJastrow< RegionType >::debug, CountingJastrow< RegionType >::debug_period, CountingJastrow< RegionType >::debug_seqlen, CountingJastrow< RegionType >::F, CountingJastrow< RegionType >::opt_C, and CountingJastrow< RegionType >::opt_F.

Referenced by qmcplusplus::TEST_CASE().

   {
     auto cjc = std::make_unique<CountingJastrow>(tqp, C->makeClone(), F, opt_C, opt_F);
     cjc->addDebug(debug, debug_seqlen, debug_period);
     cjc->initialize();
     return cjc;
   }

◆ ratio()

PsiValue ratio	(	ParticleSet &	P,
		int	iat
	)

inlineoverridevirtual

evaluate the ratio of the new to old WaveFunctionComponent value

Parameters

P	the active ParticleSet
iat	the index of a particle

Returns: $\psi( \{ {\bf R}^{'} \} )/ \psi( \{ {\bf R}\})$

Specialized for particle-by-particle move

Implements WaveFunctionComponent.

Definition at line 418 of file CountingJastrow.h.

References CountingJastrow< RegionType >::evaluateTempExponents(), qmcplusplus::exp(), CountingJastrow< RegionType >::Jval, and CountingJastrow< RegionType >::Jval_t.

Referenced by qmcplusplus::TEST_CASE().

   {
     evaluateTempExponents(P, iat);
     return std::exp(static_cast<PsiValue>(Jval_t - Jval));
   }

◆ ratioGrad()

PsiValue ratioGrad	(	ParticleSet &	P,
		int	iat,
		GradType &	grad_iat
	)

inlineoverridevirtual

evaluate the ratio of the new to old WaveFunctionComponent value and the new gradient

Parameters

P	the active ParticleSet
iat	the index of a particle
grad_iat	Gradient for the active particle

Reimplemented from WaveFunctionComponent.

Definition at line 388 of file CountingJastrow.h.

References CountingJastrow< RegionType >::evaluateTempExponents(), qmcplusplus::exp(), CountingJastrow< RegionType >::Jgrad_t, CountingJastrow< RegionType >::Jval, and CountingJastrow< RegionType >::Jval_t.

Referenced by qmcplusplus::TEST_CASE().

   {
     evaluateTempExponents(P, iat);
     grad_iat += Jgrad_t[iat];
     return std::exp(static_cast<PsiValue>(Jval_t - Jval));
   }

◆ recompute()

void recompute ( const ParticleSet & P )

inlineoverridevirtual

recompute the value of the WaveFunctionComponents which require critical accuracy.

needed for Slater Determinants but not needed for most types of WaveFunctionComponents

Reimplemented from WaveFunctionComponent.

Definition at line 236 of file CountingJastrow.h.

References CountingJastrow< RegionType >::evaluateExponents(), CountingJastrow< RegionType >::Jval, and WaveFunctionComponent::log_value_.

Referenced by qmcplusplus::TEST_CASE().

   {
     evaluateExponents(P);
     log_value_ = Jval;
   }

◆ registerData()

void registerData	(	ParticleSet &	P,
		WFBufferType &	buf
	)

inlineoverridevirtual

For particle-by-particle move.

Requests space in the buffer based on the data type sizes of the objects in this class.

Parameters

P	particle set
buf	Anonymous storage

Implements WaveFunctionComponent.

Definition at line 424 of file CountingJastrow.h.

References PooledMemory< T_scalar, Alloc >::add(), PooledMemory< T_scalar, Alloc >::current(), DEBUG_PSIBUFFER, QMCTraits::DIM, CountingJastrow< RegionType >::evaluateLog(), ParticleSet::G, CountingJastrow< RegionType >::Jgrad, CountingJastrow< RegionType >::Jlap, CountingJastrow< RegionType >::Jval, and ParticleSet::L.

   {
     LogValue logValue     = evaluateLog(P, P.G, P.L);
     RealType* Jlap_begin  = &Jlap[0];
     RealType* Jlap_end    = Jlap_begin + Jlap.size();
     RealType* Jgrad_begin = &Jgrad[0][0];
     RealType* Jgrad_end   = Jgrad_begin + Jgrad.size() * DIM;
     DEBUG_PSIBUFFER(" CountingJastrow::registerData", buf.current());
     buf.add(&Jval, &Jval);
     buf.add(Jlap_begin, Jlap_end);
     buf.add(Jgrad_begin, Jgrad_end);
     DEBUG_PSIBUFFER(" CountingJastrow::registerData", buf.current());
   }

◆ reportStatus()

void reportStatus ( std::ostream & os )

inlineoverridevirtual

print the state, e.g., optimizables

Reimplemented from OptimizableObject.

Definition at line 204 of file CountingJastrow.h.

References CountingJastrow< RegionType >::C, CountingJastrow< RegionType >::debug, CountingJastrow< RegionType >::debug_period, CountingJastrow< RegionType >::debug_seqlen, WaveFunctionComponent::myVars, CountingJastrow< RegionType >::num_regions, VariableSet::print(), and VariableSet::size_of_active().

   {
     os << "    Number of counting regions: " << num_regions << std::endl;
     os << "    Total optimizable parameters: " << C->total_num_derivs() + myVars.size_of_active() << std::endl;
     os << "    F matrix optimizable parameters: " << myVars.size_of_active() << std::endl;
     if (debug)
     {
       os << "    Debug sample sequence length: " << debug_seqlen << std::endl;
       os << "    Debug sample periodicity: " << debug_period << std::endl;
     }
     os << std::endl;
     myVars.print(os, 6, true);
     os << std::endl;
     C->reportStatus(os);
   }

◆ resetParametersExclusive()

void resetParametersExclusive ( const opt_variables_type & active )

inlineoverridevirtual

reset the parameters during optimizations.

Exclusive, see checkInVariablesExclusive

Implements OptimizableObject.

Definition at line 123 of file CountingJastrow.h.

References CountingJastrow< RegionType >::C, CountingJastrow< RegionType >::F, VariableSet::getIndex(), VariableSet::getLoc(), WaveFunctionComponent::myVars, CountingJastrow< RegionType >::num_regions, CountingJastrow< RegionType >::OPT_F, CountingJastrow< RegionType >::opt_id, CountingJastrow< RegionType >::opt_index, VariableSet::size(), and VariableSet::where().

Referenced by qmcplusplus::TEST_CASE().

   {
     int ia, IJ, JI;
     std::string id;
     myVars.getIndex(active);
     for (int i = 0; i < myVars.size(); ++i)
     {
       ia = myVars.where(i);
       if (ia != -1)
         myVars[i] = active[ia];
     }
     // set F parameters from myVars
     for (int oi = 0; oi < opt_index[OPT_F].size(); ++oi)
     {
       IJ         = opt_index[OPT_F][oi];
       JI         = num_regions * (IJ % num_regions) + IJ / num_regions;
       id         = opt_id[OPT_F][oi];
       ia         = active.getLoc(id);
       myVars[id] = active[ia];
       F(IJ)      = std::real(myVars[id]);
       F(JI)      = std::real(myVars[id]);
     }
     // reset parameters for counting regions
     C->resetParameters(active);
   }

◆ restore()

void restore ( int iat )

inlineoverridevirtual

If a move for iat-th particle is rejected, restore to the content.

Parameters

iat	index of the particle whose new position was proposed

Ye: hopefully we can gradually move away from restore

Implements WaveFunctionComponent.

Definition at line 416 of file CountingJastrow.h.

References CountingJastrow< RegionType >::C.

416 { C->restore(iat); }

qmcplusplus::CountingJastrow::C

std::unique_ptr< RegionType > C

Definition: CountingJastrow.h:40

◆ updateBuffer()

LogValue updateBuffer	(	ParticleSet &	P,
		WFBufferType &	buf,
		bool	fromscratch = `false`
	)

inlineoverridevirtual

For particle-by-particle move.

Put the objects of this class in the walker buffer or forward the memory cursor.

Parameters

P	particle set
buf	Anonymous storage
fromscratch	request recomputing the precision critical pieces of wavefunction from scratch

Returns: log value of the wavefunction.

Implements WaveFunctionComponent.

Definition at line 438 of file CountingJastrow.h.

References PooledMemory< T_scalar, Alloc >::current(), DEBUG_PSIBUFFER, QMCTraits::DIM, CountingJastrow< RegionType >::evaluateLog(), ParticleSet::G, CountingJastrow< RegionType >::Jgrad, CountingJastrow< RegionType >::Jlap, CountingJastrow< RegionType >::Jval, ParticleSet::L, and PooledMemory< T_scalar, Alloc >::put().

   {
     LogValue logValue     = evaluateLog(P, P.G, P.L);
     RealType* Jlap_begin  = &Jlap[0];
     RealType* Jlap_end    = Jlap_begin + Jlap.size();
     RealType* Jgrad_begin = &Jgrad[0][0];
     RealType* Jgrad_end   = Jgrad_begin + Jgrad.size() * DIM;
     DEBUG_PSIBUFFER(" CountingJastrow::updateBuffer ", buf.current());
     buf.put(&Jval, &Jval);
     buf.put(Jlap_begin, Jlap_end);
     buf.put(Jgrad_begin, Jgrad_end);
     DEBUG_PSIBUFFER(" CountingJastrow::updateBuffer ", buf.current());
     return Jval;
   }