SSAGES  0.1
A MetaDynamics Package
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
SSAGES::GridBase< T > Class Template Referenceabstract

Base class for Grids. More...

#include <GridBase.h>

Inheritance diagram for SSAGES::GridBase< T >:
Inheritance graph
[legend]

Public Member Functions

void syncGrid ()
 
size_t GetDimension () const
 Get the dimension. More...
 
const std::vector< int > GetNumPoints () const
 Get the number of points for all dimensions. More...
 
int GetNumPoints (size_t dim) const
 Get the number of points for a specific dimension. More...
 
const std::vector< double > GetLower () const
 Return the lower edges of the Grid. More...
 
double GetLower (size_t dim) const
 Get the lower edge for a specific dimension. More...
 
const std::vector< double > GetUpper () const
 Return the upper edges of the Grid. More...
 
double GetUpper (size_t dim) const
 Get the upper edge for a specific dimension. More...
 
const std::vector< bool > & GetPeriodic () const
 Return the periodicity of the Grid. More...
 
bool GetPeriodic (size_t dim) const
 Get the periodicity in a specific dimension. More...
 
size_t size () const
 Get the size of the internal storage vector. More...
 
T * data ()
 Get pointer to the internal data storage vector. More...
 
T const * data () const
 Get pointer to const of the internal data storage vector. More...
 
std::vector< int > GetIndices (const std::vector< double > &x) const
 Return the Grid indices for a given point. More...
 
int GetIndex (double x) const
 Return linear interpolation on a coordinate. More...
 
std::vector< double > GetCoordinates (const std::vector< int > &indices)
 Return the distance to adjacent grid center points from given coordinates. More...
 
double GetCoordinate (int index)
 Return center point of 1d-grid. More...
 
const T & at (const std::vector< int > &indices) const
 Access Grid element read-only. More...
 
T & at (const std::vector< int > &indices)
 Access Grid element read/write. More...
 
template<typename R >
const T & at (std::initializer_list< R > &&x) const
 Const access of Grid element via initializer list. More...
 
template<typename R >
T & at (std::initializer_list< R > &&x)
 Access Grid element via initializer list. More...
 
const T & at (int index) const
 Access 1d Grid by index, read-only. More...
 
T & at (int index)
 Access 1d Grid by index, read-write. More...
 
const T & at (const std::vector< double > &x) const
 Access Grid element pertaining to a specific point – read-only. More...
 
T & at (const std::vector< double > &x)
 Access Grid element pertaining to a specific point – read/write. More...
 
const T & at (double x) const
 Access 1d-Grid by point - read-only. More...
 
T & at (double x)
 Access 1d-Grid by point - read-write. More...
 
const T & operator[] (const std::vector< int > &indices) const
 Access Grid element per [] read-only. More...
 
T & operator[] (const std::vector< int > &indices)
 Access Grid element per [] read-write. More...
 
template<typename R >
const T & operator[] (std::initializer_list< R > &&x) const
 Const access of Grid element via initializer list. More...
 
template<typename R >
T & operator[] (std::initializer_list< R > &&x)
 Access Grid element via initializer list. More...
 
const T & operator[] (int index) const
 Access 1d-Grid per [] operator, read-only. More...
 
T & operator[] (int index)
 Access 1d-Grid per [] operator, read-write. More...
 
const T & operator[] (const std::vector< double > &x) const
 Access Grid element pertaining to a specific point per [] read-only. More...
 
T & operator[] (const std::vector< double > &x)
 Access Grid element pertaining to a specific point per [] read-write. More...
 
const T & operator[] (double x) const
 Access 1d-Grid via specific point, read-only. More...
 
T & operator[] (double x)
 Access 1d-Grid via specific point, read-write. More...
 

Protected Member Functions

std::vector< int > wrapIndices (const std::vector< int > &indices) const
 Wrap the index around periodic boundaries.
 
virtual size_t mapTo1d (const std::vector< int > &indices) const =0
 This function needs to be implemented by child classes. More...
 
 GridBase (std::vector< int > numPoints, std::vector< double > lower, std::vector< double > upper, std::vector< bool > isPeriodic)
 Constructor. More...
 

Protected Attributes

std::vector< T > data_
 Internal storage of the data.
 
size_t dimension_
 Dimension of the grid.
 
