DMCUpdatePbyPL2 Class Reference

Inheritance diagram for DMCUpdatePbyPL2:

Collaboration diagram for DMCUpdatePbyPL2:

Public Member Functions
	DMCUpdatePbyPL2 (MCWalkerConfiguration &w, TrialWaveFunction &psi, QMCHamiltonian &h, RandomBase< FullPrecRealType > &rg)
	Constructor. More...
	~DMCUpdatePbyPL2 () 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 . More...
RealType	m_sqrttau
	Time-step factor . 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 23 of file DMCUpdatePbyPL2.h.

Constructor & Destructor Documentation

DMCUpdatePbyPL2()

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

Constructor.

Definition at line 36 of file DMCUpdatePbyPL2.cpp.

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

~DMCUpdatePbyPL2()

~DMCUpdatePbyPL2 ( )

override

destructor

Definition at line 44 of file DMCUpdatePbyPL2.cpp.

{}

Member Function Documentation

advanceWalker()

void advanceWalker ( Walker_t &  thisWalker, bool  recompute  )

overridevirtual

move a walker

Implements QMCUpdateBase.

Definition at line 46 of file DMCUpdatePbyPL2.cpp.

References ParticleSet::accept_rejectMove(), TrialWaveFunction::acceptMove(), Walker< t_traits, p_traits >::Age, QMCHamiltonian::auxHevaluate(), QMCUpdateBase::branchEngine, SimpleFixedNodeBranch::branchWeight(), TraceManager::buffer_sample(), TrialWaveFunction::calcRatioGrad(), qmcplusplus::cholesky(), TrialWaveFunction::completeUpdates(), QMCHamiltonian::computeL2D(), QMCHamiltonian::computeL2DK(), TrialWaveFunction::copyFromBuffer(), ParticleSet::current_step, Walker< t_traits, p_traits >::DataSet, QMCUpdateBase::deltaR, QMCTraits::DIM, qmcplusplus::DMC_buffer, qmcplusplus::DMC_collectables, qmcplusplus::DMC_hamiltonian, qmcplusplus::DMC_movePbyP, qmcplusplus::DMC_tmoves, ParticleSet::donePbyP(), qmcplusplus::dot(), QMCUpdateBase::DriftModifier, TrialWaveFunction::evalGrad(), QMCHamiltonian::evaluateWithToperator(), qmcplusplus::exp(), ParticleSet::first(), ParticleSet::getActivePos(), DriftModifierBase::getDrift(), TrialWaveFunction::getPhase(), TrialWaveFunction::getPhaseDiff(), Walker< t_traits, p_traits >::getPropertyBase(), qmcplusplus::getScaledDrift(), qmcplusplus::getScaledDriftL2(), ParticleSet::groups(), QMCUpdateBase::H, QMCHamiltonian::has_L2(), qmcplusplus::Units::energy::K, ParticleSet::last(), ParticleSet::loadWalker(), QMCUpdateBase::m_r2max, qmcplusplus::makeGaussRandomWithEngine(), ParticleSet::makeMoveAndCheck(), QMCHamiltonian::makeNonLocalMoves(), QMCUpdateBase::MassInvS, DMCUpdatePbyPL2::myTimers, QMCUpdateBase::nAccept, QMCUpdateBase::nAllRejected, QMCUpdateBase::nNodeCrossing, QMCUpdateBase::NonLocalMoveAccepted, norm(), QMCUpdateBase::nReject, SimpleFixedNodeBranch::phaseChanged(), Walker< t_traits, p_traits >::Properties, QMCUpdateBase::Psi, ParticleSet::R, QMCUpdateBase::RandomGen, QMCHamiltonian::rejectedMove(), TrialWaveFunction::rejectMove(), Walker< t_traits, p_traits >::resetProperty(), QMCHamiltonian::saveProperty(), ParticleSet::saveWalker(), QMCUpdateBase::setMultiplicity(), qmcplusplus::sqrt(), QMCUpdateBase::Tau, QMCUpdateBase::Traces, TrialWaveFunction::updateBuffer(), QMCUpdateBase::W, and Walker< t_traits, p_traits >::Weight.

