AliAnalysisTaskCaloFilter.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKCALOFILTER_H
#define ALIANALYSISTASKCALOFILTER_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

//_________________________________________________________________________
//_________________________________________________________________________

#include "AliAnalysisTaskSE.h"
class AliEMCALRecoUtils;
class AliEMCALGeometry;
class AliESDEvent;
class AliAODEvent;

class AliAnalysisTaskCaloFilter : public AliAnalysisTaskSE
{
 public:
  
  AliAnalysisTaskCaloFilter();
  AliAnalysisTaskCaloFilter(const char* name);
  virtual ~AliAnalysisTaskCaloFilter() ;
    
  // * General analysis frame methods *
  
  virtual void   UserCreateOutputObjects();
  virtual void   Init();
  virtual void   LocalInit() { Init() ; }
  virtual void   UserExec(Option_t *option);
        
  // * Task own methods *
  
  Bool_t  AcceptEvent() ;
  
  Bool_t  AcceptEventEMCAL();

  Bool_t  AcceptEventPHOS();
  
  Bool_t  AcceptEventTrack();
  
  Bool_t  AcceptEventVertex();
  
  Bool_t  CheckForPrimaryVertex();
  Bool_t  CheckForPrimaryVertexInESDs();
  Bool_t  CheckForPrimaryVertexInAODs();
  
  void    CorrectionsInEMCAL();
  
  void    FillAODHeader();

  void    FillAODCaloCells();
  
  void    FillAODCaloClusters();
  
  void    FillAODCaloTrigger();

  void    FillAODMCParticles();
  
  void    FillAODTracks();

  void    FillAODv0s();
  
  void    FillAODVertices();
  
  void    FillAODVZERO();
  
  void    PrintInfo();
  
  // * Task settings *
  
  // 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      ; }
    
  void    SwitchOnCheckEventPrimaryVertex()       { fCheckEventVertex = kTRUE   ; }
  void    SwitchOffCheckEventPrimaryVertex()      { fCheckEventVertex = kFALSE  ; }

  void    SwitchOnFillAODFile()                   { fFillAODFile = kTRUE        ; }
  void    SwitchOffFillAODFile()                  { fFillAODFile = kFALSE       ; }

  void    SwitchOnFillMCParticles()               { fFillMCParticles = kTRUE    ; }
  void    SwitchOffFillMCParticles()              { fFillMCParticles = kFALSE   ; }
  
  void    SwitchOnFillTracks()                    { fFillTracks  = kTRUE        ; }
  void    SwitchOffFillTracks()                   { fFillTracks  = kFALSE       ; }
  
  void    SwitchOnFillHybridTracks()              { fFillTracks  = kTRUE        ;
                                                    fFillHybridTracks  = kTRUE  ; }
  void    SwitchOffFillHybridTracks()             { fFillHybridTracks  = kFALSE ; }
  
  void    SwitchOnFillv0s()                       { fFillv0s     = kTRUE        ; }
  void    SwitchOffFillv0s()                      { fFillv0s     = kFALSE       ; }
  
  void    SwitchOnFillVZERO()                     { fFillVZERO   = kTRUE        ; }
  void    SwitchOffFillVZERO()                    { fFillVZERO   = kFALSE       ; }
  
  void    SwitchOnFillAllVertices()               { fFillAllVertices = kTRUE    ; }
  void    SwitchOffFillAllVertices()              { fFillAllVertices = kFALSE   ; }
  
  enum    caloFilter { kBoth = 0, kEMCAL = 1, kPHOS = 2 } ;
  
  void    SetCaloFilter(Int_t calo)               { fCaloFilter = calo          ; }
  TString GetCaloFilter()                  const  { return fCaloFilter          ; }  

  void    SetEventSelection(Bool_t emcal, Bool_t phos, Bool_t track) {
    fEventSelection[0] = emcal ; fEventSelection[1] = phos ; fEventSelection[2] = track ; }
  
  void    SwitchOnAcceptAllMBEvent()              { fAcceptAllMBEvent = kTRUE   ; }
  void    SwitchOffAcceptAllMBEvent()             { fAcceptAllMBEvent = kFALSE  ; }

  void    SetMBTriggerMask(UInt_t mask)           { fMBTriggerMask    = mask    ; }
  
  void    SetEMCALRecoUtils(AliEMCALRecoUtils* ru){ fEMCALRecoUtils = ru        ; }
  AliEMCALRecoUtils* GetEMCALRecoUtils()   const  { return fEMCALRecoUtils      ; }

  void    SwitchOnClusterCorrection()             { fCorrect = kTRUE            ; }
  void    SwitchOffClusterCorrection()            { fCorrect = kFALSE           ; }
  
  void    SetConfigFileName(TString name)         { fConfigName = name          ; }
  
  void    SetEMCALEnergyCut(Float_t cut)          { fEMCALEnergyCut = cut       ; }
  Float_t GetEMCALEnergyCut()               const { return fEMCALEnergyCut      ; }
  void    SetEMCALNcellsCut(Int_t cut)            { fEMCALNcellsCut = cut       ; }
  Int_t   GetEMCALNcellsCut()               const { return fEMCALNcellsCut      ; }
  
  void    SetPHOSEnergyCut(Float_t cut)           { fPHOSEnergyCut = cut        ; }
  Float_t GetPHOSEnergyCut()                const { return fPHOSEnergyCut       ; }
  void    SetPHOSNcellsCut(Int_t cut)             { fPHOSNcellsCut = cut        ; }
  Int_t   GetPHOSNcellsCut()                const { return fPHOSNcellsCut       ; }
  
  void    SetTrackPtCut(Float_t cut)              { fTrackPtCut = cut           ; }
  Float_t GetTrackPtCut()                   const { return fTrackPtCut          ; }
  
  void    SetVzCut(Float_t cut)                   { fVzCut = cut                ; }
  Float_t GetVzCut()                        const { return fVzCut               ; }
  
  
private:
    
  Int_t               fCaloFilter;        
  Bool_t              fEventSelection[3]; 
  Bool_t              fAcceptAllMBEvent;  
  UInt_t              fMBTriggerMask;     
  Int_t               fCorrect;           
  
  //EMCAL specific
  AliEMCALGeometry  * fEMCALGeo;          
  TString             fEMCALGeoName;      
  AliEMCALRecoUtils * fEMCALRecoUtils;    
  
  //Geometry
  Bool_t              fLoadEMCALMatrices; 
  TGeoHMatrix       * fEMCALMatrix[22];   
  //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;      
  
  TString             fConfigName;        
  
  Bool_t              fFillAODFile;       
  Bool_t              fFillMCParticles;   
  Bool_t              fFillTracks;        
  Bool_t              fFillHybridTracks;  

  Bool_t              fFillAllVertices;   
  Bool_t              fFillv0s;           
  Bool_t              fFillVZERO;         

  Float_t             fEMCALEnergyCut;    
  Int_t               fEMCALNcellsCut;    

  Float_t             fPHOSEnergyCut;     
  Int_t               fPHOSNcellsCut;     
  
  Float_t             fTrackPtCut;        
  
  Float_t             fVzCut;             
  
  Bool_t              fCheckEventVertex;  

  AliVEvent*          fEvent;             
  AliESDEvent*        fESDEvent;          
  AliAODEvent*        fAODEvent;          
  
  AliAnalysisTaskCaloFilter(           const AliAnalysisTaskCaloFilter&) ;
    
  AliAnalysisTaskCaloFilter& operator=(const AliAnalysisTaskCaloFilter&) ;
  
  ClassDef(AliAnalysisTaskCaloFilter, 12) ;

};

#endif