Patch Class Reference

#include <Patch.h>

Inheritance diagram for Patch:

HomePatch ProxyPatch List of all members.

Public Member Functions

 Patch (PatchID pd)
int hasNewAtoms ()
virtual ~Patch ()
Box< Patch, CompAtom > * registerPositionPickup (Compute *cid)
void unregisterPositionPickup (Compute *cid, Box< Patch, CompAtom > **const box)
Box< Patch, CompAtom > * registerAvgPositionPickup (Compute *cid)
void unregisterAvgPositionPickup (Compute *cid, Box< Patch, CompAtom > **const box)
Box< Patch, CompAtom > * registerVelocityPickup (Compute *cid)
void unregisterVelocityPickup (Compute *cid, Box< Patch, CompAtom > **const box)
Box< Patch, Real > * registerIntRadPickup (Compute *cid)
void unregisterIntRadPickup (Compute *cid, Box< Patch, Real > **const box)
Box< Patch, GBReal > * registerPsiSumDeposit (Compute *cid)
void unregisterPsiSumDeposit (Compute *cid, Box< Patch, GBReal > **const box)
Box< Patch, Real > * registerBornRadPickup (Compute *cid)
void unregisterBornRadPickup (Compute *cid, Box< Patch, Real > **const box)
Box< Patch, GBReal > * registerDEdaSumDeposit (Compute *cid)
void unregisterDEdaSumDeposit (Compute *cid, Box< Patch, GBReal > **const box)
Box< Patch, Real > * registerDHdrPrefixPickup (Compute *cid)
void unregisterDHdrPrefixPickup (Compute *cid, Box< Patch, Real > **const box)
Box< Patch, int > * registerLcpoTypePickup (Compute *cid)
void unregisterLcpoTypePickup (Compute *cid, Box< Patch, int > **const box)
Box< Patch, Results > * registerForceDeposit (Compute *cid)
void unregisterForceDeposit (Compute *cid, Box< Patch, Results > **const box)
void positionsReady (int n=0)
void positionBoxClosed (void)
void forceBoxClosed (void)
void avgPositionBoxClosed (void)
void velocityBoxClosed (void)
void intRadBoxClosed (void)
void psiSumBoxClosed (void)
void bornRadBoxClosed (void)
void dEdaSumBoxClosed (void)
void dHdrPrefixBoxClosed (void)
void gbisP2Ready ()
void gbisP3Ready ()
void lcpoTypeBoxClosed (void)
int getNumAtoms ()
int getNumFixedAtoms ()
void setNumFixedAtoms (int numFixed)
PatchID getPatchID ()
int getNumComputes ()
CompAtomExtgetCompAtomExtInfo ()
CudaAtomgetCudaAtomList ()

Public Attributes

Latticelattice
Flags flags

Protected Member Functions

virtual void boxClosed (int)=0

Protected Attributes

const PatchID patchID
int numAtoms
int numFixedAtoms
CompAtomList p
CompAtomList p_avg
CompAtomList v
AtomMapperatomMapper
RealList intRad
GBRealList psiSum
GBRealList psiFin
RealList bornRad
RealList dHdrPrefix
GBRealList dEdaSum
IntList lcpoType
CompAtomExtList pExt
CompAtomavgPositionPtrBegin
CompAtomavgPositionPtrEnd
CompAtomvelocityPtrBegin
CompAtomvelocityPtrEnd
CudaAtomcudaAtomPtr
ForceList f [Results::maxNumForces]
Results results
int computesSortedByPriority
int firstHoldableCompute
OwnerBox< Patch, CompAtompositionBox
ComputePtrList positionComputeList
OwnerBox< Patch, CompAtomavgPositionBox
ComputePtrList avgPositionComputeList
OwnerBox< Patch, CompAtomvelocityBox
ComputePtrList velocityComputeList
OwnerBox< Patch, RealintRadBox
ComputePtrList intRadComputeList
OwnerBox< Patch, GBRealpsiSumBox
ComputePtrList psiSumComputeList
OwnerBox< Patch, RealbornRadBox
ComputePtrList bornRadComputeList
OwnerBox< Patch, GBRealdEdaSumBox
ComputePtrList dEdaSumComputeList
OwnerBox< Patch, RealdHdrPrefixBox
ComputePtrList dHdrPrefixComputeList
OwnerBox< Patch, int > lcpoTypeBox
ComputePtrList lcpoTypeComputeList
OwnerBox< Patch, ResultsforceBox
ComputePtrList forceComputeList
int boxesOpen
int _hasNewAtoms
int * child
int nChild

Detailed Description

Definition at line 34 of file Patch.h.


Constructor & Destructor Documentation

Patch::Patch ( PatchID  pd  ) 

Definition at line 45 of file Patch.C.

References atomMapper, child, cudaAtomPtr, SimParameters::lattice, lattice, nChild, ReductionMgr::Object(), Node::Object(), REDUCTIONS_BASIC, Node::simParameters, and ReductionMgr::willSubmit().

00045                        :
00046    lattice(flags.lattice),
00047    patchID(pd), numAtoms(0), numFixedAtoms(0),
00048    avgPositionPtrBegin(0), avgPositionPtrEnd(0),
00049    velocityPtrBegin(0), velocityPtrEnd(0),      // BEGIN LA, END LA
00050    positionBox(this,&Patch::positionBoxClosed,pd,0),
00051    avgPositionBox(this,&Patch::avgPositionBoxClosed,pd,3),
00052    velocityBox(this,&Patch::velocityBoxClosed,pd,4), // BEGIN LA, END LA
00053    psiSumBox(this,&Patch::psiSumBoxClosed,pd,5), // begin gbis
00054    intRadBox(this,&Patch::intRadBoxClosed,pd,6),
00055    bornRadBox(this,&Patch::bornRadBoxClosed,pd,7),
00056    dEdaSumBox(this,&Patch::dEdaSumBoxClosed,pd,8),
00057    dHdrPrefixBox(this,&Patch::dHdrPrefixBoxClosed,pd,9), //end gbis
00058    lcpoTypeBox(this,&Patch::lcpoTypeBoxClosed,pd,10),
00059    forceBox(this,&Patch::forceBoxClosed,pd,1),
00060    boxesOpen(0), _hasNewAtoms(0),
00061    computesSortedByPriority(0), firstHoldableCompute(0)
00062 
00063    // DMK - Atom Separation (water vs. non-water)
00064    #if NAMD_SeparateWaters != 0
00065      ,numWaterAtoms(-1)
00066    #endif
00067 {
00068   //CkPrintf("GBIS: PatchCreated\n");
00069 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00070     positionPtrBegin = 0;
00071     positionPtrEnd = 0;
00072 #endif
00073 
00074         nChild = 0;
00075         child = NULL;
00076 #ifdef NODEAWARE_PROXY_SPANNINGTREE
00077   #ifdef USE_NODEPATCHMGR
00078   nodeChildren = NULL;
00079   numNodeChild = 0;
00080   #endif
00081 #endif
00082 
00083   lattice = Node::Object()->simParameters->lattice;
00084   atomMapper = new AtomMapper(pd);
00085 #ifndef NAMD_CUDA
00086   reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
00087 #endif
00088 
00089   // DMK
00090   #if defined(NAMD_MIC)
00091     cudaAtomPtr = NULL;
00092     #if MIC_SUBMIT_ATOMS_ON_ARRIVAL != 0
00093       pthread_mutex_init(&mic_atomData_mutex, NULL);
00094       mic_atomData = NULL;
00095       mic_atomData_seq = -1;
00096       mic_atomData_allocSize_host = 0;
00097       for (int i = 0; i < MIC_MAX_DEVICES_PER_NODE; i++) {
00098         mic_atomData_prev[i] = NULL;
00099         mic_atomData_deviceSeq[i] = -1;
00100         mic_atomData_devicePtr[i] = 0;
00101         mic_atomData_allocSize_device[i] = 0;
00102       }
00103     #endif
00104   #endif
00105 }

