Typedefs
typedef struct NL_Msm_t	NL_Msm

Enumerations
enum	{ NL_MSM_PERIODIC_NONE = 0x000, NL_MSM_PERIODIC_VEC1 = 0x001, NL_MSM_PERIODIC_VEC2 = 0x002, NL_MSM_PERIODIC_VEC3 = 0x004, NL_MSM_PERIODIC_ALL = 0x007, NL_MSM_COMPUTE_SHORT_RANGE = 0x008, NL_MSM_COMPUTE_LONG_RANGE = 0x010, NL_MSM_COMPUTE_ALL = 0x018, NL_MSM_COMPUTE_SPREC = 0x020, NL_MSM_COMPUTE_1AWAY = 0x040, NL_MSM_COMPUTE_NONFACTORED = 0x080, NL_MSM_REPORT_TIMINGS = 0x100, NL_MSM_COMPUTE_CUDA_FALL_BACK = 0x200, NL_MSM_COMPUTE_CUDA_GRID_CUTOFF = 0x400, NL_MSM_COMPUTE_CUDA_SHORT_RANGE = 0x800, NL_MSM_COMPUTE_CUDA = 0xE00, NL_MSM_ALL_FLAGS = 0xFFF }

enum	{ NL_MSM_SUCCESS = 0, NL_MSM_ERROR_MALLOC, NL_MSM_ERROR_PARAM, NL_MSM_ERROR_RANGE, NL_MSM_ERROR_SUPPORT, NL_MSM_ERROR_CUDA, NL_MSM_ERROR_END }

enum	{ NL_MSM_APPROX_CUBIC = 0, NL_MSM_APPROX_QUINTIC, NL_MSM_APPROX_QUINTIC2, NL_MSM_APPROX_SEPTIC, NL_MSM_APPROX_SEPTIC3, NL_MSM_APPROX_NONIC, NL_MSM_APPROX_NONIC4, NL_MSM_APPROX_BSPLINE, NL_MSM_APPROX_END }

enum	{ NL_MSM_SPLIT_TAYLOR2 = 0, NL_MSM_SPLIT_TAYLOR3, NL_MSM_SPLIT_TAYLOR4, NL_MSM_SPLIT_TAYLOR5, NL_MSM_SPLIT_TAYLOR6, NL_MSM_SPLIT_TAYLOR7, NL_MSM_SPLIT_TAYLOR8, NL_MSM_SPLIT_TAYLOR1, NL_MSM_SPLIT_SIGMA2_3, NL_MSM_SPLIT_SIGMA3_5, NL_MSM_SPLIT_SIGMA4_6, NL_MSM_SPLIT_SIGMA4_7, NL_MSM_SPLIT_SIGMA5_8, NL_MSM_SPLIT_SIGMA5_9, NL_MSM_SPLIT_SIGMA6_9, NL_MSM_SPLIT_SIGMA6_10, NL_MSM_SPLIT_SIGMA6_11, NL_MSM_SPLIT_SIGMA7_11, NL_MSM_SPLIT_SIGMA7_12, NL_MSM_SPLIT_SIGMA7_13, NL_MSM_SPLIT_SIGMA8_12, NL_MSM_SPLIT_SIGMA8_13, NL_MSM_SPLIT_SIGMA8_14, NL_MSM_SPLIT_SIGMA8_15, NL_MSM_SPLIT_SIGMA2_6, NL_MSM_SPLIT_SWITCH1_2, NL_MSM_SPLIT_SWITCH3_4, NL_MSM_SPLIT_SWITCH7_8, NL_MSM_SPLIT_END }

Functions
NL_Msm *	NL_msm_create (void)

void	NL_msm_destroy (NL_Msm *)

int	NL_msm_setup (NL_Msm *msm, double cutoff, double cellvec1[3], double cellvec2[3], double cellvec3[3], double cellcenter[3], int msmflags)

int	NL_msm_configure (NL_Msm *msm, double gridspacing, int approx, int split, int nlevels)

int	NL_msm_compute_force (NL_Msm msm, double felec, double uelec, const double atom, int natoms)

int	NL_msm_compute_force_sprec (NL_Msm msm, float felec, float uelec, const float atom, int natoms)

int	NL_msm_approx (const char *name)

int	NL_msm_split (const char *name)

const char *	NL_msm_approx_name (int approx)

