Made AliESDtrackCuts inherit from TNamed (needed to identify the objects in the input list (PROOF)).
Changed testESDtrackCuts to use the selector
};
//____________________________________________________________________
-AliESDtrackCuts::AliESDtrackCuts() : TObject(),
+AliESDtrackCuts::AliESDtrackCuts(Char_t* name) : TNamed(name,name),
fCutMinNClusterTPC(0),
fCutMinNClusterITS(0),
fCutMaxChi2PerClusterTPC(0),
}
//_____________________________________________________________________________
-AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : TObject(c),
+AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : TNamed(c),
fCutMinNClusterTPC(0),
fCutMinNClusterITS(0),
fCutMaxChi2PerClusterTPC(0),
#ifndef ALIESDTRACKCUTS_H
#define ALIESDTRACKCUTS_H
-#include <TObject.h>
+#include <TNamed.h>
#include <TH2.h>
class AliESD;
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);
--- /dev/null
+/* $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();
+}
--- /dev/null
+/* $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
/* $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;
+ }
}
+
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff