set of macros to create plots (Michael Knichel)
[u/mrichter/AliRoot.git] / PWG0 / dNdPt / macros / plots / defineVariables.C
1 //------------------------------------------------------------------------------
2 // defineVariables.C
3 //
4 // define all Variables that are needed to store data and uncertainties
5 //------------------------------------------------------------------------------
6
7
8 //
9 // define more arrays to store ALICE NSD data points
10 //     
11                                              // for NSD
12 Double_t ptNsd2PiPtAlice[binsNsdAlice] = {0};            // pt   value (weighted)
13 Double_t centerPtNsd2PiPtAlice[binsNsdAlice] = {0};      //      center of bin
14 Double_t widthPtNsd2PiPtAlice[binsNsdAlice] = {0};       //      width
15 Double_t errPtNsd2PiPtAlice[binsNsdAlice] = {0};         //      error (half width)
16 Double_t lowPtNsd2PiPtAlice[binsNsdAlice] = {0};         //      lower edge
17 Double_t highPtNsd2PiPtAlice[binsNsdAlice] = {0};        //      upper edge
18
19 Double_t nsd2PiPtAlice[binsNsdAlice] = {0};                 // NSD
20 Double_t statNsd2PiPtAlice[binsNsdAlice] = {0};             //      stat error
21 Double_t lowStatNsd2PiPtAlice[binsNsdAlice] = {0};          //                  lower
22 Double_t highStatNsd2PiPtAlice[binsNsdAlice] = {0};         //                  upper
23 Double_t relStatNsd2PiPtAlice[binsNsdAlice] = {0};          //                  relative
24 Double_t systNsd2PiPtAlice[binsNsdAlice] = {0};             //      syst error
25 Double_t lowSystNsd2PiPtAlice[binsNsdAlice] = {0};          //                  lower
26 Double_t highSystNsd2PiPtAlice[binsNsdAlice] = {0};         //                  upper
27 Double_t relSystNsd2PiPtAlice[binsNsdAlice] = {0};          //                  relative
28 Double_t errNsd2PiPtAlice[binsNsdAlice] = {0};              //      stat+syst added linearly
29 Double_t lowErrNsd2PiPtAlice[binsNsdAlice] = {0};           //                  lower
30 Double_t highErrNsd2PiPtAlice[binsNsdAlice] = {0};          //                  upper
31 Double_t relErrNsd2PiPtAlice[binsNsdAlice] = {0};           //                  relative
32 Double_t err2Nsd2PiPtAlice[binsNsdAlice] = {0};             //      stat+syst added quadratically
33 Double_t lowErr2Nsd2PiPtAlice[binsNsdAlice] = {0};          //                  lower
34 Double_t highErr2Nsd2PiPtAlice[binsNsdAlice] = {0};         //                  upper
35 Double_t relErr2Nsd2PiPtAlice[binsNsdAlice] = {0};          //                  relative
36
37 //
38 // define more arrays to store ALICE INEL data points
39 //  
40                                                 // for INEL
41 Double_t ptInel2PiPtAlice[binsInelAlice] = {0};          // pt   value (weighted)
42 Double_t centerPtInel2PiPtAlice[binsInelAlice] = {0};    //      center of bin
43 Double_t widthPtInel2PiPtAlice[binsInelAlice] = {0};     //      width
44 Double_t errPtInel2PiPtAlice[binsInelAlice] = {0};       //      error (half width)
45 Double_t lowPtInel2PiPtAlice[binsInelAlice] = {0};       //      lower edge
46 Double_t highPtInel2PiPtAlice[binsInelAlice] = {0};      //      upper edge
47
48 Double_t inel2PiPtAlice[binsInelAlice] = {0};                // INEL
49 Double_t statInel2PiPtAlice[binsInelAlice] = {0};            //      stat error
50 Double_t lowStatInel2PiPtAlice[binsInelAlice] = {0};         //                  lower
51 Double_t highStatInel2PiPtAlice[binsInelAlice] = {0};        //                  upper
52 Double_t relStatInel2PiPtAlice[binsInelAlice] = {0};         //                  relative
53 Double_t systInel2PiPtAlice[binsInelAlice] = {0};            //      syst error
54 Double_t lowSystInel2PiPtAlice[binsInelAlice] = {0};         //                  lower
55 Double_t highSystInel2PiPtAlice[binsInelAlice] = {0};        //                  upper
56 Double_t relSystInel2PiPtAlice[binsInelAlice] = {0};         //                  relative
57 Double_t errInel2PiPtAlice[binsInelAlice] = {0};             //      stat+syst added linearly
58 Double_t lowErrInel2PiPtAlice[binsInelAlice] = {0};          //                  lower
59 Double_t highErrInel2PiPtAlice[binsInelAlice] = {0};         //                  upper
60 Double_t relErrInel2PiPtAlice[binsInelAlice] = {0};          //                  relative
61 Double_t err2Inel2PiPtAlice[binsInelAlice] = {0};            //      stat+syst added quadratically
62 Double_t lowErr2Inel2PiPtAlice[binsInelAlice] = {0};         //                  lower
63 Double_t highErr2Inel2PiPtAlice[binsInelAlice] = {0};        //                  upper
64 Double_t relErr2Inel2PiPtAlice[binsInelAlice] = {0};         //                  relative
65
66 //
67 // define more arrays to store ALICE YIELD data points
68 //  
69                                                 // for YIELD
70 Double_t ptYield2PiPtAlice[binsYieldAlice] = {0};        // pt   value (weighted)
71 Double_t centerPtYield2PiPtAlice[binsYieldAlice] = {0};  //      center of bin
72 Double_t widthPtYield2PiPtAlice[binsYieldAlice] = {0};   //      width
73 Double_t errPtYield2PiPtAlice[binsYieldAlice] = {0};     //      error (half width)
74 Double_t lowPtYield2PiPtAlice[binsYieldAlice] = {0};     //      lower edge
75 Double_t highPtYield2PiPtAlice[binsYieldAlice] = {0};    //      upper edge
76
77 Double_t yield2PiPtAlice[binsYieldAlice] = {0};               // Invariant Yield
78 Double_t statYield2PiPtAlice[binsYieldAlice] = {0};           //      stat error
79 Double_t lowStatYield2PiPtAlice[binsYieldAlice] = {0};        //                  lower
80 Double_t highStatYield2PiPtAlice[binsYieldAlice] = {0};       //                  upper
81 Double_t relStatYield2PiPtAlice[binsYieldAlice] = {0};        //                  relative
82 Double_t systYield2PiPtAlice[binsYieldAlice] = {0};           //      syst error
83 Double_t lowSystYield2PiPtAlice[binsYieldAlice] = {0};        //                  lower
84 Double_t highSystYield2PiPtAlice[binsYieldAlice] = {0};       //                  upper
85 Double_t relSystYield2PiPtAlice[binsYieldAlice] = {0};        //                  relative
86 Double_t errYield2PiPtAlice[binsYieldAlice] = {0};            //      stat+syst added linearly
87 Double_t lowErrYield2PiPtAlice[binsYieldAlice] = {0};         //                  lower
88 Double_t highErrYield2PiPtAlice[binsYieldAlice] = {0};        //                  upper
89 Double_t relErrYield2PiPtAlice[binsYieldAlice] = {0};         //                  relative
90 Double_t err2Yield2PiPtAlice[binsYieldAlice] = {0};           //      stat+syst added quadratically
91 Double_t lowErr2Yield2PiPtAlice[binsYieldAlice] = {0};        //                  lower
92 Double_t highErr2Yield2PiPtAlice[binsYieldAlice] = {0};       //                  upper
93 Double_t relErr2Yield2PiPtAlice[binsYieldAlice] = {0};        //                  relative
94
95
96
97
98
99
100 //
101 // define arrays to store ALICE NSD data points
102 //     
103                                              // for NSD
104 Double_t ptNsdAlice[binsNsdAlice] = {0};            // pt   value (weighted)
105 Double_t centerPtNsdAlice[binsNsdAlice] = {0};      //      center of bin
106 Double_t widthPtNsdAlice[binsNsdAlice] = {0};       //      width
107 Double_t errPtNsdAlice[binsNsdAlice] = {0};         //      error (half width)
108 Double_t lowPtNsdAlice[binsNsdAlice] = {0};         //      lower edge
109 Double_t highPtNsdAlice[binsNsdAlice] = {0};        //      upper edge
110
111 Double_t nsdAlice[binsNsdAlice] = {0};                 // NSD
112 Double_t statNsdAlice[binsNsdAlice] = {0};             //      stat error
113 Double_t lowStatNsdAlice[binsNsdAlice] = {0};          //                  lower
114 Double_t highStatNsdAlice[binsNsdAlice] = {0};         //                  upper
115 Double_t relStatNsdAlice[binsNsdAlice] = {0};          //                  relative
116 Double_t systNsdAlice[binsNsdAlice] = {0};             //      syst error
117 Double_t lowSystNsdAlice[binsNsdAlice] = {0};          //                  lower
118 Double_t highSystNsdAlice[binsNsdAlice] = {0};         //                  upper
119 Double_t relSystNsdAlice[binsNsdAlice] = {0};          //                  relative
120 Double_t errNsdAlice[binsNsdAlice] = {0};              //      stat+syst added linearly
121 Double_t lowErrNsdAlice[binsNsdAlice] = {0};           //                  lower
122 Double_t highErrNsdAlice[binsNsdAlice] = {0};          //                  upper
123 Double_t relErrNsdAlice[binsNsdAlice] = {0};           //                  relative
124 Double_t err2NsdAlice[binsNsdAlice] = {0};             //      stat+syst added quadratically
125 Double_t lowErr2NsdAlice[binsNsdAlice] = {0};          //                  lower
126 Double_t highErr2NsdAlice[binsNsdAlice] = {0};         //                  upper
127 Double_t relErr2NsdAlice[binsNsdAlice] = {0};          //                  relative
128
129 //
130 // define arrays to store ALICE INEL data points
131 //  
132                                                 // for INEL
133 Double_t ptInelAlice[binsInelAlice] = {0};          // pt   value (weighted)
134 Double_t centerPtInelAlice[binsInelAlice] = {0};    //      center of bin
135 Double_t widthPtInelAlice[binsInelAlice] = {0};     //      width
136 Double_t errPtInelAlice[binsInelAlice] = {0};       //      error (half width)
137 Double_t lowPtInelAlice[binsInelAlice] = {0};       //      lower edge
138 Double_t highPtInelAlice[binsInelAlice] = {0};      //      upper edge
139
140 Double_t inelAlice[binsInelAlice] = {0};                // INEL
141 Double_t statInelAlice[binsInelAlice] = {0};            //      stat error
142 Double_t lowStatInelAlice[binsInelAlice] = {0};         //                  lower
143 Double_t highStatInelAlice[binsInelAlice] = {0};        //                  upper
144 Double_t relStatInelAlice[binsInelAlice] = {0};         //                  relative
145 Double_t systInelAlice[binsInelAlice] = {0};            //      syst error
146 Double_t lowSystInelAlice[binsInelAlice] = {0};         //                  lower
147 Double_t highSystInelAlice[binsInelAlice] = {0};        //                  upper
148 Double_t relSystInelAlice[binsInelAlice] = {0};         //                  relative
149 Double_t errInelAlice[binsInelAlice] = {0};             //      stat+syst added linearly
150 Double_t lowErrInelAlice[binsInelAlice] = {0};          //                  lower
151 Double_t highErrInelAlice[binsInelAlice] = {0};         //                  upper
152 Double_t relErrInelAlice[binsInelAlice] = {0};          //                  relative
153 Double_t err2InelAlice[binsInelAlice] = {0};            //      stat+syst added quadratically
154 Double_t lowErr2InelAlice[binsInelAlice] = {0};         //                  lower
155 Double_t highErr2InelAlice[binsInelAlice] = {0};        //                  upper
156 Double_t relErr2InelAlice[binsInelAlice] = {0};         //                  relative
157
158 //
159 // define arrays to store ALICE YIELD data points
160 //  
161                                                 // for YIELD
162 Double_t ptYieldAlice[binsYieldAlice] = {0};        // pt   value (weighted)
163 Double_t centerPtYieldAlice[binsYieldAlice] = {0};  //      center of bin
164 Double_t widthPtYieldAlice[binsYieldAlice] = {0};   //      width
165 Double_t errPtYieldAlice[binsYieldAlice] = {0};     //      error (half width)
166 Double_t lowPtYieldAlice[binsYieldAlice] = {0};     //      lower edge
167 Double_t highPtYieldAlice[binsYieldAlice] = {0};    //      upper edge
168
169 Double_t yieldAlice[binsYieldAlice] = {0};               // Invariant Yield
170 Double_t statYieldAlice[binsYieldAlice] = {0};           //      stat error
171 Double_t lowStatYieldAlice[binsYieldAlice] = {0};        //                  lower
172 Double_t highStatYieldAlice[binsYieldAlice] = {0};       //                  upper
173 Double_t relStatYieldAlice[binsYieldAlice] = {0};        //                  relative
174 Double_t systYieldAlice[binsYieldAlice] = {0};           //      syst error
175 Double_t lowSystYieldAlice[binsYieldAlice] = {0};        //                  lower
176 Double_t highSystYieldAlice[binsYieldAlice] = {0};       //                  upper
177 Double_t relSystYieldAlice[binsYieldAlice] = {0};        //                  relative
178 Double_t errYieldAlice[binsYieldAlice] = {0};            //      stat+syst added linearly
179 Double_t lowErrYieldAlice[binsYieldAlice] = {0};         //                  lower
180 Double_t highErrYieldAlice[binsYieldAlice] = {0};        //                  upper
181 Double_t relErrYieldAlice[binsYieldAlice] = {0};         //                  relative
182 Double_t err2YieldAlice[binsYieldAlice] = {0};           //      stat+syst added quadratically
183 Double_t lowErr2YieldAlice[binsYieldAlice] = {0};        //                  lower
184 Double_t highErr2YieldAlice[binsYieldAlice] = {0};       //                  upper
185 Double_t relErr2YieldAlice[binsYieldAlice] = {0};        //                  relative
186
187 //
188 // used for fitting and shifting ALICE data
189 //
190
191 Double_t ptAliceFit[binsAlice] = {0};
192 Double_t widthPtAliceFit[binsAlice] = {0};
193 Double_t errPtAliceFit[binsAlice] = {0};
194 Double_t lowPtAliceFit[binsAlice] = {0};
195 Double_t highPtAliceFit[binsAlice] = {0};
196 Double_t nsdAliceFit[binsAlice] = {0};
197 Double_t errNsdAliceFit[binsAlice] = {0};
198 Double_t statNsdAliceFit[binsAlice] = {0};
199 Double_t systNsdAliceFit[binsAlice] = {0};
200
201 Double_t pt2PiPtAliceFit[binsAlice] = {0};
202 Double_t widthPt2PiPtAliceFit[binsAlice] = {0};
203 Double_t errPt2PiPtAliceFit[binsAlice] = {0};
204 Double_t lowPt2PiPtAliceFit[binsAlice] = {0};
205 Double_t highPt2PiPtAliceFit[binsAlice] = {0};
206 Double_t nsd2PiPtAliceFit[binsAlice] = {0};
207 Double_t errNsd2PiPtAliceFit[binsAlice] = {0};
208 Double_t statNsd2PiPtAliceFit[binsAlice] = {0};
209 Double_t systNsd2PiPtAliceFit[binsAlice] = {0};
210
211
212 //
213 // define arrays to store ATLAS data points
214 //
215
216 Double_t ptAtlas[binsAtlas] = {0};              // pt   value (weighted)
217 Double_t centerPtAtlas[binsAtlas] = {0};        //      center of bin
218 Double_t widthPtAtlas[binsAtlas] = {0};         //      width
219 Double_t errPtAtlas[binsAtlas] = {0};           //      error (half width)
220 Double_t lowErrPtAtlas[binsAtlas] = {0};        //      lower error
221 Double_t highErrPtAtlas[binsAtlas] = {0};       //      higher error
222 Double_t lowPtAtlas[binsAtlas] = {0};           //      lower edge
223 Double_t highPtAtlas[binsAtlas] = {0};          //      upper edge
224
225 Double_t nsdAtlas[binsAtlas] = {0};             // NSD
226 Double_t statNsdAtlas[binsAtlas] = {0};         //      stat error
227 Double_t lowStatNsdAtlas[binsAtlas] = {0};      //                  lower
228 Double_t highStatNsdAtlas[binsAtlas] = {0};     //                  upper
229 Double_t relStatNsdAtlas[binsAtlas] = {0};      //                  relative
230 Double_t systNsdAtlas[binsAtlas] = {0};         //      syst error
231 Double_t lowSystNsdAtlas[binsAtlas] = {0};      //                  lower
232 Double_t highSystNsdAtlas[binsAtlas] = {0};     //                  upper
233 Double_t relSystNsdAtlas[binsAtlas] = {0};      //                  relative
234 Double_t errNsdAtlas[binsAtlas] = {0};          //      stat+syst added linearly
235 Double_t lowErrNsdAtlas[binsAtlas] = {0};       //                  lower
236 Double_t highErrNsdAtlas[binsAtlas] = {0};      //                  upper
237 Double_t relErrNsdAtlas[binsAtlas] = {0};       //                  relative
238 Double_t err2NsdAtlas[binsAtlas] = {0};         //      stat+syst added quadratically
239 Double_t lowErr2NsdAtlas[binsAtlas] = {0};      //                  lower
240 Double_t highErr2NsdAtlas[binsAtlas] = {0};     //                  upper
241 Double_t relErr2NsdAtlas[binsAtlas] = {0};      //                  relative
242
243 //
244 // define arrays to store CMS data points
245 //
246
247 Double_t ptCms[binsCms] = {0};                  // pt   value (weighted)
248 Double_t centerPtCms[binsCms] = {0};            //      center of bin
249 Double_t widthPtCms[binsCms] = {0};             //      width
250 Double_t errPtCms[binsCms] = {0};               //      error (half width)
251 Double_t lowPtCms[binsCms] = {0};               //      lower edge
252 Double_t highPtCms[binsCms] = {0};              //      upper edge
253
254 Double_t nsdCms[binsCms] = {0};                 // NSD
255 /*
256 Double_t statNsdCms[binsCms] = {0};             //      stat error
257 Double_t lowStatNsdCms[binsCms] = {0};          //                  lower
258 Double_t highStatNsdCms[binsCms] = {0};         //                  upper
259 Double_t relStatNsdCms[binsCms] = {0};          //                  relative
260 Double_t systNsdCms[binsCms] = {0};             //      syst error
261 Double_t lowSystNsdCms[binsCms] = {0};          //                  lower
262 Double_t highSystNsdCms[binsCms] = {0};         //                  upper
263 Double_t relSystNsdCms[binsCms] = {0};          //                  relative
264 */
265 Double_t errNsdCms[binsCms] = {0};              //      stat+syst added linearly
266 Double_t lowErrNsdCms[binsCms] = {0};           //                  lower
267 Double_t highErrNsdCms[binsCms] = {0};          //                  upper
268 Double_t relErrNsdCms[binsCms] = {0};           //                  relative
269 Double_t err2NsdCms[binsCms] = {0};             //      stat+syst added quadratically
270 Double_t lowErr2NsdCms[binsCms] = {0};          //                  lower
271 Double_t highErr2NsdCms[binsCms] = {0};         //                  upper
272 Double_t relErr2NsdCms[binsCms] = {0};          //                  relative
273
274 //
275 // define arrays to store UA1 data points
276 //
277
278 Double_t ptUa1[binsUa1] = {0};                  // pt   value (weighted)
279 Double_t centerPtUa1[binsUa1] = {0};            //      center of bin
280 Double_t widthPtUa1[binsUa1] = {0};             //      width
281 Double_t errPtUa1[binsUa1] = {0};               //      error (half width)
282 Double_t lowPtUa1[binsUa1] = {0};               //      lower edge
283 Double_t highPtUa1[binsUa1] = {0};              //      upper edge
284
285 Double_t crossUa1[binsUa1] = {0};               // Invariant cross section
286 /*
287 Double_t statCrossUa1[binsUa1] = {0};           //      stat error
288 Double_t lowStatCrossUa1[binsUa1] = {0};        //                  lower
289 Double_t highStatCrossUa1[binsUa1] = {0};       //                  upper
290 Double_t relStatCrossUa1[binsUa1] = {0};        //                  relative
291 Double_t systCrossUa1[binsUa1] = {0};           //      syst error
292 Double_t lowSystCrossUa1[binsUa1] = {0};        //                  lower
293 Double_t highSystCrossUa1[binsUa1] = {0};       //                  upper
294 Double_t relSystCrossUa1[binsUa1] = {0};        //                  relative
295 */
296 Double_t errCrossUa1[binsUa1] = {0};            //      stat+syst added linearly
297 Double_t lowErrCrossUa1[binsUa1] = {0};         //                  lower
298 Double_t highErrCrossUa1[binsUa1] = {0};        //                  upper
299 Double_t relErrCrossUa1[binsUa1] = {0};         //                  relative
300 Double_t err2CrossUa1[binsUa1] = {0};           //      stat+syst added quadratically
301 Double_t lowErr2CrossUa1[binsUa1] = {0};        //                  lower
302 Double_t highErr2CrossUa1[binsUa1] = {0};       //                  upper
303 Double_t relErr2CrossUa1[binsUa1] = {0};        //                  relative
304
305 Double_t yieldUa1[binsUa1] = {0};               // Invariant Yield
306 /*
307 Double_t statYieldUa1[binsUa1] = {0};           //      stat error
308 Double_t lowStatYieldUa1[binsUa1] = {0};        //                  lower
309 Double_t highStatYieldUa1[binsUa1] = {0};       //                  upper
310 Double_t relStatYieldUa1[binsUa1] = {0};        //                  relative
311 Double_t systYieldUa1[binsUa1] = {0};           //      syst error
312 Double_t lowSystYieldUa1[binsUa1] = {0};        //                  lower
313 Double_t highSystYieldUa1[binsUa1] = {0};       //                  upper
314 Double_t relSystYieldUa1[binsUa1] = {0};        //                  relative
315 */
316 Double_t errYieldUa1[binsUa1] = {0};            //      stat+syst added linearly
317 Double_t lowErrYieldUa1[binsUa1] = {0};         //                  lower
318 Double_t highErrYieldUa1[binsUa1] = {0};        //                  upper
319 Double_t relErrYieldUa1[binsUa1] = {0};         //                  relative
320 Double_t err2YieldUa1[binsUa1] = {0};           //      stat+syst added quadratically
321 Double_t lowErr2YieldUa1[binsUa1] = {0};        //                  lower
322 Double_t highErr2YieldUa1[binsUa1] = {0};       //                  upper
323 Double_t relErr2YieldUa1[binsUa1] = {0};        //                  relative
324
325 //
326 // define arrays to store PHOJET data points
327 //
328
329 Double_t nEventsPhojet = 0;
330
331 Double_t centerPtPhojet[binsPhojet] = {0};     
332 Double_t ptPhojet[binsPhojet] =  {0};
333 Double_t widthPtPhojet[binsPhojet] =  {0};
334 Double_t errPtPhojet[binsPhojet] =  {0};
335 Double_t lowPtPhojet[binsPhojet] =  {0};
336 Double_t highPtPhojet[binsPhojet] =  {0};
337
338 Double_t inelPhojet[binsPhojet] = {0};
339 Double_t errInelPhojet[binsPhojet] = {0}; 
340 Double_t lowErrInelPhojet[binsPhojet] = {0};
341 Double_t highErrInelPhojet[binsPhojet] = {0};
342 Double_t relErrInelPhojet[binsPhojet] = {0};
343
344 Double_t centerPt2PiPtPhojet[binsPhojet] = {0};     
345 Double_t pt2PiPtPhojet[binsPhojet] =  {0};
346 Double_t widthPt2PiPtPhojet[binsPhojet] =  {0};
347 Double_t errPt2PiPtPhojet[binsPhojet] =  {0};
348 Double_t lowPt2PiPtPhojet[binsPhojet] =  {0};
349 Double_t highPt2PiPtPhojet[binsPhojet] =  {0};
350
351 Double_t inel2PiPtPhojet[binsPhojet] = {0};
352 Double_t errInel2PiPtPhojet[binsPhojet] = {0}; 
353 Double_t lowErrInel2PiPtPhojet[binsPhojet] = {0};
354 Double_t highErrInel2PiPtPhojet[binsPhojet] = {0};
355 Double_t relErrInel2PiPtPhojet[binsPhojet] = {0};
356
357 //
358 // define arrays to store PYTHIA D6T (109) data points
359 //
360
361 Double_t nEventsPythia109 = 0;
362
363 Double_t centerPtPythia109[binsPythia109] = {0};     
364 Double_t ptPythia109[binsPythia109] =  {0};
365 Double_t widthPtPythia109[binsPythia109] =  {0};
366 Double_t errPtPythia109[binsPythia109] =  {0};
367 Double_t lowPtPythia109[binsPythia109] =  {0};
368 Double_t highPtPythia109[binsPythia109] =  {0};
369
370 Double_t inelPythia109[binsPythia109] = {0};
371 Double_t errInelPythia109[binsPythia109] = {0}; 
372 Double_t lowErrInelPythia109[binsPythia109] = {0};
373 Double_t highErrInelPythia109[binsPythia109] = {0};
374 Double_t relErrInelPythia109[binsPythia109] = {0};
375
376 Double_t centerPt2PiPtPythia109[binsPythia109] = {0};     
377 Double_t pt2PiPtPythia109[binsPythia109] =  {0};
378 Double_t widthPt2PiPtPythia109[binsPythia109] =  {0};
379 Double_t errPt2PiPtPythia109[binsPythia109] =  {0};
380 Double_t lowPt2PiPtPythia109[binsPythia109] =  {0};
381 Double_t highPt2PiPtPythia109[binsPythia109] =  {0};
382
383 Double_t inel2PiPtPythia109[binsPythia109] = {0};
384 Double_t errInel2PiPtPythia109[binsPythia109] = {0}; 
385 Double_t lowErrInel2PiPtPythia109[binsPythia109] = {0};
386 Double_t highErrInel2PiPtPythia109[binsPythia109] = {0};
387 Double_t relErrInel2PiPtPythia109[binsPythia109] = {0};
388
389
390 //
391 // define arrays to store PYTHIA ATLAS-CSC (306) data points
392 //
393
394 Double_t nEventsPythia306 = 0;
395
396 Double_t centerPtPythia306[binsPythia306] = {0};     
397 Double_t ptPythia306[binsPythia306] =  {0};
398 Double_t widthPtPythia306[binsPythia306] =  {0};
399 Double_t errPtPythia306[binsPythia306] =  {0};
400 Double_t lowPtPythia306[binsPythia306] =  {0};
401 Double_t highPtPythia306[binsPythia306] =  {0};
402
403 Double_t inelPythia306[binsPythia306] = {0};
404 Double_t errInelPythia306[binsPythia306] = {0}; 
405 Double_t lowErrInelPythia306[binsPythia306] = {0};
406 Double_t highErrInelPythia306[binsPythia306] = {0};
407 Double_t relErrInelPythia306[binsPythia306] = {0};
408
409 Double_t centerPt2PiPtPythia306[binsPythia306] = {0};     
410 Double_t pt2PiPtPythia306[binsPythia306] =  {0};
411 Double_t widthPt2PiPtPythia306[binsPythia306] =  {0};
412 Double_t errPt2PiPtPythia306[binsPythia306] =  {0};
413 Double_t lowPt2PiPtPythia306[binsPythia306] =  {0};
414 Double_t highPt2PiPtPythia306[binsPythia306] =  {0};
415
416 Double_t inel2PiPtPythia306[binsPythia306] = {0};
417 Double_t errInel2PiPtPythia306[binsPythia306] = {0}; 
418 Double_t lowErrInel2PiPtPythia306[binsPythia306] = {0};
419 Double_t highErrInel2PiPtPythia306[binsPythia306] = {0};
420 Double_t relErrInel2PiPtPythia306[binsPythia306] = {0};
421
422 //
423 // define arrays to store PYTHIA PERUGIA0 (320) data points
424 //
425
426 Double_t nEventsPythia320 = 0;
427
428 Double_t centerPtPythia320[binsPythia320] = {0};     
429 Double_t ptPythia320[binsPythia320] =  {0};
430 Double_t widthPtPythia320[binsPythia320] =  {0};
431 Double_t errPtPythia320[binsPythia320] =  {0};
432 Double_t lowPtPythia320[binsPythia320] =  {0};
433 Double_t highPtPythia320[binsPythia320] =  {0};
434
435 Double_t inelPythia320[binsPythia320] = {0};
436 Double_t errInelPythia320[binsPythia320] = {0}; 
437 Double_t lowErrInelPythia320[binsPythia320] = {0};
438 Double_t highErrInelPythia320[binsPythia320] = {0};
439 Double_t relErrInelPythia320[binsPythia320] = {0};
440
441 Double_t centerPt2PiPtPythia320[binsPythia320] = {0};     
442 Double_t pt2PiPtPythia320[binsPythia320] =  {0};
443 Double_t widthPt2PiPtPythia320[binsPythia320] =  {0};
444 Double_t errPt2PiPtPythia320[binsPythia320] =  {0};
445 Double_t lowPt2PiPtPythia320[binsPythia320] =  {0};
446 Double_t highPt2PiPtPythia320[binsPythia320] =  {0};
447
448 Double_t inel2PiPtPythia320[binsPythia320] = {0};
449 Double_t errInel2PiPtPythia320[binsPythia320] = {0}; 
450 Double_t lowErrInel2PiPtPythia320[binsPythia320] = {0};
451 Double_t highErrInel2PiPtPythia320[binsPythia320] = {0};
452 Double_t relErrInel2PiPtPythia320[binsPythia320] = {0};
453