add tracks and clusters

diff --git a/PWG4/UserTasks/EmcalTasks/AliEsdSkimTask.cxx b/PWG4/UserTasks/EmcalTasks/AliEsdSkimTask.cxx
index 8397de932150518eaa9adaea238ef76199ea43da..727c456e02c6437ea57f4ba243fffde570d7fcf0 100644 (file)
--- a/PWG4/UserTasks/EmcalTasks/AliEsdSkimTask.cxx
+++ b/PWG4/UserTasks/EmcalTasks/AliEsdSkimTask.cxx
@@ -1,9 +1,14 @@
 // $Id$
+//
+// Task to skim ESD files.
+//
+//
 
 #include "AliEsdSkimTask.h"
 #include <TClonesArray.h>
 #include <TFile.h>
 #include <TTree.h>
+#include "AliAnalysisManager.h"
 #include "AliESDEvent.h"
 #include "AliESDtrackCuts.h"
 #include "AliMultiplicity.h"
@@ -13,7 +18,8 @@ AliEsdSkimTask::AliEsdSkimTask(const char *opt) :
   AliAnalysisTaskSE(opt), fEvent(0), fTree(0), fCuts(0),
   fDoZDC(1), fDoV0(1), fDoT0(1), fDoTPCv(1), fDoSPDv(1), fDoPriv(1),
   fDoEmCs(1), fDoPCs(1), fDoEmT(1), fDoPT(1), fDoTracks(1), fDoMult(1),
