Inheritance diagram for QMCDriverNewTestWrapper:

Collaboration diagram for QMCDriverNewTestWrapper:

Classes
struct	TestNumCrowdsVsNumThreads

Public Types
using	Base = QMCDriverNew

Public Types inherited from QMCDriverNew
enum	{ QMC_UPDATE_MODE, QMC_MULTIPLE, QMC_OPTIMIZE, QMC_WARMUP }
	separate but similar to QMCModeEnum More...

using	RealType = QMCTraits::RealType

using	IndexType = QMCTraits::IndexType

using	FullPrecRealType = QMCTraits::FullPrecRealType

using	MCPWalker = MCPopulation::MCPWalker

using	WFBuffer = MCPopulation::WFBuffer

using	SetNonLocalMoveHandler = std::function< void(QMCHamiltonian &)>

Public Types inherited from QMCDriverInterface
using	BranchEngineType = SimpleFixedNodeBranch

using	FullPrecRealType = QMCTraits::FullPrecRealType

Public Types inherited from MPIObjectBase
using	mpi_comm_type = Communicate::mpi_comm_type

Public Member Functions
	QMCDriverNewTestWrapper (const ProjectData &test_project, QMCDriverInput &&input, WalkerConfigurations &wc, MCPopulation &&population, Communicate *comm)

	~QMCDriverNewTestWrapper () override

QMCRunType	getRunType () override

void	process (xmlNodePtr node) override
	QMCDriverNew driver second (3rd, 4th...) stage of constructing a valid driver. More...

void	testAdjustGlobalWalkerCount ()

bool	run () override

int	get_num_crowds ()

void	testMeasureImbalance ()

void	testDetermineStepsPerBlock ()

Public Member Functions inherited from QMCDriverNew
	QMCDriverNew (const ProjectData &project_data, QMCDriverInput &&input, const std::optional< EstimatorManagerInput > &global_emi, WalkerConfigurations &wc, MCPopulation &&population, const std::string timer_prefix, Communicate *comm, const std::string &QMC_driver_type)
	Constructor. More...

	QMCDriverNew (QMCDriverNew &&)=default
	Move Constructor. More...

	QMCDriverNew (const QMCDriverNew &)=delete
	Copy Constructor (disabled). More...

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

	~QMCDriverNew () override

bool	putQMCInfo (xmlNodePtr cur)

void	makeLocalWalkers (int nwalkers, RealType reserve)
	Adjust populations local walkers to this number. More...

DriftModifierBase &	get_drift_modifier () const

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

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

IndexType	current () const
	return current step 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

void	createRngsStepContexts (int num_crowds)
	Creates Random Number generators for crowds and step contexts. More...

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

RefVector< RandomBase< FullPrecRealType > >	getRngRefs () const

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

std::string	getEngineName () override
	intended for logging output and debugging you should base behavior on type preferably at compile time or if necessary at runtime using and protected by dynamic cast. More...

unsigned long	getDriverMode () override

IndexType	get_num_living_walkers () const

IndexType	get_num_dead_walkers () const

const QMCDriverInput &	getQMCDriverInput () const

bool	put (xmlNodePtr cur) override
	More...

void	setUpdateMode (bool pbyp) override
	should be set in input don't see a reason to set individually More...

void	putTraces (xmlNodePtr txml) override

void	requestTraces (bool allow_traces) override

void	putWalkerLogs (xmlNodePtr wlxml) override

void	requestWalkerLogs (bool allow_walker_logs_) override

Public Member Functions inherited from QMCDriverInterface
virtual	~QMCDriverInterface ()

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

virtual std::unique_ptr< BranchEngineType >	getBranchEngine ()

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)

Additional Inherited Members
Static Public Member Functions inherited from QMCDriverNew
static void	initialLogEvaluation (int crowd_id, UPtrVector< Crowd > &crowds, UPtrVector< ContextForSteps > &step_context)

template<typename RT , CoordsType CT>
static void	scaleBySqrtTau (const TauParams< RT, CT > &taus, MCCoords< CT > &coords)

template<typename RT , CoordsType CT>
static void	computeLogGreensFunction (const MCCoords< CT > &coords, const TauParams< RT, CT > &taus, std::vector< QMCTraits::RealType > &log_gb)
	calculates Green Function from displacements stored in MCCoords [param, out] log_g More...

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

bool	allow_walker_logs
	whether to allow walker logs More...

WalkerLogInput	walker_logs_input
	walker logs input More...

Protected Member Functions inherited from QMCDriverNew
void	initializeQMC (const AdjustedWalkerCounts &awc)
	Do common section starting tasks for VMC and DMC. More...

