#include <ComputeSphericalBC.h>

Inheritance diagram for ComputeSphericalBC:

Public Member Functions
	ComputeSphericalBC (ComputeID c, PatchID pid)

virtual	~ComputeSphericalBC ()

virtual void	doForce (FullAtom p, Results r)

Public Member Functions inherited from ComputeHomePatch
	ComputeHomePatch (ComputeID c, PatchID pid)

virtual	~ComputeHomePatch ()

virtual void	initialize ()

virtual void	atomUpdate ()

virtual void	doWork ()

Public Member Functions inherited from Compute
	Compute (ComputeID)

int	type ()

virtual	~Compute ()

void	setNumPatches (int n)

int	getNumPatches ()

virtual void	patchReady (PatchID, int doneMigration, int seq)

virtual int	noWork ()

virtual void	finishPatch (int)

int	sequence (void)

int	priority (void)

int	getGBISPhase (void)

virtual void	gbisP2PatchReady (PatchID, int seq)

virtual void	gbisP3PatchReady (PatchID, int seq)

Public Attributes
SubmitReduction *	reduction

Public Attributes inherited from Compute
const ComputeID	cid

LDObjHandle	ldObjHandle

LocalWorkMsg *const	localWorkMsg

Additional Inherited Members
Protected Member Functions inherited from Compute
void	enqueueWork ()

Protected Attributes inherited from ComputeHomePatch
int	numAtoms

Patch *	patch

HomePatch *	homePatch

Protected Attributes inherited from Compute
int	computeType

int	basePriority

int	gbisPhase

int	gbisPhasePriority [3]

Detailed Description

Definition at line 13 of file ComputeSphericalBC.h.

Constructor & Destructor Documentation

ComputeSphericalBC::ComputeSphericalBC	(	ComputeID	c,
		PatchID	pid
	)

Definition at line 25 of file ComputeSphericalBC.C.

References FALSE, Node::Object(), ReductionMgr::Object(), reduction, REDUCTIONS_BASIC, Node::simParameters, simParams, SimParameters::sphericalBCexp1, SimParameters::sphericalBCexp2, SimParameters::sphericalBCk1, SimParameters::sphericalBCk2, SimParameters::sphericalBCr1, SimParameters::sphericalBCr2, SimParameters::sphericalCenter, TRUE, and ReductionMgr::willSubmit().

   : ComputeHomePatch(c,pid)
 {
         reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
 
         SimParameters *simParams = Node::Object()->simParameters;
 
         //  Get parameters from the SimParameters object
         r1 = simParams->sphericalBCr1;
         r2 = simParams->sphericalBCr2;
         r1_2 = r1*r1;
         r2_2 = r2*r2;
         k1 = simParams->sphericalBCk1;
         k2 = simParams->sphericalBCk2;
         exp1 = simParams->sphericalBCexp1;
         exp2 = simParams->sphericalBCexp2;
 
         //  Check to see if this is one set of parameters or two
         if (r2 > -1.0)
         {
                 twoForces = TRUE;
         }
         else
         {
                 twoForces = FALSE;
         }
 
         center = simParams->sphericalCenter;
 
 }

ComputeSphericalBC::~ComputeSphericalBC ( )

virtual

Definition at line 66 of file ComputeSphericalBC.C.

References reduction.

 {
         delete reduction;
 }

Member Function Documentation

void ComputeSphericalBC::doForce	(	FullAtom *	p,
		Results *	r
	)

virtual

Implements ComputeHomePatch.

Definition at line 86 of file ComputeSphericalBC.C.

