adding trigger configuration
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 May 2008 15:07:06 +0000 (15:07 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 May 2008 15:07:06 +0000 (15:07 +0000)
making control histograms mergaable
syncing run.C with runCorrection.C

PWG0/dNdEta/AlidNdEtaCorrection.h
PWG0/dNdEta/AlidNdEtaCorrectionTask.cxx
PWG0/dNdEta/AlidNdEtaCorrectionTask.h
PWG0/dNdEta/AlidNdEtaTask.cxx
PWG0/dNdEta/AlidNdEtaTask.h
PWG0/dNdEta/dNdEtaAnalysis.cxx
PWG0/dNdEta/dNdEtaAnalysis.h
PWG0/dNdEta/drawPlots.C
PWG0/dNdEta/run.C
PWG0/dNdEta/runCorrection.C [deleted file]

index c56c95f..abdf3f6 100644 (file)
@@ -68,7 +68,7 @@ public:
   Float_t GetMeasuredFraction(CorrectionType correctionType, Float_t ptCutOff, Float_t eta = -100, Bool_t debug = kFALSE);
   TH1*    GetMeasuredEventFraction(CorrectionType correctionType, Int_t multCut);
 
-  void ReduceInformation();
+  void    ReduceInformation();
 
 protected:
   AliCorrection* fTrack2ParticleCorrection;       //-> handles the track-to-particle correction (only track level (vtx_z, eta, pt))
index 4a3b467..2048da7 100644 (file)
@@ -39,6 +39,7 @@ AlidNdEtaCorrectionTask::AlidNdEtaCorrectionTask(const char* opt) :
   fOutput(0),
   fOption(opt),
   fAnalysisMode(AliPWG0Helper::kTPC),
+  fTrigger(AliPWG0Helper::kMB1),
   fSignMode(0),
   fOnlyPrimaries(kFALSE),
   fEsdTrackCuts(0),
@@ -180,21 +181,33 @@ void AlidNdEtaCorrectionTask::CreateOutputObjects()
     Printf("WARNING: sigma-vertex analysis enabled. This will produce weird results in the AliESDtrackCuts histograms");
   }
 
-  fVertexCorrelation = new TH2F("fVertexCorrelation", "fVertexCorrelation;MC z-vtx;ESD z-vtx", 80, -20, 20, 80, -20, 20);
+  fVertexCorrelation = new TH2F("fVertexCorrelation", "fVertexCorrelation;MC z-vtx;ESD z-vtx", 120, -30, 30, 120, -30, 30);
+  fOutput->Add(fVertexCorrelation);
   fVertexProfile = new TProfile("fVertexProfile", "fVertexProfile;MC z-vtx;MC z-vtx - ESD z-vtx", 40, -20, 20);
+  fOutput->Add(fVertexProfile);
   fVertexShiftNorm = new TH1F("fVertexShiftNorm", "fVertexShiftNorm;(MC z-vtx - ESD z-vtx) / #sigma_{ESD z-vtx};Entries", 200, -100, 100);
-  
+  fOutput->Add(fVertexShiftNorm);
+
   fEtaCorrelation = new TH2F("fEtaCorrelation", "fEtaCorrelation;MC #eta;ESD #eta", 120, -3, 3, 120, -3, 3);
+  fOutput->Add(fEtaCorrelation);
   fEtaProfile = new TProfile("fEtaProfile", "fEtaProfile;MC #eta;MC #eta - ESD #eta", 120, -3, 3);
+  fOutput->Add(fEtaProfile);
 
   fMultAll = new TH1F("fMultAll", "fMultAll", 500, -0.5, 499.5);
+  fOutput->Add(fMultAll);
   fMultVtx = new TH1F("fMultVtx", "fMultVtx", 500, -0.5, 499.5);
+  fOutput->Add(fMultVtx);
   fMultTr = new TH1F("fMultTr", "fMultTr", 500, -0.5, 499.5);
+  fOutput->Add(fMultTr);
 
   for (Int_t i=0; i<8; i++)
+  {
     fDeltaPhi[i] = new TH1F(Form("fDeltaPhi_%d", i), ";#Delta phi;Entries", 2000, -0.1, 0.1);
+    fOutput->Add(fDeltaPhi[i]);
+  }
 
   fEventStats = new TH2F("fEventStats", "fEventStats;event type;status;count", 2, -0.5, 1.5, 4, -0.5, 3.5);
+  fOutput->Add(fEventStats);
   fEventStats->GetXaxis()->SetBinLabel(1, "INEL");
   fEventStats->GetXaxis()->SetBinLabel(2, "NSD");
 
@@ -219,7 +232,7 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
     Printf("WARNING: Processing only primaries. For systematical studies only!");
 
   // trigger definition
-  Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB2);
+  Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), fTrigger);
 
   if (!eventTriggered)
     Printf("No trigger");
@@ -433,6 +446,7 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
       if (eventVertex)
         fdNdEtaAnalysisMC->FillTrack(vtxMC[2], eta, pt);
 
+    // TODO this value might be needed lower for the SPD study (only used for control histograms anyway)
     if (TMath::Abs(eta) < 1 && pt > 0.2)
       nAccepted++;
   }
@@ -453,7 +467,7 @@ void AlidNdEtaCorrectionTask::Exec(Option_t*)
 
     if (label < 0)
     {
-      Printf("WARNING: cannot find corresponding mc part for track(let) %d with label %d.", i, label);
+      Printf("WARNING: cannot find corresponding mc particle for track(let) %d with label %d.", i, label);
       continue;
     }
 
@@ -715,31 +729,43 @@ void AlidNdEtaCorrectionTask::Terminate(Option_t *)
   if (fSigmaVertexPrim)
     fSigmaVertexPrim->Write();
 
