Public Member Functions
AtomCoordArray &	coordArray ()

ForceArray &	forceArray ()

	PatchData (ComputeMsmMgr *pmgr, int pid)

void	init (int natoms)

void	anterpolation ()

void	sendCharge ()

void	addPotential (const Grid< Float > &epart)

void	interpolation ()

void	anterpolationC1Hermite ()

void	sendChargeC1Hermite ()

void	addPotentialC1Hermite (const Grid< C1Vector > &epart)

void	interpolationC1Hermite ()

Public Attributes
ComputeMsmMgr *	mgr

Map *	map

PatchDiagram *	pd

AtomCoordArray	coord

ForceArray	force

Grid< Float >	qh

Grid< Float >	eh

Grid< Float >	subgrid

Grid< C1Vector >	qh_c1hermite

Grid< C1Vector >	eh_c1hermite

Grid< C1Vector >	subgrid_c1hermite

BigReal	energy

int	cntRecvs

int	patchID

int	sequence

Detailed Description

Definition at line 1738 of file ComputeMsm.C.

Constructor & Destructor Documentation

msm::PatchData::PatchData	(	ComputeMsmMgr *	pmgr,
		int	pid
	)

Definition at line 6227 of file ComputeMsm.C.

References ComputeMsmMgr::approx, msm::Map::bsx, msm::Map::bsy, msm::Map::bsz, ComputeMsmMgr::C1HERMITE, eh, eh_c1hermite, msm::Grid< T >::init(), map, ComputeMsmMgr::mapData(), mgr, msm::PatchDiagram::nrange, patchID, msm::Map::patchList, pd, qh, qh_c1hermite, msm::Grid< T >::resize(), subgrid, and subgrid_c1hermite.

                                                    {
     mgr = pmgr;
     map = &(mgr->mapData());
     patchID = pid;
     //PatchMap *pm = PatchMap::Object();
     pd = &(map->patchList[pid]);
     if (mgr->approx == ComputeMsmMgr::C1HERMITE) {
       qh_c1hermite.init(pd->nrange);
       eh_c1hermite.init(pd->nrange);
       subgrid_c1hermite.resize(map->bsx[0] * map->bsy[0] * map->bsz[0]);
     }
     else {
       qh.init(pd->nrange);
       eh.init(pd->nrange);
       subgrid.resize(map->bsx[0] * map->bsy[0] * map->bsz[0]);
     }
 #ifdef MSM_TIMING
     mgr->addTiming();
 #endif
   }

Member Function Documentation

void msm::PatchData::addPotential ( const Grid< Float > & epart )

Definition at line 6402 of file ComputeMsm.C.

References cntRecvs, MsmTimer::COMM, eh, interpolation(), mgr, msm::PatchDiagram::numRecvs, and pd.

                                                        {
 #ifdef MSM_TIMING
     double startTime, stopTime;
     startTime = CkWallTimer();
 #endif
     eh += epart;
 #ifdef MSM_TIMING
     stopTime = CkWallTimer();
     mgr->msmTiming[MsmTimer::COMM] += stopTime - startTime;
 #endif
     if (++cntRecvs == pd->numRecvs) {
       interpolation();
     }
   }

void msm::PatchData::addPotentialC1Hermite ( const Grid< C1Vector > & epart )

Definition at line 6678 of file ComputeMsm.C.

References cntRecvs, MsmTimer::COMM, eh_c1hermite, interpolationC1Hermite(), mgr, msm::PatchDiagram::numRecvs, and pd.

                                                                    {
 #ifdef MSM_TIMING
     double startTime, stopTime;
     startTime = CkWallTimer();
 #endif
     eh_c1hermite += epart;
 #ifdef MSM_TIMING
     stopTime = CkWallTimer();
     mgr->msmTiming[MsmTimer::COMM] += stopTime - startTime;
 #endif
     if (++cntRecvs == pd->numRecvs) {
       interpolationC1Hermite();
     }
   }

void msm::PatchData::anterpolation ( )

