MCPopulation Class Reference

Collaboration diagram for MCPopulation:

Public Types
using	MCPWalker = Walker< QMCTraits, PtclOnLatticeTraits >
using	WFBuffer = MCPWalker::WFBuffer_t
using	RealType = QMCTraits::RealType
using	Properties = MCPWalker::PropertyContainer_t
using	IndexType = QMCTraits::IndexType
using	FullPrecRealType = QMCTraits::FullPrecRealType
using	opt_variables_type = optimize::VariableSet

Public Member Functions
	MCPopulation (int num_ranks, int this_rank, ParticleSet *elecs, TrialWaveFunction *trial_wf, QMCHamiltonian *hamiltonian_)
	Temporary constructor to deal with MCWalkerConfiguration be the only source of some information in QMCDriverFactory. More...
	~MCPopulation ()
	MCPopulation (MCPopulation &)=delete
MCPopulation &	operator= (MCPopulation &)=delete
	MCPopulation (MCPopulation &&)=default
WalkerElementsRef	spawnWalker ()
	State Requirement: More...
void	killWalker (MCPWalker &)
	Kill a walker (just barely) More...
void	killLastWalker ()
	Kill last walker (just barely) More...
void	createWalkers (IndexType num_walkers, const WalkerConfigurations &walker_configs, RealType reserve=1.0)
	}@ More...
template<typename WTTV >
void	redistributeWalkers (WTTV &walker_consumers)
	distributes walkers and their "cloned" elements to the elements of a vector of unique_ptr to "walker_consumers". More...
void	syncWalkersPerRank (Communicate *comm)
void	measureGlobalEnergyVariance (Communicate &comm, FullPrecRealType &ener, FullPrecRealType &variance) const
int	get_num_ranks () const
	The number of cases in which this and get_num_local_walkers is so few that I strongly suspect it is a design issue. More...
int	get_rank () const
IndexType	get_num_global_walkers () const
IndexType	get_num_local_walkers () const
IndexType	get_max_samples () const
IndexType	get_target_population () const
IndexType	get_target_samples () const
const ParticleSet &	get_golden_electrons () const
ParticleSet &	get_golden_electrons ()
const TrialWaveFunction &	get_golden_twf () const
TrialWaveFunction &	get_golden_twf ()
QMCHamiltonian &	get_golden_hamiltonian ()
void	set_num_global_walkers (IndexType num_global_walkers)
void	set_num_local_walkers (IndexType num_local_walkers)
void	set_target (IndexType pop)
void	set_target_samples (IndexType samples)
void	set_ensemble_property (const MCDataType< QMCTraits::FullPrecRealType > &ensemble_property)
UPtrVector< MCPWalker > &	get_walkers ()
const UPtrVector< MCPWalker > &	get_walkers () const
const UPtrVector< MCPWalker > &	get_dead_walkers () const
UPtrVector< ParticleSet > &	get_elec_particle_sets ()
UPtrVector< TrialWaveFunction > &	get_twfs ()
UPtrVector< TrialWaveFunction > &	get_dead_twfs ()
UPtrVector< QMCHamiltonian > &	get_hamiltonians ()
UPtrVector< QMCHamiltonian > &	get_dead_hamiltonians ()
WalkerElementsRef	getWalkerElementsRef (const size_t walker_index)
	Non threadsafe access to walkers and their elements. More...
std::vector< WalkerElementsRef >	get_walker_elements ()
	As long as walker WalkerElements is used we need this for unit tests. More...
const std::vector< RealType > &	get_ptclgrp_mass () const
const std::vector< RealType > &	get_ptclgrp_inv_mass () const
const std::vector< RealType > &	get_ptcl_inv_mass () const
void	checkIntegrity () const
	}@ More...
void	saveWalkerConfigurations (WalkerConfigurations &walker_configs)
	save walker configurations to walker_configs_ref_ More...

Private Attributes
MCDataType< QMCTraits::FullPrecRealType >	ensemble_property_
IndexType	num_global_walkers_ = 0
IndexType	num_local_walkers_ = 0
IndexType	max_samples_ = 0
IndexType	target_population_ = 0
IndexType	target_samples_ = 0
UPtrVector< MCPWalker >	walkers_
UPtrVector< MCPWalker >	dead_walkers_
std::vector< RealType >	ptclgrp_mass_
std::vector< RealType >	ptclgrp_inv_mass_
	1/Mass per species More...
std::vector< RealType >	ptcl_inv_mass_
	1/Mass per particle More...
TrialWaveFunction *	trial_wf_
ParticleSet *	elec_particle_set_
QMCHamiltonian *	hamiltonian_
UPtrVector< ParticleSet >	walker_elec_particle_sets_
UPtrVector< TrialWaveFunction >	walker_trial_wavefunctions_
UPtrVector< QMCHamiltonian >	walker_hamiltonians_
UPtrVector< ParticleSet >	dead_walker_elec_particle_sets_
UPtrVector< TrialWaveFunction >	dead_walker_trial_wavefunctions_
UPtrVector< QMCHamiltonian >	dead_walker_hamiltonians_
int	num_ranks_
int	rank_

