Monte Carlo Simulation of Particle Production and Decay at High-Energy Colliders

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

This work is licensed under a Creative Commons Attribution- Noncommercial 3.0 United States License. http://creativecommons.org/licenses/by-nc/3.0/us/

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

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

Michael Peskin, Primary Adviser

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

JoAnne L. Hewett

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

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 in University 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+ → Ce−Ce+ ...... 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 → Ce1 Ce1 ...... 155

viii List of Figures

3.1 Sketch of full event based on an image from the SHERPA collaboration [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 eﬀects including parton showering, hadronization and multiple interactions are pictured...... 10 3.2 All four of these diagrams could contribute to the same ﬁnal 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) insertions. (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 kinematically inaccessible at certain points in phase space, strongly affecting 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ˆ0 − 1ˆ0 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 eﬃciently sampled

by a sampling distribution p(x1, x2) = g1(x1)g2(x2) since it it ﬂat in both variables. A more eﬃcient 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 ﬂat 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 oﬀ 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 function 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 ﬁnal state vectors. For fermions, Fi should be replaced by the appropriate u or v spinor...... 127 − + 7.2 Diagrams contributing to e e → NeiNej...... 133 − + + − 7.3 Diagrams for e e → Cei Cej ...... 134 7.4 Diagrams contributing to e−e+ → fefe0...... 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 eReL peak. . . . . 144 8.3 Diagrams contributing to qq0 → q00q000...... 145 8.4 Color indices for the qq0g vertex...... 146 8.5 Diagrams contributing to gg → gg...... 149 − + + − 8.6 Diagrams contributing to e e → C1 C1 ...... 154 8.7 Plots of cos θ from the beam axis for the process e−e+ → C+C− Ce+ e1 e1 − + at benchmark point SPS4. The plots correspond to (a) eL eR at a 500 − + − + GeV ILC (b) eReL at a 500 GeV ILC (c) eL eR at a 1 TeV ILC and (d) − + eReL at a 1 TeV ILC...... 157 + − + 8.8 The nominal angular distribution of Ce various diagrams for eL eR → − Ce1 + Ce1 . 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 eReL → Ce1 Ce1 at a 500 GeV ILC collider at the benchmark

point SPS4. (a) A plot of cos θ + from the beam axis in the lab frame. Ce1 + (b) A plot of cos θ + + in the rest frame of the Ce in the backward W ,Ce1 1

(cos θ + < −.8) region. (c) A plot of cos θ + + in the rest frame of Ce1 W ,Ce1 + the Ce in the forward (cos θ + > .8) region. (d) A plot of cos θ + 1 Ce1 f,Wf + in the rest frame of the Wf in the backward (cos θ + < −.8) region. Ce1 + (e) A plot of cos θf,W + in the rest frame of the W in the forward

(cos θ + > .8) region...... 161 Ce1 − + + − 8.10 Plots for eReL → Ce1 Ce1 at a 500 GeV ILC collider at the benchmark

point SPS4. (a) A plot of cos θ + from the beam axis in the lab frame. Ce1 + (b) A plot of cos θ + + in the rest frame of the Ce in the backward W ,Ce1 1

(cos θ + > .8) region...... 162 Ce1 + 8.11 Angular distribution of various decay helicity amplitudes for C1L at + SPS4. Black is the full decay angular distribution, red is the W0 Ne1L + + channel, orange is the WR Ne1R channel, blue is the W0 Ne1R channel + + and green is the WL Ne1L channel. The amplitudes for C1R 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 → Ce2 Ce2 at LCC3...... 165 + 8.14 Plot of the energy of each leg of the Ce2 decay chain in the process − + + − e e → Ce2 Ce2 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 software. Each individual collision at the LHC will produce massive amounts of information. 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 ﬁrst 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-deﬁned 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 CHAPTER 1. INTRODUCTION 3

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 generators, 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 experimental 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 CHAPTER 1. INTRODUCTION 4

with the hard collision and including all beam effects, parton showering, hadronization 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 implemented 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 processes 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 CHAPTER 1. INTRODUCTION 5

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 interference 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 generator 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 colliders, 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 pandora’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 implementation 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 implemented into pandora. First we review the basic Standard Model processes and decays 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 → Ce1 Ce2 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 collaboration [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. 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 CHAPTER 3. PHYSICS REVIEW 11

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 computational 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 CHAPTER 3. PHYSICS REVIEW 12

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 ﬁnal 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 eﬃcient integration and CHAPTER¢ 3. PHYSICS£ REVIEW ¤¥ 13 (a) (b) (c) (d)

Figure 3.2: All four of these diagrams could contribute to the same ﬁnal state. Di- agrams (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). event generation. We will ﬁrst 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 ﬁnal state X has the form

1 Z σ = dΠ |M(p + p → X)|2 (3.1) 2s 1 2 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 Z X 2 dΠ |Mc(p1λ1 + p2λ2 → XλX )| (3.2)

λ1,λ2,λX ,c CHAPTER 3. PHYSICS REVIEW 14

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

Z n Z 3 Y d pf 1 4 (4) X dΠn = ( 3 )(2π) δ (P − pf ), (3.3) (2π) 2Ef f=1 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:

Z Z ! dσ 1 X − + − + 2 σ = d cos θ = d cos θ M(e + e → µ + µ ) (3.4) d cos θ 32πs λ1 λ2 λ3 λ4 λ3,λ4 CHAPTER 3. PHYSICS REVIEW 15

3.2 Individual decays

This simple case of only two or three ﬁnal 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 ﬁnal 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 production 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 vertex (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 2 2 2 2 (3.5) p − m0 − M (p ) where −iM 2(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) = −ZM 2(p2) = −M 2(p2) + O(α)M 2(p2), (3.6) from which we drop the higher order terms. The particle mass m is the solution of

2 2 2 2 m − m0 − ReM (m ) = 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

2 1 σ ∝ (3.8) s − m2 − iIm M 2(s) CHAPTER 3. PHYSICS REVIEW 16

¦1PI = §+ ¨ + ©+ ··· (a) = + 1PI + 1PI1PI + ··· (b)

Figure 3.3: (a) The expression for the set of all one-particle-irreducible (1PI) insertions. (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

2 1 σ ∝ (3.9) p2 − m2 − imΓ

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 diagrams. 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 ImM 2(m2) ≈ ImM 2(s) over the resonance, we can define

Z Γ = − Im M 2(m2) (3.10) m

To speciﬁcally calculate Im M 2(m2) we can apply the optical theorem to the one particle scattering to get Z 1 X 2 ZIm M 2(p2) = −Im M(p → p) = − dΠ |M(p → f)| (3.11) 2 f f where f is the set of all possible ﬁnal states of the diagram, or all possible decays from the unstable particle. This gives us a formula for the Breit-Wigner width Γ in CHAPTER 3. PHYSICS REVIEW 17

terms of the decay amplitudes of the unstable particle Z 1 X 2 Γ = dΠ |M(p → f)| (3.12) 2m f f

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 approximation 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 CHAPTER 3. PHYSICS REVIEW 18

leading to a contribution to the integral of the form

X X M(p1λ p2λ → X1λ X2λ ) × 1 2 X1 X2 λin,λfi λintern 2 1 M(X1λ → Y1λ Y2λ ) ··· (3.13) m2 − m2 − im Γ X1 Y1 Y2 X1 X10 X10

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

Z 1 X + − + − σ = dΠfull M(e e → W W )× 2s λ1 λ2 λ3 λ4 allλ 1 M(W + → e+ ν )× 2 2 λ3 1λ5 eλ6 mW + − mW 0 − imW 0Γ 1 2 M(W − → e− ν ) (3.14) 2 2 λ4 1λ7 eλ8 mW − − mW 0 − imW 0Γ CHAPTER 3. PHYSICS REVIEW 19

e+ e+ e+ e+ W + + W νe νe

ν ν W − e e W − e− e− e− e− (a) (b) + + e νe e νe Z νe νe W e+ Z, γ e+ Z, γ e− e− e− e− (c) (d) e+ e+

Z νe Z ν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 CHAPTER 3. PHYSICS REVIEW 20

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 integrating 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 suﬃcient to simply integrate the initial process separately, and then ﬁgure out the contributions of the individual CHAPTER 3. PHYSICS REVIEW 21

decays afterward. In essence, this would break our integral into Z X 2 dΠ M(p p → X X ) × 1λ1 2λ1 1λX1 2λX2 allλ 2 Z X 1 dΠ M(X → Y Y ) × · · · (3.15) 2 2 1λX1 1λY1 2λY2 m − m − imX 0Γ allλ X1 X10 1

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

iλX φ Mprod(λX )e Mdec(λX ) (3.16)

The total contribution of all helicity states to the cross section is

2 X iλX φ Mprod(λX )e Mdec(λX ) (3.17) λX CHAPTER 3. PHYSICS REVIEW 22

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

2 X 2 X iλX φ |Mprod(λX )| e Mdec(λX ) (3.18)

λX λX

This completely removes the φ dependence, eﬀectively averaging over the azimuthal angle for all decays. Then any azimuthal correlations are lost. The most eﬃcient 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 ﬁnal particles speciﬁc 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 CHAPTER 3. PHYSICS REVIEW 23 g γ g γ u u u u (a) ug → 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 CHAPTER 3. PHYSICS REVIEW 24

2 2 0 0 1 1 (a) Cfinal=1 (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 CHAPTER 3. PHYSICS REVIEW 25

construct a deﬁnite 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 speciﬁc 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 speciﬁc 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 ﬁnal colors and averaged over initial colors

1 X 2 1 † 2 † 2 |M| = tr[Tt Tt]|Mt| + tr[TuTu]|Mu| nc nc colors † ∗ ∗ † ∗ +tr[Tt Tu] Mt Mu + tr[TuTt]MuMt , (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 Mt Mu and MuMt interference terms in the calculation. To do this we will need to explicitly put the interference terms into our individual amplitudes. Let us deﬁne

† † † † tr[Tt Tt] = c1 tr[TuTu] = c2, and tr[Tt Tu] = tr[TuTt] = c3. (3.21) CHAPTER 3. PHYSICS REVIEW 26

Our proposed solution is to posit two amplitudes of the form

r r c2 c2 (aMt − bMu) and ( aMu − bMt) (3.22) c1 c1 for the two color structures. Squaring each and adding the results, and pulling out a factor of c1 gives r r 1 X 2 c2 2 c2 2 |M| = c1 |aMt − bMu| + | aMu − bMt| . (3.23) nc c1 c1 colors

This should be equal to (3.20) which, when we use the deﬁnition of c1, c2, and c3, becomes

1 X 2 2 2 ∗ ∗ |M| = c1|Mt| + c2|Mu| + c3(Mt Mu + MuMt) (3.24) nc colors

This becomes an algebraic exercise of solving the system of equations

rc c (a2 + b2) = 1, −2ab 2 = 3 , (3.25) c1 c1 which leads to

1 r c r c a = 1 + √ 3 + 1 − √ 3 , and 2 c1c2 c1c2 (3.26) 1 r c r c b = − 1 + √ 3 − 1 − √ 3 . 2 c1c2 c1c2

Thus we should construct pandora such that the t-channel color structure is given the amplitude in the ﬁrst 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 CHAPTER 3. PHYSICS REVIEW 27

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 P by a factor of fi for each color structure such that i fi = 1. The method given here is a natural one that ﬁts 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 deﬁnition of the decay width. From (3.12) we ﬁnd, in the narrow width approximation,

P R 2 dΠf |M(p → f)| 1 = f , (3.27) 2mΓ where the ﬁrst order calculation restricts f to the set of all 2-body ﬁnal states. Us- ing this we can replace the original contribution for each step of the decay with a normalized version

1 p2m Γ M(X → Y Y ) M(X → Y Y ) → X1 X1 1 1 2 . s − m2 − im Γ 1 1 2 s − m2 − im Γ p X1 X1 X1 X1 X1 X1 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 CHAPTER 3. PHYSICS REVIEW 28

diagram, including the spin correlations. Once we sum over all possible decay channels, 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 signiﬁcantly. 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 approximation of the width would be a one dimensional integral over this Breit-Wigner distribution times the nominal width integrand.

Z 2 1 X 2 1 Γ = dm dΠ2 2 2 M(X → Y1,Y2) (3.29) 2m0 m0 − m − imΓ Y1,Y2 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 CHAPTER 3. PHYSICS REVIEW 29

m2 m1

m 240 245 250 255 260

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 inaccessible at certain points in phase space, strongly aﬀecting the width integral open, there is often a noticeable shift from the naive mass value to a ﬂuctuated 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

Z 2 1 X 1 Γ = dΠfull 2 2 M(X → Y1,Y2) (3.30) 2m0 m0 − m − imΓ Y1,Y2 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. CHAPTER 3. PHYSICS REVIEW 30

X2 X22

X21 X12 X1 X11 Figure 3.9: A general process

Combining the expressions for the process cross section and the decay contributions we have an expression

Z p2mΓ M(X → X X ) X X Y Xi i i1 i2 dΠ M(p1p2 → X1X2) 2 p × s − m − imX ΓX λ,c all X i=1,2 Xi i i 2mΓXi 2 p2mΓ M(X → X X ) Y Xi ij ij1 ij2 2 p ··· (3.31) s − m − imX ΓX 2mΓ j=1,2 Xij ij ij Xij 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 ﬁxed 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 eﬀects of diﬀerent types of beams will be expressed as parton distribution function fp(x) CHAPTER 3. PHYSICS REVIEW 31

Source Implemented PDFs MRST 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

Z X X X dx1dx2 dΠ fp1 (x1)fp2 (x2) p λ,c X

p2m Γ M(X → X X ) Y Xi Xi i i1 i2 M(p1p2 → X1X2) 2 p × s − m − imX ΓX i=1,2 Xi i i 2mXi ΓXi p 2 2mX ΓX M(X → X X ) Y ij ij ij ij1 ij2 2 p ··· (3.32) s − m − imX ΓX 2m Γ j=1,2 Xij ij ij Xij Xij

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 CHAPTER 3. PHYSICS REVIEW 32

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 CHAPTER 3. PHYSICS REVIEW 33

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 CHAPTER 3. PHYSICS REVIEW 34

p3 = E3, k3 sinΘ, 0, k3 cosΘ

H L

ECM ECM p1 = , 0, 0, Θ 2 2

ECM ECM p2 = , 0, 0, - 2 2

p4 = E3, -k3 sinΘ, 0, - k3 cosΘ

Figure 3.10:H The 2 → 2 event planeL (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ˆ0 − 1ˆ0 plane by placing the momentum of particle 3 on the +3ˆ0 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 CHAPTER 3. PHYSICS REVIEW 35

x' x

p4 z' z' x' Θ34 Θ

y z p3 Φ Θ35 Ψ p5 y'

Figure 3.11: Kinematics for a 2→3 event. The three final particles fall in the 3ˆ0 − 1ˆ0 plane, and the orientation of that plane with respect to the beam axis are defined by three 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 ﬁrst (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 CHAPTER 3. PHYSICS REVIEW 36

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

0 D0,0(ψ, θ, φ) = 1 (scalar) θ i θ i ! − 2 (ψ+φ) − 2 (ψ−φ) 1/2 cos 2 e sin 2 e D 0 (ψ, θ, φ) = (fermion) m ,m θ i θ i 2 (ψ−φ) 2 (ψ+φ) sin 2 e cos 2 e   1+cos θ e−i(ψ+φ) − sin√ θ e−iψ cos θ−1 e−i(ψ−φ) 2 2 2 1  sin θ −iφ sin θ iφ  D 0 (ψ, θ, φ) =  √ e cos θ √ e  (vector) m ,m  2 2  cos θ−1 ei(ψ−φ) − sin√ θ eiψ 1+cos θ ei(ψ+φ) 2 2 2 (3.33) where ψ, θ and φ are the Euler rotation angles using the z-y-z convention, and m and m0 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 speciﬁc helicity conventions. CHAPTER 3. PHYSICS REVIEW 37

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

1 −(k) = √ (0, cos θ, −i, − sin θ) 2 k E E (k) = ( , sin θ, 0, cos θ) 0 m m m 1 +(k) = √ (0, cos θ, i, − sin θ) (3.35) 2 for left-handed, longitudinal, and right-handed polarization respective, with m2 = E2 − k2. For massless vector bosons, the longitudinal helicity state is absent. This µ ∗µ deﬁnition 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 notation, 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 CHAPTER 3. PHYSICS REVIEW 38

fermion is equivalent to

! ! ψL ψ ψDirac = ≡ † . (3.36) ψR ψ

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 D6 − 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 ! 0 −1 σµ = (1, ~σ), σµ = (1, −~σ), and c = . (3.39) 1 0 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, speciﬁcally

D † E iσ · p ψ(p)ψ†(−p) = ψ(p)ψ (−p) = p2 − |m|2 ∗ D T E −im c ψ(p)ψ (−p) = ψ(p)ψT (−p) = p2 − |m|2 D † E D ∗ E imc ψ∗(p)ψ (−p) = ψ (p)ψ†(−p) = . (3.40) p2 − |m|2 CHAPTER 3. PHYSICS REVIEW 39

p → p → p → p → u(p) v∗(p) u∗(p) v(p) (a) Incoming (b) Incoming (c) Outgoing (d) Outgoing fermion antifermion fermion 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

! ! − sin θ − cos θ u (p) = pE + p 2 , v (p) = pE − p 2 , − θ − θ cos 2 − sin 2 ! ! cos θ − sin θ u (p) = pE − p 2 , v (p) = pE + p 2 . (3.42) + θ + θ sin 2 cos 2

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) CHAPTER 3. PHYSICS REVIEW 40

where in this case θ is measured from the −3ˆ direction, as

! ! − cos θ sin θ u (p) = pE + p 2 , v (p) = pE − p 2 , − θ − θ − sin 2 − cos 2 ! ! − sin θ − cos θ u (p) = pE − p 2 , v (p) = pE + p 2 . (3.44) + θ + θ cos 2 − sin 2

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 included 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 antiparticle. 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 CHAPTER 3. PHYSICS REVIEW 41

the charge of the massless particle will determine the appropriate coupling for chiral − interactions, for instance the W boson couples to the e = eL and its antiparticle, the † + + † − e = eR, but not the e = eL and its antiparticle, the e = eR. 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

N Z V X fdV ≈ f(x ) (4.1) N i i=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 Z 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 distribution. Then we can rewrite our integral above as

Z Z N f 1 X f(xi) fdV = p dV ≈ . (4.3) p N p(x ) i=1 i

It seems that we should make this distribution p as close to our function f as possible CHAPTER 4. MONTE CARLO METHODS 44

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

|f| p = (4.4) R |f|dV 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 algorithm˜citeVEGAS. 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 speciﬁcally 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 ﬁrst 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 CHAPTER 4. MONTE CARLO METHODS 45

Figure 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. 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 CHAPTER 4. MONTE CARLO METHODS 46

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 CHAPTER 4. MONTE CARLO METHODS 47

120 140 160 180 200 0.2 0.4 0.6 0.8 1.0 (a) (b)

Figure 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. 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. CHAPTER 4. MONTE CARLO METHODS 48

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 diﬀerential cross section over some phase space dΠ

Z dσ σ = dΠ. (4.6) dΠ

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Π (4.7) Σmax and we will have events occurring at the same frequency as in nature. We can see that this process is made more eﬃcient by the same mechanism that makes the VEGAS integration algorithm more eﬃcient. Here the integrand f is the distribution dσ/dΠ. If we choose a sampling distribution p that closely models dσ/dΠ, our integral becomes

Z dσ/dΠ σ = pdΠ. (4.8) p

The weight of each randomly chosen phase space point in the new sampling distribution is dσ(x)/dΠ(x) (4.9) p(x) We can sample the phase space accurately by assigning each point the probability

dσ(x)/dΠ(x) (4.10) p(x)Σmax where dσ(x)/dΠ(x) Σ = max (4.11) max p(x) CHAPTER 4. MONTE CARLO METHODS 49

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 physical 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 distribution 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 CHAPTER 4. MONTE CARLO METHODS 50

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 adaptation process. Once the grid has been adapted a speciﬁed 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 simultaneous 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 CHAPTER 4. MONTE CARLO METHODS 51

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 ﬂat 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 Y pw(~x) = gn(xn) (4.12)

n∈Nw 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 modiﬁed average over N points as

Z N 1 X fw(~xi) f dV ≈ . (4.13) w w N p (~x ) i=1 w i

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, CHAPTER 4. MONTE CARLO METHODS 52

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 CHAPTER 4. MONTE CARLO METHODS 53

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

Z 2 N 2 X M(X → Y1,Y2) 1 X |fX,Y1,Y2 (ΓX , ~xi)| 2m0ΓX = dΠX 2 2 ≈ (4.16) tot mX0 − mX − imX ΓX N pX (~xi) Y1,Y2 i=1 where M(X → Y1,Y2) fX,Y1,Y2 (ΓX , ~xi) = 2 2 (4.17) mX0 − mX − imX ΓX

Since the integrand is a function of ΓX we will begin with a ﬁrst order estimate ΓX,0 and, as stated, we will include the decay widths lower down on the chain. Assuming all CHAPTER 4. MONTE CARLO METHODS 54

of the lower integrands, fYi , are correctly normalized, with ΓYi , we can incrementally improve our estimate of ΓX by evaluating

Z 2 X Y fY Γ = dV 0 f (Γ ) i X,n+1 X,Y1,Y2 X,n p tot 2mY ΓY Y2,Y2 i i N 2 1 X 1 Y fY (ΓY , ~xi) ≈ f (Γ , ~x ) i i . (4.18) N p0 (~x ) X,Y1,Y2 X,n i p i=1 X i 2mYi ΓYi

0 The new sampling distribution pX 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 Y 1 ΓX,n+1 Y ΓYi,n δΓX,n+1 = = . (4.19) ΓX,n δΓYi,n+1 ΓX,n ΓYi,n+1

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 CHAPTER 4. MONTE CARLO METHODS 55

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 describe 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 beneﬁt 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 speciﬁc 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 deﬁnite 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 concept 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 template 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 functions. 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 massive or not. If we just defined the distinct kinematics function in each subclass, one CHAPTER 5. OOP AND CLASS HIERARCHY 58

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 virtual 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 function 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 processes, 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 deﬁnitions have two main pieces. First, the initial declaration names the class and declares all of its member variables and prototypes for its member CHAPTER 5. OOP AND CLASS HIERARCHY 59

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 CHAPTER 5. OOP AND CLASS HIERARCHY 60

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 reﬂected in the three main types of physics classes, the luminosity classes, the process classes, and the CHAPTER 5. OOP AND CLASS HIERARCHY 61

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 basic 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 integral, and could be applied to any integrand. Still, they have been designed with the pandora particle physics integral in mind and have several features speciﬁcally useful to its execution. The VEGAS Monte Carlo algorithm has two fundamental elements, CHAPTER 5. OOP AND CLASS HIERARCHY 62

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 diﬀerent 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 necessary, 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 CHAPTER 5. OOP AND CLASS HIERARCHY 63

that cannot be treated analytically, and are best treated by the VEGAS optimization 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 dimension. Third, there are the discrete variables that choose between various speciﬁc 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 functions 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 particular 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 properly 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 CHAPTER 5. OOP AND CLASS HIERARCHY 64

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 instantiated 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 integral 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 integration 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. CHAPTER 5. OOP AND CLASS HIERARCHY 65

eetoWW

twototwomm

process

installDecay()

AdaptiveMCf unction buildcrosssection()

prepareMCvariables() buildKinematics()

installcomponent() buildEvent()

buildV ariables() prefactor()

amplitudes()

fillph()

Figure 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.

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 integration variables and other physics classes. The first layer above adaptiveMCfunction is the general process class which describes 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, CHAPTER 5. OOP AND CLASS HIERARCHY 66

when the most general operations involving basic initialization of variables are done, all objects are treated as adaptiveMCfunction objects, but when higher level functions 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 particles 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 amplitude 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 overwritten 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 CHAPTER 5. OOP AND CLASS HIERARCHY 67

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 additional 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 implementation 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. CHAPTER 5. OOP AND CLASS HIERARCHY 68

HiggstoZgdecay

decaytotwomz

decay

installDecay()

AdaptiveMCfunction buildKinematics()

prepareMCvariables() buildDecayVectors()

installcomponent() placeIDs()

buildVariables() amplitudes()

properamplitudes()

fillph()

Figure 5.4: Hierarchy image of a HiggstoZgdecay 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 properamplitudes() is initialized by the decay class as a virutal function and is finally 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 diﬀerent decay channels, some of which have distinct massive ﬁnal 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 CHAPTER 5. OOP AND CLASS HIERARCHY 69

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 functions 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 appropriate 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 CHAPTER 5. OOP AND CLASS HIERARCHY 70

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 channels. 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 CHAPTER 5. OOP AND CLASS HIERARCHY 71

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 deﬁned 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 ﬁrst 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 situations, particularly with the quark pdfs, where it is more eﬃcient to sample points in the variables ECM and rapidity, y. With this approach, x1 and x2 are derived values

ECM y ECM −y x1 = e , and x2 = e . (5.2) 2Ebeam1 2Ebeam2

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 aﬀecting 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 diﬀer- 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 CHAPTER 5. OOP AND CLASS HIERARCHY 72

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 collisions. 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 momentum 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 CHAPTER 5. OOP AND CLASS HIERARCHY 73

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 CHAPTER 5. OOP AND CLASS HIERARCHY 74

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 ﬁle, 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 parameters, 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− −1 0 1     e+ e+e+ e+γ e+e− −1 1 2 3     γ γe+ γγ γe−  → 0 4 5 6 . (6.1)     e− e−e+ e−γ e−e− 1 7 8 9

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 identiﬁed 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 77

Parton x or y → e+, e− ep,em γ g d, d d,dbar u, u u,ubar s, s s,sbar c, c c,cbar b, b b,bbar g 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 decays to massless particles. These variables are given names of the form leptonsOnly, bcOnly, and invisibleOnly, with the allStates constant to identify all open channels. 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. CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 78

Function Open channels eeactive() e−e− eepactive() e−e+, e+e− epepactive() e+e+ ggactive() γγ egactive() e−γ, e+γ, γe−, γe+, leptonAnnactive() e−e+, e+e− , γγ qqactive() qq0 qqbaractive() qq0, qq0 qbarqbaractive() qq0 glglactive() gg qqallactive() qq0, qq0, qq0, qq0 qgactive() qg, gq, qg, gq hadronAnnactive() 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 79

an error message. For the W boson with CKM mixing in the quark decays this may not be so obvious. If a speciﬁc 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 80

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 deﬁnes the appropriate invariants. It again assumes the pandora decay orientation convention, where the decaying particle, particle 0, has helicity measured along the +3ˆ axis and the ﬁrst 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 ); CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 81

deﬁne 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 ); CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 82

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 diﬀerent 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 declare 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σ X = prefactor() × |Camp[h]|2, (6.4) d cos θ h 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 83

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 daughters. 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 helicity 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 84

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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 85

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 deﬁnition 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() function will be combined with the Camps vector, deﬁned 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 reﬂect 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 proportional to α2. The standard 2 → 2 prefactor will be

2 12 πα |kf | 0.38938 × 10 fb × −2 . (6.5) 2s ECM GeV

The conversion factor from GeV−2 to fb is stored as a global constant in hepdata.h CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 86 γ νe γ ! νe e− W − e− W −

− − 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 87

example process is shown in Figure 6.1, and applying the standard two component Feynman rules, discussed in Section 3.7.2, we get

2 e † ∗ σ · (k1 + k2) iM = √ u (k4)σ · (k3) σ · (k2)v(k1) 2 sin θW s 2 † µ 1 ∗ + e u (k4)σ u(k1) 2 · (k2) · (k3)(k2 − k3)µ u − mW + imW ΓW ∗ ∗ + (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 deﬁne the fillph() function. As mentioned above, this can be CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 88

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 speciﬁcation 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 ﬁxed, 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 ﬁxed 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: CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 89

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 pandora. 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 referenced 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 configurations, 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 90

decay momentum, divided by the number of helicity states of the decaying particle. This is the ﬁrst 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 deﬁned 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 91

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 Z0 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 Z0 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. CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 92

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 adjusting the variables deﬁned in the Zdecay class, but at some point it may be easier to simply deﬁne 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 93

of the kinematic classes and completely describe the helicity structure of the decay or process, up to the speciﬁc couplings and masses involved, as well as the appropriate propagators for the process classes. The user simply needs to deﬁne 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 ﬁrst 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 properamplitudes(); 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, CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 94

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

1 S Cfactor × |M|2 (6.7) 16πM |C|

1 here S is 2 for identical ﬁnal 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 ; CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 95

decays2invariants IV; void computeGamma(); void properamplitudes(); };

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. + 0 + As a example, the definition of the class for the MSSM decay of C1 → N1 W 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);} } CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 96

The complete decay is described by defining just the constructor, and the constructor 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 couplings 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 declareOpenChannels(); double prefactor(); void amplitudes(); invariants IV; ... CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 97

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 deﬁned in the header ﬁle, such that all CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 98

γ Ce− e+ Ce− e+ Ce+

Ce νe " #γ, Z $e γ − − Ce+ e Ce+ e Ce− (a) (b) (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 propagators 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+ → Ce+Ce−. 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 massive 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)], CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 99

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 appropriate 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. CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 100

To deﬁne 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 deﬁning 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){ CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 101

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|| ((IDTINY){ 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 nodecay(ID,M,2,C)); } else if (mf1>TINY){ 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 speciﬁc 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 102

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; CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 103

coupuu*=conj(HP.ushift(ID)); coupvv*=HP.ushift(ID); computeGamma(); }

The ID variable deﬁnes 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); void computeGamma(); 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 104

} 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: CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 105

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(); } CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 106

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 0 0 Higgses to two neutralinos, h, H ,A → NeiNej 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. CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 107

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 simulating 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 defined 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; CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 108

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 "<

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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 109

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 deﬁnes 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 CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 110

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 numerical 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 sampling 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. CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 111

