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 2416 of file ComputePme.C.

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

PmeYPencil::PmeYPencil (  CkMigrateMessage *   )  [inline]
 

Definition at line 2417 of file ComputePme.C.

02417 { __sdag_init(); }

Member Function Documentation

void PmeYPencil::backward_fft (   ) 
 

Definition at line 2884 of file ComputePme.C.

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

02884                               {
02885 #ifdef NAMD_FFTW
02886   for ( int i=0; i<nx; ++i ) {
02887 #if CMK_VERSION_BLUEGENE
02888     CmiNetworkProgress();
02889 #endif
02890 
02891     fftw(backward_plan, nz,
02892         ((fftw_complex *) data) + i * nz * initdata.grid.K2,
02893         nz, 1, (fftw_complex *) work, 1, 0);
02894   }
02895 #endif
02896 }

void PmeYPencil::fft_init (   ) 
 

Definition at line 2488 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.

02488                           {
02489   CProxy_Node nd(CpvAccess(BOCclass_group).node);
02490   Node *node = nd.ckLocalBranch();
02491   SimParameters *simParams = node->simParameters;
02492 
02493   int K1 = initdata.grid.K1;
02494   int K2 = initdata.grid.K2;
02495   int dim2 = initdata.grid.dim2;
02496   int dim3 = initdata.grid.dim3;
02497   int block1 = initdata.grid.block1;
02498   int block3 = initdata.grid.block3;
02499 
02500   nx = block1;
02501   if ( (thisIndex.x + 1) * block1 > K1 ) nx = K1 - thisIndex.x * block1;
02502   nz = block3;
02503   if ( (thisIndex.z+1)*block3 > dim3/2 ) nz = dim3/2 - thisIndex.z*block3;
02504 
02505   data = new float[nx*dim2*nz*2];
02506   work = new float[2*K2];
02507 
02508   order_init(initdata.yBlocks);
02509 
02510 #ifdef NAMD_FFTW
02511   CmiLock(ComputePmeMgr::fftw_plan_lock);
02512 
02513   forward_plan = fftw_create_plan_specific(K2, FFTW_FORWARD,
02514         ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
02515         | FFTW_IN_PLACE | FFTW_USE_WISDOM, (fftw_complex *) data,
02516         nz, (fftw_complex *) work, 1);
02517   backward_plan = fftw_create_plan_specific(K2, FFTW_BACKWARD,
02518         ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
02519         | FFTW_IN_PLACE | FFTW_USE_WISDOM, (fftw_complex *) data,
02520         nz, (fftw_complex *) work, 1);
02521 
02522   CmiUnlock(ComputePmeMgr::fftw_plan_lock);
02523 #else
02524   NAMD_die("Sorry, FFTW must be compiled in to use PME.");
02525 #endif
02526 }

void PmeYPencil::forward_fft (   ) 
 

Definition at line 2706 of file ComputePme.C.

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

02706                              {
02707 #ifdef NAMD_FFTW
02708   for ( int i=0; i<nx; ++i ) {
02709     fftw(forward_plan, nz,
02710         ((fftw_complex *) data) + i * nz * initdata.grid.K2,
02711         nz, 1, (fftw_complex *) work, 1, 0);
02712   }
02713 #endif
02714 }

void PmeYPencil::recv_trans (  const PmeTransMsg *   ) 
 

Definition at line 2669 of file ComputePme.C.

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

02669                                                   {
02670   if ( imsg == 0 ) {
02671     lattice = msg->lattice;
02672     sequence = msg->sequence;
02673   }
02674   int block2 = initdata.grid.block2;
02675   int K2 = initdata.grid.K2;
02676   int jb = msg->sourceNode;
02677   int ny = msg->nx;
02678  if ( msg->hasData ) {
02679   const float *md = msg->qgrid;
02680   float *d = data;
02681   for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02682    for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02683     for ( int k=0; k<nz; ++k ) {
02684 #ifdef ZEROCHECK
02685       if ( (*md) == 0. ) CkPrintf("0 in ZY at %d %d %d %d %d %d %d %d %d\n",
02686         thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
02687 #endif
02688       d[2*(j*nz+k)] = *(md++);
02689       d[2*(j*nz+k)+1] = *(md++);
02690     }
02691    }
02692   }
02693  } else {
02694   float *d = data;
02695   for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02696    for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02697     for ( int k=0; k<nz; ++k ) {
02698       d[2*(j*nz+k)] = 0;
02699       d[2*(j*nz+k)+1] = 0;
02700     }
02701    }
02702   }
02703  }
02704 }

void PmeYPencil::recv_untrans (  const PmeUntransMsg *   ) 
 

