monte carlo simulation of particle production a …bm776hk7345/dissertation2... · monte carlo...

MONTE CARLO SIMULATION OF PARTICLE PRODUCTION

AND DECAY AT HIGH-ENERGY COLLIDERS

A DISSERTATION

SUBMITTED TO THE DEPARTMENT OF PHYSICS

AND THE COMMITTEE ON GRADUATE STUDIES

OF STANFORD UNIVERSITY

IN PARTIAL FULFILLMENT OF THE REQUIREMENTS

FOR THE DEGREE OF

DOCTOR OF PHILOSOPHY

Michael Edmund Davenport

August 2010

http://creativecommons.org/licenses/by-nc/3.0/us/

This dissertation is online at: http://purl.stanford.edu/bm776hk7345

© 2010 by Michael Edmund Davenport. All Rights Reserved.

Re-distributed by Stanford University under license with the author.

This work is licensed under a Creative Commons Attribution-Noncommercial 3.0 United States License.

ii



http://purl.stanford.edu/bm776hk7345

I certify that I have read this dissertation and that, in my opinion, it is fully adequatein scope and quality as a dissertation for the degree of Doctor of Philosophy.

Michael Peskin, Primary Adviser


JoAnne L. Hewett


Shamit Kachru

Approved for the Stanford University Committee on Graduate Studies.

Patricia J. Gumport, Vice Provost Graduate Education

This signature page was generated electronically upon submission of this dissertation in electronic format. An original signed hard copy of the signature page is on file inUniversity Archives.

iii

Acknowledgments

I am deeply indebted to a great number of people for helping me to complete my

graduate studies and this thesis. In particular I would like to thank my adviser

Michael Peskin for his constant help and support and for his patience through these

past several years.

I would also like to thank the many friends both in the Physics community and

throughout Stanford who have helped my persevere and stay sane. They are far to

numerous to list both in number or in value of their support.

Finally, I could never fully put in words how grateful I am for my parents for their

continued love, support, and encouragement

iv

Contents

Acknowledgments iv

1 Introduction 1

2 Overview 6

3 Physics Review 9

3.1 Hard Processes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.2 Individual decays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.3 Helicity Amplitudes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.4 Color Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.5 Multiple decay channels . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.6 Beam Physics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.7 Calculation Conventions . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.7.1 Angular Conventions . . . . . . . . . . . . . . . . . . . . . . . 33

3.7.2 Polarization Conventions . . . . . . . . . . . . . . . . . . . . . 36

4 Monte Carlo Methods 42

4.1 Monte Carlo Integration . . . . . . . . . . . . . . . . . . . . . . . . . 43

4.2 Monte Carlo Event Generation . . . . . . . . . . . . . . . . . . . . . 48

4.3 Adaptive Monte Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . 50

5 Object-Oriented Programming and Class Hierarchy 56

5.1 Philosophy of Object-Oriented Programming . . . . . . . . . . . . . . 56

v

5.1.1 C++ programming conventions . . . . . . . . . . . . . . . . . 58

5.2 Class Hierarchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

5.3 Monte Carlo Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

5.4 Process Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

5.5 Decay Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

5.6 Luminosity Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5.7 Pandora Class and Output . . . . . . . . . . . . . . . . . . . . . . . . 72

6 Implementation of New Physics 75

6.1 Common Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

6.2 Invariants Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

6.3 Using the kinematic classes . . . . . . . . . . . . . . . . . . . . . . . . 81

6.3.1 Processes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

6.3.2 Decays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

6.4 Using an existing completed class . . . . . . . . . . . . . . . . . . . . 91

6.5 Using the processtype and decaytype classes . . . . . . . . . . . . . . 92

6.5.1 Decays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

6.5.2 Processes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

6.6 Using the complexdecay class . . . . . . . . . . . . . . . . . . . . . . 99

6.7 A more complex example . . . . . . . . . . . . . . . . . . . . . . . . . 102

6.8 Generating Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

7 Catalog of Implemented New Physics 113

7.1 Standard Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

7.1.1 Standard Model Processes . . . . . . . . . . . . . . . . . . . . 114

7.1.2 SM Decays . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

7.2 SUSY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

7.2.1 SUSYspectrum . . . . . . . . . . . . . . . . . . . . . . . . . . 123

7.2.2 SUSY processes . . . . . . . . . . . . . . . . . . . . . . . . . . 131

7.2.3 SUSY decays . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

vi

8 Examples 139

8.1 e−e+ → µ−µ+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

8.2 pp→ 2 jets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

8.3 e−e+ → C−C+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

A Invariants Classes 167

A.1 Invariants for 2 → 2 processes . . . . . . . . . . . . . . . . . . . . . . 167

A.2 Invariants for 1 → 2 decays . . . . . . . . . . . . . . . . . . . . . . . . 170

Bibliography 172

vii

List of Tables

3.1 PDFs included in pandora . . . . . . . . . . . . . . . . . . . . . . . . 31

6.1 The xychannel naming convention for initial channel constants . . . 77

6.2 Common initial channel functions . . . . . . . . . . . . . . . . . . . . 78

6.3 LEvent member functions. The integers m and n refer to the index

number in the LEvent. . . . . . . . . . . . . . . . . . . . . . . . . . . 112

7.1 The produceOnly() function in eetopairs . . . . . . . . . . . . . . . . 115

7.2 MSSM particles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

7.3 SUSYspectrum input parameters . . . . . . . . . . . . . . . . . . . . . 125

7.4 MSSM particle mass eigenstates. There is mixing in the scalar Higgs

sector as well, but we use the mass eigenstates and mixings as inputs. 126

7.5 VFF couplings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

7.6 VSS couplings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

7.7 SFF couplings. fu refers to up type quarks or neutrinos. fd refers to

down type quarks an leptons. . . . . . . . . . . . . . . . . . . . . . . 128

7.8 SSS couplings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

7.9 SVV couplings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

8.1 SPS4 properties relevant to e−e+ → C+1 C

−1 . . . . . . . . . . . . . . . 155

viii

List of Figures

3.1 Sketch of full event based on an image from the SHERPA collabora-

tion [10]. The hard event on the left is simulated by pandora. On the

right it is represented by the white circle in the center, while the rest

of the effects including parton showering, hadronization and multiple

interactions are pictured. . . . . . . . . . . . . . . . . . . . . . . . . . 10

3.2 All four of these diagrams could contribute to the same final state.

Diagrams (a) and (b) involve 2 → 2 processes followed by several

resonant decays and are included in the pandora calculation. Diagram

(c) and (d) could be described as 2 → 5 processes with one resonant

decay, and are not considered in basic pandora calculations. In general,

they contribute much less than the enhanced resonant decay diagrams

(a) and (b). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3.3 (a) The expression for the set of all one-particle-irreducible (1PI) in-

sertions. (p) The exact propagator which is the geometric series of all

1PI insertions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3.4 Some of the diagrams for e−e+ → e−e+νeνe (there are 49 more). . . . 19

3.5 A basic color structure diagram . . . . . . . . . . . . . . . . . . . . . 23

3.6 Color structure for an color octet decaying to two octets . . . . . . . 24

3.7 There are three possible color structure diagrams for 88→ 33, diagrams

(b), (c), and (d). However, only (b) appears in the gg → qq diagram

(a). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

ix

3.8 Two overlapping Breit-Wigner resonances. If there is a kinematic con-

straint m2 < m1 then a large piece of the m2 resonance may be kine-

matically inaccessible at certain points in phase space, strongly affect-

ing the width integral . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.9 A general process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.10 The 2 → 2 event plane (needs work) . . . . . . . . . . . . . . . . . . . 34

3.11 Kinematics for a 2→3 event. The three final particles fall in the 3′− 1′

plane, and the orientation of that plane with respect to the beam axis

are defined by three Euler rotation angles φ, θ, and ψ. . . . . . . . . . 35

3.12 Weyl spinor Feynman rules . . . . . . . . . . . . . . . . . . . . . . . . 39

4.1 A peaked 2-dimensional integrand that would not be efficiently sampled

by a sampling distribution p(x1, x2) = g1(x1)g2(x2) since it it flat in

both variables. A more efficient sampling would use the distribution

p(x1, x2) = g1(x1 − x2)g2(x1 + x2) since it is peaked in the x1 − x2

direction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

4.2 The peaked Breit-Wigner integrand over masses (a), can be made a

reasonably flat integrand over a unit interval (b) by changing variables

using the inverse of the Breit Wigner cumulative distribution function. 47

4.3 A peaked function in x2, cut off by the condition x2 < x1. . . . . . . . 53

5.1 Hierarchy image of a pandora object involving the process eetoCC. . 62

5.2 Hierarchy image of a eetoWW object. The location of the function

corresponds to the level it is initialized at, and the color to the level it

is defined at. So amplitudes() is initialized by the process class as

a virutal function and is finally defined by eetoWW. . . . . . . . . . . 65

5.3 Hierarchy image of a eetoWW object. . . . . . . . . . . . . . . . . . . . 65

5.4 Hierarchy image of a HiggstoZgdecay object. The location of the func-

tion corresponds to the level it is initialized at, and the color to the level

it is defined at. So properamplitudes() is initialized by the decay

class as a virutal function and is finally defined by HiggstoZgdecay. 68

x

6.1 Diagrams for e−γ → W−νe . . . . . . . . . . . . . . . . . . . . . . . . 86

6.2 Diagrams contributing to the eetoCC class. . . . . . . . . . . . . . . . 98

7.1 MSSM Coupling diagrams. For scalars, all momenta p are outgoing.

For vectors, ε∗ should be used for final state vectors. For fermions, Fi

should be replaced by the appropriate u or v spinor. . . . . . . . . . . 127

7.2 Diagrams contributing to e−e+ → NiNj. . . . . . . . . . . . . . . . . 133

7.3 Diagrams for e−e+ → C+i C

−j . . . . . . . . . . . . . . . . . . . . . . . 134

7.4 Diagrams contributing to e−e+ → f f ′. . . . . . . . . . . . . . . . . . 135

8.1 Diagrams contributing to the eetomumu class. . . . . . . . . . . . . . 140

8.2 The Z peak in e−e+ → µ−µ+ for each polarization state at a ILC type

collider. The unpolarized peak is overlapped by the e−Re+L peak. . . . . 144

8.3 Diagrams contributing to qq′ → q′′q′′′. . . . . . . . . . . . . . . . . . . 145

8.4 Color indices for the qq′g vertex. . . . . . . . . . . . . . . . . . . . . . 146

8.5 Diagrams contributing to gg → gg. . . . . . . . . . . . . . . . . . . . 149

8.6 Diagrams contributing to e−e+ → C+1 C

−1 . . . . . . . . . . . . . . . . 154

8.7 Plots of cos θ eC+ from the beam axis for the process e−e+ → C+1 C

−1

at benchmark point SPS4. The plots correspond to (a) e−Le+R at a 500

GeV ILC (b) e−Re+L at a 500 GeV ILC (c) e−Le

+R at a 1 TeV ILC and (d)

e−Re+L at a 1 TeV ILC. . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

8.8 The nominal angular distribution of C+ various diagrams for e−Le+R →

C1 + C−1 . Figure (a) is the s-channel diagram distribution at 500 GeV.

Figure (b) is the u-channel diagram distribution at 500 GeV. Figure

(c) is the s-channel diagram distribution at 1 TeV. Figure (d) is the

u-channel diagram distribution at 1 TeV. . . . . . . . . . . . . . . . . 159

xi

8.9 Plots for e−Re+L → C+

1 C−1 at a 500 GeV ILC collider at the benchmark

point SPS4. (a) A plot of cos θ eC+1

from the beam axis in the lab frame.

(b) A plot of cos θW+, eC+1

in the rest frame of the C+1 in the backward

(cos θ eC+1< −.8) region. (c) A plot of cos θW+, eC+

1in the rest frame of

the C+1 in the forward (cos θ eC+

1> .8) region. (d) A plot of cos θf,fW+

in the rest frame of the W+ in the backward (cos θ eC+1< −.8) region.

(e) A plot of cos θf,W+ in the rest frame of the W+ in the forward

(cos θ eC+1> .8) region. . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

8.10 Plots for e−Re+L → C+



from the beam axis in the lab frame.

(b) A plot of cos θW+, eC+1

in the rest frame of the C+1 in the backward

(cos θ eC+1< −.8) region. (c) A plot of cos θW+, eC+

1in the rest frame of

the C+1 in the forward (cos θ eC+

1> .8) region. (d) A plot of cos θf,fW+

in the rest frame of the W+ in the backward (cos θ eC+1< −.8) region.

(e) A plot of cos θf,W+ in the rest frame of the W+ in the forward

(cos θ eC+1> .8) region. . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

8.11 Angular distribution of various decay helicity amplitudes for C+1L at

SPS4. Black is the full decay angular distribution, red is the W+0 N1L

channel, orange is the W+R N1R channel, blue is the W+

0 N1R channel

and green is the W+L N1L channel. The amplitudes for C+

1R replaces

cos θ with − cos θ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

8.12 Plots of angular distribution in the lab frame . . . . . . . . . . . . . . 164

8.13 Feynman diagram of the full decay chain resulting from the process

e−e+ → C+2 C

−2 at LCC3. . . . . . . . . . . . . . . . . . . . . . . . . . 165

8.14 Plot of the energy of each leg of the C+2 decay chain in the process

e−e+ → C+2 C

−2 for the MSSM benchmark point LCC3. . . . . . . . . 166

xii

Chapter 1

Introduction

With the completion and operation of the Large Hadron Collider at CERN, a new

era in elementary particle physics has been opened. By probing new energy scales,

questions about electroweak symmetry breaking, Dark Matter, and the structure of

physics beyond the Standard Model may soon be answerable. For the most part those

answers, if they are to be found, will not come simply, but will require dedicated and

rigorous data analysis.

One of the main tools of that analysis will be Monte Carlo event generator soft-

ware. Each individual collision at the LHC will produce massive amounts of informa-

tion. To have any confidence in a particular physical effect, it must be shown to occur

at a statistically significant level over thousands of individual collisions. In order to

sift through the data it is necessary to have some idea of what sort of signals to look

for as interesting, and in order to understand if some interesting signal corresponds to

a particular physical model it must be shown that the model should produce just that

signal in the collider. This is the service that event generators provide. They give

physicists a window into what to expect from particular physical models in a collider

and where they should focus their efforts to find the detectable signals of these new

models.

While the Standard Model has been remarkably successful at describing particle

physics over a wide range of energies, many of the open questions in physics that

the LHC may address revolve around its problems, or physics that it cannot address.

1

CHAPTER 1. INTRODUCTION 2

Numerous ideas for physics Beyond the Standard Model have been proposed. These

models, in particular, address the hierarchy problem, namely why the electroweak

scale is so much lower than the Planck scale, and the nature of Dark Matter, that

missing 80% of the mass in the universe. These BSM models propose new particles

and new interactions which will hopefully have observable signatures at the LHC and

other colliders. Event generators are needed to see exactly what those signatures will

be.

Supersymmetry and in particular the MSSM (Minimal Supersymmetric Standard

Model) is one of the better motivated BSM ideas. It has been studied extensively and

was one of the first new physics models to be implemented in event generators. More

recently other BSM physics models, in particular UED (Universal Extra Dimensions),

have been implemented in some available generators. Event generators should also

provide tools for implementing user-defined models that could ideally address any

new physics idea. The ability to generate events for a variety of BSM physics ensures

that a breadth of collider signatures, not limited to any particular model, can be

investigated in detail. There is no guarantee that nature will behave like the most

popular and well motivated models, so the ability to analyze a wide variety of potential

new physics is necessary.

The proton collisions at the LHC, increasing to its full design energy of 14 TeV,

will produce collisions with energies far beyond those previously observed. This may

make it possible to discover a variety of new physics. While its high energy and

luminosity will be ideal for certain types of analysis, it is possible that many properties

of new particles and interactions will be hard to measure, in particular due to the

lack of knowledge about the initial momentum state of the colliding partons. The

proposed International Linear Collider would address some of these limitations and

ideally would complement the work of the LHC by being able to produce precision

measurements of some of the new physics properties. While at a much lower collision

energy of 500 GeV or 1 TeV, the precise knowledge of the initial state of the colliding

particles, both in momentum and in polarization, would allow detailed study of new

particles that were kinematically accessible to the collider. Just as for the LHC, event

generators will be a key component of any analysis at the ILC. In particular, the


generators must be able to correctly calculate the spin effects so the correct angular

correlations are generated. While these spin effects are not completely absent in LHC

collisions, they are crucial to the precision and power of the ILC.

There are a variety of event generators available to facilitate the study of physics

at the LHC and ILC. They are all built on the same basic concept. An appropriate

cross section integrand for the events being studied is created, and the integral is

evaluated numerically. The numerical process, know as Monte Carlo integration,

involves randomly sampling the integrand a very large number of times to build up

a numerical value. In the process an efficient sampling distribution over the cross

section integrand is constructed and this can be very easily converted into an efficient

event generator.

A variety of effects must be considered to fully describe an event at a collider.

First there is the hard collision of individual particles from the beams to a set of

particles leaving the collision point. This hard event can be computed by building up

scattering amplitudes from Feynman diagrams of the process. The particles leaving

the collision point will generally be highly energetic and will radiate energy into a

series of particles. This process is known as parton showering. Further, any free

colored states must fragment into color neutral hadron states, creating even more

particles in a process known as hadronization. Additionally, there is the possibility

that multiple pairs of particles from the initial beams will collide creating even more

final state particles to keep track of. Tools exist to handle all of these effects, although

some tools focus only on a subset of them, usually the hard event. Efforts have been

made in the event generation community to facilitate communication between the

various tools, so that full event descriptions can be built up using multiple tools.

While this same basic process applies to the core of all particle physics event gen-

erators, the choices involved in what approximations to make on the cross section

and what particular types of physics to focus on leads to a variety of tools. The most

commonly used tools in the particle physics community, particularly amongst exper-

imental collaborations, are PYTHIA [1] and HERWIG [2, 3]. The goal of both of

these programs is to provide as complete an event description as possible, beginning


with the hard collision and including all beam effects, parton showering, hadroniza-

tion and multiple parton scattering. Both focus on calculating the hard process to

the leading order, focusing on the dominant resonant decay diagrams. While both

try to accurately treat the other beam effects, they use different approaches to do so.

For instance, the hadronization in PYTHIA is built on the Lund string fragmentation

model while HERWIG uses a cluster hadronization model. Both programs have im-

plemented tools to allow files with basic hard events to be imported and the parton

showering, hadronization, and multiple interaction effects added on the complete the

event picture. Many other event generators, including ours, take advantage of this to

focus on generating more complicated hard events and using PYTHIA and HERWIG

to generate the additional collision effects.

While the hard event generators in PYTHIA and HERWIG are very good and are

used extensively in the particle physics community, they generally only implement

specific models and processes, and they simulate those processes using a particular set

of assumptions. In particular they focus on the dominant resonance decay diagrams,

which will not include all of the possible interference in the event. The ALPGEN

event generator focuses on a variety of multijet SM processes important for hadron

collisions and has specific codes to recursively construct all diagrams for those pro-

cesses and generate events for them [4]. It can connect to PYTHIA or HERWIG to

complete the full event picture. The CalcHEP/CompHEP [5, 6], GRACE [7], and

MadGraph/MadEvent [8] programs attempt to further compute all of the tree level

Feynman diagrams for any given initial and final state given the Feynman rules of a

particular model. While calculations will include all interference effects for computed

processes, they come at a large computational cost to construct the diagrams and

efficiently sample the complicated pole structure of the phase spaces. The SHERPA

event generator [9] also computes the full set of tree level diagrams, but also extends

this to a full event description including parton showering and hadronization.

This thesis will focus on our particular event generator, pandora. Our goal was

to build a generator that would facilitate the study of any BSM physics model in

an efficient but fairly complete way. In particular we wanted to insure a complete

description of all spin effects in the hard events were accounted for, in particular for


facilitating polarization effects at ILC type colliders. We do not attempt to include all

contributing Feynman diagrams, but focus on the enhanced resonant decay diagrams,

which will facilitate more efficient generation, at the expense of some of the interfer-

ence terms. This will allow us to generate events for the long decay chains that are

common in many BSM models, which result in a large number of final state particles.

We do not attempt to build our own full event description, but take advantage of the

tools in place to apply the full event effects to our results using other well developed

parton showering and hadronization tools. We hope that this tool will be useful for

investigations of the phenomenology of a variety of BSM physics models at new high

energy colliders.

Chapter 2

Overview

This thesis will discuss the computer program pandora, a Monte Carlo event gener-

ator for new physics models at next generation particle colliders. This program was

designed to generate the hard processes and subsequent decays at a variety of collid-

ers, particularly the LHC and proposed ILC. Its particular virtue is that it keeps track

of all spin correlations through the long decay chains that occur in many new physics

models. The SM and MSSM and a few other BSM models are fully implemented.

Pandora is written to take advantage of object oriented programming to provide a

simple method for expansion of existing models or implementation of completely new

physics. Pandora does not calculate all physics effects present at a collider, but pan-

dora’s output can be interfaced with other programs to hadronize final state particles

and calculate initial and final state radiation effects to give a fuller picture of the

collider behavior.

In Chapter 3 we will discuss the underlying physics involved in generating events

with pandora. The first step in the event generation process is to calculate the cross

section integral for the particular interactions being studied. We will break down the

cross section into its constituent parts, starting with an initial hard process. Next we

discuss the decay of any unstable massive particles in the final states and a consistent

approach to account for their contribution to the cross section integral. In order

to correctly calculate all spin correlations, we use explicit helicity amplitudes for the

initial process and all decays. The benefits of this approach will be shown. Finally we

6

CHAPTER 2. OVERVIEW 7

will review the nature of the various types of initial beams that different colliders may

have, and the contribution of those beam types to the overall cross section integral for

the process. We will also cover the main conventions we use to complete the required

calculations. In its current form, pandora is limited to leading-order expansion of the

cross section, and to 2 → 2 and 2 → 3 hard processes. It allows, however arbitrarily

many decay steps and final state particles

In Chapter 4 we discuss the process of numerically calculating the cross section

integral described in Chapter 3 using Monte Carlo integration. This integral is made

more efficient using the VEGAS Monte Carlo method. We will show how the VEGAS

integration of the cross-section translates directly into efficient generation of physics

events. Finally, we will discuss a solution to a problem of calculating decay widths

when decaying particles can go off the mass shell, introduced in Chapter 3. The

solution involves simultaneously calculating multiple decay width integrals and using

the results to modify the full cross section integral.

In Chapter 5, we describe the object oriented nature of the pandora program.

We will discuss the general philosophy of Object Oriented Programming and how

it matches well with the mathematical structure of the cross section integral we are

trying to compute. We will then describe the general class hierarchy in pandora

and the nature of the various types of classes that are involved, discussing how the

general integration algorithm of Chapter 4 is executed. A particular focus is the use

of inheritance, a feature of Object Oriented Programming, that allows the building of

new object on top of older ones. This allows us to treat each new feature once, such

as a particular decay kinematics, and allow many objects to inherit those features

and build upon them.

Next we use Chapter 6 to discuss the practical methods of implementing a New

Physics model into pandora. First we discuss a variety of tools and conventions that

are used across all classes to help facilitate the implementation. Then we discuss

several particular methods for defining a new physics class, each building on different

features of already implemented classes. We provide examples of each type of imple-

mentation to help show the practical requirements of each process. We finish with an

example that makes use of several of the processes to construct a complicated physics

CHAPTER 2. OVERVIEW 8

process, specifically the decay of the Higgs sector in the MSSM. We also provide

instruction on setting up and running simulations.

In Chapter 7 we describe the various physics models that are currently imple-

mented into pandora. First we review the basic Standard Model processes and de-

cays that are included. Next we turn to the Minimal Supersymmetric Standard

Model(MSSM), reviewing the basic terms of the Lagrangian for that model. We then

describe the tools we have included to calculate a specific MSSM mass spectrum and

set of interactions. Finally we describe the implementation of the implemented MSSM

processes and decays. Finally we turn to the ttBSM model, which is a general model

for calculating s-channel production of top quarks through a variety of propagators,

specifically scalar, vector and tensor bosons of various color states.

Next we use Chapter 8 to describe in detail a series of processes that can be

generated in pandora, looking at physics involved and the specific implementation of

the process and decay classes and the structure of the C++ code. First we consider

a basic e−e+ → µ−µ+ process which is completely described by one class. Next

we consider the pp → 2 jets process that is also described by a single class, but

will illustrate the handling of complicated color structures. Finally we look at the

more complicated e−e+ → C−1 C

+2 process from the MSSM, which will illustrate the

handling of complicated decay structures.

Chapter 3

Physics Review

This review is intended to discuss all of the aspects of physics involved in the complete

event description used in pandora. The first issue to address is the exact calculation

we intend pandora to carry out. Most of the physics that we are interested in at

high energy colliders will be the result of an extremely high energy collision of two

beam particles, called a hard process. While these hard processes may have enough

energy to create new physics particles, most massive particles that are created will

be extremely short lived and decay down to SM particles. The true final state of a

particle collision will be some number of electrons, muons, neutrinos, mesons, and

photons, as well as any new massive particles that are stable enough to reach or pass

through the detector without decaying. Many, if not most, of the leptons and photons

will be the result of radiation from particles going to or leaving the hard process, but

separated by some distance from it. This radiation, and similar radiation from free

colored states, is known as parton showering. The mesons will generally be collected

in tight groupings called jets that contain color neutral bound states that are products

of the highly energetic quarks and gluons and the colored particles they radiate by

parton showering. These mesons themselves can also radiate and further decay down

to a stable set of mesons. This process of creating hadrons from free quarks and

gluons is called hadronization. Additionally, there may be secondary simultaneous

interactions that may contribute even more final state particles not related to the

hard process. A sketch of this complicated series of processes that contribute to the

9

CHAPTER 3. PHYSICS REVIEW 10

�Figure 3.1: Sketch of full event based on an image from the SHERPA collabora-tion [10]. The hard event on the left is simulated by pandora. On the right it isrepresented by the white circle in the center, while the rest of the effects includingparton showering, hadronization and multiple interactions are pictured.

full event is given in Figure 3.1.

The physics of these processes, parton showering, hadronization, and simultaneous

events, are generally separable from the details of the hard process and do not depend

on new physics. They are well modeled by several available programs, including

PYTHIA, HERWIG, and SHERPA. Given the details of the hard event and the

resulting light SM particles, they can shower the high energy SM particles and build

up color neutral jets for any free colored particles. We do not intend to calculate these

other effects in pandora but will restrict ourselves to calculating the hard process.

We will calculate a cross section for a given beam to a final state that is made up of

stable SM particles and any new massive particles that are stable. By stable we mean

particles that will travel a detectable distance from the initial collision point before

decays. For our purposes, all of the standard model fermions are stable, except for

the top quark. Since their masses are negligible compared to the large energies being

produced in the collision, it will be a good approximation to treat all of these fermions

—again, excluding the top quark— as massless. In a slight abuse of terminology we

will refer to all of these stable massless SM particles as partons. Thus, the initial state


of any pandora event will be two of these SM partons and the final state will include

some combination of these SM partons and stable massive new physics particles. This

output can be passed to other programs to apply the other event effects and get a

full event description.

In order to generate physics events for a hard process we need to calculate the

cross section of the initial beams to all the various final parton states that we are

interested in. For a given initial and final state, this cross section is built on the

squared scattering amplitude, which can be calculated as the sum over all connected,

amputated Feynman diagrams. We will only consider the lowest order tree level

diagrams in our calculations. Higher order loop diagrams would be necessary for the

most accurate calculations and are particularly important for calculating an accurate

SM background for new physics. For the purposes of generating new physics events

themselves, we will restrict ourselves to the tree level amplitudes.

Even considering just the tree level diagrams of the hard process, there are choices

to be made in calculating the cross section and generating events. There is a variety of

event generation software available and it is worth considering these other programs

and what choices they made in their design. The most straightforward and complete

way to calculate the cross section is to list the desired initial and final particles and

to draw every possible tree-level diagram that can connect them. These diagrams are

then summed over, squared and integrated. While the most direct process, it is also

the most computationally involved. First there is the calculation of all of the Feyn-

man diagrams with the number of graphs growing faster than factorially as legs are

added. Additionally, with each new leg, each diagram is more complicated with more

and more distinct pole structures that will make efficiently sampling events from these

amplitudes more computationally expensive. Still, in return for the additional com-

putational cost, the full interference of all tree level diagrams will be correctly treated.

This method of calculating all applicable Feynman diagrams is implemented by the

MadGraph/MadEvent, GRACE, CompHEP/CalcHEP, and SHERPA programs. In

addition the ALPGEN program follows a similar philosophy of including all diagrams.

It focuses on a specific subset of events, namely SM multijet events that are important

for hadron collisions, but has the Feynman diagram calculations hard coded into the


program, along with the pole structure.

In order to more efficiently generate events, it is useful to consider which tree level

diagrams will be most dominant in any given interaction. Since the propagator for

any internal line of a Feynman diagram is proportional to 1/(p2−m2− iε), there will

be an enhancement when any internal line is on-shell (p2 = m2). If we insist that

most of the internal lines are nearly on-shell we will get resonance diagrams which

can be interpreted as, after an initial interaction, a series massive particles decaying

down to less massive particles until a final state of stable particles is achieved. This

greatly reduces the number of contributing diagrams and makes all of the diagrams

have a fairly consistent pole structure that can be efficiently generated. This method

of calculating hard events is implemented by PYTHIA and HERWIG, in addition

to their showering and hadronization processes. These programs have been and are

the workhorse event generators for the particle physics community, particularly for

detailed simulations and analyses run by many experimental collaborations.

For pandora, we choose to follow the second path, focusing on the tree level

resonant diagrams. This will allow us to efficiently generate new physics events with

many final state particles resulting from long decay chains. We intend to provide a

platform to implement new physics models relatively easily and to generate events

that will take into account the full spin correlations of all the resonant diagrams.

3.1 Hard Processes

Focusing on the resonant diagrams for a given hard process allows us to break the

calculation into two main sections. First, there is what we will refer to as the process,

two initial partons interacting and resulting in two or three particles (a 2→2 or 2→3

process). In principle, pandora can handles 2 → n processes; however, we have

have provided tools to facilitate new processes only up to n = 3. Second, there are

the decays of those two or three resultant particles into other particles, and further

decays of those particles until a final state of stable particles is achieved. Again, this

prescription will leave out some tree level diagrams, as shown in Figure 3.2, but will

include the enhanced resonant diagrams and facilitate a more efficient integration and


�(a)�

(b)�

(c)�

(d)

Figure 3.2: All four of these diagrams could contribute to the same final state. Di-agrams (a) and (b) involve 2 → 2 processes followed by several resonant decays andare included in the pandora calculation. Diagram (c) and (d) could be described as2 → 5 processes with one resonant decay, and are not considered in basic pandoracalculations. In general, they contribute much less than the enhanced resonant decaydiagrams (a) and (b).

event generation.

We will first consider the simplest case of a 2→2 or 2→3 process with no decays.

The standard cross-section integral for a process from two initial partons p1 and p2

to some final state X has the form

σ =1

2s

∫dΠ |M(p1 + p2 → X)|2 (3.1)

where M is the amplitude of the process in question and dΠ is the phase space of

the final state (either 2 or 3 particles). For a given initial process (defined by the

two initial partons and the first two or three daughters) there are a small number

of diagrams contributing to the scattering amplitude. These must be encoded into

pandora. In order to correctly model the spin correlations we use helicity amplitudes,

distinguishing distinct sets of initial and final state spins. The properties of these

helicity amplitudes are discussed in Section 3.3. In general color is treated such

that different color structure diagrams are distinguished and squared separately. We

discuss the color factors and color structures, including the process of ensuring the

correct color interference terms, in Section 3.4. Thus we can express our general

scattering amplitude more specifically as∫dΠ

∑λ1,λ2,λX ,c

|Mc(p1λ1 + p2λ2 → XλX)|2 (3.2)


where λ1 and λ2 are the initial parton spin state, λX is the final state spin state and

c is a particular color structure.

Since there are a small number of contributing diagrams at the 2→2 level we can

generalize the contribution of a particular type of process based on the spin of the

particles involved (scalar, fermion, or vector) and get the specific result by specifying

the individual particle properties. These diagrams are simple tree diagrams with a

propagator in the s, t, or u-channel whose spin types are restricted by the initial and

final particle spins. A general prescription is provided requiring that the properties

of the initial and final particles, and the number and type of allowed propagators are

specified along with the appropriate couplings.

The cross section integral is performed over the standard relativistically invariant

n-body phase space∫dΠn = (

n∏f=1

∫d3pf(2π)3

1

2Ef)(2π)4δ(4)(P −

∑pf ), (3.3)

with pf and Ef being the n final particle momenta and energies and P being the

total initial momentum. For the case of 2 or 3 particles that we generally deal with,

this expression simplifies considerably. For two final state particles, the phase space

requires a simple integral over angles, θ and φ, of the final state momentum vectors,

which are back to back in the CM frame. All of the 2 → 2 particle interactions are

also symmetric about the beam axis, leaving just the θ integral. For a 2→3 process

we must specify three momentum fractions, xi, and three Euler angles specifying the

plane containing the final state vectors. We will use this to express our differential

cross sections with respect to cos θ for 2-body final states and with respect to the

xi and the Euler angles for 3-body states. Assuming that all of the final particles

for this simple process are stable, we have specified the basic physics necessary for

cross-section calculation and event generation. For example the full cross section for

e−e+ → µ+µ− is simply:

σ =

∫d cos θ

dσ

d cos θ=

∫d cos θ

(1

32πs

∑λ3,λ4

∣∣M(e−λ1+ e+λ2

→ µ−λ3+ µ+

λ4)∣∣2) (3.4)


3.2 Individual decays

This simple case of only two or three final particles applies only to a very limited

subset of interesting particle physics models. It is very common, in particular for

most BSM physics models, for some of the final daughters from this initial hard

process to be unstable, requiring a correct physics treatment of the decays of these

unstable products.

First we should consider how to appropriately calculate a single resonance produc-

tion diagram. In the full diagram of the event, each internal leg represents a massive

unstable particle, that is created and then very quickly decays. Each of these massive

unstable particles should be treated as an internal propagator from the previous ver-

tex (either from the process or a previous decay) to the next decay vertex resulting in

its daughter particles. In this case we must include an appropriate propagator term

into the calculation. For simplicity consider the case of a scalar particle. The exact

propagator will have the form

i

p2 −m20 −M2(p2)

(3.5)

where −iM2(p2) is the sum of all one-particle-irreducible insertions, as shown in

