#include <GridForceGrid.h>

Inheritance diagram for GridforceFullSubGrid:

Public Member Functions
	GridforceFullSubGrid (GridforceFullBaseGrid *parent_in)

void	initialize (SimParameters simParams, MGridforceParams mgridParams)

int	get_border (void) const

Tensor	tensorMult (const Tensor &t1, const Tensor &t2)

Public Member Functions inherited from GridforceFullBaseGrid
	GridforceFullBaseGrid (void)

virtual	~GridforceFullBaseGrid ()

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

float	get_grid (int i0, int i1, int i2) const

double	get_grid_d (int i0, int i1, int i2) const

void	set_grid (int i0, int i1, int i2, float V)

void	set_scale (Vector s)

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

int	get_k0 (void) const

int	get_k1 (void) const

int	get_k2 (void) const

Protected Member Functions
void	pack (MOStream *msg) const

void	unpack (MIStream *msg)

void	compute_b (float b, int inds, Vector gapscale) const

void	addToSubgridsFlat (void)

Protected Member Functions inherited from GridforceFullBaseGrid
void	readHeader (SimParameters simParams, MGridforceParams mgridParams)

long int	grid_index (int i0, int i1, int i2) const

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

void	compute_a (float a, float b) const

float	compute_V (float a, float x, float y, float z) const

Vector	compute_dV (float a, float x, float y, float z) const

Vector	compute_d2V (float a, float x, float y, float z) const

float	compute_d3V (float a, float x, float y, float z) const

void	readSubgridHierarchy (FILE *poten, int &totalGrids)

Protected Attributes
Tensor	scale_dV

Tensor	scale_d2V

float	scale_d3V

GridforceFullBaseGrid *	parent

int	pmin [3]

int	pmax [3]

GridforceFullMainGrid *	maingrid

int	subgridIdx

Protected Attributes inherited from GridforceFullBaseGrid
FILE *	poten_fp

float *	grid

GridforceFullSubGrid **	subgrids

int	numSubgrids

int	generation

int	k [3]

int	k_nopad [3]

long int	size

long int	size_nopad

long int	dk [3]

long int	dk_nopad [3]

float	factor

Position	origin

Position	center

Tensor	e

Tensor	inv

double	p_sum [3]

double	n_sum [3]

double	pad_p [3]

double	pad_n [3]

Bool	cont [3]

float	offset [3]

float	gap [3]

float	gapinv [3]

Vector	scale

Bool	checksize

Friends
class	GridforceFullBaseGrid

class	GridforceFullMainGrid

Detailed Description

Definition at line 242 of file GridForceGrid.h.

Constructor & Destructor Documentation

GridforceFullSubGrid::GridforceFullSubGrid ( GridforceFullBaseGrid * parent_in )

Definition at line 901 of file GridForceGrid.C.

References DebugM, endi(), GridforceFullBaseGrid::generation, maingrid, parent, and GridforceFullBaseGrid::poten_fp.

                                                                            {
     parent = parent_in;
     poten_fp = parent->poten_fp;
     generation = parent->generation + 1;
     GridforceFullBaseGrid *tmp = parent;
     while (tmp->generation > 0) {
         tmp = ((GridforceFullSubGrid *)tmp)->parent;
     }
     maingrid = (GridforceFullMainGrid *)tmp;
     DebugM(4, "generation = " << generation << "\n" << endi);
 }

Member Function Documentation

void GridforceFullSubGrid::addToSubgridsFlat ( void )

protected

Definition at line 1151 of file GridForceGrid.C.

References addToSubgridsFlat(), DebugM, endi(), maingrid, GridforceFullBaseGrid::numSubgrids, subgridIdx, GridforceFullBaseGrid::subgrids, and GridforceFullMainGrid::subgrids_flat.

Referenced by addToSubgridsFlat(), and GridforceFullMainGrid::buildSubgridsFlat().

 {
     DebugM(4, "addToSubgridsFlat() called, subgridIdx = " << subgridIdx << ", maingrid->numSubgrids = " << maingrid->numSubgrids << "\n" << endi);
     maingrid->subgrids_flat[subgridIdx-1] = this;
     for (int i = 0; i < numSubgrids; i++) {
         subgrids[i]->addToSubgridsFlat();
     }
 }

void GridforceFullSubGrid::compute_b	(	float *	b,
		int *	inds,
		Vector	gapscale
	)		const

protectedvirtual

Implements GridforceFullBaseGrid.

