HDFWalkerOutput Class Reference

Writes a set of walker configurations to an HDF5 file. More...

Collaboration diagram for HDFWalkerOutput:

Public Member Functions
	HDFWalkerOutput (size_t num_ptcls, const std::string &fname, Communicate *c)
	constructor More...
	~HDFWalkerOutput ()
	destructor More...
bool	dump (const WalkerConfigurations &w, int block)
	dump configurations More...

Private Types
using	BufferType = PooledData< OHMMS_PRECISION >
	PooledData<T> is used to define the shape of multi-dimensional array. More...

Private Member Functions
void	write_configuration (const WalkerConfigurations &W, hdf_archive &hout, int block)

Private Attributes
bool	DoNotAppend
	if true, keep it in memory More...
int	appended_blocks
	number of blocks for append More...
size_t	number_of_walkers_
	number of walkers when a state is dumped More...
const size_t	number_of_particles_
	number of particles More...
Communicate *	myComm
	communicator More...
int	currentConfigNumber
std::string	RootName
	rootname More...
std::string	prevFile
std::vector< Communicate::request >	myRequest
std::array< BufferType, 2 >	RemoteData
std::array< std::vector< QMCTraits::FullPrecRealType >, 2 >	RemoteDataW
int	block

Detailed Description

Writes a set of walker configurations to an HDF5 file.

Definition at line 26 of file HDFWalkerOutput.h.

Member Typedef Documentation

BufferType

using BufferType = PooledData<OHMMS_PRECISION>

private

PooledData<T> is used to define the shape of multi-dimensional array.

Definition at line 60 of file HDFWalkerOutput.h.

Constructor & Destructor Documentation

HDFWalkerOutput()

HDFWalkerOutput	(	size_t	num_ptcls,
		const std::string &	fname,
		Communicate *	c
	)

constructor

Definition at line 57 of file HDFWalkerOutput.cpp.

References HDFWalkerOutput::block.

    : appended_blocks(0),
      number_of_walkers_(0),
      number_of_particles_(num_ptcls),
      myComm(c),
      currentConfigNumber(0),
      RootName(aroot)
{
  block = -1;
}

~HDFWalkerOutput()

~HDFWalkerOutput ( )

default

destructor

Destructor writes the state of random numbers and close the file.

Member Function Documentation

dump()

bool dump	(	const WalkerConfigurations &	W,
		int	nblock
	)

dump configurations

Write the set of walker configurations to the HDF5 file.

Parameters

w	walkers
W	set of walker configurations

Dump is for restart and do not preserve the file

• version
• state_0
  • block (int)
  • number_of_walkers (int)
  • walker_partition (int array)
  • walkers (nw,np,3)

Definition at line 82 of file HDFWalkerOutput.cpp.

References hdf_archive::close(), qmcplusplus::hdf::config_ext, hdf_archive::create(), HDFWalkerOutput::currentConfigNumber, Communicate::getName(), qmcplusplus::hdf::main_state, HDFWalkerOutput::myComm, HDFWalkerOutput::prevFile, hdf_archive::push(), qmcplusplus::hdf::version, HDFVersion::version, hdf_archive::write(), and HDFWalkerOutput::write_configuration().

Referenced by MCWalkerConfiguration::dumpEnsemble(), and qmcplusplus::TEST_CASE().

{
  std::filesystem::path FileName = myComm->getName();
  FileName.concat(hdf::config_ext);
  //rotate files
  //if(!myComm->rank() && currentConfigNumber)
  //{
  //  std::ostringstream o;
  //  o<<myComm->getName()<<".b"<<(currentConfigNumber%5) << hdf::config_ext;
  //  rename(prevFile.c_str(),o.str().c_str());
  //}

  //try to use collective
  hdf_archive dump_file(myComm, true);
  dump_file.create(FileName);
  HDFVersion cur_version;
  dump_file.write(cur_version.version, hdf::version);
  dump_file.push(hdf::main_state);
  dump_file.write(nblock, "block");

  write_configuration(W, dump_file, nblock);
  dump_file.close();

  currentConfigNumber++;
  prevFile = FileName;
  return true;
}

write_configuration()

void write_configuration ( const WalkerConfigurations &  W, hdf_archive &  hout, int  block  )

private

Definition at line 110 of file HDFWalkerOutput.cpp.

References HDFWalkerOutput::block, gatherv(), WalkerConfigurations::getActiveWalkers(), WalkerConfigurations::getWalkerOffsets(), hdf_archive::is_parallel(), HDFWalkerOutput::myComm, qmcplusplus::hdf::num_walkers, HDFWalkerOutput::number_of_particles_, HDFWalkerOutput::number_of_walkers_, OHMMS_DIM, WalkerConfigurations::putConfigurations(), Communicate::rank(), HDFWalkerOutput::RemoteData, HDFWalkerOutput::RemoteDataW, Communicate::size(), qmcplusplus::hdf::walker_weights, qmcplusplus::hdf::walkers, hdf_archive::write(), and hdf_archive::writeSlabReshaped().

Referenced by HDFWalkerOutput::dump().

