GR@PPA_All Online Manual
for version 2.65
S. Odaka (KEK); February 13, 2004

Caution: The support to the LHAPDF PDF library is still preliminary in the version 2.65. The calculations are unstable on Linux PCs with the GNU g77 compiler in the combination with LHAPDF. The integrated cross sections show differences at the 4th or 5th digit from those evaluated in other environments in many processes, and the "W + 3 jets" generator gives an anomalously large cross section and error. No such problem has been found in other environments: on the same platfoem with Intel and Fujitsu compilers, and on an AIX server with an IBM compiler. This problem will be solved in the next version, which we are now preparing for the release.
Contents
  1. What Is GR@PPA_All?
  2. Program Setup
  3. Options in the Setup
    1. Event Interface
    2. PDF Library
    3. Multiple Setup
  4. Control of GR@PPA
    1. GRCPYGEN
    2. BASES/SPRING Parameters
    3. Physics Parameters
      1. CM Energy and Kinematical Cuts
      2. PDF and QCD
      3. Jet Flavor
      4. Internal Event Information
      5. Electroweak Parameters, Masses and Widths
  5. Supported Processes
  6. Process-specific Notices
    1. W + jets
    2. Z/gamma* + jets
    3. Four bottom quarks
    4. Top quark pair
    5. Di-boson production
1. What Is GR@PPA_All?

GR@PPA_All is an event generator program package for proton-proton and proton-antiproton collider experiments, such as those at Tevatron and LHC. Calculations are all at the tree level (leading order) within the framework of the minimal Standard Model. The present version of GR@PPA_All supports processes to produce following final states:
Note that matrix elements are evaluated for Feynman diagrams including heavy particle (W, Z and top quark) decays down to light partons (bottom quarks or lighter). Thus, we can expect that phase-space effects and decay correlations due to quantum effects are exactly reproduced. For instance, the former alter the resonance shape of W, Z and top quarks, and the latter generate a decay plane correlation in di-boson events.

The program is coded within the framework of GR@PPA, an extension of the GRACE system to hadron collisions. Events are generated by BASES/SPRING included in the GRACE system. Thus, generated events are already unweighted (i.e., event weight = 1).

GR@PPA_All generates events at the parton level. Users have to feed the generated events to a suitable general-purpose event generator, if they want to have hadron-level realistic events. The present version of GR@PPA_All supports the LHA event interface [1]. Therefore, the program can be easily interfaced to widely-used general-purpose event genetators, PYTHIA 6.2 and HERWIG 6.5, which support the LHA event interface, too. Since unweighted events are directly generated, GR@PPA_All can be embedded in these general-purpose event generators. Of course, a stand-alone use is also possible. The distribution package includes sample programs for these uses.

As for the PDF library, the most popular ones, PDFLIB in CERNLIB and LHAPDF, are supported. PYTHIA built-in PDFs can be used as well when the PYTHIA-embedding mode is chosen.

The distribution package can be downloaded from the GR@PPA Web page. Refer to the GR@PPA_4b manual [2] for more details concerning the GR@PPA framework.

[1] E. Boos et al., hep-ph/0109068; see also p. 226 in the PYTHIA 6.2 manual, hep-ph/0010017.
[2] S. Tsuno et al., Comput. Phys. Commun. 151 (2003) 216; hep-ph/0204222; KEK Preprint 2002-7 .

2. Program Setup

The procedure of the setup is described step-by-step in the following.

Place the downloaded gzipped tar file in a directory you prefer, and expand it.
# tar zxf GR@PPA_All-2.65.tgz
Move into the top directory of the expanded GR@PPA package.
# cd GR@PPA_All-2.65
Edit the file inc/define.h according to your choice. See the next chapter for available choices.
# vi inc/define.h
Edit the Makefile in the top directory to specify the FORTRAN compiler that you use, the paths to the libraries that the program needs to link, etc.
# emacs Makefile
Parameters you need to set are listed in the top part of the file. The other part (main part) of the Makefile should mot be touched.
After saving the edited Makefile, the setup can be completed by executing following three commands sequentially.
# make
# make install
# make example
The first command compiles GR@PPA subprograms and combines them into several object libraries. The object libraries are copied to a directory specified in the Makefile (the default is "lib") by executing the second command. The last command sets up Makefiles in the sample programs in the example directory.

The setup can be tested by running sample programs. As you can see under the example directory, we provide three sample programs for three different uses of GR@PPA; stand-alone, HERWIG-embedding, and PYTHIA-embedding modes. We describe how to run the PYTHIA-embedding sample program in the following. The procedure is the same for other samples.

