ComputeMsmMgr Class Reference

Inheritance diagram for ComputeMsmMgr:

Public Types
enum	{   VXX =0, VXY, VXZ, VYY,   VYZ, VZZ, VMAX }
enum	Approx {   CUBIC =0, QUINTIC, QUINTIC2, SEPTIC,   SEPTIC3, NONIC, NONIC4, C1HERMITE,   NUM_APPROX }
enum	Split {   TAYLOR2 =0, TAYLOR3, TAYLOR4, TAYLOR5,   TAYLOR6, TAYLOR7, TAYLOR8, TAYLOR2_DISP,   TAYLOR3_DISP, TAYLOR4_DISP, TAYLOR5_DISP, TAYLOR6_DISP,   TAYLOR7_DISP, TAYLOR8_DISP, NUM_SPLIT }
enum	{ MAX_POLY_DEGREE = 9, MAX_NSTENCIL_SIZE = (2*MAX_POLY_DEGREE + 1), MAX_NSTENCIL_SKIP_ZERO = (MAX_POLY_DEGREE + 2), NUM_APPROX_FORMS = (NONIC4 - CUBIC) + 1 }

Public Member Functions
	ComputeMsmMgr ()
	~ComputeMsmMgr ()
void	initialize (MsmInitMsg *)
void	initialize_create ()
void	recvMsmBlockProxy (MsmBlockProxyMsg *)
void	recvMsmGridCutoffProxy (MsmGridCutoffProxyMsg *)
void	recvMsmC1HermiteBlockProxy (MsmC1HermiteBlockProxyMsg *)
void	recvMsmC1HermiteGridCutoffProxy (MsmC1HermiteGridCutoffProxyMsg *)
void	update (CkQdMsg *)
void	compute (msm::Array< int > &patchIDList)
void	addPotential (GridMsg *)
void	doneCompute ()
void	setCompute (ComputeMsm *c)
msm::PatchPtrArray &	patchPtrArray ()
msm::Map &	mapData ()
int	numLevels () const
void	setup_hgrid_1d (BigReal len, BigReal &hh, int &nn, int &ia, int &ib, int isperiodic)
void	setup_periodic_blocksize (int &bsize, int n)
int	blockFlatIndex (int level, int i, int j, int k)
float	calcBlockWork (const msm::BlockDiagram &b)
float	calcGcutWork (const msm::BlockSend &bs)
void	initVirialContrib ()
void	addVirialContrib ()
void	subtractVirialContrib ()
void	doneVirialContrib ()
void	stencil_1d (Float phi[], Float t)
void	d_stencil_1d (Float dphi[], Float phi[], Float t, Float h_1)
void	stencil_1d_c1hermite (Float phi[], Float psi[], Float t, Float h)
void	d_stencil_1d_c1hermite (Float dphi[], Float phi[], Float dpsi[], Float psi[], Float t, Float h, Float h_1)

Static Public Member Functions
static int	sign (int n)
static void	splitting (BigReal &g, BigReal &dg, BigReal r_a, int _split)
static void	ndsplitting (BigReal pg[], BigReal s, int n, int _split)
static void	gc_c1hermite_elem_accum (C1Matrix &matrix, BigReal _c, Vector rv, BigReal _a, int _split)

Public Attributes
CProxy_ComputeMsmMgr	msmProxy
ComputeMsm *	msmCompute
msm::Array< CProxy_MsmBlock >	msmBlock
msm::Array< CProxy_MsmC1HermiteBlock >	msmC1HermiteBlock
CProxy_MsmGridCutoff	msmGridCutoff
CProxy_MsmC1HermiteGridCutoff	msmC1HermiteGridCutoff
int	numGridCutoff
msm::Map	map
msm::PatchPtrArray	patchPtr
msm::Grid< Float >	subgrid
msm::Grid< C1Vector >	subgrid_c1hermite
msm::Array< int >	blockAssign
msm::Array< int >	gcutAssign
msm::Grid< Float >	gvsum
int	numVirialContrib
int	cntVirialContrib
Float	virial [VMAX]
Vector	c
Vector	u
Vector	v
Vector	w
Vector	ru
Vector	rv
Vector	rw
int	ispu
int	ispv
int	ispw
Lattice	lattice
ScaledPosition	smin
ScaledPosition	smax
BigReal	gridspacing
BigReal	padding
BigReal	gridScalingFactor
BigReal	a
BigReal	hxlen
BigReal	hylen
BigReal	hzlen
BigReal	hxlen_1
BigReal	hylen_1
BigReal	hzlen_1
Vector	hu
Vector	hv
Vector	hw
Float	hufx
Float	hufy
Float	hufz
Float	hvfx
Float	hvfy
Float	hvfz
Float	hwfx
Float	hwfy
Float	hwfz
int	nhx
int	nhy
int	nhz
int	approx
int	split
int	nlevels
int	dispersion
BigReal	gzero
Vector	sglower
BigReal	shx
BigReal	shy
BigReal	shz
BigReal	shx_1
BigReal	shy_1
BigReal	shz_1
Vector	sx_shx
Vector	sy_shy
Vector	sz_shz
Float	srx_x
Float	srx_y
Float	srx_z
Float	sry_x
Float	sry_y
Float	sry_z
Float	srz_x
Float	srz_y
Float	srz_z
int	s_edge
int	omega

Static Public Attributes
static const int	PolyDegree [NUM_APPROX]
static const int	Nstencil [NUM_APPROX]
static const int	IndexOffset [NUM_APPROX][MAX_NSTENCIL_SKIP_ZERO]
static const Float	PhiStencil [NUM_APPROX_FORMS][MAX_NSTENCIL_SKIP_ZERO]

Friends
struct	msm::PatchData
class	MsmBlock
class	MsmBlockMap
class	MsmGridCutoffMap

Detailed Description

Definition at line 364 of file ComputeMsm.C.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
VXX
VXY
VXZ
VYY
VYZ
VZZ
VMAX

Definition at line 526 of file ComputeMsm.C.

{ VXX=0, VXY, VXZ, VYY, VYZ, VZZ, VMAX };

anonymous enum

anonymous enum

Enumerator
MAX_POLY_DEGREE
MAX_NSTENCIL_SIZE
MAX_NSTENCIL_SKIP_ZERO
NUM_APPROX_FORMS

Definition at line 633 of file ComputeMsm.C.

       {
    // Approximation formulas with up to degree 9 polynomials.
    MAX_POLY_DEGREE = 9,

    // Max stencil length for polynomial approximation.
    MAX_NSTENCIL_SIZE = (2*MAX_POLY_DEGREE + 1),

    // Max stencil length when skipping zeros
    // (almost half entries are zero for interpolating polynomials).
    MAX_NSTENCIL_SKIP_ZERO = (MAX_POLY_DEGREE + 2),

    // Number of scalar approximation formulaes
    NUM_APPROX_FORMS = (NONIC4 - CUBIC) + 1
  };

Approx

enum ComputeMsmMgr::Approx

Enumerator
CUBIC
QUINTIC
QUINTIC2
SEPTIC
SEPTIC3
NONIC
NONIC4
C1HERMITE
NUM_APPROX

Definition at line 625 of file ComputeMsm.C.

              { CUBIC=0, QUINTIC, QUINTIC2,
    SEPTIC, SEPTIC3, NONIC, NONIC4, C1HERMITE, NUM_APPROX };

Split

enum ComputeMsmMgr::Split

Enumerator
TAYLOR2
TAYLOR3
TAYLOR4
TAYLOR5
TAYLOR6
TAYLOR7
TAYLOR8
TAYLOR2_DISP
TAYLOR3_DISP
TAYLOR4_DISP
TAYLOR5_DISP
TAYLOR6_DISP
TAYLOR7_DISP
TAYLOR8_DISP
NUM_SPLIT

Definition at line 628 of file ComputeMsm.C.

             { TAYLOR2=0, TAYLOR3, TAYLOR4,
    TAYLOR5, TAYLOR6, TAYLOR7, TAYLOR8,
    TAYLOR2_DISP, TAYLOR3_DISP, TAYLOR4_DISP, TAYLOR5_DISP,
    TAYLOR6_DISP, TAYLOR7_DISP, TAYLOR8_DISP, NUM_SPLIT };

Constructor & Destructor Documentation

ComputeMsmMgr()

ComputeMsmMgr::ComputeMsmMgr

(

)

Definition at line 3854 of file ComputeMsm.C.

                             :
  msmProxy(thisgroup), msmCompute(0)
{
#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsmMgr:  (constructor) PE %d\n", CkMyPe());
#endif
  CkpvAccess(BOCclass_group).computeMsmMgr = thisgroup;

#ifdef MSM_TIMING
  if (CkMyPe() == 0) {
    msmTimer = CProxy_MsmTimer::ckNew();
  }
  initTiming();
#endif
#ifdef MSM_PROFILING
  if (CkMyPe() == 0) {
    msmProfiler = CProxy_MsmProfiler::ckNew();
  }
  initProfiling();
#endif
}

~ComputeMsmMgr()

ComputeMsmMgr::~ComputeMsmMgr

(

)

Definition at line 3876 of file ComputeMsm.C.

{
#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsmMgr:  (destructor) PE %d\n", CkMyPe());
#endif
  // free memory?
}

Member Function Documentation

addPotential()

void ComputeMsmMgr::addPotential

(

GridMsg *

gm

)

Definition at line 6018 of file ComputeMsm.C.

References approx, C1HERMITE, GridMsg::get(), NAMD_die(), patchPtr, subgrid, and subgrid_c1hermite.

{
  int pid;  // receive patch ID
  int pseq;
  if (approx == C1HERMITE) {
    gm->get(subgrid_c1hermite, pid, pseq);
  }
  else {
    gm->get(subgrid, pid, pseq);
  }
  delete gm;
  if (patchPtr[pid] == NULL) {
    char msg[100];
    snprintf(msg, sizeof(msg), "Expecting patch %d to exist on PE %d",
        pid, CkMyPe());
    NAMD_die(msg);
  }
  if (approx == C1HERMITE) {
    patchPtr[pid]->addPotentialC1Hermite(subgrid_c1hermite);
  }
  else {
    patchPtr[pid]->addPotential(subgrid);
  }
}

addVirialContrib()

void ComputeMsmMgr::addVirialContrib ( )

inline

Definition at line 533 of file ComputeMsm.C.

References numVirialContrib.

Referenced by MsmGridCutoffKernel< Float, Float >::init().

                          {
    numVirialContrib++;
  }

blockFlatIndex()

int ComputeMsmMgr::blockFlatIndex ( int  level, int  i, int  j, int  k  )

inline

Definition at line 487 of file ComputeMsm.C.

References msm::Map::blockLevel, and map.

Referenced by MsmBlockMap::procNum().

                                                     {
    int n = 0;
    for (int l = 0;  l < level;  l++) {
      n += map.blockLevel[l].nn();
    }
    return (n + map.blockLevel[level].flatindex(i,j,k));
  }

calcBlockWork()

float ComputeMsmMgr::calcBlockWork ( const msm::BlockDiagram &  b )

inline

Definition at line 494 of file ComputeMsm.C.

References approx, msm::Map::bsx, msm::Map::bsy, msm::Map::bsz, C1HERMITE, msm::IndexRange::extent(), msm::Map::gc, msm::Map::gc_c1hermite, msm::Ivec::i, msm::Ivec::j, msm::Ivec::k, map, msm::BlockDiagram::nrange, and msm::BlockDiagram::nrangeCutoff.

                                                {
    // XXX ratio of work for MsmBlock to MsmGridCutoff?
    const float scalingFactor = 3;
    const int volumeFullBlock = map.bsx[0] * map.bsy[0] * map.bsz[0];
    msm::Ivec gn;
    if (approx == C1HERMITE) {
      gn = map.gc_c1hermite[0].extent();
    }
    else {
      gn = map.gc[0].extent();
    }
    const int volumeFullCutoff = (map.bsx[0] + gn.i - 1) *
      (map.bsy[0] + gn.j - 1) * (map.bsz[0] + gn.k - 1);
    msm::Ivec n = b.nrange.extent();
    int volumeBlock = n.i * n.j * n.k;
    msm::Ivec nc = b.nrangeCutoff.extent();
    int volumeCutoff = nc.i * nc.j * nc.k;
    return( scalingFactor * (float(volumeBlock) / volumeFullBlock) *
        (float(volumeCutoff) / volumeFullCutoff) );
  }

calcGcutWork()

float ComputeMsmMgr::calcGcutWork ( const msm::BlockSend &  bs )

inline

Definition at line 514 of file ComputeMsm.C.

References msm::Map::bsx, msm::Map::bsy, msm::Map::bsz, msm::IndexRange::extent(), msm::Ivec::i, msm::Ivec::j, msm::Ivec::k, map, and msm::BlockSend::nrange_wrap.

                                             {
    const int volumeFullBlock = map.bsx[0] * map.bsy[0] * map.bsz[0];
    msm::Ivec n = bs.nrange_wrap.extent();;
    int volumeBlock = n.i * n.j * n.k;
    return( float(volumeBlock) / volumeFullBlock );
  }

compute()

void ComputeMsmMgr::compute

(

msm::Array< int > &

patchIDList

)

Definition at line 5990 of file ComputeMsm.C.

References approx, C1HERMITE, msm::Array< T >::len(), NAMD_die(), and patchPtr.

Referenced by ComputeMsm::doWork().

{
#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsmMgr:  compute() PE=%d\n", CkMyPe());
#endif

  int n; 
  for (n = 0;  n < patchIDList.len();  n++) {
    int patchID = patchIDList[n];
    if (patchPtr[patchID] == NULL) {
      char msg[100];
      snprintf(msg, sizeof(msg),
          "Expected MSM data for patch %d does not exist on PE %d",
          patchID, CkMyPe());
      NAMD_die(msg);
    }
    if (approx == C1HERMITE) {
      patchPtr[patchID]->anterpolationC1Hermite();
    }
    else {
      patchPtr[patchID]->anterpolation();
    }
    // all else should follow from here
  }
  return;
}

d_stencil_1d()

void ComputeMsmMgr::d_stencil_1d ( Float  dphi[], Float  phi[], Float  t, Float  h_1  )

inline

Definition at line 937 of file ComputeMsm.C.

References approx, CUBIC, NAMD_die(), NONIC, NONIC4, QUINTIC, QUINTIC2, SEPTIC, and SEPTIC3.

