NESpaceGrid< REAL > Class Template Reference

Collaboration diagram for NESpaceGrid< REAL >:

Classes
struct	IRPair

Public Types
enum	ReferenceEnergy { vacuum, neutral, noref }
using	Real = REAL
using	Point = typename NEReferencePoints::Point
using	Points = typename NEReferencePoints::Points
using	BufferType = PooledData< Real >
using	POLT = PtclOnLatticeTraits
using	ParticlePos = POLT::ParticlePos
using	AxTensor = Tensor< Real, OHMMS_DIM >

Public Member Functions
	NESpaceGrid (SpaceGridInput &sgi, const Points &points, const int nvalues, const bool is_periodic)
	This constructor is used for electron only grids. More...
	NESpaceGrid (SpaceGridInput &sgi, const Points &points, const int ndp, const int nvalues, const bool is_periodic)
	This is the general constructor. More...
	NESpaceGrid (SpaceGridInput &sgi, const Points &points, ParticlePos &static_particle_positions, std::vector< Real > &static_particle_charges, const int ndp, const int nvalues, const bool is_periodic)
	This is the constructor for when PStatic is used. More...
	NESpaceGrid (const NESpaceGrid &sg)=default
NESpaceGrid &	operator= (const NESpaceGrid &sg)=default
void	write_description (std::ostream &os, const std::string &indent)
void	registerGrid (hdf_archive &file, int grid_index)
	set up Observable helper(s) for this grid almost unchanged from legacy More...
void	write (hdf_archive &file) const
void	accumulate (const ParticlePos &R, const Matrix< Real > &values, std::vector< bool > &particles_outside)
void	accumulate (const ParticlePos &R, const Matrix< Real > &values, std::vector< bool > &particles_outside, const DistanceTableAB &dtab)
	SpaceGridAccumulate not type erased and with its own particular interface. More...
bool	check_grid (void)
int	nDomains (void) const
void	sum (const BufferType &buf, Real *vals)
auto &	getDataVector ()

Static Public Member Functions
static void	collect (NESpaceGrid &reduction_grid, RefVector< NESpaceGrid > grid_for_each_crowd)

Private Member Functions
void	copyToSoA ()
	copy AxisGrid data to SoA layout for evaluation More...
void	zero ()
bool	initializeCoordSystem ()
	dispatch to correct initialize for coord type More...
bool	initializeRectilinear (const SpaceGridInput &input, const Points &points)
	Initialize NESpaceGrid for rectilinear grid. More...
bool	initializeCylindrical (const SpaceGridInput &input, const Points &points)
	Initialize NESpaceGrid for cylindrical grid. More...
bool	initializeSpherical (const SpaceGridInput &input, const Points &points)
	Initialize NESpaceGrid for cylindrical grid. More...
void	someMoreAxisGridStuff ()
	Initialize NESpaceGrid for voronoi grid. More...

Static Private Member Functions
static Point	deriveOrigin (const SpaceGridInput &input, const Points &points)
	return actual origin point based on input More...
static void	processAxis (const SpaceGridInput &input, const Points &points, AxTensor &axes, AxTensor &axinv)
	create axes and axinv tensors More...

Private Attributes
SpaceGridInput &	input_
	refrence points for the space grid this reference it to the EstimatorManagers EDE's spacegrid_inputs_ More...
int	ndparticles_
bool	is_periodic_
const Points &	points_
	refrence points for the space grid this reference is to the EstimatorManagers EDE's reference points More...
int	buffer_start_
int	buffer_end_
const int	buffer_offset_ {0}
	in legacy used to be the starting index into the collectibles buffer. More...
int	ndomains_ {1}
int	nvalues_per_domain_
Real	volume_
Matrix< Real >	domain_uwidths_
std::string	axlabel_ [OHMMS_DIM]
std::array< std::vector< int >, 3 >	gmap_
Real	odu_ [OHMMS_DIM]
Real	umin_ [OHMMS_DIM]
Real	umax_ [OHMMS_DIM]
int	dm_ [OHMMS_DIM]
ReferenceEnergy	reference_energy_
std::vector< Real >	data_
std::shared_ptr< ObservableHelper >	observable_helper_
std::vector< IRPair >	nearcell_
Matrix< Real >	domain_volumes_
	These are calculated by NESpaceGrid before accumulation and possibly belong in SpaceGridInput as derived inputs. More...
Matrix< Real >	domain_centers_
Point	origin_
AxTensor	axes_
AxTensor	axinv_

Friends
template<typename T >
class	testing::NESpaceGridTests

Detailed Description

template<typename REAL>
class qmcplusplus::NESpaceGrid< REAL >

Definition at line 52 of file NESpaceGrid.h.

---

Class Documentation

qmcplusplus::NESpaceGrid::IRPair

struct qmcplusplus::NESpaceGrid::IRPair

template<typename REAL>
struct qmcplusplus::NESpaceGrid< REAL >::IRPair

Definition at line 259 of file NESpaceGrid.h.

Collaboration diagram for NESpaceGrid< REAL >::IRPair:

Class Members
int	i
Real	r

Member Typedef Documentation

AxTensor

using AxTensor = Tensor<Real, OHMMS_DIM>

Definition at line 61 of file NESpaceGrid.h.

BufferType

using BufferType = PooledData<Real>

Definition at line 58 of file NESpaceGrid.h.

ParticlePos

using ParticlePos = POLT::ParticlePos

Definition at line 60 of file NESpaceGrid.h.

Point

using Point = typename NEReferencePoints::Point

