extra cut for clusters

[u/mrichter/AliRoot.git] / PWG4 / macros / ConfigGammaConversion.C

diff --git a/PWG4/macros/ConfigGammaConversion.C b/PWG4/macros/ConfigGammaConversion.C
index 1b9f24771e9159962cbf22dbf3d1fb7449cd4d5d..7b049984f9b94f4278c48363ae1490ca74b3e1ee 100644 (file)
--- a/PWG4/macros/ConfigGammaConversion.C
+++ b/PWG4/macros/ConfigGammaConversion.C
@@ -15,11 +15,12 @@
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-const int c_array_size = 10;
+const int c_array_size = 26;
 
 class AliAnalysisDataContainer;
 class AliGammaConversionHistograms;
 class AliAnalysisTaskGammaConversion;
+class AliAnalysisTaskGammaJet;
 
 // set this to a number if you want to analyze a set number of files
 // if it is 0 it will analyze the files listed in the data list
@@ -28,27 +29,46 @@ Int_t kGCnumberOfFilesToAnalyze=0;
 Bool_t kGCrunNeutralMeson = kTRUE;
 Bool_t kGCrunJet          = kFALSE;
 Bool_t kGCrunChic         = kFALSE;
+Bool_t kGCrunDalitz       = kFALSE;
 Bool_t kGCrunCF           = kFALSE;
 Bool_t kGCcalculateBackground = kTRUE;
 Bool_t kGCdoNeutralMesonV0MCCheck =kFALSE;
 Bool_t kGCrunOmegaMeson = kFALSE;
 Bool_t kGCrunRES = kFALSE;
-
+Bool_t kGCRecalculateV0ForGamma = kFALSE;
+Bool_t kGCUseTrackMultiplicityForBG = kTRUE;
+Bool_t kGCMoveParticlesAccordingToVertex = kFALSE;
+Bool_t kGCLowMemoryConsumption = kFALSE;
+Bool_t kGCApplyChi2Cut = kFALSE;
+
+Bool_t kGCUseRotationMethodInBG=kTRUE;
+Int_t kGCnDegreeRotationPMForBG=15;
+Int_t kGCnumberOfRotationEventsForBG=15;
+Bool_t kGCdoBGProbability=kFALSE;
+//Svein 
+Bool_t kGCRunGammaJetTask = kFALSE;
 /** ---------------------------------- define cuts here ------------------------------------*/
+TString kGCAnalysisCutSelectionId="90035620401003321022000000"; // do not change here, use -set-cut-selection in argument instead
 
-TString kGCAnalysisCutSelectionId="9010111000"; // do not cheange here, use -set-cut-selection in argument instead
+Int_t kGCNEventsForBGCalculation=20;
 
 Int_t kGCpidOfNegativeTrack=11;
 Int_t kGCpidOfPositiveTrack=-11;
 
+Double_t kGCmaxVertexZ   = 10.;
 Double_t kGCmaxRCut   = 180.;
+Double_t kGCminRCut   = 2.8;
 Double_t kGCetaCut    = 0.9;
 Double_t kGCptCut     = 0.02;
 Double_t kGCsingleptCut = 0.02;
 Double_t kGCmaxZCut     = 240.;
 Double_t kGCminClsTPCCut= 0.;
+Double_t kGCminClsTPCCutToF= 0.;
 Double_t kGCchi2CutConversion   = 30.;
 Double_t kGCchi2CutMeson   = 50.;
+Double_t kGCalphaCutMeson   = 0.7;
+Double_t kGCalphaMinCutMeson   = 0.0;
+Double_t kGCrapidityCutMeson    = 0.9;
 
 Double_t kGCLineCutZRSlope = tan(2*atan(exp(-kGCetaCut)));
 Double_t kGCLineCutZValue = 7.;
@@ -81,6 +101,43 @@ Double_t kGCprobElectron = 0.000;
 
 Double_t kGCminOpeningAngleGhostCut = 0.005;
 
+Bool_t kGCRemovePileUp = kFALSE;
+
+Bool_t kGCSelectV0AND = kFALSE;
+Bool_t kGCUseMultiplicity = kFALSE;
+Int_t  kGCUseMultiplicityBin=0;
+
+Int_t kGCIsHeavyIon = 0;
+Int_t kGCUseCentrality = 0;
+Int_t kGCUseCentralityBin = 0;
+Int_t kGCUseCorrectedTPCClsInfo = 0;
+
+
+/** ---------------------------------- define pi0 dalitz cuts here ------------------------------------*/
+
+Bool_t kGCRunStandalone    = kTRUE;
+Bool_t kGCUseBayesPID      = kFALSE;
+Bool_t kGCUseTrackIndexCut = kTRUE;
+Bool_t kGCUsePsiPairCut    = kTRUE;
+Bool_t kGCUseMassCut       = kFALSE;
+Bool_t kGCUseGammaCut      = kFALSE;
+Bool_t kGCReadMagFieldSign = kTRUE;
+Bool_t kGCUseAliKF         = kFALSE;
+
+Double_t kGCPsiPairCut                 = 0.45;
+Double_t kGCDeltaPhiCutMin             = 0.;
+Double_t kGCDeltaPhiCutMax             = 0.12;
+Double_t kGCMassCutMin                 = 0.;
+Double_t kGCMassCutMax                 = 0.1;
+Double_t kGCNSigmaBelowElecTPCbethe    = -2.;
+Double_t kGCNSigmaAboveElecTPCbethe    = 3.;
+Double_t kGCNSigmaAbovePionTPCbethe    = 2.;
+Double_t kGCNSigmaAboveKaonTPCbethe    = 2.;
+Double_t kGCNSigmaAboveProtonTPCbethe  = 2.;
+
+Int_t kGCTrkSelectionCriteria          = 1;     // kITSsaTrack=0, kGlobalTrack=1, kITSsaGlobalTrack=2
+// NOTE: for details in the track cuts and defined histograms see AddGammaConvDalitz.C
+
 /** ----------------------------------end define cuts here----------------------------------*/
 
 /** -------------------------------- Phi/R Mapping ---------------------------------------*/
@@ -94,12 +151,21 @@ Double_t kGCmaxPhi      = TMath::Pi();
 /** ------------------------------- end Phi/R Mapping ------------------------------------*/
 
 Bool_t kGCdoOwnXYZCalculation = kFALSE;
+Bool_t kGCdoConstructGamma = kFALSE;
 
-Bool_t kGCWriteStandardAOD =kFALSE; // need to be true for train running? CKB
+/** -------------AOD stuff ---------------------------------------------------------------*/
+TString kGCDeltaAODFilename = "AliAODGammaConversion.root";  //If empty, writes to standard common aod file.
+Bool_t kGCWriteAOD =kTRUE;    // Turn on AOD 
+Bool_t kGCForceAOD = kFALSE;  // Call AliAnalysisManager::SetFillAOD(kTRUE) every ESD event. 
 
 /** ------------------- define which histograms to plot here --------------------------------*/
 /**   NB: to change the bin numbers, see below the histogram flags                           */
 
+Bool_t kGCplotEventQuality              = kTRUE;
+
+
+// MC GAMMA DECAY PLOTS
+Bool_t kGCplotMCGammaFromDecay          = kTRUE;
 // NEUTRAL MESON PLOTS
 Bool_t kGCplotMCConversionR             = kTRUE;
 Bool_t kGCplotMCConversionZR            = kTRUE;
@@ -165,16 +231,22 @@ Bool_t kGCplotMCMotherPtvsEtaConvGammaWithinAcceptance     = kTRUE;
 Bool_t kGCplotMCMotherPtvsRapidConvGammaWithinAcceptance   = kTRUE;
 Bool_t kGCplotMCMotherSpectra                          = kTRUE;
 
+Bool_t kGCplotMCPhysicalPrimaryChargedPt                = kTRUE;
+
 Bool_t kGCplotMCPi0Eta                                 = kTRUE;
 Bool_t kGCplotMCPi0Rapid                                   = kTRUE;
+Bool_t kGCplotMCPi0PtvsRapid                               = kTRUE;
 Bool_t kGCplotMCPi0Phi                                     = kTRUE;
 Bool_t kGCplotMCPi0Pt                                      = kTRUE;
 Bool_t kGCplotMCPi0PtFiducial                              = kTRUE;
 Bool_t kGCplotMCPi0PtWithinAcceptanceFiducial              = kTRUE;
 Bool_t kGCplotMCPi0PtConvGammaWithinAcceptanceFiducial     = kTRUE;
+Bool_t kGCplotMCPi0OpeningPtConvGammaWithinAcceptance      = kTRUE;
+Bool_t kGCplotMCPi0PtGammaPtConvGammaWithinAcceptance = kTRUE;
 Bool_t kGCplotMCPi0Energy                                  = kFALSE;
 Bool_t kGCplotMCPi0Mass                                    = kTRUE;
 Bool_t kGCplotMCPi0Alpha                                   = kTRUE;
+Bool_t kGCplotMCEtaAlpha                                   = kTRUE;
 Bool_t kGCplotMCPi0OpeningAngle                            = kTRUE;
 Bool_t kGCplotMCPi0R                                       = kTRUE;
 Bool_t kGCplotMCPi0ZR                                      = kFALSE;
@@ -202,6 +274,7 @@ Bool_t kGCplotMCPi0SecondaryPtvsRapidConvGammaWithinAcceptance = kTRUE;
 
 Bool_t kGCplotMCEtaEta                                = kTRUE;
 Bool_t kGCplotMCEtaRapid                              = kTRUE;
+Bool_t kGCplotMCEtaPtvsRapid                          = kTRUE;
 Bool_t kGCplotMCEtaPhi                                = kTRUE;
 Bool_t kGCplotMCEtaPt                                 = kTRUE;
 Bool_t kGCplotMCEtaEnergy                             = kFALSE;
@@ -214,12 +287,16 @@ Bool_t kGCplotMCEtaPtvsEtaWithinAcceptance                   = kTRUE;
 Bool_t kGCplotMCEtaPtvsRapidWithinAcceptance      = kTRUE;
 Bool_t kGCplotMCEtaPtvsEtaConvGammaWithinAcceptance   = kTRUE;
 Bool_t kGCplotMCEtaPtvsRapidConvGammaWithinAcceptance = kTRUE;
+Bool_t kGCplotMCEtaOpeningPtConvGammaWithinAcceptance = kTRUE;
+Bool_t kGCplotMCEtaPtGammaPtConvGammaWithinAcceptance = kTRUE;
 Bool_t kGCplotMCEtaZRConvGammaWithinAcceptance = kTRUE;
 
 // Histograms from esd tracks
 Bool_t kGCplotESDConversionR                   = kTRUE;
 Bool_t kGCplotESDConversionZR                  = kTRUE;
 Bool_t kGCplotESDConversionXY                  = kTRUE;
+Bool_t kGCplotESDConversionXYBeamPipe          = kTRUE;
+Bool_t kGCplotESDConversionRPhiBeamPipe        = kTRUE;
 Bool_t kGCplotESDConversionOpeningAngle        = kTRUE;
 Bool_t kGCplotESDConvGammaCosPointingAngle     = kTRUE;
 Bool_t kGCplotESDConvGammaDcaDaugthers         = kTRUE;
@@ -229,6 +306,11 @@ Bool_t kGCplotESDConvGammaEAsymmetryP         = kTRUE;
 Bool_t kGCplotESDConvGammaPAsymmetryP         = kTRUE;
 Bool_t kGCplotESDConvGammaEdEdxP         = kTRUE;
 Bool_t kGCplotESDConvGammaPdEdxP         = kTRUE;
+Bool_t kGCplotESDConvGammaEeProbP         = kTRUE;
+Bool_t kGCplotESDConvGammaPeProbP         = kTRUE;
+Bool_t kGCplotESDConvGammaEmupiProbP         = kTRUE;
+Bool_t kGCplotESDConvGammaPmupiProbP         = kTRUE;
+
 Bool_t kGCplotESDConvGammaQtAlfa         = kTRUE;
 
 
@@ -238,13 +320,19 @@ Bool_t kGCplotESDEEta    = kTRUE;
 Bool_t kGCplotESDEPhi    = kTRUE;
 Bool_t kGCplotESDENTPCClusters = kTRUE;
 Bool_t kGCplotESDENITSClusters = kTRUE;
+Bool_t kGCplotESDENTPCClustersToFP = kTRUE;
+Bool_t kGCplotESDENTPCClustersToFR = kTRUE;
+Bool_t kGCplotESDETPCchi2 = kTRUE;
 
 Bool_t kGCplotESDPEnergy = kFALSE;
 Bool_t kGCplotESDPPt     = kTRUE;
 Bool_t kGCplotESDPEta    = kTRUE;
 Bool_t kGCplotESDPPhi    = kTRUE;
-Bool_t kGCplotESDPNTPCClusters = kTRUE;
+Bool_t kGCplotESDPNTPCClusters = kTRUE; 
 Bool_t kGCplotESDPNITSClusters = kTRUE;
+Bool_t kGCplotESDPNTPCClustersToFP = kTRUE;
+Bool_t kGCplotESDPNTPCClustersToFR = kTRUE;
+Bool_t kGCplotESDPTPCchi2 = kTRUE;
 
 Bool_t kGCplotESDConvGammaEnergy = kFALSE;
 Bool_t kGCplotESDConvGammaPt     = kTRUE;
