Inheritance diagram for MultiDiracDeterminant:

Collaboration diagram for MultiDiracDeterminant:

Classes
struct	MultiDiracDetMultiWalkerResource

Public Types
template<typename DT >
using	OffloadVector = Vector< DT, OffloadPinnedAllocator< DT > >

template<typename DT >
using	UnpinnedOffloadVector = Vector< DT, OffloadAllocator< DT > >

template<typename DT >
using	OffloadMatrix = Matrix< DT, OffloadPinnedAllocator< DT > >

template<typename DT >
using	UnpinnedOffloadMatrix = Matrix< DT, OffloadAllocator< DT > >

using	ValueVector = SPOSet::ValueVector

using	ValueMatrix = SPOSet::ValueMatrix

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
	MultiDiracDeterminant (std::unique_ptr< SPOSet > &&spos, bool spinor, int first, int nel)
	constructor More...

	~MultiDiracDeterminant () override
	default destructor More...

	MultiDiracDeterminant (const MultiDiracDeterminant &s)
	copy constructor More...

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

std::unique_ptr< SPOSet >	clonePhi () const
	return a clone of Phi More...

SPOSetPtr	getPhi ()

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

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) override
	check out variational optimizable variables More...

void	buildOptVariables (std::vector< size_t > &C2node)
	create optimizable orbital rotation parameters More...

int	build_occ_vec (const OffloadVector< int > &data, const size_t nel, const size_t nmo, std::vector< int > &occ_vec)
	helper function to buildOptVariables More...

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

void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi, const MultiDiracDeterminant &pseudo_dn, const ValueType &psiCurrent, const std::vector< ValueType > &Coeff, const std::vector< size_t > &C2node_up, const std::vector< size_t > &C2node_dn)

void	evaluateDerivativesWF (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, const MultiDiracDeterminant &pseudo_dn, const PsiValue &psiCurrent, const std::vector< ValueType > &Coeff, const std::vector< size_t > &C2node_up, const std::vector< size_t > &C2node_dn)

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

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

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

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

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

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

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

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

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

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

ValueType	evaluate (const ParticleSet &P, ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L)

void	createDetData (const int ref_det_id, const std::vector< ci_configuration2 > &configlist_unsorted, const std::vector< size_t > &C2nodes_unsorted, std::vector< size_t > &C2nodes_sorted)
	create necessary structures related to unique determinants sort configlist_unsorted by excitation level abd store the results in ciConfigList (class member) ciConfigList shouldn't change during a simulation after it is sorted here More...

void	evaluateDetsForPtclMove (const ParticleSet &P, int iat, int refPtcl=-1)
	evaluate the value of all the unique determinants with one electron moved. More...

void	evaluateDetsAndGradsForPtclMove (const ParticleSet &P, int iat)
	evaluate the value and gradients of all the unique determinants with one electron moved. Used by the table method More...

void	evaluateDetsAndGradsForPtclMoveWithSpin (const ParticleSet &P, int iat)
	evaluate the value and gradients of all the unique determinants with one electron moved. Used by the table method. Includes Spin Gradient data More...

void	evaluateGrads (ParticleSet &P, int iat)
	evaluate the gradients of all the unique determinants with one electron moved. Used by the table method More...

void	evaluateGradsWithSpin (ParticleSet &P, int iat)
	evaluate the gradients of all the unique determinants with one electron moved. Used by the table method. Includes Spin Gradient data More...

void	evaluateForWalkerMove (const ParticleSet &P, bool fromScratch=true)

void	evaluateForWalkerMoveWithSpin (const ParticleSet &P, bool fromScratch=true)

int	getNumDets () const

int	getNumPtcls () const

int	getFirstIndex () const

const OffloadVector< ValueType > &	getRatiosToRefDet () const

const OffloadVector< ValueType > &	getNewRatiosToRefDet () const

const Matrix< GradType > &	getGrads () const

const Matrix< GradType > &	getNewGrads () const

const Matrix< ValueType > &	getLapls () const

const Matrix< ValueType > &	getNewLapls () const

const Matrix< ValueType > &	getSpinGrads () const

const Matrix< ValueType > &	getNewSpinGrads () const

PsiValue	getRefDetRatio () const

LogValue	getLogValueRefDet () const

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	registerTWFFastDerivWrapper (const ParticleSet &P, TWFFastDerivWrapper &twf) const
	Register the component with the TWFFastDerivWrapper wrapper. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual void	finalizeOptimization ()

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

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

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

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

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

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

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

Static Public Member Functions
static void	mw_accept_rejectMove (const RefVectorWithLeader< MultiDiracDeterminant > &wfc_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, const std::vector< bool > &isAccepted)

static void	mw_evaluateDetsForPtclMove (const RefVectorWithLeader< MultiDiracDeterminant > &det_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat)
	multi walker version of evaluateDetsForPtclMove More...

static void	mw_evaluateDetsAndGradsForPtclMove (const RefVectorWithLeader< MultiDiracDeterminant > &det_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, UnpinnedOffloadMatrix< ValueType > &mw_grads)
	multi walker version of mw_evaluateDetsAndGradsForPtclMove More...

static void	mw_evaluateGrads (const RefVectorWithLeader< MultiDiracDeterminant > &det_list, const RefVectorWithLeader< ParticleSet > &P_list, int iat, UnpinnedOffloadMatrix< ValueType > &mw_grads)
	multi walker version of mw_evaluateGrads More...

Public Attributes
NewTimer &	inverse_timer

NewTimer &	buildTable_timer

NewTimer &	table2ratios_timer

NewTimer &	evalWalker_timer

NewTimer &	evalOrbValue_timer

NewTimer &	evalOrbVGL_timer

NewTimer &	updateInverse_timer

NewTimer &	calculateRatios_timer

NewTimer &	calculateGradRatios_timer

NewTimer &	updateRatios_timer

NewTimer &	evaluateDetsForPtclMove_timer

NewTimer &	evaluateDetsAndGradsForPtclMove_timer

NewTimer &	evaluateGrads_timer

NewTimer &	offload_timer

NewTimer &	transferH2D_timer

NewTimer &	transferD2H_timer

opt_variables_type	myVars

std::vector< std::vector< int > >	lookup_tbl

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	mw_InverseUpdateByColumn (MultiDiracDetMultiWalkerResource &mw_res, const int working_index, const OffloadVector< ValueType > &curRatio_list, const OffloadVector< ValueType > &psiV_deviceptr_list, const OffloadVector< ValueType > &psiMinv_deviceptr_list, const size_t psiMinv_rows) const

void	mw_updateRatios_generic (const int ext_level, const size_t det_offset, const size_t data_offset, SmallMatrixDetCalculator< ValueType > &det_calculator, const OffloadVector< int > &data, const OffloadVector< RealType > &sign, const RefVector< OffloadMatrix< ValueType >> &table_matrix_list, const RefVector< OffloadVector< ValueType >> &ratios_list) const
	update ratios with respect to the reference deteriminant for a given excitation level More...

void	mw_updateRatios_det0 (const OffloadVector< ValueType > &det0_list, const OffloadVector< ValueType *> &ratios_deviceptr_list) const
	update ratios of the reference deteriminant More...

template<unsigned EXT_LEVEL>
void	mw_updateRatios (const size_t det_offset, const size_t data_offset, const OffloadVector< int > &data, const OffloadVector< RealType > &sign, const OffloadVector< ValueType > &table_matrix_deviceptr_list, const size_t num_table_matrix_cols, const OffloadVector< ValueType > &ratios_deviceptr_list) const
	update ratios with respect to the reference deteriminant for a given excitation level More...

void	mw_buildTableMatrix_calculateRatios_impl (MultiDiracDetMultiWalkerResource &mw_res, int ref, const OffloadVector< ValueType > &det0_list, const RefVector< OffloadMatrix< ValueType >> &psiinv_list, const RefVector< OffloadMatrix< ValueType >> &psi_list, const OffloadVector< int > &data, const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &pairs, const OffloadVector< RealType > &sign, const RefVector< OffloadMatrix< ValueType >> &table_matrix_list, const RefVector< OffloadVector< ValueType >> &ratios_list)
	Function to calculate the ratio of the excited determinant to the reference determinant in CustomizedMatrixDet following the paper by Clark et al. More...

void	buildTableMatrix_calculateRatios_impl (int ref, ValueType det0, ValueType *restrict ratios, const OffloadMatrix< ValueType > &psiinv, const OffloadMatrix< ValueType > &psi, OffloadMatrix< ValueType > &table_matrix, const OffloadVector< int > &data, const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &pairs, const OffloadVector< RealType > &sign)
	Function to calculate the ratio of the excited determinant to the reference determinant in CustomizedMatrixDet following the paper by Clark et al. More...

void	buildTableMatrix_calculateRatios (int ref, const OffloadMatrix< ValueType > &psiinv, const OffloadMatrix< ValueType > &psi, const OffloadVector< int > &data, const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &pairs, const OffloadVector< RealType > &sign, OffloadMatrix< ValueType > &table_matrix, OffloadVector< ValueType > &ratios)
	compute the ratio of the excited determinants to the reference determinant More...

void	mw_buildTableMatrix_calculateRatios (MultiDiracDetMultiWalkerResource &mw_res, int ref, const OffloadVector< ValueType > &det0_list, const RefVector< OffloadMatrix< ValueType >> &psiinv_list, const RefVector< OffloadMatrix< ValueType >> &psi_list, const OffloadVector< int > &data, const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &pairs, const OffloadVector< RealType > &sign, const RefVector< OffloadMatrix< ValueType >> &table_matrix_list, const RefVector< OffloadVector< ValueType >> &ratios_list)

void	buildTableMatrix_calculateGradRatios (int ref, const OffloadMatrix< ValueType > &psiinv, const OffloadMatrix< ValueType > &psi, const OffloadVector< int > &data, const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &pairs, const OffloadVector< RealType > &sign, const ValueType &det0_grad, OffloadMatrix< ValueType > &table_matrix, int dx, int iat, Matrix< GradType > &grads)
	Function to calculate the ratio of the gradients of the excited determinant to the reference determinant in CustomizedMatrixDet following the paper by Clark et al. More...

void	mw_buildTableMatrix_calculateGradRatios (MultiDiracDetMultiWalkerResource &mw_res, int ref, int iat, int dx, int getNumDets, const OffloadVector< ValueType > &det0_grad_list, const RefVector< OffloadMatrix< ValueType >> &psiinv_list, const RefVector< OffloadMatrix< ValueType >> &psi_list, const OffloadVector< int > &data, const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &pairs, const OffloadVector< RealType > &sign, const RefVector< OffloadVector< ValueType >> &WorkSpace_list, const RefVector< OffloadMatrix< ValueType >> &table_matrix_list, UnpinnedOffloadMatrix< ValueType > &mw_grads)
	Function to calculate the ratio of the gradients of the excited determinant to the reference determinant in CustomizedMatrixDet following the paper by Clark et al. More...

void	buildTableMatrix_calculateRatiosValueMatrixOneParticle (int ref, const OffloadMatrix< ValueType > &psiinv, const OffloadMatrix< ValueType > &psi, const OffloadVector< int > &data, const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &pairs, const OffloadVector< RealType > &sign, OffloadMatrix< ValueType > &table_matrix, int iat, Matrix< ValueType > &ratios)

void	resize ()
	reset the size: with the number of particles More...

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

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

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

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

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

std::shared_ptr< std::vector< ci_configuration2 > >	ciConfigList
	use shared_ptr More...

std::shared_ptr< OffloadVector< size_t > >	refdet_occup
	reference determinant occupation More...

const bool	is_spinor_

OffloadMatrix< ValueType >	psiM
	psiM(i,j) $= \psi_j({\bf r}_i)$ TpsiM(i,j) More...

OffloadMatrix< ValueType >	TpsiM

OffloadMatrix< ValueType >	psiMinv
	inverse Dirac determinant matrix of the reference det More...

OffloadMatrix< ValueType >	psiMinv_temp

OffloadMatrix< GradType >	dpsiM
	dpsiM(i,j) $= \nabla_i \psi_j({\bf r}_i)$ More...

OffloadMatrix< ValueType >	dpsiMinv

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

ValueMatrix	dspin_psiM

OffloadVector< ValueType >	psiV
	value of single-particle orbital for particle-by-particle update More...

OffloadVector< ValueType >	psiV_temp

OffloadVector< GradType >	dpsiV

OffloadVector< ValueType >	d2psiV

OffloadVector< ValueType >	workV1

OffloadVector< ValueType >	workV2

ValueVector	dspin_psiV

OffloadMatrix< ValueType >	table_matrix

OffloadVector< ValueType >	WorkSpace

Vector< IndexType >	Pivot

ValueType *	FirstAddressOfGrads

ValueType *	LastAddressOfGrads

ValueType *	FirstAddressOfdpsiM

ValueType *	LastAddressOfdpsiM

OffloadVector< ValueType >	ratios_to_ref_
	determinant ratios with respect to the reference determinant More...

OffloadVector< ValueType >	new_ratios_to_ref_
	new determinant ratios with respect to the updated reference determinant upon a proposed move More...

ValueType	curRatio
	new value of the reference determinant over the old value upon a proposed move More...

LogValue	log_value_ref_det_
	log value of the reference determinant More...

Matrix< GradType >	grads
	store determinant grads (old and new) More...

Matrix< GradType >	new_grads

Matrix< ValueType >	lapls
	store determinant lapls (old and new) More...

Matrix< ValueType >	new_lapls

Matrix< ValueType >	spingrads

Matrix< ValueType >	new_spingrads

std::shared_ptr< OffloadVector< int > >	detData

std::shared_ptr< VectorSoaContainer< int, 2, OffloadPinnedAllocator< int > > >	uniquePairs

std::shared_ptr< OffloadVector< RealType > >	DetSigns

std::shared_ptr< std::vector< int > >	ndets_per_excitation_level_
	number of unique determinants at each excitation level (relative to reference) {1, n_singles, n_doubles, n_triples, ...} More...

SmallMatrixDetCalculator< ValueType >	det_calculator_

ResourceHandle< MultiDiracDetMultiWalkerResource >	mw_res_handle_

Static Private Attributes
static constexpr int	ReferenceDeterminant = 0
	all the unique determinants are sorted, the id of the reference det id is always 0 More...

static constexpr size_t	MaxSmallDet = 5
	for matrices with leading dimensions <= MaxSmallDet, compute determinant with direct expansion. More...

Additional Inherited Members
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

Definition at line 33 of file MultiDiracDeterminant.h.

Member Typedef Documentation

◆ OffloadMatrix

using OffloadMatrix = Matrix<DT, OffloadPinnedAllocator<DT> >

Definition at line 50 of file MultiDiracDeterminant.h.

◆ OffloadVector

using OffloadVector = Vector<DT, OffloadPinnedAllocator<DT> >

Definition at line 46 of file MultiDiracDeterminant.h.

◆ UnpinnedOffloadMatrix

using UnpinnedOffloadMatrix = Matrix<DT, OffloadAllocator<DT> >

Definition at line 52 of file MultiDiracDeterminant.h.

◆ UnpinnedOffloadVector

using UnpinnedOffloadVector = Vector<DT, OffloadAllocator<DT> >

Definition at line 48 of file MultiDiracDeterminant.h.

◆ ValueMatrix

using ValueMatrix = SPOSet::ValueMatrix

Definition at line 55 of file MultiDiracDeterminant.h.

◆ ValueVector

using ValueVector = SPOSet::ValueVector

Definition at line 54 of file MultiDiracDeterminant.h.

Constructor & Destructor Documentation

◆ MultiDiracDeterminant() [1/2]

MultiDiracDeterminant	(	std::unique_ptr< SPOSet > &&	spos,
		bool	spinor,
		int	first,
		int	nel
	)

constructor

Parameters

spos	the single-particle orbital set
first	index of the first particle
spos	the single-particle orbital set
first	index of the first particle
spinor	flag to determinane if spin arrays need to be resized and used

Definition at line 589 of file MultiDiracDeterminant.cpp.

References MultiDiracDeterminant::ciConfigList, MultiDiracDeterminant::detData, MultiDiracDeterminant::DetSigns, MultiDiracDeterminant::ndets_per_excitation_level_, MultiDiracDeterminant::refdet_occup, and MultiDiracDeterminant::uniquePairs.

     : inverse_timer(createGlobalTimer(getClassName() + "::invertRefDet")),
       buildTable_timer(createGlobalTimer(getClassName() + "::buildTable")),
       table2ratios_timer(createGlobalTimer(getClassName() + "::table2ratios")),
       evalWalker_timer(createGlobalTimer(getClassName() + "::evalWalker")),
       evalOrbValue_timer(createGlobalTimer(getClassName() + "::evalOrbValue")),
       evalOrbVGL_timer(createGlobalTimer(getClassName() + "::evalOrbVGL")),
       updateInverse_timer(createGlobalTimer(getClassName() + "::updateRefDetInv")),
       calculateRatios_timer(createGlobalTimer(getClassName() + "::calcRatios")),
       calculateGradRatios_timer(createGlobalTimer(getClassName() + "::calcGradRatios")),
       updateRatios_timer(createGlobalTimer(getClassName() + "::updateRatios")),
       evaluateDetsForPtclMove_timer(createGlobalTimer(getClassName() + "::evaluateDet")),
       evaluateDetsAndGradsForPtclMove_timer(createGlobalTimer(getClassName() + "::evaluateDetAndGrad")),
       evaluateGrads_timer(createGlobalTimer(getClassName() + "::evaluateGrad")),
       offload_timer(createGlobalTimer(getClassName() + "::offload")),
       transferH2D_timer(createGlobalTimer(getClassName() + "::transferH2D")),
       transferD2H_timer(createGlobalTimer(getClassName() + "::transferD2H")),
       Phi(std::move(spos)),
       NumOrbitals(Phi->getOrbitalSetSize()),
       FirstIndex(first),
       NumPtcls(nel),
       LastIndex(first + nel),
       is_spinor_(spinor)
 {
   ciConfigList                = std::make_shared<std::vector<ci_configuration2>>();
   refdet_occup                = std::make_shared<OffloadVector<size_t>>();
   detData                     = std::make_shared<OffloadVector<int>>();
   uniquePairs                 = std::make_shared<VectorSoaContainer<int, 2, OffloadPinnedAllocator<int>>>();
   DetSigns                    = std::make_shared<OffloadVector<RealType>>();
   ndets_per_excitation_level_ = std::make_shared<std::vector<int>>();
 }

◆ ~MultiDiracDeterminant()

~MultiDiracDeterminant ( )

overridedefault

default destructor

◆ MultiDiracDeterminant() [2/2]

MultiDiracDeterminant ( const MultiDiracDeterminant & s )

copy constructor

Parameters

s	existing DiracDeterminant

This constructor makes a shallow copy of Phi. Other data members are allocated properly.

Definition at line 541 of file MultiDiracDeterminant.cpp.