Patch::~Patch (  )  [virtual]

Definition at line 38 of file Patch.C.

References atomMapper.

00038               {
00039   delete atomMapper;
00040 #ifndef NAMD_CUDA
00041   delete reduction;
00042 #endif
00043 }


Member Function Documentation

void Patch::avgPositionBoxClosed ( void   ) 

Definition at line 316 of file Patch.C.

References avgPositionPtrBegin, and boxClosed().

00317 {
00318    avgPositionPtrBegin = 0;
00319    this->boxClosed(3);
00320 }

void Patch::bornRadBoxClosed ( void   ) 

Definition at line 341 of file Patch.C.

References boxClosed().

00341                                  {
00342    //bornRadPtr = 0;
00343    this->boxClosed(7);
00344 }

virtual void Patch::boxClosed ( int   )  [protected, pure virtual]

Implemented in HomePatch, and ProxyPatch.

Referenced by avgPositionBoxClosed(), bornRadBoxClosed(), dEdaSumBoxClosed(), dHdrPrefixBoxClosed(), forceBoxClosed(), intRadBoxClosed(), lcpoTypeBoxClosed(), positionBoxClosed(), psiSumBoxClosed(), and velocityBoxClosed().

void Patch::dEdaSumBoxClosed ( void   ) 

Definition at line 345 of file Patch.C.

References boxClosed().

00345                                  {
00346    //dEdaSumPtr = 0;
00347    this->boxClosed(8);
00348 }

void Patch::dHdrPrefixBoxClosed ( void   ) 

Definition at line 349 of file Patch.C.

References boxClosed().

00349                                     {
00350    //dHdrPrefixPtr = 0;
00351    this->boxClosed(9);
00352 }

void Patch::forceBoxClosed ( void   ) 

Definition at line 253 of file Patch.C.

References ResizeArray< Elem >::begin(), boxClosed(), DebugM, f, Results::f, SubmitReduction::item(), j, lattice, Results::maxNumForces, Results::nbond, numAtoms, PatchMap::Object(), p, patchID, ResizeArray< Elem >::resize(), results, Results::slow, SubmitReduction::submit(), Lattice::unscale(), Vector::x, Vector::y, and Vector::z.

00254 {
00255    DebugM(4, "patchID("<<patchID<<") forceBoxClosed! call\n");
00256 #ifndef NAMD_CUDA
00257    // calculate direct nonbonded virial from segregated forces and aggregate forces
00258    const Vector center = lattice.unscale( PatchMap::Object()->center(patchID) );
00259 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00260    const CompAtom * const __restrict pd = positionPtrBegin;
00261 #else
00262    const CompAtom * const __restrict pd = p.begin();
00263 #endif
00264    const int n = numAtoms;
00265    int roff = 0;
00266    for ( int j1 = Results::nbond; j1 <= Results::slow; ++j1, roff += REDUCTION_VIRIAL_SLOW_XX - REDUCTION_VIRIAL_NBOND_XX ) {
00267       int j2 = j1 + ( Results::nbond_virial - Results::nbond );
00268       Force * __restrict f1 = results.f[j1];
00269       Force * __restrict f2 = results.f[j2];
00270       BigReal virial_xx = 0.;
00271       BigReal virial_xy = 0.;
00272       BigReal virial_xz = 0.;
00273       BigReal virial_yy = 0.;
00274       BigReal virial_yz = 0.;
00275       BigReal virial_zz = 0.;
00276 #pragma simd reduction(+:virial_xx,virial_xy,virial_xz,virial_yy,virial_yz,virial_zz)
00277 #pragma ivdep
00278       for ( int i=0; i<n; ++i ) {
00279         BigReal p_x = pd[i].position.x - center.x;
00280         BigReal p_y = pd[i].position.y - center.y;
00281         BigReal p_z = pd[i].position.z - center.z;
00282         BigReal f_x = f2[i].x;
00283         BigReal f_y = f2[i].y;
00284         BigReal f_z = f2[i].z;
00285         virial_xx += f_x * p_x;
00286         virial_xy += f_x * p_y;
00287         virial_xz += f_x * p_z;
00288         virial_yy += f_y * p_y;
00289         virial_yz += f_y * p_z;
00290         virial_zz += f_z * p_z;
00291         f1[i].x += f_x;
00292         f1[i].y += f_y;
00293         f1[i].z += f_z;
00294       }
00295       f[j2].resize(0);
00296       reduction->item(roff + REDUCTION_VIRIAL_NBOND_XX) += virial_xx;
00297       reduction->item(roff + REDUCTION_VIRIAL_NBOND_XY) += virial_xy;
00298       reduction->item(roff + REDUCTION_VIRIAL_NBOND_XZ) += virial_xz;
00299       reduction->item(roff + REDUCTION_VIRIAL_NBOND_YX) += virial_xy;
00300       reduction->item(roff + REDUCTION_VIRIAL_NBOND_YY) += virial_yy;
00301       reduction->item(roff + REDUCTION_VIRIAL_NBOND_YZ) += virial_yz;
00302       reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZX) += virial_xz;
00303       reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZY) += virial_yz;
00304       reduction->item(roff + REDUCTION_VIRIAL_NBOND_ZZ) += virial_zz;
00305    }
00306    reduction->submit();
00307 #endif
00308 
00309    for (int j = 0; j < Results::maxNumForces; ++j )
00310    {
00311      results.f[j] = 0;
00312    }
00313    this->boxClosed(1);
00314 }

void Patch::gbisP2Ready (  ) 

Reimplemented in HomePatch.

Definition at line 508 of file Patch.C.

