Usage of VZERO equalized multiplicity. (a) Add function to compute it (b) Add flag...
authorzconesa <zaida.conesa.del.valle@cern.ch>
Tue, 28 Oct 2014 08:45:21 +0000 (09:45 +0100)
committerzconesa <zaida.conesa.del.valle@cern.ch>
Tue, 28 Oct 2014 08:46:55 +0000 (09:46 +0100)
PWGHF/vertexingHF/AliAnalysisTaskSEDvsMultiplicity.cxx
PWGHF/vertexingHF/AliAnalysisTaskSEDvsMultiplicity.h
PWGHF/vertexingHF/AliVertexingHFUtils.cxx
PWGHF/vertexingHF/AliVertexingHFUtils.h
PWGHF/vertexingHF/macros/AddTaskDvsMultiplicity.C
PWGHF/vertexingHF/macros/ReadDvsMultiplicity.C

index 844333c..39b4ad1 100755 (executable)
@@ -48,6 +48,7 @@
 #include "AliNormalizationCounter.h"
 #include "AliVertexingHFUtils.h"
 #include "AliAODVZERO.h"
+#include "AliESDUtils.h"
 ClassImp(AliAnalysisTaskSEDvsMultiplicity)
 
 
@@ -64,19 +65,28 @@ AliAnalysisTaskSE(),
   fHistNtrEta03vsNtrEta1EvSel(0),
   fHistNtrEtaV0AvsNtrEta1EvSel(0),
   fHistNtrEtaV0MvsNtrEta1EvSel(0),
+  fHistNtrEtaV0AvsV0AEqEvSel(0),
+  fHistNtrEtaV0MvsV0MEqEvSel(0),
   fHistNtrCorrEta1vsNtrRawEta1EvSel(0),
+  fHistMultCorrvsMultRawEvSel(0),
   fHistNtrEta16vsNtrEta1EvWithCand(0),
   fHistNtrEta05vsNtrEta1EvWithCand(0),
   fHistNtrEta03vsNtrEta1EvWithCand(0),
   fHistNtrEtaV0AvsNtrEta1EvWithCand(0),
   fHistNtrEtaV0MvsNtrEta1EvWithCand(0),
+  fHistNtrEtaV0AvsV0AEqEvWithCand(0),
+  fHistNtrEtaV0MvsV0MEqEvWithCand(0),
   fHistNtrCorrEta1vsNtrRawEta1EvWithCand(0),
+  fHistMultCorrvsMultRawEvWithCand(0),
   fHistNtrEta16vsNtrEta1EvWithD(0),
   fHistNtrEta05vsNtrEta1EvWithD(0),
   fHistNtrEta03vsNtrEta1EvWithD(0),
   fHistNtrEtaV0AvsNtrEta1EvWithD(0),
   fHistNtrEtaV0MvsNtrEta1EvWithD(0),
+  fHistNtrEtaV0AvsV0AEqEvWithD(0),
+  fHistNtrEtaV0MvsV0MEqEvWithD(0),
   fHistNtrCorrEta1vsNtrRawEta1EvWithD(0),
+  fHistMultCorrvsMultRawEvWithD(0),
   fHistNtrVsZvtx(0),
   fHistNtrCorrVsZvtx(0),
   fHistNtrVsNchMC(0),
@@ -129,7 +139,8 @@ AliAnalysisTaskSE(),
   fRefMult(9.26),
   fPdgMeson(411),
   fMultiplicityEstimator(kNtrk10),
