Classes to handle many-body trial wave functions. More...

Classes
class	TrialWaveFunction
	Class to represent a many-body trial wave function. More...

Detailed Description

Classes to handle many-body trial wave functions.

Class Documentation

◆ qmcplusplus::TrialWaveFunction

class qmcplusplus::TrialWaveFunction

Class to represent a many-body trial wave function.

A many-body trial wave function is represented by $\Psi({\bf R}) = \prod_i \psi_i({\bf R})$ , where each function $\psi_i({\bf R})$ is an WaveFunctionComponent (see WaveFunctionComponent). A Composite Pattern is used to handle $\prod$ operations. Each WaveFunctionComponent should provide proper evaluate functions for the value, gradient and laplacian values.

mw_ prefix is a function name signature indicating it is for handling a batch of TrialWaveFunction objects in a lock-step fashion. These functions are defined statically because they should not have access to a concrete TWF object except through the passed RefVectorWithLeader<TWF>&. It dispatches to mw_ functions of WaveFunctionComponent

Definition at line 60 of file TrialWaveFunction.h.

Collaboration diagram for TrialWaveFunction:

Public Types
enum	ComputeType { ALL, FERMIONIC, NONFERMIONIC }
	enum type for computing partial WaveFunctionComponents More...

using	RealType = WaveFunctionComponent::RealType

using	ComplexType = WaveFunctionComponent::ComplexType

using	FullPrecRealType = WaveFunctionComponent::FullPrecRealType

using	ValueType = WaveFunctionComponent::ValueType

using	ValueVector = WaveFunctionComponent::ValueVector

using	GradType = WaveFunctionComponent::GradType

using	BufferType = WaveFunctionComponent::BufferType

using	WFBufferType = WaveFunctionComponent::WFBufferType

using	HessType = WaveFunctionComponent::HessType

using	HessVector = WaveFunctionComponent::HessVector

using	LogValue = WaveFunctionComponent::LogValue

using	PsiValue = WaveFunctionComponent::PsiValue

using	SPOMap = SPOSet::SPOMap

Public Member Functions
	TrialWaveFunction (const RuntimeOptions &runtime_options, const std::string_view aname="psi0", bool tasking=false)

	TrialWaveFunction (const TrialWaveFunction &)=delete

TrialWaveFunction &	operator= (const TrialWaveFunction &)=delete

	~TrialWaveFunction ()
	Destructor. More...

int	size () const

RealType	getPhase () const

void	setPhase (RealType PhaseValue_new)

void	getLogs (std::vector< RealType > &lvals)

void	getPhases (std::vector< RealType > &pvals)

RealType	getPhaseDiff () const

void	resetPhaseDiff ()

RealType	getLogPsi () const

void	setLogPsi (RealType LogPsi_new)

void	addComponent (std::unique_ptr< WaveFunctionComponent > &&aterm)
	add a WaveFunctionComponent More...

bool	put (xmlNodePtr cur)
	read from xmlNode More...

UniqueOptObjRefs	extractOptimizableObjectRefs ()
	extract underlying OptimizableObject references More...

void	checkInVariables (opt_variables_type &o)
	Check in an optimizable parameter. More...

void	checkOutVariables (const opt_variables_type &o)
	Check out optimizable variables Assign index mappings from global list (o) to local values in each component. More...

void	resetParameters (const opt_variables_type &active)
	Set values of parameters in each component from the global list. More...

void	reportStatus (std::ostream &os)
	print out state of the trial wavefunction More...

void	initializeTWFFastDerivWrapper (const ParticleSet &P, TWFFastDerivWrapper &twf) const
	Initialize a TWF wrapper for fast derivative evaluation. More...

RealType	evaluateLog (ParticleSet &P)
	evalaute the log (internally gradients and laplacian) of the trial wavefunction. More...

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

RealType	evaluateDeltaLog (ParticleSet &P, bool recompute=false)
	evaluate the log value of a many-body wave function More...

void	evaluateDeltaLogSetup (ParticleSet &P, RealType &logpsi_fixed, RealType &logpsi_opt, ParticleSet::ParticleGradient &fixedG, ParticleSet::ParticleLaplacian &fixedL)
	evaluate the sum of log value of optimizable many-body wavefunctions More...

ValueType	calcRatio (ParticleSet &P, int iat, ComputeType ct=ComputeType::ALL)
	compute psi(R_new) / psi(R_current) ratio It returns a complex value if the wavefunction is complex. More...

void	evaluateRatios (const VirtualParticleSet &VP, std::vector< ValueType > &ratios, ComputeType ct=ComputeType::ALL)
	compulte multiple ratios to handle non-local moves and other virtual moves More...

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

void	evaluateDerivRatios (const VirtualParticleSet &VP, const opt_variables_type &optvars, std::vector< ValueType > &ratios, Matrix< ValueType > &dratio)
	compute both ratios and deriatives of ratio with respect to the optimizables More...

void	printGL (ParticleSet::ParticleGradient &G, ParticleSet::ParticleLaplacian &L, std::string tag="GL")

GradType	evalGradSource (ParticleSet &P, ParticleSet &source, int iat)
	Returns the logarithmic gradient of the trial wave function with respect to the iat^th atom of the source ParticleSet. More...

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

ValueType	calcRatioGrad (ParticleSet &P, int iat, GradType &grad_iat)
	compute psi(R_new) / psi(R_current) ratio and ln(psi(R_new)) gradients It returns a complex value if the wavefunction is complex. More...

ValueType	calcRatioGradWithSpin (ParticleSet &P, int iat, GradType &grad_iat, ComplexType &spingrad_iat)
	compute psi(R_new) / psi(R_current) ratio and d/ds ln(psi(R_new)) spin gradient It returns a complex value if the wavefunction is complex. More...

void	prepareGroup (ParticleSet &P, int ig)
	Prepare internal data for updating WFC correspond to a particle group Particle groups usually correspond to determinants of different spins. More...

GradType	evalGrad (ParticleSet &P, int iat)

GradType	evalGradWithSpin (ParticleSet &P, int iat, ComplexType &spingrad)
	compute d/ds ln(psi) spin gradient at current particle position for iat electron More...

void	rejectMove (int iat)
	restore to the original state More...

void	acceptMove (ParticleSet &P, int iat, bool safe_to_delay=false)
	update the state with the new data More...

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

LogValue	evaluateGL (ParticleSet &P, bool fromscratch)
	compute gradients and laplacian of the TWF with respect to each particle. More...

void	registerData (ParticleSet &P, WFBufferType &buf)
	register all the wavefunction components in buffer. More...

RealType	updateBuffer (ParticleSet &P, WFBufferType &buf, bool fromscratch=false)
	update all the wavefunction components in buffer. More...

void	copyFromBuffer (ParticleSet &P, WFBufferType &buf)
	copy all the wavefunction components from buffer. More...

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

RealType	KECorrection () const

void	evaluateDerivatives (ParticleSet &P, const opt_variables_type &optvars, Vector< ValueType > &dlogpsi, Vector< ValueType > &dhpsioverpsi)
	evaluate derivatives of KE wrt optimizable varibles More...

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

void	evaluateGradDerivatives (const ParticleSet::ParticleGradient &G_in, std::vector< ValueType > &dgradlogpsi)

void	evaluateHessian (ParticleSet &P, HessVector &all_grad_grad_psi)
	evaluate the hessian w.r.t. More...

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

std::vector< std::unique_ptr< WaveFunctionComponent > > const &	getOrbitals ()

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

void	setTwist (const std::vector< RealType > &t)

void	setTwist (std::vector< RealType > &&t)

const std::vector< RealType > &	twist () const

void	setMassTerm (ParticleSet &P)

RealType	getReciprocalMass ()

const std::string &	getName () const

bool	use_tasking () const

void	storeXMLNode (xmlNodePtr node)

xmlNodePtr	getNode () const

void	storeSPOMap (SPOMap &&spomap)
	store an SPOSet map More...

const SPOSet &	getSPOSet (const std::string &name) const
	look up SPOSet named 'name', if not found, throw exception. More...

const SPOMap &	getSPOMap () const
	spomap_ reference accessor More...

RefVector< MultiSlaterDetTableMethod >	findMSD () const
	find MSD WFCs if exist More...

Static Public Member Functions
static void	mw_evaluateLog (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list)
	batched version of evaluateLog. More...

static void	mw_recompute (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< bool > &recompute)
	batched version of recompute More...

static void	mw_evaluateDeltaLogSetup (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, std::vector< RealType > &logpsi_fixed_list, std::vector< RealType > &logpsi_opt_list, RefVector< ParticleSet::ParticleGradient > &fixedG_list, RefVector< ParticleSet::ParticleLaplacian > &fixedL_list)
	evaluate the sum of log value of optimizable many-body wavefunctions More...

static void	mw_evaluateDeltaLog (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, std::vector< RealType > &logpsi_list, RefVector< ParticleSet::ParticleGradient > &dummyG_list, RefVector< ParticleSet::ParticleLaplacian > &dummyL_list, bool recompute=false)
	evaluate the log value for optimizable parts of a many-body wave function More...

static void	mw_calcRatio (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, std::vector< PsiValue > &ratios, ComputeType ct=ComputeType::ALL)
	batched version of calcRatio More...

static void	mw_evaluateRatios (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< const VirtualParticleSet > &Vp_list, const RefVector< std::vector< ValueType >> &ratios_list, ComputeType ct=ComputeType::ALL)
	batched version of evaluateRatios Note: unlike other mw_ static functions, *this is the batch leader instead of wf_list[0]. More...

template<CoordsType CT>
static void	mw_calcRatioGrad (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, std::vector< PsiValue > &ratios, TWFGrads< CT > &grads)
	batched version of ratioGrad More...

static void	mw_prepareGroup (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, int ig)
	batched version of prepareGroup More...

template<CoordsType CT>
static void	mw_evalGrad (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, TWFGrads< CT > &grads)
	batched version of evalGrad More...

static void	mw_accept_rejectMove (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, int iat, const std::vector< bool > &isAccepted, bool safe_to_delay=false)

static void	mw_completeUpdates (const RefVectorWithLeader< TrialWaveFunction > &wf_list)

static void	mw_evaluateGL (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, bool fromscratch)

static void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< TrialWaveFunction > &wf_list)
	acquire external resource Note: use RAII ResourceCollectionLock whenever possible More...

static void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< TrialWaveFunction > &wf_list)
	release external resource Note: use RAII ResourceCollectionLock whenever possible More...

static void	mw_evaluateParameterDerivatives (const RefVectorWithLeader< TrialWaveFunction > &wf_list, const RefVectorWithLeader< ParticleSet > &p_list, const opt_variables_type &optvars, RecordArray< ValueType > &dlogpsi, RecordArray< ValueType > &dhpsioverpsi)

Public Attributes
ParticleSet::ParticleGradient	G
	differential gradients More...

ParticleSet::ParticleLaplacian	L
	differential laplacians More...

Static Private Member Functions
static void	debugOnlyCheckBuffer (WFBufferType &buffer)


static std::vector< WaveFunctionComponent * >	extractWFCPtrList (const UPtrVector< TrialWaveFunction > &wf_list, int id)
	helper function for extracting a list of WaveFunctionComponent from a list of TrialWaveFunction More...

static RefVectorWithLeader< WaveFunctionComponent >	extractWFCRefList (const RefVectorWithLeader< TrialWaveFunction > &wf_list, int id)

static RefVector< ParticleSet::ParticleGradient >	extractGRefList (const RefVectorWithLeader< TrialWaveFunction > &wf_list)
	}@ More...

static RefVector< ParticleSet::ParticleLaplacian >	extractLRefList (const RefVectorWithLeader< TrialWaveFunction > &wf_list)

Private Attributes
const RuntimeOptions &	runtime_options_
	top-level runtime options from project data information > WaveFunctionPool More...

xmlNodePtr	myNode_
	XML input node for a many-body wavefunction. More...

const std::shared_ptr< SPOMap >	spomap_
	Owned SPOSets. Once a TWF is fully built, SPOSet lookup should be done via TWF. More...

const std::string	myName
	getName is in the way More...

size_t	BufferCursor
	starting index of the buffer More...

size_t	BufferCursor_scalar
	starting index of the scalar buffer More...

RealType	PhaseValue
	sign of the trial wave function More...

RealType	PhaseDiff
	diff of the phase of the trial wave function during ratio calls More...

RealType	log_real_
	real part of trial wave function log More...

RealType	OneOverM
	One over mass of target particleset, needed for Local Energy Derivatives. More...

const bool	use_tasking_
	if true, using internal tasking implementation More...

std::vector< std::unique_ptr< WaveFunctionComponent > >	Z
	a list of WaveFunctionComponents constituting many-body wave functions More...

TWFFastDerivWrapper	twf_prototype
	For now, TrialWaveFunction will own the wrapper. More...

TimerList_t	TWF_timers_
	timers at TrialWaveFunction function call level More...

std::vector< std::reference_wrapper< NewTimer > >	WFC_timers_
	timers at WaveFunctionComponent function call level More...

std::vector< RealType >	myTwist

Member Typedef Documentation

◆ BufferType

using BufferType = WaveFunctionComponent::BufferType

Definition at line 74 of file TrialWaveFunction.h.

◆ ComplexType

using ComplexType = WaveFunctionComponent::ComplexType

Definition at line 65 of file TrialWaveFunction.h.

◆ FullPrecRealType

using FullPrecRealType = WaveFunctionComponent::FullPrecRealType

Definition at line 68 of file TrialWaveFunction.h.

◆ GradType

using GradType = WaveFunctionComponent::GradType

Definition at line 73 of file TrialWaveFunction.h.

◆ HessType

using HessType = WaveFunctionComponent::HessType