The LEvent object stores all of the data for the initial and final particles and all intermediate 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 convention. 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 statement 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. CHAPTER 6. IMPLEMENTATION OF NEW PHYSICS 112

Function Returns: n() number of particles in the event id(int m) ID value parent(int m) index of the parent (0 if top-level) final(int m) 1 if ﬁnal, 2 in intermediate, -1 if initial helicity(int m) +1 or -1 for massless partons color(int m) 0 if singlet, color string index if colored anticolor(int m) 0 if singlet, anticolor string index if colored E(int m) energy p(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 momentum eta(int m) pseudo-rapidity dotproduct(int m, int n) pm · pn mass(int m, int n) invariant mass of pm + pn cost(int m, int n) relative cos θ

Table 6.3: LEvent member functions. The integers m and n refer to the index number in 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 ﬁrst 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 approximation 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 deﬁned 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, although 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 includes 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 constant variables defined in hepdata.h. It only used the e−e+ and γγ initial states and CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 115

the variaous options for the produceOnly() function are listed in Table 7.1.

produceOnly() option Included Processes ggOnly 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, γγ → uu e−e+ → ss, and γγ → ss cOnly e−e+ → cc and γγ → cc bOnly e−e+ → bb, and γγ → bb heavyquarksOnly 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 include 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 production, 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 116

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 objects 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 photons 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 117

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 interactions. 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 involve 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 symmetric, 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 118

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 contributing 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 specifically for these cases. CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 119

7.2 SUSY

Supersymmetry (SUSY) is one of the more prominent solutions proposed to the hierarchy 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 proposed 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 diﬀers 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 = eR and e = eR. 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 complex scalar ﬁeld 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 Heu is the superpartner of Hu. CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 120

The gauge bosons must fall into gauge supermultiplets, and gain fermionic superpartners 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 Be0. This completes the deﬁnition 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) uR dR (ueL deL) ueR deR † † ∗ ∗ (cL sL) cR sR (ecL seL) ecR seR † † ∗ ∗ (tL bL) tR bR (etL ebL) etR ebR † ∗ (νe eL) eR (νee eL) eR † ∗ (νµ µL) µR (νeµ µeL) µeR † ∗ (ντ τL) τR (νeτ τeL) τeR ± 0 0 ± 0 0 g W W B ge Wf Wf Be + 0 0 − + 0 0 − (Hu Hu)(Hd Hd ) (Heu Heu)(Hed Hed ) Table 7.2: MSSM particles