Move into the example directory.
# cd example/pythia/
Simply execute the make command to compile and link the sample program (pysample.F) because the necessary setup is already done.
# make
Then, you will find the executable module pysample in this directory.
Run the program to test your setup.
# ./pysample
See the README file in the this directory to check the result.

3. Options in the Setup

The event-interfacing scheme and the PDF library have to be chosen before the setup. There are two options for the event-interfacing scheme and three options for the choice of PDF libraries. Users have to specify their choice in the file inc/define.h. The program codes are modified according to the choice by the preprocessor during the setup.

3.1. Event Interface

In the present version of GR@PPA_All, users are recommended to use the default option, the Les Houches Accord (LHA) event interface [1], for the event interface. There would be no reason to choose another option since the major two general-purpose event generators, PYTHIA 6.2 and HERWIG 6.5, support this interface. Another option, PYTHIA 6.1-embedding, is remaining only for a historical reason.

We provide sample programs for three different uses of GR@PPA: stand-alone, HERWIG 6.5-embedding and PYTHIA 6.2-embedding. As far as the default interface is used, there is no essential difference between them in terms of the event interface. If users adopt an embedding mode, hard-interaction event data generated by GR@PPA_All are internally passed to HERWIG or PYTHIA. Users do not need to care about intermediate event data. However, if they want, users can refer to any level of event data by making an access to appropriate common blocks. If users want to keep the hard-interaction event data as an external file, it would be better to run GR@PPA_All in the stand-alone mode. It would be trivial to write the interfacing routines since the structure of the LHA interface common-block is well documented [1].

[1] E. Boos et al., hep-ph/0109068; see also the PYTHIA 6.2 manual, hep-ph/0010017, pp. 226 - 246.

3.2. PDF Library

GR@PPA_All supports the following three PDF (Parton Distribution Function) libraries:
(1) PYTHIA built-in PDFs
(2) PDFLIB in CERNLIB and
(3) LHAPDF (Les Houches Accord PDF).
Users have to choose one of them before the setup because the program code depends on the choice. Of course, the first one can be used in the PYTHIA-embedding mode only. The default is PDFLIB in this version. CTEQ5L in PDFLIB is used as the default in the sample programs.

Note: When you chose LHAPDF, you have to explicitly specify the location of a PDF-set file in the program in order to choose one of the supported PDF sets. In the sample programs, the PDF-set file is assumed to exist in the directory where the executable module is placed. Thus, in order to run the sample programs in the default setting, users have to copy the appropriate PDF-set file (cteq6.LHpdf as the default) there, or modify the argument of the subroutine InitPDFset in upinit.F properly.

3.3. Multiple Setup

Users may want to compare the results based on different PDFs, or the same PDF in different PDF libraries. They need to make a multiple setup with different choice of options in these cases. The essential function of the setup procedure described in the previous section is to compose the object libraries in the lib directory.

The files created by the setup are all deleted by executing the following two commands.
# make install-clean
# make clean
Thus, we can prepare different sets of object libraries by the following procedure.
  1. Execute the whole setup procedure with a choice of options.
  2. Make a copy of the lib directory with an appropriate name.
  3. Execute the above two commands to clean up the files, except for the copied libraries.
  4. Repeat the setup with another choice of options by changing inc/define.h.
  5. Repeat 2 - 4 if you want.
Note that, when you set up the sample programs, you have to edit the Makefiles for them adequately since they are set up according to the final choice of the options.

4. Control of GR@PPA

The execution of GR@PPA is initiated by calling the subroutine GRCPYGEN, and controlled by parameters defined in header files in the directory inc/. There are many parameters for the control. Most of them are internally used and user modification to them is usually dangerous. However, some of them are required to be given or allowed to be modified by users. These parameters are explained in this chapter, together with the explanation of the steering routine GRCPYGEN.

4.1. GRCPYGEN

GRCPYGEN has two modes of the execution according to the value of the third argument (MODE in the following). GRCPYGEN initiates the initialization if MODE = 1, where the integrated cross section is evaluated using a random sampling (Monte Carlo) method. The initialization may take long for complicated processes because a precise evaluation of the integrated cross section is necessary in GRACE-based event generators. After the initialization, corresponding event generation can be initiated by calling it with MODE = 0. One event is generated by one call.
CALL GRCPYGEN( BEAMS, ISUB, MODE, SIGMA )
Input
Output
Within the LHA event interface specification, the initialization is required to be done in the subroutine UPINIT, and the event generation in UPEVNT. The present version of GR@PPA_All fully supports this specification. GRCPYGEN is always called in these two subroutines in the sample programs that we provide. The sample codes can be found in the files upinit.F and upevnt.F, respectively, in the sample program directories example/xxx/ (xxx = alone, herwig and pythia).

