HPhi++  3.1.0
Functions
CheckMPI.cpp File Reference

Compute total number of electrons, spins. More...

#include "Common.hpp"
#include "wrapperMPI.hpp"

Go to the source code of this file.

Functions

int CheckMPI (struct BindStruct *X)
 Define the number of sites in each PE (DefineList.Nsite). Reduce the number of electrons (DefineList.Ne), total Sz (DefineList.Total2Sz) by them in the inter process region. More...
 
void CheckMPI_Summary (struct BindStruct *X)
 Print infomation of MPI parallelization Modify Definelist::Tpow in the inter process region. More...
 

Detailed Description

Compute total number of electrons, spins.

Definition in file CheckMPI.cpp.

Function Documentation

◆ CheckMPI()

int CheckMPI ( struct BindStruct *  X)

Define the number of sites in each PE (DefineList.Nsite). Reduce the number of electrons (DefineList.Ne), total Sz (DefineList.Total2Sz) by them in the inter process region.

Author
Mitsuaki Kawamura (The University of Tokyo)

Branch for each model

Check the number of processes for Boost

Parameters
[in,out]X

Definition at line 27 of file CheckMPI.cpp.

References BindStruct::Boost, BindStruct::Def, exitMPI(), BoostList::flgBoost, DefineList::iCalcModel, DefineList::iFlgGeneralSpin, BoostList::ishift_nspin, BoostList::list_6spin_star, DefineList::LocSpn, myrank, DefineList::Ndown, DefineList::Ne, DefineList::NLocSpn, nproc, DefineList::Nsite, DefineList::NsiteMPI, BoostList::num_pivot, DefineList::Nup, DefineList::SiteToBit, stdoutMPI, DefineList::Total2Sz, DefineList::Total2SzMPI, and BoostList::W0.

Referenced by check().

