o) adding log tags to all files
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 26 May 2006 14:48:32 +0000 (14:48 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 26 May 2006 14:48:32 +0000 (14:48 +0000)
o) AliSelector: Changing the way the header is accessed: Before it was a tree friend, this results in mismatch as soon as one ESD file is corrupt. Now it is accessed similar to the method used for the kinematics tree.
o) Adding second library PWG0selectors, this is only for the build system, because selectors are compiled on-the-fly when they are used in the Process function
o) Analysis now splitted in AnalysisESDSelector and AnalysisMCSelector

31 files changed:
PWG0/AliSelector.cxx
PWG0/AliSelector.h
PWG0/AliSelectorRL.cxx
PWG0/AliSelectorRL.h
PWG0/CorrectionMatrix2D.cxx
PWG0/CorrectionMatrix2D.h
PWG0/CreateESDChain.C
PWG0/Makefile
PWG0/PWG0baseLinkDef.h
PWG0/PWG0selectorsLinkDef.h [new file with mode: 0644]
PWG0/dNdEta/AlidNdEtaAnalysisESDSelector.cxx [new file with mode: 0644]
PWG0/dNdEta/AlidNdEtaAnalysisESDSelector.h [new file with mode: 0644]
PWG0/dNdEta/AlidNdEtaAnalysisMCSelector.cxx
PWG0/dNdEta/AlidNdEtaAnalysisMCSelector.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/dNdEtaCorrection.h
PWG0/dNdEta/drawCorrection.C
PWG0/dNdEta/makeCorrection2.C
PWG0/dNdEta/testAnalysis2.C
PWG0/esdTrackCuts/AliESDtrackCuts.cxx
PWG0/esdTrackCuts/AliESDtrackCuts.h
PWG0/esdTrackCuts/testESDtrackCuts.C
PWG0/libPWG0base.pkg
PWG0/libPWG0selectors.pkg [new file with mode: 0644]
PWG0/ptSpectra/makeCorrectionPtEta.C

index 12d390d3fc2638d65bb003804a55f3107f341ee1..ba7dec0ab2a481487f42ecf1e52c7935ddb52d57 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 // The class definition in esdV0.h has been generated automatically
 // by the ROOT utility TTree::MakeSelector(). This class is derived
 // from the ROOT class TSelector. For more information on the TSelector
@@ -31,6 +33,7 @@
 #include <TTime.h>
 #include <TParticle.h>
 #include <TParticlePDG.h>
+#include <TFriendElement.h>
 
 #include <AliLog.h>
 
@@ -40,8 +43,11 @@ AliSelector::AliSelector() :
   TSelector(),
   fChain(0),
   fESD(0),
-  fHeader(0),
-  fKineFile(0)
+  fCountFiles(0),
+  fKineFile(0),
+  fHeaderFile(0),
+  fHeaderTree(0),
+  fHeader(0)
 {
   //
   // Constructor. Initialization of pointers
@@ -76,8 +82,6 @@ void AliSelector::SlaveBegin(TTree * tree)
   AliDebug(AliLog::kDebug, "=======SLAVEBEGIN========");
   AliDebug(AliLog::kDebug, Form("Hostname: %s", gSystem->HostName()));
   AliDebug(AliLog::kDebug, Form("Time: %s", gSystem->Now().AsString()));
-  TFile *f = fChain->GetCurrentFile();
-  AliDebug(AliLog::kDebug, f->GetName());
 
   TString option = GetOption();
 }
@@ -110,9 +114,9 @@ void AliSelector::Init(TTree *tree)
   if (fESD != 0)
     AliDebug(AliLog::kInfo, "INFO: Found ESD branch in chain.");
 
-  fChain->SetBranchAddress("Header", &fHeader);
+  /*fChain->SetBranchAddress("Header", &fHeader);
   if (fHeader != 0)
-    AliDebug(AliLog::kInfo, "INFO: Found event header branch in chain.");
+    AliDebug(AliLog::kInfo, "INFO: Found event header branch in chain.");*/
 }
 
 Bool_t AliSelector::Notify()
@@ -128,10 +132,15 @@ Bool_t AliSelector::Notify()
   AliDebug(AliLog::kDebug, Form("Hostname: %s", gSystem->HostName()));
   AliDebug(AliLog::kDebug, Form("Time: %s", gSystem->Now().AsString()));
 
+  ++fCountFiles;
   TFile *f = fChain->GetCurrentFile();
-  AliDebug(AliLog::kInfo, Form("Processing file %s", f->GetName()));
+  AliDebug(AliLog::kInfo, Form("Processing %d. file %s", fCountFiles, f->GetName()));
 
   DeleteKinematicsFile();
+  DeleteHeaderFile();
+
+  /*TChain* headerChain = dynamic_cast<TChain*> (((TFriendElement*) fChain->GetListOfFriends()->First())->GetTree());
+  AliDebug(AliLog::kInfo, Form("Header File: %s", headerChain->GetCurrentFile()->GetName()));*/
 
   return kTRUE;
 }
@@ -166,6 +175,8 @@ Bool_t AliSelector::Process(Long64_t entry)
 
   fChain->GetTree()->GetEntry(entry);
 
+  /*
+  // debugging
   if (fESD)
     AliDebug(AliLog::kDebug, Form("ESD: We have %d tracks.", fESD->GetNumberOfTracks()));
 
@@ -175,6 +186,7 @@ Bool_t AliSelector::Process(Long64_t entry)
   TTree* kinematics = GetKinematics();
   if (kinematics)
     AliDebug(AliLog::kDebug, Form("Kinematics: We have %lld particles.", kinematics->GetEntries()));
+  */
 
   return kTRUE;
 }
@@ -186,6 +198,7 @@ void AliSelector::SlaveTerminate()
   // on each slave server.
 
   DeleteKinematicsFile();
+  DeleteHeaderFile();
 }
 
 void AliSelector::Terminate()
@@ -211,6 +224,8 @@ TTree* AliSelector::GetKinematics()
     TString fileName(fChain->GetCurrentFile()->GetName());
     fileName.ReplaceAll("AliESDs", "Kinematics");
 