Note that GRCPYGEN can handle only one process at one call. The LHA event interface provides several methods to handle multiple processes. One of the methods is adopted in the sample programs. General-purpose event generators supporting the LHA event interface choose one process to generate in each call of UPEVNT, according to the cross sections evaluated in UPINIT. GRCPYGEN called in UPEVNT uses this choice (as ISUB) in the PYTHIA- and HERWIG-embed sample programs. The implementation is very simple because GR@PPA_All generates unweighted events by itself. See the source codes of the sample programs and the PYTHIA 6.2 manual [1] for more details. A similar (essentially the same) method is applied in the sample program for the stand-alone mode, too.

In the present version of GR@PPA_All, some common basic initialization is done by calling the subroutine GRCINIT before calling GRCPYGEN. See the subroutine UPINIT in the sample programs.

[1] T. Sjostrand et al., hep-ph/0010017.

4.2. BASES/SPRING Parameters

GR@PPA uses the BASES/SPRING package for integration and event generation. The distribution of random numbers is optimized by an iteration in BASES, in order to realize an efficient event generation by SPRING. BASES is called by GRCPYGEN when MODE = 1, and SPRING is called when MODE = 0. The optimization results and other necessary information are written in an external file (BASES table), to be referred later by SPRING. The control parameters for BASES/SPRING are to be set in the subroutine GRCPAR for each process. Users can find sample codes in the file grcpar.F in the sample program directories.
IBSWRT (integer) = 0 if users want to execute the initialization by BASES, 1 if they want to re-use an existing BASES table.
GRCFILE (character) = the file name of the BASES table that users want to create or re-use. Two files with additional trailers ".data" and ".result" are created for each process when BASES is executed. The former is the true binary table and the latter is a character file summarizing the results. These trailers must be omitted from GRCFILE.
NCALL (integer) = the number of sampling points in each step of the iteration in BASES; to be increased if the integration accuracy is not sufficient (worse than 0.5% in each iteration step, typically), or certain anomalous jump is observed in the iteration.
In addition, users can change the seed of random numbers used in SPRING (IRSEED). A sample code can be found in UPINIT of the sample programs.
IRSEED (integer) = initial seed of random numbers used in SPRING.

4.3. Physics Parameters

4.3.1. CM Energy and Kinematical Cuts

Users are required to give some kinematical parameters before the initialization. The following parameters are set in the subroutine UPINIT in the sample programs.

First of all, users need to specify the center-of-mass energy of the collision.
GRCECM (double-precision real) = the center-of-mass (CM) energy of the colliding beams in GeV.
This variable is defined in the header file inc/grchad.inc.

A certain kinematical cut is necessary in those processes including quarks and/or gluons (jets) in the final state. The following cuts are applied to final-state jets, except for quarks from heavy particle decays. These cuts are taken into account in the mapping between the random numbers and the kinematical variables.
GPTCUT (double-precision real) = minimum value of pT of the final-state jets with respect to the beam axis.
GETACUT (double-precision real) = maximum value of the pseudorapidity (eta) of the final-state jets along the beam axis in the absolute value; no cut if = 0.
GRCONCUT (double-precision real) = minimum opening angle between the final-state jets measured in Delta_R; Delta_R2 = Delta_phi2 + Delta_eta2.
Similar cuts can be separately defined for each final-state particle.
GRCPTCUT(i) (double-precision real) = minimum value of pT with respect to the beam axis for the i-th particle.
GRCETACUT(i) (double-precision real) = maximum value of the pseudorapidity (eta) along the beam axis in the absolute value for the i-th particle; no cut if = 0.
GRCRCONCUT(i) (double-precision real) = minimum opening angle in Delta_R of the i-th particle with respect to the other final-state particles.
Note that above cuts are defined in the beam-beam CM frame (laboratory frame of colliders) before applying transverse boosts due to parton showers.

Users can define additional cuts in the subroutine GRCUSRCUT. It is possible to vary the cut values event-by-event since it is called every after an event is internally generated. It is also possible to make the cuts process-dependent. The process number can be referred in the parameter IGSUB in grchad.inc. The differential cross section is set to zero if a generated event is out of the cut (IUSRCUT = 1). Those events out of the cut are internally rejected in the event generation stage. Kinematical variables (i.e., four-momenta) of generated particles can be referred through parameters in grchad.inc. Some useful tools are also provided. Sample programs are included in the file grcpar.F in the sample program directories. Read the comments in it to see the details.

