SSAGES::Grid< T > Class Template Reference

Basic Grid. More...

#include <Grid.h>

Inheritance diagram for SSAGES::Grid< T >:

Classes
class	GridIterator
	Custom Iterator. More...

Public Types
typedef GridIterator< T >	iterator
	Custom iterator over a grid.
typedef GridIterator< const T >	const_iterator
	Custom constant iterator over a grid.

Public Member Functions
	Grid (std::vector< int > numPoints, std::vector< double > lower, std::vector< double > upper, std::vector< bool > isPeriodic)
	Constructor. More...
iterator	begin ()
	Return iterator at first grid point. More...
iterator	end ()
	Return iterator after last valid grid point. More...
const_iterator	begin () const
	Return const iterator at first grid point. More...
const_iterator	end () const
	Return const iterator after last valid grid point. More...
void	WriteToFile (const std::string &file)
	Write grid out to file. More...
void	LoadFromFile (const std::string &filename)
	Builds a grid from file. More...
Public Member Functions inherited from SSAGES::GridBase< T >
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...
double	GetInterpolated (const std::vector< double > &x)
	Return linear interpolation on a coordinate. More...
int	GetIndex (double x) const
	Return the Grid index for a one-dimensional grid. More...
std::vector< double >	GetCoordinates (const std::vector< int > &indices)
	Return coordinates of the grid center points. 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...

Static Public Member Functions
static Grid< T > *	BuildGrid (const Json::Value &json)
	Set up the grid. More...
static Grid< T > *	BuildGrid (const Json::Value &json, const std::string &path)
	Set up the grid. More...

Private Member Functions
size_t	mapTo1d (const std::vector< int > &indices) const override
	Map d-dimensional indices to 1-d data vector. More...

Additional Inherited Members
Protected Member Functions inherited from SSAGES::GridBase< T >
std::vector< int >	wrapIndices (const std::vector< int > &indices) const
	Wrap the index around periodic boundaries.
	GridBase (std::vector< int > numPoints, std::vector< double > lower, std::vector< double > upper, std::vector< bool > isPeriodic)
	Constructor. More...
Protected Attributes inherited from SSAGES::GridBase< T >
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::Grid< T >

Basic Grid.

Template Parameters

T	type of data to be stored in the grid.

A Grid is a method to store data in SSAGES. It is used to discretize a continuous number, typically a collective variable or a function, into number_points grid points. At each grid point, an arbitrary type of data can be stored, specified via the template parameter T.

The grid can be of arbitrary dimension. For each dimension, the lower bound, the upper bound and the number of grid points need to be specified. Furthermore, the grid can be defined as periodic or non-periodic in the respective dimension. By default, the grid is non-periodic. The grid points are indexed from 0 to number_points-1 following the standard C/C++ convention.

The grid spacing Delta is given by (upper - lower)/number_points. Thus, grid point n corresponds to the interval [lower + n*Delta, lower + (n+1)*Delta). Note that n follows the C/C++ convention, i.e. n = 0 for the first interval. The bin indices pertaining to a given point can be obtained via GetIndices().

Definition at line 58 of file Grid.h.

Constructor & Destructor Documentation

template<typename T>

SSAGES::Grid< T >::Grid ( std::vector< int >  numPoints, std::vector< double >  lower, std::vector< double >  upper, std::vector< bool >  isPeriodic  )

inline

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 dimension of the grid is determined by the size of the parameter vectors.

Definition at line 103 of file Grid.h.

Referenced by SSAGES::Grid< int >::BuildGrid().

      : GridBase<T>(numPoints, lower, upper, isPeriodic)
    {
        size_t data_size = 1;
        for (size_t d = 0; d < GridBase<T>::GetDimension(); ++d) {
            size_t storage_size = GridBase<T>::GetNumPoints(d);
            data_size *= storage_size;
        }

        GridBase<T>::data_.resize(data_size);
    }

Here is the caller graph for this function:

Member Function Documentation

template<typename T>

iterator SSAGES::Grid< T >::begin ( )

inline

Return iterator at first grid point.

Returns

Iterator at first grid point.

The first grid point is defined as the grid point with index 0 in all dimensions.

Definition at line 524 of file Grid.h.

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

    {
        std::vector<int> indices(GridBase<T>::GetDimension(), 0);

        return iterator(indices, this);
    }

Here is the caller graph for this function:

template<typename T>

const_iterator SSAGES::Grid< T >::begin ( ) const

inline

Return const iterator at first grid point.

Returns

Const iterator at first grid point.

The first grid point is defined as the grid point with index 0 in all dimensions.

Definition at line 555 of file Grid.h.

    {
        std::vector<int> indices(GridBase<T>::GetDimension(), 0);

        return iterator(indices, this);
    }

template<typename T>

static Grid<T>* SSAGES::Grid< T >::BuildGrid ( const Json::Value &  json )

