class to handle determinants with backflow More...

Inheritance diagram for DiracDeterminantWithBackflow:

Collaboration diagram for DiracDeterminantWithBackflow:

Public Types
using	ValueVector = SPOSet::ValueVector

using	ValueMatrix = SPOSet::ValueMatrix

using	GradVector = SPOSet::GradVector

using	GradMatrix = SPOSet::GradMatrix

using	HessMatrix = SPOSet::HessMatrix

using	HessVector = SPOSet::HessVector

using	GGGMatrix = SPOSet::GGGMatrix

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 Member Functions
	DiracDeterminantWithBackflow (std::unique_ptr< SPOSet > &&spos, BackflowTransformation &BF, int first, int last)
	constructor More...

	~DiracDeterminantWithBackflow () override
	default destructor More...

	DiracDeterminantWithBackflow (const DiracDeterminantWithBackflow &s)=delete

DiracDeterminantWithBackflow &	operator= (const DiracDeterminantWithBackflow &s)=delete

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

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

void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &active, std::vector< RealType > &dlogpsi, std::vector< RealType > &dhpsioverpsi, ParticleSet::ParticleGradient G0, ParticleSet::ParticleLaplacian L0, int k)

void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &active, int offset, Matrix< RealType > &dlogpsi, Array< GradType, OHMMS_DIM > &dG, Matrix< RealType > &dL) override

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...

PsiValue	ratio (ParticleSet &P, int iat) override
	return the ratio only for the iat-th partcle move More...

void	evaluateRatiosAlltoOne (ParticleSet &P, std::vector< ValueType > &ratios) override
	evaluate the ratios of one virtual move with respect to all the particles 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...

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

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

GradType	evalGradSource (ParticleSet &P, ParticleSet &source, int iat, TinyVector< ParticleSet::ParticleGradient, OHMMS_DIM > &grad_grad, TinyVector< ParticleSet::ParticleLaplacian, OHMMS_DIM > &lapl_grad) override

void	acceptMove (ParticleSet &P, int iat, bool safe_to_delay=false) override
	move was accepted, update the real container More...

void	restore (int iat) override
	move was rejected. More...

LogValue	evaluateLog (const ParticleSet &P, ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L) override
	Calculate the log value of the Dirac determinant for particles. More...

std::unique_ptr< DiracDeterminantWithBackflow >	makeCopyWithBF (std::unique_ptr< SPOSet > &&spo, BackflowTransformation &BF) const
	cloning function More...

std::unique_ptr< DiracDeterminantBase >	makeCopy (std::unique_ptr< SPOSet > &&spo) const override
	cloning function More...

void	testDerivFjj (ParticleSet &P, int pa)

void	testGGG (ParticleSet &P)

void	testGG (ParticleSet &P)

void	testDerivLi (ParticleSet &P, int pa)

void	testL (ParticleSet &P)

Public Member Functions inherited from DiracDeterminantBase
	DiracDeterminantBase (const std::string &class_name, std::unique_ptr< SPOSet > &&spos, int first, int last)
	constructor More...

	~DiracDeterminantBase () override
	default destructor More...

	DiracDeterminantBase (const DiracDeterminantBase &s)=delete

DiracDeterminantBase &	operator= (const DiracDeterminantBase &s)=delete

SPOSetPtr	getPhi () const

int	getFirstIndex () const

int	getLastIndex () const

virtual ValueMatrix &	getPsiMinv ()

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

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

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

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

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

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

virtual void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &active, int offset, Matrix< RealType > &dlogpsi, Array< GradType, 3 > &dG, Matrix< RealType > &dL)

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

PsiValue	ratioGradWithSpin (ParticleSet &P, int iat, GradType &grad_iat, ComplexType &spingrad) override
	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...

GradType	evalGradWithSpin (ParticleSet &P, int iat, ComplexType &spingrad) override
	return the current spin gradient for the iat-th particle Default implementation assumes that WaveFunctionComponent does not explicitly depend on Spin. 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 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 LogValue	evaluateLog (const ParticleSet &P, ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L)=0
	evaluate the value of the WaveFunctionComponent from scratch 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	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	recompute (const ParticleSet &P)
	recompute the value of the WaveFunctionComponents which require critical accuracy. More...

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

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

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

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

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

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

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

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

virtual GradType	evalGrad (ParticleSet &P, int iat)
	return the current gradient for the iat-th particle 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	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 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...

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...

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 PsiValue	ratio (ParticleSet &P, int iat)=0
	evaluate the ratio of the new to old WaveFunctionComponent value More...

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

virtual void	restore (int iat)=0
	If a move for iat-th particle is rejected, restore to the content. 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 void	evaluateHessian (ParticleSet &P, HessVector &grad_grad_psi_all)

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

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	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...

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	isMultiDet () const
	true, if this component is multi-determinant More...

virtual LogValue	evaluateLog (const ParticleSet &P, ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L)=0
	evaluate the value of the WaveFunctionComponent from scratch 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	recompute (const ParticleSet &P)
	recompute the value of the WaveFunctionComponents which require critical accuracy. 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

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, TinyVector< ParticleSet::ParticleGradient, OHMMS_DIM > &grad_grad, TinyVector< ParticleSet::ParticleLaplacian, OHMMS_DIM > &lapl_grad)
	Adds the gradient w.r.t. 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	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	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 Attributes
BackflowTransformation &	BFTrans_

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...

Private Member Functions
void	resize (int nel, int morb)
	reset the size: with the number of particles and number of orbtials More...

ValueType	rcdot (TinyVector< RealType, OHMMS_DIM > &lhs, TinyVector< ValueType, OHMMS_DIM > &rhs)

void	dummyEvalLi (ValueType &L1, ValueType &L2, ValueType &L3)

void	evaluate_SPO (ValueMatrix &logdet, GradMatrix &dlogdet, HessMatrix &grad_grad_logdet)
	replace of SPOSet::evaluate function with the removal of t_logpsi More...

void	evaluate_SPO (ValueMatrix &logdet, GradMatrix &dlogdet, HessMatrix &grad_grad_logdet, GGGMatrix &grad_grad_grad_logdet)

Private Attributes
int	NP
	total number of particles. Ye: used to track first time allocation but I still feel it very strange. More...

int	NumParticles

GradMatrix	dFa

HessMatrix	grad_grad_psiM

HessVector	grad_gradV

HessMatrix	grad_grad_psiM_temp

GGGMatrix	grad_grad_grad_psiM

ParticleSet::ParticleGradient	Gtemp

ValueType	La1

ValueType	La2

ValueType	La3

HessMatrix	Ajk_sum

HessMatrix	Qmat

GradMatrix	Fmat

GradVector	Fmatdiag

GradVector	Fmatdiag_temp

ValueMatrix	psiM
	psiM(j,i) $= \psi_j({\bf r}_i)$ More...

ValueMatrix	psiM_temp

ValueMatrix	psiMinv
	temporary container for testing More...

GradMatrix	dpsiM
	dpsiM(i,j) $= \nabla_i \psi_j({\bf r}_i)$ More...

GradMatrix	dpsiM_temp

ValueVector	psiV
	value of single-particle orbital for particle-by-particle update More...

GradVector	dpsiV

ValueVector	d2psiV

PsiValue	curRatio

ParticleSet::SingleParticleValue *	FirstAddressOfG

ParticleSet::SingleParticleValue *	LastAddressOfG

ValueType *	FirstAddressOfdV

ValueType *	LastAddressOfdV

Vector< ValueType >	WorkSpace

Vector< IndexType >	Pivot

ValueMatrix	psiMinv_temp

ValueType *	FirstAddressOfGGG

ValueType *	LastAddressOfGGG

ValueType *	FirstAddressOfFm

ValueType *	LastAddressOfFm

ParticleSet::ParticleGradient	myG

ParticleSet::ParticleGradient	myG_temp

ParticleSet::ParticleLaplacian	myL

ParticleSet::ParticleLaplacian	myL_temp

Additional Inherited Members
Static Protected Member Functions inherited from DiracDeterminantBase
static bool	checkG (const GradType &g)

Protected Attributes inherited from DiracDeterminantBase
NewTimer &	UpdateTimer
	Timers. More...

NewTimer &	RatioTimer

NewTimer &	InverseTimer

NewTimer &	BufferTimer

NewTimer &	SPOVTimer

NewTimer &	SPOVGLTimer

const std::unique_ptr< SPOSet >	Phi
	a set of single-particle orbitals used to fill in the values of the matrix More...

const int	FirstIndex
	index of the first particle with respect to the particle set More...

const int	LastIndex
	index of the last particle with respect to the particle set More...

const int	NumOrbitals
	number of single-particle orbitals which belong to this Dirac determinant More...

const int	NumPtcls
	number of particles which belong to this Dirac determinant More...

ValueMatrix	dummy_vmt

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...

Detailed Description

class to handle determinants with backflow

Definition at line 33 of file DiracDeterminantWithBackflow.h.

Member Typedef Documentation

◆ GGGMatrix

using GGGMatrix = SPOSet::GGGMatrix

Definition at line 42 of file DiracDeterminantWithBackflow.h.

◆ GradMatrix

using GradMatrix = SPOSet::GradMatrix

Definition at line 39 of file DiracDeterminantWithBackflow.h.

◆ GradVector

using GradVector = SPOSet::GradVector

Definition at line 38 of file DiracDeterminantWithBackflow.h.

◆ HessMatrix

using HessMatrix = SPOSet::HessMatrix

Definition at line 40 of file DiracDeterminantWithBackflow.h.

◆ HessVector

using HessVector = SPOSet::HessVector

Definition at line 41 of file DiracDeterminantWithBackflow.h.

◆ ValueMatrix

using ValueMatrix = SPOSet::ValueMatrix

Definition at line 37 of file DiracDeterminantWithBackflow.h.

◆ ValueVector

using ValueVector = SPOSet::ValueVector

Definition at line 36 of file DiracDeterminantWithBackflow.h.

Constructor & Destructor Documentation

◆ DiracDeterminantWithBackflow() [1/2]

DiracDeterminantWithBackflow	(	std::unique_ptr< SPOSet > &&	spos,
		BackflowTransformation &	BF,
		int	first,
		int	last
	)

constructor

Parameters

spos	the single-particle orbital set
first	index of the first particle

Definition at line 31 of file DiracDeterminantWithBackflow.cpp.

References DiracDeterminantWithBackflow::BFTrans_, ParticleSet::getTotalNum(), DiracDeterminantWithBackflow::NP, DiracDeterminantWithBackflow::NumParticles, DiracDeterminantBase::NumPtcls, BackflowTransformation::QP, and DiracDeterminantWithBackflow::resize().

     : DiracDeterminantBase(getClassName(), std::move(spos), first, last), BFTrans_(BF)
 {
   NumParticles = BFTrans_.QP.getTotalNum();
   NP           = 0;
   resize(NumPtcls, NumPtcls);
 }

◆ ~DiracDeterminantWithBackflow()

~DiracDeterminantWithBackflow ( )

override

default destructor

Definition at line 43 of file DiracDeterminantWithBackflow.cpp.

43 {}

◆ DiracDeterminantWithBackflow() [2/2]

DiracDeterminantWithBackflow ( const DiracDeterminantWithBackflow & s )

delete

Member Function Documentation

◆ acceptMove()

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

overridevirtual

move was accepted, update the real container

Implements WaveFunctionComponent.