-  fDoTof(1), fDoPileup(1), fDoClus(1)
+  fDoTof(1), fDoPileup(1), fDoClus(1), fEmcNames(""), 
+  fDoMiniTracks(0), fTracks("Tracks"), fPhosClusOnly(0)
 {
   // Constructor.
 
@@ -32,70 +38,88 @@ void AliEsdSkimTask::UserExec(Option_t */*opt*/)
   if (!esdin)
     return;
 
+  AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
+
   fEvent->Reset();
 
-  TList* objs   = fEvent->GetList();
+  TList* objsin  = esdin->GetList();
+  TList* objsout = fEvent->GetList();
 
-  AliESDHeader *header = dynamic_cast<AliESDHeader*>(objs->FindObject("AliESDHeader"));
+  AliESDHeader *header = dynamic_cast<AliESDHeader*>(objsin->FindObject("AliESDHeader"));
   if (header) {
+    am->LoadBranch("AliESDHeader.");
     *header = *esdin->GetHeader();
   }
-  AliESDRun *run = dynamic_cast<AliESDRun*>(objs->FindObject("AliESDRun"));
+  AliESDRun *run = dynamic_cast<AliESDRun*>(objsin->FindObject("AliESDRun"));
   if (run) {
+    am->LoadBranch("AliESDRun.");
     *run = *esdin->GetESDRun();
   }
-  AliESDZDC *zdc = dynamic_cast<AliESDZDC*>(objs->FindObject("AliESDZDC"));
+  AliESDZDC *zdc = dynamic_cast<AliESDZDC*>(objsin->FindObject("AliESDZDC"));
   if (zdc) {
+    am->LoadBranch("AliESDZDC.");
     *zdc = *esdin->GetESDZDC();
   }
-  AliESDVZERO *v0 = dynamic_cast<AliESDVZERO*>(objs->FindObject("AliESDVZERO"));
+  AliESDVZERO *v0 = dynamic_cast<AliESDVZERO*>(objsin->FindObject("AliESDVZERO"));
   if (v0) {
+    am->LoadBranch("AliESDVZERO.");
     *v0 = *esdin->GetVZEROData();
   }
-  AliESDTZERO *t0 = dynamic_cast<AliESDTZERO*>(objs->FindObject("AliESDTZERO"));
+  AliESDTZERO *t0 = dynamic_cast<AliESDTZERO*>(objsin->FindObject("AliESDTZERO"));
   if (t0) {
+    am->LoadBranch("AliESDTZERO.");
     *t0 = *esdin->GetESDTZERO();
   }
-  AliESDVertex *tpcv = dynamic_cast<AliESDVertex*>(objs->FindObject("TPCVertex"));
+  AliESDVertex *tpcv = dynamic_cast<AliESDVertex*>(objsin->FindObject("TPCVertex"));
   if (tpcv) {
+    am->LoadBranch("TPCVertex.");
     *tpcv = *esdin->GetPrimaryVertexTPC();
   }
-  AliESDVertex *spdv = dynamic_cast<AliESDVertex*>(objs->FindObject("SPDVertex"));
+  AliESDVertex *spdv = dynamic_cast<AliESDVertex*>(objsin->FindObject("SPDVertex"));
   if (spdv) {
+    am->LoadBranch("SPDVertex.");
     *spdv = *esdin->GetPrimaryVertexSPD();
   }
-  AliESDVertex *priv = dynamic_cast<AliESDVertex*>(objs->FindObject("PrimaryVertex"));
+  AliESDVertex *priv = dynamic_cast<AliESDVertex*>(objsin->FindObject("PrimaryVertex"));
   if (priv) {
+    am->LoadBranch("PrimaryVertex.");
     *priv = *esdin->GetPrimaryVertexTracks();
   }
-  AliESDCaloCells *ecells = dynamic_cast<AliESDCaloCells*>(objs->FindObject("EMCALCells"));
+  AliESDCaloCells *ecells = dynamic_cast<AliESDCaloCells*>(objsin->FindObject("EMCALCells"));
   if (ecells) {
+    am->LoadBranch("EMCALCells.");
     *ecells = *esdin->GetEMCALCells();
   }
-  AliESDCaloCells *pcells = dynamic_cast<AliESDCaloCells*>(objs->FindObject("PHOSCells"));
+  AliESDCaloCells *pcells = dynamic_cast<AliESDCaloCells*>(objsin->FindObject("PHOSCells"));
   if (pcells) {
+    am->LoadBranch("PHOSCells.");
     *pcells = *esdin->GetPHOSCells();
   }
-  AliESDCaloTrigger *etrig = dynamic_cast<AliESDCaloTrigger*>(objs->FindObject("EMCALTrigger"));
+  AliESDCaloTrigger *etrig = dynamic_cast<AliESDCaloTrigger*>(objsin->FindObject("EMCALTrigger"));
   if (etrig) {
+    am->LoadBranch("EMCALTrigger.");
     *etrig = *esdin->GetCaloTrigger("EMCAL");
   }
-  AliESDCaloTrigger *ptrig = dynamic_cast<AliESDCaloTrigger*>(objs->FindObject("PHOSTrigger"));
+  AliESDCaloTrigger *ptrig = dynamic_cast<AliESDCaloTrigger*>(objsin->FindObject("PHOSTrigger"));
   if (ptrig) {
+    am->LoadBranch("PHOSTrigger.");
     *ptrig = *esdin->GetCaloTrigger("PHOS");
   }
 
-  AliMultiplicity *mult = dynamic_cast<AliMultiplicity*>(objs->FindObject("AliMultiplicity"));
+  AliMultiplicity *mult = dynamic_cast<AliMultiplicity*>(objsin->FindObject("AliMultiplicity"));
   if (mult) {
+    am->LoadBranch("AliMultiplicity.");
     *mult = *esdin->GetMultiplicity();
   }
 
-  AliTOFHeader *tofh = dynamic_cast<AliTOFHeader*>(objs->FindObject("AliTOFHeader"));
+  AliTOFHeader *tofh = dynamic_cast<AliTOFHeader*>(objsin->FindObject("AliTOFHeader"));
   if (tofh) {
+    am->LoadBranch("AliTOFHeader.");
     *tofh = *esdin->GetTOFHeader();
   }
-  TClonesArray *spup = dynamic_cast<TClonesArray*>(objs->FindObject("SPDPileupVertices"));
+  TClonesArray *spup = dynamic_cast<TClonesArray*>(objsin->FindObject("SPDPileupVertices"));
   if (spup) {
+    am->LoadBranch("SPDPileupVertices");
     Int_t N = esdin->GetNumberOfPileupVerticesSPD();
     for (Int_t i=0; i<N; ++i) {
       const AliESDVertex *vtx = esdin->GetPileupVertexSPD(i);
@@ -103,8 +127,9 @@ void AliEsdSkimTask::UserExec(Option_t */*opt*/)
         fEvent->AddPileupVertexSPD(vtx);
     }
   }
-  TClonesArray *tpup = dynamic_cast<TClonesArray*>(objs->FindObject("TrkPileupVertices"));
+  TClonesArray *tpup = dynamic_cast<TClonesArray*>(objsin->FindObject("TrkPileupVertices"));
   if (tpup) {
+    am->LoadBranch("TrkPileupVertices");
     Int_t N = esdin->GetNumberOfPileupVerticesTracks();
     for (Int_t i=0; i<N; ++i) {
       const AliESDVertex *vtx = esdin->GetPileupVertexTracks(i);
@@ -112,31 +137,63 @@ void AliEsdSkimTask::UserExec(Option_t */*opt*/)
         fEvent->AddPileupVertexTracks(vtx);
     }
   }
-  TClonesArray *clus = dynamic_cast<TClonesArray*>(objs->FindObject("CaloClusters"));
+  TClonesArray *clus = dynamic_cast<TClonesArray*>(objsin->FindObject("CaloClusters"));
   if (clus) {
+    am->LoadBranch("");
     Int_t N = esdin->GetNumberOfCaloClusters();
     for (Int_t i=0; i<N; ++i) {
       AliESDCaloCluster *c = esdin->GetCaloCluster(i);
+      if (fPhosClusOnly && c->IsEMCAL())
+        continue;
       if (c)
         fEvent->AddCaloCluster(c);
     }
   }
+  TObjArray *namearr = fEmcNames.Tokenize(";");
+  if (namearr) {
+    for (Int_t i=0; i<namearr->GetEntries(); ++i) {
+      TString cname(namearr->At(i)->GetName());
+      if (cname.Length()<=0)
+        continue;
+      TClonesArray *arrin  = dynamic_cast<TClonesArray*>(objsin->FindObject(cname));
+      TClonesArray *arrout = dynamic_cast<TClonesArray*>(objsout->FindObject(cname));
+      //AliFatal(Form("Can not find tracks with name %s", fTracks.Data()));
+      arrout->Delete();
+      const Int_t N = arrin->GetEntries();
+      for (Int_t iC=0, nC=0; iC<N; ++iC) {
+        AliESDCaloCluster *c = dynamic_cast<AliESDCaloCluster*>(arrin->At(iC));
+        if (!c)
+          continue;
+        new ((*arrout)[nC++]) AliESDCaloCluster(*c);
+      }
+    }
+    delete namearr;
+  }
   if (fDoTracks) {
-    const Int_t Ntracks = esdin->GetNumberOfTracks();
+    am->LoadBranch("Tracks");
+    TClonesArray *tracks = dynamic_cast<TClonesArray*>(objsin->FindObject(fTracks));
+    if (!tracks) {
+      AliFatal(Form("Can not find tracks with name %s", fTracks.Data()));
+      return;
+    }
+    const Int_t Ntracks = tracks->GetEntries();
     Int_t nacc = 0;
     for (Int_t iTracks = 0; iTracks < Ntracks; ++iTracks) {
-      AliESDtrack *track = esdin->GetTrack(iTracks);
+      AliESDtrack *track = dynamic_cast<AliESDtrack*>(tracks->At(iTracks));
       if (!track)
         continue;
       if (fCuts) {
         if (!fCuts->IsSelected(track))
           continue;
       }
+      if (fDoMiniTracks) {
+        track->MakeMiniESDtrack();
+      }
       fEvent->AddTrack(track);
       ++nacc;
     }
     if (fCuts) 
-      printf("selected %d out of %d \n", nacc, Ntracks);
+      AliInfo(Form("Selected %d out of %d \n", nacc, Ntracks));
   }
   fTree->Fill();
 }