Definition at line 76 of file TrialWaveFunction.h.

◆ HessVector

using HessVector = WaveFunctionComponent::HessVector

Definition at line 77 of file TrialWaveFunction.h.

◆ LogValue

using LogValue = WaveFunctionComponent::LogValue

Definition at line 78 of file TrialWaveFunction.h.

◆ PsiValue

using PsiValue = WaveFunctionComponent::PsiValue

Definition at line 79 of file TrialWaveFunction.h.

◆ RealType

using RealType = WaveFunctionComponent::RealType

Definition at line 64 of file TrialWaveFunction.h.

◆ SPOMap

using SPOMap = SPOSet::SPOMap

Definition at line 81 of file TrialWaveFunction.h.

◆ ValueType

using ValueType = WaveFunctionComponent::ValueType

Definition at line 71 of file TrialWaveFunction.h.

◆ ValueVector

using ValueVector = WaveFunctionComponent::ValueVector

Definition at line 72 of file TrialWaveFunction.h.

◆ WFBufferType

using WFBufferType = WaveFunctionComponent::WFBufferType

Definition at line 75 of file TrialWaveFunction.h.

Member Enumeration Documentation

◆ ComputeType

enum ComputeType

strong

enum type for computing partial WaveFunctionComponents

Enumerator
ALL
FERMIONIC
NONFERMIONIC

Definition at line 84 of file TrialWaveFunction.h.

   {
     ALL,
     FERMIONIC,
     NONFERMIONIC
   };

Constructor & Destructor Documentation

◆ TrialWaveFunction() [1/2]

TrialWaveFunction	(	const RuntimeOptions &	runtime_options,
		const std::string_view	aname = `"psi0"`,
		bool	tasking = `false`
	)

Definition at line 56 of file TrialWaveFunction.cpp.

References qmcplusplus::suffixes, and qmcplusplus::TIMER_SKIP.

     : runtime_options_(runtime_options),
       myNode_(NULL),
       spomap_(std::make_shared<SPOMap>()),
       myName(aname),
       BufferCursor(0),
       BufferCursor_scalar(0),
       PhaseValue(0.0),
       PhaseDiff(0.0),
       log_real_(0.0),
       OneOverM(1.0),
       use_tasking_(tasking),
       TWF_timers_(getGlobalTimerManager(), create_names(aname), timer_level_medium)
 {
   if (suffixes.size() != TIMER_SKIP)
     throw std::runtime_error("TrialWaveFunction::TrialWaveFunction mismatched timer enums and suffixes");
 }

◆ TrialWaveFunction() [2/2]

TrialWaveFunction ( const TrialWaveFunction & )

delete

◆ ~TrialWaveFunction()

~TrialWaveFunction ( )

Destructor.

Warning: Have not decided whether Z is cleaned up by TrialWaveFunction or not. It will depend on I/O implementation.

Definition at line 79 of file TrialWaveFunction.cpp.

References TrialWaveFunction::myNode_.

 {
   if (myNode_ != NULL)
     xmlFreeNode(myNode_);
 }

Member Function Documentation

◆ acceptMove()

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

update the state with the new data

Parameters

P	ParticleSet
iat	index of the particle with a trial move

The proposed move of the iath particle is accepted. All the temporary data should be incorporated so that the next move is valid.

Definition at line 758 of file TrialWaveFunction.cpp.

References qmcplusplus::ACCEPT_TIMER, TrialWaveFunction::log_real_, TrialWaveFunction::PhaseDiff, TrialWaveFunction::PhaseValue, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), NonLocalECPComponent::evaluateOneWithForces(), SOECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::evaluateValueAndDerivatives(), NonLocalECPotential::makeNonLocalMovesPbyP(), WaveFunctionTester::runRatioTest(), qmcplusplus::TEST_CASE(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   ScopedTimer local_timer(TWF_timers_[ACCEPT_TIMER]);
   PRAGMA_OMP_TASKLOOP("omp taskloop default(shared) if (use_tasking_)")
   for (int i = 0; i < Z.size(); i++)
   {
     ScopedTimer z_timer(WFC_timers_[ACCEPT_TIMER + TIMER_SKIP * i]);
     Z[i]->acceptMove(P, iat, safe_to_delay);
   }
   PhaseValue += PhaseDiff;
   PhaseDiff = 0.0;
   log_real_ = 0;
   for (int i = 0; i < Z.size(); i++)
     log_real_ += std::real(Z[i]->get_log_value());
 }

◆ acquireResource()

void acquireResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list
	)

static

acquire external resource Note: use RAII ResourceCollectionLock whenever possible

Definition at line 1210 of file TrialWaveFunction.cpp.

References TrialWaveFunction::extractWFCRefList(), and RefVectorWithLeader< T >::getLeader().

 {
   auto& wf_leader               = wf_list.getLeader();
   auto& wavefunction_components = wf_leader.Z;
   const int num_wfc             = wf_leader.Z.size();
   for (int i = 0; i < num_wfc; ++i)
   {
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->acquireResource(collection, wfc_list);
   }
 }

◆ addComponent()

void addComponent ( std::unique_ptr< WaveFunctionComponent > && aterm )

add a WaveFunctionComponent

Takes owndership of aterm.

Parameters

aterm a WaveFunctionComponent pointer

Definition at line 87 of file TrialWaveFunction.cpp.

References qmcplusplus::app_log(), qmcplusplus::createGlobalTimer(), qmcplusplus::suffixes, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by qmcplusplus::doSOECPotentialTest(), qmcplusplus::TEST_CASE(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   std::string aname = aterm->getClassName();
   if (!aterm->getName().empty())
     aname += ":" + aterm->getName();
 
   if (aterm->isFermionic())
     app_log() << "  Added a fermionic WaveFunctionComponent " << aname << std::endl;
 
   for (auto& suffix : suffixes)
     WFC_timers_.push_back(createGlobalTimer(aname + "::" + suffix));
 
   Z.emplace_back(std::move(aterm));
 }

◆ calcRatio()

TrialWaveFunction::ValueType calcRatio	(	ParticleSet &	P,
		int	iat,
		ComputeType	ct = `ComputeType::ALL`
	)

compute psi(R_new) / psi(R_current) ratio It returns a complex value if the wavefunction is complex.

Parameters

P	the active ParticleSet
iat	the index of a particle moved to the new position.
ct	select ComputeType

Returns: ratio value

Definition at line 450 of file TrialWaveFunction.cpp.

References TrialWaveFunction::ALL, NaNguard::checkOneParticleRatio(), TrialWaveFunction::FERMIONIC, TrialWaveFunction::NONFERMIONIC, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, qmcplusplus::V_TIMER, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SOVMCUpdatePbyP::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DensityMatrices1B::evaluate_check(), SOECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOneWithForces(), SOECPComponent::evaluateValueAndDerivatives(), NonLocalECPComponent::evaluateValueAndDerivatives(), OneBodyDensityMatrices::generateSampleRatios(), DensityMatrices1B::integrate(), SOECPComponent::mw_evaluateOne(), NonLocalECPComponent::mw_evaluateOne(), WaveFunctionTester::runBasicTest(), WaveFunctionTester::runNodePlot(), WaveFunctionTester::runRatioTest2(), qmcplusplus::TEST_CASE(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   ScopedTimer local_timer(TWF_timers_[V_TIMER]);
   PsiValue r(1.0);
   for (int i = 0; i < Z.size(); i++)
     if (ct == ComputeType::ALL || (Z[i]->isFermionic() && ct == ComputeType::FERMIONIC) ||
         (!Z[i]->isFermionic() && ct == ComputeType::NONFERMIONIC))
     {
       ScopedTimer z_timer(WFC_timers_[V_TIMER + TIMER_SKIP * i]);
       r *= Z[i]->ratio(P, iat);
     }
 
   NaNguard::checkOneParticleRatio(r, "TWF::calcRatio at particle " + std::to_string(iat));
   return static_cast<ValueType>(r);
 }

◆ calcRatioGrad()

TrialWaveFunction::ValueType calcRatioGrad	(	ParticleSet &	P,
		int	iat,
		GradType &	grad_iat
	)

compute psi(R_new) / psi(R_current) ratio and ln(psi(R_new)) gradients It returns a complex value if the wavefunction is complex.

Parameters

P	the active ParticleSet
iat	the index of a particle moved to the new position.
grad_iat	gradients. The consumer must verify if ratio is non-zero.

Returns: ratio value. The caller must reject zero ratio moves.

Definition at line 609 of file TrialWaveFunction.cpp.

References NaNguard::checkOneParticleGradients(), NaNguard::checkOneParticleRatio(), qmcplusplus::convertValueToLog(), qmcplusplus::imag(), TrialWaveFunction::PhaseDiff, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::use_tasking_, qmcplusplus::VGL_TIMER, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by DMCUpdatePbyPWithRejectionFast::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), NonLocalECPComponent::evaluateOneWithForces(), NonLocalECPotential::makeNonLocalMovesPbyP(), and WaveFunctionTester::runRatioTest2().

 {
   ScopedTimer local_timer(TWF_timers_[VGL_TIMER]);
   grad_iat = 0.0;
   PsiValue r(1.0);
   if (use_tasking_)
   {
     std::vector<GradType> grad_components(Z.size(), GradType(0.0));
     std::vector<PsiValue> ratio_components(Z.size(), 0.0);
     PRAGMA_OMP_TASKLOOP("omp taskloop default(shared)")
     for (int i = 0; i < Z.size(); ++i)
     {
       ScopedTimer z_timer(WFC_timers_[VGL_TIMER + TIMER_SKIP * i]);
       ratio_components[i] = Z[i]->ratioGrad(P, iat, grad_components[i]);
     }
 
     for (int i = 0; i < Z.size(); ++i)
     {
       grad_iat += grad_components[i];
       r *= ratio_components[i];
     }
   }
   else
     for (int i = 0; i < Z.size(); ++i)
     {
       ScopedTimer z_timer(WFC_timers_[VGL_TIMER + TIMER_SKIP * i]);
       r *= Z[i]->ratioGrad(P, iat, grad_iat);
     }
 
   NaNguard::checkOneParticleRatio(r, "TWF::calcRatioGrad at particle " + std::to_string(iat));
   if (r != PsiValue(0)) // grad_iat is meaningful only when r is strictly non-zero
     NaNguard::checkOneParticleGradients(grad_iat, "TWF::calcRatioGrad at particle " + std::to_string(iat));
   LogValue logratio = convertValueToLog(r);
   PhaseDiff         = std::imag(logratio);
   return static_cast<ValueType>(r);
 }

◆ calcRatioGradWithSpin()

TrialWaveFunction::ValueType calcRatioGradWithSpin	(	ParticleSet &	P,
		int	iat,
		GradType &	grad_iat,
		ComplexType &	spingrad_iat
	)

compute psi(R_new) / psi(R_current) ratio and d/ds ln(psi(R_new)) spin gradient It returns a complex value if the wavefunction is complex.

Parameters

P	the active ParticleSet
iat	the index of a particle moved to the new position.
grad_iat	real space gradient for iat. The consumer must verify if ratio is non-zero.
spingrad_iat	spin gradient for iat. The consumer must verify if ratio is non-zero.

Returns: ratio value. The caller must reject zero ratio moves.

Definition at line 646 of file TrialWaveFunction.cpp.

References NaNguard::checkOneParticleGradients(), NaNguard::checkOneParticleRatio(), qmcplusplus::convertValueToLog(), qmcplusplus::imag(), TrialWaveFunction::PhaseDiff, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, qmcplusplus::VGL_TIMER, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), and SOVMCUpdatePbyP::advanceWalker().

 {
   ScopedTimer local_timer(TWF_timers_[VGL_TIMER]);
   grad_iat     = 0.0;
   spingrad_iat = 0.0;
   PsiValue r(1.0);
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[VGL_TIMER + TIMER_SKIP * i]);
     r *= Z[i]->ratioGradWithSpin(P, iat, grad_iat, spingrad_iat);
   }
 
   NaNguard::checkOneParticleRatio(r, "TWF::calcRatioGradWithSpin at particle " + std::to_string(iat));
   if (r != PsiValue(0)) // grad_iat is meaningful only when r is strictly non-zero
     NaNguard::checkOneParticleGradients(grad_iat, "TWF::calcRatioGradWithSpin at particle " + std::to_string(iat));
   LogValue logratio = convertValueToLog(r);
   PhaseDiff         = std::imag(logratio);
   return static_cast<ValueType>(r);
 }

◆ checkInVariables()

void checkInVariables ( opt_variables_type & o )

Check in an optimizable parameter.

Parameters

o	aggregated list of optimizable variables

Gather all the optimizable parameters from wavefunction components into a single list

Definition at line 912 of file TrialWaveFunction.cpp.

References TrialWaveFunction::extractOptimizableObjectRefs().

Referenced by WaveFunctionTester::runDerivCloneTest(), WaveFunctionTester::runDerivNLPPTest(), WaveFunctionTester::runDerivTest(), qmcplusplus::TEST_CASE(), and qmcplusplus::test_hcpBe_rotation().

 {
   auto opt_obj_refs = extractOptimizableObjectRefs();
   for (OptimizableObject& obj : opt_obj_refs)
     obj.checkInVariablesExclusive(active);
 }

◆ checkOutVariables()

void checkOutVariables ( const opt_variables_type & o )

Check out optimizable variables Assign index mappings from global list (o) to local values in each component.

Definition at line 919 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

Referenced by QMCCostFunctionBase::put(), WaveFunctionTester::runDerivCloneTest(), WaveFunctionTester::runDerivNLPPTest(), WaveFunctionTester::runDerivTest(), qmcplusplus::TEST_CASE(), and qmcplusplus::test_hcpBe_rotation().

 {
   for (int i = 0; i < Z.size(); i++)
     if (Z[i]->isOptimizable())
       Z[i]->checkOutVariables(active);
 }

