GridforceFullSubGrid Class Reference

#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
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 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 Attributes
Tensor	scale_dV
Tensor	scale_d2V
float	scale_d3V
GridforceFullBaseGrid *	parent
int	pmin [3]
int	pmax [3]
GridforceFullMainGrid *	maingrid
int	subgridIdx

Friends
class	GridforceFullBaseGrid
class	GridforceFullMainGrid

Additional Inherited Members
Public 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

Detailed Description

Definition at line 241 of file GridForceGrid.h.

Constructor & Destructor Documentation

GridforceFullSubGrid()

GridforceFullSubGrid::GridforceFullSubGrid

(

GridforceFullBaseGrid *

parent_in

)

Definition at line 900 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

addToSubgridsFlat()

void GridforceFullSubGrid::addToSubgridsFlat ( void  )

protected

Definition at line 1150 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();
    }
}

compute_b()

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

protectedvirtual

Implements GridforceFullBaseGrid.

Definition at line 1160 of file GridForceGrid.C.

References GridforceFullBaseGrid::compute_a(), GridforceFullBaseGrid::compute_b(), GridforceFullBaseGrid::compute_d2V(), GridforceFullBaseGrid::compute_d3V(), GridforceFullBaseGrid::compute_dV(), GridforceFullBaseGrid::compute_V(), GridforceFullBaseGrid::cont, DebugM, GridforceFullBaseGrid::e, endi(), GridforceFullBaseGrid::gap, GridforceFullBaseGrid::get_grid(), GridforceFullBaseGrid::get_grid_d(), GridforceFullBaseGrid::inv, GridforceFullBaseGrid::k, GridforceFullBaseGrid::offset, GridforceFullBaseGrid::origin, parent, scale_d2V, scale_d3V, scale_dV, Vector::x, Vector::y, and Vector::z.

{
    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);
        }
    }
}

get_border()

int GridforceFullSubGrid::get_border ( void  ) const

inlinevirtual

Implements GridforceFullBaseGrid.

Definition at line 250 of file GridForceGrid.h.

{ return 0; }

initialize()

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

Definition at line 913 of file GridForceGrid.C.

References GridforceFullBaseGrid::center, GridforceFullBaseGrid::checksize, GridforceFullBaseGrid::cont, DebugM, Tensor::diagonal(), GridforceFullBaseGrid::dk, GridforceFullBaseGrid::e, endi(), GridforceFullBaseGrid::factor, FALSE, GridforceFullBaseGrid::gap, GridforceFullBaseGrid::gapinv, GridforceFullBaseGrid::generation, GridforceFullBaseGrid::get_border(), GridforceFullBaseGrid::get_grid(), GridforceFullBaseGrid::grid, MGridforceParams::gridforceCheckSize, MGridforceParams::gridforceScale, MGridforceParams::gridforceVolts, initialize(), GridforceFullBaseGrid::inv, iout, GridforceFullBaseGrid::k, GridforceFullBaseGrid::k_nopad, NAMD_die(), GridforceFullBaseGrid::numSubgrids, GridforceFullBaseGrid::offset, GridforceFullBaseGrid::origin, parent, pmax, pmin, GridforceFullBaseGrid::poten_fp, GridforceFullBaseGrid::readHeader(), GridforceFullBaseGrid::scale, scale_d2V, scale_d3V, scale_dV, GridforceFullBaseGrid::set_grid(), simParams, GridforceFullBaseGrid::size, GridforceFullBaseGrid::size_nopad, GridforceFullBaseGrid::subgrids, tensorMult(), TRUE, Vector::x, Tensor::xx, Tensor::xy, Tensor::xz, Vector::y, Tensor::yx, Tensor::yy, Tensor::yz, Vector::z, Tensor::zx, Tensor::zy, and Tensor::zz.

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);
    }
}

pack()

void GridforceFullSubGrid::pack ( MOStream *  msg ) const

protectedvirtual

Reimplemented from GridforceFullBaseGrid.

Definition at line 1111 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);
}

tensorMult()

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

inline

Definition at line 252 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;
    }

unpack()

void GridforceFullSubGrid::unpack ( MIStream *  msg )

protectedvirtual

Reimplemented from GridforceFullBaseGrid.

Definition at line 1129 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);
}

Friends And Related Function Documentation

GridforceFullBaseGrid

friend class GridforceFullBaseGrid

friend

Definition at line 242 of file GridForceGrid.h.

GridforceFullMainGrid

friend class GridforceFullMainGrid

friend

Definition at line 243 of file GridForceGrid.h.

Member Data Documentation

maingrid

GridforceFullMainGrid* GridforceFullSubGrid::maingrid

protected

Definition at line 281 of file GridForceGrid.h.

Referenced by addToSubgridsFlat(), and GridforceFullSubGrid().

parent

GridforceFullBaseGrid* GridforceFullSubGrid::parent

protected

Definition at line 279 of file GridForceGrid.h.

Referenced by compute_b(), GridforceFullSubGrid(), and initialize().

pmax

int GridforceFullSubGrid::pmax[3]

protected

Definition at line 280 of file GridForceGrid.h.

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

pmin

int GridforceFullSubGrid::pmin[3]

protected

Definition at line 280 of file GridForceGrid.h.

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

scale_d2V

Tensor GridforceFullSubGrid::scale_d2V

protected

Definition at line 276 of file GridForceGrid.h.

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

scale_d3V

float GridforceFullSubGrid::scale_d3V

protected

Definition at line 277 of file GridForceGrid.h.

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

scale_dV

Tensor GridforceFullSubGrid::scale_dV

protected

Definition at line 275 of file GridForceGrid.h.

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

subgridIdx

int GridforceFullSubGrid::subgridIdx

protected

Definition at line 282 of file GridForceGrid.h.

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

---

The documentation for this class was generated from the following files:

• GridForceGrid.h
• GridForceGrid.C