NAMD
Public Member Functions | Public Attributes | List of all members
MsmC1HermiteBlock Class Reference
Inheritance diagram for MsmC1HermiteBlock:
MsmBlockKernel< C1Vector, C1Matrix >

Public Member Functions

 MsmC1HermiteBlock (int level)
 
 MsmC1HermiteBlock (CkMigrateMessage *m)
 
void setupSections ()
 
void sumReducedPotential (CkReductionMsg *msg)
 
void addCharge (GridMsg *)
 
void restriction ()
 
void sendUpCharge ()
 
void gridCutoff ()
 
void addPotential (GridMsg *)
 
void prolongation ()
 
void sendDownPotential ()
 
void sendPatch ()
 
- Public Member Functions inherited from MsmBlockKernel< C1Vector, C1Matrix >
 MsmBlockKernel (const msm::BlockIndex &)
 
 MsmBlockKernel (CkMigrateMessage *m)
 
void init ()
 
void setupStencils (const msm::Grid< C1Matrix > *res, const msm::Grid< C1Matrix > *pro)
 
void restrictionKernel ()
 
void prolongationKernel ()
 

Public Attributes

CProxySection_MsmC1HermiteGridCutoff msmGridCutoffBroadcast
 
CProxySection_MsmC1HermiteGridCutoff msmGridCutoffReduction
 
- Public Attributes inherited from MsmBlockKernel< C1Vector, C1Matrix >
CProxy_ComputeMsmMgr mgrProxy
 
ComputeMsmMgrmgrLocal
 
msm::Mapmap
 
msm::BlockDiagrambd
 
msm::Grid< C1Vectorqh
 
msm::Grid< C1Vectoreh
 
const msm::Grid< C1Matrix > * resStencil
 
const msm::Grid< C1Matrix > * proStencil
 
msm::Grid< C1VectorqhRestricted
 
msm::Grid< C1VectorehProlongated
 
int cntRecvsCharge
 
int cntRecvsPotential
 
msm::BlockIndex blockIndex
 
msm::Grid< C1Vectorsubgrid
 
int sequence
 

Detailed Description

Definition at line 3458 of file ComputeMsm.C.

Constructor & Destructor Documentation

MsmC1HermiteBlock::MsmC1HermiteBlock ( int  level)
inline

Definition at line 3466 of file ComputeMsm.C.

References msm::Map::gc_c1hermite, msm::Map::gpro_c1hermite, msm::Map::gres_c1hermite, msm::Map::gridrange, and ComputeMsmMgr::map.

3466  :
3468  msm::BlockIndex(level,
3469  msm::Ivec(thisIndex.x, thisIndex.y, thisIndex.z))
3470  )
3471  {
3472  int isfirstlevel = (level == 0);
3473  int istoplevel = (level == map->gridrange.len()-1);
3474  const msm::Grid<C1Matrix> *res =
3475  (istoplevel ? NULL : &(map->gres_c1hermite[level]));
3476  const msm::Grid<C1Matrix> *pro =
3477  (isfirstlevel ? NULL : &(map->gpro_c1hermite[level-1]));
3478 #ifndef MSM_GRID_CUTOFF_DECOMP
3479  const msm::Grid<C1Matrix> *gc = &(map->gc_c1hermite[level]);
3480  setupStencils(res, pro, gc);
3481 #else
3482  setupStencils(res, pro);
3483 #endif
3484  }
Array< Grid< C1Matrix > > gpro_c1hermite
Definition: MsmMap.h:952
Array< Grid< C1Matrix > > gres_c1hermite
Definition: MsmMap.h:951
Array< IndexRange > gridrange
Definition: MsmMap.h:942
Array< Grid< C1Matrix > > gc_c1hermite
Definition: MsmMap.h:949
void setupStencils(const msm::Grid< C1Matrix > *res, const msm::Grid< C1Matrix > *pro)
Definition: ComputeMsm.C:2774
MsmC1HermiteBlock::MsmC1HermiteBlock ( CkMigrateMessage *  m)
inline

Member Function Documentation

void MsmC1HermiteBlock::addCharge ( GridMsg gm)

Definition at line 3597 of file ComputeMsm.C.