@@ -146,7 +203,7 @@ void AliEsdSkimTask::UserCreateOutputObjects()
 {
   // Create output objects.
 
-  fTree = new TTree("esdTree", "Tree with ESD objects");
+  fTree = new TTree("esdTree", "Tree with skimmed ESD objects");
   fEvent = new AliESDEvent;
   fEvent->AddObject(new AliESDHeader());
   fEvent->AddObject(new AliESDRun());
@@ -187,11 +244,6 @@ void AliEsdSkimTask::UserCreateOutputObjects()
     ptrig->SetName("PHOSTrigger");
     fEvent->AddObject(ptrig);
   }
-  if (fDoTracks) {
-    TClonesArray *arr = new TClonesArray("AliESDtrack",0);
-    arr->SetName("Tracks");
-    fEvent->AddObject(arr);
-  }
   if (fDoMult) {
     fEvent->AddObject(new AliMultiplicity());
   }
@@ -211,6 +263,23 @@ void AliEsdSkimTask::UserCreateOutputObjects()
     arr->SetName("CaloClusters");
     fEvent->AddObject(arr);
   }
+  TObjArray *namearr = fEmcNames.Tokenize(";");
+  if (namearr) {
+    for (Int_t i=0; i<namearr->GetEntries(); ++i) {
+      TString cname(namearr->At(i)->GetName());
+      if (cname.Length()<=0)
+        continue;
+      TClonesArray *arr = new TClonesArray("AliESDCaloCluster",0);
+      arr->SetName(cname);
+      fEvent->AddObject(arr);
+    }
+    delete namearr;
+  }
+  if (fDoTracks) {
+    TClonesArray *arr = new TClonesArray("AliESDtrack",0);
+    arr->SetName("Tracks");
+    fEvent->AddObject(arr);
+  }
   fEvent->GetStdContent();
   fEvent->WriteToTree(fTree);
   fTree->GetUserInfo()->Add(fEvent);

