AliAnalysisTaskEMCALClusterize.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKEMCALCLUSTERIZE_H
#define ALIANALYSISTASKEMCALCLUSTERIZE_H

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

//_________________________________________________________________________
//_________________________________________________________________________

// Root
class TTree;
class TClonesArray;
#include <TRandom3.h>

// EMCAL
class AliEMCALGeometry;
class AliEMCALClusterizer;
class AliEMCALAfterBurnerUF;
class AliEMCALRecPoint;
class AliAODCaloCluster;
class AliCentrality;
class AliMultSelection;
class AliVCaloCells;

#include "AliEMCALRecParam.h"
#include "AliEMCALRecoUtils.h"

#include "AliAnalysisTaskSE.h"

class AliAnalysisTaskEMCALClusterize : public AliAnalysisTaskSE {
    
 public:
    
  AliAnalysisTaskEMCALClusterize();
  AliAnalysisTaskEMCALClusterize(const char *name);
  virtual ~AliAnalysisTaskEMCALClusterize();

  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Init();
  virtual void   LocalInit()                                   { Init()                        ; }
  void           PrintParam();
  
  // Event methods, settings
  
  Bool_t         AcceptCell(Int_t absID, Bool_t badmap = kTRUE);
  Bool_t         AcceptEventEMCAL();
  void           SwitchOnSelectEMCALEvent()                    { fSelectEMCALEvent   = kTRUE   ; }
  void           SwitchOffSelectEMCALEvent()                   { fSelectEMCALEvent   = kFALSE  ; }
  void           SetEMCALEnergyCut(Float_t cut)                { fEMCALEnergyCut     = cut     ; }
  void           SetEMCALNcellsCut(Int_t cut)                  { fEMCALNcellsCut     = cut     ; }

  void           SwitchOnInputAODFilter()                      { fInputFromFilter    = kTRUE   ; }
  void           SwitchOffInputAODFilter()                     { fInputFromFilter    = kFALSE  ; }
  
  void           CheckAndGetEvent();
  
  Bool_t         IsExoticEvent();
  void           SwitchOnExoticEventsRemoval()                  { fRemoveExoticEvents= kTRUE   ; }
  void           SwitchOffExoticEventsRemoval()                 { fRemoveExoticEvents= kFALSE  ; } 
  
  Bool_t         IsLEDEvent(const Int_t run);
  void           SwitchOnLEDEventsRemoval()                     { fRemoveLEDEvents   = kTRUE   ; }
  void           SwitchOffLEDEventsRemoval()                    { fRemoveLEDEvents   = kFALSE  ; } 
  
  // OCDB, avoid acessing OCDB!
    
  void           AccessOCDB();
  void           SwitchOnAccessOCDB()                           { fAccessOCDB       = kTRUE    ; }
  void           SwitchOffAccessOCDB()                          { fAccessOCDB       = kFALSE   ; } 
  void           SetOCDBPath(const char *path)                  { fOCDBpath         = path     ; }
  
  // Geometry methods
    
  void           InitGeometry();
  void           SetGeometryName(TString name)                  { fGeomName = name             ; }
  TString        GeometryName()                          const  { return fGeomName             ; }  
  void           SwitchOnLoadOwnGeometryMatrices()              { fLoadGeomMatrices = kTRUE    ; }
  void           SwitchOffLoadOwnGeometryMatrices()             { fLoadGeomMatrices = kFALSE   ; } 
  void           SetGeometryMatrixInSM(TGeoHMatrix* m, Int_t i) { fGeomMatrix[i]    = m        ; }

  void           SetImportGeometryFromFile(Bool_t  im, 
                                           TString pa = "")     { fImportGeometryFromFile = im ; 
                                                                  fImportGeometryFilePath = pa ; }    
  // Outout AOD branch methods
    
  void           SetAODBranchName(TString name)                 { fOutputAODBranchName = name  ; }
  void           SetAODCellsName(TString name)                  { fOutputAODCellsName  = name  ; }
  void           SetInputCaloCellsName(TString name)            { fInputCaloCellsName  = name  ; }
  void           FillAODFile(Bool_t yesno)                      { fFillAODFile         = yesno ; }
  void           FillAODCaloCells();
  void           FillAODHeader();
  void           SwitchOnFillAODHeader()                        { fFillAODHeader     = kTRUE   ; }
  void           SwitchOffFillAODHeader()                       { fFillAODHeader     = kFALSE  ; } 
  void           SwitchOnFillAODCaloCells()                     { fFillAODCaloCells  = kTRUE   ; }
  void           SwitchOffFillAODCaloCells()                    { fFillAODCaloCells  = kFALSE  ; } 