std::vector< int > numPoints_
 Number of points in each dimension.
 
std::pair< std::vector< double >, std::vector< double > > edges_
 Edges of the Grid in each dimension.
 
std::vector< bool > isPeriodic_
 Periodicity of the Grid.
 

Detailed Description

template<typename T>
class SSAGES::GridBase< T >

Base class for Grids.

Template Parameters
Typeof data stored on the grid

Base class for all grids. Currently, these are 'Grid' and 'Histogram'.

Definition at line 38 of file GridBase.h.

Constructor & Destructor Documentation

template<typename T>
SSAGES::GridBase< T >::GridBase ( std::vector< int >  numPoints,
std::vector< double >  lower,
std::vector< double >  upper,
std::vector< bool >  isPeriodic 
)
inlineprotected

Constructor.

Parameters
numPointsNumber of grid points in each dimension.
lowerLower edges of the grid.
upperUpper edges of the grid.
isPeriodicBools specifying the periodicity in the respective dimension.

The constructor is protected by design. This makes sure that only child classes of GridBase are constructed.

Definition at line 99 of file GridBase.h.

103  : dimension_(numPoints.size()),
104  numPoints_(numPoints),
105  edges_(std::pair< std::vector<double>, std::vector<double> >(lower, upper)),
106  isPeriodic_(isPeriodic)
107  {
108  // Check that vector sizes are correct
109  if (edges_.first.size() != dimension_ ||
110  edges_.second.size() != dimension_) {
111  throw std::invalid_argument("Size of vector containing upper or "
112  "lower edges, does not match size of vector containing "
113  "number of grid points.");
114  }
115  if (isPeriodic_.size() == 0) {
116  // Default: Non-periodic in all dimensions
117  isPeriodic.resize(dimension_, false);
118  } else if (isPeriodic_.size() != dimension_) {
119  throw std::invalid_argument("Size of vector isPeriodic does not "
120  "match size of vector containing number of grid points.");
121  }
122  for(size_t i=0 ; i < isPeriodic_.size() ; i++)
123  {
124  if(isPeriodic_[i])
125  {
126  double spacing = (edges_.second[i] - edges_.first[i]) / numPoints_[i];
127  numPoints_[i]++;
128  edges_.first[i] -= spacing/2;
129  edges_.second[i] += spacing/2;
130  }
131  }
132 
133  }
std::pair< std::vector< double >, std::vector< double > > edges_
Edges of the Grid in each dimension.
Definition: GridBase.h:51
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45
std::vector< bool > isPeriodic_
Periodicity of the Grid.
Definition: GridBase.h:54

Member Function Documentation

template<typename T>
const T& SSAGES::GridBase< T >::at ( const std::vector< int > &  indices) const
inline

Access Grid element read-only.

Parameters
indicesVector of integers specifying the grid point.
Returns
const reference of the value stored at the given grid point.

In non-periodic dimensions, the index needs to be in the interval [-1, numPoints]. Grid::at(-1) accessed the underflow bin, Grid::at(numPoints) accesses the overflow bin.

In periodic dimensions, the index may take any integer value and will be mapped back to the interval [0, numPoints-1]. Thus, Grid::at(-1) will access the same value as Grid::at(numPoints-1).

Definition at line 536 of file GridBase.h.

Referenced by SSAGES::GridBase< uint >::at(), SSAGES::GridBase< uint >::GetCoordinate(), SSAGES::GridBase< uint >::GetIndex(), SSAGES::GridBase< uint >::GridBase(), and SSAGES::GridBase< uint >::operator[]().

537  {
538  // Check that indices are in bound.
539  if (indices.size() != GetDimension()) {
540  throw std::invalid_argument("Dimension of indices does not match "
541  "dimension of the grid.");
542  }
543 
544  return data_.at(mapTo1d(indices));
545  }
std::vector< T > data_
Internal storage of the data.
Definition: GridBase.h:42
virtual size_t mapTo1d(const std::vector< int > &indices) const =0
This function needs to be implemented by child classes.
size_t GetDimension() const
Get the dimension.
Definition: GridBase.h:186

Here is the caller graph for this function:

template<typename T>
T& SSAGES::GridBase< T >::at ( const std::vector< int > &  indices)
inline

Access Grid element read/write.

