WalkerLogManager Class Reference

Driver-level resource for walker log collection. More...

Collaboration diagram for WalkerLogManager:

Public Member Functions
	WalkerLogManager (WalkerLogInput &inp, bool allow_logs, std::string series_root, Communicate *comm=0)
std::unique_ptr< WalkerLogCollector >	makeCollector () const
	create a WalkerLogCollector More...
void	startRun (RefVector< WalkerLogCollector > &&collectors)
	open the logs file and check consistency of the collectors at the start of a run More...
void	stopRun ()
	close the logs file at the end of a run More...
void	writeBuffers ()
	collect min/max/median walker data and write buffered walker log data to file More...

Private Member Functions
void	checkCollectors (const RefVector< WalkerLogCollector > &collectors) const
	check consistency of walker buffer row sizes More...
void	openFile (const RefVector< WalkerLogCollector > &collectors)
	open the logs file More...
void	closeFile ()
	close the logs file More...
void	openHDFFile (const RefVector< WalkerLogCollector > &collectors)
	open the logs file (HDF format) More...
void	writeBuffersHDF ()
	write data buffers to the logs file (HDF format) More...
void	closeHDFFile ()
	close the logs file (HDF format) More...

Private Attributes
std::string	file_root
	file prefix for the current driver More...
Communicate *	communicator
WalkerLogState	state
	output state More...
std::unique_ptr< hdf_archive >	hdf_file
	access to HDF file More...
bool	registered_hdf
	whether walker quantity data ("data_layout") has been recorded in HDF More...
bool	write_particle_data
	whether to write per-particle data for all walkers More...
bool	write_min_data
	whether to write full data for the minimum energy walker at each step More...
bool	write_max_data
	whether to write full data for the maximum energy walker at each step More...
bool	write_med_data
	whether to write full data for the median energy walker at each step More...
std::vector< std::tuple< size_t, WLog::Real, size_t, size_t > >	energy_order
	used to sort energy information for identifying walkers by energy quantile More...
WalkerLogBuffer< WLog::Int >	wmin_property_int_buffer
	buffer containing integer properties for the minimum energy walkers More...
WalkerLogBuffer< WLog::Real >	wmin_property_real_buffer
	buffer containing real-valued properties for the minimum energy walkers More...
WalkerLogBuffer< WLog::Real >	wmin_particle_real_buffer
	buffer containing per-particle properties for the minimum energy walkers More...
WalkerLogBuffer< WLog::Int >	wmax_property_int_buffer
	buffer containing integer properties for the maximum energy walkers More...
WalkerLogBuffer< WLog::Real >	wmax_property_real_buffer
	buffer containing real-valued properties for the maximum energy walkers More...
WalkerLogBuffer< WLog::Real >	wmax_particle_real_buffer
	buffer containing per-particle properties for the maximum energy walkers More...
WalkerLogBuffer< WLog::Int >	wmed_property_int_buffer
	buffer containing integer properties for the median energy walkers More...
WalkerLogBuffer< WLog::Real >	wmed_property_real_buffer
	buffer containing real-valued properties for the median energy walkers More...
WalkerLogBuffer< WLog::Real >	wmed_particle_real_buffer
	buffer containing per-particle properties for the median energy walkers More...
RefVector< WalkerLogCollector >	collectors_in_run_

Detailed Description

Driver-level resource for walker log collection.

This class manages the HDF file (open/close/write). Walker buffer data from all crowd-level WalkerLogCollectors are written to the HDF file at the end of each MC block.

Just prior to the write, this class examines the distribution of walker energies on its rank for each MC step in the MC block, identifies the minimum/maximum/median energy walkers and buffers their full data (including per-particle information) for the write. This data corresponds to walker information at specific quantiles of the energy distribution. See WalkerLogManager::writeBuffers()

Writing per-particle information for all walkers is optional, as is writing data for the minimum/maximum/median energy walkers. Scalar "property" data for each walker is always written.

Definition at line 44 of file WalkerLogManager.h.