The interactions of these particles are deﬁned by the supersymmetric extension of the SM Lagrangian. The SM gauge bosons couple to the fermions through the covariant derivative e 0 e 0 3 e + + − − a a Dµ = ∂µ − i BµY + Wµ I + √ (Wµ I + Wµ I ) + gsgµt . (7.1) cw sw 2sw

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

µ ∗i †i µ ∆L = −D φ Dµφi − iψ σ Dµψi, (7.2)

with φi being the complex scalar and φi the Weyl fermion portions of a chiral multiplet. To complete the supersymmetric Lagrangian there must also be analogous CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 121

terms involving the gauginos, speciﬁcally

√ ∗ e 0T e 0T 3 e +T + −T − aT a ∆L = − 2φ Be Y + Wf I + √ (Wf I + Wf I ) + gsge t cψ cw sw 2sw √ † e 0∗ e 0∗ 3 e +∗ − −∗ + a∗ a + 2ψ c Be Y + Wf I + √ (Wf I + Wf I ) + gsge t φ , cw sw 2sw (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. Speciﬁcally the MSSM superpotential is

ij ij W = − yu ueiHuααβQejβ + yd ediHdααβQejβ ij + ye eiHdααβLejβ − µHdααβHuβ. (7.4)

The contribution of the superpotential to the Yukawa coupling in the Lagrangian is

2 1 T ∂ W ∆L = − ψi cψj + h.c. , (7.5) 2 ∂φi∂φj 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 interactions 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 ﬂavor-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 P R = +1 to all SM particles and Higgs bosons and P R = −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 P R = −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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 122

neutral it makes a good candidate to explain non-baryonic dark matter. The interactions 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:

MSSM 1 L = − M3gg + M2WfWf + M1BeBe + h.c. soft 2 ee − ueauQHe u − edadQHe d − eaeQHe d) + h.c. † † 2 † 2 2 † e 2e 2 † − Qe mQQe − Le mLLe − uemuue − dmdd − emee − m2 H∗H − m2 H∗H − (bH H + h.c.) (7.6) Hu u u Hd d d u d

In addition to simply giving the sparticles larger masses, these terms will induce 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 example etL and etR, we will refer to the mass eigenstates, et1 and et2, 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. 0 0 0 0 The neutralinos Nei are superpositions of the Be , Wf , Heu, and He , d, with the indices, + + i = 1, 2, 3, 4, applied in ascending order. The charginos Cei are superpositions of Wf + − − − and Heu , and Cei are superpositions of Wf and Hed , with the indices i = 1, 2 applied CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 123

in ascending order as well. In more phenomenologically viable MSSM models the Ne1 is the LSP. The SM fermions are free from additional mass mixing terms but the new Higgs + 0 scalar sector is not. The two complex scalar doublets Hu = (Hu ,Hu) and Hd = − 0 (Hd ,Hd ) 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 ﬁve are referred to as H+ and its conjugate H−, the CP-odd A0, and the CP-even H0 0 and h . 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

2 2 mh0 < mZ cos 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 inﬂuence 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 124

most general form of the MSSM has 105 free parameters, in general these parameters will introduce ﬂavor 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 ﬂavor diagonal,

 2   2   2  mQu 0 0 mLe 0 0 mu 0 0 2   2   2   m ≈  0 m2 0  ; m ≈  0 m2 0  ; m ≈  0 m2 0  ; Q  Qc  L  Lµ  u  c  2 2 2 0 0 mQt 0 0 mLτ 0 0 mt     m2 0 0 m2 0 0 d e 2   2   m ≈  0 m2 0  ; m ≈  0 m2 0  ; d  s  e  µ  0 0 m2 0 0 m2 b τ (7.8)

