GrapheneLUTPotential Class Reference

Returns van der Waals' potential between a helium adatom and a graphene sheet using summation in reciprocal space. More...

#include <potential.h>

Inheritance diagram for GrapheneLUTPotential:

Collaboration diagram for GrapheneLUTPotential:

Public Member Functions
	GrapheneLUTPotential (const double, const double, const double, const double, const double, const Container *)
	Constructor.
	~GrapheneLUTPotential ()
	Destructor.
double	V (const dVec &r)
	Return the value of the van der Waals' interaction between a graphene sheet and a helium adatom at a position, r, above the sheet. More...
dVec	gradV (const dVec &r)
	Return the gradient of the van der Waals' interaction between a graphene sheet and a helium adatom at a position, r, above the sheet. More...
Array< dVec, 1 >	initialConfig (const Container *, MTRand &, const int)
	Initial configuration corresponding to graphene-helium vdW 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

Returns van der Waals' potential between a helium adatom and a graphene sheet using summation in reciprocal space.

Author: Nathan Nichols & Adrian Del Maestro Returns the potential energy resulting from a van der Waals' interaction between a helium adatom and a fixed infinite graphene lattice

Definition at line 1222 of file potential.h.

Member Function Documentation

gradV()

dVec GrapheneLUTPotential::gradV ( const dVec &  r )

virtual

Return the gradient of the van der Waals' interaction between a graphene sheet and a helium adatom at a position, r, above the sheet.

Parameters

r	the position of a helium particle

Returns

the gradient of the van der Waals' potential for graphene-helium

Reimplemented from PotentialBase.

Definition at line 2902 of file potential.cpp.

                                              {
 
    return 0.0;
 
    /* double x = r[0]; */
    /* double y = r[1]; */
    /* double z = r[NDIM-1]+(Lzo2); */
    /* int zindex = int((z-zmin)/dr); */
    /* dVec dv = 0.0; */
    
    /* if (z < zmin) */ 
    /*     return dv; */
 
    /* if (zindex >= tableLength) { */
    /*     dv[NDIM-1] += q*(epsilon*sigma*sigma*2.*M_PI/A)* 4. * (pow(sigma/z,4) - pow(sigma/z,10)) / z; */
    /*     return dv; */
    /* } */
    
    /* dv[NDIM-1] = gradvg(0,zindex); */
    /* double gdotb1 = 0.; */
    /* double gdotb2 = 0.; */
 
    /* int k = 0; */
    
    /* /1* NB: this has not been optimized!!! *1/ */
    /* for (int m = -gnum; m < gnum+1; m++) { */
    /*     for (int n = -gnum; n < gnum+1; n++) { */
    /*         k = karr(m+gnum,n+gnum); */
    /*         if((m != 0) or (n != 0)) { */
    /*             gdotb1 = ((m*g1x + n*g2x)*(b1x+x)) + ((m*g1y + n*g2y)*(b1y+y)); */
    /*             gdotb2 = ((m*g1x + n*g2x)*(b2x+x)) + ((m*g1y + n*g2y)*(b2y+y)); */
                
    /*             dv[0] += -(g1x*m+g2x*n) * (sin(gdotb1) + sin(gdotb2))*vg(k,zindex); */
    /*             dv[1] += -(g1y*m+g2y*n) * (sin(gdotb1) + sin(gdotb2))*vg(k,zindex); */
    /*             dv[NDIM-1] += (cos(gdotb1)+cos(gdotb2))*gradvg(k,zindex); */
    /*         } */
    /*     } */
    /* } */
    /* return dv; */
}

initialConfig()

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

virtual

Initial configuration corresponding to graphene-helium vdW potential.

Return an initial particle configuration.

We create particles at random locations above the graphene sheet.

Reimplemented from PotentialBase.