Definition at line 1161 of file GridForceGrid.C.

 {
     for (int i0 = 0; i0 < 8; i0++) {
         int inds2[3];
         
         float voff = 0.0;
         int bit = 1;    // bit = 2^i1 in the below loop
         for (int i1 = 0; i1 < 3; i1++) {
             inds2[i1] = (inds[i1] + ((i0 & bit) ? 1 : 0)) % k[i1];
             
             // Deal with voltage offsets
             if (cont[i1] && inds[i1] == (k[i1]-1) && inds2[i1] == 0) {
                 voff += offset[i1];
                 DebugM(3, "offset[" << i1 << "] = " << offset[i1] << "\n" << endi);
             }
             
             bit <<= 1;  // i.e. multiply by 2
         }
         
         DebugM(3, "inds2 = " << inds2[0] << " " << inds2[1] << " " << inds2[2] << "\n" << endi);
         
         int d_hi[3] = {1, 1, 1}; 
         int d_lo[3] = {1, 1, 1};
         float voffs[3];
         float dscales[3] = {0.5, 0.5, 0.5};
         for (int i1 = 0; i1 < 3; i1++) {
             if (inds2[i1] == 0 && cont[i1]) {
                 d_lo[i1] = -(k[i1]-1);
                 voffs[i1] = offset[i1];
                 dscales[i1] = 1.0/(1.0 + gap[i1]) * 1.0/gapscale[i1];
             }
             else if (inds2[i1] == k[i1]-1 && cont[i1]) {
                 d_hi[i1] = -(k[i1]-1);
                 voffs[i1] = offset[i1];
                 dscales[i1] = 1.0/(1.0 + gap[i1]) * 1.0/gapscale[i1];
             }
             else {
                 voffs[i1] = 0.0;
             }
         }
         
         bool edge = false;
         for (int i1 = 0; i1 < 3; i1++) {
             if (!cont[i1] && (inds2[i1] == 0 || inds2[i1] == k[i1]-1)) {
                 edge = true;
             }
         }
         
         if (inds2[2] == 0) {
 //          DebugM(3, "cont = " << cont[0] << " " << cont[1] << " " << cont[2] << " d_hi = " << d_hi[0] << " " << d_hi[1] << " " << d_hi[2] << " d_lo = " << d_lo[0] << " " << d_lo[1] << " " << d_lo[2] << " dscales = " << dscales[0] << " " << dscales[1] << " " << dscales[2] << "\n" << endi);
             DebugM(3, "cont = " << cont[0] << " " << cont[1] << " " << cont[2] << "\n" << endi);
         }
         
         if (edge) {
             DebugM(2, "Edge!\n" << endi);
             
             // Must get derivatives from parent
             Position pos = e * Vector(inds2[0], inds2[1], inds2[2]) + origin;   // Gridpoint position in realspace
             Vector g = parent->inv * (pos - parent->origin);    // Gridpoint position in parent's gridspace
             Vector dg;
             int inds3[3];
             
             DebugM(2, "g = " << g << "\n" << endi);
             
             for (int i = 0; i < 3; i++) {
                 inds3[i] = (int)floor(g[i]);
                 dg[i] = g[i] - inds3[i];
             }
     
             float x[4], y[4], z[4];
             x[0] = 1; y[0] = 1; z[0] = 1;
             for (int j = 1; j < 4; j++) {
                 x[j] = x[j-1] * dg.x;
                 y[j] = y[j-1] * dg.y;
                 z[j] = z[j-1] * dg.z;
                 DebugM(1, "x[" << j << "] = " << x[j] << "\n");
                 DebugM(1, "y[" << j << "] = " << y[j] << "\n");
                 DebugM(1, "z[" << j << "] = " << z[j] << "\n" << endi);
             }
             
             // Compute parent matrices
             float b_parent[64];
             parent->compute_b(b_parent, inds3, gapscale);
             
             float a_parent[64];
             parent->compute_a(a_parent, b_parent);
             
             // Compute parent derivatives
             float V = parent->compute_V(a_parent, x, y, z);
             Vector dV = scale_dV * parent->compute_dV(a_parent, x, y, z);
             Vector d2V = scale_d2V * parent->compute_d2V(a_parent, x, y, z);
             float d3V = scale_d3V * parent->compute_d3V(a_parent, x, y, z);
             
             b[i0] = V;
             b[8+i0] = dV[0];
             b[16+i0] = dV[1];
             b[24+i0] = dV[2];
             b[32+i0] = d2V[0];
             b[40+i0] = d2V[1];
             b[48+i0] = d2V[2];
             b[56+i0] = d3V;
         } else {
             b[i0] = get_grid(inds2[0],inds2[1],inds2[2]) + voff;        // V
             
             b[8+i0]  = dscales[0] * (get_grid_d(inds2[0]+d_hi[0],inds2[1],inds2[2]) - get_grid_d(inds2[0]-d_lo[0],inds2[1],inds2[2]) + voffs[0]);       //  dV/dx
             b[16+i0] = dscales[1] * (get_grid_d(inds2[0],inds2[1]+d_hi[1],inds2[2]) - get_grid_d(inds2[0],inds2[1]-d_lo[1],inds2[2]) + voffs[1]);       //  dV/dy
             b[24+i0] = dscales[2] * (get_grid_d(inds2[0],inds2[1],inds2[2]+d_hi[2]) - get_grid_d(inds2[0],inds2[1],inds2[2]-d_lo[2]) + voffs[2]);       //  dV/dz
             b[32+i0] = dscales[0] * dscales[1]
                 * (get_grid_d(inds2[0]+d_hi[0],inds2[1]+d_hi[1],inds2[2]) - get_grid_d(inds2[0]-d_lo[0],inds2[1]+d_hi[1],inds2[2]) -
                    get_grid_d(inds2[0]+d_hi[0],inds2[1]-d_lo[1],inds2[2]) + get_grid_d(inds2[0]-d_lo[0],inds2[1]-d_lo[1],inds2[2]));    //  d2V/dxdy
             b[40+i0] = dscales[0] * dscales[2]
                 * (get_grid_d(inds2[0]+d_hi[0],inds2[1],inds2[2]+d_hi[2]) - get_grid_d(inds2[0]-d_lo[0],inds2[1],inds2[2]+d_hi[2]) -
                    get_grid_d(inds2[0]+d_hi[0],inds2[1],inds2[2]-d_lo[2]) + get_grid_d(inds2[0]-d_lo[0],inds2[1],inds2[2]-d_lo[2]));    //  d2V/dxdz
             b[48+i0] = dscales[1] * dscales[2]
                 * (get_grid_d(inds2[0],inds2[1]+d_hi[1],inds2[2]+d_hi[2]) - get_grid_d(inds2[0],inds2[1]-d_lo[1],inds2[2]+d_hi[2]) -
                    get_grid_d(inds2[0],inds2[1]+d_hi[1],inds2[2]-d_lo[2]) + get_grid_d(inds2[0],inds2[1]-d_lo[1],inds2[2]-d_lo[2]));    //  d2V/dydz
         
             b[56+i0] = dscales[0] * dscales[1] * dscales[2]                                     // d3V/dxdydz
                 * (get_grid_d(inds2[0]+d_hi[0],inds2[1]+d_hi[1],inds2[2]+d_hi[2]) - get_grid_d(inds2[0]+d_hi[0],inds2[1]+d_hi[1],inds2[2]-d_lo[2]) -
                    get_grid_d(inds2[0]+d_hi[0],inds2[1]-d_lo[1],inds2[2]+d_hi[2]) - get_grid_d(inds2[0]-d_lo[0],inds2[1]+d_hi[1],inds2[2]+d_hi[2]) +
                    get_grid_d(inds2[0]+d_hi[0],inds2[1]-d_lo[1],inds2[2]-d_lo[2]) + get_grid_d(inds2[0]-d_lo[0],inds2[1]+d_hi[1],inds2[2]-d_lo[2]) +
                    get_grid_d(inds2[0]-d_lo[0],inds2[1]-d_lo[1],inds2[2]+d_hi[2]) - get_grid_d(inds2[0]-d_lo[0],inds2[1]-d_lo[1],inds2[2]-d_lo[2]));
         }
         
         if (inds2[0] == 1 && inds2[1] == 1 && inds2[2] == 0) {
             DebugM(1, "Sub V = " << b[i0] << "\n");
         
             DebugM(1, "Sub dV/dx = " << b[8+i0] << "\n");
             DebugM(1, "Sub dV/dy = " << b[16+i0] << "\n");
             DebugM(1, "Sub dV/dz = " << b[24+i0] << "\n");
         
             DebugM(1, "Sub d2V/dxdy = " << b[32+i0] << "\n");
             DebugM(1, "Sub d2V/dxdz = " << b[40+i0] << "\n");
             DebugM(1, "Sub d2V/dydz = " << b[48+i0] << "\n");
         
             DebugM(1, "Sub d3V/dxdydz = " << b[56+i0] << "\n" << endi);
         }
     }
 }