28 {
29  int isite;
30  int NDimInterPE, SmallDim, SpinNum, ishift;
31  int ipivot, isiteMax, isiteMax0;
32 
37  X->Def.NsiteMPI = X->Def.Nsite;
38  X->Def.Total2SzMPI = X->Def.Total2Sz;
39  switch (X->Def.iCalcModel) {
40  case HubbardGC: /****************************************************/
41  case Hubbard:
42  case HubbardNConserved:
43  case Kondo:
44  case KondoGC:
45 
51  NDimInterPE = 1;
52  for (isite = X->Def.NsiteMPI; isite > 0; isite--) {
53  if (NDimInterPE == nproc) {
54  X->Def.Nsite = isite;
55  break;
56  } /*if (NDimInterPE == nproc)*/
57  NDimInterPE *= 4;
58  } /*for (isite = NsiteMPI; isite > 0; isite--)*/
59 
60  if (isite == 0) {
61  fprintf(stdoutMPI, "%s", "Error ! The number of PROCESS should be 4-exponent !\n");
62  fprintf(stdoutMPI, " The number of PROCESS : %d\n", nproc);
63  NDimInterPE = 1;
64  int ismallNproc=1;
65  int ilargeNproc=1;
66  for (isite = X->Def.NsiteMPI; isite > 0; isite--) {
67  if (NDimInterPE > nproc) {
68  ilargeNproc = NDimInterPE;
69  if(isite >1)
70  ismallNproc = NDimInterPE/4;
71  break;
72  }/*if (NDimInterPE > nproc)*/
73  NDimInterPE *= 4;
74  }/*for (isite = X->Def.NsiteMPI; isite > 0; isite--)*/
75  fprintf(stdoutMPI, " Set the number of PROCESS as %d or %d.\n",ismallNproc, ilargeNproc );
76  return FALSE;
77  //return FALSE;
78  } /*if (isite == 0)*/
79 
80  switch (X->Def.iCalcModel) /*2 (inner)*/ {
81 
82  case Hubbard:
88  SmallDim = myrank;
89  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
90  SpinNum = SmallDim % 4;
91  SmallDim /= 4;
92  if (SpinNum == 1 /*01*/) {
93  X->Def.Nup -= 1;
94  X->Def.Ne -= 1;
95  }
96  else if (SpinNum == 2 /*10*/) {
97  X->Def.Ndown -= 1;
98  X->Def.Ne -= 1;
99  }
100  else if (SpinNum == 3 /*11*/){
101  X->Def.Nup -= 1;
102  X->Def.Ndown -= 1;
103  X->Def.Ne -= 2;
104  }
105  } /*for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)*/
106 
107  break;/*case Hubbard:*/
108 
109  case HubbardNConserved:
114  SmallDim = myrank;
115  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
116  SpinNum = SmallDim % 4;
117  SmallDim /= 4;
118  if (SpinNum == 1 /*01*/ || SpinNum == 2 /*10*/) X->Def.Ne -= 1;
119  else if (SpinNum == 3 /*11*/) X->Def.Ne -= 2;
120  } /*for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)*/
121 
122  break; /*case HubbardNConserved:*/
123 
124  case KondoGC:
125  case Kondo:
131  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)
132  if (X->Def.LocSpn[isite] != ITINERANT) X->Def.NLocSpn -= 1;
133 
134  if (X->Def.iCalcModel == Kondo) {
135  SmallDim = myrank;
136  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
137  SpinNum = SmallDim % 4;
138  SmallDim /= 4;
139  if (X->Def.LocSpn[isite] == ITINERANT) {
140  if (SpinNum == 1 /*01*/) {
141  X->Def.Nup -= 1;
142  X->Def.Ne -= 1;
143  }
144  else if (SpinNum == 2 /*10*/) {
145  X->Def.Ndown -= 1;
146  X->Def.Ne -= 1;
147  }
148  else if (SpinNum == 3 /*11*/) {
149  X->Def.Nup -= 1;
150  X->Def.Ndown -= 1;
151  X->Def.Ne -= 2;
152  }
153  }
154  else {
155  fprintf(stdoutMPI, "\n Stop because local spin in the inter process region\n");
156  return FALSE;
157  }
158  }/*for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)*/
159  } /*if (X->Def.iCalcModel == Kondo)*/
160  else {
161  X->Def.Nup = 0;
162  X->Def.Ndown = 0;
163  X->Def.Ne = 0;
164  }
165 
166  break; /*case KondoGC, Kondo*/
167 
168  case HubbardGC:
169  X->Def.Nup = 0;
170  X->Def.Ndown = 0;
171  X->Def.Ne = 0;
172  X->Def.Total2Sz = 0;
173  break;
174  } /*switch (X->Def.iCalcModel) 2(inner)*/
175 
176  break; /*case HubbardGC, Hubbard, HubbardNConserved, Kondo, KondoGC:*/
178  case SpinGC:/********************************************************/
179  case Spin:
180 
181  if (X->Def.iFlgGeneralSpin == FALSE) {
186  NDimInterPE = 1;
187  for (isite = X->Def.NsiteMPI; isite > 0; isite--) {
188  if (NDimInterPE == nproc) {
189  X->Def.Nsite = isite;
190  break;
191  }/*if (NDimInterPE == nproc)*/
192  NDimInterPE *= 2;
193  }/*for (isite = X->Def.NsiteMPI; isite > 0; isite--)*/
194 
195  if (isite == 0) {
196  fprintf(stdoutMPI, "%s", "Error ! The number of PROCESS should be 2-exponent !\n");
197  fprintf(stdoutMPI, " The number of PROCESS : %d\n", nproc);
198  NDimInterPE = 1;
199  int ismallNproc=1;
200  int ilargeNproc=1;
201  for (isite = X->Def.NsiteMPI; isite > 0; isite--) {
202  if (NDimInterPE > nproc) {
203  ilargeNproc = NDimInterPE;
204  if(isite >1)
205  ismallNproc = NDimInterPE/2;
206  break;
207  }/*if (NDimInterPE > nproc)*/
208  NDimInterPE *= 2;
209  }/*for (isite = X->Def.NsiteMPI; isite > 0; isite--)*/
210  fprintf(stdoutMPI, " Set the number of PROCESS as %d or %d.\n",ismallNproc, ilargeNproc );
211  return FALSE;
212  }/*if (isite == 0)*/
213 
214  if (X->Def.iCalcModel == Spin) {
215  /*X->Def.NeMPI = X->Def.Ne;*/
216 
217  /* Ne should be different in each PE */
218  SmallDim = myrank;
219  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
220  SpinNum = SmallDim % 2;
221  SmallDim /= 2;
222  if (SpinNum == 0) {
223  X->Def.Ndown -= 1;
224  }
225  else {
226  X->Def.Ne -= 1;
227  X->Def.Nup -= 1;
228  }
229  }/*for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)*/
230  }/*if (X->Def.iCalcModel == Spin)*/
231 
232  } /*if (X->Def.iFlgGeneralSpin == FALSE)*/
233  else{/* General Spin */
238  NDimInterPE = 1;
239  for (isite = X->Def.NsiteMPI; isite > 0; isite--) {
240  if (NDimInterPE == nproc) {
241  X->Def.Nsite = isite;
242  break;
243  }/*if (NDimInterPE == nproc)*/
244  NDimInterPE *= X->Def.SiteToBit[isite - 1];
245  }/*for (isite = X->Def.NsiteMPI; isite > 0; isite--)*/
246 
247  if (isite == 0) {
248  fprintf(stdoutMPI, "%s", "Error ! The number of PROCESS is wrong !\n");
249  fprintf(stdoutMPI, " The number of PROCESS : %d\n", nproc);
250  NDimInterPE = 1;
251  int ismallNproc=1;
252  int ilargeNproc=1;
253  for (isite = X->Def.NsiteMPI; isite > 0; isite--) {
254  if (NDimInterPE > nproc) {
255  ilargeNproc = NDimInterPE;
256  if(isite >1)
257  ismallNproc = NDimInterPE/X->Def.SiteToBit[isite - 2];
258  break;
259  }/*if (NDimInterPE > nproc)*/
260  NDimInterPE *= X->Def.SiteToBit[isite - 1];
261  }/*for (isite = X->Def.NsiteMPI; isite > 0; isite--)*/
262  fprintf(stdoutMPI, " Set the number of PROCESS as %d or %d.\n",ismallNproc, ilargeNproc );
263  return FALSE;
264  }/*if (isite == 0)*/
265 
266  if (X->Def.iCalcModel == Spin) {
267  X->Def.Total2SzMPI = X->Def.Total2Sz;
268 
269  /* Ne should be different in each PE */
270  SmallDim = myrank;
271  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
272  SpinNum = SmallDim % X->Def.SiteToBit[isite];
273  SmallDim /= X->Def.SiteToBit[isite];
274 
275  X->Def.Total2Sz += X->Def.SiteToBit[isite] - 1 - 2*SpinNum;
276  }/*for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)*/
277  }/*if (X->Def.iCalcModel == Spin)*/
278  }/*if (X->Def.iFlgGeneralSpin == TRUE)*/
279 
281  break; /*case SpinGC, Spin*/
282 
283  default:
284  fprintf(stdoutMPI, "Error ! Wrong model !\n");
285  return FALSE;
286  }/*switch (X->Def.iCalcModel)*/
287 
291  if (X->Boost.flgBoost == 1) {
292  isiteMax = X->Boost.W0;
293  ishift = 0;
294  for (ipivot = 0; ipivot < X->Boost.num_pivot; ipivot++) {
295  isiteMax0 = X->Boost.list_6spin_star[ipivot][1]
296  + X->Boost.list_6spin_star[ipivot][2]
297  + X->Boost.list_6spin_star[ipivot][3]
298  + X->Boost.list_6spin_star[ipivot][4]
299  + X->Boost.list_6spin_star[ipivot][5];
300  if (ishift > 1) isiteMax0 = X->Def.NsiteMPI - isiteMax0 - 1 - ishift;
301  else isiteMax0 = X->Def.NsiteMPI - isiteMax0 - 2;
302  if (isiteMax0 < isiteMax) isiteMax = isiteMax0;
303  if (X->Boost.list_6spin_star[ipivot][6] == 1) ishift += X->Boost.ishift_nspin;
304  }/*for (ipivot = 0; ipivot < X->Boost.num_pivot; ipivot++)*/
305 
306  NDimInterPE = 1;
307  for (isite = 0; isite < isiteMax; isite++) NDimInterPE *= 2;
308 
309  if (NDimInterPE < nproc) {
310  fprintf(stderr, "\n Error ! in ReadDefFileIdxPara.\n");
311  fprintf(stderr, "Too many MPI processes ! It should be <= %d. \n\n", NDimInterPE);
312  exitMPI(-1);
313  }/*if (NDimInterPE < nproc)*/
314  }/*if (X->Boost.flgBoost == 1)*/
315 
316  return TRUE;
317 }/*void CheckMPI*/
exitMPI
void exitMPI(int errorcode)
MPI Abortation wrapper.
Definition: wrapperMPI.cpp:86
DefineList::Nup
int Nup
Number of spin-up electrons in this process.
Definition: struct.hpp:58
BindStruct::Def
struct DefineList Def
Definision of system (Hamiltonian) etc.
Definition: struct.hpp:395
nproc
int nproc
Number of processors, defined in InitializeMPI()
Definition: global.cpp:72
stdoutMPI
FILE * stdoutMPI
File pointer to the standard output defined in InitializeMPI()
Definition: global.cpp:75
BoostList::list_6spin_star
int ** list_6spin_star
Definition: struct.hpp:388
DefineList::Total2Sz
int Total2Sz
Total in this process.
Definition: struct.hpp:69
DefineList::Nsite
int Nsite
Number of sites in the INTRA process region.
Definition: struct.hpp:56
DefineList::LocSpn
int * LocSpn
[DefineList::NLocSpn] Flag (and size) of the local spin. malloc in setmem_def().
Definition: struct.hpp:82
DefineList::NsiteMPI
int NsiteMPI
Total number of sites, differ from DefineList::Nsite.
Definition: struct.hpp:57
DefineList::Ne
int Ne
Number of electrons in this process.
Definition: struct.hpp:71
BindStruct::Boost
struct BoostList Boost
For Boost.
Definition: struct.hpp:399
myrank
int myrank
Process ID, defined in InitializeMPI()
Definition: global.cpp:73
DefineList::iFlgGeneralSpin
int iFlgGeneralSpin
Flag for the general (Sz/=1/2) spin.
Definition: struct.hpp:86
BoostList::ishift_nspin
long int ishift_nspin
Definition: struct.hpp:384
DefineList::SiteToBit
long int * SiteToBit
[DefineList::NsiteMPI] Similar to DefineList::Tpow. For general spin.
Definition: struct.hpp:94
BoostList::num_pivot
long int num_pivot
Definition: struct.hpp:383
BoostList::W0
long int W0
Definition: struct.hpp:382
DefineList::iCalcModel
int iCalcModel
Switch for model. 0:Hubbard, 1:Spin, 2:Kondo, 3:HubbardGC, 4:SpinGC, 5:KondoGC, 6:HubbardNConserved.
Definition: struct.hpp:200
BoostList::flgBoost
int flgBoost
Flag whether use CMA algorithm.
Definition: struct.hpp:380
DefineList::Ndown
int Ndown
Number of spin-down electrons in this process.
Definition: struct.hpp:59
DefineList::NLocSpn
int NLocSpn
Number of local spins.
Definition: struct.hpp:84
DefineList::Total2SzMPI
int Total2SzMPI
Total across processes.
Definition: struct.hpp:70