Second we assume that the trilinear scalar couplings are proportional to the corresponding Yukawa coupling matrix, essentially restricting their eﬀects to the third generation,

      0 0 0 0 0 0 0 0 0       au = Auyu ≈ 0 0 0  ; ad = Adyd ≈ 0 0 0  ; ae = Aeye ≈ 0 0 0  ;       0 0 at 0 0 ab 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 125

MSSM parameter SUSYspectrum variable M3,M2,M1 complex m3, m2, m1 2 2 2 mQu, mQc, mQt double msqQu, msqQc, msqQt 2 2 2 mu, mc , mt double msquR, msqcR, msqtR m2, m2, m2 d s b double msqdR, msqsR, msqbR 2 2 2 mLe, mLµ, mLτ double msqLe, msqLmu, msqLtau 2 2 2 me, mµ, mτ 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 speciﬁc 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 126

Gauge Eigenstate Mass Eigenstates Mixing variable τeL τeR τe1 τe2 Vtau[a][b] ebL ebR eb1 eb2 Vb[a][b] etL etR et1 et2 Vt[a][b] 0 0 0 0 Be Wf Heu Hed Ne1 Ne2 Ne3 Ne4 Vz[a][b] + + + + Wf Heu Ce1 Ce2 Vp[a][b] − − − − Wf Hed Ce1 Ce2 Vm[a][b] Table 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.

V F1 F2 SUSYspectrum coupling Z Nei Nej GNZ[i][j] + + γ Cek Cel GCpA[k][l] + + Z Cek Cel GCpZ[k][l] − − γ Cek Cel GCmA[k][l] − − Z Cek Cel GCmZ[k][l] + − W Cek Nei GNCWp[i][k] − + W Cek Nei GNCWm[i][k] + − W Nei Cek conj(GNCWp[i][k]) − + W Nei Cek 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 speciﬁc set of input parameters is a fairly general way to express the particular 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 speciﬁc models of supersymmetry breaking that usually CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 127

S2 S3

m V = ieGVS S (pS − pS ) m(V ) S = ieGS S S % 1 2 1 2 1 & 1 2 3 S1 S2 (a) (b)

F2 F2

† m † V = ieGVF F F σ F2m(V ) S = ieGSF F F c F2 ' 1 2 1 ( 1 2 1 F1 F1 (c) (d)

mn S = ieGSV V g m(V1)n(V2) ) 1 2 V1 (e)

Figure 7.1: MSSM Coupling diagrams. For scalars, all momenta p are outgoing. For ∗ vectors, should be used for ﬁnal state vectors. For fermions, Fi should be replaced by the appropriate u or v spinor.

V S1 S2 SUSYspectrum coupling ∗ γ fe fe Qf Z f f ∗ (I3 − sin2 θ Q )/(sin θ cos θ ) e e f W√f W W + ∗ W feu fed 1/ 2 sin θW ∗ γ fea feb Qf δab (fea 3rd gen. only) ∗ Z fea feb sw/cwQf δab− 1/(2*sw*cw)* conj(Vtau[1][a])*Vtau[1][b] + ∗ W νeτ τea 1/(sqrt(2)*sw)Vtau[1][a] + ∗ W eta eba 1/(sqrt(2)*sw)conj(Vt[1][a])Vb[1][b] γ H+ H− GHpg Z A h, H GAhZ, GAHZ ZH+ H− GHpZ W + H+ h, H, A GHphW, GHpHW, GHpAW Table 7.6: VSS couplings CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 128

(S,F1) F2 SUSYspectrum coupling (feL, fL) Nei GsfN(sfID)[i]

