EstimatorManagerNew Class Reference

Class to manage a set of ScalarEstimators As a manager, this class handles the aggregation of data from crowds, MPI ranks and I/O logics. More...

Collaboration diagram for EstimatorManagerNew:

Public Types
using	RealType = QMCTraits::FullPrecRealType
	This is to deal with vague expression of precision in legacy code. Don't use in new code. More...
using	FullPrecRealType = QMCTraits::FullPrecRealType
using	QMCT = QMCTraits
using	FPRBuffer = std::vector< FullPrecRealType >
using	MCPWalker = Walker< QMCTraits, PtclOnLatticeTraits >

Public Member Functions
	EstimatorManagerNew (const QMCHamiltonian &ham, Communicate *comm)
	default constructor More...
	EstimatorManagerNew (EstimatorManagerNew &em)=delete
	copy constructor, deleted More...
	EstimatorManagerNew (Communicate *comm, EstimatorManagerInput &&emi, const QMCHamiltonian &H, const ParticleSet &pset, const TrialWaveFunction &twf)
	Batched version constructor. More...
	~EstimatorManagerNew ()
	destructor More...
int	addEstOperator (OperatorEstBase &op_est)
	add a "non" physical operator estimator More...
bool	put (QMCHamiltonian &H, const ParticleSet &pset, const TrialWaveFunction &twf, xmlNodePtr cur)
	process xml tag associated with estimators More...
void	startDriverRun ()
	Start the manager at the beginning of a driver run(). More...
void	stopDriverRun ()
	Stop the manager at the end of a driver run(). More...
void	startBlock (int steps)
	start a block More...
void	stopBlock (unsigned long accept, unsigned long reject, RealType block_weight)
	unified: stop a block More...
void	collectMainEstimators (const RefVector< ScalarEstimatorBase > &scalar_estimators)
	At end of block collect the main scalar estimators for the entire rank. More...
void	collectScalarEstimators (const std::vector< RefVector< ScalarEstimatorBase >> &scalar_ests)
	Deals with possible free form scalar estimators. More...
void	collectOperatorEstimators (const std::vector< RefVector< OperatorEstBase >> &op_ests)
	Reduces OperatorEstimator data from Crowds to the manager's OperatorEstimator data. More...
void	getApproximateEnergyVariance (RealType &e, RealType &var)
	get the average of per-block energy and variance of all the blocks Note: this is not weighted average. More...
auto &	get_AverageCache ()
std::size_t	getNumEstimators ()
std::size_t	getNumScalarEstimators ()
bool	areThereListeners () const
	Do any of the instantiated estimators in operator_ests_ listen to per particle hamiltonian values? Listeners are lambda functions captured from crowd scope estimators and passed to QMCHamiltonian leaders. More...

Private Member Functions
template<typename EstInputType , typename... Args>
bool	createEstimator (EstimatorInput &input, Args &&... args)
	Construct estimator of type matching the underlying EstimatorInput type Consumer and push its its unique_ptr onto operator_ests_. More...
template<typename EstInputType , typename... Args>
bool	createScalarEstimator (ScalarEstimatorInput &input, Args &&... args)
	Construct scalar estimator of type matching the underlying ScalarEstimatorInput type Consumer and push its its unique_ptr onto operator_ests_. More...
void	makeConfigReport (std::ostream &os) const
	Return a string with information about which estimators estimator manager is holding. More...
void	reset ()
	reset the estimator More...
int	addScalarEstimator (std::unique_ptr< ScalarEstimatorBase > &&estimator)
	add an Estimator More...
void	addMainEstimator (std::unique_ptr< ScalarEstimatorBase > &&estimator)
void	makeBlockAverages (unsigned long accept, unsigned long reject)
	collect data and write More...
void	writeScalarH5 ()
	write scalars to scalar.dat and h5 More...
void	reduceOperatorEstimators ()
	do the rank wise reduction of the OperatorEstimators More...
void	writeOperatorEstimators ()
	Write OperatorEstimator data to *.stat.h5. More...
void	zeroOperatorEstimators ()
	OperatorEstimators need to be zeroed out after the block is finished. More...
void	addHeader (std::ostream &o)
	add header to an std::ostream More...

Private Attributes
int	RecordCount
	number of records in a block More...
int	weightInd
	index for the block weight PropertyCache(weightInd) More...
int	cpuInd
	index for the block cpu PropertyCache(cpuInd) More...
int	acceptRatioInd
	index for the accept counter PropertyCache(acceptInd) More...
std::unique_ptr< hdf_archive >	h_file
	hdf5 handler More...
std::unique_ptr< std::ofstream >	Archive
	file handler to write data More...
std::unique_ptr< std::ofstream >	DebugArchive
	file handler to write data for debugging More...
Communicate *	my_comm_
	communicator to handle communication More...
ScalarEstimatorBase::accumulator_type	energyAccumulator
	accumulator for the energy More...
ScalarEstimatorBase::accumulator_type	varAccumulator
	accumulator for the variance More...
Vector< RealType >	AverageCache
	cached block averages of the values More...
Vector< RealType >	PropertyCache
	cached block averages of properties, e.g. BlockCPU More...
RecordNamedProperty< RealType >	BlockAverages
	manager of scalar data More...
RecordNamedProperty< RealType >	BlockProperties
	manager of property data More...
UPtr< ScalarEstimatorBase >	main_estimator_
	main estimator i.e. some version of a local energy estimator. More...
std::vector< UPtr< ScalarEstimatorBase > >	scalar_ests_
	non main scalar estimators collecting simple scalars, are there any? with the removal of collectables these don't seem used or needed. More...
std::vector< ObservableHelper >	h5desc
	convenient descriptors for hdf5 More...
std::vector< std::unique_ptr< OperatorEstBase > >	operator_ests_
	OperatorEst Observables. More...
Timer	block_timer_
	block timer More...
int	max4ascii
	number of maximum data for a scalar.dat More...
size_t	FieldWidth

Static Private Attributes
static constexpr std::string_view	error_tag_ {"EstimatorManagerNew "}

Friends
class	EstimatorManagerCrowd
class	qmcplusplus::testing::EstimatorManagerNewTest
class	qmcplusplus::testing::EstimatorManagerNewTestAccess