Detailed Description

Definition at line 38 of file MCPopulation.h.

Member Typedef Documentation

FullPrecRealType

using FullPrecRealType = QMCTraits::FullPrecRealType

Definition at line 46 of file MCPopulation.h.

IndexType

using IndexType = QMCTraits::IndexType

Definition at line 45 of file MCPopulation.h.

MCPWalker

using MCPWalker = Walker<QMCTraits, PtclOnLatticeTraits>

Definition at line 41 of file MCPopulation.h.

opt_variables_type

using opt_variables_type = optimize::VariableSet

Definition at line 47 of file MCPopulation.h.

Properties

using Properties = MCPWalker::PropertyContainer_t

Definition at line 44 of file MCPopulation.h.

RealType

using RealType = QMCTraits::RealType

Definition at line 43 of file MCPopulation.h.

WFBuffer

using WFBuffer = MCPWalker::WFBuffer_t

Definition at line 42 of file MCPopulation.h.

Constructor & Destructor Documentation

MCPopulation() [1/3]

MCPopulation	(	int	num_ranks,
		int	this_rank,
		ParticleSet *	elecs,
		TrialWaveFunction *	trial_wf,
		QMCHamiltonian *	hamiltonian_
	)

Temporary constructor to deal with MCWalkerConfiguration be the only source of some information in QMCDriverFactory.

Definition at line 23 of file MCPopulation.cpp.

References ParticleSet::first(), ParticleSet::getTotalNum(), ParticleSet::groups(), ParticleSet::last(), ParticleSet::Mass, MCPopulation::ptcl_inv_mass_, MCPopulation::ptclgrp_inv_mass_, and MCPopulation::ptclgrp_mass_.

    : trial_wf_(trial_wf), elec_particle_set_(elecs), hamiltonian_(hamiltonian), num_ranks_(num_ranks), rank_(this_rank)
{
  const auto num_groups = elecs->groups();
  ptclgrp_mass_.resize(num_groups);
  ptclgrp_inv_mass_.resize(num_groups);
  for (int ig = 0; ig < num_groups; ++ig)
  {
    ptclgrp_mass_[ig]     = elecs->Mass[elecs->first(ig)];
    ptclgrp_inv_mass_[ig] = 1.0 / ptclgrp_mass_[ig];
  }

  ptcl_inv_mass_.resize(elecs->getTotalNum());
  for (int ig = 0; ig < num_groups; ++ig)
    for (int iat = elecs->first(ig); iat < elecs->last(ig); ++iat)
      ptcl_inv_mass_[iat] = ptclgrp_inv_mass_[ig];
}

~MCPopulation()

~MCPopulation ( )

default

MCPopulation() [2/3]

MCPopulation ( MCPopulation &  )

delete

MCPopulation() [3/3]

MCPopulation ( MCPopulation &&  )

default

Member Function Documentation

checkIntegrity()

void checkIntegrity

(

)

const

}@

check if all the internal vector contain consistent sizes;

Definition at line 264 of file MCPopulation.cpp.

References MCPopulation::dead_walker_elec_particle_sets_, MCPopulation::dead_walker_hamiltonians_, MCPopulation::dead_walker_trial_wavefunctions_, MCPopulation::dead_walkers_, MCPopulation::num_local_walkers_, MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_hamiltonians_, MCPopulation::walker_trial_wavefunctions_, and MCPopulation::walkers_.

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

{
  // check active walkers
  const size_t num_local_walkers_active = num_local_walkers_;
  if (walkers_.size() != num_local_walkers_active)
    throw std::runtime_error("walkers_ has inconsistent size");
  if (walker_elec_particle_sets_.size() != num_local_walkers_active)
    throw std::runtime_error("walker_elec_particle_sets_ has inconsistent size");
  if (walker_trial_wavefunctions_.size() != num_local_walkers_active)
    throw std::runtime_error("walker_trial_wavefunctions_ has inconsistent size");
  if (walker_trial_wavefunctions_.size() != num_local_walkers_active)
    throw std::runtime_error("walker_trial_wavefunctions_ has inconsistent size");
  if (walker_hamiltonians_.size() != num_local_walkers_active)
    throw std::runtime_error("walker_hamiltonians_ has inconsistent size");

  // check dead walkers
  const size_t num_local_walkers_dead = dead_walkers_.size();
  if (dead_walker_elec_particle_sets_.size() != num_local_walkers_dead)
    throw std::runtime_error("dead_walker_elec_particle_sets_ has inconsistent size");
  if (dead_walker_trial_wavefunctions_.size() != num_local_walkers_dead)
    throw std::runtime_error("dead_walker_trial_wavefunctions_ has inconsistent size");
  if (dead_walker_trial_wavefunctions_.size() != num_local_walkers_dead)
    throw std::runtime_error("dead_walker_trial_wavefunctions_ has inconsistent size");
  if (dead_walker_hamiltonians_.size() != num_local_walkers_dead)
    throw std::runtime_error("dead_walker_hamiltonians_ has inconsistent size");
}

