AliAnaCaloTrackCorrBaseClass.h

Go to the documentation of this file.

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

//_________________________________________________________________________
//_________________________________________________________________________

#include <cstdlib>

//ROOT
#include <TList.h> 
#include <TObject.h>
class TClonesArray ;
class TObjArray ;
class TObjString;

//Analysis
#include "AliCaloTrackReader.h"   
#include "AliCaloPID.h"
#include "AliFiducialCut.h"
#include "AliIsolationCut.h"
#include "AliMCAnalysisUtils.h"
#include "AliNeutralMesonSelection.h"
#include "AliCalorimeterUtils.h" 
#include "AliHistogramRanges.h"
#include "AliCaloTrackParticleCorrelation.h"
#include "AliMixedEvent.h" 
class AliVCaloCells;
class AliMCEvent ; 
class AliHeader ; 
class AliGenEventHeader ; 
class AliEMCALGeometry;
class AliPHOSGeoUtils;
class AliCentrality;
class AliMultSelection;
class AliEventplane;
#include "AliAnalysisManager.h"
#include "AliLog.h"

// Jets
class AliAODJetEventBackground;

class AliAnaCaloTrackCorrBaseClass : public TObject {
  
public:   
  
  AliAnaCaloTrackCorrBaseClass() ;          // default ctor
  virtual ~AliAnaCaloTrackCorrBaseClass() ; // virtual dtor
  
  // General methods, to be declared in deriving classes if needed
  
  virtual TList *        GetCreateOutputObjects()               { return (new TList)          ; }
  
  virtual void           Init()                                 { ; }
  virtual void           InitDebug()      ;
  virtual void           InitParameters() ;
  virtual void           InitCaloParameters() ;
  
  virtual void           FillEventMixPool()                     { ; }

  virtual void           MakeAnalysisFillAOD()                  { ; }
  
  virtual void           MakeAnalysisFillHistograms()           { ; }  
    
  virtual void           Print(const Option_t * ) const ;
  
  virtual void           Terminate(TList * /*outputList*/)      { ; }

  // Histograms, cuts 
  
  virtual void           AddToHistogramsName(TString add)       { fAddToHistogramsName = add  ; }
  virtual TString        GetAddedHistogramsStringToName() const { return fAddToHistogramsName ; }
  
  virtual TObjString *   GetAnalysisCuts()                      { return 0x0                  ; }
  virtual TString        GetBaseParametersList();
  
  // Getters, setters
  
  virtual Int_t          GetDebug()                       const { return fDebug               ; }
  virtual void           SetDebug(Int_t d)                      { fDebug = d                  ; }
  
  virtual Int_t          GetEventNumber() const ;
  
  // Centrality, multiplicity selection
  
  virtual Int_t             GetTrackMultiplicity()        const { return fReader->GetTrackMultiplicity() ; }
  virtual AliCentrality*    GetCentrality()               const { return fReader->GetCentrality() ; }
  virtual AliMultSelection* GetMultSelCen()               const { return fReader->GetMultSelCen() ; }
  virtual Int_t             GetEventCentrality()          const { if(fUseTrackMultBins)
                                                                        return GetTrackMultiplicity();
                                                                   else return fReader->GetEventCentrality(); }
  
  // Event plane
  
  virtual AliEventplane* GetEventPlane()                   const { return fReader->GetEventPlane()       ; }           
  virtual Double_t       GetEventPlaneAngle()              const { return fReader->GetEventPlaneAngle()  ; }           
  virtual TString        GetEventPlaneMethod()             const { return fReader->GetEventPlaneMethod() ; }
  
  // AOD branch
  
  virtual void           AddAODParticle(AliCaloTrackParticle part) ;
  
  virtual void           ConnectInputOutputAODBranches();
  
  virtual TClonesArray * GetCreateOutputAODBranch() ;
  
  virtual TString        GetInputAODName()                 const { return fInputAODName  ; }
  virtual void           SetInputAODName(TString name)           { fInputAODName = name  ; }
  