Detailed Description

Class to manage a set of ScalarEstimators As a manager, this class handles the aggregation of data from crowds, MPI ranks and I/O logics.

The actually per-crowd data accumulation is done by EstimatorManagerCrowd.

Definition at line 45 of file EstimatorManagerNew.h.

Member Typedef Documentation

FPRBuffer

using FPRBuffer = std::vector<FullPrecRealType>

Definition at line 53 of file EstimatorManagerNew.h.

FullPrecRealType

using FullPrecRealType = QMCTraits::FullPrecRealType

Definition at line 50 of file EstimatorManagerNew.h.

MCPWalker

using MCPWalker = Walker<QMCTraits, PtclOnLatticeTraits>

Definition at line 54 of file EstimatorManagerNew.h.

QMCT

using QMCT = QMCTraits

Definition at line 52 of file EstimatorManagerNew.h.

RealType

using RealType = QMCTraits::FullPrecRealType

This is to deal with vague expression of precision in legacy code. Don't use in new code.

Definition at line 49 of file EstimatorManagerNew.h.

Constructor & Destructor Documentation

EstimatorManagerNew() [1/3]

EstimatorManagerNew	(	const QMCHamiltonian &	ham,
		Communicate *	comm
	)

default constructor

Definition at line 50 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::addMainEstimator(), qmcplusplus::app_log(), qmcplusplus::ham, EstimatorManagerNew::max4ascii, and QMCHamiltonian::sizeOfObservables().

    : RecordCount(0), my_comm_(c), max4ascii(8), FieldWidth(20)
{
  app_log() << " Legacy constructor adding a default LocalEnergyEstimator for the MainEstimator " << std::endl;
  max4ascii = ham.sizeOfObservables() + 3;
  addMainEstimator(std::make_unique<LocalEnergyEstimator>(ham, true));
}

EstimatorManagerNew() [2/3]

EstimatorManagerNew ( EstimatorManagerNew &  em )

delete

copy constructor, deleted

EstimatorManagerNew() [3/3]

EstimatorManagerNew	(	Communicate *	comm,
		EstimatorManagerInput &&	emi,
		const QMCHamiltonian &	H,
		const ParticleSet &	pset,
		const TrialWaveFunction &	twf
	)

Batched version constructor.

Parameters

[in]	emi	EstimatorManagerInput consisting of merged global and local estimator definitions. Moved from!
[in]	H	Fully Constructed Golden Hamiltonian.
[in]	pset	The electron or equiv. pset
[in]	twf	The fully constructed TrialWaveFunction.

Definition at line 95 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::addMainEstimator(), qmcplusplus::app_log(), qmcplusplus::emi(), EstimatorManagerNew::error_tag_, EstimatorManagerInput::get_estimator_inputs(), EstimatorManagerInput::get_scalar_estimator_inputs(), EstimatorManagerNew::main_estimator_, EstimatorManagerNew::makeConfigReport(), EstimatorManagerNew::max4ascii, EstimatorManagerNew::my_comm_, qmcplusplus::pset, Communicate::rank(), QMCHamiltonian::sizeOfObservables(), and qmcplusplus::twf.

    : RecordCount(0), my_comm_(c), max4ascii(8), FieldWidth(20)
{
  for (auto& est_input : emi.get_estimator_inputs())
    if (!(createEstimator<SpinDensityInput>(est_input, pset.getLattice(), pset.getSpeciesSet()) ||
          createEstimator<MomentumDistributionInput>(est_input, pset.getTotalNum(), pset.getTwist(),
                                                     pset.getLattice()) ||
          createEstimator<SelfHealingOverlapInput>(est_input,twf) ||
          createEstimator<OneBodyDensityMatricesInput>(est_input, pset.getLattice(), pset.getSpeciesSet(),
                                                       twf.getSPOMap(), pset) ||
          createEstimator<MagnetizationDensityInput>(est_input, pset.getLattice()) ||
          createEstimator<PerParticleHamiltonianLoggerInput>(est_input, my_comm_->rank())))
      throw UniformCommunicateError(std::string(error_tag_) +
                                    "cannot construct an estimator from estimator input object.");

  for (auto& scalar_input : emi.get_scalar_estimator_inputs())
    if (!(createScalarEstimator<LocalEnergyInput>(scalar_input, H) ||
          createScalarEstimator<CSLocalEnergyInput>(scalar_input, H) ||
          createScalarEstimator<RMCLocalEnergyInput>(scalar_input, H)))
      throw UniformCommunicateError(std::string(error_tag_) +
                                    "cannot construct a scalar estimator from scalar estimator input object.");

  if (main_estimator_ == nullptr)
  {
    app_log() << "  Adding a default LocalEnergyEstimator for the MainEstimator " << std::endl;
    max4ascii = H.sizeOfObservables() + 3;
    addMainEstimator(std::make_unique<LocalEnergyEstimator>(H, true));
  }

  makeConfigReport(app_log());
}

~EstimatorManagerNew()

~EstimatorManagerNew ( )

default

destructor

Member Function Documentation

addEstOperator()

int addEstOperator

(

OperatorEstBase &

op_est

)

add a "non" physical operator estimator

this is a dratically reduced version of OperatorBase right now it just supports what the SpinDensityNew estimator needs

What is actually important is that it has its own locality aware data and EstimatorManagerNew doesn't know about or manage that data.

addHeader()

void addHeader ( std::ostream &  o )

private

add header to an std::ostream

Definition at line 179 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::BlockAverages, EstimatorManagerNew::BlockProperties, EstimatorManagerNew::FieldWidth, EstimatorManagerNew::max4ascii, omptarget::min(), RecordNamedProperty< T >::Names, and RecordNamedProperty< T >::size().

Referenced by EstimatorManagerNew::startDriverRun().

