Changes for 2012 data analysis
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 1 Feb 2012 10:35:49 +0000 (10:35 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 1 Feb 2012 10:35:49 +0000 (10:35 +0000)
Add simple task to filter ESD into AOD only if there is some data in EMCAL, for the moment a simple selection based on the energy of the clusters in the event

14 files changed:
PWGGA/CMakelibPWGGAEMCALTasks.pkg
PWGGA/CaloTasks/AliAnalysisTaskCaloFilter.cxx
PWGGA/CaloTasks/AliAnalysisTaskCaloFilter.h
PWGGA/CaloTasks/macros/AddTaskCaloFilter.C [moved from PWGGA/EMCALTasks/macros/AddTaskCaloFilter.C with 100% similarity]
PWGGA/CaloTasks/macros/ConfigCaloFilter.C [moved from PWGGA/EMCALTasks/macros/ConfigCaloFilter.C with 100% similarity]
PWGGA/EMCALTasks/AliAnalysisTaskEMCALClusterize.cxx
PWGGA/EMCALTasks/AliAnalysisTaskEMCALClusterize.h
PWGGA/EMCALTasks/AliAnalysisTaskESDfilterEMCALEventSelect.cxx [new file with mode: 0644]
PWGGA/EMCALTasks/AliAnalysisTaskESDfilterEMCALEventSelect.h [new file with mode: 0644]
PWGGA/EMCALTasks/macros/AddTaskEMCALClusterize.C
PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C
PWGGA/EMCALTasks/macros/AddTaskESDFilterEMCALEventSelect.C [new file with mode: 0644]
PWGGA/EMCALTasks/macros/ConfigureEMCALRecoUtils.C
PWGGA/PWGGAEMCALTasksLinkDef.h

index 93a1f95efa15d826291f1a9d92719b22f7a21479..1ab698dd4f7d9bf84d7cc68f2ab2b3c30a13e5ab 100644 (file)
@@ -32,6 +32,7 @@ set ( SRCS
  EMCALTasks/AliAnalysisTaskEMCALPi0CalibSelection.cxx 
  EMCALTasks/AliAnalysisTaskEMCALPi0PbPb.cxx
  EMCALTasks/AliAnalysisTaskEMCALTriggerQA.cxx
+ EMCALTasks/AliAnalysisTaskESDfilterEMCALEventSelect.cxx
  EMCALTasks/AliEmcalEsdTpcTrackTask.cxx
  EMCALTasks/AliEmcalPhysicsSelection.cxx
  EMCALTasks/AliEmcalPhysicsSelectionTask.cxx
index 7b3fa6791b4270124f0a97fbd1b4887eb425925f..0c5c5b2010629f25613ad8dad2864870e9879f17 100644 (file)
@@ -13,8 +13,6 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id: AliAnalysisTaskCaloFilter.cxx $ */
-
 //////////////////////////////////////////////////////////
 // Filter the ESDCaloClusters and ESDCaloCells of EMCAL,
 // PHOS or both, creating the corresponing AODCaloClusters
@@ -65,7 +63,7 @@ AliAnalysisTaskCaloFilter::AliAnalysisTaskCaloFilter():
 {
   // Default constructor
   fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();
-  for(Int_t i = 0; i < 10; i++) fEMCALMatrix[i] = 0 ;
+  for(Int_t i = 0; i < 12; i++) fEMCALMatrix[i] = 0 ;
   //for(Int_t i = 0; i < 5 ; i++) fPHOSMatrix[i]  = 0 ;
 
   DefineOutput(1, TNtuple::Class());
@@ -84,7 +82,7 @@ AliAnalysisTaskCaloFilter::AliAnalysisTaskCaloFilter(const char* name):
 {
   // Constructor
   fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();
-  for(Int_t i = 0; i < 10; i++) fEMCALMatrix[i] = 0 ;
+  for(Int_t i = 0; i < 12; i++) fEMCALMatrix[i] = 0 ;
   //for(Int_t i = 0; i < 5 ; i++) fPHOSMatrix[i]  = 0 ;
 
   DefineOutput(1, TNtuple::Class());
@@ -122,7 +120,7 @@ void AliAnalysisTaskCaloFilter::Init()
     fCorrect           = filter->fCorrect;
     fTrackMultEtaCut   = filter->fTrackMultEtaCut;
     fESDtrackCuts      = filter->fESDtrackCuts;
-    for(Int_t i = 0; i < 10; i++) fEMCALMatrix[i] = filter->fEMCALMatrix[i] ;
+    for(Int_t i = 0; i < 12; i++) fEMCALMatrix[i] = filter->fEMCALMatrix[i] ;
   }
 } 
 
index 4be3ebff2dc20a3b10f346f289731a9fd98a5ed6..04f886c992d8b31d018710600b289dd17bfe2ee5 100644 (file)
@@ -4,8 +4,6 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id: AliAnalysisTaskCaloFilter.h  $ */
-
 //////////////////////////////////////////////////////////
 // Filter the ESDCaloClusters and ESDCaloCells of EMCAL,
 // PHOS or both, creating the corresponing AODCaloClusters
@@ -30,13 +28,9 @@ class AliAnalysisTaskCaloFilter : public AliAnalysisTaskSE
   AliAnalysisTaskCaloFilter();
   AliAnalysisTaskCaloFilter(const char* name);
   virtual ~AliAnalysisTaskCaloFilter() ;
-  
-private:
-  AliAnalysisTaskCaloFilter(const AliAnalysisTaskCaloFilter&);
-  AliAnalysisTaskCaloFilter& operator=(const AliAnalysisTaskCaloFilter&);
-  
-public:
+    
   //General analysis frame methods
+  
   virtual void   UserCreateOutputObjects();
   virtual void   Init();
   virtual void   LocalInit() { Init() ; }
@@ -44,22 +38,27 @@ public:
   virtual void   Terminate(Option_t *option);
       
   //Geometry methods
+  
   void SetEMCALGeometryName(TString name)                  { fEMCALGeoName = name        ; }
   TString EMCALGeometryName()                       const  { return fEMCALGeoName        ; }
+  
   void SwitchOnLoadOwnEMCALGeometryMatrices()              { fLoadEMCALMatrices = kTRUE  ; }
   void SwitchOffLoadOwnEMCALGeometryMatrices()             { fLoadEMCALMatrices = kFALSE ; }
   void SetEMCALGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fEMCALMatrix[i]    = m      ; }
+  
   //void SwitchOnLoadOwnPHOSGeometryMatrices()               { fLoadPHOSMatrices = kTRUE  ; }
   //void SwitchOffLoadOwnPHOSGeometryMatrices()              { fLoadPHOSMatrices = kFALSE ; }
   //void SetPHOSGeometryMatrixInSM(TGeoHMatrix* m, Int_t i)  { fPHOSMatrix[i]    = m      ; }
   
   //Task settings
+  
   void    FillAODFile(Bool_t yesno)               { fFillAODFile = yesno    ; }
+  
   enum    caloFilter {kBoth = 0, kEMCAL = 1, kPHOS=2};
   void    SetCaloFilter(Int_t calo)               { fCaloFilter = calo      ; }
   TString GetCaloFilter()                  const  { return fCaloFilter      ; }  
   
-  void SetEMCALRecoUtils(AliEMCALRecoUtils * ru)  { fEMCALRecoUtils = ru    ; }
+  void   SetEMCALRecoUtils(AliEMCALRecoUtils* ru) { fEMCALRecoUtils = ru    ; }
   AliEMCALRecoUtils* GetEMCALRecoUtils()   const  { return fEMCALRecoUtils  ; }
 
   void    SwitchOnClusterCorrection()             { fCorrect = kTRUE        ; }
@@ -67,10 +66,13 @@ public:
   
   //Event selection
   AliESDtrackCuts* GetTrackCuts()          const  { return fESDtrackCuts    ; }
-  void    SetTrackCuts(AliESDtrackCuts * cuts)    { fESDtrackCuts = cuts    ; }                  
+  void    SetTrackCuts(AliESDtrackCuts * cuts)    { //if (fESDtrackCuts) delete fESDtrackCuts ;
+                                                    fESDtrackCuts = cuts    ; }                
+  
   Float_t GetTrackMultiplicityEtaCut()     const  { return fTrackMultEtaCut ; }
   void    SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta  ; }                