Figure 3.3. These one-particle-insertions are just the one particle self-energies with a

renormalization factor based on the LSZ formula

M(p→ p) = −ZM2(p2) = −M2(p2) +O(α)M2(p2), (3.6)

from which we drop the higher order terms. The particle mass m is the solution of

m2 −m20 − ReM2(m2) = 0 (3.7)

In the vicinity of the pole, if this propagator were in the s-channel of a diagram the

cross section will have the form

σ ∝∣∣∣∣ 1

s−m2 − iIm M2(s)

∣∣∣∣2 (3.8)


�1PI =�+� ++ · · ·

(a) =� +�1PI + 1PI1PI + · · ·

(b)

Figure 3.3: (a) The expression for the set of all one-particle-irreducible (1PI) inser-tions. (p) The exact propagator which is the geometric series of all 1PI insertions.

This is extremely similar to the standard cross section for a Breit-Wigner resonance

σ ∝∣∣∣∣ 1

p2 −m2 − imΓ

∣∣∣∣2 (3.9)

If the width Γ is narrow, we find a large contribution when the mass of the particle

is nearly on shell, reinforcing the choice of resonance diagrams as the dominant dia-

grams. In order to express the propagator as a resonance we need to define a width

Γ for the unstable particle. Assuming that the resonance is narrow, specifically that

ImM2(m2) ≈ ImM2(s) over the resonance, we can define

Γ = −Zm

Im M2(m2) (3.10)

To specifically calculate Im M2(m2) we can apply the optical theorem to the one

particle scattering to get

ZIm M2(p2) = −Im M(p→ p) = −1

2

∑f

∫dΠf |M(p→ f)|2 (3.11)

where f is the set of all possible final states of the diagram, or all possible decays

from the unstable particle. This gives us a formula for the Breit-Wigner width Γ in


terms of the decay amplitudes of the unstable particle

Γ =1

2m

∑f

∫dΠf |M(p→ f)|2 (3.12)

For a result exact to all orders, we would need to include all final decay chains as well

as a variety of of loop diagrams, but to first order we can calculate the amplitudes to

the direct 1 → 2 decay channels (possibly including further unstable particles) as the

dominant contribution to this width. In cases where there are no open 1 → 2 decay

channels or where they are highly suppressed, 1 → 3 decay channels may be needed

as well.

Thus for each internal leg, representing a decaying particle, we have an approxima-

tion of the particle propagator as a Breit-Wigner resonance with a width calculable

from possible decay channels. This calculation stands up as long as the width in

question is narrow, which will hold for most BSM unstable particles. However, even

for particles of very small width there is a problem to be resolved. The actual mass,

m, of each particle in a decay chain will vary from its nominal mass, m0 given by the

resonance pole position. This effect is especially pronounced near a threshold, where

the sum of the masses of the daughter particles is nearly equal to the mass of the

unstable particle. The contribution from a particular decay channel may vary greatly

depending on the particular value of the actual mass of the decaying particle. This

variation can invalidate our naive width calculation. We will discuss a solution to

this difficulty in Section 3.5.

From this discussion of the intermediate particle propagators, we see that the

dominant contribution to a particular decay diagram will come when the energy of the

intermediate particle is near the resonance. This allows us to treat the propagator as

a real particle of a particular mass, chosen according to the Breit-Wigner distribution


leading to a contribution to the integral of the form

∑λin,λfi

∣∣∣∣∣ ∑λintern

M(p1λ1p2λ2 → X1λX1X2λX2

) ×

1

m2X1−m2

X10 − imX10ΓM(X1λX1

→ Y1λY1Y2λY2

) · · ·∣∣∣∣2 (3.13)

Thus for each point in phase space an unstable particle in the final state of the initial

process will have a specific mass. Here λin and λfi are the initial and final particle

helicities, and λintern are the helicities of the internal decaying particles, for example

λX1 . In order to correctly treat any spin interference we must sum over the internal

helicities before squaring. The initial and final helicities define distinguishable helicity

amplitudes, so they are treated as separate contributions to the cross section and

summed after squaring. The details of correctly treating the helicity amplitudes are

discussed in Section 3.3.

The final state phase space for a particular two or three-body decay for a particle

of fixed mass is the same as for the respective process when evaluated in the rest frame

of the unstable particle. The masses of our decaying particles are not fixed though,

so we must integrate over that mass to set the scale of the final state momentum.

Thus we can build up our full event phase space, dΠfull, as the product of the known

smaller phase spaces, each taken in the center of mass frame, times the integral over

the masses of the unstable particles. Using this we can write out the contribution for

a cross section for a single diagram. As an example consider the case of the interaction

e−e+ → W+W− → e+νee−νe. This has a cross section of the form

σ =1

2s

∫dΠfull

∣∣∣∣∣∑allλ

M(e+λ1e−λ2

→ W+λ3W−λ4

)×

1

m2W+ −m2

W0 − imW0ΓM(W+

λ3→ e+1λ5

νeλ6)×

1

m2W− −m2

W0 − imW0ΓM(W−

λ4→ e−1λ7

νeλ8)

∣∣∣∣2 (3.14)


�W−

W+

e−

e+

νe

e−

e+

νe

(a)

�W−

W+

e−

e+

νe

e−

e+

νe

(b)

�Z, γ

Z

e−

e+

e+

e−

νe

νe

(c)

�Z, γ W

e−

e+

e−

e+

νe

νe

(d)

�Z

Z

e−

e+

e−

νe

νe

e+

(e)

Figure 3.4: Some of the diagrams for e−e+ → e−e+νeνe (there are 49 more).

While this is correct for this diagram, we have a new problem to consider. If we try

to calculate the full cross section from initial partons to the single final state e−e+νeνe,

there are 54 diagrams to consider, Figure 3.4. While a program like MadGraph or

CalcHEP will calculate and include all of these diagrams, we have chosen to focus

on the most important resonant diagrams. Even if we focus only on the 2 → 2 and

2 → 3 resonance diagrams we would still also have to include the diagrams involving

an initial process of e−e+ → ZZ, Figure 3.4c and several 2 → 3 diagrams, Figure

3.4d. For any chosen final state of SM partons and stable particles many different

initial process and a variety of decay structures will be involved. This would make


cataloging all contributing diagrams increasingly difficult as more final state particles

are added. A more intuitive way of grouping diagrams, and the convention used in

pandora, is by the initial 2 → 2 or 2 → 3 hard process involved. By treating each

initial process separately, we lose the interference terms between them, in addition

to the non-resonant diagrams we ignore. Still, the most important contributions to

the cross section are included. In this case we will consider the e−e+ → W+W− and

e−e+ → ZZ reactions as separate processes, to be added incoherently. On the other

hand, all spin interference effects within each process are included.

For each initial process we find all possible decays of the resonantly produced

intermediate particles. Each diagram will contribute a product of the initial process

cross section and the widths of the decaying particles from every possible decay chain.

Simply adding these contributions will not result in a physically meaningful result.

The most appropriate physical cross section to calculate is simply the cross section

of the initial process. While this cross section could be calculated by simply inte-

grating over the initial process separately, and dealing with the decays outside of the

integration process, this would lose the spin correlations we are trying to calculate.

Before we discuss how to combine multiple decay channels into a single integral we

will discuss why it is important to include all those channels in the integral in the

first place, if the final result will simply be the cross section of the initial process.

3.3 Helicity Amplitudes

We are constructing an integral and a phase space for an initial 2 → 2 or 2 → 3

process, along with any subsequent decays, that will result in a numerical result for

the cross section of just the initial process. It might seem sufficient to simply integrate

the initial process separately, and then figure out the contributions of the individual


decays afterward. In essence, this would break our integral into∫dΠ∑allλ

∣∣M(p1λ1p2λ1 → X1λX1X2λX2

)∣∣2×

∫dΠ∑allλ

∣∣∣∣ 1

m2X1−m2

X10 − imX10ΓM(X1λX1

→ Y1λY1Y2λY2

)

∣∣∣∣2 × · · · (3.15)

This is undoubtedly a more efficient way to get the numerical value of the cross

section for the initial process. Nevertheless our goal is not simply to calculate a cross

section but to use the cross section integral and the corresponding phase space to

build an event generator. Any particle information lost in the process of constructing

the integral will not be accessible to the event generator later on.

We have emphasized that the amplitudes, M, of the initial process and the decays

are helicity amplitudes that are calculated separately for each helicity state. To

accurately describe the decay of a particle, its spin in the decay amplitude must agree

with its spin in the amplitude that produced it (either the initial process or a higher

decay). In computing the full integral we define the internal helicity of a decaying

particle as the spin along the axis corresponding to its direction of motion in the rest

frame of its parent process or decay. We must then sum over all possible internal

helicities of the internal lines. If we decide to apply the above simplification, and

separately integrate the process and each decay, we will be producing spin averaged

results at each step, and any interference between separate spin states will be lost.

As an example we consider the case of a daughter particle X from the initial

process whose decay plane is tilted at an azimuthal angle, φ, from the event plane.

When an unstable particle is produced the φ dependence of its decay amplitude is

simply expressed as

Mprod(λX)eiλXφMdec(λX) (3.16)

The total contribution of all helicity states to the cross section is∣∣∣∣∣∑λX

Mprod(λX)eiλXφMdec(λX)

∣∣∣∣∣2

(3.17)


In general this will produce a non-trivial φ dependence for particles with non-zero

spin. If we apply the simplifying convention discussed above, this is reduced to

∑λX

|Mprod(λX)|2∑λX

∣∣eiλXφMdec(λX)∣∣2 (3.18)

This completely removes the φ dependence, effectively averaging over the azimuthal

angle for all decays. Then any azimuthal correlations are lost.

The most efficient way to calculate the simple initial process cross section, which

is the numerical result of the pandora integral, would be to separately integrate just

that process. However, in order to create an integral and a phase space that correctly

models the full spin correlations of all decays we must include the correct helicity

amplitudes for all decays, connected to the initial process based on the helicity states.

This still leaves the problem that simply including these amplitudes would destroy

the desired 2 → 2 or 2 → 3 process cross section value. To overcome this, we will try

to normalize each decay, so that the correct cross section is evaluated.

3.4 Color Structures

The treatment of color poses some problems for Monte Carlo event generators. All

of the Monte Carlo hadronization programs, such as PYTHIA and HERWIG, rely on

assigning initial and final particles specific color labels. Quarks and antiquarks are

given a single label each, with the quark color labels distinguished from the antiquark

anticolor labels. Gluons are given two labels, one representing color and the other

anticolor. This representation is correct only to the leading order in 1/NC , where

NC is the number of colors. In pandora we attempt to both provide definite color

labels for each final state particle and provide 2 → 2 and 2 → 3 cross sections that

are correct for NC = 3. Each Feynman diagram can be assigned a color structure

diagram. When only one diagram is involved in a particular helicity amplitude it

is straightforward to calculate the correct cross section and simply assign the event

that color structure. Reconciling the two tasks can be difficult when multiple color

structures are involved in a single helicity amplitude, since the exact cross section


�u

g

u

γ

(a) ug → uγ

�u

g

u

γ

(b) Color Structure

Figure 3.5: A basic color structure diagram

requires interference between various color structures, while the representation of the

final state requires that we treat these structures as distinct.

To define a color structure, we assign each quark-like fundamental 3 representation

of SU(3) a color line, each antiquark-like antifundamental 3 an anticolor line, and each

gluon-like adjoint 8 representation both a color and an anticolor line. In general the

color structure should connect these lines such that a line between two initial particles

or two final particles should connect color to anticolor, while a line between an initial

and final state particle should connect color to color or anticolor to anticolor. These

connections are analogous to the product of 3 and a 3 which is the basic SU(3) or

SU(N) invariant. Using these connections we should be able to define a color structure

for every event that is made up of color lines that only begin or end at initial or final

state particles such as Figure 3.5. This color line representation breaks down if baryon

number violating interactions are allowed which involve the antisymmetric SU(3)

products combining three 3 representations or three 3 representations. The accepted

convention for dealing with these cases, based on the Les Houches Accord [11], is to

leave all three lines unconnected. We define a color structure for every process and

every decay and implement a mechanism to connect the lines from the process down

through the decays to form an event color structure.

For 1 → 2 decays the color structures are very straightforward. For most possible

color conserving interactions using particles in the 1, 3, 3, and 8 representations there

is only one color structure. Only the three octet interaction (8 → 88) has multiple

color structures, with the decaying octet able to connecting its color line with the


�01

2

(a) Cfinal=1

�01

2

(b) Cfinal=2

Figure 3.6: Color structure for an color octet decaying to two octets

�(a)�

(b)�

(c)�

(d)

Figure 3.7: There are three possible color structure diagrams for 88 → 33, diagrams(b), (c), and (d). However, only (b) appears in the gg → qq diagram (a).

color of either final octet, and its anti-color line with the third octet, as shown in

Figure 3.6. The color structures for 2 → 2 process and 1 → 3 decays are more

complicated but are finite and enumerable. These diagrams and the pandora naming

convention for them are described in the corresponding header files. While this is a

listing of the possible color structures for a given set of initial and final particle colors,

not all of the diagrams will necessarily be used. The color structure of a given helicity

amplitude must correspond to the Feynman diagram for the process with the included

propagators transmitting the appropriate color lines. Thus an octet propagator must

carry a color and anticolor line, while a triplet 3 or 3 particle must carry only one

color or anticolor line. Consider, for example, the process in Figure 3.7 which can

only carry one of the three possible color structures for the color state.

If there is only one color structure for a given helicity state, the standard procedure

gives the correct result. When multiple color structures are involved in a given helicity

state, we have to carefully treat any possible interference terms. We want pandora to

treat each color structure of an amplitude as a distinguishable object, so that we can


construct a definite color structure for each generated event. But simply treating each

color structure separately will result in no interference terms and will not correctly

account for the internal color interactions of the process. One of the more common

interference contributions comes from two diagrams related by a crossing symmetry,

such as interference between t-channel and u-channel color structures. Consider a

specific helicity amplitude with two distinct color structures that a t-channel and a

u-channel diagram. If we build up the full amplitude we will have

iM = iMt ∗ Tt + iMu ∗ Tu, (3.19)

where Mi are the, color independent, amplitudes of the two distinct diagrams and Ti

are the specific color factors for the two diagrams. These color factors will be some

product of color matrices. For diagrams related by crossing symmetries they will be

the same matrices with two of the color indices switched. The result we want is this

amplitude squared, summed over final colors and averaged over initial colors

1

nc

∑colors

|M|2 =1

nc

(tr[T †t Tt]|Mt|2 + tr[T †uTu]|Mu|2

+tr[T †t Tu]∗M∗

tMu + tr[T †uTt]M∗uMt

), (3.20)

with nc the number of initial color states, e.g. 64 for a two gluon initial state. By

summing over color indices the color matrix terms become traces and result in real

numbers.

We want our squared amplitude to equal this expression, but we want to divide it

into two separable parts, but to maintain the important M∗tMu and M∗

uMt interfer-

ence terms in the calculation. To do this we will need to explicitly put the interference

terms into our individual amplitudes. Let us define

tr[T †t Tt] = c1 tr[T †uTu] = c2, and tr[T †t Tu] = tr[T †uTt] = c3. (3.21)


Our proposed solution is to posit two amplitudes of the form

(aMt −√c2c1bMu) and (

√c2c1aMu − bMt) (3.22)

for the two color structures. Squaring each and adding the results, and pulling out a

factor of c1 gives

1

nc

∑colors

|M|2 = c1

(|aMt −

√c2c1bMu|2 + |

√c2c1aMu − bMt|2

). (3.23)

This should be equal to (3.20) which, when we use the definition of c1, c2, and c3,

becomes

1

nc

∑colors

|M|2 = c1|Mt|2 + c2|Mu|2 + c3(M∗tMu +M∗

uMt) (3.24)

This becomes an algebraic exercise of solving the system of equations

(a2 + b2) = 1, −2ab

√c2c1

=c3c1, (3.25)

which leads to

a =1

2

(√1 +

c3√c1c2

+

√1− c3√

c1c2

), and

b =− 1

2

(√1 +

c3√c1c2

−√

1− c3√c1c2

).

(3.26)

Thus we should construct pandora such that the t-channel color structure is given

the amplitude in the first part of (3.22) and the u-channel is given the second part,

with a and b according to the solution above. Thus when each is squared and added

together, the overall amplitude has the correct interference leading to the correct

tree-level cross section, and each event is given a reasonable color structure.

This is just one example of possible interference patterns among color structures

but it is a common one. The procedure of solving an algebraic equation to determine a


separable set of helicity amplitudes that includes the appropriate interference term is

generalizable. It is a reasonable approximation that solves the most pressing problems

of including the proper color interference and assigning reasonable color structures

for every event. Because these requirements are ontradicting there is no perfect

solution. Other Monte Carlo generators use other methods. For example, HERWIG

and MadGraph use the Odagiri method [12] in which the full amplitude is multiplied

by a factor of fi for each color structure such that∑

i fi = 1. The method given here

is a natural one that fits well into the pandora scheme of calculations.

3.5 Multiple decay channels

In order to properly include all spin information for the event generator, our cross

section integral must include all contributions of all decay channels. However, we want

it to numerically evaluate the cross section of the initial process alone. Ideally we

will include the phase space contributions of each decay channel, but in a normalized

form that does not contribute numerically to the total cross section integral. The

way to do this can be found from our analysis of the resonance nature of the unstable

propagators above, and the subsequent definition of the decay width. From (3.12) we

find, in the narrow width approximation,

1 =

∑f

∫dΠf |M(p→ f)|2

2mΓ, (3.27)

where the first order calculation restricts f to the set of all 2-body final states. Us-

ing this we can replace the original contribution for each step of the decay with a

normalized version

1

s−m2X1− imX1ΓX1

M(X1 → Y1Y2) →√

2mX1ΓX1

s−m2X1− imX1ΓX1

M(X1 → Y1Y2)√2mX1ΓX1

.

(3.28)

For an individual diagram with a particular set of decays, this will result in the

original amplitude times a constant. This will preserve the internal structure of the


diagram, including the spin correlations. Once we sum over all possible decay chan-

nels, the contributions from the widths of the unstable particles will be normalized to

1. This leaves only the cross section of the initial process, with the internal structure

of all of the decays intact. This of course depends on the nominally calculated width

being the correct normalization factor. As mentioned above, there are certain cases

where this naive assumption fails. This issue can be addressed by calculating the

physically accurate widths for all decays by using exactly the same sampling as the

full integral.

The simplest approximation to the width is a simple on-shell analytic calculation,

but often this will not be very accurate. The value of the width integral depends

on the exact kinematics of the decay. As masses are varied with the Breit-Wigner

resonance, these values can change, sometimes significantly. We will now discuss this

point more explicitly.

The sum over all physical decay diagrams will include the Breit-Wigner resonance

to account for the variable mass of the unstable particle. So a more accurate ap-

proximation of the width would be a one dimensional integral over this Breit-Wigner

distribution times the nominal width integrand.

Γ =1

2m0

∑Y1,Y2

∫dm2 dΠ2

∣∣∣∣ 1

m20 −m2 − imΓ

M(X → Y1, Y2)

∣∣∣∣2 (3.29)

where m0 is the nominal mass of X and m is the varying physical mass. There are

several issues with this treatment, first of which is that Γ is on both sides of the

equation. Also, while more accurate, this will also be computationally expensive,

requiring a separate integral for every step of every decay chain. Additionally this

treatment will break down when kinematic constraints from the parent decay or

process cut off some of the possible masses of the unstable particle, as described in

Figure 3.8. This effect will vary depending on the particular point in phase space

being sampled, and the masses of the parent particles to the unstable particle in

question.

This leads to huge errors from the simple attempts to calculate the decay widths

discussed near thresholds. Even away from thresholds when the decay is kinematically


m1m2

240 245 250 255 260m

Figure 3.8: Two overlapping Breit-Wigner resonances. If there is a kinematic con-straint m2 < m1 then a large piece of the m2 resonance may be kinematically inac-cessible at certain points in phase space, strongly affecting the width integral

open, there is often a noticeable shift from the naive mass value to a fluctuated value

that increases the available phase space. The nuances of these shifts from the nominal

decay width are only properly treated when the decay is considered in relation to the

full phase space of the decays surrounding it.

Ideally for any particular decay we want to have a width

Γ =1

2m0

∑Y1,Y2

∫dΠfull

∣∣∣∣ 1

m20 −m2 − imΓ

M(X → Y1, Y2)

∣∣∣∣2 (3.30)

where dΠfull is the full phase space of the event, specifically including the kinematic

constraints that affect the mass selection for the decay in question. At first look

this would still seem to require a separate integral for each step of the decay, only

now a much more complicated integral. While the integral is more complicated we

have found a way to efficiently calculate it for each step of the decay chain, without

additional computation. The method to efficiently calculate these integrals will be

discussed in 4.3.


�X1

X2

X11

X12

X22

X21

Figure 3.9: A general process

Combining the expressions for the process cross section and the decay contribu-

tions we have an expression

∫dΠ∑λ,c

∑all X

∣∣∣∣∣M(p1p2 → X1X2)∏i=1,2

√2mΓXi

s−m2Xi− imXi

ΓXi

M(Xi → Xi1Xi2)√2mΓXi

×

∏j=1,2

√2mΓXi

s−m2Xij− imXij

ΓXij

M(Xij → Xij1Xij2)√2mΓXij

· · ·

∣∣∣∣∣2

(3.31)

for the integral of the general process in Figure 3.9, with the ΓX terms evaluated

by (3.30). We have suppressed the color and helicity indices in this expression, and

the following, but as above all instances of a particle Xf in various amplitudes agree

in helicity λXf. This is a valid expression for the cross-section assuming the initial

beams were single parton beams of fixed momentum. The next step towards a full

physics description is to consider the contribution of reasonably physical beams with

multiple possible partons and varied initial momenta.

3.6 Beam Physics

A variety of beam types have been included in pandora to try to address most current

and proposed collider designs. For each beam type there are a variety of possible

parton types that could participate in the hard process and those partons will have

only a fraction of the beam energy. To correctly calculate the cross section of an

event for a particular beam type we must include the selection of the initial parton

and energy into the larger phase space calculation. For uniformity, the physics effects

of different types of beams will be expressed as parton distribution function fp(x)


Source Implemented PDFsMRST collaboration MRST2002LO [13]

MRST2004NLO [14]MRST2004NNLO [14]

Table 3.1: PDFs included in pandora

where x is the fraction pf the full beam energy carries by the parton p. This leads to

a full pandora integral∫dx1dx2 dΠ

∑p

∑λ,c

∑X

fp1(x1)fp2(x2)∣∣∣∣∣M(p1p2 → X1X2)∏i=1,2

√2mXi

ΓXi

s−m2Xi− imXi

ΓXi

M(Xi → Xi1Xi2)√2mXi

ΓXi

×

∏j=1,2

√2mXij

ΓXij

s−m2Xij− imXij

ΓXij

M(Xij → Xij1Xij2)√2mXij

ΓXij

· · ·

∣∣∣∣∣2

(3.32)

Despite the similarity of form, the individual beams have very different physics effects

contributing to the particular choice of parton and energy.

Protons are composite particles of quarks and gluons, and in a collision the packets

of fundamental particles collide initiating a variety of interactions. Ideally in a given

collision, only one quark or gluon from each beam will participate in the type of

hard process we are interested. This means the hard process will have only a small

fraction of the beam energy. The energy fraction of a particular quark or gluon from

the proton at a particular energy is governed by the parton distribution functions

of the proton. These pdfs have been determined based on observed data. A variety

of fits exist, using various available data sets and models. Several of these sets have

been implemented into pandora, listed in Table 3.1.

In practice there are a variety of additional proton beam effects that are not

handled by pandora. While we are interested in the hard interaction of individual

partons, these hard partons come from a composite hadron made of many other

partons, referred to as the beam remnant. Since the beam remnant is colored its

color connection to the rest of the event must be treated correctly. Additionally, it


is possible for other pairs of partons from the beam remnants to interact as well.

In general these interactions will be soft, but some portion of them may be hard

enough to have concrete effects, producing an underlying event that must be handled

separately. In an actual collider, the beam is made up of discrete bunches of particles,

so there is a chance of multiple beam particle collisions in a single crossing, leading

to pile-up. All of these external beam effects, along with the hadronization and

showering of the final particles, can be handled by external programs such as PYTHIA

and HERWIG. The pandora output can be formatted according to the Les Houches

Accord format [15] which can be directly input into these programs to have these

additional beam effects incorporated into the generated events.

The electron and positron beams are not composite particles and so there is no

need to use a data driven pdf as for the proton beams. While ideally the electron

will maintain almost all of the beam energy, several factors can reduce the actual

energy or cause a radiated photon to interact instead. First there is a spread of

beam energies coming from the accelerator. There is the possibility of initial state

radiation radiating some of the beam energy from the colliding particle. There is

even a chance that a radiated photon will be the primary parton in the hard collision.

Finally in colliders with very small beam sizes, such as the ILC, there is an interaction

between the two beams moving in opposite directions know as beamstrahlung, which

is dependent upon the specific design of the collider [16]. The specific spectrum due

to beamstrahlung can be approximated as discussed in [17]. This prescription is

implemented in pandora for a variety of electron-positron collider design proposals.

We also implement electron-electron beams for those same collider designs [18].

The final beam type included in pandora is a photon beam which, like the electron

beam, does not have a data driven pdf but will have a variable initial parton and

momentum due to its method of production. The most common proposal for a

photon collider involves the creation of photons by Compton backscattering from a

high energy electron beam. The initial electron beam would be similar to that for an

electron-positron collider. At a short distance, a few mm, from the final interaction

point the electrons would interact with a focused laser beam. The photons from the

laser would scatter off the beam electrons and travel toward the interaction point


with similar energy to the initial electrons and only a slight angular spread. We

have included a basic method for calculating this Compton backscattering process

with the option for polarized electron and initial laser beams, which can produce

high energy polarized photons. This treatment includes the addition of ISR for the

electron beams; beamstrahlung is not relevant in this case. In studies for photon

colliders, pandora has been used with the luminosity function taken from detailed

collider simulations [19].

3.7 Calculation Conventions

The above review discusses the physics fundamental to the process of calculating

cross-sections and building a collider event generator used in pandora. Still, there are

some additional physics conventions that are not fundamental to the core of pandora

but that are used frequently in the calculation of processes and decays. Some are basic

convention choices, which must be adhered to in order to achieve consistent results.

Other are tools used to simplify and automate some portions of the calculation,

making the implementation of processes and decays simpler.

3.7.1 Angular Conventions

In pandora the primary particles in a 2 → 2 process are numbered as 1 through 4.

Specifically, 1 and 2 referring to the colliding partons from beams 1 and 2, respectively,

while 3 and 4 refer to the final state particles. For a 2 → 3 process the particles are

numbered 1 through 5, with 1 and 2 the colliding partons, and 3 through 5 the final

state particles. For decays, the decaying particle is numbered 0, and the final state

particles are 1 and 2, for a 1 → 2 decay, or 1, 2 and 3, for a 1 → 3 decay. This

numbering system is used to label masses, colors, helicities and particle IDs in the

various pandora classes.

All amplitude calculations are done in the center of mass frame of the particular

interaction being considered. Any 2 → 2 process will be symmetric around the beam

axis and we can restrict the event plane to the 3 − 1 plane for the cross-section


p1 =ECM

2, 0, 0,

ECM

2Θ

p3 = HE3, k3 sinΘ, 0, k3 cosΘL

p4 = HE3, -k3 sinΘ, 0, - k3 cosΘL

p2 =ECM

2, 0, 0, -

ECM

2

Figure 3.10: The 2 → 2 event plane (needs work)

calculation. For the generation of events, the event plane will be rotated with a

uniform distribution azimuthal to the beam axis. We assume the beam axis is along

the 3 axis, with beam 1 moving in the +3 direction and beam 2 moving in the

−3 direction. The first final state particle (particle 3 in our convention) will travel

outward from the origin at an angle θ from the +3 axis, and thus from beam 1,

measured with a right-hand rotation about 2 being positive. The second final state

particle (particle 4) travels in the −θ direction by momentum conservation. This

2 → 2 event plane is shown in Figure 3.10.

For a 2 → 3 process, the momenta of the three final particles define an event plane.

If we define this plane as being the 3′− 1′ plane by placing the momentum of particle

3 on the +3′ axis, we can label the particle moving in the upper half plane particle 4

and the one in the lower half plane particle 5. We then label their momentum angles

θ34 and θ35 from particle 3, measured counter-clockwise and clockwise, respectively.

Having specified the event plane, we must specify the orientation of the plane with

respect to the beam axis, again the fixed 3 axis. This is done by specifying the three

Euler rotation angles ψ, θ, and φ using the z-y-z convention. Thus particle 3 travels

in at an angle θ from the beam 1, and particles 4 and 5 travel at angles θ34 and θ35

from particle 3. The angle between particles 4 and 5 and the beam axis must be

derived from the other rotation angles. This 2 → 3 kinematic structure is shown in

Figure 3.11. In general this system is sufficient, although there are situations where

this convention could be problematic. The particles in pandora are usually listed with


Θ34

Θ35

p3

p4

p5

x '

z '

x

z '

z

Θ

x '

y

Ψy '

Φ

Figure 3.11: Kinematics for a 2→3 event. The three final particles fall in the 3′ − 1′

plane, and the orientation of that plane with respect to the beam axis are defined bythree Euler rotation angles φ, θ, and ψ.

the massive particles first and the massless particles last. Thus if there are massless

particles involved, particle 5 will massless. If the angle between the beam axis and a

massless particle 5 contributes to a singularity it may be necessary to change variables

so that this angle is directly integrated over, rather than derived from other variables.

For decays, we work in the rest frame of the decaying particle (particle 0) . For

helicity calculations we assume right and left handed spin of the decaying particle with

respect to the +3 direction. For helicity amplitudes of decays, we take advantage

of the Wigner D-matrices [21] to simplify our calculations. We can calculate the

helicity amplitude assuming a fixed final state event plane and rotate the helicity

amplitude to any other event plane using these rotation matrices. The easiest event

plane to deal with is the one where the first decay product (particle 1) travels along

the +3 direction. For a two-body decay this means that the other decay product

(particle 2) travels in the −3 direction, removing all angular dependence from our

initial amplitude calculation. The angular dependence is restored in a well defined

way by the rotations. For a three-body decay, if particle 1 is traveling along +3, the

other final products (particles 2 and 3) travel in the event plane at angles θ12 and

θ13 from the first (measured counter-clockwise and clockwise, respectively). Only this

relative angular dependence enters the initial amplitude calculation. In either case,

any angular contribution due to the angular relation of the direction of helicity of the


initial particle and the event plane can be determined by applying the correct Wigner

rotation matrix to the initial helicity calculation. The explicit Wigner matrices used

are

D00,0(ψ, θ, φ) = 1 (scalar)

D1/2m′,m(ψ, θ, φ) =

(cos θ

2e−

i2(ψ+φ) sin θ

2e−

i2(ψ−φ)

sin θ2e

i2(ψ−φ) cos θ

2e

i2(ψ+φ)

)(fermion)

D1m′,m(ψ, θ, φ) =

1+cos θ

2e−i(ψ+φ) − sin θ√

2e−iψ cos θ−1

2e−i(ψ−φ)

sin θ√2e−iφ cos θ sin θ√

2eiφ

cos θ−12

ei(ψ−φ) − sin θ√2eiψ 1+cos θ

2ei(ψ+φ)

(vector)

(3.33)

where ψ, θ and φ are the Euler rotation angles using the z-y-z convention, and m

and m′ are the helicity states of the decaying particle before and after the rotation,

respectively. These rotations are built into the pandora cross-section calculations, so it

is assumed that the user will input the decay amplitudes according to the conventions

described.

3.7.2 Polarization Conventions

In pandora, each helicity amplitude used to build up the cross-section integral each

has an explicit spin structure. In order to correctly connect the helicity amplitudes of

processes and decays, it is necessary to to use consistent conventions in the two pieces

of the calculation. This applies also to multiple-step decay processes where unstable

particles are created and then destroyed. As always, helicity is the projection of the

spin angular momentum onto the direction of momentum, in the rest frame of the

particular process or decay being calculated, with positive helicity being right-handed

and negative helicity being left-handed. While any consistent approach to calculating

helicity amplitudes and keeping track of the helicity states can be used for pandora,

there are a variety of tools that have been included to facilitate these calculations

that assume specific helicity conventions.


When considering Feynman diagrams with external vector boson we will have

explicit polarization vectors for each external leg, εµ for incoming legs and ε∗µ for

outgoing. To keep full spin effects in the final state, we cannot use any polarization

sum identities. Rather we must explicitly define each polarization vector and use them

in the calculation of the helicity amplitudes. As described above, all calculations can

be done in the 3− 1 plane. For a given vector boson with momentum

kµ = (E, k sin θ, 0, k cos θ)µ (3.34)

the polarization vectors are

ε−(k) =1√2(0, cos θ,−i,− sin θ)

ε0(k) = (k

m,E

msin θ, 0,

E

mcos θ)

ε+(k) =1√2(0, cos θ, i,− sin θ) (3.35)

for left-handed, longitudinal, and right-handed polarization respective, with m2 =

E2 − k2. For massless vector bosons, the longitudinal helicity state is absent. This

definition is for the incoming vector particle εµi (k) and the complex conjugate ε∗µi (k)

should be used for outgoing vector particles.

To treat the spin of fermions we decided to use two-component Weyl spinor no-

tation, since this will facilitate calculations in the MSSM and other theories with

Majorana fermions. In this notation all fermions will be two-component left-haded

spinors, with their right handed conjugates antifermions. The standard Dirac fermion

is then treated as two separate Weyl fermions, and the change of naming convention

can be confusing. For consistency we will use the notation of Martin’s Supersymme-

try Primer [20], and express the two left handed pieces of the Dirac fermion ψDirac as

ψ and ψ. The bar does not denote conjugation but rather is the name of the (left-

handed) conjugate of the right handed part of the Dirac fermion. Thus the Dirac


fermion is equivalent to

ψDirac =

(ψL

ψR

)≡

(ψ

ψ†

). (3.36)

If advantageous we may revert to the ψL, ψR convention, keeping in mind that they

are different particles. Note that pandora treats the top quark as two Weyl fermions

t and t. This is slightly unconventional, but the convention makes it easier to treat

extra-dimensional and other new physics models.

In this formalism, every Dirac fermion is part particle and part anti-particle.

For instance, the electron is composed of two left-handed fields in two-component

notation. One field, e, has charge −e and annihilates the left handed electron and

the other, e, has charge +e and annihilates the left handed positron. Similarly we

