WalkerControl Class Reference

Class for controlling the walkers for DMC simulations. More...

Inheritance diagram for WalkerControl:

Collaboration diagram for WalkerControl:

Public Types
using	Walker_t = MCWalkerConfiguration::Walker_t
	typedef of Walker_t More...
using	MCPWalker = MCPopulation::MCPWalker
	distinct type for "new" walker, currently same as Walker_t More...
using	FullPrecRealType = QMCTraits::FullPrecRealType
	typedef of FullPrecRealType More...
using	IndexType = QMCTraits::IndexType
	typedef of IndexType More...
Public Types inherited from MPIObjectBase
using	mpi_comm_type = Communicate::mpi_comm_type

Public Member Functions
	WalkerControl (Communicate *c, RandomBase< FullPrecRealType > &rng, bool use_fixed_pop=false)
	default constructor More...
	~WalkerControl ()
	empty destructor to clean up the derived classes More...
void	start ()
	start a block More...
void	writeDMCdat (int iter, const std::vector< FullPrecRealType > &curData)
	take averages and writes to a file More...
void	setTrialEnergy (FullPrecRealType et)
	set the trial energy for writing to dmc.dat More...
void	branch (int iter, MCPopulation &pop, bool do_not_branch)
	unified: perform branch and swap walkers as required More...
bool	put (xmlNodePtr cur)
void	setMinMax (int nw_in, int nmax_in)
int	get_n_max () const
int	get_n_min () const
MCDataType< FullPrecRealType > &	get_ensemble_property ()
void	set_ensemble_property (MCDataType< FullPrecRealType > &ensemble_property)
IndexType	get_num_contexts () const
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)

Private Types
enum	{   ENERGY_INDEX = 0, ENERGY_SQ_INDEX, WALKERSIZE_INDEX, WEIGHT_INDEX,   R2ACCEPTED_INDEX, R2PROPOSED_INDEX, FNSIZE_INDEX, SENTWALKERS_INDEX,   LE_MAX }
	An enum to access curData for reduction. More...

Private Member Functions
void	computeCurData (const UPtrVector< MCPWalker > &walkers, std::vector< FullPrecRealType > &curData)
	compute curData More...

Static Private Member Functions
static void	killDeadWalkersOnRank (MCPopulation &pop)
	kill dead walkers in the population More...
static std::vector< IndexType >	syncFutureWalkersPerRank (Communicate *comm, IndexType n_walkers)
static void	determineNewWalkerPopulation (const std::vector< int > &num_per_rank, std::vector< int > &fair_offset, std::vector< int > &minus, std::vector< int > &plus)
	creates the distribution plan More...

Private Attributes
RandomBase< FullPrecRealType > &	rng_
	random number generator More...
bool	use_fixed_pop_
	if true, use fixed population More...
IndexType	n_min_
	minimum number of walkers More...
IndexType	n_max_
	maximum number of walkers More...
IndexType	max_copy_
	maximum copy per walker More...
FullPrecRealType	trial_energy_
	trial energy energy More...
std::vector< int >	num_per_rank_
	number of walkers on each MPI rank after branching before load balancing More...
std::vector< int >	fair_offset_
	offset of the particle index for a fair distribution More...
std::filesystem::path	dmcFname
	filename for dmc.dat More...
std::unique_ptr< std::ofstream >	dmcStream
	file to save energy histogram More...
const IndexType	rank_num_
	context id More...
const IndexType	num_ranks_
	number of contexts More...
IndexType	SwapMode
	0 is default More...
std::vector< FullPrecRealType >	curData
	any temporary data includes many ridiculous conversions of integral types to and from fp More...
bool	use_nonblocking_
	Use non-blocking isend/irecv. More...
bool	debug_disable_branching_
	disable branching for debugging More...
MCDataType< FullPrecRealType >	ensemble_property_
	ensemble properties More...
TimerList_t	my_timers_
	timers More...
IndexType	saved_num_walkers_sent_
	Number of walkers sent during the exchange. More...

