[u/mrichter/AliRoot.git] / PWG4 / PartCorrBase / AliCaloTrackReader.h

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

//_________________________________________________________________________
// Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and 
// Central Barrel Tracking detectors.
// Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done.
// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TObjArrays (PHOS, EMCAL, CTS)
//                 : AliCaloTrackMCReader: Fills Kinematics data in 3 TObjArrays (PHOS, EMCAL, CTS)
//                 : AliCaloTrackAODReader: Fills AOD data in 3 TObjArrays (PHOS, EMCAL, CTS) 
//  
// This part is commented: Mixing analysis can be done, input AOD with events
// is opened in the AliCaloTrackReader::Init()

// -- Author: Gustavo Conesa (INFN-LNF)

// --- ROOT system ---
#include "TObject.h" 
class TObjArray ; 
#include "TString.h"
class TTree ;

//--- ANALYSIS system ---
class AliStack ; 
class AliHeader ; 
class AliGenEventHeader ; 
class AliVEvent;
class AliAODEvent;
class AliMCEvent;
class AliMixedEvent;
#include "AliVCaloCells.h"
#include "AliFiducialCut.h"
class AliAODMCHeader;
#include "AliCalorimeterUtils.h"
class AliESDtrackCuts;
class AliCentrality;

class AliCaloTrackReader : public TObject {

public: 
  AliCaloTrackReader() ; // ctor
  virtual ~AliCaloTrackReader() ;//virtual dtor
private:
  AliCaloTrackReader(const AliCaloTrackReader & g) ; // cpy ctor
  AliCaloTrackReader & operator = (const AliCaloTrackReader & g) ;//cpy assignment

public:
  enum inputDataType {kESD, kAOD, kMC};
    
  //Select generated events, depending on comparison of pT hard and jets.
  virtual Bool_t ComparePtHardAndJetPt() ;
  virtual Bool_t IsPtHardAndJetPtComparisonSet() const {return  fComparePtHardAndJetPt ;}
  virtual void SetPtHardAndJetPtComparison(Bool_t compare) { fComparePtHardAndJetPt = compare ;}	
  virtual Float_t GetPtHardAndJetFactor() const {return  fPtHardAndJetPtFactor ;}
  virtual void SetPtHardAndJetPtFactor(Float_t factor) { fPtHardAndJetPtFactor = factor ;}		
	
  virtual void InitParameters();
  virtual void Print(const Option_t * opt) const;

  virtual Int_t GetDebug()         const { return fDebug ; }
  virtual void  SetDebug(Int_t d)        { fDebug = d ; }
  virtual Int_t GetDataType()      const { return fDataType ; }
  virtual void  SetDataType(Int_t data ) { fDataType = data ; }

  virtual Int_t   GetEventNumber()     const {return fEventNumber ; }
  virtual TString GetCurrentFileName() const {return fCurrentFileName ; }
	
  //Minimum pt setters and getters 
  virtual Float_t  GetEMCALPtMin() const { return fEMCALPtMin  ; }
  virtual Float_t  GetPHOSPtMin()  const { return fPHOSPtMin  ; }
  virtual Float_t  GetCTSPtMin()   const { return fCTSPtMin  ; }

  virtual void SetEMCALPtMin(Float_t  pt) { fEMCALPtMin = pt ; }
  virtual void SetPHOSPtMin(Float_t  pt)  { fPHOSPtMin = pt ; }
  virtual void SetCTSPtMin(Float_t  pt)   { fCTSPtMin = pt ; }
  
  //Input setters and getters
  Bool_t IsEMCALCluster(AliVCluster *clus) const;
  Bool_t IsPHOSCluster (AliVCluster *clus)  const;
  void SwitchOnOldAODs()   {fOldAOD = kTRUE  ; }
  void SwitchOffOldAODs()  {fOldAOD = kFALSE ; }
  
  Bool_t IsCTSSwitchedOn()  const { return fFillCTS ; }
  void SwitchOnCTS()    {fFillCTS = kTRUE  ; }
  void SwitchOffCTS()   {fFillCTS = kFALSE ; }

  Bool_t IsEMCALSwitchedOn() const { return fFillEMCAL ; }
  void SwitchOnEMCAL()  {fFillEMCAL = kTRUE  ; }
  void SwitchOffEMCAL() {fFillEMCAL = kFALSE ; }

  Bool_t IsPHOSSwitchedOn()  const { return fFillPHOS ; }
  void SwitchOnPHOS()   {fFillPHOS = kTRUE  ; }
  void SwitchOffPHOS()  {fFillPHOS = kFALSE ; }

  Bool_t IsEMCALCellsSwitchedOn() const { return fFillEMCALCells ; }
  void SwitchOnEMCALCells()  {fFillEMCALCells = kTRUE  ; }
  void SwitchOffEMCALCells() {fFillEMCALCells = kFALSE ; }

  Bool_t IsPHOSCellsSwitchedOn()  const { return fFillPHOSCells ; }
  void SwitchOnPHOSCells()   {fFillPHOSCells = kTRUE  ; }
  void SwitchOffPHOSCells()  {fFillPHOSCells = kFALSE ; }

