PlatedLJCylinderPotential Class Reference

Computes the value of the external wall potential for a plated cylindrical cavity. More...

#include <potential.h>

Inheritance diagram for PlatedLJCylinderPotential:

Collaboration diagram for PlatedLJCylinderPotential:

Public Member Functions
	PlatedLJCylinderPotential (const double, const double, const double, const double, const double)
	Constructor. More...
	~PlatedLJCylinderPotential ()
	Destructor.
double	V (const dVec &r)
	The integrated LJ Wall potential.
dVec	gradV (const dVec &)
	Return the gradient of aziz potential for separation r using a lookup table.
double	grad2V (const dVec &)
	Return the Laplacian of aziz potential for separation r using a lookup table.
Array< dVec, 1 >	initialConfig (const Container *, MTRand &, const int)
	Initial configuration corresponding to the LJ cylinder 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	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...
Public Member Functions inherited from TabulatedPotential
	TabulatedPotential ()
	Constructor.
virtual	~TabulatedPotential ()
	Destructor.

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.
Protected Member Functions inherited from TabulatedPotential
void	initLookupTable (const double, const double)
	Given a discretization factor and the system size, create and fill the lookup tables for the potential and its derivative.
virtual double	newtonGregory (const Array< double, 1 > &, const TinyVector< double, 2 > &, const double)
	Use the Newton-Gregory forward difference method to do a 2-point lookup on the potential table. More...
virtual double	direct (const Array< double, 1 > &, const TinyVector< double, 2 > &, const double)
	Use a direct lookup for the potential table. More...
Protected Attributes inherited from TabulatedPotential
Array< double, 1 >	lookupV
	A potential lookup table.
Array< double, 1 >	lookupdVdr
	A lookup table for dVint/dr.
Array< double, 1 >	lookupd2Vdr2
	A lookup table for d2Vint/dr2.
double	dr
	The discretization for the lookup table.
int	tableLength
	The number of elements in the lookup table.
TinyVector< double, 2 >	extV
	Extremal value of V.
TinyVector< double, 2 >	extdVdr
	Extremal value of dV/dr.
TinyVector< double, 2 >	extd2Vdr2
	Extremal value of d2V/dr2.

Detailed Description

Computes the value of the external wall potential for a plated cylindrical cavity.

Definition at line 440 of file potential.h.

Constructor & Destructor Documentation

PlatedLJCylinderPotential()

PlatedLJCylinderPotential::PlatedLJCylinderPotential	(	const double	Ro_,
		const double	Rw,
		const double	sigmaPlated_,
		const double	epsilonPlated_,
		const double	densityPlated_
	)

Constructor.

We create a nested Lennard-Jones cylinder, which uses a lookup table to hold the value of the integrated 6-12 potential for helium atoms interacting with the walls of a nanpore pre-plated with an adsorbed gas.

Parameters

radius

The radius of the cylinder

Definition at line 800 of file potential.cpp.

                                                                                             : 
    PotentialBase(),
    TabulatedPotential()
{
    /* The outer radius of the tube */
    Ro = Ro_;
 
    /* Plating substrates */
    densityPlated = densityPlated_; //0.207; // atoms / angstrom^3
    epsilonPlated = epsilonPlated_; //36.13613;    // Kelvin
    sigmaPlated   = sigmaPlated_; //3.0225;    // angstroms
    Ri = Ro-Rw; //3.5; 
 
    // Neon Values
    /* densityPlated = 0.207; // atoms / angstrom^3 FIXME */
    /* epsilonPlated = 20.161242;    // Kelvin */
    /* sigmaPlated   = 2.711;    // angstroms */
    /* Ri = Ro-(1.52*2); //FIXME Fix hardcoded R2 */
 
    /* Substrate parameters for MCM-41 obtained by fitting 
     * @see https://nano.delmaestro.org/index.php?title=Effective_external_potential_(nanopores) 
     */
    density = 1.000;   // atoms / angstrom^3
    epsilon = 1.59;    // Kelvin
    sigma   = 3.44;    // angstroms
 
    /* We choose a mesh consisting of 10^6 points, and create the lookup table */
    dR = (1.0E-6)*Ri;
    initLookupTable(dR,Ri);
    
    /* Find the minimun of the potential */
    minV = 1.0E5;
    for (int n = 0; n < tableLength; n++) {
        if (lookupV(n) < minV)
            minV = lookupV(n);
    }
 
    /* The extremal values for the lookup table */
    extV = valueV(0.0),valueV(Ri);
    extdVdr = valuedVdr(0.0),valuedVdr(Ri);
}

Here is the call graph for this function:

Member Function Documentation

initialConfig()

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

virtual

Initial configuration corresponding to the LJ cylinder potential.

Return an initial particle configuration.

Return a set of initial positions inside the cylinder.

Reimplemented from PotentialBase.

Definition at line 948 of file potential.cpp.

                                {
 
    /* The particle configuration */
    Array<dVec,1> initialPos(numParticles);
    initialPos = 0.0;
 
    /* We shift the radius inward to account for the excluded volume from the
     * hard wall.  This represents the largest prism that can be put
     * inside a cylinder. */
    dVec lside;
    lside[0] = lside[1] = sqrt(2.0)*(Ri-sigmaPlated);
    lside[2] = boxPtr->side[NDIM-1];
 
    /* Get the linear size per particle */
    double initSide = pow((1.0*numParticles/product(lside)),-1.0/(1.0*NDIM));
 
    /* We determine the number of initial grid boxes there are in 
     * in each dimension and compute their size */
    int totNumGridBoxes = 1;
    iVec numNNGrid;
    dVec sizeNNGrid;
 
    for (int i = 0; i < NDIM; i++) {
        numNNGrid[i] = static_cast<int>(ceil((lside[i] / initSide) - EPS));
 
        /* Make sure we have at least one grid box */
        if (numNNGrid[i] < 1)
            numNNGrid[i] = 1;
 
        /* Compute the actual size of the grid */
        sizeNNGrid[i] = lside[i] / (1.0 * numNNGrid[i]);
 
        /* Determine the total number of grid boxes */
        totNumGridBoxes *= numNNGrid[i];
    }
 
    /* Now, we place the particles at the middle of each box */
    PIMC_ASSERT(totNumGridBoxes>=numParticles);
    dVec pos;
    for (int n = 0; n < totNumGridBoxes; n++) {
 
        iVec gridIndex;
        for (int i = 0; i < NDIM; i++) {
            int scale = 1;
            for (int j = i+1; j < NDIM; j++) 
                scale *= numNNGrid[j];
            gridIndex[i] = (n/scale) % numNNGrid[i];
        }
 
        for (int i = 0; i < NDIM; i++) 
            pos[i] = (gridIndex[i]+0.5)*sizeNNGrid[i] - 0.5*lside[i];
 
        boxPtr->putInside(pos);
 
        if (n < numParticles)
            initialPos(n) = pos;
        else 
            break;
    }
 
    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