NAMD
HomePatch.h
Go to the documentation of this file.
1 
7 /*
8  HomePatch is the key distributed source/sink of Atom data
9  including positions, velocities and forces applied
10 */
11 
12 #ifndef HOMEPATCH_H
13 #define HOMEPATCH_H
14 
15 #include "charm++.h"
16 
17 #include "NamdTypes.h"
18 #include "Patch.h"
19 #include "PatchMap.h"
20 
21 #include "MigrateAtomsMsg.h"
22 #include "main.h"
23 #include "common.h"
24 #include "Migration.h"
25 #include "Settle.h"
26 
27 #include <string>
28 #include <map>
29 
30 class RegisterProxyMsg;
31 class UnregisterProxyMsg;
33 class ProxyResultMsg;
35 class Sequencer;
36 class SubmitReduction;
39 class CheckpointAtomsMsg;
40 class ExchangeAtomsMsg;
41 
43 
44 class ComputeQMMgr;
45 
46 
47 #ifdef TIMER_COLLECTION
48 
49 #include <time.h>
50 
51 struct TimerMicrosecond {
52  struct timespec ts;
53  inline void start() {
54  clock_gettime(CLOCK_REALTIME, &ts);
55  }
56  inline double stop() {
57  struct timespec tsend;
58  clock_gettime(CLOCK_REALTIME, &tsend);
59  return( (tsend.tv_sec - ts.tv_sec) * 1e6 // sec to microsec
60  + (tsend.tv_nsec - ts.tv_nsec) * 1e-3 ); // nanosec to microsec
61  }
62 };
63 
64 #define TIMER_SLOTS 101
65 #define TIMER_SLOT_WIDTH 1
66 
68 struct TimerEntry {
69  TimerMicrosecond tmicro;
70  double tcur;
71  double tavg;
72  double tvar;
73  double tstd;
74  double tmin;
75  double tmax;
76  double tsum;
77 #if defined(DEBUG_TIMER_COLLECTION)
78  double tcharm;
79 #endif
80 #if defined(TIMER_HISTOGRAM)
81  double slotwidth;
82  double inv_slotwidth;
83  int hist[TIMER_SLOTS];
84 #endif
85  int count;
86  TimerEntry() { reset(); }
88  inline void reset() {
89  memset(this, 0, sizeof(TimerEntry));
90  }
91  inline void init(double t = TIMER_SLOT_WIDTH) {
92  tmin = 1e20;
93 #if defined(TIMER_HISTOGRAM)
94  slotwidth = t;
95  inv_slotwidth = (slotwidth > 0 ? 1./slotwidth : 0);
96 #endif
97  }
99  inline void start() {
100 #if defined(DEBUG_TIMER_COLLECTION)
101  tcharm = CkWallTimer();
102 #endif
103  tmicro.start();
104  }
106  inline void stop() {
107  tcur = tmicro.stop();
108 #if defined(DEBUG_TIMER_COLLECTION)
109  tcharm = CkWallTimer() - tcharm; // find ellapsed time
110  tcharm *= 1e6; // convert to microseconds
111 #endif
112  }
118  inline void update() {
119  count++;
120  tsum += tcur;
121  double delta = tcur - tavg;
122  tavg = tavg + delta / count;
123  double delta2 = tcur - tavg;
124  tvar += delta * delta2;
125  if (tcur > tmax) tmax = tcur;
126  if (tcur < tmin) tmin = tcur;
127 #if defined(TIMER_HISTOGRAM)
128  int index = int(floor(tcur * inv_slotwidth));
129  if (index >= TIMER_SLOTS) index = TIMER_SLOTS - 1;
130  hist[index]++;
131 #endif
132  }
136  inline void finalize() {
137  if (count > 0) tvar /= count;
138  tstd = sqrt(tvar);
139  if (tmin > tmax) tmin = tmax;
140  }
141 };
142 
143 struct TimerSet {
144  enum {
145  KICK,
146  MAXMOVE,
147  DRIFT,
148  PISTON,
149  SUBMITHALF,
150  VELBBK1,
151  VELBBK2,
152  RATTLE1,
153  SUBMITFULL,
154  SUBMITCOLLECT,
155  NUMTIMERS
156  };
157  TimerEntry t[NUMTIMERS];
158  static const char *tlabel[NUMTIMERS];
159 };
160 
161 #define TIMER_INIT(T,TYPE) \
162  do { \
163  (T).t[TimerSet::TYPE].init(); \
164  } while(0)
165 
166 #define TIMER_INIT_WIDTH(T,TYPE,WIDTH) \
167  do { \
168  (T).t[TimerSet::TYPE].init(WIDTH); \
169  } while(0)
170 
171 #define TIMER_START(T,TYPE) \
172  do { \
173  (T).t[TimerSet::TYPE].start(); \
174  } while(0)
175 
176 #if defined(DEBUG_TIMER_COLLECTION)
177 
178 // For debugging, compare clock_gettime with CkWallTimer.
179 // The concern is regarding these routines that are on average less than
180 // 10 us (microseconds) but are sometimes an order of magnitude slower.
181 //
182 // Note: After testing, everything with use of clock_gettime seems
183 // to be working correctly.
184 //
185 #define TIMER_STOP(T,TYPE) \
186  do { \
187  (T).t[TimerSet::TYPE].stop(); \
188  (T).t[TimerSet::TYPE].update(); \
189  double tcur = (T).t[TimerSet::TYPE].tcur; \
190  int count = (T).t[TimerSet::TYPE].count; \
191  if (tcur >= 100 && patch->patchID == SPECIAL_PATCH_ID) { \
192  printf("*** %s timing: %g count: %d line: %d charm: %g\n", \
193  (T).tlabel[TimerSet::TYPE], tcur, count, __LINE__, \
194  (T).t[TimerSet::TYPE].tcharm); \
195  } \
196  } while(0)
197 
198 #else // no DEBUG
199 
200 #define TIMER_STOP(T,TYPE) \
201  do { \
202  (T).t[TimerSet::TYPE].stop(); \
203  (T).t[TimerSet::TYPE].update(); \
204  } while(0)
205 
206 #endif // DEBUG_TIMER_COLLECTION
207 
208 #define TIMER_DONE(T) \
209  do { \
210  for (int i=0; i < TimerSet::NUMTIMERS; i++) { \
211  (T).t[i].finalize(); \
212  } \
213  } while(0)
214 
215 #if defined(TIMER_HISTOGRAM)
216 
217 #define TIMER_REPORT(T) \
218  do { \
219  printf("%13s %11s %11s %8s %8s %11s %8s\n", \
220  "name", "avg", "std", "min", "max", "sum", "calls"); \
221  printf("---------------------------------------------------------------" \
222  "-------------\n"); \
223  for (int i=0; i < TimerSet::NUMTIMERS; i++) { \
224  printf("%13s %11g %11g %8g %8g %11g %8d\n", \
225  (T).tlabel[i], (T).t[i].tavg, (T).t[i].tstd, \
226  (T).t[i].tmin, (T).t[i].tmax, (T).t[i].tsum, (T).t[i].count); \
227  } \
228  printf("---------------------------------------------------------------" \
229  "-------------\n"); \
230  for (int i=0; i < TimerSet::NUMTIMERS; i++) { \
231  printf("%13s %8s %8s %8s\n", \
232  (T).tlabel[i], "slot", "time", "count"); \
233  for (int j=0; j < TIMER_SLOTS; j++) { \
234  printf("%13s %8d %8g %8d\n", \
235  " ", j, (j+1)*(T).t[i].slotwidth, (T).t[i].hist[j]); \
236  } \
237  printf("---------------------------------------------------------------" \
238  "-------------\n"); \
239  } \
240  } while(0)
241 
242 #else // no HISTOGRAM
243 
244 #define TIMER_REPORT(T) \
245  do { \
246  printf("%13s %11s %11s %8s %8s %11s %8s\n", \
247  "name", "avg", "std", "min", "max", "sum", "calls"); \
248  printf("---------------------------------------------------------------" \
249  "-------------\n"); \
250  for (int i=0; i < TimerSet::NUMTIMERS; i++) { \
251  printf("%13s %11g %11g %8g %8g %11g %8d\n", \
252  (T).tlabel[i], (T).t[i].tavg, (T).t[i].tstd, \
253  (T).t[i].tmin, (T).t[i].tmax, (T).t[i].tsum, (T).t[i].count); \
254  } \
255  printf("---------------------------------------------------------------" \
256  "-------------\n"); \
257  } while(0)
258 
259 #endif // TIMER_HISTOGRAM
260 
261 #else // no TIMER
262 
263 #define TIMER_INIT(T,TYPE) do { } while(0)
264 #define TIMER_INIT_WIDTH(T,TYPE,WIDTH) do{ } while(0)
265 #define TIMER_START(T,TYPE) do { } while(0)
266 #define TIMER_STOP(T,TYPE) do { } while(0)
267 #define TIMER_DONE(T) do { } while(0)
268 #define TIMER_REPORT(T) do { } while(0)
269 
270 #endif // TIMER_COLLECTION
271 
272 
273 class HomePatch : public Patch {
274  friend class PatchMgr;
275  friend class Sequencer;
276  friend class ComputeGlobal;
277 
278 private:
279  // for PatchMgr to use only
281 
282  void reinitAtoms(FullAtomList&);
283  ScaledPosition min, max, center;
284  BigReal aAwayDist, bAwayDist, cAwayDist;
285 
286  Bool doAtomUpdate; // atom changes other than migration
287 
288  //Note: If new proxies are added to this HomePatch
289  // after load balancing, and it is not the immediate step
290  // after atom migration (where ProxyAllMsg will be sent),
291  // then the CompAtomExt list has to be resent with the
292  // ProxyDataMsg (the normal proxy msg when atoms don't
293  // migrate), otherwise, program will crash without such
294  // information when doing force calculations --Chao Mei
295  Bool isNewProxyAdded;
296  int numGBISP1Arrived, numGBISP2Arrived, numGBISP3Arrived;
297  bool phase1BoxClosedCalled;
298  bool phase2BoxClosedCalled;
299  bool phase3BoxClosedCalled;
300 
301 public:
302  ~HomePatch();
303 
304  // Message from ProxyPatch (via ProxyMgr) which registers its existence
306  // opposite of above
308 
309  // ProxyPatch sends Forces back to here (via ProxyMgr)
311  void receiveResults(ProxyResultMsg *msg);
312  //gbis receiving results from intermediate phases
313  void receiveResult(ProxyGBISP1ResultMsg *msg);//after P1
314  void receiveResult(ProxyGBISP2ResultMsg *msg);//after P2
315 
316  //direct function calls, not as entry methods
318 
319  // AtomMigration messages passes from neighbor HomePatches to here.
321 
322  // Bind a Sequencer to this HomePatch
323  void useSequencer(Sequencer *sequencerPtr);
324  // start simulation over this Patch of atoms
325  void runSequencer(void);
326 
327  //--------------------------------------------------------------------
328  // methods for Sequencer to use
329  //
330 
331  // Signal HomePatch that positions stored are to be now to be used
332  void positionsReady(int doMigration=0);
334 
335  // methods to implement integration
336  void saveForce(const int ftag = Results::normal);
337  void addForceToMomentum(
338  FullAtom * __restrict atom_arr,
339  const Force * __restrict force_arr,
340  const BigReal dt,
341  int num_atoms
342  )
343 #if !defined(WIN32) && !defined(WIN64)
344  __attribute__((__noinline__))
345 #endif
346  ;
347  void addForceToMomentum3(
348  FullAtom * __restrict atom_arr,
349  const Force * __restrict force_arr1,
350  const Force * __restrict force_arr2,
351  const Force * __restrict force_arr3,
352  const BigReal dt1,
353  const BigReal dt2,
354  const BigReal dt3,
355  int num_atoms
356  )
357 #if !defined(WIN32) && !defined(WIN64)
358  __attribute__((__noinline__))
359 #endif
360  ;
362  FullAtom * __restrict atom_arr,
363  const BigReal dt,
364  int num_atoms
365  )
366 #if !defined(WIN32) && !defined(WIN64)
367  __attribute__((__noinline__))
368 #endif
369  ;
370 
371  // impose hard wall constraint on Drude bond length
372  int hardWallDrude(const BigReal, Tensor *virial, SubmitReduction *);
373 
374  // methods for rigidBonds
375  struct RattleList {
376  int ig;
377  int icnt;
378  };
379 
380  std::vector<int> settleList;
381  std::vector<RattleList> rattleList;
382  std::vector<RattleParam> rattleParam;
383  std::vector<int> noconstList;
384 
386 
387  // Array to store new positions and velocities. Allocated in "buildRattleList" to size numAtoms
388  std::vector<Vector> velNew;
389  std::vector<Vector> posNew;
390 
391  void addRattleForce(const BigReal invdt, Tensor& wc);
392 
393  void buildRattleList();
394  int rattle1old(const BigReal, Tensor *virial, SubmitReduction *);
395  int rattle1(const BigReal, Tensor *virial, SubmitReduction *);
396  void rattle2(const BigReal, Tensor *virial);
397  void minimize_rattle2(const BigReal, Tensor *virial, bool forces=false);
398 
399  // methods for mollified impluse (MOLLY)
400  void mollyAverage();
401  void mollyMollify(Tensor *virial);
402 // Bool average(Vector qtilde[],const Vector q[],BigReal lambda[],const int n,const int m, const BigReal imass[], const BigReal length2[], const int ial[], const int ilb[], const Vector qji[], const BigReal tolf, const int ntrial);
403 // void mollify(Vector qtilde[],const Vector q0[],const BigReal lambda[], Vector force[],const int n, const int m, const BigReal imass[],const int ial[],const int ibl[],const Vector refab[]);
404 
405  // BEGIN LA
406  void loweAndersenVelocities();
407  void loweAndersenFinish();
408  // END LA
409 
410  void setGBISIntrinsicRadii();
411  void gbisComputeAfterP1();//calculate bornRad
412  void gbisComputeAfterP2();//calculate dHdrPrefix or self energies
413  void gbisP2Ready();
414  void gbisP3Ready();
415 
416  //LCPO
417  void setLcpoType();
418 
419  // methods for CONTRA, etc
420  void checkpoint(void);
421  void revert(void);
422 
423  void exchangeCheckpoint(int scriptTask, int &bpc);
424  void recvCheckpointReq(int task, const char *key, int replica, int pe);
427  void recvCheckpointAck();
429  struct checkpoint_t {
432  int numAtoms;
434  };
435  std::map<std::string,checkpoint_t*> checkpoints;
436 
437  // replica exchange
438  void exchangeAtoms(int scriptTask);
439  void recvExchangeReq(int req);
445 
446  // methods for QM (ExtForces replacement)
447  void replaceForces(ExtForce *f);
448 
449  void qmSwapAtoms();
450 
451  // load-balancing trigger
452  void submitLoadStats(int timestep);
453 
454  // for ComputeHomePatches
455  FullAtomList &getAtomList() { return (atom); }
456 
457 #ifdef NODEAWARE_PROXY_SPANNINGTREE
458  // build spanning tree for proxy nodes
459  void buildNodeAwareSpanningTree(void);
460  void setupChildrenFromProxySpanningTree();
461 #else
462  // build spanning tree for proxy nodes
463  void buildSpanningTree(void);
464 #endif
465 
468 
469  void sendSpanningTree();
470  void recvSpanningTree(int *t, int n);
471 
472 
473  void sendProxies();
474 
475 #if USE_TOPOMAP
476  int findSubroots(int dim, int* subroots, int psize, int* pidscopy);
477 #endif
478 
479  LDObjHandle ldObjHandle;
480 
481 #ifdef TIMER_COLLECTION
482  TimerSet timerSet;
483 #endif
484 protected:
485  virtual void boxClosed(int);
486 
487  // Internal Atom Migration methods and data
488  void doPairlistCheck();
489  void doGroupSizeCheck();
490  void doMarginCheck();
491  void doAtomMigration();
493  int numMlBuf;
495 
496 private:
497  // Store of Atom-wise variables
498  FullAtomList atom;
500  ExtForce *replacementForces;
501 
502  CudaAtomList cudaAtomList;
503 
504  // DMK - Atom Separation (water vs. non-water)
505  #if NAMD_SeparateWaters != 0
506  FullAtomList tempAtom; // A temporary array used to sort waters
507  // from non-waters in the atom array
508  void separateAtoms(); // Function to separate the atoms currently in atoms.
509  void mergeAtomList(FullAtomList &al); // Function to combine and separate
510  // the atoms in al with atoms.
511  #endif
512 
513 
514  // checkpointed state
515  FullAtomList checkpoint_atom;
516  Lattice checkpoint_lattice;
517 
518  // DMK - Atom Separation (water vs. non-water)
519  #if NAMD_SeparateWaters != 0
520  int checkpoint_numWaterAtoms;
521  #endif
522 
523 
524  // checkPairlist data
525  CompAtomList doPairlistCheck_positions;
526  Lattice doPairlistCheck_lattice;
527  BigReal doPairlistCheck_newTolerance;
528 
529  // MOLLY data
530  ResizeArray<BigReal> molly_lambda;
531 
532  // List of Proxies
533  NodeIDList proxy;
534 
535  Sequencer *sequencer;
536 
537  // Needed for initialization
538  int patchMapRead;
539  void readPatchMap();
540 
541  // Atom Migration internals
542  int allMigrationIn;
543  int migrationSuspended;
544  int patchMigrationCounter;
545  int numNeighbors;
547  MigrationInfo *mInfo[3][3][3];
548 
549 #ifdef NODEAWARE_PROXY_SPANNINGTREE
550  //the whole spanning tree for all the proxies this home patch has
551  proxyTreeNodeList ptnTree;
552  //the immediate children (recording pe ids) containing two parts:
553  //one part of them all belong to the physical node this home patch
554  // resides on; the other part of pes belong to all external nodes.
555  /* Moved to Patch.h */
556  //int *children;
557  //int numChild;
558 #else
559  NodeIDList tree; // the whole tree
560  int *child; // spanning tree of proxies - immediate children
561  int nChild;
562 #endif
563 
564  // Cached settle1 parameters
565  int settle_initialized;
566  BigReal settle_mOrmT; BigReal settle_mHrmT; BigReal settle_ra;
567  BigReal settle_rb; BigReal settle_rc; BigReal settle_rra;
568 
573  void redistrib_lonepair_forces(const int, Tensor *);
574 
575  // single topology force redistribution
576  void redistrib_alchpair_forces(const int);
577 
578  // PLF -- for TIP4P
579  //void redistrib_tip4p_force(Vector&, Vector&, Vector&, Vector&, int, Tensor*);
580  void redistrib_tip4p_forces(const int, Tensor*);
581  void tip4_omrepos(Vector*, Vector*, Vector*, BigReal);
582  void init_tip4();
583 
584  // Drude SWM4
585  void redistrib_swm4_forces(const int, Tensor*);
586  void swm4_omrepos(Vector*, Vector*, Vector*, BigReal);
587  void init_swm4();
588 
594  void reposition_colinear_lonepair(
595  Vector& ri, const Vector& rj, const Vector& rk, Real distance,
596  Real scale);
597 
602  void reposition_relative_lonepair(
603  Vector& ri, const Vector& rj, const Vector& rk, const Vector& rl,
604  Real distance, Real angle, Real dihedral);
605 
609  void reposition_all_lonepairs(void);
610 
611  //single topology end state reposition
612  void reposition_alchpair(Vector& ri, Vector& rj, Mass& Mi, Mass& Mj);
613  void reposition_all_alchpairs(void); //single topolofy alch
614 
618  void redistrib_colinear_lp_force(
619  Vector& fi, Vector& fj, Vector& fk,
620  const Vector& ri, const Vector& rj, const Vector& rk,
621  Real distance, Real scale);
622 
626  void redistrib_relative_lp_force(
627  Vector& fi, Vector& fj, Vector& fk, Vector& fl,
628  const Vector& ri, const Vector& rj, const Vector& rk, const Vector& rl,
629  Tensor *virial, int midpt);
630 
631  //single topology force transfer
632  void redistrib_ap_force(Vector& fi, Vector& fj);
638  void redistrib_lp_water_force(
639  Vector& f_ox, Vector& f_h1, Vector& f_h2, Vector& f_lp,
640  const Vector& p_ox, const Vector& p_h1, const Vector& p_h2,
641  const Vector& p_lp, Tensor *virial);
642 
643  BigReal r_om, r_ohc;
644  void write_tip4_props(void);
645 
646  int isProxyChanged;
647 
648 #if CMK_PERSISTENT_COMM
649  PersistentHandle *localphs;
650  int nphs;
651 #endif
652 };
653 
654 #endif
655 
void depositMigration(MigrateAtomsMsg *)
Definition: HomePatch.C:3996
void recvCheckpointLoad(CheckpointAtomsMsg *msg)
Definition: HomePatch.C:3515
void sendProxies()
Definition: HomePatch.C:468
void addVelocityToPosition(FullAtom *__restrict atom_arr, const BigReal dt, int num_atoms)
Definition: HomePatch.C:2000
void runSequencer(void)
Definition: HomePatch.C:269
void minimize_rattle2(const BigReal, Tensor *virial, bool forces=false)
Definition: HomePatch.C:2962
void registerProxy(RegisterProxyMsg *)
Definition: HomePatch.C:402
int marginViolations
Definition: HomePatch.h:333
int exchange_dst
Definition: HomePatch.h:441
Definition: Vector.h:64
int rattle1(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:2381
void addForceToMomentum(FullAtom *__restrict atom_arr, const Force *__restrict force_arr, const BigReal dt, int num_atoms)
Definition: HomePatch.C:1932
void rattle2(const BigReal, Tensor *virial)
Definition: HomePatch.C:2828
static __thread float4 * forces
void recvNodeAwareSpanningTree(ProxyNodeAwareSpanningTreeMsg *msg)
Definition: HomePatch.C:630
float Real
Definition: common.h:109
void gbisComputeAfterP2()
Definition: HomePatch.C:3174
void receiveResults(ProxyResultVarsizeMsg *msg)
Definition: HomePatch.C:796
ExchangeAtomsMsg * exchange_msg
Definition: HomePatch.h:444
virtual void boxClosed(int)
Definition: HomePatch.C:334
int inMigration
Definition: HomePatch.h:492
void doGroupSizeCheck()
Definition: HomePatch.C:3719
void loweAndersenVelocities()
Definition: HomePatch.C:3097
void recvCheckpointReq(int task, const char *key, int replica, int pe)
Definition: HomePatch.C:3485
void exchangeCheckpoint(int scriptTask, int &bpc)
Definition: HomePatch.C:3477
LDObjHandle ldObjHandle
Definition: HomePatch.h:479
void gbisP3Ready()
Definition: HomePatch.C:3238
bool rattleListValid
Definition: HomePatch.h:385
void positionsReady(int doMigration=0)
Definition: HomePatch.C:925
void recvCheckpointAck()
Definition: HomePatch.C:3568
std::vector< RattleList > rattleList
Definition: HomePatch.h:381
Definition: Patch.h:35
void revert(void)
Definition: HomePatch.C:3459
FullAtomList & getAtomList()
Definition: HomePatch.h:455
void qmSwapAtoms()
Definition: HomePatch.C:866
void unregisterProxy(UnregisterProxyMsg *)
Definition: HomePatch.C:416
ResizeArray< FullAtom > atoms
Definition: HomePatch.h:433
std::map< std::string, checkpoint_t * > checkpoints
Definition: HomePatch.h:435
void submitLoadStats(int timestep)
Definition: HomePatch.C:3619
void mollyMollify(Tensor *virial)
Definition: HomePatch.C:3386
int rattle1old(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:2558
~HomePatch()
Definition: HomePatch.C:321
int Bool
Definition: common.h:133
void buildRattleList()
Definition: HomePatch.C:2229
void recvSpanningTree(int *t, int n)
Definition: HomePatch.C:636
void replaceForces(ExtForce *f)
Definition: HomePatch.C:1330
std::vector< int > settleList
Definition: HomePatch.h:380
int PatchID
Definition: NamdTypes.h:182
void gbisComputeAfterP1()
Definition: HomePatch.C:3146
void sendNodeAwareSpanningTree()
Definition: HomePatch.C:631
void setLcpoType()
Definition: HomePatch.C:3120
int exchange_req
Definition: HomePatch.h:443
void doPairlistCheck()
Definition: HomePatch.C:3628
void doAtomMigration()
Definition: HomePatch.C:3840
MigrateAtomsMsg * msgbuf[PatchMap::MaxOneAway]
Definition: HomePatch.h:494
int hardWallDrude(const BigReal, Tensor *virial, SubmitReduction *)
Definition: HomePatch.C:2023
void setGBISIntrinsicRadii()
Definition: HomePatch.C:3131
void saveForce(const int ftag=Results::normal)
Definition: HomePatch.C:1335
std::vector< Vector > posNew
Definition: HomePatch.h:389
int exchange_src
Definition: HomePatch.h:442
void gbisP2Ready()
Definition: HomePatch.C:3218
void sendSpanningTree()
Definition: HomePatch.C:659
void checkpoint(void)
Definition: HomePatch.C:3449
std::vector< RattleParam > rattleParam
Definition: HomePatch.h:382
Definition: Tensor.h:15
void mollyAverage()
Definition: HomePatch.C:3312
void recvExchangeReq(int req)
Definition: HomePatch.C:3594
void buildSpanningTree(void)
Definition: HomePatch.C:674
int checkpoint_task
Definition: HomePatch.h:428
float Mass
Definition: ComputeGBIS.inl:20
std::vector< Vector > velNew
Definition: HomePatch.h:388
void receiveResult(ProxyGBISP1ResultMsg *msg)
Definition: HomePatch.C:3261
void addForceToMomentum3(FullAtom *__restrict atom_arr, const Force *__restrict force_arr1, const Force *__restrict force_arr2, const Force *__restrict force_arr3, const BigReal dt1, const BigReal dt2, const BigReal dt3, int num_atoms)
Definition: HomePatch.C:1961
std::vector< int > noconstList
Definition: HomePatch.h:383
ForceList f[Results::maxNumForces]
Definition: Patch.h:207
void loweAndersenFinish()
Definition: HomePatch.C:3112
void addRattleForce(const BigReal invdt, Tensor &wc)
Definition: HomePatch.C:2371
static __thread int num_atoms
int numMlBuf
Definition: HomePatch.h:493
void useSequencer(Sequencer *sequencerPtr)
Definition: HomePatch.C:265
void doMarginCheck()
Definition: HomePatch.C:3763
void recvCheckpointStore(CheckpointAtomsMsg *msg)
Definition: HomePatch.C:3554
void recvExchangeMsg(ExchangeAtomsMsg *msg)
Definition: HomePatch.C:3605
double BigReal
Definition: common.h:114
void exchangeAtoms(int scriptTask)
Definition: HomePatch.C:3573