createWalkers()

void createWalkers	(	IndexType	num_walkers,
		const WalkerConfigurations &	walker_configs,
		RealType	reserve = 1.0
	)

}@

Creates walkers with a clone of the golden electron particle set and golden trial wavefunction

Parameters

[in]	num_walkers	number of living walkers in initial population
[in]	reserve	multiple above that to reserve >=1.0

Definition at line 47 of file MCPopulation.cpp.

References MCPopulation::elec_particle_set_, WalkerConfigurations::getActiveWalkers(), ParticleSet::getTotalNum(), MCPopulation::hamiltonian_, MCPopulation::killLastWalker(), QMCHamiltonian::makeClone(), TrialWaveFunction::makeClone(), MCPopulation::num_local_walkers_, MCPopulation::num_ranks_, qmcplusplus::hdf::num_walkers, outputManager, OutputManagerClass::pause(), ParticleSet::Properties, ParticleSet::PropertyList, ParticleSet::R, MCPopulation::rank_, ConstantSizeMatrix< T, ALLOC >::resize(), OutputManagerClass::resume(), RecordNamedProperty< T >::size(), ParticleSet::spins, MCPopulation::trial_wf_, MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_hamiltonians_, MCPopulation::walker_trial_wavefunctions_, and MCPopulation::walkers_.

Referenced by QMCDriverNew::makeLocalWalkers(), and qmcplusplus::TEST_CASE().

{
  IndexType num_walkers_plus_reserve = static_cast<IndexType>(num_walkers * reserve);

  // Hack to hopefully insure no truly new walkers will be made by spawn, since I suspect that
  // doesn't capture everything that needs to make a walker + elements valid to load from a transferred
  // buffer;
  // Ye: need to resize walker_t and ParticleSet Properties
  // Really MCPopulation does not own this elec_particle_set_  seems like it should be immutable
  elec_particle_set_->Properties.resize(1, elec_particle_set_->PropertyList.size());

  // This pattern is begging for a micro benchmark, is this really better
  // than the simpler walkers_.pushback;
  walkers_.resize(num_walkers_plus_reserve);
  walker_elec_particle_sets_.resize(num_walkers_plus_reserve);
  walker_trial_wavefunctions_.resize(num_walkers_plus_reserve);
  walker_hamiltonians_.resize(num_walkers_plus_reserve);

  outputManager.pause();

  //this part is time consuming, it must be threaded and calls should be thread-safe.
#pragma omp parallel for
  for (size_t iw = 0; iw < num_walkers_plus_reserve; iw++)
  {
    walkers_[iw]             = std::make_unique<MCPWalker>(elec_particle_set_->getTotalNum());
    walkers_[iw]->Properties = elec_particle_set_->Properties;

    // initialize coord
    if (const auto num_existing_walkers = walker_configs.getActiveWalkers())
      *walkers_[iw] = *walker_configs[iw % num_existing_walkers];
    else
    {
      walkers_[iw]->R          = elec_particle_set_->R;
      walkers_[iw]->spins      = elec_particle_set_->spins;
    }

    walkers_[iw]->registerData();
    walkers_[iw]->DataSet.allocate();

    walker_elec_particle_sets_[iw]  = std::make_unique<ParticleSet>(*elec_particle_set_);
    walker_trial_wavefunctions_[iw] = trial_wf_->makeClone(*walker_elec_particle_sets_[iw]);
    walker_hamiltonians_[iw] =
        hamiltonian_->makeClone(*walker_elec_particle_sets_[iw], *walker_trial_wavefunctions_[iw]);
  };

  outputManager.resume();

  int num_walkers_created = 0;
  for (auto& walker_ptr : walkers_)
  {
    if (walker_ptr->getWalkerID() == 0)
    {
      // And so walker ID's start at one because 0 is magic.
      // \todo This is C++ all indexes start at 0, make uninitialized ID = -1
      walker_ptr->setWalkerID((num_walkers_created++) * num_ranks_ + rank_ + 1);
      walker_ptr->setParentID(walker_ptr->getWalkerID());
    }
  }

  // kill and spawn walkers update the state variable num_local_walkers_
  // so it must start at the number of reserved walkers
  num_local_walkers_ = num_walkers_plus_reserve;

  IndexType extra_walkers = num_walkers_plus_reserve - num_walkers;
  // Now we kill the extra reserve walkers and elements that we made.
  for (int i = 0; i < extra_walkers; ++i)
    killLastWalker();
}

get_dead_hamiltonians()

UPtrVector<QMCHamiltonian>& get_dead_hamiltonians ( )

inline

Definition at line 204 of file MCPopulation.h.

References MCPopulation::dead_walker_hamiltonians_.

{ return dead_walker_hamiltonians_; }

get_dead_twfs()

UPtrVector<TrialWaveFunction>& get_dead_twfs ( )

inline

Definition at line 201 of file MCPopulation.h.

References MCPopulation::dead_walker_trial_wavefunctions_.

{ return dead_walker_trial_wavefunctions_; }

get_dead_walkers()