◆ CheckMPI_Summary()

void CheckMPI_Summary ( struct BindStruct *  X)

Print infomation of MPI parallelization Modify Definelist::Tpow in the inter process region.

Author
Mitsuaki Kawamura (The University of Tokyo)

Print the configuration in the inter process region of each PE as a binary (excepting general spin) format.

Reset DefineList::Tpow[DefNsite], DefineList::Tpow[DefNsite + 1] ... as inter process space For Hubbard & Kondo system, define DefineList::OrgTpow which is not affected by the number of processes.

Parameters
[in,out]X

Definition at line 323 of file CheckMPI.cpp.

References BindStruct::Check, BindStruct::Def, exitMPI(), DefineList::iCalcModel, CheckList::idim_max, CheckList::idim_maxMPI, DefineList::iFlgGeneralSpin, DefineList::iFlgScaLAPACK, myrank, DefineList::Ndown, DefineList::Ne, nproc, DefineList::Nsite, DefineList::NsiteMPI, DefineList::Nup, DefineList::OrgTpow, DefineList::SiteToBit, stdoutMPI, SumMPI_i(), SumMPI_li(), DefineList::Total2Sz, and DefineList::Tpow.

Referenced by check().

323  {
324 
325  int iproc, SmallDim, SpinNum, Nelec;
326  int isite;
327  long int idimMPI;
328 
329  if(X->Def.iFlgScaLAPACK == 0) {
330  fprintf(stdoutMPI, "\n\n###### MPI site separation summary ######\n\n");
331  fprintf(stdoutMPI, " INTRA process site\n");
332  fprintf(stdoutMPI, " Site Bit\n");
333  for (isite = 0; isite < X->Def.Nsite; isite++) {
334  switch (X->Def.iCalcModel) {
335  case HubbardGC:
336  case Hubbard:
337  case HubbardNConserved:
338  case Kondo:
339  case KondoGC:
340 
341  fprintf(stdoutMPI, " %4d %4d\n", isite, 4);
342  break;
343 
344  case Spin:
345  case SpinGC:
346 
347  if (X->Def.iFlgGeneralSpin == FALSE) {
348  fprintf(stdoutMPI, " %4d %4d\n", isite, 2);
349  }/*if (X->Def.iFlgGeneralSpin == FALSE)*/
350  else {
351  fprintf(stdoutMPI, " %4d %4ld\n", isite, X->Def.SiteToBit[isite]);
352  }/*if (X->Def.iFlgGeneralSpin == TRUE)*/
353 
354  break;
355 
356  } /*switch (X->Def.iCalcModel)*/
357  } /*for (isite = 0; isite < X->Def.Nsite; isite++)*/
358 
359  fprintf(stdoutMPI, "\n INTER process site\n");
360  fprintf(stdoutMPI, " Site Bit\n");
361  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
362  switch (X->Def.iCalcModel) {
363  case HubbardGC:
364  case Hubbard:
365  case HubbardNConserved:
366  case Kondo:
367  case KondoGC:
368 
369  fprintf(stdoutMPI, " %4d %4d\n", isite, 4);
370  break;
371 
372  case Spin:
373  case SpinGC:
374 
375  if (X->Def.iFlgGeneralSpin == FALSE) {
376  fprintf(stdoutMPI, " %4d %4d\n", isite, 2);
377  }/*if (X->Def.iFlgGeneralSpin == FALSE) */
378  else {
379  fprintf(stdoutMPI, " %4d %4ld\n", isite, X->Def.SiteToBit[isite]);
380  }/*if (X->Def.iFlgGeneralSpin == TRUE) */
381 
382  break;
383 
384  }/*switch (X->Def.iCalcModel)*/
385  }/*for (isite = X->Def.Nsite; isite < NsiteMPI; isite++)*/
386 
387  fprintf(stdoutMPI, "\n Process element info\n");
388  fprintf(stdoutMPI, " Process Dimension Nup Ndown Nelec Total2Sz State\n");
389 
390  for (iproc = 0; iproc < nproc; iproc++) {
391 
392  fprintf(stdoutMPI, " %7d", iproc);
393 
394  if (myrank == iproc) idimMPI = X->Check.idim_max;
395  else idimMPI = 0;
396  fprintf(stdoutMPI, " %15ld", SumMPI_li(idimMPI));
397 
398  if (myrank == iproc) Nelec = X->Def.Nup;
399  else Nelec = 0;
400  fprintf(stdoutMPI, " %4d", SumMPI_i(Nelec));
401 
402  if (myrank == iproc) Nelec = X->Def.Ndown;
403  else Nelec = 0;
404  fprintf(stdoutMPI, " %5d", SumMPI_i(Nelec));
405 
406  if (myrank == iproc) {
407  Nelec = X->Def.Ne; //X->Def.Nup
408  if (X->Def.iCalcModel == Spin || X->Def.iCalcModel == SpinGC) Nelec += X->Def.Ndown;
409  } else Nelec = 0;
410 
411  fprintf(stdoutMPI, " %5d", SumMPI_i(Nelec));
412 
413  if (myrank == iproc) Nelec = X->Def.Total2Sz;
414  else Nelec = 0;
415  fprintf(stdoutMPI, " %8d ", SumMPI_i(Nelec));
420  switch (X->Def.iCalcModel) {
421  case HubbardGC: /****************************************************/
422  case Hubbard:
423  case HubbardNConserved:
424  case Kondo:
425  case KondoGC:
426 
427  SmallDim = iproc;
428  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
429  SpinNum = SmallDim % 4;
430  SmallDim /= 4;
431  if (SpinNum == 0) fprintf(stdoutMPI, "00");
432  else if (SpinNum == 1) fprintf(stdoutMPI, "01");
433  else if (SpinNum == 2) fprintf(stdoutMPI, "10");
434  else if (SpinNum == 3) fprintf(stdoutMPI, "11");
435  } /*for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)*/
436 
437  break;
438 
439  case Spin:
440  case SpinGC:
441 
442  SmallDim = iproc;
443  if (X->Def.iFlgGeneralSpin == FALSE) {
444  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
445  SpinNum = SmallDim % 2;
446  SmallDim /= 2;
447  fprintf(stdoutMPI, "%1d", SpinNum);
448  }/*for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)*/
449  }/*if (X->Def.iFlgGeneralSpin == FALSE)*/
450  else {
451  SmallDim = iproc;
452  for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++) {
453  SpinNum = SmallDim % (int) X->Def.SiteToBit[isite];
454  SmallDim /= X->Def.SiteToBit[isite];
455  fprintf(stdoutMPI, "%1d", SpinNum);
456  }/*for (isite = X->Def.Nsite; isite < X->Def.NsiteMPI; isite++)*/
457  }/*if (X->Def.iFlgGeneralSpin == TRUE)*/
458 
459  break;
460 
461  }/*switch (X->Def.iCalcModel)*/
462  fprintf(stdoutMPI, "\n");
463  }/*for (iproc = 0; iproc < nproc; iproc++)*/
464 
465  X->Check.idim_maxMPI = SumMPI_li(X->Check.idim_max);
466  fprintf(stdoutMPI, "\n Total dimension : %ld\n\n", X->Check.idim_maxMPI);
467  if (X->Check.idim_maxMPI < 1) {
468  fprintf(stdoutMPI, "ERROR! Total dimension < 1\n");
469  exitMPI(-1);
470  }
471  }
472  else{
473  fprintf(stdoutMPI, "\n Total dimension : %ld\n\n", X->Check.idim_max);
474  }
475 
482  switch (X->Def.iCalcModel) {
483  case HubbardGC: /****************************************************/
484  case Hubbard:
485  case HubbardNConserved:
486  case Kondo:
487  case KondoGC:
488 
489  X->Def.Tpow[2 * X->Def.Nsite] = 1;
490  for (isite = 2 * X->Def.Nsite + 1; isite < 2 * X->Def.NsiteMPI; isite++)
491  X->Def.Tpow[isite] = X->Def.Tpow[isite - 1] * 2;
492 
493  X->Def.OrgTpow[0]=1;
494  for (isite = 1; isite < 2 * X->Def.NsiteMPI; isite++)
495  X->Def.OrgTpow[isite] = X->Def.OrgTpow[isite-1]*2;
496 
497  break;
498 
499  case SpinGC:/********************************************************/
500  case Spin:
501 
502  if (X->Def.iFlgGeneralSpin == FALSE) {
503 
504  X->Def.Tpow[X->Def.Nsite] = 1;
505  for (isite = X->Def.Nsite + 1; isite < X->Def.NsiteMPI; isite++)
506  X->Def.Tpow[isite] = X->Def.Tpow[isite - 1] * 2;
507 
508  }/*if (X->Def.iFlgGeneralSpin == FALSE)*/
509  else{
510 
511  X->Def.Tpow[X->Def.Nsite] = 1;
512  for (isite = X->Def.Nsite + 1; isite < X->Def.NsiteMPI; isite++)
513  X->Def.Tpow[isite] = X->Def.Tpow[isite - 1] * X->Def.SiteToBit[isite - 1];
514 
515  }/*if (X->Def.iFlgGeneralSpin == TRUE)*/
516  break;
517  } /*switch (X->Def.iCalcModel)*/
518 }/*void CheckMPI_Summary*/
exitMPI
void exitMPI(int errorcode)
MPI Abortation wrapper.
Definition: wrapperMPI.cpp:86
DefineList::Nup
int Nup
Number of spin-up electrons in this process.
Definition: struct.hpp:58
BindStruct::Def
struct DefineList Def
Definision of system (Hamiltonian) etc.
Definition: struct.hpp:395
nproc
int nproc
Number of processors, defined in InitializeMPI()
Definition: global.cpp:72
stdoutMPI
FILE * stdoutMPI
File pointer to the standard output defined in InitializeMPI()
Definition: global.cpp:75
DefineList::OrgTpow
long int * OrgTpow
[2 * DefineList::NsiteMPI] malloc in setmem_def().
Definition: struct.hpp:92
DefineList::Total2Sz
int Total2Sz
Total in this process.
Definition: struct.hpp:69
SumMPI_li
long int SumMPI_li(long int idim)
MPI wrapper function to obtain sum of unsigned long integer across processes.
Definition: wrapperMPI.cpp:271
DefineList::Nsite
int Nsite
Number of sites in the INTRA process region.
Definition: struct.hpp:56
CheckList::idim_maxMPI
long int idim_maxMPI
The total dimension across process.
Definition: struct.hpp:306
DefineList::iFlgScaLAPACK
int iFlgScaLAPACK
ScaLAPACK mode ( only for FullDiag )
Definition: struct.hpp:237
DefineList::NsiteMPI
int NsiteMPI
Total number of sites, differ from DefineList::Nsite.
Definition: struct.hpp:57
DefineList::Ne
int Ne
Number of electrons in this process.
Definition: struct.hpp:71
SumMPI_i
int SumMPI_i(int idim)
MPI wrapper function to obtain sum of integer across processes.
Definition: wrapperMPI.cpp:288
myrank
int myrank
Process ID, defined in InitializeMPI()
Definition: global.cpp:73
DefineList::iFlgGeneralSpin
int iFlgGeneralSpin
Flag for the general (Sz/=1/2) spin.
Definition: struct.hpp:86
DefineList::SiteToBit
long int * SiteToBit
[DefineList::NsiteMPI] Similar to DefineList::Tpow. For general spin.
Definition: struct.hpp:94
DefineList::Tpow
long int * Tpow
[2 * DefineList::NsiteMPI] malloc in setmem_def().
Definition: struct.hpp:90
DefineList::iCalcModel
int iCalcModel
Switch for model. 0:Hubbard, 1:Spin, 2:Kondo, 3:HubbardGC, 4:SpinGC, 5:KondoGC, 6:HubbardNConserved.
Definition: struct.hpp:200
DefineList::Ndown
int Ndown
Number of spin-down electrons in this process.
Definition: struct.hpp:59
BindStruct::Check
struct CheckList Check
Size of the Hilbert space.
Definition: struct.hpp:396
CheckList::idim_max
long int idim_max
The dimension of the Hilbert space of this process.
Definition: struct.hpp:305