{
  o.setf(std::ios::scientific, std::ios::floatfield);
  o.setf(std::ios::left, std::ios::adjustfield);
  o.precision(10);
  for (int i = 0; i < BlockAverages.size(); i++)
    FieldWidth = std::max(FieldWidth, BlockAverages.Names[i].size() + 2);
  for (int i = 0; i < BlockProperties.size(); i++)
    FieldWidth = std::max(FieldWidth, BlockProperties.Names[i].size() + 2);
  int maxobjs = std::min(BlockAverages.size(), max4ascii);
  o << "#   index    ";
  for (int i = 0; i < maxobjs; i++)
    o << std::setw(FieldWidth) << BlockAverages.Names[i];
  for (int i = 0; i < BlockProperties.size(); i++)
    o << std::setw(FieldWidth) << BlockProperties.Names[i];
  o << std::endl;
  o.setf(std::ios::right, std::ios::adjustfield);
}

addMainEstimator()

void addMainEstimator ( std::unique_ptr< ScalarEstimatorBase > &&  estimator )

private

Definition at line 551 of file EstimatorManagerNew.cpp.

References qmcplusplus::app_log(), and EstimatorManagerNew::main_estimator_.

Referenced by EstimatorManagerNew::createScalarEstimator(), EstimatorManagerNew::EstimatorManagerNew(), EstimatorManagerNew::put(), and EstimatorManagerNewTest::testReplaceMainEstimator().

{
  if (main_estimator_ != nullptr)
    app_log() << "  EstimatorManagerNew replaced its main estimator with " << estimator->getSubTypeStr()
              << " estimator." << std::endl;
  main_estimator_ = std::move(estimator);
}

addScalarEstimator()

int addScalarEstimator ( std::unique_ptr< ScalarEstimatorBase > &&  estimator )

private

add an Estimator

Parameters

[in]

estimator

New Estimator

Returns

index of newestimator

Definition at line 559 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::scalar_ests_.

Referenced by EstimatorManagerNewTest::fakeScalarSamplesAndCollect().

{
  scalar_ests_.push_back(std::move(estimator));
  return scalar_ests_.size() - 1;
}

areThereListeners()

bool areThereListeners

(

)

const

Do any of the instantiated estimators in operator_ests_ listen to per particle hamiltonian values? Listeners are lambda functions captured from crowd scope estimators and passed to QMCHamiltonian leaders.

Definition at line 58 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::operator_ests_.

Referenced by Crowd::Crowd().

{
  return std::any_of(operator_ests_.begin(), operator_ests_.end(),
                     [](auto& oper_est) { return oper_est->isListenerRequired(); });
}

collectMainEstimators()

void collectMainEstimators

(

const RefVector< ScalarEstimatorBase > &

scalar_estimators

)

At end of block collect the main scalar estimators for the entire rank.

One per crowd over multiple walkers

Definition at line 264 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::AverageCache, and Vector< T, Alloc >::begin().

Referenced by EstimatorManagerNewTest::collectMainEstimators(), and EstimatorManagerNewTest::testMakeBlockAverages().

{
  AverageCache = 0.0;
  for (ScalarEstimatorBase& est : main_estimators)
    est.addAccumulated(AverageCache.begin());
}

collectOperatorEstimators()

void collectOperatorEstimators

(

const std::vector< RefVector< OperatorEstBase >> &

op_ests

)

Reduces OperatorEstimator data from Crowds to the manager's OperatorEstimator data.

Parameters

[in]

op_ests

- vector of each crowds vector of references to their OperatorEstimators.

A particular OperatorEstimators reduction via a call to collect may be straight forward if the crowd context OperatorEstimator holds a copy of the estimator data structure or more complex if it just collects for instance a list of writes to locations in the data structure.

Definition at line 287 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::operator_ests_.

{
  for (int iop = 0; iop < operator_ests_.size(); ++iop)
  {
    RefVector<OperatorEstBase> this_op_est_for_all_crowds;
    for (int icrowd = 0; icrowd < crowd_op_ests.size(); ++icrowd)
      this_op_est_for_all_crowds.emplace_back(crowd_op_ests[icrowd][iop]);
    operator_ests_[iop]->collect(this_op_est_for_all_crowds);
  }
}

collectScalarEstimators()

void collectScalarEstimators

(

const std::vector< RefVector< ScalarEstimatorBase >> &

scalar_ests

)

Deals with possible free form scalar estimators.

Parameters

[in]

scalar_ests

- vector of each crowds vector of references to their OperatorEstimators. Still looking for actual use case.

Definition at line 271 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::AverageCache, Vector< T, Alloc >::begin(), and EstimatorManagerNew::scalar_ests_.

Referenced by EstimatorManagerNewTest::fakeScalarSamplesAndCollect().

{
  assert(crowd_scalar_ests[0].size() == scalar_ests_.size());
  for (int iop = 0; iop < scalar_ests_.size(); ++iop)
  {
    RefVector<ScalarEstimatorBase> this_scalar_est_for_all_crowds;
    for (int icrowd = 0; icrowd < crowd_scalar_ests.size(); ++icrowd)
      this_scalar_est_for_all_crowds.emplace_back(crowd_scalar_ests[icrowd][iop]);
    // There is actually state in each Scalar estimator that tells it what it's "first" index in the AverageCache
    // is, It's quite unclear to me if that would really work so I'm doing this in anticipation of having to rework that
    // if we don't drop multiple scalar estimators per crowd all together.
    for (ScalarEstimatorBase& est : this_scalar_est_for_all_crowds)
      est.addAccumulated(AverageCache.begin());
  }
}

createEstimator()

bool createEstimator ( EstimatorInput &  input, Args &&...  args  )

private

Construct estimator of type matching the underlying EstimatorInput type Consumer and push its its unique_ptr onto operator_ests_.

Definition at line 65 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::operator_ests_.

{
  if (has<EstInputType>(input))
  {
    operator_ests_.push_back(std::make_unique<typename EstInputType::Consumer>(std::move(std::get<EstInputType>(input)),
                                                                               std::forward<Args>(args)...));
    return true;
  }
  else
    return false;
}

createScalarEstimator()

bool createScalarEstimator ( ScalarEstimatorInput &  input, Args &&...  args  )

private

Construct scalar estimator of type matching the underlying ScalarEstimatorInput type Consumer and push its its unique_ptr onto operator_ests_.

Definition at line 78 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::addMainEstimator(), and EstimatorManagerNew::scalar_ests_.