◆ completeUpdates()

void completeUpdates ( )

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

See WaveFunctionComponent::completeUpdates for more detail

Definition at line 807 of file TrialWaveFunction.cpp.

References qmcplusplus::ACCEPT_TIMER, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), VMCUpdatePbyP::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), and NonLocalECPotential::makeNonLocalMovesPbyP().

 {
   ScopedTimer local_timer(TWF_timers_[ACCEPT_TIMER]);
   for (int i = 0; i < Z.size(); i++)
   {
     ScopedTimer z_timer(WFC_timers_[ACCEPT_TIMER + TIMER_SKIP * i]);
     Z[i]->completeUpdates();
   }
 }

◆ copyFromBuffer()

void copyFromBuffer	(	ParticleSet &	P,
		WFBufferType &	buf
	)

copy all the wavefunction components from buffer.

See WaveFunctionComponent::updateBuffer for more detail

Definition at line 1014 of file TrialWaveFunction.cpp.

References qmcplusplus::BUFFER_TIMER, TrialWaveFunction::BufferCursor, TrialWaveFunction::BufferCursor_scalar, TrialWaveFunction::debugOnlyCheckBuffer(), PooledMemory< T_scalar, Alloc >::get(), TrialWaveFunction::log_real_, TrialWaveFunction::PhaseValue, PooledMemory< T_scalar, Alloc >::rewind(), qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), RMCUpdatePbyPWithDrift::initWalkersForPbyP(), QMCUpdateBase::initWalkersForPbyP(), WaveFunctionTester::runCloneTest(), WaveFunctionTester::runNodePlot(), WaveFunctionTester::runRatioTest(), and WaveFunctionTester::runRatioTest2().

 {
   ScopedTimer local_timer(TWF_timers_[BUFFER_TIMER]);
   buf.rewind(BufferCursor, BufferCursor_scalar);
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[BUFFER_TIMER + TIMER_SKIP * i]);
     Z[i]->copyFromBuffer(P, buf);
   }
   //get the gradients and laplacians from the buffer
   buf.get(PhaseValue);
   buf.get(log_real_);
   debugOnlyCheckBuffer(buf);
 }

◆ createResource()

void createResource ( ResourceCollection & collection ) const

initialize a shared resource and hand it to a collection

Definition at line 1204 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

Referenced by CostFunctionCrowdData::CostFunctionCrowdData(), qmcplusplus::doSOECPotentialTest(), QMCDriverNew::initializeQMC(), qmcplusplus::TEST_CASE(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   for (int i = 0; i < Z.size(); ++i)
     Z[i]->createResource(collection);
 }

◆ debugOnlyCheckBuffer()

void debugOnlyCheckBuffer ( WFBufferType & buffer )

staticprivate

Definition at line 973 of file TrialWaveFunction.cpp.

References PooledMemory< T_scalar, Alloc >::current(), PooledMemory< T_scalar, Alloc >::current_scalar(), and PooledMemory< T_scalar, Alloc >::size().

Referenced by TrialWaveFunction::copyFromBuffer(), and TrialWaveFunction::updateBuffer().

 {
 #ifndef NDEBUG
   if (buffer.size() < buffer.current() + buffer.current_scalar() * sizeof(FullPrecRealType))
   {
     std::ostringstream assert_message;
     assert_message << "On thread:" << Concurrency::getWorkerId<>() << "  buf_list[iw].get().size():" << buffer.size()
                    << " < buf_list[iw].get().current():" << buffer.current()
                    << " + buf.current_scalar():" << buffer.current_scalar()
                    << " * sizeof(FullPrecRealType):" << sizeof(FullPrecRealType) << '\n';
     throw std::runtime_error(assert_message.str());
   }
 #endif
 }

◆ evalGrad()

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

Definition at line 525 of file TrialWaveFunction.cpp.

References NaNguard::checkOneParticleGradients(), qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, qmcplusplus::VGL_TIMER, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by DMCUpdatePbyPWithRejectionFast::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), and WaveFunctionTester::runRatioTest2().

 {
   ScopedTimer local_timer(TWF_timers_[VGL_TIMER]);
   GradType grad_iat;
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[VGL_TIMER + TIMER_SKIP * i]);
     grad_iat += Z[i]->evalGrad(P, iat);
   }
   NaNguard::checkOneParticleGradients(grad_iat, "TWF::evalGrad at particle " + std::to_string(iat));
   return grad_iat;
 }

◆ evalGradSource() [1/2]

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

Returns the logarithmic gradient of the trial wave function with respect to the iat^th atom of the source ParticleSet.

Definition at line 582 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

Referenced by TrialWaveFunction::evalGradSource(), QMCHamiltonian::evaluateIonDerivs(), QMCHamiltonian::evaluateIonDerivsDeterministic(), NonLocalECPComponent::evaluateOneWithForces(), BareKineticEnergy::evaluateWithIonDerivs(), WaveFunctionTester::runGradSourceTest(), WaveFunctionTester::runZeroVarianceTest(), and qmcplusplus::TEST_CASE().

 {
   GradType grad_iat = GradType();
   for (int i = 0; i < Z.size(); ++i)
     grad_iat += Z[i]->evalGradSource(P, source, iat);
   return grad_iat;
 }

◆ evalGradSource() [2/2]

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

Returns the logarithmic gradient of the w.r.t.

the iat^th atom of the source ParticleSet of the sum of laplacians w.r.t. the electrons (target ParticleSet) of the trial wave function.

Definition at line 590 of file TrialWaveFunction.cpp.

References TrialWaveFunction::evalGradSource(), OHMMS_DIM, TinyVector< T, D >::size(), and TrialWaveFunction::Z.

 {
   GradType grad_iat = GradType();
   for (int dim = 0; dim < OHMMS_DIM; dim++)
     for (int i = 0; i < grad_grad[0].size(); i++)
     {
       grad_grad[dim][i] = GradType();
       lapl_grad[dim][i] = 0.0;
     }
   for (int i = 0; i < Z.size(); ++i)
     grad_iat += Z[i]->evalGradSource(P, source, iat, grad_grad, lapl_grad);
   return grad_iat;
 }

◆ evalGradWithSpin()

TrialWaveFunction::GradType evalGradWithSpin	(	ParticleSet &	P,
		int	iat,
		ComplexType &	spingrad
	)

compute d/ds ln(psi) spin gradient at current particle position for iat electron

Parameters

P	active particle set.
iat	index of the particle moved to the new position.
spingrad	spingrad value. Zeroed out first, then filled with d/ds ln(psi).

Returns: ln(psi) (complex)

Definition at line 538 of file TrialWaveFunction.cpp.

References NaNguard::checkOneParticleGradients(), qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, qmcplusplus::VGL_TIMER, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), and SOVMCUpdatePbyP::advanceWalker().

 {
   ScopedTimer local_timer(TWF_timers_[VGL_TIMER]);
   GradType grad_iat;
   spingrad = 0;
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[VGL_TIMER + TIMER_SKIP * i]);
     grad_iat += Z[i]->evalGradWithSpin(P, iat, spingrad);
   }
   NaNguard::checkOneParticleGradients(grad_iat, "TWF::evalGradWithSpin at particle " + std::to_string(iat));
   return grad_iat;
 }

◆ evaluateDeltaLog()

TrialWaveFunction::RealType evaluateDeltaLog	(	ParticleSet &	P,
		bool	recompute = `false`
	)

evaluate the log value of a many-body wave function

Parameters

P	input configuration containing N particles
recomputeall	recompute all orbitals from scratch

Returns: the value of $\log( \Pi_i \Psi_i)$ many-body wave function

default value. call evaluateLog only on optimizable orbitals. OK if nonlocal pp's aren't used.

To save time, logpsi, G, and L are only computed for orbitals that change over the course of the optimization. It is assumed that the fixed components are stored elsewhere. See evaluateDeltaLog(P,logpsi_fixed_r,logpsi_opt,fixedG,fixedL) defined below. Nonlocal pseudopotential evaluation requires temporary information like matrix inverses, so while the logpsi, G, and L don't change, evaluateLog is called anyways to compute these auxiliary quantities from scratch. logpsi, G, and L associated with these non-optimizable orbitals are discarded explicitly and with dummy variables.

Definition at line 232 of file TrialWaveFunction.cpp.

References TrialWaveFunction::evaluateLog(), ParticleSet::G, qmcplusplus::imag(), ParticleSet::L, TrialWaveFunction::log_real_, TrialWaveFunction::PhaseValue, qmcplusplus::RECOMPUTE_TIMER, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by qmcplusplus::TEST_CASE().

 {
   ScopedTimer local_timer(TWF_timers_[RECOMPUTE_TIMER]);
   P.G = 0.0;
   P.L = 0.0;
   LogValue logpsi(0.0);
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
     if (Z[i]->isOptimizable())
       logpsi += Z[i]->evaluateLog(P, P.G, P.L);
   }
   log_real_  = std::real(logpsi);
   PhaseValue = std::imag(logpsi);
 
   //In case we need to recompute orbitals, initialize dummy vectors for G and L.
   //evaluateLog dumps into these variables, and logPsi contribution is discarded.
   //Only called for non-optimizable orbitals.
   if (recomputeall)
   {
     ParticleSet::ParticleGradient dummyG(P.G);
     ParticleSet::ParticleLaplacian dummyL(P.L);
 
     for (int i = 0; i < Z.size(); ++i)
     {
       //update orbitals if its not flagged optimizable, AND recomputeall is true
       if (!Z[i]->isOptimizable())
         Z[i]->evaluateLog(P, dummyG, dummyL);
     }
   }
   return log_real_;
 }

◆ evaluateDeltaLogSetup()

void evaluateDeltaLogSetup	(	ParticleSet &	P,
		RealType &	logpsi_fixed,
		RealType &	logpsi_opt,
		ParticleSet::ParticleGradient &	fixedG,
		ParticleSet::ParticleLaplacian &	fixedL
	)

evaluate the sum of log value of optimizable many-body wavefunctions

Parameters

P	input configuration containing N particles
logpsi_fixed	log(std::abs(psi)) of the invariant orbitals
logpsi_opt	log(std::abs(psi)) of the variable orbitals
fixedG	gradients of log(psi) of the fixed wave functions
fixedL	laplacians of log(psi) of the fixed wave functions

This function is introduced for optimization only. fixedG and fixedL save the terms coming from the wave functions that are invariant during optimizations. It is expected that evaluateDeltaLog(P,false) is called later and the external object adds the varying G and L and the fixed terms.

Definition at line 265 of file TrialWaveFunction.cpp.

References qmcplusplus::convertToReal(), ParticleSet::G, ParticleSet::L, qmcplusplus::RECOMPUTE_TIMER, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by qmcplusplus::TEST_CASE().

 {
   ScopedTimer local_timer(TWF_timers_[RECOMPUTE_TIMER]);
   P.G    = 0.0;
   P.L    = 0.0;
   fixedL = 0.0;
   fixedG = 0.0;
   LogValue logpsi_fixed(0.0);
   LogValue logpsi_opt(0.0);
 
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
     if (Z[i]->isOptimizable())
       logpsi_opt += Z[i]->evaluateLog(P, P.G, P.L);
     else
       logpsi_fixed += Z[i]->evaluateLog(P, fixedG, fixedL);
   }
   P.G += fixedG;
   P.L += fixedL;
   convertToReal(logpsi_fixed, logpsi_fixed_r);
   convertToReal(logpsi_opt, logpsi_opt_r);
 }

◆ evaluateDerivatives()

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

evaluate derivatives of KE wrt optimizable varibles

Todo:: WaveFunctionComponent objects should take the mass into account.

Definition at line 1128 of file TrialWaveFunction.cpp.

References qmcplusplus::DERIVS_TIMER, TrialWaveFunction::OneOverM, Vector< T, Alloc >::size(), qmcplusplus::TIMER_SKIP, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by BareKineticEnergy::evaluateValueAndDerivatives(), WaveFunctionTester::runDerivCloneTest(), WaveFunctionTester::runDerivNLPPTest(), WaveFunctionTester::runDerivTest(), qmcplusplus::TEST_CASE(), and qmcplusplus::test_hcpBe_rotation().

 {
   //     // First, zero out derivatives
   //  This should only be done for some variables.
   //     for (int j=0; j<dlogpsi.size(); j++)
   //       dlogpsi[j] = dhpsioverpsi[j] = 0.0;
   for (int i = 0; i < Z.size(); i++)
   {
     ScopedTimer z_timer(WFC_timers_[DERIVS_TIMER + TIMER_SKIP * i]);
     Z[i]->evaluateDerivatives(P, optvars, dlogpsi, dhpsioverpsi);
   }
   //orbitals do not know about mass of particle.
   for (int i = 0; i < dhpsioverpsi.size(); i++)
     dhpsioverpsi[i] *= OneOverM;
 }

◆ evaluateDerivativesWF()

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

Definition at line 1164 of file TrialWaveFunction.cpp.

References qmcplusplus::DERIVS_TIMER, qmcplusplus::TIMER_SKIP, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SOECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::evaluateValueAndDerivatives().

 {
   for (int i = 0; i < Z.size(); i++)
   {
     ScopedTimer z_timer(WFC_timers_[DERIVS_TIMER + TIMER_SKIP * i]);
     Z[i]->evaluateDerivativesWF(P, optvars, dlogpsi);
   }
 }

◆ evaluateDerivRatios()

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

compute both ratios and deriatives of ratio with respect to the optimizables

Definition at line 1094 of file TrialWaveFunction.cpp.

