ComputeGridForce Class Reference

#include <ComputeGridForce.h>

Inheritance diagram for ComputeGridForce:

Public Member Functions
	ComputeGridForce (ComputeID c, PatchID pid)
virtual	~ComputeGridForce ()
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

Protected Member Functions
template<class T >
void	do_calc (T *grid, int gridnum, FullAtom *p, int numAtoms, Molecule *mol, Force *forces, BigReal &energy, Force &extForce, Tensor &extVirial)
Protected Member Functions inherited from Compute
void	enqueueWork ()

Additional Inherited Members
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

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 17 of file ComputeGridForce.h.

Constructor & Destructor Documentation

ComputeGridForce::ComputeGridForce	(	ComputeID	c,
		PatchID	pid
	)

Definition at line 23 of file ComputeGridForce.C.

References ReductionMgr::Object(), reduction, REDUCTIONS_BASIC, and ReductionMgr::willSubmit().

    : ComputeHomePatch(c,pid)
{

    reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);

}

ComputeGridForce::~ComputeGridForce ( )

virtual

Definition at line 33 of file ComputeGridForce.C.

References reduction.

{
    delete reduction;
}

Member Function Documentation

template<class T >

void ComputeGridForce::do_calc ( T *  grid, int  gridnum, FullAtom *  p, int  numAtoms, Molecule *  mol, Force *  forces, BigReal &  energy, Force &  extForce, Tensor &  extVirial  )

protected

Definition at line 39 of file ComputeGridForce.C.

References charge, DebugM, endi(), Patch::flags, Molecule::get_gridfrc_params(), ComputeHomePatch::homePatch, CompAtomExt::id, iout, Molecule::is_atom_gridforced(), iWARN(), Transform::j, Transform::k, Patch::lattice, ComputeHomePatch::numAtoms, outer(), CompAtom::position, Lattice::reverse_transform(), Flags::step, FullAtom::transform, Vector::x, Vector::y, and Vector::z.

Referenced by doForce().

{
    Real scale;                 // Scaling factor
    Charge charge;              // Charge
    Vector dV;
    float V;
    
    Vector gfScale = grid->get_scale();
    DebugM(3, "doCalc()\n" << endi);

    //  Loop through and check each atom
    for (int i = 0; i < numAtoms; i++) {
        if (mol->is_atom_gridforced(p[i].id, gridnum))
        {
            DebugM(1, "Atom " << p[i].id << " is gridforced\n" << endi);
            
            mol->get_gridfrc_params(scale, charge, p[i].id, gridnum);
            
            // Wrap coordinates using grid center
            Position pos = grid->wrap_position(p[i].position, homePatch->lattice);
            DebugM(1, "pos = " << pos << "\n" << endi);
            
            // Here's where the action happens
            int err = grid->compute_VdV(pos, V, dV);
            
            if (err) {
                DebugM(2, "V = 0\n" << endi);
                DebugM(2, "dV = 0 0 0\n" << endi);
                continue;  // This means the current atom is outside the potential
            }
            
            //Force force = scale * Tensor::diagonal(gfScale) * (-charge * dV);
            Force force = -charge * scale * Vector(gfScale.x * dV.x, gfScale.y * dV.y, gfScale.z * dV.z);
            
#ifdef DEBUGM
            DebugM(2, "scale = " << scale << " gfScale = " << gfScale << " charge = " << charge << "\n" << endi);
            
            DebugM(2, "V = " << V << "\n" << endi);
            DebugM(2, "dV = " << dV << "\n" << endi);
            DebugM(2, "grid = " << gridnum << " force = " << force << " pos = " << pos << " V = " << V << " dV = " << dV << " step = " << homePatch->flags.step << " index = " << p[i].id << "\n" << endi);
            
            DebugM(1, "transform = " << (int)p[i].transform.i << " "
                   << (int)p[i].transform.j << " " << (int)p[i].transform.k << "\n" << endi);
            
            if (V != V) {
                iout << iWARN << "V is NaN!\natomid = " << p[i].id << " loc = " << p[i].position << " V = " << V << "\n" << endi;
            }
#endif
            
            forces[i] += force;
            extForce += force;
            Position vpos = homePatch->lattice.reverse_transform(p[i].position, p[i].transform);
            
            //energy -= force * (vpos - homePatch->lattice.origin());
            if (gfScale.x == gfScale.y && gfScale.x == gfScale.z)
            {
                // only makes sense when scaling is isotropic
                energy += scale * gfScale.x * (charge * V);
                
                // add something when we're off the grid? I'm thinking no
            }
            extVirial += outer(force,vpos);
        }
    }
    DebugM(3, "doCalc() done\n" << endi);
}

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

