MagnetizationDensity Class Reference

Magnetization density estimator for non-collinear spin calculations. More...

Inheritance diagram for MagnetizationDensity:

Collaboration diagram for MagnetizationDensity:

Public Types
using	Value = QMCTraits::ValueType
using	FullPrecValue = QMCTraits::FullPrecValueType
using	Real = RealAlias< Value >
using	FullPrecReal = RealAlias< FullPrecValue >
using	Grad = TinyVector< Value, OHMMS_DIM >
using	Lattice = PtclOnLatticeTraits::ParticleLayout
using	Position = QMCTraits::PosType
using	Integrator = MagnetizationDensityInput::Integrator
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
	MagnetizationDensity (MagnetizationDensityInput &&min, const Lattice &lattice)
	MagnetizationDensity (const MagnetizationDensity &magdens, DataLocality dl)
void	startBlock (int steps) override
void	accumulate (const RefVector< MCPWalker > &walkers, const RefVector< ParticleSet > &psets, const RefVector< TrialWaveFunction > &wfns, const RefVector< QMCHamiltonian > &hams, RandomBase< FullPrecReal > &rng) override
void	collect (const RefVector< OperatorEstBase > &operator_estimators) override
	Reduce estimator result data from crowds to rank. More...
size_t	getFullDataSize ()
	This returns the total size of data object required for this estimator. More...
std::unique_ptr< OperatorEstBase >	spawnCrowdClone () const override
void	registerOperatorEstimator (hdf_archive &file) override
Value	integrateMagnetizationDensity (const std::vector< Value > &fgrid) const
	This is a convenience function that handles ^{2} dx f(x). 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	accumulate (const RefVector< MCPWalker > &walkers, const RefVector< ParticleSet > &psets, const RefVector< TrialWaveFunction > &wfns, const RefVector< QMCHamiltonian > &hams, RandomBase< FullPrecRealType > &rng)=0
	Accumulate whatever it is you are accumulating with respect to walkers. 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

Static Public Attributes
static constexpr int	DIM = QMCTraits::DIM

Private Member Functions
	MagnetizationDensity (const MagnetizationDensity &magdens)=default
void	generateSpinIntegrand (ParticleSet &pset, TrialWaveFunction &wfn, const int iat, std::vector< Value > &sx, std::vector< Value > &sy, std::vector< Value > &sz)
	Generates the spin integrand (s')/Psi(s)* s | {} | s' for a specific electron iat. More...
Value	integrateBySimpsonsRule (const std::vector< Value > &fgrid, Real gridDx) const
	Implementation of Simpson's 1/3 rule to integrate a function on a uniform grid. More...
void	generateGrid (std::vector< Real > &sgrid) const
	Convenience function to generate a grid between 0 and 2pi, consistent with nsamples_ and integration method. More...
void	generateUniformGrid (std::vector< Real > &sgrid, const Real start, const Real stop) const
	Generate a uniform grid between [start,stop] for numerical quadrature. More...
void	generateRandomGrid (std::vector< Real > &sgrid, RandomBase< FullPrecReal > &rng, Real start, Real stop) const
	Generate random grid between [start,stop] for MC integration. More...
size_t	computeBin (const Position &r, const unsigned int component) const
	For a given spatial position r and spin component s, this returns the bin for accumulating the observable. More...

Private Attributes
MagnetizationDensityInput	input_
Integrator	integrator_
Lattice	lattice_
Position	rcorner_
Position	center_
TinyVector< int, DIM >	grid_
TinyVector< int, DIM >	gdims_
size_t	npoints_
int	nsamples_

Friends
class	testing::MagnetizationDensityTests

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

Magnetization density estimator for non-collinear spin calculations.

As documented in the manual, the following formula is computed:
{m}_c = d{X} |{({X})}|^2 {}d{r} ({r}-{{r}}_i)^{2} {ds'_i}{2} {( {r}_i s'_i )}{( {r}_i s_i )} s_i | {} | s'_i