4.3.2. PDF and QCD

The definition of the QCD coupling (i.e., alpha_s) is tightly coupled to the choice of PDF, because GR@PPA_All uses the alpha_s routine provided by the chosen PDF library in order to preserve a consistency. This is the same for the electroweak couplings but ignored here since the effect is minor. According to the chosen PDF set, PDF libraries automatically set the parameters necessary to define alpha_s, such as the approximation order and the cutoff value. Users can find some examples for the initialization in the subroutine UPINIT and the main program of the sample programs. Refer to the manual of each PDF library if you want to apply a non-standard setting.

Though the behavior of alpha_s is determined by PDF libraries, the energy scale (renormalization scale) to determine the specific value of alpha_s in the matrix-element calculation has to be defined by users since it must be process dependent. Some ready-made definitions are provided in GR@PPA_All. Users can choose one of them by setting the variable ICOUP in the subroutine GRCPAR. The choice can be process dependent. You can find examples in the file grcpar.F of the sample programs.
ICOUP (integer) = choice of the renormalization scale definition.
1: sqrt(s-hat), CM energy of the hard interaction.
2: sqrt(<mT2>), quadratic average of the transverse mass of the final-state particles, where mT2 = m2 + pT2.
3: sqrt{Sigma(mT2)}, quadratic sum of the mT of the final-state particles.
4: max(mT), maximum mT of the final-state particles.
5: constant.
6: user define.
Users have to set the variable GRCQ in the subroutine GRCPAR if ICOUP = 5. If ICOUP = 6, GR@PPA_All calls the subroutine GRCUSRSETQ to determine GRCQ. You can find a dummy example in grcpar.F of the sample programs. In any choice, the variable GRCQ shows the current value of the renormalization scale.
GRCQ (double-precision real) = (current) renormalization scale in GeV.
Note that variables used to determine the energy scale (pT and mT) are evaluated in the CM frame of the hard interaction. Also note that the average and the sum are taken over real final-state particles. For instance, in the "W + jet" production, they are taken over two W-decay products and one jet. The intermediate W boson is not taken into account. If users want, for example, to take an average of mTs of W and jet, they have to set ICOUP = 6 and add appropriate codes to calculate it in GRCUSRSETQ.

There is another energy scale that users have to give. That is the energy scale of the factorization in PDF (factorization scale). Users can adopt one of the ready-made definitions by setting the variable IFACT in the subroutine GRCPAR. The notation of IFACT is the same as ICOUP. If IFACT is not given, it is regarded to be the same as ICOUP. The current value of the factorization scale is stored in the variable GRCFAQ. It can be explicitly set in GRCPAR if IFACT = 5, and can be defined in the subroutine GRCUSRSETQ if IFACT = 6. If it is not given, GRCFAQ is assumed to be the same as GRCQ in these cases.
IFACT (integer) = choice of the factorization scale definition; the notation is the same as ICOUP.
GRCFAQ (double-precision real) = (current) factorization scale in GeV.
In addition, users can change the number of quark flavors regarded as initial-state partons by using the variable INPFL. INPFL = 5 means that the flavors up to the b quark (d, u, s, c and b) are taken into account; namely, their contents in the beams are evaluated using the chosen PDF.
INPFL (integer) = number of quark flavors accounted as possible initial-state partons; the number is counted in the order of d, u, s, c, b and t.
All the parameters explained in this section are defined in the header file grchad.inc.

4.3.3. Jet Flavor

GR@PPA_All implements some processes in which heavy particles are produced in association with jets. Users can include or exclude a certain quark flavor and/or gluon to be regarded as the jets, by setting the variable IGJFLV(i) in grchad.inc. They are set in UPINIT in the sample programs.
IGJFLV(i) (integer) = 0 for exclusion and 1 for inclusion; i = 1, 2, ... , 7 in the order of d, u, s, c, b, t and gluon.
Namely, c quarks can be found in the final-state jets if IGJFLV(4) = 1.

4.3.4. Internal Event Information

Users can make an access to the information of events generated for the Monte Carlo integration in the initialization stage, and those before the final unweighting procedure in the event generation stage. Arrays containing the information are defined in grchad.inc. Users can define their custom kinematical cuts and energy scales by referring to them. Note that p and E are all given in the unit of GeV/c or GeV. Of course, users are not allowed to change the variables explained in this section.