{
  if (has<EstInputType>(input))
  {
    auto estimator = std::make_unique<typename EstInputType::Consumer>(std::move(std::get<EstInputType>(input)),
                                                                       std::forward<Args>(args)...);
    if (estimator->isMainEstimator())
      addMainEstimator(std::move(estimator));
    else
      scalar_ests_.push_back(std::move(estimator));
    return true;
  }
  else
    return false;
}

get_AverageCache()

auto& get_AverageCache ( )

inline

Definition at line 144 of file EstimatorManagerNew.h.

References EstimatorManagerNew::AverageCache.

Referenced by EstimatorManagerNewTest::fakeMainScalarSamples(), EstimatorManagerNewTest::fakeScalarSamplesAndCollect(), qmcplusplus::if(), and qmcplusplus::TEST_CASE().

{ return AverageCache; }

getApproximateEnergyVariance()

void getApproximateEnergyVariance	(	RealType &	e,
		RealType &	var
	)

get the average of per-block energy and variance of all the blocks Note: this is not weighted average.

It can be the same as weighted average only when block weights are identical.

Definition at line 437 of file EstimatorManagerNew.cpp.

References Communicate::bcast(), accumulator_set< T, typename >::count(), qmcplusplus::Units::charge::e, EstimatorManagerNew::energyAccumulator, EstimatorManagerNew::my_comm_, accumulator_set< T, typename >::result(), and EstimatorManagerNew::varAccumulator.

{
  RealType tmp[3];
  tmp[0] = energyAccumulator.count();
  tmp[1] = energyAccumulator.result();
  tmp[2] = varAccumulator.result();
  my_comm_->bcast(tmp, 3);
  e   = tmp[1] / tmp[0];
  var = tmp[2] / tmp[0] - e * e;
}

getNumEstimators()

std::size_t getNumEstimators ( )

inline

Definition at line 146 of file EstimatorManagerNew.h.

References EstimatorManagerNew::operator_ests_.

Referenced by qmcplusplus::TEST_CASE().

{ return operator_ests_.size(); }

getNumScalarEstimators()

std::size_t getNumScalarEstimators ( )

inline

Definition at line 147 of file EstimatorManagerNew.h.

References EstimatorManagerNew::scalar_ests_.

Referenced by qmcplusplus::TEST_CASE().

{ return scalar_ests_.size(); }

makeBlockAverages()

void makeBlockAverages ( unsigned long  accept, unsigned long  reject  )

private

collect data and write

Definition at line 298 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::acceptRatioInd, Communicate::allreduce(), EstimatorManagerNew::AverageCache, Vector< T, Alloc >::begin(), copy(), Vector< T, Alloc >::end(), EstimatorManagerNew::energyAccumulator, EstimatorManagerNew::my_comm_, EstimatorManagerNew::PropertyCache, Communicate::rank(), Communicate::size(), Vector< T, Alloc >::size(), EstimatorManagerNew::varAccumulator, and EstimatorManagerNew::weightInd.

Referenced by EstimatorManagerNew::stopBlock(), and EstimatorManagerNewTest::testMakeBlockAverages().

{
  // accumulate unsigned long counters over ranks.
  // Blocks ends are infrequent, two MPI transfers to preserve type
  // these could be replaced with a singple call MPI_struct_type some packing scheme or even
  // a pack into and out of an fp type that can be assured to hold the integral type exactly
  // IMHO they should not be primarily stored in a vector with magic indexes
  std::vector<unsigned long> accepts_and_rejects(my_comm_->size() * 2, 0);
  accepts_and_rejects[my_comm_->rank()]                    = accepts;
  accepts_and_rejects[my_comm_->size() + my_comm_->rank()] = rejects;
  my_comm_->allreduce(accepts_and_rejects);
  int64_t total_block_accept =
      std::accumulate(accepts_and_rejects.begin(), accepts_and_rejects.begin() + my_comm_->size(), int64_t(0));
  int64_t total_block_reject = std::accumulate(accepts_and_rejects.begin() + my_comm_->size(),
                                               accepts_and_rejects.begin() + my_comm_->size() * 2, int64_t(0));

  //Transfer FullPrecisionRead data
  const size_t n1 = AverageCache.size();
  const size_t n2 = n1 + PropertyCache.size();

  // This is a hack but it needs to be the correct size

  std::vector<double> reduce_buffer(n2, 0.0);
  {
    auto cur = reduce_buffer.begin();
    copy(AverageCache.begin(), AverageCache.end(), cur);
    copy(PropertyCache.begin(), PropertyCache.end(), cur + n1);
  }

  // This is necessary to use mpi3's C++ style reduce
#ifdef HAVE_MPI
  my_comm_->comm.reduce_in_place_n(reduce_buffer.begin(), reduce_buffer.size(), std::plus<>{});
#endif
  if (my_comm_->rank() == 0)
  {
    auto cur = reduce_buffer.begin();
    copy(cur, cur + n1, AverageCache.begin());
    copy(cur + n1, cur + n2, PropertyCache.begin());
    const RealType invTotWgt = 1.0 / PropertyCache[weightInd];
    AverageCache *= invTotWgt;
    //do not weight weightInd i.e. its index 0!
    for (int i = 1; i < PropertyCache.size(); i++)
      PropertyCache[i] *= invTotWgt;
  }

  // now we put the correct accept ratio in
  PropertyCache[acceptRatioInd] = static_cast<FullPrecRealType>(total_block_accept) /
      static_cast<FullPrecRealType>(total_block_accept + total_block_reject);

  //add the block average to summarize
  energyAccumulator(AverageCache[0]);
  varAccumulator(AverageCache[1]);
}

makeConfigReport()

void makeConfigReport ( std::ostream &  os ) const

private

Return a string with information about which estimators estimator manager is holding.

Definition at line 161 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::main_estimator_, EstimatorManagerNew::operator_ests_, and EstimatorManagerNew::scalar_ests_.

Referenced by EstimatorManagerNew::EstimatorManagerNew().

{
  os << "EstimatorManager setup for this section:\n"
     << "  Main Estimator:  " << main_estimator_->getSubTypeStr() << '\n';
  if (scalar_ests_.size() > 0)
  {
    os << "  ScalarEstimators:\n";
    for (auto& scalar_est : scalar_ests_)
      os << "    " << scalar_est->getSubTypeStr() << '\n';
  }
  if (operator_ests_.size() > 0)
  {
    os << "  General Estimators:\n";
    for (auto& est : operator_ests_)
      os << "    " << est->get_my_name() << '\n';
  }
}