diff --git a/PWG4/UserTasks/EmcalTasks/AliEsdSkimTask.h b/PWG4/UserTasks/EmcalTasks/AliEsdSkimTask.h
index f93ca84f14a61e9713d177bf0162e6cc60661fa0..bc578a0f4bec02e9baac788831011c7d42eb5b5d 100644 (file)
--- a/PWG4/UserTasks/EmcalTasks/AliEsdSkimTask.h
+++ b/PWG4/UserTasks/EmcalTasks/AliEsdSkimTask.h
@@ -15,47 +15,55 @@ class AliEsdSkimTask : public AliAnalysisTaskSE {
 
   void UserExec(Option_t *opt);
   void UserCreateOutputObjects();
-  void SetDoZdc(Bool_t b)          { fDoZDC    = b; }
-  void SetDoV0(Bool_t b)           { fDoV0     = b; }
-  void SetDoT0(Bool_t b)           { fDoT0     = b; }
-  void SetDoTpcV(Bool_t b)         { fDoTPCv   = b; }
-  void SetDoSpdV(Bool_t b)         { fDoSPDv   = b; }
-  void SetDoPriV(Bool_t b)         { fDoPriv   = b; }
-  void SetDoEmC(Bool_t b)          { fDoEmCs   = b; }
-  void SetDoPhC(Bool_t b)          { fDoPCs    = b; }
-  void SetDoEmT(Bool_t b)          { fDoEmT    = b; }
-  void SetDoPhT(Bool_t b)          { fDoPT     = b; }
-  void SetDoTracks(Bool_t b)       { fDoTracks = b; }
-  void SetDoMult(Bool_t b)         { fDoMult   = b; }
-  void SetDoTof(Bool_t b)          { fDoTof    = b; }
-  void SetDoPileup(Bool_t b)       { fDoPileup = b; }
-  void SetDoClus(Bool_t b)         { fDoClus   = b; }
-  void SetCuts(AliESDtrackCuts *c) { fCuts     = c; }
+  void SetCuts(AliESDtrackCuts *c) { fCuts         = c; }
+  void SetDoClus(Bool_t b)         { fDoClus       = b; }
+  void SetDoEmC(Bool_t b)          { fDoEmCs       = b; }
+  void SetDoEmT(Bool_t b)          { fDoEmT        = b; }
+  void SetDoMiniTracks(Bool_t b)   { fDoMiniTracks = b; }
+  void SetDoMult(Bool_t b)         { fDoMult       = b; }
+  void SetDoPhC(Bool_t b)          { fDoPCs        = b; }
+  void SetDoPhT(Bool_t b)          { fDoPT         = b; }
+  void SetDoPileup(Bool_t b)       { fDoPileup     = b; }
+  void SetDoPriV(Bool_t b)         { fDoPriv       = b; }
+  void SetDoSpdV(Bool_t b)         { fDoSPDv       = b; }
+  void SetDoT0(Bool_t b)           { fDoT0         = b; }
+  void SetDoTof(Bool_t b)          { fDoTof        = b; }
+  void SetDoTpcV(Bool_t b)         { fDoTPCv       = b; }
+  void SetDoTracks(Bool_t b)       { fDoTracks     = b; }
+  void SetDoV0(Bool_t b)           { fDoV0         = b; }
+  void SetDoZdc(Bool_t b)          { fDoZDC        = b; }
+  void SetEmcNames(const char *n)  { fEmcNames     = n; }
+  void SetPhosClusOnly(Bool_t b)   { fPhosClusOnly = b; }
+  void SetTracks(const char *n)    { fTracks       = n; }
 
  protected:
-  AliESDEvent     *fEvent;    //!esd event
-  TTree           *fTree;     //!tree
-  AliESDtrackCuts *fCuts;     // track cuts
-  Bool_t           fDoZDC;    // do zdc
-  Bool_t           fDoV0;     // do vzero
-  Bool_t           fDoT0;     // do tzero
-  Bool_t           fDoTPCv;   // do tpc vertex
-  Bool_t           fDoSPDv;   // do spd vertex
-  Bool_t           fDoPriv;   // do primary vertex
-  Bool_t           fDoEmCs;   // do emcal cells
-  Bool_t           fDoPCs;    // do phos cells
-  Bool_t           fDoEmT;    // do emcal trigger
-  Bool_t           fDoPT;     // do phos trigger
-  Bool_t           fDoTracks; // do tracks
-  Bool_t           fDoMult;   // do mult
-  Bool_t           fDoTof;    // do TOF
-  Bool_t           fDoPileup; // do pileup
-  Bool_t           fDoClus;   // do clusters
-    
+  AliESDEvent     *fEvent;        //!esd event
+  TTree           *fTree;         //!tree
+  AliESDtrackCuts *fCuts;         // track cuts
+  Bool_t           fDoZDC;        // do zdc
+  Bool_t           fDoV0;         // do vzero
+  Bool_t           fDoT0;         // do tzero
+  Bool_t           fDoTPCv;       // do tpc vertex
+  Bool_t           fDoSPDv;       // do spd vertex
+  Bool_t           fDoPriv;       // do primary vertex
+  Bool_t           fDoEmCs;       // do emcal cells
+  Bool_t           fDoPCs;        // do phos cells
+  Bool_t           fDoEmT;        // do emcal trigger
+  Bool_t           fDoPT;         // do phos trigger
+  Bool_t           fDoTracks;     // do tracks
+  Bool_t           fDoMult;       // do mult
+  Bool_t           fDoTof;        // do TOF
+  Bool_t           fDoPileup;     // do pileup
+  Bool_t           fDoClus;       // do clusters
+  TString          fEmcNames;     // name of clusters
+  Bool_t           fDoMiniTracks; // strip down tracks
+  TString          fTracks;       // name of tracks (e.g. tracks propagated to EMCAL surface)
+  Bool_t           fPhosClusOnly; // if true then only store PHOS clusters
+
  private:
   AliEsdSkimTask(const AliEsdSkimTask&);            // not implemented
   AliEsdSkimTask &operator=(const AliEsdSkimTask&); // not implemented
 
- ClassDef(AliEsdSkimTask, 1); // Esd trimming and skimming task
+ ClassDef(AliEsdSkimTask, 2); // Esd trimming and skimming task
 };
 #endif