ComputeMsm Class Reference

#include <ComputeMsm.h>

Inheritance diagram for ComputeMsm:

Public Member Functions
	ComputeMsm (ComputeID c)
virtual	~ComputeMsm ()
void	doWork ()
void	saveResults ()
void	setMgr (ComputeMsmMgr *mgr)
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 25 of file ComputeMsm.h.

Constructor & Destructor Documentation

ComputeMsm::ComputeMsm

(

ComputeID

c

)

Definition at line 6053 of file ComputeMsm.C.

References COULOMB, SimParameters::dielectric, Node::Object(), ReductionMgr::Object(), REDUCTIONS_BASIC, Node::simParameters, and ReductionMgr::willSubmit().

                                  : ComputeHomePatches(c)
{
  CProxy_ComputeMsmMgr::ckLocalBranch(
      CkpvAccess(BOCclass_group).computeMsmMgr)->setCompute(this);
  SimParameters *simParams = Node::Object()->simParameters;
  qscaling = sqrtf(COULOMB / simParams->dielectric);
  reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsm:  (constructor) PE=%d\n", CkMyPe());
#endif
}

ComputeMsm::~ComputeMsm ( )

virtual

Definition at line 6065 of file ComputeMsm.C.

{
  // free memory
#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsm:  (destructor) PE=%d\n", CkMyPe());
#endif
}

Member Function Documentation

void ComputeMsm::doWork ( void  )

virtual

Reimplemented from Compute.

Definition at line 6073 of file ComputeMsm.C.

References msm::Array< T >::append(), ASSERT, ResizeArrayIter< Type >::begin(), CompAtom::charge, ComputeMsmMgr::compute(), msm::PatchData::coordArray(), ResizeArrayIter< Type >::end(), CompAtomExt::id, msm::PatchData::init(), msm::Array< T >::len(), ComputeMsmMgr::mapData(), ComputeHomePatches::patchList, ComputeMsmMgr::patchPtrArray(), CompAtom::position, msm::Array< T >::resize(), Compute::sequence(), msm::PatchData::sequence, ResizeArray< T >::size(), SubmitReduction::submit(), and x.

{
  // for each patch do stuff
#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsm:  doWork() PE=%d\n", CkMyPe());
#endif

#if 0
#ifdef MSM_TIMING
  myMgr->initTiming();
#endif
#ifdef MSM_PROFILING
  myMgr->initProfiling();
#endif
#endif

  // patchList is inherited from ComputeHomePatches
  ResizeArrayIter<PatchElem> ap(patchList);
  numLocalPatches = patchList.size();
  cntLocalPatches = 0;
  ASSERT(cntLocalPatches < numLocalPatches);

#ifdef DEBUG_MSM_VERBOSE
  printf("patchList size = %d\n", patchList.size() );
#endif

  // Skip computations if nothing to do.
  if ( ! patchList[0].p->flags.doFullElectrostatics ) {
    for (ap = ap.begin();  ap != ap.end();  ap++) {
      CompAtom *x = (*ap).positionBox->open();
      Results *r = (*ap).forceBox->open();
      (*ap).positionBox->close(&x);
      (*ap).forceBox->close(&r);
    }
    reduction->submit();
    return;
  }
  msm::Map& map = myMgr->mapData();
  // This is the patchPtr array for MSM; any local patch will be set up
  // with a non-NULL pointer to its supporting data structure.
  msm::PatchPtrArray& patchPtr = myMgr->patchPtrArray();
  // also store just a list of IDs for the local patches
  msm::Array<int> patchIDList(numLocalPatches);
  patchIDList.resize(0);  // to use append on pre-allocated array buffer
  int cnt=0, n;
  for (ap = ap.begin();  ap != ap.end();  ap++) {
    CompAtom *x = (*ap).positionBox->open();
    CompAtomExt *xExt = (*ap).p->getCompAtomExtInfo();
    if ( patchList[0].p->flags.doMolly ) {
      (*ap).positionBox->close(&x);
      x = (*ap).avgPositionBox->open();
    }
    int numAtoms = (*ap).p->getNumAtoms();
    int patchID = (*ap).patchID;
    patchIDList.append(patchID);
    if (patchPtr[patchID] == NULL) {
      // create PatchData if it doesn't exist for this patchID
      patchPtr[patchID] = new msm::PatchData(myMgr, patchID);
#ifdef DEBUG_MSM_VERBOSE
      printf("Creating new PatchData:  patchID=%d  PE=%d\n",
          patchID, CkMyPe());
#endif
    }
    msm::PatchData& patch = *(patchPtr[patchID]);
    patch.init(numAtoms);
    msm::AtomCoordArray& coord = patch.coordArray();
    ASSERT(coord.len() == numAtoms);
    for (n = 0;  n < numAtoms;  n++) {
      coord[n].position = x[n].position;
      coord[n].charge = qscaling * x[n].charge;
      coord[n].id = xExt[n].id;
    }
    if ( patchList[0].p->flags.doMolly ) {
      (*ap).avgPositionBox->close(&x);
    }
    else {
      (*ap).positionBox->close(&x);
    }
    patch.sequence = sequence();
  }

  myMgr->compute(patchIDList);
}