Additional Inherited Members
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

Class for controlling the walkers for DMC simulations.

w and w/o MPI. Fixed and dynamic population in one place.

Definition at line 40 of file WalkerControl.h.

Member Typedef Documentation

FullPrecRealType

using FullPrecRealType = QMCTraits::FullPrecRealType

typedef of FullPrecRealType

Definition at line 48 of file WalkerControl.h.

IndexType

using IndexType = QMCTraits::IndexType

typedef of IndexType

Definition at line 50 of file WalkerControl.h.

MCPWalker

using MCPWalker = MCPopulation::MCPWalker

distinct type for "new" walker, currently same as Walker_t

Definition at line 46 of file WalkerControl.h.

Walker_t

using Walker_t = MCWalkerConfiguration::Walker_t

typedef of Walker_t

Definition at line 44 of file WalkerControl.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

An enum to access curData for reduction.

curData is larger than this //LE_MAX + n_node * T

Enumerator
ENERGY_INDEX
ENERGY_SQ_INDEX
WALKERSIZE_INDEX
WEIGHT_INDEX
R2ACCEPTED_INDEX
R2PROPOSED_INDEX
FNSIZE_INDEX
SENTWALKERS_INDEX
LE_MAX

Definition at line 130 of file WalkerControl.h.

  {
    ENERGY_INDEX = 0,
    ENERGY_SQ_INDEX,
    WALKERSIZE_INDEX,
    WEIGHT_INDEX,
    R2ACCEPTED_INDEX,
    R2PROPOSED_INDEX,
    FNSIZE_INDEX,
    SENTWALKERS_INDEX,
    LE_MAX
  };

Constructor & Destructor Documentation

WalkerControl()

WalkerControl	(	Communicate *	c,
		RandomBase< FullPrecRealType > &	rng,
		bool	use_fixed_pop = false
	)

default constructor

Set the SwapMode to zero so that instantiation can be done

Definition at line 57 of file WalkerControl.cpp.

References WalkerControl::fair_offset_, WalkerControl::num_per_rank_, WalkerControl::num_ranks_, and qmcplusplus::rank.

    : MPIObjectBase(c),
      rng_(rng),
      use_fixed_pop_(use_fixed_pop),
      n_min_(1),
      n_max_(10),
      max_copy_(2),
      rank_num_(c->rank()),
      num_ranks_(c->size()),
      SwapMode(0),
      use_nonblocking_(true),
      debug_disable_branching_(false),
      my_timers_(getGlobalTimerManager(), WalkerControlTimerNames, timer_level_medium),
      saved_num_walkers_sent_(0)
{
  num_per_rank_.resize(num_ranks_);
  fair_offset_.resize(num_ranks_ + 1);
}

~WalkerControl()

~WalkerControl ( )

default

empty destructor to clean up the derived classes

Member Function Documentation

branch()

void branch	(	int	iter,
		MCPopulation &	pop,
		bool	do_not_branch
	)

unified: perform branch and swap walkers as required

any temporary data includes many ridiculous conversions of integral types to and from fp

Definition at line 137 of file WalkerControl.cpp.

References MCPopulation::checkIntegrity(), WalkerControl::computeCurData(), WalkerControl::curData, WalkerControl::debug_disable_branching_, WalkerControl::ensemble_property_, MCPopulation::get_num_global_walkers(), MCPopulation::get_num_local_walkers(), MCPopulation::get_walkers(), WalkerControl::killDeadWalkersOnRank(), WalkerControl::LE_MAX, omptarget::min(), WalkerControl::my_timers_, MPIObjectBase::myComm, WalkerControl::num_per_rank_, WalkerControl::num_ranks_, WalkerControl::rng_, MCPopulation::set_ensemble_property(), MCPopulation::set_num_global_walkers(), MCPopulation::spawnWalker(), MCPopulation::syncWalkersPerRank(), WalkerControl::use_fixed_pop_, qmcplusplus::walker, WalkerElementsRef::walker, qmcplusplus::hdf::walkers, qmcplusplus::WC_branch, qmcplusplus::WC_copyWalkers, qmcplusplus::WC_loadbalance, qmcplusplus::WC_prebalance, and WalkerControl::writeDMCdat().

