[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliGammaConversionAODBGHandler.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: Ana Marin, Kathrin Koch, Kenneth Aamodt                        *
 * Version 1.0                                                            *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

////////////////////////////////////////////////
//--------------------------------------------- 
// Class for handling of background calculation
//---------------------------------------------
////////////////////////////////////////////////

#include "AliGammaConversionAODBGHandler.h"
#include "AliKFParticle.h"
#include "AliAODConversionPhoton.h"
#include "AliAODConversionMother.h"

using namespace std;

ClassImp(AliGammaConversionAODBGHandler)

AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler() :
  TObject(),
  fNEvents(10),
  fBGEventCounter(NULL),
  fBGEventENegCounter(NULL),
  fBGProbability(NULL),
  fBGEventVertex(NULL),
  fNBinsZ(0),
  fNBinsMultiplicity(0),
  fBinLimitsArrayZ(NULL),
  fBinLimitsArrayMultiplicity(NULL),
  fBGEvents(),
  fBGEventsENeg()
{
  // constructor
}

AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t binsZ,UInt_t binsMultiplicity,UInt_t nEvents) :
  TObject(),
  fNEvents(nEvents),
  fBGEventCounter(NULL),
  fBGEventENegCounter(NULL),
  fBGProbability(NULL),
  fBGEventVertex(NULL),
  fNBinsZ(binsZ),
  fNBinsMultiplicity(binsMultiplicity),
  fBinLimitsArrayZ(NULL),
  fBinLimitsArrayMultiplicity(NULL),
  fBGEvents(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
  fBGEventsENeg(binsZ,AliGammaConversionMultipicityVector(binsMultiplicity,AliGammaConversionBGEventVector(nEvents)))
{
  // constructor
}


AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(UInt_t collisionSystem,UInt_t centMin,UInt_t centMax,UInt_t nEvents, Bool_t useTrackMult) :
  TObject(),
  fNEvents(nEvents),
  fBGEventCounter(NULL),
  fBGEventENegCounter(NULL),
  fBGProbability(NULL),
  fBGEventVertex(NULL),
  fNBinsZ(8),
  fNBinsMultiplicity(5),
  fBinLimitsArrayZ(NULL),
  fBinLimitsArrayMultiplicity(NULL),
  fBGEvents(fNBinsZ,AliGammaConversionMultipicityVector(fNBinsMultiplicity,AliGammaConversionBGEventVector(nEvents))),
  fBGEventsENeg(fNBinsZ,AliGammaConversionMultipicityVector(fNBinsMultiplicity,AliGammaConversionBGEventVector(nEvents)))
{
  // constructor
   
   fBinLimitsArrayZ= new Double_t[8] ;
   if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
      fBinLimitsArrayZ[0] = -50.00;
      fBinLimitsArrayZ[1] = -5.5;
      fBinLimitsArrayZ[2] = -2.9;
      fBinLimitsArrayZ[3] = -0.65;
      fBinLimitsArrayZ[4] = 1.45;
      fBinLimitsArrayZ[5] = 3.65;
      fBinLimitsArrayZ[6] = 6.15;
      fBinLimitsArrayZ[7] = 50;
   }
   else if(collisionSystem == 0){
      fBinLimitsArrayZ[0] = -50.00;
      fBinLimitsArrayZ[1] = -3.375;
      fBinLimitsArrayZ[2] = -1.605;
      fBinLimitsArrayZ[3] = -0.225;
      fBinLimitsArrayZ[4] = 1.065;
      fBinLimitsArrayZ[5] = 2.445;
      fBinLimitsArrayZ[6] = 4.245;
      fBinLimitsArrayZ[7] = 50.00;
   }
   else{ 
      fBinLimitsArrayZ[0] = -50.00;
      fBinLimitsArrayZ[1] = -5.85;
      fBinLimitsArrayZ[2] = -3.35;
      fBinLimitsArrayZ[3] = -1.15;
      fBinLimitsArrayZ[4] = 0.85;
      fBinLimitsArrayZ[5] = 2.95;
      fBinLimitsArrayZ[6] = 5.55;
      fBinLimitsArrayZ[7] = 50.00;
   }


   fBinLimitsArrayMultiplicity= new Double_t[5];
   if(useTrackMult){ // pp
      fBinLimitsArrayMultiplicity[0] = 0;
      fBinLimitsArrayMultiplicity[1] = 8.5;
      fBinLimitsArrayMultiplicity[2] = 16.5;
      fBinLimitsArrayMultiplicity[3] = 27.5;
      fBinLimitsArrayMultiplicity[4] = 200.;
      if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
         if(centMin == 0 && centMax == 5){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 1540.;
            fBinLimitsArrayMultiplicity[2] = 1665.;
            fBinLimitsArrayMultiplicity[3] = 1780.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else if(centMin == 0 && centMax == 10){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 1360.;
            fBinLimitsArrayMultiplicity[2] = 1520.;
            fBinLimitsArrayMultiplicity[3] = 1685.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else if(centMin == 0 && centMax == 20){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 1110.;
            fBinLimitsArrayMultiplicity[2] = 1360.;
            fBinLimitsArrayMultiplicity[3] = 1600.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else if(centMin == 0 && centMax == 80){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 890.;
            fBinLimitsArrayMultiplicity[2] = 1240.;
            fBinLimitsArrayMultiplicity[3] = 1540.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else if(centMin == 5 && centMax == 10){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 1250.;
            fBinLimitsArrayMultiplicity[2] = 1345.;
            fBinLimitsArrayMultiplicity[3] = 1445.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else if(centMin == 10 && centMax == 20){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 915.;
            fBinLimitsArrayMultiplicity[2] = 1020.;
            fBinLimitsArrayMultiplicity[3] = 1130.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else if(centMin == 20 && centMax == 40){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 510.;
            fBinLimitsArrayMultiplicity[2] = 625.;
            fBinLimitsArrayMultiplicity[3] = 730.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else if(centMin == 40 && centMax == 80){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 185.;
            fBinLimitsArrayMultiplicity[2] = 250.;
            fBinLimitsArrayMultiplicity[3] = 300.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else if(centMin == 60 && centMax == 80){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 55.;
            fBinLimitsArrayMultiplicity[2] = 80.;
            fBinLimitsArrayMultiplicity[3] = 100.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
         else{ // Std 20-40
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 510.;
            fBinLimitsArrayMultiplicity[2] = 625.;
            fBinLimitsArrayMultiplicity[3] = 730.;
            fBinLimitsArrayMultiplicity[4] = 5000.;
         }
      }

      else if(collisionSystem == 8 || collisionSystem == 9){ //pPb

         fBinLimitsArrayMultiplicity[0] = 0.;
         fBinLimitsArrayMultiplicity[1] = 7.5;
         fBinLimitsArrayMultiplicity[2] = 16.5;
         fBinLimitsArrayMultiplicity[3] = 29.5;
         fBinLimitsArrayMultiplicity[4] = 500.;	
         
         if(centMin == 0 && centMax == 20){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 31.5;
            fBinLimitsArrayMultiplicity[2] = 40.5;
            fBinLimitsArrayMultiplicity[3] = 50.5;
            fBinLimitsArrayMultiplicity[4] = 500.;
         } else if(centMin == 20 && centMax == 40){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 19.5;
            fBinLimitsArrayMultiplicity[2] = 25.5;
            fBinLimitsArrayMultiplicity[3] = 32.5;
            fBinLimitsArrayMultiplicity[4] = 500.;
         } else if(centMin == 40 && centMax == 60){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 12.5;
            fBinLimitsArrayMultiplicity[2] = 16.5;
            fBinLimitsArrayMultiplicity[3] = 22.5;
            fBinLimitsArrayMultiplicity[4] = 500.;
         } else if(centMin == 60 && centMax == 80){ 
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 5.5;
            fBinLimitsArrayMultiplicity[2] = 9.5;
            fBinLimitsArrayMultiplicity[3] = 13.5;
            fBinLimitsArrayMultiplicity[4] = 500.;
          } else if(centMin == 60 && centMax == 100){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 2.5;
            fBinLimitsArrayMultiplicity[2] = 6.5;
            fBinLimitsArrayMultiplicity[3] = 11.5;
            fBinLimitsArrayMultiplicity[4] = 500.;
          }  
      }
   }
   else{// pp or pPb V0 Mult
      fBinLimitsArrayMultiplicity[0] = 2;
      fBinLimitsArrayMultiplicity[1] = 3;
      fBinLimitsArrayMultiplicity[2] = 4;
      fBinLimitsArrayMultiplicity[3] = 5;
      fBinLimitsArrayMultiplicity[4] = 9999;
      if(collisionSystem > 0 && collisionSystem < 8){ // PbPb
         if(centMin == 0 && centMax == 5){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 27.;
            fBinLimitsArrayMultiplicity[2] = 31.;
            fBinLimitsArrayMultiplicity[3] = 36.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else if(centMin == 0 && centMax == 10){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 25.;
            fBinLimitsArrayMultiplicity[2] = 30.;
            fBinLimitsArrayMultiplicity[3] = 36.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else if(centMin == 0 && centMax == 20){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 22.;
            fBinLimitsArrayMultiplicity[2] = 27.;
            fBinLimitsArrayMultiplicity[3] = 33.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else if(centMin == 0 && centMax == 80){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 18.;
            fBinLimitsArrayMultiplicity[2] = 25.;
            fBinLimitsArrayMultiplicity[3] = 32.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else if(centMin == 5 && centMax == 10){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 23.;
            fBinLimitsArrayMultiplicity[2] = 27.;
            fBinLimitsArrayMultiplicity[3] = 32.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else if(centMin == 10 && centMax == 20){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 18.;
            fBinLimitsArrayMultiplicity[2] = 22.;
            fBinLimitsArrayMultiplicity[3] = 27.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else if(centMin == 20 && centMax == 40){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 11.;
            fBinLimitsArrayMultiplicity[2] = 14.;
            fBinLimitsArrayMultiplicity[3] = 18.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else if(centMin == 40 && centMax == 80){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 5.;
            fBinLimitsArrayMultiplicity[2] = 7.;
            fBinLimitsArrayMultiplicity[3] = 11.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else if(centMin == 60 && centMax == 80){
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 2.;
            fBinLimitsArrayMultiplicity[2] = 3.;
            fBinLimitsArrayMultiplicity[3] = 5.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
         else{ // Std 20-40
            fBinLimitsArrayMultiplicity[0] = 0.;
            fBinLimitsArrayMultiplicity[1] = 11.;
            fBinLimitsArrayMultiplicity[2] = 14.;
            fBinLimitsArrayMultiplicity[3] = 18.;
            fBinLimitsArrayMultiplicity[4] = 100.;
         }
      }
   }
   
   Initialize(fBinLimitsArrayZ,fBinLimitsArrayMultiplicity);

}

AliGammaConversionAODBGHandler::AliGammaConversionAODBGHandler(const AliGammaConversionAODBGHandler & original) :
  TObject(original),
  fNEvents(original.fNEvents),
  fBGEventCounter(original.fBGEventCounter),
  fBGEventENegCounter(original.fBGEventENegCounter),
  fBGProbability(original.fBGProbability),
  fBGEventVertex(original.fBGEventVertex),
  fNBinsZ(original.fNBinsZ),
  fNBinsMultiplicity(original.fNBinsMultiplicity),
  fBinLimitsArrayZ(original.fBinLimitsArrayZ),
  fBinLimitsArrayMultiplicity(original.fBinLimitsArrayMultiplicity),
  fBGEvents(original.fBGEvents),
  fBGEventsENeg(original.fBGEventsENeg)
{
  //copy constructor	
}

AliGammaConversionAODBGHandler & AliGammaConversionAODBGHandler::operator = (const AliGammaConversionAODBGHandler & /*source*/)
{
  // assignment operator
  return *this;
}

AliGammaConversionAODBGHandler::~AliGammaConversionAODBGHandler(){

  //Kenneth remember to clear memory!!!!!!!!!!!!!!!!!!!!!
  if(fBGEventCounter){
    for(Int_t z=0;z<fNBinsZ;z++){
      delete[] fBGEventCounter[z];
    }
    delete[] fBGEventCounter;
    fBGEventCounter = NULL;
  }

  if(fBGEventVertex){
    for(Int_t z=0;z<fNBinsZ;z++){
      for(Int_t m=0;m<fNBinsMultiplicity;m++){
	delete [] fBGEventVertex[z][m];
      }
      delete [] fBGEventVertex[z];
    }
    delete [] fBGEventVertex;
  }

   if(fBGEventENegCounter){
    for(Int_t z=0;z<fNBinsZ;z++){
      delete[] fBGEventENegCounter[z];
    }
    delete[] fBGEventENegCounter;
    fBGEventENegCounter = NULL;
  }

  if(fBinLimitsArrayZ){
    delete[] fBinLimitsArrayZ;
  }

  if(fBinLimitsArrayMultiplicity){
    delete[] fBinLimitsArrayMultiplicity;
  }
}

void AliGammaConversionAODBGHandler::Initialize(Double_t * const zBinLimitsArray, Double_t * const multiplicityBinLimitsArray){
  // see header file for documantation  

  if(zBinLimitsArray){
    fBinLimitsArrayZ = zBinLimitsArray;
  }
  else{
    //Print warning
  }
  
  if(multiplicityBinLimitsArray){
    fBinLimitsArrayMultiplicity = multiplicityBinLimitsArray ;
  }
  else{
    //Print warning
  }
  if(fBGEventCounter == NULL){
    fBGEventCounter= new Int_t*[fNBinsZ];
  }
  for(Int_t z=0;z<fNBinsZ;z++){
    fBGEventCounter[z]=new Int_t[fNBinsMultiplicity];
  }

  for(Int_t z=0;z<fNBinsZ;z++){
    for(Int_t m=0;m<fNBinsMultiplicity;m++){
      fBGEventCounter[z][m]=0;
    }
  }

  if(fBGEventVertex == NULL){
    fBGEventVertex = new GammaConversionVertex**[fNBinsZ];
  }
  for(Int_t z=0; z < fNBinsZ; z++){
    fBGEventVertex[z]= new GammaConversionVertex*[fNBinsMultiplicity];
  }
  for(Int_t z=0;z<fNBinsZ;z++){
    for(Int_t m=0;m<fNBinsMultiplicity; m++){
      fBGEventVertex[z][m]= new GammaConversionVertex[fNEvents];
    }
  }
  if( fBGEventENegCounter == NULL){
    fBGEventENegCounter = new Int_t*[fNBinsZ];
  }

  for(Int_t z=0; z < fNBinsZ; z++){
    fBGEventENegCounter[z] = new Int_t[fNBinsMultiplicity];
  }

  for(Int_t z=0;z<fNBinsZ;z++){
    for(Int_t m=0;m<fNBinsMultiplicity; m++){
      fBGEventENegCounter[z][m] = 0;
    }
  }

  if(fBGProbability == NULL){
    fBGProbability = new Double_t*[fNBinsZ];
  }
  for(Int_t z=0; z < fNBinsZ; z++){
    fBGProbability[z] = new Double_t[fNBinsMultiplicity];
  }

  for(Int_t z=0;z<fNBinsZ;z++){
    for(Int_t m=0;m<fNBinsMultiplicity; m++){
      fBGProbability[z][m] = 0;
    }
  }
  //filling the probability
  fBGProbability[0][0] = 0.243594;
  fBGProbability[0][1] = 0.279477;
  fBGProbability[0][2] = 0.305104;
  fBGProbability[0][3] = 0.315927;
  fBGProbability[1][0] = 0.241964;
  fBGProbability[1][1] = 0.272995;
  fBGProbability[1][2] = 0.307165;
  fBGProbability[1][3] = 0.292248;
  fBGProbability[2][0] = 0.241059;
  fBGProbability[2][1] = 0.27509;
  fBGProbability[2][2] = 0.283657;
  fBGProbability[2][3] = 0.310512;
  fBGProbability[3][0] = 0.23888;
  fBGProbability[3][1] = 0.283418;
  fBGProbability[3][2] = 0.297232;
  fBGProbability[3][3] = 0.348188;
  fBGProbability[4][0] = 0.245555;
  fBGProbability[4][1] = 0.281218;
  fBGProbability[4][2] = 0.317236;
  fBGProbability[4][3] = 0.323495;
  fBGProbability[5][0] = 0.244572;
  fBGProbability[5][1] = 0.259498;
  fBGProbability[5][2] = 0.278383;
  fBGProbability[5][3] = 0.284696;
  fBGProbability[6][0] = 0.24703;
  fBGProbability[6][1] = 0.275265;
  fBGProbability[6][2] = 0.284004;
  fBGProbability[6][3] = 0.343584;
 
}

Int_t AliGammaConversionAODBGHandler::GetZBinIndex(Double_t zvalue) const{
  // see header file for documantation
  if(fNBinsZ<2 || zvalue<=fBinLimitsArrayZ[0]){
     return 0;
  }

  for(Int_t i=0; i<fNBinsZ-1 ;i++){
    if(zvalue >= fBinLimitsArrayZ[i] && zvalue <= fBinLimitsArrayZ[i+1]){
      return i;
    }
  }
  return fNBinsZ-1;
}

Int_t AliGammaConversionAODBGHandler::GetMultiplicityBinIndex(Int_t multiplicity) const{
  // see header file for documantation  
  if(fNBinsMultiplicity<2){
    return 0;
  }

  for(Int_t i=0; i<fNBinsMultiplicity-1 ;i++){
    if(multiplicity >= fBinLimitsArrayMultiplicity[i] && multiplicity < fBinLimitsArrayMultiplicity[i+1]){
      return i;
    }
  }
  return fNBinsMultiplicity-1;
}

void AliGammaConversionAODBGHandler::AddEvent(TList* const eventGammas,Double_t xvalue, Double_t yvalue, Double_t zvalue, Int_t multiplicity, Double_t epvalue){

  // see header file for documantation  

  //  cout<<"Entering the AddEvent function"<<endl;

  Int_t z = GetZBinIndex(zvalue);
  Int_t m = GetMultiplicityBinIndex(multiplicity);

  if(fBGEventCounter[z][m] >= fNEvents){
    fBGEventCounter[z][m]=0;
  }
  Int_t eventCounter=fBGEventCounter[z][m];
  
  /*
  if(fBGEventVertex[z][m][eventCounter]){
    delete fBGEventVertex[z][m][eventCounter];
  }
  */
  fBGEventVertex[z][m][eventCounter].fX = xvalue;
  fBGEventVertex[z][m][eventCounter].fY = yvalue;
  fBGEventVertex[z][m][eventCounter].fZ = zvalue;
  fBGEventVertex[z][m][eventCounter].fEP = epvalue;

  //first clear the vector
  // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl;
  //  cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl;

  //  cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl;
  for(UInt_t d=0;d<fBGEvents[z][m][eventCounter].size();d++){
    delete (AliAODConversionPhoton*)(fBGEvents[z][m][eventCounter][d]);
  }
  fBGEvents[z][m][eventCounter].clear();
  
  // add the gammas to the vector
  for(Int_t i=0; i< eventGammas->GetEntries();i++){
    //    AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i)));
    fBGEvents[z][m][eventCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventGammas->At(i))));
  }
  fBGEventCounter[z][m]++;
}
void AliGammaConversionAODBGHandler::AddElectronEvent(TClonesArray* const eventENeg, Double_t zvalue, Int_t multiplicity){

  Int_t z = GetZBinIndex(zvalue);
  Int_t m = GetMultiplicityBinIndex(multiplicity);

  if(fBGEventENegCounter[z][m] >= fNEvents){
     fBGEventENegCounter[z][m]=0;
  }
 

   Int_t eventENegCounter=fBGEventENegCounter[z][m];
  
  //first clear the vector
  // cout<<"Size of vector: "<<fBGEvents[z][m][eventCounter].size()<<endl;
  //  cout<<"Checking the entries: Z="<<z<<", M="<<m<<", eventCounter="<<eventCounter<<endl;

  //  cout<<"The size of this vector is: "<<fBGEvents[z][m][eventCounter].size()<<endl;
  for(UInt_t d=0;d<fBGEventsENeg[z][m][eventENegCounter].size();d++){
    delete (AliAODConversionPhoton*)(fBGEventsENeg[z][m][eventENegCounter][d]);
  }

  fBGEventsENeg[z][m][eventENegCounter].clear();

  // add the electron to the vector
  for(Int_t i=0; i< eventENeg->GetEntriesFast();i++){
    //    AliKFParticle *t = new AliKFParticle(*(AliKFParticle*)(eventGammas->At(i)));
    fBGEventsENeg[z][m][eventENegCounter].push_back(new AliAODConversionPhoton(*(AliAODConversionPhoton*)(eventENeg->At(i))));
  }

  fBGEventENegCounter[z][m]++;


}
AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodV0s(Int_t zbin, Int_t mbin, Int_t event){
  //see headerfile for documentation
  return &(fBGEvents[zbin][mbin][event]);
}
AliGammaConversionAODVector* AliGammaConversionAODBGHandler::GetBGGoodENeg(Int_t event, Double_t zvalue, Int_t multiplicity){


  //see headerfile for documentation
  Int_t z = GetZBinIndex(zvalue);
  Int_t m = GetMultiplicityBinIndex(multiplicity);
  return &(fBGEventsENeg[z][m][event]);


}
void AliGammaConversionAODBGHandler::PrintBGArray(){
  //see headerfile for documentation
  for(Int_t z=0;z<fNBinsZ;z++){
    if(z==2){
      cout<<"Getting the data for z bin: "<<z<<endl;
      for(Int_t multiplicity=0;multiplicity<fNBinsMultiplicity;multiplicity++){
	if(multiplicity==2){
	  cout<<"Getting the data for multiplicity bin: "<<multiplicity<<endl;	
	  for(Int_t event=0;event<fNEvents;event++){
	    if(fBGEvents[z][multiplicity][event].size()>0){
	      cout<<"Event: "<<event<<" has: "<<fBGEvents[z][multiplicity][event].size()<<endl;
	    }
	  }
	}
      }
    }
  }
}
Commit	Line	Data
2bb2434e	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"
2bb2434e	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
11c1e680	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
ae4f2cfb	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	}
11c1e680	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
2bb2434e	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
ae4f2cfb	508	void AliGammaConversionAODBGHandler::AddEvent(TList* const eventGammas,Double_t xvalue, Double_t yvalue, Double_t zvalue, Int_t multiplicity, Double_t epvalue){
ae4f2cfb	509
2bb2434e	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;
ae4f2cfb	530	fBGEventVertex[z][m][eventCounter].fEP = epvalue;
2bb2434e	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	}