  virtual Bool_t FillInputEvent(const Int_t iEntry, const char *currentFileName)  ;
  virtual void FillInputCTS() ;
  virtual void FillInputEMCAL() ;
  virtual void FillInputPHOS() ;
  virtual void FillInputEMCALCells() ;
  virtual void FillInputPHOSCells() ;
  
  virtual TList * GetAODBranchList() const { return fAODBranchList ; }

  virtual TObjArray* GetAODCTS()   const {return fAODCTS   ;}
  virtual TObjArray* GetAODEMCAL() const {return fAODEMCAL ;}
  virtual TObjArray* GetAODPHOS()  const {return fAODPHOS  ;}
  virtual AliVCaloCells* GetEMCALCells()  const { return fEMCALCells ;}
  virtual AliVCaloCells* GetPHOSCells()   const { return fPHOSCells  ;}

  //Get MC  informatio
  //Kinematics and galice.root available 
  virtual AliStack*    GetStack()      const ;
  virtual AliHeader*   GetHeader()     const ;
  virtual AliGenEventHeader* GetGenEventHeader() const ;
  //Filtered kinematics in AOD	
  virtual TClonesArray*   GetAODMCParticles(Int_t input = 0) const ;
  virtual AliAODMCHeader* GetAODMCHeader(Int_t input = 0)    const ;
	
  virtual AliVEvent*     GetInputEvent()  const {return fInputEvent;}
  virtual AliAODEvent*   GetOutputEvent() const {return fOutputEvent;}
  virtual AliMCEvent*    GetMC()          const {return fMC;}
  virtual AliMixedEvent* GetMixedEvent()  const {return fMixedEvent;}
  virtual Int_t          GetNMixedEvent() const {return fNMixedEvent ; } 

  virtual Double_t       GetBField() const { return 0.;}
	
  virtual void Init();

//  virtual void SetInputEvent(AliVEvent* const input)  {fInputEvent  = input;}
  virtual void SetInputEvent(AliVEvent* const input) ;
  virtual void SetOutputEvent(AliAODEvent* const aod) {fOutputEvent = aod;}
  virtual void SetMC(AliMCEvent* const mc)            {fMC  = mc;}

  virtual void ResetLists();

  virtual AliFiducialCut * GetFiducialCut() {if(!fFiducialCut) fFiducialCut = new AliFiducialCut(); 
	  return  fFiducialCut ;}
  virtual void SetFiducialCut(AliFiducialCut * const fc) { fFiducialCut = fc ;}
  virtual Bool_t IsFiducialCutOn()       {return fCheckFidCut ; }
  virtual void SwitchOnFiducialCut()     { fCheckFidCut = kTRUE;  fFiducialCut = new AliFiducialCut();}
  virtual void SwitchOffFiducialCut()    { fCheckFidCut = kFALSE;}
	
  virtual void SetInputOutputMCEvent(AliVEvent* /*esd*/, AliAODEvent* /*aod*/, AliMCEvent* /*mc*/) {;}
	
  //Methods for mixing with external input file (AOD)
  //virtual TTree* GetSecondInputAODTree() const {return  fSecondInputAODTree ; } 
  //virtual void SetSecondInputAODTree(TTree * tree) {fSecondInputAODTree = tree ;
  //												  fSecondInputAODEvent->ReadFromTree(tree);}//Connect tree and AOD event.
					
  //virtual AliAODEvent* GetSecondInputAODEvent() const { return fSecondInputAODEvent ; } 
	
  //TString GetSecondInputFileName() const    {return fSecondInputFileName ; }
  //void SetSecondInputFileName(TString name) { fSecondInputFileName = name ; }

  //Int_t GetSecondInputFirstEvent() const    {return fSecondInputFirstEvent ; }
  //void SetSecondInputFirstEvent(Int_t iEvent0) { fSecondInputFirstEvent = iEvent0 ; }	
	
//  Int_t GetAODCTSNormalInputEntries()   {if(!fSecondInputAODTree) { fAODCTSNormalInputEntries   = fAODCTS->GetEntriesFast()  ;}
//										 return fAODCTSNormalInputEntries ; }
//  Int_t GetAODEMCALNormalInputEntries() {if(!fSecondInputAODTree) { fAODEMCALNormalInputEntries = fAODEMCAL->GetEntriesFast();}
//										 return fAODEMCALNormalInputEntries ; }
//  Int_t GetAODPHOSNormalInputEntries()  {if(!fSecondInputAODTree) { fAODPHOSNormalInputEntries  = fAODPHOS->GetEntriesFast() ;}
//										 return fAODPHOSNormalInputEntries ; }
	
  // Track selection
  ULong_t GetTrackStatus() const   {return fTrackStatus ; }
  void SetTrackStatus(ULong_t bit) { fTrackStatus = bit ; }		
	