Definition at line 56 of file NESpaceGrid.h.

Points

using Points = typename NEReferencePoints::Points

Definition at line 57 of file NESpaceGrid.h.

POLT

using POLT = PtclOnLatticeTraits

Definition at line 59 of file NESpaceGrid.h.

Real

using Real = REAL

Definition at line 55 of file NESpaceGrid.h.

Member Enumeration Documentation

ReferenceEnergy

enum ReferenceEnergy

strong

Enumerator
vacuum
neutral
noref

Definition at line 62 of file NESpaceGrid.h.

  {
    vacuum,
    neutral,
    noref
  };

Constructor & Destructor Documentation

NESpaceGrid() [1/4]

NESpaceGrid	(	SpaceGridInput &	sgi,
		const Points &	points,
		const int	nvalues,
		const bool	is_periodic
	)

This constructor is used for electron only grids.

Parameters

[in]	sgi	input object for space grid.
[in]	reference	reference points from which origin and on other reference points referenced in input object are to be found
[in]	nvalues	number of fields the owning class wants for each grid point.
[in]	is_periodic	properly names is what is says

NESpaceGrid() [2/4]

NESpaceGrid	(	SpaceGridInput &	sgi,
		const Points &	points,
		const int	ndp,
		const int	nvalues,
		const bool	is_periodic
	)

This is the general constructor.

Parameters

[in]	sgi	input object for space grid.
[in]	reference	reference points from which origin and on other reference points referenced in input object are to be found
[in]	ndp	number of particles that can move
[in]	nvalues	number of fields the owning class wants for each grid point.
[in]	is_periodic	properly names is what is says

NESpaceGrid() [3/4]

NESpaceGrid	(	SpaceGridInput &	sgi,
		const Points &	points,
		ParticlePos &	static_particle_positions,
		std::vector< Real > &	static_particle_charges,
		const int	ndp,
		const int	nvalues,
		const bool	is_periodic
	)

This is the constructor for when PStatic is used.

NESpaceGrid() [4/4]

NESpaceGrid ( const NESpaceGrid< REAL > &  sg )

default

Member Function Documentation

accumulate() [1/2]

void accumulate	(	const ParticlePos &	R,
		const Matrix< Real > &	values,
		std::vector< bool > &	particles_outside
	)

Definition at line 583 of file NESpaceGrid.cpp.

References qmcplusplus::acos(), qmcplusplus::app_log(), qmcplusplus::atan2(), qmcplusplus::dot(), error(), qmcplusplus::floor(), OHMMS_DIM, Matrix< T, Alloc >::size1(), Matrix< T, Alloc >::size2(), and qmcplusplus::sqrt().

{
  int p, v;
  int nparticles = values.size1();
  int nvalues    = values.size2();
  int iu[OHMMS_DIM];
  int buf_index;
  const Real o2pi = 1.0 / (2.0 * M_PI);
  using CoordForm = SpaceGridInput::CoordForm;
  auto& agr       = input_.get_axis_grids();
  std::fill(particles_outside.begin(),particles_outside.end(), true);
  
  switch (input_.get_coord_form())
  {
  case CoordForm::CARTESIAN:
    if (input_.isPeriodic())
    {
      for (p = 0; p < nparticles; p++)
      {
        particles_outside[p] = false;
        Point u              = dot(axinv_, (R[p] - origin_));
        try
        {
          for (int d = 0; d < OHMMS_DIM; ++d)
            iu[d] = gmap_[d].at(floor((u[d] - umin_[d]) * odu_[d]));
        }
        catch (const std::exception& exc)
        {
          std::ostringstream error;
          error << "NESpaceGrid: particle: " << p << " position: " << R[p]
                << " falls outside of the cell, for a period system all particle positions must be in the cell!\n";
          std::throw_with_nested(std::runtime_error(error.str()));
        }
        buf_index = buffer_offset_;
        for (int d = 0; d < OHMMS_DIM; ++d)
          buf_index += nvalues * dm_[d] * iu[d];
        for (v = 0; v < nvalues; v++, buf_index++)
          data_[buf_index] += values(p, v);
      }
    }
    else
    {
      for (p = 0; p < nparticles; p++)
      {
        Point u = dot(axinv_, (R[p] - origin_));
        if (u[0] > umin_[0] && u[0] < umax_[0] && u[1] > umin_[1] && u[1] < umax_[1] && u[2] > umin_[2] &&
            u[2] < umax_[2])
        {
          particles_outside[p] = false;
          iu[0]                = gmap_[0][floor((u[0] - umin_[0]) * odu_[0])];
          iu[1]                = gmap_[1][floor((u[1] - umin_[1]) * odu_[1])];
          iu[2]                = gmap_[2][floor((u[2] - umin_[2]) * odu_[2])];
          buf_index            = buffer_offset_ + nvalues * (dm_[0] * iu[0] + dm_[1] * iu[1] + dm_[2] * iu[2]);
          for (v = 0; v < nvalues; v++, buf_index++)
            data_[buf_index] += values(p, v);
        }
      }
    }
    break;
  case CoordForm::CYLINDRICAL:
    for (p = 0; p < nparticles; p++)
    {
      Point ub = dot(axinv_, (R[p] - origin_));
      Point u{sqrt(ub[0] * ub[0] + ub[1] * ub[1]), static_cast<Real>(atan2(ub[1], ub[0]) * o2pi + .5), ub[2]};
      if (u[0] > umin_[0] && u[0] < umax_[0] && u[1] > umin_[1] && u[1] < umax_[1] && u[2] > umin_[2] &&
          u[2] < umax_[2])
      {
        particles_outside[p] = false;
        iu[0]                = gmap_[0][floor((u[0] - umin_[0]) * odu_[0])];
        iu[1]                = gmap_[1][floor((u[1] - umin_[1]) * odu_[1])];
        iu[2]                = gmap_[2][floor((u[2] - umin_[2]) * odu_[2])];
        buf_index            = buffer_offset_ + nvalues * (dm_[0] * iu[0] + dm_[1] * iu[1] + dm_[2] * iu[2]);
        for (v = 0; v < nvalues; v++, buf_index++)
          data_[buf_index] += values(p, v);
      }
    }
    break;
  case CoordForm::SPHERICAL:
    for (p = 0; p < nparticles; p++)
    {
      Point ub = dot(axinv_, (R[p] - origin_));
      Point u;
      u[0] = sqrt(ub[0] * ub[0] + ub[1] * ub[1] + ub[2] * ub[2]);
      u[1] = atan2(ub[1], ub[0]) * o2pi + .5;
      u[2] = acos(ub[2] / u[0]) * o2pi * 2.0;
      if (u[0] > umin_[0] && u[0] < umax_[0] && u[1] > umin_[1] && u[1] < umax_[1] && u[2] > umin_[2] &&
          u[2] < umax_[2])
      {
        particles_outside[p] = false;
        iu[0]                = gmap_[0][floor((u[0] - umin_[0]) * odu_[0])];
        iu[1]                = gmap_[1][floor((u[1] - umin_[1]) * odu_[1])];
        iu[2]                = gmap_[2][floor((u[2] - umin_[2]) * odu_[2])];
        buf_index            = buffer_offset_ + nvalues * (dm_[0] * iu[0] + dm_[1] * iu[1] + dm_[2] * iu[2]);
        for (v = 0; v < nvalues; v++, buf_index++)
          data_[buf_index] += values(p, v);
      }
    }
    break;
  default:
    app_log() << "  coordinate type must be cartesian, cylindrical, spherical" << std::endl;
    throw std::runtime_error("SpaceGrid<REAL>::evaluate received an invalid coordinate type");
  }
}