Definition at line 6265 of file ComputeMsm.C.

                                 {
 #ifdef DEBUG_MSM_GRID
     printf("patchID %d:  anterpolation\n", patchID);
 #endif
 
 #ifdef MSM_TIMING
     double startTime, stopTime;
     startTime = CkWallTimer();
 #endif
 #ifndef MSM_COMM_ONLY
     Float xphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
     Float yphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
     Float zphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
 
     const Double rs_edge = Double( mgr->s_edge );
     const int s_size = ComputeMsmMgr::PolyDegree[mgr->approx] + 1;
 
     const int ia = qh.ia();
     const int ib = qh.ib();
     const int ja = qh.ja();
     const int jb = qh.jb();
     const int ka = qh.ka();
     const int kb = qh.kb();
     const int ni = qh.ni();
     const int nj = qh.nj();
     Float *qhbuffer = qh.data().buffer();
 
     // loop over atoms
     for (int n = 0;  n < coord.len();  n++) {
       Float q = coord[n].charge;
       if (0==q) continue;
 
       ScaledPosition s = mgr->lattice.scale(coord[n].position);
 
       BigReal sx_hx = (s.x - mgr->sglower.x) * mgr->shx_1;
       BigReal sy_hy = (s.y - mgr->sglower.y) * mgr->shy_1;
       BigReal sz_hz = (s.z - mgr->sglower.z) * mgr->shz_1;
 
       BigReal xlo = floor(sx_hx) - rs_edge;
       BigReal ylo = floor(sy_hy) - rs_edge;
       BigReal zlo = floor(sz_hz) - rs_edge;
 
       // calculate Phi stencils along each dimension
       Float xdelta = Float(sx_hx - xlo);
       mgr->stencil_1d(xphi, xdelta);
       Float ydelta = Float(sy_hy - ylo);
       mgr->stencil_1d(yphi, ydelta);
       Float zdelta = Float(sz_hz - zlo);
       mgr->stencil_1d(zphi, zdelta);
 
       int ilo = int(xlo);
       int jlo = int(ylo);
       int klo = int(zlo);
 
       // test to see if stencil is within edges of grid
       int iswithin = ( ia <= ilo && (ilo+(s_size-1)) <= ib &&
                        ja <= jlo && (jlo+(s_size-1)) <= jb &&
                        ka <= klo && (klo+(s_size-1)) <= kb );
 
       if ( ! iswithin ) {
 #if 0
         printf("PE %d:  atom %d:  pos= %g %g %g  patchID=%d\n",
             CkMyPe(), coord[n].id,
             coord[n].position.x, coord[n].position.y, coord[n].position.z,
             patchID);
         printf("PE %d:  atom subgrid [%d..%d] x [%d..%d] x [%d..%d]\n",
             CkMyPe(),
             ilo, ilo+s_size-1, jlo, jlo+s_size-1, klo, klo+s_size-1);
         printf("PE %d:  patch grid [%d..%d] x [%d..%d] x [%d..%d]\n",
             CkMyPe(),
             ia, ib, ja, jb, ka, kb);
 #endif
         char msg[100];
         snprintf(msg, sizeof(msg), "Atom %d is outside of the MSM grid.",
             coord[n].id);
         NAMD_die(msg);
       }
 
       // determine charge on cube of grid points around atom
       for (int k = 0;  k < s_size;  k++) {
         int koff = ((k+klo) - ka) * nj;
         Float ck = zphi[k] * q;
         for (int j = 0;  j < s_size;  j++) {
           int jkoff = (koff + (j+jlo) - ja) * ni;
           Float cjk = yphi[j] * ck;
           for (int i = 0;  i < s_size;  i++) {
             int ijkoff = jkoff + (i+ilo) - ia;
             qhbuffer[ijkoff] += xphi[i] * cjk;
           }
         }
       }
 
     } // end loop over atoms
 #endif // !MSM_COMM_ONLY
 #ifdef MSM_TIMING
     stopTime = CkWallTimer();
     mgr->msmTiming[MsmTimer::ANTERP] += stopTime - startTime;
 #endif
 
     sendCharge();
   }

void msm::PatchData::anterpolationC1Hermite ( )

Definition at line 6543 of file ComputeMsm.C.

