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

PmeZPencil Class Reference

Inheritance diagram for PmeZPencil:

PmePencil< CBase_PmeZPencil > CBase_PmeZPencil List of all members.

Public Member Functions

PmeZPencil_SDAG_CODE PmeZPencil ()
 PmeZPencil (CkMigrateMessage *)
void fft_init ()
void recv_grid (const PmeGridMsg *)
void forward_fft ()
void send_trans ()
void recv_untrans (const PmeUntransMsg *)
void backward_fft ()
void send_ungrid (PmeGridMsg *)

Constructor & Destructor Documentation

PmeZPencil_SDAG_CODE PmeZPencil::PmeZPencil  )  [inline]
 

Definition at line 2420 of file ComputePme.C.

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

PmeZPencil::PmeZPencil CkMigrateMessage *   )  [inline]
 

Definition at line 2421 of file ComputePme.C.

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


Member Function Documentation

void PmeZPencil::backward_fft  ) 
 

Definition at line 2983 of file ComputePme.C.

References PmeGrid::dim3, PmePencilInitMsgData::grid, j, PmeGrid::K1, PmeGrid::K2, and PmeGrid::K3.

02983                               {
02984 #ifdef NAMD_FFTW
02985   rfftwnd_complex_to_real(backward_plan, nx*ny,
02986             (fftw_complex *) data, 1, initdata.grid.dim3/2, work, 1, 0);
02987 #endif
02988   
02989 #if CMK_BLUEGENEL
02990   CmiNetworkProgress();
02991 #endif
02992 
02993 #ifdef FFTCHECK
02994   int dim3 = initdata.grid.dim3;
02995   int K1 = initdata.grid.K1;
02996   int K2 = initdata.grid.K2;
02997   int K3 = initdata.grid.K3;
02998   float scale = 1. / (1. * K1 * K2 * K3);
02999   float maxerr = 0.;
03000   float maxstd = 0.;
03001   int mi, mj, mk;  mi = mj = mk = -1;
03002   float std_base = 100. * (thisIndex.x+1.) + 10. * (thisIndex.y+1.);
03003   const float *d = data;
03004   for ( int i=0; i<nx; ++i ) {
03005    for ( int j=0; j<ny; ++j, d += dim3 ) {
03006     for ( int k=0; k<K3; ++k ) {
03007       float std = 10. * (10. * (10. * std_base + i) + j) + k;
03008       float err = scale * d[k] - std;
03009       if ( fabsf(err) > fabsf(maxerr) ) {
03010         maxerr = err;
03011         maxstd = std;
03012         mi = i;  mj = j;  mk = k;
03013       }
03014     }
03015    }
03016   }
03017   CkPrintf("pencil %d %d max error %f at %d %d %d (should be %f)\n",
03018                 thisIndex.x, thisIndex.y, maxerr, mi, mj, mk, maxstd);
03019 #endif
03020 }

void PmeZPencil::fft_init  ) 
 

Definition at line 2474 of file ComputePme.C.

References PmeGrid::block1, PmeGrid::block2, PmeGrid::dim3, SimParameters::FFTWEstimate, PmePencilInitMsgData::grid, PmeGrid::K1, PmeGrid::K2, PmeGrid::K3, NAMD_die(), PmePencil< CBase_PmeZPencil >::order_init(), Node::simParameters, simParams, and PmePencilInitMsgData::zBlocks.

02474                           {
02475   CProxy_Node nd(CkpvAccess(BOCclass_group).node);
02476   Node *node = nd.ckLocalBranch();
02477   SimParameters *simParams = node->simParameters;
02478 
02479   int K1 = initdata.grid.K1;
02480   int K2 = initdata.grid.K2;
02481   int K3 = initdata.grid.K3;
02482   int dim3 = initdata.grid.dim3;
02483   int block1 = initdata.grid.block1;
02484   int block2 = initdata.grid.block2;
02485 
02486   nx = block1;
02487   if ( (thisIndex.x + 1) * block1 > K1 ) nx = K1 - thisIndex.x * block1;
02488   ny = block2;
02489   if ( (thisIndex.y + 1) * block2 > K2 ) ny = K2 - thisIndex.y * block2;
02490 
02491   data = new float[nx*ny*dim3];
02492   work = new float[dim3];
02493 
02494   order_init(initdata.zBlocks);
02495 
02496 #ifdef NAMD_FFTW
02497   CmiLock(ComputePmeMgr::fftw_plan_lock);
02498 
02499   forward_plan = rfftwnd_create_plan_specific(1, &K3, FFTW_REAL_TO_COMPLEX,
02500         ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
02501         | FFTW_IN_PLACE | FFTW_USE_WISDOM, data, 1, work, 1);
02502   backward_plan = rfftwnd_create_plan_specific(1, &K3, FFTW_COMPLEX_TO_REAL,
02503         ( simParams->FFTWEstimate ? FFTW_ESTIMATE : FFTW_MEASURE )
02504         | FFTW_IN_PLACE | FFTW_USE_WISDOM, data, 1, work, 1);
02505 
02506   CmiUnlock(ComputePmeMgr::fftw_plan_lock);
02507 #else
02508   NAMD_die("Sorry, FFTW must be compiled in to use PME.");
02509 #endif
02510 }

