IsHeavyIon flag, added Centrality Selection, Add mising Cut for Nch, extra histograms...

[u/mrichter/AliRoot.git] / PWG4 / GammaConv / AliAnalysisTaskGammaConversion.cxx

diff --git a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx
index 8479c22fd7dcedda61284888138e1dea07680633..c857ac3d964134e23a7a699c422e3f584c7e7eb3 100644 (file)
--- a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx
+++ b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx
@@ -40,6 +40,10 @@
 #include "AliGenDPMjetEventHeader.h"
 #include "AliGenEventHeader.h"
 #include <AliMCEventHandler.h>
+#include "TRandom3.h"
+#include "AliTriggerAnalysis.h"
+#include "AliESDCentrality.h"
+
 class AliESDTrackCuts;
 class AliCFContainer;
 class AliCFManager;
@@ -127,11 +131,19 @@ AliAnalysisTaskSE(),
   fUseTrackMultiplicityForBG(kTRUE),
   fMoveParticleAccordingToVertex(kFALSE),
   fApplyChi2Cut(kFALSE),
-  nRandomEventsForBG(15),
-  nDegreesPMBackground(15),
+  fNRandomEventsForBG(15),
+  fNDegreesPMBackground(15),
   fDoRotation(kTRUE),
   fCheckBGProbability(kTRUE),
-  fKFReconstructedGammasV0Index()
+  fKFReconstructedGammasV0Index(),
+  fRemovePileUp(kFALSE),
+  fSelectV0AND(kFALSE),
+  fTriggerAnalysis(NULL),
+  fMultiplicity(0),
+  fUseMultiplicity(0), 
+  fUseMultiplicityBin(0),
+  fUseCentrality(0), 
+  fUseCentralityBin(0)
 {
   // Default constructor
 
@@ -215,11 +227,19 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(const char* name)
   fUseTrackMultiplicityForBG(kTRUE),
   fMoveParticleAccordingToVertex(kFALSE),
   fApplyChi2Cut(kFALSE),
-  nRandomEventsForBG(15),
-  nDegreesPMBackground(15),
+  fNRandomEventsForBG(15),
+  fNDegreesPMBackground(15),
   fDoRotation(kTRUE),
   fCheckBGProbability(kTRUE),
-  fKFReconstructedGammasV0Index()
+  fKFReconstructedGammasV0Index(),
+  fRemovePileUp(kFALSE),
+  fSelectV0AND(kFALSE),
+  fTriggerAnalysis(NULL),
+  fMultiplicity(0),
+  fUseMultiplicity(0), 
+  fUseMultiplicityBin(0),
+  fUseCentrality(0), 
+  fUseCentralityBin(0)
 {
   // Common I/O in slot 0
   DefineInput (0, TChain::Class());
@@ -278,6 +298,11 @@ AliAnalysisTaskGammaConversion::~AliAnalysisTaskGammaConversion()
   }
   fAODOmega = NULL;
 
+  if(fTriggerAnalysis) {
+    delete fTriggerAnalysis;
+  }
+
+
 }
 
 
@@ -329,7 +354,8 @@ void AliAnalysisTaskGammaConversion::SetESDtrackCuts()
 
 // Using standard function  for setting Cuts
   Bool_t selectPrimaries=kTRUE;
-  fEsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selectPrimaries);
+  fEsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
+  fEsdTrackCuts->SetMaxDCAToVertexZ(2);
   fEsdTrackCuts->SetEtaRange(-0.8, 0.8);
   fEsdTrackCuts->SetPtRange(0.15);
   
@@ -452,11 +478,14 @@ void AliAnalysisTaskGammaConversion::UserExec(Option_t */*option*/)
     fKFReconstructedPi0sTClone = new TClonesArray("AliKFParticle",0);
   }
  
- if(fKFRecalculatedGammasTClone == NULL){
+  if(fKFRecalculatedGammasTClone == NULL){
     fKFRecalculatedGammasTClone = new TClonesArray("AliKFParticle",0);
   }
 
-       
+  if(fTriggerAnalysis== NULL){
+    fTriggerAnalysis = new AliTriggerAnalysis;
+  }
+
   //clear TClones
   fKFReconstructedGammasTClone->Delete();
   fCurrentEventPosElectronTClone->Delete();
@@ -513,9 +542,66 @@ void AliAnalysisTaskGammaConversion::UserExec(Option_t */*option*/)
     }
     return;
   }
+
+  if(fRemovePileUp && fV0Reader->GetESDEvent()->IsPileupFromSPD()) {
+    eventQuality=4;
+    fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
+    return;
+  }
+
+  Bool_t v0A       = fTriggerAnalysis->IsOfflineTriggerFired(fV0Reader->GetESDEvent(), AliTriggerAnalysis::kV0A);
+  Bool_t v0C       = fTriggerAnalysis->IsOfflineTriggerFired(fV0Reader->GetESDEvent(), AliTriggerAnalysis::kV0C);
+  Bool_t v0AND = v0A && v0C;
+
+  if(fSelectV0AND && !v0AND){
+    eventQuality=5;
+    fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
+    return;
+  }
+  fMultiplicity = fEsdTrackCuts->CountAcceptedTracks(fV0Reader->GetESDEvent());
+
+  if( CalculateMultiplicityBin() != fUseMultiplicityBin){
+    eventQuality=6;
+    fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
+    return;
+  }
+
+  if(fV0Reader->GetIsHeavyIon()){
+    if(fUseCentrality>0){
+      AliESDCentrality *esdCentrality = fV0Reader->GetESDEvent()->GetCentrality();
+      Int_t centralityC = -1;
+
+      if(fUseCentrality==1){
+       centralityC = esdCentrality->GetCentralityClass10("V0M");
+       if( centralityC != fUseCentralityBin ){
+         eventQuality=7;
+         fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
+         return;
+       }
+      }
+
+      if(fUseCentrality==2){
+       centralityC = esdCentrality->GetCentralityClass10("CL1");
+       if( centralityC != fUseCentralityBin ){
+         eventQuality=7;
+         fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
+         return;
+       }
+      }
+    }
+  }
   eventQuality=3;
   fHistograms->FillHistogram("ESD_EventQuality",eventQuality);
 