Definition at line 2858 of file ComputePme.C.

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

02858                                                       {
02859   if ( imsg == 0 ) evir = 0.;
02860   if ( msg->has_evir ) evir += msg->evir[0];
02861   int block2 = initdata.grid.block2;
02862   int K2 = initdata.grid.K2;
02863   int jb = msg->sourceNode;
02864   int ny = msg->ny;
02865   const float *md = msg->qgrid;
02866   float *d = data;
02867   for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02868 #if CMK_VERSION_BLUEGENE
02869     CmiNetworkProgress();
02870 #endif   
02871     for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02872       for ( int k=0; k<nz; ++k ) {
02873 #ifdef ZEROCHECK
02874         if ( (*md) == 0. ) CkPrintf("0 in XY at %d %d %d %d %d %d %d %d %d\n",
02875                                     thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
02876 #endif
02877         d[2*(j*nz+k)] = *(md++);
02878         d[2*(j*nz+k)+1] = *(md++);
02879       }
02880     }
02881   }
02882 }

void PmeYPencil::send_trans (   ) 
 

Definition at line 2716 of file ComputePme.C.

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

02716                             {
02717   int yBlocks = initdata.yBlocks;
02718   int block2 = initdata.grid.block2;
02719   int K2 = initdata.grid.K2;
02720   for ( int isend=0; isend<yBlocks; ++isend ) {
02721     int jb = send_order[isend];
02722     int ny = block2;
02723     if ( (jb+1)*block2 > K2 ) ny = K2 - jb*block2;
02724     int hd = ( hasData ? 1 : 0 );
02725     PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
02726     msg->lattice = lattice;
02727     msg->sourceNode = thisIndex.x;
02728     msg->hasData = hasData;
02729     msg->nx = nx;
02730    if ( hasData ) {
02731     float *md = msg->qgrid;
02732     const float *d = data;
02733     for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02734      for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02735       for ( int k=0; k<nz; ++k ) {
02736         *(md++) = d[2*(j*nz+k)];
02737         *(md++) = d[2*(j*nz+k)+1];
02738 #ifdef ZEROCHECK
02739         if ( *(md-2) == 0. ) CkPrintf("send 0 in YX at %d %d %d %d %d %d %d %d %d\n",
02740         thisIndex.x, jb, thisIndex.z, i, j, k, nx, ny, nz);
02741 #endif
02742       }
02743      }
02744     }
02745     if ( md != msg->qgrid + nx*ny*nz*2 ) CkPrintf("error in YX at %d %d %d\n",
02746         thisIndex.x, jb, thisIndex.z);
02747    }
02748     msg->sequence = sequence;
02749     SET_PRIORITY(msg,sequence,PME_TRANS2_PRIORITY)
02750     initdata.xPencil(0,jb,thisIndex.z).recvTrans(msg);
02751   }
02752 }

void PmeYPencil::send_untrans (   ) 
 

Definition at line 2898 of file ComputePme.C.

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

02898                               {
02899   int yBlocks = initdata.yBlocks;
02900   int block2 = initdata.grid.block2;
02901   int K2 = initdata.grid.K2;
02902   int send_evir = 1;
02903   for ( int isend=0; isend<yBlocks; ++isend ) {
02904     int jb = send_order[isend];
02905     if ( ! needs_reply[jb] ) continue;
02906     int ny = block2;
02907     if ( (jb+1)*block2 > K2 ) ny = K2 - jb*block2;
02908     PmeUntransMsg *msg = new (nx*ny*nz*2,send_evir,PRIORITY_SIZE) PmeUntransMsg;
02909     if ( send_evir ) {
02910       msg->evir[0] = evir;
02911       msg->has_evir = 1;
02912       send_evir = 0;
02913     } else {
02914       msg->has_evir = 0;
02915     }
02916     msg->sourceNode = thisIndex.z;
02917     msg->ny = nz;
02918     float *md = msg->qgrid;
02919     const float *d = data;
02920     for ( int i=0; i<nx; ++i, d += K2*nz*2 ) {
02921      for ( int j=jb*block2; j<(jb*block2+ny); ++j ) {
02922       for ( int k=0; k<nz; ++k ) {
02923         *(md++) = d[2*(j*nz+k)];
02924         *(md++) = d[2*(j*nz+k)+1];
02925       }
02926      }
02927     }
02928     SET_PRIORITY(msg,sequence,PME_UNTRANS2_PRIORITY)
02929     initdata.zPencil(thisIndex.x,jb,0).recvUntrans(msg);
02930   }
02931 }

The documentation for this class was generated from the following file:
Generated on Sun Jul 6 04:07:48 2008 for NAMD by  doxygen 1.3.9.1