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