can translate the Dirac spinor form of the QED Lagrangian

L = ψDirac(i 6D −m)ψDirac (3.37)

(here the bar is the standard Dirac conjugate times γ0) into the Weyl spinor formalism

as

L = ψ†iσ ·Dψ + ψ†iσ ·Dψ − (mψT cψ −m∗ψ†cψ

∗) (3.38)

where

σµ = (1, ~σ), σµ = (1,−~σ), and c =

(0 −1

1 0

). (3.39)

From the Weyl form of the Lagrangian, we see that by treating fermions as two distinct

two-component fermions the portions of the propagator proportional to momentum

and mass separate. We end up with three distinct propagators, specifically

⟨ψ(p)ψ†(−p)

⟩=⟨ψ(p)ψ

†(−p)

⟩=

iσ · pp2 − |m|2⟨

ψ(p)ψT(−p)

⟩=⟨ψ(p)ψT (−p)

⟩=

−im∗c

p2 − |m|2⟨ψ∗(p)ψ

†(−p)

⟩=⟨ψ∗(p)ψ†(−p)

⟩=

imc

p2 − |m|2. (3.40)

CHAPTER 3. PHYSICS REVIEW 39�p→ u(p)(a) Incoming

fermion

�p→ v∗(p)(b) Incoming

antifermion

�p→ u∗(p)(c) Outgoing

fermion

�p→ v(p)(d) Outgoing

antifermion

Figure 3.12: Weyl spinor Feynman rules

To define the helicity states of fermions we must specify the spinors u(p) and v(p)

for each particle. These are the spinors associated with the particle and anti-particle

portions of a Dirac fermion, respectively. Thus an incoming fermion, represented as

(3.36), is annihilated by the field ψ with a factor u(p) and by ψ†

with a factor v†(p).

Similarly, an outgoing version of the same particle is annihilated by ψ† with a factor

u†(p) and by ψ with a factor v(p). The antiparticle of this same fermion would be

treated the same with the roles of ψ and ψ switched. This can be summarized by the

standard Feynman rules in Figure 3.12 being sure to include all allowable directions

for fermion lines.

Assuming a real, positive mass, we can define explicit forms of these spinors for a

fermion with momentum

pµ = (E, p sin θ, 0, p cos θ)µ, (3.41)

where p > 0 and θ is measured from the +3 direction, as

u−(p) =√E + p

(− sin θ

2

cos θ2

), v−(p) =

√E − p

(− cos θ

2

− sin θ2

),

u+(p) =√E − p

(cos θ

2

sin θ2

), v+(p) =

√E + p

(− sin θ

2

cos θ2

). (3.42)

While this formula is universal if applied with the stated convention it is useful to

write out the spinors for the opposite momentum

pµ = (E,−p sin θ, 0,−p cos θ)µ = (E, p sin(θ + π), 0, p cos(θ + π))µ, (3.43)


where in this case θ is measured from the −3 direction, as

u−(p) =√E + p

(− cos θ

2

− sin θ2

), v−(p) =

√E − p

(sin θ

2

− cos θ2

),

u+(p) =√E − p

(− sin θ

2

cos θ2

), v+(p) =

√E + p

(− cos θ

2

− sin θ2

). (3.44)

For cases with a complex mass the phase of the mass will appear as interference

between amplitudes with u and v terms. This can be accounted for by explicitly

multiplying every v by the phase

η = m∗/|m| (3.45)

and every v† by η∗. Certain CP violation effects in Supersymmetry are readily in-

cluded using these η parameters.

It is important to note that for massless fermions E = p so half of the spinors

disappear. Specifically we are only left with the u−(p) and v+(p) spinors. This

means that for massless Weyl spinors the two fields ψ and ψ become completely

independent. The u term, corresponding the particle field ψ, only has a left-handed

component and the v term, corresponding to the anti-particle field ψ, only has a

right-handed component. Thus left-handed massless fermions will be consistently

treated as particles and right-handed massless fermions will be treated as antiparticles.

Assuming it is massless, the electron is treated as two completely independent fields

with e corresponding to the left-handed electron and e† corresponding to the conjugate

of the left-handed positron, i.e. the right-handed electron which is treated as an anti-

particle. Since we are treating all SM fermions, except the top quark, as massless

partons, they will all follow these conventions. In effect, this cuts in half the number

of contributing diagrams for massless fermions, and treats fermions of different spin

as distinct particles. When looking at a diagram, the spin of the massless particle will

determine whether it is a particle or antiparticle with a u or v, respectively. Whether

the particle is incoming or outgoing will determine whether the term is conjugated,

u and v∗ for incoming, u∗ and v for outgoing. Once the spin has been identified


the charge of the massless particle will determine the appropriate coupling for chiral

interactions, for instance the W boson couples to the e = e−L and its antiparticle, the

e† = e+R, but not the e = e+L and its antiparticle, the e† = e−R.

Chapter 4

Monte Carlo Methods

In general, Monte Carlo methods refer to a series of computational algorithms that

revolve around randomly sampling a known probability distribution, and performing

computations based on the selected inputs. These methods are applied in a variety

of fields for a wide range of applications, and have a history dating back to early

computational work in nuclear physics. In particle physics Monte Carlo integration

is used by all event generators to calculate event cross sections. There are other

numerical integration methods, but Monte Carlo integration is the most adept at

handling large multidimensional integrands with non-trivial regions of integration.

But the reason that Monte Carlo integration is used in event generators, and the

main reason the cross sections are calculated in the first place, is that in the process

of the integration an efficient sampling distribution over the integrand is created.

This sampling distribution facilitates efficiently generating events at rates defined by

the physics in the cross section integrand.

42

CHAPTER 4. MONTE CARLO METHODS 43

4.1 Monte Carlo Integration

To perform the most basic Monte Carlo integration we sample N random points in a

multidimensional volume V and approximate the integral of f as

∫fdV ≈ V

N

N∑i=1

f(xi) (4.1)

with the approximation getting better with larger N . This requires that the shape

of V is simple, or at least that the condition of being in V is easily parametrized.

If the actual region of integration W does not meet those conditions a larger simple

region V containing W can be sampled, if we define f = 0 for all points outside W .

While this works, it sacrifices computing power, since each point sampled outside of

W gives no information. Thus, the region V should be as close to W as possible.

In this simple version of Monte Carlo Integration, if there are highly peaked regions

of the integrand, as is common in cross-section integrals, the uniform sampling will

pick many points from regions that contribute less to the integral. One technique to

address this is called importance sampling. It seems reasonable that the integrator

should sample more points from the more interesting, highly peaked regions of the

integral, weighted to give appropriate values, in order to more accurately evaluate

the region that contributes most to the integral. This can be accomplished by first

choosing a probability distribution p over the region of integration, such that∫pdV = 1 (4.2)

where p is an approximation of the shape of the desired integral. We choose our N

points from the region V based on the distribution p instead of the uniform distribu-

tion. Then we can rewrite our integral above as

∫fdV =

∫f

pp dV ≈ 1

N

N∑i=1

f(xi)

p(xi). (4.3)

It seems that we should make this distribution p as close to our function f as possible


in order to sample from regions of V according to how strongly they contribute to

our integral. It can be shown that the optimal distribution p is

p =|f |∫|f |dV

(4.4)

but knowing this distribution perfectly requires already knowing the integral that

is being calculated. In any case there is not a straightforward way to sample an

arbitrary function f . Thus, algorithms have been designed to calculate a distribution

p that can be readily sampled and is as close to optimal as possible [22]. One example

is the VEGAS algorithmciteVEGAS.

The VEGAS algorithm approximates the d-dimensional sampling distribution as

separable into d 1-dimensional functions

p = g(x1, x2, · · · , xd) = g1(x1)g2(x2)gd(xd). (4.5)

This separable distribution is easy to store and easy to sample even for a large number

of dimensions. The algorithm then builds up a distribution p that is as close to the

optimal by starting with a uniform distribution and repeatedly sampling the integrand

and adjusting the distribution to focus on the regions of highest importance. The

sampling distribution is stored as a grid, more specifically as d 1-dimensional grids,

with each box of the grid having equal probability of being sampled. Initially this is a

uniform grid. On the first pass over the region of integration a histogram over that grid

is accumulated based on the integrand f . For each dimension, the divisions of the grid

are adjusted so that there are more grid divisions in regions that contribute more to

the integral, leading to a full grid that represents a distribution closer to the integrand

f . This process is repeated several times to converge on a good approximation to the

optimal sampling distribution.

For each of the passes described, an estimation of the integral and of the standard

deviation are computed. Each of these estimates are combined into a single best

estimate, weighted by their standard deviation. In our implementation of VEGAS,

after several passes involving grid optimization, we also run a few passes without


x1

x2

Figure 4.1: A peaked 2-dimensional integrand that would not be efficiently sampledby a sampling distribution p(x1, x2) = g1(x1)g2(x2) since it it flat in both variables. Amore efficient sampling would use the distribution p(x1, x2) = g1(x1 − x2)g2(x1 + x2)since it is peaked in the x1 − x2 direction.

grid optimization, looking for events which contribute disproportionately more to

the integral than the rest. Each point xi contributes f(xi)/p(xi), the value of the

integrand evaluated at that point divided by the probability of that point being chosen

by the sampling distribution. Thus if we have a point that has a large integrand value

and a low probability, then our distribution p is not well adjusted to the integrand,

and we should run a few more grid optimization passes to try to correct this.

While a powerful tool, the optimization of the VEGAS algorithm does not handle

all integrands equally well. VEGAS treats a d-dimensional space as separable into d 1-

dimensional functions, but not all multidimensional functions are so easily separable.

In particular, VEGAS optimizes each 1-dimensional function by projecting the full

function onto that dimension. Thus, if the larger function is fairly uniform when

projected onto each dimension, the optimization becomes ineffective, as in Figure

4.1. It is worth considering how suited the cross section integrands used in pandora

are to the VEGAS optimization.

The separable VEGAS sampling distribution creates an individual function for

each integration variable in the pandora integral. The separable nature of the pandora

integrand, where the initial process and each decay are generally separable, helps

ensure that no interesting features are hidden by being dependent on a large number


of integration variables. There are multichannel Monte Carlo methods that involve

selecting several different mappings of the d dimensional grid to the integrand and thus

different sampling distributions pi. By choosing different mappings it is possible to

redefine variables to avoid the cases were a peaked integrand is dependent on multiple

dimensions of the grid. Each of these pi are weighted based on their contributions

and the overall sampling distribution p is a weighted average of the distributions,

and using it as described above should give the correct integral [24]. We did not see

the need to go to a multichannel solution since the structure of the resonance decay

diagrams do not, in general, produce such hard to sample peaks, away from the naive

variable choices.

Theoretically, pandora is not limited in the size of the events it can simulate

but, as always, larger events lead to most difficult computations. Specifically, each

additional variable to be integrated requires a new dimension in the integral phase

space and a new dimension in the VEGAS grid. These new dimensions require more

points to fully sample them, which means more computation time. Additionally, the

large event phase space can lead to instabilities in the VEGAS grid adaptation. As

a simple example consider an integrand where the integrand is flat in the x direction

but strongly peaked in the y and z direction. A first pass at the integrand may only

sample the points near the peak at a few x values, causing the x grid to adjust to those

random points. If the integrand was just over those three dimensions it would also

become concentrated on the peak values in the y and z grid and the next passes would

strongly sample the concentrated area and smooth out the x direction. For a large

multidimensional grid there may be several of these situations. Given enough sample

points and enough passes it should adjust correctly, but it is better to remove such

problems if possible. To facilitate this we divide the integration variables into two

types, those that can be sampled reasonably well by an analytic sampling distribution,

and those that will need VEGAS adaptation to be sampled properly. For example,

rather that just integrating over the Breit-Wigner over a flat mass distribution, we can

perform an analytic change of variables using the known Breit-Wigner distribution to

make the function nearly flat, as shown in Figure 4.2. We attempt to treat as many

variables analytically as possible to keep the adaptable grid as small as possible by


120 140 160 180 200

(a)

0.2 0.4 0.6 0.8 1.0

(b)

Figure 4.2: The peaked Breit-Wigner integrand over masses (a), can be made areasonably flat integrand over a unit interval (b) by changing variables using theinverse of the Breit Wigner cumulative distribution function.

default, but pandora allows any variable to be adapted if necessary.

In addition to phase space integration variables, there are the discrete variables in

the integral that must be summed over. Specifically there are variables for helicity,

color, and decay channel selection. Some of these will be uniformly distributed while

other should be weighted according to some known values. While these discrete

variables do not have peaks and curves that need standard VEGAS adaptation, it is

useful to be able to adjust the weight values to focus on the more important values.

This can be achieved by a similar process of checking the contribution of each value of

the variable to the integral and adjusting the weight given each variable accordingly.

These three types of variables, continuous variables that can be analytically sampled,

continuous variables that need to be adapted around, and discrete choice variables,

are each distinguished and treated differently by pandora, as will be discussed in

section 5.3.

These considerations, that the pandora integrand is generally separable, and that

the portions of the function that need to be adapted around can be isolated, seem

to suggest that the VEGAS algorithm is well suited for computing the cross section

integral described in Chapter 3. Completing the computation of that integral is only

an intermediate step in the event generation process.


4.2 Monte Carlo Event Generation

As mentioned above, it is fairly straightforward to translate a Monte Carlo algorithm

for a cross section integral into an event generator. In general we are integrating the

calculated differential cross section over some phase space dΠ

σ =

∫dσ

dΠdΠ. (4.6)

So for a given random point in phase space, the probability of it occurring physically

is proportional to dσ/dΠ. Let Σmax be the maximum value of dσ/dΠ. Then we can

generate points uniformly over dΠ and keep them with a probability

dσ/dΠ

Σmax

(4.7)

and we will have events occurring at the same frequency as in nature. We can see that

this process is made more efficient by the same mechanism that makes the VEGAS

integration algorithm more efficient. Here the integrand f is the distribution dσ/dΠ.

If we choose a sampling distribution p that closely models dσ/dΠ, our integral becomes

σ =

∫dσ/dΠ

ppdΠ. (4.8)

The weight of each randomly chosen phase space point in the new sampling distribu-

tion isdσ(x)/dΠ(x)

p(x)(4.9)

We can sample the phase space accurately by assigning each point the probability

dσ(x)/dΠ(x)

p(x)Σmax

(4.10)

where

Σmax = max

(dσ(x)/dΠ(x)

p(x)

)(4.11)


If p closely models dσ/dΠ, the ratio (4.9) is nearly constant, so the probability (4.10)

is close to 1 for all events. Thus, in the process of finding a method for efficiently

calculating cross-section integrals, we find a process for efficiently generating phys-

ical events as well. As with the integral, this all depends on how well the VEGAS

algorithm can create a sampling distribution similar to our differential cross-section.

Our determination in the previous section that the cross section integrand should be

handled efficiently by the Monte Carlo integration also suggests that we should be

able to create an efficient event generator for those cross sections.

There are a few additional nuances to the event generation algorithm that dis-

tinguish it from simple cross section integration. While it is ideal to simplify the

integral into as few variables as possible, it is not always possible to apply those

simplifications to the event generation process. Specifically, even when an integrand

is constant in a particular kinematic variable and it could be analytically removed

from the integration process, we must explicitly sample it over a uniform distribu-

tion to generate events correctly. Thus all kinematic variables not constrained by

conservation laws must be treated. We will not run the VEGAS adaptation on the

variables the integrand is independent of. Instead we apply the analytic conversion

to a uniform distribution.

Additionally, the approach to what makes a good sampling distribution for a

VEGAS variable, is slightly different to what makes a good distribution for event

generation. For collecting an integral, the overall contribution to the integral is the

most important factor. So a region that is sampled with one isolated highly peaked

point, and thus a higher weight by (4.9), will be given the same importance to the

integral as region with many points of smaller weight value. For an event generator,

those highly peaked points are arguably more important, even if there are few of

them and they do not contribute much to the overall cross section. Those points

may represent rare events that are swamped out by more common events, but are

often just what we are looking for in a particle physics analysis, particularly with new

physics processes.

To reflect this perspective, we chose to implement a slightly more aggressive grid

adjustment algorithm that puts particular emphasis on individual highly weighted


points. Rather than collect a histogram of the weights and adjust teh grid to minimize

the variation over all sampled points, we adjust the grid to minimize the weight of the

highest weighted point in each section of the grid, smoothed out over the surrounding

pieces of the grid to help prevent instability. Ideally this choice and the standard

VEGAS algorithm achieve the same goal of lowering the weights of all sampled points,

until the sampling distribution is as close to the integrand as possible.

Since the focus of pandora is fundamentally the ideal sampling distribution to

facilitate event generation, we also apply an additional condition on the grid adapta-

tion process. Once the grid has been adapted a specified number of times, we sample

the grid a few more times. This may improve the accuracy of the integral, but more

importantly it is a search for highly weighted points that may have been missed. If

any are found then several more grid adaptation steps are called for to adjust to those

points. While this will add additional computing time, and may only give a negligible

change in the overall integral, it prepares a more accurate sampling distribution for

event generation.

4.3 Adaptive Monte Carlo

In Section 3.5, we discussed a more accurate integral for calculating the width of

each decay. This integral (3.30) is simply the integral of the amplitudes squared for

the particular decay, with the appropriate Breit-Wigner distribution, over the phase

space of the entire event. This will include all of the kinematic cuts on the masses of

any parent particles, and help account for effects near thresholds.

These width integrals are only slightly less complicated than the full event integral,

which suggests that evaluating them will require a significant amount of computing

power. In fact, we have found a method of calculating these width integrals simul-

taneous to the calculation of the of the full cross section integral. This method is

based on the general fact that the integral approximation (4.3) can be applied for any

function f and any distribution p. Again, as discussed in that section, the estimation

is most accurate and efficient when p is optimized to follow the shape of f closely. We

have constructed our full cross section integrand f and optimized p to it. If we want


to calculate some other integrand g we should determine how closely it is modeled by

p.

From (3.30) we see that the actual integrand for the width calculation is basically

a subset of the full cross-section integral that corresponds to the decay in question.

Thus the width integrand fw should have a very similar shape to the full cross section

integral, when the latter is considered as an integral over the variables describing

the decay only. Over all other variables, those describing the process and any other

decays, fw is flat while f will have a non-trivial shape. Thus, our sampling distribution

p does map fw well in the dimensions that contribute to it, and does not map it well

in the other dimensions. Since our VEGAS sampling distribution p stores separate

functions for each integration variable, this suggests that we construct a smaller

sampling distribution

pw(~x) =∏n∈Nw

gn(xn) (4.12)

where Nw is the set of dimensions that directly contribute to calculating the width

in question, and ~x is the particular point in that subset of dimensions. Thus we can

calculate the width integral using the modified average over N points as

∫fwdVw ≈

1

N

N∑i=1

fw(~xi)

pw(~xi). (4.13)

This approximation is based on the assumption that our smaller function fw is

flat over the other integration variables, and it is. However, the full integral is not

completely independent of these variables. We are still using the region of integration

for the full function f , which was one of the desired features, and the region depends

on the kinematics of the previous reaction. This is because the region of integration

comes from the kinematic bounds on the decays. The bounds fluctuate as the masses

of the particles involved fluctuate. The decay will not be implemented if the nominal

mass of the decaying particle is less than the sum of the nominal masses of the

daughter particles. When the Breit-Wigner distribution is applied to the masses,


there is a chance that for some points in phase space the bound

mX11 +mX12 < mX1 , (4.14)

will be exceeded. Here the masses are the fluctuated masses and X11 and X12 are the

daughter particles of X1.

As an example consider an integrand over two variables over the region [0, 1]2

defined by variables x1 and x2. We define the integrand to be peaked around 1/2

in the x2 dimension and normalized to 1. The sort of kinematic bound we describe

above might set up a situation where we want to integrate over the peak in the x2

dimension, independent of x1, but with a condition that x2 > x1, with the integrand

shown in Figure 4.3. The problem is that the sampling distribution in the x2 direction

will become correctly peaked, but that in the x1 direction, it will be weighted away

from the x1 < 1/2 region. Considering the full integral over both dimensions, we will

get a weight

p(x1, x2) = g1(x1)g2(x2) (4.15)

where g1 is almost constant over x1 < 1/2, with a value near 2. The full integral over

both dimensions will give a value of 1/2, but any attempt to normalize that integral

using only the x2 grid will fail. This is basically what we are trying to do with

pandora, normalize a piece of the integral whose region of integration is effected by

other external variables. There are two possible solutions. First, we can just include

the weight function for those external variables affecting the region of integration. For

our example this is the easiest solution, although in the full pandora integral this will

be more difficult, with many more dimensions to keep track of. Additionally, if the

full integrand is not flat in those dimensions, this may affect the subintegral as well.

Luckily, in pandora, the masses involved in the bounds on phase space can be treated

analytically with the Breit-Wigner resonance to make them fairly flat. This fact also

leads in to the second solution, the one we use in pandora, which is to make sure

that the weight function gi for the upper bound is flat. This is a natural consequence

of the adjustment we made to the VEGAS Monte Carlo algorithm discussed in the

previous section, assuming the functions involved are relatively flat. We lose some


x1

x2

Figure 4.3: A peaked function in x2, cut off by the condition x2 < x1.

efficiency due to not adapting to the holes in the phase space, but in practice these

holes will only become large when the the decay is extremely close to threshold, and

our approximation begins to break down in general.

While we have considered the effect of the integration variables higher up the decay

chain from the particular width being calculated we should briefly discuss the region

lower down the decay chain. The function is completely independent of those variables

and the region of integration, based on the kinematics cuts, is also independent of

the lower variables, so there is no direct effect on the integral. Despite this, since the

goal of this entire process of evaluating integrals for each decay is to normalize each

individual step of the decay, including them in the integral will facilitate a cleaner

recursive algorithm and allow a process for determining how well normalized the entire

decay chain is. Looking at (3.30) we want to calculate a normalization integral of the

form

2m0ΓX =∑Y1,Y2

∫tot

dΠX

∣∣∣∣ M(X → Y1, Y2)

m2X0 −m2

X − imXΓX

∣∣∣∣2 ≈ 1

N

N∑i=1

|fX,Y1,Y2(ΓX , ~xi)|2

pX(~xi)(4.16)

where

fX,Y1,Y2(ΓX , ~xi) =M(X → Y1, Y2)

m2X0 −m2

X − imXΓX(4.17)

Since the integrand is a function of ΓX we will begin with a first order estimate ΓX,0

and, as stated, we will include the decay widths lower down on the chain. Assuming all


of the lower integrands, fYi, are correctly normalized, with ΓYi

, we can incrementally

improve our estimate of ΓX by evaluating

ΓX,n+1 =∑Y2,Y2

∫tot

dV ′

∣∣∣∣∣fX,Y1,Y2(ΓX,n)∏ fYi√

2mYiΓYi

∣∣∣∣∣2

≈ 1

N

N∑i=1

1

p′X(~xi)

∣∣∣∣∣fX,Y1,Y2(ΓX,n, ~xi)∏ fYi

(ΓYi, ~xi)√

2mYiΓYi

∣∣∣∣∣2

. (4.18)

The new sampling distribution p′X includes only the gn(xn) corresponding to the

dimensions that contribute to fX and all of the fYi.

In practice, the lower integrands will not necessarily be correctly normalized, and

we must remove any errors due to them when evaluating the accuracy of the width

estimate. We can write the necessary correction to the width as

δΓX,n+1 =ΓX,n+1

ΓX,n

∏ 1

δΓYi,n+1

=ΓX,n+1

ΓX,n

∏ ΓYi,n

ΓYi,n+1

. (4.19)

Due to the statistical nature of Monte Carlo process, and the fact that, in theory,

we slowly approach more accurate values of the integral, we will not assume that

the new ΓX,n+1 is exact and replaces the old value. Indeed, we will use a weighted

geometric average that should asymptotically approach the correct value over a series

of iterations. This integrand is a function of the Γ terms so changing Γ will end up

changing the integrand by more than just a multiplicative factor. While hopefully

the change in Γ, and thus in the integrand, is small, it is necessary to restart the

integration process, resetting the stored integral data. In general the grid should be

reasonably accurate for the adjusted integrand, so the new integral will begin with

the old grid in place, ready to be adjusted as necessary to the new integral.

This gives a framework for how to evaluate many integrals simultaneously, but

there is one more issue to address. The whole reason for calculating the individual

width integrals was to correct the original full cross-section integral, and the sampling

distribution that corresponds to it. Further, looking at the individual width integrals

we see that they depend on the various widths being calculated as well. We need a


way to include the corrections we have just calculated into the full integral without

corrupting the calculation or wasting computing time. Since our corrections are

geared towards correctly normalizing the decay integrals, we have a measure of how

correct our width estimations are, by checking to what extent each normalized decay

width integrates to 1. When we observe convergence, we stop the updating of the

ΓX . The specific implementation of this evaluation and correction process will be

discusses in the implementation section in 5.5.

Adding these processes to the general VEGAS integration algorithm, we can de-

scribe adaptive Monte Carlo algorithm in pandora as made of three types of steps.

All three steps begin with sampling the integrand, and all the subintegrals for a large

number of phase space points. The first type of step adjusts the sampling grid to the

collected integrand after a large number of points are sampled. After several of these

passes adjusting the grid, the next type of step evaluates all the subintegrals and, if

they are not correctly normalized, applies the appropriate correct factors to shift the

integrand. After this the collected integral is reset, although the grid is kept intact,

and the process is repeated, adjusting the grid to the new integrand. This set of grid

adaptation and integral adjust steps is repeated a few times, by default up to five, or

until all of the subintegrals are correctly normalized. Finally the third step simply

samples more points, and looks for high weight points and, if it finds any, calls for

more grid adaptation. If no high weight points are found, the integral is considered

complete, and the sampling distribution is prepared for event generation.

Chapter 5

Object-Oriented Programming and

Class Hierarchy

Pandora is not a stand-alone program, but a series of tools to be put to use by the

user. Some basic C++ programming will be necessary to put these tools to work,

but the benefit of this is a more adaptable system for generating events for a wide

range of physics processes and analyses. We have discussed the physics background

and the computational techniques that make up the core of pandora. In this chapter

will explain the features of C++ in general and our particular approach that help

implement those ideas.

5.1 Philosophy of Object-Oriented Programming

Programming pandora in the C++ programming language allows us to take advantage

of object-oriented programming. OOP involves the grouping together of data elements

and the functions that act on them into specific structures, called classes in C++.

These classes should describe a group of things with similar sets of properties and

operations on those properties. A particular instance of the class, with definite values

for all of the included properties, is called an object. This type of programming, which

isolates closely related aspects of the program into discrete objects, is analogous to

the structure of our integral described in Chapter 3. Each layer of the process and

56

CHAPTER 5. OOP AND CLASS HIERARCHY 57

decay chain can be treated separately and linked together to form the full integral,

and this separability and linking will be reflected in the classes used to describe the

integral.

An additional feature of OOP that will figure prominently in pandora is the con-

cept of inheritance. In general a class will be a template to describe a range of objects

with similar sets of properties and functions. Individual objects will fill in the par-

ticulars of that class template to define a particular instance of that class. A class

can be defined very generally, such that a wide range of objects can be described by

it. Then it is useful to further specify the general template to describe a particular

subset of those objects. This can be done by inheritance, where a subclass inherits

the template of the parent class and adds further properties or functions to the tem-

plate to describe that specific subset. An instance of the subclass inherits all of the

properties and functions of the parent class as well. This can be used to create a

hierarchy of subclasses, further specifying particular new properties or functions with

each layer, which build to quite powerful objects that closely describe a particular

concept. In addition, any particular object can be referenced as an instance of any

of the parent classes of which it is a member. This allows two objects that are of

different subclasses to be handled by the same set of functions that they share in

common, due to a common parent class.

In object-oriented programming, subclasses are often referred to as “daughter

classes”. In this thesis, however, we will reserve the word “daughter” to refer to

the products of secondary decays, that is the particles produced in the decays of the

particle currently under consideration.

A particularly powerful tool used with inheritance is the concept of virtual func-

tions. Virtual functions are functions written in a general class that can be overwritten

by a subclass that inherits from it. Their most common use is to define a type of

function that will be used by all subclasses, but will be unique for each subclass. For

instance, every decay class will need a function to evaluate the particular kinematic

variables of the decay based on the phase space point selected. The kinematics will

be different depending on the number of decay products and whether they are mas-

sive or not. If we just defined the distinct kinematics function in each subclass, one


subclass for a decay to two massless particles and another for two massive etc., we

would have to know the particular type of decay being used to reference its kinematics

function. Instead we declare a virtual kinematics function, that we leave undefined,

and overwrite it differently in each subclass with the appropriate definition. Then,

given a particular decay object, we can call the kinematics function for the subclass

it belongs to without having to specify or know what that subclass is. Similarly vir-

tual functions can be used to overwrite a function that is exactly the same for most

subclasses, but takes a different form for a small subset of classes. It is important

to note that if a virtual function is not given a specific definition in a class then an

object of that particular class cannot be instantiated. We can only build objects of

subclasses that specify all virtual functions.

These features of OOP fit well with the mathematical properties of the integral

we are trying to compute and the physical properties of the interactions we are trying

to describe. We have incorporated them into the design philosophy of pandora. They

allow us to make the tools more adaptable and approachable for the user. In pandora,

we have made extensive use of inheritance such that any particular property or func-

tion that will be shared between different physical or mathematical objects is defined

at the most general level possible. For instance, properties that are common to all

particle decays, such as variables for the mass and width of the decaying particle, will

be defined in a class called decay that all decay subclasses will inherit from. Alterna-

tively, the functions governing the initialization of Monte Carlo variables are defined

in adaptiveMCfunction that almost all other classes inherit from. This structure

means that we only need to define any particular property or function once for all

cases. Additionally, it means that when the users are implementing new physics pro-

cesses, they only need to specify the details of their particular model, since all of the

general properties and functions are already defined.

5.1.1 C++ programming conventions

In C++, class definitions have two main pieces. First, the initial declaration names

the class and declares all of its member variables and prototypes for its member


functions, generally leaving the specifics of the functions undefined. In a separate

part of the code all of the member functions are specified, most importantly the

constructor function that should initialize the class variables. While classes can be

defined without any member functions, even without constructors, all of the classes

in pandora will have at least a constructor function to be defined.

C++ allows nearly any alphanumeric combination for variable, class, or function

names. We generally try to use names that accurately describe the nature of the

variable, class, or function. Ideally the various combinations of names when seen

in the code should reflect either the mathematical equation being evaluated or a

description of the operation. We generally try to use descriptive names for classes

that specify the particular role of the class. For example, the decay class is the general

class the all classes specifying particle decays will inherit from and SUSYspectrum is

a class that evaluates and stores the MSSM mass spectrum based on some basic

input parameters. We use a few particular abbreviation conventions that are worth

mentioning. First, in class names a lowercase m refers to a massive particle and a

lowercase z refers to a massless particle. For example, decaytotwomz is the class

describing the kinematics of an unstable particle decay to two particles, one massive

and one massless. Second, we refer to particles of a particular spin type with the

abbreviation S for a scalar particle, F for a fermion, and V for a vector particle. Thus,

FtoSFmmdecay describes the decay of an unstable fermion to a massive scalar and

a different massive fermion. Finally, there are abbreviations for specific particles.

In general the standard physics conventions are applied, so u refers to an up quark

and Z refers to a Z boson etc. One exception it that since we cannot use γ, we will

reference the photon with g and, to avoid confusion, we will reference the gluon with

gl. Finally, we generally treat processes originating in electron or photon beams

separately from process originating in proton beams, since they have non-overlapping

sets of individual partons. Processes that use electron or photon beams with electron

or photon initial partons are referred to by ee, and those that use proton beams with

quark or gluon partons are referred to by qq. There are also a few cases where q

is used to refer to final particles and it will usually include both quarks and gluons.

While we try to choose logical descriptive names, all classes and most functions and


variables are described in comments near their declaration in the code.

To make the pandora code easier to navigate and to make compiling the code more

efficient, we separate it into a number of different files, defining only a few related

classes per file. We follow a common general C++ file convention of declaring classes

in a header file, with extension .h, while in a separate file with the same name but

a .cpp extension the individual member functions of the class are defined. The .h

file must be specifically referenced using a #include "class.h" statement at the

top of the .cpp file. Similarly, if the declaration of a particular class requires using

objects from a class not defined in the same file, all of the definitions in a separate file

can be referenced using an #include "file.h" statement. This allows the stitching

together of many files into one extended piece of code that can be compiled into a

single program.

The core elements of the pandora program are defined in a set of files stored in

the engine directory. Most of the .h files in this directory declare one main class,

which shares the name of the file, and possibly one or two smaller auxiliary classes

or functions. In a few cases there are several related classes that only differ slightly

from each other and will be grouped together. For example decay2.h declares three

files for the kinematics of decays to two particles, one each for decays with zero, one

or two massive particles. Finally there is the unique hepdata.h file which defines the

common physical constants and the basic parameters of the Standard Model. It also

contains a variety of variables that store PDG particle ID codes and other ID codes

for specifying particular initial and final states. In addition there are several auxiliary

functions for particle identification and common kinematics operations.

5.2 Class Hierarchy

Looking closely at the full cross section integral (3.32), we see three main physics

elements to describe the initial beam, the initial process, and the decay chain. Fur-

ther, the decay chain can be broken up such that each step of the decay is treated

individually. This breakdown of the integral will be directly reflected in the three

main types of physics classes, the luminosity classes, the process classes, and the


decay classes. These different physics classes form the first type of class structure in

pandora. Each piece of the integral will be defined by an individual object, defined

from an appropriate class. An overall pandora object will link to the luminosity

and process objects with pointers. The process class will link to any decay classes

with pointers and those decay classes may link to further decay classes filling out the

full decay chain. While the single object will describe each piece of the integral, the

class it is defined from will be the top layer in a series of subclass layers, forming the

second type of class structure. If a particular property of a physics object is common

to many different types of objects it will be defined in a general class that can be

inherited by many different subclasses. We will discuss the various layers, from ba-

sic variable communication, to kinematics, to the helicity structure, in what follows.

This two-fold structure in pandora is described in Figure 5.1.

While the particular pieces of the full integral can be identified, they are not truly

mathematically separable, such that the full integral is a product of mathematically

independent integrals. Rather, each point in phase space that is to be evaluated is

a product of individual pieces. So, for each point to be evaluated we must evaluate

each portion of the integral correctly, being sure to choose and correctly connect

the spin of each particle and the color structure of each diagram and to choose the

particular decay channel to be used for each unstable particle. These choices and the

communication of information from higher levels of the decay chain down to lower ones