int GridforceFullSubGrid::get_border ( void ) const

inlinevirtual

Implements GridforceFullBaseGrid.

Definition at line 251 of file GridForceGrid.h.

251 { return 0; }

void GridforceFullSubGrid::initialize	(	SimParameters *	simParams,
		MGridforceParams *	mgridParams
	)

Definition at line 914 of file GridForceGrid.C.

Referenced by GridforceFullMainGrid::initialize(), and initialize().

 {
     int tmp;
     char line[256];
     long int poten_offset;
     
     // Skip 'attribute's
     DebugM(3, "Skipping 'attribute' keywords...\n" << endi);
     char str[256];
     do {
         poten_offset = ftell(poten_fp);
         fscanf(poten_fp, "%s", str);
         fgets(line, 256, poten_fp);
         DebugM(4, "Read line " << str << " " << line << endi);
     } while (strcmp(str, "attribute") == 0);
     fseek(poten_fp, poten_offset, SEEK_SET);
     
     // Skip 'field' object
     DebugM(3, "Skipping 'field' object\n" << endi);
     fscanf(poten_fp, "object");
     int n;
     n = fscanf(poten_fp, "\"%[^\"]\" class field\n", str);
     if (n == 0) {
         n = fscanf(poten_fp, "%d class field\n", &tmp);
     }
     
     if (n == 0) {
         NAMD_die("Error reading gridforce grid! Could not find field object!\n");
     }
     
     // Skip 'component's
     DebugM(3, "Skipping 'component' keywords\n" << endi);
     do {
         poten_offset = ftell(poten_fp);
         fscanf(poten_fp, "%s", str);
         fgets(line, 256, poten_fp);
     } while (strcmp(str, "component") == 0);
     fseek(poten_fp, poten_offset, SEEK_SET);
     
     // Read header
     readHeader(simParams, mgridParams);
     
     factor = 1.0;
     if (mgridParams->gridforceVolts)
     {
         factor /= 0.0434;  // convert V -> kcal/mol*e
     }
     scale = mgridParams->gridforceScale;
     checksize = mgridParams->gridforceCheckSize;
     
     for (int i = 0; i < 3; i++) {
         k[i] = k_nopad[i];      // subgrids aren't padded
     }
     
     // Make sure that each subgrid dimension is an integral
     // number of spanned supergrid cells. This is to ensure that no
     // supergrid nodes land in the middle of a subgrid, because in
     // this case forces could not be matched properly.
     for (int i = 0; i < 3; i++) {
         if ((k[i] - 1) % (pmax[i] - pmin[i] + 1) != 0) {
             iout << (k[i] - 1) << " % " << (pmax[i] - pmin[i] + 1) << " != 0\n" << endi;
             NAMD_die("Error reading gridforce grid! Subgrid dimensions must be an integral number spanned parent cells!");
         }
     }
     
     for (int i = 0; i < 3; i++) {
         if (parent->cont[i]) {
             cont[i] = (pmin[i] == 0 && pmax[i] == parent->k[i]-2) ? TRUE : FALSE;
             DebugM(3, "pmin[" << i << "] = " << pmin[i] << " pmax[" << i << "] = " << pmax[i] << " parent->k[" << i << "] = " << parent->k[i] << " cont[" << i << "] = " << cont[i] << "\n" << endi);
         } else {
             cont[i] = false;
             if (parent->generation == 0) {
                 // Add to pmin, pmax since parent got extra gridpoint layer(s) (maybe)
                 int brd = parent->get_border();
                 pmin[i] += brd;
                 pmax[i] += brd;
             }
         }               
     }
     
     DebugM(4, "pmin = " << pmin[0] << " " << pmin[1] << " " << pmin[2] << "\n");
     DebugM(4, "pmax = " << pmax[0] << " " << pmax[1] << " " << pmax[2] << "\n" << endi);
     
     Vector origin2 = parent->origin + parent->e * Position(pmin[0], pmin[1], pmin[2]);
     Vector escale, invscale;
     for (int i = 0; i < 3; i++) {
         escale[i] = double(pmax[i] - pmin[i] + 1)/(k[i]-1);
         invscale[i] = 1.0/escale[i];
         if (cont[i]) { pmax[i]++; }
     }
     Tensor e2 = tensorMult(parent->e, Tensor::diagonal(escale));
     
     // Check that lattice parameters agree with min and max numbers
     // from subgrid hierarchy.
     double TOL2 = 1e-4; // Totally arbitrary
     if (pow(origin2.x-origin.x, 2) > TOL2 ||
         pow(origin2.y-origin.y, 2) > TOL2 ||
         pow(origin2.z-origin.z, 2) > TOL2 ||
         pow(e2.xx-e.xx, 2) > TOL2 ||
         pow(e2.xy-e.xy, 2) > TOL2 ||
         pow(e2.xz-e.xz, 2) > TOL2 ||
         pow(e2.yx-e.yx, 2) > TOL2 ||
         pow(e2.yy-e.yy, 2) > TOL2 ||
         pow(e2.yz-e.yz, 2) > TOL2 ||
         pow(e2.zx-e.zx, 2) > TOL2 ||
         pow(e2.zy-e.zy, 2) > TOL2 ||
         pow(e2.zz-e.zz, 2) > TOL2)
     {
         NAMD_die("Error reading gridforce grid! Subgrid lattice does not match!");
     }
     
     // Overwrite what was read from the header
     origin = origin2;
     e = e2;
     
     inv = tensorMult(Tensor::diagonal(invscale), parent->inv);
     for (int i = 0; i < 3; i++) {
         gap[i] = escale[i] * parent->gap[i];
         gapinv[i] = invscale[i] * parent->gapinv[i];
         offset[i] = parent->offset[i];
     }
     center = origin + e * 0.5 * Position(k[0], k[1], k[2]);
     
     DebugM(4, "origin = " << origin << "\n");
     DebugM(4, "e = " << e << "\n");
     DebugM(4, "inv = " << inv << "\n");
     DebugM(4, "gap = " << gap[0] << " " << gap[2] << " " << gap[2] << " " << "\n");
     DebugM(4, "gapinv = " << gapinv[0] << " " << gapinv[2] << " " << gapinv[2] << " " << "\n");
     DebugM(4, "numSubgrids = " << numSubgrids << "\n");
     DebugM(4, "k = " << k[0] << " " << k[1] << " " << k[2] << "\n");
     DebugM(4, "escale = " << escale << "\n");
     DebugM(4, "invscale = " << invscale << "\n" << endi);
     
     /*** Set members ***/
     size = k[0] * k[1] * k[2];
     dk[0] = k[1] * k[2];
     dk[1] = k[2];
     dk[2] = 1;
     
     scale_dV = Tensor::diagonal(escale);
     scale_d2V = Tensor::diagonal(Vector(escale.x*escale.y, escale.x*escale.z, escale.y*escale.z));
     scale_d3V = escale.x * escale.y * escale.z;
     
     DebugM(4, "scale_dV = " << scale_dV << "\n");
     DebugM(4, "scale_d2V = " << scale_d2V << "\n");
     DebugM(4, "scale_d3V = " << scale_d3V << "\n" << endi);
     
     // Allocate storage for potential and read it
     float *grid_tmp = new float[size];
     
     float tmp2;
     DebugM(3, "size_nopad = " << size_nopad << "\n");
     for (long int count = 0; count < size_nopad; count++) {
 //      poten_offset = ftell(poten_fp);
 //      fscanf(poten_fp, "%s", str);
 //      fgets(line, 256, poten_fp);
 //      DebugM(4, "Read line " << str << " " << line << endi);
 //      fseek(poten_fp, poten_offset, SEEK_SET);
         
         int err = fscanf(poten_fp, "%f", &tmp2);
         if (err == EOF || err == 0) {
             NAMD_die("Grid force potential file incorrectly formatted");
         }
         grid_tmp[count] = tmp2 * factor;
     }
     fscanf(poten_fp, "\n");
     
     // Set real grid
     DebugM(3, "allocating grid\n" << endi);
     delete[] grid;
     grid = new float[size];
     for (int i0 = 0; i0 < k_nopad[0]; i0++) {
         for (int i1 = 0; i1 < k_nopad[1]; i1++) {
             for (int i2 = 0; i2 < k_nopad[2]; i2++) {
                 long int ind = i0*dk[0] + i1*dk[1] + i2*dk[2];
                 set_grid(i0, i1, i2, grid_tmp[ind]);
             }
         }
     }
     
     for (int i0 = 0; i0 < k[0]; i0++) {
         for (int i1 = 0; i1 < k[1]; i1++) {
             for (int i2 = 0; i2 < k[2]; i2++) {
                 DebugM(1, "grid[" << i0 << ", " << i1 << ", " << i2 << "] = " << get_grid(i0,i1,i2) << "\n" << endi);
             }
         }
     }
     
     // Clean up
     delete[] grid_tmp;
     
     // Call initialize for each subgrid
     for (int i = 0; i < numSubgrids; i++) {
         subgrids[i]->initialize(simParams, mgridParams);
     }
 }