const char *	NL_msm_split_name (int split)

Typedef Documentation

typedef struct NL_Msm_t NL_Msm

Definition at line 13 of file msm.h.

Enumeration Type Documentation

anonymous enum

Use in setup for msmflags, bitwise OR the options.

Enumerator
NL_MSM_PERIODIC_NONE	aperiodic cell
NL_MSM_PERIODIC_VEC1	periodic along basis vector 1
NL_MSM_PERIODIC_VEC2	periodic along basis vector 2
NL_MSM_PERIODIC_VEC3	periodic along basis vector 3
NL_MSM_PERIODIC_ALL	periodic along all basis vectors
NL_MSM_COMPUTE_SHORT_RANGE	compute the short-range part
NL_MSM_COMPUTE_LONG_RANGE	compute the long-range part
NL_MSM_COMPUTE_ALL	compute both parts
NL_MSM_COMPUTE_SPREC	use single precision (faster)
NL_MSM_COMPUTE_1AWAY	1-away neighborhood (slower)
NL_MSM_COMPUTE_NONFACTORED	use non-factored restriction and prolongation procedures (slower)
NL_MSM_REPORT_TIMINGS	report timings
NL_MSM_COMPUTE_CUDA_FALL_BACK	fall back on CPU if configuration unsupported by CUDA
NL_MSM_COMPUTE_CUDA_GRID_CUTOFF	use CUDA for grid cutoff
NL_MSM_COMPUTE_CUDA_SHORT_RANGE	use CUDA for short range
NL_MSM_COMPUTE_CUDA	all CUDA flags set on
NL_MSM_ALL_FLAGS	all flags set on

Definition at line 43 of file msm.h.

        {
     NL_MSM_PERIODIC_NONE     = 0x000,  
     NL_MSM_PERIODIC_VEC1     = 0x001,  
     NL_MSM_PERIODIC_VEC2     = 0x002,  
     NL_MSM_PERIODIC_VEC3     = 0x004,  
     NL_MSM_PERIODIC_ALL      = 0x007,  
     NL_MSM_COMPUTE_SHORT_RANGE
                              = 0x008,  
     NL_MSM_COMPUTE_LONG_RANGE
                              = 0x010,  
     NL_MSM_COMPUTE_ALL       = 0x018,  
     NL_MSM_COMPUTE_SPREC     = 0x020,  
     NL_MSM_COMPUTE_1AWAY     = 0x040,  
     NL_MSM_COMPUTE_NONFACTORED
                              = 0x080,  
     NL_MSM_REPORT_TIMINGS    = 0x100,  
     NL_MSM_COMPUTE_CUDA_FALL_BACK
                              = 0x200,  
     NL_MSM_COMPUTE_CUDA_GRID_CUTOFF
                              = 0x400,  
     NL_MSM_COMPUTE_CUDA_SHORT_RANGE
                              = 0x800,  
     NL_MSM_COMPUTE_CUDA      = 0xE00,  
     NL_MSM_ALL_FLAGS         = 0xFFF   
   };

anonymous enum

Return codes.

Enumerator
NL_MSM_SUCCESS	success
NL_MSM_ERROR_MALLOC	can't allocate memory
NL_MSM_ERROR_PARAM	incorrect parameters
NL_MSM_ERROR_RANGE	atom is outside of cell
NL_MSM_ERROR_SUPPORT	unsupported feature
NL_MSM_ERROR_CUDA	CUDA failure
NL_MSM_ERROR_END	(for internal use)

Definition at line 77 of file msm.h.

        {
     NL_MSM_SUCCESS = 0,    
     NL_MSM_ERROR_MALLOC,   
     NL_MSM_ERROR_PARAM,    
     NL_MSM_ERROR_RANGE,    
     NL_MSM_ERROR_SUPPORT,  
     NL_MSM_ERROR_CUDA,     
     NL_MSM_ERROR_END       
   };

anonymous enum

MSM approximation/interpolation methods. (Default is CUBIC.)