  AliESDtrackCuts* GetTrackCuts()          const  { return fESDtrackCuts    ; }
  void    SetTrackCuts(AliESDtrackCuts * cuts)    { fESDtrackCuts = cuts    ; }		  
  Int_t   GetTrackMultiplicity()           const  { return fTrackMult       ; }
  Float_t GetTrackMultiplicityEtaCut()     const  { return fTrackMultEtaCut ; }
  void    SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta  ; }		
  
  //MC switchs
  void SwitchOnStack()              { fReadStack          = kTRUE  ; }
  void SwitchOffStack()             { fReadStack          = kFALSE ; }
  void SwitchOnAODMCParticles()     { fReadAODMCParticles = kTRUE  ; }
  void SwitchOffAODMCParticles()    { fReadAODMCParticles = kFALSE ; }
  Bool_t ReadStack()          const { return fReadStack            ; }
  Bool_t ReadAODMCParticles() const { return fReadAODMCParticles   ; }
	
  void SetDeltaAODFileName(TString name ) {fDeltaAODFileName = name ; }
  TString GetDeltaAODFileName() const {return fDeltaAODFileName ; }

  void SetFiredTriggerClassName(TString name ) {fFiredTriggerClassName = name ; }
  TString GetFiredTriggerClassName() const {return fFiredTriggerClassName ; }
  virtual TString GetFiredTriggerClasses() {return "";}

  void AnalyzeOnlyLED()     {fAnaLED = kTRUE;}
  void AnalyzeOnlyPhysics() {fAnaLED = kFALSE;}
	
  TString  GetTaskName() const {return fTaskName;}
  void SetTaskName(TString name) {fTaskName = name;}

  AliCalorimeterUtils * GetCaloUtils() const {return fCaloUtils ; }
  void SetCaloUtils(AliCalorimeterUtils * caloutils) { fCaloUtils = caloutils ; }
  
  virtual void GetVertex(Double_t v[3]) const ;
  virtual Double_t* GetVertex(const Int_t evtIndex) const {return fVertex[evtIndex];}
  virtual void GetVertex(Double_t vertex[3], const Int_t evtIndex) const ;
  virtual void FillVertexArray();
 // virtual void       GetSecondInputAODVertex(Double_t *) const {;}
  
  void SwitchOnWriteDeltaAOD()  {fWriteOutputDeltaAOD = kTRUE ;  }
  void SwitchOffWriteDeltaAOD() {fWriteOutputDeltaAOD = kFALSE ; }
  Bool_t WriteDeltaAODToFile() const {return fWriteOutputDeltaAOD ; } 
  
  virtual void FillInputVZERO(){;}
  Int_t GetV0Signal(Int_t i) const { return fV0ADC[i];}
  Int_t GetV0Multiplicity(Int_t i)   const { return fV0Mul[i];}

  void SwitchOnCaloFilterPatch()  {fCaloFilterPatch = kTRUE ; fFillCTS = kFALSE; }
  void SwitchOffCaloFilterPatch() {fCaloFilterPatch = kFALSE ; }
  Bool_t IsCaloFilterPatchOn()    {if(fDataType == kAOD) { return fCaloFilterPatch ; } 
                                   else                  { return kFALSE ; } }
  
  virtual AliCentrality* GetCentrality() const {return 0x0;}

  
  //MC reader methods:
  
  virtual void AddNeutralParticlesArray(TArrayI & /*array*/)  { ; }  
  virtual void AddChargedParticlesArray(TArrayI & /*array*/)  { ; } 
  virtual void AddStatusArray(TArrayI & /*array*/)            { ; }
  
  virtual void SwitchOnPi0Decay()         { ; } 
  virtual void SwitchOffPi0Decay()        { ; } 
  virtual void SwitchOnStatusSelection()  { ; }
  virtual void SwitchOffStatusSelection() { ; }
  virtual void SwitchOnOverlapCheck()     { ; }
  virtual void SwitchOffOverlapCheck()    { ; }
  
  virtual void SetEMCALOverlapAngle(Float_t /*angle*/)  { ; }
  virtual void SetPHOSOverlapAngle(Float_t /*angle*/)   { ; }
  

 protected:
  Int_t	           fEventNumber;    // Event number
  TString          fCurrentFileName;// Current file name under analysis
  Int_t            fDataType ;      // Select MC:Kinematics, Data:ESD/AOD, MCData:Both
  Int_t            fDebug;          // Debugging level
  AliFiducialCut * fFiducialCut;    //! Acceptance cuts
  Bool_t           fCheckFidCut ;   // Do analysis for clusters in defined region         

  Bool_t           fComparePtHardAndJetPt;  // In MonteCarlo, jet events, reject fake events with wrong jet energy.
  Float_t          fPtHardAndJetPtFactor;   // Factor between ptHard and jet pT to reject/accept event.

  Float_t          fCTSPtMin;       // pT Threshold on charged particles 
  Float_t          fEMCALPtMin;     // pT Threshold on emcal clusters
  Float_t          fPHOSPtMin;      // pT Threshold on phos clusters

  TList          * fAODBranchList ; //! List with AOD branches created and needed in analysis  
  TObjArray      * fAODCTS ;        //! temporal referenced array with tracks
  TObjArray      * fAODEMCAL ;      //! temporal referenced array with EMCAL CaloClusters
  TObjArray      * fAODPHOS ;       //! temporal referenced array with PHOS CaloClusters
  AliVCaloCells  * fEMCALCells ;    //! temporal array with EMCAL CaloCells, ESD or AOD
  AliVCaloCells  * fPHOSCells ;     //! temporal array with PHOS CaloCells, ESD or AOD

  AliVEvent      * fInputEvent;     //! pointer to esd or aod input
  AliAODEvent    * fOutputEvent;    //! pointer to aod output
  AliMCEvent     * fMC;             //! Monte Carlo Event Handler  

  Bool_t           fFillCTS;        // use data from CTS
  Bool_t           fFillEMCAL;      // use data from EMCAL
  Bool_t           fFillPHOS;       // use data from PHOS
  Bool_t           fFillEMCALCells; // use data from EMCAL
  Bool_t           fFillPHOSCells;  // use data from PHOS

