FixedAzizPotential Class Reference

Computes the potential energy resulting from a series of fixed helium atoms that are not updated and provide a static 'external' potential. More...

#include <potential.h>

Inheritance diagram for FixedAzizPotential:

Collaboration diagram for FixedAzizPotential:

Public Member Functions
	FixedAzizPotential (const Container *)
	Constructor. More...
	~FixedAzizPotential ()
	Destructor.
double	V (const dVec &r)
	The total potential coming from the interaction of a particle with all fixed particles.
dVec	gradV (const dVec &r)
	The gradient of the total potential coming from the interaction of a particle with all fixed particles.
Array< dVec, 1 >	initialConfig (const Container *, MTRand &, const int)
	Initial configuration corresponding to FixedAziz potential. More...
Public Member Functions inherited from PotentialBase
	PotentialBase ()
	Constructor.
virtual	~PotentialBase ()
	Destructor.
virtual double	V (const dVec &, const dVec &)
	The effective potential for the pair product approximation.
virtual double	grad2V (const dVec &)
	Grad^2 of the potential.
virtual double	dVdlambda (const dVec &, const dVec &)
	The derivative of the effective potential with respect to lambda and tau.
virtual double	dVdtau (const dVec &, const dVec &)
void	output (const double)
	A debug method that output's the potential to a supplied separation. More...
virtual Array< double, 1 >	getExcLen ()
	Array to hold data elements. More...

Additional Inherited Members
Data Fields inherited from PotentialBase
double	tailV
	Tail correction factor.
Protected Member Functions inherited from PotentialBase
double	deltaSeparation (double sep1, double sep2) const
	Return the minimum image difference for 1D separations.

Detailed Description

Computes the potential energy resulting from a series of fixed helium atoms that are not updated and provide a static 'external' potential.

We require a Aziz potential interaction pointer to properly compute the interaction with the static particles.

Definition at line 924 of file potential.h.

Constructor & Destructor Documentation

FixedAzizPotential()

FixedAzizPotential::FixedAzizPotential

(

const Container *

_boxPtr

)

Constructor.

We load the positions of fixed but interacting particles from disk and create a new lookup table which will be used to speed up the computation. The interactions with the fixed particles are assumed to be Aziz.

Definition at line 490 of file potential.cpp.

                                                               :
    aziz(_boxPtr) {
 
    char state;             // Fixed or updateable?
    dVec pos;               // The loaded position
 
    /* Initialize the cutoff^2 */
    rc2 = constants()->rc2();
 
    /* We start with an array of size 500 */
    fixedParticles.resize(500);
 
    /* Here we load both the number and location of fixed helium atoms from disk. */
    numFixedParticles = 0;
    int n = 0;
    while (!communicate()->file("fixed")->stream().eof()) {
        if (communicate()->file("fixed")->stream().peek() == '#') {
            communicate()->file("fixed")->stream().ignore(512,'\n');
        }
        else {
            communicate()->file("fixed")->stream() >> state;
            for (int i = 0; i < NDIM; i++) 
                communicate()->file("fixed")->stream() >> pos[i];
 
            /* If the particle is labelled with an 'F' it is fixed and should
             * be included here */
            if (state == 'F') {
                numFixedParticles++;
                if (numFixedParticles >= int(fixedParticles.size()))
                    fixedParticles.resizeAndPreserve(numFixedParticles);
 
                /* Put the initial position in the container */
                _boxPtr->putInside(pos);
                fixedParticles(n) = pos;
                n++;
            }
            communicate()->file("fixed")->stream().ignore();
        }
    }
 
    fixedParticles.resizeAndPreserve(numFixedParticles);
 
    /* Now that we have the particle positions, create a new lookup table pointer
     * and initialize it */
    lookupPtr = new LookupTable(_boxPtr,1,numFixedParticles);
    lookupPtr->updateGrid(fixedParticles);
 
    /* Resize and initialize our local grid box arrays */
    fixedBeadsInGrid.resize(lookupPtr->getTotNumGridBoxes(),numFixedParticles);
    numFixedBeadsInGrid.resize(lookupPtr->getTotNumGridBoxes());
    fixedBeadsInGrid = XXX;
    numFixedBeadsInGrid = 0;
 
    /* Create a local copy of all beads in each grid box plus nearest neighbors.
     * This will drastically speed up the computing of potential energies. */
    for (n = 0; n < lookupPtr->getTotNumGridBoxes(); n++) {
        lookupPtr->updateFullInteractionList(n,0);
        numFixedBeadsInGrid(n) = lookupPtr->fullNumBeads;
        for (int m = 0; m < lookupPtr->fullNumBeads; m++) 
            fixedBeadsInGrid(n,m) = lookupPtr->fullBeadList(m)[1];
    }
 
}

Here is the call graph for this function:

Member Function Documentation

initialConfig()

Array< dVec, 1 > FixedAzizPotential::initialConfig ( const Container *  boxPtr, MTRand &  random, const int  numParticles  )

virtual

Initial configuration corresponding to FixedAziz potential.

Return an initial particle configuration.

We load an initial configuration from disk, which consists of a number of updateable positions. These positions are stored as NDIM vectors and proceeded by a letter 'U'.

Reimplemented from PotentialBase.

Definition at line 620 of file potential.cpp.

                                {
 
    /* The particle configuration */
    Array<dVec,1> initialPos(1);
    initialPos = 0.0;
 
    int locNumParticles = 0;    // Number of updateable particles
    char state;                 // Update or Fix
    dVec pos;                   // The current position
 
    /* We go through all lines in the fixed input file, discarding any comments
     * and assign the initial positions of the particles */
    int n = 0;
    while (!communicate()->file("fixed")->stream().eof()) {
        if (communicate()->file("fixed")->stream().peek() == '#') {
            communicate()->file("fixed")->stream().ignore(512,'\n');
        }
        else {
            communicate()->file("fixed")->stream() >> state;
            for (int i = 0; i < NDIM; i++)
                communicate()->file("fixed")->stream() >> pos[i];
 
            /* If the particle is labelled with an 'U' it is updatable and should
             * be included */
            if (state == 'U') {
                locNumParticles++;
                initialPos.resizeAndPreserve(locNumParticles);
 
                /* Put the initial position in the box */
                boxPtr->putInside(pos);
 
                /* Assign the position to all time slices*/
                initialPos(n) = pos;
                n++;
            }
            communicate()->file("fixed")->stream().ignore();
        }
    }
 
    /* Reset the file pointer */
    communicate()->file("fixed")->stream().seekg(0, ios::beg);
 
    /* Return the initial Positions */
    return initialPos;
}

Here is the call graph for this function:

---

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

• include/potential.h
• src/potential.cpp