A class to store forcefields and handle minimization. More...

#include <ForceField.h>

Public Member Functions
	ForceField (unsigned int dimension=3)
	construct with a dimension
	~ForceField ()
void	initialize ()
	does initialization
double	calcEnergy () const
	calculates and returns the energy based on existing positions in the forcefield
double	calcEnergy (double *pos)
	calculates and returns the energy of the position passed in
void	calcGrad (double *forces) const
	calculates the gradient of the energy at the current position
void	calcGrad (double pos, double forces)
	calculates the gradient of the energy at the provided position
int	minimize (unsigned int maxIts=200, double forceTol=1e-4, double energyTol=1e-6)
	minimizes the energy of the system by following gradients
RDGeom::PointPtrVect &	positions ()
	returns a reference to our points (a PointPtrVect)
const RDGeom::PointPtrVect &	positions () const
ContribPtrVect &	contribs ()
	returns a reference to our contribs (a ContribPtrVect)
const ContribPtrVect &	contribs () const
double	distance (unsigned int i, unsigned int j, double *pos=0)
	returns the distance between two points
double	distance (unsigned int i, unsigned int j, double *pos=0) const
	returns the distance between two points
unsigned int	dimension () const
	returns the dimension of the forcefield
unsigned int	numPoints () const
	returns the number of points the ForceField is handling
INT_VECT &	fixedPoints ()
const INT_VECT &	fixedPoints () const
Protected Member Functions
void	scatter (double *pos) const
	scatter our positions into an array
void	gather (double *pos)
	update our positions from an array
void	initDistanceMatrix ()
	initializes our internal distance matrix
Protected Attributes
unsigned int	d_dimension
bool	df_init
	whether or not we've been initialized
unsigned int	d_numPoints
	the number of active points
double *	dp_distMat
	our internal distance matrix
RDGeom::PointPtrVect	d_positions
	pointers to the points we're using
ContribPtrVect	d_contribs
	contributions to the energy
INT_VECT	d_fixedPoints
unsigned int	d_matSize

Detailed Description

A class to store forcefields and handle minimization.

A force field is used like this (schematically):

       ForceField ff;

       // add contributions:
       for contrib in contribs:
         ff.contribs().push_back(contrib);
         
       // set up the points:
       for positionPtr in positions:
         ff.positions().push_back(point);

       // initialize:
       ff.initialize()

       // and minimize:
       needsMore = ff.minimize();

Notes:

The ForceField owns its contributions, which are stored using smart pointers.
Distance calculations are currently lazy; the full distance matrix is never generated. In systems where the distance matrix is not sparse, this is almost certainly inefficient.

Definition at line 55 of file ForceField.h.

Constructor & Destructor Documentation

ForceFields::ForceField::ForceField ( unsigned int dimension = 3 ) [inline]

construct with a dimension

Definition at line 58 of file ForceField.h.

ForceFields::ForceField::~ForceField ( )

Member Function Documentation

double ForceFields::ForceField::calcEnergy ( ) const

calculates and returns the energy based on existing positions in the forcefield

Returns:: the current energy

Note: This function is less efficient than calcEnergy with postions passed in as double * the positions need to be converted to double * here

double ForceFields::ForceField::calcEnergy ( double * pos )

calculates and returns the energy of the position passed in

Parameters:

pos an array of doubles. Should be 3*this->numPoints() long.

Returns:: the current energy

Side effects:

Calling this resets the current distance matrix
The individual contributions may further update the distance matrix

void ForceFields::ForceField::calcGrad ( double * forces ) const

calculates the gradient of the energy at the current position

Parameters:

forces an array of doubles. Should be 3*this->numPoints() long.

Note: This function is less efficient than calcGrad with positions passed in the positions need to be converted to double * here

void ForceFields::ForceField::calcGrad	(	double *	pos,
		double *	forces
	)

calculates the gradient of the energy at the provided position

Parameters:

	pos	an array of doubles. Should be `3*this->numPoints()` long.
	forces	an array of doubles. Should be `3*this->numPoints()` long.

Side effects:

The individual contributions may modify the distance matrix

ContribPtrVect& ForceFields::ForceField::contribs ( ) [inline]

returns a reference to our contribs (a ContribPtrVect)

Definition at line 136 of file ForceField.h.

References d_contribs.

const ContribPtrVect& ForceFields::ForceField::contribs ( ) const [inline]

Definition at line 137 of file ForceField.h.

References d_contribs.

unsigned int ForceFields::ForceField::dimension ( ) const [inline]

returns the dimension of the forcefield

Definition at line 171 of file ForceField.h.

References d_dimension.

Referenced by DistGeom::FourthDimContrib::FourthDimContrib().

double ForceFields::ForceField::distance	(	unsigned int	i,
		unsigned int	j,
		double *	pos = `0`
	)

returns the distance between two points

Parameters:

	i	point index
	j	point index
	pos	(optional) If this argument is provided, it will be used to provide the positions of points. `pos` should be `3*this->numPoints()` long.

Returns:: the distance

Side effects:

if the distance between i and j has not previously been calculated, our internal distance matrix will be updated.

double ForceFields::ForceField::distance	(	unsigned int	i,
		unsigned int	j,
		double *	pos = `0`
	)			const

returns the distance between two points

Parameters:

	i	point index
	j	point index
	pos	(optional) If this argument is provided, it will be used to provide the positions of points. `pos` should be `3*this->numPoints()` long.