+    AliDebug(AliLog::kInfo, Form("Opening %s", fileName.Data()));
+
     fKineFile = TFile::Open(fileName);
     if (!fKineFile)
       return 0;
@@ -266,6 +281,53 @@ void AliSelector::DeleteKinematicsFile()
   }
 }
 
+AliHeader* AliSelector::GetHeader()
+{
+  // Returns header corresponding to current ESD active in fChain
+  // Loads the header from galice.root, the file is identified by replacing "AliESDs" to
+  // "galice" in the file path of the ESD file. This is a hack, to be changed!
+
+  if (!fHeaderFile || !fHeaderTree)
+  {
+    if (!fChain->GetCurrentFile())
+      return 0;
+
+    TString fileName(fChain->GetCurrentFile()->GetName());
+    fileName.ReplaceAll("AliESDs", "galice");
+
+    AliDebug(AliLog::kInfo, Form("Opening %s", fileName.Data()));
+
+    fHeaderFile = TFile::Open(fileName);
+    if (!fHeaderFile)
+      return 0;
+
+    fHeaderTree = dynamic_cast<TTree*> (fHeaderFile->Get("TE"));
+    if (!fHeaderTree)
+      return 0;
+
+    fHeaderTree->SetBranchAddress("Header", &fHeader);
+  }
+
+  fHeaderTree->GetEntry(fChain->GetTree()->GetReadEntry());
+
+  return fHeader;
+}
+
+void AliSelector::DeleteHeaderFile()
+{
+  //
+  // Closes the kinematics file and deletes the pointer.
+  //
+
+  if (fHeaderFile)
+  {
+    fHeaderFile->Close();
+    delete fHeaderFile;
+    fHeaderTree = 0;
+    fHeader = 0;
+  }
+}
+
 Bool_t AliSelector::IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries) const
 {
   //
@@ -275,13 +337,19 @@ Bool_t AliSelector::IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries
 
   // if the particle has a daughter primary, we do not want to count it
   if (aParticle->GetFirstDaughter() != -1 && aParticle->GetFirstDaughter() < aTotalPrimaries)
+  {
+    AliDebug(AliLog::kDebug+1, "Dropping particle because it has a daughter among the primaries.");
     return kFALSE;
+  }
 
   Int_t pdgCode = TMath::Abs(aParticle->GetPdgCode());
 
   // skip quarks and gluon
   if (pdgCode <= 10 || pdgCode == 21)
+  {
+    AliDebug(AliLog::kDebug+1, "Dropping particle because it is a quark or gluon.");
     return kFALSE;
+  }
 
   if (strcmp(aParticle->GetName(),"XXX") == 0)
   {
@@ -298,7 +366,10 @@ Bool_t AliSelector::IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries
   }
 
   if (pdgPart->Charge() == 0)
+  {
     return kFALSE;
+    AliDebug(AliLog::kDebug+1, "Dropping particle because it is not charged.");
+  }
 
   return kTRUE;
 }
index 4a8c16ac23a0c381023935fa1ab39b7fe10879df..3150b4d9fd52e87adc8a929f706dc571ced2c034 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #ifndef ALISELECTOR_H
 #define ALISELECTOR_H
 
@@ -28,17 +30,24 @@ class AliSelector : public TSelector {
 
  protected:
     TTree*  GetKinematics();
+    AliHeader* GetHeader();
     Bool_t IsPrimaryCharged(TParticle* aParticle, Int_t aTotalPrimaries) const;
 
     TChain          *fChain;   //! pointer to the analyzed TTree or TChain
 
     AliESD*          fESD;     //! "ESD" branch in fChain
-    AliHeader*       fHeader;  //! "TE" branch in fChain, contains event header
+
+    Int_t fCountFiles;         // Nr. of current file
 
  private:
     void DeleteKinematicsFile();
+    void DeleteHeaderFile();
+
+    TFile*        fKineFile;   //! pointer to Kinematics.root if the file was opened
 
-    TFile*        fKineFile;  //! pointer to Kinematics.root if the file was opened
+    TFile*        fHeaderFile; //! pointer to galice.root, if the file was opened
+    TTree*        fHeaderTree; //!
+    AliHeader*    fHeader;     //!
 
   ClassDef(AliSelector,0);
 };
index 7384fd7c16bef8b872bfebe3f9d70196eb4c3346..845eec36b454f70324c2b0755540c550a61b9d31 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #include "AliSelectorRL.h"
 
 #include <AliLog.h>
index ae0e252946f80e82433f436528f16dc5862d3a2e..c774290db00292818e40101af7cd35b90141045d 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #ifndef ALISELECTORRL_H
 #define ALISELECTORRL_H
 
index ce1745042414a05193bfa29570db241094450a09..74b5cbcb5eaf11627ca8e29d3874edc7213e5ac3 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #include "CorrectionMatrix2D.h"
 
 //____________________________________________________________________
index 96cc060894cdac810c0e5274dcc12c1d22aee6e9..28ea819b47edd8bf4bda111a730593d821f59bde 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #ifndef CORRECTIONMATRIX2D_H
 #define CORRECTIONMATRIX2D_H
 