References ResizeArrayPrimIter< T >::begin(), computeNonbondedCUDA2Type, computeNonbondedCUDAType, computeNonbondedPairType, computeNonbondedSelfType, ResizeArrayPrimIter< T >::end(), flags, patchID, positionComputeList, and Flags::sequence.

Referenced by HomePatch::gbisP2Ready(), and ProxyPatch::receiveData().

00508                         {
00509  ComputePtrListIter cid(positionComputeList);
00510 
00511   int seq = flags.sequence;
00512   for(cid = cid.begin(); cid != cid.end(); cid++) {
00513     if ( (*cid)->type() == computeNonbondedSelfType ||
00514          (*cid)->type() == computeNonbondedPairType ||
00515          (*cid)->type() == computeNonbondedCUDAType
00516 #ifdef NAMD_CUDA
00517          || (*cid)->type() == computeNonbondedCUDA2Type
00518 #endif
00519          ) {
00520       (*cid)->gbisP2PatchReady(patchID,seq);
00521     }
00522   }
00523 }

void Patch::gbisP3Ready (  ) 

Reimplemented in HomePatch.

Definition at line 525 of file Patch.C.

References ResizeArrayPrimIter< T >::begin(), computeNonbondedCUDA2Type, computeNonbondedCUDAType, computeNonbondedPairType, computeNonbondedSelfType, ResizeArrayPrimIter< T >::end(), flags, patchID, positionComputeList, and Flags::sequence.

Referenced by HomePatch::gbisP3Ready(), and ProxyPatch::receiveData().

00525                         {
00526 
00527   ComputePtrListIter cid(positionComputeList);
00528 
00529   int seq = flags.sequence;
00530   for(cid = cid.begin(); cid != cid.end(); cid++) {
00531     if ( (*cid)->type() == computeNonbondedSelfType ||
00532          (*cid)->type() == computeNonbondedPairType ||
00533          (*cid)->type() == computeNonbondedCUDAType
00534 #ifdef NAMD_CUDA
00535          || (*cid)->type() == computeNonbondedCUDA2Type
00536 #endif
00537          ) {
00538       (*cid)->gbisP3PatchReady(patchID,seq);
00539     }
00540   }
00541 }

CompAtomExt* Patch::getCompAtomExtInfo (  )  [inline]

Definition at line 116 of file Patch.h.

References ResizeArray< Elem >::begin(), and pExt.

Referenced by ComputePme::doQMWork(), ComputePatchPair::doWork(), ComputePatch::doWork(), and ComputeLCPO::doWork().

00116 { return pExt.begin(); }

CudaAtom* Patch::getCudaAtomList (  )  [inline]

Definition at line 120 of file Patch.h.

References cudaAtomPtr.

00120 { return cudaAtomPtr; }

int Patch::getNumAtoms (  )  [inline]

Definition at line 104 of file Patch.h.

References numAtoms.

Referenced by WorkDistrib::assignNodeToPatch(), ComputePatch::atomUpdate(), ComputeHomePatch::atomUpdate(), ComputeGridForce::doForce(), ComputePme::doQMWork(), ComputePme::doWork(), ComputeNonbondedCUDA::doWork(), ComputePme::initialize(), ComputePatchPair::initialize(), ComputePatch::initialize(), ComputeLCPO::initialize(), ComputeHomePatch::initialize(), ComputeHomeTuples< AnisoElem, aniso, aniso >::loadTuples(), Node::outputPatchComputeMaps(), and recursive_bisect_with_curve().

00104 { return numAtoms; }

int Patch::getNumComputes (  )  [inline]

Definition at line 114 of file Patch.h.

References positionComputeList, and ResizeArray< Elem >::size().

00114 { return positionComputeList.size(); }

int Patch::getNumFixedAtoms (  )  [inline]

Definition at line 111 of file Patch.h.

References numFixedAtoms.

00111 { return numFixedAtoms; }  // not updated

PatchID Patch::getPatchID (  )  [inline]

Definition at line 113 of file Patch.h.

References patchID.

Referenced by ProxyMgr::createProxy(), ComputeNonbondedSelf::doForce(), ComputeNonbondedPair::doForce(), ComputePatch::initialize(), ComputeHomePatch::initialize(), PatchElem::PatchElem(), Sequencer::rebalanceLoad(), Sequencer::run(), Sequencer::Sequencer(), and TuplePatchElem::TuplePatchElem().

00113 { return patchID; }

int Patch::hasNewAtoms (  )  [inline]

Definition at line 39 of file Patch.h.

References _hasNewAtoms.

00039 { return _hasNewAtoms; }

void Patch::intRadBoxClosed ( void   ) 

Definition at line 337 of file Patch.C.

References boxClosed().

00337                                 {
00338    //dHdrPrefixPtr = 0;
00339    this->boxClosed(6);
00340 }

void Patch::lcpoTypeBoxClosed ( void   ) 

Definition at line 356 of file Patch.C.

References boxClosed().

00356                                   {
00357    this->boxClosed(10);
00358 }

void Patch::positionBoxClosed ( void   ) 

Definition at line 247 of file Patch.C.

References boxClosed().

00248 {
00249    //positionPtrBegin = 0;
00250    this->boxClosed(0);
00251 }

void Patch::positionsReady ( int  n = 0  ) 

Reimplemented in HomePatch.

Definition at line 360 of file Patch.C.

References atomMapper, ResizeArray< Elem >::begin(), boxesOpen, DebugM, Flags::doLoweAndersen, Flags::doMolly, ResizeArray< Elem >::end(), flags, if(), lattice, numAtoms, PatchMap::Object(), p, patchID, pExt, CompAtom::position, AtomMapper::registerIDsCompAtomExt(), Lattice::unscale(), CompAtom::vdwType, Vector::x, Vector::y, and Vector::z.

Referenced by ProxyPatch::receiveData().