is accomplished by using pointers to link the objects representing the corresponding

pieces of the integral. The general process of cataloging and using these pointers is

similar between the process and decays, and is inherited from the most general class

adaptiveMCfunction.

5.3 Monte Carlo Classes

The most basic layers of the class hierarchy apply generally to any Monte Carlo inte-

gral, and could be applied to any integrand. Still, they have been designed with the

pandora particle physics integral in mind and have several features specifically useful

to its execution. The VEGAS Monte Carlo algorithm has two fundamental elements,


Figure 5.1: Hierarchy image of a pandora object involving the process eetoCC.

the integrand and the sampling distribution grid. As has been described, both the

sampling distribution grid and the integrand can be broken into individual pieces,

the separable functions for each dimension in the grid and the different components

of the full integrand. Generally speaking, the pieces of the integrand will be handled

by the adaptiveMCfunction class and its subclasses and the pieces of the grid will

be handled by the adaptiveMCvariable class and its subclasses.

The job of each adaptiveMCvariable class is to store the optimized sampling grid

for a particular dimension and to translate a uniformly distributed random variable

into a random variable from that optimized sampling grid. As discussed in Section

4.1, there are three relevant types of integration variables that need to be treated in

the integral. First, there are continuous variables whose contribution to the integrand

follows a known analytic distribution. For these variables no optimization is neces-

sary, and no grid needs to be stored. The random variable can simply be sent to the

integrand and the proper analytic transformation applied. Thus no particular class

is needed to describe these variables, and the random uniform random variable is left

alone. Second, there are continuous variables with complicated integrand structures


that cannot be treated analytically, and are best treated by the VEGAS optimiza-

tion procedure. These variables are treated by the Vegasvariable class. This class

stores the optimized grid for this particular variable and has functions to translate a

uniformly distributed random variable into a variable distributed according to that

grid and to optimize the grid based on the projection of the integral in this dimen-

sion. Third, there are the discrete variables that choose between various specific

choices, for instance spin states or decay channels. These variables are treated by the

Choicevariable class. This class has a set of weights for each possible choice which

is uniform by default but can be overwritten with given a priori weights. It has func-

tions to choose among the available choices based on a uniformly distributed variable

and functions to optimize the weight of each choice with respect to the projection of

the integral onto those choices.

Since the integration variables in the pandora integral are so closely related to

particular components of the integrand, it is useful to directly associate a particu-

lar component of the integral with the integration variables that contribute to it.

Each adaptiveMCfunction class will then link, through pointers, directly to the

adaptiveMCvariable classes that are associated with it. The adaptiveMCfunction

class has a switch for each variable indicating what type of variable it is so that it prop-

erly interacts with that variable as an appropriate subclass of adaptiveMCvariable,

or not interact in the case of the non-optimized continuous variable. In addition to

linking to the associated variable, each adaptiveMCfunction class can have links to

other adaptiveMCfunction classes, referred to as components, to facilitate building

up the full integral. In addition to the actual pointers linking it to other classes, there

are functions to facilitate the initialization of these links and the correct accounting

of types of variables. Built in functions also compute the total number of variables

in this class and all classes connected below it. There is a function to initialize the

variables associated with this class based on a set of uniform random numbers and to

begin the initialization of variables in each component class. There is also a process by

which this class can pass along certain kinematic variables to the component classes

attached to it, although the function to actually pass the data is virtual and must be

overwritten by a subclass. There are also several virtual functions to be overwritten


with the particular analytic translations for each variable and functions to facilitate

the process of collecting the data for the integral and adapting the integrand and the

grid. The adaptiveMCfunction class is a very general class that cannot be instanti-

ated directly because it has several purely virtual functions that must be overwritten

to evaluate properly, but it provides a framework for the building up of any integral,

and almost all other classes in pandora are subclasses of it.

One particular subclass of adaptiveMCfunction is the adaptiveMC class. This is

a controller class for the execution of the Monte Carlo integration and the selection

of points in the phase space. The main functions of this class are the getPoint()

function and the prepare() function. The getPoint() function generates the set

of uniform random variables that will define the particular point in phase space and

begins the process of evaluating the integration variables based on those random

numbers and then calls a function to evaluate the integrand based on that point.

This function is used to repeatedly sample points to build up the Monte Carlo in-

tegral and, once that is completed, it can be used to sample points based on the

optimized distribution. There are two versions of the getPoint() function, one that

generates weighted events, and one that returns unweighted or weight-1 events by

the process described in section 4.2. The prepare() function runs the full integra-

tion process, iteratively calling functions to run the various steps of the integration

process described in Section 4.3. Each step begins by repeatedly sampling points

using getPoint(weight) to build up an integral estimate, and then either optimizes

the grid or the integrand, or simply checks if any of the sampled points suggest the

grid is not well optimized. There are also a variety of functions to facilitate the full

integration process, including methods for recording of the data for the full integral

as well as any subsets of the integral, the calculation and averaging of the integral

estimates, the resetting of the integral or the grid, and the output of the integral

calculations. Like adaptiveMCfunction, adaptiveMC cannot be instantiated on its

own because of undeclared virtual functions. Specifically, the actual function to be

integrated is not defined, so this class must be inherited by a subclass that will define

the specific integral.


eetoWW

twototwomm fillph()

process installDecay() buildcrosssection() buildKinematics() buildEvent() prefactor() amplitudes()

AdaptiveMCfunction prepareMCvariables() installcomponent() buildVariables()

Figure 5.2: Hierarchy image of a eetoWW object. The location of the function corre-sponds to the level it is initialized at, and the color to the level it is defined at. Soamplitudes() is initialized by the process class as a virutal function and is finallydefined by eetoWW.

Figure 5.3: Hierarchy image of a eetoWW object.

5.4 Process Classes

IMAGE: eetoWW hierarchy image

The first set of physics classes we will look at are the classes describing the initial

2→2 or 2→3 process. As an example we will consider the classes that describe the

Standard Model process e−e+ → W+W−, whose inheritance hierarchy is shown in

Figure 5.3. As mentioned above, this class, like all physics classes, is a subclass of

adaptiveMCfunction from which it inherits the basic template for linking to integra-

tion variables and other physics classes.

The first layer above adaptiveMCfunction is the general process class which de-

scribes all initial processes. It declares variables to store the properties of the initial

partons for a given phase space point as well as the most general kinematic properties,

namely the overall collision energy and the boost from the center of mass frame to

the lab frame. These variables are common to all processes, however many daughters

may be involved, and so they are defined at this most general level. The process

class declares pointers to link to any decay classes for the produced particles. To take

advantage of any functions defined at the decay level we must be able to reference

the objects as decay objects, not just adaptiveMCfunction objects. More generally,


when the most general operations involving basic initialization of variables are done,

all objects are treated as adaptiveMCfunction objects, but when higher level func-

tions need to be addressed, we must treat them as objects of the appropriate level.

There is a function installDecay() to initialize the links to a particular daughter

class, which will also call the native adaptiveMCfunction linking function. One of

the empty virtual functions, buildVariables is overwritten to begin the process of

calculating the kinematics of the process including the masses of any decaying parti-

cles and to pass those masses to the connected decay classes. The specific kinematics

calculation is left to an undefined virtual function, one of several declared to handle

defining the actual helicity amplitude of the process and the construction of the event

listing, the IDs masses and properties of all particles involved in the event. Also in

this class is a general process to construct the integrand based on the helicity ampli-

tude of the process and the helicity amplitudes of the decays, using the new virtual

functions. Finally there are a series of useful functions to limit the set of initial parton

channels to be included in the simulation. This will be discussed more fully in Section

6.1. Once again, the process class further specifies the adaptiveMCfunction class,

but it cannot be instantiated since there are still virtual functions that need to be

specified, namely the initialization of kinematic variables and the calculation of the

helicity amplitudes.

The next level of the hierarchy involves the twototwomm class which describes any

2→2 process with two massive daughters. The role of this level of the hierarchy is

to define the kinematics of the process, which is universal to all 2→2 processes with

massive daughters. The previously undefined virtual function buildKinematics() is

declared at this level. This will set the values of the decay angles and the physical

daughter masses, based on the output of the adaptiveMCvariable classes attached

to this process. Another overwritten virtual function correctly assigns the momentum

variables of the process and boosts those momentum vectors and all decay momentum

vectors into their correct lab frame values. Finally a third virtual function is over-

written to correctly label each particle involved in the decay for the event output, and

to assign the correct color structher and to connect the color structure of the process

to the color structure of the decays. This particular set of variables and functions


have completely analogous versions in the twototwomz and twototwozz classes which

govern processes with one or no massive daughters. There are analogous but slightly

more complicated versions of these classes for the classes governing 2→3 processes,

such as twotothreemmm. The classes that involve massless particles declare an addi-

tional virtual function, fillph(), which should assign the particle type and helicity

of the massless particles. This assignment is handled by the decay classes for massive

particles.

As above, the classes at the level of twototwomm cannot be instantiated since there

are still undeclared virtual functions, specifically, the functions defining the particular

helicity amplitudes for the process. In our example the hierarchy is finally completed

in the eetoWW class. Following our class naming conventions defined in Section 5.1.1,

this class implements the two Standard Model processes e−e+ → W+W− and γγ →W+W−. The amplitudes for both have been calculated and coded into the class

overwriting the inherited virtual function amplitudes(). These diagrams are grouped

together because electron and photon beams will have both electrons and photons as

partons. For theoretical purposes, one might wish to turn off one of the other of

these processes. This can be done with the general initial parton selection functions

defined in the process class. These controls as well as functions to limit the allowed

decay channels of any unstable daughter particles will be discussed further in Section

6.1. The final step that the eetoWW class must do is to declare the specific decay

classes that will be the daughter particles and link them to the process using the

installDecay() function.

Even for just the Standard Model, the particular helicity amplitudes of a process

can become quite complicated and prone to error. To help facilitate easier imple-

mentation of new physics models we have added another layer of class hierarchy that

distinguishes between the spins of the various final daughter particles and defines

the amplitudes up to the appropriate renormalizable couplings and masses of the

particles, which the user provides. These classes will be discussed further in Section

6.2.


HiggstoZgdecay

decaytotwomz fillph()

decay installDecay() buildKinematics() buildDecayVectors() placeIDs() amplitudes() properamplitudes()

AdaptiveMCfunction prepareMCvariables() installcomponent() buildVariables()

Figure 5.4: Hierarchy image of a HiggstoZgdecay object. The location of the functioncorresponds to the level it is initialized at, and the color to the level it is defined at.So properamplitudes() is initialized by the decay class as a virutal function and isfinally defined by HiggstoZgdecay.

5.5 Decay Classes

The hierarchy of the classes governing the decays of unstable massive particles has

a similar pattern to that governing the initial process. However, there is an added

complexity of implementing the choice between a variety of decay channels that a

particular unstable particle might take. First we will consider the class structure

of an individual decay channel, and then we will discuss choosing between multiple

channels.

As a particular example of this structure, we consider the SM Higgs decay class

as an example. As for many particles the Higgs decay has several different decay

channels, some of which have distinct massive final states and must be treated by

separate decay classes. This requires an additional structure to choose among the

various decay classes. First we consider one particular decay channel the decay h→Zγ whose hierarchy is pictured in Figure 5.4. Once again the most basic layer of

the hierarchy is the adaptiveMCfunction class, which establishes the processes for

linking to integration variables and other physics classes, mainly any daughter decays.

The next layer is the general decay class, which describes all unstable particle

decays, and distinguishes these classes from the process branch of the hierarchy.

Analogous to the process class, general variables for the mass, width and other


properties of the decaying particle are declared, and pointers to daughter decays are

declared, so that the daughter decays can be addressed on the decay class level as

well as the more general adaptiveMCfunction level. Also there is the installDecay

function to link daughter decays, and the function to pass the physical mass values

of the daughters along for each phase space point. As with the process class there

are several virtual functions that will be overwritten by various subclasses to define

the specific kinematics and helicity amplitudes of the particular decay, so the decay

class cannot be instantiated on its own.

In addition to these classes analogous to the process class, there are a set of func-

tions to control the recording of data for and the evaluation of each width integral

for each individual step of the decay. There classes implement the method described

in Section 4.3 for normalizing the particle widths correctly, which is needed for each

individual decay step. The record() function simply records the value of the appro-

priate subset of the integrand and the appropriate subset of the distribution function.

The updatefunction function first updates all the decays below the current level,

and returns the value of the width integral below the current level. Next the value of

the integral at the current level is calculated from the recorded data, and an estimate

of the standard deviation is made. If the current integral is within 2 standard devia-

tions of the desired value of 1 it is left alone. If not it is shifted by the multiplicative

correction (4.19).

The next layer is added by the decaytotwomz class which defines the kinematic

structure of a massive particle decaying to one massive and one massless particle.

Building on the structure of the decay class, the virtual functions related to the

decay kinematics are defined, such as choosing the masses and decay angles of the final

particles based on the selected grid points and building the momentum vectors for all

of the particles involved. Some virtual functions related to the helicity states are left

virtual and a new virtual function to determine the final state of the massless particle

is defined. The structure of decaytotwomz is very similar to the other decaytotwo

classes, with slight differences based on the kinematics or whether the decay needs to

connect to another class for a massive final state or simply determine the properties

of a particular massless final state. There are also analogous classes for decays with


three final particles, such as decaytothreemmm.

Finally the HiggstoZgdecay class takes all of the structure and adds the final

details to determine a particular physics process. The last virtual functions are defined

giving the specific helicity amplitudes of the decay and the properties of the photon

final state. Additionally a new decay object is instantiated for the daughter Z boson

and is attached using the installDecay() function declared at the decay class level.

Having given all variables and functions a specific definition, the HiggstoZgdecay

class can be instantiated as an object with no ambiguity. Due to the structure built

up by all the subclasses, it can communicate with all of the other classes that will

make up the overall cross-section integral.

There are additional classes that have been defined to ease the implementation

of new physics process which are specified by the spin of the final state particles.

These classes have the helicity amplitudes already declared up to the appropriate

renormalizable couplings and particle masses. The structure and use of these classes

will be described in 6.2.

We have described the class structure for an individual channel of the decay

of a Higgs particle, but the Higgs can decay to any one of several different chan-

nels. To control this we declare a different subclass of decay called complexdecay.

The complexdecay class inherits all of the basic structure of the decay class, such

as the basic particle properties. It is associated with one integration variable, a

Choicevariable which will be used to choose between the various decay channels.

Further it declares list of pointers which will store the links to all the different decay

classes representing the various decay channels. The complexdecay class chooses a

particular decay with a probability proportional to the previously calculated decay

widths for each decay. There are several new functions to handle installation of new

decay classes, and the initialization of the Choicevariable. Then, all undefined

virtual functions, and a few already defined functions, are overwritten such that they

call the corresponding function of the particular channel chosen for that point in

phase space. Finally the classes handling the integration of the width integrals for

each decay are overwritten, such while only the proper channel is sampled at each

point, all channels are evaluated when the subintegrals are calculated. To describe


the Higgs boson, all of this structure is inherited by the Higgsdecay class, which

simply declares the decay class for each possible channel and links them using the

functions defined in complexdecay.

5.6 Luminosity Classes

In considering how to implement the physics of the initial beams, there are a few ways

to parametrize the variables involved. The class should eventually return the selected

momentum fractions x1 and x2 and the corresponding momentum distribution

x1fp1(x1)x2fp2(x2). (5.1)

The first look at this suggests that the process is completely separable into the two

beams, and in principle each beam could be treated individually, combining their

individual contributions. We chose not to do this, but to treat the incoming beams

together in a single luminosity class for several reasons. First there are some situa-

tions, particularly with the quark pdfs, where it is more efficient to sample points in

the variables ECM and rapidity, y. With this approach, x1 and x2 are derived values

x1 =ECM

2Ebeam1

ey, and x2 =ECM

2Ebeam2

e−y. (5.2)

The variables ECM and y are not independent and cannot be sampled by independent

beam classes. Additionally, there is a sense in which the combined class is more

fundamental physically due to the possibility of the beams affecting each other, for

instance through beam-beam interactions before the collision.

The general class governing the initial beams is the luminosity class. As above, it

is a subclass of adaptiveMCfunction. It is responsible for calculating the momentum

fractions for the chosen initial partons and helicities. The processes of computing the

physical parton properties for the proton beams and the electron beams are so differ-

ent, that the general class is mainly a placeholder for the variables a functions pandora

needs to be able to calculate the full cross section integral. It declares the variables

for the beam energies and polarizations, as well as for the identity and helicity of


the chosen parton as well as its momentum fraction. It also declares basic functions

for accessing the basic beam properties, and a virtual function distribution for the

distribution function of the chosen initial partons. This distribution function returns

(5.1).

The pplumi class is a subclass of luminosity which determines the appropriate

proton proton beam properties based on a given set of proton pdfs. It overwrites the

virtual function buildVariables() to use the random variables to choose a set of

momentum properties of the selected initial partons for the given phase space point,

and overwrites distribution() to calculate the distribution function of those partons

for the selected momentum fractions. Auxiliary classes to convert the selected pdf

data set into the actual distribution functions are defined as well. Additionally, there

is a separate ppbarlumi subclass that converts the calculation to a proton antiproton

collision.

The eelumi class is the analagous class for electron and positron beam colli-

sions. It also implements the buildvariables() and distribution() functions

but the process is much different. Several random variables are used to determine

the momentum loss of the selected parton based on initial beam spread, initial state

radiation, and beamstrahlung, and then the distribution function for the selected mo-

mentum is analytically calculated for the selected machine parameters. The explicit

implementation is described in [17] The ememlumi implements these calculations for

electron-electron collisions. The final implemented luminosity class gglumi carries

out similar analytic calculations for the Compton backscattering of a photon photon

beam collision.

5.7 Pandora Class and Output

Having declared classes for the individual pieces of the cross section integral, the

pandora class runs the full Monte Carlo integration and event generation. It is

a subclass of adaptiveMC and inherits the general integration controls from that

class. The pandora class takes pointers to a luminosity class and a process class

as inputs, and has two Choicevariable objects that are used to select the initial


partons and the initial helicities. Once the initial state variables are chosen for a given

phase space point, the momentum fractions are calculated by the luminosity class

and those are used to calculate the kinematics of the process class and any decay

classes attached to it. Once the kinematic variables are determined, and assuming

the kinematics state is valid, the overall integrand is calculated by combining the

parton distribution and the overall process cross section from the luminosity and

process classes respectively. The specific process of the Monte Carlo integration,

selecting points and accumulating the result into the full integral are controlled by

functions defined at the adaptiveMC level. Before any event generation is attempted,

the prepare() function must be called. This method implements the three step

preparation algorithm describe in Section 4.3 Once that is completed, the getEvent()

function uses the inherited getPoint() functions to sample additional phase space

points, with the added step of constructing a record of the event for each point.

Each pandora class controls the integration and event generation for one process

class usually corresponding to one 2 → 2 or 2 → 3 initial process, and all of its

possible decay chains. A pandorasBox class is provided to handle generating events

from more than one than one initial process at a time. Each process class still needs

to be given its own pandora class, and each of those pandora classes need to be

initialized with the prepare() functions. The pandorasBox class can link to several

of these classes randomly choose among all of them, weighted by their previously

calculated cross sections. Calling the getEvent() function for pandorasBox will call

the corresponding getEvent() function for a randomly selected class. A version that

generates weighted events, getEvent(weight), is also available.

The record for each event from the getEvent() functions comes in the form of an

object of the LEvent class. This class contains the list of lab frame four-vectors for

every particle in the event, initial and final particles, as well as every intermediate

unstable particle. In addition there is a series of lists storing their particle ID numbers,

helicities, colors, the identity of their parent particles and identifiers for the initial

and final particles. These LEvent objects can be translated into usable output in a

few ways. Each LEvent can be printed onto the screen or saved into a file using a

<< operator, but this becomes impractical for large numbers of events. Histograms of


particular portions of the data can be created using the histogram classes, and plots

can be generated using the gnuplot class in conjunction with the gnuplot program.

While this can produce useful output for analysis, the individual events are not stored,

so a new plot requires running the integration and event generation process again.

The most useful way to perform detailed analysis of large numbers of events is to use

the eventRecord class which takes the LEvent objects as input and stores them in a

file, of type .lhe, according to the Les Houches accord format [15]. This format is a

compact way to store large numbers of events, and is standardized so that it can be

directly input into other particle physics programs such as PYTHIA and HERWIG

for simulation of hadronization and detector event detection. The details of how to

use these various output methods are discussed in Section 6.8.

Chapter 6

Implementation of New Physics

In order to use pandora to analyze a particular new physics model, the user must

define any process and decay classes that will contribute to the physics being studied.

While this may appear to be a daunting task, there are mechanisms in place to

try to simplify the process such that each class should only require a few lines of

code to handle correctly. There are several ways to go about defining a new class

for a new particle or physics process that can be distinguished by what amount of

structure the new class will inherit. Specifically, the user can make a new class a

subclass of an existing complete decay class, a subclass of a class defined for a specific

helicity combination, or a subclass of a class for a kinematic configuration. There

are advantages to each type of definition and it will depend on the particular type

of process or decay channel being defined. Before discussing the various ways to

implement new physics, we will look at a few conventions and tools that are common

to all implementations.

6.1 Common Tools

The hepdata.h file, in addition to defining basic physical constants and SM param-

eters, defines the conventions for labeling particles and for specifying the types of

beams and the specific initial state partons to be used. These labels are stored as

constant integer variables. Each variable is declared globally and assigned an integer

75

CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 76

value which cannot be changed. The compiler will treat them as integers but using

the variable names makes the code more readable.

The first set of these constants are just the standard PDG Monte Carlo Particle

numbering scheme for SM and MSSM particles and a few light hadrons, and a few

related particles are stored in vectors so that they can be referenced by an index

number, for example the MSSM neutralinos and charginos.

There are a limited number of initial states for any pandora process, since only

massless partons which can be generated in beams are considered. A particular initial

state can be specified by four integers, two parton ID numbers and two helicity values,

but it is useful to convert these four numbers into one identifier that is used to index

the initial states. For purposed of this indexing we will deviate from the standard

PDG labels and will treat electron and photon beams as distinct from proton beams,

labeling the two conventions leptonset and hadronset respectively.

For the leptonset convention the photon is identified by an index of 0, and the

electron and positron by 1 and -1 respectively. These three possible partons set up a

3 × 3 matrix of initial parton stated that can be used to number the channels from

1-9,

e+ γ e−

e+ e+e+ e+γ e+e−

γ γe+ γγ γe−

e− e−e+ e−γ e−e−

→

−1 0 1

−1 1 2 3

0 4 5 6

1 7 8 9

. (6.1)

The single index is stored in the CHP variable, and a similar index for the helicities

from the 2×2 helicity matrix is stored in CHH variable. For the hadronset convention

the gluon is identified by 0 and the quark partons are labeled 1 through 5 according

to their PDG ID (d is 1, u is 2, etc). The antiquarks are assigned negative values.

A similar 11× 11 matrix can be used to index the 121 possible hadron initial states,

with the value stored in CHP and the same 2 × 2 matrix indexing the helicity states

in CHH. Functions are provided to convert between the CHP and CHH indices and the

parton ID numbers and helicity values, based on the given convention. In addition,

the 9 leptonset and 121 hadronset initial states are given constant variable names

according to the convention in Table 6.1 to make the code more understandable when


Parton x or y →e+, e− ep,emγ g

d, d d,dbaru, u u,ubars, s s,sbarc, c c,cbar

b, b b,bbarg gl

Table 6.1: The xychannel naming convention for initial channel constants

identifying specific initial states. There is a third convention implemented called

generalset which simply keeps the PDG ID codes, except moving the photon to 0,

and could be used to implement any type of initial parton interactions, but it is not

used in any of the physical beams implemented so far and the corresponding constants

are not defined.

The CHP and CHH variables and the auxiliary functions are used in the process

class to index the possible initial state channels. In addition there are a series of

functions implemented in the process class to allow particular initial state channels

to be turned on and off in the integration. The most basic of these functions are

makeactive() and makeinactive() which take either a CHP index, the corresponding

constant, or the two initial parton IDs and makes the corresponding channel active or

inactive. There are also the makeallactive() and makeallinactive() functions to

manipulate all of the channels at once. We caution that if no channel is open pandora

will not return any results. In addition to these, there are a series of functions, listed

in Table 6.2, which open specific commonly used sets of initial states, leaving all

others closed.

The final set of constants in hepdata.h are for use in identifying particular de-

cays to massless particles. These variables are given names of the form leptonsOnly,

bcOnly, and invisibleOnly, with the allStates constant to identify all open chan-

nels. These variable will be used by decays with multiple possible decays to SM

particles, most commonly the decays of massive SM particles like the W, Z, and

Higgs boson.


Function Open channelseeactive() e−e−

eepactive() e−e+, e+e−

epepactive() e+e+

ggactive() γγegactive() e−γ, e+γ, γe−, γe+,

leptonAnnactive() e−e+, e+e− , γγqqactive() qq′

qqbaractive() qq′, qq′

qbarqbaractive() qq′

glglactive() ggqqallactive() qq′, qq′, qq′, qq′

qgactive() qg, gq, qg, gqhadronAnnactive() qq, qq, gg

Table 6.2: Common initial channel functions

These constants are designed to be used along with the onlyDecay() functions,

implemented in the process and decay classes, although these default functions must

be overwritten by specific decays in order to have an effect. The default behavior of

onlyDecay() in both the process and decay classes is to take either one, two, or

three integers as input, and then call the onlyDecay() function of the first, second or

third attached decay class with the first second or third input respectively. There is

an alternative definition in the complexdecay class that takes one input and uses it

to select one specific channel of the complex decay exclusively. These default versions

are of limited effect, and are mainly there as placeholders for user defined functions,

in user defined classes.

Some examples of the onlyDecay() functions being used effectively are the decays

of the W , Z, and Higgs bosons. Here the onlyDecay() functions takes one of the

constants defined in hepdata.h to select specific channels for their decays. We intend

lightquarksOnly to refer to the u, d, and s quarks, and heavyquarksOnly to refer

to the c, b, and t quarks. For the Z and Higgs decays, where there is no flavor mixing,

the effects of the constants should be straightforward, although only reasonable values

of the constants are implemented. For example, calling the Z boson onlyDecay with

the WWOnly constant or calling the Higgs boson onlyDecay with eOnly will return


an error message. For the W boson with CKM mixing in the quark decays this may

not be so obvious. If a specific quark is referenced then any decay involving it or its

antiparticle is included to the exclusion of all others. The lightquarksOnly constant

will include decays involving only light quarks and heavyquarksOnly will exclude

decays involving only light quarks.

6.2 Invariants Classes

In order to facilitate easier implementation of helicity amplitudes for processes and

decays, we developed a series of classes that will compute common kinematic objects

once and for all. A separate class is needed for different numbers of initial and

final states, with the 2 → 2 and 1 → 2 classes currently implemented. The classes

take the basic kinematic variables and use them to calculate the products of spinors,

polarization vectors, momentum vectors and σ matrices. The classes will calculate

all possible invariants up to one power of momentum in the numerator for all possible

combinations of scalars, vectors and fermions for the initial and final particles, using

the explicit spinor and polarization vector conventions defined in Section 3.7.2.

Looking at the invariants class which deals with 2 → 2 processes, there are four

functions related to initializing the kinematics, starting with the constructor:

invariants(double m3, double m4);

void setetas(complex eta3 , complex eta4);

void setkinematics(double Eb, double kf, double E3

double E4, double cost , double sint);

void sethelicities(int h1, int h2, int h3, int h4);

The constructor requires the nominal masses of the two final state particles, as

inputs. By default the masses are real. For fermions where the masses can have a

phase η (defined in (3.45)), their phases can be implemented with setetas(). The

setkinematics() functions defines the kinematics of a particular phase space point

in the CM frame. The common energy, and momentum, of the two massless initial

partons is Eb. The shared momentum of the final particles is kf and the energies of

the final particles are E3 and E4. The sin and cos of θ, the angle from the momentum


of particle 3 to the beam axis, is stored in sint and cost. With the standard pandora

event orientation convention this gives momentum vectors of

k1 = (Eb, 0, 0, Eb) k2 = (Eb, 0, 0,−Eb)

k3 = (E3, k3*sint, 0, k3*cost) k4 = (E4,−k3*sint, 0,−k3*cost). (6.2)

The final function sethelicities defines the helicities of the four particles. The

helicity variables are integers, and will typically be ±1 for left and right handed

helicity, respectively, whether for fermions or vectors. A helicity input of 0 for the

longitudinal state is allowed for the final scalar or vector particles, but it must not

be called for massless vectors or the program will attempt division by the mass of 0.

Specific kinematic functions are called by using the functions of the form uekev()

where u and v represents the u(k) and v(k) spinors, e represents the polarization

vector ε(k), and k represents the momentum vector kµ. The functions take an input

for each element which identifies the particle that corresponds to each element. The

appropriate conjugations and σ matrices are assumed. Thus for our example

complex uekev(int j, int k, int l, int m, int n)

calculates

u†(kj)σ · ε(kk)σ · kl σ · ε(km) c v(kn), (6.3)

which is only valid for j, n = 3, 4, and k,m = 1, 2. The functions will return the

default 0 for an invalid combination of inputs. A detailed listing of all the invariant

functions and what they calculate is in Appendix A.1.

For 1 → 2 decays, the related decays2invariants class defines the appropriate

invariants. It again assumes the pandora decay orientation convention, where the de-

caying particle, particle 0, has helicity measured along the +3 axis and the first decay

product,particle 1, has momentum in the +3 direction. The initialization functions

decays2invariants(double m1, double m2);

void setetas(complex eta0 ,complex eta1 ,complex eta2);

void setkinematics(double M, double kf, double E1,

double E2);

void sethelicities(int h0, int h1, int h2);


define the momentum vectors

k0 = (M, 0, 0, 0) k1 = (E1, 0, 0, kf) k2 = (E2, 0, 0,−kf)

and the masses, phases, and helicities of all three particles. The conventions for

the invariant functions, such as uev(), are the same and a detailed listing of all the

functions and exactly what they calculate is made in Appendix A.2.

6.3 Using the kinematic classes

While it is possible to build a process or decay class directly from the most general

process and decay classes, or even from adaptiveMCfunction, this will almost never

be useful since the basic kinematics for most 2 → 2 and 2 → 3 processes and 1 → 2 and

1 → 3 decays are universal, as are the basic functions manipulating and storing the

records of the events. These common functions are already written in the classes like

twototwomm described in Chapter 5. The first, and most involved, way to implement

part of a new model is to define classes inheriting directly from these kinematic classes

and defining all of the undefined virtual functions. For most implementations, it will

be possible to use some of the other classes and tools described below which handle

some of the details described here automatically, but for completeness we will describe

what is necessary to build a working subclass of these classes.

6.3.1 Processes

As an example we will consider the e−γ → W−νe process defined in the eetoW class.

This is a subclass of the twototwomz class. In order to complete the class definition

we must define the class constructor function, install any massive decays, and define

and undefined virtual functions. Looking at the declaration of the eetoW class we

find:

class eetoW : public twototwomzt {

public:

eetoW(int charge );


eetoW(int charge , double ptmin , double Emin ,

double thetamin );

eetoW(int charge , double ptmin , double etamax );

protected:

void declareOpenChannels ();

double prefactor ();

void amplitudes ();

void fillph ();

invariants IV;

int charge;

};

There are three constructors that correspond to the constructors for twototwomz.

The three constructors differ in placing different kinematic cuts on the final state

momenta. The first assumes the default set of cuts on the massless particle of θmin =

0, pT,min = 10 GeV, and Emin = 0 GeV, while the second applies the given explicit

cuts. The third applies a different set of cuts on the massless particle, based on

ηmax, the maximum pseudorapidity of the massless particle. The definition of all

three constructors is the same, except that they call the corresponding constructor

for twototwomz and pass along any input cuts. The common input of charge defines

the charge of the W boson.

The four other declared functions are the four undefined virtual functions inherited

from process and twototwomz. First, declareOpenChannels() is a function to de-

clare which initial parton channels are open and closed. By default all are closed, so at

least one must be opened. This function is not called by the parent classes, but should

be called in the constructor. The prefactor() function returns the multiplicative

prefactor for the cross section, and amplitudes() defines the helicity amplitudes in

the vector Camps, which is indexed over helicity states. The differential cross section

will be computed as

dσ

d cos θ= prefactor()×

∑h

|Camp[h]|2, (6.4)

where h encodes the two final state helicities. Finally the fillph() function sets the

color structure and massless final parton and helicity configurations. The IV object


is a member of the invariants class, described in 6.2, and will be used to facilitate

calculating the helicity amplitudes. The charge variable stores the selected W boson

charge.

Before writing the constructors, we must look at constructor of the parent class

to know what inputs it requires. The prototype for the default constructor of the

twototwomz class is:

twototwomz(int partonset , double M3, int states3 ,

int nfinal );

There are additional constructors with the kinematic cut inputs listed above, but

the inputs in this constructor are common to them all. The first input, partonset,

is required by any process class and establishes the convention for indexing initial

parton states which we described in Section 6.1. For an electron or photon beam pass

the leptonset constant and for a proton beam pass the hadronset constant.

The next two inputs only occur for kinematic processes involving massive daugh-

ters. The first is just the nominal mass of the massive particle, and for twototwomm

there would be a second M4 input for the second particle. The states3 variable is

the number of helicity states of the massive daughter, 3 for vectors, 2 for fermions,

and 1 for scalars. For twototwomm there is an additional states4 input for the he-

licity states of the second massive particle. The product of all the states variables

will determine the number of final helicity states and the length of the Camps vector

storing the helicity amplitudes.

While for massive particles we sum over helicity states, since they are internal lines

of the full diagrams, for massless particles we must select the specific helicity state

for each event. In addition, since multiple possible massless final state partons can

be treated in a single class, we must select the specific parton state as well. Further,

there is the possibility of multiple color structures for a single helicity state, and we

must select the specific structure. These selections are signaled by the nfinal input

variable, which specifies the total number of choices. The process class picks a value

of the integer variable final from 1 to nfinal. We must choose nfinal to be the

maximum number of massless final states that might need to be selected between for

any given initial state. It should be maximum, over all initial states, of the product


of the number final parton states, times the number of helicity states, times the

number of color structures. This could require a lot of bookkeeping, especially with

a large number of parton choices. In general, there are only multiple final parton

states for processes to multiple massless particles, and there are very few new physics

2 → 2 process to all massless particles at tree level. Thus for most cases only the

helicity states and color structure will contribute to nfinal, and the helicity states

are generally limited by helicity conservation as well. The process of identifying the