References MsmTimer::ANTERP, msm::Array< T >::buffer(), coord, D000, D001, D010, D011, D100, D101, D110, D111, msm::Grid< T >::data(), ComputeMsmMgr::hxlen, ComputeMsmMgr::hylen, ComputeMsmMgr::hzlen, msm::IndexRange::ia(), msm::IndexRange::ib(), msm::IndexRange::ja(), msm::IndexRange::jb(), msm::IndexRange::ka(), msm::IndexRange::kb(), ComputeMsmMgr::lattice, msm::Array< T >::len(), mgr, NAMD_die(), msm::IndexRange::ni(), msm::IndexRange::nj(), patchID, qh_c1hermite, Lattice::scale(), sendChargeC1Hermite(), ComputeMsmMgr::sglower, ComputeMsmMgr::shx_1, ComputeMsmMgr::shy_1, ComputeMsmMgr::shz_1, ComputeMsmMgr::stencil_1d_c1hermite(), C1Vector::velem, Vector::x, Vector::y, and Vector::z.

                                          {
 #ifdef DEBUG_MSM_GRID
     printf("patchID %d:  anterpolationC1Hermite\n", patchID);
 #endif
 
 #ifdef MSM_TIMING
     double startTime, stopTime;
     startTime = CkWallTimer();
 #endif
 #ifndef MSM_COMM_ONLY
     Float xphi[2], xpsi[2];
     Float yphi[2], ypsi[2];
     Float zphi[2], zpsi[2];
 
     const Float hx = Float(mgr->hxlen);  // real space grid spacing
     const Float hy = Float(mgr->hylen);
     const Float hz = Float(mgr->hzlen);
 
     const int ia = qh_c1hermite.ia();
     const int ib = qh_c1hermite.ib();
     const int ja = qh_c1hermite.ja();
     const int jb = qh_c1hermite.jb();
     const int ka = qh_c1hermite.ka();
     const int kb = qh_c1hermite.kb();
     const int ni = qh_c1hermite.ni();
     const int nj = qh_c1hermite.nj();
     C1Vector *qhbuffer = qh_c1hermite.data().buffer();
 
     // loop over atoms
     for (int n = 0;  n < coord.len();  n++) {
       Float q = coord[n].charge;
       if (0==q) continue;
 
       ScaledPosition s = mgr->lattice.scale(coord[n].position);
 
       BigReal sx_hx = (s.x - mgr->sglower.x) * mgr->shx_1;
       BigReal sy_hy = (s.y - mgr->sglower.y) * mgr->shy_1;
       BigReal sz_hz = (s.z - mgr->sglower.z) * mgr->shz_1;
 
       BigReal xlo = floor(sx_hx);
       BigReal ylo = floor(sy_hy);
       BigReal zlo = floor(sz_hz);
 
       // calculate Phi stencils along each dimension
       Float xdelta = Float(sx_hx - xlo);
       mgr->stencil_1d_c1hermite(xphi, xpsi, xdelta, hx);
       Float ydelta = Float(sy_hy - ylo);
       mgr->stencil_1d_c1hermite(yphi, ypsi, ydelta, hy);
       Float zdelta = Float(sz_hz - zlo);
       mgr->stencil_1d_c1hermite(zphi, zpsi, zdelta, hz);
 
       int ilo = int(xlo);
       int jlo = int(ylo);
       int klo = int(zlo);
 
       // test to see if stencil is within edges of grid
       int iswithin = ( ia <= ilo && ilo < ib &&
                        ja <= jlo && jlo < jb &&
                        ka <= klo && klo < kb );
 
       if ( ! iswithin ) {
         char msg[100];
         snprintf(msg, sizeof(msg), "Atom %d is outside of the MSM grid.",
             coord[n].id);
         NAMD_die(msg);
       }
 
       // determine charge on cube of grid points around atom
       for (int k = 0;  k < 2;  k++) {
         int koff = ((k+klo) - ka) * nj;
         Float c_zphi = zphi[k] * q;
         Float c_zpsi = zpsi[k] * q;
         for (int j = 0;  j < 2;  j++) {
           int jkoff = (koff + (j+jlo) - ja) * ni;
           Float c_yphi_zphi = yphi[j] * c_zphi;
           Float c_ypsi_zphi = ypsi[j] * c_zphi;
           Float c_yphi_zpsi = yphi[j] * c_zpsi;
           Float c_ypsi_zpsi = ypsi[j] * c_zpsi;
           for (int i = 0;  i < 2;  i++) {
             int ijkoff = jkoff + (i+ilo) - ia;
             qhbuffer[ijkoff].velem[D000] += xphi[i] * c_yphi_zphi;
             qhbuffer[ijkoff].velem[D100] += xpsi[i] * c_yphi_zphi;
             qhbuffer[ijkoff].velem[D010] += xphi[i] * c_ypsi_zphi;
             qhbuffer[ijkoff].velem[D001] += xphi[i] * c_yphi_zpsi;
             qhbuffer[ijkoff].velem[D110] += xpsi[i] * c_ypsi_zphi;
             qhbuffer[ijkoff].velem[D101] += xpsi[i] * c_yphi_zpsi;
             qhbuffer[ijkoff].velem[D011] += xphi[i] * c_ypsi_zpsi;
             qhbuffer[ijkoff].velem[D111] += xpsi[i] * c_ypsi_zpsi;
           }
         }
       }
 
     } // end loop over atoms
 
 #endif // !MSM_COMM_ONLY
 #ifdef MSM_TIMING
     stopTime = CkWallTimer();
     mgr->msmTiming[MsmTimer::ANTERP] += stopTime - startTime;
 #endif
 
     sendChargeC1Hermite();
   }

