BAD 522 V6

EvtGen V00-11-06

EvtGen
A Monte Carlo Generator for B-Physics
Anders Ryd ([email protected])
David Lange ([email protected])
Natalia Kuznetsova ([email protected])
Sophie Versille ([email protected])
Marcello Rotondo ([email protected])
David Kirkby ([email protected])
Frank Wuerthwein ([email protected])
Akimasa Ishikawa ([email protected])
February 5, 2004

Abstract

This note describes EvtGen, an event generator that is well suited for B physics.
It implements many detailed models that are important for the physics of B mesons.
In particular, it has detailed models for semileptonic decays, CP -violating decays and
produces correct results for the angular distributions in sequential decays, including
all correlations. It also has an interface to JetSet for generation of continuum at the
Υ(4S) and for generic hadronic decays, e.g. of B mesons, that are not implemented in
the generator.

1
Contents
1 Introduction 7

2 EvtGen distribution 9
2.1 Get started with EvtGen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3 Particle properties in EvtGen 13

4 Decay tables in EvtGen 14

4.1 Guidelines to write decay files . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2 User decay files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

5 Algorithm 18

6 Particle representation 20

7 Decay models 22
7.1 Introduction to decay models . . . . . . . . . . . . . . . . . . . . . . . . . . 22
7.2 Creating new decay models . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
7.3 Example: EvtVSS model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
7.4 Example: EvtPi0Dalitz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.5 Model parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

8 Conventions 30
8.1 Units . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.2 Four-vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.3 Tensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.4 Dirac spinors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.5 Gamma matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

9 Classes 32
9.1 EvtAmp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
9.2 EvtCPUtil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.3 EvtComplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.4 EvtConst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
9.5 EvtDecayBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
9.6 EvtDiracSpinor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.7 EvtGammaMatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.8 EvtGen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.9 EvtGenKine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.10 EvtId . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.11 EvtKine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.12 EvtLineShape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

2
 9.13 EvtModel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.14 EvtPDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.15 EvtPHOTOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
9.16 EvtPartProp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
9.17 EvtParticle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
9.18 EvtParticleDecay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
9.19 EvtParticleDecayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
9.20 EvtParticleNum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
9.21 EvtParser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
9.22 EvtRandom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
9.23 EvtReadDecay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
9.24 EvtReport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
9.25 EvtResonance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
9.26 EvtSecondary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.27 EvtSpinDensity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
9.28 EvtSpinType . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
9.29 EvtStdHep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
9.30 EvtString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
9.31 EvtSymTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
9.32 EvtTemplateDummy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
9.33 EvtTensor3C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
9.34 EvtTensor4C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
9.35 EvtVector3C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
9.36 EvtVector3R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
9.37 EvtVector4C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
9.38 EvtVector4R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

10 CP Violation and Mixing 48

10.1 Mixing in the B 0 B̄ 0 System. . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
10.2 Mixing and Non-zero Lifetime Differences. . . . . . . . . . . . . . . . . . . . 49
10.3 CP-violation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
10.4 Special CP models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
10.5 Unified implementation of CP-violating and mixing . . . . . . . . . . . . . . 55
10.5.1 CP violation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
10.5.2 Mixing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

11 Semileptonic decays in EvtGen 57

11.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
11.2 Semileptonic conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
11.3 Semileptonic framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
11.4 Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
11.5 Available models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
11.5.1 EvtSLPole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

3
 11.5.2 EvtISGW2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
11.5.3 EvtISGW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
11.5.4 EvtHQET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

12 Lineshape determination (new 11/2002) 64

12.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.2 Lineshapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.2.1 What is the default? . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.2.2 Mass cutoffs, etc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12.2.3 What can be changed in user decay files? . . . . . . . . . . . . . . . . 65

A Decay models 71
A.1 BHADRONIC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
A.2 BTO3PI CP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
A.3 CB3PI-MPP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
A.4 CB3PI-P00 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
A.5 BTOKPIPI CP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
A.6 BTO4PI CP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
A.7 BTO2PI CP ISO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
A.8 BTOKPI CP ISO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
A.9 BTOXSGAMMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
A.10 D DALITZ; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
A.11 GOITY ROBERTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
A.12 HELAMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
A.13 HQET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
A.14 HQET2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
A.15 ISGW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
A.16 ISGW2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
A.17 JETSET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
A.18 JSCONT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
A.19 KLL3P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
A.20 KSLLLCQCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
A.21 KSLL3PQCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
A.22 LNUGAMMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
A.23 MELIKHOV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
A.24 OMEGA DALITZ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
A.25 PARTWAVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
A.26 PHSP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
A.27 PTO3P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
A.28 SINGLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
A.29 SLN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
A.30 SLPOLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
A.31 SSD CP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

4
 A.32 SSS CP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
A.33 SSS CP PNG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
A.34 STS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
A.35 STS CP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
A.36 SVP HELAMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
A.37 SVS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
A.38 SVS CP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
A.39 SVS CP ISO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
A.40 SVS NONCPEIGEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
A.41 SVV CP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
A.42 SVV CPLH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
A.43 SVS CPLH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
A.44 SVV NONCPEIGEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
A.45 SVV HELAMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
A.46 TAULNUNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
A.47 TAUSCALARNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
A.48 TAUVECTORNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
A.49 TSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
A.50 TVS PWAVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
A.51 VECTORISR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
A.52 VLL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
A.53 VSP PWAVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
A.54 VSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
A.55 VSS MIX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
A.56 VSS BMIX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
A.57 VVPIPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
A.58 VVS PWAVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
A.59 WSB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

B EvtGen interface 110

C Final state radiation 111

D Performance monitoring 112

D.1 Efficiency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

E Interface to JetSet 112

F Helicity amplitudes 112

F.1 Preliminaries and definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
F.2 Plane wave states . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
F.3 Helicity amplitudes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
F.4 Helicity amplitudes and sequential decays . . . . . . . . . . . . . . . . . . . . 117
F.4.1 Jackson convention . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

5
 F.4.2 Jacob-Wick convention . . . . . . . . . . . . . . . . . . . . . . . . . . 117
F.5 Explicit representations of SU(2) . . . . . . . . . . . . . . . . . . . . . . . . 118
F.5.1 J = 1/2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
F.5.2 J = 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
F.6 Projections of helicity amplitudes . . . . . . . . . . . . . . . . . . . . . . . . 119
F.7 Jacob-Wick transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
F.8 HELAMP and PARTWAVE model implementations . . . . . . . . . . . . . . . . . 120

G The routines decay angle and decay angle chi 121

H Optimizing EvtGen code 123

I Guidelines for coding in EvtGen 123

6
1 Introduction
There are several event generators available for simulation of particle decays in high energy
physics experiments. Examples used for the simulation of B-physics include the well known
packages QQ [1] and JETSET [2]. This paper describes a package that we hope will be a
useful tool for the simulation of decays of B mesons and other resonances. With several new
B physics experiments currently collecting data, the physics of B mesons will be studied in
greater detail than previously possible. It is important to have tools for the simulation of
the underlying physics processes at these experiments.
The EvtGen package provides a framework in which new decays can be added as modules.
These modules, which perform the simulation of decays, are called models in EvtGen. One
of the novel ideas in the design of EvtGen is that decay amplitudes, instead of probabilities,
are used for the simulation of decays. The framework uses the amplitude for each node in
the decay tree to simulate the entire decay chain, including all angular correlations. A few
examples of sequential decays are

B → D ∗
ν, B → D ∗
ν,
→Dπ →Dγ

B → D∗ D∗, B → D∗ D∗.
→Dπ→Dπ →Dπ→Dγ

For these decays, the EvtGen framework models all decay distributions correctly, while
implementing only the nodes (B → D ∗
ν, D ∗ → Dπ, etc.) of the decay trees. CP violating
decays have their own particular challenges, including non-trivial decay time distributions.
Examples of distributions from EvtGen for the decay B → J/ψK ∗ are shown in Figure 1.
This document will describe the functionality and organization of the EvtGen package.
Additionally, we will discuss how to use EvtGen, as well as how to implement new physics
models. EvtGen is written in C++, contains about 150 classes and 25000 lines of code.
There are approximately 70 models implemented that simulate a large variety of physics
processes. The modularity of the code allows for easy implementation of additional models.

7
 µ−
Ks 0 χ

o
θK*0 K* θJ/ Ψ z

B J/ Ψ

πo
µ+

Figure 1: The top diagram defines the angles in the decay B → J/ψK ∗ with J/ψ → µ+ µ−
and K ∗0 → KS0 π 0 . The lower four plots show projections of the distributions from an EvtGen
simulation of this decay. In this simulation the B meson was produced in an Υ(4S) decay
and ∆t is the difference in proper lifetimes of the two B mesons. The lower four plots shows
(from the upper left) the ∆t distribution, the χ angle distribution, χ vs. cos θK ∗ for ∆t < 0,
and χ vs. cos θK ∗ for ∆t > 0.

8
2 EvtGen distribution
For distribution of the EvtGen source outside of the BaBar experiment a tar file, EvtGen.tar,
containing the complete source, is available. This file can be obtained from
http://www.slac.stanford.edu/~lange/EvtGen
Here you will find the versions that are available and short descriptions of modifications and
improvements as well as known problems.
There are a handful of files other than the source files included in the EvtGen.tar file.
The functionality of the evt.pdl, DECAY.DEC, and Makefile files is described below. Ad-
ditionally, a test directory is included that provides several diagnostic tests of the EvtGen
library.
evt.pdl is needed at runtime by EvtGen, as it contains the list of particles and particle
properties to be used. This table is fully described in Section 3. Similarly, DECAY.DEC con-
tains the default list of decay channels, including branching ratios, as described in Section 4.
The Makefile is responsible for building the EvtGen library as well as test executables.
The unpacking of EvtGen.tar and the use of the Makefile are described in Section 2.1.
The directory test contains the files necesary to perform several tests of the EvtGen
code, as detailed in Section 2.1.

2.1 Get started with EvtGen

After unpacking the EvtGen.tar file, it is quite simple to get started with EvtGen. This
section describes the process of compiling and linking the code and running several simple
tests. Sample output of these tests are shown. Manipulating the output of EvtGen using
user decay files is also explained.
First, several envirnment variables are needed to setup the external packages. The list
below gives the envvar and an example setting:
1. CERN ROOT = /cern/pro

2. ROOT SYS = /home/lange/root

3. CLHEP BASE DIR = /home/lange (CLHEP in /home/lange/CLHEP and CLHEP

libs in /home/lange/lib)
To properly set up the Makefile, type configure. The configure script will ask sev-
eral questions, and then build the Makefile. The output of the configure script will look
something like the following:
lange@EvtGen>./configure
Welcome to configure for EvtGen
Deleting config.mk
This machine is running: Linux
Linux is supported.

9
Enter Name of c++ compiler (ie c++,cxx,CC, etc)
gcc-3.2.1
Will use gcc-3.2.1 for compilation of C++ code
Enter name of fortran comiler
f77
Will use f77 for compilation of fortran code
The EvtGen package uses photos and pythia from cernlib: Please set CERN_ROOT if not alrea
The EvtGen package uses root for histograming. Please set ROOTSYS if not already
The EvtGen package relies on CLHEP. Please set CLHEP_BASE_DIR if not already
Finding compiler includes

The gcc-3.2.1 compiler includes are

-Iignoring -Inonexistent -Idirectory -I"/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.2.1/in
The default gcc-3.2.1 options are
-I. -DEVTSTANDALONE
Enter any other options that you would like
to use in compilation. Examples -g -pg -o4 etc
The following options will be used by default
-I. -DEVTSTANDALONE
The default link options are
for the test program.
Please enter any others that you would like to use

Done. Type gmake lib then gmake bin

The configure script builds a file called config.mk that is included by the Makefile.
To build the EvtGen libary simply type gmake in the EvtGen directory. This should
compile each .cc file and make a library called libEvtGen.a. If this fails to compile on your
platform, please contact the authors for help.
To compile EvtGen with no changes, the JETSET [2] and PHOTOS [3] packages from
CERNLIB are needed, as well as the CLHEP [4] and ROOT [5] packages. A version of
lucomp.F is included that defines additional particles used by EvtGen. The dependence on
ROOT is solely for the histograming performed in the testEvtGen test program. If you do
not need this feature it is easy to eliminate this dependence.
The most recent version has been tested using gcc-3.2.1, CERNLIB 2000, CLHEP 1.8.0.0,
and ROOT 3.01.02. The only change from the default installations is that a softlink to
libCLHEP.a was created to libCLHEP-g++.a. The need for this change can be eliminated
by changing the Makefile in EvtGen.
If the library was built successfully, type gmake bin in order to build a sample executable
(called testEvtGen). With this executable, several tests of the EvtGen library may be
performed to check that the code is working properly. To do these type
cd test
../testEvtGen test1 20000

10
 El hEl q2 hq2
Nent = 20000 Nent = 20000
1000 Mean = 1.491 Mean = 5.164
RMS = 0.4153 600 RMS = 2.769

800 500

400
600

300
400
200

200
100

0 0
0 0.5 1 1.5 2 2.5 0 2 4 6 8 10

[h] for cos[Q]V"L0 hcostv1 [h] for cos[Q]V"G0 hcostv2

Nent = 9969 Nent = 10031
Mean = 3.154 Mean = 3.157
250 RMS = 1.684 250 RMS = 1.888

200 200

150 150

100 100

50 50

0 0
0 1 2 3 4 5 6 0 1 2 3 4 5 6

Figure 2: Histogram number 3 in test1.root for 1000 events shows the lepton energy in
the B → D ∗
ν decay.

../testEvtGen ddalitz 20000

The test directory should now contain test1.root and ddalitz.root, each of which are
ROOT files containing several histograms. Figures 2 and 3 show some of these histograms.
These Figures can be reproduced using test1-root.script and ddalitz-root.script.

11
 2 2