The way that the above relates to the underlying data structure data_ is as follows. We grid space up and assign an index for each of the real space bins (identical to SpinDensityNew). To account for the fact that magnetization is vectorial, we triple the length of this array. If grid_i is the index of the real space gridpoint i, then the data is layed out like: [grid_0_x, grid_0_y, grid_0_z, grid_1_x, ..., grid_N_x, grid_N_y, grid_N_z]. This is also the way it is stored in HDF5.

Definition at line 42 of file MagnetizationDensity.h.

Member Typedef Documentation

FullPrecReal

using FullPrecReal = RealAlias<FullPrecValue>

Definition at line 48 of file MagnetizationDensity.h.

FullPrecValue

using FullPrecValue = QMCTraits::FullPrecValueType

Definition at line 46 of file MagnetizationDensity.h.

Grad

using Grad = TinyVector<Value, OHMMS_DIM>

Definition at line 49 of file MagnetizationDensity.h.

Integrator

using Integrator = MagnetizationDensityInput::Integrator

Definition at line 52 of file MagnetizationDensity.h.

Lattice

using Lattice = PtclOnLatticeTraits::ParticleLayout

Definition at line 50 of file MagnetizationDensity.h.

Position

using Position = QMCTraits::PosType

Definition at line 51 of file MagnetizationDensity.h.

Real

using Real = RealAlias<Value>

Definition at line 47 of file MagnetizationDensity.h.

Value

using Value = QMCTraits::ValueType

Definition at line 45 of file MagnetizationDensity.h.

Constructor & Destructor Documentation

MagnetizationDensity() [1/3]

MagnetizationDensity	(	MagnetizationDensityInput &&	min,
		const Lattice &	lattice
	)

Definition at line 16 of file MagnetizationDensity.cpp.

References CrystalLattice< T, D >::Center, MagnetizationDensity::center_, MagnetizationDensityInput::DerivedParameters::corner, qmcplusplus::crowd, OperatorEstBase::data_, MagnetizationDensityInput::DerivedParameters::gdims, MagnetizationDensity::gdims_, MagnetizationDensityInput::get_integrator(), MagnetizationDensityInput::get_nsamples(), MagnetizationDensity::getFullDataSize(), MagnetizationDensityInput::DerivedParameters::grid, MagnetizationDensity::grid_, MagnetizationDensity::input_, MagnetizationDensity::integrator_, MagnetizationDensity::lattice_, OperatorEstBase::my_name_, MagnetizationDensityInput::DerivedParameters::npoints, MagnetizationDensity::npoints_, MagnetizationDensity::nsamples_, and MagnetizationDensity::rcorner_.

    : OperatorEstBase(DataLocality::crowd), input_(minput), lattice_(lat)
{
  my_name_ = "MagnetizationDensity";
  //Pull consistent corner, grids, etc., from already inititalized input.
  //DerivedParameters does the sanity checks and consistent initialization of these variables.
  MagnetizationDensityInput::DerivedParameters derived = minput.calculateDerivedParameters(lat);

  //If DerivedParameters does its job, these are all correct, so we pull them and keep them in the class.
  npoints_ = derived.npoints;
  grid_    = derived.grid;
  gdims_   = derived.gdims;

  rcorner_ = derived.corner;
  center_  = rcorner_ + lattice_.Center;

  nsamples_   = input_.get_nsamples();
  integrator_ = input_.get_integrator();

  //Resize the data arrays.
  data_.resize(getFullDataSize(), 0);
}

MagnetizationDensity() [2/3]

MagnetizationDensity	(	const MagnetizationDensity &	magdens,
		DataLocality	dl
	)

Definition at line 39 of file MagnetizationDensity.cpp.

References OperatorEstBase::data_locality_, and OperatorEstBase::my_name_.

    : MagnetizationDensity(magdens)
{
  my_name_       = "MagnetizationDensity";
  data_locality_ = dl;
}

MagnetizationDensity() [3/3]

MagnetizationDensity ( const MagnetizationDensity &  magdens )

privatedefault

Member Function Documentation

accumulate()

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

override

Definition at line 49 of file MagnetizationDensity.cpp.

