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

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

//_________________________________________________________________________
// Class for track/cluster acceptance selection
// Selection in Central barrel, DCAL and PHOS
//  
// Several selection regions possible for the different
// detectors
//
//*-- Author: Gustavo Conesa (INFN-LNF)

// --- ROOT system ---
#include <TObject.h> 
#include <TArrayF.h> 

class TString ;
//class TLorentzVector ;


class AliFiducialCut : public TObject {
  
public: 
  AliFiducialCut() ; // ctor
  virtual  ~AliFiducialCut() ;//virtual dtor
  
  void      InitParameters();

  Bool_t    CheckFiducialRegion(Float_t eta, Float_t phi,
                                const TArrayF* minphi, const TArrayF* maxphi,
                                const TArrayF* mineta, const TArrayF* maxeta) const ;

  //Bool_t    IsInFiducialCut    (TLorentzVector lv, TString det) const ;
  Bool_t    IsInFiducialCut    (Float_t eta, Float_t phi, Int_t det) const ;
  
  void      DoCTSFiducialCut  (Bool_t b)     { fCTSFiducialCut   = b    ; }
  void      DoEMCALFiducialCut(Bool_t b)     { fEMCALFiducialCut = b    ; }
  void      DoPHOSFiducialCut (Bool_t b)     { fPHOSFiducialCut  = b    ; }
  void      DoDCALFiducialCut (Bool_t b)     { fDCALFiducialCut  = b    ; }
  
  Bool_t    GetCTSFiducialCutStatus()  const { return fCTSFiducialCut   ; }
  Bool_t    GetEMCALFiducialCut()      const { return fEMCALFiducialCut ; }
  Bool_t    GetPHOSFiducialCutStatus() const { return fPHOSFiducialCut  ; }
  Bool_t    GetDCALFiducialCut()       const { return fDCALFiducialCut  ; }

  void      SetSimpleCTSFiducialCut  (Float_t abseta, Float_t phimin, Float_t phimax) ;
  void      SetSimpleEMCALFiducialCut(Float_t abseta, Float_t phimin, Float_t phimax) ;
  void      SetSimplePHOSFiducialCut (Float_t abseta, Float_t phimin, Float_t phimax) ;
  void      SetSimpleDCALFiducialCut (Float_t abseta, Float_t phimin, Float_t phimax) ;
  
  void      Print(const Option_t * opt)const;
  
  void      AddCTSFidCutMaxEtaArray(Int_t size, Float_t* array)  
                                              { fCTSFidCutMaxEta->Set(size,array)   ; } 
  TArrayF * GetCTSFidCutMaxEtaArray() const   { return fCTSFidCutMaxEta             ; }
  
  void      AddCTSFidCutMaxPhiArray(Int_t size, Float_t* array)  
                                              { fCTSFidCutMaxPhi->Set(size,array)   ; }
  TArrayF * GetCTSFidCutMaxPhiArray() const   { return fCTSFidCutMaxPhi             ; }
  
  void      AddCTSFidCutMinEtaArray(Int_t size, Float_t* array)  
                                              { fCTSFidCutMinEta->Set(size,array)   ; } 
  TArrayF * GetCTSFidCutMinEtaArray() const   { return fCTSFidCutMinEta             ; }
  
  void      AddCTSFidCutMinPhiArray(Int_t size, Float_t* array)  
                                              { fCTSFidCutMinPhi->Set(size,array)   ; }
  TArrayF * GetCTSFidCutMinPhiArray() const   { return fCTSFidCutMinPhi             ; }
  
  void      AddEMCALFidCutMaxEtaArray(Int_t size, Float_t* array)  
                                              { fEMCALFidCutMaxEta->Set(size,array) ; } 
  TArrayF * GetEMCALFidCutMaxEtaArray() const { return fEMCALFidCutMaxEta           ; }
  
  void      AddEMCALFidCutMaxPhiArray(Int_t size, Float_t* array)  
                                              { fEMCALFidCutMaxPhi->Set(size,array) ; }
  TArrayF * GetEMCALFidCutMaxPhiArray() const { return fEMCALFidCutMaxPhi           ; }
  
  void      AddEMCALFidCutMinEtaArray(Int_t size, Float_t* array)  
                                              { fEMCALFidCutMinEta->Set(size,array) ; } 
  TArrayF * GetEMCALFidCutMinEtaArray() const { return fEMCALFidCutMinEta           ; }
  