const UPtrVector<MCPWalker>& get_dead_walkers ( ) const

inline

Definition at line 196 of file MCPopulation.h.

References MCPopulation::dead_walkers_.

Referenced by QMCDriverNew::get_num_dead_walkers().

{ return dead_walkers_; }

get_elec_particle_sets()

UPtrVector<ParticleSet>& get_elec_particle_sets ( )

inline

Definition at line 198 of file MCPopulation.h.

References MCPopulation::walker_elec_particle_sets_.

Referenced by VMCBatched::run().

{ return walker_elec_particle_sets_; }

get_golden_electrons() [1/2]

const ParticleSet& get_golden_electrons ( ) const

inline

Definition at line 176 of file MCPopulation.h.

References MCPopulation::elec_particle_set_.

Referenced by QMCDriverNew::initializeQMC(), SFNBranch::initParam(), QMCFixedSampleLinearOptimizeBatched::processOptXML(), QMCDriverNew::putWalkers(), DMCBatched::run(), DMCBatched::runDMCStep(), and VMCBatched::runVMCStep().

{ return *elec_particle_set_; }

get_golden_electrons() [2/2]

ParticleSet& get_golden_electrons ( )

inline

Definition at line 177 of file MCPopulation.h.

References MCPopulation::elec_particle_set_.

{ return *elec_particle_set_; }

get_golden_hamiltonian()

QMCHamiltonian& get_golden_hamiltonian ( )

inline

Definition at line 181 of file MCPopulation.h.

References MCPopulation::hamiltonian_.

Referenced by QMCDriverNew::initializeQMC(), QMCFixedSampleLinearOptimizeBatched::processOptXML(), and QMCDriverNew::QMCDriverNew().

{ return *hamiltonian_; }

get_golden_twf() [1/2]

const TrialWaveFunction& get_golden_twf ( ) const

inline

Definition at line 178 of file MCPopulation.h.

References MCPopulation::trial_wf_.

Referenced by QMCDriverNew::initializeQMC(), and QMCFixedSampleLinearOptimizeBatched::processOptXML().

{ return *trial_wf_; }

get_golden_twf() [2/2]

TrialWaveFunction& get_golden_twf ( )

inline

Definition at line 179 of file MCPopulation.h.

References MCPopulation::trial_wf_.

{ return *trial_wf_; }

get_hamiltonians()

UPtrVector<QMCHamiltonian>& get_hamiltonians ( )

inline

Definition at line 203 of file MCPopulation.h.

References MCPopulation::walker_hamiltonians_.

Referenced by DMCBatched::run().

{ return walker_hamiltonians_; }

get_max_samples()

IndexType get_max_samples ( ) const

inline

Definition at line 170 of file MCPopulation.h.

References MCPopulation::max_samples_.

{ return max_samples_; }

get_num_global_walkers()

IndexType get_num_global_walkers ( ) const

inline

Definition at line 168 of file MCPopulation.h.

References MCPopulation::num_global_walkers_.

Referenced by WalkerControl::branch(), SFNBranch::initParam(), and DMCBatched::process().

{ return num_global_walkers_; }

get_num_local_walkers()

IndexType get_num_local_walkers ( ) const

inline

Definition at line 169 of file MCPopulation.h.

References MCPopulation::num_local_walkers_.

Referenced by WalkerControl::branch(), VMCBatched::enable_sample_collection(), qmcplusplus::operator<<(), and UnifiedDriverWalkerControlMPITest::reportWalkersPerRank().

{ return num_local_walkers_; }

get_num_ranks()

int get_num_ranks ( ) const

inline

The number of cases in which this and get_num_local_walkers is so few that I strongly suspect it is a design issue.

get_active_walkers is onlyh useful between the setting of num_local_walkers_ and creation of walkers. I would reason this is actually a time over which the MCPopulation object is invalid. Ideally MCPopulation not process any calls in this state, next best would be to only process calls to become valid.

Definition at line 166 of file MCPopulation.h.

References MCPopulation::num_ranks_.

Referenced by VMCBatched::enable_sample_collection().

{ return num_ranks_; }

get_ptcl_inv_mass()

const std::vector<RealType>& get_ptcl_inv_mass ( ) const

inline

Definition at line 225 of file MCPopulation.h.

References MCPopulation::ptcl_inv_mass_.

{ return ptcl_inv_mass_; }

get_ptclgrp_inv_mass()

const std::vector<RealType>& get_ptclgrp_inv_mass ( ) const

inline

Definition at line 224 of file MCPopulation.h.

References MCPopulation::ptclgrp_inv_mass_.

Referenced by VMCBatched::advanceWalkers(), and DMCBatched::advanceWalkers().

{ return ptclgrp_inv_mass_; }

get_ptclgrp_mass()

const std::vector<RealType>& get_ptclgrp_mass ( ) const

inline

Definition at line 223 of file MCPopulation.h.

References MCPopulation::ptclgrp_mass_.

{ return ptclgrp_mass_; }

get_rank()

int get_rank ( ) const

inline

Definition at line 167 of file MCPopulation.h.

