Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

PmeYPencil Class Reference

Inheritance diagram for PmeYPencil:

PmePencil< CBase_PmeYPencil > CBase_PmeYPencil List of all members.

Public Member Functions

PmeYPencil_SDAG_CODE PmeYPencil ()
 PmeYPencil (CkMigrateMessage *)
void fft_init ()
void recv_trans (const PmeTransMsg *)
void forward_fft ()
void send_trans ()
void recv_untrans (const PmeUntransMsg *)
void backward_fft ()
void send_untrans ()

Constructor & Destructor Documentation

PmeYPencil_SDAG_CODE PmeYPencil::PmeYPencil (   )  [inline]
 

Definition at line 2440 of file ComputePme.C.

02440 { __sdag_init(); setMigratable(false); }

PmeYPencil::PmeYPencil (  CkMigrateMessage *   )  [inline]
 

Definition at line 2441 of file ComputePme.C.

02441 { __sdag_init(); }

Member Function Documentation

void PmeYPencil::backward_fft (   ) 
 

Definition at line 2908 of file ComputePme.C.

References PmePencilInitMsgData::grid, and PmeGrid::K2.

02908                               {
02909 #ifdef NAMD_FFTW
02910   for ( int i=0; i<nx; ++i ) {
02911 #if CMK_BLUEGENEL
02912     CmiNetworkProgress();
02913 #endif
02914 
02915     fftw(backward_plan, nz,
02916         ((fftw_complex *) data) + i * nz * initdata.grid.K2,
02917         nz, 1, (fftw_complex *) work, 1, 0);
02918   }
02919 #endif
02920 }

void PmeYPencil::fft_init (   ) 
 

Definition at line 2512 of file ComputePme.C.

References PmeGrid::block1, PmeGrid::block3, PmeGrid::dim2, PmeGrid::dim3, SimParameters::FFTWEstimate, PmePencilInitMsgData::grid, PmeGrid::K1, PmeGrid::K2, NAMD_die(), PmePencil< CBase_PmeYPencil >::order_init(), Node::simParameters, simParams, and PmePencilInitMsgData::yBlocks.

02512                           {
02513   CProxy_Node nd(CkpvAccess(BOCclass_group).node);
02514   Node *node = nd.ckLocalBranch();
02515   SimParameters *simParams = node->simParameters;
02516 
02517   int K1 = initdata.grid.K1;
02518   int K2 = initdata.grid.K2;
02519   int dim2 = initdata.grid.dim2;
02520   int dim3 = initdata.grid.dim3;
02521   int block1 = initdata.grid.block1;
02522   int block3 = initdata.grid.block3;
02523 
02524   nx = block1;
02525   if ( (thisIndex.x + 1) * block1 > K1 ) nx = K1 - thisIndex.x * block1;
02526   nz = block3;
02527   if ( (thisIndex.z+1)*block3 > dim3/2 ) nz = dim3/2 - thisIndex.z*block3;
02528 
02529   data = new float[nx*dim2*nz*2];
02530   work = new float[2*K2];
02531 
02532   order_init(initdata.yBlocks);
02533 
02534 #ifdef NAMD_FFTW
02535   CmiLock(ComputePmeMgr::fftw_plan_lock);
02536 
02537   forward_plan = fftw_create_plan_specific(K2, FFTW_FORWARD,
02538         ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
02539         | FFTW_IN_PLACE | FFTW_USE_WISDOM, (fftw_complex *) data,
02540         nz, (fftw_complex *) work, 1);
02541   backward_plan = fftw_create_plan_specific(K2, FFTW_BACKWARD,
02542         ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
02543         | FFTW_IN_PLACE | FFTW_USE_WISDOM, (fftw_complex *) data,
02544         nz, (fftw_complex *) work, 1);
02545 
02546   CmiUnlock(ComputePmeMgr::fftw_plan_lock);
02547 #else
02548   NAMD_die("Sorry, FFTW must be compiled in to use PME.");
02549 #endif
02550 }

