ExDiff Monte Carlo generator for Exclusive Diffraction. Version 1.0. Physics and manual

TL;DR

ExDiff is a Monte Carlo event generator designed to simulate exclusive diffractive processes in proton-proton collisions, currently supporting elastic scattering and specific resonance production at various energies, with plans to expand its capabilities.

Contribution

This paper introduces ExDiff, a new Monte Carlo generator tailored for exclusive diffraction, including detailed implementation of elastic and resonance production processes in proton-proton collisions.

Findings

Successfully simulates elastic scattering at multiple energies

Models production of specific resonances like f0(1710) and f2(1950)

Provides a foundation for future expansion of diffractive process simulations

Abstract

ExDiff is a Monte Carlo event generator for simulation of Exclusive Diffractive processes in proton-proton collisions. The present version includes reactions: elastic scattering $pp\to pp$ at 7, 8, 13, 14~TeV; $pp\to p+R+p$, $R = f_0(1710),\, f_2(1950)$ at 13~TeV. In the future versions many processes of Central Exclusive Diffractive Production will be added.

Tables

Parameter	Value
${\alpha }_P\left(0\right)-1$	$0.109$
${\tau }_a$	$0.535$ GeV2
$g_{ppP}\left(0\right)$	$13.8$ GeV
$a_g$	$0.23$ GeV-2

Equations

$$p_1=\left(\frac{\sqrt{s}}{2},\frac{\sqrt{s}}{2}\beta ,\vec{0}\right),p_2=\left(\frac{\sqrt{s}}{2},-\frac{\sqrt{s}}{2}\beta ,\vec{0}\right).$$

$$\Delta =\left(0,\frac{-t}{\sqrt{s}\beta },\vec{\Delta }\right),p_1^{\prime }=p_1-\Delta ,p_2^{\prime }=p_2+\Delta ,$$

$$-t={\tau }^2=\frac{s{\beta }^2}{2}\left(1-\sqrt{1-\frac{4{\vec{\Delta }}^2}{s{\beta }^2}}\right)\simeq {\vec{\Delta }}^2,\beta =\sqrt{1-\frac{4m_p^2}{s}}.$$

$$\frac{d{\sigma }_{el}}{d{\tau }^2}=\frac{|T_{el}(s,\tau ){|}^2}{16\pi s^2},$$

$$T_{el}(s,\tau )=4\pi s{\int }_0^{\infty }d{b}^2{J}_0(b\tau )T_{el}(s,b).$$

$$T_{el}(s,b)=\frac{e^{2\mathrm{i}{\delta }_{el}(s,b)}-1}{2i},$$

$${\delta }_{el}(s,b)=\frac{1}{16\pi s}{\int }_0^{\infty }d{\tau }^2{J}_0(b\tau ){\delta }_{el}(s,\tau ),$$

$${\delta }_{el}(s,\tau )=g_{pp\mathrm{P}}^2(-{\tau }^2)\left(i+\tan \frac{\pi ({\alpha }_{\mathrm{P}}(-{\tau }^2)-1)}{2}\right)\pi {\alpha }_{\mathrm{P}}^{\prime }(-{\tau }^2){\left(\frac{s}{2s_0}\right)}^{{\alpha }_{\mathrm{P}}(-{\tau }^2)},$$

$${\alpha }_{\mathrm{P}}(t)=1+\frac{{\alpha }_{\mathrm{P}}(0)-1}{1-\frac{t}{{\tau }_a}},g_{pp\mathrm{P}}(t)=\frac{g_{pp\mathrm{P}}(0)}{(1-a_{g}t{)}^2},$$

$$h_1(p_1)+h_2(p_2)\to h_1(p_1^{\prime })+R(p_R)+h_2(p_2^{\prime }),$$

$$h_1(p_1)+h_2(p_2)\to h_1(p_1^{\prime })+\{a(k_a)+b(k_b)\}+h_2(p_2^{\prime }),$$

$$s$$

$$s_{1,2}$$

$$s_{1\{a,b\}}$$

$${\hat{t}}_{a,b}$$

$$\bar{s}$$

$$p_1=\left\{\sqrt{\frac{\bar{s}}{2}},\frac{m^2}{\sqrt{2\bar{s}}};\vec{0}\right\},{\Delta }_1=\left\{{\xi }_1\sqrt{\frac{\bar{s}}{2}},\frac{-{\vec{\Delta }}_1^2-{\xi }_1{m}^2}{(1-{\xi }_1)\sqrt{2\bar{s}}};{\vec{\Delta }}_1\right\},$$

$$p_2=\left\{\frac{m^2}{\sqrt{2\bar{s}}},\sqrt{\frac{\bar{s}}{2}};\vec{0}\right\},{\Delta }_2=\left\{\frac{-{\vec{\Delta }}_2^2-{\xi }_2{m}^2}{(1-{\xi }_2)\sqrt{2\bar{s}}},{\xi }_2\sqrt{\frac{\bar{s}}{2}};{\vec{\Delta }}_2\right\}$$

$$p_{1,2}^{\prime }=p_{1,2}-{\Delta }_{1,2},p_{1,2}^2=p_{1,2}^{\prime 2}=m^2,$$

$$k_{a,b}$$

$$k_{a,b}^2$$

$$t_{1,2}$$

$$s_{1,2}$$

$$M^2$$

$$M_{\perp }^2$$

$$\cos {\varphi }_0$$

$$s_{1\{a,b\}}$$

$$s_{2\{a,b\}}$$

$${\hat{t}}_{a,b}$$

$$m_{\perp }$$

$$0.01Ge{V}^2\le |t_{1,2}|\le \sim 1Ge{V}^2,$$

$${\xi }_{min}\simeq \frac{M^2}{s{\xi }_{max}}\le {\xi }_{1,2}\le {\xi }_{max}\sim 0.1,$$

$${\left(\sqrt{-t_1}-\sqrt{-t_2}\right)}^2\le \kappa \le {\left(\sqrt{-t_1}+\sqrt{-t_2}\right)}^2$$

$$\kappa ={\xi }_1{\xi }_{2}s-M^2\ll M^2$$

$${\xi }_{1,2}\simeq \frac{M_{\perp }}{\sqrt{s}}{\mathrm{e}}^{\pm y},|y|\le y_0=\ln \left(\frac{\sqrt{s}{\xi }_{max}}{M}\right),$$

$$|y_{1,2}|=\frac{1}{2}\ln \frac{(1-{\xi }_{1,2}{)}^{2}s}{m^2-t_{1,2}},$$

$$|y|\le 6.5,|y_{1,2}|\ge 8.75\text{mbox}for\sqrt{s}=7\mathrm{TeV},$$

$$|\tanh \eta |\le \sqrt{1-\frac{4m_0^2}{M^2}}.$$

$$\frac{d{\sigma }_R^{\text{mbox}CEDP}}{d{\vec{\Delta }}_1^{2}d{\vec{\Delta }}_2^{2}d{\varphi }_{0}dy}\simeq \frac{{\left|T_R^{\text{mbox}CEDP}\right|}^2}{2^8{\pi }^{4}s{s}^{\prime }},$$