  void      AddEMCALFidCutMinPhiArray(Int_t size, Float_t* array)  
                                              { fEMCALFidCutMinPhi->Set(size,array) ; }
  TArrayF * GetEMCALFidCutMinPhiArray() const { return fEMCALFidCutMinPhi           ; }
  
  void      AddPHOSFidCutMaxEtaArray(Int_t size, Float_t* array)  
                                              { fPHOSFidCutMaxEta->Set(size,array)  ; } 
  TArrayF * GetPHOSFidCutMaxEtaArray() const  { return fPHOSFidCutMaxEta            ; }
  
  void      AddPHOSFidCutMaxPhiArray(Int_t size, Float_t* array)  
                                              { fPHOSFidCutMaxPhi->Set(size,array)  ; }
  TArrayF * GetPHOSFidCutMaxPhiArray() const  { return fPHOSFidCutMaxPhi            ; }
  
  void      AddPHOSFidCutMinEtaArray(Int_t size, Float_t* array)  
                                              { fPHOSFidCutMinEta->Set(size,array)  ; } 
  TArrayF * GetPHOSFidCutMinEtaArray() const  { return fPHOSFidCutMinEta            ; }

  void      AddPHOSFidCutMinPhiArray(Int_t size, Float_t* array)  
                                              { fPHOSFidCutMinPhi->Set(size,array)  ; }
  TArrayF * GetPHOSFidCutMinPhiArray() const  { return fPHOSFidCutMinPhi            ; }
  
  void      AddDCALFidCutMaxEtaArray(Int_t size, Float_t* array)
  { fDCALFidCutMaxEta->Set(size,array) ; }
  TArrayF * GetDCALFidCutMaxEtaArray() const { return fDCALFidCutMaxEta           ; }
  
  void      AddDCALFidCutMaxPhiArray(Int_t size, Float_t* array)
  { fDCALFidCutMaxPhi->Set(size,array) ; }
  TArrayF * GetDCALFidCutMaxPhiArray() const { return fDCALFidCutMaxPhi           ; }
  
  void      AddDCALFidCutMinEtaArray(Int_t size, Float_t* array)
  { fDCALFidCutMinEta->Set(size,array) ; }
  TArrayF * GetDCALFidCutMinEtaArray() const { return fDCALFidCutMinEta           ; }
  
  void      AddDCALFidCutMinPhiArray(Int_t size, Float_t* array)
  { fDCALFidCutMinPhi->Set(size,array) ; }
  TArrayF * GetDCALFidCutMinPhiArray() const { return fDCALFidCutMinPhi           ; }

  enum detector {kEMCAL = 0, kPHOS = 1, kCTS = 2, kDCAL = 3, kDCALPHOS = 4 };
  
private:
  
  //Detector acceptance cuts
  Bool_t    fEMCALFiducialCut ;  // Apply fiducial cuts to EMCAL clusters
  Bool_t    fDCALFiducialCut  ;  // Apply fiducial cuts to DCAL clusters
  Bool_t    fPHOSFiducialCut  ;  // Apply fiducial cuts to PHOS clusters
  Bool_t    fCTSFiducialCut   ;  // Apply fiducial cuts to  CTS tracks
  
  TArrayF * fCTSFidCutMinEta ;   // Take particles in CTS with eta > fCTSFidCutMinEta
  TArrayF * fCTSFidCutMinPhi ;   // Take particles in CTS with phi > fCTSFidCutMinPhi
  TArrayF * fCTSFidCutMaxEta ;   // Take particles in CTS with eta < fCTSFidCutMaxEta
  TArrayF * fCTSFidCutMaxPhi ;   // Take particles in CTS with phi > fCTSFidCutMaxPhi
  
  TArrayF * fEMCALFidCutMinEta ; // Take particles in EMCAL with eta > fEMCALFidCutMinEta
  TArrayF * fEMCALFidCutMinPhi ; // Take particles in EMCAL with phi > fEMCALFidCutMinPhi
  TArrayF * fEMCALFidCutMaxEta ; // Take particles in EMCAL with eta < fEMCALFidCutMaxEta
  TArrayF * fEMCALFidCutMaxPhi ; // Take particles in EMCAL with phi > fEMCALFidCutMaxPhi
  
