o) compiles again :)
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 May 2006 16:41:59 +0000 (16:41 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 May 2006 16:41:59 +0000 (16:41 +0000)
o) moved correction to the end of analysis: results are not consistent! to be checked!
o) added vertex rec eff plots

14 files changed:
PWG0/CorrectionMatrix2D.cxx
PWG0/CorrectionMatrix2D.h
PWG0/PWG0selectorsLinkDef.h
PWG0/dNdEta/AlidNdEtaAnalysisESDSelector.cxx
PWG0/dNdEta/AlidNdEtaAnalysisESDSelector.h
PWG0/dNdEta/AlidNdEtaAnalysisSelector.cxx
PWG0/dNdEta/AlidNdEtaAnalysisSelector.h
PWG0/dNdEta/AlidNdEtaCorrectionSelector.cxx
PWG0/dNdEta/AlidNdEtaCorrectionSelector.h
PWG0/dNdEta/dNdEtaAnalysis.cxx
PWG0/dNdEta/dNdEtaAnalysis.h
PWG0/dNdEta/dNdEtaCorrection.cxx
PWG0/dNdEta/testAnalysis2.C
PWG0/libPWG0selectors.pkg

index fdfdd79..2b1f2cd 100644 (file)
@@ -83,8 +83,8 @@ TH1F* CorrectionMatrix2D::Get1DCorrection(Char_t* opt) {
   // integrate the correction over one variable 
   // 
 
-  TH1D* meas1D; 
-  TH1D* gene1D; 
+  TH1D* meas1D = 0;
+  TH1D* gene1D = 0; 
 
   if (strcmp(opt,"x")==0) {
     meas1D = fhMeas->ProjectionX();
index b78dff6..06ebd25 100644 (file)
@@ -27,7 +27,7 @@ class CorrectionMatrix2D : public TNamed
 {
 public:
   CorrectionMatrix2D(const CorrectionMatrix2D& c);
-  CorrectionMatrix2D(Char_t* name="CorrectionMatrix", Char_t* title="",
+  CorrectionMatrix2D(Char_t* name, Char_t* title,
                     Int_t nBinX=10, Float_t Xmin=0., Float_t Xmax=10.,
                     Int_t nBinY=10, Float_t Ymin=0., Float_t Ymax=10.);
   
index 09e5345..6854d18 100644 (file)
@@ -11,5 +11,6 @@
 #pragma link C++ class AlidNdEtaCorrectionSelector+;
 #pragma link C++ class AlidNdEtaAnalysisMCSelector+;
 #pragma link C++ class AlidNdEtaAnalysisESDSelector+;
+#pragma link C++ class AlidNdEtaVertexRecEffSelector+;
 
 #endif
index 03f140a..e35a86a 100644 (file)
@@ -9,6 +9,8 @@
 #include <TChain.h>
 
 #include <AliLog.h>
+#include <AliESDVertex.h>
+#include <AliESD.h>
 
 #include "esdTrackCuts/AliESDtrackCuts.h"
 #include "dNdEtaCorrection.h"
@@ -18,8 +20,7 @@ ClassImp(AlidNdEtaAnalysisESDSelector)
 
 AlidNdEtaAnalysisESDSelector::AlidNdEtaAnalysisESDSelector() :
   AlidNdEtaAnalysisSelector(),
-  fEsdTrackCuts(0),
-  fdNdEtaCorrection(0)
+  fEsdTrackCuts(0)
 {
   //
   // Constructor. Initialization of pointers
@@ -47,13 +48,13 @@ void AlidNdEtaAnalysisESDSelector::SlaveBegin(TTree * tree)
   if (fChain)
   {
     fEsdTrackCuts = dynamic_cast<AliESDtrackCuts*> (fChain->GetUserInfo()->FindObject("AliESDtrackCuts"));
-    fdNdEtaCorrection = dynamic_cast<dNdEtaCorrection*> (fChain->GetUserInfo()->FindObject("dNdEtaCorrection"));
+    fdNdEtaCorrection = dynamic_cast<dNdEtaCorrection*> (fChain->GetUserInfo()->FindObject("dndeta_correction"));
   }
 
   if (!fEsdTrackCuts)
      AliDebug(AliLog::kError, "ERROR: Could not read EsdTrackCuts from user info.");
 
-  if (!fEsdTrackCuts)
+  if (!fdNdEtaCorrection)
      AliDebug(AliLog::kError, "ERROR: Could not read dNdEtaCorrection from user info.");
 }
 
@@ -93,6 +94,12 @@ Bool_t AlidNdEtaAnalysisESDSelector::Process(Long64_t entry)
     return kFALSE;
   }
 
+  if (!fdNdEtaCorrection)
+  {
+    AliDebug(AliLog::kError, "fdNdEtaCorrection not available");
+    return kFALSE;
+  }
+
   // ########################################################
   // get the EDS vertex
   const AliESDVertex* vtxESD = fESD->GetVertex();
index 56842e5..4caa959 100644 (file)
@@ -6,7 +6,6 @@
 #include "AlidNdEtaAnalysisSelector.h"
 
 class AliESDtrackCuts;
-class dNdEtaCorrection;
 
 class AlidNdEtaAnalysisESDSelector : public AlidNdEtaAnalysisSelector {
   public:
@@ -20,7 +19,6 @@ class AlidNdEtaAnalysisESDSelector : public AlidNdEtaAnalysisSelector {
     virtual void WriteObjects();
 
     AliESDtrackCuts*  fEsdTrackCuts;     // Object containing the parameters of the esd track cuts
-    dNdEtaCorrection* fdNdEtaCorrection; // correction map
 
  private:
 
index d2fe1b6..2d47ae5 100644 (file)
 #include <AliHeader.h>
 
 #include "dNdEtaAnalysis.h"
+#include "dNdEtaCorrection.h"
 
 ClassImp(AlidNdEtaAnalysisSelector)
 
 AlidNdEtaAnalysisSelector::AlidNdEtaAnalysisSelector() :
   AliSelector(),
-  fdNdEtaAnalysis(0)
+  fdNdEtaAnalysis(0),
+  fdNdEtaCorrection(0)
 {
   //
   // Constructor. Initialization of pointers
@@ -82,7 +84,7 @@ void AlidNdEtaAnalysisSelector::Terminate()
     return;
   }
 
-  fdNdEtaAnalysis->Finish();
+  fdNdEtaAnalysis->Finish(fdNdEtaCorrection);
 
   TFile* fout = new TFile("out.root","RECREATE");
   WriteObjects();
index 3bceec6..e70f14b 100644 (file)
@@ -6,6 +6,7 @@
 #include "AliSelector.h"
 
 class dNdEtaAnalysis;
+class dNdEtaCorrection;
 
 class AlidNdEtaAnalysisSelector : public AliSelector {
   public:
@@ -20,6 +21,7 @@ class AlidNdEtaAnalysisSelector : public AliSelector {
     virtual void WriteObjects();
 
     dNdEtaAnalysis* fdNdEtaAnalysis;      // contains the intermediate histograms (on each slave)
+    dNdEtaCorrection* fdNdEtaCorrection;  // correction map
 
  private:
     ClassDef(AlidNdEtaAnalysisSelector, 0);
index 9711205..d90bfef 100644 (file)
 #include <TChain.h>
 #include <TSelector.h>
 
-
 #include <AliLog.h>
 #include <AliGenEventHeader.h>
 #include <AliTracker.h>
 #include <AliHeader.h>
-
+#include <AliESDVertex.h>
+#include <AliESD.h>
+#include <AliESDtrack.h>
 
 #include "esdTrackCuts/AliESDtrackCuts.h"
 #include "dNdEtaCorrection.h"
 
 ClassImp(AlidNdEtaCorrectionSelector)
 
-AlidNdEtaCorrectionSelector::AlidNdEtaCorrectionSelector(TTree *) :
+AlidNdEtaCorrectionSelector::AlidNdEtaCorrectionSelector() :
   AliSelector(),
   fEsdTrackCuts(0),
   fdNdEtaCorrection(0),
@@ -70,21 +71,6 @@ void AlidNdEtaCorrectionSelector::SlaveBegin(TTree * tree)
     AliDebug(AliLog::kError, "ERROR: Could not read EsdTrackCuts from user info");
 }
 
-Bool_t AlidNdEtaCorrectionSelector::Notify()
-{
-  // The Notify() function is called when a new file is opened. This
-  // can be either for a new TTree in a TChain or when when a new TTree
-  // is started when using PROOF. Typically here the branch pointers
-  // will be retrieved. It is normaly not necessary to make changes
-  // to the generated code, but the routine can be extended by the
-  // user if needed.
-
-  if (AliSelector::Notify() == kFALSE)
-    return kFALSE;
-
-  return kTRUE;
-}
-
 Bool_t AlidNdEtaCorrectionSelector::Process(Long64_t entry)
 {
   // The Process() function is called for each entry in the tree (or possibly
index 6b6a288..82c70b9 100644 (file)
@@ -8,25 +8,24 @@
 class AliESDtrackCuts;
 class dNdEtaCorrection;
 
-class TParticle;
-
 class AlidNdEtaCorrectionSelector : public AliSelector {
   public:
-    AlidNdEtaCorrectionSelector(TTree *tree=0);
+    AlidNdEtaCorrectionSelector();
     virtual ~AlidNdEtaCorrectionSelector();
 
     virtual void    Begin(TTree *tree);
     virtual void    SlaveBegin(TTree *tree);
-    virtual Bool_t  Notify();
     virtual Bool_t  Process(Long64_t entry);
     virtual void    SlaveTerminate();
     virtual void    Terminate();
 
  protected:
-  AliESDtrackCuts*  fEsdTrackCuts;          // Object containing the parameters of the esd track cuts
+    Bool_t  CheckVertex();
+  
+    AliESDtrackCuts*  fEsdTrackCuts;          // Object containing the parameters of the esd track cuts
 
-  dNdEtaCorrection* fdNdEtaCorrection;      // contains the intermediate histograms (on each slave)
-  dNdEtaCorrection* fdNdEtaCorrectionFinal; // contains the final histograms
+    dNdEtaCorrection* fdNdEtaCorrection;      // contains the intermediate histograms (on each slave)
+    dNdEtaCorrection* fdNdEtaCorrectionFinal; // contains the final histograms
 
  private:
 
index 31397c9..ed2e1c1 100644 (file)
@@ -10,6 +10,9 @@
 #include <TCollection.h>
 #include <TIterator.h>
 #include <TList.h>
+#include <TLegend.h>
+
+#include "dNdEtaCorrection.h"
 
 //____________________________________________________________________
 ClassImp(dNdEtaAnalysis)
@@ -23,6 +26,7 @@ TNamed(name, title)
   hEtaVsVtx->SetYTitle("#eta");
 
   hEtaVsVtxUncorrected = dynamic_cast<TH2F*> (hEtaVsVtx->Clone(Form("%s_eta_vs_vtx_uncorrected", name)));
+  hEtaVsVtxCheck = dynamic_cast<TH2F*> (hEtaVsVtx->Clone(Form("%s_eta_vs_vtx_check", name)));
   hVtx       = hEtaVsVtx->ProjectionX(Form("%s_vtx", name));
   for (Int_t i=0; i<kVertexBinning; ++i)
   {
@@ -36,9 +40,9 @@ TNamed(name, title)
 
 //____________________________________________________________________
 void
-dNdEtaAnalysis::FillTrack(Float_t vtx, Float_t eta, Float_t weight) {
-  hEtaVsVtx->Fill(vtx, eta, weight);
+dNdEtaAnalysis::FillTrack(Float_t vtx, Float_t eta, Float_t c) {
   hEtaVsVtxUncorrected->Fill(vtx,eta);
+  hEtaVsVtxCheck->Fill(vtx, eta, c);
 }
 
 //____________________________________________________________________
@@ -48,55 +52,101 @@ dNdEtaAnalysis::FillEvent(Float_t vtx) {
 }
 
 //____________________________________________________________________
-void
-dNdEtaAnalysis::Finish() {  
+void dNdEtaAnalysis::Finish(dNdEtaCorrection* correction)
+{
+  // correct with correction values if available
+  // TODO what do we do with the error?
+  if (!correction)
+    printf("INFO: No correction applied\n");
+
+  // this can be replaced by TH2F::Divide if we agree that the binning will be always the same
+  for (Int_t iVtx=0; iVtx<=hEtaVsVtxUncorrected->GetNbinsX(); iVtx++)
+  {
+    for (Int_t iEta=0; iEta<=hEtaVsVtxUncorrected->GetNbinsY(); iEta++)
+    {
+      Float_t correctionValue = 1;
+      if (correction)
+        correctionValue = correction->GetCorrection(hEtaVsVtxUncorrected->GetXaxis()->GetBinCenter(iVtx), hEtaVsVtxUncorrected->GetYaxis()->GetBinCenter(iEta));
+
+      Float_t value = hEtaVsVtxUncorrected->GetBinContent(iVtx, iEta);
+      Float_t error = hEtaVsVtxUncorrected->GetBinError(iVtx, iEta);
+
+      Float_t correctedValue = value * correctionValue;
+      Float_t correctedError = error * correctionValue;
+
+      if (correctedValue != 0)
+      {
+        hEtaVsVtx->SetBinContent(iVtx, iEta, correctedValue);
+        hEtaVsVtx->SetBinError(iVtx, iEta, correctedError);
+      }
+    }
+  }
+
+  // normalize with n events (per vtx)
+  for (Int_t iVtx=0; iVtx<=hVtx->GetNbinsX(); iVtx++) {
+    Float_t nEvents      = hVtx->GetBinContent(iVtx);
+    Float_t nEventsError = hVtx->GetBinError(iVtx);
 
-  // first normalize with n events (per vtx)
-  for (Int_t i_vtx=0; i_vtx<=hVtx->GetNbinsX(); i_vtx++) {
-    Float_t nEvents      = hVtx->GetBinContent(i_vtx);
-    Float_t nEventsError = hVtx->GetBinError(i_vtx);
-    
     if (nEvents==0) continue;
-    
-    for (Int_t i_eta=0; i_eta<=hEtaVsVtx->GetNbinsY(); i_eta++) {
-      Float_t value = hEtaVsVtx->GetBinContent(i_vtx, i_eta)/nEvents;
+
+    for (Int_t iEta=0; iEta<=hEtaVsVtx->GetNbinsY(); iEta++) {
+      Float_t value = hEtaVsVtx->GetBinContent(iVtx, iEta) / nEvents;
+      if (value==0) continue;
+      Float_t error = hEtaVsVtx->GetBinError(iVtx, iEta)/nEvents;
+      error = TMath::Sqrt(TMath::Power(hEtaVsVtx->GetBinError(iVtx, iEta)/
+                                      hEtaVsVtx->GetBinContent(iVtx, iEta),2) +
+                         TMath::Power(nEventsError/nEvents,2));
+      hEtaVsVtx->SetBinContent(iVtx, iEta, value);
+      hEtaVsVtx->SetBinError(iVtx,   iEta, error);
+    }
+
+    //debug
+    for (Int_t iEta=0; iEta<=hEtaVsVtxCheck->GetNbinsY(); iEta++) {
+      Float_t value = hEtaVsVtxCheck->GetBinContent(iVtx, iEta) / nEvents;
       if (value==0) continue;
-      Float_t error = hEtaVsVtx->GetBinError(i_vtx, i_eta)/nEvents;
-      error = TMath::Sqrt(TMath::Power(hEtaVsVtx->GetBinError(i_vtx, i_eta)/
-                                      hEtaVsVtx->GetBinContent(i_vtx, i_eta),2) +
+      Float_t error = hEtaVsVtxCheck->GetBinError(iVtx, iEta)/nEvents;
+      error = TMath::Sqrt(TMath::Power(hEtaVsVtxCheck->GetBinError(iVtx, iEta)/
+                                      hEtaVsVtxCheck->GetBinContent(iVtx, iEta),2) +
                          TMath::Power(nEventsError/nEvents,2));
-      hEtaVsVtx->SetBinContent(i_vtx, i_eta, value);
-      hEtaVsVtx->SetBinError(i_vtx,   i_eta, error);
+      hEtaVsVtxCheck->SetBinContent(iVtx, iEta, value);
+      hEtaVsVtxCheck->SetBinError(iVtx,   iEta, error);
     }
   }
 
   // then take the wieghted average for each eta
   // is this the right way to do it???
-  for (Int_t i_eta=0; i_eta<=hEtaVsVtx->GetNbinsY(); i_eta++) {
+  for (Int_t iEta=0; iEta<=hEtaVsVtx->GetNbinsY(); iEta++) {
     Float_t sum           = 0;
     Float_t sumError2     = 0;
     Int_t   nMeasurements = 0;    
 
-    Float_t sum_xw = 0;
-    Float_t sum_w  = 0;
+    Float_t sumXw = 0;
+    Float_t sumW  = 0;
     
     // do we have several histograms for different vertex positions?
-    Int_t vertexBinWidth = hVtx->GetNbinsX() / kVertexBinning;
+    Int_t vertexBinWidth = hVtx->GetNbinsX() / (kVertexBinning-1);
     for (Int_t vertexPos=0; vertexPos<kVertexBinning; ++vertexPos)
     {
-      Int_t vertexBinBegin = vertexBinWidth * vertexPos;
-      Int_t vertexBinEnd = vertexBinBegin + vertexBinWidth;
+      Int_t vertexBinBegin = 0;
+      Int_t vertexBinEnd = hVtx->GetNbinsX();
+
+      // the first histogram is always for the whole vertex range
+      if (vertexPos > 0)
+      {
+        vertexBinBegin = vertexBinWidth * (vertexPos-1);
+        vertexBinEnd = vertexBinBegin + vertexBinWidth;
+      }
 
-      for (Int_t i_vtx=vertexBinBegin; i_vtx<=vertexBinEnd; i_vtx++) {
-        if (hVtx->GetBinContent(i_vtx)==0)             continue;
-        if (hEtaVsVtx->GetBinContent(i_vtx, i_eta)==0) continue;
+      for (Int_t iVtx=vertexBinBegin; iVtx<=vertexBinEnd; iVtx++) {
+        if (hVtx->GetBinContent(iVtx)==0)             continue;
+        if (hEtaVsVtx->GetBinContent(iVtx, iEta)==0) continue;
 
-        Float_t w = 1/TMath::Power(hEtaVsVtx->GetBinError(i_vtx, i_eta),2);
-        sum_xw = sum_xw + hEtaVsVtx->GetBinContent(i_vtx, i_eta)*w;
-        sum_w  = sum_w + w;
+        Float_t w = 1/TMath::Power(hEtaVsVtx->GetBinError(iVtx, iEta),2);
+        sumXw = sumXw + hEtaVsVtx->GetBinContent(iVtx, iEta)*w;
+        sumW  = sumW + w;
 
-        sum = sum + hEtaVsVtx->GetBinContent(i_vtx, i_eta);
-        sumError2 = sumError2 + TMath::Power(hEtaVsVtx->GetBinError(i_vtx, i_eta),2);      
+        sum = sum + hEtaVsVtx->GetBinContent(iVtx, iEta);
+        sumError2 = sumError2 + TMath::Power(hEtaVsVtx->GetBinError(iVtx, iEta),2);      
         nMeasurements++;
       }
       Float_t dndeta = 0;
@@ -106,17 +156,16 @@ dNdEtaAnalysis::Finish() {
         dndeta = sum/Float_t(nMeasurements);
         error  = TMath::Sqrt(sumError2)/Float_t(nMeasurements);
 
-        dndeta = sum_xw/sum_w;
-        error  = 1/TMath::Sqrt(sum_w);
+        dndeta = sumXw/sumW;
+        error  = 1/TMath::Sqrt(sumW);
 
-        dndeta = dndeta/hdNdEta[vertexPos]->GetBinWidth(i_eta);
-        error  = error/hdNdEta[vertexPos]->GetBinWidth(i_eta);
+        dndeta = dndeta/hdNdEta[vertexPos]->GetBinWidth(iEta);
+        error  = error/hdNdEta[vertexPos]->GetBinWidth(iEta);
 
-        hdNdEta[vertexPos]->SetBinContent(i_eta, dndeta);
-        hdNdEta[vertexPos]->SetBinError(i_eta, error);
+        hdNdEta[vertexPos]->SetBinContent(iEta, dndeta);
+        hdNdEta[vertexPos]->SetBinError(iEta, error);
       }
     }
-
   }
 }
 
@@ -128,6 +177,7 @@ dNdEtaAnalysis::SaveHistograms() {
   gDirectory->cd(GetName());
   
   hEtaVsVtx  ->Write();
+  hEtaVsVtxUncorrected->Write();
   hVtx       ->Write();
   for (Int_t i=0; i<kVertexBinning; ++i)
     hdNdEta[i]    ->Write();
@@ -146,16 +196,46 @@ void dNdEtaAnalysis::DrawHistograms()
     hEtaVsVtx->Draw("COLZ");
 
   canvas->cd(2);
+  if (hEtaVsVtxCheck)
+    hEtaVsVtxCheck->Draw("COLZ");
+
+  canvas->cd(3);
   if (hEtaVsVtxUncorrected)
     hEtaVsVtxUncorrected->Draw("COLZ");
 
-  canvas->cd(3);
+  /*canvas->cd(3);
   if (hVtx)
-    hVtx->Draw();
+    hVtx->Draw();*/
 
   canvas->cd(4);
   if (hdNdEta[0])
     hdNdEta[0]->Draw();
+
+    // histograms for different vertices?
+  if (kVertexBinning > 0)
+  {
+      // doesnt work, but i dont get it, giving up...
+    /*TCanvas* canvas2 =*/ new TCanvas("dNdEtaAnalysisVtx", "dNdEtaAnalysisVtx", 450, 450);
+    //Int_t yPads = (Int_t) TMath::Ceil(((Double_t) kVertexBinning - 1) / 2);
+    //printf("%d\n", yPads);
+    //canvas2->Divide(2, yPads);
+
+    TLegend* legend = new TLegend(0.7, 0.7, 0.9, 0.9);
+
+    for (Int_t i=1; i<kVertexBinning; ++i)
+    {
+      //canvas2->cd(i-1);
+      //printf("%d\n", i);
+      if (hdNdEta[i])
+      {
+        hdNdEta[i]->SetLineColor(i);
+        hdNdEta[i]->Draw((i == 1) ? "" : "SAME");
+        legend->AddEntry(hdNdEta[i], Form("Vtx Bin %d", i-1));
+      }
+    }
+
+    legend->Draw();
+  }
 }
 
 Long64_t dNdEtaAnalysis::Merge(TCollection* list)
index bc93ad6..754f797 100644 (file)
 class TH2F;
 class TH1D;
 class TCollection;
+class dNdEtaCorrection;
 
 class dNdEtaAnalysis : public TNamed
 {
 public:
-  enum { kVertexBinning = 1 };
+  enum { kVertexBinning = 1+6 }; // the first is for the whole vertex range, the others divide the vertex range
 
   dNdEtaAnalysis(Char_t* name, Char_t* title);
 
-  void FillTrack(Float_t vtx, Float_t eta, Float_t weight);
+  void FillTrack(Float_t vtx, Float_t eta, Float_t c);
   void FillEvent(Float_t vtx);
 
-  void Finish();
+  void Finish(dNdEtaCorrection* correction);
 
   void DrawHistograms();
   void SaveHistograms();
@@ -48,6 +49,7 @@ public:
 
 protected:
   TH2F* hEtaVsVtx;
+  TH2F* hEtaVsVtxCheck;
   TH2F* hEtaVsVtxUncorrected;
   TH1D* hVtx;
   TH1D* hdNdEta[kVertexBinning];
index 44c3185..fd9783a 100644 (file)
@@ -14,8 +14,8 @@ dNdEtaCorrection::dNdEtaCorrection(Char_t* name)
   // constructor
   //
 
-  fNtrackToNparticleCorrection = new CorrectionMatrix2D("nTrackToNPart","",80,-20,20,120,-6,6);
-  fEventBiasCorrection         = new CorrectionMatrix2D("EventBias",    "",80,-20,20,120,-6,6);
+  fNtrackToNparticleCorrection = new CorrectionMatrix2D("nTrackToNPart", "nTrackToNPart",80,-20,20,120,-6,6);
+  fEventBiasCorrection         = new CorrectionMatrix2D("EventBias",    "EventBias ",80,-20,20,120,-6,6);
 
   fNtrackToNparticleCorrection ->SetAxisTitles("vtx z [cm]", "#eta");
   fEventBiasCorrection         ->SetAxisTitles("vtx z [cm]", "#eta");
index 151ff9d..3f19677 100644 (file)
@@ -10,7 +10,7 @@
 
 #include "../CreateESDChain.C"
 
-testAnalysis2(Char_t* dataDir, Int_t nRuns=20, Int_t offset=0, Bool_t aMC = kFALSE)
+testAnalysis2(Char_t* dataDir, Int_t nRuns=20, Int_t offset=0, Bool_t aMC = kFALSE, Bool_t aDebug = kFALSE)
 {
   gSystem->Load("libPWG0base");
 
@@ -41,13 +41,16 @@ testAnalysis2(Char_t* dataDir, Int_t nRuns=20, Int_t offset=0, Bool_t aMC = kFAL
   }
 
   TString selectorName = ((aMC == kFALSE) ? "AlidNdEtaAnalysisESDSelector" : "AlidNdEtaAnalysisMCSelector");
-
   AliLog::SetClassDebugLevel(selectorName, AliLog::kInfo);
 
+  selectorName += ".cxx++";
+  if (aDebug != kFALSE)
+    selectorName += "g";
+
   TStopwatch timer;
   timer.Start();
 
-  chain->Process(selectorName + ".cxx+");
+  chain->Process(selectorName);
 
   timer.Stop();
   timer.Print();
index 32eda39..eecd960 100644 (file)
@@ -5,7 +5,8 @@
 
 HDRS = dNdEta/AlidNdEtaCorrectionSelector.h \
        dNdEta/AlidNdEtaAnalysisMCSelector.h \
-       dNdEta/AlidNdEtaAnalysisESDSelector.h
+       dNdEta/AlidNdEtaAnalysisESDSelector.h \
+       dNdEta/AlidNdEtaVertexRecEffSelector.h 
 
 SRCS = $(HDRS:.h=.cxx)