AtomCoordArray& msm::PatchData::coordArray ( )

inline

Definition at line 1756 of file ComputeMsm.C.

Referenced by ComputeMsm::doWork().

1756 { return coord; }

msm::PatchData::coord

AtomCoordArray coord

Definition: ComputeMsm.C:1742

ForceArray& msm::PatchData::forceArray ( )

inline

Definition at line 1757 of file ComputeMsm.C.

1757 { return force; }

msm::PatchData::force

ForceArray force

Definition: ComputeMsm.C:1743

void msm::PatchData::init ( int natoms )

Definition at line 6248 of file ComputeMsm.C.

References ComputeMsmMgr::approx, ComputeMsmMgr::C1HERMITE, cntRecvs, coord, eh, eh_c1hermite, energy, force, mgr, qh, qh_c1hermite, msm::Grid< T >::reset(), and msm::Array< T >::resize().

Referenced by ComputeMsm::doWork().

                                  {
     coord.resize(natoms);
     force.resize(natoms);
     cntRecvs = 0;
     energy = 0;
     //memset(virial, 0, 3*3*sizeof(BigReal));
     for (int i = 0;  i < natoms;  i++)  force[i] = 0;
     if (mgr->approx == ComputeMsmMgr::C1HERMITE) {
       qh_c1hermite.reset(0);
       eh_c1hermite.reset(0);
     }
     else {
       qh.reset(0);
       eh.reset(0);
     }
   }

void msm::PatchData::interpolation ( )

Definition at line 6417 of file ComputeMsm.C.

References ComputeMsmMgr::approx, msm::Array< T >::buffer(), coord, ComputeMsmMgr::d_stencil_1d(), msm::Grid< T >::data(), ComputeMsmMgr::doneCompute(), eh, energy, force, ComputeMsmMgr::gzero, ComputeMsmMgr::hxlen_1, ComputeMsmMgr::hylen_1, ComputeMsmMgr::hzlen_1, msm::IndexRange::ia(), msm::IndexRange::ib(), MsmTimer::INTERP, msm::IndexRange::ja(), msm::IndexRange::jb(), msm::IndexRange::ka(), msm::IndexRange::kb(), ComputeMsmMgr::lattice, msm::Array< T >::len(), ComputeMsmMgr::MAX_POLY_DEGREE, mgr, NAMD_die(), msm::IndexRange::ni(), msm::IndexRange::nj(), patchID, ComputeMsmMgr::PolyDegree, ComputeMsmMgr::s_edge, Lattice::scale(), ComputeMsmMgr::sglower, ComputeMsmMgr::shx_1, ComputeMsmMgr::shy_1, ComputeMsmMgr::shz_1, ComputeMsmMgr::srx_x, ComputeMsmMgr::srx_y, ComputeMsmMgr::srx_z, ComputeMsmMgr::sry_x, ComputeMsmMgr::sry_y, ComputeMsmMgr::sry_z, ComputeMsmMgr::srz_x, ComputeMsmMgr::srz_y, ComputeMsmMgr::srz_z, Vector::x, Vector::y, and Vector::z.