00361 {
00362    DebugM(4,"Patch::positionsReady() - patchID(" << patchID <<")"<<std::endl );
00363 
00364    if ( doneMigration ){
00365 // #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00366 //       AtomMap::Object()->registerIDs(patchID,positionPtrBegin,positionPtrEnd);       
00367 // #else
00368        atomMapper->registerIDsCompAtomExt(pExt.begin(),pExt.end());
00369 // #endif
00370 
00371    }
00372 
00373 #ifdef NAMD_KNL
00374    {
00375      const Vector center = lattice.unscale( PatchMap::Object()->center(patchID) );
00376      const int n = numAtoms;
00377      pFlt.resize(n);
00378      CompAtomFlt * const pf = pFlt.begin();
00379 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00380      const CompAtom * const pd = positionPtrBegin;
00381 #else
00382      const CompAtom * const pd = p.begin();
00383 #endif
00384      for ( int i=0; i<n; ++i ) {
00385        // need to subtract center in double precision, then assign to float
00386        pf[i].position.x = pd[i].position.x - center.x;
00387        pf[i].position.y = pd[i].position.y - center.y;
00388        pf[i].position.z = pd[i].position.z - center.z;
00389        pf[i].vdwType = pd[i].vdwType;
00390      }
00391    }
00392 #endif
00393 
00394    boxesOpen = 2;
00395    if ( flags.doMolly ) boxesOpen++;
00396    // BEGIN LA
00397    if (flags.doLoweAndersen) {
00398        DebugM(4, "Patch::positionsReady, flags.doMolly = " << flags.doMolly << "\n");
00399        boxesOpen++;
00400    }
00401    // END LA
00402    _hasNewAtoms = (doneMigration != 0);
00403 
00404 #if CMK_BLUEGENEL
00405    CmiNetworkProgressAfter (0);
00406 #endif
00407 
00408    // Give all position pickup boxes access to positions
00409    //positionPtrBegin = p.begin();
00410 #ifdef REMOVE_PROXYDATAMSG_EXTRACOPY
00411    positionBox.open(positionPtrBegin);
00412 #else
00413    positionBox.open(p.begin());
00414 #endif
00415    if ( flags.doMolly ) {
00416      //avgPositionPtrBegin = p_avg.begin();
00417      avgPositionBox.open(avgPositionPtrBegin);
00418    }
00419    
00420    // BEGIN LA
00421    if (flags.doLoweAndersen) {
00422        velocityBox.open(velocityPtrBegin);
00423    }
00424    // END LA
00425    // begin gbis
00426     if (flags.doGBIS) {
00427       boxesOpen += 5;
00428       //intRad should already be taken care of
00429       intRadBox.open(intRad.begin());
00430       psiSum.resize(numAtoms);//resize array
00431       psiSum.setall(0);
00432       psiSumBox.open(psiSum.begin());
00433       psiFin.resize(numAtoms);//has no box
00434       psiFin.setall(0);
00435       bornRad.resize(numAtoms);
00436       bornRad.setall(0);
00437       bornRadBox.open(bornRad.begin());
00438       dEdaSum.resize(numAtoms);//resize array
00439       dEdaSum.setall(0);
00440       dEdaSumBox.open(dEdaSum.begin());
00441       dHdrPrefix.resize(numAtoms);
00442       dHdrPrefix.setall(0);
00443       dHdrPrefixBox.open(dHdrPrefix.begin());
00444     }
00445    // end gbis
00446 
00447   //LCPO
00448   if (flags.doLCPO) {
00449     boxesOpen++;
00450     lcpoTypeBox.open(lcpoType.begin());
00451   }
00452 
00453 #if CMK_BLUEGENEL
00454    CmiNetworkProgressAfter (0);
00455 #endif
00456    
00457    // Give all force deposit boxes access to forces
00458    Force *forcePtr;
00459    for ( int j = 0; j < Results::maxNumForces; ++j )
00460     {
00461       f[j].resize(numAtoms);
00462       forcePtr = f[j].begin();
00463       memset (forcePtr, 0, sizeof (Force) * numAtoms);
00464       results.f[j] = forcePtr;
00465     }
00466    forceBox.open(&results);
00467 
00468    if ( ! computesSortedByPriority ) {
00469      if (positionComputeList.size() == 0 && PatchMap::Object()->node(patchID) != CkMyPe()) {
00470        iout << iINFO << "PATCH_COUNT: Patch " << patchID 
00471             << " on PE " << CkMyPe() <<" home patch " 
00472             << PatchMap::Object()->node(patchID)
00473             << " does not have any computes\n" 
00474             << endi;
00475      }
00476 
00477      cptr_sortop_priority so;
00478      std::sort(positionComputeList.begin(), positionComputeList.end(), so);
00479      computesSortedByPriority = 1;
00480      int i;
00481      for ( i=0; i<positionComputeList.size(); ++i ) {
00482        if ( positionComputeList[i]->priority() > PME_PRIORITY ) break;
00483      }
00484      firstHoldableCompute = i;
00485    }
00486 
00487    int seq = flags.sequence;
00488 
00489    // Iterate over compute objects that need to be informed we are ready
00490    Compute **cid = positionComputeList.begin();
00491    for ( int i=0; i < firstHoldableCompute; ++i, ++cid ) {
00492      (*cid)->patchReady(patchID,doneMigration,seq);
00493    }
00494    Compute **cend = positionComputeList.end();
00495 
00496    // gzheng
00497    if (Sync::Object()->holdComputes(patchID, cid, cend, doneMigration, seq)) {
00498      return;
00499    }
00500 
00501    for( ; cid != cend; cid++ ) {
00502      (*cid)->patchReady(patchID,doneMigration,seq);
00503    }
00504 }

void Patch::psiSumBoxClosed ( void   ) 

Definition at line 334 of file Patch.C.

References boxClosed().

00334                                 {
00335   this->boxClosed(5);
00336 }

Box< Patch, CompAtom > * Patch::registerAvgPositionPickup ( Compute cid  ) 

Definition at line 134 of file Patch.C.

References avgPositionBox, OwnerBox< Owner, Data >::checkOut(), and Compute::cid.

Referenced by ComputePme::initialize(), ComputeNonbondedSelf::initialize(), PatchElem::PatchElem(), and TuplePatchElem::TuplePatchElem().

00135 {
00136    //DebugM(4, "registerAvgPositionPickup("<<patchID<<") from " << cid->cid << "\n");
00137    return avgPositionBox.checkOut(cid->cid);
00138 }

Box< Patch, Real > * Patch::registerBornRadPickup ( Compute cid  ) 

Definition at line 196 of file Patch.C.

References bornRadBox, and Compute::cid.

Referenced by ComputeNonbondedSelf::initialize(), ComputeNonbondedPair::initialize(), and ComputeNonbondedCUDA::registerPatches().

00196                                                           {
00197   return bornRadBox.checkOut(cid->cid);
00198 }

Box< Patch, GBReal > * Patch::registerDEdaSumDeposit ( Compute cid  ) 

Definition at line 204 of file Patch.C.

References SortedArray< Elem >::add(), Compute::cid, DebugM, dEdaSumBox, dEdaSumComputeList, and ResizeArray< Elem >::size().

Referenced by ComputeNonbondedSelf::initialize(), ComputeNonbondedPair::initialize(), and ComputeNonbondedCUDA::registerPatches().

00204                                                              {
00205   if (dEdaSumComputeList.add(cid) < 0) {
00206     DebugM(7, "registerDEdaSumDeposit() failed for cid " << cid->cid << std::endl);
00207     DebugM(7, "  size of dEdaSumCompueList " << dEdaSumComputeList.size() << std::endl);
00208      return NULL;
00209   }
00210   return dEdaSumBox.checkOut(cid->cid);
00211 }

