simulation monte-carlo d’une th eorie de jauge su(2) · simulation monte-carlo d’une th eorie...

13
Simulation Monte-Carlo d’une th´ eorie de jauge SU(2) Antonin Portelli sujet propos´ e par Laurent Lellouch Des ph´ enom` enes comme le confinement des quarks dans les hadrons motivent ` a effectuer une ´ etude non perturbative des th´ eories de jauge non ab´ eliennes. On d´ efinit une th´ eorie de jauge dans un espace-temps discret en s’assurant que l’invariance de jauge soit conserv´ ee et que la limite vers le continu restitue bien la th´ eorie de Yang-Mills. Un algorithme permettant d’´ evaluer l’int´ egrale de chemin de cette th´ eorie est ´ elabor´ e pour le groupe de jauge SU(2), puis son impl´ ementation en C++ dans un contexte orient´ e objet est discut´ ee. On valide le mod` ele en le confrontant `a des donn´ ees th´ eoriques puis on l’utilise pour ´ evaluer la tension de corde, quantit´ e physique responsable du confinement des quarks. 1. MOTIVATIONS A basse ´ energie, la constante de couplage de la QCD est trop ´ elev´ ee pour que les effets perturbatifs de la th´ eorie soient dominant. Ceci interdit le calcul des in- teractions ` a partir d’un d´ eveloppement en diagrammes de Feynman et motive ` a entamer une ´ etude non per- turbative de la th´ eorie. De plus certains ph´ enom` enes observ´ es exp´ erimentalement, comme le confinement des quarks dans les hadrons, semblent impr´ evisibles par des ethodes perturbatives et doivent ˆ etre de fait des ef- fets purement non perturbatifs de la th´ eorie. Les th´ eories quantiques de champs bas´ ees sur les sym´ etries de jauge se d´ efinissent de fa¸con physique et correct sur un espace- temps continu par le biais de la renormalisation, or le processus de renormalisation est essentiellement bas´ e sur l’analyse de la structure pertubative d’une th´ eorie. C’est pour surmonter ce probl` eme que Wilson proposera en 1974 une ´ etude non perturbative des th´ eories de jauge sur un espace temps discret (o` u eseau ), cette ´ etude mon- trera le ph´ enom` ene de confinement dans la limite d’un couplage fort. C’est rapidement (en 1980) que Creutz proposera des m´ ethodes de simulations num´ eriques de la th´ eorie discr` ete de Wilson. Le travail qui suit est enti` erement bas´ e sur ces approches. 2. TH ´ EORIES DE JAUGE SUR R ´ ESEAU On consid` ere d’un champ de mati` ere ` a ψ poss´ edant un ”espace interne” dans la repr´ esentation fondamentale d’un groupe G de matrices unitaires de dimension n c . Une transformation de jauge locale de ψ est d´ efinie par ψ(x) 7g(x)ψ(x) , o` u g(x) est un ´ el´ ement de G. Dans le lagrangien de Dirac : L D = ψ(i/ - m)ψ (1) les termes de la forme ψ∂ μ ψ ne sont pas invariants par une transformation de jauge locale, ce qui conduit ` a l’in- troduction d’un nouveau champ (le champ de jauge ) afin d’obtenir une th´ eorie invariante de jauge. Une m´ ethode est de remplacer la d´ eriv´ ee standard : μ ψ(x) = lim ε0 1 ε (ψ(x + ε) - ψ(x)) (2) par une eriv´ ee covariante : D μ ψ(x) = lim ε0 1 ε (U (x, x + ε)ψ(x + ε) - ψ(x)) (3) o` u U (x, x +ε) est un ´ el´ ement de G dont la transformation de jauge est d´ efinie par U (x, y) 7g(x)U (x, y)g(y) -1 . On peut ensuite d´ efinir le champ de jauge en x en effectuant le d´ eveloppement infinit´ esimal de U (x, x + ε), ce champ en x sera un ´ el´ ement de l’alg` ebre de Lie de G. C’est cette quantit´ e U (x, y) qui va permettre de d´ efinir la th´ eorie discr` ete. 2.1. Construction On consid` ere comme variable de la th´ eorie sur r´ eseau un champ U sur l’ensemble des couples d’´ el´ ements voisins (ou liens )du r´ eseau L a = a(Z/N Z) 4 ` a valeurs dans G. Les ´ el´ ements de L a seront appel´ es sites du r´ eseau. On appellera plaquette de L a tout quadruplet (i, j, k, l) de sites tels que (i, j ), (j, k), (k,l) et (l, i) soient des liens de L a . On suppose de plus que U erifie : U ij = U -1 ji = U ji (4) On d´ efini la th´ eorie classique par le lagrangien : L ()= β ï 1 - 1 n c < tr(U ij U jk U kl U li ) ò (5) o` u =(i, j, k, l) est une plaquette de L a . L’action S issue de L est donn´ ee par : S = X L () (6) L’int´ egrale de chemin de la th´ eorie quantique associ´ ee ` a L peut-ˆ etre d´ efinie simplement par une puissance de la mesure de Haar normalis´ ee de G : DU =d g (7) o` u =4N 4 est le nombre de liens de L a . Si O (U ) est une fonction de corr´ elation euclidienne de la th´ eorie, alors sa valeur moyenne est donn´ ee par : hO (U )i = R (Q i,j dU ij ) O (U )e -S(U) R (Q i,j dU ij ) e -S(U) (8)

Upload: letu

Post on 02-Jan-2019

241 views

Category:

Documents


0 download

TRANSCRIPT

Page 1: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

Simulation Monte-Carlo d’une theorie de jauge SU(2)

Antonin Portellisujet propose par Laurent Lellouch

Des phenomenes comme le confinement des quarks dans les hadrons motivent a effectuer uneetude non perturbative des theories de jauge non abeliennes. On definit une theorie de jauge dansun espace-temps discret en s’assurant que l’invariance de jauge soit conservee et que la limite versle continu restitue bien la theorie de Yang-Mills. Un algorithme permettant d’evaluer l’integralede chemin de cette theorie est elabore pour le groupe de jauge SU(2), puis son implementationen C++ dans un contexte oriente objet est discutee. On valide le modele en le confrontant a desdonnees theoriques puis on l’utilise pour evaluer la tension de corde, quantite physique responsabledu confinement des quarks.

1. MOTIVATIONS

A basse energie, la constante de couplage de la QCDest trop elevee pour que les effets perturbatifs de latheorie soient dominant. Ceci interdit le calcul des in-teractions a partir d’un developpement en diagrammesde Feynman et motive a entamer une etude non per-turbative de la theorie. De plus certains phenomenesobserves experimentalement, comme le confinement desquarks dans les hadrons, semblent imprevisibles par desmethodes perturbatives et doivent etre de fait des ef-fets purement non perturbatifs de la theorie. Les theoriesquantiques de champs basees sur les symetries de jaugese definissent de facon physique et correct sur un espace-temps continu par le biais de la renormalisation, or leprocessus de renormalisation est essentiellement base surl’analyse de la structure pertubative d’une theorie. C’estpour surmonter ce probleme que Wilson proposera en1974 une etude non perturbative des theories de jaugesur un espace temps discret (ou reseau), cette etude mon-trera le phenomene de confinement dans la limite d’uncouplage fort. C’est rapidement (en 1980) que Creutzproposera des methodes de simulations numeriques dela theorie discrete de Wilson. Le travail qui suit estentierement base sur ces approches.

2. THEORIES DE JAUGE SUR RESEAU

On considere d’un champ de matiere a ψ possedantun ”espace interne” dans la representation fondamentaled’un groupe G de matrices unitaires de dimension nc.Une transformation de jauge locale de ψ est definie parψ(x) 7→ g(x)ψ(x) , ou g(x) est un element de G. Dans lelagrangien de Dirac :

LD = ψ(i/∂ −m)ψ (1)

les termes de la forme ψ∂µψ ne sont pas invariants parune transformation de jauge locale, ce qui conduit a l’in-troduction d’un nouveau champ (le champ de jauge) afind’obtenir une theorie invariante de jauge. Une methodeest de remplacer la derivee standard :

∂µψ(x) = limε→0

(ψ(x+ ε)− ψ(x)) (2)

par une derivee covariante :

Dµψ(x) = limε→0

(U(x, x+ ε)ψ(x+ ε)− ψ(x)) (3)

ou U(x, x+ε) est un element de G dont la transformationde jauge est definie par U(x, y) 7→ g(x)U(x, y)g(y)−1. Onpeut ensuite definir le champ de jauge en x en effectuantle developpement infinitesimal de U(x, x + ε), ce champen x sera un element de l’algebre de Lie de G. C’est cettequantite U(x, y) qui va permettre de definir la theoriediscrete.

2.1. Construction

On considere comme variable de la theorie sur reseauun champ U sur l’ensemble des couples d’elements voisins(ou liens)du reseau La = a(Z/NZ)4 a valeurs dans G.Les elements de La seront appeles sites du reseau. Onappellera plaquette de La tout quadruplet (i, j, k, l) desites tels que (i, j), (j, k), (k, l) et (l, i) soient des liens deLa. On suppose de plus que U verifie :

Uij = U−1ji = U†ji (4)

On defini la theorie classique par le lagrangien :

L () = β

ï1− 1

nc< tr(UijUjkUklUli)

ò(5)

ou = (i, j, k, l) est une plaquette de La. L’action Sissue de L est donnee par :

S =∑

L () (6)

L’integrale de chemin de la theorie quantique associee aL peut-etre definie simplement par une puissance de lamesure de Haar normalisee de G :

DU = d`g (7)

ou ` = 4N4 est le nombre de liens de La. Si O(U) est unefonction de correlation euclidienne de la theorie, alors savaleur moyenne est donnee par :

〈O(U)〉 =

∫ (∏i,j dUij

)O(U)e−S(U)∫ (∏

i,j dUij)e−S(U)

(8)

Page 2: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

2

2.2. Limite vers le continu

Avec i et j deux sites voisins de La et x le milieu entrei et j on defini Aµ(x) par :

Uij = e−ig0(j−i)µAµ(x) (9)

ou g0 est une constante de couplage. En developpant l’ex-ponentielle pour a→ 0 (i.e. j − i→ 0) on montre que :

L () =βg2

0

2nca4 tr(F 2

µν) + O(a6) (10)

ou les directions µ et ν engendrent le plan contenant et :

Fµν = ∂µAν − ∂νAµ − ig0[Aµ, Aν ] (11)

L’action peut alors s’ecrire :

S =βg2

0

4nc

∫d4xFµνF

µν + O(a6) (12)

On observe donc que pour a → 0, la theorie sur reseautends vers une theorie de Yang-Mills pour le groupe dejauge G et le couplage g2

0 = 2ncβ .

2.3. Boucles de Wilson

D’apres la discussion en introduction, il est naturel dedefinir une transformation de jauge g de U par :

Ui,j 7−→ giUi,jg−1j (13)

ou g est une application de La dans G. Alors il est fa-cile de voir que la quantite invariante de jauge la pluselementaire que l’on puisse construire est :

W () =1nc

tr(UijUjkUklUli) (14)

ou = (i, j, k, l) est une plaquette de La. De facon plusgenerale, si P est un chemin ferme sur La, la quantitedefinie par :

W (P ) =1nc

tr

ÑP

∏(i,j)∈P 2

Ui,j

é(15)

est invariante de jauge, on l’appelle la boucle de Wilsonde U sur P . On notera w(I, J) la valeur moyenne sur lereseau d’une boucle de Wilson rectangulaire de cotes delongueurs respectives I et J . A partir de (8), on peutcalculer des equivalents de w(1, 1) dans la limite d’uncouplage fort (β → 0) ou faible (β → +∞) :

w(1, 1) ∼β→0

β

4et w(1, 1) ∼

β→+∞1− 3

4β(16)

Pour une longueur R et un duree T (en unite dereseau), la quantite w(R, T ) peut-etre interpretee comme

l’evolution pendant un temps T de deux charges de cou-leurs statiques separees par une distance R. La seuleenergie presente lors de ce processus est l’energie po-tentielle V (R) de l’interaction de jauge, on peut doncs’attendre, pour un temps T assez grand, a avoir :

w(R, T ) ∼ e−TV (R) (17)

Si le potentiel V (r), ou r est une longueur physique,possede un terme de confinement lineaire Kr, alors pourde grandes valeurs I et J on aura :

w(I, J) ∼ e−IJa2K+O(I)+O(J) (18)

La quantite physique K est appelee tension de corde.Toujours dans la limite de boucles rectangulaires ou l’airedomine le perimetre, on peut evaluer a2K par le calculdu rapport de Creutz :

χ(I, J) = lnïw(I, J)w(I − 1, J − 1)w(I, J − 1)w(I − 1, J)

ò' a2K (19)

On montre, que dans les limites de couplage fort et faible :

a2K ∼β→0− ln

β

4et a2K ∼

β→+∞e−

6π2β11 (20)

3. SIMULATION NUMERIQUE

Il s’agit ici d’implementer un algorithme permettantd’evaluer numeriquement des fonctions de correlationseuclidiennes d’une theorie de jauge SU(2), en l’ap-proximant par une theorie sur reseau telle que decriteprecedemment.

3.1. L’algorithme

Pour calculer la valeur moyenne dans le vide d’une ob-servable O(U), on va evaluer l’integrale de chemin (8) parune methode Monte-Carlo. On genere aleatoirement ungrand nombre K de champs

(U (k)

)16k6K avec la densite

de probabilite :

dP (U) ∼ e−S(U)

(∏i,j

dUij

)(21)

et on aura :

〈O(U)〉 ' 1K

K∑k=1

O(U (k)) (22)

Pour tirer aleatoirement un champ U selon la loi (21),on tire aleatoirement chacune de ces valeurs Uij avec unedensite de probabilite :

dP (Uij) ∼ dUije12β tr

(Uij∑

k,lUjkUklUli

)(23)

Page 3: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

3

Il est utile ici de parametrer SU(2) par des elements deS3 :

SU(2) =a0 + i−→a · −→σ (a0,

−→a ) ∈ S3

(24)

ou les composantes de −→σ sont les trois matrices de Pauli.La mesure de Haar normalisee dg de SU(2) devient alorsla mesure de probabilite uniforme sur S3 :

dg =1

2π2d4aδ(a2 − 1) (25)

Du parametrage (24), on deduit que toute sommed’element de SU(2) est proportionnelle a un element deSU(2), en particulier la somme presente dans (23) peuts’ecrire : ∑

k,l

UjkUklUli = λijU ij (26)

avec U ij ∈ SU(2). Il est facile de voir que :

λij =

Õdet

Ñ∑k,l

UjkUklUli

é(27)

La loi (23) devient alors :

dP (Uij) ∼ d4aδ(a2 − 1)e12λij tr(βUijUij) (28)

En effectuant le changement de variable Uij 7→ UijU−1

ij ,on obtient grace a l’invariance par action de SU(2) dedUij et au fait que les matrices de Pauli soient de tracenulle :

dP (UijU−1

ij ) ∼ d4aδ(a2 − 1)e12λijβa0 (29)

Enfin, on integre la distribution δ :

dP (UijU−1

ij ) ∼ da0dΩ»

1− a20e

12λijβa0 (30)

On peut donc, pour tirer aleatoirement une valeur Uij duchamp U selon la loi (23), suivre la procedure suivante :

1. calculer U ij et λij2. tirer aleatoirement un reel a0 par une methode de

rejet suivant la loi dP (a0) =√

1− a20e

12λijβa0

3. tirer aleatoirement un vecteur −→a de√

1− a20S2 se-

lon une loi uniforme4. calculer l’element g de SU(2) associe a (a0,

−→a ) parle parametrage (24)

5. poser Uij = gU−1

ij

3.2. Implementation en C++

On dispose d’une bibliotheque de classes implementantdes objets mathematiques elementaires (cf. annexe A), enparticulier :

– dComplex represente un nombre complexe dont lesparties reelle et imaginaire sont de type double

– cMatrix represente une matrice dont les coefficientssont de classe dComplex

– iVector4 represente un vecteur a 4 composantes detype int

Les operateurs de ces objets ont ete correctement sur-charges afin de reproduire les operations mathematiquesclassiques.

On definit une classe Site, heritee de iVector4,qui contient un champ latsize, representant la tailledu reseau sur lequel la simulation va avoir lieu. Lesoperateurs de iVector sont surcharges afin que les coeffi-cients d’un objets Site soient calcules modulo latsize.

Afin de representer des chemins sur un reseau on definitune classe Path. Path possede aussi un champ latsize

representant la taille du reseau et contient un objetsiteslist de classe vector<Site> issue de la bibliothequestandard C++ pour contenir les sommets du chemin. Unemethode void add(Site) permet de creer le chemin som-met par sommet en verifiant qu’un sommet ajoute estbien voisin du precedent. On definit ensuite l’objet prin-cipal : celui qui representera le champ du jauge. On achoisi une classe template GaugeField<G> ou G est uneclasse qui interface le groupe de jauge (ici le nom de laclasse implementee est SU2). On attends que G possedeles methodes suivantes :

– cMatrix neutral(void) renvoie l’element neutre dugroupe.

– cMatrix randU(void) renvoie un element du groupealeatoire selon une loi uniforme.

– cMatrix randBoltz(double beta, cMatrix* neigh)

renvoie un element du groupe aleatoire selon la loi(23) ou neigh est un tableau de 6 objets cMatrix

representant les 6 produits UjkUklUli.GaugeField<G> contient un tableau links d’objetscMatrix, et des champs latsize et beta. L’acces enlecture seule au liens du champ se fait par une surchargede l’operateur () : on accede a un lien en renseignantdeux sites voisins. En revanche il est preferable quel’acces en ecriture aux liens se fasse par une methodevoid setLink(const Site& i, const Site& j, cMatrix U)

car le respect de la condition (4) se traite differemment enlecture et en ecriture et il pourrait y avoir une ambiguıteentre deux surcharges de l’operateur (). GaugeField<G>

possede trois methodes modifiant globalement le champ :– void orderize(void) initialize tous les liens aG::neutral (element neutre du groupe de jauge).

– void randomize(void) tire aleatoirement etindependamment tous les liens selon une loiuniforme (appel de G::randU)

– void update(void) modifie aleatoirement tous lesliens de facon a avoir un nouveau champ tire avecla loi (21) (appel de G::randBoltz)

GaugeField<G>::update est la procedure clef de tout leprogramme, c’est aussi celle qui consommera le plus deressources machine lors des calculs, son code source ainsique celui de SU2::randBoltz sont disponibles dans l’an-

Page 4: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

4

nexe C.Deux fonctions globales sont definies :

Path WilsonRec(Site& i,Site& j,cSite& k,

unsigned int J, unsigned int K) permet de creerune boucle rectangulaire dans le plan (i,j,k) de lon-gueur J dans la direction (i,j) et de longueur J dansla direction (i,k), j et k doivent etre voisins de i.cMatrix POProduct(GaugeField<G>& A, Path& P) permetde calculer des produits P-ordonnes sur un champA selon un chemin P. L’ensemble des prototypes desprocedures decrites precedemment est disponible enannexe B.

Dans tous les calculs qui suivent, pour chaque configu-ration de champ, ont ne calculera pas seulement une va-leur de la fonction de correlation utilisee, mais sa valeurmoyenne sur tout le champ afin d’optimiser la conver-gence de la methode Monte-Carlo.

Dans la suite trois simulations particulieres seronteffectuees, tout d’abord on testera la convergence dela methode Monte-Carlo, on confrontera ensuite lesresultats simules avec les limites de couplage fort et faiblepresentees en (16) et enfin on calculera les rapports deCreutz afin de mettre en evidence les variations de lataille physique du reseau et le confinement. Un travailassez long cherchant a calculer directement le potentielentre deux charges de couleurs statiques a ete effectue,mais les publications parcourues sur le sujet on montreque ce resultat est tres difficile a obtenir.

3.3. Resultats

Le programme est compile avec g++ 4.3.2 dans unsysteme GNU/Linux Ubuntu 8.10 (noyau 2.6.27-11)operant sur un Intel Dual Core 2.66GHz avec 2Go dememoire vive.

3.3.1. Convergence de la methode Monte-Carlo

Ici on evalue la valeur moyenne de boucles de Wilsonsur des plaquettes. On observe l’evolution de cette va-leur en fonction du nombre de champs tires aleatoirementpour des reseaux a 44, 64, 84 et 104 sites. On s’attend avoir une convergence de la sequence calculee, preuve dufonctionnement de la methode Monte-Carlo. On chercheaussi a observer l’independance des resultats a la taille dureseau considere. Deux resultats, calcules pour β = 2.3et β = 5, sont presentes respectivement dans les figures 1et 2. Chaque calcul a ete effectue en partant d’un champdont tous les liens sont egaux a l’identite, puis avec tousles liens tires aleatoirement de facon uniforme.

On observe la convergence de la methode Monte-Carlo, une limite assez precise est obtenue a partir de70 iterations. En revanche, selon certaines valeurs de β,la limite semble dependre de facon non monotone de lataille du reseau.

Fig. 1: evolution w(1, 1) pour β = 2.3

Fig. 2: evolution w(1, 1) pour β = 5

3.3.2. Test des limites de couplage fort et faible

Ici on on calcule la valeur la valeur moyenne de bouclesde Wilson sur des plaquettes apres 80 iterations en fonc-tion de β pour diverses tailles de reseau. Le resultat, com-portant une estimation de l’erreur de la simulation, estpresent dans la figure 3.

On observe un comportement compatible avec les li-mites theoriques (16), cependant, le probleme constate auresultat precedent apparait ici tres clairement : il sembleque la dependance de la valeur moyenne des boucles ala taille du reseau apparaisse lors de la transition entreles regimes de couplage fort et faible. Pour palier a ceprobleme, plusieurs generateurs de nombres aleatoiresont ete utilises, dont certains ayant une fiabilite eprouvee(Boost C++). Les algorithmes ont ete testes un par unet reecrits de differentes facon mais le probleme demeured’origine inconnue.

Page 5: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

5

Fig. 3: w(1, 1) en fonction de β

3.3.3. Mesure des rapports de Creutz

Ici on mesure les rapports de Creutz pour des taillesde boucle diverses sur un reseau 84. Le resultat est dis-ponible en figure 4.

Encore une fois le comportement theorique attendu estverifie, la rapide decroissance de la taille physique dureseau pour β & 2 dans le regime de couplage faible laissepenser que ce regime est celui qui permet l’etude d’objetsphysique de petite taille. L’existence d’une valeur de a2Kevidemment non nulle prouve la caractere confinant dupotentiel d’interaction entre deux charges de couleurs.

4. CONCLUSION

Les methodes de simulation de theories de jaugesur reseau sont efficaces dans le sens ou des prin-cipes numeriques simples (methode Monte-Carlo) per-mettent de simuler de facon realiste des phenomenestres complexes (effets non perturbatifs de l’interaction dejauge). Les importants progres recents de ces techniqueslaisses a penser des voies experimentales alternatives auxaccelerateurs pour explorer la physique des particules.

References

Le detail des resultats theorique presente dans ce tra-vail est disponible dans les references suivantes :

– M. Creutz, Monte-Carlo study of quantized SU(2)gauge theory, Phys. Rev. D21, 2308-2315 (1980)

– M. Creutz, Quarks, Gluons ans Lattices, Cam-bridge University Press (1985)

Fig. 4: a2K en fonction de β

Page 6: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

6

Annexe A: Prototypes des classes C++ pour les objets mathematiques elementaires

1. La classe Complex<T>

6 // ///////////////////////////////////////////////////////////////////

7 // Classe ///////////////////////////////////////////////////////////

8 // ///////////////////////////////////////////////////////////////////

9

10 template <class T>

11 class Complex

12

13 public:

14 T re;

15 T im;

16

17 // Constructeurs

18 Complex(void);

19 Complex(T ire , T iim);

20

21 // Operateurs

22 template <class S> Complex <T>& operator=(const Complex <S>& z);

23 Complex <T>& operator=(const Complex <T>& z);

24 template <class S> Complex <T>& operator=(const S& x);

25 Complex <T> operator+(const T& x) const;

26 Complex <T> operator -(const T& x) const;

27 Complex <T> operator*(const T& x) const;

28 Complex <T> operator/(const T& x) const;

29 Complex <T> operator+(const Complex <T>& z) const;

30 Complex <T> operator -(const Complex <T>& z) const;

31 Complex <T> operator*(const Complex <T>& z) const;

32 Complex <T> operator/(const Complex <T>& z) const;

33

34 // Operateurs amis

35 friend std:: ostream& operator <<(std:: ostream& stream , const Complex <double >& z);

36 template <class S> friend Complex <S> operator -(const S& x, const Complex <S>& z2);

37 template <class S> friend Complex <S> operator -(const Complex <S>& z);

38 ;

39

40 // ///////////////////////////////////////////////////////////////////

41 // Alias ////////////////////////////////////////////////////////////

42 // ///////////////////////////////////////////////////////////////////

43

44 typedef Complex <double > dComplex;

45

46 // ///////////////////////////////////////////////////////////////////

47 // Fonctions ////////////////////////////////////////////////////////

48 // ///////////////////////////////////////////////////////////////////

49 template <class T> Complex <T> conj(const Complex <T>& z);

50 template <class T> T sqmod(const Complex <T>& z);

Page 7: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

7

2. Les classes Matrix<T> et Vector<T>

9 // ///////////////////////////////////////////////////////////////////

10 // Classes //////////////////////////////////////////////////////////

11 // ///////////////////////////////////////////////////////////////////

12

13 template <class T>

14 class Matrix

15

16 protected:

17 unsigned int rsize;

18 unsigned int csize;

19 T* elements;

20

21 public:

22 // Constructeurs

23 Matrix(void);

24 Matrix(unsigned int irsize , unsigned int icsize);

25 Matrix(const Matrix <T>& A);

26

27 // Destructeur

28 virtual ~Matrix(void);

29

30 // Operateurs

31 T operator()(unsigned int rind , unsigned int cind) const;

32 T& operator()(unsigned int rind , unsigned int cind);

33 template <class S> Matrix <T>& operator=(const Matrix <S>& A);

34 Matrix <T>& operator=(const Matrix <T>& A);

35 Matrix <T> operator+(const Matrix <T>& A) const;

36 Matrix <T> operator -(const Matrix <T>& A) const;

37 Matrix <T> operator*(const Matrix <T>& A) const;

38 Matrix <T> operator*(const T& x) const;

39 Matrix <T> operator/(const T& x) const;

40 Matrix <T> operator%(const T& x) const;

41 bool operator==(const Matrix <T>& A) const;

42 bool operator!=(const Matrix <T>& A) const;

43 bool operator <(const Matrix <T>& A) const;

44

45 // Operateurs amis

46 template <class S> friend std:: ostream& operator <<(std:: ostream& stream , const

Matrix <S>& A);

47 template <class S> friend Matrix <S> operator*(const S& x, const Matrix <S>& A);

48

49 // Accesseurs

50 unsigned int getRSize(void) const;

51 unsigned int getCSize(void) const;

52

53 // Methodes

54 bool isSquare(void) const;

55 ;

56

57 template <class T>

58 class Vector : public Matrix <T>

59

60 using Matrix <T>::operator=;

61 protected:

62 unsigned int size;

63 public:

64 // Constructeurs

65 Vector(void);

66 Vector(unsigned int isize);

67 Vector(const Vector <T>& v);

68

Page 8: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

8

69 // Operateurs

70 T operator()(unsigned int ind) const;

71 T& operator()(unsigned int ind);

72

73 // Accesseur

74 unsigned int getSize(void) const;

75 ;

76

77 template <class T>

78 class Vector4 : public Vector <T>

79

80 using Matrix <T>::operator=;

81 public:

82 // Constructeurs

83 Vector4(void);

84 Vector4(T t, T x, T y, T z);

85 ;

86

87 template <class T>

88 class Vector3 : public Vector <T>

89

90 using Matrix <T>::operator=;

91 public:

92 // Constructeurs

93 Vector3(void);

94 Vector3(T x, T y, T z);

95 ;

96

97 // ///////////////////////////////////////////////////////////////////

98 // Alias ////////////////////////////////////////////////////////////

99 // ///////////////////////////////////////////////////////////////////

100

101 typedef Matrix <double > dMatrix;

102 typedef Matrix <int> iMatrix;

103 typedef Matrix <dComplex > cMatrix;

104 typedef Vector <double > dVector;

105 typedef Vector <int> iVector;

106 typedef Vector <dComplex > cVector;

107 typedef Vector4 <double > dVector4;

108 typedef Vector4 <int> iVector4;

109 typedef Vector4 <dComplex > cVector4;

110 typedef Vector3 <double > dVector3;

111 typedef Vector3 <int> iVector3;

112 typedef Vector3 <dComplex > cVector3;

113

114 // ///////////////////////////////////////////////////////////////////

115 // Fonctions ////////////////////////////////////////////////////////

116 // ///////////////////////////////////////////////////////////////////

117

118 Matrix <double > identity(unsigned int size);

119 Matrix <dComplex > conj(const Matrix <dComplex >& A);

120 template <class T> Matrix <T> trans(const Matrix <T>& A);

121 Matrix <dComplex > transc(const Matrix <dComplex >& A);

122 template <class T> T trace(const Matrix <T>& A);

123 template <class T> T scalprod(const Vector <T>& u, const Vector <T>& v);

124 template <class T> T sqnorm(const Vector <T>& u);

125 Vector <double > randUnit(unsigned int dim);

Page 9: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

9

Annexe B: Prototypes des classes C++ developpees pour la simulation

1. Les classes Site, Path et GaugeField<G>

9 // ///////////////////////////////////////////////////////////////////

10 // Classes //////////////////////////////////////////////////////////

11 // ///////////////////////////////////////////////////////////////////

12

13 class Site : public iVector4

14

15 using iVector4 ::operator=;

16 private:

17 unsigned int latsize;

18

19 public:

20 // Constructeurs

21 Site(void);

22 Site(unsigned int ilatsize);

23 Site(int t, int x, int y, int z, unsigned int ilatsize);

24 Site(const Site& i);

25

26 // Operateurs

27 Site operator+(const Site& i) const;

28 Site operator -(const Site& i) const;

29 bool operator==(const Site& i) const;

30 bool operator!=(const Site& i) const;

31

32 // Accesseur

33 unsigned int getLatSize(void) const;

34 ;

35

36 class Path

37

38 private:

39 unsigned int latsize;

40 std::vector <Site > siteslist;

41

42 public:

43 // Constructeurs

44 Path(void);

45 Path(unsigned int ilatsize);

46 Path(const Path& P);

47

48 // Operateur

49 Path& operator=(const Path& P);

50 Site operator()(unsigned int i) const;

51

52 // Operateurs amis

53 friend std:: ostream& operator <<(std:: ostream& stream , const Path& P);

54

55 // Accesseur

56 unsigned int getLatSize(void) const;

57 void setLatSize(unsigned int nlatsize);

58

59 // Methodes

60 void add(const Site& i);

61 int getLength(void) const;

62 bool isLoop(void) const;

63 ;

64

65

66 template <class G>

Page 10: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

10

67 class GaugeField

68

69 private:

70 cMatrix* links;

71 unsigned int latsize;

72 double beta;

73

74 public:

75 const G gGroup;

76

77 // Constructeurs

78 GaugeField(void);

79 GaugeField(unsigned int ilatsize , double ibeta);

80

81 // Destructeur

82 virtual ~GaugeField(void);

83

84 // Operateurs

85 cMatrix operator()(const Site& i, const Site& j) const;

86

87 // Accesseurs

88 unsigned int getLatSize(void) const;

89 double getBeta(void) const;

90 void setBeta(double nbeta);

91 void setLatSize(unsigned int nlatsize);

92 void setLink(const Site& i, const Site& j, cMatrix U);

93

94 // Methodes

95 void randomize(void);

96 void orderize(void);

97 void update(void);

98 ;

99

100

101 // ///////////////////////////////////////////////////////////////////

102 // Alias ////////////////////////////////////////////////////////////

103 // ///////////////////////////////////////////////////////////////////

104

105 typedef GaugeField <SU2 > SU2Field;

106

107 // ///////////////////////////////////////////////////////////////////

108 // Fonctions ////////////////////////////////////////////////////////

109 // ///////////////////////////////////////////////////////////////////

110

111 bool isNeigh(const Site& i, const Site& j);

112 Path WilsonRec(const Site& i, const Site& j, const Site& k, unsigned int J, unsigned int

K);

113 template <class G> cMatrix POProduct(const GaugeField <G>& A, const Path& P);

Page 11: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

11

2. La classe SU2

9 class SU2

10

11 private:

12 cMatrix neutral_element;

13

14 public:

15 // Constructeurs

16 SU2(void);

17

18 // Accesseur

19 cMatrix neutral(void) const;

20

21 // Methodes

22 cMatrix element(dComplex a, dComplex b) const;

23 cMatrix element(double a1 , double a2, double b1, double b2) const;

24 cMatrix randU(void) const;

25 cMatrix randBoltz(double beta , cMatrix* neigh) const;

26 ;

Page 12: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

12

Annexe C: Code source C++ des procedures gerant les tirages aleatoires de champs

1. La methode update

286 template <class G>

287 void GaugeField <G>:: update(void)

288

289 unsigned int dir , n;

290 Site i(latsize);

291 Site j(latsize);

292 Site k(latsize);

293 cMatrix* neigh;

294 GaugeField <G>& A = *this;

295

296 neigh = new cMatrix [6];

297 for (unsigned int i4=0; i4 <latsize; i4++)

298

299 i(4) = i4;

300 for (unsigned int i3=0; i3 <latsize; i3++)

301

302 i(3) = i3;

303 for (unsigned int i2=0; i2 <latsize; i2++)

304

305 i(2) = i2;

306 for (unsigned int i1=0; i1 <latsize; i1++)

307

308 i(1) = i1;

309 for (unsigned int indj =1; indj <=4 ; indj ++)

310

311 j=i;

312 dir=0;

313 j(indj) = ((j(indj)+1)%latsize+latsize)%latsize;

314 for (unsigned int indk=(indj %4) +1; indk!=indj; indk = (indk %4) +1)

315

316 k=j;

317 k(indk) = ((k(indk)+1)%latsize+latsize)%latsize;

318 neigh[dir] = A(j,k)*A(k,k+i-j)*A(k+i-j,i);

319 dir ++;

320

321 for (unsigned int indk=(indj %4) +1; indk!=indj; indk = (indk %4) +1)

322

323 k=j;

324 k(indk) = ((k(indk) -1)%latsize+latsize)%latsize;

325 neigh[dir] = A(j,k)*A(k,k+i-j)*A(k+i-j,i);

326 dir ++;

327

328 setLink(i,j,gGroup.randBoltz(beta ,neigh));

329

330

331

332

333

334 delete[] neigh;

335

Page 13: Simulation Monte-Carlo d’une th eorie de jauge SU(2) · Simulation Monte-Carlo d’une th eorie de jauge SU(2) Antonin Portelli sujet propos e par Laurent Lellouch Des ph enom enes

13

2. La methode randBoltz

50 cMatrix SU2:: randBoltz(double beta , cMatrix* neigh) const

51

52 cMatrix neighSum (2,2);

53 cMatrix tmp(2,2);

54 dVector3 vec;

55 dComplex k;

56 double a0 , test , nrm;

57

58 for (unsigned int i=0; i<6; i++)

59

60 neighSum = neighSum + neigh[i];

61

62 k = sqrt(( neighSum (1,1)*neighSum (2,2)-neighSum (1,2)*neighSum (2,1)).re);

63 neighSum = neighSum/k;

64 do

65

66 a0 = lrand::randU(exp(-k.re*beta),exp(k.re*beta));

67 test = lrand ::randU (0,1);

68 while (test > sqrt(1-(log(a0)*log(a0))/(k.re*beta*k.re*beta)));

69 a0 = 1/(k.re*beta)*log(a0);

70 nrm = sqrt(1-a0*a0);

71 vec = nrm*randUnit (3);

72 tmp = element(a0 ,vec (1),vec (2),vec (3))*transc(neighSum);

73

74 return tmp;

75