References Matrix< T, Alloc >::begin(), qmcplusplus::DERIVS_TIMER, Matrix< T, Alloc >::end(), qmcplusplus::TIMER_SKIP, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SOECPComponent::evaluateValueAndDerivatives(), and NonLocalECPComponent::evaluateValueAndDerivatives().

 {
   std::fill(ratios.begin(), ratios.end(), 1.0);
   std::fill(dratio.begin(), dratio.end(), 0.0);
   std::vector<ValueType> t(ratios.size());
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[DERIVS_TIMER + TIMER_SKIP * i]);
     Z[i]->evaluateDerivRatios(VP, optvars, t, dratio);
     for (int j = 0; j < ratios.size(); ++j)
       ratios[j] *= t[j];
   }
 }

◆ evaluateGL()

TrialWaveFunction::LogValue evaluateGL	(	ParticleSet &	P,
		bool	fromscratch
	)

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

See WaveFunctionComponent::evaluateGL for more detail

Definition at line 832 of file TrialWaveFunction.cpp.

References qmcplusplus::BUFFER_TIMER, ParticleSet::G, TrialWaveFunction::G, qmcplusplus::imag(), ParticleSet::L, TrialWaveFunction::L, TrialWaveFunction::log_real_, TrialWaveFunction::PhaseValue, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   ScopedTimer local_timer(TWF_timers_[BUFFER_TIMER]);
   P.G = 0.0;
   P.L = 0.0;
   LogValue logpsi(0.0);
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[BUFFER_TIMER + TIMER_SKIP * i]);
     logpsi += Z[i]->evaluateGL(P, P.G, P.L, fromscratch);
   }
 
   // Ye: temporal workaround to have WF.G/L always defined.
   // remove when KineticEnergy use WF.G/L instead of P.G/L
   G          = P.G;
   L          = P.L;
   log_real_  = std::real(logpsi);
   PhaseValue = std::imag(logpsi);
   return logpsi;
 }

◆ evaluateGradDerivatives()

void evaluateGradDerivatives	(	const ParticleSet::ParticleGradient &	G_in,
		std::vector< ValueType > &	dgradlogpsi
	)

Definition at line 1175 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

 {
   for (int i = 0; i < Z.size(); i++)
     Z[i]->evaluateGradDerivatives(G_in, dgradlogpsi);
 }

◆ evaluateHessian()

void evaluateHessian	(	ParticleSet &	P,
		HessVector &	all_grad_grad_psi
	)

evaluate the hessian w.r.t.

electronic coordinates of particle iat evaluate the hessian hessian w.r.t. electronic coordinates of particle iat

Definition at line 434 of file TrialWaveFunction.cpp.

References ParticleSet::getTotalNum(), and TrialWaveFunction::Z.

Referenced by L2Potential::evaluate(), and StressPBC::evaluateKineticSymTensor().

 {
   grad_grad_psi.resize(P.getTotalNum());
 
   for (int i = 0; i < Z.size(); i++)
   {
     HessVector tmp_hess(grad_grad_psi);
     tmp_hess = 0.0;
     Z[i]->evaluateHessian(P, tmp_hess);
     grad_grad_psi += tmp_hess;
     //  app_log()<<"TrialWavefunction::tmp_hess = "<<tmp_hess<< std::endl;
     //  app_log()<< std::endl<< std::endl;
   }
   // app_log()<<" TrialWavefunction::Hessian = "<<grad_grad_psi<< std::endl;
 }

◆ evaluateLog()

TrialWaveFunction::RealType evaluateLog ( ParticleSet & P )

evalaute the log (internally gradients and laplacian) of the trial wavefunction.

return log(|psi|)

gold reference

PhaseValue is the phase for the complex wave function

Definition at line 123 of file TrialWaveFunction.cpp.

References ParticleSet::G, TrialWaveFunction::G, qmcplusplus::imag(), ParticleSet::L, TrialWaveFunction::L, TrialWaveFunction::log_real_, TrialWaveFunction::PhaseValue, qmcplusplus::RECOMPUTE_TIMER, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

 {
   ScopedTimer local_timer(TWF_timers_[RECOMPUTE_TIMER]);
   P.G = 0.0;
   P.L = 0.0;
   LogValue logpsi(0.0);
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
 #ifndef NDEBUG
     // Best way I've found yet to quickly see if WFC made it over the wire successfully
     auto subterm = Z[i]->evaluateLog(P, P.G, P.L);
     // std::cerr << "evaluate log Z element:" <<  i << "  value: " << subterm << '\n';
     logpsi += subterm;
 #else
     logpsi += Z[i]->evaluateLog(P, P.G, P.L);
 #endif
   }
 
   G = P.G;
   L = P.L;
 
   log_real_  = std::real(logpsi);
   PhaseValue = std::imag(logpsi);
   return log_real_;
 }

◆ evaluateRatios()

void evaluateRatios	(	const VirtualParticleSet &	VP,
		std::vector< ValueType > &	ratios,
		ComputeType	ct = `ComputeType::ALL`
	)

compulte multiple ratios to handle non-local moves and other virtual moves

Definition at line 1029 of file TrialWaveFunction.cpp.

References TrialWaveFunction::ALL, TrialWaveFunction::FERMIONIC, VirtualParticleSet::getTotalNum(), qmcplusplus::NL_TIMER, TrialWaveFunction::NONFERMIONIC, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SOECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOneWithForces(), MagnetizationDensity::generateSpinIntegrand(), and WaveFunctionTester::runRatioV().

 {
   ScopedTimer local_timer(TWF_timers_[NL_TIMER]);
   assert(VP.getTotalNum() == ratios.size());
   std::vector<ValueType> t(ratios.size());
   std::fill(ratios.begin(), ratios.end(), 1.0);
   for (int i = 0; i < Z.size(); ++i)
     if (ct == ComputeType::ALL || (Z[i]->isFermionic() && ct == ComputeType::FERMIONIC) ||
         (!Z[i]->isFermionic() && ct == ComputeType::NONFERMIONIC))
     {
       ScopedTimer z_timer(WFC_timers_[NL_TIMER + TIMER_SKIP * i]);
       Z[i]->evaluateRatios(VP, t);
       for (int j = 0; j < ratios.size(); ++j)
         ratios[j] *= t[j];
     }
 }

◆ evaluateRatiosAlltoOne()

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

Definition at line 1190 of file TrialWaveFunction.cpp.

References qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, qmcplusplus::V_TIMER, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by MomentumDistribution::accumulate(), MomentumEstimator::evaluate(), DensityMatrices1B::generate_sample_ratios(), and OneBodyDensityMatrices::generateSampleRatios().

 {
   ScopedTimer local_timer(TWF_timers_[V_TIMER]);
   std::fill(ratios.begin(), ratios.end(), 1.0);
   std::vector<ValueType> t(ratios.size());
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer local_timer(WFC_timers_[V_TIMER + TIMER_SKIP * i]);
     Z[i]->evaluateRatiosAlltoOne(P, t);
     for (int j = 0; j < t.size(); ++j)
       ratios[j] *= t[j];
   }
 }

◆ evaluateSpinorRatios()

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

Used by SOECPComponent to do faster SOC evaluation.

Definition at line 1046 of file TrialWaveFunction.cpp.

References VirtualParticleSet::getTotalNum(), qmcplusplus::NL_TIMER, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by SOECPComponent::evaluateOneExactSpinIntegration().

 {
   ScopedTimer local_timer(TWF_timers_[NL_TIMER]);
   assert(VP.getTotalNum() == ratios.size());
   std::vector<ValueType> t(ratios.size());
   std::fill(ratios.begin(), ratios.end(), 1.0);
   for (int i = 0; i < Z.size(); ++i)
   {
       ScopedTimer z_timer(WFC_timers_[NL_TIMER + TIMER_SKIP * i]);
       Z[i]->evaluateSpinorRatios(VP, spinor_multiplier, t);
       for (int j = 0; j < ratios.size(); ++j)
         ratios[j] *= t[j];
   }
 }

◆ extractGRefList()

RefVector< ParticleSet::ParticleGradient > extractGRefList ( const RefVectorWithLeader< TrialWaveFunction > & wf_list )

staticprivate

}@

Definition at line 1256 of file TrialWaveFunction.cpp.

Referenced by TrialWaveFunction::mw_evaluateDeltaLog(), TrialWaveFunction::mw_evaluateDeltaLogSetup(), TrialWaveFunction::mw_evaluateGL(), and TrialWaveFunction::mw_evaluateLog().

 {
   RefVector<ParticleSet::ParticleGradient> g_list;
   for (TrialWaveFunction& wf : wf_list)
     g_list.push_back(wf.G);
   return g_list;
 }

◆ extractLRefList()

RefVector< ParticleSet::ParticleLaplacian > extractLRefList ( const RefVectorWithLeader< TrialWaveFunction > & wf_list )

staticprivate

Definition at line 1265 of file TrialWaveFunction.cpp.

Referenced by TrialWaveFunction::mw_evaluateDeltaLog(), TrialWaveFunction::mw_evaluateDeltaLogSetup(), TrialWaveFunction::mw_evaluateGL(), and TrialWaveFunction::mw_evaluateLog().

 {
   RefVector<ParticleSet::ParticleLaplacian> l_list;
   for (TrialWaveFunction& wf : wf_list)
     l_list.push_back(wf.L);
   return l_list;
 }

◆ extractOptimizableObjectRefs()

UniqueOptObjRefs extractOptimizableObjectRefs ( )

extract underlying OptimizableObject references

Parameters

opt_obj_refs aggregated list of optimizable object references

Definition at line 904 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

Referenced by TrialWaveFunction::checkInVariables(), QMCCostFunctionBase::extractOptimizableObjects(), QMCCostFunctionBase::reportParameters(), TrialWaveFunction::reportStatus(), TrialWaveFunction::resetParameters(), and qmcplusplus::TEST_CASE().

 {
   UniqueOptObjRefs opt_obj_refs;
   for (int i = 0; i < Z.size(); i++)
     Z[i]->extractOptimizableObjectRefs(opt_obj_refs);
   return opt_obj_refs;
 }

◆ extractWFCPtrList()

std::vector< WaveFunctionComponent * > extractWFCPtrList	(	const UPtrVector< TrialWaveFunction > &	wf_list,
		int	id
	)

staticprivate

helper function for extracting a list of WaveFunctionComponent from a list of TrialWaveFunction

Definition at line 1247 of file TrialWaveFunction.cpp.

 {
   std::vector<WaveFunctionComponent*> WFC_list;
   WFC_list.reserve(g.size());
   for (auto& WF : g)
     WFC_list.push_back(WF->Z[id].get());
   return WFC_list;
 }

◆ extractWFCRefList()

RefVectorWithLeader< WaveFunctionComponent > extractWFCRefList	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		int	id
	)

staticprivate

Definition at line 1236 of file TrialWaveFunction.cpp.

References RefVectorWithLeader< T >::getLeader().

 {
   RefVectorWithLeader<WaveFunctionComponent> wfc_list(*wf_list.getLeader().Z[id]);
   wfc_list.reserve(wf_list.size());
   for (TrialWaveFunction& wf : wf_list)
     wfc_list.push_back(*wf.Z[id]);
   return wfc_list;
 }

◆ findMSD()

RefVector< MultiSlaterDetTableMethod > findMSD ( ) const

find MSD WFCs if exist

Definition at line 110 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

Referenced by SelfHealingOverlap::accumulate(), SelfHealingOverlapLegacy::evaluate(), SelfHealingOverlap::SelfHealingOverlap(), SelfHealingOverlapLegacy::SelfHealingOverlapLegacy(), and qmcplusplus::TEST_CASE().

 {
   RefVector<MultiSlaterDetTableMethod> refs;
   for (auto& component : Z)
     if (auto* comp_ptr = dynamic_cast<MultiSlaterDetTableMethod*>(component.get()); comp_ptr)
       refs.push_back(*comp_ptr);
   return refs;
 }

◆ getLogPsi()

RealType getLogPsi ( ) const

inline

Definition at line 114 of file TrialWaveFunction.h.

References TrialWaveFunction::log_real_.