@@ -261,6 +349,17 @@ 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 kGCplotESDTrueHadronicContaminationR  = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialContaminationPt = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialElecContaminationPt = kTRUE;
+Bool_t kGCplotESDTrueHadronicContaminationPt  = kTRUE;
+
+
+Bool_t kGCplotESDTrueBackground              = kTRUE;
 Bool_t kGCplotESDTrueConvGammaEnergy         = kFALSE;
 Bool_t kGCplotESDTrueConvGammaPt             = kTRUE;
 Bool_t kGCplotESDTrueConvGammaEta            = kTRUE;
@@ -283,7 +382,7 @@ Bool_t kGCplotESDTrueConvGammaEAsymmetryP         = kTRUE;
 Bool_t kGCplotESDTrueConvGammaPAsymmetryP         = kTRUE;
 Bool_t kGCplotESDTrueConvGammaEdEdxP         = kTRUE;
 Bool_t kGCplotESDTrueConvGammaPdEdxP         = kTRUE;
-
+Bool_t kGCplotESDTrueConvGammaQtAlfa         = kTRUE;
 
 Bool_t kGCplotESDTrueConvGammaPtvsChi2       = kTRUE;
 Bool_t kGCplotESDTrueConvGammaEtavsChi2      = kTRUE;
@@ -291,6 +390,7 @@ Bool_t kGCplotESDTrueConvGammaMCPtEta        = kTRUE;
 Bool_t kGCplotESDTrueConversionMCZR          = kFALSE;
 Bool_t kGCplotESDTrueConversionMCXY          = kFALSE;
 
+Bool_t kGCplotESDNoCutAllV0Pt                = kTRUE;
 Bool_t kGCplotESDNoCutConvGammaEnergy         = kFALSE;
 Bool_t kGCplotESDNoCutConvGammaPt             = kTRUE;
 Bool_t kGCplotESDNoCutConvGammaEta            = kTRUE;
@@ -320,6 +420,7 @@ Bool_t kGCplotESDNoCutConvGammaMCPtEta        = kTRUE;
 Bool_t kGCplotESDNoCutConversionMCZR          = kFALSE;
 Bool_t kGCplotESDNoCutConversionMCXY          = kFALSE;
 
+Bool_t kGCplotESDMotherChi2 = kTRUE;
 Bool_t kGCplotESDMotherOpeningAngleGamma = kTRUE;
 Bool_t kGCplotESDMotherEnergy            = kFALSE;
 Bool_t kGCplotESDMotherPt                = kFALSE;
@@ -378,10 +479,16 @@ Bool_t kGCplotESDCutKink          = kTRUE;
 Bool_t kGCplotESDCutPIDProb       = kTRUE;
 Bool_t kGCplotESDCutdedxSigmaElectronLine=kTRUE;
 Bool_t kGCplotESDCutdedxSigmaPionLine=kTRUE;
+Bool_t kGCplotESDCutPionRejectionLowP  =kTRUE;
+Bool_t kGCplotESDCutProtonRejectionLowP=kTRUE;
+Bool_t kGCplotESDCutKaonRejectionLowP  =kTRUE;
+Bool_t kGCplotESDCutQtGammaSelection=kTRUE;
 Bool_t kGCplotESDCutR             = kTRUE;
+Bool_t kGCplotESDCutMinR          = kTRUE;
 Bool_t kGCplotESDCutLine          = kTRUE;
 Bool_t kGCplotESDCutZ             = kTRUE;
 Bool_t kGCplotESDCutMinClsTPC     = kTRUE;
+Bool_t kGCplotESDCutMinClsTPCToF  = kTRUE;
 Bool_t kGCplotESDGoodV0s          = kTRUE;
 Bool_t kGCplotESDAllV0s           = kTRUE;
 Bool_t kGCplotESDAllV0sCurrentFinder = kTRUE;
@@ -391,6 +498,7 @@ Bool_t kGCplotESDCutNDF           = kTRUE;
 Bool_t kGCplotESDCutChi2          = kTRUE;
 Bool_t kGCplotESDCutEta           = kTRUE;
 Bool_t kGCplotESDCutPt            = kTRUE;
+Bool_t kGCplotESDCutSinglePt      = kTRUE;
 Bool_t kGCplotESDTrueConvGammaTrackLength =kFALSE;
 Bool_t kGCplotESDTrueConvGammaTrackLengthVSInvMass =kFALSE;
 
@@ -439,6 +547,23 @@ Bool_t kGCplotImbalanceHdrGam       = kTRUE;
 
 
 /** ----------- Define the binning for the different plot types here -------------------------*/
+// Number of V0s-plot
+Int_t kGCnXBinsNV0        = 1000;
+Double_t kGCfirstXBinNV0  = -0.5;
+Double_t kGClastXBinNV0   =  999.5;
+
+
+// Number of ESD track-Plot
+Int_t kGCnXBinsESDtrk      = 10000;
+Double_t kGCfirstXBinESDtrk= -0.5;
+Double_t kGClastXBinESDtrk = 9999.5;
+
+
+//EventQuality-plot
+Int_t kGCnXBinsEvtQ= 9;
+Double_t kGCfirstXBinEvtQ=-1.5;
+Double_t kGClastXBinEvtQ=7.5;
+
 //R-plots
 Int_t kGCnXBinsR = 400;
 Double_t kGCfirstXBinR = 0.;
@@ -460,6 +585,24 @@ Int_t kGCnYBinsXY = 800;
 Double_t kGCfirstYBinXY = -200.;
 Double_t kGClastYBinXY = 200.;
 
+//XY-plots-BeamPipe
+Int_t kGCnXBinsXYBP = 200;
+Double_t kGCfirstXBinXYBP = -10.;
+Double_t kGClastXBinXYBP = 10.;
+Int_t kGCnYBinsXYBP = 200;
+Double_t kGCfirstYBinXYBP = -10.;
+Double_t kGClastYBinXYBP = 10.;
+
+//Rphi-plots-BeamPipe
+Int_t kGCnXBinsRPhiBP = 200;
+Double_t kGCfirstXBinRPhiBP = -TMath::Pi();
+Double_t kGClastXBinRPhiBP = TMath::Pi();
+Int_t kGCnYBinsRPhiBP = 200;
+Double_t kGCfirstYBinRPhiBP = 0.;
+Double_t kGClastYBinRPhiBP = 10.;
+
+
+
 //OpenAngle-plots
 Int_t kGCnXBinsOpeningAngle = 400;
 Double_t kGCfirstXBinOpeningAngle = 0.;
@@ -493,7 +636,7 @@ Double_t kGClastXBinEnergy = 50.;
 
 //P-plots
 Int_t kGCnXBinsP = 200;
-Double_t kGCfirstXBinP = 0.;
+Double_t kGCfirstXBinP = 0.05;
 Double_t kGClastXBinP = 50.;
 
 //dEdx-plots
@@ -501,6 +644,11 @@ Int_t kGCnYBinsdEdx = 200;
 Double_t kGCfirstYBindEdx = 0.;
 Double_t kGClastYBindEdx = 200.;
 
+//EProb-plots
+Int_t kGCnYBinsEProb = 200;
+Double_t kGCfirstYBinEProb = 0.;
+Double_t kGClastYBinEProb = 1.;
+
 //Qt-plots
 Int_t kGCnYBinsQt = 250;
 Double_t kGCfirstYBinQt = 0.;
@@ -544,6 +692,15 @@ Int_t kGCnXBinsNITSClusters = 7;
 Double_t kGCfirstXBinNITSClusters = -0.5;
 Double_t kGClastXBinNITSClusters = 6.5;
 
+//TPCcluster to Findable-plots
+Int_t kGCnYBinsClsToF = 200;
+Double_t kGCfirstYBinClsToF = 0.;
+Double_t kGClastYBinClsToF = 2.0;
+
+//TPCchi2 -plots
+Int_t kGCnXBinsTPCchi2 = 100;
+Double_t kGCfirstXBinTPCchi2 = 0.;
+Double_t kGClastXBinTPCchi2 = 10;
 
 
 //Mapping-plots
@@ -556,17 +713,17 @@ Double_t kGClastYBinMapping = 2;
 
 //ResolutionPlots
 //RESdPt
-Int_t kGCnXBinsResdPt=1000;
+Int_t kGCnXBinsResdPt=500;
 Int_t kGCfirstXBinResdPt= 0;
 Int_t kGClastXBinResdPt=100;
-Int_t kGCnYBinsResdPt=500;
+Int_t kGCnYBinsResdPt=200;
 Int_t kGCfirstYBinResdPt= -10;
 Int_t kGClastYBinResdPt=10;
 
 //RESdR
-Int_t kGCnXBinsResdR=500;
+Int_t kGCnXBinsResdR=400;
 Int_t kGCfirstXBinResdR= 0;
-Int_t kGClastXBinResdR=250;
+Int_t kGClastXBinResdR=200;
 Int_t kGCnYBinsResdR=100;
 Int_t kGCfirstYBinResdR= -25;
 Int_t kGClastYBinResdR=25;
@@ -608,7 +765,7 @@ Double_t kGClastXBinGammaMass = 1.;
 Int_t kGCnXBinsPi0Mass = 1000;
 Double_t kGCfirstXBinPi0Mass = 0.;
 Double_t kGClastXBinPi0Mass = 1.;
-Double_t kGCfirstXBinPi0Alpha = -1.;
+Double_t kGCfirstXBinPi0Alpha = 0.;
 Double_t kGClastXBinPi0Alpha = 1.;
 
 
@@ -623,6 +780,7 @@ Double_t kGCfirstXBinGammaWidth = 0.;
 Double_t kGClastXBinGammaWidth = 1.;
 
 //GammaChi2-plots
+Int_t kGCnXBinsMesonChi2 = 200;
 Int_t kGCnXBinsGammaChi2 = 100;
 Double_t kGCfirstXBinGammaChi2 = 0;
 Double_t kGClastXBinGammaChi2 = 200.;
@@ -633,14 +791,15 @@ Double_t kGCfirstXBinGammaNDF = 0.;
 Double_t kGClastXBinGammaNDF = 10.;
 
 //Spectra-plots
-Int_t kGCnXBinsSpectra = 1000;
+Int_t kGCnXBinsSpectra = 500;
 Double_t kGCfirstXBinSpectra = 0.;
 Double_t kGClastXBinSpectra = 1.;
 Int_t kGCnYBinsSpectra = 250;
 Double_t kGCfirstYBinSpectra = 0.;
 Double_t kGClastYBinSpectra = 25.;
 
-Double_t kGCfirstXBinAlpha = -1.;
+Double_t kGCfirstXBinAlphaG = -1.;
+Double_t kGCfirstXBinAlpha = 0.;
 Double_t kGClastXBinAlpha = 1.;
 
 //track length plots
@@ -648,6 +807,16 @@ Int_t kGCnXBinsTrackLength = 1000;
 Double_t kGCfirstXBinTrackLength = 0;
 Double_t kGClastXBinTrackLength = 500;
 
+/////////Pi0 Dalitz decay AnalysisTask ///////////////////////////////////
+
+Int_t kGCnXBinsDalitzMass = 4000;
+Double_t kGCfirstXBinDalitzMass = 0.;
+Double_t kGClastXBinDalitzMass = 4.;
+
+Int_t kGCnXBinsPi0DalitzMass = 4000;
+Double_t kGCfirstXBinPi0DalitzMass = 0.;
+Double_t kGClastXBinPi0DalitzMass = 4.;
+
 /////////Chic_Analysis///////////////////////////////////
 Int_t kGCnXBinsEPt = 1000;
 Double_t kGCfirstXBinEPt = 0.;
@@ -739,6 +908,7 @@ Bool_t kGCusePWG4PartCorr = kTRUE;
 
 /** Flag to enable running on train  */
 Bool_t kGCrunOnTrain = kFALSE;
+Bool_t kGCrunOnGsiTrain = kFALSE;
 
 /** ------------------------------ Monte Carlo flag -----------------------------------------*/
 Bool_t kGCdoMCTruth = kTRUE;
@@ -756,11 +926,30 @@ Bool_t kGCuseESDTrack   = kFALSE;
 /**------------------------------Flag to apply dEdx cut base on sigmas to electron line----------*/
 Bool_t kGCdodEdxSigmaCut= kTRUE;
 /**------------------------------end Flag to apply NsigmadEdx cut ----------*/
+
 Double_t kGCPIDnSigmaAboveElectronLine=5;
 Double_t kGCPIDnSigmaBelowElectronLine=-3;
 Double_t kGCPIDnSigmaAbovePionLine=0;
