SpinDensityNew Class Reference

Class that collects density per species of particle. More...

Inheritance diagram for SpinDensityNew:

Collaboration diagram for SpinDensityNew:

Public Types
using	POLT = PtclOnLatticeTraits
using	Lattice = POLT::ParticleLayout
using	QMCT = QMCTraits
using	FullPrecRealType = QMCT::FullPrecRealType
Public Types inherited from OperatorEstBase
using	QMCT = QMCTraits
using	FullPrecRealType = QMCT::FullPrecRealType
using	MCPWalker = Walker< QMCTraits, PtclOnLatticeTraits >
using	Data = std::vector< QMCT::RealType >

Public Member Functions
	SpinDensityNew (SpinDensityInput &&sdi, const SpeciesSet &species, DataLocality dl=DataLocality::crowd)
	Constructor for SpinDensityNew that contains an explicitly defined cell part of legacy input handling, Deprecated. More...
	SpinDensityNew (SpinDensityInput &&sdi, const Lattice &, const SpeciesSet &species, const DataLocality dl=DataLocality::crowd)
	Constructor. More...
	SpinDensityNew (const SpinDensityNew &sdn, DataLocality dl)
	Constructor used when spawing crowd clones needs to be public so std::make_unique can call it. More...
void	startBlock (int steps) override
	This allows us to allocate the necessary data for the DataLocality::queue. More...
std::unique_ptr< OperatorEstBase >	spawnCrowdClone () const override
	standard interface More...
void	accumulate (const RefVector< MCPWalker > &walkers, const RefVector< ParticleSet > &psets, const RefVector< TrialWaveFunction > &wfns, const RefVector< QMCHamiltonian > &hams, RandomBase< FullPrecRealType > &rng) override
	accumulate 1 or more walkers of SpinDensity samples More...
void	collect (const RefVector< OperatorEstBase > &operator_estimators) override
	this allows the EstimatorManagerNew to reduce without needing to know the details of SpinDensityNew's data. More...
void	registerOperatorEstimator (hdf_archive &file) override
	this allows the EstimatorManagerNew to reduce without needing to know the details of SpinDensityNew's data. More...
Public Member Functions inherited from OperatorEstBase
	OperatorEstBase (DataLocality dl)
	constructor More...
	OperatorEstBase (const OperatorEstBase &oth)
	Shallow copy constructor! This alows us to keep the default copy constructors for derived classes which is quite useful to the spawnCrowdClone design. More...
virtual	~OperatorEstBase ()=default
	virtual destructor More...
virtual void	normalize (QMCT::RealType invToWgt)
std::vector< QMCT::RealType > &	get_data ()
void	write (hdf_archive &file)
	Write to previously registered observable_helper hdf5 wrapper. More...
void	zero ()
	zero data appropriately for the DataLocality More...
QMCT::FullPrecRealType	get_walkers_weight () const
	Return the total walker weight for this block. More...
const std::string &	get_my_name () const
virtual void	registerListeners (QMCHamiltonian &ham_leader)
	Register 0-many listeners with a leading QMCHamiltonian instance i.e. More...
bool	isListenerRequired ()
DataLocality	get_data_locality () const

Private Member Functions
	SpinDensityNew (const SpinDensityNew &sdn)=default
size_t	getFullDataSize ()
	derived_parameters_ must be valid i.e. More...
void	accumulateToData (size_t point, QMCT::RealType weight)
void	reset ()
void	report (const std::string &pad)

Static Private Member Functions
static std::vector< int >	getSpeciesSize (const SpeciesSet &species)

Private Attributes
const SpinDensityInput	input_
const SpeciesSet &	species_
const std::vector< int >	species_size_
Lattice	lattice_
	they should be limited to values that can be changed from input or are not present explicitly in the SpinDensityInput More...
SpinDensityInput::DerivedParameters	derived_parameters_
class	testing::SpinDensityNewTests
	}@ More...

Additional Inherited Members
Protected Attributes inherited from OperatorEstBase
DataLocality	data_locality_
	locality for accumulation of estimator data. More...
std::string	my_name_
	name of this object – only used for debugging and h5 output More...
QMCT::FullPrecRealType	walkers_weight_
std::vector< ObservableHelper >	h5desc_
Data	data_
bool	requires_listener_ = false