inlinestatic

Set up the grid.

Parameters

json	JSON value containing all input information.

Returns

Pointer to the newly built grid.

This function builds a grid from a JSON node. It will return a nullptr if an unknown error occured, but generally, it will throw a BuildException of failure.

Definition at line 127 of file Grid.h.

Referenced by SSAGES::Grid< int >::BuildGrid().

    {
        return BuildGrid(json, "#/Grid");
    }

Here is the caller graph for this function:

template<typename T>

static Grid<T>* SSAGES::Grid< T >::BuildGrid ( const Json::Value &  json, const std::string &  path  )

inlinestatic

Set up the grid.

Parameters

json	JSON Value containing all input information.
path	Path for JSON path specification.

Returns

Pointer to the newly built grid.

This function builds a grid from a JSON node. It will return a nullptr if an unknown error occured, but generally, it will throw a BuildException on failure.

Definition at line 142 of file Grid.h.

    {
        Json::ObjectRequirement validator;
        Json::Value schema;
        Json::Reader reader;

        reader.parse(JsonSchema::grid, schema);
        validator.Parse(schema, path);

        // Validate inputs.
        validator.Validate(json, path);
        if (validator.HasErrors()) {
            throw BuildException(validator.GetErrors());
        }

        // Read in Lower Grid edges.
        std::vector<double> lower;
        for (auto &lv : json["lower"]) {
           lower.push_back(lv.asDouble());
        }

        size_t dimension = lower.size();

        // Read in upper grid edges.
        std::vector<double> upper;
        for (auto &uv : json["upper"]) {
            upper.push_back(uv.asDouble());
        }

        if (upper.size() != dimension) {
            throw BuildException({"Number of upper values does not match "
                                  "number of lower values!"});
        }

        // Read in number of points.
        std::vector<int> number_points;
        for (auto &np : json["number_points"]) {
            number_points.push_back(np.asInt());
        }

        if (number_points.size() != dimension) {
            throw BuildException({"Arrays \"lower\" and \"number_points\" do "
                                  "not have the same size!"});
        }

        // Read in periodicity.
        std::vector<bool> isPeriodic;
        for (auto &periodic : json["periodic"]) {
            isPeriodic.push_back(periodic.asBool());
        }

        if (isPeriodic.size() == 0) {
            isPeriodic = std::vector<bool>(dimension, false);
        } else if (isPeriodic.size() != dimension) {
            throw BuildException({"Arrays \"lower\" and \"periodic\" do not "
                                  "have the same size!"});
        }

        // Construct the grid.
        Grid<T>* grid = new Grid(number_points, lower, upper, isPeriodic);

        return grid;
    }

template<typename T>

iterator SSAGES::Grid< T >::end ( )

inline

Return iterator after last valid grid point.

Returns

Iterator after last valid grid point.

The last valid grid point has index num_points - 1 in all dimensions.

Definition at line 537 of file Grid.h.

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

    {
        std::vector<int> indices(GridBase<T>::GetDimension());
        for (size_t i = 0; i < indices.size(); ++i) {
            indices.at(i) = GridBase<T>::GetNumPoints(i) - 1;
        }

        iterator it(indices, this);
        return ++it;
    }

Here is the caller graph for this function:

template<typename T>

const_iterator SSAGES::Grid< T >::end ( ) const

inline

Return const iterator after last valid grid point.

Returns

Const iterator after last valid grid point.

The last valid grid point has index num_points - 1 in all dimensions.

Definition at line 568 of file Grid.h.

    {
        std::vector<int> indices(GridBase<T>::GetDimension());
        for (size_t i = 0; i < indices.size(); ++i) {
            indices.at(i) = GridBase<T>::GetNumPoints(i) - 1;
        }

        iterator it(indices, this);
        return ++it;
    }

template<typename T>

void SSAGES::Grid< T >::LoadFromFile ( const std::string &  filename )

inline

Builds a grid from file.

Parameters

filename

Filename containing grid data.

Returns

Pointer to the newly built grid.

This function builds a grid from a text data file.

Definition at line 626 of file Grid.h.