Constructor & Destructor Documentation

WalkerLogManager()

WalkerLogManager	(	WalkerLogInput &	inp,
		bool	allow_logs,
		std::string	series_root,
		Communicate *	comm = 0
	)

Definition at line 21 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), qmcplusplus::comm, WalkerLogManager::communicator, WalkerLogManager::file_root, InputSection::get(), qmcplusplus::Concurrency::getWorkerId(), WalkerLogBuffer< T >::label, WalkerLogState::logs_active, WalkerLogInput::present, WalkerLogManager::registered_hdf, WalkerLogManager::state, WalkerLogState::step_period, WalkerLogState::verbose, WalkerLogManager::wmax_particle_real_buffer, WalkerLogManager::wmax_property_int_buffer, WalkerLogManager::wmax_property_real_buffer, WalkerLogManager::wmed_particle_real_buffer, WalkerLogManager::wmed_property_int_buffer, WalkerLogManager::wmed_property_real_buffer, WalkerLogManager::wmin_particle_real_buffer, WalkerLogManager::wmin_property_int_buffer, WalkerLogManager::wmin_property_real_buffer, WalkerLogManager::write_max_data, WalkerLogManager::write_med_data, WalkerLogManager::write_min_data, and WalkerLogManager::write_particle_data.

{
  communicator            = comm;
  file_root               = series_root;
  bool driver_allows_logs = allow_logs; // driver allows logs or not

  bool logs_requested = inp.present; // xml input present or not
  // determine whether walker logs will be active
  state.logs_active = logs_requested && driver_allows_logs;

  if (state.logs_active)
  {
    if (Concurrency::getWorkerId() == 0)
    {
      app_log() << "\n  WalkerLogManager::put() " << std::endl;
      app_log() << "    logs requested      : " << logs_requested << std::endl;
      app_log() << "    driver allows logs  : " << driver_allows_logs << std::endl;
      app_log() << "    logs active         : " << state.logs_active << std::endl;
      app_log() << std::endl;
    }
    // retrieve input data
    state.step_period   = inp.get<int>("step_period");
    state.verbose       = inp.get<bool>("verbose");
    bool quantiles      = inp.get<bool>("quantiles");
    write_particle_data = inp.get<bool>("particle");
    write_min_data      = inp.get<bool>("min") && quantiles;
    write_max_data      = inp.get<bool>("max") && quantiles;
    write_med_data      = inp.get<bool>("median") && quantiles;
  }

  // label min energy walker buffers for HDF file write
  wmin_property_int_buffer.label  = "wmin_property_int";
  wmin_property_real_buffer.label = "wmin_property_real";
  wmin_particle_real_buffer.label = "wmin_particle_real";

  // label max energy walker buffers for HDF file write
  wmax_property_int_buffer.label  = "wmax_property_int";
  wmax_property_real_buffer.label = "wmax_property_real";
  wmax_particle_real_buffer.label = "wmax_particle_real";

  // label median energy walker buffers for HDF file write
  wmed_property_int_buffer.label  = "wmed_property_int";
  wmed_property_real_buffer.label = "wmed_property_real";
  wmed_particle_real_buffer.label = "wmed_particle_real";

  // walker quantity information ("data_layout") has not be put in the HDF file yet
  registered_hdf = false;
}

Member Function Documentation

checkCollectors()

void checkCollectors ( const RefVector< WalkerLogCollector > &  collectors ) const

private

check consistency of walker buffer row sizes

Definition at line 212 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogBuffer< T >::sameAs(), WalkerLogManager::state, WalkerLogState::verbose, WalkerLogCollector::walker_particle_real_buffer, WalkerLogCollector::walker_property_int_buffer, and WalkerLogCollector::walker_property_real_buffer.

Referenced by WalkerLogManager::startRun().