+  fVertexCorrelation = dynamic_cast<TH2F*> (fOutput->FindObject("fVertexCorrelation"));
   if (fVertexCorrelation)
     fVertexCorrelation->Write();
+  fVertexProfile = dynamic_cast<TProfile*> (fOutput->FindObject("fVertexProfile"));
   if (fVertexProfile)
     fVertexProfile->Write();
+  fVertexShiftNorm = dynamic_cast<TH1F*> (fOutput->FindObject("fVertexShiftNorm"));
   if (fVertexShiftNorm)
     fVertexShiftNorm->Write();
 
+  fEtaCorrelation = dynamic_cast<TH2F*> (fOutput->FindObject("fEtaCorrelation"));
   if (fEtaCorrelation)
     fEtaCorrelation->Write();
+  fEtaProfile = dynamic_cast<TProfile*> (fOutput->FindObject("fEtaProfile"));
   if (fEtaProfile)
     fEtaProfile->Write();
 
+  fMultAll = dynamic_cast<TH1F*> (fOutput->FindObject("fMultAll"));
   if (fMultAll)
     fMultAll->Write();
 
+  fMultTr = dynamic_cast<TH1F*> (fOutput->FindObject("fMultTr"));
   if (fMultTr)
     fMultTr->Write();
-  
+
+  fMultVtx = dynamic_cast<TH1F*> (fOutput->FindObject("fMultVtx"));
   if (fMultVtx)
     fMultVtx->Write();
 
   for (Int_t i=0; i<8; ++i)
+  {
+    fDeltaPhi[i] = dynamic_cast<TH1F*> (fOutput->FindObject(Form("fDeltaPhi_%d", i)));
     if (fDeltaPhi[i])
       fDeltaPhi[i]->Write();
+  }
 
+  fEventStats = dynamic_cast<TH2F*> (fOutput->FindObject("fEventStats"));
   if (fEventStats)
     fEventStats->Write();
 
index bd46e79..0c3b472 100644 (file)
@@ -29,6 +29,9 @@ class AlidNdEtaCorrectionTask : public AliAnalysisTask {
     void SetTrackCuts(AliESDtrackCuts* cuts) { fEsdTrackCuts = cuts; }
     void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
     void SetOnlyPrimaries(Bool_t flag = kTRUE) { fOnlyPrimaries = flag; }
+    void SetTrigger(AliPWG0Helper::Trigger trigger) { fTrigger = trigger; }
+
+    void SetOption(const char* opt) { fOption = opt; }
 
  protected:
     Bool_t SignOK(TParticlePDG* particle);
@@ -38,6 +41,7 @@ class AlidNdEtaCorrectionTask : public AliAnalysisTask {
 
     TString fOption;                 // option string
     AliPWG0Helper::AnalysisMode fAnalysisMode;    // detector that is used for analysis
+    AliPWG0Helper::Trigger fTrigger; // trigger used in the analysis
     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 573ef5a..71fbb0e 100644 (file)
@@ -43,6 +43,7 @@ AlidNdEtaTask::AlidNdEtaTask(const char* opt) :
   fOutput(0),
   fOption(opt),
   fAnalysisMode(AliPWG0Helper::kTPC),
+  fTrigger(AliPWG0Helper::kMB1),
   fReadMC(kFALSE),
   fUseMCVertex(kFALSE),
   fUseMCKine(kFALSE),
@@ -53,6 +54,7 @@ AlidNdEtaTask::AlidNdEtaTask(const char* opt) :
   fEvents(0),
   fVertexResolution(0),
   fdNdEtaAnalysis(0),
+  fdNdEtaAnalysisNSD(0),
   fdNdEtaAnalysisTr(0),
   fdNdEtaAnalysisTrVtx(0),
   fdNdEtaAnalysisTracks(0),
@@ -99,19 +101,18 @@ void AlidNdEtaTask::ConnectInputData(Option_t *)
     // Disable all branches and enable only the needed ones
     //tree->SetBranchStatus("*", 0);
 
-    tree->SetBranchStatus("fTriggerMask", 1);
-    tree->SetBranchStatus("fSPDVertex*", 1);
-    // PrimaryVertex also needed
+    tree->SetBranchStatus("TriggerMask", 1);
+    tree->SetBranchStatus("SPDVertex*", 1);
+    tree->SetBranchStatus("PrimaryVertex*", 1);
+    tree->SetBranchStatus("TPCVertex*", 1);
 
     if (fAnalysisMode == AliPWG0Helper::kSPD) {
-      tree->SetBranchStatus("fSPDMult*", 1);
-      //AliPWG0Helper::SetBranchStatusRecursive(tree, "AliMultiplicity", kTRUE);
+      tree->SetBranchStatus("AliMultiplicity*", 1);
     }
-    
+
     if (fAnalysisMode == AliPWG0Helper::kTPC || fAnalysisMode == AliPWG0Helper::kTPCITS) {
-      AliESDtrackCuts::EnableNeededBranches(tree);
-      tree->SetBranchStatus("fTracks.fLabel", 1);
-      //AliPWG0Helper::SetBranchStatusRecursive(tree, "Tracks", kTRUE);
+      //AliESDtrackCuts::EnableNeededBranches(tree);
+      tree->SetBranchStatus("Tracks*", 1);
     }
 
     AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
@@ -151,7 +152,7 @@ void AlidNdEtaTask::CreateOutputObjects()
     fOutput->Add(fPartEta[i]);
   }
 
-  fEvents = new TH1F("dndeta_check_vertex", "dndeta_check_vertex", 40, -20, 20);
+  fEvents = new TH1F("dndeta_check_vertex", "dndeta_check_vertex", 160, -40, 40);
   fOutput->Add(fEvents);
 
   fVertexResolution = new TH1F("dndeta_vertex_resolution_z", "dndeta_vertex_resolution_z", 1000, 0, 10);
@@ -162,6 +163,9 @@ void AlidNdEtaTask::CreateOutputObjects()
     fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta", fAnalysisMode);
     fOutput->Add(fdNdEtaAnalysis);
 
+    fdNdEtaAnalysisNSD = new dNdEtaAnalysis("dndetaNSD", "dndetaNSD", fAnalysisMode);
+    fOutput->Add(fdNdEtaAnalysisNSD);
+
     fdNdEtaAnalysisTr = new dNdEtaAnalysis("dndetaTr", "dndetaTr", fAnalysisMode);
     fOutput->Add(fdNdEtaAnalysisTr);
 
@@ -195,7 +199,7 @@ void AlidNdEtaTask::Exec(Option_t*)
   }
 
   // trigger definition