-  virtual Bool_t CheckForPrimaryVertex();
+  
+  Bool_t  CheckForPrimaryVertex();
 
   void    PrintInfo();
   
@@ -79,8 +81,10 @@ public:
 private:
   
   //TList* fCuts ;      //! List with analysis cuts
+  
   Int_t               fCaloFilter;        // Calorimeter to filter
   Int_t               fCorrect;           // Recalibrate or recalculate different cluster parameters
+  
   //EMCAL specific
   AliEMCALGeometry  * fEMCALGeo;          //! EMCAL geometry
   TString             fEMCALGeoName;      // Name of geometry to use.
@@ -92,7 +96,7 @@ private:
   
   //Geometry
   Bool_t              fLoadEMCALMatrices; // Matrices set from configuration, not get from geometry.root or from ESDs/AODs
-  TGeoHMatrix       * fEMCALMatrix[10];   // Geometry matrices with alignments
+  TGeoHMatrix       * fEMCALMatrix[12];   // Geometry matrices with alignments
   //Bool_t            fLoadPHOSMatrices;  // Matrices set from configuration, not get from geometry.root or from ESDs/AODs
   //TGeoHMatrix *     fPHOSMatrix[5];     // Geometry matrices with alignments
   Bool_t              fGeoMatrixSet;      // Set geometry matrices only once, for the first event.   
@@ -102,7 +106,11 @@ private:
   TString             fConfigName;        // Name of analysis configuration file
   Bool_t              fFillAODFile;       // Fill the output AOD file with clusters 
   
-  ClassDef(AliAnalysisTaskCaloFilter, 6); // Analysis task for standard ESD filtering
+  AliAnalysisTaskCaloFilter(           const AliAnalysisTaskCaloFilter&);
+  AliAnalysisTaskCaloFilter& operator=(const AliAnalysisTaskCaloFilter&);
+  
+  ClassDef(AliAnalysisTaskCaloFilter, 7); // Analysis task for standard ESD filtering
+  
 };
 
 #endif