Enumerator
NL_MSM_APPROX_CUBIC	C1 degree 3 poly (numerical Hermite)
NL_MSM_APPROX_QUINTIC	C1 degree 5 poly (linear blend of degree 4)
NL_MSM_APPROX_QUINTIC2	C2 degree 5 poly
NL_MSM_APPROX_SEPTIC	C1 degree 7 poly (linear blend of degree 6)
NL_MSM_APPROX_SEPTIC3	C3 degree 7 poly
NL_MSM_APPROX_NONIC	C1 degree 9 poly (linear blend of degree 8)
NL_MSM_APPROX_NONIC4	C4 degree 9 poly
NL_MSM_APPROX_BSPLINE	C2 degree 3 B-spline
NL_MSM_APPROX_END	(for internal use)

Definition at line 153 of file msm.h.

        {
     NL_MSM_APPROX_CUBIC = 0, 
     NL_MSM_APPROX_QUINTIC,   
     NL_MSM_APPROX_QUINTIC2,  
     NL_MSM_APPROX_SEPTIC,    
     NL_MSM_APPROX_SEPTIC3,   
     NL_MSM_APPROX_NONIC,     
     NL_MSM_APPROX_NONIC4,    
     NL_MSM_APPROX_BSPLINE,   
     NL_MSM_APPROX_END        
   };

anonymous enum

MSM splitting functions to smooth the 1/r potential. (Default is TAYLOR2.)

The Taylor splittings are the family of C^k Taylor polynomials of s^(-1/2) about s=1. Discussed in section 5.1 of the thesis. TAYLOR1 is listed last so that reasonable default parameters (CUBIC approximation with TAYLOR2 splitting) are automatically selected from zeroing the values.

The sigma(k,d) splittings generalize the Taylor splittings above for C^k continuity at r=1 and degree d polynomial in r. (The Taylor splittings are sigma(d/2,d).) The ones here are uniquely determined. Discussed in section 5.2 of the thesis.

The special sigma(2,6) splitting is from section 5.3 of the thesis. This is a proof-of-concept where the polynomial in even powers of r has an extra degree of freedom chosen to minimize the error bound.

Elimiate the self-force artifact through the use of a switching function between 1/r and a polynomial reproduced exactly by CUBIC interpolation. Discussed in section 5.4 of thesis.

Enumerator
NL_MSM_SPLIT_TAYLOR2	C2 Taylor
NL_MSM_SPLIT_TAYLOR3	C3 Taylor
NL_MSM_SPLIT_TAYLOR4	C4 Taylor
NL_MSM_SPLIT_TAYLOR5	C5 Taylor
NL_MSM_SPLIT_TAYLOR6	C6 Taylor
NL_MSM_SPLIT_TAYLOR7	C7 Taylor
NL_MSM_SPLIT_TAYLOR8	C8 Taylor
NL_MSM_SPLIT_TAYLOR1	C1 Taylor
NL_MSM_SPLIT_SIGMA2_3	C2, degree 3 (the "perfect" smoothing)
NL_MSM_SPLIT_SIGMA3_5	C3, degree 5
NL_MSM_SPLIT_SIGMA4_6	C4, degree 6
NL_MSM_SPLIT_SIGMA4_7	C4, degree 7
NL_MSM_SPLIT_SIGMA5_8	C5, degree 8
NL_MSM_SPLIT_SIGMA5_9	C5, degree 9
NL_MSM_SPLIT_SIGMA6_9	C6, degree 9
NL_MSM_SPLIT_SIGMA6_10	C6, degree 10
NL_MSM_SPLIT_SIGMA6_11	C6, degree 11
NL_MSM_SPLIT_SIGMA7_11	C7, degree 11
NL_MSM_SPLIT_SIGMA7_12	C7, degree 12
NL_MSM_SPLIT_SIGMA7_13	C7, degree 13
NL_MSM_SPLIT_SIGMA8_12	C8, degree 12
NL_MSM_SPLIT_SIGMA8_13	C8, degree 13
NL_MSM_SPLIT_SIGMA8_14	C8, degree 14
NL_MSM_SPLIT_SIGMA8_15	C8, degree 15
NL_MSM_SPLIT_SIGMA2_6	C2, degree 6, even powers of r, chosen to minimize error bound
NL_MSM_SPLIT_SWITCH1_2	C2, switching at r/a=1/2
NL_MSM_SPLIT_SWITCH3_4	C2, switching at r/a=3/4
NL_MSM_SPLIT_SWITCH7_8	C2, switching at r/a=7/8
NL_MSM_SPLIT_END	(for internal use)

