GridforceLiteGrid Class Reference

#include <GridForceGrid.h>

Inheritance diagram for GridforceLiteGrid:

GridforceGrid List of all members.

Public Member Functions

 GridforceLiteGrid (int gridnum)
virtual ~GridforceLiteGrid ()
void initialize (char *potfilename, SimParameters *simParams, MGridforceParams *mgridParams)
void reinitialize (SimParameters *simParams, MGridforceParams *mgridParams)
Position get_center (void) const
Position get_origin (void) const
Tensor get_e (void) const
Tensor get_inv (void) const
Vector get_scale (void) const
Bool get_checksize (void) const
int get_k0 (void) const
int get_k1 (void) const
int get_k2 (void) const
int get_total_grids (void) const
void set_scale (Vector s)
float get_grid (int i0, int i1, int i2, int i3) const
double get_grid_d (int i0, int i1, int i2, int i3) const
void set_grid (int i0, int i1, int i2, int i3, float V)
long int get_all_gridvals (float **all_gridvals) const
void set_all_gridvals (float *all_gridvals, long int sz)
int compute_VdV (Position pos, float &V, Vector &dV) const

Protected Member Functions

void compute_derivative_grids (void)
void compute_wts (float *wts, const Vector &dg) const
int get_inds (Position pos, int *inds, Vector &dg) const
float linear_interpolate (int i0, int i1, int i2, int i3, const float *wts) const
void pack (MOStream *msg) const
void unpack (MIStream *msg)
long int grid_index (int i0, int i1, int i2, int i3) const

Protected Attributes

float * grid
int k [4]
long int size
long int dk [4]
Position origin
Position center
Tensor e
Tensor inv
Vector scale
Bool checksize
char filename [129]

Detailed Description

Definition at line 287 of file GridForceGrid.h.


Constructor & Destructor Documentation

GridforceLiteGrid::GridforceLiteGrid ( int  gridnum  )  [explicit]

Definition at line 1305 of file GridForceGrid.C.

References grid, GridforceGrid::GridforceGridTypeLite, GridforceGrid::mygridnum, and GridforceGrid::type.

01306 {
01307     mygridnum = gridnum;
01308     grid = NULL;
01309     type = GridforceGridTypeLite;
01310 }

GridforceLiteGrid::~GridforceLiteGrid (  )  [virtual]

Definition at line 1313 of file GridForceGrid.C.

References grid.

01314 {
01315     delete[] grid;
01316 }


Member Function Documentation

void GridforceLiteGrid::compute_derivative_grids ( void   )  [protected]

Definition at line 1369 of file GridForceGrid.C.

References DebugM, endi(), get_grid(), get_grid_d(), and set_grid().

Referenced by initialize().

01370 {
01371     // calculate derivative grids
01372     // separate loop so all V values have been set already
01373     for (int i0 = 0; i0 < k[0]; i0++) {
01374         for (int i1 = 0; i1 < k[1]; i1++) {
01375             for (int i2 = 0; i2 < k[2]; i2++) {
01376                 float dx, dy, dz;
01377                 if (i0 == 0 || i0 == k[0]-1 || i1 == 0 || i1 == k[1]-1 || i2 == 0 || i2 == k[2]-1) {
01378                     // on edge, set ALL derivatives to zero (make up for lack of padding)
01379                     dx = 0;
01380                     dy = 0;
01381                     dz = 0;
01382                 } else {
01383                     dx = 0.5 * (get_grid_d(i0+1,i1,i2,0) - get_grid_d(i0-1,i1,i2,0));
01384                     dy = 0.5 * (get_grid_d(i0,i1+1,i2,0) - get_grid_d(i0,i1-1,i2,0));
01385                     dz = 0.5 * (get_grid_d(i0,i1,i2+1,0) - get_grid_d(i0,i1,i2-1,0));
01386                 }
01387                 set_grid(i0, i1, i2, 1, dx);
01388                 set_grid(i0, i1, i2, 2, dy);
01389                 set_grid(i0, i1, i2, 3, dz);
01390                 DebugM(1, "dx[" << i0 << "," << i1 << "," << i2 << "] = " << get_grid(i0, i1, i2, 1) << "(" << dx << ")\n" << endi);
01391                 DebugM(1, "dy[" << i0 << "," << i1 << "," << i2 << "] = " << get_grid(i0, i1, i2, 2) << "(" << dy << ")\n" << endi);
01392                 DebugM(1, "dz[" << i0 << "," << i1 << "," << i2 << "] = " << get_grid(i0, i1, i2, 3) << "(" << dz << ")\n" << endi);
01393             }
01394         }
01395     }
01396 }