{
  if (debug_disable_branching_)
    do_not_branch = true;
  /* dynamic population
    1. compute multiplicity. If iter 0, multiplicity = 1
    2. compute curData, collect multiplicity on every rank

     fix population
    1. compute curData, collect weight on every rank
    2. compute multiplicity by comb method

    3. figure out final distribution, apply walker count ceiling
    4. collect good, bad walkers
    5. communicate walkers
    6. unpack received walkers, apply walker count floor
   */

  ScopedTimer branch_timer(my_timers_[WC_branch]);
  auto& walkers = pop.get_walkers();

  {
    ScopedTimer prebalance_timer(my_timers_[WC_prebalance]);
    ///any temporary data includes many ridiculous conversions of integral types to and from fp
    std::vector<FullPrecRealType> curData(LE_MAX + num_ranks_, 0.0);

    if (use_fixed_pop_)
    {
      computeCurData(walkers, curData);
      // convert  node local num of walkers after combing
      // curData[LE_MAX + rank_num_] = wsum to num_total_copies
      // calculate walker->Multiplicity;
    }
    else
    {
      // no branching at the first iteration to avoid large population change.
      if (do_not_branch)
        for (auto& walker : walkers)
          walker->Multiplicity = 1.0;
      else
        for (auto& walker : walkers)
          walker->Multiplicity = static_cast<int>(walker->Weight + rng_());
      computeCurData(walkers, curData);
      for (int i = 0, j = LE_MAX; i < num_ranks_; i++, j++)
        num_per_rank_[i] = static_cast<int>(curData[j]);
    }
    // at this point, curData[LE_MAX + rank_num_] and walker->Multiplicity are ready.

    writeDMCdat(iter, curData);
    pop.set_ensemble_property(ensemble_property_);
  }

  auto untouched_walkers = walkers.size();
#if defined(HAVE_MPI)
  {
    ScopedTimer loadbalance_timer(my_timers_[WC_loadbalance]);
    // kill walkers, actually put them in deadlist for be recycled for receiving walkers
    killDeadWalkersOnRank(pop);
    // ranks receiving walkers from other ranks have the lowest walker count now.
    untouched_walkers = std::min(untouched_walkers, walkers.size());

    // load balancing over MPI
    swapWalkersSimple(pop);
  }
#endif

  // kill dead walker to be recycled by the following copy
  killDeadWalkersOnRank(pop);
  // ranks sending walkers from other ranks have the lowest walker count now.
  untouched_walkers = std::min(untouched_walkers, walkers.size());

  { // copy good walkers
    ScopedTimer copywalkers_timer(my_timers_[WC_copyWalkers]);
    const size_t good_walkers = walkers.size();
    for (size_t iw = 0; iw < good_walkers; iw++)
    {
      size_t num_copies = static_cast<int>(walkers[iw]->Multiplicity);
      while (num_copies > 1)
      {
        auto walker_elements = pop.spawnWalker();
        // save this walkers ID
        // \todo revisit Walker assignment operator after legacy drivers removed.
        // but in the modern scheme walker IDs are permanent after creation, what walker they
        // were copied from is in ParentID.
        long save_id                    = walker_elements.walker.getWalkerID();
        walker_elements.walker          = *walkers[iw];
        walker_elements.walker.setParentID(walker_elements.walker.getWalkerID());
        walker_elements.walker.setWalkerID(save_id);
        num_copies--;
      }
    }
  }

  const int current_num_global_walkers = std::accumulate(num_per_rank_.begin(), num_per_rank_.end(), 0);
  pop.set_num_global_walkers(current_num_global_walkers);
#ifndef NDEBUG
  pop.checkIntegrity();
  pop.syncWalkersPerRank(myComm);
  if (current_num_global_walkers != pop.get_num_global_walkers())
    throw std::runtime_error("Potential bug! Population num_global_walkers mismatched!");
#endif

  if (!do_not_branch)
    for (UPtr<MCPWalker>& walker : pop.get_walkers())
    {
      walker->Weight       = 1.0;
      walker->Multiplicity = 1.0;
    }

  for (int iw = 0; iw < untouched_walkers; iw++)
    pop.get_walkers()[iw]->wasTouched = false;

  for (int iw = untouched_walkers; iw < pop.get_num_local_walkers(); iw++)
    pop.get_walkers()[iw]->wasTouched = true;
}