Referenced by msm::PatchData::interpolation().

                                                                   {
    switch (approx) {
      case CUBIC:
        phi[0] = 0.5f * (1 - t) * (2 - t) * (2 - t);
        dphi[0] = (1.5f * t - 2) * (2 - t) * h_1;
        t--;
        phi[1] = (1 - t) * (1 + t - 1.5f * t * t);
        dphi[1] = (-5 + 4.5f * t) * t * h_1;
        t--;
        phi[2] = (1 + t) * (1 - t - 1.5f * t * t);
        dphi[2] = (-5 - 4.5f * t) * t * h_1;
        t--;
        phi[3] = 0.5f * (1 + t) * (2 + t) * (2 + t);
        dphi[3] = (1.5f * t + 2) * (2 + t) * h_1;
        break;
      case QUINTIC:
        phi[0] = (1.f/24) * (1-t) * (2-t) * (3-t) * (3-t) * (4-t);
        dphi[0] = ((-1.f/24) * ((3-t) * (3-t) * (14 + t * (-14 + 3*t))
              + 2 * (1-t) * (2-t) * (3-t) * (4-t))) * h_1;
        t--;
        phi[1] = (1-t) * (2-t) * (3-t) * ((1.f/6)
            + t * (0.375f - (5.f/24)*t));
        dphi[1] = (-((1.f/6) + t * (0.375f - (5.f/24)*t)) *
            (11 + t * (-12 + 3*t)) + (1-t) * (2-t) * (3-t) *
            (0.375f - (5.f/12)*t)) * h_1;
        t--;
        phi[2] = (1-t*t) * (2-t) * (0.5f + t * (0.25f - (5.f/12)*t));
        dphi[2] = (-(0.5f + t * (0.25f - (5.f/12)*t)) * (1 + t * (4 - 3*t))
            + (1-t*t) * (2-t) * (0.25f - (5.f/6)*t)) * h_1;
        t--;
        phi[3] = (1-t*t) * (2+t) * (0.5f - t * (0.25f + (5.f/12)*t));
        dphi[3] = ((0.5f + t * (-0.25f - (5.f/12)*t)) * (1 + t * (-4 - 3*t))
            - (1-t*t) * (2+t) * (0.25f + (5.f/6)*t)) * h_1;
        t--;
        phi[4] = (1+t) * (2+t) * (3+t) * ((1.f/6)
            - t * (0.375f + (5.f/24)*t));
        dphi[4] = (((1.f/6) + t * (-0.375f - (5.f/24)*t)) *
            (11 + t * (12 + 3*t)) - (1+t) * (2+t) * (3+t) *
            (0.375f + (5.f/12)*t)) * h_1;
        t--;
        phi[5] = (1.f/24) * (1+t) * (2+t) * (3+t) * (3+t) * (4+t);
        dphi[5] = ((1.f/24) * ((3+t) * (3+t) * (14 + t * (14 + 3*t))
              + 2 * (1+t) * (2+t) * (3+t) * (4+t))) * h_1;
        break;
      case QUINTIC2:
        phi[0] = (1.f/24) * (3-t) * (3-t) * (3-t) * (t-2) * (5*t-8);
        dphi[0] = ((1.f/24) * (3-t) * (3-t) * ((3-t)*(5*t-8)
              - 3*(t-2)*(5*t-8) + 5*(t-2)*(3-t))) * h_1;
        t--;
        phi[1] = (-1.f/24) * (2-t) * (t-1) * (-48+t*(153+t*(-114+t*25)));
        dphi[1] = ((-1.f/24) * ((2-t)*(-48+t*(153+t*(-114+t*25)))
              - (t-1)* (-48+t*(153+t*(-114+t*25)))
              + (2-t)*(t-1)*(153+t*(-228+t*75)))) * h_1;
        t--;
        phi[2] = (1.f/12) * (1-t) * (12+t*(12+t*(-3+t*(-38+t*25))));
        dphi[2] = ((1.f/12) * (-(12+t*(12+t*(-3+t*(-38+t*25))))
              + (1-t)*(12+t*(-6+t*(-114+t*100))))) * h_1;
        t--;
        phi[3] = (1.f/12) * (1+t) * (12+t*(-12+t*(-3+t*(38+t*25))));
        dphi[3] = ((1.f/12) * ((12+t*(-12+t*(-3+t*(38+t*25))))
              + (1+t)*(-12+t*(-6+t*(114+t*100))))) * h_1;
        t--;
        phi[4] = (-1.f/24) * (2+t) * (t+1) * (48+t*(153+t*(114+t*25)));
        dphi[4] = ((-1.f/24) * ((2+t)*(48+t*(153+t*(114+t*25)))
              + (t+1)* (48+t*(153+t*(114+t*25)))
              + (2+t)*(t+1)*(153+t*(228+t*75)))) * h_1;
        t--;
        phi[5] = (1.f/24) * (3+t) * (3+t) * (3+t) * (t+2) * (5*t+8);
        dphi[5] = ((1.f/24) * (3+t) * (3+t) * ((3+t)*(5*t+8)
              + 3*(t+2)*(5*t+8) + 5*(t+2)*(3+t))) * h_1;
        break;
      case SEPTIC:
        phi[0] = (-1.f/720)*(t-1)*(t-2)*(t-3)*(t-4)*(t-4)*(t-5)*(t-6);
        dphi[0] = (-1.f/720)*(t-4)*(-1944+t*(3644+t*(-2512+t*(807
                  +t*(-122+t*7))))) * h_1;
        t--;
        phi[1] = (1.f/720)*(t-1)*(t-2)*(t-3)*(t-4)*(t-5)*(-6+t*(-20+7*t));
        dphi[1] = (1.f/720)*(756+t*(-9940+t*(17724+t*(-12740+t*(4445
                    +t*(-750+t*49)))))) * h_1;
        t--;
        phi[2] = (-1.f/240)*(t*t-1)*(t-2)*(t-3)*(t-4)*(-10+t*(-12+7*t));
        dphi[2] = (-1.f/240)*(-28+t*(1260+t*(-756+t*(-1260+t*(1365
                    +t*(-450+t*49)))))) * h_1;
        t--;
        phi[3] = (1.f/144)*(t*t-1)*(t*t-4)*(t-3)*(-12+t*(-4+7*t));
        dphi[3] = (1.f/144)*t*(-560+t*(84+t*(644+t*(-175
                  +t*(-150+t*49))))) * h_1;
        t--;
        phi[4] = (-1.f/144)*(t*t-1)*(t*t-4)*(t+3)*(-12+t*(4+7*t));
        dphi[4] = (-1.f/144)*t*(560+t*(84+t*(-644+t*(-175
                  +t*(150+t*49))))) * h_1;
        t--;
        phi[5] = (1.f/240)*(t*t-1)*(t+2)*(t+3)*(t+4)*(-10+t*(12+7*t));
        dphi[5] = (1.f/240)*(-28+t*(-1260+t*(-756+t*(1260+t*(1365
                    +t*(450+t*49)))))) * h_1;
        t--;
        phi[6] = (-1.f/720)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*(-6+t*(20+7*t));
        dphi[6] = (-1.f/720)*(756+t*(9940+t*(17724+t*(12740+t*(4445
                    +t*(750+t*49)))))) * h_1;
        t--;
        phi[7] = (1.f/720)*(t+1)*(t+2)*(t+3)*(t+4)*(t+4)*(t+5)*(t+6);
        dphi[7] = (1.f/720)*(t+4)*(1944+t*(3644+t*(2512+t*(807
                  +t*(122+t*7))))) * h_1;
        break;
      case SEPTIC3:
        phi[0] = (3632.f/5) + t*((-7456.f/5) + t*((58786.f/45) + t*(-633
                + t*((26383.f/144) + t*((-22807.f/720) + t*((727.f/240)
                      + t*(-89.f/720)))))));
        dphi[0] = ((-7456.f/5) + t*((117572.f/45) + t*(-1899
                + t*((26383.f/36) + t*((-22807.f/144) + t*((727.f/40)
                      + t*(-623.f/720))))))) * h_1;
        t--;
        phi[1] = -440 + t*((25949.f/20) + t*((-117131.f/72) + t*((2247.f/2)
                + t*((-66437.f/144) + t*((81109.f/720) + t*((-727.f/48)
                      + t*(623.f/720)))))));
        dphi[1] = ((25949.f/20) + t*((-117131.f/36) + t*((6741.f/2)
                + t*((-66437.f/36) + t*((81109.f/144) + t*((-727.f/8)
                      + t*(4361.f/720))))))) * h_1;
        t--;
        phi[2] = (138.f/5) + t*((-8617.f/60) + t*((12873.f/40) + t*((-791.f/2)
                + t*((4557.f/16) + t*((-9583.f/80) + t*((2181.f/80)
                      + t*(-623.f/240)))))));
        dphi[2] = ((-8617.f/60) + t*((12873.f/20) + t*((-2373.f/2)
                + t*((4557.f/4) + t*((-9583.f/16) + t*((6543.f/40)
                      + t*(-4361.f/240))))))) * h_1;
        t--;
        phi[3] = 1 + t*t*((-49.f/36) + t*t*((-959.f/144) + t*((2569.f/144)
                + t*((-727.f/48) + t*(623.f/144)))));
        dphi[3] = (t*((-49.f/18) + t*t*((-959.f/36) + t*((12845.f/144)
                  + t*((-727.f/8) + t*(4361.f/144)))))) * h_1;
        t--;
        phi[4] = 1 + t*t*((-49.f/36) + t*t*((-959.f/144) + t*((-2569.f/144)
                + t*((-727.f/48) + t*(-623.f/144)))));
        dphi[4] = (t*((-49.f/18) + t*t*((-959.f/36) + t*((-12845.f/144)
                  + t*((-727.f/8) + t*(-4361.f/144)))))) * h_1;
        t--;
        phi[5] = (138.f/5) + t*((8617.f/60) + t*((12873.f/40) + t*((791.f/2)
                + t*((4557.f/16) + t*((9583.f/80) + t*((2181.f/80)
                      + t*(623.f/240)))))));
        dphi[5] = ((8617.f/60) + t*((12873.f/20) + t*((2373.f/2)
                + t*((4557.f/4) + t*((9583.f/16) + t*((6543.f/40)
                      + t*(4361.f/240))))))) * h_1;
        t--;
        phi[6] = -440 + t*((-25949.f/20) + t*((-117131.f/72) + t*((-2247.f/2)
                + t*((-66437.f/144) + t*((-81109.f/720) + t*((-727.f/48)
                      + t*(-623.f/720)))))));
        dphi[6] = ((-25949.f/20) + t*((-117131.f/36) + t*((-6741.f/2)
                + t*((-66437.f/36) + t*((-81109.f/144) + t*((-727.f/8)
                      + t*(-4361.f/720))))))) * h_1;
        t--;
        phi[7] = (3632.f/5) + t*((7456.f/5) + t*((58786.f/45) + t*(633
                + t*((26383.f/144) + t*((22807.f/720) + t*((727.f/240)
                      + t*(89.f/720)))))));
        dphi[7] = ((7456.f/5) + t*((117572.f/45) + t*(1899
                + t*((26383.f/36) + t*((22807.f/144) + t*((727.f/40)
                      + t*(623.f/720))))))) * h_1;
        break;
      case NONIC:
        phi[0] = (-1.f/40320)*(t-8)*(t-7)*(t-6)*(t-5)*(t-5)*(t-4)*(t-3)*
          (t-2)*(t-1);
        dphi[0] = (-1.f/40320)*(t-5)*(-117648+t*(256552+t*(-221416
                +t*(99340+t*(-25261+t*(3667+t*(-283+t*9)))))))*h_1;
        t--;
        phi[1] = (1.f/40320)*(t-7)*(t-6)*(t-5)*(t-4)*(t-3)*(t-2)*(t-1)*
          (-8+t*(-35+9*t));
        dphi[1] = (1.f/40320)*(71856+t*(-795368+t*(1569240+t*(-1357692
                  +t*(634725+t*(-172116+t*(27090+t*(-2296+t*81))))))))*h_1;
        t--;
        phi[2] = (-1.f/10080)*(t-6)*(t-5)*(t-4)*(t-3)*(t-2)*(t-1)*(t+1)*
          (-14+t*(-25+9*t));
        dphi[2] = (1.f/10080)*(3384+t*(-69080+t*(55026
                +t*(62580+t*(-99225+t*(51660+t*(-13104+t*(1640
                          +t*(-81)))))))))*h_1;
        t--;
        phi[3] = (1.f/1440)*(t-5)*(t-4)*(t-3)*(t-2)*(t-1)*(t+1)*(t+2)*
          (-6+t*(-5+3*t));
        dphi[3] = (1.f/1440)*(72+t*(-6344+t*(2070
                +t*(7644+t*(-4725+t*(-828+t*(1260+t*(-328+t*27))))))))*h_1;
        t--;
        phi[4] = (-1.f/2880)*(t-4)*(t-3)*(t-2)*(t-1)*(t+1)*(t+2)*(t+3)*
          (-20+t*(-5+9*t));
        dphi[4] = (-1.f/2880)*t*(10792+t*(-972+t*(-12516
                +t*(2205+t*(3924+t*(-882+t*(-328+t*81)))))))*h_1;
        t--;
        phi[5] = (1.f/2880)*(t-3)*(t-2)*(t-1)*(t+1)*(t+2)*(t+3)*(t+4)*
          (-20+t*(5+9*t));
        dphi[5] = (1.f/2880)*t*(-10792+t*(-972+t*(12516
                +t*(2205+t*(-3924+t*(-882+t*(328+t*81)))))))*h_1;
        t--;
        phi[6] = (-1.f/1440)*(t-2)*(t-1)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*
          (-6+t*(5+3*t));
        dphi[6] = (1.f/1440)*(-72+t*(-6344+t*(-2070
                +t*(7644+t*(4725+t*(-828+t*(-1260+t*(-328+t*(-27)))))))))*h_1;
        t--;
        phi[7] = (1.f/10080)*(t-1)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*(t+6)*
          (-14+t*(25+9*t));
        dphi[7] = (1.f/10080)*(-3384+t*(-69080+t*(-55026
                +t*(62580+t*(99225+t*(51660+t*(13104+t*(1640+t*81))))))))*h_1;
        t--;
        phi[8] = (-1.f/40320)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*(t+6)*(t+7)*
          (-8+t*(35+9*t));
        dphi[8] = (-1.f/40320)*(71856+t*(795368+t*(1569240
                +t*(1357692+t*(634725+t*(172116+t*(27090+t*(2296
                          +t*81))))))))*h_1;
        t--;
        phi[9] = (1.f/40320)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*(t+5)*(t+6)*
          (t+7)*(t+8);
        dphi[9] = (1.f/40320)*(t+5)*(117648+t*(256552+t*(221416
                +t*(99340+t*(25261+t*(3667+t*(283+t*9)))))))*h_1;
        break;
      case NONIC4:
      { // begin grouping to define local variables
        double Tphi[10], Tdphi[10];
        double T=t;
        Tphi[0] = 439375./7+T*(-64188125./504+T*(231125375./2016
              +T*(-17306975./288+T*(7761805./384+T*(-2895587./640
                    +T*(129391./192+T*(-259715./4032+T*(28909./8064
                          +T*(-3569./40320)))))))));
        Tdphi[0] = (-64188125./504+T*(231125375./1008
              +T*(-17306975./96+T*(7761805./96+T*(-2895587./128
                    +T*(129391./32+T*(-259715./576+T*(28909./1008
                          +T*(-3569./4480))))))))) * h_1;
        T--;
        Tphi[1] = -56375+T*(8314091./56+T*(-49901303./288+T*(3763529./32
                +T*(-19648027./384+T*(9469163./640+T*(-545977./192
                      +T*(156927./448+T*(-28909./1152
                          +T*(3569./4480)))))))));
        Tdphi[1] = (8314091./56+T*(-49901303./144+T*(11290587./32
                +T*(-19648027./96+T*(9469163./128+T*(-545977./32
                      +T*(156927./64+T*(-28909./144
                          +T*(32121./4480))))))))) * h_1;
        T--;
        Tphi[2] = 68776./7+T*(-1038011./28+T*(31157515./504+T*(-956669./16
                +T*(3548009./96+T*(-2422263./160+T*(197255./48
                      +T*(-19959./28+T*(144545./2016
                          +T*(-3569./1120)))))))));
        Tdphi[2] = (-1038011./28+T*(31157515./252+T*(-2870007./16
                +T*(3548009./24+T*(-2422263./32+T*(197255./8
                      +T*(-19959./4+T*(144545./252
                          +T*(-32121./1120))))))))) * h_1;
        T--;
        Tphi[3] = -154+T*(12757./12+T*(-230123./72+T*(264481./48
                +T*(-576499./96+T*(686147./160+T*(-96277./48
                      +T*(14221./24+T*(-28909./288+T*(3569./480)))))))));
        Tdphi[3] = (12757./12+T*(-230123./36+T*(264481./16
                +T*(-576499./24+T*(686147./32+T*(-96277./8
                      +T*(99547./24+T*(-28909./36
                          +T*(10707./160))))))))) * h_1;
        T--;
        Tphi[4] = 1+T*T*(-205./144+T*T*(91./192+T*(-6181./320
                +T*(6337./96+T*(-2745./32+T*(28909./576
                      +T*(-3569./320)))))));
        Tdphi[4] = T*(-205./72+T*T*(91./48+T*(-6181./64
                +T*(6337./16+T*(-19215./32+T*(28909./72
                      +T*(-32121./320))))))) * h_1;
        T--;
        Tphi[5] = 1+T*T*(-205./144+T*T*(91./192+T*(6181./320
                +T*(6337./96+T*(2745./32+T*(28909./576
                      +T*(3569./320)))))));
        Tdphi[5] = T*(-205./72+T*T*(91./48+T*(6181./64
                +T*(6337./16+T*(19215./32+T*(28909./72
                      +T*(32121./320))))))) * h_1;
        T--;
        Tphi[6] = -154+T*(-12757./12+T*(-230123./72+T*(-264481./48
                +T*(-576499./96+T*(-686147./160+T*(-96277./48
                      +T*(-14221./24+T*(-28909./288+T*(-3569./480)))))))));
        Tdphi[6] = (-12757./12+T*(-230123./36+T*(-264481./16
                +T*(-576499./24+T*(-686147./32+T*(-96277./8
                      +T*(-99547./24+T*(-28909./36
                          +T*(-10707./160))))))))) * h_1;
        T--;
        Tphi[7] = 68776./7+T*(1038011./28+T*(31157515./504+T*(956669./16
                +T*(3548009./96+T*(2422263./160+T*(197255./48
                      +T*(19959./28+T*(144545./2016+T*(3569./1120)))))))));
        Tdphi[7] = (1038011./28+T*(31157515./252+T*(2870007./16
                +T*(3548009./24+T*(2422263./32+T*(197255./8
                      +T*(19959./4+T*(144545./252
                          +T*(32121./1120))))))))) * h_1;
        T--;
        Tphi[8] = -56375+T*(-8314091./56+T*(-49901303./288+T*(-3763529./32
                +T*(-19648027./384+T*(-9469163./640+T*(-545977./192
                      +T*(-156927./448+T*(-28909./1152
                          +T*(-3569./4480)))))))));
        Tdphi[8] = (-8314091./56+T*(-49901303./144+T*(-11290587./32
                +T*(-19648027./96+T*(-9469163./128+T*(-545977./32
                      +T*(-156927./64+T*(-28909./144
                          +T*(-32121./4480))))))))) * h_1;
        T--;
        Tphi[9] = 439375./7+T*(64188125./504+T*(231125375./2016
              +T*(17306975./288+T*(7761805./384+T*(2895587./640
                    +T*(129391./192+T*(259715./4032+T*(28909./8064
                          +T*(3569./40320)))))))));
        Tdphi[9] = (64188125./504+T*(231125375./1008
              +T*(17306975./96+T*(7761805./96+T*(2895587./128
                    +T*(129391./32+T*(259715./576+T*(28909./1008
                          +T*(3569./4480))))))))) * h_1;
        for (int i=0;  i < 10;  i++) {
          phi[i] = Float(Tphi[i]);
          dphi[i] = Float(Tdphi[i]);
        }
      } // end grouping to define local variables
        break;
      default:
        NAMD_die("Unknown MSM approximation.");
    } // switch
  } // d_stencil_1d()

d_stencil_1d_c1hermite()

void ComputeMsmMgr::d_stencil_1d_c1hermite ( Float  dphi[], Float  phi[], Float  dpsi[], Float  psi[], Float  t, Float  h, Float  h_1  )

inline

Definition at line 1252 of file ComputeMsm.C.

Referenced by msm::PatchData::interpolationC1Hermite().

                                   {
    phi[0] = (1 - t) * (1 - t) * (1 + 2*t);
    dphi[0] = -6 * t * (1 - t) * h_1;
    psi[0] = h * t * (1 - t) * (1 - t);
    dpsi[0] = (1 - t) * (1 - 3*t);
    t--;
    phi[1] = (1 + t) * (1 + t) * (1 - 2*t);
    dphi[1] = -6 * t * (1 + t) * h_1;
    psi[1] = h * t * (1 + t) * (1 + t);
    dpsi[1] = (1 + t) * (1 + 3*t);
  }

doneCompute()

void ComputeMsmMgr::doneCompute

(

)

Definition at line 6044 of file ComputeMsm.C.

References msmCompute, and ComputeMsm::saveResults().

Referenced by msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

{
  msmCompute->saveResults();
}

doneVirialContrib()

void ComputeMsmMgr::doneVirialContrib ( )

inline

Definition at line 539 of file ComputeMsm.C.

References c, cntVirialContrib, gvsum, hufx, hufy, hufz, hvfx, hvfy, hvfz, hwfx, hwfy, hwfz, msm::IndexRange::ia(), msm::IndexRange::ib(), initVirialContrib(), msm::IndexRange::ja(), msm::IndexRange::jb(), msm::IndexRange::ka(), msm::IndexRange::kb(), numVirialContrib, virial, VMAX, VXX, VXY, VXZ, VYY, VYZ, and VZZ.

                           {
    if (++cntVirialContrib >= numVirialContrib) {
      // reduce all gvsum contributions into virial tensor
      for (int n = 0;  n < VMAX;  n++) { virial[n] = 0; }
      int ia = gvsum.ia();
      int ib = gvsum.ib();
      int ja = gvsum.ja();
      int jb = gvsum.jb();
      int ka = gvsum.ka();
      int kb = gvsum.kb();
      for (int k = ka;  k <= kb;  k++) {
        for (int j = ja;  j <= jb;  j++) {
          for (int i = ia;  i <= ib;  i++) {
            Float cu = Float(i);
            Float cv = Float(j);
            Float cw = Float(k);
            Float c = gvsum(i,j,k);
            Float vx = cu*hufx + cv*hvfx + cw*hwfx;
            Float vy = cu*hufy + cv*hvfy + cw*hwfy;
            Float vz = cu*hufz + cv*hvfz + cw*hwfz;
            virial[VXX] -= c * vx * vx;
            virial[VXY] -= c * vx * vy;
            virial[VXZ] -= c * vx * vz;
            virial[VYY] -= c * vy * vy;
            virial[VYZ] -= c * vy * vz;
            virial[VZZ] -= c * vz * vz;
          }
        }
      }
      initVirialContrib();
    }
  }