Referenced by DMCUpdateAllWithRejection::advanceWalker(), WalkerLogCollector::collect(), qmcplusplus::TEST_CASE(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

114 { return log_real_; }

qmcplusplus::TrialWaveFunction::log_real_

RealType log_real_

real part of trial wave function log

Definition: TrialWaveFunction.h:547

◆ getLogs()

void getLogs ( std::vector< RealType > & lvals )

Definition at line 940 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

Referenced by QMCUpdateBase::getLogs().

 {
   lvals.resize(Z.size(), 0);
   for (int i = 0; i < Z.size(); i++)
   {
     lvals[i] = std::real(Z[i]->get_log_value());
   }
 }

◆ getName()

const std::string& getName ( ) const

inline

Definition at line 496 of file TrialWaveFunction.h.

References TrialWaveFunction::myName.

Referenced by QMCCostFunctionBase::put().

496 { return myName; }

qmcplusplus::TrialWaveFunction::myName

const std::string myName

getName is in the way

Definition: TrialWaveFunction.h:532

◆ getNode()

xmlNodePtr getNode ( ) const

inline

Definition at line 502 of file TrialWaveFunction.h.

References TrialWaveFunction::myNode_.

502 { return myNode_; }

qmcplusplus::TrialWaveFunction::myNode_

xmlNodePtr myNode_

XML input node for a many-body wavefunction.

Definition: TrialWaveFunction.h:526

◆ getOrbitals()

std::vector<std::unique_ptr<WaveFunctionComponent> > const& getOrbitals ( )

inline

Definition at line 477 of file TrialWaveFunction.h.

References TrialWaveFunction::Z.

Referenced by SelfHealingOverlap::accumulate(), WaveFunctionTester::checkGradientAtConfiguration(), SelfHealingOverlapLegacy::evaluate(), qmcplusplus::TEST_CASE(), and qmcplusplus::test_hcpBe_rotation().

477 { return Z; }

qmcplusplus::TrialWaveFunction::Z

std::vector< std::unique_ptr< WaveFunctionComponent > > Z

a list of WaveFunctionComponents constituting many-body wave functions

Definition: TrialWaveFunction.h:556

◆ getPhase()

RealType getPhase ( ) const

inline

Definition at line 106 of file TrialWaveFunction.h.

References TrialWaveFunction::PhaseValue.

Referenced by SOVMCUpdateAll::advanceWalker(), SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdateAllWithRejection::advanceWalker(), VMCUpdateAll::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), DMCUpdateAllWithKill::advanceWalker(), RMCUpdateAllWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), RMCUpdateAllWithDrift::advanceWalkersVMC(), WaveFunctionTester::checkGradientAtConfiguration(), WalkerLogCollector::collect(), WaveFunctionTester::computeNumericalGrad(), RMCUpdateAllWithDrift::initWalkers(), QMCUpdateBase::initWalkers(), RMCUpdatePbyPWithDrift::initWalkersForPbyP(), QMCUpdateBase::initWalkersForPbyP(), WaveFunctionTester::runBasicTest(), WaveFunctionTester::runRatioTest(), WaveFunctionTester::runRatioTest2(), WaveFunctionTester::runZeroVarianceTest(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

106 { return PhaseValue; }

qmcplusplus::TrialWaveFunction::PhaseValue

RealType PhaseValue

sign of the trial wave function

Definition: TrialWaveFunction.h:541

◆ getPhaseDiff()

RealType getPhaseDiff ( ) const

inline

Definition at line 112 of file TrialWaveFunction.h.

References TrialWaveFunction::PhaseDiff.

Referenced by DMCUpdateAllWithRejection::advanceWalker(), SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), DMCUpdateAllWithKill::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdateAllWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), RMCUpdateAllWithDrift::advanceWalkersVMC(), and WaveFunctionTester::runBasicTest().

112 { return PhaseDiff; }

qmcplusplus::TrialWaveFunction::PhaseDiff

RealType PhaseDiff

diff of the phase of the trial wave function during ratio calls

Definition: TrialWaveFunction.h:544

◆ getPhases()

void getPhases ( std::vector< RealType > & pvals )

Definition at line 949 of file TrialWaveFunction.cpp.

References qmcplusplus::imag(), and TrialWaveFunction::Z.

 {
   pvals.resize(Z.size(), 0);
   for (int i = 0; i < Z.size(); i++)
   {
     pvals[i] = std::imag(Z[i]->get_log_value());
   }
 }

◆ getReciprocalMass()

RealType getReciprocalMass ( )

inline

Definition at line 494 of file TrialWaveFunction.h.

References TrialWaveFunction::OneOverM.

494 { return OneOverM; }

qmcplusplus::TrialWaveFunction::OneOverM

RealType OneOverM

One over mass of target particleset, needed for Local Energy Derivatives.

Definition: TrialWaveFunction.h:550

◆ getSPOMap()

const SPOMap& getSPOMap ( ) const

inline

spomap_ reference accessor

Definition at line 511 of file TrialWaveFunction.h.

References TrialWaveFunction::spomap_.

Referenced by HamiltonianFactory::build(), and DensityMatrices1B::set_state().

511 { return *spomap_; }

qmcplusplus::TrialWaveFunction::spomap_

const std::shared_ptr< SPOMap > spomap_

Owned SPOSets. Once a TWF is fully built, SPOSet lookup should be done via TWF.

Definition: TrialWaveFunction.h:529

◆ getSPOSet()

const SPOSet & getSPOSet ( const std::string & name ) const

look up SPOSet named 'name', if not found, throw exception.

Definition at line 102 of file TrialWaveFunction.cpp.

References TrialWaveFunction::spomap_.

 {
   auto spoit = spomap_->find(name);
   if (spoit == spomap_->end())
     throw std::runtime_error("SPOSet " + name + " cannot be found!");
   return *spoit->second;
 }

◆ initializeTWFFastDerivWrapper()

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

Initialize a TWF wrapper for fast derivative evaluation.

Definition at line 1274 of file TrialWaveFunction.cpp.

References qmcplusplus::twf, and TrialWaveFunction::Z.

Referenced by ACForce::ACForce(), and qmcplusplus::TEST_CASE().

 {
   for (int i = 0; i < Z.size(); ++i)
   {
     if (Z[i]->isFermionic())
     {
       //OK, so this is a hack only for SlaterDeterminant objects.
       //Needs a bit of logic and protection before this reaches production.
       //SlaterDet* det = dynamic_cast<SlaterDet*>(Z[i].get());
       //det->registerTWFFastDerivWrapper(P, twf);
       Z[i]->registerTWFFastDerivWrapper(P, twf);
     }
     else
       twf.addJastrow(Z[i].get());
   }
 }

◆ KECorrection()

TrialWaveFunction::RealType KECorrection ( ) const

Definition at line 1182 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

Referenced by ChiesaCorrection::evaluate().

 {
   RealType sum = 0.0;
   for (int i = 0; i < Z.size(); ++i)
     sum += Z[i]->KECorrection();
   return sum;
 }

◆ makeClone()

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

Definition at line 1113 of file TrialWaveFunction.cpp.

References TrialWaveFunction::BufferCursor, TrialWaveFunction::BufferCursor_scalar, TrialWaveFunction::myName, TrialWaveFunction::OneOverM, TrialWaveFunction::runtime_options_, TrialWaveFunction::use_tasking_, and TrialWaveFunction::Z.

Referenced by CostFunctionCrowdData::CostFunctionCrowdData(), MCPopulation::createWalkers(), qmcplusplus::doSOECPotentialTest(), CloneManager::makeClones(), WaveFunctionTester::runCloneTest(), WaveFunctionTester::runDerivCloneTest(), MCPopulation::spawnWalker(), qmcplusplus::TEST_CASE(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   auto myclone                 = std::make_unique<TrialWaveFunction>(runtime_options_, myName, use_tasking_);
   myclone->BufferCursor        = BufferCursor;
   myclone->BufferCursor_scalar = BufferCursor_scalar;
   for (int i = 0; i < Z.size(); ++i)
     myclone->addComponent(Z[i]->makeClone(tqp));
   myclone->OneOverM = OneOverM;
   return myclone;
 }

◆ mw_accept_rejectMove()

void mw_accept_rejectMove	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		int	iat,
		const std::vector< bool > &	isAccepted,
		bool	safe_to_delay = `false`
	)

static

Definition at line 774 of file TrialWaveFunction.cpp.

References qmcplusplus::ACCEPT_TIMER, TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), qmcplusplus::imag(), and qmcplusplus::TIMER_SKIP.

Referenced by TWFdispatcher::flex_accept_rejectMove(), qmcplusplus::TEST_CASE(), qmcplusplus::test_LiH_msd(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[ACCEPT_TIMER]);
   const int num_wfc             = wf_leader.Z.size();
   auto& wavefunction_components = wf_leader.Z;
 
   for (int iw = 0; iw < wf_list.size(); iw++)
     if (isAccepted[iw])
     {
       wf_list[iw].log_real_  = 0;
       wf_list[iw].PhaseValue = 0;
     }
 
   PRAGMA_OMP_TASKLOOP("omp taskloop default(shared) if (wf_leader.use_tasking_)")
   for (int i = 0; i < num_wfc; i++)
   {
     ScopedTimer z_timer(wf_leader.WFC_timers_[ACCEPT_TIMER + TIMER_SKIP * i]);
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->mw_accept_rejectMove(wfc_list, p_list, iat, isAccepted, safe_to_delay);
     for (int iw = 0; iw < wf_list.size(); iw++)
       if (isAccepted[iw])
       {
         wf_list[iw].log_real_ += std::real(wfc_list[iw].get_log_value());
         wf_list[iw].PhaseValue += std::imag(wfc_list[iw].get_log_value());
       }
   }
 }

◆ mw_calcRatio()

void mw_calcRatio	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		int	iat,
		std::vector< PsiValue > &	ratios,
		ComputeType	ct = `ComputeType::ALL`
	)

static

batched version of calcRatio

Definition at line 466 of file TrialWaveFunction.cpp.

References TrialWaveFunction::ALL, NaNguard::checkOneParticleRatio(), TrialWaveFunction::extractWFCRefList(), TrialWaveFunction::FERMIONIC, RefVectorWithLeader< T >::getLeader(), TrialWaveFunction::NONFERMIONIC, qmcplusplus::TIMER_SKIP, and qmcplusplus::V_TIMER.

Referenced by TWFdispatcher::flex_calcRatio(), qmcplusplus::TEST_CASE(), qmcplusplus::test_LiH_msd(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   const int num_wf = wf_list.size();
   ratios.resize(num_wf);
   std::fill(ratios.begin(), ratios.end(), PsiValue(1));
 
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[V_TIMER]);
   const int num_wfc             = wf_leader.Z.size();
   auto& wavefunction_components = wf_leader.Z;
 
   std::vector<PsiValue> ratios_z(num_wf);
   for (int i = 0; i < num_wfc; i++)
   {
     if (ct == ComputeType::ALL || (wavefunction_components[i]->isFermionic() && ct == ComputeType::FERMIONIC) ||
         (!wavefunction_components[i]->isFermionic() && ct == ComputeType::NONFERMIONIC))
     {
       ScopedTimer z_timer(wf_leader.WFC_timers_[V_TIMER + TIMER_SKIP * i]);
       const auto wfc_list(extractWFCRefList(wf_list, i));
       wavefunction_components[i]->mw_calcRatio(wfc_list, p_list, iat, ratios_z);
       for (int iw = 0; iw < wf_list.size(); iw++)
         ratios[iw] *= ratios_z[iw];
     }
   }
 
   for (int iw = 0; iw < wf_list.size(); iw++)
   {
     NaNguard::checkOneParticleRatio(ratios[iw], "TWF::mw_calcRatio at particle " + std::to_string(iat));
     wf_list[iw].PhaseDiff = std::arg(ratios[iw]);
   }
 }

◆ mw_calcRatioGrad()

void mw_calcRatioGrad	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		int	iat,
		std::vector< PsiValue > &	ratios,
		TWFGrads< CT > &	grads
	)

static

batched version of ratioGrad

all vector sizes must match implements switch between normal and WithSpin version

Definition at line 670 of file TrialWaveFunction.cpp.

References NaNguard::checkOneParticleGradients(), NaNguard::checkOneParticleRatio(), TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), qmcplusplus::TIMER_SKIP, and qmcplusplus::VGL_TIMER.

Referenced by TWFdispatcher::flex_calcRatioGrad(), qmcplusplus::TEST_CASE(), qmcplusplus::test_LiH_msd(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   const int num_wf = wf_list.size();
   ratios.resize(num_wf);
   std::fill(ratios.begin(), ratios.end(), PsiValue(1));
   grad_new = TWFGrads<CT>(num_wf);
 
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[VGL_TIMER]);
   const int num_wfc             = wf_leader.Z.size();
   auto& wavefunction_components = wf_leader.Z;
 
   if (wf_leader.use_tasking_)
   {
     std::vector<std::vector<PsiValue>> ratios_components(num_wfc, std::vector<PsiValue>(wf_list.size()));
     std::vector<TWFGrads<CT>> grads_components(num_wfc, TWFGrads<CT>(num_wf));
     PRAGMA_OMP_TASKLOOP("omp taskloop default(shared)")
     for (int i = 0; i < num_wfc; ++i)
     {
       ScopedTimer z_timer(wf_leader.WFC_timers_[VGL_TIMER + TIMER_SKIP * i]);
       const auto wfc_list(extractWFCRefList(wf_list, i));
       wavefunction_components[i]->mw_ratioGrad(wfc_list, p_list, iat, ratios_components[i], grads_components[i]);
     }
 
     for (int i = 0; i < num_wfc; ++i)
     {
       grad_new += grads_components[i];
       for (int iw = 0; iw < wf_list.size(); iw++)
         ratios[iw] *= ratios_components[i][iw];
     }
   }
   else
   {
     std::vector<PsiValue> ratios_z(wf_list.size());
     for (int i = 0; i < num_wfc; ++i)
     {
       ScopedTimer z_timer(wf_leader.WFC_timers_[VGL_TIMER + TIMER_SKIP * i]);
       const auto wfc_list(extractWFCRefList(wf_list, i));
       wavefunction_components[i]->mw_ratioGrad(wfc_list, p_list, iat, ratios_z, grad_new);
       for (int iw = 0; iw < wf_list.size(); iw++)
         ratios[iw] *= ratios_z[iw];
     }
   }
   for (int iw = 0; iw < wf_list.size(); iw++)
   {
     wf_list[iw].PhaseDiff = std::arg(ratios[iw]);
     NaNguard::checkOneParticleRatio(ratios[iw], "TWF::mw_calcRatioGrad at particle " + std::to_string(iat));
     if (ratios[iw] != PsiValue(0))
       NaNguard::checkOneParticleGradients(grad_new.grads_positions[iw],
                                           "TWF::mw_calcRatioGrad at particle " + std::to_string(iat));
   }
 }

◆ mw_completeUpdates()

void mw_completeUpdates ( const RefVectorWithLeader< TrialWaveFunction > & wf_list )

static

Definition at line 817 of file TrialWaveFunction.cpp.

References qmcplusplus::ACCEPT_TIMER, TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), and qmcplusplus::TIMER_SKIP.