The array PGRC(i,j) is the i-th component of the four-momentum of the j-th particle, defined in the CM frame of the hard (parton-level) interaction where the z axis is parallel to the direction of colliding partons.
PGRC(i,j) (double-precision real) = i-th component of the four-momentum (i = 1, ..., 4 in the order of px, py, pz and E) of the j-th particle in the CM frame of the hard interaction; j = 1 and 2 for the initial-state partons (px = py = 0), and j > 2 for the final-state particles.
Users can refer to the event information in the CM frame of the beam-beam collision (laboratory frame of colliders) in the array PLGRC(i,j). This information must be useful for defining custom cuts.
PLGRC(i,j) (double-precision real) = i-th component of the j-th particle in the beam-beam CM frame, where i = 1, ..., 4 for px, py, pz and E for the initial-state particles (j = 1, 2) and pT, phi, eta and E for the final-state particles (j > 2).
The numbering of the final-state particles is process-dependent. Refer to the final chapter of this manual to see the assignment.

4.3.5. Electroweak Parameters, Masses and Widths

Among various electroweak parameters, such as alpha, GF, sin2thetaW, mW and mZ, only three of them are independent at the tree level. As the default, GR@PPA_All adopts the so-called GF scheme, where GF, mW and mZ are independent parameters. The default values set in the subroutine SETMAS in the file grcpar.F of the sample programs are as follows:
GF (double-precision real) = GF in GeV-2 = 1.16639 x 10-5,
AMW (double-precision real) = mW in GeV = 80.419,
AMZ (double-precision real) = mZ in GeV = 91.188.
These variables are defined in the header file inclm.h. The above choice results in alpha = 1/132.51 and sin2thetaW = 0.2222. These dependent parameters are also set in SETMAS of sample programs but re-evaluated later during the initialization.

Alternative schemes can be selected by changing the IGAUGE parameter in grchad.inc.
IGAUGE (integer) = choice of the independent electroweak parameter set.
1: GF scheme, described in the above (default).
2: alpha(mZ), mW, mZ.
3: alpha_0, GF, mW.
4: sin2thetaW, GF, mW.
The matrix elements of those processes including the W and/or Z boson production are calculated on the basis of those diagrams including their decays, in order to reproduce the exact decay kinematics. Since the calculations are all at the tree level, the total decay widths of W and Z in their propagators are free parameters. Though they can be calculated at the tree level, it must be preferable to use experimental results since they affect observable distributions. The total decay widths are given by the following parameters in the header file inclm.h.
AGW (double-precision real) = total decay width of W in GeV = 2.048
AGZ (double-precision real) = total decay width of Z in GeV = 2.446
The numbers show the default values set in SETMAS in the sample programs.

Users can turn on and off certain decay modes of W and Z bosons using the parameter IGWMOD(i) and IGZMOD(i) in grchad.inc, respectively. The numbering of the decay mode is identical to that in PYTHIA.
IGWMOD(i) (integer) = 0 to turn off and 1 to turn on the i-th decay mode of W
IGZMOD(i) (integer) = 0 to turn off and 1 to turn on the i-th decay mode of Z
Since the matrix elements are evaluated at the tree level in GR@PPA_All, calculated cross sections can not be regarded as those for the W and/or Z productions with a corresponding choice of decay branches. When all branches are turned on, the calculated total decay width do not match the value given by hand as in the above. This argument is relevant to the normalization only. Therefore, the results can be regarded as those for the W and/or Z productions if we apply the following correction to every branches:
sigma = sigma(tree) x {G_tot(given)/G(tree)} x B(given),
where sigma(tree) and G(tree) are the tree-level cross section and the decay width, respectively, for a certain branch. The variable G_tot(given) is the total decay width given by users, and B(given) the given branching ratio. Users would usually use experimental results for G_tot(given) and B(given). This correction is applied if users set IWIDCOR = 2. The parameter IWIDCOR is defined in grchad.inc. B(given) is given by the parameters GRCWBR(i) and GRCZBR(i) in grchad.inc for the W and Z bosons, respectively. The numbering is identical to that in PYTHIA, again.
IWIDCOR (integer) = 2 to apply the above correction; otherwise, the correction is not applied (default = 1).

GRCWBR(i) (double-precision real) = branching ratio for the i-th decay mode of W
GRCZBR(i) (double-precision real) = branching ratio for the i-th decay mode of Z
The following tables show the decay mode assignment and the default setting for W and Z decays.

i
 IGWMOD(i)
default
 decay mode for W+
 GRCWBR(i)
default
1
 0
 dbar + u
 0.321
2
 0
 dbar + c
 0.016
3
 0
 dbar + t
 0
4
 0
 dbar + 4th-up-type
 0
5
 0
 sbar + u
 0.017
