Move all the particles for each walker. More...

Collaboration diagram for QMC Drivers using walker-by-walker update:

Classes
class	CSVMC
	Implements the VMC algorithm using umbrella sampling. More...

class	CSVMCUpdateAll
	Implements the VMC algorithm using umbrella sampling. More...

Detailed Description

Move all the particles for each walker.

Class Documentation

◆ qmcplusplus::CSVMC

class qmcplusplus::CSVMC

Implements the VMC algorithm using umbrella sampling.

Energy difference method with multiple H/Psi. Consult S. Chiesa's note.

Definition at line 34 of file CSVMC.h.

Inheritance diagram for CSVMC:

Collaboration diagram for CSVMC:

Public Member Functions
	CSVMC (const ProjectData &project_data, MCWalkerConfiguration &w, TrialWaveFunction &psi, QMCHamiltonian &h, Communicate *comm)
	Constructor. More...

bool	run () override
	Run the CSVMC algorithm. More...

bool	put (xmlNodePtr cur) override
	allocate internal data here before run() is called More...

QMCRunType	getRunType () override

Public Member Functions inherited from QMCDriver
	QMCDriver (const ProjectData &project_data, MCWalkerConfiguration &w, TrialWaveFunction &psi, QMCHamiltonian &h, Communicate *comm, const std::string &QMC_driver_type, bool enable_profiling=false)
	Constructor. More...

	~QMCDriver () override

int	current () const
	return current step More...

void	setUpdateMode (bool pbyp) override
	set the update mode More...

void	setStatus (const std::string &aname, const std::string &h5name, bool append) override
	Set the status of the QMCDriver. More...

void	add_H_and_Psi (QMCHamiltonian h, TrialWaveFunction psi) override
	add QMCHamiltonian/TrialWaveFunction pair for multiple More...

void	process (xmlNodePtr cur) override
	initialize with xmlNode More...

xmlNodePtr	getQMCNode ()
	return a xmlnode with update More...

void	putWalkers (std::vector< xmlNodePtr > &wset) override
	Read walker configurations from *.config.h5 files. More...

void	putTraces (xmlNodePtr txml) override

void	requestTraces (bool traces) override

void	putWalkerLogs (xmlNodePtr wlxml) override

void	requestWalkerLogs (bool allow_walker_logs_) override

std::string	getEngineName () override

template<class PDT >
void	setValue (const std::string &aname, PDT x)

void	setBranchEngine (std::unique_ptr< BranchEngineType > &&be) override
	set the BranchEngineType More...

std::unique_ptr< BranchEngineType >	getBranchEngine () override
	return BranchEngineType* More...

int	addObservable (const std::string &aname)

RealType	getObservable (int i)

void	setTau (RealType i)

void	setWalkerOffsets ()
	set global offsets of the walkers More...

RefVector< RandomBase< FullPrecRealType > >	getRngRefs () const
	return the random generators More...

RandomBase< FullPrecRealType > &	getRng (int i) override
	return the i-th random generator More...

unsigned long	getDriverMode () override

Public Member Functions inherited from QMCDriverInterface
virtual	~QMCDriverInterface ()

virtual void	setBranchEngine (std::unique_ptr< BranchEngineType > &&be)

Public Member Functions inherited from MPIObjectBase
	MPIObjectBase (Communicate *c)
	constructor with communicator More...

int	rank () const
	return the rank of the communicator More...

int	getGroupID () const
	return the group id of the communicator More...

Communicate *	getCommunicator () const
	return myComm More...

Communicate &	getCommRef () const
	return a TEMPORARY reference to Communicate More...

mpi_comm_type	getMPI () const
	return MPI communicator if one wants to use MPI directly More...

bool	is_manager () const
	return true if the rank == 0 More...

const std::string &	getName () const
	return the name More...

void	setName (const std::string &aname)

Public Member Functions inherited from CloneManager
	CloneManager ()
	Constructor. More...

virtual	~CloneManager ()
	virtual destructor More...

void	makeClones (MCWalkerConfiguration &w, TrialWaveFunction &psi, QMCHamiltonian &ham)

void	makeClones (MCWalkerConfiguration &w, std::vector< TrialWaveFunction > &psi, std::vector< QMCHamiltonian > &ham)

void	makeClones (MCWalkerConfiguration &wg, TrialWaveFunction &guide)

void	makeClones (TrialWaveFunction &guide)

RealType	acceptRatio () const

Private Member Functions
	CSVMC (const CSVMC &)=delete
	Copy Constructor (disabled) More...

CSVMC &	operator= (const CSVMC &)=delete
	Copy operator (disabled). More...

void	resetRun ()

Private Attributes
std::string	UseDrift

int	prevSteps

int	prevStepsBetweenSamples

int	equilBlocks
	blocks over which normalization factors are accumulated More...