-  Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB2);
+  Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), fTrigger);
 
   // get the ESD vertex
   const AliESDVertex* vtxESD = AliPWG0Helper::GetVertex(fESD, fAnalysisMode);
@@ -426,6 +430,13 @@ void AlidNdEtaTask::Exec(Option_t*)
     TArrayF vtxMC(3);
     genHeader->PrimaryVertex(vtxMC);
 
+    // get process type; NB: this only works for Pythia
+    Int_t processType = AliPWG0Helper::GetPythiaEventProcessType(header);
+    AliDebug(AliLog::kDebug+1, Form("Found pythia process type %d", processType));
+
+    if (processType<0)
+      AliDebug(AliLog::kError, Form("Unknown Pythia process type %d.", processType));
+
     // loop over mc particles
     Int_t nPrim  = stack->GetNprimary();
 
@@ -453,6 +464,9 @@ void AlidNdEtaTask::Exec(Option_t*)
       fdNdEtaAnalysis->FillTrack(vtxMC[2], eta, pt);
       fVertex->Fill(particle->Vx(), particle->Vy(), particle->Vz());
 
+      if (processType != 92 && processType != 93)
+        fdNdEtaAnalysisNSD->FillTrack(vtxMC[2], eta, pt);
+
       if (eventTriggered)
       {
         fdNdEtaAnalysisTr->FillTrack(vtxMC[2], eta, pt);
@@ -465,6 +479,9 @@ void AlidNdEtaTask::Exec(Option_t*)
     }
 
     fdNdEtaAnalysis->FillEvent(vtxMC[2], nAcceptedParticles);
