ComputeGlobal Class Reference

#include <ComputeGlobal.h>

Inheritance diagram for ComputeGlobal:

Public Member Functions
	ComputeGlobal (ComputeID, ComputeMgr *)
virtual	~ComputeGlobal ()
void	doWork ()
void	recvResults (ComputeGlobalResultsMsg *)
void	saveTotalForces (HomePatch *)
Public Member Functions inherited from ComputeHomePatches
	ComputeHomePatches (ComputeID c)
virtual	~ComputeHomePatches ()
virtual void	initialize ()
virtual void	atomUpdate ()
Flags *	getFlags (void)
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)

Additional Inherited Members
Public Attributes inherited from Compute
const ComputeID	cid
LDObjHandle	ldObjHandle
LocalWorkMsg *const	localWorkMsg
Protected Member Functions inherited from Compute
void	enqueueWork ()
Protected Attributes inherited from ComputeHomePatches
int	useAvgPositions
int	hasPatchZero
ComputeHomePatchList	patchList
PatchMap *	patchMap
Protected Attributes inherited from Compute
int	computeType
int	basePriority
int	gbisPhase
int	gbisPhasePriority [3]

Detailed Description

Definition at line 35 of file ComputeGlobal.h.

Constructor & Destructor Documentation

ComputeGlobal::ComputeGlobal	(	ComputeID	c,
		ComputeMgr *	m
	)

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

Definition at line 35 of file ComputeGlobal.C.

References SimParameters::colvarsOn, DebugM, SimParameters::FMAOn, SimParameters::fullDirectOn, SimParameters::GBISOn, SimParameters::GBISserOn, PatchMap::numPatches(), numPatches, PatchMap::Object(), Node::Object(), ReductionMgr::Object(), SimParameters::PMEOn, REDUCTIONS_BASIC, ResizeArray< T >::resize(), Node::simParameters, SimParameters::tclForcesOn, and ReductionMgr::willSubmit().

  : ComputeHomePatches(c)
{
  DebugM(3,"Constructing client\n");
  aid.resize(0);
  gdef.resize(0);
  comm = m;
  firsttime = 1;
  isRequested = 0;
  isRequestedAllocSize = 0;
  endRequested = 0;
  numGroupsRequested = 0;
  SimParameters *sp = Node::Object()->simParameters;
  dofull = (sp->GBISserOn || sp->GBISOn || sp->fullDirectOn || sp->FMAOn || sp->PMEOn);
  forceSendEnabled = 0;
  if ( sp->tclForcesOn ) forceSendEnabled = 1;
  if ( sp->colvarsOn ) forceSendEnabled = 1;
  forceSendActive = 0;
  fid.resize(0);
  totalForce.resize(0);
  gfcount = 0;
  groupTotalForce.resize(0);
  reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
  int numPatches = PatchMap::Object()->numPatches();
  forcePtrs = new Force*[numPatches];
  atomPtrs = new FullAtom*[numPatches];
  gridForcesPtrs = new ForceList **[numPatches];
  numGridObjects = numActiveGridObjects = 0;
  for ( int i = 0; i < numPatches; ++i ) {
    forcePtrs[i] = NULL; atomPtrs[i] = NULL;
    gridForcesPtrs[i] = NULL;
  }
}

ComputeGlobal::~ComputeGlobal ( )

virtual

Definition at line 69 of file ComputeGlobal.C.

{
  delete[] isRequested;
  delete[] forcePtrs;
  deleteGridObjects();
  delete[] gridForcesPtrs;
  delete[] atomPtrs;
  delete reduction;
}

Member Function Documentation

void ComputeGlobal::doWork ( void  )

virtual

Reimplemented from Compute.

Definition at line 322 of file ComputeGlobal.C.

References ResizeArray< T >::add(), ResizeArrayIter< Type >::begin(), ComputeGlobalDataMsg::count, DebugM, ComputeMgr::enableComputeGlobalResults(), ResizeArrayIter< Type >::end(), ComputeHomePatches::hasPatchZero, ComputeGlobalDataMsg::lat, ComputeGlobalDataMsg::patchcount, ComputeHomePatches::patchList, ComputeMgr::sendComputeGlobalData(), ComputeGlobalDataMsg::step, and x.