Definition at line 187 of file msm.h.

        {
     NL_MSM_SPLIT_TAYLOR2 = 0,  
     NL_MSM_SPLIT_TAYLOR3,      
     NL_MSM_SPLIT_TAYLOR4,      
     NL_MSM_SPLIT_TAYLOR5,      
     NL_MSM_SPLIT_TAYLOR6,      
     NL_MSM_SPLIT_TAYLOR7,      
     NL_MSM_SPLIT_TAYLOR8,      
     NL_MSM_SPLIT_TAYLOR1,      
     NL_MSM_SPLIT_SIGMA2_3,     
     NL_MSM_SPLIT_SIGMA3_5,     
     NL_MSM_SPLIT_SIGMA4_6,     
     NL_MSM_SPLIT_SIGMA4_7,     
     NL_MSM_SPLIT_SIGMA5_8,     
     NL_MSM_SPLIT_SIGMA5_9,     
     NL_MSM_SPLIT_SIGMA6_9,     
     NL_MSM_SPLIT_SIGMA6_10,    
     NL_MSM_SPLIT_SIGMA6_11,    
     NL_MSM_SPLIT_SIGMA7_11,    
     NL_MSM_SPLIT_SIGMA7_12,    
     NL_MSM_SPLIT_SIGMA7_13,    
     NL_MSM_SPLIT_SIGMA8_12,    
     NL_MSM_SPLIT_SIGMA8_13,    
     NL_MSM_SPLIT_SIGMA8_14,    
     NL_MSM_SPLIT_SIGMA8_15,    
     NL_MSM_SPLIT_SIGMA2_6,     
     NL_MSM_SPLIT_SWITCH1_2,    
     NL_MSM_SPLIT_SWITCH3_4,    
     NL_MSM_SPLIT_SWITCH7_8,    
     NL_MSM_SPLIT_END           
   };

Function Documentation

int NL_msm_approx ( const char * name )

Helper function to determine APPROX enum constant from string name.

Definition at line 160 of file msm.c.

References ApproxName, and NELEMS.

                                     {
   int i;
   if (name) {
     for (i = 0;  i < NELEMS(ApproxName);  i++) {
       if (strcasecmp(name, ApproxName[i]) == 0) return i;
     }
   }
   return -1;
 }

const char* NL_msm_approx_name ( int approx )

Helper function returning string name for APPROX enum constant.

Definition at line 170 of file msm.c.

References ApproxName, and NELEMS.

Referenced by print_status().

                                            {
   if (approx >= 0 && approx < NELEMS(ApproxName)) {
     return ApproxName[approx];
   }
   else return NULL;
 }

int NL_msm_compute_force	(	NL_Msm *	msm,
		double *	felec,
		double *	uelec,
		const double *	atom,
		int	natoms
	)

Compute the electrostatic forces and potential energy for the array of atoms. The felec array and the location pointed to by uelec is expected to be initialized before the call. As stated, the atoms must be within the defined cell.

Parameters

msm	the MSM solver object
felec	electrostatic forces x/y/z for each atom
uelec	electrostatic potential energy
atom	positions and charge x/y/z/q for each atom
natoms	number of atoms

Definition at line 56 of file msm.c.

References NL_Msm_t::atom, NL_Msm_t::felec, NL_Msm_t::msmflags, NL_MSM_COMPUTE_LONG_RANGE, NL_msm_compute_long_range(), NL_MSM_COMPUTE_SHORT_RANGE, NL_msm_compute_short_range(), NL_MSM_COMPUTE_SPREC, NL_MSM_ERROR_PARAM, NL_Msm_t::numatoms, NL_Msm_t::report_timings, NL_Msm_t::timer, NL_Msm_t::uelec, wkf_timer_start(), wkf_timer_stop(), and wkf_timer_time().