//  TTree *        fSecondInputAODTree;    // Tree with second input AOD, for mixing analysis.	
//  AliAODEvent*   fSecondInputAODEvent;   //! pointer to second input AOD event.
//  TString        fSecondInputFileName;   // File with AOD data to mix with normal stream of data.
//  Int_t          fSecondInputFirstEvent; // First event to be considered in the mixing.
//	
//  Int_t          fAODCTSNormalInputEntries;   // Number of entries in CTS   in case of standard input, larger with mixing.
//  Int_t          fAODEMCALNormalInputEntries; // Number of entries in EMCAL in case of standard input, larger with mixing.
//  Int_t          fAODPHOSNormalInputEntries;  // Number of entries in PHOS  in case of standard input, larger with mixing.
	
  ULong_t          fTrackStatus        ; // Track selection bit, select tracks refitted in TPC, ITS ...
  AliESDtrackCuts *fESDtrackCuts       ; // Track cut  
  Int_t            fTrackMult          ; // Track multiplicity
  Float_t          fTrackMultEtaCut    ; // Track multiplicity eta cut
  Bool_t           fReadStack          ; // Access kine information from stack
  Bool_t	         fReadAODMCParticles ; // Access kine information from filtered AOD MC particles
	
  TString          fDeltaAODFileName   ; // Delta AOD file name
  TString          fFiredTriggerClassName; // Name of trigger event type used to do the analysis

  Bool_t           fAnaLED;             // Analyze LED data only.

  TString          fTaskName;           // Name of task that executes the analysis
	
  AliCalorimeterUtils * fCaloUtils ;    //  Pointer to CalorimeterUtils

  AliMixedEvent  * fMixedEvent  ;       //! mixed event object. This class is not the owner
  Int_t            fNMixedEvent ;       // number of events in mixed event buffer
  Double_t      ** fVertex      ;       //! vertex array 3 dim for each mixed event buffer
  
  Bool_t           fWriteOutputDeltaAOD;// Write the created delta AOD objects into file  
	Bool_t           fOldAOD;             // Old AODs, before revision 4.20
  
  Int_t            fV0ADC[2]    ;       // Integrated V0 signal
  Int_t            fV0Mul[2]    ;       // Integrated V0 Multiplicity

  Bool_t           fCaloFilterPatch;    // CaloFilter patch
  
  ClassDef(AliCaloTrackReader,21)
} ;


#endif //ALICALOTRACKREADER_H
Commit	Line	Data
1c5acb87	1	#ifndef ALICALOTRACKREADER_H
	2	#define ALICALOTRACKREADER_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5	/* $Id: $ */
	6
	7	//_________________________________________________________________________
	8	// Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and
	9	// Central Barrel Tracking detectors.
	10	// Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done.
591cc579	11	// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TObjArrays (PHOS, EMCAL, CTS)
	12	// : AliCaloTrackMCReader: Fills Kinematics data in 3 TObjArrays (PHOS, EMCAL, CTS)
	13	// : AliCaloTrackAODReader: Fills AOD data in 3 TObjArrays (PHOS, EMCAL, CTS)
1e68a3f4	14	//
	15	// This part is commented: Mixing analysis can be done, input AOD with events
	16	// is opened in the AliCaloTrackReader::Init()
	17
1c5acb87	18	// -- Author: Gustavo Conesa (INFN-LNF)
	19
	20	// --- ROOT system ---
	21	#include "TObject.h"
591cc579	22	class TObjArray ;
a97cd470	23	#include "TString.h"
591cc579	24	class TTree ;
1c5acb87	25
	26	//--- ANALYSIS system ---
	27	class AliStack ;
	28	class AliHeader ;
	29	class AliGenEventHeader ;