Referenced by addPotential().

                                 {
 #ifdef DEBUG_MSM_GRID
     printf("patchID %d:  interpolation\n", patchID);
 #endif
 
 #ifdef MSM_TIMING
     double startTime, stopTime;
     startTime = CkWallTimer();
 #endif
 #ifndef MSM_COMM_ONLY
     BigReal energy_self = 0;
 
     Float xphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
     Float yphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
     Float zphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
     Float dxphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
     Float dyphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
     Float dzphi[ComputeMsmMgr::MAX_POLY_DEGREE+1];
 
     const Double rs_edge = Double( mgr->s_edge );
     const int s_size = ComputeMsmMgr::PolyDegree[mgr->approx] + 1;
 
     const Float hx_1 = Float(mgr->hxlen_1);  // real space inverse grid spacing
     const Float hy_1 = Float(mgr->hylen_1);
     const Float hz_1 = Float(mgr->hzlen_1);
 
     const int ia = eh.ia();
     const int ib = eh.ib();
     const int ja = eh.ja();
     const int jb = eh.jb();
     const int ka = eh.ka();
     const int kb = eh.kb();
     const int ni = eh.ni();
     const int nj = eh.nj();
     Float *ehbuffer = eh.data().buffer();
 
     // loop over atoms
     for (int n = 0;  n < coord.len();  n++) {
       Float q = coord[n].charge;
       if (0==q) continue;
 
       ScaledPosition s = mgr->lattice.scale(coord[n].position);
 
       BigReal sx_hx = (s.x - mgr->sglower.x) * mgr->shx_1;
       BigReal sy_hy = (s.y - mgr->sglower.y) * mgr->shy_1;
       BigReal sz_hz = (s.z - mgr->sglower.z) * mgr->shz_1;
 
       BigReal xlo = floor(sx_hx) - rs_edge;
       BigReal ylo = floor(sy_hy) - rs_edge;
       BigReal zlo = floor(sz_hz) - rs_edge;
 
       // calculate Phi stencils along each dimension
       Float xdelta = Float(sx_hx - xlo);
       mgr->d_stencil_1d(dxphi, xphi, xdelta, hx_1);
       Float ydelta = Float(sy_hy - ylo);
       mgr->d_stencil_1d(dyphi, yphi, ydelta, hy_1);
       Float zdelta = Float(sz_hz - zlo);
       mgr->d_stencil_1d(dzphi, zphi, zdelta, hz_1);
 
       int ilo = int(xlo);
       int jlo = int(ylo);
       int klo = int(zlo);
 
 #if 0
       // XXX don't need to test twice!
 
       // test to see if stencil is within edges of grid
       int iswithin = ( ia <= ilo && (ilo+(s_size-1)) <= ib &&
                        ja <= jlo && (jlo+(s_size-1)) <= jb &&
                        ka <= klo && (klo+(s_size-1)) <= kb );
 
       if ( ! iswithin ) {
         char msg[100];
         snprintf(msg, sizeof(msg), "Atom %d is outside of the MSM grid.",
             coord[n].id);
         NAMD_die(msg);
       }
 #endif
 
       // determine force on atom from surrounding potential grid points
       //Force f = 0;
       //BigReal e = 0;
       Float fx=0, fy=0, fz=0, e=0;
       for (int k = 0;  k < s_size;  k++) {
         int koff = ((k+klo) - ka) * nj;
         for (int j = 0;  j < s_size;  j++) {
           int jkoff = (koff + (j+jlo) - ja) * ni;
           Float cx = yphi[j] * zphi[k];
           Float cy = dyphi[j] * zphi[k];
           Float cz = yphi[j] * dzphi[k];
           for (int i = 0;  i < s_size;  i++) {
             int ijkoff = jkoff + (i+ilo) - ia;
             Float ec = ehbuffer[ijkoff];
             fx += ec * dxphi[i] * cx;
             fy += ec * xphi[i] * cy;
             fz += ec * xphi[i] * cz;
             e += ec * xphi[i] * cx;
           }
         }
       }
 
 #if 0
       force[n].x -= q * (mgr->srx_x * fx + mgr->srx_y * fy + mgr->srx_z * fz);
       force[n].y -= q * (mgr->sry_x * fx + mgr->sry_y * fy + mgr->sry_z * fz);
       force[n].z -= q * (mgr->srz_x * fx + mgr->srz_y * fy + mgr->srz_z * fz);
 #endif
       force[n].x -= q * fx;
       force[n].y -= q * fy;
       force[n].z -= q * fz;
       energy += q * e;
       energy_self += q * q;
 
     } // end loop over atoms
 
     energy_self *= mgr->gzero;
     energy -= energy_self;
     energy *= 0.5;
 #endif // !MSM_COMM_ONLY
 #ifdef MSM_TIMING
     stopTime = CkWallTimer();
     mgr->msmTiming[MsmTimer::INTERP] += stopTime - startTime;
     mgr->doneTiming();
 #endif
     mgr->doneCompute();
   }

void msm::PatchData::interpolationC1Hermite ( )

Definition at line 6693 of file ComputeMsm.C.

References msm::Array< T >::buffer(), coord, D000, D001, D010, D011, D100, D101, D110, D111, ComputeMsmMgr::d_stencil_1d_c1hermite(), msm::Grid< T >::data(), ComputeMsmMgr::doneCompute(), eh_c1hermite, energy, force, ComputeMsmMgr::gzero, ComputeMsmMgr::hxlen, ComputeMsmMgr::hxlen_1, ComputeMsmMgr::hylen, ComputeMsmMgr::hylen_1, ComputeMsmMgr::hzlen, ComputeMsmMgr::hzlen_1, msm::IndexRange::ia(), msm::IndexRange::ib(), MsmTimer::INTERP, msm::IndexRange::ja(), msm::IndexRange::jb(), msm::IndexRange::ka(), msm::IndexRange::kb(), ComputeMsmMgr::lattice, msm::Array< T >::len(), mgr, NAMD_die(), msm::IndexRange::ni(), msm::IndexRange::nj(), patchID, Lattice::scale(), ComputeMsmMgr::sglower, ComputeMsmMgr::shx_1, ComputeMsmMgr::shy_1, ComputeMsmMgr::shz_1, ComputeMsmMgr::srx_x, ComputeMsmMgr::srx_y, ComputeMsmMgr::srx_z, ComputeMsmMgr::sry_x, ComputeMsmMgr::sry_y, ComputeMsmMgr::sry_z, ComputeMsmMgr::srz_x, ComputeMsmMgr::srz_y, ComputeMsmMgr::srz_z, C1Vector::velem, Vector::x, Vector::y, and Vector::z.