References MsmTimer::COMM, GridMsg::get(), ComputeMsmMgr::nlevels, restriction(), and ComputeMsmMgr::subgrid.

3598 {
3599 #ifdef MSM_TIMING
3600  double startTime, stopTime;
3601  startTime = CkWallTimer();
3602 #endif
3603  int pid;
3604  gm->get(subgrid, pid, sequence);
3605  delete gm;
3606  qh += subgrid;
3607 #ifdef MSM_TIMING
3608  stopTime = CkWallTimer();
3609  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
3610 #endif
3611  if (++cntRecvsCharge == bd->numRecvsCharge) {
3612  int nlevels = mgrLocal->numLevels();
3613  if (blockIndex.level < nlevels-1) {
3614  restriction();
3615  }
3616  gridCutoff();
3617  }
3618 } // MsmC1HermiteBlock::addCharge()
int numLevels() const
Definition: ComputeMsm.C:449
void get(msm::Grid< T > &g, int &id, int &seq)
Definition: ComputeMsm.C:141
int numRecvsCharge
Definition: MsmMap.h:923
void MsmC1HermiteBlock::addPotential ( GridMsg gm)

Definition at line 3748 of file ComputeMsm.C.

References MsmTimer::COMM, GridMsg::get(), prolongation(), and ComputeMsmMgr::subgrid.

3749 {
3750 #ifdef MSM_TIMING
3751  double startTime, stopTime;
3752  startTime = CkWallTimer();
3753 #endif
3754  int pid;
3755  int pseq;
3756  gm->get(subgrid, pid, pseq); // receive sender's level
3757  delete gm;
3758  eh += subgrid;
3759 #ifdef MSM_TIMING
3760  stopTime = CkWallTimer();
3761  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
3762 #endif
3764  if (blockIndex.level > 0) {
3765  prolongation();
3766  }
3767  else {
3768  sendPatch();
3769  }
3770  }
3771 } // MsmC1HermiteBlock::addPotential()
int numRecvsPotential
Definition: MsmMap.h:924
void get(msm::Grid< T > &g, int &id, int &seq)
Definition: ComputeMsm.C:141
void MsmC1HermiteBlock::gridCutoff ( )

Definition at line 3656 of file ComputeMsm.C.

References MsmTimer::COMM, MSM_PRIORITY, GridMsg::put(), and SET_PRIORITY.