Definition at line 561 of file DiracDeterminantWithBackflow.cpp.

 {
   log_value_ += convertValueToLog(curRatio);
   UpdateTimer.start();
   switch (UpdateMode)
   {
   case ORB_PBYP_RATIO:
     psiMinv = psiMinv_temp;
     psiM    = psiM_temp;
     break;
   case ORB_PBYP_PARTIAL:
     psiMinv        = psiMinv_temp;
     psiM           = psiM_temp;
     dpsiM          = dpsiM_temp;
     grad_grad_psiM = grad_grad_psiM_temp;
     Fmatdiag       = Fmatdiag_temp;
     break;
   default:
     myG            = myG_temp;
     myL            = myL_temp;
     psiMinv        = psiMinv_temp;
     psiM           = psiM_temp;
     dpsiM          = dpsiM_temp;
     grad_grad_psiM = grad_grad_psiM_temp;
     Fmatdiag       = Fmatdiag_temp;
     break;
   }
   UpdateTimer.stop();
   curRatio = 1.0;
 }

◆ copyFromBuffer()

void copyFromBuffer	(	ParticleSet &	P,
		WFBufferType &	buf
	)

overridevirtual

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 167 of file DiracDeterminantWithBackflow.cpp.

 {
   buf.get(psiM.first_address(), psiM.last_address());
   buf.get(FirstAddressOfdV, LastAddressOfdV);
   buf.get(FirstAddressOfGGG, LastAddressOfGGG);
   buf.get(myL.first_address(), myL.last_address());
   buf.get(FirstAddressOfG, LastAddressOfG);
   buf.get(FirstAddressOfFm, LastAddressOfFm);
   buf.get(psiMinv.first_address(), psiMinv.last_address());
   buf.get(log_value_);
   //re-evaluate it for testing
   //Phi.evaluate(P, FirstIndex, LastIndex, psiM, dpsiM, d2psiM);
   //CurrentDet = Invert(psiM.data(),NumPtcls,NumOrbitals);
   //need extra copy for gradient/laplacian calculations without updating it
   //psiM_temp = psiM;
   //dpsiM_temp = dpsiM;
   //d2psiM_temp = d2psiM;
 }

◆ dummyEvalLi()

void dummyEvalLi	(	ValueType &	L1,
		ValueType &	L2,
		ValueType &	L3
	)

private

Definition at line 1318 of file DiracDeterminantWithBackflow.cpp.

References BackflowTransformation::Amat, DiracDeterminantWithBackflow::BFTrans_, BackflowTransformation::Bmat_full, Vector< T, Alloc >::data(), qmcplusplus::simd::dot(), qmcplusplus::dot(), DiracDeterminantWithBackflow::dpsiM, DiracDeterminantWithBackflow::evaluate_SPO(), DiracDeterminantBase::FirstIndex, DiracDeterminantWithBackflow::Fmat, ParticleSet::getTotalNum(), DiracDeterminantWithBackflow::grad_grad_psiM, DiracDeterminantBase::InverseTimer, qmcplusplus::InvertWithLog(), WaveFunctionComponent::log_value_, DiracDeterminantBase::NumOrbitals, DiracDeterminantBase::NumPtcls, qmcplusplus::outerProduct(), DiracDeterminantWithBackflow::Pivot, DiracDeterminantWithBackflow::psiM, DiracDeterminantWithBackflow::psiMinv, BackflowTransformation::QP, DiracDeterminantWithBackflow::rcdot(), TimerType< CLOCK >::start(), TimerType< CLOCK >::stop(), qmcplusplus::traceAtB(), qmcplusplus::transpose(), and DiracDeterminantWithBackflow::WorkSpace.

Referenced by DiracDeterminantWithBackflow::testDerivLi().

 {
   L1 = L2 = L3 = 0.0;
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM);
   psiMinv = psiM;
   InverseTimer.start();
   InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
   InverseTimer.stop();
   for (int i = 0; i < NumPtcls; i++)
     for (int j = 0; j < NumPtcls; j++)
     {
       Fmat(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
     }
   GradType temp;
   int num = BFTrans_.QP.getTotalNum();
   for (int i = 0; i < num; i++)
   {
     for (int j = 0; j < NumPtcls; j++)
       L1 += rcdot(Fmat(j, j), BFTrans_.Bmat_full(i, FirstIndex + j));
   }
   for (int j = 0; j < NumPtcls; j++)
   {
     HessType q_j;
     for (int k = 0; k < NumPtcls; k++)
       q_j += psiMinv(j, k) * grad_grad_psiM(j, k);
     HessType a_j;
     for (int i = 0; i < num; i++)
       a_j += dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + j));
     L2 += traceAtB(a_j, q_j);
     for (int k = 0; k < NumPtcls; k++)
     {
       HessType a_jk;
       for (int i = 0; i < num; i++)
         a_jk += dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + k));
       L3 -= traceAtB(a_jk, outerProduct(Fmat(k, j), Fmat(j, k)));
     }
   }
 }

◆ evalGrad()

DiracDeterminantWithBackflow::GradType evalGrad	(	ParticleSet &	P,
		int	iat
	)

overridevirtual

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 229 of file DiracDeterminantWithBackflow.cpp.

References BackflowTransformation::Amat, DiracDeterminantWithBackflow::BFTrans_, qmcplusplus::dot(), DiracDeterminantBase::FirstIndex, DiracDeterminantWithBackflow::Fmatdiag, and DiracDeterminantBase::NumPtcls.

 {
   GradType g;
   g = 0.0;
   for (int j = 0; j < NumPtcls; j++)
   {
     g += dot(BFTrans_.Amat(iat, FirstIndex + j), Fmatdiag[j]);
   }
   return g;
 }

◆ evalGradSource() [1/2]

DiracDeterminantWithBackflow::GradType evalGradSource	(	ParticleSet &	P,
		ParticleSet &	source,
		int	iat
	)

overridevirtual

return the logarithmic gradient for the iat-th particle of the source particleset

Parameters

Pquantum	particle set
iat	particle index

Returns: the gradient of the iat-th particle

Reimplemented from WaveFunctionComponent.

Definition at line 240 of file DiracDeterminantWithBackflow.cpp.

References APP_ABORT.

 {
   APP_ABORT(" Need to implement DiracDeterminantWithBackflow::evalGradSource() \n");
   return GradType();
 }

◆ evalGradSource() [2/2]

DiracDeterminantWithBackflow::GradType evalGradSource	(	ParticleSet &	P,
		ParticleSet &	source,
		int	iat,
		TinyVector< ParticleSet::ParticleGradient, OHMMS_DIM > &	grad_grad,
		TinyVector< ParticleSet::ParticleLaplacian, OHMMS_DIM > &	lapl_grad
	)

override

Definition at line 248 of file DiracDeterminantWithBackflow.cpp.

References APP_ABORT.

 {
   APP_ABORT(" Need to implement DiracDeterminantWithBackflow::evalGradSource() \n");
   return GradType();
 }

◆ evaluate_SPO() [1/2]

void evaluate_SPO	(	ValueMatrix &	logdet,
		GradMatrix &	dlogdet,
		HessMatrix &	grad_grad_logdet
	)

private

replace of SPOSet::evaluate function with the removal of t_logpsi

Definition at line 82 of file DiracDeterminantWithBackflow.cpp.

References DiracDeterminantWithBackflow::BFTrans_, DiracDeterminantBase::FirstIndex, DiracDeterminantBase::LastIndex, DiracDeterminantBase::NumOrbitals, DiracDeterminantBase::Phi, DiracDeterminantWithBackflow::psiM_temp, BackflowTransformation::QP, and qmcplusplus::simd::transpose().