References MCPopulation::rank_.

{ return rank_; }

get_target_population()

IndexType get_target_population ( ) const

inline

Definition at line 171 of file MCPopulation.h.

References MCPopulation::target_population_.

{ return target_population_; }

get_target_samples()

IndexType get_target_samples ( ) const

inline

Definition at line 172 of file MCPopulation.h.

References MCPopulation::target_samples_.

{ return target_samples_; }

get_twfs()

UPtrVector<TrialWaveFunction>& get_twfs ( )

inline

Definition at line 200 of file MCPopulation.h.

References MCPopulation::walker_trial_wavefunctions_.

{ return walker_trial_wavefunctions_; }

get_walker_elements()

std::vector< WalkerElementsRef > get_walker_elements

(

)

As long as walker WalkerElements is used we need this for unit tests.

As operator[] don't use it to ignore the concurrency design.

Definition at line 121 of file MCPopulation.cpp.

References MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_trial_wavefunctions_, and MCPopulation::walkers_.

{
  std::vector<WalkerElementsRef> walker_elements;
  for (int iw = 0; iw < walkers_.size(); ++iw)
  {
    walker_elements.emplace_back(*walkers_[iw], *walker_elec_particle_sets_[iw], *walker_trial_wavefunctions_[iw]);
  }
  return walker_elements;
}

get_walkers() [1/2]

UPtrVector<MCPWalker>& get_walkers ( )

inline

Definition at line 194 of file MCPopulation.h.

References MCPopulation::walkers_.

Referenced by WalkerControl::branch(), QMCDriverNew::get_num_living_walkers(), WalkerControl::killDeadWalkersOnRank(), and QMCDriverNew::makeLocalWalkers().

{ return walkers_; }

get_walkers() [2/2]

const UPtrVector<MCPWalker>& get_walkers ( ) const

inline

Definition at line 195 of file MCPopulation.h.

References MCPopulation::walkers_.

{ return walkers_; }

getWalkerElementsRef()

WalkerElementsRef getWalkerElementsRef

(

const size_t

walker_index

)

Non threadsafe access to walkers and their elements.

Prefer to distribute the walker elements and access through a crowd to support the concurrency design.

You should not use this unless absolutely necessary. That doesn't include that you would rather just use omp parallel and ignore concurrency.

Definition at line 116 of file MCPopulation.cpp.

References MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_trial_wavefunctions_, and MCPopulation::walkers_.

{
  return {*walkers_[index], *walker_elec_particle_sets_[index], *walker_trial_wavefunctions_[index]};
}

killLastWalker()

void killLastWalker

(

)

Kill last walker (just barely)

By kill we mean put it and all its elements in a "dead" list.

Definition at line 188 of file MCPopulation.cpp.

References MCPopulation::dead_walker_elec_particle_sets_, MCPopulation::dead_walker_hamiltonians_, MCPopulation::dead_walker_trial_wavefunctions_, MCPopulation::dead_walkers_, MCPopulation::num_local_walkers_, MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_hamiltonians_, MCPopulation::walker_trial_wavefunctions_, and MCPopulation::walkers_.

Referenced by MCPopulation::createWalkers(), and QMCDriverNew::makeLocalWalkers().

{
  --num_local_walkers_;
  // kill the walker but just barely we need all its setup and connections to remain
  dead_walkers_.push_back(std::move(walkers_.back()));
  walkers_.pop_back();
  dead_walker_elec_particle_sets_.push_back(std::move(walker_elec_particle_sets_.back()));
  walker_elec_particle_sets_.pop_back();
  dead_walker_trial_wavefunctions_.push_back(std::move(walker_trial_wavefunctions_.back()));
  walker_trial_wavefunctions_.pop_back();
  dead_walker_hamiltonians_.push_back(std::move(walker_hamiltonians_.back()));
  walker_hamiltonians_.pop_back();
}

killWalker()

void killWalker

(

MCPWalker &

walker

)

Kill a walker (just barely)

By kill we mean put it and all its elements in a "dead" list.

Definition at line 205 of file MCPopulation.cpp.

References MCPopulation::dead_walker_elec_particle_sets_, MCPopulation::dead_walker_hamiltonians_, MCPopulation::dead_walker_trial_wavefunctions_, MCPopulation::dead_walkers_, MCPopulation::num_local_walkers_, qmcplusplus::walker, MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_hamiltonians_, MCPopulation::walker_trial_wavefunctions_, and MCPopulation::walkers_.

Referenced by WalkerControl::killDeadWalkersOnRank().