  virtual TString        GetOutputAODName()                const { return fOutputAODName ; }
  virtual void           SetOutputAODName(TString name)          { fNewAOD = kTRUE ; fOutputAODName = name; }
  
  virtual Bool_t         NewOutputAOD()                    const { return fNewAOD        ; }
  
  virtual TString        GetOutputAODClassName()           const { return fOutputAODClassName ; }
  virtual void           SetOutputAODClassName(TString name)     { fOutputAODClassName = name ; }
  
  virtual TString        GetAODObjArrayName()              const { return fAODObjArrayName ; }
  virtual void           SetAODObjArrayName(TString name)        { fAODObjArrayName = name ; }
  
  virtual TClonesArray * GetInputAODBranch()               const { return fInputAODBranch  ; }
  virtual TClonesArray * GetOutputAODBranch()              const { if(fNewAOD) return fOutputAODBranch; else return fInputAODBranch ; }
  virtual TClonesArray * GetAODBranch(const TString & aodBranchName) const ;
  
  // Track cluster arrays access methods
  
  virtual TClonesArray*  GetAODCaloClusters()              const ; // Output AOD clusters, not used?
  virtual TClonesArray*  GetAODTracks()                    const ; // Output AOD tracks,   not used?
  virtual AliVCaloCells* GetPHOSCells()                    const { return fReader->GetPHOSCells()  ; }
  virtual AliVCaloCells* GetEMCALCells()                   const { return fReader->GetEMCALCells() ; }
  virtual TObjArray*     GetCTSTracks()                    const ;
  virtual TObjArray*     GetEMCALClusters()                const ;
  virtual TObjArray*     GetPHOSClusters()                 const ;
  
  // Jets
  
  virtual TClonesArray*  GetNonStandardJets()              const { return fReader->GetNonStandardJets() ;}
  virtual AliAODJetEventBackground*  GetBackgroundJets()   const { return fReader->GetBackgroundJets() ;}

  // Common analysis switchs 
  
  enum detector 
  { 
    kEMCAL    = AliFiducialCut::kEMCAL,   
    kPHOS     = AliFiducialCut::kPHOS,    
    kCTS      = AliFiducialCut::kCTS,     
    kDCAL     = AliFiducialCut::kDCAL,    
    kDCALPHOS = AliFiducialCut::kDCALPHOS 
  } ;

  virtual Int_t          GetCalorimeter()                 const  { return fCalorimeter          ; }
  virtual TString        GetCalorimeterString()           const  { return fCalorimeterString    ; }
  virtual void           SetCalorimeter(TString & calo);
  virtual void           SetCalorimeter(Int_t calo) ;

  virtual Bool_t         IsDataMC()                        const { return fDataMC                ; }
  virtual void           SwitchOnDataMC()                        { fDataMC = kTRUE ;
                                                                   if(!fMCUtils) fMCUtils = new AliMCAnalysisUtils() ; }
  virtual void           SwitchOffDataMC()                       { fDataMC = kFALSE              ; }
  
  virtual Bool_t         IsFiducialCutOn()                 const { return fCheckFidCut           ; }
  virtual void           SwitchOnFiducialCut()                   { fCheckFidCut = kTRUE ;
                                                                   if(!fFidCut)  fFidCut   = new AliFiducialCut()     ; }
  virtual void           SwitchOffFiducialCut()                  { fCheckFidCut = kFALSE         ; }

  virtual Bool_t         IsRealCaloAcceptanceOn()          const { return fCheckRealCaloAcc      ; }
  virtual void           SwitchOnRealCaloAcceptance()            { fCheckRealCaloAcc = kTRUE;  }
  virtual void           SwitchOffRealCaloAcceptance()           { fCheckRealCaloAcc = kFALSE    ; }
  
  virtual Bool_t         IsCaloPIDOn()                     const { return fCheckCaloPID          ; }
  virtual void           SwitchOnCaloPID()                       { fCheckCaloPID = kTRUE ;
                                                                   if(!fCaloPID)  fCaloPID = new AliCaloPID()         ; }
  virtual void           SwitchOffCaloPID()                      { fCheckCaloPID = kFALSE        ; }
  