+    if (processType != 92 && processType != 93)
+      fdNdEtaAnalysisNSD->FillEvent(vtxMC[2], nAcceptedParticles);
+
     if (eventTriggered)
     {
       fdNdEtaAnalysisTr->FillEvent(vtxMC[2], nAcceptedParticles);
@@ -605,6 +622,7 @@ void AlidNdEtaTask::Terminate(Option_t *)
   if (fReadMC)
   {
     fdNdEtaAnalysis = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndeta"));
+    fdNdEtaAnalysisNSD = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaNSD"));
     fdNdEtaAnalysisTr = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaTr"));
     fdNdEtaAnalysisTrVtx = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaTrVtx"));
     fdNdEtaAnalysisTracks = dynamic_cast<dNdEtaAnalysis*> (fOutput->FindObject("dndetaTracks"));
@@ -617,6 +635,7 @@ void AlidNdEtaTask::Terminate(Option_t *)
     }
 
     fdNdEtaAnalysis->Finish(0, -1, AlidNdEtaCorrection::kNone);
+    fdNdEtaAnalysisNSD->Finish(0, -1, AlidNdEtaCorrection::kNone);
     fdNdEtaAnalysisTr->Finish(0, -1, AlidNdEtaCorrection::kNone);
     fdNdEtaAnalysisTrVtx->Finish(0, -1, AlidNdEtaCorrection::kNone);
     fdNdEtaAnalysisTracks->Finish(0, -1, AlidNdEtaCorrection::kNone);
@@ -628,6 +647,7 @@ void AlidNdEtaTask::Terminate(Option_t *)
     TFile* fout = new TFile("analysis_mc.root","RECREATE");
 
     fdNdEtaAnalysis->SaveHistograms();
+    fdNdEtaAnalysisNSD->SaveHistograms();
     fdNdEtaAnalysisTr->SaveHistograms();
     fdNdEtaAnalysisTrVtx->SaveHistograms();
     fdNdEtaAnalysisTracks->SaveHistograms();
index 3aaf075..8799a57 100644 (file)
@@ -28,6 +28,9 @@ class AlidNdEtaTask : public AliAnalysisTask {
     void SetReadMC(Bool_t flag = kTRUE) { fReadMC = flag; }
     void SetUseMCVertex(Bool_t flag = kTRUE) { fUseMCVertex = flag; }
     void SetUseMCKine(Bool_t flag = kTRUE) { fUseMCKine = flag; }
+    void SetTrigger(AliPWG0Helper::Trigger trigger) { fTrigger = trigger; }
+
+    void SetOption(const char* opt) { fOption = opt; }
 
  protected:
     AliESDEvent *fESD;    //! ESD object
@@ -35,6 +38,7 @@ class AlidNdEtaTask : public AliAnalysisTask {
 
     TString fOption;      // option string
     AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
+    AliPWG0Helper::Trigger fTrigger;           // trigger that is used
 
     Bool_t  fReadMC;       // if true reads MC data (to build correlation maps)
     Bool_t  fUseMCVertex;  // the MC vtx is used instead of the ESD vertex (for syst. check)
@@ -53,6 +57,7 @@ class AlidNdEtaTask : public AliAnalysisTask {
 
     // Gathered from MC (when fReadMC is set)
     dNdEtaAnalysis* fdNdEtaAnalysis;        //! contains the dndeta from the full sample
+    dNdEtaAnalysis* fdNdEtaAnalysisNSD;        //! contains the dndeta for the NSD sample
     dNdEtaAnalysis* fdNdEtaAnalysisTr;      //! contains the dndeta from the triggered events
     dNdEtaAnalysis* fdNdEtaAnalysisTrVtx;   //! contains the dndeta from the triggered events with vertex
     dNdEtaAnalysis* fdNdEtaAnalysisTracks;  //! contains the dndeta from the triggered events with vertex counted from the mc particles associated to the tracks (comparing this to the raw values from the esd shows the effect of the detector resolution)
index c308a48..53f50eb 100644 (file)
@@ -185,7 +185,7 @@ void dNdEtaAnalysis::FillTriggeredEvent(Float_t n)
 }
 
 //____________________________________________________________________
-void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, Int_t multCut)
+void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, const char* tag)
 {
   //
   // correct with the given correction values and calculate dNdEta and pT distribution
@@ -195,17 +195,19 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
 
   // TODO put tag somewhere which corrections have been applied
 
-  if (multCut > 1)
-  {
-    Printf("ERROR: A bigger multiplicity cut than 1 is not possible in the current implementation");
-    return;
-  }
+  Printf("\n\nCorrecting dN/deta spectrum >>> %s <<<. Correction type: %d, pt cut: %.2f.", tag, (Int_t) correctionType, ptCut);
 
   // set corrections to 1
   fData->SetCorrectionToUnity();
 
   if (correction && correctionType != AlidNdEtaCorrection::kNone)
   {
+   /* Printf("FAKE: Rebinning. For test only");
+    correction->GetVertexRecoCorrection()->GetEventCorrection()->Rebin(2, 1);
+    correction->GetTriggerBiasCorrectionINEL()->GetEventCorrection()->Rebin(2, 1);
+    correction->GetTriggerBiasCorrectionNSD()->GetEventCorrection()->Rebin(2, 1);
+    fData->GetEventCorrection()->Rebin(2, 1);*/
+
     TH3F* trackCorr = fData->GetTrackCorrection()->GetCorrectionHistogram();
     TH2F* eventCorr = fData->GetEventCorrection()->GetCorrectionHistogram();
 
@@ -217,7 +219,7 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
       trackCorr->Multiply(correction->GetVertexRecoCorrection()->GetTrackCorrection()->GetCorrectionHistogram());
       eventCorr->Multiply(correction->GetVertexRecoCorrection()->GetEventCorrection()->GetCorrectionHistogram());
 
-      // set bin with multiplicity 0 to 1 (correction has no meaning in this bin)
+      // set bin with multiplicity 0 to unity (correction has no meaning in this bin)
       for (Int_t i=0; i<=eventCorr->GetNbinsX()+1; i++)
         eventCorr->SetBinContent(i, 1, 1);
     }
@@ -264,7 +266,7 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
     //new TCanvas; correctedEvents->DrawCopy("TEXT");
 
     // start above 0 mult. bin with integration
-    TH1* vertexDist = measuredEvents->ProjectionX("vertexdist_measured", 2);
+    TH1* vertexDist = correctedEvents->ProjectionX("vertexdist_measured", 2);
     //new TCanvas; vertexDist->DrawCopy();
 
     Int_t allEventsWithVertex = (Int_t) vertexDist->Integral(0, vertexDist->GetNbinsX()+1); // include under/overflow!
@@ -280,7 +282,7 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
       // multiply with trigger correction if set above
       events *= fData->GetEventCorrection()->GetCorrectionHistogram()->GetBinContent(i, 1);
 
-      Printf("Bin %d, alpha is %.2f, number of events with 0 mult. are %.2f", i, alpha, events);
+      Printf("Bin %d, alpha is %.2f, number of events with 0 mult.: %.2f", i, alpha, events);
 
       correctedEvents->SetBinContent(i, 1, events);
     }
@@ -632,8 +634,8 @@ Long64_t dNdEtaAnalysis::Merge(TCollection* list)
       continue;
 
     collections[0]->Add(entry->fData);
-    collections[2]->Add(entry->fMult);
-    collections[3]->Add(entry->fPtDist);
+    collections[1]->Add(entry->fMult);
+    collections[2]->Add(entry->fPtDist);
 
     for (Int_t i=0; i<kVertexBinning; ++i)
     {
index 8edf7ef..94aee85 100644 (file)
@@ -43,7 +43,7 @@ public:
   void FillEvent(Float_t vtx, Float_t n);
   void FillTriggeredEvent(Float_t n);
 
-  void Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, Int_t multCut = 0);
+  void Finish(AlidNdEtaCorrection* correction, Float_t ptCut, AlidNdEtaCorrection::CorrectionType correctionType, const char* tag = "");
 
   void DrawHistograms(Bool_t simple = kFALSE);
   void LoadHistograms(const Char_t* dir = 0);
index 118555b..e188a69 100644 (file)
@@ -251,6 +251,7 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
 {
   TFile* file = TFile::Open("analysis_esd.root");
   TH1* histESD = (TH1*) file->Get("dndeta/dNdEta_corrected");
+  TH1* histESDnsd = (TH1*) file->Get("dndetaNSD/dNdEta_corrected");
   TH1* histESDNoPt = (TH1*) file->Get("dndeta/dNdEta");
   TH1* histESDMB = (TH1*) file->Get("dndetaTr/dNdEta_corrected");
   TH1* histESDMBNoPt = (TH1*) file->Get("dndetaTr/dNdEta");
@@ -259,6 +260,7 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   TH1* histESDMBTracksNoPt = (TH1*) file->Get("dndetaTracks/dNdEta");
 
   Prepare1DPlot(histESD);
+  Prepare1DPlot(histESDnsd);
   Prepare1DPlot(histESDMB);
   Prepare1DPlot(histESDMBVtx);
 
@@ -268,6 +270,7 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   Prepare1DPlot(histESDMBTracksNoPt);
 
   histESD->SetLineWidth(0);
+  histESDnsd->SetLineWidth(0);
   histESDMB->SetLineWidth(0);
   histESDMBVtx->SetLineWidth(0);
 
@@ -276,10 +279,12 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   histESDMBVtxNoPt->SetLineWidth(0);
 
   histESD->SetMarkerColor(1);
+  histESDnsd->SetMarkerColor(6);
   histESDMB->SetMarkerColor(2);
   histESDMBVtx->SetMarkerColor(3);
 
   histESD->SetLineColor(1);
+  histESDnsd->SetLineColor(6);
   histESDMB->SetLineColor(2);
   histESDMBVtx->SetLineColor(3);
 
@@ -289,6 +294,7 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   histESDMBTracksNoPt->SetMarkerColor(4);
 
   histESD->SetMarkerStyle(20);
+  histESDnsd->SetMarkerStyle(29);
   histESDMB->SetMarkerStyle(21);
   histESDMBVtx->SetMarkerStyle(22);
 
@@ -297,24 +303,28 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   histESDMBVtxNoPt->SetMarkerStyle(22);
   histESDMBTracksNoPt->SetMarkerStyle(23);
   
-  TH2F* dummy = new TH2F("dummy", "", 100, -1.5, 1.5, 1000, 0, histESDMBVtx->GetMaximum() * 1.1);
-  Prepare1DPlot(dummy);
-  dummy->SetStats(kFALSE);
-  dummy->SetXTitle("#eta");
-  dummy->SetYTitle("dN_{ch}/d#eta");
-  dummy->GetYaxis()->SetTitleOffset(1);
-
   Float_t etaLimit = 1.2999;
 
   histESDMBVtx->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
   histESDMB->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
   histESD->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
+  histESDnsd->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
 
   histESDNoPt->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
   histESDMBNoPt->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
   histESDMBVtxNoPt->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
   histESDMBTracksNoPt->GetXaxis()->SetRangeUser(-etaLimit, etaLimit);
 
+  Float_t max = TMath::Max(histESDMBVtx->GetMaximum(), histESDMB->GetMaximum());
+  max = TMath::Max(max, histESD->GetMaximum());
+
+  TH2F* dummy = new TH2F("dummy", "", 100, -1.5, 1.5, 1000, 0, max * 1.1);
+  Prepare1DPlot(dummy);
+  dummy->SetStats(kFALSE);
+  dummy->SetXTitle("#eta");
+  dummy->SetYTitle("dN_{ch}/d#eta");
+  dummy->GetYaxis()->SetTitleOffset(1);
+
   TCanvas* canvas = new TCanvas("dNdEta1", "dNdEta1", 500, 500);
 
   dummy->DrawCopy();
@@ -335,6 +345,10 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
 
   TFile* file2 = TFile::Open("analysis_mc.root");
   TH1* histMC = (TH1*) file2->Get("dndeta/dNdEta_corrected")->Clone("cloned");
+  TH1* histMCnsd = (TH1*) file2->Get("dndetaNSD/dNdEta_corrected");
+  // FAKE
+  if (!histMCnsd)
+       histMCnsd = histMC;
   TH1* histMCTr = (TH1*) file2->Get("dndetaTr/dNdEta_corrected")->Clone("cloned2");
   TH1* histMCTrVtx = (TH1*) file2->Get("dndetaTrVtx/dNdEta_corrected")->Clone("cloned3");
 
@@ -342,27 +356,28 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   fdNdEtaAnalysis->LoadHistograms();
   dNdEtaAnalysis* fdNdEtaAnalysis2 = (dNdEtaAnalysis*) fdNdEtaAnalysis->Clone();
 
-  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
+  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "MC: full inelastic");
   TH1* histMCPtCut = (TH1*) fdNdEtaAnalysis->GetdNdEtaHistogram(0)->Clone("histMCPtCut");
 
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTr", "dndetaTr");
   fdNdEtaAnalysis->LoadHistograms();
-  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
+  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "MC: minimum bias");
   TH1* histMCTrPtCut = fdNdEtaAnalysis->GetdNdEtaHistogram(0);
 
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx");
   fdNdEtaAnalysis->LoadHistograms();