Referenced by DiracDeterminantWithBackflow::dummyEvalLi(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::testDerivFjj(), DiracDeterminantWithBackflow::testGG(), DiracDeterminantWithBackflow::testGGG(), and DiracDeterminantWithBackflow::testL().

 {
   Phi->evaluate_notranspose(BFTrans_.QP, FirstIndex, LastIndex, psiM_temp, dlogdet, grad_grad_logdet);
   simd::transpose(psiM_temp.data(), NumOrbitals, psiM_temp.cols(), logdet.data(), NumOrbitals, logdet.cols());
 }

◆ evaluate_SPO() [2/2]

void evaluate_SPO	(	ValueMatrix &	logdet,
		GradMatrix &	dlogdet,
		HessMatrix &	grad_grad_logdet,
		GGGMatrix &	grad_grad_grad_logdet
	)

private

Definition at line 88 of file DiracDeterminantWithBackflow.cpp.

References DiracDeterminantWithBackflow::BFTrans_, DiracDeterminantBase::FirstIndex, DiracDeterminantBase::LastIndex, DiracDeterminantBase::NumOrbitals, DiracDeterminantBase::Phi, DiracDeterminantWithBackflow::psiM_temp, BackflowTransformation::QP, and qmcplusplus::simd::transpose().

 {
   Phi->evaluate_notranspose(BFTrans_.QP, FirstIndex, LastIndex, psiM_temp, dlogdet, grad_grad_logdet,
                             grad_grad_grad_logdet);
   simd::transpose(psiM_temp.data(), NumOrbitals, psiM_temp.cols(), logdet.data(), NumOrbitals, logdet.cols());
 }

◆ evaluateDerivatives() [1/3]

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

overridevirtual

Compute the derivatives of both the log of the wavefunction and kinetic energy with respect to optimizable parameters.

Parameters

P	particle set
optvars	optimizable parameters
dlogpsi	array of derivatives of the log of the wavefunction. Add the contribution from this component.
dhpsioverpsi	array of Hamiltonian derivatives. Add the kinetic energy derivatives contribution from this component. $-\frac{1}{2}{\partial}_\alpha \tilde L - G \cdot {\partial}_\alpha \tilde G$ . $\tilde L$ and $\tilde G$ are from this WaveFunctionComponent. is from TrialWaveFunction. The 1/m factor is applied in TrialWaveFunction. This is a bug when the particle set doesn't hold equal mass particles.

Implements WaveFunctionComponent.

Definition at line 596 of file DiracDeterminantWithBackflow.cpp.

Referenced by SlaterDetWithBackflow::testDerivGL(), and DiracDeterminantWithBackflow::testDerivLi().

 {
   /*  Note:
    *    Since evaluateDerivatives seems to always be called after
    *    evaluateDeltaLog, which in turn calls evaluateLog, many
    *    of the structures calculated here do not need to be calculated
    *    again. The only one that need to be called is a routine
    *    to calculate grad_grad_grad_psiM. The following structures
    *    should already be known here:
    *       -psiM
    *       -dpsiM
    *       -grad_grad_psiM
    *       -psiM_inv
    *       -Fmat
    */
   {
     //       must compute if didn;t call earlier function
     evaluate_SPO(psiM, dpsiM, grad_grad_psiM, grad_grad_grad_psiM);
     //       copy(psiM.begin(),psiM.end(),psiMinv.begin());
     psiMinv = psiM;
     //       invert backflow matrix
     InverseTimer.start();
     InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
     InverseTimer.stop();
     //       calculate F matrix (gradients wrt bf coordinates)
     //       could use dgemv with increments of 3*nCols
     for (int i = 0; i < NumPtcls; i++)
       for (int j = 0; j < NumPtcls; j++)
       {
         Fmat(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
       }
   }
   int num = P.getTotalNum();
   //mmorales: cheap trick for now
   for (int j = 0; j < NumPtcls; j++)
     for (int k = 0; k < NumPtcls; k++)
     {
       HessType& q_jk = Qmat(j, k);
       q_jk           = 0;
       for (int n = 0; n < NumPtcls; n++)
         q_jk += psiMinv(j, n) * grad_grad_psiM(k, n);
       HessType& a_jk = Ajk_sum(j, k);
       a_jk           = 0;
       for (int n = 0; n < num; n++)
         a_jk += dot(transpose(BFTrans_.Amat(n, FirstIndex + j)), BFTrans_.Amat(n, FirstIndex + k));
     }
   // this is a mess, there should be a better way
   // to rearrange this
   for (int pa = 0; pa < BFTrans_.optIndexMap.size(); ++pa)
   //for (int pa=0; pa<BFTrans_.numParams; ++pa)
   {
     ValueType dpsia = 0;
     Gtemp           = 0;
     ValueType dLa   = 0;
     GradType temp;
     temp = 0;
     for (int i = 0; i < NumPtcls; i++)
       for (int j = 0; j < NumPtcls; j++)
       {
         GradType f_a;
         f_a         = 0;
         PosType& cj = BFTrans_.Cmat(pa, FirstIndex + j);
         for (int k = 0; k < NumPtcls; k++)
         {
           f_a += (psiMinv(i, k) * dot(grad_grad_psiM(j, k), cj) -
                   Fmat(k, j) * rcdot(BFTrans_.Cmat(pa, FirstIndex + k), Fmat(i, k)));
         }
         dFa(i, j) = f_a;
       }
     for (int i = 0; i < num; i++)
     {
       temp = 0;
       for (int j = 0; j < NumPtcls; j++)
         temp +=
             (dot(BFTrans_.Xmat(pa, i, FirstIndex + j), Fmat(j, j)) + dot(BFTrans_.Amat(i, FirstIndex + j), dFa(j, j)));
       Gtemp[i] += temp;
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       GradType B_j;
       B_j = 0;
       for (int i = 0; i < num; i++)
         B_j += BFTrans_.Bmat_full(i, FirstIndex + j);
       dLa += (rcdot(Fmat(j, j), BFTrans_.Ymat(pa, FirstIndex + j)) + dot(B_j, dFa(j, j)));
       dpsia += rcdot(Fmat(j, j), BFTrans_.Cmat(pa, FirstIndex + j));
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       HessType a_j_prime;
       a_j_prime = 0;
       for (int i = 0; i < num; i++)
         a_j_prime += (dot(transpose(BFTrans_.Xmat(pa, i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + j)) +
                       dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Xmat(pa, i, FirstIndex + j)));
       HessType q_j_prime;
       q_j_prime   = 0;
       PosType& cj = BFTrans_.Cmat(pa, FirstIndex + j);
       for (int k = 0; k < NumPtcls; k++)
       {
         //tmp=0.0;
         //for(int n=0; n<NumPtcls; n++) tmp+=psiMinv(k,n)*grad_grad_psiM(j,n);
         //tmp *= dot(BFTrans_.Cmat(pa,FirstIndex+k),Fmat(j,k));
         q_j_prime += (psiMinv(j, k) *
                           (cj[0] * grad_grad_grad_psiM(j, k)[0] + cj[1] * grad_grad_grad_psiM(j, k)[1]
 #if OHMMS_DIM == 3
                            + cj[2] * grad_grad_grad_psiM(j, k)[2]
 #endif
                            ) -
                       rcdot(BFTrans_.Cmat(pa, FirstIndex + k), Fmat(j, k)) * Qmat(k, j));
       }
       dLa += (traceAtB(a_j_prime, Qmat(j, j)) + traceAtB(Ajk_sum(j, j), q_j_prime));
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       for (int k = 0; k < NumPtcls; k++)
       {
         HessType a_jk_prime;
         a_jk_prime = 0;
         for (int i = 0; i < num; i++)
           a_jk_prime += (dot(transpose(BFTrans_.Xmat(pa, i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + k)) +
                          dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Xmat(pa, i, FirstIndex + k)));
         dLa -= (traceAtB(a_jk_prime, outerProduct(Fmat(k, j), Fmat(j, k))) +
                 traceAtB(Ajk_sum(j, k), outerProduct(dFa(k, j), Fmat(j, k)) + outerProduct(Fmat(k, j), dFa(j, k))));
       } // k
     }   // j
     //int kk = pa; //BFTrans_.optIndexMap[pa];
     int kk = BFTrans_.optIndexMap[pa];
 #if defined(QMC_COMPLEX)
     //dlogpsi[kk] += real(dpsia);
     dlogpsi[kk] += dpsia;
     //dhpsioverpsi[kk] -= real(0.5 * static_cast<ParticleSet::SingleParticleValue>(dLa) + Dot(P.G, Gtemp));
     dhpsioverpsi[kk] -= 0.5 * static_cast<ParticleSet::SingleParticleValue>(dLa) + Dot(P.G, Gtemp);
 #else
     dlogpsi[kk] += dpsia;
     dhpsioverpsi[kk] -= (0.5 * static_cast<ParticleSet::SingleParticleValue>(dLa) + Dot(P.G, Gtemp));
 #endif
   }
 }

◆ evaluateDerivatives() [2/3]

void evaluateDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	active,
		std::vector< RealType > &	dlogpsi,
		std::vector< RealType > &	dhpsioverpsi,
		ParticleSet::ParticleGradient *	G0,
		ParticleSet::ParticleLaplacian *	L0,
		int	k
	)

Definition at line 873 of file DiracDeterminantWithBackflow.cpp.

 {
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM, grad_grad_grad_psiM);
   //std::copy(psiM.begin(),psiM.end(),psiMinv.begin());
   psiMinv = psiM;
   // invert backflow matrix
   InverseTimer.start();
   InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
   InverseTimer.stop();
   // calculate F matrix (gradients wrt bf coordinates)
   // could use dgemv with increments of 3*nCols
   for (int i = 0; i < NumPtcls; i++)
     for (int j = 0; j < NumPtcls; j++)
     {
       Fmat(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
     }
   //for(int i=0, iat=FirstIndex; i<NumPtcls; i++, iat++)
   // G(iat) += Fmat(i,i);
   // this is a mess, there should be a better way
   // to rearrange this
   //for (int pa=0; pa<BFTrans_.optIndexMap.size(); ++pa)
   //for (int pa=0; pa<BFTrans_.numParams; ++pa)
   const ValueType ConstZero(0.0);
   {
     ValueType dpsia = ConstZero;
     Gtemp           = ConstZero;
     //ValueType dLa=0.0;
     La1 = La2 = La3 = ConstZero;
     GradType temp;
     int num = P.getTotalNum();
     for (int i = 0; i < NumPtcls; i++)
       for (int j = 0; j < NumPtcls; j++)
       {
         GradType f_a;
         PosType& cj = BFTrans_.Cmat(pa, FirstIndex + j);
         for (int k = 0; k < NumPtcls; k++)
         {
           f_a += (psiMinv(i, k) * dot(grad_grad_psiM(j, k), cj) -
                   Fmat(k, j) * rcdot(BFTrans_.Cmat(pa, FirstIndex + k), Fmat(i, k)));
         }
         dFa(i, j) = f_a;
       }
     for (int i = 0; i < num; i++)
     {
       temp = ConstZero;
       for (int j = 0; j < NumPtcls; j++)
         temp +=
             (dot(BFTrans_.Xmat(pa, i, FirstIndex + j), Fmat(j, j)) + dot(BFTrans_.Amat(i, FirstIndex + j), dFa(j, j)));
       Gtemp[i] += temp;
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       GradType B_j;
       for (int i = 0; i < num; i++)
         B_j += BFTrans_.Bmat_full(i, FirstIndex + j);
       La1 += (rcdot(Fmat(j, j), BFTrans_.Ymat(pa, FirstIndex + j)) + dot(B_j, dFa(j, j)));
       dpsia += rcdot(Fmat(j, j), BFTrans_.Cmat(pa, FirstIndex + j));
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       HessType q_j;
       for (int k = 0; k < NumPtcls; k++)
         q_j += psiMinv(j, k) * grad_grad_psiM(j, k);
       // define later the dot product with a transpose tensor
       HessType a_j;
       for (int i = 0; i < num; i++)
         a_j += dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + j));
       HessType a_j_prime;
       for (int i = 0; i < num; i++)
         a_j_prime += (dot(transpose(BFTrans_.Xmat(pa, i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + j)) +
                       dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Xmat(pa, i, FirstIndex + j)));
       HessType q_j_prime, tmp;
       PosType& cj = BFTrans_.Cmat(pa, FirstIndex + j);
       for (int k = 0; k < NumPtcls; k++)
       {
         tmp = ConstZero;
         for (int n = 0; n < NumPtcls; n++)
           tmp += psiMinv(k, n) * grad_grad_psiM(j, n);
         tmp *= rcdot(BFTrans_.Cmat(pa, FirstIndex + k), Fmat(j, k));
         q_j_prime += (psiMinv(j, k) *
                           (cj[0] * grad_grad_grad_psiM(j, k)[0] + cj[1] * grad_grad_grad_psiM(j, k)[1] +
                            cj[2] * grad_grad_grad_psiM(j, k)[2]) -
                       tmp);
       }
       La2 += (traceAtB(a_j_prime, q_j) + traceAtB(a_j, q_j_prime));
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       for (int k = 0; k < NumPtcls; k++)
       {
         HessType a_jk;
         for (int i = 0; i < num; i++)
           a_jk += dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + k));
         HessType a_jk_prime;
         for (int i = 0; i < num; i++)
           a_jk_prime += (dot(transpose(BFTrans_.Xmat(pa, i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + k)) +
                          dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Xmat(pa, i, FirstIndex + k)));
         La3 -= (traceAtB(a_jk_prime, outerProduct(Fmat(k, j), Fmat(j, k))) +
                 traceAtB(a_jk, outerProduct(dFa(k, j), Fmat(j, k)) + outerProduct(Fmat(k, j), dFa(j, k))));
       }          // k
     }            // j
     int kk = pa; //BFTrans_.optIndexMap[pa];
 #if defined(QMC_COMPLEX)
     dlogpsi[kk] += real(dpsia);
     dhpsioverpsi[kk] -= real(0.5 * static_cast<ParticleSet::SingleParticleValue>(La1 + La2 + La3) + Dot(P.G, Gtemp));
 #else
     dlogpsi[kk] += dpsia;
     dhpsioverpsi[kk] -= (0.5 * static_cast<ParticleSet::SingleParticleValue>(La1 + La2 + La3) + Dot(P.G, Gtemp));
 #endif
     *G0 += Gtemp;
     (*L0)[0] += La1 + La2 + La3;
   }
 }

◆ evaluateDerivatives() [3/3]

void evaluateDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	active,
		int	offset,
		Matrix< RealType > &	dlogpsi,
		Array< GradType, OHMMS_DIM > &	dG,
		Matrix< RealType > &	dL
	)

override