{
  const int wb = OHMMS_DIM * number_of_particles_;
  if (nblock > block)
  {
    RemoteData[0].resize(wb * W.getActiveWalkers());
    RemoteDataW[0].resize(W.getActiveWalkers());
    W.putConfigurations(RemoteData[0].data(), RemoteDataW[0].data());
    block = nblock;
  }

  auto& walker_offsets = W.getWalkerOffsets();
  number_of_walkers_ = walker_offsets[myComm->size()];
  hout.write(number_of_walkers_, hdf::num_walkers);

  if (hout.is_parallel())
  {
    { // write walker offset.
      // Though it is a small array, it needs to be written collectively in large scale runs.
      std::array<size_t, 1> gcounts{static_cast<size_t>(myComm->size()) + 1};
      std::array<size_t, 1> counts{0};
      std::array<size_t, 1> offsets{static_cast<size_t>(myComm->rank())};
      std::vector<int> myWalkerOffset;
      if (myComm->size() - 1 == myComm->rank())
      {
        counts[0] = 2;
        myWalkerOffset.push_back(walker_offsets[myComm->rank()]);
        myWalkerOffset.push_back(walker_offsets[myComm->size()]);
      }
      else
      {
        counts[0] = 1;
        myWalkerOffset.push_back(walker_offsets[myComm->rank()]);
      }
      hyperslab_proxy<std::vector<int>, 1> slab(myWalkerOffset, gcounts, counts, offsets);
      hout.write(slab, "walker_partition");
    }
    { // write walker configuration
      std::array<size_t, 3> gcounts{number_of_walkers_, number_of_particles_, OHMMS_DIM};
      std::array<size_t, 3> counts{W.getActiveWalkers(), number_of_particles_, OHMMS_DIM};
      std::array<size_t, 3> offsets{static_cast<size_t>(walker_offsets[myComm->rank()]), 0, 0};
      hyperslab_proxy<BufferType, 3> slab(RemoteData[0], gcounts, counts, offsets);
      hout.write(slab, hdf::walkers);
    }
    {
      std::array<size_t, 1> gcounts{number_of_walkers_};
      std::array<size_t, 1> counts{W.getActiveWalkers()};
      std::array<size_t, 1> offsets{static_cast<size_t>(walker_offsets[myComm->rank()])};
      hyperslab_proxy<std::vector<QMCTraits::FullPrecRealType>, 1> slab(RemoteDataW[0], gcounts, counts, offsets);
      hout.write(slab, hdf::walker_weights);
    }
  }
  else
  { //gaterv to the master and master writes it, could use isend/irecv
    hout.write(walker_offsets, "walker_partition");
    if (myComm->size() > 1)
    {
      std::vector<int> displ(myComm->size()), counts(myComm->size());
      for (int i = 0; i < myComm->size(); ++i)
      {
        counts[i] = wb * (walker_offsets[i + 1] - walker_offsets[i]);
        displ[i]  = wb * walker_offsets[i];
      }
      if (!myComm->rank())
        RemoteData[1].resize(wb * walker_offsets[myComm->size()]);
      mpi::gatherv(*myComm, RemoteData[0], RemoteData[1], counts, displ);
      // update counts and displ for gathering walker weights
      for (int i = 0; i < myComm->size(); ++i)
      {
        counts[i] = (walker_offsets[i + 1] - walker_offsets[i]);
        displ[i]  = walker_offsets[i];
      }
      if (!myComm->rank())
        RemoteDataW[1].resize(walker_offsets[myComm->size()]);
      mpi::gatherv(*myComm, RemoteDataW[0], RemoteDataW[1], counts, displ);
    }
    int buffer_id = (myComm->size() > 1) ? 1 : 0;
    {
      std::array<size_t, 3> gcounts{number_of_walkers_, number_of_particles_, OHMMS_DIM};
      hout.writeSlabReshaped(RemoteData[buffer_id], gcounts, hdf::walkers);
    }
    {
      std::array<size_t, 1> gcounts{number_of_walkers_};
      hout.writeSlabReshaped(RemoteDataW[buffer_id], gcounts, hdf::walker_weights);
    }
  }
}

Member Data Documentation

appended_blocks

int appended_blocks

private

number of blocks for append

Definition at line 31 of file HDFWalkerOutput.h.

block

int block

private

Definition at line 64 of file HDFWalkerOutput.h.

Referenced by HDFWalkerOutput::HDFWalkerOutput(), and HDFWalkerOutput::write_configuration().

currentConfigNumber

int currentConfigNumber

private

Definition at line 42 of file HDFWalkerOutput.h.

Referenced by HDFWalkerOutput::dump().

DoNotAppend

bool DoNotAppend

private

if true, keep it in memory

Definition at line 29 of file HDFWalkerOutput.h.

myComm

Communicate* myComm

private

communicator

Definition at line 41 of file HDFWalkerOutput.h.

Referenced by HDFWalkerOutput::dump(), and HDFWalkerOutput::write_configuration().

myRequest

std::vector<Communicate::request> myRequest

private

Definition at line 61 of file HDFWalkerOutput.h.

number_of_particles_

const size_t number_of_particles_

private

number of particles

Definition at line 39 of file HDFWalkerOutput.h.

Referenced by HDFWalkerOutput::write_configuration().

number_of_walkers_

size_t number_of_walkers_

private

number of walkers when a state is dumped

When the number of walkers per state has changed, NumOfWalkers is used to reallocate the hdf5 group.

Definition at line 37 of file HDFWalkerOutput.h.

Referenced by HDFWalkerOutput::write_configuration().

prevFile

std::string prevFile

private

Definition at line 45 of file HDFWalkerOutput.h.

Referenced by HDFWalkerOutput::dump().

RemoteData

std::array<BufferType, 2> RemoteData

private

Definition at line 62 of file HDFWalkerOutput.h.

Referenced by HDFWalkerOutput::write_configuration().

RemoteDataW

std::array<std::vector<QMCTraits::FullPrecRealType>, 2> RemoteDataW

private

Definition at line 63 of file HDFWalkerOutput.h.

Referenced by HDFWalkerOutput::write_configuration().

RootName

std::string RootName

private

rootname

Definition at line 44 of file HDFWalkerOutput.h.

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Particle/HDFWalkerOutput.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Particle/HDFWalkerOutput.cpp