[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 TClonesArrays (PHOS, EMCAL, CTS)
//                 : AliCaloTrackMCReader: Fills Kinematics data in 3 TClonesArrays (PHOS, EMCAL, CTS)
//                 : AliCaloTrackAODReader: Fills AOD data in 3 TClonesArrays (PHOS, EMCAL, CTS) 
//                          
// -- Author: Gustavo Conesa (INFN-LNF)

// --- ROOT system ---
#include "TObject.h" 
class TClonesArray ; 
class TLorentzVector ;
class TString ;
#include "TArrayF.h"  

//--- ANALYSIS system ---
class AliStack ; 
class AliHeader ; 
class AliGenEventHeader ; 
#include "AliESDEvent.h" 
#include "AliAODEvent.h" 
#include "AliMCEvent.h" 
class AliLog ;
#include "AliFidutialCut.h"

class AliCaloTrackReader : public TObject {

public: 

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

  enum inputDataType {kESD, kAOD, kMC};
  
  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 ; }

  //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 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 void FillInputEvent(Int_t iEntry)  ;
  virtual void FillInputCTS()   {;}
  virtual void FillInputEMCAL() {;}
  virtual void FillInputPHOS()  {;}
  virtual void FillInputEMCALCells() {;}
  virtual void FillInputPHOSCells()  {;}

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

  virtual AliStack*          GetStack()  const ;
  virtual AliHeader*         GetHeader() const ;
  virtual AliGenEventHeader* GetGenEventHeader() const ;
  virtual AliESDEvent* GetESD() const {return fESD;}
  virtual AliAODEvent* GetAOD() const {return fAOD;}
  virtual AliMCEvent*  GetMC()  const {return fMC;}
  virtual AliVEvent*   GetInputEvent()        const {return (new AliESDEvent());}
  virtual void         GetVertex(Double_t * ) const {;}

  virtual void SetESD( AliESDEvent* esd) {fESD = esd;}
  virtual void SetAOD(AliAODEvent* aod)  {fAOD = aod;}
  virtual void SetMC(AliMCEvent* mc)     {fMC  = mc;}

  virtual void ResetLists();

  virtual AliFidutialCut * GetFidutialCut() const {return  fFidutialCut ;}
  virtual void SetFidutialCut(AliFidutialCut * fc) { fFidutialCut = fc ;}

  virtual void SetInputEvent(TObject* /*esd*/, TObject* /*aod*/, TObject* /*mc*/) {;}

 protected:
  Int_t			   fEventNumber; // Event number
  Int_t            fDataType ;   // Select MC:Kinematics, Data:ESD/AOD, MCData:Both
  Int_t            fDebug;       // Debugging level
  AliFidutialCut * fFidutialCut; // Acceptance cuts
		
  Float_t        fCTSPtMin;      // pT  Threshold on charged particles 
  Float_t        fEMCALPtMin;    // pT Threshold on emcal clusters
  Float_t        fPHOSPtMin;     // pT  Threshold on phos clusters

  TClonesArray * fAODCTS ;        //! temporal array with tracks
  TClonesArray * fAODEMCAL ;      //! temporal array with EMCAL CaloClusters
  TClonesArray * fAODPHOS ;       //! temporal array with PHOS CaloClusters
  TNamed *       fEMCALCells ;    //! temporal array with EMCAL CaloCells, ESD or AOD
  TNamed *       fPHOSCells ;     //! temporal array with PHOS CaloCells, ESD or AOD

  AliESDEvent *  fESD;            //! pointer to esd
  AliAODEvent *  fAOD;            //! pointer to aod
  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

  ClassDef(AliCaloTrackReader,1)
} ;