Definition at line 738 of file DiracDeterminantWithBackflow.cpp.

 {
   /*  Note:
    *    Since evaluateDerivatives seems to always be called after
    *    evaluateDeltaLog, which in turn calls evaluateLog, many
    *    of the structures calculated here do not need to be calculated
    *    again. The only one that need to be called is a routine
    *    to calculate grad_grad_grad_psiM. The following structures
    *    should already be known here:
    *       -psiM
    *       -dpsiM
    *       -grad_grad_psiM
    *       -psiM_inv
    *       -Fmat
    */
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM, grad_grad_grad_psiM);
   //std::copy(psiM.begin(),psiM.end(),psiMinv.begin());
   psiMinv = psiM;
   // invert backflow matrix
   InverseTimer.start();
   InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
   InverseTimer.stop();
   // calculate F matrix (gradients wrt bf coordinates)
   // could use dgemv with increments of 3*nCols
   for (int i = 0; i < NumPtcls; i++)
     for (int j = 0; j < NumPtcls; j++)
     {
       Fmat(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
     }
   //for(int i=0, iat=FirstIndex; i<NumPtcls; i++, iat++)
   // G(iat) += Fmat(i,i);
   const ValueType ConstZero(0.0);
   int num = P.getTotalNum();
   for (int j = 0; j < NumPtcls; j++)
     for (int k = 0; k < NumPtcls; k++)
     {
       HessType& q_jk = Qmat(j, k);
       q_jk           = ConstZero;
       for (int n = 0; n < NumPtcls; n++)
         q_jk += psiMinv(j, n) * grad_grad_psiM(k, n);
       HessType& a_jk = Ajk_sum(j, k);
       a_jk           = ConstZero;
       for (int n = 0; n < num; n++)
         a_jk += dot(transpose(BFTrans_.Amat(n, FirstIndex + j)), BFTrans_.Amat(n, FirstIndex + k));
     }
   ValueType sumL = Sum(myL);
   ValueType dotG = Dot(myG, myG);
   // this is a mess, there should be a better way
   // to rearrange this
   for (int pa = 0; pa < BFTrans_.optIndexMap.size(); ++pa)
   //for (int pa=0; pa<BFTrans_.numParams; ++pa)
   {
     ValueType dpsia = ConstZero;
     Gtemp           = ConstZero;
     ValueType dLa   = ConstZero;
     GradType temp;
     for (int i = 0; i < NumPtcls; i++)
       for (int j = 0; j < NumPtcls; j++)
       {
         GradType f_a;
         PosType& cj = BFTrans_.Cmat(pa, FirstIndex + j);
         for (int k = 0; k < NumPtcls; k++)
         {
           f_a += (psiMinv(i, k) * dot(grad_grad_psiM(j, k), cj) -
                   Fmat(k, j) * rcdot(BFTrans_.Cmat(pa, FirstIndex + k), Fmat(i, k)));
         }
         dFa(i, j) = f_a;
       }
     for (int i = 0; i < num; i++)
     {
       temp = ConstZero;
       for (int j = 0; j < NumPtcls; j++)
         temp +=
             (dot(BFTrans_.Xmat(pa, i, FirstIndex + j), Fmat(j, j)) + dot(BFTrans_.Amat(i, FirstIndex + j), dFa(j, j)));
       Gtemp[i] += temp;
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       GradType B_j;
       for (int i = 0; i < num; i++)
         B_j += BFTrans_.Bmat_full(i, FirstIndex + j);
       dLa += (rcdot(Fmat(j, j), BFTrans_.Ymat(pa, FirstIndex + j)) + dot(B_j, dFa(j, j)));
       dpsia += rcdot(Fmat(j, j), BFTrans_.Cmat(pa, FirstIndex + j));
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       HessType a_j_prime;
       for (int i = 0; i < num; i++)
         a_j_prime += (dot(transpose(BFTrans_.Xmat(pa, i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + j)) +
                       dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Xmat(pa, i, FirstIndex + j)));
       HessType q_j_prime;
       PosType& cj = BFTrans_.Cmat(pa, FirstIndex + j);
       for (int k = 0; k < NumPtcls; k++)
       {
         //tmp=0.0;
         //for(int n=0; n<NumPtcls; n++) tmp+=psiMinv(k,n)*grad_grad_psiM(j,n);
         //tmp *= dot(BFTrans_.Cmat(pa,FirstIndex+k),Fmat(j,k));
         q_j_prime += (psiMinv(j, k) *
                           (cj[0] * grad_grad_grad_psiM(j, k)[0] + cj[1] * grad_grad_grad_psiM(j, k)[1] +
                            cj[2] * grad_grad_grad_psiM(j, k)[2]) -
                       rcdot(BFTrans_.Cmat(pa, FirstIndex + k), Fmat(j, k)) * Qmat(k, j));
       }
       dLa += (traceAtB(a_j_prime, Qmat(j, j)) + traceAtB(Ajk_sum(j, j), q_j_prime));
     }
     for (int j = 0; j < NumPtcls; j++)
     {
       for (int k = 0; k < NumPtcls; k++)
       {
         HessType a_jk_prime;
         for (int i = 0; i < num; i++)
           a_jk_prime += (dot(transpose(BFTrans_.Xmat(pa, i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + k)) +
                          dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Xmat(pa, i, FirstIndex + k)));
         dLa -= (traceAtB(a_jk_prime, outerProduct(Fmat(k, j), Fmat(j, k))) +
                 traceAtB(Ajk_sum(j, k), outerProduct(dFa(k, j), Fmat(j, k)) + outerProduct(Fmat(k, j), dFa(j, k))));
       } // k
     }   // j
 #if defined(QMC_COMPLEX)
     convertToReal(dpsia, dlogpsi(offset, pa));
     convertToReal(dLa + sumL * dpsia + dotG * dpsia + static_cast<ValueType>(2.0 * Dot(myG, Gtemp)), dL(offset, pa));
 #else
     dlogpsi(offset, pa) = dpsia; // \nabla_pa ln(D)
     dL(offset, pa)      = dLa + sumL * dpsia + dotG * dpsia + static_cast<ValueType>(2.0 * Dot(myG, Gtemp));
 #endif
     // \sum_i (\nabla_pa  \nabla2_i D) / D
     for (int k = 0; k < num; k++)
       dG(offset, pa, k) =
           Gtemp[k] + myG[k] * static_cast<ParticleSet::SingleParticleValue>(dpsia); // (\nabla_pa \nabla_i D) / D
   }
 }

◆ evaluateLog()

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

override

Calculate the log value of the Dirac determinant for particles.

Parameters

P	input configuration containing N particles
G	a vector containing N gradients
L	a vector containing N laplacians

Returns: the value of the determinant

$ (first,first+nel). $ Add the gradient and laplacian contribution of the determinant to G(radient) and L(aplacian) for local energy calculations.

Definition at line 480 of file DiracDeterminantWithBackflow.cpp.

Referenced by DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

 {
   //testGG(P);
   //testL(P);
   // calculate backflow matrix, 1st and 2nd derivatives
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM);
   //std::copy(psiM.begin(),psiM.end(),psiMinv.begin());
   psiMinv = psiM;
   // invert backflow matrix
   InverseTimer.start();
   InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
   InverseTimer.stop();
   // calculate F matrix (gradients wrt bf coordinates)
   // could use dgemv with increments of 3*nCols
   for (int i = 0; i < NumPtcls; i++)
   {
     for (int j = 0; j < NumPtcls; j++)
     {
       Fmat(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
     }
     Fmatdiag[i] = Fmat(i, i);
   }
   // calculate gradients and first piece of laplacians
   GradType temp;
   ValueType temp2;
   myG     = 0.0;
   myL     = 0.0;
   int num = P.getTotalNum();
   for (int i = 0; i < num; i++)
   {
     temp  = 0.0;
     temp2 = 0.0;
     for (int j = 0; j < NumPtcls; j++)
     {
       for (int k = 0; k < OHMMS_DIM; k++)
         temp2 += BFTrans_.Bmat_full(i, FirstIndex + j)[k] * Fmat(j, j)[k];
       temp += dot(BFTrans_.Amat(i, FirstIndex + j), Fmat(j, j));
       //temp2 += rcdot(BFTrans_.Bmat_full(i,FirstIndex+j),Fmat(j,j));
     }
     myG[i] += temp;
     myL[i] += temp2;
   }
   // NOTE: check derivatives of Fjj and Amat numerically here, the problem has to come from somewhere
   for (int j = 0; j < NumPtcls; j++)
   {
     HessType q_j;
     q_j = 0.0;
     for (int k = 0; k < NumPtcls; k++)
       q_j += psiMinv(j, k) * grad_grad_psiM(j, k);
     for (int i = 0; i < num; i++)
     {
       Tensor<RealType, OHMMS_DIM> AA =
           dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + j));
       myL[i] += traceAtB(AA, q_j);
       //myL[i] += traceAtB(dot(transpose(BFTrans_.Amat(i,FirstIndex+j)),BFTrans_.Amat(i,FirstIndex+j)),q_j);
     }
     for (int k = 0; k < NumPtcls; k++)
     {
       for (int i = 0; i < num; i++)
       {
         Tensor<RealType, OHMMS_DIM> AA =
             dot(transpose(BFTrans_.Amat(i, FirstIndex + j)), BFTrans_.Amat(i, FirstIndex + k));
         HessType FF = outerProduct(Fmat(k, j), Fmat(j, k));
         myL[i] -= traceAtB(AA, FF);
         //myL[i] -= traceAtB(dot(transpose(BFTrans_.Amat(i,FirstIndex+j)),BFTrans_.Amat(i,FirstIndex+k)), outerProduct(Fmat(k,j),Fmat(j,k)));
       }
     }
   }
   for (int i = 0; i < num; i++)
   {
     L[i] += myL[i];
     G[i] += myG[i];
   }
   return log_value_;
 }

◆ evaluateRatiosAlltoOne()

void evaluateRatiosAlltoOne	(	ParticleSet &	P,
		std::vector< ValueType > &	ratios
	)

overridevirtual

evaluate the ratios of one virtual move with respect to all the particles

Parameters

P	reference particleset
ratios	$ratios[i]=\{{\bf R}\}\rightarrow {r_0,\cdots,r_i^p=pos,\cdots,r_{N-1}}$

Reimplemented from WaveFunctionComponent.

Definition at line 224 of file DiracDeterminantWithBackflow.cpp.

References APP_ABORT.

 {
   APP_ABORT(" Need to implement DiracDeterminantWithBackflow::evaluateRatiosAlltoOne. \n");
 }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements WaveFunctionComponent.

Definition at line 58 of file DiracDeterminantWithBackflow.h.

58 { return "DiracDeterminantWithBackflow"; }

◆ makeCopy()

std::unique_ptr<DiracDeterminantBase> makeCopy ( std::unique_ptr< SPOSet > && spo ) const

inlineoverridevirtual

cloning function

Parameters

tqp	target particleset
spo	spo set

This interface is exposed only to SlaterDet and its derived classes can overwrite to clone itself correctly.

Implements DiracDeterminantBase.

Definition at line 126 of file DiracDeterminantWithBackflow.h.

   {
     throw std::runtime_error("makeCopy spo should not be called.");
   }

◆ makeCopyWithBF()

std::unique_ptr< DiracDeterminantWithBackflow > makeCopyWithBF	(	std::unique_ptr< SPOSet > &&	spo,
		BackflowTransformation &	BF
	)		const

cloning function

Parameters

tqp	target particleset
spo	spo set

This interface is exposed only to SlaterDet and its derived classes can overwrite to clone itself correctly.

Definition at line 993 of file DiracDeterminantWithBackflow.cpp.

References DiracDeterminantBase::FirstIndex, and DiracDeterminantBase::LastIndex.

 {
   return std::make_unique<DiracDeterminantWithBackflow>(std::move(spo), BF, FirstIndex, LastIndex);
 }

◆ operator=()

DiracDeterminantWithBackflow& operator= ( const DiracDeterminantWithBackflow & s )

delete

◆ ratio()

DiracDeterminantWithBackflow::PsiValue ratio	(	ParticleSet &	P,
		int	iat
	)

overridevirtual

return the ratio only for the iat-th partcle move

Parameters

P	current configuration
iat	the particle thas is being moved