void PmeZPencil::forward_fft  ) 
 

Definition at line 2628 of file ComputePme.C.

References PmeGrid::dim3, PmePencilInitMsgData::grid, j, and PmeGrid::K3.

02628                              {
02629 #ifdef FFTCHECK
02630   int dim3 = initdata.grid.dim3;
02631   int K3 = initdata.grid.K3;
02632   float std_base = 100. * (thisIndex.x+1.) + 10. * (thisIndex.y+1.);
02633   float *d = data;
02634   for ( int i=0; i<nx; ++i ) {
02635    for ( int j=0; j<ny; ++j, d += dim3 ) {
02636     for ( int k=0; k<dim3; ++k ) {
02637       d[k] = 10. * (10. * (10. * std_base + i) + j) + k;
02638     }
02639    }
02640   }
02641 #endif
02642 #ifdef NAMD_FFTW
02643   rfftwnd_real_to_complex(forward_plan, nx*ny,
02644         data, 1, initdata.grid.dim3, (fftw_complex *) work, 1, 0);
02645 #endif
02646 #ifdef ZEROCHECK
02647   int dim3 = initdata.grid.dim3;
02648   int K3 = initdata.grid.K3;
02649   float *d = data;
02650   for ( int i=0; i<nx; ++i ) {
02651    for ( int j=0; j<ny; ++j, d += dim3 ) {
02652     for ( int k=0; k<dim3; ++k ) {
02653       if ( d[k] == 0. ) CkPrintf("0 in Z at %d %d %d %d %d %d %d %d %d\n",
02654         thisIndex.x, thisIndex.y, i, j, k, nx, ny, dim3);
02655     }
02656    }
02657   }
02658 #endif
02659 }

void PmeZPencil::recv_grid const PmeGridMsg  ) 
 

Definition at line 2598 of file ComputePme.C.

References PmeGrid::dim3, PmeGridMsg::fgrid, PmePencilInitMsgData::grid, PmeGridMsg::hasData, j, PmeGridMsg::lattice, PmeGridMsg::qgrid, PmeGridMsg::sequence, PmeGridMsg::zlist, and PmeGridMsg::zlistlen.

02598                                                 {
02599 
02600   int dim3 = initdata.grid.dim3;
02601   if ( imsg == 0 ) {
02602     lattice = msg->lattice;
02603     sequence = msg->sequence;
02604     memset(data, 0, sizeof(float) * nx*ny*dim3);
02605   }
02606 
02607   if ( ! msg->hasData ) return;
02608 
02609   int zlistlen = msg->zlistlen;
02610   int *zlist = msg->zlist;
02611   char *fmsg = msg->fgrid;
02612   float *qmsg = msg->qgrid;
02613   float *d = data;
02614   int numGrids = 1;  // pencil FFT doesn't support multiple grids
02615   for ( int g=0; g<numGrids; ++g ) {
02616     for ( int i=0; i<nx; ++i ) {
02617      for ( int j=0; j<ny; ++j, d += dim3 ) {
02618       if( *(fmsg++) ) {
02619         for ( int k=0; k<zlistlen; ++k ) {
02620           d[zlist[k]] += *(qmsg++);
02621         }
02622       }
02623      }
02624     }
02625   }
02626 }

void PmeZPencil::recv_untrans const PmeUntransMsg  ) 
 

Definition at line 2957 of file ComputePme.C.

References PmeGrid::block3, PmeGrid::dim3, PmeUntransMsg::evir, PmePencilInitMsgData::grid, PmeUntransMsg::has_evir, j, PmeUntransMsg::ny, PmeUntransMsg::qgrid, and PmeUntransMsg::sourceNode.