(feR, f L) Nei GsfbN(sfID)[i] + (feuL, fdL) Cek GsfCp(sfID)[i] − (fedL, fuL) Cek GsfCm(sfID)[i]

Table 7.7: SFF couplings. fu refers to up type quarks or neutrinos. fd refers to down type quarks an leptons.

S1 S2 S3 SUSYspectrum coupling h h h Ghhh h h H GhhH h H H GhHH HHH GHHH h A A GhAA HAA GHAA H+ H− h, H, A GHph,GHpH,GhpA

Table 7.8: SSS couplings

SV1 V2 SUSYspectrum coupling h, H Z Z GZZh,GZZH h, H W W GWWh,GWWH Table 7.9: SVV couplings CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 129

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 simplifies the low energy SUSY-breaking Lagrangian, reducing the number of parameters from 105 to just four. Methods for implementing this mSUGRA form of gravitymediation 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 between the hidden and visible sectors through gauge bosons and their superpartners. In general the models include new chiral superfields that couple directly to the hidden SUSY-breaking sector, and interact indirectly with the visible sector through the standard MSSM gauge bosons and gauginos. Like with mSUGRA, assuming the simplest 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 130

based on various assumptions and SUSY-breaking models beyond the few we have implemented 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 parameters 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 benchmarks 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 131

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 ﬁne 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 corresponding 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 ﬁnal 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 ﬁnal 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 132

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 generally 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 contributing 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 combination 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 133

e+ Nej e+ Nej e+ Nej

eL eR *Z +e ,e e− − − Nei e Nei e Nei (a) (b) (c)

− + Figure 7.2: Diagrams contributing to e e → NeiNej. 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 declaration 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 νee 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 γγ → Ci Ci process CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 134

γ Ce− e+ Ce− e+ Ce+

Ce νe - .γ, Z /e γ − − Ce+ e Ce+ e Ce− (a) (b) (c)

− + + − Figure 7.3: Diagrams for e e → Cei Cej .

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 νee 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 γγ → Ci Ci 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 γγ → Ci Ci 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+ → fefe∗ processes, one with a γ propagator and one with a Z propagator. Additionally there is a γγ → fefe∗ with a t-channel fe 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 135

+ f ∗ γ f ∗ + 0 e e e e e

fe Nei 0γ, Z 1 2 − γ − e fe fe e e (a) (b) (c)

Figure 7.4: Diagrams contributing to e−e+ → fefe0. 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 deﬁne 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γ → eNe, which has s and t − − channel contributions, and eL γ → νeeCe , 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 → NeNe 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 diﬀerent chargino species, the qq0 → Ce+Ce− also a s-channel diagram with a CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 136

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 → Ce+N involving all combinations 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- 0 ∗ 0 cesses, qq → elel and qq → elνel, 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. 0 00 000 The squark process qq → qe qe is implemented in qqtosquarks which is a su- ∗ persymmetric version of the four quark and the gg → qeqe 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 → gege and gg → gege processes, and the qqtosqsg class which implements the qg → qege. 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 137

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 ﬁrst 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 CHAPTER 7. CATALOG OF IMPLEMENTED NEW PHYSICS 138

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 speciﬁc neutralino or chargino being decayed are references by the standard index convention. In most phenomenologically viable cases the lightest Ne1 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 ﬁnished. 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 diﬀerent 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 eﬀectively.

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

− e+ µ− γ µ

µ 3γ, Z 4 e− µ+ γ µ+ (a) (b)

Figure 8.1: Diagrams contributing to the eetomumu class.

To calculate the helicity amplitudes of these diagrams, we first consider the possible 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:

e2 iM(e−e+ → γ → µ−µ+) = (1 + cos θ) L R L R s e2 iM(e−e+ → γ → µ−µ+) = (1 − cos θ) R L L R s 2 1 2 2 − + − + e (− 2 + sin θw) 1 iM(eL eR → Z → µL µR) = 2 2 (1 + cos θ) (cos θw sin θw) (s − mZ − imZ ΓZ ) 2 1 2 2 − + − + e (− 2 + sin θw) 1 iM(eReL → Z → µL µR) = 2 2 (1 − cos θ) (cos θw sin θw) (s − mZ − imZ ΓZ ) 2e2 sin θ iM(γ γ → µ−µ+) = L R L R s 1 − cos θ 2e2 sin θ iM(γ γ → µ−µ+) = (8.1) R L L R s 1 + cos θ

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 CHAPTER 8. EXAMPLES 141

are determined by the beam physics which we denote as fp(x). Using this notation and plugging into (3.32), we ﬁnd the full cross section

Z 1 Z 1 2 − + − + α σ(e e → µL µR) = dx1 dx2 0 0 s 1 2 2 2 (− 2 + sin θw) s fe(x1)fe(x2) 1 + 2 2 (1 − cos θ) + (cos θw sin θw) (s − mZ − imZ ΓZ ) 1 2 2 2 (− 2 + sin θw) s fe(x1)fe(x2) 1 + 2 2 (1 + cos θ) + (cos θw sin θw) (s − mZ − imZ ΓZ ) 2 2! sin θ sin θ fγ(x1)fγ(x2) 2 + fγ(x1)fγ(x2) 2 (8.2) 1 − cos θ 1 + cos θ

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 eL eR, eReL , γ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 declareOpenChannels(); CHAPTER 8. EXAMPLES 142

void fillph (); double prefactor(); void amplitudes(); }

eetomumu::eetomumu(): twototwozz(leptonset, 1){ name = "e+e- (and gamma gamma) -> mu+ mu-"; declareOpenChannels(); }

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); } CHAPTER 8. EXAMPLES 143

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 procedure, which, in addition to displaying the additional complications for proton beam CHAPTER 8. EXAMPLES 144

Figure 8.2: The Z peak in e−e+ → µ−µ+ for each polarization state at a ILC type − + collider. The unpolarized peak is overlapped by the eReL 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 qq0 → qq0 CHAPTER 8. EXAMPLES 145 q2 5 q4 q2 6 q4 q2 7 q4 q1 q3 q1 q3 q1 q3 (a) (b) (c)

Figure 8.3: Diagrams contributing to qq0 → q00q000. t-channel diagram. Ignoring the color factors for now, the four possible helicity states of the diagram give

s u iM(q q0 → q q0 ) = ig2 , iM(q q0 → q q0 ) = ig2 , L L L L t L R L R t u s iM(q q0 → q q0 ) = ig2 , iM(q q0 → q q0 ) = ig2 . (8.3) R L R L t R R R R t

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

2 2 2 (pa + pc) 2 (pa + pd) iM(ha = hc) = ig 2 , and iM(ha = hd) = ig 2 (8.4) (pa + pb) (pa + pb) where hi are the helicities, deﬁned outgoing, and the pi are the standard momentum vectors, not ﬂipped 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) CHAPTER 8. EXAMPLES 146

0 qi0 8 ga qi

Figure 8.4: Color indices for the qq0g 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 a 0 factor (t )i0i 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 a a overall color factor (t )i0i(t )j0j. Thus a single four quark diagram, when squared and summed over final color and averaged over initial color, will give a color factor

1 X a a b b 1 a b a b 2 (t ) 0 (t ) 0 (t ) 0 (t ) 0 = tr[t t ]tr[t t ] = . (8.5) 9 i i j j jj ii 9 9 colors

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 j0 from above, resulting in

1 X a a b b 1 a b a b 2 (t ) 0 (t ) 0 (t ) (t ) 0 0 = tr[t t t t ] = − . (8.6) 9 i i jj ij j i 9 27 colors

While we have assembled all of the pieces to construct the helicity amplitudes CHAPTER 8. EXAMPLES 147

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 2 2 2 |M |2 + |M |2 − (M∗M +M∗M1) = (|aM −bM |2 +|aM −bM |2) (8.7) 9 1 9 2 27 1 2 2 9 1 2 2 1 with M1 and M2 being the amplitudes of the two contributing diagrams according to (8.4). Solving for a and b we get √ √ 2 + 2 2 − 2 a = √ , and b = √ . (8.8) 12 12 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 speciﬁc diagram qq → gg we have the helicity amplitudes