Referenced by addPotentialC1Hermite().

                                          {
 #ifdef DEBUG_MSM_GRID
     printf("patchID %d:  interpolation\n", patchID);
 #endif
 
 #ifdef MSM_TIMING
     double startTime, stopTime;
     startTime = CkWallTimer();
 #endif
 #ifndef MSM_COMM_ONLY
     BigReal energy_self = 0;
 
     Float xphi[2], dxphi[2], xpsi[2], dxpsi[2];
     Float yphi[2], dyphi[2], ypsi[2], dypsi[2];
     Float zphi[2], dzphi[2], zpsi[2], dzpsi[2];
 
     const Float hx = Float(mgr->hxlen);      // real space grid spacing
     const Float hy = Float(mgr->hylen);
     const Float hz = Float(mgr->hzlen);
 
     const Float hx_1 = Float(mgr->hxlen_1);  // real space inverse grid spacing
     const Float hy_1 = Float(mgr->hylen_1);
     const Float hz_1 = Float(mgr->hzlen_1);
 
     const int ia = eh_c1hermite.ia();
     const int ib = eh_c1hermite.ib();
     const int ja = eh_c1hermite.ja();
     const int jb = eh_c1hermite.jb();
     const int ka = eh_c1hermite.ka();
     const int kb = eh_c1hermite.kb();
     const int ni = eh_c1hermite.ni();
     const int nj = eh_c1hermite.nj();
     C1Vector *ehbuffer = eh_c1hermite.data().buffer();
 
     // loop over atoms
     for (int n = 0;  n < coord.len();  n++) {
       Float q = coord[n].charge;
       if (0==q) continue;
 
       ScaledPosition s = mgr->lattice.scale(coord[n].position);
 
       BigReal sx_hx = (s.x - mgr->sglower.x) * mgr->shx_1;
       BigReal sy_hy = (s.y - mgr->sglower.y) * mgr->shy_1;
       BigReal sz_hz = (s.z - mgr->sglower.z) * mgr->shz_1;
 
       BigReal xlo = floor(sx_hx);
       BigReal ylo = floor(sy_hy);
       BigReal zlo = floor(sz_hz);
 
       // calculate Phi stencils along each dimension
       Float xdelta = Float(sx_hx - xlo);
       mgr->d_stencil_1d_c1hermite(dxphi, xphi, dxpsi, xpsi,
           xdelta, hx, hx_1);
       Float ydelta = Float(sy_hy - ylo);
       mgr->d_stencil_1d_c1hermite(dyphi, yphi, dypsi, ypsi,
           ydelta, hy, hy_1);
       Float zdelta = Float(sz_hz - zlo);
       mgr->d_stencil_1d_c1hermite(dzphi, zphi, dzpsi, zpsi,
           zdelta, hz, hz_1);
 
       int ilo = int(xlo);
       int jlo = int(ylo);
       int klo = int(zlo);
 
 #if 0
       // XXX don't need to test twice!
 
       // test to see if stencil is within edges of grid
       int iswithin = ( ia <= ilo && ilo < ib &&
                        ja <= jlo && jlo < jb &&
                        ka <= klo && klo < kb );
 
       if ( ! iswithin ) {
         char msg[100];
         snprintf(msg, sizeof(msg), "Atom %d is outside of the MSM grid.",
             coord[n].id);
         NAMD_die(msg);
       }
 #endif
 
       // determine force on atom from surrounding potential grid points
       Float fx=0, fy=0, fz=0, e=0;
       for (int k = 0;  k < 2;  k++) {
         int koff = ((k+klo) - ka) * nj;
         for (int j = 0;  j < 2;  j++) {
           int jkoff = (koff + (j+jlo) - ja) * ni;
           Float c_yphi_zphi = yphi[j] * zphi[k];
           Float c_ypsi_zphi = ypsi[j] * zphi[k];
           Float c_yphi_zpsi = yphi[j] * zpsi[k];
           Float c_ypsi_zpsi = ypsi[j] * zpsi[k];
           Float c_yphi_dzphi = yphi[j] * dzphi[k];
           Float c_ypsi_dzphi = ypsi[j] * dzphi[k];
           Float c_yphi_dzpsi = yphi[j] * dzpsi[k];
           Float c_ypsi_dzpsi = ypsi[j] * dzpsi[k];
           Float c_dyphi_zphi = dyphi[j] * zphi[k];
           Float c_dypsi_zphi = dypsi[j] * zphi[k];
           Float c_dyphi_zpsi = dyphi[j] * zpsi[k];
           Float c_dypsi_zpsi = dypsi[j] * zpsi[k];
           for (int i = 0;  i < 2;  i++) {
             int ijkoff = jkoff + (i+ilo) - ia;
             fx += dxphi[i] * (c_yphi_zphi * ehbuffer[ijkoff].velem[D000]
                 + c_ypsi_zphi * ehbuffer[ijkoff].velem[D010]
                 + c_yphi_zpsi * ehbuffer[ijkoff].velem[D001]
                 + c_ypsi_zpsi * ehbuffer[ijkoff].velem[D011])
               + dxpsi[i] * (c_yphi_zphi * ehbuffer[ijkoff].velem[D100]
                   + c_ypsi_zphi * ehbuffer[ijkoff].velem[D110]
                   + c_yphi_zpsi * ehbuffer[ijkoff].velem[D101]
                   + c_ypsi_zpsi * ehbuffer[ijkoff].velem[D111]);
             fy += xphi[i] * (c_dyphi_zphi * ehbuffer[ijkoff].velem[D000]
                 + c_dypsi_zphi * ehbuffer[ijkoff].velem[D010]
                 + c_dyphi_zpsi * ehbuffer[ijkoff].velem[D001]
                 + c_dypsi_zpsi * ehbuffer[ijkoff].velem[D011])
               + xpsi[i] * (c_dyphi_zphi * ehbuffer[ijkoff].velem[D100]
                   + c_dypsi_zphi * ehbuffer[ijkoff].velem[D110]
                   + c_dyphi_zpsi * ehbuffer[ijkoff].velem[D101]
                   + c_dypsi_zpsi * ehbuffer[ijkoff].velem[D111]);
             fz += xphi[i] * (c_yphi_dzphi * ehbuffer[ijkoff].velem[D000]
                 + c_ypsi_dzphi * ehbuffer[ijkoff].velem[D010]
                 + c_yphi_dzpsi * ehbuffer[ijkoff].velem[D001]
                 + c_ypsi_dzpsi * ehbuffer[ijkoff].velem[D011])
               + xpsi[i] * (c_yphi_dzphi * ehbuffer[ijkoff].velem[D100]
                   + c_ypsi_dzphi * ehbuffer[ijkoff].velem[D110]
                   + c_yphi_dzpsi * ehbuffer[ijkoff].velem[D101]
                   + c_ypsi_dzpsi * ehbuffer[ijkoff].velem[D111]);
             e += xphi[i] * (c_yphi_zphi * ehbuffer[ijkoff].velem[D000]
                 + c_ypsi_zphi * ehbuffer[ijkoff].velem[D010]
                 + c_yphi_zpsi * ehbuffer[ijkoff].velem[D001]
                 + c_ypsi_zpsi * ehbuffer[ijkoff].velem[D011])
               + xpsi[i] * (c_yphi_zphi * ehbuffer[ijkoff].velem[D100]
                   + c_ypsi_zphi * ehbuffer[ijkoff].velem[D110]
                   + c_yphi_zpsi * ehbuffer[ijkoff].velem[D101]
                   + c_ypsi_zpsi * ehbuffer[ijkoff].velem[D111]);
           }
         }
       }
 
 #if 0
       force[n].x -= q * (mgr->srx_x * fx + mgr->srx_y * fy + mgr->srx_z * fz);
       force[n].y -= q * (mgr->sry_x * fx + mgr->sry_y * fy + mgr->sry_z * fz);
       force[n].z -= q * (mgr->srz_x * fx + mgr->srz_y * fy + mgr->srz_z * fz);
 #endif
       force[n].x -= q * fx;
       force[n].y -= q * fy;
       force[n].z -= q * fz;
       energy += q * e;
       energy_self += q * q;
 
     } // end loop over atoms
 
     energy_self *= mgr->gzero;
     energy -= energy_self;
     energy *= 0.5;
 #endif // !MSM_COMM_ONLY
 #ifdef MSM_TIMING
     stopTime = CkWallTimer();
     mgr->msmTiming[MsmTimer::INTERP] += stopTime - startTime;
     mgr->doneTiming();
 #endif
     mgr->doneCompute();
   }