Detailed Description

Class that collects density per species of particle.

commonly used for spin up and down electrons

Definition at line 35 of file SpinDensityNew.h.

Member Typedef Documentation

FullPrecRealType

using FullPrecRealType = QMCT::FullPrecRealType

Definition at line 41 of file SpinDensityNew.h.

Lattice

using Lattice = POLT::ParticleLayout

Definition at line 39 of file SpinDensityNew.h.

POLT

using POLT = PtclOnLatticeTraits

Definition at line 38 of file SpinDensityNew.h.

QMCT

using QMCT = QMCTraits

Definition at line 40 of file SpinDensityNew.h.

Constructor & Destructor Documentation

SpinDensityNew() [1/4]

SpinDensityNew	(	SpinDensityInput &&	sdi,
		const SpeciesSet &	species,
		DataLocality	dl = DataLocality::crowd
	)

Constructor for SpinDensityNew that contains an explicitly defined cell part of legacy input handling, Deprecated.

Definition at line 23 of file SpinDensityNew.cpp.

References SpinDensityInput::calculateDerivedParameters(), qmcplusplus::crowd, OperatorEstBase::data_, OperatorEstBase::data_locality_, SpinDensityNew::derived_parameters_, CrystalLattice< T, D >::explicitly_defined, SpinDensityInput::get_cell(), SpinDensityInput::get_save_memory(), SpinDensityInput::get_write_report(), SpinDensityNew::getFullDataSize(), SpinDensityNew::input_, SpinDensityNew::lattice_, OperatorEstBase::my_name_, qmcplusplus::rank, and SpinDensityNew::report().

    : OperatorEstBase(dl), input_(std::move(input)), species_(species), species_size_(getSpeciesSize(species))
{
  my_name_ = "SpinDensity";

  data_locality_ = DataLocality::crowd;
  if (input_.get_save_memory())
    dl = DataLocality::rank;

  if (input_.get_cell().explicitly_defined == true)
    lattice_ = input_.get_cell();
  else
    throw std::runtime_error("If SpinDensityInput does not contain a cell definition you must call the constructor "
                             "with an explicit lattice defined");

  derived_parameters_ = input_.calculateDerivedParameters(lattice_);

  data_.resize(getFullDataSize(), 0.0);

  if (input_.get_write_report())
    report("  ");
}

SpinDensityNew() [2/4]

SpinDensityNew	(	SpinDensityInput &&	sdi,
		const Lattice &	lattice,
		const SpeciesSet &	species,
		const DataLocality	dl = DataLocality::crowd
	)

Constructor.

If the sdi contains a cell definition the Lattice passed will be ignored.

Other wise the crystal lattice should come from the same particle set as the species set. in case you are tempted to just pass the ParticleSet don't. It clouds the data dependence of constructing the estimator and creates a strong coupling between the classes.

Ideally when validating input is built up enough there would be only one constructor with signature

SpinDensityNew(SpinDensityInput&& sdi, SpinDensityInput::DerivedParameters&& dev_par, SpeciesSet species, DataLocality dl);

Definition at line 46 of file SpinDensityNew.cpp.

References SpinDensityInput::calculateDerivedParameters(), OperatorEstBase::data_, OperatorEstBase::data_locality_, SpinDensityNew::derived_parameters_, CrystalLattice< T, D >::explicitly_defined, SpinDensityInput::get_cell(), SpinDensityInput::get_write_report(), SpinDensityNew::getFullDataSize(), SpinDensityNew::input_, SpinDensityNew::lattice_, OperatorEstBase::my_name_, and SpinDensityNew::report().

    : OperatorEstBase(dl),
      input_(std::move(input)),
      species_(species),
      species_size_(getSpeciesSize(species)),
      lattice_(lattice)
{
  my_name_       = "SpinDensity";
  data_locality_ = dl;
  if (input_.get_cell().explicitly_defined == true)
    lattice_ = input_.get_cell();
  derived_parameters_ = input_.calculateDerivedParameters(lattice_);
  data_.resize(getFullDataSize());
  if (input_.get_write_report())
    report("  ");
}

SpinDensityNew() [3/4]

SpinDensityNew	(	const SpinDensityNew &	sdn,
		DataLocality	dl
	)