void PmeYPencil::forward_fft (   ) 
 

Definition at line 2730 of file ComputePme.C.

References PmePencilInitMsgData::grid, and PmeGrid::K2.

02730                              {
02731 #ifdef NAMD_FFTW
02732   for ( int i=0; i<nx; ++i ) {
02733     fftw(forward_plan, nz,
02734         ((fftw_complex *) data) + i * nz * initdata.grid.K2,
02735         nz, 1, (fftw_complex *) work, 1, 0);
02736   }
02737 #endif
02738 }

void PmeYPencil::recv_trans (  const PmeTransMsg *   ) 
 

Definition at line 2693 of file ComputePme.C.

References PmeGrid::block2, PmePencilInitMsgData::grid, PmeTransMsg::hasData, j, PmeGrid::K2, PmeTransMsg::lattice, PmeTransMsg::nx, PmeTransMsg::qgrid, PmeTransMsg::sequence, and PmeTransMsg::sourceNode.

02693                                                   {
02694   if ( imsg == 0 ) {
02695     lattice = msg->lattice;
02696     sequence = msg->sequence;
02697   }
02698   int block2 = initdata.grid.block2;
02699   int K2 = initdata.grid.K2;
02700   int jb = msg->sourceNode;
02701   int ny = msg->nx;
02702  if ( msg->hasData ) {
02703   const float *md = msg->qgrid;
02704   float *d = data;
02705   for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02706    for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02707     for ( int k=0; k<nz; ++k ) {
02708 #ifdef ZEROCHECK
02709       if ( (*md) == 0. ) CkPrintf("0 in ZY at %d %d %d %d %d %d %d %d %d\n",
02710         thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
02711 #endif
02712       d[2*(j*nz+k)] = *(md++);
02713       d[2*(j*nz+k)+1] = *(md++);
02714     }
02715    }
02716   }
02717  } else {
02718   float *d = data;
02719   for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02720    for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02721     for ( int k=0; k<nz; ++k ) {
02722       d[2*(j*nz+k)] = 0;
02723       d[2*(j*nz+k)+1] = 0;
02724     }
02725    }
02726   }
02727  }
02728 }

void PmeYPencil::recv_untrans (  const PmeUntransMsg *   ) 
 

Definition at line 2882 of file ComputePme.C.

References PmeGrid::block2, PmeUntransMsg::evir, PmePencilInitMsgData::grid, PmeUntransMsg::has_evir, j, PmeGrid::K2, PmeUntransMsg::ny, PmeUntransMsg::qgrid, and PmeUntransMsg::sourceNode.

02882                                                       {
02883   if ( imsg == 0 ) evir = 0.;
02884   if ( msg->has_evir ) evir += msg->evir[0];
02885   int block2 = initdata.grid.block2;
02886   int K2 = initdata.grid.K2;
02887   int jb = msg->sourceNode;
02888   int ny = msg->ny;
02889   const float *md = msg->qgrid;
02890   float *d = data;
02891   for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02892 #if CMK_BLUEGENEL
02893     CmiNetworkProgress();
02894 #endif   
02895     for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02896       for ( int k=0; k<nz; ++k ) {
02897 #ifdef ZEROCHECK
02898         if ( (*md) == 0. ) CkPrintf("0 in XY at %d %d %d %d %d %d %d %d %d\n",
02899                                     thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
02900 #endif
02901         d[2*(j*nz+k)] = *(md++);
02902         d[2*(j*nz+k)+1] = *(md++);
02903       }
02904     }
02905   }
02906 }

void PmeYPencil::send_trans (   ) 
 

Definition at line 2740 of file ComputePme.C.

References PmeGrid::block2, PmePencilInitMsgData::grid, PmeTransMsg::hasData, j, PmeGrid::K2, PmeTransMsg::lattice, PmeTransMsg::nx, PME_TRANS2_PRIORITY, PmeTransMsg::qgrid, PmeTransMsg::sequence, SET_PRIORITY, PmeTransMsg::sourceNode, PmePencilInitMsgData::xPencil, and PmePencilInitMsgData::yBlocks.