int GridforceLiteGrid::compute_VdV ( Position  pos,
float &  V,
Vector dV 
) const [inline]

Reimplemented from GridforceGrid.

Definition at line 66 of file GridForceGrid.inl.

References get_inds(), inv, j, linear_interpolate(), Vector::x, Vector::y, and Vector::z.

00067 {
00068     int inds[3];
00069     Vector g, dg;
00070     
00071     int err = get_inds(pos, inds, dg);
00072     if (err) {
00073         return -1;
00074     }
00075     
00076     float wts[4][8];
00077     float results[4];
00078     
00079     // compute_wts(wts, dg);
00080     // wts[0][0] = (1-dg.x) * (1-dg.y) * (1-dg.z);
00081     // wts[0][1] = (1-dg.x) * (1-dg.y) *   dg.z;
00082     // wts[0][2] = (1-dg.x) *   dg.y   * (1-dg.z);
00083     // wts[0][3] = (1-dg.x) *   dg.y   *   dg.z;
00084     // wts[0][4] =   dg.x   * (1-dg.y) * (1-dg.z);
00085     // wts[0][5] =   dg.x   * (1-dg.y) *   dg.z;
00086     // wts[0][6] =   dg.x   *   dg.y   * (1-dg.z);
00087     // wts[0][7] =   dg.x   *   dg.y   *   dg.z;
00088 
00089     int i = 1;
00090     wts[i][0] = -(1-dg.y) * (1-dg.z);
00091     wts[i][1] = -(1-dg.y) *   dg.z;
00092     wts[i][2] = -  dg.y   * (1-dg.z);
00093     wts[i][3] = -  dg.y   *   dg.z;
00094     for (int j=0; j<4; j++) wts[i][j+4] = -wts[i][j];
00095 
00096     i = 2;
00097     wts[i][0] = -(1-dg.x) * (1-dg.z);
00098     wts[i][1] = -(1-dg.x) *   dg.z;
00099     wts[i][2] = -wts[i][0];
00100     wts[i][3] = -wts[i][1];
00101     wts[i][4] =   - dg.x  * (1-dg.z);
00102     wts[i][5] =   - dg.x  *   dg.z;
00103     wts[i][6] = -wts[i][4];
00104     wts[i][7] = -wts[i][5];
00105 
00106     i = 3;
00107     wts[i][0] = - (1-dg.x) * (1-dg.y);
00108     wts[i][1] = -wts[i][0];
00109     wts[i][2] = - (1-dg.x) *   dg.y  ;
00110     wts[i][3] = -wts[i][2];
00111     wts[i][4] = - dg.x     * (1-dg.y);
00112     wts[i][5] = -wts[i][4];
00113     wts[i][6] = - dg.x     *   dg.y  ;
00114     wts[i][7] = -wts[i][6];
00115 
00116     i = 0;
00117     for (int j=0; j<4; j++) wts[i][j]   = (1-dg.x) * wts[i+1][j+4];
00118     for (int j=0; j<4; j++) wts[i][j+4] =   dg.x   * wts[i+1][j+4];    
00119 
00120     for (i = 0; i < 4; i++) {
00121         results[i] = linear_interpolate(inds[0], inds[1], inds[2], 0, wts[i]);
00122     }
00123     
00124     V = results[0];
00125     dV = Vector(results[1], results[2], results[3]) * inv;
00126     
00127     return 0;
00128 }

void GridforceLiteGrid::compute_wts ( float *  wts,
const Vector dg 
) const [inline, protected]

Definition at line 400 of file GridForceGrid.inl.

References DebugM, endi(), Vector::x, Vector::y, and Vector::z.

