SSAGES::BasisEvaluator Class Reference

Calculates the inner product of all the basis functions and the histogram. More...

#include <Basis.h>

Public Member Functions
	BasisEvaluator (const std::vector< BasisFunction * > &functions)
	Constructor. More...
void	CoeffInit ()
	Initializes coefficient lookup vector. More...
void	BasisInit ()
	Creates lookup table for basis functions.
void	UpdateBias (Grid< double > *bias, Grid< std::vector< double >> *grad)
	Outputs the basis projection at a specific coordinate. More...
double	UpdateCoeff (const std::vector< double > &array, Grid< unsigned int > *hist)
std::vector< double >	GetCoeff (void)
	Gets the coefficient array. More...
void	SetCoeff (const std::vector< double > &coeff)
	Set the coefficient array in the event of a restart run. More...

Private Attributes
std::vector< Map >	coeff_
	Vector of basis function coefficients.
std::vector< BasisFunction * >	functions_
	Vector of basis functions.
std::vector< BasisLUT >	lookup_
	Lookup table for basis functions.

Detailed Description

Calculates the inner product of all the basis functions and the histogram.

Definition at line 347 of file Basis.h.

Constructor & Destructor Documentation

BasisEvaluator()

SSAGES::BasisEvaluator::BasisEvaluator ( const std::vector< BasisFunction * > &  functions )

inline

Constructor.

Parameters

functions

Vector of BasisFunction members.

Initialize the evaluator.

Definition at line 361 of file Basis.h.

                                                                   : 
            functions_(functions)
        {
            CoeffInit();
            BasisInit();
        }

References BasisInit(), and CoeffInit().

Here is the call graph for this function:

Member Function Documentation

CoeffInit()

void SSAGES::BasisEvaluator::CoeffInit

(

void

)

Initializes coefficient lookup vector.

For now, when the basis evaluator is called it will store all the values of the basis functions into a lookup table. [Subject to change]

Definition at line 100 of file Basis.cpp.

    {     
        double coeff_size = 1;
        //Get the size of the number of coefficients + 1
        for(size_t i = 0; i < functions_.size(); ++i)
        {
            coeff_size *= functions_[i]->GetOrder()+1;
        }
 
        std::vector<int> jdx(functions_.size(), 0);
        Map temp_map(jdx,0.0);
        //Initialize the mapping for the coeff function
        for(size_t i = 0; i < coeff_size; ++i)
        {
            for(size_t j = 0; j < jdx.size(); ++j)
            {
                if(jdx[j] > 0 && jdx[j] % (functions_[j]->GetOrder()+1) == 0)
                {
                    if(j != functions_.size() - 1)
                    { 
                        jdx[j+1]++;
                        jdx[j] = 0;
                    }
                }
                temp_map.map[j] = jdx[j];
                temp_map.value  = 0; 
            }
            coeff_.push_back(temp_map);           
            jdx[0]++;
        }
    }

References coeff_, functions_, SSAGES::Map::map, and SSAGES::Map::value.

Referenced by BasisEvaluator().

Here is the caller graph for this function:

GetCoeff()

std::vector<double> SSAGES::BasisEvaluator::GetCoeff ( void  )

inline

Gets the coefficient array.

Returns

Vector of current coefficients

Definition at line 394 of file Basis.h.

        {
            std::vector<double> coeffArray (coeff_.size(),0);
            for (size_t i=0; i<coeff_.size(); i++)
            {
                coeffArray[i] = coeff_[i].value;
            }
            return coeffArray; 
        }

References coeff_.

SetCoeff()

void SSAGES::BasisEvaluator::SetCoeff ( const std::vector< double > &  coeff )

inline

Set the coefficient array in the event of a restart run.

Parameters

coeff

Vector of coefficients to set

Definition at line 408 of file Basis.h.

        {
            size_t ii = 0;
            for(auto& val : coeff_) 
            {    
                val.value = coeff[ii];
                ii++;
            }
        }

References coeff_.

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

Here is the caller graph for this function:

UpdateBias()

void SSAGES::BasisEvaluator::UpdateBias	(	Grid< double > *	bias,
		Grid< std::vector< double >> *	grad
	)

Outputs the basis projection at a specific coordinate.

Parameters