Constructor used when spawing crowd clones needs to be public so std::make_unique can call it.

Do not use directly unless you've really thought it through.

Definition at line 66 of file SpinDensityNew.cpp.

References OperatorEstBase::data_locality_.

                                                                         : SpinDensityNew(sdn)
{
  data_locality_ = dl;
}

SpinDensityNew() [4/4]

SpinDensityNew ( const SpinDensityNew &  sdn )

privatedefault

Member Function Documentation

accumulate()

void accumulate ( const RefVector< MCPWalker > &  walkers, const RefVector< ParticleSet > &  psets, const RefVector< TrialWaveFunction > &  wfns, const RefVector< QMCHamiltonian > &  hams, RandomBase< FullPrecRealType > &  rng  )

overridevirtual

accumulate 1 or more walkers of SpinDensity samples

Gets called every step and writes to thread local data.

I tried for readable and not doing the optimizers job. The offsets into bare data are already bad enough.

Implements OperatorEstBase.

Definition at line 117 of file SpinDensityNew.cpp.

References SpinDensityNew::accumulateToData(), SpinDensityNew::derived_parameters_, QMCTraits::DIM, qmcplusplus::floor(), SpinDensityNew::lattice_, qmcplusplus::Units::time::ps, qmcplusplus::pset, qmcplusplus::Units::time::s, SpeciesSet::size(), SpinDensityNew::species_, SpinDensityNew::species_size_, CrystalLattice< T, D >::toUnit(), qmcplusplus::walker, qmcplusplus::hdf::walkers, and OperatorEstBase::walkers_weight_.

Referenced by qmcplusplus::accumulateFromPsets(), qmcplusplus::randomUpdateAccumulate(), and qmcplusplus::TEST_CASE().

{
  auto& dp_ = derived_parameters_;
  for (int iw = 0; iw < walkers.size(); ++iw)
  {
    MCPWalker& walker     = walkers[iw];
    ParticleSet& pset     = psets[iw];
    QMCT::RealType weight = walker.Weight;
    assert(weight >= 0);
    // for testing
    walkers_weight_ += weight;
    int p         = 0;
    size_t offset = 0;
    for (int s = 0; s < species_.size(); ++s, offset += dp_.npoints)
      for (int ps = 0; ps < species_size_[s]; ++ps, ++p)
      {
        QMCT::PosType u = lattice_.toUnit(pset.R[p] - dp_.corner);
        size_t point    = offset;
        for (int d = 0; d < QMCT::DIM; ++d)
          point += dp_.gdims[d] * ((int)(dp_.grid[d] * (u[d] - std::floor(u[d])))); //periodic only
        accumulateToData(point, weight);
      }
  }
}

accumulateToData()

void accumulateToData ( size_t  point, QMCT::RealType  weight  )

private

Definition at line 146 of file SpinDensityNew.cpp.

References qmcplusplus::crowd, OperatorEstBase::data_, OperatorEstBase::data_locality_, and qmcplusplus::queue.

Referenced by SpinDensityNew::accumulate().

{
  if (data_locality_ == DataLocality::crowd)
  {
    data_[point] += weight;
  }
  else if (data_locality_ == DataLocality::queue)
  {
    data_.push_back(point);
    data_.push_back(weight);
  }
  else
  {
    throw std::runtime_error("You cannot accumulate to a SpinDensityNew with datalocality of this type");
  }
}

collect()

void collect ( const RefVector< OperatorEstBase > &  operator_estimators )

overridevirtual

this allows the EstimatorManagerNew to reduce without needing to know the details of SpinDensityNew's data.

can use base class default until crowd level SpinDensity estimators don't have a copy of the density grid.

Reimplemented from OperatorEstBase.

Definition at line 163 of file SpinDensityNew.cpp.

References OperatorEstBase::collect(), qmcplusplus::crowd, OperatorEstBase::data_, OperatorEstBase::data_locality_, OperatorEstBase::get_data(), qmcplusplus::rank, and OperatorEstBase::walkers_weight_.