CSEnergyEstimator *	multiEstimator

CSUpdateBase *	Mover

Additional Inherited Members
Public Types inherited from QMCDriver
enum	{ QMC_UPDATE_MODE, QMC_MULTIPLE, QMC_OPTIMIZE, QMC_WARMUP }
	enumeration coupled with QMCMode More...

using	Walker_t = MCWalkerConfiguration::Walker_t

using	Buffer_t = Walker_t::Buffer_t

using	FullPrecRealType = QMCTraits::FullPrecRealType

Public Types inherited from QMCDriverInterface
using	BranchEngineType = SimpleFixedNodeBranch

using	FullPrecRealType = QMCTraits::FullPrecRealType

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 Types inherited from MPIObjectBase
using	mpi_comm_type = Communicate::mpi_comm_type

Static Public Member Functions inherited from CloneManager
static void	clearClones ()

Public Attributes inherited from QMCDriver
std::bitset< QMC_MODE_MAX >	qmc_driver_mode
	bits to classify QMCDriver More...

bool	allow_traces
	whether to allow traces More...

xmlNodePtr	traces_xml
	traces xml More...

bool	allow_walker_logs
	whether to allow traces More...

xmlNodePtr	walker_logs_xml
	traces xml More...

EstimatorManagerBase *	Estimators
	Observables manager. More...

std::unique_ptr< TraceManager >	Traces
	Traces manager. More...

std::unique_ptr< WalkerLogManager >	wlog_manager_
	Traces manager. More...

Protected Member Functions inherited from QMCDriver
bool	putQMCInfo (xmlNodePtr cur)
	Parses the xml input file for parameter definitions for a single qmc simulation. More...

void	addWalkers (int nwalkers)
	Add walkers to the end of the ensemble of walkers. More...

void	recordBlock (int block) override
	record the state of the block More...

bool	finalize (int block, bool dumpwalkers=true)
	finalize a qmc section More...

std::string	getRotationName (std::string RootName)

std::string	getLastRotationName (std::string RootName)

const std::string &	get_root_name () const override

Protected Member Functions inherited from CloneManager
RefVector< WalkerLogCollector >	getWalkerLogCollectorRefs ()

Protected Attributes inherited from QMCDriver
const ProjectData &	project_data_
	top-level project data information More...

std::unique_ptr< BranchEngineType >	branchEngine
	branch engine More...

DriftModifierBase *	DriftModifier
	drift modifer More...

bool	ResetRandom
	randomize it More...

bool	AppendRun
	flag to append or restart the run More...

bool	DumpConfig
	flag to turn off dumping configurations More...

bool	IsQMCDriver
	true, if it is a real QMC engine More...

int	MyCounter
	the number of times this QMCDriver is executed More...

int	kDelay
	the number to delay updates by More...

int	Period4CheckPoint
	period of dumping walker configurations and everything else for restart More...

int	Period4CheckProperties
	period of dumping walker positions and IDs for Forward Walking More...

int	Period4WalkerDump
	period of recording walker configurations More...

int	Period4ConfigDump
	period of recording walker positions and IDs for forward walking afterwards More...

IndexType	CurrentStep
	current step More...

IndexType	nBlocks
	maximum number of blocks More...

IndexType	nSteps
	maximum number of steps More...

IndexType	nSubSteps
	number of steps between a step: VMCs do not evaluate energies More...

IndexType	nWarmupSteps
	number of warmup steps More...

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

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

IndexType	nBlocksBetweenRecompute
	the number of blocks between recomptePsi More...

IndexType	nTargetWalkers
	the number of walkers More...

IndexType	nTargetSamples
	the number of saved samples More...

IndexType	nStepsBetweenSamples
	alternate method of setting QMC run parameters More...

RealType	nSamplesPerThread
	samples per thread More...

RealType	nTargetPopulation
	target population More...

RealType	Tau
	timestep More...

int	MaxCPUSecs
	maximum cpu in secs More...

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

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

xmlNodePtr	qmcNode
	pointer to qmc node in xml file More...

const std::string	QMCType
	type of QMC driver More...

std::string	h5FileRoot
	the root of h5File More...

std::string	RootName
	root of all the output files More...

ParameterSet	m_param
	store any parameter that has to be read from a file More...

MCWalkerConfiguration &	W
	walker ensemble More...

TrialWaveFunction &	Psi
	trial function More...

QMCHamiltonian &	H
	Hamiltonian. More...

std::unique_ptr< HDFWalkerOutput >	wOut
	record engine for walkers More...

std::vector< TrialWaveFunction * >	Psi1
	a list of TrialWaveFunctions for multiple method More...

std::vector< QMCHamiltonian * >	H1
	a list of QMCHamiltonians for multiple method More...

