msm::PatchData Struct Reference

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

PatchData()

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

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

addPotential()

void PatchData::addPotential

(

const Grid< Float > &

epart

)

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

addPotentialC1Hermite()

void PatchData::addPotentialC1Hermite

(

const Grid< C1Vector > &

epart

)

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

anterpolation()

void PatchData::anterpolation

(

)

Definition at line 6269 of file ComputeMsm.C.

References MsmTimer::ANTERP, ComputeMsmMgr::approx, msm::Array< T >::buffer(), coord, msm::Grid< T >::data(), msm::IndexRange::ia(), msm::IndexRange::ib(), 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, qh, ComputeMsmMgr::s_edge, Lattice::scale(), sendCharge(), ComputeMsmMgr::sglower, ComputeMsmMgr::shx_1, ComputeMsmMgr::shy_1, ComputeMsmMgr::shz_1, ComputeMsmMgr::stencil_1d(), Vector::x, Vector::y, and Vector::z.

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

anterpolationC1Hermite()

void PatchData::anterpolationC1Hermite

(

)

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

coordArray()

AtomCoordArray& msm::PatchData::coordArray ( )

inline

Definition at line 1756 of file ComputeMsm.C.

References coord.

Referenced by ComputeMsm::doWork().

{ return coord; }

forceArray()

ForceArray& msm::PatchData::forceArray ( )

inline

Definition at line 1757 of file ComputeMsm.C.

References force.

{ return force; }

init()

void PatchData::init

(

int

natoms

)

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

interpolation()

void PatchData::interpolation

(

)

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

interpolationC1Hermite()

void PatchData::interpolationC1Hermite

(

)

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

sendCharge()

void PatchData::sendCharge

(

)

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

sendChargeC1Hermite()

void PatchData::sendChargeC1Hermite

(

)

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

Member Data Documentation

cntRecvs

int msm::PatchData::cntRecvs

Definition at line 1752 of file ComputeMsm.C.

Referenced by addPotential(), addPotentialC1Hermite(), and init().

coord

AtomCoordArray msm::PatchData::coord

Definition at line 1742 of file ComputeMsm.C.

Referenced by anterpolation(), anterpolationC1Hermite(), coordArray(), init(), interpolation(), and interpolationC1Hermite().

eh

Grid<Float> msm::PatchData::eh

Definition at line 1745 of file ComputeMsm.C.

Referenced by addPotential(), init(), interpolation(), and PatchData().

eh_c1hermite

Grid<C1Vector> msm::PatchData::eh_c1hermite

Definition at line 1748 of file ComputeMsm.C.

Referenced by addPotentialC1Hermite(), init(), interpolationC1Hermite(), and PatchData().

energy

BigReal msm::PatchData::energy

Definition at line 1750 of file ComputeMsm.C.

Referenced by init(), interpolation(), interpolationC1Hermite(), and ComputeMsm::saveResults().

force

ForceArray msm::PatchData::force

Definition at line 1743 of file ComputeMsm.C.

Referenced by forceArray(), init(), interpolation(), interpolationC1Hermite(), and ComputeMsm::saveResults().

map

Map* msm::PatchData::map

Definition at line 1740 of file ComputeMsm.C.

Referenced by PatchData().

mgr

ComputeMsmMgr* msm::PatchData::mgr

Definition at line 1739 of file ComputeMsm.C.

Referenced by addPotential(), addPotentialC1Hermite(), anterpolation(), anterpolationC1Hermite(), init(), interpolation(), interpolationC1Hermite(), PatchData(), sendCharge(), and sendChargeC1Hermite().

patchID

int msm::PatchData::patchID

Definition at line 1753 of file ComputeMsm.C.

Referenced by anterpolation(), anterpolationC1Hermite(), interpolation(), interpolationC1Hermite(), and PatchData().

pd

PatchDiagram* msm::PatchData::pd

Definition at line 1741 of file ComputeMsm.C.

Referenced by addPotential(), addPotentialC1Hermite(), PatchData(), sendCharge(), and sendChargeC1Hermite().

qh

Grid<Float> msm::PatchData::qh

Definition at line 1744 of file ComputeMsm.C.

Referenced by anterpolation(), init(), PatchData(), and sendCharge().

qh_c1hermite

Grid<C1Vector> msm::PatchData::qh_c1hermite

Definition at line 1747 of file ComputeMsm.C.

Referenced by anterpolationC1Hermite(), init(), PatchData(), and sendChargeC1Hermite().

sequence

int msm::PatchData::sequence

Definition at line 1754 of file ComputeMsm.C.

Referenced by ComputeMsm::doWork(), sendCharge(), and sendChargeC1Hermite().

subgrid

Grid<Float> msm::PatchData::subgrid

Definition at line 1746 of file ComputeMsm.C.

Referenced by PatchData(), and sendCharge().

subgrid_c1hermite

Grid<C1Vector> msm::PatchData::subgrid_c1hermite

Definition at line 1749 of file ComputeMsm.C.

Referenced by PatchData(), and sendChargeC1Hermite().

---

The documentation for this struct was generated from the following file:

• ComputeMsm.C