accumulate() [2/2]

void accumulate	(	const ParticlePos &	R,
		const Matrix< Real > &	values,
		std::vector< bool > &	particles_outside,
		const DistanceTableAB &	dtab
	)

SpaceGridAccumulate not type erased and with its own particular interface.

the composing class needs to provide the following to spave grid.

Parameters

[in]	R	particle positions
[in]	values	matrix indexed particle, value
	[in/out]	buf buffer to accumulating grid to
[out]	particles_outside	mask vector of particles falling outside the grid box
[in]	dtab	particle A to Particle B distance table

right now cartesian grids are all accumulated as if they were "periodic" which honestly does not seem to be well defined with repsect to these grids. But for the particle cell itself it doesn't make sense that it be periodic unless it is exactly comenserate with the particle cell (at least IMHO)

Definition at line 543 of file NESpaceGrid.cpp.

{
  // //find cell center nearest to each dynamic particle
  // int nd, nn;
  // RealType dist;
  // for (p = 0; p < ndparticles; p++)
  // {
  //   const auto& dist = dtab.getDistRow(p);
  //   for (nd = 0; nd < ndomains; nd++)
  //     if (dist[nd] < nearcell[p].r)
  //     {
  //       nearcell[p].r = dist[nd];
  //       nearcell[p].i = nd;
  //     }
  // }
  // //accumulate values for each dynamic particle
  // for (p = 0; p < ndparticles; p++)
  // {
  //   buf_index = buffer_offset + nvalues * nearcell[p].i;
  //   for (v = 0; v < nvalues; v++, buf_index++)
  //     buf[buf_index] += values(p, v);
  // }
  // //accumulate values for static particles (static particles == cell centers)
  // buf_index = buffer_offset;
  // for (p = ndparticles; p < nparticles; p++)
  //   for (v = 0; v < nvalues; v++, buf_index++)
  //     buf[buf_index] += values(p, v);
  // //each particle belongs to some voronoi cell
  // for (p = 0; p < nparticles; p++)
  //   particles_outside[p] = false;
  // //reset distances
  // for (p = 0; p < ndparticles; p++)
  //   nearcell[p].r = std::numeric_limits<RealType>::max();
  accumulate(R, values, particles_outside);
}

check_grid()

bool check_grid

(

void

)

Definition at line 723 of file NESpaceGrid.cpp.

References qmcplusplus::acos(), qmcplusplus::app_log(), qmcplusplus::atan2(), qmcplusplus::dot(), qmcplusplus::floor(), OHMMS_DIM, and qmcplusplus::sqrt().