Box< Patch, Real > * Patch::registerDHdrPrefixPickup ( Compute cid  ) 

Definition at line 218 of file Patch.C.

References Compute::cid, and dHdrPrefixBox.

Referenced by ComputeNonbondedSelf::initialize(), ComputeNonbondedPair::initialize(), and ComputeNonbondedCUDA::registerPatches().

00219 {
00220   return dHdrPrefixBox.checkOut(cid->cid);
00221 }

Box< Patch, Results > * Patch::registerForceDeposit ( Compute cid  ) 

Definition at line 228 of file Patch.C.

References SortedArray< Elem >::add(), OwnerBox< Owner, Data >::checkOut(), Compute::cid, DebugM, forceBox, forceComputeList, and ResizeArray< Elem >::size().

Referenced by ComputePme::initialize(), ComputePatchPair::initialize(), ComputePatch::initialize(), ComputeLCPO::initialize(), ComputeHomePatch::initialize(), PatchElem::PatchElem(), ComputeNonbondedCUDA::registerPatches(), and TuplePatchElem::TuplePatchElem().

00229 {
00230    if (forceComputeList.add(cid) < 0)
00231    {
00232      DebugM(7, "registerForceDeposit() failed for cid " << cid->cid << std::endl);
00233      DebugM(7, "  size of forceCompueList " << forceComputeList.size() << std::endl);
00234      return NULL;
00235    }
00236    return forceBox.checkOut(cid->cid);
00237 }

Box< Patch, Real > * Patch::registerIntRadPickup ( Compute cid  ) 

Definition at line 179 of file Patch.C.

References Compute::cid, and intRadBox.

Referenced by ComputeNonbondedSelf::initialize(), ComputeNonbondedPair::initialize(), and ComputeNonbondedCUDA::registerPatches().

00179                                                          {
00180   return intRadBox.checkOut(cid->cid);
00181 }

Box< Patch, int > * Patch::registerLcpoTypePickup ( Compute cid  ) 

Definition at line 188 of file Patch.C.

References OwnerBox< Owner, Data >::checkOut(), Compute::cid, and lcpoTypeBox.

Referenced by ComputeLCPO::initialize().

00188                                                           {
00189   return lcpoTypeBox.checkOut(cid->cid);
00190 }

Box< Patch, CompAtom > * Patch::registerPositionPickup ( Compute cid  ) 

Definition at line 107 of file Patch.C.

References SortedArray< Elem >::add(), OwnerBox< Owner, Data >::checkOut(), Compute::cid, computesSortedByPriority, DebugM, positionBox, positionComputeList, and SortedArray< Elem >::sort().

Referenced by ComputePme::initialize(), ComputePatchPair::initialize(), ComputePatch::initialize(), ComputeLCPO::initialize(), ComputeHomePatch::initialize(), PatchElem::PatchElem(), ComputeNonbondedCUDA::registerPatches(), and TuplePatchElem::TuplePatchElem().

00108 {
00109    if ( computesSortedByPriority ) {
00110      positionComputeList.sort();
00111      computesSortedByPriority = 0;
00112    }
00113    //DebugM(4, "registerPositionPickupa("<<patchID<<") from " << cid->cid << "\n");
00114    if (positionComputeList.add(cid) < 0)
00115    {
00116      DebugM(7, "registerPositionPickup() failed for cid " << cid->cid << std::endl);
00117      return NULL;
00118    }
00119    return positionBox.checkOut(cid->cid);
00120 }

Box< Patch, GBReal > * Patch::registerPsiSumDeposit ( Compute cid  ) 

Definition at line 164 of file Patch.C.

References SortedArray< Elem >::add(), Compute::cid, DebugM, psiSumBox, psiSumComputeList, and ResizeArray< Elem >::size().

Referenced by ComputeNonbondedSelf::initialize(), ComputeNonbondedPair::initialize(), and ComputeNonbondedCUDA::registerPatches().

00164                                                             {
00165 
00166   if (psiSumComputeList.add(cid) < 0) {
00167     DebugM(7, "registerPsiSumDeposit() failed for cid " << cid->cid << std::endl);
00168     DebugM(7, "  size of psiSumCompueList " << psiSumComputeList.size() << std::endl);
00169      return NULL;
00170   }
00171   return psiSumBox.checkOut(cid->cid);
00172 }

Box< Patch, CompAtom > * Patch::registerVelocityPickup ( Compute cid  ) 

Definition at line 148 of file Patch.C.

References OwnerBox< Owner, Data >::checkOut(), Compute::cid, and velocityBox.

Referenced by ComputeNonbondedSelf::initialize(), and ComputeNonbondedPair::initialize().

00149 {
00150    //DebugM(4, "registerVelocityPickup("<<patchID<<") from " << cid->cid << "\n");
00151    return velocityBox.checkOut(cid->cid);
00152 }

void Patch::setNumFixedAtoms ( int  numFixed  )  [inline]

Definition at line 112 of file Patch.h.

References numFixedAtoms.

Referenced by PatchMgr::setHomePatchFixedAtomNum().

00112 { numFixedAtoms=numFixed; }  // not updated

void Patch::unregisterAvgPositionPickup ( Compute cid,
Box< Patch, CompAtom > **const   box 
)

Definition at line 140 of file Patch.C.

References avgPositionBox, OwnerBox< Owner, Data >::checkIn(), Compute::cid, and DebugM.

Referenced by ComputeNonbondedSelf::~ComputeNonbondedSelf(), and ComputePmeCUDA::~ComputePmeCUDA().

00141 {
00142    DebugM(4, "UnregisterAvgPositionPickup from " << cid->cid << "\n");
00143    avgPositionBox.checkIn(*box);
00144    *box = 0;
00145 }

void Patch::unregisterBornRadPickup ( Compute cid,
Box< Patch, Real > **const   box 
)

Definition at line 199 of file Patch.C.

References bornRadBox.

Referenced by ComputeNonbondedSelf::~ComputeNonbondedSelf().

00199                                                                             {
00200   bornRadBox.checkIn(*box);
00201   *box = 0;
00202 }

void Patch::unregisterDEdaSumDeposit ( Compute cid,
Box< Patch, GBReal > **const   box 
)

Definition at line 212 of file Patch.C.

References dEdaSumBox, dEdaSumComputeList, and SortedArray< Elem >::del().

Referenced by ComputeNonbondedSelf::~ComputeNonbondedSelf().

00212                                                                               {
00213   dEdaSumComputeList.del(cid);
00214   dEdaSumBox.checkIn(*box);
00215   *box = 0;
00216 }

void Patch::unregisterDHdrPrefixPickup ( Compute cid,
Box< Patch, Real > **const   box 
)

Definition at line 222 of file Patch.C.

References dHdrPrefixBox.

Referenced by ComputeNonbondedSelf::~ComputeNonbondedSelf().

