Added selector to check esd track cuts.
authorekman <ekman@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 6 Sep 2006 09:30:49 +0000 (09:30 +0000)
committerekman <ekman@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 6 Sep 2006 09:30:49 +0000 (09:30 +0000)
Made AliESDtrackCuts inherit from TNamed (needed to identify the objects in the input list (PROOF)).
Changed testESDtrackCuts to use the selector

PWG0/esdTrackCuts/AliESDtrackCuts.cxx
PWG0/esdTrackCuts/AliESDtrackCuts.h
PWG0/esdTrackCuts/AliTestESDtrackCutsSelector.cxx [new file with mode: 0644]
PWG0/esdTrackCuts/AliTestESDtrackCutsSelector.h [new file with mode: 0644]
PWG0/esdTrackCuts/testESDtrackCuts.C

index 38b03f576f522ce316dec7f12a14f76e978c44ae..1d38ce394aa0165899e901695b7109d1f1a3e390 100644 (file)
@@ -35,7 +35,7 @@ const Char_t* AliESDtrackCuts::fgkCutNames[kNCuts] = {
 };
 
 //____________________________________________________________________
-AliESDtrackCuts::AliESDtrackCuts() : TObject(),
+AliESDtrackCuts::AliESDtrackCuts(Char_t* name) : TNamed(name,name),
   fCutMinNClusterTPC(0),
   fCutMinNClusterITS(0),
   fCutMaxChi2PerClusterTPC(0),
@@ -98,7 +98,7 @@ AliESDtrackCuts::AliESDtrackCuts() : TObject(),
 }
 
 //_____________________________________________________________________________
-AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : TObject(c),
+AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : TNamed(c),
   fCutMinNClusterTPC(0),
   fCutMinNClusterITS(0),
   fCutMaxChi2PerClusterTPC(0),
index 789c343cfbe102bf6d6070fcd7cd3f31410afc2a..53c70afe801aedead42b8b6b544ddc06ee73512a 100644 (file)
@@ -24,7 +24,7 @@
 #ifndef ALIESDTRACKCUTS_H
 #define ALIESDTRACKCUTS_H
 
-#include <TObject.h>
+#include <TNamed.h>
 #include <TH2.h>
 
 class AliESD;
@@ -32,11 +32,11 @@ class AliESDtrack;
 class AliLog;
 class TTree;
 
