Inheritance diagram for SODMCUpdatePbyPWithRejectionFast:

Collaboration diagram for SODMCUpdatePbyPWithRejectionFast:

Public Member Functions
	SODMCUpdatePbyPWithRejectionFast (MCWalkerConfiguration &w, TrialWaveFunction &psi, QMCHamiltonian &h, RandomBase< FullPrecRealType > &rg)
	Constructor. More...

	~SODMCUpdatePbyPWithRejectionFast () override
	destructor More...

void	advanceWalker (Walker_t &thisWalker, bool recompute) override
	move a walker More...

Public Member Functions inherited from QMCUpdateBase
	QMCUpdateBase (MCWalkerConfiguration &w, TrialWaveFunction &psi, QMCHamiltonian &h, RandomBase< FullPrecRealType > &rg)
	Constructor. More...

	QMCUpdateBase (MCWalkerConfiguration &w, TrialWaveFunction &psi, TrialWaveFunction &guide, QMCHamiltonian &h, RandomBase< FullPrecRealType > &rg)
	Alt Constructor. More...

virtual	~QMCUpdateBase ()
	destructor More...

RealType	acceptRatio () const

void	resetRun (BranchEngineType brancher, EstimatorManagerBase est, TraceManager traces, const DriftModifierBase driftmodifer)
	reset the QMCUpdateBase parameters More...

void	resetRun2 (BranchEngineType brancher, EstimatorManagerBase est, TraceManager traces, WalkerLogCollector wlog_collector_, const DriftModifierBase *driftmodifer)

RealType	getTau ()

void	setTau (RealType t)

RealType	getSpinMass ()

void	setSpinMass (RealType m)

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

void	set_step (int step)

void	startRun (int blocks, bool record)
	start a run More...

void	stopRun ()
	stop a run More...

void	stopRun2 ()

void	startBlock (int steps)
	prepare to start a block More...

void	stopBlock (bool collectall=true)
	stop a block More...

void	setMultiplicity (WalkerIter_t it, WalkerIter_t it_end)
	set the multiplicity of the walkers to branch More...

void	setMultiplicity (Walker_t &awalker) const

virtual void	initWalkersForPbyP (WalkerIter_t it, WalkerIter_t it_end)
	initialize Walker buffers for PbyP update More...

virtual void	initWalkers (WalkerIter_t it, WalkerIter_t it_end)
	initialize Walker for walker update More...

virtual bool	put (xmlNodePtr cur)
	process options More...

void	accumulate (WalkerIter_t it, WalkerIter_t it_end)

virtual void	advanceWalkers (WalkerIter_t it, WalkerIter_t it_end, bool recompute)
	advance walkers executed at each step More...

virtual RealType	advanceWalkerForEE (Walker_t &w1, std::vector< PosType > &dR, std::vector< int > &iats, std::vector< int > &rs, std::vector< RealType > &ratios)

int	RMC_checkIndex (int N, int NMax)

void	RMC_checkWalkerBounds (WalkerIter_t &it, WalkerIter_t first, WalkerIter_t last)

RealType	logBackwardGF (const ParticleSet::ParticlePos &displ)

Private Attributes
TimerList_t	myTimers

Additional Inherited Members
Public Types inherited from QMCUpdateBase
using	Walker_t = MCWalkerConfiguration::Walker_t

using	WalkerIter_t = MCWalkerConfiguration::iterator

using	BranchEngineType = SimpleFixedNodeBranch

using	mPosType = PosType

using	mTensorType = TensorType

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

using	QTBase = QMCTypes< OHMMS_PRECISION, DIM >

using	QTFull = QMCTypes< OHMMS_PRECISION_FULL, DIM >

using	RealType = QTBase::RealType

using	ComplexType = QTBase::ComplexType

using	ValueType = QTBase::ValueType

using	PosType = QTBase::PosType

using	GradType = QTBase::GradType

using	TensorType = QTBase::TensorType

using	IndexType = OHMMS_INDEXTYPE
	define other types More...

using	FullPrecRealType = QTFull::RealType

using	FullPrecValueType = QTFull::ValueType

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

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

Public Attributes inherited from QMCUpdateBase
int	nSubSteps
	number of steps per measurement More...

DriverDebugChecks	debug_checks_ = DriverDebugChecks::ALL_OFF
	determine additional checks for debugging purpose More...

std::string	debug_checks_str_

IndexType	MaxAge
	MaxAge>0 indicates branch is done. More...

IndexType	nAccept
	counter for number of moves accepted More...

IndexType	nReject
	counter for number of moves rejected More...

IndexType	nAllRejected
	Total number of the steps when all the particle moves are rejected. More...

IndexType	nNodeCrossing
	Total number of node crossings per block. More...

IndexType	NonLocalMoveAccepted
	Total numer of non-local moves accepted. More...

RealType	Tau
	timestep More...

RealType	spinMass
	spin mass More...

bool	UseDrift
	use Drift More...

RealType	csoffset
	normalization offset for cs type runs. More...

TraceManager *	Traces
	traces More...

WalkerLogCollector *	wlog_collector