  void           SwitchOnRecalibrateWithClusterTime()           { fRecalibrateWithClusterTime  = kTRUE   ; }
  void           SwitchOffRecalibrateWithClusterTime()          { fRecalibrateWithClusterTime  = kFALSE  ; }
  
  // Algorithms settings
  
  AliEMCALRecParam * GetRecParam()                              { if(!fRecParam)  fRecParam  = new AliEMCALRecParam  ;
                                                                  return fRecParam             ; }
  
  AliEMCALRecoUtils* GetRecoUtils()                             { if(!fRecoUtils) fRecoUtils = new AliEMCALRecoUtils ;  
                                                                  return fRecoUtils            ; }
  void          ConfigureEMCALRecoUtils(Bool_t  bMC    = kFALSE, Bool_t  bExotic= kTRUE, Bool_t  bNonLin= kFALSE,  
                                        Bool_t  bRecalE= kTRUE , Bool_t  bBad   = kTRUE, Bool_t  bRecalT= kTRUE, Int_t   debug  = -1);
  
  void           InitClusterization();
  void           ClusterizeCells();
  void           ClusterUnfolding();
  void           JustUnfold(Bool_t yesno)                       { fJustUnfold        = yesno   ; }
  void           UpdateCells();
  
  void           SetConfigFileName(TString name)                { fConfigName        = name    ; }
  void           SetMaxEvent(Int_t max)                         { fMaxEvent          = max     ; }
  void           SetMinEvent(Int_t max)                         { fMinEvent          = max     ; }
  
  void           SwitchOnTrackMatching()                        { fDoTrackMatching   = kTRUE   ; }
  void           SwitchOffTrackMatching()                       { fDoTrackMatching   = kFALSE  ; } 

  void           SwitchOnUpdateCell()                           { fUpdateCell        = kTRUE   ; } 
  void           SwitchOffUpdateCell()                          { fUpdateCell        = kFALSE  ; }  

  // Cell selection after unfolding
    
  void           SwitchOnCellEnergySelection()                  { fSelectCell        = kTRUE   ; }
  void           SwitchOffCellEnergySelection()                 { fSelectCell        = kFALSE  ; } 
  void           SetCellCuts(Float_t e, Float_t frac)           { fSelectCellMinE    = e       ; 
                                                                  fSelectCellMinFrac = frac    ; }
  void           SetRejectBelowThreshold(Bool_t reject)         { fRejectBelowThreshold =reject ; }
    
  // OADB options settings
  
  void           AccessOADB() ;
  
  TString        GetPass()    ;
  
  void           SwitchOnEMCALOADB()                            { fAccessOADB        = kTRUE   ; }
  void           SwitchOffEMCALOADB()                           { fAccessOADB        = kFALSE  ; }
    
  void           SetOADBFilePath(TString path)                  { fOADBFilePath      = path    ; }
  
  void           SetConstantTimeShift(Float_t shift)            { fConstantTimeShift = shift   ; }

  // Centrality selection
  
  AliCentrality* GetCentrality()                          const { return InputEvent()->GetCentrality() ; } 
  AliMultSelection* GetMultSelCen()                       const { return (AliMultSelection * ) InputEvent()->FindListObject("MultSelection") ; }
  void           SwitchOnAliCentrality ()                       { fUseAliCentrality  = kTRUE  ; }
  void           SwitchOffAliCentrality()                       { fUseAliCentrality  = kFALSE ; }
  
  void           SetCentralityClass(TString name)               { fCentralityClass   = name            ; }
  TString        GetCentralityClass()                     const { return fCentralityClass              ; }
  Float_t        GetEventCentrality()                     const ;
  void           SetCentralityBin(Int_t min, Int_t max) //Set the centrality bin to select the event. If used, then need to get percentile
                                                                { fCentralityBin[0]=min ; fCentralityBin[1]=max ; }
  Float_t        GetCentralityBin(Int_t i)                const { if(i < 0 || i > 1) return -1 ; 
                                                                  else               return fCentralityBin[i]   ; }
  