{
  // find the walker and move its pointer to the dead walkers vector
  auto it_walkers = walkers_.begin();
  auto it_psets   = walker_elec_particle_sets_.begin();
  auto it_twfs    = walker_trial_wavefunctions_.begin();
  auto it_hams    = walker_hamiltonians_.begin();
  while (it_walkers != walkers_.end())
  {
    if (&walker == (*it_walkers).get())
    {
      dead_walkers_.push_back(std::move(*it_walkers));
      walkers_.erase(it_walkers);
      dead_walker_elec_particle_sets_.push_back(std::move(*it_psets));
      walker_elec_particle_sets_.erase(it_psets);
      dead_walker_trial_wavefunctions_.push_back(std::move(*it_twfs));
      walker_trial_wavefunctions_.erase(it_twfs);
      dead_walker_hamiltonians_.push_back(std::move(*it_hams));
      walker_hamiltonians_.erase(it_hams);
      --num_local_walkers_;
      return;
    }
    ++it_walkers;
    ++it_psets;
    ++it_twfs;
    ++it_hams;
  }
  throw std::runtime_error("Attempt to kill nonexistent walker in MCPopulation!");
}

measureGlobalEnergyVariance()

void measureGlobalEnergyVariance	(	Communicate &	comm,
		FullPrecRealType &	ener,
		FullPrecRealType &	variance
	)		const

Definition at line 245 of file MCPopulation.cpp.

References Communicate::allreduce(), qmcplusplus::comm, qmcplusplus::Units::charge::e, MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_hamiltonians_, and MCPopulation::walkers_.

Referenced by DMCBatched::run().

{
  std::vector<FullPrecRealType> weight_energy_variance(3, 0.0);
  for (int iw = 0; iw < walker_elec_particle_sets_.size(); iw++)
  {
    auto w = walkers_[iw]->Weight;
    auto e = walker_hamiltonians_[iw]->getLocalEnergy();
    weight_energy_variance[0] += w;
    weight_energy_variance[1] += w * e;
    weight_energy_variance[2] += w * e * e;
  }

  comm.allreduce(weight_energy_variance);
  ener     = weight_energy_variance[1] / weight_energy_variance[0];
  variance = weight_energy_variance[2] / weight_energy_variance[0] - ener * ener;
}

operator=()

MCPopulation& operator= ( MCPopulation &  )

delete

redistributeWalkers()

void redistributeWalkers ( WTTV &  walker_consumers )

inline

distributes walkers and their "cloned" elements to the elements of a vector of unique_ptr to "walker_consumers".

a valid "walker_consumer" has a member function of void addWalker(MCPWalker& walker, ParticleSet& elecs, TrialWaveFunction& twf, QMCHamiltonian& hamiltonian);

Definition at line 131 of file MCPopulation.h.

References fairDivide(), MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_hamiltonians_, MCPopulation::walker_trial_wavefunctions_, and MCPopulation::walkers_.

Referenced by QMCDriverNew::initializeQMC(), and DMCBatched::run().

  {
    // The type returned here is dependent on the integral type that the walker_consumers
    // use to return there size.
    auto walkers_per_crowd = fairDivide(walkers_.size(), walker_consumers.size());

    auto walker_index = 0;
    for (int i = 0; i < walker_consumers.size(); ++i)
    {
      walker_consumers[i]->clearWalkers();
      for (int j = 0; j < walkers_per_crowd[i]; ++j)
      {
        walker_consumers[i]->addWalker(*walkers_[walker_index], *walker_elec_particle_sets_[walker_index],
                                       *walker_trial_wavefunctions_[walker_index], *walker_hamiltonians_[walker_index]);
        ++walker_index;
      }
    }
  }

saveWalkerConfigurations()

void saveWalkerConfigurations

(

WalkerConfigurations &

walker_configs

)

save walker configurations to walker_configs_ref_

Definition at line 291 of file MCPopulation.cpp.

References MCPopulation::elec_particle_set_, ParticleSet::getTotalNum(), WalkerConfigurations::resize(), MCPopulation::walker_elec_particle_sets_, and MCPopulation::walkers_.

Referenced by QMCDriverNew::finalize(), and QMCDriverNew::recordBlock().

{
  walker_configs.resize(walker_elec_particle_sets_.size(), elec_particle_set_->getTotalNum());
  for (int iw = 0; iw < walker_elec_particle_sets_.size(); iw++)
  {
    walker_elec_particle_sets_[iw]->saveWalker(*walker_configs[iw]);
    walker_configs[iw]->Weight = walkers_[iw]->Weight;
  }
}

set_ensemble_property()

void set_ensemble_property ( const MCDataType< QMCTraits::FullPrecRealType > &  ensemble_property )

inline

Definition at line 189 of file MCPopulation.h.

References MCPopulation::ensemble_property_.

Referenced by WalkerControl::branch().

  {
    ensemble_property_ = ensemble_property;
  }

set_num_global_walkers()

void set_num_global_walkers ( IndexType  num_global_walkers )

inline

Definition at line 183 of file MCPopulation.h.

References MCPopulation::num_global_walkers_.

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

{ num_global_walkers_ = num_global_walkers; }

set_num_local_walkers()

void set_num_local_walkers ( IndexType  num_local_walkers )

inline

Definition at line 184 of file MCPopulation.h.

References MCPopulation::num_local_walkers_.

{ num_local_walkers_ = num_local_walkers; }

set_target()

void set_target ( IndexType  pop )

inline

Definition at line 186 of file MCPopulation.h.

References MCPopulation::target_population_.

{ target_population_ = pop; }

