Uniwersytet Jagielloński Wydział Fizyki, Astronomii i Informatyki

Uniwersytet Jagielloński
Wydział Fizyki, Astronomii i Informatyki
Stosowanej
Praca magisterska
WINHAC++ – obiektowy generator
Monte Carlo do modelowania
naładowanych procesów Drella-Yana
Autor:
Kamil Sobol
Promotor:
dr hab. prof. UJ Wiesław Płaczek
Kraków 2010
Wydział Fizyki, Astronomii i Informatyki Stosowanej
Uniwersytet Jagielloński
Oświadczenie
Ja niżej podpisany Kamil Sobol (nr indeksu: 1000848) student Wydziału Fizyki, Astronomii i Informatyki Stosowanej Uniwersytetu Jagiellońskiego kierunku fizyka,
oświadczam, że przedłożona przeze mnie praca magisterska pt. ”WINHAC++ — obiektowy generator Monte Carlo do modelowania naładowanych procesów Drella-Yana”
przedstawia wyniki badań wykonanych przeze mnie osobiście, pod kierunkiem dr hab.
Wiesława Płaczka. Pracę napisałem samodzielnie.
Oświadczam, że moja praca dyplomowa została opracowana zgodnie z Ustawą o
prawie autorskim i prawach pokrewnych z dnia 4 lutego 1994 r. (Dziennik Ustaw 1994
nr 24 poz. 83 wraz z późniejszymi zmianami).
Jestem świadom, że niezgodność niniejszego oświadczenia z prawdą ujawniona w
dowolnym czasie, niezależnie od skutków prawnych wynikających z ww. ustawy, może
spowodować unieważnienie tytułu nabytego na podstawie tej pracy.
Kraków, dnia 22. czerwca 2010
..................................
Streszczenie
Niniejsza praca poświęcona jest implementacji generatora WINHAC++. Jest to nowa,
obiektowa wersja generatora Monte Carlo WINHAC, napisanego w języku Fortran, służącego do modelowania naładowanych procesów Drella–Yana z uwzględnieniem poprawek
radiacyjnych poprzez schemat ekskluzywnej eksponencjacji Yennie–Frautschi–Suura.
Na dzień dzisiejszy do nowej wersji został przeniesiony poziom Borna oraz radiacja
ze stanu końcowego (FSR). Poprawność implementacji została potwierdzona szeregiem
testów numerycznych.
Abstract
This thesis is devoted to the implementation of the generator WINHAC++. This is a new,
object–oriented version of the Monte Carlo generator WINHAC written in Fortran, which
is used for modeling the charged Drella–Yan processes, taking into account the radiative
corrections by exclusive Yennie–Frautschi–Suura exponentiation. At present, the Born
level and the final–state radiation (FSR) has been included into the new version. The
correctness of the implementation has been confirmed in a series of numerical tests.
Spis treści
Wstęp
4
1 Teoria
1.1 Proces
1.1.1
1.1.2
1.2 Proces
1.2.1
1.2.2
1.2.3
.
.
.
.
.
.
.
5
5
5
6
6
6
7
8
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
11
11
12
12
12
12
13
13
13
14
14
15
15
15
17
18
18
.
.
.
.
.
.
.
.
20
20
21
21
21
21
21
21
21
Drella–Yana . . . . . . . . . . . .
Wprowadzenie . . . . . . . . . . .
Przekrój czynny . . . . . . . . . .
partonowy . . . . . . . . . . . . .
Poziom Borna, amplitudy spinowe
Poprawki radiacyjne O(α) . . . .
Eksponencjacja YFS . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2 Algorytm Monte Carlo
2.1 Inicjalizacja . . . . . . . . . . . . . . . . . . . . .
2.1.1 Uproszczony przekrój czynny . . . . . . .
2.2 Generacja kwarków . . . . . . . . . . . . . . . .
2.2.1 Poziom partonowy . . . . . . . . . . . . .
2.2.2 Poziom hadronowy . . . . . . . . . . . . .
2.3 Generacja procesu twardego . . . . . . . . . . . .
2.3.1 Generacja leptonu i neutrina . . . . . . . .
2.3.2 Generacja kątów leptonu . . . . . . . . . .
2.3.3 Generacja twardych fotonów . . . . . . . .
2.3.4 Konstrukcja kinematyki . . . . . . . . . .
2.3.5 Wagi „crude” . . . . . . . . . . . . . . . .
2.4 Obliczanie wag modelowych . . . . . . . . . . . .
2.4.1 Poziom Borna . . . . . . . . . . . . . . . .
2.4.2 Poprawki radiacyjne . . . . . . . . . . . .
2.5 Kumulowanie statystyk . . . . . . . . . . . . . .
2.6 Opcjonalna obsługa przypadku przez użytkownika
2.7 Finalizacja . . . . . . . . . . . . . . . . . . . . .
3 Projekt oraz implementacja
3.1 Źródła programu oraz dokumentacja techniczna
3.2 Pakiety zewnętrzne . . . . . . . . . . . . . . . .
3.2.1 Xerces-C . . . . . . . . . . . . . . . . .
3.2.2 FOAM . . . . . . . . . . . . . . . . . . . .
3.2.3 CLHEP . . . . . . . . . . . . . . . . . . .
3.2.4 SANC . . . . . . . . . . . . . . . . . . . .
3.2.5 LHAPDF . . . . . . . . . . . . . . . . . . .
3.2.6 ROOT – opcjonalnie . . . . . . . . . . . .
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
22
22
22
22
23
24
24
25
25
27
28
28
35
4 Testy
4.1 Przekroje czynne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Histogramy obserwabli . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
36
37
Podsumowanie
44
Podziękowania
44
A Struktura katalogów pakietu WINHAC++
45
B Instalacja pakietu WINHAC++
47
C Wydruk programu Demo
49
3.3
3.4
3.5
3.6
3.2.7 Doxygen – opcjonalnie . . . . . . . . . .
Budowanie pakietu WINHAC++ . . . . . . . .
Wejście–wyjście . . . . . . . . . . . . . . . . . .
3.4.1 Wejście . . . . . . . . . . . . . . . . . .
3.4.2 Wyjście . . . . . . . . . . . . . . . . . .
Struktura obiektowa . . . . . . . . . . . . . . .
3.5.1 Klasa Event . . . . . . . . . . . . . . . .
3.5.2 Nadrzędna klasa Manager i jej pochodna
3.5.3 Interfejs ProcessHandler i jego pochodne
3.5.4 Interfejs PDF i jego pochodne . . . . .
3.5.5 InitializationHandler – inicjalizacja . . .
Demo . . . . . . . . . . . . . . . . . . . . . . .
3.6.1 Skrypty dla farm komputerowych . . . .
3
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
WINHAC
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Wstęp
W niniejszym opracowaniu opisuję wyniki mojej dwuletniej pracy nad nową obiektową wersją fortanowskiego generatora Monte Carlo WINHAC [1], która nazwana została
WINHAC++. Nowy generator został zaimplementowany w języku C++. Nadano mu nową
obiektową strukturę. Generator służy do modelowania naładowanych procesów Drella–
Yana (DY) z uwzględnieniem poprawek radiacyjnych przy użyciu schematu ekskluzywnej eksponencjacji Yennie–Frautschi–Suura.
Proces DY jest wyraźnie widoczny w akceleratorach hadronowych takich jak Tevatron (Fermilab, USA) czy uruchomiony obecnie Large Hadron Collider (CERN, Europa). Służy on do precyzyjnego wyznaczania parametrów modeli teoretycznych (np.
Modelu Standardowego), czy też szukania „nowej fizyki”. Proces ten używany jest między innymi do precyzyjnego wyznaczania masy i szerokości bozonu W oraz badania
funkcji rozkładu partonów w hadronach (PDF). Bardzo ważne jest uwględnienie poprawek radiacyjnych, które w wyraźny sposób wpływają na rozkłady obserwabli, między
innymi masy transwersalnej bozonu W , czy pędu poprzecznego powstającego w rozpadzie naładowanego leptonu.
Generator, przy użyciu technik Monte Carlo, produkuje, w oparciu o model teoretyczny, przypadki zdarzeń zachodzących podczas oddziaływania cząstek. W ten sposób
można uzyskać symulację procesów zachodzących podczas prawdziwego eksperymentu.
Techniki Monte Carlo pozwalają w prosty sposób uwzględniać ograniczenia detektorów
poprzez nakładanie odpowiednich cięć kinematycznych.
Podczas realizacji projektu szczególną uwagę poświecono analizie funkcjonalności
oraz projektowi struktury obiektowej generatora, którą następnie implementowano przy
użyciu współczesnych technologii informatycznych. Gotowy kod poddano szeregowi testów numerycznych, które potwierdziły zgodność nowej implementacji z jej pierwowzorem napisanym w języku Fortran.
Pracę podzieliłem na cztery rozdziały. W rozdziale 1 przybliżam opis teoretyczny
procesów DY, w rozdziale 2 omawiam algorytm Monte Carlo generatora, w rozdziale 3
przedstawiam szczegóły procesu projektowania i implementacji pakietu WINHAC++, zaś
w rozdziale 4 przedstawiam wybrane wyniki uzyskane podczas testów numerycznych
generatora.
4
Rozdział 1
Teoria
1.1
1.1.1
Proces Drella–Yana
Wprowadzenie
Proces Drella–Yana (DY) zachodzi przy wysokoenergetycznych zderzeniach hadron–
hadron. Został on zaproponowany przez Sidneya Drella oraz Tung-Mowa Yana w 1970
roku [2]. Pierwsze obserwacje tego procesu zanotowano podczas rozpraszania wysokoenergetycznych protonów na jądrach uranu [3].
Proces ten zachodzi podczas zderzeń hadronów. Wówczas kwark z jedngo hadronu
anihiluje z antykwarkiem z drugiego hadronu dając bozon pośredniczący. Rozróżnia
się dwa rodzaje procesów DY: zachodzące przez prądy naładowane (wówczas bozonem
pośredniczącym jest W + lub W − , patrz rysunek 1.1a) oraz zachodzące przez prądy
neutralne (bozony pośredniczące to γ oraz Z, patrz rysunek 1.1b). Bozon rozpada się
na parę naładowanych elektrycznie leptonów (prąd neutralny) lub na naładowany lepton i odpowiadające mu neutrino (prąd naładowany). Generator WINHAC++ realizuje
naładowane procesy Drella–Yana.
(a) Prąd naładowany
(b) Prąd neutralny
Rysunek 1.1: Proces Drella–Yana [4].
W dalszej części pracy będę rozważać naładowany proces Drella–Yana oraz będę nazywać pełny proces jako proces na poziomie hadronowym, zaś anihilację pary kwarków
do pary lepton–neutrino będę nazywać procesem na poziomie partonowym.
5
1.1.2
Przekrój czynny
Drell i Yan zauważyli, że przekrój czynny dla pełnego procesu może być wyrażony
jako konwolucja przekroju czynnego na poziomie partonowym z funkcjami rozkładu
partonów w hadronach (PDF – Parton Distribution Functions) oraz wysumowanie po
zapachach kwarków [5]. Można to zapisać równaniem:
σ=
XZ
dx1 dx2 fqA (x1 )fq̄B (x2 ) + (q ↔ q̄) σbqq̄→lν̄ ,
(1.1)
q,q̄
gdzie 0 ¬ x1 , x2 ¬ 1 to ułamki pędów hadronów unoszone przez kwarki, fqA , fq̄B to
PDFy kwarku i antykwarku pochodzącego odpowiednio z hadronu A i hadronu B (np.
dla LHC A = p, B = p; dla Tevatronu A = p, B = p̄), zaś σbqq̄→lν̄ to przekrój czynny dla
procesu na poziomie partonowym.
Rysunek 1.2 przedstawia schemat tego mechanizmu.
Rysunek 1.2: Proces Drella–Yana — schemat mechanizmu obliczania przekroju czynnego.
1.2
Proces partonowy
W tym podrozdziale przybliżam proces partonowy realizowany przez program WINHAC.
Znajdują się tutaj najważniejsze rezultaty otrzymane przez W. Płaczka oraz S. Jadacha
[1], które są podstawą generatora WINHAC oraz jego obiektowej wersji WINHAC++.
1.2.1
Poziom Borna, amplitudy spinowe
W najniższym rzędzie rozważany proces partonowy jest opisywany diagramem Feynmana przedstawionym na rysunku 1.3. Kwark oraz antykwark anihilują do bozonu W +
lub W − , zgodnie z zachowaniem ładunku, następnie bozon rozpada się w lepton (antylepton) oraz antyneutrino (neutrino).
Rysunek 1.3: Produkcja bozonu W na poziomie Borna.
6
Stosując reguły Feynmana, które można znaleźć w większości podręczników teorii pola, można obliczyć element macierzowy odpowiadający temu diagramowi. Zaś
przekrój czynny jest proporcjonalny do kwadratu tego elementu macierzowego. Istnieje
jednak lepsza droga do obliczania elementów macierzowych, a mianowicie amplitudy
spinowe, które są swego rodzaju klockami do budowy elementów macierzowych. Pokażę
to na przykładzie wyżej wymienionego diagramu.
Diagram jest dekomponowany (rysunek 1.4) na wysumowane po polaryzacjach bozonu pośredniczącego amplitudy spinowe, odpowiadające produkcji oraz rozpadowi tego
bozonu. Należy to jeszcze przemnożyć przez propagator bozonu.
Rysunek 1.4: Dekompozycja diagramu na amplitudy spinowe; Q – czteropęd bozonu, λ
– polaryzacja bozonu.
Formalnie można to wyrazić za pomocą równania:
M(0) (σ1 , σ2 ; τ1 , τ2 ) =
X
1
(0)
(0)
MP (σ1 , σ2 ; λ)MD (λ; τ1 , τ2 ),
2
2
2
Q − MW + iγW (Q ) λ
(1.2)
gdzie σ1 , σ2 = ±1 to stany helicity wchodzących kwarków, τ1 , τ2 = ±1 to stany helicity
(0)
wychodzącego leptonu i neutrina, Q to czteropęd bozonu, MW to masa bozonu, MP
(0)
oraz MD oznaczają amplitudy spinowe odpowiednio dla produkcji (P) oraz rozpadu
(D), λ oznacza polaryzację bozonu, zaś
(
2
γW (Q ) =
ΓW MW
Q2 ΓW /MW
w schemacie stałej szerokości,
w schemacie biegnącej szerokości.
(1.3)
Wyrażenia na wyżej wymienione amplitudy można znaleźć w pracy [1].
Zastosowanie amplitud spinowych jest korzystne, ponieważ jest łatwe w implementacji. Po drugie mając skonstruowane odpowiednie amplitudy spinowe, można z nich
składać różne diagramy bez konieczności wielokrotnego obliczania tych samych wyrażeń.
Amplitudy spinowe są sercem generatorów WINHAC oraz WINHAC++. W obiektowej wersji
powstała specjalna klasa (SpecialMatrix [6]) realizująca dowolne amplitudy spinowe.
1.2.2
Poprawki radiacyjne O(α)
Fotony wirtualne i miękkie
Fotony wirtualne i miękkie realne uwzględniane są analitycznie poprzez odpowiednie
czynniki mnożące amplitudy (patrz rozdział 2.2.1 w [1]).
7
Radiacja twardego fotonu
Radiacja twardego realnego fotonu może następować z linii naładowanej cząstki.
Może to być linia któregoś z kwarków (mówimy wtedy o radiacji ze stanu początkowego, ISR), linia wychodzącego leptonu (radiacja ze stanu końcowego, FSR) lub linia
naładowanego bozonu. Jak pokazano w rozdziale 2.2.2 w [1] radiacja z linii naładowanego bozonu może być podzielona na dwie części – jedna jest uwzględniana w amplitudzie
dla produkcji wraz z ISR, zaś druga w amplitudzie dla rozpadu wraz z FSR.
Generator WINHAC realizuje radiację FSR oraz interferencję FSR z ISR. Na dzień dzisiejszy do generatora WINHAC++ została przeniesiona radiacja FSR, pozostała do przeniesienia interferencja ISR z FSR.
Rysunek 1.5 przedstawia wkłady do amplitudy spinowej dla rozpadu, które po połączeniu z amplitudą dla produkcji na poziomie Borna dają wkład O(α) do rozważanego
procesu.
Rysunek 1.5: Wkłady do amplitudy spinowej rozpadu z pojedynczą radiacją twardego
fotonu.
Stosując reguły Feynmana można otrzymać (patrz rozdział 2.2.2 w [1]) wyrażenie
(1)
na amplitudę spinową dla rozpadu MD (λ, τ1 , τ2 , κ), gdzie nowy parametr κ = 1, 2
to polaryzacja fotonu. Następnie składając to z amplitudą dla produkcji na poziomie
Borna dostaje się element macierzowy:
M(1) (σ1 , σ2 ; τ1 , τ2 , κ) =
1.2.3
X
1
(0)
(1)
MP (σ1 , σ2 ; λ)MD (λ; τ1 , τ2 , κ).
2
2
2
Q − MW + iγW (Q ) λ
(1.4)
Eksponencjacja YFS
Głównym celem generatora WINHAC jest symulacja procesu produkcji bozonu W z
wielofotonową radiacją, patrz rysunek 1.6. W tym celu został użyty schemat ekskluzywnej eksponencjacji Yennie–Frautschi–Suura (YFS) [7]. Rozważany jest proces:
q1 (p1 ) + q2 (p2 ) → W± (Q) → l(ql ) + ν̄(qν ) + γ(k1 ) + · · · + γ(kn ),
n = 0, 1, . . . . (1.5)
Całkowity przekrój czynny po zastosowaniu eksponencjacji dany jest wyrażeniem:
σY F S =
∞ Z
X
n=0
d3 ql d3 qν (1)
ρ (p1 , p2 , ql , qν , k1 , . . . , kn ),
ql0 qν0 n
gdzie
8
(1.6)
Rysunek 1.6: Wielofotonowa radiacja w rozpadzie W [1].
ρ(1)
n
Y (Q,ql ;ks )
=e
n
n
X
1 Y
d3 ki
0
(4)
S̃(Q,
q
,
k
)θ(k
−
k
)δ
p
+
p
−
q
−
q
−
ki
l i
s
1
2
l
ν
i
n! i=1 ki0
i=1

(1)
× β̄0 (p1 , p2 , ql , qν )
+
!

(1)
n
X
β̄1 (p1 , p2 , ql , qν , ki ) 
i=1
S̃(Q, ql , ki )
(1.7)
,
2
Q
ql
gdzie S̃(Q, ql , k) = − 4πα2 kQ
− kq
jest czynnikiem odpowiadającym radiacji miękkich
l
fotonów; Y (Q, ql ; ks ) to czynnik postaci (ang. form factor ) YFS zawierający zregularyzowane osobliwości podczerwone; ks ECM jest granicą miękkich fotonów, tzn. realne
fotony o energii poniżej progu są uwzględnione w analitycznych czynnikach, zaś powyżej są generowane przy użyciu technik Monte Carlo, wyniki nie zależą od ks . Funkcje
(1)
(1)
β̄0 oraz β̄1 są funkcjami pozbawionymi osobliwości podczerwonych wyrażonymi przez
elementy macierzowe do rzędu O(α) oraz wcześniej wspomniane poprawki wirtualne.
1
1 X
1 (0)
2
β̄0 =
|M(0) | ,
2
2
16s(2π) 12
(1)
(1.8)
h
(0)
i
β̄0 (p1 , p2 , ql , qν ) = β̄0 (p1 , p2 , ql , qν ) 1 + δ (1) (Q, ql , qν ) ,
δ
(1)
=
(1)
δQED
+
(1)
δweak ,
(1)
δQED
α
M
1
=
ln
+
.
π
ml 2
(1.9)
(1.10)
(1)
Poprawka δweak jest dostarczana przez zewnętrzny pakiet SANC, patrz [8].
(1)
β̄1 (p1 , p2 , ql , qν , k) =
1
1 X
2
(0)
|M(1) | − S̃(Q, ql , k)β̄0 (p1 , p2 , ql , qν )
5
16s(2π) 12
(1)
(1)
(1.11)
Dokładne wyprowadzenie β̄0 oraz β̄1 , jak również pozostałe interesujące szczegóły
można znaleźć w rozdziale 3 w pracy [1].
9
Rozdział 2
Algorytm Monte Carlo
Podstawowym zadaniem generatora WINHAC++ jest wygenerowanie pojedynczego
przypadku (zdarzenia) mającego symulować (modelować) realną sytuację zachodzącą
przy zderzaniu cząstek. Proces generacji przebiega w następujący sposób:
• generacja parametrów zdarzenia z uproszczonych rozkładów,
• kompensacja uproszczeń poprzez obliczenie wag korekcyjnych.
Wygenerowany przypadek zawiera następujące informacje:
• czteropędy oraz rodzaje cząstek (PDG id):
– zderzanych hadronów,
– reszt zderzanych hadronów,
– kwarków biorących udział w procesie partonowym,
– bozonu pośredniczącego,
– naładowanego leptonu,
– neutrina,
– twardych fotonów;
• wicrude – wagi tzw. surowe („crude”), pochodzące z generacji partonów i konstrukcji
kinematyki procesu;
• wjmodel – wagi modelowe, pochodzące z obliczania dokładnych elementów macierzowych dla różnych modeli teoretycznych, efektów itd.;
• całkowity uproszczony przekrój czynny σ crude , wspólny dla wszystkich przypadków generowanych w jednym uruchomieniu generatora.
Całkowitą wagę przypadku oblicza się poprzez wymnożenie przekroju czynnego
„crude” przez wagi „crude” oraz przez wybraną wagę modelową (lub kombinację wag
modelowych), w zależności od tego jakie efekty chce się uwzględnić:
wjevent = σ crude
Y
wicrude wjmodel .
(2.1)
i
Proces generacji można podzielić funkcjonalnie na pewne fazy (mają one odbicie w
strukturze obiektowej generatora). Są to:
10
• inicjalizacja;
• właściwa generacja pewnej ilości zdarzeń:
– generacja kwarków,
– generacja naładowanego leptonu, neutrina oraz fotonów, konstrukcja kinematyki procesu,
– obliczanie wag modelowych,
– kumulowanie statystyk,
– opcjonalna obsługa przypadku przez użytkownika;
• finalizacja.
Etap generacji kwarków może być wyłączony, wtedy generowany jest sam proces na
poziomie partonowym.
2.1
Inicjalizacja
Ten etap jest wykonywany raz, przy uruchamianiu generatora. Tutaj ustawiane są
wszelkie stałe fizyczne i inne parametry programu. Na tym etapie obliczany jest uproszczony przekrój czynny (σ crude ).
2.1.1
Uproszczony przekrój czynny
Poziom partonowy
W przypadku rozważania tylko procesu partonowego całkowity przekrój czynny
„crude” dany jest wzorem:
σ
crude
π
=N
36
αef f VijCKM
sin2 θW
!2
s
2 2
(s − MW
) + γ(s)
(2.2)
gdzie:
(
γ(s) =
(ΓW MW )2
ΓW 2
)
(s M
W
w schemacie stałej szerokości,
w schemacie biegnącej szerokości,
(2.3)
s to zmienna Mandelstama (w tym przypadku równa kwadratowi czteropędu bozonu),
VijCKM to element macierzy CKM [5] odpowiadający mieszaniu wybranych kwarków, θW
to kąt Weinberga, zaś N to czynnik normalizacyjny zależny od liczby rodzin leptonów
oczekiwanych w stanie końcowym, występuje tu też konwersja jednostek z GeV −2 do
nb (nanobarn):
N = Conv GeV
−2 →N b
N final lepton families ,
N final lepton families = 1, 2, 3 dla jednej, dwóch, trzech rodzin leptonów;
(2.4)
(2.5)
zaś efektywna stała sprzężenia:
(
αef f =
α
αGµ =
√
w schemacie α,
2 sin2 θ
2Gµ MW
W
π
11
w schemacie Gµ .
(2.6)
Poziom hadronowy
Na poziomie hadronowym konstruuje się konwolucję (równanie 1.1) przekroju partonowego z funkcjami rozkładu partonów w hadronach (PDF). W tym celu tworzy się
dwuwymiarowy rozkład prawdopodobieństwa zbudowany z przekroju 2.2 (bez czynnika
normalizacyjnego, który będzie domnożony później), PDFów oraz macierzy CKM, patrz
klasa ppWintegrand w [6]. Otrzymaną funkcję całkuje się (używając do tego pakietu
FOAM, patrz [9][10]) po kwadracie [0, 1]2 otrzymując σ FOAM . Ostatecznie
σ crude = N σ FOAM .
2.2
2.2.1
(2.7)
Generacja kwarków
Poziom partonowy
W przypadku wyłączenia części hadronowej generatora i badania samego procesu
partonowego ta część programu ustawia tylko czteropędy kwarków w układzie własnym
bozonu W . Wtedy zwracana jest waga:
crude
wgen.quarks
= 1.
2.2.2
(2.8)
Poziom hadronowy
Przy rozważaniu pełnego procesu, do generowania kwarków używa się adaptacyjnego generatora FOAM [9][10]. Korzystając z wcześniej wspomnianej funkcji gęstości prawdopodobieństwa losuje się parę liczb x1 , x2 będącymi ułamkami pędów unoszonymi z
hadronów przez kwarki. W funkcji gęstości prawdopodobieństwa została zrobiona zamiana zmiennych mająca na celu zwiększenie wydajności generowania. Następnie w
oparciu o wyewoluowane w trakcie tej generacji PDFy losuje się zapachy oraz ładunki
kwarków, które determinują jednoznacznie jaki bozon powstanie z wylosowanej pary
kwarków.
W oparciu o wygenerowane x1 oraz x2 konstruowane są czteropędy kwarków, a
następnie czteropędy w układzie własnym bozonu.
Waga z tej części procesu powstaje z wagi zwróconej przez FOAM oraz wagi z konstrukcji kinematyki:
crude
wgen.quarks
= wFOAM wkin ,
(
w
2.3
kin
=
0:
1:
któryś z kwarków poza przestrzenią fazową,
w przeciwnym razie.
(2.9)
(2.10)
Generacja procesu twardego
Jako wejście dla tej części generacji otrzymywany jest bozon i kwarki. Tutaj generowana jest rodzina leptonów, twarde fotony oraz konstruowana jest kinematyka rozpadu
W . Całość rozważana jest w układzie własnym bozonu gdzie trójpędy kwarków skierowane są wzdłóż osi z:
12
p1 = (E1 , 0, 0, p)
p2 = (E2 , 0, 0, −p)
Q = (E1 + E2 , 0, 0, 0)
kwark
antykwark
bozon
(2.11)
(2.12)
(2.13)
Na końcu przeprowadzana jest transformacja Lorentza do układu laboratoryjnego.
2.3.1
Generacja leptonu i neutrina
W zależności od ustawień generatora w stanie końcowym może być otrzymywana
od jednej do trzech rodzin leptonów, tj. elektrony, miony, tau’y. Generacja odbywa
się z rozkładu równomiernego, tj. każda rodzina ma jednakowe prawdopodobieństwo
wylosowania. Ładunek leptonu jest jednoznacznie określony przez wytworzony bozon
W , zaś neutrino determinuje zachowanie liczby leptonowej. Dozwolone są rozpady:
W
2.3.2
+
e+ + νe
→ µ+ + νµ ,

 +
τ + ντ



W
−
e− + ν̄e
→ µ− + ν̄µ .

 −
τ + ν̄τ



(2.14)
Generacja kątów leptonu
Aby skonstruować kinematykę generowane są dwa kąty opisujące położenie czteropędu emitowanego leptonu. Są to standardowe kąty w układzie współrzędnych sferycznych,
θ – kąt polarny oraz φ – kąt azymutalny. Kąt azymutalny generowany jest z rozkładu
jednorodnego na przedziale [0, 2π), zaś polarny z uproszczonego rozkładu:
φ ∈ U[0, 2π),
1
cos(θ) = QW (1 − 2(X) 3 ),
2.3.3
(2.15)
(
X ∈ U[0, 1),
QW =
+
W
.
W−
+1 :
−1 :
(2.16)
Generacja twardych fotonów
Liczba fotonów generowana jest przez generator rozkładu Poissona. Ponadto generator ten wykorzystywany jest do produkcji liczb losowych, z których konstruuje się
czteropędy fotonów. Wynikiem działania tego generatora jest krotność N fotonów oraz
liczby ri , i = 1, . . . , N .
Moduły czteropędów fotonów (równe ich energiom) konstruuje się w następujący
sposób:
√
|~ki | = Eiγ =
γ
Q2 2Emin
1
CM
CM
2
E
max(2E1 /E , 2E2 /E CM )
"
#ri
(2.17)
γ
gdzie Emin
to granica miękkich fotonów, E CM energia zderzenia w układzie środka masy
wiązek.
13
2.3.4
Konstrukcja kinematyki
Poziom Borna
Kinematyka produkcji pary leptonów bez radiacji jest standardową kinematyką procesu 2 → 2. Do sparametryzowania jej wystarczają wygenerowane kąty leptonu.
El =
(E1 + E2 )2 + m2l − m2ν
,
2(E1 + E2 )
(2.18)
q
q = |~ql | =
[(E1 + E2 )2 − (ml + mν )2 ] [(E1 + E2 )2 − (ml − mν )2 ]
2(E1 + E2 )
ql = (El , q sin θ cos φ, q sin θ sin φ, q cos θ),
,
(2.19)
(2.20)
qν = p 1 + p2 − ql .
(2.21)
Poprawki radiacyjne
Na początku kinematyka konstruowana jest w układzie, w którym trójpęd leptonu
skierowany jest wzdłóż osi z. W tym układzie generowane są kąty polarne (θi ) i azymutalne (φi ) trójpędów fotonów z uproszczonego rozkładu. Ponieważ czteropędy fotonów
są już ustalone, kinematyka konstruowana jest jako proces 2 → 3, gdzie oprócz naładowanego leptonu i neutrina pojawia się suma czteropędów fotonów. Rozważając ten
(3)
proces można dojść do równań na El oraz pl :
(3) 2
El2 − pl
= m2l ,
(1) 2
γ
(E1 + E2 − Etot
− El )2 = m2ν + ktot
(2.22)
(2) 2
+ ktot
(3)
+ ktot + pl
2
,
(2.23)
czteropęd neutrina uzyskuje się przez:
qν = Q − pl − ktot .
(2.24)
Ostatecznie wszystkie skonstruowane czteropędy obracane są tak, aby wektor pędu
leptonu był ustawiony pod kątami wygenerowanymi wcześniej.
2.3.5
Wagi „crude”
Poziom Borna
crude
Na poziomie Borna nie ma przybliżeń, więc waga „crude” z tego etapu whard
= 1.
Poprawki radiacyjne
Gdy uwzględniane są poprawki radiacyjne na wagę „crude” z tego etapu składa się
pięć wag korekcyjnych:
f in
crude
whard
= wY wS wP S wm wkin
.
(2.25)
Waga wY koryguje uproszczenia w czynniku postaci YFS, wS koryguje uproszczenia w
S̃ z równania 1.7 (dla FSR wS = 1), wP S odpowiada wycałkowaniu delty zachowania
czteropędu po przestrzeni fazowej, wm kompensuje opuszczenie wyrazów masowych
f in
przy generowaniu kątów fotonów, a wkin
to waga kinematyczna dla stanu końcowego
f in
(wkin
= 0/1, gdy przypadek jest poza/w przestrzeni fazowej).
14
2.4
Obliczanie wag modelowych
Wagi modelowe korygują uproszczenia w elementach macierzowych użytych do wyprodukowania uproszczonego przekroju czynnego. Z wag modelowych wybiera się jedną
lub kombinację kilku wag (w zależności od pożądanych efektów) i mnożąc ją przez wagi
z poprzednich etapów dostaje się pełną wagę zdarzenia.
model
, która odpowiada najlepszemu przewidywaDodatkowo ustawiana jest waga wbest
niu oferowanemu przez generator. Jest ona używana domyślnie do wyliczania pełnej
wagi przypadku.
Wagi te obliczane są w układzie własnym bozonu.
2.4.1
Poziom Borna
model
Na poziomie Borna obliczana jest jedna waga modelowa wborn
. Otrzymuje się ją
dzieląc dokładny różniczkowy przekrój czynny przez uproszczoną jego wersję dla konkretnego przypadku:
dσ crude
dσ (0)
/
,
dΩl
dΩl
!
model
wborn
=
!
(2.26)
gdzie
dσ crude
2
=
dΩl
3
αef f VijCKM
8 sin2 θW
!2
s(1 − QW cos θl )2
,
2 2
(s − MW
) + γ(s)
(2.27)
γ(s) dana jest równaniem 2.3. Dokładny przekrój czynny dany jest wzorem:
dσ (0)
1
1 (0) 2
=
M ,
dΩl
8(2π)2 s 12
(2.28)
gdzie pojawia się dokładny element macierzowy uśredniony po kolorach i spinach cząstek
początkowych.
2.4.2
Poprawki radiacyjne
Eksponencjacja YFS
Przy włączonych poprawkach radiacyjnych obliczane są funkcje β̄ (patrz równania
1.5 do 1.11):
(0)
β̄0 =
(1)
(2.29)
uwzględnia poprawki elektrodynamiczne (QED); (2.30)
(0)
uwzględnia pełne poprawki elektrosłabe
β̄0(EW ) = β̄0 (1 + δ QED + δ weak ),
(1)
odpowiada to wzorowi 1.8;
(0)
β̄0(QED) = β̄0 (1 + δ QED ),
(1)
dσ (0)
dΩl
(0)
β̄0(LL) = β̄0 (1 + δ LL ),
uwzględnia przybliżenie wiodących logarytmów:
15
(2.31)
(2.32)
δ
!
√
1α
s
=
2 ln
−1 .
2π
ml
LL
(2.33)
(1)
Następnie obliczana jest suma funkcji β̄1 widoczna w równaniu 1.7:
(1)
β̃1
(1)
n
X
β̄1 (p1 , p2 , ql , qν , ki )
=
S̃(Q, ql , ki )
i=1
.
(2.34)
(1)
Dodatkowo obliczana jest β̃1 w przybliżeniu wiodących logarytmów:
(1)
β̃1(LL)
=
(1)
n
X
zi2
,
i=1 2(1 − zi )
(0)
β̄0
2Eiγ
zi =
.
E1 + E2
(2.35)
(1)
Z obliczonych funkcji β̃1 , β̄0 oraz uproszczonego przekroju czynnego (równanie
2.27) konstruowane są wagi modelowe. Obliczane są indywidualne stosunki tych funkcji
do uproszczonego przekroju czynnego oraz następujące wagi:
model
wYFS
O(α)
=
model
wYFS
O(α) EW =
model
wYFS
O(α) QED
model
wLL
O(α) QED
=
=
dσ crude
,
dΩl
!
(0)
β̄0 /
(1)
β̄0(QED)
(1)
β̄0(EW )
(1)
β̄0(LL)
+
+
+
(1)
β̃1
(1)
β̃1
(1)
β̃1(LL)
(2.36)
dσ crude
/
,
dΩl
!
(2.37)
dσ crude
,
/
dΩl
(2.38)
dσ crude
/
.
dΩl
(2.39)
!
!
Jako najlepsza waga, wybierana jest:
model
model
wbest
= wYFS
O(α) EW
(2.40)
Rząd O(α)
W celu obliczenia poprawek rzędu O(α) upraszcza się czynnik postaci YFS i uwzględnia się poprawki miękkie i wirtualne (patrz rozdział 2.2.1 w [1]). Oblicza się funkcje:
(0)
(0)
dσ0 = β̄0 /eY (Q,ql ;ks ) ,
(2.41)
(1)
(0)
(2.42)
(0)
(2.43)
v+s
dσ0(QED) = dσ0 (1 + δQED
),
(1)
v+s
dσ0(EW ) = dσ0 (1 + δEW
),
(1)
dσ1
!
=
dσ (1)
/ S̃(Q, ql , k)eY (Q,ql ;ks ) ,
dΩl
(2.44)
gdzie:
dσ (1)
1 (1) 2
1
=
M .
dΩl
16(2π)5 s 12
16
(2.45)
Z obliczonych funkcji definiuje się wagi modelowe:
model
wBorn
model
wO(α)
QED
model
wO(α)
EW
=
=
=
(1)
dσ0(QED)
(1)
dσ0(EW )
model
wBorn
+ virtual (QED) + soft
model
wBorn
+ virtual (EW) + soft
model
wOne
photon
2.5
dσ crude
,
dΩl
!
(0)
dσ0 /
=
+
(1)
dσ1
dσ crude
/
,
dΩl
!
dσ crude
/
,
dΩl
+
(1)
dσ1
=
(1)
dσ0(QED) /
=
(1)
dσ0(EW ) /
(1)
dσ1 /
(2.46)
(2.47)
!
dσ crude
,
dΩl
(2.48)
!
dσ crude
,
dΩl
(2.49)
!
dσ crude
.
dΩl
(2.50)
!
(2.51)
Kumulowanie statystyk
Generator w trakcie generowania przypadków kumuluje statystyki wag zdarzeń. Informacje zbierane są dla:
• indywidualnych wag,
• wag wymienionych w sekcji 2.4,
• iloczynów wszystkich wag modelowych z wagami „crude” – pełnych wag przypadku:
Y
wjevent =
wicrude wjmodel ,
(2.52)
i
• najlepszej wagi przypadku:
event
wbest
=
Y
model
wicrude wbest
.
(2.53)
i
Przy generowaniu przypadków dla każdej z wymienionych wyżej wag zbierane są
informacje:
•
P
wi ,
•
P
wi2 ,
i
i
• N – ilość przypadków,
• waga minimalna i maksymalna: wmin , wmax .
Skumulowane statystyki posłużą później do wyliczania przekrojów czynnych.
17
2.6
Opcjonalna obsługa przypadku przez użytkownika
Generator WINHAC++ pozwala na zbudowanie dodatkowej, własnej obsługi przypadków przez użytkownika. Jest ona wykonywana na końcu generacji każdego przypadku.
Jako przykład demonstracyjny w wydanej wersji generatora zostało stworzone histogramowanie następujących obserwabli (kostruowanych w układzie LAB):
• rapidity bozonu W :
(3)
yW
1 EW + pW
,
= ln
2 EW − p(3)
W
(2.54)
• cosinus kąta polarnego leptonu:
(3)
p
cos θl = l ,
|~
pl |
(2.55)
• pseudorapidity leptonu:
!
θ
ηl = − ln tan
,
2
(2.56)
• pęd poprzeczny leptonu:
pTl
=
r
(1) 2
(2) 2
pl
+ pl
2
(1) (1)
,
(2.57)
• masa transwersalna bozonu W :
mTW
=
r h
(2) (2)
i
2 (pTl ) − pl pν − pl pν ,
(2.58)
• krotność fotonów nγ ,
• suma energii fotonów Eγtot ,
• energia najtwardszego fotonu Eγhardest ,
• pęd poprzeczny najtwardszego fotonu pTγ (hardest) ,
• pseudorapidity najtwardszego fotonu ηγhardest .
2.7
Finalizacja
W procesie finalizacji przetwarzane są informacje zebrane w etapie opisanym w
rozdziale 2.5. Obliczane są średnie wagi wraz z błędami statystycznymi (odchyleniami
standardowymi):
PN
i=1
hwi =
N
18
wi
,
(2.59)
δ(w)
=
hwi
v
u
u PN
2
u
u i=1 wi
t P
2
N
i=1 wi
1 − .
N (2.60)
Wśród obliczonych średnich wag są wymienione wcześniej pełne wagi (rozdział 2.5)
przypadku odpowiadające różnym typom poprawek/efektów. Z tych wag i przekroju
czynnego „crude” konstruuje się pełny przekrój czynny rozważanego procesu:
σitot = σ crude hwievent i,
(2.61)
δ(σitot ) = σ crude hwievent iδ(wievent ).
(2.62)
Najlepszą wartość całkowitego przekroju czynnego wylicza się korzystając z wagi
model
:
wbest
tot
event
σbest
= σ crude hwbest
i,
(2.63)
tot
event
event
δ(σbest
) = σ crude hwbest
iδ(wbest
).
(2.64)
19
Rozdział 3
Projekt oraz implementacja
WINHAC++ jest pakietem dostarczającym generator Monte Carlo, który może być używany przez użytkownika w jego własnym projekcie. Jego zadaniem jest produkowanie
przypadków, które mogą być dalej obsługiwane przez użytkownika w dowolny sposób,
np. przekazane innym generatorom. Finalnym produktem są trzy biblioteki dzielone
(ang. shared libraries), które mogą być skonsolidowane (ang. linked ) z aplikacją użytkownika.
W tym rozdziale omówię koncepcję implementacji generatora. Równolegle tworzony
był przez Andrzeja Siódmoka bliźniaczy generator ZINHAC [11] do generowania procesów Drella–Yana przez prądy neutralne. Ponieważ oba generatory mają ze sobą wiele
wspólnego, to we współpracy z Wiesławem Płaczkiem i Andrzejem Siódmokiem został
opracowany w UMLu wstępny szkic struktury obu generatorów. Planowanie to okazało
się bardzo ważnym etapem rozwoju pakietu WINHAC++, ponieważ dało mi pełny pogląd
na oczekiwane funkcjonalności oraz trafnie nakreśliło przyszłą strukturę obiektową generatora. W dystrybucji generatora można odnaleźć tę pierwotną wersję struktury w
katalogu vpproject (są to pliki pakietu Visual Paradigm [12]). Podczas modelowania
zostały również podjęte decyzje o używanych pakietach zewnętrznych.
W czasie implementacji zaszły drobne zmiany w planowanej strukturze, więc aktualna wersja generatora może różnić się nieco od założonej struktury, jednak główne idee
zaproponowane na początku zostały zachowane.
Projekt rozwijany był przy pomocy zintegrowanego środowiska programistycznego
Eclipse [13].
W dodatku A można znaleźć strukturę katalogową pakietu WINHAC++, zaś w dodatku
B zamieściłem instrukcję instalacji i uruchomienia programu.
3.1
Źródła programu oraz dokumentacja techniczna
Dokumentacja techniczna oraz źródła programu dostępne są na stronie WWW [6].
Użytkownicy Subversion mogą skorzystać z repozytorium znajdującego się pod adresem [14]:
$ svn c h e c k o u t h t t p : / / w i n h a c p l u s p l u s . g o o g l e c o d e . com/ svn / t r u n k / WINHAC
20
3.2
Pakiety zewnętrzne
WINHAC++ używa pakietów zewnętrzych wymienionych poniżej. Część z nich powinna
być dostępna w systemie operacyjnym, na którym chce się uruchamiać generator.
3.2.1
Xerces-C
Zdecydowano, że główne pliki wejściowe będą w postaci XMLa. Główną przesłanką ku temu było to, że jest to dobrze zdefiniowany standard przechowywania danych.
Drugą przesłanką była dostępność gotowych parserów do plików tego formatu. Zdecydowano, że będzie to Xerces-C [15]. Jest on dostarczany z generatorem WINHAC++ w
postaci źródeł i w razie niewykrycia go w systemie operacyjnym jest on automatycznie
budowany przy kompilacji.
3.2.2
FOAM
Pakiet FOAM (patrz [9][10]) jest dobrze znanym narzędziem Monte Carlo. Jest używany do całkowania, jak również do generowania zdarzeń losowych z zadanej gęstości
prawdopodobieństwa. Narzędzie to jest używane w fortranowskiej wersji generatora
WINHAC. W pakiecie WINHAC++ jest używana wersja 2.06 (w C++), włączona w postaci
źródeł.
3.2.3
CLHEP
Część pakietu CLHEP jest włączona w postaci źródeł. Ten pakiet został wybrany,
ponieważ miał dobrze wytestowane klasy obsługujące czterowektory oraz dobrze wytestowane generatory liczb losowych. Poza tym dzięki przejrzystej strukturze łatwo było
wydobyć z niego interesujące klasy (próbowano tego samego z systemem ROOT, jednak
z powodu zawiłości jego struktury szybko porzucono ten pomysł). Dodatkowo zmieniono interfejs generatorów liczb losowych tak, aby mógł go używać FOAM, tj. dodano
dziedziczenie interfejsu z pakietu CLHEP po interfejsie używanym przez pakiet FOAM.
3.2.4
SANC
Pakiet SANC dostarcza poprawki elektrosłabe do rozpadu bozonu W (patrz [8]). Jest
on włączony w postaci źródeł fortranowskich. Została napisana nakładka (wrapper)
pozwalająca na wywoływanie tego narzędzia z kodu w języku C++.
3.2.5
LHAPDF
Pakiet LHAPDF dostarcza funkcje rozkładów partonów w hadronach (PDF). Ponieważ
jest to duży pakiet, to nie jest on dołączany do generatora WINHAC++, należy zainstalować go samodzielnie w systemie operacyjnym. Dostępny jest na stronie [16].
3.2.6
ROOT – opcjonalnie
Pakiet ROOT [17] nie jest wymagany do działania generatora. Był on używany przy
testach numerycznych do histogramowania. Jest on natomiast potrzebny do pełnego
uruchomienia programu demonstracyjnego.
21
3.2.7
Doxygen – opcjonalnie
Pakiet Doxygen [18] również nie jest wymagany do pracy generatora. Jest on wymagany do wygenerowania dokumentacji ze źródeł programu. Dokumentacja techniczna
[6] jest wygenerowana tym narzędziem.
3.3
Budowanie pakietu WINHAC++
Do budowania pakietu WINHAC++ postanowiono użyć nowoczesnego systemu budowania CMake [19]. Narzędzie to jest następcą Autotools (GNU Build System). Cechuje
się prostotą i wysoką konfigurowalnością. Korzystają z niego takie znane pakiety jak:
Boost C++ Libraries, KDE 4, MySQL oraz wiele, wiele innych.
Zasada działania jest prosta. Programista przygotowuje proste skrypty zawierające
informacje o strukturze projektu i zależnościach. Następnie należy wywołać:
$ cmake .
w katalogu budowanego projektu. Zaowocuje to sprawdzeniem konfiguracji systemu
operacyjnego i wygenerowaniem plików Makefile dla narzędzia make. W przypadku
niespełniania wymagań przez system operacyjny użytkownika zostanie wyrzucony błąd.
Ponadto CMake potrafi generować konfigurację dla zintegrowanych środowisk programistycznych, takich jak Eclipse czy Microsoft Visual Studio. W repozytorium
[14], jak i w archiwach z dystrubucją pakietu WINHAC++ znajdują się wygenerowane pliki
konfiguracyjne dla Eclipse.
3.4
Wejście–wyjście
Przed inicjalizacją generatora należy podać mu ścieżki do katalogu z danymi wejściowymi oraz sprecyzować ścieżkę, do której ma być zapisane wyjście generatora (patrz
sekcja 3.6).
3.4.1
Wejście
Wejście generatora podzielone jest na kilka plików. Większość z nich została stworzona w XML, poza plikiem z ziarnem generatora liczb losowych, ze względu na wygodę
przy używaniu generatora na farmach obliczeniowych. Predefiniowane pliki wejściowe
można znaleźć w katalogu input w wersji dystrybucyjnej generatora, jest to katalog
wzorcowy.
InputData.xml, UserFile.xml
Są to główne pliki wejściowe generatora. W pliku InputData.xml zawarte są wszystkie (poza ziarnem generatora) ustawienia generatora WINHAC++ (dokumentacja dostępna na [6]). Plik ten nie powinien być modyfikowany przez użytkownika, gdyż grozi to
nieprawidłowym działaniem generatora.
22
Dla użytkownika udostępniono wzorzec pliku (UserFile.xml ) służącego do wprowadzania własnych ustawień. Polega to na tym, że plik użytkownika jest podzbiorem pliku
głównego. Następnie tagi występujące w pliku głównym są w odpowiedni sposób podmieniane tymi, które zdefiniowane zostały w pliku użytkownika. Generatorowi należy
podać ścieżkę do pliku ze swoimi ustawieniami, w przeciwnym razie zostaną zastosowane
ustawienia domyślne.
W trakcie inicjalizacji tworzone jest echo wczytanych parametrów, tak aby użytkownik mógł sprawdzić czy poprawnie przygotował swój plik.
ParticleDataBase.xml
Jest to plik z danymi używanych w programie cząstek. Zawarto w nim ekstrakt
danych z pliku generatora Pythia [20]: ParticleData.xml. Aby zmienić dane cząstek
należy go edytować.
seed.dat
Plik zawierający ziarno generatora liczb losowych – liczbę typu long.
semaphore
W przypadku generowania zdarzeń metodą generateEvents(double NbEvents) sterowanie procesem odbywa się przez plik semaphore/semaphore w katalogu wejściowym.
Jeśli użytkownik używa metody generateEvent() (generującej jedno zdarzenie), to również może używać tego pliku, jednak wtedy musi sam wywołać odpowiednie metody
udostępniane przez generator. Semafor może mieć trzy stany:
• continue – nie zatrzymuj generacji,
• stop – zatrzymaj generację, zrzuć wyniki,
• resume – wznów generację ze zrzutu danych innej (wymaga obecności zrzutu
danych w katalogu wyjściowym).
W przypadku ręcznego wznawiania generatora należy ustawić semafor na resume i
użyć odpowiedniej metody.
3.4.2
Wyjście
Pliki wyjściowe zrzucane są do wcześniej ustawionego katalogu. Ponadto pliki niezbędne do wznowienia pracy generatora zrzucane są do podkatalogu snapshots co 105
zdarzeń w przypadku generowania metodą generateEvents(double NbEvents). Użytkownik nie korzystający z tej metody może samodzielnie wywołać zrzucanie tych plików
używając odpowiedniej metody generatora. Przy zapisywaniu nowych plików robione
są kopie zapasowe starych.
generator.dat
Do tego pliku zrzucany jest stan generatora liczb losowych, służący do wznawiania go. Jest to realizowane dzięki wbudowanej funkcjonalności generatorów z pakietu
CLHEP.
23
MonitorsBackup.dat
Do tego pliku zrzucane są niezbędne dane potrzebne do wznowienia monitorów wag.
numberOfEvents.dat
Do tego pliku zapisywana całkowita liczba wygenerowanych przypadków.
XSections.dat
Do tego pliku zrzucane są wszystkie obliczane przekroje czynne wraz z błędami
statystycznymi, w postaci:
nazwa : w a r t o s c : b l a d
InputEcho.xml
Plik tworzony przez parser Xerces-C zawierający ustawienia, jakie zostały wczytane
z plików wejściowych.
XSectionCrude.dat
Plik zawierający uproszczony przekrój czynny w formacie:
wartosc : blad
histograms.root (tylko w programie demonstracyjnym)
Plik zawiera zserializowane obiekty histogramów pakietu ROOT używanych w programie demonstracyjnym. W innych przypadkach plik ten nie występuje.
3.5
Struktura obiektowa
Zaprojektowana struktura obiektowa została w pełni oparta na analizie algorytmu realizowanego przez generator (patrz rozdział 2). Algorytm został funkcjonalnie
zdekomponowany na odpowiednie interfejsy i klasy. Klasy generatora znajdują się w
przestrzeni nazw VINHAC.
Pełną strukturę obiektową można znaleźć w dokumentacji technicznej [6]. Tutaj
przybliżę tylko najważniejsze jej składniki.
3.5.1
Klasa Event
Klasa Event jest prostą klasą będącą nośnikiem informacji o przypadku. Zawiera
w sobie obiekty reprezentujące cząstki biorące udział w zdarzeniu oraz informację o
24
obliczonych wagach. Dostęp do większości składowych przypadku realizowany jest przez
referencję ze względów wydajnościowych.
Dodatkowo klasa posiada dwie metody:
s t r i n g printInLabFrame ( ) ;
s t r i n g printInQuarksCMSFrame ( ) ;
zwracające sformatowane napisy zawierające informacje o czteropędach i rodzajach cząstek w układzie laboratoryjnym (LAB) i w układzie środka masy (CMS) zderzających
się kwarków.
3.5.2
Nadrzędna klasa Manager i jej pochodna WINHAC
Klasa Manager początkowo była planowana jako wspólny rdzeń generatorów WINHAC++
oraz ZINHAC. Oba generatory miały mieć bardzo podobny przepływ sterowania, stąd
był powód takiego planowania. Jednak wraz z upływem czasu oba projekty ewoluowały
osobno i nie wiadomo czy będzie to potrzebne. Klasa WINHAC rozszerza Manager i
w ten sposób staje się podstawową klasą używaną przez użytkownika. Aby korzystać z
generatora należy utworzyć instancję klasy WINHAC.
Obiekt klasy Manager jest, jak sama nazwa wskazuje, odpowiedzialny za tworzenie
i uruchamianie wewnętrzych obiektów klas, m. in. takich jak:
• InitializationHandler — odpowiada za przeprowadzenie inicjalizacji generatora
• implementujących interfejs ProcessHandler — odpowiadają za generowanie przypadku; generator posiada wektor takich obiektów, na których jest wywoływana
metoda eventEvolve, sukcesywnie prowadząc do stworzenia przypadku.
Najważniejszą metodą udostępnioną użytkownikowi jest:
Event g e n e r a t e E v e n t ( ) ;
Generator wytwarza w niej jeden przypadek i zwraca go użytkownikowi, który może
następnie przy pomocy metod klasy Event wyciągnąć z niej wszelkie informacje.
Z punktu widzenia użytkownika innymi ważnymi metodami są:
void a d d P r o c e s s H a n d l e r (VINHAC : : P r o c e s s H a n d l e r ∗ h a n d l e r ) ;
void r e m o v e P r o c e s s H a n d l e r ( s t r i n g Name ) ;
umożliwiające dodawanie własnych obiektów sterowania procesem generacji.
3.5.3
Interfejs ProcessHandler i jego pochodne
Interfejs ProcessHandler został wyspecyfikowany w celu ujednolicenia dostępu poszczególnych modułów programu do generowanego przypadku.
25
class ProcessHandler {
private :
s t r i n g handlerName ;
public :
v i r t u a l bool e v e n t E v o l v e (VINHAC : : Event& e v e n t ) = 0 ;
v i r t u a l ˜ P r o c e s s H a n d l e r ( ) {}
i n l i n e s t r i n g getHandlerName ( ) {
return handlerName ;
}
i n l i n e void setHandlerName ( s t r i n g name ) {
handlerName = name ;
}
};
Czysto wirtualna metoda eventEvolve służy jako uniwersalny dostęp modułów do generowanego zdarzenia. Dostęp jest realizowany przez referencję, aby niepotrzebnie nie
kopiować przypadku.
Interfejs ten służy również do włączenia obsługi użytkownika generowanych przypadków. Użytkownik może rozszerzyć ten interfejs i włączyć swój ProcessHandler w
obsługę przypadków (patrz rozdział 3.6).
Poniższy diagram przedstawia klasy pochodne.
Rysunek 3.1: Klasy pochodne interfejsu ProcessHandler.
BeamHandler
Obiekt klasy BeamHandler realizuje część algorytmu opisaną w rozdziale 2.2. Dodatkowo w czasie inicjalizacji obiektu wyliczany jest przekrój czynny „crude” (rozdział
2.1.1).
26
BeamHandler odpowiada również za obsługę FOAMa i PDFów (patrz rozdział 3.2).
Dostęp do PDFów realizowany jest przez interfejs PDF (patrz rozdział 3.5.4).
HardProcessHandler
Obiekt klasy HardProcessHandler realizuje część algorytmu opisaną w rozdziale 2.3.
ModelHandler
Obiekt klasy ModelHandler realizuje część algorytmu opisaną w rozdziale 2.4.
MonitorHandler
Obiekt klasy MonitorHandler realizuje część algorytmu opisaną w rozdziale 2.5.
Dokonuje on również finalizacji (rozdział 2.7).
Dla każdej wykrytej wagi tworzy obiekt klasy WeightMonitor, będący nośnikiem danych dla kumulowanych statystyk. Potrafi również zrzucać i przywracać stan monitorów
wag.
DemoAnalysisHandler
Klasa DemoAnalysisHandler pokazuje jak realizować część algorytmu opisaną w
rozdziale 2.6. Jest to wzorzec dla użytkownika. Patrz rozdział 3.6.
3.5.4
Interfejs PDF i jego pochodne
Interfejs został stworzony aby ujednolicić dostęp do różnych parametryzacji PDFów.
Dzięki temu łatwo będzie można rozszerzyć generator WINHAC++ o inne pakiety z PDFami.
Najważniejszymi deklarowanymi metodami są:
v i r t u a l v e c t o r <double> x f x ( double x , double q ) = 0 ;
v i r t u a l double x f x ( double x , double q , int f l ) = 0 ;
zwracają one wartości PDFów pomnożone przez x Bjorkena.
Obecnie realizowane są trzy typy obsługi:
• PDF noPDF — brak hadronów, x = 1,
• PDF Simple — prosta parametryzacja,
• PDF LHA — pakiet LHAPDF (patrz rozdział 3.2).
27
Rysunek 3.2: Klasy pochodne interfejsu PDF.
3.5.5
InitializationHandler – inicjalizacja
Obiekt klasy InitializationHandler jest używany przez klasę nadrzędną do:
• przetworzenia plików wejściowych,
• stworzenia i zainicjalizowania podstawowych ProcessHandlerów.
Przetwarzanie wejścia odbywa się przez interfejs Reader.
Interfejs Reader i jego pochodne
Interfejs Reader został stworzony w celu ujednolicenia dostępu do różnych formatów
plików wejściowych.
Obecnie zaimplementowane jest przetwarzanie plików formatu XML, używana jest
do tego klasa XercesReader implementująca interfejs. Korzysta ona wewnętrznie z pakietu Xerces-C (patrz rozdział 3.2).
Rysunek 3.3: Klasy pochodne interfejsu Reader.
Obecność interfejsu Reader pozwoli w przyszłości na „bezbolesne” dodanie nowego
typu plików inputowych lub przeorganizowanie istniejącego.
3.6
Demo
Został napisany program demonstracyjny używający biblioteki pakietu WINHAC++.
Był on używany przeze mnie do robienia testów. Jest to bardzo prosta i przejrzysta
aplikacja, która może służyć użytkownikowi jako wzór postępowania ze stworzoną biblioteką.
Program demonstracyjny składa się z dwóch części, można je znaleźć w katalogu src
w dystrybucji programu. Są to:
• Demo.cpp
• vinhac/DemoAnalysisHandler.h wraz z vinhac/DemoAnalysisHandler.cpp.
28
Po zbudowaniu projektu, plik wykonywalny Demo można znaleźć w katalogu build/exec, zaś przykładowy wydruk z uruchomienia programu można znaleźć w pliku example run 100000 i386.log w dystrybucji programu oraz w dodatku C. Jeśli użytkownik
posiada zainstalowany system ROOT to wyświetlą mu się również histogramy obserwabli kolekcjonowanych przez DemoAnalysisHandler, podobne do przedstawionych w
rozdziale 4.2.
Demo.cpp
W tym pliku znajduje się główna część aplikacji demonstracyjnej. Tworzony jest
obiekt generatora WINHAC++. Jest on inicjalizowany. Następnie generowane są zdarzenia. Na końcu wypisywane jest podsumowanie zawierające skumulowane wagi i przekroje czynne. Dodatkowo uruchamiana jest ROOTowska aplikacja rysująca histogramy
zarejestrowane przez obiekt klasy DemoAnalysisHandler, włączony w obsługę przypadku.
Poniżej można znaleźć źródło tego programu
#include <i o s t r e a m >
#include ”LHAPDF/LHAPDF. h”
using namespace s t d ;
//CMake a u t o m a t i c a l l y c h e c k s i f t h e r e i s ROOT on your s y st e m and s e t s p r o p e r f l a g
#i f d e f ROOT HIST
#include ”TCanvas . h”
#include ” T A p p l i c a t i o n . h”
#endif
#include
#include
#include
#include
” v i n h a c /WINHAC. h”
” v i n h a c / V i n h a c E x c e p t i o n . h”
” v i n h a c / DemoAnalysisHandler . h”
” v i n h a c / Event . h”
i n t main ( i n t a r g c , char∗ a r g v [ ] ) {
string
string
string
double
userPath ;
inputPath ;
outputPath ;
eventsNb ;
/∗ Reading command l i n e p a r a m e t e r s ∗/
i f ( a r g c <3 ) {
cout<<” Usage : Demo [ i n p u t path ] [ ou tp ut path ] ”
<<”<number o f e v e n t s > <u s e r f i l e path>”<<e n d l ;
return 1 ;
}
i f ( a r g c >= 3 ) {
/∗ r e a d i n g p a t h t o i n p u t and o u t p u t d i r e c t o r y ∗/
inputPath = argv [ 1 ] ;
outputPath = a r g v [ 2 ] ;
}
i f ( a r g c >3 ) {
/∗ r e a d i n g number o f e v e n t s t o g e n e r a t e ∗/
eventsNb = a t o f ( a r g v [ 3 ] ) ;
} else {
/∗ d e f a u l t number o f e v e n t s ∗/
eventsNb = 1 0 0 0 0 ;
}
i f ( a r g c >4){
/∗ p a t h t o U s e r F i l e . xml−l i k e f i l e ∗/
userPath = argv [ 4 ] ;
}
29
try {
// C r e a t i o n o f WINHAC i n s t a n c e
VINHAC : : WINHAC g e n e r a t o r ;
// C r e a t i o n o f DemoAnalysisHandler i n s t a n c e
VINHAC : : DemoAnalysisHandler d e m o A n a l y s i s H a n d l e r ;
// S e t t i n g p a t h t o i n p u t , o u t p u t and U s e r F i l e . xml−l i k e
g e n e r a t o r . setInputPath ( inputPath ) ;
g e n e r a t o r . setOutputPath ( outputPath ) ;
g e ne r a to r . setUserFilePath ( userPath ) ;
file
// I n i t i a l i z a t i o n o f WINHAC
g e n e r a t o r . i n i t i a l i z e G e n e r a t o r ( argc , argv ) ;
// Adding own DemoAnalysisHandler t o g e n e r a t o r ’ s P r o c e s s H a n d l e r s v e c t o r
// This s t e p s h o u l d be done a f t e r i n i t i a l i z a t i o n
g e n e r a t o r . a d d P r o c e s s H a n d l e r (& d e m o A n a l y s i s H a n d l e r ) ;
// The main e v e n t s g e n e r a t i o n l o o p
cout<<”######## GENERATION #########”<<e n d l ;
double i =0;
f o r ( i =0; i <eventsNb ; i ++){
VINHAC : : Event e v e n t = g e n e r a t o r . g e n e r a t e E v e n t ( ) ;
// Generator makes s n a p s h o t
i f ( fmod ( i ,100000)==0){
g e n e r a t o r . makeSnapshot ( outputPath+” / s n a p s h o t s ” , i +1);
cout<<i +1<<e n d l ;
}
// Here c o u l d be some u s e r ’ s code h a n d l i n g e v e n t
}
cout<<”############################”<<e n d l ;
cout<<” Generated : ”<<i <<” e v e n t s ”<<e n d l ;
// Generator makes s n a p s h o t
g e n e r a t o r . makeSnapshot ( outputPath , i ) ;
// Here a r e some o u t p u t s a f t e r g e n e r a t i o n
cout . p r e c i s i o n ( 1 5 ) ;
// The main c r o s s s e c t i o n w i t h i t s e r r o r
cout<<” X s e c t i o n = ”<<g e n e r a t o r . g e t F i n a l X s e c t i o n ()<<” +/− ”
<<g e n e r a t o r . g e t F i n a l X s e c t i o n E r r o r ()<< e n d l ;
// This method p r i n t s w e i g h t s and c r o s s s e c t i o n s
g e n e r a t o r . printSummary ( ) ;
// This method c a u s e s t h a t
// demoAnalysisHandler w r i t e s ROOT’ s h i s t o g r a m s t o o u t p u t d i r e c t o r y
d e m o A n a l y s i s H a n d l e r . makeSnapshot ( outputPath ) ;
// Below you can f i n d ROOT a p p l i c a t i o n drawing c o l l e c t e d h i s t o g r a m s
#i f d e f ROOT HIST
T A p p l i c a t i o n theApp ( ” theApp ” ,& a r g c , a r g v ) ;
TCanvas kanwa ( ”kanwa” , ” H i s t o g r a m s ” , 5 , 5 , 1 0 2 4 , 7 6 8 ) ;
kanwa . D i v i d e ( 2 , 3 ) ;
kanwa . cd ( 1 ) ;
d e m o A n a l y s i s H a n d l e r . g e t W r a p i d i t y H i s t ( ) . Draw ( ) ;
kanwa . cd ( 2 ) ;
d e m o A n a l y s i s H a n d l e r . g e t C o s T h e t a H i s t ( ) . Draw ( ) ;
kanwa . cd ( 3 ) ;
d e m o A n a l y s i s H a n d l e r . getLeptonPTHist ( ) . Draw ( ) ;
kanwa . cd ( 4 ) ;
d e m o A n a l y s i s H a n d l e r . g e t L e p t o n P s e u d o r a p i d i t y H i s t ( ) . Draw ( ) ;
kanwa . cd ( 5 ) ;
d e m o A n a l y s i s H a n d l e r . getWTransverseMass ( ) . Draw ( ) ;
kanwa . cd ( 6 ) ;
30
d e m o A n a l y s i s H a n d l e r . g e t P h o t o n M u l t i p l i c i t y ( ) . Draw ( ) ;
TCanvas kanwa2 ( ”kanwa2” , ” H i s t o g r a m s 2 ” , 5 , 5 , 1 0 2 4 , 7 6 8 ) ;
kanwa2 . cd ( 1 ) ;
d e m o A n a l y s i s H a n d l e r . g et P ho t on s En e rg y ( ) . Draw ( ) ;
TCanvas kanwa4 ( ”kanwa4” , ” H i s t o g r a m s 4 ” , 5 , 5 , 1 0 2 4 , 7 6 8 ) ;
kanwa4 . cd ( 1 ) ;
d e m o A n a l y s i s H a n d l e r . getHardPhotonPt ( ) . Draw ( ) ;
TCanvas kanwa3 ( ”kanwa3” , ” H i s t o g r a m s 3 ” , 5 , 5 , 1 0 2 4 , 7 6 8 ) ;
kanwa3 . cd ( 1 ) ;
d e m o A n a l y s i s H a n d l e r . getHardPhotonEnergy ( ) . Draw ( ) ;
TCanvas kanwa5 ( ”kanwa5” , ” H i s t o g r a m s 5 ” , 5 , 5 , 1 0 2 4 , 7 6 8 ) ;
kanwa5 . cd ( 1 ) ;
d e m o A n a l y s i s H a n d l e r . getHardPhotonEta ( ) . Draw ( ) ;
theApp . Connect ( ”TCanvas” , ” C l o s e d ( ) ” , ” T A p p l i c a t i o n ” ,&theApp , ” Terminate ( ) ” ) ;
theApp . Run ( ) ;
#endif
} catch (VINHAC : : V i n h a c E x c e p t i o n e ) {
// In c a s e o f p r o b l e m s WINHAC t h r o w s
// V i n h a c E x c e p t i o n w i t h message what ’ s wrong .
cout<<”EXCEPTION : ”<<e . g e t M e s s a g e ()<< e n d l ;
}
}
Klasa DemoAnalysisHandler
Ta klasa jest integralną częścią programu demonstracyjnego. Pokazuje ona użytkownikowi w jaki sposób może być realizowana jego własna obsługa zdarzenia włączona w
zestaw ProcessHandlerów wywoływanych przy generowaniu każdego zdarzenia. Implementuje ona wirtualną metodę eventEvolve, która wydobywa ze zdarzenia potrzebne
informacje i konstruuje obserwable.
DemoAnalysisHandler.h
#include <s t r i n g >
using namespace s t d ;
#i f n d e f
#define
#include
#include
#include
#include
#include
#include
#include
DemoAnalysisHandler h
DemoAnalysisHandler h
” Manager . h”
” Event . h”
” P r o c e s s H a n d l e r . h”
” P a r t i c l e . h”
<f s t r e a m >
” . . / u t i l s /CLHEP/ V e c t o r / V e c t o r / L o r e n t z V e c t o r . h”
<c s t r i n g >
#i f d e f ROOT HIST
#include ”TH1D . h”
#include ” T F i l e . h”
#include ” TObject . h”
#endif
namespace VINHAC {
c l a s s Manager ;
c l a s s Event ;
class P a r t i c l e ;
31
class AnalisysHandler ;
}
namespace VINHAC {
// !
d e m o n s t r a t i o n c l a s s showing how t o w r i t e your own h a n d l e r .
/∗ !
∗ I t i s showed h e r e how t o w r i t e your own h a n d l e r by e x t e n d i n g P r o c e s s H a n d l e r
∗ and you can p a s s i t t o g e n e r a t o r u s i n g Manager ( i . e . WINHAC) methods .
∗ This example j u s t c u m u l a t e s some o b s e r v a b l e s u s i n g ROOT h i s t o g r a m s .
∗ @see P r o c e s s H a n d l e r
∗ @see Manager
∗ @see WINHAC
∗/
c l a s s DemoAnalysisHandler : public VINHAC : : P r o c e s s H a n d l e r {
private :
#i f d e f ROOT HIST
// //ROOT h i s t o g r a m s :
TFile h f i l e ;
i n t numberOfBins ;
TH1D h s t W r a p i d i t y ;
TH1D h s t c o s T h e t a ;
TH1D h s t l e p t o n P T ;
TH1D h s t l e p t o n P s e u d o r a p i d i t y ;
TH1D h s t p h o t o n m u l t i p l i c i t y ;
TH1D hst WTransverseMass ;
TH1D
TH1D
TH1D
TH1D
hst
hst
hst
hst
photonsEnergy ;
hardPhotonEnergy ;
hardPhotonPt ;
hardPhotonEta ;
#endif
VINHAC : : Manager ∗ p Manager ;
public :
/∗ ∗
∗ \ b r i e f evolves the event
∗
∗ I t d o e s w h o l e p a r t o f g e n e r a t i o n p r o c e s s which i s t o do i n t h i s h a n d l e r
∗ @see Event
∗ @param e v e n t r e f e r e n c e t o c u r r e n t Event o b j e c t
∗ @return i f w e i g h t was z e r o
∗/
bool e v e n t E v o l v e (VINHAC : : Event& e v e n t ) ;
#i f d e f ROOT HIST
i n l i n e TH1D& g e t W r a p i d i t y H i s t ( ) {
return h s t W r a p i d i t y ;
}
i n l i n e TH1D& g e t C o s T h e t a H i s t ( ) {
return h s t c o s T h e t a ;
}
i n l i n e TH1D& getLeptonPTHist ( ) {
return h s t l e p t o n P T ;
}
i n l i n e TH1D& g e t L e p t o n P s e u d o r a p i d i t y H i s t ( ) {
return h s t l e p t o n P s e u d o r a p i d i t y ;
}
i n l i n e TH1D& getWTransverseMass ( ) {
return hst WTransverseMass ;
}
i n l i n e TH1D& g e t P h o t o n M u l t i p l i c i t y ( ) {
return h s t p h o t o n m u l t i p l i c i t y ;
}
i n l i n e TH1D& g et P ho to n sE n er g y ( ) {
return h s t p h o t o n s E n e r g y ;
32
}
i n l i n e TH1D& getHardPhotonEnergy ( ) {
return h s t h a r d P h o t o n E n e r g y ;
}
i n l i n e TH1D& getHardPhotonPt ( ) {
return h s t h a r d P h o t o n P t ;
}
i n l i n e TH1D& getHardPhotonEta ( ) {
return h s t h a r d P h o t o n E t a ;
}
#endif
/∗ ∗
∗ \ b r i e f saves histograms to s p e c i f i e d path
∗
∗ @param s n a p s h o t P a t h p a t h t o f o l d e r where h i s t o g r a m s have t o be s a v e d
∗/
bool makeSnapshot ( s t r i n g s n a p s h o t P a t h ) ;
DemoAnalysisHandler ( ) ;
˜ DemoAnalysisHandler ( ) { } ;
} ; // c l a s s DemoAnalysisHandler
} // namespace VINHAC
#endif
DemoAnalysisHandler.cpp
#include <s t r i n g >
using namespace s t d ;
#include ” DemoAnalysisHandler . h”
// C r e a t e s h i s t o g r a m s o b j e c t s
VINHAC : : DemoAnalysisHandler : : DemoAnalysisHandler ( )
#i f d e f ROOT HIST
:
numberOfBins ( 1 0 0 ) ,
h s t W r a p i d i t y ( ”W: r a p i d i t y y” , ”W: r a p i d i t y y” ,
numberOfBins , −6, 6 ) ,
hst cosTheta ( ” lepton : cos ( theta ) ” ,
” l e p t o n : c o s ( t h e t a ) ” , numberOfBins , −1, 1 ) ,
h s t l e p t o n P T ( ” l e p t o n : p T” , ” l e p t o n : p T” , numberOfBins , 0 , 5 0 ) ,
hst leptonPseudorapidity ( ” lepton : pseudorapidity eta ” ,
” l e p t o n : p s e u d o r a p i d i t y e t a ” , numberOfBins , −6, 6 ) ,
h s t p h o t o n m u l t i p l i c i t y ( ” photon : m u l t i p l i c i t y ” ,
” photon : m u l t i p l i c i t y ” , 1 0 , 0 , 1 0 ) ,
hst WTransverseMass (
”W: t r a n s v e r s e mass ” , ”W: t r a n s v e r s e mass ” , numberOfBins ,
0 , 150) ,
h s t p h o t o n s E n e r g y ( ” photon : e n e r g y sum” ,
” photon : e n e r g y sum” , numberOfBins , −1, 5 0 ) ,
h s t h a r d P h o t o n E n e r g y ( ” photon : hard photon e n e r g y ” ,
” photon : hard photon e n e r g y ” , numberOfBins , −1, 5 0 ) ,
h s t h a r d P h o t o n P t ( ” photon : hard photon pt ” ,
” photon : hard photon pt ” , numberOfBins , −1, 5 0 ) ,
h s t h a r d P h o t o n E t a ( ” photon : hard photon e t a ” ,
” photon : hard photon e t a ” , numberOfBins , −6, 6 )
#endif
{
// Fo r ce s h i s t o g r a m s t o s t o r e sum o f w e i g h t s s q u a r e d
#i f d e f ROOT HIST
h s t W r a p i d i t y . Sumw2 ( ) ;
h s t c o s T h e t a . Sumw2 ( ) ;
h s t l e p t o n P T . Sumw2 ( ) ;
h s t l e p t o n P s e u d o r a p i d i t y . Sumw2 ( ) ;
h s t p h o t o n m u l t i p l i c i t y . Sumw2 ( ) ;
33
hst
hst
hst
hst
hst
WTransverseMass . Sumw2 ( ) ;
p h o t o n s E n e r g y . Sumw2 ( ) ;
h a r d P h o t o n E n e r g y . Sumw2 ( ) ;
h a r d P h o t o n P t . Sumw2 ( ) ;
h a r d P h o t o n E t a . Sumw2 ( ) ;
#endif
setHandlerName ( ” DemoAnalysisHandler ” ) ;
}
bool VINHAC : : DemoAnalysisHandler : : e v e n t E v o l v e (VINHAC : : Event& e v e n t ) {
// E x t r a c t i n g d a t a from Event o b j e c t
P a r t i c l e& boson = e v e n t . getBoson ( ) ;
P a r t i c l e& l e p t o n = e v e n t . g e t L e p t o n ( ) ;
P a r t i c l e& n e u t r i n o = e v e n t . g e t N e u t r i n o ( ) ;
double
double
double
double
double
double
double
double
double
double
yw = − 5 0 . 0 ;
cosTheta = −2.0;
e t a l = −50.0;
pTl = − 1 0 . 0 ;
pTn = − 1 0 . 0 ;
wTransverseMass = − 1 0 . 0 ;
photonsEnergy = − 1 0 . 0 ;
hardPhotonE = − 1 0 . 0 ;
hardPhotonPt = − 1 0 . 0 ;
hardPhotonEta = − 1 0 . 0 ;
// E x t r a c t i n g main w e i g h t from e v e n t
double mainWt = e v e n t . mainWt ( ) ;
// C o n s t r u c t i o n o f o b s e r v a b l e s
i f ( mainWt != 0 . 0 ) {
double EnW = boson . getFourMomentum ( ) . e ( ) ;
double pzW = boson . getFourMomentum ( ) . pz ( ) ;
yw = 0 . 5 ∗ l o g ( (EnW + pzW) / (EnW − pzW ) ) ;
CLHEP : : H epLore ntzVe ctor p l = l e p t o n . getFourMomentum ( ) ;
CLHEP : : H epLore ntzVe ctor pn = n e u t r i n o . getFourMomentum ( ) ;
c o s T h e t a = p l . z ( ) / p l . getV ( ) . mag ( ) ;
double t h e t a = a c o s ( c o s T h e t a ) ;
e t a l = −l o g ( tan ( t h e t a / 2 ) ) ;
pTl = l e p t o n . getFourMomentum ( ) . getV ( ) . rho ( ) ;
pTn = n e u t r i n o . getFourMomentum ( ) . getV ( ) . rho ( ) ;
wTransverseMass = s q r t ( 2 ∗ ( pTl ∗ pTn − p l . x ( ) ∗ pn . x ( ) − p l . y ( )
∗ pn . y ( ) ) ) ;
photonsEnergy = 0 . 0 ;
f o r ( unsigned i = 0 ; i < e v e n t . g e t P h o t o n s ( ) . s i z e ( ) ; ++i ) {
photonsEnergy += e v e n t . g e t P h o t o n s ( ) [ i ] . getFourMomentum ( ) . e ( ) ;
}
i f ( event . getPhotons ( ) . s i z e ( ) > 0) {
hardPhotonE =
e v e n t . g e t P h o t o n s ( ) [ 0 ] . getFourMomentum ( ) . e ( ) ;
hardPhotonPt =
e v e n t . g e t P h o t o n s ( ) [ 0 ] . getFourMomentum ( ) . getV ( ) . rho ( ) ;
double cosThetaPhoton =
e v e n t . g e t P h o t o n s ( ) [ 0 ] . getFourMomentum ( ) . z ( )
/ e v e n t . g e t P h o t o n s ( ) [ 0 ] . getFourMomentum ( ) . getV ( ) . mag ( ) ;
double t h e t a P h o t o n = a c o s ( cosThetaPhoton ) ;
hardPhotonEta = −l o g ( tan ( t h e t a P h o t o n / 2 ) ) ;
}
}
// F i l l i n g h i s t o g r a m s
#i f d e f ROOT HIST
34
hst
hst
hst
hst
hst
hst
hst
hst
hst
hst
W r a p i d i t y . F i l l (yw , mainWt ) ;
c o s T h e t a . F i l l ( cosTheta , mainWt ) ;
l e p t o n P T . F i l l ( pTl , mainWt ) ;
l e p t o n P s e u d o r a p i d i t y . F i l l ( e t a l , mainWt ) ;
WTransverseMass . F i l l ( wTransverseMass , mainWt ) ;
p h o t o n m u l t i p l i c i t y . F i l l ( e v e n t . g e t P h o t o n s ( ) . s i z e ( ) , mainWt ) ;
p h o t o n s E n e r g y . F i l l ( photonsEnergy , mainWt ) ;
h a r d P h o t o n E n e r g y . F i l l ( hardPhotonE , mainWt ) ;
h a r d P h o t o n P t . F i l l ( hardPhotonPt , mainWt ) ;
h a r d P h o t o n E t a . F i l l ( hardPhotonEta , mainWt ) ;
#endif
return true ;
}
bool VINHAC : : DemoAnalysisHandler : : makeSnapshot ( s t r i n g s n a p s h o t P a t h ) {
#i f d e f ROOT HIST
s t r i n g f i l e P a t h = snapshotPath + ”/ histograms . r o o t ” ;
s t r i n g filePathBak = snapshotPath + ”/ histogramsBak . r o o t ” ;
s t r i n g m v f i l e c o m a n d = ”mv ” + f i l e P a t h + ” ” + f i l e P a t h B a k ;
system ( m v f i l e c o m a n d . c s t r ( ) ) ;
T F i l e r o o t S a n p s h o t ( f i l e P a t h . c s t r ( ) , ”RECREATE” , ” Snapshot h i s t o g r a m s ” ) ;
hst
hst
hst
hst
hst
hst
hst
hst
hst
hst
W r a p i d i t y . Write ( ) ;
c o s T h e t a . Write ( ) ;
l e p t o n P T . Write ( ) ;
l e p t o n P s e u d o r a p i d i t y . Write ( ) ;
p h o t o n m u l t i p l i c i t y . Write ( ) ;
WTransverseMass . Write ( ) ;
p h o t o n s E n e r g y . Write ( ) ;
h a r d P h o t o n E n e r g y . Write ( ) ;
h a r d P h o t o n P t . Write ( ) ;
h a r d P h o t o n E t a . Write ( ) ;
r o o t S a n p s h o t . Write ( ) ;
rootSanpshot . Close ( ) ;
#endif
return true ;
}
3.6.1
Skrypty dla farm komputerowych
Podczas rozwoju projektu WINHAC++ powstały skrypty uruchamiające program demonstracyjny na farmie obliczeniowej. Skrypty zostały napisane dla systemu kolejkowego PBS, a konkretnie uruchamiane były na systemie TORQUE. Użytkownik znający
programowanie skryptów powłoki łatwo może dostosować je do swojego systemu kolejkowego. Można je znaleźć w dystrybucji w katalogu farm.
Uruchamianie na farmie przebiega w następujący sposób:
• pliki wejściowe należy przygotować w katalogu głównym w podkatalogu input,
• przejść do podkatalogu farm i tam wykonać następujące kroki:
– uruchomić skrypt make jobs.sh, który stworzy zadania w katalogu jobs (ustawienia PBS są w pliku pbs.properties),
– uruchomić skrypt run jobs.sh, który wysyła zadania do systemu kolejkowego,
– po zakończeniu zadań uruchomić skrypt combine.sh, który połączy wyniki z
poszczególnych zadań w jedno wyjście w katalogu output.
35
Rozdział 4
Testy
W czasie fazy implementacji były robione testy porównawcze (na małych statystykach) z wersją fortranową generatora WINHAC w celu sprawdzania poprawności implementacji i wychwytywania błędów. Po zakończeniu fazy implementacyjnej przeprowadzono ostateczne testy przy użyciu farmy obliczeniowej. W tym rozdziale zamieszczam
część wyników uzyskanych w czasie tych testów, zaś wszystkie wyniki i parametry wejściowe można znaleźć na stronie WWW generatora [6].
W testach sprawdzano zgodność przekrojów czynnych uzyskiwanych z obu generatorów jak również tworzono histogramy obserwabli wymienionych w rozdziale 2.6.
Rozważano procesy wyszczególnione w tabeli 4.1 w podrozdziale 4.1.
Dla każdego procesu generowano statystyki wielkości dwóch miliardów (2 × 109 )
przypadków. Energie wiązek wynosiły w przypadku procesu partonowego i hadronowego
odpowiednio po 40 GeV i 7 TeV.
Uzyskano bardzo dobrą zgodność generatora WINHAC++ z pierwowzorem, zaimplementowanym w języku Fortran.
4.1
Przekroje czynne
W tabeli 4.1 zamieściłem zestawienie otrzymanych całkowitych przekrojów czynnych. Podano przekrój czynny na poziomie Borna oraz względne przyczynki poprawek
elektrodynamicznych (QED) i „słabych” (weak) do całkowitego przekroju czynnego. W
testach używano schematu Gµ .
Obliczano:
model
• σBorn z użyciem wagi wBorn
,
model
• σQED z użyciem wagi wYFS
O(α) QED ,
model
• σEW z użyciem wagi wYFS
O(α) EW ,
oraz względne przyczynki poprawek do całkowitego przekroju czynnego:
δQED =
σQED − σBorn
,
σBorn
(4.1)
δweak =
σEW − σQED
.
σBorn
(4.2)
36
Proces
Generator
ud¯ → W + + X → e+ νe , µ+ νµ + X
WINHAC
pp → W + X → eνe , µνµ + X
WINHAC++
WINHAC
WINHAC++
pp → W − + X → e− ν̄e + X
WINHAC
pp → W + + X → e+ νe + X
WINHAC
pp → W − + X → µ− ν̄µ + X
WINHAC
pp → W + + X → µ+ νµ + X
WINHAC
pp → W − + X → τ − ν̄τ + X
WINHAC
pp → W + + X → τ + ντ + X
WINHAC
WINHAC++
WINHAC++
WINHAC++
WINHAC++
WINHAC++
WINHAC++
σBorn [nb]
15.00753135(2)
15.00753132(3)
35.54376(5)
35.54384(5)
7.574157(12)
7.574149(12)
10.197775(16)
10.197802(15)
7.574150(12)
7.574116(12)
10.197765(16)
10.197749(15)
7.572035(12)
7.572021(12)
10.194957(16)
10.194945(15)
δQED [%]
−0.0349(5)
−0.0345(5)
−0.0368(5)
−0.0390(5)
−0.0352(6)
−0.0344(6)
−0.0349(6)
−0.0369(6)
−0.0326(5)
−0.0317(5)
−0.0328(5)
−0.0323(5)
−0.0793(5)
−0.0796(5)
−0.0799(5)
−0.0799(5)
δweak [%]
−0.2837(7)
−0.2837(7)
−0.2837(7)
−0.2830(7)
−0.2794(8)
−0.2809(8)
−0.2794(8)
−0.2794(8)
−0.2880(7)
−0.2887(7)
−0.2880(7)
−0.2885(7)
−0.2928(7)
−0.2926(7)
−0.2928(7)
−0.2938(7)
Tabela 4.1: Porównanie przekrojów czynnych otrzymanych przy użyciu generatorów
WINHAC i WINHAC++ (w nawiasach podano błąd statystyczny dla ostatnich cyfr).
Dla uzyskanych przekrojów czynnych na poziomie Borna uzyskano zgodność między
oboma generatorami na poziomie < 0.01%. Podobną zgodność uzyskano dla względnych
poprawek radiacyjnych δQED i δweak .
4.2
Histogramy obserwabli
W tym podrozdziale przedstawiam wybrane histogramy obserwabli opisanych w
rozdziale 2.6. Wszystkie otrzymane rozkłady wykazują bardzo dobrą zgodność obu generatorów. Na potwierdzenie tego pod każdym histogramem można znaleźć względną
różnicę w procentach między rozkładami z generatorów WINHAC i WINHAC++.
Na rysunkach 4.1–4.12 przedstawiam wybrane rozkłady:
• rapidity bozonu W ,
• pseudorapidity naładowanego leptonu,
• pędu poprzecznego naładowanego leptonu,
• masy transwersalnej bozonu W .
W procesach:
• pp → W + X → eνe , µνµ + X,
• pp → W − + X → e− ν̄e + X,
• pp → W + + X → e+ νe + X.
Pozostałe rozkłady dostępne są na stronie WWW [6].
37
A. Poziom Borna
(a)
(b)
Rysunek 4.1: Rozkłady rapidity (a) oraz masy transwersalnej (b) bozonu W dla procesu
pp → W + X → eνe , µνµ + X.
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.2: Rozkłady pseudorapidity elektronu (a) i pozytonu (b) z rozpadów
bozonów W .
38
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.3: Rozkłady pędu poprzecznego elektronu (a) i pozytonu (b) z rozpadów
bozonów W .
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.4: Rozkłady masy transwersalnej W − (a) i W + (b) dla rozpadów elektronowych.
39
B. Eksponencjacja – względne poprawki elektrodynamiczne (QED)
(a)
(b)
Rysunek 4.5: Rozkłady rapidity (a) oraz masy transwersalnej (b) bozonu W dla procesu
pp → W + X → eνe , µνµ + X.
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.6: Rozkłady pseudorapidity elektronu (a) i pozytonu (b) z rozpadów
bozonów W .
40
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.7: Rozkłady pędu poprzecznego elektronu (a) i pozytonu (b) z rozpadów
bozonów W .
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.8: Rozkłady masy transwersalnej W − (a) i W + (b) dla rozpadów elektronowych.
41
C. Eksponencjacja – względne poprawki elektrosłabe (EW)
(a)
(b)
Rysunek 4.9: Rozkłady rapidity (a) oraz masy transwersalnej (b) bozonu W dla procesu
pp → W + X → eνe , µνµ + X.
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.10: Rozkłady pseudorapidity elektronu (a) i pozytonu (b) z rozpadów
bozonów W .
42
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.11: Rozkłady pędu poprzecznego elektronu (a) i pozytonu (b) z rozpadów
bozonów W .
(a) pp → W − + X → e− ν̄e + X
(b) pp → W + + X → e+ νe + X
Rysunek 4.12: Rozkłady masy transwersalnej W − (a) i W + (b) dla rozpadów elektronowych.
43
Podsumowanie
W tej pracy omówiłem konstrukcję obiektowego generatora Monte Carlo WINHAC++,
służącego do modelowania naładowanych procesów Drella–Yana. Generator uwzględnia
poprawki radiacyjne w rozpadach bozonów W poprzez schemat ekskluzywnej eksponenecjacji YFS. Wiarygodność jego implementacji została potwierdzona przez testy
numeryczne polegające na porównaniach z jego pierwowzorem – generatorem WINHAC,
napisanym w języku Fortran.
Efektem niniejszej pracy jest pakiet dostarczający generator WINHAC++. Może on być
dołączony do programu użytkownika i w dowolny sposób przez niego używany.
Planowane jest:
• uwzględnienie interferencji radiacji ze stanu początkowego (ISR) z radiacją ze
stanu końcowego (FSR),
• dodanie opcji: generowanie przypadków nieważonych,
• dodanie nowej fizyki w postaci dodatkowych ciężkich bozonów naładowanych (W 0
itd.),
• implementacja procesów ze spolaryzowanymi bozonami W ,
• implementacja amplitud spinowych dla podwójnej radiacji,
• implementacja algorytmu kaskad partonowych stanu początkowego.
Dodatkowo podjęte zostaną próby podniesienia efektywności generacji przypadków,
ponieważ obecnie wydajność jest 4–5 razy gorsza od wersji fortranowskiej.
Podziękowania
Pragnę podziękować mojemu opiekunowi dr. hab. prof. UJ Wiesławowi Płaczkowi za opiekę naukową w czasie moich ostatnich dwóch lat studiów. Dziękuję za wszelką
pomoc i rady udzielone mi w czasie rozwijania projektu WINHAC++. Chciałbym podziękować również dr. Andrzejowi Siódmokowi za owocną współpracę w czasie pierwszej fazy
projektu. Szczególnie chciałbym podziękować rodzinie za wsparcie materialne i duchowe
w czasie moich studiów magisterskich, zwłaszcza mamie Dorocie, która zachęcała mnie
do podjęcia studiów w naukach ścisłych oraz żonie Agnieszce, która motywowała mnie
do bardziej wytężonej pracy.
44
Dodatek A
Struktura katalogów pakietu
WINHAC++
Poniżej przedstawiam opis struktury katalogowej pakietu WINHAC++ (widocznej na
rysunku A.1).
WINHAC – główny katalog pakietu WINHAC++.
build – pliki wynikowe budowania pakietu.
bin – binaria.
exec – pliki wykonywalne.
lib – biblioteki dzielone.
cmake – pliki pakietu CMake.
config – konfiguracja pakietu Doxygen.
farm – narzędzia przydatne do obliczeń na farmach komputerowych.
jobs – zadania.
output – tutaj zapisywany jest złączony wynik z wszystkich zadań.
input – pliki wejściowe.
semaphore – tutaj znajduje się plik semaphore.
lib – biblioteki potrzebne do zbudowania pakietu.
output – pliki wyjściowe.
snapshots – zrzuty stanu generatora.
src – źródła pakietu WINHAC++.
utils – źródła narzędzi zewnętrznych i pomocniczych.
CLHEP – klasy wyodrębnione z pakietu CLHEP.
farm – narzędzie do złączania wyników z farm komputerowych.
FOAM – źródła pakietu FOAM.
SANC – źródła pakietu SANC (dostarcza poprawki elektrosłabe).
vinhac – główne źródła pakietu WINHAC++.
vpproject – pliki z wstępnej analizy, otwierane pakietem Visual Paradigm.
45
Rysunek A.1: Struktura katalogów pakietu WINHAC++.
46
Dodatek B
Instalacja pakietu WINHAC++
Przedstawiam tutaj przykładową instalację pakietu WINHAC++. Zakładam, że użytkownik używa powłoki systemu Linux.
Pobranie pakietu
Używając Subversion
$ svn c h e c k o u t h t t p : / / w i n h a c p l u s p l u s . g o o g l e c o d e . com/ svn / t r u n k / WINHAC
Używając archiwum
Pobieranie
$ wget h t t p : / / th . i f . u j . edu . p l /˜ s o b o l /WINHAC/ r e l e a s e s /WINHAC−l a t e s t . t a r . gz
Rozpakowanie
$ t a r −z x v f WINHAC−l a t e s t . t a r . gz
Konfiguracja pakietu
$ cd WINHAC
$ cmake .
47
Budowanie pakietu
$ make
Uruchomienie programu demonstracyjnego
Bezpośrednio
$ . / b u i l d / exec /Demo i n p u t o ut pu t 100000 i n p u t / U s e r F i l e . xml
Narzędziem make
$ make run100000
Instalacja w systemie Linux
Uwaga! Należy mieć uprawnienia administratora.
Biblioteki dzielone:
• libwinhac.so,
• libwinhacUtils.so,
• libwinhacUtilsSanc.so
zostaną zainstalowane w katalogu /usr/local/lib, zaś pliki nagłówkowe zostaną skopiowane do katalogu /usr/local/include.
# make i n s t a l l
Użytkownik korzystający z pakietu WINHAC++ powinien skonsolidować wymienione
biblioteki dzielone ze swoim programem.
48
Dodatek C
Wydruk programu Demo
$$$$$$$$$$ SEED = 123456789
Reading user file: input/UserFile.xml
====================Initialize beamA===================
PDFinterface => LHAPDF
PDFsubset => 0
atomicNb =>
chargeNb =>
energy => 7000
idPDG => 2212
name => cteq61
nuclearCorre => 0
switchOn => off
xMax => 1.0
xMin => 1e-6
====================Initialize beamB===================
PDFinterface => LHAPDF
PDFsubset => 0
atomicNb =>
chargeNb =>
energy => 7000
idPDG => 2212
name => cteq61
nuclearCorre => 0
switchOn => off
xMax => 1.0
xMin => 1e-6
========================LHAPDF==============================
2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222|1000
2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222|2000
2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222|3000
2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222|4000
222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
######## GENERATION #########
100000
############################
Generated: 100000 events
Xsection = 35.4279828430281 +/- 0.0255806475700515
########################################################################
Weights
========================================================================
Crude
-----------------------------------------------------------------------HardProcessWeight
0.9681913045054
+/- 0.0007322965199577
PartonsGeneration
0.9684025667996
+/- 0.0002073056049222
XsCrudWt
36.69772346097
+/- 9.407186083896e-08
========================================================================
Model
-----------------------------------------------------------------------ModelBest
419.1830825492
+/- 194.5638284501
beta00
0.9592010001072
+/- 0.0004397286140017
beta01_EW
0.9780643000345
+/- 0.0004479817161729
beta01_EW + beta11
419.1830825492
+/- 194.5638284501
beta01_LL
0.9786969353816
+/- 0.0004482714755075
beta01_LL + beta11_LL
0.9885627251707
+/- 0.0003312758176593
49
beta01_QED
0.9809249862169
+/- 0.0004492919689975
beta01_QED + beta11
419.1859432354
+/- 194.5638283888
beta11
418.2050182492
+/- 194.563849431
beta11_LL
0.009865789789061
+/- 0.0001809025277456
xs00
0.8677579916274
+/- 0.00234192704801
xs0gEW
0.5411924345893
+/- 0.001440388588756
xs0gEW + xs1g
377.692553895
+/- 197.5341353221
xs0gQED
0.5437804045791
+/- 0.001447048556406
xs0gQED + xs1g
377.695141865
+/- 197.5341352726
xs1g
377.1513614605
+/- 197.5341456795
========================================================================
Main Weight
35.42798284303
+/- 0.02558064757005
########################################################################
########################################################################
Cross Sections [nb]
========================================================================
Best
-----------------------------------------------------------------------Best
35.42798284303
+/- 0.02558064757005
========================================================================
YFS exponentiation
-----------------------------------------------------------------------XsTot
O(alf0)
33.82060643907
+/- 0.02980816578882
XsTot_EW O(alf1)_EW
35.42798284303
+/- 0.02558064757005
XsTot_LL O(alf1)_LL
34.61149849327
+/- 0.02963853186642
XsTot_QED O(alf1)_QED
35.5288481906
+/- 0.02566437639096
========================================================================
Fixed Order
-----------------------------------------------------------------------Born
32.91291329328
+/- 0.08941723512663
Born + virtual_EW + soft
20.51381935047
+/- 0.05488088720806
Born + virtual_QED + soft
20.6119776296
+/- 0.05513528901415
O(alpha)_EW
35.40626611712
+/- 0.05213035937837
O(alpha)_QED
35.50442439625
+/- 0.05211838777165
One real hard photon
14.89244676666
+/- 0.07626061789237
========================================================================
All
-----------------------------------------------------------------------ModelBest
35.52959749185
+/- 0.02493836032027
beta00
33.91761080598
+/- 0.02933658254663
beta01_EW
34.58402225302
+/- 0.0299108957458
beta01_EW + beta11
35.52959749185
+/- 0.02493836032027
beta01_LL
34.60639241343
+/- 0.02993023936467
beta01_LL + beta11_LL
34.71077129918
+/- 0.02913643270782
beta01_QED
34.68517690289
+/- 0.02999836488673
beta01_QED + beta11
35.63075214173
+/- 0.0250206053146
beta11
0.9455752388329
+/- 0.01065249706878
beta11_LL
0.10437888575
+/- 0.001547518286787
xs00
33.00731421193
+/- 0.08949929740622
xs0gEW
20.57265714992
+/- 0.05492790630239
xs0gEW + xs1g
35.50781847797
+/- 0.05193287381771
xs0gQED
20.67109696692
+/- 0.05518249303395
xs0gQED + xs1g
35.60625829497
+/- 0.05191885400512
xs1g
14.93516132805
+/- 0.07643751049806
========================================================================
########################################################################
*************************************
*
LHAPDF Version 5.7.0
*
*************************************
>>>>>> PDF description: <<<<<<
CTEQ6.1
Reference:
J. Pumplin, D.R. Stump, J. Huston, H.L. Lai
W.K. Tung, S. Kuhlmann, J. Owens
hep-ph/0303013
This set has 41 member PDFs.
mem=0 --> central value (cteq61m)
mem=1-40 --> 20 sets of +ve/-ve error values
>>>>>>
<<<<<<
*************************************
*
LHAPDF Version 5.7.0
*
50
*************************************
>>>>>> PDF description: <<<<<<
CTEQ6.1
Reference:
J. Pumplin, D.R. Stump, J. Huston, H.L. Lai
W.K. Tung, S. Kuhlmann, J. Owens
hep-ph/0303013
This set has 41 member PDFs.
mem=0 --> central value (cteq61m)
mem=1-40 --> 20 sets of +ve/-ve error values
>>>>>>
<<<<<<
51
Bibliografia
[1] W. Płaczek and S. Jadach, Eur. Phys. J. C29, 325 (2003).
[2] S. D. Drell and T.-M. Yan, Phys. Rev. Lett. 25, 316 (1970).
[3] J. H. Christenson, G. S. Hicks, L. M. Lederman, P. J. Limon, B. G.
Pope, and E. Zavattini, Phys. Rev. Lett. 25, 1523 (1970).
[4] Wikipedia, the free encyclopedia, http://www.wikipedia.org, Grafiki.
[5] R. K. Ellis, W. J. Stirling, and B. R. Webber, QCD and Collider Physics,
Cambridge Univ. Press, Cambridge, 2003.
[6] K. Sobol, WINHAC++ Home Page,
http://th.if.uj.edu.pl/~sobol/WINHAC/index.html, 2010.
[7] D. Yennie, S. Frautschi, and H. Suura, Ann. Phys. (NY) 13, 379 (1961).
[8] D. Bardin, S. Bondarenko, S. Jadach, L. Kalinovskaya, and W. Placzek, Acta Phys. Polon. B40, 75 (2009).
[9] S. Jadach, Computer Physics Communications 152, 55 (2003).
[10] S. Jadach and P. Sawicki, Computer Physics Communications 177, 441 (2007).
[11] A. Siódmok, ZINHAC Home Page, http://th.if.uj.edu.pl/ZINHAC, 2010.
[12] Visual Paradigm, http://www.visual-paradigm.com.
[13] Eclipse, http://www.eclipse.org.
[14] K. Sobol, WINHAC++ @ Google Code,
http://code.google.com/p/winhacplusplus/, 2010.
[15] Xerces-C, http://xerces.apache.org/xerces-c.
[16] LHAPDF, http://projects.hepforge.org/lhapdf.
[17] ROOT, http://root.cern.ch.
[18] Doxygen, http://www.doxygen.org.
[19] Cmake, http://www.cmake.org.
[20] Pythia, http://home.thep.lu.se/~torbjorn/Pythia.html.
52