Protected Member Functions inherited from QMCUpdateBase
RealType	getNodeCorrection (const ParticleSet::ParticleGradient &g, ParticleSet::ParticlePos &gscaled)
	evaluate the ratio of scaled velocity and velocity More...

	QMCUpdateBase (const QMCUpdateBase &)=delete
	copy constructor (disabled) More...

Static Protected Member Functions inherited from QMCUpdateBase
static void	checkLogAndGL (ParticleSet &pset, TrialWaveFunction &twf, const std::string_view location)
	check logpsi and grad and lap against values computed from scratch More...

Protected Attributes inherited from QMCUpdateBase
bool	UpdatePbyP
	update particle-by-particle More...

IndexType	NumPtcl
	number of particles More...

RealType	m_oneover2tau
	Time-step factor $1/(2\tau)$ . More...

RealType	m_sqrttau
	Time-step factor $\sqrt{\tau}$ . More...

RealType	m_tauovermass
	tau/mass More...

RealType	m_r2max
	maximum displacement^2 More...

MCWalkerConfiguration &	W
	walker ensemble More...

TrialWaveFunction &	Psi
	trial function More...

TrialWaveFunction &	Guide
	guide function More...

QMCHamiltonian &	H
	Hamiltonian. More...

RandomBase< FullPrecRealType > &	RandomGen
	random number generator More...

const BranchEngineType *	branchEngine
	branch engine, stateless reference to the one in QMCDriver More...

const DriftModifierBase *	DriftModifier
	drift modifer, stateless reference to the one in QMCDriver More...

EstimatorManagerBase *	Estimators
	estimator More...

ParameterSet	myParams
	parameters More...

std::vector< RealType >	MassInvS
	1/Mass per species More...

std::vector< RealType >	MassInvP
	1/Mass per particle More...

std::vector< RealType >	SqrtTauOverMass
	sqrt(tau/Mass) per particle More...

ParticleSet::ParticlePos	drift
	temporary storage for drift More...

ParticleSet::ParticlePos	deltaR
	temporary storage for random displacement More...

ParticleSet::ParticleScalar	deltaS
	temporart storage for spin displacement More...

ParticleSet::ParticleGradient	G
	storage for differential gradients for PbyP update More...

ParticleSet::ParticleGradient	dG

ParticleSet::ParticleLaplacian	L
	storage for differential laplacians for PbyP update More...

ParticleSet::ParticleLaplacian	dL

Detailed Description

Definition at line 19 of file SODMCUpdatePbyP.h.

Constructor & Destructor Documentation

◆ SODMCUpdatePbyPWithRejectionFast()

SODMCUpdatePbyPWithRejectionFast	(	MCWalkerConfiguration &	w,
		TrialWaveFunction &	psi,
		QMCHamiltonian &	h,
		RandomBase< FullPrecRealType > &	rg
	)

Constructor.

Definition at line 39 of file SODMCUpdatePbyPFast.cpp.

     : QMCUpdateBase(w, psi, h, rg), myTimers(getGlobalTimerManager(), SODMCTimerNames, timer_level_medium)
 
 {}

◆ ~SODMCUpdatePbyPWithRejectionFast()

~SODMCUpdatePbyPWithRejectionFast ( )

override

destructor

Definition at line 48 of file SODMCUpdatePbyPFast.cpp.

48 {}

Member Function Documentation

◆ advanceWalker()

void advanceWalker	(	Walker_t &	thisWalker,
		bool	recompute
	)

overridevirtual

move a walker

Implements QMCUpdateBase.