Parameters
indicesVector of integers specifying the grid point.
Returns
Reference to value at the specified grid point.

Definition at line 552 of file GridBase.h.

553  {
554  return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(indices));
555  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
template<typename R >
const T& SSAGES::GridBase< T >::at ( std::initializer_list< R > &&  x) const
inline

Const access of Grid element via initializer list.

Template Parameters
RDatatype in the initializer list
Parameters
xinitializer list
Returns
Const reference to value at the specified point.

This function avoids abiguity if at() is called with a brace-enclosed initializer list. The template parameter makes sure that this function can be called with either ints, specifying a grid point, or doubles, specifying coordinates in space, inside the initializer list.

Definition at line 569 of file GridBase.h.

570  {
571  return at(static_cast<std::vector<R> >(x));
572  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
template<typename R >
T& SSAGES::GridBase< T >::at ( std::initializer_list< R > &&  x)
inline

Access Grid element via initializer list.

Template Parameters
RDatatype in the initializer list
Parameters
xinitializer list
Returns
Reference to value at the specified point.

This function avoids abiguity if at() is called with a brace-enclosed initializer list. The template parameter makes sure that this function can be called with either ints, specifying a grid point, or doubles, specifying coordinates in space, inside the initializer list.

Definition at line 586 of file GridBase.h.

587  {
588  return at(static_cast<std::vector<R> >(x));
589  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
const T& SSAGES::GridBase< T >::at ( int  index) const
inline

Access 1d Grid by index, read-only.

Parameters
indexIndex specifying the grid point.
Returns
Const reference of value at the given index.
Note
This function can only be used for 1d-Grids.

Definition at line 598 of file GridBase.h.

599  {
600  if (dimension_ != 1) {
601  throw std::invalid_argument("Only 1d-Grids can be accessed with a "
602  "single integer as the index.");
603  }
604  return at({index});
605  }
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
T& SSAGES::GridBase< T >::at ( int  index)
inline

Access 1d Grid by index, read-write.

Parameters
indexIndex specifying the grid point.
Returns
Reference of value at the given grid point.
Note
This function can only be used for 1d-Grids.

Definition at line 614 of file GridBase.h.

615  {
616  return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(index));
617  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
const T& SSAGES::GridBase< T >::at ( const std::vector< double > &  x) const
inline

Access Grid element pertaining to a specific point – read-only.

Parameters
xVector of doubles specifying a point.
Returns
Const reference of the value at the given coordinates.

This function is provided for convenience. It is identical to GridBase::at(GridBase::GetIndices(x)).

Definition at line 627 of file GridBase.h.

628  {
629  return at(GetIndices(x));
630  }
std::vector< int > GetIndices(const std::vector< double > &x) const
Return the Grid indices for a given point.
Definition: GridBase.h:368
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
T& SSAGES::GridBase< T >::at ( const std::vector< double > &  x)
inline

Access Grid element pertaining to a specific point – read/write.

Parameters
xVector of doubles specifying a point.
Returns
Reference to the value at the given coordinates.

This function is provided for convenience. It is identical to GridBase::at(GridBase::GetIndices(x)).

Definition at line 640 of file GridBase.h.

641  {
642  return at(GetIndices(x));
643  }
std::vector< int > GetIndices(const std::vector< double > &x) const
Return the Grid indices for a given point.
Definition: GridBase.h:368
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
const T& SSAGES::GridBase< T >::at ( double  x) const
inline

Access 1d-Grid by point - read-only.

Parameters
xAccess grid point pertaining to this value.
Returns
Const reference to the value pertaining to the specified coordinate.
Note
This function can only be used for 1d-Grids.

Definition at line 653 of file GridBase.h.

654  {
655  if (dimension_ != 1) {
656  throw std::invalid_argument("Only 1d-Grids can be accessed with a "
657  "single float as the specified point.");
658  }
659  return at({x});
660  }
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
T& SSAGES::GridBase< T >::at ( double  x)
inline

Access 1d-Grid by point - read-write.

Parameters
xAccess grid point pertaining to this value.
Returns
Reference to the value pertaining to the specified coordinate.
Note
This function can only be used for 1d Grids.

Definition at line 669 of file GridBase.h.

670  {
671  return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(x));
672  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
T* SSAGES::GridBase< T >::data ( )
inline

Get pointer to the internal data storage vector.

Returns
Pointer to data in the internal storage vector.

It is discouraged to directly access the internal data storage. It might, however be necessary. For example when communicating the data over MPI.

Definition at line 334 of file GridBase.h.

Referenced by SSAGES::BFS::ProjectBias().

335  {
336  return data_.data();
337  }
std::vector< T > data_
Internal storage of the data.
Definition: GridBase.h:42

Here is the caller graph for this function:

template<typename T>
T const* SSAGES::GridBase< T >::data ( ) const
inline

Get pointer to const of the internal data storage vector.

Returns
Const pointer to data in the internal storage vector.

It is discouraged to directly access the internal data storage. It might, however be necessary. For example when communicating data over MPI.

Definition at line 346 of file GridBase.h.

347  {
348  return data_.data();
349  }
std::vector< T > data_
Internal storage of the data.
Definition: GridBase.h:42
template<typename T>
double SSAGES::GridBase< T >::GetCoordinate ( int  index)
inline

Return center point of 1d-grid.

Parameters
indexIndex of the 1d grid.
Returns
Coordinate in real/CV space.
Note
This function is only available for 1d grids.

Definition at line 518 of file GridBase.h.

519  {
520  return GetCoordinates({index}).at(0);
521  }
std::vector< double > GetCoordinates(const std::vector< int > &indices)
Return the distance to adjacent grid center points from given coordinates.
Definition: GridBase.h:493
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
std::vector<double> SSAGES::GridBase< T >::GetCoordinates ( const std::vector< int > &  indices)
inline

Return the distance to adjacent grid center points from given coordinates.

Parameters
coords
dimTo be finalized.

std::vector<double> GetDist(const std::vector<double> &coords) {

} Return coordinates of the grid center points

Parameters
indicesGrid indices specifying a grid point.
Returns
Vector of double specifying the position of the grid point.

The grid is a discretization of real or cv space. Thus, each grid point is associated with an interval of the underlying space. This function returns the center point of this interval.

Definition at line 493 of file GridBase.h.

Referenced by SSAGES::GridBase< uint >::GetCoordinate().

494  {
495  if (indices.size() != dimension_) {
496  throw std::invalid_argument(
497  "Grid indices specified for GetCoordinates() do not have "
498  "the same dimensionality as the grid.");
499  }
500 
501  std::vector<double> v(dimension_);
502 
503  for (size_t i = 0; i < dimension_; ++i) {
504  double spacing = (edges_.second[i] - edges_.first[i]) / numPoints_[i];
505  v.at(i) = edges_.first[i] + (indices[i] + 0.5)*spacing;
506  }
507 
508  return v;
509  }
std::pair< std::vector< double >, std::vector< double > > edges_
Edges of the Grid in each dimension.
Definition: GridBase.h:51
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45

Here is the caller graph for this function:

template<typename T>
size_t SSAGES::GridBase< T >::GetDimension ( ) const
inline

Get the dimension.

Returns
Dimensionality of the grid.

Definition at line 186 of file GridBase.h.

Referenced by SSAGES::GridBase< uint >::at(), SSAGES::GridBase< uint >::GetLower(), SSAGES::GridBase< uint >::GetNumPoints(), SSAGES::GridBase< uint >::GetPeriodic(), SSAGES::GridBase< uint >::GetUpper(), and SSAGES::GridBase< uint >::GridBase().

187  {
188  return dimension_;
189  }
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45

Here is the caller graph for this function:

template<typename T>
int SSAGES::GridBase< T >::GetIndex ( double  x) const
inline

Return linear interpolation on a coordinate.

Parameters
xPoint in space.
Returns
Linearly interpolated value of grid at that point. This function performs a n-linear interpolation on the grid. The formula is bilinear/trilinear interpolation generalized to N-dimensional space. double GetInterpolated(const std::vector<double> &x) { double interpvalue = 0; int tempindex; for (size_t i = 0 ; i < pow(2,dimension_) ; ++i) {
std::vector<double> shiftedvector = x;
tempindex = i;

double accumulatedweight = 1;
for(size_t j = 0; j < dimension_ ; ++j)
{
    double spacing = (edges_.second[j] - edges_.first[j]) / numPoints_[j];
    shiftedvector[j] += ((tempindex%2)-0.5)*spacing;
    tempindex = tempindex/2;
}

std::vector<int> shiftedindices = GetIndices(shiftedvector);
std::vector<double> shiftedcenters = GetCoordinates(shiftedindices);

for(size_t j = 0; j < dimension_ ; ++j)
{   
    double spacing = (edges_.second[j] - edges_.first[j]) / numPoints_[j];
Handle Edges if(shiftedindices[j] == -1) { accumulatedweight *= ((std::abs(x[j]-GetCoordinates(GetIndices(x))[j])/spacing)); shiftedvector[j] += spacing/2; } else if (shiftedindices[j] == numPoints_[j]) { accumulatedweight *= ((std::abs(x[j]-GetCoordinates(GetIndices(x))[j])/spacing)); shiftedvector[j] -= spacing/2; } else { Handle Periodicity if(std::abs(x[j]-shiftedcenters[j]) > spacing) accumulatedweight *= (1-(std::abs(std::abs(x[j]-shiftedcenters[j]) - (edges_.second[j] - edges_.first[j]))/spacing)); else accumulatedweight *= (1-(std::abs(x[j]-shiftedcenters[j])/spacing)); } } interpvalue += accumulatedweight*at(shiftedvector); } return interpvalue; } Return the Grid index for a one-dimensional grid.
Parameters
xPoint in space.
Returns
Grid index to which the point pertains.

Return the Grid index pertaining to the given point in space. This function is for convenience when accessing 1d-Grids. For higher-dimensional grids, x needs to be a vector of doubles.

Definition at line 462 of file GridBase.h.

463  {
464  if (dimension_ != 1) {
465  throw std::invalid_argument("1d Grid index can only be accessed for "
466  "1d-Grids can be accessed with a.");
467  }
468  return GetIndices({x}).at(0);
469  }
std::vector< int > GetIndices(const std::vector< double > &x) const
Return the Grid indices for a given point.
Definition: GridBase.h:368
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
std::vector<int> SSAGES::GridBase< T >::GetIndices ( const std::vector< double > &  x) const
inline

Return the Grid indices for a given point.

Parameters
xPoint in space.
Returns
Indices of the grid point to which the point in space pertains.

The grid discretizes the continuous space. For a given point in this continuous space, this function will return the indices of the grid point covering the point in space.

If the grid is non-periodic in a given dimension and x is lower than the lower edge in this dimension, the function will return -1, the index of the underflow bin. Similarly, it will return numPoints, the index of the overflow bin, if x is larger than the upper edge.

In periodic dimensions, the index can take any integer value and will be wrapped to the interval [0, numPoints).

Definition at line 368 of file GridBase.h.

Referenced by SSAGES::GridBase< uint >::at(), and SSAGES::GridBase< uint >::GetIndex().

369  {
370  // Check that input vector has the correct dimensionality
371  if (x.size() != dimension_) {
372  throw std::invalid_argument("Specified point has a larger "
373  "dimensionality than the grid.");
374  }
375 
376  std::vector<int> indices(dimension_);
377  for (size_t i = 0; i < dimension_; ++i) {
378  double xpos = x.at(i);
379  if (!GetPeriodic(i)) {
380  if (xpos < edges_.first[i]) {
381  indices.at(i) = -1;
382  continue;
383  } else if (xpos > edges_.second[i]) {
384  indices.at(i) = numPoints_[i];
385  continue;
386  }
387  }
388 
389  // To make sure, the value is rounded in the correct direction.
390  double spacing = (edges_.second[i] - edges_.first[i]) / numPoints_[i];
391  indices.at(i) = std::floor( (xpos - edges_.first[i]) / spacing);
392  }
393 
394  return wrapIndices(indices);
395  }
std::pair< std::vector< double >, std::vector< double > > edges_
Edges of the Grid in each dimension.
Definition: GridBase.h:51
const std::vector< bool > & GetPeriodic() const
Return the periodicity of the Grid.
Definition: GridBase.h:291
std::vector< int > wrapIndices(const std::vector< int > &indices) const
Wrap the index around periodic boundaries.
Definition: GridBase.h:57
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45

Here is the caller graph for this function:

template<typename T>
const std::vector<double> SSAGES::GridBase< T >::GetLower ( ) const
inline

Return the lower edges of the Grid.

Returns
Vector containing the lower edges of the grid.

Definition at line 227 of file GridBase.h.

Referenced by SSAGES::Grid< uint >::WriteToFile().

228  {
229  std::vector<double> lower(dimension_);
230  for(size_t i = 0; i<dimension_;++i)
231  if(GetPeriodic(i)) {lower[i] = edges_.first[i] - ((edges_.first[i] - edges_.second[i]) / numPoints_[i])/2;}
232  else {lower[i] = edges_.first[i];}
233  return lower;
234  }
std::pair< std::vector< double >, std::vector< double > > edges_
Edges of the Grid in each dimension.
Definition: GridBase.h:51
const std::vector< bool > & GetPeriodic() const
Return the periodicity of the Grid.
Definition: GridBase.h:291
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45

Here is the caller graph for this function:

template<typename T>
double SSAGES::GridBase< T >::GetLower ( size_t  dim) const
inline

Get the lower edge for a specific dimension.

Parameters
dimIndex of the dimension.
Returns
Value of the lower edge in the requested dimension.
Note
The first dimension has the index 0.

Definition at line 243 of file GridBase.h.

244  {
245  if (dim >= GetDimension()) {
246  std::cerr << "Warning! Lower edge requested for a dimension larger "
247  "than the grid dimensionality!\n";
248  return 0.0;
249  }
250  if(GetPeriodic(dim)){return edges_.first[dim] - ((edges_.first[dim] - edges_.second[dim]) / numPoints_[dim])/2;}
251  else{return edges_.first[dim];}
252  }
std::pair< std::vector< double >, std::vector< double > > edges_
Edges of the Grid in each dimension.
Definition: GridBase.h:51
const std::vector< bool > & GetPeriodic() const
Return the periodicity of the Grid.
Definition: GridBase.h:291
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t GetDimension() const
Get the dimension.
Definition: GridBase.h:186
template<typename T>
const std::vector<int> SSAGES::GridBase< T >::GetNumPoints ( ) const
inline

Get the number of points for all dimensions.

Returns
Vector of ints containing the number of grid points for each dimension.

Definition at line 196 of file GridBase.h.

Referenced by SSAGES::BFS::Build(), SSAGES::Histogram< T >::end(), SSAGES::Histogram< T >::Histogram(), SSAGES::Histogram< T >::mapTo1d(), and SSAGES::Grid< uint >::WriteToFile().

197  {
198  std::vector<int> numPoints = numPoints_;
199  for(size_t i = 0; i<dimension_;++i)
200  if(GetPeriodic(i)){numPoints[i]--;}
201  return numPoints;
202  }
const std::vector< bool > & GetPeriodic() const
Return the periodicity of the Grid.
Definition: GridBase.h:291
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45

Here is the caller graph for this function:

template<typename T>
int SSAGES::GridBase< T >::GetNumPoints ( size_t  dim) const
inline

Get the number of points for a specific dimension.

Parameters
dimIndex of the dimension.
Returns
Number of grid points in the requested dimension.
Note
The first dimension uses the index 0.

Definition at line 211 of file GridBase.h.

212  {
213  if (dim >= GetDimension()) {
214  std::cerr << "Warning! Grid size requested for a dimension larger "
215  "than the grid dimensionality!\n";
216  return 0;
217  }
218  if(GetPeriodic(dim)){return numPoints_[dim]-1;}
219  else
220  return numPoints_.at(dim);
221  }
const std::vector< bool > & GetPeriodic() const
Return the periodicity of the Grid.
Definition: GridBase.h:291
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t GetDimension() const
Get the dimension.
Definition: GridBase.h:186
template<typename T>
const std::vector<bool>& SSAGES::GridBase< T >::GetPeriodic ( ) const
inline

Return the periodicity of the Grid.

Returns
Vector of bools. The values are True (False ) if the grid is periodic (non-periodic) in the given dimension.

Definition at line 291 of file GridBase.h.

Referenced by SSAGES::GridBase< uint >::GetIndices(), SSAGES::GridBase< uint >::GetLower(), SSAGES::GridBase< uint >::GetNumPoints(), SSAGES::GridBase< uint >::GetPeriodic(), SSAGES::GridBase< uint >::GetUpper(), SSAGES::Histogram< T >::mapTo1d(), and SSAGES::GridBase< uint >::wrapIndices().

292  {
293  return isPeriodic_;
294  }
std::vector< bool > isPeriodic_
Periodicity of the Grid.
Definition: GridBase.h:54

Here is the caller graph for this function:

template<typename T>
bool SSAGES::GridBase< T >::GetPeriodic ( size_t  dim) const
inline

Get the periodicity in a specific dimension.

Parameters
dimIndex of the dimension.
Returns
True (False ) if the grid is periodic (non-periodic) in the specified dimension.
Note
The dimensions are indexed starting with 0.

Definition at line 304 of file GridBase.h.

305  {
306  if (dim >= GetDimension()) {
307  std::cerr << "Warning! Periodicity requested for a dimension larger "
308  "than the grid dimensionality!\n";
309  return false;
310  }
311  return GetPeriodic().at(dim);
312  }
const std::vector< bool > & GetPeriodic() const
Return the periodicity of the Grid.
Definition: GridBase.h:291
size_t GetDimension() const
Get the dimension.
Definition: GridBase.h:186
template<typename T>
const std::vector<double> SSAGES::GridBase< T >::GetUpper ( ) const
inline

Return the upper edges of the Grid.

Returns
Vector containing the upper edges of the grid.

Definition at line 258 of file GridBase.h.

Referenced by SSAGES::Grid< uint >::WriteToFile().

259  {
260  std::vector<double> upper(dimension_);
261  for(size_t i = 0; i<dimension_;++i)
262  if(GetPeriodic(i)) {upper[i] = edges_.second[i] + ((edges_.first[i] - edges_.second[i]) / numPoints_[i])/2;}
263  else {upper[i] = edges_.second[i];}
264  return upper;
265  }
std::pair< std::vector< double >, std::vector< double > > edges_
Edges of the Grid in each dimension.
Definition: GridBase.h:51
const std::vector< bool > & GetPeriodic() const
Return the periodicity of the Grid.
Definition: GridBase.h:291
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t dimension_
Dimension of the grid.
Definition: GridBase.h:45

Here is the caller graph for this function:

template<typename T>
double SSAGES::GridBase< T >::GetUpper ( size_t  dim) const
inline

Get the upper edge for a specific dimension.

Parameters
dimIndex of the dimension.
Returns
Value of the upper edge in the given dimension.
Note
The dimensions are indexed starting with 0.

Definition at line 275 of file GridBase.h.

276  {
277  if (dim >= GetDimension()) {
278  std::cerr << "Warning! Upper edge requested for a dimension larger "
279  "than the grid dimensionality!\n";
280  return 0.0;
281  }
282  if(GetPeriodic(dim)){return edges_.second[dim] + ((edges_.first[dim] - edges_.second[dim]) / numPoints_[dim])/2;}
283  else{return edges_.second[dim];}
284  }
std::pair< std::vector< double >, std::vector< double > > edges_
Edges of the Grid in each dimension.
Definition: GridBase.h:51
const std::vector< bool > & GetPeriodic() const
Return the periodicity of the Grid.
Definition: GridBase.h:291
std::vector< int > numPoints_
Number of points in each dimension.
Definition: GridBase.h:48
size_t GetDimension() const
Get the dimension.
Definition: GridBase.h:186
template<typename T>
virtual size_t SSAGES::GridBase< T >::mapTo1d ( const std::vector< int > &  indices) const
protectedpure virtual

This function needs to be implemented by child classes.

Parameters
indicesThe indices specifying the grid point.
Returns
Index of the grid point in the 1d storage vector.

mapTo1d maps the indices onto a single index to access the data stored in the data_ vector. This mapping will be different for different grid implementations.

Implemented in SSAGES::Histogram< T >, SSAGES::Grid< T >, SSAGES::Grid< double >, SSAGES::Grid< Vector >, SSAGES::Grid< int >, SSAGES::Grid< std::vector< double > >, SSAGES::Grid< Eigen::VectorXd >, and SSAGES::Grid< uint >.

Referenced by SSAGES::GridBase< uint >::at(), and SSAGES::GridBase< uint >::wrapIndices().

Here is the caller graph for this function:

template<typename T>
const T& SSAGES::GridBase< T >::operator[] ( const std::vector< int > &  indices) const
inline

Access Grid element per [] read-only.

Parameters
indicesVector of integers specifying the grid point.
Returns
Const reference to value to the given grid point.

Definition at line 679 of file GridBase.h.

680  {
681  return at(indices);
682  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
T& SSAGES::GridBase< T >::operator[] ( const std::vector< int > &  indices)
inline

Access Grid element per [] read-write.

Parameters
indicesVector of integers specifying the grid point.
Returns
Reference to value at the specified grid point.

Definition at line 689 of file GridBase.h.

690  {
691  return at(indices);
692  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
template<typename R >
const T& SSAGES::GridBase< T >::operator[] ( std::initializer_list< R > &&  x) const
inline

Const access of Grid element via initializer list.

Template Parameters
RDatatype in the initializer list
Parameters
xinitializer list
Returns
Const reference to the value at the specified point.

This function avoids abiguity if operator[] is called with a brace-enclosed initializer list.

Example: grid[{0,1}] or grid[{-1.23, 4.2, 0.0}]

Definition at line 706 of file GridBase.h.

707  {
708  return at(static_cast<std::vector<R> >(x));
709  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
template<typename R >
T& SSAGES::GridBase< T >::operator[] ( std::initializer_list< R > &&  x)
inline

Access Grid element via initializer list.

Template Parameters
RDatatype in the initializer list
Parameters
xinitializer list
Returns
Reference to the value at the specified point.

This function avoids abiguity if operator[] is called with a brace-enclosed initializer list.

Example: grid[{0,1}]

Definition at line 723 of file GridBase.h.

724  {
725  return at(static_cast<std::vector<R> >(x));
726  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
const T& SSAGES::GridBase< T >::operator[] ( int  index) const
inline

Access 1d-Grid per [] operator, read-only.

Parameters
indexIndex of the grid point.
Returns
Const reference to the value at the given grid point.
Note
This function can only be used for 1d grids.

Definition at line 735 of file GridBase.h.

736  {
737  return at(index);
738  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
T& SSAGES::GridBase< T >::operator[] ( int  index)
inline

Access 1d-Grid per [] operator, read-write.

Parameters
indexIndex of the grid point.
Returns
Reference to the value at the given grid point.
Note
This function can only be used for 1d grids.

Definition at line 747 of file GridBase.h.

748  {
749  return at(index);
750  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
const T& SSAGES::GridBase< T >::operator[] ( const std::vector< double > &  x) const
inline

Access Grid element pertaining to a specific point per [] read-only.

Parameters
xVector of doubles specifying the point in space.
Returns
Const reference to the value pertaining to the given coordinates.

Definition at line 757 of file GridBase.h.

758  {
759  return at(x);
760  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
T& SSAGES::GridBase< T >::operator[] ( const std::vector< double > &  x)
inline

Access Grid element pertaining to a specific point per [] read-write.

Parameters
xVector of doubles specifying the point in space.
Returns
Reference to the value pertaining to the given coordinates.

Definition at line 767 of file GridBase.h.

768  {
769  return at(x);
770  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
const T& SSAGES::GridBase< T >::operator[] ( double  x) const
inline

Access 1d-Grid via specific point, read-only.

Parameters
xPoint specifying the desired Grid point.
Returns
Const reference to the value at the specified coordinate.
Note
This function can only be used for 1d grids.

Definition at line 779 of file GridBase.h.

780  {
781  return at(x);
782  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
T& SSAGES::GridBase< T >::operator[] ( double  x)
inline

Access 1d-Grid via specific point, read-write.

Parameters
xPoint specifying the desired Grid point.
Returns
Reference to value at the specified coordinate.
Note
This function can only be used for 1d grids.

Definition at line 791 of file GridBase.h.

792  {
793  return at(x);
794  }
const T & at(const std::vector< int > &indices) const
Access Grid element read-only.
Definition: GridBase.h:536
template<typename T>
size_t SSAGES::GridBase< T >::size ( ) const
inline

Get the size of the internal storage vector.

Returns
Size of the internal storage vector.

This function returns the size of the internal storage vector. This is also the total number of grid points including the over/underflow bins in case of a histogram.

Definition at line 322 of file GridBase.h.

323  {
324  return data_.size();
325  }
std::vector< T > data_
Internal storage of the data.
Definition: GridBase.h:42

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