$$\frac{d{\sigma }_{ab}^{\text{mbox}CEDP}}{d{\vec{\Delta }}_1^{2}d{\vec{\Delta }}_2^{2}d{\varphi }_{0}dyd{M}^{2}d{\Phi }_{ab}}\simeq \frac{{\left|T_{ab}^{\text{mbox}CEDP}\right|}^2}{2^9{\pi }^{5}s{s}^{\prime }},$$

$$d{\Phi }_{ab}=\frac{d^4{k}_a}{(2\pi {)}^2}\delta (k_a^2-m_0^2)\delta (k_b^2-m_0^2)$$

$$=\frac{d{\vec{k}}^2}{8\pi M^2\sqrt{1-\frac{4({\vec{k}}^2+m_0^2)}{M^2}}}=\frac{d\eta }{16\pi {\cosh }^2\eta }.$$

$$T^{\text{mbox}CEDP}(p_1,p_2,{\Delta }_1,{\Delta }_2)=\int \frac{d^2{\vec{q}}_T}{(2\pi {)}^2}\frac{d^2{\vec{q}}_T^{\prime }}{(2\pi {)}^2}V(s,{\vec{q}}_T)$$

Full text

1. 1 Introduction

2. 2 Physics Overview

3. 2.1 Elastic scattering

4. 2.2 Central Exclusive Diffractive Production

5. 3 Program Overview

6. 3.1 General information

7. 3.2 Basic classes and functions

8. 4 Program Installation

9. 5 Getting Started with the Simple Example

10. 5.1 Analyzer

11. 5.2 For developers

12. Index of basic Classes, Methods and Variables

1 Introduction

Substantial fraction (about 40% at LHC) of total cross section of pp interactions is due to diffractive processes. And about 60% of these events are exclusive. So, simulation of such events is one of the basic tasks at LHC.

At this moment there is no unique definition of diffraction:

• •

Interactions where the beam particles emerge intact or dissociated into low-mass states.

• •

Interactions mediated by t-channel exchange of object with the quantum numbers of the vacuum, color singlet exchange or Pomeron. Descriptions of the Pomeron are based on phenomenological approaches or on QCD.

In general such processes lead to final state particles separated by large rapidity gaps. However only a fraction of Large Rapidity Gap (LRG) events is due to diffractive processes, gaps can arise also from fluctuations in the hadronisation processes.

The key experimental trigger for diffraction is the angle distribution, which gives the typical diffractive pattern with zero-angle maximum and one or, sometimes, two dips. Here wave properties of hadrons play the main role. From this distribution we can make the conclusion about size and shape of the scatterer, or the ”interaction region”.

Elastic scattering is the basic exclusive process, i.e. so called “standard candle”. Advantages of this process are:

• $\bullet$

Clear signature: both intitial particles remain intact and should be detected in the final state.

• $\bullet$

Small number of variables in the differential cross-section.

• $\bullet$

Large value of the cross-section.

• $\bullet$

Huge number of experimental data at different energies.

• $\bullet$

From the theoretical point of view: we have the possibility to extract size and shape of the “interaction region” from the slope and fine structure of the $t$-distribution.

• $\bullet$

Also we can “calibrate” diffractive models for further calculations of absorptive corrections in other exclusive processes.

Experimental difficulty is mainly due to closeness of final protons to beams. That is why we need special runs of an accelerator to avoid different contaminations like pile-up events, for example.

Another process is the Central Exclusive Diffractive Production (CEDP). CEDP gives us unique experimental possibilities for particle searches and investigations of diffraction itself. This is due to several advantages of the process:

• $\bullet$

clear signature of the process: both protons remain intact plus LRG;

• $\bullet$

possibility to use ”missing mass method” that improve the mass resolution;

• $\bullet$

usually background is strongly suppressed, especially for “hard” production, due to $J_{z}=0$ selection rule;

• $\bullet$

spin-parity analysis of the central system can be done by the use of azimuthal distributions;

• $\bullet$

interesting measurements concerning the interplay between ”soft” and ”hard” scales are possible [1],[2].

All these properties are realized in common CMS/TOTEM detector measurements at LHC [3].

Theoretically calculations of CEDP and elastic scattering are closely related, especially when we try to take into account all the unitarity effects (absorption, “gap survival probability”).

In the paper we present a new Monte-Carlo event generator ExDiff. The generator is devoted to the simulation of Exclusive Diffractive processes in proton-proton collisions (elastic process and CEP of low mass resonances in this version). All these processes are depicted in the Fig. 1.

The present version includes reactions: $pp\to pp$ at 7, 8, 13, 14 TeV; $pp\to p+R+p$, $R=f_{0}(1710),\,f_{2}(1950)$ at 13 TeV. In the future versions many other processes of CEP will be added: $pp\to p+R+p$, where $R$ is a resonance like Higgs boson, for example; $pp\to p+A+B+p$, where $A$, $B$ are hadrons, jets or gauge bosons (see Figs. 1(c)-(j)).

2 Physics Overview

2.1 Elastic scattering

2.1.1 Kinematics

The diagram of the elastic scattering $p+p\to p+p$ is presented in Fig. 1. The momenta are $p_{1}$, $p_{2}$, $p_{1}^{\prime}$, $p_{2}^{\prime}$ respectively. In the center-of-mass frame these can be represented as follows ($p\equiv(p_{0},p_{z},\vec{p}\,)$, $\vec{p}\equiv(p_{x},p_{y})$):

[TABLE]

With this notation, the four momentum transfer is

[TABLE]

Cross-section for elastic scattering can be calculated as

[TABLE]

2.1.2 Model for the elastic scattering

Here is the outlook of the model for elastic scattering used in this version of the generator.

In the Regge-eikonal approach the elastic nonflip scattering amplitude looks like

[TABLE]

where $s$ and $t=-\tau^{2}$ are the Mandelstam variables, $b=|\vec{b}|$ is the impact parameter, and eikonal $\delta(s,\tau)$ is parametrized as in the work [4]

[TABLE]

where

[TABLE]

2.2 Central Exclusive Diffractive Production

2.2.1 Kinematics of CEDP

Let us consider the kinematics of two CEDP processes

[TABLE]

with four-momenta indicated in parentheses. Initial hadrons remain intact, $\{a\;b\}$ can be di-boson or di-hadron system and R denotes a resonance, “+” signs denote LRG.

We use the following set of variables:

[TABLE]

[TABLE]

In the light-cone representation $p=\{p_{+},p_{-};\vec{p}_{\perp}\}$

[TABLE]

and additional notations for the $2\to 4$ process are

[TABLE]

Here $\xi_{1,2}$ are fractions of hadrons’ longitudinal momenta lost, $y$ denotes the rapidity of the central system, $\eta=(\eta_{b}-\eta_{a})/2$, where $\eta_{a,b}$ are rapidities of particles $a,b$. From the above notations we can obtain the relations:

[TABLE]

and additional set for the $2\to 4$ process

[TABLE]

Physical region of diffractive events with two large rapidity gaps is defined by the following kinematical cuts:

[TABLE]

We can write the relations in terms of $y_{1,2}$ (rapidities of hadrons) and $y$. For instance:

[TABLE]

Differential cross-sections for the above processes can be represented as

[TABLE]

$T^{\mbox{\tiny CEDP}}$ is given by the following analytical expression:

[TABLE]

where $\Delta_{1T}=\Delta_{1}-q_{T}-q^{\prime}_{T}$, $\Delta_{2T}=\Delta_{2}+q_{T}+q^{\prime}_{T}$, ${C}$ is the “bare” amplitude of the process $p+p\to p+X+p$.

2.2.2 Model for CEDP

In the case of the eikonal representation of the elastic amplitude $T_{el}$ we have

[TABLE]

In this case amplitude (24) can be rewritten as

[TABLE]

Calculations for concrete expressions of $C$ in the general case were considered in [2],[5].

Here we present the model for resonances in CEDP based on the schemes for single diffractive dissociation [6] and tensor resonance decays [7]. Absorptive corrections are calculated according to [6].

[TABLE]

where $J$ is the spin of a central particle, and $e^{(\lambda)}(\Delta_{1}+\Delta_{2})$ are states with the helicity $\lambda$.

3 Program Overview

3.1 General information

ExDiff is written in a modular way using C++. The general structure of the generator is shown on the Fig. 2. In this subsection there is an outlook. You can find more detailed description of all the elements in next subsections.

3.1.1 Data card

The first element is the data card. Let us consider an example

../ExDiff1.0/config/card_sample.card:

1 0 0 1 1000 0 0

IDauthors IDprocess IDenergy version Nevents IDinput_format IDoutput_format

Only the first line with int type of numbers is used. Sequence of parameters of the first string with possible values for ExDiff 1.0:

• •

IDauthors defines authors of the model used for a process:

IDauthors=1: A. Godizov (only one for this version).

• •

IDprocess defines the process:

IDprocess=0: elastic $p+p\to p+p$ scattering;

IDprocess=1: CEDP of low mass resonance $f_{0}(1710)$, $p+p\to p+f_{0}(1710)+p$;

IDprocess=2: CEDP of low mass resonance $f_{2}(1950)$, $p+p\to p+f_{2}(1950)+p$;

• •

IDenergy defines the collision energy of the process:

IDenergy=0: $13$ TeV; (for all processes in this version)

IDenergy=2: $7$ TeV; (only for elastic in this version)

IDenergy=3: $8$ TeV; (only for elastic in this version)

IDenergy=4: $14$ TeV; (only for elastic in this version)

• •

version is auxiliary parameter that is used to define different versions. Default value is $1$.

• •

Nevents defines number of events to generate.

• •

IDinput_format defines a set of variables for kinematics. Default value is [math]. It means that we use the following sets of variables: $\{t,\phi\}$ (elastic scattering); $\{\tau_{1},\tau_{2},\phi_{0},\ln\xi_{1},\phi_{1}\}$ (CED resonance production); $\{\tau_{1},\tau_{2},\phi_{0},\ln\xi_{1},\phi_{1},\eta,\phi_{a}\}$ (CED di-jet, di-hadron, di-boson production).

• •

IDoutput_format defines output format. Default value is [math]. In ExDiff v1.0 the simple file ../ExDiff1.0/output/A1M1E0_1F0.exdiff generated, where the output looks like

============================== ExDiff Event ==================================

ID E px py pz

2212 6.50000000e+03Ψ 0.00000000e+00Ψ 0.00000000e+00Ψ 6.49999993e+03 2212 6.50000000e+03Ψ 0.00000000e+00Ψ 0.00000000e+00Ψ-6.49999993e+03

2212 6.49922495e+03Ψ 1.20107011e-01Ψ 1.07105789e-01Ψ 6.49922488e+03 10331 1.72153048e+00Ψ-3.95672633e-02Ψ-9.27803302e-02Ψ-1.71445119e-01 2212 6.49905351e+03Ψ-8.05397481e-02Ψ-1.43254592e-02Ψ-6.49905344e+03

============================== ExDiff Event ==================================

ID E px py pz

2212 6.50000000e+03Ψ 0.00000000e+00Ψ 0.00000000e+00Ψ 6.49999993e+03 2212 6.50000000e+03Ψ 0.00000000e+00Ψ 0.00000000e+00Ψ-6.49999993e+03

2212 6.49922495e+03Ψ 1.20107011e-01Ψ 1.07105789e-01Ψ 6.49922488e+03 10331 1.72153048e+00Ψ-3.95672633e-02Ψ-9.27803302e-02Ψ-1.71445119e-01 2212 6.49905351e+03Ψ-8.05397481e-02Ψ-1.43254592e-02Ψ-6.49905344e+03

...

where the first column containes particles IDs (standard PDG numbering scheme [8]), and other four columns contain their four-momentum. Output filename is constructed from parameters in the data card:

A<IDauthor>M<IDprocess>E<IDenergy>_<version>F<IDinput_format>.exdiff

3.1.2 Block of models

This block contains data files (simple txt files) obtained somehow from external calculations. Naming of these files is the same as for *.exdiff.