UPtrVector< RandomBase< FullPrecRealType > >	Rng
	Random number generators. More...

std::vector< xmlNodePtr >	mcwalkerNodePtr
	a list of mcwalkerset element More...

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

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

RealType	SpinMass
	spin mass for spinor calcs More...

int	rotation

Protected Attributes inherited from MPIObjectBase
Communicate *	myComm
	pointer to Communicate More...

std::string	ClassName
	class Name More...

std::string	myName
	name of the object More...

Protected Attributes inherited from CloneManager
const IndexType	NumThreads
	number of threads More...

std::vector< QMCUpdateBase * >	Movers
	update engines More...

std::vector< EstimatorManagerBase * >	estimatorClones
	estimator managers More...

std::vector< TraceManager * >	traceClones
	trace managers More...

UPtrVector< WalkerLogCollector >	wlog_collectors
	trace collectors More...

UPtrVector< CSUpdateBase >	CSMovers

std::vector< int >	wPerRank
	Walkers per MPI rank. More...

Static Protected Attributes inherited from CloneManager
static UPtrVector< MCWalkerConfiguration >	wClones_uptr
	walkers More...

static std::vector< MCWalkerConfiguration * >	wClones

static UPtrVector< MCWalkerConfiguration >	wgClones

static UPtrVector< TrialWaveFunction >	psiClones_uptr
	trial wavefunctions More...

static std::vector< TrialWaveFunction * >	psiClones

static UPtrVector< TrialWaveFunction >	guideClones_uptr
	guide wavefunctions More...

static std::vector< TrialWaveFunction * >	guideClones

static UPtrVector< QMCHamiltonian >	hClones_uptr
	Hamiltonians. More...

static std::vector< QMCHamiltonian * >	hClones

static std::vector< UPtrVector< MCWalkerConfiguration > >	WPoolClones_uptr

static std::vector< std::vector< MCWalkerConfiguration * > >	WPoolClones

static std::vector< UPtrVector< TrialWaveFunction > >	PsiPoolClones_uptr

static std::vector< std::vector< TrialWaveFunction * > >	PsiPoolClones

static std::vector< UPtrVector< QMCHamiltonian > >	HPoolClones_uptr

static std::vector< std::vector< QMCHamiltonian * > >	HPoolClones

Constructor & Destructor Documentation

◆ CSVMC() [1/2]

CSVMC	(	const ProjectData &	project_data,
		MCWalkerConfiguration &	w,
		TrialWaveFunction &	psi,
		QMCHamiltonian &	h,
		Communicate *	comm
	)

Constructor.

Definition at line 37 of file CSVMC.cpp.

References ParameterSet::add(), CSVMC::equilBlocks, QMCDriver::m_param, QMCDriver::qmc_driver_mode, QMCDriver::QMC_MULTIPLE, QMCDriver::RootName, and CSVMC::UseDrift.

     : QMCDriver(project_data, w, psi, h, comm, "CSVMC"), UseDrift("yes"), multiEstimator(0), Mover(0)
 {
   RootName = "csvmc";
   m_param.add(UseDrift, "useDrift");
   m_param.add(UseDrift, "usedrift");
   m_param.add(UseDrift, "use_drift");
   equilBlocks = -1;
   m_param.add(equilBlocks, "equilBlocks");
   qmc_driver_mode.set(QMC_MULTIPLE, 1);
 }

◆ CSVMC() [2/2]

CSVMC ( const CSVMC & )

privatedelete

Copy Constructor (disabled)

Member Function Documentation

◆ getRunType()

QMCRunType getRunType ( )

inlineoverridevirtual

Implements QMCDriverInterface.

Definition at line 46 of file CSVMC.h.

References qmcplusplus::CSVMC.

46 { return QMCRunType::CSVMC; }

qmcplusplus::QMCRunType::CSVMC

◆ operator=()

CSVMC& operator= ( const CSVMC & )

privatedelete

Copy operator (disabled).

◆ put()

bool put ( xmlNodePtr q )

overridevirtual

allocate internal data here before run() is called

Author: SIMONE

See QMCDriver::process

Implements QMCDriverInterface.

Definition at line 58 of file CSVMC.cpp.