References MagnetizationDensity::computeBin(), OperatorEstBase::data_, MagnetizationDensity::generateSpinIntegrand(), MagnetizationDensity::integrateMagnetizationDensity(), MagnetizationDensity::nsamples_, qmcplusplus::pset, qmcplusplus::walker, qmcplusplus::hdf::walkers, and OperatorEstBase::walkers_weight_.

{
  for (int iw = 0; iw < walkers.size(); ++iw)
  {
    MCPWalker& walker      = walkers[iw];
    ParticleSet& pset      = psets[iw];
    TrialWaveFunction& wfn = wfns[iw];

    QMCT::RealType weight = walker.Weight;
    std::vector<Value> sxgrid(nsamples_, 0.0);
    std::vector<Value> sygrid(nsamples_, 0.0);
    std::vector<Value> szgrid(nsamples_, 0.0);

    //Temporary variables to hold the integrated sx, sy, sz estimates.
    //These are overwritten as needed in the loop over particles.
    Value sx(0.0);
    Value sy(0.0);
    Value sz(0.0);

    const int np = pset.getTotalNum();
    assert(weight >= 0);

    walkers_weight_ += weight;
    for (int p = 0; p < np; ++p)
    {
      size_t sxindex = computeBin(pset.R[p], 0);
      generateSpinIntegrand(pset, wfn, p, sxgrid, sygrid, szgrid);
      sx = integrateMagnetizationDensity(sxgrid);
      sy = integrateMagnetizationDensity(sygrid);
      sz = integrateMagnetizationDensity(szgrid);

      data_[sxindex] += std::real(sx * weight);
      data_[sxindex + 1] += std::real(sy * weight);
      data_[sxindex + 2] += std::real(sz * weight);
    }
  }
};

collect()

void collect ( const RefVector< OperatorEstBase > &  oebs )

overridevirtual

Reduce estimator result data from crowds to rank.

This is assumed to be called from only from one thread per crowds->rank reduction. Implied is this is during a global sync or there is a guarantee that the crowd operator estimators accumulation data is not being written to.

There could be concurrent operations inside the scope of the collect call.

Reimplemented from OperatorEstBase.

Definition at line 91 of file MagnetizationDensity.cpp.

References OperatorEstBase::collect(), qmcplusplus::crowd, and OperatorEstBase::data_locality_.

{
  if (data_locality_ == DataLocality::crowd)
  {
    OperatorEstBase::collect(type_erased_operator_estimators);
  }
  else
  {
    throw std::runtime_error("You cannot call collect on MagnetizationDensity with this DataLocality");
  }
}

computeBin()

size_t computeBin ( const Position &  r, const unsigned int  component  ) const

private

For a given spatial position r and spin component s, this returns the bin for accumulating the observable.

Parameters

[in]	Position	in real space. 3D
[in]	component,the	x=0,y=1,z=2 component of the spin.

Returns

Index of appropriate bin for this position and spin component

Definition at line 103 of file MagnetizationDensity.cpp.

References QMCTraits::DIM, MagnetizationDensity::DIM, qmcplusplus::floor(), MagnetizationDensity::gdims_, MagnetizationDensity::grid_, MagnetizationDensity::lattice_, MagnetizationDensity::rcorner_, and CrystalLattice< T, D >::toUnit().

Referenced by MagnetizationDensity::accumulate(), and MagnetizationDensityTests::computeBinAccessor().

{
  assert(component < QMCT::DIM);
  QMCT::PosType u = lattice_.toUnit(r - rcorner_);
  size_t point    = 0; //This establishes the real space grid point.
  for (int d = 0; d < QMCT::DIM; ++d)
    point += gdims_[d] * ((int)(grid_[d] * (u[d] - std::floor(u[d])))); //periodic only

  //We now have the real space grid point.  For each grid point, we store sx[point],sy[point],sz[point].
  //Thus, the actual position in array is DIM*point+component.
  return DIM * point + component;
}

generateGrid()

void generateGrid ( std::vector< Real > &  sgrid ) const

private