The file ../ExDiff1.0/modeldata/*.grid contains one column with values of kinematical variables that author use to parametrize differential cross section of the process under consideration. For each variable v_i we have the interval divided by Nv_i parts. The file looks like

1rst value of v_1 2nd value of v_1 ... (Nv_1+1)th value of v_1 1rst value of v_2 ... (Nv_2+1)th value of v_2 1rst value of v_3 ... (Nv_3+1)th value of v_3 ... (Nv_n+1)th value of v_n

Values are of the double type. n is the number of variables in the set.

By default sets of variables for different kinematics are

• •

$2\to 2$ process: $\{t,\phi\}$;

• •

$2\to 3$ process: $\{\tau_{1},\tau_{2},\phi_{0},\ln\xi_{1},\phi_{1}\}$;

• •

$2\to 4$ process: $\{\tau_{1},\tau_{2},\phi_{0},\ln\xi_{1},\phi_{1},\eta,\phi_{a}\}$.

$\phi$, $\phi_{1}$, $\phi_{a}$ variables are uniformly distributed in the interval $0\to 2\pi$, that is why their values are simply generated as $2\pi\times$(random number in the $[0,1]$ interval). So, finally we have one significant variable for $2\to 2$ process, four variables for $2\to 3$ process and five variables for $2\to 4$ process.

The file ../ExDiff1.0/modeldata/*.dat contains one column with values of the cross section of the process. This file is loaded to the multidimensional array which corresponds to the class ExDiff::NDarray (see below).

3.2 Basic classes and functions

Here we describe only basic classes and some of their methods and variables which can be used by developers.

ExDiff::NDarray

• Purpose:

to initialize multidimensional dynamical array of any type or class.

• ---

• Initialization example:
• …
• std::vectorstd::size_t dim = {129,129,9,9};
• ExDiff::NDarray<double> dat(dim);
• …
• Here we have vector dim which defines number of node points for each variable. Indexes are $0\to 128$ for the first variable, the same for the second one and so on.
• Methods:

• ---

• T& get(const std::vectorstd::size_t& indexes)

• ---

gets the value of the cross section (T is double in examples) in the node point defined by the vector of indexes of variables. Example:

• ---

• ---

std::vectorstd::size_t indexes = {1,2,3,4};

• ---

double cs = dat.get(indexes);

• ---

• std::vector<size_t>& GetDimensions()

• ---

gets the value of the private dimensions vector, which is defined by the vector dim in the initialization example above. Example:

• ---

• ---

std::vectorstd::size_t gdim = dat.GetDimensions();

• ---

• std::vector<T>& GetValues()

• ---

gets the value of the private values vector of any type or class T, which is filled by numbers loaded from *.dat file or calculated in some other way. Example:

• ---

• ---

std::vector<double> gvalues = dat.GetValues();

• ---

• std::size_t computeTotalSize(const std::vectorstd::size_t& dimensions_)

• ---

calculates the total size of the array by multiplication of all dimensions.

• ---

• std::size_t computeIndex(const std::vectorstd::size_t& indexes)

• ---

calculates the global index of the array from the input node point indexes to read the value of the cross section from the vector values, i.e. converts vector of indexes to the single index. Example: (used by get)

• ---

• ---

return values[computeIndex(indexes)];

• ---

• std::vectorstd::size_t computeIndexes(std::size_t index)

• ---

converts back the single index to the vector of indexes of the node point.

• ---

• printC()

• ---

prints the general information about the class object.

• ---

• LoadFromFile(std::string filename)

• ---

loads data from a *.dat file after the initialization.

• ---

• Variables:

• ---

• std::vectorstd::size_t dimensions (input) :

private vector, which contains dimensions of the array (numbers of node points for each variable).

• ---

• std::vector<T> values (input) :

private vector, which contains values of any class or type T loaded from a file or calculated in some other way.

• ---

• Used by:

iFunc, Interface.

• Includes:

<cmath> <complex> <cstdlib> <iostream> <fstream> <map> <string> <utility> <vector> <cassert>

ExDiff::NDgrid

• Purpose:

to initialize special array which contains node points for each variable in the set (from *.grid file or by the use of some calculations).

• ---

• Initialization example:
• …
• std::vectorstd::size_t dim = {129,129,9,9};
• ExDiff::NDgrid<double> grid(dim);
• …
• Here we have vector dim which defines numbers of node points for each variable. Indexes are $0\to 128$ for the first variable, the same for the second one and so on.
• Methods:

• ---

• T& GetVar(const std::size_t& varindex, const std::size_t& index)

• ---

gets the value of a variable (type T is double as in examples above) with the number varindex (in the set of variables) in the node point with the number index. Use this method only to change node points of the grid inside an object of the class.

• ---

• ---

• std::vector<size_t>& GetDimensions()

• ---

gets the value of the private dimensions vector, which is defined by the vector dim in the initialization example above. Example:

• ---

• ---

std::vectorstd::size_t gdim = grid.GetDimensions();

• ---

• std::vector<T>& GetValues()

• ---

gets the value of the private values vector of any type or class T, which is filled by numbers loaded from *.grid file or calculated in some other way. Example:

• ---

• ---

std::vector<double> gvalues = grid.GetValues();

• ---

• std::vector<T>& get(const std::vectorstd::size_t& _indexes)

• ---

gets corresponding vector node point (values of each variable are of the type or class T).

• ---

• std::size_t computeIndex(const std::size_t& varindex,
• const std::size_t& index)

• ---

computes the global index of the concrete variable (with the number varindex in the set) node point (with the node number index for this variable) in the NDgrid vector.

• ---

• std::size_t computeTotalSize(const std::vectorstd::size_t& _dimensions)

• ---

calculates the total size of the array by summation of all dimensions.

• ---

• printC()

• ---

prints the general information about the class object.

• ---

• LoadFromFile(std::string filename)

• ---

loads data from a *.grid file after the initialization.

• ---

• Variables:

• ---

• std::vectorstd::size_t dimensions (input) :

private vector, which contains dimensions of the array (numbers of node points for each variable).

• ---

• std::vector<T> values (input) :

private vector, which contains values of any class or type T loaded from a file or calculated in some other way.

• ---

• Used by:

iFunc, Interface.

• Includes:

<cmath> <complex> <cstdlib> <iostream> <fstream> <map> <string> <utility> <vector> <cassert>

ExDiff::iFunc

• Purpose:

to initialize special class which contains a multidimensional interpolation function. Node points and values of the function are taken from *.grid (or by the use of some calculations) and *.dat files correspondingly.

• ---

• Initialization example:
• ...
• std::vectorstd::size_t dim;
• dim = {129,129,9,9};
• ...
• ExDiff::NDarray<double> dat_(dim);
• ExDiff::NDgrid<double> grid_(dim);
• ...
• // load *.dat and *.grid
• ExDiff::iFunc fungen(dat_,grid_);
• ...

• ---

• Methods:

• ---

• double Calc(std::vector<double>)

• ---

calculates the value of the interpolation function in the point defined by vector of variables. Example:

• ---

• ...

• ---

std::vector<double> p = {1.2345,2.3456,3.4567,4.5678};

• ---

double value = fungen.Calc(p);

• ...

• ---

• ---

• int CheckPoint(std::vector<double>& _point)

• ---

private method which returns 0 if vector _point lies inside the interpolation range and 1 if it is outside the interpolation range.

• ---

• NDgrid<double>& GetGrid()

• ---

returns an object of the private class iGrid, which contains data from *.grid file.

• ---

• NDarray<double>& GetTab()

• ---

returns an object of the private class iTab, which contains data from *.dat file.

• ---

• std::vectorstd::size_t& GetDimensions()

• ---

returns the vector of dimensions which is equal to dim in the initialization example.

• ---

• std::vector<double>& GetPoint()

• ---

returns the private vector point which contains the last point of calculations.

• ---

• std::vector<double>& GetMinFunPoint()

• ---

returns private vector minfunpoint where the function is minimal.

• ---

• std::vector<double>& GetMaxFunPoint()

• ---

returns private vector maxfunpoint where the function is maximal.

• ---

• double& GetMinFun()

• ---

returns private variable minfunvalue which is equal to the minimal value of the function.

• ---

• double& GetMaxFun()

• ---

returns private variable maxfunvalue which is equal to the maximal value of the function.

• ---

• void PrintVector(std::vector<size_t>, std::size_t)
• void PrintVector(std::vector<double>, std::size_t)

• ---

prints size_t or double vector

• ---

• void printC()

• ---

prints the general information about the class object.

• ---

• Variables:

• ---

• std::vectorstd::size_t dimensions :

private vector, which contains dimensions of the array (numbers of node points for each variable).

• ---

• std::vector<double> minvars :

private vector, which contains minimal values of variables in the interpolation range.

• ---

• std::vector<double> maxvars :

private vector, which contains maximal values of variables in the interpolation range.

• ---

• std::vector<double> minfunpoint :

private vector, which contains point where the function is minimal.

• ---

• std::vector<double> maxfunpoint :

private vector, which contains point where the function is maximal.

• ---

• double minfunvalue :

private variable, which contains the minimal value of the function.

• ---

• double maxfunvalue :

private variable, which contains the maximal value of the function.

• ---

• Used by:

Generator, Interface.

• Includes:

<cmath> <complex> <cstdlib> <iostream> <fstream> <map> <string> <utility> <vector> <cassert> "NDarray.h" "NDgrid.h" "I.h" "PI.h"

ExDiff::Generator

• Purpose:

to initialize special class which is applied to a multidimensional interpolation function, and generates a set of variables according to this function. iFunc class is used to create the input object.

• ---

• Initialization example:
• ...
• ExDiff::Generator gen(fungen);
• ExDiff::newrand();
• ...
• fungen is taken from the initialization example of the class ExDiff::iFunc. ExDiff::newrand() sets the random initial condition for new generation by the use of a system clock.

• ---

• Methods:

• ---

• double RNUM()

• ---

returns random number between 0 and 1.

• ---

• void printC()

• ---

prints the general information about the object of the class.

• ---

• ExDiff::iFunc CalcMinus(const ExDiff::iFunc&)

• ---

calculates new iFunc object of $N-1$ variables by resummation in the last variable from the vector of variables, where $N$ is the number of variables of the input object.

• ---

• std::vectorExDiff::iFunc CalcFUNG(const ExDiff::iFunc&)

• ---

calculates a full set of interpolation functions of lower dimensions, including also the total integral of the input interpolation function, and outputs results to private vector FUNG and the variable FUNGTOT.

• ---

• double& GetFUNGTOT()

• ---

gets the total cross-section from the private variable FUNGTOT.

• ---

• double GenVar(const std::vector<double>& x_,
• const std::vector<double>& f_, const double& R_)

• ---

generates a variable from one-dimensional interpolation function, represented by the std::vector array f_. x_ contains node points, f_ contains values of the function in these node points, R_ is the input random number.

• ---

• double EGenVarFast1(const std::vector<double>& x_,
• const std::vector<double>& f_, const std::vector<double>& F_,
• const double& R_)

• ---

generates a variable from one-dimensional interpolation function, represented by the std::vector array f_. x_ contains node points, f_ contains values of the function in these node points, F_ contains integrals of the function, R_ is the input random number.

• ---

• double IntVec(const std::vector<double>& x_, const std::vector<double>& f_)

• ---

calculates the total integral of one-dimensional interpolation function. x_ contains node points, f_ contains values of the function in these node points.

• ---

• std::vector<double> Generate()

• ---

generates the output set (std::vector) of variables.

• ---

• Variables:

• ---

• ExDiff::iFunc FUN :

private variable which contains an input object of class iFunc (initial multidimensional interpolation function).

• ---

• std::vectorExDiff::iFunc FUNG :

private vector which contains an input object of class iFunc (initial multidimensional interpolation function) and all the functions of lower dimensions.

• ---

• double FUNGTOT :

private variable which contains the total cross-section.

• ---

• Used by:

Interface.

• Includes:

<cmath> <complex> <cstdlib> <iostream> <fstream> <map> <string> <utility> <vector> <cassert> <time.h> <ctime>

"NDarray.h" "NDgrid.h" "iFunc.h" "newrand.h" "I.h" "PI.h"

ExDiff::Constants

• Purpose:

to initialize special class which contains fundamental constants: couplings, masses, spins and IDs of particles.

• ---

• Initialization example:
• ...
• ExDiff::Constants c;
• ...
• Methods:
• void Print()

• ---

prints all the constants.

• ---

• double mass(int ID)

• ---

returns the mass of a particle by the use of its ID number.

• ---

• int dspin(int ID)

• ---

returns $2s+1$, where $s$ is the particle spin.

• ---

• Variables:

• ---

• const double m_p, m_n, m_pi0, m_pi, m_H, m_Gra, m_R, m_Glu, m_Z, m_W :

public variables which contain masses of proton, neutron, $\pi_{0}$, $\pi^{\pm}$, Higgs boson, graviton, glueball, Z and W bosons.

• ---

• const double alpha_EM, Lam_QCD :

public variables which contain electromagnetic $\alpha_{e}$ and QCD $\alpha_{s}$ couplings.

• ---

• const double VEV, M_Pl :

public variables which contain vacuum expectation value $246$ GeV and the Plank mass.

• ---

• const int IDproton, ID1710, ID1950, IDpi0, IDpiplus, IDpiminus, IDdef :

public variables which contain PDG (or PYTHIA’s) IDs of particles.

• ---

• Used by:

Interface, Event, KinCM.

• Includes:

<cmath> <complex> <cstdlib> <iostream> <fstream> <map> <string> <utility> <vector> <cassert>

"I.h" "PI.h"

ExDiff::Particle

• Purpose:

to initialize special class which contains four-momentum, mass, spin, color, ID of a relativistic particle.

• ---

• Initialization example:
• ...
• ExDiff::Constants c;
• std::vector<double> v = {c.m_p,0.0,0.0,0.0};
• ExDiff::Particle pa(v,c.m_p,2212,2,0,0);
• ...
• Methods:
• void Print()

• ---

prints all the information about the particle.

• ---

• double Rapidity(std::vector<double>& p_)

• ---

calculates particle rapidity. p_ is the input four-momentum.

• ---

• double Pseudorapidity(std::vector<double>& p_)

• ---

calculates particle pseudorapidity. p_ is the input four-momentum.

• ---

• double Theta(std::vector<double>& p_)

• ---

calculates particle polar angle. p_ is the input four-momentum.

• ---

• double Phi(std::vector<double>& p_)

• ---

calculates particle azimuthal angle. p_ is the input four-momentum.

• ---

• double Lmult(std::vector<double>& p1_, std::vector<double>& p2_)

• ---

returns scalar product of p1_ and p2_ four momenta.

• ---

• std::vector<double> Lminus(std::vector<double>& p1_, std::vector<double>& p2_)

• ---

returns four momenta which is equal to p1_ minus p2_.

• ---

• std::vector<double> Lplus(std::vector<double>& p1_, std::vector<double>& p2_)

• ---

returns four momenta which is equal to p1_ plus p2_.

• ---

• void Lprint(std::vector<double>& vec_)

• ---

prints the four-momentum vec_.

• ---

• int OnShell()

• ---

returns on-shell status of the particle:

• 0 :

particle is on-shell, $p^{2}=m^{2}$

• 1 :

$0<p^{2}<m^{2}$

• -1 :

$-m^{2}<p^{2}<0$

• 2 :

$p^{2}>m^{2}$

• -2 :

$p^{2}<-m^{2}$

• 3 :

$m=0$

• 4 :

$m<0$ (error value)

• ---

• void Reset(const std::vector<double>& p_, const double& m_,
• const int& ID_, const int& DSpin_,
• const int& Colour_, const int& Anticolour_)

• ---

resets parameters of a particle (all the private variables).

• ---

• void ResetP(const std::vector<double>& p_)

• ---

resets only four-momentum of the particle.

• ---

• const std::vector<double>& _p()

• ---

returns private variable which contains four-momentum of the particle.

• ---

• double& _px()
• double& _py()
• double& _pz()
• double& _E()
• double& _m()
• double& _pp()
• double& _pT()
• double& _p3D()
• int& _DSpin()
• int& _ID()
• int& _Colour()
• int& _Anticolour()

• ---

return private variables which contain $p_{x}$, $p_{y}$, $p_{z}$, $E$, $p^{2}$, $p_{T}=\sqrt{p_{x}^{2}+p_{y}^{2}}$, $p_{3D}=\sqrt{p_{x}^{2}+p_{y}^{2}+p_{z}^{2}}$, $2s+1$ ($s$ is the spin), ID number, colour and anticolour of the particle.

• ---

• Variables:

• ---

• std::vector<double> p :

private vector which contains four-momentum of the particle ${E,p_{x},p_{y},p_{z}}$.

• ---

• double E, px, py, pz, m, pp, pT, p3D :

private variables which contain $E$, $p_{x}$, $p_{y}$, $p_{z}$, $m$, $p^{2}$, $p_{T}=\sqrt{p_{x}^{2}+p_{y}^{2}}$, $p_{3D}=\sqrt{p_{x}^{2}+p_{y}^{2}+p_{z}^{2}}$.

• ---

• int ID, DSpin, Colour, Anticolour :

private variables which contain ID, $2s+1$, colour and anticolour of the particle.

• ---

• Used by:

Interface, Event, KinCM.

• Includes:

<cmath> <complex> <cstdlib> <iostream> <fstream> <map> <string> <utility> <vector> <cassert>

"I.h" "PI.h"

ExDiff::Event

• Purpose:

to initialize special class which contains all the particles of an event.

• ---

• Initialization example:
• ...
• ExDiff::Event ev(particles);
• ...
• where particles is of the std::vector<Particle> type.
• Methods:
• void Print(int format)

• ---

prints parameters of particles in different form.

• format=0 :

all the parameters of every particle.

• format=1 :

mass, on-shell status and four-momentum of every particle.

• format=2 :

four-momenta of particles.

• format=3 :

four-momenta of final particles.

• ---

• std::vector<Particle>& _particles()

• ---

returns private vector particles.

• ---

• void AddToFile(int format_, std::string filename_)

• ---

add an event to file *.exdiff in special format.

• format_=0 :

intrinsic ExDiff format.

• ---

• std::vector<int> ExDiff::Event::TakeFromFile(int number_,
• int format_, std::string filename_)

• ---

loads an event number number_ from the file filename_ in special format.

• format_=0 :

intrinsic ExDiff format.

• ---

returns int vector, which contains numbers of

• [0] :

particles in the event,

• [1] :

events in the file,

• [2] :

strings in the file.

• ---

• void ExDiff::Event::TakeEvent(std::vector<int> Nfile_,
• int number_, int format_, std::string filename_)

• ---

loads an event number number_ from the file filename_ in special format.

• format_=0 :

intrinsic ExDiff format.

• ---

The file is the same as in the previouse method. Vector Nfile_ is obtained by the use of TakeFromFile:

• ...
• std::vector<int> Nfile = ev.TakeFromFile(ev_number,format,filename);
• ev.TakeEvent(Nfile,ev_number,format,filename);
• int CheckSum()

• ---

returns [math], if momentum conservation law is carried out, $1$ in other cases.

• ---

• Variables:

• ---

• std::vectorExDiff::Particle particles :

private vector which contains all the particles.

• ---

• Used by:

Interface.

• Includes:

<cmath> <complex> <cstdlib> <iostream> <fstream> <map> <string> <utility> <vector> <cassert> <iomanip> <limits>

"I.h" "PI.h" "Particle.h" "Constants.h"

ExDiff::KinCM

• Purpose:

to initialize special class which contains all kinematical variables for different processes.

• ---

• Initialization example:
• ...
• ExDiff::KinCM kinematics(sqs_,0,genvec,masses__,ids__);
• ...
• where sqs_ is the central mass frame collision energy, [math] defines the set of variables, genvec contains generated variables, masses__ and ids__ contain all the final(!) particles masses and IDs. Other way to initialize an object of the class is
• ...
• ExDiff::KinCM kinematics(sqs_,particles_);
• ...
• where particles_ is the vector of type ExDiff::Particle which contains all the particles of a process.
• Methods:
• void Print()

• ---

prints all the information on kinematical variables of the process.

• ---

• std::vector<Particle> EvParticles()

• ---

returns the vector of all the particles including initial protons (to use it in the ExDiff::Event class objects).

• ---

• void ResetVars(const std::vector<double>& variables_)

• ---

sets new values only to kinematical variables of the process without changing masses, ids, spins and so on. Also it verifies conservation laws.

• ---

• int Phys()

• ---

checks out physical region conditions for the process (conservation laws, positivity of particles energies, all particles are on-shell) and returns

• 0 :

everything is correct

• 1 :

some of energies are negative

• 2 :

some particles are off-shell

• 2 :

other errors

• ---

• std::vector<double> Transform_CMpp_to_CMdd(std::vector<double>& k_)

• ---

makes transformation of the Lorentz vector k_ calculated in the C.M. frame of two colliding protons to the frame where $\vec{\Delta}_{1}+\vec{\Delta}_{2}=0$ and ${\Delta_{1}}_{0}+{\Delta_{2}}_{0}=\sqrt{(\Delta_{1}+\Delta_{2})^{2}}$ (the rest frame of a central resonance or system of particles). All the vectors are defined in (14).

• ---

• std::vector<double> Transform_CMdd_to_CMpp(std::vector<double>& k_)

• ---

makes transformation of the Lorentz vector k_ calculated in the reference frame where $\vec{\Delta}_{1}+\vec{\Delta}_{2}=0$ and ${\Delta_{1}}_{0}+{\Delta_{2}}_{0}=\sqrt{(\Delta_{1}+\Delta_{2})^{2}}$ (the rest frame of a central resonance or system of particles) to the C.M. frame of two colliding protons. All the vectors are defined in (14).

• ---

• std::vector<double> Transform_CMpp_to_CMdd_(std::vector<double>& k_,
• std::vector<double>& Delta_1_, std::vector<double>& Delta_2_)

• ---

makes transformation of the Lorentz vector k_ calculated in the C.M. frame of two colliding protons to the frame where $\vec{\Delta}_{1}+\vec{\Delta}_{2}=0$ and ${\Delta_{1}}_{0}+{\Delta_{2}}_{0}=\sqrt{(\Delta_{1}+\Delta_{2})^{2}}$ (the rest frame of a central resonance or system of particles). Delta_1_ and Delta_2_ contain vectors $\Delta_{1,2}$ calculated in the C.M. frame of two colliding protons. All the vectors are defined in (14).

• ---

• std::vector<double> Transform_CMdd_to_CMpp_(std::vector<double>& k_)
• std::vector<double>& Delta_1_, std::vector<double>& Delta_2_)

• ---

makes transformation of the Lorentz vector k_ calculated in the reference frame where $\vec{\Delta}_{1}+\vec{\Delta}_{2}=0$ and ${\Delta_{1}}_{0}+{\Delta_{2}}_{0}=\sqrt{(\Delta_{1}+\Delta_{2})^{2}}$ (the rest frame of a central resonance or system of particles) to the C.M. frame of two colliding protons. Delta_1_ and Delta_2_ contain vectors $\Delta_{1,2}$ calculated in the C.M. frame of two colliding protons. All the vectors are defined in (14).

• ---

• void VtoP2(std::size_t& _ID, std::vector<double>& _masses,
• std::vector<int>& _IDs)

• ---

sets all the final particles momenta from the set of variables for the process $2\to 2$. _masses and _IDs are vectors of masses and ids of two final particles. _ID identifies the set of kinematical variables for the process:

• _ID=0 :

$|t|$, $\phi$;

• _ID=1 :

$\theta$ (polar scattering angle of the final hadron), $\phi$ (azimuthal angle of the final hadron);

• _ID=2 :

$y_{h}$ (rapidity of the final hadron), $\phi$;

• _ID=3 :

$|\vec{\Delta}|$ (transverse momentum of the final hadron), $\phi$;

• ---

• void VtoP3(std::size_t& _ID, std::vector<double>& _masses,
• std::vector<int>& _IDs)

• ---

similar to previous one, but it sets all the final particles momenta from the set of variables for the process $2\to 3$. _ID identifies the set of kinematical variables for the process:

• _ID=0 :

$|\vec{\Delta}_{1T}|$, $|\vec{\Delta}_{2T}|$, $\phi_{0}$ (azimuthal angle between final protons), $\ln\xi_{1}$, $\phi_{1}$

(azimuthal angle of the first final hadron);

• _ID=1 :

$|\vec{\Delta}_{1T}|$, $|\vec{\Delta}_{2T}|$, $\phi_{0}$, $y_{c}$ (rapidity of a central particle), $\phi_{1}$;

• ---

• void VtoP4(std::size_t& _ID, std::vector<double>& _masses,
• std::vector<int>& _IDs)

• ---

similar to previous one, but it sets all the final particles momenta from the set of variables for the process $2\to 4$. _ID identifies the set of kinematical variables for the process:

• _ID=0 :

$|\vec{\Delta}_{1T}|$, $|\vec{\Delta}_{2T}|$, $\phi_{0}$, $\phi_{1}$, $M$ (mass of a central system), $y$ (rapidity of the central system), $\eta_{j}$ (pseudorapidity of the first particle in the central system in its rest frame, or, in other words, in the C.M. frame of two central particles. For example, consider $\pi^{+}\pi^{-}$ central production. In this case $\eta_{j}\equiv\eta_{\pi^{+}}$ or $\eta_{j}\equiv\eta_{\pi^{-}}$ in the $\pi^{+}\pi^{-}$ C.M. frame. It is equal to $\eta$ in (15)), $\phi_{j}$ (azimuthal angle of the particle, which we choose to fix $\eta_{j}$, in the same reference frame);

• _ID=1 :

$|\vec{\Delta}_{1T}|$, $|\vec{\Delta}_{2T}|$, $\phi_{0}$, $\phi_{1}$, $\xi_{1}$, $\xi_{2}$ (see (14)), $\eta_{j}$, $\phi_{j}$;

• ---

• void PtoV2()

• ---

calculates all the variables for a $2\to 2$ process in the second initialization case (see above), when we use momenta as input.

• ---

• void PtoV3()

• ---

calculates all the variables for a $2\to 3$ process in the second initialization case (see above), when we use momenta as input.

• ---

• void PtoV4()

• ---

calculates all the variables for a $2\to 4$ process in the second initialization case (see above), when we use momenta as input.

• ---

• X _Y()

• ---

give the access to the private variable Y of the type (class) X (see below the list of private variables). For example std::vector<Particle>& _particles() returns private vector particles, double& _Eta_j() returns Eta_j variable.

• ---

• Variables:

• ---

• ExDiff::Particle hadron1, hadron2 :

private objects which contain information on initial hadrons.

• ---

• std::vector<Particle> particles :

private object which contains information on final particles.

• ---

• std::vector<double> variables :

private vector which contains values of variables used in the input set.

• ---

• double sqs :

private variable which contains $\sqrt{s}$ (collision energy).

• ---

• double t, phi, DeltaT, Delta3D, theta, y
• std::vector<double> Delta :

private variables which contain $|t|$, $\phi$, $|\vec{\Delta}|=\sqrt{\Delta_{x}^{2}+\Delta_{y}^{2}}$, $\sqrt{\Delta_{x}^{2}+\Delta_{y}^{2}+\Delta_{z}^{2}}$, $\theta$, $y$, $\Delta$ of a $2\to 2$ process (see (2)).

• ---

• double t_1, t_2, phi_12, phi_1, xi_1, xi_2, y_c, M_T, M_c,
• DeltaT_1, DeltaT_2, Delta3D_1, Delta3D_2
• std::vector<double> Delta_1, Delta_2 :

private variables which contain $|t_{1}|$, $|t_{2}|$, $\phi_{0}$, $\phi_{1}$, $\xi_{1}$, $\xi_{2}$, $y$, $M_{\perp}$, $M$, $|\vec{\Delta}_{1}|$, $|\vec{\Delta}_{2}|$, $\sqrt{\Delta_{1x}^{2}+\Delta_{1y}^{2}+\Delta_{1z}^{2}}$, $\sqrt{\Delta_{2x}^{2}+\Delta_{2y}^{2}+\Delta_{2z}^{2}}$, $\Delta_{1}$, $\Delta_{2}$ (see (14),(16)).

• ---

• double t_hat, s_hat, Eta_j, Theta_j, Phi_j :

additional private variables which contain $\hat{t}_{a}$, $\hat{s}=M^{2}$, $\eta_{j}=\eta=-\ln\tan\frac{\theta_{j}}{2}$, $\theta_{j}$, $\phi_{j}$ (see (15),(17)).

• ---

• int flag :

private variable which contains [math] if everything is correct in the kinematics and nonzero values in other cases.

• ---

• std::size_t ID
• std::vector<double> masses
• std::vector<int> IDs

private variables (vectors) which contain information on the set of input variables, masses and ids of final particles.

• ---

• Used by:

Interface.

• Includes:

<cmath> <complex> <cstdlib> <iostream> <fstream> <map> <string> <utility> <vector> <stdio.h> <cassert>

"I.h" "PI.h" "Particle.h" "Constants.h"

ExDiff::Interface

• Purpose:

to initialize special class which provides convenient input/output.

• ---

• Initialization example:
• ...
• ExDiff::Interface iogen(datacard);
• ...
• where datacard is the name of a configuration (*.card) file.
• Methods:
• void GeneratorInfo()

• ---

prints the general information on the generator (authors, version and so on).

• ---

• void PrintPars()

• ---

prints the general information on the process (authors, process, C.M. energy, version, number of output events, input/output format).

• ---

• void GetCard(const char *_filename)

• ---

reads parameters from the configuration file.

• ---

• void GenerateFile()

• ---

creates final output file according to input data.

• ---

• std::string ResultFileName()

• ---

creates output filename which is used by default.

• ---

• std::string DatFileName()()

• ---

creates input *.dat filename .

• ---

• std::string GridFileName()

• ---

creates input *.grid filename.

• ---

• int& _X()

• ---

returns private variable X. For example, _Nevents returns the private variable Nevents (see below).

• ---

• Variables:

• ---

• int IDauthors, IDprocess, IDenergy, version, Nevents, kinformat, outformat:

private variables which define authors, process, C.M. energy, version of the data files, number of events, set of input variables and an output format.

• ---

• Used by:

main.

• Includes:

<fstream> <cassert> <cmath> <complex> <cstdlib> <iostream> <map> <string> <utility> <vector> <stdio.h> <time.h> <iomanip> <limits> <string> <ctime> "newrand.h" "NDarray.h" "NDgrid.h" "iFunc.h" "Generator.h" "Particle.h" "Constants.h" "Kinematics.h" "Event.h"

4 Program Installation

Some materials related to the ExDiff physics and generator can be found on the web page

https://exdiff.hepforge.org/

To get the code of the generator one should download the file

https://exdiff.hepforge.org/code/ExDiff1.0.zip

The program is written essentially entirely in standard c++, and should run on any platform with such a compiler.

The following installation procedure is suggested for the Linux users, it was tested with CERN SLC7.

Copy files to your folder 2. 2.

Change the card file in the folder config or use sample files. 3. 3.

Go to the folder with Makefile 4. 4.

$ make 5. 5.

$ ExDiff <cardfile name> [<output file name>] 6. 6.

$ cd output 7. 7.

see output file in the folder output

In the main folder you can see some files:

• readme.txt

contains brief description of the generator;

• main.cpp

is the main function;

• Makefile

defines compilation instructions;

• main_with_analizer.cpp

is the main function with analyzer examples;

5 Getting Started with the Simple Example

The Simple Example could look as following:

/* main.cpp */ #include <fstream> #include <cassert> #include <cmath> #include <complex> #include <cstdlib> #include <iostream> #include <map> #include <string> #include <utility> #include <vector> #include <stdio.h> #include <time.h> #include <iomanip> #include <limits> #include <string> #include <ctime> #include "inc/I.h" #include "inc/PI.h" #include "inc/newrand.h" #include "inc/NDarray.h" #include "inc/NDgrid.h" #include "inc/iFunc.h" #include "inc/Generator.h" #include "inc/Particle.h" #include "inc/Constants.h" #include "inc/Kinematics.h" #include "inc/Event.h" #include "inc/Interface.h"