6
 0
 sbar + c
 0.321
7
 0
 sbar + t
 0
8
 0
 sbar + 4th-up-type
 0
9
 0
 bbar + u
 0
10
 0
 bbar + c
 0.001
11
 0
 bbar + t
 0
12
 0
 bbar + 4th-up-type
 0
13
 0
 4th-down-type-bar + u
 0
14
 0
 4th-down-type-bar + c
 0
15
 0
 4th-down-type-bar + t
 0
16
 0
 4th-down-type-bar + 4th-up-type
 0
17
 1
 e+ + nu_e
 0.108
18
 0
 mu+ + nu_mu
 0.108
19
 0
 tau+ + nu_tau
 0.108
20
 0
 4th-lepton+ + nu_4th
 0

i
 IGZMOD(i)
default
 decay mode for Z
 GRCZBR(i)
default
1
 0
 d + dbar
 0.154
2
 0
 u + ubar
 0.119
3
 0
 s + sbar
 0.154
4
 0
 c + cbar
 0.119
5
 0
 b + bbar
 0.152
6
 0
 t + tbar
 0
7
 0
 4th-down-type + 4th-down-type-bar
 0
8
 0
 4th-up-type + 4th-up-type-bar
 0
9
 1
 e- + e+
 0.034
10
 0
 nu_e + nu_e-bar
 0.067
11
 0
 mu- + mu+
 0.034
12
 0
 nu_mu + nu_mu-bar
 0.067
13
 0
 tau- + tau+
 0.034
14
 0
 nu_tau + nu_tau-bar
 0.067
15
 0
 4th-lepton- + 4th-lepton+
 0
16
 0
 4th-nu + 4th-nu-bar
 0


GR@PPA_All supports the non-diagonal feature of the Cabibbo-Kobayashi-Masukawa (CKM) matrix. The matrix elements are defined by the variables GRCCKM(i,j) in grchad.inc, where i and j = 1, ..., 4. The values are given in the squared absolute value, like in PYTHIA.
GRCCKM(i,j) (double-precision real) = squared absolute value of the CKM matrix element between the i-th and j-th generation quarks.
The Z-boson production can not be separated from the production of the same final state via virtual photon (gamma*) exchange. Any Z-boson production includes the latter effect in GR@PPA_All. Users can turn on and off the small interference effect using the parameter IGRCGEF defined in grchad.inc.
IGRCGEF  (integer) = 0 (default) to ignore, and 1 to take into account the interference between Z and gamma* exchanges.
Note that, since the gamma exchange can not be separated, it is necessary to apply an appropriate cut on the separation between the two decay products, in order to obtain reliable results in Z/gamma* production processes. The cut can be defined by using the kinematical cut parameters, GRCPTCUT(i), GRCETACUT(i) and GRCRCONCUT(i), or by adding appropriate codes in the subroutine GRCUSRCUT.

All quarks are treated as massive particles in GR@PPA_All. Their masses and total decay widths can be changed by users. Also, the mass and the total decay width of the Higgs boson can be set independently. Users can find examples in the subroutine SETMAS included in the file grcpar.F of the sample programs.

5. Supported Processes

The "processes" are classified according to the final state of the hard interaction. Most of the "processes" are composed of several incoherent "subprocesses" as listed in the following table. Users can activate these "subprocesses" separately since independent process numbers are assigned to them. In the table, "jet" should be attributed to any possible quark and gluon, and "q" to any possible quark. Users can select the flavor(s) to actually generate using the parameters IGJFLV(i). Namely, ISUB = 102 can be regarded as a "W + b + bbar" generator if IGJFLV(5) = 1 and the others are set to 0. The character "f" in the W and Z boson decays represents any possible fermions. Users can select the decay mode(s) by appropriately setting the parameters IGWMOD(i) and IGZMOD(i). When the up-type and down-type quarks need to be distinguished, they are represented by the characters "u" and "d", respectively. The processes shown in the table include their charge conjugate interactions, too.

Users must remind themselves that the calculation consumes much CPU time for large multiplicity processes, since a huge number of diagrams contribute to one process. For instance, the "W + 3 jets" process (ISUB = 103) is composed of more than 18,000 diagrams. The initialization (integration by BASES) with the default setting in the sample programs takes about 87 hours for this process, on 1.0 GHz Pentium Lunux PCs with the g77 compiler without any compile option.

ISUB
 Final state of the hard interaction
 ISUB
 Subprocess
100
 W (-> f fbar')
 421
 q + qbar' -> W (-> f fbar')