m[K-[p]+ vs m[K-[p]0 h1
Nent = 20000
3.5
Mean x = 1.621
Mean y = 1.483
3 RMS x = 0.8587
RMS y = 0.8507

2.5

1.5

0.5

0
0 0.5 1 1.5 2 2.5 3 3.5

Figure 3: Histogram number 1 in ddalitz.root for 20000 event shows the dalitz plot for
the D → Kππ decay.

12
3 Particle properties in EvtGen
In EvtGen, all particle property information is contained within evt.pdl and is parsed at
runtime. Each line in evt.pdl corresponds to a particle, and has the form

add p Lepton mu- 13 0.1056584 0 0 -3 1 658654. 13

add p Lepton mu+ -13 0.1056584 0 0 3 1 658654. 0
add p Meson pi+ 211 0.139570 0 0 3 0 7804.5 101
add p Meson pi- -211 0.139570 0 0 -3 0 7804.5 0
add p Meson rho+ 213 0.7685 0.151 0.4 3 2 0 121
add p Meson rho- -213 0.7685 0.151 0.4 -3 2 0 0
add p Meson D0 421 1.86451 0 0 0 0 0.1244 105
add p Meson anti-D0 -421 1.86451 0 0 0 0 0.1244 0

The first three columns are not used in EvtGen. The fourth column corresponds to the
particle name. The fifth column is the particle number according to the stdhep numbering
scheme. The sixth through eighth columns contain the mass, width, and maximum allowed
deviation from the mean mass in the downward direction, respectively. The nineth column
contains 3 times the charge of the particle. The tenth column contains twice the spin. The
eleventh column is cτ in mm. The twelvth column is the Lund-KC number. This is used for
the interface to JetSet and has to match what is in lucomp.F.

13
4 Decay tables in EvtGen
The decay table included in the EvtGen package, DECAY.DEC, provides an extensive list
of decays for resonances below the Υ(4S). However, the table is updated with available
experimental and theoretical information on a regular basis. To describe the format of the
decay table consider the decay of a D ∗+ meson

Decay D*+
0.67 D0 pi+ VSS;
0.33 D+ pi0 VSS;
Enddecay

A decay entry starts with the keyword “Decay” and ends with “Enddecay”. Throughout the
decay table, capitalization is important. Decay channel entries are separated by “;”. There
are three main components needed to specify a decay channel. First the branching ratio is
given, followed by the list of final state particles. Finally the model used to simulate the
decay is specified. For many models, the order of final state particles is important. The
correct order for each model can be found in the DECAY.DEC provided, or in Section A of
this documentation. Details on available models can be found in Section A.
Certain models also take arguments, as in the case of the decay B 0 → π + π −

Decay B0
1.00 pi+ pi- SSS_CP dm alpha 1 1.0 0.0 1.0 0.0;
Enddecay

The meaning of these arguments are explained in Section A.

The above example also shows the use of constants defined in the decay table, in this
case “dm” and “alpha”. The syntax for defining constants is

Define alpha 0.9

Note that a “Define” statement can not be within a “Decay-Enddecay” statement and also
must precede the first use of the constant that it defines. If a constant is redefined, the
last value defined before the use in the decay table is used. To illustrate this consider the
following example

Define alpha 0.9

Decay B0
1.00 pi+ pi- SSS_CP dm alpha 1 1.0 0.0 1.0 0.0;
Enddecay
Define alpha 1.1
Decay B0B
1.00 pi+ pi- SSS_CP dm alpha 1 1.0 0.0 1.0 0.0;
Enddecay

14
Here the decay of the B 0 will use α = 0.9 while the B̄ 0 decay will use α = 1.1. This means,
in particular, that you can not create user decay files that change parameter values to change
the default decay table settings after the default decay table has been parsed.
Once the decay channels of a particle (eg, a D 0 ) have been specified, the decay channels
of the charge conjugate particle (D̄ 0 ) can be specified using the syntax

CDecay anti-D0

Another feature is that particle aliases may be defined. These aliases are useful for various
reasons, including the generation of Monte Carlo for special signal channels. Consider the
case of Monte Carlo for the decay B 0 → J/ΨKs0 with J/Ψ → µ+ µ− . Not all J/Ψ mesons in
the event should decay to µ+ µ− , only the ones in the signal mode. The concept of particle
aliases solves this problem. Consider the example

Alias myJ/psi J/psi

Decay B0
1.00 myJ/psi K_S0 SVS_CP dm beta 1.0 1.0 0.0 1.0 0.0;
Endedecay
Decay myJ/psi
1.00 mu+ mu- VLL;
Enddecay

Here, myJ/psi has been created to alias the J/psi. Inside the generator, myJ/psi is treated
as a new particle, with the same properties as the J/psi, except for its decay channels. This
includes the particle name and number, such that at the end of each event, the output will
contain the chain B 0 → J/ΨKs0 , J/Ψ → µ+ µ− . There is no need for user analysis code to
know about myJ/psi.
There is one small complication related to aliased particles involving the CDecay feature
described above.
Sometimes it is necesary to define the charge conjugate of an alias. This is used, for
example by the CDecay feature. To use this feature with aliases, you must specify the charge
conjugate state for each alias. If you alias a particle that is its own charge conjugate, (eg, a
π 0 ) the aliased particle will be its own charge conjugate. However, in the case of the alias
mypi+, which represents pi+, a charge conjugate alais mypi- must be defined and you will
need to tell the generator that the charge conjugate of mypi- is mypi+:

ChargeConj mypi+ mypi-

The charge conjugate of mypi+ can not be defined to be pi-.

Final state radiation using the PHOTOS [3] package may be included in each decay. This
option is invoked by the key word PHOTOS, which is placed after the list of decay daughters,
but before the model name. See Appendix C for more details.
The keyword JetSetPar allows for manipulation of parameters in the JETSET common
blocks using the lugive subroutine. For example, to set the parameter MSTJ(26)=0 (this
turns off B 0 -B̄ 0 mixing in JetSet) the line

15
JetSetPar MSTJ(26)=0

is added to the decay table. Note that no spaces are allowed in the string that is passed to
lugive. This is due to a limitation of how the decay table is parsed by EvtGen. The setting
of a global parameter, illustrated by JetSetPar, is a general feature that any decay model
can implement. This is discussed further in Section 7.5.

4.1 Guidelines to write decay files

There are several things to know when writing a decay table:

• The decay table must end with End. This is also true for user decay tables as described
in Section 4.2.

• Everything in the decay table is case sensitive.

• Charge conservation will be checked on each decay in the decay table.

• Each parent and daughter particle must be contained in evt.pdl.

• Most models included in the EvtGen package will check that the number of daughters
as well as the spin of each daughter are correct.

• The number of arguements provided must be the same as is expected by the model.

• If the sum of branching ratios in the decay channels for a particle do not sum to 1.0,
they will all be rescaled so that the sum is 1.0.

• Any line beginning with “#” is considered a comment.

4.2 User decay files

In addition to changing DECAY.DEC, the output of EvtGen may be controlled via a user decay
file. We now give several examples of how to configure a user decay table. Many details of
decay tables have already been discussed above.
As the first example, consider generating Υ(4S) → B + B − , B + → D ∗0 e+ νe with D ∗0 →
D̄ 0 π 0 and D̄ 0 → K + π − . The other B from the Υ(4S) decays generically.
The standard way of running EvtGen begins with parsing the full standard decay table,
DECAY.DEC. After this, a user decay table is parsed in order to redefine the particle decays
of interest. This way, the user decay file will override the standard decay table.
In the example above, the user decay table could be implemented as:

# Ups(4S)->B+ B-
# | |-> generic
# |->D*0 e+ nu_e
# |->D0B pi0

16
# |->K+pi-
#
Alias myD*0 D*0
Alias my-anti-D0 anti-D0
#
Decay Upsilon(4S)
1.000 B+ B- VSS;
Enddecay
#
Decay B+
1.000 my-anti-D*0 e+ nu_e ISGW2;
Enddecay
#
Decay my-anti-D*0
1.000 my-anti-D0 pi0 VSS;
Enddecay
#
Decay my-anti-D0
1.000 K+ pi- PHSP;
Enddecay
#
End

The decay of the Υ(4S) is redefined. In the default decay table it is defined to decay to
a proper mixture of charged and neutral B mesons. Note that when a Decay statement is
found for a particle, it erases all previous decays that have been defined for that particle.
The Υ(4S) above is redefined such that it decays into a B + and a B − 100% of the time.
The B − decay is not redefined and hence it decays generically according to the entries in
DECAY.DEC. However, the B + is redefined such that it is forced to decay semileptonically
according to the model of ISGW2. (For more information about details about what different
models do, see Appendix A.)
Another use of user decay files is to make a particle stable (if, for example, its decay is
uninteresting for your purpose). To make a KS stable do

Decay K0S
Enddecay

Anders, add b0b0bar mixing example

17
5 Algorithm
To illustrate how the event selection algorithm works consider the decay B → D ∗ τ ν̄, D ∗ →
Dπ, and τ → πν. The general case is a straight forward generalization of this example. The
decay amplitude can be written as

∗ ∗
→Dπ
A= AB→D
λD ∗ λτ
τν
× AD
λD ∗ × Aτλ→πν
τ
, (1)
λD ∗ λτ

where λD∗ and λτ label the states of spin degrees of freedom of the D ∗ and the τ , respec-
∗τ ν
tively. Thus, AB→D
λD ∗ λτ represents the decay amplitude for B → D ∗ τ ν for the six different
combinations of D ∗ and τ states.
A possible implementation of Eq. 1 is to generate kinematics according to phase space
for the entire decay chain and to calculate the probability, the amplitude squared, which is
used in an accept-reject algorithm. This approach has two serious limitations. First, the
maximum probability of the decay chain must be known. This is logicistally difficult given
the large number of potential decay chains in B decays. Second, for long decay chains the
accept-reject algorithm can be very inefficient as the entire chain must be regenerated if
the event is rejected. We have implemented an algorithm that generates a decay chain as a
sequence of sub-decays, thus avoiding both of these limitations.
First the decay of the B is considered. Kinematics are generated according to phase
space and the probability is calculated

∗
τν 2
PB = |AB→D
λD ∗ λτ |. (2)
λD ∗ λτ

The kinematics are regenerated until the event passes an accept-reject algorithm based on
PB . After decaying the B we form the spin density matrix
∗
∗ ∗τ ν
ρD
λ λ
 = AB→D
λD ∗ λτ
τν
[AB→D

λ λ
]∗ , (3)
D∗ D∗ D∗ τ
λτ

which describes a D ∗ from the B → D ∗ τ ν decay after summing over the degrees of freedom
∗
for the τ . To generate the D ∗ → Dπ decay, proceed as with the B, including also ρD
1
∗ →Dπ ∗ ∗ →Dπ
PD ∗ = ρD  AD [AD ]∗ , (4)
Tr ρD∗ 
λ λ
D∗ D∗
λD ∗ λ D∗
λD ∗ λD ∗

∗
where the scale factor, 1/Tr ρD , is proportional to the decay rate, and does not affect the
angular distributions. This scale factor makes the maximum decay probability of each sub-
decay independent of the full decay chain.
Finally, we decay the τ . We form the density matrix
∗ ∗ ∗ →Dπ
ρ̃D
λ λ
 = AλDD∗→Dπ [AD
λ
 ]∗ , (5)
D∗ D∗ D∗

18
which encapsulates the information about the D ∗ decay needed to properly decay the τ with
∗
the full correlations between all kinematic variables in the decay. Using the ρ̃D matrix we
calculate the spin density matrix of the τ

∗ ∗ ∗τ ν
ρτλ  = ρ̃D  AB→D
λD ∗ λτ
τν
[AB→D

λ λ
]∗ . (6)
τ λτ λ λ
D∗ D∗ D∗ τ

λD ∗ λD ∗

As in the other decays, kinematics are generated according to phase space and the accept-
reject is based on the probability calculated as in Eq. 4, replacing D ∗ with τ .
The algorithm was illustrated above using an example which should convey the idea. In
general consider the decay
A → B1 B2 ...BN (7)
where the amplitudes are denoted by

AA→B 1 B2 ...BN
λA λB λB ...λB . (8)
1 2 N

The probability for, PA , for this decay is given by

A→B1 B2 ...BN A→B1 B2 ...BN ∗
PA = ρA
λA λA AλA λB λB ...λB [Aλ λB λB ...λB ] . (9)
1 2 N A 1 2 N
λA λA λB1 ...λBN

The forward spin-density matrix ρBi , given that Bj , j < i, have been decayed and have
backward spin-density matrices ρ̂Bj , is given by

B ∗
ρBi
λB λ = ρA B1
λA λA ρ̂λB λ ...ρ̂λBi−1 λB AA→B 1 B2 ...BN A→B1 B2 ...BN
λA λB λB ...λB [Aλ λ ...λ λB ...λBN ] .
i Bi 1 B1 i−1 i−1 1 2 N A B1 Bi i+1
λA λ λB ...λB
A 1 N
λ ...λ
B1 Bi−1

(10)
After all Bi are decays the backward spin-density matrix is given by

A→B1 B2 ...BN ∗
ρ̂A
λA λ = ρ̂B1
λB λ ...ρ̂BN
λB λB AA→B 1 B2 ...BN
λA λB λB ...λB [Aλ λ ...λ ] . (11)
A 1 B1 N N 1 2 N A B1 BN
λB ...λB
1 N
λ ...λ
B1 BN

19
6 Particle representation
Particles with spin up to spin 2, with the exception of spin 3/2, are handled by classes
within the framework of EvtGen.1 This section will describe how spin degrees of freedom
are represented, and will introduce the classes that represent particles in EvtGen. Table 1
summarizes the different types of particles currently implemented.

Class name Rep. J States Example

EvtScalarParticle 1 0 1 π, B 0
EvtDiracParticle uα 1/2 2 e, τ
EvtNeutrinoParticle uα 1/2 1 νe
EvtVectorParticle µ 1 3 ρ, J/Ψ
EvtPhotonParticle µ 1 2 γ
EvtTensorParticle T µν 2 5 D2∗ , f2

Table 1: The different types of particles that supported by EvtGen. The spin 3/2, Rarita-
Schwinger, representation has not yet been implemented.

In Table 1, uα represents a four component Dirac spinor, defined in the Pauli-Dirac

convention for the gamma matrices, as discussed in Section 8.4. The EvtDiracParticle
class represents massive spin 1/2 particles that have two spin degrees of freedom. Neutrinos
are also represented with a 4-component Dirac spinor by the EvtNeutrinoParticle class.
Neutrinos are assumed to be massless and only left handed neutrinos and right handed
anti-neutrinos are considered.
The complex 4-vector µ is used to represent the spin degrees of freedom for spin 1
particles. Massive spin 1 particles, represented by the EvtVectorParticle class, have three
degrees of freedom. The EvtPhotonParticle class represents massless spin 1 particles, which
have only two (longitudinal) degrees of freedom.
Massive spin 2 particles are represented with a complex symmetric rank 2 tensor and are
implemented in the EvtTensorParticle class.
For each particle initialized in EvtGen, a set of basis states is created, where the number
of basis states is the same as the number of spin degrees of freedom. These basis states can be
accessed through the EvtParticle class in either the particle’s rest frame or in the parent’s
rest frame. For massless particles, only states in the parent’s rest frame are available. As an
example, consider the basis for a massive spin 1 particle in it’s own rest frame

µ1 = (0, 1, 0, 0), (12)

µ2 = (0, 0, 1, 0), (13)
µ3 = (0, 0, 0, 1). (14)
1
Other particles will be added as need arises.

20
Note that these basis vectors are mutually orthogonal, and normalized. That is,

gµν ∗µ ν
i j = δij . (15)

Further, they form a complete set

∗µ
 νi i = g µν − pµ pν /m2 , (16)
i

where g µν − pµ pν /m2 is the propagator for an on-shell spin 1 particle.

In order to write a new decay model, there is no reason to need to know the exact choice
of these basis states. The code needed to describe the amplitude for a decay process is
independent of these states, as long as they are complete, orthogonal and normalized.

21
 EvtDecayBase

EvtDecayAmp EvtDecayProb EvtDecayIncoherent

EvtVSS EvtPHSP
EvtPi0Dalitz
EvtISGW2 EvtJetSet

Figure 4: Diagram of the EvtDecayBase class and classes derived from it. EvtDecayAmp,
EvtDecayTBaseProb, and EvtDecayIncoherent are templated classes that are used by mod-
ules that compute the full decay amplitude, that compute the decay probability, and those
that return unpolarized daughters, respectively.

7 Decay models
7.1 Introduction to decay models
Anders put text here...
Each decay model is a class that is derived from the base class EvtDecayBase, as shown
in Figure 4. Models may handle many different decays, or might be specialized for one
special decay. An example of a model that can handle many different decays is the VSS
model, which decays a vector meson to a pair of scalar particles. For example, the decays
D ∗ → Dπ and ρ → ππ are handled by this model. An example of a highly specialized model
is BTO4PICP, which describes the decay B → π + π − π + π − .

7.2 Creating new decay models

To simplify the writing of decay models there are three different classes that are derived from
EvtDecayBase. These are EvtDecayAmp, EvtDecayProb, and EvtDecayIncoherent. When
writing decay models it is most convenient to derive from one of these classes. These classes
have slightly different interfaces depending on what information the decay model provides.
Some models will provide the complete amplitude information where as other models might
provide just a probability or a set of four-vectors. Models that don’t provide the full set of

22
amplitudes will of course not be able to simulate the complete angular distributions. Below,
a short description is given to explain when you want to use each of these classes as the base
class for your decay model.

• EvtDecayAmp allows you to specify the complete amplitudes and hence do a complete
simulation of the angular distributions.

• EvtDecayProb allows you to calculate a probability for the decay. This probability
is then used in the accept-reject method. Any spin information is lost, all produced
particles are unpolarized and uncorrelated.

• EvtDecayIncoherent just accepts the four vectors as generated. This is most useful
when interfacing to another generator, e.g. JetSet. Any spin information is lost, all
produced particles are unpolarized and uncorrelated.

7.3 Example: EvtVSS model

In writing a decay model there are five member functions that need to be implemented. To
illustrate this, we show the EvtVSS model as an example.

//--------------------------------------------------------------------------
//
// Environment:
// This software is part of the EvtGen package developed jointly
// for the BaBar and CLEO collaborations. If you use all or part
// of it, please give an appropriate acknowledgement.
//
// Copyright Information:
// Copyright (C) 1998 Caltech, UCSB
//
// Module: EvtGen/EvtVSS.hh
//
// Description:
//
// Modification history:
//
// DJL/RYD August 11, 1998 Module created
//
//------------------------------------------------------------------------

#ifndef EVTVSS_HH
#define EVTVSS_HH

#include "EvtGen/EvtDecayAmp.hh"
#include "EvtGen/EvtParticle.hh"

class EvtVSS:public EvtDecayAmp {

public:

23
 EvtVSS() {}
virtual ~EvtVSS();

EvtDecayBase* clone();
void getName(EvtString& name);

void init();
void initProbMax();
void decay(EvtParticle *p);
};

#endif

The constructor and destructor in this example are emtpy. The virtual destructor must
be implemented in the .cc file, and is not shown.
The simplest method to implement is the clone() method, which is used to create an
instance of a model each time the it is used in the decay table. This is done using the
prototype pattern [6]. The implementation of the clone() method in the EvtVSS module is

EvtDecayBase* EvtVSS::clone(){
return new EvtVSS;
}

The getName method specifies the name of the module, and is used when parsing the
decay table. The EvtReadDecay class searches for a match between the models in the decay
table and the names stored by each implemented module using the getName function. For
the EvtVSS class, the implementation of getName is

void EvtVSS::getName(EvtString& model_name){

model_name="VSS";
}

The initProbMax member function sets the maximum probability that can be obtained
by the model in any decay. This maximum probability is used by the EvtGen framework in
its decision to keep or reject a decay based on the decay amplitude or probability computed
by the model. The maximum probability should be chosen such that it is truely a maximum.
However, the larger the maximum probability as compared to the true maximum, the less
efficient the model will be. During the generation of events, if the calculated probability is
greater than the maximum probability, a warning is printed.
When particles of finite width are present in the decay tree, it may be difficult to efficiently
set the maximum probability, as the true maximum may depend on the mass of the wide
particle. When this is the case, the model will still give correct output. However it will be
very inefficient and may get into semi-infinite loops for extreme mass configurations. Care
should be taken in the implementation of decay amplitudes so that this is not the case.
The maximum probability is set by calling setProbMax(prbmax) method, which is a
member function of EvtDecayBase.

24
void EvtVSS::initProbMax() {
setProbMax(1.0);
}

Models that can handle many different decays may have different maximal probabilities
depending on what initial and final state is being generated. To accomadate such mod-
els, the parent and daughter information (ndaug, parent, narg, daug, args from the
EvtDecayBase base class) can be accessed to calculate the maximum probabilites.
During development of a model it is often convenient not to implement the initProbMax
function. If this function is not implemented, a default maximum probability is found by
calling the model 500 times and using the largest value of the probability in these 500
tries. For a production Monte Carlo, this is not an acceptable way of determining the
maximum probability, as during the first call to the model, random numbers will be used
when performing the 500 iterations. This way, the output of the Monte Carlo will depend
on the starting event, not just the random number seed. There is a strict requirement on
EvtGen that given the random number seed at the start of the event the same decay must
be obtained independently of previous events.
The init method is a generic initialization function that will be called once for each occu-
rance of the decay model in the decay file. The init function allows modules to precompute
quantities, for example to process the arguments of the model into a more convenient form.
For many of the models currently implemented, the init function is used to check consis-
tency between the number of arguments in the decay table and that expected by the model.
The init method for the EvtVSS class is shown below.

void EvtVSS::Init(){

// check that there are 0 arguments

if (getNArg()!=0) {

report(ERROR,"EvtGen") << "EvtVSS generator expected "

<< " 0 arguments but found:"<<getNArg()<<endl;
report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
::abort();

}
if ( getNDaug()!=2) {
report(INFO,"EvtGen") << getNDaug() <<" "<<EvtPDL::name(getDaug(0))<<endl;
report(ERROR,"EvtGen") << "EvtVSS generator expected "
<< " a 2 daughters, found:"<<
getNDaug()<<endl;
report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
::abort();
}

EvtSpinType::spintype parenttype = EvtPDL::getSpinType(getParentId());

EvtSpinType::spintype d1type=EvtPDL::getSpinType(getDaug(0));
EvtSpinType::spintype d2type=EvtPDL::getSpinType(getDaug(1));

25
 if ( parenttype != EvtSpinType::VECTOR ) {
report(ERROR,"EvtGen") << "EvtVSS generator expected "
<< " a VECTOR parent, found:"<<
EvtPDL::name(getParentId())<<endl;
report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
::abort();
}
if ( d1type != EvtSpinType::SCALAR ) {
report(ERROR,"EvtGen") << "EvtVSS generator expected "
<< " a SCALAR 1st daughter, found:"<<
EvtPDL::name(getDaug(0))<<endl;
report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
::abort();
}
if ( d2type != EvtSpinType::SCALAR ) {
report(ERROR,"EvtGen") << "EvtVSS generator expected "
<< " a SCALAR 2nd daughter, found:"<<
EvtPDL::name(getDaug(1))<<endl;
report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
::abort();
}

Finally, we describe the decay member function. This method does the actual work
of decaying the particle, including the generation of kinematics as well as the amplitude or
probability calculation. For the EvtVSS class, the amplitude for the decay of a vector particle
into two scalar particles can be written as

A = εµ v µ , (17)

where εµ is the polarization vector for the vector particle and v is the four velocity of the
first scalar particle. This amplitude is implemented as

void EvtVSS::Decay( EvtParticle *p){

p->initializePhaseSpace(getNDaug(),getDaugs());

EvtVector4R pdaug = p->getDaug(0)->getP4();

double norm=1.0/pdaug.d3mag();

vertex(0,norm*pdaug*(p->eps(0)));
vertex(1,norm*pdaug*(p->eps(1)));
vertex(2,norm*pdaug*(p->eps(2)));

return;
}

26
 The argument of the decay member function is a pointer to the particle that should be
decayed. The first thing that is done is to create the the daughter particles and to link these
particles onto the decay tree. This is done by the EvtParticle::initializePhaseSpace
member function. The arguments to this method are the number and list of daughters,
as specified in the decay table. The initializePhaseSpace function generates kinematics
according to phase space.
For models that use the class EvtDecayAmp, an amplitude for every possible set of set
states should be computed. For EvtVSS, these amplitudes are calculated according to Eq. 17.
These amplitudes are then saved using the vertex member function. The first argument is
the index of the basis vector used to compute the amplitude. The EvtDecayAmp header file
shows how this syntax generatizes when more than one nontrival spin is invovled (as is the
case for B → D ∗
ν, for example).
void vertex(int i1, const EvtComplex& amp)
void vertex(int i1, int i2, const EvtComplex& amp)
void vertex(int i1, int i2, int i3, const EvtComplex& amp)

After computing the amplitude, the decay function returns and the amplitudes are used
in an accept-reject test. If failed, the decay method is called once more and a new kinematic
configuration is generated and new amplitudes are calculated.

7.4 Example: EvtPi0Dalitz

For models which derive from EvtDecayProb or EvtDecayIncoherent classes, the decay
function is slightly different. As an example of a model derived from the EvtDecayProb
class, we show the PI0DALITZ model:

//--------------------------------------------------------------------------
//
// Environment:
// This software is part of the EvtGen package developed jointly
// for the BaBar and CLEO collaborations. If you use all or part
// of it, please give an appropriate acknowledgement.
//
// Copyright Information:
// Copyright (C) 1998 Caltech, UCSB
//
// Module: EvtPi0Dalitz.cc
//
// Description: pi0 -> e+ e- gamma
//
// Modification history:
//
// DJL/RYD June 30, 1998 Module created
//
//------------------------------------------------------------------------
//
#include <fstream.h>
#include <stdio.h>

27
#include "EvtGen/EvtString.hh"
#include "EvtGen/EvtGenKine.hh"
#include "EvtGen/EvtParticle.hh"
#include "EvtGen/EvtPDL.hh"
#include "EvtGen/EvtReport.hh"
#include "EvtGen/EvtPi0Dalitz.hh"
#include "EvtGen/EvtVector4C.hh"
#include "EvtGen/EvtDiracSpinor.hh"

//code left out

void EvtPi0Dalitz::decay( EvtParticle *p){

EvtParticle *ep, *em, *gamma;

p->makeDaughters(getNDaug(),getDaugs());
ep=p->getDaug(0);
em=p->getDaug(1);
gamma=p->getDaug(2);

double mass[3];

double m = p->mass();

findMasses( p, getNDaug(), getDaugs(), mass );

EvtVector4R p4[3];

setWeight(EvtGenKine::PhaseSpacePole
(m,mass[0],mass[1],mass[2],0.00000002,p4));

ep->init( getDaug(0), p4[0] );

em->init( getDaug(1), p4[1]);
gamma->init( getDaug(2), p4[2]);

//ep em invariant mass^2

double m2=(p4[0]+p4[1]).mass2();
EvtVector4R q=p4[0]+p4[1];
//Just use the prob summed over spins...

EvtTensor4C w,v;

v=2.0*(p4[2]*q)*directProd(q,p4[2])
- (p4[2]*q)*(p4[2]*q)*EvtTensor4C::g()
-m2*directProd(p4[2],p4[2]);

w=4.0*( directProd(p4[0],p4[1]) + directProd(p4[1],p4[0])

-EvtTensor4C::g()*(p4[0]*p4[1]-p4[0].mass2()));

28
 double prob=(real(cont(v,w)))/(m2*m2);
prob *=(1.0/( (0.768*0.768-m2)*(0.768*0.768-m2)
+0.768*0.768*0.151*0.151));

setProb(prob);

return;
}
}

Instead of the vertex function in EvtVSS, the π 0 Dalitz model returns a single probabiltiy
using the setProb member function.
Finally we show the implementation of the decay member function in the PHSP model,
which derives from the EvtDecayIncoherent class.
void EvtPhsp::Decay( EvtParticle *p ){

p->initializePhaseSpace(ndaug,daug);
return ;
}

In this case, the decay function must only initialize the daughters and add them to the
particle tree.
In order to write new decay models, it is also necessary to know some of the syntax for
finding momenta and spin basis vector information for a given particle. This is discussed in
Section 9.

7.5 Model parameters

In Section 4 the feature of parameters for a model was introduced. In particular, JetSetPar
is an example of the mechanism that allows any model to set parameters. To make use of
this, the methods

EvtString commandName();
void command(EvtString cmd);

must be implemented within the model. The commandName method returns a string that
contains the identifier to be searched for in the decay table. In the case of the JetSet model,
this was JetSetPar. It is encouraged that this string start with the model name, such that
it is obvious to which model the parameter belongs. When the decay table is parsed, the
method command is called with the string found in the decay table as the argument. This
function is invoked on the prototype object. Thus, any data that is obtained through this
mechanism should be stored in a static variable such that it is common to all instances of
the model.

29
8 Conventions
This section discusses the conventions we use for various physics quantities in the code.

8.1 Units
In EvtGen, c = 1, such that mass, energy and momentum are all measured in units of GeV.
Similarly, time and space have units of mm.

8.2 Four-vectors
There are two types of four-vectors used in EvtGen, EvtVector4R and EvtVector4C, which
are real and complex respectively.
A four-vector is represented by pµ = (E, p). When a four-vector is used its components
are always corresponding to raised indices. A contraction of two vectors p and k (p*k)
automatically lowers the indices on k according to the metric g = diag(1, −1, −1, −1) so
that p*p is the mass squared of a particle with four-momentum p.

8.3 Tensors
We currently only support complex second rank tensors. As in the case of vectors, tensors
are always reperesented with all indices raised. The convention for the totaly antisymmetric
tensor, αβµν , is 0123 = +1.

8.4 Dirac spinors

Dirac spinors are represented as a 4 component spinor in the Dirac-Pauli representation,
with initial state fermions or final state anti-fermions.

8.5 Gamma matrices

Dirac gamma matrices are also represented in the Dirac-Pauli representation, which has

   
1 0 0 0 0 0 0 1
 0 1 0 0   0 0 1 0 
   
γ0 =  , γ1 =  , (18)
 0 0 −1 0   0 −1 0 0 
0 0 0 −1 −1 0 0 0
   
0 0 0 −i 0 0 1 0
 0 0 i 0   0 0 0 −1 
   
γ2 =  , γ3 =  . (19)
 0 i 0 0   −1 0 0 0 
−i 0 0 0 0 1 0 0

30
This gives  
0 0 1 0
i  0 0 0 1 
 
γ 5 = iγ 0 γ 1 γ 2 γ 3 = λµνπ γ λ γ µ γ ν γ π =  . (20)
4!  1 0 0 0 
0 1 0 0

31
9 Classes
This section describes the classes in the EvtGen package, except for the classes are models;
these are described separately in Appendix A.

9.1 EvtAmp
This class keeps track of the amplitudes computed by the decay models. It provides member
functions to calculate spin-density matrices from the amplitudes, as described in section 5.
The only member functions that a user writing decay models should need to use are the
vertex functions that allow you to set the amplitudes that are calculated in a decay model

• void vertex(const EvtComplex& amp)

Sets the amplitude in a decay where all particles, both in the initial and final state,
have only one spin degree of freedom.

• void vertex(int i1, const EvtComplex& amp)

Sets the amplitude when one particle has more than one spin degree of freedom.

• void vertex(int i1, int i2, const EvtComplex& amp)

Sets the amplitudes in a decay with two particles having non-trivial spin.

• void vertex(int i1, int i2, int i3, const EvtComplex& amp)
Sets the amplitudes in a decay with three particles having non-trivial spin.

• there is also a general case – Need to fix and document

The other functions are for internal use only. Some of the core functionality of EvtGen
is implemented in these functions that perform the low level manipulation of the amplitudes
and spin-density matrices.

• EvtAmp()
Default constructor.

• void init(EvtId p,int ndaug,EvtId *daug)

Initializes amplitude for the particles specified.

• void setNDaug(int n)
Sets the number of daughters.

• void setNState(int parent states,int *daug states)

Sets the number of spin states each particle has.

• void setAmp(int *ind,const EvtComplex& amp)

Sets an amplitude.

32
 • const EvtComplex& getAmp(int *ind)const
Returns an amplitude.

• EvtSpinDensity getSpinDensity()
Returns spin density matrix for the parent.

• EvtSpinDensity contract(int i,const EvtAmp& a)

Contracts amplitude to calculate spin-density matrix.

• EvtAmp contract(int i, const EvtSpinDensity& rho)

Contracts amplitude with spin-density matrix to calculate new amplitude.

• EvtSpinDensity getForwardSpinDensity(EvtSpinDensity *rho list,int k)

Calculates forward spin-density matrix for one of the daughters.

• EvtSpinDensity getBackwardSpinDensity(EvtSpinDensity *rho list)

Contracts amplitudes to calculate the backward spin-density matrix for the parent.

9.2 EvtCPUtil
Update with Anders fixes the code to be more general
This class contains some utilities that are useful for generating CP -violating decays from
the Υ(4S) system. In particular, it contains the two methods

• static void OtherB(EvtParticle *p, double &t, EvtId &otherb)

Particle p is a B meson from an Υ(4S) decay. otherb is the flavor that you want the
other B to have. When this function is invoked, flavor of the other B is changed, such
that it becomes of type otherb. The lifetime of the other B meson is returned in t.

• static void OtherB(EvtParticle *p, double &t, EvtId &otherb,

double probB0)
Similar to the function above, except that a probability is supplied for how ofthe th
other B should be a B 0 .

9.3 EvtComplex
Using the implementation of complex numbers provided by the compiler has caused con-
stant problems with porting EvtGen to different platforms, as these implementations do not
generally conform to a uniform standard. Therefore, we have implemented the EvtComplex
class. This implemention is not complete.
David should add the currently implemented function.

33
9.4 EvtConst
This class defines useful constants.

const double EvtConst::pi = 3.141592653589793238;

const double EvtConst::twoPi = 2*pi;
const double EvtConst::radToDegrees = 180./pi;

const double EvtConst::c = 2.99792458E11; // mm/sec

9.5 EvtDecayBase
This class is the base class for decay models and contains the interface for the decay models
to the framework. The most important member function is decay(EvtParticle *), which
performs the actual decay of the particle. Before explaining the purpose of other member
function, recall that for each entry in the decay table an instance of the decay model class
is created.
There are three classes that derive from EvtDecayBase; EvtDecayAmp, EvtDecayProb,
and EvtDecayIncoherent. These classes proved slightly different interfaces for writing decay
models, as discussed in detail in Section 7
The EvtDecayBase class provides the following member fuctions:

• virtual void getName(EvtString& name)=0

This function must be implemented each decay model. getName returns the name of
the model, to be used in the decay table.

• virtual EvtDecayBase* clone()=0

This is a pure virtual function, has to be implemented in the decay model, it returns
a new instance of the derived class.

• virtual void Decay(EvtParticle *p)=0

This method implements the actual decay. Each decay model should implement this
function.

• virtual void makeDecay(EvtParticle *p)=0

Implemented in the EvtDecayAmp, EvtDecayProb, and EvtDecayIncoherent classes.
Implements the accept reject as appropriate for the type of decay model. In the
EvtDecayAmp implementation, the decay probability is computed from amplitudes,
which are set by the decay models.

• void disableCheckQ()
By default, EvtGen checks each decay for charge conservation. Sometimes this is not
appropriate, for example with the SINGLE model, which generates single particles. If
disableCheckQ() is called in the init() member function, this check will not be
performed.

34
 • void init()
If the model to be implemented has any data members that must be initialized this
should be done in the call to the init member function. An example of such initial-
ization might be to process the arguments into some more convienient form.

• void initProbMax()
initProbMax is intended for a special kind of initialization, namely of the maximum
probability that can be obtained in the decay. This is used by the acceptance rejection
method to generate the correct distributions. Note that the call to initProbMax()
is done after the call to init(), which means that in initProbmax() you have ac-
cess to anything calcualted in init(). The maximum probability is set via the
setProbMax(double ) member function.

9.6 EvtDiracSpinor
The EvtDiracSpinor class encapsulates the properties of a Dirac spinor. It is used to repere-
sent spin 1/2 particles. EvtDiracSpinor is reperesented as a complex four component spinor
using the standard Pauli-Dirac convention for the γ-matrices. The operations that are avail-
able on an EvtDiracSpinor are seting the elements of the spinor, retreving an element print-
ing out the spinor, taking the complex conjugate, boosting the spinor into another Lorentz
frame, and evaluating some common matrix elements as summarized in Table 2.

Matrix elemet Function Return type

ū|γ µ (1 − γ 5 )|v EvtLeptonVACurrent(u,v) EvtVector4C
ū|γ µ |v EvtLeptonVCurrent(u,v) EvtVector4C
ū|γ µ γ 5 |v EvtLeptonACurrent(u,v) EvtVector4C
ū|v EvtLeptonSCurrent(u,v) EvtComplex
ū|γ 5 |v EvtLeptonPCurrent(u,v) EvtComplex
ū|σ µν |v EvtLeptonTCurrent(u,v) EvtTensor4C

Table 2: This table sumarizes the methods in EvtDiracSpinor that evaluates special matrix
elements.

Also see Section 9.7 for operations between Dirac spinors and γ-matrices.

9.7 EvtGammaMatrix
EvtGammaMatrix is a class for handling complex 4×4 matrices. The generic operations that
are available are addition (+), subtraction (-), and multiplication (*). An EvtGammaMatrix
can also be multiplied by a complex scalar. Besides these generic operations on matrices,
there are special operations related to gamma matrices. There are static member functions
that returns the gamma matrices according to the standard Pauli-Dirac representaion. Thr

35
g0(), g1(), g2(), g3(), g5(), and id() functions return γ 0 , γ 1 , γ 2 , γ 3 , γ 5 and the identity
matrix, respectively. Besides these basic functions there are four more specialized functions,
va0(), va1(), va2(), and va3() that are used in the evaluation of the weak lepton current.
These matrices are given by γ 0 γ µ (1 − γ 5 ), where µ = (0, 1, 2, 3). Similarly, the functions
v0(), v1(), v2(), and v3() return γ 0 γ µ , where µ = (0, 1, 2, 3).
There is also an operation (*) defined, which multiplies an EvtGammaMatrix with an
EvtDiracSpinor, and returns an EvtDiracSpinor.

9.8 EvtGen
This class provides the interface to EvtGen for an external user, see Appendix B.

9.9 EvtGenKine
EvtGenKine contains tools for generating kinematics such as phase space distributions. Cur-
rently only two functions are implemented

• static double PhaseSpace( int ndaug, double mass[10],

EvtVector4R p4[10], double mp)
Generates phase space for a decay with ndaug daughters with masses given by mass
for a parent with mass mp. The generated four-vectors are stored in p4.

• static double PhaseSpacePole(double M, double m1, double m2,

double m3, double a,EvtVector4R p4[10])
Similar to the PhaseSpace member function, expect that the kinematics are generated
with a 1/m pole in the invariant mass of particle 1 and 2 in a three-body decay, (for
example, π 0 → e+ e− γ). a is the strength of the pole. This method is designed to speed
up the generation of decays with a pole in the decay distribution. The return value
of this function is needed to correctly handle the accept-reject algorithm, and must
be passed to the EvtDecayBase framework via the void setWeight(double) member
function. For example:

setWeight(EvtGenKine::PhaseSpacePole
(m,mass[0],mass[1],mass[2],0.00000002,p4));

is used in the EvtPi0Dalitz model.

9.10 EvtId
The class EvtId is used to identify particles in EvtGen. It is used, e.g., as argument to the
EvtPDL member functions to look up particle properties.
The EvtId class provides the following operators (and a copy constructor) operator=,
operator== and operator!=. These are the only operations any user code for implementing
particle decays should need.

36
 The EvtId class contains two member data: id and alias. For regular particles, i.e.,
non aliases these are the same; an integer from 0 to n − 1 where n is the number of defined
particles. These numbers are assigned by EvtPDL when reading the particle list. When a
particle alias is created, e.g., mypi0, for a pi0, a new EvtId is created with the same id as
the pi0 but with a unique alias. The two comaprison operators, == and != compare the
id when determining if two particles are the same. Therefore mypi0 and pi0 are considered
the same particles, when compared using the == operator.
There are two places where aliased particles are treated differently than regular particles.
The first place is that when decay modes are selected the alias number is used, so that so
that we allow different decays for an aliased particle and its alias. The second place where
a complication arises is in the definition of the charge conjugate of an aliased particle. For
regular particles EvtGen uses the stdhep number to find the charge conjugate. However, for
aliased particles, the charge conjugate must be specified by hand. See Section 9.14 and 4.

9.11 EvtKine
This class provides some utility functions for calculating kinematic quantities such as decay
angles. See Appendix G.

9.12 EvtLineShape
This class contains utilities for simulating line shapes of particles. Currently this class only
provides the trivial implementation of a non-relativistic Breit-Wigner shape.

• static double BreitWigner( double mass,

double width, double min, double max)

9.13 EvtModel
This class handles the registration of decay models.

9.14 EvtPDL
The particle information read from the evt.pdl file can be accessed through member func-
tions of the EvtPDL class. The following (static) member functions are available:

• static double getNominalMass(EvtId id)

Returns the nominal mass.

• static double getMass(EvtId id)

Generates a mass according to a simple non-relativistic Breit-Wigner shape.

• static double getMaxMass(EvtId id)

The maximal mass that will be generated.

37
 • static double getMinMass(EvtId id)
The minimal mass that will be generated.

• static double getWidth(EvtId id)

The width of the resonance.

• static double getctau(EvtId id)

The lifetime, cτ (in mm).

• static int getStdHep(EvtId id)

The number according to the stdhep numbering scheme.

• static int getLundKC(EvtId id)

The compact Lund, kc, number.

• static EvtId evtIdFromStdHep(int stdhep)

The EvtId given the stdhep number.

• static EvtId chargeConj(EvtId id)

The charge conjugate of the particle.

• static int chg3(EvtId id)

The charge in units of 1/3 of the positron charge.

• static EvtSpinType::spintype getSpinType(EvtId id)

The spin type, i.e., scalar, vector, dirac, neutrino, etc.

• static EvtId getId(const EvtString& name)

Finds the EvtId given the name.

• static EvtString name(EvtId id)

The particle name.

• static void alias(EvtId num,const EvtString& newname)

Defines a new particle alias.

• static void aliasChgConj(EvtId a,EvtId abar)

Defines that two aliases are the charge conjugate of each other.

• static int entries()

Number of particles in the list, not including aliases.

Except for the aliases the EvtPDL class is quite simple. The use of alias has been explained
previously in the description of the decay tables and in several examples. This class makes
use of the EvtPartProp class to represent the properties of a single particle.

38
 EvtParticle

EvtScalarParticle EvtDiracParticle

EvtVectorParticle EvtTensorParticle

Figure 5: EvtParticle forms the base class for the concrete implementations of the different
particle types in EvtGen.

9.15 EvtPHOTOS
Provides an interface to the PHOTOS package for generation of final state radiation.

• static void PHOTOS(EvtParticle *p)

If PHOTOS generates additional photons they are added at the end of the list of particles
produced.

9.16 EvtPartProp
Class to represent the particle properties of a single particle. Used by EvtPDL to keep the
particle properties.

9.17 EvtParticle
This is the base class for particles. It contains the common interface to particles such as the
four momentum particle number, list of daughters and parent etc. The Particle class forms
a base class for the different type of particles: Scalar, Vector, Tensor, Dirac, Photon, and
Neutrino, see Figure 5.
The derived classes add a basis for the states used to represent the spin degrees of freedom
of the particle. For example the vector particles (EvtVectorParticle) adds three complex
four-vectors, the massive spin 1/2 particles (EvtDiracParticle) adds two Dirac spinors for
its basis vectors. This data is stored in the derived class as appropriate for the particle
type. The accessor functions are virtual functions in the EvtParticle base class. The
accessor functions for these basis vectors are shown in Table 3. The default implementation
in EvtParticle of these accessor functions generates an error message and then aborts the
application. The motivation for doing this is that you don’t have to do a cast to the derived
type to be able to access the basis vectors. But, yes, this is not very good OO practice.
The init(const EvtId id, const EvtVector4R& p4) member function sets the id and
four-momentum of the particle. This function sets up the basis states of the particle and is

39
 Class Type Own rest frame Parent frame
Scalar N/A N/A N/A
Dirac EvtDiracSpinor sp(int i) spParent(int i)
Neutrino EvtDiracSpinor N/A spNeutrinoParent()
Vector EvtVector4C eps(int i) epsParent(int i)
Photon EvtVector4C N/A epsParentPhoton(int i)
Tensor EvtTensor4 epsTensor epsTensorParent(int i)

Table 3: This table shows the accessor functions for the basis vectors.

hence implemented in the derived class. Note that, in general, to be able to construct the
basis vectors both the id and the four-momentum must be know. In the case of a photon,
i.e., a massless vector meson, the polarization vectors that makes up the basis state, ε1
and ε2 , has to be orthogonal to the momentum, i.e. p · ε1 = p · ε2 = 0. For a fermion,
represented by a Dirac-spinor, the basis vectors needs to know if it is representing a particle
or an anti-particle.
Given a particle there are two member functions that are useful for creating the daughters.
These two functions are:

void makeDaughters(int ndaug, EvtId *id);

void initializePhaseSpace(int ndaug, EvtId *id);

The first of these two routines creates the particles with the types according to the array
of EvtId’s as specified by id. The daughters are added to the parent, i.e., the particle on
which this member function is invoked, but the momentum of the particle is not initialized.
The second function, initializePhaseSpace, is similar except that it generates kinematics
according to phase space and initializes the daughters with this momentum.
The Decay() member function performs the actual decay of the particle. The Decay
member function selects a decay by using the class EvtDecayTable and then using the
EvtDecayBase decays the particle. This function recursively decays particles until all parti-
cles are stable.
There are various other functions which are useful in EvtParticle:

• EvtParticle* getDaug(int i)
Returns a pointer to the i:th daughter of the particle.

• EvtVector4R getP4Lab()
Gets the four-vector of the particle in the laboratory frame. With laboratory frame is
meant the rest frame in which the root particles momentum is measured.

• EvtVector4R get4Pos()
Returns the four-position of the particle in the laboratory frame, again the laboratory
frame is defined by the position and momentum of the root particle.

40
• EvtParticle* getParent()
Returns the pointer to the parent particle. If it is the root particle 0 is returned.

• double mass()
Returns the mass of the particle.

• EvtId getId()
Returns the id of the particle.

• EvtSpinType::spintype getSpinType()
Returns the particle type. This is an enum in the EvtSpinType class.

• int getSpinStates()
Returns the number of spin degrees of freedom. E.g., 1 for a scalar and 3 for a vector.

• EvtVector4R& getP4()
Returns the four-momentum of the particle in it parents rest frame.

• void setP4(const EvtVector4R& p4)

Set the four-momentum of the particle in its parents rest frame. For a particle that
doesn’t have a parent its momentum is measured is the laboratory frame.

• int getNDaug()
Returns the number of daughters of the particle.

• void printTree()
Prints out the decay tree starting from the particle the function is invoked on.

• void printParticle ()
Prints detailed information about the particle, this include what type it is and its
momentum.

• void setLifetime(double tau)

Sets the lifetime of the particle to tau, measured in mm/c.

• void setLifetime()
Generates a lifetime of the particle according to a pure exponential with mean according
to EvtPDT for the id of the particle.

• double getLifetime()
Returns the lifetime of the particle.

• void setDiagonalSpinDensity()
Initializes the particle with a diagonal spin density matrix. This function is typically
invoked on the initial particle before it is decayed.

41
 • void setVectorSpinDensity()
Initializes a vector particle with the appropriate spin density matrix for the production
of the vector particle in an e+ e− interaction.

• void setSpinDensity(const EvtSpinDensity& rho)

Initializes the particle with the spin density matrix rho.

Besides these functions there are a few more. These are either considered obsolete and
will eventually be removed or should be made private as they are really only helper functions.

9.18 EvtParticleDecay
Stores information for one particle decay. This class is not used yet.

9.19 EvtParticleDecayList
Stores the list of decays of one particle. This class is not used yet

9.20 EvtParticleNum
Defines EvtID for all particles.

9.21 EvtParser
Used by EvtDecayTable to read the decay table. Comments are removed and each token
togheter with the current line number is put into a list which is used when building the
decay table.

9.22 EvtRandom
EvtRandom provides the interface for random numbers that are used in the EvtGen package.
We still need to specify the initialization of this class. The interface is some what clumsy.

• static double Flat( double min, double max )

Generate pseudo random nmber between min and max.

• static double Flat( double max )

Generate pseudo random nmber between 0 and max.

• static double Flat( )

Generate pseudo random nmber between 0 and 1.

• static double random()

Generate pseudo random nmber between 0 and 1.

42
 • static RandFcnD& ranFcnD()
Return reference to random function.

• static RandFcnF& ranFcnF()

Return reference to random function.

• static HepRandomEngine** ranEngine() Return the HepRandomEngine.

• static void setRandFcnD(RandFcnD& arandfcnd)

Use a random function that is a static function returning a double precision number.

• static void setRandFcnF(RandFcnF& arandfcnf)

Use a random function that is a static function returning a double single number.

• static void setRandEngine(HepRandomEngine& aHepRandomEngine)

Use a CLHEP random engine.

9.23 EvtReadDecay
This is a real mess! But it’s purpose is to read in the decay table.

9.24 EvtReport
Utility to print out mesages from EvtGen.

9.25 EvtResonance
The EvtResonance class allows one to handle resonances as a single structure. It is cur-
rently implemented for decays with three daughter particles. An EvtResonance object is
constructed using the four momenta of the parent, the four momenta of the two daughters
which constitute a resonance, and the parameters describing the resonance: amplitude c,
phase angle θ, width Γ, Breit-Wigner mass mBW , and spin. The spin can be 0, 1, 2, or
3 (as of 09/07/97, it has only been tested for spin 0 and 1, however). The member func-
tion resAmpl() returns the complex amplitude for the resonance calculated according to the
following formula:
ck eiθk FkBW (x, y)Dkang (x, y) (21)
where x and y are the invariant masses of the two particle combinations, FkBW is a normalized
Breit-Wigner function, and Dkang describes the angular distribution for the kth resonance.
More precisely, for spin 0 the (non-relativistic) amplitude is:


iθ Γ 1
ce (22)
2π (m12 − mBW ) − iΓ
2

43
 For spin 1 the amplitude is:


Γ cosφ3
c eiθ (23)
2π (m12 − mBW ) − iΓ
2

For spin 2:  3

iθ Γ 2
− 12
cos2 φ3
ce (24)
2π (m12 − mBW ) − iΓ
2
For spin 3:  5

iθ Γ cos3 φ
2
− 32 cosφ3
3
ce (25)
2π (m12 − mBW ) − iΓ2
where m12 is the invariant mass of particles 1 and 2, cosφ3 is the cosine of the angle 3 makes
with 2 in the rest frame of 12 (cosine of the angle 3 makes with 1 in the rest frame of 12 is,
obviously, −cosφ3 ).
Note that if two of the three daughters (for example 2 and 3) are identical, one has to take
into account the contributions from two possible combinations 12 and 13, with corresponding
signs for the cosines (for spin 1 and higher), and a normalization factor of 1/2.
Another member function, relBrWig( int ), returns the relativistic Breit-Wigner ampli-
tude for the K ∗ π (in which case the integer argument should be equal to 1) or Kρ (in which
case the argument should be = 1) resonances. More precisely, for a P-wave decay of a scalar
meson (which I’ll denote S), the amplitudes are given by:
√
2 Γ0 M
BW (mij ) = (26)
(mR − m2ij ) − iΓmR
2

where the matrix element M is:

M = (PS − Pk )µ (g µν − Pijµ Pijν /m2R )(Pi2 − Pj2) (27)

1 + (RpjR )2
|M|2 = (m2ik − m2jk − (m2S − m2k )(m2i − m2j )/m2R ) (28)
1 + (Rpj )2

3
mR pj 1 + (RpjR )2
Γ = Γ0 (29)
mij pjR 1 + (Rpj )2
Here, mR and Γ0 are the mass and width of the m2ij resonance; mS , mi , mj , mk are the
masses of the parent and of the ith , j th , k th particles, respectively; pj is the magnitude of the
3-momentum of the j th particle in the i − j rest frame, and pjR is the same when m2ij = m2R .
The value of R for the “centrifugal barrier penetration factor” is taken to be 2 fm for the
K ∗ and 5 fm for the ρ.

9.26 EvtSecondary
Allows EvtGen not to write secondary particles to StdHep. This class will most likely be
removed.

44
9.27 EvtSpinDensity
This class represents spin-density matrices of arbitrary dimensions. (Well, this is not quite
true, at the moment it is limited to dimension 5 which is the number of degrees of freedom of
a spin 2 particle.) Functions are provided to manipulate the components of the spin density
matrix as well as to calculate probabilites.

9.28 EvtSpinType
Defines the folowing enum for the different particle types that EvtGen handles.

enum spintype { SCALAR,VECTOR,TENSOR,DIRAC,PHOTON,NEUTRINO,STRING };

9.29 EvtStdHep
This class flattens out the EvtGen decay tree that is used internaly to represent the particles
and stores the particles in a structure that is parallel to StdHep.

9.30 EvtString
This class is used by EvtGen to represent character strings. It does not provide a full
interface for what you might need to do with strings. But the following is available, other
things can be added if need arise.

• EvtString()
Default constructor.
• EvtString(const char* cptr)
Constructor from char*.
• EvtString(const EvtString& string)
Copy constructor.
• friend ostream& operator<<(ostream& s, const EvtString& str)
Print out string.
• friend istream& operator>>(istream& s, EvtString& str)
Read in string.
• virtual EvtString()
Virtual destructor.
• EvtString operator=(const EvtString& string)
Assignment operator.
• int operator==(const EvtString& string) const
Equal operator between two strings.

45
 • int operator!=(const EvtString& string) const
Not equal operator between two strings.

• int operator==(const char* string)

Equal operator between EvtString and char *.

• int operator!=(const char* string)

Not equal operator between EvtString and char *.

• char* value() const

Return pointer to a char*.

9.31 EvtSymTable
Variables that are defined using a “Define” statement in the decay table are stored in this
class. Member functions allow storing new symbols, querring about the existence of variables
and looking up their values. This is only used from the EvtDecayTable class when reading
the decay table.

9.32 EvtTemplateDummy
This class was introduced just such that the EvtGen package made use of templates, this
should be removed.

9.33 EvtTensor3C
Complex rank 2 tensors in 3 dimensions.

9.34 EvtTensor4C
This class encapsulates the properties of second rank complex tensors. A tensor is repere-
sented as a 4 × 4 matrix of complex elements. As in the reperesentation of 4-vectors the
tensor elements stored reperesents the tensor T µν , i.e., the tensor with raised indices. The
components of a tensor can be manipulated using the set, setdiag, and get member func-
tions. setdiag sets the diagonal elements while all other elements are initialized to zero. If
g is of type EvtTensor4C tensor g.setdiag(1.0,-1.0,-1.0,-1.0) will set g to the metric
tensor. The member function trace() calculates the trace, T µµ . The operators + and -
are defined to be addition and subtraction of tensors. The operator * is defined between a
complex number and a tensor and is a scalar multiplication.
A tensor can also be constructed from two four vectors, either EvtVector4C or EvtVec-
tor4R, using the direct product function. T=directProd(k,p) has components T µν = k µ pν .
The dual function performs a contraction with the totaly anti symmetric tensor µναβ ,
F=dual(T) has components F µν = µναβ Tαβ . The sign convention is 0123 = +1. conj()
takes the complex conjugate of a tensor by conjugating each individual element.

46
 A tensor can also be obtained by contracting two tensors, e.g., Gαβ = T αµ F βµ , this is
expressed by G=cont22(T,F). The numbers 22 means that it was the second two indices
that was contracted. A tensor can also be contracted with a vector. This operation creates
a new vector, e.g., p=T.cont1(k), where cont1 means that the first index of the tensor is
contracted with k, pµ = T νµ kν .
As special tensors that are defined is the metric tensor, g = diag(1, −1, −1, −1), which
is accessed through the static member function EvtTensor4C::g().
The member function boost(e,px,py,pz) boost a tensor to the restframe given by
(e, px , py , pz ).

9.35 EvtVector3C
Complex three-vectors.

9.36 EvtVector3R
Real three-vectors.

9.37 EvtVector4C
This is a class for reperesenting complex four-vectors. Examples of complex four vectors are
polarization vectors, ε and currents, e.g., Lµ .

9.38 EvtVector4R
This is a class for representing real four vectors. Examples of real four vectors are four
momenta and space-time positions.
The operators =, +, -, +=, -= are supported with the obvious meaning, also multiplica-
tion and divison by real numbers are available.
√
The quantity pµ pµ can be evaluated using the mass2() member function and pµ pµ , the
mass, is given by mass(). The member function d3mag() evaluates the magnitude of the
spatial components, i.e., the three momentum.
Components of a four-vector can be manipulated with the set(int i, double d) mem-
ber function which sets component i of the vector to d. The components are labeled from 0
to 3. O is the time component and 1 through 3 are the space components. To set all com-
ponents at once the set(double t, double x, double y, double z) memeber function
can be used. get(int i) accesses the i:th component of the vector.
The EvtVector4R boost to v4(const EvtVector4R& v2,const EvtVector4R& vto)
function returns the four vector v2 boosted to the frame in which a particle with momentum
vto is at rest.

47
10 CP Violation and Mixing
This section discusses how CP violation and mixing work in the generator. These two topics
are closely related, since a large fraction of CP violating decays occurs via mixing. Exactly
what is the best way of introducing these two effects into EvtGen is still not clear; there
are different ways of generating CP violating decays depending on what one is interested
in. For example, one might want to generate a sample of events with B → a+ −
1 π , and
the B’s which tag the flavor of this B (e.g., via semileptonic decays) are all B 0 ’s. On the
other hand, one might want to generate a sample that has the correct mixture of B 0 and
B̄ 0 tags, as determined by the decay dynamics. From the point of view of implementation
these two situations are fairly different, and at the moment we are still working on choosing
a consistent way of dealing with them.
This section starts out describing how mixing works, and then proceeds to describe how
CP violation is introduced. Examples will be provided. CP violating decays are among the
most complicated things this generator does, and various ways in which one might get the
generation of CP violating decays wrong will be pointed out.

10.1 Mixing in the B 0B̄ 0 System.

As is well know, when Υ(4S) decays into the B 0 B̄ 0 system, the B’s are produced in a coherent
state. This implies that when one of the B’s decays, and its flavor is determined, the other
B is known to be in a pure state of the opposite flavor. This state then evolves (oscillates)
independently, with the oscillation frequency given by ∆m/2, (∆m being m2 − m1 , the mass
difference between the two B mass eigenstates). Assuming |B0phys (t = 0) = |B 0 , its time
evolution is given by:
   
0 −Γt/2 imt 0 ∆mt q ∆mt
|Bphys (t)=e e |B  cos + i |B̄ 0  sin , (30)
2 p 2
√ √
where m ≡ (m1 + m2 )/2, q = eiφM / 2, and p = e−iφM / 2 (φM is the mixing angle). Time
t in this formula is the time between the two B decays.
By projecting |B0phys (t) into a pure B 0 or B̄ 0 state, one can obtain the amplitudes for
the B to decay with a given flavor. In turn, squaring them gives the probabilities:

0 1 −Γt
P (Bphys → B 0) = e (1 + cos(∆mt)) (31)
2
0 1 −Γt
P (Bphys → B̄ 0 ) = e (1 − cos(∆mt)) (32)
2
(33)

Integrating these over all times, one obtains the total rates:

0 x2d
P (Bphys → B0) = (34)
2 (1 + x2d )

48
 0 2 + x2d
P (Bphys → B̄ 0 ) = (35)
2 (1 + x2d )
(36)

where xd ≡ ∆mΓ
.
Considering
 in a similar way the time evolution of the coherently produced state (Ψ(t =
1 0 0
0) = √2 |B B  − |B B 0  ), one can obtain the ratio:
0

N(Υ(4S) → B 0 B 0 ) + N(Υ(4S) → B̄ 0 B̄ 0 ) x2d

= . (37)
N(Υ(4S) → B 0 B̄ 0 ) 2 + x2d

Currently, mixing is implemented in two decay models: VSS MIX and VSS BMIX. These
models both take the mass difference to be a parameter and use the width assigned in the
particle properties table, i.e., from the evt.pdl file in the BaBar environment. These models
differ in the number of parameters that the user must supply. The VSS MIX model requires
that the branching fractions into mixed and unmixed final states be set by hand, and does
not require that they be consistent with the mass difference and lifetime. The VSSB MIX model
calculates the branching fractions automatically and is therefore safer and easier to use. One
can use this model as follows:

Decay Upsilon(4S)
0.5 B+ B- VSS;
0.5 B0 anti-B0 VSS_BMIX;
Enddecay

Both models give identical results when the VSS MIX branching fractions are set correctly.

10.2 Mixing and Non-zero Lifetime Differences.

This section should probably be merged with the previous but is currently written separately,
mostly due to historical reasons, as this is only needed for Bs mixing, which was added later.
In this section B 0 and B̄ 0 will generically denote any neutral meson flavor eigenstate.
These states are not eigenstates of the full hamiltonian and hence do not have a definite
mass or lifetime. The states that are eigenstates of the hamiltonian are

|BL  = p|B 0  + q|B̄ 0 , (38)

|BH  = p|B 0  − q|B̄ 0 . (39)

The states BL and BH have masses, mL and mH , and widths, ΓL and ΓH , respectively such
that
|BL,H (t) = e−(ΓL,T /2+imL,T )t |BL,H  (40)
where BL,H (t) is the state after evolving the state BL,H for a time t.

49
 This allows us to evaluate several matrix elements that are useful for calculating the
mixing rates
1
B 0 |B 0 (t) = (B 0 |BL (t) + B 0 |BH (t))
2p
1 −(ΓL /2+imL )t
= (e + e−(ΓH /2+imH )t ), (41)
2
0 0 1
B̄ |B (t) = (B̄ 0 |BL (t) + B̄ 0 |BH (t))
2p
q −(ΓL /2+imL )t
= (e − e−(ΓH /2+imH )t ), (42)
2p
1
B 0 |B̄ 0 (t) = (B 0 |BL (t) − B 0 |BH (t))
2q
p −(ΓL /2+imL )t
= (e − e−(ΓH /2+imH )t ), (43)
2q
1
B̄ 0 |B̄ 0 (t) = (B̄ 0 |BL (t) + B̄ 0 |BH (t))
2q
1 −(ΓL /2+imL )t
= (e + e−(ΓH /2+imH )t ). (44)
2
Now it is straight forward to calculate the mixing rate. Let χ define the probability that
a meson produced, at t = 0, as a B 0 will decay as a B̄ 0 . It is now easy to see that
∞
0 |B̄ 0 |B 0 (t)|2 dt
χ = ∞ ∞
0 |B̄ |B (t)| dt + 0 |B |B (t)| dt
0 0 2 0 0 2

x2 + y 2
= 2 (45)
x + y 2 + | pq |2 (2 + x2 − y 2 )
where
∆m ∆Γ
x≡ , y≡ (46)
Γ Γ
and
ΓL + ΓH
Γ≡ , ∆Γ ≡ ΓH − ΓL , ∆m ≡ mH − mL . (47)
2
Similarly the probability that that a meson produced, at t = 0 as a B̄ 0 will decay as a B 0 is
given by
∞
0 |B 0 |B̄ 0 (t)|2 dt
χ̄ =  ∞ ∞
0 |B |B̄ (t)| dt + 0 |B̄ |B̄ (t)| dt
0 0 2 0 0 2

x2 + y 2
= 2 . (48)
x + y 2 + | pq |2 (2 + x2 − y 2 )

In the limit of |p/q| = 1 and y = 0 we have

x2
P± (t) = χ = χ̄ = (49)
2(1 + x2 )

50
as expected. The time distribution, arbitrary normalization, is given by

e−ΓL t (1 + e∆Γt ± 2e∆Γt/2 cos ∆mt) (50)

The minus sign corresponds to the case of mixing, and the plus sign to the case of no mixing.

10.3 CP-violation.
The “first generation” of models which were implemented in EvtGen to deal with CP vio-
lation did not solve all the problems that are involved in simulating the physics of the B B̄
system. To illustrate how these models work, let us consider the following example (the
decay B → π + π − ):
Alias MYB B0
#
Decay Upsilon(4S)
0.70 MYB B0 VSS;
0.30 MYB B0B VSS;
Enddecay
#
Decay MYB
1.0 pi+ pi- SSS_CP alpha dm CP |A| arg(A) |Abar| arg(Abar);
Enddecay
End
The model used in this example is SSS CP. Its first argument is alpha, is the relevant
CKM angle (in this case it is α); the second argument dm is the mass difference of the two B
mass eigenstates; the third argument, CP, specifies the CP of the final state, and is either +1
or −1. The latter argument could in principle be determined from the particle properties,
but at the moment EvtGen does not include the C and P quantum numbers in its particle
properties list (this should be fixed). The last 4 arguments are the (complex) amplitudes for
B 0 and B̄ 0 to produce the final state.
In this example the Υ(4S) decays with unequal probabilities to “MYB” and B 0 and to
“MYB” and B̄ 0 . The B 0 and B̄ 0 simply decay as a B 0 and a B̄ 0 , respectively, according to
the generic decay table. The interesting thing is how “MYB” decays. In the SSS CP model,
“MYB” will produce a π + π − final state, while the other B will provide a tag of the flavor
that is listed in the decay of the Υ(4S) (B 0 in 70% of the cases, and B̄ 0 in 30% of the cases).
Therefore, in this example there will be some number of B 0 tags and some number of B̄ 0
tags.
If one would like to get a sample of events with only B 0 tags, one could do it in the
following way:
Alias MYB B0
#
Decay Upsilon(4S)

51
1.00 MYB B0 VSS;
Enddecay
#
Decay MYB
1.0 pi+ pi- SSS_CP dm alpha CP |A| arg(A) |Abar| arg(Abar);
Enddecay
End

Here, the only available tag (as specified by the Υ(4S) branching fraction) is B 0 .
When the Υ(4S) is decayed and the two B’s are produced, they are assigned lifetimes
which are sampled from a pure exponential distribution, with a mean of the average lifetime
specified in the particle properties list. (If the decay model is one that includes the effects
of mixing, the time distribution is no longer a pure exponential; see the previous section.
However, as will be evident below, it doesn’t matter what time distribution is used in the
decay of the Υ(4S).) Since the lifetime distributions of both the B that decays to the
CP channel and the tag B are no longer exponential, the SSS CP model has to regenerate
lifetimes of both B’s. However, the model does not change what tag one of the B provides.
This is important, because it means that this model cannot enforce the right fraction of B 0
and B̄ 0 tags. The only way to control this is through the decay table.
The SSS CP model handles decays to a pair of scalar particles. Of these, the most im-
portant one is probably B → ππ, but the model also works for any other decay with two
scalars in the final state, e.g., Ks η  . Other models which are implemented in a similar way
are SVS CP and STS CP, which handle the decays to a scalar and a vector and to a scalar
and a tensor, respectively. There is also a model for two vectors in the final state: it is
called SVV CP. One complication with this model is that there are three partial waves that
contribute to the rate with different CP.
All of these models have one feature in common: they generate the B tags with the rel-
ative fractions specified in the decay table. It seems logical that the next step in expanding
the functionality of the generator should be implementing some way to generate the right
fraction of B 0 and B̄ 0 tags according to the amplitudes that are specified for a particular
decay channel. Indeed, this would be a very natural thing to do, because given the ampli-
tudes, the relative fraction of B 0 and B̄ 0 tags can be determined. A new class of models
which have been recently put into EvtGen does have this feature. These new models are
particularly important for decays into final states that are not CP eigenstates, for example
B → a+ −
1 π , or decays with direct CP violation (e.g., due to the presence of penguins).
Let us consider in more detail what the problem is. The time-dependent CP-asymmetry
for the decay B → f , where f is a CP eigenstate, is defined as:
0
Γ(B 0 (t) → f ) − Γ(B (t) → f )
Af (t) = 0 (51)
Γ(B 0 (t) → f ) + Γ(B (t) → f )
0 +∞ 
If |A(B 0 → f )| = |A(B → f )|, then the integrated asymmetry −∞ Af (t)dt = 0, and the
0 0 0 0
relative fraction of B (B̄ ) tags is known (1/2). However, if |A(B → f )| = |A(B → f )|

52
 +∞ 
(which can happen, e.g., because of penguin pollution), −∞ Af (t)dt = 0, so the fraction of
tags must be somehow determined.
One way to get the correct fraction of tags is to use integrated rates. For example, for
decays into a CP-eigenstate it can be defined as:
∞
−∞ Γ(B(t)0 → f )dt
fr ≡  ∞  0
 (52)
−∞ Γ(B 0 (t) → f ) + Γ(B (t) → f ) dt

so that 
2 2 (1−|r f |2 )
|Af | 1 + |r f | + 1+x2d
fr =   , (53)
(1−|r f |2 ) (1−|rf |2 )
|Af |2 1 + |r f |2 + 1+x2d
+ |Af |2 1 + |rf |2 + 1+x2d

where xd ≡ ∆m Γ
, rf = e2i φM A
A
, and r f = r1f .
Two functions in the new version of EvtOtherB return this fraction (fractB0CP for decays
into a CP eigenstate and fractB0nonCP for decays into non-CP eigenstates). However,
analytical calculations of the integrals can be done only in the simplest cases. For example,
for the B → ρπ decay one would have to integrate over the Dalitz plot as well as over time
to get the total rates, which is very hard to do! A better solution is to use the so-called
acceptance-rejection method, which is effectively equivalent to numerical integration. This
method has been used in the “second generation” models which introduce direct CP-violation
into EvtGen.
The new models that are available are: SSS CP PNG for the B → π + π − decay with penguin
contributions; BTO2PI CP ISO for the three isospin-related B → ππ modes; BTOKPI CP ISO
for the four isospin-related B → Kπ modes; and SVS CP ISO for the five isospin-related
generic scalar → (pseudo)scalar +vector modes. There is another decay model for the latter
case, which also returns the correct fraction of B 0 (B̄ 0 ) tags. It is called SVS NONCPEIGEN.
Here is an example of how this model can be used for the B → a1 π decay:
Alias MYB B0
Decay Upsilon(4S)
1.000 MYB anti-B0 VSS;
Enddecay
Decay MYB
1.000 a_1- pi+ SVS_NONCPEIGEN 1.22 0.51e12 0.0
1.0 0.0 3.0 0.1
3.0 0.1 1.0 0.0;
Enddecay
End
The first parameter of this model is the corresponding CKM angle (in this case, it is
α); the second parameter is ∆m; the third parameter is the “flip” which determines the
fraction of “MYB” → f to “MYB” → f decays, where the state specified in the decay table
is considered the “f ” state. If the flip is set to 0, “MYB” always decays into the f state.

53
The next four parameters are the absolute values and phases for the amplitudes B 0 → f
and B̄ 0 → f , respectively, and the last four parameters are those for the amplitudes B 0 → f
0
and B → f .
It is important not to confuse the “flip” parameter with the number of tags. For example,
one would like to generate 10,000 BB events with the flip parameter set to 0.5. This means
that one would get 5,000 “MYB” → f decays and 5,000 “MYB” → f decays, but within
each 5,000 event sample the number of B 0 and B̄ 0 tags is determined by the amplitudes
specified in the decay file!
As before, “MYB” in this example decays into a CP-mode, while the other B provides
a tag. However, the model itself generates the correct fraction of B 0 (B̄ 0 ) tags, which
is determined from the last eight parameters (the amplitudes), and is independent of the
Υ(4S) branching fractions.

10.4 Special CP models

The models described above are meant to be generic models that can be applied to different
decays with appropriate arguments. All of the above models are two body decays. There
is, however, many other decays that are not two body decays and these can not be treated
quite as simply since there will in general be interference between various resonances. As an
example consider the decay B → π + π − π 0 which is dominated by the ρ(770) resonances.
To handle the B → 3π and the B → 4π decays two special models have been written.
These models are called BTO3PI CP and BTO4PI CP. The second of model BTO4PI CP needs
more work interms of understanding the conventions of the phases between the resonances
that contributes.

54
10.5 Unified implementation of CP-violating and mixing
This section describes a proposal for how to unify and simplify the simulation of CP-violating
decays and mixing in EvtGen, this should allow writing models that works independently
of how the neutral B meson is produced, i.e. in a coherent pair in an Υ(4S) decay or
incoherently e.g. in a pp̄ collision.

10.5.1 CP violation
The decays that we are considering here are common final states to a neutral B meson and
its antiparticle, e.g. B → J/ψKS or B → J/ψK ∗ . At the Υ(4S) in the absence of direct CP
violation these decays can be simplified as we can make the assumption that you have an
equal number of B 0 and B̄ 0 tags, or equivalent that there is no time integrated asymmetry.
However, we want to write the code such that no assumptions are made about the numbers
of B 0 and B̄ 0 tags. For B mesons that are produced incoherently we always have to consider
the asymmetries in the rates for an initial B 0 or B̄ 0 .
To allow generating these asymmetries correctly these models will be allowed to modify
the flavor of the B meson that is decayed. For the Υ(4S) this means changing the the flavor
of ’the other’ B meson in the Υ(4S) decay, the tag B. For incoherent produced B mesons
this means that if a specific flavor is given to EvtGen it can return a decay of the opposite
flavor. If e.g. EvtGen is given a B ∗∗ + to decay and it decays it to B 0 π + the decay of the B 0
might decide to flip the flavor of the decay chain to allow generating the right time integrated
asymmetry. This means that after EvtGen is done the code that called EvtGen will get back
a B ∗∗ − and needs to be prepared to handle this, e.g. by applying CP to the decay chain
that produced the B ∗∗ +. Also note the meaning of branching fractions in the decay table,
for modes that are common to a B and its anti-particle, the B̄ the above implies that the
branching fraction listed for the B and the B̄ are the average branching fractions.
Practically, this is implemented in the EvtCPUtil class, which will handle the cases of
coherent and incoherently produced B mesons.
How is this different from the current implementation, V00-09-38? Not very much, there
are already some models, e.g. the SVS NONCPEIGEN that has the full functionality that allows
for direct CP violation and will generate the right mixture of B and B̄ tags. All CP models
should convert to this more general model. For applying this to B mesons that are produced
incoherent, i.e. with a definite flavor, we need to modify the EvtCPUtil::otherB() method
to allow the change of the flavor.

10.5.2 Mixing
In the Υ(4S) system mixing is handled by the decay of the Υ(4S) meson via models such
as VSS BMIX. This implementation seems sufficient at this point. Note that we are not
considering the case of the Υ(5S) at this point.
For incoherently produced neutral B mesons, B 0 or Bs , we assume that the flavor is
tagged and mixing will be generated by adding a decay like B 0 → B̄ 0 where the mixed
particle have zero lifetime. Models that simulate CP violation, or in general models that

55
handle decays common to the B and the B̄ decay will remove any mixing, this is done in
EvtCPUtil. (Models that do not make any assumption about the flavor of the B should
probably be using a ’neutral B’ particle instead of a specific flavor, but at BABAR we have
not implemented this as it would be very confusing at this point to a lot of analysis code
that uses Monte Carlo truth.)
This means that models that simulates CP-violating decays should not need to turn of
mixing, it will practically be ignored.
The mixing of incoherently produced B mesons is not done in a model, this causes some
problems as it is hard to control the mixing, e.g., turning it of or modifying the parameters.
We need to invent a way to control this.

56
11 Semileptonic decays in EvtGen
11.1 Introduction
We summarize the treatment of semileptonic decays in EvtGen. A framework is setup such
that the implementation of a model for semileptonic form factors requires only the coding of
the form factors themselves. Currently, we consider semileptonic decays from pseudoscalar
mesons into pseudoscalar, vector, or tensor meson daughters. In section 11.2 we define the
conventions used in the implementation of semileptonic decays. Section 11.3 describes the
framework from which semileptonic form factor models can be built. An example of such
a model is given in section 11.4. Finally, we list the form factor models implemented in
EvtGen in section 11.5.

11.2 Semileptonic conventions

We have tried to follow standard descriptions of semileptonic form factors in EvtGen. For
decays of pseudoscalar mesons to pseudoscalar daughters, we describe the form factors as
 
m2 − m2
< S(k)|Vµ|P (p) > = (p + k)µ − P 2 S qµ f+ (q 2 ) (54)
q
 2 2 
mP − mS
+ qµ f0 (q 2 )
q2

P denotes the parent (pseudoscalar) meson (B, D or Bs ) and S denotes a pseudoscalar

daughter (D, K, or π). In this form, we have the constraint f+ (0) = f0 (0).
For decays to vector mesons, we use the form

A2 (q 2 )
< V (k)|(V − A)µ |P (p) > = ∗µ (mP + mV )A1 (q 2 ) − (p + k)µ (∗ p) (55)
(mP + mV )
2mV
− qµ (∗ p) (A3 (q 2 ) − iA0 (q 2 ))
q2
2V(q 2 )
+ µνρσ ∗ν pρ k σ
mP + mV
Where V denotes a vector daughter meson (D ∗ , K ∗ or ρ) and A3 is defined as
mP + mV mP − mV
A3 (q 2 ) = A1 (q 2 ) − A2 (q 2 ) (56)
2mV 2mV
where A0 (0) = A3 (0).
For semileptonic decays to tensor mesons (D2∗ ), to be denoted as T , we use the form

< T (k)|(V − A)µ |P (p) > = ih(q 2 )µνλρ ∗να pα (p + k)λ (p − k)ρ − k(q 2 )∗µν pν (57)
2
+ b+ (q )∗αβ pα pβ (p + k)µ − b− (q 2
)∗αβ pα pβ (p − k)µ

57
11.3 Semileptonic framework
There are two abstract classes responsible for the semileptonic decay framework. The first
of these is EvtSemiLeptonicFF, which provides the framework for the calculations of form
factors. There are three member functions:

• virtual void getscalarff( int parent, int daught,

double t, double mass, double *fpf,
double *fmf )

• virtual void getvectorff( int parent, int daught,

double t, double mass, double *a1f,
double *a2f, double *vf, double *a0f )

• virtual void gettensorff( int parent, int daught,

double t, double mass, double *hf,
double *kf, double *bpf, double *bmf )

All form factors models should include a class derived from EvtSemiLeptonicFF, which will
implement the relevant member functions of EvtSemiLeptonicFF.
These form factor implementations are used by classes derived from the abstract class
EvtSemiLeptonicAmp, which contains the member function:

• virtual void CalcAmp( EvtParticle *parent,

EvtSemiLeptonicFF *FormFactors )

Classes to calculate the amplitude for semileptonic pseudoscalar to pseudoscalar, pseu-

doscalar to vector, and pseudoscalar to tensor decays are EvtSemiLeptonicScalarAmp,
EvtSemiLeptonicVectorAmp, and EvtSemiLeptonicTensorAmp, respectively. These rou-
tines are passed form factors which must follow the conventions described in section 11.2.
An example of how to use this framework is presented in section 11.4.

11.4 Examples
Above we have defined the conventions followed in the standard semileptonic framework of
EvtGen. Here we show how new form factor models can be easily implemented. We take
as an example a heavy quark effictive theory model of B → D ∗
ν form factors, where
is
either an electron or muon. In this decay we can write the form factors as:

hA1 (w) q2
A1 = 1 − (58)
R∗ (MB + MD∗ )2

hA1 (w)
V = R1 (59)
R∗
hA (w)
A2 = R2 1 ∗ (60)
R

58
where 
hA1 (w) = hA1 (1) 1 − ρ2A1 (w − 1) , (61)

2.0(MB MD∗ )1/2

R∗ = , (62)
(MB + MD∗ )
and
MB2 + MD2 ∗ − q 2
w= (63)
2MB MD∗
To implement a decay model using these form factors we must write two classes

• class EvtHQETFF : public EvtSemiLeptonicFF {

public:
EvtHQETFF(double hqetrho2, double hqetr1, double hqetr2);

void getvectorff( int parent, int daught,

double t, double mass, double *a1f,
double *a2f, double *vf, double *a0f );

private:
double r1;
double rho2;
double r2;
};

• class EvtHQET:public EvtDecayTBase<EvtHQET> {

public:

static void getName(char *name,int &narg);

void Decay(EvtParticle *p);

void InitProbMax();
void Init();

private:
EvtSemiLeptonicFF *hqetffmodel;
EvtSemiLeptonicAmp *calcamp;
};

This class is to implement B → D ∗
ν decays, so only the vector form factor routine must
be provided. The constuctor allows R1, R2 and ρ2 to be passed in as a run time arguement.
We will discuss this point more below. The implementation of EvtHQETFF is quite simple:

59
EvtHQETFF::EvtHQETFF(double hqetrho2, double hqetr1, double hqetr2) {

rho2 = hqetrho2;
r1 = hqetr1;
r2 = hqetr2;
return;
}

void EvtHQETFF::getvectorff( int parent, int daught,

double t, double mass, double *a1f,
double *a2f, double *vf, double *a0f ){

double mb=EvtPDL::nom_mass(parent);
double w = ((mb*mb)+(mass*mass)-t)/(2.0*mb*mass);

// Form factors have a general form, with parameters passed in

// from the arguements.

double rstar = ( 2.0*sqrt(mb*mass))/(mb+mass);

double ha1 = 1-rho2*(w-1);

*a1f = (1.0 - (t/((mb+mass)*(mb+mass))))*ha1;

*a1f = (*a1f)/rstar;
*a2f = (r2/rstar)*ha1;
*vf = (r1/rstar)*ha1;
*a0f = 0.0;

return;
}
The getvectorff routine takes the parent meson, daughter vector meson, q 2 (t), and the
daughter meson mass. The form factors A1 , A2 , V and A0 are returned.
The EvtHQET class is also quite easy to implement. As with other classes which handle
decay models, it is derived from EvtDecayAmp, which is described elsewhere. The class
should provide a Decay routine as well as getName, Init, clone and InitProbMax routines.
Additionally, the form factor model and amplitude calculation implementations are handled
as memeber data. The EvtHQET implementation is:
void EvtHQET::getName(char *model_name,int &narg){

strcpy(model_name,"HQET");
}

60
EvtDecayBase* EvtHQET::clone(){

return new EvtHQET;

void EvtHQET::Decay( EvtParticle *p ){

p->init_daughters(ndaug,daug);
calcamp->CalcAmp(p,hqetffmodel);
}

void EvtHQET::InitProbMax() {

SetProbMax(20000.0);
}

void EvtHQET::Init(){

if ( ndaug!=3 ) {
report(ERROR,"EvtGen") << "Wrong number of daughters in EvtHQET.cc\n";
}

hqetffmodel = new EvtHQETFF(args[0],args[1],args[2]);

calcamp = new EvtSemiLeptonicVectorAmp;
}

This class would be virtually unchanged for different form factor models. In Decay, after ini-
tialization of the daughter particles, CalcAmp (in this case from EvtSemiLeptonicVectorAmp
is called. If the standard form factor parameterizations are used, this routine does not need
to be rewriten. The Init function is responsible for two things. First the correct form
factor model must be initialized. As EvtHQETFF takes arguements, these must be passed
into the constructor. The arguements are otherwise private to the EvtHQET model. Second,
the CalcAmp function must be properly initialized such that the amplitude is calculated
for vector daughter mesons. For models with form factors for daughter mesons of different
spins, the meson spin (EvtPDL::spin(daug[0]) should be used to decide how to initialize
calcamp.
With the existing framework, the implementation of new form factor models should be quite
simple. The majority of the work is in the coding of the form factors themselves

61
11.5 Available models
There are several semileptonic form factor models implemented within EvtGen and the
EvtSemiLeptonicAmp framework. In this section we describe the basic features of each,
including the modes available in each model and what arguements must be passed in. This
is by no means a complete list of all possible semileptonic models, and the authors would
welcome any additional form factor models implemented.

11.5.1 EvtSLPole
• A general pole form is implemented for each form factor, using the form

F (0)
F = 2 4 (64)
(1.0 + a Mq 2 + b Mq 4 )p

where M is the mass of the parent meson.

• Leptons available: e, µ, and τ .

• Arguements: For each form factor there are four arguements, F (0), a, b, and p. Note
that p can be a non-integer.

– For scalar daughters the arguements should be ordered as

F (0)f+ af+ bf+ pf+ F (0)f0 af0 bf0 pf0 .
– For vector daughters the arguements should be ordered as
F (0)A1 aA1 bA1 pA1 F (0)A2 aA2 bA2 pA2 F (0)V aV bV pV F (0)A0 aA0 bA0 pA0
– For tensor daughters the arguements should be ordered as
F (0)k ak bk pk F (0)h ah bh ph F (0)b+ ab+ bb+ pb+ F (0)b− ab− bb− pb−

• In DECAY.DEC

0.0210 D+ e- anti-nu_e SLPOLE .... arguements;

11.5.2 EvtISGW2
• Implementation of form factors defined from Scora and Isgur [7].

• Leptons available: e, µ, and τ .

• Arguements: None

• In DECAY.DEC

0.0210 D+ e- anti-nu_e ISGW2;

We have implemented decays of B,D,Ds , and Bs mesons as described by Scora and Isgur.

62
11.5.3 EvtISGW
• Implementation of form factors defined from Isgur, Scora, Grinstein, and Wise [8].

• Leptons available: e and µ only.

• Arguements: None

• In DECAY.DEC

0.0210 D+ e- anti-nu_e ISGW;

11.5.4 EvtHQET
• Simple implementation of form factors within HQET using a linear form for ρ2 . This
model is described in more detail above.

• Leptons available: e and µ only.

• Arguements:ρ2 , R1, and R2.

• In DECAY.DEC

0.050 D*+ e- anti-nu_e HQET 0.92 1.18 0.72;

This model is most useful for the decay B → D ∗
ν, however no assumptions are made about
either the parent meson or the daughter meson. Any pseudoscalar semileptonic decay to a
vector meson could be modeled using these form factors.

63
12 Lineshape determination (new 11/2002)
12.1 Introduction
This note summarizes the proposed lineshape treatment for SP5 Monte Carlo production in
EvtGen. Some significant changes have been made since SP4 given input from users during
the past year. The generater now works in several steps:

1. The complete decay chain is determined according to the branching fractions given in
EvtGen/DECAY.DEC and the user decay file.

2. The mass of each particle in the decay chain is determined, as described below.

3. The kinematics of each particle are determined according to the decay model specified.

As these are separate steps, the algorithm for the determination of masses is not as
general is would be possible if the mass determination and kinematic determination were
combined. This would entail a more significant code rewrite, which we were not able to
undertake.

12.2 Lineshapes
12.2.1 What is the default?
The short answer is that it depends on the decay. For a particle P , the algorithm is as
follows:

1. Something like 30% of B mesons are decayed using JETSET. If P is produced by

JETSET, then its lineshape is determined by JETSET. JETSET uses a nonrelativistic
Breit-Wigner.

2. If P or any of its daughters has a spin other than 0, 1/2, 1, 3/2, or 2, a nonrelativistic
Breit Wigner is used.

3. If the decay P → D1 D2 proceeds by a higher partial wave than D wave, a nonrel-

ativistic Breit Wigner is used. (in practice, this case appears to never occur in our
DECAY.DEC)

4. G → P P1 and P → D1 D2 (ie, P is produced and decayed in a two body decay): A

relativistic Breit-Wigner is used. The corresponding amplitude is
L
G→P P1 L
P →D1 D2
(pG→P P1 )(pP →D1 D2 ) B(pG→P P1 ) B(pP →D1 D2 )
A(m) = 2 ( )( ) (65)
m − m0 2 + imΓ(m) B(pG→P P1 ) B(pP →D1 D2 )

where m0 is the nominal particle mass as specified in PDT/pdt.table and p is the

daughter momentum in the rest frame of its parent (for the specified decay chain). p

64
 is the same, but for the nominal mass of P. Γ(m) is

2LP →D +1   
1 D2
p m0 B(p)
Γ(m) = Γ0 . (66)
p m B(p )

Here Γ0 is the nominal particle width has specified in PDT/pdt.table. p and p are the
daughter momenta in the rest frame of P , if P has mass m or m0 , respectively. L is
the angular momentum of the decay specified in its subscript, which is assumed to be
the lowest allowed given the parent and daughter spins. B(p) is the Blatt-Weisskopf
form factor, which depends on L:

B(p) = 1
1
B(p) = 
1 + (Rp)2
1
B(p) =  (67)
(Rp)2 (Rp)4
1+ 3 + 9

for LP →D1 D2 equal to 0, 1, or 2. R is 3 GeV−1 .

5. G → P P1 P2 X and P → D1 D2 (ie, P has two daughters): Very similar to the above

case, except the birth momentum factor and form factor are removed:
→D1 D2 L
(pP P→D 1 D2
) B(pP →D1 D2 )
A(m) = 2 ( ) (68)
m − m0 + imΓ(m) B(pP →D1 D2 )
2

6. P → P1 P2 P3 X (ie, P decays to more than two daughters): A nonrelativitic Breit-

Wigner is used.

12.2.2 Mass cutoffs, etc

Cutoffs are listed in PDT/pdt.table. The cutoff given represents the maximum ∆ allowed
from the nominal mass, but only on the low side. That is, the lowest allowed mass is m − ∆.
The highest allowed mass is m + 15Γ. In the case that the cutoff is not given, the lowest
mass is max(0, m − 15Γ).

12.2.3 What can be changed in user decay files?

We have added some flexibility in how lineshapes can be generated for signal Monte Carlo.
We hope that this will simplify systematic studies. The various options are listed below.
As with other features of user decay files, be sure to test your changes with GeneratorsQA
before submitted your request for a Monte Carlo sample.

• Lowest generated mass

65
 ChangeMassMin rho0 0.7

• Highest generated mass

ChangeMassMax rho0 0.9

• Presence of the birth momentum factor and form factor (pP LG→P P1 and corresponding
form factor)

IncludeBirthFactor rho0 no

• Presence of the decay momenum factor and form factor (pD LP →D1 D2 and corresponding
form factor)

IncludeDecayFactor rho0 no

• Blatt-Weisskopf factor (in GeV −1 )

BlattWeisskopf rho 3.0

• Lineshape used. There are a few alternative lineshapes available:

LSNONRELBW rho0
LSFLAT rho0

Note that LSFLAT should be used together with the ChangeMassMin and Change-
MassMax options.

• Mass and width

Particle rho0 0.8 0.2

Some of these are illustrated in Figures 6 to 13 for the ρ mass in the decay B → ρπ and
ρ → ππ.

66
 nominal nominal
Nent = 200000
Mean = 0.7931
1600
RMS = 0.1859

1400

1200

1000

800

600

400

200

0
0 0.5 1 1.5 2 2.5

Figure 6: The nominal ρ mass distribution in B → ρπ and ρ → ππ.

masswid masswid
Nent = 200000
Mean = 0.8293
RMS = 0.2143
1200

1000

800

600

400

200

0
0 0.5 1 1.5 2 2.5

Figure 7: The ρ mass distribution in B → ρπ and ρ → ππ having included Particle rho0

0.8 0.2 in the user decay table.

67
 min7 min7
Nent = 200000
2200 Mean = 0.8442
RMS = 0.1757
2000
1800
1600
1400
1200
1000
800
600
400
200
0
0 0.5 1 1.5 2 2.5

Figure 8: The ρ mass distribution in B → ρπ and ρ → ππ having included ChangeMassMin

rho0 0.7 in the user decay table.

max9 max9
Nent = 200000
2000 Mean = 0.7392
RMS = 0.09405
1800

1600

1400

1200

1000

800

600

400

200

0
0 0.5 1 1.5 2 2.5

Figure 9: The ρ mass distribution in B → ρπ and ρ → ππ having included ChangeMassMax

0.9 in the user decay table.

68
 nodecay nodecay
Nent = 200000
Mean = 0.7493
RMS = 0.1797
1400

1200

1000

800

600

400

200

0
0 0.5 1 1.5 2 2.5

Figure 10: The ρ mass distribution in B → ρπ, ρ → ππ using IncludeDecayFactor rho0

no in the user decay table.

nobirth nobirth
Nent = 200000
Mean = 0.7932
1600
RMS = 0.1861

1400

1200

1000

800

600

400

200

0
0 0.5 1 1.5 2 2.5

Figure 11: The ρ mass distribution in B → ρπ, ρ → ππ using IncludeBirthFactor rho0

no in the user decay table.

69
 nonrel nonrel
Nent = 200000
1600 Mean = 0.8014
RMS = 0.2236
1400

1200

1000

800

600

400

200

0
0 0.5 1 1.5 2 2.5

Figure 12: The ρ mass distribution in B → ρπ and ρ → ππ having included LSNONRELBW

rho0 in the user decay table.

flat flat
Nent = 200000
1200 Mean = 0.7688
RMS = 0.08711

1000

800

600

400

200

0
0 0.5 1 1.5 2 2.5

Figure 13: The ρ mass distribution in B → ρπ and ρ → ππ having included LSFLAT rho in
the user decay table.

70
A Decay models
This section lists the different decay models that has been implemented in EvtGen. It is
strongly urged that all decays that are implemented are added to this list with, at least, a
minimal description of what they are doing.
The models are organized in alphabetical order here. Each model is briefly described
with respect to what decays it can handle and what the arguments mean and one or more
examples are given. For further examples of use please see the decay table, DECAY.DEC

A.1 BHADRONIC
Author:Ryd
Usage:
BrFr P1 P2 ... PN BHADRONIC JH JW;

Explanation:
This is an experimental model for hadronic B decays. Until further developed this is not
recommended to be used. For questions ask Anders Ryd.

A.2 BTO3PI CP
Author:Le Diberder, Versille
Usage:
BrFr P1 P2 P3 BTO3PI CP dm alpha;

Explanation:
This model is for neutral B decays in π − π + π 0 . Several resonances are taken into account: the
ρ(770), the ρ(1450), and the ρ(1700), the generator therefore implements the interferences
between all different final states (e.g. B 0 → ρ+ (770)π − → π + π 0 π − and B 0 → ρ− (770)π + →
π − π 0 π + ). Several Breit-Wigners descriptions are available. By default, the generator is
initialized with relativistic Breit-Wigners according to the Kuhn-Santamaria model where
the parameters have been fitted by Aleph with e+ e− and τ + τ − data [9]. It uses a pole-
compensation method to generate the events efficiently by taking into account the poles due
to the Breit-Wigners of the ρ’s [10].
The generator returns the amplitudes for B 0 → 3π, and B 0 → 3π for the kinematics
of the generated final state. It makes use of values of Tree and Penguins amplitudes and
phases which have been computed by the LPTHE using the factorization approximation and
the Orsay quark model, on the basis of the Isospin relation (no ElectroWeak Penguins are
included here, and the strong phases are set to zero).The ρ0 π 0 gets a very low branching
ratio due to color-suppression [11].

Example:
The example shows how to generate B 0 → π − π + π 0 .

71
Decay B0
1.000 pi- pi+ pi0 BTO3PI_CP dm alpha;
Enddecay

Notes:
This routine makes use of a fortran routine to perform the actual calculation of the amplitude.

A.3 CB3PI-MPP
Author:Le Diberder, Versillé
Usage:
BrFr P1 P2 P3 CB3PI-MPP dm alpha;

Explanation:
This model is for charged B decays in π ± π + π − . It is built on the same basis than the
BTO3PI CP model, making also use of interferences between the three ρ bands: ρ(770), the
ρ(1450), and the ρ(1700). The amplitudes are computed by the LPTHE.

Example:
The example shows how to generate B + → π + π + π − .

Decay B+
1.000 pi+ pi+ pi- CB3PI-MPP dm alpha;
Enddecay

Notes:
This routine makes use of a fortran routine to perform the actual calculation of the amplitude.

A.4 CB3PI-P00
Author:Le Diberder, Versillé
Usage:
BrFr P1 P2 P3 CB3PI-P00 dm alpha;

Explanation:
This model is for charged B decays in π ± π 0 π 0 . It is built on the same basis than the
BTO3PI CP model, making also use of interferences between the three ρ bands: ρ(770), the
ρ(1450), and the ρ(1700). The amplitudes are computed by the LPTHE.

Example:
The example shows how to generate B + → π + π 0 π 0 .

72
Decay B+
1.000 pi+ pi0 pi0 CB3PI-P00 dm alpha;
Enddecay

Notes:
This routine makes use of a fortran routine to perform the actual calculation of the amplitude.

A.5 BTOKPIPI CP
Author: Le Diberder, Versillé
Usage:
BrFr P1 P2 P3 BTOKPIPI CP dm alpha;

Explanation:
This model is for neutral B decays in Kππ (note that the B 0 decays in K + π − π 0 and the B 0
in K − π + π 0 ). It generates interferences between different resonances:

• B 0 → K ∗+ π − , with K ∗+ → K + π 0 ,

• B 0 → K ∗0 π 0 , with K ∗0 → K + π − ,

• B 0 → K − ρ+ , with ρ+ → π + π 0

It also provides the amplitudes for the CP-conjugate channels B 0 → K − π + π 0 . The Tree
and Penguins amplitudes are computed by the LPTHE.

Example:
The example shows how to generate B 0 → K + π − π 0 .

Decay B0
1.000 K+ pi- pi0 BTOKPIPI_CP dm alpha;
Enddecay

Notes:
This routine makes use of a fortran routine to perform the actual calculation of the ampli-
tudes.

A.6 BTO4PI CP
Author:Ryd
Usage:
BrFr P1 P2 P3 P4 BTO4PI CP dm alpha +8 amplitudes;

73
Explanation:
This model is for B → π + π − π + π − . It implements the time dependence of the decay correctly
depending on where in the dalitz plot you are. The amplitudes that needs to be specified
are B → a+ − + − + − + − − + − +
1 π , B̄ → a1 π , B → a2 π , B̄ → a2 π , B → a1 π , B̄ → a1 π , B → a2 π ,
− +

and B̄ → a−
2π .
+

Example:
The example shows how to generate B 0 → π + π − π + π − .

Decay B0
1.000 pi+ pi- pi+ pi- BTP4PI_CP dm alpha 1.0 0.0 1.0 0.0
1.0 0.0 1.0 0.0
1.0 0.0 1.0 0.0
1.0 0.0 1.0 0.0;
Enddecay

Notes:
This routine is still developing.

A.7 BTO2PI CP ISO

Author:NK
Usage:
BrFr P1 P2 BTO2PI CP ISO beta dm |A2 | ϕA2 |A2 | ϕA2 |A0 | ϕA0 |A0 | ϕA0 ;

Explanation:
This model approaches the three B → ππ modes from the point of view of isospin analysis.
0
It is applicable to both the two B 0 (B ) modes, in which case it takes into account mixing,
and to the B + (B − ) mode, as all three modes should indeed be treated together in this
approach. Following the conventions of Lipkin, Nir, Quinn, and Snyder (Phys. Rev. D44,
1454 (1991)), the various decay amplitudes can be written as follows:

A(B + → π + π 0 ) ≡ A+0 = 3 A2 (69)


1 +−
A(B 0 → π + π − ) ≡ A = A2 − A0 (70)
2

A(B 0 → π 0 π 0 ) ≡ A00 = 2 A2 + A0 , (71)

where A2 is the amplitude for If = 2 states (tree only), and A0 , for If = 0 states (where
both tree and penguin contribute).
The model’s parameters are:

74
 • beta = corresponding CKM angle
0
• dm = B 0 B mass difference (≈ 0.5 × 1012 s−1 ).

• |A2 |, ϕA2 = magnitude and phase of the corresponding amplitude

• |A2 |, ϕA2 = magnitude and phase of the amplitude for the CP-conjugate process

• |A0 |, ϕA0 = magnitude and phase of the corresponding amplitude

• |A0 |, ϕA0 = magnitude and phase of the amplitude for the CP-conjugate process

Example:

Decay B0
1.000 pi+ pi- BT02PI_CP_ISO beta dm 1.0 gamma 1.0 -gamma
1.0 gamma 1.0 -gamma;
Enddecay

Notes:
Precise numerical estimates for the amplitudes are not available at the moment.

A.8 BTOKPI CP ISO

Author:NK
Usage:
BrFr PI K BTOKPI CP ISO beta dm |U| ϕU |U| ϕU |V | ϕV |V | ϕV |W | ϕW |W | ϕW ;

Explanation:
This model considers the four B → πK modes from the point of view of isospin analysis. It is
0
applicable to both the two B 0 (B ) modes and to the two B + (B − ) modes, as all four modes
should indeed be treated together in this approach. Following the conventions of Lipkin,
Nir, Quinn, and Snyder (Phys. Rev. D44, 1454 (1991)), the various decay amplitudes can
be written as follows:
A(B + → π 0 K + ) ≡ A0+ = U − W (72)

+ + 0 1 +0
A(B → π K ) ≡ A =V + W (73)
2

1 −+
A(B 0 → π − K + ) ≡ A =V − W (74)
2

A(B 0 → π 0 K 0 ) ≡ A00 = U + W, (75)

75
 where W , U, and V are linear combinations of the three independent amplitudes AIt ,If
for various transition (It ) and final (If ) isospins (please see the reference for more details).
Note that both U and V are tree-only amplitudes, whereas W includes both tree and penguin
contributions.
The model’s parameters are:

• beta = corresponding CKM angle

0
• dm = B 0 B mass difference (≈ 0.5 × 1012 s−1 ).

• |U|, ϕU = magnitude and phase of the corresponding amplitude

• |U|, ϕU = magnitude and phase of the amplitude for the CP-conjugate process

• |V |, ϕV = magnitude and phase of the corresponding amplitude

• |V |, ϕV = magnitude and phase of the amplitude for the CP-conjugate process

• |W |, ϕW = magnitude and phase of the corresponding amplitude

• |W |, ϕW = magnitude and phase of the amplitude for the CP-conjugate process

Example:

Decay B0
1.000 K+ pi- BTOKPI_CP_ISO beta dm 1.0 gamma 1.0 -gamma
1.0 gamma 1.0 -gamma
1.0 gamma 1.0 -gamma;
Enddecay

Notes:
Precise numerical estimates for the amplitudes are not available at the moment.

A.9 BTOXSGAMMA
Author: Francesca Di Lodovico, Jane Tinslay, Mark Ian Williams
Usage:
BrFr P1 P2 BTOXSGAMMA model or
Usage:
BrFr P1 P2 BTOXSGAMMA model F mB mb µ λ1 δ z (number of intervals to
compute αs ) (number of intervals tocompute the hadronic mass)

Explanation:
This model is for two-body non-resonant B → Xs γ decays where strange hadrons, Xs , are

76
generated with a linewidth given by the mass spectrum predicted by either Ali and Greub [12]
or Kagan and Neubert [13] model, according to the first parameter in the datacards given
after the model is chosen. In case the Ali and Greub model is chosen, a parameterisation of
the mass spectrum predicted for given inputs is used. The input parameters where based on
PDG 2000 values plus a b quark Fermi momentum of 265 MeV for a spectator quark mass of
150 MeV, which was taken from CLEO fits of the semileptonic B momentum spectrum. In
case the Kagan and Neubert model is used, the input parameters can be given as an input
in the datacards. The are: F = Fermi momentum model (1 = exponential shape function,
2 = gaussian shape function, 3 = roman shape function), mB , mb , µ, λ1 , δ, z, number of
intervals to compute αs , number of intervals to compute the hadronic mass. Moreover, as
a possible option, no input parameters can be given after the Kagan and Neubert model is
chosen, and in this case default input parameters are chosen ( F = 1, mB = 5.27885 GeV/c2 ,
mb = 4.80 GeV/c2 , µ = 4.80 GeV/c2 , λ1 = 0.3, δ = 0.9, z = 0.084, number of intervals to
compute αs = 100, number of intervals to compute the hadronic mass = 80). A a cut–off on
the hadronic mass at 1.1 GeV/c2 is applied in this case according to [13].
The maximum mass value for all Xs is 4.5 GeV/c2 and the minimum mass value is at
the Kπ threshold for Xsu and Xsd , and at the KK threshold for Xss . JETSET is required to
decay the resulting Xs into hadrons via phase-space production from the available quarks.
The decay of Xs needs to be switched on in the decay file using JETSET switches.

Example:
The example shows how to generate B 0 → Xsd γ for the Ali and Greub Model.

# Xsd meson (sbar-d system, introduced for b->s gamma decays)

# Set Xsd so it can decay:

JetSetPar MDCY(455,1)=1
# Set decay table entry pt for Xsd:
JetSetPar MDCY(455,2)=1154
# Number of decay channels for Xsd:
JetSetPar MDCY(455,3)=1
# Switch on Xsd decay
JetSetPar MDME(1154,1)=1
# Phase space decays into hadrons from available quarks
JetSetPar MDME(1154,2)=11
# Xsd decays into two quarks a d and an anti-s
JetSetPar KFDP(1154,1)=-3
JetSetPar KFDP(1154,2)=1

Decay B0
1.0000 Xsd gamma BTOXSGAMMA 1;
Enddecay

77
Notes:
P1 should always be reserved for the Xs particle and P2 should always be a gamma. Also,
this model requires Jst74 V00-00-11 or higher to work.

A.10 D DALITZ;
Author:Kuznetsova
Usage:
BrFr D1 D2 D3 D DALITZ;

Explanation:
The Dalitz amplitude for three-body Kππ D decays; namely, for decays

• D + → K − π + π + or D − → K + π − π − ,
∗ ∗ ∗
with the resonances (for the D + mode) K (892)0π + , K (1430)0 π + , and K (1680)0 π + ,
using data from the E691 Fermilab experiment [14].
0
• D + → K π + π 0 or D − → K 0 π − π 0 ,
∗ 0
with the resonances (for the D + mode) K (892)0π + , and K ρ+ , using data from
MARK III [15].
0 0
• D 0 → K π + π − or D → K 0 π − π + ,
0
with the resonances (for the D 0 mode) K ∗ (892)− π+ and K ρ(770)0, using data from
[14].
0
• D 0 → K − π + π 0 or D → K + π − π 0 ,
∗
with the resonances (for the D 0 mode) K (892)0π 0 , K ∗ (892)− π + , and K − ρ(770)+ ,
using data from [14].
0
Be aware that the D + → K π + π 0 and D − → K 0 π − π 0 modes currently use the results
from Mark III [15], which are based on rather limited statistics.

Example:
To generate the decay D + → K − π + π + the following entry in the decay table should be
used

Decay D+
1.000 K- pi+ pi+ D_DALITZ;
Enddecay

Notes:
The order in which the particles are listed is very important: the kaon should always be
first, and for the modes with the neutral pion the π 0 should always be last.

78
A.11 GOITY ROBERTS
Author:Alain,Ryd
Usage:
BrFr M1 M2 L N GOITY ROBERTS ;

Explanation:
Model for the non-resonant D (∗) π
ν decays of B mesons. The daughters are in the order:
D-meson, pion, lepton and last the neutrino.

Example:
Decay B0
1.000 D0B pi- e+ nu_e GOITY_ROBERTS;
Enddecay

Notes:
This is not exactly what was published by Goity and Roberts [16], partly due to errors in
the paper and because the D ∗ had to be removed from the Dπ non-resonant.

A.12 HELAMP
Author:Ryd
Usage:
BrFr M D1 D2 HELAMP Amplitudes;

Explanation:
This model allows simulation of any two body decay by specifying the helicity amplitudes for
the final state particles. The helicity amplitudes are complex numbers specified as pairs of
magnitude and phase. The amplitudes are ordered, starting by the highest allowed helicity
for the first particle. For a fixed helicity of the first particle the amplitudes are then specified
starting with the highest allowed helicity of the second particle. This means that the helicities
Hλ1 λ2 are ordered first according the the value of λ1 and then the value of λ2 .

Example:
Decay of B 0 − > D∗ ρ,
Decay B+
1.000 anti-D*0 rho+ HELAMP 0.228 0.95 0.283 1.13 0.932 0;
Enddecay

Notes:
The amplitudes are taken from ICHEP 98-852. This model has been tested on many special
cases, but further testing is needed.

79
A.13 HQET
Author:Lange
Usage:
BrFr M L N HQET RHO2 R1 R2;

Explanation:
Model for the D ∗
ν decay of B mesons according to a HQET inspired parameterization.
The daughters are in the order: D ∗ , lepton and last the neutrino. Since only the three form
factors that contributes in the zero lepton mass limit are included the model is not accurate
for τ ’s. The arguments, RHO2, R1, and R2 are the form factor slope, ρ2A1 and the form factor
ratios R1 and R2 respectively. These are defined, and measured, in [17]

Example:
Decay of B 0 → D ∗
ν using HQET model

Decay B0
1.000 D*- e+ nu_e HQET3S1 0.92 1.18 0.72;
Enddecay

Notes:
The values in the example above comes from the measurement in [17] by the CLEO collab-
oration.

A.14 HQET2
Author:Ishikawa
Usage:
BrFr M L N HQET2 RHO2 R1 R2;

Explanation:
Model for the D ∗
ν decay of B mesons according to the dispersive relation [18]. The daugh-
ters are in the order: D ∗ , lepton and last the neutrino. The arguments, RHO2, R1, and R2
are the form factor slope, ρ2A1 and the form factor ratios R1 and R2 respectively.

Example:
Decay of B 0 → D ∗
ν using HQET model

Decay B0
1.000 D*- e+ nu_e HQET2 1.35 1.3 0.8;
Enddecay

80
Notes:
The values in the example above comes from the measurement in [19] by the Belle collabo-
ration.

A.15 ISGW
Author:Lange, Ryd
Usage:
BrFr D1 D2 D3 ISGW ;

Explanation:
This is a model for semileptonic decays of B, and D mesons according to the ISGW model [8].
The first daughter is the meson produced in the semileptonic decay. The second and third
argument is the lepton and the neutrino respectively. See Section 11 for more details about
semileptonic decays.

Example:
The example shows how to generate B̄ 0 → D ∗+ eν

Decay anti-B0
1.000 D*+ e- anti-nu_e ISGW;
Enddecay

Notes:
This model does not include the A3 form factor that is needed for non-zero mass leptons,
i.e., tau’s. If tau’s are generated the A3 form factor will be zero.

A.16 ISGW2
Author:Lange, Ryd
Usage:
BrFr D1 D2 D3 ISGW2 ;

Explanation:
This is a model for semileptonic decays of B, D, and Ds mesons according to the ISGW2
model [7]. The first daughter is the meson produced in the semileptonic decay. The second
and third argument is the lepton and the neutrino respectively. See Section 11 for more
details about semileptonic decays.

Example:
The example shows how to generate B̄ 0 → D ∗+ eν

81
Decay anti-B0
1.000 D*+ e- anti-nu_e ISGW2;
Enddecay

Notes:
This model has been fairly well tested for B decays, most form factors and distributions
have been compared to the original code that we obtained from D. Scora.

A.17 JETSET
Author:Ryd, Waldi
Usage:
BrFr D1 D2 DN JETSET MODE;

Explanation:
A particle who’s decay is not implanted in EvtGen can be decayed by calling JetSet using
this model as an interface. The decays that uses the JETSET model are converted into the
JetSet decay table format and read in by JetSet. However, if JetSet produces a final state
which is explicitly listed as another decay of the parent it is rejected. E.g. consider this
example:

Decay J/psi
0.0602 e+ e- VLL;
0.0602 mu+ mu- VLL;
.
.
.
0.8430 rndmflav anti-rndmflav JETSET 12;
Enddecay

In this example if JetSet decays the J/Ψ to e+ e− or µ+ µ− the decay is rejected and regen-
erated. For more details about the EvtGen-Jetset interface see Appendix E.

Notes:
As discussed in Appendix E the JETSET model can not be used to decay a particle that is
an alias. This is bacause JetSet does not allow for more than one decay table per particle.

A.18 JSCONT
Author:Ryd, Kim
Usage:
BrFr JSCONT Flavor;

82
Explanation:
This decay model is for generation of continuum events at the Υ(4S). It uses JetSet to
fragment quark strings. The flavor of the primary string is given as the argument to the
model and 1 means a dd, ¯ 2 is uū, 3 is ss̄ and 4 is cc̄. If the flavor is 0 a mixture of the quarks
will be generated in the appropriate amounts. The first particle that is created is the vpho
which can be decayed using this decay model. The primary jets are created according to a
1 + cos2 θ distribution, where θ is the angle of the primary jet with respect to the beam line,
or more precisely the z-axis.

Example:
Decay vpho
1.000 JSCONT 1;
Enddecay

A.19 KLL3P
Author:Rotondo
Usage:
BrFr K L1 L2 KLL3P ;

Explanation:
Implementation for the process B → Kl+ l− , as the previous model the form-factors are
calculated in the framework of three-point QCD sum-rules [20].

Example:
The example shows how to generate B + → K + e+ e−
Decay B+
1.000 K+ e+ e- KLL3P;
Enddecay

Notes:
Only Short Distance interaction are considered.

A.20 KSLLLCQCD
Author:Rotondo
Usage:
BrFr K* L1 L2 KSLLLCQCD ;

Explanation:
Implementation of the process B → K ∗ l+ l− . In this model the hadronic part of the matrix
element is calculated in the framework of the light-cone QCD sum rules [21].

83
Example:
The example shows how to generate B 0 → K ∗0 τ + τ − .

Decay B0
1.000 K*0 tau+ tau- KSLLLCQCD;
Enddecay

Notes:
In the Aliev’s paper [21] are taken in account some effects out the Standard-Model, this
implementation recover only the SM part of the interaction.
Only Short Distance contribution are considered.
Warning: a cut-off on the q 2 of the lepton pair are introduced. The q 2 is required to be greater
than 0.08GeV 2 , to avoid a large spend of time for the generation of the right configuration.
This approximation is not useful for B → K ∗ e+ e− .

A.21 KSLL3PQCD
Author:Rotondo
Usage:
BrFr K* L1 L2 KSLL3PQCD ;

Explanation:
Implementation for the process B → K ∗ l+ l− in which the hadronic part of the matrix
element is calculated in the framework of the three-point QCD sum rules [20].

Example:
The example shows how to generate B 0 → K ∗0 µ+ µ− .

Decay B0
1.000 K*0 mu+ mu- KSLL3PQCD;
Enddecay

Notes:
Only Short Distance interaction are considered.
Warning: as the previous model.

A.22 LNUGAMMA
Author:edward
Usage:
BrFr L NU GAMMA LNUGAMMA PMC R M B FAFVZERO;

84
Explanation:
Calculation of the tree-level matrix element for the process B + → l+ νl γ [22].

Example:
The example shows how to generate B + → l+ νl γ.

Decay B0
1.0000 e+ nu_e gamma LNUGAMMA 0.35 3.0 5.0 0;
Enddecay

Notes:
See the citation given above for more detail.
Arg(0) is the photon mass cutoff in GeV , Arg(1) is R in GeV −1 , Arg(2) is mb in GeV ,
and Arg(3) is set to 0 if the user wants |fa /fv | = 1, and set to 1 if the user wants fa /fv = 0.
Arg(3) is optional, defaulting to 0.

A.23 MELIKHOV
Author:Lange
Usage:
BrFr M L NU MELIKHOV ;

Explanation:
Implements the form factor model for B → ρ
ν according to Melikhov, as described in
hep-ph/9603340. There is one argument, which should be an integer between 1 and 4. The
arguement sets which set of form factors from Melikhov should be used.

Example:
The example shows how to generate B 0 → ρ− µ+ νµ .

Decay B0
1.000 rho- mu+ nu_mu MELIKHOV 1;
Enddecay

A.24 OMEGA DALITZ

Author:Lange
Usage:
BrFr P1 P2 P3 OMEGA DALITZ ;

Explanation:
The dalitz amplitude for the decay ω → π + π − π 0 . The amplitude for this process is given by
A = µναβ pµπ+ pνπ− pαπ0 εβ .

85
Example:

Decay omega
1.000 pi+ pi- pi0 OMEGA_DALITZ;
Enddecay

A.25 PARTWAVE
Author:Ryd
Usage:
BrFr M D1 D2 PARTWAVE Amplitudes;

Explanation:
This model is similar to the HELAMP model in that it allows any two-body decay specified by
the partial wave amplitudes. This model translates the partial wave amplitudes to helicity
amplitudes using the Jacob Wick transformation. The partial wave amplitudes are complex
numbers, specified as a magnitude and a phase. The amplitudes MLS are sorted on the
highest value of L and then on the highest value of S.

Example:
Decay of B 0 − > D∗ ρ in this example would be in pure P -wave.

Decay B+
1.000 anti-D*0 rho+ PARTWAVE 0.0 0.0 1.0 0.0 0.0 0.0;
Enddecay

Notes:
This model has been tested on some special cases, but further testing is needed.

A.26 PHSP
Author:Ryd
Usage:
BrFr P1 P2 ... PN PHSP ;

Explanation:
Generic phase space to n-bodies. All spins of particles in the initial state and the final state
are averaged.

Example:
As an example of using this model the decay D 0 → K ∗− π + π 0 π 0 is used.

86
Decay D0
1.000 K*- pi+ pi0 pi0 PHSP;
Enddecay

A.27 PTO3P
Author:Dvoretskii
The PTO3P model is a generic decay-file driven model for simulating decays of a scalar
(typically pseudoscalar, hence the P) particle into a final state composed of three scalar
particles. B + → K + π + π − would be an example of such a decay.
It is possible to specify several channels through which the decay can proceed. The
interference effects are proprely handled by the model. It is also possible to include time-
dependent mixing in decays of neutral mesons.

Explanation:
For an example of a decay, see the example below. The first two parameters specify the PDF
maximum (e.g. MAXPDF 116.2). The PDF maximum is needed to perform accept/reject
during generation. Alternatively if the maximum is not known one can specify the number
of points that will be sampled SCANPDF 10000. The PDF will be evaluated at each point.
To be conservative this maximum will be increased by 20%. Typically it’s a good idea to
do the scan once for a large number of events. Determine the maximum and then put it
explicitly in the decay file.
The other parameters are grouped into partial AMPLITUDE specifications and COEFFICIENT
specifications. Compelex coefficients can be in cartesian or polar coordinates. The keywords
are: CARTESIAN for cartesian coordinates and POLAR RAD and POLAR DEG for polar coordi-
nates.
Partial amplitudes can be either PHASESPACE or RESONANCE. For amplitudes describing
intermediate resonances one should specify which two particles form the resonance (AB, BC,
CA), and the parameters of the resonance - spin, mass and width. The resonance parameters
can be specified, either as three numbers or as the particle name. In the latter case the
parameters will be taken from the evt.pdl file. Finally, it’s possible to get the spin from the
evt.pdl file and override the mass and the width of the particle. Examples:

RESONANCE BC 1 0.77 0.15

RESONANCE BC rho+
RESONANCE BC rho+ 0.77 0.15

ANGULAR AB declares between which two particles the helicity angle will be evaluated.
(The rest frame was specified previously, e.g. RESONANCE BC. This disambiguates the sign of
the amplitude.
TYPE specifies the type of the propagator. Choose between non-relativistic Breit-Wigner
(NBW), relativistic Zemach expression (RBW ZEMACH), Kuehn-Santamaria propagator (RBW KUEHN)
and relativistic propagator used e.g. in CLEO hep-ex/0011065 (RWB CLEO).

87
 Finally it’s possible to supply Blatt-Weisskopf form factors at the production (birth)
vertex of the resonance and its decay vertex.

DVFF BLATTWEISSKOPF 3.0

BVFF BLATTWEISSKOPF 1.0

For decays with mixing, e.g. B 0 → π + π − π 0 first specify partial amplitudes for B 0 →
π + π − π 0 , then stick in keyword CONJUGATE followed by mixing parameters (currently dm).
Then specify partial amplitudes for B¯0 → π + π − π 0 in the usual way.
For very narrow resonances the generation efficiency may be very low. In that case one
should use pole compensation. In PTO3P pole-compensation is automatically turned on
for all resonances. The pole-compensator PDF is created by the same factory that creates
the amplitude. EvtDalitzBwPdf is used for that purpose. If you would like to switch off
pole-compensation you’ll need to edit EvtPto3PAmpFactory.cc, there is no way to control it
via the decay file at this point.

Example:
The example below shows the decay D + → K̄ 0 π + π 0 including the ρ+ and K̄ ∗0 resonances.

Decay D+

1.0 anti-K0 pi+ pi0 PTO3P

MAXPDF 75.0
#SCANPDF 10000
#gives 73.5

# Non-resonant
AMPLITUDE PHASESPACE
COEFFICIENT POLAR_RAD 0.9522 -1.8565

# rho+ (770)
AMPLITUDE RESONANCE BC rho+ 0.7699 0.1512
ANGULAR AC
TYPE RBW_CLEO
DVFF BLATTWEISSKOPF 25.38
COEFFICIENT POLAR_RAD 0.389 0.0

# anti-K*0 (770)
AMPLITUDE RESONANCE AC anti-K*0 0.89159 0.0498
ANGULAR BC
TYPE RBW_CLEO
DVFF BLATTWEISSKOPF 10.15
COEFFICIENT POLAR_RAD 0.194 0.7191

88
 ;
Enddecay

A.28 SINGLE
Author:Ryd
Usage:
BrFr P SINGLE pmin pmax [cthetamin cthetamax [phimin phimax]];

Explanation:
Generates single particle rays in the region of phase space specified by the arguments. This
single particle generator generates decays uniformly in the parents rest frame in the momen-
tum range from pmin to pmax. However, the range of θ is specified in the lab frame.
The last two and four arguments need not be specified. If the last two are omitted the φ
range is from 0 to 2π and if the last four arguments are omitted the cos θ range is from −1
to +1.

Example:
Generates µ+ with momentum from 0.5 to 1.0 GeV over 4π.

Decay Upsilon(4S)
1.000 mu+ SINGLE 0.5 1.0 -1.0 1.0 0.0 6.283185;
Enddecay

or simply

Decay Upsilon(4S)
1.000 mu+ SINGLE 0.5 1.0;
Enddecay

A.29 SLN
Author:Songhoon,Ryd
Usage:
BrFr L N SLN ;

Explanation:
This decay generates the decay of a scalar to a lepton and a neutrino. The amplitude for
this process is given by A = P ν 
|(V − A)ν |ν.

Example:
As an example of using this model the decay Ds+ → µ+ ν̄ is used.

89
Decay DS+
1.000 mu+ nu_mu SLN;
Enddecay

A.30 SLPOLE
Author:Lange
Usage:
BrFr M L NU SLPOLE arguments;

Explanation:
Implements a semileptonic decay according to a pole form parametrization. For definition
of the form factors that are used see section 11.5.1.

Example:
The example shows how to generate B 0 → ρ− µ+ νµ .

Decay B0
1.000 rho- mu+ nu_mu SLPOLE 0.27 -0.11 -0.75 1.0 0.23 -0.77
-0.40 1.0 0.34 -1.32 0.19 1.0 0.37 -1.42 0.50 1.0;

Enddecay

A.31 SSD CP
Author:Ryd
Usage:
BrFr S D SSD CP dm dgog |q/p| arg(q/p) |A f| argA f |barA f| argbarA f
|A barf| argA barf |barA barf| argbarA barf |z| arg(z);

Explanation:
This model simulates the decay of a B meson to a scalar and one other particle of arbitrary
(integer) spin. An example of using this model is B → J/ψKS

Decay B0
1.000 J/psi K0S SSD_CD dm dgog |qop| arg(qop)
|Af| arg(Af) |Abarf| arg(Abarf)
|Afbar| arg(Afbar) |Abarfbar| arg(Abarfbar)
|z| arg(z);
Enddecay

where dm is the mass difference of the two mass eigenstates, dgog is 2y, y ≡ (ΓH −
ΓL )/(ΓH + ΓL ). qop is q/p where |BL,H  = p|B 0  ± q|B̄ 0 . Af and Abarf are the amplitudes
for the decay of a B 0 and a B̄ 0 respectively to the final state f . The set of amplitudes, Afbar

90
and Abarfbar corresponds to the decay to the CP conjugate final state. These amplitudes
are optional and are by default Af¯ = Ā∗f and Āf¯ = A∗f , consistent with CP T for a common
final state of the B 0 and B̄ 0 . However, in modes such as B → D ∗ π it is usefull to be able to
specify these amplitudes separately.
The example below shows the decays B → J/ψKS and B → J/ψKL
Define dm 0.472e12
Define minusTwoBeta -0.85
Decay B0
0.5000 J/psi K0S SSD_CD dm 0.0 1.0 minusTwoBeta 1.0 0.0 -1.0 0.0;
0.5000 J/psi K0L SSD_CD dm 0.0 1.0 minusTwoBeta 1.0 0.0 1.0 0.0;
Enddecay
Note that the sign of the amplitude for the B̄ 0 decay have the oposite sign for the KS as
this final state is odd under parity.
To generate the final state π + π − .
Define dm 0.472e12
Define minusTwoBeta -0.85
Define gamma 1.0
Decay B0
1.0000 pi+ pi- SSD_CD dm 0.0 1.0 minusTwoBeta 1.0 gamma 1.0 -gamma;
Enddecay
These examples have used |q/p| = 1 and ∆Γ = 0. An example with non-trivial values for
these parameters would be Bs → J/ψη
Define dms 14e12
DEfine dgog 0.1
Decay B_s0
1.0000 J/psi eta SSD_CD dms dgog 1.0 0.0 1.0 0.0 1.0 0.0;
Enddecay
This model can also be used for final states that are not CP eigenstates, such as B 0 →
D π and B 0 → D ∗− π + . We can generate these decays using
∗+ −

Define dms 14e12

Define minusTwoBeta -0.85
Define gamma 1.0
Decay B0
1.0000 D*+ pi- SSD_CD dm 0.0 1.0 minusTwoBeta 1.0 0.0 0.3 gamma;
Enddecay
Where the Cabibbo-suppressed decay has a relative strong phase γ with respect to the
Cabibbo-favored decay.

Notes:
For more details about the treatment of CP violating decays see Section 10.

91
A.32 SSS CP
Author:Ryd
Usage:
BrFr S S SSS CP ALPHA dm cp |A| argA |barA| argbarA;

Explanation:
Decay of a scalar to two scalar and allows for CP violating time asymmetries. The first
argument is the relevant CKM angle in radians. The second argument is the mass difference
in s− 1 (approx 0.5 × 1012 ). cp is the CP of the final state, it is ±1. Next is the amplitude of
a B 0 to decay to the final state, where the third argument is the magnitude of the amplitude
and the fourth is the phase. The last two arguments are the magnitude and phase of the
amplitude for a decay of a B̄ 0 to decay to the final state. This model then uses these
amplitudes together with the time evolution of the B B̄ system and the flavor of the other
B to generate the time distributions.

Example:
This example decays the B meson to π + π −
Decay B
1.000 pi+ pi- SSS_CP alpha dm 1.0 0.0 1.0 0.0;
Enddecay

Notes:
For more details about the treatment of CP violating decays see Section 10.

A.33 SSS CP PNG

Author:Ryd, Kuznetsova
Usage:
BrFr S S SSS CP PNG BETA GAMMA DELTA dm cp |Atree | |Atree |/|Apenguin|;

Explanation:
This model takes into account penguin contributions in B → π π decays. It assumes single
(top) quark dominance for the penguin. The first two arguments are the relevant CKM
angles in radians; the third argument is the relative strong phase in radians; dm is the mass
difference in s−1 (approx 0.5 × 1012 ); cp is the CP of the final state; |Atree | is the tree-level
amplitude, and |Atree |/|Apenguin| is the ratio of the amplitudes for the tree and penguin
diagrams (≈ 0.2 for this decay mode). This model automatically takes into account the
correct number of B 0 tags for this decay, which is given by:

2 2 (1−|r f |2 )
|Af | 1 + |rf | + 1+x2d
f=   (76)
(1−|r f |2 ) (1−|rf |2 )
|Af |2 1 + |rf |2 + 1+x2d
+ |Af |2 1 + |rf |2 + 1+x2d

92
 ∆m
where xd ≡ Γ
≈ 0.65, and
Af 1
rf = e2i φM , rf = (77)
Af rf
φM being the mixing angle, and the amplitude Af being:

Af ≡ A(B 0 → π + π − ) = At eiφt + Ap eiφp eiδ (78)

with
0
Af ≡ A(B → π + π − ) = At e−iφt + Ap e−iφp eiδ (79)
Here, At , φt are tree-level amplitude and phase, respectively, Ap , φp are those for the
penguin, and δ is the relative strong phase.

Example:
This example generates B 0 → π + π − .
Decay B0
1.000 pi+ pi- SSS_CP_PNG beta gamma 0.1 dm 1.0 1.0 0.2;
Enddecay

Notes:
For more details about the treatment of CP violating decays see section 10.

A.34 STS
Author:Ryd
Usage:
BrFr T S STS ;

Explanation:
This model decays a scalar meson to a tensor and a scalar.

Example:
This example decays the B + meson to D2∗ 0π +
Decay B+
1.000 D_2*0 pi+ STS;
Enddecay

A.35 STS CP
Author:Ryd
Usage:
BrFr T S STS CP ALPHA dm cp |A| argA |barA| argbarA;

93
Explanation:
Decay of a scalar to a tensor and a scalar and allows for CP violating time asymmetries.
The first argument is the relevant CKM angle in radians. The second argument is the mass
difference in s− 1 (approx 0.5 × 1012 ). cp is the CP of the final state, it is ±1. Next is the
amplitude of a B 0 to decay to the final state, where the third argument is the magnitude of
the amplitude and the fourth is the phase. The last two arguments are the magnitude and
phase of the amplitude for a decay of a B̄ 0 to decay to the final state. This model then uses
these amplitudes together with the time evolution of the B B̄ system and the flavor of the
other B to generate the time distributions.

Example:
This example decays the B meson to a02 π 0
Decay B0
1.000 a_20 pi0 STS_CP alpha dm 1.0 0.0 1.0 0.0;
Enddecay

Notes:
For more details about the treatment of CP violating decays see section 10.

A.36 SVP HELAMP

Author:Ryd
Usage:
BrFr V P SVP HELAMP |H+| argH+ |H-| argH-;

Explanation:
The decay of a scalar to a vector and a photon. This decay is parameterized by the helicity
amplitudes H+ and H− . For more information about helicity amplitudes see Section F/

Example:
Decay B0
1.000 K*0 gamma SVP_HELAMP 1.0 0.0 1.0 0.0;
Enddecay

A.37 SVS
Author:Ryd
Usage:
BrFr V S SVS ;

Explanation:
The decay of a scalar to a vector and a scalar. The first daughter is the vector meson.

94
Example:
As an example we consider B → D ∗ π.

Decay B0
1.000 D*+ pi- SVS;
Enddecay

A.38 SVS CP
Author:Ryd
Usage:
BrFr V S SVS CP ALPHA dm cp |A| argA |barA| argbarA;

Explanation:
Decay of a scalar to a vector and a scalar and allows for CP violating time asymmetries.
The first daughter has to be the vector. The first argument is the relevant CKM angle in
radians. The second argument is the mass difference in s− 1 (approx 0.5 × 1012 ). cp is the CP
of the final state, it is ±1. Next is the amplitude of a B 0 to decay to the final state, where
the third argument is the magnitude of the amplitude and the fourth is the phase. The last
two arguments are the magnitude and phase of the amplitude for a decay of a B̄ 0 to decay
to the final state. This model then uses these amplitudes together with the time evolution
of the B B̄ system and the flavor of the other B to generate the time distributions.

Example:
This example decays the B 0 meson to J/ΨKs
Decay B0
1.000 J/psi K_S0 SVS_CP beta dm 1.0 0.0 1.0 0.0;
Enddecay

Notes:
For more details about the treatment of CP violating decays see Section 10.

A.39 SVS CP ISO

Author:NK
Usage:
BrFr V S SVS CP ISO beta dm flip |T +0 | argT +0 |T +0 | argT +0
|T 0+ | argT 0+ |T 0+ | argT 0+
|T +− | argT +− |T +− | argT +−
|T −+ | argT −+ |T −+ | argT −+
|P0 | argP0 |P0 | argP0
|P2 | argP2 |P2 | argP2 ;

95
Explanation:
This model considers B decays into a vector (V ) and a scalar (S) from the point of view of
0
isospin analysis. The vector should always be listed first. For the three B 0 (or B ) modes
(B 0 → V + S − , B 0 → V − S + , and B 0 → V 0 S 0 ), it takes into account mixing, and generates
the corresponding CP-violating asymmetries. It can also be used for the two isospin-related
B + (B − ) modes (e.g., B + → V + S 0 and B + → V 0 S + ), as all five modes should be treated
together in this approach. Following the conventions of Lipkin, Nir, Quinn, and Snyder
(Phys. Rev. D44, 1454 (1991)), the various decay amplitudes can be written as follows:
√
A(B + → V + S 0 ) ≡ 2A+0 = T +0 + 2P1 (80)
√
A(B + → V 0 S + ) ≡ 2A0+ = T 0+ − 2P1 (81)
A(B 0 → V + S − ) ≡ A+− = T +− + P1 + P0 (82)
A(B 0 → V − S + ) ≡ A−+ = T −+ − P1 + P0 (83)
A(B 0 → V 0 S 0 ) ≡ 2A00 = T 0+ + T +0 − T −+ − T +− − 2P0 (84)
where the amplitudes T ij contain no penguin contributions, P1 is penguin amplitude for
the final I = 1 state, and P0 , for the final I = 0 state.
The model’s arguments are:
• beta = corresponding CKM angle
0
• dm = B 0 B mass difference (≈ 0.5 × 1012 s−1 ).
• “flip” sets the fraction of B → f to B → f decays, where the state specified in the
.DEC table is considered the “f ” state. Set it to 0 to always get the B → f case, and
to 1 to always get the B → f case.
• |T +0 |, ϕT +0 = magnitude and phase of the corresponding amplitude
• |T +0 |, ϕT +0 = magnitude and phase of the corresponding amplitude for the CP-
conjugate process.
• |T 0+ |, ϕT 0+ = magnitude and phase of the corresponding amplitude
• |T 0+ |, ϕT 0+ = magnitude and phase of the corresponding amplitude for the CP-
conjugate process.
• |T +− |, ϕT +− = magnitude and phase of the corresponding amplitude
• |T +− |, ϕT +− = magnitude and phase of the corresponding amplitude for the CP-
conjugate process.
• |T −+ |, ϕT −+ = magnitude and phase of the corresponding amplitude
• |T −+ |, ϕT −+ = magnitude and phase of the corresponding amplitude for the CP-
conjugate process.

96
 • |P0 |, ϕP0 = magnitude and phase of the corresponding amplitude

• |P0 |, ϕP0 = magnitude and phase of the corresponding amplitude for the CP-conjugate
process.

• |P2 |, ϕP2 = magnitude and phase of the corresponding amplitude

• |P2 |, ϕP2 = magnitude and phase of the corresponding amplitude for the CP-conjugate
process.

Example:
This example decays the B 0 meson to a− +
1 π assuming no penguin contributions

Decay B0
1.000 a_1- pi+ SVS_CP_ISO beta dm 0.0 1.0 0.0 1.0 0.0
1.0 0.0 1.0 0.0
1.0 gamma 3.0 -gamma
3.0 gamma 1.0 -gamma
0.0 0.0 0.0 0.0;

Enddecay

Notes:
For more details about the treatment of CP violating decays see section 10.

A.40 SVS NONCPEIGEN

Author:Natalia,Ryd
Usage:
BrFr V S SVS NONCPEIGEN
alpha dm flip |Af | argAf |Af | argAf
|Af | argAf |Af | argsAf ; [these are optional]

Explanation:
This model allows to generate scalar → vector + scalar decays, where the final state is
not a CP-eigenstate. The flip parameter sets the fraction of f to f¯ decays, where the
state specified in the .DEC table is considered the “f ” state. Set it to 0 to always get the
final f case, and to 1 to always get the f final state. Otherwise, set it to 0.5 to get the
physical situation. This model automatically generates the correct number of B 0 and B̄ 0
tags, depending on the specified amplitudes.

97
 Note that the last four parameters are optional. If they are not specified, then they are
evaluated from the following relations between the complex amplitudes:

Af = Af
Af = Af (85)

Example:
This example will generate a mixture of a+ − − +
1 π and a1 π final states with the appropriate
0 0
number of B and B̄ tags. Note that the last 4 parameters could have been omitted, since
they agree with Eq. (85)

Alias MYB B0
Decay Upsilon(4S)
1.00 MYB B0
Enddecay
Decay MYB
1.000 a_1- pi+ SVS_NONCPEIGEN alpha dm 0.5
1.0 0.0 3.0 0.0
3.0 0.0 1.0 0.0;
Enddecay

For B → D∗±π ∓ , use the CKM phase betaPlusHalfGamma.

Note: Temporarily, this model only works for B0, not anti-B0. This will be fixed later.

Notes:
For more details about the treatment of CP violating decays see Section 10.

A.41 SVV CP
Author:Ryd
Usage:
BrFr V1 V2 SVV CP BETA dm eta |G1+| argG1+ |G0+| argG0+
|G1-| argG1-;

Explanation:
Decay of a scalar to two vector mesons and allows for CP violating time asymmetries. The
first argument is the relevant CKM angle in radians. The second argument is the B 0 − B̄ 0
mass difference in s−1 (approximately 0.5 × 1012 ). The next argument is called η in Ref. [23]
and is either +1 or −1. The last six arguments are G1+ , G0+ , and G1− , and are expressed
as their absolute values and phases again the definition of these parameters are in Ref. [23].
This model then uses these amplitudes together with the time evolution of the B B̄ system
and the flavor of the other B to generate the time distributions.

98
Example:
This example decays the B 0 meson to J/ΨK ∗0

Decay B0
1.000 J/psi K*0 SVV_CP beta dm 1.0 1.0 0.0 1.0 0.0 1.0 0.0;
Enddecay

Notes:
For more details about the treatment of CP violating decays see Section 10. Note that the
value of η depends on how the K ∗0 decays, it is either +1 or −1 depending on weather a KS
or a KL is produced. (It needs to be checked which sign goes with the KS and the KL .

A.42 SVV CPLH

Author:Ryd
Usage:
BrFr V1 V2 SVV CPLH BETA dm eta |G1+| argG1+ |G0+| argG0+
|G1-| argG1-;

Explanation:
Decay of a scalar to two vector mesons and allows for CP violating time asymmetries in-
cluding different lifetimes for the different mass eigenstates, the Light and Heavy state. This
model is particularly intended for decays like Bs → J/ψφ. The first argument is the rel-
evant CKM angle in radians. The second argument is the Bs − B̄s mass difference in s−1
(> 1.8 × 1012 ). The width difference is not an input parameter to the model. It is deter-
mined via the definition of B s0L and B s0H in the evt.pdl. The next argument is called η
in Ref. [23] and is either +1 or −1. The last six arguments are G1+ , G0+ , and G1− , and are
expressed as their absolute values and phases again the definition of these parameters are in
Ref. [23]. This model then uses these amplitudes together with the time evolution of the Bs
to generate the time dependent angular distributions.

Example:
This example decays the Bs meson to φK ∗0

Decay B_s0
1.000 J/psi phi SVV_CPLH 0.4 3.0e12 2.0 1 1.0 0.0 1.0 0.0 1.0 0.0;
Enddecay

Notes:
For more details about the treatment of CP violating decays see Section 10. This code is
not well tested at all. Please be aware that there can be serious mistakes in this model!

99
A.43 SVS CPLH
Author:Ryd
Usage:
BrFr V S SVS CPLH dm dGoG |q/p| arg(q/p) |Af| arg(Af) |Abarf| arg(Abarf);

Explanation:
Decay of a neutral B meson to a scalar and a vector CP eigenstate, e.g. B 0 → J/ψKS . The
first argument is the B 0 − B̄ 0 mass difference. The second argument in ∆Γ/Γ. The third
and fourth argument is the magnitude and phase of q/p, and the last four arguments are the
magnitude and phases of the amplitude for B 0 and B̄ 0 to decay to the final state f .

Example:
This example decays the B 0 meson to J/ψKS
Decay B0
1.000 J/psi K_S0 SVS_CPLH 0.472e12 0.1 1.0 0.7 1.0 0.0 1.0 0.0;
Enddecay

A.44 SVV NONCPEIGEN

Author: Kurup
Usage:
BrFr V1 V2 SVV NONCPEIGEN
dm beta gamma |A+f | argA+f |A0f | argA0f |A−f | argA−f
|A+f | argA+f |A0f | argA0f |A−f | argA−f
|A+f | argA+f |A0f | argA0f |A−f | argA−f [optional]
|A+f | argA+f |A0f | argA0f |A−f | argA−f ; [optional]

Explanation:
This model is based on the SVS NONCPEIGEN model and allows the generation of CP
violation in scalar → vector + vector decays, where the final state is not a CP-eigenstate.
The first argument is the B 0 − B̄ 0 mass difference. The second argument is the angle beta.
The third argument is the angle relevant to the decay mode being generated. In the example
below it is gamma (in fact, it’s enough to specify 2 beta + gamma, perhaps in the next
round of fixes). The next 24 arguments are the magnitudes and phases of the amplitudes for
the four types of decay, Af , Af , Af and Af , which are split into the three different helicity
states +, 0 and −. Depending on the specified amplitudes, the final state will be charge
conjugated and the correct number of B 0 and B̄ 0 tags are generated.
Note that the last 12 parameters are optional. If they are not specified, then they
are evaluated according to the following relation between the complex amplitudes (with
i = +, 0, −):
Aif = Aif

100
 Aif = Aif (86)

Example:
This example will generate B → D ∗± ρ∓ final states with the appropriate number of B 0
and B̄ 0 tags. The helicity amplitude parameters chosen for the first line are those measured
by CLEO. The amplitudes on the second line are identical, but suppressed by a factor of
100. The last two lines were omitted, so that Eq (86) takes effect:

Alias MYB B0
Decay Upsilon(4S)
1.00 MYB anti-B0
Enddecay
Decay MYB
1.000 D*- rho+ SVV_NONCPEIGEN dm beta gamma
0.152 1.47 0.936 0 0.317 0.19
0.00152 1.47 0.00936 0 0.00317 0.19;
Enddecay

Note: Temporarily, this model only works for B0, not anti-B0. This will be fixed later.

A.45 SVV HELAMP

Author:Ryd
Usage:
BrFr V1 V2 SVV HELAMP |H+| argH+ |H0| argH0 |H-| argH-;

Explanation:
The decay of a scalar to two vectors. The decay amplitude is specified by the helicity
amplitudes which are given as arguments for the decay. The arguments are H+ , H0 , and
H− . Where these complex amplitudes are specified as magnitude and phase. The convention
for the helicity amplitudes are that of Jacob and Wick (at least I hope this is what it is!).
For more details about helicity amplitudes see Section F.

Example:

Decay D0
1.000 K*0 rho0 SVV_HELAMP 1.0 0.0 1.0 0.0 1.0 0.0;
Enddecay

A.46 TAULNUNU
Author:Ryd

101
Usage:
BrFr L N1 N2 TAULNUNU ;

Explanation:
The decay of a tau to a lepton and two neutrinos. The first daughter is the produced lepton
the second is the associated neutrino and the third is the tau neutrino. The amplitude for
this decay is given by A = τ |(V − A)α |ντ 
|(V − A)α |ν .

Example:
The example shows the decay τ → eνe ν̄t au
Decay tau-
1.000 e- anti-nu_e nu_tau TAULNUNU;
Enddecay

A.47 TAUSCALARNU
Author:Ryd
Usage:
BrFr S N TAUSCALARNU

Explanation:
The decay of a tau to a scalar meson and a tau neutrino. The meson is the first daughter.
The amplitude for this decay is given by A = τ |(V − A)α |ντ P α.

Example:
An example of the use of this model is in the decay τ → πντ
Decay tau-
1.000 pi- nu_tau TAUSCALARNU;
Enddecay

A.48 TAUVECTORNU
Author:Ryd
Usage:
BrFr V N TAUVECTORNU

Explanation:
The decay of a tau to a vector meson and a tau neutrino. The meson is the first daughter.
The amplitude for this decay is given by A = τ |(V − A)α |ντ εα .

Example:
An example of the use of this model is in the decay τ → ρντ

102
Decay tau-
1.000 rho- nu_tau TAUVECTORNU;
Enddecay

A.49 TSS
Author:Ryd
Usage:
BrFr S1 S2 TSS

Explanation:
The decay of a tensor particle to two scalar mesons.

Example:
As an example the decay D2∗0 → D 0 π 0 is used.

Decay D_2*0
1.000 D0 pi0 TSS;
Enddecay

A.50 TVS PWAVE

Author:Ryd
Usage:
BrFr V S TVS PWAVE |P| argP |D| argD |F| argF;

Explanation:
The decay of a tensor particle to a vector and a scalar. The decay takes six arguments, which
parameterizes the P , D, and F wave amplitudes. The first two arguments are the magnitude
and the phase of the P -wave amplitude, the third and forth are the D-wave amplitude and
the last two are the F -wave amplitude.

Example:
The decay D2∗0 → D ∗0 π 0 which is expected, by HQET, to be dominated by D wave.

Decay D_2*0
1.000 D*0 pi0 TVS_PWAVE 0.0 0.0 1.0 0.0 0.0 0.0;
Enddecay

Notes:
This model has only been used yet for D-wave so further test are needed before it is safe to
use for nonzero P and F wave amplitudes.

103
A.51 VECTORISR
Author:Zallo,Ryd
Usage:
BrFr VECTOR GAMMA VECTORISR CSFWMN CSBKMN;

Explanation:
Generates the interaction, e+ e− → V γ where V is a vector meson according to [24]. This
model should be used as a decay of the vpho.

Example:
Example below shows how to generate the φγ final state from an virtual photon.

Decay vpho
1.000 phi gamma VECTORISR 0.878 0.95;
Enddecay

Notes:
This model produces an unpolarized vector meson.

A.52 VLL
Author:Ryd
Usage:
BrFr L1 L2 VLL ;

Explanation:
Decay of a vector meson to a pair of charged leptons, e.g., J/ψ →
+
− . The amplitude for
¯
this process is given by A = εµ Lµ where Lµ = 
|Vµ |
.

Example:
The example shows how to generate J/Ψ → e− e+

Decay J/psi
1.000 e- e+ VLL;
Enddecay

A.53 VSP PWAVE

Author:Ryd
Usage:
BrFr S gamma VSP PWAVE ;

104
Explanation:
The decay of a vector to a scalar meson and a photon, the decay goes in P-wave. The first
daughter is the scalar meson and the second daughter is the photon.

Example:
This decay is useful for example in the decay D ∗0 → D 0 γ

Decay D*0
1.000 D0 gamma VSP_PWAVE;
Enddecay

A.54 VSS
Author:Ryd
Usage:
BrFr S1 S2 VSS ;

Explanation:
Decays a vector particle into two scalars. It generates the correct decay angle distributions
for the produced scalars. The amplitude for this decay is given by A = εµ vµ where ε is the
polarization vector of the parent particle and the v is the (four) velocity of the first daughter.

Example:
The example shows how to generate D ∗+ → D 0 π +

Decay D*+
1.000 D0 pi+ VSS;
Enddecay

A.55 VSS MIX

Author:Ryd
Usage:
BrFr B1 B2 VSS MIX dm;

Explanation:
Decays a vector particle into two scalar and generates the correct angular and time distri-
butions for the particles in the decay Υ(4S) → B 0 B̄ 0 . The mass difference is supplied as an
argument to the model

Example:
The example shows how to generate the mixture of mixed and unmixed B 0 and B̄ 0 events.

105
Define dm 0.474e12
Decay Upsilon(4S)
0.420 B0 anti-B0 VSS_MIX dm;
0.040 anti-B0 anti-B0 VSS_MIX dm;
0.040 B0 B0 VSS_MIX dm;
Enddecay

Notes:
The user has to manually specify the fractions of mixed and un-mixed event through the
branching fraction. This means that all this model does is to generate the right time distri-
bution for the given final state. Use the new VSS BMIX model to generate mixing in the
correct proportions using a single decay channel. See Section 10 for more details about how
mixing is implemented and how it works with CP violation.

A.56 VSS BMIX

Author:Kirkby
Usage:
BrFr B1 B2 VSS BMIX dm;

Explanation:
Decays a C=-1 vector particle into two scalar particles using B 0 B̄ 0 -like coherent mixing.
The two possible daughter particles must be charge conjugates and have the same lifetime.
Their mass difference is supplied as an argument to the model, in units of h̄/s. While
the mass difference is a required arguement, ∆Γ/Γ and |q/p| can be supplied as optional
arguements, with defaults of 0 and 1 respectively. The examples below illustrate how this
model accomadates aliased daughters.

Example:
The example shows how to generate Υ(4S) → B 0 B̄ 0 decays with coherent mixing (but
without CP violating effects).
Define dm 0.474e12
Decay Upsilon(4S)
1.0 B0 anti-B0 VSS_BMIX dm;
Enddecay
to include a non-zero ∆Γ/Γ:
Define dm 0.474e12
Define dgog 0.5
Decay Upsilon(4S)
1.0 B0 anti-B0 VSS_BMIX dm dgog;
Enddecay

106
and to specify |q/p|

Define dm 0.474e12
Define dgog 0.5
Define qoverp 1.2
Decay Upsilon(4S)
1.0 B0 anti-B0 VSS_BMIX dm dgog qoverp;
Enddecay

Finally, aliased particles can be generated using this model

Define dm 0.474e12
alias myB0 B0
alias myanti-B0 anti-B0
Decay Upsilon(4S)
1.0 B0 anti-B0 myB0 myanti-B0 VSS_BMIX dm;
Enddecay

generates either B0 myanti-B0, anti-B0 myanti-B0, myB0 anti-B0, or myB0 B0.

Notes:
This model is similar to the VSS MIX model, but it eliminates the need to manually specify
the fractions of mixed and un-mixed events through branching fractions. This approach has
the effect that the resulting mixing distributions are necessarily self consistent, which is not
true for the VSS MIX model when using the wrong branching fractions. See Section 10 for
more details about how mixing is implemented and how it works with CP violation.

A.57 VVPIPI
Author:Ryd
Usage:
BrFr V S S VVPIPI ;

Explanation:
This decay model was constructed for the decay ψ  → J/ψπ + π − but should work for any
V → V  ππ decay in which the approximation that the ππ system can be treated as one
particle which combined with the V  meson is dominated by S-wave. The amplitude for the
mass of the ππ sstem is given by A ∝ (m2ππ − 4m2π ).

Example:

Decay psi(2S)
1.000 J/psi pi+ pi- VVPIPI;
Enddecay

107
A.58 VVS PWAVE
Author:Ryd
Usage:
BrFr V S VVS PWAVE |S| argS |P| argP |D| argD;

Explanation:
The decay of a vector particle to a vector and a scalar. The decay takes six arguments, which
parameterizes the S, P , and D wave amplitudes. The first two arguments are the magnitude
and the phase of the S-wave amplitude, the third and forth are the P -wave amplitude and
the last two are the D-wave amplitude.

Example:
The example below shows how to decay the a01 in pure P wave to ρπ.

Decay a_10
1.000 rho0 pi0 VVS_PWAVE 0.0 0.0 1.0 0.0 0.0 0.0;
Enddecay

Notes:
This model has only been used yet for P -wave so further test are needed before it is safe to
use use for nonzero S and D wave amplitudes.

A.59 WSB
Author:Lange, Ryd
Usage:
BrFr M L N WSB ;

Explanation:
This is a model for semileptonic decays of B, and D mesons according to the WSB model [25].
The first daughter is the meson produced in the semileptonic decay. The second and third
argument is the lepton and the neutrino respectively. See Section 11 for more details about
semileptonic decays.

Example:
The example shows how to generate B̄ 0 → D ∗+ eν̄

Decay anti-B0
1.000 D*+ e- anti-nu_e WSB;
Enddecay

108
Notes:
This model does not include the A3 form factor that is needed for non-zero mass leptons,
i.e., tau’s. If tau’s are generated the A3 form factor will be zero.

109
B EvtGen interface
The EvtGen package supplies a test program, testEvtGen.cc, which provides a main routine
that tests various functions of the EvtGen package. However, a user of the EvtGen package
is not expected to use this program in his application. Instead it is expected that the event
loop needed to generate the events is written externally and invokes routines in EvtGen
to do initialization and event generation. This section describes the various functions that
makes the user interface.
The interface is provided through the class EvtGen that provides member functions to do
initialization of the generator, normally prior to generating events, and to generate events. It
also provides access to controll of various configurations parameters that are used to control
the generator.
Initialization of the generator is done with the function

void EvtGen::init(char* decay, char* pdt, char *udecay);

where decay is the name of the decay table to use, pdt is the name of the particle property
file that is used by EvtGen and udecay is the optional name of a user decay table that is
read after the main decay table, decay. If udecay is either an empty string or an NULL
pointer then no user decay file is read. If you want to read additional decay files this can be
done with the

EvtDecayTable::ReadDecay(char * decay);

member function.
EvtGen can after this initialization be asked to generate one event at the time by calling
the member function

void EvtGen::event(int stdhepid,LorentzVector p,LorentzVector d);

where stdhepid is the particle number according to the stdhep particle numbering scheme.
p is a four-vector giving the initial momentum and energy of the initial particle. Similarly. d
gives the initial vertex and time for the initial particle. This function will generate an event
and then store it in the stdhep comon block, hepevt. This is the most convenient form for
having EvtGen to generate an event. In some test that are internal to EvtGen it is not an
advantage to have EvtGen fill the stdhep common block. Instead these test work with the
internal EvtGen structures. Here the user will need to create the initial particle and then
generate the decay with the memebr function

void EvtGen::event(EvtParticle* p);

Note that here the user is also responsible for destroying the the created decay structure.
This is done by

p->deleteTree();

110
 For the convienence of users more familar with fortran, we have also provided a fortran
frontend to the EvtGen interface described above. There are three necesary files:

• top.cc

• myfunc.F

• evtgenevent .cc

The first of these simply is the main that calls myfort.F. In order to link with a C++
compiler, there must be a main writen in C++. evtgeninit and evtgenevent are the
routines that actually call the EvtGen:Init and EvtGen:Decay routines. These routine
handles the initialization of EvtGen as well as the deletion of the particle tree from memory
when it is no longer needed. evtgenint takes three arguements, and is declared as

void evtgeninit_(char *decayname, char *udecayname, char *pdttablename)

evtgenevent also takes three input arguments:

void evtgenevent_(float *pos, float *tim, int *parent)

pos is an array that contains the initial x, y, and z position of the particle. tim is the pro-
duction time of the particle. parent is the standard HEP number of the particle. The Evt-
Gen output is returned in the standard HEP common block defined in stdhep/stdhep.inc
myfort.F is the fortran routine that should be modified to suit your needs. By default it
will generate one event with a B 0 meson as the parent.
It is straightforward to modify this interface structure in order to include EvtGen inside
of a larger fortran program. top.cc should be modified to call whichever routine is currently
the top fortran routine. The routine myfort.F can then be modified to suit your needs.

C Final state radiation

To incorporate the effects of final state radiation an interface to PHOTOS [3] has been
added. Photos is a packaged that generate final state photons on a generated decay. In the
case of the decay J/Ψ → e+ e− a large fraction of the electrons and positrons in the final
state will emit one (or more) photons.
PHOTOS is activated in the decay file for a particular channel by adding “PHOTOS”
before the name of the decay model,

Decay J/psi
1.0000 e+ e- PHOTOS VLL;
Enddecay

PHOTOS is useful for radiating photons of any charged particles in the final state, maybe
someone should try it on B → π + π − !

111
D Performance monitoring
This section describes various tools that are available to monitor and debug the performance
of EvtGen.

D.1 Efficiency
One, of many, possible reason for the generator to run slowly is that the maximum proba-
bility, against which the acceptance-rejection method is applied, is to high. This means that
the efficiency for accepting an event is low. Diagnostics of this can be studied by setting the
environment variable “EVTINFO”. At the end of the job a summary will then be printed out
which gives the number of times each decay model was invoked, the efficiency for accepting
the decay and the ratio of the largest probability in the sample that was generated to the
maximum probability. Optimal running condition wants to maximize both of these.

E Interface to JetSet
The JETSET and JSCONT models provides interface to JetSet. The JSCONT model is specialized
for producing q q̄ jets from an e+ e− interaction. The JETSET model is a generic interface to
use JetSet for decaying particles.
When JetSet is asked to decay a particle it uses a decay table that has been build from
the EvtGen decay table, DECAY.DEC. Entries in the decay table that uses the JETSET
model is copied into a JetSet format decay table. This decay table is read by JetSet after
EvtGen is done reading the decay tables, including user decay tables. (This file is currently
called jet.d and is left after the jobs is finished in the current directory.) The decay table for
JetSet is constructed from the list of daughters that were listed in the EvtGen decay table
and the model is taken as the argument to the JETSET model.
To implement the partons that jetset generates a new particle in EvtGen was created
to hold the list of partons. This class is called EvtStringParticle, the name is taken from
the idea in JetSet that these partons form a string. The EvtStringParticle is derived from
EvtParticle, and addes member data to store the four momenta and ids of the partons.
The functionality of aliases in EvtGen and the JETSET model don’t work well together.
The implementation of aliases in EvtGen creates a new decay table for the aliased particle.
However, JetSet don’t have the functionality to allow two, or more, different decay tables
for the same particle. Hence, EvtGen will not allow you to decay a particle that is an alias
using the JETSET model.

F Helicity amplitudes
This section will deal with some details related to helicity amplitudes and their relations to
partial wave amplitudes. In particular the sign conventions are described and the relations

112
between the Jackson [26] and the Jackob-Wick [27] conventions for the helicity formalism is
explained.
This section is not meant as a complete guide to the use of helicity amplitudes. There
are several references that gives a good introduction to the use of helicity amplitudes for
describing the dynamics of particle decays. Richman [28] gives a pedagogical introduction
following the conventions of Jacob and Wick [27]. Jackson [26] uses a slightly different choice
of conventions. One of the main purposes of this section is to describe these conventions
and establish a map between the two conventions. Both of these conventions are used in the
literature and, unfortunately, it is not always clear which convention is used.
The origin of the choice of conventions comes from how the Euler angles are chosen. To
make sure that there is no ambiguity about definitions and conventions the next section
provides definitions for the terminology used.

F.1 Preliminaries and definitions

A few definitions are stated explicitly here as to avoid confusion about what conventions are
used.
First, the basis vectors x̂, ŷ, and ẑ are said to form a right handed coordinate system
if rotating the x̂-axis 90 degrees counter-clockwise, as seen from the positive ẑ directions,
will take it to the direction of the ŷ directions. It is assumed that x̂, ŷ, and ẑ are mutually
orthogonal. If the coordinate system is not right handed it is left handed – there is no other
alternative. In the discussion below all coordinate systems considered are right handed.
The Euler angles, α, β, and γ defines a rotation R(α, β, γ) by

R(α, β, γ) ≡ Rz  (γ)Ry (β)Rz (α) (87)

where this means that a rotation by α is first performed around the z-axis. Then a rotation
by β around the y -axis is done. Where the y -axis is the new axis as obtained after the
first rotation. Last the rotation around the new z-axis, z  , is performed by an amount given
by γ. Note that these rotations are not according to a fixed set of rotation axis. This is
inconvenient as the rotation operators that we have are with respect to a fixed coordinate
system. However, there is a simple way of rewriting the Euler rotation in terms of rotations
around a fixed coordinate system,

R(α, β, γ) = Rz (α)Ry (β)Rz (γ). (88)

See e.g. Sakurai [29] page 171-174 for illustrations of the rotations.
J
The Dm,m  (α, β, γ) functions are defined by


 (α, β, γ) ≡ Jm|R(α, β, γ)|Jm .
J
Dm,m (89)

Using dJm,m (β) ≡ Jm|e−iβJy |Jm $ we can write

−imα J 
J
Dm,m (α, β, γ) = e dm,m (β)e−im γ . (90)

113
F.2 Plane wave states
The state Ψpλ denotes a state with momentum p along the z-axis with helicity λ. This
state is obtained by applying a boost L(p) along the z-axis to the state |J = s m = λ,
where |Jm are the canonical angular momentum states. The total angular momentum, s,
is suppressed in the notation below.
Following Jacob and Wick [27] we define the states χpλ which have momentum p along
the negative z-direction
χpλ = (−1)s−λ e−iπJy Ψpλ. (91)
First we will verify that this state has the properties that we expect;

Jz χpλ = Jz (−1)s−λ e−iπJy Ψpλ

= (−1)s−λ e−iπJy eiπJy Jz e−iπJy Ψpλ
= (−1)s − λe−iπJy (−1)Jz Ψpλ
= −λχpλ (92)

shows that the eigen value of Jz is −λ as expected. Further, we look at the application of
the lowering operator, J− = Jx − iJy , on the state χpλ

J− χpλ = (−1)s−λ (Jx − iJy )e−iπJy Ψpλ

= (−1)s−λ e−iπJy eiπJy (Jx − iJy )e−iπJy Ψpλ
= (−1)s−λ e−iπJy (−Jx − iJy )Ψpλ
= −(−1)s−λ e−iπJy J+ Ψpλ

= −(−1)s−λ e−iπJy (s − λ)(s + λ + 1)Ψpλ+1

= (s − λ)(s + λ + 1)(−1)s−(λ+1) e−iπJy Ψpλ+1 (93)

which shows that the application of J− on Ψpλ behaves as expected for a particle with helicity
λ along the negative z-direction. Note in particular that the factor (−1)λ is important to
ensure the right phase when applying the lowering operators. In fact, the properties that we
have demonstrated above almost shows the following property. If p = 0, i.e. the particle is
at rest, then
χ0λ = Ψ0−λ . (94)
The properties of the lowering and raising operators and Jz that we have shown above shows
that the states χ0λ and Ψ0−λ differs at most by a phase and that this phase is independent
of λ. However, it is easiest to show Eq. 94 using the Wigner d-functions

s
χ0λ = (−1)s−λ e−iπJy Ψ0λ = (−1)s−λ dλ λ (π)Ψ0λ = Ψ0−λ (95)
λ

since
dsmm (π) = (−1)s−λ δm,−m . (96)

114
 An alternative way to define the states χpλ is by

χpλ = (−i)2s e−iπJx Ψpλ . (97)

we find that

χ0λ = (−i)2s e−iπJx Ψ0λ = (−i)2s d˜sλ λ (π)Ψ0λ = Ψ0−λ (98)
λ

where
d˜sm m (θ) = jm |e−iθJx |jm. (99)
The d˜ function is similar to the standard Wigner d function except that it refers to expec-
tation values for rotations around the x-axis instead of the y-axis. An explicit formula for
the d˜ function is given by


(j + m)!(j − m)!(j + m )!(j − m )!
d˜jm m (θ) = ×
(m + m + k)!(j − m − k)!k!(j − m − k)!

m +m+2k
2j−2k−m −m
θ θ
cos −i sin (100)
2 2

from which it is easy to show that

d˜jm m (π) = (−1)2j δm ,−m (101)

It is straight forward to show that the application of the raising and lowering operators
as well as the operators Jz on the state defined by Eq. 97 is what is expected. Note in
particular that there is no longer any need for phase factors to get the right phase on the
different helicity states. This is particularly useful because it allows us to simply interpret
the states χpλ in the rest frame of the particle with the momentum p along the negative z
direction. That is, the state χpλ is equal to |J = s m = λ in a coordinate system that
has been rotated by π around the x axis. This is very important because it tells us how to
construct the coordinates systems in sequential decays when applying the helicity formalism,
this will be discussed further below.
We now define the two particle plane wave states when particle A is along the positive
z-direction by
|pλA λB  = ΨpλA χpλB . (102)
Applying Jz to this state we find

Jz |pλA λB  = (λA − λB )|pλA λB  (103)

States where the relative momentum, p, is not along the z-axis are obtained by rotating the
state |pλA λB . Let θ and φ denote the polar coordinates for particle A, then the we define
the state |pθφλA λB  by

|pθφλA λB  = R(α, β, γ)|pλAλB  (104)

115
where R(α, β, γ) is an Euler rotation. Here there is a choice of conventions. Jackson [26]
takes α = φ, β = θ, and γ = 0 while Jacob and Wick [27] uses α = φ, β = θ, and γ = −φ.
The choice of the angle γ is arbitrary but has to be used consistently.
We have now defined the state |pθφλA λB  and explored its properties in some detail.
This state is used as the final state in the two body decays in the helicity formalism.
Before we are ready to use these states we need to construct a set of states that are
labeled by p, λA , and λB and have definite values of J and m, i.e., are eigenstates of J 2 and
Jz . That such states exists is obvious since p, λA , and λB are invariant under rotations. We
denote these states by |pJMλA λB . The relation between these states and the plane wave
states created above is given by


2J + 1 ∗J
|pJMλA λB  = DM λA −λB (φ, θ, −φ)|pθφλA λB . (105)
4π dΩ

Note that the states |pJMλA λB  are independent of the choice of Euler angles.

F.3 Helicity amplitudes

We will now consider the decay C → A + B. The initial particle, C, is assumed to be in the
state |JM and the final state, A + B, is |pJMλA λB . We will assume that the interaction U
that causes this transition is invariant under rotation, but is otherwise arbitrary. We which
to evaluate the matrix element

M = pJMλA λB |U|JM. (106)

To do this we insert the identity written as

I= |p J  M  λA λB p J  M  λA λB | (107)
p J  M  λA λB

and use Eq. 105.

M = pθφλA λB |U|JM


= pθφλA λB |p J  M  λA λB p J  M  λA λB |U|JM
p J  M  λA λB

= pθφλA λB |pJMλA λB pJMλA λB |U|JM



2J + 1 ∗J
= pθφλA λB | DM,λA −λB
(φ , θ , −φ )|pθ φ λA λB pJMλA λB |U|JM
4π dΩ

2J + 1 ∗J
= DM,λA−λB (φ, θ, −φ)HλA λB (108)
4π
where the helicity amplitudes are defined by

HλA λB = pJMλA λB |U|JM. (109)

116
F.4 Helicity amplitudes and sequential decays
The previous section explained how the helicity formalism is used to calculate the amplitudes
for a two body decay, A → B + C. It is straight forward to now to use this in sequential
decays. The only thing that requires a it of care is the construction of the coordinate systems
in which the decay angles are measured.
To explain how to use the helicity formalism in sequential decays we will consider the
decay chain A → B + C, B → D + E, and C → F + G. The initial particle, A, is in the
state |J = JA m = λA . The amplitudes for the decay A → B + C is now given by

2JA + 1 ∗JA
AλA→B+C
A λB λC
= DλA ,λB −λC (φB , θB , −φB )HλAB λC (110)
4π
where θB and φB are the polar angles of particle B in the rest frame of particle A.
Similarly, we can write the amplitude for the decay of particle B

2JB + 1 ∗JB
AλB→D+E
B λD λE
= DλB ,λD −λE (φD , θD , −φD )HλBD λE . (111)
4π
The coordinate system in which the angles θD and φD are measured is obtained by rotating
the coordinate system of the parent particle, A, using the same Euler angles as was used
when calculating the amplitude for the decay of particle A. This means that the coordinate
system for particle B is obtained by doing the rotation R(φB , θB , φB ) of the coordinate
system of particle A.
In the same way we obtain the amplitude for the decay of particle C,

+G 2JC + 1 ∗JC
AC→F
λC λF λG = DλC ,λF −λG (φF , θF , −φF )HλCF λG . (112)
4π
As discussed above the coordinate system for the second particle, here particle C in the
decay of particle A, is obtained by rotating the coordinates system of the first particle, B,
by π around its x axis. I.e. the x-axis of particles B and C frames are parallel.

F.4.1 Jackson convention

In the Jackson convention the Euler rotation is taken to be R(φ, θ, 0) where the angles (θ, φ)
are the polar coordinates for p. This is a rotation first by φ around the z-axis and then a
rotation by θ around the new y-axis. The new y-axis is in the direction of z × p and the new
x-axis is therefore in the direction (z × p) × p.
This is a simple geometrical construction that allows the construction of the coordinate
system used with the Jackson convention for the Euler rotations.

F.4.2 Jacob-Wick convention

The coordinate system used in the Jacob-Wick convention is obtained by performing an
additional rotation of −φ around the new z-axis as obtained in the Jackson conventions.
In the sense that there is a simple geometrical construction for the coordinate system in
the Jackson convention if might be argued that this convention is somewhat simpler to use.

117
F.5 Explicit representations of SU(2)
This section describes the explicit representations of SU(2) that are used in the generator.
As usual h̄ = 1.

F.5.1 J = 1/2
1
Sn = γ 0 γ 5 n
/. (113)
2

F.5.2 J =1
We will consider the representation of spin 1.
     
0 0 0 0 0 i 0 −i 0
Jx =  
 0 0 −i  , Jy =  
 0 0 0 , Jz = 
 i 0 0 
 (114)
0 i 0 −i 0 0 0 0 0
From these explicit representations it is trivial to show that they obey the standard
commutation relations, e.g.,
[Jx , Jy ] = iJz (115)
Further we find, as expected, that
J 2 = Jx2 + Jy2 + Jz2 = 2I (116)
such that J 2 = j(j + 1) which shows that this in fact is a representation of spin 1. The
raising and lowering operators are as usual given by
   
0 0 −1 0 0 1
   
J+ = Jx + iJy =  0 0 −i  , J− = Jx − iJy  0 0 −i  (117)
1 i 0 −1 i 0
It is also convenient to evaluate the expression for a finite rotation
 
cos θ − sin θ 0
 
Rz (θ) = e−iθJz =  sin θ cos θ 0  . (118)
0 0 1

Of course we could have guessed the form of Rz (θ), but an explicit evaluation of e−iθJz is
possible through direct evaluation of the series expansion, but is more elegantly done using
Cayley-Hamilton’s theorem.2
2
Cayley-Hamilton’s theorem states that if PA (λ) = det(λI −A) then PA (A) = 0 for any symmetric matrix
A. This means that if A has dimension n then Ak can be written as a linear combination of Ai for i < n. In
particular it can be shown that f (A) = q(A) where q is a polynomial of degree < n. The polynomial q(A)
is defined by
dj f dj q
(λk ) = (λk ) (119)
dz j dz j
where λk are the eigen values of A, with multiplicity nk and j = 0..nk − 1.

118
 The states      
−1 0 1
1     1  
+ = √  −i  , 0 =  0  , − = √  −i  (120)
2 0 1 2 0
are easily seen to satisfy
Jz λ = λλ (121)
and therefore form a helicity eigenstate basis for a particle with J = 1 moving in the direction
of the positive z-axis.

F.6 Projections of helicity amplitudes

This section shows how the helicity amplitudes are related to the invariant amplitudes.
Consider the decay of a scalar to two vector particles. Let the final states of the two vector
particles be denoted by 1s1 and 2s2 and p be the relative momentum of the two particles in
the parents rest frame. The amplitude for this process is then written as

As1 s2 = 1∗ 2∗
is1 js2 Mij (
p) (122)

where Mij (p) is a rank 2 tensor as a function of the available momenta in the process, i.e.,
a function of p. The most general form of M is given by

Mij = aδij + bijk pk + cpi pj . (123)

The coefficients a, b, and c are the invariant amplitudes, we wand to relate them to helicity
amplitudes. First we note that there are three invariant amplitudes, this is the same as the
number of helicity amplitudes.
From Eq. 108 the amplitude is given by

2J + 1 ∗J
Aλ1 λ2 = Hλ1 λ2 DM λ1 −λ2 (φ, θ, −φ). (124)
4π
When relating the helicity amplitudes to the invariant amplitudes it is sufficient to look
at one kinematic configuration, we chose the simplest possible in which θ = φ = 0. From
∗J
the definition of the D function it is obvious that DM λ1 −λ2 (0, 0, 0) = δM,λ1 −λ2 . This gives

4π
Hλ1 λ2 = Aλ λ . (125)
2J + 1 1 2
This allows us to simply evaluate the helicity amplitudes from the invariant amplitudes if
we chose the states, 1 and 2 , to correspond to the states in the helicity formalism. For 1
we take the states given by 120
     
−1 0 1
1     1  
1+ = √  −i  , 10 =  0  , 1− = √  −i  . (126)
2 0 1 2 0

119
The states for the second particle have to satisfy χ0λ = Ψ0−λ which gives
     
1 0 −1
2 1   2   2 1  
+ = √  −i , 0 =  0  , − = √  −i  . (127)
2 0 1 2 0

Note that this is consistent with Eq. 97. Now it is straight forward to evaluate the helicity
amplitudes

4π
H++ = (−a − ib), (128)
3

4π
H00 = (a + c), (129)
3

4π
H−− = (−a + ib). (130)
3
These equations are easily inverted to give

1 3
a = − (H++ + H−− ), (131)
2 4π

i 3
b = (H++ − H−− ), (132)
2 4π

3 1
c = (H00 + (H++ + H−− )), (133)
4π 2
(134)

F.7 Jacob-Wick transformation

This section derives the relation between partial wave amplitudes and helicity amplitudes.
The amplitude for a decay, given the partial wave amplitudes MLs , is given by


A(Ω, m1, m2, m3) = Cs2 s3 (s ms ; m2 m3 )CLs (s1 m1 ; mL ms )YLmL (Ω)MLs .
L,s

F.8 HELAMP and PARTWAVE model implementations

The two models HELAMP and PARTWAVE implements generic two body decays where the am-
plitudes are specified by the helicity and partial wave amplitudes respectively. The partial
wave model uses the translation to helicity amplitudes as given in Sect. F.7. Henceforth,
this section will focus in the description of the evalution of helicity amplitudes.
EvtGen uses a set of states, that are not the same as the helicity states. In this section
it is important to distinguish between these two sets of states. The basis states used by
EvtGen will be called |n and the helicity states will be denoted |λ, s, or simply |λ >.

120
 We consider the decay of the form A → BC where the state of the initial particle is given
by |nA  and the two particles in the final state are labeled by |nB  and |nC . For convenience
we label the final state |nB , nC  = |nB  ⊗ |nC . Given this notation we write the amplitude
that we need to implement as

nA ,nB ,nC = nB , nC |H|nA .

AB→BC

Using the completeness of the basis states we write

AB→BC
nA ,nB ,nC = nB , nC |λB λB |λC λC |H|λA λA |nA  (135)
λA ,λB ,λC


= nB |λB nC |λC λB |λC |H|λA λA |nA  (136)
λA ,λB ,λC


= Rn∗ B λB Rn∗ C λC λB |λC |H|λA RλA nA (137)
λA ,λB ,λC

Where

RnA λA = λA |nA  (138)

RnB λB = λB |nB  (139)
RnC λC = λC |nC  (140)

G The routines decay angle and decay angle chi

This section will describe the utility routines, EvtDecayAngle, EvtDecayPlaneNormalAngle,
and EvtDecayAngleChi, that compute decay angles. The function EvtDecayAngle is useful
for finding the decay angle, known as the helicity angle, in a decay tree that includes a two
body decay. Teh routine EvtDecayPlaneNormalAngle calculates the angle of the decay plane
normal in a three-body decay. EvtDecayAngleChi computes the azimuthal angle between
two decay planes in sequencial decays such as B → D ∗ D ∗ or B → D ∗
ν.
To call EvtDecayAngle, the syntax is
costheta=EvtDecayAngle(P,Q,D),
where P, Q and D are of type EvtVector4R. This routine returns the cosine of the angle θ,
as defined in Figure 14. The decay angle calculated is that between the flight direction of
the daughter meson, D, in the rest frame of Q (the parent of D), with respect to Q’s flight
direction in P’s (the parent of Q) rest frame. P, Q, and D are the momentum four vectors of
these particles in any frame of reference. The decay angle is computed using the (manifestly
invariant) expression
(P · D)MQ2 − (P · Q)(Q · D)
cos θ =  . (141)
[(P · Q)2 − MQ2 MP2 ][(Q · D)2 − MQ2 MD2 ]

To call EvtDecayPlaneNormalAngle the syntax is

121
costheta=EvtDecayPlaneNormalAngle(P,Q,D1,D2),

where P, Q, D1, and D2 are of type EvtVector4R. This routine returns the cosine of the angle
θ of the normal to the decay plane. The angle calculated is that between the normal of the
decay plane formed by the daughter mesons, D1 and D2, in the rest frame of Q (the parent
of D1 and D2), with respect to Q’s flight direction in P’s (the parent of Q) rest frame. P, Q,
D1, and D2 are the momentum four-vectors of these particles in any frame of reference. The
decay angle is computed using the (manifestly invariant) expression

cos θ = MQ P · L
 (142)
[(P · Q)2 − MP2 MQ2 ][−L2 ]

where Lν = νµαβ Qν D1α D2β .

The routine EvtDecayAngleChi is used to calculate the azimuthal angel, χ, between
the decay planes of a pair of two body decays. As illustrated in Figure 15, χ is the angle
calculated from the particle d1 to the particle h1 as seen from the direction of particle D.
The form of the call to this subroutine is

chi=EvtDecayAngleChi(p4_parent,p4_d1,p4_d2,p4_h1,p4_h2),

where p4 d1, p4 d2, p4 t1, p4 h2 are of type EvtVector4R and are the four momenta of
the daughter particles as illustrated in Figure 15.
D

P Q θ

Figure 14: Definition of the decay angle.

122
 d1
h1 d1
h1

H parent
D
D

h2
h2 d2
d2

Figure 15: Definition of the χ angle.

H Optimizing EvtGen code

Broadly speaking there are two different categories of optimization. The firt type concerns
just making the code more efficient, i.e., there are no changes to the algorithm. A very
simple example of such optimization is the order in which operations are performed, let a be
a double and p and k four-vectors.

a*(p*k);

is more efficient then

(a*p)*k;

I Guidelines for coding in EvtGen

This section is included for the convenience of the developers to make clear how classes,
memeber functions etc. should be named. Note that a lot of the original code was written
completely without any of these guidelines and hence are in complete violation of this guide.
It is, however, a goal of the developers to modify the old code to be consistent with this
standard.
All classes, and in general any global symbols, should start with the three letters “Evt”.
This is the package TLA as used in BaBar. Further class names are written using capital
letters for the first letter in each word that makes up the name, e.g., EvtDecayTable.
Member functions start with a lower case letter and further words in the name are written
with the first letter in capital, e.g., getDecayModel() is then the way a member function that
returns the decay model should be named.
Memeber data starts with an underscore, , and decaymodel is then how a the member
data that stores the decay models should be named.

123
 Note in particular that it is discouraged to use an underscore in the name of either classes,
member functions, or member data to separate words.

124
References
[1] See http://www.lns.cornell.edu/public/CLEO/soft/QQ.

[2] T. Sjöstrand, Computer Physics Commun. 82 74 (1994).

[3] E. Richter-Was, Phys. Lett. B303, 163, (1993).

[4] What can be referenced for CLHEP?

[5] http://root.cern.ch/.

[6] Gangof4.

[7] D. Scora and N. Isgur, Phys. Rev. D52, 2783 (1995).

[8] N. Isgur, D. Scora, B. Grinstein, and M.B. Wise, Phys. Rev. D39, 799 (1989).

[9] The ALEPH collaboration, CERN-PPE/97013.

[10] S. Versillé, F. Le Diberder, CP-Fitting of B → 3π events (BaBar Note in preparation).

[11] 3π section of the BaBar Book.

[12] A.Ali and C.Greub, Phys. Lett. B 361, 146 (1995).

[13] A.Kagan and M.Neubert, Euro. Phys. Jour 7, 5 1999.

[14] J.C. Anjos et al., (E691), Phys. Rev. D48, 56 (1993).

[15] J.Adler et al.,(MARK III),Phys. Lett. B196, 107 (1987).

[16] J.L. Goity and W. Roberts, Phys. Rev. D51 3459-3477 (1995).

[17] J.E. Duboscq et al., (CLEO) Phys. Rev. LEtt. 76, 3898 (1996).

[18] I. Caprini et al., Nucl. Phys. B 530, 153 (1998).

[19] K. Abe et al., (Belle) Phys. Lett. B 526, 247 (2002).

[20] P.Colangelo, F. De Fazio, P. Santorelli and E. Scrimieri Phys. Rev. D53, 3672 (1996).

[21] T.M. Aliev, M. Savci and A. Ozpineci, Phys. Rev. D56, 4260 (1997).

[22] G.P. Korchemsky, D. Pirjol, and T. Yan, Phys. Rev. D61, 114510 (2000).

[23] I. Dunietz, H. Quinn, A. Snyder, W Toki, and H.J. Lipkin, Phys. Rev. D43, 2193
(1991).

[24] I have lost this reference...

125
[25] M. Wirbel et al., Z. Phys. C29, 637 (1985).

[26] J. D. Jackson, in Les Houches Lectures in High Energy Physics, 1965 C. DeWitt and
M. Jacob, eds. (Goordon and Breach, New York), 1966.

[27] M. Jacob and G. C. Wick, Ann. Phys. 7, 404 (1959).

[28] J.D. Richman, Cal. Tech. Preprint CALT-68-1148, (1984) (unpublished).

[29]

126