using namespace ExDiff;

int main(int argc, const char** argv){

// final construction // datacard is the argument of the main file (filename) const char* datacard = argv[1]; // reading input data card // create interface Interface iogen(datacard); iogen.GeneratorInfo(); iogen.PrintPars(); // output using interface iogen.GenerateFile();

// Additional procedures

return 0; }

First, we set the object of the ExDiff::Interface class, then print the general information, and finally generate an output file. If you need another type of output, you can make some modifications in the ExDiff::Interface::GenerateFile method (see subsection 5.2).

5.1 Analyzer

Here you can see example of the simple analyzer. It can be inserted into the previous example instead of the phrase // Additional procedures.

// time for calculations startΨ//////////////////////////ΨΨΨΨΨΨΨΨΨΨΨΨ printf("analizer clock start = %d\n", std::clock()); start = std::clock(); /////////////////////////////////////////////////////////

Event ev; // input file std::string filename="output/A1M2E0_2F0.exdiff"; // output file std::string ofilename="output/t_A1M2E0_2F0.res";

int i,j,n,Nbins; Nbins = 128; // number of bins in t variable // t-bins std::vector<double> tbin, result, tgrid; tbin.clear(); tgrid.clear(); double taux=0.0; for(i = 0; i < Nbins; i++){ taux=(2.0*i+1.0)0.5/Nbins; tbin.push_back(taux); taux=i1.0/Nbins; tgrid.push_back(taux); result.push_back(0.0);ΨΨ }