References MultiDiracDeterminant::resize().

     : WaveFunctionComponent(s),
       inverse_timer(s.inverse_timer),
       buildTable_timer(s.buildTable_timer),
       table2ratios_timer(s.table2ratios_timer),
       evalWalker_timer(s.evalWalker_timer),
       evalOrbValue_timer(s.evalOrbValue_timer),
       evalOrbVGL_timer(s.evalOrbVGL_timer),
       updateInverse_timer(s.updateInverse_timer),
       calculateRatios_timer(s.calculateRatios_timer),
       calculateGradRatios_timer(s.calculateGradRatios_timer),
       updateRatios_timer(s.updateRatios_timer),
       evaluateDetsForPtclMove_timer(s.evaluateDetsForPtclMove_timer),
       evaluateDetsAndGradsForPtclMove_timer(s.evaluateDetsAndGradsForPtclMove_timer),
       evaluateGrads_timer(s.evaluateGrads_timer),
       offload_timer(s.offload_timer),
       transferH2D_timer(s.transferH2D_timer),
       transferD2H_timer(s.transferD2H_timer),
       lookup_tbl(s.lookup_tbl),
       Phi(s.Phi->makeClone()),
       NumOrbitals(Phi->getOrbitalSetSize()),
       FirstIndex(s.FirstIndex),
       NumPtcls(s.NumPtcls),
       LastIndex(s.LastIndex),
       ciConfigList(s.ciConfigList),
       refdet_occup(s.refdet_occup),
       is_spinor_(s.is_spinor_),
       detData(s.detData),
       uniquePairs(s.uniquePairs),
       DetSigns(s.DetSigns),
       ndets_per_excitation_level_(s.ndets_per_excitation_level_)
 {
   resize();
 }

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 411 of file MultiDiracDeterminant.cpp.

 {
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0 && WorkingIndex < LastIndex - FirstIndex);
   assert(P.isSpinor() == is_spinor_);
   if (curRatio == ValueType(0))
   {
     std::ostringstream msg;
     msg << "MultiDiracDeterminant::acceptMove curRatio is " << curRatio << "! Report a bug." << std::endl;
     throw std::runtime_error(msg.str());
   }
   log_value_ref_det_ += convertValueToLog(curRatio);
   curRatio = ValueType(1);
   switch (UpdateMode)
   {
   case ORB_PBYP_RATIO:
     psiMinv = psiMinv_temp;
     // Ye: During acceptMove and restore, TpsiM is updated on the host, thus need to update the device copy.
     // Ideally, this should be done directly on the device.
     // However, acceptMove/restore are shared by both single walker and batched APIs.
     // So the data motion must be kept consistently in all implementations.
     // Right now in batched APIs, ratio and ratioGad implementation also doesn't have the same data motion.
     // Thus also need a fix.
     for (int i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = psiV[i];
     std::copy(psiV.begin(), psiV.end(), psiM[iat - FirstIndex]);
     std::copy(new_ratios_to_ref_.begin(), new_ratios_to_ref_.end(), ratios_to_ref_.begin());
     {
       ScopedTimer local_timer(transferH2D_timer);
       ratios_to_ref_.updateTo();
       TpsiM.updateTo();
       psiMinv.updateTo();
       psiM.updateTo();
       dpsiM.updateTo();
     }
     break;
   case ORB_PBYP_PARTIAL:
     psiMinv = psiMinv_temp;
     for (int i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = psiV[i];
     std::copy(new_ratios_to_ref_.begin(), new_ratios_to_ref_.end(), ratios_to_ref_.begin());
     std::copy(psiV.begin(), psiV.end(), psiM[WorkingIndex]);
     std::copy(dpsiV.begin(), dpsiV.end(), dpsiM[WorkingIndex]);
     std::copy(d2psiV.begin(), d2psiV.end(), d2psiM[WorkingIndex]);
     {
       ScopedTimer local_timer(transferH2D_timer);
       ratios_to_ref_.updateTo();
       TpsiM.updateTo();
       psiMinv.updateTo();
       psiM.updateTo();
       dpsiM.updateTo();
     }
     if (is_spinor_)
       std::copy(dspin_psiV.begin(), dspin_psiV.end(), dspin_psiM[WorkingIndex]);
     break;
   default:
     psiMinv = psiMinv_temp;
     for (int i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = psiV[i];
 
     std::copy(new_ratios_to_ref_.begin(), new_ratios_to_ref_.end(), ratios_to_ref_.begin());
     std::copy(new_grads.begin(), new_grads.end(), grads.begin());
     std::copy(new_lapls.begin(), new_lapls.end(), lapls.begin());
     std::copy(psiV.begin(), psiV.end(), psiM[WorkingIndex]);
     std::copy(dpsiV.begin(), dpsiV.end(), dpsiM[WorkingIndex]);
     std::copy(d2psiV.begin(), d2psiV.end(), d2psiM[WorkingIndex]);
     {
       ScopedTimer local_timer(transferH2D_timer);
       ratios_to_ref_.updateTo();
       TpsiM.updateTo();
       psiMinv.updateTo();
       psiM.updateTo();
       dpsiM.updateTo();
     }
     if (is_spinor_)
     {
       std::copy(new_spingrads.begin(), new_spingrads.end(), spingrads.begin());
       std::copy(dspin_psiV.begin(), dspin_psiV.end(), dspin_psiM[WorkingIndex]);
     }
     break;
   }
 }

◆ acquireResource()

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

Definition at line 655 of file MultiDiracDeterminant.cpp.

 {
   auto& wfc_leader          = wfc_list.getCastedLeader<MultiDiracDeterminant>();
   wfc_leader.mw_res_handle_ = collection.lendResource<MultiDiracDetMultiWalkerResource>();
   auto& mw_res              = wfc_leader.mw_res_handle_.getResource();
 
   const size_t nw = wfc_list.size();
   mw_res.resizeConstants(nw);
 
   auto& psiV_temp_deviceptr_list    = mw_res.psiV_temp_deviceptr_list;
   auto& psiMinv_temp_deviceptr_list = mw_res.psiMinv_temp_deviceptr_list;
   auto& dpsiMinv_deviceptr_list     = mw_res.dpsiMinv_deviceptr_list;
   auto& workV1_deviceptr_list       = mw_res.workV1_deviceptr_list;
   auto& workV2_deviceptr_list       = mw_res.workV2_deviceptr_list;
 
   auto& psiV_deviceptr_list    = mw_res.psiV_deviceptr_list;
   auto& dpsiV_deviceptr_list   = mw_res.dpsiV_deviceptr_list;
   auto& TpsiM_deviceptr_list   = mw_res.TpsiM_deviceptr_list;
   auto& psiM_deviceptr_list    = mw_res.psiM_deviceptr_list;
   auto& psiMinv_deviceptr_list = mw_res.psiMinv_deviceptr_list;
   auto& dpsiM_deviceptr_list   = mw_res.dpsiM_deviceptr_list;
 
   psiV_temp_deviceptr_list.resize(nw);
   psiMinv_temp_deviceptr_list.resize(nw);
   dpsiMinv_deviceptr_list.resize(nw);
   workV1_deviceptr_list.resize(nw);
   workV2_deviceptr_list.resize(nw);
 
   psiV_deviceptr_list.resize(nw);
   dpsiV_deviceptr_list.resize(nw);
   TpsiM_deviceptr_list.resize(nw);
   psiM_deviceptr_list.resize(nw);
   psiMinv_deviceptr_list.resize(nw);
   dpsiM_deviceptr_list.resize(nw);
 
   for (size_t iw = 0; iw < nw; iw++)
   {
     auto& det                       = wfc_list.getCastedElement<MultiDiracDeterminant>(iw);
     psiV_temp_deviceptr_list[iw]    = det.psiV_temp.device_data();
     psiMinv_temp_deviceptr_list[iw] = det.psiMinv_temp.device_data();
     dpsiMinv_deviceptr_list[iw]     = det.dpsiMinv.device_data();
     workV1_deviceptr_list[iw]       = det.workV1.device_data();
     workV2_deviceptr_list[iw]       = det.workV2.device_data();
 
     psiV_deviceptr_list[iw]    = det.psiV.device_data();
     dpsiV_deviceptr_list[iw]   = det.dpsiV.device_data();
     TpsiM_deviceptr_list[iw]   = det.TpsiM.device_data();
     psiM_deviceptr_list[iw]    = det.psiM.device_data();
     psiMinv_deviceptr_list[iw] = det.psiMinv.device_data();
     dpsiM_deviceptr_list[iw]   = det.dpsiM.device_data();
   }
 
   psiV_temp_deviceptr_list.updateTo();
   psiMinv_temp_deviceptr_list.updateTo();
   dpsiMinv_deviceptr_list.updateTo();
   workV1_deviceptr_list.updateTo();
   workV2_deviceptr_list.updateTo();
 
   psiV_deviceptr_list.updateTo();
   dpsiV_deviceptr_list.updateTo();
   TpsiM_deviceptr_list.updateTo();
   psiM_deviceptr_list.updateTo();
   psiMinv_deviceptr_list.updateTo();
   dpsiM_deviceptr_list.updateTo();
 }

◆ build_occ_vec()

int build_occ_vec	(	const OffloadVector< int > &	data,
		const size_t	nel,
		const size_t	nmo,
		std::vector< int > &	occ_vec
	)

helper function to buildOptVariables

Definition at line 834 of file MultiDiracDeterminant.cpp.

References Vector< T, Alloc >::size().

Referenced by MultiDiracDeterminant::buildOptVariables().

 {
   size_t it = 0;
   int count = 0; //number of determinants
   while (it < data.size())
   {
     int k = data[it]; // number of excitations with respect to the reference matrix
     if (count == 0)
     {
       it += 3 * k + 1;
       count++;
     }
     else
     {
       for (int i = 0; i < k; i++)
       {
         //for determining active orbitals
         occ_vec[data[it + 1 + i]]++;
         occ_vec[data[it + 1 + k + i]]++;
       }
       it += 3 * k + 1;
       count++;
     }
   }
   return count;
 }

◆ buildOptVariables()

void buildOptVariables ( std::vector< size_t > & C2node )

create optimizable orbital rotation parameters

Definition at line 771 of file MultiDiracDeterminant.cpp.

References MultiDiracDeterminant::build_occ_vec(), RotatedSPOs::buildOptVariables(), MultiDiracDeterminant::detData, MultiDiracDeterminant::isOptimizable(), MultiDiracDeterminant::lookup_tbl, MultiDiracDeterminant::NumOrbitals, MultiDiracDeterminant::NumPtcls, and MultiDiracDeterminant::Phi.

 {
   if (!isOptimizable())
     return;
 
   const size_t nel = NumPtcls;
   const size_t nmo = NumOrbitals;
   //a vector in which the element's index value correspond to Molecular Orbitals.
   //The element value at an index indicates how many times an electron is excited from or to that orbital in the Multi-Slater expansion i.e the indices with non-zero elements are active space orbitals
   std::vector<int> occupancy_vector(nmo, 0);
 
   // Function to fill occupancy_vectors and also return number of unique determinants
   const size_t unique_dets = build_occ_vec(*detData, nel, nmo, occupancy_vector);
 
   // When calculating the parameter derivative of the Multi-Slater component of the wavefunction, each unique deterimant can contribute multiple times.
   // The lookup_tbls are used so that a parameter derivative of a unique determinant is only done once and then scaled according to how many times it appears in the Multi-Slater expansion
   lookup_tbl.resize(unique_dets);
   //construct lookup table
   for (int i(0); i < C2node.size(); i++)
   {
     lookup_tbl[C2node[i]].push_back(i);
   }
 
   // create active rotation parameter indices
   std::vector<std::pair<int, int>> m_act_rot_inds;
   std::vector<std::pair<int, int>> other_rot_inds;
 
   for (int i = 0; i < nmo; i++)
     for (int j = i + 1; j < nmo; j++)
     {
       bool core_i(!occupancy_vector[i] and i <= nel - 1); // true if orbital i is a 'core' orbital
       bool core_j(!occupancy_vector[j] and j <= nel - 1); // true if orbital j is a 'core' orbital
       bool virt_i(!occupancy_vector[i] and i > nel - 1);  // true if orbital i is a 'virtual' orbital
       bool virt_j(!occupancy_vector[j] and j > nel - 1);  // true if orbital j is a 'virtual' orbital
       if (!((core_i and core_j) or (virt_i and virt_j)))
       {
         m_act_rot_inds.push_back(
             std::pair<
                 int,
                 int>(i,
                      j)); // orbital rotation parameter accepted as long as rotation isn't core-core or virtual-virtual
       }
       else
       {
         other_rot_inds.push_back(std::pair<int, int>(i, j));
       }
     }
 
   std::vector<std::pair<int, int>> full_rot_inds;
 
   // Copy the adjustable rotations first
   full_rot_inds = m_act_rot_inds;
   // Add the other rotations at the end
   full_rot_inds.insert(full_rot_inds.end(), other_rot_inds.begin(), other_rot_inds.end());
 
 
 #ifndef QMC_COMPLEX
   RotatedSPOs* rot_spo = dynamic_cast<RotatedSPOs*>(Phi.get());
   if (rot_spo)
     rot_spo->buildOptVariables(m_act_rot_inds, full_rot_inds);
 #endif
 }

◆ buildTableMatrix_calculateGradRatios()

void buildTableMatrix_calculateGradRatios	(	int	ref,
		const OffloadMatrix< ValueType > &	psiinv,
		const OffloadMatrix< ValueType > &	psi,
		const OffloadVector< int > &	data,
		const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &	pairs,
		const OffloadVector< RealType > &	sign,
		const ValueType &	det0_grad,
		OffloadMatrix< ValueType > &	table_matrix,
		int	dx,
		int	iat,
		Matrix< GradType > &	grads
	)

private

Function to calculate the ratio of the gradients of the excited determinant to the reference determinant in CustomizedMatrixDet following the paper by Clark et al.

JCP 135(24), 244105

Parameters

ref	ID of the reference determinant
psiinv
psi
data	(Shared by all determinants)
pairs	is the number of unique determinants (std::pair[Nb_unique_alpha][Nb_unique_beta]) (Shared by all determinants)
sign	(Shared by all determinants)
det0_grad	gradient value taking RatioGrad/curRatio
table_matrix	stores all the dot products between 2 determinants (I,J)
dx	dimension (OHMMS_DIM)
iat	atom ID
grads	returned computed gradients

Definition at line 248 of file MultiDiracDeterminant.2.cpp.

References MultiDiracDeterminant::buildTableMatrix_calculateRatios_impl(), MultiDiracDeterminant::calculateGradRatios_timer, MultiDiracDeterminant::getNumDets(), MultiDiracDeterminant::grads, sign(), MultiDiracDeterminant::table_matrix, and MultiDiracDeterminant::WorkSpace.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGrads(), and MultiDiracDeterminant::evaluateGradsWithSpin().

 {
   ScopedTimer local_timer(calculateGradRatios_timer);
   buildTableMatrix_calculateRatios_impl(ref, det0_grad, WorkSpace.data(), psiinv, psi, table_matrix, data, pairs, sign);
   for (size_t count = 0; count < getNumDets(); ++count)
     grads(count, iat)[dx] = WorkSpace[count];
 }

◆ buildTableMatrix_calculateRatios()

void buildTableMatrix_calculateRatios	(	int	ref,
		const OffloadMatrix< ValueType > &	psiinv,
		const OffloadMatrix< ValueType > &	psi,
		const OffloadVector< int > &	data,
		const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &	pairs,
		const OffloadVector< RealType > &	sign,
		OffloadMatrix< ValueType > &	table_matrix,
		OffloadVector< ValueType > &	ratios
	)

private

compute the ratio of the excited determinants to the reference determinant

Parameters

ratios the output.

Definition at line 211 of file MultiDiracDeterminant.2.cpp.

References MultiDiracDeterminant::buildTableMatrix_calculateRatios_impl(), MultiDiracDeterminant::calculateRatios_timer, Vector< T, Alloc >::data(), sign(), and MultiDiracDeterminant::table_matrix.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), MultiDiracDeterminant::evaluateForWalkerMove(), and MultiDiracDeterminant::evaluateForWalkerMoveWithSpin().

 {
   ScopedTimer local_timer(calculateRatios_timer);
   buildTableMatrix_calculateRatios_impl(ref, ValueType(1), ratios.data(), psiinv, psi, table_matrix, data, pairs, sign);
 }

◆ buildTableMatrix_calculateRatios_impl()

void buildTableMatrix_calculateRatios_impl	(	int	ref,
		ValueType	det0,
		ValueType *restrict	ratios,
		const OffloadMatrix< ValueType > &	psiinv,
		const OffloadMatrix< ValueType > &	psi,
		OffloadMatrix< ValueType > &	table_matrix,
		const OffloadVector< int > &	data,
		const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &	pairs,
		const OffloadVector< RealType > &	sign
	)

private

Function to calculate the ratio of the excited determinant to the reference determinant in CustomizedMatrixDet following the paper by Clark et al.

shared function used by buildTableMatrix_calculateRatios

JCP 135(24), 244105

Parameters

ref	ID of the reference determinant
det0	take ValueType(1) for the value or RatioGrad/curRatio for the gradients
ratios	returned computed ratios
psiinv
psi
table_matrix	stores all the dot products between 2 determinants (I,J)
data	(Shared by all determinants)
pairs	is the number of unique determinants (std::pair[Nb_unique_alpha][Nb_unique_beta]) (Shared by all determinants)
sign	(Shared by all determinants)

Definition at line 29 of file MultiDiracDeterminant.2.cpp.

References MultiDiracDeterminant::buildTable_timer, qmcplusplus::calcSmallDeterminant(), Vector< T, Alloc >::data(), MultiDiracDeterminant::det_calculator_, qmcplusplus::simd::dot(), SmallMatrixDetCalculator< T >::evaluate(), Matrix< T, Alloc >::extent(), I, qmcplusplus::Units::energy::J, MultiDiracDeterminant::MaxSmallDet, qmcplusplus::n, qmcplusplus::Units::second, sign(), MultiDiracDeterminant::table2ratios_timer, and MultiDiracDeterminant::table_matrix.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateGradRatios(), MultiDiracDeterminant::buildTableMatrix_calculateRatios(), and MultiDiracDeterminant::buildTableMatrix_calculateRatiosValueMatrixOneParticle().

 {
   {
     ScopedTimer local(buildTable_timer);
     const size_t num    = psi.extent(1);
     const size_t npairs = pairs.size();
     //MatrixOperators::product_ABt(psiinv,psi,table_matrix);
     const int* first  = pairs.data(0);
     const int* second = pairs.data(1);
     for (size_t i = 0; i < npairs; ++i)
     {
       const int I        = first[i];
       const int J        = second[i];
       table_matrix(I, J) = simd::dot(psiinv[I], psi[J], num);
     }
   }
 
   {
     ScopedTimer local(table2ratios_timer);
     const int* it2       = data.data();
     const size_t nitems  = sign.size();
     const size_t nb_cols = table_matrix.cols();
     // explore Inclusive Scan for OpenMP
     for (size_t count = 0; count < nitems; ++count)
     {
       const size_t n = *it2;
       if (count != ref)
         ratios[count] = sign[count] * det0 *
             (n > MaxSmallDet ? det_calculator_.evaluate(table_matrix, it2 + 1, n)
                              : calcSmallDeterminant(n, table_matrix.data(), it2 + 1, nb_cols));
       it2 += 3 * n + 1;
     }
 
     ratios[ref] = det0;
   }
 }

◆ buildTableMatrix_calculateRatiosValueMatrixOneParticle()

void buildTableMatrix_calculateRatiosValueMatrixOneParticle	(	int	ref,
		const OffloadMatrix< ValueType > &	psiinv,
		const OffloadMatrix< ValueType > &	psi,
		const OffloadVector< int > &	data,
		const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &	pairs,
		const OffloadVector< RealType > &	sign,
		OffloadMatrix< ValueType > &	table_matrix,
		int	iat,
		Matrix< ValueType > &	ratios
	)

private

Definition at line 303 of file MultiDiracDeterminant.2.cpp.

References MultiDiracDeterminant::buildTableMatrix_calculateRatios_impl(), qmcplusplus::simd::dot(), MultiDiracDeterminant::getNumDets(), qmcplusplus::n, sign(), MultiDiracDeterminant::table_matrix, and MultiDiracDeterminant::WorkSpace.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), and MultiDiracDeterminant::evaluateGradsWithSpin().

 {
   const ValueType det0 = ratios(ref, iat);
   buildTableMatrix_calculateRatios_impl(ref, det0, WorkSpace.data(), psiinv, psi, table_matrix, data, pairs, sign);
   //splatt
   for (size_t count = 0; count < getNumDets(); ++count)
     ratios(count, iat) = WorkSpace[count];
 #if 0
     ValueType det0 = ratios(ref,iat);
     int num=psi.extent(1);
     std::vector<std::pair<int,int> >::iterator it(pairs.begin()), last(pairs.end());
     while(it != last)
     {
       table_matrix((*it).first,(*it).second) = simd::dot(psiinv[(*it).first],psi[(*it).second],num);
       it++;
     }
     std::vector<int>::iterator it2 = data.begin();
     int count= 0;  // number of determinants processed
     while(it2 != data.end())
     {
       int n = *it2; // number of excitations
       if(count == ref)
       {
         it2+=3*n+1;  // number of integers used to encode the current excitation
         count++;
         continue;
       }
       ratios(count,iat) = sign[count]*det0*CustomizedMatrixDet(n,table_matrix,it2+1);
       count++;
       it2+=3*n+1;
     }
 #endif
 }

