Inheritance diagram for DiracDeterminant< DU_TYPE >:

Collaboration diagram for DiracDeterminant< DU_TYPE >:

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	mValueType = QMCTraits::QTFull::ValueType

using	mGradType = TinyVector< mValueType, DIM >

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
	DiracDeterminant (std::unique_ptr< SPOSet > &&spos, int first, int last, int ndelay=1, DetMatInvertor matrix_inverter_kind=DetMatInvertor::ACCEL)
	constructor More...

	DiracDeterminant (const DiracDeterminant &s)=delete

DiracDeterminant &	operator= (const DiracDeterminant &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	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...

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

void	updateAfterSweep (const ParticleSet &P, ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L)

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

void	registerTWFFastDerivWrapper (const ParticleSet &P, TWFFastDerivWrapper &twf) const final
	Finds the SPOSet associated with this determinant, and registers it with WFN wrapper. More...

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

void	evaluateRatios (const VirtualParticleSet &VP, std::vector< ValueType > &ratios) override
	compute multiple ratios for a particle move More...

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

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

void	evaluateDerivRatios (const VirtualParticleSet &VP, const opt_variables_type &optvars, std::vector< ValueType > &ratios, Matrix< ValueType > &dratios) override
	evaluate ratios to evaluate the non-local PP 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...

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

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 override
	compute the ratio of the new to old WaveFunctionComponent value and the new gradient of multiple walkers More...

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

GradType	evalGradWithSpin (ParticleSet &P, int iat, ComplexType &spingrad) final
	return the current spin gradient for the iat-th particle Default implementation assumes that WaveFunctionComponent does not explicitly depend on Spin. 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
	Adds the gradient w.r.t. More...

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

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 override
	moves of the iat-th particle on some walkers in a batch is accepted. More...

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

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

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

LogValue	evaluateLog (const ParticleSet &P, ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L) override
	evaluate log of a determinant for a particle set More...

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

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

void	evaluateHessian (ParticleSet &P, HessVector &grad_grad_psi) override

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

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

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

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

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

ValueMatrix &	getPsiMinv () override
	return for testing More...

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

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

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

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

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_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_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 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	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
ValueMatrix	psiM_temp
	psiM(j,i) $= \psi_j({\bf r}_i)$ More...

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

ValueMatrix	psiMinv
	temporary container for testing More...

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

ValueMatrix	d2psiM
	d2psiM(i,j) $= \nabla_i^2 \psi_j({\bf r}_i)$ More...

GradMatrix	grad_source_psiM
	Used for force computations. More...

GradMatrix	grad_lapl_source_psiM

HessMatrix	grad_grad_source_psiM

GradMatrix	phi_alpha_Minv

GradMatrix	grad_phi_Minv

ValueMatrix	lapl_phi_Minv

HessMatrix	grad_phi_alpha_Minv

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

ValueVector	dspin_psiV

GradVector	dpsiV

ValueVector	d2psiV

DU_TYPE	updateEng
	delayed update engine More...

ValueVector	invRow
	the row of up-to-date inverse matrix More...

int	invRow_id
	row id correspond to the up-to-date invRow. More...

PsiValue	curRatio

ValueType *	FirstAddressOfdV

ValueType *	LastAddressOfdV

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

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

Protected Attributes
const int	ndelay_

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

Private Member Functions
void	invertPsiM (const ValueMatrix &logdetT, ValueMatrix &invMat)
	invert psiM or its copies More...

void	resizeScratchObjectsForIonDerivs ()
	Resize all temporary arrays required for force computation. More...

PsiValue	ratioGrad_compute (int iat, GradType &grad_iat)
	internal function computing ratio and gradients after computing the SPOs, used by ratioGrad. More...

Private Attributes
DiracMatrix< QMCTraits::QTFull::ValueType >	host_inverter_
	slow but doesn't consume device memory More...

const DetMatInvertor	matrix_inverter_kind_
	selected scheme for inversion More...

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

Detailed Description

template<typename DU_TYPE = DelayedUpdate<QMCTraits::ValueType, QMCTraits::QTFull::ValueType>>
class qmcplusplus::DiracDeterminant< DU_TYPE >

Definition at line 37 of file DiracDeterminant.h.

Member Typedef Documentation

◆ GradMatrix

using GradMatrix = SPOSet::GradMatrix

Definition at line 49 of file DiracDeterminant.h.

◆ GradVector

using GradVector = SPOSet::GradVector

Definition at line 48 of file DiracDeterminant.h.

◆ HessMatrix

using HessMatrix = SPOSet::HessMatrix

Definition at line 50 of file DiracDeterminant.h.

◆ HessVector

using HessVector = SPOSet::HessVector

Definition at line 51 of file DiracDeterminant.h.

◆ mGradType

using mGradType = TinyVector<mValueType, DIM>

Definition at line 54 of file DiracDeterminant.h.

◆ mValueType

using mValueType = QMCTraits::QTFull::ValueType

Definition at line 53 of file DiracDeterminant.h.

◆ ValueMatrix

using ValueMatrix = SPOSet::ValueMatrix

Definition at line 47 of file DiracDeterminant.h.

◆ ValueVector

using ValueVector = SPOSet::ValueVector

Definition at line 46 of file DiracDeterminant.h.

Constructor & Destructor Documentation

◆ DiracDeterminant() [1/2]

DiracDeterminant	(	std::unique_ptr< SPOSet > &&	spos,
		int	first,
		int	last,
		int	ndelay = `1`,
		DetMatInvertor	matrix_inverter_kind = `DetMatInvertor::ACCEL`
	)

constructor

Parameters

spos	the single-particle orbital set
first	index of the first particle
last	index of last particle
ndelay	delayed update rank
spos	the single-particle orbital set
first	index of the first particle

Definition at line 33 of file DiracDeterminant.cpp.

References RotatedSPOs::buildOptVariables(), DiracDeterminantBase::NumPtcls, DiracDeterminantBase::Phi, and DiracDeterminant< DU_TYPE >::resize().

     : DiracDeterminantBase(getClassName(), std::move(spos), first, last),
       ndelay_(ndelay),
       invRow_id(-1),
       matrix_inverter_kind_(matrix_inverter_kind)
 {
   resize(NumPtcls, NumPtcls);
 
   RotatedSPOs* rot_spo = dynamic_cast<RotatedSPOs*>(Phi.get());
   if (rot_spo)
     rot_spo->buildOptVariables(NumPtcls);
 
   if (Phi->getOrbitalSetSize() < NumPtcls)
   {
     std::ostringstream err_msg;
     err_msg << "The SPOSet " << Phi->getName() << " only has " << Phi->getOrbitalSetSize() << " orbitals "
             << "but this determinant needs at least " << NumPtcls << std::endl;
     throw std::runtime_error(err_msg.str());
   }
 }

◆ DiracDeterminant() [2/2]

DiracDeterminant ( const DiracDeterminant< DU_TYPE > & 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 277 of file DiracDeterminant.cpp.

References qmcplusplus::convertValueToLog(), and qmcplusplus::simd::copy().

 {
   if (curRatio == PsiValue(0))
   {
     std::ostringstream msg;
     msg << "DiracDeterminant::acceptMove curRatio is " << curRatio << "! Report a bug." << std::endl;
     throw std::runtime_error(msg.str());
   }
   ScopedTimer local_timer(UpdateTimer);
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0);
   log_value_ += convertValueToLog(curRatio);
   updateEng.acceptRow(psiM, WorkingIndex, psiV, curRatio);
   if (!safe_to_delay)
     updateEng.updateInvMat(psiM);
   // invRow becomes invalid after accepting a move
   invRow_id = -1;
   if (UpdateMode == ORB_PBYP_PARTIAL)
   {
     simd::copy(dpsiM[WorkingIndex], dpsiV.data(), NumOrbitals);
     simd::copy(d2psiM[WorkingIndex], d2psiV.data(), NumOrbitals);
   }
   curRatio = 1.0;
 }

◆ acquireResource()

void acquireResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< WaveFunctionComponent > &	wfc_list
	)		const