gc_c1hermite_elem_accum()

static void ComputeMsmMgr::gc_c1hermite_elem_accum ( C1Matrix &  matrix, BigReal  _c, Vector  rv, BigReal  _a, int  _split  )

inlinestatic

Definition at line 1410 of file ComputeMsm.C.

References C1_VECTOR_SIZE, C1INDEX, D000, D001, D010, D011, D100, D101, D110, D111, C1Matrix::melem, ndsplitting(), rv, TAYLOR2, TAYLOR3, TAYLOR4, TAYLOR5, Vector::x, Vector::y, and Vector::z.

Referenced by initialize().

                                         {
    const BigReal a_1 = 1./_a;
    const BigReal a_2 = a_1 * a_1;
    const BigReal s = (rv * rv) * a_2;
    const BigReal dx = -2 * rv.x * a_2;  // ds/dx
    const BigReal dy = -2 * rv.y * a_2;  // ds/dy
    const BigReal dz = -2 * rv.z * a_2;  // ds/dz
    const BigReal dd = 2 * a_2;  // d^2s/dx^2 = d^2s/dy^2 = d^2s/dz^2
    BigReal tmp;
    enum { nderiv = C1_VECTOR_SIZE-1 };
    BigReal p[nderiv];
    Float *g = matrix.melem;

    // multiply entire matrix by this coefficient
    _c = _c * a_1;

    // compute derivatives (d/ds)^k of splitting g(s), s=r^2
    ndsplitting(p, s, nderiv, _split);

    // weight 0
    tmp = _c * p[0];
    g[C1INDEX(D000,D000)] += tmp;

    // weight 1
    tmp = _c * p[1] * dx;
    g[C1INDEX(D100,D000)] += tmp;
    g[C1INDEX(D000,D100)] -= tmp;

    tmp = _c * p[1] * dy;
    g[C1INDEX(D010,D000)] += tmp;
    g[C1INDEX(D000,D010)] -= tmp;

    tmp = _c * p[1] * dz;
    g[C1INDEX(D001,D000)] += tmp;
    g[C1INDEX(D000,D001)] -= tmp;

    // C1 splitting returns here

    // weight 2
    tmp = _c * p[2] * dx * dy;
    g[C1INDEX(D110,D000)] += tmp;
    g[C1INDEX(D000,D110)] += tmp;
    g[C1INDEX(D100,D010)] -= tmp;
    g[C1INDEX(D010,D100)] -= tmp;

    tmp = _c * p[2] * dx * dz;
    g[C1INDEX(D101,D000)] += tmp;
    g[C1INDEX(D000,D101)] += tmp;
    g[C1INDEX(D100,D001)] -= tmp;
    g[C1INDEX(D001,D100)] -= tmp;

    tmp = _c * p[2] * dy * dz;
    g[C1INDEX(D011,D000)] += tmp;
    g[C1INDEX(D000,D011)] += tmp;
    g[C1INDEX(D010,D001)] -= tmp;
    g[C1INDEX(D001,D010)] -= tmp;

    tmp = _c * (p[2] * dx*dx + p[1] * dd);
    g[C1INDEX(D100,D100)] -= tmp;
    tmp = _c * (p[2] * dy*dy + p[1] * dd);
    g[C1INDEX(D010,D010)] -= tmp;
    tmp = _c * (p[2] * dz*dz + p[1] * dd);
    g[C1INDEX(D001,D001)] -= tmp;

    // C2 splitting returns here
    if (_split == TAYLOR2) return;

    // weight 3
    tmp = _c * p[3] * dx * dy * dz;
    g[C1INDEX(D111,D000)] += tmp;
    g[C1INDEX(D110,D001)] -= tmp;
    g[C1INDEX(D101,D010)] -= tmp;
    g[C1INDEX(D011,D100)] -= tmp;
    g[C1INDEX(D100,D011)] += tmp;
    g[C1INDEX(D010,D101)] += tmp;
    g[C1INDEX(D001,D110)] += tmp;
    g[C1INDEX(D000,D111)] -= tmp;

    tmp = _c * (p[3] * dx*dx * dy + p[2] * dd * dy);
    g[C1INDEX(D110,D100)] -= tmp;
    g[C1INDEX(D100,D110)] += tmp;

    tmp = _c * (p[3] * dx*dx * dz + p[2] * dd * dz);
    g[C1INDEX(D101,D100)] -= tmp;
    g[C1INDEX(D100,D101)] += tmp;

    tmp = _c * (p[3] * dy*dy * dx + p[2] * dd * dx);
    g[C1INDEX(D110,D010)] -= tmp;
    g[C1INDEX(D010,D110)] += tmp;

    tmp = _c * (p[3] * dy*dy * dz + p[2] * dd * dz);
    g[C1INDEX(D011,D010)] -= tmp;
    g[C1INDEX(D010,D011)] += tmp;

    tmp = _c * (p[3] * dz*dz * dx + p[2] * dd * dx);
    g[C1INDEX(D101,D001)] -= tmp;
    g[C1INDEX(D001,D101)] += tmp;

    tmp = _c * (p[3] * dz*dz * dy + p[2] * dd * dy);
    g[C1INDEX(D011,D001)] -= tmp;
    g[C1INDEX(D001,D011)] += tmp;

    // C3 splitting returns here
    if (_split == TAYLOR3) return;

    // weight 4
    tmp = _c * (p[4] * dx*dx * dy * dz + p[3] * dd * dy * dz);
    g[C1INDEX(D111,D100)] -= tmp;
    g[C1INDEX(D100,D111)] -= tmp;
    g[C1INDEX(D110,D101)] += tmp;
    g[C1INDEX(D101,D110)] += tmp;

    tmp = _c * (p[4] * dy*dy * dx * dz + p[3] * dd * dx * dz);
    g[C1INDEX(D111,D010)] -= tmp;
    g[C1INDEX(D010,D111)] -= tmp;
    g[C1INDEX(D110,D011)] += tmp;
    g[C1INDEX(D011,D110)] += tmp;

    tmp = _c * (p[4] * dz*dz * dx * dy + p[3] * dd * dx * dy);
    g[C1INDEX(D111,D001)] -= tmp;
    g[C1INDEX(D001,D111)] -= tmp;
    g[C1INDEX(D101,D011)] += tmp;
    g[C1INDEX(D011,D101)] += tmp;

    tmp = _c * (p[4] * dx*dx * dy*dy + p[3] * dx*dx * dd
        + p[3] * dd * dy*dy + p[2] * dd * dd);
    g[C1INDEX(D110,D110)] += tmp;
    tmp = _c * (p[4] * dx*dx * dz*dz + p[3] * dx*dx * dd
        + p[3] * dd * dz*dz + p[2] * dd * dd);
    g[C1INDEX(D101,D101)] += tmp;
    tmp = _c * (p[4] * dy*dy * dz*dz + p[3] * dy*dy * dd
        + p[3] * dd * dz*dz + p[2] * dd * dd);
    g[C1INDEX(D011,D011)] += tmp;

    // C4 splitting returns here
    if (_split == TAYLOR4) return;

    // weight 5
    tmp = _c * (p[5] * dx*dx * dy*dy * dz + p[4] * dx*dx * dd * dz
        + p[4] * dd * dy*dy * dz + p[3] * dd * dd * dz);
    g[C1INDEX(D111,D110)] += tmp;
    g[C1INDEX(D110,D111)] -= tmp;

    tmp = _c * (p[5] * dx*dx * dz*dz * dy + p[4] * dx*dx * dd * dy
        + p[4] * dd * dz*dz * dy + p[3] * dd * dd * dy);
    g[C1INDEX(D111,D101)] += tmp;
    g[C1INDEX(D101,D111)] -= tmp;

    tmp = _c * (p[5] * dy*dy * dz*dz * dx + p[4] * dy*dy * dd * dx
        + p[4] * dd * dz*dz * dx + p[3] * dd * dd * dx);
    g[C1INDEX(D111,D011)] += tmp;
    g[C1INDEX(D011,D111)] -= tmp;

    // C5 splitting returns here
    if (_split == TAYLOR5) return;

    // weight 6
    tmp = _c * (p[6] * dx*dx * dy*dy * dz*dz + p[5] * dx*dx * dy*dy * dd
        + p[5] * dx*dx * dd * dz*dz + p[5] * dd * dy*dy * dz*dz
        + p[4] * dx*dx * dd * dd + p[4] * dd * dy*dy * dd
        + p[4] * dd * dd * dz*dz + p[3] * dd * dd * dd);
    g[C1INDEX(D111,D111)] -= tmp;

    // calculate full matrix for C6 or higher splitting

  } // gc_c1hermite_elem_accum()

initialize()

void ComputeMsmMgr::initialize

(

MsmInitMsg *

msg

)

Definition at line 3969 of file ComputeMsm.C.

References Lattice::a(), a, Lattice::a_p(), Lattice::a_r(), approx, ASSERT, Lattice::b(), Lattice::b_p(), Lattice::b_r(), msm::Map::blockLevel, msm::Map::bsx, msm::Map::bsy, msm::Map::bsz, Lattice::c(), c, C1HERMITE, C1INDEX, Lattice::c_p(), Lattice::c_r(), CUBIC, D000, D001, D010, D011, D100, D101, D110, D111, dispersion, endi(), msm::Map::foldfactor, msm::Map::gc, msm::Map::gc_c1hermite, gc_c1hermite_elem_accum(), msm::Map::gpro_c1hermite, msm::Map::gres_c1hermite, msm::Map::grespro, msm::Map::gridrange, gridScalingFactor, gridspacing, msm::Map::gvc, gvsum, gzero, hu, hufx, hufy, hufz, hv, hvfx, hvfy, hvfz, hw, hwfx, hwfy, hwfz, hxlen, hxlen_1, hylen, hylen_1, hzlen, hzlen_1, msm::IndexRange::ia(), msm::IndexRange::ib(), iINFO(), iout, msm::Map::ispx, msm::Map::ispy, msm::Map::ispz, msm::IndexRange::ja(), msm::IndexRange::jb(), msm::IndexRange::ka(), msm::IndexRange::kb(), lattice, Vector::length(), map, MSM_MAX_BLOCK_VOLUME, NAMD_die(), nhx, nhy, nhz, msm::IndexRange::ni(), msm::IndexRange::nj(), msm::IndexRange::nk(), nlevels, msm::IndexRange::nn(), NONIC, NONIC4, Nstencil, NUM_APPROX, NUM_SPLIT, PatchMap::numPatches(), PatchMap::Object(), Node::Object(), omega, padding, msm::Map::patchList, PhiStencil, PolyDegree, QUINTIC, QUINTIC2, msm::Grid< T >::reset(), msm::Array< T >::resize(), ru, rv, rw, s_edge, Lattice::scale(), SEPTIC, SEPTIC3, C1Matrix::set(), msm::Grid< T >::set(), msm::Grid< T >::setbounds(), setup_hgrid_1d(), setup_periodic_blocksize(), sglower, shx, shx_1, shy, shy_1, shz, shz_1, Node::simParameters, simParams, MsmInitMsg::smax, smax, MsmInitMsg::smin, smin, split, splitting(), srx_x, srx_y, srx_z, sry_x, sry_y, sry_z, srz_x, srz_y, srz_z, sx_shx, sy_shy, sz_shz, TAYLOR2, TAYLOR2_DISP, TAYLOR3, TAYLOR4, TAYLOR5, TAYLOR6, TAYLOR7, TAYLOR8, Vector::unit(), virial, VMAX, Vector::x, Vector::y, and Vector::z.