{
  app_log() << "SpaceGrid<REAL>::check_grid" << std::endl;
  const Real o2pi = 1.0 / (2.0 * M_PI);
  int iu[OHMMS_DIM];
  int idomain;
  bool ok = true;
  Point dc;
  auto& agr = input_.get_axis_grids();
  for (int i = 0; i < ndomains_; i++)
  {
    for (int d = 0; d < OHMMS_DIM; d++)
      dc[d] = domain_centers_(i, d);
    Point ub = dot(axinv_, (dc - origin_));
    Point u;
    using CoordForm = SpaceGridInput::CoordForm;
    switch (input_.get_coord_form())
    {
    case CoordForm::CARTESIAN:
      u = ub;
      break;
    case CoordForm::CYLINDRICAL:
      u[0] = sqrt(ub[0] * ub[0] + ub[1] * ub[1]);
      u[1] = atan2(ub[1], ub[0]) * o2pi + .5;
      u[2] = ub[2];
      break;
    case CoordForm::SPHERICAL:
      u[0] = sqrt(ub[0] * ub[0] + ub[1] * ub[1] + ub[2] * ub[2]);
      u[1] = atan2(ub[1], ub[0]) * o2pi + .5;
      u[2] = acos(ub[2] / u[0]) * o2pi * 2.0;
      break;
    default:
      break;
    }
    iu[0]   = gmap_[0][floor((u[0] - agr[0].umin) * odu_[0])];
    iu[1]   = gmap_[1][floor((u[1] - agr[1].umin) * odu_[1])];
    iu[2]   = gmap_[2][floor((u[2] - agr[2].umin) * odu_[2])];
    idomain = dm_[0] * iu[0] + dm_[1] * iu[1] + dm_[2] * iu[2];
    if (idomain != i)
    {
      app_log() << "  cell mismatch " << i << " " << idomain << std::endl;
      ok = false;
    }
  }
  if (!ok)
  {
    app_log() << "  NESpaceGrid cells do not map onto themselves" << std::endl;
  }
  app_log() << "end NESpaceGrid<REAL>::check_grid" << std::endl;
  return ok;
}

collect()

void collect ( NESpaceGrid< REAL > &  reduction_grid, RefVector< NESpaceGrid< REAL > >  grid_for_each_crowd  )

static

Definition at line 706 of file NESpaceGrid.cpp.

References NESpaceGrid< REAL >::data_.

{
  for (NESpaceGrid& crowd_grid : grid_for_each_crowd)
  {
    std::transform(reduction_grid.data_.begin(), reduction_grid.data_.end(), crowd_grid.data_.begin(),
                   reduction_grid.data_.begin(), std::plus<>{});
    crowd_grid.zero();
  }
}

copyToSoA()

void copyToSoA ( )

private

copy AxisGrid data to SoA layout for evaluation

Definition at line 529 of file NESpaceGrid.cpp.

References qmcplusplus::floor(), and OHMMS_DIM.

{
  auto& agr = input_.get_axis_grids();
  for (int id = 0; id < OHMMS_DIM; ++id)
  {
    odu_[id]  = agr[id].odu;
    umin_[id] = agr[id].umin;
    umax_[id] = agr[id].umax;
    gmap_[id].resize(floor((umax_[id] - umin_[id]) * odu_[id] + .5));
    gmap_[id] = agr[id].gmap;
  }
}

deriveOrigin()

NESpaceGrid< REAL >::Point deriveOrigin ( const SpaceGridInput &  input, const Points &  points  )

staticprivate

return actual origin point based on input

Definition at line 110 of file NESpaceGrid.cpp.

{
  const std::string& origin_p1 = input.get_origin_p1();
  const std::string& origin_p2 = input.get_origin_p2();

  if (origin_p1.size() > 0 && origin_p2.size() > 0)
  {
    return points.at(origin_p1) + input.get_origin_fraction() * (points.at(origin_p2) - points.at(origin_p1));
  }
  else if (origin_p1.size() > 0)
    return points.at(origin_p1);
  else
    return points.at("zero");
}

getDataVector()

auto& getDataVector ( )

inline

Definition at line 138 of file NESpaceGrid.h.

References NESpaceGrid< REAL >::data_.

{ return data_; }

initializeCoordSystem()

bool initializeCoordSystem ( )

private

dispatch to correct initialize for coord type

Definition at line 71 of file NESpaceGrid.cpp.

{
  using CoordForm   = SpaceGridInput::CoordForm;
  bool init_success = false;
  switch (input_.get_coord_form())
  {
  case (CoordForm::CARTESIAN):
    init_success = initializeRectilinear(input_, points_);
    break;
  case (CoordForm::CYLINDRICAL):
    init_success = initializeCylindrical(input_, points_);
    break;
  case (CoordForm::SPHERICAL):
    init_success = initializeSpherical(input_, points_);
    break;
  }
  return init_success;
}

initializeCylindrical()

bool initializeCylindrical ( const SpaceGridInput &  input, const Points &  points  )

private

Initialize NESpaceGrid for cylindrical grid.

Parameters

[in]	input	SpaceGridInput object
[in]	points	ReferencePoints object for grid Causes side effects updating origin_ fixed up origin for grid axes_ axes with scaling applied to it. axinv_ the inverse of the axes with scaling applied

Definition at line 145 of file NESpaceGrid.cpp.

{
  // This code should be refactored to SpaceGridInput such that a simple map of
  // axis is available.

  origin_ = deriveOrigin(input, points);
  processAxis(input, points, axes_, axinv_);
  // bool succeeded = checkAxisGridValues(input, axes_);

  someMoreAxisGridStuff();

  copyToSoA();

  return true;
}

initializeRectilinear()

bool initializeRectilinear ( const SpaceGridInput &  input, const Points &  points  )

private

Initialize NESpaceGrid for rectilinear grid.

Parameters

[in]	input	SpaceGridInput object
[in]	points	ReferencePoints object for grid Causes side effects updating origin_ fixed up origin for grid axes_ axes with scaling applied to it. axinv_ the inverse of the axes with scaling applied

Definition at line 126 of file NESpaceGrid.cpp.