00401 {
00402     wts[0] = (1-dg.x) * (1-dg.y) * (1-dg.z);
00403     wts[1] = (1-dg.x) * (1-dg.y) *   dg.z;
00404     wts[2] = (1-dg.x) *   dg.y   * (1-dg.z);
00405     wts[3] = (1-dg.x) *   dg.y   *   dg.z;
00406     wts[4] =   dg.x   * (1-dg.y) * (1-dg.z);
00407     wts[5] =   dg.x   * (1-dg.y) *   dg.z;
00408     wts[6] =   dg.x   *   dg.y   * (1-dg.z);
00409     wts[7] =   dg.x   *   dg.y   *   dg.z;
00410     DebugM(2, "dg = " << dg << "\n" << endi);
00411 }

long int GridforceLiteGrid::get_all_gridvals ( float **  all_gridvals  )  const [virtual]

Implements GridforceGrid.

Definition at line 1449 of file GridForceGrid.C.

References DebugM, endi(), grid, and size.

01450 {
01451     // Creates a flat array of all grid values and puts it in the
01452     // value pointed to by the 'all_gridvals' argument. Returns the
01453     // resulting array size. Caller is responsible for destroying the
01454     // array via 'delete[]'
01455     
01456     DebugM(4, "GridforceLiteGrid::get_all_gridvals called\n" << endi);
01457     
01458     long int sz = size;
01459     DebugM(4, "size = " << sz << "\n" << endi);
01460     
01461     float *grid_vals = new float[sz];
01462     long int idx = 0;
01463     for (long int i = 0; i < size; i++) {
01464         grid_vals[idx++] = grid[i];
01465     }
01466     CmiAssert(idx == sz);
01467     
01468     *all_gridvals = grid_vals;
01469     
01470     DebugM(4, "GridforceLiteGrid::get_all_gridvals finished\n" << endi);
01471     
01472     return sz;
01473 }

Position GridforceLiteGrid::get_center ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 295 of file GridForceGrid.h.

References center.

00295 { return center; }

Bool GridforceLiteGrid::get_checksize ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 300 of file GridForceGrid.h.

References checksize.

00300 { return checksize; }

Tensor GridforceLiteGrid::get_e ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 297 of file GridForceGrid.h.

References e.

00297 { return e; }

float GridforceLiteGrid::get_grid ( int  i0,
int  i1,
int  i2,
int  i3 
) const [inline]

Definition at line 307 of file GridForceGrid.h.

References grid, and grid_index().

Referenced by compute_derivative_grids(), initialize(), and linear_interpolate().

00307                                                                 {
00308         return grid[grid_index(i0, i1, i2, i3)];
00309     }

double GridforceLiteGrid::get_grid_d ( int  i0,
int  i1,
int  i2,
int  i3 
) const [inline]

Definition at line 310 of file GridForceGrid.h.

References grid, and grid_index().

Referenced by compute_derivative_grids().

00310                                                                    {
00311         return double(grid[grid_index(i0, i1, i2, i3)]);
00312     }

int GridforceLiteGrid::get_inds ( Position  pos,
int *  inds,
Vector dg 
) const [inline, protected]

Definition at line 378 of file GridForceGrid.inl.

References inv, k, and origin.

Referenced by compute_VdV().

00379 {
00380     Vector p = pos - origin;
00381     Vector g;
00382     
00383     g = inv * p;
00384     
00385     for (int i = 0; i < 3; i++) {
00386         inds[i] = (int)floor(g[i]);
00387         dg[i] = g[i] - inds[i];
00388     }
00389     
00390     for (int i = 0; i < 3; i++) {
00391         if (inds[i] < 0 || inds[i] >= k[i]-1) {
00392             return -1;  // Outside potential and grid is not continuous
00393         }
00394     }
00395     
00396     return 0;
00397 }

Tensor GridforceLiteGrid::get_inv ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 298 of file GridForceGrid.h.

References inv.

00298 { return inv; }

int GridforceLiteGrid::get_k0 ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 301 of file GridForceGrid.h.

References k.

00301 { return k[0]; }

int GridforceLiteGrid::get_k1 ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 302 of file GridForceGrid.h.

References k.

00302 { return k[1]; }

int GridforceLiteGrid::get_k2 ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 303 of file GridForceGrid.h.

References k.

00303 { return k[2]; }

Position GridforceLiteGrid::get_origin ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 296 of file GridForceGrid.h.

