GridforceLiteGrid Class Reference

#include <GridForceGrid.h>

Inheritance diagram for GridforceLiteGrid:

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
Public Member Functions inherited from GridforceGrid
virtual	~GridforceGrid ()
Position	wrap_position (const Position &pos, const Lattice &lattice)
bool	fits_lattice (const Lattice &lattice)
int	compute_VdV (Position pos, float &V, Vector &dV) const
GridforceGridType	get_grid_type (void)

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 Member Functions inherited from GridforceGrid
Position	get_corner (int idx)
	GridforceGrid ()

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 [NAMD_FILENAME_BUFFER_SIZE]
Protected Attributes inherited from GridforceGrid
GridforceGridType	type
int	mygridnum

Additional Inherited Members
Public Types inherited from GridforceGrid
enum	GridforceGridType { GridforceGridTypeUndefined = 0, GridforceGridTypeFull, GridforceGridTypeLite }
Static Public Member Functions inherited from GridforceGrid
static GridforceGrid *	new_grid (int gridnum, char *potfilename, SimParameters *simParams, MGridforceParams *mgridParams)
static void	pack_grid (GridforceGrid *grid, MOStream *msg)
static GridforceGrid *	unpack_grid (int gridnum, MIStream *msg)

Detailed Description

Definition at line 287 of file GridForceGrid.h.

Constructor & Destructor Documentation

GridforceLiteGrid::GridforceLiteGrid ( int  gridnum )

explicit

Definition at line 1306 of file GridForceGrid.C.

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

{
    mygridnum = gridnum;
    grid = NULL;
    type = GridforceGridTypeLite;
}

GridforceLiteGrid::~GridforceLiteGrid ( )

virtual

Definition at line 1314 of file GridForceGrid.C.

References grid.

{
    delete[] grid;
}

Member Function Documentation

void GridforceLiteGrid::compute_derivative_grids ( void  )

protected

Definition at line 1370 of file GridForceGrid.C.

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

Referenced by initialize().

{
    // calculate derivative grids
    // separate loop so all V values have been set already
    for (int i0 = 0; i0 < k[0]; i0++) {
        for (int i1 = 0; i1 < k[1]; i1++) {
            for (int i2 = 0; i2 < k[2]; i2++) {
                float dx, dy, dz;
                if (i0 == 0 || i0 == k[0]-1 || i1 == 0 || i1 == k[1]-1 || i2 == 0 || i2 == k[2]-1) {
                    // on edge, set ALL derivatives to zero (make up for lack of padding)
                    dx = 0;
                    dy = 0;
                    dz = 0;
                } else {
                    dx = 0.5 * (get_grid_d(i0+1,i1,i2,0) - get_grid_d(i0-1,i1,i2,0));
                    dy = 0.5 * (get_grid_d(i0,i1+1,i2,0) - get_grid_d(i0,i1-1,i2,0));
                    dz = 0.5 * (get_grid_d(i0,i1,i2+1,0) - get_grid_d(i0,i1,i2-1,0));
                }
                set_grid(i0, i1, i2, 1, dx);
                set_grid(i0, i1, i2, 2, dy);
                set_grid(i0, i1, i2, 3, dz);
                DebugM(1, "dx[" << i0 << "," << i1 << "," << i2 << "] = " << get_grid(i0, i1, i2, 1) << "(" << dx << ")\n" << endi);
                DebugM(1, "dy[" << i0 << "," << i1 << "," << i2 << "] = " << get_grid(i0, i1, i2, 2) << "(" << dy << ")\n" << endi);
                DebugM(1, "dz[" << i0 << "," << i1 << "," << i2 << "] = " << get_grid(i0, i1, i2, 3) << "(" << dz << ")\n" << endi);
            }
        }
    }
}

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

inline

Definition at line 66 of file GridForceGrid.inl.

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