r √ u3 ut iM(q q → g g ) = ig2 , iM(q q → g g ) = ig2 , L R L R ts2 L R R L s √ r ut u3 iM(q q → g g ) = ig2 , iM(q q → g g ) = ig2 . (8.9) R L L R s R L R L ts2

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 outgoing 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 CHAPTER 8. EXAMPLES 148

cases. Then we can generalize the amplitude, again labeling helicities as outgoing,

p 2 2 (pa + pc) (pb + pc) iM(ha = hc) ∝ 2 , (pc + pd) s 6 (pa + pd) iM(ha = hd) ∝ 2 4 . (8.10) (pa + pc) (pc + pd)

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. a b Each of these diagrams has a color factor (t )ik(t )kj with a and b being the gluon colors and i and j the external quark colors. Squaring and summing over ﬁnal colors, and averaging over the cinit initial colors, depending on the orientation,

1 X a b b a 1 a b b a 1 16 (t )ik(t )kj(t )jk0 (t )ki = tr[t t t t ] = . (8.11) cinit cinit cinit 3 colors 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, speciﬁcally

1 X a b a b 1 a b a b 1 2 (t )ik(t )kj(t )jk0 (t )ki = tr[t t t t ] = − . (8.12) cinit cinit cinit 3 colors ollowing the same prescription as above we get

1 16 2 16 2 2 ∗ ∗ |M1| + |M2| − (M1M2 + M2M1) = cinit 3 3 3

16 2 2 (|aM1 − bM2| + |aM2 − bM1| ). (8.13) 3cinit

This leads to solutions of √ √ 3 + 7 3 − 7 a = √ , and b = √ . (8.14) 32 32

Finally we must consider the four gluon vertex. This process has four contributing CHAPTER9 8. EXAMPLES : ; 149 (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 diﬀerent 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 deﬁnite helicity amplitude. Using the same helicity labeling, convention we can express the general form of the amplitudes as

2 (pa + pb) iM(ha = hb) ∝ 2 , (pb + pc) 2 (pb + pc) iM(ha = hc) ∝ 2 , (pa + pb) 4 (pa + pc) iM(ha = hd) ∝ 2 2 . (8.15) (pa + pb) (pb + pc)

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 overwritten, there are several class specific functions to facilitate calculating the amplitudes. Specifically there are three functions to calculate the three general formulas we described for the amplitudes of the three types of diagrams. The declaration is CHAPTER 8. EXAMPLES 150

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 (); double prefactor(); void amplitudes(); void declareOpenChannels(); 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, int hb , int c, int hc , int d, int hd ); complex ggggamplitude(int a, int ha , int b, int hb , int c, int hc , int d, int hd ); 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); declareOpenChannels(); }

void qqtoqq::declareOpenChannels(){ makeallactive(); } CHAPTER 8. EXAMPLES 151

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 ; } CHAPTER 8. EXAMPLES 152