#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.
	11	// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
	12	// : AliCaloTrackMCReader: Fills Kinematics data in 3 TClonesArrays (PHOS, EMCAL, CTS)
	13	// : AliCaloTrackAODReader: Fills AOD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
	14	//
	15	// -- Author: Gustavo Conesa (INFN-LNF)
	16
	17	// --- ROOT system ---
	18	#include "TObject.h"
	19	class TClonesArray ;
	20	class TLorentzVector ;
	21	class TString ;
	22	#include "TArrayF.h"
	23
	24	//--- ANALYSIS system ---
	25	class AliStack ;
	26	class AliHeader ;
	27	class AliGenEventHeader ;
	28	#include "AliESDEvent.h"
	29	#include "AliAODEvent.h"
	30	#include "AliMCEvent.h"
	31	class AliLog ;
	32	#include "AliFidutialCut.h"
	33
	34	class AliCaloTrackReader : public TObject {
	35
	36	public:
	37
	38	AliCaloTrackReader() ; // ctor
	39	AliCaloTrackReader(const AliCaloTrackReader & g) ; // cpy ctor
	40	AliCaloTrackReader & operator = (const AliCaloTrackReader & g) ;//cpy assignment
	41	virtual ~AliCaloTrackReader() ;//virtual dtor
	42
	43	enum inputDataType {kESD, kAOD, kMC};
	44
	45	virtual void InitParameters();
	46	virtual void Print(const Option_t * opt) const;
	47
	48	virtual Int_t GetDebug() const { return fDebug ; }
	49	virtual void SetDebug(Int_t d) { fDebug = d ; }
	50	virtual Int_t GetDataType() const { return fDataType ; }
	51	virtual void SetDataType(Int_t data ) { fDataType = data ; }
	52
6639984f	53	virtual Int_t GetEventNumber() const {return fEventNumber ; }
1c5acb87	54
	55	//Minimum pt setters and getters
	56	virtual Float_t GetEMCALPtMin() const { return fEMCALPtMin ; }
	57	virtual Float_t GetPHOSPtMin() const { return fPHOSPtMin ; }
	58	virtual Float_t GetCTSPtMin() const { return fCTSPtMin ; }
	59
	60	virtual void SetEMCALPtMin(Float_t pt) { fEMCALPtMin = pt ; }
	61	virtual void SetPHOSPtMin(Float_t pt) { fPHOSPtMin = pt ; }
	62	virtual void SetCTSPtMin(Float_t pt) { fCTSPtMin = pt ; }
	63
	64	//Input setters and getters
	65
	66	Bool_t IsCTSSwitchedOn() const { return fFillCTS ; }
	67	void SwitchOnCTS() {fFillCTS = kTRUE ; }
	68	void SwitchOffCTS() {fFillCTS = kFALSE ; }
	69
	70	Bool_t IsEMCALSwitchedOn() const { return fFillEMCAL ; }
	71	void SwitchOnEMCAL() {fFillEMCAL = kTRUE ; }
	72	void SwitchOffEMCAL() {fFillEMCAL = kFALSE ; }
	73
	74	Bool_t IsPHOSSwitchedOn() const { return fFillPHOS ; }
	75	void SwitchOnPHOS() {fFillPHOS = kTRUE ; }
	76	void SwitchOffPHOS() {fFillPHOS = kFALSE ; }
	77
	78	Bool_t IsEMCALCellsSwitchedOn() const { return fFillEMCALCells ; }
	79	void SwitchOnEMCALCells() {fFillEMCALCells = kTRUE ; }
	80	void SwitchOffEMCALCells() {fFillEMCALCells = kFALSE ; }
	81
	82	Bool_t IsPHOSCellsSwitchedOn() const { return fFillPHOSCells ; }
	83	void SwitchOnPHOSCells() {fFillPHOSCells = kTRUE ; }
	84	void SwitchOffPHOSCells() {fFillPHOSCells = kFALSE ; }
	85
6639984f	86	virtual void FillInputEvent(Int_t iEntry) ;
1c5acb87	87	virtual void FillInputCTS() {;}
	88	virtual void FillInputEMCAL() {;}
	89	virtual void FillInputPHOS() {;}
	90	virtual void FillInputEMCALCells() {;}
	91	virtual void FillInputPHOSCells() {;}
	92
	93	virtual TClonesArray* GetAODCTS() const {return fAODCTS ;}
	94	virtual TClonesArray* GetAODEMCAL() const {return fAODEMCAL ;}
	95	virtual TClonesArray* GetAODPHOS() const {return fAODPHOS ;}
	96	virtual TNamed* GetEMCALCells() const {return fEMCALCells ;}
	97	virtual TNamed* GetPHOSCells() const {return fPHOSCells ;}
	98
	99	virtual AliStack* GetStack() const ;
	100	virtual AliHeader* GetHeader() const ;
	101	virtual AliGenEventHeader* GetGenEventHeader() const ;
	102	virtual AliESDEvent* GetESD() const {return fESD;}
	103	virtual AliAODEvent* GetAOD() const {return fAOD;}
	104	virtual AliMCEvent* GetMC() const {return fMC;}
	105	virtual AliVEvent* GetInputEvent() const {return (new AliESDEvent());}
	106	virtual void GetVertex(Double_t * ) const {;}
	107
	108	virtual void SetESD( AliESDEvent* esd) {fESD = esd;}
	109	virtual void SetAOD(AliAODEvent* aod) {fAOD = aod;}
	110	virtual void SetMC(AliMCEvent* mc) {fMC = mc;}
	111
	112	virtual void ResetLists();
	113
	114	virtual AliFidutialCut * GetFidutialCut() const {return fFidutialCut ;}
	115	virtual void SetFidutialCut(AliFidutialCut * fc) { fFidutialCut = fc ;}
	116
	117	virtual void SetInputEvent(TObject* /esd/, TObject* /aod/, TObject* /mc/) {;}
	118
	119	protected:
6639984f	120	Int_t fEventNumber; // Event number
1c5acb87	121	Int_t fDataType ; // Select MC:Kinematics, Data:ESD/AOD, MCData:Both
	122	Int_t fDebug; // Debugging level
	123	AliFidutialCut * fFidutialCut; // Acceptance cuts
6639984f	124
1c5acb87	125	Float_t fCTSPtMin; // pT Threshold on charged particles
	126	Float_t fEMCALPtMin; // pT Threshold on emcal clusters
	127	Float_t fPHOSPtMin; // pT Threshold on phos clusters
	128
	129	TClonesArray * fAODCTS ; //! temporal array with tracks
	130	TClonesArray * fAODEMCAL ; //! temporal array with EMCAL CaloClusters
	131	TClonesArray * fAODPHOS ; //! temporal array with PHOS CaloClusters
	132	TNamed * fEMCALCells ; //! temporal array with EMCAL CaloCells, ESD or AOD
	133	TNamed * fPHOSCells ; //! temporal array with PHOS CaloCells, ESD or AOD
	134
	135	AliESDEvent * fESD; //! pointer to esd
	136	AliAODEvent * fAOD; //! pointer to aod
	137	AliMCEvent * fMC; //! Monte Carlo Event Handler
	138
	139	Bool_t fFillCTS; // use data from CTS
	140	Bool_t fFillEMCAL; // use data from EMCAL
	141	Bool_t fFillPHOS; // use data from PHOS
	142	Bool_t fFillEMCALCells; // use data from EMCAL
	143	Bool_t fFillPHOSCells; // use data from PHOS
	144
	145	ClassDef(AliCaloTrackReader,1)
	146	} ;
	147
	148
	149	#endif //ALICALOTRACKREADER_H
	150
	151
	152