  // MC label properly assignation methods
  
  void           RemapMCLabelForAODs(Int_t &label);
  void           SwitchOnRemapMCLabelForAODs()                  { fRemapMCLabelForAODs       = kTRUE   ; }
  void           SwitchOffRemapMCLabelForAODs()                 { fRemapMCLabelForAODs       = kFALSE  ; }

  void           SetClustersMCLabelFrom2SelectedLabels(AliEMCALRecPoint* recPoint, AliAODCaloCluster *clus) ;
  void           SetClustersMCLabelFromOriginalClusters(AliAODCaloCluster * clus) ;
  
  void           SwitchOnUseClusterMCLabelForCell(Int_t opt = 0){ fSetCellMCLabelFromCluster = opt     ; }
  void           SwitchOffUseClusterMCLabelForCell()            { fSetCellMCLabelFromCluster = 0       ; }

  void           SwitchOnUseMCEdepFracLabelForCell()            { fSetCellMCLabelFromEdepFrac = kTRUE  ;  
                                                                   fSetCellMCLabelFromCluster = 0      ; }
  void           SwitchOffUseMCEdepFracLabelForCell()           { fSetCellMCLabelFromEdepFrac = kFALSE ; }
  
  //-----------------------------------------
  // T-Card correlation emulation, do on MC
  
  void           MakeCellTCardCorrelation() ;
  void           CalculateInducedEnergyInTCardCell(Int_t absId, Int_t absIdRef, Int_t sm, Float_t ampRef, Int_t cellCase) ;
  void           AddNewTCardInducedCellsToDigit() ;
  
  void           SwitchOnTCardCorrelation(Bool_t conservEnergy = kFALSE)  { fTCardCorrEmulation = kTRUE  ; fTCardCorrClusEnerConserv = conservEnergy ; }   
  
  void           SwitchOffTCardCorrelation()                              { fTCardCorrEmulation = kFALSE ; fTCardCorrClusEnerConserv = kFALSE        ; }      

  
  void           SetInducedEnergyLossConstant(Float_t ud, Float_t udlr, Float_t lr, Float_t sec) { 
    for(Int_t ism = 0; ism < 22; ism++) {
      fTCardCorrInduceEner[0][ism] = ud; fTCardCorrInduceEner[1][ism] = udlr;  
      fTCardCorrInduceEner[2][ism] = lr; fTCardCorrInduceEner[3][ism] = sec ; } } 
  
  void           SetInducedEnergyLossFraction(Float_t ud, Float_t udlr, Float_t lr, Float_t sec) { 
    for(Int_t ism = 0; ism < 22; ism++) {
      fTCardCorrInduceEnerFrac[0][ism] = ud; fTCardCorrInduceEnerFrac[1][ism] = udlr;  
      fTCardCorrInduceEnerFrac[2][ism] = lr; fTCardCorrInduceEnerFrac[3][ism] = sec ; } } 

  void           SetInducedEnergyLossFractionP1(Float_t ud, Float_t udlr, Float_t lr, Float_t sec) { 
    for(Int_t ism = 0; ism < 22; ism++) {
      fTCardCorrInduceEnerFracP1[0][ism] = ud; fTCardCorrInduceEnerFracP1[1][ism] = udlr;  
      fTCardCorrInduceEnerFracP1[2][ism] = lr; fTCardCorrInduceEnerFracP1[3][ism] = sec ; } }

  void           SetInducedEnergyLossConstantPerSM(Int_t sm, Float_t ud, Float_t udlr, Float_t lr, Float_t sec) { 
    if ( sm < 22 && sm >= 0 ) {
      fTCardCorrInduceEner[0][sm] = ud; fTCardCorrInduceEner[1][sm] = udlr;  
      fTCardCorrInduceEner[2][sm] = lr; fTCardCorrInduceEner[3][sm] = sec ; } } 
  
  void           SetInducedEnergyLossFractionPerSM(Int_t sm, Float_t ud, Float_t udlr, Float_t lr, Float_t sec) { 
    if ( sm < 22 && sm >= 0 ) {
      fTCardCorrInduceEnerFrac[0][sm] = ud; fTCardCorrInduceEnerFrac[1][sm] = udlr;  
      fTCardCorrInduceEnerFrac[2][sm] = lr; fTCardCorrInduceEnerFrac[3][sm] = sec ; } } 
  