virtual

Implements ComputeHomePatch.

Definition at line 106 of file ComputeGridForce.C.

References ADD_TENSOR_OBJECT, ADD_VECTOR_OBJECT, SimParameters::berendsenPressureOn, DebugM, do_calc(), endi(), Results::f, GridforceGrid::fits_lattice(), Patch::flags, forces, GridforceGrid::get_center(), GridforceGrid::get_checksize(), GridforceGrid::get_e(), GridforceGrid::get_grid_type(), Molecule::get_gridfrc_grid(), GridforceGrid::get_scale(), Patch::getNumAtoms(), GF_OVERLAPCHECK_FREQ, GridforceGrid::GridforceGridTypeFull, GridforceGrid::GridforceGridTypeLite, ComputeHomePatch::homePatch, SubmitReduction::item(), SimParameters::langevinPistonOn, Patch::lattice, Node::molecule, NAMD_bug(), NAMD_die(), Results::normal, ComputeHomePatch::numAtoms, Molecule::numGridforceGrids, Node::Object(), reduction, REDUCTION_MISC_ENERGY, Node::simParameters, simParams, Flags::step, SubmitReduction::submit(), Vector::x, Vector::y, and Vector::z.

{
    SimParameters *simParams = Node::Object()->simParameters;
    Molecule *mol = Node::Object()->molecule;
    
    Force *forces = r->f[Results::normal];
    BigReal energy = 0;
    Force extForce = 0.;
    Tensor extVirial;
    
    int numAtoms = homePatch->getNumAtoms();

    if ( mol->numGridforceGrids < 1 ) NAMD_bug("No grids loaded in ComputeGridForce::doForce()");

    DebugM(3, "doForce()\n" << endi);
    
    for (int gridnum = 0; gridnum < mol->numGridforceGrids; gridnum++) {
        GridforceGrid *grid = mol->get_gridfrc_grid(gridnum);

        const Vector gfScale = grid->get_scale();
        if ((gfScale.x == 0.0) && (gfScale.y == 0.0) && (gfScale.z == 0.0)) {
          DebugM(3, "Skipping grid index " << gridnum << "\n" << endi);
          continue;
        }
        
        if (homePatch->flags.step % GF_OVERLAPCHECK_FREQ == 0) {
            // only check on node 0 and every GF_OVERLAPCHECK_FREQ steps
          if (simParams->langevinPistonOn || simParams->berendsenPressureOn) {
                // check for grid overlap if pressure control is on
                // not needed without pressure control, since the check is also performed on startup
      if (!grid->fits_lattice(homePatch->lattice)) {
        char errmsg[512];
        if (grid->get_checksize()) {
          sprintf(errmsg, "Warning: Periodic cell basis too small for Gridforce grid %d.  Set gridforcechecksize off in configuration file to ignore.\n", gridnum);
          NAMD_die(errmsg);      
        }
      }
         }
        }
        
        if (homePatch->flags.step % 100 == 1) {
            Position center = grid->get_center();
            DebugM(3, "center = " << center << "\n" << endi);
            DebugM(3, "e = " << grid->get_e() << "\n" << endi);
        }
        
        if (grid->get_grid_type() == GridforceGrid::GridforceGridTypeFull) {
            GridforceFullMainGrid *g = (GridforceFullMainGrid *)grid;
            do_calc(g, gridnum, p, numAtoms, mol, forces, energy, extForce, extVirial);
        } else if (grid->get_grid_type() == GridforceGrid::GridforceGridTypeLite) {
            GridforceLiteGrid *g = (GridforceLiteGrid *)grid;
            do_calc(g, gridnum, p, numAtoms, mol, forces, energy, extForce, extVirial);
        }
    }
    reduction->item(REDUCTION_MISC_ENERGY) += energy;
    ADD_VECTOR_OBJECT(reduction,REDUCTION_EXT_FORCE_NORMAL,extForce);
    ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,extVirial);
    reduction->submit();
    DebugM(3, "doForce() done\n" << endi);
}

Member Data Documentation

SubmitReduction* ComputeGridForce::reduction

Definition at line 28 of file ComputeGridForce.h.

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

---

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

• ComputeGridForce.h
• ComputeGridForce.C