◆ checkOutVariables()

void checkOutVariables ( const opt_variables_type & active )

inlineoverridevirtual

check out variational optimizable variables

Parameters

active a super set of optimizable variables

Reimplemented from WaveFunctionComponent.

Definition at line 157 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::Phi.

   {
     if (Phi->isOptimizable())
       Phi->checkOutVariables(active);
   }

◆ clonePhi()

std::unique_ptr< SPOSet > clonePhi ( ) const

return a clone of Phi

Definition at line 576 of file MultiDiracDeterminant.cpp.

References MultiDiracDeterminant::Phi.

576 { return Phi->makeClone(); }

qmcplusplus::MultiDiracDeterminant::Phi

const std::unique_ptr< SPOSet > Phi

a set of single-particle orbitals used to fill in the values of the matrix

Definition: MultiDiracDeterminant.h:516

◆ 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 384 of file MultiDiracDeterminant.cpp.

 {
   assert(P.isSpinor() == is_spinor_);
   buf.get(psiM.first_address(), psiM.last_address());
   buf.get(FirstAddressOfdpsiM, LastAddressOfdpsiM);
   buf.get(d2psiM.first_address(), d2psiM.last_address());
   buf.get(psiMinv.first_address(), psiMinv.last_address());
   buf.get(log_value_ref_det_);
   buf.get(ratios_to_ref_.first_address(), ratios_to_ref_.last_address());
   buf.get(FirstAddressOfGrads, LastAddressOfGrads);
   buf.get(lapls.first_address(), lapls.last_address());
   if (is_spinor_)
   {
     buf.get(dspin_psiM.first_address(), dspin_psiM.last_address());
     buf.get(spingrads.first_address(), spingrads.last_address());
   }
   // only used with ORB_PBYP_ALL,
   psiMinv_temp = psiMinv;
   int n1       = psiM.extent(0);
   int n2       = psiM.extent(1);
   for (int i = 0; i < n1; i++)
     for (int j = 0; j < n2; j++)
       TpsiM(j, i) = psiM(i, j);
 }

◆ createDetData()

void createDetData	(	const int	ref_det_id,
		const std::vector< ci_configuration2 > &	configlist_unsorted,
		const std::vector< size_t > &	C2nodes_unsorted,
		std::vector< size_t > &	C2nodes_sorted
	)

create necessary structures related to unique determinants sort configlist_unsorted by excitation level abd store the results in ciConfigList (class member) ciConfigList shouldn't change during a simulation after it is sorted here

Parameters

ref_det_id	id of the reference determinant before sorting
configlist_unsorted	config list to be loaded.
C2nodes_unsorted	mapping from overall det index to unique det (configlist_unsorted) index
C2nodes_sorted	mapping from overall det index to unique det (ciConfigList) index

Definition at line 36 of file MultiDiracDeterminant.cpp.

References qmcplusplus::app_log(), MultiDiracDeterminant::ciConfigList, MultiDiracDeterminant::detData, MultiDiracDeterminant::DetSigns, MultiDiracDeterminant::ndets_per_excitation_level_, MultiDiracDeterminant::NumPtcls, MultiDiracDeterminant::refdet_occup, MultiDiracDeterminant::resize(), qmcplusplus::Units::second, sign(), MultiDiracDeterminant::transferH2D_timer, and MultiDiracDeterminant::uniquePairs.

 {
   auto& ref                        = configlist_unsorted[ref_det_id];
   auto& configlist_sorted          = *ciConfigList;
   auto& data                       = *detData;
   auto& pairs                      = *uniquePairs;
   auto& sign                       = *DetSigns;
   auto& ndets_per_excitation_level = *ndets_per_excitation_level_;
 
   const size_t nci = configlist_unsorted.size();
   std::vector<std::pair<int, int>> pairs_local;
 
   size_t nex_max = 0;
   std::vector<size_t> pos(NumPtcls);
   std::vector<size_t> ocp(NumPtcls);
   std::vector<size_t> uno(NumPtcls);
   // map key is exc. lvl
   std::map<int, std::vector<int>> dataMap;
   std::map<int, std::vector<int>> sortMap;
   std::vector<RealType> tmp_sign(nci, 0);
   for (size_t i = 0; i < nci; i++)
   {
     size_t nex;
     tmp_sign[i] = ref.calculateExcitations(configlist_unsorted[i], nex, pos, ocp, uno);
     nex_max     = std::max(nex, nex_max);
     dataMap[nex].push_back(nex);
     sortMap[nex].push_back(i);
     for (int k = 0; k < nex; k++)
       dataMap[nex].push_back(pos[k]);
     for (int k = 0; k < nex; k++)
       dataMap[nex].push_back(uno[k]);
     for (int k = 0; k < nex; k++)
       dataMap[nex].push_back(ocp[k]);
     // determine unique pairs, to avoid redundant calculation of matrix elements
     // if storing the entire MOxMO matrix is too much, then make an array and a mapping to it.
     // is there an easier way??
     for (int k1 = 0; k1 < nex; k1++)
       for (int k2 = 0; k2 < nex; k2++)
       {
         //           std::pair<int,int> temp(ocp[k1],uno[k2]);
         std::pair<int, int> temp(pos[k1], uno[k2]);
         if (find(pairs_local.begin(), pairs_local.end(), temp) == pairs_local.end()) //pair is new
           pairs_local.push_back(temp);
       }
   }
   pairs.resize(pairs_local.size());
   int* first  = pairs.data(0);
   int* second = pairs.data(1);
 
   for (size_t i = 0; i < pairs_local.size(); i++)
   {
     first[i]  = pairs_local[i].first;
     second[i] = pairs_local[i].second;
   }
 
 
   app_log() << "Number of terms in pairs array: " << pairs.size() << std::endl;
   ndets_per_excitation_level.resize(nex_max + 1, 0);
   //reorder configs and det data
   std::vector<size_t> det_idx_order;           // old indices in new order
   std::vector<size_t> det_idx_reverse(nci, 0); // new indices in old order
 
   // populate data, ordered by exc. lvl.
   // make mapping from new to old det idx
   std::vector<int> data_local;
   data_local.clear();
   data.clear();
 
   for (const auto& [nex, det_idx_old] : sortMap)
   {
     data_local.insert(data_local.end(), dataMap[nex].begin(), dataMap[nex].end());
     det_idx_order.insert(det_idx_order.end(), det_idx_old.begin(), det_idx_old.end());
     ndets_per_excitation_level[nex] = det_idx_old.size();
   }
   data.resize(data_local.size());
   for (size_t i = 0; i < data_local.size(); i++)
     data[i] = data_local[i];
 
   assert(det_idx_order.size() == nci);
 
   // make reverse mapping (old to new) and reorder confgList by exc. lvl.
   configlist_sorted.resize(nci);
   sign.resize(nci);
   for (size_t i = 0; i < nci; i++)
   {
     det_idx_reverse[det_idx_order[i]] = i;
     configlist_sorted[i]              = configlist_unsorted[det_idx_order[i]];
     sign[i]                           = tmp_sign[det_idx_order[i]];
   }
 
   auto& refdet_occup_ref(*refdet_occup);
   refdet_occup_ref.resize(NumPtcls);
   for (size_t i = 0; i < NumPtcls; i++)
     refdet_occup_ref[i] = configlist_unsorted[ref_det_id].occup[i];
 
   {
     ScopedTimer local_timer(transferH2D_timer);
     sign.updateTo();
     pairs.updateTo();
     data.updateTo();
     refdet_occup_ref.updateTo();
   }
   // update C2nodes for new det ordering
   C2nodes_sorted.resize(C2nodes_unsorted.size());
   for (int i = 0; i < C2nodes_unsorted.size(); i++)
     C2nodes_sorted[i] = det_idx_reverse[C2nodes_unsorted[i]];
 
   /*
        std::cout <<"ref: " <<ref << std::endl;
        std::cout <<"list: " << std::endl;
        for(int i=0; i<confgList.size(); i++)
          std::cout <<confgList[i] << std::endl;
 
        std::cout <<"pairs: " << std::endl;
        for(int i=0; i<pairs.size(); i++)
          std::cout <<pairs[i].first <<"   " <<pairs[i].second << std::endl;
   */
 
   // make sure internal objects depending on the number of unique determinants are resized
   resize();
 }

◆ createResource()

void createResource ( ResourceCollection & collection ) const

overridevirtual

initialize a shared resource and hand it to a collection

Reimplemented from WaveFunctionComponent.

Definition at line 650 of file MultiDiracDeterminant.cpp.

References ResourceCollection::addResource().

 {
   collection.addResource(std::make_unique<MultiDiracDetMultiWalkerResource>());
 }

◆ evalGrad()

GradType evalGrad	(	ParticleSet &	P,
		int	iat
	)

inlineoverridevirtual

return the current gradient for the iat-th particle

Parameters

P	quantum particle set
iat	particle index

Returns: the gradient of the iat-th particle

Reimplemented from WaveFunctionComponent.

Definition at line 231 of file MultiDiracDeterminant.h.

References APP_ABORT.

   {
     APP_ABORT("  MultiDiracDeterminant: This should not be called. \n");
     return GradType();
   }

◆ evaluate()

ValueType evaluate	(	const ParticleSet &	P,
		ParticleSet::ParticleGradient &	G,
		ParticleSet::ParticleLaplacian &	L
	)

inline

Definition at line 251 of file MultiDiracDeterminant.h.

References APP_ABORT.

   {
     APP_ABORT("  MultiDiracDeterminant: This should not be called. \n");
     return ValueType();
   }

◆ evaluateDerivatives() [1/2]

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

inlineoverride

Definition at line 168 of file MultiDiracDeterminant.h.

172 {}

◆ evaluateDerivatives() [2/2]

void evaluateDerivatives	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		Vector< ValueType > &	dlogpsi,
		Vector< ValueType > &	dhpsioverpsi,
		const MultiDiracDeterminant &	pseudo_dn,
		const ValueType &	psiCurrent,
		const std::vector< ValueType > &	Coeff,
		const std::vector< size_t > &	C2node_up,
		const std::vector< size_t > &	C2node_dn
	)

Definition at line 865 of file MultiDiracDeterminant.cpp.

 {
   if (!isOptimizable())
     return;
 
   const OffloadVector<ValueType>& detValues_up = getRatiosToRefDet();
   const OffloadVector<ValueType>& detValues_dn = pseudo_dn.getRatiosToRefDet();
   const Matrix<GradType>& grads_up             = grads;
   const Matrix<GradType>& grads_dn             = pseudo_dn.grads;
   const Matrix<ValueType>& lapls_up            = lapls;
   const Matrix<ValueType>& lapls_dn            = pseudo_dn.lapls;
   const OffloadMatrix<ValueType>& M_up         = psiM;
   const OffloadMatrix<ValueType>& M_dn         = pseudo_dn.psiM;
   const OffloadMatrix<ValueType>& Minv_up      = psiMinv;
   const OffloadMatrix<ValueType>& Minv_dn      = pseudo_dn.psiMinv;
   const OffloadMatrix<GradType>& B_grad        = dpsiM;
   const OffloadMatrix<ValueType>& B_lapl       = d2psiM;
   std::vector<int> detData_local(detData->size());
   for (size_t i = 0; i < detData->size(); i++)
     detData_local[i] = (*detData)[i];
 
 
   const size_t N1  = FirstIndex;
   const size_t N2  = pseudo_dn.FirstIndex;
   const size_t NP1 = NumPtcls;
   const size_t NP2 = pseudo_dn.NumPtcls;
   Vector<ValueType> detValues_up_host_view(const_cast<ValueType*>(detValues_up.data()), detValues_up.size());
   Vector<ValueType> detValues_dn_host_view(const_cast<ValueType*>(detValues_dn.data()), detValues_dn.size());
   Matrix<ValueType> M_up_host_view(const_cast<ValueType*>(M_up.data()), M_up.rows(), M_up.cols());
   Matrix<ValueType> M_dn_host_view(const_cast<ValueType*>(M_dn.data()), M_dn.rows(), M_dn.cols());
   Matrix<ValueType> Minv_up_host_view(const_cast<ValueType*>(Minv_up.data()), Minv_up.rows(), Minv_up.cols());
   Matrix<ValueType> Minv_dn_host_view(const_cast<ValueType*>(Minv_dn.data()), Minv_dn.rows(), Minv_dn.cols());
   Matrix<GradType> B_grad_host_view(const_cast<GradType*>(B_grad.data()), B_grad.rows(), B_grad.cols());
   Matrix<ValueType> B_lapl_host_view(const_cast<ValueType*>(B_lapl.data()), B_lapl.rows(), B_lapl.cols());
   Phi->evaluateDerivatives(P, optvars, dlogpsi, dhpsioverpsi, psiCurrent, Coeff, C2node_up, C2node_dn,
                            detValues_up_host_view, detValues_dn_host_view, grads_up, grads_dn, lapls_up, lapls_dn,
                            M_up_host_view, M_dn_host_view, Minv_up_host_view, Minv_dn_host_view, B_grad_host_view,
                            B_lapl_host_view, detData_local, N1, N2, NP1, NP2, lookup_tbl);
 }

◆ evaluateDerivativesWF()

void evaluateDerivativesWF	(	ParticleSet &	P,
		const opt_variables_type &	optvars,
		Vector< ValueType > &	dlogpsi,
		const MultiDiracDeterminant &	pseudo_dn,
		const PsiValue &	psiCurrent,
		const std::vector< ValueType > &	Coeff,
		const std::vector< size_t > &	C2node_up,
		const std::vector< size_t > &	C2node_dn
	)

Definition at line 914 of file MultiDiracDeterminant.cpp.

References Matrix< T, Alloc >::cols(), Matrix< T, Alloc >::data(), Vector< T, Alloc >::data(), MultiDiracDeterminant::detData, MultiDiracDeterminant::getRatiosToRefDet(), MultiDiracDeterminant::isOptimizable(), MultiDiracDeterminant::lookup_tbl, MultiDiracDeterminant::Phi, MultiDiracDeterminant::psiM, MultiDiracDeterminant::psiMinv, Matrix< T, Alloc >::rows(), and Vector< T, Alloc >::size().

 {
   if (!isOptimizable())
     return;
 
   const OffloadVector<ValueType>& detValues_up = getRatiosToRefDet();
   const OffloadVector<ValueType>& detValues_dn = pseudo_dn.getRatiosToRefDet();
   const OffloadMatrix<ValueType>& M_up         = psiM;
   const OffloadMatrix<ValueType>& M_dn         = pseudo_dn.psiM;
   const OffloadMatrix<ValueType>& Minv_up      = psiMinv;
   const OffloadMatrix<ValueType>& Minv_dn      = pseudo_dn.psiMinv;
 
   std::vector<int> detData_local(detData->size());
   for (size_t i = 0; i < detData->size(); i++)
     detData_local[i] = (*detData)[i];
   Vector<ValueType> detValues_up_host_view(const_cast<ValueType*>(detValues_up.data()), detValues_up.size());
   Vector<ValueType> detValues_dn_host_view(const_cast<ValueType*>(detValues_dn.data()), detValues_dn.size());
   Matrix<ValueType> M_up_host_view(const_cast<ValueType*>(M_up.data()), M_up.rows(), M_up.cols());
   Matrix<ValueType> M_dn_host_view(const_cast<ValueType*>(M_dn.data()), M_dn.rows(), M_dn.cols());
   Matrix<ValueType> Minv_up_host_view(const_cast<ValueType*>(Minv_up.data()), Minv_up.rows(), Minv_up.cols());
   Matrix<ValueType> Minv_dn_host_view(const_cast<ValueType*>(Minv_dn.data()), Minv_dn.rows(), Minv_dn.cols());
   Phi->evaluateDerivativesWF(P, optvars, dlogpsi, psiCurrent, Coeff, C2node_up, C2node_dn, detValues_up_host_view,
                              detValues_dn_host_view, M_up_host_view, M_dn_host_view, Minv_up_host_view,
                              Minv_dn_host_view, detData_local, lookup_tbl);
 }

◆ evaluateDetsAndGradsForPtclMove()

void evaluateDetsAndGradsForPtclMove	(	const ParticleSet &	P,
		int	iat
	)

evaluate the value and gradients of all the unique determinants with one electron moved. Used by the table method

Definition at line 530 of file MultiDiracDeterminant.2.cpp.

 {
   ScopedTimer local_timer(evaluateDetsAndGradsForPtclMove_timer);
   UpdateMode = ORB_PBYP_PARTIAL;
   {
     ScopedTimer local_timer(evalOrbVGL_timer);
     // Using Host Views for Phi-evaluateVGL since not ported to GPU
     Vector<ValueType> psiV_host_view(psiV.data(), psiV.size());
     Vector<GradType> dpsiV_host_view(dpsiV.data(), dpsiV.size());
     Vector<ValueType> d2psiV_host_view(d2psiV.data(), d2psiV.size());
     Phi->evaluateVGL(P, iat, psiV_host_view, dpsiV_host_view, d2psiV_host_view);
   }
   const int WorkingIndex = iat - FirstIndex;
   const auto& confgList  = *ciConfigList;
   assert(WorkingIndex >= 0 && WorkingIndex < LastIndex - FirstIndex);
 
   GradType ratioGradRef;
   {
     ScopedTimer inverse(updateInverse_timer);
     //mmorales: check comment above
     psiMinv_temp = psiMinv;
     //std::vector<int>::iterator it(confgList[ReferenceDeterminant].occup.begin());
     auto it(confgList[ReferenceDeterminant].occup.begin());
     for (size_t i = 0; i < NumPtcls; i++)
     {
       psiV_temp[i] = psiV[*it];
       ratioGradRef += psiMinv_temp(i, WorkingIndex) * dpsiV[*it];
       it++;
     }
     curRatio = DetRatioByColumn(psiMinv_temp, psiV_temp, WorkingIndex);
     InverseUpdateByColumn(psiMinv_temp, psiV_temp, workV1, workV2, WorkingIndex, curRatio);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = psiV[i];
   }
   buildTableMatrix_calculateRatios(ReferenceDeterminant, psiMinv_temp, TpsiM, *detData, *uniquePairs, *DetSigns,
                                    table_matrix, new_ratios_to_ref_);
   for (size_t idim = 0; idim < OHMMS_DIM; idim++)
   {
     {
       ScopedTimer inverse(updateInverse_timer);
       //dpsiMinv = psiMinv_temp;
       dpsiMinv = psiMinv;
       auto it(confgList[ReferenceDeterminant].occup.begin());
       for (size_t i = 0; i < NumPtcls; i++)
         psiV_temp[i] = dpsiV[*(it++)][idim];
       InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, WorkingIndex, ratioGradRef[idim]);
       for (size_t i = 0; i < NumOrbitals; i++)
         TpsiM(i, WorkingIndex) = dpsiV[i][idim];
     }
     buildTableMatrix_calculateGradRatios(ReferenceDeterminant, dpsiMinv, TpsiM, *detData, *uniquePairs, *DetSigns,
                                          ratioGradRef[idim] / curRatio, table_matrix, idim, WorkingIndex, new_grads);
   }
   // check comment above
   for (int i = 0; i < NumOrbitals; i++)
     TpsiM(i, WorkingIndex) = psiM(WorkingIndex, i);
 }

◆ evaluateDetsAndGradsForPtclMoveWithSpin()

void evaluateDetsAndGradsForPtclMoveWithSpin	(	const ParticleSet &	P,
		int	iat
	)

evaluate the value and gradients of all the unique determinants with one electron moved. Used by the table method. Includes Spin Gradient data