{
  DebugM(2,"doWork\n");

  ResizeArrayIter<PatchElem> ap(patchList);
  FullAtom **t = atomPtrs;

  for (ap = ap.begin(); ap != ap.end(); ap++) {
    CompAtom *x = (*ap).positionBox->open();
    t[(*ap).patchID] = (*ap).p->getAtomList().begin();
  }

  if(!firsttime) sendData();
  else {
    if ( hasPatchZero ) {
      ComputeGlobalDataMsg *msg = new ComputeGlobalDataMsg;
      msg->lat.add(patchList[0].p->lattice);
      msg->step = -1;
      msg->count = 1;
      msg->patchcount = 0;
      comm->sendComputeGlobalData(msg);
    }
    firsttime = 0;
    comm->enableComputeGlobalResults();
  }
  DebugM(2,"done with doWork\n");
}

void ComputeGlobal::recvResults

(

ComputeGlobalResultsMsg *

msg

)

Definition at line 210 of file ComputeGlobal.C.

References ADD_TENSOR_OBJECT, ADD_VECTOR_OBJECT, ComputeGlobalResultsMsg::aid, ResizeArray< T >::begin(), ResizeArrayIter< Type >::begin(), DebugM, ResizeArray< T >::end(), ResizeArrayIter< Type >::end(), ComputeGlobalResultsMsg::f, ComputeGlobalResultsMsg::gforce, LocalID::index, AtomMap::localID(), FullAtom::mass, NAMD_bug(), ComputeGlobalResultsMsg::newaid, ComputeGlobalResultsMsg::newgdef, ComputeGlobalResultsMsg::newgridobjid, Results::normal, notUsed, AtomMap::Object(), outer(), ComputeHomePatches::patchList, LocalID::pid, CompAtom::position, ComputeGlobalResultsMsg::reconfig, ComputeGlobalResultsMsg::resendCoordinates, ResizeArray< T >::resize(), Lattice::reverse_transform(), ResizeArray< T >::size(), SubmitReduction::submit(), ComputeGlobalResultsMsg::totalforces, FullAtom::transform, and x.

Referenced by ComputeMgr::recvComputeGlobalResults().

                                                            {
  DebugM(3,"Receiving results (" << msg->aid.size() << " forces, "
         << msg->newgdef.size() << " new group atoms) on client\n");

  forceSendActive = msg->totalforces;
  if ( forceSendActive && ! forceSendEnabled ) NAMD_bug("ComputeGlobal::recvResults forceSendActive without forceSendEnabled");

  // set the forces only if we aren't going to resend the data
  int setForces = !msg->resendCoordinates;

  if(setForces) { // we are requested to 
    // Store forces to patches
    AtomMap *atomMap = AtomMap::Object();
    const Lattice & lattice = patchList[0].p->lattice;
    ResizeArrayIter<PatchElem> ap(patchList);
    Force **f = forcePtrs;
    FullAtom **t = atomPtrs;
    Force extForce = 0.;
    Tensor extVirial;

    for (ap = ap.begin(); ap != ap.end(); ap++) {
      (*ap).r = (*ap).forceBox->open();
      f[(*ap).patchID] = (*ap).r->f[Results::normal];
      t[(*ap).patchID] = (*ap).p->getAtomList().begin();
    }

    AtomIDList::iterator a = msg->aid.begin();
    AtomIDList::iterator a_e = msg->aid.end();
    ForceList::iterator f2 = msg->f.begin();
    for ( ; a != a_e; ++a, ++f2 ) {
      DebugM(1,"processing atom "<<(*a)<<", F="<<(*f2)<<"...\n");
      /* XXX if (*a) is out of bounds here we get a segfault */
      LocalID localID = atomMap->localID(*a);
      if ( localID.pid == notUsed || ! f[localID.pid] ) continue;
      Force f_atom = (*f2);
      f[localID.pid][localID.index] += f_atom;
      FullAtom &atom = t[localID.pid][localID.index];
      Position x_orig = atom.position;
      Transform trans = atom.transform;
      Position x_atom = lattice.reverse_transform(x_orig,trans);
      extForce += f_atom;
      extVirial += outer(f_atom,x_atom);
    }
    DebugM(1,"done with the loop\n");

    // calculate forces for atoms in groups
    AtomIDList::iterator g_i, g_e;
    g_i = gdef.begin(); g_e = gdef.end();
    ForceList::iterator gf_i = msg->gforce.begin();
    //iout << iDEBUG << "recvResults\n" << endi;
    for ( ; g_i != g_e; ++g_i, ++gf_i ) {
      //iout << iDEBUG << *gf_i << '\n' << endi;
      Vector accel = (*gf_i);
      for ( ; *g_i != -1; ++g_i ) {
        //iout << iDEBUG << *g_i << '\n' << endi;
        LocalID localID = atomMap->localID(*g_i);
        if ( localID.pid == notUsed || ! f[localID.pid] ) continue;
        FullAtom &atom = t[localID.pid][localID.index];
        Force f_atom = accel * atom.mass;
        f[localID.pid][localID.index] += f_atom;
        Position x_orig = atom.position;
        Transform trans = atom.transform;
        Position x_atom = lattice.reverse_transform(x_orig,trans);
        extForce += f_atom;
        extVirial += outer(f_atom,x_atom);
      }
    }
    DebugM(1,"done with the groups\n");

    if (numActiveGridObjects > 0) {
      applyGridObjectForces(msg, &extForce, &extVirial);
    }

    ADD_VECTOR_OBJECT(reduction,REDUCTION_EXT_FORCE_NORMAL,extForce);
    ADD_TENSOR_OBJECT(reduction,REDUCTION_VIRIAL_NORMAL,extVirial);
    reduction->submit();
  }
  // done setting the forces, close boxes below

  // Get reconfiguration if present
  if ( msg->reconfig ) {
    DebugM(3,"Reconfiguring\n");
    configure(msg->newaid, msg->newgdef, msg->newgridobjid);
  }

  // send another round of data if requested

  if(msg->resendCoordinates) {
    DebugM(3,"Sending requested data right away\n");
    sendData();
  }

  groupTotalForce.resize(numGroupsRequested);
  for ( int i=0; i<numGroupsRequested; ++i ) groupTotalForce[i] = 0;

  if(setForces) {
    ResizeArrayIter<PatchElem> ap(patchList);
    Force **f = forcePtrs;
    FullAtom **t = atomPtrs;
    for (ap = ap.begin(); ap != ap.end(); ap++) {
      CompAtom *x;
      (*ap).positionBox->close(&x);
      (*ap).forceBox->close(&((*ap).r));
      f[(*ap).patchID] = 0;
      t[(*ap).patchID] = 0;
    }
  }

  delete msg;
  DebugM(3,"Done processing results\n");
}