-  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
+  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "MC: MB with trigger");
   TH1* histMCTrVtxPtCut = fdNdEtaAnalysis->GetdNdEtaHistogram(0);
 
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks");
   fdNdEtaAnalysis->LoadHistograms();
-  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone);
+  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "MC: Tracks w/o resolution effect");
   TH1* histMCTracksPtCut = fdNdEtaAnalysis->GetdNdEtaHistogram(0);
 
   TCanvas* canvas2 = new TCanvas("dNdEta2", "dNdEta2", 500, 500);
 
   Prepare1DPlot(histMC);
+  Prepare1DPlot(histMCnsd);
   Prepare1DPlot(histMCTr);
   Prepare1DPlot(histMCTrVtx);
 
@@ -373,6 +388,7 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
     Prepare1DPlot(histMCTracksPtCut);
 
   histMC->SetLineColor(1);
+  histMCnsd->SetLineColor(6);
   histMCTr->SetLineColor(2);
   histMCTrVtx->SetLineColor(3);
 
@@ -384,13 +400,15 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
 
   TH2* dummy2 = (TH2F*) dummy->Clone("dummy2");
   Prepare1DPlot(dummy2);
-  dummy2->GetYaxis()->SetRangeUser(0, histESDMBVtx->GetMaximum() * 1.1);
+  dummy2->GetYaxis()->SetRangeUser(0, max * 1.1);
 
   dummy2->DrawCopy();
   histMC->Draw("SAME");
+  histMCnsd->Draw("SAME");
   histMCTr->Draw("SAME");
   histMCTrVtx->Draw("SAME");
   histESD->Draw("SAME");