overridevirtual

acquire a shared resource from a collection

Reimplemented from WaveFunctionComponent.

Definition at line 771 of file DiracDeterminant.cpp.

References qmcplusplus::det(), RefVectorWithLeader< T >::getCastedLeader(), and DiracDeterminantBase::Phi.

 {
   auto& wfc_leader = wfc_list.getCastedLeader<DiracDeterminant<DU_TYPE>>();
   RefVectorWithLeader<SPOSet> phi_list(*wfc_leader.Phi);
   for (WaveFunctionComponent& wfc : wfc_list)
   {
     auto& det = static_cast<DiracDeterminant<DU_TYPE>&>(wfc);
     phi_list.push_back(*det.Phi);
   }
   wfc_leader.Phi->acquireResource(collection, phi_list);
 }

◆ completeUpdates()

void completeUpdates ( )

overridevirtual

complete all the delayed or asynchronous operations before leaving the p-by-p move region.

Must be called at the end of each substep if p-by-p move is used. This function was initially introduced for determinant delayed updates to complete all the delayed operations. It has been extended to handle asynchronous operations on accellerators before leaving the p-by-p move region.

Reimplemented from WaveFunctionComponent.

Definition at line 311 of file DiracDeterminant.cpp.

Referenced by DiracDeterminant< DU_TYPE >::mw_completeUpdates().

 {
   ScopedTimer local_timer(UpdateTimer);
   // invRow becomes invalid after updating the inverse matrix
   invRow_id = -1;
   updateEng.updateInvMat(psiM);
 }

◆ 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 397 of file DiracDeterminant.cpp.

References PooledMemory< T_scalar, Alloc >::get(), and PooledMemory< T_scalar, Alloc >::lendReference().

 {
   ScopedTimer local_timer(BufferTimer);
   psiM.attachReference(buf.lendReference<ValueType>(psiM.size()));
   dpsiM.attachReference(buf.lendReference<GradType>(dpsiM.size()));
   d2psiM.attachReference(buf.lendReference<ValueType>(d2psiM.size()));
   buf.get(log_value_);
   // start with invRow labelled invalid
   invRow_id = -1;
   updateEng.initializeInv(psiM);
 }

◆ createResource()

void createResource ( ResourceCollection & collection ) const

overridevirtual

initialize a shared resource and hand it to a collection

Reimplemented from WaveFunctionComponent.

Definition at line 765 of file DiracDeterminant.cpp.

 {
   Phi->createResource(collection);
 }

◆ evalGrad()

DiracDeterminant< DU_TYPE >::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 139 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot().

 {
   ScopedTimer local_timer(RatioTimer);
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0);
   invRow_id = WorkingIndex;
   updateEng.getInvRow(psiM, WorkingIndex, invRow);
   GradType g = simd::dot(invRow.data(), dpsiM[WorkingIndex], invRow.size());
   assert(checkG(g));
   return g;
 }

◆ evalGradSource() [1/2]

DiracDeterminant< DU_TYPE >::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 556 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot().

 {
   GradType g(0.0);
   if (Phi->hasIonDerivs())
   {
     resizeScratchObjectsForIonDerivs();
     Phi->evaluateGradSource(P, FirstIndex, LastIndex, source, iat, grad_source_psiM);
     g = simd::dot(psiM.data(), grad_source_psiM.data(), psiM.size());
   }
 
   return g;
 }

◆ evalGradSource() [2/2]

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

overridevirtual

Adds the gradient w.r.t.

the iat-th particle of the source particleset (ions) of the logarithmic gradient and laplacian w.r.t. the target paritlceset (electrons).

Parameters

P	quantum particle set (electrons)
source	classical particle set (ions)
iat	particle index of source (ion)
the	ion gradient of the elctron gradient
the	ion gradient of the elctron laplacian.

Returns: the log gradient of psi w.r.t. the source particle iat

Reimplemented from WaveFunctionComponent.

Definition at line 598 of file DiracDeterminant.cpp.