Referenced by TWFdispatcher::flex_completeUpdates(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[ACCEPT_TIMER]);
   const int num_wfc             = wf_leader.Z.size();
   auto& wavefunction_components = wf_leader.Z;
 
   for (int i = 0; i < num_wfc; i++)
   {
     ScopedTimer z_timer(wf_leader.WFC_timers_[ACCEPT_TIMER + TIMER_SKIP * i]);
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->mw_completeUpdates(wfc_list);
   }
 }

◆ mw_evalGrad()

void mw_evalGrad	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		int	iat,
		TWFGrads< CT > &	grads
	)

static

batched version of evalGrad

This is static because it should have no direct access to any TWF. implements switch between normal and WithSpin version

Definition at line 553 of file TrialWaveFunction.cpp.

References NaNguard::checkOneParticleGradients(), TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), qmcplusplus::TIMER_SKIP, and qmcplusplus::VGL_TIMER.

Referenced by TWFdispatcher::flex_evalGrad(), qmcplusplus::TEST_CASE(), qmcplusplus::test_LiH_msd(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   const int num_wf = wf_list.size();
   grads            = TWFGrads<CT>(num_wf); //ensure elements are set to zero
 
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[VGL_TIMER]);
   // Right now mw_evalGrad can only be called through an concrete instance of a wavefunctioncomponent
   const int num_wfc             = wf_leader.Z.size();
   auto& wavefunction_components = wf_leader.Z;
 
   TWFGrads<CT> grads_z(num_wf);
   for (int i = 0; i < num_wfc; i++)
   {
     ScopedTimer localtimer(wf_leader.WFC_timers_[VGL_TIMER + TIMER_SKIP * i]);
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->mw_evalGrad(wfc_list, p_list, iat, grads_z);
     grads += grads_z;
   }
 
   for (const GradType& grads : grads.grads_positions)
     NaNguard::checkOneParticleGradients(grads, "TWF::mw_evalGrad at particle " + std::to_string(iat));
 }

◆ mw_evaluateDeltaLog()

void mw_evaluateDeltaLog	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		std::vector< RealType > &	logpsi_list,
		RefVector< ParticleSet::ParticleGradient > &	dummyG_list,
		RefVector< ParticleSet::ParticleLaplacian > &	dummyL_list,
		bool	recompute = `false`
	)

static

evaluate the log value for optimizable parts of a many-body wave function

Parameters

wf_list	vector of wavefunctions
p_list	vector of input particle configurations
logpsi_list	vector of log(std::abs(psi)) of the variable orbitals
dummyG_list	vector of gradients of log(psi) of the fixed wave functions.
dummyL_list	vector of laplacians of log(psi) of the fixed wave functions

The dummyG_list and dummyL_list are only referenced if recompute is true. If recompute is false, the storage of these lists are needed, but the values can be discarded.

default value. call evaluateLog only on optimizable orbitals. OK if nonlocal pp's aren't used.

To save time, logpsi, G, and L are only computed for orbitals that change over the course of the optimization. It is assumed that the fixed components are stored elsewhere. See mw_evaluateDeltaLogSetup defined above. Nonlocal pseudopotential evaluation requires temporary information like matrix inverses, so while the logpsi, G, and L don't change, evaluateLog is called anyways to compute these auxiliary quantities from scratch. logpsi, G, and L associated with these non-optimizable orbitals are discarded explicitly and with dummy variables.

Definition at line 352 of file TrialWaveFunction.cpp.

References BLAS::czero, TrialWaveFunction::extractGRefList(), TrialWaveFunction::extractLRefList(), TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), qmcplusplus::pset, TrialWaveFunction::recompute(), qmcplusplus::RECOMPUTE_TIMER, qmcplusplus::TIMER_SKIP, and qmcplusplus::twf.

Referenced by QMCCostFunctionBatched::correlatedSampling(), and qmcplusplus::TEST_CASE().

 {
   auto& p_leader  = p_list.getLeader();
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[RECOMPUTE_TIMER]);
   constexpr RealType czero(0);
   int num_particles = p_leader.getTotalNum();
   const auto g_list(TrialWaveFunction::extractGRefList(wf_list));
   const auto l_list(TrialWaveFunction::extractLRefList(wf_list));
 
   // Initialize various members of the wavefunction, grad, and laplacian
   auto initGandL = [num_particles, czero](TrialWaveFunction& twf, ParticleSet::ParticleGradient& grad,
                                           ParticleSet::ParticleLaplacian& lapl) {
     grad.resize(num_particles);
     lapl.resize(num_particles);
     grad           = czero;
     lapl           = czero;
     twf.log_real_  = czero;
     twf.PhaseValue = czero;
   };
   for (int iw = 0; iw < wf_list.size(); iw++)
     initGandL(wf_list[iw], g_list[iw], l_list[iw]);
 
   // Get wavefunction components (assumed the same for every WF in the list)
   auto& wavefunction_components = wf_leader.Z;
   const int num_wfc             = wf_leader.Z.size();
 
   // Loop over the wavefunction components
   for (int i = 0; i < num_wfc; ++i)
     if (wavefunction_components[i]->isOptimizable())
     {
       ScopedTimer z_timer(wf_leader.WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
       const auto wfc_list(extractWFCRefList(wf_list, i));
       wavefunction_components[i]->mw_evaluateLog(wfc_list, p_list, g_list, l_list);
       for (int iw = 0; iw < wf_list.size(); iw++)
         logpsi_list[iw] += std::real(wfc_list[iw].get_log_value());
     }
 
   // Temporary workaround to have P.G/L always defined.
   // remove when KineticEnergy use WF.G/L instead of P.G/L
   auto copyToP = [](ParticleSet& pset, TrialWaveFunction& twf) {
     pset.G = twf.G;
     pset.L = twf.L;
   };
   for (int iw = 0; iw < wf_list.size(); iw++)
     copyToP(p_list[iw], wf_list[iw]);
 
   // Recompute is usually used to prepare the wavefunction for NLPP derivatives.
   // (e.g compute the matrix inverse for determinants)
   // Call mw_evaluateLog for the wavefunction components that were skipped previously.
   // Ignore logPsi, G and L.
   if (recompute)
     for (int i = 0; i < num_wfc; ++i)
       if (!wavefunction_components[i]->isOptimizable())
       {
         ScopedTimer z_timer(wf_leader.WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
         const auto wfc_list(extractWFCRefList(wf_list, i));
         wavefunction_components[i]->mw_evaluateLog(wfc_list, p_list, dummyG_list, dummyL_list);
       }
 }

◆ mw_evaluateDeltaLogSetup()

void mw_evaluateDeltaLogSetup	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		std::vector< RealType > &	logpsi_fixed_list,
		std::vector< RealType > &	logpsi_opt_list,
		RefVector< ParticleSet::ParticleGradient > &	fixedG_list,
		RefVector< ParticleSet::ParticleLaplacian > &	fixedL_list
	)

static

evaluate the sum of log value of optimizable many-body wavefunctions

Parameters

wf_list	vector of wavefunctions
p_list	vector of input particle configurations
logpsi_fixed_list	vector of log(std::abs(psi)) of the invariant orbitals
logpsi_opt_list	vector of log(std::abs(psi)) of the variable orbitals
fixedG_list	vector of gradients of log(psi) of the fixed wave functions
fixedL_list	vector of laplacians of log(psi) of the fixed wave functions

For wavefunction optimization, it can speed evaluation to split the log value, the gradient, and the laplacian computed from wavefunction components with optimizable parameters from components that do not. This function computes the log value of both parts, and the gradient and laplacian of the fixed components. During correlated sampling steps only the components with optimizable parameters need to have the gradient and laplacian re-evaluated.

Parameters fixedG_list and fixedL_list save the terms coming from the components that do not have optimizable parameters. It is expected that mw_evaluateDeltaLog(P,false) is called later and the external object adds the varying G and L and the fixed terms.

Definition at line 294 of file TrialWaveFunction.cpp.

References BLAS::czero, TrialWaveFunction::extractGRefList(), TrialWaveFunction::extractLRefList(), TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), qmcplusplus::pset, qmcplusplus::RECOMPUTE_TIMER, qmcplusplus::TIMER_SKIP, and qmcplusplus::twf.

Referenced by QMCCostFunctionBatched::checkConfigurations(), and qmcplusplus::TEST_CASE().

 {
   auto& wf_leader = wf_list.getLeader();
   auto& p_leader  = p_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[RECOMPUTE_TIMER]);
   constexpr RealType czero(0);
   const int num_particles = p_leader.getTotalNum();
   const auto g_list(TrialWaveFunction::extractGRefList(wf_list));
   const auto l_list(TrialWaveFunction::extractLRefList(wf_list));
 
   auto initGandL = [num_particles, czero](TrialWaveFunction& twf, ParticleSet::ParticleGradient& grad,
                                           ParticleSet::ParticleLaplacian& lapl) {
     grad.resize(num_particles);
     lapl.resize(num_particles);
     grad           = czero;
     lapl           = czero;
     twf.log_real_  = czero;
     twf.PhaseValue = czero;
   };
   for (int iw = 0; iw < wf_list.size(); iw++)
     initGandL(wf_list[iw], g_list[iw], l_list[iw]);
   auto& wavefunction_components = wf_leader.Z;
   const int num_wfc             = wf_leader.Z.size();
   for (int i = 0; i < num_wfc; ++i)
   {
     ScopedTimer z_timer(wf_leader.WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
     const auto wfc_list(extractWFCRefList(wf_list, i));
     if (wavefunction_components[i]->isOptimizable())
     {
       wavefunction_components[i]->mw_evaluateLog(wfc_list, p_list, g_list, l_list);
       for (int iw = 0; iw < wf_list.size(); iw++)
         logpsi_opt_list[iw] += std::real(wfc_list[iw].get_log_value());
     }
     else
     {
       wavefunction_components[i]->mw_evaluateLog(wfc_list, p_list, fixedG_list, fixedL_list);
       for (int iw = 0; iw < wf_list.size(); iw++)
         logpsi_fixed_list[iw] += std::real(wfc_list[iw].get_log_value());
     }
   }
 
   // Temporary workaround to have P.G/L always defined.
   // remove when KineticEnergy use WF.G/L instead of P.G/L
   auto addAndCopyToP = [](ParticleSet& pset, TrialWaveFunction& twf, ParticleSet::ParticleGradient& grad,
                           ParticleSet::ParticleLaplacian& lapl) {
     pset.G = twf.G + grad;
     pset.L = twf.L + lapl;
   };
   for (int iw = 0; iw < wf_list.size(); iw++)
     addAndCopyToP(p_list[iw], wf_list[iw], fixedG_list[iw], fixedL_list[iw]);
 }

◆ mw_evaluateGL()

void mw_evaluateGL	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		bool	fromscratch
	)

static

Definition at line 853 of file TrialWaveFunction.cpp.

References qmcplusplus::BUFFER_TIMER, BLAS::czero, TrialWaveFunction::extractGRefList(), TrialWaveFunction::extractLRefList(), TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), qmcplusplus::imag(), qmcplusplus::pset, qmcplusplus::TIMER_SKIP, and qmcplusplus::twf.

Referenced by TWFdispatcher::flex_evaluateGL(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   auto& p_leader  = p_list.getLeader();
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[BUFFER_TIMER]);
 
   constexpr RealType czero(0);
   const auto g_list(TrialWaveFunction::extractGRefList(wf_list));
   const auto l_list(TrialWaveFunction::extractLRefList(wf_list));
 
   const int num_particles = p_leader.getTotalNum();
   for (TrialWaveFunction& wfs : wf_list)
   {
     wfs.G.resize(num_particles);
     wfs.L.resize(num_particles);
     wfs.G          = czero;
     wfs.L          = czero;
     wfs.log_real_  = czero;
     wfs.PhaseValue = czero;
   }
 
   auto& wavefunction_components = wf_leader.Z;
   const int num_wfc             = wf_leader.Z.size();
 
   for (int i = 0; i < num_wfc; ++i)
   {
     ScopedTimer z_timer(wf_leader.WFC_timers_[BUFFER_TIMER + TIMER_SKIP * i]);
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->mw_evaluateGL(wfc_list, p_list, g_list, l_list, fromscratch);
   }
 
   for (int iw = 0; iw < wf_list.size(); iw++)
   {
     ParticleSet& pset      = p_list[iw];
     TrialWaveFunction& twf = wf_list[iw];
 
     for (int i = 0; i < num_wfc; ++i)
     {
       twf.log_real_ += std::real(twf.Z[i]->get_log_value());
       twf.PhaseValue += std::imag(twf.Z[i]->get_log_value());
     }
 
     // Ye: temporal workaround to have P.G/L always defined.
     // remove when KineticEnergy use WF.G/L instead of P.G/L
     pset.G = twf.G;
     pset.L = twf.L;
   }
 }

◆ mw_evaluateLog()

void mw_evaluateLog	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list
	)

static

batched version of evaluateLog.

gold reference

Definition at line 150 of file TrialWaveFunction.cpp.

References BLAS::czero, TrialWaveFunction::extractGRefList(), TrialWaveFunction::extractLRefList(), TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), qmcplusplus::imag(), qmcplusplus::pset, qmcplusplus::RECOMPUTE_TIMER, qmcplusplus::TIMER_SKIP, and qmcplusplus::twf.