Referenced by ComputeMsmSerialMgr::recvCoord().

       {
   int rc;
   double time_delta;
 
   if (pm->msmflags & NL_MSM_COMPUTE_SPREC) {
     return NL_MSM_ERROR_PARAM;
   }
 
   /* store buffer pointers from caller */
   pm->felec = felec;
   pm->atom = atom;
   pm->numatoms = natoms;
   pm->uelec = 0;
 
   if (pm->msmflags & NL_MSM_COMPUTE_SHORT_RANGE) {
     wkf_timer_start(pm->timer);
     rc = NL_msm_compute_short_range(pm);
     if (rc) return rc;
     wkf_timer_stop(pm->timer);
     time_delta = wkf_timer_time(pm->timer);
     if (pm->report_timings) {
       printf("MSM short-range part:  %6.3f sec\n", time_delta);
     }
   }
   if (pm->msmflags & NL_MSM_COMPUTE_LONG_RANGE) {
     wkf_timer_start(pm->timer);
     rc = NL_msm_compute_long_range(pm);
     if (rc) return rc;
     wkf_timer_stop(pm->timer);
     time_delta = wkf_timer_time(pm->timer);
     if (pm->report_timings) {
       printf("MSM long-range part:   %6.3f sec\n", time_delta);
     }
   }
   *uelec += pm->uelec;  /* add to caller's potential */
 
   return 0;
 }

int NL_msm_compute_force_sprec	(	NL_Msm *	msm,
		float *	felec,
		float *	uelec,
		const float *	atom,
		int	natoms
	)

Same as NL_msm_compute_force() except for single precision calculation. Call this only if NL_MSM_COMPUTE_SPREC flag was selected.

Parameters

msm	the MSM solver object
felec	electrostatic forces x/y/z for each atom
uelec	electrostatic potential energy
atom	positions and charge x/y/z/q for each atom
natoms	number of atoms

Definition at line 102 of file msm.c.

References NL_Msm_t::atom_f, NL_Msm_t::felec_f, NL_Msm_t::msmflags, NL_MSM_COMPUTE_LONG_RANGE, NL_msm_compute_long_range_sprec(), NL_MSM_COMPUTE_SHORT_RANGE, NL_msm_compute_short_range_sprec(), NL_MSM_COMPUTE_SPREC, NL_MSM_ERROR_PARAM, NL_Msm_t::numatoms, NL_Msm_t::report_timings, NL_Msm_t::timer, NL_Msm_t::uelec, wkf_timer_start(), wkf_timer_stop(), and wkf_timer_time().

       {
   int rc;
   double time_delta;
 
   if ((pm->msmflags & NL_MSM_COMPUTE_SPREC) == 0) {
     return NL_MSM_ERROR_PARAM;
   }
 
   /* store buffer pointers from caller */
   pm->felec_f = felec_f;
   pm->atom_f = atom_f;
   pm->numatoms = natoms;
   pm->uelec = 0;
 
   if (pm->msmflags & NL_MSM_COMPUTE_SHORT_RANGE) {
     wkf_timer_start(pm->timer);
     rc = NL_msm_compute_short_range_sprec(pm);
     if (rc) return rc;
     wkf_timer_stop(pm->timer);
     time_delta = wkf_timer_time(pm->timer);
     if (pm->report_timings) {
       printf("MSM short-range part:  %6.3f sec\n", time_delta);
     }
   }
   if (pm->msmflags & NL_MSM_COMPUTE_LONG_RANGE) {
     wkf_timer_start(pm->timer);
     rc = NL_msm_compute_long_range_sprec(pm);
     if (rc) return rc;
     wkf_timer_stop(pm->timer);
     time_delta = wkf_timer_time(pm->timer);
     if (pm->report_timings) {
       printf("MSM long-range part:   %6.3f sec\n", time_delta);
     }
   }
   *uelec_f += (float) pm->uelec;  /* add to caller's potential */
 
   return 0;
 }

int NL_msm_configure	(	NL_Msm *	msm,
		double	gridspacing,
		int	approx,
		int	split,
		int	nlevels
	)

Advanced configuration of MSM. The ratio of cutoff / gridspacing is generally kept between about 2.5 and 6. For atomic lengths in Angstroms, good results are demonstrated for a cutoff distance between 8 and 12 A and the default grid spacing of 2.5 A.

The optimal pairings of approx and split have been demonstrated to be:

CUBIC with TAYLOR2 (the default),
QUINTIC with TAYLOR3,
SEPTIC with TAYLOR4,
NONIC with TAYLOR5.

Use QUINTIC2, SEPTIC3, NONIC4 paired with the same splitting functions above if greater continuity is desired.

Set "nlevels" to 0 (the default) to fully adapt the number of grid levels to the system cell size.

Parameters

msm	the MSM solver object
gridspacing	grid spacing for first grid level
approx	which approximation method
split	which splitting
nlevels	number of grid levels to use

Definition at line 36 of file msm.c.