put()

bool put	(	QMCHamiltonian &	H,
		const ParticleSet &	pset,
		const TrialWaveFunction &	twf,
		xmlNodePtr	cur
	)

process xml tag associated with estimators

Definition at line 448 of file EstimatorManagerNew.cpp.

References OhmmsAttributeSet::add(), EstimatorManagerNew::addMainEstimator(), qmcplusplus::app_log(), qmcplusplus::crowd, CrystalLattice< T, D >::explicitly_defined, SpinDensityInput::get_cell(), SpinDensityInput::get_save_memory(), EstimatorManagerNew::main_estimator_, EstimatorManagerNew::max4ascii, qmcplusplus::obdmi, EstimatorManagerNew::operator_ests_, qmcplusplus::pset, qmcplusplus::pset_target, OhmmsAttributeSet::put(), qmcplusplus::rank, QMCHamiltonian::sizeOfObservables(), and qmcplusplus::twf.

{
  std::vector<std::string> extra_types;
  std::vector<std::string> extra_names;
  cur = cur->children;
  std::string MainEstimatorName("LocalEnergy");
  while (cur != NULL)
  {
    std::string cname((const char*)(cur->name));
    if (cname == "estimator")
    {
      std::string est_type("none");
      std::string est_name(MainEstimatorName);
      std::string use_hdf5("yes");
      OhmmsAttributeSet hAttrib;
      hAttrib.add(est_type, "type");
      hAttrib.add(est_name, "name");
      hAttrib.add(use_hdf5, "hdf5");
      hAttrib.put(cur);
      if ((est_name == MainEstimatorName) || (est_name == "elocal"))
      {
        max4ascii = H.sizeOfObservables() + 3;
        addMainEstimator(std::make_unique<LocalEnergyEstimator>(H, use_hdf5 == "yes"));
      }
      else if (est_name == "RMC")
      {
        int nobs(20);
        OhmmsAttributeSet hAttrib;
        hAttrib.add(nobs, "nobs");
        hAttrib.put(cur);
        max4ascii = nobs * H.sizeOfObservables() + 3;
        addMainEstimator(std::make_unique<RMCLocalEnergyEstimator>(H, nobs));
      }
      else if (est_name == "CSLocalEnergy")
      {
        OhmmsAttributeSet hAttrib;
        int nPsi = 1;
        hAttrib.add(nPsi, "nPsi");
        hAttrib.put(cur);
        addMainEstimator(std::make_unique<CSEnergyEstimator>(H, nPsi));
        app_log() << "  Adding a CSLocalEnergy estimator for the MainEstimator " << std::endl;
      }
      else if (est_name == "SpinDensityNew")
      {
        SpinDensityInput spdi(cur);
        DataLocality dl = DataLocality::crowd;
        if (spdi.get_save_memory())
          dl = DataLocality::rank;
        if (spdi.get_cell().explicitly_defined)
          operator_ests_.emplace_back(std::make_unique<SpinDensityNew>(std::move(spdi), pset.getSpeciesSet(), dl));
        else
          operator_ests_.emplace_back(
              std::make_unique<SpinDensityNew>(std::move(spdi), pset.getLattice(), pset.getSpeciesSet(), dl));
      }
      else if (est_type == "MomentumDistribution")
      {
        MomentumDistributionInput mdi(cur);
        DataLocality dl = DataLocality::crowd;
        operator_ests_.emplace_back(std::make_unique<MomentumDistribution>(std::move(mdi), pset.getTotalNum(),
                                                                           pset.getTwist(), pset.getLattice(), dl));
      }
      else if (est_type == "OneBodyDensityMatrices")
      {
        OneBodyDensityMatricesInput obdmi(cur);
        // happens once insures golden particle set is not abused.
        ParticleSet pset_target(pset);
        operator_ests_.emplace_back(std::make_unique<OneBodyDensityMatrices>(std::move(obdmi), pset.getLattice(),
                                                                             pset.getSpeciesSet(), twf.getSPOMap(),
                                                                             pset_target));
      }
      else if (est_type == "MagnetizationDensity")
      {
        MagnetizationDensityInput magdensinput(cur);
        ParticleSet pset_target(pset);
        operator_ests_.emplace_back(std::make_unique<MagnetizationDensity>(std::move(magdensinput), pset.getLattice()));
      }
      else
      {
        extra_types.push_back(est_type);
        extra_names.push_back(est_name);
      }
    }
    cur = cur->next;
  }
  if (main_estimator_ == nullptr)
  {
    app_log() << " ::put Adding a default LocalEnergyEstimator for the MainEstimator " << std::endl;
    max4ascii = H.sizeOfObservables() + 3;
    addMainEstimator(std::make_unique<LocalEnergyEstimator>(H, true));
  }
  if (!extra_types.empty())
  {
    app_log() << "\nUnrecognized estimators in input:" << std::endl;
    for (int i = 0; i < extra_types.size(); i++)
    {
      app_log() << "  type: " << extra_types[i] << "     name: " << extra_names[i] << std::endl;
    }
    app_log() << std::endl;
    throw UniformCommunicateError("Unrecognized estimators encountered in input.  See log message for more details.");
  }
  return true;
}

reduceOperatorEstimators()

void reduceOperatorEstimators ( )

private

do the rank wise reduction of the OperatorEstimators

Why do this here?

1. Operator estimators don't know about the concurrency model
2. EstimatorManager owns the resources: send & receive buffers
3. The operation is generic as long as OperatorEstimator satisfies the requirement that get_data_ref() returns a reference to std::vector<RealType>

Implementation makes the assumption that sending each OperatorEstimator separately is the correct memory use vs. mpi message balance.

Definition at line 375 of file EstimatorManagerNew.cpp.

References qmcplusplus::convertUPtrToRefVector(), qmcplusplus::syclBLAS::copy_n(), EstimatorManagerNew::my_comm_, EstimatorManagerNew::operator_ests_, and Communicate::rank().