Definition at line 587 of file MultiDiracDeterminant.2.cpp.

 {
   assert(P.isSpinor() == is_spinor_);
   ScopedTimer local_timer(evaluateDetsAndGradsForPtclMove_timer);
   UpdateMode = ORB_PBYP_PARTIAL;
   {
     ScopedTimer orb_timer(evalOrbVGL_timer);
     // Creating Host view to call Phi->evaluateVGL
     Vector<ValueType> psiV_host_view(psiV.data(), psiV.size());
     Vector<GradType> dpsiV_host_view(dpsiV.data(), dpsiV.size());
     Vector<ValueType> d2psiV_host_view(d2psiV.data(), d2psiV.size());
     Phi->evaluateVGL_spin(P, iat, psiV_host_view, dpsiV_host_view, d2psiV_host_view, dspin_psiV);
   }
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0 && WorkingIndex < LastIndex - FirstIndex);
   const auto& confgList = *ciConfigList;
   GradType ratioGradRef;
   ValueType ratioSpinGradRef = 0.0;
   {
     ScopedTimer inverse(updateInverse_timer);
     //mmorales: check comment above
     psiMinv_temp = psiMinv;
     //std::vector<int>::iterator it(confgList[ReferenceDeterminant].occup.begin());
     auto it(confgList[ReferenceDeterminant].occup.begin());
     for (size_t i = 0; i < NumPtcls; i++)
     {
       psiV_temp[i] = psiV[*it];
       ratioGradRef += psiMinv_temp(i, WorkingIndex) * dpsiV[*it];
       ratioSpinGradRef += psiMinv_temp(i, WorkingIndex) * dspin_psiV[*it];
       it++;
     }
     curRatio                                          = DetRatioByColumn(psiMinv_temp, psiV_temp, WorkingIndex);
     new_spingrads(ReferenceDeterminant, WorkingIndex) = ratioSpinGradRef / curRatio;
     InverseUpdateByColumn(psiMinv_temp, psiV_temp, workV1, workV2, WorkingIndex, curRatio);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = psiV[i];
   }
   buildTableMatrix_calculateRatios(ReferenceDeterminant, psiMinv_temp, TpsiM, *detData, *uniquePairs, *DetSigns,
                                    table_matrix, new_ratios_to_ref_);
   for (size_t idim = 0; idim < OHMMS_DIM; idim++)
   {
     {
       ScopedTimer inverse(updateInverse_timer);
       //dpsiMinv = psiMinv_temp;
       dpsiMinv = psiMinv;
       auto it(confgList[ReferenceDeterminant].occup.begin());
       for (size_t i = 0; i < NumPtcls; i++)
         psiV_temp[i] = dpsiV[*(it++)][idim];
       InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, WorkingIndex, ratioGradRef[idim]);
       for (size_t i = 0; i < NumOrbitals; i++)
         TpsiM(i, WorkingIndex) = dpsiV[i][idim];
     }
     buildTableMatrix_calculateGradRatios(ReferenceDeterminant, dpsiMinv, TpsiM, *detData, *uniquePairs, *DetSigns,
                                          ratioGradRef[idim] / curRatio, table_matrix, idim, WorkingIndex, new_grads);
   }
 
   //Now compute the spin gradient, same procedure as normal gradient components above
   {
     ScopedTimer inverse(updateInverse_timer);
     dpsiMinv = psiMinv;
     auto it(confgList[ReferenceDeterminant].occup.begin());
     for (size_t i = 0; i < NumPtcls; i++)
       psiV_temp[i] = dspin_psiV[*(it++)];
     InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, WorkingIndex, ratioSpinGradRef);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = dspin_psiV[i];
   }
   buildTableMatrix_calculateRatiosValueMatrixOneParticle(ReferenceDeterminant, dpsiMinv, TpsiM, *detData, *uniquePairs,
                                                          *DetSigns, table_matrix, WorkingIndex, new_spingrads);
 
   // check comment above
   for (int i = 0; i < NumOrbitals; i++)
     TpsiM(i, WorkingIndex) = psiM(WorkingIndex, i);
 }

◆ evaluateDetsForPtclMove()

void evaluateDetsForPtclMove	(	const ParticleSet &	P,
		int	iat,
		int	refPtcl = `-1`
	)

evaluate the value of all the unique determinants with one electron moved.

Used by the table method

Parameters

P	particle set which provides the positions
iat	the index of the moved electron
refPtcl	if given, the id of the reference particle in virtual moves

Definition at line 492 of file MultiDiracDeterminant.2.cpp.

 {
   ScopedTimer local_timer(evaluateDetsForPtclMove_timer);
 
   UpdateMode = ORB_PBYP_RATIO;
   {
     ScopedTimer orb_timer(evalOrbValue_timer);
     Vector<ValueType> psiV_host_view(psiV.data(), psiV.size());
     Phi->evaluateValue(P, iat, psiV_host_view);
   }
   const int WorkingIndex = (refPtcl < 0 ? iat : refPtcl) - FirstIndex;
   assert(WorkingIndex >= 0 && WorkingIndex < LastIndex - FirstIndex);
   const auto& confgList = *ciConfigList;
   //std::vector<int>::iterator it(confgList[ReferenceDeterminant].occup.begin());
   auto it(confgList[ReferenceDeterminant].occup.begin());
   // mmorales: the only reason this is here is because
   // NonlocalECP do not necessarily call rejectMove after
   // calling ratio(), and even if the move is rejected
   // this matrix needs to be restored
   // If we always restore after ratio, then this is not needed
   // For efficiency reasons, I don't do this for ratioGrad or ratio(P,dG,dL)
   {
     ScopedTimer inverse(updateInverse_timer);
     psiMinv_temp = psiMinv;
     for (size_t i = 0; i < NumPtcls; i++)
       psiV_temp[i] = psiV[*(it++)];
     curRatio = DetRatioByColumn(psiMinv_temp, psiV_temp, WorkingIndex);
     InverseUpdateByColumn(psiMinv_temp, psiV_temp, workV1, workV2, WorkingIndex, curRatio);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = psiV[i];
   }
   buildTableMatrix_calculateRatios(ReferenceDeterminant, psiMinv_temp, TpsiM, *detData, *uniquePairs, *DetSigns,
                                    table_matrix, new_ratios_to_ref_);
   // check comment above
   for (size_t i = 0; i < NumOrbitals; i++)
     TpsiM(i, WorkingIndex) = psiM(WorkingIndex, i);
 }

◆ evaluateForWalkerMove()

void evaluateForWalkerMove	(	const ParticleSet &	P,
		bool	fromScratch = `true`
	)

Force host view as no implementation of evaluate_notranspose

Pinning ratios_to_ref_ to the device.

Definition at line 161 of file MultiDiracDeterminant.cpp.

Referenced by MultiDiracDeterminant::updateBuffer().

 {
   ScopedTimer local_timer(evalWalker_timer);
   if (fromScratch)
   {
     ///Force host view as no implementation of evaluate_notranspose
     Matrix<ValueType> psiM_host_view(psiM.data(), psiM.rows(), psiM.cols());
     Matrix<GradType> dpsiM_host_view(dpsiM.data(), dpsiM.rows(), dpsiM.cols());
     Matrix<ValueType> d2psiM_host_view(d2psiM.data(), d2psiM.rows(), d2psiM.cols());
     Phi->evaluate_notranspose(P, FirstIndex, LastIndex, psiM_host_view, dpsiM_host_view, d2psiM_host_view);
     {
       ScopedTimer local_timer(transferH2D_timer);
       psiM.updateTo();
       dpsiM.updateTo();
       //d2psiM.updateTo();
     }
   }
 
 
   const auto& confgList = *ciConfigList;
 
   {
     ScopedTimer local_timer(inverse_timer);
     auto it(confgList[ReferenceDeterminant].occup.begin());
     for (size_t i = 0; i < NumPtcls; i++)
     {
       for (size_t j = 0; j < NumPtcls; j++)
         psiMinv(j, i) = psiM(j, *it);
       it++;
     }
 
     for (size_t i = 0; i < NumPtcls; i++)
       for (size_t j = 0; j < NumOrbitals; j++)
         TpsiM(j, i) = psiM(i, j);
 
     std::complex<RealType> logValueRef;
     InvertWithLog(psiMinv.data(), NumPtcls, NumPtcls, WorkSpace.data(), Pivot.data(), logValueRef);
     log_value_ref_det_ = logValueRef;
   }
 
   const RealType detsign = (*DetSigns)[ReferenceDeterminant];
   buildTableMatrix_calculateRatios(ReferenceDeterminant, psiMinv, TpsiM, *detData, *uniquePairs, *DetSigns,
                                    table_matrix, ratios_to_ref_);
   ///Pinning ratios_to_ref_ to the device.
 
 
   for (size_t iat = 0; iat < NumPtcls; iat++)
   {
     auto it(confgList[ReferenceDeterminant].occup.begin());
     GradType gradRatio;
     ValueType ratioLapl = 0.0;
     for (size_t i = 0; i < NumPtcls; i++)
     {
       gradRatio += psiMinv(i, iat) * dpsiM(iat, *it);
       ratioLapl += psiMinv(i, iat) * d2psiM(iat, *it);
       it++;
     }
     lapls(ReferenceDeterminant, iat) = ratioLapl;
     for (size_t idim = 0; idim < OHMMS_DIM; idim++)
     {
       dpsiMinv = psiMinv;
       it       = confgList[ReferenceDeterminant].occup.begin();
       for (size_t i = 0; i < NumPtcls; i++)
         psiV_temp[i] = dpsiM(iat, *(it++))[idim];
       InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, iat, gradRatio[idim]);
       for (size_t i = 0; i < NumOrbitals; i++)
         TpsiM(i, iat) = dpsiM(iat, i)[idim];
       buildTableMatrix_calculateGradRatios(ReferenceDeterminant, dpsiMinv, TpsiM, *detData, *uniquePairs, *DetSigns,
                                            gradRatio[idim], table_matrix, idim, iat, grads);
     }
     dpsiMinv = psiMinv;
     it       = confgList[ReferenceDeterminant].occup.begin();
     for (size_t i = 0; i < NumPtcls; i++)
       psiV_temp[i] = d2psiM(iat, *(it++));
     InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, iat, ratioLapl);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, iat) = d2psiM(iat, i);
     buildTableMatrix_calculateRatiosValueMatrixOneParticle(ReferenceDeterminant, dpsiMinv, TpsiM, *detData,
                                                            *uniquePairs, *DetSigns, table_matrix, iat, lapls);
     // restore matrix
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, iat) = psiM(iat, i);
   }
 
   {
     ScopedTimer local_timer(transferH2D_timer);
     ratios_to_ref_.updateTo();
     psiMinv.updateTo();
     TpsiM.updateTo();
   }
 
   psiMinv_temp = psiMinv;
 }

◆ evaluateForWalkerMoveWithSpin()

void evaluateForWalkerMoveWithSpin	(	const ParticleSet &	P,
		bool	fromScratch = `true`
	)

Force host view as no implementation of evaluate_notranspose

Stop inverse_timerScop

Definition at line 255 of file MultiDiracDeterminant.cpp.

Referenced by MultiDiracDeterminant::updateBuffer().

 {
   ScopedTimer local_timer(evalWalker_timer);
   if (fromScratch)
   {
     ///Force host view as no implementation of evaluate_notranspose
     Matrix<ValueType> psiM_host_view(psiM.data(), psiM.rows(), psiM.cols());
     Matrix<GradType> dpsiM_host_view(dpsiM.data(), dpsiM.rows(), dpsiM.cols());
     Matrix<ValueType> d2psiM_host_view(d2psiM.data(), d2psiM.rows(), d2psiM.cols());
     Phi->evaluate_notranspose_spin(P, FirstIndex, LastIndex, psiM_host_view, dpsiM_host_view, d2psiM_host_view,
                                    dspin_psiM);
     {
       ScopedTimer local_timer(transferH2D_timer);
       psiM.updateTo();
       dpsiM.updateTo();
     }
   }
 
 
   const auto& confgList = *ciConfigList;
   std::complex<RealType> logValueRef;
 
   {
     ScopedTimer local_timer(inverse_timer);
     auto it(confgList[ReferenceDeterminant].occup.begin());
     for (size_t i = 0; i < NumPtcls; i++)
     {
       for (size_t j = 0; j < NumPtcls; j++)
         psiMinv(j, i) = psiM(j, *it);
       it++;
     }
     for (size_t i = 0; i < NumPtcls; i++)
     {
       for (size_t j = 0; j < NumOrbitals; j++)
         TpsiM(j, i) = psiM(i, j);
     }
     InvertWithLog(psiMinv.data(), NumPtcls, NumPtcls, WorkSpace.data(), Pivot.data(), logValueRef);
     log_value_ref_det_ = logValueRef;
   } ///Stop inverse_timerScop
   const RealType detsign = (*DetSigns)[ReferenceDeterminant];
   buildTableMatrix_calculateRatios(ReferenceDeterminant, psiMinv, TpsiM, *detData, *uniquePairs, *DetSigns,
                                    table_matrix, ratios_to_ref_);
 
   for (size_t iat = 0; iat < NumPtcls; iat++)
   {
     auto it(confgList[ReferenceDeterminant].occup.begin());
     GradType gradRatio;
     ValueType ratioLapl     = 0.0;
     ValueType spingradRatio = 0.0;
     for (size_t i = 0; i < NumPtcls; i++)
     {
       gradRatio += psiMinv(i, iat) * dpsiM(iat, *it);
       ratioLapl += psiMinv(i, iat) * d2psiM(iat, *it);
       spingradRatio += psiMinv(i, iat) * dspin_psiM(iat, *it);
       it++;
     }
     lapls(ReferenceDeterminant, iat)     = ratioLapl;
     spingrads(ReferenceDeterminant, iat) = spingradRatio;
     for (size_t idim = 0; idim < OHMMS_DIM; idim++)
     {
       dpsiMinv = psiMinv;
       it       = confgList[ReferenceDeterminant].occup.begin();
       for (size_t i = 0; i < NumPtcls; i++)
         psiV_temp[i] = dpsiM(iat, *(it++))[idim];
       InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, iat, gradRatio[idim]);
       for (size_t i = 0; i < NumOrbitals; i++)
         TpsiM(i, iat) = dpsiM(iat, i)[idim];
       buildTableMatrix_calculateGradRatios(ReferenceDeterminant, dpsiMinv, TpsiM, *detData, *uniquePairs, *DetSigns,
                                            gradRatio[idim], table_matrix, idim, iat, grads);
     }
     dpsiMinv = psiMinv;
     it       = confgList[ReferenceDeterminant].occup.begin();
     for (size_t i = 0; i < NumPtcls; i++)
       psiV_temp[i] = d2psiM(iat, *(it++));
     InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, iat, ratioLapl);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, iat) = d2psiM(iat, i);
     buildTableMatrix_calculateRatiosValueMatrixOneParticle(ReferenceDeterminant, dpsiMinv, TpsiM, *detData,
                                                            *uniquePairs, *DetSigns, table_matrix, iat, lapls);
 
     //Adding the spin gradient
     dpsiMinv = psiMinv;
     it       = confgList[ReferenceDeterminant].occup.begin();
     for (size_t i = 0; i < NumPtcls; i++)
       psiV_temp[i] = dspin_psiM(iat, *(it++));
     InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, iat, spingradRatio);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, iat) = dspin_psiM(iat, i);
     buildTableMatrix_calculateRatiosValueMatrixOneParticle(ReferenceDeterminant, dpsiMinv, TpsiM, *detData,
                                                            *uniquePairs, *DetSigns, table_matrix, iat, spingrads);
 
     // restore matrix
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, iat) = psiM(iat, i);
   }
 
   {
     ScopedTimer local_timer(transferH2D_timer);
     ratios_to_ref_.updateTo();
     psiMinv.updateTo();
     TpsiM.updateTo();
   }
   psiMinv_temp = psiMinv;
 }

◆ evaluateGrads()

void evaluateGrads	(	ParticleSet &	P,
		int	iat
	)

evaluate the gradients of all the unique determinants with one electron moved. Used by the table method

Definition at line 894 of file MultiDiracDeterminant.2.cpp.

 {
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0 && WorkingIndex < LastIndex - FirstIndex);
 
   const auto& confgList = *ciConfigList;
   for (size_t idim = 0; idim < OHMMS_DIM; idim++)
   {
     //dpsiMinv = psiMinv_temp;
     dpsiMinv         = psiMinv;
     auto it          = confgList[ReferenceDeterminant].occup.begin();
     ValueType ratioG = 0.0;
     for (size_t i = 0; i < NumPtcls; i++)
     {
       psiV_temp[i] = dpsiM(WorkingIndex, *it)[idim];
       ratioG += psiMinv(i, WorkingIndex) * dpsiM(WorkingIndex, *it)[idim];
       it++;
     }
     InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, WorkingIndex, ratioG);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = dpsiM(WorkingIndex, i)[idim];
     buildTableMatrix_calculateGradRatios(ReferenceDeterminant, dpsiMinv, TpsiM, *detData, *uniquePairs, *DetSigns,
                                          ratioG, table_matrix, idim, WorkingIndex, grads);
   }
   // check comment above
   for (size_t i = 0; i < NumOrbitals; i++)
     TpsiM(i, WorkingIndex) = psiM(WorkingIndex, i);
 }

◆ evaluateGradsWithSpin()

void evaluateGradsWithSpin	(	ParticleSet &	P,
		int	iat
	)

evaluate the gradients of all the unique determinants with one electron moved. Used by the table method. Includes Spin Gradient data

Definition at line 923 of file MultiDiracDeterminant.2.cpp.

 {
   assert(P.isSpinor() == is_spinor_);
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0 && WorkingIndex < LastIndex - FirstIndex);
 
   const auto& confgList = *ciConfigList;
   for (size_t idim = 0; idim < OHMMS_DIM; idim++)
   {
     //dpsiMinv = psiMinv_temp;
     dpsiMinv         = psiMinv;
     auto it          = confgList[ReferenceDeterminant].occup.begin();
     ValueType ratioG = 0.0;
     for (size_t i = 0; i < NumPtcls; i++)
     {
       psiV_temp[i] = dpsiM(WorkingIndex, *it)[idim];
       ratioG += psiMinv(i, WorkingIndex) * dpsiM(WorkingIndex, *it)[idim];
       it++;
     }
     InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, WorkingIndex, ratioG);
     for (size_t i = 0; i < NumOrbitals; i++)
       TpsiM(i, WorkingIndex) = dpsiM(WorkingIndex, i)[idim];
     buildTableMatrix_calculateGradRatios(ReferenceDeterminant, dpsiMinv, TpsiM, *detData, *uniquePairs, *DetSigns,
                                          ratioG, table_matrix, idim, WorkingIndex, grads);
   }
 
   //Now compute the spin gradient, same procedure as normal gradient components above
   dpsiMinv          = psiMinv;
   auto it           = confgList[ReferenceDeterminant].occup.begin();
   ValueType ratioSG = 0.0;
   for (size_t i = 0; i < NumPtcls; i++)
   {
     psiV_temp[i] = dspin_psiM(WorkingIndex, *it);
     ratioSG += psiMinv(i, WorkingIndex) * dspin_psiM(WorkingIndex, *it);
     it++;
   }
   spingrads(ReferenceDeterminant, WorkingIndex) = ratioSG;
   InverseUpdateByColumn(dpsiMinv, psiV_temp, workV1, workV2, WorkingIndex, ratioSG);
   for (size_t i = 0; i < NumOrbitals; i++)
     TpsiM(i, WorkingIndex) = dspin_psiM(WorkingIndex, i);
   buildTableMatrix_calculateRatiosValueMatrixOneParticle(ReferenceDeterminant, dpsiMinv, TpsiM, *detData, *uniquePairs,
                                                          *DetSigns, table_matrix, WorkingIndex, spingrads);
 
   // check comment above
   for (size_t i = 0; i < NumOrbitals; i++)
     TpsiM(i, WorkingIndex) = psiM(WorkingIndex, i);
 }

◆ evaluateLog()

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

inlineoverridevirtual

evaluate the value of the WaveFunctionComponent from scratch

Parameters

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

Returns: the log value

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