References NL_Msm_t::approx, NL_Msm_t::gridspacing, NL_MSM_APPROX_END, NL_MSM_ERROR_PARAM, NL_MSM_SPLIT_END, NL_MSM_SUCCESS, NL_Msm_t::nlevels, split(), and NL_Msm_t::split.

Referenced by ComputeMsmSerialMgr::recvCoord().

       {
   if (gridspacing > 0) pm->gridspacing = gridspacing;
   else if (gridspacing < 0) return NL_MSM_ERROR_PARAM;
   if (approx >= 0 && approx < NL_MSM_APPROX_END) pm->approx = approx;
   else return NL_MSM_ERROR_PARAM;
   if (split >= 0 && split < NL_MSM_SPLIT_END) pm->split = split;
   else return NL_MSM_ERROR_PARAM;
   if (nlevels >= 0) pm->nlevels = nlevels;
   else return NL_MSM_ERROR_PARAM;
 
   return NL_MSM_SUCCESS;
 }

NL_Msm* NL_msm_create ( void )

Allocate MSM solver.

Definition at line 6 of file msm.c.

References NL_Msm_t::approx, NL_Msm_t::binfill, DEFAULT_APPROX, DEFAULT_BINFILL, DEFAULT_DENSITY, DEFAULT_GRIDSPACING, DEFAULT_NBINSLOTS, DEFAULT_NLEVELS, DEFAULT_SPLIT, NL_Msm_t::density, NL_Msm_t::gridspacing, NL_Msm_t::nbinslots, NL_Msm_t::nlevels, NL_Msm_t::split, NL_Msm_t::timer, NL_Msm_t::timer_longrng, and wkf_timer_create().

Referenced by ComputeMsmSerialMgr::recvCoord().

                             {
   NL_Msm *pm = (NL_Msm *) calloc(1, sizeof(NL_Msm));
   if (NULL == pm) return NULL;
 
   pm->timer = wkf_timer_create();
   if (NULL == pm->timer) return NULL;
   pm->timer_longrng = wkf_timer_create();
   if (NULL == pm->timer) return NULL;
 
   /* method parameters are modified with msm_configure() */
   pm->gridspacing = DEFAULT_GRIDSPACING;
   pm->approx = DEFAULT_APPROX;
   pm->split = DEFAULT_SPLIT;
   pm->nlevels = DEFAULT_NLEVELS;
 
   pm->density = DEFAULT_DENSITY;
   pm->binfill = DEFAULT_BINFILL;
   pm->nbinslots = DEFAULT_NBINSLOTS;
   return pm;
 }

void NL_msm_destroy ( NL_Msm * )

Free MSM solver.

Definition at line 28 of file msm.c.

References NL_msm_cleanup(), NL_Msm_t::timer, NL_Msm_t::timer_longrng, and wkf_timer_destroy().

Referenced by ComputeMsmSerialMgr::~ComputeMsmSerialMgr().

                                 {
   NL_msm_cleanup(pm);
   wkf_timer_destroy(pm->timer);
   wkf_timer_destroy(pm->timer_longrng);
   free(pm);
 }

int NL_msm_setup	(	NL_Msm *	msm,
		double	cutoff,
		double	cellvec1[3],
		double	cellvec2[3],
		double	cellvec3[3],
		double	cellcenter[3],
		int	msmflags
	)

Setup the MSM solver for the molecular system. These parameters come directly from the simulation. Here the cutoff provides some control over the accuracy. The region of space containing the atoms is defined as a parallelepiped, and the "isperiodic" flag determines whether or not each individual cell dimension has periodic boundary conditions. The defined cell is expected to contain the atoms regardless of the choice of boundary conditions. The cell volume must contain the cutoff-sphere.

XXX For now, the MSM solver permits only cell vectors that align with the x-, y-, and z-axis, respectively.

Parameters

msm	the MSM solver object
cutoff	cutoff distance for short-range part
cellvec1	cell basis vector 1
cellvec2	cell basis vector 2
cellvec3	cell basis vector 3
cellcenter	center of cell
msmflags	flags for periodicity and calculation

Definition at line 62 of file msm_setup.c.