set_target_samples()

void set_target_samples ( IndexType  samples )

inline

Definition at line 187 of file MCPopulation.h.

References MCPopulation::target_samples_.

{ target_samples_ = samples; }

spawnWalker()

WalkerElementsRef spawnWalker

(

)

State Requirement:

creates a walker and returns a reference

• createWalkers must have been called

Walkers are reused It would be better if this could be done just by reusing memory. Not thread safe.

Definition at line 138 of file MCPopulation.cpp.

References qmcplusplus::app_warning(), MCPopulation::dead_walker_elec_particle_sets_, MCPopulation::dead_walker_hamiltonians_, MCPopulation::dead_walker_trial_wavefunctions_, MCPopulation::dead_walkers_, MCPopulation::elec_particle_set_, MCPopulation::hamiltonian_, QMCHamiltonian::makeClone(), TrialWaveFunction::makeClone(), MCPopulation::num_local_walkers_, MCPopulation::num_ranks_, outputManager, OutputManagerClass::pause(), MCPopulation::rank_, OutputManagerClass::resume(), MCPopulation::trial_wf_, MCPopulation::walker_elec_particle_sets_, MCPopulation::walker_hamiltonians_, MCPopulation::walker_trial_wavefunctions_, and MCPopulation::walkers_.

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

{
  ++num_local_walkers_;
  outputManager.pause();

  if (dead_walkers_.size() > 0)
  {
    walkers_.push_back(std::move(dead_walkers_.back()));
    dead_walkers_.pop_back();
    walker_elec_particle_sets_.push_back(std::move(dead_walker_elec_particle_sets_.back()));
    dead_walker_elec_particle_sets_.pop_back();
    walker_trial_wavefunctions_.push_back(std::move(dead_walker_trial_wavefunctions_.back()));
    dead_walker_trial_wavefunctions_.pop_back();
    walker_hamiltonians_.push_back(std::move(dead_walker_hamiltonians_.back()));
    dead_walker_hamiltonians_.pop_back();
    // Emulating the legacy implementation valid walker elements were created with the initial walker and DataSet
    // registration and allocation were done then so are not necessary when resurrecting walkers and elements
    walkers_.back()->Generation         = 0;
    walkers_.back()->Age                = 0;
    walkers_.back()->Multiplicity       = 1.0;
    walkers_.back()->Weight             = 1.0;
  }
  else
  {
    app_warning() << "Spawning walker number " << walkers_.size() + 1
                  << " outside of reserves, this ideally should never happened." << std::endl;
    walkers_.push_back(std::make_unique<MCPWalker>(*(walkers_.back())));

    // There is no value in doing this here because its going to be wiped out
    // When we load from the receive buffer. It also won't necessarily be correct
    // Because the buffer is changed by Hamiltonians and wavefunctions that
    // Add to the dataSet.

    walker_elec_particle_sets_.emplace_back(std::make_unique<ParticleSet>(*elec_particle_set_));
    walker_trial_wavefunctions_.emplace_back(trial_wf_->makeClone(*walker_elec_particle_sets_.back()));
    walker_hamiltonians_.emplace_back(
        hamiltonian_->makeClone(*walker_elec_particle_sets_.back(), *walker_trial_wavefunctions_.back()));
    walkers_.back()->Multiplicity = 1.0;
    walkers_.back()->Weight       = 1.0;
    walkers_.back()->setWalkerID((walkers_.size() + 1) * num_ranks_ + rank_ + 1);
  }

  outputManager.resume();
  return {*walkers_.back().get(), *walker_elec_particle_sets_.back().get(), *walker_trial_wavefunctions_.back().get()};
}

syncWalkersPerRank()

void syncWalkersPerRank

(

Communicate *

comm

)

Definition at line 235 of file MCPopulation.cpp.

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

Referenced by WalkerControl::branch().

{
  std::vector<IndexType> num_local_walkers_per_rank(comm->size(), 0);

  num_local_walkers_per_rank[comm->rank()] = num_local_walkers_;
  comm->allreduce(num_local_walkers_per_rank);

  num_global_walkers_ = std::accumulate(num_local_walkers_per_rank.begin(), num_local_walkers_per_rank.end(), 0);
}

Member Data Documentation

dead_walker_elec_particle_sets_

UPtrVector<ParticleSet> dead_walker_elec_particle_sets_

private

Definition at line 82 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), and MCPopulation::spawnWalker().

dead_walker_hamiltonians_

UPtrVector<QMCHamiltonian> dead_walker_hamiltonians_

private

Definition at line 84 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::get_dead_hamiltonians(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), and MCPopulation::spawnWalker().

dead_walker_trial_wavefunctions_

UPtrVector<TrialWaveFunction> dead_walker_trial_wavefunctions_

private

Definition at line 83 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::get_dead_twfs(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), and MCPopulation::spawnWalker().

dead_walkers_

UPtrVector<MCPWalker> dead_walkers_

private

Definition at line 62 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::get_dead_walkers(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), and MCPopulation::spawnWalker().

elec_particle_set_