References OHMMS_DIM.

 {
   GradType gradPsi(0.0);
   if (Phi->hasIonDerivs())
   {
     resizeScratchObjectsForIonDerivs();
     Phi->evaluateGradSource(P, FirstIndex, LastIndex, source, iat, grad_source_psiM, grad_grad_source_psiM,
                             grad_lapl_source_psiM);
     // HACK HACK HACK
     // Phi->evaluateVGL(P, FirstIndex, LastIndex, psiM, dpsiM, d2psiM);
     // psiM_temp = psiM;
     // LogValue=InvertWithLog(psiM.data(),NumPtcls,NumOrbitals,
     //         WorkSpace.data(),Pivot.data(),PhaseValue);
     // for (int i=0; i<NumPtcls; i++)
     //   for (int j=0; j<NumPtcls; j++) {
     //  double val = 0.0;
     //  for (int k=0; k<NumPtcls; k++)
     //    val += psiM(i,k) * psiM_temp(k,j);
     //  val -= (i == j) ? 1.0 : 0.0;
     //  if (std::abs(val) > 1.0e-12)
     //    std::cerr << "Error in inverse.\n";
     //   }
     // for (int i=0; i<NumPtcls; i++) {
     //   P.G[FirstIndex+i] = GradType();
     //   for (int j=0; j<NumOrbitals; j++)
     //  P.G[FirstIndex+i] += psiM(i,j)*dpsiM(i,j);
     // }
     // Compute matrices
     phi_alpha_Minv      = 0.0;
     grad_phi_Minv       = 0.0;
     lapl_phi_Minv       = 0.0;
     grad_phi_alpha_Minv = 0.0;
     for (int i = 0; i < NumPtcls; i++)
       for (int j = 0; j < NumOrbitals; j++)
       {
         lapl_phi_Minv(i, j) = 0.0;
         for (int k = 0; k < NumOrbitals; k++)
           lapl_phi_Minv(i, j) += d2psiM(i, k) * psiM(j, k);
       }
     for (int dim = 0; dim < OHMMS_DIM; dim++)
     {
       for (int i = 0; i < NumPtcls; i++)
         for (int j = 0; j < NumOrbitals; j++)
         {
           for (int k = 0; k < NumOrbitals; k++)
           {
             phi_alpha_Minv(i, j)[dim] += grad_source_psiM(i, k)[dim] * psiM(j, k);
             grad_phi_Minv(i, j)[dim] += dpsiM(i, k)[dim] * psiM(j, k);
             for (int dim_el = 0; dim_el < OHMMS_DIM; dim_el++)
               grad_phi_alpha_Minv(i, j)(dim, dim_el) += grad_grad_source_psiM(i, k)(dim, dim_el) * psiM(j, k);
           }
         }
     }
     for (int i = 0, iel = FirstIndex; i < NumPtcls; i++, iel++)
     {
       HessType dval(0.0);
       GradType d2val(0.0);
       for (int dim = 0; dim < OHMMS_DIM; dim++)
         for (int dim_el = 0; dim_el < OHMMS_DIM; dim_el++)
           dval(dim, dim_el) = grad_phi_alpha_Minv(i, i)(dim, dim_el);
       for (int j = 0; j < NumOrbitals; j++)
       {
         gradPsi += grad_source_psiM(i, j) * psiM(i, j);
         for (int dim = 0; dim < OHMMS_DIM; dim++)
           for (int k = 0; k < OHMMS_DIM; k++)
             dval(dim, k) -= phi_alpha_Minv(j, i)[dim] * grad_phi_Minv(i, j)[k];
       }
       for (int dim = 0; dim < OHMMS_DIM; dim++)
       {
         for (int k = 0; k < OHMMS_DIM; k++)
           grad_grad[dim][iel][k] += dval(dim, k);
         for (int j = 0; j < NumOrbitals; j++)
         {
           // First term, eq 9
           lapl_grad[dim][iel] += grad_lapl_source_psiM(i, j)[dim] * psiM(i, j);
           // Second term, eq 9
           if (j == i)
             for (int dim_el = 0; dim_el < OHMMS_DIM; dim_el++)
               lapl_grad[dim][iel] -=
                   (RealType)2.0 * grad_phi_alpha_Minv(j, i)(dim, dim_el) * grad_phi_Minv(i, j)[dim_el];
           // Third term, eq 9
           // First term, eq 10
           lapl_grad[dim][iel] -= phi_alpha_Minv(j, i)[dim] * lapl_phi_Minv(i, j);
           // Second term, eq 11
           for (int dim_el = 0; dim_el < OHMMS_DIM; dim_el++)
             lapl_grad[dim][iel] +=
                 (RealType)2.0 * phi_alpha_Minv(j, i)[dim] * grad_phi_Minv(i, i)[dim_el] * grad_phi_Minv(i, j)[dim_el];
         }
       }
     }
   }
   return gradPsi;
 }

◆ evalGradWithSpin()

DiracDeterminant< DU_TYPE >::GradType evalGradWithSpin	(	ParticleSet &	P,
		int	iat,
		ComplexType &	spingrad
	)

finalvirtual

return the current spin gradient for the iat-th particle Default implementation assumes that WaveFunctionComponent does not explicitly depend on Spin.

Parameters

P	quantum particle set
iat	particle index

Returns: the spin gradient of the iat-th particle

Reimplemented from WaveFunctionComponent.

Definition at line 152 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot().

 {
   Phi->evaluate_spin(P, iat, psiV, dspin_psiV);
   ScopedTimer local_timer(RatioTimer);
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0);
   invRow_id = WorkingIndex;
   updateEng.getInvRow(psiM, WorkingIndex, invRow);
   GradType g         = simd::dot(invRow.data(), dpsiM[WorkingIndex], invRow.size());
   ComplexType spin_g = simd::dot(invRow.data(), dspin_psiV.data(), invRow.size());
   spingrad += spin_g;
 
   return g;
 }

◆ evaluateDerivatives()

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 741 of file DiracDeterminant.cpp.

 {
   Phi->evaluateDerivatives(P, active, dlogpsi, dhpsioverpsi, FirstIndex, LastIndex);
 }

◆ evaluateDerivativesWF()

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

overridevirtual

Compute the derivatives of the log of the wavefunction with respect to optimizable parameters.

parameters

Parameters

P	particle set
optvars	optimizable parameters
dlogpsi	array of derivatives of the log of the wavefunction. Note: this function differs from the evaluateDerivatives function in the way that it only computes the derivative of the log of the wavefunction.

Reimplemented from DiracDeterminantBase.

Definition at line 750 of file DiracDeterminant.cpp.

 {
   Phi->evaluateDerivativesWF(P, active, dlogpsi, FirstIndex, LastIndex);
 }

◆ evaluateDerivRatios()

void evaluateDerivRatios	(	const VirtualParticleSet &	VP,
		const opt_variables_type &	optvars,
		std::vector< ValueType > &	ratios,
		Matrix< ValueType > &	dratios
	)

overridevirtual

evaluate ratios to evaluate the non-local PP

Parameters

VP	VirtualParticleSet
ratios	ratios with new positions VP.R[k] the VP.refPtcl
dratios	Nq x Num_param matrix. $\partial_{\alpha}(\ln \Psi ({\bf R}^{\prime}) - \ln \Psi ({\bf R}))$

Reimplemented from WaveFunctionComponent.

Definition at line 522 of file DiracDeterminant.cpp.