void	measureImbalance (const std::string &tag) const
	inject additional barrier and measure load imbalance. More...

void	endBlock ()
	end of a block operations. Aggregates statistics across all MPI ranks and write to disk. More...

const std::string &	get_root_name () const override

Static Protected Member Functions inherited from QMCDriverNew
static QMCDriverNew::AdjustedWalkerCounts	adjustGlobalWalkerCount (Communicate &comm, const IndexType current_configs, const IndexType requested_total_walkers, const IndexType requested_walkers_per_rank, const RealType reserve_walkers, int num_crowds)
	}@ More...

static size_t	determineStepsPerBlock (IndexType global_walkers, IndexType requested_samples, IndexType requested_steps, IndexType blocks)
	pure function calculating the actual number of steps per block More...

static void	checkNumCrowdsLTNumThreads (const int num_crowds)

static void	checkLogAndGL (Crowd &crowd, const std::string_view location)
	check logpsi and grad and lap against values computed from scratch More...

static void	setWalkerOffsets (WalkerConfigurations &, Communicate *comm)
	update the global offsets of walker configurations after active walkers being touched. More...

Protected Attributes inherited from QMCDriverNew
QMCDriverInput	qmcdriver_input_

RealType	max_disp_sq_
	they should be limited to values that can be changed from input or are live state. More...

IndexType	target_samples_
	the number of saved samples More...

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

UPtrVector< Crowd >	crowds_
	}@ More...

std::string	h5_file_root_

std::unique_ptr< DriftModifierBase >	drift_modifier_
	drift modifer More...

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

int	walker_dump_period
	period of recording walker configurations More...

IndexType	current_step_

size_t	steps_per_block_ = 0
	actual number of steps per block More...

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

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

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

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

const std::string	QMCType
	type of qmc: assigned by subclasses More...

MCPopulation	population_
	the entire (on node) walker population it serves VMCBatch and DMCBatch right now but will be polymorphic More...

struct DriverWalkerResourceCollection	golden_resource_
	the golden multi walker shared resource serves ParticleSet TrialWaveFunction right now but actually should be based on MCPopulation. More...

const MultiWalkerDispatchers	dispatchers_
	multi walker dispatchers More...

std::unique_ptr< EstimatorManagerNew >	estimator_manager_
	Observables manager Has very problematic owner ship and life cycle. More...

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

UPtrVector< ContextForSteps >	step_contexts_
	Per crowd move contexts, this is where the DistanceTables etc. More...

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

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

DriverTimers	timers_
	period of dumping walker configurations and everything else for restart More...

ScopedProfiler	driver_scope_profiler_
	profile the driver lifetime More...

const ProjectData &	project_data_
	project info for accessing global fileroot and series id More...

WalkerConfigurations &	walker_configs_ref_

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

Detailed Description

Definition at line 28 of file QMCDriverNewTestWrapper.h.

Member Typedef Documentation

◆ Base

using Base = QMCDriverNew

Definition at line 31 of file QMCDriverNewTestWrapper.h.

Constructor & Destructor Documentation

◆ QMCDriverNewTestWrapper()

QMCDriverNewTestWrapper	(	const ProjectData &	test_project,
		QMCDriverInput &&	input,
		WalkerConfigurations &	wc,
		MCPopulation &&	population,
		Communicate *	comm
	)

inline

Definition at line 32 of file QMCDriverNewTestWrapper.h.

       : QMCDriverNew(test_project,
                      std::move(input),
                      std::nullopt,
                      wc,
                      std::move(population),
                      "QMCDriverTestWrapper::",
                      comm,
                      "QMCDriverNewTestWrapper")
   {}

◆ ~QMCDriverNewTestWrapper()

~QMCDriverNewTestWrapper ( )

inlineoverride

Definition at line 47 of file QMCDriverNewTestWrapper.h.

47 {}

Member Function Documentation

◆ get_num_crowds()

int get_num_crowds ( )

inline

Definition at line 170 of file QMCDriverNewTestWrapper.h.

References QMCDriverNew::crowds_.

170 { return crowds_.size(); }

qmcplusplus::QMCDriverNew::crowds_

UPtrVector< Crowd > crowds_

}@

Definition: QMCDriverNew.h:389

◆ getRunType()

QMCRunType getRunType ( )

inlineoverridevirtual

Implements QMCDriverInterface.

Definition at line 49 of file QMCDriverNewTestWrapper.h.

References qmcplusplus::DUMMY.

49 { return QMCRunType::DUMMY; }

qmcplusplus::QMCRunType::DUMMY

◆ process()

void process ( xmlNodePtr cur )

inlineoverridevirtual

QMCDriverNew driver second (3rd, 4th...) stage of constructing a valid driver.