Implements WaveFunctionComponent.

Definition at line 243 of file MultiDiracDeterminant.h.

References APP_ABORT.

   {
     APP_ABORT("  MultiDiracDeterminant: This should not be called. \n");
     return 0.0;
   }

◆ extractOptimizableObjectRefs()

void extractOptimizableObjectRefs ( UniqueOptObjRefs & opt_obj_refs )

inlinefinalvirtual

extract underlying OptimizableObject references

Parameters

opt_obj_refs aggregated list of optimizable object references

Reimplemented from WaveFunctionComponent.

Definition at line 152 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::Phi.

   {
     Phi->extractOptimizableObjectRefs(opt_obj_refs);
   }

◆ getClassName()

std::string getClassName ( ) const

inlineoverridevirtual

return class name

Implements WaveFunctionComponent.

Definition at line 147 of file MultiDiracDeterminant.h.

147 { return "MultiDiracDeterminant"; }

◆ getFirstIndex()

int getFirstIndex ( ) const

inline

Definition at line 316 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::FirstIndex.

316 { return FirstIndex; }

qmcplusplus::MultiDiracDeterminant::FirstIndex

const int FirstIndex

index of the first particle with respect to the particle set

Definition: MultiDiracDeterminant.h:520

◆ getGrads()

const Matrix<GradType>& getGrads ( ) const

inline

Definition at line 320 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::grads.

320 { return grads; }

qmcplusplus::MultiDiracDeterminant::grads

Matrix< GradType > grads

store determinant grads (old and new)

Definition: MultiDiracDeterminant.h:578

◆ getLapls()

const Matrix<ValueType>& getLapls ( ) const

inline

Definition at line 322 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::lapls.

322 { return lapls; }

qmcplusplus::MultiDiracDeterminant::lapls

Matrix< ValueType > lapls

store determinant lapls (old and new)

Definition: MultiDiracDeterminant.h:580

◆ getLogValueRefDet()

LogValue getLogValueRefDet ( ) const

inline

Definition at line 328 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::log_value_ref_det_.

328 { return log_value_ref_det_; }

qmcplusplus::MultiDiracDeterminant::log_value_ref_det_

LogValue log_value_ref_det_

log value of the reference determinant

Definition: MultiDiracDeterminant.h:576

◆ getNewGrads()

const Matrix<GradType>& getNewGrads ( ) const

inline

Definition at line 321 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::new_grads.

321 { return new_grads; }

qmcplusplus::MultiDiracDeterminant::new_grads

Matrix< GradType > new_grads

Definition: MultiDiracDeterminant.h:578

◆ getNewLapls()

const Matrix<ValueType>& getNewLapls ( ) const

inline

Definition at line 323 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::new_lapls.

323 { return new_lapls; }

qmcplusplus::MultiDiracDeterminant::new_lapls

Matrix< ValueType > new_lapls

Definition: MultiDiracDeterminant.h:580

◆ getNewRatiosToRefDet()

const OffloadVector<ValueType>& getNewRatiosToRefDet ( ) const

inline

Definition at line 319 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::new_ratios_to_ref_.

319 { return new_ratios_to_ref_; }

qmcplusplus::MultiDiracDeterminant::new_ratios_to_ref_

OffloadVector< ValueType > new_ratios_to_ref_

new determinant ratios with respect to the updated reference determinant upon a proposed move ...

Definition: MultiDiracDeterminant.h:572

◆ getNewSpinGrads()

const Matrix<ValueType>& getNewSpinGrads ( ) const

inline

Definition at line 325 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::new_spingrads.

325 { return new_spingrads; }

qmcplusplus::MultiDiracDeterminant::new_spingrads

Matrix< ValueType > new_spingrads

Definition: MultiDiracDeterminant.h:582

◆ getNumDets()

int getNumDets ( ) const

inline

Definition at line 314 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::ciConfigList.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateGradRatios(), MultiDiracDeterminant::buildTableMatrix_calculateRatiosValueMatrixOneParticle(), MultiDiracDeterminant::mw_buildTableMatrix_calculateGradRatios(), MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::mw_evaluateGrads(), MultiDiracDeterminant::registerData(), and MultiDiracDeterminant::resize().

314 { return ciConfigList->size(); }

qmcplusplus::MultiDiracDeterminant::ciConfigList

std::shared_ptr< std::vector< ci_configuration2 > > ciConfigList

use shared_ptr

Definition: MultiDiracDeterminant.h:526

◆ getNumPtcls()

int getNumPtcls ( ) const

inline

Definition at line 315 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::NumPtcls.

315 { return NumPtcls; }

qmcplusplus::MultiDiracDeterminant::NumPtcls

const int NumPtcls

number of particles which belong to this Dirac determinant

Definition: MultiDiracDeterminant.h:522

◆ getPhi()

SPOSetPtr getPhi ( )

inline

Definition at line 145 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::Phi.

Referenced by MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), and MultiDiracDeterminant::mw_evaluateDetsForPtclMove().

145 { return Phi.get(); };

qmcplusplus::MultiDiracDeterminant::Phi

const std::unique_ptr< SPOSet > Phi

a set of single-particle orbitals used to fill in the values of the matrix

Definition: MultiDiracDeterminant.h:516

◆ getRatiosToRefDet()

const OffloadVector<ValueType>& getRatiosToRefDet ( ) const

inline

Definition at line 318 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::ratios_to_ref_.

Referenced by MultiDiracDeterminant::evaluateDerivatives(), and MultiDiracDeterminant::evaluateDerivativesWF().

318 { return ratios_to_ref_; }

qmcplusplus::MultiDiracDeterminant::ratios_to_ref_

OffloadVector< ValueType > ratios_to_ref_

determinant ratios with respect to the reference determinant

Definition: MultiDiracDeterminant.h:570

◆ getRefDetRatio()

PsiValue getRefDetRatio ( ) const

inline

Definition at line 327 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::curRatio.

327 { return static_cast<PsiValue>(curRatio); }

qmcplusplus::MultiDiracDeterminant::curRatio

ValueType curRatio

new value of the reference determinant over the old value upon a proposed move

Definition: MultiDiracDeterminant.h:574

qmcplusplus::WaveFunctionComponent::PsiValue

QTFull::ValueType PsiValue

Definition: WaveFunctionComponent.h:85

◆ getSpinGrads()

const Matrix<ValueType>& getSpinGrads ( ) const

inline

Definition at line 324 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::spingrads.

324 { return spingrads; }

qmcplusplus::MultiDiracDeterminant::spingrads

Matrix< ValueType > spingrads

Definition: MultiDiracDeterminant.h:582

◆ isFermionic()

bool isFermionic ( ) const

inlinefinalvirtual

true, if this component is fermionic

Reimplemented from WaveFunctionComponent.

Definition at line 149 of file MultiDiracDeterminant.h.

149 { return true; }

◆ isOptimizable()

bool isOptimizable ( ) const

inlinefinalvirtual

if true, this contains optimizable components

Reimplemented from WaveFunctionComponent.

Definition at line 150 of file MultiDiracDeterminant.h.

References MultiDiracDeterminant::Phi.

Referenced by MultiDiracDeterminant::buildOptVariables(), MultiDiracDeterminant::evaluateDerivatives(), and MultiDiracDeterminant::evaluateDerivativesWF().

150 { return Phi->isOptimizable(); }

qmcplusplus::MultiDiracDeterminant::Phi

const std::unique_ptr< SPOSet > Phi

a set of single-particle orbitals used to fill in the values of the matrix

Definition: MultiDiracDeterminant.h:516

◆ makeClone()

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

overridevirtual

make clone

Parameters

tqp	target Quantum ParticleSet
deepcopy	if true, make a decopy

If not true, return a proxy class

Reimplemented from WaveFunctionComponent.

Definition at line 578 of file MultiDiracDeterminant.cpp.

References APP_ABORT.

 {
   APP_ABORT(" Illegal action. Cannot use MultiDiracDeterminant::makeClone");
   return std::unique_ptr<MultiDiracDeterminant>();
 }

◆ mw_accept_rejectMove()

void mw_accept_rejectMove	(	const RefVectorWithLeader< MultiDiracDeterminant > &	wfc_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		int	iat,
		const std::vector< bool > &	isAccepted
	)

static

Definition at line 527 of file MultiDiracDeterminant.cpp.

 {
   // TODO to be expanded to serve offload needs without relying on calling acceptMove and restore
   for (int iw = 0; iw < wfc_list.size(); iw++)
     if (isAccepted[iw])
       wfc_list[iw].acceptMove(p_list[iw], iat, false);
     else
       wfc_list[iw].restore(iat);
 }

◆ mw_buildTableMatrix_calculateGradRatios()

void mw_buildTableMatrix_calculateGradRatios	(	MultiDiracDetMultiWalkerResource &	mw_res,
		int	ref,
		int	iat,
		int	dx,
		int	getNumDets,
		const OffloadVector< ValueType > &	det0_grad_list,
		const RefVector< OffloadMatrix< ValueType >> &	psiinv_list,
		const RefVector< OffloadMatrix< ValueType >> &	psi_list,
		const OffloadVector< int > &	data,
		const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &	pairs,
		const OffloadVector< RealType > &	sign,
		const RefVector< OffloadVector< ValueType >> &	WorkSpace_list,
		const RefVector< OffloadMatrix< ValueType >> &	table_matrix_list,
		UnpinnedOffloadMatrix< ValueType > &	mw_grads
	)

private

Function to calculate the ratio of the gradients of the excited determinant to the reference determinant in CustomizedMatrixDet following the paper by Clark et al.

JCP 135(24), 244105

Parameters

nw	Number of walkers in the batch
ref	ID of the reference determinant
iat	atom ID
dx	dimension (OHMMS_DIM)
getNumDets	Number of determinants
psiinv_list
psi_list
data	(Shared by all determinants)
pairs	is the number of unique determinants (std::pair[Nb_unique_alpha][Nb_unique_beta]) (Shared by all determinants)
sign	(Shared by all determinants)
WorkSpace_list	list refering to det.WorkSpace
table_matrix_list	stores all the dot products between 2 determinants (I,J)
ratios_list	returned computed list of gradients

Definition at line 267 of file MultiDiracDeterminant.2.cpp.

References MultiDiracDeterminant::calculateGradRatios_timer, Matrix< T, Alloc >::cols(), Matrix< T, Alloc >::data(), Vector< T, Alloc >::data(), Vector< T, Alloc >::device_data(), MultiDiracDeterminant::getNumDets(), MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl(), and sign().

Referenced by MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), and MultiDiracDeterminant::mw_evaluateGrads().

 {
   ScopedTimer local_timer(calculateGradRatios_timer);
   mw_buildTableMatrix_calculateRatios_impl(mw_res, ref, det0_grad_list, psiinv_list, psi_list, data, pairs, sign,
                                            table_matrix_list, WorkSpace_list);
 
   const size_t nw = WorkSpace_list.size();
   OffloadVector<ValueType*> WorkSpace_deviceptr_list(nw);
   for (size_t iw = 0; iw < nw; iw++)
     WorkSpace_deviceptr_list[iw] = WorkSpace_list[iw].get().device_data();
 
   auto* WorkSpace_list_ptr = WorkSpace_deviceptr_list.data();
   auto* mw_grads_ptr       = mw_grads.data();
   const size_t Grads_cols  = mw_grads.cols();
 
   PRAGMA_OFFLOAD("omp target teams distribute parallel for collapse(2)  map(from:mw_grads_ptr[:mw_grads.size()]) \
                                                             map(always, to:WorkSpace_list_ptr[:nw])")
   for (uint32_t iw = 0; iw < nw; iw++)
     for (uint32_t count = 0; count < getNumDets; ++count)
       mw_grads_ptr[(3 * iw + dx) * Grads_cols + count] = WorkSpace_list_ptr[iw][count];
 }

◆ mw_buildTableMatrix_calculateRatios()

void mw_buildTableMatrix_calculateRatios	(	MultiDiracDetMultiWalkerResource &	mw_res,
		int	ref,
		const OffloadVector< ValueType > &	det0_list,
		const RefVector< OffloadMatrix< ValueType >> &	psiinv_list,
		const RefVector< OffloadMatrix< ValueType >> &	psi_list,
		const OffloadVector< int > &	data,
		const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &	pairs,
		const OffloadVector< RealType > &	sign,
		const RefVector< OffloadMatrix< ValueType >> &	table_matrix_list,
		const RefVector< OffloadVector< ValueType >> &	ratios_list
	)

private

Definition at line 225 of file MultiDiracDeterminant.2.cpp.

References MultiDiracDeterminant::calculateRatios_timer, MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl(), sign(), and MultiDiracDeterminant::transferD2H_timer.

Referenced by MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), and MultiDiracDeterminant::mw_evaluateDetsForPtclMove().

 {
   ScopedTimer local_timer(calculateRatios_timer);
   mw_buildTableMatrix_calculateRatios_impl(mw_res, ref, det0_list, psiinv_list, psi_list, data, pairs, sign,
                                            table_matrix_list, ratios_list);
 
   {
     ScopedTimer local_timer(transferD2H_timer);
     for (size_t iw = 0; iw < ratios_list.size(); iw++)
       ratios_list[iw].get().updateFrom();
   }
 }

◆ mw_buildTableMatrix_calculateRatios_impl()

void mw_buildTableMatrix_calculateRatios_impl	(	MultiDiracDetMultiWalkerResource &	mw_res,
		int	ref,
		const OffloadVector< ValueType > &	det0_list,
		const RefVector< OffloadMatrix< ValueType >> &	psiinv_list,
		const RefVector< OffloadMatrix< ValueType >> &	psi_list,
		const OffloadVector< int > &	data,
		const VectorSoaContainer< int, 2, OffloadPinnedAllocator< int >> &	pairs,
		const OffloadVector< RealType > &	sign,
		const RefVector< OffloadMatrix< ValueType >> &	table_matrix_list,
		const RefVector< OffloadVector< ValueType >> &	ratios_list
	)

private

Function to calculate the ratio of the excited determinant to the reference determinant in CustomizedMatrixDet following the paper by Clark et al.

JCP 135(24), 244105

Parameters

nw	Number of walkers in the batch
ref	ID of the reference determinant
det0_list	takes lists of ValueType(1) for the value or RatioGrad/curRatio for the gradients
psiinv_list
psi_list
data	(Shared by all determinants)
pairs	is the number of unique determinants (std::pair[Nb_unique_alpha][Nb_unique_beta]) (Shared by all determinants)
sign	(Shared by all determinants)
table_matrix_list	stores all the dot products between 2 determinants (I,J)
ratio_list	returned computed ratios

Definition at line 75 of file MultiDiracDeterminant.2.cpp.

Referenced by MultiDiracDeterminant::mw_buildTableMatrix_calculateGradRatios(), and MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios().

 {
   const size_t nw                   = ratios_list.size();
   auto& psiinv_deviceptr_list       = mw_res.psiinv_deviceptr_list;
   auto& psi_deviceptr_list          = mw_res.psi_deviceptr_list;
   auto& table_matrix_deviceptr_list = mw_res.table_matrix_deviceptr_list;
   auto& ratios_deviceptr_list       = mw_res.ratios_deviceptr_list;
   const size_t nb_cols_table_matrix(table_matrix_list[0].get().cols());
 
   {
     ScopedTimer local(buildTable_timer);
     const size_t npairs = pairs.size();
     const size_t num    = psi_list[0].get().extent(1);
     const size_t nitems = sign.size();
 
     const int* first  = pairs.data(0);
     const int* second = pairs.data(1);
 
     psiinv_deviceptr_list.resize(nw);
     psi_deviceptr_list.resize(nw);
     table_matrix_deviceptr_list.resize(nw);
     ratios_deviceptr_list.resize(nw);
 
     for (size_t iw = 0; iw < nw; iw++)
     {
       psiinv_deviceptr_list[iw]       = psiinv_list[iw].get().device_data();
       psi_deviceptr_list[iw]          = psi_list[iw].get().device_data();
       table_matrix_deviceptr_list[iw] = table_matrix_list[iw].get().device_data();
       ratios_deviceptr_list[iw]       = ratios_list[iw].get().device_data();
     }
 
     const size_t nb_cols_psi(psi_list[0].get().cols());
     const size_t nb_cols_psiinv(psiinv_list[0].get().cols());
 
     auto* ratios_list_ptr       = ratios_deviceptr_list.data();
     auto* table_matrix_list_ptr = table_matrix_deviceptr_list.data();
     const auto* psiinv_list_ptr = psiinv_deviceptr_list.data();
     const auto* psi_list_ptr    = psi_deviceptr_list.data();
 
     {
       ScopedTimer local_timer(offload_timer);
       PRAGMA_OFFLOAD("omp target teams distribute parallel for collapse(2) \
           map(always, to: psiinv_list_ptr[:nw], psi_list_ptr[:nw]) \
           map(always, to: ratios_list_ptr[:nw], table_matrix_list_ptr[:nw]) \
     map(to:first[:npairs], second[:npairs])")
       for (uint32_t iw = 0; iw < nw; iw++)
         for (uint32_t i = 0; i < npairs; ++i)
         {
           const int I = first[i];
           const int J = second[i];
 
           ValueType table_matrix_local = 0.0;
           for (uint32_t ind = 0; ind < num; ind++)
             table_matrix_local +=
                 psiinv_list_ptr[iw][I * nb_cols_psiinv + ind] * psi_list_ptr[iw][J * nb_cols_psi + ind];
           table_matrix_list_ptr[iw][I * nb_cols_table_matrix + J] = table_matrix_local;
         }
     }
   }
   {
     ScopedTimer local(table2ratios_timer);
     const int max_ext_level = ndets_per_excitation_level_->size() - 1;
 
     // Compute workload changes drastically as the excitation level increases.
     // this may need different parallelization strategy.
     size_t det_offset  = 1;
     size_t data_offset = 1;
 
     auto update_offsets = [&](size_t ext_level) {
       det_offset += (*ndets_per_excitation_level_)[ext_level];
       data_offset += (*ndets_per_excitation_level_)[ext_level] * (3 * ext_level + 1);
     };
 
     mw_updateRatios_det0(det0_list, ratios_deviceptr_list);
 
     if (max_ext_level >= 1)
     {
       mw_updateRatios<1>(det_offset, data_offset, data, sign, table_matrix_deviceptr_list, nb_cols_table_matrix,
                          ratios_deviceptr_list);
       update_offsets(1);
     }
 
     if (max_ext_level >= 2)
     {
       mw_updateRatios<2>(det_offset, data_offset, data, sign, table_matrix_deviceptr_list, nb_cols_table_matrix,
                          ratios_deviceptr_list);
       update_offsets(2);
     }
 
     if (max_ext_level >= 3)
     {
       mw_updateRatios<3>(det_offset, data_offset, data, sign, table_matrix_deviceptr_list, nb_cols_table_matrix,
                          ratios_deviceptr_list);
       update_offsets(3);
     }
 
     if (max_ext_level >= 4)
     {
       mw_updateRatios<4>(det_offset, data_offset, data, sign, table_matrix_deviceptr_list, nb_cols_table_matrix,
                          ratios_deviceptr_list);
       update_offsets(4);
     }
 
     if (max_ext_level >= 5)
     {
       mw_updateRatios<5>(det_offset, data_offset, data, sign, table_matrix_deviceptr_list, nb_cols_table_matrix,
                          ratios_deviceptr_list);
       update_offsets(5);
     }
 
     if (max_ext_level >= 6)
     {
       for (size_t iw = 0; iw < nw; iw++)
         table_matrix_list[iw].get().updateFrom();
       for (size_t ext_level = 6; ext_level <= max_ext_level; ext_level++)
       {
         mw_updateRatios_generic(ext_level, det_offset, data_offset, det_calculator_, data, sign, table_matrix_list,
                                 ratios_list);
         update_offsets(ext_level);
       }
       // FIXME need to transfer the part of det ratios ext_level >= 6 to the device.
     }
   }
 }

◆ mw_evaluateDetsAndGradsForPtclMove()