References qmcplusplus::syclBLAS::copy_n(), and VirtualParticleSet::refPtcl.

 {
   const int WorkingIndex = VP.refPtcl - FirstIndex;
   assert(WorkingIndex >= 0);
   std::copy_n(psiM[WorkingIndex], invRow.size(), invRow.data());
   Phi->evaluateDerivRatios(VP, optvars, psiV, invRow, ratios, dratios, FirstIndex, LastIndex);
 }

◆ evaluateGL()

DiracDeterminant< DU_TYPE >::LogValue evaluateGL	(	const ParticleSet &	P,
		ParticleSet::ParticleGradient &	G,
		ParticleSet::ParticleLaplacian &	L,
		bool	fromscratch
	)

overridevirtual

compute gradients and laplacian of the TWF with respect to each particle.

Parameters

P	particle set
G	Gradients, $\nabla\ln\Psi$
L	Laplacians, $\nabla^2\ln\Psi$
fromscratch	if true and this WFC is sensitive to numeical error accumulation, all the internal data are recomputed from scratch.

Returns: log(psi)

Reimplemented from WaveFunctionComponent.

Definition at line 370 of file DiracDeterminant.cpp.

 {
   if (fromscratch)
     evaluateLog(P, G, L);
   else
     updateAfterSweep(P, G, L);
   return log_value_;
 }

◆ evaluateHessian()

void evaluateHessian	(	ParticleSet &	P,
		HessVector &	grad_grad_psi
	)

overridevirtual

Reimplemented from WaveFunctionComponent.

Definition at line 572 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot(), and qmcplusplus::outerProduct().

 {
   // Hessian is not often used, so only resize/allocate if used
   grad_grad_source_psiM.resize(psiM.rows(), psiM.cols());
   //IM A HACK.  Assumes evaluateLog has already been executed.
   Phi->evaluate_notranspose(P, FirstIndex, LastIndex, psiM_temp, dpsiM, grad_grad_source_psiM);
   invertPsiM(psiM_temp, psiM);
 
   phi_alpha_Minv      = 0.0;
   grad_phi_Minv       = 0.0;
   lapl_phi_Minv       = 0.0;
   grad_phi_alpha_Minv = 0.0;
   //grad_grad_psi.resize(NumPtcls);
 
   for (int i = 0, iat = FirstIndex; i < NumPtcls; i++, iat++)
   {
     GradType rv = simd::dot(psiM[i], dpsiM[i], NumOrbitals);
     //  HessType hess_tmp=simd::dot(psiM[i],grad_grad_source_psiM[i],NumOrbitals);
     HessType hess_tmp;
     hess_tmp           = 0.0;
     hess_tmp           = simd::dot(psiM[i], grad_grad_source_psiM[i], NumOrbitals);
     grad_grad_psi[iat] = hess_tmp - outerProduct(rv, rv);
   }
 }

◆ evaluateLog()

DiracDeterminant< DU_TYPE >::LogValue evaluateLog	(	const ParticleSet &	P,
		ParticleSet::ParticleGradient &	G,
		ParticleSet::ParticleLaplacian &	L
	)

overridevirtual

evaluate log of a determinant for a particle set

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.

Implements WaveFunctionComponent.

Definition at line 709 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot(), and qmcplusplus::dot().

 {
   recompute(P);
 
   for (int i = 0, iat = FirstIndex; i < NumPtcls; i++, iat++)
   {
     mGradType rv   = simd::dot(psiM[i], dpsiM[i], NumOrbitals);
     mValueType lap = simd::dot(psiM[i], d2psiM[i], NumOrbitals);
     G[iat] += rv;
     L[iat] += lap - dot(rv, rv);
   }
   return log_value_;
 }

◆ evaluateRatios()

void evaluateRatios	(	const VirtualParticleSet &	VP,
		std::vector< ValueType > &	ratios
	)

overridevirtual

compute multiple ratios for a particle move

Reimplemented from WaveFunctionComponent.

Definition at line 445 of file DiracDeterminant.cpp.

References qmcplusplus::syclBLAS::copy_n(), and VirtualParticleSet::refPtcl.

 {
   {
     ScopedTimer local_timer(RatioTimer);
     const int WorkingIndex = VP.refPtcl - FirstIndex;
     assert(WorkingIndex >= 0);
     std::copy_n(psiM[WorkingIndex], invRow.size(), invRow.data());
   }
   {
     ScopedTimer local_timer(SPOVTimer);
     Phi->evaluateDetRatios(VP, psiV, invRow, ratios);
   }
 }

◆ 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 534 of file DiracDeterminant.cpp.

References qmcplusplus::MatrixOperators::product().

 {
   ScopedTimer local_timer(SPOVTimer);
   Phi->evaluateValue(P, -1, psiV);
   Vector<ValueType> ratios_this_det(ratios.data() + FirstIndex, NumPtcls);
   MatrixOperators::product(psiM, psiV, ratios_this_det);
 }

◆ evaluateSpinorRatios()

void evaluateSpinorRatios	(	const VirtualParticleSet &	VP,
		const std::pair< ValueVector, ValueVector > &	spinor_multiplier,
		std::vector< ValueType > &	ratios
	)

overridevirtual

Used by SOECPComponent for faster SOC evaluation.

Reimplemented from WaveFunctionComponent.

Definition at line 460 of file DiracDeterminant.cpp.

References qmcplusplus::syclBLAS::copy_n(), and VirtualParticleSet::refPtcl.

 {
   {
     ScopedTimer local_timer(RatioTimer);
     const int WorkingIndex = VP.refPtcl - FirstIndex;
     assert(WorkingIndex >= 0);
     std::copy_n(psiM[WorkingIndex], invRow.size(), invRow.data());
   }
   {
     ScopedTimer local_timer(SPOVTimer);
     Phi->evaluateDetSpinorRatios(VP, psiV, spinor_multiplier, invRow, ratios);
   }
 }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements WaveFunctionComponent.

Definition at line 72 of file DiracDeterminant.h.

72 { return "DiracDeterminant"; }

◆ getPsiMinv()

ValueMatrix& getPsiMinv ( )

inlineoverridevirtual

return for testing

Reimplemented from DiracDeterminantBase.

Definition at line 210 of file DiracDeterminant.h.

References DiracDeterminant< DU_TYPE >::psiM.

210 { return psiM; }

qmcplusplus::DiracDeterminant::psiM

ValueMatrix psiM

inverse transpose of psiM(j,i)

Definition: DiracDeterminant.h:219

◆ invertPsiM()

void invertPsiM	(	const ValueMatrix &	logdetT,
		ValueMatrix &	invMat
	)

private

