NAMD
ComputeGBIS.inl
Go to the documentation of this file.
1 
7 /*******************************************************************************
8  These are inline functions which define all the atom-pair calculations
9  included in ComputeGBIS.C and ComputeGBISCUDAKernal.h
10 *******************************************************************************/
11 
12 #ifndef COMPUTEGBIS_INL
13 #define COMPUTEGBIS_INL
14 
15 /* Should psiSum and dEdaSum reductions be performed with doubles? */
16 //this value is now defined in NamdTypes
17 typedef float GBReal;
18 
19 //copied from NamdTypes.h
20 typedef float Mass;
21 
22 
23 #ifndef FS_MAX
24 #define FS_MAX 1.728f /*maximum screened radius*/
25 #endif
26 
27 #ifndef COULOMB
28 #define COULOMB 332.0636f /* ke [kcal*Ang/e^2] common.h */
29 #endif
30 
31 #ifndef TA
32 #define TA 0.333333333333333f // 1/3
33 #define TB 0.4f // 2/5
34 #define TC 0.428571428571428f // 3/7
35 #define TD 0.444444444444444f // 4/9
36 #define TE 0.454545454545454f // 5/11
37 #define DA 1.333333333333333f // 4* 1/3
38 #define DB 2.4f // 6* 2/5
39 #define DC 3.428571428571428f // 8* 3/7
40 #define DD 4.444444444444444f // 10*4/9
41 #define DE 5.454545454545454f // 12*5/11
42 #endif
43 
44 static inline float FastTanH( float x ) {
45  float a = 2.f*x+0.02f;;
46  a *= (6.f + a*(3.f + a));
47  return (a)/(a+12.f);
48 }
49 
50 /******************************************************************************
51  * use mass to determine element
52  * return Bondi radius
53  * returns the radius of i, depends on j though
54  ******************************************************************************/
55 static inline float MassToRadius(Mass mi) {//, Mass mj) {
56 return
57  (mi < 2.50f ) ? 1.20f : // AtmNum = 1; Elem = H ; Mass = 1.00
58  (mi < 5.47f ) ? 1.40f : // AtmNum = 2; Elem = He; Mass = 4.00
59  (mi < 7.98f ) ? 1.82f : // AtmNum = 3; Elem = Li; Mass = 6.94
60  (mi < 9.91f ) ? 2.13f : // AtmNum = 4; Elem = Be; Mass = 9.01
61  (mi < 11.41f ) ? 2.13f : // AtmNum = 5; Elem = B ; Mass = 10.81
62  (mi < 13.01f ) ? 1.70f : // AtmNum = 6; Elem = C ; Mass = 12.01
63  (mi < 15.00f ) ? 1.55f : // AtmNum = 7; Elem = N ; Mass = 14.00
64  (mi < 17.49f ) ? 1.50f : // AtmNum = 8; Elem = O ; Mass = 15.99
65  (mi < 19.58f ) ? 1.50f : // AtmNum = 9; Elem = F ; Mass = 18.99
66  (mi < 21.58f ) ? 1.54f : // AtmNum = 10; Elem = Ne; Mass = 20.17
67  (mi < 23.64f ) ? 2.27f : // AtmNum = 11; Elem = Na; Mass = 22.98
68  (mi < 25.64f ) ? 1.73f : // AtmNum = 12; Elem = Mg; Mass = 24.30
69  (mi < 27.53f ) ? 2.51f : // AtmNum = 13; Elem = Al; Mass = 26.98
70  (mi < 29.53f ) ? 2.10f : // AtmNum = 14; Elem = Si; Mass = 28.08
71  (mi < 31.52f ) ? 1.85f : // AtmNum = 15; Elem = P ; Mass = 30.97
72  (mi < 33.76f ) ? 1.80f : // AtmNum = 16; Elem = S ; Mass = 32.06
73  (mi < 37.28f ) ? 1.70f : // AtmNum = 17; Elem = Cl; Mass = 35.45
74  (mi < 39.29f ) ? 2.75f : // AtmNum = 19; Elem = K ; Mass = 39.10
75  (mi < 49.09f ) ? 1.88f : // AtmNum = 18; Elem = Ar; Mass = 39.48
76  (mi < 61.12f ) ? 1.63f : // AtmNum = 28; Elem = Ni; Mass = 58.69
77  (mi < 64.46f ) ? 1.40f : // AtmNum = 29; Elem = Cu; Mass = 63.54
78  (mi < 67.55f ) ? 1.39f : // AtmNum = 30; Elem = Zn; Mass = 65.38
79  (mi < 71.18f ) ? 1.87f : // AtmNum = 31; Elem = Ga; Mass = 69.72
80  (mi < 73.78f ) ? 2.19f : // AtmNum = 32; Elem = Ge; Mass = 72.64
81  (mi < 76.94f ) ? 1.85f : // AtmNum = 33; Elem = As; Mass = 74.92
82  (mi < 79.43f ) ? 1.90f : // AtmNum = 34; Elem = Se; Mass = 78.96
83  (mi < 81.85f ) ? 1.85f : // AtmNum = 35; Elem = Br; Mass = 79.90
84  (mi < 95.11f ) ? 2.02f : // AtmNum = 36; Elem = Kr; Mass = 83.79
85  (mi < 107.14f ) ? 1.63f : // AtmNum = 46; Elem = Pd; Mass = 106.42
86  (mi < 110.14f ) ? 1.72f : // AtmNum = 47; Elem = Ag; Mass = 107.86
87  (mi < 113.61f ) ? 1.58f : // AtmNum = 48; Elem = Cd; Mass = 112.41
88  (mi < 116.76f ) ? 1.93f : // AtmNum = 49; Elem = In; Mass = 114.81
89  (mi < 120.24f ) ? 2.17f : // AtmNum = 50; Elem = Sn; Mass = 118.71
90  (mi < 124.33f ) ? 2.09f : // AtmNum = 51; Elem = Sb; Mass = 121.76
91  (mi < 127.25f ) ? 1.98f : // AtmNum = 53; Elem = I ; Mass = 126.90
92  (mi < 129.45f ) ? 2.06f : // AtmNum = 52; Elem = Te; Mass = 127.60
93  (mi < 163.19f ) ? 2.16f : // AtmNum = 54; Elem = Xe; Mass = 131.29
94  (mi < 196.02f ) ? 1.75f : // AtmNum = 78; Elem = Pt; Mass = 195.08
95  (mi < 198.78f ) ? 1.66f : // AtmNum = 79; Elem = Au; Mass = 196.96
96  (mi < 202.49f ) ? 1.55f : // AtmNum = 80; Elem = Hg; Mass = 200.59
97  (mi < 205.79f ) ? 1.96f : // AtmNum = 81; Elem = Tl; Mass = 204.38
98  (mi < 222.61f ) ? 2.02f : // AtmNum = 82; Elem = Pb; Mass = 207.20
99  (mi < 119.01f ) ? 1.86f : // AtmNum = 92; Elem = U ; Mass = 238.02
100  1.50f ; // Unknown
101 }
102 
103 /******************************************************************************
104  * Screen radii
105  * use masses to determine elements
106  * use elements to lookup Sij
107  * to scale the coulomb radius
108  * from Hawkins, Cramer, Truhlar; 1996
109  * mi is descreened atom - calculating it's alpha (outer loop index)
110  * mj is descreening atom - contributor (inner loop index)
111  ******************************************************************************/
112 static inline float MassToScreen(Mass mi) {//, Mass mj) {
113  return
114  (mi < 1.500f) ? 0.85f : //H
115  (mi < 12.500f) ? 0.72f : //C
116  (mi < 14.500f) ? 0.79f : //N
117  (mi < 16.500f) ? 0.85f : //O
118  (mi < 19.500f) ? 0.88f : //F
119  (mi < 31.500f) ? 0.86f : //P
120  (mi < 32.500f) ? 0.96f : //S
121  0.8f ; //all others
122 }
123 
124 
125 /******************************************************************************
126  Piecewise screening functions Hij dHij/drij
127  r distance
128  r2 square distance
129  ri inverse distance
130  rc cutoff
131  r0 descreened atom radius
132  rs descreening atom radius
133  h return value
134  dh return value
135  ******************************************************************************/
136 #ifdef GBIS_CUDA
137 __device__ __forceinline__ void h0
138 #else
139 static inline void h0
140 #endif
141 ( float r, float r2, float ri,//(0)*5.3%
142  float rc, float r0, float rs, float & h ) {
143  h = 0.f;
144 }
145 #ifdef GBIS_CUDA
146 __device__ __forceinline__ void dh0
147 #else
148 static inline void dh0
149 #endif
150 ( float r, float r2, float ri,//(0)*5.3%
151  float rc, float r0, float rs, float & dh ) {
152  dh = 0.f;
153 }
154 
155 #ifdef GBIS_CUDA
156 __device__ __forceinline__ void h1
157 #else
158 static inline void h1
159 #endif
160 ( float r, float r2, float ri, //(6+ 11* 2/ 1log)*18.4%
161  float rc, float r0, float rs, float & h ) {
162 
163  float rci = 1.f/rc;
164  float rmrs = r-rs;
165  float rmrsi = 1.f/rmrs;
166  //float rmrs2 = rmrs*rmrs;
167  float rs2 = rs*rs;
168  float logr = log(rmrs*rci);
169  float rci2 = rci*rci;
170  h = 0.125f*ri*(1.f + 2.f*r*rmrsi + rci2*(r2 - 4.f*rc*r - rs2) + 2.f*logr);
171 }
172 #ifdef GBIS_CUDA
173 __device__ __forceinline__ void dh1
174 #else
175 static inline void dh1
176 #endif
177 ( float r, float r2, float ri, //(4+ 13* 2/ 1log)*18.4%
178  float rc, float r0, float rs, float & dh ) {
179 
180  float rci = 1.f/rc;
181  float rmrs = r-rs;// 4 times
182  float rmrsi = 1.f/rmrs;
183  float rmrs2 = rmrs*rmrs;
184  float rs2 = rs*rs;
185  float logr = log(rmrs*rci);
186  float rci2 = rci*rci;
187  dh = ri*ri*(-0.25f*logr - (rc*rc - rmrs2)*(rs2 + r2)*0.125f*rci2*rmrsi*rmrsi);
188 }
189 
190 #ifdef GBIS_CUDA
191 __device__ __forceinline__ void h2
192 #else
193 static inline void h2
194 #endif
195 ( float r, float r2, float ri,//(4+ 10* )*74.5%
196 float rc, float r0, float rs, float & h ) {
197 
198  float k = rs*ri; k*=k;//k=(rs/r)^2
199  h = rs*ri*ri*k*(TA+k*(TB+k*(TC+k*(TD+k*TE))));
200 }
201 #ifdef GBIS_CUDA
202 __device__ __forceinline__ void dh2
203 #else
204 static inline void dh2
205 #endif
206 ( float r, float r2, float ri,//(4+ 11* )*74.5%
207 float rc, float r0, float rs, float & dh ) {
208 
209  float k = rs*ri; k*=k;//k=(rs/r)^2
210  dh = -rs*ri*ri*ri*k*(DA+k*(DB+k*(DC+k*(DD+k*DE))));
211 }
212 
213 #ifdef GBIS_CUDA
214 __device__ __forceinline__ void h3
215 #else
216 static inline void h3
217 #endif
218 ( float r, float r2, float ri,//(3+ 5* 2/ 1log) 1.4%
219 float rc, float r0, float rs, float & h ) {
220  float r2mrs2i = 1.f/(r2-rs*rs);
221  h = 0.5f * ( rs*r2mrs2i + 0.5f * log((r-rs)/(r+rs))*ri );
222 }
223 #ifdef GBIS_CUDA
224 __device__ __forceinline__ void dh3
225 #else
226 static inline void dh3
227 #endif
228 ( float r, float r2, float ri,//(5+ 8* 2/ 1log)*1.4%
229 float rc, float r0, float rs, float & dh ) {
230  float rs2 = rs*rs;
231  float r2mrs2i = 1.f/(r2-rs2);
232  dh = -0.25f*ri*(2.f*(r2+rs2)*rs*r2mrs2i*r2mrs2i + ri*log((r-rs)/(r+rs)));
233 }
234 
235 #ifdef GBIS_CUDA
236 __device__ __forceinline__ void h4
237 #else
238 static inline void h4
239 #endif
240 ( float r, float r2, float ri,//(6+ 9* 2/ 1log)*0.4%
241 float rc, float r0, float rs, float & h ) {
242  //float ri2 = ri*ri;
243  float r02 = r0*r0;
244  float rs2 = rs*rs;
245  float r0i = 1.f/r0;
246  float rspri = 1.f/(r+rs);
247  float logr = log(r0*rspri);
248  //float r02mrs2 = r02-rs2;
249  float rilogr = ri*logr;
250  h = 0.25f*( r0i*(2.f- 0.5f*(r0i*ri*(r2 + r02 - rs2))) - rspri + rilogr );
251 }
252 #ifdef GBIS_CUDA
253 __device__ __forceinline__ void dh4
254 #else
255 static inline void dh4
256 #endif
257 ( float r, float r2, float ri,//(6+ 18* 2/ 1log)*0.4%
258 float rc, float r0, float rs, float & dh ) {
259  float ri2 = ri*ri;
260  float r02 = r0*r0;
261  float rs2 = rs*rs;
262  float r0i = 1.f/r0;
263  float rspri = 1.f/(r+rs);
264  float logr = log(r0*rspri);
265  float r02mrs2 = r02-rs2;
266  float rilogr = ri*logr;
267  dh = 0.25f*( (- 0.5f +(r2*r02mrs2 - 2.f*r*rs*rs2+rs2*r02mrs2)
268  * 0.5f *ri2*rspri*rspri)*r0i*r0i - ri*rilogr );
269 }
270 
271 #ifdef GBIS_CUDA
272 __device__ __forceinline__ void h5
273 #else
274 static inline void h5
275 #endif
276 ( float r, float r2, float ri,//(6+ 5* 3/ 1log)*0%, r<0.7Ang
277 float rc, float r0, float rs, float & h ) {
278  float rs2 = rs*rs;
279  float r2mrs2i = 1.f/(r2-rs2);
280  float rsr2mrs2i = rs*r2mrs2i;
281  float rprs = r+rs;
282  float rmrs = r-rs;
283  float logr = 0.5f*ri*log(-rmrs/rprs);
284  h = 0.5f*( rsr2mrs2i + 2.f/r0 + logr );
285 }
286 #ifdef GBIS_CUDA
287 __device__ __forceinline__ void dh5
288 #else
289 static inline void dh5
290 #endif
291 ( float r, float r2, float ri,//(5+ 8* 2/ 1log)*0%, r<0.7Ang
292 float rc, float r0, float rs, float & dh ) {
293  float rs2 = rs*rs;
294  float r2mrs2i = 1.f/(r2-rs2);
295  float rsr2mrs2i = rs*r2mrs2i;
296  float rprs = r+rs;
297  float rmrs = r-rs;
298  float logr = 0.5f*ri*log(-rmrs/rprs);
299  dh = -0.5f*ri*((rs2+r2)*rsr2mrs2i*r2mrs2i+logr );
300 }
301 
302 #ifdef GBIS_CUDA
303 __device__ __forceinline__ void h6
304 #else
305 static inline void h6
306 #endif
307 ( float r, float r2, float ri,//0%, one atom within other
308 float rc, float r0, float rs, float & h ) {
309  h = 0;
310 }
311 #ifdef GBIS_CUDA
312 __device__ __forceinline__ void dh6
313 #else
314 static inline void dh6
315 #endif
316 ( float r, float r2, float ri,//0%, one atom within other
317 float rc, float r0, float rs, float & dh ) {
318  dh = 0;
319 }
320 
321 #ifdef GBIS_CUDA
322 __device__ __forceinline__ void CalcH
323 #else
324 static inline void CalcH
325 #endif
326 ( float r, float r2, float ri,
327 float rc, float r0, float rs, float & h, int & d) {
328 
329 /*
330 r - distance
331 rc - alpha cutoff
332 rs - screened radius
333 */
334 
335 if (r > 4*rs) { //change this to 1/4 r > rs
336  if( r < rc - rs) {//II 68%
337  h2(r,r2,ri,rc,r0,rs,h); d = 2;
338  } else if (r < rc + rs) {//I 23%
339  h1(r,r2,ri,rc,r0,rs,h); d = 1;
340  } else /*if (r > rc + rs)*/ {//0 7%
341  h0(r,r2,ri,rc,r0,rs,h); d = 0;
342  }
343 } else {
344  if( r > r0 + rs ) {//III 1%
345  h3(r,r2,ri,rc,r0,rs,h); d = 3;
346  } else if ( r > (r0>rs?r0-rs:rs-r0) ) {//IV 0%
347  h4(r,r2,ri,rc,r0,rs,h); d = 4;
348  } else if (r0 < rs ) {//V 0%
349  h5(r,r2,ri,rc,r0,rs,h); d = 5;
350  } else {//VI 0%
351  h6(r,r2,ri,rc,r0,rs,h); d = 6;
352  }
353 }
354 }
355 #ifdef GBIS_CUDA
356 __device__ __forceinline__ void CalcDH
357 #else
358 static inline void CalcDH
359 #endif
360 ( float r, float r2, float ri,
361 float rc, float r0, float rs, float & dh, int & d) {
362 if (r > 4*rs) {
363  if( r < rc - rs) {//II
364  dh2(r,r2,ri,rc,r0,rs,dh); d = 2;
365  } else if (r < rc + rs) {//I
366  dh1(r,r2,ri,rc,r0,rs,dh); d = 1;
367  } else /*if (r > rc + rs)*/ {//0
368  dh0(r,r2,ri,rc,r0,rs,dh); d = 0;
369  }
370 } else {
371  if( r > r0 + rs ) {//III
372  dh3(r,r2,ri,rc,r0,rs,dh); d = 3;
373  } else if (r > (r0>rs?r0-rs:rs-r0) ) {//IV
374  dh4(r,r2,ri,rc,r0,rs,dh); d = 4;
375  } else if (r0 < rs ) {//V
376  dh5(r,r2,ri,rc,r0,rs,dh); d = 5;
377  } else {//VI
378  dh6(r,r2,ri,rc,r0,rs,dh); d = 6;
379  }
380 }
381 }
382 #ifdef GBIS_CUDA
383 __device__ __forceinline__ void CalcHPair
384 #else
385 static inline void CalcHPair
386 #endif
387 (
388  float r,//distance
389  float r2,//distance squared
390  float ri,//inverse distance
391  float rc,//cutoff
392  float ri0,
393  float rjs,
394  float rj0,
395  float ris,
396  int & dij,//domain 1
397  int & dji,//domain 2
398  float & hij,//output
399  float & hji//output
400 ) {
401  CalcH(r,r2,ri,rc,ri0,rjs,hij,dij);//hij
402  CalcH(r,r2,ri,rc,rj0,ris,hji,dji);//hji
403 }
404 #ifdef GBIS_CUDA
405 __device__ __forceinline__ void CalcDHPair
406 #else
407 static inline void CalcDHPair
408 #endif
409 ( float r,//distance
410  float r2,
411  float ri,
412  float rc,//cutoff
413  float ri0,
414  float rjs,
415  float rj0,
416  float ris,
417  int & dij,//domain 1
418  int & dji,//domain 2
419  float & dhij,
420  float & dhji
421 ) {
422 // swapped
423  CalcDH(r,r2,ri,rc,ri0,rjs,dhij,dij);//hij
424  CalcDH(r,r2,ri,rc,rj0,ris,dhji,dji);//hji
425 }
426 
427 /*
428  * Calculate GB Energy, GB dEdr force
429  * also output intermediate values used in dEda
430  */
431 #ifdef GBIS_CUDA
432 __device__ __forceinline__ void Calc_dEdr_Pair
433 #else
434 static inline void Calc_dEdr_Pair
435 #endif
436 (//no longer does i==j
437  const float & r,
438  const float & r2,
439  const float & qiqj,
440  const float & ai,
441  const float & aj,
442  const float & kappa,
443  const float & epsilon_p_i,
444  const float & epsilon_s_i,
445  float & aiaj,
446  float & expr2aiaj4,
447  float & fij,
448  float & f_i,
449  float & expkappa,
450  float & Dij,
451  float & gbE, //return
452  float & ddrGbE //return
453 ) {
454  //allocate local variables
455  float aiaj4,ddrDij,ddrf_i,ddrfij;
456 
457  //calculate GB energy
458  aiaj = ai*aj;
459  aiaj4 = 4.f*aiaj;
460  //printf("exp(%e)\n",(-r2/aiaj4));
461  expr2aiaj4 = exp(-r2/aiaj4);
462  fij = sqrt(r2+aiaj*expr2aiaj4);
463  f_i = 1/fij;
464  expkappa = (kappa > 0.f) ? exp(-kappa*fij) : 1.f;
465  Dij = epsilon_p_i - expkappa*epsilon_s_i;
466  //gbE = -COULOMB*qiqj*Dij*f_i;
467  gbE = qiqj*Dij*f_i;
468 
469  //calculate energy derivatives
470  ddrfij = r*f_i*(1.f - 0.25f*expr2aiaj4);
471  ddrf_i = -ddrfij*f_i*f_i;
472  ddrDij = kappa*expkappa*ddrfij*epsilon_s_i;
473  //ddrGbE = -COULOMB*qiqj*(ddrDij*f_i+Dij*ddrf_i);
474  ddrGbE = qiqj*(ddrDij*f_i+Dij*ddrf_i);
475 }
476 
477 /*
478  * Calculate summation element of dEda array
479  * must calculate dEdr previously to retreive intermediate values
480  */
481 #ifdef GBIS_CUDA
482 __device__ __forceinline__ void Calc_dEda_Pair
483 #else
484 static inline void Calc_dEda_Pair
485 #endif
486 ( const float & r2,
487  const float & ai,
488  const float & aj,
489  const float & qiqj,
490  const float & kappa,
491  const float & aiaj,
492  const float & expkappa,
493  const float & expr2aiaj4,
494  const float & fij,
495  const float & f_i,
496  const float & Dij,
497  const float & epsilon_s_i,
498  float & dEdai,//return
499  float & dEdaj //return
500 ) {
501 
502  //float tmp_dEda = -0.5*COULOMB*qiqj*f_i*f_i
503  float tmp_dEda = 0.5f*qiqj*f_i*f_i
504  *(kappa*epsilon_s_i*expkappa-Dij*f_i)
505  *(aiaj+0.25f*r2)*expr2aiaj4;//0
506  dEdai = tmp_dEda/ai;
507  dEdaj = tmp_dEda/aj;
508 }
509 
510 /*
511  * Calculate Coulomb and GB interaction and dEda element
512  * for a pair of atoms
513  */
514 #ifdef GBIS_CUDA
515 __device__ __forceinline__ void Phase2_Pair
516 #else
517 static inline void Phase2_Pair
518 #endif
519 (//doesn't do self energies
520 
521 //input values
522  const float & r,
523  const float & r2,
524  const float & r_i,
525  const float & qiqj,
526  const float & ai,
527  const float & aj,
528  const float & epsilon_p_i,
529  const float & epsilon_s_i,
530  const float & kappa,
531  const int & doFullElect,
532 
533 //return values
534  float & gbEij,
535  float & ddrGbEij,
536  float & dEdai,
537  float & dEdaj
538 ) {
539 
540  //calculate GB energy and force
541  float aiaj,expr2aiaj4,fij,f_i,expkappa,Dij;
542  Calc_dEdr_Pair(r,r2,qiqj,ai,aj,
543  kappa,epsilon_p_i,epsilon_s_i,
544  aiaj,expr2aiaj4,fij,f_i,expkappa,
545  Dij,gbEij,ddrGbEij);
546 
547  //calculate dEda
548  if (doFullElect) {
549  Calc_dEda_Pair(r2,ai,aj,qiqj,kappa,
550  aiaj,expkappa,expr2aiaj4,
551  fij,f_i,Dij,epsilon_s_i,dEdai,dEdaj);
552  } else {
553  dEdai = 0.f;
554  dEdaj = 0.f;
555  }
556 }
557 
558 #if 0
559 static inline void init_gbisTable (
560 float **tablePtr,
561 float kappa,
562 float maxX,
563 int numEntriesPerX
564 ) {
565  float *table = *tablePtr;//dereference
566  float minX = 0;
567  int numPts = (maxX-minX) * numEntriesPerX;
568  int numVals = 3;
569  /*
570  table = (float*) malloc(numVals*numPts*sizeof(float));
571  for (int i = 0; i < numPts; i++) {
572  float x = (1.0*i) / numEntriesPerX + minX;
573  bornRadJ = gbisParams->bornRad[1][j];
574  aiaj = bornRadI * bornRadJ;
575  aiaj4 = 4.0 * aiaj;
576  expr2aiaj4 = exp(-r2/aiaj4);
577  fij = sqrt(r2+aiaj*expr2aiaj4);
578  f_i = 1.0/fij;
579  expkappa = (kappa > 0.0) ? exp(-kappa*fij) : 1.0;
580  }
581 */
582 }
583 #endif
584 
585 //include once
586 #endif
#define TE
Definition: ComputeGBIS.inl:36
#define TD
Definition: ComputeGBIS.inl:35
#define TA
Definition: ComputeGBIS.inl:32
static void h4(float r, float r2, float ri, float rc, float r0, float rs, float &h)
static void h2(float r, float r2, float ri, float rc, float r0, float rs, float &h)
static void dh0(float r, float r2, float ri, float rc, float r0, float rs, float &dh)
#define TC
Definition: ComputeGBIS.inl:34
static void Phase2_Pair(const float &r, const float &r2, const float &r_i, const float &qiqj, const float &ai, const float &aj, const float &epsilon_p_i, const float &epsilon_s_i, const float &kappa, const int &doFullElect, float &gbEij, float &ddrGbEij, float &dEdai, float &dEdaj)
static void dh3(float r, float r2, float ri, float rc, float r0, float rs, float &dh)
#define DA
Definition: ComputeGBIS.inl:37
#define DD
Definition: ComputeGBIS.inl:40
static void h5(float r, float r2, float ri, float rc, float r0, float rs, float &h)
static void CalcDHPair(float r, float r2, float ri, float rc, float ri0, float rjs, float rj0, float ris, int &dij, int &dji, float &dhij, float &dhji)
static void dh1(float r, float r2, float ri, float rc, float r0, float rs, float &dh)
static void h1(float r, float r2, float ri, float rc, float r0, float rs, float &h)
static void CalcDH(float r, float r2, float ri, float rc, float r0, float rs, float &dh, int &d)
static void dh5(float r, float r2, float ri, float rc, float r0, float rs, float &dh)
static void Calc_dEdr_Pair(const float &r, const float &r2, const float &qiqj, const float &ai, const float &aj, const float &kappa, const float &epsilon_p_i, const float &epsilon_s_i, float &aiaj, float &expr2aiaj4, float &fij, float &f_i, float &expkappa, float &Dij, float &gbE, float &ddrGbE)
static void dh2(float r, float r2, float ri, float rc, float r0, float rs, float &dh)
#define DB
Definition: ComputeGBIS.inl:38
#define DC
Definition: ComputeGBIS.inl:39
static void h3(float r, float r2, float ri, float rc, float r0, float rs, float &h)
static void CalcHPair(float r, float r2, float ri, float rc, float ri0, float rjs, float rj0, float ris, int &dij, int &dji, float &hij, float &hji)
static void h6(float r, float r2, float ri, float rc, float r0, float rs, float &h)
static float MassToRadius(Mass mi)
Definition: ComputeGBIS.inl:55
static float MassToScreen(Mass mi)
float Mass
Definition: ComputeGBIS.inl:20
static void CalcH(float r, float r2, float ri, float rc, float r0, float rs, float &h, int &d)
static void h0(float r, float r2, float ri, float rc, float r0, float rs, float &h)
#define TB
Definition: ComputeGBIS.inl:33
static void dh6(float r, float r2, float ri, float rc, float r0, float rs, float &dh)
gridSize x
static void Calc_dEda_Pair(const float &r2, const float &ai, const float &aj, const float &qiqj, const float &kappa, const float &aiaj, const float &expkappa, const float &expr2aiaj4, const float &fij, const float &f_i, const float &Dij, const float &epsilon_s_i, float &dEdai, float &dEdaj)
static void dh4(float r, float r2, float ri, float rc, float r0, float rs, float &dh)
#define DE
Definition: ComputeGBIS.inl:41
static float FastTanH(float x)
Definition: ComputeGBIS.inl:44
float GBReal
Definition: ComputeGBIS.inl:17