{
  if (state.verbose)
    app_log() << "WalkerLogManager::checkCollectors" << std::endl;
  if (collectors.size() > 0)
  {
    bool all_same           = true;
    WalkerLogCollector& ref = collectors[0];
    for (int i = 0; i < collectors.size(); ++i)
    {
      WalkerLogCollector& tc = collectors[i];
      all_same &= tc.walker_property_int_buffer.sameAs(ref.walker_property_int_buffer);
      all_same &= tc.walker_property_real_buffer.sameAs(ref.walker_property_real_buffer);
      all_same &= tc.walker_particle_real_buffer.sameAs(ref.walker_particle_real_buffer);
    }
    if (!all_same)
    {
      throw std::runtime_error(
          "WalkerLogManager::checkCollectors  log buffer widths of collectors do not match\n  contiguous write is "
          "impossible\n  this was first caused by collectors contributing array logs from identical, but "
          "differently named, particlesets such as e, e2, e3 ... (fixed)\n  please check the WalkerLogManager "
          "summaries printed above");
    }
  }
}

closeFile()

void closeFile ( )

private

close the logs file

Definition at line 247 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogManager::closeHDFFile(), WalkerLogManager::state, and WalkerLogState::verbose.

Referenced by WalkerLogManager::stopRun().

{
  if (state.verbose)
    app_log() << "WalkerLogManager::closeFile " << std::endl;
  closeHDFFile();
}

closeHDFFile()

void closeHDFFile ( )

private

close the logs file (HDF format)

Definition at line 355 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogManager::hdf_file, WalkerLogManager::state, and WalkerLogState::verbose.

Referenced by WalkerLogManager::closeFile().

{
  if (state.verbose)
    app_log() << "WalkerLogManager::closeHDFFile " << std::endl;
  hdf_file.reset();
}

makeCollector()

std::unique_ptr< WalkerLogCollector > makeCollector

(

)

const

create a WalkerLogCollector

Definition at line 71 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogManager::state, and WalkerLogState::verbose.

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

{
  if (state.verbose)
    app_log() << "WalkerLogManager::makeCollector " << std::endl;
  return std::make_unique<WalkerLogCollector>(state);
}

openFile()

void openFile ( const RefVector< WalkerLogCollector > &  collectors )

private

open the logs file

Definition at line 239 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogManager::openHDFFile(), WalkerLogManager::state, and WalkerLogState::verbose.

Referenced by WalkerLogManager::startRun().

{
  if (state.verbose)
    app_log() << "WalkerLogManager::openFile " << std::endl;
  openHDFFile(collectors);
}

openHDFFile()

void openHDFFile ( const RefVector< WalkerLogCollector > &  collectors )

private

open the logs file (HDF format)

Definition at line 255 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogManager::communicator, WalkerLogManager::file_root, WalkerLogManager::hdf_file, qmcplusplus::rank, Communicate::rank(), Communicate::size(), WalkerLogManager::state, and WalkerLogState::verbose.

Referenced by WalkerLogManager::openFile().

{
  if (state.verbose)
    app_log() << "WalkerLogManager::openHDFFile " << std::endl;
  if (collectors.size() == 0)
    throw std::runtime_error("WalkerLogManager::openHDFFile  no log collectors exist, cannot open file");
  // each rank opens a wlogs.h5 file
  int nprocs = communicator->size();
  int rank   = communicator->rank();
  std::array<char, 32> ptoken;
  std::string file_name = file_root;
  if (nprocs > 1)
  { // extend the file name to include processor/rank information
    int length{0};
    if (nprocs > 10000)
      length = std::snprintf(ptoken.data(), ptoken.size(), ".p%05d", rank);
    else if (nprocs > 1000)
      length = std::snprintf(ptoken.data(), ptoken.size(), ".p%04d", rank);
    else
      length = std::snprintf(ptoken.data(), ptoken.size(), ".p%03d", rank);
    if (length < 0)
      throw std::runtime_error("Error generating filename");
    file_name.append(ptoken.data(), length);
  }
  file_name += ".wlogs.h5";
  if (state.verbose)
    app_log() << "WalkerLogManager::openHDFFile  opening logs hdf file " << file_name << std::endl;
  // create the hdf archive
  hdf_file = std::make_unique<hdf_archive>();
  // open the file
  bool successful = hdf_file->create(file_name);
  if (!successful)
    throw std::runtime_error("WalkerLogManager::openHDFFile  failed to open hdf file " + file_name);
}

