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

diff --git a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx
index 473a23b6329cbb94fe1753d0d0015cd65f94319e..c857ac3d964134e23a7a699c422e3f584c7e7eb3 100644 (file)
--- a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx
+++ b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.cxx
@@ -42,6 +42,7 @@
 #include <AliMCEventHandler.h>
 #include "TRandom3.h"
 #include "AliTriggerAnalysis.h"
+#include "AliESDCentrality.h"
 
 class AliESDTrackCuts;
 class AliCFContainer;
@@ -140,7 +141,9 @@ AliAnalysisTaskSE(),
   fTriggerAnalysis(NULL),
   fMultiplicity(0),
   fUseMultiplicity(0), 
-  fUseMultiplicityBin(0)
+  fUseMultiplicityBin(0),
+  fUseCentrality(0), 
+  fUseCentralityBin(0)
 {
   // Default constructor
 
@@ -234,7 +237,9 @@ AliAnalysisTaskGammaConversion::AliAnalysisTaskGammaConversion(const char* name)
   fTriggerAnalysis(NULL),
   fMultiplicity(0),
   fUseMultiplicity(0), 
-  fUseMultiplicityBin(0)
+  fUseMultiplicityBin(0),
+  fUseCentrality(0), 
+  fUseCentralityBin(0)
 {
   // Common I/O in slot 0
   DefineInput (0, TChain::Class());
@@ -350,6 +355,7 @@ void AliAnalysisTaskGammaConversion::SetESDtrackCuts()
 // Using standard function  for setting Cuts
   Bool_t selectPrimaries=kTRUE;
   fEsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
+  fEsdTrackCuts->SetMaxDCAToVertexZ(2);
   fEsdTrackCuts->SetEtaRange(-0.8, 0.8);
   fEsdTrackCuts->SetPtRange(0.15);
   
@@ -560,6 +566,30 @@ void AliAnalysisTaskGammaConversion::UserExec(Option_t */*option*/)
     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);
 
@@ -967,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());       
       
@@ -1006,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() );
@@ -1553,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();
@@ -1590,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);
@@ -1631,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;
@@ -1649,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

diff --git a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.h b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.h
index 91039dd8d4f8c1324da6fcdc5a3312f4dbf626a5..8abeda845475fde8d7a6f8cfdeb408f300f4f39f 100644 (file)
--- a/PWG4/GammaConv/AliAnalysisTaskGammaConversion.h
+++ b/PWG4/GammaConv/AliAnalysisTaskGammaConversion.h
@@ -160,6 +160,12 @@ class AliAnalysisTaskGammaConversion : public AliAnalysisTaskSE
   void SetUseMultiplicity(Int_t useMultiplicity) {fUseMultiplicity=useMultiplicity;}
   void SetUseMultiplicityBin(Int_t useMultiplicityBin) {fUseMultiplicityBin=useMultiplicityBin;}
   Int_t CalculateMultiplicityBin();
+  void SetUseCentrality(Int_t useCentrality) {fUseCentrality=useCentrality;}
+  void SetUseCentralityBin(Int_t useCentralityBin) {fUseCentralityBin=useCentralityBin;}
+
+
+
+
  private:
   AliAnalysisTaskGammaConversion(const AliAnalysisTaskGammaConversion&); // Not implemented
   AliAnalysisTaskGammaConversion& operator=(const AliAnalysisTaskGammaConversion&); // Not implemented
@@ -300,7 +306,9 @@ class AliAnalysisTaskGammaConversion : public AliAnalysisTaskSE
   Int_t fMultiplicity;
   Int_t fUseMultiplicity;
   Int_t fUseMultiplicityBin;
-  ClassDef(AliAnalysisTaskGammaConversion, 15); // Analysis task for gamma conversions
+  Int_t fUseCentrality;
+  Int_t fUseCentralityBin;
+  ClassDef(AliAnalysisTaskGammaConversion, 16); // Analysis task for gamma conversions
 };
 
 #endif //ALIANALYSISTASKGAMMA_H