-  fMCPrimariesEstimator(kEta10)
+  fMCPrimariesEstimator(kEta10),
+  fDoVZER0ParamVertexCorr(0)
 {
    // Default constructor
   for(Int_t i=0; i<5; i++) fHistMassPtImpPar[i]=0;
@@ -149,19 +160,28 @@ AliAnalysisTaskSEDvsMultiplicity::AliAnalysisTaskSEDvsMultiplicity(const char *n
   fHistNtrEta03vsNtrEta1EvSel(0),
   fHistNtrEtaV0AvsNtrEta1EvSel(0),
   fHistNtrEtaV0MvsNtrEta1EvSel(0),
+  fHistNtrEtaV0AvsV0AEqEvSel(0),
+  fHistNtrEtaV0MvsV0MEqEvSel(0),
   fHistNtrCorrEta1vsNtrRawEta1EvSel(0),
+  fHistMultCorrvsMultRawEvSel(0),
   fHistNtrEta16vsNtrEta1EvWithCand(0),
   fHistNtrEta05vsNtrEta1EvWithCand(0),
   fHistNtrEta03vsNtrEta1EvWithCand(0),
   fHistNtrEtaV0AvsNtrEta1EvWithCand(0),
   fHistNtrEtaV0MvsNtrEta1EvWithCand(0),
+  fHistNtrEtaV0AvsV0AEqEvWithCand(0),
+  fHistNtrEtaV0MvsV0MEqEvWithCand(0),
   fHistNtrCorrEta1vsNtrRawEta1EvWithCand(0),
+  fHistMultCorrvsMultRawEvWithCand(0),
   fHistNtrEta16vsNtrEta1EvWithD(0),
   fHistNtrEta05vsNtrEta1EvWithD(0),
   fHistNtrEta03vsNtrEta1EvWithD(0),
   fHistNtrEtaV0AvsNtrEta1EvWithD(0),
   fHistNtrEtaV0MvsNtrEta1EvWithD(0),
+  fHistNtrEtaV0AvsV0AEqEvWithD(0),
+  fHistNtrEtaV0MvsV0MEqEvWithD(0),
   fHistNtrCorrEta1vsNtrRawEta1EvWithD(0),
+  fHistMultCorrvsMultRawEvWithD(0),
   fHistNtrVsZvtx(0),
   fHistNtrCorrVsZvtx(0),
   fHistNtrVsNchMC(0),
@@ -214,7 +234,8 @@ AliAnalysisTaskSEDvsMultiplicity::AliAnalysisTaskSEDvsMultiplicity(const char *n
   fRefMult(9.26),
   fPdgMeson(pdgMeson),
   fMultiplicityEstimator(kNtrk10),
-  fMCPrimariesEstimator(kEta10)
+  fMCPrimariesEstimator(kEta10),
+  fDoVZER0ParamVertexCorr(0)
 {
   // 
   // Standard constructor
@@ -347,65 +368,78 @@ void AliAnalysisTaskSEDvsMultiplicity::UserCreateOutputObjects()
   Float_t lastMultBinNtrk = lastMultBin;
   Int_t nMultBinsV0 = 400;
   Float_t lastMultBinV0 = 799.5;
+  const char *estimatorName="tracklets";
   if(fisPPbData) {
     nMultBinsNtrk = 375;
     lastMultBinNtrk = 374.5;
     nMultBins = nMultBinsNtrk;
     lastMultBin = lastMultBinNtrk;
   }
-  if(fMultiplicityEstimator==kVZERO || fMultiplicityEstimator==kVZEROA) {
+  if(fMultiplicityEstimator==kVZERO || fMultiplicityEstimator==kVZEROA || fMultiplicityEstimator==kVZEROEq || fMultiplicityEstimator==kVZEROAEq) {
     nMultBins = nMultBinsV0;
     lastMultBin = lastMultBinV0;
+    estimatorName = "vzero";
   }
 
-  fHistNtrUnCorrPSSel = new TH1F("hNtrUnCorrPSSel","Uncorrected tracklets multiplicity for PS selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrUnCorrPSTrigSel = new TH1F("hNtrUnCorrPSTrigSel","Uncorrected tracklets multiplicity for PS + trigger name selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrUnCorrPSTrigPileUpSel = new TH1F("hNtrUnCorrPSTrigPileUpSel","Uncorrected tracklets multiplicity for PS + trigger name + pileup selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrUnCorrPSTrigPileUpVtxSel = new TH1F("hNtrUnCorrPSTrigPileUpVtxSel","Uncorrected tracklets multiplicity for PS + trigger name + pileup + with-vertex selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrUnCorrPSTrigPileUpVtxContSel = new TH1F("hNtrUnCorrPSTrigPileUpVtxContSel","Uncorrected tracklets multiplicity for PS + trigger name + pileup + with-vertex-contrib selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrUnCorrPSTrigPileUpVtxRangeSel = new TH1F("hNtrUnCorrPSTrigPileUpVtxRangeSel","Uncorrected tracklets multiplicity for PS + trigger name + pileup + with-vertex-contrib-range selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrUnCorrPSTrigPileUpVtxRangeCentrSel = new TH1F("hNtrUnCorrPSTrigPileUpVtxRangeCentrSel","Uncorrected tracklets multiplicity for PS + trigger name + pileup + with-vertex-contrib-range + centrality selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrUnCorrEvSel = new TH1F("hNtrUnCorrEvSel","Uncorrected tracklets multiplicity for selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrUnCorrEvWithCand = new TH1F("hNtrUnCorrEvWithCand", "Uncorrected Tracklets multiplicity for events with D candidates; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);// Total multiplicity
-  fHistNtrUnCorrEvWithD = new TH1F("hNtrUnCorrEvWithD","Uncorrected Tracklets multiplicity for events with D in mass region ; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin); // 
-  fHistNtrCorrPSSel = new TH1F("hNtrCorrPSSel","Corrected tracklets multiplicity for PS selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrCorrEvSel = new TH1F("hNtrCorrEvSel","Corrected tracklets multiplicity for selected events; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);
-  fHistNtrCorrEvWithCand = new TH1F("hNtrCorrEvWithCand", "Tracklets multiplicity for events with D candidates; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin);// Total multiplicity
-  fHistNtrCorrEvWithD = new TH1F("hNtrCorrEvWithD", "Tracklets multiplicity for events with D in mass region ; Tracklets ; Entries",nMultBins,firstMultBin,lastMultBin); // 
+  fHistNtrUnCorrPSSel = new TH1F("hNtrUnCorrPSSel",Form("Uncorrected %s multiplicity for PS selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrUnCorrPSTrigSel = new TH1F("hNtrUnCorrPSTrigSel",Form("Uncorrected %s multiplicity for PS + trigger name selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrUnCorrPSTrigPileUpSel = new TH1F("hNtrUnCorrPSTrigPileUpSel",Form("Uncorrected %s multiplicity for PS + trigger name + pileup selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrUnCorrPSTrigPileUpVtxSel = new TH1F("hNtrUnCorrPSTrigPileUpVtxSel",Form("Uncorrected %s multiplicity for PS + trigger name + pileup + with-vertex selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrUnCorrPSTrigPileUpVtxContSel = new TH1F("hNtrUnCorrPSTrigPileUpVtxContSel",Form("Uncorrected %s multiplicity for PS + trigger name + pileup + with-vertex-contrib selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrUnCorrPSTrigPileUpVtxRangeSel = new TH1F("hNtrUnCorrPSTrigPileUpVtxRangeSel",Form("Uncorrected %s multiplicity for PS + trigger name + pileup + with-vertex-contrib-range selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrUnCorrPSTrigPileUpVtxRangeCentrSel = new TH1F("hNtrUnCorrPSTrigPileUpVtxRangeCentrSel",Form("Uncorrected %s multiplicity for PS + trigger name + pileup + with-vertex-contrib-range + centrality selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrUnCorrEvSel = new TH1F("hNtrUnCorrEvSel",Form("Uncorrected %s multiplicity for selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrUnCorrEvWithCand = new TH1F("hNtrUnCorrEvWithCand",Form("Uncorrected %s multiplicity for events with D candidates; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);// Total multiplicity
+  fHistNtrUnCorrEvWithD = new TH1F("hNtrUnCorrEvWithD",Form("Uncorrected %s multiplicity for events with D in mass region ; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin); //
+  fHistNtrCorrPSSel = new TH1F("hNtrCorrPSSel",Form("Corrected %s multiplicity for PS selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrCorrEvSel = new TH1F("hNtrCorrEvSel",Form("Corrected %s multiplicity for selected events; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);
+  fHistNtrCorrEvWithCand = new TH1F("hNtrCorrEvWithCand", Form("%s multiplicity for events with D candidates; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin);// Total multiplicity
+  fHistNtrCorrEvWithD = new TH1F("hNtrCorrEvWithD", Form("%s multiplicity for events with D in mass region ; %s ; Entries",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin); //
 
   if(fKeepCorrPlots){
     fHistNtrEta16vsNtrEta1EvSel = new TH2F("hNtrEta16vsNtrEta1EvSel","Uncorrected Eta1.6 vs Eta1.0 (events selected); Ntracklets #eta<1.0; Ntracklets #eta<1.6",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 1.6 vs eta 1.0 histogram 
     fHistNtrEta05vsNtrEta1EvSel = new TH2F("hNtrEta05vsNtrEta1EvSel","Uncorrected Eta0.5 vs Eta1.0 (events selected); Ntracklets #eta<1.0; Ntracklets #eta<0.5",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 0.5 vs eta 1.0 histogram 
     fHistNtrEta03vsNtrEta1EvSel = new TH2F("hNtrEta03vsNtrEta1EvSel","Uncorrected Eta0.3 vs Eta1.0 (events selected); Ntracklets #eta<1.0; Ntracklets #eta<0.3",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 0.3 vs eta 1.0 histogram 
     fHistNtrEtaV0AvsNtrEta1EvSel = new TH2F("hNtrEtaV0AvsNtrEta1EvSel","Uncorrected Eta-V0A vs Eta1.0 (events selected); Ntracklets #eta<1.0; Multiplicity V0A",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsV0,firstMultBin,lastMultBinV0); //eta V0A vs eta 1.0 histogram 
-    fHistNtrEtaV0MvsNtrEta1EvSel = new TH2F("hNtrEtaV0MvsNtrEta1EvSel","Uncorrected Eta-V0M vs Eta1.0 (events selected); Ntracklets #eta<1.0; Multiplicity V0A+V0C",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsV0,firstMultBin,lastMultBinV0); //eta V0M vs eta 1.0 histogram 
+    fHistNtrEtaV0MvsNtrEta1EvSel = new TH2F("hNtrEtaV0MvsNtrEta1EvSel","Uncorrected Eta-V0M vs Eta1.0 (events selected); Ntracklets #eta<1.0; Multiplicity V0A+V0C",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsV0,firstMultBin,lastMultBinV0); //eta V0M vs eta 1.0 histogram
+    fHistNtrEtaV0AvsV0AEqEvSel = new TH2F("hNtrEtaV0AvsV0AEqEvSel","Corrected V0A vs corrected V0A-Equalized (events selected); Vzero-A; Vzero-A Equalized",nMultBinsV0,firstMultBin,lastMultBinV0,nMultBinsV0,firstMultBin,lastMultBinV0); // comparison V0A - V0Aeq
+    fHistNtrEtaV0MvsV0MEqEvSel = new TH2F("hNtrEtaV0MvsV0MEqEvSel","Corrected V0M vs corrected V0M-Equalized (events selected); Vzero-M; Vzero-M Equalized",nMultBinsV0,firstMultBin,lastMultBinV0,nMultBinsV0,firstMultBin,lastMultBinV0); // comparison V0M - V0Meq
     fHistNtrCorrEta1vsNtrRawEta1EvSel = new TH2F("hNtrCorrEta1vsNtrRawEta1EvSel","Corrected Eta1 vs Eta1.0 (events selected); Ntracklets #eta<1.0 corrected; Ntracklets #eta<1",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 1.6 vs eta 1.0 histogram
+    fHistMultCorrvsMultRawEvSel = new TH2F("hMultCorrvsMultRawEvSel",Form("Corrected multiplicity vs uncorrected multiplicity (events selected); %s corrected; %s",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // corrected vs uncorrected multiplicity
 
     fHistNtrEta16vsNtrEta1EvWithCand = new TH2F("hNtrEta16vsNtrEta1EvWithCand","Uncorrected Eta1.6 vs Eta1.0 (events selected with a D candidate); Ntracklets #eta<1.0; Ntracklets #eta<1.6",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 1.6 vs eta 1.0 histogram 
     fHistNtrEta05vsNtrEta1EvWithCand = new TH2F("hNtrEta05vsNtrEta1EvWithCand","Uncorrected Eta0.5 vs Eta1.0 (events selected with a D candidate); Ntracklets #eta<1.0; Ntracklets #eta<0.5",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 0.5 vs eta 1.0 histogram 
     fHistNtrEta03vsNtrEta1EvWithCand = new TH2F("hNtrEta03vsNtrEta1EvWithCand","Uncorrected Eta0.3 vs Eta1.0 (events selected with a D candidate); Ntracklets #eta<1.0; Ntracklets #eta<0.3",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 0.3 vs eta 1.0 histogram 
     fHistNtrEtaV0AvsNtrEta1EvWithCand = new TH2F("hNtrEtaV0AvsNtrEta1EvWithCand","Uncorrected Eta-V0A vs Eta1.0 (events selected with a D candidate); Ntracklets #eta<1.0; Multiplicity V0A",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsV0,firstMultBin,lastMultBinV0); //eta V0A vs eta 1.0 histogram 
     fHistNtrEtaV0MvsNtrEta1EvWithCand = new TH2F("hNtrEtaV0MvsNtrEta1EvWithCand","Uncorrected Eta-V0M vs Eta1.0 (events selected with a D candidate); Ntracklets #eta<1.0; Multiplicity V0A+V0C",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsV0,firstMultBin,lastMultBinV0); //eta V0M vs eta 1.0 histogram 
+    fHistNtrEtaV0AvsV0AEqEvWithCand = new TH2F("hNtrEtaV0AvsV0AEqEvWithCand","Corrected V0A vs corrected V0A-Equalized (events selected with a D candidate); Vzero-A; Vzero-A Equalized",nMultBinsV0,firstMultBin,lastMultBinV0,nMultBinsV0,firstMultBin,lastMultBinV0); // comparison V0A - V0Aeq
+    fHistNtrEtaV0MvsV0MEqEvWithCand = new TH2F("hNtrEtaV0MvsV0MEqEvWithCand","Corrected V0M vs corrected V0M-Equalized (events selected with a D candidate); Vzero-M; Vzero-M Equalized",nMultBinsV0,firstMultBin,lastMultBinV0,nMultBinsV0,firstMultBin,lastMultBinV0); // comparison V0M - V0Meq
     fHistNtrCorrEta1vsNtrRawEta1EvWithCand = new TH2F("hNtrCorrEta1vsNtrRawEta1EvWithCand","Corrected Eta1 vs Eta1.0 (events selected with a D candidate); Ntracklets #eta<1.0 corrected; Ntracklets #eta<1",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 1.6 vs eta 1.0 histogram
+    fHistMultCorrvsMultRawEvWithCand = new TH2F("hMultCorrvsMultRawEvWithCand",Form("Corrected multiplicity vs uncorrected multiplicity (events selected) with a D candidate; %s corrected; %s",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // corrected vs uncorrected multiplicity
+
 
     fHistNtrEta16vsNtrEta1EvWithD = new TH2F("hNtrEta16vsNtrEta1EvWithD","Uncorrected Eta1.6 vs Eta1.0 (events selected with D in mass range); Ntracklets #eta<1.0; Ntracklets #eta<1.6",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 1.6 vs eta 1.0 histogram 
     fHistNtrEta05vsNtrEta1EvWithD = new TH2F("hNtrEta05vsNtrEta1EvWithD","Uncorrected Eta0.5 vs Eta1.0 (events selected with D in mass range); Ntracklets #eta<1.0; Ntracklets #eta<0.5",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 0.5 vs eta 1.0 histogram 
     fHistNtrEta03vsNtrEta1EvWithD = new TH2F("hNtrEta03vsNtrEta1EvWithD","Uncorrected Eta0.3 vs Eta1.0 (events selected with D in mass range); Ntracklets #eta<1.0; Ntracklets #eta<0.3",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 0.3 vs eta 1.0 histogram 
     fHistNtrEtaV0AvsNtrEta1EvWithD = new TH2F("hNtrEtaV0AvsNtrEta1EvWithD","Uncorrected Eta-V0A vs Eta1.0 (events selected with D in mass range); Ntracklets #eta<1.0; Multiplicity V0A",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsV0,firstMultBin,lastMultBinV0); //eta V0A vs eta 1.0 histogram 
     fHistNtrEtaV0MvsNtrEta1EvWithD = new TH2F("hNtrEtaV0MvsNtrEta1EvWithD","Uncorrected Eta-V0M vs Eta1.0 (events selected with D in mass range); Ntracklets #eta<1.0; Multiplicity V0A+V0C",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsV0,firstMultBin,lastMultBinV0); //eta V0M vs eta 1.0 histogram 
+    fHistNtrEtaV0AvsV0AEqEvWithD = new TH2F("hNtrEtaV0AvsV0AEqEvWithD","Corrected V0A vs corrected V0A-Equalized (events selected with D in mass range); Vzero-A; Vzero-A Equalized",nMultBinsV0,firstMultBin,lastMultBinV0,nMultBinsV0,firstMultBin,lastMultBinV0); // comparison V0A - V0Aeq
+    fHistNtrEtaV0MvsV0MEqEvWithD = new TH2F("hNtrEtaV0MvsV0MEqEvWithD","Corrected V0M vs corrected V0M-Equalized (events selected with D in mass range); Vzero-M; Vzero-M Equalized",nMultBinsV0,firstMultBin,lastMultBinV0,nMultBinsV0,firstMultBin,lastMultBinV0); // comparison V0M - V0Meq
     fHistNtrCorrEta1vsNtrRawEta1EvWithD = new TH2F("hNtrCorrEta1vsNtrRawEta1EvWithD","Corrected Eta1 vs Eta1.0 (events selected with D in mass range); Ntracklets #eta<1.0 corrected; Ntracklets #eta<1",nMultBinsNtrk,firstMultBin,lastMultBinNtrk,nMultBinsNtrk,firstMultBin,lastMultBinNtrk); //eta 1.6 vs eta 1.0 histogram
+    fHistMultCorrvsMultRawEvWithD = new TH2F("hMultCorrvsMultRawEvWithD",Form("Corrected multiplicity vs uncorrected multiplicity (events selected with D in mass range); %s corrected; %s",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // corrected vs uncorrected multiplicity
+
   }
-  fHistNtrVsZvtx = new TH2F("hNtrVsZvtx","Ntracklet vs VtxZ; VtxZ;N_{tracklet};",300,-15,15,nMultBins,firstMultBin,lastMultBin); // 
-  fHistNtrCorrVsZvtx = new TH2F("hNtrCorrVsZvtx","Ntracklet vs VtxZ; VtxZ;N_{tracklet};",300,-15,15,nMultBins,firstMultBin,lastMultBin); // 
+  fHistNtrVsZvtx = new TH2F("hNtrVsZvtx",Form("N%s vs VtxZ; VtxZ;N_{%s};",estimatorName,estimatorName),300,-15,15,nMultBins,firstMultBin,lastMultBin); //
+  fHistNtrCorrVsZvtx = new TH2F("hNtrCorrVsZvtx",Form("N%s vs VtxZ; VtxZ;N_{%s};",estimatorName,estimatorName),300,-15,15,nMultBins,firstMultBin,lastMultBin); //
 
-  fHistNtrVsNchMC = new TH2F("hNtrVsNchMC","Ntracklet vs NchMC; Nch;N_{tracklet};",nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // 
-  fHistNtrCorrVsNchMC = new TH2F("hNtrCorrVsNchMC","Ntracklet vs Nch; Nch;N_{tracklet};",nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // 
+  fHistNtrVsNchMC = new TH2F("hNtrVsNchMC",Form("N%s vs NchMC; Nch;N_{%s};",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); //
+  fHistNtrCorrVsNchMC = new TH2F("hNtrCorrVsNchMC",Form("N%s vs Nch; Nch;N_{%s};",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); //
   
-  fHistNtrVsNchMCPrimary = new TH2F("hNtrVsNchMCPrimary","Ntracklet vs Nch (Primary); Nch (Primary);N_{tracklet};",nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // 
-  fHistNtrCorrVsNchMCPrimary = new TH2F("hNtrCorrVsNchMCPrimary","Ntracklet vs Nch (Primary); Nch(Primary) ;N_{tracklet};",nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // 
+  fHistNtrVsNchMCPrimary = new TH2F("hNtrVsNchMCPrimary",Form("N%s vs Nch (Primary); Nch (Primary);N_{%s};",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); //
+  fHistNtrCorrVsNchMCPrimary = new TH2F("hNtrCorrVsNchMCPrimary",Form("N%s vs Nch (Primary); Nch(Primary) ;N_{%s};",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); //
 
-  fHistNtrVsNchMCPhysicalPrimary = new TH2F("hNtrVsNchMCPhysicalPrimary","Ntracklet vs Nch (Physical Primary); Nch (Physical Primary);N_{tracklet};",nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // 
-  fHistNtrCorrVsNchMCPhysicalPrimary = new TH2F("hNtrCorrVsMCPhysicalPrimary","Ntracklet vs Nch (Physical Primary); Nch (Physical Primary);N_{tracklet};",nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); // 
+  fHistNtrVsNchMCPhysicalPrimary = new TH2F("hNtrVsNchMCPhysicalPrimary",Form("N%s vs Nch (Physical Primary); Nch (Physical Primary);N_{%s};",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); //
+  fHistNtrCorrVsNchMCPhysicalPrimary = new TH2F("hNtrCorrVsMCPhysicalPrimary",Form("N%s vs Nch (Physical Primary); Nch (Physical Primary);N_{%s};",estimatorName,estimatorName),nMultBins,firstMultBin,lastMultBin,nMultBins,firstMultBin,lastMultBin); //
   
   fHistGenPrimaryParticlesInelGt0 = new TH1F("hGenPrimaryParticlesInelGt0","Multiplcity of generated charged particles ; Nparticles ; Entries",nMultBins,firstMultBin,lastMultBin);
 
@@ -446,19 +480,28 @@ void AliAnalysisTaskSEDvsMultiplicity::UserCreateOutputObjects()
     fOutput->Add(fHistNtrEta03vsNtrEta1EvSel);
     fOutput->Add(fHistNtrEtaV0AvsNtrEta1EvSel);
     fOutput->Add(fHistNtrEtaV0MvsNtrEta1EvSel);
+    fOutput->Add(fHistNtrEtaV0AvsV0AEqEvSel);
+    fOutput->Add(fHistNtrEtaV0MvsV0MEqEvSel);
     fOutput->Add(fHistNtrCorrEta1vsNtrRawEta1EvSel);
+    fOutput->Add(fHistMultCorrvsMultRawEvSel);
     fOutput->Add(fHistNtrEta16vsNtrEta1EvWithCand);
     fOutput->Add(fHistNtrEta05vsNtrEta1EvWithCand);
     fOutput->Add(fHistNtrEta03vsNtrEta1EvWithCand);
     fOutput->Add(fHistNtrEtaV0AvsNtrEta1EvWithCand);
     fOutput->Add(fHistNtrEtaV0MvsNtrEta1EvWithCand);
+    fOutput->Add(fHistNtrEtaV0AvsV0AEqEvWithCand);
+    fOutput->Add(fHistNtrEtaV0MvsV0MEqEvWithCand);
     fOutput->Add(fHistNtrCorrEta1vsNtrRawEta1EvWithCand);
+    fOutput->Add(fHistMultCorrvsMultRawEvWithCand);
     fOutput->Add(fHistNtrEta16vsNtrEta1EvWithD);
     fOutput->Add(fHistNtrEta05vsNtrEta1EvWithD);
     fOutput->Add(fHistNtrEta03vsNtrEta1EvWithD);
     fOutput->Add(fHistNtrEtaV0AvsNtrEta1EvWithD);
     fOutput->Add(fHistNtrEtaV0MvsNtrEta1EvWithD);
+    fOutput->Add(fHistNtrEtaV0AvsV0AEqEvWithD);
+    fOutput->Add(fHistNtrEtaV0MvsV0MEqEvWithD);
     fOutput->Add(fHistNtrCorrEta1vsNtrRawEta1EvWithD);
+    fOutput->Add(fHistMultCorrvsMultRawEvWithD);
   }
   fOutput->Add(fHistNtrVsZvtx);
   fOutput->Add(fHistNtrCorrVsZvtx);
@@ -624,12 +667,16 @@ void AliAnalysisTaskSEDvsMultiplicity::UserExec(Option_t */*option*/)
   }
   
 
-  Int_t vzeroMult=0;
-  Int_t vzeroMultA=0;
+  Int_t vzeroMult=0, vzeroMultA=0, vzeroMultC=0;
+  Int_t vzeroMultEq=0, vzeroMultAEq=0, vzeroMultCEq=0;
   AliAODVZERO *vzeroAOD = (AliAODVZERO*)aod->GetVZEROData();
   if(vzeroAOD) {
-    vzeroMultA = vzeroAOD->GetMTotV0A();
-    vzeroMult = vzeroMultA + vzeroAOD->GetMTotV0C();
+    vzeroMultA = static_cast<Int_t>(vzeroAOD->GetMTotV0A());
+    vzeroMultC = static_cast<Int_t>(vzeroAOD->GetMTotV0C());
+    vzeroMult = vzeroMultA + vzeroMultC;
+    vzeroMultAEq = static_cast<Int_t>(AliVertexingHFUtils::GetVZEROAEqualizedMultiplicity(aod));
+    vzeroMultCEq = static_cast<Int_t>(AliVertexingHFUtils::GetVZEROCEqualizedMultiplicity(aod));
+    vzeroMultEq = vzeroMultAEq + vzeroMultCEq;
   }
 
   Int_t countMult = countTreta1;
@@ -638,6 +685,8 @@ void AliAnalysisTaskSEDvsMultiplicity::UserExec(Option_t */*option*/)
   else if(fMultiplicityEstimator==kNtrk10to16) { countMult = countTreta16 - countTreta1; }
   else if(fMultiplicityEstimator==kVZERO) { countMult = vzeroMult; }
   else if(fMultiplicityEstimator==kVZEROA) { countMult = vzeroMultA; }
+  else if(fMultiplicityEstimator==kVZEROEq) { countMult = vzeroMultEq; }
+  else if(fMultiplicityEstimator==kVZEROAEq) { countMult = vzeroMultAEq; }
 
 
   fCounterU->StoreEvent(aod,fRDCutsAnalysis,fReadMC,countMult);
@@ -646,18 +695,53 @@ void AliAnalysisTaskSEDvsMultiplicity::UserExec(Option_t */*option*/)
   Double_t countTreta1corr=countTreta1;
   Double_t countCorr=countMult;
   AliAODVertex *vtx1 = (AliAODVertex*)aod->GetPrimaryVertex();
-  //  if(vtx1){
-  // FIX ME: No correction to the VZERO !!
-  if(vtx1 && (fMultiplicityEstimator!=kVZERO) && (fMultiplicityEstimator!=kVZEROA)){
+  // In case of VZERO multiplicity, consider the zvtx correction flag
+  //  fDoVZER0ParamVertexCorr: 0= none, 1= usual d2h, 2=AliESDUtils
+  Bool_t isDataDrivenZvtxCorr=kTRUE;
+  Bool_t isVtxOk=kFALSE;
+  Int_t vzeroMultACorr=vzeroMultA, vzeroMultCCorr=vzeroMultC, vzeroMultCorr=vzeroMult;
+  Int_t vzeroMultAEqCorr=vzeroMultAEq, vzeroMultCEqCorr=vzeroMultCEq, vzeroMultEqCorr=vzeroMultEq;
+  if(vtx1){
     if(vtx1->GetNContributors()>0){
       fHistNEvents->Fill(1);
-      TProfile* estimatorAvg = GetEstimatorHistogram(aod);
-      if(estimatorAvg){
-       countTreta1corr=AliVertexingHFUtils::GetCorrectedNtracklets(estimatorAvg,countTreta1,vtx1->GetZ(),fRefMult);
-       countCorr=AliVertexingHFUtils::GetCorrectedNtracklets(estimatorAvg,countMult,vtx1->GetZ(),fRefMult);
+      isVtxOk=kTRUE;
+    }
+  }
+  if(isVtxOk){
+    if( (fMultiplicityEstimator==kVZERO) || (fMultiplicityEstimator==kVZEROA) ||
+       (fMultiplicityEstimator==kVZEROEq) || (fMultiplicityEstimator==kVZEROAEq) ){
+      if(fDoVZER0ParamVertexCorr==0){
+       // do not correct
+       isDataDrivenZvtxCorr=kFALSE;
+      } else if (fDoVZER0ParamVertexCorr==2){
+       // use AliESDUtils correction
+       Float_t zvtx = vtx1->GetZ();
+       isDataDrivenZvtxCorr=kFALSE;
+       vzeroMultACorr = static_cast<Int_t>(AliESDUtils::GetCorrV0A(vzeroMultA,zvtx));
+       vzeroMultCCorr = static_cast<Int_t>(AliESDUtils::GetCorrV0C(vzeroMultC,zvtx));
+       vzeroMultCorr = vzeroMultACorr + vzeroMultCCorr;
+       vzeroMultAEqCorr = static_cast<Int_t>(AliESDUtils::GetCorrV0A(vzeroMultAEq,zvtx));
+       vzeroMultCEqCorr =static_cast<Int_t>( AliESDUtils::GetCorrV0C(vzeroMultCEq,zvtx));
+       vzeroMultEqCorr = vzeroMultAEqCorr + vzeroMultCEqCorr;
+       if(fMultiplicityEstimator==kVZERO) { countCorr = vzeroMultCorr; }
+       else if(fMultiplicityEstimator==kVZEROA) { countCorr = vzeroMultACorr; }
+       else if(fMultiplicityEstimator==kVZEROEq) { countCorr = vzeroMultEqCorr; }
+       else if(fMultiplicityEstimator==kVZEROAEq) { countCorr = vzeroMultAEqCorr; }
       }
     }
   }
+  // Data driven multiplicity z-vertex correction
+  if(isVtxOk && isDataDrivenZvtxCorr){
+    TProfile* estimatorAvg = GetEstimatorHistogram(aod);
+    if(estimatorAvg){
+      countTreta1corr=static_cast<Int_t>(AliVertexingHFUtils::GetCorrectedNtracklets(estimatorAvg,countTreta1,vtx1->GetZ(),fRefMult));
+      // vzeroMultACorr=static_cast<Int_t>(AliVertexingHFUtils::GetCorrectedNtracklets(estimatorAvg,vzeroMultA,vtx1->GetZ(),fRefMult));
+      // vzeroMultCorr= vzeroMultACorr + static_cast<Int_t>(AliVertexingHFUtils::GetCorrectedNtracklets(estimatorAvg,vzeroMultC,vtx1->GetZ(),fRefMult));
+      // vzeroMultAEqCorr=static_cast<Int_t>(AliVertexingHFUtils::GetCorrectedNtracklets(estimatorAvg,vzeroMultAEq,vtx1->GetZ(),fRefMult));
+      // vzeroMultEqCorr= vzeroMultAEqCorr + static_cast<Int_t>(AliVertexingHFUtils::GetCorrectedNtracklets(estimatorAvg,vzeroMultCEq,vtx1->GetZ(),fRefMult));
+      countCorr=static_cast<Int_t>(AliVertexingHFUtils::GetCorrectedNtracklets(estimatorAvg,countMult,vtx1->GetZ(),fRefMult));
+    }
+  }
 
 
   Bool_t isEvSel=fRDCutsAnalysis->IsEventSelected(aod);
@@ -704,7 +788,10 @@ void AliAnalysisTaskSEDvsMultiplicity::UserExec(Option_t */*option*/)
     fHistNtrEta03vsNtrEta1EvSel->Fill(countTreta1,countTreta03);
     fHistNtrEtaV0AvsNtrEta1EvSel->Fill(countTreta1,vzeroMultA);
     fHistNtrEtaV0MvsNtrEta1EvSel->Fill(countTreta1,vzeroMult);
+    fHistNtrEtaV0AvsV0AEqEvSel->Fill(vzeroMultA,vzeroMultAEq);
+    fHistNtrEtaV0MvsV0MEqEvSel->Fill(vzeroMult,vzeroMultEq);
     fHistNtrCorrEta1vsNtrRawEta1EvSel->Fill(countTreta1,countTreta1corr);
+    fHistMultCorrvsMultRawEvSel->Fill(countMult,countCorr);
   }
   if(vtx1){
     fHistNtrVsZvtx->Fill(vtx1->GetZ(),countMult);
@@ -1041,7 +1128,10 @@ void AliAnalysisTaskSEDvsMultiplicity::UserExec(Option_t */*option*/)
       fHistNtrEta03vsNtrEta1EvWithCand->Fill(countTreta1,countTreta03);
       fHistNtrEtaV0AvsNtrEta1EvWithCand->Fill(countTreta1,vzeroMultA);
       fHistNtrEtaV0MvsNtrEta1EvWithCand->Fill(countTreta1,vzeroMult);
+      fHistNtrEtaV0AvsV0AEqEvWithCand->Fill(vzeroMultA,vzeroMultAEq);
+      fHistNtrEtaV0MvsV0MEqEvWithCand->Fill(vzeroMult,vzeroMultEq);
       fHistNtrCorrEta1vsNtrRawEta1EvWithCand->Fill(countTreta1,countTreta1corr);
+      fHistMultCorrvsMultRawEvWithCand->Fill(countMult,countCorr);
     }
   }
   if(nSelectedInMassPeak>0) {
@@ -1053,7 +1143,10 @@ void AliAnalysisTaskSEDvsMultiplicity::UserExec(Option_t */*option*/)
       fHistNtrEta03vsNtrEta1EvWithD->Fill(countTreta1,countTreta03);
       fHistNtrEtaV0AvsNtrEta1EvWithD->Fill(countTreta1,vzeroMultA);
       fHistNtrEtaV0MvsNtrEta1EvWithD->Fill(countTreta1,vzeroMult);
+      fHistNtrEtaV0AvsV0AEqEvWithD->Fill(vzeroMultA,vzeroMultAEq);
+      fHistNtrEtaV0MvsV0MEqEvWithD->Fill(vzeroMult,vzeroMultEq);
       fHistNtrCorrEta1vsNtrRawEta1EvWithD->Fill(countTreta1,countTreta1corr);
+      fHistMultCorrvsMultRawEvWithD->Fill(countMult,countCorr);
     }
   }
 
index 54e7ba7..091bde4 100755 (executable)
@@ -101,7 +101,11 @@ class AliAnalysisTaskSEDvsMultiplicity : public AliAnalysisTaskSE
   void SetSubtractTrackletsFromDaughters(Bool_t opt){fSubtractTrackletsFromDau=opt;}
   Int_t CheckOrigin(TClonesArray* arrayMC, AliAODMCParticle *mcPartCandidate) const;
 
-  enum { kNtrk10=0, kNtrk10to16=1, kVZERO=2, kNtrk03=3, kNtrk05=4, kVZEROA=5 };
+  // Flag to use the zvtx correction from ( 0= none, 1= usual d2h, 2=AliESDUtils for VZERO multiplicity)
+  void SetUseVZEROParameterizedVertexCorr(Int_t flag) { fDoVZER0ParamVertexCorr=flag; }
+  Int_t GetUseVZEROParameterizedVertexCorr() { return fDoVZER0ParamVertexCorr; }
+
+  enum { kNtrk10=0, kNtrk10to16=1, kVZERO=2, kNtrk03=3, kNtrk05=4, kVZEROA=5, kVZEROEq=6, kVZEROAEq=7 };
   void SetMultiplicityEstimator(Int_t value){ fMultiplicityEstimator=value; }
   Int_t GetMultiplicityEstimator(){ return fMultiplicityEstimator; }
   enum { kEta10=0, kEta10to16=1, kEtaVZERO=2, kEta03=3, kEta05=5, kEtaVZEROA=5 };
@@ -137,19 +141,28 @@ class AliAnalysisTaskSEDvsMultiplicity : public AliAnalysisTaskSE
   TH2F* fHistNtrEta03vsNtrEta1EvSel; //!hist. for Ntracklets in eta<0.3 vs. eta<1.
   TH2F* fHistNtrEtaV0AvsNtrEta1EvSel; //!hist. for Ntracklets in eta-V0A vs. eta<1.
   TH2F* fHistNtrEtaV0MvsNtrEta1EvSel; //!hist. for Ntracklets in eta-V0M vs. eta<1.
+  TH2F* fHistNtrEtaV0AvsV0AEqEvSel;   //!hist. for V0A raw mult vs V0A equalized multiplicity
+  TH2F* fHistNtrEtaV0MvsV0MEqEvSel;   //!hist. for V0M raw mult vs V0M equalized multiplicity
   TH2F* fHistNtrCorrEta1vsNtrRawEta1EvSel; //!hist. for Ntracklets in eta<1 with and w/o corrections
+  TH2F* fHistMultCorrvsMultRawEvSel;       //!hist. for multiplicity with and w/o corrections
   TH2F* fHistNtrEta16vsNtrEta1EvWithCand; //!hist. for Ntracklets in eta<1.6 vs. eta<1. for events with a candidate
   TH2F* fHistNtrEta05vsNtrEta1EvWithCand; //!hist. for Ntracklets in eta<0.5 vs. eta<1. for events with a candidate
   TH2F* fHistNtrEta03vsNtrEta1EvWithCand; //!hist. for Ntracklets in eta<0.3 vs. eta<1. for events with a candidate
   TH2F* fHistNtrEtaV0AvsNtrEta1EvWithCand; //!hist. for Ntracklets in eta-V0A vs. eta<1. for events with a candidate
   TH2F* fHistNtrEtaV0MvsNtrEta1EvWithCand; //!hist. for Ntracklets in eta-V0M vs. eta<1. for events with a candidate
+  TH2F* fHistNtrEtaV0AvsV0AEqEvWithCand;     //!hist. for V0A raw mult vs V0A equalized multiplicity for events with a candidate
+  TH2F* fHistNtrEtaV0MvsV0MEqEvWithCand;     //!hist. for V0M raw mult vs V0M equalized multiplicity for events with a candidate
   TH2F* fHistNtrCorrEta1vsNtrRawEta1EvWithCand; //!hist. for Ntracklets in eta<1 with and w/o corrections for events with a candidate
+  TH2F* fHistMultCorrvsMultRawEvWithCand;       //!hist. for multiplicity with and w/o corrections for events with a candidate
   TH2F* fHistNtrEta16vsNtrEta1EvWithD; //!hist. for Ntracklets in eta<1.6 vs. eta<1. for events with a candidate in D mass peak
   TH2F* fHistNtrEta05vsNtrEta1EvWithD; //!hist. for Ntracklets in eta<0.5 vs. eta<1. for events with a candidate in D mass peak
   TH2F* fHistNtrEta03vsNtrEta1EvWithD; //!hist. for Ntracklets in eta<0.3 vs. eta<1. for events with a candidate in D mass peak
   TH2F* fHistNtrEtaV0AvsNtrEta1EvWithD; //!hist. for Ntracklets in eta-V0A vs. eta<1. for events with a candidate in D mass peak
   TH2F* fHistNtrEtaV0MvsNtrEta1EvWithD; //!hist. for Ntracklets in eta-V0M vs. eta<1. for events with a candidate in D mass peak
+  TH2F* fHistNtrEtaV0AvsV0AEqEvWithD;   //!hist. for V0A raw mult vs V0A equalized multiplicity with a candidate in D mass peak
+  TH2F* fHistNtrEtaV0MvsV0MEqEvWithD;   //!hist. for V0M raw mult vs V0M equalized multiplicity with a candidate in D mass peak
   TH2F* fHistNtrCorrEta1vsNtrRawEta1EvWithD; //!hist. for Ntracklets in eta<1 with and w/o corrections for events with a candidate in D mass peak
+  TH2F* fHistMultCorrvsMultRawEvWithD;       //!hist. for multiplicity with and w/o corrections for events with a candidate in D mass peak
 
   TH2F* fHistNtrVsZvtx; //!  hist of ntracklets vs Zvertex
   TH2F* fHistNtrCorrVsZvtx; //!  hist of ntracklets vs Zvertex
@@ -217,9 +230,11 @@ class AliAnalysisTaskSEDvsMultiplicity : public AliAnalysisTaskSE
   Int_t fPdgMeson;   // pdg code of analyzed meson
 
   Int_t fMultiplicityEstimator; // Definition of the multiplicity estimator: kNtrk10=0, kNtrk10to16=1, kVZERO=2
-  Int_t fMCPrimariesEstimator;  // Definition of the primaries estimator eta range: |eta|<1.0=0, -1.6<|eta|<1.0=1, VZEROrange=2 
+  Int_t fMCPrimariesEstimator;  // Definition of the primaries estimator eta range: |eta|<1.0=0, -1.6<|eta|<1.0=1, VZEROrange=2
+
+  Int_t fDoVZER0ParamVertexCorr; // Flag to use the zvtx correction from (0=none, 1=usual d2h, 2=AliESDUtils for VZERO multiplicity)
   
-  ClassDef(AliAnalysisTaskSEDvsMultiplicity,13); // D vs. mult task
+  ClassDef(AliAnalysisTaskSEDvsMultiplicity,14); // D vs. mult task
 };
 
 #endif
index 4e1814a..a8b9bd0 100644 (file)
@@ -239,6 +239,37 @@ Int_t AliVertexingHFUtils::GetGeneratedPhysicalPrimariesInEtaRange(TClonesArray*
   }
   return nChargedMC;
 }
+
+
+//______________________________________________________________________
+Double_t AliVertexingHFUtils::GetVZEROAEqualizedMultiplicity(AliAODEvent* ev){
+  //
+  // Method to get VZERO-A equalized multiplicty as done in AliCentralitySelectionTask
+  //  getting the equalized VZERO factors from the tender or AOD
+  // http://git.cern.ch/pubweb/AliRoot.git/blob/HEAD:/ANALYSIS/AliCentralitySelectionTask.cxx#l1345
+
+  Double_t multV0AEq=0;
+  for(Int_t iCh = 32; iCh < 64; ++iCh) {
+    Double_t mult = ev->GetVZEROEqMultiplicity(iCh);
+    multV0AEq += mult;
+  }
+  return multV0AEq;
+}
+
+//______________________________________________________________________
+Double_t AliVertexingHFUtils::GetVZEROCEqualizedMultiplicity(AliAODEvent* ev){
+  // Method to get VZERO-C equalized multiplicty as done in AliCentralitySelectionTask
+  //  getting the equalized VZERO factors from the tender or AOD
+  // http://git.cern.ch/pubweb/AliRoot.git/blob/HEAD:/ANALYSIS/AliCentralitySelectionTask.cxx#l1345
+
+  Double_t multV0CEq=0;
+  for(Int_t iCh = 0; iCh < 32; ++iCh) {
+    Double_t mult = ev->GetVZEROEqMultiplicity(iCh);
+    multV0CEq += mult;
+  }
+  return multV0CEq;
+}
+
 //______________________________________________________________________
 void AliVertexingHFUtils::AveragePt(Float_t& averagePt, Float_t& errorPt,Float_t ptmin,Float_t ptmax, TH2F* hMassD, Float_t massFromFit, Float_t sigmaFromFit, TF1* funcB2, Float_t sigmaRangeForSig,Float_t sigmaRangeForBkg, Float_t minMass, Float_t maxMass, Int_t rebin){
 
index 15e98f5..ed5580d 100644 (file)
@@ -89,6 +89,10 @@ class AliVertexingHFUtils : public TObject{
   static Int_t GetGeneratedPrimariesInEtaRange(TClonesArray* arrayMC, Double_t mineta, Double_t maxeta);
   static Int_t GetGeneratedPhysicalPrimariesInEtaRange(TClonesArray* arrayMC, Double_t mineta, Double_t maxeta);
 
+  // Utilities for V0 multiplicity checks
+  static Double_t GetVZEROAEqualizedMultiplicity(AliAODEvent* ev);
+  static Double_t GetVZEROCEqualizedMultiplicity(AliAODEvent* ev);
+
   // Functions for computing average pt 
   static void AveragePt(Float_t& averagePt, Float_t& errorPt, Float_t ptmin, Float_t ptmax, TH2F* hMassD, Float_t massFromFit, Float_t sigmaFromFit, TF1* funcB2, Float_t sigmaRangeForSig=2.5, Float_t sigmaRangeForBkg=4.5, Float_t minMass=0., Float_t maxMass=3., Int_t rebin=1);
 
index 76a7311..50e9a9a 100755 (executable)
@@ -107,11 +107,17 @@ AliAnalysisTaskSEDvsMultiplicity *AddTaskDvsMultiplicity(Int_t system=0,
 
     dMultTask->SetReferenceMultiplcity(refMult);
 
+    const Char_t* profilebasename="SPDmult10";
+    if(recoEstimator==AliAnalysisTaskSEDvsMultiplicity::kVZEROA || recoEstimator==AliAnalysisTaskSEDvsMultiplicity::kVZEROAEq) profilebasename="VZEROAmult";
+    else if(recoEstimator==AliAnalysisTaskSEDvsMultiplicity::kVZERO || recoEstimator==AliAnalysisTaskSEDvsMultiplicity::kVZEROEq) profilebasename="VZEROMmult";
+    cout<<endl<<endl<<" profilebasename="<<profilebasename<<endl<<endl;
+
     if (isPPbData) {    //Only use two profiles if pPb
       const Char_t* periodNames[2] = {"LHC13b", "LHC13c"};
       TProfile* multEstimatorAvg[2];
       for(Int_t ip=0; ip<2; ip++) {
-       multEstimatorAvg[ip] = (TProfile*)(fileEstimator->Get(Form("SPDmult10_%s",periodNames[ip]))->Clone(Form("SPDmult10_%s_clone",periodNames[ip])));
+       cout<< " Trying to get "<<Form("%s_%s",profilebasename,periodNames[ip])<<endl;
+       multEstimatorAvg[ip] = (TProfile*)(fileEstimator->Get(Form("%s_%s",profilebasename,periodNames[ip]))->Clone(Form("%s_%s_clone",profilebasename,periodNames[ip])));
        if (!multEstimatorAvg[ip]) {
          AliFatal(Form("Multiplicity estimator for %s not found! Please check your estimator file",periodNames[ip]));
          return;
@@ -124,7 +130,7 @@ AliAnalysisTaskSEDvsMultiplicity *AddTaskDvsMultiplicity(Int_t system=0,
       const Char_t* periodNames[4] = {"LHC10b", "LHC10c", "LHC10d", "LHC10e"};
       TProfile* multEstimatorAvg[4];                       
       for(Int_t ip=0; ip<4; ip++) {
-       multEstimatorAvg[ip] = (TProfile*)(fileEstimator->Get(Form("SPDmult10_%s",periodNames[ip]))->Clone(Form("SPDmult10_%s_clone",periodNames[ip])));
+       multEstimatorAvg[ip] = (TProfile*)(fileEstimator->Get(Form("%s_%s",profilebasename,periodNames[ip]))->Clone(Form("%s_%s_clone",profilebasename,periodNames[ip])));
        if (!multEstimatorAvg[ip]) {
          AliFatal(Form("Multiplicity estimator for %s not found! Please check your estimator file",periodNames[ip]));
          return;
index 1999e95..82936ea 100644 (file)
@@ -12,6 +12,7 @@
 #include <TH3.h>
 #include <TH3F.h>
 #include <TH1D.h>
+#include <TProfile.h>
 #include <TF1.h>
 #include <TSystem.h>
 #include <TStyle.h>
@@ -801,10 +802,16 @@ Bool_t CheckNtrVsZvtx(TH2F** hNtrackVsVtxZ, TH2F** hNtrackVsVtxZCorr, Int_t nFil
 
   TCanvas *cNtrVsZvtx = new TCanvas("cNtrVsZvtx","Ntr Vs Zvtx");
   cNtrVsZvtx->Divide(2,2);
+  TProfile **hProf = new TProfile*[nFiles];
+  TProfile **hProfCorr = new TProfile*[nFiles];
   for(Int_t i=0; i<nFiles; i++){
     cNtrVsZvtx->cd(i+1);
+    cNtrVsZvtx->SetLogz();
     //    hNtrackVsVtxZ[i]->Fit("pol4");
     hNtrackVsVtxZ[i]->Draw("colz");
+    hProf[i] = (TProfile*)hNtrackVsVtxZ[i]->ProfileX(Form("%s_%d","hProf",i));
+    hProf[i]->SetLineColor(kBlack);
+    hProf[i]->Draw("same");
     cNtrVsZvtx->Update();
   }
 
@@ -812,29 +819,31 @@ Bool_t CheckNtrVsZvtx(TH2F** hNtrackVsVtxZ, TH2F** hNtrackVsVtxZCorr, Int_t nFil
   cNtrVsZvtxCorr->Divide(2,2);
   for(Int_t i=0; i<nFiles; i++){
     cNtrVsZvtxCorr->cd(i+1);
+    cNtrVsZvtxCorr->SetLogz();
     //    hNtrackVsVtxZCorr[i]->Fit("pol4");
     hNtrackVsVtxZCorr[i]->Draw("colz");
+    hProfCorr[i] = (TProfile*)hNtrackVsVtxZCorr[i]->ProfileX(Form("%s_%d","hProfCorr",i));
+    hProfCorr[i]->SetLineColor(kBlack);
+    hProfCorr[i]->Draw("same");
+    cNtrVsZvtx->Update();
   }
 
   TH1F *hNtrAxis = (TH1F*)hNtrackVsVtxZ[0]->ProjectionY("hNtrAxis");
-  TH1F *hZvtx[nMultbins];
-  Int_t firstbin=0, lastbin=0;
+  TH1F *hZvtx[nFiles];
+  Int_t firstbin = hNtrAxis->FindBin( multlims[0] );
+  Int_t lastbin = hNtrAxis->FindBin( multlims[nMultbins] ) -1;
   TCanvas *cZvtx = new TCanvas("cZvtx","Zvtx projections");
   cZvtx->Divide(2,2);
   for(Int_t i=0; i<nFiles; i++){
     cZvtx->cd(i+1);
-    firstbin = hNtrAxis->FindBin( multlims[i] );
-    lastbin = hNtrAxis->FindBin( multlims[i+1] ) -1;
     hZvtx[i] = (TH1F*)hNtrackVsVtxZ[i]->ProjectionX(Form("hZvtx_%d",i),firstbin,lastbin);
     hZvtx[i]->Draw();
   }
-  TH1F *hZvtxCorr[nMultbins]; 
+  TH1F *hZvtxCorr[nFiles];
   TCanvas *cZvtxCorr = new TCanvas("cZvtxCorr","Zvtx projections Corr");
   cZvtxCorr->Divide(2,2);
   for(Int_t i=0; i<nFiles; i++){
     cZvtxCorr->cd(i+1);
-    firstbin = hNtrAxis->FindBin( multlims[i] );
-    lastbin = hNtrAxis->FindBin( multlims[i+1] ) -1;
     hZvtxCorr[i] = (TH1F*)hNtrackVsVtxZCorr[i]->ProjectionX(Form("hZvtxCorr_%d",i),firstbin,lastbin);
     hZvtxCorr[i]->Draw();
   }