Implements WaveFunctionComponent.

Definition at line 190 of file DiracDeterminantWithBackflow.cpp.

References DiracDeterminantWithBackflow::BFTrans_, LogToValue< T >::convert(), DiracDeterminantWithBackflow::curRatio, Vector< T, Alloc >::data(), DiracDeterminantBase::FirstIndex, BackflowTransformation::indexQP, DiracDeterminantBase::InverseTimer, qmcplusplus::InvertWithLog(), DiracDeterminantBase::LastIndex, WaveFunctionComponent::log_value_, ParticleSet::makeMove(), BackflowTransformation::newQP, DiracDeterminantBase::NumOrbitals, DiracDeterminantBase::NumPtcls, WaveFunctionComponent::ORB_PBYP_RATIO, DiracDeterminantBase::Phi, DiracDeterminantWithBackflow::Pivot, DiracDeterminantWithBackflow::psiM, DiracDeterminantWithBackflow::psiM_temp, DiracDeterminantWithBackflow::psiMinv_temp, DiracDeterminantWithBackflow::psiV, BackflowTransformation::QP, ParticleSet::R, ParticleSet::rejectMove(), TimerType< CLOCK >::start(), TimerType< CLOCK >::stop(), WaveFunctionComponent::UpdateMode, and DiracDeterminantWithBackflow::WorkSpace.

 {
   // FIX FIX FIX : code Woodbury formula
   psiM_temp = psiM;
   // either code Woodbury or do multiple single particle updates
   UpdateMode                        = ORB_PBYP_RATIO;
   std::vector<int>::iterator it     = BFTrans_.indexQP.begin();
   std::vector<int>::iterator it_end = BFTrans_.indexQP.end();
   while (it != it_end)
   {
     if (*it < FirstIndex || *it >= LastIndex)
     {
       ++it;
       continue;
     }
     int jat    = *it - FirstIndex;
     PosType dr = BFTrans_.newQP[*it] - BFTrans_.QP.R[*it];
     BFTrans_.QP.makeMove(*it, dr);
     Phi->evaluateValue(BFTrans_.QP, *it, psiV);
     for (int orb = 0; orb < psiV.size(); orb++)
       psiM_temp(orb, jat) = psiV[orb];
     BFTrans_.QP.rejectMove(*it);
     it++;
   }
   // FIX FIX FIX : code Woodbury formula
   psiMinv_temp = psiM_temp;
   // FIX FIX FIX : code Woodbury formula
   InverseTimer.start();
   LogValue NewLog;
   InvertWithLog(psiMinv_temp.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), NewLog);
   InverseTimer.stop();
   return curRatio = LogToValue<PsiValue>::convert(NewLog - log_value_);
 }

◆ ratioGrad()

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

overridevirtual

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 259 of file DiracDeterminantWithBackflow.cpp.

References BackflowTransformation::Amat_temp, DiracDeterminantWithBackflow::BFTrans_, LogToValue< T >::convert(), copy(), DiracDeterminantWithBackflow::curRatio, DiracDeterminantWithBackflow::d2psiV, Vector< T, Alloc >::data(), qmcplusplus::simd::dot(), qmcplusplus::dot(), DiracDeterminantWithBackflow::dpsiM, DiracDeterminantWithBackflow::dpsiM_temp, DiracDeterminantWithBackflow::dpsiV, DiracDeterminantBase::FirstIndex, DiracDeterminantWithBackflow::Fmatdiag_temp, DiracDeterminantWithBackflow::grad_grad_psiM_temp, DiracDeterminantWithBackflow::grad_gradV, BackflowTransformation::indexQP, DiracDeterminantBase::InverseTimer, qmcplusplus::InvertWithLog(), DiracDeterminantBase::LastIndex, WaveFunctionComponent::log_value_, ParticleSet::makeMove(), BackflowTransformation::newQP, DiracDeterminantBase::NumOrbitals, DiracDeterminantBase::NumPtcls, WaveFunctionComponent::ORB_PBYP_PARTIAL, DiracDeterminantBase::Phi, DiracDeterminantWithBackflow::Pivot, DiracDeterminantWithBackflow::psiM, DiracDeterminantWithBackflow::psiM_temp, DiracDeterminantWithBackflow::psiMinv_temp, DiracDeterminantWithBackflow::psiV, BackflowTransformation::QP, ParticleSet::R, ParticleSet::rejectMove(), TimerType< CLOCK >::start(), TimerType< CLOCK >::stop(), WaveFunctionComponent::UpdateMode, and DiracDeterminantWithBackflow::WorkSpace.

 {
   // FIX FIX FIX : code Woodbury formula
   psiM_temp                         = psiM;
   dpsiM_temp                        = dpsiM;
   UpdateMode                        = ORB_PBYP_PARTIAL;
   std::vector<int>::iterator it     = BFTrans_.indexQP.begin();
   std::vector<int>::iterator it_end = BFTrans_.indexQP.end();
   ParticleSet::ParticlePos dr;
   while (it != it_end)
   {
     if (*it < FirstIndex || *it >= LastIndex)
     {
       ++it;
       continue;
     }
     int jat    = *it - FirstIndex;
     PosType dr = BFTrans_.newQP[*it] - BFTrans_.QP.R[*it];
     BFTrans_.QP.makeMove(*it, dr);
     Phi->evaluateVGL(BFTrans_.QP, *it, psiV, dpsiV, d2psiV);
     for (int orb = 0; orb < psiV.size(); orb++)
       psiM_temp(orb, jat) = psiV[orb];
     std::copy(dpsiV.begin(), dpsiV.end(), dpsiM_temp.begin(jat));
     std::copy(grad_gradV.begin(), grad_gradV.end(), grad_grad_psiM_temp.begin(jat));
     BFTrans_.QP.rejectMove(*it);
     it++;
   }
   // FIX FIX FIX : code Woodbury formula
   psiMinv_temp = psiM_temp;
   // FIX FIX FIX : code Woodbury formula
   InverseTimer.start();
   LogValue NewLog;
   InvertWithLog(psiMinv_temp.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), NewLog);
   InverseTimer.stop();
   // update Fmatdiag_temp
   for (int j = 0; j < NumPtcls; j++)
   {
     Fmatdiag_temp[j] = simd::dot(psiMinv_temp[j], dpsiM_temp[j], NumOrbitals);
     grad_iat += dot(BFTrans_.Amat_temp(iat, FirstIndex + j), Fmatdiag_temp[j]);
   }
   return curRatio = LogToValue<PsiValue>::convert(NewLog - log_value_);
 }

◆ rcdot()

ValueType rcdot	(	TinyVector< RealType, OHMMS_DIM > &	lhs,
		TinyVector< ValueType, OHMMS_DIM > &	rhs
	)

inlineprivate

Definition at line 143 of file DiracDeterminantWithBackflow.h.

References OHMMS_DIM.

Referenced by DiracDeterminantWithBackflow::dummyEvalLi(), and DiracDeterminantWithBackflow::evaluateDerivatives().

   {
     ValueType ret(0);
     for (int i(0); i < OHMMS_DIM; i++)
       ret += lhs[i] * rhs[i];
     return ret;
   };

◆ registerData()

void registerData	(	ParticleSet &	P,
		WFBufferType &	buf
	)

overridevirtual

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 98 of file DiracDeterminantWithBackflow.cpp.

 {
   if (NP == 0)
   //first time, allocate once
   {
     int norb     = NumOrbitals;
     NP           = P.getTotalNum();
     NumParticles = P.getTotalNum();
     dpsiM_temp.resize(NumPtcls, norb);
     grad_grad_psiM_temp.resize(NumPtcls, norb);
     dpsiV.resize(norb);
     d2psiV.resize(norb);
     grad_gradV.resize(norb);
     Fmatdiag_temp.resize(norb);
     myG_temp.resize(NP);
     myL_temp.resize(NP);
     resize(NumPtcls, NumOrbitals);
     FirstAddressOfG   = &myG[0][0];
     LastAddressOfG    = FirstAddressOfG + NP * DIM;
     FirstAddressOfdV  = &(dpsiM(0, 0)[0]); //(*dpsiM.begin())[0]);
     LastAddressOfdV   = FirstAddressOfdV + NumPtcls * NumOrbitals * DIM;
     FirstAddressOfGGG = grad_grad_psiM(0, 0).begin(); //[0];
     LastAddressOfGGG  = FirstAddressOfGGG + NumPtcls * norb * DIM * DIM;
     FirstAddressOfFm  = &(Fmatdiag[0][0]); //[0];
     LastAddressOfFm   = FirstAddressOfFm + NumOrbitals * DIM;
   }
   myG_temp = 0.0;
   myL_temp = 0.0;
   //ValueType x=evaluate(P,myG,myL);
   log_value_ = evaluateLog(P, myG_temp, myL_temp);
   P.G += myG_temp;
   P.L += myL_temp;
   //add the data: determinant, inverse, gradient and laplacians
   buf.add(psiM.first_address(), psiM.last_address());
   buf.add(FirstAddressOfdV, LastAddressOfdV);
   buf.add(FirstAddressOfGGG, LastAddressOfGGG);
   buf.add(myL.first_address(), myL.last_address());
   buf.add(FirstAddressOfG, LastAddressOfG);
   buf.add(FirstAddressOfFm, LastAddressOfFm);
   buf.add(psiMinv.first_address(), psiMinv.last_address());
   buf.add(log_value_);
 }

◆ resize()

void resize	(	int	nel,
		int	morb
	)

private

reset the size: with the number of particles and number of orbtials

Definition at line 46 of file DiracDeterminantWithBackflow.cpp.

Referenced by DiracDeterminantWithBackflow::DiracDeterminantWithBackflow(), and DiracDeterminantWithBackflow::registerData().

 {
   int norb = morb;
   if (norb <= 0)
     norb = nel; // for morb == -1 (default)
   psiM.resize(nel, norb);
   dpsiM.resize(nel, norb);
   psiMinv.resize(nel, norb);
   WorkSpace.resize(nel);
   Pivot.resize(nel);
   grad_grad_psiM.resize(nel, norb);
   grad_grad_grad_psiM.resize(nel, norb);
   Gtemp.resize(NumParticles); // not correct for spin polarized...
   myG.resize(NumParticles);   // not correct for spin polarized...
   myL.resize(NumParticles);   // not correct for spin polarized...
   dFa.resize(nel, norb);
   Ajk_sum.resize(nel, norb);
   Qmat.resize(nel, norb);
   Fmat.resize(nel, norb);
   Fmatdiag.resize(norb);
   psiMinv_temp.resize(NumPtcls, norb);
   psiV.resize(norb);
   psiM_temp.resize(NumPtcls, norb);
   // For forces
   /*  not used
   grad_source_psiM.resize(nel,norb);
   grad_lapl_source_psiM.resize(nel,norb);
   grad_grad_source_psiM.resize(nel,norb);
   phi_alpha_Minv.resize(nel,norb);
   grad_phi_Minv.resize(nel,norb);
   lapl_phi_Minv.resize(nel,norb);
   grad_phi_alpha_Minv.resize(nel,norb);
   */
 }

◆ restore()

void restore ( int iat )

overridevirtual

move was rejected.

copy the real container to the temporary to move on

Nothing to restore for now.

Implements WaveFunctionComponent.

Definition at line 594 of file DiracDeterminantWithBackflow.cpp.

References DiracDeterminantWithBackflow::curRatio.

594 { curRatio = 1.0; }

qmcplusplus::DiracDeterminantWithBackflow::curRatio

PsiValue curRatio