00222                                                                                {
00223   dHdrPrefixBox.checkIn(*box);
00224   *box = 0;
00225 }

void Patch::unregisterForceDeposit ( Compute cid,
Box< Patch, Results > **const   box 
)

Definition at line 239 of file Patch.C.

References OwnerBox< Owner, Data >::checkIn(), DebugM, SortedArray< Elem >::del(), forceBox, and forceComputeList.

Referenced by ComputeHomePatch::~ComputeHomePatch(), ComputeLCPO::~ComputeLCPO(), ComputePatch::~ComputePatch(), and ComputePmeCUDA::~ComputePmeCUDA().

00240 {
00241    DebugM(4, "unregisterForceDeposit() computeID("<<cid<<")"<<std::endl);
00242    forceComputeList.del(cid);
00243    forceBox.checkIn(*box);
00244    *box = 0;
00245 }

void Patch::unregisterIntRadPickup ( Compute cid,
Box< Patch, Real > **const   box 
)

Definition at line 182 of file Patch.C.

References intRadBox.

Referenced by ComputeNonbondedSelf::~ComputeNonbondedSelf().

00182                                                                            {
00183   intRadBox.checkIn(*box);
00184   *box = 0;
00185 }

void Patch::unregisterLcpoTypePickup ( Compute cid,
Box< Patch, int > **const   box 
)

Definition at line 191 of file Patch.C.

References OwnerBox< Owner, Data >::checkIn(), and lcpoTypeBox.

Referenced by ComputeLCPO::~ComputeLCPO().

00191                                                                             {
00192   lcpoTypeBox.checkIn(*box);
00193   *box = 0;
00194 }

void Patch::unregisterPositionPickup ( Compute cid,
Box< Patch, CompAtom > **const   box 
)

Definition at line 122 of file Patch.C.

References OwnerBox< Owner, Data >::checkIn(), Compute::cid, computesSortedByPriority, DebugM, SortedArray< Elem >::del(), positionBox, positionComputeList, and SortedArray< Elem >::sort().

Referenced by ComputeHomePatch::~ComputeHomePatch(), ComputeLCPO::~ComputeLCPO(), ComputePatch::~ComputePatch(), and ComputePmeCUDA::~ComputePmeCUDA().

00123 {
00124    if ( computesSortedByPriority ) {
00125      positionComputeList.sort();
00126      computesSortedByPriority = 0;
00127    }
00128    DebugM(4, "UnregisterPositionPickup from " << cid->cid << "\n");
00129    positionComputeList.del(cid);
00130    positionBox.checkIn(*box);
00131    *box = 0;
00132 }

void Patch::unregisterPsiSumDeposit ( Compute cid,
Box< Patch, GBReal > **const   box 
)

Definition at line 174 of file Patch.C.

References SortedArray< Elem >::del(), psiSumBox, and psiSumComputeList.

Referenced by ComputeNonbondedSelf::~ComputeNonbondedSelf().

00174                                                                               {
00175   psiSumComputeList.del(cid);
00176   psiSumBox.checkIn(*box);
00177   *box = 0;
00178 }

void Patch::unregisterVelocityPickup ( Compute cid,
Box< Patch, CompAtom > **const   box 
)

Definition at line 154 of file Patch.C.

References OwnerBox< Owner, Data >::checkIn(), Compute::cid, DebugM, and velocityBox.

Referenced by ComputeNonbondedSelf::~ComputeNonbondedSelf().

00155 {
00156    DebugM(4, "UnregisterVelocityPickup from " << cid->cid << "\n");
00157    velocityBox.checkIn(*box);
00158    *box = 0;
00159 }

void Patch::velocityBoxClosed ( void   ) 

Definition at line 323 of file Patch.C.

References boxClosed(), DebugM, patchID, and velocityPtrBegin.

00324 {
00325    DebugM(4, "patchID("<<patchID<<") velocityBoxClosed! call\n");
00326    velocityPtrBegin = 0;
00327    this->boxClosed(4);  // ?? Don't know about number
00328 }


Member Data Documentation

int Patch::_hasNewAtoms [protected]

Definition at line 238 of file Patch.h.

Referenced by hasNewAtoms().

AtomMapper* Patch::atomMapper [protected]

Definition at line 148 of file Patch.h.

Referenced by HomePatch::doAtomMigration(), Sequencer::integrate(), Sequencer::minimize(), Patch(), positionsReady(), ProxyPatch::receiveAll(), HomePatch::recvCheckpointLoad(), HomePatch::recvExchangeMsg(), HomePatch::revert(), HomePatch::~HomePatch(), ~Patch(), and ProxyPatch::~ProxyPatch().

OwnerBox<Patch,CompAtom> Patch::avgPositionBox [protected]

Definition at line 208 of file Patch.h.

Referenced by registerAvgPositionPickup(), and unregisterAvgPositionPickup().

ComputePtrList Patch::avgPositionComputeList [protected]

Definition at line 209 of file Patch.h.

CompAtom* Patch::avgPositionPtrBegin [protected]

Definition at line 190 of file Patch.h.

Referenced by avgPositionBoxClosed(), ProxyPatch::receiveAll(), and ProxyPatch::receiveData().

CompAtom* Patch::avgPositionPtrEnd [protected]

Definition at line 191 of file Patch.h.

Referenced by ProxyPatch::receiveAll(), and ProxyPatch::receiveData().

RealList Patch::bornRad [protected]

Definition at line 154 of file Patch.h.

Referenced by HomePatch::gbisComputeAfterP1(), HomePatch::gbisComputeAfterP2(), HomePatch::gbisP2Ready(), and ProxyPatch::receiveData().

OwnerBox<Patch,Real> Patch::bornRadBox [protected]

Definition at line 220 of file Patch.h.

Referenced by registerBornRadPickup(), and unregisterBornRadPickup().

ComputePtrList Patch::bornRadComputeList [protected]

Definition at line 221 of file Patch.h.

int Patch::boxesOpen [protected]

Definition at line 236 of file Patch.h.

Referenced by ProxyPatch::boxClosed(), HomePatch::boxClosed(), positionsReady(), ProxyPatch::receiveAll(), and ProxyPatch::receiveData().

int* Patch::child [protected]

Definition at line 255 of file Patch.h.

Referenced by ProxyPatch::getSpanningTreeChild(), ProxyPatch::getSpanningTreeChildPtr(), Patch(), ProxyPatch::ProxyPatch(), ProxyPatch::setSpanningTree(), and ProxyPatch::~ProxyPatch().

int Patch::computesSortedByPriority [protected]

Definition at line 203 of file Patch.h.

Referenced by registerPositionPickup(), and unregisterPositionPickup().

CudaAtom* Patch::cudaAtomPtr [protected]

Definition at line 198 of file Patch.h.