3657 {
3658 #ifdef DEBUG_MSM_GRID
3659  printf("MsmC1HermiteBlock level=%d, id=%d %d %d: grid cutoff\n",
3661 #endif
3662 #ifndef MSM_GRID_CUTOFF_DECOMP
3663  gridCutoffKernel();
3664  sendAcrossPotential();
3665 #else // MSM_GRID_CUTOFF_DECOMP
3666 
3667  // send charge block to MsmGridCutoff compute objects
3668 #ifdef MSM_TIMING
3669  double startTime, stopTime;
3670  startTime = CkWallTimer();
3671 #endif
3672  int priority = mgrLocal->nlevels + 2*(mgrLocal->nlevels - blockIndex.level)-1;
3673  int msgsz = qh.data().len() * sizeof(C1Vector);
3674  int len = bd->indexGridCutoff.len();
3675 
3676 #if 0
3677  // send charge message to each MsmGridCutoff compute element in list
3678  for (int n = 0; n < len; n++) {
3679 #ifdef MSM_TIMING
3680  startTime = CkWallTimer();
3681 #endif
3682  int index = bd->indexGridCutoff[n];
3683  GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
3684  SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
3685  gm->put(qh, blockIndex.level, sequence); // send my level
3686 #ifdef MSM_TIMING
3687  stopTime = CkWallTimer();
3688  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
3689 #endif
3690  mgrLocal->msmGridCutoff[index].compute(gm);
3691  }
3692 #else
3693 
3694  // broadcast charge message to section
3695  GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
3696  SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
3697  gm->put(qh, blockIndex.level, sequence); // send my level
3698  msmGridCutoffBroadcast.compute(gm);
3699 #ifdef MSM_TIMING
3700  stopTime = CkWallTimer();
3701  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
3702 #endif
3703 
3704 #endif // 0
3705 
3706 #endif // MSM_GRID_CUTOFF_DECOMP
3707 
3708 } // MsmC1HermiteBlock::gridCutoff()
int len() const
Definition: MsmMap.h:218
int k
Definition: MsmMap.h:411
const Array< T > & data() const
Definition: MsmMap.h:666
int i
Definition: MsmMap.h:411
#define MSM_PRIORITY
Definition: Priorities.h:36
CProxySection_MsmC1HermiteGridCutoff msmGridCutoffBroadcast
Definition: ComputeMsm.C:3463
int j
Definition: MsmMap.h:411
void put(const msm::Grid< T > &g, int id, int seq)
Definition: ComputeMsm.C:126
CProxy_MsmGridCutoff msmGridCutoff
Definition: ComputeMsm.C:467
Array< int > indexGridCutoff
Definition: MsmMap.h:917
#define SET_PRIORITY(MSG, SEQ, PRIO)
Definition: Priorities.h:18
void MsmC1HermiteBlock::prolongation ( )
inline

Definition at line 3526 of file ComputeMsm.C.

3526  {
3529  }
void sendDownPotential()
Definition: ComputeMsm.C:3774
void MsmC1HermiteBlock::restriction ( )
inline

Definition at line 3514 of file ComputeMsm.C.

3514  {
3516  sendUpCharge();
3517  }
void MsmC1HermiteBlock::sendDownPotential ( )

Definition at line 3774 of file ComputeMsm.C.

References ComputeMsmMgr::addPotential(), ASSERT, MsmTimer::COMM, msm::Ivec::i, msm::Grid< T >::init(), msm::Ivec::j, msm::Ivec::k, msm::BlockIndex::level, MSM_PRIORITY, msm::BlockIndex::n, msm::IndexRange::nn(), GridMsg::put(), SET_PRIORITY, ComputeMsmMgr::subgrid, and msm::Grid< T >::updateLower().

3775 {
3776 #ifdef MSM_TIMING
3777  double startTime, stopTime;
3778  startTime = CkWallTimer();
3779 #endif
3780  int lnext = blockIndex.level - 1;
3781  int priority = mgrLocal->nlevels + 2*(mgrLocal->nlevels - blockIndex.level);
3782  // buffer portions of grid to send to Blocks on next level
3783  for (int n = 0; n < bd->sendDown.len(); n++) {
3784  // initialize the proper subgrid indexing range
3785  subgrid.init( bd->sendDown[n].nrange );
3786  // extract the values from the larger grid into the subgrid
3788  // translate the subgrid indexing range to match the MSM block
3789  subgrid.updateLower( bd->sendDown[n].nrange_wrap.lower() );
3790  // add the subgrid charges into the block
3791  msm::BlockIndex& bindex = bd->sendDown[n].nblock_wrap;
3792  ASSERT(bindex.level == lnext);
3793  // place subgrid into message
3794  int msgsz = subgrid.nn() * sizeof(C1Vector);
3795  GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
3796  SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
3797  gm->put(subgrid, blockIndex.level, sequence); // send my level
3798  // lookup in ComputeMsmMgr proxy array by level
3799  mgrLocal->msmC1HermiteBlock[lnext](
3800  bindex.n.i, bindex.n.j, bindex.n.k).addPotential(gm);
3801  } // for
3802 #ifdef MSM_TIMING
3803  stopTime = CkWallTimer();
3804  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
3805  mgrLocal->doneTiming();
3806 #endif
3807  init(); // reinitialize for next computation
3808 } // MsmC1HermiteBlock::sendDownPotential()
int k
Definition: MsmMap.h:411
void addPotential(GridMsg *)
Definition: ComputeMsm.C:3748
int i
Definition: MsmMap.h:411
#define MSM_PRIORITY
Definition: Priorities.h:36
void extract(Grid< T > &g)
Definition: MsmMap.h:748
int j
Definition: MsmMap.h:411
void init(const IndexRange &n)
Definition: MsmMap.h:603
#define ASSERT(E)
int nn() const
Definition: MsmMap.h:443
void put(const msm::Grid< T > &g, int id, int seq)
Definition: ComputeMsm.C:126
void updateLower(const Ivec &n)
Definition: MsmMap.h:677
msm::Array< CProxy_MsmC1HermiteBlock > msmC1HermiteBlock
Definition: ComputeMsm.C:465
msm::Grid< C1Vector > ehProlongated
Definition: ComputeMsm.C:2748
#define SET_PRIORITY(MSG, SEQ, PRIO)
Definition: Priorities.h:18
Array< BlockSend > sendDown
Definition: MsmMap.h:921
void MsmC1HermiteBlock::sendPatch ( )

Definition at line 3811 of file ComputeMsm.C.

References ASSERT, MsmTimer::COMM, msm::Grid< T >::init(), MSM_PRIORITY, msm::IndexRange::nn(), PatchMap::node(), PatchMap::Object(), GridMsg::put(), SET_PRIORITY, ComputeMsmMgr::subgrid, and msm::Grid< T >::updateLower().

3812 {
3813 #ifdef MSM_TIMING
3814  double startTime, stopTime;
3815  startTime = CkWallTimer();
3816 #endif
3817  int lnext = blockIndex.level;
3818  int priority = mgrLocal->nlevels + 2*(mgrLocal->nlevels - blockIndex.level);
3819  ASSERT(lnext == 0);
3820  // buffer portions of grid to send to Blocks on next level
3821  for (int n = 0; n < bd->sendPatch.len(); n++) {
3822  // initialize the proper subgrid indexing range
3823  subgrid.init( bd->sendPatch[n].nrange );
3824  // extract the values from the larger grid into the subgrid
3825  eh.extract(subgrid);
3826  // translate the subgrid indexing range to match the MSM block
3827  subgrid.updateLower( bd->sendPatch[n].nrange_unwrap.lower() );
3828  // add the subgrid charges into the block, need its patch ID
3829  int pid = bd->sendPatch[n].patchID;
3830  // place subgrid into message
3831  int msgsz = subgrid.nn() * sizeof(C1Vector);
3832  GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
3833  SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
3834  gm->put(subgrid, pid, sequence); // send patch ID
3835  // lookup which PE has this patch
3836  PatchMap *pm = PatchMap::Object();
3837  int pe = pm->node(pid);
3838  mgrProxy[pe].addPotential(gm);
3839  }
3840 #ifdef MSM_TIMING
3841  stopTime = CkWallTimer();
3842  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
3843  mgrLocal->doneTiming();
3844 #endif
3845  init(); // reinitialize for next computation
3846 } // MsmC1HermiteBlock::sendPatch()
static PatchMap * Object()
Definition: PatchMap.h:27
#define MSM_PRIORITY
Definition: Priorities.h:36
void extract(Grid< T > &g)
Definition: MsmMap.h:748
void init(const IndexRange &n)
Definition: MsmMap.h:603
#define ASSERT(E)
int nn() const
Definition: MsmMap.h:443
void put(const msm::Grid< T > &g, int id, int seq)
Definition: ComputeMsm.C:126
Array< PatchSend > sendPatch
Definition: MsmMap.h:922
void updateLower(const Ivec &n)
Definition: MsmMap.h:677
int node(int pid) const
Definition: PatchMap.h:114
#define SET_PRIORITY(MSG, SEQ, PRIO)
Definition: Priorities.h:18
void MsmC1HermiteBlock::sendUpCharge ( )

Definition at line 3621 of file ComputeMsm.C.

References ASSERT, MsmTimer::COMM, msm::Ivec::i, msm::Grid< T >::init(), msm::Ivec::j, msm::Ivec::k, msm::BlockIndex::level, MSM_PRIORITY, msm::BlockIndex::n, msm::IndexRange::nn(), GridMsg::put(), SET_PRIORITY, ComputeMsmMgr::subgrid, and msm::Grid< T >::updateLower().

3622 {
3623 #ifdef MSM_TIMING
3624  double startTime, stopTime;
3625  startTime = CkWallTimer();
3626 #endif
3627  int lnext = blockIndex.level + 1;
3628  // buffer portions of grid to send to Blocks on next level
3629  for (int n = 0; n < bd->sendUp.len(); n++) {
3630  // initialize the proper subgrid indexing range
3631  subgrid.init( bd->sendUp[n].nrange );
3632  // extract the values from the larger grid into the subgrid
3634  // translate the subgrid indexing range to match the MSM block
3635  subgrid.updateLower( bd->sendUp[n].nrange_wrap.lower() );
3636  // add the subgrid charges into the block
3637  msm::BlockIndex& bindex = bd->sendUp[n].nblock_wrap;
3638  ASSERT(bindex.level == lnext);
3639  // place subgrid into message
3640  // SET MESSAGE PRIORITY
3641  int msgsz = subgrid.nn() * sizeof(C1Vector);
3642  GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
3643  SET_PRIORITY(gm, sequence, MSM_PRIORITY + lnext);
3644  gm->put(subgrid, blockIndex.level, sequence); // send my level
3645  // lookup in ComputeMsmMgr proxy array by level
3646  mgrLocal->msmC1HermiteBlock[lnext](
3647  bindex.n.i, bindex.n.j, bindex.n.k).addCharge(gm);
3648  } // for
3649 #ifdef MSM_TIMING
3650  stopTime = CkWallTimer();
3651  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
3652 #endif
3653 } // MsmC1HermiteBlock::sendUpCharge()
void addCharge(GridMsg *)
Definition: ComputeMsm.C:3597
int k
Definition: MsmMap.h:411
int i
Definition: MsmMap.h:411
#define MSM_PRIORITY
Definition: Priorities.h:36
Array< BlockSend > sendUp
Definition: MsmMap.h:915
void extract(Grid< T > &g)
Definition: MsmMap.h:748
int j
Definition: MsmMap.h:411
void init(const IndexRange &n)
Definition: MsmMap.h:603
#define ASSERT(E)
int nn() const
Definition: MsmMap.h:443
void put(const msm::Grid< T > &g, int id, int seq)
Definition: ComputeMsm.C:126
void updateLower(const Ivec &n)
Definition: MsmMap.h:677
msm::Array< CProxy_MsmC1HermiteBlock > msmC1HermiteBlock
Definition: ComputeMsm.C:465
#define SET_PRIORITY(MSG, SEQ, PRIO)
Definition: Priorities.h:18
msm::Grid< C1Vector > qhRestricted
Definition: ComputeMsm.C:2747
void MsmC1HermiteBlock::setupSections ( )

Definition at line 3535 of file ComputeMsm.C.

References MsmC1HermiteGridCutoffSetupMsg::put().

3536 {
3537 #ifdef DEBUG_MSM_GRID
3538  CkPrintf("LEVEL %d MSM C1 HERMITE BLOCK (%d,%d,%d): "
3539  "creating broadcast section on PE %d\n",
3540  blockIndex.level, thisIndex.x, thisIndex.y, thisIndex.z, CkMyPe());
3541 #endif
3542  std::vector<CkArrayIndex1D> elems;
3543  elems.reserve(bd->indexGridCutoff.len());
3544  for (int n = 0; n < bd->indexGridCutoff.len(); n++) {
3545  elems.emplace_back(bd->indexGridCutoff[n]);
3546  }
3547  msmGridCutoffBroadcast = CProxySection_MsmC1HermiteGridCutoff::ckNew(
3548  mgrLocal->msmC1HermiteGridCutoff, elems.data(), elems.size()
3549  );
3550  CProxy_CkMulticastMgr mcastProxy = CkpvAccess(BOCclass_group).multicastMgr;
3551  CkMulticastMgr *mcastPtr = CProxy_CkMulticastMgr(mcastProxy).ckLocalBranch();
3552  msmGridCutoffBroadcast.ckSectionDelegate(mcastPtr);
3553 
3554 #ifdef DEBUG_MSM_GRID
3555  char s[1024];
3556  sprintf(s, "LEVEL %d MSM C1 HERMITE BLOCK (%d,%d,%d): "
3557  "creating reduction section on PE %d\n",
3558  blockIndex.level, thisIndex.x, thisIndex.y, thisIndex.z, CkMyPe());
3559 #endif
3560  std::vector<CkArrayIndex1D> elems2;
3561  elems2.reserve(bd->recvGridCutoff.len());
3562 #ifdef DEBUG_MSM_GRID
3563  strcat(s, "receiving from MsmC1HermiteGridCutoff ID:");
3564 #endif
3565  for (int n = 0; n < bd->recvGridCutoff.len(); n++) {
3566 #ifdef DEBUG_MSM_GRID
3567  char t[20];
3568  sprintf(t, " %d", bd->recvGridCutoff[n]);
3569  strcat(s, t);
3570 #endif
3571  elems2.emplace_back(bd->recvGridCutoff[n]);
3572  }
3573 #ifdef DEBUG_MSM_GRID
3574  strcat(s, "\n");
3575  CkPrintf(s);
3576 #endif
3577  msmGridCutoffReduction = CProxySection_MsmC1HermiteGridCutoff::ckNew(
3578  mgrLocal->msmC1HermiteGridCutoff, elems2.data(), elems2.size()
3579  );
3580  msmGridCutoffReduction.ckSectionDelegate(mcastPtr);
3582  CProxyElement_MsmC1HermiteBlock thisElementProxy = thisProxy(thisIndex);
3583  msg->put(&thisElementProxy);
3584 
3585  msmGridCutoffReduction.setupSections(msg); // broadcast to entire section
3586 
3587  /* XXX alternatively, setup default reduction client
3588  *
3589  mcastPtr->setReductionClient(msmGridCutoffReduction,
3590  new CkCallback(CkIndex_MsmC1HermiteBlock::myReductionEntry(NULL),
3591  thisElementProxy));
3592  *
3593  */
3594 } // MsmC1HermiteBlock::setupSections()
Array< int > recvGridCutoff
Definition: MsmMap.h:919
int len() const
Definition: MsmMap.h:218
CProxySection_MsmC1HermiteGridCutoff msmGridCutoffBroadcast
Definition: ComputeMsm.C:3463
CProxySection_MsmC1HermiteGridCutoff msmGridCutoffReduction
Definition: ComputeMsm.C:3464
CProxy_MsmC1HermiteGridCutoff msmC1HermiteGridCutoff
Definition: ComputeMsm.C:468
Array< int > indexGridCutoff
Definition: MsmMap.h:917
void put(const CProxyElement_MsmC1HermiteBlock *q)
Definition: ComputeMsm.C:274
void MsmC1HermiteBlock::sumReducedPotential ( CkReductionMsg *  msg)
inline

Definition at line 3490 of file ComputeMsm.C.

References ComputeMsmMgr::addPotential(), msm::Array< T >::buffer(), MsmTimer::COMM, msm::Grid< T >::data(), msm::Grid< T >::init(), msm::Array< T >::len(), MSM_PRIORITY, GridMsg::put(), and SET_PRIORITY.

3490  {
3491 #ifdef MSM_TIMING
3492  double startTime, stopTime;
3493  startTime = CkWallTimer();
3494 #endif
3495  msm::Grid<C1Vector> ehfull;
3496  ehfull.init( msm::IndexRange(eh) );
3497  memcpy(ehfull.data().buffer(), msg->getData(), msg->getSize());
3498  delete msg;
3499  int priority = mgrLocal->nlevels
3500  + 2*(mgrLocal->nlevels - blockIndex.level)-1;
3501  int msgsz = ehfull.data().len() * sizeof(C1Vector);
3502  GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
3503  SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
3504  gm->put(ehfull, blockIndex.level, sequence); // send my level
3505 #ifdef MSM_TIMING
3506  stopTime = CkWallTimer();
3507  mgrLocal->msmTiming[MsmTimer::COMM] += stopTime - startTime;
3508 #endif
3509  addPotential(gm);
3510  }
int len() const
Definition: MsmMap.h:218
const Array< T > & data() const
Definition: MsmMap.h:666
void addPotential(GridMsg *)
Definition: ComputeMsm.C:3748
#define MSM_PRIORITY
Definition: Priorities.h:36
void init(const IndexRange &n)
Definition: MsmMap.h:603
void put(const msm::Grid< T > &g, int id, int seq)
Definition: ComputeMsm.C:126
#define SET_PRIORITY(MSG, SEQ, PRIO)
Definition: Priorities.h:18
const T * buffer() const
Definition: MsmMap.h:259

Member Data Documentation

CProxySection_MsmC1HermiteGridCutoff MsmC1HermiteBlock::msmGridCutoffBroadcast

Definition at line 3463 of file ComputeMsm.C.

CProxySection_MsmC1HermiteGridCutoff MsmC1HermiteBlock::msmGridCutoffReduction

Definition at line 3464 of file ComputeMsm.C.


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