std::cout<< "Begin to read events" <<std::endl; // events reading and analysis

int format = 0; // format of the input file
double t; // |t| variable
double x = 0.0; // auxiliary variable

// defines number of events in the file std::vector<int> Nfile = ev.TakeFromFile(10,format,filename); int Nevents = Nfile[1];

// prints parameters std::cout<< "Number of events = " << Nevents << " Number of particles = " << Nfile[0] << " Number of strings = " << Nfile[2] <<std::endl;

for(n = 1; n < Nevents + 1; n++){

// read the n-th event from file ev.TakeEvent(Nfile,n,format,filename);

// calculation of the variable t of the event t = 0.0; x = (ev._particles()[0]._E()-ev._particles()[2]._E()); t = -xx; x = (ev._particles()[0]._px()-ev._particles()[2]._px()); t = t+xx; x = (ev._particles()[0]._py()-ev._particles()[2]._py()); t = t+xx; x = (ev._particles()[0]._pz()-ev._particles()[2]._pz()); t = t+xx;

// defines the t-bin i = 0; j = 0; while(tgrid[i] <= t && i < Nbins){ j=i; i++; }

   result[j]++; // adds 1 to the bin

}

// output std::ofstream f; f.open(ofilename, std::ofstream::out | std::ofstream::app);

   if (!f.is_open()) {
      std::cout << "Can not add to an *.res file!\n";
    }

   for(i = 0; i < Nbins; i++){
      result[i]=result[i]/Nevents;
      f << std::setw(9) << "{ " << std::setprecision(19)
      << std::scientific << tbin[i] << ", "
      << std::scientific << result[i] << " }, \n";
   }

   f.close();

