Base class for Grids. More...

#include <GridBase.h>

Inheritance diagram for SSAGES::GridBase< T >:

[legend]

Public Member Functions
void	syncGrid ()
	Sync the grid.

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...

virtual	~GridBase ()
	Destructor.

Protected Member Functions
std::vector< int >	wrapIndices (const std::vector< int > &indices) const
	Wrap the index around periodic boundaries. More...

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

Type	of 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

◆ GridBase()

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

numPoints	Number of grid points in each dimension.
lower	Lower edges of the grid.
upper	Upper edges of the grid.
isPeriodic	Bools 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 104 of file GridBase.h.

         : dimension_(numPoints.size()),
           numPoints_(numPoints),
           edges_(std::pair< std::vector<double>, std::vector<double> >(lower, upper)),
           isPeriodic_(isPeriodic)
     {
         // Check that vector sizes are correct
         if (edges_.first.size() != dimension_ ||
             edges_.second.size() != dimension_) {
             throw std::invalid_argument("Size of vector containing upper or "
                 "lower edges, does not match size of vector containing "
                 "number of grid points.");
         }
         if (isPeriodic_.size() == 0) {
             // Default: Non-periodic in all dimensions
             isPeriodic.resize(dimension_, false);
         } else if (isPeriodic_.size() != dimension_) {
             throw std::invalid_argument("Size of vector isPeriodic does not "
                     "match size of vector containing number of grid points.");
         }
         for(size_t i=0 ; i < isPeriodic_.size() ; i++)
         {
             if(isPeriodic_[i])
             {
                 if(numPoints_[i] <= 1)
                 {
                     throw std::invalid_argument("A periodic grid is incompatible with a grid size of 1.");
                 }               
                 double spacing = (edges_.second[i] - edges_.first[i]) / (numPoints_[i]-1);
                 edges_.first[i] -= spacing/2;
                 edges_.second[i] += spacing/2;
             }
         }
         
     }

References SSAGES::GridBase< T >::dimension_, SSAGES::GridBase< T >::edges_, SSAGES::GridBase< T >::isPeriodic_, and SSAGES::GridBase< T >::numPoints_.

Member Function Documentation

◆ at() [1/10]

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

x	Vector 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 650 of file GridBase.h.

     {
         return at(GetIndices(x));
     }

References SSAGES::GridBase< T >::at(), and SSAGES::GridBase< T >::GetIndices().

Here is the call graph for this function:

◆ at() [2/10]

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

x	Vector 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 637 of file GridBase.h.

     {
         return at(GetIndices(x));
     }

References SSAGES::GridBase< T >::at(), and SSAGES::GridBase< T >::GetIndices().

Here is the call graph for this function:

◆ at() [3/10]

template<typename T >

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

inline

Access Grid element read/write.

Parameters

indices Vector of integers specifying the grid point.

Returns: Reference to value at the specified grid point.

Definition at line 562 of file GridBase.h.

     {
         return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(indices));
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ at() [4/10]

template<typename T >

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

inline

Access Grid element read-only.

Parameters

indices Vector 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 546 of file GridBase.h.

     {
         // Check that indices are in bound.
         if (indices.size() != GetDimension()) {
             throw std::invalid_argument("Dimension of indices does not match "
                     "dimension of the grid.");
         }
  
         return data_.at(mapTo1d(indices));
     }

References SSAGES::GridBase< T >::data_, SSAGES::GridBase< T >::GetDimension(), and SSAGES::GridBase< T >::mapTo1d().

Referenced by SSAGES::GridBase< T >::at(), SSAGES::GridBase< T >::GetCoordinate(), SSAGES::GridBase< T >::GetIndex(), SSAGES::GridBase< T >::operator[](), SSAGES::ANN::PostIntegration(), and SSAGES::GridBase< T >::syncGrid().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ at() [5/10]

template<typename T >

T& SSAGES::GridBase< T >::at ( double x )

inline

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

Parameters

x	Access 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 679 of file GridBase.h.

     {
         return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(x));
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ at() [6/10]

template<typename T >

const T& SSAGES::GridBase< T >::at ( double x ) const

inline

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

Parameters