References origin.

00296 { return origin; }

Vector GridforceLiteGrid::get_scale ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 299 of file GridForceGrid.h.

References scale.

00299 { return scale; }

int GridforceLiteGrid::get_total_grids ( void   )  const [inline, virtual]

Implements GridforceGrid.

Definition at line 304 of file GridForceGrid.h.

00304 { return 1; }

long int GridforceLiteGrid::grid_index ( int  i0,
int  i1,
int  i2,
int  i3 
) const [inline, protected]

Definition at line 331 of file GridForceGrid.h.

References dk.

Referenced by get_grid(), get_grid_d(), and set_grid().

00331                                                                      {
00332         // 'i3' is an index for the grid itself (0=V, 1=dV/dx, 2=dV/dy, 3=dV/dz)
00333         register int inds[4] = {i0, i1, i2, i3};
00334         return inds[0]*dk[0] + inds[1]*dk[1] + inds[2]*dk[2] + inds[3]*dk[3];
00335     }

void GridforceLiteGrid::initialize ( char *  potfilename,
SimParameters simParams,
MGridforceParams mgridParams 
) [virtual]

Implements GridforceGrid.

Definition at line 1319 of file GridForceGrid.C.

References center, compute_derivative_grids(), DebugM, e, endi(), filename, GridforceFullMainGrid::get_center(), GridforceFullMainGrid::get_e(), get_grid(), GridforceFullBaseGrid::get_grid(), GridforceFullMainGrid::get_inv(), GridforceFullMainGrid::get_k0(), GridforceFullMainGrid::get_k1(), GridforceFullMainGrid::get_k2(), GridforceFullMainGrid::get_origin(), GridforceFullMainGrid::get_scale(), GridforceFullMainGrid::get_total_grids(), grid, GridforceFullMainGrid::initialize(), inv, GridforceGrid::mygridnum, NAMD_die(), origin, scale, set_grid(), simParams, and size.

Referenced by reinitialize().

01320 {
01321     // cheat and use GridforceFullMainGrid to read the file
01322     GridforceFullMainGrid *tmp_grid = new GridforceFullMainGrid(mygridnum);
01323     tmp_grid->initialize(potfilename, simParams, mgridParams, 1);
01324     
01325     if (tmp_grid->get_total_grids() != 1) {
01326         NAMD_die("Cannot use gridforcelite option with multi-resolution grid!");
01327     }
01328     
01329     // save file name so that grid can be re-read via Tcl
01330     strcpy(filename, potfilename);
01331     
01332     // copy parameters
01333     k[0] = tmp_grid->get_k0();
01334     k[1] = tmp_grid->get_k1();
01335     k[2] = tmp_grid->get_k2();
01336     k[3] = 4;   // for V, dV/dx, dV/dy, dV/dz grids
01337     origin = tmp_grid->get_origin();
01338     center = tmp_grid->get_center();
01339     e = tmp_grid->get_e();
01340     inv = tmp_grid->get_inv();
01341     scale = tmp_grid->get_scale();
01342     
01343     // calculate rest of parameters
01344     size = k[0] * k[1] * k[2] * k[3];
01345     dk[0] = k[1] * k[2] * k[3];
01346     dk[1] = k[2] * k[3];
01347     dk[2] = k[3];
01348     dk[3] = 1;
01349     
01350     // copy the potential grid
01351     delete[] grid;
01352     grid = new float[size];
01353     for (int i0 = 0; i0 < k[0]; i0++) {
01354         for (int i1 = 0; i1 < k[1]; i1++) {
01355             for (int i2 = 0; i2 < k[2]; i2++) {
01356                 float V = tmp_grid->get_grid(i0, i1, i2);
01357                 set_grid(i0, i1, i2, 0, V);
01358                 DebugM(1, "V[" << i0 << "," << i1 << "," << i2 << "] = " << get_grid(i0, i1, i2, 0) << "(" << V << ")\n" << endi);
01359             }
01360         }
01361     }
01362     
01363     delete tmp_grid;
01364     
01365     compute_derivative_grids();
01366 }

float GridforceLiteGrid::linear_interpolate ( int  i0,
int  i1,
int  i2,
int  i3,
const float *  wts 
) const [inline, protected]