+
+
+  fHistograms->FillHistogram("ESD_NumberOfGoodESDTracks",fMultiplicity);
+  if (fV0Reader->GetNumberOfContributorsVtx()>=1){
+    fHistograms->FillHistogram("ESD_NumberOfGoodESDTracksVtx",fMultiplicity);
+  } 
+
+
+
   // Process the MC information
   if(fDoMCTruth){
     ProcessMCData();
@@ -585,6 +671,7 @@ void AliAnalysisTaskGammaConversion::UserExec(Option_t */*option*/)
 // }
 
 void AliAnalysisTaskGammaConversion::CheckMesonProcessTypeEventQuality(Int_t evtQ){
+  // Check meson process type event quality
   fStack= MCEvent()->Stack();
   fGCMCEvent=MCEvent();
 
@@ -657,8 +744,8 @@ void AliAnalysisTaskGammaConversion::ProcessMCData(){
   if(fV0Reader->CheckForPrimaryVertex() == kFALSE){
     return; // aborts if the primary vertex does not have contributors.
   }
-
-  for (Int_t iTracks = 0; iTracks < fStack->GetNtrack(); iTracks++) {
+  for (Int_t iTracks = 0; iTracks < fStack->GetNprimary(); iTracks++) {
+    //  for (Int_t iTracks = 0; iTracks < fStack->GetNtrack(); iTracks++) {
     TParticle* particle = (TParticle *)fStack->Particle(iTracks);
 
 
@@ -669,70 +756,70 @@ void AliAnalysisTaskGammaConversion::ProcessMCData(){
     }
                
     ///////////////////////Begin Chic Analysis/////////////////////////////
-               
-    if(particle->GetPdgCode() == 443){//Is JPsi        
-      if(particle->GetNDaughters()==2){
-       if(TMath::Abs(fStack->Particle(particle->GetFirstDaughter())->GetPdgCode()) == 11 &&
-          TMath::Abs(fStack->Particle(particle->GetLastDaughter())->GetPdgCode()) == 11){
-
-         TParticle* daug0 = fStack->Particle(particle->GetFirstDaughter());
-         TParticle* daug1 = fStack->Particle(particle->GetLastDaughter());
-         if(TMath::Abs(daug0->Eta()) < 0.9 && TMath::Abs(daug1->Eta()) < 0.9)
-           fHistograms->FillTable("Table_Electrons",3);//e+ e-  from J/Psi inside acceptance
+    if(fDoChic) {
+      if(particle->GetPdgCode() == 443){//Is JPsi      
+       if(particle->GetNDaughters()==2){
+         if(TMath::Abs(fStack->Particle(particle->GetFirstDaughter())->GetPdgCode()) == 11 &&
+            TMath::Abs(fStack->Particle(particle->GetLastDaughter())->GetPdgCode()) == 11){
+
+           TParticle* daug0 = fStack->Particle(particle->GetFirstDaughter());
+           TParticle* daug1 = fStack->Particle(particle->GetLastDaughter());
+           if(TMath::Abs(daug0->Eta()) < 0.9 && TMath::Abs(daug1->Eta()) < 0.9)
+             fHistograms->FillTable("Table_Electrons",3);//e+ e-  from J/Psi inside acceptance
                                        
-         if( TMath::Abs(daug0->Eta()) < 0.9){
-           if(daug0->GetPdgCode() == -11)
-             fHistograms->FillTable("Table_Electrons",1);//e+  from J/Psi inside acceptance
-           else
-             fHistograms->FillTable("Table_Electrons",2);//e-   from J/Psi inside acceptance
+           if( TMath::Abs(daug0->Eta()) < 0.9){
+             if(daug0->GetPdgCode() == -11)
+               fHistograms->FillTable("Table_Electrons",1);//e+  from J/Psi inside acceptance
+             else
+               fHistograms->FillTable("Table_Electrons",2);//e-   from J/Psi inside acceptance
                                                
-         }
-         if(TMath::Abs(daug1->Eta()) < 0.9){
-           if(daug1->GetPdgCode() == -11)
-             fHistograms->FillTable("Table_Electrons",1);//e+  from J/Psi inside acceptance
-           else
-             fHistograms->FillTable("Table_Electrons",2);//e-   from J/Psi inside acceptance
+           }
+           if(TMath::Abs(daug1->Eta()) < 0.9){
+             if(daug1->GetPdgCode() == -11)
+               fHistograms->FillTable("Table_Electrons",1);//e+  from J/Psi inside acceptance
+             else
+               fHistograms->FillTable("Table_Electrons",2);//e-   from J/Psi inside acceptance
+           }
          }
        }
       }
-    }
-    //              const int CHI_C0   = 10441;
-    //              const int CHI_C1   = 20443;
-    //              const int CHI_C2   = 445
-    if(particle->GetPdgCode() == 22){//gamma from JPsi
-      if(particle->GetMother(0) > -1){
-       if(fStack->Particle(particle->GetMother(0))->GetPdgCode() == 10441 ||
-          fStack->Particle(particle->GetMother(0))->GetPdgCode() == 20443 ||
-          fStack->Particle(particle->GetMother(0))->GetPdgCode() == 445){
-         if(TMath::Abs(particle->Eta()) < 1.2)
-           fHistograms->FillTable("Table_Electrons",17);// gamma from chic inside accptance
+      //              const int CHI_C0   = 10441;
+      //              const int CHI_C1   = 20443;
+      //              const int CHI_C2   = 445
+      if(particle->GetPdgCode() == 22){//gamma from JPsi
+       if(particle->GetMother(0) > -1){
+         if(fStack->Particle(particle->GetMother(0))->GetPdgCode() == 10441 ||
+            fStack->Particle(particle->GetMother(0))->GetPdgCode() == 20443 ||
+            fStack->Particle(particle->GetMother(0))->GetPdgCode() == 445){
+           if(TMath::Abs(particle->Eta()) < 1.2)
+             fHistograms->FillTable("Table_Electrons",17);// gamma from chic inside accptance
+         }
        }
       }
-    }
-    if(particle->GetPdgCode() == 10441 || particle->GetPdgCode() == 20443 || particle->GetPdgCode() == 445){
-      if( particle->GetNDaughters() == 2){
-       TParticle* daug0 = fStack->Particle(particle->GetFirstDaughter());
-       TParticle* daug1 = fStack->Particle(particle->GetLastDaughter());
+      if(particle->GetPdgCode() == 10441 || particle->GetPdgCode() == 20443 || particle->GetPdgCode() == 445){
+       if( particle->GetNDaughters() == 2){
+         TParticle* daug0 = fStack->Particle(particle->GetFirstDaughter());
+         TParticle* daug1 = fStack->Particle(particle->GetLastDaughter());
                                
-       if( (daug0->GetPdgCode() == 443 || daug0->GetPdgCode() == 22) && (daug1->GetPdgCode() == 443 || daug1->GetPdgCode() == 22) ){
-         if( daug0->GetPdgCode() == 443){
-           TParticle* daugE0 = fStack->Particle(daug0->GetFirstDaughter());
-           TParticle* daugE1 = fStack->Particle(daug0->GetLastDaughter());
-           if( TMath::Abs(daug1->Eta()) < 1.2 && TMath::Abs(daugE0->Eta()) < 0.9 && TMath::Abs(daugE1->Eta()) < 0.9 )
-             fHistograms->FillTable("Table_Electrons",18);
+         if( (daug0->GetPdgCode() == 443 || daug0->GetPdgCode() == 22) && (daug1->GetPdgCode() == 443 || daug1->GetPdgCode() == 22) ){
+           if( daug0->GetPdgCode() == 443){
+             TParticle* daugE0 = fStack->Particle(daug0->GetFirstDaughter());
+             TParticle* daugE1 = fStack->Particle(daug0->GetLastDaughter());
+             if( TMath::Abs(daug1->Eta()) < 1.2 && TMath::Abs(daugE0->Eta()) < 0.9 && TMath::Abs(daugE1->Eta()) < 0.9 )
+               fHistograms->FillTable("Table_Electrons",18);
                                                
-         }//if
-         else if (daug1->GetPdgCode() == 443){
-           TParticle* daugE0 = fStack->Particle(daug1->GetFirstDaughter());
-           TParticle* daugE1 = fStack->Particle(daug1->GetLastDaughter());
-           if( TMath::Abs(daug0->Eta()) < 1.2 && TMath::Abs(daugE0->Eta()) < 0.9 && TMath::Abs(daugE1->Eta()) < 0.9 )
-             fHistograms->FillTable("Table_Electrons",18);
-         }//else if
-       }//gamma o Jpsi
-      }//GetNDaughters
+           }//if
+           else if (daug1->GetPdgCode() == 443){
+             TParticle* daugE0 = fStack->Particle(daug1->GetFirstDaughter());
+             TParticle* daugE1 = fStack->Particle(daug1->GetLastDaughter());
+             if( TMath::Abs(daug0->Eta()) < 1.2 && TMath::Abs(daugE0->Eta()) < 0.9 && TMath::Abs(daugE1->Eta()) < 0.9 )
+               fHistograms->FillTable("Table_Electrons",18);
+           }//else if
+         }//gamma o Jpsi
+       }//GetNDaughters
+      }
     }
                
-               
     /////////////////////End Chic Analysis////////////////////////////
                
                
@@ -910,6 +997,8 @@ void AliAnalysisTaskGammaConversion::ProcessMCData(){
       Int_t zBin    = fHistograms->GetZBin(ePos->Vz());
       Int_t phiBin  = fHistograms->GetPhiBin(particle->Phi());
       Double_t rFMD=30;
+      Double_t rITSTPCMin=50;
+      Double_t rITSTPCMax=80;
 
       TVector3 vtxPos(ePos->Vx(),ePos->Vy(),ePos->Vz());       
       
@@ -949,6 +1038,12 @@ void AliAnalysisTaskGammaConversion::ProcessMCData(){
        fHistograms->FillHistogram(nameMCMappingFMDPhiInZ, vtxPos.Phi());
       }
 
+      if(ePos->R()>rITSTPCMin  && ePos->R()<rITSTPCMax){
+       TString nameMCMappingITSTPCPhiInZ="";
+       nameMCMappingITSTPCPhiInZ.Form("MC_Conversion_Mapping_ITSTPC_Phi_in_Z_%02d",zBin);
+       fHistograms->FillHistogram(nameMCMappingITSTPCPhiInZ, vtxPos.Phi());
+      }
+
       TString nameMCMappingRInZ="";
       nameMCMappingRInZ.Form("MC_Conversion_Mapping_R_in_Z_%02d",zBin);
       fHistograms->FillHistogram(nameMCMappingRInZ,ePos->R() );
@@ -1161,7 +1256,7 @@ void AliAnalysisTaskGammaConversion::ProcessMCData(){
              fHistograms->FillHistogram("MC_Pi0_ConvGamma_PtGamma_Pt", particle->Pt(),daughter1->Pt());
 
              Double_t alfa=0.;
-             if((daughter0->Energy()+daughter1->Energy())!= 0.){
+             if((daughter0->Energy()+daughter1->Energy()) > 0.){
                alfa= TMath::Abs((daughter0->Energy()-daughter1->Energy())/(daughter0->Energy()+daughter1->Energy()));
              }
              fHistograms->FillHistogram("MC_Pi0_alpha",alfa);
@@ -1426,8 +1521,8 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){
     fHistograms->FillHistogram("ESD_E_nTPCClusters", fV0Reader->GetNegativeTracknTPCClusters());
     fHistograms->FillHistogram("ESD_E_nITSClusters", fV0Reader->GetNegativeTracknITSClusters());
     if(fV0Reader->GetNegativeTracknTPCFClusters()!=0 && fV0Reader->GetNegativeTracknTPCClusters()!=0 ){
-      Double_t EclsToF= (Double_t)fV0Reader->GetNegativeTracknTPCClusters()/(Double_t)fV0Reader->GetNegativeTracknTPCFClusters();
-      fHistograms->FillHistogram("ESD_E_nTPCClustersToFP", fV0Reader->GetNegativeTrackP(),EclsToF );
+      Double_t eClsToF= (Double_t)fV0Reader->GetNegativeTracknTPCClusters()/(Double_t)fV0Reader->GetNegativeTracknTPCFClusters();
+      fHistograms->FillHistogram("ESD_E_nTPCClustersToFP", fV0Reader->GetNegativeTrackP(),eClsToF );
       fHistograms->FillHistogram("ESD_E_TPCchi2", fV0Reader->GetNegativeTrackTPCchi2()/(Double_t)fV0Reader->GetNegativeTracknTPCClusters());
     }
 
@@ -1440,8 +1535,8 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){
     fHistograms->FillHistogram("ESD_P_nTPCClusters", fV0Reader->GetPositiveTracknTPCClusters());
     fHistograms->FillHistogram("ESD_P_nITSClusters", fV0Reader->GetPositiveTracknITSClusters());
     if(fV0Reader->GetPositiveTracknTPCFClusters()!=0 && (Double_t)fV0Reader->GetPositiveTracknTPCClusters()!=0 ){
-      Double_t PclsToF= (Double_t)fV0Reader->GetPositiveTracknTPCClusters()/(Double_t)fV0Reader->GetPositiveTracknTPCFClusters();
-      fHistograms->FillHistogram("ESD_P_nTPCClustersToFP",fV0Reader->GetPositiveTrackP(), PclsToF);
+      Double_t pClsToF= (Double_t)fV0Reader->GetPositiveTracknTPCClusters()/(Double_t)fV0Reader->GetPositiveTracknTPCFClusters();
+      fHistograms->FillHistogram("ESD_P_nTPCClustersToFP",fV0Reader->GetPositiveTrackP(), pClsToF);
       fHistograms->FillHistogram("ESD_P_TPCchi2", fV0Reader->GetPositiveTrackTPCchi2()/(Double_t)fV0Reader->GetPositiveTracknTPCClusters());
     }
 
@@ -1496,7 +1591,8 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){
     Int_t zBin    = fHistograms->GetZBin(fV0Reader->GetZ());
     Int_t phiBin  = fHistograms->GetPhiBin(fV0Reader->GetNegativeTrackPhi());
     Double_t rFMD=30;
-
+    Double_t rITSTPCMin=50;
+    Double_t rITSTPCMax=80;
 
 
     //    Double_t motherCandidateEta= fV0Reader->GetMotherCandidateEta();
@@ -1533,6 +1629,11 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){
       fHistograms->FillHistogram(nameESDMappingFMDPhiInZ, vtxConv.Phi());
     }
 
+    if(fV0Reader->GetXYRadius()>rITSTPCMin && fV0Reader->GetXYRadius()<rITSTPCMax){
+      TString nameESDMappingITSTPCPhiInZ="";
+      nameESDMappingITSTPCPhiInZ.Form("ESD_Conversion_Mapping_ITSTPC_Phi_in_Z_%02d",zBin);
+      fHistograms->FillHistogram(nameESDMappingITSTPCPhiInZ, vtxConv.Phi());
+    }
 
     TString nameESDMappingRInZ="";
     nameESDMappingRInZ.Form("ESD_Conversion_Mapping_R_in_Z_%02d",zBin);
@@ -1574,12 +1675,19 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){
                
     //----------------------------------- checking for "real" conversions (MC match) --------------------------------------
     if(fDoMCTruth){
+      TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle();
+      TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle();
                        
       if(fV0Reader->HasSameMCMother() == kFALSE){
+       fHistograms->FillHistogram("ESD_TrueConvCombinatorial_R", fV0Reader->GetXYRadius());
+       if(TMath::Abs(negativeMC->GetPdgCode())==11 && TMath::Abs(positiveMC->GetPdgCode())==11){
+         fHistograms->FillHistogram("ESD_TrueConvCombinatorialElec_R", fV0Reader->GetXYRadius());
+       }
        continue;
       }
-      TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle();
-      TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle();
+      // Moved up to check true electron background
+      //      TParticle * negativeMC = (TParticle*)fV0Reader->GetNegativeMCParticle();
+      //      TParticle * positiveMC = (TParticle*)fV0Reader->GetPositiveMCParticle();
 
       if(TMath::Abs(negativeMC->GetPdgCode())!=11 || TMath::Abs(positiveMC->GetPdgCode())!=11){
        continue;
@@ -1592,7 +1700,12 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){
          (negativeMC->GetUniqueID() == 0 && positiveMC->GetUniqueID() ==0) ){// fill r distribution for Dalitz decays 
        if(fV0Reader->GetMotherMCParticle()->GetPdgCode() == 111){ //pi0
          fHistograms->FillHistogram("ESD_TrueDalitzContamination_R", fV0Reader->GetXYRadius());
+         fHistograms->FillHistogram("ESD_TrueConvDalitzPi0_R", fV0Reader->GetXYRadius());
+       }
+       if(fV0Reader->GetMotherMCParticle()->GetPdgCode() == 221){ //eta
+         fHistograms->FillHistogram("ESD_TrueConvDalitzEta_R", fV0Reader->GetXYRadius());
        }
+
       }
 
       if(negativeMC->GetUniqueID() != 5 || positiveMC->GetUniqueID() !=5){// check if the daughters come from a conversion
@@ -1691,9 +1804,9 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){
  //    AliESDtrack * negTrk = fV0Reader->GetNegativeESDTrack();
        UInt_t kTRDoutN =  (statusN & AliESDtrack::kTRDout);
 
-       Int_t ITSclsE= fV0Reader->GetNegativeTracknITSClusters();
+       Int_t nITSclsE= fV0Reader->GetNegativeTracknITSClusters();
        // filling Resolution_Pt_dPt with respect to the Number of ITS clusters for Positrons
-        switch(ITSclsE){
+        switch(nITSclsE){
          case 0: // 0 ITS clusters
                fHistograms->FillHistogram("Resolution_E_dPt_Pt_ITS0", mcEpt, resEdPt);
            break;
@@ -1737,9 +1850,9 @@ void AliAnalysisTaskGammaConversion::ProcessV0s(){
 //     AliESDtrack * posTr= fV0Reader->GetPositiveESDTrack();
        UInt_t kTRDoutP =  (statusP & AliESDtrack::kTRDout);
        
-       Int_t ITSclsP = fV0Reader->GetPositiveTracknITSClusters();
+       Int_t nITSclsP = fV0Reader->GetPositiveTracknITSClusters();
        // filling Resolution_Pt_dPt with respect to the Number of ITS clusters for Positrons
-        switch(ITSclsP){
+        switch(nITSclsP){
          case 0: // 0 ITS clusters
                fHistograms->FillHistogram("Resolution_P_dPt_Pt_ITS0", mcPpt, resPdPt);
            break;
@@ -1901,9 +2014,10 @@ void AliAnalysisTaskGammaConversion::ProcessGammasForOmegaMesonAnalysis(){
          //  delete omegaCandidatePipPinPi0;
        }
       }
-    } // checking ig gammajet because in that case the chargedparticle list is created
 
+      if (posPiKF) delete posPiKF; posPiKF=NULL;     if (negPiKF) delete negPiKF; negPiKF=NULL;
 
+    } // checking ig gammajet because in that case the chargedparticle list is created
 
   }
 
@@ -1956,14 +2070,14 @@ void AliAnalysisTaskGammaConversion::ProcessGammasForOmegaMesonAnalysis(){
 }
 
 
-void AliAnalysisTaskGammaConversion::AddOmegaToAOD(AliKFParticle * omegakf, Double_t mass, Int_t omegaDaughter, Int_t gammaDaughter) {
+void AliAnalysisTaskGammaConversion::AddOmegaToAOD(const AliKFParticle * const omegakf, Double_t mass, Int_t omegaDaughter, Int_t gammaDaughter) {
   //See header file for documentation
   AliGammaConversionAODObject omega;
-  omega.SetPx(omegakf->Px());
-  omega.SetPy(omegakf->Py());
-  omega.SetPz(omegakf->Pz());
+  omega.SetPx(omegakf->GetPx());
+  omega.SetPy(omegakf->GetPy());
+  omega.SetPz(omegakf->GetPz());
   omega.SetChi2(omegakf->GetChi2());
-  omega.SetE(omegakf->E());
+  omega.SetE(omegakf->GetE());
   omega.SetIMass(mass);
   omega.SetLabel1(omegaDaughter);
   //dynamic_cast<AliGammaConversionAODObject*>(fAODBranch->At(daughter1))->SetTagged(kTRUE);
@@ -2044,25 +2158,29 @@ void AliAnalysisTaskGammaConversion::ProcessGammasForNeutralMesonAnalysis(){
            continue;   // minimum opening angle to avoid using ghosttracks
          }
                        
-         fHistograms->FillHistogram("ESD_Mother_GammaDaughter_OpeningAngle", openingAngleTwoGammaCandidate);
-         fHistograms->FillHistogram("ESD_Mother_Energy", twoGammaCandidate->GetE());
-         fHistograms->FillHistogram("ESD_Mother_Pt", momentumVectorTwoGammaCandidate.Pt());
-         fHistograms->FillHistogram("ESD_Mother_Eta", momentumVectorTwoGammaCandidate.Eta());
-         fHistograms->FillHistogram("ESD_Mother_Rapid", rapidity);                                     
-         fHistograms->FillHistogram("ESD_Mother_Phi", spaceVectorTwoGammaCandidate.Phi());
-         fHistograms->FillHistogram("ESD_Mother_Mass", massTwoGammaCandidate);
-         fHistograms->FillHistogram("ESD_Mother_alfa", alfa);
-         fHistograms->FillHistogram("ESD_Mother_R", spaceVectorTwoGammaCandidate.Pt());    // Pt in Space == R!!!
-         fHistograms->FillHistogram("ESD_Mother_ZR", twoGammaCandidate->GetZ(), spaceVectorTwoGammaCandidate.Pt());
-         fHistograms->FillHistogram("ESD_Mother_XY", twoGammaCandidate->GetX(), twoGammaCandidate->GetY());
-         fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
          if(alfa>fV0Reader->GetAlphaMinCutMeson() && alfa<fV0Reader->GetAlphaCutMeson()){
+           fHistograms->FillHistogram("ESD_Mother_GammaDaughter_OpeningAngle", openingAngleTwoGammaCandidate);
+           fHistograms->FillHistogram("ESD_Mother_Energy", twoGammaCandidate->GetE());
+           fHistograms->FillHistogram("ESD_Mother_Pt", momentumVectorTwoGammaCandidate.Pt());
+           fHistograms->FillHistogram("ESD_Mother_Eta", momentumVectorTwoGammaCandidate.Eta());
+           fHistograms->FillHistogram("ESD_Mother_Rapid", rapidity);                                   
+           fHistograms->FillHistogram("ESD_Mother_Phi", spaceVectorTwoGammaCandidate.Phi());
+           fHistograms->FillHistogram("ESD_Mother_Mass", massTwoGammaCandidate);
+           fHistograms->FillHistogram("ESD_Mother_alfa", alfa);
+           if(massTwoGammaCandidate>0.1 && massTwoGammaCandidate<0.15){
+             fHistograms->FillHistogram("ESD_Mother_alfa_Pi0", alfa);
+           }
+           fHistograms->FillHistogram("ESD_Mother_R", spaceVectorTwoGammaCandidate.Pt());    // Pt in Space == R!!!
+           fHistograms->FillHistogram("ESD_Mother_ZR", twoGammaCandidate->GetZ(), spaceVectorTwoGammaCandidate.Pt());
+           fHistograms->FillHistogram("ESD_Mother_XY", twoGammaCandidate->GetX(), twoGammaCandidate->GetY());
+           fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+           fHistograms->FillHistogram("ESD_Mother_InvMass",massTwoGammaCandidate);         
            fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_alpha",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
          }
          if(alfa<0.1){
            fHistograms->FillHistogram("ESD_Mother_InvMass_vs_E_alpha",massTwoGammaCandidate ,twoGammaCandidate->GetE());
          }
-         fHistograms->FillHistogram("ESD_Mother_InvMass",massTwoGammaCandidate);
+
 
          if(fCalculateBackground){
            /* Kenneth, just for testing*/
@@ -2081,10 +2199,12 @@ void AliAnalysisTaskGammaConversion::ProcessGammasForNeutralMesonAnalysis(){
            }
            //      cout<<"Filling bin number "<<zbin<<" and "<<mbin<<endl;
            //      cout<<"Corresponding to z = "<<fV0Reader->GetVertexZ()<<" and m = "<<multKAA<<endl;
-           fHistograms->FillHistogram(Form("%d%dESD_Mother_InvMass",zbin,mbin),massTwoGammaCandidate);
-           fHistograms->FillHistogram(Form("%d%dESD_Mother_InvMass_vs_Pt",zbin,mbin),massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
-           /* end Kenneth, just for testing*/
-           fHistograms->FillHistogram(Form("%dESD_Mother_InvMass_vs_Pt",mbin),massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+           if(alfa>fV0Reader->GetAlphaMinCutMeson() && alfa<fV0Reader->GetAlphaCutMeson()){
+             fHistograms->FillHistogram(Form("%d%dESD_Mother_InvMass",zbin,mbin),massTwoGammaCandidate);
+             fHistograms->FillHistogram(Form("%d%dESD_Mother_InvMass_vs_Pt",zbin,mbin),massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+             /* end Kenneth, just for testing*/
+             fHistograms->FillHistogram(Form("%dESD_Mother_InvMass_vs_Pt",mbin),massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+           }
          }
          /*      if(fCalculateBackground){
            AliGammaConversionBGHandler * bgHandler = fV0Reader->GetBGHandler();
@@ -2141,118 +2261,118 @@ void AliAnalysisTaskGammaConversion::ProcessGammasForNeutralMesonAnalysis(){
                  }
 
                }
-
-               if(TMath::Abs(eta1)>0.9 && TMath::Abs(eta2)>0.9){
-                 //              fHistograms->FillHistogram("ESD_Mother_InvMass_1212",massTwoGammaCandidate);
-                 //              fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt1212",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
-                 if(isRealPi0 || isRealEta){
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_1212",massTwoGammaCandidate);
-                   fHistograms->FillHistogram("ESD_TruePi0_OpeningAngle_1212",openingAngleTwoGammaCandidate);
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt1212",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass",massTwoGammaCandidate);
-                   if(alfa>fV0Reader->GetAlphaMinCutMeson() && alfa<fV0Reader->GetAlphaCutMeson()){
+               if(alfa>fV0Reader->GetAlphaMinCutMeson() && alfa<fV0Reader->GetAlphaCutMeson()){
+                 if(TMath::Abs(eta1)>0.9 && TMath::Abs(eta2)>0.9){
+                   //            fHistograms->FillHistogram("ESD_Mother_InvMass_1212",massTwoGammaCandidate);
+                   //            fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt1212",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
+                   if(isRealPi0 || isRealEta){
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_1212",massTwoGammaCandidate);
+                     fHistograms->FillHistogram("ESD_TruePi0_OpeningAngle_1212",openingAngleTwoGammaCandidate);
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt1212",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass",massTwoGammaCandidate);
                      fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt_alpha",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
                    }
-                 }
-                 if(!isRealPi0 && !isRealEta){
-                   if(gamma1MotherLabel>-1 && gamma2MotherLabel>-1){
-                     fHistograms->FillHistogram("ESD_TrueBckGG_InvMass",massTwoGammaCandidate);
-                   }else{
-                     fHistograms->FillHistogram("ESD_TrueBckCont_InvMass",massTwoGammaCandidate);
+
+                   if(!isRealPi0 && !isRealEta){
+                     if(gamma1MotherLabel>-1 && gamma2MotherLabel>-1){
+                       fHistograms->FillHistogram("ESD_TrueBckGG_InvMass",massTwoGammaCandidate);
+                     }else{
+                       fHistograms->FillHistogram("ESD_TrueBckCont_InvMass",massTwoGammaCandidate);
+                     }
                    }
-                 }
 
-               }
-               else if(TMath::Abs(eta1)>0.9 || TMath::Abs(eta2)>0.9){
+                 }
+                 else if(TMath::Abs(eta1)>0.9 || TMath::Abs(eta2)>0.9){
                  //              fHistograms->FillHistogram("ESD_Mother_InvMass_0912",massTwoGammaCandidate);
                  //              fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt0912",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
-                 if(isRealPi0 || isRealEta){
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_0912",massTwoGammaCandidate);
-                   fHistograms->FillHistogram("ESD_TruePi0_OpeningAngle_0912",openingAngleTwoGammaCandidate);
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt0912",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass",massTwoGammaCandidate);
-                   if(alfa>fV0Reader->GetAlphaMinCutMeson() && alfa<fV0Reader->GetAlphaCutMeson()){
+                 
+                   if(isRealPi0 || isRealEta){
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_0912",massTwoGammaCandidate);
+                     fHistograms->FillHistogram("ESD_TruePi0_OpeningAngle_0912",openingAngleTwoGammaCandidate);
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt0912",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass",massTwoGammaCandidate);
                      fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt_alpha",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
                    }
-                 }
-                 if(!isRealPi0 && !isRealEta){
-                   if(gamma1MotherLabel>-1 && gamma2MotherLabel>-1){
-                     fHistograms->FillHistogram("ESD_TrueBckGG_InvMass",massTwoGammaCandidate);
-                   }else{
-                     fHistograms->FillHistogram("ESD_TrueBckCont_InvMass",massTwoGammaCandidate);
+                   if(!isRealPi0 && !isRealEta){
+                     if(gamma1MotherLabel>-1 && gamma2MotherLabel>-1){
+                       fHistograms->FillHistogram("ESD_TrueBckGG_InvMass",massTwoGammaCandidate);
+                     }else{
+                       fHistograms->FillHistogram("ESD_TrueBckCont_InvMass",massTwoGammaCandidate);
+                     }
                    }
                  }
-               }
-               else{
+                 else{
                  //              fHistograms->FillHistogram("ESD_Mother_InvMass_0909",massTwoGammaCandidate);
                  //              fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt0909",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
-                 if(isRealPi0 || isRealEta){
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_0909",massTwoGammaCandidate);
-                   fHistograms->FillHistogram("ESD_TruePi0_OpeningAngle_0909",openingAngleTwoGammaCandidate);
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt0909",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
-                   fHistograms->FillHistogram("ESD_TruePi0_InvMass",massTwoGammaCandidate);
-                   if(alfa>fV0Reader->GetAlphaMinCutMeson() && alfa<fV0Reader->GetAlphaCutMeson()){
+                   if(isRealPi0 || isRealEta){
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_0909",massTwoGammaCandidate);
+                     fHistograms->FillHistogram("ESD_TruePi0_OpeningAngle_0909",openingAngleTwoGammaCandidate);
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt0909",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+                     fHistograms->FillHistogram("ESD_TruePi0_InvMass",massTwoGammaCandidate);
                      fHistograms->FillHistogram("ESD_TruePi0_InvMass_vs_Pt_alpha",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+                     if(gamma1MotherLabel > fV0Reader->GetMCStack()->GetNprimary()){
+                       fHistograms->FillHistogram("ESD_TruePi0Sec_InvMass",massTwoGammaCandidate);
+                     }
                    }
-                   if(gamma1MotherLabel > fV0Reader->GetMCStack()->GetNprimary()){
-                     fHistograms->FillHistogram("ESD_TruePi0Sec_InvMass",massTwoGammaCandidate);
-                   }
-                 }
-                 if(!isRealPi0 && !isRealEta){
-                   if(gamma1MotherLabel>-1 && gamma2MotherLabel>-1){
-                     fHistograms->FillHistogram("ESD_TrueBckGG_InvMass",massTwoGammaCandidate);
-                   }else{
-                     fHistograms->FillHistogram("ESD_TrueBckCont_InvMass",massTwoGammaCandidate);
+                   if(!isRealPi0 && !isRealEta){
+                     if(gamma1MotherLabel>-1 && gamma2MotherLabel>-1){
+                       fHistograms->FillHistogram("ESD_TrueBckGG_InvMass",massTwoGammaCandidate);
+                     }else{
+                       fHistograms->FillHistogram("ESD_TrueBckCont_InvMass",massTwoGammaCandidate);
+                     }
                    }
                  }
                }
              }
            }
          }
-         if ( TMath::Abs(twoGammaDecayCandidateDaughter0->GetEta())<0.9 &&  TMath::Abs(twoGammaDecayCandidateDaughter1->GetEta())<0.9 ){
-           fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_Fiducial",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
-           fHistograms->FillHistogram("ESD_Mother_InvMass_Fiducial",massTwoGammaCandidate);
-         }
+         if(alfa>fV0Reader->GetAlphaMinCutMeson() && alfa<fV0Reader->GetAlphaCutMeson()){
+           if ( TMath::Abs(twoGammaDecayCandidateDaughter0->GetEta())<0.9 &&  TMath::Abs(twoGammaDecayCandidateDaughter1->GetEta())<0.9 ){
+             fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_Fiducial",massTwoGammaCandidate ,momentumVectorTwoGammaCandidate.Pt());
+             fHistograms->FillHistogram("ESD_Mother_InvMass_Fiducial",massTwoGammaCandidate);
+           }
+           
+           if(TMath::Abs(twoGammaDecayCandidateDaughter0->GetEta())>0.9 && TMath::Abs(twoGammaDecayCandidateDaughter1->GetEta())>0.9){
+             fHistograms->FillHistogram("ESD_Mother_InvMass_1212",massTwoGammaCandidate);
+             fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt1212",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
+           }
+           else if(TMath::Abs(twoGammaDecayCandidateDaughter0->GetEta())>0.9 || TMath::Abs(twoGammaDecayCandidateDaughter1->GetEta())>0.9){
+             fHistograms->FillHistogram("ESD_Mother_InvMass_0912",massTwoGammaCandidate);
+             fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt0912",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
+           }
+           else{
+             fHistograms->FillHistogram("ESD_Mother_InvMass_0909",massTwoGammaCandidate);
+             fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt0909",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
+           }
 
-         if(TMath::Abs(twoGammaDecayCandidateDaughter0->GetEta())>0.9 && TMath::Abs(twoGammaDecayCandidateDaughter1->GetEta())>0.9){
-           fHistograms->FillHistogram("ESD_Mother_InvMass_1212",massTwoGammaCandidate);
-           fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt1212",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
-         }
-         else if(TMath::Abs(twoGammaDecayCandidateDaughter0->GetEta())>0.9 || TMath::Abs(twoGammaDecayCandidateDaughter1->GetEta())>0.9){
-           fHistograms->FillHistogram("ESD_Mother_InvMass_0912",massTwoGammaCandidate);
-           fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt0912",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
-         }
-         else{
-           fHistograms->FillHistogram("ESD_Mother_InvMass_0909",massTwoGammaCandidate);
-           fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt0909",massTwoGammaCandidate,momentumVectorTwoGammaCandidate.Pt());
+           Double_t lowMassPi0=0.1;
+           Double_t highMassPi0=0.15;
+           if (massTwoGammaCandidate > lowMassPi0 && massTwoGammaCandidate < highMassPi0 ){
+             new((*fKFReconstructedPi0sTClone)[fKFReconstructedPi0sTClone->GetEntriesFast()])  AliKFParticle(*twoGammaCandidate);
+             fGammav1.push_back(firstGammaIndex);
+             fGammav2.push_back(secondGammaIndex);
+             AddPionToAOD(twoGammaCandidate, massTwoGammaCandidate, firstGammaIndex, secondGammaIndex);
+           }
          }
-         Double_t lowMassPi0=0.1;
-         Double_t highMassPi0=0.15;
-         if (massTwoGammaCandidate > lowMassPi0 && massTwoGammaCandidate < highMassPi0 ){
-            new((*fKFReconstructedPi0sTClone)[fKFReconstructedPi0sTClone->GetEntriesFast()])  AliKFParticle(*twoGammaCandidate);
-            fGammav1.push_back(firstGammaIndex);
-            fGammav2.push_back(secondGammaIndex);
-           AddPionToAOD(twoGammaCandidate, massTwoGammaCandidate, firstGammaIndex, secondGammaIndex);
-          }
 
        }
          //}
-         delete twoGammaCandidate;
+       delete twoGammaCandidate;
     }
   }
 }
 
-void AliAnalysisTaskGammaConversion::AddPionToAOD(AliKFParticle * pionkf, Double_t mass, Int_t daughter1, Int_t daughter2) {
+void AliAnalysisTaskGammaConversion::AddPionToAOD(const AliKFParticle * const pionkf, Double_t mass, Int_t daughter1, Int_t daughter2) {
   //See header file for documentation
   AliGammaConversionAODObject pion;
-  pion.SetPx(pionkf->Px());
-  pion.SetPy(pionkf->Py());
-  pion.SetPz(pionkf->Pz());
+  pion.SetPx(pionkf->GetPx());
+  pion.SetPy(pionkf->GetPy());
+  pion.SetPz(pionkf->GetPz());
   pion.SetChi2(pionkf->GetChi2());
-  pion.SetE(pionkf->E());
+  pion.SetE(pionkf->GetE());
   pion.SetIMass(mass);
   pion.SetLabel1(daughter1);
   //dynamic_cast<AliGammaConversionAODObject*>(fAODBranch->At(daughter1))->SetTagged(kTRUE);
@@ -2262,9 +2382,9 @@ void AliAnalysisTaskGammaConversion::AddPionToAOD(AliKFParticle * pionkf, Double
 }
 
 
-
-void AliAnalysisTaskGammaConversion::ProcessConvPHOSGammasForNeutralMesonAnalysis(){
 /*
+  void AliAnalysisTaskGammaConversion::ProcessConvPHOSGammasForNeutralMesonAnalysis(){
+
   // see header file for documentation
   // Analyse Pi0 with one photon from Phos and 1 photon from conversions
        
@@ -2287,29 +2407,29 @@ void AliAnalysisTaskGammaConversion::ProcessConvPHOSGammasForNeutralMesonAnalysi
 
 
   for (Int_t i=0; i<fV0Reader->GetESDEvent()->GetNumberOfCaloClusters(); i++) {
-    clu = fV0Reader->GetESDEvent()->GetCaloCluster(i);
-    if ( !clu->IsPHOS() || clu->E()<0.1 ) continue;
-    clu ->GetMomentum(pPHOS ,vtx);
-    for(Int_t firstGammaIndex=0;firstGammaIndex<fKFReconstructedGammasTClone->GetEntriesFast();firstGammaIndex++){
-      AliKFParticle * twoGammaDecayCandidateDaughter0 = (AliKFParticle *)fKFReconstructedGammasTClone->At(firstGammaIndex);
-      gammaGammaConv.SetXYZM(twoGammaDecayCandidateDaughter0->Px(),twoGammaDecayCandidateDaughter0->Py(),twoGammaDecayCandidateDaughter0->Pz(),0.);
-      gammaPHOS.SetXYZM(pPHOS.Px(),pPHOS.Py(),pPHOS.Pz(),0.);
-      pi0GammaConvPHOS=gammaGammaConv+gammaPHOS;
-      fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvPHOS",pi0GammaConvPHOS.M());
-      fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvPHOS",pi0GammaConvPHOS.M(),pi0GammaConvPHOS.Pt());
-
-      TVector3 v3D0(twoGammaDecayCandidateDaughter0->Px(),twoGammaDecayCandidateDaughter0->Py(),twoGammaDecayCandidateDaughter0->Pz());
-      TVector3 v3D1(gammaPHOS.Px(),gammaPHOS.Py(),gammaPHOS.Pz());
-      Double_t opanConvPHOS= v3D0.Angle(v3D1);
-      if ( opanConvPHOS < 0.35){
-       fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanLow",pi0GammaConvPHOS.M());
-      }else{
-       fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanHigh",pi0GammaConvPHOS.M());
-      }
+  clu = fV0Reader->GetESDEvent()->GetCaloCluster(i);
+  if ( !clu->IsPHOS() || clu->E()<0.1 ) continue;
+  clu ->GetMomentum(pPHOS ,vtx);
+  for(Int_t firstGammaIndex=0;firstGammaIndex<fKFReconstructedGammasTClone->GetEntriesFast();firstGammaIndex++){
+  AliKFParticle * twoGammaDecayCandidateDaughter0 = (AliKFParticle *)fKFReconstructedGammasTClone->At(firstGammaIndex);
+  gammaGammaConv.SetXYZM(twoGammaDecayCandidateDaughter0->Px(),twoGammaDecayCandidateDaughter0->Py(),twoGammaDecayCandidateDaughter0->Pz(),0.);
+  gammaPHOS.SetXYZM(pPHOS.Px(),pPHOS.Py(),pPHOS.Pz(),0.);
+  pi0GammaConvPHOS=gammaGammaConv+gammaPHOS;
+  fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvPHOS",pi0GammaConvPHOS.M());
+  fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvPHOS",pi0GammaConvPHOS.M(),pi0GammaConvPHOS.Pt());
+
+  TVector3 v3D0(twoGammaDecayCandidateDaughter0->Px(),twoGammaDecayCandidateDaughter0->Py(),twoGammaDecayCandidateDaughter0->Pz());
+  TVector3 v3D1(gammaPHOS.Px(),gammaPHOS.Py(),gammaPHOS.Pz());
+  Double_t opanConvPHOS= v3D0.Angle(v3D1);
+  if ( opanConvPHOS < 0.35){
+  fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanLow",pi0GammaConvPHOS.M());
+  }else{
+  fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanHigh",pi0GammaConvPHOS.M());
+  }
 
-    }
+  }
 
-    //  Now the LorentVector pPHOS is obtained and can be paired with the converted proton
+  //  Now the LorentVector pPHOS is obtained and can be paired with the converted proton
   }
   //==== End of the PHOS cluster selection ============
   TLorentzVector pEMCAL;
@@ -2317,109 +2437,110 @@ void AliAnalysisTaskGammaConversion::ProcessConvPHOSGammasForNeutralMesonAnalysi
   TLorentzVector pi0GammaConvEMCAL;
   TLorentzVector pi0GammaConvEMCALBck;
 
-   for (Int_t i=0; i<fV0Reader->GetESDEvent()->GetNumberOfCaloClusters(); i++) {
-    clu = fV0Reader->GetESDEvent()->GetCaloCluster(i);
-    if ( !clu->IsEMCAL()  || clu->E()<0.1 ) continue;
-    if (clu->GetNCells() <= 1) continue;
-    if ( clu->GetTOF()*1e9 < 550  || clu->GetTOF()*1e9 > 750) continue;
-
-    clu ->GetMomentum(pEMCAL ,vtx);
-    for(Int_t firstGammaIndex=0;firstGammaIndex<fKFReconstructedGammasTClone->GetEntriesFast();firstGammaIndex++){
-      AliKFParticle * twoGammaDecayCandidateDaughter0 = (AliKFParticle *)fKFReconstructedGammasTClone->At(firstGammaIndex);
-      gammaGammaConv.SetXYZM(twoGammaDecayCandidateDaughter0->Px(),
-                            twoGammaDecayCandidateDaughter0->Py(),
-                            twoGammaDecayCandidateDaughter0->Pz(),0.);
-      gammaEMCAL.SetXYZM(pEMCAL.Px(),pEMCAL.Py(),pEMCAL.Pz(),0.);
-      pi0GammaConvEMCAL=gammaGammaConv+gammaEMCAL;
-      fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvEMCAL",pi0GammaConvEMCAL.M());
-      fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL",pi0GammaConvEMCAL.M(),pi0GammaConvEMCAL.Pt());
-      TVector3 v3D0(twoGammaDecayCandidateDaughter0->Px(),
-                   twoGammaDecayCandidateDaughter0->Py(),
-                   twoGammaDecayCandidateDaughter0->Pz());
-      TVector3 v3D1(gammaEMCAL.Px(),gammaEMCAL.Py(),gammaEMCAL.Pz());
-
+  for (Int_t i=0; i<fV0Reader->GetESDEvent()->GetNumberOfCaloClusters(); i++) {
+  clu = fV0Reader->GetESDEvent()->GetCaloCluster(i);
+  if ( !clu->IsEMCAL()  || clu->E()<0.1 ) continue;
+  if (clu->GetNCells() <= 1) continue;
+  if ( clu->GetTOF()*1e9 < 550  || clu->GetTOF()*1e9 > 750) continue;
 
-      Double_t opanConvEMCAL= v3D0.Angle(v3D1);
-      if ( opanConvEMCAL < 0.35){
-       fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanLow",pi0GammaConvEMCAL.M());
-      }else{
-       fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanHigh",pi0GammaConvEMCAL.M());
-      }
+  clu ->GetMomentum(pEMCAL ,vtx);
+  for(Int_t firstGammaIndex=0;firstGammaIndex<fKFReconstructedGammasTClone->GetEntriesFast();firstGammaIndex++){
+  AliKFParticle * twoGammaDecayCandidateDaughter0 = (AliKFParticle *)fKFReconstructedGammasTClone->At(firstGammaIndex);
+  gammaGammaConv.SetXYZM(twoGammaDecayCandidateDaughter0->Px(),
+  twoGammaDecayCandidateDaughter0->Py(),
+  twoGammaDecayCandidateDaughter0->Pz(),0.);
+  gammaEMCAL.SetXYZM(pEMCAL.Px(),pEMCAL.Py(),pEMCAL.Pz(),0.);
+  pi0GammaConvEMCAL=gammaGammaConv+gammaEMCAL;
+  fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvEMCAL",pi0GammaConvEMCAL.M());
+  fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL",pi0GammaConvEMCAL.M(),pi0GammaConvEMCAL.Pt());
+  TVector3 v3D0(twoGammaDecayCandidateDaughter0->Px(),
+  twoGammaDecayCandidateDaughter0->Py(),
+  twoGammaDecayCandidateDaughter0->Pz());
+  TVector3 v3D1(gammaEMCAL.Px(),gammaEMCAL.Py(),gammaEMCAL.Pz());
+
+
+  Double_t opanConvEMCAL= v3D0.Angle(v3D1);
+  if ( opanConvEMCAL < 0.35){
+  fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanLow",pi0GammaConvEMCAL.M());
+  }else{
+  fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanHigh",pi0GammaConvEMCAL.M());
+  }
 
-    }
-    if(fCalculateBackground){
-      for(Int_t nEventsInBG=0;nEventsInBG <fV0Reader->GetNBGEvents();nEventsInBG++){
-       AliGammaConversionKFVector * previousEventV0s = fV0Reader->GetBGGoodV0s(nEventsInBG);
-       for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
-         AliKFParticle previousGoodV0 = (AliKFParticle)(*(previousEventV0s->at(iPrevious)));
-         gammaGammaConvBck.SetXYZM(previousGoodV0.Px(),
-                                   previousGoodV0.Py(),
-                                   previousGoodV0.Pz(),0.);
-         pi0GammaConvEMCALBck=gammaGammaConvBck+gammaEMCAL;
-         fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvEMCAL_Bck",pi0GammaConvEMCALBck.M());
-         fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL_Bck",pi0GammaConvEMCALBck.M(),
-                                    pi0GammaConvEMCALBck.Pt());
-       }
-      }
+  }
+  if(fCalculateBackground){
+  for(Int_t nEventsInBG=0;nEventsInBG <fV0Reader->GetNBGEvents();nEventsInBG++){
+  AliGammaConversionKFVector * previousEventV0s = fV0Reader->GetBGGoodV0s(nEventsInBG);
+  for(UInt_t iPrevious=0;iPrevious<previousEventV0s->size();iPrevious++){
+  AliKFParticle previousGoodV0 = (AliKFParticle)(*(previousEventV0s->at(iPrevious)));
+  gammaGammaConvBck.SetXYZM(previousGoodV0.Px(),
+  previousGoodV0.Py(),
+  previousGoodV0.Pz(),0.);
+  pi0GammaConvEMCALBck=gammaGammaConvBck+gammaEMCAL;
+  fHistograms->FillHistogram("ESD_Mother_InvMass_GammaConvEMCAL_Bck",pi0GammaConvEMCALBck.M());
+  fHistograms->FillHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL_Bck",pi0GammaConvEMCALBck.M(),
+  pi0GammaConvEMCALBck.Pt());
+  }
+  }
       
-      //  Now the LorentVector pEMCAL is obtained and can be paired with the converted proton
-    } // end of checking if background photons are available
-   }
+  //  Now the LorentVector pEMCAL is obtained and can be paired with the converted proton
+  } // end of checking if background photons are available
+  }
   //==== End of the PHOS cluster selection ============
+
+  }
 */
-}
 
-void AliAnalysisTaskGammaConversion::MoveParticleAccordingToVertex(AliKFParticle *particle,AliGammaConversionBGHandler::GammaConversionVertex *vertex){
+void AliAnalysisTaskGammaConversion::MoveParticleAccordingToVertex(AliKFParticle * particle,const AliGammaConversionBGHandler::GammaConversionVertex *vertex){
   //see header file for documentation
 
-  Double_t dx = vertex->fX - fESDEvent->GetPrimaryVertex()->GetX();
-  Double_t dy = vertex->fY - fESDEvent->GetPrimaryVertex()->GetY();
-  Double_t dz = vertex->fZ - fESDEvent->GetPrimaryVertex()->GetZ();
+   Double_t dx = vertex->fX - fESDEvent->GetPrimaryVertex()->GetX();
+   Double_t dy = vertex->fY - fESDEvent->GetPrimaryVertex()->GetY();
+   Double_t dz = vertex->fZ - fESDEvent->GetPrimaryVertex()->GetZ();
   
   //  cout<<"dx, dy, dz: ["<<dx<<","<<dy<<","<<dz<<"]"<<endl;
-  particle->X() = particle->GetX() - dx;
-  particle->Y() = particle->GetY() - dy;
-  particle->Z() = particle->GetZ() - dz;
+   particle->X() = particle->GetX() - dx;
+   particle->Y() = particle->GetY() - dy;
+   particle->Z() = particle->GetZ() - dz;
 }
 
 void AliAnalysisTaskGammaConversion::RotateKFParticle(AliKFParticle * kfParticle,Double_t angle){
-  
+  // Rotate the kf particle
   Double_t c = cos(angle);
   Double_t s = sin(angle);
   
-  Double_t A[7][ 7];
+  Double_t mA[7][ 7];
   for( Int_t i=0; i<7; i++ ){
     for( Int_t j=0; j<7; j++){
-      A[i][j] = 0;
+      mA[i][j] = 0;
     }
   }
   for( int i=0; i<7; i++ ){
-    A[i][i] = 1;
+    mA[i][i] = 1;
   }
-  A[0][0] =  c;   A[0][1] = s;
-  A[1][0] = -s;  A[1][1] = c;
-  A[3][3] =  c;  A[3][4] = s;
-  A[4][3] = -s;  A[4][4] = c;
+  mA[0][0] =  c;  mA[0][1] = s;
+  mA[1][0] = -s;  mA[1][1] = c;
+  mA[3][3] =  c;  mA[3][4] = s;
+  mA[4][3] = -s;  mA[4][4] = c;
   
-  Double_t AC[7][7];
-  Double_t Ap[7];
+  Double_t mAC[7][7];
+  Double_t mAp[7];
   
   for( Int_t i=0; i<7; i++ ){
-    Ap[i] = 0;
+    mAp[i] = 0;
     for( Int_t k=0; k<7; k++){
-      Ap[i]+=A[i][k] * kfParticle->GetParameter(k);
+      mAp[i]+=mA[i][k] * kfParticle->GetParameter(k);
     }
   }
   
   for( Int_t i=0; i<7; i++){
-    kfParticle->Parameter(i) = Ap[i];
+    kfParticle->Parameter(i) = mAp[i];
   }
 
   for( Int_t i=0; i<7; i++ ){
     for( Int_t j=0; j<7; j++ ){
-      AC[i][j] = 0;
+      mAC[i][j] = 0;
       for( Int_t k=0; k<7; k++ ){
-       AC[i][j]+= A[i][k] * kfParticle->GetCovariance(k,j);
+       mAC[i][j]+= mA[i][k] * kfParticle->GetCovariance(k,j);
       }
     }
   }
@@ -2428,7 +2549,7 @@ void AliAnalysisTaskGammaConversion::RotateKFParticle(AliKFParticle * kfParticle
     for( Int_t j=0; j<=i; j++ ){
       Double_t xx = 0;
       for( Int_t k=0; k<7; k++){
-       xx+= AC[i][k]*A[j][k];
+       xx+= mAC[i][k]*mA[j][k];
       }
       kfParticle->Covariance(i,j) = xx;
     }
@@ -2458,7 +2579,7 @@ void AliAnalysisTaskGammaConversion::CalculateBackground(){
     for(Int_t iCurrent=0;iCurrent<currentEventV0s->GetEntriesFast();iCurrent++){
       AliKFParticle currentEventGoodV0 = *(AliKFParticle *)(currentEventV0s->At(iCurrent)); 
       for(Int_t iCurrent2=iCurrent+1;iCurrent2<currentEventV0s->GetEntriesFast();iCurrent2++){
-       for(Int_t nRandom=0;nRandom<nRandomEventsForBG;nRandom++){
+       for(Int_t nRandom=0;nRandom<fNRandomEventsForBG;nRandom++){
        
          AliKFParticle currentEventGoodV02 = *(AliKFParticle *)(currentEventV0s->At(iCurrent2));
 
@@ -2476,7 +2597,7 @@ void AliAnalysisTaskGammaConversion::CalculateBackground(){
            delete backgroundCandidateProb;
          }
        
-         Double_t nRadiansPM = nDegreesPMBackground*TMath::Pi()/180;
+         Double_t nRadiansPM = fNDegreesPMBackground*TMath::Pi()/180;
          
          Double_t rotationValue = random->Rndm()*2*nRadiansPM + TMath::Pi()-nRadiansPM;
 
@@ -2521,48 +2642,49 @@ void AliAnalysisTaskGammaConversion::CalculateBackground(){
            }                   
          
            // original
-           fHistograms->FillHistogram("ESD_Background_GammaDaughter_OpeningAngle", openingAngleBG);
-           fHistograms->FillHistogram("ESD_Background_Energy", backgroundCandidate->GetE());
-           fHistograms->FillHistogram("ESD_Background_Pt",  momentumVectorbackgroundCandidate.Pt());
-           fHistograms->FillHistogram("ESD_Background_Eta", momentumVectorbackgroundCandidate.Eta());
-           fHistograms->FillHistogram("ESD_Background_Rapidity", rapidity);
-           fHistograms->FillHistogram("ESD_Background_Phi", spaceVectorbackgroundCandidate.Phi());
-           fHistograms->FillHistogram("ESD_Background_Mass", massBG);
-           fHistograms->FillHistogram("ESD_Background_R", spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
-           fHistograms->FillHistogram("ESD_Background_ZR", backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
-           fHistograms->FillHistogram("ESD_Background_XY", backgroundCandidate->GetX(), backgroundCandidate->GetY());
-           fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt",massBG,momentumVectorbackgroundCandidate.Pt());
-           fHistograms->FillHistogram("ESD_Background_InvMass",massBG);
-         
            if(alfa>fV0Reader->GetAlphaMinCutMeson() &&   alfa<fV0Reader->GetAlphaCutMeson()){
+             fHistograms->FillHistogram("ESD_Background_GammaDaughter_OpeningAngle", openingAngleBG);
+             fHistograms->FillHistogram("ESD_Background_Energy", backgroundCandidate->GetE());
+             fHistograms->FillHistogram("ESD_Background_Pt",  momentumVectorbackgroundCandidate.Pt());
+             fHistograms->FillHistogram("ESD_Background_Eta", momentumVectorbackgroundCandidate.Eta());
+             fHistograms->FillHistogram("ESD_Background_Rapidity", rapidity);
+             fHistograms->FillHistogram("ESD_Background_Phi", spaceVectorbackgroundCandidate.Phi());
+             fHistograms->FillHistogram("ESD_Background_Mass", massBG);
+             fHistograms->FillHistogram("ESD_Background_R", spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
+             fHistograms->FillHistogram("ESD_Background_ZR", backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
+             fHistograms->FillHistogram("ESD_Background_XY", backgroundCandidate->GetX(), backgroundCandidate->GetY());
+             fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt",massBG,momentumVectorbackgroundCandidate.Pt());
+             fHistograms->FillHistogram("ESD_Background_InvMass",massBG);
              fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_alpha",massBG,momentumVectorbackgroundCandidate.Pt());
+
+
+             if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(currentEventGoodV02.GetEta())<0.9 ){
+               fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_Fiducial",massBG,momentumVectorbackgroundCandidate.Pt());
+               fHistograms->FillHistogram("ESD_Background_InvMass_Fiducial",massBG);
+             }
+             
+             fHistograms->FillHistogram(Form("%d%dESD_Background_GammaDaughter_OpeningAngle",zbin,mbin), openingAngleBG);
+             fHistograms->FillHistogram(Form("%d%dESD_Background_Energy",zbin,mbin), backgroundCandidate->GetE());
+             fHistograms->FillHistogram(Form("%d%dESD_Background_Pt",zbin,mbin),  momentumVectorbackgroundCandidate.Pt());
+             fHistograms->FillHistogram(Form("%d%dESD_Background_Eta",zbin,mbin), momentumVectorbackgroundCandidate.Eta());
+             fHistograms->FillHistogram(Form("%d%dESD_Background_Rapidity",zbin,mbin), rapidity);
+             fHistograms->FillHistogram(Form("%d%dESD_Background_Phi",zbin,mbin), spaceVectorbackgroundCandidate.Phi());
+             fHistograms->FillHistogram(Form("%d%dESD_Background_Mass",zbin,mbin), massBG);
+             fHistograms->FillHistogram(Form("%d%dESD_Background_R",zbin,mbin), spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
+             fHistograms->FillHistogram(Form("%d%dESD_Background_ZR",zbin,mbin), backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
+             fHistograms->FillHistogram(Form("%d%dESD_Background_XY",zbin,mbin), backgroundCandidate->GetX(), backgroundCandidate->GetY());
+             fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
+             fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass",zbin,mbin),massBG);
+             
+             if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(currentEventGoodV02.GetEta())<0.9 ){
+               fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt_Fiducial",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
+               fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_Fiducial",zbin,mbin),massBG);
+             }
            }
            if(alfa<0.1){
              fHistograms->FillHistogram("ESD_Background_InvMass_vs_E_alpha",massBG ,backgroundCandidate->GetE());
            }
 
-           if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(currentEventGoodV02.GetEta())<0.9 ){
-             fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_Fiducial",massBG,momentumVectorbackgroundCandidate.Pt());
-             fHistograms->FillHistogram("ESD_Background_InvMass_Fiducial",massBG);
-           }
-         
-           fHistograms->FillHistogram(Form("%d%dESD_Background_GammaDaughter_OpeningAngle",zbin,mbin), openingAngleBG);
-           fHistograms->FillHistogram(Form("%d%dESD_Background_Energy",zbin,mbin), backgroundCandidate->GetE());
-           fHistograms->FillHistogram(Form("%d%dESD_Background_Pt",zbin,mbin),  momentumVectorbackgroundCandidate.Pt());
-           fHistograms->FillHistogram(Form("%d%dESD_Background_Eta",zbin,mbin), momentumVectorbackgroundCandidate.Eta());
-           fHistograms->FillHistogram(Form("%d%dESD_Background_Rapidity",zbin,mbin), rapidity);
-           fHistograms->FillHistogram(Form("%d%dESD_Background_Phi",zbin,mbin), spaceVectorbackgroundCandidate.Phi());
-           fHistograms->FillHistogram(Form("%d%dESD_Background_Mass",zbin,mbin), massBG);
-           fHistograms->FillHistogram(Form("%d%dESD_Background_R",zbin,mbin), spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
-           fHistograms->FillHistogram(Form("%d%dESD_Background_ZR",zbin,mbin), backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
-           fHistograms->FillHistogram(Form("%d%dESD_Background_XY",zbin,mbin), backgroundCandidate->GetX(), backgroundCandidate->GetY());
-           fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
-           fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass",zbin,mbin),massBG);
-
-           if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(currentEventGoodV02.GetEta())<0.9 ){
-             fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt_Fiducial",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
-             fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_Fiducial",zbin,mbin),massBG);
-           }
          }
          //}
          delete backgroundCandidate;      
@@ -2642,51 +2764,51 @@ void AliAnalysisTaskGammaConversion::CalculateBackground(){
              }                 
 
              // original
-             fHistograms->FillHistogram("ESD_Background_GammaDaughter_OpeningAngle", openingAngleBG);
-             fHistograms->FillHistogram("ESD_Background_Energy", backgroundCandidate->GetE());
-             fHistograms->FillHistogram("ESD_Background_Pt",  momentumVectorbackgroundCandidate.Pt());
-             fHistograms->FillHistogram("ESD_Background_Eta", momentumVectorbackgroundCandidate.Eta());
-             fHistograms->FillHistogram("ESD_Background_Rapidity", rapidity);
-             fHistograms->FillHistogram("ESD_Background_Phi", spaceVectorbackgroundCandidate.Phi());
-             fHistograms->FillHistogram("ESD_Background_Mass", massBG);
-             fHistograms->FillHistogram("ESD_Background_R", spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
-             fHistograms->FillHistogram("ESD_Background_ZR", backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
-             fHistograms->FillHistogram("ESD_Background_XY", backgroundCandidate->GetX(), backgroundCandidate->GetY());
-             fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt",massBG,momentumVectorbackgroundCandidate.Pt());
-             fHistograms->FillHistogram("ESD_Background_InvMass",massBG);
-
              if(alfa>fV0Reader->GetAlphaMinCutMeson() &&   alfa<fV0Reader->GetAlphaCutMeson()){
+               fHistograms->FillHistogram("ESD_Background_GammaDaughter_OpeningAngle", openingAngleBG);
+               fHistograms->FillHistogram("ESD_Background_Energy", backgroundCandidate->GetE());
+               fHistograms->FillHistogram("ESD_Background_Pt",  momentumVectorbackgroundCandidate.Pt());
+               fHistograms->FillHistogram("ESD_Background_Eta", momentumVectorbackgroundCandidate.Eta());
+               fHistograms->FillHistogram("ESD_Background_Rapidity", rapidity);
+               fHistograms->FillHistogram("ESD_Background_Phi", spaceVectorbackgroundCandidate.Phi());
+               fHistograms->FillHistogram("ESD_Background_Mass", massBG);
+               fHistograms->FillHistogram("ESD_Background_R", spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
+               fHistograms->FillHistogram("ESD_Background_ZR", backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
+               fHistograms->FillHistogram("ESD_Background_XY", backgroundCandidate->GetX(), backgroundCandidate->GetY());
+               fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt",massBG,momentumVectorbackgroundCandidate.Pt());
+               fHistograms->FillHistogram("ESD_Background_InvMass",massBG);
                fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_alpha",massBG,momentumVectorbackgroundCandidate.Pt());
+
+
+               if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(previousGoodV0.GetEta())<0.9 ){
+                 fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_Fiducial",massBG,momentumVectorbackgroundCandidate.Pt());
+                 fHistograms->FillHistogram("ESD_Background_InvMass_Fiducial",massBG);
+               }
+
+               // test
+               fHistograms->FillHistogram(Form("%d%dESD_Background_GammaDaughter_OpeningAngle",zbin,mbin), openingAngleBG);
+               fHistograms->FillHistogram(Form("%d%dESD_Background_Energy",zbin,mbin), backgroundCandidate->GetE());
+               fHistograms->FillHistogram(Form("%d%dESD_Background_Pt",zbin,mbin),  momentumVectorbackgroundCandidate.Pt());
+               fHistograms->FillHistogram(Form("%d%dESD_Background_Eta",zbin,mbin), momentumVectorbackgroundCandidate.Eta());
+               fHistograms->FillHistogram(Form("%d%dESD_Background_Rapidity",zbin,mbin), rapidity);
+               fHistograms->FillHistogram(Form("%d%dESD_Background_Phi",zbin,mbin), spaceVectorbackgroundCandidate.Phi());
+               fHistograms->FillHistogram(Form("%d%dESD_Background_Mass",zbin,mbin), massBG);
+               fHistograms->FillHistogram(Form("%d%dESD_Background_R",zbin,mbin), spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
+               fHistograms->FillHistogram(Form("%d%dESD_Background_ZR",zbin,mbin), backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
+               fHistograms->FillHistogram(Form("%d%dESD_Background_XY",zbin,mbin), backgroundCandidate->GetX(), backgroundCandidate->GetY());
+               fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
+               fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass",zbin,mbin),massBG);
+               
+               if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(previousGoodV0.GetEta())<0.9 ){
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt_Fiducial",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_Fiducial",zbin,mbin),massBG);
+               }
+               //        }
              }
              if(alfa<0.1){
                fHistograms->FillHistogram("ESD_Background_InvMass_vs_E_alpha",massBG ,backgroundCandidate->GetE());
              }
 
-             if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(previousGoodV0.GetEta())<0.9 ){
-               fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_Fiducial",massBG,momentumVectorbackgroundCandidate.Pt());
-               fHistograms->FillHistogram("ESD_Background_InvMass_Fiducial",massBG);
-             }
-           
-           
-             // test
-             fHistograms->FillHistogram(Form("%d%dESD_Background_GammaDaughter_OpeningAngle",zbin,mbin), openingAngleBG);
-             fHistograms->FillHistogram(Form("%d%dESD_Background_Energy",zbin,mbin), backgroundCandidate->GetE());
-             fHistograms->FillHistogram(Form("%d%dESD_Background_Pt",zbin,mbin),  momentumVectorbackgroundCandidate.Pt());
-             fHistograms->FillHistogram(Form("%d%dESD_Background_Eta",zbin,mbin), momentumVectorbackgroundCandidate.Eta());
-             fHistograms->FillHistogram(Form("%d%dESD_Background_Rapidity",zbin,mbin), rapidity);
-             fHistograms->FillHistogram(Form("%d%dESD_Background_Phi",zbin,mbin), spaceVectorbackgroundCandidate.Phi());
-             fHistograms->FillHistogram(Form("%d%dESD_Background_Mass",zbin,mbin), massBG);
-             fHistograms->FillHistogram(Form("%d%dESD_Background_R",zbin,mbin), spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
-             fHistograms->FillHistogram(Form("%d%dESD_Background_ZR",zbin,mbin), backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
-             fHistograms->FillHistogram(Form("%d%dESD_Background_XY",zbin,mbin), backgroundCandidate->GetX(), backgroundCandidate->GetY());
-             fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
-             fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass",zbin,mbin),massBG);
-
-             if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(previousGoodV0.GetEta())<0.9 ){
-               fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt_Fiducial",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
-               fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_Fiducial",zbin,mbin),massBG);
-             }
-             //          }
            }
            delete backgroundCandidate;      
          }
@@ -2761,55 +2883,58 @@ void AliAnalysisTaskGammaConversion::CalculateBackground(){
                  continue;   // minimum opening angle to avoid using ghosttracks
                }                       
 
-               fHistograms->FillHistogram("ESD_Background_GammaDaughter_OpeningAngle", openingAngleBG);
-               fHistograms->FillHistogram("ESD_Background_Energy", backgroundCandidate->GetE());
-               fHistograms->FillHistogram("ESD_Background_Pt",  momentumVectorbackgroundCandidate.Pt());
-               fHistograms->FillHistogram("ESD_Background_Eta", momentumVectorbackgroundCandidate.Eta());
-               fHistograms->FillHistogram("ESD_Background_Rapidity", rapidity);
-               fHistograms->FillHistogram("ESD_Background_Phi", spaceVectorbackgroundCandidate.Phi());
-               fHistograms->FillHistogram("ESD_Background_Mass", massBG);
-               fHistograms->FillHistogram("ESD_Background_R", spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
-               fHistograms->FillHistogram("ESD_Background_ZR", backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
-               fHistograms->FillHistogram("ESD_Background_XY", backgroundCandidate->GetX(), backgroundCandidate->GetY());
-               fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt",massBG,momentumVectorbackgroundCandidate.Pt());
-               fHistograms->FillHistogram("ESD_Background_InvMass",massBG);
-
                if(alfa>fV0Reader->GetAlphaMinCutMeson() &&   alfa<fV0Reader->GetAlphaCutMeson()){
+                 fHistograms->FillHistogram("ESD_Background_GammaDaughter_OpeningAngle", openingAngleBG);
+                 fHistograms->FillHistogram("ESD_Background_Energy", backgroundCandidate->GetE());
+                 fHistograms->FillHistogram("ESD_Background_Pt",  momentumVectorbackgroundCandidate.Pt());
+                 fHistograms->FillHistogram("ESD_Background_Eta", momentumVectorbackgroundCandidate.Eta());
+                 fHistograms->FillHistogram("ESD_Background_Rapidity", rapidity);
+                 fHistograms->FillHistogram("ESD_Background_Phi", spaceVectorbackgroundCandidate.Phi());
+                 fHistograms->FillHistogram("ESD_Background_Mass", massBG);
+                 fHistograms->FillHistogram("ESD_Background_R", spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
+                 fHistograms->FillHistogram("ESD_Background_ZR", backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
+                 fHistograms->FillHistogram("ESD_Background_XY", backgroundCandidate->GetX(), backgroundCandidate->GetY());
+                 fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt",massBG,momentumVectorbackgroundCandidate.Pt());
+                 fHistograms->FillHistogram("ESD_Background_InvMass",massBG);
+                 
+
                  fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_alpha",massBG,momentumVectorbackgroundCandidate.Pt());
-               }
-               if(alfa<0.1){
-                 fHistograms->FillHistogram("ESD_Background_InvMass_vs_E_alpha",massBG ,backgroundCandidate->GetE());
-               }
 
-               if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(previousGoodV0.GetEta())<0.9 ){
-                 fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_Fiducial",massBG,momentumVectorbackgroundCandidate.Pt());
-                 fHistograms->FillHistogram("ESD_Background_InvMass_Fiducial",massBG);
-               }
-           
-               if(massBG>0.5 && massBG<0.6){
-                 fHistograms->FillHistogram("ESD_Background_alfa_pt0506",momentumVectorbackgroundCandidate.Pt(),alfa);
-               }
-               if(massBG>0.3 && massBG<0.4){
-                 fHistograms->FillHistogram("ESD_Background_alfa_pt0304",momentumVectorbackgroundCandidate.Pt(),alfa);
+                 
+                 if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(previousGoodV0.GetEta())<0.9 ){
+                   fHistograms->FillHistogram("ESD_Background_InvMass_vs_Pt_Fiducial",massBG,momentumVectorbackgroundCandidate.Pt());
+                   fHistograms->FillHistogram("ESD_Background_InvMass_Fiducial",massBG);
+                 }
+                 
+                 if(massBG>0.5 && massBG<0.6){
+                   fHistograms->FillHistogram("ESD_Background_alfa_pt0506",momentumVectorbackgroundCandidate.Pt(),alfa);
+                 }
+                 if(massBG>0.3 && massBG<0.4){
+                   fHistograms->FillHistogram("ESD_Background_alfa_pt0304",momentumVectorbackgroundCandidate.Pt(),alfa);
+                 }
+                 
+                 // test
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_GammaDaughter_OpeningAngle",zbin,mbin), openingAngleBG);
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_Energy",zbin,mbin), backgroundCandidate->GetE());
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_Pt",zbin,mbin),  momentumVectorbackgroundCandidate.Pt());
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_Eta",zbin,mbin), momentumVectorbackgroundCandidate.Eta());
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_Rapidity",zbin,mbin), rapidity);
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_Phi",zbin,mbin), spaceVectorbackgroundCandidate.Phi());
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_Mass",zbin,mbin), massBG);
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_R",zbin,mbin), spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_ZR",zbin,mbin), backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_XY",zbin,mbin), backgroundCandidate->GetX(), backgroundCandidate->GetY());
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
+                 fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass",zbin,mbin),massBG);
+                 
+                 if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(previousGoodV0.GetEta())<0.9 ){
+                   fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt_Fiducial",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
+                   fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_Fiducial",zbin,mbin),massBG);
+                 }
                }
-           
-               // test
-               fHistograms->FillHistogram(Form("%d%dESD_Background_GammaDaughter_OpeningAngle",zbin,mbin), openingAngleBG);
-               fHistograms->FillHistogram(Form("%d%dESD_Background_Energy",zbin,mbin), backgroundCandidate->GetE());
-               fHistograms->FillHistogram(Form("%d%dESD_Background_Pt",zbin,mbin),  momentumVectorbackgroundCandidate.Pt());
-               fHistograms->FillHistogram(Form("%d%dESD_Background_Eta",zbin,mbin), momentumVectorbackgroundCandidate.Eta());
-               fHistograms->FillHistogram(Form("%d%dESD_Background_Rapidity",zbin,mbin), rapidity);
-               fHistograms->FillHistogram(Form("%d%dESD_Background_Phi",zbin,mbin), spaceVectorbackgroundCandidate.Phi());
-               fHistograms->FillHistogram(Form("%d%dESD_Background_Mass",zbin,mbin), massBG);
-               fHistograms->FillHistogram(Form("%d%dESD_Background_R",zbin,mbin), spaceVectorbackgroundCandidate.Pt());  // Pt in Space == R!!!!
-               fHistograms->FillHistogram(Form("%d%dESD_Background_ZR",zbin,mbin), backgroundCandidate->GetZ(), spaceVectorbackgroundCandidate.Pt());
-               fHistograms->FillHistogram(Form("%d%dESD_Background_XY",zbin,mbin), backgroundCandidate->GetX(), backgroundCandidate->GetY());
-               fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
-               fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass",zbin,mbin),massBG);
 
-               if ( TMath::Abs(currentEventGoodV0.GetEta())<0.9 &&  TMath::Abs(previousGoodV0.GetEta())<0.9 ){
-                 fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_vs_Pt_Fiducial",zbin,mbin),massBG,momentumVectorbackgroundCandidate.Pt());
-                 fHistograms->FillHistogram(Form("%d%dESD_Background_InvMass_Fiducial",zbin,mbin),massBG);
+               if(alfa<0.1){
+                 fHistograms->FillHistogram("ESD_Background_InvMass_vs_E_alpha",massBG ,backgroundCandidate->GetE());
                }
                //  }
              }
@@ -2847,7 +2972,7 @@ void AliAnalysisTaskGammaConversion::ProcessGammasForGammaJetAnalysis(){
 }
 
 //____________________________________________________________________
-Bool_t AliAnalysisTaskGammaConversion::IsGoodImpPar(AliESDtrack *const track)
+Bool_t AliAnalysisTaskGammaConversion::IsGoodImpPar(const AliESDtrack *const track)
 {
 //
 // check whether particle has good DCAr(Pt) impact
@@ -2888,14 +3013,16 @@ void AliAnalysisTaskGammaConversion::CreateListOfChargedParticles(){
       numberOfESDTracks++;
     }
   }
-  fHistograms->FillHistogram("ESD_NumberOfGoodESDTracks",numberOfESDTracks);
-
-  if (fV0Reader->GetNumberOfContributorsVtx()>=1){
-    fHistograms->FillHistogram("ESD_NumberOfGoodESDTracksVtx",numberOfESDTracks);
-  } 
+// Moved to UserExec using CountAcceptedTracks function. runjet is not needed by default
+//   fHistograms->FillHistogram("ESD_NumberOfGoodESDTracks",numberOfESDTracks);
+//   cout<<"esdtracks::"<< numberOfESDTracks<<endl;
+//   if (fV0Reader->GetNumberOfContributorsVtx()>=1){
+//     fHistograms->FillHistogram("ESD_NumberOfGoodESDTracksVtx",numberOfESDTracks);
+//   } 
 }
 void AliAnalysisTaskGammaConversion::RecalculateV0ForGamma(){
-  
+  //recalculates v0 for gamma
+
  Double_t massE=0.00051099892;
  TLorentzVector curElecPos;
  TLorentzVector curElecNeg;
@@ -3333,7 +3460,7 @@ void AliAnalysisTaskGammaConversion::UserCreateOutputObjects()
   fOutputContainer->SetName(GetName());
 }
 
-Double_t AliAnalysisTaskGammaConversion::GetMCOpeningAngle(TParticle* const daughter0, TParticle* const daughter1) const{
+Double_t AliAnalysisTaskGammaConversion::GetMCOpeningAngle(const TParticle* const daughter0, const TParticle* const daughter1) const{
   //helper function
   TVector3 v3D0(daughter0->Px(),daughter0->Py(),daughter0->Pz());
   TVector3 v3D1(daughter1->Px(),daughter1->Py(),daughter1->Pz());
@@ -3888,7 +4015,7 @@ void AliAnalysisTaskGammaConversion::CleanWithAngleCuts(TClonesArray const negat
 }
 
 
-void  AliAnalysisTaskGammaConversion::GetPID(AliESDtrack *track, Stat_t &pid, Stat_t &weight)
+void  AliAnalysisTaskGammaConversion::GetPID(const AliESDtrack *track, Stat_t &pid, Stat_t &weight)
 {
   // see header file for documentation
   pid = -1;
@@ -3936,7 +4063,7 @@ void  AliAnalysisTaskGammaConversion::GetPID(AliESDtrack *track, Stat_t &pid, St
   pid = ipid;
   weight = max;
 }
-double AliAnalysisTaskGammaConversion::GetSigmaToVertex(AliESDtrack* t)
+double AliAnalysisTaskGammaConversion::GetSigmaToVertex(const AliESDtrack* t)
 {
   // Calculates the number of sigma to the vertex.
        
@@ -3997,8 +4124,7 @@ TClonesArray AliAnalysisTaskGammaConversion::GetTLorentzVector(TClonesArray *con
        
   //  return tlVtrack;
 }
-
-Int_t AliAnalysisTaskGammaConversion::GetProcessType(AliMCEvent * mcEvt) {
+Int_t AliAnalysisTaskGammaConversion::GetProcessType(const AliMCEvent * mcEvt) {
 
   // Determine if the event was generated with pythia or phojet and return the process type
 
@@ -4053,3 +4179,21 @@ Int_t AliAnalysisTaskGammaConversion::GetProcessType(AliMCEvent * mcEvt) {
   AliError(Form("Unknown header: %s", htmp->IsA()->GetName()));
   return kProcUnknown;
 }
+
+
+Int_t AliAnalysisTaskGammaConversion::CalculateMultiplicityBin(){
+  // Get Centrality bin
+
+  Int_t multiplicity = 0;
+
+  if ( fUseMultiplicity == 1 ) {
+
+    if (fMultiplicity>= 0 && fMultiplicity<= 5) multiplicity=1;
+    if (fMultiplicity>= 6 && fMultiplicity<= 9) multiplicity=2;
+    if (fMultiplicity>=10 && fMultiplicity<=14) multiplicity=3;
+    if (fMultiplicity>=15 && fMultiplicity<=22) multiplicity=4;
+    if (fMultiplicity>=23 )                     multiplicity=5;
+
+  }
+  return multiplicity;
+}