computeCurData()

void computeCurData ( const UPtrVector< MCPWalker > &  walkers, std::vector< FullPrecRealType > &  curData  )

private

compute curData

Definition at line 253 of file WalkerControl.cpp.

References Communicate::allreduce(), WalkerControl::curData, qmcplusplus::Units::charge::e, WalkerControl::ENERGY_INDEX, WalkerControl::ENERGY_SQ_INDEX, WalkerControl::FNSIZE_INDEX, WalkerControl::LE_MAX, WalkerControl::my_timers_, MPIObjectBase::myComm, WalkerControl::R2ACCEPTED_INDEX, WalkerControl::R2PROPOSED_INDEX, WalkerControl::rank_num_, WalkerControl::saved_num_walkers_sent_, WalkerControl::SENTWALKERS_INDEX, WalkerControl::use_fixed_pop_, qmcplusplus::walker, qmcplusplus::hdf::walkers, WalkerControl::WALKERSIZE_INDEX, qmcplusplus::WC_allreduce, and WalkerControl::WEIGHT_INDEX.

Referenced by WalkerControl::branch().

{
  FullPrecRealType esum = 0.0, e2sum = 0.0, wsum = 0.0;
  FullPrecRealType r2_accepted = 0.0, r2_proposed = 0.0;
  int num_good_walkers(0), num_total_copies(0);
  for (const auto& walker : walkers)
  {
    const int num_copies = static_cast<int>(walker->Multiplicity);
    num_good_walkers += num_copies > 0 ? 1 : 0;
    num_total_copies += num_copies;
    // Ye : not sure about these r2
    r2_accepted += walker->Properties(WP::R2ACCEPTED);
    r2_proposed += walker->Properties(WP::R2PROPOSED);
    FullPrecRealType e   = walker->Properties(WP::LOCALENERGY);
    FullPrecRealType wgt = walker->Weight;
    esum += wgt * e;
    e2sum += wgt * e * e;
    wsum += wgt;
  }
  //temp is an array to perform reduction operations
  std::fill(curData.begin(), curData.end(), 0.0);
  curData[ENERGY_INDEX]      = esum;
  curData[ENERGY_SQ_INDEX]   = e2sum;
  curData[WALKERSIZE_INDEX]  = walkers.size(); // num of all the current walkers (good+bad)
  curData[WEIGHT_INDEX]      = wsum;
  curData[R2ACCEPTED_INDEX]  = r2_accepted;
  curData[R2PROPOSED_INDEX]  = r2_proposed;
  curData[FNSIZE_INDEX]      = num_good_walkers; // num of good walkers before branching
  curData[SENTWALKERS_INDEX] = saved_num_walkers_sent_;
  if (use_fixed_pop_)
    curData[LE_MAX + rank_num_] = wsum; // node sum of walker weights
  else
    curData[LE_MAX + rank_num_] = num_total_copies; // node num of walkers after local branching

  {
    ScopedTimer allreduce_timer(my_timers_[WC_allreduce]);
    myComm->allreduce(curData);
  }
}

determineNewWalkerPopulation()

void determineNewWalkerPopulation ( const std::vector< int > &  num_per_rank, std::vector< int > &  fair_offset, std::vector< int > &  minus, std::vector< int > &  plus  )

staticprivate

creates the distribution plan