Definition at line 414 of file GridForceGrid.inl.

References DebugM, endi(), and get_grid().

Referenced by compute_VdV().

00415 {
00416 #ifdef DEBUGM
00417     float vals[8];
00418     vals[0] = get_grid(i0,   i1,   i2,   i3);
00419     vals[1] = get_grid(i0,   i1,   i2+1, i3);
00420     vals[2] = get_grid(i0,   i1+1, i2,   i3);
00421     vals[3] = get_grid(i0,   i1+1, i2+1, i3);
00422     vals[4] = get_grid(i0+1, i1,   i2,   i3);
00423     vals[5] = get_grid(i0+1, i1,   i2+1, i3);
00424     vals[6] = get_grid(i0+1, i1+1, i2,   i3);
00425     vals[7] = get_grid(i0+1, i1+1, i2+1, i3);
00426     
00427     switch (i3) {
00428     case 0:
00429         DebugM(2, "V\n" << endi);
00430         break;
00431     case 1:
00432         DebugM(2, "dV/dx\n" << endi);
00433         break;
00434     case 2:
00435         DebugM(2, "dV/dy\n" << endi);
00436         break;
00437     case 3:
00438         DebugM(2, "dV/dz\n" << endi);
00439         break;
00440     }
00441     
00442     for (int i = 0; i < 8; i++) {
00443         DebugM(2, "vals[" << i << "] = " << vals[i] << " wts[" << i << "] = " << wts[i] << "\n" << endi);
00444     }
00445 #endif
00446     
00447     float result =
00448         wts[0] * get_grid(i0,   i1,   i2,   i3) +
00449         wts[1] * get_grid(i0,   i1,   i2+1, i3) +
00450         wts[2] * get_grid(i0,   i1+1, i2,   i3) +
00451         wts[3] * get_grid(i0,   i1+1, i2+1, i3) +
00452         wts[4] * get_grid(i0+1, i1,   i2,   i3) +
00453         wts[5] * get_grid(i0+1, i1,   i2+1, i3) +
00454         wts[6] * get_grid(i0+1, i1+1, i2,   i3) +
00455         wts[7] * get_grid(i0+1, i1+1, i2+1, i3);
00456     
00457     DebugM(2, "result = " << result << "\n" << endi);
00458     
00459     return result;
00460 }

void GridforceLiteGrid::pack ( MOStream msg  )  const [protected, virtual]

Implements GridforceGrid.

Definition at line 1405 of file GridForceGrid.C.

References center, checksize, e, filename, grid, inv, origin, MOStream::put(), scale, and size.

01406 {
01407     msg->put(4*sizeof(int), (char*)k);
01408     msg->put(size);
01409     msg->put(4*sizeof(long int), (char*)dk);
01410     
01411     msg->put(sizeof(Vector), (char*)&origin);
01412     msg->put(sizeof(Vector), (char*)&center);
01413     msg->put(sizeof(Tensor), (char*)&e);
01414     msg->put(sizeof(Tensor), (char*)&inv);
01415     msg->put(sizeof(Vector), (char*)&scale);
01416     msg->put(sizeof(Bool), (char*)&checksize);
01417     
01418     msg->put(129*sizeof(char), (char*)filename);
01419     
01420     msg->put(size*sizeof(float), (char*)grid);
01421 }

void GridforceLiteGrid::reinitialize ( SimParameters simParams,
MGridforceParams mgridParams 
) [virtual]

Implements GridforceGrid.

Definition at line 1399 of file GridForceGrid.C.

References filename, initialize(), and simParams.

01400 {
01401     initialize(filename, simParams, mgridParams);
01402 }

void GridforceLiteGrid::set_all_gridvals ( float *  all_gridvals,
long int  sz 
) [virtual]

Implements GridforceGrid.

Definition at line 1476 of file GridForceGrid.C.

References DebugM, endi(), grid, and size.

01477 {
01478     DebugM(4, "GridforceLiteGrid::set_all_gridvals called\n" << endi);
01479     
01480     long int sz_calc = size;
01481     CmiAssert(sz == sz_calc);
01482     
01483     long int idx = 0;
01484     for (long int i = 0; i < size; i++) {
01485         grid[i] = all_gridvals[idx++];
01486     }
01487     CmiAssert(idx == sz);
01488     
01489     //compute_derivative_grids();       // not needed if we're sending all 4 grids
01490     
01491     DebugM(4, "GridforceLiteGrid::set_all_gridvals finished\n" << endi);
01492 }