{
  if (data_locality_ == DataLocality::rank)
  {
    for (OperatorEstBase& crowd_oeb : type_erased_operator_estimators)
    {
      // This will throw a std::bad_cast in debug if the calling code hands the
      // wrong type erased operator_estimator type into here.
      // In release we don't want that overhead.
#ifndef NDEBUG
      auto& oeb = dynamic_cast<SpinDensityNew&>(crowd_oeb);
#else
      auto& oeb = static_cast<SpinDensityNew&>(crowd_oeb);
#endif
      auto& data = oeb.get_data();
      for (int id = 0; id < data.size(); id += 2)
      {
        // This is a smell
        size_t point{static_cast<size_t>(data[id])};
        const QMCT::RealType weight{data[id + 1]};
        data_[point] += weight;
        walkers_weight_ += weight;
      }
      oeb.zero();
    }
  }
  else if (data_locality_ == DataLocality::crowd)
  {
    OperatorEstBase::collect(type_erased_operator_estimators);
  }
  else
  {
    throw std::runtime_error("You cannot call collect on a SpinDensityNew with this DataLocality");
  }
}

getFullDataSize()

size_t getFullDataSize ( )

private

derived_parameters_ must be valid i.e.

initialized with call to input_.calculateDerivedParameters

Definition at line 82 of file SpinDensityNew.cpp.

References SpinDensityNew::derived_parameters_, SpinDensityInput::DerivedParameters::npoints, SpeciesSet::size(), and SpinDensityNew::species_.

Referenced by SpinDensityNew::SpinDensityNew().

{ return species_.size() * derived_parameters_.npoints; }

getSpeciesSize()

std::vector< int > getSpeciesSize ( const SpeciesSet &  species )

staticprivate

Definition at line 71 of file SpinDensityNew.cpp.

References SpeciesSet::findAttribute(), qmcplusplus::Units::time::s, and SpeciesSet::size().

{
  std::vector<int> species_size;
  int index = species.findAttribute("membersize");
  if (index < 0)
    throw std::runtime_error("SpinDensity(P) Species set does not have the required attribute 'membersize'");
  for (int s = 0; s < species.size(); ++s)
    species_size.push_back(species(index, s));
  return species_size;
}

registerOperatorEstimator()

void registerOperatorEstimator ( hdf_archive &  file )

overridevirtual

this allows the EstimatorManagerNew to reduce without needing to know the details of SpinDensityNew's data.

can use base class default until crowd level SpinDensity estimators don't have a copy of the density grid. this gets us into the hdf5 file

Just parroting for now don't fully understand. , needs to be unraveled and simplified the hdf5 output is another big state big coupling design.

Reimplemented from OperatorEstBase.

Definition at line 220 of file SpinDensityNew.cpp.

References SpinDensityNew::derived_parameters_, OperatorEstBase::h5desc_, OperatorEstBase::my_name_, SpinDensityInput::DerivedParameters::npoints, qmcplusplus::oh, qmcplusplus::Units::time::s, ObservableHelper::set_dimensions(), SpeciesSet::size(), SpinDensityNew::species_, and SpeciesSet::speciesName.

{
  std::vector<size_t> my_indexes;

  std::vector<int> ng(1, derived_parameters_.npoints);

  hdf_path hdf_name{my_name_};
  for (int s = 0; s < species_.size(); ++s)
  {
    h5desc_.emplace_back(hdf_name / species_.speciesName[s]);
    auto& oh = h5desc_.back();
    oh.set_dimensions(ng, s * derived_parameters_.npoints);
  }
}

report()

void report ( const std::string &  pad )

private

Definition at line 199 of file SpinDensityNew.cpp.

References qmcplusplus::app_log(), CrystalLattice< T, D >::Center, SpinDensityNew::derived_parameters_, QMCTraits::DIM, SpinDensityNew::lattice_, CrystalLattice< T, D >::Rv, qmcplusplus::Units::time::s, SpeciesSet::size(), SpinDensityNew::species_, SpinDensityNew::species_size_, and SpeciesSet::speciesName.

Referenced by SpinDensityNew::SpinDensityNew().

