first paper analysis code:
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 2 Dec 2009 08:27:48 +0000 (08:27 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 2 Dec 2009 08:27:48 +0000 (08:27 +0000)
http://arxiv.org/abs/0911.5430

PWG0/AliCorrection.cxx
PWG0/dNdEta/AlidNdEtaCorrectionTask.cxx
PWG0/dNdEta/AlidNdEtaCorrectionTask.h
PWG0/dNdEta/AlidNdEtaTask.cxx
PWG0/dNdEta/AlidNdEtaTask.h
PWG0/dNdEta/correct.C
PWG0/dNdEta/dNdEtaAnalysis.cxx
PWG0/dNdEta/drawPlots.C
PWG0/dNdEta/drawSystematics.C
PWG0/dNdEta/drawSystematicsNew.C
PWG0/dNdEta/run.C

index 85de079..38754b7 100644 (file)
@@ -44,6 +44,7 @@ AliCorrection::AliCorrection(const Char_t* name, const Char_t* title, AliPWG0Hel
   if ((analysisMode & AliPWG0Helper::kTPC || analysisMode & AliPWG0Helper::kTPCITS) && (analysisMode & AliPWG0Helper::kFieldOn))
   {
     static Float_t binLimitsPtTmp[] = {0.0, 0.05, 0.1, 0.125, 0.15, 0.175, 0.2, 0.225, 0.25, 0.275, 0.3, 0.325, 0.35, 0.375, 0.4, 0.425, 0.45, 0.475, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.5, 2.0, 5.0, 10.0, 100.0};
+    //static Float_t binLimitsPtTmp[] = {0.0, 0.05, 0.1, 0.125, 0.15, 0.175, 0.2, 0.225, 0.25, 0.275, 0.3, 0.325, 0.35, 0.375, 0.4, 0.425, 0.45, 0.475, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 2.0, 5.0, 10.0, 100.0};
     binLimitsPt = (Float_t*) binLimitsPtTmp;
     nBinsPt = 28;
   }
@@ -64,8 +65,10 @@ AliCorrection::AliCorrection(const Char_t* name, const Char_t* title, AliPWG0Hel
   Int_t nBinsN2 = 1;
   Float_t binLimitsN2[]   = {-0.5, 1000};
   const char* title3 = "Ntracks";
+  
   //Int_t nBinsN2 = 21;
   //Float_t binLimitsN2[]   = {-0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 12.5, 14.5, 16.5, 18.5, 20.5, 25.5, 30.5, 40.5, 50.5, 100.5, 1000.5};
+  
   // phi
   //Int_t nBinsN2 = 36;
   //Float_t binLimitsN2[]   = {0.000, 0.175, 0.349, 0.524, 0.698, 0.873, 1.047, 1.222, 1.396, 1.571, 1.745, 1.920, 2.094, 2.269, 2.443, 2.618, 2.793, 2.967, 3.142, 3.316, 3.491, 3.665, 3.840, 4.014, 4.189, 4.363, 4.538, 4.712, 4.887, 5.061, 5.236, 5.411, 5.585, 5.760, 5.934, 6.109, TMath::Pi() * 2};
@@ -86,8 +89,17 @@ AliCorrection::AliCorrection(const Char_t* name, const Char_t* title, AliPWG0Hel
                              0.2, 0.4, 0.6, 0.8, 1.0,
                              1.2, 1.4, 1.6, 1.8, 2.0,
                              2.2, 2.4, 2.6, 2.8, 3.0};*/
-  Float_t binLimitsEta[] = { -3.0, -2.9, -2.8, -2.7, -2.6, -2.5, -2.4, -2.3, -2.2, -2.1, -2.0, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, -0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0 };
-//  Float_t binLimitsEta[] = {-2,-1.8,-1.6,-1.4,-1.2,-1.0,-0.8,-0.6,-0.4,-0.2,0.0,0.2,0.4,0.6,0.8,1.0,1.2,1.4,1.6,1.8,2.0};
+  //Float_t binLimitsEta[] = { -3.0, -2.9, -2.8, -2.7, -2.6, -2.5, -2.4, -2.3, -2.2, -2.1, -2.0, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, -0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0 };
+  /*Float_t binLimitsEta[] = {-3,-2.75,-2.5,-2.25,-2.0,
+                            -1.75,-1.5,-1.25,
+                            -1,-0.75,-0.5,-0.25,
+                            0,0.25,0.5,0.75,
+                            1.0,1.25,1.5,1.75,
+                            2.0,2.25,2.5,2.75,3.0}; */
+  Float_t binLimitsEta[] = {-2.8,-2.4,-2,-1.6,-1.2,-0.8,-0.4,0,0.4,0.8,1.2,1.6,2.0,2.4,2.8}; 
+  //Float_t binLimitsEta[] = {-2.8,-2.4,-2,-1.6,-1.2,-0.8,-0.5,0,0.5,0.8,1.2,1.6,2.0,2.4,2.8}; 
+
+  //Float_t binLimitsEta[] = {-3,-2.6,-2.2,-1.8,-1.4,-1,-0.6,-0.2,0.2,0.6,1,1.4,1.8,2.2,2.6,3.0};
 //  Float_t binLimitsEta[] = {-2,-1.9,-1.8,-1.7,-1.6,-1.5,-1.4,-1.3,-1.2,-1.1,-1.0,-0.9,-0.8,-0.7,-0.6,-0.5,-0.4,-0.3,-0.2,-0.1,0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0};
 //  Float_t binLimitsEta[] = { -7.0, -6.9, -6.8, -6.7, -6.6, -6.5, -6.4, -6.3, -6.2, -6.1, -6.0, -5.9, -5.8, -5.7, -5.6, -5.5, -5.4, -5.3, -5.2, -5.1, -5.0, -4.9, -4.8, -4.7, -4.6, -4.5, -4.4, -4.3, -4.2, -4.1, -4.0, -3.9, -3.8, -3.7, -3.6, -3.5, -3.4, -3.3, -3.2, -3.1, -3.0, -2.9, -2.8, -2.7, -2.6, -2.5, -2.4, -2.3, -2.2, -2.1, -2.0, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3, -1.2, -1.1, -1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, -0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5.0, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6.0, 6.1, 6.2, 6.3, 6.4, 6.5, 6.6, 6.7, 6.8, 6.9, 7.0 };
 
@@ -95,14 +107,14 @@ AliCorrection::AliCorrection(const Char_t* name, const Char_t* title, AliPWG0Hel
 
   if (analysisMode & AliPWG0Helper::kSPD)
   {
-    TH3F* dummyBinning = new TH3F("dummyBinning","dummyBinning",18, binLimitsVtx, 60, binLimitsEta, nBinsN2, binLimitsN2);
+    TH3F* dummyBinning = new TH3F("dummyBinning","dummyBinning",18, binLimitsVtx, 14, binLimitsEta, nBinsN2, binLimitsN2);
     fTrackCorr = new AliCorrectionMatrix3D("TrackCorrection", Form("%s TrackCorrection", fTitle.Data()), dummyBinning);
     fTrackCorr->SetAxisTitles("vtx-z (cm)", "#eta", title3);
     delete dummyBinning;
   }
   else
   {
-    TH3F* dummyBinning = new TH3F("dummyBinning","dummyBinning",18, binLimitsVtx, 60, binLimitsEta , nBinsPt, binLimitsPt);
+    TH3F* dummyBinning = new TH3F("dummyBinning","dummyBinning",18, binLimitsVtx, 14, binLimitsEta , nBinsPt, binLimitsPt);
     fTrackCorr = new AliCorrectionMatrix3D("TrackCorrection", Form("%s TrackCorrection", fTitle.Data()), dummyBinning);
     fTrackCorr->SetAxisTitles("vtx-z (cm)", "#eta", "p_{T} (GeV/c)");
     delete dummyBinning;
@@ -461,6 +473,7 @@ void AliCorrection::PrintInfo(Float_t ptCut)
 
   Printf("Example centered bin: tracks measured: %.1f tracks generated: %.1f, events measured: %.1f, events generated %.1f", measured->GetBinContent(measured->GetNbinsX() / 2, measured->GetNbinsY() / 2, measured->GetNbinsZ() / 2), generated->GetBinContent(measured->GetNbinsX() / 2, measured->GetNbinsY() / 2, measured->GetNbinsZ() / 2), measuredEvents->GetBinContent(measuredEvents->GetNbinsX() / 2, measuredEvents->GetNbinsY() / 2), generatedEvents->GetBinContent(measuredEvents->GetNbinsX() / 2, measuredEvents->GetNbinsY() / 2));
 
+  PrintStats(10, 0.6, ptCut);
   PrintStats(10, 0.8, ptCut);
   PrintStats(10, 1.5, ptCut);
 }
index d3cfa70..2dde4d9 100644 (file)
@@ -42,6 +42,7 @@ AlidNdEtaCorrectionTask::AlidNdEtaCorrectionTask() :
   fTrigger(AliTriggerAnalysis::kMB1),
   fFillPhi(kFALSE),
   fDeltaPhiCut(-1),
+  fSymmetrize(kFALSE),
   fSignMode(0),
   fOnlyPrimaries(kFALSE),
   fStatError(0),
@@ -91,6 +92,7 @@ AlidNdEtaCorrectionTask::AlidNdEtaCorrectionTask(const char* opt) :
   fTrigger(AliTriggerAnalysis::kMB1),
   fFillPhi(kFALSE),
   fDeltaPhiCut(0),
+  fSymmetrize(kFALSE),
   fSignMode(0),
   fOnlyPrimaries(kFALSE),
   fStatError(0),
@@ -457,6 +459,8 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
         continue;
       
       etaArr[inputCount] = mult->GetEta(i);
+      if (fSymmetrize)
+        etaArr[inputCount] = TMath::Abs(etaArr[inputCount]);
       labelArr[inputCount] = mult->GetLabel(i, 0);
       labelArr2[inputCount] = mult->GetLabel(i, 1);
       thirdDimArr[inputCount] = phi;
@@ -509,6 +513,8 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
         }        
   
         etaArr[inputCount] = esdTrack->Eta();
+        if (fSymmetrize)
+          etaArr[inputCount] = TMath::Abs(etaArr[inputCount]);
         labelArr[inputCount] = TMath::Abs(esdTrack->GetLabel());
         labelArr2[inputCount] = labelArr[inputCount]; // no second label for tracks
         thirdDimArr[inputCount] = esdTrack->Pt();
@@ -608,6 +614,8 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
       fPIDParticles->Fill(particle->GetPdgCode());
 
     Float_t eta = particle->Eta();
+    if (fSymmetrize)
+      eta = TMath::Abs(eta);
     
     Float_t thirdDim = -1;
     if (fAnalysisMode & AliPWG0Helper::kSPD)
@@ -740,7 +748,10 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
       processed++;
 
       // resolutions
-      fEtaResolution->Fill(particle->Eta() - etaArr[i]);
+      if (fSymmetrize)
+        fEtaResolution->Fill(TMath::Abs(particle->Eta()) - etaArr[i]);
+      else
+        fEtaResolution->Fill(particle->Eta() - etaArr[i]);
 
       if (fAnalysisMode & AliPWG0Helper::kTPC || fAnalysisMode & AliPWG0Helper::kTPCITS)
         if (TMath::Abs(particle->Eta() < 0.9) && particle->Pt() > 0)
@@ -754,6 +765,8 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
       if (label == label2)
       {
         eta = particle->Eta();
+        if (fSymmetrize)
+          eta = TMath::Abs(eta);
         
         if (fAnalysisMode & AliPWG0Helper::kSPD)
         {
@@ -808,12 +821,19 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
       // eta comparison for tracklets with the same label (others are background)
       if (label == label2)
       {
-        fEtaProfile->Fill(particle->Eta(), particle->Eta() - etaArr[i]);
-        fEtaCorrelation->Fill(etaArr[i], particle->Eta());
-        fEtaCorrelationShift->Fill(particle->Eta(), particle->Eta() - etaArr[i]);
+        Float_t eta2 = particle->Eta();
+        if (fSymmetrize)
+          eta2 = TMath::Abs(eta2);
+        
+        fEtaProfile->Fill(eta2, eta2 - etaArr[i]);
+        fEtaCorrelation->Fill(etaArr[i], eta2);
+        fEtaCorrelationShift->Fill(eta2, eta2 - etaArr[i]);
       }
 
-      fdNdEtaAnalysisESD->FillTrack(vtxMC[2], particle->Eta(), thirdDim);
+      if (fSymmetrize)
+        fdNdEtaAnalysisESD->FillTrack(vtxMC[2], TMath::Abs(particle->Eta()), thirdDim);
+      else
+        fdNdEtaAnalysisESD->FillTrack(vtxMC[2], particle->Eta(), thirdDim);
 
       if (fOption.Contains("process-types"))
       {
index c8b45cc..ba26c41 100644 (file)
@@ -35,6 +35,7 @@ class AlidNdEtaCorrectionTask : public AliAnalysisTask {
     void SetTrigger(AliTriggerAnalysis::Trigger trigger) { fTrigger = trigger; }
     void SetFillPhi(Bool_t flag = kTRUE) { fFillPhi = flag; }
     void SetDeltaPhiCut(Float_t cut) { fDeltaPhiCut = cut; }
+    void SetSymmetrize(Bool_t flag = kTRUE) { fSymmetrize = flag; }
 
     void SetOption(const char* opt) { fOption = opt; }
 
@@ -49,6 +50,7 @@ class AlidNdEtaCorrectionTask : public AliAnalysisTask {
     AliTriggerAnalysis::Trigger fTrigger;      // trigger used in the analysis
     Bool_t fFillPhi;                           // if true phi is filled as 3rd coordinate in all maps
     Float_t fDeltaPhiCut;                      // cut in delta phi (only SPD)
+    Bool_t  fSymmetrize;     // move all negative to positive eta
 
     Int_t fSignMode;                 // if 0 process all particles, if +-1 process only particles with that sign
     Bool_t fOnlyPrimaries;           // only process primaries (syst. studies)
index 5bb041a..3d7de5e 100644 (file)
@@ -29,6 +29,7 @@
 #include <AliMCEventHandler.h>
 #include <AliMCEvent.h>
 #include <AliESDInputHandler.h>
+#include <AliESDInputHandlerRP.h>
 #include <AliESDHeader.h>
 
 #include "AliESDtrackCuts.h"
@@ -53,6 +54,8 @@ AlidNdEtaTask::AlidNdEtaTask(const char* opt) :
   fUseMCVertex(kFALSE),
   fOnlyPrimaries(kFALSE),
   fUseMCKine(kFALSE),
+  fCheckEventType(kFALSE),
+  fSymmetrize(kFALSE),
   fEsdTrackCuts(0),
   fdNdEtaAnalysisESD(0),
   fMult(0),
@@ -67,14 +70,18 @@ AlidNdEtaTask::AlidNdEtaTask(const char* opt) :
   fdNdEtaAnalysisTracks(0),
   fPartPt(0),
   fVertex(0),
+  fVertexVsMult(0),
   fPhi(0),
   fRawPt(0),
   fEtaPhi(0),
   fDeltaPhi(0),
   fDeltaTheta(0),
   fFiredChips(0),
+  fTrackletsVsClusters(0),
+  fTrackletsVsUnassigned(0),
   fTriggerVsTime(0),
-  fStats(0)
+  fStats(0),
+  fStats2(0)
 {
   //
   // Constructor. Initialization of pointers
@@ -197,11 +204,29 @@ void AlidNdEtaTask::CreateOutputObjects()
   fTriggerVsTime->GetYaxis()->SetTitle("count");
   fOutput->Add(fTriggerVsTime);
 
-  fStats = new TH1F("fStats", "fStats", 3, 0.5, 3.5);
+  fStats = new TH1F("fStats", "fStats", 5, 0.5, 5.5);
   fStats->GetXaxis()->SetBinLabel(1, "vertexer 3d");
   fStats->GetXaxis()->SetBinLabel(2, "vertexer z");
   fStats->GetXaxis()->SetBinLabel(3, "trigger");
+  fStats->GetXaxis()->SetBinLabel(4, "physics events");
+  fStats->GetXaxis()->SetBinLabel(5, "physics events after veto");
   fOutput->Add(fStats);
+  
+  fStats2 = new TH2F("fStats2", "fStats2", 6, -0.5, 5.5, 7, -0.5, 6.5);
+  fStats2->GetXaxis()->SetBinLabel(1, "No Vertex");
+  fStats2->GetXaxis()->SetBinLabel(2, "|z-vtx| > 10");
+  fStats2->GetXaxis()->SetBinLabel(3, "0 tracklets");
+  fStats2->GetXaxis()->SetBinLabel(4, "Splash identification");
+  fStats2->GetXaxis()->SetBinLabel(5, "Scan Veto");
+  fStats2->GetXaxis()->SetBinLabel(6, "Selected");
+  fStats2->GetYaxis()->SetBinLabel(1, "n/a");
+  fStats2->GetYaxis()->SetBinLabel(2, "emptyA");
+  fStats2->GetYaxis()->SetBinLabel(3, "emptyC");
+  fStats2->GetYaxis()->SetBinLabel(4, "emptyAC");
+  fStats2->GetYaxis()->SetBinLabel(5, "BB");
+  fStats2->GetYaxis()->SetBinLabel(6, "BGA");
+  fStats2->GetYaxis()->SetBinLabel(7, "BGC");
+  fOutput->Add(fStats2);
 
   if (fAnalysisMode & AliPWG0Helper::kSPD)
   {
@@ -211,6 +236,10 @@ void AlidNdEtaTask::CreateOutputObjects()
     fOutput->Add(fDeltaTheta);
     fFiredChips = new TH2F("fFiredChips", "fFiredChips;Chips L1 + L2;tracklets", 1201, -0.5, 1201, 50, -0.5, 49.5);
     fOutput->Add(fFiredChips);
+    fTrackletsVsClusters = new TH2F("fTrackletsVsClusters", ";tracklets;clusters in ITS", 50, -0.5, 49.5, 1000, -0.5, 999.5);
+    fOutput->Add(fTrackletsVsClusters);
+    fTrackletsVsUnassigned = new TH2F("fTrackletsVsUnassigned", ";tracklets;unassigned clusters in L0", 50, -0.5, 49.5, 200, -0.5, 199.5);
+    fOutput->Add(fTrackletsVsUnassigned);
     for (Int_t i=0; i<2; i++)
     {
       fZPhi[i] = new TH2F(Form("fZPhi_%d", i), Form("fZPhi Layer %d;z (cm);#phi (rad.)", i), 200, -20, 20, 180, 0, TMath::Pi() * 2);
@@ -224,8 +253,11 @@ void AlidNdEtaTask::CreateOutputObjects()
     fOutput->Add(fRawPt);
   }
 
-  fVertex = new TH3F("vertex_check", "vertex_check", 100, -1, 1, 100, -1, 1, 100, -30, 30);
+  fVertex = new TH3F("vertex_check", "vertex_check;x;y;z", 100, -1, 1, 100, -1, 1, 100, -30, 30);
   fOutput->Add(fVertex);
+  
+  fVertexVsMult = new TH3F("fVertexVsMult", "fVertexVsMult;x;y;multiplicity", 100, -1, 1, 100, -1, 1, 100, -0.5, 99.5);
+  fOutput->Add(fVertexVsMult);
 
   if (fReadMC)
   {
@@ -273,7 +305,6 @@ void AlidNdEtaTask::Exec(Option_t*)
   // ESD analysis
   if (fESD)
   {
-    // check event type (should be PHYSICS = 7)
     AliESDHeader* esdHeader = fESD->GetHeader();
     if (!esdHeader)
     {
@@ -281,15 +312,580 @@ void AlidNdEtaTask::Exec(Option_t*)
       return;
     }
     
-    Printf("Trigger classes: %s:", fESD->GetFiredTriggerClasses().Data());
+    //Printf("Trigger classes: %s:", fESD->GetFiredTriggerClasses().Data());
 
-//    UInt_t eventType = esdHeader->GetEventType();
-//     if (eventType != 7)
-//     {
-//       Printf("Skipping event because it is of type %d", eventType);
-//       return;
-//     }
+    // check event type (should be PHYSICS = 7)
+    if (fCheckEventType)
+    {
+      UInt_t eventType = esdHeader->GetEventType();
+      if (eventType != 7)
+      {
+        Printf("Skipping event because it is of type %d", eventType);
+        return;
+      }
+      
+      fStats->Fill(4);
+      
+      const Int_t kMaxEvents = 30;
+      UInt_t maskedEvents[kMaxEvents][2] = { 
+      {0, 0x1ac4a5},
+      {0, 0x4a34af}, 
+      {0, 0x697b0f}, 
+      {0, 0x74a07d}, 
+      {0, 0x864339}, 
+      {0, 0x94fbfb}, 
+      {0, 0xb87d2b}, 
+      {0, 0xd471f3}, 
+      {0, 0xddb0e3}, 
+      {0, 0xf30af3}, 
+      {1, 0xef46f}, 
+      {1, 0x12cdd1}, 
+      {1, 0x2d7591}, 
+      {1, 0x925245}, 
+      {1, 0x9af0fd}, 
+      {1, 0xb880d5}, 
+      {1, 0xb91b0b}, 
+      {0, 0x134066}, 
+      {0, 0x140dbc}, 
+      {0, 0x1d85f6}, 
+      {0, 0x8cb1da}, 
+      {0, 0xf9b31c}, 
+      {1, 0x500dbc}, 
+      {1, 0x587134}, 
+      {1, 0x687dbe}, 
+      {1, 0x6eab78}, 
+      {1, 0x894caa},
+      {0, 0x845fb3}, 
+      {0, 0x22b966}, 
+      {0, 0xb1d576}
+   
+//      {0, 0xbe8f99}, //put back in after discussion with adam
+//      {1, 0x2b43d4}, //put back in after discussion with adam
+
+/*      ,{0, 0x23585E}, // jet test
+      {0, 0x50EF2F},
+      {0, 0x672ADD}*/
+      };
+      
+      Bool_t veto = kFALSE;
 
+      for (Int_t i=0; i<kMaxEvents; i++)
+      {
+        if (fESD->GetPeriodNumber() == maskedEvents[i][0] && fESD->GetOrbitNumber() == maskedEvents[i][1])
+        {
+           Printf("Skipping event because it is masked: period: %d orbit: %x", fESD->GetPeriodNumber(), fESD->GetOrbitNumber());
+           veto = kTRUE;
+        }
+      }
+      
+      Int_t decision = (veto) ? 4 : -1;
+      
+      if (!veto)
+      {
+        // ITS cluster tree
+        AliESDInputHandlerRP* handlerRP = dynamic_cast<AliESDInputHandlerRP*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+        if (!handlerRP)
+          return;
+          
+        TTree* itsClusterTree = handlerRP->GetTreeR("ITS");  
+        if (!itsClusterTree)
+          return;
+          
+        TClonesArray* itsClusters = new TClonesArray("AliITSRecPoint");
+        TBranch* itsClusterBranch=itsClusterTree->GetBranch("ITSRecPoints");
+      
+        itsClusterBranch->SetAddress(&itsClusters);
+      
+        Int_t nItsSubs = (Int_t)itsClusterTree->GetEntries();  
+      
+        Int_t totalClusters = 0;
+          
+        // loop over the its subdetectors
+        for (Int_t iIts=0; iIts < nItsSubs; iIts++) {
+          
+          if (!itsClusterTree->GetEvent(iIts)) 
+            continue;
+          
+          Int_t nClusters = itsClusters->GetEntriesFast();
+          totalClusters += nClusters;
+        }
+                
+        const AliMultiplicity* mult = fESD->GetMultiplicity();
+        if (!mult)
+          return;
+        
+        fTrackletsVsClusters->Fill(mult->GetNumberOfTracklets(), totalClusters);
+              
+        Int_t limit = 80 + mult->GetNumberOfTracklets() * 220/20;
+        
+        if (totalClusters > limit)
+        {
+          Printf("Skipping event because %d clusters is above limit of %d from %d tracklets: Period number: %d Orbit number: %x", totalClusters, limit, mult->GetNumberOfTracklets(), fESD->GetPeriodNumber(), fESD->GetOrbitNumber());
+          decision = 3;
+        }
+        else 
+        {
+          vtxESD = AliPWG0Helper::GetVertex(fESD, fAnalysisMode);
+          if (!vtxESD)
+          {
+            decision = 0;
+          }
+          else
+          {
+            Double_t vtx[3];
+            vtxESD->GetXYZ(vtx);
+            
+            if (TMath::Abs(vtx[2]) > 10)
+            {
+              decision = 1;
+            }
+            else
+            {
+              if (mult->GetNumberOfTracklets() == 0)
+              {
+                decision = 2;
+              }
+              else
+              {
+                decision = 5;
+              }
+            }
+          }
+        }
+      }
+      
+      const Int_t kMaxVZero = 190;
+      
+      #define emptyA 1
+      #define emptyC 2
+      #define BBA 3
+      #define BBC 4
+      #define BGA 5
+      #define BGC 6
+      UInt_t vzeroAnalysis[kMaxVZero][4] = {
+        
+        {0, 0x5d31bc, emptyA, BBC},
+        {0, 0x5e4dcc, BBA, BBC},
+        {0, 0x6063a8, BBA, BBC},
+        {0, 0x613d53, BBA, BBC},
+        {0, 0x655069, BBA, BBC},
+        {0, 0x65e1cf, BBA, BBC},
+        {0, 0x66cea0, BBA, BBC},
+        {0, 0x672add, BBA, BBC},
+        {0, 0x68e567, BBA, BBC},
+        {0, 0x697b0f, BBA, emptyC},
+        {0, 0x6a686d, BGA, BBC},
+        {0, 0x6c4c2f, BBA, BBC},
+        {0, 0x6ca84d, BBA, BBC},
+        {0, 0x6ee60b, BBA, BBC},
+        {0, 0x6fa64f, BBA, BBC},
+        {0, 0x71cc8d, BBA, BBC},
+        {0, 0x74a07d, BBA, BBC},
+        {0, 0x77761b, BGA, BBC},
+        {0, 0x783454, BBA, BBC},
+        {0, 0x7d2414, BBA, BBC},
+        {0, 0x7f443f, BBA, BBC},
+        {0, 0x815daa, BBA, BBC},
+        {0, 0x8367dd, BBA, BBC},
+        {0, 0x838852, BBA, BBC},
+        {0, 0x845fb3, BBA, BBC},
+        {0, 0x84c722, emptyA, BBC},
+        {0, 0x86256e, BBA, BBC},
+        {0, 0x864339, BBA, BBC},
+        {0, 0x869be0, BGA, BBC},
+        {0, 0x895222, BBA, BBC},
+        {0, 0x8c1a56, emptyA, BBC},
+        {0, 0x8cb1da, BBA, BBC},
+        {0, 0x8e954e, BBA, BGC},
+        {0, 0x8fe645, BBA, BBC},
+        {0, 0x91bafc, BBA, BBC},
+        {0, 0x93ae80, BBA, BBC},
+        {0, 0x94f793, BBA, BBC},
+        {0, 0x94fbfb, BBA, BBC},
+        {0, 0x954c20, emptyA, BBC},
+        {0, 0x965e0f, BBA, BBC},
+        {0, 0x96a30e, BBA, BBC},
+        {0, 0x972f1d, BBA, BBC},
+        {0, 0x98fd10, BBA, BBC},
+        {0, 0x9a0472, BBA, BBC},
+        {0, 0x9c4894, BBA, BBC},
+        {0, 0x9e6dc8, emptyA, emptyC},
+        {0, 0x9f5e8b, BBA, BBC},
+        {0, 0xa035bb, BBA, BGC},
+        {0, 0xa53f7c, BBA, BBC},
+        {0, 0xa56537, BBA, BBC},
+        {0, 0xa60957, BBA, BBC},
+        {0, 0xa689db, BBA, BBC},
+        {0, 0xa6d494, BBA, BBC},
+        {0, 0xa6d935, BBA, BBC},
+        {0, 0xa8671a, BBA, BBC},
+        {0, 0xaa7956, BBA, BBC},
+        {0, 0xaee392, BBA, BBC},
+        {0, 0xb1d576, BBA, BBC},
+        {0, 0xb235c3, BBA, BGC},
+        {0, 0xb24b2d, BBA, BBC},
+        {0, 0xb2f999, BBA, emptyC},
+        {0, 0xb5acac, BBA, BBC},
+        {0, 0xb60ef4, BBA, BBC},
+        {0, 0xb7f38a, BBA, BBC},
+        {0, 0xb87d2b, BBA, BBC},
+        {0, 0xb8d564, BGA, BBC},
+        {0, 0xb9722e, BBA, BBC},
+        {0, 0xb98a5b, BBA, BBC},
+        {0, 0xb99f55, BBA, BBC},
+        {0, 0xbda770, BBA, BBC},
+        {0, 0xbe8f99, BBA, BBC},
+        {0, 0xc226a0, emptyA, BBC},
+        {0, 0xc2b248, BBA, BBC},
+        {0, 0xc56f42, emptyA, emptyC},
+        {0, 0xc6ec01, BBA, emptyC},
+        {0, 0xc768f2, BBA, BBC},
+        {0, 0xc7f149, BBA, BBC},
+        {0, 0xc94a96, BBA, BBC},
+        {0, 0xcbf834, BBA, BBC},
+        {0, 0xce4b94, BBA, BBC},
+        {0, 0xcf1b7b, BBA, BBC},
+        {0, 0xcf7257, BBA, BBC},
+        {0, 0xcffe10, BBA, BBC},
+        {0, 0xd471f3, BBA, BBC},
+        {0, 0xd5b0c6, BBA, BGC},
+        {0, 0xd5c7e7, BBA, BBC},
+        {0, 0xd8b421, emptyA, emptyC},
+        {0, 0xd978ed, BBA, BBC},
+        {0, 0xdbee52, BBA, emptyC},
+        {0, 0xdc0425, BBA, BBC},
+        {0, 0xdcc9e1, BBA, BBC},
+        {0, 0xddb0e3, BBA, BBC},
+        {0, 0xddd1a7, BGA, BBC},
+        {0, 0xdfd2c6, BBA, BBC},
+        {0, 0xe1db66, BBA, BBC},
+        {0, 0xe27106, BBA, BBC},
+        {0, 0xe69c79, BBA, BBC},
+        {0, 0xe71d7b, BBA, BBC},
+        {0, 0xe80a68, BBA, BBC},
+        {0, 0xea06fc, BBA, BBC},
+        {0, 0xf01c8e, BBA, BBC},
+        {0, 0xf08660, BBA, BBC},
+        {0, 0xf1a165, BBA, BBC},
+        {0, 0xf30af3, BBA, BBC},
+        {0, 0xf7635b, BGA, BBC},
+        {0, 0xf7a36c, emptyA, BBC},
+        {0, 0xf9b31c, BBA, BBC},
+        {0, 0xfb35f9, emptyA, BBC},
+        {0, 0xfc22dd, BBA, BBC},
+        {0, 0xfe58ba, BBA, BBC},
+        {0, 0xff5c1f, BBA, BBC},
+        {0, 0xff93b5, emptyA, BBC},
+        {1, 0x3513, BBA, BBC},
+        {1, 0x20656, BBA, BBC},
+        {1, 0x4345d, BBA, BBC},
+        {1, 0x5ec2f, BBA, BBC},
+        {1, 0x8140f, BBA, BBC},
+        {1, 0x93898, BBA, BBC},
+        {1, 0xef46f, BBA, BBC},
+        {1, 0xfff01, BGA, BBC},
+        {1, 0x10ce3e, BBA, BBC},
+        {1, 0x117f6a, BBA, BBC},
+        {1, 0x12cdd1, BBA, emptyC},
+        {1, 0x14b973, BBA, BGC},
+        {1, 0x155e84, BBA, BBC},
+        {1, 0x181dda, BBA, BBC},
+        {1, 0x1bd5b5, BBA, BBC},
+        {1, 0x1ca304, BBA, BBC},
+        {1, 0x1d095a, emptyA, BBC},
+        {1, 0x1e0125, BBA, BBC},
+        {1, 0x24a1c5, BBA, BBC},
+        {1, 0x24c960, BBA, BBC},
+        {1, 0x2638f4, BBA, BBC},
+        {1, 0x27cdee, BBA, BBC},
+        {1, 0x283e0d, BBA, BBC},
+        {1, 0x29b1f3, BBA, BBC},
+        {1, 0x2b43d4, BBA, BBC},
+        {1, 0x2bb918, BBA, BBC},
+        {1, 0x2d7591, BBA, BBC},
+        {1, 0x2da5ac, BGA, BBC},
+        {1, 0x2e2d65, BBA, BBC},
+        {1, 0x33bef9, BBA, BBC},
+        {1, 0x35505d, BBA, BBC},
+        {1, 0x36084d, BBA, BBC},
+        {1, 0x380b1f, emptyA, emptyC},
+        {1, 0x38d478, BBA, BBC},
+        {1, 0x3a0622, BBA, BBC},
+        {1, 0x3a194e, emptyA, emptyC},
+        {1, 0x3b5972, emptyA, BBC},
+        {1, 0x3ed6f5, BBA, BBC},
+        {1, 0x3ef093, BBA, BBC},
+        {1, 0x422847, BBA, BBC},
+        {1, 0x426bbb, BBA, BBC},
+        {1, 0x4b2f9b, BBA, BBC},
+        {1, 0x4c5781, emptyA, BBC},
+        {1, 0x4f1137, BBA, BBC},
+        {1, 0x4fe5ae, BBA, BBC},
+        {1, 0x500dbc, BBA, BBC},
+        {1, 0x502a5e, BGA, BBC},
+        {1, 0x505769, BBA, BBC},
+        {1, 0x507bd3, BBA, BBC},
+        {1, 0x55b3ef, BBA, BBC},
+        {1, 0x56333f, BBA, BBC},
+        {1, 0x587134, BBA, BBC},
+        {1, 0x5b4847, BBA, BGC},
+        {1, 0x5b777a, BBA, BBC},
+        {1, 0x5b7dde, BBA, BBC},
+        {1, 0x5b7e14, BBA, BBC},
+        {1, 0x5cd9ca, BBA, BBC},
+        {1, 0x5e7c42, BBA, BBC},
+        {1, 0x5facec, BBA, BBC},
+        {1, 0x6030ae, BBA, BBC},
+        {1, 0x64a772, BBA, BBC},
+        {1, 0x687dbe, BBA, BBC},
+        {1, 0x68c5dd, BBA, BGC},
+        {1, 0x692064, BBA, BBC},
+        {1, 0x6949da, BBA, BBC},
+        {1, 0x6db110, BBA, BBC},
+        {1, 0x6eab78, BBA, BBC},
+        {1, 0x6fc13d, BGA, BBC},
+        {1, 0x7463b6, BBA, BBC},
+        {1, 0x749cec, BBA, BBC},
+        {1, 0x756547, BBA, BBC},
+        {1, 0x77819e, BBA, BBC},
+        {1, 0x785e0b, BBA, BBC},
+        {1, 0x7b3caa, BBA, BBC},
+        {1, 0x7cccbb, BBA, BBC},
+        {1, 0x7e7e17, BBA, BBC},
+        {1, 0x7fc0f5, BBA, BBC},
+        {1, 0x806ee5, BBA, emptyC}
+        
+/* first cvetan list         
+        {0, 0x5d31bc, emptyA, emptyC},
+        {0, 0x5e4dcc, BBA, BBC},
+        {0, 0x6063a8, BBA, BBC},
+        {0, 0x613d53, BBA, BBC},
+        {0, 0x655069, BBA, BBC},
+        {0, 0x65e1cf, BBA, BBC},
+        {0, 0x66cea0, BBA, BBC},
+        {0, 0x672add, BBA, BBC},
+        {0, 0x68e567, BBA, BBC},
+        {0, 0x697b0f, emptyA, emptyC},
+        {0, 0x6a686d, BGA, BBC},
+        {0, 0x6c4c2f, BBA, BBC},
+        {0, 0x6ca84d, BBA, BBC},
+        {0, 0x6ee60b, BBA, BBC},
+        {0, 0x6fa64f, BBA, BBC},
+        {0, 0x71cc8d, BBA, BBC},
+        {0, 0x74a07d, BBA, BBC},
+        {0, 0x77761b, BGA, BBC},
+        {0, 0x783454, BBA, BBC},
+        {0, 0x7d2414, BBA, BBC},
+        {0, 0x7f443f, BBA, BBC},
+        {0, 0x815daa, BBA, BBC},
+        {0, 0x8367dd, BBA, BBC},
+        {0, 0x838852, BBA, BBC},
+        {0, 0x845fb3, BBA, BBC},
+        {0, 0x84c722, emptyA, emptyC},
+        {0, 0x86256e, BBA, BBC},
+        {0, 0x864339, BBA, BBC},
+        {0, 0x869be0, BGA, BBC},
+        {0, 0x895222, BBA, BBC},
+        {0, 0x8c1a56, emptyA, emptyC},
+        {0, 0x8cb1da, BBA, BBC},
+        {0, 0x8e954e, BBA, BGC},
+        {0, 0x8fe645, BBA, BBC},
+        {0, 0x91bafc, BBA, BBC},
+        {0, 0x93ae80, BBA, BBC},
+        {0, 0x94f793, BBA, BBC},
+        {0, 0x94fbfb, BBA, BBC},
+        {0, 0x954c20, emptyA, emptyC},
+        {0, 0x965e0f, BBA, BBC},
+        {0, 0x96a30e, BBA, BBC},
+        {0, 0x972f1d, BBA, BBC},
+        {0, 0x98fd10, BBA, BBC},
+        {0, 0x9a0472, BBA, BBC},
+        {0, 0x9c4894, BBA, BBC},
+        {0, 0x9e6dc8, emptyA, emptyC},
+        {0, 0x9f5e8b, BBA, BBC},
+        {0, 0xa035bb, BBA, BGC},
+        {0, 0xa53f7c, BBA, BBC},
+        {0, 0xa56537, BBA, BBC},
+        {0, 0xa60957, BBA, BBC},
+        {0, 0xa689db, BBA, BBC},
+        {0, 0xa6d494, BBA, BBC},
+        {0, 0xa6d935, BBA, BBC},
+        {0, 0xa8671a, BBA, BBC},
+        {0, 0xaa7956, BBA, BBC},
+        {0, 0xaee392, BBA, BBC},
+        {0, 0xb1d576, BBA, BBC},
+        {0, 0xb235c3, BBA, BGC},
+        {0, 0xb24b2d, BBA, BBC},
+        {0, 0xb2f999, emptyA, emptyC},
+        {0, 0xb5acac, BBA, BBC},
+        {0, 0xb60ef4, BBA, BBC},
+        {0, 0xb7f38a, BBA, BBC},
+        {0, 0xb87d2b, BBA, BBC},
+        {0, 0xb8d564, BGA, BBC},
+        {0, 0xb9722e, BBA, BBC},
+        {0, 0xb98a5b, BBA, BBC},
+        {0, 0xb99f55, BBA, BBC},
+        {0, 0xbda770, BBA, BBC},
+        {0, 0xbe8f99, BBA, BBC},
+        {0, 0xc226a0, BBA, BBC},
+        {0, 0xc2b248, BBA, BBC},
+        {0, 0xc56f42, emptyA, emptyC},
+        {0, 0xc6ec01, emptyA, emptyC},
+        {0, 0xc768f2, BBA, BBC},
+        {0, 0xc7f149, BBA, BBC},
+        {0, 0xc94a96, BBA, BBC},
+        {0, 0xcbf834, BBA, BBC},
+        {0, 0xce4b94, BBA, BBC},
+        {0, 0xcf1b7b, BBA, BBC},
+        {0, 0xcf7257, BBA, BBC},
+        {0, 0xcffe10, BBA, BBC},
+        {0, 0xd471f3, BBA, BBC},
+        {0, 0xd5b0c6, BBA, BGC},
+        {0, 0xd5c7e7, BBA, BBC},
+        {0, 0xd8b421, emptyA, emptyC},
+        {0, 0xd978ed, BBA, BBC},
+        {0, 0xdbee52, BBA, emptyC},
+        {0, 0xdc0425, BBA, BBC},
+        {0, 0xdcc9e1, BBA, BBC},
+        {0, 0xddb0e3, BBA, BBC},
+        {0, 0xddd1a7, BGA, BBC},
+        {0, 0xdfd2c6, BBA, BBC},
+        {0, 0xe1db66, BBA, BBC},
+        {0, 0xe27106, BBA, BBC},
+        {0, 0xe69c79, BBA, BBC},
+        {0, 0xe71d7b, BBA, BBC},
+        {0, 0xe80a68, BBA, BBC},
+        {0, 0xea06fc, BBA, BBC},
+        {0, 0xf01c8e, BBA, BBC},
+        {0, 0xf08660, BBA, BBC},
+        {0, 0xf1a165, BBA, BBC},
+        {0, 0xf30af3, BBA, BBC},
+        {0, 0xf7635b, BGA, BBC},
+        {0, 0xf7a36c, emptyA, emptyC},
+        {0, 0xf9b31c, BBA, BBC},
+        {0, 0xfb35f9, emptyA, emptyC},
+        {0, 0xfc22dd, BBA, BBC},
+        {0, 0xfe58ba, BBA, BBC},
+        {0, 0xff5c1f, BBA, BBC},
+        {0, 0xff93b5, emptyA, emptyC},
+        {1, 0x3513, BBA, BBC},
+        {1, 0x20656, BBA, BBC},
+        {1, 0x4345d, BBA, BBC},
+        {1, 0x5ec2f, BBA, BBC},
+        {1, 0x8140f, BBA, BBC},
+        {1, 0x93898, BBA, BBC},
+        {1, 0xef46f, BBA, BBC},
+        {1, 0xfff01, BGA, BBC},
+        {1, 0x10ce3e, BBA, BBC},
+        {1, 0x117f6a, BBA, BBC},
+        {1, 0x12cdd1, BBA, emptyC},
+        {1, 0x14b973, BBA, BGC},
+        {1, 0x155e84, BBA, BBC},
+        {1, 0x181dda, BBA, BBC},
+        {1, 0x1bd5b5, BBA, BBC},
+        {1, 0x1ca304, BBA, BBC},
+        {1, 0x1d095a, emptyA, emptyC},
+        {1, 0x1e0125, BBA, BBC},
+        {1, 0x24a1c5, BBA, BBC},
+        {1, 0x24c960, BBA, BBC},
+        {1, 0x2638f4, BBA, BBC},
+        {1, 0x27cdee, BBA, BBC},
+        {1, 0x283e0d, BBA, BBC},
+        {1, 0x29b1f3, BBA, BBC},
+        {1, 0x2b43d4, BBA, BBC},
+        {1, 0x2bb918, BBA, BBC},
+        {1, 0x2d7591, BBA, BBC},
+        {1, 0x2da5ac, BGA, BBC},
+        {1, 0x2e2d65, BBA, BBC},
+        {1, 0x33bef9, BBA, BBC},
+        {1, 0x35505d, BBA, BBC},
+        {1, 0x36084d, BBA, BBC},
+        {1, 0x380b1f, emptyA, emptyC},
+        {1, 0x38d478, BBA, BBC},
+        {1, 0x3a0622, BBA, BBC},
+        {1, 0x3a194e, emptyA, emptyC},
+        {1, 0x3b5972, emptyA, emptyC},
+        {1, 0x3ed6f5, BBA, BBC},
+        {1, 0x3ef093, BBA, BBC},
+        {1, 0x422847, BBA, BBC},
+        {1, 0x426bbb, BBA, BBC},
+        {1, 0x4b2f9b, BBA, BBC},
+        {1, 0x4c5781, emptyA, emptyC},
+        {1, 0x4f1137, BBA, BBC},
+        {1, 0x4fe5ae, BBA, BBC},
+        {1, 0x500dbc, BBA, BBC},
+        {1, 0x502a5e, BGA, BBC},
+        {1, 0x505769, BBA, BBC},
+        {1, 0x507bd3, BBA, BBC},
+        {1, 0x55b3ef, BBA, BBC},
+        {1, 0x56333f, BBA, BBC},
+        {1, 0x587134, BBA, BBC},
+        {1, 0x5b4847, BBA, BGC},
+        {1, 0x5b777a, BBA, BBC},
+        {1, 0x5b7dde, BBA, BBC},
+        {1, 0x5b7e14, BBA, BBC},
+        {1, 0x5cd9ca, BBA, BBC},
+        {1, 0x5e7c42, BBA, BBC},
+        {1, 0x5facec, BBA, BBC},
+        {1, 0x6030ae, BBA, BBC},
+        {1, 0x64a772, BBA, BBC},
+        {1, 0x687dbe, BBA, BBC},
+        {1, 0x68c5dd, BBA, BGC},
+        {1, 0x692064, BBA, BBC},
+        {1, 0x6949da, BBA, BBC},
+        {1, 0x6db110, BBA, BBC},
+        {1, 0x6eab78, BBA, BBC},
+        {1, 0x6fc13d, BGA, BBC},
+        {1, 0x7463b6, BBA, BBC},
+        {1, 0x749cec, BBA, BBC},
+        {1, 0x756547, BBA, BBC},
+        {1, 0x77819e, BBA, BBC},
+        {1, 0x785e0b, BBA, BBC},
+        {1, 0x7b3caa, BBA, BBC},
+        {1, 0x7cccbb, BBA, BBC},
+        {1, 0x7e7e17, BBA, BBC},
+        {1, 0x7fc0f5, BBA, BBC},
+        {1, 0x806ee5, BBA, emptyC} */
+        };
+      
+      Bool_t found = kFALSE;
+      
+      for (Int_t i=1; i<kMaxVZero; i++)
+      {
+        if (fESD->GetPeriodNumber() == vzeroAnalysis[i-1][0] && fESD->GetOrbitNumber() == vzeroAnalysis[i-1][1])
+        {
+          found = kTRUE;
+          Int_t vZero = -1;
+          if (vzeroAnalysis[i][2] == emptyA && vzeroAnalysis[i][3] == BBC)
+            vZero = 1;
+          if (vzeroAnalysis[i][2] == BBA && vzeroAnalysis[i][3] == emptyC)
+            vZero = 2;
+          if (vzeroAnalysis[i][2] == emptyA && vzeroAnalysis[i][3] == emptyC)
+            vZero = 3;
+          if (vzeroAnalysis[i][2] == BBA && vzeroAnalysis[i][3] == BBC)
+            vZero = 4;
+          if (vzeroAnalysis[i][2] == BGA && vzeroAnalysis[i][3] == BBC)
+            vZero = 5;
+          if (vzeroAnalysis[i][2] == BBA && vzeroAnalysis[i][3] == BGC)
+            vZero = 6;
+            
+          fStats2->Fill(decision, vZero);
+          break;
+        }
+      }
+      
+      if (!found)
+        fStats2->Fill(decision, 0);
+      
+      if (decision == 3 || decision == 4)
+      {
+        Printf("Skipping event %d: Period number: %d Orbit number: %x", decision, fESD->GetPeriodNumber(), fESD->GetOrbitNumber());
+        return;
+      }
+    }
+      
+    fStats->Fill(5);
+    
     // trigger definition
     static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;
     eventTriggered = triggerAnalysis->IsTriggerFired(fESD, fTrigger);
@@ -307,8 +903,11 @@ void AlidNdEtaTask::Exec(Option_t*)
     if (vtxESD)
     {
       fVertexResolution->Fill(vtxESD->GetZRes());
-      fVertex->Fill(vtxESD->GetXv(), vtxESD->GetYv(), vtxESD->GetZv());
-
+      //if (strcmp(vtxESD->GetTitle(), "vertexer: 3D") == 0)
+      {
+        fVertex->Fill(vtxESD->GetXv(), vtxESD->GetYv(), vtxESD->GetZv());
+      }
+      
       if (AliPWG0Helper::TestVertex(vtxESD, fAnalysisMode))
       {
           vtxESD->GetXYZ(vtx);
@@ -317,9 +916,19 @@ void AlidNdEtaTask::Exec(Option_t*)
           if (strcmp(vtxESD->GetTitle(), "vertexer: 3D") == 0)
           {
             fStats->Fill(1);
+            if (fCheckEventType && TMath::Abs(vtx[0] > 0.3))
+            {
+              Printf("Suspicious x-vertex x=%f y=%f z=%f (period: %d orbit %x)", vtx[0], vtx[1], vtx[2], fESD->GetPeriodNumber(), fESD->GetOrbitNumber());
+            }
+            if (fCheckEventType && vtx[1] < 0.05 || vtx[1] > 0.5)
+            {
+              Printf("Suspicious y-vertex x=%f y=%f z=%f (period: %d orbit %x)", vtx[0], vtx[1], vtx[2], fESD->GetPeriodNumber(), fESD->GetOrbitNumber());
+            }
           }
           else if (strcmp(vtxESD->GetTitle(), "vertexer: Z") == 0)
+          {
             fStats->Fill(2);
+          }
       }
       else
         vtxESD = 0;
@@ -414,7 +1023,7 @@ void AlidNdEtaTask::Exec(Option_t*)
 
         Int_t label = mult->GetLabel(i, 0);
         Float_t eta = mult->GetEta(i);
-
+        
         // control histograms
         Float_t phi = mult->GetPhi(i);
         if (phi < 0)
@@ -432,9 +1041,12 @@ void AlidNdEtaTask::Exec(Option_t*)
           fZPhi[1]->Fill(z, phi);
         }
 
-        fDeltaPhi->Fill(deltaPhi);
-        fDeltaTheta->Fill(mult->GetDeltaTheta(i));
-
+        if (vtxESD && TMath::Abs(vtx[2]) < 10)
+        {
+          fDeltaPhi->Fill(deltaPhi);
+          fDeltaTheta->Fill(mult->GetDeltaTheta(i));
+        }
+        
         if (fDeltaPhiCut > 0 && TMath::Abs(deltaPhi) > fDeltaPhiCut)
           continue;
 
@@ -450,6 +1062,9 @@ void AlidNdEtaTask::Exec(Option_t*)
             Printf("WARNING: fUseMCKine set without fOnlyPrimaries and no label found");
         }
         
+        if (fSymmetrize)
+          eta = TMath::Abs(eta);
+
         etaArr[inputCount] = eta;
         labelArr[inputCount] = label;
         thirdDimArr[inputCount] = phi;
@@ -466,6 +1081,8 @@ void AlidNdEtaTask::Exec(Option_t*)
       Int_t firedChips = mult->GetNumberOfFiredChips(0) + mult->GetNumberOfFiredChips(1);
       fFiredChips->Fill(firedChips, inputCount);
       Printf("Accepted %d tracklets (%d fired chips)", inputCount, firedChips);
+      
+      fTrackletsVsUnassigned->Fill(inputCount, mult->GetNumberOfSingleClusters());
     }
     else if (fAnalysisMode & AliPWG0Helper::kTPC || fAnalysisMode & AliPWG0Helper::kTPCITS)
     {
@@ -534,6 +1151,8 @@ void AlidNdEtaTask::Exec(Option_t*)
               Printf("WARNING: fUseMCKine set without fOnlyPrimaries and no label found");
           }
   
+          if (fSymmetrize)
+            eta = TMath::Abs(eta);
           etaArr[inputCount] = eta;
           labelArr[inputCount] = TMath::Abs(esdTrack->GetLabel());
           thirdDimArr[inputCount] = pT;
@@ -560,6 +1179,10 @@ void AlidNdEtaTask::Exec(Option_t*)
       if (vtxESD)
       {
         // control hist
+        
+        if (strcmp(vtxESD->GetTitle(), "vertexer: 3D") == 0)
+          fVertexVsMult->Fill(vtxESD->GetXv(), vtxESD->GetYv(), inputCount);
+      
         fMultVtx->Fill(inputCount);
 
         for (Int_t i=0; i<inputCount; ++i)
@@ -584,7 +1207,8 @@ void AlidNdEtaTask::Exec(Option_t*)
         fdNdEtaAnalysisESD->FillEvent(vtx[2], inputCount);
 
         // control hist
-        fEvents->Fill(vtx[2]);
+       if (inputCount > 0)
+               fEvents->Fill(vtx[2]);
 
         if (fReadMC)
         {
@@ -618,7 +1242,10 @@ void AlidNdEtaTask::Exec(Option_t*)
             else
               thirdDim = particle->Pt();
 
-            fdNdEtaAnalysisTracks->FillTrack(vtxMC[2], particle->Eta(), thirdDim);
+            Float_t eta = particle->Eta();
+            if (fSymmetrize)
+              eta = TMath::Abs(eta);
+            fdNdEtaAnalysisTracks->FillTrack(vtxMC[2], eta, thirdDim);
           } // end of track loop
 
           // for event count per vertex
@@ -724,6 +1351,9 @@ void AlidNdEtaTask::Exec(Option_t*)
         continue;
 
       Float_t eta = particle->Eta();
+      if (fSymmetrize)
+        eta = TMath::Abs(eta);
+
       Float_t thirdDim = -1;
 
       if (fAnalysisMode & AliPWG0Helper::kSPD)
@@ -755,7 +1385,8 @@ void AlidNdEtaTask::Exec(Option_t*)
 
       if (TMath::Abs(eta) < 1.0 && particle->Pt() > 0 && particle->P() > 0)
       {
-        Float_t value = 1. / TMath::TwoPi() / particle->Pt() * particle->Energy() / particle->P();
+        //Float_t value = 1. / TMath::TwoPi() / particle->Pt() * particle->Energy() / particle->P();
+        Float_t value = 1;
         fPartPt->Fill(particle->Pt(), value);
       }
     }
@@ -795,6 +1426,8 @@ void AlidNdEtaTask::Terminate(Option_t *)
     fEvents = dynamic_cast<TH1F*> (fOutput->FindObject("dndeta_check_vertex"));
     fVertexResolution = dynamic_cast<TH1F*> (fOutput->FindObject("dndeta_vertex_resolution_z"));
 
+    fVertex = dynamic_cast<TH3F*> (fOutput->FindObject("vertex_check"));
+    fVertexVsMult = dynamic_cast<TH3F*> (fOutput->FindObject("fVertexVsMult"));
     fPhi = dynamic_cast<TH1F*> (fOutput->FindObject("fPhi"));
     fRawPt = dynamic_cast<TH1F*> (fOutput->FindObject("fRawPt"));
     fEtaPhi = dynamic_cast<TH2F*> (fOutput->FindObject("fEtaPhi"));
@@ -803,8 +1436,11 @@ void AlidNdEtaTask::Terminate(Option_t *)
     fDeltaPhi = dynamic_cast<TH1F*> (fOutput->FindObject("fDeltaPhi"));
     fDeltaTheta = dynamic_cast<TH1F*> (fOutput->FindObject("fDeltaTheta"));
     fFiredChips = dynamic_cast<TH2F*> (fOutput->FindObject("fFiredChips"));
+    fTrackletsVsClusters = dynamic_cast<TH2F*> (fOutput->FindObject("fTrackletsVsClusters"));
+    fTrackletsVsUnassigned = dynamic_cast<TH2F*> (fOutput->FindObject("fTrackletsVsUnassigned"));
     fTriggerVsTime = dynamic_cast<TGraph*> (fOutput->FindObject("fTriggerVsTime"));
     fStats = dynamic_cast<TH1F*> (fOutput->FindObject("fStats"));
+    fStats2 = dynamic_cast<TH2F*> (fOutput->FindObject("fStats2"));
 
     fEsdTrackCuts = dynamic_cast<AliESDtrackCuts*> (fOutput->FindObject("fEsdTrackCuts"));
   }
@@ -906,16 +1542,27 @@ void AlidNdEtaTask::Terminate(Option_t *)
     if (fFiredChips)
       fFiredChips->Write();
 
+    if (fTrackletsVsClusters)
+      fTrackletsVsClusters->Write();
+    
+    if (fTrackletsVsUnassigned)
+      fTrackletsVsUnassigned->Write();
+    
     if (fTriggerVsTime)
       fTriggerVsTime->Write();
 
     if (fStats)
       fStats->Write();
 
-    fVertex = dynamic_cast<TH3F*> (fOutput->FindObject("vertex_check"));
+    if (fStats2)
+      fStats2->Write();
+    
     if (fVertex)
       fVertex->Write();
 
+    if (fVertexVsMult)
+      fVertexVsMult->Write();
+    
     fout->Write();
     fout->Close();
 
index 3ccaa4f..9c634e3 100644 (file)
@@ -36,6 +36,8 @@ class AlidNdEtaTask : public AliAnalysisTask {
     void SetTrigger(AliTriggerAnalysis::Trigger trigger) { fTrigger = trigger; }
     void SetFillPhi(Bool_t flag = kTRUE) { fFillPhi = flag; }
     void SetDeltaPhiCut(Float_t cut) { fDeltaPhiCut = cut; }
+    void SetCheckEventType(Bool_t flag = kTRUE) { fCheckEventType = flag; }
+    void SetSymmetrize(Bool_t flag = kTRUE) { fSymmetrize = flag; }
     
     void SetOption(const char* opt) { fOption = opt; }
 
@@ -53,6 +55,8 @@ class AlidNdEtaTask : public AliAnalysisTask {
     Bool_t  fUseMCVertex;  // the MC vtx is used instead of the ESD vertex (for syst. check)
     Bool_t  fOnlyPrimaries;// Process only primaries by using the MC information (for syst. check)
     Bool_t  fUseMCKine;    // use the MC values for each found track/tracklet (for syst. check)
+    Bool_t  fCheckEventType;  // check if event type is physics (for real data)
+    Bool_t  fSymmetrize;     // move all negative to positive eta
 
     AliESDtrackCuts* fEsdTrackCuts;         // Object containing the parameters of the esd track cuts
 
@@ -78,6 +82,7 @@ class AlidNdEtaTask : public AliAnalysisTask {
 
     // control histograms (ESD)
     TH3F* fVertex;                //! 3d vertex distribution
+    TH3F* fVertexVsMult;          //! x-vtx vs y-vtx vs multiplicity
     TH1F* fPhi;                   //! raw phi distribution
     TH1F* fRawPt;                 //! raw pt distribution
     TH2F* fEtaPhi;                //! raw eta - phi distribution
@@ -85,8 +90,11 @@ class AlidNdEtaTask : public AliAnalysisTask {
     TH1F* fDeltaPhi;              //! histogram of delta_phi values for tracklets (only for SPD analysis)
     TH1F* fDeltaTheta;            //! histogram of delta_theta values for tracklets (only for SPD analysis)
     TH2F* fFiredChips;            //! fired chips l1+l2 vs. number of tracklets (only for SPD analysis)
+    TH2F* fTrackletsVsClusters;   //! number of tracklets vs. clusters in all ITS detectors (only for SPD analysis)
+    TH2F* fTrackletsVsUnassigned; //! number of tracklets vs. number of unassigned clusters in L1 (only for SPD analysis)
     TGraph* fTriggerVsTime;       //! trigger as function of event time
-    TH1F* fStats;                 //! further statistics : bin 1 = vertexer 3d, bin 2 = vertexer z
+    TH1F* fStats;                 //! further statistics : bin 1 = vertexer 3d, bin 2 = vertexer z, etc (see CreateOutputObjects)
+    TH2F* fStats2;                //! V0 vs SPD statistics
 
  private:
     AlidNdEtaTask(const AlidNdEtaTask&);
index d484ace..6264bb5 100644 (file)
@@ -8,12 +8,13 @@ void loadlibs()
   gSystem->Load("libPWG0base");
 }
 
-void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const char* dataOutput = "analysis_esd.root", const char* correctionMapFile = "correction_map.root", const char* correctionMapFolder = "dndeta_correction")
+void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const char* dataOutput = "analysis_esd.root", const char* correctionMapFile = "correction_map2.root", const char* correctionMapFolder = "dndeta_correction_ua5")
 {
   loadlibs();
 
   AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection(correctionMapFolder, correctionMapFolder);
-  TFile::Open(correctionMapFile);
+  if (!TFile::Open(correctionMapFile))
+    return;
   dNdEtaCorrection->LoadHistograms();
 
   TFile* file = TFile::Open(dataInput);
index 957f1f2..ae044f0 100644 (file)
@@ -15,6 +15,7 @@
 #include <TLine.h>
 #include <TParameter.h>
 
+#include <AliLog.h>
 #include "AlidNdEtaCorrection.h"
 #include <AliCorrection.h>
 #include <AliPWG0Helper.h>
@@ -308,6 +309,8 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
       Double_t mcEvents = vertexDist->GetBinContent(i) * eTrig->GetBinContent(i, 1) / eTrigVtx_projx->GetBinContent(i) * fData->GetEventCorrection()->GetCorrectionHistogram()->GetBinContent(i, 1);
 
       Printf("Bin %d, alpha is %.2f, fZ is %.3f, number of events with 0 mult.: %.2f (MC comparison: %.2f)", i, alpha * 100., fZ, events, mcEvents);
+      Printf("Using MC value for 0-bin correction!");
+      events = mcEvents;
 
       correctedEvents->SetBinContent(i, 1, events);
     }
@@ -412,28 +415,25 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
       Int_t vertexBinEnd   = vertexHist->GetXaxis()->FindBin(vertexRangeEnd[vertexPos]);
 
       const Int_t *binBegin = 0;
-      const Int_t maxBins = 60;
+      const Int_t maxBins = 14;
+      
+      if (dataHist->GetNbinsY() != maxBins)
+        AliFatal(Form("Binning of acceptance is different from data histogram: data=%d, acceptance=%d", dataHist->GetNbinsY(), maxBins));
 
       // adjust acceptance range
       // produce with drawPlots.C: DetermineAcceptance(...)
       if (fAnalysisMode & AliPWG0Helper::kSPD)
       {
-        //const Int_t binBeginSPD[30] = { 18, 16, 15, 14, 13, 13, 12, 11, 9, 7, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1 }; // by eye
-        //const Int_t binBeginSPD[30] = { -1, -1, -1, -1, 16, 14, 12, 10, 9, 7, 6, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, -1, -1, -1, -1}; // limit in correction map is 5
-
-        //const Int_t binBegin[30] = { -1, -1, -1, 17, 15, 14, 12, 10, 8, 7, 6, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, -1, -1, -1};  // limit in correction map is 10
-
-        //const Int_t binBeginSPD[30] = { -1, -1, -1, -1, 16, 15, 13, 11, 9, 8, 7, 6, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, -1, -1, -1, -1}; // limit 2
-        const Int_t binBeginSPD[maxBins] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 15, 14, 13, 12, 11, 10, 9, 9, 8, 7, 7, 6, 6, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; //limit 5
+        const Int_t binBeginSPD[maxBins] = {-1, 16, 13, 9, 7, 5, 4, 4, 3, 3, 2, 2, 2, -1};
 
         binBegin = binBeginSPD;
       }
       else if (fAnalysisMode & AliPWG0Helper::kTPC)
       {
         //const Int_t binBeginTPC[30] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // limit 5, pt cut off 0.2 mev/c
-        const Int_t binBeginTPC[maxBins] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 9, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // limit 5
+        //const Int_t binBeginTPC[maxBins] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 9, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; // limit 5
 
-        binBegin = binBeginTPC;
+        //binBegin = binBeginTPC;
       }
       else if (fAnalysisMode & AliPWG0Helper::kTPCITS)
       {
index 3bf3d5b..a09ce00 100644 (file)
@@ -146,7 +146,6 @@ void PrintInfo(const char* fileName = "correction_map.root", const char* dirName
   {
     Printf("Correction %d", i);
     dNdEtaCorrection->GetCorrection(i)->PrintInfo(0.2);
-    return;
   }
 }
 
@@ -519,7 +518,8 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   legend->SetFillColor(0);
   legend->AddEntry(histESDMBVtx, "Triggered, vertex");
   legend->AddEntry(histESDMB, "Triggered");
-  legend->AddEntry(histESD, "All events");
+  legend->AddEntry(histESD, "All INEL events");
+  legend->AddEntry(histESDnsd, "All NSD events");
 
   TH2F* dummy = new TH2F("dummy", "", 100, -etaPlotLimit, etaPlotLimit, 1000, 0, max * 1.1);
   dummy->GetYaxis()->SetRangeUser(2.1, max * 1.1);
@@ -535,6 +535,7 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   histESDMBVtx->Draw("SAME");
   histESDMB->Draw("SAME");
   histESD->Draw("SAME");
+  histESDnsd->Draw("SAME");
   legend->Draw();
 
   if (save)
@@ -542,6 +543,9 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
     canvas->SaveAs("dNdEta1.gif");
     canvas->SaveAs("dNdEta1.eps");
   }
+  
+  histESD->Fit("pol0", "0", "", -0.45, 0.45);
+  histESDnsd->Fit("pol0", "0", "", -0.45, 0.45);
 
   if (onlyESD)
     return;
@@ -2740,7 +2744,7 @@ void ZeroOutsideAcceptance(TH2* acc, TH3* hist)
   for (Int_t x=0; x<=acc->GetNbinsX()+1; ++x)
     for (Int_t y=0; y<=acc->GetNbinsY()+1; ++y)
     {
-      if (acc->GetBinContent(x, y) > 1.5 || acc->GetBinContent(x, y) == 0)
+      if (acc->GetBinContent(x, y) > 2 || acc->GetBinContent(x, y) == 0)
       {
         for (Int_t z=0; z<=hist->GetNbinsZ()+1; ++z)
         {
@@ -2794,20 +2798,20 @@ void DrawPhi()
   c = new TCanvas;
 
   histG->GetXaxis()->SetRangeUser(-9.9, 9.9);
-  histG->Project3D("z")->Draw();
+  histG->Project3D("z")->DrawCopy();
 
   histM->GetXaxis()->SetRangeUser(-9.9, 9.9);
   proj = histM->Project3D("z2");
   proj->SetLineColor(2);
-  proj->Draw("SAME");
+  proj->DrawCopy("SAME");
 
   histMC->GetXaxis()->SetRangeUser(-9.9, 9.9);
   projMC = histMC->Project3D("z3");
-  projMC->SetLineColor(3);
-  projMC->Draw("SAME");
+  projMC->SetLineColor(4);
+  projMC->DrawCopy("SAME");
 }
 
-void PrintEventStats(Int_t corrID = 3)
+void PrintEventStats(Int_t corrID = 3, const char* fileName = "correction_map.root", const char* dir = "dndeta_correction")
 {
   loadlibs();
 
@@ -2819,8 +2823,8 @@ void PrintEventStats(Int_t corrID = 3)
   eventHist = fdNdEtaAnalysis->GetData()->GetEventCorrection()->GetGeneratedHistogram();
   */
 
-  TFile::Open("correction_map.root");
-  AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection("dndeta_correction", "dndeta_correction");
+  TFile::Open(fileName);
+  AlidNdEtaCorrection* dNdEtaCorrection = new AlidNdEtaCorrection(dir, dir);
   if (!dNdEtaCorrection->LoadHistograms())
     return;
   trackHist = dNdEtaCorrection->GetCorrection(corrID)->GetTrackCorrection()->GetGeneratedHistogram();
@@ -2858,6 +2862,27 @@ void PrintEventStats(Int_t corrID = 3)
   Printf("SD  = %.1f",  100. * (proj->GetBinContent(4) - stats->GetBinContent(4, 1) - stats->GetBinContent(4, 3)) / proj->GetBinContent(4));
   Printf("DD  = %.1f",  100. * (proj->GetBinContent(5) - stats->GetBinContent(5, 1) - stats->GetBinContent(5, 3)) / proj->GetBinContent(5));
   
+  Printf("+++ VERTEX EFFICIENCIES +++");
+  
+  Printf("INEL = %.1f", 100. * (stats->GetBinContent(1, 3) + stats->GetBinContent(1, 4)) / proj->GetBinContent(1));
+  Printf("NSD  = %.1f", 100. * (stats->GetBinContent(2, 3) + stats->GetBinContent(2, 4)) / proj->GetBinContent(2));
+  
+  Float_t vtxND = 100. * (stats->GetBinContent(3, 3) + stats->GetBinContent(3, 4)) / proj->GetBinContent(3);
+  Float_t vtxSD = 100. * (stats->GetBinContent(4, 3) + stats->GetBinContent(4, 4)) / proj->GetBinContent(4);
+  Float_t vtxDD = 100. * (stats->GetBinContent(5, 3) + stats->GetBinContent(5, 4)) / proj->GetBinContent(5);
+  Printf("ND  = %.1f", vtxND);
+  Printf("SD  = %.1f", vtxSD);
+  Printf("DD  = %.1f", vtxDD);
+  
+  Float_t ua5_SD = 0.153;
+  Float_t ua5_DD = 0.080;
+  Float_t ua5_ND = 0.767;
+  
+  Float_t vtxINELUA5 = ua5_SD * vtxSD + ua5_DD * vtxDD + ua5_ND * vtxND;
+  Float_t vtxNSDUA5  = (ua5_DD * vtxDD + ua5_ND * vtxND) / (ua5_DD + ua5_ND);
+  Printf("INEL (UA5)  = %.1f", vtxINELUA5);
+  Printf("NSD (UA5)  = %.1f", vtxNSDUA5);
+  
   Printf("+++ TRIGGER + VERTEX EFFICIENCIES +++");
   
   Printf("INEL = %.1f", 100. * stats->GetBinContent(1, 4) / proj->GetBinContent(1));
@@ -2866,6 +2891,8 @@ void PrintEventStats(Int_t corrID = 3)
   Printf("SD  = %.1f",  100. * stats->GetBinContent(4, 4) / proj->GetBinContent(4));
   Printf("DD  = %.1f",  100. * stats->GetBinContent(5, 4) / proj->GetBinContent(5));
   
+  
+  
   for (Int_t i=7; i<=proj->GetNbinsX(); i++)
     if (proj->GetBinContent(i) > 0)
       Printf("bin %d (process type %d) = %.2f", i, (Int_t) proj->GetXaxis()->GetBinCenter(i), 100.0 * (proj->GetBinContent(i) - stats->GetBinContent(i, 1)) / proj->GetBinContent(i));
@@ -3099,3 +3126,143 @@ void PlotPt1DCorrection()
   
   legend->Draw();
 }
+
+void FitDiamond()
+{
+  TFile::Open("analysis_esd_raw.root");
+  
+  hist = (TH3*) gFile->Get("vertex_check");
+  
+  gStyle->SetOptFit(1);
+  
+  TH1* proj[3];
+  proj[0] = hist->ProjectionX();
+  proj[1] = hist->ProjectionY();
+  proj[2] = hist->ProjectionZ();
+  
+  for (Int_t i=0; i<3; i++)
+  {
+    c = new TCanvas;
+    proj[i]->Draw();
+    proj[i]->Fit("gaus");
+    
+    c->SaveAs(Form("FitDiamond_%d.png", i));
+  }
+}
+
+void FitDiamondVsMult()
+{
+  TFile::Open("analysis_esd_raw.root");
+  
+  fVertexVsMult = (TH3*) gFile->Get("fVertexVsMult");
+  fVertexVsMult->GetZaxis()->SetTitle("multiplicity");
+  
+  TH2* proj[2];
+  proj[0] = (TH2*) fVertexVsMult->Project3D("xz");
+  proj[1] = (TH2*) fVertexVsMult->Project3D("yz");
+  
+  gStyle->SetPadGridX(kTRUE);
+  gStyle->SetPadGridY(kTRUE);
+  
+  Int_t max = 25;
+  
+  for (Int_t i=0; i<2; i++)
+  {
+    proj[i]->Rebin2D(4, 1);
+    proj[i]->FitSlicesY();
+    
+    c = new TCanvas(Form("c_%d", i), Form("c_%d", i), 800, 400);
+    c->Divide(2, 1);
+    
+    c->cd(1);
+    hist = (TH1*) gROOT->FindObject(Form("fVertexVsMult_%sz_1", (i == 0) ? "x" : "y"));
+    hist->GetXaxis()->SetRangeUser(0, max);
+    hist->GetYaxis()->SetRangeUser(-0.4, 0.4);
+    hist->Draw();
+    
+    c->cd(2);
+    hist = (TH1*) gROOT->FindObject(Form("fVertexVsMult_%sz_2", (i == 0) ? "x" : "y"));
+    hist->GetXaxis()->SetRangeUser(0, max);
+    hist->GetYaxis()->SetRangeUser(0, 0.2);
+    hist->Draw();
+    
+    c->SaveAs(Form("FitDiamondVsMult_%d.png", i));
+  }
+}
+
+void CompareQualityHists(const char* fileName1, const char* fileName2, const char* plotName, Int_t rebin1 = 1, Int_t rebin2 = 1)
+{
+  file1 = TFile::Open(fileName1);
+  hist1 = (TH1*) file1->Get(plotName);
+  
+  file2 = TFile::Open(fileName2);
+  hist2 = (TH1*) file2->Get(plotName);
+  
+  hist1->SetLineColor(1);
+  hist2->SetLineColor(2);
+  if (rebin1 != 0 && rebin2 != 0)
+  { 
+    hist1->Rebin(TMath::Abs(rebin1));
+    hist2->Rebin(TMath::Abs(rebin2));
+  }
+  
+  if (rebin1 > 0 && rebin2 > 0)
+  {
+    hist1->Scale(hist2->Integral() / hist1->Integral() / rebin1 * rebin2);
+  
+    //hist1->Scale(0.5);
+    //hist2->Scale(0.5);
+  }
+
+  c = new TCanvas;
+  hist1->DrawCopy();
+  hist2->DrawCopy("SAME");
+  
+  c2 = new TCanvas;
+  hist1->Divide(hist2);
+  hist1->DrawCopy();
+}
+
+void DrawClustersVsTracklets()
+{
+  TFile::Open("analysis_esd_raw.root");
+  
+  hist = (TH2*) gFile->Get("fTrackletsVsClusters");
+  
+  c = new TCanvas("c", "c", 600, 600);
+  c->SetRightMargin(0.05);
+  c->SetTopMargin(0.05);
+  
+  hist->SetStats(0);
+  hist->GetYaxis()->SetRangeUser(0, 400);
+  hist->GetYaxis()->SetTitleOffset(1.3);
+  hist->GetXaxis()->SetRangeUser(0, 30);
+  hist->Draw("BOX");
+  
+  func = new TF1("func", "80 + x * 11", 0, 30);
+  func->Draw("SAME");
+  
+  c->SaveAs("clusters_vs_tracklets.eps");
+}
+  
+void VertexPlotBackgroundNote()
+{
+  TFile::Open("all.root");
+  
+  hist = (TH3*) gFile->Get("vertex_check");
+  proj = (TH1*) hist->ProjectionZ()->Clone("all");
+  proj->Rebin(2);
+  
+  proj->Draw();
+  
+  TFile::Open("analysis_esd_raw.root");
+  hist = (TH3*) gFile->Get("vertex_check");
+  proj = (TH1*) hist->ProjectionZ()->Clone("afterbg");
+  proj->Rebin(2);
+  
+  proj->SetLineColor(2);
+  proj->Draw("SAME");
+  
+  
+}
\ No newline at end of file
index 7283618..95af45d 100644 (file)
@@ -794,15 +794,26 @@ void mergeCorrectionsWithDifferentCrosssections(Int_t correctionTarget = 3, Char
 
   const Char_t* typeName[] = { "vertexreco", "trigger", "vtxtrigger" };
 
+  //Karel:
+//     fsd = 0.153 +- 0.031 (0.050 to take into account SD definition) --> change
+//     fdd = 0.080 +- 0.050 --> change 
+//     fnd = 0.767 +- 0.059 --> keep (error small)
 
-
-  const Char_t* changes[]  = { "pythia","ddmore","ddless","sdmore","sdless", "dmore", "dless", "sdlessddmore", "sdmoreddless", "ddmore25","ddless25","sdmore25","sdless25", "dmore25", "dless25", "sdlessddmore25", "sdmoreddless25"};
-  Float_t scalesND[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,  1.0,  1.0,  1.0,  1.0,  1.0,  1.0,  1.0 };
+//  const Char_t* changes[]  = { "pythia","ddmore","ddless","sdmore","sdless", "dmore", "dless", "sdlessddmore", "sdmoreddless", "ddmore25","ddless25","sdmore25","sdless25", "dmore25", "dless25", "sdlessddmore25", "sdmoreddless25"};
+  //Float_t scalesND[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,  1.0,  1.0,  1.0,  1.0,  1.0,  1.0,  1.0 };
   //Float_t scalesDD[] = {1.0, 1.5, 0.5, 1.0, 1.0, 1.5, 0.5, 1.5, 0.5, 1.25, 0.75, 1.0,  1.0,  1.25, 0.75, 1.25, 0.75};
   //Float_t scalesSD[] = {1.0, 1.0, 1.0, 1.5, 0.5, 1.5, 0.5, 0.5, 1.5, 1.0,  1.0,  1.25, 0.75, 1.25, 0.75, 0.75, 1.25};
-  Float_t scalesDD[] = {1.0, 1.4, 0.6, 1.0, 1.0, 1.4, 0.6, 1.4, 0.6, 1.25, 0.75, 1.0,  1.0,  1.25, 0.75, 1.25, 0.75};
-  Float_t scalesSD[] = {1.0, 1.0, 1.0, 1.4, 0.6, 1.4, 0.6, 0.4, 1.6, 1.0,  1.0,  1.25, 0.75, 1.25, 0.75, 0.75, 1.25};
-  Int_t nChanges = 17;
+  //Float_t scalesDD[] = {1.0, 1.4, 0.6, 1.0, 1.0, 1.4, 0.6, 1.4, 0.6, 1.25, 0.75, 1.0,  1.0,  1.25, 0.75, 1.25, 0.75};
+  //Float_t scalesSD[] = {1.0, 1.0, 1.0, 1.4, 0.6, 1.4, 0.6, 0.4, 1.6, 1.0,  1.0,  1.25, 0.75, 1.25, 0.75, 0.75, 1.25};
+  Int_t nChanges = 9;
+
+  const Char_t* changes[]  = { "ua5","ddmore","ddless","sdmore","sdless", "dmore", "dless", "sdlessddmore", "sdmoreddless" };
+  Float_t scalesND[] = {0.767, 0.767, 0.767, 0.767, 0.767, 0.767, 0.767, 0.767, 0.767};
+  Float_t scalesDD[] = {0.080, 0.130, 0.030, 0.080, 0.080, 0.130, 0.030, 0.130, 0.030};
+  Float_t scalesSD[] = {0.153, 0.153, 0.153, 0.203, 0.103, 0.203, 0.103, 0.103, 0.203};
+  
+  for (Int_t i=0; i<9; i++)
+    scalesND[i] = 1.0 - scalesDD[i] - scalesSD[i];
 
   /*
   const Char_t* changes[]  = { "pythia", "qgsm", "phojet"};
@@ -834,7 +845,7 @@ void mergeCorrectionsWithDifferentCrosssections(Int_t correctionTarget = 3, Char
   TH1F* hRatios[100];
 
   Int_t counter = 0;
-  for (Int_t j=0; j<3; j++) { // j = 0 (change vtx), j = 1 (change trg), j = 2 (change both)
+  for (Int_t j=2; j<3; j++) { // j = 0 (change vtx), j = 1 (change trg), j = 2 (change both)
 
     for (Int_t i=0; i<nChanges; i++) {
       TFile::Open(correctionFileName);
@@ -856,34 +867,51 @@ void mergeCorrectionsWithDifferentCrosssections(Int_t correctionTarget = 3, Char
       dNdEtaCorrectionSD->LoadHistograms();
 
       // calculating relative
-      Float_t nd = 100 * sigmaND/(sigmaND + (scalesDD[i]*sigmaDD) + (scalesDD[i]*sigmaSD));
+      Float_t nd = dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral();
+      Float_t dd = dNdEtaCorrectionDD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral();
+      Float_t sd = dNdEtaCorrectionSD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral();
+      Float_t total = nd + dd + sd;
+      
+      nd /= total;
+      sd /= total;
+      dd /= total;
+      
+      Printf("Ratios in the correction map are: ND=%f, DD=%f, SD=%f", nd, dd, sd);
+      
+      Float_t scaleND = scalesND[i] / nd;
+      Float_t scaleDD = scalesDD[i] / dd;
+      Float_t scaleSD = scalesSD[i] / sd;
+      
+      Printf("ND=%.2f, DD=%.2f, SD=%.2f",scaleND, scaleDD, scaleSD);      
+      
+/*      Float_t nd = 100 * sigmaND/(sigmaND + (scalesDD[i]*sigmaDD) + (scalesDD[i]*sigmaSD));
       Float_t dd = 100 * (scalesDD[i]*sigmaDD)/(sigmaND + (scalesDD[i]*sigmaDD) + (scalesDD[i]*sigmaSD));
       Float_t sd = 100 * (scalesSD[i]*sigmaSD)/(sigmaND + (scalesDD[i]*sigmaDD) + (scalesDD[i]*sigmaSD));
 
-      printf(Form("%s : ND=%.2f\%, DD=%.2f\%, SD=%.2f\% \n",changes[i],nd,dd,sd));
-      current->SetTitle(Form("ND=%.2f\%,DD=%.2f\%,SD=%.2f\%",nd,dd,sd));
+      printf(Form("%s : ND=%.2f\%, DD=%.2f\%, SD=%.2f\% \n",changes[i],nd,dd,sd));*/
+      current->SetTitle(Form("ND=%.2f\%,DD=%.2f\%,SD=%.2f\%",scaleND,scaleDD,scaleSD));
       current->SetTitle(name);
 
       // scale
       if (j == 0 || j == 2)
       {
-        dNdEtaCorrectionND->GetVertexRecoCorrection()->Scale(scalesND[i]);
-        dNdEtaCorrectionDD->GetVertexRecoCorrection()->Scale(scalesDD[i]);
-        dNdEtaCorrectionSD->GetVertexRecoCorrection()->Scale(scalesSD[i]);
+        dNdEtaCorrectionND->GetVertexRecoCorrection()->Scale(scaleND);
+        dNdEtaCorrectionDD->GetVertexRecoCorrection()->Scale(scaleDD);
+        dNdEtaCorrectionSD->GetVertexRecoCorrection()->Scale(scaleSD);
       }
       if (j == 1 || j == 2)
       {
-        dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->Scale(scalesND[i]);
+        dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->Scale(scaleND);
         dNdEtaCorrectionDD->GetTriggerBiasCorrectionINEL()->Scale(scalesDD[i]);
         dNdEtaCorrectionSD->GetTriggerBiasCorrectionINEL()->Scale(scalesSD[i]);
 
-        dNdEtaCorrectionND->GetTriggerBiasCorrectionNSD()->Scale(scalesND[i]);
-        dNdEtaCorrectionDD->GetTriggerBiasCorrectionNSD()->Scale(scalesDD[i]);
-        dNdEtaCorrectionSD->GetTriggerBiasCorrectionNSD()->Scale(scalesSD[i]);
+        dNdEtaCorrectionND->GetTriggerBiasCorrectionNSD()->Scale(scaleND);
+        dNdEtaCorrectionDD->GetTriggerBiasCorrectionNSD()->Scale(scaleDD);
+        dNdEtaCorrectionSD->GetTriggerBiasCorrectionNSD()->Scale(scaleSD);
 
-        dNdEtaCorrectionND->GetTriggerBiasCorrectionND()->Scale(scalesND[i]);
-        dNdEtaCorrectionDD->GetTriggerBiasCorrectionND()->Scale(scalesDD[i]);
-        dNdEtaCorrectionSD->GetTriggerBiasCorrectionND()->Scale(scalesSD[i]);
+        dNdEtaCorrectionND->GetTriggerBiasCorrectionND()->Scale(scaleND);
+        dNdEtaCorrectionDD->GetTriggerBiasCorrectionND()->Scale(scaleDD);
+        dNdEtaCorrectionSD->GetTriggerBiasCorrectionND()->Scale(scaleSD);
       }
 
       //clear track in correction
@@ -918,7 +946,7 @@ void mergeCorrectionsWithDifferentCrosssections(Int_t correctionTarget = 3, Char
 
       hRatios[counter] = (TH1F*) fdNdEtaAnalysis->GetdNdEtaHistogram()->Clone(name);
 
-      name.Form("DD #times %0.2f, SD #times %0.2f",scalesDD[i],scalesSD[i]);
+      name.Form("ND #times %0.2f DD #times %0.2f, SD #times %0.2f",scaleND,scaleDD,scaleSD);
       hRatios[counter]->SetTitle(name.Data());
       hRatios[counter]->SetYTitle("dN_{ch}/d#eta ratio #frac{default cross-section}{modified cross-sections}");
 
@@ -936,7 +964,7 @@ void mergeCorrectionsWithDifferentCrosssections(Int_t correctionTarget = 3, Char
   // to make everything consistent
   hRatios[0]->Divide(hRatios[0],hRatios[0],1,1);
 
-  for (Int_t i=0; i<nChanges * 3; i++)
+  for (Int_t i=0; i<counter; i++)
   {
     corrections[i]->SaveHistograms();
     hRatios[i]->Write();
@@ -946,6 +974,128 @@ void mergeCorrectionsWithDifferentCrosssections(Int_t correctionTarget = 3, Char
   fout->Close();
 }
 
+void CreateCorrectionsWithUA5CrossSections(const Char_t* correctionFileName="correction_mapprocess-types.root", const Char_t* outputFileName="correction_map2.root") {
+  //
+  // Function used to merge standard corrections with vertex
+  // reconstruction corrections obtained by a certain mix of ND, DD
+  // and SD events.
+  //
+
+  loadlibs();
+
+  const Char_t* typeName[] = { "vertexreco", "trigger", "vtxtrigger" };
+  
+  Float_t ua5_SD = 0.153;
+  Float_t ua5_DD = 0.080;
+  Float_t ua5_ND = 0.767;
+
+  //Karel:
+//     fsd = 0.153 +- 0.031
+//     fdd = 0.080 +- 0.050
+//     fnd = 0.767 +- 0.059
+
+  // Pythia, as test
+/*  ua5_SD = 0.223788;
+  ua5_DD = 0.123315;
+  ua5_ND = 0.652897; */
+  
+  // standard correction
+  TFile::Open(correctionFileName);
+  AlidNdEtaCorrection* correctionStandard = new AlidNdEtaCorrection("dndeta_correction","dndeta_correction");
+  correctionStandard->LoadHistograms();
+
+  // dont take vertexreco from this one
+  correctionStandard->GetVertexRecoCorrection()->Reset();
+  // dont take triggerbias from this one
+  correctionStandard->GetTriggerBiasCorrectionINEL()->Reset();
+  correctionStandard->GetTriggerBiasCorrectionNSD()->Reset();
+  correctionStandard->GetTriggerBiasCorrectionND()->Reset();
+
+  AlidNdEtaCorrection* corrections[100];
+  TH1F* hRatios[100];
+
+  Int_t counter = 0;
+      
+  TFile::Open(correctionFileName);
+
+  AlidNdEtaCorrection* current = new AlidNdEtaCorrection("dndeta_correction_ua5", "dndeta_correction_ua5");
+  current->LoadHistograms("dndeta_correction");
+  current->Reset();
+
+  TString name;
+  name.Form("dndeta_correction_ND");
+  AlidNdEtaCorrection* dNdEtaCorrectionND = new AlidNdEtaCorrection(name,name);
+  dNdEtaCorrectionND->LoadHistograms();
+  name.Form("dndeta_correction_DD");
+  AlidNdEtaCorrection* dNdEtaCorrectionDD = new AlidNdEtaCorrection(name,name);
+  dNdEtaCorrectionDD->LoadHistograms();
+  name.Form("dndeta_correction_SD");
+  AlidNdEtaCorrection* dNdEtaCorrectionSD = new AlidNdEtaCorrection(name,name);
+  dNdEtaCorrectionSD->LoadHistograms();
+
+  // calculating relative
+  Float_t nd = dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral();
+  Float_t dd = dNdEtaCorrectionDD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral();
+  Float_t sd = dNdEtaCorrectionSD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral();
+  Float_t total = nd + dd + sd;
+  
+  nd /= total;
+  sd /= total;
+  dd /= total;
+  
+  Printf("Ratios in the correction map are: ND=%f, DD=%f, SD=%f", nd, dd, sd);
+  
+  Float_t scaleND = ua5_ND / nd;
+  Float_t scaleDD = ua5_DD / dd;
+  Float_t scaleSD = ua5_SD / sd;
+  
+  Printf("ND=%.2f, DD=%.2f, SD=%.2f",scaleND, scaleDD, scaleSD);
+
+  // scale
+  dNdEtaCorrectionND->GetVertexRecoCorrection()->Scale(scaleND);
+  dNdEtaCorrectionDD->GetVertexRecoCorrection()->Scale(scaleDD);
+  dNdEtaCorrectionSD->GetVertexRecoCorrection()->Scale(scaleSD);
+    
+  dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->Scale(scaleND);
+  dNdEtaCorrectionDD->GetTriggerBiasCorrectionINEL()->Scale(scaleDD);
+  dNdEtaCorrectionSD->GetTriggerBiasCorrectionINEL()->Scale(scaleSD);
+
+  dNdEtaCorrectionND->GetTriggerBiasCorrectionNSD()->Scale(scaleND);
+  dNdEtaCorrectionDD->GetTriggerBiasCorrectionNSD()->Scale(scaleDD);
+  dNdEtaCorrectionSD->GetTriggerBiasCorrectionNSD()->Scale(scaleSD);
+
+  dNdEtaCorrectionND->GetTriggerBiasCorrectionND()->Scale(scaleND);
+  dNdEtaCorrectionDD->GetTriggerBiasCorrectionND()->Scale(scaleDD);
+  dNdEtaCorrectionSD->GetTriggerBiasCorrectionND()->Scale(scaleSD);
+
+  //clear track in correction
+  dNdEtaCorrectionND->GetTrack2ParticleCorrection()->Reset();
+  dNdEtaCorrectionDD->GetTrack2ParticleCorrection()->Reset();
+  dNdEtaCorrectionSD->GetTrack2ParticleCorrection()->Reset();
+
+  TList collection;
+  collection.Add(correctionStandard);
+  collection.Add(dNdEtaCorrectionND);
+  collection.Add(dNdEtaCorrectionDD);
+  collection.Add(dNdEtaCorrectionSD);
+
+  current->Merge(&collection);
+  current->Finish();
+
+  TFile* fout = new TFile(outputFileName,"RECREATE");
+  current->SaveHistograms();
+
+  fout->Write();
+  fout->Close();
+
+  Printf("Trigger efficiencies:");
+  Printf("ND: %.2f %%", 100.0 * dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetMeasuredHistogram()->Integral() / dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral());
+  Printf("SD: %.2f %%", 100.0 * dNdEtaCorrectionSD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetMeasuredHistogram()->Integral() / dNdEtaCorrectionSD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral());
+  Printf("DD: %.2f %%", 100.0 * dNdEtaCorrectionDD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetMeasuredHistogram()->Integral() / dNdEtaCorrectionDD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral());
+  Printf("INEL: %.2f %%", 100.0 * current->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetMeasuredHistogram()->Integral() / current->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral());
+  Printf("NSD: %.2f %%", 100.0 * (dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetMeasuredHistogram()->Integral() + dNdEtaCorrectionDD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetMeasuredHistogram()->Integral()) / (dNdEtaCorrectionND->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral() + dNdEtaCorrectionDD->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->GetGeneratedHistogram()->Integral()));
+}
+
 DrawTriggerEfficiency(Char_t* fileName) {
 
   gStyle->SetOptStat(0);
index fbc62e0..4592693 100644 (file)
@@ -72,6 +72,7 @@ TPad* DrawChange(Bool_t spd, const char* basename, const char** changes, Int_t n
 
   TH1F* hRatios[100];
   for(Int_t i=0; i<nChanges; i++) {
+    Printf("%d", i);
     hRatios[i] = (TH1F*)gFile->Get(Form("%s%s",basename,changes[i]));
     hRatios[i]->SetLineWidth(1);
     hRatios[i]->SetMarkerStyle(22);
@@ -171,12 +172,13 @@ void DrawEffectOfChangeInCrossSection(Bool_t spd = kFALSE, const char* fileName
 {
   TFile::Open(fileName);
 
-  const Char_t* changes[]  = {"pythia","ddmore","ddless","sdmore","sdless", "dmore", "dless", "sdmoreddless", "sdlessddmore", "ddmore25","ddless25","sdmore25","sdless25", "dmore25", "dless25", "sdmoreddless25", "sdlessddmore25" };
+//  const Char_t* changes[]  = {"pythia","ddmore","ddless","sdmore","sdless", "dmore", "dless", "sdmoreddless", "sdlessddmore", "ddmore25","ddless25","sdmore25","sdless25", "dmore25", "dless25", "sdmoreddless25", "sdlessddmore25" };
+  const Char_t* changes[]  = { "ua5","ddmore","ddless","sdmore","sdless", "dmore", "dless", "sdlessddmore", "sdmoreddless" };
   //const Char_t* changes[]  = { "pythia", "qgsm", "phojet" };
   //const Int_t nChanges = 3;
   Int_t colors[] = {1,1,4,1,2,2,4,2,1};
 
-  c = DrawChange(spd, "ratio_vertexReco_triggerBias_", changes, 17, 9, colors, 0);
+  c = DrawChange(spd, "ratio_vertexReco_triggerBias_", changes, 9, 9, colors, 0);
   c->SaveAs("cross_sections.eps");
 }
 
index 439f7cf..62bfddf 100644 (file)
@@ -97,12 +97,14 @@ void run(Int_t runWhat, const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool
   mgr = new AliAnalysisManager;
 
   // Add ESD handler
-  AliESDInputHandler* esdH = new AliESDInputHandler;
+  //AliESDInputHandler* esdH = new AliESDInputHandler;
+  AliESDInputHandler* esdH = new AliESDInputHandlerRP; // for RecPoints
+  
   esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDVZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks Kinks Cascades AliESDTZERO ALIESDACORDE MuonTracks TrdTracks CaloClusters");
   mgr->SetInputEventHandler(esdH);
 
   AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD | AliPWG0Helper::kFieldOn;
-  AliTriggerAnalysis::Trigger trigger      = AliTriggerAnalysis::kMB1 | AliTriggerAnalysis::kOfflineFlag; // AcceptAll;
+  AliTriggerAnalysis::Trigger trigger      = AliTriggerAnalysis::kSPDGFOBits | AliTriggerAnalysis::kOfflineFlag; // AcceptAll;
 
   AliPWG0Helper::PrintConf(analysisMode, trigger);
 
@@ -145,11 +147,14 @@ void run(Int_t runWhat, const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool
     //task->SetUseMCKine();
     //task->SetOnlyPrimaries();
     //task->SetFillPhi();
+    //task->SetSymmetrize();
     
     task->SetTrigger(trigger);
     task->SetAnalysisMode(analysisMode);
     task->SetTrackCuts(esdTrackCuts);
     //task->SetDeltaPhiCut(0.05);
+    
+    task->SetCheckEventType();
 
     mgr->AddTask(task);
 
@@ -168,6 +173,7 @@ void run(Int_t runWhat, const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool
     // syst. error flags
     //task2->SetFillPhi();
     //task2->SetOnlyPrimaries();
+    //task2->SetSymmetrize();
 
     task2->SetTrigger(trigger);
     task2->SetAnalysisMode(analysisMode);
@@ -210,16 +216,14 @@ void run(Int_t runWhat, const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool
       TString path("maps/");
       path += TString(data).Tokenize("/")->Last()->GetName();
       
-      switch (trigger)
+      UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) AliTriggerAnalysis::kStartOfFlags;
+      switch (triggerNoFlags)
       {
-        case AliPWG0Helper::kMB1:
-        case AliPWG0Helper::kOfflineMB1: path += "/mb1"; break;
-        case AliPWG0Helper::kMB2:
-        case AliPWG0Helper::kOfflineMB2: path += "/mb2"; break;
-        case AliPWG0Helper::kMB3:
-        case AliPWG0Helper::kOfflineMB3: path += "/mb3"; break;
-        case AliPWG0Helper::kFASTOR:
-        case AliPWG0Helper::kOfflineFASTOR: path += "/fastor"; break;
+        case AliTriggerAnalysis::kMB1: path += "/mb1"; break;
+        case AliTriggerAnalysis::kMB2: path += "/mb2"; break;
+        case AliTriggerAnalysis::kMB3: path += "/mb3"; break;
+        case AliTriggerAnalysis::kSPDGFO: path += "/spdgfo"; break;
+        case AliTriggerAnalysis::kSPDGFOBits: path += "/spdgfobits"; break;
         default: Printf("ERROR: Trigger undefined for path to files"); return;
       }
       
@@ -231,10 +235,13 @@ void run(Int_t runWhat, const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool
         
       gSystem->mkdir(path, kTRUE);
       if (runWhat == 0 || runWhat == 2)
+      {
         gSystem->Rename("analysis_esd_raw.root", path + "/analysis_esd_raw.root");
+        if (mc)
+          gSystem->Rename("analysis_mc.root", path + "/analysis_mc.root");
+      }
       if (runWhat == 1 || runWhat == 2)
       {
-        gSystem->Rename("analysis_mc.root", path + "/analysis_mc.root");
         gSystem->Rename("correction_map.root", path + "/correction_map.root");
       }