101
 W (-> f fbar') + jet
 422
 q + g -> W (-> f fbar') + q'


423
 q + qbar -> W (-> f fbar') + g
102
 W (-> f fbar') + 2 jets
 424
 q + g -> W (-> f fbar') + q' +g


425
 u + dbar -> W (-> f fbar') + q + qbar'


426
 u + dbar -> W (-> f fbar') + g + g


427
 g + g -> W (-> f fbar') + q + qbar'


428
 u + ubar' -> W (-> f fbar') + q + qbar'


429
 u + u' or d + d' -> W (-> f fbar') + q + q'


430
 u + d -> W (-> f fbar') + q + q'
103
 W (-> f fbar') + 3 jets
 431
 q + g -> W (-> f fbar') + q' + g + g


432
 q + g -> W (-> f fbar') + q' + q'' + qbar'''


433
 u + dbar -> W (-> f fbar') + q + qbar' + g


434
 u + dbar -> W (-> f fbar') + g + g + g


435
 g + g -> W (-> f fbar') + q + qbar' + g


436
 u + ubar' or d + dbar' -> W (-> f fbar') + q + qbar' + g


437
 u + u' or d + d' -> W (-> f fbar') + q + q' + g


438
 u + d -> W (-> f fbar') + q + q' + g
110
 Z/gamma* (-> f fbar)
 500
 q + qbar -> Z/gamma* (-> f fbar)
111
 Z/gamma* (-> f fbar) + jet
 501
 q + g -> Z/gamma* (-> f fbar) + q


502
 q + qbar -> Z/gamma* (-> f fbar) + g
112
 Z/gamma* (-> f fbar) + 2 jets
 503
 q + g -> Z/gamma* (-> f fbar) + q + g


504
 u + ubar' or d + dbar' -> Z/gamma* (-> f fbar) + q + qbar'


505
 q + qbar -> Z/gamma* (-> f fbar) + g + g


506
 g + g -> Z/gamma* (-> f fbar) + q + qbar


507
 u + dbar -> Z/gamma* (-> f fbar) + u + dbar


508
 u + u' or d + d' -> Z/gamma* (-> f fbar) + q + q'


509
 u + d -> Z/gamma* (-> f fbar) + q + q'
160
 H (-> b bbar) + b + bbar
 400
 g + g -> H (-> b bbar) + b + bbar


401
 q + qbar -> H (-> b bbar) + b + bbar
161
 Z/gamma* (-> b bbar)+ b + bbar
 402
 g + g -> Z/gamma* (-> b bbar)+ b + bbar


403
 q + qbar -> Z/gamma* (-> b bbar)+ b + bbar
162
 b + bbar + b + bbar (pure QCD)
 405
 g + g -> b + bbar + b + bbar (pure QCD)


406
 q + qbar -> b + bbar + b + bbar (pure QCD)
163
 H (-> b bbar) + Z/gamma* (-> b bbar)
 404
 q + qbar -> H (-> b bbar) + Z/gamma* (-> b bbar)
164
 Z/gamma* (-> b bbar) + Z/gamma* (-> b bbar)
 407
 q + qbar -> Z/gamma* (-> b bbar) + Z/gamma* (-> b bbar)
170
 t (-> b + W+ (-> f fbar')) + tbar (-> bbar + W- (-> f'' fbar'''))
 419
 g + g -> t (-> b + W+ (-> f fbar')) + tbar (-> bbar + W- (-> f'' fbar'''))


420
 q + qbar -> t (-> b + W+ (-> f fbar')) + tbar (-> bbar + W- (-> f'' fbar'''))
550
 Z/gamma* (-> f fbar) + Z/gamma* (-> f' fbar')

551
 W+ (-> f fbar') + W- (-> f'' fbar''')

552
 Z/gamma* (-> f fbar) + W (-> f' fbar'')



6. Process-specific Notices

6.1. W + jets (ISUB = 100 - 103, 421 - 438)
The matrix elements have been generated for those diagrams in which a W+ boson is produced from a u -> d transition vertex and subsequently decays to a positron-neutrino pair. Other processes are evaluated by changing the couplings and masses, and applying an appropriate charge-conjugate transformation. Thus, the interference between the quarks from W decays and those externally produced (jets) is not taken into account. The results can be regarded as those for the "W + jets" productions if users set IWIDCOR = 2.

The assignment of the particle number in PGRC(i,j) and PLGRC(i,j) is as follows.

j
 3
 4
 5
 6
 7
ISUB = 100
 1st W-decay product
 2nd W-decay product
 -
 -
 -
ISUB = 101
 1st W-decay product
 2nd W-decay product
 jet
 -
 -
ISUB = 102
 1st W-decay product
 2nd W-decay product
 1st jet
 2nd jet
 -
ISUB = 103
 1st W-decay product
 2nd W-decay product
 1st jet
 2nd jet
 3rd jet


6.2. Z/gamma* + jets (ISUB = 110 - 112, 500 - 509)

The matrix elements have been generated for those diagrams in which a Z boson produced from a quark line subsequently decays to a electron-positron pair. Other processes are evaluated by changing the couplings and masses, and applying an appropriate charge-conjugate transformation. Thus, the interference between the quarks from Z decays and those externally produced (jets) is not taken into account. The Z-gamma* interference is turned on if IGRCGEF = 1. It is necessary to apply an appropriate cut on the separation between the two decay products. The results can be regarded as those for the "Z + jets" productions if users set IWIDCOR = 2.

The assignment of the particle number in PGRC(i,j) and PLGRC(i,j) is as follows.

j
 3
 4
 5
 6
ISUB = 110
 1st Z/gamma*-decay product
 2nd Z/gamma*-decay product
 -
 -
ISUB = 111
 1st Z/gamma*-decay product
 2nd Z/gamma*-decay product
 jet
 -
ISUB = 112
 1st Z/gamma*-decay product
 2nd Z/gamma*-decay product
 1st jet
 2nd jet


6.3. Four bottom quarks (ISUB = 160 - 164, 400 - 407)

The program is essentially same as GR@PPA_4b version 2.01. The subprocesses numbers (ISUB = 400 - 407) are identical to the process numbaers in GR@PPA_4b.

The assignment of the particle number in PGRC(i,j) and PLGRC(i,j) is as follows.

j
 3
 4
 5
 6
ISUB = 160 - 164
 b
 bbar
 b
 bbar

Since each process consists of many coherent diagrams, it is impossible to say which pair originates from an intermediate heavy boson. However, in ISUB = 160, the first pair is most likely the decay product of the Higgs boson. This is merely due to a technical reason.

6.4. Top quark pair (ISUB = 170, 419 - 420)
The matrix elements have been generated for those diagrams in which top quarks produced in pair decay to a W boson and a b-quark, and subsequently W+ decaya to a positron-neutrino pair and W- decays to a muon-antineutrino pair. Therefore, the final state is six body. Other decay modes are evaluated by changing the couplings and masses. Since full kinematics and quantum effects are taken into account, some observable distributions are different from those simulated by PYTHIA, where on-shell approximations are applied. For instance, in the top-quark invariant mass distribution, we observe a larger tail in the large mass side due to a phase-space effect in the decay. Just like other processes, the normalization and the ratio of the W decay can be tuned to experimental or user-defined values by setting IWIDCOR = 2.

The assignment of the particle number in PGRC(i,j) and PLGRC(i,j) is as follows.

j
 3
 4
 5
 6
 7
 8
ISUB = 170
 b quark from t
 1st decay product of W+ from t
 2nd decay product of W+ from t
 bbar quark from tbar
 1st decay product of W- from tbar
 2nd decay product of W- from tbar


6.5. Di-boson production (ISUB = 550, 551, 552)

The matrix elements have been generated for those diagrams including the decays to a lepton pair. Therefore, the final state is four body. Other decay modes are evaluated by changing the couplings and masses, and applying an appropriate charge-conjugate transformation if necessary. In ISUB = 551, diagrams of the W-pair production via an s-channel Z/gamma* exchange are included as well. The kinematical distributions of the final state are identical to those simulated by PYTHIA, because the PYTHIA simulation is based on exact four-body matrix elements, too, for these processes.

Note that the calculations are all at the tree level including the boson decays in the default setting. They can be regarded as those for "di-boson productions" only when users set IWIDCOR = 2. The Z-gamma* interference is turned on if IGRCGEF = 1. It is necessary to apply an appropriate cut on the separation between the two decay products of Z/gamma* in relevant processes.

The assignment of the particle number in PGRC(i,j) and PLGRC(i,j) is as follows.

j
 3
 4
 5
 6
ISUB = 550
 1st decay product of 1st Z/gamma*
 2nd decay product of 1st Z/gamma*
 1st decay product of 2nd Z/gamma*
 2nd decay product of 2nd Z/gamma*
ISUB = 551
 1st decay product of W+
 2nd decay product of W+
 1st decay product of W-
 2nd decay product of W-
ISUB = 552
 1st decay product of Z/gamma*
 2nd decay product of Z/gamma*
 1st decay product of W
 2nd decay product of W


S. Odaka, February 3, 2004