  void           SetInducedEnergyLossFractionP1PerSM(Int_t sm, Float_t ud, Float_t udlr, Float_t lr, Float_t sec) { 
    if ( sm < 22 && sm >= 0 ) {
      fTCardCorrInduceEnerFracP1[0][sm] = ud; fTCardCorrInduceEnerFracP1[1][sm] = udlr;  
      fTCardCorrInduceEnerFracP1[2][sm] = lr; fTCardCorrInduceEnerFracP1[3][sm] = sec ; } }

  void           SetInducedEnergyLossFractionWidth(Float_t ud, Float_t udlr, Float_t lr, Float_t sec) {
    for(Int_t ism = 0; ism < 22; ism++) {
      fTCardCorrInduceEnerFracWidth[0][ism] = ud; fTCardCorrInduceEnerFracWidth[1][ism] = udlr;  
      fTCardCorrInduceEnerFracWidth[2][ism] = lr; fTCardCorrInduceEnerFracWidth[3][ism] = sec ; } }

  void           SetInducedEnergyLossFractionWidthPerSM(Int_t sm, Float_t ud, Float_t udlr, Float_t lr, Float_t sec) {
    if ( sm < 22 && sm >= 0 ) {
      fTCardCorrInduceEnerFracWidth[0][sm] = ud; fTCardCorrInduceEnerFracWidth[1][sm] = udlr;  
      fTCardCorrInduceEnerFracWidth[2][sm] = lr; fTCardCorrInduceEnerFracWidth[3][sm] = sec ; } }

  void           SetInducedEnergyLossMaximumFractionPerSM(Float_t max, Int_t sm) { 
    if ( sm < 22 && sm >= 0 ) fTCardCorrInduceEnerFracMax[sm] = max ; }  
  
  void           SetInducedEnergyLossMinimumFractionPerSM(Float_t min, Int_t sm) { 
    if ( sm < 22 && sm >= 0 ) fTCardCorrInduceEnerFracMin[sm] = min ; }  
  
  void           SetInducedEnergyLossMaximumFraction(Float_t max) { 
    for(Int_t ism = 0; ism < 22; ism++) fTCardCorrInduceEnerFracMax[ism] = max ; }  
  
  void           SetInducedEnergyLossMinimumFraction(Float_t min) { 
    for(Int_t ism = 0; ism < 22; ism++) fTCardCorrInduceEnerFracMin[ism] = min ; }  
  
  void           SetInducedEnergyLossProbabilityPerSM(Float_t prob, Int_t sm) { 
    if ( sm < 22 && sm >= 0 ) fTCardCorrInduceEnerProb[sm] = prob ; }  
  
  void           SwitchOnRandomizeTCardInducedEnergy()          { fRandomizeTCard = kTRUE   ; } 
  void           SwitchOffRandomizeTCardInducedEnergy()         { fRandomizeTCard = kFALSE  ; }  

  void           SetInducedTCardMinimumCellEnergy(Float_t mi)   { fTCardCorrMinAmp     = mi ; }
  void           SetInducedTCardMaximum(Float_t ma)             { fTCardCorrMaxInduced = ma ; }
  void           SetInducedTCardMinimum(Float_t mi)             { fTCardCorrMinInduced = mi ; }
  void           SetInducedTCardMaximumLowE(Float_t ma)         { fTCardCorrMaxInducedLowE = ma ; }
  
  void           PrintTCardParam();
  
  //------------------------------------------
  
private:
    
  virtual void   FillCaloClusterInEvent();
  
  virtual void   RecPoints2Clusters();
  
  virtual void   ResetArrays();
    
  AliVEvent             *fEvent;                   
  
  // Geometry
  AliEMCALGeometry      *fGeom;                    
  TString                fGeomName;                
  TGeoHMatrix           *fGeomMatrix[22];          
  Bool_t                 fGeomMatrixSet;           
  Bool_t                 fLoadGeomMatrices;        

  // OCDB
  TString                fOCDBpath;                
  Bool_t                 fAccessOCDB;              

  // Temporal arrays
  TClonesArray          *fDigitsArr;               
  TObjArray             *fClusterArr;              
  TObjArray             *fCaloClusterArr;          
  AliVCaloCells         *fCaloCells;               

  // Clusterizers
  AliEMCALRecParam      *fRecParam;                
  AliEMCALClusterizer   *fClusterizer;             
  AliEMCALAfterBurnerUF *fUnfolder;                
  Bool_t                 fJustUnfold;              
  
