[u/mrichter/AliRoot.git] / PWG / CaloTrackCorrBase / AliAnaCaloTrackCorrBaseClass.h

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

//_________________________________________________________________________
// Base class for CaloTrackCorr analysis algorithms
//-- Author: Gustavo Conesa (INFN-LNF, LPSC-Grenoble)
//-- Add the possibility for event selection analysis based on 
//   vertex and multiplicity bins (Yaxian Mao, 10/10/2010)
//
//_________________________________________________________________________

#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 "AliAODPWG4ParticleCorrelation.h"
#include "AliMixedEvent.h" 
class AliVCaloCells;
class AliStack ; 
class AliHeader ; 
class AliGenEventHeader ; 
class AliEMCALGeometry;
class AliPHOSGeoUtils;
class AliCentrality;
class AliEventplane;

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           InitParameters() ;
  
  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
  virtual AliCentrality* GetCentrality()                   const { return fReader->GetCentrality()       ; }
  virtual Int_t          GetEventCentrality()              const { 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(AliAODPWG4Particle 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(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 ;
  
	
  // Common analysis switchs 
  
  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         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         DoEventSelect()                   const { return fUseSelectEvent   ; }   // Do correlation analysis with different event buffers

  virtual void           SwitchOnEventSelection()                { fUseSelectEvent = kTRUE  ; }
  virtual void           SwitchOffEventSelection()               { fUseSelectEvent = 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   ; } //ns
  virtual Float_t        GetPairTimeCut()                  const { return fPairTimeCut ; } //ns
  
  //Getters / Setters for parameters of event buffers
    
  virtual Int_t          GetMultiBin()                     const { return fMultiBin  ; } // number of bins in Multiplicity 
  virtual Int_t          GetNZvertBin()                    const { return fNZvertBin ; } // number of bins in vertex   
  virtual Int_t          GetNRPBin()                       const { return fNrpBin    ; } // number of bins in reaction plain 
  virtual Int_t          GetNCentrBin()                    const { return fNCentrBin ; } // number of bins in centrality
  virtual Int_t          GetNMaxEvMix()                    const { return fNmaxMixEv ; } // maximal number of events for mixin
  virtual Float_t        GetZvertexCut()                   const { return GetReader()->GetZvertexCut();} // cut on vertex position  
  virtual Int_t          GetMaxMulti()                     const { return fMaxMulti  ; }  
  virtual Int_t          GetMinMulti()                     const { return fMinMulti  ; }  
    
  virtual Int_t          GetEventCentralityBin();
  virtual Int_t          GetEventRPBin();
  virtual Int_t          GetEventVzBin();
  virtual Int_t          GetEventMixBin();
  virtual Int_t          GetEventMixBin(const Int_t iCen, const Int_t iVz, const Int_t iRP);
  
  virtual void           SetMultiBin (Int_t n = 1 )              { fMultiBin  = n ; if(n < 1) fMultiBin  = 1 ; } // number of bins in Multiplicity  
  virtual void           SetNZvertBin(Int_t n = 1 )              { fNZvertBin = n ; if(n < 1) fNZvertBin = 1 ; } // number of bins for vertex position
  virtual void           SetNRPBin   (Int_t n = 1 )              { fNrpBin    = n ; if(n < 1) fNrpBin    = 1 ; } // number of bins in reaction plain  
  virtual void           SetNCentrBin(Int_t n = 1 )              { fNCentrBin = n ; if(n < 1) fNCentrBin = 1 ; } // number of bins in centrality 
  virtual void           SetNMaxEvMix(Int_t n = 20)              { fNmaxMixEv = n ; if(n < 1) fNmaxMixEv = 1 ; } // maximal number of events for mixing
  virtual void           SetMultiplicity(Int_t multimin, Int_t multimax) {fMinMulti = multimin ; fMaxMulti = multimax ; }
  
  virtual void           SwitchOnTrackMultBins()                 { fUseTrackMultBins = kTRUE  ; }
  virtual void           SwitchOffTrackMultBins()                { fUseTrackMultBins = kFALSE ; }
  
  virtual void           SwitchOnOwnMix()                        { fDoOwnMix         = kTRUE  ; }
  virtual void           SwitchOffOwnMix()                       { fDoOwnMix         = kFALSE ; }
  
  virtual Bool_t         DoOwnMix()                              { return fDoOwnMix           ; }
  virtual Bool_t         UseTrackMultBins()                      { return fUseTrackMultBins   ; }

  //Mixed event  
  virtual Int_t           CheckMixedEventVertex(const Int_t caloLabel, const Int_t trackLabel) ;
  virtual AliMixedEvent * GetMixedEvent()                        { 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(const Int_t evtIndex)   const { return GetReader()->GetVertex(evtIndex) ; } 
  virtual void           GetVertex(Double_t vertex[3], const Int_t evtIndex) const { GetReader()->GetVertex(vertex,evtIndex) ; } 

  
  //MULTIPLICITY
  
  virtual Int_t GetTrackMultiplicity()                     const { return fReader->GetTrackMultiplicity() ; }
  
  //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)   ; }
  
  
  //MC event acces methods
  virtual AliStack *                 GetMCStack()          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 * const pid)                             { delete fCaloPID; fCaloPID = pid     ; }
  
  virtual void                       SetCaloUtils(AliCalorimeterUtils * caloutils)                  { fCaloUtils = caloutils              ; }	
  
  virtual void                       SetFiducialCut(AliFiducialCut * const fc)                      { delete fFidCut;  fFidCut  = fc      ; }
  
  virtual void                       SetHistogramRanges(AliHistogramRanges * const hr)              { delete fHisto;   fHisto   = hr      ; }
  
  virtual void                       SetIsolationCut(AliIsolationCut * const ic)                    { delete fIC;      fIC      = ic      ; }
  
  virtual void                       SetMCAnalysisUtils(AliMCAnalysisUtils * const mcutils)         { delete fMCUtils; fMCUtils = mcutils ; }	
  
  virtual void                       SetNeutralMesonSelection(AliNeutralMesonSelection * const nms) { delete fNMS;     fNMS     = nms     ; }
  
  virtual void                       SetReader(AliCaloTrackReader * const reader)                   { fReader = reader                    ; }
  
  //Calorimeter specific access methods and calculations
    
  virtual Bool_t         IsTrackMatched(AliVCluster * cluster, AliVEvent* event) {
   return GetCaloPID()->IsTrackMatched(cluster, fCaloUtils, event) ; } 
  
  virtual Int_t          GetModuleNumberCellIndexes(const Int_t absId, const TString calo, Int_t & icol, Int_t & irow, Int_t &iRCU) const {
	  return fCaloUtils->GetModuleNumberCellIndexes(absId, calo, icol, irow,iRCU) ; }
  
  virtual Int_t          GetModuleNumber(AliAODPWG4Particle * part) const {
	  return fCaloUtils->GetModuleNumber(part, fReader->GetInputEvent()) ; }
  
  virtual Int_t          GetModuleNumber(AliVCluster * cluster)     const {
	  return fCaloUtils->GetModuleNumber(cluster) ; }
  
  virtual AliVCluster*   FindCluster(TObjArray* clusters, const Int_t id, Int_t & iclus, const Int_t first=0) ;

private:    
  
  Bool_t                     fDataMC ;             // Flag to access MC data when using ESD or AOD     
  Int_t                      fDebug ;              // Debug level
  Bool_t                     fCheckFidCut ;        // Do analysis for clusters in defined region         
  Bool_t                     fCheckCaloPID ;       // Do analysis for calorimeters
  Bool_t                     fRecalculateCaloPID ; // Recalculate PID or use PID weights in calorimeters
  Float_t                    fMinPt ;              // Maximum pt of (trigger) particles in the analysis
  Float_t                    fMaxPt ;              // Minimum pt of (trigger) particles in the analysis
  Float_t                    fPairTimeCut;         // Maximum difference between time of cluster pairs (ns)
  Int_t                      fMultiBin ;	         // Number of bins in event container for multiplicity
  Int_t                      fNZvertBin ;	         // Number of bins in event container for vertex position
  Int_t                      fNrpBin ;	           // Number of bins in event container for reaction plain
  Int_t                      fNCentrBin ;	         // Number of bins in event container for centrality
  Int_t                      fNmaxMixEv ;	         // Maximal number of events stored in buffer for mixing
  Bool_t                     fDoOwnMix;            // Do combinatorial background not the one provided by the frame
  Bool_t                     fUseTrackMultBins;    // Use track multiplicity and not centrality bins in mixing
  Int_t                      fMaxMulti ;           // Maximum multiplicity of particles in the analysis
  Int_t                      fMinMulti ;           // Maximum multiplicity of particles in the analysis
  Bool_t                     fUseSelectEvent ;     // Select events based on multiplicity and vertex cuts
  Bool_t                     fMakePlots   ;        // Print plots
    
  TClonesArray*              fInputAODBranch ;     //! Selected input particles branch
  TString                    fInputAODName ;       //  Name of input AOD branch;
  TClonesArray*              fOutputAODBranch ;    //! Selected output particles branch
  Bool_t                     fNewAOD ;             //  Flag, new aod branch added to the analysis or not.
  TString                    fOutputAODName ;      //  Name of output AOD branch;
  TString                    fOutputAODClassName;  //  Type of aod objects to be stored in the TClonesArray (AliAODPWG4Particle, AliAODPWG4ParticleCorrelation ...)	
  TString                    fAODObjArrayName ;    //  Name of ref array kept in a TList in AliAODParticleCorrelation with clusters or track references.
  TString                    fAddToHistogramsName; //  Add this string to histograms name
  
  //Analysis helper classes access pointers
  AliCaloPID               * fCaloPID;             // PID calculation
  AliCalorimeterUtils      * fCaloUtils ;          // Pointer to CalorimeterUtils
  AliFiducialCut           * fFidCut;              // Acceptance cuts
  AliHistogramRanges       * fHisto ;              // Histogram ranges container
  AliIsolationCut          * fIC;                  // Isolation cut 
  AliMCAnalysisUtils       * fMCUtils;             // MonteCarlo Analysis utils 
  AliNeutralMesonSelection * fNMS;                 // Neutral Meson Selection
  AliCaloTrackReader       * fReader;              // Acces to ESD/AOD/MC data

  AliAnaCaloTrackCorrBaseClass(              const AliAnaCaloTrackCorrBaseClass & bc) ; // cpy ctor
  AliAnaCaloTrackCorrBaseClass & operator = (const AliAnaCaloTrackCorrBaseClass & bc) ; // cpy assignment
  
  ClassDef(AliAnaCaloTrackCorrBaseClass,21)
} ;


#endif //ALIANACALOTRACKCORRBASECLASS_H
Commit	Line	Data
f15155ed	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
f15155ed	17	#include <TList.h>
f15155ed	18	#include <TObject.h>
0de1814a	19	class TClonesArray ;
0de1814a	20	class TObjArray ;
f15155ed	21	class TObjString;
	22
	23	//Analysis
f15155ed	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"
0de1814a	32	#include "AliAODPWG4ParticleCorrelation.h"
	33	#include "AliMixedEvent.h"
	34	class AliVCaloCells;
f15155ed	35	class AliStack ;
	36	class AliHeader ;
	37	class AliGenEventHeader ;
f15155ed	38	class AliEMCALGeometry;
f15155ed	39	class AliPHOSGeoUtils;
0de1814a	40	class AliCentrality;
0de1814a	41	class AliEventplane;
f15155ed	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() ;
31864468	55
	56	virtual void FillEventMixPool() { ; }
	57
f15155ed	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() ; }
11045377	86	virtual Double_t GetEventPlaneAngle() const { return fReader->GetEventPlaneAngle() ; }
f15155ed	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
31864468	166
1eb93b25	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
f15155ed	173	virtual Int_t GetMaxMulti() const { return fMaxMulti ; }
f15155ed	174	virtual Int_t GetMinMulti() const { return fMinMulti ; }
11045377	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);
f15155ed	181
1eb93b25	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
f15155ed	187	virtual void SetMultiplicity(Int_t multimin, Int_t multimax) {fMinMulti = multimin ; fMaxMulti = multimax ; }
f15155ed	188
11045377	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
04f7a616	198	//Mixed event
04f7a616	199	virtual Int_t CheckMixedEventVertex(const Int_t caloLabel, const Int_t trackLabel) ;
f15155ed	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
ad5fec38	267	virtual Bool_t IsTrackMatched(AliVCluster * cluster, AliVEvent* event) {
ad5fec38	268	return GetCaloPID()->IsTrackMatched(cluster, fCaloUtils, event) ; }
f15155ed	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
11045377	296	Bool_t fDoOwnMix; // Do combinatorial background not the one provided by the frame
11045377	297	Bool_t fUseTrackMultBins; // Use track multiplicity and not centrality bins in mixing
f15155ed	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
11045377	325	ClassDef(AliAnaCaloTrackCorrBaseClass,21)
f15155ed	326	} ;
	327
	328
	329	#endif //ALIANACALOTRACKCORRBASECLASS_H
	330
	331
	332