void ComputeMsm::saveResults

(

)

Definition at line 6157 of file ComputeMsm.C.

References ASSERT, ResizeArrayIter< Type >::begin(), ResizeArrayIter< Type >::end(), msm::PatchData::energy, Results::f, msm::PatchData::force, SubmitReduction::item(), msm::Array< T >::len(), ComputeMsmMgr::mapData(), NAMD_die(), ComputeHomePatches::patchList, msm::Map::patchList, ComputeMsmMgr::patchPtrArray(), REDUCTION_ELECT_ENERGY_SLOW, Results::slow, SubmitReduction::submit(), ComputeMsmMgr::virial, ComputeMsmMgr::VXX, ComputeMsmMgr::VXY, ComputeMsmMgr::VXZ, ComputeMsmMgr::VYY, ComputeMsmMgr::VYZ, and ComputeMsmMgr::VZZ.

Referenced by ComputeMsmMgr::doneCompute().

{
  if (++cntLocalPatches != numLocalPatches) return;

  // NAMD patches
  ResizeArrayIter<PatchElem> ap(patchList);
#ifdef DEBUG_MSM
  for (ap = ap.begin();  ap != ap.end();  ap++) {
    int patchID = (*ap).patchID;
    ASSERT(myMgr->patchPtrArray()[patchID]->cntRecvs ==
        myMgr->mapData().patchList[patchID].numRecvs);
  }
#endif

  // get results from ComputeMsmMgr
  msm::PatchPtrArray& patchPtr = myMgr->patchPtrArray();

#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsm:  saveResults() PE=%d\n", CkMyPe());
#endif
  // store force updates
  // submit reductions

  // add in forces
  int cnt=0, n;
  for (ap = ap.begin(); ap != ap.end(); ap++) {
    Results *r = (*ap).forceBox->open();
    Force *f = r->f[Results::slow];
    int numAtoms = (*ap).p->getNumAtoms();
    int patchID = (*ap).patchID;
    if (patchPtr[patchID] == NULL) {
      char msg[100];
      snprintf(msg, sizeof(msg), "Expecting patch %d to exist on PE %d",
          patchID, CkMyPe());
      NAMD_die(msg);
    }
    msm::PatchData& patch = *(patchPtr[patchID]);
    ASSERT(numAtoms == patch.force.len() );
    for (n = 0;  n < numAtoms;  n++) {
      f[n] += patch.force[n];
    }
    (*ap).forceBox->close(&r);

    reduction->item(REDUCTION_ELECT_ENERGY_SLOW) += patch.energy;
//    reduction->item(REDUCTION_VIRIAL_SLOW_XX) += patch.virial[0][0];
//    reduction->item(REDUCTION_VIRIAL_SLOW_XY) += patch.virial[0][1];
//    reduction->item(REDUCTION_VIRIAL_SLOW_XZ) += patch.virial[0][2];
//    reduction->item(REDUCTION_VIRIAL_SLOW_YX) += patch.virial[1][0];
//    reduction->item(REDUCTION_VIRIAL_SLOW_YY) += patch.virial[1][1];
//    reduction->item(REDUCTION_VIRIAL_SLOW_YZ) += patch.virial[1][2];
//    reduction->item(REDUCTION_VIRIAL_SLOW_ZX) += patch.virial[2][0];
//    reduction->item(REDUCTION_VIRIAL_SLOW_ZY) += patch.virial[2][1];
//    reduction->item(REDUCTION_VIRIAL_SLOW_ZZ) += patch.virial[2][2];
    Float *virial = myMgr->virial;
    reduction->item(REDUCTION_VIRIAL_SLOW_XX) += virial[ComputeMsmMgr::VXX];
    reduction->item(REDUCTION_VIRIAL_SLOW_XY) += virial[ComputeMsmMgr::VXY];
    reduction->item(REDUCTION_VIRIAL_SLOW_XZ) += virial[ComputeMsmMgr::VXZ];
    reduction->item(REDUCTION_VIRIAL_SLOW_YX) += virial[ComputeMsmMgr::VXY];
    reduction->item(REDUCTION_VIRIAL_SLOW_YY) += virial[ComputeMsmMgr::VYY];
    reduction->item(REDUCTION_VIRIAL_SLOW_YZ) += virial[ComputeMsmMgr::VYZ];
    reduction->item(REDUCTION_VIRIAL_SLOW_ZX) += virial[ComputeMsmMgr::VXZ];
    reduction->item(REDUCTION_VIRIAL_SLOW_ZY) += virial[ComputeMsmMgr::VYZ];
    reduction->item(REDUCTION_VIRIAL_SLOW_ZZ) += virial[ComputeMsmMgr::VZZ];
  }
  reduction->submit();
}

void ComputeMsm::setMgr ( ComputeMsmMgr *  mgr )

inline

Definition at line 32 of file ComputeMsm.h.

Referenced by ComputeMsmMgr::setCompute().

{ myMgr = mgr; }

---

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

• ComputeMsm.h
• ComputeMsm.C