specific color and massless parton configuration based on the chosen value of nfinal

and the chosen initial state is done by fillph().

The constructor for any subclass of one of the twototwoxx kinematic process

classes must: call the appropriate kinematic class constructor; install decay classes

for any massive daughters; and make at least one initial parton channel open. There

may be other auxiliary functions and variables that must be defined and instantiated

to fully define the particular physics of the class, but the above steps are the minimum

requirements. For our example class the default constructor is:

eetoW::eetoW(int Charge ): twototwomz(leptonset ,mw ,3,1),

IV(mw ,0.0), charge(Charge ){

name = " e gamma -> W nu ";

installDecay (1,new Wdecay(charge ));

declareOpenChannels ();

}

First the parent constructor is called, specifying the leptonset convention and

identifying the massive particle as a vector particle with mass mw which is a global

variable storing the W boson mass. The choice of W boson charge of -1 or +1 fixes

the massless particle as a νe or νe, respectively, and also fixes the helicity. Since there

is no color involved the nfinal variable should be 1. The IV object is a member

of the invariants class, described in Section 6.2, used to help calculate the helicity

amplitudes. It is initialized with the masses of the two final particles. Finally the

charge input is stored in a class variable. The installDecay() function is called to

create and link to the appropriate decay class, in this case Wdecay. The final step

is to open an initial state channel, done here by calling declareOpenChannels().

The name variable is a string that is used to identify the process is certain output


functions, and is not required to generate events.

The declareOpenChannels() function should use the makeactive() functions,

described in Section 6.1, to declare the appropriate initial state channels open. For

pandora to run at all at least one channel must be opened. The diagrams contributing

to the helicity amplitudes will determine which diagrams should be opened and which

should not. Further selection of particular initial states for focused analyses can be

made after the process object is instantiated. In our example there are two possible

channels for each choice of W boson charge, the eg channels that conserve charge.

The function definition in this case is:

void eetoW:: declareOpenChannels (){

if (charge == -1) {

makeactive(egchannel );

makeactive(gechannel );

} else {

makeactive(epgchannel );

makeactive(gepchannel );

}

}

To form the cross section integral, the result returned by the prefactor() func-

tion will be combined with the Camps vector, defined in amplitudes(), according

to (6.4) with additional contributions from the decays included as well. Technically

any multiplicative factors could be moved from the amplitudes to the prefactor, and

the entire prefactor could simply be multiplied into Camps. For consistency, and to

reflect the actual calculation, we follow the convention that only the contributions

to the matrix elements are included in amplitudes and everything else is put into

prefactor(). The one exception to this is that we pull out a factor of e from each

interaction of the amplitude and place it, squared, in the prefactor, making it pro-

portional to α2. The standard 2 → 2 prefactor will be

πα2

2s

|kf |ECM

×(

0.38938× 1012fb

GeV−2

). (6.5)

The conversion factor from GeV−2 to fb is stored as a global constant in hepdata.h


e−

γ

W−

νe

!e−

γ

W−

νe

Figure 6.1: Diagrams for e−γ → W−νe

as fb. Any additional color factors, QCD corrections should be multiplied here.

Additionally, if nfinal is greater than 1, then the prefactor should be multiplied by

nfinal/ncases, where ncases is the number of values of final that identify the given

configuration. This will compensate for the reduced number of times each individual

configuration is selected and correctly normalize the contributions to the integral. It

is common that the prefactor will depend on the initial state chosen or on the final

variable, particularly when color and nfinal factors are involved. In our case, Figure

6.1, there is no color factor, and nfinal is 1 so the standard prefactor is appropriate.

The prefactor() function is defined as:

double eetoW:: prefactor (){

const double pref = PI*alpha*alpha * fb/2.0;

double A = (pref/s)* (kf/Eb);

return A;

}

The amplitudes() function must fill the complex vector Camps with the helicity

amplitudes as a function of the kinematic variables and the initial and final parton

states. In general there will be a series of definitions, one for each initial and final state

configuration, with a different element of the vector filled for each massive particles

helicity state. This process can be simplified both computationally and in terms of

code by using the invariants classes. With these classes, we can simply write down

the basic amplitude from the Feynman diagrams and express it using the invariants

class functions. Then we simply pass the kinematics to the invariants class and

iterate through the final helicity states, passing the helicities along as well, and it will

calculate the amplitude in terms of the kinematic variables. The diagrams for our


example process is shown in Figure 6.1, and applying the standard two component

Feynman rules, discussed in Section 3.7.2, we get

iM =e2√

2 sin θWu†(k4)σ · ε∗(k3)

σ · (k1 + k2)

sσ · ε(k2)v(k1)

+ e2u†(k4)σµu(k1)

1

u−m2W + imWΓW

·[ε(k2) · ε∗(k3)(k2 − k3)µ

+ ε∗(k3) · (−(k2 + k3)− k2)ε(k2)µ + ε(k2) · (k3 + (k2 + k3))ε∗(k3)µ

]. (6.6)

Applying a few identities, expressing it in terms of the invariants class functions,

and removing the e2 factor which is accounted for in prefactor() we can write our

amplitudes function:

void eetoW:: amplitudes (){

const complex MWsq = mw * (mw - I * GammaW );

Camps.zero ();

IV.setkinematics(Eb,kf,E3,E4,cost ,sint);

int fh = 0;

for (int h3 = -1; h3 <= 1; h3 ++){

fh++;

IV.sethelicities(h1,h2,h3,h4);

if (charge ==-1){ // CHP = egchannel only

Camps[fh] = (1.0 /(sqrt (2.0) *sw))

*((IV.uekeu (4,3,1,2,1)+IV.uekeu (4,3,2,2,1))/s

- 2.0* (IV.ee(2,3) * IV.uku(4,3,1)

+ IV.ek(3,2) * IV.ueu(4,2,1)

- IV.ek(2,3) * IV.ueu (4 ,3 ,1))/(u - MWsq ));

} else { // charge =-1, CHP = gepchannel only

Camps[fh] = (1.0 /(sqrt (2.0) *sw))

*((IV.vekev (2,1,1,3,4)+IV.vekev (2,1,2,3,4))/s

- 2.0* (IV.ee(1,3) * IV.vkv(2,3,4)

+ IV.ek(3,1) * IV.vev(2,1,4)

- IV.ek(1,3) * IV.vev (2 ,3 ,4))/(t - MWsq ));

}

}

}

Finally we must define the fillph() function. As mentioned above, this can be


very complicated for classes with many massless parton choices, but for most new

physics processes this will only involve selecting helicity and color structure, and they

will generally be quite constrained. The variables that must be defined by fillph()

are the pi and hi, where i is the number of any massless final particles. If any of

the massless final particles have color, then the color value must be specified with

the Ci variable, 3 for quarks, -3 for antiquarks and 8 for gluons. If color structures

need to be assigned, the Cfinal variable should be set to the appropriate value. The

default for Cfinal is 1 which is correct for colorless interactions. For processes to two

massive final states there is a default fillph() function that simply assigns Cfinal

the value final. This is valid, since there are no massless partons of helicities to

choose, as long as only one color structure contributes to the reaction. For processes

with massless final states it is undefined and must be overwritten. In our example

there the charge of the W boson completely constrains the final state so we have:

void eetoWp :: fillph (){

if(charge == -1){

p4 = 12; h4 = -1;

} else {

p4 = -12; h4 = 1;

}

}

This completes the specification of the eetoW class.

6.3.2 Decays

Building a decay class is similar to building a process class, but is simpler on many

levels. First, the initial state is fixed, since it is just the decaying particle. Second,

the amplitude calculations are simpler since they will involve fewer vertices and fewer

external legs. Also, pandora assumes a fixed decay direction and adds the angular

terms afterward by rotation matrices, described in Section 3.7.1. These factors lead

to fewer virtual functions that need overwriting and fewer computations.

For an example of we will use the decay of the t quark which is controlled by the

tdecay class. The declaration of the class is:


class tdecay : public decaytotwomz {

public:

tdecay(int charge );

// use tdecay(1) for a top ,

// tdecay(-1) for an antitop decay

void properamplitudes ();

void setcharge(int charge );

protected:

void fillph ();

};

This simple specification gives full spin correlation for every t or t produced by pan-

dora. There is only one constructor, which takes an input value to select the t versus

the t decay, and only two virtual functions to overwrite. The properamplitudes()

function is analogous to the amplitudes() function above, and fillph() performs

the same function as for the process class.

We must first consider what is needed for the parent constructor. The prototype

for the decaytotwomz constructor is:

decaytotwomz(int ID, double mass , int states ,

double M1, int states1 , int nfinal );

The ID input is the PDG ID number of the decaying variable, which can be ref-

erenced by the appropriate constant defined in hepdata.h. The mass and states

inputs are the mass and the number of helicity of the decaying particle. The M1 and

states1 inputs are the same properties for the massive daughter particle. If there

are more massive daughters there will be additional similar variables. Just as for the

process class, the nfinal variable should be the maximum number a final config-

urations, the product of the number of final massless parton choices, final massless

helicity choices, and color structures. For 1 → 2 decays only a decay involving 3 color

octets can have more than one color structure, so it will often simply be used to select

the helicity state.

The constructor for the decay classes must call the parent constructor and install

any decay classes for massive daughters, like for the process classes. In addition it

must define two variables, divideby and G. The divideby variable should be set to

the squared sum of all the helicity amplitudes, using the nominal masses to specify the


decay momentum, divided by the number of helicity states of the decaying particle.

This is the first estimate of the value of the matrix element squared, which will be

used to try to normalize the decay. This will be adjusted based on the results of

the integral if function adaptation is turned on. The variable G should be set to the

nominal width value, which will be the standard decay prefactor times divideby,

multiplied by any additional color or nfinal factors. If the decaying particle has

color, that color should be defined in the C variable in the constructor as well. For

the tdecay example, the constructor is:

tdecay :: tdecay(int Charge ):

decaytotwomz(Charge*6,mt ,2,mw ,3,1){

charge = Charge;

C = 3 * Charge;

divideby = sqrt (2.0 * (2.0 + SQR(mt/mw)))

* (mt*mt - mw*mw )/(2.0* mt);

G = Gammat;

decay * DW = new Wdecay(Charge );

installDecay (1,DW);

}

The properamplitudes() function should fill the matrix CDPamps which has two

indices. The first is the helicity of the decaying particle, and the second is the set

of final helicity states of massive particles, indexed similarly to Camps. While there

is a decays2invariants class to aid in the calculation of the helicity amplitudes, in

this example it is quite straightforward. The use of the auxiliary class is analogous

to the use of invariants above. The matrix element is expressed in terms of the

functions of the class, and for each event the kinematics are set, and the matrix is

filled by iterating through all of the possible helicity states. In this case the kinematic

formulas are quite simple and are just added by hand:

void tdecay :: properamplitudes (){

CDPamps.zero ();

if (charge > 0){

CDPamps [ -1][1] = kd * 2.0;

CDPamps [1][2] = kd * (mt/mw) * sqrt (2.0);

CDPamps /= divideby;

} else { // charge < 0


CDPamps [ -1][2] = kd * (mt/mw) * sqrt (2.0);

CDPamps [1][3] = - kd * 2.0;

CDPamps /= divideby;

}

}

This simple prescription gives full spin correlations for every t or t produced by

pandora.

Finally we must define the fillph() function, which should use the final variable

to set the pi, hi, and, if necessary, Ci variables for each massless final states. In

addition, in the rare case where multiple color structures are involved it should set

Cfinal. As above, decays to only massive states have a default fillph() that sets

Cfinal to the value of final. In cases with massless final particles it is undefined

and must be overwritten. In our example the identity and spin of the final particle is

fixed by the choice of the t or t:

void tdecay :: fillph (){

if (charge > 0){

pd2 = 5; hd2 = -1; C2 = 3;

} else { // charge < 0

pd2 = -5; hd2 = 1; C2 = -3;

}

}

6.4 Using an existing completed class

The simplest way to define a new class is simply to take a pre-existing decay or process

class and redefine a few elements. This only really makes sense when you have a new

particle that is extremely similar to an already implemented particle, such as one

from the SM or the MSSM. A simple example to implement is a Z ′ with all the same

couplings as the SM Z boson but a higher mass. Since the Z decay is a single decay

class that has several massless final states, the Z ′ decay can be defined as a subclass

of the Zdecay class. The only change is to set the mass variable M to the desired

value.


class Zprimedecay: public Zdecay{

public:

Zprimedecay( double mzp);

}

Zprimedecay :: Zprimedecay(double mzp){

M = mzp;

}

In addition, in this case various branching ratios can be adjusted as well by ad-

justing the variables defined in the Zdecay class, but at some point it may be easier

to simply define a new class altogether. This version of the constructor restricts the

decays to leptons by making the last 10 channels of the Choicevariable FI inactive.

Zprimedecay :: Zprimedecay(double mzp){

M = mzp;

for (int i=10; i<=20; i++){

FI->makeinactive(i);

}

}

This is a trivial example. In general, when considering new physics, new channels

will open up that need to be defined, and these will require a new complexdecay

to control the various channels. Still, the channels of any new physics process that

closely correspond to an already defined decay, or process, can be defined this way.

6.5 Using the processtype and decaytype classes

In the process of implementing the MSSM into pandora we found it advantageous to

create a series of classes to deal once and for all with 2 → 2 processes and 1 → 2

decays involving the various possible particle types (scalar, fermion and vector) that

are found in most new physics models. These classes are labeled by the type of

particles involved as well as whether those particles are massive or massless (using

the m for massive and z for massless convention). So a fermion decaying to a massive

vector and a massless fermion is described by the FtoVFmzdecay class, and a process

of two partons from a proton beam going to two massive fermions is described by the

qqtoFFmm class. These classes inherit the appropriate kinematic structure from one


of the kinematic classes and completely describe the helicity structure of the decay or

process, up to the specific couplings and masses involved, as well as the appropriate

propagators for the process classes. The user simply needs to define these couplings

and masses, and give the various propagators involved, as well as provide pointers to

the decay classes of any massive daughter particles.

6.5.1 Decays

These classes describing decays at the helicity level all share a similar class structure.

As a first example, we will look at the StoSSmzdecay class. This class is declared as

class StoSSmzdecay : public decaytotwomz {

public:

StoSSmzdecay(int ID, int color , double Smass ,

decay * SD1 , int sID2 , int nfinal =1);

void setcouplings(complex GS, double Cfactor );

protected:

int sID2;

complex GS;

double Cfactor;

void computeGamma ();


void fillph ();

};

The two undefined virtual functions in the decaytotwomz, properamplitudes()

and fillph(), are overwritten here. Thus, this class could be instantiated as is,

although it will generally be more useful to declare a subclass that inherits from it

with a more appropriate name. To properly initialize this class, whether through a

subclass or simply by instantiating an object, it simply needs to have the constructor

called and the setcouplings function called with appropriate inputs.

The constructor for StoSSmzdecay has a very similar structure to all of the other

decaytype classes. These classes have names of the form XtoXXxxdecay. The first

three inputs will always be the decaying particle PDG ID, its color, and its mass,

labeled Smass for the scalar decays, Fmass for fermions and Vmass for vectors. Next,

for each massive final particles there will be a pointer to the appropriate decay class,


and for every massless particle a PDG ID number. Finally there is the nfinal

variable, that is set to a default value of 1 or 2 depending on if there are multiple

possible helicity final states for the decay. The default fillph() is to simply select

the helicity of the massless particles, if necessary, since the parton ID is fixed by the

input value. If a more complicated set of massless configurations is desired involving

either more final partons, or more than one color structure, nfinal should be set

to the appropriate value, and fillph() should be overwritten to act accordingly.

Technically, properamplitudes() could be overwritten as well, but at that point it

is just as easy to declare the class directly from the kinematics level classes.

The setcouplings() function sets the two adjustable parameters in the decay,

the coupling Gs and a multiplicative prefactor Cfactor. For interactions involving

scalars and vectors, there is only one coupling and it is a simple multiplicative factor

on the matrix element. The width of the decay is calculated in the computeGamma()

function, which is called by setcoupling(). The default width value is

Cfactor× 1

16πM|M|2 S

|C|(6.7)

here S is 12

for identical final states and C is the color of the particle. The standard

color factor for the color average of the initial particle is included, but any additional

color factors or other multiplicative factors can be added with Cfactor.

Decays involving fermions add an additional layer of complexity, since we must

account for the two interaction diagrams with opposite fermion line direction. This

simply means we have two couplings to consider, and we must be careful to treat

them correctly. Let us look at the FtoVFmmdecay class as an example:

class FtoVFmmdecay : public decaytotwomm {

public:

FtoVFmmdecay(int ID, int color , double Fmass ,

decay * VD, decay * FD, int Nfinal =1);

void setcouplings(complex GF, complex GFbar ,

double Cfactor );

protected:

complex GF, GFbar;

double Cfactor;


decays2invariants IV;



};

The constructor has the same structure described above and the set of functions

is extremely similar. The fillph() function is not defined since the default version

defined for decaytotwomm should be correct in most cases. The two other differences

are that there are now two couplings input into the setcouplings() function and

there is a decays2invariants object. The two couplings are labeled GF and GFbar.

The convention for any helicity level decay class involving fermions is the GF is the

coupling that treats the first listed fermion as a particle, and GFbar is that coupling

that treats that fermion as an antiparticle. So for fermion decays, GF is the coupling

with the decaying particle gives a u spinor and GFbar is the coupling where it gives

a v† spinor. For decays from a scalar or vector to two fermions, GF is the coupling

where the first fermion contributes a u† spinor and GFbar is the coupling where it

contributes a v spinor. The decays2invariants object is included to facilitate the

calculation, but also to implement proper treatment of complex phases on the fermion

masses. If there are complex phases to be considered, the constructor of the subclass

should call the setetas function to input the phases.

As a example, the definition of the class for the MSSM decay of C+1 → N0

1W+ is:

class CdecaytoNW : public FtoVFmmdecay {

public:

CdecaytoNW(int j, int k, SUSYspectrum & S);

};

CdecaytoNW :: CdecaytoNW(int j, int k, SUSYspectrum & S):

FtoVFmmdecay(SIGN(Chargino[ABS(j)],j),

1,ABS(S.mC[ABS(j)]),

new Wdecay(SIGN(1,j)), new Ndecay(k,S)){

IV.setetas(S.etaC[ABS(j)], 1.0, S.etaN[k]);

if (j>0) {setcouplings(conj(S.GNCWm[k][j]),

-S.GNCWp[k][j] ,1.0);}

else {setcouplings(conj(S.GNCWp[k][-j]),

-S.GNCWm[k][-j] ,1.0);}

}


The complete decay is described by defining just the constructor, and the con-

structor is only a few lines long. The daughter decays are created inline as they are

passed to the helicity level decay, where they are installed. The constructor simply

calls the setetas() function and the setcouplings() function, with different values

depending on the sign of the decaying chargino. The actual MSSM masses and cou-

plings are retrieved by referencing specific vectors and functions. These are methods

of the SUSYspectrum class explained in Section 7.2.1. While the specifics of this class

which defines and stores the masses and couplings for the MSSM will be discussed

later, this examples shows how compact new decays definitions can be when using

the helicity level classes.

6.5.2 Processes

For the process classes the definition is more involved. In addition to giving particle

properties and couplings, the user must list the virtual propagators connecting the

initial and final state particles. Again the problem of specifying these contributions

can be addressed once and for all if we assume that only tree diagrams corresponding

to s, t, and u-channel exchanges will be included.

The constructor and initialization functions for these classes are very much like

those of the decay classes. As an example we will look at the eetoFF class. The first

part of its declaration is:

class eetoFF: public twototwommt {

public:

eetoFF(double M1, double M2, int c1, int c2);

eetoFF(double M1, double M2, int c1, int c2,

double thetamin );

eetoFF(double M1, double M2, int c1, int c2,

double ptmin , double etamax );

protected:



void amplitudes ();

invariants IV;

...


There are again three constructors, the default and two with additional kinematic

cuts. The common input variables are just the masses and colors of the two final

particles. We make extensive use of the invariants object to facilitate calculating

the many possible contributing diagrams, and in the case where the final particles have

complex phases on their masses, they should be added with the setetas() function.

The previously undefined virtual functions defined for these classes, and designed to

handle implementing any possible tree level diagram. The declareOpenchannels()

functions declares the 4 ee channels open, since in general only they will contribute.

A mixed eγ state is not possible since both final particles are fermions. There would

be three external fermion legs and no way to connect the fermion lines correctly. The

one possible photon initial state is the γγ initial state, which will only be open if the

two final state fermions are a charged particle antiparticle pair. In this case there is

a t-channel diagram with the same final fermion as propagator. When this channel

is open, the s-channel photon state is also open, so the two will be handled together.

That is all that is needed for the basic declaration, but before we can generate events

we must establish what propagators will contribute.

For this class, there are four functions that can be used to add propagators,

two for the common photon and Z boson propagators, and two for general scalar and

vector propagators. Three fermion vertices are not allowed so there can be no fermion

propagator. The functions to add the propagators are

void addgammaprop(double Q);

void addZprop(double I31 , double Y1,

double I32 , double Y2);

void addVprop(double Mprop , complex GF1e ,

complex GF1eb , complex GF2e ,

complex GF2eb , complex Geeb ,

complex Gebe , complex GFFL , complex GFFR);

void addSprop(double Mprop , complex GF1eu ,

complex GF1ebu , complex GF1ev ,

complex GF1ebv , complex GF2eu ,

complex GF2ebu , complex GF2ev ,

complex GF2ebv , complex Geeb , complex GFF);

Here the couplings follow conventions defined in the header file, such that all


"C

γ

γ

C+

C−

(a)

#γ, Ze−

e+

C+

C−

(b)

$νe

e−

e+

C−

C+

(c)

Figure 6.2: Diagrams contributing to the eetoCC class.

possible vertex combinations are accounted for.

As above, the class is declared as a subclass of the appropriate processtype class

initialized with the appropriate particle properties and pointers to any needed decay

classes. Now the user must call the appropriate function to define the various propa-

gators of the process, such as addSprop for a scalar particle propagator or addVprop

for a vector particle. These functions require giving the mass and couplings for these

propagators to the initial and final particles, with different couplings corresponding

to the various s, t and u- channels. From these function calls a list of propagators is

built up and the appropriate helicity amplitude is constructed.

As an example consider the class defining a eetoFF process from the MSSM,

specifically e−e+ → C+C−. This process will be discussed more fully in Section 8.3,

but for our purposes it will demonstrate the compact nature of the class definitions

in this case. The eetoCC class defines a process from electron beams to two mas-

sive charged fermions, shown in Figure 6.2, and the only function it requires is the

constructor

eetoCC :: eetoCC(int i, int j, SUSYspectrum &S):

eetoFF(ABS(S.mC[ABS(i)]), ABS(S.mC[ABS(j)]), 1, 1,

S.etaC[ABS(i)], S.etaC[ABS(j)]){

installDecay (1,new Cdecay(i,S));

installDecay (2,new Cdecay(j,S));

if (i==-j){ addgammaprop(SIGN(1,i));}

if (i*j<0){

if (i<0){

addVprop(mz ,0,0,0,0,-(0.5-sstw )/(sw*cw),-(sw/cw),

S.GCmZ[ABS(i)][ABS(j)],


S.GCpZ[ABS(j)][ABS(i)]);

addSprop(ABS(S.sfmass(snue)),0,0,

S.GsfCm(snue)[ABS(i)],0,

S.GsfCp(snue)[ABS(j)],0,0,0,0,0);

} else {

addVprop(mz ,0,0,0,0,-(0.5-sstw )/(sw*cw),-(sw/cw),

S.GCpZ[ABS(i)][ABS(j)],S.GCmZ[ABS(j)][ABS(i)]);

addSprop(ABS(S.sfmass(snue)),

S.GsfCp(snue)[ABS(i)],0,0,0,0,0,

S.GsfCm(snue)[ABS(j)],0,0,0);

}

}

The constructor simply calls the installDecay() function to install the appro-

priate decays and then adds the necessary propagators. In this case there is one

scalar and one vector propagator and the appropriate couplings to make the vector

s-channel and the scalar t-channel. There are two cases implemented, depending on

the charge of the two final particles, and an additional possibility of an s-channel

photon propagator, and the corresponding γγ initial state process if the two final

particles are of the same species and opposite charge.

For most decay channels and many initial processes, this type of definition will be

the simplest class construction, since only the input of the various particle properties

and couplings is required, with the specific helicity amplitudes already calculated. It

should be noted that for new unstable particles these classes will define one particular

decay channel. If there are several decay channels to be included for the particle a

complexdecay class must be declared as well. This is described further in the next

section.

6.6 Using the complexdecay class

We have described the implementation of a particular physics decay, with specific

initial and final particles, but in general a decay will have several kinematically allowed

decay channels with different final state particles. As mentioned above, to correctly

implement this choice of decay channels we use a controller class called complexdecay.


To define a decay with multiple channels the user declares a new class as a subclass of

complexdecay with the appropriate particle mass and spin type. In the declaration of

this class the user must call the function add() for each decay channel to be treated,

using a pointer to the class defining that decay channel as input. For bookkeeping

purposes, such as when some channels may become open or closed depending on the

masses of the particles involved, it may be useful to add a nodecay class when a

channel is kinematically closed. The nodecay class is a dummy decay class with no

width. In this context it will never be sampled, but it can hold the place for a possible

decay class that is closed for the current set of nominal particle masses. Once all of the

decays have been added, the function build() must be called. This will get the width

of each included decay channel and set up a choice variable to appropriately sample

the various channels based on the values of those widths. The build() function must

be called before any attempt to sample points in the complexdecay subclass is made.

Once build() is called more channels can be added using the add function, as long

as build() is called again once all channels are added. This allows the user to add

on to existing decay classes by inheriting from a given complexdecay subclass and

adding extra channels to the decay if needed.

As a simple example of a complexdecay we consider another MSSM example, in

particular the class called sfermiondecays which governs the decays of sfermions,

which are scalar analogs of the fermions. In this case everything is done in the

constructor

sfdecay :: sfdecay(int id, SUSYspectrum &SS):

complexdecay(id,SS.sfmass(id),1,7), S(SS),

GfN(S.GsfN(ABS(id))), GfCp(S.GsfCp(ABS(id))),

GfbN(S.GsfbN(ABS(id))),GfCm(S.GsfCm(ABS(id))),

V(S.Vsf(ABS(id))){

C=findcolor(id %100);

int j;

double mf1=0.0, mf2 =0.0;

if (ID == stquark1 || ID == stquark2) {mf1=mt;}

if (ID == sbquark1 || ID == sbquark2) {mf2=mt;}

for (j = 1; j <= 4; j++) {

if (M <= ABS(S.mN[j])+mf1){


add(new nodecay(ID,M,2,C));

} else if (mf1 >TINY){

add(new sttoNtdecay(ID,j,S));

} else{

add(new sftoNfdecay(ID,j,S));

}

}

for (j =1; j <= 2; j++){

if (M <= ABS(S.mC[j])+mf2||

((ID<sdquarkR )&&( ABS(ID%10) <5))){



add(new sbtoCtdecay(ID,-SIGN(j,ID),S));

} else if (ABS(ID%2) == 1){

add(new sftoCfdecay(ID,-SIGN(j,ID),S));

} else {

add(new sftoCfdecay(ID,SIGN(j,ID),S));

}

}

if (M <= ABS(S.mg)+mf1 || ABS(C) < 3){



add(new sttosgtdecay(ID,S));

} else{

add(new sttosgtdecay(ID,S));

}

build ();

}

In this particular case, there are several possible types of decay channels, and

several versions of each of them, but only a few will be kinematically open in most

cases. For each possible decay channel a mass check is performed and either a nodecay

or the appropriate decay channel class is added to the list of decays. Thus a specific

channel will always be in the same place on the list, no matter what the particular

mass spectrum. This class also performs an additional check for cases where a top

quark is one of the decay products, instead of a massless fermion, and a separate class

that will correctly decay the top quark will be added. Finally, once every class is added

the build() function is called to gather the widths of the decays and construct the


branching ration. If for some reason an additional decay channel should be desired,

it could be added by calling the add() function for the decay class, being sure to call

build() once all decays were added.

6.7 A more complex example

We discussed the class structure used to describe the SM Higgs in order to show how

the particular classes used were built up from more basic classes. Similarly it will be

useful to consider the Higgs again as an example of building onto existing completed

classes to define new interactions. In particular we will consider how to construct

an extended Higgs sector which is comprised of two Higgs doublets, similar to the

MSSM Higgs sector. This doublet manifests as two neutral Higgs scalars, a neutral

pseudoscalar and a charged scalar. The neutral scalars couple to other SM particles

just like the SM Higgs up to a multiplicative shift in the coupling, which can be

calculated based on the parameters of the sector. Therefore it will be useful to build

the extended Higgs decays on top of the SM Higgs.

Since the couplings of each decay channel will be affected differently, it is necessary

to define new classes for each decay channel. To build these, we can simply inherit the

general structure of the decay channels to SM particles, since they only need to have

a redefined mass and a shifted coupling. First, for simplicity the various parameters

of the extended Higgs sector are computed and stored in a separate HAhparameters

class for easy access. Included in this class are the ushift() and dshift() functions

which return the appropriate multiplicative coupling shifts for the selected Higgs

scalar. Then to define the decay class for decays to tt we have

class HAhtottbardecay: public Higgstottbardecay {

public :

HAhtottbardecay(int ID, HAhparameters & HP);

};

HAhtottbardecay :: HAhtottbardecay(int id,

HAhparameters & HP):

Higgstottbardecay(HP.hmass(id)){

ID=id;


coupuu *=conj(HP.ushift(ID));

coupvv *=HP.ushift(ID);

computeGamma ();

}

The ID variable defines whether the decaying particle is the light scalar h, the

heavy scalar H, or the pseudoscalar A, and the HAHparameters object HP stores all

the masses and couplings of the sector. The original SM Higgs decay to tt is called with

the appropriate mass using the hmass function. Next, that SM decay is corrected by

giving it the correct id number, and then shifting the two couplings by the appropriate

multiplicative factor, using the functions ushift() and dshift() functions. Finally

computeGamma must be called again to recompute the correct width with the new

couplings.

A slightly more complicated case is the decay to light SM particles. This is

implemented by a class Hahtolightdecay which needs to overwrite the computeGamma

()function

class HAhtolightdecay: public Higgstolightdecay {

public:

HAhtolightdecay(int ID, HAhparameters & HP);


private:

HAhparameters & HP;

};

HAhtolightdecay :: HAhtolightdecay(int id,

HAhparameters & HHP):

Higgstolightdecay(HHP.mh),HP(HHP){

ID=id;

computeGamma ();

}

void HAhtolightdecay :: computeGamma (){

for (int i=1; i<=2; i++){

Gammas[i]*= norm(HP.ushift(ID)); //ccbar

Gammas [2+i]*= norm(HP.dshift(ID)); //bbbar

Gammas [4+i]*= norm(HP.ushift(ID)); //mumu

Gammas [6+i]*= norm(HP.ushift(ID)); //tautau


}

Gammas [9]*= norm(HP.glshift(ID));

Gammas [10]*= norm(HP.gshift(ID));

G=0.0;

for (int i=1; i<= nfinal; i++) {G+= Gammas[i];}

DVector w(Gammas/G);

FI->putAPW(w);

}

Since each channel needs to be adjusted separately an overwritten version of

computeGamma() is needed, which simply recalls the original SM version and applies

the appropriate shifts in the couplings.

In addition to these decay channels to SM particles that can simply inherit from

the original SM Higgs, there are decays between different Higgs sector particles that

must be defined from scratch. For example one of the neutral Higgs particles can

decay to charged Higgs and a W boson, defined by

class HAhtoWpHmdecay: public StoSVdecay {

public :

HAhtoWpHmdecay(int ID, int Hq, HAhparameters & HP);

};

HAhtoWpHmdecay :: HAhtoWpHmdecay(int id,int Hq,

HAhparameters & HP):

StoSVdecay(id,HP.hmass(id),

new nodecay(SIGN(Hpboson ,Hq),HP.mHp ,1),

new nodecay(-SIGN(Wboson ,Hq),mw ,3),

1.0){

switch(ID){

case hboson:

coup = ecoup*(Hq >0?-HP.GHphW:conj(HP.GHphW ));

break;

case Hboson:

coup = ecoup*(Hq >0?-HP.GHpHW:conj(HP.GHpHW ));

break;

case Aboson:

coup = ecoup*(Hq >0?-HP.GHpAW:conj(HP.GHpAW ));

break;

default:


therror("ID is not valid for HAhtoWpHmdecay");

}

computeGamma ();

}

Here the new decay is defined using one of the decaytype classes StoSVdecay,

from which it will inherit the helicity structure, which happens to be trivial in this

case. The id variable again defines the decaying particle, and Hq defines the sign of the

charged Higgs, which will be opposite the W charge. The StoSVdecay class requires

the decaying particle id number the mass, given by the hmass function, two pointers

to the two massive final state particles, as well as the single coupling needed to define

the decay. Since the coupling needs to be calculated appropriately, a dummy value

of 1.0 is given at first, and in the declaration the appropriate value for the coupling

variable is determined, based on the decaying particle and the Higgs charge. Since

the coupling has been redefined the correct width must also be recalculated using

computeGamma. A similar process is used to define the other new neutral Higgs

decays, as well as to define the decays of the charged Higgs particle which has no SM

counterpart.

Once all the decay channels are defined they must be combined into a single Higgs

decay class using complexdecay. While the SM Higgs already has a complexdecay

class defined, it points to all the original SM Higgs decay classes so inheriting from

it would not link to the correct decays. Thus, a new HAhdecay class is defined.

class HAhdecay : public complexdecay {

public:

HAhdecay(int id, HAhparameters & HP);

protected:

HAhparameters & HP;

void inputChannels ();

};

HAhdecay :: HAhdecay(int id, HAhparameters & HHP):

complexdecay(id, HHP.hmass(id), 1,9), HP(HHP){

initialize ();

}


void HAhdecay :: inputChannels (){

channel [1] = new HAhtolightdecay(ID,HP);

channel [2] = new HAhtottbardecay(ID,HP);

channel [3] = new HAhtoWWdecay(ID,HP);

channel [4] = new HAhtoZZdecay(ID,HP);

channel [5] = new HAhtoZgdecay(ID,HP);

channel [6] = new HAhtoWpHmdecay(ID, 1,HP);

channel [7] = new HAhtoWpHmdecay(ID ,-1,HP);

if (ID== hboson || ID== Hboson ){

channel [8] = new HAhtoZhdecay(ID,Aboson ,HP);

channel [9] = new nodecay(ID,HP.hmass(ID),1);

}

else {

channel [8] = new HAhtoZhdecay(ID,hboson ,HP);

channel [9] = new HAhtoZhdecay(ID,Hboson ,HP);

}

}

This class simply defines a complexdecay and adds pointers to the appropriate

decay channels. Since the masses of the individual particles in the Higgs sector vary

depending on the particular parameters chosen, it is necessary consider all possible

decay channels, and check that each one is kinematically accessible before initializing

a member of the appropriate decay class. While there are kinematic checks elsewhere

in the definition of each channel, it is important to check that each channel is open at

this level, since each new class will initialize members of its massive daughter’s decay

classes, whether or not those lower kinematic checks are passed.

This extended Higgs sector is exactly the Higgs sector of the MSSM, except that

there are new decay channels to other supersymmetric particles that must be treated

as well. The above structure can be expanded simply by defining the new decay

channels with the decaytypes classes, defining a new general MSSM Higgs class that

inherits from the HAhdecay complexdecay class and adding the new channels with

the add() function. In the following example, the class adds the decays of neutral

Higgses to two neutralinos, h,H0, A0 → NiNj with the parameters for the neutralinos

taken form the SUSYSpectrum class described in Section 7.2.1. The other additional

MSSM Higgs decays are not shown.


class SHAhdecay: public HAhdecay {

public:

SHAhdecay(int ID, SUSYspectrum & S);

};

SHAhdecay :: SHAhdecay(int id, SUSYspectrum &S):

HAhdecay(id, new HAhparameters(S)){

for (int i=1; i<=4; i++){

for (int j=1; j<=i; j++){

if(M>(ABS(S.mN[i])+ABS(S.mN[j])))

{add(new SHAhtoNNdecay(ID,i,j,S));}

}

...

Unlike the expansion from the SM to the extended Higgs sector, the treatment

of the decays from the Higgs sector to the SM and within the Higgs sector do not

change, so all of the existing decay channels are still valid for the MSSM Higgs.

6.8 Generating Events

Once the particular set of process and decay classes that you are interested in sim-

ulating are defined, pandora can use them to generate collider events. In order to do

this the user must write a short simulation program that uses the classes and tools de-

fined for pandora to calculate the integral and generate physics events. This program

will have four main portions: the #include statements, the parameter definitions,

the sampling distribution preparation, and the output control. As an example, we

show a simple program that generates e−e+ → W−W+ → e−νee+νe events at a 500

GeV ILC type collider using the eetopairs process class defined for the SM. The

entire program is

#include "pandora.h"

#include "eelumi.h"

#include "eetoWZ.h"

#include "eventRecord.h"

int main (){

double ECM = 500.0;

int Nevents = 1000000;


eelumi * lu = new eelumi(ECM/2.0, 0.8, ECM/2.0,

0.3, ILC500 );

eetoWW * proc = new eetoWW ();

proc ->eepactive ();

proc ->onlyDecay(eOnly ,eOnly)

pandora P(lu,proc);

P.prepare(Nevents );

P.printEventLabel(cout)

cout << endl;

eventRecord eR("eetoWWenu" ,1,1);

eR.inputbeaminfo (11 , -11 ,500 ,500 ,0);

eR.inputprocessinfo (1,1,P);

eR.begin ();

for (int i=1; i<= 10000; i++){

if (100*(i/100) == i){

cout << " Wrote event no. " << i << endl;

}

LEvent LE = P.getEvent ();

eR.writeLHAformat(LE)

if (i <=10){ cout <<"event "<<i<<endl <<LE<<endl;}

}

eR.finish ();

return 0;

}

The first three lines are the #include statements that tell the program exactly

what files contain the code that defines all of the classes and objects that we will be

using. In general it is necessary to provide #include statements for the files that

define every class that will be used in the main() function. In fact to completely

compile the program we will need many more files that just the three listed in order

to define all of the parent classes that the eelumi, eetoWW, and pandora classes inherit

from. It is not necessary to include all of them here, since each of the files that we do

reference here in turn call all of the files needed to define their own classes, so by just

including these three we will include all the files needed to compile. In fact, it is not

technically necessary to have an #include statement for the pandora class since it is


included by several other files as well, but for simplicity and consistency we include

it since it is referenced directly in this file. Any duplicate calls to include the same

files will be skipped.

The other portions of the simulation program all fall within the main() function.

This is the function that will be executed when the executable compiled from this

code is called. The first step is to define the parameters necessary for the beams and

processes. In this case we are simulating a SM process without reference to the Higgs,

so there are no free parameters to define. If we were using a new physics model we

would need to define any parameters that may be needed to define the particular

mass spectrum and set of coupling involved. For instance, the SUSYspectrum class

defines the masses and couplings for a particular point in the MSSM parameter space,

as discussed in Section 7.2.1. We would need to define the particular SUSYspectrum

object for the particular parameter space point here before we can define the processes

involved. In our case we simply define the total beam energy ECM which is an input for

the eelumi class, and the number of events to be used in the integration Nprepare.

Next, we have to define the particular pandora class and prepare the sampling

distribution over it. To do this we define the luminosity and process classes we

intend to use for the simulation. Rather than directly define an object of the eelumi

class we define a pointer to a luminosity object and then tell the compiler to instantiate

a new object where that pointer is referencing. In the line

eelumi *lu = new eelumi(ECM/2.0,0.8,ECM/2.0,0.3, ILC500 );

The asterisk defines lu to be a pointer to an object of the eelumi class, which

rather than directly storing an object, stores the address in the system memory where

a particular object is. The new statement tells the compiler to create the following

object and pass along its address in memory. So after this line the lu pointer stores the

address in memory of the newly created eelumi object, which was created using the

default eelumi constructor function. We use pointers rather than directly referencing

the object because if we tried to pass the object directly to some function, then the

function would create a new copy of that object for its own use. This would be very

taxing on the memory for the complicated objects we are dealing with. The particular


eelumi class we have defined is an ILC type collider with a center of mass energy

of 500GeV, half of which comes from each beam. The beam polarizations are set to

80% for the e− and 30% for the e+ beam, as actually envisioned for the ILC.

We similarly define a pointer to the desired process class, in this case the eetoWW

class. This standard model process takes no inputs in the default constructor so

the declaration is straightforward. The next two lines to use the eeactive() and

decayOnly() functions to restrict the initial state, and the particular decay channels

of the W bosons. These functions are discussed more fully in Section 6.1, but we

should note how they are called here. Since both of these functions are member

functions of the class pointed to by the proc pointer we use the proc-> prefix to tell

the compiler where the particular function is defined. This syntax can be used to run

several different member function for the process before integrating it. In fact it is

even possible to call the member functions of the decays with a syntax of the form

proc->Df[1]-> but this requires knowing the exact location of the desired decay in

the decay chain. If too many of these member functions need to be called before

running the simulation, it may be easier to just adjust the class definitions.

Finally we define the pandora object directly using the pointers to the luminosity

and the process objects. The last stage of the preparation step is to call the

prepare() function with the desired number of integration points. This number

is actually just a reference and more points may be used if function adaptation is

used or additional grid adaptation is found to be necessary. There is another form of

the prepare() function that takes the particular number of each VEGAS integration

step, function adaptation, plain grid adaptation, and maximum weight search, to be

executed. Both forms of the function can take one addition input to define the numer-

ical seed for the random number generator used in the Monte Carlo integration. This

is default to 1, so that if it is not overwritten, pandora will always produce exactly

the same sequence of events for the same setup. This sequence should be machine

independent.

Having done all this the pandora object is defined and integrated and has a sam-

pling distribution that is ready to generate events. This is done by repeatedly calling

the getEvent() function which will return an LEvent object each time it is called.


The LEvent object stores all of the data for the initial and final particles and all in-

termediate particles. The information included in the object can be accessed through

a number of member functions which are listed in Table 6.3. These can be used to

directly build up histograms and plots, but they will not store the event as a whole.

The most useful way to store the events is using the eventRecord class to create a

.lhe file which stores the data according to the Les Houches Accord Event File con-

vention. The last section of the sample program does exactly that. The eventRecord

object is defined with the default constructor, which takes a string for the file name

and two integers as inputs. The first is an index variable in case several files are

use to store a single run. The number is appended to the string to create the file-

name, so in the example the output file will be eeWWwnu1.lhe. The last input defines

the number of different processes that contribute to the file. The next two function

calls are to inputbeaminfo() and inputprocessinfo() which output the beam and

process information to the .lhe file. The begin() function prepares the file to re-

ceieve event data, and then a for loop is defined to iterate through and record 10000

events into the file. The first if statement simply sends updates to the monitor so

the user knows how far along the simulation is. Then an event is generated through

getEvent() and written to the file in the LHA format by writeLHAformat(). The

last if statement simply outputs the first 10 events to the screen in a readable format

so the user can check that the events being generated seem to make sense. Once all

events are recorded the finish() function closes the .lhe file. The return 0 state-

ment is required by the C++ compiler to know that the function ran without any

errors.

With this completed C++ file and executable can be compiled to run the defined

simulation and create the output files. The simplest way to do this is to place the

default makefile in the same directory as your code file example.cpp and call make

example.ex. This will compile the code and all of the files defining the needed classes

and constructing the executable, sample.ex.


Function Returns:n() number of particles in the event

id(int m) ID valueparent(int m) index of the parent (0 if top-level)final(int m) 1 if final, 2 in intermediate, -1 if initial

helicity(int m) +1 or -1 for massless partonscolor(int m) 0 if singlet, color string index if colored

anticolor(int m) 0 if singlet, anticolor string index if coloredE(int m) energyp(int m) magnitude of momentum

cost(int m) cos θsint(int m) sin θ

cosphi(int m) cosφsinphi(int m) sinφphi(int m) φ (0-2π)pt(int m) transverse momentumeta(int m) pseudo-rapidity

dotproduct(int m, int n) pm · pnmass(int m, int n) invariant mass of pm + pncost(int m, int n) relative cos θ

Table 6.3: LEvent member functions. The integers m and n refer to the index numberin the LEvent.

Chapter 7

Catalog of Implemented New

Physics

Using the tools and techniques discussed in this section, we have implemented several

models into pandora. The first model implemented is the Standard Model, which is

not a new physics model but is the base on which all new physics must be built. In

addition we have implemented the most commonly discussed new physics model, the

MSSM. Other models have begun to be implemented although we will not discuss

them all here.

7.1 Standard Model

The Standard Model is a fairly simple model to implement in pandora. The masses

of the SM particles are well known, except for the Higgs boson, so there is no mass

spectrum to calculate. Due to the energies of the hard processes involved, we treat

all of the SM fermions, except the top quark, as massless partons. After this ap-

proximation the vast majority of SM processes become 2 → 2 processes to massless

partons with no decays. The W and Z bosons are massive and unstable but have

a relatively simple spectrum of decays to massless partons that can be treated in a

single decaytotwozz class. The top quark is also unstable but only has one decay

channel to a bottom quark and a W boson. The only SM particle that has multiple

113

CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 114

decay channels that requires a complexdecay class is the Higgs boson. Since the only

user defined parameter in the SM is the Higgs mass, the only input variables on any

of the processes or decays is the Higgs mass, and the charge for any W boson or top

quark decays.

7.1.1 Standard Model Processes

There are two main sets of processes in pandora for the Standard Model, processes

for electron and photon beams and processes for proton beams. The first will depend

mostly on QED interactions while the second will include QED processes but be

dominated by QCD for quark final states. In both cases all of the considered processes

are 2 → 2 processes most of which have 2 massless partons in the final state. Rather

than defining a class for each massless final state, these will be collected into one

or two general classes, with the final states being selected by the randomly selected

final variable weighted according to their contribution to the cross-section.

Looking at the electron/photon beam processes first, the general class for all

massless final state processes is eetopairs. This is defined in eetopairs.h and

eetopairs.cpp files. The class can be initialized without any input parameters, al-

though there is an option to initialize with some kinematic cuts applied as well. The

class covers initial states with any pair of e−, e+, and γ , and final states with any

combination of massless final states. In practice, the SM only allows t and u-channel

Møller scattering processes for e−e− or e+e+ beams, and Compton scattering for

mixed eγ beams. The other initial states of e−e+ and γγ allow the pair production

of any massless partons, through s-channel annihalation and t/u-channel production

respectively, except in the case of e−e+ → e−e+ where the Bhaba scattering in-

cludes an additional scattering term. While all of these processes are included in the

eetopairs class and are turned on by default, the class inherits the makeactive()

series of functions described in Table 6.2 which can turn off any undesired initial

states. Additionally, the produceOnly() function is provided to allow the user to

select the specific processes desired for the simulation, based on the set of Only con-

stant variables defined in hepdata.h. It only used the e−e+ and γγ initial states and


the variaous options for the produceOnly() function are listed in Table 7.1.

produceOnly() option Included ProcessesggOnly e−e+ → γγeOnly e−e+ → e−e+, γγ → e−e+

muOnly e−e+ → µ−µ+, and γγ → µ−µ+

tauOnly e−e+ → τ−τ+, and γγ → τ−τ+

mutauOnly muOnly and tauOnly

leptonsOnly eOnly, muOnly and tauOnly

nuOnly or invisibleOnly e−e+ → νeνe, e−e+ → νµνµ,

and e−e+ → ντντlightquarksOnly e−e+ → dd, γγ → dd

e−e+ → uu, γγ → uue−e+ → ss, and γγ → ss

cOnly e−e+ → cc and γγ → cc

bOnly e−e+ → bb, and γγ → bbheavyquarksOnly or bcOnly cOnly and bOnly

quarksOnly lightquarksOnly and heavyquarksOnly

allStates all e−e+ and γγ initial state processes

Table 7.1: The produceOnly() function in eetopairs

In addition to the massless production amplitudes, there are several SM process

resulting in massive unstable particles. All of these are 2 → 2 processes which in-

clude the t quark, the Higgs, the W or Z bosons in their final states. Since these

involve unstable massive particles that must be treated by specific decay classes, each

unique final state requires its own process class. The first set of these are contained in

eetoWZ.h which contains classes handling processes that produce W and Z bosons.

The eetoZ class inherits the kinematics of twototwomz and handles single Z pro-

duction, specifically e−e+ → Zγ and eγ → Ze. It can be initialized without any

parameters or with kinematic cuts and since the specific final massless parton is fixed

by the initial beam partons the user can select between particular classes with the

makeactive() functions from Table 6.2. Similarly, the eetoW class handles single W

production through eγ → Wνe. The class handles both W+ and W− production

and requires the user to input desired charge of the boson, which fixes both the final

and initial state, as well as any desired kinematic cuts. Double boson production is


handled by the classes eetoZZ, for e−e+ → ZZ, and eetoWW, for e−e+ → W−W+,

γγ → W−W+ and e−e− → W−W−, both of which inherit the kinematics of the

twototwomm class. As above the two W pair production processes can be isolated by

selecting the particular initial state. In all of these classes new Zdecay or Wdecay ob-

jects are initialized and linked using the installdecay() function to properly treat

the decays of the massive unstable bosons.

In addition to the massive gauge final states, there are two more massive unstable

particles that can be produced in the SM, the t quark and the Higgs boson. The classes

covering the production of these processes are eetoZHiggs and eetottbar are simply

implementations of the eetoVS and eetoFF classes with the SM propagators added,

a Z boson for the Higgs and a Z and a photon for the top quark.

Since the Higgs is such a focus of next generation collider particle searches we

implemented some additional processes that go beyond the basic tree level amplitudes.

The most basic of these is a single Higgs production channel γγ → H. This 2 → 1

process implements a loop order interaction of the Higgs with the photon, and then

decays it through a specialized Higgs decay class that implements several higher order

contributions to the decay widths.

In addition to these classes for electron and photon beams, there is a similar set

of classes for proton beams. As above, the many 2 → 2 processes to massless final

partons are grouped together. While for electron beams only one class covered all

massless final states, for proton beams there are two distinct types of processes leading

us to create two classes. Proton beam processes that end in massless leptons and pho-

tons are governed by electroweak physics and are handled by the class pptoll, which

is analogous to the eetopairs class, with similar contributing diagrams, although

the proton initial states allow for some W boson propagators as well. Similarly the

processes to W and Z and Higgs bosons are analogous to the electron beam classes

although there are again some new diagrams with s-channel W bosons. The biggest

difference for the proton classes is the bookkeeping necessary due to the large number

of possible initial states.

The processes that end in massless quarks and gluons are require a completely

different treatment since they are dominated by QCD physics. These process are


implemented in the qqtoqq class, and only the QCD interactions are considered.

For most initial quark states, there is simply a t-channel scattering amplitude, but

if there are identical particles involved there may be multiple color structures for

a single helicity state. This requires careful consideration of the color interference

term as described in Section 3.4. This class is discussed in more detail as one of the

examples in Section 8.2.

The process qq → tt and gg → tt processes are also dominated by QCD interac-

tions. For the quark initial state there is only one s-channel diagram through a gluon

that can be straightforwardly implemented with the correct color fact multiplied on.

For the gluon initial state there is a t-channel and a u channel diagram that will have

color interference between them. The treatment of the interference is analogous to

the four quark diagrams in the pptopp class, and is easily corrected for.

7.1.2 SM Decays

There are four particles of the SM that must be treated as massive unstable particles in

pandora, the t quark and the W , Z, and Higgs bosons. The first three have relatively

straightforward decay patterns each of which can be handles by a single class, all of

which are defined in the file WZtdecay.h. The Higgs boson includes several distinct

decay channels to massive particles, requiring each to be treated separately, with an

overall complexdecay class to link them together. Additionally, we break convention

when dealing with the Higgs boson decay, including a few higher order corrections

and loop processes. Several of these become extremely important phenomenolgically

for certain types of Higgs searches, neccesitating the special handling. All of this is

defined in the Higgsdecay file.

Looking first to the W boson decay, it has several decay channels all of which in-

volve massless partons, so we define the Wdecay class as a daughter of decaytotwozz,

inheriting its kinematic structure. The SM W+ and W− boson decays are CP sym-

metric, so they can be treated similarly with a switch of particles to anti-particles

and a helicity flip of all particles to change between them. The constructor Wdecay()

takes the charge of the W boson as an input and applies to appropriate changes if


needed. Both bosons have nine decay channels, three to lepton, neutrino pairs and

six to combinations of CKM mixed up-type and down-type quark pairs, excluding the

top quark since it is more massive than the W boson. By default, all decay channels

are open, but the onlyDecay function is provided to select particular decay channels

based on the Only variables defined in hepdata.h.

The Z boson decay is similar to the W boson decay, with all of its decay channels

resulting in massless partons. Inheriting the kinematics of decaytotwozz, and with

its propreties fixed by the SM the Zdecay requires no input for its constructor. It

has 19 possible decay channels, 9 lepton channels and 10 quark channels, one for each

particle/anti-particles pair of massless SM partons, treating the left and right handed

versions of each particle separately and excluding the more massive t quark. As with

the W boson decay the onlyDecay function can be used to choose particular channels

of the decay to be included.

The final class defined in WZtdecay.h is the t quark decay class tdecay. This

class handles both t and t decays and the constructor takes an integer as input, with

1 producing a t decay and −1 producing a t decay. Both the decays involve only one

possible channel, to W+b for the t and W−b for the t, but these involve the massive W

boson which will decay as well. Inheriting from the decaytotwomz class the tdecay

class declares a new Wdecay object with the appropriate charge and links to it using

the installDecay() function. Since the final state is fixed by particle/anti-particle

choice there is no particular onlyDecay() function defined for the t quark decay, but

the version inherited from the decay class will pass the Only variable down to the

Wdecay class to select the appropriate decay channels of the W boson.

The final massive SM particle decay to be treated is the Higgs boson decay. The

Higgsdecay.h file contains definitions for several decay classes, one for each distinct

massive final state, another to treat the massless final states, and a complexdecay

class that will choose between them. As described above the Higgs decay is treated

slightly differently than most particles, with several higher order processes contribut-

ing as well as treatment for the possibility of off-shell W and Z bosons. As a result of

this there are some additional non-standard kinematics that are implemented specif-

ically for these cases.


7.2 SUSY

Supersymmetry (SUSY) is one of the more prominent solutions proposed to the hi-

erarchy problem of the Higgs mass in the Standard Model. This symmetry relating

fermions and bosons produces new diagrams contributing to scalar mass terms which

cancel the divergent diagrams that are the source of the problem. The simplest pro-

posed extension of the Standard Model that implements this supersymmetry is the

Minimal Supersymmetric Standard Model. Since this is one of the most studied new

physics models, we have implemented it into pandora.

The MSSM has an N = 1 supersymmetry which is a symmetry relating every

fermion state with a boson state, and every boson with a fermion. Thus every Stan-

dard Model particle gains a superpartner particle that differs in spin from the original

by 1/2. These particle and superpartner particle pairs form a supermultiplet which

can be one of two types, chiral or gauge. Chiral supermultiplets contain a single Weyl

fermion and a complex scalar, while gauge supermultiplets contain a vector boson

and a Weyl fermion, both in the adjoint representation of the gauge group.

Since all of the SM fermions are chiral fermions, they must be included into chiral

multiplets, with complex scalar superpartners that share the same gauge charges.

The naming convention for the scalar superpartners is to add an ”s” to the name, so

the superpartner of the electron is called the selectron,. We denote the superpartners

of e and e as e and e, respectively. There is similar common notation that refers to

the eL and eR and their superpartners eL and eR. The L and R do not refer to the

spin of the scalars, which are spin 0, but to the particular Weyl fermion that they are

related to. Then e = e†R and e = e∗R.

The Higgs scalar must also be part of a chiral supermultiplet, but in order to

preserve anomaly cancellation, the MSSM actually requires two SU(2)L doublet com-

plex scalar field with opposite hypercharges Y = ±1/2. These will be labeled Hu for

Y = +1/2 and Hd for Y = −1/2. The SM Higgs boson, h0, is a mass eigenstate of

the CP-even neutral portions of each doublet. The fermionic superparters to these

scalars follow a naming convention of adding ”ino” to the end, so they are Higgsinos

and are denoted by the same tilde notation where Hu is the superpartner of Hu.


The gauge bosons must fall into gauge supermultiplets, and gain fermionic super-

partners with the same gauge charges. The same ”ino” naming convention applies

and the superpartners are generally referred to as gauginos. The superpartner of the

B0 is referred to as the bino and denoted B0. This completes the definition of the

gauge eigenstates of the MSSM, with the entire particle content listed in Table 7.2.

R parity +1 R parity -1

(uL dL) u†R d†R (uL dL) u∗R d∗R(cL sL) c†R s†R (cL sL) c∗R s∗R(tL bL) t†R b†R (tL bL) t∗R b∗R(νe eL) e†R (νe eL) e∗R(νµ µL) µ†R (νµ µL) µ∗R(ντ τL) τ †R (ντ τL) τ ∗Rg W± W 0 B0 g W± W 0 B0

(H+u H0

u) (H0d H−

d ) (H+u H0

u) (H0d H−

d )

Table 7.2: MSSM particles

The interactions of these particles are defined by the supersymmetric extension

of the SM Lagrangian. The SM gauge bosons couple to the fermions through the

covariant derivative

Dµ = ∂µ − i

(e

cwB0µY +

e

swW 0µI

3 +e√2sw

(W+µ I

+ +W−µ I

−) + gsgaµta

). (7.1)

This covariant derivative now acts not only on the SM fermions but on the entire

chiral multiplets. Replacing the ordinary derivatives of the free chiral Lagrangians

with the covariant derivatives gives the MSSM gauge interactions

∆L = −Dµφ∗iDµφi − iψ†iσµDµψi, (7.2)

with φi being the complex scalar and φi the Weyl fermion portions of a chiral mul-

tiplet. To complete the supersymmetric Lagrangian there must also be analogous


terms involving the gauginos, specifically

∆L =−√

2φ∗(e

cwB0TY +

e

swW 0T I3 +

e√2sw

(W+T I+ + W−T I−) + gsgaT ta

)cψ

+√

2ψ†c

(e

cwB0∗Y +

e

swW 0∗I3 +

e√2sw

(W+∗I− + W−∗I+) + gsga∗ta)φ ,

(7.3)

with φ and ψ being members of the same chiral multiplet.

The supersymmetric extension of the SM Yukawa couplings is produced through

the superpotential term. Specifically the MSSM superpotential is

W =− yiju uiHuαεαβQjβ + yijd diHdαεαβQjβ

+ yije eiHdαεαβLjβ − µHdαεαβHuβ. (7.4)

The contribution of the superpotential to the Yukawa coupling in the Lagrangian is

∆L = −1

2ψTi cψj

∂2W

∂φi∂φj+ h.c. , (7.5)

where α and β are the SU(2) indices and ε12 = +1. If the ya are the standard

Yukawa couplings, this will recreate the SM Yukawa terms plus give related interac-

tions including the sfermions and Higgsinos. There are other renormalizable terms

that could be added to the superpotential W that do not violate gauge invariance

but will induce baryon and lepton number violating terms. In general these terms

would be disastrous, inducing proton decay and lepton flavor-changing reactions at

much to large a rate. The most common solution to avoiding these terms is to add

a new symmetry to the MSSM known as R-parity. This is an extension of a simple

(B − L) matter parity that assigns PR = +1 to all SM particles and Higgs bosons

and PR = −1 to all of their superpartners, as described in Table 7.2. In addition to

removing the dangerous superpotential terms, R-parity forces all interaction vertices

of the MSSM to have an even number of PR = −1 particles. This means that it is

impossible to write a decay term for the lightest of these particles, referred to as the

lightest supersymmetric particle (LSP). If this absolutely stable particle is electrically


neutral it makes a good candidate to explain non-baryonic dark matter. The inter-

actions just described all preserve supersymmetry, and in general any SM interaction

will have analogous MSSM interactions where any two SM particles are replaced by

their superpartners and the same coupling up to a possible factor of√

2.

If this supersymmetry between each SM particle and its superpartner were exact,

then there would be scalars of equal mass to every SM fermion and fermions with

equal mass to each gauge boson, which would have been easily detectable. Since

these new particles have not been observed supersymmetry must be broken at some

higher scale, leaving the superpartners with masses larger than we have been able

to observe, but not so large as to break the divergence cancellation that solves the

hierarchy problem. There are a variety of theories for an exact method for breaking

supersymmetry. Here, we will parametrize the most general set of soft supersymmetry

breaking terms as:

LMSSMsoft =− 1

2

(M3gg +M2WW +M1BB

)+ h.c.

−(uauQHu − dadQHd − eaeQHd)

)+ h.c.

− Q†m2QQ− L†m2

LL− um2uu

† − dm2dd†− em2

e e†

−m2HuH∗uHu −m2

HdH∗dHd − (bHuHd + h.c.) (7.6)

In addition to simply giving the sparticles larger masses, these terms will in-

duce mass mixings that will result in mass eigenstates that are superpositions of the

gauge eigenstates. While the most general supersymmetry breaking terms will induce

sfermion mass mixing, some common assumptions we discuss below will restrict this

mixing to the third generation. Rather than referring to the gauge eigenstates, for ex-

ample tL and tR, we will refer to the mass eigenstates, t1 and t2, with index 1 referring

to the lighter eigenstate. The fermionic superpartners, the gauginos and Higgsinos,

will all mix resulting in mass eigenstates referred to as neutralinos and charginos.

The neutralinos Ni are superpositions of the B0, W 0, H0u, and H0, d, with the indices,

i = 1, 2, 3, 4, applied in ascending order. The charginos C+i are superpositions of W+

and H+u , and C−

i are superpositions of W− and H−d , with the indices i = 1, 2 applied


in ascending order as well. In more phenomenologically viable MSSM models the N1

is the LSP.

The SM fermions are free from additional mass mixing terms but the new Higgs

scalar sector is not. The two complex scalar doublets Hu = (H+u , H

0u) and Hd =

(H−d , H

0d) can be considered as eight real scalars. Three of these will be the Goldstone

bosons of electroweak symmetry breaking and the mass eigenstates of the other five

are referred to as H+ and its conjugate H−, the CP-odd A0, and the CP-even H0

and h0. The lighter of these last two, h0, will often be very similar to a SM Higgs.

The mass mixing places an upper bound on the mass squared of this h0 particle

mh0 < m2Z cos2 2β, (7.7)

where tan β is the ration of the vevs of the two doublets vu/vd. This bound, which

would make this lightest Higgs scalar accessible to past experiments can be lifted

somewhat by radiative corrections. We will generally include these corrections by

hand, by making mh0 an input parameter.

While most of the parameters for the supersymmetry preserving portion of the

MSSM Lagrangian are derived from the SM, the supersymmetry breaking terms add

a large number of additional parameters. In total there are 105 new parameters in

the most general expression of the MSSM. These parameters influence the masses

and couplings of all the new particles we plan to simulate in pandora requiring a

consistent method for keeping track of them.

7.2.1 SUSYspectrum

Before we can discuss the processes and decays of the new MSSM particles we must

first define the masses and couplings of those particles. In order to do this we have

defined a new class SUSYspectrum which will store all of the mass and parameter data

for a particular point in MSSM parameter space, as well as functions to calculate and

use those parameters [20, 25, 26].

The most basic way to define the masses and couplings is to explicitly derive them

from the parameters of the particular MSSM point we are considering. While the


most general form of the MSSM has 105 free parameters, in general these parameters

will introduce flavor changing terms and CP violating terms that have already been

ruled out by experiment. Along these lines we make a few common well motivated

assumptions to reduce the number of parameters to a more manageable number. First

we assume that the squark and slepton mass matrices are flavor diagonal,

m2Q ≈

m2Qu 0 0

0 m2Qc 0

0 0 m2Qt

;m2L ≈

m2Le 0 0

0 m2Lµ 0

0 0 m2Lτ

;m2u ≈

m2u 0 0

0 m2c 0

0 0 m2t

;

m2d≈

m2d

0 0

0 m2s 0

0 0 m2b

;m2e ≈

m2e 0 0

0 m2µ 0

0 0 m2τ

;

(7.8)

Second we assume that the trilinear scalar couplings are proportional to the corre-

sponding Yukawa coupling matrix, essentially restricting their effects to the third

generation,

au = Auyu ≈

0 0 0

0 0 0

0 0 at

; ad = Adyd ≈

0 0 0

0 0 0

0 0 ab

; ae = Aeye ≈

0 0 0

0 0 0

0 0 aτ

;

(7.9)

While some types of CP-violation have been ruled out by experiment, in general some

CP-violation could be allowed. The SUSYspectrum class assumes that CP-violation

will be restricted to the complex Af terms terms in the sfermion sector, the Mi terms

in the gaugino sector, and the µ term in the Higgs sector. In pandora, all of these

inputs can be complex, while the rest must be real numbers.

We also choose not to parametrize the Higgs sector in terms of the Lagrangian

couplings in (7.6) but in terms of the lightest CP-even h0 mass, the mass of the CP-

odd neutral scalar A0, the Higgs vev mixing angle tan β, and the complex phase µ.

This is mainly due to the fact that we want to include possible radiative corrections

to mh0 to push back the upper bound (7.7). The easiest way to do this is to simply


MSSM parameter SUSYspectrum variableM3,M2,M1 complex m3, m2, m1

m2Qu,m

2Qc,m

2Qt double msqQu, msqQc, msqQt

m2u,m

2c ,m

2t

double msquR, msqcR, msqtR

m2d,m2

s,m2b

double msqdR, msqsR, msqbR

m2Le,m

2Lµ,m

2Lτ double msqLe, msqLmu, msqLtau

m2e,m

2µ,m

2τ double msqeR, msqmuR, msqtauR

at, ab, aτ complex At, Ab, Atau

mh0 ,mA0 , tan β double mh, mA, tanbeta

µ complex mu

Table 7.3: SUSYspectrum input parameters

make mh0 an input. This gives us a set of 25 parameters, 7 complex numbers and

18 real numbers listed in Table 7.3, to determine the particular MSSM point we are

interested in.

Once the user has input these parameters, it is necessary to calculate the fill()

function must be called to calculate the various eigenstate masses and couplings

that will be used to simulate the phenomenology of the particular point in MSSM

space. To carry out this calculation the user should call the fill() method of the

SUSYspectrum classes. The mass eigenstate particles that derive from mixing the

gauge eigenstates are listed in Table 7.4 along with the SUSYspectrum variable names.

For ease of use, the masses of the neutralinos and charginos are included both by

individual variables and in an indexed vector. Their mixing angles are stored in the Vz,

Vp, and Vm matrices, for neutralino and positive and negative chargino, respectively.

The sfermion masses are included in individual variables and an auxiliary function

sfmass() will return the appropriate particle mass given the PDG ID number, or

corresponding constant variable name. Similarly, the mixing angles are stored in

specific matrices and are also accessible with an auxiliary function Vsf(). Once the

parameters are input and the full spectrum of masses in calculated with the fill()

function, the writeParameters() and writeSpectrum() functions will print out the

input parameters and the mass eigenstate spectrum respectively.

The couplings calculated by SUSYspectrum are listed in Tables 7.5-7.9 with the

vertex conventions shown in Figure 7.1. In general couplings involving neutralinos or


Gauge Eigenstate Mass Eigenstates Mixing variableτL τR τ1 τ2 Vtau[a][b]

bL bR b1 b2 Vb[a][b]

tL tR t1 t2 Vt[a][b]

B0 W 0 H0u H0

d N1 N2 N3 N4 Vz[a][b]

W+ H+u C+

1 C+2 Vp[a][b]

W− H−d C−

1 C−2 Vm[a][b]

Table 7.4: MSSM particle mass eigenstates. There is mixing in the scalar Higgs sectoras well, but we use the mass eigenstates and mixings as inputs.

V F1 F2 SUSYspectrum coupling

Z Ni Nj GNZ[i][j]

γ C+k C+

l GCpA[k][l]

Z C+k C+

l GCpZ[k][l]

γ C−k C−

l GCmA[k][l]

Z C−k C−

l GCmZ[k][l]

W+ C−k Ni GNCWp[i][k]

W− C+k Ni GNCWm[i][k]

W+ Ni C−k conj(GNCWp[i][k])

W− Ni C+k conj(GNCWm[i][k])

Table 7.5: VFF couplings

charginos are stored in vectors indexed by the mass order of the gaugino. Addition-

ally, most couplings involving sfermions have an auxiliary function provided that will

return the appropriate coupling or vector of couplings based on the PDG ID of the

sfermion involved.

While this specific set of input parameters is a fairly general way to express the par-

ticular point in MSSM space we are interested in, there are other ways of parametriz-

ing the space, usually using additional sets of assumptions. One simple model that

adds additional assumptions, such as generation independent masses, is provided in

the generalsfermions() function.

Additionally there are specific models of supersymmetry breaking that usually


%VS1

S2

= ieGV S1S2(pS1 − pS2)mεm(V )

(a)

&S1

S2

S3

= ieGS1S2S3

(b)'VF1

F2

= ieGV F1F2F†1σ

mF2εm(V )

(c)

(SF1

F2

= ieGSF1F2F†1 c F2

(d))SV1

V2

= ieGSV1V2gmnεm(V1)εn(V2)

(e)

Figure 7.1: MSSM Coupling diagrams. For scalars, all momenta p are outgoing. Forvectors, ε∗ should be used for final state vectors. For fermions, Fi should be replacedby the appropriate u or v spinor.

V S1 S2 SUSYspectrum coupling

γ f f ∗ Qf

Z f f ∗ (I3f − sin2 θWQf )/(sin θW cos θW )

W+ fu f ∗d 1/√

2 sin θWγ fa f ∗b Qfδab (fa 3rd gen. only)

Z fa f ∗b sw/cwQfδab− 1/(2*sw*cw)*

conj(Vtau[1][a])*Vtau[1][b]

W+ ντ τ ∗a 1/(sqrt(2)*sw)Vtau[1][a]

W+ ta b∗a 1/(sqrt(2)*sw)conj(Vt[1][a])Vb[1][b]

γ H+ H− GHpg

Z A h,H GAhZ, GAHZZ H+ H− GHpZ

W+ H+ h,H,A GHphW, GHpHW, GHpAW

Table 7.6: VSS couplings


(S, F1) F2 SUSYspectrum coupling

(fL, fL) Ni GsfN(sfID)[i]

(fR, fL) Ni GsfbN(sfID)[i]

(fuL, fdL) C+k GsfCp(sfID)[i]

(fdL, fuL) C−k GsfCm(sfID)[i]

Table 7.7: SFF couplings. fu refers to up type quarks or neutrinos. fd refers to downtype quarks an leptons.

S1 S2 S3 SUSYspectrum couplingh h h Ghhh

h h H GhhH

h H H GhHH

H H H GHHH

h A A GhAA

H A A GHAA

H+ H− h,H,A GHph,GHpH,GhpA

Table 7.8: SSS couplings

S V1 V2 SUSYspectrum couplingh,H Z Z GZZh,GZZH

h,H W W GWWh,GWWH

Table 7.9: SVV couplings


involve a hidden sector of new particles that induce a specific pattern of soft SUSY-

breaking terms for the MSSM. Two common models for this process are gravity-

mediated and gauge-mediated SUSY breaking. Gravity-mediated SUSY-breaking

models are those where the hidden sector is connected to the visible sector only

through gravitational interactions that are suppressed by the Planck mass [28]. In its

simplest form, known as minimal super gravity (mSUGRA), this model greatly simpli-

fies the low energy SUSY-breaking Lagrangian, reducing the number of parameters

from 105 to just four. Methods for implementing this mSUGRA form of gravity-

mediation are included in the gravitymediation() and gravitymediationwEWSB()

functions. These functions make slightly different assumptions about whether the

inputs are high scale parameters that need to have RG running applied or low scale

input parameters, with the details discussed in the SUSYspectrum.h header file. With

all of these functions, the user must be sure to call the fill() function to translate

the initial parameters into the masses and couplings needed for pandora.

Gauge-mediated SUSY breaking is a model that has the dominant interaction be-

tween the hidden and visible sectors through gauge bosons and their superpartners.

In general the models include new chiral superfields that couple directly to the hid-

den SUSY-breaking sector, and interact indirectly with the visible sector through the

standard MSSM gauge bosons and gauginos. Like with mSUGRA, assuming the sim-

plest forms of these models puts strong constraints on the SUSY-breaking Lagrangian,

greatly reducing the number of free parameters. We have included a few methods

for implementing gauge mediated SUSY-breaking. First, simpleguagemediation()

implements the model discusses in Dine et al. [29]. The gaugemediation() function

adds RG running to improve the model and the gaugemediationwEWSB() function

applies EWSB conditions on the mA parameter that was user defined in the first two.

As above, the user must be sure to call the fill() function once the particular gauge-

mediated model is chosen. These attempts at develop models for SUSY breaking help

to motivate constraints on the number of free parameters in the MSSM making it more

manageable, but they add additional assumptions that must be considered carefully,

and may hide interesting regions of the MSSM parameter space.

There are a variety of tools and programs available to calculate SUSY spectra


based on various assumptions and SUSY-breaking models beyond the few we have im-

plemented directly. One commonly used tool is the ISAJET/ISASUSY program [27].

To facilitate the wide variety of models it includes and for reference and comparison,

we have provided methods for directly implementing an ISAJET model. Specifically,

fromISAJET() takes the tree level data blocks from the ISAJET program as inputs

and, once fill() is called, will produce a spectrum very similar to the ISAJET

spectrum. Since the basic SUSYspectrum methods differ slightly from the ISAJET

program, the exactISAJET() function is provided. It takes the exact masses and

mixings from ISAJET spectrum as inputs to fill the SUSYspectrum variables. The

user should not call the fill() function in this case, since it will ruin the exact

correlation.

All of these tools are attempts to get a handle on the large number of free pa-

rameters in the most general version of the MSSM. Since the parameter space is so

large the particle physics community has found it advantageous to define a number of

benchmark points in the parameter space. These benchmarks allow for comparison of

simulation and analysis techniques, and were chosen to try and represent a wide range

of possible phenomenology. We have implemented several of these standard bench-

marks for ease of use in the file SUSYmodels.h. Two important sets of benchmarks are

the Snowmass (SPS) points [30] and the LCC points [31]. These are implemented in

the fromSnowmass() function for Snowmass (SPS1, SPS4, SPS5, SPS7, and SPS8),

and the fromLCC() and exactLCC() for LCC (LCC1, LCC2, LCC3, and LCC4).

These are implemented based on the fromISAJET() function (exactISAJET() for

exactLCC()) but the fill() function has already been called where appropriate, so

the user should not call it. These benchmarks provide a base set of phenomenology

for the MSSM and provide useful tools for comparison of programs and techniques,

but it is important to remember that the parameter space is extremely large and

cannot be completely described be a small number of points.

All of this discussion has been geared towards developing consistent MSSM models

for calculation and simulation, but it is not always easy to influence a particular

phenomenological feature by adjusting the parameters of one of the SUSY breaking

models or other functions with fixed assumptions. It is always possible to adjust


the model by directly declaring any of the masses or couplings in the SUSYspectrum

object if desired, even after a particular model has been calculated. The user must be

careful since this may introduce inconsistencies in the model. In general, if the user

wants fine control over a model, it is a good idea to pick one of the benchmarks or

generate ones with one of the provided functions and then adjust the general input

parameters by hand. It is important to call the fill() function after any changes to

keep the model consistent, being sure to pay attention to any error conditions that

are returned.

7.2.2 SUSY processes

Having constructed a particular MSSM mass spectrum and calculated the corre-

sponding couplings, we must use the results to calculate the cross-section of various

processes. Following the standard pandora conventions we focus on the main tree-

level processes, primarily 2 → 2 processes. We will treat processes involving electron

beams with e and γ initial states separately from processes from proton beams with

quark and gluon initial states. Since we are assuming R-parity in the MSSM, no new

particles can be singly produced, and in a 2 → 2 tree level process we must have two

MSSM particles in the final state. All of the new MSSM particles are massive and all,

except the LSP, are unstable. While the LSP is usually the lightest neutralino, there

are cases where it is the lightest sneutrino or even some other, electrically charged,

particle. While the neutralino LSP cases are seen as better motivated, than the other

cases, rather than restrict the choice we treat all massive MSSM particles as possibly

unstable particles, declaring a complexdecay class for each one. Whichever MSSM

particle ends up being lightest in the particular mass spectrum chosen will have no

open decay channels; it will fail every mass comparison, since there is no lighter new

particle to decay to. Thus it will only link to a nodecay class which will leave this

particle stable and appropriately handle the mass, ID and spin assignments. These

two facts, that any 2 → 2 tree level MSSM process must have 2 new particles in

the final state and that all new MSSM particles are massive and will be treated by

a distinct decay class, determine that all 2 → 2 MSSM processes in pandora are


subclasses of twototwomm.

All of the new processes are constructed using the eeto2types classes, eetoSS,

pptoFF, etc. Since the helicity structure of these processes has been calculated gener-

ally in those classes, as discussed in Section 6.2, we need only consider the properties

of the final state particles, and the properties of any propagators, and the couplings

between the propagators and the initial and final state particles. The first step is

to determine all of the contributing diagrams and the corresponding propagators.

Since each vertex must have an even number of supersymmetric particles contribut-

ing to it, any s-channel propagators must be SM particles or Higgs sector scalars,

and any t-channel or u-channel propagators must be superpartner particles. Once

these are determined the masses and couplings can simply be read off the appropriate

SUSYspectrum variables based on the conventions discussed in Section 7.2.1.

Most of the new process will be supersymmetric forms of the SM processes, with

the final state particles, and any t-channel or u-channel propagators, replaced with

their superpartners. The exception is additional processes for the expanded Higgs

sector such as the extension of the associated Z Higgs production through an s-

channel Z boson. The fact that the superpartners of the γ, Z, and neutral Higgs,

are all treated analogously as neutralinos limits the number of new process classes

required. Since we set up the SUSYspectrum class to store the masses and couplings of

the neutralinos and charginos in vectors and matrices indexed according to the mass

order, we can define processes generally and apply the specific coupling based on the

input values. Similarly, defining functions to select sfermion masses and couplings

based on the ID numbers means we can define classes for the sfermions generally, and

use the ID number to select the specific case. This is slightly more complicated for

the third generation sfermions since there is additional mass mixing to keep track of.

Turning to the specific process classes, we consider electron/photon classes first,

beginning with the eetoNN class. This class calculates processes with any combina-

tion of neutralinos in the final state meaning it covers the supersymmetric forms of

the SM processes eetoZZ, eetoZHiggs, and the Zγ final state part of eetoZ. Since

the neutralinos are fermions it inherits from the eetoFF class and we must provide

the contributing propagators. Since the neutralinos do not couple directly to the


*Z

e−

e+

Ni

Nj

(a)

+eL

e−

e+

Ni

Nj

(b)

,eR

e−

e+

Ni

Nj

(c)

Figure 7.2: Diagrams contributing to e−e+ → NiNj.

photon and since the final state is neutral we only need to consider the e−e+ initial

state. There are three distinct particles that must be included as propagators, the Z

boson in the s-channel, and the eL and eR in the t and u-channels. The actual decla-

ration for the eetoNN is very straightforward, with many of the detailed calculations

hidden in the eetoFF and SUSYspectrum classes. It requires only one function, the

constructor, which takes the index numbers of the two neutralinos as input, as well

as the SUSYspectrum object, storing mass spectrum and couplings. The constructor

first initializes the eetoFF class it inherits from, then installs two Ndecay objects to

treat the final state decays, and finally initializes the three propagator particles using

the addXprop() function. The masses of the final particles can be accessed using the

mN vector from SUSYspectrum and the masses of the selectron propagators can be

accesses using the sfmass() function using the constant variables selectronR and

selectronL as input. The couplings required can be found by looking at the tables in

Section 7.2.1 and are referenced using the GNZ matrix and the GsfN() function. The

most difficult aspect of the initialization is insuring the correct input variables are

used in the addXprop() functions, but carefully following the conventions in Sections

6.2 and 7.2.1 will insure the correct result.

The structure and construction of the eetoCC class, handling processes with pairs

of charginos in the final state, is similar. If the charginos have opposite charge and

different species we still only need to consider the e−e+ initial state and there are

only two propagators, the νe in the t and u-channels, and the s-channel Z boson as

above. If the two charginos are of the same species there are two additional processes,

an e−e+ initial state with an s-channel γ propagator and the γγ → C−i C

+i process


-C

γ

γ

C+

C−

(a)

.γ, Ze−

e+

C+

C−

(b)

/νe

e−

e+

C−

C+

(c)

Figure 7.3: Diagrams for e−e+ → C+i C

−j .

which has a Ci propagator in the t and u-channel. Finally if the two charginos have

the same charge then there is only one possible process with the corresponding like

charged electrons in the initial state and the νe propagator. As above there is only one

function associated the eetoCC class, the constructor. The constructor must check

the charge of the final state particles and apply the correct propagators, following

the conventions of Sections 6.2 and 7.2.1, as above. One thing to note is that the

propagator for the γγ → C−i C

+i is handled slightly differently since it is not an

ee initial state. Assuming that the photon only couples electromagnetically, the γ

coupling commutes with the mass matrix and so the index i is the same for both the

final charginos and hte chargino in the propagator. This is coded into eetoFF in its

γγ process automatically, and all we need to do to treat it properly is turn on the

γγ initial state using makeactive(). Since adding the s-channel γ propagator means

that the two final state particles are a charged particle/antiparticle pair coupling to

the photon, this means that the γγ → C−i C

+i should be open as well, and so the

function to add the s-channel γ opens the γγ channel as well.

The eetosfermions class is a supersymmetric version of the SM eetopairs class.

For general sfermion particle/antiparticle pairs, there are two s-channel e−e+ → f f ∗

processes, one with a γ propagator and one with a Z propagator. Additionally there is

a γγ → f f ∗ with a t-channel f propagator. This is fairly straightforward for the first

and second generation sfermions, simply using the corresponding SM couplings, but

since the third generation has some mass mixing between the left and right handed

superpartners, the mass mixing matrices must be used to get the correct couplings.

For final states involving pairs of selectrons, there are additional processes analogous


0γ, Ze−

e+

f

f ∗

(a)

1f

γ

γ

f

f ∗

(b)

2Ni

e−

e+

e

e′

(c)

Figure 7.4: Diagrams contributing to e−e+ → f f ′.

to the scattering amplitudes in eetopairs. If the selectrons are a particle/antiparticle

pair the above diagrams still hold, but in any case there are t-channel diagrams with

neutralino propagators. Since each neutralino is superpositions of the γ and the

Z superpartners, as well as the neutral Higgs boson superpartners, we must add

propagators for all four neutralinos. As above we only need to define the constructor

for the eetosfermions class which initializes the eetoSS class, installs the appropriate

sfdecay classes, and initialized the appropriate propagators.

There are also two mixed initial state processes, eγ → eN , which has s and t

channel contributions, and e−Lγ → νeC−, which only has a s-channel contribution.

These are treated in the classes eetoseN and eetosnueC respectively.

In addition to the processes to the sparticles, there are a few processes to the

new extended Higgs sector. Since the electron and photon are massless there is no

coupling directly to any of the Higgs particles so the only possible processes involve

s-channel annihilation through a Z boson propagator. The Z boson can couple to: a

CP-odd A scalar and either a H or h CP-even scalar; an H+, H− pair; or another Z

boson and either the H or h scalar. These are implemented in the classes eetoHpHhA

and eetoZHh.

The proton initial state processes to neutralinos and charginos are implemented

in the pptoNN and pptoCC classes, respectively, which are subclasses of the pptoFF

class. The set of diagrams for qq → NN is similar to that of the electron beam classes,

requiring a quark antiquark pair in the initial state. There is the Z boson s-channel

propagator, and a series of t and u-channel propagators, one for each squark. Assum-

ing two different chargino species, the qq′ → C+C− also a s-channel diagram with a


Z boson and t-channel and u-channel diagrams for each squark. There is the added

possibility of mixed quark initial states since the wino contribution to the chargino

couples to quarks with the CKM mass mixing. If the charginos have the same species

then there is the added s-channel diagram through a photon. There is an additional

set of processes to the electroweak gauginos of the form ud→ C+N involving all com-

binations of left-handed up-type and down-type quarks. It has contributions from an

s-channel diagram through a W boson and t and u-channel diagrams with squark

propagators.

We treat the sleptons and squarks differently, since the squark interactions are

dominated by the larger QCD interactions. The two possible types of slepton pro-

cesses, qq′ → ll∗ and qq′ → lνl, are implemented by theqqtosleptons class. The two

processes both have one s-channel propagator, a Z-boson for the first and a W -boson

for the second.

The squark process qq′ → q′′q′′′ is implemented in qqtosquarks which is a su-

persymmetric version of the four quark and the gg → qq∗ portion of qqtoqq. All of

the s-channel diagrams will still have a gluon propagator, while the t and u-channel

diagrams will now have gluino propagators. The color structures and color factors of

the SM diagram and its supersymmetric version will be the same, so the same color

interference calculation can be used just replacing the correct helicity amplitudes.

The color interference is not handled correctly by the helicity level class pptoSS we

do not use it in constructing the qqtosquarks class. There is the related qqtosgsg

class which implements the qq → gg and gg → gg processes, and the qqtosqsg class

which implements the qg → qg. These implement the other supersymmetric versions

of the other portions of qqtoqq. Again we can translate the color structures, color

terms and color interference from the SM calculation, replacing the correct MSSM

helicity amplitudes.

Finally, we consider the proton beam processes to the expanded Higgs sector.

First there are proton beam versions of the s-channel diagrams through a Z boson

which will have the same structure as the electron beam versions. Additionally there

are s-channel processes through a W boson that can result in a charged Higgs boson

or final state W boson and one of the neutral Higgs bosons. These are implemented


in the qqtoHpHha, qqtoZHh, and qqtoWHh.

7.2.3 SUSY decays

The actual set open decay channels for a given sparticle can vary greatly depending

on the particular mass spectrum being used. To accommodate this we implement

every possible 2-body decay channel and also a small set of 3-body channels, and

apply mass checks on each one to make sure they are open for the current spectrum.

Because of R-parity, every sparticle that can decay must decay into one other sparticle

and one or two SM particles. Since we are treating the LSP as a massive particle

and assigning it a nodecay class, all of the individual MSSM decay channels will be

subclasses of decaytotwomm, decaytotwomz, or decaytothreemzz for the three body

decays.

We implement four types of sfermion decay channels, those involving neutralinos,

those involving charginos, those involving gluinos, and those to another sfermion

and a W . The first three are implemented in the sftoNsfdecay, sftofdecay and

sftosgfdecay classes. Each is a subclass of StoFFmzdecay and takes the sfermion

ID and the gaugino index as input and passes along the appropriate couplings based

on the functions implemented in SUSYspectrum. There are specialized versions of

all of these for the cases where the fermion is a top quark, since this requires a

subclass of StoFFmmdecay instead. The last type of sfermion decay are those of left

handed superpartners to a W and the other sfermion in its doublet. These rarely

occur because the mass splitting between the sfermions is usually to small, but are

implemented in the sftosfWdecay class, a subclass of StoSVmmdecay. All of these

are collected in a single complexdecay class sfdecay. This class simply takes the

sfermion ID and the SUSYspectrum object as inputs and performs all the necessary

mass checks, also being sure to include the top quark versions of the classes where

necessary.

The decays of the gauginos are more complicated. The decay of the gluino is

simplest since it must interact through QCD, and the only possible decays are to

squark quark pairs. The decays of the Chargino and Neutralino, in addition to decays


to sfermion fermion pairs, must also include possible decays to the other Charginos

or Neutralinos, along with either a vector boson or Higgs scalar. The individual

decay channels are implemented in classes such as Ndecaytofsf and CdecaytoNW.

The overall classes for these decays Ndecay, Cdecay and sgdecay iterate through

all possible decay channels, checking the mass to see which are open, and linking to

the open decay channels where appropriate. The specific neutralino or chargino being

decayed are references by the standard index convention. In most phenomenologically

viable cases the lightest N1 is the LSP and is stable, but it is still assigned an Ndecay

class. In this case every mass check would fail because there is no lighter sparticle to

decay into, so the class would simply link to a nodecay class which will contribute

the appropriate mass for kinematics and pass along the correct ID value for event

construction.

Finally we must consider the decays of the newly expanded Higgs sector. As

described in Section 6.7 the neutral Higgs bosons are subclasses of the general two

Higgs doublet class, which is itself a subclass of the SM Higgs. Similarly the decay of

the charged SUSY Higgs is a subclass of the charged Higgs of the two Higgs doublet

model. In order to treat the decays of these particles to the SM particles, it is simply

necessary to pass along the correct coupling values to the parent class. In addition

there is the possibility of decays of these Higgs particles to sparticles. Since the Higgs

sector id R-parity even, any decays to sparticles must involved two sparticles. Thus

the possible decays of the neutral Higgs particles are to pairs of neutralinos, charginos

or sfermions. These channels are implemented in the SHAhtoNNdecay, SHAhtoCCdecay

and SHAhtosfsfdecay classes. Similarly the charged Higgs has decay channel classes

SHptoNCdecay, and SHptosfsfbdecay. These new decays are implemented in the

overall SHAhdecay and SHpdecay classes by performing the proper mass check and

then simply calling the add() function with the new channels, calling build() when

finished. This adds these channels to the list of already built two Higgs doublet

decays, and then readjust the branching ratios, taking into account the newly added

decays.

Chapter 8

Examples

In this section we will discuss fully several different physics processes that can be

described by pandora. We will discuss the physics underlying the processes as well as

the implementation and class structure in pandora. These examples should address

a variety of approaches to implementing processes and give the user some guidance

in how to use pandora effectively.

8.1 e−e+ → µ−µ+

Our first example is the very simple Standard Model process e−e+ → µ−µ+. Since this

is a 2 → 2 process with massless final states, it can be described completely by a single

twototwozz class. First, though, we consider the physics of this process. Our process

is a collision between an electron beam and a positron beam, so in considering the

contributing physics we must include initial states where one or both beam contributes

a photon to the collision, in addition to the standard e−e+ initial state. Our final state,

µ−µ+, is neutral so conservation of charge prevents a mixed e−γ or γe+ initial state

both of which have non-zero charge. This leaves four contributing Feynman diagrams

pictured in Figure 8.1. First, there are two s-channel diagrams from the e−e+ initial

state, one with a γ propagator and the other with a Z propagator. Second, there are

two diagrams from the γγ initial state, one t-channel and one u-channel, both having

a µ propagator.

139

CHAPTER 8. EXAMPLES 140

3γ, Z

e−

e+

µ+

µ−

(a)

4µ

γ

γ

µ+

µ−

(b)

Figure 8.1: Diagrams contributing to the eetomumu class.

To calculate the helicity amplitudes of these diagrams, we first consider the possi-

ble spin states. By convention, we treat the final state muons as massless. In the two

component Weyl spinor notation the µ− will be left handed, since it is the particle,

and the µ+ will be right handed, since it is the antiparticle. Computing all possible

initial helicity states we find that for all four diagrams only the LR and RL initial

state helicities contribute. Separated by helicity states the helicity amplitudes for

each diagram are:

iM(e−Le+R → γ → µ−Lµ

+R) =

e2

s(1 + cos θ)

iM(e−Re+L → γ → µ−Lµ

+R) =

e2

s(1− cos θ)

iM(e−Le+R → Z → µ−Lµ

+R) =

e2(−12

+ sin2 θw)2

(cos θw sin θw)2

1

(s−m2Z − imZΓZ)

(1 + cos θ)

iM(e−Re+L → Z → µ−Lµ

+R) =

e2(−12

+ sin2 θw)2

(cos θw sin θw)2

1


(1− cos θ)

iM(γLγR → µ−Lµ+R) =

2e2

s

sin θ

1− cos θ

iM(γRγL → µ−Lµ+R) =

2e2

s

sin θ

1 + cos θ(8.1)

In computing the full cross section, we must add together all states with the same

initial and final helicity states, so we combine contributions from the two different

s-channel propagators. The probability of a specific initial beam particle and helicity


are determined by the beam physics which we denote as fp(x). Using this notation

and plugging into (3.32), we find the full cross section

σ(e−e+ → µ−Lµ+R) =

∫ 1

0

dx1

∫ 1

0

dx2α2

s(fe(x1)fe(x2)

∣∣∣∣(1 +(−1

2+ sin2 θw)2

(cos θw sin θw)2

s


)(1− cos θ)

∣∣∣∣2 +

fe(x1)fe(x2)

∣∣∣∣(1 +(−1

2+ sin2 θw)2

(cos θw sin θw)2

s


)(1 + cos θ)

∣∣∣∣2 +

fγ(x1)fγ(x2)

∣∣∣∣2 sin θ

1− cos θ

∣∣∣∣2 + fγ(x1)fγ(x2)

∣∣∣∣2 sin θ

1 + cos θ

∣∣∣∣2)

(8.2)

To implement this process in pandora is straightforward. The process is a 2 → 2

process with two massless stable final particles. There is no need to include any

additional decay classes to describe the physics. We define a class eetomumu which

inherits from the eetotwozz class. To fully describe the eetomumu class we need

to define five functions, the initialization function and four functions inherited from

eetotwozz. The declareopenchannels() function tells pandora which initial state

channels to include in the calculation, in our case e−Le+R, e−Re

+L , γRγL, and γLγR. The

fillph() function defines the final state parton ID values and helicities. Our example

involves a single final state, but in general there will be a variety of massless final states

for a given class and each value of the final variable will be defined to correspond to

a different final state. The prefactor() function defines a multiplicative prefactor

universal to all cross sections. The amplitudes() function defines the specific helicity

amplitude as a function of the kinematic variables for each particular phase space

point.

In our example these five functions will look like

class eetomumu : public twototwozz{

public:

eetomumu ();

private:



void fillph ();


void amplitudes ();

}

eetomumu :: eetomumu (): twototwozz(leptonset , 1){

name = "e+e- (and gamma gamma) -> mu+ mu-";


}

void eetomumu :: declareOpenChannels (){

leptonAnnactive ();

}

void eetomumu :: fillph (){

p3 = 13; h3 = -1; p4 = -13; h4 = +1;

}

double eetomumu :: prefactor (){

return 0.5 * PI*alpha*alpha * fb / s;

}

void eetomumu :: amplitudes (){

complex Zs;

Zs = s/(s - mz*(mz - I * GammaZ ));

Camps [1] = 0.0;

switch(CHP){

case ggchannel:

if(CHH == 2){

Camps [1] = 2.0 * sint /(1.0 - cost);

} else if(CHH == 3){

Camps [1] = 2.0 * sint /(1.0 + cost);

}

break;

case eepchannel:

if(CHH == 2){

Camps [1] = (1.0 + QZl*QZl * Zs) * (1.0 + cost);

} else if (CHH == 3){

Camps [1] = (1.0 + QZl*QZl * Zs) * (1.0 - cost);

}


break;

default:

break;

}

}

In practice it is not efficient to define a separate class for every massless final

state, and in defining the SM we combined them into one class. The eetopairs

class actually describes any process from a combination of e−, e+, and γ to any

massless ff final state. For a given initial state, each final state is assigned a different

value of the final variable. The various initial state partons, and helicities, as well

as the implemented final states are selected randomly, weighted according to their

contribution to the cross-section. By default all possible channels are turned on and

the e−e+ → µ−µ+ state we have described is just one of many possible processes

that will contribute to the calculation, weighted according to their particular cross-

sections. Since it is often advantageous to pick out a small group of these processes to

analyze, we implement two sets of functions to limit the included channels. Defined

at the process class level, the makeactive() and makeinactive() functions will

open and close particular initial state parton combinations from the calculation, and

several common initial state choices are implemented based on them. For instance,

the eepactive() function will turn on only the e−e+ and e+e− channels, and the

ggactive() function turns on only the γγ channel. Specific to the eetopairs class,

the produceOnly() function takes an integer value that defines the particular final

state channel to be used. To facilitate this a series of constant variables are defined

in hepdata.h to specify common final states according the convention XOnly for

the parton X. Thus to restrict eetopairs to the e−e+ → µ−µ+ state we discuss

above, the user simply needs to call the function with the muOnly variable, specifically

produceOnly(muOnly).

8.2 pp→ 2 jets

Having considered a simple SM e−e+ procedure, we will turn to a common pp proce-

dure, which, in addition to displaying the additional complications for proton beam


Figure 8.2: The Z peak in e−e+ → µ−µ+ for each polarization state at a ILC typecollider. The unpolarized peak is overlapped by the e−Re

+L peak.

processes, will give an explicit example of color interference. Since both the proton

and the antiproton has a chance to contribute any quark or antiquark, except the

top, or a gluon to the process, we have to consider every qq, qg, and gg initial state

for our process, though in most cases the quarks all behave analogously. For the final

state, while it would be nice to choose a particular pair of quarks and gluons, in an

actual detector most light colored states will be indistinguishable from each other.

For this reason we will look at the general two jet final state, which will require us to

consider all massless quark and gluon final states.

While including all possible colored massless partons in both the initial and final

states might seem to make the process much more complicated, most of the processes

are related and the possible final states can be broken into three categories. Focusing

on the dominant QCD interactions, the processes with four quarks or antiquarks will

have a gluon propagator and can all be related through crossing symmetries. Similarly

the processes with two external gluons, which will have a quark propagator, and the

four gluon amplitudes are each related by crossing symmetries as well.

Looking first at the four quark amplitudes, we start with a the general qq′ → qq′


5q1

q2

q3

q4

(a)

6q1

q2

q3

q4

(b)

7q1

q2

q3

q4

(c)

Figure 8.3: Diagrams contributing to qq′ → q′′q′′′.

t-channel diagram. Ignoring the color factors for now, the four possible helicity states

of the diagram give

iM(qLq′L → qLq

′L) = ig2 s

t, iM(qLq

′R → qLq

′R) = ig2u

t,

iM(qRq′L → qRq

′L) = ig2u

t, iM(qRq

′R → qRq

′R) = ig2 s

t. (8.3)

Applying crossing symmetries, paying close attention to any spin flips, will allow us to

build all other quark helicity amplitudes by switching s,t, and u factors accordingly.

In fact we can write a general prescription for the quark diagrams with the following

conventions. We label the first particle a and particle at the other end of its fermion

line b, so b is the other incoming particle in the s-channel, the first outgoing in the

t-channel, and the second outgoing in the u-channel. Then we label the other two

particles c and d. Finally we label define all helicities as outgoing, simply flipping

initial helicities. In this prescription quarks a and b interact with the gluon and thus

must have opposite spins, when defined outgoing, and similarly c and d must have

opposite spins. With all other helicity states being zero, we can express the nonzero

states as

iM(ha = hc) = ig2 (pa + pc)2

(pa + pb)2, and iM(ha = hd) = ig2 (pa + pd)

2

(pa + pb)2(8.4)

where hi are the helicities, defined outgoing, and the pi are the standard momentum

vectors, not flipped for incoming). This is just an explicit expression of the standard

crossing symmetry, applied to the helicity amplitudes. The t-channel case in (8.3)


8qi

q′i′

ga

Figure 8.4: Color indices for the qq′g vertex.

would label the initial particles a and c and the final particles b and d. Switching the

final particles to make a u-channel diagram would switch the t and u terms in (8.3)

and would switch pb and pd in (8.4).

Turning to the color factors of the diagrams. Each qqg vertex contributes a color

factor (ta)i′i where i′ and i are the two quark colors, labeled according to Figure

8.4, and a is the gluon color. Thus for a four quark diagram (Figure 8.3) we get an

overall color factor (ta)i′i(ta)j′j. Thus a single four quark diagram, when squared and

summed over final color and averaged over initial color, will give a color factor

1

9

∑colors

(ta)i′i(ta)j′j(t

b)jj′(tb)ii′ =

1

9tr[tatb]tr[tatb] =

2

9. (8.5)

For a helicity state with only one contributing diagram, we have completely specified

the helicity amplitude for the process, but if multiple diagrams contribute there is

an additional consideration of cross terms between the diagrams. When the two

initial quarks are of the same species there will be two contributing diagrams, t and

u channel diagrams for qq → qq or qq → qq and s and t diagrams for qq → qq. While

the individual diagrams are still defined by (8.4) and the color factor for an individual

diagram squared is the same, when we square the sum of the diagrams we get a cross

term with a different color factor due to differences in indexing of the color matrices.

In all cases the difference in indexing of the two terms is simply a switch of i and j′

from above, resulting in

1

9

∑colors

(ta)i′i(ta)jj′(t

b)ij(tb)j′i′ =

1

9tr[tatbtatb] = − 2

27. (8.6)

While we have assembled all of the pieces to construct the helicity amplitudes


of all four quark processes, there is one final problem to consider. As discussed in

Section 3.4 we want to assign every event in pandora a color structure to connect

the initial and final colors, which will help correctly simulate hadronization. For

helicity amplitude with only one diagram, this is simply a matter of looking up the

label for the correct color structure, and associating that helicity amplitude with that

label. For amplitudes with multiple diagrams, each diagram will have a different color

structure, and if we simply separated the two diagrams according to color structure

we would lose the interference cross term in the calculation. We split the contribution

of the two diagrams between the two color structures with the correct coefficient to

preserve the interference term in the sum of the two terms squares. Specifically we

want to have

2

9|M1|2+

2

9|M2|2−

2

27(M∗

1M2+M∗2M1) =

2

9(|aM1−bM2|2+|aM2−bM1|2) (8.7)

with M1 and M2 being the amplitudes of the two contributing diagrams according

to (8.4). Solving for a and b we get

a =2 +

√2√

12, and b =

2−√

2√12

. (8.8)

e will use these factors to divide the two diagrams between the two color structures

and accurately account for the interference term.

Turning to the diagrams with two gluons, we can follow a similar procedure.

Looking at a specific diagram qq → gg we have the helicity amplitudes

iM(qLqR → gLgR) = ig2

√u3

ts2, iM(qLqR → gRgL) = ig2

√ut

s,

iM(qRqL → gLgR) = ig2

√ut

s, iM(qRqL → gRgL) = ig2

√u3

ts2. (8.9)

Similar to the four quark amplitude, we can generalize this with the convention that

we label the incoming quark or outgoing anti-quark a, the incoming anti-quark or out-

going quark b, and the two gluons c and d. The two quarks must be of opposite spin,

and the same-spin gluon diagrams disappear, leaving only the opposite spin gluon


cases. Then we can generalize the amplitude, again labeling helicities as outgoing,

iM(ha = hc) ∝√

(pa + pc)2(pb + pc)2

(pc + pd)2,

iM(ha = hd) ∝

√(pa + pd)6

(pa + pc)2(pc + pd)4. (8.10)

There is a nuance concerning the phase of these expressions. To treat it correctly we

will use the absolute value of these terms and apply the interference by hand with

the correct phase.

Each of these diagrams has a color factor (ta)ik(tb)kj with a and b being the gluon

colors and i and j the external quark colors. Squaring and summing over final colors,

and averaging over the cinit initial colors, depending on the orientation,

1

cinit

∑colors

(ta)ik(tb)kj(t

b)jk′(ta)ki =

1

cinittr[tatbtbta] =

1

cinit

16

3. (8.11)

he interfering diagrams will have the same color factor but with a change in the

indexing of the gluon colors, or the quark colors. This leads to the same cross term

color factor as above, specifically

1

cinit

∑colors

(ta)ik(tb)kj(t

a)jk′(tb)ki =

1

cinittr[tatbtatb] = − 1

cinit

2

3. (8.12)

ollowing the same prescription as above we get

1

cinit

(16

3|M1|2 +

16

3|M2|2 −

2

3(M∗

1M2 +M∗2M1)

)=

16

3cinit(|aM1 − bM2|2 + |aM2 − bM1|2). (8.13)

This leads to solutions of

a =3 +

√7√

32, and b =

3−√

7√32

. (8.14)

Finally we must consider the four gluon vertex. This process has four contributing


9(a)

:(b)

;(c)

<(d)

Figure 8.5: Diagrams contributing to gg → gg.

diagrams, s, t, and u channel and a four-point diagram as well. These diagrams lead

to 3 different color structures, which would seem to imply some interference between

various color structures for any given helicity. In fact there is a cancellation that

eliminates the interference terms in the helicity sum, so that each color structure can

be completely associated with a definite helicity amplitude. Using the same helicity

labeling, convention we can express the general form of the amplitudes as

iM(ha = hb) ∝(pa + pb)

2

(pb + pc)2,

iM(ha = hc) ∝(pb + pc)

2

(pa + pb)2,

iM(ha = hd) ∝(pa + pc)

4

(pa + pb)2(pb + pc)2. (8.15)

To implement this process in pandora we will define the pptopp class as a subclass

of twototwozz. In addition to the required virtual functions that must be overwrit-

ten, there are several class specific functions to facilitate calculating the amplitudes.

Specifically there are three functions to calculate the three general formulas we de-

scribed for the amplitudes of the three types of diagrams. The declaration is


class qqtoqq: public twototwozz {

public:

qqtoqq ();

qqtoqq(double ecmmin , double ptmin ,

double thetamin );

qqtoqq(double ptmin , double etamax );

void produceOnly(int Only);

protected:

void fillph ();


void amplitudes ();


complex qqbqqbamplitude(int a, int ha, int b,

int hb, int c, int hc, int d, int hd);

complex qggqbamplitude(int a, int ha, int b,


complex ggggamplitude(int a, int ha, int b,


int checkOnly (); // implements produceOnly

IVector allowfinal;

// allowed final states 1 .. 121

CMatrix stu; // invariants , placed in a matrix

void fillstu ();

};

Both the constructors and the declareOpenChannels() functions are very simple.

There are no massive decays so the constructor simply initializes the variables of

the class and calls declareOpenChannels(). Since all possible parton states could

contribute, declareOpenChannels() simply calls makeallactive(). Thus we have

qqtoqq :: qqtoqq (): twototwozz(hadronset ,48),

allowfinal (1,121), stu(1,4,1,4){

name = copy(" parton + parton -> parton + parton ");

allowfinal.constant (1);


}

void qqtoqq :: declareOpenChannels (){

makeallactive ();

}


We chose a large value, 48, for the nfinal, the number of allowable cases in the

final state. This is to accommodate the process gg → qq, gg. Since gg → qq has 2

color structures and gg → gg has 8 color structures this has 5×2×2+6×4 = 44 cases.

For efficiency, we assign given final states of the other processes multiple values of

nfinal. The prefactor() function is fairly straightforward, applying the standard

prefactor, replacing α with αs for the QCD interaction, and calculating the over all

color factor for each initial state, the diagram color factors divided by the number of

initial color states. A few of the channels have additional multiplicative factors due to

the use of the final variable. Once again these factors are nfinal/ncases with ncases

being the number of values of final that correspond to that channel. The function

definition is

double qqtoqq :: prefactor (){

double pref = 0.5*PI*SQR(alphas(sqrt(Qsq ())))* fb/s;

if (isquark(p1) && isquark(p2)){

pref *= (8.0/9.0);

} else if (isantiquark(p1) && isantiquark(p2)){

pref *= (8.0/9.0);

} else if (isquark(p1) && isantiquark(p2)){

if (final <= 24){

pref *= (64.0/27.0) * 8.0;

} else {

pref *= (8.0/9.0) * 24.0;

}

} else if (isquark(p1) && isgluon(p2)) {

pref *= (8.0/9.0) * 4.0;

} else if (isgluon(p1) && isantiquark(p2)) {

pref *= (8.0/9.0) * 4.0;

} else if (isgluon(p1) && isgluon(p2)) {

if (final <= 24){ // gg -> gg

pref *= (9.0/8.0) * 24.0;

} else { // gg -> qqbar

pref *= (1.0/3.0) * 48.0;

}

}

return pref;

}


The fillph(), and amplitudes() functions all both quite long as the most sort

out all possible initial state and final state combinations and apply them color states

and helicity amplitudes. We will focus on the portions pertaining to a small subset

of the entire set of initial states, namely the qq initial state.

void qqtoqq :: fillph (){


p3 = p1; h3 = h1; p4 = p2; h4 = h2;

Cfinal = 2;

} else if ...

}

The two quarks cannot annihilate so the process is just a scattering amplitude,

so for each individual pair of quarks there is only one possible final state, the same

partons and spins as the initial state. There is an additional nuance that for an initial

state with two of the same quarks with the same helicities there are two diagrams

to consider, the t-channel and the u-channel with different color structures. This is

implemented in amplitudes as

void qqtoqq :: amplitudes (){

// factors for treating color interferences

const double aq = (2.0 + sqrt (2.0))/ sqrt (12.0);

const double bq = (2.0 - sqrt (2.0))/ sqrt (12.0);

const double ag = (3.0 + sqrt (7.0))/ sqrt (32.0);

const double bg = (3.0 - sqrt (7.0))/ sqrt (32.0);

// check criteria on final state

if (checkOnly () == 0){

Camps [1] = 0.0;

return;

}

fillstu ();


if (p1 == p2 && h1 == h2){

Camps [1]=aq*qqbqqbamplitude (1,-h1 ,3,h3 ,2,-h2 ,4,h4)

- bq*qqbqqbamplitude (1,-h1 ,4,h4 ,2,-h2 ,3,h3);

} else {

Camps [1] = qqbqqbamplitude (1,-h1 ,3,h3 ,2,-h2 ,4,h4);

}

} else if ...


If the two initial state quarks are different, or if they are the same but have different

helicities, then there is only one diagram that contributes and that is calculated by

the qqbqqbamplitude() function. If the two quarks are the same and have the

same helicity then we have to add diagrams for both color structures. We induce

the correct color interference term using the a and b coefficients calculated above.

At first glance it may seem like we have made two mistakes here. First we have

only specifically added the contribution from one color structure. Second we have

forgotten the multiplicative factor of 1/2 on the amplitude due to identical final states.

In essence the two “mistakes” cancel out. Since the two final states are identical,

we could relabel them and switch one color structure into the other, doubling the

contribution to the amplitude, which cancels the 1/2. This computational trick does

not erase the fact that there are in fact two color factors contributing to the amplitude

and that we need to include the color interference term, but it does save some space.

The rest of the fillph() and amplitude() functions apply similar processes of

using the specialized amplitude functions like ggggamplitude() defined for this class

to fill in the Camps vector. The cases where multiple color structures may interfere are

identified and the appropriate coefficients are used to ensure the correct interference

term. Finally, there is one additional function, the produceOnly() function that uses

the Only constants described in Section 6.1 and to allow the user to specify that only

certain final states be allowed. As always the initial states can be selected using the

makeactive() functions described in the same section.

8.3 e−e+ → C−C+

The next set of examples we will consider are MSSM processes that will expand

beyond simple massless partons in the final state. We will consider the 2 → 2 processes

of the form ee → C+C− including the decays of the massive charginos. One of the

unique signatures of BSM physics, and the MSSM in particular is the presence of

long chains of decays of massive particles down to massless SM particles. Ideally by

identifying the SM particles from each step of the decay, some fraction of the decay

chain and its kinematics can be reconstructed, offering valuable information about the


=γ, Z

e−

e+

C−

C+

(a)

>νe

e−

e+

C−

C+

(b)

Figure 8.6: Diagrams contributing to e−e+ → C+1 C

−1

intermediate massive particles, many of which will be new BSM particles. We have

designed pandora to fully treat these decay chains, keeping as much of the physics,

particularly the spin interactions, intact as possible as we generate events.

First we consider the the physics of the process e−e+ → C+1 C

−1 , focusing on spin

effects on the overall angular distribution of the daughter particles. For this particular

example we will work with the Snowmass MSSM benchmark point SPS4.

First we consider the physics of the initial 2 → 2 process, before looking at the

decays. There are three contributing diagrams, two s-channel diagrams through the

γ and the Z and a t-channel diagram through with a sneutrino propagator. The

sneutrino-chargino coupling is related by supersymmetry to the eνeW coupling and

so only involves the left-handed electron. Thus it only contributes to the e−Le+R initial

state, while the s-channel diagrams contribute to both the e−Le+R and e−Re

+L initial

states. Focusing first on the e−Re+L initial state we get amplitudes of the form

iM = −2ie2(

1

s(v†(p1)c u

∗(p3)u(p2)T c v(p4) − v†(p1)c u

∗(p4)u(p2)T c v(p3))

+1

s−M2Z

(− sin θW )

cos θW(GCpZv

†(p1)c u∗(p3)u(p2)

T c v(p4)

−GCmZv†(p1)c u

∗(p4)u(p2)T c v(p3))

)(8.16)


m eC1217.779

meνe 441.135m eN1

118.752

GCpZ 1.79836GCmZ -1.66296GsfCp 2.0564GsfCm 1.92927GNCWm* .084577-GNCWp .147423

Table 8.1: SPS4 properties relevant to e−e+ → C+1 C

−1

where p1, p2, p3, and p4 are the momenta for the e−, e+, C+1 , and C−

1 respectively.

For the SPS4 point we are considering, the couplings involved are listed in Table

8.3. Considering the signs of the GCpZ and GCmZ couplings, we can see that there

will be different interference between the two different helicity structures. The first

terms in each pair will interfere destructively, while the second terms in each pair

will interfere constructively. Since the C+1 C

−1 threshold is much higher than the Z

boson resonance, and the couplings are of similar magnitudes, this will lead to one

pair contributing much more than the other. Using the helicity amplitudes defined in

Section 3.7.2, we can see how these contributions will effect the angular distribution

of the charginos. For an initial state of e−Re+L , the spinors combine to give

v†(p1)c u∗(p3)u(p2)

T c v(p4) =

Eb ∗√

(E3 + k)(E4 − k)√

(1− cos θ)(1 + cos θ) LL

Eb ∗√

(E3 + k)(E4 + k)(1− cos θ) LR

−Eb ∗√

(E3 − k)(E4 − k)(1 + cos θ) RL

−Eb ∗√

(E3 − k)(E4 + k)√

(1 + cos θ)(1− cos θ) RR

(8.17)


and

v†(p1)c u∗(p4)u(p2)

T c v(p3) =

Eb ∗√

(E4 + k)(E3 − k)√

(1 + cos θ)(1− cos θ) LL

Eb ∗√

(E4 − k)(E3 − k)(1− cos θ) LR

−Eb ∗√

(E4 + k)(E3 + k)(1 + cos θ) RL

−Eb ∗√

(E4 − k)(E3 + k)√

(1− cos θ)(1 + cos θ) RR

(8.18)

where LL refers to the C+1L C

−1L state, etc. Since k is the magnitude of the momentum

of the two charginos, the (Ei+k) terms will contribute more than the (Ei−k) terms.

So the most dominant contributions are from C+LC

−R for the first spinor term and the

C+RC

−L for the second. The second set of spinor terms interfere constructively while

the first set interfere destructively the C+RC

−L contribution will have the strongest

influence. Since this term has a (1 + cos θ)2 angular distribution it suggests that the

C+ should be produced mainly forward. This is borne out in Figure 8.7.

Next we consider the e−Le+R initial state, the contribution of the s-channel diagrams

will be analogous with

iM = −2ie2(

1

s(v†(p2)c u

∗(p3)u(p1)T c v(p4) − v†(p2)c u

∗(p4)u(p1)T c v(p3))

+1

s−M2Z

(− sin θW )

cos θW(GCpZv

†(p2)c u∗(p3)u(p1)

T c v(p4)

−GCmZv†(p2)c u

∗(p4)u(p1)T c v(p3))

)(8.19)

Again we see a difference in interference between the two pairs of helicity structures

when we consider the SPS4 couplings in Table 8.3. Specifically the second terms

in each pair will interfere constructively while the first terms in each pair interfere

destructively. Plugging in the helicity amplitudes from Section 3.7.2 we get


(a) (b)

(c) (d)

Figure 8.7: Plots of cos θ eC+ from the beam axis for the process e−e+ → C+1 C

−1 at

benchmark point SPS4. The plots correspond to (a) e−Le+R at a 500 GeV ILC (b) e−Re

+L

at a 500 GeV ILC (c) e−Le+R at a 1 TeV ILC and (d) e−Re

+L at a 1 TeV ILC.


v†(p2)c u∗(p3)u(p1)

T c v(p4) =

Eb ∗√

(E3 + k)(E4 − k)√

(1 + cos θ)(1− cos θ) LL

−Eb ∗√

(E3 + k)(E4 + k)(1 + cos θ) LR

Eb ∗√

(E3 − k)(E4 − k)(1− cos θ) RL

−Eb ∗√

(E3 − k)(E4 + k)√

(1− cos θ)(1 + cos θ) RR

(8.20)

and

v†(p2)c u∗(p4)u(p1)

T c v(p3) =

Eb ∗√

(E4 + k)(E3 − k)√

(1− cos θ)(1 + cos θ) LL

−Eb ∗√

(E4 − k)(E3 − k)(1 + cos θ) LR

Eb ∗√

(E4 + k)(E3 + k)(1− cos θ) RL

−Eb ∗√

(E4 − k)(E3 + k)√

(1 + cos θ)(1− cos θ) RR

(8.21)

which would lead to an analogous forward peaking of the charginos, since the C+LC

−R

for the second helicity amplitude dominates with a (1 + cos θ)2 distribution. This is

not complete though, since to this point we have not considered the contribution of

the sneutrino diagram to the e−Le+R amplitude. This diagram contributes an amplitude

of

iM =−ie2

u−Meνe

(v†(p2)c u∗(p3)u(p1)

T c v(p4)) (8.22)

The helicity structure of the numerator is identical to that of the constructively

interfering term above, but there is an additional angular contribution due to the u

term in the denominator. Specifically

u = (k1 − k4)2 = M2eC1

− 2k1 · k4

= M2eC1− 2Ebeam(E4 + k cos θ) (8.23)


-1.0 -0.5 0.0 0.5 1.0cosHΘL

(a)

-1.0 -0.5 0.0 0.5 1.0cosHΘL

(b)

-1.0 -0.5 0.0 0.5 1.0cosHΘL

(c)

-1.0 -0.5 0.0 0.5 1.0cosHΘL

(d)

Figure 8.8: The nominal angular distribution of C+ various diagrams for e−Le+R →

C1 + C−1 . Figure (a) is the s-channel diagram distribution at 500 GeV. Figure (b) is

the u-channel diagram distribution at 500 GeV. Figure (c) is the s-channel diagramdistribution at 1 TeV. Figure (d) is the u-channel diagram distribution at 1 TeV.

For the LCC3 benchmark the νe has a mass of 441 GeV and chargino has a mass

of 217 GeV. For a 500 GeV collider Ebeam is 250 GeV and the momentum of the

Charginos will be 122 GeV so the cos θ term is very small compared to the Mass

terms and there is little angular contribution due to the denominator as shown in

Figure 8.8. From the signs of the couplings in Table 8.3 we see that at a 500 GeV

collider the νe term will destructively interfere with the larger term above, decreasing

the overall cross section, but leaving the shape of the angular distribution the same.

For a 1 TeV collider Ebeam is 500 GeV and the momentum of the Charginos will

be around 450 GeV so that the cos θ term is much more relevant in the denominator.

Dividing by this ≈ (1 + cos θ)2 will decrease the forward contribution and increase

the backwards contribution of the νe diagram. The nominal angular of the s-channel

and u-channel diagrams at 500 GeV and 1 TeV are shown in Figure 8.8. When the


two terms interfere in destructively interferes with the s channel terms the effect is

quite dramatic, leaving a mostly backward angular distribution of the C+. The effect

of the νe propagtor term on the e−Le+R initial state angular distribution at the two

different energies can be seen in Figure 8.7.

In addition to affecting the overall angular distributions, the initial polarization of

the beams can have an effect on the distribution of various decay products down decay

chain. As an example we look further at the e−e+ → C+1 C

−1 example, considering the

decay products of the Charginos. At the SPS4 benchmark point, the dominant decay

of the C1 is to a N1 and a W boson. If we consider the C+1 in the very forward and

very backward directions, the forward moving chargino must have similar helicity to

the e− while a backwards moving one must have similar helicity to the e+ to conserve

spin angular momentum. We can probe this by considering the angular distribution

of the W+ bosons in the rest frame of the C+. The W+ boson spin in turn can be

probed by looking at the spin of its decay products.

Starting at the bottom of the chain, the W+ couples chirally to fermions. If we

plot the angular distribution of the positrons coming from the decay, which must be

right handed, we can probe the helicity of the W+. In the rest frame of the W+,

a right-handed W+ will distribute positrons with a (1 + cos θ)2 distribution, a left-

handed W+ will distribute them with a (1− cos θ)2 distribution and a longitudinally

polarized W+ with a symmetric (sin θ)2 distribution. The plots in Figures 8.9 and

8.10 show that the positron distribution in both the forward and backward regions

for both initial states is a combination of mostly longitudinal and right polarized W+

bosons. There is almost no contribution at cos θ = −1, signaling the absence of the

W+L → e+Lνe.

To understand the source of the W+ polarization we look at the masses and

coupling of the C1 to the N1 and the W listed in Table 8.3. The decay of a fermion to

a vector and fermion has four possible helicity amplitudes for each initial polarization


(a)

(b) (c)

(d) (e)

Figure 8.9: Plots for e−Re+L → C+



from the beam axis in the lab frame. (b) A plot of

cos θW+, eC+1

in the rest frame of the C+1 in the backward (cos θ eC+

1< −.8) region. (c)

A plot of cos θW+, eC+1

in the rest frame of the C+1 in the forward (cos θ eC+

1> .8) region.

(d) A plot of cos θf,fW+ in the rest frame of the W+ in the backward (cos θ eC+1< −.8)

region. (e) A plot of cos θf,W+ in the rest frame of theW+ in the forward (cos θ eC+1> .8)

region.


(a)

(b) (c)

(d) (e)

Figure 8.10: Plots for e−Re+L → C+



from the beam axis in the lab frame. (b) A plot of

cos θW+, eC+1

in the rest frame of the C+1 in the backward (cos θ eC+

1< −.8) region. (c)

A plot of cos θW+, eC+1

in the rest frame of the C+1 in the forward (cos θ eC+

1> .8) region.

(d) A plot of cos θf,fW+ in the rest frame of the W+ in the backward (cos θ eC+1< −.8)

region. (e) A plot of cos θf,W+ in the rest frame of theW+ in the forward (cos θ eC+1> .8)

region.


iM(C+1L → W+

L + N1L) = ie√

2mC1

(−G∗

N1C1Wm

√E eN1L

+ k

+GN1C1Wp

√E eN1L

− k)√

1 + cos θ

iM(C+1L → W+

0 + N1R) = ie√mC1

(−G∗

N1C1Wm

EW − k

mW

√E eN1L

− k

+GN1C1WpEW + k

mW

√E eN1L

+ k

)√1 + cos θ

iM(C+1L → W+

0 + N1L) = ie√mC1

(−G∗

N1C1Wm

EW + k

mW

√E eN1L

+ k

+GN1C1WpEW − k

mW

√E eN1L

− k

)√1− cos θ

iM(C+1L → W+

R + N1R) = ie√

2mC1

(G∗N1C1Wm

√E eN1L

− k

−GN1C1Wp

√E eN1L

+ k)√

1− cos θ (8.24)

with the equations for a right handed C+ simply replacing cos θ by − cos θ. Applying

the nominal kinematic values we can plot the angular distribution of the various

helicity states for a purely right handed C+ as seen in Figure 8.11. We find that most

of the W+ bosons are longitudinally polarized, with most of those distributed with a

(1 + cos θ) angular distribution, and of those not longitudinally polarized almost all

are right handed, distributed with a (1− cos θ) distribution.

Comparing this to the events generated in Figure 8.9 with an e−Re+L initial state we

find that the C+ fermions in the forward region are almost completely right handed

as we expect, while those in the backwards region are almost purely left handed. For

Figure 8.10 we find teh expected opposite situation with C+ fermions left handed in

teh forward region and right handed in the backwards region.

These effects, shown so far in the rest frame of the decaying particle, may be

enough to have an effect in the lab frame as well. Figure 8.12 shows the angular

distribution of the Charginos, W bosons, and the resultant fermions in the e−Le+R and

e−Re+L initial states in the lab frame, with a noticeable difference in the e+ angular

distributions. The same effects should appear in the µ+ and τ+ distributions.


-1.0 -0.5 0.0 0.5 1.0cosHΘL

Figure 8.11: Angular distribution of various decay helicity amplitudes for C+1L at

SPS4. Black is the full decay angular distribution, red is the W+0 N1L channel, orange

is the W+R N1R channel, blue is the W+

0 N1R channel and green is the W+L N1L channel.

The amplitudes for C+1R replaces cos θ with − cos θ.

(a) (b) (c) (d)

(e) (f) (g) (h)

Figure 8.12: Plots of angular distribution in the lab frame


?C−2

C+2

τ+C+

1h0

C−1h0

τ−

e−

e+

N1

τ−

τ+

N1b b ντ

b b ντ

Figure 8.13: Feynman diagram of the full decay chain resulting from the processe−e+ → C+

2 C−2 at LCC3.

In many SUSY models there are extremely long chains of decays that can result

in a very large number of final states. As an example we consider a process similar to

the one above. In Figure 8.3 we show the Feynman diagram for the large decay chains

resulting from the process e−e+ → C+2 C

−2 at the MSSM benchmark point LCC3. In

Figure 8.14 we plot the energy distribution of the particles involved in the decay chain

from the C+2 leg. All of these effects are built up in pandora by simple recursion using

the class structure described in Section 6.


Figure 8.14: Plot of the energy of each leg of the C+2 decay chain in the process

e−e+ → C+2 C

−2 for the MSSM benchmark point LCC3.

Appendix A

Invariants Classes

A.1 Invariants for 2 → 2 processes

• double ek(int j, int k) = ε(kj) · kk.

• double ee(int j, int k) = ε(kj) · ε(kk).

• complex uu(int j, int k) =

uT (kj)cu(kk), j, k = 1, 2

u†(kj)cu∗(kk), j, k = 3, 4

• complex vv(int j, int k) =

v†(kj)cv∗(kk), j, k = 1, 2

vT (kj)cv(kk), j, k = 3, 4

• complex uv(int j, int k) =

uT (kj)cv(kk), j = 1, 2, k = 3, 4

u†(kj)cv∗(kk), j = 3, 4, k = 1, 2

• complex vu(int j, int k) =

v†(kj)cu∗(kk), j = 1, 2, k = 3, 4

vT (kj)cu(kk), j = 3, 4, k = 1, 2

• complex vku(int j, int k, int `) = v†(kj)σ · kk u(k`), j, ` = 1, 2.

167

APPENDIX A. INVARIANTS CLASSES 168

• complex ukv(int j, int k, int `) = u†(kj)σ · kk v(k`), j, ` = 3, 4.

• complex uku(int j, int k, int `) = u†(kj)σ · kk u(k`), j = 3, 4, ` = 1, 2.

• complex vkv(int j, int k, int `) =v†(kj)σ · kk v(k`), j = 1, 2, ` = 3, 4.

• complex veu(int j, int k, int `)

= v†(kj)σ · ε(kk)u(k`), j, ` = 1, 2, k = 3, 4.

• complex uev(int j, int k, int `)

= u†(kj)σ · ε(kk) v(k`), j, ` = 3, 4, k = 1, 2.

• complex ueu(int j, int k, int `)

= u†(kj)σ · ε(kk)u(k`), j = 3, 4, ` = 1, 2, k 6= j, `.

• complex vev(int j, int k, int `)

= v†(kj)σ · ε(kk) v(k`), j = 1, 2, ` = 3, 4, k 6= j, `.

• complex ueku(int j, int k, int `, int m)

=

uT (kj)cσ · ε(kk)σ · k` u(km), j,m = 1, 2, k = 3, 4.

u†(kj)σ · ε(kk)σ · k` cu∗(km), j,m = 3, 4k = 1, 2.

• complex vekv(int j, int k, int `, int m)

=

v†(kj)σ · ε(kk)σ · k` cv∗(km), j,m = 1, 2, k = 3, 4.

vT (kj)cσ · ε(kk)σ · k` v(km), j,m = 3, 4k = 1, 2.

• complex uekv(int j, int k, int `, int m)

=

uT (kj)cσ · ε(kk)σ · k` v(km), j = 1, 2,m = 3, 4, k 6= j,m.

u†(kj)σ · ε(kk)σ · k` cv∗(km), j = 3, 4,m = 1, 2, k 6= j,m.

• complex veku(int j, int k, int `, int m)

=

v†(kj)σ · ε(kk)σ · k` cu∗(km), j = 1, 2,m = 3, 4, k 6= j,m.

vT (kj)cσ · ε(kk)σ · k` u(km), j = 3, 4,m = 1, 2, k 6= j,m.


• complex ukeu(int j, int k, int `, int m)

=

uT (kj)cσ · kk σ · ε(k`) u(km), j,m = 1, 2, ` = 3, 4.

u†(kj)σ · kk σ · ε(k`) cu∗(km), j,m = 3, 4` = 1, 2.

• complex vkev(int j, int k, int `, int m)

=

v†(kj)σ · kk σ · ε(k`) cv∗(km), j,m = 1, 2, ` = 3, 4.

vT (kj)cσ · ε(kk)σ · k` v(km), j,m = 3, 4` = 1, 2.

• complex ukev(int j, int k, int `, int m)

=

uT (kj)cσ · kk σ · ε(k`) v(km), j = 1, 2,m = 3, 4, ` 6= j,m.

u†(kj)σ · kk σ · ε(k`) cv∗(km), j = 3, 4,m = 1, 2, ` 6= j,m.

• complex vkeu(int j, int k, int `, int m)