x	Access 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 663 of file GridBase.h.

     {
         if (dimension_ != 1) {
             throw std::invalid_argument("Only 1d-Grids can be accessed with a "
                     "single float as the specified point.");
         }
         return at({x});
     }

References SSAGES::GridBase< T >::at(), and SSAGES::GridBase< T >::dimension_.

Here is the call graph for this function:

◆ at() [7/10]

template<typename T >

T& SSAGES::GridBase< T >::at ( int index )

inline

Access 1d Grid by index, read-write.

Parameters

index Index 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 624 of file GridBase.h.

     {
         return const_cast<T&>(static_cast<const GridBase<T>* >(this)->at(index));
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ at() [8/10]

template<typename T >

const T& SSAGES::GridBase< T >::at ( int index ) const

inline

Access 1d Grid by index, read-only.

Parameters

index Index 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 608 of file GridBase.h.

     {
         if (dimension_ != 1) {
             throw std::invalid_argument("Only 1d-Grids can be accessed with a "
                     "single integer as the index.");
         }
         return at({index});
     }

References SSAGES::GridBase< T >::at(), and SSAGES::GridBase< T >::dimension_.

Here is the call graph for this function:

◆ at() [9/10]

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

R	Datatype in the initializer list

Parameters

x	initializer 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 596 of file GridBase.h.

     {
         return at(static_cast<std::vector<R> >(x));
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ at() [10/10]

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

R	Datatype in the initializer list

Parameters

x	initializer 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 579 of file GridBase.h.

     {
         return at(static_cast<std::vector<R> >(x));
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ data() [1/2]

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 338 of file GridBase.h.

     {
         return data_.data();
     }

References SSAGES::GridBase< T >::data_.

Referenced by SSAGES::BFS::ProjectBias(), SSAGES::ANN::ReadBias(), SSAGES::ANN::TrainNetwork(), and SSAGES::ANN::WriteBias().

Here is the caller graph for this function:

◆ data() [2/2]

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 350 of file GridBase.h.

     {
         return data_.data();
     }

References SSAGES::GridBase< T >::data_.

◆ GetCoordinate()

template<typename T >

double SSAGES::GridBase< T >::GetCoordinate ( int index )

inline

Return center point of 1d-grid.

Parameters

index Index of the 1d grid.

Returns: Coordinate in real/CV space.

Note: This function is only available for 1d grids.

Definition at line 528 of file GridBase.h.

     {
         return GetCoordinates({index}).at(0);
     }

References SSAGES::GridBase< T >::at(), and SSAGES::GridBase< T >::GetCoordinates().

Here is the call graph for this function:

◆ GetCoordinates()

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

Return coordinates of the grid center points

Parameters

indices Grid 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 503 of file GridBase.h.

     {
         if (indices.size() != dimension_) {
             throw std::invalid_argument(
                     "Grid indices specified for GetCoordinates() do not have "
                     "the same dimensionality as the grid.");
         }
  
         std::vector<double> v(dimension_);
  
         for (size_t i = 0; i < dimension_; ++i) {
             double spacing = (edges_.second[i] - edges_.first[i]) / (numPoints_[i]);
             v.at(i) = edges_.first[i] + (indices[i] + 0.5)*spacing;
         }
  
         return v;
     }

References SSAGES::GridBase< T >::dimension_, SSAGES::GridBase< T >::edges_, and SSAGES::GridBase< T >::numPoints_.

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

Here is the caller graph for this function:

◆ GetDimension()

template<typename T >

size_t SSAGES::GridBase< T >::GetDimension ( ) const

inline

Get the dimension.

Returns: Dimensionality of the grid.

Definition at line 195 of file GridBase.h.

     {
         return dimension_;
     }

References SSAGES::GridBase< T >::dimension_.

Referenced by SSAGES::ANN::ANN(), SSAGES::GridBase< T >::at(), SSAGES::CFF::CFF(), SSAGES::GridBase< T >::GetLower(), SSAGES::GridBase< T >::GetNumPoints(), SSAGES::GridBase< T >::GetPeriodic(), SSAGES::GridBase< T >::GetUpper(), SSAGES::ANN::PreSimulation(), and SSAGES::GridBase< T >::syncGrid().

Here is the caller graph for this function:

◆ GetIndex()

template<typename T >

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

inline

Return linear interpolation on a coordinate.

   \param x Point in space.
   \return 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

x	Point 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 472 of file GridBase.h.

     {
         if (dimension_ != 1) {
             throw std::invalid_argument("1d Grid index can only be accessed for "
                    "1d-Grids can be accessed with a.");
         }
         return GetIndices({x}).at(0);
     }

References SSAGES::GridBase< T >::at(), SSAGES::GridBase< T >::dimension_, and SSAGES::GridBase< T >::GetIndices().

Here is the call graph for this function:

◆ GetIndices()

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

x	Point 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 372 of file GridBase.h.

     {
         // Check that input vector has the correct dimensionality
         if (x.size() != dimension_) {
             throw std::invalid_argument("Specified point has a larger "
                     "dimensionality than the grid.");
         }
  
         std::vector<int> indices(dimension_);
         for (size_t i = 0; i < dimension_; ++i) 
     {
             double xpos = x.at(i);
                 if (!GetPeriodic(i)) 
         {
                     if (xpos < edges_.first[i]) 
             {
                             indices.at(i) = -1;
                             continue;
                     } 
             else if (xpos > edges_.second[i]) 
             {
                             indices.at(i) = numPoints_[i];
                             continue;
                     }
  
                 }
  
                 // To make sure, the value is rounded in the correct direction.
         double spacing = (edges_.second[i] - edges_.first[i]) / (numPoints_[i]);
                 indices.at(i) = std::floor( (xpos - edges_.first[i]) / spacing);
         }
         
         return wrapIndices(indices);
     }

References SSAGES::GridBase< T >::dimension_, SSAGES::GridBase< T >::edges_, SSAGES::GridBase< T >::GetPeriodic(), SSAGES::GridBase< T >::numPoints_, and SSAGES::GridBase< T >::wrapIndices().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLower() [1/2]

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 231 of file GridBase.h.

     {
         std::vector<double> lower(dimension_);
         for(size_t i = 0; i<dimension_;++i) 
             if(GetPeriodic(i)) {lower[i] = edges_.first[i] - ((edges_.first[i] - edges_.second[i]) / (numPoints_[i]))/2;}
             else {lower[i] = edges_.first[i];}
         return lower;
     }

References SSAGES::GridBase< T >::dimension_, SSAGES::GridBase< T >::edges_, SSAGES::GridBase< T >::GetPeriodic(), and SSAGES::GridBase< T >::numPoints_.

Referenced by SSAGES::ANN::PostIntegration(), SSAGES::BasisEvaluator::UpdateBias(), and SSAGES::Grid< T >::WriteToFile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLower() [2/2]

template<typename T >

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

inline

Get the lower edge for a specific dimension.

Parameters

dim	Index of the dimension.

Returns: Value of the lower edge in the requested dimension.

Note: The first dimension has the index 0.

Definition at line 247 of file GridBase.h.

     {
         if (dim >= GetDimension()) {
             std::cerr << "Warning! Lower edge requested for a dimension larger "
                          "than the grid dimensionality!\n";
             return 0.0;
         }
         if(GetPeriodic(dim)){return edges_.first[dim] - ((edges_.first[dim] - edges_.second[dim]) / (numPoints_[dim]))/2;}
         else{return edges_.first[dim];}
     }

References SSAGES::GridBase< T >::edges_, SSAGES::GridBase< T >::GetDimension(), SSAGES::GridBase< T >::GetPeriodic(), and SSAGES::GridBase< T >::numPoints_.

Here is the call graph for this function:

◆ GetNumPoints() [1/2]

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 205 of file GridBase.h.

     {
         return numPoints_;
     }

References SSAGES::GridBase< T >::numPoints_.

Referenced by SSAGES::BFS::Build(), SSAGES::BasisEvaluator::UpdateBias(), SSAGES::BasisEvaluator::UpdateCoeff(), and SSAGES::Grid< T >::WriteToFile().

Here is the caller graph for this function:

◆ GetNumPoints() [2/2]

template<typename T >

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

inline

Get the number of points for a specific dimension.

Parameters

dim	Index of the dimension.

Returns: Number of grid points in the requested dimension.

Note: The first dimension uses the index 0.

Definition at line 217 of file GridBase.h.

     {
         if (dim >= GetDimension()) {
             std::cerr << "Warning! Grid size requested for a dimension larger "
                          "than the grid dimensionality!\n";
             return 0;
         }
     return numPoints_.at(dim);
     }

References SSAGES::GridBase< T >::GetDimension(), and SSAGES::GridBase< T >::numPoints_.

Here is the call graph for this function:

◆ GetPeriodic() [1/2]

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 295 of file GridBase.h.

     {
         return isPeriodic_;
     }

References SSAGES::GridBase< T >::isPeriodic_.

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

Here is the caller graph for this function:

◆ GetPeriodic() [2/2]

template<typename T >

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

inline

Get the periodicity in a specific dimension.

Parameters

dim	Index 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 308 of file GridBase.h.

     {
         if (dim >= GetDimension()) {
             std::cerr << "Warning! Periodicity requested for a dimension larger "
                          "than the grid dimensionality!\n";
             return false;
         }
         return GetPeriodic().at(dim);
     }

References SSAGES::GridBase< T >::GetDimension(), and SSAGES::GridBase< T >::GetPeriodic().

Here is the call graph for this function:

◆ GetUpper() [1/2]

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 262 of file GridBase.h.

     {
         std::vector<double> upper(dimension_);
         for(size_t i = 0; i<dimension_;++i) 
             if(GetPeriodic(i)) {upper[i] = edges_.second[i] + ((edges_.first[i] - edges_.second[i]) / (numPoints_[i]))/2;}
             else {upper[i] = edges_.second[i];}
         return upper;
     }

References SSAGES::GridBase< T >::dimension_, SSAGES::GridBase< T >::edges_, SSAGES::GridBase< T >::GetPeriodic(), and SSAGES::GridBase< T >::numPoints_.

Referenced by SSAGES::ANN::PostIntegration(), SSAGES::BasisEvaluator::UpdateBias(), and SSAGES::Grid< T >::WriteToFile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetUpper() [2/2]

template<typename T >

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

inline

Get the upper edge for a specific dimension.

Parameters

dim	Index of the dimension.

Returns: Value of the upper edge in the given dimension.

Note: The dimensions are indexed starting with 0.

Definition at line 279 of file GridBase.h.

     {
         if (dim >= GetDimension()) {
             std::cerr << "Warning! Upper edge requested for a dimension larger "
                          "than the grid dimensionality!\n";
             return 0.0;
         }
         if(GetPeriodic(dim)){return edges_.second[dim] + ((edges_.first[dim] - edges_.second[dim]) / (numPoints_[dim]))/2;}
         else{return edges_.second[dim];}
     }

References SSAGES::GridBase< T >::edges_, SSAGES::GridBase< T >::GetDimension(), SSAGES::GridBase< T >::GetPeriodic(), and SSAGES::GridBase< T >::numPoints_.

Here is the call graph for this function:

◆ mapTo1d()

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

indices The 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::Grid< T >, SSAGES::Grid< double >, SSAGES::Grid< Vector >, SSAGES::Grid< int >, SSAGES::Grid< unsigned int >, SSAGES::Grid< std::vector< double > >, and SSAGES::Grid< Eigen::VectorXd >.

Referenced by SSAGES::GridBase< T >::at().

Here is the caller graph for this function:

◆ operator[]() [1/10]

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

x	Vector of doubles specifying the point in space.

Returns: Reference to the value pertaining to the given coordinates.

Definition at line 777 of file GridBase.h.

     {
         return at(x);
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [2/10]

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

x	Vector of doubles specifying the point in space.

Returns: Const reference to the value pertaining to the given coordinates.

Definition at line 767 of file GridBase.h.

     {
         return at(x);
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [3/10]

template<typename T >

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

inline

Access Grid element per [] read-write.

Parameters

indices Vector of integers specifying the grid point.

Returns: Reference to value at the specified grid point.

Definition at line 699 of file GridBase.h.

     {
         return at(indices);
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [4/10]

template<typename T >

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

inline

Access Grid element per [] read-only.

Parameters

indices Vector of integers specifying the grid point.

Returns: Const reference to value to the given grid point.

Definition at line 689 of file GridBase.h.

     {
         return at(indices);
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [5/10]

template<typename T >

T& SSAGES::GridBase< T >::operator[] ( double x )

inline

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

Parameters

x	Point 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 801 of file GridBase.h.

     {
         return at(x);
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [6/10]

template<typename T >

const T& SSAGES::GridBase< T >::operator[] ( double x ) const

inline

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

Parameters

x	Point 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 789 of file GridBase.h.

     {
         return at(x);
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [7/10]

template<typename T >

T& SSAGES::GridBase< T >::operator[] ( int index )

inline

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

Parameters

index Index 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 757 of file GridBase.h.

     {
         return at(index);
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [8/10]

template<typename T >

const T& SSAGES::GridBase< T >::operator[] ( int index ) const

inline

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

Parameters

index Index 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 745 of file GridBase.h.

     {
         return at(index);
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [9/10]

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

R	Datatype in the initializer list

Parameters

x	initializer 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 733 of file GridBase.h.

     {
         return at(static_cast<std::vector<R> >(x));
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ operator[]() [10/10]

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

R	Datatype in the initializer list

Parameters

x	initializer 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 716 of file GridBase.h.

     {
         return at(static_cast<std::vector<R> >(x));
     }

References SSAGES::GridBase< T >::at().

Here is the call graph for this function:

◆ size()

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 326 of file GridBase.h.

     {
         return data_.size();
     }

References SSAGES::GridBase< T >::data_.

Referenced by SSAGES::ANN::ANN(), SSAGES::Grid< T >::BuildGrid(), SSAGES::CFF::CFF(), and SSAGES::ANN::TrainNetwork().

Here is the caller graph for this function:

◆ wrapIndices()

template<typename T >

std::vector<int> SSAGES::GridBase< T >::wrapIndices ( const std::vector< int > & indices ) const

inlineprotected

Wrap the index around periodic boundaries.

Parameters

indices Current indices of grid to wrap

Returns: Resulting indices after wrapping

Definition at line 62 of file GridBase.h.

     {
         std::vector<int> newIndices(indices);
         for (size_t i = 0; i < dimension_; ++i) {
             if (!GetPeriodic(i)) {
                 continue;
             }
  
             int index = indices.at(i);
             while (index < 0) { index += numPoints_[i]; }
             while (index >= numPoints_[i]) { index -= numPoints_[i]; }
         if(index == numPoints_[i]-1)
         index = 0;
             newIndices.at(i) = index;
         }
  
         return newIndices;
     }

References SSAGES::GridBase< T >::dimension_, SSAGES::GridBase< T >::GetPeriodic(), and SSAGES::GridBase< T >::numPoints_.

Referenced by SSAGES::GridBase< T >::GetIndices().

Here is the call graph for this function:

Here is the caller graph for this function:

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

/home/michael/development/SSAGES/src/Grids/GridBase.h

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

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

Constructor & Destructor Documentation

◆ GridBase()

Member Function Documentation

◆ at() [1/10]

◆ at() [2/10]

◆ at() [3/10]

◆ at() [4/10]

◆ at() [5/10]

◆ at() [6/10]

◆ at() [7/10]

◆ at() [8/10]

◆ at() [9/10]

◆ at() [10/10]

◆ data() [1/2]

◆ data() [2/2]

◆ GetCoordinate()

◆ GetCoordinates()

◆ GetDimension()

◆ GetIndex()

◆ GetIndices()

◆ GetLower() [1/2]

◆ GetLower() [2/2]

◆ GetNumPoints() [1/2]

◆ GetNumPoints() [2/2]

◆ GetPeriodic() [1/2]

◆ GetPeriodic() [2/2]

◆ GetUpper() [1/2]

◆ GetUpper() [2/2]

◆ mapTo1d()

◆ operator[]() [1/10]

◆ operator[]() [2/10]

◆ operator[]() [3/10]

◆ operator[]() [4/10]

◆ operator[]() [5/10]

◆ operator[]() [6/10]

◆ operator[]() [7/10]

◆ operator[]() [8/10]

◆ operator[]() [9/10]

◆ operator[]() [10/10]

◆ size()

◆ wrapIndices()

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