index 0524dc1b39fdd6f5f47f958d56e75899b19faf4e..f25e1531281dc31d69f5484761a6f29e7f8168f5 100644 (file)
@@ -1,5 +1,16 @@
-TChain* CreateESDChainFromDir(const char* aDataDir, Int_t aRuns = 20, Bool_t aAddHeader = kTRUE)
+/* $Id$ */
+
+// Helper macros for creating chains
+
+TChain* CreateESDChainFromDir(const char* aDataDir, Int_t aRuns = 20, Int_t offset = 0, Bool_t aAddHeader = kTRUE)
 {
+  // creates chain of files in a given directory. The structure is expected as:
+  // <aDataDir>/<dir0>/AliESDs.root
+  // <aDataDir>/<dir0>/galice.root (when <aAddHeader> flag is set)
+  // <aDataDir>/<dir1>/AliESDs.root
+  // <aDataDir>/<dir1>/galice.root (when <aAddHeader> flag is set)
+  // ...
+
   if (!aDataDir)
     return 0;
 
@@ -23,6 +34,12 @@ TChain* CreateESDChainFromDir(const char* aDataDir, Int_t aRuns = 20, Bool_t aAd
     if (!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0)
       continue;
 
+    if (offset > 0)
+    {
+      --offset;
+      continue;
+    }
+
     if (count++ == aRuns)
       break;
 
@@ -44,6 +61,10 @@ TChain* CreateESDChainFromDir(const char* aDataDir, Int_t aRuns = 20, Bool_t aAd
 
 TChain* CreateESDChainFromList(const char* listFile, Int_t aRuns = 20, Bool_t aAddHeader = kTRUE)
 {
+  // Creates a chain from a file which contains a list of ESD files
+  // if <aAddHeader> is set, the filename of the galice.root file is created by replacing
+  // AliESDs to galice in the esd file name
+
   if (!listFile)
     return 0;
 
index 6fcfbf249326c2212069daff4695602dda8e9b22..3700a1a2b7ed5471b534805c4158b4675490a2ea 100644 (file)
@@ -1,3 +1,5 @@
+# $Id$
+
 PACKAGE = PWG0base
 
 include $(ROOTSYS)/test/Makefile.arch
index dec411b15e27a8bf6a5411df14d51c9b739db12f..26ff721ba58711aacba101e1206bbb8fd321d7ac 100644 (file)
@@ -11,9 +11,7 @@
 #pragma link C++ class AliSelector+;
 #pragma link C++ class AliSelectorRL+;
 
-#pragma link C++ class AlidNdEtaCorrectionSelector+;
 #pragma link C++ class AlidNdEtaAnalysisSelector+;
-#pragma link C++ class AlidNdEtaAnalysisMCSelector+;
 #pragma link C++ class dNdEtaAnalysis+;
 #pragma link C++ class dNdEtaCorrection+;
 
diff --git a/PWG0/PWG0selectorsLinkDef.h b/PWG0/PWG0selectorsLinkDef.h
new file mode 100644 (file)
index 0000000..09e5345
--- /dev/null
@@ -0,0 +1,15 @@
+#ifdef __CINT__
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class AlidNdEtaCorrectionSelector+;
+#pragma link C++ class AlidNdEtaAnalysisMCSelector+;
+#pragma link C++ class AlidNdEtaAnalysisESDSelector+;
+
+#endif
diff --git a/PWG0/dNdEta/AlidNdEtaAnalysisESDSelector.cxx b/PWG0/dNdEta/AlidNdEtaAnalysisESDSelector.cxx
new file mode 100644 (file)
index 0000000..0a32b3f
--- /dev/null
@@ -0,0 +1,160 @@
+/* $Id$ */
+
+#include "AlidNdEtaAnalysisESDSelector.h"
+
+#include <TStyle.h>
+#include <TSystem.h>
+#include <TCanvas.h>
+#include <TVector3.h>
+
+#include <AliLog.h>
+#include <AliGenEventHeader.h>
+
+#include "esdTrackCuts/AliESDtrackCuts.h"
+#include "dNdEtaCorrection.h"
+#include "dNdEtaAnalysis.h"
+
+ClassImp(AlidNdEtaAnalysisESDSelector)
+
+AlidNdEtaAnalysisESDSelector::AlidNdEtaAnalysisESDSelector() :
+  AlidNdEtaAnalysisSelector(),
+  fEsdTrackCuts(0),
+  fdNdEtaCorrection(0)
+{
+  //
+  // Constructor. Initialization of pointers
+  //
+}
+
+AlidNdEtaAnalysisESDSelector::~AlidNdEtaAnalysisESDSelector()
+{
+  //
+  // Destructor
+  //
+
+  // histograms are in the output list and deleted when the output
+  // list is deleted by the TSelector dtor
+}
+
+void AlidNdEtaAnalysisESDSelector::SlaveBegin(TTree * tree)
+{
+  // The SlaveBegin() function is called after the Begin() function.
+  // When running with PROOF SlaveBegin() is called on each slave server.
+  // The tree argument is deprecated (on PROOF 0 is passed).
+
+  AlidNdEtaAnalysisSelector::SlaveBegin(tree);
+
+  if (fChain)
+  {
+    fEsdTrackCuts = dynamic_cast<AliESDtrackCuts*> (fChain->GetUserInfo()->FindObject("AliESDtrackCuts"));
+    fdNdEtaCorrection = dynamic_cast<dNdEtaCorrection*> (fChain->GetUserInfo()->FindObject("dNdEtaCorrection"));
+  }
+
+  if (!fEsdTrackCuts)
+     AliDebug(AliLog::kError, "ERROR: Could not read EsdTrackCuts from user info.");
+
+  if (!fEsdTrackCuts)
+     AliDebug(AliLog::kError, "ERROR: Could not read dNdEtaCorrection from user info.");
+}
+
+Bool_t AlidNdEtaAnalysisESDSelector::Process(Long64_t entry)
+{
+  // The Process() function is called for each entry in the tree (or possibly
+  // keyed object in the case of PROOF) to be processed. The entry argument
+  // specifies which entry in the currently loaded tree is to be processed.
+  // It can be passed to either TTree::GetEntry() or TBranch::GetEntry()
+  // to read either all or the required parts of the data. When processing
+  // keyed objects with PROOF, the object is already loaded and is available
+  // via the fObject pointer.
+  //
+  // This function should contain the "body" of the analysis. It can contain
+  // simple or elaborate selection criteria, run algorithms on the data
+  // of the event and typically fill histograms.
+
+  // WARNING when a selector is used with a TChain, you must use
+  //  the pointer to the current TTree to call GetEntry(entry).
+  //  The entry is always the local entry number in the current tree.
+  //  Assuming that fChain is the pointer to the TChain being processed,
+  //  use fChain->GetTree()->GetEntry(entry).
+
+  if (AlidNdEtaAnalysisSelector::Process(entry) == kFALSE)
+    return kFALSE;
+
+  // Check prerequisites
+  if (!fESD)
+  {
+    AliDebug(AliLog::kError, "ESD branch not available");
+    return kFALSE;
+  }
+
+  if (!fEsdTrackCuts)
+  {
+    AliDebug(AliLog::kError, "fESDTrackCuts not available");
+    return kFALSE;
+  }
+
+  // ########################################################
+  // get the EDS vertex
+  const AliESDVertex* vtxESD = fESD->GetVertex();
+
+  // the vertex should be reconstructed
+  if (strcmp(vtxESD->GetName(),"default")==0)
+    return kTRUE;
+
+  Double_t vtx_res[3];
+  vtx_res[0] = vtxESD->GetXRes();
+  vtx_res[1] = vtxESD->GetYRes();
+  vtx_res[2] = vtxESD->GetZRes();
+
+  // the resolution should be reasonable???
+  if (vtx_res[2]==0 || vtx_res[2]>0.1)
+    return kTRUE;
+
+  Double_t vtx[3];
+  vtxESD->GetXYZ(vtx);
+
+  // ########################################################
+  // loop over esd tracks
+  Int_t nTracks = fESD->GetNumberOfTracks();
+  for (Int_t t=0; t<nTracks; t++)
+  {
+    AliESDtrack* esdTrack = fESD->GetTrack(t);
+    if (!esdTrack)
+    {
+      AliDebug(AliLog::kError, Form("ERROR: Could not retrieve track %d.", t));
+      continue;
+    }
+
+    // cut the esd track?
+    if (!fEsdTrackCuts->AcceptTrack(esdTrack))
+      continue;
+
+    Double_t p[3];
+    esdTrack->GetConstrainedPxPyPz(p); // ### TODO or GetInnerPxPyPy / GetOuterPxPyPy
+    TVector3 vector(p);
+
+    Float_t theta = vector.Theta();
+    Float_t eta   = -TMath::Log(TMath::Tan(theta/2.));
+
+    Float_t correction = fdNdEtaCorrection->GetCorrection(vtx[2], eta);
+
+    fdNdEtaAnalysis->FillTrack(vtx[2], eta, correction);
+
+  } // end of track loop
+
+  // for event count per vertex
+  fdNdEtaAnalysis->FillEvent(vtx[2]);
+
+  return kTRUE;
+}
+
+void AlidNdEtaAnalysisESDSelector::WriteObjects()
+{
+  AlidNdEtaAnalysisSelector::WriteObjects();
+
+  if (fEsdTrackCuts)
+    fEsdTrackCuts->SaveHistograms("esd_tracks_cuts");
+
+  if (fdNdEtaCorrection)
+    fdNdEtaCorrection->SaveHistograms();
+}
diff --git a/PWG0/dNdEta/AlidNdEtaAnalysisESDSelector.h b/PWG0/dNdEta/AlidNdEtaAnalysisESDSelector.h
new file mode 100644 (file)
index 0000000..56842e5
--- /dev/null
@@ -0,0 +1,30 @@
+/* $Id$ */
+
+#ifndef ALIDNDETAANALYSISESDSELECTOR_H
+#define ALIDNDETAANALYSISESDSELECTOR_H
+
+#include "AlidNdEtaAnalysisSelector.h"
+
+class AliESDtrackCuts;
+class dNdEtaCorrection;
+
+class AlidNdEtaAnalysisESDSelector : public AlidNdEtaAnalysisSelector {
+  public:
+    AlidNdEtaAnalysisESDSelector();
+    virtual ~AlidNdEtaAnalysisESDSelector();
+
+    virtual void    SlaveBegin(TTree *tree);
+    virtual Bool_t  Process(Long64_t entry);
+
+ protected:
+    virtual void WriteObjects();
+
+    AliESDtrackCuts*  fEsdTrackCuts;     // Object containing the parameters of the esd track cuts
+    dNdEtaCorrection* fdNdEtaCorrection; // correction map
+
+ private:
+
+  ClassDef(AlidNdEtaAnalysisESDSelector, 0);
+};
+
+#endif
index f2241a696ed081db549c1be21f5575466883b4e3..f74e1a85f64042472b2300315e176f88dc9b2cee 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #include "AlidNdEtaAnalysisMCSelector.h"
 
 #include <TStyle.h>
@@ -6,16 +8,19 @@
 #include <TParticle.h>
 #include <TParticlePDG.h>
 #include <TVector3.h>
+#include <TH3F.h>
 
 #include <AliLog.h>
 #include <AliGenEventHeader.h>
 
 #include "dNdEtaAnalysis.h"
 
+
 ClassImp(AlidNdEtaAnalysisMCSelector)
 
-AlidNdEtaAnalysisMCSelector::AlidNdEtaAnalysisMCSelector(TTree * tree) :
-  AlidNdEtaAnalysisSelector(tree)
+AlidNdEtaAnalysisMCSelector::AlidNdEtaAnalysisMCSelector() :
+  AlidNdEtaAnalysisSelector(),
+  fVertex(0)
 {
   //
   // Constructor. Initialization of pointers
@@ -34,6 +39,8 @@ void AlidNdEtaAnalysisMCSelector::Init(TTree *tree)
    AlidNdEtaAnalysisSelector::Init(tree);
 
   tree->SetBranchStatus("ESD", 0);
+
+  fVertex = new TH3F("vertex", "vertex", 50, -50, 50, 50, -50, 50, 50, -50, 50);
 }
 
 Bool_t AlidNdEtaAnalysisMCSelector::Process(Long64_t entry)
@@ -44,11 +51,21 @@ Bool_t AlidNdEtaAnalysisMCSelector::Process(Long64_t entry)
     return kFALSE;
 
   TTree* particleTree = GetKinematics();
-  if (!fHeader || !particleTree)
+  if (!particleTree)
+  {
+    AliDebug(AliLog::kError, "Kinematics not available");
     return kFALSE;
+  }
+
+  AliHeader* header = GetHeader();
+  if (!header)
+  {
+    AliDebug(AliLog::kError, "Header not available");
+    return kFALSE;
+  }
 
   // get the MC vertex
-  AliGenEventHeader* genHeader = fHeader->GenEventHeader();
+  AliGenEventHeader* genHeader = header->GenEventHeader();
 
   TArrayF vtxMC(3);
   genHeader->PrimaryVertex(vtxMC);
@@ -59,12 +76,15 @@ Bool_t AlidNdEtaAnalysisMCSelector::Process(Long64_t entry)
   particleTree->SetBranchStatus("fPx", 1);
   particleTree->SetBranchStatus("fPy", 1);
   particleTree->SetBranchStatus("fPz", 1);
-  
+  particleTree->SetBranchStatus("fVx", 1);
+  particleTree->SetBranchStatus("fVy", 1);
+  particleTree->SetBranchStatus("fVz", 1);
+
   TParticle* particle = 0;
   particleTree->SetBranchAddress("Particles", &particle);
 
-  Int_t nPrim  = fHeader->GetNprimary();
-  Int_t nTotal = fHeader->GetNtrack();
+  Int_t nPrim  = header->GetNprimary();
+  Int_t nTotal = header->GetNtrack();
 
   for (Int_t i_mc = nTotal - nPrim; i_mc < nTotal; ++i_mc)
   {
@@ -76,9 +96,20 @@ Bool_t AlidNdEtaAnalysisMCSelector::Process(Long64_t entry)
     if (IsPrimaryCharged(particle, nPrim) == kFALSE)
       continue;
 
+    AliDebug(AliLog::kDebug+1, Form("Accepted primary %d, unique ID: %d", i_mc, particle->GetUniqueID()));
+
     fdNdEtaAnalysis->FillTrack(vtxMC[2], particle->Eta(), 1);
+    fVertex->Fill(particle->Vx(), particle->Vy(), particle->Vz());
   }
   fdNdEtaAnalysis->FillEvent(vtxMC[2]);
 
   return kTRUE;
 }
+
+void AlidNdEtaAnalysisMCSelector::Terminate()
+{
+  AlidNdEtaAnalysisSelector::Terminate();
+
+  new TCanvas;
+  fVertex->Draw();
+}
index ca1a0d09608949d7f3cafac5234c21524fdae141..4f54eb8d77add1547ee502b2a7dbfe5bff1c1588 100644 (file)
@@ -1,19 +1,25 @@
+/* $Id$ */
+
 #ifndef ALIDNDETAANALYSISSELECTORMC_H
 #define ALIDNDETAANALYSISSELECTORMC_H
 
 #include "AlidNdEtaAnalysisSelector.h"
 
+class TH3F;
+
 class AlidNdEtaAnalysisMCSelector : public AlidNdEtaAnalysisSelector {
   public:
-    AlidNdEtaAnalysisMCSelector(TTree *tree=0);
+    AlidNdEtaAnalysisMCSelector();
     virtual ~AlidNdEtaAnalysisMCSelector();
 
     virtual void    Init(TTree *tree);
     virtual Bool_t  Process(Long64_t entry);
+    virtual void    Terminate();
 
  protected:
 
  private:
+  TH3F* fVertex;
 
   ClassDef(AlidNdEtaAnalysisMCSelector, 0);
 };
index 75076d08fa0ca8f39c811db52affa0045cd488ee..26e2a6ea9cf34d68bcf9adfeade836f519a64505 100644 (file)
@@ -1,24 +1,23 @@
+/* $Id$ */
+
 #include "AlidNdEtaAnalysisSelector.h"
 
 #include <TStyle.h>
 #include <TSystem.h>
 #include <TCanvas.h>
 #include <TVector3.h>
+#include <TH2F.h>
 
 #include <AliLog.h>
 #include <AliGenEventHeader.h>
 
-#include "esdTrackCuts/AliESDtrackCuts.h"
-#include "dNdEtaCorrection.h"
 #include "dNdEtaAnalysis.h"
 
 ClassImp(AlidNdEtaAnalysisSelector)
 
-AlidNdEtaAnalysisSelector::AlidNdEtaAnalysisSelector(TTree *) :
+AlidNdEtaAnalysisSelector::AlidNdEtaAnalysisSelector() :
   AliSelector(),
-  fEsdTrackCuts(0),
   fdNdEtaAnalysis(0),
-  fdNdEtaCorrection(0),
   fdNdEtaAnalysisFinal(0)
 {
   //
@@ -45,102 +44,6 @@ void AlidNdEtaAnalysisSelector::SlaveBegin(TTree * tree)
   AliSelector::SlaveBegin(tree);
 
   fdNdEtaAnalysis = new dNdEtaAnalysis("dndeta");
-
-  if (fChain)
-  {
-    fEsdTrackCuts = dynamic_cast<AliESDtrackCuts*> (fChain->GetUserInfo()->FindObject("AliESDtrackCuts"));
-    fdNdEtaCorrection = dynamic_cast<dNdEtaCorrection*> (fChain->GetUserInfo()->FindObject("dNdEtaCorrection"));
-  }
-
-  if (!fEsdTrackCuts)
-     AliDebug(AliLog::kError, "ERROR: Could not read EsdTrackCuts from user info.");
-
-  if (!fEsdTrackCuts)
-     AliDebug(AliLog::kWarning, "ERROR: Could not read dNdEtaCorrection from user info.");
-
-  AliLog::SetClassDebugLevel("AliESDtrackCuts", 1);
-}
-
-Bool_t AlidNdEtaAnalysisSelector::Process(Long64_t entry)
-{
-  // The Process() function is called for each entry in the tree (or possibly
-  // keyed object in the case of PROOF) to be processed. The entry argument
-  // specifies which entry in the currently loaded tree is to be processed.
-  // It can be passed to either TTree::GetEntry() or TBranch::GetEntry()
-  // to read either all or the required parts of the data. When processing
-  // keyed objects with PROOF, the object is already loaded and is available
-  // via the fObject pointer.
-  //
-  // This function should contain the "body" of the analysis. It can contain
-  // simple or elaborate selection criteria, run algorithms on the data
-  // of the event and typically fill histograms.
-
-  // WARNING when a selector is used with a TChain, you must use
-  //  the pointer to the current TTree to call GetEntry(entry).
-  //  The entry is always the local entry number in the current tree.
-  //  Assuming that fChain is the pointer to the TChain being processed,
-  //  use fChain->GetTree()->GetEntry(entry).
-
-  if (AliSelector::Process(entry) == kFALSE)
-    return kFALSE;
-
-  // Check prerequisites
-  if (!fESD || !fEsdTrackCuts)
-    return kFALSE;
-
-  // ########################################################
-  // get the EDS vertex
-  const AliESDVertex* vtxESD = fESD->GetVertex();
-
-  // the vertex should be reconstructed
-  if (strcmp(vtxESD->GetName(),"default")==0)
-    return kTRUE;
-
-  Double_t vtx_res[3];
-  vtx_res[0] = vtxESD->GetXRes();
-  vtx_res[1] = vtxESD->GetYRes();
-  vtx_res[2] = vtxESD->GetZRes();
-
-  // the resolution should be reasonable???
-  if (vtx_res[2]==0 || vtx_res[2]>0.1)
-    return kTRUE;
-
-  Double_t vtx[3];
-  vtxESD->GetXYZ(vtx);
-
-  // ########################################################
-  // loop over esd tracks
-  Int_t nTracks = fESD->GetNumberOfTracks();
-  for (Int_t t=0; t<nTracks; t++)
-  {
-    AliESDtrack* esdTrack = fESD->GetTrack(t);
-    if (!esdTrack)
-    {
-      AliDebug(AliLog::kError, Form("ERROR: Could not retrieve track %d.", t));
-      continue;
-    }
-
-    // cut the esd track?
-    if (!fEsdTrackCuts->AcceptTrack(esdTrack))
-      continue;
-
-    Double_t p[3];
-    esdTrack->GetConstrainedPxPyPz(p); // ### TODO or GetInnerPxPyPy / GetOuterPxPyPy
-    TVector3 vector(p);
-
-    Float_t theta = vector.Theta();
-    Float_t eta   = -TMath::Log(TMath::Tan(theta/2.));
-
-    Float_t correction = fdNdEtaCorrection->GetCorrection(vtx[2], eta);
-
-    fdNdEtaAnalysis->FillTrack(vtx[2], eta, correction);
-
-  } // end of track loop
-
-  // for event count per vertex
-  fdNdEtaAnalysis->FillEvent(vtx[2]);
-
-  return kTRUE;
 }
 
 void AlidNdEtaAnalysisSelector::SlaveTerminate()
@@ -193,17 +96,18 @@ void AlidNdEtaAnalysisSelector::Terminate()
   fdNdEtaAnalysisFinal->Finish();
 
   TFile* fout = new TFile("out.root","RECREATE");
-
-  if (fEsdTrackCuts)
-    fEsdTrackCuts->SaveHistograms("esd_tracks_cuts");
-
-  if (fdNdEtaCorrection)
-    fdNdEtaCorrection->SaveHistograms();
-
-  fdNdEtaAnalysisFinal->SaveHistograms();
-
+  WriteObjects();
   fout->Write();
   fout->Close();
 
   fdNdEtaAnalysisFinal->DrawHistograms();
 }
+
+void AlidNdEtaAnalysisSelector::WriteObjects()
+{
+  // Write objects to output file
+  // this is an extra function to be overloaded...
+  //
+
+  fdNdEtaAnalysisFinal->SaveHistograms();
+}
index 52d3afd173e551b2dab93a8d16b79edc98b85e18..552ba3a54e87e170f3a26abfdbba3b0a33067a9d 100644 (file)
@@ -1,33 +1,29 @@
+/* $Id$ */
+
 #ifndef ALIDNDETAANALYSISSELECTOR_H
 #define ALIDNDETAANALYSISSELECTOR_H
 
 #include "AliSelector.h"
 
-class AliESDtrackCuts;
-class dNdEtaCorrection;
 class dNdEtaAnalysis;
 
 class AlidNdEtaAnalysisSelector : public AliSelector {
   public:
-    AlidNdEtaAnalysisSelector(TTree *tree=0);
+    AlidNdEtaAnalysisSelector();
     virtual ~AlidNdEtaAnalysisSelector();
 
     virtual void    SlaveBegin(TTree *tree);
-    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
-
-  dNdEtaAnalysis* fdNdEtaAnalysis;      // contains the intermediate histograms (on each slave)
+    virtual void WriteObjects();
 
-  dNdEtaCorrection* fdNdEtaCorrection; // correction map
-  dNdEtaAnalysis* fdNdEtaAnalysisFinal; // contains the final histograms
+    dNdEtaAnalysis* fdNdEtaAnalysis;      // contains the intermediate histograms (on each slave)
+    dNdEtaAnalysis* fdNdEtaAnalysisFinal; // contains the final histograms
 
  private:
-
-  ClassDef(AlidNdEtaAnalysisSelector, 0);
+    ClassDef(AlidNdEtaAnalysisSelector, 0);
 };
 
 #endif
index 373f4ffa05f923b275f07ea2ef978b819ea670fe..f415d6c09a905f2211d9a102331452de9d947b7f 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #include "AlidNdEtaCorrectionSelector.h"
 
 #include <TStyle.h>
@@ -107,9 +109,10 @@ Bool_t AlidNdEtaCorrectionSelector::Process(Long64_t entry)
     return kFALSE;
   }
 
-  if (!fHeader)
+  AliHeader* header = GetHeader();
+  if (!header)
   {
-    AliDebug(AliLog::kError, "Header branch not available");
+    AliDebug(AliLog::kError, "Header not available");
     return kFALSE;
   }
 
@@ -138,7 +141,7 @@ Bool_t AlidNdEtaCorrectionSelector::Process(Long64_t entry)
 
   // ########################################################
   // get the MC vertex
-  AliGenEventHeader* genHeader = fHeader->GenEventHeader();
+  AliGenEventHeader* genHeader = header->GenEventHeader();
 
   TArrayF vtxMC(3);
   genHeader->PrimaryVertex(vtxMC);
@@ -149,8 +152,8 @@ Bool_t AlidNdEtaCorrectionSelector::Process(Long64_t entry)
   TParticle* particle = 0;
   particleTree->SetBranchAddress("Particles", &particle);
 
-  Int_t nPrim  = fHeader->GetNprimary();
-  Int_t nTotal = fHeader->GetNtrack();
+  Int_t nPrim  = header->GetNprimary();
+  Int_t nTotal = header->GetNtrack();
 
   for (Int_t i_mc = nTotal - nPrim; i_mc < nTotal; ++i_mc)
   {
index 11f608650811f695afc462fafa2847ffd16f96f9..6b6a28888d8a3c1a8325e1f7d9d18b4dc321b324 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #ifndef ALIDNDETACORRECTIONSELECTOR_H
 #define ALIDNDETACORRECTIONSELECTOR_H
 
index 3d0590a550d8e3547026a18168533a277a864a84..ae704487101dbacd3f5aa7a1b3d108dbec312f3f 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #include "dNdEtaAnalysis.h"
 
 #include <TFile.h>
index aeff7068ce51ef6a5d68adcc88738b78bfaf0f18..86783f4549157715d127ee0bd5597a62c6b8a57e 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #ifndef DNDETANALYSIS_H
 #define DNDETANALYSIS_H
 
index 0ddaf6f37c844ec7fb03fa7bb091c57bbb29e442..d3dcd14ca02493a584f4f16abad7b0bfef06fd5c 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #include "dNdEtaCorrection.h"
 
 #include <TCanvas.h>
@@ -55,14 +57,14 @@ dNdEtaCorrection::Finish() {
 void
 dNdEtaCorrection::RemoveEdges(Float_t cut, Int_t nBinsVtx, Int_t nBinsEta) {
 
-  // remove edges of correction histogram by removing 
-  // - bins with content less than cut
+  // remove edges of correction histogram by removing
+  // - bins with content bigger than cut
   // - bins next to bins with zero bin content
-  
+
   Int_t nBinsX = hEtaVsVtx_corr->GetNbinsX();
   Int_t nBinsY = hEtaVsVtx_corr->GetNbinsY();
 
-  // set bin content to zero for bins with content smaller cut
+  // set bin content to zero for bins with content bigger than cut
   for (Int_t bx=0; bx<=nBinsX; bx++) {
     for (Int_t by=0; by<=nBinsY; by++) {
       if (hEtaVsVtx_corr->GetBinContent(bx,by)>cut) {
@@ -75,28 +77,28 @@ dNdEtaCorrection::RemoveEdges(Float_t cut, Int_t nBinsVtx, Int_t nBinsEta) {
   // set bin content to zero for bins next to bins with zero
   TH2F* tmp = (TH2F*)hEtaVsVtx_corr->Clone("tmp");
   tmp->Reset();
-  
+
   Bool_t done = kFALSE;
   Int_t nBinsVtxCount = 0;
   Int_t nBinsEtaCount = 0;
-  while (!done) {    
-    if (nBinsVtxCount<nBinsVtx) 
+  while (!done) {
+    if (nBinsVtxCount<nBinsVtx)
       for (Int_t bx=0; bx<=nBinsX; bx++) {
        for (Int_t by=0; by<=nBinsY; by++) {
-         if ((hEtaVsVtx_corr->GetBinContent(bx+1,by)==0)|| 
+         if ((hEtaVsVtx_corr->GetBinContent(bx+1,by)==0)||
              (hEtaVsVtx_corr->GetBinContent(bx-1,by)==0))
-           tmp->SetBinContent(bx,by,1);        
-         
+           tmp->SetBinContent(bx,by,1);
+
        }
       }
-    if (nBinsEtaCount<nBinsEta) 
+    if (nBinsEtaCount<nBinsEta)
       for (Int_t bx=0; bx<=nBinsX; bx++) {
        for (Int_t by=0; by<=nBinsY; by++) {
-         if ((hEtaVsVtx_corr->GetBinContent(bx,by+1)==0)|| 
+         if ((hEtaVsVtx_corr->GetBinContent(bx,by+1)==0)||
              (hEtaVsVtx_corr->GetBinContent(bx,by-1)==0))
-           tmp->SetBinContent(bx,by,1);        
+           tmp->SetBinContent(bx,by,1);
        }
-      }    
+      }
     for (Int_t bx=0; bx<=nBinsX; bx++) {
       for (Int_t by=0; by<=nBinsY; by++) {
        if (tmp->GetBinContent(bx,by)==1) {
@@ -109,7 +111,7 @@ dNdEtaCorrection::RemoveEdges(Float_t cut, Int_t nBinsVtx, Int_t nBinsEta) {
     nBinsEtaCount++;
     if ((nBinsVtxCount>=nBinsVtx)&&(nBinsEtaCount>=nBinsEta)) done=kTRUE;
   }
-  tmp->Delete();  
+  tmp->Delete();
 
 }
 
index ccf7e7f1b2c4ce861e7badd14f3d5e27c23d3c0c..7a3ceb0f15b445685605f8afbf9ea33542967cb4 100644 (file)
@@ -1,6 +1,9 @@
+/* $Id$ */
+
 #ifndef DNDETACORRECTION_H
 #define DNDETACORRECTION_H
 
+
 // ------------------------------------------------------
 //
 // Class to handle corrections for dN/dEta measurements
index e151d02021417960c6cddfc80f0fc6720d005472..4a819bc52d0b33b8e6ead3b051c520d6f1a424b5 100644 (file)
@@ -1,7 +1,9 @@
+/* $Id$ */
+
 void drawCorrection()
 {
-  gSystem->Load("libdNdEta.so");
-  
+  gSystem->Load("libPWG0base");
+
   dNdEtaCorrection* dNdEtaMap = new dNdEtaCorrection();
   dNdEtaMap->LoadCorrection("correction_map.root");
   
index 9fdc840834bc3b0b77a306b389ad61e707bdfe37..f134856b8a7edbaaf4f355caa06acbc2a9db59b8 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 //
 // Script to make correction maps for dndeta measurements using the
 // dNdEtaCorrection class.
@@ -7,12 +9,11 @@
 
 #include "../CreateESDChain.C"
 
-void makeCorrection2(Char_t* dataDir, Int_t nRuns=20)
+void makeCorrection2(Char_t* dataDir, Int_t nRuns=20, Int_t offset = 0)
 {
   gSystem->Load("libPWG0base");
-  gSystem->SetIncludePath("-I$ALICE_ROOT/PWG0");
 
-  TChain* chain = CreateESDChainFromDir(dataDir, nRuns);
+  TChain* chain = CreateESDChainFromDir(dataDir, nRuns, offset, kFALSE);
 
   fEsdTrackCuts = new AliESDtrackCuts();
   fEsdTrackCuts->DefineHistograms(1);
index a01a379dd2ca627303b5ef49a5fa9c4079af97b6..e7928b1e5f9178e86e59eb8021dfe954ac244a07 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 //
 // Script to test the dN/dEta analysis using the dNdEtaAnalysis and
 // dNdEtaCorrection classes. Note that there is a cut on the events,
 
 #include "../CreateESDChain.C"
 
-testAnalysis2(Char_t* dataDir, Int_t nRuns=20, Bool_t aMC = kFALSE)
+testAnalysis2(Char_t* dataDir, Int_t nRuns=20, Int_t offset=0, Bool_t aMC = kFALSE)
 {
   gSystem->Load("libPWG0base");
-  gSystem->SetIncludePath("-I$ALICE_ROOT/PWG0");
 
-  TChain* chain = CreateESDChainFromDir(dataDir, nRuns);
+  TChain* chain = CreateESDChainFromDir(dataDir, nRuns, offset, kFALSE);
 
   // ########################################################
   // selection of esd tracks
@@ -34,12 +35,12 @@ testAnalysis2(Char_t* dataDir, Int_t nRuns=20, Bool_t aMC = kFALSE)
   {
     dNdEtaCorrection* dNdEtaCorrection = new dNdEtaCorrection();
     dNdEtaCorrection->LoadHistograms("correction_map.root","dndeta_correction");
-    dNdEtaCorrection->RemoveEdges(2,0,2);
+    dNdEtaCorrection->RemoveEdges(2, 0, 2);
 
     chain->GetUserInfo()->Add(dNdEtaCorrection);
   }
 
-  TString selectorName = ((aMC == kFALSE) ? "AlidNdEtaAnalysisSelector" : "AlidNdEtaAnalysisMCSelector");
+  TString selectorName = ((aMC == kFALSE) ? "AlidNdEtaAnalysisESDSelector" : "AlidNdEtaAnalysisMCSelector");
 
   AliLog::SetClassDebugLevel(selectorName, AliLog::kInfo);
 
index 6fa20577f1829ed458341534fd02a29c1a325fbb..eba881f8fc6b06200b5f201cf24b68ceecd73e61 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #include "AliESDtrackCuts.h"
 
 #include <Riostream.h>
@@ -282,7 +284,7 @@ AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) {
   // 
   Float_t nSigmaToVertex = -1;
   if (bRes[0]!=0 && bRes[1]!=0)
-    nSigmaToVertex = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));  
+    nSigmaToVertex = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
 
   // getting the kinematic variables of the track 
   // (assuming the mass is known)
index e5bdc03d4af538319889160f269e224198f806e2..5f62c925e49c0caedeebba35d907284827cd2dfe 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 #ifndef ALIESDTRACKCUTS_H
 #define ALIESDTRACKCUTS_H
 
index 7c35b809dbb43e1653e44fb67cbd898b242e21d7..decbd45bdf4782bab13aae8d36819bdde7da74dd 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 testESDtrackCuts(Char_t* dataDir=, Int_t nRuns=10) {
 
   Char_t str[256];
index 0bc6f7e8de3eb64ca45595223d86e92b81163293..155d8d40455dd314424c2bd83eb764a61707c2cd 100644 (file)
@@ -1,8 +1,8 @@
+# $Id$
+
 HDRS = AliSelector.h \
        AliSelectorRL.h \
-      dNdEta/AlidNdEtaCorrectionSelector.h \
       dNdEta/AlidNdEtaAnalysisSelector.h \
-      dNdEta/AlidNdEtaAnalysisMCSelector.h \
       dNdEta/dNdEtaAnalysis.h \
       dNdEta/dNdEtaCorrection.h \
       esdTrackCuts/AliESDtrackCuts.h \
@@ -10,10 +10,6 @@ HDRS = AliSelector.h \
 
 SRCS = $(HDRS:.h=.cxx)
 
-#PARBLACKLIST = dNdEta/AlidNdEtaCorrectionSelector.h \
-#      dNdEta/AlidNdEtaAnalysisSelector.h \
-#      dNdEta/AlidNdEtaAnalysisMCSelector.h
-
 DHDR= PWG0baseLinkDef.h
 
 EINCLUDE=
diff --git a/PWG0/libPWG0selectors.pkg b/PWG0/libPWG0selectors.pkg
new file mode 100644 (file)
index 0000000..32eda39
--- /dev/null
@@ -0,0 +1,14 @@
+# $Id$
+
+# this library contains the selectors, which are loaded on the fly when one uses a given selector
+# thus this library is never used, it just exists for the build system to check if everything compiles
+
+HDRS = dNdEta/AlidNdEtaCorrectionSelector.h \
+       dNdEta/AlidNdEtaAnalysisMCSelector.h \
+       dNdEta/AlidNdEtaAnalysisESDSelector.h
+
+SRCS = $(HDRS:.h=.cxx)
+
+DHDR= PWG0selectorsLinkDef.h
+
+EINCLUDE=
index 644c73c9da14b870b4f66e6c5cc8da8691bc75a6..37b05b3f0ad8bd78b032ccc1a263847e557c582d 100644 (file)
@@ -1,3 +1,5 @@
+/* $Id$ */
+
 //
 // Script to calculate PtvsEta correction map using the CorrectionMatrix2D class.
 //