Definition: DiracDeterminantWithBackflow.h:192

◆ testDerivFjj()

void testDerivFjj	(	ParticleSet &	P,
		int	pa
	)

Definition at line 1171 of file DiracDeterminantWithBackflow.cpp.

Referenced by SlaterDetWithBackflow::testDerivGL().

 {
   app_log() << " Testing derivatives of the F matrix, prm: " << pa << std::endl;
   opt_variables_type wfVars, wfvar_prime;
   BFTrans_.checkInVariables(wfVars);
   BFTrans_.checkOutVariables(wfVars);
   int Nvars   = wfVars.size();
   wfvar_prime = wfVars;
   GradMatrix dpsiM_1, dpsiM_2, dpsiM_0;
   dpsiM_0.resize(NumPtcls, NumOrbitals);
   dpsiM_1.resize(NumPtcls, NumOrbitals);
   dpsiM_2.resize(NumPtcls, NumOrbitals);
   const RealType dh(0.00001); //PREC_WARN
   int pr = pa;
   for (int j = 0; j < Nvars; j++)
     wfvar_prime[j] = wfVars[j];
   wfvar_prime[pr] = wfVars[pr] + dh;
   BFTrans_.resetParameters(wfvar_prime);
   BFTrans_.evaluateDerivatives(P);
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM, grad_grad_grad_psiM);
   //std::copy(psiM.begin(),psiM.end(),psiMinv.begin());
   psiMinv = psiM;
   // invert backflow matrix
   InverseTimer.start();
   InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
   InverseTimer.stop();
   // calculate F matrix (gradients wrt bf coordinates)
   // could use dgemv with increments of 3*nCols
   for (int i = 0; i < NumPtcls; i++)
     for (int j = 0; j < NumPtcls; j++)
     {
       dpsiM_1(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
     }
   for (int j = 0; j < Nvars; j++)
     wfvar_prime[j] = wfVars[j];
   wfvar_prime[pr] = wfVars[pr] - dh;
   BFTrans_.resetParameters(wfvar_prime);
   BFTrans_.evaluateDerivatives(P);
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM, grad_grad_grad_psiM);
   //std::copy(psiM.begin(),psiM.end(),psiMinv.begin());
   psiMinv = psiM;
   // invert backflow matrix
   InverseTimer.start();
   InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
   InverseTimer.stop();
   // calculate F matrix (gradients wrt bf coordinates)
   // could use dgemv with increments of 3*nCols
   for (int i = 0; i < NumPtcls; i++)
     for (int j = 0; j < NumPtcls; j++)
     {
       dpsiM_2(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
     }
   for (int j = 0; j < Nvars; j++)
     wfvar_prime[j] = wfVars[j];
   BFTrans_.resetParameters(wfvar_prime);
   BFTrans_.evaluateDerivatives(P);
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM, grad_grad_grad_psiM);
   //std::copy(psiM.begin(),psiM.end(),psiMinv.begin());
   psiMinv = psiM;
   // invert backflow matrix
   InverseTimer.start();
   InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
   InverseTimer.stop();
   // calculate F matrix (gradients wrt bf coordinates)
   // could use dgemv with increments of 3*nCols
   for (int i = 0; i < NumPtcls; i++)
     for (int j = 0; j < NumPtcls; j++)
     {
       Fmat(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
     }
   RealType cnt = 0, av = 0;
   RealType maxD(0);
   for (int i = 0; i < NumPtcls; i++)
     for (int j = 0; j < NumPtcls; j++)
       for (int lb = 0; lb < 3; lb++)
       {
         dpsiM_0(i, j)[lb] = 0.0;
         for (int k = 0; k < NumPtcls; k++)
           for (int lc = 0; lc < 3; lc++)
           {
             dpsiM_0(i, j)[lb] += (BFTrans_.Cmat(pr, FirstIndex + j)[lc] * psiMinv(i, k) * grad_grad_psiM(j, k)(lb, lc) -
                                   BFTrans_.Cmat(pr, FirstIndex + k)[lc] * Fmat(i, k)[lc] * Fmat(k, j)[lb]);
           }
         cnt++;
 #if defined(QMC_COMPLEX)
         RealType t = real(dpsiM_0(i, j)[lb] - (dpsiM_1(i, j)[lb] - dpsiM_2(i, j)[lb])) / (2 * dh);
         av += t;
         maxD = std::max(maxD, std::abs(t));
 #else
         av += dpsiM_0(i, j)[lb] - (dpsiM_1(i, j)[lb] - dpsiM_2(i, j)[lb]) / (2 * dh);
         if (std::abs(dpsiM_0(i, j)[lb] - (dpsiM_1(i, j)[lb] - dpsiM_2(i, j)[lb]) / (2 * dh)) > maxD)
           maxD = dpsiM_0(i, j)[lb] - (dpsiM_1(i, j)[lb] - dpsiM_2(i, j)[lb]) / (2 * dh);
 #endif
       }
   app_log() << " av,max : " << av / cnt << "  " << maxD << std::endl;
   //APP_ABORT("testing Fij \n");
 }

◆ testDerivLi()

void testDerivLi	(	ParticleSet &	P,
		int	pa
	)

Definition at line 1270 of file DiracDeterminantWithBackflow.cpp.

Referenced by SlaterDetWithBackflow::testDerivGL().

 {
   //app_log() <<"Testing new L[i]: \n";
   opt_variables_type wfVars, wfvar_prime;
   BFTrans_.checkInVariables(wfVars);
   BFTrans_.checkOutVariables(wfVars);
   int Nvars   = wfVars.size();
   wfvar_prime = wfVars;
   RealType dh = 0.00001;
   //BFTrans_.evaluate(P);
   ValueType L1a, L2a, L3a;
   ValueType L1b, L2b, L3b;
   //dummyEvalLi(L1,L2,L3);
   myG = 0.0;
   myL = 0.0;
   //ValueType ps = evaluateLog(P,myG,myL);
   //L0 = Sum(myL);
   //app_log() <<"L old, L new: " <<L0 <<"  " <<L1+L2+L3 << std::endl;
   app_log() << std::endl << " Testing derivatives of L[i] matrix. " << std::endl;
   for (int j = 0; j < Nvars; j++)
     wfvar_prime[j] = wfVars[j];
   wfvar_prime[pa] = wfVars[pa] + dh;
   BFTrans_.resetParameters(wfvar_prime);
   BFTrans_.evaluate(P);
   dummyEvalLi(L1a, L2a, L3a);
   for (int j = 0; j < Nvars; j++)
     wfvar_prime[j] = wfVars[j];
   wfvar_prime[pa] = wfVars[pa] - dh;
   BFTrans_.resetParameters(wfvar_prime);
   BFTrans_.evaluate(P);
   dummyEvalLi(L1b, L2b, L3b);
   BFTrans_.resetParameters(wfVars);
   BFTrans_.evaluateDerivatives(P);
   std::vector<RealType> dlogpsi;
   std::vector<RealType> dhpsi;
   dlogpsi.resize(Nvars);
   dhpsi.resize(Nvars);
   evaluateDerivatives(P, wfVars, dlogpsi, dhpsi, &myG, &myL, pa);
   app_log() << "pa: " << pa << std::endl
             << "dL Numrical: " << (L1a - L1b) / (2 * dh) << "  " << (L2a - L2b) / (2 * dh) << "  "
             << (L3a - L3b) / (2 * dh) << "\n"
             << "dL Analitival: " << La1 << "  " << La2 << "  " << La3 << std::endl
             << " dLDiff: " << (L1a - L1b) / (2 * dh) - La1 << "  " << (L2a - L2b) / (2 * dh) - La2 << "  "
             << (L3a - L3b) / (2 * dh) - La3 << std::endl;
 }

◆ testGG()

void testGG ( ParticleSet & P )

Definition at line 1000 of file DiracDeterminantWithBackflow.cpp.

References qmcplusplus::app_log(), DiracDeterminantWithBackflow::BFTrans_, DiracDeterminantWithBackflow::dpsiM, DiracDeterminantWithBackflow::evaluate_SPO(), DiracDeterminantBase::FirstIndex, qmcplusplus::for(), ParticleSet::getTotalNum(), DiracDeterminantBase::LastIndex, DiracDeterminantBase::NumOrbitals, DiracDeterminantBase::NumPtcls, DiracDeterminantBase::Phi, DiracDeterminantWithBackflow::psiM, BackflowTransformation::QP, ParticleSet::R, Vector< T, Alloc >::resize(), and ParticleSet::update().

 {
   ParticleSet::ParticlePos qp_0;
   qp_0.resize(BFTrans_.QP.getTotalNum());
   ValueMatrix psiM_1, psiM_2;
   ValueMatrix psiM_3, psiM_4;
   GradMatrix dpsiM_1, dpsiM_2;
   HessMatrix dgM, ggM, ggM0;
   psiM_1.resize(NumPtcls, NumOrbitals);
   psiM_2.resize(NumPtcls, NumOrbitals);
   psiM_3.resize(NumPtcls, NumOrbitals);
   psiM_4.resize(NumPtcls, NumOrbitals);
   dpsiM_1.resize(NumPtcls, NumOrbitals);
   dgM.resize(NumPtcls, NumOrbitals);
   ggM.resize(NumPtcls, NumOrbitals);
   ggM0.resize(NumPtcls, NumOrbitals);
   const RealType dh = 0.0000000001; //PREC_WARNING
   for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
     qp_0[i] = BFTrans_.QP.R[i];
   Phi->evaluate_notranspose(BFTrans_.QP, FirstIndex, LastIndex, psiM, dpsiM, ggM);
   app_log() << "Testing GGType calculation: " << std::endl;
   for (int lx = 0; lx < 3; lx++)
   {
     for (int ly = 0; ly < 3; ly++)
     {
       if (lx == ly)
       {
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i] = qp_0[i];
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][lx] = qp_0[i][lx] + dh;
         BFTrans_.QP.update();
         evaluate_SPO(psiM_1, dpsiM_1, ggM0);
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i] = qp_0[i];
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][lx] = qp_0[i][lx] - dh;
         BFTrans_.QP.update();
         evaluate_SPO(psiM_2, dpsiM_1, ggM0);
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i] = qp_0[i];
         BFTrans_.QP.update();
         evaluate_SPO(psiM_3, dpsiM_1, ggM0);
         for (int i = 0; i < NumPtcls; i++)
           for (int j = 0; j < NumOrbitals; j++)
             (dgM(i, j))(lx, ly) = (psiM_1(i, j) + psiM_2(i, j) - (RealType)2.0 * psiM_3(i, j)) / (dh * dh);
       }
       else
       {
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i] = qp_0[i];
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][lx] = qp_0[i][lx] + dh;
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][ly] = qp_0[i][ly] + dh;
         BFTrans_.QP.update();
         evaluate_SPO(psiM_1, dpsiM_1, ggM0);
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i] = qp_0[i];
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][lx] = qp_0[i][lx] - dh;
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][ly] = qp_0[i][ly] - dh;
         BFTrans_.QP.update();
         evaluate_SPO(psiM_2, dpsiM_1, ggM0);
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i] = qp_0[i];
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][lx] = qp_0[i][lx] + dh;
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][ly] = qp_0[i][ly] - dh;
         BFTrans_.QP.update();
         evaluate_SPO(psiM_3, dpsiM_1, ggM0);
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i] = qp_0[i];
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][lx] = qp_0[i][lx] - dh;
         for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
           BFTrans_.QP.R[i][ly] = qp_0[i][ly] + dh;
         BFTrans_.QP.update();
         evaluate_SPO(psiM_4, dpsiM_1, ggM0);
         for (int i = 0; i < NumPtcls; i++)
           for (int j = 0; j < NumOrbitals; j++)
             (dgM(i, j))(lx, ly) =
                 (psiM_1(i, j) + psiM_2(i, j) - psiM_3(i, j) - psiM_4(i, j)) / ((RealType)4.0 * dh * dh);
       }
     }
   }
   for (int i = 0; i < NumPtcls; i++)
     for (int j = 0; j < NumOrbitals; j++)
     {
       std::cout << "i,j: " << i << " " << j << std::endl;
       for (int lx = 0; lx < 3; lx++)
         for (int ly = 0; ly < 3; ly++)
         {
           std::cout << "a,b: " << lx << " " << ly << (dgM(i, j))(lx, ly) - (ggM(i, j))(lx, ly) << " -- "
                     << (dgM(i, j))(lx, ly) << " -- " << (ggM(i, j))(lx, ly) << std::endl;
         }
     }
   for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
     BFTrans_.QP.R[i] = qp_0[i];
   BFTrans_.QP.update();
 }