  virtual Bool_t         MakePlotsOn()                     const { return fMakePlots             ; }
  virtual void           SwitchOnPlotsMaking()                   { fMakePlots = kTRUE            ; }
  virtual void           SwitchOffPlotsMaking()                  { fMakePlots = kFALSE           ; }
  
  virtual Bool_t         IsPileUpAnalysisOn()              const { return fFillPileUpHistograms  ; }
  virtual void           SwitchOnFillPileUpHistograms()          { fFillPileUpHistograms = kTRUE ; }
  virtual void           SwitchOffFillPileUpHistograms()         { fFillPileUpHistograms = kFALSE; }
  
  virtual Bool_t         IsHighMultiplicityAnalysisOn()     const { return fFillHighMultHistograms   ; }
  virtual void           SwitchOnFillHighMultiplicityHistograms() { fFillHighMultHistograms = kTRUE  ; }
  virtual void           SwitchOffFillHighMultiplicityHistograms(){ fFillHighMultHistograms = kFALSE ; }

  // Cluster energy/momentum cut
  
  virtual Float_t        GetMaxPt()                        const { return fMaxPt ; }
  virtual Float_t        GetMinPt()                        const { return fMinPt ; }
  virtual void           SetMaxPt(Float_t pt)                    { fMaxPt = pt   ; }
  virtual void           SetMinPt(Float_t pt)                    { fMinPt = pt   ; }
  virtual void           SetPtCutRange(Double_t mi, Double_t ma) { fMaxPt = ma;  fMinPt=mi; }
  
  virtual Float_t        GetMaxEnergy()                    const { return fMaxPt ; }
  virtual Float_t        GetMinEnergy()                    const { return fMinPt ; }
  virtual void           SetMaxEnergy(Float_t e)                 { fMaxPt = e    ; }
  virtual void           SetMinEnergy(Float_t e)                 { fMinPt = e    ; }
  virtual void           SetEnergyCutRange(Double_t mi, Double_t ma) { fMaxPt = ma;   fMinPt = mi; }
  
  // Cluster Pairs Time cut  
  
  virtual void           SetPairTimeCut(Float_t t)               { fPairTimeCut  = t   ; } 
  virtual Float_t        GetPairTimeCut()                  const { return fPairTimeCut ; } 
  
  // Number of TRD modules in front of EMCAL (year <=2012)
  
  Int_t                  GetFirstSMCoveredByTRD()          const { return fTRDSMCovered ; }
  void                   SetFirstSMCoveredByTRD(Int_t n)         { fTRDSMCovered    = n ; }
  
  // Getters / Setters for parameters of event buffers
  
  virtual Int_t          GetNZvertBin()                    const { return fNZvertBin ; }    
  virtual Int_t          GetNRPBin()                       const { return fNrpBin    ; }    
  virtual Int_t          GetNCentrBin()                    const { return fNCentrBin ; }    
  virtual Int_t          GetNTrackMultBin()                const { return GetNCentrBin(); } 
  virtual Int_t          GetNMaxEvMix()                    const { return fNmaxMixEv ; }    
  virtual Float_t        GetZvertexCut()                   const { return GetReader()->GetZvertexCut();} 
  virtual Int_t          GetTrackMultiplicityBin()         const ;
  virtual Int_t          GetEventCentralityBin()           const ;
  virtual Int_t          GetEventRPBin()                   const ;
  virtual Int_t          GetEventVzBin()                   const ;
  virtual Int_t          GetEventMixBin()                  const ;
  virtual Int_t          GetEventMixBin(Int_t iCen, Int_t iVz, Int_t iRP) const;
  
  virtual Double_t       GetEventWeight()                  const { return GetReader()->GetEventWeight()      ; }
  virtual Double_t       GetParticlePtWeight(Float_t pt, Int_t pdg, TString genName, Int_t igen) 
    const { return (GetReader()->GetWeightUtils())->GetParticlePtWeight(pt, pdg, genName, igen)  ; }
  