References ParameterSet::add(), qmcplusplus::app_log(), qmcplusplus::ceil(), QMCDriver::CurrentStep, QMCDriver::DumpConfig, ParameterSet::get(), WalkerConfigurations::getActiveWalkers(), QMCDriver::m_param, MPIObjectBase::myComm, QMCDriver::MyCounter, QMCDriver::nBlocks, QMCDriver::nSamplesPerThread, QMCDriver::nSteps, QMCDriver::nStepsBetweenSamples, QMCDriver::nSubSteps, QMCDriver::nTargetPopulation, QMCDriver::nTargetSamples, omp_get_max_threads(), QMCDriver::Period4CheckPoint, QMCDriver::Period4WalkerDump, CSVMC::prevSteps, CSVMC::prevStepsBetweenSamples, ParameterSet::put(), qmcplusplus::qmc_common, QMCState::qmc_counter, Communicate::size(), QMCDriver::Tau, and QMCDriver::W.

 {
   int target_min = -1;
   ParameterSet p;
   p.add(target_min, "minimumtargetwalkers");
   p.add(target_min, "minimumsamples");
   p.put(q);
 
   app_log() << "\n<vmc function=\"put\">"
             << "\n  qmc_counter=" << qmc_common.qmc_counter << "  my_counter=" << MyCounter << std::endl;
   if (qmc_common.qmc_counter && MyCounter)
   {
     nSteps               = prevSteps;
     nStepsBetweenSamples = prevStepsBetweenSamples;
   }
   else
   {
     int nw = W.getActiveWalkers();
     //compute samples and overwrite steps for the given samples
     int Nthreads = omp_get_max_threads();
     int Nprocs   = myComm->size();
     //target samples set by samples or samplesperthread/dmcwalkersperthread
     nTargetPopulation = std::max(nTargetPopulation, nSamplesPerThread * Nprocs * Nthreads);
     nTargetSamples    = static_cast<int>(std::ceil(nTargetPopulation));
 
     if (nTargetSamples)
     {
       int nwtot      = nw * Nprocs; //total number of walkers used by this qmcsection
       nTargetSamples = std::max(nwtot, nTargetSamples);
       if (target_min > 0)
       {
         nTargetSamples    = std::max(nTargetSamples, target_min);
         nTargetPopulation = std::max(nTargetPopulation, static_cast<RealType>(target_min));
       }
       nTargetSamples = ((nTargetSamples + nwtot - 1) / nwtot) *
           nwtot; // nTargetSamples are always multiples of total number of walkers
       nSamplesPerThread = nTargetSamples / Nprocs / Nthreads;
       int ns_target     = nTargetSamples * nStepsBetweenSamples; //total samples to generate
       int ns_per_step   = Nprocs * nw;                           //total samples per step
       nSteps            = std::max(nSteps, (ns_target / ns_per_step + nBlocks - 1) / nBlocks);
       Period4WalkerDump = nStepsBetweenSamples = (ns_per_step * nSteps * nBlocks) / nTargetSamples;
     }
     else
     {
       Period4WalkerDump = nStepsBetweenSamples = (nBlocks + 1) * nSteps; //some positive number, not used
       nSamplesPerThread                        = 0;
     }
   }
   prevSteps               = nSteps;
   prevStepsBetweenSamples = nStepsBetweenSamples;
 
   app_log() << "  time step      = " << Tau << std::endl;
   app_log() << "  blocks         = " << nBlocks << std::endl;
   app_log() << "  steps          = " << nSteps << std::endl;
   app_log() << "  substeps       = " << nSubSteps << std::endl;
   app_log() << "  current        = " << CurrentStep << std::endl;
   app_log() << "  target samples = " << nTargetPopulation << std::endl;
   app_log() << "  walkers/mpi    = " << W.getActiveWalkers() << std::endl << std::endl;
   app_log() << "  stepsbetweensamples = " << nStepsBetweenSamples << std::endl;
 
   m_param.get(app_log());
 
   if (DumpConfig)
   {
     app_log() << "  DumpConfig==true Configurations are dumped to config.h5 with a period of " << Period4CheckPoint
               << " blocks" << std::endl;
   }
   else
   {
     app_log() << "  DumpConfig==false Nothing (configurations, state) will be saved." << std::endl;
   }
 
   if (Period4WalkerDump > 0)
     app_log() << "  Walker Samples are dumped every " << Period4WalkerDump << " steps." << std::endl;
 
   app_log() << "</vmc>" << std::endl;
   app_log().flush();
 
   return true;
 }

◆ resetRun()

void resetRun ( )

private

Definition at line 210 of file CSVMC.cpp.

References APP_ABORT, qmcplusplus::app_log(), WalkerConfigurations::begin(), QMCDriver::branchEngine, RandomNumberControl::Children, copy(), CloneManager::CSMovers, QMCDriver::DriftModifier, CloneManager::estimatorClones, QMCDriver::Estimators, FairDivideLow(), WalkerConfigurations::getActiveWalkers(), QMCDriver::H1, CloneManager::HPoolClones, CloneManager::makeClones(), CloneManager::Movers, QMCDriver::nSamplesPerThread, QMCDriver::nTargetSamples, CloneManager::NumThreads, QMCDriver::nWarmupSteps, QMCDriver::Psi1, CloneManager::PsiPoolClones, QMCDriver::qmc_driver_mode, QMCDriver::QMC_UPDATE_MODE, QMCDriver::qmcNode, QMCDriver::Rng, CloneManager::traceClones, QMCDriver::Traces, CSVMC::UseDrift, QMCDriver::W, CloneManager::wClones, and CloneManager::wPerRank.