Referenced by qmcplusplus::doSOECPotentialTest(), TWFdispatcher::flex_evaluateLog(), qmcplusplus::TEST_CASE(), qmcplusplus::test_LiH_msd(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   auto& wf_leader = wf_list.getLeader();
   auto& p_leader  = p_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[RECOMPUTE_TIMER]);
 
   constexpr RealType czero(0);
   const auto g_list(TrialWaveFunction::extractGRefList(wf_list));
   const auto l_list(TrialWaveFunction::extractLRefList(wf_list));
 
   // due to historic design issue, ParticleSet holds G and L instead of TrialWaveFunction.
   // TrialWaveFunction now also holds G and L to move forward but they need to be copied to P.G and P.L
   // to be compatible with legacy use pattern.
   const int num_particles = p_leader.getTotalNum();
   auto initGandL          = [num_particles, czero](TrialWaveFunction& twf, ParticleSet::ParticleGradient& grad,
                                           ParticleSet::ParticleLaplacian& lapl) {
     grad.resize(num_particles);
     lapl.resize(num_particles);
     grad           = czero;
     lapl           = czero;
     twf.log_real_  = czero;
     twf.PhaseValue = czero;
   };
   for (int iw = 0; iw < wf_list.size(); iw++)
     initGandL(wf_list[iw], g_list[iw], l_list[iw]);
 
   auto& wavefunction_components = wf_leader.Z;
   const int num_wfc             = wf_leader.Z.size();
   for (int i = 0; i < num_wfc; ++i)
   {
     ScopedTimer z_timer(wf_leader.WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->mw_evaluateLog(wfc_list, p_list, g_list, l_list);
   }
 
   for (int iw = 0; iw < wf_list.size(); iw++)
   {
     ParticleSet& pset      = p_list[iw];
     TrialWaveFunction& twf = wf_list[iw];
 
     for (int i = 0; i < num_wfc; ++i)
     {
       twf.log_real_ += std::real(twf.Z[i]->get_log_value());
       twf.PhaseValue += std::imag(twf.Z[i]->get_log_value());
     }
 
     // Ye: temporal workaround to have P.G/L always defined.
     // remove when KineticEnergy use WF.G/L instead of P.G/L
     pset.G = twf.G;
     pset.L = twf.L;
   }
 }

◆ mw_evaluateParameterDerivatives()

void mw_evaluateParameterDerivatives	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const opt_variables_type &	optvars,
		RecordArray< ValueType > &	dlogpsi,
		RecordArray< ValueType > &	dhpsioverpsi
	)

static

Definition at line 1147 of file TrialWaveFunction.cpp.

References RecordArray< T >::getNumOfParams().

Referenced by BareKineticEnergy::mw_evaluateWithParameterDerivatives(), qmcplusplus::TEST_CASE(), and qmcplusplus::test_hcpBe_rotation().

 {
   const int nparam = dlogpsi.getNumOfParams();
   for (int iw = 0; iw < wf_list.size(); iw++)
   {
     Vector<ValueType> dlogpsi_record_view(dlogpsi[iw], nparam);
     Vector<ValueType> dhpsioverpsi_record_view(dhpsioverpsi[iw], nparam);
 
     wf_list[iw].evaluateDerivatives(p_list[iw], optvars, dlogpsi_record_view, dhpsioverpsi_record_view);
   }
 }

◆ mw_evaluateRatios()

void mw_evaluateRatios	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< const VirtualParticleSet > &	Vp_list,
		const RefVector< std::vector< ValueType >> &	ratios_list,
		ComputeType	ct = `ComputeType::ALL`
	)

static

batched version of evaluateRatios Note: unlike other mw_ static functions, *this is the batch leader instead of wf_list[0].

Definition at line 1061 of file TrialWaveFunction.cpp.

References TrialWaveFunction::ALL, TrialWaveFunction::extractWFCRefList(), TrialWaveFunction::FERMIONIC, RefVectorWithLeader< T >::getLeader(), qmcplusplus::NL_TIMER, TrialWaveFunction::NONFERMIONIC, and qmcplusplus::TIMER_SKIP.

Referenced by TWFdispatcher::flex_evaluateRatios(), SOECPComponent::mw_evaluateOne(), NonLocalECPComponent::mw_evaluateOne(), and qmcplusplus::testTrialWaveFunction_diamondC_2x1x1().

 {
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[NL_TIMER]);
   auto& wavefunction_components = wf_leader.Z;
   std::vector<std::vector<ValueType>> t(ratios_list.size());
   for (int iw = 0; iw < wf_list.size(); iw++)
   {
     std::vector<ValueType>& ratios = ratios_list[iw];
     assert(vp_list[iw].getTotalNum() == ratios.size());
     std::fill(ratios.begin(), ratios.end(), 1.0);
     t[iw].resize(ratios.size());
   }
 
   for (int i = 0; i < wavefunction_components.size(); i++)
     if (ct == ComputeType::ALL || (wavefunction_components[i]->isFermionic() && ct == ComputeType::FERMIONIC) ||
         (!wavefunction_components[i]->isFermionic() && ct == ComputeType::NONFERMIONIC))
     {
       ScopedTimer z_timer(wf_leader.WFC_timers_[NL_TIMER + TIMER_SKIP * i]);
       const auto wfc_list(extractWFCRefList(wf_list, i));
       wavefunction_components[i]->mw_evaluateRatios(wfc_list, vp_list, t);
       for (int iw = 0; iw < wf_list.size(); iw++)
       {
         std::vector<ValueType>& ratios = ratios_list[iw];
         for (int j = 0; j < ratios.size(); ++j)
           ratios[j] *= t[iw][j];
       }
     }
 }

◆ mw_prepareGroup()

void mw_prepareGroup	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		int	ig
	)

static

batched version of prepareGroup

all vector sizes must match

Definition at line 508 of file TrialWaveFunction.cpp.

References TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), qmcplusplus::PREPAREGROUP_TIMER, and qmcplusplus::TIMER_SKIP.

Referenced by TWFdispatcher::flex_prepareGroup(), SOECPotential::mw_evaluateImpl(), NonLocalECPotential::mw_evaluateImpl(), and qmcplusplus::test_LiH_msd().

 {
   auto& wf_leader = wf_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[PREPAREGROUP_TIMER]);
   const int num_wfc             = wf_leader.Z.size();
   auto& wavefunction_components = wf_leader.Z;
 
   for (int i = 0; i < num_wfc; i++)
   {
     ScopedTimer z_timer(wf_leader.WFC_timers_[PREPAREGROUP_TIMER + TIMER_SKIP * i]);
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->mw_prepareGroup(wfc_list, p_list, ig);
   }
 }

◆ mw_recompute()

void mw_recompute	(	const RefVectorWithLeader< TrialWaveFunction > &	wf_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< bool > &	recompute
	)

static

batched version of recompute

Definition at line 214 of file TrialWaveFunction.cpp.

References TrialWaveFunction::extractWFCRefList(), RefVectorWithLeader< T >::getLeader(), TrialWaveFunction::recompute(), qmcplusplus::RECOMPUTE_TIMER, and qmcplusplus::TIMER_SKIP.

Referenced by TWFdispatcher::flex_recompute().

 {
   auto& wf_leader = wf_list.getLeader();
   auto& p_leader  = p_list.getLeader();
   ScopedTimer local_timer(wf_leader.TWF_timers_[RECOMPUTE_TIMER]);
 
   auto& wavefunction_components = wf_leader.Z;
   const int num_wfc             = wf_leader.Z.size();
   for (int i = 0; i < num_wfc; ++i)
   {
     ScopedTimer z_timer(wf_leader.WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->mw_recompute(wfc_list, p_list, recompute);
   }
 }

◆ operator=()

TrialWaveFunction& operator= ( const TrialWaveFunction & )

delete

◆ prepareGroup()

void prepareGroup	(	ParticleSet &	P,
		int	ig
	)

Prepare internal data for updating WFC correspond to a particle group Particle groups usually correspond to determinants of different spins.

This call can be used to handle precomputation for PbyP moves.

Parameters

P	quantum particle set
ig	particle group index

Definition at line 502 of file TrialWaveFunction.cpp.

References TrialWaveFunction::Z.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), VMCUpdatePbyP::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), NonLocalECPotential::evalIonDerivsImpl(), NonLocalECPotential::evaluateImpl(), and NonLocalECPotential::makeNonLocalMovesPbyP().

 {
   for (int i = 0; i < Z.size(); ++i)
     Z[i]->prepareGroup(P, ig);
 }

◆ printGL()

void printGL	(	ParticleSet::ParticleGradient &	G,
		ParticleSet::ParticleLaplacian &	L,
		std::string	tag = `"GL"`
	)

Definition at line 727 of file TrialWaveFunction.cpp.

References TrialWaveFunction::G, and TrialWaveFunction::L.

 {
   std::ostringstream o;
   o << "---  reporting " << tag << std::endl << "  ---" << std::endl;
   for (int iat = 0; iat < L.size(); iat++)
     o << "index: " << std::fixed << iat << std::scientific << "   G: " << G[iat][0] << "  " << G[iat][1] << "  "
       << G[iat][2] << "   L: " << L[iat] << std::endl;
   o << "---  end  ---" << std::endl;
   std::cout << o.str();
 }

◆ put()

bool put ( xmlNodePtr cur )

read from xmlNode

Definition at line 1111 of file TrialWaveFunction.cpp.

Referenced by HamiltonianFactory::addForceHam().

1111 { return true; }

◆ recompute()

void recompute ( const ParticleSet & P )

recompute the value of the orbitals which require critical accuracy

Definition at line 204 of file TrialWaveFunction.cpp.

References qmcplusplus::RECOMPUTE_TIMER, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by TrialWaveFunction::mw_evaluateDeltaLog(), and TrialWaveFunction::mw_recompute().

 {
   ScopedTimer local_timer(TWF_timers_[RECOMPUTE_TIMER]);
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[RECOMPUTE_TIMER + TIMER_SKIP * i]);
     Z[i]->recompute(P);
   }
 }

◆ registerData()

void registerData	(	ParticleSet &	P,
		WFBufferType &	buf
	)

register all the wavefunction components in buffer.

See WaveFunctionComponent::registerData for more detail

Definition at line 958 of file TrialWaveFunction.cpp.

References PooledMemory< T_scalar, Alloc >::add(), qmcplusplus::BUFFER_TIMER, TrialWaveFunction::BufferCursor, TrialWaveFunction::BufferCursor_scalar, PooledMemory< T_scalar, Alloc >::current(), PooledMemory< T_scalar, Alloc >::current_scalar(), TrialWaveFunction::log_real_, TrialWaveFunction::PhaseValue, qmcplusplus::TIMER_SKIP, TrialWaveFunction::TWF_timers_, TrialWaveFunction::WFC_timers_, and TrialWaveFunction::Z.

Referenced by RMCUpdatePbyPWithDrift::initWalkersForPbyP(), QMCUpdateBase::initWalkersForPbyP(), WaveFunctionTester::runCloneTest(), WaveFunctionTester::runRatioTest(), WaveFunctionTester::runRatioTest2(), WaveFunctionTester::runRatioV(), and qmcplusplus::TEST_CASE().

 {
   ScopedTimer local_timer(TWF_timers_[BUFFER_TIMER]);
   //save the current position
   BufferCursor        = buf.current();
   BufferCursor_scalar = buf.current_scalar();
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[BUFFER_TIMER + TIMER_SKIP * i]);
     Z[i]->registerData(P, buf);
   }
   buf.add(PhaseValue);
   buf.add(log_real_);
 }

◆ rejectMove()

void rejectMove ( int iat )

restore to the original state

Parameters

iat	index of the particle with a trial move

The proposed move of the iath particle is rejected. All the temporary data should be restored to the state prior to the move.

Definition at line 744 of file TrialWaveFunction.cpp.

References TrialWaveFunction::PhaseDiff, and TrialWaveFunction::Z.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), WaveFunctionTester::runBasicTest(), WaveFunctionTester::runNodePlot(), WaveFunctionTester::runRatioTest(), and WaveFunctionTester::runRatioTest2().

 {
   for (int i = 0; i < Z.size(); i++)
     Z[i]->restore(iat);
   PhaseDiff = 0;
 }

◆ releaseResource()

void releaseResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< TrialWaveFunction > &	wf_list
	)

static

release external resource Note: use RAII ResourceCollectionLock whenever possible

Definition at line 1223 of file TrialWaveFunction.cpp.

References TrialWaveFunction::extractWFCRefList(), and RefVectorWithLeader< T >::getLeader().

 {
   auto& wf_leader               = wf_list.getLeader();
   auto& wavefunction_components = wf_leader.Z;
   const int num_wfc             = wf_leader.Z.size();
   for (int i = 0; i < num_wfc; ++i)
   {
     const auto wfc_list(extractWFCRefList(wf_list, i));
     wavefunction_components[i]->releaseResource(collection, wfc_list);
   }
 }

◆ reportStatus()

void reportStatus ( std::ostream & os )

print out state of the trial wavefunction

Definition at line 933 of file TrialWaveFunction.cpp.

References TrialWaveFunction::extractOptimizableObjectRefs().

 {
   auto opt_obj_refs = extractOptimizableObjectRefs();
   for (OptimizableObject& obj : opt_obj_refs)
     obj.reportStatus(os);
 }

◆ resetParameters()

void resetParameters ( const opt_variables_type & active )

Set values of parameters in each component from the global list.

Definition at line 926 of file TrialWaveFunction.cpp.

References TrialWaveFunction::extractOptimizableObjectRefs().

Referenced by WaveFunctionTester::runDerivCloneTest(), WaveFunctionTester::runDerivNLPPTest(), WaveFunctionTester::runDerivTest(), qmcplusplus::TEST_CASE(), and qmcplusplus::test_hcpBe_rotation().

 {
   auto opt_obj_refs = extractOptimizableObjectRefs();
   for (OptimizableObject& obj : opt_obj_refs)
     obj.resetParametersExclusive(active);
 }

◆ resetPhaseDiff()

void resetPhaseDiff ( )

inline

Definition at line 113 of file TrialWaveFunction.h.

References TrialWaveFunction::PhaseDiff.