void GridforceLiteGrid::set_grid ( int  i0,
int  i1,
int  i2,
int  i3,
float  V 
) [inline]

Definition at line 313 of file GridForceGrid.h.

References grid, and grid_index().

Referenced by compute_derivative_grids(), and initialize().

00313                                                                   {
00314         grid[grid_index(i0, i1, i2, i3)] = V;
00315     }

void GridforceLiteGrid::set_scale ( Vector  s  )  [inline, virtual]

Implements GridforceGrid.

Definition at line 305 of file GridForceGrid.h.

References scale.

00305 { scale = s; }

void GridforceLiteGrid::unpack ( MIStream msg  )  [protected, virtual]

Implements GridforceGrid.

Definition at line 1424 of file GridForceGrid.C.

References center, checksize, e, filename, MIStream::get(), grid, inv, origin, scale, and size.

01425 {
01426     delete[] grid;
01427     grid = NULL;
01428 
01429     msg->get(4*sizeof(int), (char*)k);
01430     msg->get(size);
01431     msg->get(4*sizeof(long int), (char*)dk);
01432     
01433     msg->get(sizeof(Vector), (char*)&origin);
01434     msg->get(sizeof(Vector), (char*)&center);
01435     msg->get(sizeof(Tensor), (char*)&e);
01436     msg->get(sizeof(Tensor), (char*)&inv);
01437     msg->get(sizeof(Vector), (char*)&scale);
01438     msg->get(sizeof(Bool), (char*)&checksize);
01439     
01440     msg->get(129*sizeof(char), (char*)filename);
01441     
01442     if (size) {
01443         grid = new float[size];
01444         msg->get(size*sizeof(float), (char*)grid);
01445     }
01446 }


Member Data Documentation

Position GridforceLiteGrid::center [protected]

Definition at line 344 of file GridForceGrid.h.

Referenced by get_center(), initialize(), pack(), and unpack().

Bool GridforceLiteGrid::checksize [protected]

Definition at line 349 of file GridForceGrid.h.

Referenced by get_checksize(), pack(), and unpack().

long int GridforceLiteGrid::dk[4] [protected]

Definition at line 341 of file GridForceGrid.h.

Referenced by grid_index().

Tensor GridforceLiteGrid::e [protected]

Definition at line 345 of file GridForceGrid.h.

Referenced by get_e(), initialize(), pack(), and unpack().

char GridforceLiteGrid::filename[129] [protected]

Definition at line 351 of file GridForceGrid.h.

Referenced by initialize(), pack(), reinitialize(), and unpack().

float* GridforceLiteGrid::grid [protected]

Definition at line 337 of file GridForceGrid.h.

Referenced by get_all_gridvals(), get_grid(), get_grid_d(), GridforceLiteGrid(), initialize(), pack(), set_all_gridvals(), set_grid(), unpack(), and ~GridforceLiteGrid().

Tensor GridforceLiteGrid::inv [protected]

Definition at line 346 of file GridForceGrid.h.

Referenced by compute_VdV(), get_inds(), get_inv(), initialize(), pack(), and unpack().

int GridforceLiteGrid::k[4] [protected]

Definition at line 339 of file GridForceGrid.h.

Referenced by get_inds(), get_k0(), get_k1(), and get_k2().

Position GridforceLiteGrid::origin [protected]

Definition at line 343 of file GridForceGrid.h.

Referenced by get_inds(), get_origin(), initialize(), pack(), and unpack().

Vector GridforceLiteGrid::scale [protected]

Definition at line 348 of file GridForceGrid.h.

Referenced by get_scale(), initialize(), pack(), set_scale(), and unpack().

long int GridforceLiteGrid::size [protected]

Definition at line 340 of file GridForceGrid.h.

Referenced by get_all_gridvals(), initialize(), pack(), set_all_gridvals(), and unpack().


The documentation for this class was generated from the following files:
Generated on Sun Sep 24 01:17:18 2017 for NAMD by  doxygen 1.4.7