void GridforceFullSubGrid::pack ( MOStream * msg ) const

protectedvirtual

Reimplemented from GridforceFullBaseGrid.

Definition at line 1112 of file GridForceGrid.C.

References DebugM, endi(), GridforceFullBaseGrid::pack(), pmax, pmin, MOStream::put(), scale_d2V, scale_d3V, scale_dV, and subgridIdx.

Referenced by GridforceFullBaseGrid::pack().

 {
     DebugM(4, "Packing subgrid\n" << endi);
     
     msg->put(sizeof(Tensor), (char*)&scale_dV);
     msg->put(sizeof(Tensor), (char*)&scale_d2V);
     msg->put(sizeof(float), (char*)&scale_d3V);
     
     msg->put(3*sizeof(int), (char*)pmin);
     msg->put(3*sizeof(int), (char*)pmax);
     msg->put(subgridIdx);
     
     DebugM(3, "calling GridforceFullBaseGrid::pack\n" << endi);
     
     GridforceFullBaseGrid::pack(msg);
 }

Tensor GridforceFullSubGrid::tensorMult	(	const Tensor &	t1,
		const Tensor &	t2
	)

inline

Definition at line 253 of file GridForceGrid.h.

References Tensor::xx, Tensor::xy, Tensor::xz, Tensor::yx, Tensor::yy, Tensor::yz, Tensor::zx, Tensor::zy, and Tensor::zz.