-Double_t kGCPIDMinPnSigmaAbovePionLine=1;
- 
+Double_t kGCPIDMinPnSigmaAbovePionLine=1.;
+Double_t kGCPIDMaxPnSigmaAbovePionLine=3.;
+
+/**------- Flag to apply rejection at LowP of Kaons, protons , pions------------*/
+Bool_t kGCdoPionRejectionLowP=kTRUE;
+Bool_t kGCdoKaonRejectionLowP=kTRUE;
+Bool_t kGCdoProtonRejectionLowP=kTRUE;
+/**---------------------------------------*/
+
+Double_t kGCPIDnSigmaAtLowPAroundKaonLine=0;
+Double_t kGCPIDnSigmaAtLowPAroundProtonLine=0;
+Double_t kGCPIDnSigmaAtLowPAroundPionLine=0;
+
+Double_t kGCPIDMinPKaonRejectionLowP=1.5;
+Double_t kGCPIDMinPProtonRejectionLowP=2.;
+Double_t kGCPIDMinPPionRejectionLowP=0.5;
+
+
+Bool_t kGCdoQtGammaSelection=kTRUE;
+Double_t kGCQtMax=100.;
 
 
 
@@ -807,6 +996,35 @@ Bool_t scanArguments(TString arguments){
       else if (argument.CompareTo("-bg-off") == 0){
        kGCcalculateBackground =kFALSE;
       }
+      else if (argument.CompareTo("-bg-prob-off") == 0){
+       kGCdoBGProbability = kFALSE;
+      }
+      else if (argument.CompareTo("-bg-prob-on") == 0){
+       kGCdoBGProbability = kTRUE;
+      }
+      else if (argument.CompareTo("-bg-rotation-off") == 0){
+       kGCUseRotationMethodInBG = kFALSE;
+      }
+      else if (argument.CompareTo("-use-v0-multiplicity") == 0){
+       kGCUseTrackMultiplicityForBG = kFALSE;
+      }
+      else if (argument.CompareTo("-apply-chi2-cut") == 0){
+       kGCApplyChi2Cut = kTRUE;
+      }
+      else if(argument.CompareTo("-set-number-of-rotations") == 0){
+       if((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+       kGCnumberOfRotationEventsForBG = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+      }
+      else if(argument.CompareTo("-set-number-of-degrees") == 0){
+       if((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+       kGCnDegreeRotationPMForBG = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+      }
+      else if (argument.CompareTo("-low-memory") == 0){
+       kGCLowMemoryConsumption = kTRUE;
+      }
+      else if (argument.CompareTo("-move-bg-vertex") == 0){
+       kGCMoveParticlesAccordingToVertex = kTRUE;
+      }
       else if (argument.CompareTo("-check-neutralmeson-pi0s") == 0){
        kGCdoNeutralMesonV0MCCheck=kTRUE;
       }
@@ -819,18 +1037,24 @@ Bool_t scanArguments(TString arguments){
       }
       else if (argument.CompareTo("-run-on-train") == 0){
        cout<<"Running on train"<<endl;
-       kGCWriteStandardAOD=kTRUE;
+       //kGCWriteStandardAOD=kTRUE;
+       kGCDeltaAODFilename="";
        kGCrunOnTrain = kTRUE;
       }
       else if (argument.CompareTo("-run-on-gsi-train") == 0){
        cout<<"Running on gsi train"<<endl;
-       kGCWriteStandardAOD=kFALSE;
+       //kGCWriteStandardAOD=kFALSE;
        kGCrunOnTrain = kTRUE;
+       kGCrunOnGsiTrain = kTRUE;
       }
       else if (argument.CompareTo("-run-jet") == 0){
        cout<<"Running jet analysis"<<endl;
        kGCrunJet = kTRUE;
       }
+      else if (argument.CompareTo("-run-gamma-jet-task") == 0){
+       cout<<"Running gamma jet task"<<endl;
+       kGCRunGammaJetTask= kTRUE;
+      }
       else if (argument.CompareTo("-run-neutralmeson") == 0){
        cout<<"Running neutral meson analysis"<<endl;
        kGCrunNeutralMeson = kTRUE;
@@ -847,6 +1071,10 @@ Bool_t scanArguments(TString arguments){
        cout<<"Running Chi_c analysis"<<endl;
        kGCrunChic = kTRUE;
       }
+      else if (argument.CompareTo("-run-dalitz") == 0){
+       cout<<"Running Dalitz analysis"<<endl;
+       kGCrunDalitz = kTRUE;
+      }
       else if (argument.CompareTo("-run-cf") == 0){
        cout<<"Running CF"<<endl;
        kGCrunCF = kTRUE;
@@ -855,6 +1083,10 @@ Bool_t scanArguments(TString arguments){
        cout<<"Running Resolution"<<endl;
        kGCrunRES = kTRUE;
       }
+      else if (argument.CompareTo("-run-recalculateV0") == 0){
+       cout<<"Running RecalculateV0ForGamma"<<endl;
+       kGCRecalculateV0ForGamma=kTRUE;
+      }
       else if (argument.CompareTo("-jet-off") == 0){
        cout<<"Skipping jet analysis"<<endl;
        kGCrunJet = kFALSE;
@@ -883,6 +1115,23 @@ Bool_t scanArguments(TString arguments){
        cout<<"Switching on use own xyz calculation"<<endl;
        kGCdoOwnXYZCalculation = kTRUE;
       }
+      else if (argument.CompareTo("-use-ConstructGamma") == 0){
+       cout<<"Switching on use ConstructGamma and OFF own xyz calculation"<<endl;
+       kGCdoOwnXYZCalculation = kFALSE;
+       kGCdoConstructGamma = kTRUE;
+      }
+      else if (argument.CompareTo("-no-aod") == 0){
+       cout<<"Turning off AOD"<<endl;
+       kGCWriteAOD = kFALSE;
+      }
+      else if (argument.CompareTo("-force-aod") == 0){
+       cout<<"Turning on FillAOD = kTRUE every event; If running in common train this should probably not be done!!!"<<endl;
+       kGCForceAOD = kTRUE;
+      }
+      else if (argument.CompareTo("-standard-aod") == 0){
+       cout<<"Writing to standard AOD, will only work on train"<<endl;
+       kGCDeltaAODFilename = "";
+      }
       else if(argument.CompareTo("-append-to-output-file") == 0){
        if((bMissingParam=(++i>=pTokens->GetEntries()))) break;
        kGCoutputFileAppendix = TString("_")+((TObjString*)pTokens->At(i))->GetString();
@@ -930,8 +1179,8 @@ void SetVersionLibrary(){
 }
 
 
+AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnalysisDataContainer *cin_esd=NULL){
 
-AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnalysisDataContainer *cin_esd=NULL){ 
                                                      
        
   
@@ -972,7 +1221,7 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
     cout<<"Number Of files to analyze: "<<kGCnumberOfFilesToAnalyze<<endl;
                
     build();//build (if necessary) and load the libraries needed
-
+    LoadLibraries();
     gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C"); // load the CreateChain macro
   }
                
@@ -1044,7 +1293,8 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
     for(int i = 0;i<nstep;i++){
       TObjArray *tmp = new TObjArray(0);
       man->SetParticleCutsList(i,tmp) ;
-    } 
+    }
+
     // end ---------------------------------------------------------------------------
                
                
@@ -1093,15 +1343,7 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
     }
   }
        
-  // Define Output Event Handler and ad
-  if(kGCrunOnTrain == kFALSE){
-    if(kGCWriteStandardAOD == kTRUE){
-      AliAODHandler* aodHandler = new AliAODHandler();
-      TString fileOutAOD = "AOD_"+ kGCoutputFileName + kGCoutputFileAppendix + ".root";
-      aodHandler->SetOutputFileName(fileOutAOD);
-      mgr->SetOutputEventHandler (aodHandler);
-    }
-  }
+
        
   if(kGCrunOnTrain == kFALSE){
     mgr->SetInputEventHandler  (inpHandler);
@@ -1112,28 +1354,30 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
        
   // Declare Common Input Tchain
   AliAnalysisDataContainer *cinput1 = NULL;
+  
   if(kGCusePWG4PartCorr){
+  
     if(kGCrunOnTrain == kFALSE){
       cinput1 = mgr->CreateContainer("GammaConvChain",TChain::Class(),AliAnalysisManager::kInputContainer);
-    }
-    else{
+    
+    } else{
       cinput1 = cin_esd;
+    
     }
   }
   else{
       cinput1 = mgr->GetCommonInputContainer();
   }
        
-  // Common Output Tree in common â\80\98defaultâ\80\99 output file
+  // Common Output Tree in common ??????default?????? output file
   // CKB kGCusePWG4PartCorr and writestandard are not mutually exclusive?
   AliAnalysisDataContainer *coutput1 = NULL;
-  if(kGCusePWG4PartCorr){
-    //    coutput1 = mgr->CreateContainer("GammaConvTree",TTree::Class(),AliAnalysisManager::kOutputContainer, "default");
-    coutput1 = mgr->CreateContainer("GammaConvTree",TTree::Class(),AliAnalysisManager::kOutputContainer, "default");
-  }
-  else{
-    if(kGCWriteStandardAOD){
+
+  if(kGCWriteAOD) {
+    if(kGCrunOnTrain && !(kGCrunOnGsiTrain)) {
       coutput1 = mgr->GetCommonOutputContainer();
+    } else {
+      coutput1 = mgr->CreateContainer("GammaConvTree",TTree::Class(),AliAnalysisManager::kOutputContainer, "default");  
     }
   }
        
@@ -1151,24 +1395,23 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
   cout<<"Analyis cut selection ID is: "<<kGCAnalysisCutSelectionId.Data()<<endl;
   //  outputfile += Form(":PWG4_GammaConversion_%s",kGCAnalysisCutSelectionId.Data());
   outputfile += Form(":PWG4_GammaConversion");
-  /*  
-  // this is not really needed
-  if(kGCrunNeutralMeson==kTRUE) outputfile +="1";  else outputfile +="0";
 
-  if(kGCrunJet==kTRUE) outputfile +="1"; else outputfile +="0";
+//   if(kGCrunNeutralMeson==kTRUE) outputfile +="1";  else outputfile +="0";
+
+//   if(kGCrunJet==kTRUE) outputfile +="1"; else outputfile +="0";
 
-  if(kGCrunChic==kTRUE) outputfile +="1"; else outputfile +="0";
+//   if(kGCrunChic==kTRUE) outputfile +="1"; else outputfile +="0";
 
-  if(kGCrunCF==kTRUE) outputfile +="1"; else outputfile +="0";
+//   if(kGCrunCF==kTRUE) outputfile +="1"; else outputfile +="0";
 
-  if(kGCcalculateBackground==kTRUE) outputfile +="1"; else outputfile +="0";
+//   if(kGCcalculateBackground==kTRUE) outputfile +="1"; else outputfile +="0";
 
-  if(kGCdoNeutralMesonV0MCCheck==kTRUE) outputfile +="1"; else outputfile +="0";
+//   if(kGCdoNeutralMesonV0MCCheck==kTRUE) outputfile +="1"; else outputfile +="0";
 
-  if(kGCrunOmegaMeson==kTRUE) outputfile +="1"; else outputfile +="0";
+//   if(kGCrunOmegaMeson==kTRUE) outputfile +="1"; else outputfile +="0";
+
+//   if(kGCrunRES==kTRUE) outputfile +="1"; else outputfile +="0";
 
-  if(kGCrunRES==kTRUE) outputfile +="1"; else outputfile +="0";
-  */
   outputfile += Form("_%s",kGCAnalysisCutSelectionId.Data());
 
   cout<<"Ouput file::"<<  outputfile <<endl;
@@ -1190,6 +1433,7 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
        
 
   if(!SetAnalysisCutSelection(kGCAnalysisCutSelectionId)){
+    cout<<"Error in analysis cut selection"<<endl;
     return 0;
   }
        
@@ -1201,18 +1445,25 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
   else if(kGCuseESDTrack){
     v0Reader->UseESDTrack();
   }
+
+  v0Reader->SetMaxVertexZ(kGCmaxVertexZ);
   v0Reader->SetNegativeTrackPID(kGCpidOfNegativeTrack);
   v0Reader->SetPositiveTrackPID(kGCpidOfPositiveTrack);
   v0Reader->SetMaxRCut(kGCmaxRCut);
+  v0Reader->SetMinRCut(kGCminRCut);
   v0Reader->SetEtaCut(kGCetaCut);
+  v0Reader->SetRapidityMesonCut(kGCrapidityCutMeson);
   v0Reader->SetPtCut(kGCptCut);
   v0Reader->SetSinglePtCut(kGCsingleptCut);
   v0Reader->SetLineCutZRSlope(kGCLineCutZRSlope);
   v0Reader->SetLineCutZValue(kGCLineCutZValue);        
   v0Reader->SetMaxZCut(kGCmaxZCut);    
   v0Reader->SetMinClsTPCCut(kGCminClsTPCCut);  
+  v0Reader->SetMinClsTPCCutToF(kGCminClsTPCCutToF);    
   v0Reader->SetChi2CutConversion(kGCchi2CutConversion);
   v0Reader->SetChi2CutMeson(kGCchi2CutMeson);
+  v0Reader->SetAlphaCutMeson(kGCalphaCutMeson);
+  v0Reader->SetAlphaMinCutMeson(kGCalphaMinCutMeson);
   v0Reader->SetPIDProbability(kGCprobElectron);
   v0Reader->SetXVertexCut(kGCxVertexCut);
   v0Reader->SetYVertexCut(kGCyVertexCut);
@@ -1221,7 +1472,7 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
   v0Reader->SetUseImprovedVertex(kGCuseImprovedVertex);
   v0Reader->SetDoMCTruth(kGCdoMCTruth);
   v0Reader->SetUseOwnXYZCalculation(kGCdoOwnXYZCalculation);
-
+  v0Reader->SetUseChargedTracksMultiplicityForBG(kGCUseTrackMultiplicityForBG);
   // for CF
   v0Reader->SetCFManager(man);
        
@@ -1231,9 +1482,26 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
   v0Reader->SetPIDnSigmaBelowElectronLine(kGCPIDnSigmaBelowElectronLine);
   v0Reader->SetPIDnSigmaAbovePionLine(kGCPIDnSigmaAbovePionLine);
   v0Reader->SetPIDMinPnSigmaAbovePionLine(kGCPIDMinPnSigmaAbovePionLine);
+  v0Reader->SetPIDMaxPnSigmaAbovePionLine(kGCPIDMaxPnSigmaAbovePionLine);
   v0Reader->SetOnFlyFlag(kGCUseOnFlyV0Finder);
   v0Reader->SetCalculateBackground(kGCcalculateBackground);
 
+  // for the rejection at LowP based on Dedx signal
+
+  v0Reader->SetDoKaonRejectionLowP(kGCdoKaonRejectionLowP);
+  v0Reader->SetDoProtonRejectionLowP(kGCdoProtonRejectionLowP);
+  v0Reader->SetDoPionRejectionLowP(kGCdoPionRejectionLowP);
+  v0Reader->SetPIDnSigmaAtLowPAroundKaonLine(kGCPIDnSigmaAtLowPAroundKaonLine);
+  v0Reader->SetPIDnSigmaAtLowPAroundProtonLine(kGCPIDnSigmaAtLowPAroundProtonLine);
+  v0Reader->SetPIDnSigmaAtLowPAroundPionLine(kGCPIDnSigmaAtLowPAroundPionLine);
+  v0Reader->SetPIDMinPKaonRejectionLowP(kGCPIDMinPKaonRejectionLowP);
+  v0Reader->SetPIDMinPProtonRejectionLowP(kGCPIDMinPProtonRejectionLowP);
+  v0Reader->SetPIDMinPPionRejectionLowP(kGCPIDMinPPionRejectionLowP);
+  v0Reader->SetDoQtGammaSelection(kGCdoQtGammaSelection);
+  v0Reader->SetQtMax(kGCQtMax);
+  kGCNEventsForBGCalculation= kGCnumberOfRotationEventsForBG;
+  cout<< "number of Events used for mixing::"<<kGCNEventsForBGCalculation<<endl;
+  v0Reader->SetNEventsForBG(kGCNEventsForBGCalculation);
 
   // Create the GammaConversionTask
 
@@ -1260,6 +1528,7 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
   gammaconversion->SetEtaWidth(kGCetaWidth);
        
   gammaconversion->SetMinOpeningAngleGhostCut(kGCminOpeningAngleGhostCut);
+  
        
   Double_t lowPtMapping=0.4;
   Double_t highPtMapping=1.5;
@@ -1282,25 +1551,112 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
   gammaconversion->SetDoJet(kGCrunJet);
   gammaconversion->SetDoChic(kGCrunChic);
   gammaconversion->SetDoOmegaMeson(kGCrunOmegaMeson);
+  gammaconversion->SetRecalculateV0ForGamma(kGCRecalculateV0ForGamma);
+  gammaconversion->SetUseChargedTracksMultiplicityForBG(kGCUseTrackMultiplicityForBG);
+  gammaconversion->SetMoveParticleAccordingToVertex(kGCMoveParticlesAccordingToVertex);
+  gammaconversion->SetApplyChi2Cut(kGCApplyChi2Cut);
+  cout<<"NumberOfDegrees in rotatation method set to: "<<kGCnDegreeRotationPMForBG<<endl;
+  gammaconversion->SetPMDegreesBG(kGCnDegreeRotationPMForBG);
+  if(kGCUseRotationMethodInBG){
+    cout<<"Using rotation method for bg."<<endl;
+  }
+  else{
+    cout<<"Using mixed event for bg."<<endl;
+  }
+  if(kGCUseTrackMultiplicityForBG){
+    cout<<"Using track multiplicity for bck"<<endl;
+  }else{
+    cout<<"Using V0 multiplicity for bck"<<endl;
+  }
+  gammaconversion->SetDoRotation(kGCUseRotationMethodInBG);
+  cout<<"Using :"<<kGCnumberOfRotationEventsForBG<<" rotations in bg calculation"<<endl;
+  gammaconversion->SetNumberOfRotationsBG(kGCnumberOfRotationEventsForBG);
+  gammaconversion->SetCheckBGProbability(kGCdoBGProbability);
+
+  gammaconversion->SetRemovePileUp(kGCRemovePileUp);
+  gammaconversion->SetSelectV0AND(kGCSelectV0AND);
+  gammaconversion->SetUseMultiplicity(kGCUseMultiplicity);
+  gammaconversion->SetUseMultiplicityBin(kGCUseMultiplicityBin);
+
+  v0Reader->SetIsHeavyIon(kGCIsHeavyIon);
+  v0Reader->SetUseCorrectedTPCClsInfo(kGCUseCorrectedTPCClsInfo);
+  gammaconversion->SetUseCentrality(kGCUseCentrality);
+  if(kGCUseCentrality){
+    gammaconversion->SetUseCentralityBin(kGCUseCentralityBin);
+  }
+
+
+
 
   // for CF
   gammaconversion->SetCFManager(man);
   gammaconversion->SetDoCF(kGCrunCF);
   v0Reader->SetDoCF(kGCrunCF);
-       
+
   // Add task to the manager 
   mgr->AddTask(gammaconversion);
-       
+
+
+  // Define Output Event Handler and add
+  if(kGCWriteAOD){
+    gammaconversion->SetForceAOD(kGCForceAOD);
+    gammaconversion->SetOutputAODClassName("AliAODConversionParticle");
+    //gammaconversion->SetOutputAODClassName("AliGammaConversionAODObject");
+
+    if( kGCrunOnTrain ) {
+      
+      AliAODHandler * aodHandler = dynamic_cast<AliAODHandler*>(mgr->GetOutputEventHandler());
+      if(!aodHandler) {
+       ::Error("This task requires an AOD handler");
+       return NULL;
+      }
+      
+      gammaconversion->SetDeltaAODFileName(kGCDeltaAODFilename);
+      
+      if(kGCDeltaAODFilename.Length() > 0) {
+       mgr->RegisterExtraFile(kGCDeltaAODFilename.Data());
+      }
+      
+    } else {
+      if(kGCDeltaAODFilename.Length() == 0 ) {
+       cout << "Error:: Need a file name for the AOD"<<endl;
+       return NULL;
+      }
+      AliAODHandler* aodHandler = new AliAODHandler();
+      aodHandler->SetOutputFileName(kGCDeltaAODFilename);
+      aodHandler->SetCreateNonStandardAOD();
+      mgr->SetOutputEventHandler(aodHandler);  
+    }
+  }  else {
+    gammaconversion->SetCreateAOD(kFALSE);
+  }
+
   // Connect I/O to the task
   mgr->ConnectInput (gammaconversion, 0, cinput1);
+  if(mgr->GetCommonOutputContainer())
+    mgr->ConnectOutput(gammaconversion, 0, mgr->GetCommonOutputContainer());
   
-
-  // CKB Output slot 0 is NOT connected if WriteStandardAOD is false?
-  if(kGCWriteStandardAOD){
-    mgr->ConnectOutput(gammaconversion, 0, coutput1);
-  }
   mgr->ConnectOutput(gammaconversion, 1, coutput2);
   mgr->ConnectOutput(gammaconversion, 2, coutput3);
+  
+  if(kGCRunGammaJetTask) {
+    AliAnalysisTaskGammaJet * gammaJetTask = new AliAnalysisTaskGammaJet("GammaJetTask");
+    if(kGCrunOnTrain) {
+      gammaJetTask->SetDeltaAODFileName(kGCDeltaAODFileName);
+    }
+    
+    mgr->ConnectInput(gammaJetTask, 0, cinput1);
+    AliAnalysisDataContainer *coutputgj = mgr->CreateContainer("chistpt", TList::Class(), AliAnalysisManager::kOutputContainer, "AnalysisResultsConvJets.root");
+    mgr->ConnectOutput(gammaJetTask, 1, coutputgj);
+  }
+
+
+  if( kGCrunDalitz ){
+   
+   gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskGammaConvDalitz.C");
+   AddTaskGammaConvDalitz( v0Reader, kGCcalculateBackground, kGCRunStandalone );
+
+  }
 
   if(kGCrunOnTrain == kFALSE){
     if(kGCdataList.IsNull()){
@@ -1332,6 +1688,25 @@ AliAnalysisTaskGammaConversion* ConfigGammaConversion(TString arguments, AliAnal
   return gammaconversion;
 }
 
+void LoadLibraries() {
+                
+  TStopwatch timer;
+  timer.Start();
+  gSystem->Load("libTree.so");
+  gSystem->Load("libGeom");
+  
+  gSystem->Load("libSTEERBase.so");
+  gSystem->Load("libVMC.so");
+  gSystem->Load("libESD.so");
+  gSystem->Load("libAOD.so");
+  gSystem->Load("libANALYSIS.so");
+  gSystem->Load("libANALYSISalice.so");
+  gSystem->Load("libCORRFW.so");
+  gSystem->Load("libPWG4GammaConv.so");
+  
+  //  gSystem->ChangeDirectory(pwd.Data());
+  
+}
 void build() {
        
   TStopwatch timer;
@@ -1339,21 +1714,24 @@ void build() {
   gSystem->Load("libTree.so");
   gSystem->Load("libGeom");
        
-  ////
-  //Setting up ESD.par//
-  ////
-  cout<<"compiling ESD"<<endl;
-  setupPar("ESD");
-  gSystem->Load("libVMC.so");
-  gSystem->Load("libESD.so");
+  TString pwd = gSystem->WorkingDirectory();
        
-  ////
   ////
   //Setting up STEERBase.par//
   ////
   cout<<"compiling STEERBase"<<endl;
   setupPar("STEERBase");
   gSystem->Load("libSTEERBase.so");
+
+
+   ////
+  //Setting up ESD.par//
+  ////
+  cout<<"compiling ESD"<<endl;
+  setupPar("ESD");
+  gSystem->Load("libVMC.so");
+  gSystem->Load("libESD.so");
+
        
   ////
   //Setting up AOD.par//
@@ -1381,7 +1759,7 @@ void build() {
   ////
   cout<<"compiling CORRFW"<<endl;
   setupPar("CORRFW");
-  gSystem->Load("CORRFW.so");
+  gSystem->Load("libCORRFW.so");
        
   ////
   //Setting up PWG4GammaConv.par//
@@ -1389,6 +1767,8 @@ void build() {
   cout<<"compiling PWG4GammaConv"<<endl;
   setupPar("PWG4GammaConv");
   gSystem->Load("libPWG4GammaConv.so");
+  
+  gSystem->ChangeDirectory(pwd.Data());
 }
 
 Int_t setupPar(const char* pararchivename) {
@@ -1500,6 +1880,19 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
 
   }// end kGCrunChic
        
+
+  //---------------------------------------------- Gamma from Decay ----------------------------------------------------
+  if(kGCplotMCGammaFromDecay == kTRUE && kGCdoMCTruth == kTRUE){
+     histograms->AddHistogram("MC_DecayPi0Gamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");  
+     histograms->AddHistogram("MC_DecayRho0Gamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+     histograms->AddHistogram("MC_DecayEtaGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+     histograms->AddHistogram("MC_DecayOmegaGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+     histograms->AddHistogram("MC_DecayK0sGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+     histograms->AddHistogram("MC_DecayEtapGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+     histograms->AddHistogram("MC_DecayPhiGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+     histograms->AddHistogram("MC_DecayAllGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+  }
+
   //---------------------------------------------- Neutral Meson ---------------------------------------------------------
   if(kGCrunNeutralMeson){
                
@@ -1510,6 +1903,11 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
     if(kGCplotESDEPhi == kTRUE){ histograms->AddHistogram("ESD_E_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
     if(kGCplotESDENTPCClusters == kTRUE){ histograms->AddHistogram("ESD_E_nTPCClusters" ,"" , kGCnXBinsNTPCClusters, kGCfirstXBinNTPCClusters, kGClastXBinNTPCClusters, "", "");}
     if(kGCplotESDENITSClusters == kTRUE){ histograms->AddHistogram("ESD_E_nITSClusters" ,"" , kGCnXBinsNITSClusters, kGCfirstXBinNITSClusters, kGClastXBinNITSClusters, "", "");}
+    if(kGCplotESDENTPCClustersToFP== kTRUE){ histograms->AddHistogram("ESD_E_nTPCClustersToFP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+    if(kGCplotESDENTPCClustersToFR== kTRUE){ histograms->AddHistogram("ESD_E_nTPCClustersToFR" ,"" ,kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+    if(kGCplotESDENTPCClustersToFR== kTRUE){ histograms->AddHistogram("ESD_TrueConversion_E_nTPCClustersToFR" ,"" ,kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+    if(kGCplotESDETPCchi2 == kTRUE){ histograms->AddHistogram("ESD_E_TPCchi2" ,"" , kGCnXBinsTPCchi2, kGCfirstXBinTPCchi2, kGClastXBinTPCchi2, "", "");}
+
                
     if(kGCplotESDPEnergy == kTRUE){ histograms->AddHistogram("ESD_P_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
     if(kGCplotESDPPt == kTRUE){ histograms->AddHistogram("ESD_P_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
@@ -1517,7 +1915,11 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
     if(kGCplotESDPPhi == kTRUE){ histograms->AddHistogram("ESD_P_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
     if(kGCplotESDPNTPCClusters == kTRUE){ histograms->AddHistogram("ESD_P_nTPCClusters" ,"" , kGCnXBinsNTPCClusters, kGCfirstXBinNTPCClusters, kGClastXBinNTPCClusters, "", "");}
     if(kGCplotESDPNITSClusters == kTRUE){ histograms->AddHistogram("ESD_P_nITSClusters" ,"" , kGCnXBinsNITSClusters, kGCfirstXBinNITSClusters, kGClastXBinNITSClusters, "", "");}
-               
+    if(kGCplotESDPNTPCClustersToFP== kTRUE){ histograms->AddHistogram("ESD_P_nTPCClustersToFP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);} 
+    if(kGCplotESDPNTPCClustersToFR== kTRUE){ histograms->AddHistogram("ESD_P_nTPCClustersToFR" ,"" ,kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+    if(kGCplotESDPNTPCClustersToFR== kTRUE){ histograms->AddHistogram("ESD_TrueConversion_P_nTPCClustersToFR" ,"" ,kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+    if(kGCplotESDPTPCchi2 == kTRUE){ histograms->AddHistogram("ESD_P_TPCchi2" ,"" , kGCnXBinsTPCchi2, kGCfirstXBinTPCchi2, kGClastXBinTPCchi2, "", "");}
+
     if(kGCplotESDConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
     if(kGCplotESDConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
     if(kGCplotESDConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
@@ -1536,6 +1938,8 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
     if(kGCplotESDConversionR == kTRUE){ histograms->AddHistogram("ESD_Conversion_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
     if(kGCplotESDConversionZR == kTRUE){ histograms->AddHistogram("ESD_Conversion_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
     if(kGCplotESDConversionXY == kTRUE){ histograms->AddHistogram("ESD_Conversion_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
+    if(kGCplotESDConversionXYBeamPipe == kTRUE && kGCLowMemoryConsumption == kFALSE){ histograms->AddHistogram("ESD_Conversion_XY_BeamPipe" ,"" , kGCnXBinsXYBP, kGCfirstXBinXYBP, kGClastXBinXYBP, kGCnYBinsXYBP, kGCfirstYBinXYBP, kGClastYBinXYBP, "", "");}
+    if(kGCplotESDConversionRPhiBeamPipe == kTRUE && kGCLowMemoryConsumption == kFALSE){ histograms->AddHistogram("ESD_Conversion_RPhi_BeamPipe" ,"" , kGCnXBinsRPhiBP, kGCfirstXBinRPhiBP, kGClastXBinRPhiBP, kGCnYBinsRPhiBP, kGCfirstYBinRPhiBP, kGClastYBinRPhiBP, "", "");}
     if(kGCplotESDConversionOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_Conversion_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
 
     if(kGCplotESDConvGammaCosPointingAngle == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_CosPointingAngle" ,"" , kGCnXBinsCosPointingAngle, kGCfirstXBinCosPointingAngle, kGClastXBinCosPointingAngle, "", "");}
@@ -1544,15 +1948,57 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
     if(kGCplotESDConvGammaLikelihoodAP == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_LikelihoodAP" ,"" , kGCnXBinsLikelihoodAP, kGCfirstXBinLikelihoodAP, kGClastXBinLikelihoodAP, "", "");}
     if(kGCplotESDConvGammaEAsymmetryP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_E_AsymmetryP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsAsymmetry, kGCfirstYBinAsymmetry, kGClastYBinAsymmetry,"", "");}
     if(kGCplotESDConvGammaPAsymmetryP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_P_AsymmetryP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsAsymmetry, kGCfirstYBinAsymmetry, kGClastYBinAsymmetry,"", "");}
-    if(kGCplotESDConvGammaEdEdxP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_E_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "");}
-    if(kGCplotESDConvGammaPdEdxP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_P_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "");}
+    if(kGCplotESDConvGammaEdEdxP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_E_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "",0);}
+    if(kGCplotESDConvGammaPdEdxP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_P_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "",0);}
+
+    if(kGCplotESDConvGammaEeProbP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_E_EProbP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsEProb, kGCfirstYBinEProb, kGClastYBinEProb,"", "",0);}
+    if(kGCplotESDConvGammaPeProbP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_P_EProbP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsEProb, kGCfirstYBinEProb, kGClastYBinEProb,"", "",0);}
+    if(kGCplotESDConvGammaEmupiProbP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_E_mupiProbP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsEProb, kGCfirstYBinEProb, kGClastYBinEProb,"", "",0);}
+    if(kGCplotESDConvGammaPmupiProbP== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_P_mupiProbP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsEProb, kGCfirstYBinEProb, kGClastYBinEProb,"", "",0);}
 
-    if(kGCplotESDConvGammaQtAlfa== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_alfa_qt" ,"" ,kGCnXBinsP, kGCfirstXBinAlpha, kGClastXBinAlpha,kGCnYBinsQt, kGCfirstYBinQt, kGClastYBinQt,"", "");}
+    if(kGCplotESDConvGammaQtAlfa== kTRUE){ histograms->AddHistogram("ESD_ConvGamma_alfa_qt" ,"" ,kGCnXBinsP, kGCfirstXBinAlphaG, kGClastXBinAlpha,kGCnYBinsQt, kGCfirstYBinQt, kGClastYBinQt,"", "");}
 
 
                
     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(kGCplotESDTrueHadronicContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvHadronicBck_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+    if(kGCplotESDTrueCombinatorialContaminationPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorial_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+    if(kGCplotESDTrueCombinatorialElecContaminationPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorialElec_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+    if(kGCplotESDTrueHadronicContaminationPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvHadronicBck_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
+
+    if(kGCplotESDTrueBackground){
+       histograms->AddHistogram("ESD_TrueConvCombinatorialDaughter_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");
+       histograms->AddHistogram("ESD_TrueConvHadronicBckDaughter_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");
+       histograms->AddHistogram("ESD_TrueConvCombinatorialPiDaughter_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");
+       histograms->AddHistogram("ESD_TrueConvCombinatorialPiPDaughter_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");
+
+       histograms->AddHistogram("ESD_TrueConvCombinatorialPi_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+       histograms->AddHistogram("ESD_TrueConvCombinatorialPi_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+       histograms->AddHistogram("ESD_TrueConvCombinatorialPiP_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+       histograms->AddHistogram("ESD_TrueConvCombinatorialPiP_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+       histograms->AddHistogram("ESD_TrueConvCombinatorialElecPi_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+       histograms->AddHistogram("ESD_TrueConvCombinatorialElecPi_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+       histograms->AddHistogram("ESD_TrueConvMeson_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+       histograms->AddHistogram("ESD_TrueConvMeson_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+       histograms->AddHistogram("ESD_TrueConvLambda_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+       histograms->AddHistogram("ESD_TrueConvLambda_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+    }
+
+    histograms->AddHistogram("ESD_TrueConvDalitzPi0_SinglePos_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+    histograms->AddHistogram("ESD_TrueConvDalitzPi0_SingleNeg_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+    histograms->AddHistogram("ESD_TrueConvDalitzPi0_SinglePos_kFirst_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+    histograms->AddHistogram("ESD_TrueConvDalitzPi0_SingleNeg_kFirst_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+    histograms->AddHistogram("ESD_TrueConversion_SinglePos_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,  kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,"", "");
+    histograms->AddHistogram("ESD_TrueConversion_SingleNeg_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,  kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+    histograms->AddHistogram("ESD_TrueConversion_SinglePos_kFirst_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+    histograms->AddHistogram("ESD_TrueConversion_SingleNeg_kFirst_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+
+
     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, "", "");}
@@ -1577,16 +2023,16 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
     if(kGCplotESDTrueConvGammaLikelihoodAP == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_LikelihoodAP" ,"" , kGCnXBinsLikelihoodAP, kGCfirstXBinLikelihoodAP, kGClastXBinLikelihoodAP, "", "");}
     if(kGCplotESDTrueConvGammaEAsymmetryP== kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_E_AsymmetryP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsAsymmetry, kGCfirstYBinAsymmetry, kGClastYBinAsymmetry,"", "");}
     if(kGCplotESDTrueConvGammaPAsymmetryP== kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_P_AsymmetryP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsAsymmetry, kGCfirstYBinAsymmetry, kGClastYBinAsymmetry,"", "");}
-    if(kGCplotESDTrueConvGammaEdEdxP== kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_E_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "");}
-    if(kGCplotESDTrueConvGammaPdEdxP== kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_P_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "");}
-
+    if(kGCplotESDTrueConvGammaEdEdxP== kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_E_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "",0);}
+    if(kGCplotESDTrueConvGammaPdEdxP== kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_P_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "",0);}
+    if(kGCplotESDTrueConvGammaQtAlfa== kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_alfa_qt" ,"" ,kGCnXBinsP, kGCfirstXBinAlphaG, kGClastXBinAlpha,kGCnYBinsQt, kGCfirstYBinQt, kGClastYBinQt,"", "");}
                
     if(kGCplotESDTrueConvGammaMCPtEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_MC_Pt_Eta" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
     if(kGCplotESDTrueConversionMCZR == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_MC_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
     if(kGCplotESDTrueConversionMCXY == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_MC_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
                
                
-               
+    if(kGCplotESDNoCutAllV0Pt == kTRUE){ histograms->AddHistogram("ESD_NoCutAllV0_Pt" ,"" , kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");}              
     if(kGCplotESDNoCutConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
     if(kGCplotESDNoCutConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
     if(kGCplotESDNoCutConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
@@ -1613,15 +2059,15 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
     if(kGCplotESDNoCutConvGammaPAsymmetryP== kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_P_AsymmetryP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsAsymmetry, kGCfirstYBinAsymmetry, kGClastYBinAsymmetry,"", "");}
 
 
-    if(kGCplotESDNoCutConvGammaEdEdxP== kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_E_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "");}
-    if(kGCplotESDNoCutConvGammaPdEdxP== kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_P_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "");}
+    if(kGCplotESDNoCutConvGammaEdEdxP== kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_E_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "",0);}
+    if(kGCplotESDNoCutConvGammaPdEdxP== kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_P_dEdxP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "",0);}
 
     if(kGCplotESDNoCutConvGammaMCPtEta == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_MC_Pt_Eta" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
     if(kGCplotESDNoCutConversionMCZR == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_MC_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
     if(kGCplotESDNoCutConversionMCXY == kTRUE){ histograms->AddHistogram("ESD_NoCutConversion_MC_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
                
                
-               
+    if(kGCplotESDMotherChi2 == kTRUE){ histograms->AddHistogram("ESD_Mother_Chi2","" , kGCnXBinsMesonChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
     if(kGCplotESDMotherOpeningAngleGamma == kTRUE){ histograms->AddHistogram("ESD_Mother_GammaDaughter_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
     if(kGCplotESDMotherEnergy == kTRUE){ histograms->AddHistogram("ESD_Mother_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
     if(kGCplotESDMotherPt == kTRUE){ histograms->AddHistogram("ESD_Mother_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
@@ -1634,7 +2080,7 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
     if(kGCplotESDMotherRapid == kTRUE){ histograms->AddHistogram("ESD_Mother_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
                
     for(Int_t z=0;z<8;z++){
-      for(Int_t m=0;m<4;m++){
+      for(Int_t m=0;m<6;m++){
        if(kGCplotESDBackgroundOpeningAngleGamma == kTRUE){ histograms->AddHistogram(Form("%d%dESD_Background_GammaDaughter_OpeningAngle",z,m) ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
        if(kGCplotESDBackgroundEnergy == kTRUE){ histograms->AddHistogram(Form("%d%dESD_Background_Energy",z,m) ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
        if(kGCplotESDBackgroundPt == kTRUE){ histograms->AddHistogram(Form("%d%dESD_Background_Pt",z,m) ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
@@ -1724,10 +2170,10 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
                histograms->AddHistogram("Resolution_E_dPt_Pt_ITS5" ,"" ,kGCnYBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, kGCnYBinsResdPt, kGCfirstYBinResdPt, kGClastYBinResdPt, "", "");
                histograms->AddHistogram("Resolution_E_dPt_Pt_ITS6" ,"" ,kGCnYBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, kGCnYBinsResdPt, kGCfirstYBinResdPt, kGClastYBinResdPt, "", "");
                histograms->AddHistogram("Resolution_E_dPt_Phi" ,"" , kGCnYBinsResdR, -TMath::Pi(), TMath::Pi(), kGCnYBinsResdPt, kGCfirstYBinResdPt, kGClastYBinResdPt, "", "");
-               histograms->AddHistogram("Resolution_E_nTRDtracklets_ESDPt" ,"" ,kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 7.5, -0.5, 8.,"", "");
-               histograms->AddHistogram("Resolution_E_nTRDtracklets_MCPt","" ,kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 7.5, -0.5, 8.,"", "");   
-               histograms->AddHistogram("Resolution_E_nTRDclusters_ESDPt","",kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 200.5, -0.5, 201,"", "");
-               histograms->AddHistogram("Resolution_E_nTRDclusters_MCPt","",kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 200.5, -0.5, 201.,"", "");
+               histograms->AddHistogram("Resolution_E_nTRDtracklets_ESDPt" ,"" ,kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 8, -0.5, 7.5,"", "");
+               histograms->AddHistogram("Resolution_E_nTRDtracklets_MCPt","" ,kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 8, -0.5, 7.5,"", "");    
+               histograms->AddHistogram("Resolution_E_nTRDclusters_ESDPt","",kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 201, -0.5, 200.5,"", "");
+               histograms->AddHistogram("Resolution_E_nTRDclusters_MCPt","",kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 201, -0.5, 200.5,"", "");
                //              histograms->AddHistogram("Resolution_E_TRDsignal_ESDPt","", fV0Reader->GetNegativeTrackPt(), fV0Reader->GetNegativeESDTrack()->GetTRDsignal());
                
                // :::::::::::::::::::::::::::::::::::::::: histograms for positrons :::::::::::::::::::::::::::::::::::::::::::::::::::
@@ -1740,21 +2186,22 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
                histograms->AddHistogram("Resolution_P_dPt_Pt_ITS5" ,"" ,kGCnYBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, kGCnYBinsResdPt, kGCfirstYBinResdPt, kGClastYBinResdPt, "", "");
                histograms->AddHistogram("Resolution_P_dPt_Pt_ITS6" ,"" ,kGCnYBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, kGCnYBinsResdPt, kGCfirstYBinResdPt, kGClastYBinResdPt, "", "");
                histograms->AddHistogram("Resolution_P_dPt_Phi" ,"" , kGCnYBinsResdR, -TMath::Pi(), TMath::Pi(), kGCnYBinsResdPt, kGCfirstYBinResdPt, kGClastYBinResdPt, "", "");
-               histograms->AddHistogram("Resolution_P_nTRDtracklets_ESDPt" ,"" ,kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 7.5, -0.5, 8.,"", "");   
-               histograms->AddHistogram("Resolution_P_nTRDtracklets_MCPt","", kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 7.5, -0.5, 8.,"", "");
-               histograms->AddHistogram("Resolution_P_nTRDclusters_ESDPt","",kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 200.5, -0.5, 201.,"", "");
-               histograms->AddHistogram("Resolution_P_nTRDclusters_MCPt","",kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 200.5,-0.5, 201.0,"", "");
+               histograms->AddHistogram("Resolution_P_nTRDtracklets_ESDPt" ,"" ,kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 8, -0.5, 7.5,"", "");   
+               histograms->AddHistogram("Resolution_P_nTRDtracklets_MCPt","", kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 8, -0.5, 7.5,"", "");
+               histograms->AddHistogram("Resolution_P_nTRDclusters_ESDPt","",kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 201, -0.5, 200.5,"", "");
+               histograms->AddHistogram("Resolution_P_nTRDclusters_MCPt","",kGCnXBinsResdPt, kGCfirstXBinResdPt, kGClastXBinResdPt, 201,-0.5, 200.5,"", "");
                //              histograms->AddHistogram("Resolution_P_TRDsignal_ESDPt", "",fV0Reader->GetPositiveTrackPt(), fV0Reader->GetPositiveESDTrack()->GetTRDsignal());
     } //end of specific trigger study resolution plots
     } //end if(kGCrunRES=true)
     
     // ___________________________________________________________________________________________________________________________________________________
 
-    if(kGCplotESDNumberOfV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfV0s","Number of v0s",100, -0.5, 99.5,"","");}
-    if(kGCplotESDNumberOfSurvivingV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfSurvivingV0s","Number of surviving v0s",100, -0.5, 99.5,"","");}
-    if(kGCplotESDNumberOfContributorsVtx == kTRUE){histograms->AddHistogram("ESD_NumberOfContributorsVtx","Number of contributors to vertex",100, -0.5, 99.5,"","");}
-    if(kGCplotESDNumberOfGoodESDTracks == kTRUE){histograms->AddHistogram("ESD_NumberOfGoodESDTracks","Number of Good ESD tracks",100, -0.5, 99.5,"","");}
-    if(kGCplotESDNumberOfGoodESDTracks == kTRUE){histograms->AddHistogram("ESD_NumberOfGoodESDTracksVtx","Number of Good ESD tracks",100, -0.5, 99.5,"","");}  
+    if(kGCplotEventQuality == kTRUE){histograms->AddHistogram("ESD_EventQuality","ESD_EventQuality",kGCnXBinsEvtQ,kGCfirstXBinEvtQ,kGClastXBinEvtQ,"","");}
+    if(kGCplotESDNumberOfV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfV0s","Number of v0s",kGCnXBinsNV0,kGCfirstXBinNV0 ,kGClastXBinNV0 ,"","");}
+    if(kGCplotESDNumberOfSurvivingV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfSurvivingV0s","Number of surviving v0s",kGCnXBinsNV0, kGCfirstXBinNV0 , kGClastXBinNV0,"","");}
+    if(kGCplotESDNumberOfContributorsVtx == kTRUE){histograms->AddHistogram("ESD_NumberOfContributorsVtx","Number of contributors to vertex",kGCnXBinsESDtrk, kGCfirstXBinESDtrk, kGClastXBinESDtrk,"","");}
+    if(kGCplotESDNumberOfGoodESDTracks == kTRUE){histograms->AddHistogram("ESD_NumberOfGoodESDTracks","Number of Good ESD tracks",kGCnXBinsESDtrk, kGCfirstXBinESDtrk, kGClastXBinESDtrk,"","");}
+    if(kGCplotESDNumberOfGoodESDTracks == kTRUE){histograms->AddHistogram("ESD_NumberOfGoodESDTracksVtx","Number of Good ESD tracks",kGCnXBinsESDtrk, kGCfirstXBinESDtrk, kGClastXBinESDtrk,"","");}   
        
     //  debug histograms
     if(kGCplotESDCutGetOnFly == kTRUE){histograms->AddHistogram("ESD_CutGetOnFly_InvMass" ,"Not GetOnFly" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
@@ -1766,21 +2213,29 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
 
     if(kGCplotESDCutdedxSigmaElectronLine == kTRUE){histograms->AddHistogram("ESD_CutdEdxSigmaElectronLine_InvMass" ,"dedx ElectronLine" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutdedxSigmaPionLine == kTRUE){histograms->AddHistogram("ESD_CutdEdxSigmaPionLine_InvMass" ,"dedx PionLine" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+    if(kGCplotESDCutPionRejectionLowP==kTRUE){histograms->AddHistogram("ESD_CutPionRejectionLowP_InvMass" ,"dedx PionRejection LowP" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+    if(kGCplotESDCutKaonRejectionLowP==kTRUE){histograms->AddHistogram("ESD_CutKaonRejectionLowP_InvMass" ,"dedx KaonRejection LowP" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+    if(kGCplotESDCutQtGammaSelection==kTRUE){histograms->AddHistogram("ESD_CutQt_InvMass","ESD_CutQt_InvMass",kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
 
+    if(kGCplotESDCutProtonRejectionLowP==kTRUE){histograms->AddHistogram("ESD_CutProtonRejectionLowP_InvMass" ,"dedx ProtonRejection LowP" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutR == kTRUE){histograms->AddHistogram("ESD_CutR_InvMass" ,"Above RMax" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+    if(kGCplotESDCutMinR == kTRUE){histograms->AddHistogram("ESD_CutMinR_InvMass" ,"Above RMax" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutNDF == kTRUE){histograms->AddHistogram("ESD_CutNDF_InvMass" ,"NDF <= 0" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutChi2 == kTRUE){histograms->AddHistogram("ESD_CutChi2_InvMass" ,"#chi^{2} > Max" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutEta == kTRUE){histograms->AddHistogram("ESD_CutEta_InvMass" ,"Above #eta max" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+    if(kGCplotESDCutSinglePt == kTRUE){histograms->AddHistogram("ESD_CutSinglePt_InvMass" ,"Below p_{t} min" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutPt == kTRUE){histograms->AddHistogram("ESD_CutPt_InvMass" ,"Below p_{t} min" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutLine == kTRUE){histograms->AddHistogram("ESD_CutLine_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutZ == kTRUE){histograms->AddHistogram("ESD_CutZ_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDCutMinClsTPC == kTRUE){histograms->AddHistogram("ESD_CutMinNClsTPC_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+    if(kGCplotESDCutMinClsTPCToF == kTRUE){histograms->AddHistogram("ESD_CutMinNClsTPCToF_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
 
     if(kGCplotESDGoodV0s == kTRUE){histograms->AddHistogram("ESD_GoodV0s_InvMass" ,"Good V0s" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDAllV0s == kTRUE){histograms->AddHistogram("ESD_AllV0s_InvMass" ,"All V0s" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
     if(kGCplotESDAllV0sCurrentFinder == kTRUE){histograms->AddHistogram("ESD_AllV0sCurrentFinder_InvMass" ,"All V0s Current Finder" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
 
-    if(kGCplotESDAllV0sCurrentFinderQtAlfa== kTRUE){ histograms->AddHistogram("ESD_AllV0sCurrentFinder_alfa_qt" ,"" ,kGCnXBinsP, kGCfirstXBinAlpha, kGClastXBinAlpha,kGCnYBinsQt, kGCfirstYBinQt, kGClastYBinQt,"", "");}
+    if(kGCplotESDAllV0sCurrentFinderQtAlfa== kTRUE){ histograms->AddHistogram("ESD_AllV0sCurrentFinder_alfa_qt" ,"" ,kGCnXBinsP, kGCfirstXBinAlphaG, kGClastXBinAlpha,kGCnYBinsQt, kGCfirstYBinQt, kGClastYBinQt,"", "");}
+    if(kGCplotESDAllV0sCurrentFinderQtAlfa== kTRUE){ histograms->AddHistogram("ESD_AllV0sCurrentFinder_goodtracks_alfa_qt" ,"" ,kGCnXBinsP, kGCfirstXBinAlphaG, kGClastXBinAlpha,kGCnYBinsQt, kGCfirstYBinQt, kGClastYBinQt,"", "");}
 
     if(kGCplotESDTrueConvGammaTrackLength == kTRUE){histograms->AddHistogram("ESD_TrueConvGamma_TrackLength","Track length of TrueConvGamma",kGCnXBinsTrackLength,kGCfirstXBinTrackLength,kGClastXBinTrackLength,"","");}
     if(kGCplotESDTrueConvGammaTrackLengthVSInvMass == kTRUE){histograms->AddHistogram("ESD_TrueConvGamma_TrackLengthVSInvMass","Track length of TrueConvGamma vs Inv mass",kGCnXBinsTrackLength,kGCfirstXBinTrackLength,kGClastXBinTrackLength,kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,"","");}
@@ -1797,9 +2252,15 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
     }
 
     if(kGCplotPi0Spectra == kTRUE){
-      histograms->AddHistogram("ESD_Mother_alfa","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alfa","Counts");
-
+      histograms->AddHistogram("ESD_Mother_alfa","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+      histograms->AddHistogram("ESD_Mother_alfa_Pi0","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+      histograms->AddHistogram("ESD_Mother_alfa_Eta","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+      histograms->AddHistogram("ESD_Background_alfa_Pi0","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+      histograms->AddHistogram("ESD_Background_alfa_Eta","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+      //      histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
       histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+      histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_alpha" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+      histograms->AddHistogram("ESD_Mother_InvMass_vs_E_alpha" ,"Invariant Mass vs E" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","E [GeV]");
       histograms->AddHistogram("ESD_Mother_InvMass","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
       histograms->AddHistogram("ESD_Mother_InvMass_1212","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
       histograms->AddHistogram("ESD_Mother_InvMass_0912","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
@@ -1808,24 +2269,27 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
       histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt0912" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
       histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt0909" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
 
+      if(kGCLowMemoryConsumption == kFALSE){
+       histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+       histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvPHOS" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+       histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanLow","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+       histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanHigh","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
 
-      histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-      histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvPHOS" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-      histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanLow","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-      histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanHigh","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-
-      histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
- histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_Bck","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-
-      histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-      histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL_Bck" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-
-
-      histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanLow","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-      histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanHigh","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-
+       histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+       histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_Bck","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+       
+       histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+       histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL_Bck" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+       
+       histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanLow","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+       histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanHigh","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+      }
 
       //      if(kGCdoNeutralMesonV0MCCheck == kTRUE){
+      histograms->AddHistogram("ESD_TrueBckGG_InvMass_vs_Pt","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Counts");
+      histograms->AddHistogram("ESD_TrueBckCont_InvMass_vs_Pt","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Counts");
+      histograms->AddHistogram("ESD_TruePi0Sec_InvMass_vs_Pt","Invariant mass vs Pt",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Counts");
+      histograms->AddHistogram("ESD_TruePi0DalitzCont_InvMass_vs_Pt","Invariant mass vs Pt",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Counts");
        histograms->AddHistogram("ESD_TruePi0_InvMass","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
        histograms->AddHistogram("ESD_TruePi0_InvMass_1212","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
        histograms->AddHistogram("ESD_TruePi0_InvMass_0912","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
@@ -1834,24 +2298,35 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
        histograms->AddHistogram("ESD_TruePi0_OpeningAngle_0912" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");
        histograms->AddHistogram("ESD_TruePi0_OpeningAngle_0909" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");
        histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-       histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt1212" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-       histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt0912" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-       histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt0909" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt_alpha" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+
+ if(kGCLowMemoryConsumption == kFALSE){
+   histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt1212" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+   histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt0912" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+   histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt0909" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+
        //}
 
-      histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_Fiducial" ,"Invariant Mass vs Pt |eta|<0.9" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+   histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_Fiducial" ,"Invariant Mass vs Pt |eta|<0.9" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ }
       histograms->AddHistogram("ESD_Mother_InvMass_Fiducial","Invariant mass |eta|<0.9",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
 
 
     }
 
     if(kGCplotPi0Spectra == kTRUE && kGCcalculateBackground == kTRUE){
+      for(Int_t m=0;m<6;m++){
+       histograms->AddHistogram(Form("%dESD_Mother_InvMass_vs_Pt",m) ,"Background Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+      }
       for(Int_t z=0;z<8;z++){
-       for(Int_t m=0;m<4;m++){
+       for(Int_t m=0;m<6;m++){
+         histograms->AddHistogram(Form("%d%dESD_Mother_InvMass_vs_Pt",z,m) ,"ESD Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+
          histograms->AddHistogram(Form("%d%dESD_Background_InvMass_vs_Pt",z,m) ,"Background Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
 
          
          histograms->AddHistogram(Form("%d%dESD_Background_InvMass",z,m),"Invariant mass background",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass BG [GeV]","Counts");
+         histograms->AddHistogram(Form("%d%dESD_Mother_InvMass",z,m),"Invariant mass in z and m bins",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass BG [GeV]","Counts");
 
 
          histograms->AddHistogram(Form("%d%dESD_Background_InvMassvsPtFid",z,m) ,"Background Invariant Mass vs Pt |eta|<0.9" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
@@ -1862,7 +2337,11 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
       }
     
       histograms->AddHistogram("ESD_Background_InvMass_vs_Pt" ,"Background Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-      histograms->AddHistogram("ESD_Background_InvMass","Invariant mass background",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass BG [GeV]","Counts");
+      histograms->AddHistogram("ESD_Background_InvMass_vs_Pt_alpha" ,"Background Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+
+     histograms->AddHistogram("ESD_Background_InvMass_vs_E_alpha" ,"Background Invariant Mass vs E" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","E [GeV]");
+
+  histograms->AddHistogram("ESD_Background_InvMass","Invariant mass background",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass BG [GeV]","Counts");
 
       histograms->AddHistogram("ESD_Background_InvMass_vs_Pt_Fiducial" ,"Background Invariant Mass vs Pt |eta|<0.9" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
       histograms->AddHistogram("ESD_Background_InvMass_Fiducial","Invariant mass background |eta|<0.9",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass BG [GeV]","Counts");
@@ -1938,20 +2417,43 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
        histograms->AddHistogram("MC_Mother_InvMass_vs_Pt_ConvGamma_withinAcceptance" ,"" ,kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra, kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra, "", "");
       }
                
-               
+      if(kGCplotMCPhysicalPrimaryChargedPt == kTRUE){ histograms->AddHistogram("MC_PhysicalPrimaryCharged_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
       if(kGCplotMCPi0Eta == kTRUE){ histograms->AddHistogram("MC_Pi0_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}       
       if(kGCplotMCPi0Rapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}     
+      if(kGCplotMCPi0PtvsRapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_vs_Rapid" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
+       if(kGCplotMCPi0PtvsRapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_vs_Rapid_allDaughters" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");} // OWN primary Pi0 debug
       if(kGCplotMCPi0Phi == kTRUE){ histograms->AddHistogram("MC_Pi0_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
       if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ1_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ2_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ3_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ4_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ5_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ1_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ2_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ3_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ4_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ5_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
+
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ1_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ2_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ3_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ4_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+      if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ5_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
       if(kGCplotMCPi0PtFiducial == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_Fiducial" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
       if(kGCplotMCPi0PtWithinAcceptanceFiducial == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_withinAcceptance_Fiducial" ,"" , kGCnXBinsPt,kGCfirstXBinPt, kGClastXBinPt, "", "");}
       if(kGCplotMCPi0PtConvGammaWithinAcceptanceFiducial == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_ConvGamma_withinAcceptance_Fiducial","" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
-
+      if(kGCplotMCPi0OpeningPtConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_ConvGamma_OpeningAngle_Pt","", kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
+      if(kGCplotMCPi0PtGammaPtConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Pi0_ConvGamma_PtGamma_Pt","", kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
       if(kGCplotMCPi0Energy == kTRUE){ histograms->AddHistogram("MC_Pi0_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
       if(kGCplotMCPi0Mass == kTRUE){ histograms->AddHistogram("MC_Pi0_Mass" ,"" , kGCnXBinsPi0Mass, kGCfirstXBinPi0Mass, kGClastXBinPi0Mass, "", "");}
       if(kGCplotMCPi0Alpha == kTRUE){ histograms->AddHistogram("MC_Pi0_alpha" ,"" , kGCnXBinsPi0Mass, kGCfirstXBinPi0Alpha, kGClastXBinPi0Alpha, "", "");}
-
-      if(kGCplotMCPi0OpeningAngle == kTRUE){ histograms->AddHistogram("MC_Pi0_GammaDaughter_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
+      if(kGCplotMCEtaAlpha == kTRUE){ histograms->AddHistogram("MC_Eta_alpha" ,"" , kGCnXBinsPi0Mass, kGCfirstXBinPi0Alpha, kGClastXBinPi0Alpha, "", "");}
+       if(kGCplotMCPi0OpeningAngle == kTRUE){ histograms->AddHistogram("MC_Pi0_GammaDaughter_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
       if(kGCplotMCPi0R == kTRUE){ histograms->AddHistogram("MC_Pi0_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
       if(kGCplotMCPi0ZR == kTRUE){ histograms->AddHistogram("MC_Pi0_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
       if(kGCplotMCPi0XY == kTRUE){ histograms->AddHistogram("MC_Pi0_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
@@ -1981,6 +2483,7 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
                
       if(kGCplotMCEtaEta == kTRUE){ histograms->AddHistogram("MC_Eta_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
       if(kGCplotMCEtaRapid == kTRUE){ histograms->AddHistogram("MC_Eta_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
+      if(kGCplotMCEtaPtvsRapid == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_vs_Rapid" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
       if(kGCplotMCEtaPhi == kTRUE){ histograms->AddHistogram("MC_Eta_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
       if(kGCplotMCEtaPt == kTRUE){ histograms->AddHistogram("MC_Eta_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
       if(kGCplotMCEtaEnergy == kTRUE){ histograms->AddHistogram("MC_Eta_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
@@ -1995,17 +2498,38 @@ void AddHistograms(AliGammaConversionHistograms *histograms){
       if(kGCplotMCEtaPtvsRapidConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_Rapid_ConvGamma_withinAcceptance" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
       if(kGCplotMCEtaZRConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_ZR_ConvGamma_withinAcceptance" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");} 
     }
-    
+    if(kGCplotMCEtaOpeningPtConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_ConvGamma_OpeningAngle_Pt","", kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
+    if(kGCplotMCEtaPtGammaPtConvGammaWithinAcceptance == kTRUE){ histograms->AddHistogram("MC_Eta_ConvGamma_PtGamma_Pt","", kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
   }// end kGCrunNeutralMeson
 
   
   //---------------------------------------------------  2 gamma Background -------------------------------------------------------
 
   if(kGCcalculateBackground==kTRUE){
+    histograms->AddHistogram("ESD_GlobalPrimaryVtxZ","Z primary vertex Global",300, -15., 15.,"Z[cm]","counts");
+    histograms->AddHistogram("ESD_SPDPrimaryVtxZ","Z primary vertex SPD",300, -15., 15.,"Z[cm]","counts");
     histograms->AddHistogram("ESD_Z_distribution" ,"Z primary vertex" , 2000, -30, 30,"Z[cm]","counts");
     histograms->AddHistogram("ESD_multiplicity_distribution" ,"multiplicity distribution" , 200, 0, 200,"counts","Multiplicity");
     histograms->AddHistogram("ESD_ZvsMultiplicity" ,"Z vs Multiplicity" , 1000, -10, 10,200,0,200,"Z[cm]","Multiplicity");
   }
+  
+  if(kGCRecalculateV0ForGamma==kTRUE){
+    histograms->AddHistogram("ESD_RecalculateV0_InvMass","", kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");
+    histograms->AddHistogram("ESD_RecalculateV0_Pt","",kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+    histograms->AddHistogram("ESD_RecalculateV0_E_dEdxP","",kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "",0);
+    histograms->AddHistogram("ESD_RecalculateV0_P_dEdxP","",kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsdEdx, kGCfirstYBindEdx, kGClastYBindEdx,"", "",0);
+    histograms->AddHistogram("ESD_RecalculateV0_cpa","",1000,-1.,1.,"","");
+    histograms->AddHistogram("ESD_RecalculateV0_dca","",100,0.,10.,"","");
+    histograms->AddHistogram("ESD_RecalculateV0_Rr","",250,0.,250.,"","");
+    histograms->AddHistogram("ESD_RecalculateV0_normdistP","",250,0.,250.,"","");
+    histograms->AddHistogram("ESD_RecalculateV0_normdistN","",250,0.,250.,"","");
+
+    histograms->AddHistogram("ESD_RecalculateGG_InvMass","",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+    histograms->AddHistogram("ESD_RecalculateGG_InvMass_vs_Pt","", kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");            
+
+  }
+  
+
 }
 
 
@@ -2016,7 +2540,7 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   // set the cuts depending on the Cut Selection Id
   // first number is dummy always set to 9 
   //  const char* cutSelection = analysisCutSelection.Data(); 
-  if(analysisCutSelection.Length()!=10){
+  if(analysisCutSelection.Length()!=c_array_size){
     cout<<"Cut selection has the wrong length!"<<endl;
     return 0;
   }
@@ -2038,9 +2562,39 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   Int_t singlePtCut=array[7];
   Int_t clsTPCCut=array[8];
   Int_t etaCut=array[9];
-
-
-
+  Int_t chi2MesonCut=array[10];
+  Int_t LowPRejectionSigmaCut=array[11];
+  Int_t QtMaxCut=array[12];
+  Int_t piMaxMomdedxSigmaCut=array[13];
+  Int_t alphaMesonCut=array[14];
+  Int_t minRCut=array[15];
+  Int_t RapidityMesonCut=array[16];
+  Int_t BackgroundScheme=array[17];
+  Int_t DegreesForRotationMethod=array[18];
+  Int_t NumberOfRotations=array[19];
+  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;
+  cout<<"NumberOfRotations::"<<NumberOfRotations<<endl;
+  cout<<"DegreesForRotationMethod::"<<DegreesForRotationMethod<<endl;
+  cout<<"BackgroundScheme::"<<BackgroundScheme<<endl;
+  cout<<"RapidityMesonCut::"<<RapidityMesonCut<<endl;  
+  cout<<"minRCut::"<<minRCut<<endl;
+  cout<<"alphaMesonCut::"<<alphaMesonCut<<endl;        
+  cout<<"piMaxMomdedxSigmaCut::"<<piMaxMomdedxSigmaCut<<endl;
+  cout<<"QtMaxCut:"<<QtMaxCut<<endl;
+  cout<<"LowPRejectionSigmaCut:"<<LowPRejectionSigmaCut<<endl;
+  cout<<"chi2MesonCut: "<< chi2MesonCut<<endl;
   cout<<"etaCut: "<<etaCut<<endl;
   cout<<"clsTPCCut: "<<clsTPCCut<<endl;
   cout<<"singlePtCut: "<<singlePtCut<<endl;
@@ -2067,15 +2621,19 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   default:
     return iResult;
   }
+
   switch(eProbCut){
-  case 0:  // 0.
-    kGCprobElectron = 0.000;
+  case 0:
+    kGCprobElectron=0;
     break;
-  case 1:  // 0.001
-    kGCprobElectron = 0.001;
+  case 1:
+    kGCprobElectron=0.1;
     break;
-  case 2:  // 0.01
-    kGCprobElectron = 0.01;
+  case 2:
+    kGCprobElectron=0.5;
+    break;
+  case 3:
+    kGCprobElectron=0.7;
     break;
   default:
     return iResult;
@@ -2094,6 +2652,10 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
     kGCPIDnSigmaBelowElectronLine=-3;
     kGCPIDnSigmaAboveElectronLine=5;
     break;
+  case 3: // -4,5
+    kGCPIDnSigmaBelowElectronLine=-4;
+    kGCPIDnSigmaAboveElectronLine=5;
+    break;
   default:
     return iResult;
   }
@@ -2108,6 +2670,16 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   case 2:  // 1
     kGCPIDnSigmaAbovePionLine=1;
     break;
+  case 3:  // 1
+    kGCPIDnSigmaAbovePionLine=-1;
+    break;
+  case 4:  // 1
+    kGCPIDnSigmaAbovePionLine=-1.5;
+    break;
+  case 5:  // 1
+    kGCPIDnSigmaAbovePionLine=2.;
+    break;
+
   default:
     return iResult;
   }
@@ -2122,6 +2694,21 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   case 2:  // 1.5 GeV
     kGCPIDMinPnSigmaAbovePionLine=1.5;
     break;
+  case 3:  // 20.0 GeV
+    kGCPIDMinPnSigmaAbovePionLine=20.;
+    break;
+  case 4:  // 50.0 GeV
+    kGCPIDMinPnSigmaAbovePionLine=50.;
+    break;
+  case 5:  // 0.3 GeV
+    kGCPIDMinPnSigmaAbovePionLine=0.3;
+    break;
+  case 6:  // 0.3 GeV
+    kGCPIDMinPnSigmaAbovePionLine=0.25;
+    break;
+  case 7:  // 0.4 GeV
+    kGCPIDMinPnSigmaAbovePionLine=0.4;
+    break;
   default:
     return iResult;
   }
@@ -2136,6 +2723,27 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   case 2:  // 30
     kGCchi2CutConversion = 30.;
     break;
+  case 3:
+    kGCchi2CutConversion = 200.;
+    break;
+  case 4:
+    kGCchi2CutConversion = 500.;
+    break;
+  case 5:
+    kGCchi2CutConversion = 1000.;
+    break;
+  case 6:
+    kGCchi2CutConversion = 5.;
+    break;
+  case 7:
+    kGCchi2CutConversion = 10.;
+    break;
+  case 8:
+    kGCchi2CutConversion = 20.;
+    break;
+  case 9:
+    kGCchi2CutConversion = 15.;
+    break;
   default:
     return iResult;
   }
@@ -2153,6 +2761,12 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   case 3:  // 0.200 GeV
     kGCsingleptCut = 0.200;
     break;
+  case 4:  // 0.075 GeV
+    kGCsingleptCut = 0.075;
+    break;
+  case 5:  // 0.125 GeV
+    kGCsingleptCut = 0.125;
+    break;
   default:
     return iResult;
  }
@@ -2170,6 +2784,30 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
   case 3:  // 100 
     kGCminClsTPCCut= 100.;
     break;
+  case 4:  // 60% of findable clusters
+    kGCminClsTPCCutToF= 0.6;
+    kGCUseCorrectedTPCClsInfo=0;
+    break;
+  case 5:  // 0% of findable clusters
+    kGCminClsTPCCutToF= 0.0;
+    kGCUseCorrectedTPCClsInfo=1;
+    break;
+  case 6:  // 0% of findable clusters
+    kGCminClsTPCCutToF= 0.7;
+    kGCUseCorrectedTPCClsInfo=0;
+    break;
+  case 7:  // 0% of findable clusters
+    kGCminClsTPCCutToF= 0.35;
+    kGCUseCorrectedTPCClsInfo=0;
+    break;
+  case 8:
+    kGCminClsTPCCutToF= 0.35;
+    kGCUseCorrectedTPCClsInfo=1;
+    break;
+  case 9:
+    kGCminClsTPCCutToF= 0.6;
+    kGCUseCorrectedTPCClsInfo=1;
+    break;
   default:
     return iResult;
   }
@@ -2191,8 +2829,364 @@ Int_t SetAnalysisCutSelection(TString analysisCutSelection){
     return iResult;
   }
 
+  switch(chi2MesonCut){
+  case 0:  // 100.
+    kGCchi2CutMeson = 100.;
+    break;
+  case 1:  // 50.
+    kGCchi2CutMeson = 50.;
+    break;
+  case 2:  // 30.
+    kGCchi2CutMeson = 30.;
+    break;
+  case 3:
+    kGCchi2CutMeson = 200.;
+    break;
+  case 4:
+    kGCchi2CutMeson = 500.;
+    break;
+  case 5:
+    kGCchi2CutMeson = 1000.;
+    break;
+  default:
+    return iResult;
+  }
+
+
+  switch(LowPRejectionSigmaCut){
+  case 0:  // 
+    kGCPIDnSigmaAtLowPAroundKaonLine=0;
+    kGCPIDnSigmaAtLowPAroundProtonLine=0;
+    kGCPIDnSigmaAtLowPAroundPionLine=0;
+    break;
+  case 1:  // 
+    kGCPIDnSigmaAtLowPAroundKaonLine=0.5;
+    kGCPIDnSigmaAtLowPAroundProtonLine=0.5;
+    kGCPIDnSigmaAtLowPAroundPionLine=0.5;
+    break;
+  case 2:  // 
+    kGCPIDnSigmaAtLowPAroundKaonLine=1;
+    kGCPIDnSigmaAtLowPAroundProtonLine=1;
+    kGCPIDnSigmaAtLowPAroundPionLine=1;
+    break;
+  case 3:  // 
+    kGCPIDnSigmaAtLowPAroundKaonLine=2.;
+    kGCPIDnSigmaAtLowPAroundProtonLine=2.;
+    kGCPIDnSigmaAtLowPAroundPionLine=2.;
+    break;
+  case 4:  // 
+    kGCPIDnSigmaAtLowPAroundKaonLine=0.;
+    kGCPIDnSigmaAtLowPAroundProtonLine=0.;
+    kGCPIDnSigmaAtLowPAroundPionLine=1;
+    break;
+  case 5:  // 
+    kGCPIDnSigmaAtLowPAroundKaonLine=0.;
+    kGCPIDnSigmaAtLowPAroundProtonLine=0.;
+    kGCPIDnSigmaAtLowPAroundPionLine=1.5;
+    break;
+  case 6:  // 
+    kGCPIDnSigmaAtLowPAroundKaonLine=0.;
+    kGCPIDnSigmaAtLowPAroundProtonLine=0.;
+    kGCPIDnSigmaAtLowPAroundPionLine=2.;
+    break;
+
+  default:
+    return iResult;
+  }
+  switch(QtMaxCut){
+  case 0: //
+    kGCQtMax=1.;
+    break;
+  case 1:
+    kGCQtMax=0.1;
+    break;
+  case 2:
+    kGCQtMax=0.07;
+    break;
+  case 3:
+    kGCQtMax=0.05;
+    break;
+  case 4:
+    kGCQtMax=0.03;
+    break;
+  case 5: // OWN try to improve (get rid of) low InvMass peak in PbPb
+    kGCQtMax=0.02;
+    break; // end OWN ///////////////////////////////////////////////
+  default:
+    return iResult;
+  }
+
+  switch(piMaxMomdedxSigmaCut){
+  case 0:  // 100. GeV
+    kGCPIDMaxPnSigmaAbovePionLine=100.;
+    break;
+  case 1:  // 5. GeV
+    kGCPIDMaxPnSigmaAbovePionLine=5.;
+    break;
+  case 2:  // 4. GeV
+    kGCPIDMaxPnSigmaAbovePionLine=4.;
+    break;
+  case 3:  // 3.5 GeV
+    kGCPIDMaxPnSigmaAbovePionLine=3.5;
+    break;
+  case 4:  // 3. GeV
+    kGCPIDMaxPnSigmaAbovePionLine=3.;
+    break;
+  default:
+    return iResult;
+  }
+
+       
+  switch(alphaMesonCut){
+  case 0:  // 0- 0.7
+    kGCalphaMinCutMeson   = 0.0;
+    kGCalphaCutMeson   = 0.7;
+    break;
+  case 1:  // 0-0.5
+    kGCalphaMinCutMeson   = 0.0;
+    kGCalphaCutMeson   = 0.5;
+    break;
+  case 2:  // 0.5-1 
+    kGCalphaMinCutMeson   = 0.5;
+    kGCalphaCutMeson   = 1.;
+    break;
+  case 3:  // 0.0-1 
+    kGCalphaMinCutMeson   = 0.0;
+    kGCalphaCutMeson   = 1.;
+    break;
+  default:
+    return iResult;
+  }
+  
+  switch(minRCut){
+  case 0:
+    kGCminRCut=0;
+    kGCmaxRCut = 180.;
+    break;
+  case 1:
+    kGCminRCut=2.8;
+    kGCmaxRCut = 180.;
+    break;
+  case 2:
+    kGCminRCut=5.;
+    kGCmaxRCut = 180.;
+    break;
+  case 3:
+    kGCmaxRCut = 70.;
+    kGCminRCut = 10.;
+    break;
+  case 4:
+    kGCmaxRCut = 70.;
+    kGCminRCut = 5.;
+    break;
+  case 5:
+    kGCmaxRCut = 180.;
+    kGCminRCut = 10.;
+    break;
+    
+  default:
+    return iResult;
+  }
+
+  switch(RapidityMesonCut){
+  case 0:  //
+    kGCrapidityCutMeson   = 0.9;
+    break;
+  case 1:  // 
+    kGCrapidityCutMeson   = 0.8;
+    break;
+  case 2:  // 
+    kGCrapidityCutMeson   = 0.7;
+    break;
+    
+  default:
+    return iResult;
+  }
+
+  switch(BackgroundScheme){
+  case 0: //Rotation
+    kGCUseRotationMethodInBG=kTRUE;
+    kGCdoBGProbability=kFALSE;
+    break;
+  case 1: // mixed event with track multiplicity
+    kGCUseRotationMethodInBG=kFALSE;
+    kGCUseTrackMultiplicityForBG=kFALSE;
+    kGCdoBGProbability=kFALSE;
+    break;
+  case 2: // mixed event with V0 multiplicity
+    kGCUseRotationMethodInBG=kFALSE;
+    kGCUseTrackMultiplicityForBG=kTRUE;
+    kGCdoBGProbability=kFALSE;
+    break;
+  case 3: //Rotation
+    kGCUseRotationMethodInBG=kTRUE;
+    kGCdoBGProbability=kTRUE;
+    break;
+  default:
+    return iResult;
+  }
+  
+  switch(DegreesForRotationMethod){
+  case 0:
+    kGCnDegreeRotationPMForBG = 5;
+    break;
+  case 1:
+    kGCnDegreeRotationPMForBG = 10;
+    break;
+  case 2:
+    kGCnDegreeRotationPMForBG = 15;
+    break;
+  case 3:
+    kGCnDegreeRotationPMForBG = 20;
+    break;
+
+  default:
+    return iResult;
+  }
+
+  switch(NumberOfRotations){
+  case 0:
+    kGCnumberOfRotationEventsForBG = 5;
+    break;
+  case 1:
+    kGCnumberOfRotationEventsForBG = 10;
+    break;
+  case 2:
+    kGCnumberOfRotationEventsForBG = 15;
+    break;
+  case 3:
+    kGCnumberOfRotationEventsForBG = 20;
+    break;
+  case 4:
+    kGCnumberOfRotationEventsForBG = 2;
+    break;
+  case 5:
+    kGCnumberOfRotationEventsForBG = 50;
+    break;
+  case 6:
+    kGCnumberOfRotationEventsForBG = 80;
+    break;
+  case 7:
+    kGCnumberOfRotationEventsForBG = 100;
+    break;
+  default:
+    return iResult;
+  }
+
+  switch(removePileUp){
+  case 0:
+    kGCRemovePileUp=kFALSE;
+    break;
+  case 1:
+    kGCRemovePileUp=kTRUE;
+    break;
+  default:
+    return iResult;
+  }
+
+  switch(selectV0AND){
+  case 0:
+    kGCSelectV0AND=kFALSE;
+    break;
+  case 1:
+    kGCSelectV0AND=kTRUE;
+    break;
+  default:
+    return iResult;
+  }
+
+  switch(multiplicityBin){
+  case 0:
+    kGCUseMultiplicity=kFALSE;
+    kGCUseMultiplicityBin=0;
+    break;
+  case 1:
+    kGCUseMultiplicity=kTRUE;
+    kGCUseMultiplicityBin=1;
+     break;
+  case 2:
+    kGCUseMultiplicity=kTRUE;
+    kGCUseMultiplicityBin=2;
+     break;
+  case 3:
+    kGCUseMultiplicity=kTRUE;
+    kGCUseMultiplicityBin=3;
+     break;
+  case 4:
+    kGCUseMultiplicity=kTRUE;
+    kGCUseMultiplicityBin=4;
+     break;
+  case 5:
+    kGCUseMultiplicity=kTRUE;
+    kGCUseMultiplicityBin=5;
+     break;
+  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;
+
+
 }
 
 
@@ -2210,6 +3204,22 @@ void string2array(const std::string& number, int a[c_array_size])
         ASSIGNARRAY(7);
         ASSIGNARRAY(8);
         ASSIGNARRAY(9);
+        ASSIGNARRAY(10);
+        ASSIGNARRAY(11);
+        ASSIGNARRAY(12);
+        ASSIGNARRAY(13);
+        ASSIGNARRAY(14);
+        ASSIGNARRAY(15);
+        ASSIGNARRAY(16);
+        ASSIGNARRAY(17);
+        ASSIGNARRAY(18);
+        ASSIGNARRAY(19);
+        ASSIGNARRAY(20);
+        ASSIGNARRAY(21);
+        ASSIGNARRAY(22);
+        ASSIGNARRAY(23);
+        ASSIGNARRAY(24);
+        ASSIGNARRAY(25);
   }
 }