DIPHOX version 1.2

Diphox has been tested on DEC Alpha and Linux PC.

Structure of the program

diphox
working	src	frag	pdfs	pawres	read_ntuple	basesv5.1
Directory which contains the files: "Makefile", "parameter.indat", "param_histo.indat" and "start.pl"	Directories containing all the source files in order that the program runs	Directory containing the fragmentation functions of partons into photon of Bourhis et al. and partons into hadron of BKK, KKP and Kretzer	Directory containing the pdfs mrst99, mrst01, cteq5 and cteq6	Directory where the ntuple and/or histograms will be put	Directory containing a typical fortran code to analyse the ntuple	Directory containing the BASES/SPRING package

Installation

Load the DIPHOX code as gzipped .tar file and unpack it.
In the directory "working", there is a Makefile (using the GNU makefile).
1. The user has to verify that the fortran compiler called in the Makefile is the one implemented on his machine.
  The default is the f77 DEC fortran compiler FC = f77. On Linux PCs use the GNU compiler g77.
2. Options of compilation:
  FFLAGS = -O : the compilation flag FFLAGS = -O corresponds to the default level of optimization used by the f77 DEC
  compiler (it works also with g77). For any alternative choice of optimization, please see your compiler's manual.
3. The user has to verify that the choice of the makefile to build the BASES library is the one corresponding to his machine.
  One can choose between:
  Makefile.dec, Makefile.f2c, Makefile.hiux, Makefile.hpux, Makefile.sgi, Makefile.sun, Makefile.tpl, Makefile.linux
  depending on the computer to be used. The default is
  MAKEBASES = Makefile.dec
4. The program uses the exe cernlib which is not provided with the program package because it is very likely that the cernlib
  is already installed on your system (if not you can get it from the CERN program library ).
  The user has to verify that the path to the CERN library on his system has been set correctly.
  Default: PATHCERNLIB = cern/pro/bin

Run once the Makefile with the option bases ("gmake bases") to create the library for Bases/Spring.

To run the program

Fix the input parameters of your choice in the file "parameter.indat" in the directory "working".
This is the main input file containing the parameters for integration and event generation.
Further information on these parameters is given directly in this file.
If you also would like to project events into histograms, define the corresponding parameters in the file "param_histo.indat".

To run the perl script "start.pl" which creates the executable files, type "perl start.pl". This does the following:

The two files "parameter.indat" and "param_histo.indat" containing the input parameters are read automatically.
In case you have several parameter files with different names, you simply have to specify the names of your parameter files as options: type
"perl start.pl --parameter your_parameterfilename --histo your_param_histofilename".
Note that "param_histo.indat" will be read only if the flag "histo" in the file "parameter.indat" has been selected.
start.pl automatically rewrites the Makefile according to the options you chose in "parameter.indat", and runs the compiler.
start.pl creates an executable file called "run_string.exe" where "string" is the name of the run defined in "parameter.indat". You have to execute this file with your favorite options.

start.pl creates a directory called "resultstring".
In this directory, there will be a file "histoNameHisto.outdat" containing a summary of the input which "start.pl" has read from "param_histo.indat". The string NameHisto used to label the files containing the histograms (or the ntuple) is defined in "parameter.indat".
The directory "resultstring" also will contain subdirectories called
"dirstring" and/or
"onefstring"
"twofstring"
depending on which subprocesses you selected in your input. The shorthand
"dir" stands for the contribution which has no fragmentation function (it contributes only to gamma-gamma production),
"onef" stands for the contribution which has one fragmentation function,
"twof" stands for the contribution which has two fragmentation functions (it is the only contribution for hadron-hadron production).

So the structure of the output is the following:

resultstring
NameHisto.outdat	dirstring	onefstring	twofstring
parameters read from "param_histo.indat"	output files specified below	see below	see below

"output.param"	parameters read from parameter.indat
"sigmaint.res"	physical integrated cross-section
"integral.res"	results of integration of absolute values of pseudo-cross sections; no physical meaning, needed for normalization of generated events
"*.bs"	results of the grid for each pseudo-cross section; needed for event generation
"diphox.log"	details of the integration by BASES (efficiency, convergence behaviour, time per point, ...)

Comments

With Diphox, we also provide the mrst01,cteq6,mrst99 and cteq5 parton distribution functions, but the user can choose other pdfs, either older ones via pdflib (see parameter.indat) or newer ones by making a new interface (see "pdftopdg_mrst01.f" or "pdftopdg_cteq6.f" in the pdfs directory. The user also has to modify the "Makefile" to add newer ones).

In the input file "parameter.indat" you have to choose between two options:
- either to compute the integrated cross section over the phase space defined by the cuts
If you you are not interested in integrated cross sections, set the corresponding flag to "FALSE" and make directly the grids in order to save integration time. You do not need to calculate first the integrated cross section in order to make the grid and/or generate events.

If you want to generate isolated photon events, you have to apply the isolation cuts already when making the grids.

Once you have produced the grids (stored in the *.bs files), you can use them again to generate new events and enlarge an existing event sample without having to recompute grids. However if you are interested in a kinematic range which is not populated efficiently by the existing grids, keeping these grids will generate too many events that further will be lost in the histrogramming stage. In such a case the computation of a new dedicated grid is much more efficient in the end.

If you chose the option "histo" in your input to produce directly histograms instead of passing via ntuples, you can refine some cuts already defined in "parameter.indat" and specify the histograms you want in the file "param_histo.indat" (there is a list of defined cut-parameters and variables in "param_histo.indat"). When running "start.pl" the corresponding Fortran files to fill the histograms with the specified cuts are created automatically.

You can use the information given in the file "diphox.log" to adjust the parameters for BASES/SPRING such that the efficiency is optimized.

Please contact guillet@lapp.in2p3.fr in case you have any questions or comments.

Back to Diphox