-
Notifications
You must be signed in to change notification settings - Fork 104
/
Copy pathdirac_quda.h
1170 lines (945 loc) · 44.3 KB
/
dirac_quda.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#ifndef _DIRAC_QUDA_H
#define _DIRAC_QUDA_H
#include <quda_internal.h>
#include <color_spinor_field.h>
#include <gauge_field.h>
#include <clover_field.h>
#include <dslash_quda.h>
#include <blas_quda.h>
#include <typeinfo>
namespace quda {
class Transfer;
class Dirac;
// Params for Dirac operator
class DiracParam {
public:
QudaDiracType type;
double kappa;
double mass;
double m5; // used by domain wall only
int Ls; //!NEW: used by domain wall and twisted mass
double b_5[QUDA_MAX_DWF_LS]; //!NEW: used by mobius domain wall only
double c_5[QUDA_MAX_DWF_LS]; //!NEW: used by mobius domain wall only
QudaMatPCType matpcType;
QudaDagType dagger;
cudaGaugeField *gauge;
cudaGaugeField *fatGauge; // used by staggered only
cudaGaugeField *longGauge; // used by staggered only
cudaCloverField *clover;
double mu; // used by twisted mass only
double mu_factor; // used by multigrid only
double epsilon; //2nd tm parameter (used by twisted mass only)
ColorSpinorField *tmp1;
ColorSpinorField *tmp2; // used by Wilson-like kernels only
int commDim[QUDA_MAX_DIM]; // whether to do comms or not
// for multigrid only
Transfer *transfer;
Dirac *dirac;
DiracParam()
: type(QUDA_INVALID_DIRAC), kappa(0.0), m5(0.0), matpcType(QUDA_MATPC_INVALID),
dagger(QUDA_DAG_INVALID), gauge(0), clover(0), mu(0.0), mu_factor(0.0), epsilon(0.0),
tmp1(0), tmp2(0)
{
}
void print() {
printfQuda("Printing DslashParam\n");
printfQuda("type = %d\n", type);
printfQuda("kappa = %g\n", kappa);
printfQuda("mass = %g\n", mass);
printfQuda("m5 = %g\n", m5);
printfQuda("Ls = %d\n", Ls);
printfQuda("matpcType = %d\n", matpcType);
printfQuda("dagger = %d\n", dagger);
printfQuda("mu = %g\n", mu);
printfQuda("epsilon = %g\n", epsilon);
for (int i=0; i<QUDA_MAX_DIM; i++) printfQuda("commDim[%d] = %d\n", i, commDim[i]);
for (int i=0; i<Ls; i++) printfQuda("b_5[%d] = %e\t c_5[%d] = %e\n", i,b_5[i],i,c_5[i]);
}
};
void setDiracParam(DiracParam &diracParam, QudaInvertParam *inv_param, bool pc);
void setDiracSloppyParam(DiracParam &diracParam, QudaInvertParam *inv_param, bool pc);
// forward declarations
class DiracMatrix;
class DiracM;
class DiracMdagM;
class DiracMMdag;
class DiracMdag;
//Forward declaration of multigrid Transfer class
class Transfer;
// Abstract base class
class Dirac : public Object {
friend class DiracMatrix;
friend class DiracM;
friend class DiracMdagM;
friend class DiracMMdag;
friend class DiracMdag;
protected:
cudaGaugeField *gauge;
double kappa;
double mass;
QudaMatPCType matpcType;
mutable QudaDagType dagger; // mutable to simplify implementation of Mdag
mutable unsigned long long flops;
mutable ColorSpinorField *tmp1; // temporary hack
mutable ColorSpinorField *tmp2; // temporary hack
QudaDiracType type;
bool newTmp(ColorSpinorField **, const ColorSpinorField &) const;
void deleteTmp(ColorSpinorField **, const bool &reset) const;
QudaTune tune;
int commDim[QUDA_MAX_DIM]; // whether do comms or not
mutable TimeProfile profile;
public:
Dirac(const DiracParam ¶m);
Dirac(const Dirac &dirac);
virtual ~Dirac();
Dirac& operator=(const Dirac &dirac);
virtual void checkParitySpinor(const ColorSpinorField &, const ColorSpinorField &) const;
virtual void checkFullSpinor(const ColorSpinorField &, const ColorSpinorField &) const;
void checkSpinorAlias(const ColorSpinorField &, const ColorSpinorField &) const;
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const = 0;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x,
const double &k) const = 0;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const = 0;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const = 0;
void Mdag(ColorSpinorField &out, const ColorSpinorField &in) const;
void MMdag(ColorSpinorField &out, const ColorSpinorField &in) const;
// required methods to use e-o preconditioning for solving full system
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const = 0;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const = 0;
void setMass(double mass){ this->mass = mass;}
// Dirac operator factory
static Dirac* create(const DiracParam ¶m);
double Kappa() const { return kappa; }
virtual double Mu() const { return 0.; }
virtual double MuFactor() const { return 0.; }
unsigned long long Flops() const { unsigned long long rtn = flops; flops = 0; return rtn; }
QudaMatPCType getMatPCType() const { return matpcType; }
int getStencilSteps() const;
void Dagger(QudaDagType dag) const { dagger = dag; }
/**
* @brief Create the coarse operator (virtual parent)
*
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat[out] Coarse preconditioned link field
* @param T[in] Transfer operator defining the coarse grid
* @param kappa Kappa parameter for the coarse operator
* @param mu TM mu parameter for the coarse operator
* @param mu_factor multiplicative factor for the mu parameter
*/
virtual void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu=0., double mu_factor=0.) const
{errorQuda("Not implemented");}
};
// Full Wilson
class DiracWilson : public Dirac {
protected:
void initConstants();
public:
DiracWilson(const DiracParam ¶m);
DiracWilson(const DiracWilson &dirac);
DiracWilson(const DiracParam ¶m, const int nDims);//to correctly adjust face for DW and non-deg twisted mass
virtual ~DiracWilson();
DiracWilson& operator=(const DiracWilson &dirac);
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
/**
* @brief Create the coarse Wilson operator
*
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat[out] Coarse preconditioned link field
* @param T[in] Transfer operator defining the coarse grid
* @param kappa Kappa parameter for the coarse operator
*/
virtual void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu=0., double mu_factor=0.) const;
};
// Even-odd preconditioned Wilson
class DiracWilsonPC : public DiracWilson {
private:
public:
DiracWilsonPC(const DiracParam ¶m);
DiracWilsonPC(const DiracWilsonPC &dirac);
virtual ~DiracWilsonPC();
DiracWilsonPC& operator=(const DiracWilsonPC &dirac);
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// Full clover
class DiracClover : public DiracWilson {
protected:
cudaCloverField &clover;
void checkParitySpinor(const ColorSpinorField &, const ColorSpinorField &) const;
void initConstants();
public:
DiracClover(const DiracParam ¶m);
DiracClover(const DiracClover &dirac);
virtual ~DiracClover();
DiracClover& operator=(const DiracClover &dirac);
void Clover(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
const ColorSpinorField &x, const double &k) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
/**
* @brief Create the coarse clover operator
*
* @param T[in] Transfer operator defining the coarse grid
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat coarse preconditioned link field
* @param kappa Kappa parameter for the coarse operator
*/
void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu=0., double mu_factor=0.) const;
};
// Even-odd preconditioned clover
class DiracCloverPC : public DiracClover {
public:
DiracCloverPC(const DiracParam ¶m);
DiracCloverPC(const DiracCloverPC &dirac);
virtual ~DiracCloverPC();
DiracCloverPC& operator=(const DiracCloverPC &dirac);
void CloverInv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const;
void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
/**
* @brief Create the coarse even-odd preconditioned clover
* operator. Unlike the Wilson operator, the coarsening of the
* preconditioned clover operator differs from that of the
* unpreconditioned clover operator, so we need to specialize it.
*
* @param T[in] Transfer operator defining the coarse grid
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat coarse preconditioned link field
* @param kappa Kappa parameter for the coarse operator
*/
void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu=0., double mu_factor=0.) const;
};
// Full domain wall
class DiracDomainWall : public DiracWilson {
protected:
double m5;
double kappa5;
int Ls; // length of the fifth dimension
public:
DiracDomainWall(const DiracParam ¶m);
DiracDomainWall(const DiracDomainWall &dirac);
virtual ~DiracDomainWall();
DiracDomainWall& operator=(const DiracDomainWall &dirac);
void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const;
void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// 5d Even-odd preconditioned domain wall
class DiracDomainWallPC : public DiracDomainWall {
private:
public:
DiracDomainWallPC(const DiracParam ¶m);
DiracDomainWallPC(const DiracDomainWallPC &dirac);
virtual ~DiracDomainWallPC();
DiracDomainWallPC& operator=(const DiracDomainWallPC &dirac);
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// 4d Even-odd preconditioned domain wall
class DiracDomainWall4DPC : public DiracDomainWallPC {
private:
public:
DiracDomainWall4DPC(const DiracParam ¶m);
DiracDomainWall4DPC(const DiracDomainWall4DPC &dirac);
virtual ~DiracDomainWall4DPC();
DiracDomainWall4DPC& operator=(const DiracDomainWall4DPC &dirac);
void Dslash4(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
void Dslash5(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
void Dslash5inv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity, const double &kappa5) const;
void Dslash4Xpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
void Dslash5Xpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
void Dslash5invXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const double &kappa5, const ColorSpinorField &x, const double &k) const;
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// Full Mobius
class DiracMobius : public DiracDomainWall {
protected:
//Mobius coefficients
double b_5[QUDA_MAX_DWF_LS];
double c_5[QUDA_MAX_DWF_LS];
public:
DiracMobius(const DiracParam ¶m);
DiracMobius(const DiracMobius &dirac);
virtual ~DiracMobius();
DiracMobius& operator=(const DiracMobius &dirac);
void Dslash4(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
void Dslash4pre(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
void Dslash5(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
void Dslash4Xpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
void Dslash4preXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
const ColorSpinorField &x, const double &k) const;
void Dslash5Xpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// 4d Even-odd preconditioned Mobius domain wall
class DiracMobiusPC : public DiracMobius {
protected:
private:
public:
DiracMobiusPC(const DiracParam ¶m);
DiracMobiusPC(const DiracMobiusPC &dirac);
virtual ~DiracMobiusPC();
DiracMobiusPC& operator=(const DiracMobiusPC &dirac);
void Dslash5inv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
void Dslash5invXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol, ColorSpinorField &x,
ColorSpinorField &b, const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b, const QudaSolutionType) const;
};
// Full twisted mass
class DiracTwistedMass : public DiracWilson {
protected:
double mu;
double epsilon;
void twistedApply(ColorSpinorField &out, const ColorSpinorField &in,
const QudaTwistGamma5Type twistType) const;
void TwistedDslash(ColorSpinorField &out, const ColorSpinorField &in,
QudaParity parity, QudaTwistDslashType twistDslashType,
double a, double b, double c, double d) const;
void TwistedDslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const ColorSpinorField &x, QudaParity parity,
QudaTwistDslashType twistDslashType,
double a, double b, double c, double d) const;
void NdegTwistedDslash(ColorSpinorField &out, const ColorSpinorField &in,
QudaParity parity, QudaTwistDslashType twistDslashType,
double a, double b, double c, double d) const;
void NdegTwistedDslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const ColorSpinorField &x, QudaParity parity, QudaTwistDslashType twistDslashType,
double a, double b, double c, double d) const;
public:
DiracTwistedMass(const DiracTwistedMass &dirac);
DiracTwistedMass(const DiracParam ¶m, const int nDim);
virtual ~DiracTwistedMass();
DiracTwistedMass& operator=(const DiracTwistedMass &dirac);
void Twist(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
double Mu() const { return mu; }
/**
* @brief Create the coarse twisted-mass operator
*
* @param T[in] Transfer operator defining the coarse grid
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat coarse preconditioned link field
* @param kappa Kappa parameter for the coarse operator
* @param mu TM mu parameter for the coarse operator
* @param mu_factor multiplicative factor for the mu parameter
*/
void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu, double mu_factor=0.) const;
};
// Even-odd preconditioned twisted mass
class DiracTwistedMassPC : public DiracTwistedMass {
public:
DiracTwistedMassPC(const DiracTwistedMassPC &dirac);
DiracTwistedMassPC(const DiracParam ¶m, const int nDim);
virtual ~DiracTwistedMassPC();
DiracTwistedMassPC& operator=(const DiracTwistedMassPC &dirac);
void TwistInv(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
/**
* @brief Create the coarse even-odd preconditioned twisted-mass
* operator
* @param T[in] Transfer operator defining the coarse grid
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat coarse preconditioned link field
* @param kappa Kappa parameter for the coarse operator
* @param mu TM mu parameter for the coarse operator
* @param mu_factor multiplicative factor for the mu parameter
*/
void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu, double mu_factor=0.) const;
};
// Full twisted mass with a clover term
class DiracTwistedClover : public DiracWilson {
protected:
double mu;
double epsilon;
cudaCloverField &clover;
void checkParitySpinor(const ColorSpinorField &, const ColorSpinorField &) const;
void twistedCloverApply(ColorSpinorField &out, const ColorSpinorField &in,
const QudaTwistGamma5Type twistType, const int parity) const;
public:
DiracTwistedClover(const DiracTwistedClover &dirac);
DiracTwistedClover(const DiracParam ¶m, const int nDim);
virtual ~DiracTwistedClover();
DiracTwistedClover& operator=(const DiracTwistedClover &dirac);
void TwistClover(ColorSpinorField &out, const ColorSpinorField &in, const int parity) const; //IS PARITY REQUIRED???
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
double Mu() const { return mu; }
/**
* @brief Create the coarse twisted-clover operator
*
* @param T[in] Transfer operator defining the coarse grid
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat coarse preconditioned link field
* @param kappa Kappa parameter for the coarse operator
* @param mu TM mu parameter for the coarse operator
* @param mu_factor multiplicative factor for the mu parameter
*/
void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu, double mu_factor=0.) const;
};
// Even-odd preconditioned twisted mass with a clover term
class DiracTwistedCloverPC : public DiracTwistedClover {
public:
DiracTwistedCloverPC(const DiracTwistedCloverPC &dirac);
DiracTwistedCloverPC(const DiracParam ¶m, const int nDim);
virtual ~DiracTwistedCloverPC();
DiracTwistedCloverPC& operator=(const DiracTwistedCloverPC &dirac);
void TwistCloverInv(ColorSpinorField &out, const ColorSpinorField &in, const int parity) const;
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
/**
* @brief Create the coarse even-odd preconditioned twisted-clover
* operator. Unlike the Wilson operator, the coarsening of the
* preconditioned clover operator differs from that of the
* unpreconditioned clover operator, so we need to specialize it.
*
* @param T[in] Transfer operator defining the coarse grid
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat coarse preconditioned link field
* @param kappa Kappa parameter for the coarse operator
* @param mu TM mu parameter for the coarse operator
* @param mu_factor multiplicative factor for the mu parameter
*/
void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu, double mu_factor=0.) const;
};
// Full staggered
class DiracStaggered : public Dirac {
protected:
public:
DiracStaggered(const DiracParam ¶m);
DiracStaggered(const DiracStaggered &dirac);
virtual ~DiracStaggered();
DiracStaggered& operator=(const DiracStaggered &dirac);
virtual void checkParitySpinor(const ColorSpinorField &, const ColorSpinorField &) const;
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// Even-odd preconditioned staggered
class DiracStaggeredPC : public DiracStaggered {
protected:
public:
DiracStaggeredPC(const DiracParam ¶m);
DiracStaggeredPC(const DiracStaggeredPC &dirac);
virtual ~DiracStaggeredPC();
DiracStaggeredPC& operator=(const DiracStaggeredPC &dirac);
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// Full staggered
class DiracImprovedStaggered : public Dirac {
protected:
cudaGaugeField &fatGauge;
cudaGaugeField &longGauge;
public:
DiracImprovedStaggered(const DiracParam ¶m);
DiracImprovedStaggered(const DiracImprovedStaggered &dirac);
virtual ~DiracImprovedStaggered();
DiracImprovedStaggered& operator=(const DiracImprovedStaggered &dirac);
virtual void checkParitySpinor(const ColorSpinorField &, const ColorSpinorField &) const;
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// Even-odd preconditioned staggered
class DiracImprovedStaggeredPC : public DiracImprovedStaggered {
protected:
public:
DiracImprovedStaggeredPC(const DiracParam ¶m);
DiracImprovedStaggeredPC(const DiracImprovedStaggeredPC &dirac);
virtual ~DiracImprovedStaggeredPC();
DiracImprovedStaggeredPC& operator=(const DiracImprovedStaggeredPC &dirac);
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
/**
This class serves as a front-end to the coarse Dslash operator,
similar to the other dslash operators.
*/
class DiracCoarse : public Dirac {
protected:
double mu;
double mu_factor;
const Transfer *transfer; /** restrictor / prolongator defined here */
const Dirac *dirac; /** Parent Dirac operator */
cpuGaugeField *Y_h; /** CPU copy of the coarse link field */
cpuGaugeField *X_h; /** CPU copy of the coarse clover term */
cpuGaugeField *Xinv_h; /** CPU copy of the inverse coarse clover term */
cpuGaugeField *Yhat_h; /** CPU copy of the preconditioned coarse link field */
cudaGaugeField *Y_d; /** GPU copy of the coarse link field */
cudaGaugeField *X_d; /** GPU copy of the coarse clover term */
cudaGaugeField *Xinv_d; /** GPU copy of inverse coarse clover term */
cudaGaugeField *Yhat_d; /** GPU copy of the preconditioned coarse link field */
void initializeCoarse(); /** Initialize the coarse gauge field */
bool enable_gpu; /** Whether to enable this operator for the GPU */
bool init; /** Whether this instance did the allocation or not */
public:
double Mu() const { return mu; }
double MuFactor() const { return mu_factor; }
/**
@param[in] param Parameters defining this operator
@param[in] enable_gpu Whether to enable this operator for the GPU
*/
DiracCoarse(const DiracParam ¶m, bool enable_gpu=true);
/**
@param[in] param Parameters defining this operator
@param[in] Y_h CPU coarse link field
@param[in] X_h CPU coarse clover field
@param[in] Xinv_h CPU coarse inverse clover field
@param[in] Yhat_h CPU coarse preconditioned link field
@param[in] Y_d GPU coarse link field
@param[in] X_d GPU coarse clover field
@param[in] Xinv_d GPU coarse inverse clover field
@param[in] Yhat_d GPU coarse preconditioned link field
*/
DiracCoarse(const DiracParam ¶m,
cpuGaugeField *Y_h, cpuGaugeField *X_h, cpuGaugeField *Xinv_h, cpuGaugeField *Yhat_h,
cudaGaugeField *Y_d=0, cudaGaugeField *X_d=0, cudaGaugeField *Xinv_d=0, cudaGaugeField *Yhat_d=0);
/**
@param[in] dirac Another operator instance to clone from (shallow copy)
@param[in] param Parameters defining this operator
*/
DiracCoarse(const DiracCoarse &dirac, const DiracParam ¶m);
virtual ~DiracCoarse();
/**
@brief Apply the coarse clover operator
@param[out] out Output field
@param[in] in Input field
@param[paraity] parity Parity which we are applying the operator to
*/
void Clover(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
/**
@brief Apply the inverse coarse clover operator
@param[out] out Output field
@param[in] in Input field
@param[paraity] parity Parity which we are applying the operator to
*/
void CloverInv(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
/**
@brief Apply DslashXpay out = (D * in)
@param[out] out Output field
@param[in] in Input field
@param[paraity] parity Parity which we are applying the operator to
*/
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity) const;
/**
@brief Apply DslashXpay out = (D * in + A * x)
@param[out] out Output field
@param[in] in Input field
@param[paraity] parity Parity which we are applying the operator to
*/
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
const ColorSpinorField &x, const double &k) const;
/**
@brief Apply the full operator
@param[out] out output vector, out = M * in
@param[in] in input vector
*/
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol, ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b, const QudaSolutionType) const;
/**
* @brief Create the coarse operator from this coarse operator
*
* @param T[in] Transfer operator defining the coarse grid
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat[out] Coarse preconditioned link field
* @param kappa Kappa parameter for the coarse operator
* @param mu TM mu parameter for the coarse operator
* @param mu_factor multiplicative factor for the mu parameter
*/
void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu, double mu_factor=0.) const;
};
/**
Even-odd preconditioned variant of coarse Dslash operator
*/
class DiracCoarsePC : public DiracCoarse {
public:
DiracCoarsePC(const DiracParam ¶m, bool enable_gpu=true);
DiracCoarsePC(const DiracCoarse &dirac, const DiracParam ¶m);
virtual ~DiracCoarsePC();
void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity,
const ColorSpinorField &x, const double &k) const;
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol, ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b, const QudaSolutionType) const;
/**
* @brief Create the coarse even-odd preconditioned coarse
* operator. Unlike the Wilson operator, the coarsening of the
* preconditioned coarse operator differs from that of the
* unpreconditioned coarse operator, so we need to specialize it.
*
* @param T[in] Transfer operator defining the coarse grid
* @param Y[out] Coarse link field
* @param X[out] Coarse clover field
* @param Xinv[out] Coarse clover inverse field
* @param Yhat coarse preconditioned link field
* @param kappa Kappa parameter for the coarse operator
* @param mu TM mu parameter for the coarse operator
* @param mu_factor multiplicative factor for the mu parameter
*/
void createCoarseOp(GaugeField &Y, GaugeField &X, GaugeField &Xinv, GaugeField &Yhat, const Transfer &T, double kappa, double mu, double mu_factor=0.) const;
};
/**
@brief Full Gauge Laplace operator. Although not a Dirac
operator per se, it's a linear operator so it's conventient to
put in the Dirac operator abstraction.
*/
class GaugeLaplace : public Dirac {
public:
GaugeLaplace(const DiracParam ¶m);
GaugeLaplace(const GaugeLaplace &laplace);
virtual ~GaugeLaplace();
GaugeLaplace& operator=(const GaugeLaplace &laplace);
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
/**
@brief Even-odd preconditioned Gauge Laplace operator
*/
class GaugeLaplacePC : public GaugeLaplace {
public:
GaugeLaplacePC(const DiracParam ¶m);
GaugeLaplacePC(const GaugeLaplacePC &laplace);
virtual ~GaugeLaplacePC();
GaugeLaplacePC& operator=(const GaugeLaplacePC &laplace);
void M(ColorSpinorField &out, const ColorSpinorField &in) const;
void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
void reconstruct(ColorSpinorField &x, const ColorSpinorField &b, const QudaSolutionType) const;
};
/**
@brief Full Covariant Derivative operator. Although not a Dirac
operator per se, it's a linear operator so it's conventient to
put in the Dirac operator abstraction.
*/
class GaugeCovDev : public Dirac {
public:
GaugeCovDev(const DiracParam ¶m);
GaugeCovDev(const GaugeCovDev &covDev);
virtual ~GaugeCovDev();
GaugeCovDev& operator=(const GaugeCovDev &covDev);
virtual void DslashCD(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity, const int mu) const;
virtual void MCD(ColorSpinorField &out, const ColorSpinorField &in, const int mu) const;
virtual void MdagMCD(ColorSpinorField &out, const ColorSpinorField &in, const int mu) const;
virtual void Dslash(ColorSpinorField &out, const ColorSpinorField &in, const QudaParity parity) const;
virtual void DslashXpay(ColorSpinorField &out, const ColorSpinorField &in,
const QudaParity parity, const ColorSpinorField &x, const double &k) const;
virtual void M(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void MdagM(ColorSpinorField &out, const ColorSpinorField &in) const;
virtual void prepare(ColorSpinorField* &src, ColorSpinorField* &sol,
ColorSpinorField &x, ColorSpinorField &b,
const QudaSolutionType) const;
virtual void reconstruct(ColorSpinorField &x, const ColorSpinorField &b,
const QudaSolutionType) const;
};
// Functor base class for applying a given Dirac matrix (M, MdagM, etc.)
class DiracMatrix {
protected:
const Dirac *dirac;
public:
DiracMatrix(const Dirac &d) : dirac(&d) { }
DiracMatrix(const Dirac *d) : dirac(d) { }
virtual ~DiracMatrix() { }
virtual void operator()(ColorSpinorField &out, const ColorSpinorField &in) const = 0;
virtual void operator()(ColorSpinorField &out, const ColorSpinorField &in,
ColorSpinorField &tmp) const = 0;
virtual void operator()(ColorSpinorField &out, const ColorSpinorField &in,
ColorSpinorField &Tmp1, ColorSpinorField &Tmp2) const = 0;
unsigned long long flops() const { return dirac->Flops(); }
QudaMatPCType getMatPCType() const { return dirac->getMatPCType(); }
virtual int getStencilSteps() const = 0;