Referenced by SOECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOne(), NonLocalECPComponent::evaluateOneWithForces(), OneBodyDensityMatrices::generateSampleRatios(), SOECPComponent::mw_evaluateOne(), NonLocalECPComponent::mw_evaluateOne(), and WaveFunctionTester::runRatioV().

113 { PhaseDiff = 0.0; }

qmcplusplus::TrialWaveFunction::PhaseDiff

RealType PhaseDiff

diff of the phase of the trial wave function during ratio calls

Definition: TrialWaveFunction.h:544

◆ setLogPsi()

void setLogPsi ( RealType LogPsi_new )

inline

Definition at line 115 of file TrialWaveFunction.h.

References TrialWaveFunction::log_real_.

Referenced by qmcplusplus::TEST_CASE().

115 { log_real_ = LogPsi_new; }

qmcplusplus::TrialWaveFunction::log_real_

RealType log_real_

real part of trial wave function log

Definition: TrialWaveFunction.h:547

◆ setMassTerm()

void setMassTerm ( ParticleSet & P )

inline

Definition at line 485 of file TrialWaveFunction.h.

References ParticleSet::Mass, and TrialWaveFunction::OneOverM.

   {
     OneOverM = 1.0 / P.Mass[0];
     //SpeciesSet tspecies(P.getSpeciesSet());
     //int massind=tspecies.addAttribute("mass");
     //RealType mass = tspecies(massind,0);
     //OneOverM = 1.0/mass;
   }

◆ setPhase()

void setPhase ( RealType PhaseValue_new )

inline

Definition at line 108 of file TrialWaveFunction.h.

References TrialWaveFunction::PhaseValue.

108 { PhaseValue = PhaseValue_new; }

qmcplusplus::TrialWaveFunction::PhaseValue

RealType PhaseValue

sign of the trial wave function

Definition: TrialWaveFunction.h:541

◆ setTwist() [1/2]

void setTwist ( const std::vector< RealType > & t )

inline

Definition at line 481 of file TrialWaveFunction.h.

References TrialWaveFunction::myTwist.

481 { myTwist = t; }

qmcplusplus::TrialWaveFunction::myTwist

std::vector< RealType > myTwist

Definition: TrialWaveFunction.h:564

◆ setTwist() [2/2]

void setTwist ( std::vector< RealType > && t )

inline

Definition at line 482 of file TrialWaveFunction.h.

References TrialWaveFunction::myTwist.

482 { myTwist = std::move(t); }

qmcplusplus::TrialWaveFunction::myTwist

std::vector< RealType > myTwist

Definition: TrialWaveFunction.h:564

◆ size()

int size ( void ) const

inline

Definition at line 105 of file TrialWaveFunction.h.

References TrialWaveFunction::Z.

105 { return Z.size(); }

qmcplusplus::TrialWaveFunction::Z

std::vector< std::unique_ptr< WaveFunctionComponent > > Z

a list of WaveFunctionComponents constituting many-body wave functions

Definition: TrialWaveFunction.h:556

◆ storeSPOMap()

void storeSPOMap ( SPOMap && spomap )

inline

store an SPOSet map

Definition at line 505 of file TrialWaveFunction.h.

References qmcplusplus::spomap, and TrialWaveFunction::spomap_.

505 { *spomap_ = std::move(spomap); }

qmcplusplus::TrialWaveFunction::spomap_

const std::shared_ptr< SPOMap > spomap_

Owned SPOSets. Once a TWF is fully built, SPOSet lookup should be done via TWF.

Definition: TrialWaveFunction.h:529

qmcplusplus::spomap

auto & spomap

Definition: test_OneBodyDensityMatrices.cpp:366

◆ storeXMLNode()

void storeXMLNode ( xmlNodePtr node )

inline

Definition at line 500 of file TrialWaveFunction.h.

References TrialWaveFunction::myNode_, and qmcplusplus::node.

500 { myNode_ = xmlCopyNode(node, 1); }

qmcplusplus::node

if(!okay) throw std xmlNodePtr node

Definition: test_OneBodyDensityMatrices.cpp:372

qmcplusplus::TrialWaveFunction::myNode_

xmlNodePtr myNode_

XML input node for a many-body wavefunction.

Definition: TrialWaveFunction.h:526

◆ twist()

const std::vector<RealType>& twist ( ) const

inline

Definition at line 483 of file TrialWaveFunction.h.

References TrialWaveFunction::myTwist.

483 { return myTwist; }

qmcplusplus::TrialWaveFunction::myTwist

std::vector< RealType > myTwist

Definition: TrialWaveFunction.h:564

◆ updateBuffer()

TrialWaveFunction::RealType updateBuffer	(	ParticleSet &	P,
		WFBufferType &	buf,
		bool	fromscratch = `false`
	)

update all the wavefunction components in buffer.

See WaveFunctionComponent::updateBuffer for more detail

Definition at line 988 of file TrialWaveFunction.cpp.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker(), SOVMCUpdatePbyP::advanceWalker(), VMCUpdatePbyP::advanceWalker(), DMCUpdatePbyPWithRejectionFast::advanceWalker(), DMCUpdatePbyPL2::advanceWalker(), RMCUpdatePbyPWithDrift::advanceWalkersRMC(), RMCUpdatePbyPWithDrift::advanceWalkersVMC(), RMCUpdatePbyPWithDrift::initWalkersForPbyP(), QMCUpdateBase::initWalkersForPbyP(), WaveFunctionTester::runCloneTest(), WaveFunctionTester::runRatioTest(), and WaveFunctionTester::runRatioTest2().

 {
   ScopedTimer local_timer(TWF_timers_[BUFFER_TIMER]);
   P.G = 0.0;
   P.L = 0.0;
   buf.rewind(BufferCursor, BufferCursor_scalar);
   LogValue logpsi(0.0);
   for (int i = 0; i < Z.size(); ++i)
   {
     ScopedTimer z_timer(WFC_timers_[BUFFER_TIMER + TIMER_SKIP * i]);
     logpsi += Z[i]->updateBuffer(P, buf, fromscratch);
   }
 
   G = P.G;
   L = P.L;
 
   log_real_  = std::real(logpsi);
   PhaseValue = std::imag(logpsi);
   //printGL(P.G,P.L);
   buf.put(PhaseValue);
   buf.put(log_real_);
   // Ye: temperal added check, to be removed
   debugOnlyCheckBuffer(buf);
   return log_real_;
 }

◆ use_tasking()

bool use_tasking ( ) const

inline

Definition at line 498 of file TrialWaveFunction.h.

References TrialWaveFunction::use_tasking_.

498 { return use_tasking_; }

qmcplusplus::TrialWaveFunction::use_tasking_

const bool use_tasking_

if true, using internal tasking implementation

Definition: TrialWaveFunction.h:553

Member Data Documentation

◆ BufferCursor

size_t BufferCursor

private

starting index of the buffer

Definition at line 535 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::copyFromBuffer(), TrialWaveFunction::makeClone(), TrialWaveFunction::registerData(), and TrialWaveFunction::updateBuffer().

◆ BufferCursor_scalar

size_t BufferCursor_scalar

private

starting index of the scalar buffer

Definition at line 538 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::copyFromBuffer(), TrialWaveFunction::makeClone(), TrialWaveFunction::registerData(), and TrialWaveFunction::updateBuffer().

◆ G

ParticleSet::ParticleGradient G

differential gradients

Definition at line 92 of file TrialWaveFunction.h.

Referenced by ACForce::evaluate(), TrialWaveFunction::evaluateGL(), TrialWaveFunction::evaluateLog(), TrialWaveFunction::printGL(), and TrialWaveFunction::updateBuffer().

◆ L

ParticleSet::ParticleLaplacian L

differential laplacians

Definition at line 94 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::evaluateGL(), TrialWaveFunction::evaluateLog(), TrialWaveFunction::printGL(), and TrialWaveFunction::updateBuffer().

◆ log_real_

RealType log_real_

private

real part of trial wave function log

Definition at line 547 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::acceptMove(), TrialWaveFunction::copyFromBuffer(), TrialWaveFunction::evaluateDeltaLog(), TrialWaveFunction::evaluateGL(), TrialWaveFunction::evaluateLog(), TrialWaveFunction::getLogPsi(), TrialWaveFunction::registerData(), TrialWaveFunction::setLogPsi(), and TrialWaveFunction::updateBuffer().

◆ myName

const std::string myName

private

getName is in the way

Definition at line 532 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::getName(), and TrialWaveFunction::makeClone().

◆ myNode_

xmlNodePtr myNode_

private

XML input node for a many-body wavefunction.

Copied from the original one. WFOpt driver needs to look it up and make its own copies. YL: updating parameters in an XML file is extremely messy. Better to make WFOpt using h5 only.

Definition at line 526 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::getNode(), TrialWaveFunction::storeXMLNode(), and TrialWaveFunction::~TrialWaveFunction().

◆ myTwist

std::vector<RealType> myTwist

private

Definition at line 564 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::setTwist(), and TrialWaveFunction::twist().

◆ OneOverM

RealType OneOverM

private

One over mass of target particleset, needed for Local Energy Derivatives.

Definition at line 550 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::evaluateDerivatives(), TrialWaveFunction::getReciprocalMass(), TrialWaveFunction::makeClone(), and TrialWaveFunction::setMassTerm().

◆ PhaseDiff

RealType PhaseDiff

private

diff of the phase of the trial wave function during ratio calls

Definition at line 544 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::acceptMove(), TrialWaveFunction::calcRatioGrad(), TrialWaveFunction::calcRatioGradWithSpin(), TrialWaveFunction::getPhaseDiff(), TrialWaveFunction::rejectMove(), and TrialWaveFunction::resetPhaseDiff().

◆ PhaseValue

RealType PhaseValue

private

sign of the trial wave function

Definition at line 541 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::acceptMove(), TrialWaveFunction::copyFromBuffer(), TrialWaveFunction::evaluateDeltaLog(), TrialWaveFunction::evaluateGL(), TrialWaveFunction::evaluateLog(), TrialWaveFunction::getPhase(), TrialWaveFunction::registerData(), TrialWaveFunction::setPhase(), and TrialWaveFunction::updateBuffer().

◆ runtime_options_

const RuntimeOptions& runtime_options_

private

top-level runtime options from project data information > WaveFunctionPool

Definition at line 520 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::makeClone().

◆ spomap_

const std::shared_ptr<SPOMap> spomap_

private

Owned SPOSets. Once a TWF is fully built, SPOSet lookup should be done via TWF.

Definition at line 529 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::getSPOMap(), TrialWaveFunction::getSPOSet(), and TrialWaveFunction::storeSPOMap().

◆ twf_prototype

TWFFastDerivWrapper twf_prototype

private

For now, TrialWaveFunction will own the wrapper.

Definition at line 559 of file TrialWaveFunction.h.

◆ TWF_timers_

TimerList_t TWF_timers_

private

◆ use_tasking_

const bool use_tasking_

private

if true, using internal tasking implementation

Definition at line 553 of file TrialWaveFunction.h.

Referenced by TrialWaveFunction::calcRatioGrad(), TrialWaveFunction::makeClone(), and TrialWaveFunction::use_tasking().

◆ WFC_timers_

std::vector<std::reference_wrapper<NewTimer> > WFC_timers_

private

timers at WaveFunctionComponent function call level

Definition at line 563 of file TrialWaveFunction.h.

◆ Z

std::vector<std::unique_ptr<WaveFunctionComponent> > Z

private

a list of WaveFunctionComponents constituting many-body wave functions

Definition at line 556 of file TrialWaveFunction.h.

Classes

Detailed Description

Class Documentation

◆ qmcplusplus::TrialWaveFunction

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Private Member Functions

Private Attributes

Member Typedef Documentation

◆ BufferType

◆ ComplexType

◆ FullPrecRealType

◆ GradType

◆ HessType

◆ HessVector

◆ LogValue

◆ PsiValue

◆ RealType

◆ SPOMap

◆ ValueType

◆ ValueVector

◆ WFBufferType

Member Enumeration Documentation

◆ ComputeType

Constructor & Destructor Documentation

◆ TrialWaveFunction() [1/2]

◆ TrialWaveFunction() [2/2]

◆ ~TrialWaveFunction()

Member Function Documentation

◆ acceptMove()

◆ acquireResource()

◆ addComponent()

◆ calcRatio()

◆ calcRatioGrad()

◆ calcRatioGradWithSpin()

◆ checkInVariables()

◆ checkOutVariables()

◆ completeUpdates()

◆ copyFromBuffer()

◆ createResource()

◆ debugOnlyCheckBuffer()

◆ evalGrad()

◆ evalGradSource() [1/2]

◆ evalGradSource() [2/2]

◆ evalGradWithSpin()

◆ evaluateDeltaLog()

◆ evaluateDeltaLogSetup()

◆ evaluateDerivatives()

◆ evaluateDerivativesWF()

◆ evaluateDerivRatios()

◆ evaluateGL()

◆ evaluateGradDerivatives()

◆ evaluateHessian()

◆ evaluateLog()

◆ evaluateRatios()

◆ evaluateRatiosAlltoOne()

◆ evaluateSpinorRatios()

◆ extractGRefList()

◆ extractLRefList()

◆ extractOptimizableObjectRefs()

◆ extractWFCPtrList()

◆ extractWFCRefList()

◆ findMSD()

◆ getLogPsi()

◆ getLogs()

◆ getName()

◆ getNode()

◆ getOrbitals()

◆ getPhase()

◆ getPhaseDiff()

◆ getPhases()

◆ getReciprocalMass()

◆ getSPOMap()

◆ getSPOSet()

◆ initializeTWFFastDerivWrapper()

◆ KECorrection()

◆ makeClone()

◆ mw_accept_rejectMove()