void mw_evaluateDetsAndGradsForPtclMove	(	const RefVectorWithLeader< MultiDiracDeterminant > &	det_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	iat,
		UnpinnedOffloadMatrix< ValueType > &	mw_grads
	)

static

multi walker version of mw_evaluateDetsAndGradsForPtclMove

This is needed by Host in acceptMove. Eventually acceptMove will need to become mw_acceptMove.

Definition at line 662 of file MultiDiracDeterminant.2.cpp.

 {
   const int nw                      = det_list.size();
   MultiDiracDeterminant& det_leader = det_list.getLeader();
   RefVectorWithLeader<SPOSet> phi_list(*det_leader.getPhi());
 
   ScopedTimer local_timer(det_leader.evaluateDetsAndGradsForPtclMove_timer);
   int success      = 0;
   int dummy_handle = 0;
   const size_t NumOrbitals(det_leader.NumOrbitals);
   const size_t NumPtcls(det_leader.NumPtcls);
 
   RefVector<OffloadVector<ValueType>> psiV_list, psiV_temp_list, new_ratios_to_ref_list, WorkSpace_list;
   RefVector<OffloadVector<ValueType>> d2psiV_list;
 
   RefVector<OffloadMatrix<ValueType>> psiMinv_temp_list, psiMinv_list, dpsiMinv_list;
   RefVector<OffloadMatrix<ValueType>> table_matrix_list, psiM_list, TpsiM_list;
 
   RefVector<OffloadVector<GradType>> dpsiV_list;
 
   phi_list.reserve(nw);
   psiV_list.reserve(nw);
   dpsiV_list.reserve(nw);
   d2psiV_list.reserve(nw);
   psiV_temp_list.reserve(nw);
   psiMinv_temp_list.reserve(nw);
   psiMinv_list.reserve(nw);
   psiM_list.reserve(nw);
 
   TpsiM_list.reserve(nw);
   new_ratios_to_ref_list.reserve(nw);
   table_matrix_list.reserve(nw);
   dpsiMinv_list.reserve(nw);
   WorkSpace_list.reserve(nw);
 
   auto& mw_res            = det_leader.mw_res_handle_.getResource();
   auto& ratioGradRef_list = mw_res.ratioGradRef_list;
   auto& det0_grad_list    = mw_res.det0_grad_list;
   ratioGradRef_list.resize(nw);
   det0_grad_list.resize(nw);
 
   det_leader.UpdateMode  = ORB_PBYP_PARTIAL;
   const int WorkingIndex = iat - det_leader.FirstIndex;
 
   for (size_t iw = 0; iw < nw; iw++)
   {
     MultiDiracDeterminant& det = (det_list[iw]);
     det.UpdateMode             = ORB_PBYP_PARTIAL;
     phi_list.push_back(*det.Phi);
     psiV_list.push_back(det.psiV);
     dpsiV_list.push_back(det.dpsiV);
     d2psiV_list.push_back(det.d2psiV);
     psiV_temp_list.push_back(det.psiV_temp);
     psiMinv_list.push_back(det.psiMinv);
     psiM_list.push_back(det.psiM);
     psiMinv_temp_list.push_back(det.psiMinv_temp);
     new_ratios_to_ref_list.push_back(det.new_ratios_to_ref_);
     TpsiM_list.push_back(det.TpsiM);
     table_matrix_list.push_back(det.table_matrix);
     dpsiMinv_list.push_back(det.dpsiMinv);
     WorkSpace_list.push_back(det.WorkSpace);
   }
 
   {
     ScopedTimer local_timer(det_leader.evalOrbVGL_timer);
     for (size_t iw = 0; iw < nw; iw++)
     {
       MultiDiracDeterminant& det = (det_list[iw]);
       Vector<ValueType> psiV_list_host_view(psiV_list[iw].get().data(), psiV_list[iw].get().size());
       Vector<GradType> dpsiV_list_host_view(dpsiV_list[iw].get().data(), dpsiV_list[iw].get().size());
       Vector<ValueType> d2psiV_list_host_view(d2psiV_list[iw].get().data(), d2psiV_list[iw].get().size());
       det.Phi->evaluateVGL(P_list[iw], iat, psiV_list_host_view, dpsiV_list_host_view, d2psiV_list_host_view);
 
       {
         ScopedTimer local_timer(det_leader.transferH2D_timer);
         psiV_list[iw].get().updateTo();
         dpsiV_list[iw].get().updateTo();
       }
     }
   }
 
   const auto psiMinv_rows   = psiMinv_list[0].get().rows();
   const auto psiMinv_cols   = psiMinv_list[0].get().cols();
   const auto TpsiM_num_cols = TpsiM_list[0].get().cols();
   const auto psiM_num_cols  = psiM_list[0].get().cols();
   const auto& confgList     = *det_leader.ciConfigList;
 
   auto* psiV_list_devptr         = mw_res.psiV_deviceptr_list.device_data();
   auto* psiV_temp_list_ptr       = mw_res.psiV_temp_deviceptr_list.data();
   auto* TpsiM_list_devptr        = mw_res.TpsiM_deviceptr_list.device_data();
   auto* psiM_list_ptr            = mw_res.psiM_deviceptr_list.data();
   auto* psiMinv_list_devptr      = mw_res.psiMinv_deviceptr_list.device_data();
   auto* dpsiMinv_list_devptr     = mw_res.dpsiMinv_deviceptr_list.device_data();
   auto* psiMinv_temp_list_devptr = mw_res.psiMinv_temp_deviceptr_list.device_data();
 
   auto& curRatio_list = mw_res.curRatio_list;
   curRatio_list.resize(nw);
   auto* curRatio_list_ptr = curRatio_list.data();
 
   auto& inv_curRatio_list = mw_res.inv_curRatio_list;
   inv_curRatio_list.resize(nw);
   auto* inv_curRatio_list_ptr = inv_curRatio_list.data();
 
   auto* det0_grad_list_ptr = det0_grad_list.data();
   auto* confgListOccup_ptr = det_leader.refdet_occup->data();
 
   auto* dpsiV_list_ptr        = mw_res.dpsiV_deviceptr_list.data();
   auto* ratioGradRef_list_ptr = ratioGradRef_list.data();
 
   {
     success = ompBLAS::copy_batched(dummy_handle, psiMinv_rows * psiMinv_cols, psiMinv_list_devptr, 1,
                                     psiMinv_temp_list_devptr, 1, nw);
     if (success != 0)
       throw std::runtime_error("In MultiDiracDeterminant ompBLAS::copy_batched_offset failed.");
 
 
     // Index of loop over nw must be 32 bit sized to avoid assignment-after-reduction offload bug
     // See https://github.com/QMCPACK/qmcpack/issues/4767
     PRAGMA_OFFLOAD("omp target teams distribute is_device_ptr(psiV_list_devptr, psiMinv_temp_list_devptr) \
                         map(always, from:curRatio_list_ptr[:nw])")
     for (uint32_t iw = 0; iw < nw; iw++)
     {
       GradType ratioGradRef_local(0);
       PRAGMA_OFFLOAD("omp parallel for reduction(+ : ratioGradRef_local)")
       for (uint32_t i = 0; i < NumPtcls; i++)
       {
         const size_t J            = confgListOccup_ptr[i];
         psiV_temp_list_ptr[iw][i] = psiV_list_devptr[iw][J];
         ratioGradRef_local += psiMinv_temp_list_devptr[iw][i * psiMinv_cols + WorkingIndex] * dpsiV_list_ptr[iw][J];
       }
       // Workaround for assignment-after-reduction issue.
       // In full precision, changing the loop variable iw to 32 bits in size works.
       // In mixed precision, changing the loop variable iw to 16 bits would work, but is not acceptable.
       // For that case we use the other workaround of assigning each value in the array separately.
       // See https://github.com/QMCPACK/qmcpack/issues/4767
       ratioGradRef_list_ptr[iw][0] = ratioGradRef_local[0];
       ratioGradRef_list_ptr[iw][1] = ratioGradRef_local[1];
       ratioGradRef_list_ptr[iw][2] = ratioGradRef_local[2];
 
       ValueType c_ratio = 0.0;
       PRAGMA_OFFLOAD("omp parallel for reduction(+ : c_ratio)")
       for (uint32_t jc = 0; jc < psiMinv_cols; jc += 1)
       {
         const size_t ic = jc * psiMinv_cols;
         c_ratio += (psiMinv_temp_list_devptr[iw] + WorkingIndex)[ic] * psiV_temp_list_ptr[iw][jc];
       }
       curRatio_list_ptr[iw]     = c_ratio;
       inv_curRatio_list_ptr[iw] = ValueType(1) / c_ratio;
     }
 
     success = ompBLAS::copy_batched_offset(dummy_handle, det_leader.NumOrbitals, psiV_list_devptr, 0, 1,
                                            TpsiM_list_devptr, WorkingIndex, TpsiM_num_cols, nw);
     if (success != 0)
       throw std::runtime_error("In MultiDiracDeterminant ompBLAS::copy_batched_offset failed.");
 
 
     det_leader.mw_InverseUpdateByColumn(det_leader.mw_res_handle_, WorkingIndex, inv_curRatio_list,
                                         mw_res.psiV_temp_deviceptr_list, mw_res.psiMinv_temp_deviceptr_list,
                                         psiMinv_rows);
 
     ///This is needed by Host in acceptMove. Eventually acceptMove will need to become mw_acceptMove.
     {
       ScopedTimer local_timer(det_leader.transferD2H_timer);
       for (size_t iw = 0; iw < nw; iw++)
         psiMinv_temp_list[iw].get().updateFrom();
     }
 
     auto& det0_list = mw_res.cone_vec;
     det_leader.mw_buildTableMatrix_calculateRatios(det_leader.mw_res_handle_, det_leader.ReferenceDeterminant,
                                                    det0_list, psiMinv_temp_list, TpsiM_list, *det_leader.detData,
                                                    *det_leader.uniquePairs, *det_leader.DetSigns, table_matrix_list,
                                                    new_ratios_to_ref_list);
 
     for (size_t idim = 0; idim < OHMMS_DIM; idim++)
     {
       success = ompBLAS::copy_batched(dummy_handle, psiMinv_rows * psiMinv_cols, psiMinv_list_devptr, 1,
                                       dpsiMinv_list_devptr, 1, nw);
       if (success != 0)
         throw std::runtime_error("In MultiDiracDeterminant ompBLAS::copy_batched_offset failed.");
 
       PRAGMA_OFFLOAD("omp target teams distribute map(to: ratioGradRef_list_ptr[:nw])")
       for (uint32_t iw = 0; iw < nw; iw++)
       {
         inv_curRatio_list_ptr[iw] = ValueType(1) / ratioGradRef_list_ptr[iw][idim];
 
         for (uint32_t i = 0; i < NumPtcls; i++)
         {
           const size_t J            = confgListOccup_ptr[i];
           psiV_temp_list_ptr[iw][i] = dpsiV_list_ptr[iw][J][idim];
         }
       }
 
       det_leader.mw_InverseUpdateByColumn(det_leader.mw_res_handle_, WorkingIndex, inv_curRatio_list,
                                           mw_res.psiV_temp_deviceptr_list, mw_res.dpsiMinv_deviceptr_list,
                                           psiMinv_rows);
 
       PRAGMA_OFFLOAD("omp target teams distribute map(to:dpsiV_list_ptr[:nw], curRatio_list_ptr[:nw]) \
                            map(always,from:det0_grad_list_ptr[:nw]) \
                            is_device_ptr(TpsiM_list_devptr)")
       for (uint32_t iw = 0; iw < nw; iw++)
       {
         det0_grad_list_ptr[iw] = ratioGradRef_list_ptr[iw][idim] / curRatio_list_ptr[iw];
         for (uint32_t i = 0; i < NumOrbitals; i++)
           TpsiM_list_devptr[iw][i * TpsiM_num_cols + WorkingIndex] = dpsiV_list_ptr[iw][i][idim];
       }
 
       det_leader.mw_buildTableMatrix_calculateGradRatios(det_leader.mw_res_handle_, det_leader.ReferenceDeterminant,
                                                          WorkingIndex, idim, det_leader.getNumDets(), det0_grad_list,
                                                          dpsiMinv_list, TpsiM_list, *det_leader.detData,
                                                          *det_leader.uniquePairs, *det_leader.DetSigns, WorkSpace_list,
                                                          table_matrix_list, mw_grads);
     }
 
     // restore the modified column of TpsiM.
     PRAGMA_OFFLOAD("omp target teams distribute parallel for collapse(2) is_device_ptr(TpsiM_list_devptr) \
                                         map(always, to:psiM_list_ptr[:nw])")
     for (uint32_t iw = 0; iw < nw; iw++)
       for (uint32_t i = 0; i < NumOrbitals; i++)
         TpsiM_list_devptr[iw][i * TpsiM_num_cols + WorkingIndex] = psiM_list_ptr[iw][i + psiM_num_cols * WorkingIndex];
   }
 
   for (size_t iw = 0; iw < nw; iw++)
   {
     MultiDiracDeterminant& det = (det_list[iw]);
     det.curRatio               = curRatio_list[iw];
   }
 }

◆ mw_evaluateDetsForPtclMove()

void mw_evaluateDetsForPtclMove	(	const RefVectorWithLeader< MultiDiracDeterminant > &	det_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	iat
	)

static

multi walker version of evaluateDetsForPtclMove

Transfer of data from host to Device

This is needed by acceptMove. Eventually acceptMove will need to become mw_acceptMove.

Definition at line 346 of file MultiDiracDeterminant.2.cpp.

 {
   const int nw                      = det_list.size();
   MultiDiracDeterminant& det_leader = det_list.getLeader();
   RefVectorWithLeader<SPOSet> phi_list(*det_leader.getPhi());
 
   ScopedTimer local_timer(det_leader.evaluateDetsForPtclMove_timer);
 
   RefVector<OffloadVector<ValueType>> psiV_list, new_ratios_to_ref_list;
   RefVector<OffloadMatrix<ValueType>> TpsiM_list, psiM_list, table_matrix_list;
   RefVector<OffloadMatrix<ValueType>> psiMinv_temp_list, psiMinv_list;
 
   phi_list.reserve(nw);
   psiV_list.reserve(nw);
   psiMinv_list.reserve(nw);
   psiMinv_temp_list.reserve(nw);
   table_matrix_list.reserve(nw);
   TpsiM_list.reserve(nw);
   psiM_list.reserve(nw);
   new_ratios_to_ref_list.reserve(nw);
 
   for (size_t iw = 0; iw < nw; iw++)
   {
     MultiDiracDeterminant& det = (det_list[iw]);
     det.UpdateMode             = ORB_PBYP_PARTIAL;
     phi_list.push_back(*det.Phi);
     psiV_list.push_back(det.psiV);
     psiMinv_list.push_back(det.psiMinv);
     psiM_list.push_back(det.psiM);
     psiMinv_temp_list.push_back(det.psiMinv_temp);
     new_ratios_to_ref_list.push_back(det.new_ratios_to_ref_);
     table_matrix_list.push_back(det.table_matrix);
     TpsiM_list.push_back(det.TpsiM);
   }
 
 
   det_leader.UpdateMode  = ORB_PBYP_RATIO;
   const int WorkingIndex = iat - det_leader.FirstIndex;
 
   {
     ScopedTimer local_timer(det_leader.evalOrbValue_timer);
     for (size_t iw = 0; iw < nw; iw++)
     {
       MultiDiracDeterminant& det = (det_list[iw]);
       Vector<ValueType> psiV_list_host_view(psiV_list[iw].get().data(), psiV_list[iw].get().size());
       det.getPhi()->evaluateValue(P_list[iw], iat, psiV_list_host_view);
       ///Transfer of data from host to Device
       {
         ScopedTimer local_timer(det.transferH2D_timer);
         psiV_list[iw].get().updateTo();
       }
     }
   }
 
   size_t success          = 0;
   int dummy_handle        = 0;
   const auto psiMinv_rows = psiMinv_list[0].get().rows();
   const auto psiMinv_cols = psiMinv_list[0].get().cols();
   const auto TpsiM_cols   = TpsiM_list[0].get().cols();
   const auto psiM_cols    = psiM_list[0].get().cols();
   const auto TpsiM_rows   = TpsiM_list[0].get().rows();
   const auto NumPtcls     = det_leader.NumPtcls;
   const auto NumOrbitals  = det_leader.NumOrbitals;
   const auto& confgList   = *det_leader.ciConfigList;
 
   auto& mw_res             = det_leader.mw_res_handle_.getResource();
   auto* psiV_list_devptr   = mw_res.psiV_deviceptr_list.device_data();
   auto* psiV_temp_list_ptr = mw_res.psiV_temp_deviceptr_list.data();
 
   auto* psiMinv_list_devptr      = mw_res.psiMinv_deviceptr_list.device_data();
   auto* psiMinv_temp_list_devptr = mw_res.psiMinv_temp_deviceptr_list.device_data();
 
   auto* TpsiM_list_devptr = mw_res.TpsiM_deviceptr_list.device_data();
   auto* psiM_list_ptr     = mw_res.psiM_deviceptr_list.data();
 
   auto& curRatio_list = mw_res.curRatio_list;
   curRatio_list.resize(nw);
   auto* curRatio_list_ptr = curRatio_list.data();
 
   auto& inv_curRatio_list = mw_res.inv_curRatio_list;
   inv_curRatio_list.resize(nw);
   auto* inv_curRatio_list_ptr = inv_curRatio_list.data();
 
   auto* confgListOccup_ptr = det_leader.refdet_occup->data();
 
   {
     success = ompBLAS::copy_batched(dummy_handle, psiMinv_rows * psiMinv_cols, psiMinv_list_devptr, 1,
                                     psiMinv_temp_list_devptr, 1, nw);
     if (success != 0)
       throw std::runtime_error("In MultiDiracDeterminant ompBLAS::copy_batched_offset failed.");
 
     success = ompBLAS::copy_batched_offset(dummy_handle, det_leader.NumOrbitals, psiV_list_devptr, 0, 1,
                                            TpsiM_list_devptr, WorkingIndex, TpsiM_cols, nw);
     if (success != 0)
       throw std::runtime_error("In MultiDiracDeterminant ompBLAS::copy_batched_offset failed.");
 
     PRAGMA_OFFLOAD("omp target teams distribute map(always, from:curRatio_list_ptr[:nw]) \
                     is_device_ptr(psiV_list_devptr, psiMinv_temp_list_devptr)")
     for (uint32_t iw = 0; iw < nw; iw++)
     {
       ValueType c_ratio = 0.0;
       PRAGMA_OFFLOAD("omp parallel for reduction(+ : c_ratio)")
       for (uint32_t jc = 0; jc < NumPtcls; jc++)
       {
         const size_t J             = confgListOccup_ptr[jc];
         psiV_temp_list_ptr[iw][jc] = psiV_list_devptr[iw][J];
         size_t ic                  = jc * psiMinv_cols;
         c_ratio += (psiMinv_temp_list_devptr[iw] + WorkingIndex)[ic] * psiV_temp_list_ptr[iw][jc];
       }
       curRatio_list_ptr[iw]     = c_ratio;
       inv_curRatio_list_ptr[iw] = ValueType(1) / c_ratio;
     }
 
     det_leader.mw_InverseUpdateByColumn(det_leader.mw_res_handle_, WorkingIndex, inv_curRatio_list,
                                         mw_res.psiV_temp_deviceptr_list, mw_res.psiMinv_temp_deviceptr_list,
                                         psiMinv_rows);
     ///This is needed by acceptMove. Eventually acceptMove will need to become mw_acceptMove.
     {
       ScopedTimer local_timer(det_leader.transferD2H_timer);
       for (size_t iw = 0; iw < nw; iw++)
         psiMinv_temp_list[iw].get().updateFrom();
     }
 
     auto& det0_list = mw_res.cone_vec;
     det_leader.mw_buildTableMatrix_calculateRatios(det_leader.mw_res_handle_, det_leader.ReferenceDeterminant,
                                                    det0_list, psiMinv_temp_list, TpsiM_list, *det_leader.detData,
                                                    *det_leader.uniquePairs, *det_leader.DetSigns, table_matrix_list,
                                                    new_ratios_to_ref_list);
 
     // restore the modified column of TpsiM.
     PRAGMA_OFFLOAD("omp target teams distribute parallel for collapse(2) is_device_ptr(TpsiM_list_devptr) \
                                         map(always, to:psiM_list_ptr[:nw])")
     for (uint32_t iw = 0; iw < nw; iw++)
       for (uint32_t i = 0; i < NumOrbitals; i++)
         TpsiM_list_devptr[iw][i * TpsiM_cols + WorkingIndex] = psiM_list_ptr[iw][i + psiM_cols * WorkingIndex];
   }
 
   for (size_t iw = 0; iw < nw; iw++)
   {
     MultiDiracDeterminant& det = (det_list[iw]);
     det.curRatio               = curRatio_list_ptr[iw];
   }
 }