{
#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsmMgr:  initialize() PE %d\n", CkMyPe());
#endif

  smin = msg->smin;
  smax = msg->smax;
  delete msg;

#if 0
  printf("PE%d: initializing MSM\n", CkMyPe());
#endif

  SimParameters *simParams = Node::Object()->simParameters;

  // get required sim params, check validity
  lattice = simParams->lattice;

  // set user-defined extent of system
  Vector rmin(simParams->MSMxmin, simParams->MSMymin, simParams->MSMzmin);
  Vector rmax(simParams->MSMxmax, simParams->MSMymax, simParams->MSMzmax);
  Vector sdmin = lattice.scale(rmin);
  Vector sdmax = lattice.scale(rmax);
  // swap coordinates between min and max to correct for possible rotation
  if (sdmin.x > sdmax.x) { double t=sdmin.x; sdmin.x=sdmax.x; sdmax.x=t; }
  if (sdmin.y > sdmax.y) { double t=sdmin.y; sdmin.y=sdmax.y; sdmax.y=t; }
  if (sdmin.z > sdmax.z) { double t=sdmin.z; sdmin.z=sdmax.z; sdmax.z=t; }
  // extend smin, smax by user-defined extent, where appropriate
  if ( ! lattice.a_p() && (sdmin.x != 0 || sdmax.x != 0)) {
    if (sdmin.x < smin.x) {
      smin.x = sdmin.x;
      if (CkMyPe() == 0) {
        iout << iINFO << "MSM extending minimum X to "
          << simParams->MSMxmin << " A\n" << endi;
      }
    }
    if (sdmax.x > smax.x) {
      smax.x = sdmax.x;
      if (CkMyPe() == 0) {
        iout << iINFO << "MSM extending maximum X to "
          << simParams->MSMxmax << " A\n" << endi;
      }
    }
  }
  if ( ! lattice.b_p() && (sdmin.y != 0 || sdmax.y != 0)) {
    if (sdmin.y < smin.y) {
      smin.y = sdmin.y;
      if (CkMyPe() == 0) {
        iout << iINFO << "MSM extending minimum Y to "
          << simParams->MSMymin << " A\n" << endi;
      }
    }
    if (sdmax.y > smax.y) {
      smax.y = sdmax.y;
      if (CkMyPe() == 0) {
        iout << iINFO << "MSM extending maximum Y to "
          << simParams->MSMymax << " A\n" << endi;
      }
    }
  }
  if ( ! lattice.c_p() && (sdmin.z != 0 || sdmax.z != 0)) {
    if (sdmin.z < smin.z) {
      smin.z = sdmin.z;
      if (CkMyPe() == 0) {
        iout << iINFO << "MSM extending minimum Z to "
          << simParams->MSMzmin << " A\n" << endi;
      }
    }
    if (sdmax.z > smax.z) {
      smax.z = sdmax.z;
      if (CkMyPe() == 0) {
        iout << iINFO << "MSM extending maximum Z to "
          << simParams->MSMzmax << " A\n" << endi;
      }
    }
  }

#ifdef DEBUG_MSM_VERBOSE
  printf("smin = %g %g %g  smax = %g %g %g\n",
      smin.x, smin.y, smin.z, smax.x, smax.y, smax.z);
#endif

  approx = simParams->MSMApprox;
  if (approx < 0 || approx >= NUM_APPROX) {
    NAMD_die("MSM: unknown approximation requested (MSMApprox)");
  }

  split = simParams->MSMSplit;
  if (split < 0 || split >= NUM_SPLIT) {
    NAMD_die("MSM: unknown splitting requested (MSMSplit)");
  }

  if (CkMyPe() == 0) {
    const char *approx_str, *split_str;
    switch (approx) {
      case CUBIC:      approx_str = "C1 cubic";    break;
      case QUINTIC:    approx_str = "C1 quintic";  break;
      case QUINTIC2:   approx_str = "C2 quintic";  break;
      case SEPTIC:     approx_str = "C1 septic";   break;
      case SEPTIC3:    approx_str = "C3 septic";   break;
      case NONIC:      approx_str = "C1 nonic";    break;
      case NONIC4:     approx_str = "C4 nonic";    break;
      case C1HERMITE:  approx_str = "C1 Hermite";  break;
      default:         approx_str = "unknown";     break;
    }
    switch (split) {
      case TAYLOR2:  split_str = "C2 Taylor";   break;
      case TAYLOR3:  split_str = "C3 Taylor";   break;
      case TAYLOR4:  split_str = "C4 Taylor";   break;
      case TAYLOR5:  split_str = "C5 Taylor";   break;
      case TAYLOR6:  split_str = "C6 Taylor";   break;
      case TAYLOR7:  split_str = "C7 Taylor";   break;
      case TAYLOR8:  split_str = "C8 Taylor";   break;
      default:       split_str = "unknown";     break;
    }
    iout << iINFO << "MSM using "
                  << approx_str << " interpolation\n";
    iout << iINFO << "MSM using "
                  << split_str << " splitting function\n";
  }

  a = simParams->cutoff;

  if (approx == C1HERMITE) {
    gridScalingFactor = 2;
  }
  else {
    gridScalingFactor = 1;
  }

  gridspacing = gridScalingFactor * simParams->MSMGridSpacing;
  if (gridspacing <= 0) {
    NAMD_die("MSM: grid spacing must be greater than 0 (MSMGridSpacing)");
  }
  else if (gridspacing >= a) {
    NAMD_die("MSM: grid spacing must be less than cutoff (MSMGridSpacing)");
  }

  padding = gridScalingFactor * simParams->MSMPadding;
  if (padding < 0) {
    NAMD_die("MSM: padding must be non-negative (MSMPadding)");
  }

  // set maximum number of levels (default 0 adapts levels to system)
  nlevels = simParams->MSMLevels;

  // XXX dispersion unused for now
  dispersion = 0;
  if ( ! dispersion && split >= TAYLOR2_DISP) {
    NAMD_die("MSM: requested splitting for long-range dispersion "
        "(not implemented)");
  }

  // set block sizes for grid decomposition
  int bsx = simParams->MSMBlockSizeX / int(gridScalingFactor);
  int bsy = simParams->MSMBlockSizeY / int(gridScalingFactor);
  int bsz = simParams->MSMBlockSizeZ / int(gridScalingFactor);
  if (bsx <= 0 || bsy <= 0 || bsz <= 0) {
    NAMD_die("MSM: invalid block size requested (MSMBlockSize[XYZ])");
  }
#ifdef MSM_FIXED_SIZE_GRID_MSG
  else if (bsx * bsy * bsz > MSM_MAX_BLOCK_VOLUME) {
    NAMD_die("MSM: requested block size (MSMBlockSize[XYZ]) too big");
  }
#endif
  if (CkMyPe() == 0) {
    iout << iINFO << "MSM block size decomposition along X is "
                  << bsx << " grid points\n";
    iout << iINFO << "MSM block size decomposition along Y is "
                  << bsy << " grid points\n";
    iout << iINFO << "MSM block size decomposition along Z is "
                  << bsz << " grid points\n";
  }

  s_edge = (PolyDegree[approx] - 1) / 2;  // stencil edge size
  omega = 2 * PolyDegree[approx];         // smallest non-periodic grid length

  BigReal xlen, ylen, zlen;
  Vector sgmin, sgmax;  // grid min and max, in scaled coordinates
  int ispx = lattice.a_p();
  int ispy = lattice.b_p();
  int ispz = lattice.c_p();
  int ispany = (ispx || ispy || ispz);  // is there any periodicity?

  if (ispx) {  // periodic along basis vector
    xlen = lattice.a().length();
    sgmax.x = 0.5;
    sgmin.x = -0.5;
  }
  else {  // non-periodic
    sgmax.x = smax.x + padding;  // pad the edges
    sgmin.x = smin.x - padding;
    ASSERT(gridspacing > 0);
    // restrict center to be on a grid point
    BigReal mupper = ceil(sgmax.x / (2*gridspacing));
    BigReal mlower = floor(sgmin.x / (2*gridspacing));
    sgmax.x = 2*gridspacing*mupper;
    sgmin.x = 2*gridspacing*mlower;
    xlen = sgmax.x - sgmin.x;
  }
#ifdef DEBUG_MSM_VERBOSE
  printf("xlen = %g   sgmin.x = %g   sgmax.x = %g\n", xlen, sgmin.x, sgmax.x);
#endif

  if (ispy) {  // periodic along basis vector
    ylen = lattice.b().length();
    sgmax.y = 0.5;
    sgmin.y = -0.5;
  }
  else {  // non-periodic
    sgmax.y = smax.y + padding;  // pad the edges
    sgmin.y = smin.y - padding;
    ASSERT(gridspacing > 0);
    // restrict center to be on a grid point
    BigReal mupper = ceil(sgmax.y / (2*gridspacing));
    BigReal mlower = floor(sgmin.y / (2*gridspacing));
    sgmax.y = 2*gridspacing*mupper;
    sgmin.y = 2*gridspacing*mlower;
    ylen = sgmax.y - sgmin.y;
  }
#ifdef DEBUG_MSM_VERBOSE
  printf("ylen = %g   sgmin.y = %g   sgmax.y = %g\n", ylen, sgmin.y, sgmax.y);
#endif

  if (ispz) {  // periodic along basis vector
    zlen = lattice.c().length();
    sgmax.z = 0.5;
    sgmin.z = -0.5;
  }
  else {  // non-periodic
    sgmax.z = smax.z + padding;  // pad the edges
    sgmin.z = smin.z - padding;
    ASSERT(gridspacing > 0);
    // restrict center to be on a grid point
    BigReal mupper = ceil(sgmax.z / (2*gridspacing));
    BigReal mlower = floor(sgmin.z / (2*gridspacing));
    sgmax.z = 2*gridspacing*mupper;
    sgmin.z = 2*gridspacing*mlower;
    zlen = sgmax.z - sgmin.z;
  }
#ifdef DEBUG_MSM_VERBOSE
  printf("zlen = %g   sgmin.z = %g   sgmax.z = %g\n", zlen, sgmin.z, sgmax.z);
#endif
  sglower = sgmin;

  int ia, ib, ja, jb, ka, kb;
  setup_hgrid_1d(xlen, hxlen, nhx, ia, ib, ispx);
  setup_hgrid_1d(ylen, hylen, nhy, ja, jb, ispy);
  setup_hgrid_1d(zlen, hzlen, nhz, ka, kb, ispz);
  hxlen_1 = 1 / hxlen;
  hylen_1 = 1 / hylen;
  hzlen_1 = 1 / hzlen;
  if (CkMyPe() == 0) {
    if (ispx || ispy || ispz) {
      iout << iINFO << "MSM grid spacing along X is "<< hxlen << " A\n";
      iout << iINFO << "MSM grid spacing along Y is "<< hylen << " A\n";
      iout << iINFO << "MSM grid spacing along Z is "<< hzlen << " A\n";
    }
    else {
      iout << iINFO << "MSM grid spacing is " << gridspacing << " A\n";
    }
    if ( ! ispx || ! ispy || ! ispz ) {
      iout << iINFO<<"MSM non-periodic padding is "<< padding << " A\n";
    }
  }

  int ni = ib - ia + 1;
  int nj = jb - ja + 1;
  int nk = kb - ka + 1;
  int n;

#if 0
  // reserve temp space for factored grid transfer operation
  n = (nk > omega ? nk : omega);  // row along z-dimension
  lzd.resize(n);
  n *= (nj > omega ? nj : omega);  // plane along yz-dimensions
  lyzd.resize(n);
#endif

  int lastnelems = 1;
  int smallestnbox = 1;
  int isclamped = 0;
  int maxlevels = nlevels;  // user-defined number of levels

#ifdef DEBUG_MSM_VERBOSE
  printf("maxlevels = %d\n", maxlevels);
#endif
  if (nlevels <= 0) {  // instead we set number of levels
    n = ni;
    if (n < nj) n = nj;
    if (n < nk) n = nk;
    for (maxlevels = 1;  n > 0;  n >>= 1)  maxlevels++;
    if (ispany == 0) {  // no periodicity
      // use rule of thumb 3/4 diameter of grid cutoff sphere
      int ngci = (int) ceil(3*a / hxlen) - 1;
      int ngcj = (int) ceil(3*a / hylen) - 1;
      int ngck = (int) ceil(3*a / hzlen) - 1;
      int omega3 = omega * omega * omega;
      int nhalf = (int) sqrt((double)ni * nj * nk);
      lastnelems = (nhalf > omega3 ? nhalf : omega3);
      smallestnbox = ngci * ngcj * ngck;  // smaller grids don't reduce work
      isclamped = 1;
    }
  }
#ifdef DEBUG_MSM_VERBOSE
  printf("maxlevels = %d\n", maxlevels);
#endif

  // allocate space for storing grid dimensions for each level
  map.gridrange.resize(maxlevels);

  // set periodicity flags
  map.ispx = ispx;
  map.ispy = ispy;
  map.ispz = ispz;

  int level = 0;
  int done = 0;
  int alldone = 0;
  do {
    map.gridrange[level].setbounds(ia, ib, ja, jb, ka, kb);

    // Msm index?

    if (++level == nlevels)  done |= 0x07;  // user limit on levels

    if (isclamped) {
      int nelems = ni * nj * nk;
      if (nelems <= lastnelems)    done |= 0x07;
      if (nelems <= smallestnbox)  done |= 0x07;
    }

    alldone = (done == 0x07);  // make sure all dimensions are done

    if (ispx) {
      ni >>= 1;
      ib = ni-1;
      if (ni & 1)        done |= 0x07;  // == 3 or 1
      else if (ni == 2)  done |= 0x01;  // can do one more
    }
    else {
      ia = -((-ia+1)/2) - s_edge;
      ib = (ib+1)/2 + s_edge;
      ni = ib - ia + 1;
      if (ni <= omega)   done |= 0x01;  // can do more restrictions
    }

    if (ispy) {
      nj >>= 1;
      jb = nj-1;
      if (nj & 1)        done |= 0x07;  // == 3 or 1
      else if (nj == 2)  done |= 0x02;  // can do one more
    }
    else {
      ja = -((-ja+1)/2) - s_edge;
      jb = (jb+1)/2 + s_edge;
      nj = jb - ja + 1;
      if (nj <= omega)   done |= 0x02;  // can do more restrictions
    }

    if (ispz) {
      nk >>= 1;
      kb = nk-1;
      if (nk & 1)        done |= 0x07;  // == 3 or 1
      else if (nk == 2)  done |= 0x04;  // can do one more
    }
    else {
      ka = -((-ka+1)/2) - s_edge;
      kb = (kb+1)/2 + s_edge;
      nk = kb - ka + 1;
      if (nk <= omega)   done |= 0x04;  // can do more restrictions
    }
  } while ( ! alldone );
  nlevels = level;

  // for periodic boundaries, don't visit top level (all 0)
  // toplevel visited only for all nonperiodic boundaries
  int toplevel = (ispany ? nlevels : nlevels - 1);

  // resize down to the actual number of levels (does not change alloc)
  map.gridrange.resize(nlevels);

  // print out some information about MSM
  if (CkMyPe() == 0) {
    iout << iINFO << "MSM using " << nlevels << " levels\n";
    for (n = 0;  n < nlevels;  n++) {
      char s[100];
      snprintf(s, sizeof(s), "    level %d:  "
          "[%d..%d] x [%d..%d] x [%d..%d]\n", n,
          map.gridrange[n].ia(), map.gridrange[n].ib(),
          map.gridrange[n].ja(), map.gridrange[n].jb(),
          map.gridrange[n].ka(), map.gridrange[n].kb());
      iout << iINFO << s;
    }
    iout << endi;
  }

  // find grid spacing basis vectors
  hu = hxlen * lattice.a().unit();
  hv = hylen * lattice.b().unit();
  hw = hzlen * lattice.c().unit();
  hufx = Float(hu.x);
  hufy = Float(hu.y);
  hufz = Float(hu.z);
  hvfx = Float(hv.x);
  hvfy = Float(hv.y);
  hvfz = Float(hv.z);
  hwfx = Float(hw.x);
  hwfy = Float(hw.y);
  hwfz = Float(hw.z);

  ru = lattice.a_r();
  rv = lattice.b_r();
  rw = lattice.c_r();

  // determine grid spacings in scaled space
  shx = ru * hu;
  shy = rv * hv;
  shz = rw * hw;
  shx_1 = 1 / shx;
  shy_1 = 1 / shy;
  shz_1 = 1 / shz;

  // row vectors to transform interpolated force back to real space
  // XXX Is not needed.
  sx_shx = shx_1 * Vector(ru.x, rv.x, rw.x);
  sy_shy = shy_1 * Vector(ru.y, rv.y, rw.y);
  sz_shz = shz_1 * Vector(ru.z, rv.z, rw.z);
  srx_x = Float(sx_shx.x);
  srx_y = Float(sx_shx.y);
  srx_z = Float(sx_shx.z);
  sry_x = Float(sy_shy.x);
  sry_y = Float(sy_shy.y);
  sry_z = Float(sy_shy.z);
  srz_x = Float(sz_shz.x);
  srz_y = Float(sz_shz.y);
  srz_z = Float(sz_shz.z);

  Vector pu = cross(hv, hw);
  BigReal s = (hu * pu) / (pu * pu);
  pu *= s;  // pu is orthogonal projection of hu onto hv CROSS hw

  Vector pv = cross(hw, hu);
  s = (hv * pv) / (pv * pv);
  pv *= s;  // pv is orthogonal projection of hv onto hw CROSS hu

  Vector pw = cross(hu, hv);
  s = (hw * pw) / (pw * pw);
  pw *= s;  // pw is orthogonal projection of hw onto hu CROSS hv

  // radii for parallelepiped of weights enclosing grid cutoff sphere
  ni = (int) ceil(2*a / pu.length() ) - 1;
  nj = (int) ceil(2*a / pv.length() ) - 1;
  nk = (int) ceil(2*a / pw.length() ) - 1;

  Float scaling = 1;
  Float scaling_factor = 0.5f;
  BigReal a_1 = 1/a;
  BigReal a_p = a_1;
  if (dispersion) {
    a_p = a_p * a_p * a_p;   // = 1/a^3
    a_p = a_p * a_p;         // = 1/a^6
    scaling_factor = 1.f/64;  // = 1/2^6
  }
  int i, j, k;
  if (approx < C1HERMITE) {
    // resize gc and gvc constants for number of levels
    map.gc.resize(nlevels);
    map.gvc.resize(nlevels);

    for (level = 0;  level < toplevel;  level++) {
      map.gc[level].setbounds(-ni, ni, -nj, nj, -nk, nk);
      map.gvc[level].setbounds(-ni, ni, -nj, nj, -nk, nk);

      for (k = -nk;  k <= nk;  k++) {
        for (j = -nj;  j <= nj;  j++) {
          for (i = -ni;  i <= ni;  i++) {
            if (level == 0) {
              BigReal s, t, gs=0, gt=0, g=0, dgs=0, dgt=0, dg=0;
              BigReal vlen = (i*hu + j*hv + k*hw).length();
              s = vlen * a_1;
              t = 0.5 * s;
              if (t >= 1) {
                g = 0;
                dg = 0;
              }
              else {
                splitting(gt, dgt, t, split);
                if (s >= 1) {
                  BigReal s_1 = 1/s;
                  if (dispersion) {
                    gs = s_1 * s_1 * s_1;  // = 1/s^3
                    gs = gs * gs;  // = 1/s^6
                    dgs = -6 * gs * s_1;
                  }
                  else {
                    gs = s_1;
                    dgs = -gs * s_1;
                  }
                }
                else {
                  splitting(gs, dgs, s, split);
                }
                g = (gs - scaling_factor * gt) * a_p;
                BigReal c=0;
                if (i || j || k) {
                  c = a_p * a_1 / vlen;
                }
                dg = 0.5 * (dgs - 0.5*scaling_factor * dgt) * c;

                // Msm index?

              }
              map.gc[0](i,j,k) = Float(g);
              map.gvc[0](i,j,k) = Float(dg);
            } // if level 0
            else {
              map.gc[level](i,j,k) = scaling * map.gc[0](i,j,k);
              map.gvc[level](i,j,k) = scaling * map.gvc[0](i,j,k);
            }

          } // for i
        } // for j
      } // for k
      scaling *= scaling_factor;

    } // for level

    // for summed virial factors
    gvsum.setbounds(-ni, ni, -nj, nj, -nk, nk);
    // make sure final virial sum is initialized to 0
    for (i = 0;  i < VMAX;  i++) { virial[i] = 0; }

    if (toplevel < nlevels) {
      // nonperiodic along all basis vector directions
      // calculate top level weights where all grid points
      // interact with each other
      ni = map.gridrange[toplevel].ni();
      nj = map.gridrange[toplevel].nj();
      nk = map.gridrange[toplevel].nk();
      map.gc[toplevel].setbounds(-ni, ni, -nj, nj, -nk, nk);

      // Msm index?

      for (k = -nk;  k <= nk;  k++) {
        for (j = -nj;  j <= nj;  j++) {
          for (i = -ni;  i <= ni;  i++) {
            BigReal s, gs, d;
            BigReal vlen = (i*hu + j*hv + k*hw).length();
            s = vlen * a_1;
            if (s >= 1) {
              BigReal s_1 = 1/s;
              if (dispersion) {
                gs = s_1 * s_1 * s_1;  // = 1/s^3
                gs = gs * gs;  // = 1/s^6
              }
              else {
                gs = s_1;
              }
            }
            else {
              splitting(gs, d, s, split);
            }
            map.gc[toplevel](i,j,k) = scaling * Float(gs * a_p);
          } // for i
        } // for j
      } // for k
    } // if toplevel

    // generate grespro stencil
    const int nstencil = Nstencil[approx];
    const Float *phi = PhiStencil[approx];
    map.grespro.set(0, nstencil, 0, nstencil, 0, nstencil);
    for (k = 0;  k < nstencil;  k++) {
      for (j = 0;  j < nstencil;  j++) {
        for (i = 0;  i < nstencil;  i++) {
          map.grespro(i,j,k) = phi[i] * phi[j] * phi[k];
        }
      }
    }

  } // end if approx < C1HERMITE
  else {
    // C1HERMITE
    // resize gc_c1hermite constants for number of levels
    map.gc_c1hermite.resize(nlevels);
    scaling = 1;

    for (level = 0;  level < toplevel;  level++) {

      Vector hmu = scaling * hu;
      Vector hmv = scaling * hv;
      Vector hmw = scaling * hw;
      BigReal am = scaling * a;

      map.gc_c1hermite[level].setbounds(-ni, ni, -nj, nj, -nk, nk);

      for (k = -nk;  k <= nk;  k++) {
        for (j = -nj;  j <= nj;  j++) {
          for (i = -ni;  i <= ni;  i++) {
            C1Matrix& m = map.gc_c1hermite[level](i,j,k);
            Vector rv = i*hmu + j*hmv + k*hmw;
            BigReal r2 = rv * rv;
            m.set(0);
            if (r2 < 4*am*am) {
              // accumulate D( g_{a}(0,r) ) term for this level
              gc_c1hermite_elem_accum(m, 1, rv, am, split);
              // accumulate D( -g_{2a}(0,r) ) term for this level
              gc_c1hermite_elem_accum(m, -1, rv, 2*am, split);
            } // if within cutoff
          }
        }
      } // end loop over gc_c1hermite elements for this level
      scaling *= 2;  // double grid spacing and cutoff at each iteration

    } // end loop over levels

    if (toplevel < nlevels) {
      Vector hmu = scaling * hu;
      Vector hmv = scaling * hv;
      Vector hmw = scaling * hw;
      BigReal am = scaling * a;

      // nonperiodic along all basis vector directions
      // calculate top level weights where all grid points
      // interact with each other
      ni = map.gridrange[toplevel].ni();
      nj = map.gridrange[toplevel].nj();
      nk = map.gridrange[toplevel].nk();
      map.gc_c1hermite[toplevel].setbounds(-ni, ni, -nj, nj, -nk, nk);

      for (k = -nk;  k <= nk;  k++) {
        for (j = -nj;  j <= nj;  j++) {
          for (i = -ni;  i <= ni;  i++) {
            C1Matrix& m = map.gc_c1hermite[level](i,j,k);
            Vector rv = i*hmu + j*hmv + k*hmw;
            m.set(0);
            // accumulate D( g_{a}(0,r) ) term for this level
            gc_c1hermite_elem_accum(m, 1, rv, am, split);
          }
        }
      } // end loop over gc_c1hermite elements for top level

    } // end if top level

    // C1 Hermite restriction and prolongation stencils
    map.gres_c1hermite.resize(nlevels-1);
    map.gpro_c1hermite.resize(nlevels-1);

    enum {
      ND = 3,    // stencil diameter
      NR = ND/2  // stencil radius
    };

    // the master basis functions PHI0 and PHI1 for the 3-point stencil
    // and their derivatives DPHI0 and DPHI1
    const double  PHI0[ND] = { 0.5, 1, 0.5 };
    const double DPHI0[ND] = { 1.5, 0, -1.5 };
    const double  PHI1[ND] = { -0.125, 0, 0.125 };
    const double DPHI1[ND] = { -0.25, 1, -0.25 };

    // for intermediate calculations
    double  xphi0_base_array[ND];
    double dxphi0_base_array[ND];
    double  yphi0_base_array[ND];
    double dyphi0_base_array[ND];
    double  zphi0_base_array[ND];
    double dzphi0_base_array[ND];
    double  xphi1_base_array[ND];
    double dxphi1_base_array[ND];
    double  yphi1_base_array[ND];
    double dyphi1_base_array[ND];
    double  zphi1_base_array[ND];
    double dzphi1_base_array[ND];
    // will point to center of stencil arrays
    double *xphi0, *dxphi0, *xphi1, *dxphi1;
    double *yphi0, *dyphi0, *yphi1, *dyphi1;
    double *zphi0, *dzphi0, *zphi1, *dzphi1;

    for (n = 0;  n < ND;  n++) {
      xphi0_base_array[n]  = PHI0[n];
      dxphi0_base_array[n] = hxlen_1 * DPHI0[n];  // scale by grid spacing
      xphi1_base_array[n]  = hxlen * PHI1[n];     // scale by grid spacing
      dxphi1_base_array[n] = DPHI1[n];
      yphi0_base_array[n]  = PHI0[n];
      dyphi0_base_array[n] = hylen_1 * DPHI0[n];  // scale by grid spacing
      yphi1_base_array[n]  = hylen * PHI1[n];     // scale by grid spacing
      dyphi1_base_array[n] = DPHI1[n];
      zphi0_base_array[n]  = PHI0[n];
      dzphi0_base_array[n] = hzlen_1 * DPHI0[n];  // scale by grid spacing
      zphi1_base_array[n]  = hzlen * PHI1[n];     // scale by grid spacing
      dzphi1_base_array[n] = DPHI1[n];
    }
    xphi0  =  xphi0_base_array + NR;  // point into center of arrays
    dxphi0 = dxphi0_base_array + NR;
    xphi1  =  xphi1_base_array + NR;
    dxphi1 = dxphi1_base_array + NR;
    yphi0  =  yphi0_base_array + NR;
    dyphi0 = dyphi0_base_array + NR;
    yphi1  =  yphi1_base_array + NR;
    dyphi1 = dyphi1_base_array + NR;
    zphi0  =  zphi0_base_array + NR;
    dzphi0 = dzphi0_base_array + NR;
    zphi1  =  zphi1_base_array + NR;
    dzphi1 = dzphi1_base_array + NR;

    for (level = 0;  level < nlevels-1;  level++) {
      // allocate space for restriction and prolongation stencils
      map.gres_c1hermite[level].set(0, ND, 0, ND, 0, ND);
      map.gpro_c1hermite[level].set(0, ND, 0, ND, 0, ND);

      // scale up to next level grid spacing
      //
      // have to determine for each dimension whether or not 
      // a periodic grid spacing has increased 
      // (equivalent to if there are fewer grid points)
      for (n = -NR;  n <= NR;  n++) {
        if ( ! ispx ||
              map.gridrange[level+1].ni() < map.gridrange[level].ni() ) {
          dxphi0[n] *= 0.5;
          xphi1[n] *= 2;
        }
        if ( ! ispy ||
              map.gridrange[level+1].nj() < map.gridrange[level].nj() ) {
          dyphi0[n] *= 0.5;
          yphi1[n] *= 2;
        }
        if ( ! ispz ||
              map.gridrange[level+1].nk() < map.gridrange[level].nk() ) {
          dzphi0[n] *= 0.5;
          zphi1[n] *= 2;
        }
      }

      // loop over restriction stencil matrices
      // calculate from partial derivatives
      for (k = -NR;  k <= NR;  k++) {
        for (j = -NR;  j <= NR;  j++) {
          for (i = -NR;  i <= NR;  i++) {
            Float *t = map.gres_c1hermite[level](i+NR,j+NR,k+NR).melem;

            t[C1INDEX(D000,D000)] =  xphi0[i] *  yphi0[j]  *  zphi0[k];
            t[C1INDEX(D000,D100)] = dxphi0[i] *  yphi0[j]  *  zphi0[k];
            t[C1INDEX(D000,D010)] =  xphi0[i] * dyphi0[j]  *  zphi0[k];
            t[C1INDEX(D000,D001)] =  xphi0[i] *  yphi0[j]  * dzphi0[k];
            t[C1INDEX(D000,D110)] = dxphi0[i] * dyphi0[j]  *  zphi0[k];
            t[C1INDEX(D000,D101)] = dxphi0[i] *  yphi0[j]  * dzphi0[k];
            t[C1INDEX(D000,D011)] =  xphi0[i] * dyphi0[j]  * dzphi0[k];
            t[C1INDEX(D000,D111)] = dxphi0[i] * dyphi0[j]  * dzphi0[k];

            t[C1INDEX(D100,D000)] =  xphi1[i] *  yphi0[j]  *  zphi0[k];
            t[C1INDEX(D100,D100)] = dxphi1[i] *  yphi0[j]  *  zphi0[k];
            t[C1INDEX(D100,D010)] =  xphi1[i] * dyphi0[j]  *  zphi0[k];
            t[C1INDEX(D100,D001)] =  xphi1[i] *  yphi0[j]  * dzphi0[k];
            t[C1INDEX(D100,D110)] = dxphi1[i] * dyphi0[j]  *  zphi0[k];
            t[C1INDEX(D100,D101)] = dxphi1[i] *  yphi0[j]  * dzphi0[k];
            t[C1INDEX(D100,D011)] =  xphi1[i] * dyphi0[j]  * dzphi0[k];
            t[C1INDEX(D100,D111)] = dxphi1[i] * dyphi0[j]  * dzphi0[k];

            t[C1INDEX(D010,D000)] =  xphi0[i] *  yphi1[j]  *  zphi0[k];
            t[C1INDEX(D010,D100)] = dxphi0[i] *  yphi1[j]  *  zphi0[k];
            t[C1INDEX(D010,D010)] =  xphi0[i] * dyphi1[j]  *  zphi0[k];
            t[C1INDEX(D010,D001)] =  xphi0[i] *  yphi1[j]  * dzphi0[k];
            t[C1INDEX(D010,D110)] = dxphi0[i] * dyphi1[j]  *  zphi0[k];
            t[C1INDEX(D010,D101)] = dxphi0[i] *  yphi1[j]  * dzphi0[k];
            t[C1INDEX(D010,D011)] =  xphi0[i] * dyphi1[j]  * dzphi0[k];
            t[C1INDEX(D010,D111)] = dxphi0[i] * dyphi1[j]  * dzphi0[k];

            t[C1INDEX(D001,D000)] =  xphi0[i] *  yphi0[j]  *  zphi1[k];
            t[C1INDEX(D001,D100)] = dxphi0[i] *  yphi0[j]  *  zphi1[k];
            t[C1INDEX(D001,D010)] =  xphi0[i] * dyphi0[j]  *  zphi1[k];
            t[C1INDEX(D001,D001)] =  xphi0[i] *  yphi0[j]  * dzphi1[k];
            t[C1INDEX(D001,D110)] = dxphi0[i] * dyphi0[j]  *  zphi1[k];
            t[C1INDEX(D001,D101)] = dxphi0[i] *  yphi0[j]  * dzphi1[k];
            t[C1INDEX(D001,D011)] =  xphi0[i] * dyphi0[j]  * dzphi1[k];
            t[C1INDEX(D001,D111)] = dxphi0[i] * dyphi0[j]  * dzphi1[k];

            t[C1INDEX(D110,D000)] =  xphi1[i] *  yphi1[j]  *  zphi0[k];
            t[C1INDEX(D110,D100)] = dxphi1[i] *  yphi1[j]  *  zphi0[k];
            t[C1INDEX(D110,D010)] =  xphi1[i] * dyphi1[j]  *  zphi0[k];
            t[C1INDEX(D110,D001)] =  xphi1[i] *  yphi1[j]  * dzphi0[k];
            t[C1INDEX(D110,D110)] = dxphi1[i] * dyphi1[j]  *  zphi0[k];
            t[C1INDEX(D110,D101)] = dxphi1[i] *  yphi1[j]  * dzphi0[k];
            t[C1INDEX(D110,D011)] =  xphi1[i] * dyphi1[j]  * dzphi0[k];
            t[C1INDEX(D110,D111)] = dxphi1[i] * dyphi1[j]  * dzphi0[k];

            t[C1INDEX(D101,D000)] =  xphi1[i] *  yphi0[j]  *  zphi1[k];
            t[C1INDEX(D101,D100)] = dxphi1[i] *  yphi0[j]  *  zphi1[k];
            t[C1INDEX(D101,D010)] =  xphi1[i] * dyphi0[j]  *  zphi1[k];
            t[C1INDEX(D101,D001)] =  xphi1[i] *  yphi0[j]  * dzphi1[k];
            t[C1INDEX(D101,D110)] = dxphi1[i] * dyphi0[j]  *  zphi1[k];
            t[C1INDEX(D101,D101)] = dxphi1[i] *  yphi0[j]  * dzphi1[k];
            t[C1INDEX(D101,D011)] =  xphi1[i] * dyphi0[j]  * dzphi1[k];
            t[C1INDEX(D101,D111)] = dxphi1[i] * dyphi0[j]  * dzphi1[k];

            t[C1INDEX(D011,D000)] =  xphi0[i] *  yphi1[j]  *  zphi1[k];
            t[C1INDEX(D011,D100)] = dxphi0[i] *  yphi1[j]  *  zphi1[k];
            t[C1INDEX(D011,D010)] =  xphi0[i] * dyphi1[j]  *  zphi1[k];
            t[C1INDEX(D011,D001)] =  xphi0[i] *  yphi1[j]  * dzphi1[k];
            t[C1INDEX(D011,D110)] = dxphi0[i] * dyphi1[j]  *  zphi1[k];
            t[C1INDEX(D011,D101)] = dxphi0[i] *  yphi1[j]  * dzphi1[k];
            t[C1INDEX(D011,D011)] =  xphi0[i] * dyphi1[j]  * dzphi1[k];
            t[C1INDEX(D011,D111)] = dxphi0[i] * dyphi1[j]  * dzphi1[k];

            t[C1INDEX(D111,D000)] =  xphi1[i] *  yphi1[j]  *  zphi1[k];
            t[C1INDEX(D111,D100)] = dxphi1[i] *  yphi1[j]  *  zphi1[k];
            t[C1INDEX(D111,D010)] =  xphi1[i] * dyphi1[j]  *  zphi1[k];
            t[C1INDEX(D111,D001)] =  xphi1[i] *  yphi1[j]  * dzphi1[k];
            t[C1INDEX(D111,D110)] = dxphi1[i] * dyphi1[j]  *  zphi1[k];
            t[C1INDEX(D111,D101)] = dxphi1[i] *  yphi1[j]  * dzphi1[k];
            t[C1INDEX(D111,D011)] =  xphi1[i] * dyphi1[j]  * dzphi1[k];
            t[C1INDEX(D111,D111)] = dxphi1[i] * dyphi1[j]  * dzphi1[k];
          }
        }
      } // end loops over restriction stencil matrices

      // loop over prolongation stencil matrices
      // prolongation stencil matrices are the transpose of restriction
      for (k = -NR;  k <= NR;  k++) {
        for (j = -NR;  j <= NR;  j++) {
          for (i = -NR;  i <= NR;  i++) {
            Float *t = map.gres_c1hermite[level](i+NR,j+NR,k+NR).melem;
            Float *tt = map.gpro_c1hermite[level](i+NR,j+NR,k+NR).melem;

            tt[C1INDEX(D000,D000)] = t[C1INDEX(D000,D000)];
            tt[C1INDEX(D000,D100)] = t[C1INDEX(D100,D000)];
            tt[C1INDEX(D000,D010)] = t[C1INDEX(D010,D000)];
            tt[C1INDEX(D000,D001)] = t[C1INDEX(D001,D000)];
            tt[C1INDEX(D000,D110)] = t[C1INDEX(D110,D000)];
            tt[C1INDEX(D000,D101)] = t[C1INDEX(D101,D000)];
            tt[C1INDEX(D000,D011)] = t[C1INDEX(D011,D000)];
            tt[C1INDEX(D000,D111)] = t[C1INDEX(D111,D000)];

            tt[C1INDEX(D100,D000)] = t[C1INDEX(D000,D100)];
            tt[C1INDEX(D100,D100)] = t[C1INDEX(D100,D100)];
            tt[C1INDEX(D100,D010)] = t[C1INDEX(D010,D100)];
            tt[C1INDEX(D100,D001)] = t[C1INDEX(D001,D100)];
            tt[C1INDEX(D100,D110)] = t[C1INDEX(D110,D100)];
            tt[C1INDEX(D100,D101)] = t[C1INDEX(D101,D100)];
            tt[C1INDEX(D100,D011)] = t[C1INDEX(D011,D100)];
            tt[C1INDEX(D100,D111)] = t[C1INDEX(D111,D100)];

            tt[C1INDEX(D010,D000)] = t[C1INDEX(D000,D010)];
            tt[C1INDEX(D010,D100)] = t[C1INDEX(D100,D010)];
            tt[C1INDEX(D010,D010)] = t[C1INDEX(D010,D010)];
            tt[C1INDEX(D010,D001)] = t[C1INDEX(D001,D010)];
            tt[C1INDEX(D010,D110)] = t[C1INDEX(D110,D010)];
            tt[C1INDEX(D010,D101)] = t[C1INDEX(D101,D010)];
            tt[C1INDEX(D010,D011)] = t[C1INDEX(D011,D010)];
            tt[C1INDEX(D010,D111)] = t[C1INDEX(D111,D010)];

            tt[C1INDEX(D001,D000)] = t[C1INDEX(D000,D001)];
            tt[C1INDEX(D001,D100)] = t[C1INDEX(D100,D001)];
            tt[C1INDEX(D001,D010)] = t[C1INDEX(D010,D001)];
            tt[C1INDEX(D001,D001)] = t[C1INDEX(D001,D001)];
            tt[C1INDEX(D001,D110)] = t[C1INDEX(D110,D001)];
            tt[C1INDEX(D001,D101)] = t[C1INDEX(D101,D001)];
            tt[C1INDEX(D001,D011)] = t[C1INDEX(D011,D001)];
            tt[C1INDEX(D001,D111)] = t[C1INDEX(D111,D001)];

            tt[C1INDEX(D110,D000)] = t[C1INDEX(D000,D110)];
            tt[C1INDEX(D110,D100)] = t[C1INDEX(D100,D110)];
            tt[C1INDEX(D110,D010)] = t[C1INDEX(D010,D110)];
            tt[C1INDEX(D110,D001)] = t[C1INDEX(D001,D110)];
            tt[C1INDEX(D110,D110)] = t[C1INDEX(D110,D110)];
            tt[C1INDEX(D110,D101)] = t[C1INDEX(D101,D110)];
            tt[C1INDEX(D110,D011)] = t[C1INDEX(D011,D110)];
            tt[C1INDEX(D110,D111)] = t[C1INDEX(D111,D110)];

            tt[C1INDEX(D101,D000)] = t[C1INDEX(D000,D101)];
            tt[C1INDEX(D101,D100)] = t[C1INDEX(D100,D101)];
            tt[C1INDEX(D101,D010)] = t[C1INDEX(D010,D101)];
            tt[C1INDEX(D101,D001)] = t[C1INDEX(D001,D101)];
            tt[C1INDEX(D101,D110)] = t[C1INDEX(D110,D101)];
            tt[C1INDEX(D101,D101)] = t[C1INDEX(D101,D101)];
            tt[C1INDEX(D101,D011)] = t[C1INDEX(D011,D101)];
            tt[C1INDEX(D101,D111)] = t[C1INDEX(D111,D101)];

            tt[C1INDEX(D011,D000)] = t[C1INDEX(D000,D011)];
            tt[C1INDEX(D011,D100)] = t[C1INDEX(D100,D011)];
            tt[C1INDEX(D011,D010)] = t[C1INDEX(D010,D011)];
            tt[C1INDEX(D011,D001)] = t[C1INDEX(D001,D011)];
            tt[C1INDEX(D011,D110)] = t[C1INDEX(D110,D011)];
            tt[C1INDEX(D011,D101)] = t[C1INDEX(D101,D011)];
            tt[C1INDEX(D011,D011)] = t[C1INDEX(D011,D011)];
            tt[C1INDEX(D011,D111)] = t[C1INDEX(D111,D011)];

            tt[C1INDEX(D111,D000)] = t[C1INDEX(D000,D111)];
            tt[C1INDEX(D111,D100)] = t[C1INDEX(D100,D111)];
            tt[C1INDEX(D111,D010)] = t[C1INDEX(D010,D111)];
            tt[C1INDEX(D111,D001)] = t[C1INDEX(D001,D111)];
            tt[C1INDEX(D111,D110)] = t[C1INDEX(D110,D111)];
            tt[C1INDEX(D111,D101)] = t[C1INDEX(D101,D111)];
            tt[C1INDEX(D111,D011)] = t[C1INDEX(D011,D111)];
            tt[C1INDEX(D111,D111)] = t[C1INDEX(D111,D111)];
          }
        }
      } // end loops over prolongation stencil matrices

    } // end loop over levels

  } // end if C1HERMITE

  // calculate self energy factor for splitting
  BigReal gs=0, d=0;
  splitting(gs, d, 0, split);
  gzero = gs * a_p;

  if (CkMyPe() == 0) {
    iout << iINFO << "MSM finished calculating stencils\n" << endi;
  }

  // allocate map for patches
  PatchMap *pm = PatchMap::Object();
  int numpatches = pm->numPatches();
  map.patchList.resize(numpatches);
#ifdef DEBUG_MSM_VERBOSE
  printf("numPatches = %d\n", numpatches);
#endif

  // allocate map for blocks for each grid level
  map.blockLevel.resize(nlevels);
  map.bsx.resize(nlevels);
  map.bsy.resize(nlevels);
  map.bsz.resize(nlevels);
#ifdef MSM_FOLD_FACTOR
  map.foldfactor.resize(nlevels);
#endif
  for (level = 0;  level < nlevels;  level++) {
    msm::IndexRange& g = map.gridrange[level];
    msm::Grid<msm::BlockDiagram>& b = map.blockLevel[level];
    int gia = g.ia();
    int gni = g.ni();
    int gja = g.ja();
    int gnj = g.nj();
    int gka = g.ka();
    int gnk = g.nk();
    map.bsx[level] = bsx;
    map.bsy[level] = bsy;
    map.bsz[level] = bsz;
    if (/* map.bsx[level] < gni ||
        map.bsy[level] < gnj ||
        map.bsz[level] < gnk */ 1) {
      // make sure that block sizes divide evenly into periodic dimensions
      if (ispx) setup_periodic_blocksize(map.bsx[level], gni);
      if (ispy) setup_periodic_blocksize(map.bsy[level], gnj);
      if (ispz) setup_periodic_blocksize(map.bsz[level], gnk);
#ifdef MSM_DEBUG_VERBOSE
      if (CkMyPe() == 0) {
        printf("level = %d\n  map.bs* = %d %d %d  gn* = %d %d %d\n",
            level, map.bsx[level], map.bsy[level], map.bsz[level],gni,gnj,gnk);
      }
#endif
      // subdivide grid into multiple blocks
      //   == ceil(gni / bsx), etc.
      int bni = (gni / map.bsx[level]) + (gni % map.bsx[level] != 0);
      int bnj = (gnj / map.bsy[level]) + (gnj % map.bsy[level] != 0);
      int bnk = (gnk / map.bsz[level]) + (gnk % map.bsz[level] != 0);
#ifdef MSM_FOLD_FACTOR
      if (/* level > 2 && */ (bni == 1 || bnj == 1 || bnk == 1)) {
        map.foldfactor[level].set(bsx / gni, bsy / gnj, bsz / gnk);
#if 0
        if (CkMyPe() == 0) {
          printf("Setting MSM FoldFactor level %d:  %d %d %d\n",
              level, bsx / gni, bsy / gnj, bsz / gnk);
        }
#endif
      }
#endif
      b.set(0, bni, 0, bnj, 0, bnk);
      for (k = 0;  k < bnk;  k++) {
        for (j = 0;  j < bnj;  j++) {
          for (i = 0;  i < bni;  i++) {
            b(i,j,k).reset();
            int ia = gia + i*map.bsx[level];
            int ib = ia + map.bsx[level] - 1;
            int ja = gja + j*map.bsy[level];
            int jb = ja + map.bsy[level] - 1;
            int ka = gka + k*map.bsz[level];
            int kb = ka + map.bsz[level] - 1;
            if (ib >= gia + gni) ib = gia + gni - 1;
            if (jb >= gja + gnj) jb = gja + gnj - 1;
            if (kb >= gka + gnk) kb = gka + gnk - 1;
            b(i,j,k).nrange.setbounds(ia, ib, ja, jb, ka, kb);
          }
        }
      }
    }
    /*
    else {
      // make entire grid into single block
      b.set(0, 1, 0, 1, 0, 1);
      b(0,0,0).reset();
      b(0,0,0).nrange.set(gia, gni, gja, gnj, gka, gnk);
      // set correct block dimensions
      map.bsx[level] = gni;
      map.bsy[level] = gnj;
      map.bsz[level] = gnk;
    }
    */
  }
  //CkExit();
#ifdef DEBUG_MSM_VERBOSE
  printf("Done allocating map for grid levels\n");
  printf("Grid level decomposition:\n");
  for (level = 0;  level < nlevels;  level++) {
    msm::Grid<msm::BlockDiagram>& b = map.blockLevel[level];
    int bia = b.ia();
    int bib = b.ib();
    int bja = b.ja();
    int bjb = b.jb();
    int bka = b.ka();
    int bkb = b.kb();
    for (k = bka;  k <= bkb;  k++) {
      for (j = bja;  j <= bjb;  j++) {
        for (i = bia;  i <= bib;  i++) {
          int ia = b(i,j,k).nrange.ia();
          int ib = b(i,j,k).nrange.ib();
          int ja = b(i,j,k).nrange.ja();
          int jb = b(i,j,k).nrange.jb();
          int ka = b(i,j,k).nrange.ka();
          int kb = b(i,j,k).nrange.kb();
          printf("level=%d  id=%d %d %d  [%d..%d] x [%d..%d] x [%d..%d]"
              " --> %d\n",
              level, i, j, k, ia, ib, ja, jb, ka, kb,
              b(i,j,k).nrange.nn());
        }
      }
    }
  }
#endif
  if (CkMyPe() == 0) {
    iout << iINFO << "MSM finished creating map for grid levels\n" << endi;
  }

  initialize2();
} // ComputeMsmMgr::initialize()