Referenced by initialize().

                                                                   {
         Tensor tmp;
         tmp.xx = t1.xx * t2.xx + t1.xy * t2.yx + t1.xz * t2.zx;
         tmp.xy = t1.xx * t2.xy + t1.xy * t2.yy + t1.xz * t2.zy;
         tmp.xz = t1.xx * t2.xz + t1.xy * t2.yz + t1.xz * t2.zz;
         tmp.yx = t1.yx * t2.xx + t1.yy * t2.yx + t1.yz * t2.zx;
         tmp.yy = t1.yx * t2.xy + t1.yy * t2.yy + t1.yz * t2.zy;
         tmp.yz = t1.yx * t2.xz + t1.yy * t2.yz + t1.yz * t2.zz;
         tmp.zx = t1.zx * t2.xx + t1.zy * t2.yx + t1.zz * t2.zx;
         tmp.zy = t1.zx * t2.xy + t1.zy * t2.yy + t1.zz * t2.zy;
         tmp.zz = t1.zx * t2.xz + t1.zy * t2.yz + t1.zz * t2.zz;
         return tmp;
     }

void GridforceFullSubGrid::unpack ( MIStream * msg )

protectedvirtual

Reimplemented from GridforceFullBaseGrid.

Definition at line 1130 of file GridForceGrid.C.

References DebugM, endi(), GridforceFullBaseGrid::gapinv, GridforceFullBaseGrid::generation, MIStream::get(), GridforceFullBaseGrid::numSubgrids, pmax, pmin, scale_d2V, scale_d3V, scale_dV, GridforceFullBaseGrid::size, subgridIdx, and GridforceFullBaseGrid::unpack().

Referenced by GridforceFullBaseGrid::unpack().

 {
     DebugM(4, "Unpacking subgrid\n" << endi);
     
     msg->get(sizeof(Tensor), (char*)&scale_dV);
     msg->get(sizeof(Tensor), (char*)&scale_d2V);
     msg->get(sizeof(float), (char*)&scale_d3V);
     
     msg->get(3*sizeof(int), (char*)pmin);
     msg->get(3*sizeof(int), (char*)pmax);
     msg->get(subgridIdx);
     
     GridforceFullBaseGrid::unpack(msg);
     
     DebugM(4, "size  = " << size << "\n");
     DebugM(4, "numSubgrids = " << numSubgrids << "\n");
     DebugM(4, "gapinv = " << gapinv[0] << " " << gapinv[2] << " " << gapinv[2] << " " << "\n");
     DebugM(4, "generation = " << generation << "\n" << endi);
 }