=

v†(kj)σ · kk σ · ε(k`) cu∗(km), j = 1, 2,m = 3, 4, ` 6= j,m.

vT (kj)cσ · kk σ · ε(k`)u(km), j = 3, 4,m = 1, 2, ` 6= j,m.

• complex ueeu(int j, int k, int `, int m)

=

uT (kj)cσ · ε(kk)σ · ε(k`) u(km), j,m = 1, 2, k, ` = 3, 4.

u†(kj)σ · ε(kk)σ · ε(k`) cu∗(km), j,m = 3, 4k, ` = 1, 2.

• complex veev(int j, int k, int `, int m)

=

v†(kj)σ · ε(kk)σ · ε(k`) cv∗(km), j,m = 1, 2, k, ` = 3, 4.

vT (kj)cσ · ε(kk)σ · ε(k`) v(km), j,m = 3, 4k, ` = 1, 2.

• complex ueev(int j, int k, int `, int m)

=

uT (kj)cσ · ε(kk)σ · ε(k`) v(km), j = 1, 2,m = 3, 4, k, ` 6= j,m.

u†(kj)σ · ε(kk)σ · ε(k`) cv∗(km), j = 3, 4,m = 1, 2, k, ` 6= j,m.

• complex veeu(int j, int k, int `, int m)