ParticleSet* elec_particle_set_

private

Definition at line 73 of file MCPopulation.h.

Referenced by MCPopulation::createWalkers(), MCPopulation::get_golden_electrons(), MCPopulation::saveWalkerConfigurations(), and MCPopulation::spawnWalker().

ensemble_property_

MCDataType<QMCTraits::FullPrecRealType> ensemble_property_

private

Definition at line 51 of file MCPopulation.h.

Referenced by MCPopulation::set_ensemble_property().

hamiltonian_

QMCHamiltonian* hamiltonian_

private

Definition at line 74 of file MCPopulation.h.

Referenced by MCPopulation::createWalkers(), MCPopulation::get_golden_hamiltonian(), and MCPopulation::spawnWalker().

max_samples_

IndexType max_samples_ = 0

private

Definition at line 55 of file MCPopulation.h.

Referenced by MCPopulation::get_max_samples().

num_global_walkers_

IndexType num_global_walkers_ = 0

private

Definition at line 53 of file MCPopulation.h.

Referenced by MCPopulation::get_num_global_walkers(), MCPopulation::set_num_global_walkers(), and MCPopulation::syncWalkersPerRank().

num_local_walkers_

IndexType num_local_walkers_ = 0

private

Definition at line 54 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::createWalkers(), MCPopulation::get_num_local_walkers(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), MCPopulation::set_num_local_walkers(), MCPopulation::spawnWalker(), and MCPopulation::syncWalkersPerRank().

num_ranks_

int num_ranks_

private

Definition at line 88 of file MCPopulation.h.

Referenced by MCPopulation::createWalkers(), MCPopulation::get_num_ranks(), and MCPopulation::spawnWalker().

ptcl_inv_mass_

std::vector<RealType> ptcl_inv_mass_

private

1/Mass per particle

Definition at line 67 of file MCPopulation.h.

Referenced by MCPopulation::get_ptcl_inv_mass(), and MCPopulation::MCPopulation().

ptclgrp_inv_mass_

std::vector<RealType> ptclgrp_inv_mass_

private

1/Mass per species

Definition at line 65 of file MCPopulation.h.

Referenced by MCPopulation::get_ptclgrp_inv_mass(), and MCPopulation::MCPopulation().

ptclgrp_mass_

std::vector<RealType> ptclgrp_mass_

private

Definition at line 63 of file MCPopulation.h.

Referenced by MCPopulation::get_ptclgrp_mass(), and MCPopulation::MCPopulation().

rank_

int rank_

private

Definition at line 89 of file MCPopulation.h.

Referenced by MCPopulation::createWalkers(), MCPopulation::get_rank(), and MCPopulation::spawnWalker().

target_population_

IndexType target_population_ = 0

private

Definition at line 56 of file MCPopulation.h.

Referenced by MCPopulation::get_target_population(), and MCPopulation::set_target().

target_samples_

IndexType target_samples_ = 0

private

Definition at line 57 of file MCPopulation.h.

Referenced by MCPopulation::get_target_samples(), and MCPopulation::set_target_samples().

trial_wf_

TrialWaveFunction* trial_wf_

private

Definition at line 72 of file MCPopulation.h.

Referenced by MCPopulation::createWalkers(), MCPopulation::get_golden_twf(), and MCPopulation::spawnWalker().

walker_elec_particle_sets_

UPtrVector<ParticleSet> walker_elec_particle_sets_

private

Definition at line 76 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::createWalkers(), MCPopulation::get_elec_particle_sets(), MCPopulation::get_walker_elements(), MCPopulation::getWalkerElementsRef(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), MCPopulation::measureGlobalEnergyVariance(), MCPopulation::redistributeWalkers(), MCPopulation::saveWalkerConfigurations(), and MCPopulation::spawnWalker().

walker_hamiltonians_

UPtrVector<QMCHamiltonian> walker_hamiltonians_

private

Definition at line 78 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::createWalkers(), MCPopulation::get_hamiltonians(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), MCPopulation::measureGlobalEnergyVariance(), MCPopulation::redistributeWalkers(), and MCPopulation::spawnWalker().

walker_trial_wavefunctions_

UPtrVector<TrialWaveFunction> walker_trial_wavefunctions_

private

Definition at line 77 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::createWalkers(), MCPopulation::get_twfs(), MCPopulation::get_walker_elements(), MCPopulation::getWalkerElementsRef(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), MCPopulation::redistributeWalkers(), and MCPopulation::spawnWalker().

walkers_

UPtrVector<MCPWalker> walkers_

private

Definition at line 61 of file MCPopulation.h.

Referenced by MCPopulation::checkIntegrity(), MCPopulation::createWalkers(), MCPopulation::get_walker_elements(), MCPopulation::get_walkers(), MCPopulation::getWalkerElementsRef(), MCPopulation::killLastWalker(), MCPopulation::killWalker(), MCPopulation::measureGlobalEnergyVariance(), MCPopulation::redistributeWalkers(), MCPopulation::saveWalkerConfigurations(), and MCPopulation::spawnWalker().

---

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

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