{
    int inds[3];
    Vector g, dg;
    
    int err = get_inds(pos, inds, dg);
    if (err) {
        return -1;
    }
    
    float wts[4][8];
    float results[4];
    
    // compute_wts(wts, dg);
    // wts[0][0] = (1-dg.x) * (1-dg.y) * (1-dg.z);
    // wts[0][1] = (1-dg.x) * (1-dg.y) *   dg.z;
    // wts[0][2] = (1-dg.x) *   dg.y   * (1-dg.z);
    // wts[0][3] = (1-dg.x) *   dg.y   *   dg.z;
    // wts[0][4] =   dg.x   * (1-dg.y) * (1-dg.z);
    // wts[0][5] =   dg.x   * (1-dg.y) *   dg.z;
    // wts[0][6] =   dg.x   *   dg.y   * (1-dg.z);
    // wts[0][7] =   dg.x   *   dg.y   *   dg.z;

    int i = 1;
    wts[i][0] = -(1-dg.y) * (1-dg.z);
    wts[i][1] = -(1-dg.y) *   dg.z;
    wts[i][2] = -  dg.y   * (1-dg.z);
    wts[i][3] = -  dg.y   *   dg.z;
    for (int j=0; j<4; j++) wts[i][j+4] = -wts[i][j];

    i = 2;
    wts[i][0] = -(1-dg.x) * (1-dg.z);
    wts[i][1] = -(1-dg.x) *   dg.z;
    wts[i][2] = -wts[i][0];
    wts[i][3] = -wts[i][1];
    wts[i][4] =   - dg.x  * (1-dg.z);
    wts[i][5] =   - dg.x  *   dg.z;
    wts[i][6] = -wts[i][4];
    wts[i][7] = -wts[i][5];

    i = 3;
    wts[i][0] = - (1-dg.x) * (1-dg.y);
    wts[i][1] = -wts[i][0];
    wts[i][2] = - (1-dg.x) *   dg.y  ;
    wts[i][3] = -wts[i][2];
    wts[i][4] = - dg.x     * (1-dg.y);
    wts[i][5] = -wts[i][4];
    wts[i][6] = - dg.x     *   dg.y  ;
    wts[i][7] = -wts[i][6];

    i = 0;
    for (int j=0; j<4; j++) wts[i][j]   = (1-dg.x) * wts[i+1][j+4];
    for (int j=0; j<4; j++) wts[i][j+4] =   dg.x   * wts[i+1][j+4];    

    for (i = 0; i < 4; i++) {
        results[i] = linear_interpolate(inds[0], inds[1], inds[2], 0, wts[i]);
    }
    
    V = results[0];
    dV = Vector(results[1], results[2], results[3]) * inv;
    
    return 0;
}

void GridforceLiteGrid::compute_wts ( float *  wts, const Vector &  dg  ) const

inlineprotected

Definition at line 400 of file GridForceGrid.inl.

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

{
    wts[0] = (1-dg.x) * (1-dg.y) * (1-dg.z);
    wts[1] = (1-dg.x) * (1-dg.y) *   dg.z;
    wts[2] = (1-dg.x) *   dg.y   * (1-dg.z);
    wts[3] = (1-dg.x) *   dg.y   *   dg.z;
    wts[4] =   dg.x   * (1-dg.y) * (1-dg.z);
    wts[5] =   dg.x   * (1-dg.y) *   dg.z;
    wts[6] =   dg.x   *   dg.y   * (1-dg.z);
    wts[7] =   dg.x   *   dg.y   *   dg.z;
    DebugM(2, "dg = " << dg << "\n" << endi);
}

long int GridforceLiteGrid::get_all_gridvals ( float **  all_gridvals ) const

virtual

Implements GridforceGrid.

Definition at line 1450 of file GridForceGrid.C.

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

{
    // Creates a flat array of all grid values and puts it in the
    // value pointed to by the 'all_gridvals' argument. Returns the
    // resulting array size. Caller is responsible for destroying the
    // array via 'delete[]'
    
    DebugM(4, "GridforceLiteGrid::get_all_gridvals called\n" << endi);
    
    long int sz = size;
    DebugM(4, "size = " << sz << "\n" << endi);
    
    float *grid_vals = new float[sz];
    long int idx = 0;
    for (long int i = 0; i < size; i++) {
        grid_vals[idx++] = grid[i];
    }
    CmiAssert(idx == sz);
    
    *all_gridvals = grid_vals;
    
    DebugM(4, "GridforceLiteGrid::get_all_gridvals finished\n" << endi);
    
    return sz;
}

Position GridforceLiteGrid::get_center ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 295 of file GridForceGrid.h.

References center.

{ return center; }

Bool GridforceLiteGrid::get_checksize ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 300 of file GridForceGrid.h.

References checksize.

{ return checksize; }

Tensor GridforceLiteGrid::get_e ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 297 of file GridForceGrid.h.

References e.