References Results::f, forces, SubmitReduction::item(), Results::normal, ComputeHomePatch::numAtoms, CompAtom::position, reduction, REDUCTION_BC_ENERGY, SubmitReduction::submit(), Vector::x, x, Vector::y, and Vector::z.

 {
         Vector diff;            //  Distance from atom to center of sphere
         Vector f;               //  Calculated force vector
         int i, j;               //  Loop counters
         BigReal dist, dist_2;   //  Distance from atom to center, and this
                                 //  distance squared
         BigReal rval;           //  Difference between distance from atom
                                 //  to center and radius of sphere
         BigReal eval;           //  Energy value for this atom
         BigReal fval;           //  Force magnitude for this atom
 
         // aliases to work with old code
         FullAtom *x = p;
         Force *forces = r->f[Results::normal];
         BigReal energy = 0;
 
         //  Loop through and check each atom
         for (i=0; i<numAtoms; i++)
         {
                 //  Calculate the vector from the atom to the center of the
                 //  sphere
                 diff.x = x[i].position.x - center.x;
                 diff.y = x[i].position.y - center.y;
                 diff.z = x[i].position.z - center.z;
                 
                 //  Calculate the distance squared
                 dist_2 = diff.x*diff.x + diff.y*diff.y + diff.z*diff.z;
 
                 //  Look to see if we are outside either radius
                 if ( (dist_2 > r1_2) || (twoForces && (dist_2 > r2_2)) )
                 {
                         //  Calculate the distance to the center
                         dist = sqrt(dist_2);
 
                         //  Normalize the direction vector
                         diff /= dist;
 
                         //  Check to see if we are outside radius 1
                         if (dist > r1)
                         {
                                 //  Assign the force vector to the
                                 //  unit direction vector
                                 f.x = diff.x;
                                 f.y = diff.y;
                                 f.z = diff.z;
 
                                 //  Calculate the energy which is
                                 //  e = k1*(r_i-r_center)^exp1
                                 eval = k1;
                                 rval = fabs(dist - r1);
 
                                 for (j=0; j<exp1; j++)
                                 {
                                         eval *= rval;
                                 }
 
                                 energy += eval;
 
                                 //  Now calculate the force which is
                                 //  e = -k1*exp1*(r_i-r_center1)^(exp1-1)
                                 fval = -exp1*k1;
 
                                 for (j=0; j<exp1-1; j++)
                                 {
                                         fval *= rval;
                                 }
 
                                 //  Multiply the force magnitude to the
                                 //  unit direction vector to get the
                                 //  resulting force
                                 f *= fval;
 
                                 //  Add the force to the force vectors
                                 forces[i].x += f.x;
                                 forces[i].y += f.y;
                                 forces[i].z += f.z;
                         }
 
                         //  Check to see if there is a second radius
                         //  and if we are outside of it
                         if (twoForces && (dist > r2) )
                         {
                                 //  Assign the force vector to the
                                 //  unit direction vector
                                 f.x = diff.x;
                                 f.y = diff.y;
                                 f.z = diff.z;
 
                                 //  Calculate the energy which is
                                 //  e = k2*(r_i-r_center2)^exp2
                                 eval = k2;
                                 rval = fabs(dist - r2);
 
                                 for (j=0; j<exp2; j++)
                                 {
                                         eval *= rval;
                                 }
 
                                 energy += eval;
 
                                 //  Now calculate the force which is
                                 //  e = -k2*exp2*(r_i-r_center2)^(exp2-1)
                                 fval = -exp2*k2;
 
                                 for (j=0; j<exp2-1; j++)
                                 {
                                         fval *= rval;
                                 }
 
                                 //  Multiply the force magnitude to the
                                 //  unit direction vector to get the
                                 //  resulting force
                                 f *= fval;
 
                                 //  Add the force to the force vectors
                                 forces[i].x += f.x;
                                 forces[i].y += f.y;
                                 forces[i].z += f.z;
                         }
                 }
         }
 
     reduction->item(REDUCTION_BC_ENERGY) += energy;
     reduction->submit();
 
 }

Member Data Documentation

SubmitReduction* ComputeSphericalBC::reduction

Definition at line 32 of file ComputeSphericalBC.h.

Referenced by ComputeSphericalBC(), doForce(), and ~ComputeSphericalBC().

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

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation