GrapheneLUT3DPotential 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 GrapheneLUT3DPotential:

Collaboration diagram for GrapheneLUT3DPotential:

Public Member Functions
	GrapheneLUT3DPotential (const string, const Container *)
	Constructor.
	~GrapheneLUT3DPotential ()
	Destructor.
double	V (const dVec &)
	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 &)
	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...
double	grad2V (const dVec &)
	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...
Array< dVec, 1 >	initialConfig1 (const Container *, MTRand &, const int)
	Return an initial particle configuration. More...
void	put_in_uc (dVec &, double, double)
void	cartesian_to_uc (dVec &, double, double, double, double)
double	trilinear_interpolation (Array< double, 3 >, dVec, double, double, double)
double	direct_lookup (Array< double, 3 >, dVec, double, double, double)
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...

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 Returns the potential energy resulting from a van der Waals' interaction between a helium adatom and a fixed infinite graphene lattice

Definition at line 1296 of file potential.h.

Member Function Documentation

grad2V()

double GrapheneLUT3DPotential::grad2V ( 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 3120 of file potential.cpp.

                                                   {
    double _grad2V = 0.0;
    if (r[2] + Lzo2 < zmin){ 
        return 0.0;
    }
    dVec _r = r;
    _r[2] += Lzo2 - zmin;
 
    cartesian_to_uc(_r, A11, A12, A21, A22);
    put_in_uc(_r, cell_length_a, cell_length_b);
    _grad2V = trilinear_interpolation(grad2V3d, _r, dx, dy, dz);
    //_grad2V = direct_lookup(grad2V3d, _r, dx, dy, dz);
    return _grad2V;
}

gradV()

dVec GrapheneLUT3DPotential::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 3091 of file potential.cpp.

                                                {
    dVec _gradV = 0.0;
    if (r[2] + Lzo2 < zmin){ 
        return _gradV;
    }
    dVec _r = r;
    _r[2] += Lzo2 - zmin;
 
    cartesian_to_uc(_r, A11, A12, A21, A22);
    put_in_uc(_r, cell_length_a, cell_length_b);
    double _gradV_x = trilinear_interpolation(gradV3d_x, _r, dx, dy, dz);
    double _gradV_y = trilinear_interpolation(gradV3d_y, _r, dx, dy, dz);
    double _gradV_z = trilinear_interpolation(gradV3d_z, _r, dx, dy, dz);
    //double _gradV_x = direct_lookup(gradV3d_x, _r, dx, dy, dz);
    //double _gradV_y = direct_lookup(gradV3d_y, _r, dx, dy, dz);
    //double _gradV_z = direct_lookup(gradV3d_z, _r, dx, dy, dz);
    _gradV(0) = _gradV_x;
    _gradV(1) = _gradV_y;
    _gradV(2) = _gradV_z;
    return _gradV;
}

initialConfig()

Array< dVec, 1 > GrapheneLUT3DPotential::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 3222 of file potential.cpp.

                                {
    
    /* The particle configuration */
    Array<dVec,1> initialPos(numParticles);
    initialPos = 0.0;
 
    dVec side_; 
    side_ = boxPtr->side;
 
    /* The first particle is randomly placed inside the box */
    for (int i = 0; i < NDIM-1; i++)
        initialPos(0)[i] = side_[i]*(-0.5 + random.rand());
    initialPos(0)[NDIM-1] = -0.5*side_[NDIM-1]+zmin + (zWall-zmin)*random.rand();
 
    double hardCoreRadius = 1.00;
 
    /* We keep trying to insert particles with no overlap */
    int numInserted = 1;
    int numAttempts = 0;
    int maxNumAttempts = ipow(10,6);
    dVec trialPos,sep;
    double rsep;
    while ((numInserted < numParticles) && (numAttempts < maxNumAttempts)) {
        numAttempts += 1;
 
        /* Generate a random position inside the box */
        for (int i = 0; i < NDIM-1; i++)
            trialPos[i] = side_[i]*(-0.5 + random.rand());
        trialPos[NDIM-1] = -0.5*side_[NDIM-1]+zmin + (zWall-zmin)*random.rand();
 
        /* Make sure it doesn't overlap with any existing particles. If not,
         * add it, otherwise, break */
        bool acceptParticle = true;
        for (int n = 0; n < numInserted; n++) {
            sep = trialPos - initialPos(n);
            boxPtr->putInBC(sep);
            rsep = sqrt(dot(sep,sep));
            if (rsep < 2*hardCoreRadius) {
                acceptParticle = false;
                break;
            }
        }
 
        if (acceptParticle) {
            initialPos(numInserted) = trialPos;
            numInserted += 1;
        }
 
    }
 
    if (numAttempts == maxNumAttempts) {
        cerr << "Could not construct a valid initial configuration." << endl;
        exit(EXIT_FAILURE);
    }
 
    /* Output configuration to terminal suitable for plotting with python */
    /* cout << "np.array(["; */
    /* for (int n = 0; n < numParticles; n++)  { */
    /*     cout << "["; */
    /*     for (int i = 0; i < NDIM-1; i++) */
    /*         cout << initialPos(n)[i] << ", "; */
    /*     cout << initialPos(n)[NDIM-1] << "]," << endl; */
    /* } */
    /* cout << "])" << endl; */
    /* exit(EXIT_FAILURE); */
 
    return initialPos;
}

Here is the call graph for this function:

initialConfig1()

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

Return an initial particle configuration.

We create particles at random locations above the graphene sheet.

Definition at line 3140 of file potential.cpp.

                                {
    //FIXME We initialize on grid here above zmin, should I do C_1/3 here. I think not because might
    // be hard to get out of if other configurations are more favorable
 
    /* The particle configuration */
    Array<dVec,1> initialPos(numParticles);
    initialPos = 0.0;
 
    /* Get the average inter-particle separation in the accessible volume. */
    double initSide = pow((1.0*numParticles/boxPtr->volume),-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((boxPtr->side[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] = boxPtr->side[i] / (1.0 * numNNGrid[i]);
 
        /* Modify due to the graphene and hard wall */
        if (i == NDIM - 1) {
            sizeNNGrid[i] = (zWall - zmin) / (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];
        }
 
        /* We treat the z-direction differently due to the graphene and wall */
        for (int i = 0; i < NDIM; i++) 
            pos[i] = (gridIndex[i]+0.5)*sizeNNGrid[i] - 0.5*boxPtr->side[i];
        pos[NDIM-1] += zmin;
 
        boxPtr->putInside(pos);
 
        if (n < numParticles)
            initialPos(n) = pos;
        else 
            break;
    }
 
    /* Output for plotting in python */
    /* cout << "np.array(["; */
    /* for (int n = 0; n < numParticles; n++)  { */
    /*     cout << "["; */
    /*     for (int i = 0; i < NDIM-1; i++) */
    /*         cout << initialPos(n)[i] << ", "; */
    /*     cout << initialPos(n)[NDIM-1] << "]," << endl; */
    /* } */
    /* cout << "])" << endl; */
    /* exit(-1); */
 
    return initialPos;
}

Here is the call graph for this function:

V()

double GrapheneLUT3DPotential::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 3062 of file potential.cpp.

                                              {
    double z = r[2]+Lzo2;
 
    /* Check for extremal values of z */
    if (z < zmin)
        return V_zmin;
 
    /* A sigmoid to represent the hard-wall */
    double VWall = V_zmin/(1.0+exp(-invWallWidth*(z-zWall)));
    
    dVec _r = r;
    _r[2] += Lzo2 - zmin;
 
    cartesian_to_uc(_r, A11, A12, A21, A22);
    put_in_uc(_r, cell_length_a, cell_length_b);
    double _V = trilinear_interpolation(V3d, _r, dx, dy, dz);
    //double _V = direct_lookup(V3d, _r, dx, dy, dz);
    //std::cout << _r << " " << _V << std::endl;
    
    return _V + VWall;
}

---

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

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