-class AliESDtrackCuts : public TObject 
+class AliESDtrackCuts : public TNamed 
 {
 
 public:
-  AliESDtrackCuts();
+  AliESDtrackCuts(Char_t* name="AliESDtrackCuts");
   virtual ~AliESDtrackCuts();
 
   Bool_t AcceptTrack(AliESDtrack* esdTrack);
diff --git a/PWG0/esdTrackCuts/AliTestESDtrackCutsSelector.cxx b/PWG0/esdTrackCuts/AliTestESDtrackCutsSelector.cxx
new file mode 100644 (file)
index 0000000..7ec5ea5
--- /dev/null
@@ -0,0 +1,206 @@
+/* $Id$ */
+
+#include "AliTestESDtrackCutsSelector.h"
+
+#include <TStyle.h>
+#include <TSystem.h>
+#include <TCanvas.h>
+#include <TParticle.h>
+#include <TParticlePDG.h>
+#include <TVector3.h>
+#include <TChain.h>
+#include <TFile.h>
+#include <TH1F.h>
+
+#include <TSelector.h>
+#include <TFile.h>
+
+#include <AliLog.h>
+#include <AliESD.h>
+#include <AliRunLoader.h>
+#include <AliStack.h>
+
+#include "esdTrackCuts/AliESDtrackCuts.h"
+#include "AliPWG0Helper.h"
+
+
+ClassImp(AliTestESDtrackCutsSelector)
+
+AliTestESDtrackCutsSelector::AliTestESDtrackCutsSelector() :
+  AliSelectorRL(),
+  fEsdTrackCutsAll(0),
+  fEsdTrackCutsPri(0),
+  fEsdTrackCutsSec(0)
+{
+  //
+  // Constructor. Initialization of pointers
+  //
+}
+
+AliTestESDtrackCutsSelector::~AliTestESDtrackCutsSelector()
+{
+  //
+  // Destructor
+  //
+
+  // histograms are in the output list and deleted when the output
+  // list is deleted by the TSelector dtor
+}
+
+void AliTestESDtrackCutsSelector::Begin(TTree* tree)
+{
+  // Begin function
+
+  AliSelectorRL::Begin(tree);
+
+  ReadUserObjects(tree);
+}
+
+void AliTestESDtrackCutsSelector::ReadUserObjects(TTree* tree)
+{
+  // read the user objects, called from slavebegin and begin
+
+  if (!fEsdTrackCutsAll && fInput)
+    fEsdTrackCutsAll = dynamic_cast<AliESDtrackCuts*> (fInput->FindObject("esdTrackCutsAll"));
+  if (!fEsdTrackCutsPri && fInput)
+    fEsdTrackCutsPri = dynamic_cast<AliESDtrackCuts*> (fInput->FindObject("esdTrackCutsPri"));
+  if (!fEsdTrackCutsSec && fInput)
+    fEsdTrackCutsSec = dynamic_cast<AliESDtrackCuts*> (fInput->FindObject("esdTrackCutsSec"));
+
+  if (!fEsdTrackCutsAll && tree)
+    fEsdTrackCutsAll = dynamic_cast<AliESDtrackCuts*> (tree->GetUserInfo()->FindObject("esdTrackCutsAll"));
+  if (!fEsdTrackCutsPri && tree)
+    fEsdTrackCutsPri = dynamic_cast<AliESDtrackCuts*> (tree->GetUserInfo()->FindObject("esdTrackCutsPri"));
+  if (!fEsdTrackCutsSec && tree)
+    fEsdTrackCutsSec = dynamic_cast<AliESDtrackCuts*> (tree->GetUserInfo()->FindObject("esdTrackCutsSec"));
+
+  if (!fEsdTrackCutsAll || !fEsdTrackCutsPri || !fEsdTrackCutsSec)
+     AliDebug(AliLog::kError, "ERROR: Could not read esdTrackCutsXXX from input list.");
+}
+
+void AliTestESDtrackCutsSelector::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).
+
+  AliSelectorRL::SlaveBegin(tree);
+
+  ReadUserObjects(tree);
+}
+
+Bool_t AliTestESDtrackCutsSelector::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 fTree is the pointer to the TChain being processed,
+  //  use fTree->GetTree()->GetEntry(entry).
+
+  if (AliSelectorRL::Process(entry) == kFALSE)
+    return kFALSE;
+
+  // Check prerequisites
+  if (!fESD) {
+    AliDebug(AliLog::kError, "ESD branch not available");
+    return kFALSE;
+  }  
+
+  if (!AliPWG0Helper::IsVertexReconstructed(fESD)) {
+    AliDebug(AliLog::kDebug+5, "Vertex is not reconstructed");
+    return kFALSE;
+  }
+
+  // check if the esd track cut objects are there
+  if (!fEsdTrackCutsAll || !fEsdTrackCutsPri || !fEsdTrackCutsSec) {
+    AliDebug(AliLog::kError, "fEsdTrackCutsXXX not available");
+    return kFALSE;
+  }
+
+  // get particle stack
+  AliStack* stack = GetStack();
+  if (!stack) {
+    AliDebug(AliLog::kError, "Stack not available");
+    return kFALSE;
+  }
+  Int_t nPrim  = stack->GetNprimary();
+  
+  // ########################################################
+  // loop over esd tracks
+  Int_t nTracks = fESD->GetNumberOfTracks();
+
+  // count the number of "good" tracks as parameter for vertex reconstruction efficiency
+  for (Int_t t=0; t<nTracks; t++) {
+    AliDebug(AliLog::kDebug+1, Form("ESD Loop: Processing track %d.", t));
+
+    AliESDtrack* esdTrack = fESD->GetTrack(t);
+
+    fEsdTrackCutsAll->AcceptTrack(esdTrack);
+
+    // using the properties of the mc particle
+    Int_t label = TMath::Abs(esdTrack->GetLabel());
+    if (label == 0) {
+      AliDebug(AliLog::kWarning, Form("WARNING: cannot find corresponding mc part for track %d.", t));
+      continue;
+    }
+    TParticle* particle = stack->Particle(label);
+    if (!particle) {
+      AliDebug(AliLog::kError, Form("UNEXPECTED: part with label %d not found in stack (track loop).", label));
+      continue;
+    }
+    if (AliPWG0Helper::IsPrimaryCharged(particle, nPrim) == kFALSE)
+      fEsdTrackCutsPri->AcceptTrack(esdTrack);
+    else
+      fEsdTrackCutsSec->AcceptTrack(esdTrack);
+  }
+  
+  return kTRUE;
+}
+
+void AliTestESDtrackCutsSelector::SlaveTerminate()
+{
+  // The SlaveTerminate() function is called after all entries or objects
+  // have been processed. When running with PROOF SlaveTerminate() is called
+  // on each slave server.
+
+  AliSelectorRL::SlaveTerminate();
+  
+  // Add the histograms to the output on each slave server
+  if (!fOutput)
+  {
+    AliDebug(AliLog::kError, Form("ERROR: Output list not initialized."));
+    return;
+  }
+
+  fOutput->Add(fEsdTrackCutsAll);
+  fOutput->Add(fEsdTrackCutsPri);
+  fOutput->Add(fEsdTrackCutsSec);
+}
+
+void AliTestESDtrackCutsSelector::Terminate()
+{
+  // The Terminate() function is the last function to be called during
+  // a query. It always runs on the client, it can be used to present
+  // the results graphically or save the results to file.
+
+  AliSelectorRL::Terminate();
+
+  TFile* file = TFile::Open("trackCuts.root", "RECREATE");
+  fEsdTrackCutsAll->SaveHistograms("esdTrackCutsAll");
+  fEsdTrackCutsPri->SaveHistograms("esdTrackCutsPri");
+  fEsdTrackCutsSec->SaveHistograms("esdTrackCutsSec");
+
+  file->Close();
+}
diff --git a/PWG0/esdTrackCuts/AliTestESDtrackCutsSelector.h b/PWG0/esdTrackCuts/AliTestESDtrackCutsSelector.h
new file mode 100644 (file)
index 0000000..c54f672
--- /dev/null
@@ -0,0 +1,35 @@
+/* $Id$ */
+
+#ifndef ALIMULTIPLICITYESDSELECTOR_H
+#define ALIMULTIPLICITYESDSELECTOR_H
+
+#include "AliSelectorRL.h"
+
+class AliESDtrackCuts;
+
+class AliTestESDtrackCutsSelector : public AliSelectorRL {
+  public:
+    AliTestESDtrackCutsSelector();
+    virtual ~AliTestESDtrackCutsSelector();
+
+    virtual void    Begin(TTree* tree);
+    virtual void    SlaveBegin(TTree *tree);
+    virtual Bool_t  Process(Long64_t entry);
+    virtual void    SlaveTerminate();
+    virtual void    Terminate();
+
+ protected:
+    void ReadUserObjects(TTree* tree);
+
+    AliESDtrackCuts*  fEsdTrackCutsAll;  // esd track cuts for all tracks   
+    AliESDtrackCuts*  fEsdTrackCutsPri;  // cuts for tracks from primary particles 
+    AliESDtrackCuts*  fEsdTrackCutsSec;  // cuts for tracks from secondary particles 
+
+ private:
+    AliTestESDtrackCutsSelector(const AliTestESDtrackCutsSelector&);
+    AliTestESDtrackCutsSelector& operator=(const AliTestESDtrackCutsSelector&);
+
+  ClassDef(AliTestESDtrackCutsSelector, 0);
+};
+
+#endif
index 6df62709326bbd04a7721fcbcfe4f07e755b394b..1ac70343c03b27c9918ace5b4e99811d3c02cb7f 100644 (file)
 /* $Id$ */
 