invert psiM or its copies

Definition at line 59 of file DiracDeterminant.cpp.

References qmcplusplus::ACCEL, OHMMS::Controller, qmcplusplus::Units::charge::e, omp_get_thread_num(), and Communicate::rank().

 {
   ScopedTimer local_timer(InverseTimer);
   if (matrix_inverter_kind_ == DetMatInvertor::ACCEL)
   {
     bool success        = false;
     int failure_counter = 0;
     do
     {
       try
       {
         updateEng.invert_transpose(logdetT, invMat, log_value_);
         if (failure_counter > 0)
         {
           std::ostringstream success_msg;
           success_msg << "Successful rerun matrix inversion on Rank " << OHMMS::Controller->rank() << " Thread "
                       << omp_get_thread_num() << std::endl;
           std::cerr << success_msg.str();
         }
         success = true;
       }
       catch (const std::exception& e)
       {
         failure_counter++;
         std::ostringstream err_msg;
         err_msg << failure_counter << "th matrix inversion on Rank " << OHMMS::Controller->rank() << " Thread "
                 << omp_get_thread_num() << " which failed earlier with an error:\n  " << e.what() << std::endl;
         std::cerr << err_msg.str();
         if (failure_counter == 1)
         {
           //record the bad matrix to a file at the first failure
           std::ostringstream matfname;
           matfname << "badmatrix.r" << OHMMS::Controller->rank() << "t" << omp_get_thread_num() << ".txt";
           std::ofstream matfile(matfname.str().c_str(), std::ios::app);
           matfile << std::setprecision(14) << std::scientific;
           for (size_t i = 0; i < logdetT.rows(); i++)
           {
             for (size_t j = 0; j < logdetT.cols(); j++)
               matfile << "  " << logdetT[i][j];
             matfile << std::endl;
           }
         }
       }
     } while (!success && failure_counter < 5); // try 5 times at maximum
     if (!success)
       throw std::runtime_error("Matrix inversion failed after " + std::to_string(failure_counter) + " attempts.\n");
   }
   else
   {
     host_inverter_.invert_transpose(logdetT, invMat, log_value_);
     updateEng.initializeInv(psiM);
   }
 }

◆ makeCopy()

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

overridevirtual

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 758 of file DiracDeterminant.cpp.

 {
   return std::make_unique<DiracDeterminant<DU_TYPE>>(std::move(spo), FirstIndex, LastIndex, ndelay_,
                                                      matrix_inverter_kind_);
 }

◆ mw_accept_rejectMove()

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

inlineoverridevirtual

moves of the iat-th particle on some walkers in a batch is accepted.

Update the current content. Note that all the lists only include accepted walkers.

Parameters

wfc_list	the list of WaveFunctionComponent pointers of the same component in a walker batch
p_list	the list of ParticleSet pointers in a walker batch
iat	particle index
safe_to_delay	if true, delayed accept is safe.

Reimplemented from WaveFunctionComponent.

Definition at line 146 of file DiracDeterminant.h.

   {
     for (int iw = 0; iw < wfc_list.size(); iw++)
       if (isAccepted[iw])
         wfc_list[iw].acceptMove(p_list[iw], iat, safe_to_delay);
       else
         wfc_list[iw].restore(iat);
   }

◆ mw_completeUpdates()

void mw_completeUpdates ( const RefVectorWithLeader< WaveFunctionComponent > & wfc_list ) const

inlineoverridevirtual

complete all the delayed or asynchronous operations for all the walkers in a batch before leaving the p-by-p move region.

Reimplemented from WaveFunctionComponent.

Definition at line 161 of file DiracDeterminant.h.

References DiracDeterminant< DU_TYPE >::completeUpdates().

   {
     for (int iw = 0; iw < wfc_list.size(); iw++)
       wfc_list[iw].completeUpdates();
   }

◆ mw_evaluateRatios()

void mw_evaluateRatios	(	const RefVectorWithLeader< WaveFunctionComponent > &	wfc_list,
		const RefVectorWithLeader< const VirtualParticleSet > &	vp_list,
		std::vector< std::vector< ValueType >> &	ratios
	)		const

overridevirtual

evaluate ratios to evaluate the non-local PP multiple walkers

Parameters

wfc_list	the list of WaveFunctionComponent references of the same component in a walker batch
vp_list	the list of VirtualParticleSet references in a walker batch
ratios	of all the virtual moves of all the walkers

Reimplemented from WaveFunctionComponent.

Definition at line 475 of file DiracDeterminant.cpp.

References qmcplusplus::det(), and RefVectorWithLeader< T >::getCastedElement().

 {
   const size_t nw = wfc_list.size();
 
   RefVectorWithLeader<SPOSet> phi_list(*Phi);
   RefVector<ValueVector> psiV_list;
   std::vector<const ValueType*> invRow_ptr_list;
   phi_list.reserve(nw);
   psiV_list.reserve(nw);
   invRow_ptr_list.reserve(nw);
 
   {
     ScopedTimer local_timer(RatioTimer);
     for (size_t iw = 0; iw < nw; iw++)
     {
       auto& det = wfc_list.getCastedElement<DiracDeterminant<DU_TYPE>>(iw);
       const VirtualParticleSet& vp(vp_list[iw]);
       const int WorkingIndex = vp.refPtcl - FirstIndex;
       assert(WorkingIndex >= 0);
       // If DiracDeterminant is in a valid state this copy_n is not necessary.
       // That is at minimum a call to evaluateLog and ...
       // std::copy_n(det.psiM[WorkingIndex], det.invRow.s.ize(), det.invRow.data());
       // build lists
       phi_list.push_back(*det.Phi);
       psiV_list.push_back(det.psiV);
       invRow_ptr_list.push_back(det.psiM[WorkingIndex]);
     }
   }
 
   {
     ScopedTimer local_timer(SPOVTimer);
     // Phi->isOMPoffload() requires device invRow pointers for mw_evaluateDetRatios.
     // evaluateDetRatios only requires host invRow pointers.
     if (Phi->isOMPoffload())
       for (int iw = 0; iw < phi_list.size(); iw++)
       {
         Vector<ValueType> invRow(const_cast<ValueType*>(invRow_ptr_list[iw]), psiV_list[iw].get().size());
         phi_list[iw].evaluateDetRatios(vp_list[iw], psiV_list[iw], invRow, ratios[iw]);
       }
     else
       Phi->mw_evaluateDetRatios(phi_list, vp_list, psiV_list, invRow_ptr_list, ratios);
   }
 }

◆ mw_ratioGrad()

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