References NL_Msm_t::a, NL_Msm_t::a_f, NL_Msm_t::cellcenter, NL_Msm_t::cellcenter_f, NL_Msm_t::cellvec1, NL_Msm_t::cellvec1_f, NL_Msm_t::cellvec2, NL_Msm_t::cellvec2_f, NL_Msm_t::cellvec3, NL_Msm_t::cellvec3_f, NL_Msm_t::gx, NL_Msm_t::gx_f, NL_Msm_t::gy, NL_Msm_t::gy_f, NL_Msm_t::gz, NL_Msm_t::gz_f, NL_Msm_t::hx, NL_Msm_t::hx_f, NL_Msm_t::hy, NL_Msm_t::hy_f, NL_Msm_t::hz, NL_Msm_t::hz_f, NL_Msm_t::msmflags, NL_MSM_ALL_FLAGS, NL_MSM_COMPUTE_1AWAY, NL_MSM_COMPUTE_ALL, NL_MSM_COMPUTE_CUDA_FALL_BACK, NL_MSM_COMPUTE_CUDA_GRID_CUTOFF, NL_MSM_COMPUTE_LONG_RANGE, NL_MSM_COMPUTE_SHORT_RANGE, NL_MSM_COMPUTE_SPREC, NL_MSM_ERROR_PARAM, NL_MSM_ERROR_SUPPORT, NL_MSM_PERIODIC_VEC1, NL_MSM_PERIODIC_VEC2, NL_MSM_PERIODIC_VEC3, NL_MSM_REPORT_TIMINGS, NL_MSM_SUCCESS, print_status(), NL_Msm_t::recipvec1, NL_Msm_t::recipvec1_f, NL_Msm_t::recipvec2, NL_Msm_t::recipvec2_f, NL_Msm_t::recipvec3, NL_Msm_t::recipvec3_f, NL_Msm_t::report_timings, setup_bins_1away(), setup_bins_k_away(), setup_cell_vectors(), and setup_grids().