  TArrayF * fPHOSFidCutMinEta ;  // Take particles in PHOS with eta > fPHOSFidCutMinEta
  TArrayF * fPHOSFidCutMinPhi ;  // Take particles in PHOS with phi > fPHOSFidCutMinPhi
  TArrayF * fPHOSFidCutMaxEta ;  // Take particles in PHOS with eta < fPHOSFidCutMaxEta
  TArrayF * fPHOSFidCutMaxPhi ;  // Take particles in PHOS with phi > fPHOSFidCutMaxPhi
  
  TArrayF * fDCALFidCutMinEta ; // Take particles in DCAL with eta > fDCALFidCutMinEta
  TArrayF * fDCALFidCutMinPhi ; // Take particles in DCAL with phi > fDCALFidCutMinPhi
  TArrayF * fDCALFidCutMaxEta ; // Take particles in DCAL with eta < fDCALFidCutMaxEta
  TArrayF * fDCALFidCutMaxPhi ; // Take particles in DCAL with phi > fDCALFidCutMaxPhi
  
  AliFiducialCut(              const AliFiducialCut & g) ; // cpy ctor
  AliFiducialCut & operator = (const AliFiducialCut & g) ; // cpy assignment
  
  ClassDef(AliFiducialCut,2)
  
} ;


#endif //ALIFIDUCIALCUT_H
Commit	Line	Data
ff45398a	1	#ifndef ALIFIDUCIALCUT_H
ff45398a	2	#define ALIFIDUCIALCUT_H
1c5acb87	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
1c5acb87	4	* See cxx source for full Copyright notice */
1c5acb87	5
	6	//_________________________________________________________________________
	7	// Class for track/cluster acceptance selection
87fae7e8	8	// Selection in Central barrel, DCAL and PHOS
5efec477	9	//
	10	// Several selection regions possible for the different
	11	// detectors
1c5acb87	12	//
	13	//*-- Author: Gustavo Conesa (INFN-LNF)
	14
	15	// --- ROOT system ---
	16	#include <TObject.h>
	17	#include <TArrayF.h>
	18
	19	class TString ;
05f778ab	20	//class TLorentzVector ;
1c5acb87	21
1c5acb87	22
ff45398a	23	class AliFiducialCut : public TObject {
c5693f62	24
c5693f62	25	public:
ff45398a	26	AliFiducialCut() ; // ctor
c5693f62	27	virtual ~AliFiducialCut() ;//virtual dtor
78219bac	28
c5693f62	29	void InitParameters();
87fae7e8	30
	31	Bool_t CheckFiducialRegion(Float_t eta, Float_t phi,
	32	const TArrayF* minphi, const TArrayF* maxphi,
c5693f62	33	const TArrayF* mineta, const TArrayF* maxeta) const ;
87fae7e8	34
02e3ce0c	35	//Bool_t IsInFiducialCut (TLorentzVector lv, TString det) const ;
87fae7e8	36	Bool_t IsInFiducialCut (Float_t eta, Float_t phi, Int_t det) const ;
1c5acb87	37
b960c7eb	38	void DoCTSFiducialCut (Bool_t b) { fCTSFiducialCut = b ; }
	39	void DoEMCALFiducialCut(Bool_t b) { fEMCALFiducialCut = b ; }
	40	void DoPHOSFiducialCut (Bool_t b) { fPHOSFiducialCut = b ; }
87fae7e8	41	void DoDCALFiducialCut (Bool_t b) { fDCALFiducialCut = b ; }
c5693f62	42
b960c7eb	43	Bool_t GetCTSFiducialCutStatus() const { return fCTSFiducialCut ; }
	44	Bool_t GetEMCALFiducialCut() const { return fEMCALFiducialCut ; }
	45	Bool_t GetPHOSFiducialCutStatus() const { return fPHOSFiducialCut ; }
87fae7e8	46	Bool_t GetDCALFiducialCut() const { return fDCALFiducialCut ; }
87fae7e8	47
8a2dbbff	48	void SetSimpleCTSFiducialCut (Float_t abseta, Float_t phimin, Float_t phimax) ;
	49	void SetSimpleEMCALFiducialCut(Float_t abseta, Float_t phimin, Float_t phimax) ;
	50	void SetSimplePHOSFiducialCut (Float_t abseta, Float_t phimin, Float_t phimax) ;
87fae7e8	51	void SetSimpleDCALFiducialCut (Float_t abseta, Float_t phimin, Float_t phimax) ;
c5693f62	52
c5693f62	53	void Print(const Option_t * opt)const;
c5693f62	54
	55	void AddCTSFidCutMaxEtaArray(Int_t size, Float_t* array)
	56	{ fCTSFidCutMaxEta->Set(size,array) ; }
	57	TArrayF * GetCTSFidCutMaxEtaArray() const { return fCTSFidCutMaxEta ; }
	58
	59	void AddCTSFidCutMaxPhiArray(Int_t size, Float_t* array)
	60	{ fCTSFidCutMaxPhi->Set(size,array) ; }
	61	TArrayF * GetCTSFidCutMaxPhiArray() const { return fCTSFidCutMaxPhi ; }
	62
	63	void AddCTSFidCutMinEtaArray(Int_t size, Float_t* array)
	64	{ fCTSFidCutMinEta->Set(size,array) ; }
	65	TArrayF * GetCTSFidCutMinEtaArray() const { return fCTSFidCutMinEta ; }
	66
	67	void AddCTSFidCutMinPhiArray(Int_t size, Float_t* array)
	68	{ fCTSFidCutMinPhi->Set(size,array) ; }
	69	TArrayF * GetCTSFidCutMinPhiArray() const { return fCTSFidCutMinPhi ; }
	70
	71	void AddEMCALFidCutMaxEtaArray(Int_t size, Float_t* array)
	72	{ fEMCALFidCutMaxEta->Set(size,array) ; }
	73	TArrayF * GetEMCALFidCutMaxEtaArray() const { return fEMCALFidCutMaxEta ; }
	74
	75	void AddEMCALFidCutMaxPhiArray(Int_t size, Float_t* array)
	76	{ fEMCALFidCutMaxPhi->Set(size,array) ; }
	77	TArrayF * GetEMCALFidCutMaxPhiArray() const { return fEMCALFidCutMaxPhi ; }
	78
	79	void AddEMCALFidCutMinEtaArray(Int_t size, Float_t* array)
	80	{ fEMCALFidCutMinEta->Set(size,array) ; }
	81	TArrayF * GetEMCALFidCutMinEtaArray() const { return fEMCALFidCutMinEta ; }
	82
	83	void AddEMCALFidCutMinPhiArray(Int_t size, Float_t* array)
	84	{ fEMCALFidCutMinPhi->Set(size,array) ; }
	85	TArrayF * GetEMCALFidCutMinPhiArray() const { return fEMCALFidCutMinPhi ; }
	86
	87	void AddPHOSFidCutMaxEtaArray(Int_t size, Float_t* array)
	88	{ fPHOSFidCutMaxEta->Set(size,array) ; }
	89	TArrayF * GetPHOSFidCutMaxEtaArray() const { return fPHOSFidCutMaxEta ; }
	90
	91	void AddPHOSFidCutMaxPhiArray(Int_t size, Float_t* array)
	92	{ fPHOSFidCutMaxPhi->Set(size,array) ; }
	93	TArrayF * GetPHOSFidCutMaxPhiArray() const { return fPHOSFidCutMaxPhi ; }
	94
	95	void AddPHOSFidCutMinEtaArray(Int_t size, Float_t* array)
	96	{ fPHOSFidCutMinEta->Set(size,array) ; }
	97	TArrayF * GetPHOSFidCutMinEtaArray() const { return fPHOSFidCutMinEta ; }
1c5acb87	98
c5693f62	99	void AddPHOSFidCutMinPhiArray(Int_t size, Float_t* array)
	100	{ fPHOSFidCutMinPhi->Set(size,array) ; }
	101	TArrayF * GetPHOSFidCutMinPhiArray() const { return fPHOSFidCutMinPhi ; }
	102
87fae7e8	103	void AddDCALFidCutMaxEtaArray(Int_t size, Float_t* array)
	104	{ fDCALFidCutMaxEta->Set(size,array) ; }
	105	TArrayF * GetDCALFidCutMaxEtaArray() const { return fDCALFidCutMaxEta ; }
	106
	107	void AddDCALFidCutMaxPhiArray(Int_t size, Float_t* array)
	108	{ fDCALFidCutMaxPhi->Set(size,array) ; }
	109	TArrayF * GetDCALFidCutMaxPhiArray() const { return fDCALFidCutMaxPhi ; }
	110
	111	void AddDCALFidCutMinEtaArray(Int_t size, Float_t* array)
	112	{ fDCALFidCutMinEta->Set(size,array) ; }
	113	TArrayF * GetDCALFidCutMinEtaArray() const { return fDCALFidCutMinEta ; }
	114
	115	void AddDCALFidCutMinPhiArray(Int_t size, Float_t* array)
	116	{ fDCALFidCutMinPhi->Set(size,array) ; }
	117	TArrayF * GetDCALFidCutMinPhiArray() const { return fDCALFidCutMinPhi ; }
	118
	119	enum detector {kEMCAL = 0, kPHOS = 1, kCTS = 2, kDCAL = 3, kDCALPHOS = 4 };
	120
b960c7eb	121	private:
c5693f62	122
	123	//Detector acceptance cuts
	124	Bool_t fEMCALFiducialCut ; // Apply fiducial cuts to EMCAL clusters
87fae7e8	125	Bool_t fDCALFiducialCut ; // Apply fiducial cuts to DCAL clusters
b960c7eb	126	Bool_t fPHOSFiducialCut ; // Apply fiducial cuts to PHOS clusters
b960c7eb	127	Bool_t fCTSFiducialCut ; // Apply fiducial cuts to CTS tracks
c5693f62	128
	129	TArrayF * fCTSFidCutMinEta ; // Take particles in CTS with eta > fCTSFidCutMinEta
	130	TArrayF * fCTSFidCutMinPhi ; // Take particles in CTS with phi > fCTSFidCutMinPhi
	131	TArrayF * fCTSFidCutMaxEta ; // Take particles in CTS with eta < fCTSFidCutMaxEta
	132	TArrayF * fCTSFidCutMaxPhi ; // Take particles in CTS with phi > fCTSFidCutMaxPhi
	133
	134	TArrayF * fEMCALFidCutMinEta ; // Take particles in EMCAL with eta > fEMCALFidCutMinEta
	135	TArrayF * fEMCALFidCutMinPhi ; // Take particles in EMCAL with phi > fEMCALFidCutMinPhi
	136	TArrayF * fEMCALFidCutMaxEta ; // Take particles in EMCAL with eta < fEMCALFidCutMaxEta
	137	TArrayF * fEMCALFidCutMaxPhi ; // Take particles in EMCAL with phi > fEMCALFidCutMaxPhi
	138
	139	TArrayF * fPHOSFidCutMinEta ; // Take particles in PHOS with eta > fPHOSFidCutMinEta
	140	TArrayF * fPHOSFidCutMinPhi ; // Take particles in PHOS with phi > fPHOSFidCutMinPhi
	141	TArrayF * fPHOSFidCutMaxEta ; // Take particles in PHOS with eta < fPHOSFidCutMaxEta
	142	TArrayF * fPHOSFidCutMaxPhi ; // Take particles in PHOS with phi > fPHOSFidCutMaxPhi
	143
87fae7e8	144	TArrayF * fDCALFidCutMinEta ; // Take particles in DCAL with eta > fDCALFidCutMinEta
	145	TArrayF * fDCALFidCutMinPhi ; // Take particles in DCAL with phi > fDCALFidCutMinPhi
	146	TArrayF * fDCALFidCutMaxEta ; // Take particles in DCAL with eta < fDCALFidCutMaxEta
	147	TArrayF * fDCALFidCutMaxPhi ; // Take particles in DCAL with phi > fDCALFidCutMaxPhi
	148
b960c7eb	149	AliFiducialCut( const AliFiducialCut & g) ; // cpy ctor
b960c7eb	150	AliFiducialCut & operator = (const AliFiducialCut & g) ; // cpy assignment
1c5acb87	151
87fae7e8	152	ClassDef(AliFiducialCut,2)
c5693f62	153
c5693f62	154	} ;
1c5acb87	155
1c5acb87	156
ff45398a	157	#endif //ALIFIDUCIALCUT_H
1c5acb87	158
	159
	160