PWGGA/GammaConv/AliGammaConversionAODBGHandler.cxx

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