{
  // This code should be refactored to SpaceGridInput such that a simple map of
  // axis is available.

  origin_ = deriveOrigin(input, points);
  processAxis(input, points, axes_, axinv_);

  // this should all be done in SpaceGrid input parsing/construction now.
  // bool succeeded = checkAxisGridValues(input, axes_);

  someMoreAxisGridStuff();

  copyToSoA();

  return true;
}

initializeSpherical()

bool initializeSpherical ( const SpaceGridInput &  input, const Points &  points  )

private

Initialize NESpaceGrid for cylindrical grid.

Parameters

[in]	input	SpaceGridInput object
[in]	points	ReferencePoints object for grid Causes side effects updating origin_ fixed up origin for grid axes_ axes with scaling applied to it. axinv_ the inverse of the axes with scaling applied

Definition at line 162 of file NESpaceGrid.cpp.

{
  // This code should be refactored to SpaceGridInput such that a simple map of
  // axis is available.

  origin_ = deriveOrigin(input, points);
  processAxis(input, points, axes_, axinv_);
  //bool succeeded = checkAxisGridValues(input, axes_);

  someMoreAxisGridStuff();

  copyToSoA();

  return true;
}

nDomains()

int nDomains ( void  ) const

inline

Definition at line 132 of file NESpaceGrid.h.

References NESpaceGrid< REAL >::ndomains_.

{ return ndomains_; }

operator=()

NESpaceGrid& operator= ( const NESpaceGrid< REAL > &  sg )

default

processAxis()

void processAxis ( const SpaceGridInput &  input, const Points &  points, AxTensor &  axes, AxTensor &  axinv  )

staticprivate

create axes and axinv tensors

Parameters

[in]	input	space grid input
[out]	axes
[out]	axinv

Definition at line 91 of file NESpaceGrid.cpp.

References qmcplusplus::inverse(), and OHMMS_DIM.

{
  auto& axis_labels = input.get_axis_labels();
  auto& axis_p1s    = input.get_axis_p1s();
  auto& axis_p2s    = input.get_axis_p2s();
  auto& axis_scales = input.get_axis_scales();
  auto& axis_grids  = input.get_axis_grids();

  // SpaceGridInput check particular validity insures the number of axis == OHMMS_DIM
  for (int iaxis = 0; iaxis < OHMMS_DIM; ++iaxis)
  {
    Real frac = axis_scales[iaxis];
    for (int d = 0; d < OHMMS_DIM; d++)
      axes(d, iaxis) = frac * (points.at(axis_p1s[iaxis])[d] - points.at(axis_p2s[iaxis])[d]);
  }
  axinv = inverse(axes);
}

registerGrid()

void registerGrid	(	hdf_archive &	file,
		int	grid_index
	)

set up Observable helper(s) for this grid almost unchanged from legacy

Todo:

uses Observable helper unpleasantly in implementation, remove

Definition at line 396 of file NESpaceGrid.cpp.

References ObservableHelper::addProperty(), qmcplusplus::hdf::coord, qmcplusplus::int2string(), qmcplusplus::n, qmcplusplus::oh, OHMMS_DIM, Matrix< T, Alloc >::resize(), and ObservableHelper::set_dimensions().

{
  using iMatrix = Matrix<int>;
  iMatrix imat;
  std::vector<int> ng(1);
  int cshift = 1;
  std::stringstream ss;
  ss << grid_index + cshift;
  hdf_path hdf_name{"spacegrid" + ss.str()};
  observable_helper_ = std::make_shared<ObservableHelper>(hdf_name);
  auto& oh           = *observable_helper_;
  ng[0]              = nvalues_per_domain_ * ndomains_;
  oh.set_dimensions(ng, buffer_offset_);

  // Create a bunch of temporary SoA data from input to write the grid attributes
  auto& agr = input_.get_axis_grids();
  std::vector<int> dimensions(OHMMS_DIM);
  for (int id = 0; id < OHMMS_DIM; ++id)
  {
    dimensions[id] = agr[id].dimensions;
  }

  int coord = static_cast<int>(input_.get_coord_form());
  oh.addProperty(const_cast<int&>(coord), "coordinate", file);
  oh.addProperty(const_cast<int&>(ndomains_), "ndomains", file);
  oh.addProperty(const_cast<int&>(nvalues_per_domain_), "nvalues_per_domain_", file);
  oh.addProperty(const_cast<Real&>(volume_), "volume", file);
  oh.addProperty(const_cast<Matrix<Real>&>(domain_volumes_), "domain_volumes", file);
  oh.addProperty(const_cast<Matrix<Real>&>(domain_centers_), "domain_centers", file);
  oh.addProperty(const_cast<Point&>(origin_), "origin", file);
  oh.addProperty(const_cast<Tensor<Real, OHMMS_DIM>&>(axes_), "axes", file);
  oh.addProperty(const_cast<Tensor<Real, OHMMS_DIM>&>(axinv_), "axinv", file);
  oh.addProperty(const_cast<Matrix<Real>&>(domain_uwidths_), "domain_uwidths", file);
  //add dimensioned quantities
  std::map<std::string, int> axtmap;
  axtmap["x"]     = 0;
  axtmap["y"]     = 1;
  axtmap["z"]     = 2;
  axtmap["r"]     = 0;
  axtmap["phi"]   = 1;
  axtmap["theta"] = 2;
  int axtypes[OHMMS_DIM];
  auto& axis_labels = input_.get_axis_labels();
  for (int d = 0; d < OHMMS_DIM; d++)
  {
    axtypes[d] = axtmap[axis_labels[d]];
  }
  int n;
  const int ni = 3;
  // Now we arrive to a bunch of pointers to pointers that assume that all the axis grid
  // information is laid out soa versus aos
  int* ivar[ni];
  std::string iname[ni];
  n        = 0;
  ivar[n]  = (int*)axtypes;
  iname[n] = "axtypes";
  n++;
  ivar[n]  = dimensions.data();
  iname[n] = "dimensions";
  n++;
  ivar[n]  = (int*)dm_;
  iname[n] = "dm";
  n++;
  const int nr = 3;
  Real* rvar[nr];
  std::string rname[nr];
  n        = 0;
  rvar[n]  = (Real*)odu_;
  rname[n] = "odu";
  n++;
  rvar[n]  = (Real*)umin_;
  rname[n] = "umin";
  n++;
  rvar[n]  = (Real*)umax_;
  rname[n] = "umax";
  n++;
  imat.resize(OHMMS_DIM, 1);
  for (int i = 0; i < ni; i++)
  {
    for (int d = 0; d < OHMMS_DIM; d++)
      imat(d, 0) = ivar[i][d];
    oh.addProperty(const_cast<iMatrix&>(imat), iname[i], file);
  }
  Matrix<Real> rmat;
  rmat.resize(OHMMS_DIM, 1);
  for (int i = 0; i < nr; i++)
  {
    for (int d = 0; d < OHMMS_DIM; d++)
      rmat(d, 0) = rvar[i][d];
    oh.addProperty(const_cast<Matrix<Real>&>(rmat), rname[i], file);
  }
  for (int d = 0; d < OHMMS_DIM; d++)
  {
    int gsize = gmap_[d].size();
    imat.resize(gsize, 1);
    for (int i = 0; i < gsize; i++)
    {
      int gval   = gmap_[d][i];
      imat(i, 0) = gval;
    }
    int ival           = d + 1;
    std::string gmname = "gmap" + int2string(ival);
    oh.addProperty(const_cast<iMatrix&>(imat), gmname, file);
  }
  return;
}