Referenced by CSVMC::run().

 {
   H1[0]->setPrimary(true);
   IndexType nPsi = Psi1.size();
   for (int ipsi = 1; ipsi < nPsi; ipsi++)
     H1[ipsi]->setPrimary(false);
 
 
   makeClones(W, Psi1, H1);
   FairDivideLow(W.getActiveWalkers(), NumThreads, wPerRank);
 
   if (NumThreads > 1)
     APP_ABORT("OpenMP Parallelization for CSVMC not working at the moment");
 
   app_log() << "  Initial partition of walkers ";
   copy(wPerRank.begin(), wPerRank.end(), std::ostream_iterator<int>(app_log(), " "));
   app_log() << std::endl;
 
 
   if (Movers.empty())
   {
     CSMovers.resize(NumThreads);
     estimatorClones.resize(NumThreads, nullptr);
     traceClones.resize(NumThreads, nullptr);
     Rng.resize(NumThreads);
 
     // hdf_archive::hdf_archive() is not thread-safe
     for (int ip = 0; ip < NumThreads; ++ip)
       estimatorClones[ip] = new EstimatorManagerBase(*Estimators);
 
 #pragma omp parallel for
     for (int ip = 0; ip < NumThreads; ++ip)
     {
       std::ostringstream os;
       estimatorClones[ip]->resetTargetParticleSet(*wClones[ip]);
       estimatorClones[ip]->setCollectionMode(false);
 #if !defined(REMOVE_TRACEMANAGER)
       traceClones[ip] = Traces->makeClone();
 #endif
       Rng[ip] = RandomNumberControl::Children[ip]->makeClone();
       if (qmc_driver_mode[QMC_UPDATE_MODE])
       {
         if (UseDrift == "yes")
         {
           os << "  Using particle-by-particle update with drift " << std::endl;
           CSMovers[ip] = std::make_unique<CSVMCUpdatePbyPWithDriftFast>(*wClones[ip], PsiPoolClones[ip], HPoolClones[ip], *Rng[ip]);
         }
         else
         {
           os << "  Using particle-by-particle update with no drift" << std::endl;
           CSMovers[ip] = std::make_unique<CSVMCUpdatePbyP>(*wClones[ip], PsiPoolClones[ip], HPoolClones[ip], *Rng[ip]);
         }
       }
       else
       {
         if (UseDrift == "yes")
         {
           os << "  Using walker-by-walker update with Drift " << std::endl;
           CSMovers[ip] = std::make_unique<CSVMCUpdateAllWithDrift>(*wClones[ip], PsiPoolClones[ip], HPoolClones[ip], *Rng[ip]);
         }
         else
         {
           os << "  Using walker-by-walker update " << std::endl;
           CSMovers[ip] = std::make_unique<CSVMCUpdateAll>(*wClones[ip], PsiPoolClones[ip], HPoolClones[ip], *Rng[ip]);
         }
       }
       if (ip == 0)
         app_log() << os.str() << std::endl;
 
       CSMovers[ip]->put(qmcNode);
       CSMovers[ip]->resetRun(branchEngine.get(), estimatorClones[ip], traceClones[ip], DriftModifier);
     }
   }
 #if !defined(REMOVE_TRACEMANAGER)
   else
   {
 #pragma omp parallel for
     for (int ip = 0; ip < NumThreads; ++ip)
     {
       traceClones[ip]->transfer_state_from(*Traces);
     }
   }
 #endif
 
   app_log() << "  Total Sample Size   =" << nTargetSamples << std::endl;
   app_log() << "  Walker distribution on root = ";
   copy(wPerRank.begin(), wPerRank.end(), std::ostream_iterator<int>(app_log(), " "));
   app_log() << std::endl;
   app_log().flush();
 
 #pragma omp parallel for
   for (int ip = 0; ip < NumThreads; ++ip)
   {
     //int ip=omp_get_thread_num();
     CSMovers[ip]->put(qmcNode);
     CSMovers[ip]->resetRun(branchEngine.get(), estimatorClones[ip], traceClones[ip], DriftModifier);
     if (qmc_driver_mode[QMC_UPDATE_MODE])
       CSMovers[ip]->initCSWalkersForPbyP(W.begin() + wPerRank[ip], W.begin() + wPerRank[ip + 1], nWarmupSteps > 0);
     else
       CSMovers[ip]->initCSWalkers(W.begin() + wPerRank[ip], W.begin() + wPerRank[ip + 1], nWarmupSteps > 0);
 
     for (int prestep = 0; prestep < nWarmupSteps; ++prestep)
     {
       CSMovers[ip]->advanceWalkers(W.begin() + wPerRank[ip], W.begin() + wPerRank[ip + 1], true);
       if (prestep == nWarmupSteps - 1)
         CSMovers[ip]->updateNorms();
     }
   }
 
   for (int ip = 0; ip < NumThreads; ++ip)
     wClones[ip]->clearEnsemble();
   if (nSamplesPerThread)
     for (int ip = 0; ip < NumThreads; ++ip)
       wClones[ip]->setNumSamples(nSamplesPerThread);
   nWarmupSteps = 0;
 }