void msm::PatchData::sendCharge ( )

Definition at line 6367 of file ComputeMsm.C.

References MsmTimer::COMM, msm::Grid< T >::data(), msm::Grid< T >::extract(), msm::Ivec::i, msm::Grid< T >::init(), msm::Ivec::j, msm::Ivec::k, msm::Array< T >::len(), msm::BlockIndex::level, mgr, MSM_PRIORITY, ComputeMsmMgr::msmBlock, msm::BlockIndex::n, pd, GridMsg::put(), qh, msm::PatchDiagram::send, sequence, SET_PRIORITY, subgrid, and msm::Grid< T >::updateLower().

Referenced by anterpolation().

                              {
 #ifdef MSM_TIMING
     double startTime, stopTime;
 #endif
     int priority = 1;
     // buffer portions of grid to send to Blocks on level 0
     // allocate the largest buffer space we'll need
     //Grid<BigReal> subgrid;
     //subgrid.resize(map->bsx[0] * map->bsy[0] * map->bsz[0]);
     for (int n = 0;  n < pd->send.len();  n++) {
 #ifdef MSM_TIMING
       startTime = CkWallTimer();
 #endif
       // initialize the proper subgrid indexing range
       subgrid.init( pd->send[n].nrange );
       // extract the values from the larger grid into the subgrid
       qh.extract(subgrid);
       // translate the subgrid indexing range to match the MSM block
       subgrid.updateLower( pd->send[n].nrange_wrap.lower() );
       // add the subgrid charges into the block
       BlockIndex& bindex = pd->send[n].nblock_wrap;
       // place subgrid into message
       int msgsz = subgrid.data().len() * sizeof(Float);
       GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
       SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
       gm->put(subgrid, bindex.level, sequence);
 #ifdef MSM_TIMING
       stopTime = CkWallTimer();
       mgr->msmTiming[MsmTimer::COMM] += stopTime - startTime;
 #endif
       mgr->msmBlock[bindex.level](
           bindex.n.i, bindex.n.j, bindex.n.k).addCharge(gm);
     }
   }