someMoreAxisGridStuff()

void someMoreAxisGridStuff ( )

private

Initialize NESpaceGrid for voronoi grid.

Parameters

[in]	input	SpaceGridInput object
[in]	points	ReferencePoints object for grid
[in]	rs_static	Initial static particle positions Causes side effects updating origin_ fixed up origin for grid axes_ axes with scaling applied to it. axinv_ the inverse of the axes with scaling applied Another function to cut scopes to sort of manageable size. does nothing but create many side effects

Definition at line 179 of file NESpaceGrid.cpp.

References qmcplusplus::abs(), qmcplusplus::app_log(), qmcplusplus::cos(), qmcplusplus::det(), qmcplusplus::dot(), OHMMS_DIM, and qmcplusplus::sin().

{
  auto& axis_grids = input_.get_axis_grids();
  // This dates back to the legacy implementation and I'm not sure why both code blocks are here.
  //set grid dimensions
  // C/Python style indexing
  dm_[0] = axis_grids[1].dimensions * axis_grids[2].dimensions;
  dm_[1] = axis_grids[2].dimensions;
  dm_[2] = 1;
  // Fortran/Matlab style indexing
  //dm[0] = 1;
  //dm[1] = dimensions[0];
  //dm[2] = dimensions[0]*dimensions[1];

  ndomains_ = axis_grids[0].dimensions * axis_grids[1].dimensions * axis_grids[2].dimensions;

  data_.resize(ndomains_ * nvalues_per_domain_);

  volume_ = std::abs(det(axes_)) * 8.0; //axes span only one octant
  //compute domain volumes, centers, and widths

  domain_volumes_.resize(ndomains_, 1);
  domain_centers_.resize(ndomains_, OHMMS_DIM);
  domain_uwidths_.resize(ndomains_, OHMMS_DIM);
  std::vector<Real> interval_centers[OHMMS_DIM];
  std::vector<Real> interval_widths[OHMMS_DIM];

  auto& agr = axis_grids;

  for (int d = 0; d < OHMMS_DIM; d++)
  {
    int nintervals = agr[d].ndu_per_interval.size();
    app_log() << "nintervals " << d << " " << nintervals << std::endl;
    interval_centers[d].resize(nintervals);
    interval_widths[d].resize(nintervals);
    interval_widths[d][0]  = agr[d].ndu_per_interval[0] / agr[d].odu;
    interval_centers[d][0] = interval_widths[d][0] / 2.0 + agr[d].umin;
    for (int i = 1; i < nintervals; i++)
    {
      interval_widths[d][i]  = agr[d].ndu_per_interval[i] / agr[d].odu;
      interval_centers[d][i] = interval_centers[d][i - 1] + .5 * (interval_widths[d][i] + interval_widths[d][i - 1]);
    }
    //app_log()<<"  interval widths"<< std::endl;
    //for(int i=0;i<nintervals;i++)
    //  app_log()<<"    "<<i<<" "<<interval_widths[d][i]<< std::endl;
    //app_log()<<"  interval centers"<< std::endl;
    //for(int i=0;i<nintervals;i++)
    //  app_log()<<"    "<<i<<" "<<interval_centers[d][i]<< std::endl;
  }
  Point du, uc, ubc, rc;
  Real vol        = 0.0;
  Real vscale     = std::abs(det(axes_));
  using CoordForm = SpaceGridInput::CoordForm;
  for (int i = 0; i < agr[0].dimensions; i++)
  {
    for (int j = 0; j < agr[1].dimensions; j++)
    {
      for (int k = 0; k < agr[2].dimensions; k++)
      {
        int idomain = dm_[0] * i + dm_[1] * j + dm_[2] * k;
        du[0]       = interval_widths[0][i];
        du[1]       = interval_widths[1][j];
        du[2]       = interval_widths[2][k];
        uc[0]       = interval_centers[0][i];
        uc[1]       = interval_centers[1][j];
        uc[2]       = interval_centers[2][k];
        switch (input_.get_coord_form())
        {
        case (CoordForm::CARTESIAN):
          vol = du[0] * du[1] * du[2];
          ubc = uc;
          break;
        case (CoordForm::CYLINDRICAL):
          uc[1]  = 2.0 * M_PI * uc[1] - M_PI;
          du[1]  = 2.0 * M_PI * du[1];
          vol    = uc[0] * du[0] * du[1] * du[2];
          ubc[0] = uc[0] * cos(uc[1]);
          ubc[1] = uc[0] * sin(uc[1]);
          ubc[2] = uc[2];
          break;
        case (CoordForm::SPHERICAL):
          uc[1] = 2.0 * M_PI * uc[1] - M_PI;
          du[1] = 2.0 * M_PI * du[1];
          uc[2] = M_PI * uc[2];
          du[2] = M_PI * du[2];
          vol   = (uc[0] * uc[0] + du[0] * du[0] / 12.0) * du[0] //r
              * du[1]                                            //theta
              * 2.0 * sin(uc[2]) * sin(.5 * du[2]);              //phi
          ubc[0] = uc[0] * sin(uc[2]) * cos(uc[1]);
          ubc[1] = uc[0] * sin(uc[2]) * sin(uc[1]);
          ubc[2] = uc[0] * cos(uc[2]);
          break;
        default:
          break;
        }
        vol *= vscale;
        rc = dot(axes_, ubc) + origin_;
        //app_log()<< std::endl;
        //app_log()<<"umin "<<uc-du/2<< std::endl;
        //app_log()<<"uc "<<uc<< std::endl;
        //app_log()<<"umax "<<uc+du/2<< std::endl;
        //app_log()<<"rc "<<rc<< std::endl;
        domain_volumes_(idomain, 0) = vol;
        for (int d = 0; d < OHMMS_DIM; d++)
        {
          domain_uwidths_(idomain, d) = du[d];
          domain_centers_(idomain, d) = rc[d];
        }
      }
    }
  }

  //find the actual volume of the grid
  for (int d = 0; d < OHMMS_DIM; d++)
  {
    du[d] = agr[d].umax - agr[d].umin;
    uc[d] = .5 * (agr[d].umax + agr[d].umin);
  }
  switch (input_.get_coord_form())
  {
  case CoordForm::CARTESIAN:
    vol = du[0] * du[1] * du[2];
    break;
  case CoordForm::CYLINDRICAL:
    uc[1] = 2.0 * M_PI * uc[1] - M_PI;
    du[1] = 2.0 * M_PI * du[1];
    vol   = uc[0] * du[0] * du[1] * du[2];
    break;
  case CoordForm::SPHERICAL:
    uc[1] = 2.0 * M_PI * uc[1] - M_PI;
    du[1] = 2.0 * M_PI * du[1];
    uc[2] = M_PI * uc[2];
    du[2] = M_PI * du[2];
    vol   = (uc[0] * uc[0] + du[0] * du[0] / 12.0) * du[0] //r
        * du[1]                                            //theta
        * 2.0 * sin(uc[2]) * sin(.5 * du[2]);              //phi
    break;
  default:
    break;
  }
  volume_ = vol * det(axes_);

  return;
}