◆ run()

bool run ( )

overridevirtual

Run the CSVMC algorithm.

Similar to VMC::run

write samples to a file

Implements QMCDriverInterface.

Definition at line 143 of file CSVMC.cpp.

References qmcplusplus::app_log(), WalkerConfigurations::begin(), RandomNumberControl::Children, ParticleSet::Collectables, CloneManager::CSMovers, QMCDriver::CurrentStep, QMCDriver::DumpConfig, MCWalkerConfiguration::dumpEnsemble(), CloneManager::estimatorClones, QMCDriver::Estimators, QMCDriver::finalize(), MPIObjectBase::myComm, QMCDriver::nBlocks, QMCDriver::nSteps, CloneManager::NumThreads, omp_get_thread_num(), QMCDriver::Period4CheckProperties, QMCDriver::Period4WalkerDump, QMCDriver::qmc_driver_mode, QMCDriver::QMC_UPDATE_MODE, QMCDriver::recordBlock(), CSVMC::resetRun(), QMCDriver::Rng, PooledData< T >::size(), Communicate::size(), EstimatorManagerBase::start(), EstimatorManagerBase::stop(), EstimatorManagerBase::stopBlock(), CloneManager::traceClones, QMCDriver::Traces, QMCDriver::W, CloneManager::wClones, QMCDriver::wOut, and CloneManager::wPerRank.

 {
   resetRun();
   //start the main estimator
   Estimators->start(nBlocks);
   for (int ip = 0; ip < NumThreads; ++ip)
     CSMovers[ip]->startRun(nBlocks, false);
 
 #if !defined(REMOVE_TRACEMANAGER)
   Traces->startRun(nBlocks, traceClones);
 #endif
   const bool has_collectables = W.Collectables.size();
   for (int block = 0; block < nBlocks; ++block)
   {
 #pragma omp parallel
     {
       int ip                 = omp_get_thread_num();
       IndexType updatePeriod = (qmc_driver_mode[QMC_UPDATE_MODE]) ? Period4CheckProperties : 0;
       //assign the iterators and resuse them
       MCWalkerConfiguration::iterator wit(W.begin() + wPerRank[ip]), wit_end(W.begin() + wPerRank[ip + 1]);
       CSMovers[ip]->startBlock(nSteps);
       int now_loc    = CurrentStep;
       RealType cnorm = 1.0 / static_cast<RealType>(wPerRank[ip + 1] - wPerRank[ip]);
       for (int step = 0; step < nSteps; ++step)
       {
         CSMovers[ip]->set_step(now_loc);
         //collectables are reset, it is accumulated while advancing walkers
         wClones[ip]->resetCollectables();
         CSMovers[ip]->advanceWalkers(wit, wit_end, false);
         if (has_collectables)
           wClones[ip]->Collectables *= cnorm;
         CSMovers[ip]->accumulate(wit, wit_end);
         ++now_loc;
         if (Period4WalkerDump && now_loc % Period4WalkerDump == 0)
           wClones[ip]->saveEnsemble(wit, wit_end);
       }
       CSMovers[ip]->stopBlock(false);
 
     } //end-of-parallel for
     CurrentStep += nSteps;
     Estimators->stopBlock(estimatorClones);
 #if !defined(REMOVE_TRACEMANAGER)
     Traces->write_buffers(traceClones, block);
 #endif
     recordBlock(block);
   } //block
   Estimators->stop(estimatorClones);
   for (int ip = 0; ip < NumThreads; ++ip)
     CSMovers[ip]->stopRun2();
 #if !defined(REMOVE_TRACEMANAGER)
   Traces->stopRun();
 #endif
   //copy back the random states
   for (int ip = 0; ip < NumThreads; ++ip)
     RandomNumberControl::Children[ip] = Rng[ip]->makeClone();
   ///write samples to a file
   bool wrotesamples = DumpConfig;
   if (DumpConfig)
   {
     wrotesamples = MCWalkerConfiguration::dumpEnsemble(wClones, *wOut, myComm->size(), nBlocks);
     if (wrotesamples)
       app_log() << "  samples are written to the config.h5" << std::endl;
   }
   //finalize a qmc section
   return finalize(nBlocks, !wrotesamples);
 }