This is the shared entry point with legacy, from QMCMain so the API cannot be updated yet

Todo:: remove cur, the driver and all its child nodes should be completely processed before this stage of driver initialization is hit.

Implements QMCDriverNew.

Definition at line 51 of file QMCDriverNewTestWrapper.h.

References QMCDriverNew::adjustGlobalWalkerCount(), QMCDriverInput::get_num_crowds(), QMCDriverInput::get_total_walkers(), QMCDriverInput::get_walkers_per_rank(), QMCDriverNew::initializeQMC(), MPIObjectBase::myComm, and QMCDriverNew::qmcdriver_input_.

Referenced by qmcplusplus::TEST_CASE().

   {
     // We want to test the reserve ability as well
     AdjustedWalkerCounts awc =
         adjustGlobalWalkerCount(*myComm, 0, qmcdriver_input_.get_total_walkers(), qmcdriver_input_.get_walkers_per_rank(),
                                 1.0, qmcdriver_input_.get_num_crowds());
 
     Base::initializeQMC(awc);
   }

◆ run()

bool run ( )

inlineoverridevirtual

Implements QMCDriverInterface.

Definition at line 168 of file QMCDriverNewTestWrapper.h.

168 { return false; }

◆ testAdjustGlobalWalkerCount()

void testAdjustGlobalWalkerCount ( )

inline

Definition at line 61 of file QMCDriverNewTestWrapper.h.

References QMCDriverNew::adjustGlobalWalkerCount(), qmcplusplus::CHECK(), QMCDriverNew::AdjustedWalkerCounts::global_walkers, qmcplusplus::Concurrency::maxCapacity(), MPIObjectBase::myComm, Communicate::rank(), Communicate::size(), QMCDriverNew::AdjustedWalkerCounts::walkers_per_crowd, and QMCDriverNew::AdjustedWalkerCounts::walkers_per_rank.

   {
     AdjustedWalkerCounts awc;
     if (myComm->size() == 4)
     {
       awc = adjustGlobalWalkerCount(*myComm, 0, 64, 0, 1.0, 0);
       if (myComm->rank() == 1)
       {
         CHECK(awc.global_walkers == 64);
         CHECK(awc.walkers_per_crowd.size() == 8);
         CHECK(awc.walkers_per_rank[0] == 16);
         CHECK(awc.walkers_per_rank[3] == 16);
         CHECK(awc.walkers_per_crowd[4] == 2);
         CHECK(awc.walkers_per_crowd[7] == 2);
       }
 
       awc = adjustGlobalWalkerCount(*myComm, 4, 0, 0, 1.0, 0);
       if (myComm->rank() == 1)
       {
         CHECK(awc.global_walkers == 16);
         CHECK(awc.walkers_per_crowd.size() == 8);
         CHECK(awc.walkers_per_rank[0] == 4);
         CHECK(awc.walkers_per_rank[3] == 4);
         CHECK(awc.walkers_per_crowd[3] == 1);
         CHECK(awc.walkers_per_crowd[7] == 0);
       }
 
       awc = adjustGlobalWalkerCount(*myComm, 0, 63, 0, 1.0, 4);
       if (myComm->rank() == 1)
       {
         CHECK(awc.global_walkers == 63);
         CHECK(awc.walkers_per_crowd.size() == 4);
         CHECK(awc.walkers_per_rank[0] == 16);
         CHECK(awc.walkers_per_rank[3] == 15);
         CHECK(awc.walkers_per_crowd[0] == 4);
         CHECK(awc.walkers_per_crowd[3] == 4);
       }
       awc = adjustGlobalWalkerCount(*myComm, 0, 63, 0, 1.0, 4);
       if (myComm->rank() == 3)
       {
         CHECK(awc.global_walkers == 63);
         CHECK(awc.walkers_per_crowd.size() == 4);
         CHECK(awc.walkers_per_rank[0] == 16);
         CHECK(awc.walkers_per_rank[3] == 15);
         CHECK(awc.walkers_per_crowd[0] == 4);
         CHECK(awc.walkers_per_crowd[3] == 3);
       }
 
       awc = adjustGlobalWalkerCount(*myComm, 0, 0, 32, 1.0, 4);
       if (myComm->rank() == 3)
       {
         CHECK(awc.global_walkers == 128);
         CHECK(awc.walkers_per_crowd.size() == 4);
         CHECK(awc.walkers_per_rank[0] == 32);
         CHECK(awc.walkers_per_rank[3] == 32);
         CHECK(awc.walkers_per_crowd[0] == 8);
         CHECK(awc.walkers_per_crowd[3] == 8);
       }
     }
     if (myComm->size() == 1)
     {
       awc = adjustGlobalWalkerCount(*myComm, 0, 7, 0, 1.0, 8);
       CHECK(awc.global_walkers == 7);
       CHECK(awc.walkers_per_crowd.size() == 8);
       CHECK(awc.walkers_per_rank.size() == 1);
       CHECK(awc.walkers_per_rank[0] == 7);
       CHECK(awc.walkers_per_crowd[0] == 1);
       CHECK(awc.walkers_per_crowd[7] == 0);
     }
 
     if (myComm->size() == 2)
     {
       awc = adjustGlobalWalkerCount(*myComm, 0, 28, 0, 1.0, 0);
       if (myComm->rank() == 0)
       {
         CHECK(awc.global_walkers == 28);
         CHECK(awc.walkers_per_crowd.size() == Concurrency::maxCapacity());
         CHECK(awc.walkers_per_rank.size() == 2);
         CHECK(awc.walkers_per_rank[0] == 14);
         // \todo for std::thread these will be ones
         CHECK(awc.walkers_per_crowd[0] == 2);
         CHECK(awc.walkers_per_crowd[7] == 1);
       }
       awc = adjustGlobalWalkerCount(*myComm, 0, 27, 0, 1.0, 4);
       if (myComm->rank() == 1)
       {
         CHECK(awc.global_walkers == 27);
         CHECK(awc.walkers_per_crowd.size() == 4);
         CHECK(awc.walkers_per_rank.size() == 2);
         CHECK(awc.walkers_per_rank[0] == 14);
         CHECK(awc.walkers_per_rank[1] == 13);
         CHECK(awc.walkers_per_crowd[0] == 4);
         CHECK(awc.walkers_per_crowd[3] == 3);
       }
       // Ask for 27 total walkers on 2 ranks of 11 walkers (inconsistent input)
       // results in fatal exception on all ranks.
       CHECK_THROWS_AS(adjustGlobalWalkerCount(*myComm, 0, 27, 11, 1.0, 4), UniformCommunicateError);
     }
 
     if (myComm->size() == 16)
     {
       // Ask for 14 total walkers on 16 ranks (inconsistent input)
       // results in fatal exception on all ranks.
       CHECK_THROWS_AS(adjustGlobalWalkerCount(*myComm, 0, 14, 0, 0, 0), UniformCommunicateError);
     }
   }