startRun()

void startRun

(

RefVector< WalkerLogCollector > &&

collectors

)

open the logs file and check consistency of the collectors at the start of a run

Definition at line 79 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogManager::checkCollectors(), WalkerLogManager::collectors_in_run_, WalkerLogState::logs_active, WalkerLogManager::openFile(), WalkerLogManager::state, and WalkerLogState::verbose.

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

{
  collectors_in_run_ = std::move(collectors);
  if (!state.logs_active)
    return; // no-op for driver if logs are inactive
  if (collectors_in_run_.empty())
    throw std::runtime_error("BUG collectors are empty but walker logs are active");
  if (state.verbose)
    app_log() << "WalkerLogManager::startRun " << std::endl;
  // check data size consistency among the log collector buffers
  checkCollectors(collectors_in_run_);
  // open the logs file
  openFile(collectors_in_run_);
}

stopRun()

void stopRun

(

)

close the logs file at the end of a run

Definition at line 95 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogManager::closeFile(), WalkerLogManager::collectors_in_run_, WalkerLogState::logs_active, WalkerLogManager::state, and WalkerLogState::verbose.

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

{
  if (!state.logs_active)
    return; // no-op for driver if logs are inactive
  if (state.verbose)
    app_log() << "WalkerLogManager::stopRun " << std::endl;
  collectors_in_run_.clear();
  // close the logs file
  closeFile();
}

writeBuffers()

void writeBuffers

(

)

collect min/max/median walker data and write buffered walker log data to file

Definition at line 107 of file WalkerLogManager.cpp.

References WalkerLogBuffer< T >::addRow(), qmcplusplus::app_log(), WalkerLogCollector::checkBuffers(), WalkerLogManager::collectors_in_run_, WalkerLogCollector::energies, WalkerLogManager::energy_order, WalkerLogState::logs_active, qmcplusplus::n, WalkerLogBuffer< T >::resetBuffer(), WalkerLogManager::state, WalkerLogCollector::steps, WalkerLogState::verbose, WalkerLogManager::wmax_particle_real_buffer, WalkerLogManager::wmax_property_int_buffer, WalkerLogManager::wmax_property_real_buffer, WalkerLogManager::wmed_particle_real_buffer, WalkerLogManager::wmed_property_int_buffer, WalkerLogManager::wmed_property_real_buffer, WalkerLogManager::wmin_particle_real_buffer, WalkerLogManager::wmin_property_int_buffer, WalkerLogManager::wmin_property_real_buffer, WalkerLogManager::write_max_data, WalkerLogManager::write_med_data, WalkerLogManager::write_min_data, and WalkerLogManager::writeBuffersHDF().

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