overridevirtual

compute the ratio of the new to old WaveFunctionComponent value and the new gradient of multiple walkers

Parameters

wfc_list	the list of WaveFunctionComponent pointers of the same component in a walker batch
p_list	the list of ParticleSet pointers in a walker batch
iat	particle index
ratios	the list of WF ratios of a walker batch, $\Psi( \{ {\bf R}^{'} \} )/ \Psi( \{ {\bf R}\})$
grad_now	the list of new gradients in a walker batch, $\nabla\ln\Psi$

Reimplemented from WaveFunctionComponent.

Definition at line 240 of file DiracDeterminant.cpp.

References qmcplusplus::det(), RefVectorWithLeader< T >::getCastedElement(), and DiracDeterminant< DU_TYPE >::ratioGrad_compute().

 {
   {
     ScopedTimer local_timer(SPOVGLTimer);
     RefVectorWithLeader<SPOSet> phi_list(*Phi);
     phi_list.reserve(wfc_list.size());
     RefVector<ValueVector> psi_v_list;
     psi_v_list.reserve(wfc_list.size());
     RefVector<GradVector> dpsi_v_list;
     dpsi_v_list.reserve(wfc_list.size());
     RefVector<ValueVector> d2psi_v_list;
     d2psi_v_list.reserve(wfc_list.size());
 
     for (WaveFunctionComponent& wfc : wfc_list)
     {
       auto& det = static_cast<DiracDeterminant<DU_TYPE>&>(wfc);
       phi_list.push_back(*det.Phi);
       psi_v_list.push_back(det.psiV);
       dpsi_v_list.push_back(det.dpsiV);
       d2psi_v_list.push_back(det.d2psiV);
     }
 
     Phi->mw_evaluateVGL(phi_list, p_list, iat, psi_v_list, dpsi_v_list, d2psi_v_list);
   }
 
   for (int iw = 0; iw < wfc_list.size(); iw++)
     ratios[iw] = wfc_list.getCastedElement<DiracDeterminant<DU_TYPE>>(iw).ratioGrad_compute(iat, grad_new[iw]);
 }

◆ operator=()

DiracDeterminant& operator= ( const DiracDeterminant< DU_TYPE > & s )

delete

◆ ratio()

DiracDeterminant< DU_TYPE >::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 420 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot().

 {
   UpdateMode             = ORB_PBYP_RATIO;
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0);
   {
     ScopedTimer local_timer(SPOVTimer);
     Phi->evaluateValue(P, iat, psiV);
   }
   {
     ScopedTimer local_timer(RatioTimer);
     // This is an optimization.
     // check invRow_id against WorkingIndex to see if getInvRow() has been called
     // This is intended to save redundant compuation in TM1 and TM3
     if (invRow_id != WorkingIndex)
     {
       invRow_id = WorkingIndex;
       updateEng.getInvRow(psiM, WorkingIndex, invRow);
     }
     curRatio = simd::dot(invRow.data(), psiV.data(), invRow.size());
   }
   return curRatio;
 }

◆ ratioGrad()

DiracDeterminant< DU_TYPE >::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 170 of file DiracDeterminant.cpp.

 {
   {
     ScopedTimer local_timer(SPOVGLTimer);
     Phi->evaluateVGL(P, iat, psiV, dpsiV, d2psiV);
   }
   return ratioGrad_compute(iat, grad_iat);
 }

◆ ratioGrad_compute()

DiracDeterminant< DU_TYPE >::PsiValue ratioGrad_compute	(	int	iat,
		GradType &	grad_iat
	)

private

internal function computing ratio and gradients after computing the SPOs, used by ratioGrad.

Definition at line 182 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot().

Referenced by DiracDeterminant< DU_TYPE >::mw_ratioGrad().

 {
   ScopedTimer local_timer(RatioTimer);
 
   UpdateMode             = ORB_PBYP_PARTIAL;
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0);
   // This is an satefy mechanism.
   // check invRow_id against WorkingIndex to see if getInvRow() has been called already
   // when evalGrad has not been called already or the particle id is not consistent,
   // invRow is recomputed.
   if (invRow_id != WorkingIndex)
   {
     invRow_id = WorkingIndex;
     updateEng.getInvRow(psiM, WorkingIndex, invRow);
   }
   curRatio = simd::dot(invRow.data(), psiV.data(), invRow.size());
   grad_iat += static_cast<ValueType>(static_cast<PsiValue>(1.0) / curRatio) *
       simd::dot(invRow.data(), dpsiV.data(), invRow.size());
   return curRatio;
 }

◆ ratioGradWithSpin()

DiracDeterminant< DU_TYPE >::PsiValue ratioGradWithSpin	(	ParticleSet &	P,
		int	iat,
		GradType &	grad_iat,
		ComplexType &	spingrad_iat
	)

finalvirtual

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.

Parameters

P	the active ParticleSet
iat	the index of a particle
grad_iat	realspace gradient for the active particle
spingrad_iat	spin gradient for the active particle

Reimplemented from WaveFunctionComponent.

Definition at line 205 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot().

 {
   {
     ScopedTimer local_timer(SPOVGLTimer);
     Phi->evaluateVGL_spin(P, iat, psiV, dpsiV, d2psiV, dspin_psiV);
   }
 
   {
     ScopedTimer local_timer(RatioTimer);
     UpdateMode             = ORB_PBYP_PARTIAL;
     const int WorkingIndex = iat - FirstIndex;
     assert(WorkingIndex >= 0);
     // This is an optimization.
     // check invRow_id against WorkingIndex to see if getInvRow() has been called already
     // Some code paths call evalGrad before calling ratioGrad.
     if (invRow_id != WorkingIndex)
     {
       invRow_id = WorkingIndex;
       updateEng.getInvRow(psiM, WorkingIndex, invRow);
     }
     curRatio = simd::dot(invRow.data(), psiV.data(), invRow.size());
     grad_iat += static_cast<ValueType>(static_cast<PsiValue>(1.0) / curRatio) *
         simd::dot(invRow.data(), dpsiV.data(), invRow.size());
 
     spingrad_iat += static_cast<ValueType>(static_cast<PsiValue>(1.0) / curRatio) *
         simd::dot(invRow.data(), dspin_psiV.data(), invRow.size());
   }
 
   return curRatio;
 }

◆ recompute()

void recompute ( const ParticleSet & P )

overridevirtual

recompute the value of the WaveFunctionComponents which require critical accuracy.

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

Reimplemented from WaveFunctionComponent.

Definition at line 726 of file DiracDeterminant.cpp.

 {
   {
     ScopedTimer local_timer(SPOVGLTimer);
     UpdateMode = ORB_WALKER;
     Phi->evaluate_notranspose(P, FirstIndex, LastIndex, psiM_temp, dpsiM, d2psiM);
   }
 
   invertPsiM(psiM_temp, psiM);
 
   // invRow becomes invalid after updating the inverse matrix
   invRow_id = -1;
 }

◆ 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 341 of file DiracDeterminant.cpp.

References PooledMemory< T_scalar, Alloc >::add(), PooledMemory< T_scalar, Alloc >::current(), and PooledMemory< T_scalar, Alloc >::forward().

 {
   if (Bytes_in_WFBuffer == 0)
   {
     //add the data: inverse, gradient and laplacian
     Bytes_in_WFBuffer = buf.current();
     buf.add(psiM.first_address(), psiM.last_address());
     buf.add(FirstAddressOfdV, LastAddressOfdV);
     buf.add(d2psiM.first_address(), d2psiM.last_address());
     Bytes_in_WFBuffer = buf.current() - Bytes_in_WFBuffer;
     // free local space
     psiM.free();
     dpsiM.free();
     d2psiM.free();
   }
   else
   {
     buf.forward(Bytes_in_WFBuffer);
 #ifndef NDEBUG
     // this causes too much output in the legacy code.
     // \todo turn this back on after legacy is dropped,
     // I don't think it should print at all in the new design
     // std::cerr << ("You really should know whether you have registered this objects data previously!, consider this an error in the unified code");
 #endif
   }
   buf.add(log_value_);
 }

◆ registerTWFFastDerivWrapper()

void registerTWFFastDerivWrapper	(	const ParticleSet &	P,
		TWFFastDerivWrapper &	twf
	)		const

finalvirtual

Finds the SPOSet associated with this determinant, and registers it with WFN wrapper.

Reimplemented from DiracDeterminantBase.

Definition at line 410 of file DiracDeterminant.cpp.

References ParticleSet::getGroupID(), and qmcplusplus::twf.

 {
   twf.addGroup(P, P.getGroupID(FirstIndex), Phi.get());
 }

◆ releaseResource()

void releaseResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< WaveFunctionComponent > &	wfc_list
	)		const