{ 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().

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

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().

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

int GridforceLiteGrid::get_inds ( Position  pos, int *  inds, Vector &  dg  ) const

inlineprotected

Definition at line 378 of file GridForceGrid.inl.

References inv, k, and origin.

Referenced by compute_VdV().

{
    Vector p = pos - origin;
    Vector g;
    
    g = inv * p;
    
    for (int i = 0; i < 3; i++) {
        inds[i] = (int)floor(g[i]);
        dg[i] = g[i] - inds[i];
    }
    
    for (int i = 0; i < 3; i++) {
        if (inds[i] < 0 || inds[i] >= k[i]-1) {
            return -1;  // Outside potential and grid is not continuous
        }
    }
    
    return 0;
}

Tensor GridforceLiteGrid::get_inv ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 298 of file GridForceGrid.h.

References inv.

{ return inv; }

int GridforceLiteGrid::get_k0 ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 301 of file GridForceGrid.h.

References k.

{ return k[0]; }

int GridforceLiteGrid::get_k1 ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 302 of file GridForceGrid.h.

References k.

{ return k[1]; }

int GridforceLiteGrid::get_k2 ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 303 of file GridForceGrid.h.

References k.

{ return k[2]; }

Position GridforceLiteGrid::get_origin ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 296 of file GridForceGrid.h.

References origin.

{ return origin; }

Vector GridforceLiteGrid::get_scale ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 299 of file GridForceGrid.h.

References scale.

{ return scale; }

int GridforceLiteGrid::get_total_grids ( void  ) const

inlinevirtual

Implements GridforceGrid.

Definition at line 304 of file GridForceGrid.h.

{ return 1; }

long int GridforceLiteGrid::grid_index ( int  i0, int  i1, int  i2, int  i3  ) const

inlineprotected

Definition at line 331 of file GridForceGrid.h.

References dk.

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

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

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

virtual

Implements GridforceGrid.

Definition at line 1320 of file GridForceGrid.C.

References center, compute_derivative_grids(), DebugM, dk, e, endi(), filename, GridforceFullMainGrid::get_center(), GridforceFullMainGrid::get_e(), GridforceFullBaseGrid::get_grid(), 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, k, GridforceGrid::mygridnum, NAMD_die(), origin, scale, set_grid(), and size.

Referenced by reinitialize().

{
    // cheat and use GridforceFullMainGrid to read the file
    GridforceFullMainGrid *tmp_grid = new GridforceFullMainGrid(mygridnum);
    tmp_grid->initialize(potfilename, simParams, mgridParams, 1);
    
    if (tmp_grid->get_total_grids() != 1) {
        NAMD_die("Cannot use gridforcelite option with multi-resolution grid!");
    }
    
    // save file name so that grid can be re-read via Tcl
    strcpy(filename, potfilename);
    
    // copy parameters
    k[0] = tmp_grid->get_k0();
    k[1] = tmp_grid->get_k1();
    k[2] = tmp_grid->get_k2();
    k[3] = 4;   // for V, dV/dx, dV/dy, dV/dz grids
    origin = tmp_grid->get_origin();
    center = tmp_grid->get_center();
    e = tmp_grid->get_e();
    inv = tmp_grid->get_inv();
    scale = tmp_grid->get_scale();
    
    // calculate rest of parameters
    size = k[0] * k[1] * k[2] * k[3];
    dk[0] = k[1] * k[2] * k[3];
    dk[1] = k[2] * k[3];
    dk[2] = k[3];
    dk[3] = 1;
    
    // copy the potential grid
    delete[] grid;
    grid = new float[size];
    for (int i0 = 0; i0 < k[0]; i0++) {
        for (int i1 = 0; i1 < k[1]; i1++) {
            for (int i2 = 0; i2 < k[2]; i2++) {
                float V = tmp_grid->get_grid(i0, i1, i2);
                set_grid(i0, i1, i2, 0, V);
                DebugM(1, "V[" << i0 << "," << i1 << "," << i2 << "] = " << get_grid(i0, i1, i2, 0) << "(" << V << ")\n" << endi);
            }
        }
    }
    
    delete tmp_grid;
    
    compute_derivative_grids();
}

float GridforceLiteGrid::linear_interpolate ( int  i0, int  i1, int  i2, int  i3, const float *  wts  ) const

inlineprotected

Definition at line 414 of file GridForceGrid.inl.

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

Referenced by compute_VdV().

{
#ifdef DEBUGM
    float vals[8];
    vals[0] = get_grid(i0,   i1,   i2,   i3);
    vals[1] = get_grid(i0,   i1,   i2+1, i3);
    vals[2] = get_grid(i0,   i1+1, i2,   i3);
    vals[3] = get_grid(i0,   i1+1, i2+1, i3);
    vals[4] = get_grid(i0+1, i1,   i2,   i3);
    vals[5] = get_grid(i0+1, i1,   i2+1, i3);
    vals[6] = get_grid(i0+1, i1+1, i2,   i3);
    vals[7] = get_grid(i0+1, i1+1, i2+1, i3);
    
    switch (i3) {
    case 0:
        DebugM(2, "V\n" << endi);
        break;
    case 1:
        DebugM(2, "dV/dx\n" << endi);
        break;
    case 2:
        DebugM(2, "dV/dy\n" << endi);
        break;
    case 3:
        DebugM(2, "dV/dz\n" << endi);
        break;
    }
    
    for (int i = 0; i < 8; i++) {
        DebugM(2, "vals[" << i << "] = " << vals[i] << " wts[" << i << "] = " << wts[i] << "\n" << endi);
    }
#endif
    
    float result =
        wts[0] * get_grid(i0,   i1,   i2,   i3) +
        wts[1] * get_grid(i0,   i1,   i2+1, i3) +
        wts[2] * get_grid(i0,   i1+1, i2,   i3) +
        wts[3] * get_grid(i0,   i1+1, i2+1, i3) +
        wts[4] * get_grid(i0+1, i1,   i2,   i3) +
        wts[5] * get_grid(i0+1, i1,   i2+1, i3) +
        wts[6] * get_grid(i0+1, i1+1, i2,   i3) +
        wts[7] * get_grid(i0+1, i1+1, i2+1, i3);
    
    DebugM(2, "result = " << result << "\n" << endi);
    
    return result;
}

void GridforceLiteGrid::pack ( MOStream *  msg ) const

protectedvirtual

Implements GridforceGrid.

Definition at line 1406 of file GridForceGrid.C.

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

{
    msg->put(4*sizeof(int), (char*)k);
    msg->put(size);
    msg->put(4*sizeof(long int), (char*)dk);
    
    msg->put(sizeof(Vector), (char*)&origin);
    msg->put(sizeof(Vector), (char*)&center);
    msg->put(sizeof(Tensor), (char*)&e);
    msg->put(sizeof(Tensor), (char*)&inv);
    msg->put(sizeof(Vector), (char*)&scale);
    msg->put(sizeof(Bool), (char*)&checksize);
    
    msg->put(129*sizeof(char), (char*)filename);
    
    msg->put(size*sizeof(float), (char*)grid);
}

void GridforceLiteGrid::reinitialize ( SimParameters *  simParams, MGridforceParams *  mgridParams  )

virtual

Implements GridforceGrid.

Definition at line 1400 of file GridForceGrid.C.

References filename, and initialize().

{
    initialize(filename, simParams, mgridParams);
}

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

virtual

Implements GridforceGrid.

Definition at line 1477 of file GridForceGrid.C.

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

{
    DebugM(4, "GridforceLiteGrid::set_all_gridvals called\n" << endi);
    
    long int sz_calc = size;
    CmiAssert(sz == sz_calc);
    
    long int idx = 0;
    for (long int i = 0; i < size; i++) {
        grid[i] = all_gridvals[idx++];
    }
    CmiAssert(idx == sz);
    
    //compute_derivative_grids();       // not needed if we're sending all 4 grids
    
    DebugM(4, "GridforceLiteGrid::set_all_gridvals finished\n" << endi);
}

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().

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

void GridforceLiteGrid::set_scale ( Vector  s )

inlinevirtual

Implements GridforceGrid.

Definition at line 305 of file GridForceGrid.h.

References scale.

{ scale = s; }

void GridforceLiteGrid::unpack ( MIStream *  msg )

protectedvirtual

Implements GridforceGrid.

Definition at line 1425 of file GridForceGrid.C.

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

{
    delete[] grid;
    grid = NULL;

    msg->get(4*sizeof(int), (char*)k);
    msg->get(size);
    msg->get(4*sizeof(long int), (char*)dk);
    
    msg->get(sizeof(Vector), (char*)&origin);
    msg->get(sizeof(Vector), (char*)&center);
    msg->get(sizeof(Tensor), (char*)&e);
    msg->get(sizeof(Tensor), (char*)&inv);
    msg->get(sizeof(Vector), (char*)&scale);
    msg->get(sizeof(Bool), (char*)&checksize);
    
    msg->get(129*sizeof(char), (char*)filename);
    
    if (size) {
        grid = new float[size];
        msg->get(size*sizeof(float), (char*)grid);
    }
}

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(), initialize(), pack(), and unpack().

Tensor GridforceLiteGrid::e

protected

Definition at line 345 of file GridForceGrid.h.

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

char GridforceLiteGrid::filename[NAMD_FILENAME_BUFFER_SIZE]

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 compute_derivative_grids(), get_inds(), get_k0(), get_k1(), get_k2(), initialize(), pack(), and unpack().

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:

• GridForceGrid.h
• GridForceGrid.C
• GridForceGrid.inl