void ComputeGlobal::saveTotalForces

(

HomePatch *

homePatch

)

Definition at line 612 of file ComputeGlobal.C.

References SimParameters::accelMDDebugOn, SimParameters::accelMDdihe, ResizeArray< T >::add(), Results::amdf, atoms, ResizeArray< T >::begin(), ResizeArray< T >::end(), Patch::f, intpair::first, SimParameters::fixedAtomsOn, NAMD_bug(), Results::nbond, Results::normal, Patch::numAtoms, Node::Object(), intpair::second, Node::simParameters, and Results::slow.

Referenced by Sequencer::integrate(), and Sequencer::minimize().

{
  if ( ! forceSendEnabled ) NAMD_bug("ComputeGlobal::saveTotalForces called unexpectedly");
  if ( ! forceSendActive ) return;

  if ( Node::Object()->simParameters->accelMDOn && Node::Object()->simParameters->accelMDDebugOn && Node::Object()->simParameters->accelMDdihe ) {
    int num=homePatch->numAtoms;
    FullAtomList &atoms = homePatch->atom;
    ForceList &af=homePatch->f[Results::amdf];

    for (int i=0; i<num; ++i) {
      int index = atoms[i].id;
      if (index < endRequested && isRequested[index] & 1) {
        fid.add(index);
        totalForce.add(af[i]);
      }
    }
    return;
  }

  int fixedAtomsOn = Node::Object()->simParameters->fixedAtomsOn;
  int num=homePatch->numAtoms;
  FullAtomList &atoms = homePatch->atom;
  ForceList &f1=homePatch->f[Results::normal], &f2=homePatch->f_saved[Results::nbond],
            &f3=homePatch->f_saved[Results::slow];
  Force f_sum;
  
  for (int i=0; i<num; ++i) {
    int index = atoms[i].id;
    char reqflag;
    if (index < endRequested && (reqflag = isRequested[index])) {
     f_sum = f1[i]+f2[i];
     if (dofull)
       f_sum += f3[i];
     if ( fixedAtomsOn && atoms[i].atomFixed ) f_sum = 0.;
     if ( reqflag  & 1 ) {  // individual atom
      fid.add(index);
      totalForce.add(f_sum);
     }
     if ( reqflag  & 2 ) {  // part of group
       intpair *gpend = gpair.end();
       intpair *gpi = std::lower_bound(gpair.begin(),gpend,intpair(index,0));
       if ( gpi == gpend || gpi->first != index )
         NAMD_bug("ComputeGlobal::saveTotalForces gpair corrupted.");
       do {
         ++gfcount;
         groupTotalForce[gpi->second] += f_sum;
       } while ( ++gpi != gpend && gpi->first == index );
     }
    }
  }
}

---

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

• ComputeGlobal.h
• ComputeGlobal.C