=

v†(kj)σ · ε(kk)σ · ε(k`) cu∗(km), j = 1, 2,m = 3, 4, k, ` 6= j,m.

vT (kj)cσ · ε(kk)σ · ε(k`)u(km), j = 3, 4,m = 1, 2, k, ` 6= j,m.


• complex vekeu(int j, int k, int `, int m, int n)

= v†(kj)σ · ε(kk)σ · k` σ · ε(km) u(kn), j, n = 1, 2, k,m = 3, 4.

• complex uekev(int j, int k, int `, int m, int n)

= u†(kj)σ · ε(kk)σ · k`σ · ε(km) cv(kn), j,n = 3,4, k, m = 1,2 .

• complex uekeu(int j, int k, int `, int m, int n)

= u†(kj)σ · ε(kk)σ · ε(k`)σ · ε(km) v(kn), j = 3, 4, n = 1, 2, k,m 6= j, n.

• complex vekev(int j, int k, int `, int m, int n)

= v†(kj)σ · ε(kk)σ · ε(k`)σ · ε(km) v(kn), j = 1, 2, n = 3, 4, k,m 6= j, n.

A.2 Invariants for 1 → 2 decays

• double ek(int j, int k) = ε(kj) · kk.

• double ee(int j, int k) = ε(kj) · ε(kk).

• complex uu(int j, int k) = u†(kj)cu∗(kk), j, k = 1, 2

• complex vv(int j, int k) = vT (kj)cv(kk), j, k = 1, 2

• complex uv(int j, int k) =

uT (kj)cv(kk), j= 0,k= 1, 2

u†(kj)cv∗(kk), j= 1, 2,k= 0

• complex vu(int j, int k) =

v†(kj)cu∗(kk), j= 0,k= 1, 2

vT (kj)cu(kk), j= 1, 2,k= 0

• complex ukv(int j, int k, int `) = u†(kj)σ · kk v(k`), j, ` = 1,2.

• complex uku(int j, int k, int `) = u†(kj)σ · kk u(k`), j = 1,2, ` = 0.

• complex vkv(int j, int k, int `) = v†(kj)σ · kk v(k`), j = 0, ` = 1,2.


• complex uev(int j, int k, int `) = u†(kj)σ · ε(kk) v(k`), j, ` = 1,2, k = 0.

• complex ueu(int j, int k, int `)

= u†(kj)σ · ε(kk)u(k`), j = 1,2, ` = 0, k 6= j, `.

• complex vev(int j, int k, int `)

= v†(kj)σ · ε(kk) v(k`), j = 0, ` = 1,2, k 6= j, `.

Bibliography

[1] T. Sjostrand, S. Mrenna and P. Z. Skands, JHEP 0605, 026 (2006) [arXiv:hep-

ph/0603175].

[2] G. Corcella et al., JHEP 0101, 010 (2001) [arXiv:hep-ph/0011363].

[3] S. Moretti, K. Odagiri, P. Richardson, M. H. Seymour and B. R. Webber, JHEP

0204, 028 (2002) [arXiv:hep-ph/0204123].

[4] M. L. Mangano, M. Moretti, F. Piccinini, R. Pittau and A. D. Polosa, JHEP

0307, 001 (2003) [arXiv:hep-ph/0206293].

[5] E. Boos et al. [CompHEP Collaboration], Nucl. Instrum. Meth. A 534, 250

(2004) [arXiv:hep-ph/0403113].

[6] A. Pukhov, arXiv:hep-ph/0412191.

[7] F. Yuasa et al., Prog. Theor. Phys. Suppl. 138, 18 (2000) [arXiv:hep-

ph/0007053].

[8] J. Alwall et al., JHEP 0709, 028 (2007) [arXiv:0706.2334 [hep-ph]].

[9] T. Gleisberg, S. Hoche, F. Krauss, M. Schonherr, S. Schumann, F. Siegert and

J. Winter, JHEP 0902, 007 (2009) [arXiv:0811.4622 [hep-ph]].

[10] based on image at http://projects.hepforge.org/sherpa/dokuwiki/doku.php

[11] E. Boos et al., in proceedings of the Workshop on Physics at TeV Colliders, Les

Houches, France, 2001 [arXiv:hep-ph/0109068].

172

BIBLIOGRAPHY 173

[12] K. Odagiri, JHEP 9810, 006 (1998) [arXiv:hep-ph/9806531].

[13] A. D. Martin, R. G. Roberts, W. J. Stirling and R. S. Thorne, Phys. Lett. B

531, 216 (2002) [arXiv:hep-ph/0201127].

[14] A. D. Martin, R. G. Roberts, W. J. Stirling and R. S. Thorne, Phys. Lett. B

604, 61 (2004) [arXiv:hep-ph/0410230].

[15] J. Alwall et al., Comput. Phys. Commun. 176, 300 (2007) [arXiv:hep-

ph/0609017].

[16] N. Phinney, N. Toge and N. Walker, arXiv:0712.2361 [physics.acc-ph].

[17] M. E. Peskin, SLAC-TN-04-032, LCC-0010 (1999)

[18] K. A. Thompson, Int. J. Mod. Phys. A 15, 2485 (2000).

[19] D. M. Asner, J. B. Gronberg and J. F. Gunion, Phys. Rev. D 67, 035009 (2003)

[arXiv:hep-ph/0110320].

[20] S. P. Martin, arXiv:hep-ph/9709356.

[21] M. Jacob and G. C. Wick, Annals Phys. 7, 404 (1959) [Annals Phys. 281, 774

(2000)].

[22] W. Press, S. Teukolsky, W. Vetterling, and B. Flannery, Numerical Recipes in

C, Cambridge, UK: Unis. Pr. (1994)

[23] G.P. Lepage, J. Comput. Phys. 27, 192, (1978)

[24] R. Kleiss and R. Pittau, Comput. Phys. Commun. 83, 141 (1994) [arXiv:hep-

ph/9405257].

[25] V. D. Barger, M. S. Berger and P. Ohmann, Phys. Rev. D 49, 4908 (1994)


[26] H. E. Haber, R. Hempfling and A. H. Hoang, Z. Phys. C 75, 539 (1997)


BIBLIOGRAPHY 174

[27] F. E. Paige, S. D. Protopopescu, H. Baer and X. Tata, arXiv:hep-ph/0312045.

[28] A. H. Chamseddine, R. L. Arnowitt and P. Nath, Phys. Rev. Lett. 49, 970 (1982).

[29] M. Dine, A. E. Nelson, Y. Nir and Y. Shirman, Phys. Rev. D 53, 2658 (1996)


[30] B. C. Allanach et al., in Proc. of the APS/DPF/DPB Summer Study on the

Future of Particle Physics (Snowmass 2001) ed. N. Graf, Eur. Phys. J. C 25,

113 (2002) [arXiv:hep-ph/0202233].

[31] G. Aarons et al. [ILC Collaboration], arXiv:0709.1893 [hep-ph].

monte carlo simulation of particle production a …bm776hk7345/dissertation2... · monte carlo...

Documents