477d6cee	30	class AliVEvent;
8dacfd76	31	class AliAODEvent;
477d6cee	32	class AliMCEvent;
c8fe2783	33	class AliMixedEvent;
c8fe2783	34	#include "AliVCaloCells.h"
decca433	35	#include "AliFiducialCut.h"
591cc579	36	class AliAODMCHeader;
765d44e7	37	#include "AliCalorimeterUtils.h"
3a58eee6	38	class AliESDtrackCuts;
b6dd6ad2	39	class AliCentrality;
1c5acb87	40
	41	class AliCaloTrackReader : public TObject {
	42
03190ad7	43	public:
1c5acb87	44	AliCaloTrackReader() ; // ctor
1c5acb87	45	virtual ~AliCaloTrackReader() ;//virtual dtor
03190ad7	46	private:
78219bac	47	AliCaloTrackReader(const AliCaloTrackReader & g) ; // cpy ctor
03190ad7	48	AliCaloTrackReader & operator = (const AliCaloTrackReader & g) ;//cpy assignment
	49
	50	public:
1c5acb87	51	enum inputDataType {kESD, kAOD, kMC};
f37fa8d2	52
591cc579	53	//Select generated events, depending on comparison of pT hard and jets.
	54	virtual Bool_t ComparePtHardAndJetPt() ;
	55	virtual Bool_t IsPtHardAndJetPtComparisonSet() const {return fComparePtHardAndJetPt ;}
	56	virtual void SetPtHardAndJetPtComparison(Bool_t compare) { fComparePtHardAndJetPt = compare ;}
	57	virtual Float_t GetPtHardAndJetFactor() const {return fPtHardAndJetPtFactor ;}
	58	virtual void SetPtHardAndJetPtFactor(Float_t factor) { fPtHardAndJetPtFactor = factor ;}
	59
1c5acb87	60	virtual void InitParameters();
	61	virtual void Print(const Option_t * opt) const;
	62
	63	virtual Int_t GetDebug() const { return fDebug ; }
	64	virtual void SetDebug(Int_t d) { fDebug = d ; }
	65	virtual Int_t GetDataType() const { return fDataType ; }
	66	virtual void SetDataType(Int_t data ) { fDataType = data ; }
	67
a79a2424	68	virtual Int_t GetEventNumber() const {return fEventNumber ; }
	69	virtual TString GetCurrentFileName() const {return fCurrentFileName ; }
	70
1c5acb87	71	//Minimum pt setters and getters
	72	virtual Float_t GetEMCALPtMin() const { return fEMCALPtMin ; }
	73	virtual Float_t GetPHOSPtMin() const { return fPHOSPtMin ; }
	74	virtual Float_t GetCTSPtMin() const { return fCTSPtMin ; }
	75
	76	virtual void SetEMCALPtMin(Float_t pt) { fEMCALPtMin = pt ; }
	77	virtual void SetPHOSPtMin(Float_t pt) { fPHOSPtMin = pt ; }
	78	virtual void SetCTSPtMin(Float_t pt) { fCTSPtMin = pt ; }
	79
	80	//Input setters and getters
f37fa8d2	81	Bool_t IsEMCALCluster(AliVCluster *clus) const;
	82	Bool_t IsPHOSCluster (AliVCluster *clus) const;
	83	void SwitchOnOldAODs() {fOldAOD = kTRUE ; }
	84	void SwitchOffOldAODs() {fOldAOD = kFALSE ; }
	85
1c5acb87	86	Bool_t IsCTSSwitchedOn() const { return fFillCTS ; }
f37fa8d2	87	void SwitchOnCTS() {fFillCTS = kTRUE ; }
1c5acb87	88	void SwitchOffCTS() {fFillCTS = kFALSE ; }
	89
	90	Bool_t IsEMCALSwitchedOn() const { return fFillEMCAL ; }
f37fa8d2	91	void SwitchOnEMCAL() {fFillEMCAL = kTRUE ; }
1c5acb87	92	void SwitchOffEMCAL() {fFillEMCAL = kFALSE ; }
	93
	94	Bool_t IsPHOSSwitchedOn() const { return fFillPHOS ; }
f37fa8d2	95	void SwitchOnPHOS() {fFillPHOS = kTRUE ; }
1c5acb87	96	void SwitchOffPHOS() {fFillPHOS = kFALSE ; }
	97
	98	Bool_t IsEMCALCellsSwitchedOn() const { return fFillEMCALCells ; }
f37fa8d2	99	void SwitchOnEMCALCells() {fFillEMCALCells = kTRUE ; }
1c5acb87	100	void SwitchOffEMCALCells() {fFillEMCALCells = kFALSE ; }
	101
	102	Bool_t IsPHOSCellsSwitchedOn() const { return fFillPHOSCells ; }
f37fa8d2	103	void SwitchOnPHOSCells() {fFillPHOSCells = kTRUE ; }
1c5acb87	104	void SwitchOffPHOSCells() {fFillPHOSCells = kFALSE ; }
1c5acb87	105
29b2ceec	106	virtual Bool_t FillInputEvent(const Int_t iEntry, const char *currentFileName) ;
c8fe2783	107	virtual void FillInputCTS() ;
	108	virtual void FillInputEMCAL() ;
	109	virtual void FillInputPHOS() ;
	110	virtual void FillInputEMCALCells() ;
	111	virtual void FillInputPHOSCells() ;
f37fa8d2	112
f37fa8d2	113	virtual TList * GetAODBranchList() const { return fAODBranchList ; }
1c5acb87	114
f37fa8d2	115	virtual TObjArray* GetAODCTS() const {return fAODCTS ;}
591cc579	116	virtual TObjArray* GetAODEMCAL() const {return fAODEMCAL ;}
f37fa8d2	117	virtual TObjArray* GetAODPHOS() const {return fAODPHOS ;}
c8fe2783	118	virtual AliVCaloCells* GetEMCALCells() const { return fEMCALCells ;}
f37fa8d2	119	virtual AliVCaloCells* GetPHOSCells() const { return fPHOSCells ;}
1c5acb87	120
591cc579	121	//Get MC informatio
591cc579	122	//Kinematics and galice.root available
477d6cee	123	virtual AliStack* GetStack() const ;
477d6cee	124	virtual AliHeader* GetHeader() const ;
1c5acb87	125	virtual AliGenEventHeader* GetGenEventHeader() const ;
591cc579	126	//Filtered kinematics in AOD
	127	virtual TClonesArray* GetAODMCParticles(Int_t input = 0) const ;
	128	virtual AliAODMCHeader* GetAODMCHeader(Int_t input = 0) const ;
	129
f8006433	130	virtual AliVEvent* GetInputEvent() const {return fInputEvent;}
	131	virtual AliAODEvent* GetOutputEvent() const {return fOutputEvent;}
	132	virtual AliMCEvent* GetMC() const {return fMC;}
	133	virtual AliMixedEvent* GetMixedEvent() const {return fMixedEvent;}
	134	virtual Int_t GetNMixedEvent() const {return fNMixedEvent ; }
	135
	136	virtual Double_t GetBField() const { return 0.;}
591cc579	137
591cc579	138	virtual void Init();
f8006433	139
c8fe2783	140	// virtual void SetInputEvent(AliVEvent* const input) {fInputEvent = input;}
c8fe2783	141	virtual void SetInputEvent(AliVEvent* const input) ;
8dacfd76	142	virtual void SetOutputEvent(AliAODEvent* const aod) {fOutputEvent = aod;}
8dacfd76	143	virtual void SetMC(AliMCEvent* const mc) {fMC = mc;}
1c5acb87	144
	145	virtual void ResetLists();
	146
decca433	147	virtual AliFiducialCut * GetFiducialCut() {if(!fFiducialCut) fFiducialCut = new AliFiducialCut();
decca433	148	return fFiducialCut ;}
ff45398a	149	virtual void SetFiducialCut(AliFiducialCut * const fc) { fFiducialCut = fc ;}
decca433	150	virtual Bool_t IsFiducialCutOn() {return fCheckFidCut ; }
	151	virtual void SwitchOnFiducialCut() { fCheckFidCut = kTRUE; fFiducialCut = new AliFiducialCut();}
	152	virtual void SwitchOffFiducialCut() { fCheckFidCut = kFALSE;}
29b2ceec	153
477d6cee	154	virtual void SetInputOutputMCEvent(AliVEvent* /esd/, AliAODEvent* /aod/, AliMCEvent* /mc/) {;}
591cc579	155
591cc579	156	//Methods for mixing with external input file (AOD)
1e68a3f4	157	//virtual TTree* GetSecondInputAODTree() const {return fSecondInputAODTree ; }
591cc579	158	//virtual void SetSecondInputAODTree(TTree * tree) {fSecondInputAODTree = tree ;
	159	// fSecondInputAODEvent->ReadFromTree(tree);}//Connect tree and AOD event.
	160
1e68a3f4	161	//virtual AliAODEvent* GetSecondInputAODEvent() const { return fSecondInputAODEvent ; }
591cc579	162
1e68a3f4	163	//TString GetSecondInputFileName() const {return fSecondInputFileName ; }
1e68a3f4	164	//void SetSecondInputFileName(TString name) { fSecondInputFileName = name ; }
1c5acb87	165
1e68a3f4	166	//Int_t GetSecondInputFirstEvent() const {return fSecondInputFirstEvent ; }
1e68a3f4	167	//void SetSecondInputFirstEvent(Int_t iEvent0) { fSecondInputFirstEvent = iEvent0 ; }
591cc579	168
1e68a3f4	169	// Int_t GetAODCTSNormalInputEntries() {if(!fSecondInputAODTree) { fAODCTSNormalInputEntries = fAODCTS->GetEntriesFast() ;}
	170	// return fAODCTSNormalInputEntries ; }
	171	// Int_t GetAODEMCALNormalInputEntries() {if(!fSecondInputAODTree) { fAODEMCALNormalInputEntries = fAODEMCAL->GetEntriesFast();}
	172	// return fAODEMCALNormalInputEntries ; }
	173	// Int_t GetAODPHOSNormalInputEntries() {if(!fSecondInputAODTree) { fAODPHOSNormalInputEntries = fAODPHOS->GetEntriesFast() ;}
	174	// return fAODPHOSNormalInputEntries ; }
591cc579	175
3a58eee6	176	// Track selection
3a58eee6	177	ULong_t GetTrackStatus() const {return fTrackStatus ; }
591cc579	178	void SetTrackStatus(ULong_t bit) { fTrackStatus = bit ; }
591cc579	179
3a58eee6	180	AliESDtrackCuts* GetTrackCuts() const { return fESDtrackCuts ; }
	181	void SetTrackCuts(AliESDtrackCuts * cuts) { fESDtrackCuts = cuts ; }
	182	Int_t GetTrackMultiplicity() const { return fTrackMult ; }
	183	Float_t GetTrackMultiplicityEtaCut() const { return fTrackMultEtaCut ; }
	184	void SetTrackMultiplicityEtaCut(Float_t eta) { fTrackMultEtaCut = eta ; }
	185
	186	//MC switchs
591cc579	187	void SwitchOnStack() { fReadStack = kTRUE ; }
	188	void SwitchOffStack() { fReadStack = kFALSE ; }
	189	void SwitchOnAODMCParticles() { fReadAODMCParticles = kTRUE ; }
	190	void SwitchOffAODMCParticles() { fReadAODMCParticles = kFALSE ; }
	191	Bool_t ReadStack() const { return fReadStack ; }
	192	Bool_t ReadAODMCParticles() const { return fReadAODMCParticles ; }
	193
42dc8e7d	194	void SetDeltaAODFileName(TString name ) {fDeltaAODFileName = name ; }
42dc8e7d	195	TString GetDeltaAODFileName() const {return fDeltaAODFileName ; }
72d2488e	196
	197	void SetFiredTriggerClassName(TString name ) {fFiredTriggerClassName = name ; }
	198	TString GetFiredTriggerClassName() const {return fFiredTriggerClassName ; }
	199	virtual TString GetFiredTriggerClasses() {return "";}
0866d83a	200
c1ac3823	201	void AnalyzeOnlyLED() {fAnaLED = kTRUE;}
	202	void AnalyzeOnlyPhysics() {fAnaLED = kFALSE;}
	203
486258c9	204	TString GetTaskName() const {return fTaskName;}
	205	void SetTaskName(TString name) {fTaskName = name;}
	206
765d44e7	207	AliCalorimeterUtils * GetCaloUtils() const {return fCaloUtils ; }
765d44e7	208	void SetCaloUtils(AliCalorimeterUtils * caloutils) { fCaloUtils = caloutils ; }
c8fe2783	209
f8006433	210	virtual void GetVertex(Double_t v[3]) const ;
	211	virtual Double_t* GetVertex(const Int_t evtIndex) const {return fVertex[evtIndex];}
	212	virtual void GetVertex(Double_t vertex[3], const Int_t evtIndex) const ;
	213	virtual void FillVertexArray();
	214	// virtual void GetSecondInputAODVertex(Double_t *) const {;}
	215
f37fa8d2	216	void SwitchOnWriteDeltaAOD() {fWriteOutputDeltaAOD = kTRUE ; }
	217	void SwitchOffWriteDeltaAOD() {fWriteOutputDeltaAOD = kFALSE ; }
	218	Bool_t WriteDeltaAODToFile() const {return fWriteOutputDeltaAOD ; }
1e68a3f4	219
798a9b04	220	virtual void FillInputVZERO(){;}
	221	Int_t GetV0Signal(Int_t i) const { return fV0ADC[i];}
	222	Int_t GetV0Multiplicity(Int_t i) const { return fV0Mul[i];}
	223
af7b3903	224	void SwitchOnCaloFilterPatch() {fCaloFilterPatch = kTRUE ; fFillCTS = kFALSE; }
	225	void SwitchOffCaloFilterPatch() {fCaloFilterPatch = kFALSE ; }
	226	Bool_t IsCaloFilterPatchOn() {if(fDataType == kAOD) { return fCaloFilterPatch ; }
	227	else { return kFALSE ; } }
eb3e2665	228
b6dd6ad2	229	virtual AliCentrality* GetCentrality() const {return 0x0;}
eb3e2665	230
eb3e2665	231
0ae57829	232	//MC reader methods:
	233
	234	virtual void AddNeutralParticlesArray(TArrayI & /array/) { ; }
	235	virtual void AddChargedParticlesArray(TArrayI & /array/) { ; }
	236	virtual void AddStatusArray(TArrayI & /array/) { ; }
	237
	238	virtual void SwitchOnPi0Decay() { ; }
	239	virtual void SwitchOffPi0Decay() { ; }
	240	virtual void SwitchOnStatusSelection() { ; }
	241	virtual void SwitchOffStatusSelection() { ; }
	242	virtual void SwitchOnOverlapCheck() { ; }
	243	virtual void SwitchOffOverlapCheck() { ; }
	244
	245	virtual void SetEMCALOverlapAngle(Float_t /angle/) { ; }
	246	virtual void SetPHOSOverlapAngle(Float_t /angle/) { ; }
	247
af7b3903	248
0ae57829	249
1c5acb87	250	protected:
7e25653f	251	Int_t fEventNumber; // Event number
	252	TString fCurrentFileName;// Current file name under analysis
	253	Int_t fDataType ; // Select MC:Kinematics, Data:ESD/AOD, MCData:Both
	254	Int_t fDebug; // Debugging level
	255	AliFiducialCut * fFiducialCut; //! Acceptance cuts
	256	Bool_t fCheckFidCut ; // Do analysis for clusters in defined region
decca433	257
591cc579	258	Bool_t fComparePtHardAndJetPt; // In MonteCarlo, jet events, reject fake events with wrong jet energy.
	259	Float_t fPtHardAndJetPtFactor; // Factor between ptHard and jet pT to reject/accept event.
	260
7e25653f	261	Float_t fCTSPtMin; // pT Threshold on charged particles
	262	Float_t fEMCALPtMin; // pT Threshold on emcal clusters
	263	Float_t fPHOSPtMin; // pT Threshold on phos clusters
1c5acb87	264
7e25653f	265	TList * fAODBranchList ; //! List with AOD branches created and needed in analysis
	266	TObjArray * fAODCTS ; //! temporal referenced array with tracks
	267	TObjArray * fAODEMCAL ; //! temporal referenced array with EMCAL CaloClusters
	268	TObjArray * fAODPHOS ; //! temporal referenced array with PHOS CaloClusters
	269	AliVCaloCells * fEMCALCells ; //! temporal array with EMCAL CaloCells, ESD or AOD
	270	AliVCaloCells * fPHOSCells ; //! temporal array with PHOS CaloCells, ESD or AOD
1c5acb87	271
7e25653f	272	AliVEvent * fInputEvent; //! pointer to esd or aod input
	273	AliAODEvent * fOutputEvent; //! pointer to aod output
	274	AliMCEvent * fMC; //! Monte Carlo Event Handler
1c5acb87	275
7e25653f	276	Bool_t fFillCTS; // use data from CTS
	277	Bool_t fFillEMCAL; // use data from EMCAL
	278	Bool_t fFillPHOS; // use data from PHOS
	279	Bool_t fFillEMCALCells; // use data from EMCAL
	280	Bool_t fFillPHOSCells; // use data from PHOS
1c5acb87	281
1e68a3f4	282	// TTree * fSecondInputAODTree; // Tree with second input AOD, for mixing analysis.
	283	// AliAODEvent* fSecondInputAODEvent; //! pointer to second input AOD event.
	284	// TString fSecondInputFileName; // File with AOD data to mix with normal stream of data.
	285	// Int_t fSecondInputFirstEvent; // First event to be considered in the mixing.
	286	//
	287	// Int_t fAODCTSNormalInputEntries; // Number of entries in CTS in case of standard input, larger with mixing.
	288	// Int_t fAODEMCALNormalInputEntries; // Number of entries in EMCAL in case of standard input, larger with mixing.
	289	// Int_t fAODPHOSNormalInputEntries; // Number of entries in PHOS in case of standard input, larger with mixing.
591cc579	290
7e25653f	291	ULong_t fTrackStatus ; // Track selection bit, select tracks refitted in TPC, ITS ...
3a58eee6	292	AliESDtrackCuts *fESDtrackCuts ; // Track cut
	293	Int_t fTrackMult ; // Track multiplicity
	294	Float_t fTrackMultEtaCut ; // Track multiplicity eta cut
7e25653f	295	Bool_t fReadStack ; // Access kine information from stack
7e25653f	296	Bool_t fReadAODMCParticles ; // Access kine information from filtered AOD MC particles
591cc579	297
7e25653f	298	TString fDeltaAODFileName ; // Delta AOD file name
7e25653f	299	TString fFiredTriggerClassName; // Name of trigger event type used to do the analysis
afabc52f	300
7e25653f	301	Bool_t fAnaLED; // Analyze LED data only.
c1ac3823	302
7e25653f	303	TString fTaskName; // Name of task that executes the analysis
765d44e7	304
7e25653f	305	AliCalorimeterUtils * fCaloUtils ; // Pointer to CalorimeterUtils
c8fe2783	306
7e25653f	307	AliMixedEvent * fMixedEvent ; //! mixed event object. This class is not the owner
	308	Int_t fNMixedEvent ; // number of events in mixed event buffer
	309	Double_t ** fVertex ; //! vertex array 3 dim for each mixed event buffer
c8fe2783	310
7e25653f	311	Bool_t fWriteOutputDeltaAOD;// Write the created delta AOD objects into file
7e25653f	312	Bool_t fOldAOD; // Old AODs, before revision 4.20
f37fa8d2	313
798a9b04	314	Int_t fV0ADC[2] ; // Integrated V0 signal
	315	Int_t fV0Mul[2] ; // Integrated V0 Multiplicity
	316
af7b3903	317	Bool_t fCaloFilterPatch; // CaloFilter patch
798a9b04	318
af7b3903	319	ClassDef(AliCaloTrackReader,21)
1c5acb87	320	} ;
	321
	322
	323	#endif //ALICALOTRACKREADER_H
	324
	325
	326