◆ testDetermineStepsPerBlock()

void testDetermineStepsPerBlock ( )

inline

Definition at line 179 of file QMCDriverNewTestWrapper.h.

References qmcplusplus::CHECK(), and QMCDriverNew::determineStepsPerBlock().

Referenced by qmcplusplus::TEST_CASE().

   {
     CHECK(QMCDriverNew::determineStepsPerBlock(6, 36, 2, 3) == 2);
     CHECK(QMCDriverNew::determineStepsPerBlock(6, 36, 1, 6) == 1);
     CHECK(QMCDriverNew::determineStepsPerBlock(6, 33, 3, 2) == 3);
     CHECK(QMCDriverNew::determineStepsPerBlock(6, 33, 0, 2) == 3);
     CHECK(QMCDriverNew::determineStepsPerBlock(6, 25, 0, 2) == 3);
     CHECK(QMCDriverNew::determineStepsPerBlock(6, 24, 0, 2) == 2);
     CHECK(QMCDriverNew::determineStepsPerBlock(6, 0, 2, 2) == 2);
     CHECK(QMCDriverNew::determineStepsPerBlock(6, 0, 0, 2) == 1);
 
     CHECK_THROWS_WITH(QMCDriverNew::determineStepsPerBlock(6, 13, 1, 2),
                       Catch::Contains("more than the total number of walkers"));
   }

◆ testMeasureImbalance()

void testMeasureImbalance ( )

inline

Definition at line 178 of file QMCDriverNewTestWrapper.h.

References QMCDriverNew::measureImbalance().

Referenced by qmcplusplus::TEST_CASE().

178 { measureImbalance("Test"); }

qmcplusplus::QMCDriverNew::measureImbalance

void measureImbalance(const std::string &tag) const

inject additional barrier and measure load imbalance.

Definition: QMCDriverNew.cpp:618

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

/home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/QMCDrivers/tests/QMCDriverNewTestWrapper.h

Classes

Public Types

Public Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

Constructor & Destructor Documentation

◆ QMCDriverNewTestWrapper()

◆ ~QMCDriverNewTestWrapper()

Member Function Documentation

◆ get_num_crowds()

◆ getRunType()

◆ process()

◆ run()

◆ testAdjustGlobalWalkerCount()

◆ testDetermineStepsPerBlock()

◆ testMeasureImbalance()