bias	Grid of current bias
grad	Grid of gradient to be applied

Definition at line 154 of file Basis.cpp.

    { 
        double basis;
        double temp;
        size_t j = 0;
        int nbins;
 
        for(Grid<double>::iterator it = bias->begin(); it != bias->end(); ++it, ++j)
        {
            std::vector<double> tmp_grad (functions_.size(),0);
            double tmp_bias = 0;
            for (size_t i = 1; i < coeff_.size(); ++i)
            {
                basis = 1.0;
                for (size_t l = 0; l < functions_.size(); l++)
                {
                    temp = 1.0;
                    //For the gradients we only evaluate the gradient for diagonal terms
                    //Off diagonals are the basis set value
                    for (size_t k = 0; k < functions_.size(); k++)
                    {
                        nbins = bias->GetNumPoints(k);
                        temp *= l == k ?  lookup_[k].derivs[it.index(k) + coeff_[i].map[k]*nbins] * functions_[l]->GetRange() / (bias->GetUpper(l) - bias->GetLower(l))
                                       :  lookup_[k].values[it.index(k) + coeff_[i].map[k]*nbins];
                    }
                    tmp_grad[l] -= coeff_[i].value * temp;
                    nbins = bias->GetNumPoints(l);
                    basis *= lookup_[l].values[it.index(l) + coeff_[i].map[l]*nbins];
                }
                //Update the bias values
                tmp_bias += coeff_[i].value * basis;
                //Store the gradient values
            }
            grad->at(it.coordinates()) = tmp_grad;
            *it = tmp_bias;
        }
    }

References SSAGES::Grid< T >::begin(), coeff_, SSAGES::Grid< T >::end(), functions_, SSAGES::GridBase< T >::GetLower(), SSAGES::GridBase< T >::GetNumPoints(), SSAGES::GridBase< T >::GetUpper(), and lookup_.

Here is the call graph for this function:

UpdateCoeff()

double SSAGES::BasisEvaluator::UpdateCoeff	(	const std::vector< double > &	array,
		Grid< unsigned int > *	hist
	)

Calculates the inner product of the basis set and the biased histogram This function then returns the coefficients from this calculation

Parameters

array	Basis set.
hist	Biased histrogram.

Returns

Inner product of the basis set and the biased histogram.

Definition at line 194 of file Basis.cpp.

    {
        double coeffTemp = 0;
        double sum = 0;
 
        for(auto& coeff : coeff_)
        {
            // The method uses a standard integration
            size_t j = 0;
            coeffTemp = coeff.value;
            coeff.value = 0.0;
            for(Grid<unsigned int>::iterator it2 = hist->begin(); it2 != hist->end(); ++it2, ++j)
            { 
 
                double weight = std::pow(2.0,functions_.size());
 
                // This adds in a trap-rule type weighting which lowers error significantly at the boundaries
                for(size_t k = 0; k < functions_.size(); ++k)
                {
                    if( it2.index(k) == 0 ||
                        it2.index(k) == hist->GetNumPoints(k)-1)
                        weight /= 2.0;
                }
                /*The numerical integration of the biased histogram across the entirety of CV space
                 *All calculations include the normalization as well
                 */
                double basis = 1.0;
 
                for(size_t l = 0; l < functions_.size(); l++)
                {
                    int nbins = hist->GetNumPoints(l);
                    basis *= lookup_[l].values[it2.index(l) + coeff.map[l]*nbins]*functions_[l]->GetRange()/nbins;
                    //Normalize the values by the associated value
                    basis *= functions_[l]->GetNorm(coeff.map[l])*functions_[l]->Weight(it2.coordinate(l));
                }
                coeff.value += basis * array[j] * weight/std::pow(2.0,functions_.size());
            }
            coeffTemp -= coeff.value;
            //std::cout<<coeffTemp<<std::endl;
            sum += fabs(coeffTemp);
        }
        return sum;
    }

References SSAGES::Grid< T >::begin(), coeff_, SSAGES::Grid< T >::end(), functions_, SSAGES::GridBase< T >::GetNumPoints(), and lookup_.

Here is the call graph for this function:

---

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

• /home/michael/development/SSAGES/src/Utility/Basis.h
• /home/michael/development/SSAGES/src/Utility/Basis.cpp