PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.h

   1 #ifndef ALIANACALOTRACKCORRBASECLASS_H
   2 #define ALIANACALOTRACKCORRBASECLASS_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice     */
   5
   6 //_________________________________________________________________________
   7 // Base class for CaloTrackCorr analysis algorithms
   8 //-- Author: Gustavo Conesa (INFN-LNF, LPSC-Grenoble)
   9 //-- Add the possibility for event selection analysis based on
  10 //   vertex and multiplicity bins (Yaxian Mao, 10/10/2010)
  11 //
  12 //_________________________________________________________________________
  13
  14 #include <cstdlib>
  15
  16 //ROOT
  17 #include <TList.h>
  18 #include <TObject.h>
  19 class TClonesArray ;
  20 class TObjArray ;
  21 class TObjString;
  22
  23 //Analysis
  24 #include "AliCaloTrackReader.h"
  25 #include "AliCaloPID.h"
  26 #include "AliFiducialCut.h"
  27 #include "AliIsolationCut.h"
  28 #include "AliMCAnalysisUtils.h"
  29 #include "AliNeutralMesonSelection.h"
  30 #include "AliCalorimeterUtils.h"
  31 #include "AliHistogramRanges.h"
  32 #include "AliAODPWG4ParticleCorrelation.h"
  33 #include "AliMixedEvent.h"
  34 class AliVCaloCells;
  35 class AliStack ;
  36 class AliHeader ;
  37 class AliGenEventHeader ;
  38 class AliEMCALGeometry;
  39 class AliPHOSGeoUtils;
  40 class AliCentrality;
  41 class AliEventplane;
  42
  43 class AliAnaCaloTrackCorrBaseClass : public TObject {
  44
  45 public:
  46   AliAnaCaloTrackCorrBaseClass() ;          // default ctor
  47   virtual ~AliAnaCaloTrackCorrBaseClass() ; // virtual dtor
  48
  49   //General methods, to be declared in deriving classes if needed
  50
  51   virtual TList *        GetCreateOutputObjects()               { return (new TList)          ; }
  52
  53   virtual void           Init() {;}
  54   virtual void           InitParameters() ;
  55
  56   virtual void           FillEventMixPool()                     { ; }
  57
  58   virtual void           MakeAnalysisFillAOD()                  { ; }
  59
  60   virtual void           MakeAnalysisFillHistograms()           { ; }
  61
  62   virtual void           Print(const Option_t * ) const ;
  63
  64   virtual void           Terminate(TList * /*outputList*/)      { ; }
  65
  66   //Histograms, cuts
  67
  68   virtual void           AddToHistogramsName(TString add)       { fAddToHistogramsName = add  ; }
  69   virtual TString        GetAddedHistogramsStringToName() const { return fAddToHistogramsName ; }
  70
  71   virtual TObjString *   GetAnalysisCuts()                      { return 0x0                  ; }
  72   virtual TString              GetBaseParametersList();
  73
  74   //Getters, setters
  75   virtual Int_t          GetDebug()                       const { return fDebug               ; }
  76   virtual void           SetDebug(Int_t d)                      { fDebug = d                  ; }
  77
  78   virtual Int_t          GetEventNumber() const ;
  79
  80   //Centrality
  81   virtual AliCentrality* GetCentrality()                   const { return fReader->GetCentrality()       ; }
  82   virtual Int_t          GetEventCentrality()              const { return fReader->GetEventCentrality()  ; }
  83
  84   //Event plane
  85   virtual AliEventplane* GetEventPlane()                   const { return fReader->GetEventPlane()       ; }
  86   virtual Double_t       GetEventPlaneAngle()              const { return fReader->GetEventPlaneAngle()  ; }
  87   virtual TString        GetEventPlaneMethod()             const { return fReader->GetEventPlaneMethod() ; }
  88
  89   //AOD branch
  90   virtual void           AddAODParticle(AliAODPWG4Particle part) ;
  91
  92   virtual void           ConnectInputOutputAODBranches();
  93
  94   virtual TClonesArray * GetCreateOutputAODBranch() ;
  95
  96   virtual TString        GetInputAODName()                 const { return fInputAODName  ; }
  97   virtual void           SetInputAODName(TString name)           { fInputAODName = name  ; }
  98
  99   virtual TString        GetOutputAODName()                const { return fOutputAODName ; }
 100   virtual void           SetOutputAODName(TString name)          { fNewAOD = kTRUE ; fOutputAODName = name; }
 101
 102   virtual Bool_t         NewOutputAOD()                    const { return fNewAOD        ; }
 103
 104   virtual TString        GetOutputAODClassName()           const { return fOutputAODClassName ; }
 105   virtual void           SetOutputAODClassName(TString name)     { fOutputAODClassName = name ; }
 106
 107   virtual TString        GetAODObjArrayName()              const { return fAODObjArrayName ; }
 108   virtual void           SetAODObjArrayName(TString name)        { fAODObjArrayName = name ; }
 109
 110   virtual TClonesArray * GetInputAODBranch()               const { return fInputAODBranch  ; }
 111   virtual TClonesArray * GetOutputAODBranch()              const { if(fNewAOD) return fOutputAODBranch; else return fInputAODBranch ; }
 112   virtual TClonesArray * GetAODBranch(TString aodBranchName) const ;
 113
 114   //Track cluster arrays access methods
 115   virtual TClonesArray*  GetAODCaloClusters()              const ; // Output AOD clusters, not used?
 116   virtual TClonesArray*  GetAODTracks()                    const ; // Output AOD tracks,   not used?
 117   virtual AliVCaloCells* GetPHOSCells()                    const { return fReader->GetPHOSCells()  ; }
 118   virtual AliVCaloCells* GetEMCALCells()                   const { return fReader->GetEMCALCells() ; }
 119   virtual TObjArray*     GetCTSTracks()                    const ;
 120   virtual TObjArray*     GetEMCALClusters()                const ;
 121   virtual TObjArray*     GetPHOSClusters()                 const ;
 122
 123
 124   // Common analysis switchs
 125
 126   virtual Bool_t         IsDataMC()                        const { return fDataMC                ; }
 127   virtual void           SwitchOnDataMC()                        { fDataMC = kTRUE ; if(!fMCUtils)fMCUtils = new AliMCAnalysisUtils();}
 128   virtual void           SwitchOffDataMC()                       { fDataMC = kFALSE              ; }
 129
 130   virtual Bool_t         IsFiducialCutOn()                 const { return fCheckFidCut           ; }
 131   virtual void           SwitchOnFiducialCut()                   { fCheckFidCut = kTRUE;  if(!fFidCut)fFidCut = new AliFiducialCut();}
 132   virtual void           SwitchOffFiducialCut()                  { fCheckFidCut = kFALSE         ; }
 133
 134   virtual Bool_t         IsCaloPIDOn()                     const { return fCheckCaloPID          ; }
 135   virtual void           SwitchOnCaloPID()                       { fCheckCaloPID = kTRUE; if(!fCaloPID)fCaloPID = new AliCaloPID();}
 136   virtual void           SwitchOffCaloPID()                      { fCheckCaloPID = kFALSE        ; }
 137
 138   virtual Bool_t         MakePlotsOn()                     const { return fMakePlots        ; }
 139   virtual void           SwitchOnPlotsMaking()                   { fMakePlots = kTRUE       ; }
 140   virtual void           SwitchOffPlotsMaking()                  { fMakePlots = kFALSE      ; }
 141
 142   virtual Bool_t         DoEventSelect()                   const { return fUseSelectEvent   ; }   // Do correlation analysis with different event buffers
 143
 144   virtual void           SwitchOnEventSelection()                { fUseSelectEvent = kTRUE  ; }
 145   virtual void           SwitchOffEventSelection()               { fUseSelectEvent = kFALSE ; }
 146
 147   // Cluster energy/momentum cut
 148
 149   virtual Float_t        GetMaxPt()                        const { return fMaxPt ; }
 150   virtual Float_t        GetMinPt()                        const { return fMinPt ; }
 151   virtual void           SetMaxPt(Float_t pt)                    { fMaxPt = pt   ; }
 152   virtual void           SetMinPt(Float_t pt)                    { fMinPt = pt   ; }
 153   virtual void           SetPtCutRange(Double_t mi, Double_t ma) { fMaxPt = ma;  fMinPt=mi; }
 154
 155   virtual Float_t        GetMaxEnergy()                    const { return fMaxPt ; }
 156   virtual Float_t        GetMinEnergy()                    const { return fMinPt ; }
 157   virtual void           SetMaxEnergy(Float_t e)                 { fMaxPt = e    ; }
 158   virtual void           SetMinEnergy(Float_t e)                 { fMinPt = e    ; }
 159   virtual void           SetEnergyCutRange(Double_t mi, Double_t ma) { fMaxPt = ma;   fMinPt = mi; }
 160
 161   //Cluster Pairs Time cut
 162   virtual void           SetPairTimeCut(Float_t t)               { fPairTimeCut  = t   ; } //ns
 163   virtual Float_t        GetPairTimeCut()                  const { return fPairTimeCut ; } //ns
 164
 165   //Getters / Setters for parameters of event buffers
 166
 167   virtual Int_t          GetMultiBin()                     const { return fMultiBin  ; } // number of bins in Multiplicity
 168   virtual Int_t          GetNZvertBin()                    const { return fNZvertBin ; } // number of bins in vertex
 169   virtual Int_t          GetNRPBin()                       const { return fNrpBin    ; } // number of bins in reaction plain
 170   virtual Int_t          GetNCentrBin()                    const { return fNCentrBin ; } // number of bins in centrality
 171   virtual Int_t          GetNMaxEvMix()                    const { return fNmaxMixEv ; } // maximal number of events for mixin
 172   virtual Float_t        GetZvertexCut()                   const { return GetReader()->GetZvertexCut();} // cut on vertex position
 173   virtual Int_t          GetMaxMulti()                     const { return fMaxMulti  ; }
 174   virtual Int_t          GetMinMulti()                     const { return fMinMulti  ; }
 175
 176   virtual Int_t          GetEventCentralityBin();
 177   virtual Int_t          GetEventRPBin();
 178   virtual Int_t          GetEventVzBin();
 179   virtual Int_t          GetEventMixBin();
 180   virtual Int_t          GetEventMixBin(const Int_t iCen, const Int_t iVz, const Int_t iRP);
 181
 182   virtual void           SetMultiBin (Int_t n = 1 )              { fMultiBin  = n ; if(n < 1) fMultiBin  = 1 ; } // number of bins in Multiplicity
 183   virtual void           SetNZvertBin(Int_t n = 1 )              { fNZvertBin = n ; if(n < 1) fNZvertBin = 1 ; } // number of bins for vertex position
 184   virtual void           SetNRPBin   (Int_t n = 1 )              { fNrpBin    = n ; if(n < 1) fNrpBin    = 1 ; } // number of bins in reaction plain
 185   virtual void           SetNCentrBin(Int_t n = 1 )              { fNCentrBin = n ; if(n < 1) fNCentrBin = 1 ; } // number of bins in centrality
 186   virtual void           SetNMaxEvMix(Int_t n = 20)              { fNmaxMixEv = n ; if(n < 1) fNmaxMixEv = 1 ; } // maximal number of events for mixing
 187   virtual void           SetMultiplicity(Int_t multimin, Int_t multimax) {fMinMulti = multimin ; fMaxMulti = multimax ; }
 188
 189   virtual void           SwitchOnTrackMultBins()                 { fUseTrackMultBins = kTRUE  ; }
 190   virtual void           SwitchOffTrackMultBins()                { fUseTrackMultBins = kFALSE ; }
 191
 192   virtual void           SwitchOnOwnMix()                        { fDoOwnMix         = kTRUE  ; }
 193   virtual void           SwitchOffOwnMix()                       { fDoOwnMix         = kFALSE ; }
 194
 195   virtual Bool_t         DoOwnMix()                              { return fDoOwnMix           ; }
 196   virtual Bool_t         UseTrackMultBins()                      { return fUseTrackMultBins   ; }
 197
 198   //Mixed event
 199   virtual Int_t           CheckMixedEventVertex(const Int_t caloLabel, const Int_t trackLabel) ;
 200   virtual AliMixedEvent * GetMixedEvent()                        { return GetReader()->GetMixedEvent()  ; }
 201   virtual Int_t           GetNMixedEvent()                 const { return GetReader()->GetNMixedEvent() ; }
 202
 203   //Vertex methods
 204   virtual void           GetVertex(Double_t vertex[3])     const { GetReader()->GetVertex(vertex)       ; }
 205   virtual Double_t*      GetVertex(const Int_t evtIndex)   const { return GetReader()->GetVertex(evtIndex) ; }
 206   virtual void           GetVertex(Double_t vertex[3], const Int_t evtIndex) const { GetReader()->GetVertex(vertex,evtIndex) ; }
 207
 208
 209   //MULTIPLICITY
 210
 211   virtual Int_t GetTrackMultiplicity()                     const { return fReader->GetTrackMultiplicity() ; }
 212
 213   //VZERO
 214
 215   virtual Int_t GetV0Signal(Int_t i )                      const { return fReader->GetV0Signal(i)         ; }
 216
 217   virtual Int_t GetV0Multiplicity(Int_t i )                const { return fReader->GetV0Multiplicity(i)   ; }
 218
 219
 220   //MC event acces methods
 221   virtual AliStack *                 GetMCStack()          const ;
 222
 223   virtual AliHeader*                 GetMCHeader()         const ;
 224
 225   virtual AliGenEventHeader        * GetMCGenEventHeader() const ;
 226
 227   //Analysis helpers classes pointers setters and getters
 228
 229   virtual AliCaloPID               * GetCaloPID()                { if(!fCaloPID) fCaloPID = new AliCaloPID();               return  fCaloPID ; }
 230
 231   virtual AliCalorimeterUtils      * GetCaloUtils()        const { return fCaloUtils            ; }
 232
 233   virtual AliFiducialCut           * GetFiducialCut()            { if(!fFidCut)  fFidCut  = new AliFiducialCut();           return  fFidCut  ; }
 234
 235   virtual AliHistogramRanges       * GetHistogramRanges()        { if(!fHisto)   fHisto   = new AliHistogramRanges();       return  fHisto   ; }
 236
 237   virtual AliIsolationCut          * GetIsolationCut()           { if(!fIC)      fIC      = new AliIsolationCut();          return  fIC      ; }
 238
 239   virtual AliMCAnalysisUtils       * GetMCAnalysisUtils()        { if(!fMCUtils) fMCUtils = new AliMCAnalysisUtils();       return  fMCUtils ; }
 240
 241   virtual AliNeutralMesonSelection * GetNeutralMesonSelection()  { if(!fNMS)     fNMS     = new AliNeutralMesonSelection(); return  fNMS     ; }
 242
 243   virtual AliCaloTrackReader       * GetReader()           const { return fReader                        ; }
 244
 245   virtual AliEMCALGeometry         * GetEMCALGeometry()    const { return fCaloUtils->GetEMCALGeometry() ; }
 246
 247   virtual AliPHOSGeoUtils          * GetPHOSGeometry()     const { return fCaloUtils->GetPHOSGeometry()  ; }
 248
 249   virtual void                       SetCaloPID(AliCaloPID * const pid)                             { delete fCaloPID; fCaloPID = pid     ; }
 250
 251   virtual void                       SetCaloUtils(AliCalorimeterUtils * caloutils)                  { fCaloUtils = caloutils              ; }
 252
 253   virtual void                       SetFiducialCut(AliFiducialCut * const fc)                      { delete fFidCut;  fFidCut  = fc      ; }
 254
 255   virtual void                       SetHistogramRanges(AliHistogramRanges * const hr)              { delete fHisto;   fHisto   = hr      ; }
 256
 257   virtual void                       SetIsolationCut(AliIsolationCut * const ic)                    { delete fIC;      fIC      = ic      ; }
 258
 259   virtual void                       SetMCAnalysisUtils(AliMCAnalysisUtils * const mcutils)         { delete fMCUtils; fMCUtils = mcutils ; }
 260
 261   virtual void                       SetNeutralMesonSelection(AliNeutralMesonSelection * const nms) { delete fNMS;     fNMS     = nms     ; }
 262
 263   virtual void                       SetReader(AliCaloTrackReader * const reader)                   { fReader = reader                    ; }
 264
 265   //Calorimeter specific access methods and calculations
 266
 267   virtual Bool_t         IsTrackMatched(AliVCluster * cluster, AliVEvent* event) {
 268    return GetCaloPID()->IsTrackMatched(cluster, fCaloUtils, event) ; }
 269
 270   virtual Int_t          GetModuleNumberCellIndexes(const Int_t absId, const TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const {
 271           return fCaloUtils->GetModuleNumberCellIndexes(absId, calo, icol, irow,iRCU) ; }
 272
 273   virtual Int_t          GetModuleNumber(AliAODPWG4Particle * part) const {
 274           return fCaloUtils->GetModuleNumber(part, fReader->GetInputEvent()) ; }
 275
 276   virtual Int_t          GetModuleNumber(AliVCluster * cluster)     const {
 277           return fCaloUtils->GetModuleNumber(cluster) ; }
 278
 279   virtual AliVCluster*   FindCluster(TObjArray* clusters, const Int_t id, Int_t & iclus, const Int_t first=0) ;
 280
 281 private:
 282
 283   Bool_t                     fDataMC ;             // Flag to access MC data when using ESD or AOD
 284   Int_t                      fDebug ;              // Debug level
 285   Bool_t                     fCheckFidCut ;        // Do analysis for clusters in defined region
 286   Bool_t                     fCheckCaloPID ;       // Do analysis for calorimeters
 287   Bool_t                     fRecalculateCaloPID ; // Recalculate PID or use PID weights in calorimeters
 288   Float_t                    fMinPt ;              // Maximum pt of (trigger) particles in the analysis
 289   Float_t                    fMaxPt ;              // Minimum pt of (trigger) particles in the analysis
 290   Float_t                    fPairTimeCut;         // Maximum difference between time of cluster pairs (ns)
 291   Int_t                      fMultiBin ;                 // Number of bins in event container for multiplicity
 292   Int_t                      fNZvertBin ;                // Number of bins in event container for vertex position
 293   Int_t                      fNrpBin ;             // Number of bins in event container for reaction plain
 294   Int_t                      fNCentrBin ;                // Number of bins in event container for centrality
 295   Int_t                      fNmaxMixEv ;                // Maximal number of events stored in buffer for mixing
 296   Bool_t                     fDoOwnMix;            // Do combinatorial background not the one provided by the frame
 297   Bool_t                     fUseTrackMultBins;    // Use track multiplicity and not centrality bins in mixing
 298   Int_t                      fMaxMulti ;           // Maximum multiplicity of particles in the analysis
 299   Int_t                      fMinMulti ;           // Maximum multiplicity of particles in the analysis
 300   Bool_t                     fUseSelectEvent ;     // Select events based on multiplicity and vertex cuts
 301   Bool_t                     fMakePlots   ;        // Print plots
 302
 303   TClonesArray*              fInputAODBranch ;     //! Selected input particles branch
 304   TString                    fInputAODName ;       //  Name of input AOD branch;
 305   TClonesArray*              fOutputAODBranch ;    //! Selected output particles branch
 306   Bool_t                     fNewAOD ;             //  Flag, new aod branch added to the analysis or not.
 307   TString                    fOutputAODName ;      //  Name of output AOD branch;
 308   TString                    fOutputAODClassName;  //  Type of aod objects to be stored in the TClonesArray (AliAODPWG4Particle, AliAODPWG4ParticleCorrelation ...)
 309   TString                    fAODObjArrayName ;    //  Name of ref array kept in a TList in AliAODParticleCorrelation with clusters or track references.
 310   TString                    fAddToHistogramsName; //  Add this string to histograms name
 311
 312   //Analysis helper classes access pointers
 313   AliCaloPID               * fCaloPID;             // PID calculation
 314   AliCalorimeterUtils      * fCaloUtils ;          // Pointer to CalorimeterUtils
 315   AliFiducialCut           * fFidCut;              // Acceptance cuts
 316   AliHistogramRanges       * fHisto ;              // Histogram ranges container
 317   AliIsolationCut          * fIC;                  // Isolation cut
 318   AliMCAnalysisUtils       * fMCUtils;             // MonteCarlo Analysis utils
 319   AliNeutralMesonSelection * fNMS;                 // Neutral Meson Selection
 320   AliCaloTrackReader       * fReader;              // Acces to ESD/AOD/MC data
 321
 322   AliAnaCaloTrackCorrBaseClass(              const AliAnaCaloTrackCorrBaseClass & bc) ; // cpy ctor
 323   AliAnaCaloTrackCorrBaseClass & operator = (const AliAnaCaloTrackCorrBaseClass & bc) ; // cpy assignment
 324
 325   ClassDef(AliAnaCaloTrackCorrBaseClass,21)
 326 } ;
 327
 328
 329 #endif //ALIANACALOTRACKCORRBASECLASS_H
 330
 331
 332