Referenced by EstimatorManagerNew::stopBlock(), and EstimatorManagerNewTest::testReduceOperatorEstimators().

{
  if (operator_ests_.size() > 0)
  {
    std::vector<size_t> operator_data_sizes(operator_ests_.size());
    RefVector<OperatorEstBase> ref_op_ests = convertUPtrToRefVector(operator_ests_);
    for (int iop = 0; iop < operator_data_sizes.size(); ++iop)
    {
      operator_data_sizes[iop] = operator_ests_[iop]->get_data().size();
    }
    // 1 larger because we put the weight in to avoid dependence of the Scalar estimators being reduced firt.
    size_t nops = *(std::max_element(operator_data_sizes.begin(), operator_data_sizes.end())) + 1;
    std::vector<RealType> operator_send_buffer;
    std::vector<RealType> operator_recv_buffer;
    operator_send_buffer.reserve(nops);
    operator_recv_buffer.reserve(nops);
    for (int iop = 0; iop < operator_ests_.size(); ++iop)
    {
      auto& estimator      = *operator_ests_[iop];
      auto& data           = estimator.get_data();
      size_t adjusted_size = data.size() + 1;
      operator_send_buffer.resize(adjusted_size, 0.0);
      operator_recv_buffer.resize(adjusted_size, 0.0);
      std::copy_n(data.begin(), data.size(), operator_send_buffer.begin());
      operator_send_buffer[data.size()] = estimator.get_walkers_weight();
      // This is necessary to use mpi3's C++ style reduce
#ifdef HAVE_MPI
      my_comm_->comm.reduce_n(operator_send_buffer.begin(), adjusted_size, operator_recv_buffer.begin(), std::plus<>{},
                              0);
#else
      operator_recv_buffer = operator_send_buffer;
#endif
      if (my_comm_->rank() == 0)
      {
        std::copy_n(operator_recv_buffer.begin(), data.size(), data.begin());
        size_t reduced_walker_weights = operator_recv_buffer[data.size()];
        RealType invTotWgt            = 1.0 / static_cast<QMCT::RealType>(reduced_walker_weights);
        operator_ests_[iop]->normalize(invTotWgt);
      }
    }
  }
}

reset()

void reset ( )

private

reset the estimator

reset names of the properties

Todo:

this should be in in constructor object shouldn't be reused Warning this is different from some "resets" in the code, it does not clear the object

The number of estimators and their order can vary from the previous state. reinitialized properties before setting up a new BlockAverage data list.

The object is still not completely valid.

Definition at line 144 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::acceptRatioInd, RecordNamedProperty< T >::add(), EstimatorManagerNew::BlockAverages, EstimatorManagerNew::BlockProperties, RecordNamedProperty< T >::clear(), EstimatorManagerNew::cpuInd, EstimatorManagerNew::main_estimator_, EstimatorManagerNew::max4ascii, EstimatorManagerNew::scalar_ests_, RecordNamedProperty< T >::size(), and EstimatorManagerNew::weightInd.

Referenced by EstimatorManagerNew::startDriverRun().

{
  //It's essential that this one is first, other code assumes weightInd always == 0
  weightInd = BlockProperties.add("BlockWeight");
  assert(weightInd == 0);
  cpuInd         = BlockProperties.add("BlockCPU");
  acceptRatioInd = BlockProperties.add("AcceptRatio");
  BlockAverages.clear(); //cleaup the records
  // Side effect of this is that BlockAverages becomes size to number of scalar values tracked by all the
  // scalar estimators
  main_estimator_->add2Record(BlockAverages);
  for (int i = 0; i < scalar_ests_.size(); i++)
    scalar_ests_[i]->add2Record(BlockAverages);
  // possibly redundant variable
  max4ascii += BlockAverages.size();
}

startBlock()

void startBlock

(

int

steps

)

start a block

Parameters

steps

number of steps in a block

Definition at line 244 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::block_timer_, and Timer::restart().

{ block_timer_.restart(); }

startDriverRun()

void startDriverRun

(

)

Start the manager at the beginning of a driver run().

Open files. Setting zeros.

Parameters

blocks	number of blocks
record	if true, will write to a file

Replace reportHeader and reset functon.

Todo:

clean up this method its a mess

Definition at line 199 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::addHeader(), EstimatorManagerNew::Archive, EstimatorManagerNew::AverageCache, EstimatorManagerNew::BlockAverages, EstimatorManagerNew::BlockProperties, accumulator_set< T, typename >::clear(), EstimatorManagerNew::DebugArchive, EstimatorManagerNew::energyAccumulator, Communicate::getName(), EstimatorManagerNew::h5desc, EstimatorManagerNew::h_file, EstimatorManagerNew::main_estimator_, EstimatorManagerNew::my_comm_, EstimatorManagerNew::operator_ests_, EstimatorManagerNew::PropertyCache, Communicate::rank(), EstimatorManagerNew::RecordCount, EstimatorManagerNew::reset(), Vector< T, Alloc >::resize(), EstimatorManagerNew::scalar_ests_, RecordNamedProperty< T >::setValues(), RecordNamedProperty< T >::size(), and EstimatorManagerNew::varAccumulator.

{
  reset();
  RecordCount = 0;
  energyAccumulator.clear();
  varAccumulator.clear();
  BlockAverages.setValues(0.0);
  AverageCache.resize(BlockAverages.size());
  PropertyCache.resize(BlockProperties.size());
  // Now Estimatormanager New is actually valid i.e. in the state you would expect after the constructor.
  // Until the put is dropped this isn't feasible to fix.
#if defined(DEBUG_ESTIMATOR_ARCHIVE)
  if (!DebugArchive)
  {
    std::array<char, 128> fname;
    if (std::snprintf(fname.data(), fname.size(), "%s.p%03d.scalar.dat", my_comm_->getName().c_str(),
                      my_comm_->rank()) < 0)
      throw std::runtime_error("Error generating filename");
    DebugArchive = std::make_unique<std::ofstream>(fname.data());
    addHeader(*DebugArchive);
  }
#endif
  if (my_comm_->rank() == 0)
  {
    std::filesystem::path fname(my_comm_->getName());
    fname.concat(".scalar.dat");
    Archive = std::make_unique<std::ofstream>(fname);
    addHeader(*Archive);
    if (h5desc.size())
    {
      h5desc.clear();
    }
    fname  = my_comm_->getName() + ".stat.h5";
    h_file = std::make_unique<hdf_archive>();
    h_file->create(fname);
    main_estimator_->registerObservables(h5desc, *h_file);
    for (int i = 0; i < scalar_ests_.size(); i++)
      scalar_ests_[i]->registerObservables(h5desc, *h_file);
    for (auto& uope : operator_ests_)
      uope->registerOperatorEstimator(*h_file);
  }
}