  virtual void           SetNZvertBin(Int_t n = 1 )              { fNZvertBin = n ; if(n < 1) fNZvertBin = 1 ; } 
  virtual void           SetNRPBin   (Int_t n = 1 )              { fNrpBin    = n ; if(n < 1) fNrpBin    = 1 ; } 
  virtual void           SetNCentrBin(Int_t n = 1 )              { fNCentrBin = n ; if(n < 1) fNCentrBin = 1 ; } 
  virtual void           SetNTrackMultBin(Int_t n = 1 )          { SetNCentrBin(n); }                            
  virtual void           SetNMaxEvMix(Int_t n = 20)              { fNmaxMixEv = n ; if(n < 1) fNmaxMixEv = 1 ; } 
  virtual void           SetTrackMultiplicityBin(Int_t bin, Int_t mult) { if(bin < 20) fTrackMultBins[bin] = mult ; }
  
  virtual void           SwitchOnTrackMultBins()                 { fUseTrackMultBins = kTRUE  ; }
  virtual void           SwitchOffTrackMultBins()                { fUseTrackMultBins = kFALSE ; }
  
  virtual void           SwitchOnOwnMix()                        { fDoOwnMix         = kTRUE  ; }
  virtual void           SwitchOffOwnMix()                       { fDoOwnMix         = kFALSE ; }
  
  virtual Bool_t         DoOwnMix()                        const { return fDoOwnMix           ; }
  virtual Bool_t         UseTrackMultBins()                const { return fUseTrackMultBins   ; }

  // Mixed event 
  
  virtual Int_t           CheckMixedEventVertex(Int_t caloLabel, Int_t trackLabel) ;
  
  virtual AliMixedEvent * GetMixedEvent()                  const { return GetReader()->GetMixedEvent()     ; }
  
  virtual Int_t           GetNMixedEvent()                 const { return GetReader()->GetNMixedEvent()    ; } 
  
  // Vertex methods
  
  virtual void           GetVertex(Double_t vertex[3])     const { GetReader()->GetVertex(vertex)          ; } 
  
  virtual Double_t*      GetVertex(Int_t evtIndex)         const { return GetReader()->GetVertex(evtIndex) ; }
  
  virtual void           GetVertex(Double_t vertex[3],
                                   Int_t evtIndex)         const { GetReader()->GetVertex(vertex,evtIndex) ; }
  // VZERO
  
  virtual Int_t          GetV0Signal(Int_t i )             const { return fReader->GetV0Signal(i)          ; }
  
  virtual Int_t          GetV0Multiplicity(Int_t i )       const { return fReader->GetV0Multiplicity(i)    ; }
  
  
  // Some utilities dealing with cluster angles
  
  Float_t                GetPhi  (Float_t phi)             const { if ( phi < 0 ) phi += TMath::TwoPi() ; return phi ; }
  
  Float_t                DegToRad(Float_t deg)             const { deg *= TMath::DegToRad(); return deg ; }
  
  Float_t                RadToDeg(Float_t rad)             const { rad *= TMath::RadToDeg(); return rad ; }
  
  // Calorimeter specific access methods and calculations
  
  virtual Bool_t         IsTrackMatched(AliVCluster * cluster, AliVEvent* event) 
  { return GetCaloPID()->IsTrackMatched(cluster, fCaloUtils, event)             ; } 
  