{
  const RefVector<WalkerLogCollector>& collectors = collectors_in_run_;
  if (!state.logs_active)
    return; // no-op for driver if logs are inactive
  if (state.verbose)
    app_log() << "WalkerLogManager::writeBuffers " << std::endl;

  if (write_min_data)
  { // resize min energy walker buffers to zero rows
    wmin_property_int_buffer.resetBuffer();
    wmin_property_real_buffer.resetBuffer();
    wmin_particle_real_buffer.resetBuffer();
  }
  if (write_max_data)
  { // resize max energy walker buffers to zero rows
    wmax_property_int_buffer.resetBuffer();
    wmax_property_real_buffer.resetBuffer();
    wmax_particle_real_buffer.resetBuffer();
  }
  if (write_med_data)
  { // resize median energy walker buffers to zero rows
    wmed_property_int_buffer.resetBuffer();
    wmed_property_real_buffer.resetBuffer();
    wmed_particle_real_buffer.resetBuffer();
  }

  // collect energy information and extract info from min/max/median energy walkers
  if (write_min_data || write_max_data || write_med_data)
  {
    // gather per energy and step data for all walker throughout the MC block
    for (size_t c = 0; c < collectors.size(); ++c)
    {
      WalkerLogCollector& tc = collectors[c];
      tc.checkBuffers();
      for (size_t r = 0; r < tc.energies.size(); ++r)
        energy_order.push_back(std::make_tuple(tc.steps[r], tc.energies[r], c, r));
    }
    // sort the data by step and energy to enable selection of min/max/median energy walker data
    std::sort(energy_order.begin(), energy_order.end());
    // select out the min/max/median energy walker data and store in rank-level buffers
    size_t n = 0;
    size_t n1, n2;
    size_t prev_step;
    for (auto& v : energy_order)
    {
      auto step = std::get<0>(v);
      if (n == 0)
      {
        n1        = n;
        prev_step = step;
      }
      if (step != prev_step || n == energy_order.size() - 1)
      {
        // for a given step, find data for min/max/median energy walkers
        //   n1/n2 are indices of the first/last data in energy_order for this step
        if (step != prev_step)
          n2 = n - 1;
        if (n == energy_order.size() - 1)
          n2 = n;
        auto nmin = n1;            // index of minimum energy walker for this step
        auto nmax = n2;            // index of maximum energy walker for this step
        auto nmed = (n1 + n2) / 2; // index of median  energy walker for this step
        size_t c, r;
        if (write_min_data)
        { //  cache data for minimum energy walker
          c                      = std::get<2>(energy_order[nmin]);
          r                      = std::get<3>(energy_order[nmin]);
          WalkerLogCollector& tc = collectors[c];
          wmin_property_int_buffer.addRow(tc.walker_property_int_buffer, r);
          wmin_property_real_buffer.addRow(tc.walker_property_real_buffer, r);
          wmin_particle_real_buffer.addRow(tc.walker_particle_real_buffer, r);
        }
        if (write_max_data)
        { //  cache data for maximum energy walker
          c                      = std::get<2>(energy_order[nmax]);
          r                      = std::get<3>(energy_order[nmax]);
          WalkerLogCollector& tc = collectors[c];
          wmax_property_int_buffer.addRow(tc.walker_property_int_buffer, r);
          wmax_property_real_buffer.addRow(tc.walker_property_real_buffer, r);
          wmax_particle_real_buffer.addRow(tc.walker_particle_real_buffer, r);
        }
        if (write_med_data)
        { //  cache data for median energy walker
          c                      = std::get<2>(energy_order[nmed]);
          r                      = std::get<3>(energy_order[nmed]);
          WalkerLogCollector& tc = collectors[c];
          wmed_property_int_buffer.addRow(tc.walker_property_int_buffer, r);
          wmed_property_real_buffer.addRow(tc.walker_property_real_buffer, r);
          wmed_particle_real_buffer.addRow(tc.walker_particle_real_buffer, r);
        }
        // reset pointers
        n1        = n;
        prev_step = step;
      }
      n++;
    }
    energy_order.resize(0);
  }

  // write buffer data to file
  writeBuffersHDF();
}

writeBuffersHDF()

void writeBuffersHDF ( )

private

write data buffers to the logs file (HDF format)

Definition at line 291 of file WalkerLogManager.cpp.

References qmcplusplus::app_log(), WalkerLogManager::collectors_in_run_, WalkerLogManager::hdf_file, WalkerLogBuffer< T >::hdf_file_pointer, WalkerLogManager::registered_hdf, WalkerLogBuffer< T >::registerHDFData(), WalkerLogManager::state, WalkerLogState::verbose, WalkerLogCollector::walker_particle_real_buffer, WalkerLogCollector::walker_property_int_buffer, WalkerLogCollector::walker_property_real_buffer, WalkerLogManager::wmax_particle_real_buffer, WalkerLogManager::wmax_property_int_buffer, WalkerLogManager::wmax_property_real_buffer, WalkerLogManager::wmed_particle_real_buffer, WalkerLogManager::wmed_property_int_buffer, WalkerLogManager::wmed_property_real_buffer, WalkerLogManager::wmin_particle_real_buffer, WalkerLogManager::wmin_property_int_buffer, WalkerLogManager::wmin_property_real_buffer, WalkerLogManager::write_max_data, WalkerLogManager::write_med_data, WalkerLogManager::write_min_data, WalkerLogManager::write_particle_data, and WalkerLogBuffer< T >::writeHDF().

