OpenAtom  Version1.5a
eesCache.C
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////=
2 ///////////////////////////////////////////////////////////////////////////////c
3 ///////////////////////////////////////////////////////////////////////////////=
4 /** \file eesCache.C
5  *
6  *
7  */
8 ///////////////////////////////////////////////////////////////////////////////=
9 ///////////////////////////////////////////////////////////////////////////////c
10 ///////////////////////////////////////////////////////////////////////////////=
11 
12 
13 ///////////////////////////////////////////////////////////////////////////////=
14 #include "charm++.h"
15 #include "utility/util.h"
16 #include "cpaimd.h"
17 #include "eesCache.h"
18 #include "AtomsCache.h"
19 #include "src_piny_physics_v1.0/include/class_defs/Interface_ctrl.h"
20 #include "PhysScratchCache.h"
21 #include <cmath>
22 #include "fft_slab_ctrl/fftCacheSlab.h"
23 #include "cp_state_ctrl/CP_State_Plane.h"
24 #include "src_piny_physics_v1.0/include/class_defs/CP_OPERATIONS/class_cpnonlocal.h"
25 #include "src_piny_physics_v1.0/include/class_defs/CP_OPERATIONS/class_cplocal.h"
26 #include "src_piny_physics_v1.0/include/class_defs/CP_OPERATIONS/class_cpintegrate.h"
27 
28 
29 //----------------------------------------------------------------------------
30 extern Config config;
31 extern CkVec <CProxy_CP_State_ParticlePlane> UparticlePlaneProxy;
32 extern CkVec <CProxy_CP_State_RealParticlePlane> UrealParticlePlaneProxy;
33 extern CkVec <CProxy_CP_Rho_RHartExt> UrhoRHartExtProxy;
34 extern CkVec <CProxy_CP_Rho_GHartExt> UrhoGHartExtProxy;
35 extern CProxy_PhysScratchCache pScratchProxy;
36 extern CkVec <CProxy_AtomsCache> UatomsCacheProxy;
37 extern CkVec <CProxy_eesCache> UeesCacheProxy;
38 
39 #define _EESCACHE_VERBOSE_OFF_
40 
41 ///////////////////////////////////////////////////////////////////////////////=
42 
43 
44 
45 ///////////////////////////////////////////////////////////////////////////////=
46 /// Group constructor
47 ///////////////////////////////////////////////////////////////////////////////=
48 ///////////////////////////////////////////////////////////////////////////////c
49 ///////////////////////////////////////////////////////////////////////////////=
50 eesCache::eesCache(int _nchareRPP, int _nchareGPP, int _nchareRHart,
51  int _nchareGHart, int _nstates, int _nchareRhoG, int _nkpoint,
52  UberCollection _thisInstance): thisInstance(_thisInstance)
53 ///////////////////////////////////////////////////////////////////////////////=
54  {//begin rotuine
55 ///////////////////////////////////////////////////////////////////////////////=
56 
57  itimeRPP = 0;
58  itimeRHart = 0;
59  rpp_on = 0;
60  nMallSize = 100;
61 
62  nkpoint = _nkpoint;
63  nchareRPP = _nchareRPP;
64  nchareGPP = _nchareGPP;
65  nchareRHart = _nchareRHart;
66  nchareGHart = _nchareGHart;
67  nchareGSP = _nchareGPP;
68  nchareRhoG = _nchareRhoG;
69  nstates = _nstates;
70 
71  nchareGSPProcT = 0;
72  nchareGSPProc = 0;
73  nchareRPPProc = 0;
74  nchareGPPProc = 0;
75  nchareRHartProc = 0;
76  nchareGHartProc = 0;
77 
78  gspStateInd = new int [nMallSize];
79  gspPlaneInd = new int [nMallSize];
80 
81  allowedRppChares = new int[nchareRPP];
82  allowedGppChares = new int[nchareGPP];
83  allowedRhoRHartChares = new int[nchareRHart];
84  allowedRhoGHartChares = new int[nchareGHart];
85  allowedGspChares = new int[nchareGSP];
86  allowedRhoGChares = new int[nchareRhoG];
87 
88  for(int i=0;i<nchareRPP ;i++){allowedRppChares[i] = 0;}
89  for(int i=0;i<nchareGPP ;i++){allowedGppChares[i] = 0;}
90  for(int i=0;i<nchareRHart;i++){allowedRhoRHartChares[i] = 0;}
91  for(int i=0;i<nchareGHart;i++){allowedRhoGHartChares[i] = 0;}
92  for(int i=0;i<nchareGSP; i++){allowedGspChares[i] = 0;}
93  for(int i=0;i<nchareRhoG ;i++){allowedRhoGChares[i] = 0;}
94 
95  indGppChares = new int[nchareGPP]; // over dimensioned
96  indRppChares = new int[nchareRPP];
97  indRhoRHartChares = new int[nchareRHart];
98  indRhoGHartChares = new int[nchareGHart];
99  indGspChares = new int[nchareGSP];
100  indRhoGChares = new int[nchareRhoG];
101 
102  GppData = new GPPDATA * [nchareGPP]; // over dimensioned
103  RppData = new RPPDATA * [nchareRPP];
104  RhoGHartData = new RHOGHARTDATA*[nchareGHart];
105  RhoRHartData = new RHORHARTDATA*[nchareRHart];
106  GspData = new GSPDATA*[nchareGSP];
107  //RhoGData = new RHOGDATA[nchareRhoG];
108 
109 }// end constructor
110 ///////////////////////////////////////////////////////////////////////////////=
111 
112 
113 ///////////////////////////////////////////////////////////////////////////////=
114 /// realParticlePlane Cache Management tool
115 ///////////////////////////////////////////////////////////////////////////////=
116 ///////////////////////////////////////////////////////////////////////////////c
117 ///////////////////////////////////////////////////////////////////////////////=
118 void eesCache::registerCacheRPP (int index){
119 ///////////////////////////////////////////////////////////////////////////////=
120 /// Cache warm up
121 
122  if(allowedRppChares[index]==0){
123  nchareRPPProc += 1;
124  allowedRppChares[index] = 1;
125  RppData[index] = new RPPDATA();
126  RppData[index]->init(index);
127  }//endif
128 
129 }//end routine
130 ///////////////////////////////////////////////////////////////////////////////=
131 
132 
133 ///////////////////////////////////////////////////////////////////////////////=
134 /// GParticlePlane Cache Management tool
135 ///////////////////////////////////////////////////////////////////////////////=
136 ///////////////////////////////////////////////////////////////////////////////c
137 ///////////////////////////////////////////////////////////////////////////////=
138 void eesCache::registerCacheGPP (int index, int ncoef, int *ka, int *kb, int *kc){
139 ///////////////////////////////////////////////////////////////////////////////=
140 /// Cache warm up
141 
142  if(allowedGppChares[index]==0){
143  nchareGPPProc += 1;
144  allowedGppChares[index] = 1;
145  GppData[index] = new GPPDATA();
146  GppData[index]->init(nkpoint,index,ncoef,ka,kb,kc);
147  }//endif
148 
149 }//end routine
150 ///////////////////////////////////////////////////////////////////////////////=
151 
152 
153 ///////////////////////////////////////////////////////////////////////////////=
154 /// RhoRhart Cache Management tool
155 ///////////////////////////////////////////////////////////////////////////////=
156 ///////////////////////////////////////////////////////////////////////////////c
157 ///////////////////////////////////////////////////////////////////////////////=
158 void eesCache::registerCacheRHart(int index){
159 ///////////////////////////////////////////////////////////////////////////////=
160 /// Cache warm up
161 
162  if(allowedRhoRHartChares[index]==0){
163 #ifdef _EESCACHE_VERBOSE_
164  CkPrintf("Registering Rhart %d\n",index);
165 #endif
166  nchareRHartProc += 1;
167  allowedRhoRHartChares[index] = 1;
168  RhoRHartData[index] = new RHORHARTDATA();
169  RhoRHartData[index]->init(index);
170  }//endif
171 
172 }//end routine
173 ///////////////////////////////////////////////////////////////////////////////=
174 
175 
176 ///////////////////////////////////////////////////////////////////////////////=
177 /// RhoGhart Cache Management tool
178 ///////////////////////////////////////////////////////////////////////////////=
179 ///////////////////////////////////////////////////////////////////////////////c
180 ///////////////////////////////////////////////////////////////////////////////=
181 void eesCache::registerCacheGHart(int index, int ncoef, int *ka, int *kb, int *kc){
182 ///////////////////////////////////////////////////////////////////////////////=
183 /// Cache warm up
184 
185  if(allowedRhoGHartChares[index]==0){
186  nchareGHartProc += 1;
187  allowedRhoGHartChares[index] = 1;
188  RhoGHartData[index] = new RHOGHARTDATA();
189  RhoGHartData[index]->init(index,ncoef,ka,kb,kc);
190  }//endif
191 
192 }//end routine
193 ///////////////////////////////////////////////////////////////////////////////=
194 
195 
196 ///////////////////////////////////////////////////////////////////////////////=
197 ///////////////////////////////////////////////////////////////////////////////c
198 ///////////////////////////////////////////////////////////////////////////////=
199 void eesCache::registerCacheGSP(int is ,int ip){
200 
201  if(allowedGspChares[ip]==0){
202  nchareGSPProc += 1;
203  allowedGspChares[ip] = 1;
204  GspData[ip] = new GSPDATA();
205  GspData[ip]->init(ip,nkpoint);
206  }//endif
207 
208  int i = nchareGSPProcT;
209  if(nMallSize<=i ){
210  CkPrintf("Bad Mall size in registerCacheGSP %d %d\n",nMallSize,i);
211  CkExit();
212  }//endif
213 
214  gspStateInd[i] = is;
215  gspPlaneInd[i] = ip;
216  nchareGSPProcT += 1;
217 
218  if(2*nchareGSPProcT >= nMallSize){
219  nMallSize *= 2;
220  int *tempS = new int [nMallSize];
221  int *tempP = new int [nMallSize];
222  for(int j=0;j<nchareGSPProcT;j++){
223  tempS[j] = gspStateInd[j];
224  tempP[j] = gspPlaneInd[j];
225  }//endfor
226  delete [] gspStateInd;
227  delete [] gspPlaneInd;
228  gspStateInd = tempS;
229  gspPlaneInd = tempP;
230  }//endif
231 }
232 ///////////////////////////////////////////////////////////////////////////////=
233 
234 
235 
236 ///////////////////////////////////////////////////////////////////////////////=
237 /// Initialize the RealParticlePlane Cache Data class
238 ///////////////////////////////////////////////////////////////////////////////=
239 ///////////////////////////////////////////////////////////////////////////////c
240 ///////////////////////////////////////////////////////////////////////////////=
241 void RPPDATA::init(int index_in){
242 #define _CP_BRK_BETTER_OFF // must flip cp_ees_nonlocal.h too
243 
244  CPNONLOCAL::getEesPrms(&ngrid_a,&ngrid_b,&ngrid_c,&n_interp,&natm);
245 
246  index = index_in;
247  int n_interp2 = n_interp*n_interp;
248 
249  plane_index = (int *)fftw_malloc(natm*sizeof(int));
250  nBreakJ = (int *)fftw_malloc(natm*sizeof(int));
251 
252  igrid = (int **)fftw_malloc(natm*sizeof(int*));
253 #ifdef _CP_BRK_BETTER_
254  sBreakJ = (int **)fftw_malloc(natm*sizeof(int*));
255 #endif
256  mn = (double **)fftw_malloc(natm*sizeof(double*));
257  dmn_x = (double **)fftw_malloc(natm*sizeof(double*));
258  dmn_y = (double **)fftw_malloc(natm*sizeof(double*));
259  dmn_z = (double **)fftw_malloc(natm*sizeof(double*));
260  for(int i=0;i<natm;i++){
261  igrid[i] = (int *)fftw_malloc(n_interp2*sizeof(int))-1;
262 #ifdef _CP_BRK_BETTER_
263  sBreakJ[i] = (int *)fftw_malloc((n_interp2+1)*sizeof(int))-1;
264 #endif
265  double *tmp = (double *)fftw_malloc(4*n_interp2*sizeof(double));
266  int ioff = 0;
267  mn[i] = &tmp[ioff]-1; ioff+=n_interp2;
268  dmn_x[i] = &tmp[ioff]-1; ioff+=n_interp2;
269  dmn_y[i] = &tmp[ioff]-1; ioff+=n_interp2;
270  dmn_z[i] = &tmp[ioff]-1;
271  }//endfor
272 
273 }//end routine
274 ///////////////////////////////////////////////////////////////////////////////=
275 
276 
277 ///////////////////////////////////////////////////////////////////////////////=
278 /// Initialize the GParticlePlane Cache Data class
279 ///////////////////////////////////////////////////////////////////////////////=
280 ///////////////////////////////////////////////////////////////////////////////c
281 ///////////////////////////////////////////////////////////////////////////////=
282 void GPPDATA::init(int nkpoint_in,int index_in,int ncoef_in, int *ka, int *kb, int *kc){
283 
284  nkpoint = nkpoint_in;
285  index = index_in;
286  ncoef = ncoef_in;
287  b_re = (double *)fftw_malloc((ncoef+1)*sizeof(double));
288  b_im = (double *)fftw_malloc((ncoef+1)*sizeof(double));
289 
290  h_gspl = cmall_mat(0,nkpoint,0,ncoef,"CPPDATA:init");
291  ind_gspl = cmall_int_mat(0,nkpoint,0,ncoef,"CPPDATA:init");
292 
293  CPNONLOCAL::getEesPrms(&ngrid_a,&ngrid_b,&ngrid_c,&n_interp,&natm);
294  CPNONLOCAL::eesSetEesWghtGgrp(ncoef,ka,kb,kc,b_re,b_im,ngrid_a,ngrid_b,ngrid_c,
295  n_interp);
296  CPNONLOCAL::eesSplProjectorGgrp(ncoef,ka,kb,kc,h_gspl,ind_gspl);
297 
298 }
299 ///////////////////////////////////////////////////////////////////////////////=
300 
301 
302 ///////////////////////////////////////////////////////////////////////////////=
303 /// Initialize the RhoRhart Cache Data class
304 ///////////////////////////////////////////////////////////////////////////////=
305 ///////////////////////////////////////////////////////////////////////////////c
306 ///////////////////////////////////////////////////////////////////////////////=
307 void RHORHARTDATA::init(int index_in){
308 ///////////////////////////////////////////////////////////////////////////////=
309 /// General intialization : Set parameters
310 
311  index = index_in;
312  rhoRsubplanes = config.rhoRsubplanes;
313 
314  CPLOCAL::getEesPrms(&ngrid_a,&ngrid_b,&ngrid_c,&n_interp,&natm);
315 
316 //////////////////////////////////////////////////////
317 /// The subplane decomposition vectors
318 
319  subStr = (int *)fftw_malloc(rhoRsubplanes*sizeof(int));
320  subEnd = (int *)fftw_malloc(rhoRsubplanes*sizeof(int));
321  subSiz = (int *)fftw_malloc(rhoRsubplanes*sizeof(int));
322  ntemp = (int *)fftw_malloc(rhoRsubplanes*sizeof(int));
323  itemp = (int **)fftw_malloc(rhoRsubplanes*sizeof(int*));
324  for(int s=0;s<rhoRsubplanes;s++){itemp[s] = (int *)fftw_malloc(n_interp*sizeof(int))-1;}
325 
326  for(int s=0; s<rhoRsubplanes; s++){
327  int div = (ngrid_b / rhoRsubplanes); // parallelize y
328  int rem = (ngrid_b % rhoRsubplanes);
329  int add = (s < rem ? 1 : 0);
330  int max = (s < rem ? s : rem);
331  subStr[s] = div*s + max; // start of y desired by chare s
332  subSiz[s] = div + add; // total of y desired by chare s
333  subEnd[s] = subStr[s] + subSiz[s]; // end of y desired by chare s
334  }//endfor
335 
336 //////////////////////////////////////////////////////
337 /// Mallocs
338 
339  plane_index = (int *)fftw_malloc(natm*sizeof(int));
340 
341  nSub = (int **)fftw_malloc(rhoRsubplanes*sizeof(int *));
342  igrid = (int ***)fftw_malloc(rhoRsubplanes*sizeof(int **));
343  mn = (double ***)fftw_malloc(rhoRsubplanes*sizeof(double**));
344  dmn_x = (double ***)fftw_malloc(rhoRsubplanes*sizeof(double**));
345  dmn_y = (double ***)fftw_malloc(rhoRsubplanes*sizeof(double**));
346  dmn_z = (double ***)fftw_malloc(rhoRsubplanes*sizeof(double**));
347 
348  int n_interp21 = n_interp*n_interp+1;
349  for(int s=0;s<rhoRsubplanes;s++){
350  nSub[s] = (int *)fftw_malloc (natm*sizeof(int *));
351  igrid[s] = (int **)fftw_malloc(natm*sizeof(int *));
352  mn[s] = (double **)fftw_malloc(natm*sizeof(double*));
353  dmn_x[s] = (double **)fftw_malloc(natm*sizeof(double*));
354  dmn_y[s] = (double **)fftw_malloc(natm*sizeof(double*));
355  dmn_z[s] = (double **)fftw_malloc(natm*sizeof(double*));
356  for(int i=0;i<natm;i++){
357  igrid[s][i] = (int *)fftw_malloc(n_interp21*sizeof(int ))-1;
358  mn[s][i] = (double *)fftw_malloc(n_interp21*sizeof(double))-1;
359  dmn_x[s][i] = (double *)fftw_malloc(n_interp21*sizeof(double))-1;
360  dmn_y[s][i] = (double *)fftw_malloc(n_interp21*sizeof(double))-1;
361  dmn_z[s][i] = (double *)fftw_malloc(n_interp21*sizeof(double))-1;
362  }//endfor : atoms
363  }//endfor : subplanes
364 
365 //-----------------------------------------------------------------------------
366  }//end routine
367 ///////////////////////////////////////////////////////////////////////////////=
368 
369 
370 ///////////////////////////////////////////////////////////////////////////////=
371 /// Initialize the RhoGhart Cache Data class
372 ///////////////////////////////////////////////////////////////////////////////=
373 ///////////////////////////////////////////////////////////////////////////////c
374 ///////////////////////////////////////////////////////////////////////////////=
375 void RHOGHARTDATA::init(int index_in,int ncoef_in, int *ka, int *kb, int *kc){
376 
377  index = index_in;
378  ncoef = ncoef_in;
379  b_re = (double *)fftw_malloc((ncoef+1)*sizeof(double));
380  b_im = (double *)fftw_malloc((ncoef+1)*sizeof(double));
381 
382  CPLOCAL::getEesPrms(&ngrid_a,&ngrid_b,&ngrid_c,&n_interp,&natm);
383  CPLOCAL::eesSetEesWghtGgrp(ncoef,ka,kb,kc,b_re,b_im,ngrid_a,ngrid_b,ngrid_c,
384  n_interp);
385 }
386 ///////////////////////////////////////////////////////////////////////////////=
387 
388 
389 ///////////////////////////////////////////////////////////////////////////////=
390 /// realParticlePlane Cache Management tool
391 ///////////////////////////////////////////////////////////////////////////////=
392 ///////////////////////////////////////////////////////////////////////////////c
393 ///////////////////////////////////////////////////////////////////////////////=
394 void eesCache::queryCacheRPP (int index,int itime,int iter){
395 ///////////////////////////////////////////////////////////////////////////////=
396 /// Cache compute
397 
398  if(itime != itimeRPP && iter==1){
399 
400  if(itime!=itimeRPP+1 || iter != 1 || allowedRppChares[index]!=1){
401  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@\n");
402  CkPrintf("Broken RPP cache query by %d at %d %d %d\n",index,itime,itimeRPP,iter);
403  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@\n");
404  CkExit();
405  }//endif
406  itimeRPP= itime;
407 
408 #ifdef _EESCACHE_VERBOSE_
409  CkPrintf("HI, I am rPP %d in query : %d\n",index,iter);
410 #endif
411 
412  AtomsCache *ag = UatomsCacheProxy[thisInstance.proxyOffset].ckLocalBranch();
413  CkAssert(ag!=NULL);
414  FastAtoms *fastAtoms = &(ag->fastAtoms);
415  CkAssert(fastAtoms!=NULL);
416  CkAssert(fastAtoms->x!=NULL);
417 #if CMK_TRACE_ENABLED
418  double StartTime=CmiWallTimer();
419 #endif
420 
421  CPNONLOCAL::eesAtmBsplineRgrp(fastAtoms,allowedRppChares,RppData, pScratchProxy.ckLocalBranch()->psscratch);
422 
423 #if CMK_TRACE_ENABLED
424  traceUserBracketEvent(eesAtmBspline_, StartTime, CmiWallTimer());
425 #endif
426 
427  }//endif : time to update the B-splines
428 
429 }//end routine
430 ///////////////////////////////////////////////////////////////////////////////=
431 
432 
433 ///////////////////////////////////////////////////////////////////////////////=
434 /// RhoGhart Cache Management tool
435 ///////////////////////////////////////////////////////////////////////////////=
436 ///////////////////////////////////////////////////////////////////////////////c
437 ///////////////////////////////////////////////////////////////////////////////=
438 void eesCache::queryCacheRHart(int index,int itime,int iter){
439 ///////////////////////////////////////////////////////////////////////////////=
440 /// Cache compute : 1st guy in does the job
441 
442 #ifdef _EESCACHE_VERBOSE_
443  CkPrintf("Querying Rhart by %d at t= %d %d\n",index,itime,itimeRHart);
444 #endif
445 
446  if(itime != itimeRHart){
447 
448  if(itime!=itimeRHart+1 || iter != 1 || allowedRhoRHartChares[index] != 1){
449  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@\n");
450  CkPrintf("Broken HartR cache query by %d at %d %d %d\n",index,itime,itimeRHart,iter);
451  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@\n");
452  CkExit();
453  }//endif
454  itimeRHart= itime;
455 
456 #ifdef _EESCACHE_VERBOSE_
457  CkPrintf("Computing eesAtmBspline\n");
458 #endif
459 
460  AtomsCache *ag = UatomsCacheProxy[thisInstance.proxyOffset].ckLocalBranch();
461  FastAtoms *fastAtoms = &(ag->fastAtoms);
462 #if CMK_TRACE_ENABLED
463  double StartTime=CmiWallTimer();
464 #endif
465 
466  CPLOCAL::eesAtmBsplineRgrp(fastAtoms,allowedRhoRHartChares,RhoRHartData, pScratchProxy.ckLocalBranch()->psscratch);
467 
468 #if CMK_TRACE_ENABLED
469  traceUserBracketEvent(eesAtmBspline_, StartTime, CmiWallTimer());
470 #endif
471 
472  }//endif : time to update the B-splines
473 
474 }//end routine
475 ///////////////////////////////////////////////////////////////////////////////=
476 
477 
478 ///////////////////////////////////////////////////////////////////////////////=
479 /// Initialize the GstatePlane Cache Data class
480 ///////////////////////////////////////////////////////////////////////////////=
481 ///////////////////////////////////////////////////////////////////////////////c
482 ///////////////////////////////////////////////////////////////////////////////=
483 void GSPDATA::init(int index_in,int nkpoint_in){
484 ///////////////////////////////////////////////////////////////////////////////=
485 
486  CPcharmParaInfo *sim = CPcharmParaInfo::get();
487 
488  //------------------------------------------------------------
489  // Set the variables from the generic parainfo group
490 
491  index = index_in;
492  ngrid_a = sim->sizeX;
493  ngrid_b = sim->sizeY;
494  ngrid_c = sim->sizeZ;
495  ncoef = sim->npts_per_chareG[index];
496  numLines = sim->nlines_per_chareG[index];
497  numRuns = 2*numLines;
498  nkpoint = nkpoint_in;
499 
500  //------------------------------------------------------------
501  // Set the runs from the generic group :
502 
503  CkVec <RunDescriptor> *sortedRunDescriptors = sim->sortedRunDescriptors;
504  runs = new RunDescriptor[numRuns];
505  int x = index;
506  if(sortedRunDescriptors[x].size()!=numRuns){
507  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@\n");
508  CkPrintf("Broken run descriptor for plane %d : %d %d\n",
509  x,numRuns,sortedRunDescriptors[x].size());
510  CkPrintf("@@@@@@@@@@@@@@@@@@@@_error_@@@@@@@@@@@@@@@@@@@@\n");
511  CkExit();
512  }//endif
513  for(int j=0;j<numRuns;j++){runs[j] = sortedRunDescriptors[x][j];}
514 
515  //------------------------------------------------------------
516  // set the k-vectors
517 
518  ka = (int *)fftw_malloc(ncoef*sizeof(int));
519  kb = (int *)fftw_malloc(ncoef*sizeof(int));
520  kc = (int *)fftw_malloc(ncoef*sizeof(int));
521  g2 = cmall_mat(0,nkpoint,0,ncoef,"eesCache.C");
522  g = cmall_mat(0,nkpoint,0,ncoef,"eesCache.C");
523 
524  CPNONLOCAL::genericSetKvector(ncoef,ka,kb,kc,numRuns,runs,&gCharePkg,1,
525  ngrid_a,ngrid_b,ngrid_c,g2,g);
526 
527  //------------------------------------------------------------
528  // set the coef masses
529 
530  int mydoublePack = config.doublePack;
531  coef_mass = (double *)fftw_malloc(ncoef*sizeof(double));
532  CPINTEGRATE::CP_create_mass(ncoef,ka,kb,kc,coef_mass,mydoublePack);
533 
534 ///////////////////////////////////////////////////////////////////////////////=
535  }//end routine
536 ///////////////////////////////////////////////////////////////////////////////=
eesCache::registerCacheRHart
void registerCacheRHart(int)
= RhoRhart Cache Management tool
Definition: eesCache.C:158
UberCollection
holds the UberIndex and the offset for proxies
Definition: Uber.h:68
eesCache::queryCacheRHart
void queryCacheRHart(int, int, int)
= RhoGhart Cache Management tool
Definition: eesCache.C:438
GPPDATA::init
void init(int, int, int, int *, int *, int *)
= Initialize the GParticlePlane Cache Data class
Definition: eesCache.C:282
RPPDATA::init
void init(int)
= Initialize the RealParticlePlane Cache Data class
Definition: eesCache.C:241
GSPDATA::init
void init(int, int)
= Initialize the GstatePlane Cache Data class
Definition: eesCache.C:483
RHOGHARTDATA::init
void init(int, int, int *, int *, int *)
= Initialize the RhoGhart Cache Data class
Definition: eesCache.C:375
GSPDATA
Data class : Minimal copies of big redundant data sets.
Definition: eesDataClass.h:127
eesCache::registerCacheGHart
void registerCacheGHart(int, int, int *, int *, int *)
= RhoGhart Cache Management tool
Definition: eesCache.C:181
fftCacheSlab.h
Add type declarations for simulationConstants class (readonly vars) and once class for each type of o...
eesCache::queryCacheRPP
void queryCacheRPP(int, int, int)
= realParticlePlane Cache Management tool
Definition: eesCache.C:394
RunDescriptor
== Index logic for lines of constant x,y in gspace.
Definition: RunDescriptor.h:22
cpaimd.h
Some basic data structures and the array map classes are defined here.
eesCache::registerCacheGPP
void registerCacheGPP(int, int, int *, int *, int *)
= GParticlePlane Cache Management tool
Definition: eesCache.C:138
RHORHARTDATA::init
void init(int)
= Initialize the RhoRhart Cache Data class
Definition: eesCache.C:307
RPPDATA
Data class.
Definition: eesDataClass.h:20
CP_State_Plane.h
GPPDATA
Data class.
Definition: eesDataClass.h:69
RHOGHARTDATA
Data class.
Definition: eesDataClass.h:89
RHORHARTDATA
Data class.
Definition: eesDataClass.h:42
eesCache::registerCacheRPP
void registerCacheRPP(int)
= realParticlePlane Cache Management tool
Definition: eesCache.C:118