Referenced by getCudaAtomList(), Patch(), HomePatch::positionsReady(), ProxyPatch::receiveAll(), and ProxyPatch::receiveData().

GBRealList Patch::dEdaSum [protected]

Definition at line 156 of file Patch.h.

Referenced by ProxyPatch::boxClosed(), and HomePatch::gbisComputeAfterP2().

OwnerBox<Patch,GBReal> Patch::dEdaSumBox [protected]

Definition at line 222 of file Patch.h.

Referenced by HomePatch::boxClosed(), registerDEdaSumDeposit(), and unregisterDEdaSumDeposit().

ComputePtrList Patch::dEdaSumComputeList [protected]

Definition at line 223 of file Patch.h.

Referenced by registerDEdaSumDeposit(), and unregisterDEdaSumDeposit().

RealList Patch::dHdrPrefix [protected]

Definition at line 155 of file Patch.h.

Referenced by HomePatch::gbisComputeAfterP2(), HomePatch::gbisP3Ready(), ProxyPatch::receiveData(), and HomePatch::receiveResult().

OwnerBox<Patch,Real> Patch::dHdrPrefixBox [protected]

Definition at line 224 of file Patch.h.

Referenced by registerDHdrPrefixPickup(), and unregisterDHdrPrefixPickup().

ComputePtrList Patch::dHdrPrefixComputeList [protected]

Definition at line 225 of file Patch.h.

ForceList Patch::f[Results::maxNumForces] [protected]

Definition at line 200 of file Patch.h.

Referenced by Sequencer::addForceToMomentum(), Sequencer::addForceToMomentum3(), HomePatch::addRattleForce(), HomePatch::boxClosed(), Sequencer::calcFixVirial(), forceBoxClosed(), HomePatch::minimize_rattle2(), Sequencer::minimizeMoveDownhill(), HomePatch::mollyMollify(), Sequencer::multigratorPressure(), Sequencer::newMinimizeDirection(), HomePatch::rattle1old(), HomePatch::receiveResults(), HomePatch::replaceForces(), Sequencer::rescaleaccelMD(), HomePatch::saveForce(), ComputeGlobal::saveTotalForces(), Sequencer::submitCollections(), Sequencer::submitMinimizeReductions(), and Sequencer::submitReductions().

int Patch::firstHoldableCompute [protected]

Definition at line 204 of file Patch.h.

Flags Patch::flags

Definition at line 123 of file Patch.h.

Referenced by ProxyPatch::boxClosed(), HomePatch::boxClosed(), ExclElem::computeForce(), ImproperElem::computeForce(), DihedralElem::computeForce(), BondElem::computeForce(), AngleElem::computeForce(), ComputeGridForce::do_calc(), ComputeStir::doForce(), ComputeRestraints::doForce(), ComputeNonbondedSelf::doForce(), ComputeNonbondedPair::doForce(), ComputeLCPO::doForce(), ComputeGridForce::doForce(), ComputeEField::doForce(), HomePatch::doGroupSizeCheck(), HomePatch::doPairlistCheck(), ComputePme::doWork(), ComputePatch::doWork(), HomePatch::gbisComputeAfterP1(), HomePatch::gbisComputeAfterP2(), gbisP2Ready(), HomePatch::gbisP2Ready(), gbisP3Ready(), HomePatch::gbisP3Ready(), Sequencer::integrate(), Sequencer::minimize(), Sequencer::multigratorPressure(), ComputePme::noWork(), ComputeNonbondedSelf::noWork(), positionsReady(), HomePatch::positionsReady(), ProxyPatch::receiveAll(), ProxyPatch::receiveData(), HomePatch::receiveResult(), Sequencer::runComputeObjects(), Sequencer::submitCollections(), Sequencer::submitHalfstep(), Sequencer::submitMinimizeReductions(), Sequencer::submitReductions(), and ComputePme::ungridForces().

OwnerBox<Patch,Results> Patch::forceBox [protected]

Definition at line 232 of file Patch.h.

Referenced by HomePatch::receiveResults(), registerForceDeposit(), HomePatch::registerProxy(), unregisterForceDeposit(), and HomePatch::unregisterProxy().

ComputePtrList Patch::forceComputeList [protected]

Definition at line 233 of file Patch.h.

Referenced by registerForceDeposit(), and unregisterForceDeposit().

RealList Patch::intRad [protected]

Definition at line 151 of file Patch.h.

Referenced by HomePatch::gbisComputeAfterP1(), HomePatch::gbisComputeAfterP2(), HomePatch::positionsReady(), ProxyPatch::receiveAll(), and HomePatch::setGBISIntrinsicRadii().

OwnerBox<Patch,Real> Patch::intRadBox [protected]

Definition at line 216 of file Patch.h.

Referenced by registerIntRadPickup(), and unregisterIntRadPickup().

ComputePtrList Patch::intRadComputeList [protected]

Definition at line 217 of file Patch.h.

Lattice& Patch::lattice

Definition at line 122 of file Patch.h.

Referenced by Sequencer::berendsenPressure(), HomePatch::checkpoint(), TholeElem::computeForce(), ExclElem::computeForce(), ImproperElem::computeForce(), GromacsPairElem::computeForce(), DihedralElem::computeForce(), CrosstermElem::computeForce(), BondElem::computeForce(), AnisoElem::computeForce(), AngleElem::computeForce(), HomePatch::depositMigration(), ComputeGridForce::do_calc(), HomePatch::doAtomMigration(), ComputeStir::doForce(), ComputeRestraints::doForce(), ComputeNonbondedSelf::doForce(), ComputeNonbondedPair::doForce(), ComputeGridForce::doForce(), ComputeEField::doForce(), ComputeConsTorque::doForce(), ComputeConsForce::doForce(), HomePatch::doMarginCheck(), HomePatch::doPairlistCheck(), HomePatch::exchangeAtoms(), forceBoxClosed(), HomePatch::hardWallDrude(), Sequencer::langevinPiston(), PatchMgr::moveAtom(), Sequencer::multigratorPressure(), Patch(), positionsReady(), HomePatch::positionsReady(), HomePatch::rattle1old(), HomePatch::recvCheckpointLoad(), HomePatch::recvExchangeMsg(), HomePatch::revert(), Sequencer::scalePositionsVelocities(), Sequencer::submitCollections(), Sequencer::submitHalfstep(), and Sequencer::submitReductions().

IntList Patch::lcpoType [protected]

Definition at line 160 of file Patch.h.

Referenced by HomePatch::positionsReady(), ProxyPatch::receiveAll(), HomePatch::setLcpoType(), and ProxyPatch::~ProxyPatch().

OwnerBox<Patch,int> Patch::lcpoTypeBox [protected]

Definition at line 229 of file Patch.h.

Referenced by registerLcpoTypePickup(), and unregisterLcpoTypePickup().