  virtual Int_t          GetModuleNumberCellIndexes(Int_t absId, Int_t calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const 
  { return fCaloUtils->GetModuleNumberCellIndexes(absId, calo, icol, irow,iRCU) ; }

  virtual Int_t          GetModuleNumberCellIndexesAbsCaloMap(Int_t absId, Int_t calo, 
                                                              Int_t & icol, Int_t & irow, Int_t &iRCU,
                                                              Int_t & icolAbs, Int_t & irowAbs) const 
  { return fCaloUtils->GetModuleNumberCellIndexesAbsCaloMap(absId, calo, icol, irow,iRCU,icolAbs,irowAbs) ; }
  
  virtual Int_t          GetModuleNumber(AliCaloTrackParticle * part) const 
  { return fCaloUtils->GetModuleNumber(part, fReader->GetInputEvent())          ; }
  
  virtual Int_t          GetModuleNumber(AliVCluster * cluster)     const 
  { return fCaloUtils->GetModuleNumber(cluster)                                 ; }
  
  virtual AliVCluster*   FindCluster(TObjArray* clusters, Int_t clId, Int_t & iclus, Int_t first = 0 ) ;

  
  // MC event acces methods
  
  virtual AliMCEvent *               GetMC()               const ;
  
  virtual AliHeader*                 GetMCHeader()         const ;
  
  virtual AliGenEventHeader        * GetMCGenEventHeader() const ;
  
  // Analysis helpers classes pointers setters and getters
  
  virtual AliCaloPID               * GetCaloPID()                { if(!fCaloPID) fCaloPID = new AliCaloPID();               return  fCaloPID ; }
  
  virtual AliCalorimeterUtils      * GetCaloUtils()        const { return fCaloUtils            ; }
  
  virtual AliFiducialCut           * GetFiducialCut()            { if(!fFidCut)  fFidCut  = new AliFiducialCut();           return  fFidCut  ; }
  
  virtual AliHistogramRanges       * GetHistogramRanges()        { if(!fHisto)   fHisto   = new AliHistogramRanges();       return  fHisto   ; }
  
  virtual AliIsolationCut          * GetIsolationCut()           { if(!fIC)      fIC      = new AliIsolationCut();          return  fIC      ; }
  
  virtual AliMCAnalysisUtils       * GetMCAnalysisUtils()        { if(!fMCUtils) fMCUtils = new AliMCAnalysisUtils();       return  fMCUtils ; }
  
  virtual AliNeutralMesonSelection * GetNeutralMesonSelection()  { if(!fNMS)     fNMS     = new AliNeutralMesonSelection(); return  fNMS     ; }
  
  virtual AliCaloTrackReader       * GetReader()           const { return fReader                        ; }
  
  virtual AliEMCALGeometry         * GetEMCALGeometry()    const { return fCaloUtils->GetEMCALGeometry() ; }
  
  virtual AliPHOSGeoUtils          * GetPHOSGeometry()     const { return fCaloUtils->GetPHOSGeometry()  ; }

  virtual void                       SetCaloPID(AliCaloPID * pid)                                   { delete fCaloPID; fCaloPID = pid     ; }
  
  virtual void                       SetCaloUtils(AliCalorimeterUtils * caloutils)                  { fCaloUtils = caloutils              ; } 
  
  virtual void                       SetFiducialCut(AliFiducialCut * fc)                            { delete fFidCut;  fFidCut  = fc      ; }
  
  virtual void                       SetHistogramRanges(AliHistogramRanges * hr)                    { delete fHisto;   fHisto   = hr      ; }
  
  virtual void                       SetIsolationCut(AliIsolationCut * ic)                          { delete fIC;      fIC      = ic      ; }
  
  virtual void                       SetMCAnalysisUtils(AliMCAnalysisUtils * mcutils)               { delete fMCUtils; fMCUtils = mcutils ; }
  
  virtual void                       SetNeutralMesonSelection(AliNeutralMesonSelection * const nms) { delete fNMS;     fNMS     = nms     ; }
  
  virtual void                       SetReader(AliCaloTrackReader * reader)                         { fReader = reader                    ; }
  
  // Cocktail generator studies
  
  void                               SwitchOnStudyClusterOverlapsPerGenerator()   { fStudyClusterOverlapsPerGenerator = kTRUE  ; }
  void                               SwitchOffStudyClusterOverlapsPerGenerator()  { fStudyClusterOverlapsPerGenerator = kFALSE ; }  
  Bool_t                             IsStudyClusterOverlapsPerGeneratorOn() const {  return fStudyClusterOverlapsPerGenerator  ; }  
  
  void                               SetNCocktailGenNamesToCheck(Int_t nb)        { fNCocktailGenNames = nb   ; }
  Int_t                              GetNCocktailGenNamesToCheck()          const { return fNCocktailGenNames ; }
  
  void                               SetCocktailGenNameToCheck(Int_t i, TString v){ if(i < 10) fCocktailGenNames[i] = v   ; }
  TString                            GetCocktailGenNameToCheck(Int_t i)     const { if(i < 10) return fCocktailGenNames[i]; 
    else       return ""                  ; }
  void                               SetCocktailGenIndexToCheck(Int_t i, Int_t v) { if(i < 10) fCocktailGenIndeces[i] = v ; }
  Int_t                              GetCocktailGenIndexToCheck(Int_t i)    const { if(i < 10) return fCocktailGenIndeces[i]; 
    else       return -1                  ; }
  
  Int_t                              GetCocktailGeneratorBackgroundTag(AliVCluster * clus, Int_t mctag,
                                                                       TString & genName   , Int_t & index,
                                                                       TString & genNameBkg, Int_t & indexBkg);
  
protected:

  Int_t                      fNModules    ;        
  Int_t                      fNRCU        ;        
  Int_t                      fFirstModule ;        
  Int_t                      fLastModule  ;        
  Int_t                      fNMaxCols    ;        
  Int_t                      fNMaxRows    ;        
  Int_t                      fNMaxColsFull;        
  Int_t                      fNMaxRowsFull;        
  Int_t                      fNMaxRowsFullMin;     
  Int_t                      fNMaxRowsFullMax;     

private:    
  
  Bool_t                     fDataMC ;             
  Int_t                      fDebug ;              
  Int_t                      fCalorimeter ;        
  TString                    fCalorimeterString ;  
  Bool_t                     fCheckFidCut ;        
  Bool_t                     fCheckRealCaloAcc ;   
  Bool_t                     fCheckCaloPID ;       
  Bool_t                     fRecalculateCaloPID ; 
  Float_t                    fMinPt ;              
  Float_t                    fMaxPt ;              
  Float_t                    fPairTimeCut;         
  Int_t                      fTRDSMCovered;        
  
  Int_t                      fNZvertBin ;          
  Int_t                      fNrpBin ;             
  Int_t                      fNCentrBin ;          
  Int_t                      fNmaxMixEv ;          
  Bool_t                     fDoOwnMix;            
  Bool_t                     fUseTrackMultBins;    
  Int_t                      fTrackMultBins[20];   
  Bool_t                     fFillPileUpHistograms;   
  Bool_t                     fFillHighMultHistograms; 
  Bool_t                     fMakePlots   ;        
    
  TClonesArray*              fInputAODBranch ;     
  TString                    fInputAODName ;       
  TClonesArray*              fOutputAODBranch ;    
  Bool_t                     fNewAOD ;             
  TString                    fOutputAODName ;      
  TString                    fOutputAODClassName;  
  TString                    fAODObjArrayName ;    
  TString                    fAddToHistogramsName; 
  
  // Analysis helper classes access pointers
  AliCaloPID               * fCaloPID;             
  AliCalorimeterUtils      * fCaloUtils ;          
  AliFiducialCut           * fFidCut;              
  AliHistogramRanges       * fHisto ;              
  AliIsolationCut          * fIC;                  
  AliMCAnalysisUtils       * fMCUtils;             
  AliNeutralMesonSelection * fNMS;                 
  AliCaloTrackReader       * fReader;              

  // Cocktail generator studies
  Bool_t                     fStudyClusterOverlapsPerGenerator; 
  Int_t                      fNCocktailGenNames;                
  TString                    fCocktailGenNames[10];             
  Int_t                      fCocktailGenIndeces[10];           
  
  AliAnaCaloTrackCorrBaseClass(              const AliAnaCaloTrackCorrBaseClass & bc) ; 
  
  AliAnaCaloTrackCorrBaseClass & operator = (const AliAnaCaloTrackCorrBaseClass & bc) ; 
  
  ClassDef(AliAnaCaloTrackCorrBaseClass,29) ;

} ;

#endif //ALIANACALOTRACKCORRBASECLASS_H