Member Data Documentation

◆ equilBlocks

int equilBlocks

private

blocks over which normalization factors are accumulated

Definition at line 53 of file CSVMC.h.

Referenced by CSVMC::CSVMC().

◆ Mover

CSUpdateBase* Mover

private

Definition at line 63 of file CSVMC.h.

◆ multiEstimator

CSEnergyEstimator* multiEstimator

private

Definition at line 62 of file CSVMC.h.

◆ prevSteps

int prevSteps

private

Definition at line 50 of file CSVMC.h.

Referenced by CSVMC::put().

◆ prevStepsBetweenSamples

int prevStepsBetweenSamples

private

Definition at line 51 of file CSVMC.h.

Referenced by CSVMC::put().

◆ UseDrift

std::string UseDrift

private

Definition at line 49 of file CSVMC.h.

Referenced by CSVMC::CSVMC(), and CSVMC::resetRun().

◆ qmcplusplus::CSVMCUpdateAll

class qmcplusplus::CSVMCUpdateAll

Implements the VMC algorithm using umbrella sampling.

Energy difference method with multiple H/Psi. Consult S. Chiesa's note.

Definition at line 32 of file CSVMCUpdateAll.h.

Inheritance diagram for CSVMCUpdateAll:

Collaboration diagram for CSVMCUpdateAll:

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

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

Public Member Functions inherited from CSUpdateBase
	CSUpdateBase (MCWalkerConfiguration &w, std::vector< TrialWaveFunction > &psi, std::vector< QMCHamiltonian > &h, RandomBase< FullPrecRealType > &rg)

	~CSUpdateBase () override

void	computeSumRatio (const std::vector< RealType > &logpsi, const std::vector< RealType > &avgNorm, std::vector< RealType > &sumratio)

void	computeSumRatio (const Matrix< RealType > &ratioij, std::vector< RealType > &sumratio)

void	computeSumRatio (const std::vector< RealType > &logpsi, const std::vector< RealType > &avgNorm, Matrix< RealType > &ratioij, std::vector< RealType > &sumratio)

void	updateRatioMatrix (const std::vector< RealType > &ratio_pbyp, Matrix< RealType > &ratioij)

void	resizeWorkSpace (int nw, int nptcls)

void	updateNorms ()

void	updateAvgWeights ()

void	initCSWalkers (WalkerIter_t it, WalkerIter_t it_end, bool resetNorms)

void	initCSWalkersForPbyP (WalkerIter_t it, WalkerIter_t it_end, bool resetNorms)

void	updateCSWalkers (WalkerIter_t it, WalkerIter_t it_end)

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)

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 CSUpdateBase
int	nPsi

bool	useDrift

std::vector< RealType >	logpsi

std::vector< RealType >	sumratio

std::vector< RealType >	invsumratio

std::vector< RealType >	avgNorm

std::vector< RealType >	avgWeight

std::vector< RealType >	logNorm

std::vector< RealType >	cumNorm

std::vector< RealType >	instRij

std::vector< RealType >	ratio

Matrix< RealType >	ratioIJ

std::string	useDriftOption

Matrix< RealType >	RatioIJ

CSEnergyEstimator *	multiEstimator
	multiple estimator More...

std::vector< QMCHamiltonian * >	H1
	a list of QMCHamiltonians for multiple method More...

std::vector< TrialWaveFunction * >	Psi1
	a list of TrialWaveFunctions for multiple method More...

std::vector< ParticleSet::ParticleGradient * >	G1

std::vector< ParticleSet::ParticleLaplacian * >	L1

std::vector< GradType >	g1_old

std::vector< GradType >	g1_new

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

Constructor & Destructor Documentation

◆ CSVMCUpdateAll()

CSVMCUpdateAll	(	MCWalkerConfiguration &	w,
		std::vector< TrialWaveFunction *> &	psi,
		std::vector< QMCHamiltonian *> &	h,
		RandomBase< FullPrecRealType > &	rg
	)

Constructor.

Definition at line 33 of file CSVMCUpdateAll.cpp.

References QMCUpdateBase::UpdatePbyP.

     : CSUpdateBase(w, psi, h, rg)
 {
   UpdatePbyP = false;
 }

Member Function Documentation

◆ advanceWalker()

void advanceWalker	(	Walker_t &	thisWalker,
		bool	recompute
	)

overridevirtual

move a walker

Implements QMCUpdateBase.

Definition at line 42 of file CSVMCUpdateAll.cpp.