Referenced by WalkerLogManager::writeBuffers().

{
  const RefVector<WalkerLogCollector>& collectors = collectors_in_run_;
  if (state.verbose)
    app_log() << "WalkerLogManager::writeBuffersHDF " << std::endl;
  WalkerLogCollector& tc_lead = collectors[0];
  if (!registered_hdf)
  { // write walker quantity information ("data_layout") for each buffer in the HDF file
    //  create data_layout for all-walker buffers
    tc_lead.walker_property_int_buffer.registerHDFData(*hdf_file);
    tc_lead.walker_property_real_buffer.registerHDFData(*hdf_file);
    if (write_particle_data)
      tc_lead.walker_particle_real_buffer.registerHDFData(*hdf_file);
    if (write_min_data)
    { //  create data_layout for min energy walker buffers
      wmin_property_int_buffer.registerHDFData(*hdf_file);
      wmin_property_real_buffer.registerHDFData(*hdf_file);
      wmin_particle_real_buffer.registerHDFData(*hdf_file);
    }
    if (write_max_data)
    { //  create data_layout for max energy walker buffers
      wmax_property_int_buffer.registerHDFData(*hdf_file);
      wmax_property_real_buffer.registerHDFData(*hdf_file);
      wmax_particle_real_buffer.registerHDFData(*hdf_file);
    }
    if (write_med_data)
    { //  create data_layout for median energy walker buffers
      wmed_property_int_buffer.registerHDFData(*hdf_file);
      wmed_property_real_buffer.registerHDFData(*hdf_file);
      wmed_particle_real_buffer.registerHDFData(*hdf_file);
    }
    // walker quantity information ("data_layout") has now been added to HDF, do not repeat
    registered_hdf = true;
  }
  // write data for all-walker buffers to HDF
  for (int ip = 0; ip < collectors.size(); ++ip)
  {
    WalkerLogCollector& tc = collectors[ip];
    tc.walker_property_int_buffer.writeHDF(*hdf_file, tc_lead.walker_property_int_buffer.hdf_file_pointer);
    tc.walker_property_real_buffer.writeHDF(*hdf_file, tc_lead.walker_property_real_buffer.hdf_file_pointer);
    if (write_particle_data)
      tc.walker_particle_real_buffer.writeHDF(*hdf_file, tc_lead.walker_particle_real_buffer.hdf_file_pointer);
  }
  if (write_min_data)
  { // write data for min energy walker buffers to HDF
    wmin_property_int_buffer.writeHDF(*hdf_file);
    wmin_property_real_buffer.writeHDF(*hdf_file);
    wmin_particle_real_buffer.writeHDF(*hdf_file);
  }
  if (write_max_data)
  { // write data for max energy walker buffers to HDF
    wmax_property_int_buffer.writeHDF(*hdf_file);
    wmax_property_real_buffer.writeHDF(*hdf_file);
    wmax_particle_real_buffer.writeHDF(*hdf_file);
  }
  if (write_med_data)
  { // write data for median energy walker buffers to HDF
    wmed_property_int_buffer.writeHDF(*hdf_file);
    wmed_property_real_buffer.writeHDF(*hdf_file);
    wmed_particle_real_buffer.writeHDF(*hdf_file);
  }
}

Member Data Documentation

collectors_in_run_

RefVector<WalkerLogCollector> collectors_in_run_

private

Definition at line 90 of file WalkerLogManager.h.