initialize_create()

void ComputeMsmMgr::initialize_create

(

)

Definition at line 5798 of file ComputeMsm.C.

References approx, ASSERT, msm::Map::blockLevel, C1HERMITE, endi(), iINFO(), iout, map, msmBlock, msmC1HermiteBlock, msmC1HermiteGridCutoff, msmGridCutoff, msmProxy, msm::IndexRange::ni(), msm::IndexRange::nj(), msm::IndexRange::nk(), nlevels, numGridCutoff, MsmBlockProxyMsg::put(), MsmC1HermiteBlockProxyMsg::put(), MsmGridCutoffProxyMsg::put(), MsmC1HermiteGridCutoffProxyMsg::put(), and msm::Array< T >::resize().

                                      {
  int i, j, k, n, level;

  if (CkMyPe() == 0) {

    // on PE 0, create 3D chare array of MsmBlock for each level;
    // broadcast this array of proxies to the rest of the group
    if (approx == C1HERMITE) {
      msmC1HermiteBlock.resize(nlevels);
    }
    else {
      msmBlock.resize(nlevels);
    }
    for (level = 0;  level < nlevels;  level++) {
      int ni = map.blockLevel[level].ni();
      int nj = map.blockLevel[level].nj();
      int nk = map.blockLevel[level].nk();
#ifdef MSM_NODE_MAPPING
      CkPrintf("Using MsmBlockMap for level %d\n", level);
      CProxy_MsmBlockMap blockMap = CProxy_MsmBlockMap::ckNew(level);
      CkArrayOptions opts(ni, nj, nk);
      opts.setMap(blockMap);
      if (approx == C1HERMITE) {
        msmC1HermiteBlock[level] =
          CProxy_MsmC1HermiteBlock::ckNew(level, opts);
      }
      else {
        msmBlock[level] = CProxy_MsmBlock::ckNew(level, opts);
      }
#else
      if (approx == C1HERMITE) {
        msmC1HermiteBlock[level] =
          CProxy_MsmC1HermiteBlock::ckNew(level, ni, nj, nk);
      }
      else {
        msmBlock[level] = CProxy_MsmBlock::ckNew(level, ni, nj, nk);
      }
#endif
#ifdef DEBUG_MSM_VERBOSE
      printf("Create MsmBlock[%d] 3D chare array ( %d x %d x %d )\n",
          level, ni, nj, nk);
#endif
      char msg[128];
      int nijk = ni * nj * nk;
      sprintf(msg, "MSM grid level %d decomposed into %d block%s"
          " ( %d x %d x %d )\n",
          level, nijk, (nijk==1 ? "" : "s"), ni, nj, nk);
      iout << iINFO << msg;
    }
    if (approx == C1HERMITE) {
      MsmC1HermiteBlockProxyMsg *msg = new MsmC1HermiteBlockProxyMsg;
      msg->put(msmC1HermiteBlock);
      msmProxy.recvMsmC1HermiteBlockProxy(msg);  // broadcast
    }
    else {
      MsmBlockProxyMsg *msg = new MsmBlockProxyMsg;
      msg->put(msmBlock);
      msmProxy.recvMsmBlockProxy(msg);  // broadcast
    }

#ifdef MSM_GRID_CUTOFF_DECOMP
    // on PE 0, create 1D chare array of MsmGridCutoff
    // broadcast this array proxy to the rest of the group
#ifdef MSM_NODE_MAPPING
    CkPrintf("Using MsmGridCutoffMap\n");
    CProxy_MsmGridCutoffMap gcutMap = CProxy_MsmGridCutoffMap::ckNew();
    CkArrayOptions optsgcut(numGridCutoff);
    optsgcut.setMap(gcutMap);
    if (approx == C1HERMITE) {
      msmC1HermiteGridCutoff = CProxy_MsmC1HermiteGridCutoff::ckNew(optsgcut);
    }
    else {
      msmGridCutoff = CProxy_MsmGridCutoff::ckNew(optsgcut);
    }
#else
    if (approx == C1HERMITE) {
      msmC1HermiteGridCutoff =
        CProxy_MsmC1HermiteGridCutoff::ckNew(numGridCutoff);
    }
    else {
      msmGridCutoff = CProxy_MsmGridCutoff::ckNew(numGridCutoff);
    }
#endif
    if (approx == C1HERMITE) {
      MsmC1HermiteGridCutoffProxyMsg *gcmsg =
        new MsmC1HermiteGridCutoffProxyMsg;
      gcmsg->put(&msmC1HermiteGridCutoff);
      msmProxy.recvMsmC1HermiteGridCutoffProxy(gcmsg);
    }
    else {
      MsmGridCutoffProxyMsg *gcmsg = new MsmGridCutoffProxyMsg;
      gcmsg->put(&msmGridCutoff);
      msmProxy.recvMsmGridCutoffProxy(gcmsg);
    }

    // XXX PE 0 initializes each MsmGridCutoff
    // one-to-many
    // for M length chare array, better for each PE to initialize M/P?
    for (level = 0;  level < nlevels;  level++) { // for all levels
      msm::Grid<msm::BlockDiagram>& b = map.blockLevel[level];
      int bni = b.ni();
      int bnj = b.nj();
      int bnk = b.nk();
      for (k = 0;  k < bnk;  k++) { // for all blocks
        for (j = 0;  j < bnj;  j++) {
          for (i = 0;  i < bni;  i++) {
            // source for charges
            msm::BlockIndex bi = msm::BlockIndex(level, msm::Ivec(i,j,k));
            int numSendAcross = b(i,j,k).sendAcross.len();
            ASSERT( numSendAcross == b(i,j,k).indexGridCutoff.len() );
            // for this source, loop over destinations for potentials
            for (n = 0;  n < numSendAcross;  n++) {
              msm::BlockSend &bs = b(i,j,k).sendAcross[n];
              int index = b(i,j,k).indexGridCutoff[n];
              MsmGridCutoffInitMsg *bsmsg = new MsmGridCutoffInitMsg(bi, bs);
              if (approx == C1HERMITE) {
                msmC1HermiteGridCutoff[index].setup(bsmsg);
              }
              else {
                msmGridCutoff[index].setup(bsmsg);
              }
            } // traverse sendAcross, indexGridCutoff arrays

          }
        }
      } // end for all blocks

    } // end for all levels

    iout << iINFO << "MSM grid cutoff calculation decomposed into "
      << numGridCutoff << " work objects\n";
#endif
    iout << endi;
  }

#ifdef DEBUG_MSM_VERBOSE
  printf("end of initialization\n");
#endif
} // ComputeMsmMgr::initialize_create()