diff --git a/PWG4/GammaConv/AliGammaConversionHistograms.cxx b/PWG4/GammaConv/AliGammaConversionHistograms.cxx
index 361d41c3fa102ea1e5e3a07ca8cd2efdd26f2d41..27578768c852d2acd99723e183d69537d6b5ce89 100644 (file)
--- a/PWG4/GammaConv/AliGammaConversionHistograms.cxx
+++ b/PWG4/GammaConv/AliGammaConversionHistograms.cxx
@@ -719,6 +719,14 @@ void AliGammaConversionHistograms::AddMappingHistograms(Int_t nPhiIndex, Int_t n
     //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
     AddHistogram(nameMCFMDPhiInZ, titleMCFMDPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
                
+    //Mapping Phi in Z for ITSTPC
+    TString nameMCITSTPCPhiInZ="";
+    nameMCITSTPCPhiInZ.Form("MC_Conversion_Mapping_ITSTPC_Phi_in_Z_%02d",z);
+    TString titleMCITSTPCPhiInZ="";
+    titleMCITSTPCPhiInZ.Form("MC Mapping ITSTPC of Phi in Z%02d",z);
+    //    AddHistogram(nameMCPhiInR, titleMCPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);
+    AddHistogram(nameMCITSTPCPhiInZ, titleMCITSTPCPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);
+
 
     //Mapping R in Z
     TString nameMCRInZ="";
@@ -774,6 +782,14 @@ void AliGammaConversionHistograms::AddMappingHistograms(Int_t nPhiIndex, Int_t n
     //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);    
     AddHistogram(nameESDFMDPhiInZ, titleESDFMDPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);    
 
+    //Mapping Phi in Z for ITSTPC
+    TString nameESDITSTPCPhiInZ="";
+    nameESDITSTPCPhiInZ.Form("ESD_Conversion_Mapping_ITSTPC_Phi_in_Z_%02d",z);
+    TString titleESDITSTPCPhiInZ="";
+    titleESDITSTPCPhiInZ.Form("ESD Mapping ITSTPC of Phi in Z%02d",z);
+    //    AddHistogram(nameESDPhiInR, titleESDPhiInR, nXBins, firstX, lastX, xAxisTitle, yAxisTitle);    
+    AddHistogram(nameESDITSTPCPhiInZ, titleESDITSTPCPhiInZ, nXBins, -TMath::Pi(), TMath::Pi(), xAxisTitle, yAxisTitle);    
+
 
    //Mapping R in Z
     TString nameESDRInZ="";

diff --git a/PWG4/GammaConv/AliV0Reader.cxx b/PWG4/GammaConv/AliV0Reader.cxx
index 4b2fb01f6ef7129262034996bf01af8fdc0bce0c..a487aeab464da5d55410b4ba4b74b596499f6e34 100644 (file)
--- a/PWG4/GammaConv/AliV0Reader.cxx
+++ b/PWG4/GammaConv/AliV0Reader.cxx
@@ -139,7 +139,8 @@ AliV0Reader::AliV0Reader() :
   fNumberOfESDTracks(0),
   nEventsForBGCalculation(20),
   fUseChargedTrackMultiplicityForBG(kTRUE),
-  fNumberOfGoodV0s(0)
+  fNumberOfGoodV0s(0),
+  fIsHeavyIon(0)
 {
   //fESDpid = new AliESDpid;   
 }
@@ -235,7 +236,8 @@ AliV0Reader::AliV0Reader(const AliV0Reader & original) :
   fNumberOfESDTracks(original.fNumberOfESDTracks),
   nEventsForBGCalculation(original.nEventsForBGCalculation),
   fUseChargedTrackMultiplicityForBG(original.fUseChargedTrackMultiplicityForBG),
-  fNumberOfGoodV0s(original.fNumberOfGoodV0s)
+  fNumberOfGoodV0s(original.fNumberOfGoodV0s),
+  fIsHeavyIon(original.fIsHeavyIon)
 {
        
 }
@@ -367,7 +369,14 @@ void AliV0Reader::Initialize(){
        multiplicityBinLimitsArray[3] = 27.5;
        multiplicityBinLimitsArray[4] = 41.5;
        multiplicityBinLimitsArray[5] = 100.;
-
+       if(fIsHeavyIon){
+         multiplicityBinLimitsArray[0] = 0;
+         multiplicityBinLimitsArray[1] = 200.;
+         multiplicityBinLimitsArray[2] = 500.;
+         multiplicityBinLimitsArray[3] = 1000.;
+         multiplicityBinLimitsArray[4] = 1500.;
+         multiplicityBinLimitsArray[5] = 3000.;
+       }
        fBGEventHandler = new AliGammaConversionBGHandler(9,6,nEventsForBGCalculation);
       }
       else{
@@ -376,6 +385,13 @@ void AliV0Reader::Initialize(){
        multiplicityBinLimitsArray[2] = 4;
        multiplicityBinLimitsArray[3] = 5;
        multiplicityBinLimitsArray[4] = 9999;
+       if(fIsHeavyIon){
+         multiplicityBinLimitsArray[0] = 2;
+         multiplicityBinLimitsArray[1] = 10;
+         multiplicityBinLimitsArray[2] = 30;
+         multiplicityBinLimitsArray[3] = 50;
+         multiplicityBinLimitsArray[4] = 9999;
+       }
 
        fBGEventHandler = new AliGammaConversionBGHandler(9,5,nEventsForBGCalculation);
       }

diff --git a/PWG4/GammaConv/AliV0Reader.h b/PWG4/GammaConv/AliV0Reader.h
index 6fd36252dfeafddb7ccf1fc1292813713377f0d2..661d5864a347acb60f9206138d697154bd1d72f9 100644 (file)
--- a/PWG4/GammaConv/AliV0Reader.h
+++ b/PWG4/GammaConv/AliV0Reader.h
@@ -832,7 +832,9 @@ class AliV0Reader : public TObject {
   static AliESDpid* GetESDpid() {return fgESDpid;}
 
   void SetUseChargedTracksMultiplicityForBG(Bool_t flag){fUseChargedTrackMultiplicityForBG = flag;}
-  
+  void SetIsHeavyIon(Int_t isHeavyIon) {fIsHeavyIon=isHeavyIon;}
+  Int_t GetIsHeavyIon() const { return fIsHeavyIon;}
+ 
   Int_t GetPindex(Int_t i) {return fV0Pindex.at(i);}
   Int_t GetNindex(Int_t i) {return fV0Nindex.at(i);}
 
@@ -963,8 +965,9 @@ class AliV0Reader : public TObject {
   
   Bool_t fUseChargedTrackMultiplicityForBG;
   Int_t fNumberOfGoodV0s;
+  Int_t fIsHeavyIon;
 
-  ClassDef(AliV0Reader,16)
+  ClassDef(AliV0Reader,17)
 };
 
 inline void AliV0Reader::InitESDpid(Int_t type)

diff --git a/PWG4/macros/ConfigGammaConversion.C b/PWG4/macros/ConfigGammaConversion.C
index 96271a911e5d03be5e232faf9de74356942fd316..e5aeffd1d8547d9477aa7e68392022eefdb7bb2b 100644 (file)
--- a/PWG4/macros/ConfigGammaConversion.C
+++ b/PWG4/macros/ConfigGammaConversion.C
@@ -15,7 +15,7 @@
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-const int c_array_size = 23;
+const int c_array_size = 26;
 
 class AliAnalysisDataContainer;
 class AliGammaConversionHistograms;
@@ -48,7 +48,7 @@ Bool_t kGCdoBGProbability=kFALSE;
 //Svein 
 Bool_t kGCRunGammaJetTask = kFALSE;
 /** ---------------------------------- define cuts here ------------------------------------*/
-TString kGCAnalysisCutSelectionId="90035620401003321022000"; // do not change here, use -set-cut-selection in argument instead
+TString kGCAnalysisCutSelectionId="90035620401003321022000000"; // do not change here, use -set-cut-selection in argument instead
 
 Int_t kGCNEventsForBGCalculation=20;
 
@@ -107,6 +107,12 @@ Bool_t kGCSelectV0AND = kFALSE;
 Bool_t kGCUseMultiplicity = kFALSE;
 Int_t  kGCUseMultiplicityBin=0;
 
+Int_t kGCIsHeavyIon = 0;
+Int_t kGCUseCentrality = 0;
+Int_t  kGCUseCentralityBin = 0;
+
+
+
 /** ---------------------------------- define pi0 dalitz cuts here ------------------------------------*/
 
 Bool_t kGCRunStandalone    = kTRUE;
@@ -340,6 +346,11 @@ Bool_t kGCplotESDConvGammaEtavsChi2 = kTRUE;
 
 
 Bool_t kGCplotESDTrueDalitzContaminationR    = kTRUE;
+Bool_t kGCplotESDTruePi0DalitzContaminationR = kTRUE;
+Bool_t kGCplotESDTrueEtaDalitzContaminationR = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialContaminationR = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialElecContaminationR = kTRUE;
+
 Bool_t kGCplotESDTrueConvGammaEnergy         = kFALSE;
 Bool_t kGCplotESDTrueConvGammaPt             = kTRUE;
 Bool_t kGCplotESDTrueConvGammaEta            = kTRUE;
@@ -539,9 +550,9 @@ Double_t kGClastXBinESDtrk = 9999.5;
 
 
 //EventQuality-plot
-Int_t kGCnXBinsEvtQ= 8;
+Int_t kGCnXBinsEvtQ= 9;
 Double_t kGCfirstXBinEvtQ=-1.5;
-Double_t kGClastXBinEvtQ=6.5;
+Double_t kGClastXBinEvtQ=7.5;
 
 //R-plots
 Int_t kGCnXBinsR = 400;
@@ -1550,6 +1561,15 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
   gammaconversion->SetUseMultiplicity(kGCUseMultiplicity);
   gammaconversion->SetUseMultiplicityBin(kGCUseMultiplicityBin);
 
+  v0Reader->SetIsHeavyIon(kGCIsHeavyIon);
+  gammaconversion->SetUseCentrality(kGCUseCentrality);
+  if(kGCUseCentrality){
+    gammaconversion->SetUseCentralityBin(kGCUseCentralityBin);
+  }
+
+
+
+
   // for CF
   gammaconversion->SetCFManager(man);
   gammaconversion->SetDoCF(kGCrunCF);
@@ -1895,7 +1915,11 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
 
                
     if(kGCplotESDTrueDalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueDalitzContamination_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
-               
+    if(kGCplotESDTruePi0DalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvDalitzPi0_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+    if(kGCplotESDTrueEtaDalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvDalitzEta_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+    if(kGCplotESDTrueCombinatorialContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorial_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+    if(kGCplotESDTrueCombinatorialElecContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorialElec_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+
     if(kGCplotESDTrueConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
     if(kGCplotESDTrueConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
     if(kGCplotESDTrueConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
@@ -2461,7 +2485,13 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   Int_t removePileUp=array[20];
   Int_t selectV0AND=array[21];
   Int_t multiplicityBin=array[22];
+  Int_t isHeavyIon=array[23];
+  Int_t useCentrality=array[24];
+  Int_t centralityBin=array[25];
 
+  cout<<"CentralityBin::"<< centralityBin <<endl;
+  cout<<"Use Centrality::"<< useCentrality <<endl;
+  cout<<"Heavy Ion::"<< isHeavyIon<<endl;
   cout<<"Multiplicity Bin::"<< multiplicityBin<<endl;
   cout<<"Select V0AND::"<< selectV0AND<<endl;
   cout<<"Remove PileUp::"<< removePileUp<<endl;
@@ -2912,6 +2942,9 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   case 3:
     kGCnumberOfRotationEventsForBG = 20;
     break;
+  case 4:
+    kGCnumberOfRotationEventsForBG = 2;
+    break;
 
   default:
     return iResult;
@@ -2967,6 +3000,66 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   default:
     return iResult;
   }
+
+  switch(isHeavyIon){
+  case 0:
+    kGCIsHeavyIon=0;
+    break;
+  case 1:
+    kGCIsHeavyIon=1;
+    break;
+   default:
+    return iResult;
+  }
+
+  switch(useCentrality){
+  case 0:
+    kGCUseCentrality=0;
+    break;
+  case 1:
+    kGCUseCentrality=1;//    GetCentralityClass10("V0M")
+    break;
+  case 2:
+    kGCUseCentrality=2; //    GetCentralityClass10("CL1")
+    break;
+   default:
+    return iResult;
+  }
+
+  switch(centralityBin){
+  case 0:
+    kGCUseCentralityBin=0;
+    break;
+  case 1:
+    kGCUseCentralityBin=1;
+    break;
+  case 2:
+    kGCUseCentralityBin=2;
+    break;
+  case 3:
+    kGCUseCentralityBin=3;
+    break;
+  case 4:
+    kGCUseCentralityBin=4;
+    break;
+  case 5:
+    kGCUseCentralityBin=5;
+    break;
+  case 6:
+    kGCUseCentralityBin=6;
+    break;
+  case 7:
+    kGCUseCentralityBin=7;
+    break;
+  case 8:
+    kGCUseCentralityBin=8;
+    break;
+  case 9:
+    kGCUseCentralityBin=9;
+    break;
+   default:
+    return iResult;
+  }
   iResult=1;
   return iResult;
 
@@ -3001,6 +3094,9 @@ void string2array(const std::string& number, int a[c_array_size])
         ASSIGNARRAY(20);
         ASSIGNARRAY(21);
         ASSIGNARRAY(22);
+        ASSIGNARRAY(23);
+        ASSIGNARRAY(24);
+        ASSIGNARRAY(25);
   }
 }