stopBlock()

void stopBlock	(	unsigned long	accept,
		unsigned long	reject,
		RealType	block_weight
	)

unified: stop a block

Parameters

	accept	acceptance rate of this block
[in]	accept
[in]	reject
[in]	block_weight

Definition at line 246 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::block_timer_, EstimatorManagerNew::cpuInd, Timer::elapsed(), EstimatorManagerNew::makeBlockAverages(), EstimatorManagerNew::PropertyCache, EstimatorManagerNew::RecordCount, EstimatorManagerNew::reduceOperatorEstimators(), EstimatorManagerNew::weightInd, EstimatorManagerNew::writeOperatorEstimators(), EstimatorManagerNew::writeScalarH5(), and EstimatorManagerNew::zeroOperatorEstimators().

{
  /* Need a redesign of how accept, reject and block_weight are handled from driver to this manager.
   * DMC needs to add non-local move counters.
   * also need to add num_samples which differs from block_weight
   */
  //take block averages and update properties per block
  PropertyCache[weightInd] = block_weight;
  makeBlockAverages(accept, reject);
  reduceOperatorEstimators();
  writeOperatorEstimators();
  zeroOperatorEstimators();
  // intentionally put after all the estimator I/O
  PropertyCache[cpuInd] = block_timer_.elapsed();
  writeScalarH5();
  RecordCount++;
}

stopDriverRun()

void stopDriverRun

(

)

Stop the manager at the end of a driver run().

Flush/close files.

Definition at line 242 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::h_file.

{ h_file.reset(); }

writeOperatorEstimators()

void writeOperatorEstimators ( )

private

Write OperatorEstimator data to *.stat.h5.

Note that OperatorEstimator owns its own observable_helpers

Definition at line 418 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::h_file, EstimatorManagerNew::my_comm_, EstimatorManagerNew::operator_ests_, and Communicate::rank().

Referenced by EstimatorManagerNew::stopBlock().

{
  if (my_comm_->rank() == 0)
  {
    if (h_file)
    {
      for (auto& op_est : operator_ests_)
        op_est->write(*h_file);
      h_file->flush();
    }
  }
}

writeScalarH5()

void writeScalarH5 ( )

private

write scalars to scalar.dat and h5

Definition at line 352 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::Archive, EstimatorManagerNew::AverageCache, EstimatorManagerNew::BlockAverages, Vector< T, Alloc >::data(), EstimatorManagerNew::FieldWidth, EstimatorManagerNew::h5desc, EstimatorManagerNew::h_file, EstimatorManagerNew::max4ascii, omptarget::min(), EstimatorManagerNew::PropertyCache, EstimatorManagerNew::RecordCount, Vector< T, Alloc >::size(), and RecordNamedProperty< T >::size().

Referenced by EstimatorManagerNew::stopBlock().

{
  //Do not assume h_file is valid
  if (h_file)
  {
    for (int o = 0; o < h5desc.size(); ++o)
      // cheating here, remove SquaredAverageCache from API
      h5desc[o].write(AverageCache.data(), *h_file);
    h_file->flush();
  }

  if (Archive)
  {
    *Archive << std::setw(10) << RecordCount;
    int maxobjs = std::min(BlockAverages.size(), max4ascii);
    for (int j = 0; j < maxobjs; j++)
      *Archive << std::setw(FieldWidth) << AverageCache[j];
    for (int j = 0; j < PropertyCache.size(); j++)
      *Archive << std::setw(FieldWidth) << PropertyCache[j];
    *Archive << std::endl;
  }
}

zeroOperatorEstimators()

void zeroOperatorEstimators ( )

private

OperatorEstimators need to be zeroed out after the block is finished.

Definition at line 431 of file EstimatorManagerNew.cpp.

References EstimatorManagerNew::operator_ests_.

Referenced by EstimatorManagerNew::stopBlock().

{
  for (auto& op_est : operator_ests_)
    op_est->zero();
}

Friends And Related Function Documentation

EstimatorManagerCrowd

friend class EstimatorManagerCrowd

friend

Definition at line 276 of file EstimatorManagerNew.h.

qmcplusplus::testing::EstimatorManagerNewTest

friend class qmcplusplus::testing::EstimatorManagerNewTest

friend

Definition at line 277 of file EstimatorManagerNew.h.

qmcplusplus::testing::EstimatorManagerNewTestAccess

friend class qmcplusplus::testing::EstimatorManagerNewTestAccess

friend

Definition at line 278 of file EstimatorManagerNew.h.

Member Data Documentation

acceptRatioInd

int acceptRatioInd

private

index for the accept counter PropertyCache(acceptInd)

Definition at line 222 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::makeBlockAverages(), EstimatorManagerNew::reset(), and EstimatorManagerNewTest::testMakeBlockAverages().

Archive

std::unique_ptr<std::ofstream> Archive

private

file handler to write data

Definition at line 226 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::startDriverRun(), and EstimatorManagerNew::writeScalarH5().

AverageCache

Vector<RealType> AverageCache

private

cached block averages of the values

Definition at line 240 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::collectMainEstimators(), EstimatorManagerNew::collectScalarEstimators(), EstimatorManagerNew::get_AverageCache(), EstimatorManagerNew::makeBlockAverages(), EstimatorManagerNew::startDriverRun(), and EstimatorManagerNew::writeScalarH5().

block_timer_

Timer block_timer_

private

block timer

Definition at line 265 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::startBlock(), and EstimatorManagerNew::stopBlock().

BlockAverages

RecordNamedProperty<RealType> BlockAverages

private

manager of scalar data