populates the minus and plus vectors they contain 1 copy of a partition index for each adjustment in population to the context.

Parameters

[in]	num_per_rank	as if all walkers were copied out to multiplicity
[out]	fair_offset	running population count at each partition boundary
[out]	minus	list of partition indexes one occurrence for each walker removed
[out]	plus	list of partition indexes one occurrence for each walker added

Definition at line 294 of file WalkerControl.cpp.

References qmcplusplus::app_error(), and FairDivideLow().

Referenced by UnifiedDriverWalkerControlMPITest::testNewDistribution().

{
  const int num_contexts       = num_per_rank.size();
  const int current_population = std::accumulate(num_per_rank.begin(), num_per_rank.end(), 0);
  FairDivideLow(current_population, num_contexts, fair_offset);
  for (int ip = 0; ip < num_contexts; ip++)
  {
    int dn = num_per_rank[ip] - (fair_offset[ip + 1] - fair_offset[ip]);
    if (dn > 0)
      plus.insert(plus.end(), dn, ip);
    else if (dn < 0)
      minus.insert(minus.end(), -dn, ip);
  }
#ifndef NDEBUG
  if (plus.size() != minus.size())
  {
    app_error() << "Walker send/recv pattern doesn't match. "
                << "The send size " << plus.size() << " is not equal to the recv size " << minus.size() << " ."
                << std::endl;
    throw std::runtime_error("Trying to swap in WalkerControl::swapWalkersSimple with mismatched queues");
  }
#endif
}

get_ensemble_property()

MCDataType<FullPrecRealType>& get_ensemble_property ( )

inline

Definition at line 81 of file WalkerControl.h.

References WalkerControl::ensemble_property_.

{ return ensemble_property_; }

get_n_max()

int get_n_max ( ) const

inline

Definition at line 79 of file WalkerControl.h.

References WalkerControl::n_max_.

{ return n_max_; }

get_n_min()

int get_n_min ( ) const

inline

Definition at line 80 of file WalkerControl.h.

References WalkerControl::n_min_.

{ return n_min_; }

get_num_contexts()

IndexType get_num_contexts ( ) const

inline

Definition at line 86 of file WalkerControl.h.

References WalkerControl::num_ranks_.

{ return num_ranks_; }

killDeadWalkersOnRank()

void killDeadWalkersOnRank ( MCPopulation &  pop )

staticprivate

kill dead walkers in the population

Definition at line 525 of file WalkerControl.cpp.

References MCPopulation::checkIntegrity(), MCPopulation::get_walkers(), MCPopulation::killWalker(), qmcplusplus::walker, and qmcplusplus::hdf::walkers.

Referenced by WalkerControl::branch().

{
  // kill walkers, actually put them in deadlist
  RefVector<MCPWalker> bad_walkers;
  auto& walkers = pop.get_walkers();
  bad_walkers.reserve(walkers.size());
  for (auto& walker : walkers)
    if (static_cast<int>(walker->Multiplicity) == 0)
      bad_walkers.push_back(*walker);
  for (MCPWalker& bad_walker : bad_walkers)
    pop.killWalker(bad_walker);
#ifndef NDEBUG
  pop.checkIntegrity();
#endif
}

put()

bool put

(

xmlNodePtr

cur

)

Definition at line 550 of file WalkerControl.cpp.

References ParameterSet::add(), qmcplusplus::app_log(), Communicate::barrier_and_abort(), WalkerControl::debug_disable_branching_, WalkerControl::max_copy_, MPIObjectBase::myComm, WalkerControl::n_max_, WalkerControl::n_min_, ParameterSet::put(), WalkerControl::setMinMax(), and WalkerControl::use_nonblocking_.