Definition at line 50 of file SODMCUpdatePbyPFast.cpp.

 {
   Walker_t::WFBuffer_t& w_buffer(thisWalker.DataSet);
   {
     ScopedTimer local_timer(myTimers[SODMC_buffer]);
     W.loadWalker(thisWalker, true);
     Psi.copyFromBuffer(W, w_buffer);
   }
   //create a 3N-Dimensional Gaussian with variance=1
   makeGaussRandomWithEngine(deltaR, RandomGen);
   makeGaussRandomWithEngine(deltaS, RandomGen);
   int nAcceptTemp(0);
   int nRejectTemp(0);
   //copy the old energy and scale factor of drift
   FullPrecRealType eold(thisWalker.Properties(WP::LOCALENERGY));
   FullPrecRealType enew(eold);
   RealType rr_proposed = 0.0;
   RealType rr_accepted = 0.0;
   {
     ScopedTimer local_timer(myTimers[SODMC_movePbyP]);
     for (int ig = 0; ig < W.groups(); ++ig) //loop over species
     {
       RealType tauovermass = Tau * MassInvS[ig];
       RealType oneover2tau = 0.5 / (tauovermass);
       RealType sqrttau     = std::sqrt(tauovermass);
       Psi.prepareGroup(W, ig);
       for (int iat = W.first(ig); iat < W.last(ig); ++iat)
       {
         //get the displacement
         ComplexType spingrad_iat;
         GradType grad_iat = Psi.evalGradWithSpin(W, iat, spingrad_iat);
         PosType dr;
         ParticleSet::Scalar_t ds;
         DriftModifier->getDrift(tauovermass, grad_iat, dr);
         DriftModifier->getDrift(tauovermass / spinMass, spingrad_iat, ds);
         dr += sqrttau * deltaR[iat];
         ds += std::sqrt(tauovermass / spinMass) * deltaS[iat];
         bool is_valid = W.makeMoveAndCheckWithSpin(iat, dr, ds);
         RealType rr   = tauovermass * dot(deltaR[iat], deltaR[iat]);
         rr_proposed += rr;
         if (!is_valid || rr > m_r2max)
         {
           ++nRejectTemp;
           W.accept_rejectMove(iat, false);
           continue;
         }
         ValueType ratio = Psi.calcRatioGradWithSpin(W, iat, grad_iat, spingrad_iat);
         //node is crossed reject the move
         if (branchEngine->phaseChanged(Psi.getPhaseDiff()))
         {
           ++nRejectTemp;
           ++nNodeCrossing;
           W.accept_rejectMove(iat, false);
           Psi.rejectMove(iat);
         }
         else
         {
           FullPrecRealType logGf = -0.5 * dot(deltaR[iat], deltaR[iat]);
           logGf += -0.5 * deltaS[iat] * deltaS[iat];
           //Use the force of the particle iat
           DriftModifier->getDrift(tauovermass, grad_iat, dr);
           DriftModifier->getDrift(tauovermass / spinMass, spingrad_iat, ds);
           dr                     = W.R[iat] - W.getActivePos() - dr;
           ds                     = W.spins[iat] - W.getActiveSpinVal() - ds;
           FullPrecRealType logGb = -oneover2tau * dot(dr, dr);
           logGb += -spinMass * oneover2tau * ds * ds;
           RealType prob    = std::norm(ratio) * std::exp(logGb - logGf);
           bool is_accepted = false;
 
           if (RandomGen() < prob)
           {
             is_accepted = true;
 
             ++nAcceptTemp;
             Psi.acceptMove(W, iat, true);
             rr_accepted += rr;
           }
           else
           {
             ++nRejectTemp;
             Psi.rejectMove(iat);
           }
           W.accept_rejectMove(iat, is_accepted);
         }
       }
     }
     Psi.completeUpdates();
     W.donePbyP();
   }
 
   if (nAcceptTemp > 0)
   {
     //need to overwrite the walker properties
     RealType logpsi(0);
     {
       ScopedTimer local_timer(myTimers[SODMC_buffer]);
       thisWalker.Age = 0;
       logpsi         = Psi.updateBuffer(W, w_buffer, recompute);
       if (debug_checks_ & DriverDebugChecks::CHECKGL_AFTER_MOVES)
         checkLogAndGL(W, Psi, "checkGL_after_moves");
       W.saveWalker(thisWalker);
     }
     {
       ScopedTimer local_timer(myTimers[SODMC_hamiltonian]);
       enew = H.evaluateWithToperator(W);
     }
     thisWalker.resetProperty(logpsi, Psi.getPhase(), enew, rr_accepted, rr_proposed, 1.0);
     thisWalker.Weight *= branchEngine->branchWeight(enew, eold);
     {
       ScopedTimer local_timer(myTimers[SODMC_collectables]);
       H.auxHevaluate(W, thisWalker);
       H.saveProperty(thisWalker.getPropertyBase());
     }
   }
   else
   {
     //all moves are rejected: does not happen normally with reasonable wavefunctions
     thisWalker.Age++;
     thisWalker.Properties(WP::R2ACCEPTED) = 0.0;
     //weight is set to 0 for traces
     // consistent w/ no evaluate/auxHevaluate
     RealType wtmp     = thisWalker.Weight;
     thisWalker.Weight = 0.0;
     H.rejectedMove(W, thisWalker);
     thisWalker.Weight = wtmp;
     ++nAllRejected;
     enew = eold; //copy back old energy
     thisWalker.Weight *= branchEngine->branchWeight(enew, eold);
   }
 #if !defined(REMOVE_TRACEMANAGER)
   Traces->buffer_sample(W.current_step);
 #endif
   {
     ScopedTimer local_timer(myTimers[SODMC_tmoves]);
     const int NonLocalMoveAcceptedTemp = H.makeNonLocalMoves(W);
     if (NonLocalMoveAcceptedTemp > 0)
     {
       RealType logpsi = Psi.updateBuffer(W, w_buffer, false);
       W.saveWalker(thisWalker);
       NonLocalMoveAccepted += NonLocalMoveAcceptedTemp;
     }
   }
   nAccept += nAcceptTemp;
   nReject += nRejectTemp;
 
   setMultiplicity(thisWalker);
 }

Member Data Documentation

◆ myTimers

TimerList_t myTimers

private

Definition at line 33 of file SODMCUpdatePbyP.h.

Referenced by SODMCUpdatePbyPWithRejectionFast::advanceWalker().

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

/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/DMC/SODMCUpdatePbyP.h
/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/DMC/SODMCUpdatePbyPFast.cpp

Public Member Functions

Private Attributes

Additional Inherited Members