Referenced by ComputeMsmSerialMgr::recvCoord().

       {
 
   int rc = 0;
 
   /* check sanity of msmflags */
   if ((~NL_MSM_ALL_FLAGS & msmflags) != 0 ||
       (NL_MSM_COMPUTE_ALL & msmflags) == 0) {
     return NL_MSM_ERROR_PARAM;
   }
 
   /* report timings? */
   pm->report_timings = ((msmflags & NL_MSM_REPORT_TIMINGS) != 0);
 
   /* for now, permit only orthogonal cell aligned with coordinate axes */
   if (cellvec1[1] != 0 || cellvec1[2] != 0 ||
       cellvec2[0] != 0 || cellvec2[2] != 0 ||
       cellvec3[0] != 0 || cellvec3[1] != 0 ||
       cellvec1[0] <= 0 || cellvec2[1] <= 0 || cellvec3[2] <= 0) {
     return NL_MSM_ERROR_SUPPORT;
   }
 
   /* check sanity of cutoff wrt expected cell;
    * XXX cell widths must be at least the cutoff distance length */
   if (cutoff <= 0 ||
       (cutoff > cellvec1[0] && (msmflags & NL_MSM_PERIODIC_VEC1)) ||
       (cutoff > cellvec2[1] && (msmflags & NL_MSM_PERIODIC_VEC2)) ||
       (cutoff > cellvec3[2] && (msmflags & NL_MSM_PERIODIC_VEC3))) {
     return NL_MSM_ERROR_PARAM;
   }
 
   pm->msmflags = msmflags;
   pm->cellvec1[0] = cellvec1[0];
   pm->cellvec1[1] = cellvec1[1];
   pm->cellvec1[2] = cellvec1[2];
   pm->cellvec2[0] = cellvec2[0];
   pm->cellvec2[1] = cellvec2[1];
   pm->cellvec2[2] = cellvec2[2];
   pm->cellvec3[0] = cellvec3[0];
   pm->cellvec3[1] = cellvec3[1];
   pm->cellvec3[2] = cellvec3[2];
   pm->cellcenter[0] = cellcenter[0];
   pm->cellcenter[1] = cellcenter[1];
   pm->cellcenter[2] = cellcenter[2];
 
   pm->a = cutoff;
 
   rc = setup_cell_vectors(pm);
   if (rc) return rc;
 
   if (msmflags & NL_MSM_COMPUTE_SHORT_RANGE) {
     /* set up bins for short-range part */
     if (msmflags & NL_MSM_COMPUTE_1AWAY) {
       rc = setup_bins_1away(pm);
     }
     else {
       rc = setup_bins_k_away(pm);
     }
     if (rc) return rc;
   }
 
   if (msmflags & NL_MSM_COMPUTE_LONG_RANGE) {
     /* set up grid hierarchy for long-range part */
     rc = setup_grids(pm);
     if (rc) return rc;
   }
 
   if (msmflags & NL_MSM_COMPUTE_SPREC) {
     /* fill out single precision data if needed */
     pm->cellvec1_f[0] = (float) pm->cellvec1[0];
     pm->cellvec1_f[1] = (float) pm->cellvec1[1];
     pm->cellvec1_f[2] = (float) pm->cellvec1[2];
     pm->cellvec2_f[0] = (float) pm->cellvec2[0];
     pm->cellvec2_f[1] = (float) pm->cellvec2[1];
     pm->cellvec2_f[2] = (float) pm->cellvec2[2];
     pm->cellvec3_f[0] = (float) pm->cellvec3[0];
     pm->cellvec3_f[1] = (float) pm->cellvec3[1];
     pm->cellvec3_f[2] = (float) pm->cellvec3[2];
     pm->cellcenter_f[0] = (float) pm->cellcenter[0];
     pm->cellcenter_f[1] = (float) pm->cellcenter[1];
     pm->cellcenter_f[2] = (float) pm->cellcenter[2];
     pm->recipvec1_f[0] = (float) pm->recipvec1[0];
     pm->recipvec1_f[1] = (float) pm->recipvec1[1];
     pm->recipvec1_f[2] = (float) pm->recipvec1[2];
     pm->recipvec2_f[0] = (float) pm->recipvec2[0];
     pm->recipvec2_f[1] = (float) pm->recipvec2[1];
     pm->recipvec2_f[2] = (float) pm->recipvec2[2];
     pm->recipvec3_f[0] = (float) pm->recipvec3[0];
     pm->recipvec3_f[1] = (float) pm->recipvec3[1];
     pm->recipvec3_f[2] = (float) pm->recipvec3[2];
     pm->hx_f = pm->hx;
     pm->hy_f = pm->hy;
     pm->hz_f = pm->hz;
     pm->a_f = pm->a;
     pm->gx_f = pm->gx;
     pm->gy_f = pm->gy;
     pm->gz_f = pm->gz;
   }
 
   print_status(pm);
 
 #ifdef NL_USE_CUDA
   if (msmflags & NL_MSM_COMPUTE_CUDA_GRID_CUTOFF) {
     rc = NL_msm_cuda_setup_gridcutoff(pm);
     if (rc == NL_MSM_SUCCESS) {
       printf("Using CUDA for grid cutoff computation\n");
     }
     else {
       printf("Unable to set up CUDA for grid cutoff computation\n");
       if (msmflags & NL_MSM_COMPUTE_CUDA_FALL_BACK) {
         NL_msm_cuda_cleanup_gridcutoff(pm);
         printf("Falling back on CPU\n");
         pm->msmflags &= ~NL_MSM_COMPUTE_CUDA_GRID_CUTOFF;
       }
       else return rc;
     }
   }
 #else
   if (msmflags & NL_MSM_COMPUTE_CUDA_GRID_CUTOFF) {
     if (msmflags & NL_MSM_COMPUTE_CUDA_FALL_BACK) {
       printf("Falling back on CPU\n");
       pm->msmflags &= ~NL_MSM_COMPUTE_CUDA_GRID_CUTOFF;
     }
     else return NL_MSM_ERROR_SUPPORT;
   }
 #endif /* NL_USE_CUDA */
 
   return NL_MSM_SUCCESS;
 }

int NL_msm_split ( const char * name )

Helper function to determine SPLIT enum constant from string name.

Definition at line 210 of file msm.c.

References NELEMS, and SplitName.

                                    {
   int i;
   if (name) {
     for (i = 0;  i < NELEMS(SplitName);  i++) {
       if (strcasecmp(name, SplitName[i]) == 0) return i;
     }
   }
   return -1;
 }

const char* NL_msm_split_name ( int split )

Helper function returning string name for SPLIT enum constant.

Definition at line 220 of file msm.c.

References NELEMS, split(), and SplitName.

Referenced by print_status().

                                          {
   if (split >= 0 && split < NELEMS(SplitName)) {
     return SplitName[split];
   }
   else return NULL;
 }

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation