OpenAtom  Version1.5a
cpaimd.h
Go to the documentation of this file.
1 //////////////////////////////////////////////////////////////////////////////
2 //////////////////////////////////////////////////////////////////////////////
3 //////////////////////////////////////////////////////////////////////////////
4 /** \file cpaimd.h
5  * Some basic data structures and the array map classes are defined
6  * here. These maps are used to map the array elements to the correct
7  * processors. Please read ../doc/README for a detailed
8  * documentation on the structure of the program.
9  */
10 //////////////////////////////////////////////////////////////////////////////
11 //#define _NAN_CHECK_
12 
13 #include "debug_flags.h"
14 
15 #ifndef _CPAIMD_H
16 #define _CPAIMD_H
17 //#define MAP_DEBUG 1
18 #include "CPcharmParaInfoGrp.h"
19 #include "load_balance/PeList.h"
20 #include "uber/Uber.h"
21 #include "EachToManyMulticastStrategy.h"
22 #include "RingMulticastStrategy.h"
23 #include "StreamingStrategy.h"
24 #include "ckhashtable.h"
25 
26 #undef OLD_COMMLIB
27 #define USE_INT_MAP
28 #ifndef USE_INT_MAP
29 class IntMap2
30 {
31  public:
32  void pup(PUP::er &p)
33  {
34  }
35 };
36 
37 typedef IntMap2 IntMap4;
38 #else
39 #include "load_balance/IntMap.h"
40 #endif
41 
42 #include "load_balance/MapTable.h"
43 
44 //#define BARRIER_CP_GSPACE_PSI 1
45 
46 #define LOAD_BALANCE_STEP 100000000
47 
48 #define PRE_BALANCE_STEP 2
49 
50 #define FIRST_BALANCE_STEP 100000000
51 
52 #if CMK_TRACE_ENABLED
53 #define TRACE_ON_STEP 4
54 #define TRACE_OFF_STEP 5
55 #endif
56 #ifdef CMK_BLUEGENEP
57 #define HPM_ON_STEP 4
58 #define HPM_OFF_STEP 5
59 #endif
60 #ifndef CmiMemcpy
61 #define CmiMemcpy(dest, src, size) CmiMemcpy((dest), (src), (size))
62 #endif
63 
64 extern bool fakeTorus;
65 extern CkVec <int> PIBImaptable;
66 extern CkVec <MapType1> AtomImaptable;
67 extern CkVec <MapType2> GSImaptable;
68 extern CkVec <MapType2> RSImaptable;
69 extern CkVec <MapType2> RPPImaptable;
70 extern CkVec <MapType2> RhoGSImaptable;
71 extern CkVec <MapType2> RhoRSImaptable;
72 extern CkVec <MapType2> RhoGHartImaptable;
73 extern CkVec <MapType3> RhoRHartImaptable;
74 
75 extern CkHashtableT <intdual, int> GSmaptable;
76 extern CkHashtableT <intdual, int> RSmaptable;
77 extern CkHashtableT <intdual, int> RPPmaptable;
78 extern CkHashtableT <intdual, int> RhoGSmaptable;
79 extern CkHashtableT <intdual, int> RhoRSmaptable;
80 extern CkHashtableT <intdual, int> RhoGHartmaptable;
81 extern CkHashtableT <inttriple, int> RhoRHartmaptable;
82 extern CkHashtableT <intdual, int> AsymScalcmaptable;
83 extern CkHashtableT <intdual, int> SymScalcmaptable;
84 CkReductionMsg *sumFastDouble(int nMsg, CkReductionMsg **msgs);
85 void fastAdd (double *a, double *b, int nelem);
86 //////////////////////////////////////////////////////////////////////////////
87 //////////////////////////////////////////////////////////////////////////////
88 //////////////////////////////////////////////////////////////////////////////
89 /** \brief The class which creates the main chare.
90  *
91  *
92  *
93  */
94 //////////////////////////////////////////////////////////////////////////////
95 
96 class main : public Chare {
97  public:
98  main(CkMigrateMessage *m) { }
99  main(CkArgMsg *);
100  ~main();
101 
102 
103 };
104 //////////////////////////////////////////////////////////////////////////////
105 
106 
107 //////////////////////////////////////////////////////////////////////////////
108 //////////////////////////////////////////////////////////////////////////////
109 //////////////////////////////////////////////////////////////////////////////
110 /** \brief Helper class for map hashtables copied from femrefine.C.
111  *
112  */
113 //////////////////////////////////////////////////////////////////////////////
114 
115 
116 
117 
118 //////////////////////////////////////////////////////////////////////////////
119 /** \brief Base Class used for maptable based proc maps
120  *
121  *
122  */
123 class CkArrayMapTable1 : public CkArrayMap
124 {
125 /// trivial 1d here for usage consistency
126  public:
127  MapType1 *maptable;
128  UberCollection thisInstance;
129 
130  CkArrayMapTable1() {}
131  inline int procNum(int, const CkArrayIndex &iIndex){
132  int *index=(int *) iIndex.data();
133  int proc;
134  proc=maptable->get(index[0]);
135  CkAssert(proc>=0);
136  if(numPes!=CkNumPes())
137  return(proc%CkNumPes());
138  else
139  return(proc);
140 
141  }
142  void pup(PUP::er &p)
143  {
144  CkArrayMap::pup(p);
145  p|thisInstance;
146  }
147  ~CkArrayMapTable1(){}
148 
149 };
150 
151 
152 class CkArrayMapTable2 : public CkArrayMap
153 {
154  public:
155  MapType2 *maptable;
156  UberCollection thisInstance;
157 
158  CkArrayMapTable2() {}
159  inline int procNum(int, const CkArrayIndex &iIndex){
160  int *index=(int *) iIndex.data();
161  int proc;
162 
163 #ifdef USE_INT_MAP
164  proc=maptable->get(index[0],index[1]);
165 #else
166  proc=maptable->get(intdual(index[0],index[1]));
167 #endif
168  CkAssert(proc>=0);
169  if(numPes!=CkNumPes())
170  return(proc%CkNumPes());
171  else
172  return(proc);
173 
174  }
175  void pup(PUP::er &p)
176  {
177  CkArrayMap::pup(p);
178  p|thisInstance;
179  }
180  ~CkArrayMapTable2(){}
181 
182 };
183 
184 class CkArrayMapTable3 : public CkArrayMap
185 {
186  public:
187  MapType3 *maptable;
188  UberCollection thisInstance;
189 
190  CkArrayMapTable3() {}
191  inline int procNum(int, const CkArrayIndex &iIndex){
192  int *index=(int *) iIndex.data();
193  int proc;
194 
195 #ifdef USE_INT_MAP
196  proc=maptable->get(index[0],index[1],index[2]);
197 #else
198  proc=maptable->get(inttriple(index[0],index[1],index[2]));
199 #endif
200  CkAssert(proc>=0);
201  if(numPes!=CkNumPes())
202  return(proc%CkNumPes());
203  else
204  return(proc);
205 
206 
207  }
208  void pup(PUP::er &p)
209  {
210  CkArrayMap::pup(p);
211  p|thisInstance;
212  }
213  ~CkArrayMapTable3(){}
214 
215 };
216 
217 class CkArrayMapTable4 : public CkArrayMap
218 {
219  public:
220  MapType4 *maptable;
221  UberCollection thisInstance;
222 
223  CkArrayMapTable4() {}
224  inline int procNum(int, const CkArrayIndex &iIndex){
225  int proc;
226 
227 #ifdef USE_INT_MAP
228  short *sindex=(short *) iIndex.data();
229  proc=maptable->get(sindex[0], sindex[1], sindex[2], sindex[3]);
230 #else
231  int *index=(int *) iIndex.data();
232  proc=maptable->get(intdual(index[0], index[1]));
233 #endif
234  CkAssert(proc>=0);
235  if(numPes!=CkNumPes())
236  return(proc%CkNumPes());
237  else
238  return(proc);
239 
240  }
241  void pup(PUP::er &p)
242  {
243  CkArrayMap::pup(p);
244  p|thisInstance;
245  }
246  ~CkArrayMapTable4(){}
247 
248 };
249 
250 //////////////////////////////////////////////////////////////////////////////
251 //////////////////////////////////////////////////////////////////////////////
252 //////////////////////////////////////////////////////////////////////////////
253 /** \brief Class used for instantiation of G-space group objects.
254  *
255  *
256  */
257 //////////////////////////////////////////////////////////////////////////////
258 
259 
260 class AtomComputeMap : public CkArrayMapTable1 {
261  public:
262  AtomComputeMap(UberCollection _instance)
263  {
264  thisInstance=_instance;
265  maptable= &AtomImaptable[thisInstance.getPO()];
266  }
267 
268  ~AtomComputeMap()
269  {
270  }
271 
272  void pup(PUP::er &p)
273  {
274  CkArrayMap::pup(p);
275  maptable= &AtomImaptable[thisInstance.getPO()];
276  }
277  inline int procNum(int, const CkArrayIndex &iIndex){
278  int *index=(int *) iIndex.data();
279  int proc;
280  proc=maptable->get(index[0]);
281  CkAssert(proc>=0);
282  if(numPes!=CkNumPes())
283  return(proc%CkNumPes());
284  else
285  return(proc);
286  }
287 
288 };
289 
290 class GSMap: public CkArrayMapTable2 {
291 
292  public:
293  GSMap(UberCollection _instance)
294  {
295  thisInstance=_instance;
296 #ifdef USE_INT_MAP
297  maptable = &GSImaptable[thisInstance.getPO()];
298  if(CkMyPe()) {
299  if(maptable == NULL)
300  CkAbort("hey 2");
301  }
302 #else
303  maptable = &GSmaptable;
304 #endif
305  }
306  void pup(PUP::er &p)
307  {
308  CkArrayMapTable2::pup(p);
309 #ifdef USE_INT_MAP
310  maptable= &GSImaptable[thisInstance.getPO()];
311 #else
312  maptable= &GSmaptable;
313 #endif
314  }
315  inline int procNum(int, const CkArrayIndex &iIndex){
316  int *index=(int *) iIndex.data();
317  int proc;
318 #ifdef USE_INT_MAP
319  if(maptable == NULL) {
320  CkPrintf("hey %d\n", CkMyPe());
321  CkAbort("hey");
322  }
323  proc=maptable->get(index[0],index[1]);
324 #else
325  proc=maptable->get(intdual(index[0],index[1]));
326 #endif
327  CkAssert(proc>=0);
328  if(numPes!=CkNumPes())
329  return(proc%CkNumPes());
330  else
331  return(proc);
332  }
333 
334  // int procNum(int, const CkArrayIndex &);
335  ~GSMap(){
336  }
337 };
338 //////////////////////////////////////////////////////////////////////////////
339 
340 //////////////////////////////////////////////////////////////////////////////
341 //////////////////////////////////////////////////////////////////////////////
342 //////////////////////////////////////////////////////////////////////////////
343 /** \brief Class used for instantiation of real-space group objects.
344  *
345  *
346  */
347 //////////////////////////////////////////////////////////////////////////////
348 
349 class RSMap: public CkArrayMapTable2 {
350 
351  public:
352  RSMap(UberCollection _instance)
353  {
354  thisInstance=_instance;
355 #ifdef USE_INT_MAP
356  maptable= &RSImaptable[thisInstance.getPO()];
357 #else
358  maptable= &RSmaptable;
359 #endif
360  }
361  void pup(PUP::er &p)
362  {
363  CkArrayMapTable2::pup(p);
364 #ifdef USE_INT_MAP
365  maptable= &RSImaptable[thisInstance.getPO()];
366 #else
367  maptable= &RSmaptable;
368 #endif
369  }
370  // int procNum(int, const CkArrayIndex &);
371  inline int procNum(int, const CkArrayIndex &iIndex){
372  int *index=(int *) iIndex.data();
373  int proc;
374 
375 #ifdef USE_INT_MAP
376  proc=maptable->get(index[0],index[1]);
377 #else
378  proc=maptable->get(intdual(index[0],index[1]));
379 #endif
380  CkAssert(proc>=0);
381  if(numPes!=CkNumPes())
382  return(proc%CkNumPes());
383  else
384  return(proc);
385 
386  }
387 
388  ~RSMap(){
389  }
390 };
391 //////////////////////////////////////////////////////////////////////////////
392 
393 class RPPMap: public CkArrayMapTable2 {
394 
395  public:
396  RPPMap(UberCollection _instance)
397  {
398  thisInstance=_instance;
399 #ifdef USE_INT_MAP
400  maptable= &RPPImaptable[thisInstance.getPO()];
401 #else
402  maptable= &RPPmaptable;
403 #endif
404  }
405  void pup(PUP::er &p)
406  {
407  CkArrayMapTable2::pup(p);
408 #ifdef USE_INT_MAP
409  maptable= &RPPImaptable[thisInstance.getPO()];
410 #else
411  maptable= &RPPmaptable;
412 #endif
413 
414  }
415  // int procNum(int, const CkArrayIndex &);
416  ~RPPMap(){
417 
418  }
419  inline int procNum(int, const CkArrayIndex &iIndex){
420  int *index=(int *) iIndex.data();
421  int proc;
422 
423 #ifdef USE_INT_MAP
424  proc=maptable->get(index[0],index[1]);
425 #else
426  proc=maptable->get(intdual(index[0],index[1]));
427 #endif
428  CkAssert(proc>=0);
429  if(numPes!=CkNumPes())
430  return(proc%CkNumPes());
431  else
432  return(proc);
433 
434 
435  }
436 
437 };
438 //////////////////////////////////////////////////////////////////////////////
439 
440 
441 //////////////////////////////////////////////////////////////////////////////
442 /**
443  * provide procnum mapping for RhoR
444  */
445 class RhoRSMap : public CkArrayMapTable2 {
446  public:
447  int nchareRhoR;
448  RhoRSMap(UberCollection _instance)
449  {
450  thisInstance=_instance;
451 #ifdef USE_INT_MAP
452  maptable= &RhoRSImaptable[thisInstance.getPO()];
453 #else
454  maptable= &RhoRSmaptable;
455 #endif
456  }
457 
458  ~RhoRSMap() {
459  }
460 
461  void pup(PUP::er &p)
462  {
463  CkArrayMapTable2::pup(p);
464 #ifdef USE_INT_MAP
465  maptable= &RhoRSImaptable[thisInstance.getPO()];
466 #else
467  maptable= &RhoRSmaptable;
468 #endif
469  }
470 
471  // int procNum(int arrayHdl, const CkArrayIndex &idx);
472  inline int procNum(int, const CkArrayIndex &iIndex){
473  int *index=(int *) iIndex.data();
474  int proc;
475 
476 #ifdef USE_INT_MAP
477  proc=maptable->get(index[0],index[1]);
478 #else
479  proc=maptable->get(intdual(index[0],index[1]));
480 #endif
481  CkAssert(proc>=0);
482  if(numPes!=CkNumPes())
483  return(proc%CkNumPes());
484  else
485  return(proc);
486  }
487 
488 };
489 
490 
491 /**
492  * provide procnum mapping for RhoG
493  */
494 class RhoGSMap : public CkArrayMapTable2 {
495  public:
496  RhoGSMap(UberCollection _instance)
497  {
498  thisInstance=_instance;
499 #ifdef USE_INT_MAP
500  maptable= &RhoGSImaptable[thisInstance.getPO()];
501 #else
502  maptable= &RhoGSmaptable;
503 #endif
504  }
505 
506  ~RhoGSMap() {
507  }
508 
509  // int procNum(int arrayHdl, const CkArrayIndex &idx);
510  inline int procNum(int, const CkArrayIndex &iIndex){
511  int *index=(int *) iIndex.data();
512  int proc;
513 
514 #ifdef USE_INT_MAP
515  proc=maptable->get(index[0],index[1]);
516 #else
517  proc=maptable->get(intdual(index[0],index[1]));
518 #endif
519  CkAssert(proc>=0);
520  if(numPes!=CkNumPes())
521  return(proc%CkNumPes());
522  else
523  return(proc);
524 
525  }
526 
527  void pup(PUP::er &p)
528  {
529  CkArrayMapTable2::pup(p);
530  }
531 };
532 
533 
534 class RhoGHartMap : public CkArrayMapTable2 {
535  public:
536  RhoGHartMap(UberCollection _instance)
537  {
538  thisInstance=_instance;
539 #ifdef USE_INT_MAP
540  maptable= &RhoGHartImaptable[thisInstance.getPO()];
541 #else
542  maptable= &RhoGHartmaptable;
543 #endif
544  }
545 
546  ~RhoGHartMap()
547  {
548  }
549 
550  // int procNum(int arrayHdl, const CkArrayIndex &idx);
551 
552  void pup(PUP::er &p)
553  {
554  CkArrayMapTable2::pup(p);
555 #ifdef USE_INT_MAP
556  maptable= &RhoGHartImaptable[thisInstance.getPO()];
557 #else
558  maptable= &RhoGHartmaptable;
559 #endif
560  }
561  inline int procNum(int, const CkArrayIndex &iIndex){
562  int *index=(int *) iIndex.data();
563  int proc;
564 #ifdef USE_INT_MAP
565  proc=maptable->get(index[0],index[1]);
566 #else
567  proc=maptable->get(intdual(index[0],index[1]));
568 #endif
569  CkAssert(proc>=0);
570  if(numPes!=CkNumPes())
571  return(proc%CkNumPes());
572  else
573  return(proc);
574 
575  }
576 
577 
578 };
579 
580 class RhoRHartMap : public CkArrayMapTable3 {
581  public:
582  RhoRHartMap(UberCollection _instance)
583  {
584  thisInstance=_instance;
585 #ifdef USE_INT_MAP
586  maptable= &RhoRHartImaptable[thisInstance.getPO()];
587 #else
588  maptable= &RhoRHartmaptable;
589 #endif
590  }
591 
592  ~RhoRHartMap()
593  {
594  }
595 
596  // int procNum(int arrayHdl, const CkArrayIndex &idx);
597 
598  void pup(PUP::er &p)
599  {
600  CkArrayMapTable3::pup(p);
601 #ifdef USE_INT_MAP
602  maptable= &RhoRHartImaptable[thisInstance.getPO()];
603 #else
604  maptable= &RhoRHartmaptable;
605 #endif
606  }
607  inline int procNum(int, const CkArrayIndex &iIndex){
608  int *index=(int *) iIndex.data();
609  int proc;
610 
611 #ifdef USE_INT_MAP
612  proc=maptable->get(index[0],index[1],index[2]);
613 #else
614  proc=maptable->get(inttriple(index[0],index[1],index[2]));
615 #endif
616  CkAssert(proc>=0);
617  if(numPes!=CkNumPes())
618  return(proc%CkNumPes());
619  else
620  return(proc);
621  }
622 
623 };
624 
625 
626 //////////////////////////////////////////////////////////////////////////////
627 //////////////////////////////////////////////////////////////////////////////
628 //////////////////////////////////////////////////////////////////////////////
629 
630 
631 /******** Optimization flags ********/
632  //#define _CP_USE_BLAS_GATHER_
633 
634 /******** User Trace Events *********/
635 #define DoFFTContribute_ 1100
636 #define doRealFwFFT_ 1110
637 #define doRealBwFFT_ 1120
638 #define GspaceFwFFT_ 1130
639 #define GspaceBwFFT_ 1140
640 #define RhoRtoGFFT_ 1150
641 
642 #define PostByrdfwFFTGtoR_ 1152
643 #define BwFFTRtoG_ 1153
644 #define ByrdanddoFwFFTGtoR_ 1154
645 #define HartExcVksG_ 1160
646 #define divRhoVksGspace_ 1161
647 #define AcceptStructFact_ 1162
648 #define eesHartExcG_ 1163
649 #define eesEwaldG_ 1164
650 #define eesAtmForcR_ 1165
651 #define eesAtmBspline_ 1166
652 #define eesZmatR_ 1167
653 #define eesEnergyAtmForcR_ 1168
654 #define eesProjG_ 1169
655 #define fwFFTGtoR0_ 1170
656 #define fwFFTGtoRnot0_ 1171
657 #define doNlFFTGtoR_ 1172
658 #define doNlFFTRtoG_ 1173
659 #define eesPsiForcGspace_ 1174
660 #define GradCorrGGA_ 1180
661 #define WhiteByrdFFTX_ 1181
662 #define WhiteByrdFFTY_ 1182
663 #define WhiteByrdFFTZ_ 1183
664 #define enlMatrixCalc_ 1300
665 #define enlAtmForcCalc_ 1301
666 #define enlForcCalc_ 1302
667 #define doEextFFTRtoG_ 1303
668 #define doEextFFTGtoR_ 1304
669 #define doEextFFTGxtoRx_ 1305
670 #define doEextFFTRytoGy_ 1306
671 #define doRhoFFTRytoGy_ 1307
672 #define doRhoFFTGxtoRx_ 1308
673 #define OrthoDGEMM1_ 1401
674 #define OrthoDGEMM2_ 1402
675 ///200-300 reserved for paircalculator
676 #define IntegrateModForces_ 1000
677 #define Scalcmap_ 2000
678 #define GHartAtmForcCopy_ 3000
679 #define GHartAtmForcSend_ 4000
680 //////////////////////////////////////////////////////////////////////////////
681 
682 
683 //////////////////////////////////////////////////////////////////////////////
684 //////////////////////////////////////////////////////////////////////////////
685 //////////////////////////////////////////////////////////////////////////////
686 /*
687  * Initialization routines to initialize the GSpace, Real Space,
688  * Particle space planes, CP_Rho_GSpacePlane & CP_Rho_RealSpacePlane arrays
689  and the S_Calculators
690  */
691 //////////////////////////////////////////////////////////////////////////////
692 class size2d; //forward decl to shup the compiler
693 namespace cp { namespace paircalc { class pcConfig; } }
694 namespace pc = cp::paircalc;
695 
696 void init_commlib_strategies(int, int,int, UberCollection thisInstance);
697 void lst_sort_clean(int , int *, int *);
698 void init_PIBeads(CPcharmParaInfo *sim, UberCollection thisInstance);
699 
700 void init_state_chares(int natm_nl,int natm_nl_grp_max,int numSfGrps,
701  int doublePack, CPcharmParaInfo *sim, UberCollection thisInstance);
702 
703 void init_eesNL_chares(int natm_nl,int natm_nl_grp_max,
704  int doublePack, PeList *exclusion, CPcharmParaInfo *sim, UberCollection thisInstance);
705 int init_rho_chares(CPcharmParaInfo*, UberCollection thisInstance);
706 void control_physics_to_driver(UberCollection thisInstance);
707 void get_grp_params(int natm_nl, int numSfGrps, int indexSfGrp, int planeIndex,
708  int *n_ret, int *istrt_ret, int *iend_ret);
709 int atmGrpMap(int istart, int nsend, int listsize, int *listpe, int AtmGrp,
710  int dup, int planeIndex);
711 int gsprocNum(CPcharmParaInfo *sim,int state, int plane, int numInst);
712 bool findCuboid(int &x, int &y, int &z, int &order, int maxX, int maxY, int maxZ, int maxT, int volume, int vn);
713 void create_Rho_fft_numbers(int ,int ,int , int, int, int, int *,int *,int *,int *, int *);
714 void setTraceUserEvents();
715 void computeMapOffsets();
716 //////////////////////////////////////////////////////////////////////////////
717 
718 
719 //////////////////////////////////////////////////////////////////////////////
720 
721 /// stuff to be include before the decl or else
722 #include "Atoms.h"
723 #include "energy.h"
724 #include "paircalc/ckPairCalculator.h"
725 #include "cpaimd.decl.h"
726 void paircalcstartup(pc::pcConfig *cfgSymmPC, pc::pcConfig *cfgAsymmPC, CPcharmParaInfo *sim, int doublePack);
727 void orthostartup( cp::ortho::orthoConfig *orthoCfg, pc::pcConfig *cfgSymmPC, pc::pcConfig *cfgAsymmPC, CPcharmParaInfo *sim, PeListFactory *peList4PCmapping);
728 
729 #endif
730 
CkArrayMapTable1
Helper class for map hashtables copied from femrefine.C.
Definition: cpaimd.h:123
main::~main
~main()
Cleanup stuff in the hopes of getting clean valgrind.
Definition: cpaimd.C:746
UberCollection
holds the UberIndex and the offset for proxies
Definition: Uber.h:68
control_physics_to_driver
void control_physics_to_driver(UberCollection thisInstance)
Get the atoms and the parainfo //////////////////////////////////////////////////////////////////////...
Definition: cpaimd.C:2373
size2d
== Size or location in a regular 2D array
Definition: util.h:59
PeList
Definition: PeList.h:33
init_commlib_strategies
void init_commlib_strategies(int, int, int, UberCollection thisInstance)
Initialize Commlib communication strategies.
Definition: cpaimd.C:762
sumFastDouble
CkReductionMsg * sumFastDouble(int nMsg, CkReductionMsg **msgs)
sum together matrices of doubles possibly faster than sum_double due to minimizing copies and using s...
Definition: cpaimd.C:2924
init_PIBeads
void init_PIBeads(CPcharmParaInfo *sim, UberCollection thisInstance)
Create the PIBeadAtoms array.
Definition: cpaimd.C:1203
cp::ortho::orthoConfig
Configuration settings for the ortho world.
Definition: orthoConfig.h:17
RhoRSMap::procNum
int procNum(int, const CkArrayIndex &iIndex)
New functions beind added for the topology mapping of the density objects - RhoR, RhoG...
Definition: cpaimd.h:472
init_state_chares
void init_state_chares(int natm_nl, int natm_nl_grp_max, int numSfGrps, int doublePack, CPcharmParaInfo *sim, UberCollection thisInstance)
Create the array elements for the GSpace, Particle and Real Space planes ////////////////////////////...
Definition: cpaimd.C:1235
create_Rho_fft_numbers
void create_Rho_fft_numbers(int, int, int, int, int, int, int *, int *, int *, int *, int *)
Definition: cpaimd.C:2948
IntMap.h
Author: Eric J Bohm Date Created: June 4th, 2006.
GSMap::procNum
int procNum(int, const CkArrayIndex &iIndex)
int GSMap::slowprocNum(int arrayHdl, const CkArrayIndex2D &idx2d)
Definition: cpaimd.h:315
PeListFactory
Hacky solution to passing a PeList to GSpace(0,0) for use in paircalc mapping without actually having...
Definition: PeList.h:423
fakeTorus
bool fakeTorus
readonly defined in cpaimd.C
Definition: cpaimd.C:172
setTraceUserEvents
void setTraceUserEvents()
Definition: cpaimd.C:3028
IntMap4
Definition: IntMap.h:26
RSMap
Class used for instantiation of real-space group objects.
Definition: cpaimd.h:349
RPPMap
Definition: cpaimd.h:393
RSMap::procNum
int procNum(int, const CkArrayIndex &iIndex)
Function for RealSpace objects.
Definition: cpaimd.h:371
init_eesNL_chares
void init_eesNL_chares(int natm_nl, int natm_nl_grp_max, int doublePack, PeList *exclusion, CPcharmParaInfo *sim, UberCollection thisInstance)
/addtogroup Particle
Definition: cpaimd.C:1753
cp::paircalc::pcConfig
Dumb structure that holds all the configuration inputs required for paircalc instantiation, functioning and interaction.
Definition: pcConfig.h:23
main
The class which creates the main chare.
Definition: cpaimd.h:96
findCuboid
bool findCuboid(int &x, int &y, int &z, int &order, int maxX, int maxY, int maxZ, int maxT, int volume, int vn)
return the cuboid x,y,z of a subpartition exactly matching that volume
Definition: cpaimd.C:2583
GSMap
Definition: cpaimd.h:290
AtomComputeMap
Class used for instantiation of G-space group objects.
Definition: cpaimd.h:260
debug_flags.h
Useful debugging flags.
paircalcstartup
void paircalcstartup(pc::pcConfig *cfgSymmPC, pc::pcConfig *cfgAsymmPC, CPcharmParaInfo *sim, int doublePack)
stuff to be include before the decl or else
Definition: cpaimd.C:3137
MapTable.h
Author: Eric J Bohm Date Created: June 4th, 2006.
RhoRSMap
provide procnum mapping for RhoR
Definition: cpaimd.h:445
RhoGSMap
provide procnum mapping for RhoG
Definition: cpaimd.h:494
CkArrayMapTable1::maptable
MapType1 * maptable
trivial 1d here for usage consistency
Definition: cpaimd.h:127
init_rho_chares
int init_rho_chares(CPcharmParaInfo *, UberCollection thisInstance)
Creating arrays CP_Rho_GSpacePlane, CP_Rho_GSpacePlaneHelper and CP_Rho_RealSpacePlane.
Definition: cpaimd.C:1902
PeList.h
Author: Eric J Bohm Date Created: May 31, 2006.
PIBImaptable
CkVec< int > PIBImaptable
INT_MAPs are the ones actually used so these are being changed to CkVec's for beads.
Definition: cpaimd.ci:223