◆ mw_evaluateGrads()

void mw_evaluateGrads	(	const RefVectorWithLeader< MultiDiracDeterminant > &	det_list,
		const RefVectorWithLeader< ParticleSet > &	P_list,
		int	iat,
		UnpinnedOffloadMatrix< ValueType > &	mw_grads
	)

static

multi walker version of mw_evaluateGrads

Definition at line 971 of file MultiDiracDeterminant.2.cpp.

 {
   const int nw                      = det_list.size();
   MultiDiracDeterminant& det_leader = det_list.getLeader();
   const int WorkingIndex            = iat - det_leader.FirstIndex;
   int success                       = 0;
   int dummy_handle                  = 0;
   const size_t NumOrbitals(det_leader.NumOrbitals);
   const size_t NumPtcls(det_leader.NumPtcls);
 
   ScopedTimer local_timer(det_leader.evaluateGrads_timer);
 
   RefVector<OffloadMatrix<ValueType>> dpsiMinv_list, psiMinv_list;
   RefVector<OffloadMatrix<GradType>> dpsiM_list;
   RefVector<OffloadVector<ValueType>> psiV_temp_list, WorkSpace_list;
   RefVector<OffloadMatrix<ValueType>> table_matrix_list, TpsiM_list, psiM_list;
   //RefVector<OffloadMatrix<GradType>> grads_list;
 
   psiMinv_list.reserve(nw);
   dpsiMinv_list.reserve(nw);
   dpsiM_list.reserve(nw);
   psiV_temp_list.reserve(nw);
   //grads_list.reserve(nw);
   table_matrix_list.reserve(nw);
   TpsiM_list.reserve(nw);
   psiM_list.reserve(nw);
   WorkSpace_list.reserve(nw);
 
   for (size_t iw = 0; iw < nw; iw++)
   {
     MultiDiracDeterminant& det = (det_list[iw]);
     psiMinv_list.push_back(det.psiMinv);
     dpsiMinv_list.push_back(det.dpsiMinv);
     psiV_temp_list.push_back(det.psiV_temp);
     dpsiM_list.push_back(det.dpsiM);
     //grads_list.push_back(det.grads);
     TpsiM_list.push_back(det.TpsiM);
     psiM_list.push_back(det.psiM);
     table_matrix_list.push_back(det.table_matrix);
     WorkSpace_list.push_back(det.WorkSpace);
   }
 
   const auto psiMinv_rows = psiMinv_list[0].get().rows();
   const auto psiMinv_cols = psiMinv_list[0].get().cols();
   const auto TpsiM_cols   = TpsiM_list[0].get().cols();
   const auto psiM_cols    = psiM_list[0].get().cols();
   const auto dpsiM_cols   = dpsiM_list[0].get().cols();
   const auto dpsiM_rows   = dpsiM_list[0].get().rows();
   const auto& confgList   = *det_leader.ciConfigList;
 
   auto& mw_res      = det_leader.mw_res_handle_.getResource();
   auto& ratioG_list = mw_res.curRatio_list;
   ratioG_list.resize(nw);
   auto* ratioG_list_ptr = ratioG_list.data();
 
   auto& inv_ratioG_list = mw_res.inv_curRatio_list;
   inv_ratioG_list.resize(nw);
   auto* inv_ratioG_list_ptr = inv_ratioG_list.data();
 
   auto* psiMinv_list_devptr  = mw_res.psiMinv_deviceptr_list.device_data();
   auto* dpsiMinv_list_devptr = mw_res.dpsiMinv_deviceptr_list.device_data();
   auto* TpsiM_list_devptr    = mw_res.TpsiM_deviceptr_list.data();
   auto* psiM_list_ptr        = mw_res.psiM_deviceptr_list.data();
   auto* psiV_temp_list_ptr   = mw_res.psiV_temp_deviceptr_list.data();
   auto* dpsiM_list_ptr       = mw_res.dpsiM_deviceptr_list.data();
   auto* confgListOccup_ptr   = det_leader.refdet_occup->data();
 
   {
     for (size_t idim = 0; idim < OHMMS_DIM; idim++)
     {
       success = ompBLAS::copy_batched(dummy_handle, psiMinv_rows * psiMinv_cols, psiMinv_list_devptr, 1,
                                       dpsiMinv_list_devptr, 1, nw);
       if (success != 0)
         throw std::runtime_error("In MultiDiracDeterminant ompBLAS::copy_batched_offset failed.");
 
       PRAGMA_OFFLOAD("omp target teams distribute  map(always, to: psiV_temp_list_ptr[:nw]) \
                                       map(always, to: dpsiM_list_ptr[:nw])")
       for (uint32_t iw = 0; iw < nw; iw++)
         for (uint32_t i = 0; i < NumPtcls; i++)
         {
           size_t J                  = confgListOccup_ptr[i];
           psiV_temp_list_ptr[iw][i] = dpsiM_list_ptr[iw][WorkingIndex * dpsiM_cols + J][idim];
         }
 
       PRAGMA_OFFLOAD("omp target teams distribute is_device_ptr(psiMinv_list_devptr) \
                                       map(always, from: ratioG_list_ptr[:nw])")
       for (uint32_t iw = 0; iw < nw; iw++)
       {
         ValueType ratioG_local(0);
         PRAGMA_OFFLOAD("omp parallel for reduction(+ : ratioG_local)")
         for (uint32_t i = 0; i < NumPtcls; i++)
         {
           size_t J = confgListOccup_ptr[i];
           ratioG_local += psiMinv_list_devptr[iw][i * psiMinv_cols + WorkingIndex] *
               dpsiM_list_ptr[iw][WorkingIndex * dpsiM_cols + J][idim];
         }
         ratioG_list_ptr[iw]     = ratioG_local;
         inv_ratioG_list_ptr[iw] = ValueType(1) / ratioG_local;
       }
 
       det_leader.mw_InverseUpdateByColumn(det_leader.mw_res_handle_, WorkingIndex, inv_ratioG_list,
                                           mw_res.psiV_temp_deviceptr_list, mw_res.dpsiMinv_deviceptr_list,
                                           psiMinv_rows);
 
       PRAGMA_OFFLOAD("omp target teams distribute parallel for collapse(2) map(to:dpsiM_list_ptr[:nw]) \
                                                   map(always, to: TpsiM_list_devptr[:nw])")
       for (uint32_t iw = 0; iw < nw; iw++)
         for (uint32_t i = 0; i < NumOrbitals; i++)
           TpsiM_list_devptr[iw][i * TpsiM_cols + WorkingIndex] =
               dpsiM_list_ptr[iw][dpsiM_cols * WorkingIndex + i][idim];
 
 
       det_leader.mw_buildTableMatrix_calculateGradRatios(det_leader.mw_res_handle_, det_leader.ReferenceDeterminant,
                                                          WorkingIndex, idim, det_leader.getNumDets(), ratioG_list,
                                                          dpsiMinv_list, TpsiM_list, *det_leader.detData,
                                                          *det_leader.uniquePairs, *det_leader.DetSigns, WorkSpace_list,
                                                          table_matrix_list, mw_grads);
     }
 
     // restore the modified column of TpsiM.
     PRAGMA_OFFLOAD("omp target teams distribute parallel for map(from:TpsiM_list_devptr[:nw]) \
                                                        map(always,to:psiM_list_ptr[:nw])")
     for (uint32_t iw = 0; iw < nw; iw++)
       for (uint32_t i = 0; i < NumOrbitals; i++)
         TpsiM_list_devptr[iw][i * TpsiM_cols + WorkingIndex] = psiM_list_ptr[iw][i + psiM_cols * WorkingIndex];
   }
 }

◆ mw_InverseUpdateByColumn()

void mw_InverseUpdateByColumn	(	MultiDiracDetMultiWalkerResource &	mw_res,
		const int	working_index,
		const OffloadVector< ValueType > &	curRatio_list,
		const OffloadVector< ValueType *> &	psiV_deviceptr_list,
		const OffloadVector< ValueType *> &	psiMinv_deviceptr_list,
		const size_t	psiMinv_rows
	)		const

private

Definition at line 1168 of file MultiDiracDeterminant.2.cpp.

References MultiDiracDeterminant::MultiDiracDetMultiWalkerResource::cminus_one_vec, BLAS::cone, qmcplusplus::ompBLAS::copy_batched_offset(), MultiDiracDeterminant::MultiDiracDetMultiWalkerResource::czero_vec, Vector< T, Alloc >::device_data(), qmcplusplus::ompBLAS::gemv_batched(), qmcplusplus::ompBLAS::ger_batched(), Vector< T, Alloc >::size(), MultiDiracDeterminant::updateInverse_timer, MultiDiracDeterminant::MultiDiracDetMultiWalkerResource::workV1_deviceptr_list, and MultiDiracDeterminant::MultiDiracDetMultiWalkerResource::workV2_deviceptr_list.

Referenced by MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::mw_evaluateDetsForPtclMove(), and MultiDiracDeterminant::mw_evaluateGrads().

 {
   ScopedTimer local_timer(updateInverse_timer);
 
   constexpr ValueType cone(1);
 
   const size_t nw = inv_curRatio_list.size();
 
   ValueType* czero_ptr      = mw_res.czero_vec.device_data();
   ValueType* cminus_one_ptr = mw_res.cminus_one_vec.device_data();
 
   int success      = 0;
   int dummy_handle = 0;
 
   auto* psiV_list_devptr         = psiV_deviceptr_list.device_data();
   auto* psiMinv_list_devptr      = psiMinv_deviceptr_list.device_data();
   auto* workV1_list_ptr          = mw_res.workV1_deviceptr_list.device_data();
   auto* workV2_list_ptr          = mw_res.workV2_deviceptr_list.device_data();
   auto* inv_curRatio_list_devptr = inv_curRatio_list.device_data();
 
   success =
       ompBLAS::gemv_batched(dummy_handle, 'N', psiMinv_rows, psiMinv_rows, inv_curRatio_list_devptr,
                             psiMinv_list_devptr, psiMinv_rows, psiV_list_devptr, 1, czero_ptr, workV1_list_ptr, 1, nw);
   if (success != 0)
     throw std::runtime_error("In MultiDiracDeterminant ompBLAS::gemv_batched failed.");
 
   PRAGMA_OFFLOAD("omp target teams distribute parallel for is_device_ptr(workV1_list_ptr, inv_curRatio_list_devptr)")
   for (uint32_t iw = 0; iw < nw; iw++)
     workV1_list_ptr[iw][working_index] = cone - inv_curRatio_list_devptr[iw];
   if (success != 0)
     throw std::runtime_error("In MultiDiracDeterminant ompBLAS::copy_batched_offset failed.");
 
   success = ompBLAS::copy_batched_offset(dummy_handle, psiMinv_rows, psiMinv_list_devptr, working_index, psiMinv_rows,
                                          workV2_list_ptr, 0, 1, nw);
   if (success != 0)
     throw std::runtime_error("In MultiDiracDeterminant ompBLAS::copy_batched_offset failed.");
 
   success = ompBLAS::ger_batched(dummy_handle, psiMinv_rows, psiMinv_rows, cminus_one_ptr, workV1_list_ptr, 1,
                                  workV2_list_ptr, 1, psiMinv_list_devptr, psiMinv_rows, nw);
   if (success != 0)
     throw std::runtime_error("In MultiDiracDeterminant ompBLAS::ger_batched failed.");
 }

◆ mw_updateRatios()

void mw_updateRatios	(	const size_t	det_offset,
		const size_t	data_offset,
		const OffloadVector< int > &	data,
		const OffloadVector< RealType > &	sign,
		const OffloadVector< ValueType *> &	table_matrix_deviceptr_list,
		const size_t	num_table_matrix_cols,
		const OffloadVector< ValueType *> &	ratios_deviceptr_list
	)		const

private

update ratios with respect to the reference deteriminant for a given excitation level

Parameters

det_offset	offset of the determinant id
data_offset	offset of the "data" structure
sign	of determinants
table_matrix_list	list of table_matrix

this is intended to be customized based on EXT_LEVEL

Definition at line 1137 of file MultiDiracDeterminant.2.cpp.

References Vector< T, Alloc >::data(), qmcplusplus::evaluate(), sign(), Vector< T, Alloc >::size(), and MultiDiracDeterminant::updateRatios_timer.

 {
   const size_t nw        = ratios_deviceptr_list.size();
   const size_t size_sign = sign.size();
   const size_t ndet_ext  = (*ndets_per_excitation_level_)[EXT_LEVEL];
 
   ScopedTimer local_timer(updateRatios_timer);
 
   auto* ratios_list_ptr             = ratios_deviceptr_list.data();
   const auto* sign_ptr              = sign.data();
   const int* data_ptr               = data.data();
   const auto* table_matrix_list_ptr = table_matrix_deviceptr_list.data();
 
   PRAGMA_OFFLOAD("omp target teams distribute parallel for collapse(2)")
   for (uint32_t iw = 0; iw < nw; iw++)
     for (uint32_t count = 0; count < ndet_ext; ++count)
     {
       size_t det_id               = det_offset + count;
       ratios_list_ptr[iw][det_id] = sign_ptr[det_id] * ratios_list_ptr[iw][0] *
           CustomizedMatrixDet<EXT_LEVEL>::evaluate(table_matrix_list_ptr[iw],
                                                    (data_ptr + data_offset) + 1 + count * (3 * EXT_LEVEL + 1),
                                                    num_table_matrix_cols);
     }
 }

◆ mw_updateRatios_det0()

void mw_updateRatios_det0	(	const OffloadVector< ValueType > &	det0_list,
		const OffloadVector< ValueType *> &	ratios_deviceptr_list
	)		const

private

update ratios of the reference deteriminant

Parameters

det0_list list of reference det value

Definition at line 1122 of file MultiDiracDeterminant.2.cpp.

References Vector< T, Alloc >::data(), Vector< T, Alloc >::size(), and MultiDiracDeterminant::updateRatios_timer.

Referenced by MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl().

 {
   ScopedTimer local_timer(updateRatios_timer);
 
   const size_t nw           = ratios_deviceptr_list.size();
   auto* ratios_list_ptr     = ratios_deviceptr_list.data();
   const auto* det0_list_ptr = det0_list.data();
 
   PRAGMA_OFFLOAD("omp target teams distribute parallel for map(always, to: det0_list_ptr[:nw])")
   for (uint32_t iw = 0; iw < nw; iw++)
     ratios_list_ptr[iw][0] = det0_list_ptr[iw];
 }

◆ mw_updateRatios_generic()

void mw_updateRatios_generic	(	const int	ext_level,
		const size_t	det_offset,
		const size_t	data_offset,
		SmallMatrixDetCalculator< ValueType > &	det_calculator,
		const OffloadVector< int > &	data,
		const OffloadVector< RealType > &	sign,
		const RefVector< OffloadMatrix< ValueType >> &	table_matrix_list,
		const RefVector< OffloadVector< ValueType >> &	ratios_list
	)		const

private

update ratios with respect to the reference deteriminant for a given excitation level

Parameters

ext_level	excitation level
det_offset	offset of the determinant id
data_offset	offset of the "data" structure
sign	of determinants
table_matrix_list	list of table_matrix

this is a general implementation. Support abitrary excitation level

Definition at line 1102 of file MultiDiracDeterminant.2.cpp.

References Vector< T, Alloc >::data(), SmallMatrixDetCalculator< T >::evaluate(), and sign().

Referenced by MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl().

 {
   const size_t nw = ratios_list.size();
   const int* it2  = data.data() + data_offset;
   for (size_t iw = 0; iw < nw; iw++)
     for (size_t count = 0; count < (*ndets_per_excitation_level_)[ext_level]; ++count)
     {
       size_t det_id                 = det_offset + count;
       ratios_list[iw].get()[det_id] = sign[det_id] * ratios_list[iw].get()[0] *
           det_calculator.evaluate(table_matrix_list[iw].get(), it2 + 1 + count * (3 * ext_level + 1), ext_level);
     }
 }

◆ operator=()

MultiDiracDeterminant& operator= ( const MultiDiracDeterminant & s )

delete

◆ ratio()

PsiValue ratio	(	ParticleSet &	P,
		int	iat
	)

inlineoverridevirtual

evaluate the ratio of the new to old WaveFunctionComponent value

Parameters

P	the active ParticleSet
iat	the index of a particle

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

Specialized for particle-by-particle move

Implements WaveFunctionComponent.

Definition at line 225 of file MultiDiracDeterminant.h.

References APP_ABORT.

   {
     APP_ABORT("  MultiDiracDeterminant: This should not be called. \n");
     return PsiValue();
   }

◆ ratioGrad()

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

inlineoverridevirtual

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

Parameters

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

Reimplemented from WaveFunctionComponent.

Definition at line 237 of file MultiDiracDeterminant.h.

References APP_ABORT.

   {
     APP_ABORT("  MultiDiracDeterminant: This should not be called. \n");
     return PsiValue();
   }

◆ 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 624 of file MultiDiracDeterminant.cpp.

 {
   assert(P.isSpinor() == is_spinor_);
 
   //extra pointers
   FirstAddressOfGrads = &(grads(0, 0)[0]);
   LastAddressOfGrads  = FirstAddressOfGrads + NumPtcls * DIM * getNumDets();
   FirstAddressOfdpsiM = &(dpsiM(0, 0)[0]);
   LastAddressOfdpsiM  = FirstAddressOfdpsiM + NumPtcls * NumOrbitals * DIM;
 
   //add the data:
   buf.add(psiM.first_address(), psiM.last_address());
   buf.add(FirstAddressOfdpsiM, LastAddressOfdpsiM);
   buf.add(d2psiM.first_address(), d2psiM.last_address());
   buf.add(psiMinv.first_address(), psiMinv.last_address());
   buf.add(log_value_ref_det_);
   buf.add(ratios_to_ref_.first_address(), ratios_to_ref_.last_address());
   buf.add(FirstAddressOfGrads, LastAddressOfGrads);
   buf.add(lapls.first_address(), lapls.last_address());
   if (is_spinor_)
   {
     buf.add(dspin_psiM.first_address(), dspin_psiM.last_address());
     buf.add(spingrads.first_address(), spingrads.last_address());
   }
 }

◆ releaseResource()

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

Definition at line 722 of file MultiDiracDeterminant.cpp.

References RefVectorWithLeader< T >::getCastedLeader(), and ResourceCollection::takebackResource().

 {
   auto& wfc_leader = wfc_list.getCastedLeader<MultiDiracDeterminant>();
   collection.takebackResource(wfc_leader.mw_res_handle_);
 }

◆ resize()

void resize ( )

private

reset the size: with the number of particles

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

Definition at line 730 of file MultiDiracDeterminant.cpp.