{
  int nw_target = 0, nw_max = 0;
  ParameterSet params;
  params.add(max_copy_, "maxCopy");
  params.add(nw_target, "targetwalkers");
  params.add(nw_max, "max_walkers");
  params.add(use_nonblocking_, "use_nonblocking", {true});
  params.add(debug_disable_branching_, "debug_disable_branching", {false});

  try
  {
    bool success = params.put(cur);
  }
  catch (const std::runtime_error& re)
  {
    myComm->barrier_and_abort("WalkerControl::put parsing error. " + std::string(re.what()));
  }

  setMinMax(nw_target, nw_max);

  app_log() << "  WalkerControl parameters " << std::endl;
  //app_log() << "    energyBound = " << targetEnergyBound << std::endl;
  //app_log() << "    sigmaBound = " << targetSigma << std::endl;
  app_log() << "    maxCopy = " << max_copy_ << std::endl;
  app_log() << "    Max Walkers per MPI rank " << n_max_ << std::endl;
  app_log() << "    Min Walkers per MPI rank " << n_min_ << std::endl;
  app_log() << "    Using " << (use_nonblocking_ ? "non-" : "") << "blocking send/recv" << std::endl;
  if (debug_disable_branching_)
    app_log() << "    Disable branching for debugging as the user input request." << std::endl;
  return true;
}

set_ensemble_property()

void set_ensemble_property ( MCDataType< FullPrecRealType > &  ensemble_property )

inline

Definition at line 82 of file WalkerControl.h.

References WalkerControl::ensemble_property_.

  {
    ensemble_property_ = ensemble_property;
  }

setMinMax()

void setMinMax	(	int	nw_in,
		int	nmax_in
	)

Definition at line 583 of file WalkerControl.cpp.

References WalkerControl::max_copy_, WalkerControl::n_max_, WalkerControl::n_min_, WalkerControl::num_ranks_, and WalkerControl::use_fixed_pop_.

Referenced by WalkerControl::put().

{
  if (nw_in > 0)
  {
    int npernode = nw_in / num_ranks_;
    if (use_fixed_pop_)
    {
      n_max_ = npernode;
      n_min_ = npernode;
    }
    else
    {
      n_max_ = max_copy_ * npernode + 1;
      n_min_ = npernode / 5 + 1;
      if (nmax_in > 0)
        n_max_ = nmax_in;
    }
  }
}

setTrialEnergy()

void setTrialEnergy ( FullPrecRealType  et )

inline

set the trial energy for writing to dmc.dat

Definition at line 69 of file WalkerControl.h.

References WalkerControl::trial_energy_.

{ trial_energy_ = et; }

start()

void start

(

)

start a block

Definition at line 78 of file WalkerControl.cpp.

References WalkerControl::dmcFname, WalkerControl::dmcStream, Communicate::getName(), MPIObjectBase::myComm, and WalkerControl::rank_num_.

{
  if (rank_num_ == 0)
  {
    std::filesystem::path hname(myComm->getName());
    hname.concat(".dmc.dat");
    if (hname != dmcFname)
    {
      dmcStream = std::make_unique<std::ofstream>(hname);
      dmcStream->setf(std::ios::scientific, std::ios::floatfield);
      dmcStream->precision(10);
      (*dmcStream) << "# Index " << std::setw(20) << "LocalEnergy" << std::setw(20) << "Variance" << std::setw(20)
                   << "Weight" << std::setw(20) << "NumOfWalkers" << std::setw(20)
                   << "AvgSentWalkers"; //add the number of walkers
      (*dmcStream) << std::setw(20) << "TrialEnergy" << std::setw(20) << "DiffEff";
      (*dmcStream) << std::setw(20) << "LivingFraction";
      (*dmcStream) << std::endl;
      dmcFname = std::move(hname);
    }
  }
}

syncFutureWalkersPerRank()

std::vector< WalkerControl::IndexType > syncFutureWalkersPerRank ( Communicate *  comm, IndexType  n_walkers  )

staticprivate

Definition at line 541 of file WalkerControl.cpp.

References Communicate::allreduce(), qmcplusplus::comm, Communicate::rank(), and Communicate::size().