index 84051e9b57bf1002bbf14416a32f650f14bf9f42..21d3a4999fb0a6f09a3e0efb08cee974a7bd18cf 100644 (file)
@@ -86,8 +86,9 @@ AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize(const char *name)
 , fImportGeometryFromFile(kFALSE), fImportGeometryFilePath("")
 {
   //ctor
-  for(Int_t i = 0; i < 10;    i++)  fGeomMatrix[i] =  0;
-  for(Int_t j = 0; j < 24*48*11; j++)  {
+  for(Int_t i = 0; i < 12;    i++)  fGeomMatrix[i] =  0;
+  for(Int_t j = 0; j < 24*48*11; j++)  
+  {
     fCellLabels[j]       = -1;
     fCellSecondLabels[j] = -1;
     fCellTime[j]         =  0.;    
@@ -127,8 +128,9 @@ AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize()
 , fImportGeometryFromFile(kFALSE), fImportGeometryFilePath("")
 {
   // Constructor
-  for(Int_t i = 0; i < 10;    i++)  fGeomMatrix[i] =  0;
-  for(Int_t j = 0; j < 24*48*11; j++)  {
+  for(Int_t i = 0; i < 12;    i++)  fGeomMatrix[i] =  0;
+  for(Int_t j = 0; j < 24*48*11; j++)  
+  {
     fCellLabels[j]       = -1;
     fCellSecondLabels[j] = -1;
     fCellTime[j]         =  0.; 
@@ -681,7 +683,7 @@ void AliAnalysisTaskEMCALClusterize::Init()
     fMaxEvent         = clus->fMaxEvent;
     fDoTrackMatching  = clus->fDoTrackMatching;
     fOutputAODBranchName = clus->fOutputAODBranchName;
-    for(Int_t i = 0; i < 10; i++) fGeomMatrix[i] = clus->fGeomMatrix[i] ;
+    for(Int_t i = 0; i < 12; i++) fGeomMatrix[i] = clus->fGeomMatrix[i] ;
     
   }
   
index 618d9d0619c02ec53c576d9bec4406aabd3139e1..ebbb6b57c69edb6a99f6910f1509c4b30d7f7177 100644 (file)
@@ -108,7 +108,7 @@ class AliAnalysisTaskEMCALClusterize : public AliAnalysisTaskSE {
   //Geometry  
   AliEMCALGeometry      *fGeom;                    // EMCAL geometry
   TString                fGeomName;                // Name of geometry to use.
-  TGeoHMatrix           *fGeomMatrix[10];          // Geometry matrices with alignments
+  TGeoHMatrix           *fGeomMatrix[12];          // Geometry matrices with alignments
   Bool_t                 fGeomMatrixSet;           // Set geometry matrices only once, for the first event.         
   Bool_t                 fLoadGeomMatrices;        // Matrices set from configuration, not get from geometry.root or from ESDs/AODs
 
@@ -161,7 +161,7 @@ class AliAnalysisTaskEMCALClusterize : public AliAnalysisTaskSE {
   TString                fImportGeometryFilePath;  // path fo geometry.root file
 
   
-  ClassDef(AliAnalysisTaskEMCALClusterize, 17);
+  ClassDef(AliAnalysisTaskEMCALClusterize, 18);
 
 };
 
diff --git a/PWGGA/EMCALTasks/AliAnalysisTaskESDfilterEMCALEventSelect.cxx b/PWGGA/EMCALTasks/AliAnalysisTaskESDfilterEMCALEventSelect.cxx
new file mode 100644 (file)
index 0000000..dab07cb
--- /dev/null
@@ -0,0 +1,102 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+//////////////////////////////////////////////////////////
+// Calls derived from AliAnalysisTaskESDfilter
+// Filter the ESD Events to AODs, only those events with
+// some signal in EMCAL, righ now at least a 
+// cluster of high energy
+//
+// Author: Gustavo Conesa Balbastre (LPSC - Grenoble)
+//////////////////////////////////////////////////////////
+
+#include "AliESDCaloCluster.h"
+
+#include "AliAnalysisTaskESDfilterEMCALEventSelect.h"
+
+ClassImp(AliAnalysisTaskESDfilterEMCALEventSelect)
+
+//____________________________________________________________________________________
+AliAnalysisTaskESDfilterEMCALEventSelect::AliAnalysisTaskESDfilterEMCALEventSelect() : 
+AliAnalysisTaskESDfilter("ESD Filte : EMCAL selected events"), 
+fEnergyCut(10),            fNcellsCut (2),
+fRecoUtils(0x0),           
+fGeometry(0),              fGeoName("EMCAL_COMPLETE12SMV1")        
+{
+  // Default constructor
+  
+  fRecoUtils = new AliEMCALRecoUtils;
+
+}                    
+
+//____________________________________________________________________________________________________
+AliAnalysisTaskESDfilterEMCALEventSelect::AliAnalysisTaskESDfilterEMCALEventSelect(const char *name) : 
+AliAnalysisTaskESDfilter(name), 
+fEnergyCut(10),            fNcellsCut (2),
+fRecoUtils(0x0),           
+fGeometry(0),              fGeoName("EMCAL_COMPLETE12SMV1")
+{
+  // Constructor
+  
+  fRecoUtils = new AliEMCALRecoUtils;
+
+}
+
+//_________________________________________________________________
+Bool_t AliAnalysisTaskESDfilterEMCALEventSelect::AcceptEventEMCAL()
+{
+  // Accept event given there is a cluster with enough energy
+    
+  if(!fGeometry)  fGeometry  = AliEMCALGeometry::GetInstance("EMCAL_COMPLETE12SMV1");
+
+  Int_t           nCluster = InputEvent() -> GetNumberOfCaloClusters();
+  AliVCaloCells * caloCell = InputEvent() -> GetEMCALCells();
+  Int_t           bc       = InputEvent() -> GetBunchCrossNumber();
+  
+  for(Int_t icalo = 0; icalo < nCluster; icalo++)
+  {
+    AliESDCaloCluster *clus = (AliESDCaloCluster*) (InputEvent()->GetCaloCluster(icalo));
+    
+    if( ( clus->IsEMCAL() ) && ( clus->GetNCells() > fNcellsCut ) && ( clus->E() > fEnergyCut ) &&
+        fRecoUtils->IsGoodCluster(clus,fGeometry,caloCell,bc))
+    {
+      
+     // printf("Accept event %d, E %2.2f > %2.2f, nCells %d > %d \n", 
+     //        (Int_t) Entry(),clus->E(), fEnergyCut, clus->GetNCells(), fNcellsCut);
+      
+      return kTRUE;
+    }
+    
+  }// loop
+  
+  return kFALSE;
+  
+}  
+
+//_________________________________________________________________
+void AliAnalysisTaskESDfilterEMCALEventSelect::UserExec(Option_t *) 
+{
+  // Main loop
+
+  // Check if the events contains what we want in EMCAL, if not, 
+  // do not copy the ESD into AOD
+  
+  if(!AcceptEventEMCAL()) return ;
+  
+  // Continue the processing in the same way as in the ESD filter
+  
+  AliAnalysisTaskESDfilter::UserExec("");
+  
+}
diff --git a/PWGGA/EMCALTasks/AliAnalysisTaskESDfilterEMCALEventSelect.h b/PWGGA/EMCALTasks/AliAnalysisTaskESDfilterEMCALEventSelect.h
new file mode 100644 (file)
index 0000000..813bf3f
--- /dev/null
@@ -0,0 +1,69 @@
+#ifndef ALIANALYSISTASKESDFILTEREMCALEVENTSELECT_H
+#define ALIANALYSISTASKESDFILTEREMCALEVENTSELECT_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//////////////////////////////////////////////////////////
+// Calls derived from AliAnalysisTaskESDfilter
+// Filter the ESD Events to AODs, only those events with
+// some signal in EMCAL, righ now at least a 
+// cluster of high energy
+//
+// Author: Gustavo Conesa Balbastre (LPSC - Grenoble)
+//////////////////////////////////////////////////////////
+
+#include "AliEMCALGeometry.h"
+#include "AliEMCALRecoUtils.h"
+
+#include "AliAnalysisTaskESDfilter.h"
+
+class AliAnalysisTaskESDfilterEMCALEventSelect : public AliAnalysisTaskESDfilter 
+{
+public:
+  
+  AliAnalysisTaskESDfilterEMCALEventSelect();                   // default constructor
+  
+  AliAnalysisTaskESDfilterEMCALEventSelect(const char *name);   // named constructor
+  
+  virtual ~AliAnalysisTaskESDfilterEMCALEventSelect() { ; }     // destructor
+  
+  void    UserExec(Option_t *option);               
+  
+  Bool_t  AcceptEventEMCAL() ;
+  
+  void    AccessBadMap();
+  
+  void    SetGeometryName(TString name)  { fGeoName = name   ; } 
+  TString GetGeometryName()        const { return fGeoName   ; } 
+
+  void    SetEnergyCut(Float_t cut)      { fEnergyCut = cut  ; }
+  Float_t GetEnergyCut()           const { return fEnergyCut ; }
+  
+  void    SetNcellsCut(Int_t cut)        { fNcellsCut = cut  ; }
+  Int_t   GetNcellsCut()           const { return fNcellsCut ; }
+
+  
+  AliEMCALRecoUtils* GetRecoUtils()      { return fRecoUtils ; }
+  
+private:
+  
+  Float_t             fEnergyCut;       //  At least a cluster with this energy in the event
+  
+  Int_t               fNcellsCut;       //  At least a cluster with fNCellsCut cells over fEnergyCut
+  
+  AliEMCALRecoUtils * fRecoUtils;       //  RecoUtils
+
+  AliEMCALGeometry  * fGeometry;        //  Access to EMCAL geometry utils
+  
+  TString             fGeoName;         //  Name of geometry used
+    
+  AliAnalysisTaskESDfilterEMCALEventSelect(           const AliAnalysisTaskESDfilterEMCALEventSelect&); // not implemented
+  
+  AliAnalysisTaskESDfilterEMCALEventSelect& operator=(const AliAnalysisTaskESDfilterEMCALEventSelect&); // not implemented
+  
+  ClassDef(AliAnalysisTaskESDfilterEMCALEventSelect, 1);  
+  
+};
+
+#endif 
index 74f529c471e4b6e99fa0483f1d7b54f031eb9ae1..b87c9c462a538484ff44bf1552fe3e5ea7ba887b 100644 (file)
@@ -53,8 +53,9 @@ AliAnalysisTaskEMCALClusterize* AddTaskEMCALClusterize(
   
   printf(" ---- Clusterize RUN >%d< ---- \n",run);
   
-  if(run > 140000)  clusterize->SetGeometryName("EMCAL_COMPLETEV1");
-  else              clusterize->SetGeometryName("EMCAL_FIRSTYEARV1");
+  if     (run > 140000)  clusterize->SetGeometryName("EMCAL_COMPLETEV1");
+  else if(run > 171000)  clusterize->SetGeometryName("EMCAL_COMPLETE12SMV1");
+  else                   clusterize->SetGeometryName("EMCAL_FIRSTYEARV1");
 
   AliEMCALRecParam * params = clusterize->GetRecParam();
 
@@ -113,7 +114,7 @@ AliAnalysisTaskEMCALClusterize* AddTaskEMCALClusterize(
 
   } // unfold
   
-  TGeoHMatrix* matrix[10];
+  TGeoHMatrix* matrix[12];
   AliEMCALRecoUtils * reco = clusterize->GetRecoUtils();
   
   gROOT->LoadMacro("ConfigureEMCALRecoUtils.C"); // $ALICE_ROOT/PWGGA/EMCALTasks/macros
@@ -130,7 +131,7 @@ AliAnalysisTaskEMCALClusterize* AddTaskEMCALClusterize(
   
   clusterize->SetImportGeometryFromFile(kTRUE); // import geometry.root file
   
-  for (Int_t mod=0;mod<10;mod++)
+  for (Int_t mod=0;mod<12;mod++)
   {
     //((TGeoHMatrix*) mobj->At(mod))->Print();
     clusterize->SetGeometryMatrixInSM(matrix[mod],mod);
index 8d083b33fec8b045a43be13a4711fa426b755fa3..27b3479ab0bb97c20d7299ffba063e7268cd38fe 100644 (file)
@@ -35,7 +35,7 @@ AliAnalysisTaskEMCALTriggerQA * AddTaskEMCALTriggerQA(TString outputFile = "", B
         reco->SwitchOnBadChannelsRemoval();
         printf("*** EMCAL trigger QA: REMOVE bad cells \n");
         
-        for (Int_t i=0; i<10; ++i) {
+        for (Int_t i=0; i<12; ++i) {
           TH2I *hbm = reco->GetEMCALChannelStatusMap(i);
           if (hbm)
             delete hbm;
diff --git a/PWGGA/EMCALTasks/macros/AddTaskESDFilterEMCALEventSelect.C b/PWGGA/EMCALTasks/macros/AddTaskESDFilterEMCALEventSelect.C
new file mode 100644 (file)
index 0000000..8098498
--- /dev/null
@@ -0,0 +1,389 @@
+
+Bool_t AddTrackCutsLHC10h(AliAnalysisTaskESDfilter* esdFilter);
+Bool_t AddTrackCutsLHC11h(AliAnalysisTaskESDfilter* esdFilter);
+Bool_t enableTPCOnlyAODTracksLocalFlag=kFALSE;
+
+
+AliAnalysisTaskESDfilter *AddTaskESDFilterEMCALEventSelect(Float_t energyCut = 10,     // EMCAL
+                                                           Int_t   ncellsCut = 2,      // EMCAL
+                                                           Int_t   runNumber = 170000, // EMCAL
+                                                           Bool_t  useKineFilter=kTRUE, 
+                                                           Int_t   tofTimeZeroType=AliESDpid::kTOF_T0,
+                                                           Bool_t  enableTPCOnlyAODTracks=kFALSE,
+                                                           Bool_t  disableCascades=kFALSE,
+                                                           Bool_t  disableKinks=kFALSE, 
+                                                           Int_t   runFlag = 1100)
+{
+  // Creates a filter task and adds it to the analysis manager.
+  // Get the pointer to the existing analysis manager via the static access method.
+  //==============================================================================
+  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+  if (!mgr) {
+    ::Error("AddTaskESDFilter", "No analysis manager to connect to.");
+    return NULL;
+  }   
+  
+  // This task requires an ESD input handler and an AOD output handler.
+  // Check this using the analysis manager.
+  //===============================================================================
+  TString type = mgr->GetInputEventHandler()->GetDataType();
+  if (!type.Contains("ESD")) {
+    ::Error("AddTaskESDFilter", "ESD filtering task needs the manager to have an ESD input handler.");
+    return NULL;
+  }   
+  // Check if AOD output handler exist.
+  AliAODHandler *aod_h = (AliAODHandler*)mgr->GetOutputEventHandler();
+  if (!aod_h) {
+    ::Error("AddTaskESDFilter", "ESD filtering task needs the manager to have an AOD output handler.");
+    return NULL;
+  }
+  // Check if MC handler is connected in case kine filter requested
+  AliMCEventHandler *mcH = (AliMCEventHandler*)mgr->GetMCtruthEventHandler();
+  if (!mcH && useKineFilter) {
+    ::Error("AddTaskESDFilter", "No MC handler connected while kine filtering requested");
+    return NULL;
+  }   
+  
+  // Create the task, add it to the manager and configure it.
+  //===========================================================================   
+  AliAnalysisTaskESDfilterEMCALEventSelect *esdfilter = new AliAnalysisTaskESDfilterEMCALEventSelect("ESD Filter : EMCAL event select");
+  
+  esdfilter->DisableZDC();
+  esdfilter->DisablePmdClusters();
+  
+  // EMCAL settings
+  esdfilter->SetEnergyCut(energyCut);
+  esdfilter->SetNcellsCut(ncellsCut);
+  
+  AliEMCALRecoUtils * reco = esdfilter->GetRecoUtils();
+  reco->SwitchOnRejectExoticCluster();
+  
+  // Pass the bad channels, need to access run number
+  TString fileName="$ALICE_ROOT/OADB/EMCAL/EMCALBadChannels.root";
+  AliOADBContainer *contBC=new AliOADBContainer("");
+  contBC->InitFromFile((char*)fileName.Data(),"AliEMCALBadChannels"); 
+  TObjArray *arrayBC=(TObjArray*)contBC->GetObject(runNumber); 
+  if(arrayBC){
+    TObjArray *arrayBCpass=(TObjArray*)arrayBC->FindObject("pass1");
+    if(arrayBCpass){
+      
+      reco->SwitchOnBadChannelsRemoval();
+      printf("*** EMCAL RecoUtils : REMOVE bad cells \n");
+      
+      for (Int_t i=0; i<10; ++i) {
+        TH2I *hbm = reco->GetEMCALChannelStatusMap(i);
+        if (hbm)
+          delete hbm;
+        hbm=(TH2I*)arrayBCpass->FindObject(Form("EMCALBadChannelMap_Mod%d",i));
+        
+        if (!hbm) {
+          AliError(Form("Can not get EMCALBadChannelMap_Mod%d",i));
+          continue;
+        }
+        
+        hbm->SetDirectory(0);
+        reco->SetEMCALChannelStatusMap(i,hbm);
+      }
+    } else printf("AliEMCALRecoUtils ---Do NOT remove bad channels 1\n");
+  }  else  printf("AliEMCALRecoUtils ---Do NOT remove bad channels 2\n");
+    
+  // From here keep sync with $ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C
+  
+  esdfilter->SetTimeZeroType(tofTimeZeroType);
+  if  (disableCascades) esdfilter->DisableCascades();
+  if  (disableKinks)    esdfilter->DisableKinks();
+  
+  mgr->AddTask(esdfilter);
+  
+  // Filtering of MC particles (decays conversions etc)
+  // this task has to go AFTER all other filter tasks
+  // since it fills the AODMC array with all
+  // selected MC Particles, only this way we have the 
+  // AODMCparticle information available for following tasks
+  AliAnalysisTaskMCParticleFilter *kinefilter = 0;
+  if (useKineFilter) {
+    kinefilter = new AliAnalysisTaskMCParticleFilter("Particle Kine Filter");
+    mgr->AddTask(kinefilter);
+  }   
+  
+  enableTPCOnlyAODTracksLocalFlag = enableTPCOnlyAODTracks;
+  if((runFlag/100)==10){
+    AddTrackCutsLHC10h(esdfilter);
+  }
+  else {
+    // default 11h
+    AddTrackCutsLHC11h(esdfilter);
+  }
+  
+  // Filter with cuts on V0s
+  AliESDv0Cuts*   esdV0Cuts = new AliESDv0Cuts("Standard V0 Cuts pp", "ESD V0 Cuts");
+  esdV0Cuts->SetMinRadius(0.2);
+  esdV0Cuts->SetMaxRadius(200);
+  esdV0Cuts->SetMinDcaPosToVertex(0.05);
+  esdV0Cuts->SetMinDcaNegToVertex(0.05);
+  esdV0Cuts->SetMaxDcaV0Daughters(1.5);
+  esdV0Cuts->SetMinCosinePointingAngle(0.99);
+  AliAnalysisFilter* v0Filter = new AliAnalysisFilter("v0Filter");
+  v0Filter->AddCuts(esdV0Cuts);
+  
+  esdfilter->SetV0Filter(v0Filter);
+  
+  // Create ONLY the output containers for the data produced by the task.
+  // Get and connect other common input/output containers via the manager as below
+  //==============================================================================
+  mgr->ConnectInput  (esdfilter,  0, mgr->GetCommonInputContainer());
+  mgr->ConnectOutput (esdfilter,  0, mgr->GetCommonOutputContainer());
+  if (useKineFilter) {
+    mgr->ConnectInput  (kinefilter,  0, mgr->GetCommonInputContainer());
+    mgr->ConnectOutput (kinefilter,  0, mgr->GetCommonOutputContainer());
+    AliAnalysisDataContainer *coutputEx = mgr->CreateContainer("cFilterList", TList::Class(),
+                                                               AliAnalysisManager::kOutputContainer,"pyxsec_hists.root");
+    mgr->ConnectOutput (kinefilter,  1,coutputEx);
+  }   
+  return esdfilter;
+}
+
+
+
+
+Bool_t AddTrackCutsLHC10h(AliAnalysisTaskESDfilter* esdfilter){
+  
+  Printf("%s%d: Creating Track Cuts for LH10h",(char*)__FILE__,__LINE__);
+  
+  // Cuts on primary tracks
+  AliESDtrackCuts* esdTrackCutsL = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
+  
+  // ITS stand-alone tracks
+  AliESDtrackCuts* esdTrackCutsITSsa = new AliESDtrackCuts("ITS stand-alone Track Cuts", "ESD Track Cuts");
+  esdTrackCutsITSsa->SetRequireITSStandAlone(kTRUE);
+  
+  // Pixel OR necessary for the electrons
+  AliESDtrackCuts *itsStrong = new AliESDtrackCuts("ITSorSPD", "pixel requirement for ITS");
+  itsStrong->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
+  
+  
+  // PID for the electrons
+  AliESDpidCuts *electronID = new AliESDpidCuts("Electrons", "Electron PID cuts");
+  electronID->SetTPCnSigmaCut(AliPID::kElectron, 3.);
+  
+  // tighter cuts on primary particles for high pT tracks
+  // take the standard cuts, which include already 
+  // ITSrefit and use only primaries...
+  
+  // ITS cuts for new jet analysis 
+  //  gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/CreateTrackCutsPWGJE.C");
+  //  AliESDtrackCuts* esdTrackCutsHG0 = CreateTrackCutsPWGJE(10001006);
+  
+  AliESDtrackCuts *jetCuts1006 = new AliESDtrackCuts("AliESDtrackCuts"); 
+  
+  TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.*x");
+  jetCuts1006->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep,20.);
+  jetCuts1006->SetMinNClustersTPC(70);
+  jetCuts1006->SetMaxChi2PerClusterTPC(4);
+  jetCuts1006->SetRequireTPCStandAlone(kTRUE); //cut on NClustersTPC and chi2TPC Iter1
+  jetCuts1006->SetAcceptKinkDaughters(kFALSE);
+  jetCuts1006->SetRequireTPCRefit(kTRUE);
+  jetCuts1006->SetMaxFractionSharedTPCClusters(0.4);
+  // ITS
+  jetCuts1006->SetRequireITSRefit(kTRUE);
+  //accept secondaries
+  jetCuts1006->SetMaxDCAToVertexXY(2.4);
+  jetCuts1006->SetMaxDCAToVertexZ(3.2);
+  jetCuts1006->SetDCAToVertex2D(kTRUE);
+  //reject fakes
+  jetCuts1006->SetMaxChi2PerClusterITS(36);
+  jetCuts1006->SetMaxChi2TPCConstrainedGlobal(36);
+  
+  jetCuts1006->SetRequireSigmaToVertex(kFALSE);
+  
+  jetCuts1006->SetEtaRange(-0.9,0.9);
+  jetCuts1006->SetPtRange(0.15, 1E+15.);
+  
+  AliESDtrackCuts* esdTrackCutsHG0 = jetCuts1006->Clone("JetCuts10001006");
+  esdTrackCutsHG0->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
+  
+  
+  // throw out tracks with too low number of clusters in
+  // the first pass (be consistent with TPC only tracks)
+  // N.B. the number off crossed rows still acts on the tracks after
+  // all iterations if we require tpc standalone, number of clusters
+  // and chi2 TPC cuts act on track after the first iteration
+  //   esdTrackCutsH0->SetRequireTPCStandAlone(kTRUE);
+  //   esdTrackCutsH0->SetMinNClustersTPC(80); // <--- first pass
+  
+  
+  // the complement to the one with SPD requirement
+  //  AliESDtrackCuts* esdTrackCutsHG1 = CreateTrackCutsPWGJE(10011006);
+  AliESDtrackCuts* esdTrackCutsHG1 = jetCuts1006->Clone("JetCuts10011006");
+  esdTrackCutsHG1->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kNone);
+  
+  // the tracks that must not be taken pass this cut and
+  // non HGC1 and HG
+  //  AliESDtrackCuts* esdTrackCutsHG2 = CreateTrackCutsPWGJE(10021006);
+  AliESDtrackCuts* esdTrackCutsHG2 = jetCuts1006->Clone("JetCuts10021006");
+  esdTrackCutsHG2->SetMaxChi2PerClusterITS(1E10);
+  
+  
+  // standard cuts also used in R_AA analysis
+  //   "Global track RAA analysis QM2011 + Chi2ITS<36";
+  //  AliESDtrackCuts* esdTrackCutsH2 = CreateTrackCutsPWGJE(1000);
+  AliESDtrackCuts* esdTrackCutsH2 = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE,1);
+  esdTrackCutsH2->SetMinNCrossedRowsTPC(120);
+  esdTrackCutsH2->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
+  esdTrackCutsH2->SetMaxChi2PerClusterITS(36);
+  esdTrackCutsH2->SetMaxFractionSharedTPCClusters(0.4);
+  esdTrackCutsH2->SetMaxChi2TPCConstrainedGlobal(36);
+  
+  esdTrackCutsH2->SetEtaRange(-0.9,0.9);
+  esdTrackCutsH2->SetPtRange(0.15, 1e10);
+  
+  
+  //  AliESDtrackCuts* esdTrackCutsGCOnly = CreateTrackCutsPWGJE(10041006);
+  AliESDtrackCuts* esdTrackCutsGCOnly = jetCuts1006->Clone("JetCuts10041006");
+  esdTrackCutsGCOnly->SetRequireITSRefit(kFALSE);
+  
+  
+  
+  // TPC only tracks
+  AliESDtrackCuts* esdTrackCutsTPCCOnly = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
+  esdTrackCutsTPCCOnly->SetMinNClustersTPC(70);
+  
+  // Compose the filter
+  AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
+  // 1, 1<<0
+  trackFilter->AddCuts(esdTrackCutsL);
+  // 2 1<<1
+  trackFilter->AddCuts(esdTrackCutsITSsa);
+  // 4 1<<2
+  trackFilter->AddCuts(itsStrong);
+  itsStrong->SetFilterMask(1);        // AND with Standard track cuts 
+  // 8 1<<3
+  trackFilter->AddCuts(electronID);
+  electronID->SetFilterMask(4);       // AND with Pixel Cuts
+  // 16 1<<4
+  trackFilter->AddCuts(esdTrackCutsHG0);
+  // 32 1<<5
+  trackFilter->AddCuts(esdTrackCutsHG1);
+  // 64 1<<6
+  trackFilter->AddCuts(esdTrackCutsHG2);
+  // 128 1<<7
+  trackFilter->AddCuts(esdTrackCutsTPCCOnly); // add QM TPC only track cuts
+  if(enableTPCOnlyAODTracksLocalFlag)esdfilter->SetTPCOnlyFilterMask(128);
+  // 256 1<<8
+  trackFilter->AddCuts(esdTrackCutsGCOnly);
+  // 512 1<<9                         
+  AliESDtrackCuts* esdTrackCutsHG1_tmp = new AliESDtrackCuts(*esdTrackCutsHG1); // avoid double delete
+  trackFilter->AddCuts(esdTrackCutsHG1_tmp); // add once more for tpc only tracks
+  // 1024 1<<10                        
+  trackFilter->AddCuts(esdTrackCutsH2); // add r_aa cuts
+  
+  
+  
+  esdfilter->SetGlobalConstrainedFilterMask(1<<8|1<<9); // these tracks are written out as global constrained tracks
+  esdfilter->SetHybridFilterMaskGlobalConstrainedGlobal((1<<4)); // these normal global tracks will be marked as hybrid
+  esdfilter->SetWriteHybridGlobalConstrainedOnly(kTRUE); // write only the complement
+  //     esdfilter->SetTPCConstrainedFilterMask(1<<11); // these tracks are written out as tpc constrained tracks
+  
+  esdfilter->SetTrackFilter(trackFilter);
+  return kTRUE;
+  
+}
+
+
+
+Bool_t AddTrackCutsLHC11h(AliAnalysisTaskESDfilter* esdfilter){
+  
+  
+  Printf("%s%d: Creating Track Cuts LHC11h",(char*)__FILE__,__LINE__);
+  
+  // Cuts on primary tracks
+  AliESDtrackCuts* esdTrackCutsL = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
+  
+  // ITS stand-alone tracks
+  AliESDtrackCuts* esdTrackCutsITSsa = new AliESDtrackCuts("ITS stand-alone Track Cuts", "ESD Track Cuts");
+  esdTrackCutsITSsa->SetRequireITSStandAlone(kTRUE);
+  
+  // Pixel OR necessary for the electrons
+  AliESDtrackCuts *itsStrong = new AliESDtrackCuts("ITSorSPD", "pixel requirement for ITS");
+  itsStrong->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
+  
+  
+  // PID for the electrons
+  AliESDpidCuts *electronID = new AliESDpidCuts("Electrons", "Electron PID cuts");
+  electronID->SetTPCnSigmaCut(AliPID::kElectron, 3.);
+  
+  // standard cuts with very loose DCA
+  AliESDtrackCuts* esdTrackCutsH = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE); 
+  esdTrackCutsH->SetMaxDCAToVertexXY(2.4);
+  esdTrackCutsH->SetMaxDCAToVertexZ(3.2);
+  esdTrackCutsH->SetDCAToVertex2D(kTRUE);
+  
+  // standard cuts with tight DCA cut
+  AliESDtrackCuts* esdTrackCutsH2 = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011();
+  
+  // standard cuts with tight DCA but with requiring the first SDD cluster instead of an SPD cluster
+  // tracks selected by this cut are exclusive to those selected by the previous cut
+  AliESDtrackCuts* esdTrackCutsH3 = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(); 
+  esdTrackCutsH3->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kNone);
+  esdTrackCutsH3->SetClusterRequirementITS(AliESDtrackCuts::kSDD, AliESDtrackCuts::kFirst);
+  
+  // TPC only tracks: Optionally enable the writing of TPConly information
+  // constrained to SPD vertex in the filter below
+  AliESDtrackCuts* esdTrackCutsTPCOnly = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
+  // The following line is needed for 2010 PbPb reprocessing and pp, but not for 2011 PbPb
+  //esdTrackCutsTPCOnly->SetMinNClustersTPC(70);
+  
+  // Extra cuts for hybrids
+  // first the global tracks we want to take
+  AliESDtrackCuts* esdTrackCutsHTG = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE); 
+  esdTrackCutsHTG->SetName("Global Hybrid tracks, loose DCA");
+  esdTrackCutsHTG->SetMaxDCAToVertexXY(2.4);
+  esdTrackCutsHTG->SetMaxDCAToVertexZ(3.2);
+  esdTrackCutsHTG->SetDCAToVertex2D(kTRUE);
+  esdTrackCutsHTG->SetMaxChi2TPCConstrainedGlobal(36);
+  
+  // Than the complementary tracks which will be stored as global
+  // constraint, complement is done in the ESDFilter task
+  AliESDtrackCuts* esdTrackCutsHTGC = new AliESDtrackCuts(*esdTrackCutsHTG);
+  esdTrackCutsHTGC->SetName("Global Constraint Hybrid tracks, loose DCA no it requirement");
+  esdTrackCutsHTGC->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kOff);
+  esdTrackCutsHTGC->SetRequireITSRefit(kFALSE);
+  
+  // standard cuts with tight DCA cut, using cluster cut instead of crossed rows (a la 2010 default)
+  AliESDtrackCuts* esdTrackCutsH2Cluster = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kTRUE, 0);
+  
+  // Compose the filter
+  AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
+  // 1, 1<<0
+  trackFilter->AddCuts(esdTrackCutsL);
+  // 2, 1<<1
+  trackFilter->AddCuts(esdTrackCutsITSsa);
+  // 4, 1<<2
+  trackFilter->AddCuts(itsStrong);
+  itsStrong->SetFilterMask(1);        // AND with Standard track cuts 
+  // 8, 1<<3
+  trackFilter->AddCuts(electronID);
+  electronID->SetFilterMask(4);       // AND with Pixel Cuts
+  // 16, 1<<4
+  trackFilter->AddCuts(esdTrackCutsH);
+  // 32, 1<<5
+  trackFilter->AddCuts(esdTrackCutsH2);
+  // 64, 1<<6
+  trackFilter->AddCuts(esdTrackCutsH3);
+  // 128 , 1 << 7
+  trackFilter->AddCuts(esdTrackCutsTPCOnly);
+  if(enableTPCOnlyAODTracksLocalFlag)esdfilter->SetTPCOnlyFilterMask(128);
+  // 256, 1 << 8 Global Hybrids
+  trackFilter->AddCuts(esdTrackCutsHTG);
+  esdfilter->SetHybridFilterMaskGlobalConstrainedGlobal((1<<8)); // these normal global tracks will be marked as hybrid    
+  // 512, 1<< 9 GlobalConstraint Hybrids
+  trackFilter->AddCuts(esdTrackCutsHTGC);
+  esdfilter->SetGlobalConstrainedFilterMask(1<<9); // these tracks are written out as global constrained tracks 
+  esdfilter->SetWriteHybridGlobalConstrainedOnly(kTRUE); // write only the complement
+  // 1024, 1<< 10
+  trackFilter->AddCuts(esdTrackCutsH2Cluster);
+  esdfilter->SetTrackFilter(trackFilter);
+  
+  return kTRUE;
+  
+}
index 2441e0b753f7fde9ef204d7dc3c24a88b65d7d61..f3d90a8f981de205d0f61631b17f0fa8c671199d 100644 (file)
@@ -2,7 +2,7 @@
 void ConfigureEMCALRecoUtils(
                              AliEMCALRecoUtils* reco,
                              Bool_t  bMC   = kFALSE,
-                             TGeoHMatrix* matrix[10],
+                             TGeoHMatrix* matrix[12],
                              TString path  = "",
                              Int_t   run   = 0, 
                              TString pass  = "pass2",
@@ -32,8 +32,9 @@ void ConfigureEMCALRecoUtils(
   // Instantiate EMCAL geometry for the first time
   
   AliEMCALGeometry*   geom = 0; 
-  if   (run < 140000) geom = AliEMCALGeometry::GetInstance("EMCAL_FIRSTYEARV1");
-  else                geom = AliEMCALGeometry::GetInstance("EMCAL_COMPLETEV1");
+  if     (run < 140000) geom = AliEMCALGeometry::GetInstance("EMCAL_FIRSTYEARV1");
+  else if(run < 171000) geom = AliEMCALGeometry::GetInstance("EMCAL_COMPLETEV1");
+  else                  geom = AliEMCALGeometry::GetInstance("EMCAL_COMPLETE12SMV1");
 
   Int_t nSM = geom->GetNumberOfSuperModules();
 
@@ -99,7 +100,7 @@ void ConfigureEMCALRecoUtils(
     }else printf("AliEMCALRecoUtils ---Do NOT recalibrate 3\n");
     
     //TFile * f = new TFile("RecalibrationFactors.root","read");
-    //for(Int_t i =0; i< 10; i++)  reco->SetEMCALChannelRecalibrationFactors( i, (TH2F*) f->Get(Form("EMCALRecalFactors_SM%d",i)));                                                                     
+    //for(Int_t i =0; i< 12; i++)  reco->SetEMCALChannelRecalibrationFactors( i, (TH2F*) f->Get(Form("EMCALRecalFactors_SM%d",i)));                                                                     
     // //  reco->SwitchOnTimeDepCorrection();
     // //  //char cmd[200] ; 
     // //  //sprintf(cmd, ".!tar xvfz CorrectionFiles.tgz") ; 
index d155d57d923ac8e7992764c356cb79b78c8cf963..0836c1facf4d2d364698209addbdbddf26fa0b90 100644 (file)
@@ -10,6 +10,7 @@
 #pragma link C++ class AliAnalysisTaskEMCALPi0PbPb+;
 #pragma link C++ class AliAnalysisTaskEMCALPi0PbPb+;
 #pragma link C++ class AliAnalysisTaskEMCALTriggerQA+;
+#pragma link C++ class AliAnalysisTaskESDfilterEMCALEventSelect+;
 #pragma link C++ class AliEmcalEsdTpcTrackTask+;
 #pragma link C++ class AliEmcalPhysicsSelection+;
 #pragma link C++ class AliEmcalPhysicsSelectionTask+;