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 c56c95f2401eb60b7291c2712c21b579acda942f..abdf3f6a6f58741484aab7002974b9a8ada1c14a 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 4a3b4678fc4cca0b17dd04ef602d3ecf99f8c688..2048da79c9ad7ea11d4c9d251a14cd4743c67820 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 bd46e79e2fbee9f075aa4b3119d269a61f116b35..0c3b472938235d33c7775d1aaeb1998b5d461067 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 573ef5a4d0440c18e6180b5a0e66d7e85f8f795f..71fbb0e1d6e42aafc890f2244d092f185d765107 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 3aaf075ff615c61b8c26c9094c751cdaf709d9bb..8799a57f9f3698cb28ccf3d5a726ec82d92c3762 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 c308a483d6b91d8dc873e2ec960ed8376e4a7540..53f50eb366dc472c304bd536185eacf71c85b7fb 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 8edf7ef6b31175563a858439e343337760f4e638..94aee8527c3a375febc671da84faefbccdcf872b 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 118555ba95218e20935c88a5cdf991ebcada2f08..e188a69be9ec667d27472e646187fae17e865634 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 ce581c5a1e9b4a8e80d97b63a3df6c843e0ea287..d967bc918b6133afecf0ff6bbdf372c7148b41bc 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);
-}