The fillph(), and amplitudes() functions all both quite long as the most sort out all possible initial state and ﬁnal 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(){ if (isquark(p1) && isquark(p2)){ 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 ﬁnal 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 diﬀerent 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 (isquark(p1) && isquark(p2)){ 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 ... CHAPTER 8. EXAMPLES 153

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+ → Ce−Ce+

The next set of examples we will consider are MSSM processes that will expand beyond simple massless partons in the ﬁnal 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, oﬀering valuable information about the CHAPTER 8. EXAMPLES 154

e+ Ce+ e+ Ce+

νee =γ, Z > − e − − − Ce e Ce (a) (b)

− + + − Figure 8.6: Diagrams contributing to e e → C1 C1 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 → C1 C1 , focusing on spin eﬀects 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 eL eR initial − + − + state, while the s-channel diagrams contribute to both the eL eR and eReL initial − + states. Focusing ﬁrst on the eReL initial state we get amplitudes of the form

1 iM = −2ie2 (v†(p )c u∗(p ) u(p )T c v(p ) − v†(p )c u∗(p ) u(p )T c v(p )) s 1 3 2 4 1 4 2 3

1 (− sin θW ) † ∗ T + 2 (GCpZ v (p1)c u (p3) u(p2) c v(p4) s − MZ cos θW ! † ∗ T − GCmZ v (p1)c u (p4) u(p2) c v(p3)) (8.16) CHAPTER 8. EXAMPLES 155

m 217.779 Ce1 m 441.135 νee m 118.752 Ne1 GCpZ 1.79836 GCmZ -1.66296 GsfCp 2.0564 GsfCm 1.92927 GNCWm* .084577 -GNCWp .147423

− + + − Table 8.1: SPS4 properties relevant to e e → Ce1 Ce1

− + + − where p1, p2, p3, and p4 are the momenta for the e , e , Ce1 , and C1 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 C1 C1 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 eReL , the spinors combine to give

† ∗ T v (p1)c u (p3) u(p2) c v(p4) =  p p Eb ∗ (E3 + k)(E4 − k) (1 − cos θ)(1 + cos θ) LL   p Eb ∗ (E3 + k)(E4 + k)(1 − cos θ) LR (8.17) p −Eb ∗ (E3 − k)(E4 − k)(1 + cos θ) RL   p p −Eb ∗ (E3 − k)(E4 + k) (1 + cos θ)(1 − cos θ) RR CHAPTER 8. EXAMPLES 156

and

† ∗ T v (p1)c u (p4) u(p2) c v(p3) =  p p Eb ∗ (E4 + k)(E3 − k) (1 + cos θ)(1 − cos θ) LL   p Eb ∗ (E4 − k)(E3 − k)(1 − cos θ) LR (8.18) p −Eb ∗ (E4 + k)(E3 + k)(1 + cos θ) RL   p p −Eb ∗ (E4 − k)(E3 + k) (1 − cos θ)(1 + cos θ) RR

+ − where LL refers to the Ce1L C1L 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 CL CR for the first spinor term and the + − CR CL for the second. The second set of spinor terms interfere constructively while + − the first set interfere destructively the CR CL 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 eL eR initial state, the contribution of the s-channel diagrams will be analogous with

1 iM = −2ie2 (v†(p )c u∗(p ) u(p )T c v(p ) − v†(p )c u∗(p ) u(p )T c v(p )) s 2 3 1 4 2 4 1 3

1 (− sin θW ) † ∗ T + 2 (GCpZ v (p2)c u (p3) u(p1) c v(p4) s − MZ cos θW ! † ∗ T − GCmZ v (p2)c u (p4) u(p1) 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 CHAPTER 8. EXAMPLES 157

(a) (b)

Figure 8.7: Plots of cos θ from the beam axis for the process e−e+ → C+C− at Ce+ e1 e1 − + − + benchmark point SPS4. The plots correspond to (a) eL eR at a 500 GeV ILC (b) eReL − + − + at a 500 GeV ILC (c) eL eR at a 1 TeV ILC and (d) eReL at a 1 TeV ILC. CHAPTER 8. EXAMPLES 158

† ∗ T v (p2)c u (p3) u(p1) c v(p4) =  p p Eb ∗ (E3 + k)(E4 − k) (1 + cos θ)(1 − cos θ) LL   p −Eb ∗ (E3 + k)(E4 + k)(1 + cos θ) LR (8.20) p Eb ∗ (E3 − k)(E4 − k)(1 − cos θ) RL   p p −Eb ∗ (E3 − k)(E4 + k) (1 − cos θ)(1 + cos θ) RR and

† ∗ T v (p2)c u (p4) u(p1) c v(p3) =  p p Eb ∗ (E4 + k)(E3 − k) (1 − cos θ)(1 + cos θ) LL   p −Eb ∗ (E4 − k)(E3 − k)(1 + cos θ) LR (8.21) p Eb ∗ (E4 + k)(E3 + k)(1 − cos θ) RL   p p −Eb ∗ (E4 − k)(E3 + k) (1 + cos θ)(1 − cos θ) RR

+ − which would lead to an analogous forward peaking of the charginos, since the CL CR 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 eL eR amplitude. This diagram contributes an amplitude of

−ie2 iM = (v†(p )c u∗(p ) u(p )T c v(p )) (8.22) u − M 2 3 1 4 νee 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. Speciﬁcally

2 2 u = (k1 − k4) = M − 2k1 · k4 Ce1 2 = M − 2Ebeam(E4 + k cos θ) (8.23) Ce1 CHAPTER 8. EXAMPLES 159

cos Θ cos Θ -1.0 -0.5 0.0 0.5 1.0 -1.0 -0.5 0.0 0.5 1.0

(a) H L (b) H L

cos Θ cos Θ -1.0 -0.5 0.0 0.5 1.0 -1.0 -0.5 0.0 0.5 1.0

+ − + Figure 8.8: The nominal angular distribution of Ce various diagrams for eL eR → − Ce1 + Ce1 . 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.

For the LCC3 benchmark the νee 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 νee 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 νee 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 CHAPTER 8. EXAMPLES 160

two terms interfere in destructively interferes with the s channel terms the effect is quite dramatic, leaving a mostly backward angular distribution of the Ce+. The effect − + of the νee propagtor term on the eL eR 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 → Ce1 Ce1 example, considering the decay products of the Charginos. At the SPS4 benchmark point, the dominant decay + of the Ce1 is to a Ne1 and a W boson. If we consider the Ce1 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 Ce+. 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 + + WL → eL νe. To understand the source of the W + polarization we look at the masses and coupling of the Ce1 to the Ne1 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 CHAPTER 8. EXAMPLES 161

(a)

(b) (c)

(d) (e)

− + + − Figure 8.9: Plots for eReL → Ce1 Ce1 at a 500 GeV ILC collider at the benchmark point SPS4. (a) A plot of cos θ + from the beam axis in the lab frame. (b) A plot of Ce1 + cos θ + + in the rest frame of the Ce in the backward (cos θ + < −.8) region. (c) W ,Ce1 1 Ce1 + A plot of cos θ + + in the rest frame of the Ce in the forward (cos θ + > .8) region. W ,Ce1 1 Ce1 + (d) A plot of cos θ + in the rest frame of the Wf in the backward (cos θ + < −.8) f,Wf Ce1 + region. (e) A plot of cos θf,W + in the rest frame of the W in the forward (cos θ + > .8) Ce1 region. CHAPTER 8. EXAMPLES 162

(a)

(b) (c)

(d) (e)

− + + − Figure 8.10: Plots for eReL → Ce1 Ce1 at a 500 GeV ILC collider at the benchmark point SPS4. (a) A plot of cos θ + from the beam axis in the lab frame. (b) A plot of Ce1 + cos θ + + in the rest frame of the Ce in the backward (cos θ + < −.8) region. (c) W ,Ce1 1 Ce1 + A plot of cos θ + + in the rest frame of the Ce in the forward (cos θ + > .8) region. W ,Ce1 1 Ce1 + (d) A plot of cos θ + in the rest frame of the Wf in the backward (cos θ + < −.8) f,Wf Ce1 + region. (e) A plot of cos θf,W + in the rest frame of the W in the forward (cos θ + > .8) Ce1 region. CHAPTER 8. EXAMPLES 163

q iM(C+ → W + + N ) = iep2m −G∗ E + k e1L L e1L C1 N1C1W m Ne1L q √ +G E − k 1 + cos θ N1C1W p Ne1L √ E − k q iM(C+ → W + + N ) = ie m −G∗ W E − k e1L 0 e1R C1 N1C1W m Ne1L mW E + k q √ +G W E + k 1 + cos θ N1C1W p Ne1L mW √ E + k q iM(C+ → W + + N ) = ie m −G∗ W E + k e1L 0 e1L C1 N1C1W m Ne1L mW E − k q √ +G W E − k 1 − cos θ N1C1W p Ne1L mW q iM(C+ → W + + N ) = iep2m G∗ E − k e1L R e1R C1 N1C1W m Ne1L q √ −G E + k 1 − cos θ (8.24) N1C1W p Ne1L with the equations for a right handed Ce+ 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 eReL 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 eL eR and − + + eReL initial states in the lab frame, with a noticeable difference in the e angular distributions. The same effects should appear in the µ+ and τ + distributions. CHAPTER 8. EXAMPLES 164

cos Θ -1.0 -0.5 0.0 0.5 1.0

H L + Figure 8.11: Angular distribution of various decay helicity amplitudes for C1L at + SPS4. Black is the full decay angular distribution, red is the W0 Ne1L channel, orange + + + is the WR Ne1R channel, blue is the W0 Ne1R channel and green is the WL Ne1L channel. + The amplitudes for C1R replaces cos θ with − cos θ.

(a) (b) (c) (d)

(e) (f) (g) (h)

Figure 8.12: Plots of angular distribution in the lab frame CHAPTER 8. EXAMPLES 165

+ e b b ντ Ne 1

+ h0 + τ Ce1 e + τ + Ce2

− − τe Ce2 τ − C− ?h0 e1 e− ν b b τ Ne1 Figure 8.13: Feynman diagram of the full decay chain resulting from the process − + + − e e → Ce2 Ce2 at LCC3.

In many SUSY models there are extremely long chains of decays that can result in a very large number of ﬁnal 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 → Ce2 Ce2 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 Ce2 leg. All of these eﬀects are built up in pandora by simple recursion using the class structure described in Section 6. CHAPTER 8. EXAMPLES 166

+ Figure 8.14: Plot of the energy of each leg of the Ce2 decay chain in the process − + + − e e → Ce2 Ce2 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).

 T u (kj)cu(kk), j, k = 1, 2 • complex uu(int j, int k) = † ∗ u (kj)cu (kk), j, k = 3, 4  † ∗ v (kj)cv (kk), j, k = 1, 2 • complex vv(int j, int k) = T v (kj)cv(kk), j, k = 3, 4  T u (kj)cv(kk), j = 1, 2, k = 3, 4 • complex uv(int j, int k) = † ∗ u (kj)cv (kk), j = 3, 4, k = 1, 2  † ∗ v (kj)cu (kk), j = 1, 2, k = 3, 4 • complex vu(int j, int k) = T v (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)  T u (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. = T v (kj)cσ · (kk) σ · k` v(km), j, m = 3, 4k = 1, 2.

• complex uekv(int j, int k, int `, int m)  T u (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. = T v (kj)cσ · (kk) σ · k` u(km), j = 3, 4, m = 1, 2, k 6= j, m. APPENDIX A. INVARIANTS CLASSES 169

• complex ukeu(int j, int k, int `, int m)  T u (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. = T v (kj)cσ · (kk) σ · k` v(km), j, m = 3, 4` = 1, 2.

• complex ukev(int j, int k, int `, int m)  T u (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. = T v (kj)cσ · kk σ · (k`) u(km), j = 3, 4, m = 1, 2, ` 6= j, m.

• complex ueeu(int j, int k, int `, int m)  T u (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. = T v (kj)cσ · (kk) σ · (k`) v(km), j, m = 3, 4k, ` = 1, 2.

• complex ueev(int j, int k, int `, int m)  T u (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. = T v (kj)cσ · (kk) σ · (k`) u(km), j = 3, 4, m = 1, 2, k, ` 6= j, m. APPENDIX A. INVARIANTS CLASSES 170

• 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

T • complex vv(int j, int k) = v (kj)cv(kk), j, k = 1, 2  T u (kj)cv(kk), j= 0,k= 1, 2 • complex uv(int j, int k) = † ∗ u (kj)cv (kk), j= 1, 2,k= 0  † ∗ v (kj)cu (kk), j= 0,k= 1, 2 • complex vu(int j, int k) = T v (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. APPENDIX A. INVARIANTS CLASSES 171

† • 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) [arXiv:hep-ph/9311269].

[26] H. E. Haber, R. Hempﬂing and A. H. Hoang, Z. Phys. C 75, 539 (1997) [arXiv:hep-ph/9609331]. 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) [arXiv:hep-ph/9507378].

[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].