PWGGA/GammaConv/AliGammaConversionAODBGHandler.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: Ana Marin, Kathrin Koch, Kenneth Aamodt                        *
   5  * Version 1.0                                                            *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 ////////////////////////////////////////////////
  17 //---------------------------------------------
  18 // Class for handling of background calculation
  19 //---------------------------------------------
  20 ////////////////////////////////////////////////
  21
  22 #include "AliGammaConversionAODBGHandler.h"
  23 #include "AliKFParticle.h"
  24 #include "AliAODConversionPhoton.h"
  25 #include "AliAODConversionMother.h"
  26
  27 using namespace std;
  28
  29 ClassImp(AliGammaConversionAODBGHandler)
  30
  31 AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler() :
  32   TObject(),
  33   fNEvents(10),
  34   fBGEventCounter(NULL),
  35   fBGEventENegCounter(NULL),
  36   fBGProbability(NULL),
  37   fBGEventVertex(NULL),
  38   fNBinsZ(0),
  39   fNBinsMultiplicity(0),
  40   fBinLimitsArrayZ(NULL),
  41   fBinLimitsArrayMultiplicity(NULL),
  42   fBGEvents(),
  43   fBGEventsENeg()
  44 {
  45   // constructor
  46 }
  47
  48 AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t binsZ,UInt_t binsMultiplicity,UInt_t nEvents) :
  49   TObject(),
  50   fNEvents(nEvents),
  51   fBGEventCounter(NULL),
  52   fBGEventENegCounter(NULL),
  53   fBGProbability(NULL),
  54   fBGEventVertex(NULL),
  55   fNBinsZ(binsZ),
  56   fNBinsMultiplicity(binsMultiplicity),
  57   fBinLimitsArrayZ(NULL),
  58   fBinLimitsArrayMultiplicity(NULL),
  59   fBGEvents(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
  60   fBGEventsENeg(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents)))
  61 {
  62   // constructor
  63 }
  64
  65
  66 AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t collisionSystem,UInt_t centMin,UInt_t centMax,UInt_t nEvents, Bool_t useTrackMult) :
  67   TObject(),
  68   fNEvents(nEvents),
  69   fBGEventCounter(NULL),
  70   fBGEventENegCounter(NULL),
  71   fBGProbability(NULL),
  72   fBGEventVertex(NULL),
  73   fNBinsZ(8),
  74   fNBinsMultiplicity(5),
  75   fBinLimitsArrayZ(NULL),
  76   fBinLimitsArrayMultiplicity(NULL),
  77   fBGEvents(fNBinsZ,AliGammaConversionMultipicityVector(fNBinsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
  78   fBGEventsENeg(fNBinsZ,AliGammaConversionMultipicityVector(fNBinsMultiplicity,AliGammaConversionBGEventVector(nEvents)))
  79 {
  80   // constructor
  81
  82    fBinLimitsArrayZ= new Double_t[8] ;
  83    if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
  84       fBinLimitsArrayZ[0] = -50.00;
  85       fBinLimitsArrayZ[1] = -5.5;
  86       fBinLimitsArrayZ[2] = -2.9;
  87       fBinLimitsArrayZ[3] = -0.65;
  88       fBinLimitsArrayZ[4] = 1.45;
  89       fBinLimitsArrayZ[5] = 3.65;
  90       fBinLimitsArrayZ[6] = 6.15;
  91       fBinLimitsArrayZ[7] = 50;
  92    }
  93    else if(collisionSystem == 0){
  94       fBinLimitsArrayZ[0] = -50.00;
  95       fBinLimitsArrayZ[1] = -3.375;
  96       fBinLimitsArrayZ[2] = -1.605;
  97       fBinLimitsArrayZ[3] = -0.225;
  98       fBinLimitsArrayZ[4] = 1.065;
  99       fBinLimitsArrayZ[5] = 2.445;
 100       fBinLimitsArrayZ[6] = 4.245;
 101       fBinLimitsArrayZ[7] = 50.00;
 102    }
 103    else{
 104       fBinLimitsArrayZ[0] = -50.00;
 105       fBinLimitsArrayZ[1] = -5.85;
 106       fBinLimitsArrayZ[2] = -3.35;
 107       fBinLimitsArrayZ[3] = -1.15;
 108       fBinLimitsArrayZ[4] = 0.85;
 109       fBinLimitsArrayZ[5] = 2.95;
 110       fBinLimitsArrayZ[6] = 5.55;
 111       fBinLimitsArrayZ[7] = 50.00;
 112    }
 113
 114
 115
 116    fBinLimitsArrayMultiplicity= new Double_t[5];
 117    if(useTrackMult){ // pp
 118       fBinLimitsArrayMultiplicity[0] = 0;
 119       fBinLimitsArrayMultiplicity[1] = 8.5;
 120       fBinLimitsArrayMultiplicity[2] = 16.5;
 121       fBinLimitsArrayMultiplicity[3] = 27.5;
 122       fBinLimitsArrayMultiplicity[4] = 200.;
 123       if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
 124          if(centMin == 0 && centMax == 5){
 125             fBinLimitsArrayMultiplicity[0] = 0.;
 126             fBinLimitsArrayMultiplicity[1] = 1540.;
 127             fBinLimitsArrayMultiplicity[2] = 1665.;
 128             fBinLimitsArrayMultiplicity[3] = 1780.;
 129             fBinLimitsArrayMultiplicity[4] = 5000.;
 130          }
 131          else if(centMin == 0 && centMax == 10){
 132             fBinLimitsArrayMultiplicity[0] = 0.;
 133             fBinLimitsArrayMultiplicity[1] = 1360.;
 134             fBinLimitsArrayMultiplicity[2] = 1520.;
 135             fBinLimitsArrayMultiplicity[3] = 1685.;
 136             fBinLimitsArrayMultiplicity[4] = 5000.;
 137          }
 138          else if(centMin == 0 && centMax == 20){
 139             fBinLimitsArrayMultiplicity[0] = 0.;
 140             fBinLimitsArrayMultiplicity[1] = 1110.;
 141             fBinLimitsArrayMultiplicity[2] = 1360.;
 142             fBinLimitsArrayMultiplicity[3] = 1600.;
 143             fBinLimitsArrayMultiplicity[4] = 5000.;
 144          }
 145          else if(centMin == 0 && centMax == 80){
 146             fBinLimitsArrayMultiplicity[0] = 0.;
 147             fBinLimitsArrayMultiplicity[1] = 890.;
 148             fBinLimitsArrayMultiplicity[2] = 1240.;
 149             fBinLimitsArrayMultiplicity[3] = 1540.;
 150             fBinLimitsArrayMultiplicity[4] = 5000.;
 151          }
 152          else if(centMin == 5 && centMax == 10){
 153             fBinLimitsArrayMultiplicity[0] = 0.;
 154             fBinLimitsArrayMultiplicity[1] = 1250.;
 155             fBinLimitsArrayMultiplicity[2] = 1345.;
 156             fBinLimitsArrayMultiplicity[3] = 1445.;
 157             fBinLimitsArrayMultiplicity[4] = 5000.;
 158          }
 159          else if(centMin == 10 && centMax == 20){
 160             fBinLimitsArrayMultiplicity[0] = 0.;
 161             fBinLimitsArrayMultiplicity[1] = 915.;
 162             fBinLimitsArrayMultiplicity[2] = 1020.;
 163             fBinLimitsArrayMultiplicity[3] = 1130.;
 164             fBinLimitsArrayMultiplicity[4] = 5000.;
 165          }
 166          else if(centMin == 20 && centMax == 40){
 167             fBinLimitsArrayMultiplicity[0] = 0.;
 168             fBinLimitsArrayMultiplicity[1] = 510.;
 169             fBinLimitsArrayMultiplicity[2] = 625.;
 170             fBinLimitsArrayMultiplicity[3] = 730.;
 171             fBinLimitsArrayMultiplicity[4] = 5000.;
 172          }
 173          else if(centMin == 40 && centMax == 80){
 174             fBinLimitsArrayMultiplicity[0] = 0.;
 175             fBinLimitsArrayMultiplicity[1] = 185.;
 176             fBinLimitsArrayMultiplicity[2] = 250.;
 177             fBinLimitsArrayMultiplicity[3] = 300.;
 178             fBinLimitsArrayMultiplicity[4] = 5000.;
 179          }
 180          else if(centMin == 60 && centMax == 80){
 181             fBinLimitsArrayMultiplicity[0] = 0.;
 182             fBinLimitsArrayMultiplicity[1] = 55.;
 183             fBinLimitsArrayMultiplicity[2] = 80.;
 184             fBinLimitsArrayMultiplicity[3] = 100.;
 185             fBinLimitsArrayMultiplicity[4] = 5000.;
 186          }
 187          else{ // Std 20-40
 188             fBinLimitsArrayMultiplicity[0] = 0.;
 189             fBinLimitsArrayMultiplicity[1] = 510.;
 190             fBinLimitsArrayMultiplicity[2] = 625.;
 191             fBinLimitsArrayMultiplicity[3] = 730.;
 192             fBinLimitsArrayMultiplicity[4] = 5000.;
 193          }
 194       }
 195
 196       else if(collisionSystem == 8 || collisionSystem == 9){ //pPb
 197
 198          fBinLimitsArrayMultiplicity[0] = 0.;
 199          fBinLimitsArrayMultiplicity[1] = 7.5;
 200          fBinLimitsArrayMultiplicity[2] = 16.5;
 201          fBinLimitsArrayMultiplicity[3] = 29.5;
 202          fBinLimitsArrayMultiplicity[4] = 500.;
 203
 204          if(centMin == 0 && centMax == 20){
 205             fBinLimitsArrayMultiplicity[0] = 0.;
 206             fBinLimitsArrayMultiplicity[1] = 31.5;
 207             fBinLimitsArrayMultiplicity[2] = 40.5;
 208             fBinLimitsArrayMultiplicity[3] = 50.5;
 209             fBinLimitsArrayMultiplicity[4] = 500.;
 210          } else if(centMin == 20 && centMax == 40){
 211             fBinLimitsArrayMultiplicity[0] = 0.;
 212             fBinLimitsArrayMultiplicity[1] = 19.5;
 213             fBinLimitsArrayMultiplicity[2] = 25.5;
 214             fBinLimitsArrayMultiplicity[3] = 32.5;
 215             fBinLimitsArrayMultiplicity[4] = 500.;
 216          } else if(centMin == 40 && centMax == 60){
 217             fBinLimitsArrayMultiplicity[0] = 0.;
 218             fBinLimitsArrayMultiplicity[1] = 12.5;
 219             fBinLimitsArrayMultiplicity[2] = 16.5;
 220             fBinLimitsArrayMultiplicity[3] = 22.5;
 221             fBinLimitsArrayMultiplicity[4] = 500.;
 222          } else if(centMin == 60 && centMax == 80){
 223             fBinLimitsArrayMultiplicity[0] = 0.;
 224             fBinLimitsArrayMultiplicity[1] = 5.5;
 225             fBinLimitsArrayMultiplicity[2] = 9.5;
 226             fBinLimitsArrayMultiplicity[3] = 13.5;
 227             fBinLimitsArrayMultiplicity[4] = 500.;
 228           } else if(centMin == 60 && centMax == 100){
 229             fBinLimitsArrayMultiplicity[0] = 0.;
 230             fBinLimitsArrayMultiplicity[1] = 2.5;
 231             fBinLimitsArrayMultiplicity[2] = 6.5;
 232             fBinLimitsArrayMultiplicity[3] = 11.5;
 233             fBinLimitsArrayMultiplicity[4] = 500.;
 234           }
 235       }
 236    }
 237    else{// pp or pPb V0 Mult
 238       fBinLimitsArrayMultiplicity[0] = 2;
 239       fBinLimitsArrayMultiplicity[1] = 3;
 240       fBinLimitsArrayMultiplicity[2] = 4;
 241       fBinLimitsArrayMultiplicity[3] = 5;
 242       fBinLimitsArrayMultiplicity[4] = 9999;
 243       if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
 244          if(centMin == 0 && centMax == 5){
 245             fBinLimitsArrayMultiplicity[0] = 0.;
 246             fBinLimitsArrayMultiplicity[1] = 27.;
 247             fBinLimitsArrayMultiplicity[2] = 31.;
 248             fBinLimitsArrayMultiplicity[3] = 36.;
 249             fBinLimitsArrayMultiplicity[4] = 100.;
 250          }
 251          else if(centMin == 0 && centMax == 10){
 252             fBinLimitsArrayMultiplicity[0] = 0.;
 253             fBinLimitsArrayMultiplicity[1] = 25.;
 254             fBinLimitsArrayMultiplicity[2] = 30.;
 255             fBinLimitsArrayMultiplicity[3] = 36.;
 256             fBinLimitsArrayMultiplicity[4] = 100.;
 257          }
 258          else if(centMin == 0 && centMax == 20){
 259             fBinLimitsArrayMultiplicity[0] = 0.;
 260             fBinLimitsArrayMultiplicity[1] = 22.;
 261             fBinLimitsArrayMultiplicity[2] = 27.;
 262             fBinLimitsArrayMultiplicity[3] = 33.;
 263             fBinLimitsArrayMultiplicity[4] = 100.;
 264          }
 265          else if(centMin == 0 && centMax == 80){
 266             fBinLimitsArrayMultiplicity[0] = 0.;
 267             fBinLimitsArrayMultiplicity[1] = 18.;
 268             fBinLimitsArrayMultiplicity[2] = 25.;
 269             fBinLimitsArrayMultiplicity[3] = 32.;
 270             fBinLimitsArrayMultiplicity[4] = 100.;
 271          }
 272          else if(centMin == 5 && centMax == 10){
 273             fBinLimitsArrayMultiplicity[0] = 0.;
 274             fBinLimitsArrayMultiplicity[1] = 23.;
 275             fBinLimitsArrayMultiplicity[2] = 27.;
 276             fBinLimitsArrayMultiplicity[3] = 32.;
 277             fBinLimitsArrayMultiplicity[4] = 100.;
 278          }
 279          else if(centMin == 10 && centMax == 20){
 280             fBinLimitsArrayMultiplicity[0] = 0.;
 281             fBinLimitsArrayMultiplicity[1] = 18.;
 282             fBinLimitsArrayMultiplicity[2] = 22.;
 283             fBinLimitsArrayMultiplicity[3] = 27.;
 284             fBinLimitsArrayMultiplicity[4] = 100.;
 285          }
 286          else if(centMin == 20 && centMax == 40){
 287             fBinLimitsArrayMultiplicity[0] = 0.;
 288             fBinLimitsArrayMultiplicity[1] = 11.;
 289             fBinLimitsArrayMultiplicity[2] = 14.;
 290             fBinLimitsArrayMultiplicity[3] = 18.;
 291             fBinLimitsArrayMultiplicity[4] = 100.;
 292          }
 293          else if(centMin == 40 && centMax == 80){
 294             fBinLimitsArrayMultiplicity[0] = 0.;
 295             fBinLimitsArrayMultiplicity[1] = 5.;
 296             fBinLimitsArrayMultiplicity[2] = 7.;
 297             fBinLimitsArrayMultiplicity[3] = 11.;
 298             fBinLimitsArrayMultiplicity[4] = 100.;
 299          }
 300          else if(centMin == 60 && centMax == 80){
 301             fBinLimitsArrayMultiplicity[0] = 0.;
 302             fBinLimitsArrayMultiplicity[1] = 2.;
 303             fBinLimitsArrayMultiplicity[2] = 3.;
 304             fBinLimitsArrayMultiplicity[3] = 5.;
 305             fBinLimitsArrayMultiplicity[4] = 100.;
 306          }
 307          else{ // Std 20-40
 308             fBinLimitsArrayMultiplicity[0] = 0.;
 309             fBinLimitsArrayMultiplicity[1] = 11.;
 310             fBinLimitsArrayMultiplicity[2] = 14.;
 311             fBinLimitsArrayMultiplicity[3] = 18.;
 312             fBinLimitsArrayMultiplicity[4] = 100.;
 313          }
 314       }
 315    }
 316
 317    Initialize(fBinLimitsArrayZ,fBinLimitsArrayMultiplicity);
 318
 319 }
 320
 321 AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(const AliGammaConversionAODBGHandler & original) :
 322   TObject(original),
 323   fNEvents(original.fNEvents),
 324   fBGEventCounter(original.fBGEventCounter),
 325   fBGEventENegCounter(original.fBGEventENegCounter),
 326   fBGProbability(original.fBGProbability),
 327   fBGEventVertex(original.fBGEventVertex),
 328   fNBinsZ(original.fNBinsZ),
 329   fNBinsMultiplicity(original.fNBinsMultiplicity),
 330   fBinLimitsArrayZ(original.fBinLimitsArrayZ),
 331   fBinLimitsArrayMultiplicity(original.fBinLimitsArrayMultiplicity),
 332   fBGEvents(original.fBGEvents),
 333   fBGEventsENeg(original.fBGEventsENeg)
 334 {
 335   //copy constructor
 336 }
 337
 338 AliGammaConversionAODBGHandler & AliGammaConversionAODBGHandler::operator = (const AliGammaConversionAODBGHandler & /*source*/)
 339 {
 340   // assignment operator
 341   return *this;
 342 }
 343
 344 AliGammaConversionAODBGHandler::~AliGammaConversionAODBGHandler(){
 345
 346   //Kenneth remember to clear memory!!!!!!!!!!!!!!!!!!!!!
 347   if(fBGEventCounter){
 348     for(Int_t z=0;z<fNBinsZ;z++){
 349       delete[] fBGEventCounter[z];
 350     }
 351     delete[] fBGEventCounter;
 352     fBGEventCounter = NULL;
 353   }
 354
 355   if(fBGEventVertex){
 356     for(Int_t z=0;z<fNBinsZ;z++){
 357       for(Int_t m=0;m<fNBinsMultiplicity;m++){
 358         delete [] fBGEventVertex[z][m];
 359       }
 360       delete [] fBGEventVertex[z];
 361     }
 362     delete [] fBGEventVertex;
 363   }
 364
 365    if(fBGEventENegCounter){
 366     for(Int_t z=0;z<fNBinsZ;z++){
 367       delete[] fBGEventENegCounter[z];
 368     }
 369     delete[] fBGEventENegCounter;
 370     fBGEventENegCounter = NULL;
 371   }
 372
 373   if(fBinLimitsArrayZ){
 374     delete[] fBinLimitsArrayZ;
 375   }
 376
 377   if(fBinLimitsArrayMultiplicity){
 378     delete[] fBinLimitsArrayMultiplicity;
 379   }
 380 }
 381
 382 void AliGammaConversionAODBGHandler::Initialize(Double_t * const zBinLimitsArray, Double_t * const multiplicityBinLimitsArray){
 383   // see header file for documantation
 384
 385   if(zBinLimitsArray){
 386     fBinLimitsArrayZ = zBinLimitsArray;
 387   }
 388   else{
 389     //Print warning
 390   }
 391
 392   if(multiplicityBinLimitsArray){
 393     fBinLimitsArrayMultiplicity = multiplicityBinLimitsArray ;
 394   }
 395   else{
 396     //Print warning
 397   }
 398   if(fBGEventCounter == NULL){
 399     fBGEventCounter= new Int_t*[fNBinsZ];
 400   }
 401   for(Int_t z=0;z<fNBinsZ;z++){
 402     fBGEventCounter[z]=new Int_t[fNBinsMultiplicity];
 403   }
 404
 405   for(Int_t z=0;z<fNBinsZ;z++){
 406     for(Int_t m=0;m<fNBinsMultiplicity;m++){
 407       fBGEventCounter[z][m]=0;
 408     }
 409   }
 410
 411   if(fBGEventVertex == NULL){
 412     fBGEventVertex = new GammaConversionVertex**[fNBinsZ];
 413   }
 414   for(Int_t z=0; z < fNBinsZ; z++){
 415     fBGEventVertex[z]= new GammaConversionVertex*[fNBinsMultiplicity];
 416   }
 417   for(Int_t z=0;z<fNBinsZ;z++){
 418     for(Int_t m=0;m<fNBinsMultiplicity; m++){
 419       fBGEventVertex[z][m]= new GammaConversionVertex[fNEvents];
 420     }
 421   }
 422   if( fBGEventENegCounter == NULL){
 423     fBGEventENegCounter = new Int_t*[fNBinsZ];
 424   }
 425
 426   for(Int_t z=0; z < fNBinsZ; z++){
 427     fBGEventENegCounter[z] = new Int_t[fNBinsMultiplicity];
 428   }
 429
 430   for(Int_t z=0;z<fNBinsZ;z++){
 431     for(Int_t m=0;m<fNBinsMultiplicity; m++){
 432       fBGEventENegCounter[z][m] = 0;
 433     }
 434   }
 435
 436   if(fBGProbability == NULL){
 437     fBGProbability = new Double_t*[fNBinsZ];
 438   }
 439   for(Int_t z=0; z < fNBinsZ; z++){
 440     fBGProbability[z] = new Double_t[fNBinsMultiplicity];
 441   }
 442
 443   for(Int_t z=0;z<fNBinsZ;z++){
 444     for(Int_t m=0;m<fNBinsMultiplicity; m++){
 445       fBGProbability[z][m] = 0;
 446     }
 447   }
 448   //filling the probability
 449   fBGProbability[0][0] = 0.243594;
 450   fBGProbability[0][1] = 0.279477;
 451   fBGProbability[0][2] = 0.305104;
 452   fBGProbability[0][3] = 0.315927;
 453   fBGProbability[1][0] = 0.241964;
 454   fBGProbability[1][1] = 0.272995;
 455   fBGProbability[1][2] = 0.307165;
 456   fBGProbability[1][3] = 0.292248;
 457   fBGProbability[2][0] = 0.241059;
 458   fBGProbability[2][1] = 0.27509;
 459   fBGProbability[2][2] = 0.283657;
 460   fBGProbability[2][3] = 0.310512;
 461   fBGProbability[3][0] = 0.23888;
 462   fBGProbability[3][1] = 0.283418;
 463   fBGProbability[3][2] = 0.297232;
 464   fBGProbability[3][3] = 0.348188;
 465   fBGProbability[4][0] = 0.245555;
 466   fBGProbability[4][1] = 0.281218;
 467   fBGProbability[4][2] = 0.317236;
 468   fBGProbability[4][3] = 0.323495;
 469   fBGProbability[5][0] = 0.244572;
 470   fBGProbability[5][1] = 0.259498;
 471   fBGProbability[5][2] = 0.278383;
 472   fBGProbability[5][3] = 0.284696;
 473   fBGProbability[6][0] = 0.24703;
 474   fBGProbability[6][1] = 0.275265;
 475   fBGProbability[6][2] = 0.284004;
 476   fBGProbability[6][3] = 0.343584;
 477
 478 }
 479
 480 Int_t AliGammaConversionAODBGHandler::GetZBinIndex(Double_t zvalue) const{
 481   // see header file for documantation
 482   if(fNBinsZ<2 || zvalue<=fBinLimitsArrayZ[0]){
 483      return 0;
 484   }
 485
 486   for(Int_t i=0; i<fNBinsZ-1 ;i++){
 487     if(zvalue >= fBinLimitsArrayZ[i] && zvalue <= fBinLimitsArrayZ[i+1]){
 488       return i;
 489     }
 490   }
 491   return fNBinsZ-1;
 492 }
 493
 494 Int_t AliGammaConversionAODBGHandler::GetMultiplicityBinIndex(Int_t multiplicity) const{
 495   // see header file for documantation
 496   if(fNBinsMultiplicity<2){
 497     return 0;
 498   }
 499
 500   for(Int_t i=0; i<fNBinsMultiplicity-1 ;i++){
 501     if(multiplicity >= fBinLimitsArrayMultiplicity[i] && multiplicity < fBinLimitsArrayMultiplicity[i+1]){
 502       return i;
 503     }
 504   }
 505   return fNBinsMultiplicity-1;
 506 }
 507
 508 void AliGammaConversionAODBGHandler::AddEvent(TList* const eventGammas,Double_t xvalue, Double_t yvalue, Double_t zvalue, Int_t multiplicity, Double_t epvalue){
 509
 510   // see header file for documantation
 511
 512   //  cout<<"Entering the AddEvent function"<<endl;
 513
 514   Int_t z = GetZBinIndex(zvalue);
 515   Int_t m = GetMultiplicityBinIndex(multiplicity);
 516
 517   if(fBGEventCounter[z][m] >= fNEvents){
 518     fBGEventCounter[z][m]=0;
 519   }
 520   Int_t eventCounter=fBGEventCounter[z][m];
 521
 522   /*
 523   if(fBGEventVertex[z][m][eventCounter]){
 524     delete fBGEventVertex[z][m][eventCounter];
 525   }
 526   */
 527   fBGEventVertex[z][m][eventCounter].fX = xvalue;
 528   fBGEventVertex[z][m][eventCounter].fY = yvalue;
 529   fBGEventVertex[z][m][eventCounter].fZ = zvalue;
 530   fBGEventVertex[z][m][eventCounter].fEP = epvalue;
 531
 532   //first clear the vector
 533   // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl;
 534   //  cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl;
 535
 536   //  cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl;
 537   for(UInt_t d=0;d<fBGEvents[z][m][eventCounter].size();d++){
 538     delete (AliAODConversionPhoton*)(fBGEvents[z][m][eventCounter][d]);
 539   }
 540   fBGEvents[z][m][eventCounter].clear();
 541
 542   // add the gammas to the vector
 543   for(Int_t i=0; i< eventGammas->GetEntries();i++){
 544     //    AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i)));
 545     fBGEvents[z][m][eventCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventGammas->At(i))));
 546   }
 547   fBGEventCounter[z][m]++;
 548 }
 549 void AliGammaConversionAODBGHandler::AddElectronEvent(TClonesArray* const eventENeg, Double_t zvalue, Int_t multiplicity){
 550
 551   Int_t z = GetZBinIndex(zvalue);
 552   Int_t m = GetMultiplicityBinIndex(multiplicity);
 553
 554   if(fBGEventENegCounter[z][m] >= fNEvents){
 555      fBGEventENegCounter[z][m]=0;
 556   }
 557
 558
 559    Int_t eventENegCounter=fBGEventENegCounter[z][m];
 560
 561   //first clear the vector
 562   // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl;
 563   //  cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl;
 564
 565   //  cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl;
 566   for(UInt_t d=0;d<fBGEventsENeg[z][m][eventENegCounter].size();d++){
 567     delete (AliAODConversionPhoton*)(fBGEventsENeg[z][m][eventENegCounter][d]);
 568   }
 569
 570   fBGEventsENeg[z][m][eventENegCounter].clear();
 571
 572   // add the electron to the vector
 573   for(Int_t i=0; i< eventENeg->GetEntriesFast();i++){
 574     //    AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i)));
 575     fBGEventsENeg[z][m][eventENegCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventENeg->At(i))));
 576   }
 577
 578   fBGEventENegCounter[z][m]++;
 579
 580
 581 }
 582 AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodV0s(Int_t zbin, Int_t mbin, Int_t event){
 583   //see headerfile for documentation
 584   return &(fBGEvents[zbin][mbin][event]);
 585 }
 586 AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodENeg(Int_t event, Double_t zvalue, Int_t multiplicity){
 587
 588
 589   //see headerfile for documentation
 590   Int_t z = GetZBinIndex(zvalue);
 591   Int_t m = GetMultiplicityBinIndex(multiplicity);
 592   return &(fBGEventsENeg[z][m][event]);
 593
 594
 595 }
 596 void AliGammaConversionAODBGHandler::PrintBGArray(){
 597   //see headerfile for documentation
 598   for(Int_t z=0;z<fNBinsZ;z++){
 599     if(z==2){
 600       cout<<"Getting the data for z bin: "<<z<<endl;
 601       for(Int_t multiplicity=0;multiplicity<fNBinsMultiplicity;multiplicity++){
 602         if(multiplicity==2){
 603           cout<<"Getting the data for multiplicity bin: "<<multiplicity<<endl;
 604           for(Int_t event=0;event<fNEvents;event++){
 605             if(fBGEvents[z][multiplicity][event].size()>0){
 606               cout<<"Event: "<<event<<" has: "<<fBGEvents[z][multiplicity][event].size()<<endl;
 607             }
 608           }
 609         }
 610       }
 611     }
 612   }
 613 }