// time for calculations stopΨ////////////////////////// printf("clock stop = %d\n", std::clock()); durationm = ( std::clock() - start ) / (double) CLOCKS_PER_SEC; std::cout<<"duration of the analizer = "<< durationm << ’\n’; /////////////////////////////////////////////////////////

Let us use any output *.exdiff file to extract events in the special kinematical region.

In this example, we obtain the normalized $|t|$ probability distribution and put the result into a simple file.

5.2 For developers

In this subsection we show how you can make modifications to perform another type of output format. For this purpose we can use direct access to values of momenta and ids of all the particles. In the file ExDiff1.0/src/interface.cpp you can find some comments:

// FOR DEVELOPERS ================================================== // You can use directly all the parameters of particles in the event // to make your own output or connection to your software // instead of the string

ev.AddToFile(outformat,outputfile);ΨΨ

// use your own method with the following parameters of all particles ... // i: 0 => ev._particles().size()-1 [i changes 0=>3 (2 to 2), ... // ev._particles().size() = number of particles in the event // ev._particles()[i]._ID() = ID of theΨparticle // ev._particles()[i]._m() = mass of theΨparticle // ev._particles()[i]._E() = energy of theΨparticle // ev._particles()[i]._px() = px of theΨparticle // ev._particles()[i]._py() = py of theΨparticle // ev._particles()[i]._pz() = pz of theΨparticleΨ // FOR DEVELOPERS ===================================================

You could create your own class for output. In further versions of the generator we will add HEPMC or other usual output.

Aknowledgements

Authors thanks to Simone Giani, Robert Ciesielski, Jan Kaspar, Gustavo Gil Da Silveira, Michele Arneodo, Joao Varela and other members of the LHC diffractive community for useful discussions and help.

Index of basic Classes, Methods and Variables

[TABLE]

[TABLE]

[TABLE]