void msm::PatchData::sendChargeC1Hermite ( )

Definition at line 6646 of file ComputeMsm.C.

References MsmTimer::COMM, msm::Grid< T >::data(), msm::Grid< T >::extract(), msm::Ivec::i, msm::Grid< T >::init(), msm::Ivec::j, msm::Ivec::k, msm::Array< T >::len(), msm::BlockIndex::level, mgr, MSM_PRIORITY, ComputeMsmMgr::msmC1HermiteBlock, msm::BlockIndex::n, pd, GridMsg::put(), qh_c1hermite, msm::PatchDiagram::send, sequence, SET_PRIORITY, subgrid_c1hermite, and msm::Grid< T >::updateLower().

Referenced by anterpolationC1Hermite().

                                       {
 #ifdef MSM_TIMING
     double startTime, stopTime;
 #endif
     int priority = 1;
     // buffer portions of grid to send to Blocks on level 0
     for (int n = 0;  n < pd->send.len();  n++) {
 #ifdef MSM_TIMING
       startTime = CkWallTimer();
 #endif
       // initialize the proper subgrid indexing range
       subgrid_c1hermite.init( pd->send[n].nrange );
       // extract the values from the larger grid into the subgrid
       qh_c1hermite.extract(subgrid_c1hermite);
       // translate the subgrid indexing range to match the MSM block
       subgrid_c1hermite.updateLower( pd->send[n].nrange_wrap.lower() );
       // add the subgrid charges into the block
       BlockIndex& bindex = pd->send[n].nblock_wrap;
       // place subgrid into message
       int msgsz = subgrid_c1hermite.data().len() * sizeof(C1Vector);
       GridMsg *gm = new(msgsz, sizeof(int)) GridMsg;
       SET_PRIORITY(gm, sequence, MSM_PRIORITY + priority);
       gm->put(subgrid_c1hermite, bindex.level, sequence);
 #ifdef MSM_TIMING
       stopTime = CkWallTimer();
       mgr->msmTiming[MsmTimer::COMM] += stopTime - startTime;
 #endif
       mgr->msmC1HermiteBlock[bindex.level](
           bindex.n.i, bindex.n.j, bindex.n.k).addCharge(gm);
     }
   }