Definition at line 244 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::addHeader(), EstimatorManagerNew::reset(), EstimatorManagerNew::startDriverRun(), and EstimatorManagerNew::writeScalarH5().

BlockProperties

RecordNamedProperty<RealType> BlockProperties

private

manager of property data

Definition at line 246 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::addHeader(), EstimatorManagerNew::reset(), EstimatorManagerNew::startDriverRun(), and EstimatorManagerNewTest::testMakeBlockAverages().

cpuInd

int cpuInd

private

index for the block cpu PropertyCache(cpuInd)

Definition at line 220 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::reset(), EstimatorManagerNew::stopBlock(), and EstimatorManagerNewTest::testMakeBlockAverages().

DebugArchive

std::unique_ptr<std::ofstream> DebugArchive

private

file handler to write data for debugging

Definition at line 228 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::startDriverRun().

energyAccumulator

ScalarEstimatorBase::accumulator_type energyAccumulator

private

accumulator for the energy

Todo:

expand it for all the scalar observables to report the final results

Definition at line 235 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::getApproximateEnergyVariance(), EstimatorManagerNew::makeBlockAverages(), and EstimatorManagerNew::startDriverRun().

error_tag_

constexpr std::string_view error_tag_ {"EstimatorManagerNew "}

staticprivate

Definition at line 274 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::EstimatorManagerNew().

FieldWidth

size_t FieldWidth

private

Definition at line 272 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::addHeader(), and EstimatorManagerNew::writeScalarH5().

h5desc

std::vector<ObservableHelper> h5desc

private

convenient descriptors for hdf5

Definition at line 254 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::startDriverRun(), and EstimatorManagerNew::writeScalarH5().

h_file

std::unique_ptr<hdf_archive> h_file

private

hdf5 handler

Definition at line 224 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::startDriverRun(), EstimatorManagerNew::stopDriverRun(), EstimatorManagerNew::writeOperatorEstimators(), and EstimatorManagerNew::writeScalarH5().

main_estimator_

UPtr<ScalarEstimatorBase> main_estimator_

private

main estimator i.e. some version of a local energy estimator.

Definition at line 248 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::addMainEstimator(), EstimatorManagerCrowd::EstimatorManagerCrowd(), EstimatorManagerNew::EstimatorManagerNew(), EstimatorManagerNewTestAccess::getMainEstimator(), EstimatorManagerNew::makeConfigReport(), EstimatorManagerNew::put(), EstimatorManagerNew::reset(), EstimatorManagerNew::startDriverRun(), and EstimatorManagerNewTest::testReplaceMainEstimator().

max4ascii

int max4ascii

private

number of maximum data for a scalar.dat

Definition at line 268 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::addHeader(), EstimatorManagerNew::EstimatorManagerNew(), EstimatorManagerNew::put(), EstimatorManagerNew::reset(), and EstimatorManagerNew::writeScalarH5().

my_comm_

Communicate* my_comm_

private

communicator to handle communication

Definition at line 230 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::EstimatorManagerNew(), EstimatorManagerNew::getApproximateEnergyVariance(), EstimatorManagerNew::makeBlockAverages(), EstimatorManagerNew::reduceOperatorEstimators(), EstimatorManagerNew::startDriverRun(), EstimatorManagerNewTest::testMakeBlockAverages(), and EstimatorManagerNew::writeOperatorEstimators().

operator_ests_

std::vector<std::unique_ptr<OperatorEstBase> > operator_ests_

private

OperatorEst Observables.

since the operator estimators are also a close set at compile time they could be treated just like the inputs. However the idea of a shared interface is much more straight forward for them.

Definition at line 262 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::areThereListeners(), EstimatorManagerNew::collectOperatorEstimators(), EstimatorManagerNew::createEstimator(), EstimatorManagerCrowd::EstimatorManagerCrowd(), EstimatorManagerNewTest::fakeSomeOperatorEstimatorSamples(), EstimatorManagerNewTest::get_operator_data(), EstimatorManagerNew::getNumEstimators(), EstimatorManagerNew::makeConfigReport(), EstimatorManagerNew::put(), EstimatorManagerNew::reduceOperatorEstimators(), EstimatorManagerNew::startDriverRun(), EstimatorManagerNew::writeOperatorEstimators(), and EstimatorManagerNew::zeroOperatorEstimators().

PropertyCache

Vector<RealType> PropertyCache

private

cached block averages of properties, e.g. BlockCPU

Definition at line 242 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::makeBlockAverages(), EstimatorManagerNew::startDriverRun(), EstimatorManagerNew::stopBlock(), EstimatorManagerNewTest::testMakeBlockAverages(), and EstimatorManagerNew::writeScalarH5().

RecordCount

int RecordCount

private

number of records in a block

Definition at line 216 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::startDriverRun(), EstimatorManagerNew::stopBlock(), and EstimatorManagerNew::writeScalarH5().

scalar_ests_

std::vector<UPtr<ScalarEstimatorBase> > scalar_ests_

private

non main scalar estimators collecting simple scalars, are there any? with the removal of collectables these don't seem used or needed.

Definition at line 252 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::addScalarEstimator(), EstimatorManagerNew::collectScalarEstimators(), EstimatorManagerNew::createScalarEstimator(), EstimatorManagerCrowd::EstimatorManagerCrowd(), EstimatorManagerNew::getNumScalarEstimators(), EstimatorManagerNew::makeConfigReport(), EstimatorManagerNew::reset(), and EstimatorManagerNew::startDriverRun().

varAccumulator

ScalarEstimatorBase::accumulator_type varAccumulator

private

accumulator for the variance

Definition at line 237 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::getApproximateEnergyVariance(), EstimatorManagerNew::makeBlockAverages(), and EstimatorManagerNew::startDriverRun().

weightInd

int weightInd

private

index for the block weight PropertyCache(weightInd)

Definition at line 218 of file EstimatorManagerNew.h.

Referenced by EstimatorManagerNew::makeBlockAverages(), EstimatorManagerNew::reset(), EstimatorManagerNew::stopBlock(), and EstimatorManagerNewTest::testMakeBlockAverages().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Estimators/EstimatorManagerNew.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Estimators/EstimatorManagerNew.cpp