Definition at line 2948 of file potential.cpp.

                                {
    /* The particle configuration */
    Array<dVec,1> initialPos(numParticles);
    initialPos = 0.0;
    
    int Nlayer = round(boxPtr->side[0]*boxPtr->side[1]/a1x/a1y/4);
    int numX = round(boxPtr->side[0]/a1x/2);
    int numY = round(boxPtr->side[1]/a1y/2);
    double gridX = boxPtr->side[0]/numX;
    double gridY = boxPtr->side[1]/numY;
    int gridSize = 0;
    if (3*Nlayer < numParticles){
        gridSize = numParticles - 3*Nlayer;
    }
    int numInLayers = numParticles - gridSize;
    int layerNum = 0;
    int iShifted = 0;
    dVec pos;
    for (int i = 0; i < numInLayers; i++){
        layerNum = i/Nlayer;
        iShifted = i - (layerNum*Nlayer);
        pos[0] = ((iShifted % numX) + 0.5)*gridX - (boxPtr->side[0]/2);
        pos[1] = ((iShifted / numX) + 0.5)*gridY - (boxPtr->side[1]/2);
        pos[NDIM-1] = ((layerNum+1)*3.0)-(boxPtr->side[NDIM-1]/2);
        boxPtr->putInside (pos);
        initialPos(i) = pos;
    }
    if (gridSize) {
        int initCubePart = ceil(pow(1.0*gridSize,1.0/(1.0*NDIM)));
        dVec initSide;
        for (int i = 0; i < NDIM - 1; i++) {
            initSide[i] = boxPtr->side[i]/initCubePart;
        }
 
        initSide[NDIM-1] = (boxPtr->side[NDIM-1] - 12.0)/initCubePart;
    
        for (int n = 0; n < gridSize; n++) {
            pos[0] = (((n % initCubePart) + 0.5) * initSide[0]) - (boxPtr->side[0]/2);
            pos[1] = (((n / initCubePart) + 0.5) * initSide[1]) - (boxPtr->side[1]/2);
            pos[NDIM-1] = (((n / initCubePart / initCubePart) + 0.5) * initSide[NDIM-1]) - (boxPtr->side[NDIM-1]/2) + 12.0;
            boxPtr->putInside (pos);
            initialPos(n + numInLayers) = pos;
        }
    }
    return initialPos;
}

Here is the call graph for this function:

V()

double GrapheneLUTPotential::V ( const dVec &  r )

virtual

Return the value of the van der Waals' interaction between a graphene sheet and a helium adatom at a position, r, above the sheet.

Parameters

r	the position of a helium particle

Returns

the van der Waals' potential for graphene-helium

Reimplemented from PotentialBase.

Definition at line 2853 of file potential.cpp.

                                            {
    
    double z = r[2]+(Lzo2);
    if (z < zmin) 
        return V_zmin;
 
    /* A sigmoid to represent the hard-wall */
    double VWall = V_zmin/(1.0+exp(-invWallWidth*(z-zWall)));
    
    int zindex = int((z-zmin)/dr);
    if (zindex >= tableLength)
        return q*(epsilon*sigma*sigma*2.*M_PI/A)*( ((2./5.)*pow((sigma/z),10)) - pow((sigma/z),4) );
 
    double x1 = r[0]+b1x;
    double x2 = r[0]+b2x;
    double y1 = r[1]+b1y;
    double y2 = r[1]+b2y;
 
    double mx,my;
    double v = vg(0,zindex);
 
    int ig = 1;
    for (int m = -gnum; m <= gnum; m++) {
        mx = m*g1x;
        my = m*g1y;
        for (int n = 1; n <= gnum; n++) {
            v += 2.0*(cos((mx + n*g2x)*x1 + (my + n*g2y)*y1) + 
                      cos((mx + n*g2x)*x2 + (my + n*g2y)*y2)) * vg(gMagID(ig),zindex); 
            ig++;
        }
    }
 
    for (int m=1; m <= gnum; m++){
        mx = m*g1x;
        my = m*g1y;
        v += 2.0*(cos(mx*x1 + my*y1) + cos(mx*x2 + my*y2)) * vg(gMagID(ig),zindex);
        ig++;
    }
 
    return v + VWall;
}

---

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

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