02957                                                       {
02958   if ( imsg == 0 ) evir = 0.;
02959   if ( msg->has_evir ) evir += msg->evir[0];
02960   int block3 = initdata.grid.block3;
02961   int dim3 = initdata.grid.dim3;
02962   int kb = msg->sourceNode;
02963   int nz = msg->ny;
02964   const float *md = msg->qgrid;
02965   float *d = data;
02966   for ( int i=0; i<nx; ++i ) {
02967 #if CMK_BLUEGENEL
02968     CmiNetworkProgress();
02969 #endif   
02970     for ( int j=0; j<ny; ++j, d += dim3 ) {
02971       for ( int k=kb*block3; k<(kb*block3+nz); ++k ) {
02972 #ifdef ZEROCHECK
02973         if ( (*md) == 0. ) CkPrintf("0 in YZ at %d %d %d %d %d %d %d %d %d\n",
02974                                     thisIndex.x, thisIndex.y, kb, i, j, k, nx, ny, nz);
02975 #endif
02976         d[2*k] = *(md++);
02977         d[2*k+1] = *(md++);
02978       }
02979     }
02980   }
02981 }

void PmeZPencil::send_trans  ) 
 

Definition at line 2661 of file ComputePme.C.

References PmeGrid::block3, PmeGrid::dim3, PmePencilInitMsgData::grid, PmeTransMsg::hasData, j, PmeTransMsg::lattice, PmeTransMsg::nx, PME_TRANS_PRIORITY, PmeTransMsg::qgrid, PmeTransMsg::sequence, SET_PRIORITY, PmeTransMsg::sourceNode, PmePencilInitMsgData::yPencil, and PmePencilInitMsgData::zBlocks.

02661                             {
02662   int zBlocks = initdata.zBlocks;
02663   int block3 = initdata.grid.block3;
02664   int dim3 = initdata.grid.dim3;
02665   for ( int isend=0; isend<zBlocks; ++isend ) {
02666     int kb = send_order[isend];
02667     int nz = block3;
02668     if ( (kb+1)*block3 > dim3/2 ) nz = dim3/2 - kb*block3;
02669     int hd = ( hasData ? 1 : 0 );
02670     PmeTransMsg *msg = new (hd*nx*ny*nz*2,PRIORITY_SIZE) PmeTransMsg;
02671     msg->lattice = lattice;
02672     msg->sourceNode = thisIndex.y;
02673     msg->hasData = hasData;
02674     msg->nx = ny;
02675    if ( hasData ) {
02676     float *md = msg->qgrid;
02677     const float *d = data;
02678     for ( int i=0; i<nx; ++i ) {
02679      for ( int j=0; j<ny; ++j, d += dim3 ) {
02680       for ( int k=kb*block3; k<(kb*block3+nz); ++k ) {
02681         *(md++) = d[2*k];
02682         *(md++) = d[2*k+1];
02683       }
02684      }
02685     }
02686    }
02687     msg->sequence = sequence;
02688     SET_PRIORITY(msg,sequence,PME_TRANS_PRIORITY)
02689     initdata.yPencil(thisIndex.x,0,kb).recvTrans(msg);
02690   }
02691 }

void PmeZPencil::send_ungrid PmeGridMsg  ) 
 

Definition at line 3022 of file ComputePme.C.

References PmeGrid::dim3, PmeGridMsg::fgrid, PmePencilInitMsgData::grid, j, PME_UNGRID_PRIORITY, PmePencilInitMsgData::pmeProxy, PmeGridMsg::qgrid, SET_PRIORITY, PmeGridMsg::sourceNode, PmePencilInitMsgData::yBlocks, PmeGridMsg::zlist, and PmeGridMsg::zlistlen.

03022                                             {
03023   int pe = msg->sourceNode;
03024   msg->sourceNode = thisIndex.x * initdata.yBlocks + thisIndex.y;
03025   int dim3 = initdata.grid.dim3;
03026   int zlistlen = msg->zlistlen;
03027   int *zlist = msg->zlist;
03028   char *fmsg = msg->fgrid;
03029   float *qmsg = msg->qgrid;
03030   float *d = data;
03031   int numGrids = 1;  // pencil FFT doesn't support multiple grids
03032   for ( int g=0; g<numGrids; ++g ) {
03033 #if CMK_BLUEGENEL
03034     CmiNetworkProgress();
03035 #endif    
03036     for ( int i=0; i<nx; ++i ) {
03037       for ( int j=0; j<ny; ++j, d += dim3 ) {
03038         if( *(fmsg++) ) {
03039           for ( int k=0; k<zlistlen; ++k ) {
03040             *(qmsg++) = d[zlist[k]];
03041           }
03042         }
03043       }
03044     }
03045   }
03046 
03047   SET_PRIORITY(msg,sequence,PME_UNGRID_PRIORITY)
03048   initdata.pmeProxy[pe].recvUngrid(msg);
03049 }


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