initVirialContrib()

void ComputeMsmMgr::initVirialContrib ( )

inline

Definition at line 529 of file ComputeMsm.C.

References cntVirialContrib, gvsum, and msm::Grid< T >::reset().

Referenced by doneVirialContrib().

                           {
    gvsum.reset(0);
    cntVirialContrib = 0;
  }

mapData()

msm::Map& ComputeMsmMgr::mapData ( )

inline

Definition at line 447 of file ComputeMsm.C.

References map.

Referenced by ComputeMsm::doWork(), MsmGridCutoffKernel< Float, Float >::init(), MsmBlockKernel< Float, Float >::MsmBlockKernel(), msm::PatchData::PatchData(), and ComputeMsm::saveResults().

{ return map; }

ndsplitting()

static void ComputeMsmMgr::ndsplitting ( BigReal  pg[], BigReal  s, int  n, int  _split  )

inlinestatic

Definition at line 1266 of file ComputeMsm.C.

References NAMD_die(), TAYLOR2, TAYLOR3, TAYLOR4, TAYLOR5, TAYLOR6, TAYLOR7, and TAYLOR8.

Referenced by gc_c1hermite_elem_accum().

                                                                      {
    int k = 0;
    if (k == n) return;
    if (s <= 1) {
      // compute derivatives of smoothed part
      switch (_split) {
        case TAYLOR2:
          pg[k++] = 1 + (s-1)*(-1./2 + (s-1)*(3./8));
          if (k == n) break;
          pg[k++] = -1./2 + (s-1)*(3./4);
          if (k == n) break;
          pg[k++] = 3./4;
          break;
        case TAYLOR3:
          pg[k++] = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16)));
          if (k == n) break;
          pg[k++] = -1./2 + (s-1)*(3./4 + (s-1)*(-15./16));
          if (k == n) break;
          pg[k++] = 3./4 + (s-1)*(-15./8);
          if (k == n) break;
          pg[k++] = -15./8;
          break;
        case TAYLOR4:
          pg[k++] = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                  + (s-1)*(35./128))));
          if (k == n) break;
          pg[k++] = -1./2 + (s-1)*(3./4 + (s-1)*(-15./16 + (s-1)*(35./32)));
          if (k == n) break;
          pg[k++] = 3./4 + (s-1)*(-15./8 + (s-1)*(105./32));
          if (k == n) break;
          pg[k++] = -15./8 + (s-1)*(105./16);
          if (k == n) break;
          pg[k++] = 105./16;
          break;
        case TAYLOR5:
          pg[k++] = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                  + (s-1)*(35./128 + (s-1)*(-63./256)))));
          if (k == n) break;
          pg[k++] = -1./2 + (s-1)*(3./4 + (s-1)*(-15./16 + (s-1)*(35./32
                  + (s-1)*(-315./256))));
          if (k == n) break;
          pg[k++] = 3./4 + (s-1)*(-15./8 + (s-1)*(105./32 + (s-1)*(-315./64)));
          if (k == n) break;
          pg[k++] = -15./8 + (s-1)*(105./16 + (s-1)*(-945./64));
          if (k == n) break;
          pg[k++] = 105./16 + (s-1)*(-945./32);
          if (k == n) break;
          pg[k++] = -945./32;
          break;
        case TAYLOR6:
          pg[k++] = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                  + (s-1)*(35./128 + (s-1)*(-63./256 + (s-1)*(231./1024))))));
          if (k == n) break;
          pg[k++] = -1./2 + (s-1)*(3./4 + (s-1)*(-15./16 + (s-1)*(35./32
                  + (s-1)*(-315./256 + (s-1)*(693./512)))));
          if (k == n) break;
          pg[k++] = 3./4 + (s-1)*(-15./8 + (s-1)*(105./32 + (s-1)*(-315./64
                  + (s-1)*(3465./512))));
          if (k == n) break;
          pg[k++] = -15./8 + (s-1)*(105./16 + (s-1)*(-945./64
                + (s-1)*(3465./128)));
          if (k == n) break;
          pg[k++] = 105./16 + (s-1)*(-945./32 + (s-1)*(10395./128));
          if (k == n) break;
          pg[k++] = -945./32 + (s-1)*(10395./64);
          if (k == n) break;
          pg[k++] = 10395./64;
          break;
        case TAYLOR7:
          pg[k++] = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                  + (s-1)*(35./128 + (s-1)*(-63./256
                      + (s-1)*(231./1024 + (s-1)*(-429./2048)))))));
          if (k == n) break;
          pg[k++] = -1./2 + (s-1)*(3./4 + (s-1)*(-15./16 + (s-1)*(35./32
                  + (s-1)*(-315./256 + (s-1)*(693./512
                      + (s-1)*(-3003./2048))))));
          if (k == n) break;
          pg[k++] = 3./4 + (s-1)*(-15./8 + (s-1)*(105./32 + (s-1)*(-315./64
                  + (s-1)*(3465./512 + (s-1)*(-9009./1024)))));
          if (k == n) break;
          pg[k++] = -15./8 + (s-1)*(105./16 + (s-1)*(-945./64 + (s-1)*(3465./128
                  + (s-1)*(-45045./1024))));
          if (k == n) break;
          pg[k++] = 105./16 + (s-1)*(-945./32 + (s-1)*(10395./128
                + (s-1)*(-45045./256)));
          if (k == n) break;
          pg[k++] = -945./32 + (s-1)*(10395./64 + (s-1)*(-135135./256));
          if (k == n) break;
          pg[k++] = 10395./64 + (s-1)*(-135135./128);
          if (k == n) break;
          pg[k++] = -135135./128;
          break;
        case TAYLOR8:
          pg[k++] = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                  + (s-1)*(35./128 + (s-1)*(-63./256
                      + (s-1)*(231./1024 + (s-1)*(-429./2048
                          + (s-1)*(6435./32768))))))));
          if (k == n) break;
          pg[k++] = -1./2 + (s-1)*(3./4 + (s-1)*(-15./16 + (s-1)*(35./32
                  + (s-1)*(-315./256 + (s-1)*(693./512
                      + (s-1)*(-3003./2048 + (s-1)*(6435./4096)))))));
          if (k == n) break;
          pg[k++] = 3./4 + (s-1)*(-15./8 + (s-1)*(105./32 + (s-1)*(-315./64
                  + (s-1)*(3465./512 + (s-1)*(-9009./1024
                      + (s-1)*(45045./4096))))));
          if (k == n) break;
          pg[k++] = -15./8 + (s-1)*(105./16 + (s-1)*(-945./64 + (s-1)*(3465./128
                  + (s-1)*(-45045./1024 + (s-1)*(135135./2048)))));
          if (k == n) break;
          pg[k++] = 105./16 + (s-1)*(-945./32 + (s-1)*(10395./128
                + (s-1)*(-45045./256 + (s-1)*(675675./2048))));
          if (k == n) break;
          pg[k++] = -945./32 + (s-1)*(10395./64 + (s-1)*(-135135./256
                + (s-1)*(675675./512)));
          if (k == n) break;
          pg[k++] = 10395./64 + (s-1)*(-135135./128 + (s-1)*(2027025./512));
          if (k == n) break;
          pg[k++] = -135135./128 + (s-1)*(2027025./256);
          if (k == n) break;
          pg[k++] = 2027025./256;
          break;
        default:
          NAMD_die("Unknown MSM splitting.");
      }
    } // if (s <= 1)
    else { // (s > 1)
      // compute derivatives of s^(-1/2)
      const BigReal s_1 = 1./s;
      BigReal s_p = sqrt(s_1);
      BigReal p = -0.5;
      BigReal _c = 1;
      pg[k++] = _c * s_p;
      while (k < n) {
        s_p *= s_1;
        _c *= p;
        p -= 1;
        pg[k++] = _c * s_p;
      }
    } // else (s > 1)
    // higher derivatives are zero
    while (k < n) pg[k++] = 0;
  } // ndsplitting()

numLevels()

int ComputeMsmMgr::numLevels ( ) const

inline

Definition at line 449 of file ComputeMsm.C.

References nlevels.

Referenced by MsmBlock::addCharge(), and MsmC1HermiteBlock::addCharge().

{ return nlevels; }

patchPtrArray()

msm::PatchPtrArray& ComputeMsmMgr::patchPtrArray ( )

inline

Definition at line 445 of file ComputeMsm.C.

References patchPtr.

