]>
Commit | Line | Data |
---|---|---|
1b446896 | 1 | //Piotr Skowronski@cern.ch |
4617f71a | 2 | //Classes fAnd single particle cuts |
1b446896 | 3 | //User should use only AliHBTParticleCut, eventually EmptyCut which passes all particles |
4617f71a | 4 | //There is all interface fAnd setting cuts on all particle properties |
1b446896 | 5 | //The main method is Pass - which returns |
4617f71a | 6 | // True in Andder to reject particle |
1b446896 | 7 | // False in case it meets all the criteria of the given cut |
8 | // | |
9 | //User should create (and also destroy) cuts himself | |
4617f71a | 10 | //and then pass them to the Analysis And Function by a proper method |
1b446896 | 11 | // |
4617f71a | 12 | //mAnde info: http://alisoft.cern.ch/people/skowron/analyzer/index.html |
1b446896 | 13 | |
14 | ||
15 | #ifndef ALIHBTPARTICLECUT_H | |
16 | #define ALIHBTPARTICLECUT_H | |
17 | ||
18 | #include <TObject.h> | |
19 | #include "AliHBTParticle.h" | |
20 | ||
21 | ||
22 | class AliHBTEmptyParticleCut; | |
23 | class AliHBTParticleCut; | |
24 | class AliHBTPairCut; | |
25 | class AliHBTPair; | |
26 | class AliHbtBaseCut; | |
27 | ||
28 | ||
29 | /******************************************************************/ | |
30 | /******************************************************************/ | |
31 | /******************************************************************/ | |
32 | ||
33 | enum AliHBTCutProperty | |
34 | { | |
35 | //codes particle property | |
36 | kHbtP, //Momentum | |
37 | kHbtPt, //Transverse momentum | |
38 | kHbtE, //Energy | |
39 | kHbtRapidity, // | |
40 | kHbtPseudoRapidity, | |
4617f71a | 41 | kHbtPx, //X coAnddinate of the momentum |
42 | kHbtPy, //Y coAnddinate of the momentum | |
43 | kHbtPz, //Z coAnddinate of the momentum | |
1b446896 | 44 | kHbtPhi,//angle |
45 | kHbtTheta,//angle | |
4617f71a | 46 | kHbtVx, // vertex X coAnddinate |
47 | kHbtVy, // vertex Y coAnddinate | |
48 | kHbtVz, // vertex Z coAnddinate | |
49 | kHbtPid, // vertex Z coAnddinate | |
1b446896 | 50 | //_____________________________ |
4617f71a | 51 | kHbtNone |
1b446896 | 52 | }; |
53 | ||
54 | /******************************************************************/ | |
55 | /******************************************************************/ | |
56 | /******************************************************************/ | |
57 | ||
58 | class AliHBTParticleCut: public TObject | |
59 | { | |
60 | //Class describing cut on pairs of particles | |
61 | public: | |
62 | AliHBTParticleCut(); | |
63 | AliHBTParticleCut(const AliHBTParticleCut&); | |
64 | virtual ~AliHBTParticleCut(); | |
65 | ||
66 | virtual Bool_t Pass(AliHBTParticle*); | |
a925ebdf | 67 | Bool_t IsEmpty() {return kFALSE;} |
1b446896 | 68 | |
69 | void AddBasePartCut(AliHbtBaseCut*); | |
70 | ||
71 | Int_t GetPID() const { return fPID;} | |
72 | void SetPID(Int_t pid){fPID=pid;} | |
73 | void SetMomentumRange(Double_t min, Double_t max); | |
74 | void SetPRange(Double_t min, Double_t max){SetMomentumRange(min,max);} | |
75 | void SetPtRange(Double_t min, Double_t max); | |
76 | void SetEnergyRange(Double_t min, Double_t max); | |
77 | void SetRapidityRange(Double_t min, Double_t max); | |
78 | void SetYRange(Double_t min, Double_t max){SetRapidityRange(min,max);} | |
79 | void SetPseudoRapidityRange(Double_t min, Double_t max); | |
80 | void SetPxRange(Double_t min, Double_t max); | |
81 | void SetPyRange(Double_t min, Double_t max); | |
82 | void SetPzRange(Double_t min, Double_t max); | |
83 | void SetPhiRange(Double_t min, Double_t max); | |
84 | void SetThetaRange(Double_t min, Double_t max); | |
85 | void SetVxRange(Double_t min, Double_t max); | |
86 | void SetVyRange(Double_t min, Double_t max); | |
87 | void SetVzRange(Double_t min, Double_t max); | |
88 | ||
89 | void Print(void); | |
90 | protected: | |
91 | ||
92 | AliHbtBaseCut* FindCut(AliHBTCutProperty); | |
93 | ||
94 | AliHbtBaseCut ** fCuts;//! Array with cuts | |
95 | Int_t fNCuts; | |
96 | ||
97 | Int_t fPID; //particle PID - if=0 (rootino) all pids are accepted | |
98 | ||
99 | private: | |
100 | static const Int_t fkgMaxCuts; | |
101 | public: | |
102 | ClassDef(AliHBTParticleCut,1) | |
103 | ||
104 | }; | |
105 | /******************************************************************/ | |
106 | /******************************************************************/ | |
107 | /******************************************************************/ | |
108 | ||
109 | class AliHBTEmptyParticleCut: public AliHBTParticleCut | |
110 | { | |
111 | //Empty - it passes possitively all particles - it means returns always False | |
112 | //Class describing cut on pairs of particles | |
113 | public: | |
114 | AliHBTEmptyParticleCut(){}; | |
115 | virtual ~AliHBTEmptyParticleCut(){}; | |
116 | ||
a925ebdf | 117 | Bool_t Pass(AliHBTParticle*){return kFALSE;} //accpept everything |
118 | Bool_t IsEmpty() {return kTRUE;} | |
1b446896 | 119 | |
120 | ClassDef(AliHBTEmptyParticleCut,1) | |
121 | ||
122 | }; | |
123 | ||
124 | /******************************************************************/ | |
125 | /******************************************************************/ | |
126 | /******************************************************************/ | |
127 | ||
128 | class AliHbtBaseCut: public TObject | |
129 | { | |
130 | //This class defines the range of some property - pure virtual | |
131 | //Property is coded by AliHBTCutTypes type | |
132 | ||
133 | public: | |
134 | ||
135 | AliHbtBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliHBTCutProperty prop = kHbtNone): | |
136 | fProperty(prop),fMin(min),fMax(max){} | |
137 | ||
4617f71a | 138 | virtual ~AliHbtBaseCut(){} |
1b446896 | 139 | |
4617f71a | 140 | virtual Bool_t Pass(AliHBTParticle *p); |
1b446896 | 141 | |
4617f71a | 142 | void SetRange(Double_t min, Double_t max){fMin = min; fMax = max;} |
1b446896 | 143 | |
4617f71a | 144 | void SetMinimum(Double_t min){fMin = min;} |
145 | void SetMaximum(Double_t max){fMax = max;} | |
1b446896 | 146 | |
4617f71a | 147 | Double_t GetMinimum() const {return fMin;} |
148 | Double_t GetMaximum() const {return fMax;} | |
1b446896 | 149 | |
150 | AliHBTCutProperty GetProperty() const {return fProperty;} | |
4617f71a | 151 | virtual void Print(void); |
152 | ||
1b446896 | 153 | protected: |
154 | virtual Double_t GetValue(AliHBTParticle *) = 0; | |
155 | ||
156 | AliHBTCutProperty fProperty; | |
157 | Double_t fMin; | |
158 | Double_t fMax; | |
4617f71a | 159 | |
1b446896 | 160 | private: |
161 | void PrintProperty(void); | |
1b446896 | 162 | ClassDef(AliHbtBaseCut,1) |
163 | ||
164 | }; | |
165 | ||
166 | inline Bool_t | |
167 | AliHbtBaseCut::Pass(AliHBTParticle *p) | |
168 | { | |
6374caa2 | 169 | if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected |
170 | else return kFALSE; //accepted | |
1b446896 | 171 | } |
172 | /******************************************************************/ | |
173 | /******************************************************************/ | |
174 | /******************************************************************/ | |
175 | ||
176 | ||
177 | class AliHBTMomentumCut: public AliHbtBaseCut | |
178 | { | |
179 | public: | |
180 | AliHBTMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtP){} | |
181 | virtual ~AliHBTMomentumCut(){} | |
182 | protected: | |
183 | Double_t GetValue(AliHBTParticle * p){return p->P();} | |
1b446896 | 184 | ClassDef(AliHBTMomentumCut,1) |
1b446896 | 185 | }; |
186 | ||
1b446896 | 187 | class AliHBTPtCut: public AliHbtBaseCut |
188 | { | |
189 | public: | |
190 | AliHBTPtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPt){} | |
191 | virtual ~AliHBTPtCut(){} | |
192 | protected: | |
193 | Double_t GetValue(AliHBTParticle * p){return p->Pt();} | |
1b446896 | 194 | ClassDef(AliHBTPtCut,1) |
1b446896 | 195 | }; |
196 | ||
197 | ||
198 | class AliHBTEnergyCut: public AliHbtBaseCut | |
199 | { | |
200 | public: | |
201 | AliHBTEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtE){} | |
202 | virtual ~AliHBTEnergyCut(){} | |
203 | protected: | |
204 | Double_t GetValue(AliHBTParticle * p){return p->Energy();} | |
1b446896 | 205 | ClassDef(AliHBTEnergyCut,1) |
1b446896 | 206 | }; |
207 | ||
208 | class AliHBTRapidityCut: public AliHbtBaseCut | |
209 | { | |
210 | public: | |
211 | AliHBTRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtRapidity){} | |
212 | virtual ~AliHBTRapidityCut(){} | |
213 | protected: | |
214 | Double_t GetValue(AliHBTParticle * p){return p->Y();} | |
1b446896 | 215 | ClassDef(AliHBTRapidityCut,1) |
1b446896 | 216 | }; |
217 | ||
218 | class AliHBTPseudoRapidityCut: public AliHbtBaseCut | |
219 | { | |
220 | public: | |
221 | AliHBTPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPseudoRapidity){} | |
222 | virtual ~AliHBTPseudoRapidityCut(){} | |
223 | protected: | |
224 | Double_t GetValue(AliHBTParticle * p){return p->Eta();} | |
1b446896 | 225 | ClassDef(AliHBTPseudoRapidityCut,1) |
1b446896 | 226 | }; |
227 | ||
228 | class AliHBTPxCut: public AliHbtBaseCut | |
229 | { | |
230 | public: | |
231 | AliHBTPxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPx){} | |
232 | virtual ~AliHBTPxCut(){} | |
233 | protected: | |
234 | Double_t GetValue(AliHBTParticle * p){return p->Px();} | |
1b446896 | 235 | ClassDef(AliHBTPxCut,1) |
1b446896 | 236 | }; |
237 | ||
238 | class AliHBTPyCut: public AliHbtBaseCut | |
239 | { | |
240 | public: | |
241 | AliHBTPyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPy){} | |
242 | virtual ~AliHBTPyCut(){} | |
243 | protected: | |
244 | Double_t GetValue(AliHBTParticle * p){return p->Py();} | |
1b446896 | 245 | ClassDef(AliHBTPyCut,1) |
1b446896 | 246 | }; |
247 | ||
248 | ||
249 | class AliHBTPzCut: public AliHbtBaseCut | |
250 | { | |
251 | public: | |
252 | AliHBTPzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPz){} | |
253 | virtual ~AliHBTPzCut(){} | |
254 | protected: | |
255 | Double_t GetValue(AliHBTParticle * p){return p->Pz();} | |
1b446896 | 256 | ClassDef(AliHBTPzCut,1) |
1b446896 | 257 | }; |
258 | ||
259 | class AliHBTPhiCut: public AliHbtBaseCut | |
260 | { | |
261 | public: | |
262 | AliHBTPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPhi){} | |
263 | virtual ~AliHBTPhiCut(){} | |
264 | protected: | |
265 | Double_t GetValue(AliHBTParticle * p){return p->Phi();} | |
1b446896 | 266 | ClassDef(AliHBTPhiCut,1) |
267 | ||
268 | }; | |
269 | ||
270 | class AliHBTThetaCut: public AliHbtBaseCut | |
271 | { | |
272 | public: | |
273 | AliHBTThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtTheta){} | |
274 | virtual ~AliHBTThetaCut(){} | |
275 | protected: | |
276 | Double_t GetValue(AliHBTParticle * p){return p->Theta();} | |
1b446896 | 277 | ClassDef(AliHBTThetaCut,1) |
278 | ||
279 | }; | |
280 | ||
281 | class AliHBTVxCut: public AliHbtBaseCut | |
282 | { | |
4617f71a | 283 | //Cut of the X coAnddinate of the vertex position |
1b446896 | 284 | public: |
285 | AliHBTVxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVx){} | |
286 | virtual ~AliHBTVxCut(){} | |
287 | protected: | |
288 | Double_t GetValue(AliHBTParticle * p){return p->Vx();} //retruns value of the vertex | |
1b446896 | 289 | ClassDef(AliHBTVxCut,1) |
290 | ||
291 | }; | |
292 | ||
293 | ||
294 | class AliHBTVyCut: public AliHbtBaseCut | |
295 | { | |
4617f71a | 296 | //Cut of the X coAnddinate of the vertex position |
1b446896 | 297 | public: |
298 | AliHBTVyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVy){} | |
299 | virtual ~AliHBTVyCut(){} | |
300 | protected: | |
301 | Double_t GetValue(AliHBTParticle * p){return p->Vy();} //retruns value of the vertex | |
1b446896 | 302 | ClassDef(AliHBTVyCut,1) |
303 | ||
304 | }; | |
305 | ||
306 | class AliHBTVzCut: public AliHbtBaseCut | |
307 | { | |
4617f71a | 308 | //Cut of the X coAnddinate of the vertex position |
1b446896 | 309 | public: |
310 | AliHBTVzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVz){} | |
311 | virtual ~AliHBTVzCut(){} | |
312 | protected: | |
313 | Double_t GetValue(AliHBTParticle * p){return p->Vz();} //retruns value of the vertex | |
4617f71a | 314 | |
1b446896 | 315 | ClassDef(AliHBTVzCut,1) |
316 | ||
317 | }; | |
318 | ||
4617f71a | 319 | class AliHBTPIDCut: public AliHbtBaseCut |
320 | { | |
321 | public: | |
641c8b86 | 322 | AliHBTPIDCut():AliHbtBaseCut(0.0,0.0,kHbtPid),fPID(0){} |
4617f71a | 323 | AliHBTPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliHbtBaseCut(min,max,kHbtPid),fPID(pid){} |
324 | virtual ~AliHBTPIDCut(){} | |
325 | protected: | |
326 | Double_t GetValue(AliHBTParticle * p){return p->GetPIDprobability(fPID);} | |
327 | Int_t fPID; //pid of particle that the pid is set | |
328 | ClassDef(AliHBTPIDCut,1) | |
329 | }; | |
330 | //___________________________________________________ | |
331 | ///////////////////////////////////////////////////// | |
332 | // // | |
333 | // class AliHBTLogicalOperCut // | |
334 | // // | |
335 | // This cut is base class fAnd class that perfAndms // | |
336 | // logical operations on cuts // | |
337 | // // | |
338 | ///////////////////////////////////////////////////// | |
339 | class AliHBTLogicalOperCut: public AliHbtBaseCut | |
340 | { | |
341 | public: | |
342 | AliHBTLogicalOperCut(); | |
343 | AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second); | |
344 | virtual ~AliHBTLogicalOperCut(); | |
345 | protected: | |
bed069a4 | 346 | Double_t GetValue(AliHBTParticle * /*part*/){MayNotUse("GetValue");return 0.0;} |
4617f71a | 347 | |
348 | AliHbtBaseCut* fFirst; //second cut | |
349 | AliHbtBaseCut* fSecond; //first cut | |
350 | private: | |
351 | class AliHBTDummyBaseCut: public AliHbtBaseCut | |
352 | { | |
bed069a4 | 353 | Double_t GetValue(AliHBTParticle * /*part*/){return 0.0;} |
354 | Bool_t Pass(AliHBTParticle* /*part*/); | |
4617f71a | 355 | }; |
356 | ||
357 | ClassDef(AliHBTLogicalOperCut,1) | |
358 | }; | |
1b446896 | 359 | |
4617f71a | 360 | class AliHBTOrCut: public AliHBTLogicalOperCut |
361 | { | |
362 | public: | |
363 | AliHBTOrCut(){} | |
364 | AliHBTOrCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){} | |
365 | virtual ~AliHBTOrCut(){} | |
366 | Bool_t Pass(AliHBTParticle *p); | |
367 | ClassDef(AliHBTOrCut,1) | |
368 | }; | |
1b446896 | 369 | |
4617f71a | 370 | class AliHBTAndCut: public AliHBTLogicalOperCut |
371 | { | |
372 | public: | |
373 | AliHBTAndCut(){} | |
374 | AliHBTAndCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){} | |
375 | virtual ~AliHBTAndCut(){} | |
376 | Bool_t Pass(AliHBTParticle *p); | |
377 | ClassDef(AliHBTAndCut,1) | |
378 | }; | |
1b446896 | 379 | |
380 | #endif |