sum()

void sum	(	const BufferType &	buf,
		Real *	vals
	)

Definition at line 690 of file NESpaceGrid.cpp.

References qmcplusplus::n.

{
  for (int v = 0; v < nvalues_per_domain_; v++)
  {
    vals[v] = 0.0;
  }
  for (int i = 0, n = buffer_offset_; i < ndomains_; i++, n += nvalues_per_domain_)
  {
    for (int v = 0; v < nvalues_per_domain_; v++)
    {
      vals[v] += data_[n + v];
    }
  }
}

write()

void write

(

hdf_archive &

file

)

const

Definition at line 504 of file NESpaceGrid.cpp.

References qmcplusplus::syclBLAS::copy_n(), and hdf_archive::pop().

{
  if (observable_helper_)
  {
    if constexpr (std::is_same<Real, QMCTraits::FullPrecRealType>::value)
    {
      observable_helper_->write(data_.data(), file);
    }
    else
    {
      std::vector<QMCTraits::FullPrecRealType> expanded_data(data_.size(), 0.0);
      std::copy_n(data_.begin(), data_.size(), expanded_data.begin());
      assert(!data_.empty());
      // auto total = std::accumulate(data_->begin(), data_->end(), 0.0);
      // std::cout << "data size: " << data_->size() << " : " << total << '\n';
      observable_helper_->write(expanded_data.data(), file);
    }
    file.pop();
  }
  return;
}

write_description()

void write_description	(	std::ostream &	os,
		const std::string &	indent
	)

Definition at line 353 of file NESpaceGrid.cpp.

References OHMMS_DIM, and qmcplusplus::Units::time::s.