References Walker< t_traits, p_traits >::Age, CSUpdateBase::avgNorm, CSUpdateBase::cumNorm, QMCUpdateBase::deltaR, qmcplusplus::exp(), ParticleSet::G, CSUpdateBase::G1, Walker< t_traits, p_traits >::getPropertyBase(), CSUpdateBase::H1, CSUpdateBase::invsumratio, ParticleSet::L, CSUpdateBase::L1, CSUpdateBase::logpsi, qmcplusplus::makeGaussRandomWithEngine(), ParticleSet::makeMoveAllParticles(), QMCUpdateBase::MassInvS, Walker< t_traits, p_traits >::Multiplicity, QMCUpdateBase::nAccept, CSUpdateBase::nPsi, QMCUpdateBase::nReject, Walker< t_traits, p_traits >::Properties, CSUpdateBase::Psi1, ParticleSet::R, Walker< t_traits, p_traits >::R, Random, QMCUpdateBase::RandomGen, qmcplusplus::sqrt(), CSUpdateBase::sumratio, QMCUpdateBase::Tau, and QMCUpdateBase::W.

 {
   using WP = WalkerProperties::Indexes;
   //create a 3N-Dimensional Gaussian with variance=1
   makeGaussRandomWithEngine(deltaR, RandomGen);
 
   RealType tau_over_mass = std::sqrt(Tau * MassInvS[0]);
 
   if (!W.makeMoveAllParticles(thisWalker, deltaR, tau_over_mass))
   {
     for (int ipsi = 0; ipsi < nPsi; ipsi++)
       H1[ipsi]->rejectedMove(W, thisWalker);
     return;
   }
 
   //Evaluate Psi and graidients and laplacians
   //\f$\sum_i \ln(|psi_i|)\f$ and catching the sign separately
   for (int ipsi = 0; ipsi < nPsi; ipsi++)
   {
     logpsi[ipsi]  = Psi1[ipsi]->evaluateLog(W);
     Psi1[ipsi]->L = W.L;
     Psi1[ipsi]->G = W.G;
 
     *G1[ipsi]      = W.G;
     *L1[ipsi]      = W.L;
     sumratio[ipsi] = 1.0;
   }
   // Compute the sum over j of Psi^2[j]/Psi^2[i] for each i
   for (int ipsi = 0; ipsi < nPsi - 1; ipsi++)
   {
     for (int jpsi = ipsi + 1; jpsi < nPsi; jpsi++)
     {
       RealType ratioij = avgNorm[ipsi] / avgNorm[jpsi] * std::exp(2.0 * (logpsi[jpsi] - logpsi[ipsi]));
       sumratio[ipsi] += ratioij;
       sumratio[jpsi] += 1.0 / ratioij;
     }
   }
   for (int ipsi = 0; ipsi < nPsi; ipsi++)
   {
     invsumratio[ipsi] = 1.0 / sumratio[ipsi];
     cumNorm[ipsi] += invsumratio[ipsi];
   }
 
   for (int ipsi = 0; ipsi < nPsi; ipsi++)
     cumNorm[ipsi] += invsumratio[ipsi];
 
   RealType g = sumratio[0] / thisWalker.Multiplicity * std::exp(2.0 * (logpsi[0] - thisWalker.Properties(WP::LOGPSI)));
 
   if (Random() > g)
   {
     thisWalker.Age++;
     ++nReject;
     for (int ipsi = 0; ipsi < nPsi; ipsi++)
       H1[ipsi]->rejectedMove(W, thisWalker);
   }
   else
   {
     thisWalker.Age          = 0;
     thisWalker.Multiplicity = sumratio[0];
     thisWalker.R            = W.R;
     for (int ipsi = 0; ipsi < nPsi; ipsi++)
     {
       W.L = *L1[ipsi];
       W.G = *G1[ipsi];
 
       RealType et                                     = H1[ipsi]->evaluate(W);
       thisWalker.Properties(ipsi, WP::LOGPSI)         = logpsi[ipsi];
       thisWalker.Properties(ipsi, WP::SIGN)           = Psi1[ipsi]->getPhase();
       thisWalker.Properties(ipsi, WP::UMBRELLAWEIGHT) = invsumratio[ipsi];
       thisWalker.Properties(ipsi, WP::LOCALENERGY)    = et;
       H1[ipsi]->auxHevaluate(W, thisWalker);
       H1[ipsi]->saveProperty(thisWalker.getPropertyBase(ipsi));
     }
     ++nAccept;
   }
 }

Classes

Detailed Description

Class Documentation

◆ qmcplusplus::CSVMC

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ CSVMC() [1/2]

◆ CSVMC() [2/2]

Member Function Documentation

◆ getRunType()

◆ operator=()

◆ put()

◆ resetRun()

◆ run()

Member Data Documentation

◆ equilBlocks

◆ Mover

◆ multiEstimator

◆ prevSteps

◆ prevStepsBetweenSamples

◆ UseDrift

◆ qmcplusplus::CSVMCUpdateAll

Public Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

◆ CSVMCUpdateAll()

Member Function Documentation

◆ advanceWalker()