  // AOD
  TClonesArray          *fOutputAODBranch;         
  TString                fOutputAODBranchName;     
  AliAODCaloCells       *fOutputAODCells;          
  TString                fOutputAODCellsName;      
  TString                fInputCaloCellsName;      
  Bool_t                 fOutputAODBranchSet ;     
  Bool_t                 fFillAODFile;             
  Bool_t                 fFillAODHeader;           
  Bool_t                 fFillAODCaloCells;        

  Int_t                  fRun;                     
  
  AliEMCALRecoUtils*     fRecoUtils;               
  TString                fConfigName;              
    
  static const Int_t fgkNEMCalCells = 17664;       
  
  Int_t                  fOrgClusterCellId[fgkNEMCalCells]; 
  Int_t                  fCellLabels      [fgkNEMCalCells]; 
  Int_t                  fCellSecondLabels[fgkNEMCalCells]; 
  Double_t               fCellTime        [fgkNEMCalCells]; 
  Float_t                fCellMatchdEta   [fgkNEMCalCells]; 
  Float_t                fCellMatchdPhi   [fgkNEMCalCells]; 

  Bool_t                 fRecalibrateWithClusterTime;       
  
  Int_t                  fMaxEvent;                
  Int_t                  fMinEvent;                
  
  Bool_t                 fDoTrackMatching;         
  Bool_t                 fUpdateCell;              
  Bool_t                 fSelectCell;              
  Float_t                fSelectCellMinE;          
  Float_t                fSelectCellMinFrac;       
  Bool_t                 fRejectBelowThreshold;    
  Bool_t                 fRemoveLEDEvents;         
  Bool_t                 fRemoveExoticEvents;      
  
  Bool_t                 fImportGeometryFromFile;  
  TString                fImportGeometryFilePath;  

  Bool_t                 fOADBSet ;                
  Bool_t                 fAccessOADB ;             
  TString                fOADBFilePath ;           
  Float_t                fConstantTimeShift;       

  // Centrality
  TString                fCentralityClass;         
  Float_t                fCentralityBin[2];        
  Bool_t                 fUseAliCentrality;        

  //  Event selection with some signal in EMCAL
  Bool_t                 fSelectEMCALEvent;        
  Float_t                fEMCALEnergyCut;          
  Int_t                  fEMCALNcellsCut;          

  Int_t                  fSetCellMCLabelFromCluster;
  
  Bool_t                 fSetCellMCLabelFromEdepFrac;  
    
  Bool_t                 fRemapMCLabelForAODs ;    

  Bool_t                 fInputFromFilter ;        
    
  
  // T-Card correlation emulation, do on MC
  Bool_t                fTCardCorrEmulation;       
  Bool_t                fTCardCorrClusEnerConserv; 
  Float_t               fTCardCorrCellsEner[fgkNEMCalCells]; 
  Bool_t                fTCardCorrCellsNew [fgkNEMCalCells]; 
  
  Float_t               fTCardCorrInduceEner         [4 ][22]; 
  Float_t               fTCardCorrInduceEnerFrac     [4 ][22]; 
  Float_t               fTCardCorrInduceEnerFracP1   [4 ][22]; 
  Float_t               fTCardCorrInduceEnerFracWidth[4 ][22]; 
  Float_t               fTCardCorrInduceEnerFracMax[22];   
  Float_t               fTCardCorrInduceEnerFracMin[22];   
  Float_t               fTCardCorrInduceEnerProb[22];      
 
 
  TRandom3              fRandom   ;                
  Bool_t                fRandomizeTCard ;          
  
  Float_t               fTCardCorrMinAmp;          
  Float_t               fTCardCorrMinInduced;      
  Float_t               fTCardCorrMaxInducedLowE;  
  Float_t               fTCardCorrMaxInduced;      
  
  Bool_t                fPrintOnce;                
  
  AliAnalysisTaskEMCALClusterize(           const AliAnalysisTaskEMCALClusterize&) ;
    
  AliAnalysisTaskEMCALClusterize& operator=(const AliAnalysisTaskEMCALClusterize&) ;

  ClassDef(AliAnalysisTaskEMCALClusterize, 43) ;

};

#endif //ALIANALYSISTASKEMCALCLUSTERIZE_H