Referenced by MultiDiracDeterminant::createDetData(), and MultiDiracDeterminant::MultiDiracDeterminant().

 {
   const int nel = NumPtcls;
   assert(NumPtcls > 0);
   const int NumDets = getNumDets();
   assert(NumDets > 0);
 
   psiV_temp.resize(nel);
   psiV.resize(NumOrbitals);
   dpsiV.resize(NumOrbitals);
   d2psiV.resize(NumOrbitals);
   psiM.resize(nel, NumOrbitals);
   dpsiM.resize(nel, NumOrbitals);
   d2psiM.resize(nel, NumOrbitals);
   TpsiM.resize(NumOrbitals, nel);
   psiMinv.resize(nel, nel);
   dpsiMinv.resize(nel, nel);
   psiMinv_temp.resize(nel, nel);
   //scratch spaces: stateless
   WorkSpace.resize(std::max(nel, NumDets));
   Pivot.resize(nel);
   workV1.resize(nel);
   workV2.resize(nel);
   ratios_to_ref_.resize(NumDets);
   new_ratios_to_ref_.resize(NumDets);
   grads.resize(NumDets, nel);
   new_grads.resize(NumDets, nel);
   lapls.resize(NumDets, nel);
   new_lapls.resize(NumDets, nel);
   table_matrix.resize(NumOrbitals, NumOrbitals);
   det_calculator_.resize(nel);
 
   if (is_spinor_)
   {
     dspin_psiV.resize(NumOrbitals);
     dspin_psiM.resize(nel, NumOrbitals);
     spingrads.resize(NumDets, nel);
     new_spingrads.resize(NumDets, nel);
   }
 }

◆ restore()

void restore ( int iat )

overridevirtual

move was rejected.

copy the real container to the temporary to move on

Implements WaveFunctionComponent.

Definition at line 496 of file MultiDiracDeterminant.cpp.

References MultiDiracDeterminant::curRatio, MultiDiracDeterminant::FirstIndex, MultiDiracDeterminant::LastIndex, MultiDiracDeterminant::NumOrbitals, MultiDiracDeterminant::psiM, MultiDiracDeterminant::psiMinv, MultiDiracDeterminant::psiMinv_temp, MultiDiracDeterminant::TpsiM, and MultiDiracDeterminant::transferH2D_timer.

 {
   const int WorkingIndex = iat - FirstIndex;
   assert(WorkingIndex >= 0 && WorkingIndex < LastIndex - FirstIndex);
   psiMinv_temp = psiMinv;
   for (int i = 0; i < NumOrbitals; i++)
     TpsiM(i, WorkingIndex) = psiM(WorkingIndex, i);
   {
     ScopedTimer local_timer(transferH2D_timer);
     TpsiM.updateTo();
   }
   curRatio = ValueType(1);
   /*
       switch(UpdateMode)
       {
         case ORB_PBYP_RATIO:
           psiMinv_temp = psiMinv;
           for(int i=0; i<NumOrbitals; i++)
             TpsiM(i,WorkingIndex) = psiM(WorkingIndex,i);
           break;
         case ORB_PBYP_PARTIAL:
           psiMinv_temp = psiMinv;
           for(int i=0; i<NumOrbitals; i++)
             TpsiM(i,WorkingIndex) = psiM(WorkingIndex,i);
           break;
         default:
           break;
       }
   */
 }

◆ updateBuffer()

MultiDiracDeterminant::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 361 of file MultiDiracDeterminant.cpp.

 {
   assert(P.isSpinor() == is_spinor_);
   if (is_spinor_)
     evaluateForWalkerMoveWithSpin(P, (fromscratch || UpdateMode == ORB_PBYP_RATIO));
   else
     evaluateForWalkerMove(P, (fromscratch || UpdateMode == ORB_PBYP_RATIO));
   buf.put(psiM.first_address(), psiM.last_address());
   buf.put(FirstAddressOfdpsiM, LastAddressOfdpsiM);
   buf.put(d2psiM.first_address(), d2psiM.last_address());
   buf.put(psiMinv.first_address(), psiMinv.last_address());
   buf.put(log_value_ref_det_);
   buf.put(ratios_to_ref_.first_address(), ratios_to_ref_.last_address());
   buf.put(FirstAddressOfGrads, LastAddressOfGrads);
   buf.put(lapls.first_address(), lapls.last_address());
   if (is_spinor_)
   {
     buf.put(dspin_psiM.first_address(), dspin_psiM.last_address());
     buf.put(spingrads.first_address(), spingrads.last_address());
   }
   return 1.0;
 }

Member Data Documentation

◆ buildTable_timer

NewTimer & buildTable_timer

Definition at line 36 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateRatios_impl(), and MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl().

◆ calculateGradRatios_timer

NewTimer & calculateGradRatios_timer

Definition at line 38 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateGradRatios(), and MultiDiracDeterminant::mw_buildTableMatrix_calculateGradRatios().

◆ calculateRatios_timer

NewTimer & calculateRatios_timer

Definition at line 38 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateRatios(), and MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios().

◆ ciConfigList

std::shared_ptr<std::vector<ci_configuration2> > ciConfigList

private

use shared_ptr

Definition at line 526 of file MultiDiracDeterminant.h.

◆ curRatio

ValueType curRatio

private

new value of the reference determinant over the old value upon a proposed move

Definition at line 574 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), MultiDiracDeterminant::getRefDetRatio(), and MultiDiracDeterminant::restore().

◆ d2psiM

OffloadMatrix<ValueType> d2psiM

private

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

Definition at line 544 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::copyFromBuffer(), MultiDiracDeterminant::evaluateDerivatives(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::registerData(), MultiDiracDeterminant::resize(), and MultiDiracDeterminant::updateBuffer().

◆ d2psiV

OffloadVector<ValueType> d2psiV

private

Definition at line 554 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), and MultiDiracDeterminant::resize().

◆ det_calculator_

SmallMatrixDetCalculator<ValueType> det_calculator_

private

Definition at line 600 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateRatios_impl(), MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl(), and MultiDiracDeterminant::resize().

◆ detData

std::shared_ptr<OffloadVector<int> > detData

private

Definition at line 593 of file MultiDiracDeterminant.h.

◆ DetSigns

std::shared_ptr<OffloadVector<RealType> > DetSigns

private

Definition at line 595 of file MultiDiracDeterminant.h.

◆ dpsiM

OffloadMatrix<GradType> dpsiM

private

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

Definition at line 540 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDerivatives(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGrads(), MultiDiracDeterminant::evaluateGradsWithSpin(), MultiDiracDeterminant::registerData(), and MultiDiracDeterminant::resize().

◆ dpsiMinv

OffloadMatrix<ValueType> dpsiMinv

private

Definition at line 542 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGrads(), MultiDiracDeterminant::evaluateGradsWithSpin(), and MultiDiracDeterminant::resize().

◆ dpsiV

OffloadVector<GradType> dpsiV

private

Definition at line 553 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), and MultiDiracDeterminant::resize().

◆ dspin_psiM

ValueMatrix dspin_psiM

private

Definition at line 548 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::copyFromBuffer(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGradsWithSpin(), MultiDiracDeterminant::registerData(), MultiDiracDeterminant::resize(), and MultiDiracDeterminant::updateBuffer().

◆ dspin_psiV

ValueVector dspin_psiV

private

Definition at line 557 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), and MultiDiracDeterminant::resize().

◆ evalOrbValue_timer

NewTimer & evalOrbValue_timer

Definition at line 36 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsForPtclMove(), and MultiDiracDeterminant::mw_evaluateDetsForPtclMove().

◆ evalOrbVGL_timer

NewTimer & evalOrbVGL_timer

Definition at line 36 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), and MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove().

◆ evaluateDetsAndGradsForPtclMove_timer

NewTimer & evaluateDetsAndGradsForPtclMove_timer

Definition at line 39 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), and MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove().

◆ evaluateDetsForPtclMove_timer

NewTimer& evaluateDetsForPtclMove_timer

Definition at line 39 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsForPtclMove(), and MultiDiracDeterminant::mw_evaluateDetsForPtclMove().

◆ evaluateGrads_timer

NewTimer & evaluateGrads_timer

Definition at line 39 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::mw_evaluateGrads().

◆ evalWalker_timer

NewTimer & evalWalker_timer

Definition at line 36 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateForWalkerMove(), and MultiDiracDeterminant::evaluateForWalkerMoveWithSpin().

◆ FirstAddressOfdpsiM

ValueType* FirstAddressOfdpsiM

private

Definition at line 566 of file MultiDiracDeterminant.h.

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

◆ FirstAddressOfGrads

ValueType* FirstAddressOfGrads

private

Definition at line 564 of file MultiDiracDeterminant.h.

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

◆ FirstIndex

const int FirstIndex

private

index of the first particle with respect to the particle set

Definition at line 520 of file MultiDiracDeterminant.h.

◆ grads

Matrix<GradType> grads

private

store determinant grads (old and new)

Definition at line 578 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::buildTableMatrix_calculateGradRatios(), MultiDiracDeterminant::evaluateDerivatives(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGrads(), MultiDiracDeterminant::evaluateGradsWithSpin(), MultiDiracDeterminant::getGrads(), MultiDiracDeterminant::registerData(), and MultiDiracDeterminant::resize().

◆ inverse_timer

NewTimer& inverse_timer

Definition at line 36 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateForWalkerMove(), and MultiDiracDeterminant::evaluateForWalkerMoveWithSpin().

◆ is_spinor_

const bool is_spinor_

private

Definition at line 532 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::copyFromBuffer(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateGradsWithSpin(), MultiDiracDeterminant::registerData(), MultiDiracDeterminant::resize(), and MultiDiracDeterminant::updateBuffer().

◆ lapls

Matrix<ValueType> lapls

private

store determinant lapls (old and new)

Definition at line 580 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::copyFromBuffer(), MultiDiracDeterminant::evaluateDerivatives(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::getLapls(), MultiDiracDeterminant::registerData(), MultiDiracDeterminant::resize(), and MultiDiracDeterminant::updateBuffer().

◆ LastAddressOfdpsiM

ValueType* LastAddressOfdpsiM

private

Definition at line 567 of file MultiDiracDeterminant.h.

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

◆ LastAddressOfGrads

ValueType* LastAddressOfGrads

private

Definition at line 565 of file MultiDiracDeterminant.h.

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

◆ LastIndex

const int LastIndex

private

index of the last particle with respect to the particle set

Definition at line 524 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGrads(), MultiDiracDeterminant::evaluateGradsWithSpin(), and MultiDiracDeterminant::restore().

◆ log_value_ref_det_

LogValue log_value_ref_det_

private

log value of the reference determinant

Definition at line 576 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::copyFromBuffer(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::getLogValueRefDet(), MultiDiracDeterminant::registerData(), and MultiDiracDeterminant::updateBuffer().

◆ lookup_tbl

std::vector<std::vector<int> > lookup_tbl

Definition at line 120 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::buildOptVariables(), MultiDiracDeterminant::evaluateDerivatives(), and MultiDiracDeterminant::evaluateDerivativesWF().

◆ MaxSmallDet

constexpr size_t MaxSmallDet = 5

staticprivate

for matrices with leading dimensions <= MaxSmallDet, compute determinant with direct expansion.

Definition at line 603 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateRatios_impl().

◆ mw_res_handle_

ResourceHandle<MultiDiracDetMultiWalkerResource> mw_res_handle_

private

Definition at line 605 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acquireResource(), MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::mw_evaluateDetsForPtclMove(), and MultiDiracDeterminant::mw_evaluateGrads().

◆ myVars

opt_variables_type myVars

Definition at line 43 of file MultiDiracDeterminant.h.

◆ ndets_per_excitation_level_

std::shared_ptr<std::vector<int> > ndets_per_excitation_level_

private

number of unique determinants at each excitation level (relative to reference) {1, n_singles, n_doubles, n_triples, ...}

Definition at line 599 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::createDetData(), MultiDiracDeterminant::MultiDiracDeterminant(), and MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl().

◆ new_grads

Matrix<GradType> new_grads

private

Definition at line 578 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::getNewGrads(), and MultiDiracDeterminant::resize().

◆ new_lapls

Matrix<ValueType> new_lapls

private

Definition at line 580 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::getNewLapls(), and MultiDiracDeterminant::resize().

◆ new_ratios_to_ref_

OffloadVector<ValueType> new_ratios_to_ref_

private

new determinant ratios with respect to the updated reference determinant upon a proposed move

Definition at line 572 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), MultiDiracDeterminant::getNewRatiosToRefDet(), and MultiDiracDeterminant::resize().

◆ new_spingrads

Matrix<ValueType> new_spingrads

private

Definition at line 582 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::getNewSpinGrads(), and MultiDiracDeterminant::resize().

◆ NumOrbitals

const int NumOrbitals

private

number of single-particle orbitals which belong to this Dirac determinant

Definition at line 518 of file MultiDiracDeterminant.h.

◆ NumPtcls

const int NumPtcls

private

number of particles which belong to this Dirac determinant

Definition at line 522 of file MultiDiracDeterminant.h.

◆ offload_timer

NewTimer& offload_timer

Definition at line 40 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl().

◆ Phi

const std::unique_ptr<SPOSet> Phi

private

a set of single-particle orbitals used to fill in the values of the matrix

Definition at line 516 of file MultiDiracDeterminant.h.

◆ Pivot

Vector<IndexType> Pivot

private

Definition at line 562 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), and MultiDiracDeterminant::resize().

◆ psiM

OffloadMatrix<ValueType> psiM

private

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

Definition at line 536 of file MultiDiracDeterminant.h.

◆ psiMinv

OffloadMatrix<ValueType> psiMinv

private

inverse Dirac determinant matrix of the reference det

Definition at line 538 of file MultiDiracDeterminant.h.

◆ psiMinv_temp

OffloadMatrix<ValueType> psiMinv_temp

private

Definition at line 538 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::copyFromBuffer(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::resize(), and MultiDiracDeterminant::restore().

◆ psiV

OffloadVector<ValueType> psiV

private

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

Definition at line 552 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), and MultiDiracDeterminant::resize().

◆ psiV_temp

OffloadVector<ValueType> psiV_temp

private

Definition at line 552 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGrads(), MultiDiracDeterminant::evaluateGradsWithSpin(), and MultiDiracDeterminant::resize().

◆ ratios_to_ref_

OffloadVector<ValueType> ratios_to_ref_

private

determinant ratios with respect to the reference determinant

Definition at line 570 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::copyFromBuffer(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::getRatiosToRefDet(), MultiDiracDeterminant::registerData(), MultiDiracDeterminant::resize(), and MultiDiracDeterminant::updateBuffer().

◆ refdet_occup

std::shared_ptr<OffloadVector<size_t> > refdet_occup

private

reference determinant occupation

Definition at line 530 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::createDetData(), MultiDiracDeterminant::MultiDiracDeterminant(), MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::mw_evaluateDetsForPtclMove(), and MultiDiracDeterminant::mw_evaluateGrads().

◆ ReferenceDeterminant

constexpr int ReferenceDeterminant = 0

staticprivate

all the unique determinants are sorted, the id of the reference det id is always 0

Definition at line 528 of file MultiDiracDeterminant.h.

◆ spingrads

Matrix<ValueType> spingrads

private

Definition at line 582 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::copyFromBuffer(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGradsWithSpin(), MultiDiracDeterminant::getSpinGrads(), MultiDiracDeterminant::registerData(), MultiDiracDeterminant::resize(), and MultiDiracDeterminant::updateBuffer().

◆ table2ratios_timer

NewTimer & table2ratios_timer

Definition at line 36 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateRatios_impl(), and MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios_impl().

◆ table_matrix

OffloadMatrix<ValueType> table_matrix

private

Definition at line 559 of file MultiDiracDeterminant.h.

◆ TpsiM

OffloadMatrix<ValueType> TpsiM

private

Definition at line 536 of file MultiDiracDeterminant.h.

◆ transferD2H_timer

NewTimer & transferD2H_timer

Definition at line 40 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::mw_buildTableMatrix_calculateRatios(), MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), and MultiDiracDeterminant::mw_evaluateDetsForPtclMove().

◆ transferH2D_timer

NewTimer & transferH2D_timer

Definition at line 40 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::acceptMove(), MultiDiracDeterminant::createDetData(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::mw_evaluateDetsAndGradsForPtclMove(), and MultiDiracDeterminant::restore().

◆ uniquePairs

std::shared_ptr<VectorSoaContainer<int, 2, OffloadPinnedAllocator<int> > > uniquePairs

private

Definition at line 594 of file MultiDiracDeterminant.h.

◆ updateInverse_timer

NewTimer& updateInverse_timer

Definition at line 38 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), and MultiDiracDeterminant::mw_InverseUpdateByColumn().

◆ updateRatios_timer

NewTimer & updateRatios_timer

Definition at line 38 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::mw_updateRatios(), and MultiDiracDeterminant::mw_updateRatios_det0().

◆ WorkSpace

OffloadVector<ValueType> WorkSpace

private

Definition at line 561 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::buildTableMatrix_calculateGradRatios(), MultiDiracDeterminant::buildTableMatrix_calculateRatiosValueMatrixOneParticle(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), and MultiDiracDeterminant::resize().

◆ workV1

OffloadVector<ValueType> workV1

private

Definition at line 555 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGrads(), MultiDiracDeterminant::evaluateGradsWithSpin(), and MultiDiracDeterminant::resize().

◆ workV2

OffloadVector<ValueType> workV2

private

Definition at line 555 of file MultiDiracDeterminant.h.

Referenced by MultiDiracDeterminant::evaluateDetsAndGradsForPtclMove(), MultiDiracDeterminant::evaluateDetsAndGradsForPtclMoveWithSpin(), MultiDiracDeterminant::evaluateDetsForPtclMove(), MultiDiracDeterminant::evaluateForWalkerMove(), MultiDiracDeterminant::evaluateForWalkerMoveWithSpin(), MultiDiracDeterminant::evaluateGrads(), MultiDiracDeterminant::evaluateGradsWithSpin(), and MultiDiracDeterminant::resize().

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

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ OffloadMatrix

◆ OffloadVector

◆ UnpinnedOffloadMatrix

◆ UnpinnedOffloadVector

◆ ValueMatrix

◆ ValueVector

Constructor & Destructor Documentation

◆ MultiDiracDeterminant() [1/2]

◆ ~MultiDiracDeterminant()

◆ MultiDiracDeterminant() [2/2]

Member Function Documentation

◆ acceptMove()

◆ acquireResource()

◆ build_occ_vec()

◆ buildOptVariables()

◆ buildTableMatrix_calculateGradRatios()

◆ buildTableMatrix_calculateRatios()

◆ buildTableMatrix_calculateRatios_impl()

◆ buildTableMatrix_calculateRatiosValueMatrixOneParticle()

◆ checkOutVariables()

◆ clonePhi()

◆ copyFromBuffer()

◆ createDetData()

◆ createResource()

◆ evalGrad()

◆ evaluate()

◆ evaluateDerivatives() [1/2]

◆ evaluateDerivatives() [2/2]

◆ evaluateDerivativesWF()

◆ evaluateDetsAndGradsForPtclMove()

◆ evaluateDetsAndGradsForPtclMoveWithSpin()

◆ evaluateDetsForPtclMove()

◆ evaluateForWalkerMove()

◆ evaluateForWalkerMoveWithSpin()

◆ evaluateGrads()

◆ evaluateGradsWithSpin()

◆ evaluateLog()

◆ extractOptimizableObjectRefs()

◆ getClassName()

◆ getFirstIndex()

◆ getGrads()

◆ getLapls()

◆ getLogValueRefDet()

◆ getNewGrads()

◆ getNewLapls()

◆ getNewRatiosToRefDet()

◆ getNewSpinGrads()

◆ getNumDets()

◆ getNumPtcls()

◆ getPhi()

◆ getRatiosToRefDet()

◆ getRefDetRatio()

◆ getSpinGrads()

◆ isFermionic()

◆ isOptimizable()

◆ makeClone()

◆ mw_accept_rejectMove()

◆ mw_buildTableMatrix_calculateGradRatios()

◆ mw_buildTableMatrix_calculateRatios()

◆ mw_buildTableMatrix_calculateRatios_impl()

◆ mw_evaluateDetsAndGradsForPtclMove()

◆ mw_evaluateDetsForPtclMove()

◆ mw_evaluateGrads()

◆ mw_InverseUpdateByColumn()

◆ mw_updateRatios()

◆ mw_updateRatios_det0()

◆ mw_updateRatios_generic()

◆ operator=()

◆ ratio()