{
  os << indent + "SpaceGrid" << std::endl;
  std::string s;
  using CoordForm = SpaceGridInput::CoordForm;
  switch (input_.get_coord_form())
  {
  case CoordForm::CARTESIAN:
    s = "cartesian";
    break;
  case CoordForm::CYLINDRICAL:
    s = "cylindrical";
    break;
  case CoordForm::SPHERICAL:
    s = "spherical";
    break;
  default:
    break;
  }
  auto& agr         = input_.get_axis_grids();
  auto& axis_labels = input_.get_axis_labels();
  os << indent + "  SpaceGridInput::lookup_input_ename_value(input_.get_coord_form()  = " + s << std::endl;
  os << indent + "  ndomains_      = " << ndomains_ << std::endl;
  os << indent + "  axes  = " << axes_ << std::endl;
  os << indent + "  axinv = " << axinv_ << std::endl;
  for (int d = 0; d < OHMMS_DIM; d++)
  {
    os << indent + "  axis " << axis_labels[d] << ":" << std::endl;
    os << indent + "    umin = " << agr[d].umin << std::endl;
    os << indent + "    umax = " << agr[d].umax << std::endl;
    os << indent + "    du   = " << 1.0 / static_cast<double>(agr[d].odu) << std::endl;
    os << indent + "    dm   = " << dm_[d] << std::endl;
    os << indent + "    gmap = ";
    for (int g = 0; g < gmap_[d].size(); g++)
    {
      os << gmap_[d][g] << " ";
    }
    os << std::endl;
  }
  os << indent + "end NESpaceGrid" << std::endl;
}

zero()

void zero ( )

private

Definition at line 717 of file NESpaceGrid.cpp.

{
  data_.clear();
}

Friends And Related Function Documentation

testing::NESpaceGridTests

friend class testing::NESpaceGridTests

friend

Definition at line 268 of file NESpaceGrid.h.

Member Data Documentation

axes_

AxTensor axes_

private

Definition at line 242 of file NESpaceGrid.h.

axinv_

AxTensor axinv_

private

Definition at line 243 of file NESpaceGrid.h.

axlabel_

std::string axlabel_[OHMMS_DIM]

private

Definition at line 249 of file NESpaceGrid.h.

buffer_end_

int buffer_end_

private

Definition at line 224 of file NESpaceGrid.h.

Referenced by NESpaceGridTests< REAL >::getBufferEnd().

buffer_offset_

const int buffer_offset_ {0}

private

in legacy used to be the starting index into the collectibles buffer.

Maintained to use more legacy code without modificaiton in the short term. In the long term its possible the entire way the grid data is structured in memory should be redesigned.

Definition at line 230 of file NESpaceGrid.h.

buffer_start_

int buffer_start_

private

Definition at line 223 of file NESpaceGrid.h.

Referenced by NESpaceGridTests< REAL >::getBufferStart().

data_

std::vector<Real> data_

private

Definition at line 256 of file NESpaceGrid.h.

Referenced by NESpaceGrid< REAL >::collect(), NESpaceGridTests< REAL >::getData(), and NESpaceGrid< REAL >::getDataVector().

dm_

int dm_[OHMMS_DIM]

private

Definition at line 254 of file NESpaceGrid.h.

domain_centers_

Matrix<Real> domain_centers_

private

Definition at line 239 of file NESpaceGrid.h.

domain_uwidths_

Matrix<Real> domain_uwidths_

private

Definition at line 248 of file NESpaceGrid.h.

domain_volumes_

Matrix<Real> domain_volumes_

private

These are calculated by NESpaceGrid before accumulation and possibly belong in SpaceGridInput as derived inputs.

i.e. they are immutable and only based on the input. Alternately they would be appropriate to calculate at construction time.

Definition at line 238 of file NESpaceGrid.h.

gmap_

std::array<std::vector<int>, 3> gmap_

private

Definition at line 250 of file NESpaceGrid.h.

input_

SpaceGridInput& input_

private

refrence points for the space grid this reference it to the EstimatorManagers EDE's spacegrid_inputs_

Definition at line 214 of file NESpaceGrid.h.

is_periodic_

bool is_periodic_

private

Definition at line 216 of file NESpaceGrid.h.

ndomains_

int ndomains_ {1}

private

Definition at line 231 of file NESpaceGrid.h.

Referenced by NESpaceGrid< REAL >::nDomains().

ndparticles_

int ndparticles_

private

Definition at line 215 of file NESpaceGrid.h.

nearcell_

std::vector<IRPair> nearcell_

private

Definition at line 264 of file NESpaceGrid.h.

nvalues_per_domain_

int nvalues_per_domain_

private

Definition at line 232 of file NESpaceGrid.h.

observable_helper_

std::shared_ptr<ObservableHelper> observable_helper_

private

Definition at line 257 of file NESpaceGrid.h.

odu_

Real odu_[OHMMS_DIM]

private

Definition at line 251 of file NESpaceGrid.h.

Referenced by NESpaceGridTests< REAL >::getOdu().

origin_

Point origin_

private

Definition at line 241 of file NESpaceGrid.h.

points_

const Points& points_

private

refrence points for the space grid this reference is to the EstimatorManagers EDE's reference points

Definition at line 220 of file NESpaceGrid.h.

reference_energy_

ReferenceEnergy reference_energy_

private

Definition at line 255 of file NESpaceGrid.h.

umax_

Real umax_[OHMMS_DIM]

private

Definition at line 253 of file NESpaceGrid.h.

umin_

Real umin_[OHMMS_DIM]

private

Definition at line 252 of file NESpaceGrid.h.

volume_

Real volume_

private

Definition at line 247 of file NESpaceGrid.h.

---

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

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