+  histESDnsd->Draw("SAME");
   histESDMB->Draw("SAME");
   histESDMBVtx->Draw("SAME");
   histESDNoPt->Draw("SAME");
@@ -409,6 +427,11 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
     canvas2->SaveAs("dNdEta2.eps");
   }
 
+  new TCanvas;
+  dummy2->DrawCopy();
+  histMCnsd->Draw("SAME");
+  histESDnsd->Draw("SAME");
+
   TH1* ratio = (TH1*) histMC->Clone("ratio");
   TH1* ratioNoPt = (TH1*) histMCPtCut->Clone("ratioNoPt");
 
@@ -477,13 +500,13 @@ void dNdEta(Bool_t onlyESD = kFALSE, Bool_t save = kTRUE)
   pad2->cd();
   pad2->SetBottomMargin(0.15);
 
-  Float_t min = TMath::Min(0.961, ratio->GetMinimum() * 0.95);
-  Float_t max = TMath::Max(1.049, ratio->GetMaximum() * 1.05);
+  Float_t minR = TMath::Min(0.961, ratio->GetMinimum() * 0.95);
+  Float_t maxR = TMath::Max(1.049, ratio->GetMaximum() * 1.05);
 
   TH1F dummy3("dummy3", ";#eta;Ratio: MC / ESD", 1, -1.5, 1.5);
   dummy3.SetStats(kFALSE);
   dummy3.SetBinContent(1, 1);
-  dummy3.GetYaxis()->SetRangeUser(min, max);
+  dummy3.GetYaxis()->SetRangeUser(minR, maxR);
   dummy3.SetLineWidth(2);
   dummy3.GetXaxis()->SetLabelSize(0.06);
   dummy3.GetYaxis()->SetLabelSize(0.06);
@@ -1468,10 +1491,17 @@ void CompareCorrection2Measured(const char* dataInput = "analysis_esd_raw.root",
   Printf("esd contains %f entries in |vtx-z| < 10, pt > 0.3", hist2->Integral(hist2->GetXaxis()->FindBin(-9.9), hist2->GetXaxis()->FindBin(9.9), 1, hist2->GetNbinsY(), hist2->GetZaxis()->FindBin(0.301), hist2->GetNbinsZ()));
 
   AliPWG0Helper::CreateDividedProjections(hist1, hist2);
+  AliPWG0Helper::CreateDividedProjections(hist1, hist2, "x");
+
+  hist1->GetXaxis()->SetRange(hist1->GetXaxis()->FindBin(-10), hist2->GetXaxis()->FindBin(10));
+  hist2->GetXaxis()->SetRange(hist1->GetXaxis()->FindBin(-10), hist2->GetXaxis()->FindBin(10));
+  AliPWG0Helper::CreateDividedProjections(hist1, hist2, "y");
 
   new TCanvas; gROOT->FindObject("mc_yx_div_esd_yx")->Draw("COLZ");
   new TCanvas; gROOT->FindObject("mc_zx_div_esd_zx")->Draw("COLZ");
   new TCanvas; gROOT->FindObject("mc_zy_div_esd_zy")->Draw("COLZ");
+  new TCanvas; gROOT->FindObject("mc_x_div_esd_x")->Draw("COLZ");
+  new TCanvas; gROOT->FindObject("mc_y_div_esd_y")->Draw("COLZ");
 }
 
 void CompareMeasured2Measured(const char* dataInput = "analysis_esd_raw.root", const char* dataInput2 = "analysis_esd_raw.root")
@@ -1541,3 +1571,60 @@ void CompareMeasured2Measured(const char* dataInput = "analysis_esd_raw.root", c
 
 }
 