{
  auto& dp_ = derived_parameters_;
  app_log() << pad << "SpinDensity report" << std::endl;
  app_log() << pad << "  dim     = " << QMCT::DIM << std::endl;
  app_log() << pad << "  npoints = " << dp_.npoints << std::endl;
  app_log() << pad << "  grid    = " << dp_.grid << std::endl;
  app_log() << pad << "  gdims   = " << dp_.gdims << std::endl;
  app_log() << pad << "  corner  = " << dp_.corner << std::endl;
  app_log() << pad << "  center  = " << dp_.corner + lattice_.Center << std::endl;
  app_log() << pad << "  cell " << std::endl;
  for (int d = 0; d < QMCT::DIM; ++d)
    app_log() << pad << "    " << d << " " << lattice_.Rv[d] << std::endl;
  app_log() << pad << "  end cell " << std::endl;
  app_log() << pad << "  nspecies = " << species_.size() << std::endl;
  for (int s = 0; s < species_.size(); ++s)
    app_log() << pad << "    species[" << s << "]"
              << " = " << species_.speciesName[s] << " " << species_size_[s] << std::endl;
  app_log() << pad << "end SpinDensity report" << std::endl;
}

reset()

void reset ( )

private

spawnCrowdClone()

std::unique_ptr< OperatorEstBase > spawnCrowdClone ( ) const

overridevirtual

standard interface

Implements OperatorEstBase.

Definition at line 84 of file SpinDensityNew.cpp.

References OperatorEstBase::data_, OperatorEstBase::data_locality_, qmcplusplus::queue, qmcplusplus::rank, and SpinDensityNew::species_size_.

Referenced by qmcplusplus::accumulateFromPsets().

{
  std::size_t data_size    = data_.size();
  auto spawn_data_locality = data_locality_;
  if (data_locality_ == DataLocality::rank)
  {
    spawn_data_locality = DataLocality::queue;
    // at construction we don't know what the data requirement is going to be
    // since its steps per block  dependent. so start with 10 steps worth.
    int num_particles = std::accumulate(species_size_.begin(), species_size_.end(), 0);
    data_size         = num_particles * 20;
  }
  UPtr<SpinDensityNew> spawn(std::make_unique<SpinDensityNew>(*this, spawn_data_locality));
  spawn->get_data().resize(data_size);
  return spawn;
}

startBlock()

void startBlock ( int  steps )

overridevirtual

This allows us to allocate the necessary data for the DataLocality::queue.

Implements OperatorEstBase.

Definition at line 101 of file SpinDensityNew.cpp.

References OperatorEstBase::data_, OperatorEstBase::data_locality_, qmcplusplus::rank, and SpinDensityNew::species_size_.

{
  if (data_locality_ == DataLocality::rank)
  {
    int num_particles = std::accumulate(species_size_.begin(), species_size_.end(), 0);
    size_t data_size  = num_particles * steps * 2;
    data_.reserve(data_size);
    data_.resize(0);
  }
}

Friends And Related Function Documentation

testing::SpinDensityNewTests

friend class testing::SpinDensityNewTests

friend

}@

Definition at line 143 of file SpinDensityNew.h.

Member Data Documentation

derived_parameters_

SpinDensityInput::DerivedParameters derived_parameters_

private

Definition at line 140 of file SpinDensityNew.h.

Referenced by SpinDensityNew::accumulate(), SpinDensityNew::getFullDataSize(), SpinDensityNew::registerOperatorEstimator(), SpinDensityNew::report(), and SpinDensityNew::SpinDensityNew().

input_

const SpinDensityInput input_

private

Definition at line 126 of file SpinDensityNew.h.

Referenced by SpinDensityNew::SpinDensityNew().

lattice_

Lattice lattice_

private

they should be limited to values that can be changed from input or are not present explicitly in the SpinDensityInput

Lattice is always local since it is either in the input or a constructor argument.

Definition at line 139 of file SpinDensityNew.h.

Referenced by SpinDensityNew::accumulate(), SpinDensityNew::report(), and SpinDensityNew::SpinDensityNew().

species_

const SpeciesSet& species_

private

Definition at line 127 of file SpinDensityNew.h.

Referenced by SpinDensityNew::accumulate(), SpinDensityNew::getFullDataSize(), SpinDensityNew::registerOperatorEstimator(), and SpinDensityNew::report().

species_size_

const std::vector<int> species_size_

private

Definition at line 129 of file SpinDensityNew.h.

Referenced by SpinDensityNew::accumulate(), SpinDensityNew::report(), SpinDensityNew::spawnCrowdClone(), SpinDensityNew::startBlock(), and SpinDensityNewTests::testCopyConstructor().

---

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

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