-testESDtrackCuts(Char_t* dataDir=, Int_t nRuns=10) {
-
-  Char_t str[256];
-
-  gSystem->Load("libPWG0base.so");
-
-  // ########################################################
-  // definition of ESD track cuts
-
-  AliESDtrackCuts* trackCuts = new AliESDtrackCuts();
-  trackCuts->DefineHistograms(4);
-
-  trackCuts->SetMinNClustersTPC(50);
-  trackCuts->SetMaxChi2PerClusterTPC(3.5);
-  trackCuts->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
-  trackCuts->SetRequireTPCRefit(kTRUE);
-
-  trackCuts->SetMinNsigmaToVertex(3);
-  trackCuts->SetAcceptKingDaughters(kFALSE);
-
-  trackCuts->SetPRange(0.3);
-
-  AliLog::SetClassDebugLevel("AliESDtrackCuts",1);
-
-  // ########################################################
-  // definition of used pointers
-  TFile* esdFile;
-  TTree* esdTree;
-  TBranch* esdBranch;
-
-  AliESD* esd = 0;
-
-  // ########################################################
-  // get the data dir  
-  Char_t execDir[256];
-  sprintf(execDir,gSystem->pwd());
-  TSystemDirectory* baseDir = new TSystemDirectory(".",dataDir);
-  TList* dirList            = baseDir->GetListOfFiles();
-  Int_t nDirs               = dirList->GetEntries();
-  // go back to the dir where this script is executed
-  gSystem->cd(execDir);
-  
-  // ########################################################
-  // loop over runs
-  Int_t nRunCounter = 0;
-  for (Int_t r=1; r<=nDirs; r++) {
-
-    TSystemFile* presentDir = (TSystemFile*)dirList->At(r);
-    if (!presentDir->IsDirectory())
-      continue;
-    // first check that the files are there
-    sprintf(str,"%s/%s",dataDir, presentDir->GetName());
-    if ((!gSystem->Which(str,"galice.root")) ||
-        (!gSystem->Which(str,"AliESDs.root"))) 
-      continue;
-    
-    if (nRunCounter++ >= nRuns)
-      break;    
-    
-    cout << "run #" << nRunCounter << endl;
-
-    // #########################################################
-    // setup galice and runloader
-    if (gAlice) {
-      delete gAlice->GetRunLoader();
-      delete gAlice;
-      gAlice=0;
-    }
-
-    sprintf(str,"%s/run%d/galice.root",dataDir,r);
-    AliRunLoader* runLoader = AliRunLoader::Open(str);
-
-    runLoader->LoadgAlice();
-    gAlice = runLoader->GetAliRun();
-    runLoader->LoadHeader();
-
-    // #########################################################
-    // open esd file and get the tree
-
-    sprintf(str,"%s/run%d/AliESDs.root",dataDir,r);
-    // close it first to avoid memory leak
-    if (esdFile)
-      if (esdFile->IsOpen())
-        esdFile->Close();
-
-    esdFile = TFile::Open(str);
-    esdTree = (TTree*)esdFile->Get("esdTree");
-    if (!esdTree)
-      continue;
-    esdBranch = esdTree->GetBranch("ESD");
-    esdBranch->SetAddress(&esd);
-    if (!esdBranch)
-      continue;
-
-    // ########################################################
-    // Magnetic field
-    AliTracker::SetFieldMap(gAlice->Field(),kTRUE); // kTRUE means uniform magnetic field
-
-    // ########################################################
-    // getting number of events
-    Int_t nEvents    = (Int_t)runLoader->GetNumberOfEvents();
-    Int_t nESDEvents = esdBranch->GetEntries();
-    
-    if (nEvents!=nESDEvents) 
-      cout << " Warning: Different number of events from runloader and esdtree!!!" << nEvents << " / " << nESDEvents << endl;
-    
-    // ########################################################
-    // loop over number of events
-    cout << " looping over events..." << endl;
-    for(Int_t i=1; i<nEvents; i++) {
-      
-      esdBranch->GetEntry(i);
-      runLoader->GetEvent(i);
-      
-      // ########################################################
-      // get the EDS vertex
-      AliESDVertex* vtxESD = esd->GetVertex();
-      
-      Double_t vtxSigma[3];
-      vtxESD->GetSigmaXYZ(vtxSigma);
-      
-      // ########################################################
-      // loop over esd tracks      
-      Int_t nTracks = esd->GetNumberOfTracks();      
-
-      for (Int_t t=0; t<nTracks; t++) {
-       AliESDtrack* esdTrack = esd->GetTrack(t);      
-       
-       //trackCuts->AcceptTrack(esdTrack, vtxESD, esd->GetMagneticField());
-       trackCuts->AcceptTrack(esdTrack);
-       
-      } // end of track loop
-    } // end  of event loop
-  } // end of run loop
-
-  TFile* fout = new TFile("out.root","RECREATE");
-
-  trackCuts->SaveHistograms("esd_track_cuts");
-  
-  fout->Write();
-  fout->Close();
-
+//
+// script to run the AliMultiplicityESDSelector
+//
+
+#include "../CreateESDChain.C"
+#include "../PWG0Helper.C"
+
+TChain* testESDtrackCuts(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Bool_t aProof = kFALSE)
+{
+  if (aProof)
+    connectProof("proof01@lxb6046");
+
+  TString libraries("libEG;libGeom;libESD;libPWG0base;libVMC;libMinuit;libSTEER;libPWG0dep;libEVGEN;libFASTSIM;libmicrocern;libpdf;libpythia6;lib
+EGPythia6;libAliPythia6");
+  TString packages("PWG0base;PWG0dep");
+
+  if (!prepareQuery(libraries, packages, kTRUE))
+    return;
+
+  // selection of esd tracks
+  AliESDtrackCuts* esdTrackCutsAll = new AliESDtrackCuts("esdTrackCutsAll");
+  AliESDtrackCuts* esdTrackCutsPri = new AliESDtrackCuts("esdTrackCutsPri");
+  AliESDtrackCuts* esdTrackCutsSec = new AliESDtrackCuts("esdTrackCutsSec");
+
+  esdTrackCutsAll->DefineHistograms(1);
+  esdTrackCutsAll->SetMinNClustersTPC(50);
+  esdTrackCutsAll->SetMaxChi2PerClusterTPC(3.5);
+  esdTrackCutsAll->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+  esdTrackCutsAll->SetRequireTPCRefit(kTRUE);
+  esdTrackCutsAll->SetMinNsigmaToVertex(3);
+  esdTrackCutsAll->SetRequireSigmaToVertex(kTRUE);
+  esdTrackCutsAll->SetAcceptKingDaughters(kFALSE);
+
+  esdTrackCutsPri->DefineHistograms(4);
+  esdTrackCutsPri->SetMinNClustersTPC(50);
+  esdTrackCutsPri->SetMaxChi2PerClusterTPC(3.5);
+  esdTrackCutsPri->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+  esdTrackCutsPri->SetRequireTPCRefit(kTRUE);
+  esdTrackCutsPri->SetMinNsigmaToVertex(3);
+  esdTrackCutsPri->SetRequireSigmaToVertex(kTRUE);
+  esdTrackCutsPri->SetAcceptKingDaughters(kFALSE);
+
+  esdTrackCutsSec->DefineHistograms(2);
+  esdTrackCutsSec->SetMinNClustersTPC(50);
+  esdTrackCutsSec->SetMaxChi2PerClusterTPC(3.5);
+  esdTrackCutsSec->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+  esdTrackCutsSec->SetRequireTPCRefit(kTRUE);
+  esdTrackCutsSec->SetMinNsigmaToVertex(3);
+  esdTrackCutsSec->SetRequireSigmaToVertex(kTRUE);
+  esdTrackCutsSec->SetAcceptKingDaughters(kFALSE);
+
+
+  TList inputList;
+  inputList.Add(esdTrackCutsAll);
+  inputList.Add(esdTrackCutsPri);
+  inputList.Add(esdTrackCutsSec);
+
+  TChain* chain = CreateESDChain(data, nRuns, offset);
+
+  TString selectorName = "AliTestESDtrackCutsSelector";
+  AliLog::SetClassDebugLevel(selectorName, AliLog::kInfo);
+
+  selectorName += ".cxx+";
+
+  if (aDebug != kFALSE)
+    selectorName += "g";
+
+  Int_t result = executeQuery(chain, &inputList, selectorName);
+
+  if (result != 0)
+  {
+    printf("ERROR: Executing process failed with %d.\n", result);
+    return;
+  }
 }
+