overridevirtual

return a shared resource to a collection

Reimplemented from WaveFunctionComponent.

Definition at line 785 of file DiracDeterminant.cpp.

References qmcplusplus::det(), RefVectorWithLeader< T >::getCastedLeader(), and DiracDeterminantBase::Phi.

 {
   auto& wfc_leader = wfc_list.getCastedLeader<DiracDeterminant<DU_TYPE>>();
   RefVectorWithLeader<SPOSet> phi_list(*wfc_leader.Phi);
   for (WaveFunctionComponent& wfc : wfc_list)
   {
     auto& det = static_cast<DiracDeterminant<DU_TYPE>&>(wfc);
     phi_list.push_back(*det.Phi);
   }
   wfc_leader.Phi->releaseResource(collection, phi_list);
 }

◆ resize()

void resize	(	int	nel,
		int	morb
	)

protected

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

Definition at line 116 of file DiracDeterminant.cpp.

References qmcplusplus::ewaldref::DIM.

Referenced by DiracDeterminant< DU_TYPE >::DiracDeterminant().

 {
   if (Bytes_in_WFBuffer > 0)
     throw std::runtime_error("DiracDeterimnant just went out of sync with buffer");
   int norb = morb;
   if (norb <= 0)
     norb = nel; // for morb == -1 (default)
   updateEng.resize(norb, ndelay_);
   psiM.resize(nel, norb);
   dpsiM.resize(nel, norb);
   d2psiM.resize(nel, norb);
   psiV.resize(norb);
   invRow.resize(norb);
   psiM_temp.resize(nel, norb);
 
   dpsiV.resize(NumOrbitals);
   dspin_psiV.resize(NumOrbitals);
   d2psiV.resize(NumOrbitals);
   FirstAddressOfdV = &(dpsiM(0, 0)[0]); //(*dpsiM.begin())[0]);
   LastAddressOfdV  = FirstAddressOfdV + NumPtcls * NumOrbitals * DIM;
 }

◆ resizeScratchObjectsForIonDerivs()

void resizeScratchObjectsForIonDerivs ( )

private

Resize all temporary arrays required for force computation.

Definition at line 544 of file DiracDeterminant.cpp.

 {
   grad_source_psiM.resize(NumPtcls, NumOrbitals);
   grad_lapl_source_psiM.resize(NumPtcls, NumOrbitals);
   grad_grad_source_psiM.resize(NumPtcls, NumOrbitals);
   phi_alpha_Minv.resize(NumPtcls, NumOrbitals);
   grad_phi_Minv.resize(NumPtcls, NumOrbitals);
   lapl_phi_Minv.resize(NumPtcls, NumOrbitals);
   grad_phi_alpha_Minv.resize(NumPtcls, NumOrbitals);
 }

◆ restore()

void restore ( int iat )

overridevirtual

move was rejected.

copy the real container to the temporary to move on

Implements WaveFunctionComponent.

Definition at line 305 of file DiracDeterminant.cpp.

 {
   curRatio = 1.0;
 }

◆ updateAfterSweep()

void updateAfterSweep	(	const ParticleSet &	P,
		ParticleSet::ParticleGradient &	G,
		ParticleSet::ParticleLaplacian &	L
	)

Definition at line 320 of file DiracDeterminant.cpp.

References qmcplusplus::simd::dot(), and qmcplusplus::dot().

 {
   if (UpdateMode == ORB_PBYP_RATIO)
   { //need to compute dpsiM and d2psiM. Do not touch psiM!
     ScopedTimer local_timer(SPOVGLTimer);
     Phi->evaluate_notranspose(P, FirstIndex, LastIndex, psiM_temp, dpsiM, d2psiM);
     UpdateMode = ORB_WALKER;
   }
 
   for (size_t i = 0, iat = FirstIndex; i < NumPtcls; ++i, ++iat)
   {
     mValueType dot_temp = simd::dot(psiM[i], d2psiM[i], NumOrbitals);
     mGradType rv        = simd::dot(psiM[i], dpsiM[i], NumOrbitals);
     G[iat] += rv;
     L[iat] += dot_temp - dot(rv, rv);
   }
 }

◆ updateBuffer()

DiracDeterminant< DU_TYPE >::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 383 of file DiracDeterminant.cpp.