◆ testGGG()

void testGGG ( ParticleSet & P )

Definition at line 1104 of file DiracDeterminantWithBackflow.cpp.

References qmcplusplus::abs(), qmcplusplus::app_log(), DiracDeterminantWithBackflow::BFTrans_, DiracDeterminantWithBackflow::dpsiM, DiracDeterminantWithBackflow::evaluate_SPO(), qmcplusplus::for(), ParticleSet::getTotalNum(), DiracDeterminantWithBackflow::grad_grad_grad_psiM, DiracDeterminantWithBackflow::grad_grad_psiM, DiracDeterminantBase::NumOrbitals, DiracDeterminantBase::NumPtcls, DiracDeterminantWithBackflow::psiM, BackflowTransformation::QP, ParticleSet::R, qmcplusplus::real(), Vector< T, Alloc >::resize(), and ParticleSet::update().

Referenced by SlaterDetWithBackflow::testDerivGL().

 {
   ParticleSet::ParticlePos qp_0;
   qp_0.resize(BFTrans_.QP.getTotalNum());
   ValueMatrix psiM_1, psiM_2;
   GradMatrix dpsiM_1, dpsiM_2;
   HessMatrix ggM_1, ggM_2;
   psiM_1.resize(NumPtcls, NumOrbitals);
   psiM_2.resize(NumPtcls, NumOrbitals);
   dpsiM_1.resize(NumPtcls, NumOrbitals);
   dpsiM_2.resize(NumPtcls, NumOrbitals);
   ggM_1.resize(NumPtcls, NumOrbitals);
   ggM_2.resize(NumPtcls, NumOrbitals);
   GGGMatrix ggg_psiM1, ggg_psiM2;
   ggg_psiM1.resize(NumPtcls, NumOrbitals);
   ggg_psiM2.resize(NumPtcls, NumOrbitals);
   const RealType dh = 0.000001; //PREC_WARNING
   for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
     qp_0[i] = BFTrans_.QP.R[i];
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM, grad_grad_grad_psiM);
   app_log() << "Testing GGGType calculation: " << std::endl;
   for (int lc = 0; lc < 3; lc++)
   {
     for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
       BFTrans_.QP.R[i] = qp_0[i];
     for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
       BFTrans_.QP.R[i][lc] = qp_0[i][lc] + dh;
     BFTrans_.QP.update();
     evaluate_SPO(psiM_1, dpsiM_1, ggM_1, ggg_psiM1);
     for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
       BFTrans_.QP.R[i][lc] = qp_0[i][lc] - dh;
     BFTrans_.QP.update();
     evaluate_SPO(psiM_2, dpsiM_2, ggM_2, ggg_psiM2);
     const RealType dh2 = RealType(0.5 / dh);
     RealType maxD(0);
     ValueType av(0);
     RealType cnt(0);
     for (int i = 0; i < NumPtcls; i++)
       for (int j = 0; j < NumOrbitals; j++)
       {
         //HessType dG = (ggM_1(i,j)-ggM_2(i,j))/((RealType)2.0*dh)-(grad_grad_grad_psiM(i,j))[lc];
         HessType dG = (ggM_1(i, j) - ggM_2(i, j)) * dh2 - grad_grad_grad_psiM(i, j)[lc];
         for (int la = 0; la < 9; la++)
         {
           cnt++;
           av += dG[la];
 #if defined(QMC_COMPLEX)
           if (std::abs(dG[la].real()) > maxD)
             maxD = std::abs(dG[la].real());
 #else
           if (std::abs(dG[la]) > maxD)
             maxD = std::abs(dG[la]);
 #endif
         }
         app_log() << i << "  " << j << "\n"
                   << "dG : \n"
                   << dG << std::endl
                   << "GGG: \n"
                   << (grad_grad_grad_psiM(i, j))[lc] << std::endl;
       }
     app_log() << "lc, av, max: " << lc << "  " << av / cnt << "  " << maxD << std::endl;
   }
   for (int i = 0; i < BFTrans_.QP.getTotalNum(); i++)
     BFTrans_.QP.R[i] = qp_0[i];
   BFTrans_.QP.update();
 }

◆ testL()

void testL ( ParticleSet & P )

Definition at line 304 of file DiracDeterminantWithBackflow.cpp.

 {
   GradMatrix Fmat_p, Fmat_m;
   GradVector Fdiag_p, Fdiag_m;
   HessMatrix Kij, Qij; // finite difference and analytic derivative of Fmat
   using HessType_0 = Tensor<RealType, OHMMS_DIM>;
   using GradType_0 = TinyVector<RealType, DIM>;
   Matrix<GradType_0> Bij, dAij;
   Matrix<HessType_0> Aij_p, Aij_m;
   Fdiag_p.resize(NumOrbitals);
   Fdiag_m.resize(NumOrbitals);
   Fmat_p.resize(NumPtcls, NumOrbitals);
   Fmat_m.resize(NumPtcls, NumOrbitals);
   Kij.resize(NumParticles, NumPtcls);
   Qij.resize(NumParticles, NumPtcls);
   Bij.resize(NumParticles, NumParticles);
   dAij.resize(NumParticles, NumParticles);
   Aij_p.resize(NumParticles, NumParticles);
   Aij_m.resize(NumParticles, NumParticles);
   Fmat_p = 0.0;
   Fmat_m = 0.0;
   Kij    = 0.0;
   Qij    = 0.0;
   Bij    = 0.0;
   dAij   = 0.0;
   Aij_p  = 0.0;
   Aij_m  = 0.0;
   P.update();
   BFTrans_.evaluate(P);
   // calculate backflow matrix, 1st and 2nd derivatives
   evaluate_SPO(psiM, dpsiM, grad_grad_psiM);
   //std::copy(psiM.begin(),psiM.end(),psiMinv.begin());
   psiMinv = psiM;
   // invert backflow matrix
   InverseTimer.start();
   InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
   InverseTimer.stop();
   // calculate F matrix (gradients wrt bf coordinates)
   // could use dgemv with increments of 3*nCols
   for (int i = 0; i < NumPtcls; i++)
   {
     for (int j = 0; j < NumPtcls; j++)
     {
       Fmat(i, j) = simd::dot(psiMinv[i], dpsiM[j], NumOrbitals);
     }
     Fmatdiag[i] = Fmat(i, i);
   }
   // calculate gradients and first piece of laplacians
   GradType temp;
   int num = P.getTotalNum();
   for (int i = 0; i < num; i++)
     for (int j = 0; j < NumPtcls; j++)
       for (int a = 0; a < 3; a++)
         (Bij(i, j))[a] = (BFTrans_.Bmat_full(i, FirstIndex + j))[a];
   for (int i = 0; i < num; i++)
   {
     for (int j = 0; j < NumPtcls; j++)
     {
       HessType q_j;
       q_j = 0.0;
       for (int k = 0; k < NumPtcls; k++)
         q_j += psiMinv(j, k) * grad_grad_psiM(j, k);
       for (int a = 0; a < 3; a++)
       {
         for (int b = 0; b < 3; b++)
         {
           ValueType& qijab = (Qij(i, j))(a, b);
           for (int k = 0; k < NumPtcls; k++)
           {
             if (j == k)
             {
               for (int c = 0; c < 3; c++)
                 qijab -=
                     ((BFTrans_.Amat(i, FirstIndex + k))(a, c)) * (((Fmat(j, k))[c]) * ((Fmat(k, j))[b]) - q_j(b, c));
             }
             else
             {
               for (int c = 0; c < 3; c++)
                 qijab -= ((BFTrans_.Amat(i, FirstIndex + k))(a, c)) * (((Fmat(j, k))[c]) * ((Fmat(k, j))[b]));
             }
           }
         }
       }
     }
   }
   RealType dr = 0.000001;
   for (int i = 0; i < num; i++)
   {
     for (int a = 0; a < 3; a++)
     {
       (P.R[i])[a] += dr;
       P.update();
       BFTrans_.evaluate(P);
       evaluate_SPO(psiM, dpsiM, grad_grad_psiM);
       psiMinv = psiM;
       InverseTimer.start();
       InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
       InverseTimer.stop();
       for (int j = 0; j < NumPtcls; j++)
       {
         Fdiag_p[j] = simd::dot(psiMinv[j], dpsiM[j], NumOrbitals);
       }
       for (int j = 0; j < NumPtcls; j++)
         for (int b = 0; b < 3; b++)
         {
           (Aij_p(i, j))(a, b) = (BFTrans_.Amat(i, FirstIndex + j))(a, b);
         }
       (P.R[i])[a] -= 2.0 * dr;
       P.update();
       BFTrans_.evaluate(P);
       evaluate_SPO(psiM, dpsiM, grad_grad_psiM);
       psiMinv = psiM;
       InverseTimer.start();
       InvertWithLog(psiMinv.data(), NumPtcls, NumOrbitals, WorkSpace.data(), Pivot.data(), log_value_);
       InverseTimer.stop();
       for (int j = 0; j < NumPtcls; j++)
       {
         Fdiag_m[j] = simd::dot(psiMinv[j], dpsiM[j], NumOrbitals);
       }
       for (int j = 0; j < NumPtcls; j++)
         for (int b = 0; b < 3; b++)
         {
           (Aij_m(i, j))(a, b) = (BFTrans_.Amat(i, FirstIndex + j))(a, b);
         }
       (P.R[i])[a] += dr;
       P.update();
       BFTrans_.evaluate(P);
       for (int j = 0; j < NumPtcls; j++)
         for (int b = 0; b < 3; b++)
         {
           (Kij(i, j))(a, b) = ((Fdiag_p[j])[b] - (Fdiag_m[j])[b]) / ((RealType)2.0 * dr);
         }
       for (int j = 0; j < NumPtcls; j++)
         for (int b = 0; b < 3; b++)
         {
           (dAij(i, j))[b] += ((Aij_p(i, j))(a, b) - (Aij_m(i, j))(a, b)) / ((RealType)2.0 * dr);
         }
     }
   }
   std::cout << "Testing derivative of Fjj in complex case: \n";
   for (int i = 0; i < num; i++)
     for (int j = 0; j < NumPtcls; j++)
     {
       std::cout << "i,j: " << i << " " << j << std::endl;
       for (int a = 0; a < 3; a++)
         for (int b = 0; b < 3; b++)
         {
           std::cout << a << " " << b << " " << ((Kij(i, j))(a, b)) - ((Qij(i, j))(a, b)) << " -- "
                     << ((Kij(i, j))(a, b)) << " -- " << ((Qij(i, j))(a, b)) << std::endl;
         }
     }
   std::cout << "Testing derivative of Aij in complex case: \n";
   for (int i = 0; i < num; i++)
     for (int j = 0; j < NumPtcls; j++)
     {
       std::cout << "i,j: " << i << " " << j << std::endl;
       for (int a = 0; a < 3; a++)
       {
         std::cout << a << " " << ((dAij(i, j))[a]) - ((Bij(i, j))[a]) << " -- " << ((dAij(i, j))[a]) << " -- "
                   << ((Bij(i, j))[a]) << std::endl;
       }
     }
   std::cout.flush();
   APP_ABORT("Finished testL: Aborting \n");
 }