Referenced by ComputeMsm::doWork(), and ComputeMsm::saveResults().

{ return patchPtr; }

recvMsmBlockProxy()

void ComputeMsmMgr::recvMsmBlockProxy

(

MsmBlockProxyMsg *

msg

)

Definition at line 5939 of file ComputeMsm.C.

References MsmBlockProxyMsg::get(), and msmBlock.

{
  msg->get(msmBlock);
  delete(msg);
}

recvMsmC1HermiteBlockProxy()

void ComputeMsmMgr::recvMsmC1HermiteBlockProxy

(

MsmC1HermiteBlockProxyMsg *

msg

)

Definition at line 5951 of file ComputeMsm.C.

References MsmC1HermiteBlockProxyMsg::get(), and msmC1HermiteBlock.

{
  msg->get(msmC1HermiteBlock);
  delete(msg);
}

recvMsmC1HermiteGridCutoffProxy()

void ComputeMsmMgr::recvMsmC1HermiteGridCutoffProxy

(

MsmC1HermiteGridCutoffProxyMsg *

msg

)

Definition at line 5959 of file ComputeMsm.C.

References MsmC1HermiteGridCutoffProxyMsg::get(), and msmC1HermiteGridCutoff.

{
  msg->get(&msmC1HermiteGridCutoff);
  delete(msg);
}

recvMsmGridCutoffProxy()

void ComputeMsmMgr::recvMsmGridCutoffProxy

(

MsmGridCutoffProxyMsg *

msg

)

Definition at line 5945 of file ComputeMsm.C.

References MsmGridCutoffProxyMsg::get(), and msmGridCutoff.

{
  msg->get(&msmGridCutoff);
  delete(msg);
}

setCompute()

void ComputeMsmMgr::setCompute ( ComputeMsm *  c )

inline

Definition at line 443 of file ComputeMsm.C.

References c, and msmCompute.

{ msmCompute = c;  c->setMgr(this); } // local

setup_hgrid_1d()

void ComputeMsmMgr::setup_hgrid_1d	(	BigReal	len,
		BigReal &	hh,
		int &	nn,
		int &	ia,
		int &	ib,
		int	isperiodic
	)

Definition at line 3893 of file ComputeMsm.C.

References ASSERT, gridspacing, NAMD_die(), and s_edge.

Referenced by initialize().

{
  ASSERT(gridspacing > 0);
  if (isperiodic) {
    const BigReal hmin = (4./5) * gridspacing;
    const BigReal hmax = 1.5 * hmin;
    hh = len;
    nn = 1;  // start with one grid point across length
    while (hh >= hmax) {
      hh *= 0.5;  // halve spacing and double grid points
      nn <<= 1;
    }
    if (hh < hmin) {
      if (nn < 4) {
        NAMD_die("Basis vector is too short or MSM grid spacing is too large");
      }
      hh *= (4./3);  // scale hh by 4/3 and nn by 3/4
      nn >>= 2;
      nn *= 3;
    }
    // now we have:  hmin <= h < hmax,
    // where nn is a power of 2 times no more than one power of 3
    ia = 0;
    ib = nn-1;
  }
  else {
    hh = gridspacing;
    // Instead of "nn = (int) ceil(len / hh);"
    // len is divisible by hh, up to roundoff error, so round to closest nn
    nn = (int) floor(len/hh + 0.5);
    ia = -s_edge;
    ib = nn + s_edge;
  }
} // ComputeMsmMgr::setup_hgrid_1d()

setup_periodic_blocksize()

void ComputeMsmMgr::setup_periodic_blocksize	(	int &	bsize,
		int	n
	)

Definition at line 3932 of file ComputeMsm.C.

References NAMD_die().

Referenced by initialize().

{
  if (n % bsize != 0) {
    // n is either 2^k or 3*2^k
    int newbsize = 1;
    if (n % 3 == 0) newbsize = 3;
    while (newbsize < bsize && newbsize < n) newbsize *= 2;
    if (bsize < newbsize) newbsize /= 2;
    if (n % newbsize != 0) {
      NAMD_die("MSM grid size for periodic dimensions must be "
          "a power of 2 times at most one power of 3");
    }
    bsize = newbsize;
  }
  return;
}

sign()

static int ComputeMsmMgr::sign ( int  n )

inlinestatic

Definition at line 452 of file ComputeMsm.C.

                                {
    return (n < 0 ? -1 : (n > 0 ? 1 : 0));
  }

splitting()

static void ComputeMsmMgr::splitting ( BigReal &  g, BigReal &  dg, BigReal  r_a, int  _split  )

inlinestatic

Definition at line 667 of file ComputeMsm.C.

References NAMD_die(), TAYLOR2, TAYLOR2_DISP, TAYLOR3, TAYLOR3_DISP, TAYLOR4, TAYLOR4_DISP, TAYLOR5, TAYLOR5_DISP, TAYLOR6, TAYLOR6_DISP, TAYLOR7, TAYLOR7_DISP, TAYLOR8, and TAYLOR8_DISP.

Referenced by initialize().

                                                                          {
    BigReal s = r_a * r_a;  // s = (r/a)^2, assuming 0 <= s <= 1
    switch (_split) {
      case TAYLOR2:
        g = 1 + (s-1)*(-1./2 + (s-1)*(3./8));
        dg = (2*r_a)*(-1./2 + (s-1)*(3./4));
        break;
      case TAYLOR3:
        g = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16)));
        dg = (2*r_a)*(-1./2 + (s-1)*(3./4 + (s-1)*(-15./16)));
        break;
      case TAYLOR4:
        g = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                + (s-1)*(35./128))));
        dg = (2*r_a)*(-1./2 + (s-1)*(3./4 + (s-1)*(-15./16
                + (s-1)*(35./32))));
        break;
      case TAYLOR5:
        g = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                + (s-1)*(35./128 + (s-1)*(-63./256)))));
        dg = (2*r_a)*(-1./2 + (s-1)*(3./4 + (s-1)*(-15./16
                + (s-1)*(35./32 + (s-1)*(-315./256)))));
        break;
      case TAYLOR6:
        g = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                + (s-1)*(35./128 + (s-1)*(-63./256
                    + (s-1)*(231./1024))))));
        dg = (2*r_a)*(-1./2 + (s-1)*(3./4 + (s-1)*(-15./16
                + (s-1)*(35./32 + (s-1)*(-315./256
                    + (s-1)*(693./512))))));
        break;
      case TAYLOR7:
        g = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
            + (s-1)*(35./128 + (s-1)*(-63./256
                + (s-1)*(231./1024 + (s-1)*(-429./2048)))))));
        dg = (2*r_a)*(-1./2 + (s-1)*(3./4 + (s-1)*(-15./16
                + (s-1)*(35./32 + (s-1)*(-315./256
                    + (s-1)*(693./512 + (s-1)*(-3003./2048)))))));
        break;
      case TAYLOR8:
        g = 1 + (s-1)*(-1./2 + (s-1)*(3./8 + (s-1)*(-5./16
                + (s-1)*(35./128 + (s-1)*(-63./256
                    + (s-1)*(231./1024 + (s-1)*(-429./2048
                        + (s-1)*(6435./32768))))))));
        dg = (2*r_a)*(-1./2 + (s-1)*(3./4 + (s-1)*(-15./16
                + (s-1)*(35./32 + (s-1)*(-315./256
                    + (s-1)*(693./512 + (s-1)*(-3003./2048
                        + (s-1)*(6435./4096))))))));
        break;
      case TAYLOR2_DISP:
        g = 1 + (s-1)*(-3 + (s-1)*(6));
        dg = (2*r_a)*(-3 + (s-1)*(12));
        break;
      case TAYLOR3_DISP:
        g = 1 + (s-1)*(-3 + (s-1)*(6 + (s-1)*(-10)));
        dg = (2*r_a)*(-3 + (s-1)*(12 + (s-1)*(-30)));
        break;
      case TAYLOR4_DISP:
        g = 1 + (s-1)*(-3 + (s-1)*(6 + (s-1)*(-10 + (s-1)*(15))));
        dg = (2*r_a)*(-3 + (s-1)*(12 + (s-1)*(-30 + (s-1)*(60))));
        break;
      case TAYLOR5_DISP:
        g = 1 + (s-1)*(-3 + (s-1)*(6 + (s-1)*(-10
                + (s-1)*(15 + (s-1)*(-21)))));
        dg = (2*r_a)*(-3 + (s-1)*(12 + (s-1)*(-30
                + (s-1)*(60 + (s-1)*(-105)))));
        break;
      case TAYLOR6_DISP:
        g = 1 + (s-1)*(-3 + (s-1)*(6 + (s-1)*(-10
                + (s-1)*(15 + (s-1)*(-21 + (s-1)*(28))))));
        dg = (2*r_a)*(-3 + (s-1)*(12 + (s-1)*(-30
                + (s-1)*(60 + (s-1)*(-105 + (s-1)*(168))))));
        break;
      case TAYLOR7_DISP:
        g = 1 + (s-1)*(-3 + (s-1)*(6 + (s-1)*(-10
                + (s-1)*(15 + (s-1)*(-21 + (s-1)*(28
                      + (s-1)*(-36)))))));
        dg = (2*r_a)*(-3 + (s-1)*(12 + (s-1)*(-30
                + (s-1)*(60 + (s-1)*(-105 + (s-1)*(168
                      + (s-1)*(-252)))))));
        break;
      case TAYLOR8_DISP:
        g = 1 + (s-1)*(-3 + (s-1)*(6 + (s-1)*(-10
                + (s-1)*(15 + (s-1)*(-21 + (s-1)*(28
                      + (s-1)*(-36 + (s-1)*(45))))))));
        dg = (2*r_a)*(-3 + (s-1)*(12 + (s-1)*(-30
                + (s-1)*(60 + (s-1)*(-105 + (s-1)*(168
                      + (s-1)*(-252 + (s-1)*(360))))))));
        break;
      default:
        NAMD_die("Unknown MSM splitting.");
    } // switch
  } // splitting()

stencil_1d()

void ComputeMsmMgr::stencil_1d ( Float  phi[], Float  t  )

inline

Definition at line 761 of file ComputeMsm.C.

References approx, CUBIC, NAMD_die(), NONIC, NONIC4, QUINTIC, QUINTIC2, SEPTIC, and SEPTIC3.

Referenced by msm::PatchData::anterpolation().

                                        {
    switch (approx) {
      case CUBIC:
        phi[0] = 0.5f * (1 - t) * (2 - t) * (2 - t);
        t--;
        phi[1] = (1 - t) * (1 + t - 1.5f * t * t);
        t--;
        phi[2] = (1 + t) * (1 - t - 1.5f * t * t);
        t--;
        phi[3] = 0.5f * (1 + t) * (2 + t) * (2 + t);
        break;
      case QUINTIC:
        phi[0] = (1.f/24) * (1-t) * (2-t) * (3-t) * (3-t) * (4-t);
        t--;
        phi[1] = (1-t) * (2-t) * (3-t) * ((1.f/6)
            + t * (0.375f - (5.f/24)*t));
        t--;
        phi[2] = (1-t*t) * (2-t) * (0.5f + t * (0.25f - (5.f/12)*t));
        t--;
        phi[3] = (1-t*t) * (2+t) * (0.5f - t * (0.25f + (5.f/12)*t));
        t--;
        phi[4] = (1+t) * (2+t) * (3+t) * ((1.f/6)
            - t * (0.375f + (5.f/24)*t));
        t--;
        phi[5] = (1.f/24) * (1+t) * (2+t) * (3+t) * (3+t) * (4+t);
        break;
      case QUINTIC2:
        phi[0] = (1.f/24) * (3-t) * (3-t) * (3-t) * (t-2) * (5*t-8);
        t--;
        phi[1] = (-1.f/24) * (2-t) * (t-1) * (-48+t*(153+t*(-114+t*25)));
        t--;
        phi[2] = (1.f/12) * (1-t) * (12+t*(12+t*(-3+t*(-38+t*25))));
        t--;
        phi[3] = (1.f/12) * (1+t) * (12+t*(-12+t*(-3+t*(38+t*25))));
        t--;
        phi[4] = (-1.f/24) * (2+t) * (t+1) * (48+t*(153+t*(114+t*25)));
        t--;
        phi[5] = (1.f/24) * (3+t) * (3+t) * (3+t) * (t+2) * (5*t+8);
        break;
      case SEPTIC:
        phi[0] = (-1.f/720)*(t-1)*(t-2)*(t-3)*(t-4)*(t-4)*(t-5)*(t-6);
        t--;
        phi[1] = (1.f/720)*(t-1)*(t-2)*(t-3)*(t-4)*(t-5)*(-6+t*(-20+7*t));
        t--;
        phi[2] = (-1.f/240)*(t*t-1)*(t-2)*(t-3)*(t-4)*(-10+t*(-12+7*t));
        t--;
        phi[3] = (1.f/144)*(t*t-1)*(t*t-4)*(t-3)*(-12+t*(-4+7*t));
        t--;
        phi[4] = (-1.f/144)*(t*t-1)*(t*t-4)*(t+3)*(-12+t*(4+7*t));
        t--;
        phi[5] = (1.f/240)*(t*t-1)*(t+2)*(t+3)*(t+4)*(-10+t*(12+7*t));
        t--;
        phi[6] = (-1.f/720)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*(-6+t*(20+7*t));
        t--;
        phi[7] = (1.f/720)*(t+1)*(t+2)*(t+3)*(t+4)*(t+4)*(t+5)*(t+6);
        break;
      case SEPTIC3:
        phi[0] = (3632.f/5) + t*((-7456.f/5) + t*((58786.f/45) + t*(-633
                + t*((26383.f/144) + t*((-22807.f/720) + t*((727.f/240)
                      + t*(-89.f/720)))))));
        t--;
        phi[1] = -440 + t*((25949.f/20) + t*((-117131.f/72) + t*((2247.f/2)
                + t*((-66437.f/144) + t*((81109.f/720) + t*((-727.f/48)
                      + t*(623.f/720)))))));
        t--;
        phi[2] = (138.f/5) + t*((-8617.f/60) + t*((12873.f/40) + t*((-791.f/2)
                + t*((4557.f/16) + t*((-9583.f/80) + t*((2181.f/80)
                      + t*(-623.f/240)))))));
        t--;
        phi[3] = 1 + t*t*((-49.f/36) + t*t*((-959.f/144) + t*((2569.f/144)
                + t*((-727.f/48) + t*(623.f/144)))));
        t--;
        phi[4] = 1 + t*t*((-49.f/36) + t*t*((-959.f/144) + t*((-2569.f/144)
                + t*((-727.f/48) + t*(-623.f/144)))));
        t--;
        phi[5] = (138.f/5) + t*((8617.f/60) + t*((12873.f/40) + t*((791.f/2)
                + t*((4557.f/16) + t*((9583.f/80) + t*((2181.f/80)
                      + t*(623.f/240)))))));
        t--;
        phi[6] = -440 + t*((-25949.f/20) + t*((-117131.f/72) + t*((-2247.f/2)
                + t*((-66437.f/144) + t*((-81109.f/720) + t*((-727.f/48)
                      + t*(-623.f/720)))))));
        t--;
        phi[7] = (3632.f/5) + t*((7456.f/5) + t*((58786.f/45) + t*(633
                + t*((26383.f/144) + t*((22807.f/720) + t*((727.f/240)
                      + t*(89.f/720)))))));
        break;
      case NONIC:
        phi[0] = (-1.f/40320)*(t-8)*(t-7)*(t-6)*(t-5)*(t-5)*(t-4)*(t-3)*
          (t-2)*(t-1);
        t--;
        phi[1] = (1.f/40320)*(t-7)*(t-6)*(t-5)*(t-4)*(t-3)*(t-2)*(t-1)*
          (-8+t*(-35+9*t));
        t--;
        phi[2] = (-1.f/10080)*(t-6)*(t-5)*(t-4)*(t-3)*(t-2)*(t-1)*(t+1)*
          (-14+t*(-25+9*t));
        t--;
        phi[3] = (1.f/1440)*(t-5)*(t-4)*(t-3)*(t-2)*(t-1)*(t+1)*(t+2)*
          (-6+t*(-5+3*t));
        t--;
        phi[4] = (-1.f/2880)*(t-4)*(t-3)*(t-2)*(t-1)*(t+1)*(t+2)*(t+3)*
          (-20+t*(-5+9*t));
        t--;
        phi[5] = (1.f/2880)*(t-3)*(t-2)*(t-1)*(t+1)*(t+2)*(t+3)*(t+4)*
          (-20+t*(5+9*t));
        t--;
        phi[6] = (-1.f/1440)*(t-2)*(t-1)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*
          (-6+t*(5+3*t));
        t--;
        phi[7] = (1.f/10080)*(t-1)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*(t+6)*
          (-14+t*(25+9*t));
        t--;
        phi[8] = (-1.f/40320)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*(t+6)*(t+7)*
          (-8+t*(35+9*t));
        t--;
        phi[9] = (1.f/40320)*(t+1)*(t+2)*(t+3)*(t+4)*(t+5)*(t+5)*(t+6)*
          (t+7)*(t+8);
        break;
      case NONIC4:
      { // begin grouping to define local variables
        double Tphi[10];
        double T=t;
        Tphi[0] = 439375./7+T*(-64188125./504+T*(231125375./2016
              +T*(-17306975./288+T*(7761805./384+T*(-2895587./640
                    +T*(129391./192+T*(-259715./4032+T*(28909./8064
                          +T*(-3569./40320)))))))));
        T--;
        Tphi[1] = -56375+T*(8314091./56+T*(-49901303./288+T*(3763529./32
                +T*(-19648027./384+T*(9469163./640+T*(-545977./192
                      +T*(156927./448+T*(-28909./1152
                          +T*(3569./4480)))))))));
        T--;
        Tphi[2] = 68776./7+T*(-1038011./28+T*(31157515./504+T*(-956669./16
                +T*(3548009./96+T*(-2422263./160+T*(197255./48
                      +T*(-19959./28+T*(144545./2016
                          +T*(-3569./1120)))))))));
        T--;
        Tphi[3] = -154+T*(12757./12+T*(-230123./72+T*(264481./48
                +T*(-576499./96+T*(686147./160+T*(-96277./48
                      +T*(14221./24+T*(-28909./288+T*(3569./480)))))))));
        T--;
        Tphi[4] = 1+T*T*(-205./144+T*T*(91./192+T*(-6181./320
                +T*(6337./96+T*(-2745./32+T*(28909./576
                      +T*(-3569./320)))))));
        T--;
        Tphi[5] = 1+T*T*(-205./144+T*T*(91./192+T*(6181./320
                +T*(6337./96+T*(2745./32+T*(28909./576
                      +T*(3569./320)))))));
        T--;
        Tphi[6] = -154+T*(-12757./12+T*(-230123./72+T*(-264481./48
                +T*(-576499./96+T*(-686147./160+T*(-96277./48
                      +T*(-14221./24+T*(-28909./288+T*(-3569./480)))))))));
        T--;
        Tphi[7] = 68776./7+T*(1038011./28+T*(31157515./504+T*(956669./16
                +T*(3548009./96+T*(2422263./160+T*(197255./48
                      +T*(19959./28+T*(144545./2016+T*(3569./1120)))))))));
        T--;
        Tphi[8] = -56375+T*(-8314091./56+T*(-49901303./288+T*(-3763529./32
                +T*(-19648027./384+T*(-9469163./640+T*(-545977./192
                      +T*(-156927./448+T*(-28909./1152
                          +T*(-3569./4480)))))))));
        T--;
        Tphi[9] = 439375./7+T*(64188125./504+T*(231125375./2016
              +T*(17306975./288+T*(7761805./384+T*(2895587./640
                    +T*(129391./192+T*(259715./4032+T*(28909./8064
                          +T*(3569./40320)))))))));
        for (int i=0;  i < 10;  i++) {
          phi[i] = Float(Tphi[i]);
        }
      } // end grouping to define local variables
        break;
      default:
        NAMD_die("Unknown MSM approximation.");
    } // switch
  } // stencil_1d()