Referenced by WalkerLogManager::startRun(), WalkerLogManager::stopRun(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

communicator

Communicate* communicator

private

Definition at line 49 of file WalkerLogManager.h.

Referenced by WalkerLogManager::openHDFFile(), and WalkerLogManager::WalkerLogManager().

energy_order

std::vector<std::tuple<size_t, WLog::Real, size_t, size_t> > energy_order

private

used to sort energy information for identifying walkers by energy quantile

Definition at line 67 of file WalkerLogManager.h.

Referenced by WalkerLogManager::writeBuffers().

file_root

std::string file_root

private

file prefix for the current driver

Definition at line 48 of file WalkerLogManager.h.

Referenced by WalkerLogManager::openHDFFile(), and WalkerLogManager::WalkerLogManager().

hdf_file

std::unique_ptr<hdf_archive> hdf_file

private

access to HDF file

Definition at line 53 of file WalkerLogManager.h.

Referenced by WalkerLogManager::closeHDFFile(), WalkerLogManager::openHDFFile(), and WalkerLogManager::writeBuffersHDF().

registered_hdf

bool registered_hdf

private

whether walker quantity data ("data_layout") has been recorded in HDF

Definition at line 55 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), and WalkerLogManager::writeBuffersHDF().

state

WalkerLogState state

private

output state

Definition at line 51 of file WalkerLogManager.h.

Referenced by WalkerLogManager::checkCollectors(), WalkerLogManager::closeFile(), WalkerLogManager::closeHDFFile(), WalkerLogManager::makeCollector(), WalkerLogManager::openFile(), WalkerLogManager::openHDFFile(), WalkerLogManager::startRun(), WalkerLogManager::stopRun(), WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmax_particle_real_buffer

WalkerLogBuffer<WLog::Real> wmax_particle_real_buffer

private

buffer containing per-particle properties for the maximum energy walkers

Definition at line 81 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmax_property_int_buffer

WalkerLogBuffer<WLog::Int> wmax_property_int_buffer

private

buffer containing integer properties for the maximum energy walkers

Definition at line 77 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmax_property_real_buffer

WalkerLogBuffer<WLog::Real> wmax_property_real_buffer

private

buffer containing real-valued properties for the maximum energy walkers

Definition at line 79 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmed_particle_real_buffer

WalkerLogBuffer<WLog::Real> wmed_particle_real_buffer

private

buffer containing per-particle properties for the median energy walkers

Definition at line 88 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmed_property_int_buffer

WalkerLogBuffer<WLog::Int> wmed_property_int_buffer

private

buffer containing integer properties for the median energy walkers

Definition at line 84 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmed_property_real_buffer

WalkerLogBuffer<WLog::Real> wmed_property_real_buffer

private

buffer containing real-valued properties for the median energy walkers

Definition at line 86 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmin_particle_real_buffer

WalkerLogBuffer<WLog::Real> wmin_particle_real_buffer

private

buffer containing per-particle properties for the minimum energy walkers

Definition at line 74 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmin_property_int_buffer

WalkerLogBuffer<WLog::Int> wmin_property_int_buffer

private

buffer containing integer properties for the minimum energy walkers

Definition at line 70 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

wmin_property_real_buffer

WalkerLogBuffer<WLog::Real> wmin_property_real_buffer

private

buffer containing real-valued properties for the minimum energy walkers

Definition at line 72 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

write_max_data

bool write_max_data

private

whether to write full data for the maximum energy walker at each step

Definition at line 62 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

write_med_data

bool write_med_data

private

whether to write full data for the median energy walker at each step

Definition at line 64 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

write_min_data

bool write_min_data

private

whether to write full data for the minimum energy walker at each step

Definition at line 60 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), WalkerLogManager::writeBuffers(), and WalkerLogManager::writeBuffersHDF().

write_particle_data

bool write_particle_data

private

whether to write per-particle data for all walkers

Definition at line 58 of file WalkerLogManager.h.

Referenced by WalkerLogManager::WalkerLogManager(), and WalkerLogManager::writeBuffersHDF().

---

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

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