+void DrawTrackletOrigin()
+{
+  TFile::Open("correction_map.root");
+
+  Int_t colors[]  = {1,2,3,4,6,7,8,102};
+
+  Int_t maxHists = 8;
+  TH1* hist[8];
+
+  const char* titles[] = { "PP", "SS", "PP'", "PS", "PS*", "SP", "SS'", "" };
+
+  TLegend* legend = new TLegend(0.75, 0.6, 0.95, 0.95);
+
+  Int_t total = 0;
+  for (Int_t i=0; i<maxHists; i++)
+  {
+    hist[i] = (TH1*) gFile->Get(Form("fDeltaPhi_%d", i));
+    //hist[i]->Rebin(20);
+    hist[i]->SetStats(kFALSE);
+    hist[i]->SetLineColor(colors[i]);
+    hist[i]->GetXaxis()->SetRangeUser(-0.2, 0.2);
+    hist[i]->Draw(((i == 0) ? "" : "SAME"));
+
+    total += hist[i]->GetEntries();
+
+    if (i != 7)
+      legend->AddEntry(hist[i], titles[i]);
+  }
+
+  legend->Draw();
+  gPad->SetLogy();
+
+  Printf("Total: %d", total);
+  for (Int_t i=0; i<maxHists; i++)
+    Printf("Histogram %d (%s) containts %.2f %% of the entries", i, titles[i], 100.0 * hist[i]->GetEntries() / total);
+
+  printf("|  Delta phi  |  Acc. %%  |  ");
+  for (Int_t i=0; i<maxHists; i++)
+    printf("%3s %%   |  ", titles[i]);
+  Printf("");
+
+  for (Float_t f = 0.01; f < 0.09; f += 0.01)
+  {
+    Int_t integralBegin = hist[0]->GetXaxis()->FindBin(-f);
+    Int_t integralEnd = hist[0]->GetXaxis()->FindBin(f);
+
+    Int_t total2 = 0;
+    for (Int_t i=0; i<maxHists; i++)
+      total2 += (Int_t) hist[i]->Integral(integralBegin, integralEnd);
+
+    printf("|    %.2f     |  %6.2f  |  ", f, 100.0 * total2 / total);
+
+    for (Int_t i=0; i<maxHists; i++)
+      printf("%6.2f  |  ", (hist[i]->GetEntries() > 0) ? (100.0 * hist[i]->Integral(integralBegin, integralEnd) / hist[i]->GetEntries()) : -1.0);
+    Printf("");
+  }
+}
index ce581c5..d967bc9 100644 (file)
@@ -1,20 +1,57 @@
-void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Bool_t aProof = kFALSE, Bool_t mc = kTRUE, const char* option = "")
+void run(Int_t runWhat, Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Int_t aProof = kFALSE, Bool_t mc = kTRUE, const char* option = "")
 {
+  // runWhat options: 0 = AlidNdEtaTask
+  //                  1 = AlidNdEtaCorrectionTask
+  //
+  // aProof option: 0 no proof
+  //                1 proof with chain
+  //                2 proof with dataset
+
+  TString taskName;
+  if (runWhat == 0)
+  {
+    taskName = "AlidNdEtaTask";
+  }
+  else if (runWhat == 1)
+  {
+    taskName = "AlidNdEtaCorrectionTask";
+    if (!mc)
+    {
+      Printf("%s needs MC. Exiting...", taskName.Data());
+      return;
+    }
+  }
+  else
+  {
+    Printf("Do not know what to run. Exiting...");
+    return;
+  }
+
+  Printf("Processing task: %s", taskName.Data());
+
+  if (nRuns < 0)
+    nRuns = 1234567890;
+
   if (aProof)
   {
     TProof::Open("lxb6046");
+    //gProof->SetParallel(1);
 
     // Enable the needed package
-    gProof->UploadPackage("STEERBase");
+    /*gProof->UploadPackage("STEERBase");
     gProof->EnablePackage("STEERBase");
     gProof->UploadPackage("ESD");
     gProof->EnablePackage("ESD");
     gProof->UploadPackage("AOD");
     gProof->EnablePackage("AOD");
     gProof->UploadPackage("ANALYSIS");
-    gProof->EnablePackage("ANALYSIS");
-    gProof->UploadPackage("PWG0base");
-    gProof->EnablePackage("PWG0base");
+    gProof->EnablePackage("ANALYSIS");*/
+
+    gProof->UploadPackage("$ALICE_ROOT/AF-v4-12");
+    gProof->EnablePackage("$ALICE_ROOT/AF-v4-12");
+
+    gProof->UploadPackage("$ALICE_ROOT/PWG0base");
+    gProof->EnablePackage("$ALICE_ROOT/PWG0base");
   }
   else
   {
@@ -26,47 +63,58 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
     gSystem->Load("libPWG0base");
   }
 
-  // Create chain of input files
-  gROOT->LoadMacro("../CreateESDChain.C");
-  chain = CreateESDChain(data, nRuns, offset);
-
   // Create the analysis manager
   mgr = new AliAnalysisManager;
 
-  TString taskName("AlidNdEtaTask.cxx+");
+  TString compileTaskName;
+  compileTaskName.Form("%s.cxx+", taskName.Data());
   if (aDebug)
-    taskName += "+g";
+    compileTaskName += "+g";
 
   // Create, add task
   if (aProof) {
-    gProof->Load(taskName);
+    gProof->Load(compileTaskName);
   } else
-    gROOT->Macro(taskName);
-
-  task = new AlidNdEtaTask(option);
+    gROOT->Macro(compileTaskName);
 
   AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD;
-  task->SetAnalysisMode(analysisMode);
+  AliPWG0Helper::Trigger      trigger = AliPWG0Helper::kMB1;
+
+  AliPWG0Helper::PrintConf(analysisMode, trigger);
 
+  AliESDtrackCuts* esdTrackCuts = 0;
   if (analysisMode != AliPWG0Helper::kSPD)
   {
     // selection of esd tracks
     gROOT->ProcessLine(".L ../CreateStandardCuts.C");
-    AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
+    esdTrackCuts = CreateTrackCuts(analysisMode);
     if (!esdTrackCuts)
     {
       printf("ERROR: esdTrackCuts could not be created\n");
       return;
     }
+  }
+
+  if (runWhat == 0)
+  {
+    task = new AlidNdEtaTask(option);
 
-    task->SetTrackCuts(esdTrackCuts);
+    if (mc)
+      task->SetReadMC();
+
+    //task->SetUseMCVertex();
+    //task->SetUseMCKine();
   }
+  else if (runWhat == 1)
+  {
+    task = new AlidNdEtaCorrectionTask(option);
 
-  if (mc)
-    task->SetReadMC();
+    //task->SetOnlyPrimaries();
+  }
 
-  //task->SetUseMCVertex();
-  //task->SetUseMCKine();
+  task->SetTrigger(trigger);
+  task->SetAnalysisMode(analysisMode);
+  task->SetTrackCuts(esdTrackCuts);
 
   mgr->AddTask(task);
 
@@ -91,13 +139,31 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
 
   // Enable debug printouts
   if (aDebug)
+  {
     mgr->SetDebugLevel(2);
+    AliLog::SetClassDebugLevel(taskName, AliLog::kDebug+2);
+  }
+  else
+    AliLog::SetClassDebugLevel(taskName, AliLog::kWarning);
 
   // Run analysis
   mgr->InitAnalysis();
   mgr->PrintStatus();
 
-  mgr->StartAnalysis((aProof) ? "proof" : "local", chain);
+  if (aProof == 2)
+  {
+    // process dataset
+
+    mgr->StartAnalysis("proof", data, nRuns, offset);
+  }
+  else
+  {
+    // Create chain of input files
+    gROOT->LoadMacro("../CreateESDChain.C");
+    chain = CreateESDChain(data, nRuns, offset);
+
+    mgr->StartAnalysis((aProof > 0) ? "proof" : "local", chain);
+  }
 }
 
 void loadlibs()