stencil_1d_c1hermite()

void ComputeMsmMgr::stencil_1d_c1hermite ( Float  phi[], Float  psi[], Float  t, Float  h  )

inline

Definition at line 1244 of file ComputeMsm.C.

Referenced by msm::PatchData::anterpolationC1Hermite().

                                                                        {
    phi[0] = (1 - t) * (1 - t) * (1 + 2*t);
    psi[0] = h * t * (1 - t) * (1 - t);
    t--;
    phi[1] = (1 + t) * (1 + t) * (1 - 2*t);
    psi[1] = h * t * (1 + t) * (1 + t);
  }

subtractVirialContrib()

void ComputeMsmMgr::subtractVirialContrib ( )

inline

Definition at line 536 of file ComputeMsm.C.

References numVirialContrib.

                               {
    numVirialContrib--;
  }

update()

void ComputeMsmMgr::update

(

CkQdMsg *

msg

)

Definition at line 5967 of file ComputeMsm.C.

References approx, C1HERMITE, msmBlock, msmC1HermiteBlock, and nlevels.

{
#ifdef DEBUG_MSM_VERBOSE
  printf("ComputeMsmMgr:  update() PE %d\n", CkMyPe());
#endif
  delete msg;

  // have to setup sections AFTER initialization is finished
  if (CkMyPe() == 0) {
    for (int level = 0;  level < nlevels;  level++) {
      if (approx == C1HERMITE) {
        msmC1HermiteBlock[level].setupSections();
      }
      else {
        msmBlock[level].setupSections();
      }
    }
  }

  // XXX how do update for constant pressure simulation?
}

Friends And Related Function Documentation

msm::PatchData

friend struct msm::PatchData

friend

Definition at line 365 of file ComputeMsm.C.

MsmBlock

friend class MsmBlock

friend

Definition at line 366 of file ComputeMsm.C.

MsmBlockMap

friend class MsmBlockMap

friend

Definition at line 368 of file ComputeMsm.C.

MsmGridCutoffMap

friend class MsmGridCutoffMap

friend

Definition at line 369 of file ComputeMsm.C.

Member Data Documentation

a

BigReal ComputeMsmMgr::a

Definition at line 598 of file ComputeMsm.C.

Referenced by initialize().

approx

int ComputeMsmMgr::approx

Definition at line 604 of file ComputeMsm.C.

Referenced by addPotential(), msm::PatchData::anterpolation(), calcBlockWork(), compute(), d_stencil_1d(), msm::PatchData::init(), initialize(), initialize_create(), msm::PatchData::interpolation(), msm::PatchData::PatchData(), MsmBlockKernel< Float, Float >::prolongationKernel(), MsmBlockKernel< Float, Float >::restrictionKernel(), stencil_1d(), and update().

blockAssign

msm::Array<int> ComputeMsmMgr::blockAssign

Definition at line 484 of file ComputeMsm.C.

Referenced by MsmBlockMap::MsmBlockMap().

c

Vector ComputeMsmMgr::c

Definition at line 588 of file ComputeMsm.C.

Referenced by doneVirialContrib(), initialize(), and setCompute().

cntVirialContrib

int ComputeMsmMgr::cntVirialContrib

Definition at line 525 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initVirialContrib().

dispersion

int ComputeMsmMgr::dispersion

Definition at line 607 of file ComputeMsm.C.

Referenced by initialize().

gcutAssign

msm::Array<int> ComputeMsmMgr::gcutAssign

Definition at line 485 of file ComputeMsm.C.

Referenced by MsmGridCutoffMap::MsmGridCutoffMap().

gridScalingFactor

BigReal ComputeMsmMgr::gridScalingFactor

Definition at line 597 of file ComputeMsm.C.

Referenced by initialize().

gridspacing

BigReal ComputeMsmMgr::gridspacing

Definition at line 595 of file ComputeMsm.C.

Referenced by initialize(), and setup_hgrid_1d().

gvsum

msm::Grid<Float> ComputeMsmMgr::gvsum

Definition at line 523 of file ComputeMsm.C.

Referenced by doneVirialContrib(), initialize(), and initVirialContrib().

gzero

BigReal ComputeMsmMgr::gzero

Definition at line 608 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

hu

Vector ComputeMsmMgr::hu

Definition at line 601 of file ComputeMsm.C.

Referenced by initialize().

hufx

Float ComputeMsmMgr::hufx

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hufy

Float ComputeMsmMgr::hufy

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hufz

Float ComputeMsmMgr::hufz

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hv

Vector ComputeMsmMgr::hv

Definition at line 601 of file ComputeMsm.C.

Referenced by initialize().

hvfx

Float ComputeMsmMgr::hvfx

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hvfy

Float ComputeMsmMgr::hvfy

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hvfz

Float ComputeMsmMgr::hvfz

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hw

Vector ComputeMsmMgr::hw

Definition at line 601 of file ComputeMsm.C.

Referenced by initialize().

hwfx

Float ComputeMsmMgr::hwfx

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hwfy

Float ComputeMsmMgr::hwfy

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hwfz

Float ComputeMsmMgr::hwfz

Definition at line 602 of file ComputeMsm.C.

Referenced by doneVirialContrib(), and initialize().

hxlen

BigReal ComputeMsmMgr::hxlen

Definition at line 599 of file ComputeMsm.C.

Referenced by msm::PatchData::anterpolationC1Hermite(), initialize(), and msm::PatchData::interpolationC1Hermite().

hxlen_1

BigReal ComputeMsmMgr::hxlen_1

Definition at line 600 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

hylen

BigReal ComputeMsmMgr::hylen

Definition at line 599 of file ComputeMsm.C.

Referenced by msm::PatchData::anterpolationC1Hermite(), initialize(), and msm::PatchData::interpolationC1Hermite().

hylen_1

BigReal ComputeMsmMgr::hylen_1

Definition at line 600 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

hzlen

BigReal ComputeMsmMgr::hzlen

Definition at line 599 of file ComputeMsm.C.

Referenced by msm::PatchData::anterpolationC1Hermite(), initialize(), and msm::PatchData::interpolationC1Hermite().

hzlen_1

BigReal ComputeMsmMgr::hzlen_1

Definition at line 600 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

IndexOffset

const int ComputeMsmMgr::IndexOffset

static

Initial value:

= {
  
  {-3, -1, 0, 1, 3},

  
  {-5, -3, -1, 0, 1, 3, 5},

  
  {-5, -3, -1, 0, 1, 3, 5},

  
  {-7, -5, -3, -1, 0, 1, 3, 5, 7},

  
  {-7, -5, -3, -1, 0, 1, 3, 5, 7},

  
  {-9, -7, -5, -3, -1, 0, 1, 3, 5, 7, 9},

  
  {-9, -7, -5, -3, -1, 0, 1, 3, 5, 7, 9},

  
  {-1, 0, 1},
}

Definition at line 656 of file ComputeMsm.C.

Referenced by MsmBlockKernel< Float, Float >::prolongationKernel(), and MsmBlockKernel< Float, Float >::restrictionKernel().

ispu

int ComputeMsmMgr::ispu

Definition at line 590 of file ComputeMsm.C.

ispv

int ComputeMsmMgr::ispv

Definition at line 590 of file ComputeMsm.C.

ispw

int ComputeMsmMgr::ispw

Definition at line 590 of file ComputeMsm.C.

lattice

Lattice ComputeMsmMgr::lattice

Definition at line 592 of file ComputeMsm.C.

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

map

msm::Map ComputeMsmMgr::map

Definition at line 471 of file ComputeMsm.C.

Referenced by blockFlatIndex(), calcBlockWork(), calcGcutWork(), initialize(), initialize_create(), and mapData().

msmBlock

msm::Array<CProxy_MsmBlock> ComputeMsmMgr::msmBlock

Definition at line 464 of file ComputeMsm.C.

Referenced by MsmGridCutoff::compute(), initialize_create(), recvMsmBlockProxy(), msm::PatchData::sendCharge(), MsmBlock::sendDownPotential(), MsmBlock::sendUpCharge(), and update().

msmC1HermiteBlock

msm::Array<CProxy_MsmC1HermiteBlock> ComputeMsmMgr::msmC1HermiteBlock

Definition at line 465 of file ComputeMsm.C.

Referenced by MsmC1HermiteGridCutoff::compute(), initialize_create(), recvMsmC1HermiteBlockProxy(), msm::PatchData::sendChargeC1Hermite(), MsmC1HermiteBlock::sendDownPotential(), MsmC1HermiteBlock::sendUpCharge(), and update().

msmC1HermiteGridCutoff

CProxy_MsmC1HermiteGridCutoff ComputeMsmMgr::msmC1HermiteGridCutoff

Definition at line 468 of file ComputeMsm.C.

Referenced by initialize_create(), recvMsmC1HermiteGridCutoffProxy(), and MsmC1HermiteBlock::setupSections().

msmCompute

ComputeMsm* ComputeMsmMgr::msmCompute

Definition at line 462 of file ComputeMsm.C.

Referenced by doneCompute(), and setCompute().

msmGridCutoff

CProxy_MsmGridCutoff ComputeMsmMgr::msmGridCutoff

Definition at line 467 of file ComputeMsm.C.

Referenced by MsmBlock::gridCutoff(), MsmC1HermiteBlock::gridCutoff(), initialize_create(), recvMsmGridCutoffProxy(), and MsmBlock::setupSections().

msmProxy

CProxy_ComputeMsmMgr ComputeMsmMgr::msmProxy

Definition at line 461 of file ComputeMsm.C.

Referenced by initialize_create().

nhx

int ComputeMsmMgr::nhx

Definition at line 603 of file ComputeMsm.C.

Referenced by initialize().

nhy

int ComputeMsmMgr::nhy

Definition at line 603 of file ComputeMsm.C.

Referenced by initialize().

nhz

int ComputeMsmMgr::nhz

Definition at line 603 of file ComputeMsm.C.

Referenced by initialize().

nlevels

int ComputeMsmMgr::nlevels

Definition at line 606 of file ComputeMsm.C.

Referenced by MsmBlock::gridCutoff(), MsmC1HermiteBlock::gridCutoff(), initialize(), initialize_create(), numLevels(), MsmBlock::sendDownPotential(), MsmC1HermiteBlock::sendDownPotential(), MsmBlock::sendPatch(), MsmC1HermiteBlock::sendPatch(), MsmGridCutoffKernel< Float, Float >::setup(), MsmBlock::sumReducedPotential(), MsmC1HermiteBlock::sumReducedPotential(), and update().

Nstencil

const int ComputeMsmMgr::Nstencil

static

Initial value:

= {
  5, 7, 7, 9, 9, 11, 11, 3,
}

Definition at line 652 of file ComputeMsm.C.

Referenced by initialize(), MsmBlockKernel< Float, Float >::prolongationKernel(), and MsmBlockKernel< Float, Float >::restrictionKernel().

numGridCutoff

int ComputeMsmMgr::numGridCutoff

Definition at line 469 of file ComputeMsm.C.

Referenced by initialize_create().

numVirialContrib

int ComputeMsmMgr::numVirialContrib

Definition at line 524 of file ComputeMsm.C.

Referenced by addVirialContrib(), doneVirialContrib(), and subtractVirialContrib().

omega

int ComputeMsmMgr::omega

Definition at line 623 of file ComputeMsm.C.

Referenced by initialize().

padding

BigReal ComputeMsmMgr::padding

Definition at line 596 of file ComputeMsm.C.

Referenced by initialize().

patchPtr

msm::PatchPtrArray ComputeMsmMgr::patchPtr

Definition at line 476 of file ComputeMsm.C.

Referenced by addPotential(), compute(), and patchPtrArray().

PhiStencil

const Float ComputeMsmMgr::PhiStencil

static

Initial value:

= {
  
  {-1.f/16, 9.f/16, 1, 9.f/16, -1.f/16},

  
  {3.f/256, -25.f/256, 75.f/128, 1, 75.f/128, -25.f/256, 3.f/256},

  
  {3.f/256, -25.f/256, 75.f/128, 1, 75.f/128, -25.f/256, 3.f/256},

  
  { -5.f/2048, 49.f/2048, -245.f/2048, 1225.f/2048, 1, 1225.f/2048,
    -245.f/2048, 49.f/2048, -5.f/2048 },

  
  { -5.f/2048, 49.f/2048, -245.f/2048, 1225.f/2048, 1, 1225.f/2048,
    -245.f/2048, 49.f/2048, -5.f/2048 },

  
  { 35.f/65536, -405.f/65536, 567.f/16384, -2205.f/16384, 
    19845.f/32768, 1, 19845.f/32768, -2205.f/16384, 567.f/16384, 
    -405.f/65536, 35.f/65536 },

  
  { 35.f/65536, -405.f/65536, 567.f/16384, -2205.f/16384, 
    19845.f/32768, 1, 19845.f/32768, -2205.f/16384, 567.f/16384, 
    -405.f/65536, 35.f/65536 },
}

Definition at line 660 of file ComputeMsm.C.

Referenced by initialize().

PolyDegree

const int ComputeMsmMgr::PolyDegree

static

Initial value:

= {
  3, 5, 5, 7, 7, 9, 9, 1,
}

Definition at line 649 of file ComputeMsm.C.

Referenced by msm::PatchData::anterpolation(), initialize(), and msm::PatchData::interpolation().

ru

Vector ComputeMsmMgr::ru

Definition at line 589 of file ComputeMsm.C.

Referenced by initialize().

rv

Vector ComputeMsmMgr::rv

Definition at line 589 of file ComputeMsm.C.

Referenced by gc_c1hermite_elem_accum(), and initialize().

rw

Vector ComputeMsmMgr::rw

Definition at line 589 of file ComputeMsm.C.

Referenced by initialize().

s_edge

int ComputeMsmMgr::s_edge

Definition at line 622 of file ComputeMsm.C.

Referenced by msm::PatchData::anterpolation(), initialize(), msm::PatchData::interpolation(), and setup_hgrid_1d().

sglower

Vector ComputeMsmMgr::sglower

Definition at line 610 of file ComputeMsm.C.

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

shx

BigReal ComputeMsmMgr::shx

Definition at line 613 of file ComputeMsm.C.

Referenced by initialize().

shx_1

BigReal ComputeMsmMgr::shx_1

Definition at line 614 of file ComputeMsm.C.

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

shy

BigReal ComputeMsmMgr::shy

Definition at line 613 of file ComputeMsm.C.

Referenced by initialize().

shy_1

BigReal ComputeMsmMgr::shy_1

Definition at line 614 of file ComputeMsm.C.

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

shz

BigReal ComputeMsmMgr::shz

Definition at line 613 of file ComputeMsm.C.

Referenced by initialize().

shz_1

BigReal ComputeMsmMgr::shz_1

Definition at line 614 of file ComputeMsm.C.

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

smax

ScaledPosition ComputeMsmMgr::smax

Definition at line 594 of file ComputeMsm.C.

Referenced by initialize().

smin

ScaledPosition ComputeMsmMgr::smin

Definition at line 593 of file ComputeMsm.C.

Referenced by initialize().

split

int ComputeMsmMgr::split

Definition at line 605 of file ComputeMsm.C.

Referenced by initialize().

srx_x

Float ComputeMsmMgr::srx_x

Definition at line 618 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

srx_y

Float ComputeMsmMgr::srx_y

Definition at line 618 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

srx_z

Float ComputeMsmMgr::srx_z

Definition at line 618 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

sry_x

Float ComputeMsmMgr::sry_x

Definition at line 619 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

sry_y

Float ComputeMsmMgr::sry_y

Definition at line 619 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

sry_z

Float ComputeMsmMgr::sry_z

Definition at line 619 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

srz_x

Float ComputeMsmMgr::srz_x

Definition at line 620 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

srz_y

Float ComputeMsmMgr::srz_y

Definition at line 620 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

srz_z

Float ComputeMsmMgr::srz_z

Definition at line 620 of file ComputeMsm.C.

Referenced by initialize(), msm::PatchData::interpolation(), and msm::PatchData::interpolationC1Hermite().

subgrid

msm::Grid<Float> ComputeMsmMgr::subgrid

Definition at line 480 of file ComputeMsm.C.

Referenced by addPotential().

subgrid_c1hermite

msm::Grid<C1Vector> ComputeMsmMgr::subgrid_c1hermite

Definition at line 481 of file ComputeMsm.C.

Referenced by addPotential().

sx_shx

Vector ComputeMsmMgr::sx_shx

Definition at line 615 of file ComputeMsm.C.

Referenced by initialize().

sy_shy

Vector ComputeMsmMgr::sy_shy

Definition at line 616 of file ComputeMsm.C.

Referenced by initialize().

sz_shz

Vector ComputeMsmMgr::sz_shz

Definition at line 617 of file ComputeMsm.C.

Referenced by initialize().

u

Vector ComputeMsmMgr::u

Definition at line 588 of file ComputeMsm.C.

v

Vector ComputeMsmMgr::v

Definition at line 588 of file ComputeMsm.C.

virial

Float ComputeMsmMgr::virial[VMAX]

Definition at line 527 of file ComputeMsm.C.

Referenced by doneVirialContrib(), initialize(), and ComputeMsm::saveResults().

w

Vector ComputeMsmMgr::w

Definition at line 588 of file ComputeMsm.C.

---

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

• ComputeMsm.C