ComputePtrList Patch::lcpoTypeComputeList [protected]

Definition at line 230 of file Patch.h.

int Patch::nChild [protected]

Definition at line 256 of file Patch.h.

Referenced by ProxyPatch::getSpanningTreeNChild(), Patch(), and ProxyPatch::ProxyPatch().

int Patch::numAtoms [protected]

Definition at line 140 of file Patch.h.

Referenced by Sequencer::addForceToMomentum(), Sequencer::addForceToMomentum3(), Sequencer::addMovDragToPosition(), Sequencer::addRotDragToPosition(), Sequencer::addVelocityToPosition(), Sequencer::berendsenPressure(), ProxyPatch::boxClosed(), Sequencer::calcFixVirial(), Sequencer::calcKineticEnergy(), Sequencer::correctMomentum(), forceBoxClosed(), getNumAtoms(), Sequencer::langevinPiston(), Sequencer::langevinVelocities(), Sequencer::langevinVelocitiesBBK1(), Sequencer::langevinVelocitiesBBK2(), Sequencer::maximumMove(), Sequencer::minimizationQuenchVelocity(), Sequencer::minimizeMoveDownhill(), Sequencer::multigratorPressure(), Sequencer::multigratorTemperature(), Sequencer::newMinimizeDirection(), Sequencer::newMinimizePosition(), positionsReady(), ProxyPatch::ProxyPatch(), Sequencer::quenchVelocities(), Sequencer::reassignVelocities(), ProxyPatch::receiveAll(), ProxyPatch::receiveData(), Sequencer::reinitVelocities(), Sequencer::reloadCharges(), Sequencer::rescaleaccelMD(), Sequencer::rescaleVelocities(), Sequencer::rescaleVelocitiesByFactor(), ComputeGlobal::saveTotalForces(), Sequencer::scalePositionsVelocities(), Sequencer::scaleVelocities(), Sequencer::submitHalfstep(), Sequencer::submitMinimizeReductions(), Sequencer::submitMomentum(), Sequencer::submitReductions(), and Sequencer::tcoupleVelocities().

int Patch::numFixedAtoms [protected]

Definition at line 141 of file Patch.h.

Referenced by getNumFixedAtoms(), and setNumFixedAtoms().

CompAtomList Patch::p [protected]

Definition at line 142 of file Patch.h.

Referenced by IRSet::find(), forceBoxClosed(), ComputeHomeTuples< AnisoElem, aniso, aniso >::loadTuples(), positionsReady(), HomePatch::positionsReady(), IRSet::print(), ProxyPatch::receiveAll(), ProxyPatch::receiveData(), IRSet::remove(), and ProxyPatch::~ProxyPatch().

CompAtomList Patch::p_avg [protected]

Definition at line 143 of file Patch.h.

Referenced by HomePatch::mollyAverage(), HomePatch::mollyMollify(), and HomePatch::positionsReady().

const PatchID Patch::patchID [protected]

Definition at line 139 of file Patch.h.

Referenced by ProxyPatch::boxClosed(), HomePatch::boxClosed(), HomePatch::buildSpanningTree(), HomePatch::depositMigration(), HomePatch::doAtomMigration(), HomePatch::exchangeAtoms(), HomePatch::exchangeCheckpoint(), forceBoxClosed(), gbisP2Ready(), HomePatch::gbisP2Ready(), gbisP3Ready(), HomePatch::gbisP3Ready(), getPatchID(), Sequencer::integrate(), Sequencer::maximumMove(), positionsReady(), HomePatch::positionsReady(), ProxyPatch::ProxyPatch(), ProxyPatch::receiveAll(), ProxyPatch::receiveData(), HomePatch::receiveResults(), HomePatch::recvCheckpointLoad(), HomePatch::recvCheckpointReq(), HomePatch::recvCheckpointStore(), HomePatch::registerProxy(), HomePatch::sendProxies(), HomePatch::sendSpanningTree(), HomePatch::submitLoadStats(), velocityBoxClosed(), and ProxyPatch::~ProxyPatch().

CompAtomExtList Patch::pExt [protected]

Definition at line 170 of file Patch.h.

Referenced by HomePatch::gbisComputeAfterP1(), HomePatch::gbisComputeAfterP2(), getCompAtomExtInfo(), positionsReady(), HomePatch::positionsReady(), ProxyPatch::receiveAll(), ProxyPatch::receiveData(), HomePatch::setLcpoType(), Sequencer::submitMinimizeReductions(), and ProxyPatch::~ProxyPatch().

OwnerBox<Patch,CompAtom> Patch::positionBox [protected]

Definition at line 206 of file Patch.h.

Referenced by registerPositionPickup(), and unregisterPositionPickup().

ComputePtrList Patch::positionComputeList [protected]

Definition at line 207 of file Patch.h.

Referenced by gbisP2Ready(), gbisP3Ready(), getNumComputes(), registerPositionPickup(), and unregisterPositionPickup().

GBRealList Patch::psiFin [protected]

Definition at line 153 of file Patch.h.

Referenced by HomePatch::gbisComputeAfterP1(), HomePatch::gbisComputeAfterP2(), and HomePatch::receiveResult().

GBRealList Patch::psiSum [protected]

Definition at line 152 of file Patch.h.

Referenced by ProxyPatch::boxClosed(), and HomePatch::gbisComputeAfterP1().

OwnerBox<Patch,GBReal> Patch::psiSumBox [protected]

Definition at line 218 of file Patch.h.

Referenced by HomePatch::boxClosed(), registerPsiSumDeposit(), and unregisterPsiSumDeposit().

ComputePtrList Patch::psiSumComputeList [protected]

Definition at line 219 of file Patch.h.

Referenced by registerPsiSumDeposit(), and unregisterPsiSumDeposit().

Results Patch::results [protected]

Definition at line 201 of file Patch.h.

Referenced by forceBoxClosed().

CompAtomList Patch::v [protected]

Definition at line 145 of file Patch.h.

Referenced by HomePatch::positionsReady().

OwnerBox<Patch,CompAtom> Patch::velocityBox [protected]

Definition at line 211 of file Patch.h.

Referenced by registerVelocityPickup(), and unregisterVelocityPickup().

ComputePtrList Patch::velocityComputeList [protected]

Definition at line 212 of file Patch.h.

CompAtom* Patch::velocityPtrBegin [protected]

Definition at line 194 of file Patch.h.

Referenced by ProxyPatch::receiveAll(), ProxyPatch::receiveData(), and velocityBoxClosed().

CompAtom* Patch::velocityPtrEnd [protected]

Definition at line 195 of file Patch.h.

Referenced by ProxyPatch::receiveAll(), and ProxyPatch::receiveData().


The documentation for this class was generated from the following files:
Generated on Fri Nov 24 01:17:20 2017 for NAMD by  doxygen 1.4.7