QUDA  v0.5.0
A library for QCD on GPUs
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
misc.cpp
Go to the documentation of this file.
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include "quda.h"
4 #include <string.h>
5 #include "invert_quda.h"
6 #include "misc.h"
7  #include <assert.h>
8 #include "util_quda.h"
9 #include <test_util.h>
10 
11 
12 extern int verbose;
13 
14 #define stSpinorSiteSize 6
15 template<typename Float>
16 void display_spinor_internal(Float* spinor)
17 {
18  printf("(%f,%f) (%f,%f) (%f,%f) \t",
19  spinor[0], spinor[1], spinor[2],
20  spinor[3], spinor[4], spinor[5]);
21 
22  printf("\n");
23  return;
24 }
25 
26 
27 
28 void display_spinor(void* spinor, int len, int precision)
29 {
30  int i;
31 
32  if (precision == QUDA_DOUBLE_PRECISION){
33  double* myspinor = (double*)spinor;
34  for (i = 0;i < len; i++){
35  display_spinor_internal(myspinor + stSpinorSiteSize*i);
36  }
37  }else if (precision == QUDA_SINGLE_PRECISION){
38  float* myspinor = (float*)spinor;
39  for (i=0;i < len ;i++){
40  display_spinor_internal(myspinor + stSpinorSiteSize*i);
41  }
42  }
43  return;
44 }
45 
46 
47 
48 template<typename Float>
49 void display_link_internal(Float* link)
50 {
51  int i, j;
52 
53  for (i = 0;i < 3; i++){
54  for(j=0;j < 3; j++){
55  printf("(%.10f,%.10f) \t", link[i*3*2 + j*2], link[i*3*2 + j*2 + 1]);
56  }
57  printf("\n");
58  }
59  printf("\n");
60  return;
61 }
62 
63 
64 
65 void display_link(void* link, int len, int precision)
66 {
67  int i;
68 
69  if (precision == QUDA_DOUBLE_PRECISION){
70  double* mylink = (double*)link;
71  for (i = 0;i < len; i++){
72  display_link_internal(mylink + gaugeSiteSize*i);
73  }
74  }else if (precision == QUDA_SINGLE_PRECISION){
75  float* mylink = (float*)link;
76  for (i=0;i < len ;i++){
77  display_link_internal(mylink + gaugeSiteSize*i);
78  }
79  }
80  return;
81 }
82 
83 
84 
85 template <typename Float>
86 void accumulateConjugateProduct(Float *a, Float *b, Float *c, int sign) {
87  a[0] += sign * (b[0]*c[0] - b[1]*c[1]);
88  a[1] -= sign * (b[0]*c[1] + b[1]*c[0]);
89 }
90 
91 
92 template<typename Float>
93 int link_sanity_check_internal_12(Float* link, int dir, int ga_idx, QudaGaugeParam* gaugeParam, int oddBit)
94 {
95  //printf("link sanity check is called\n");
96 
97  int ret =0;
98 
99  Float refc_buf[6];
100  Float* refc = &refc_buf[0];
101 
102  memset((void*)refc, 0, sizeof(refc_buf));
103 
104  Float* a = link;
105  Float* b = link + 6;
106  Float* c = link + 12;
107 
108  accumulateConjugateProduct(refc + 0*2, a + 1*2, b + 2*2, +1);
109  accumulateConjugateProduct(refc + 0*2, a + 2*2, b + 1*2, -1);
110  accumulateConjugateProduct(refc + 1*2, a + 2*2, b + 0*2, +1);
111  accumulateConjugateProduct(refc + 1*2, a + 0*2, b + 2*2, -1);
112  accumulateConjugateProduct(refc + 2*2, a + 0*2, b + 1*2, +1);
113  accumulateConjugateProduct(refc + 2*2, a + 1*2, b + 0*2, -1);
114 
115  int X1h=gaugeParam->X[0]/2;
116  int X1 =gaugeParam->X[0];
117  int X2 =gaugeParam->X[1];
118  int X3 =gaugeParam->X[2];
119  int X4 =gaugeParam->X[3];
120  double t_boundary = (gaugeParam->t_boundary ==QUDA_ANTI_PERIODIC_T)? -1.0:1.0;
121 
122  double u0 = gaugeParam->tadpole_coeff;
123  double coff= -u0*u0*24;
124  //coff = (dir < 6) ? coff : ( (ga_idx >= (X4-3)*X1h*X2*X3 )? t_boundary : 1);
125 
126  //float u0 = (dir < 6) ? gaugeParam->anisotropy : ( (ga_idx >= (X4-3)*X1h*X2*X3 )? t_boundary : 1);
127 
128 
129 #if 1
130 
131  {
132  int index = fullLatticeIndex(ga_idx, oddBit);
133  int i4 = index /(X3*X2*X1);
134  int i3 = (index - i4*(X3*X2*X1))/(X2*X1);
135  int i2 = (index - i4*(X3*X2*X1) - i3*(X2*X1))/X1;
136  int i1 = index - i4*(X3*X2*X1) - i3*(X2*X1) - i2*X1;
137 
138  if (dir == 0) {
139  if (i4 % 2 == 1){
140  coff *= -1;
141  }
142  }
143 
144  if (dir == 2){
145  if ((i1+i4) % 2 == 1){
146  coff *= -1;
147  }
148  }
149  if (dir == 4){
150  if ( (i4+i1+i2) % 2 == 1){
151  coff *= -1;
152  }
153  }
154  if (dir == 6){
155  if (ga_idx >= (X4-3)*X1h*X2*X3 ){
156  coff *= -1;
157  }
158  }
159 
160  //printf("local ga_idx =%d, index=%d, i4,3,2,1 =%d %d %d %d\n", ga_idx, index, i4, i3, i2,i1);
161 
162  }
163 #endif
164 
165 
166  refc[0]*=coff; refc[1]*=coff; refc[2]*=coff; refc[3]*=coff; refc[4]*=coff; refc[5]*=coff;
167 
168 
169  double delta = 0.0001;
170  int i;
171  for (i =0;i < 6; i++){
172  double diff = refc[i] - c[i];
173  double absdiff = diff > 0? diff: (-diff);
174  if (absdiff > delta){
175  printf("ERROR: sanity check failed for link\n");
176  display_link_internal(link);
177  printf("refc = (%.10f,%.10f) (%.10f,%.10f) (%.10f,%.10f)\n",
178  refc[0], refc[1], refc[2], refc[3], refc[4], refc[5]);
179  printf("dir=%d, ga_idx=%d, coff=%f, t_boundary=%f\n",dir, ga_idx,coff, t_boundary);
180  printf("X=%d %d %d %d, X1h=%d\n", gaugeParam->X[0], X2, X3, X4, X1h);
181  return -1;
182  }
183 
184  }
185 
186 
187  return ret;
188 }
189 
190 
191 template<typename Float>
192 int site_link_sanity_check_internal_12(Float* link, int dir, int ga_idx, QudaGaugeParam* gaugeParam, int oddBit)
193 {
194  int ret = 0;
195 
196  Float refc_buf[6];
197  Float* refc = &refc_buf[0];
198 
199  memset((void*)refc, 0, sizeof(refc_buf));
200 
201  Float* a = link;
202  Float* b = link + 6;
203  Float* c = link + 12;
204 
205  accumulateConjugateProduct(refc + 0*2, a + 1*2, b + 2*2, +1);
206  accumulateConjugateProduct(refc + 0*2, a + 2*2, b + 1*2, -1);
207  accumulateConjugateProduct(refc + 1*2, a + 2*2, b + 0*2, +1);
208  accumulateConjugateProduct(refc + 1*2, a + 0*2, b + 2*2, -1);
209  accumulateConjugateProduct(refc + 2*2, a + 0*2, b + 1*2, +1);
210  accumulateConjugateProduct(refc + 2*2, a + 1*2, b + 0*2, -1);
211 
212  int X1h=gaugeParam->X[0]/2;
213  int X1 =gaugeParam->X[0];
214  int X2 =gaugeParam->X[1];
215  int X3 =gaugeParam->X[2];
216  int X4 =gaugeParam->X[3];
217 
218  // only apply temporal boundary condition if I'm the last node in T
219 #ifdef MULTI_GPU
220  bool last_node_in_t = (commCoords(3) == commDim(3)-1);
221 #else
222  bool last_node_in_t = true;
223 #endif
224 
225 #if 1
226  double coeff= 1.0;
227 
228  {
229  int index = fullLatticeIndex(ga_idx, oddBit);
230  int i4 = index /(X3*X2*X1);
231  int i3 = (index - i4*(X3*X2*X1))/(X2*X1);
232  int i2 = (index - i4*(X3*X2*X1) - i3*(X2*X1))/X1;
233  int i1 = index - i4*(X3*X2*X1) - i3*(X2*X1) - i2*X1;
234 
235  if (dir == XUP) {
236  if (i4 % 2 == 1){
237  coeff *= -1;
238  }
239  }
240 
241  if (dir == YUP){
242  if ((i1+i4) % 2 == 1){
243  coeff *= -1;
244  }
245  }
246  if (dir == ZUP){
247  if ( (i4+i1+i2) % 2 == 1){
248  coeff *= -1;
249  }
250  }
251  if (dir == TUP){
252  if (last_node_in_t && i4 == (X4-1) ){
253  coeff *= -1;
254  }
255  }
256  }
257 
258 
259  refc[0]*=coeff; refc[1]*=coeff; refc[2]*=coeff; refc[3]*=coeff; refc[4]*=coeff; refc[5]*=coeff;
260 #endif
261 
262 
263  double delta = 0.0001;
264  int i;
265  for (i =0;i < 6; i++){
266  double diff = refc[i] - c[i];
267  double absdiff = diff > 0? diff: (-diff);
268  if (absdiff > delta){
269  printf("ERROR: sanity check failed for site link\n");
270  display_link_internal(link);
271  printf("refc = (%.10f,%.10f) (%.10f,%.10f) (%.10f,%.10f)\n",
272  refc[0], refc[1], refc[2], refc[3], refc[4], refc[5]);
273  printf("X=%d %d %d %d, X1h=%d\n", gaugeParam->X[0], X2, X3, X4, X1h);
274  return -1;
275  }
276 
277  }
278 
279 
280  return ret;
281 }
282 
283 
284 
285 
286 
287 
288 // a+=b
289 template <typename Float>
290 void complexAddTo(Float *a, Float *b) {
291  a[0] += b[0];
292  a[1] += b[1];
293 }
294 
295 // a = b*c
296 template <typename Float>
297 void complexProduct(Float *a, Float *b, Float *c) {
298  a[0] = b[0]*c[0] - b[1]*c[1];
299  a[1] = b[0]*c[1] + b[1]*c[0];
300 }
301 
302 // a = conj(b)*conj(c)
303 template <typename Float>
304 void complexConjugateProduct(Float *a, Float *b, Float *c) {
305  a[0] = b[0]*c[0] - b[1]*c[1];
306  a[1] = -b[0]*c[1] - b[1]*c[0];
307 }
308 
309 // a = conj(b)*c
310 template <typename Float>
311 void complexDotProduct(Float *a, Float *b, Float *c) {
312  a[0] = b[0]*c[0] + b[1]*c[1];
313  a[1] = b[0]*c[1] - b[1]*c[0];
314 }
315 
316 // a += b*c
317 template <typename Float>
318 void accumulateComplexProduct(Float *a, Float *b, Float *c, Float sign) {
319  a[0] += sign*(b[0]*c[0] - b[1]*c[1]);
320  a[1] += sign*(b[0]*c[1] + b[1]*c[0]);
321 }
322 
323 // a += conj(b)*c)
324 template <typename Float>
325 void accumulateComplexDotProduct(Float *a, Float *b, Float *c) {
326  a[0] += b[0]*c[0] + b[1]*c[1];
327  a[1] += b[0]*c[1] - b[1]*c[0];
328 }
329 
330 
331 template<typename Float>
332 int link_sanity_check_internal_8(Float* link, int dir, int ga_idx, QudaGaugeParam* gaugeParam, int oddBit)
333 {
334  int ret =0;
335 
336  Float ref_link_buf[18];
337  Float* ref = & ref_link_buf[0];
338  memset(ref, 0, sizeof(ref_link_buf));
339 
340  ref[0] = atan2(link[1], link[0]);
341  ref[1] = atan2(link[13], link[12]);
342  for (int i=2; i<7; i++) {
343  ref[i] = link[i];
344  }
345 
346  int X1h=gaugeParam->X[0]/2;
347  int X2 =gaugeParam->X[1];
348  int X3 =gaugeParam->X[2];
349  int X4 =gaugeParam->X[3];
350  double t_boundary = (gaugeParam->t_boundary ==QUDA_ANTI_PERIODIC_T)? -1.0:1.0;
351 
352 
353  // First reconstruct first row
354  Float row_sum = 0.0;
355  row_sum += ref[2]*ref[2];
356  row_sum += ref[3]*ref[3];
357  row_sum += ref[4]*ref[4];
358  row_sum += ref[5]*ref[5];
359 
360 #define SMALL_NUM 1e-24
361  row_sum = (row_sum != 0)?row_sum: SMALL_NUM;
362 #if 1
363  Float u0= -gaugeParam->tadpole_coeff*gaugeParam->tadpole_coeff*24;
364  {
365  int X1h=gaugeParam->X[0]/2;
366  int X1 =gaugeParam->X[0];
367  int X2 =gaugeParam->X[1];
368  int X3 =gaugeParam->X[2];
369  int X4 =gaugeParam->X[3];
370 
371  int index = fullLatticeIndex(ga_idx, oddBit);
372  int i4 = index /(X3*X2*X1);
373  int i3 = (index - i4*(X3*X2*X1))/(X2*X1);
374  int i2 = (index - i4*(X3*X2*X1) - i3*(X2*X1))/X1;
375  int i1 = index - i4*(X3*X2*X1) - i3*(X2*X1) - i2*X1;
376 
377  if (dir == 0) {
378  if (i4 % 2 == 1){
379  u0 *= -1;
380  }
381  }
382 
383  if (dir == 1){
384  if ((i1+i4) % 2 == 1){
385  u0 *= -1;
386  }
387  }
388  if (dir == 2){
389  if ( (i4+i1+i2) % 2 == 1){
390  u0 *= -1;
391  }
392  }
393  if (dir == 3){
394  if (ga_idx >= (X4-3)*X1h*X2*X3 ){
395  u0 *= -1;
396  }
397  }
398 
399  //printf("local ga_idx =%d, index=%d, i4,3,2,1 =%d %d %d %d\n", ga_idx, index, i4, i3, i2,i1);
400 
401  }
402 #endif
403 
404 
405  Float U00_mag = sqrt( (1.f/(u0*u0) - row_sum)>0? (1.f/(u0*u0)-row_sum):0);
406 
407  ref[14] = ref[0];
408  ref[15] = ref[1];
409 
410  ref[0] = U00_mag * cos(ref[14]);
411  ref[1] = U00_mag * sin(ref[14]);
412 
413  Float column_sum = 0.0;
414  for (int i=0; i<2; i++) column_sum += ref[i]*ref[i];
415  for (int i=6; i<8; i++) column_sum += ref[i]*ref[i];
416  Float U20_mag = sqrt( (1.f/(u0*u0) - column_sum) > 0? (1.f/(u0*u0)-column_sum) : 0);
417 
418  ref[12] = U20_mag * cos(ref[15]);
419  ref[13] = U20_mag * sin(ref[15]);
420 
421  // First column now restored
422 
423  // finally reconstruct last elements from SU(2) rotation
424  Float r_inv2 = 1.0/(u0*row_sum);
425 
426  // U11
427  Float A[2];
428  complexDotProduct(A, ref+0, ref+6);
429  complexConjugateProduct(ref+8, ref+12, ref+4);
430  accumulateComplexProduct(ref+8, A, ref+2, u0);
431  ref[8] *= -r_inv2;
432  ref[9] *= -r_inv2;
433 
434  // U12
435  complexConjugateProduct(ref+10, ref+12, ref+2);
436  accumulateComplexProduct(ref+10, A, ref+4, -u0);
437  ref[10] *= r_inv2;
438  ref[11] *= r_inv2;
439 
440  // U21
441  complexDotProduct(A, ref+0, ref+12);
442  complexConjugateProduct(ref+14, ref+6, ref+4);
443  accumulateComplexProduct(ref+14, A, ref+2, -u0);
444  ref[14] *= r_inv2;
445  ref[15] *= r_inv2;
446 
447  // U12
448  complexConjugateProduct(ref+16, ref+6, ref+2);
449  accumulateComplexProduct(ref+16, A, ref+4, u0);
450  ref[16] *= -r_inv2;
451  ref[17] *= -r_inv2;
452 
453  double delta = 0.0001;
454  int i;
455  for (i =0;i < 18; i++){
456 
457  double diff = ref[i] - link[i];
458  double absdiff = diff > 0? diff: (-diff);
459  if ( (ref[i] != ref[i]) || (absdiff > delta)){
460  printf("ERROR: sanity check failed for link\n");
461  display_link_internal(link);
462  printf("reconstructed link is\n");
463  display_link_internal(ref);
464  printf("dir=%d, ga_idx=%d, u0=%f, t_boundary=%f\n",dir, ga_idx, u0, t_boundary);
465  printf("X=%d %d %d %d, X1h=%d\n", gaugeParam->X[0], X2, X3, X4, X1h);
466  return -1;
467  }
468 
469  }
470 
471 
472  return ret;
473 }
474 
475 
476 //this len must be V
477 int
478 link_sanity_check(void* link, int len, int precision, int dir, QudaGaugeParam* gaugeParam)
479 {
480  int i;
481  int rc = 0;
482 
483  if (precision == QUDA_DOUBLE_PRECISION){
484  double* mylink = (double*)link;
485  //even
486  for (i = 0;i < len/2; i++){
487  rc = link_sanity_check_internal_12(mylink + gaugeSiteSize*i, dir, i, gaugeParam, 0);
488  if (rc != 0){
489  printf("ERROR: even link sanity check failed, i=%d\n",i);
490  display_link_internal(mylink+gaugeSiteSize*i);
491  exit(1);
492  }
493  }
494 
495  mylink = mylink + gaugeSiteSize*len/2;
496  //odd
497  for (i = 0;i < len/2; i++){
498  rc = link_sanity_check_internal_12(mylink + gaugeSiteSize*i, dir, i, gaugeParam, 1);
499  if (rc != 0){
500  printf("ERROR: odd link sanity check failed, i=%d\n",i);
501  display_link_internal(mylink+gaugeSiteSize*i);
502  exit(1);
503  }
504  }
505 
506  }else if (precision == QUDA_SINGLE_PRECISION){
507  float* mylink = (float*)link;
508 
509  //even
510  for (i=0;i < len/2 ;i++){
511  rc = link_sanity_check_internal_12(mylink + gaugeSiteSize*i, dir, i, gaugeParam, 0);
512  if (rc != 0){
513  printf("ERROR: even link sanity check 12 failed, i=%d\n",i);
514  exit(1);
515  }
516  /*
517  rc = link_sanity_check_internal_8(mylink + gaugeSiteSize*i, dir, i, gaugeParam, 0);
518  if (rc != 0){
519  printf("ERROR: even link sanity check 8 failed, i=%d\n",i);
520  exit(1);
521  }
522  */
523 
524  }
525  mylink = mylink + gaugeSiteSize*len/2;
526  //odd
527  for (i=0;i < len/2 ;i++){
528  rc = link_sanity_check_internal_12(mylink + gaugeSiteSize*i, dir, i, gaugeParam, 1);
529  if (rc != 0){
530  printf("ERROR: odd link sanity check 12 failed, i=%d\n", i);
531  exit(1);
532  }
533  /*
534  rc = link_sanity_check_internal_8(mylink + gaugeSiteSize*i, dir, i, gaugeParam, 0);
535  if (rc != 0){
536  printf("ERROR: even link sanity check 8 failed, i=%d\n",i);
537  exit(1);
538  }
539  */
540  }
541 
542  }
543 
544  return rc;
545 }
546 
547 
548 
549 //this len must be V
550 int
551 site_link_sanity_check(void* link, int len, int precision, QudaGaugeParam* gaugeParam)
552 {
553  int i;
554  int rc = 0;
555  int dir;
556 
557  if (precision == QUDA_DOUBLE_PRECISION){
558  double* mylink = (double*)link;
559  //even
560  for (i = 0;i < len/2; i++){
561  for(dir=XUP;dir <= TUP; dir++){
562  rc = site_link_sanity_check_internal_12(mylink + gaugeSiteSize*(4*i+dir), dir, i, gaugeParam, 0);
563  if (rc != 0){
564  printf("ERROR: even link sanity check failed, i=%d, function %s\n",i, __FUNCTION__);
565  display_link_internal(mylink+gaugeSiteSize*i);
566  exit(1);
567  }
568  }
569  }
570 
571  mylink = mylink + 4*gaugeSiteSize*len/2;
572  //odd
573  for (i = 0;i < len/2; i++){
574  for(dir=XUP;dir <= TUP; dir++){
575  rc = site_link_sanity_check_internal_12(mylink + gaugeSiteSize*(4*i+dir), dir, i, gaugeParam, 1);
576  if (rc != 0){
577  printf("ERROR: odd link sanity check failed, i=%d, function %s\n",i, __FUNCTION__);
578  display_link_internal(mylink+gaugeSiteSize*i);
579  exit(1);
580  }
581  }
582  }
583 
584  }else if (precision == QUDA_SINGLE_PRECISION){
585  float* mylink = (float*)link;
586 
587  //even
588  for (i=0;i < len/2 ;i++){
589  for(dir=XUP;dir <= TUP; dir++){
590  rc = site_link_sanity_check_internal_12(mylink + gaugeSiteSize*(4*i+dir), dir, i, gaugeParam, 0);
591  if (rc != 0){
592  printf("ERROR: even link sanity check 12 failed, i=%d, function %s\n",i, __FUNCTION__);
593  exit(1);
594  }
595  }
596  }
597  mylink = mylink + 4*gaugeSiteSize*len/2;
598  //odd
599  for (i=0;i < len/2 ;i++){
600  for(dir=XUP;dir <= TUP; dir++){
601  rc = site_link_sanity_check_internal_12(mylink + gaugeSiteSize*(4*i+dir), dir, i, gaugeParam, 1);
602  if (rc != 0){
603  printf("ERROR: odd link sanity check 12 failed, i=%d, function %s\n", i, __FUNCTION__);
604  exit(1);
605  }
606  }
607  }
608 
609  }
610 
611  return rc;
612 }
613 
614 
615 QudaReconstructType
616 get_recon(char* s)
617 {
618  QudaReconstructType ret;
619 
620  if (strcmp(s, "8") == 0){
621  ret = QUDA_RECONSTRUCT_8;
622  }else if (strcmp(s, "12") == 0){
623  ret = QUDA_RECONSTRUCT_12;
624  }else if (strcmp(s, "18") == 0){
625  ret = QUDA_RECONSTRUCT_NO;
626  }else{
627  fprintf(stderr, "Error: invalid reconstruct type\n");
628  exit(1);
629  }
630 
631  return ret;
632 
633 
634 }
635 
636 QudaPrecision
637 get_prec(char* s)
638 {
639  QudaPrecision ret = QUDA_DOUBLE_PRECISION;
640 
641  if (strcmp(s, "double") == 0){
642  ret = QUDA_DOUBLE_PRECISION;
643  }else if (strcmp(s, "single") == 0){
644  ret = QUDA_SINGLE_PRECISION;
645  }else if (strcmp(s, "half") == 0){
646  ret = QUDA_HALF_PRECISION;
647  }else{
648  fprintf(stderr, "Error: invalid precision type\n");
649  exit(1);
650  }
651 
652  return ret;
653 }
654 
655 const char*
656 get_prec_str(QudaPrecision prec)
657 {
658  const char* ret;
659 
660  switch( prec){
661 
662  case QUDA_DOUBLE_PRECISION:
663  ret= "double";
664  break;
665  case QUDA_SINGLE_PRECISION:
666  ret= "single";
667  break;
668  case QUDA_HALF_PRECISION:
669  ret= "half";
670  break;
671  default:
672  ret = "unknown";
673  break;
674  }
675 
676 
677  return ret;
678 }
679 
680 
681 const char*
682 get_unitarization_str(bool svd_only)
683 {
684  const char* ret;
685 
686  if(svd_only){
687  ret = "SVD";
688  }else{
689  ret = "Cayley-Hamilton/SVD";
690  }
691  return ret;
692 }
693 
694 const char*
695 get_gauge_order_str(QudaGaugeFieldOrder order)
696 {
697  const char* ret;
698 
699  switch(order){
700  case QUDA_QDP_GAUGE_ORDER:
701  ret = "qdp";
702  break;
703 
704  case QUDA_MILC_GAUGE_ORDER:
705  ret = "milc";
706  break;
707 
708  case QUDA_CPS_WILSON_GAUGE_ORDER:
709  ret = "cps_wilson";
710  break;
711 
712  default:
713  ret = "unknown";
714  break;
715  }
716 
717  return ret;
718 }
719 
720 
721 const char*
722 get_recon_str(QudaReconstructType recon)
723 {
724  const char* ret;
725  switch(recon){
726  case QUDA_RECONSTRUCT_12:
727  ret= "12";
728  break;
729  case QUDA_RECONSTRUCT_8:
730  ret = "8";
731  break;
732  case QUDA_RECONSTRUCT_NO:
733  ret = "18";
734  break;
735  default:
736  ret="unknown";
737  break;
738  }
739 
740  return ret;
741 }
742 
743 const char*
744 get_test_type(int t)
745 {
746  const char* ret;
747  switch(t){
748  case 0:
749  ret = "even";
750  break;
751  case 1:
752  ret = "odd";
753  break;
754  case 2:
755  ret = "full";
756  break;
757  case 3:
758  ret = "mcg_even";
759  break;
760  case 4:
761  ret = "mcg_odd";
762  break;
763  case 5:
764  ret = "mcg_full";
765  break;
766  default:
767  ret = "unknown";
768  break;
769  }
770 
771  return ret;
772 }
773 
774 QudaDslashType
775 get_dslash_type(char* s)
776 {
777  QudaDslashType ret = QUDA_INVALID_DSLASH;
778 
779  if (strcmp(s, "wilson") == 0){
780  ret = QUDA_WILSON_DSLASH;
781  }else if (strcmp(s, "clover") == 0){
782  ret = QUDA_CLOVER_WILSON_DSLASH;
783  }else if (strcmp(s, "twisted_mass") == 0){
784  ret = QUDA_TWISTED_MASS_DSLASH;
785  }else if (strcmp(s, "asqtad") == 0){
786  ret = QUDA_ASQTAD_DSLASH;
787  }else if (strcmp(s, "domain_wall") == 0){
788  ret = QUDA_DOMAIN_WALL_DSLASH;
789  }else{
790  fprintf(stderr, "Error: invalid dslash type\n");
791  exit(1);
792  }
793 
794  return ret;
795 }
796 
797 const char*
798 get_dslash_type_str(QudaDslashType type)
799 {
800  const char* ret;
801 
802  switch( type){
803  case QUDA_WILSON_DSLASH:
804  ret= "wilson";
805  break;
806  case QUDA_CLOVER_WILSON_DSLASH:
807  ret= "clover";
808  break;
809  case QUDA_TWISTED_MASS_DSLASH:
810  ret= "twisted_mass";
811  break;
812  case QUDA_ASQTAD_DSLASH:
813  ret = "asqtad";
814  break;
815  case QUDA_DOMAIN_WALL_DSLASH:
816  ret = "domain_wall";
817  break;
818  default:
819  ret = "unknown";
820  break;
821  }
822 
823 
824  return ret;
825 
826 }
827 
828 const char*
829 get_quda_ver_str()
830 {
831  static char vstr[32];
832  int major_num = QUDA_VERSION_MAJOR;
833  int minor_num = QUDA_VERSION_MINOR;
834  int ext_num = QUDA_VERSION_SUBMINOR;
835  sprintf(vstr, "%1d.%1d.%1d",
836  major_num,
837  minor_num,
838  ext_num);
839  return vstr;
840 }
841 
Generated on Wed Mar 20 2013 12:52:18 for QUDA by   doxygen 1.8.2