PWGLF/SPECTRA/ChargedHadrons/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