References PooledMemory< T_scalar, Alloc >::forward(), ParticleSet::G, ParticleSet::L, and PooledMemory< T_scalar, Alloc >::put().

 {
   evaluateGL(P, P.G, P.L, fromscratch);
   {
     ScopedTimer local_timer(BufferTimer);
     buf.forward(Bytes_in_WFBuffer);
     buf.put(log_value_);
   }
   return log_value_;
 }

Member Data Documentation

◆ curRatio

PsiValue curRatio

Definition at line 257 of file DiracDeterminant.h.

◆ d2psiM

ValueMatrix d2psiM

d2psiM(i,j) $= \nabla_i^2 \psi_j({\bf r}_i)$

Definition at line 228 of file DiracDeterminant.h.

◆ d2psiV

ValueVector d2psiV

Definition at line 242 of file DiracDeterminant.h.

◆ dpsiM

GradMatrix dpsiM

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

Definition at line 225 of file DiracDeterminant.h.

◆ dpsiV

GradVector dpsiV

Definition at line 241 of file DiracDeterminant.h.

◆ dspin_psiV

ValueVector dspin_psiV

Definition at line 240 of file DiracDeterminant.h.

◆ FirstAddressOfdV

ValueType* FirstAddressOfdV

Definition at line 258 of file DiracDeterminant.h.

◆ grad_grad_source_psiM

HessMatrix grad_grad_source_psiM

Definition at line 232 of file DiracDeterminant.h.

◆ grad_lapl_source_psiM

GradMatrix grad_lapl_source_psiM

Definition at line 231 of file DiracDeterminant.h.

◆ grad_phi_alpha_Minv

HessMatrix grad_phi_alpha_Minv

Definition at line 236 of file DiracDeterminant.h.

◆ grad_phi_Minv

GradMatrix grad_phi_Minv

Definition at line 234 of file DiracDeterminant.h.

◆ grad_source_psiM

GradMatrix grad_source_psiM

Used for force computations.

Definition at line 231 of file DiracDeterminant.h.

◆ host_inverter_

DiracMatrix<QMCTraits::QTFull::ValueType> host_inverter_

private

slow but doesn't consume device memory

Definition at line 263 of file DiracDeterminant.h.

◆ invRow

ValueVector invRow

the row of up-to-date inverse matrix

Definition at line 248 of file DiracDeterminant.h.

◆ invRow_id

int invRow_id

row id correspond to the up-to-date invRow.

[0 norb), invRow is ready; -1, invRow is not valid. This id is set after calling getInvRow indicating invRow has been prepared for the invRow_id row ratioGrad checks if invRow_id is consistent. If not, invRow needs to be recomputed. acceptMove and completeUpdates mark invRow invalid by setting invRow_id to -1

Definition at line 255 of file DiracDeterminant.h.

◆ lapl_phi_Minv

ValueMatrix lapl_phi_Minv

Definition at line 235 of file DiracDeterminant.h.

◆ LastAddressOfdV

ValueType* LastAddressOfdV

Definition at line 259 of file DiracDeterminant.h.

◆ matrix_inverter_kind_

const DetMatInvertor matrix_inverter_kind_

private

selected scheme for inversion

Definition at line 266 of file DiracDeterminant.h.

◆ ndelay_

const int ndelay_

protected

Definition at line 40 of file DiracDeterminant.h.

◆ phi_alpha_Minv

GradMatrix phi_alpha_Minv

Definition at line 234 of file DiracDeterminant.h.

◆ psiM

ValueMatrix psiM

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

Definition at line 219 of file DiracDeterminant.h.

Referenced by DiracDeterminant< DU_TYPE >::getPsiMinv().

◆ psiM_temp

ValueMatrix psiM_temp

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

Definition at line 216 of file DiracDeterminant.h.

◆ psiMinv

ValueMatrix psiMinv

temporary container for testing

Definition at line 222 of file DiracDeterminant.h.

◆ psiV

ValueVector psiV

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

Definition at line 239 of file DiracDeterminant.h.

◆ updateEng

DU_TYPE updateEng

delayed update engine

Definition at line 245 of file DiracDeterminant.h.

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

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

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename DU_TYPE = DelayedUpdate<QMCTraits::ValueType, QMCTraits::QTFull::ValueType>> class qmcplusplus::DiracDeterminant< DU_TYPE >

Member Typedef Documentation

◆ GradMatrix

◆ GradVector

◆ HessMatrix

◆ HessVector

◆ mGradType

◆ mValueType

◆ ValueMatrix

◆ ValueVector

Constructor & Destructor Documentation

◆ DiracDeterminant() [1/2]

◆ DiracDeterminant() [2/2]

Member Function Documentation

◆ acceptMove()

◆ acquireResource()

◆ completeUpdates()

◆ copyFromBuffer()

◆ createResource()

◆ evalGrad()

◆ evalGradSource() [1/2]

◆ evalGradSource() [2/2]

◆ evalGradWithSpin()

◆ evaluateDerivatives()

◆ evaluateDerivativesWF()

◆ evaluateDerivRatios()

◆ evaluateGL()

◆ evaluateHessian()

◆ evaluateLog()

◆ evaluateRatios()

◆ evaluateRatiosAlltoOne()

◆ evaluateSpinorRatios()

◆ getClassName()

◆ getPsiMinv()

◆ invertPsiM()

◆ makeCopy()

◆ mw_accept_rejectMove()

◆ mw_completeUpdates()

◆ mw_evaluateRatios()

◆ mw_ratioGrad()

◆ operator=()

◆ ratio()

◆ ratioGrad()

◆ ratioGrad_compute()

◆ ratioGradWithSpin()

◆ recompute()

◆ registerData()

◆ registerTWFFastDerivWrapper()

◆ releaseResource()

◆ resize()

◆ resizeScratchObjectsForIonDerivs()

◆ restore()

◆ updateAfterSweep()

◆ updateBuffer()

Member Data Documentation

◆ curRatio

◆ d2psiM

◆ d2psiV

◆ dpsiM

◆ dpsiV

◆ dspin_psiV

◆ FirstAddressOfdV

◆ grad_grad_source_psiM

◆ grad_lapl_source_psiM

◆ grad_phi_alpha_Minv

◆ grad_phi_Minv

◆ grad_source_psiM

◆ host_inverter_

◆ invRow

◆ invRow_id

◆ lapl_phi_Minv

template<typename DU_TYPE = DelayedUpdate<QMCTraits::ValueType, QMCTraits::QTFull::ValueType>>
class qmcplusplus::DiracDeterminant< DU_TYPE >