◆ updateBuffer()

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

overridevirtual

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 141 of file DiracDeterminantWithBackflow.cpp.

 {
   // for now, always recalculate from scratch
   // enable from_scratch = true later
   UpdateTimer.start();
   myG_temp   = 0.0;
   myL_temp   = 0.0;
   log_value_ = evaluateLog(P, myG_temp, myL_temp);
   P.G += myG_temp;
   P.L += myL_temp;
   //copy psiM to psiM_temp
   psiM_temp = psiM;
   buf.put(psiM.first_address(), psiM.last_address());
   buf.put(FirstAddressOfdV, LastAddressOfdV);
   buf.put(FirstAddressOfGGG, LastAddressOfGGG);
   buf.put(myL.first_address(), myL.last_address());
   buf.put(FirstAddressOfG, LastAddressOfG);
   buf.put(FirstAddressOfFm, LastAddressOfFm);
   buf.put(psiMinv.first_address(), psiMinv.last_address());
   buf.put(log_value_);
   UpdateTimer.stop();
   return log_value_;
 }

Member Data Documentation

◆ Ajk_sum

HessMatrix Ajk_sum

private

Definition at line 171 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), and DiracDeterminantWithBackflow::resize().

◆ BFTrans_

BackflowTransformation& BFTrans_

Definition at line 137 of file DiracDeterminantWithBackflow.h.

◆ curRatio

PsiValue curRatio

private

Definition at line 192 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::ratio(), DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::restore().

◆ d2psiV

ValueVector d2psiV

private

Definition at line 190 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::registerData().

◆ dFa

GradMatrix dFa

private

Definition at line 164 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), and DiracDeterminantWithBackflow::resize().

◆ dpsiM

GradMatrix dpsiM

private

dpsiM(i,j) $= \nabla_i \psi_j({\bf r}_i)$

Definition at line 185 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::dummyEvalLi(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::ratioGrad(), DiracDeterminantWithBackflow::registerData(), DiracDeterminantWithBackflow::resize(), DiracDeterminantWithBackflow::testDerivFjj(), DiracDeterminantWithBackflow::testGG(), DiracDeterminantWithBackflow::testGGG(), and DiracDeterminantWithBackflow::testL().

◆ dpsiM_temp

GradMatrix dpsiM_temp

private

Definition at line 185 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::registerData().

◆ dpsiV

GradVector dpsiV

private

Definition at line 189 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::registerData().

◆ FirstAddressOfdV

ValueType* FirstAddressOfdV

private

Definition at line 195 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ FirstAddressOfFm

ValueType* FirstAddressOfFm

private

Definition at line 204 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ FirstAddressOfG

ParticleSet::SingleParticleValue* FirstAddressOfG

private

Definition at line 193 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ FirstAddressOfGGG

ValueType* FirstAddressOfGGG

private

Definition at line 202 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ Fmat

GradMatrix Fmat

private

Definition at line 172 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::dummyEvalLi(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::resize(), DiracDeterminantWithBackflow::testDerivFjj(), and DiracDeterminantWithBackflow::testL().

◆ Fmatdiag

GradVector Fmatdiag

private

Definition at line 173 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::evalGrad(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::registerData(), DiracDeterminantWithBackflow::resize(), and DiracDeterminantWithBackflow::testL().

◆ Fmatdiag_temp

GradVector Fmatdiag_temp

private

Definition at line 174 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::registerData().

◆ grad_grad_grad_psiM

GGGMatrix grad_grad_grad_psiM

private

Definition at line 168 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::resize(), DiracDeterminantWithBackflow::testDerivFjj(), and DiracDeterminantWithBackflow::testGGG().

◆ grad_grad_psiM

HessMatrix grad_grad_psiM

private

Definition at line 165 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::dummyEvalLi(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::registerData(), DiracDeterminantWithBackflow::resize(), DiracDeterminantWithBackflow::testDerivFjj(), DiracDeterminantWithBackflow::testGGG(), and DiracDeterminantWithBackflow::testL().

◆ grad_grad_psiM_temp

HessMatrix grad_grad_psiM_temp

private

Definition at line 167 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::registerData().

◆ grad_gradV

HessVector grad_gradV

private

Definition at line 166 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::registerData().

◆ Gtemp

ParticleSet::ParticleGradient Gtemp

private

Definition at line 169 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), and DiracDeterminantWithBackflow::resize().

◆ La1

ValueType La1

private

Definition at line 170 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), and DiracDeterminantWithBackflow::testDerivLi().

◆ La2

ValueType La2

private

Definition at line 170 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), and DiracDeterminantWithBackflow::testDerivLi().

◆ La3

ValueType La3

private

Definition at line 170 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), and DiracDeterminantWithBackflow::testDerivLi().

◆ LastAddressOfdV

ValueType* LastAddressOfdV

private

Definition at line 196 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ LastAddressOfFm

ValueType* LastAddressOfFm

private

Definition at line 205 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ LastAddressOfG

ParticleSet::SingleParticleValue* LastAddressOfG

private

Definition at line 194 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ LastAddressOfGGG

ValueType* LastAddressOfGGG

private

Definition at line 203 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ myG

ParticleSet::ParticleGradient myG

private

Definition at line 207 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::registerData(), DiracDeterminantWithBackflow::resize(), and DiracDeterminantWithBackflow::testDerivLi().

◆ myG_temp

ParticleSet::ParticleGradient myG_temp

private

Definition at line 207 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ myL

ParticleSet::ParticleLaplacian myL

private

Definition at line 208 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::registerData(), DiracDeterminantWithBackflow::resize(), DiracDeterminantWithBackflow::testDerivLi(), and DiracDeterminantWithBackflow::updateBuffer().

◆ myL_temp

ParticleSet::ParticleLaplacian myL_temp

private

Definition at line 208 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::registerData(), and DiracDeterminantWithBackflow::updateBuffer().

◆ NP

int NP

private

total number of particles. Ye: used to track first time allocation but I still feel it very strange.

Definition at line 149 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::DiracDeterminantWithBackflow(), and DiracDeterminantWithBackflow::registerData().

◆ NumParticles

int NumParticles

private

Definition at line 163 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::DiracDeterminantWithBackflow(), DiracDeterminantWithBackflow::registerData(), DiracDeterminantWithBackflow::resize(), and DiracDeterminantWithBackflow::testL().

◆ Pivot

Vector<IndexType> Pivot

private

Definition at line 199 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::dummyEvalLi(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::ratio(), DiracDeterminantWithBackflow::ratioGrad(), DiracDeterminantWithBackflow::resize(), DiracDeterminantWithBackflow::testDerivFjj(), and DiracDeterminantWithBackflow::testL().

◆ psiM

ValueMatrix psiM

private

psiM(j,i) $= \psi_j({\bf r}_i)$

Definition at line 179 of file DiracDeterminantWithBackflow.h.

◆ psiM_temp

ValueMatrix psiM_temp

private

Definition at line 179 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::evaluate_SPO(), DiracDeterminantWithBackflow::ratio(), DiracDeterminantWithBackflow::ratioGrad(), DiracDeterminantWithBackflow::resize(), and DiracDeterminantWithBackflow::updateBuffer().

◆ psiMinv

ValueMatrix psiMinv

private

temporary container for testing

Definition at line 182 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::copyFromBuffer(), DiracDeterminantWithBackflow::dummyEvalLi(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::registerData(), DiracDeterminantWithBackflow::resize(), DiracDeterminantWithBackflow::testDerivFjj(), DiracDeterminantWithBackflow::testL(), and DiracDeterminantWithBackflow::updateBuffer().

◆ psiMinv_temp

ValueMatrix psiMinv_temp

private

Definition at line 201 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::acceptMove(), DiracDeterminantWithBackflow::ratio(), DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::resize().

◆ psiV

ValueVector psiV

private

value of single-particle orbital for particle-by-particle update

Definition at line 188 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::ratio(), DiracDeterminantWithBackflow::ratioGrad(), and DiracDeterminantWithBackflow::resize().

◆ Qmat

HessMatrix Qmat

private

Definition at line 171 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::evaluateDerivatives(), and DiracDeterminantWithBackflow::resize().

◆ WorkSpace

Vector<ValueType> WorkSpace

private

Definition at line 198 of file DiracDeterminantWithBackflow.h.

Referenced by DiracDeterminantWithBackflow::dummyEvalLi(), DiracDeterminantWithBackflow::evaluateDerivatives(), DiracDeterminantWithBackflow::evaluateLog(), DiracDeterminantWithBackflow::ratio(), DiracDeterminantWithBackflow::ratioGrad(), DiracDeterminantWithBackflow::resize(), DiracDeterminantWithBackflow::testDerivFjj(), and DiracDeterminantWithBackflow::testL().

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

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

Public Types

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ GGGMatrix

◆ GradMatrix

◆ GradVector

◆ HessMatrix

◆ HessVector

◆ ValueMatrix

◆ ValueVector

Constructor & Destructor Documentation

◆ DiracDeterminantWithBackflow() [1/2]

◆ ~DiracDeterminantWithBackflow()

◆ DiracDeterminantWithBackflow() [2/2]

Member Function Documentation

◆ acceptMove()

◆ copyFromBuffer()

◆ dummyEvalLi()

◆ evalGrad()

◆ evalGradSource() [1/2]

◆ evalGradSource() [2/2]

◆ evaluate_SPO() [1/2]

◆ evaluate_SPO() [2/2]

◆ evaluateDerivatives() [1/3]

◆ evaluateDerivatives() [2/3]

◆ evaluateDerivatives() [3/3]

◆ evaluateLog()

◆ evaluateRatiosAlltoOne()

◆ getClassName()

◆ makeCopy()

◆ makeCopyWithBF()

◆ operator=()

◆ ratio()

◆ ratioGrad()

◆ rcdot()

◆ registerData()

◆ resize()

◆ restore()

◆ testDerivFjj()

◆ testDerivLi()

◆ testGG()

◆ testGGG()

◆ testL()

◆ updateBuffer()

Member Data Documentation

◆ Ajk_sum

◆ BFTrans_

◆ curRatio

◆ d2psiV

◆ dFa

◆ dpsiM

◆ dpsiM_temp

◆ dpsiV

◆ FirstAddressOfdV

◆ FirstAddressOfFm

◆ FirstAddressOfG

◆ FirstAddressOfGGG

◆ Fmat

◆ Fmatdiag

◆ Fmatdiag_temp

◆ grad_grad_grad_psiM

◆ grad_grad_psiM

◆ grad_grad_psiM_temp

◆ grad_gradV

◆ Gtemp

◆ La1

◆ La2

◆ La3

◆ LastAddressOfdV

◆ LastAddressOfFm

◆ LastAddressOfG

◆ LastAddressOfGGG

◆ myG

◆ myG_temp

◆ myL