02740                             {
02741   int yBlocks = initdata.yBlocks;
02742   int block2 = initdata.grid.block2;
02743   int K2 = initdata.grid.K2;
02744   for ( int isend=0; isend<yBlocks; ++isend ) {
02745     int jb = send_order[isend];
02746     int ny = block2;
02747     if ( (jb+1)*block2 > K2 ) ny = K2 - jb*block2;
02748     int hd = ( hasData ? 1 : 0 );
02749     PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
02750     msg->lattice = lattice;
02751     msg->sourceNode = thisIndex.x;
02752     msg->hasData = hasData;
02753     msg->nx = nx;
02754    if ( hasData ) {
02755     float *md = msg->qgrid;
02756     const float *d = data;
02757     for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02758      for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02759       for ( int k=0; k<nz; ++k ) {
02760         *(md++) = d[2*(j*nz+k)];
02761         *(md++) = d[2*(j*nz+k)+1];
02762 #ifdef ZEROCHECK
02763         if ( *(md-2) == 0. ) CkPrintf("send 0 in YX at %d %d %d %d %d %d %d %d %d\n",
02764         thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
02765 #endif
02766       }
02767      }
02768     }
02769     if ( md != msg->qgrid + nx*ny*nz*2 ) CkPrintf("error in YX at %d %d %d\n",
02770         thisIndex.x, jb, thisIndex.z);
02771    }
02772     msg->sequence = sequence;
02773     SET_PRIORITY(msg,sequence,PME_TRANS2_PRIORITY)
02774     initdata.xPencil(0,jb,thisIndex.z).recvTrans(msg);
02775   }
02776 }

void PmeYPencil::send_untrans (   ) 
 

Definition at line 2922 of file ComputePme.C.

References PmeGrid::block2, PmeUntransMsg::evir, PmePencilInitMsgData::grid, PmeUntransMsg::has_evir, j, PmeGrid::K2, PmeUntransMsg::ny, PME_UNTRANS2_PRIORITY, PmeUntransMsg::qgrid, SET_PRIORITY, PmeUntransMsg::sourceNode, PmePencilInitMsgData::yBlocks, and PmePencilInitMsgData::zPencil.

02922                               {
02923   int yBlocks = initdata.yBlocks;
02924   int block2 = initdata.grid.block2;
02925   int K2 = initdata.grid.K2;
02926   int send_evir = 1;
02927   for ( int isend=0; isend<yBlocks; ++isend ) {
02928     int jb = send_order[isend];
02929     if ( ! needs_reply[jb] ) continue;
02930     int ny = block2;
02931     if ( (jb+1)*block2 > K2 ) ny = K2 - jb*block2;
02932     PmeUntransMsg *msg = new (nx*ny*nz*2,send_evir,PRIORITY_SIZE) PmeUntransMsg;
02933     if ( send_evir ) {
02934       msg->evir[0] = evir;
02935       msg->has_evir = 1;
02936       send_evir = 0;
02937     } else {
02938       msg->has_evir = 0;
02939     }
02940     msg->sourceNode = thisIndex.z;
02941     msg->ny = nz;
02942     float *md = msg->qgrid;
02943     const float *d = data;
02944     for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02945      for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02946       for ( int k=0; k<nz; ++k ) {
02947         *(md++) = d[2*(j*nz+k)];
02948         *(md++) = d[2*(j*nz+k)+1];
02949       }
02950      }
02951     }
02952     SET_PRIORITY(msg,sequence,PME_UNTRANS2_PRIORITY)
02953     initdata.zPencil(thisIndex.x,jb,0).recvUntrans(msg);
02954   }
02955 }

The documentation for this class was generated from the following file:
Generated on Mon Nov 23 05:00:07 2009 for NAMD by  doxygen 1.3.9.1