Convenience function to generate a grid between 0 and 2pi, consistent with nsamples_ and integration method.

Can be uniform or random, depending on choice of integrator.

Parameters

[out]

sgrid

A grid with nsamples_ points between 0 and 2pi. Overwritten.

Definition at line 174 of file MagnetizationDensity.cpp.

References MagnetizationDensity::generateUniformGrid(), MagnetizationDensity::integrator_, MagnetizationDensityInput::MONTECARLO, MagnetizationDensity::nsamples_, and MagnetizationDensityInput::SIMPSONS.

Referenced by MagnetizationDensity::generateSpinIntegrand().

{
  sgrid.resize(nsamples_);
  Real start = 0.0;
  Real stop  = 2 * M_PI;

  switch (integrator_)
  {
  case Integrator::SIMPSONS:
    generateUniformGrid(sgrid, start, stop);
    break;
  case Integrator::MONTECARLO:
    throw std::runtime_error("Monte Carlo sampling not implemented yet");
    break;
  }
}

generateRandomGrid()

void generateRandomGrid ( std::vector< Real > &  sgrid, RandomBase< FullPrecReal > &  rng, Real  start, Real  stop  ) const

private

Generate random grid between [start,stop] for MC integration.

Template Parameters

RAN_GEN

Random number generator type.

Parameters

[out]	sgrid	Random number grid between "start" and "stop". Number of points taken from size of sgrid.
[in]	rng	Random number generator queried to generate random points.
[in]	start	start of grid interval
[in]	stop	end of grid interval

Definition at line 244 of file MagnetizationDensity.cpp.

Referenced by MagnetizationDensityTests::testGrids().

{
  size_t npoints = sgrid.size();
  for (int i = 0; i < npoints; i++)
    sgrid[i] = (stop - start) * rng();
}

generateSpinIntegrand()

void generateSpinIntegrand ( ParticleSet &  pset, TrialWaveFunction &  wfn, const int  iat, std::vector< Value > &  sx, std::vector< Value > &  sy, std::vector< Value > &  sz  )

private