{
  int ncontexts = comm->size();
  std::vector<IndexType> future_walkers(ncontexts, 0);
  future_walkers[comm->rank()] = n_walkers;
  comm->allreduce(future_walkers);
  return future_walkers;
}

writeDMCdat()

void writeDMCdat	(	int	iter,
		const std::vector< FullPrecRealType > &	curData
	)

take averages and writes to a file

Definition at line 100 of file WalkerControl.cpp.

References MCDataType< T >::AlternateEnergy, WalkerControl::curData, WalkerControl::dmcStream, MCDataType< T >::Energy, WalkerControl::ENERGY_INDEX, WalkerControl::ENERGY_SQ_INDEX, WalkerControl::ensemble_property_, WalkerControl::FNSIZE_INDEX, MCDataType< T >::LivingFraction, WalkerControl::num_ranks_, MCDataType< T >::NumSamples, MCDataType< T >::R2Accepted, WalkerControl::R2ACCEPTED_INDEX, MCDataType< T >::R2Proposed, WalkerControl::R2PROPOSED_INDEX, WalkerControl::SENTWALKERS_INDEX, WalkerControl::trial_energy_, MCDataType< T >::Variance, WalkerControl::WALKERSIZE_INDEX, MCDataType< T >::Weight, and WalkerControl::WEIGHT_INDEX.

Referenced by WalkerControl::branch().

{
  //taking average over the walkers
  FullPrecRealType wgtInv(1.0 / curData[WEIGHT_INDEX]);
  FullPrecRealType eavg         = curData[ENERGY_INDEX] * wgtInv;
  ensemble_property_.Energy     = eavg;
  ensemble_property_.Weight     = curData[WEIGHT_INDEX];
  ensemble_property_.Variance   = (curData[ENERGY_SQ_INDEX] * wgtInv - eavg * eavg);
  ensemble_property_.NumSamples = curData[WALKERSIZE_INDEX];
  ensemble_property_.R2Accepted = curData[R2ACCEPTED_INDEX];
  ensemble_property_.R2Proposed = curData[R2PROPOSED_INDEX];
  ensemble_property_.LivingFraction =
      static_cast<FullPrecRealType>(curData[FNSIZE_INDEX]) / static_cast<FullPrecRealType>(curData[WALKERSIZE_INDEX]);
  ensemble_property_.AlternateEnergy = FullPrecRealType(0);
  // \\todo If WalkerControl is not exclusively for dmc then this shouldn't be here.
  // If it is it shouldn't be in QMDrivers but QMCDrivers/DMC
  if (dmcStream)
  {
    //boost::archive::text_oarchive oa(*dmcStream);
    //(*oa) & iter  & eavg_cur & wgt_cur & Etrial  & pop_old;
    (*dmcStream) << std::setw(10) << iter << std::setw(20) << ensemble_property_.Energy << std::setw(20)
                 << ensemble_property_.Variance << std::setw(20) << ensemble_property_.Weight << std::setw(20)
                 << ensemble_property_.NumSamples << std::setw(20)
                 << curData[SENTWALKERS_INDEX] / static_cast<double>(num_ranks_);
    (*dmcStream) << std::setw(20) << trial_energy_ << std::setw(20)
                 << ensemble_property_.R2Accepted / ensemble_property_.R2Proposed;
    (*dmcStream) << std::setw(20) << ensemble_property_.LivingFraction;
    // Work around for bug with deterministic scalar trace test on select compiler/architectures.
    // While WalkerControl appears to have exclusive ownership of the dmcStream pointer,
    // this is not actually true. Apparently it doesn't actually and can loose ownership then it is
    // either leaked or not flushed before it is destroyed.
    // \todo fix this, you don't want to flush every step since you really hope that could be very rapid.
    (*dmcStream)
        << std::endl; //'\n'; // this is definitely not a place to put an endl as that is also a signal for a flush.
  }
}

Member Data Documentation

curData

std::vector<FullPrecRealType> curData

private

any temporary data includes many ridiculous conversions of integral types to and from fp

Definition at line 170 of file WalkerControl.h.