Referenced by SSAGES::ABF::Build().

    {
        std::ifstream file(filename);
        std::string line, buff; 

        // Skip type for now. 
        std::getline(file, line); 

        // Get dimension.
        {
            int dim = 0;
            std::getline(file, line);
            std::istringstream iss(line);
            iss >> buff >> buff >> dim; 
            if(dim != GridBase<T>::dimension_)
                throw std::invalid_argument(filename + 
                    ": Expected dimension " + std::to_string(GridBase<T>::dimension_) + 
                    " but got " + std::to_string(dim) + " instead.");
        }

        // Get size. 
        {
            std::getline(file, line); 
            std::istringstream iss(line);
            int count = 0;
            auto counts = GridBase<T>::numPoints_;
            iss >> buff >> buff;
            for(int i = 0; iss >> count; ++i)
            {
                if(count != counts[i])
                    throw std::invalid_argument(filename + 
                    ": Expected count " + std::to_string(counts[i]) + 
                    " on dimension " + std::to_string(i) + " but got " + 
                    std::to_string(count) + " instead.");
            }
        }

        // Get lower bounds. 
        {
            std::getline(file, line); 
            std::istringstream iss(line);
            double lower = 0; 
            auto lowers = GridBase<T>::edges_.first; 
            iss >> buff >> buff;
            for(int i = 0; iss >> lower; ++i)
            {
                if(std::abs(lower - lowers[i]) > 1e-8)
                    throw std::invalid_argument(filename + 
                    ": Expected lower " + std::to_string(lowers[i]) + 
                    " on dimension " + std::to_string(i) + " but got " + 
                    std::to_string(lower) + " instead.");
            }
        }

        // Get upper bounds. 
        {
            std::getline(file, line); 
            std::istringstream iss(line);
            double upper = 0; 
            auto uppers = GridBase<T>::edges_.second; 
            iss >> buff >> buff;
            for(int i = 0; iss >> upper; ++i)
            {
                if(std::abs(upper - uppers[i]) > 1e-8)
                    throw std::invalid_argument(filename + 
                    ": Expected upper " + std::to_string(uppers[i]) + 
                    " on dimension " + std::to_string(i) + " but got " + 
                    std::to_string(upper) + " instead.");
            }
        }

        // Get periodic. 
        {
            std::getline(file, line); 
            std::istringstream iss(line);
            bool periodic; 
            auto periodics = GridBase<T>::isPeriodic_; 
            iss >> buff >> buff;
            for(int i = 0; iss >> periodic; ++i)
            {
                if(periodic != periodics[i])
                    throw std::invalid_argument(filename + 
                    ": Expected periodic " + std::to_string(periodics[i]) + 
                    " on dimension " + std::to_string(i) + " but got " + 
                    std::to_string(periodic) + " instead.");
            }
        }

        // Finally load data.
        for(auto& d : GridBase<T>::data_)
        {
            std::getline(file, line);
            std::istringstream iss(line);
            
            // Skip coordinates.
            for(int i = 0; i < GridBase<T>::dimension_; ++i) 
                iss >> buff;
            
            iss >> d;
        }
    }

Here is the caller graph for this function:

template<typename T>

size_t SSAGES::Grid< T >::mapTo1d ( const std::vector< int > &  indices ) const

inlineoverrideprivatevirtual

Map d-dimensional indices to 1-d data vector.

Parameters

indices

Vector specifying the grid point.

Returns

Index of 1d data vector.

Map a set of indices to the index of the 1d data vector. Keep in mind, that the data includes underflow (index -1) and overflow (index numPoints) bins in periodic dimension.

Implements SSAGES::GridBase< T >.

Definition at line 70 of file Grid.h.

    {
        // Check if an index is out of bounds
        for (size_t i=0; i < GridBase<T>::GetDimension(); ++i) {
            int index = indices.at(i);
            int numpoints = GridBase<T>::GetNumPoints(i);
            if ( index < 0 || index >= numpoints )
            {
                throw std::out_of_range("Grid index out of range.");
            }
        }

        size_t idx = 0;
        size_t fac = 1;
        for (size_t i=0; i < GridBase<T>::GetDimension(); ++i) {
            idx += indices.at(i) * fac;
            fac *= GridBase<T>::GetNumPoints(i);
        }
        return idx;
    }

template<typename T>

void SSAGES::Grid< T >::WriteToFile ( const std::string &  file )

inline

Write grid out to file.

Parameters

filename

Name of the output file.

Definition at line 583 of file Grid.h.

    {
        std::ofstream output(file.c_str(), std::ofstream::out);

        // Print out header.
        output << "#! type grid\n";
        output << "#! dim  " << GridBase<T>::dimension_ << "\n"; 
        output << "#! count "; 
        for(auto& c : GridBase<T>::numPoints_) 
            output << c << " "; 
        output << "\n";
        output << "#! lower "; 
        for(auto& l : GridBase<T>::edges_.first)
            output << l << " "; 
        output << "\n"; 
        output << "#! upper "; 
        for(auto& u : GridBase<T>::edges_.second)
            output << u << " "; 
        output << "\n"; 
        output << "#! periodic "; 
        for(auto p : GridBase<T>::isPeriodic_)
            output << p << " "; 
        output << "\n";

        for(auto it = this->begin(); it != this->end(); ++it)
        {
            auto coords = it.coordinates(); 
            for(auto& c : coords)
                output << std::setprecision(8) << std::fixed << c << " "; 
            output.unsetf(std::ios_base::fixed);
            output << std::setprecision(16) << *it << "\n";
        }

        output.close();
    }

---

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

• /home/cody/SSAGES/src/Grids/Grid.h