{
  Walker_t::WFBuffer_t& w_buffer(thisWalker.DataSet);
  {
    ScopedTimer local_timer(myTimers[DMC_buffer]);
    W.loadWalker(thisWalker, true);
    Psi.copyFromBuffer(W, w_buffer);
  }
  //create a 3N-Dimensional Gaussian with variance=1
  makeGaussRandomWithEngine(deltaR, RandomGen);
  int nAcceptTemp(0);
  int nRejectTemp(0);
  //copy the old energy and scale factor of drift
  //EstimatorRealType eold(thisWalker.Properties(LOCALENERGY));
  //EstimatorRealType enew(eold);
  FullPrecRealType eold(thisWalker.Properties(WP::LOCALENERGY));
  FullPrecRealType enew(eold);
  RealType rr_proposed = 0.0;
  RealType rr_accepted = 0.0;
  mPosType K;
  mTensorType D;
  mTensorType Dchol;
  PosType Ktmp, drtmp;
  TensorType Dtmp;
  bool L2_proj = H.has_L2();
  if (L2_proj)
  {
    Ktmp = 0.0;
    Dtmp = 0.0;
    for (int d = 0; d < DIM; d++)
      Dtmp(d, d) = 1.0;
  }
  {
    ScopedTimer local_timer(myTimers[DMC_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);
      RealType rr;
      for (int iat = W.first(ig); iat < W.last(ig); ++iat)
      {
        //W.setActive(iat);
        //get the displacement
        GradType grad_iat = Psi.evalGrad(W, iat);
        mPosType dr;
        mPosType dr_diff = deltaR[iat];
        if (!L2_proj) // normal projector
        {
          getScaledDrift(tauovermass, grad_iat, dr);
          dr += sqrttau * dr_diff;
          rr = tauovermass * dot(dr_diff, dr_diff);
          rr_proposed += rr;
          if (rr > m_r2max)
          {
            ++nRejectTemp;
            W.accept_rejectMove(iat, false);
            continue;
          }
          if (!W.makeMoveAndCheck(iat, dr))
          {
            W.accept_rejectMove(iat, false);
            continue;
          }
        }
        else // projector including L2 potential
        {
          // do a fake move (zero distance)
          // this ensures the temporary distance data is correct
          // will need to remove this later, but requires reimplementation of computeL2DK
          dr = 0.0;
          if (!W.makeMoveAndCheck(iat, dr))
          {
            W.accept_rejectMove(iat, false);
            continue;
          }

          H.computeL2DK(W, iat, Dtmp, Ktmp);
          D = Dtmp; // upcast for mixed precision
          K = Ktmp;
          getScaledDriftL2(tauovermass, grad_iat, D, K, dr);

          W.accept_rejectMove(iat, false);
          rr = tauovermass * dot(dr_diff, dr_diff);
          rr_proposed += rr;
          if (rr > m_r2max)
          {
            ++nRejectTemp;
            W.accept_rejectMove(iat, false);
            continue;
          }

          // move with just drift to update distance tables
          if (!W.makeMoveAndCheck(iat, dr))
          {
            W.accept_rejectMove(iat, false);
            continue;
          }

          // compute diffusion step
          H.computeL2D(W, iat, Dtmp);
          D       = Dtmp; // upcast for mixed precision
          Dchol   = cholesky(D);
          dr_diff = dot(Dchol, dr_diff);
          dr += sqrttau * dr_diff;

          // reverse the intermediate drift move
          W.accept_rejectMove(iat, false);
          // move with drift and diffusion together
          if (!W.makeMoveAndCheck(iat, dr))
          {
            W.accept_rejectMove(iat, false);
            continue;
          }
        }
        ValueType ratio = Psi.calcRatioGrad(W, iat, grad_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]);
          //Use the force of the particle iat
          DriftModifier->getDrift(tauovermass, grad_iat, drtmp);
          dr                     = drtmp; // upcast for mixed precision
          dr                     = W.R[iat] - W.getActivePos() - dr;
          FullPrecRealType logGb = -oneover2tau * dot(dr, dr);
          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[DMC_buffer]);
      thisWalker.Age = 0;
      logpsi         = Psi.updateBuffer(W, w_buffer, recompute);
      W.saveWalker(thisWalker);
    }
    {
      ScopedTimer local_timer(myTimers[DMC_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[DMC_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[DMC_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 37 of file DMCUpdatePbyPL2.h.

Referenced by DMCUpdatePbyPL2::advanceWalker().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/DMC/DMCUpdatePbyPL2.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/DMC/DMCUpdatePbyPL2.cpp