]>
Commit | Line | Data |
---|---|---|
bdcfac30 | 1 | #ifndef ALIGAMMAREADER_H |
2 | #define ALIGAMMAREADER_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 | /* History of cvs commits: | |
8 | * | |
9 | * $Log$ | |
4b707925 | 10 | * Revision 1.2 2007/08/17 12:40:04 schutz |
11 | * New analysis classes by Gustavo Conesa | |
12 | * | |
bdcfac30 | 13 | * Revision 1.1.2.1 2007/07/26 10:32:09 schutz |
14 | * new analysis classes in the the new analysis framework | |
15 | * | |
16 | * | |
17 | */ | |
18 | ||
19 | //_________________________________________________________________________ | |
3bb2c538 | 20 | // Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and |
21 | // Central Barrel Tracking detectors. | |
22 | // Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done. | |
23 | // Mother class of : AliGammaDataReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS) | |
24 | // : AliGammaMCReader: Fills Kinematics data in 3 TClonesArrays (PHOS, EMCAL, CTS) | |
25 | // : AliGammaMCDataReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS) | |
26 | // and MC data in other 3 TClonesArray | |
bdcfac30 | 27 | //*-- Author: Gustavo Conesa (INFN-LNF) |
28 | ||
29 | // --- ROOT system --- | |
bdcfac30 | 30 | #include "TObject.h" |
bdcfac30 | 31 | |
3bb2c538 | 32 | class TClonesArray ; |
33 | class TFormula ; | |
34 | class TParticle ; | |
35 | class Riostream ; | |
36 | //--- AliRoot system --- | |
37 | ||
38 | class AliStack ; | |
39 | class AliESDEvent ; | |
40 | class AliLog ; | |
bdcfac30 | 41 | |
42 | class AliGammaReader : public TObject { | |
43 | ||
44 | public: | |
45 | ||
46 | AliGammaReader() ; // ctor | |
47 | AliGammaReader(const AliGammaReader & g) ; // cpy ctor | |
48 | AliGammaReader & operator = (const AliGammaReader & g) ;//cpy assignment | |
49 | virtual ~AliGammaReader() {;} //virtual dtor | |
50 | ||
4b707925 | 51 | enum PidType { |
52 | kPhoton = 22, | |
53 | kPi0 = 111, | |
54 | kEta = 221, | |
55 | kElectron = 11, | |
56 | kEleCon = 13, | |
57 | kNeutralHadron = 2112, | |
58 | kChargedHadron = 211, | |
59 | kNeutralUnknown = 130, | |
60 | kChargedUnknown=321 | |
61 | }; | |
62 | ||
3bb2c538 | 63 | enum PhotonStatusType { |
64 | kPromptPhoton=2, | |
65 | kFragmentPhoton=3, | |
66 | kPi0DecayPhoton=4, | |
67 | kEtaDecayPhoton=5, | |
68 | kOtherDecayPhoton=6, | |
69 | kUnknown=7 | |
70 | }; | |
71 | ||
72 | enum Datatype {kData, kMC, kMCData}; | |
bdcfac30 | 73 | |
74 | void InitParameters(); | |
75 | ||
3bb2c538 | 76 | Int_t GetDataType() const { return fDataType ; } |
bdcfac30 | 77 | void SetDataType(Int_t data ){fDataType = data ; } |
78 | ||
3bb2c538 | 79 | virtual Float_t GetCTSEtaCut() const {return fCTSEtaCut ; } |
80 | virtual Float_t GetEMCALEtaCut() const {return fEMCALEtaCut ; } | |
81 | virtual Float_t GetPHOSEtaCut() const {return fPHOSEtaCut ; } | |
bdcfac30 | 82 | virtual Float_t GetPhiEMCALCut(Int_t i) { return fPhiEMCALCut[i] ; } |
83 | virtual Float_t GetPhiPHOSCut(Int_t i) { return fPhiPHOSCut[i] ; } | |
84 | virtual Float_t GetNeutralPtCut() { return fNeutralPtCut ; } | |
85 | virtual Float_t GetChargedPtCut() { return fChargedPtCut ; } | |
86 | ||
3bb2c538 | 87 | virtual Float_t GetEMCALIPDistance() const { return fEMCALIPDistance ; } |
88 | virtual Float_t GetPHOSIPDistance() const { return fPHOSIPDistance ; } | |
89 | virtual Float_t GetEMCALMinAngle() const { return fEMCALMinAngle ; } | |
90 | virtual Float_t GetPHOSMinAngle() const { return fPHOSMinAngle ; } | |
4b707925 | 91 | |
92 | virtual Bool_t IsEMCALPIDOn() const {return fEMCALPID ; } | |
93 | virtual Bool_t IsPHOSPIDOn() const {return fPHOSPID ; } | |
3bb2c538 | 94 | virtual Float_t GetEMCALPhotonWeight() const { return fEMCALPhotonWeight ; } |
95 | virtual Float_t GetEMCALPi0Weight() const { return fEMCALPi0Weight ; } | |
96 | virtual Float_t GetEMCALElectronWeight() const { return fEMCALElectronWeight ; } | |
97 | virtual Float_t GetEMCALChargeWeight() const { return fEMCALChargeWeight ; } | |
98 | virtual Float_t GetEMCALNeutralWeight() const { return fEMCALNeutralWeight ; } | |
99 | virtual Float_t GetPHOSPhotonWeight() const { return fPHOSPhotonWeight ; } | |
100 | virtual Float_t GetPHOSPi0Weight() const { return fPHOSPi0Weight ; } | |
101 | virtual Float_t GetPHOSElectronWeight() const { return fPHOSElectronWeight ; } | |
102 | virtual Float_t GetPHOSChargeWeight() const { return fPHOSChargeWeight ; } | |
103 | virtual Float_t GetPHOSNeutralWeight() const { return fPHOSNeutralWeight ; } | |
104 | ||
105 | virtual Bool_t IsPHOSPIDWeightFormulaOn() const { return fPHOSWeightFormula ; } | |
106 | virtual TFormula * GetPHOSPhotonWeightFormula() const { return fPHOSPhotonWeightFormula ; } | |
107 | virtual TFormula * GetPHOSPi0WeightFormula() const { return fPHOSPi0WeightFormula ; } | |
4b707925 | 108 | |
bdcfac30 | 109 | virtual void Print(const Option_t * opt)const; |
110 | ||
111 | virtual void SetCTSEtaCut(Float_t eta){ fCTSEtaCut= eta ; } | |
112 | virtual void SetEMCALEtaCut(Float_t eta){ fEMCALEtaCut= eta ; } | |
113 | virtual void SetPHOSEtaCut(Float_t eta){ fPHOSEtaCut= eta ; } | |
114 | virtual void SetPhiEMCALCut(Float_t phi0, Float_t phi1) | |
115 | { fPhiEMCALCut[0]= phi0 ; fPhiEMCALCut[1]= phi1 ;} | |
116 | virtual void SetPhiPHOSCut(Float_t phi0, Float_t phi1) | |
117 | { fPhiPHOSCut[0]= phi0 ; fPhiPHOSCut[1]= phi1 ;} | |
118 | virtual void SetNeutralPtCut(Float_t pt){ fNeutralPtCut = pt ; } | |
119 | virtual void SetChargedPtCut(Float_t pt){ fChargedPtCut = pt ; } | |
120 | ||
4b707925 | 121 | virtual void SetEMCALIPDistance(Float_t d){ fEMCALIPDistance = d ; } |
122 | virtual void SetPHOSIPDistance(Float_t d){ fPHOSIPDistance = d ; } | |
123 | virtual void SetEMCALMinAngle(Float_t d){ fEMCALMinAngle = d ; } | |
124 | virtual void SetPHOSMinAngle(Float_t d){ fPHOSMinAngle = d ; } | |
125 | ||
126 | virtual void SetEMCALPIDOn(Bool_t pid){ fEMCALPID= pid ; } | |
127 | virtual void SetPHOSPIDOn(Bool_t pid){ fPHOSPID= pid ; } | |
128 | virtual void SetEMCALPhotonWeight(Float_t w){ fEMCALPhotonWeight = w ; } | |
129 | virtual void SetEMCALPi0Weight(Float_t w){ fEMCALPi0Weight = w ; } | |
130 | virtual void SetEMCALElectronWeight(Float_t w){ fEMCALElectronWeight = w ; } | |
131 | virtual void SetEMCALChargeWeight(Float_t w){ fEMCALChargeWeight = w ; } | |
132 | virtual void SetEMCALNeutralWeight(Float_t w){ fEMCALNeutralWeight = w ; } | |
133 | virtual void SetPHOSPhotonWeight(Float_t w){ fPHOSPhotonWeight = w ; } | |
134 | virtual void SetPHOSPi0Weight(Float_t w){ fPHOSPi0Weight = w ; } | |
135 | virtual void SetPHOSElectronWeight(Float_t w){ fPHOSElectronWeight = w ; } | |
136 | virtual void SetPHOSChargeWeight(Float_t w){ fPHOSChargeWeight = w ; } | |
137 | virtual void SetPHOSNeutralWeight(Float_t w){ fPHOSNeutralWeight = w ; } | |
138 | ||
139 | virtual void UsePHOSPIDWeightFormula(Bool_t par) { fPHOSWeightFormula = par; } | |
140 | virtual void SetPHOSPhotonWeightFormula(TFormula * photon) { fPHOSPhotonWeightFormula = photon; } | |
141 | virtual void SetPHOSPi0WeightFormula(TFormula * pi0) { fPHOSPi0WeightFormula = pi0; } | |
142 | ||
3bb2c538 | 143 | virtual Bool_t IsEMCALOn() const { return fSwitchOnEMCAL ; } |
144 | virtual Bool_t IsPHOSOn() const { return fSwitchOnPHOS ; } | |
145 | virtual Bool_t IsCTSOn() const { return fSwitchOnCTS ; } | |
146 | ||
147 | virtual void SwitchOnEMCAL(Bool_t sw) {fSwitchOnEMCAL = sw ; } | |
148 | virtual void SwitchOnPHOS(Bool_t sw) {fSwitchOnPHOS = sw ; } | |
149 | virtual void SwitchOnCTS(Bool_t sw) {fSwitchOnCTS = sw ; } | |
150 | ||
151 | virtual void CreateParticleList(TObject* , TObject * , | |
152 | TClonesArray * , TClonesArray * , TClonesArray *, | |
153 | TClonesArray * , TClonesArray * , TClonesArray * ) {;} | |
154 | ||
bdcfac30 | 155 | protected: |
3bb2c538 | 156 | |
157 | Int_t fDataType ; //Select MC:Kinematics, Data:ESD/AOD, MCData:Both | |
158 | ||
159 | Bool_t fSwitchOnEMCAL ; //Do not consider EMCAL neutral particles/clusters | |
160 | Bool_t fSwitchOnPHOS ;//Do not consider PHOS neutral particles/clusters | |
161 | Bool_t fSwitchOnCTS ;//Do not consider tracks/ charged particles | |
162 | ||
163 | //Kinematical cuts | |
bdcfac30 | 164 | Float_t fCTSEtaCut ;//CTS pseudorapidity acceptance |
165 | Float_t fEMCALEtaCut ;//EMCAL pseudorapidity acceptance | |
166 | Float_t fPHOSEtaCut ;//PHOS pseudorapidity acceptance | |
167 | Float_t fPhiEMCALCut[2]; //EMCAL phi acceptance | |
168 | Float_t fPhiPHOSCut[2]; //PHOS phi acceptance | |
3bb2c538 | 169 | Float_t fNeutralPtCut; //pT Threshold on neutral particles |
170 | Float_t fChargedPtCut; // pT Threshold on charged particles | |
bdcfac30 | 171 | |
3bb2c538 | 172 | //Overlapping |
4b707925 | 173 | Float_t fEMCALIPDistance; //Calorimeter IP distance. |
174 | Float_t fPHOSIPDistance; //Calorimeter IP distance | |
175 | Float_t fEMCALMinAngle; //Gamma decay minimum aperture angle for overlapping. | |
176 | Float_t fPHOSMinAngle; //Gamma decay minimum aperture angle for overlapping. | |
177 | ||
3bb2c538 | 178 | //PID |
4b707925 | 179 | Bool_t fEMCALPID ;//Fill EMCAL particle lists with particles with corresponding pid |
180 | Bool_t fPHOSPID; //Fill PHOS particle lists with particles with corresponding pid | |
181 | Float_t fEMCALPhotonWeight; //Bayesian PID weight for photons in EMCAL | |
182 | Float_t fEMCALPi0Weight; //Bayesian PID weight for pi0 in EMCAL | |
183 | Float_t fEMCALElectronWeight; //Bayesian PID weight for electrons in EMCAL | |
184 | Float_t fEMCALChargeWeight; //Bayesian PID weight for charged hadrons in EMCAL | |
185 | Float_t fEMCALNeutralWeight; //Bayesian PID weight for neutral hadrons in EMCAL | |
186 | Float_t fPHOSPhotonWeight; //Bayesian PID weight for photons in PHOS | |
187 | Float_t fPHOSPi0Weight; //Bayesian PID weight for pi0 in PHOS | |
188 | Float_t fPHOSElectronWeight; //Bayesian PID weight for electrons in PHOS | |
189 | Float_t fPHOSChargeWeight; //Bayesian PID weight for charged hadrons in PHOS | |
190 | Float_t fPHOSNeutralWeight; //Bayesian PID weight for neutral hadrons in PHOS | |
191 | ||
192 | Bool_t fPHOSWeightFormula ; //Use parametrized weight threshold, function of energy | |
193 | TFormula * fPHOSPhotonWeightFormula ; //Formula for photon weight | |
194 | TFormula * fPHOSPi0WeightFormula ; //Formula for pi0 weight | |
195 | ||
196 | ClassDef(AliGammaReader,1) | |
bdcfac30 | 197 | } ; |
4b707925 | 198 | |
bdcfac30 | 199 | |
200 | #endif //ALIGAMMAREADER_H | |
201 | ||
202 | ||
203 |