OpenAtom  Version1.5a
PIBeadAtoms.C
1 /*
2 ** PIBeadAtoms.C
3 **
4 ** Made by (Eric Bohm)
5 ** Login <bohm@alacrity>
6 **
7 ** Started on Tue Mar 2 10:15:33 2010 Eric Bohm
8 ** Last update Sun May 12 01:17:25 2002 Speed Blue
9 
10 */
11 
12 
13 #include "AtomsCompute.h"
14 #include "PIBeadAtoms.h"
15 
16 extern CkVec <CProxy_AtomsCompute> UatomsComputeProxy;
17 
18 /// NOTE: thisIndex == atomIndex
19 
20 //////////////////////////////////////////////////////////////////////////////
21 //////////////////////////////////////////////////////////////////////////////
22 //////////////////////////////////////////////////////////////////////////////
23 PIBeadAtoms::PIBeadAtoms(UberCollection _thisInstance, int _numBeads, int _natm) :thisInstance(_thisInstance),
24  numBeads(_numBeads), natm (_natm)
25 //////////////////////////////////////////////////////////////////////////////
26  {// begin routine
27 //////////////////////////////////////////////////////////////////////////////
28 /// CkPrintf("{%d}[%d] PIBeadAtoms::PIBeadAtoms numbeads %d\n",thisInstance.proxyOffset,thisIndex, numBeads);
29 
30  x= new double[numBeads];
31  y= new double[numBeads];
32  z= new double[numBeads];
33  xu= new double[numBeads];
34  yu= new double[numBeads];
35  zu= new double[numBeads];
36  fx= new double[numBeads];
37  fy= new double[numBeads];
38  fz= new double[numBeads];
39  fxu= new double[numBeads];
40  fyu= new double[numBeads];
41  fzu= new double[numBeads];
42 
43  rat1 = new double[numBeads];
44  rat2 = new double[numBeads];
45  veig = new double[numBeads];
46 
47 //////////////////////////////////////////////////////////////////////////////
48 /// Initialize magic ratios
49 
50  rat1[0] = 0.0;
51  rat2[0] = 0.0;
52  veig[0] = 0.0;
53  for(int ip=2;ip<=numBeads;ip++){
54  int ip1 = ip-1;
55  rat1[ip1] = ((double)(ip1))/((double)(ip));
56  rat2[ip1] = 1.0/((double)(ip));
57  veig[ip1] = ((double)(ip))/((double)(ip1));
58  }//endfor
59 
60 //////////////////////////////////////////////////////////////////////////////
61 /// Initialize communication counters
62 
63  acceptCount_Fx=0;
64  acceptCount_u=0;
65  acceptCount_x=0;
66 
67 //////////////////////////////////////////////////////////////////////////////
68  }//end routine
69 //////////////////////////////////////////////////////////////////////////////
70 
71 
72 
73 //////////////////////////////////////////////////////////////////////////////
74 //////////////////////////////////////////////////////////////////////////////
75 //////////////////////////////////////////////////////////////////////////////
76 void PIBeadAtoms::accept_PIMD_Fx(AtomXYZMsg *msg)
77 //////////////////////////////////////////////////////////////////////////////
78  {// begin routine
79  fx[msg->index]=msg->x[thisIndex];
80  fy[msg->index]=msg->y[thisIndex];
81  fz[msg->index]=msg->z[thisIndex];
82  delete msg;
83  // atomdest[PIBeadIndex]=atomdest;
84  acceptCount_Fx++;
85  // CkPrintf("{%d}[%d] PIBeadAtoms::accept_PIMD_Fx (%d of %d)\n",thisInstance.proxyOffset,thisIndex, acceptCount_Fx, numBeads);
86 
87  //
88  if(acceptCount_Fx==numBeads){
89  compute_PIMD_Fu();
90  acceptCount_Fx=0;
91  UberCollection instance=thisInstance;
92  for(int bead=0;bead<numBeads; bead++){
93  instance.idxU.x=bead;
94  int proxyOffset=instance.setPO();
95  // CkPrintf("{%d}[%d] PIBeadAtoms::accept_PIMD_Fx sending atomsGrp{%d}.accept_PIMD_fu\n",thisInstance.proxyOffset,thisIndex, proxyOffset);
96  // UatomsGrpProxy[proxyOffset][atomdest].accept_PIMD_fu(fxu[bead],
97  // fyu[bead], fzu[bead], thisIndex);
98  // this atom index has to send the Fu to everyone
99  UatomsComputeProxy[proxyOffset].accept_PIMD_Fu(fxu[bead], fyu[bead], fzu[bead], thisIndex);
100  }//endfor
101  }//endif
102 //////////////////////////////////////////////////////////////////////////////
103  }//end routine
104 //////////////////////////////////////////////////////////////////////////////
105 
106 
107 //////////////////////////////////////////////////////////////////////////////
108 //////////////////////////////////////////////////////////////////////////////
109 //////////////////////////////////////////////////////////////////////////////
110 void PIBeadAtoms::accept_PIMD_Fx_and_x(AtomXYZMsg *msg)
111 //////////////////////////////////////////////////////////////////////////////
112  {// begin routine
113 //////////////////////////////////////////////////////////////////////////////
114 
115  fx[msg->index]=msg->x[thisIndex];
116  fy[msg->index]=msg->y[thisIndex];
117  fz[msg->index]=msg->z[thisIndex];
118  x[msg->index]=msg->x[(thisIndex+natm)];
119  y[msg->index]=msg->y[(thisIndex+natm)];
120  z[msg->index]=msg->z[(thisIndex+natm)];
121  delete msg;
122 
123 //////////////////////////////////////////////////////////////////////////////
124 /// atomdest[PIBeadIndex]=atomdest;
125 
126  acceptCount_Fx++;
127  // CkPrintf("{%d}[%d] PIBeadAtoms::accept_PIMD_Fx (%d of %d)\n",thisInstance.proxyOffset,thisIndex, acceptCount_Fx, numBeads);
128 
129  if(acceptCount_Fx==numBeads){
130  compute_PIMD_Fu();
131  compute_PIMD_u();
132  acceptCount_Fx=0;
133  UberCollection instance=thisInstance;
134  for(int bead=0;bead<numBeads; bead++){
135  instance.idxU.x=bead;
136  int proxyOffset=instance.setPO();
137  // CkPrintf("{%d}[%d] PIBeadAtoms::accept_PIMD_Fx sending atomsGrp{%d}.accept_PIMD_fu\n",thisInstance.proxyOffset,thisIndex, proxyOffset);
138  // UatomsGrpProxy[proxyOffset][atomdest].accept_PIMD_fu(fxu[bead],
139  // fyu[bead], fzu[bead], thisIndex);
140  // this atom index has to send the Fu to everyone
141  UatomsComputeProxy[proxyOffset].accept_PIMD_Fu_and_u(fxu[bead], fyu[bead], fzu[bead],xu[bead], yu[bead], zu[bead], thisIndex);
142  }//endfor
143  }//endif
144 //////////////////////////////////////////////////////////////////////////////
145  }//end routine
146 //////////////////////////////////////////////////////////////////////////////
147 
148 
149 
150 //////////////////////////////////////////////////////////////////////////////
151 //////////////////////////////////////////////////////////////////////////////
152 //////////////////////////////////////////////////////////////////////////////
153 void PIBeadAtoms::accept_PIMD_u(double _xu, double _yu, double _zu, int PIBeadIndex)
154 //////////////////////////////////////////////////////////////////////////////
155  {// begin routine
156 //////////////////////////////////////////////////////////////////////////////
157 
158  xu[PIBeadIndex]=_xu;
159  yu[PIBeadIndex]=_yu;
160  zu[PIBeadIndex]=_zu;
161  acceptCount_u++;
162  // CkPrintf("{%d}[%d] PIBeadAtoms::accept_PIMD_u (%d of %d)\n",thisInstance.proxyOffset,thisIndex, acceptCount_u, numBeads );
163  if(acceptCount_u==numBeads){
164  compute_PIMD_x();
165  acceptCount_u=0;
166  UberCollection instance=thisInstance;
167  for(int bead=0;bead<numBeads; bead++){
168  instance.idxU.x=bead;
169  int proxyOffset=instance.setPO();
170  int atomdest=0;
171  // UatomsGrpProxy[proxyOffset][atomdest].accept_PIMD_x(x[bead],y[bead], z[bead], thisIndex);
172  UatomsComputeProxy[proxyOffset].accept_PIMD_x(x[bead], y[bead], z[bead], thisIndex);
173  }//endfor
174  }//endif
175 
176 //////////////////////////////////////////////////////////////////////////////
177  }//end routine
178 //////////////////////////////////////////////////////////////////////////////
179 
180 
181 
182 //////////////////////////////////////////////////////////////////////////////
183 //////////////////////////////////////////////////////////////////////////////
184 //////////////////////////////////////////////////////////////////////////////
185 void PIBeadAtoms::accept_PIMD_x(double _x, double _y, double _z, int PIBeadIndex )
186 //////////////////////////////////////////////////////////////////////////////
187  {// begin routine
188 //////////////////////////////////////////////////////////////////////////////
189 
190  x[PIBeadIndex]=_x;
191  y[PIBeadIndex]=_y;
192  z[PIBeadIndex]=_z;
193  acceptCount_x++;
194  // CkPrintf("{%d}[%d] PIBeadAtoms::accept_PIMD_x (%d of %d) \n",thisInstance.proxyOffset,thisIndex, acceptCount_x, numBeads);
195  if(acceptCount_x==numBeads){
196  compute_PIMD_u();
197  acceptCount_x=0;
198  UberCollection instance=thisInstance;
199  for(int bead=0;bead<numBeads; bead++){
200  instance.idxU.x=bead;
201  int proxyOffset=instance.setPO();
202  int atomdest=0;
203  // UatomsGrpProxy[proxyOffset][atomdest].accept_PIMD_u(xu[bead],yu[bead],zu[bead], thisIndex);
204  UatomsComputeProxy[proxyOffset].accept_PIMD_u(xu[bead],yu[bead],zu[bead], thisIndex);
205  }//endfor
206  }//endif
207 
208 //////////////////////////////////////////////////////////////////////////////
209  }//end routine
210 //////////////////////////////////////////////////////////////////////////////
211 
212 
213 
214 //////////////////////////////////////////////////////////////////////////////
215 //////////////////////////////////////////////////////////////////////////////
216 //////////////////////////////////////////////////////////////////////////////
217 void PIBeadAtoms::compute_PIMD_Fu()
218 //////////////////////////////////////////////////////////////////////////////
219  {// begin routine
220 //////////////////////////////////////////////////////////////////////////////
221 
222  if(numBeads<=0){
223  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@@@\n");
224  CkPrintf("The number of beads must be >=0\n");
225  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@@@\n");
226  exit(0);
227  }//endif
228 
229 //////////////////////////////////////////////////////////////////////////////
230 
231  if(numBeads>1){
232  fxu[0] = 0.0; fyu[0] = 0.0; fzu[0] = 0.0;
233  for(int ip=0;ip<numBeads;ip++){
234  fxu[0] += fx[ip]; fyu[0] += fy[ip]; fzu[0] += fz[ip];
235  }/*endfor*/
236  fxu[1] = fx[1]; fyu[1] = fy[1]; fzu[1] = fz[1];
237  for(int ip=1;ip<numBeads-1;ip++){
238  int ip1 = ip+1;
239  fxu[ip1] = fx[ip1] + rat1[ip]*fxu[ip];
240  fyu[ip1] = fy[ip1] + rat1[ip]*fyu[ip];
241  fzu[ip1] = fz[ip1] + rat1[ip]*fzu[ip];
242  }/*endfor*/
243  }else{
244  fxu[0] = fx[0]; fyu[0] = fy[0]; fzu[0] = fz[0];
245  }/*endif*/
246 
247 //////////////////////////////////////////////////////////////////////////////
248  }//end routine
249 //////////////////////////////////////////////////////////////////////////////
250 
251 
252 
253 
254 //////////////////////////////////////////////////////////////////////////////
255 //////////////////////////////////////////////////////////////////////////////
256 //////////////////////////////////////////////////////////////////////////////
257 void PIBeadAtoms::compute_PIMD_u()
258 //////////////////////////////////////////////////////////////////////////////
259  {// begin routine
260 //////////////////////////////////////////////////////////////////////////////
261 
262  if(numBeads<=0){
263  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@@@\n");
264  CkPrintf("The number of beads must be >=0\n");
265  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@@@\n");
266  exit(0);
267  }//endif
268 
269 //////////////////////////////////////////////////////////////////////////////
270 
271  if(numBeads>1){
272  xu[0] = x[0]; yu[0] = y[0]; zu[0] = z[0];
273  for(int ip=1;ip<numBeads-1;ip++){
274  int ip1 = ip+1;
275  double xstar = rat1[ip]*x[ip1] + rat2[ip]*x[0];
276  double ystar = rat1[ip]*y[ip1] + rat2[ip]*y[0];
277  double zstar = rat1[ip]*z[ip1] + rat2[ip]*z[0];
278  xu[ip] = x[ip] - xstar;
279  yu[ip] = y[ip] - ystar;
280  zu[ip] = z[ip] - zstar;
281  }/*endfor:ip*/
282  int ip = numBeads-1;
283  xu[ip] = x[ip] - x[0];
284  yu[ip] = y[ip] - y[0];
285  zu[ip] = z[ip] - z[0];
286  }else{
287  xu[0] = x[0]; yu[0] = y[0]; zu[0] = z[0];
288  }//endif
289 
290 //////////////////////////////////////////////////////////////////////////////
291  }//end routine
292 //////////////////////////////////////////////////////////////////////////////
293 
294 
295 
296 
297 //////////////////////////////////////////////////////////////////////////////
298 //////////////////////////////////////////////////////////////////////////////
299 //////////////////////////////////////////////////////////////////////////////
300 void PIBeadAtoms::compute_PIMD_x()
301 //////////////////////////////////////////////////////////////////////////////
302  {// begin routine
303 //////////////////////////////////////////////////////////////////////////////
304 
305  if(numBeads<=0){
306  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@@@\n");
307  CkPrintf("The number of beads must be >=0\n");
308  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@@@\n");
309  exit(0);
310  }//endif
311 
312 //////////////////////////////////////////////////////////////////////////////
313 
314 
315  if(numBeads>1){
316  x[0] = xu[0]; y[0] = yu[0]; z[0] = zu[0];
317  int ip = numBeads-1;
318  x[ip] = xu[ip] + x[0]; y[ip] = yu[ip] + y[0]; z[ip] = zu[ip] + z[0];
319  for(int ip=numBeads-2;ip>=1;ip--){
320  int ip1 = ip+1;
321  double xadd = rat1[ip]*x[ip1]+xu[0]*rat2[ip];
322  double yadd = rat1[ip]*y[ip1]+yu[0]*rat2[ip];
323  double zadd = rat1[ip]*z[ip1]+zu[0]*rat2[ip];
324  x[ip] = xu[ip] + xadd;
325  y[ip] = yu[ip] + yadd;
326  z[ip] = zu[ip] + zadd;
327  }/*endfor*/
328  }else{
329  x[0] = xu[0]; y[0] = yu[0]; z[0] = zu[0];
330  }//endif
331 
332 //////////////////////////////////////////////////////////////////////////////
333  }//end routine
334 //////////////////////////////////////////////////////////////////////////////
335 
336 
337 
338 //////////////////////////////////////////////////////////////////////////////
339 /// useful for debugging
340 //////////////////////////////////////////////////////////////////////////////
341 //////////////////////////////////////////////////////////////////////////////
342 //////////////////////////////////////////////////////////////////////////////
343 void PIBeadAtoms::output_PIMD_x()
344 //////////////////////////////////////////////////////////////////////////////
345  {// begin routine
346 //////////////////////////////////////////////////////////////////////////////
347 
348  CkPrintf("\n/////////////////////////////////\n");
349  for(int i =0;i<numBeads;i++){
350  CkPrintf("x[%d]: %g %g %g\n",i,x[i],y[i],z[i]);
351  }//endfor
352  CkPrintf("/////////////////////////////////\n\n");
353 
354 //////////////////////////////////////////////////////////////////////////////
355  }//end routine
356 //////////////////////////////////////////////////////////////////////////////
357 
358 
359 //////////////////////////////////////////////////////////////////////////////
360 /// useful for debugging
361 //////////////////////////////////////////////////////////////////////////////
362 //////////////////////////////////////////////////////////////////////////////
363 //////////////////////////////////////////////////////////////////////////////
364 void PIBeadAtoms::output_PIMD_u()
365 //////////////////////////////////////////////////////////////////////////////
366  {// begin routine
367 //////////////////////////////////////////////////////////////////////////////
368 
369  CkPrintf("\n/////////////////////////////////\n");
370  for(int i =0;i<numBeads;i++){
371  CkPrintf("u[%d]: %g %g %g\n",i,xu[i],yu[i],zu[i]);
372  }//endfor
373  CkPrintf("/////////////////////////////////\n\n");
374 
375 //////////////////////////////////////////////////////////////////////////////
376  }//end routine
377 //////////////////////////////////////////////////////////////////////////////
378 
379 
380 //////////////////////////////////////////////////////////////////////////////
381 /// useful for debugging
382 //////////////////////////////////////////////////////////////////////////////
383 //////////////////////////////////////////////////////////////////////////////
384 //////////////////////////////////////////////////////////////////////////////
385 void PIBeadAtoms::zero_PIMD_u()
386 //////////////////////////////////////////////////////////////////////////////
387  {// begin routine
388 //////////////////////////////////////////////////////////////////////////////
389 
390  for(int i =0;i<numBeads;i++){
391  xu[i] = 0.0; yu[i] = 0.0; zu[i] = 0.0;;
392  }//endfor
393 
394 //////////////////////////////////////////////////////////////////////////////
395  }//end routine
396 //////////////////////////////////////////////////////////////////////////////
397 
398 //////////////////////////////////////////////////////////////////////////////
399 /// useful for debugging
400 //////////////////////////////////////////////////////////////////////////////
401 //////////////////////////////////////////////////////////////////////////////
402 //////////////////////////////////////////////////////////////////////////////
403 void PIBeadAtoms::zero_PIMD_fu()
404 //////////////////////////////////////////////////////////////////////////////
405  {// begin routine
406 //////////////////////////////////////////////////////////////////////////////
407 
408  for(int i =0;i<numBeads;i++){
409  fxu[i] = 0.0; fyu[i] = 0.0; fzu[i] = 0.0;;
410  }//endfor
411 
412 //////////////////////////////////////////////////////////////////////////////
413  }//end routine
414 //////////////////////////////////////////////////////////////////////////////
415 
416 
417 //////////////////////////////////////////////////////////////////////////////
418 /// useful for debugging
419 //////////////////////////////////////////////////////////////////////////////
420 //////////////////////////////////////////////////////////////////////////////
421 //////////////////////////////////////////////////////////////////////////////
422 void PIBeadAtoms::zero_PIMD_x()
423 //////////////////////////////////////////////////////////////////////////////
424  {// begin routine
425 //////////////////////////////////////////////////////////////////////////////
426 
427  for(int i =0;i<numBeads;i++){
428  x[i] = 0.0; y[i] = 0.0; z[i] = 0.0;;
429  }//endfor
430 
431 //////////////////////////////////////////////////////////////////////////////
432  }//end routine
433 //////////////////////////////////////////////////////////////////////////////
434 
435 
436 //////////////////////////////////////////////////////////////////////////////
437 /// useful for debugging
438 //////////////////////////////////////////////////////////////////////////////
439 //////////////////////////////////////////////////////////////////////////////
440 //////////////////////////////////////////////////////////////////////////////
441 void PIBeadAtoms::energy_PIMD_x()
442 //////////////////////////////////////////////////////////////////////////////
443  {// begin routine
444 //////////////////////////////////////////////////////////////////////////////
445 
446  int ip = 0;
447  int ip1 = numBeads-1;
448  double ep;
449  ep = ( (x[ip]-x[ip1])*(x[ip]-x[ip1])
450  +(y[ip]-y[ip1])*(y[ip]-y[ip1])
451  +(z[ip]-z[ip1])*(z[ip]-z[ip1])
452  );
453  for(int ip=1;ip<numBeads;ip++){
454  int ip1 = ip-1;
455  ep += ( (x[ip]-x[ip1])*(x[ip]-x[ip1])
456  +(y[ip]-y[ip1])*(y[ip]-y[ip1])
457  +(z[ip]-z[ip1])*(z[ip]-z[ip1])
458  );
459  }//endfor
460  CkPrintf("\n/////////////////////////////////\n");
461  CkPrintf("x energy %.10g\n",ep);
462  CkPrintf("/////////////////////////////////\n");
463 
464 //////////////////////////////////////////////////////////////////////////////
465  }//end routine
466 //////////////////////////////////////////////////////////////////////////////
467 
468 
469 //////////////////////////////////////////////////////////////////////////////
470 /// useful for debugging
471 //////////////////////////////////////////////////////////////////////////////
472 //////////////////////////////////////////////////////////////////////////////
473 //////////////////////////////////////////////////////////////////////////////
474 void PIBeadAtoms::energy_PIMD_u()
475 //////////////////////////////////////////////////////////////////////////////
476  {// begin routine
477 //////////////////////////////////////////////////////////////////////////////
478 
479  double ep = 0.0;
480  for(int ip =1;ip<numBeads;ip++){
481  double fk = veig[ip];
482  ep += fk*(xu[ip]*xu[ip]
483  +yu[ip]*yu[ip]
484  +zu[ip]*zu[ip]
485  );
486  }//endfor
487  CkPrintf("\n/////////////////////////////////\n");
488  CkPrintf("u energy %.10g\n",ep);
489  CkPrintf("/////////////////////////////////\n");
490 
491 //////////////////////////////////////////////////////////////////////////////
492  }//end routine
493 //////////////////////////////////////////////////////////////////////////////
494 
495 
496 
497 //////////////////////////////////////////////////////////////////////////////
498 /// useful for debugging
499 //////////////////////////////////////////////////////////////////////////////
500 //////////////////////////////////////////////////////////////////////////////
501 //////////////////////////////////////////////////////////////////////////////
502 void PIBeadAtoms::checkUforce()
503 //////////////////////////////////////////////////////////////////////////////
504  {// begin routine
505 //////////////////////////////////////////////////////////////////////////////
506 
507  printf("\n/////////////////////////////////\n");
508 
509  double potpx,potmx;
510  double potpy,potmy;
511  double potpz,potmz;
512  double delta = 1.e-05;
513  for(int ip =0;ip<numBeads;ip++){
514 
515  xu[ip] += delta;
516  compute_PIMD_x();
517  modelpot_PIMD_x(&potpx);
518  xu[ip] -= 2.0*delta;
519  compute_PIMD_x();
520  modelpot_PIMD_x(&potmx);
521  xu[ip] += delta;
522 
523  yu[ip] += delta;
524  compute_PIMD_x();
525  modelpot_PIMD_x(&potpy);
526  yu[ip] -= 2.0*delta;
527  compute_PIMD_x();
528  modelpot_PIMD_x(&potmy);
529  yu[ip] += delta;
530 
531  zu[ip] += delta;
532  compute_PIMD_x();
533  modelpot_PIMD_x(&potpz);
534  zu[ip] -= 2.0*delta;
535  compute_PIMD_x();
536  modelpot_PIMD_x(&potmz);
537  zu[ip] += delta;
538  printf("fu[%d]: %.10g %.10g : %.10g %.10g : %.10g %.10g\n",
539  ip,fxu[ip],0.5*(potmx-potpx)/delta,
540  fyu[ip],0.5*(potmy-potpy)/delta,
541  fzu[ip],0.5*(potmz-potpz)/delta);
542  }//endfor
543 
544  printf("/////////////////////////////////\n");
545 
546 //////////////////////////////////////////////////////////////////////////////
547  }//end routine
548 //////////////////////////////////////////////////////////////////////////////
549 
550 
551 //////////////////////////////////////////////////////////////////////////////
552 /// useful for debugging
553 //////////////////////////////////////////////////////////////////////////////
554 //////////////////////////////////////////////////////////////////////////////
555 //////////////////////////////////////////////////////////////////////////////
556 void PIBeadAtoms::modelpot_PIMD_x(double *pot_out)
557 //////////////////////////////////////////////////////////////////////////////
558  {// begin routine
559 //////////////////////////////////////////////////////////////////////////////
560 
561  double pot = 0.0;
562  double fk = 0.5;
563  for(int ip =0;ip<numBeads;ip++){
564  pot += fk*(x[ip]*x[ip]
565  +y[ip]*y[ip]
566  +z[ip]*z[ip]
567  );
568  }//endfor
569 
570  pot_out[0] = pot;
571 
572 //////////////////////////////////////////////////////////////////////////////
573  }//end routine
574 //////////////////////////////////////////////////////////////////////////////
575 
576 #include "PIBeadAtoms.def.h"
UberCollection
holds the UberIndex and the offset for proxies
Definition: Uber.h:68
AtomsCompute.h
Accepts reduction of forces from AtomsCache, integrates forces to produce new coordinates, distributes new coordinates to AtomsCache.
PIBeadAtoms::output_PIMD_x
void output_PIMD_x()
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:343
PIBeadAtoms::zero_PIMD_u
void zero_PIMD_u()
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:385
PIBeadAtoms::zero_PIMD_x
void zero_PIMD_x()
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:422
PIBeadAtoms::output_PIMD_u
void output_PIMD_u()
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:364
PIBeadAtoms::energy_PIMD_x
void energy_PIMD_x()
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:441
PIBeadAtoms::accept_PIMD_Fx_and_x
void accept_PIMD_Fx_and_x(AtomXYZMsg *msg)
Definition: PIBeadAtoms.C:110
PIBeadAtoms::energy_PIMD_u
void energy_PIMD_u()
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:474
PIBeadAtoms::checkUforce
void checkUforce()
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:502
PIBeadAtoms::zero_PIMD_fu
void zero_PIMD_fu()
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:403
PIBeadAtoms::modelpot_PIMD_x
void modelpot_PIMD_x(double *)
useful for debugging /////////////////////////////////////////////////////////////////////////// ////...
Definition: PIBeadAtoms.C:556