Generates the spin integrand (s')/Psi(s)* s | {} | s' for a specific electron iat.

Since this is a vectorial quantity, this function returns sx, sy, and sz in their own arrays.

Parameters

[in]	pset	ParticleSet
[in]	wfn	TrialWaveFunction
[in]	iat	electron index
[out]	sx	x component of spin integrand
[out]	sy	y component of spin integrand
[out]	sz	z component of spin integrand

Definition at line 136 of file MagnetizationDensity.cpp.

References qmcplusplus::cos(), TrialWaveFunction::evaluateRatios(), MagnetizationDensity::generateGrid(), MagnetizationDensity::nsamples_, qmcplusplus::pset_target, and qmcplusplus::sin().

Referenced by MagnetizationDensity::accumulate().

{
  std::vector<Real> sgrid(nsamples_);
  std::vector<Real> ds(nsamples_, 0.0);
  std::vector<Value> ratios(nsamples_, 0);
  generateGrid(sgrid);
  for (int samp = 0; samp < nsamples_; samp++)
    ds[samp] = sgrid[samp] - pset_target.spins[iat];

  VirtualParticleSet vp(pset_target, nsamples_);
  std::vector<Position> dV(nsamples_, 0);
  vp.makeMovesWithSpin(pset_target, iat, dV, ds);
  psi_target.evaluateRatios(vp, ratios);

  const std::complex<Real> eye(0, 1.0);

  for (int samp = 0; samp < nsamples_; samp++)
  {
    sxgrid[samp] = std::real(Real(2.0) * Real(std::cos(sgrid[samp] + pset_target.spins[iat])) * ratios[samp]);
    sygrid[samp] = std::real(Real(2.0) * Real(std::sin(sgrid[samp] + pset_target.spins[iat])) * ratios[samp]);
    szgrid[samp] = std::real(Real(-2.0) * eye * std::sin(ds[samp]) * ratios[samp]);
  }
}

generateUniformGrid()

void generateUniformGrid ( std::vector< Real > &  sgrid, const Real  start, const Real  stop  ) const

private

Generate a uniform grid between [start,stop] for numerical quadrature.

Parameters

[out]	sgrid	Random number grid between "start" and "stop". Number of points taken from size of sgrid.
[in]	start	start of grid interval
[in]	stop	end of grid interval

Definition at line 166 of file MagnetizationDensity.cpp.

Referenced by MagnetizationDensity::generateGrid(), and MagnetizationDensityTests::testGrids().

{
  size_t num_gridpoints = sgrid.size();
  Real delta            = (stop - start) / (num_gridpoints - 1.0);
  for (int i = 0; i < num_gridpoints; i++)
    sgrid[i] = start + i * delta;
}

getFullDataSize()

size_t getFullDataSize

(

)

This returns the total size of data object required for this estimator.

Right now, it's 3*number_of_realspace_gridpoints

Returns

Size of data.

Definition at line 47 of file MagnetizationDensity.cpp.

References MagnetizationDensity::DIM, and MagnetizationDensity::npoints_.

Referenced by MagnetizationDensity::MagnetizationDensity(), and MagnetizationDensity::registerOperatorEstimator().

{ return npoints_ * DIM; }

integrateBySimpsonsRule()

MagnetizationDensity::Value integrateBySimpsonsRule ( const std::vector< Value > &  fgrid, Real  gridDx  ) const

private

Implementation of Simpson's 1/3 rule to integrate a function on a uniform grid.

Parameters

[in]	fgrid	f(x), the function to integrate.
[in]	gridDx,the	grid spacing for the uniform grid. Assumed to be consistent with size of fgrid.

Returns

Value of integral.

Definition at line 203 of file MagnetizationDensity.cpp.

Referenced by MagnetizationDensity::integrateMagnetizationDensity(), and MagnetizationDensityTests::testIntegrationFunctions().

{
  Value sint(0.0);
  int gridsize = fgrid.size();
  for (int is = 1; is < gridsize - 1; is += 2)
    sint += Real(4. / 3.) * gridDx * fgrid[is];

  for (int is = 2; is < gridsize - 1; is += 2)
    sint += Real(2. / 3.) * gridDx * fgrid[is];

  sint += Real(1. / 3.) * gridDx * fgrid[0];
  sint += Real(1. / 3.) * gridDx * fgrid[gridsize - 1];

  return sint;
}

integrateMagnetizationDensity()

MagnetizationDensity::Value integrateMagnetizationDensity

(

const std::vector< Value > &

fgrid

)

const

This is a convenience function that handles ^{2} dx f(x).

There are two provided methods for integrating this, so this function picks Simpson's or Monte Carlo to perform this integration, while keeping awareness of the integration interval and number of samples.

Template Parameters

Value

type. Real or complex in double or single precision. Return type is same as fgrid type.

Parameters

[in]

fgrid

f(x), the function to integrate. Assumed to be on a [0-2pi] interval, and if the grid isn't random, it's assumed to be uniform.

Returns

Value of integral.

Definition at line 220 of file MagnetizationDensity.cpp.

References MagnetizationDensity::integrateBySimpsonsRule(), MagnetizationDensity::integrator_, MagnetizationDensityInput::MONTECARLO, MagnetizationDensity::nsamples_, and MagnetizationDensityInput::SIMPSONS.

Referenced by MagnetizationDensity::accumulate().

{
  Real start  = 0.0;
  Real stop   = 2 * M_PI;
  Real deltax = (stop - start) / (nsamples_ - 1.0);
  Value val   = 0.0;
  switch (integrator_)
  {
  case Integrator::SIMPSONS:
    //There's a normalizing 2pi factor in this integral.  Take care of it here.
    val = integrateBySimpsonsRule(fgrid, deltax) / Real(2.0 * M_PI);

    break;
  case Integrator::MONTECARLO:
    //Integrand has form that can be monte carlo sampled.  This means the 2*PI
    //is taken care of if the integrand is uniformly sampled between [0,2PI),
    //which it is.  The following is just an average.
    val = std::accumulate(fgrid.begin(), fgrid.end(), Value(0));
    val /= Real(nsamples_);
    break;
  }
  return val;
}

registerOperatorEstimator()

void registerOperatorEstimator ( hdf_archive &  file )

overridevirtual

Reimplemented from OperatorEstBase.

Definition at line 191 of file MagnetizationDensity.cpp.

References MagnetizationDensity::getFullDataSize(), OperatorEstBase::h5desc_, OperatorEstBase::my_name_, qmcplusplus::oh, and ObservableHelper::set_dimensions().

{
  std::vector<size_t> my_indexes;

  std::vector<int> ng(1, getFullDataSize());

  hdf_path hdf_name{my_name_};
  h5desc_.emplace_back(hdf_name);
  auto& oh = h5desc_.back();
  oh.set_dimensions(ng, 0);
}

spawnCrowdClone()

std::unique_ptr< OperatorEstBase > spawnCrowdClone ( ) const

overridevirtual

Implements OperatorEstBase.

Definition at line 116 of file MagnetizationDensity.cpp.

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

{
  std::size_t data_size    = data_.size();
  auto spawn_data_locality = data_locality_;

  //Everyone else has this attempt to set up a non-implemented memory saving optimization.
  //We won't rock the boat.
  if (data_locality_ == DataLocality::rank)
  {
    // This is just a stub until a memory saving optimization is deemed necessary
    spawn_data_locality = DataLocality::queue;
    data_size           = 0;
    throw std::runtime_error("There is no memory savings implementation for MagnetizationDensity");
  }

  UPtr<MagnetizationDensity> spawn(std::make_unique<MagnetizationDensity>(*this, spawn_data_locality));
  spawn->get_data().resize(data_size);
  return spawn;
};

startBlock()

void startBlock ( int  steps )

overridevirtual

Implements OperatorEstBase.

Definition at line 45 of file MagnetizationDensity.cpp.

{};

Friends And Related Function Documentation

testing::MagnetizationDensityTests

friend class testing::MagnetizationDensityTests

friend

Definition at line 172 of file MagnetizationDensity.h.

Member Data Documentation

center_

Position center_

private

Definition at line 166 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::MagnetizationDensity(), and MagnetizationDensityTests::testCopyConstructor().

DIM

constexpr int DIM = QMCTraits::DIM

static

Definition at line 53 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::computeBin(), and MagnetizationDensity::getFullDataSize().

gdims_

TinyVector<int, DIM> gdims_

private

Definition at line 168 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::computeBin(), MagnetizationDensity::MagnetizationDensity(), and MagnetizationDensityTests::testCopyConstructor().

grid_

TinyVector<int, DIM> grid_

private

Definition at line 167 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::computeBin(), MagnetizationDensity::MagnetizationDensity(), and MagnetizationDensityTests::testCopyConstructor().

input_

MagnetizationDensityInput input_

private

Definition at line 161 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::MagnetizationDensity().

integrator_

Integrator integrator_

private

Definition at line 163 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::generateGrid(), MagnetizationDensity::integrateMagnetizationDensity(), MagnetizationDensity::MagnetizationDensity(), and MagnetizationDensityTests::testCopyConstructor().

lattice_

Lattice lattice_

private

Definition at line 164 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::computeBin(), and MagnetizationDensity::MagnetizationDensity().

npoints_

size_t npoints_

private

Definition at line 169 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::getFullDataSize(), and MagnetizationDensity::MagnetizationDensity().

nsamples_

int nsamples_

private

Definition at line 170 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::accumulate(), MagnetizationDensity::generateGrid(), MagnetizationDensity::generateSpinIntegrand(), MagnetizationDensity::integrateMagnetizationDensity(), MagnetizationDensity::MagnetizationDensity(), and MagnetizationDensityTests::testCopyConstructor().

rcorner_

Position rcorner_

private

Definition at line 165 of file MagnetizationDensity.h.

Referenced by MagnetizationDensity::computeBin(), MagnetizationDensity::MagnetizationDensity(), and MagnetizationDensityTests::testCopyConstructor().

---

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

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