Referenced by WalkerControl::branch(), WalkerControl::computeCurData(), and WalkerControl::writeDMCdat().

debug_disable_branching_

bool debug_disable_branching_

private

disable branching for debugging

Definition at line 174 of file WalkerControl.h.

Referenced by WalkerControl::branch(), and WalkerControl::put().

dmcFname

std::filesystem::path dmcFname

private

filename for dmc.dat

Definition at line 160 of file WalkerControl.h.

Referenced by WalkerControl::start().

dmcStream

std::unique_ptr<std::ofstream> dmcStream

private

file to save energy histogram

Definition at line 162 of file WalkerControl.h.

Referenced by WalkerControl::start(), and WalkerControl::writeDMCdat().

ensemble_property_

MCDataType<FullPrecRealType> ensemble_property_

private

ensemble properties

Definition at line 176 of file WalkerControl.h.

Referenced by WalkerControl::branch(), WalkerControl::get_ensemble_property(), WalkerControl::set_ensemble_property(), and WalkerControl::writeDMCdat().

fair_offset_

std::vector<int> fair_offset_

private

offset of the particle index for a fair distribution

Definition at line 158 of file WalkerControl.h.

Referenced by WalkerControl::WalkerControl().

max_copy_

IndexType max_copy_

private

maximum copy per walker

Definition at line 152 of file WalkerControl.h.

Referenced by WalkerControl::put(), and WalkerControl::setMinMax().

my_timers_

TimerList_t my_timers_

private

timers

Definition at line 178 of file WalkerControl.h.

Referenced by WalkerControl::branch(), and WalkerControl::computeCurData().

n_max_

IndexType n_max_

private

maximum number of walkers

Definition at line 150 of file WalkerControl.h.

Referenced by WalkerControl::get_n_max(), WalkerControl::put(), and WalkerControl::setMinMax().

n_min_

IndexType n_min_

private

minimum number of walkers

Definition at line 148 of file WalkerControl.h.

Referenced by WalkerControl::get_n_min(), WalkerControl::put(), and WalkerControl::setMinMax().

num_per_rank_

std::vector<int> num_per_rank_

private

number of walkers on each MPI rank after branching before load balancing

Definition at line 156 of file WalkerControl.h.

Referenced by WalkerControl::branch(), and WalkerControl::WalkerControl().

num_ranks_

const IndexType num_ranks_

private

number of contexts

Definition at line 166 of file WalkerControl.h.

Referenced by WalkerControl::branch(), WalkerControl::get_num_contexts(), WalkerControl::setMinMax(), WalkerControl::WalkerControl(), and WalkerControl::writeDMCdat().

rank_num_

const IndexType rank_num_

private

context id

Definition at line 164 of file WalkerControl.h.

Referenced by WalkerControl::computeCurData(), and WalkerControl::start().

rng_

RandomBase<FullPrecRealType>& rng_

private

random number generator

Definition at line 144 of file WalkerControl.h.

Referenced by WalkerControl::branch().

saved_num_walkers_sent_

IndexType saved_num_walkers_sent_

private

Number of walkers sent during the exchange.

Definition at line 180 of file WalkerControl.h.

Referenced by WalkerControl::computeCurData().

SwapMode

IndexType SwapMode

private

0 is default

Definition at line 168 of file WalkerControl.h.

trial_energy_

FullPrecRealType trial_energy_

private

trial energy energy

Definition at line 154 of file WalkerControl.h.

Referenced by WalkerControl::setTrialEnergy(), and WalkerControl::writeDMCdat().

use_fixed_pop_

bool use_fixed_pop_

private

if true, use fixed population

Definition at line 146 of file WalkerControl.h.

Referenced by WalkerControl::branch(), WalkerControl::computeCurData(), and WalkerControl::setMinMax().

use_nonblocking_

bool use_nonblocking_

private

Use non-blocking isend/irecv.

Definition at line 172 of file WalkerControl.h.

Referenced by WalkerControl::put().

---

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

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