@@ -126,17 +192,25 @@ void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const ch
     return;
   }
 
-  dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta");
+  dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaNSD", "dndetaNSD");
   fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
-  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL, 1);
+  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kNSD, "ESD -> NSD");
   //fdNdEtaAnalysis->DrawHistograms(kTRUE);
   TFile* file2 = TFile::Open(dataOutput, "RECREATE");
   fdNdEtaAnalysis->SaveHistograms();
 
   file->cd();
+  dNdEtaAnalysis* fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta", "dndeta");
+  fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
+  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kINEL, "ESD -> full inelastic");
+  //fdNdEtaAnalysis->DrawHistograms(kTRUE);
+  file2->cd();
+  fdNdEtaAnalysis->SaveHistograms();
+
+  file->cd();
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTr", "dndetaTr");
   fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
-  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kVertexReco, 1);
+  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kVertexReco, "ESD -> minimum bias");
   //fdNdEtaAnalysis->DrawHistograms(kTRUE);
   file2->cd();
   fdNdEtaAnalysis->SaveHistograms();
@@ -144,7 +218,7 @@ void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const ch
   file->cd();
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTrVtx", "dndetaTrVtx");
   fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
-  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kTrack2Particle, 1);
+  fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0.3, AlidNdEtaCorrection::kTrack2Particle, "ESD -> MB with trigger");
   //fdNdEtaAnalysis->DrawHistograms(kTRUE);
   file2->cd();
   fdNdEtaAnalysis->SaveHistograms();
@@ -152,7 +226,7 @@ void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const ch
   file->cd();
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndetaTracks", "dndetaTracks");
   fdNdEtaAnalysis->LoadHistograms("fdNdEtaAnalysisESD");
-  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, 1);
+  fdNdEtaAnalysis->Finish(0, 0.3, AlidNdEtaCorrection::kNone, "ESD raw");
   //fdNdEtaAnalysis->DrawHistograms(kTRUE);
   file2->cd();
   fdNdEtaAnalysis->SaveHistograms();
diff --git a/PWG0/dNdEta/runCorrection.C b/PWG0/dNdEta/runCorrection.C
deleted file mode 100644 (file)
index 174b22c..0000000
+++ /dev/null
@@ -1,102 +0,0 @@
-void runCorrection(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Bool_t aProof = kFALSE, const char* option = ""){
-  if (aProof)
-  {
-    TProof::Open("lxb6046");
-
-    // Enable the needed package
-    gProof->UploadPackage("STEERBase");
-    gProof->EnablePackage("STEERBase");
-    gProof->UploadPackage("ESD");
-    gProof->EnablePackage("ESD");
-    gProof->UploadPackage("AOD");
-    gProof->EnablePackage("AOD");
-    gProof->UploadPackage("ANALYSIS");
-    gProof->EnablePackage("ANALYSIS");
-    gProof->UploadPackage("PWG0base");
-    gProof->EnablePackage("PWG0base");
-  }
-  else
-  {
-    gSystem->Load("libVMC");
-    gSystem->Load("libTree");
-    gSystem->Load("libSTEERBase");
-    gSystem->Load("libESD");
-    gSystem->Load("libAOD");
-    gSystem->Load("libANALYSIS");
-    gSystem->Load("libPWG0base");
-  }
-
-  // Create chain of input files
-  gROOT->LoadMacro("../CreateESDChain.C");
-  chain = CreateESDChain(data, nRuns, offset);
-
-  // Create the analysis manager
-  mgr = new AliAnalysisManager;
-
-  TString taskName("AlidNdEtaCorrectionTask.cxx+");
-  if (aDebug)
-    taskName += "+g";
-
-  // Create, add task
-  if (aProof) {
-    gProof->Load(taskName);
-  } else
-    gROOT->Macro(taskName);
-
-  task = new AlidNdEtaCorrectionTask(option);
-
-  AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD;
-  task->SetAnalysisMode(analysisMode);
-
-  //task->SetOnlyPrimaries();
-
-  if (analysisMode != AliPWG0Helper::kSPD)
-  {
-    // selection of esd tracks
-    gROOT->ProcessLine(".L ../CreateStandardCuts.C");
-    AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
-    if (!esdTrackCuts)
-    {
-      printf("ERROR: esdTrackCuts could not be created\n");
-      return;
-    }
-
-    task->SetTrackCuts(esdTrackCuts);
-  }
-
-  mgr->AddTask(task);
-
-  // Enable MC event handler
-  AliMCEventHandler* handler = new AliMCEventHandler;
-  handler->SetReadTR(kFALSE);
-  mgr->SetMCtruthEventHandler(handler);
-
-  // Add ESD handler
-  AliESDInputHandler* esdH = new AliESDInputHandler;
-  mgr->SetInputEventHandler(esdH);
-
-  // Attach input
-  cInput  = mgr->CreateContainer("cInput", TChain::Class(), AliAnalysisManager::kInputContainer);
-  mgr->ConnectInput(task, 0, cInput);
-
-  // Attach output
-  cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer);
-  mgr->ConnectOutput(task, 0, cOutput);
-
-  // Enable debug printouts
-  if (aDebug)
-  {
-    mgr->SetDebugLevel(2);
-    AliLog::SetClassDebugLevel("AlidNdEtaCorrectionTask", AliLog::kDebug+2);
-  }
-  else
-    AliLog::SetClassDebugLevel("AlidNdEtaCorrectionTask", AliLog::kWarning);
-
-  // Run analysis
-  mgr->InitAnalysis();
-  mgr->PrintStatus();
-
-  //aProof = kFALSE;
-
-  mgr->StartAnalysis((aProof) ? "proof" : "local", chain);
-}