1 //__________________________________________________________________________
2 ////////////////////////////////////////////////////////////////////////////
4 // class AliHBTParticleCut //
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 //
14 // User should create (and also destroy) cuts himself //
15 // and then pass them to the Analysis And Function by a proper method //
18 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html //
19 // resonsible: Piotr Skowronski@cern.ch //
21 ////////////////////////////////////////////////////////////////////////////
24 #ifndef ALIHBTPARTICLECUT_H
25 #define ALIHBTPARTICLECUT_H
28 #include "AliHBTParticle.h"
31 class AliHBTEmptyParticleCut;
32 class AliHBTParticleCut;
38 /******************************************************************/
39 /******************************************************************/
40 /******************************************************************/
42 enum AliHBTCutProperty
44 //codes particle property
46 kHbtPt, //Transverse momentum
50 kHbtPx, //X coAnddinate of the momentum
51 kHbtPy, //Y coAnddinate of the momentum
52 kHbtPz, //Z coAnddinate of the momentum
55 kHbtVx, // vertex X coAnddinate
56 kHbtVy, // vertex Y coAnddinate
57 kHbtVz, // vertex Z coAnddinate
58 kHbtPid, // vertex Z coAnddinate
59 //_____________________________
63 /******************************************************************/
64 /******************************************************************/
65 /******************************************************************/
67 class AliHBTParticleCut: public TObject
69 //Class describing cut on pairs of particles
72 AliHBTParticleCut(const AliHBTParticleCut& in);
73 virtual ~AliHBTParticleCut();
74 const AliHBTParticleCut& operator = (const AliHBTParticleCut& in);
76 virtual Bool_t Pass(AliHBTParticle* p);
77 Bool_t IsEmpty() const {return kFALSE;}
79 void AddBasePartCut(AliHbtBaseCut* basecut);
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);
99 void Print(void) const;
102 AliHbtBaseCut* FindCut(AliHBTCutProperty property);
104 AliHbtBaseCut ** fCuts;//! Array with cuts
105 Int_t fNCuts; //number of base cuts stored in fCuts
107 Int_t fPID; //particle PID - if=0 (rootino) all pids are accepted
110 static const Int_t fgkMaxCuts; //Size of the fCuts array
112 ClassDef(AliHBTParticleCut,1)
114 /******************************************************************/
115 /******************************************************************/
116 /******************************************************************/
118 class AliHBTEmptyParticleCut: public AliHBTParticleCut
120 //Empty - it passes possitively all particles - it means returns always False
121 //Class describing cut on pairs of particles
123 AliHBTEmptyParticleCut(){};
124 virtual ~AliHBTEmptyParticleCut(){};
126 Bool_t Pass(AliHBTParticle*){return kFALSE;} //accept everything <<CAN NOT BE const!!!!>>
127 Bool_t IsEmpty() const {return kTRUE;}
129 ClassDef(AliHBTEmptyParticleCut,1)
133 /******************************************************************/
134 /******************************************************************/
135 /******************************************************************/
137 class AliHbtBaseCut: public TObject
139 //This class defines the range of some property - pure virtual
140 //Property is coded by AliHBTCutTypes type
144 AliHbtBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliHBTCutProperty prop = kHbtNone):
145 fProperty(prop),fMin(min),fMax(max){}
147 virtual ~AliHbtBaseCut(){}
149 virtual Bool_t Pass(AliHBTParticle *p);
151 void SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
153 void SetMinimum(Double_t min){fMin = min;}
154 void SetMaximum(Double_t max){fMax = max;}
156 Double_t GetMinimum() const {return fMin;}
157 Double_t GetMaximum() const {return fMax;}
159 AliHBTCutProperty GetProperty() const {return fProperty;}
160 virtual void Print(void) const;
163 virtual Double_t GetValue(AliHBTParticle *) const = 0;
165 AliHBTCutProperty fProperty; //property that this cut describes
166 Double_t fMin;//minimum value
167 Double_t fMax;//maximum value
170 void PrintProperty(void) const;
171 ClassDef(AliHbtBaseCut,1)
176 AliHbtBaseCut::Pass(AliHBTParticle *p)
178 //cjecks if particle property fits in range
179 if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
180 else return kFALSE; //accepted
182 /******************************************************************/
183 /******************************************************************/
184 /******************************************************************/
187 class AliHBTMomentumCut: public AliHbtBaseCut
190 AliHBTMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtP){}
191 virtual ~AliHBTMomentumCut(){}
193 Double_t GetValue(AliHBTParticle * p)const{return p->P();}
194 ClassDef(AliHBTMomentumCut,1)
197 class AliHBTPtCut: public AliHbtBaseCut
200 AliHBTPtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPt){}
201 virtual ~AliHBTPtCut(){}
203 Double_t GetValue(AliHBTParticle * p)const{return p->Pt();}
204 ClassDef(AliHBTPtCut,1)
208 class AliHBTEnergyCut: public AliHbtBaseCut
211 AliHBTEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtE){}
212 virtual ~AliHBTEnergyCut(){}
214 Double_t GetValue(AliHBTParticle * p)const{return p->Energy();}
215 ClassDef(AliHBTEnergyCut,1)
218 class AliHBTRapidityCut: public AliHbtBaseCut
221 AliHBTRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtRapidity){}
222 virtual ~AliHBTRapidityCut(){}
224 Double_t GetValue(AliHBTParticle * p)const{return p->Y();}
225 ClassDef(AliHBTRapidityCut,1)
228 class AliHBTPseudoRapidityCut: public AliHbtBaseCut
231 AliHBTPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPseudoRapidity){}
232 virtual ~AliHBTPseudoRapidityCut(){}
234 Double_t GetValue(AliHBTParticle * p)const{return p->Eta();}
235 ClassDef(AliHBTPseudoRapidityCut,1)
238 class AliHBTPxCut: public AliHbtBaseCut
241 AliHBTPxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPx){}
242 virtual ~AliHBTPxCut(){}
244 Double_t GetValue(AliHBTParticle * p)const{return p->Px();}
245 ClassDef(AliHBTPxCut,1)
248 class AliHBTPyCut: public AliHbtBaseCut
251 AliHBTPyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPy){}
252 virtual ~AliHBTPyCut(){}
254 Double_t GetValue(AliHBTParticle * p)const{return p->Py();}
255 ClassDef(AliHBTPyCut,1)
259 class AliHBTPzCut: public AliHbtBaseCut
262 AliHBTPzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPz){}
263 virtual ~AliHBTPzCut(){}
265 Double_t GetValue(AliHBTParticle * p)const{return p->Pz();}
266 ClassDef(AliHBTPzCut,1)
269 class AliHBTPhiCut: public AliHbtBaseCut
272 AliHBTPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPhi){}
273 virtual ~AliHBTPhiCut(){}
275 Double_t GetValue(AliHBTParticle * p)const{return p->Phi();}
276 ClassDef(AliHBTPhiCut,1)
280 class AliHBTThetaCut: public AliHbtBaseCut
283 AliHBTThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtTheta){}
284 virtual ~AliHBTThetaCut(){}
286 Double_t GetValue(AliHBTParticle * p)const{return p->Theta();}
287 ClassDef(AliHBTThetaCut,1)
291 class AliHBTVxCut: public AliHbtBaseCut
293 //Cut of the X coAnddinate of the vertex position
295 AliHBTVxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVx){}
296 virtual ~AliHBTVxCut(){}
298 Double_t GetValue(AliHBTParticle * p)const{return p->Vx();} //retruns value of the vertex
299 ClassDef(AliHBTVxCut,1)
304 class AliHBTVyCut: public AliHbtBaseCut
306 //Cut of the X coAnddinate of the vertex position
308 AliHBTVyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVy){}
309 virtual ~AliHBTVyCut(){}
311 Double_t GetValue(AliHBTParticle * p)const{return p->Vy();} //retruns value of the vertex
312 ClassDef(AliHBTVyCut,1)
316 class AliHBTVzCut: public AliHbtBaseCut
318 //Cut of the X coAnddinate of the vertex position
320 AliHBTVzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVz){}
321 virtual ~AliHBTVzCut(){}
323 Double_t GetValue(AliHBTParticle * p)const{return p->Vz();} //retruns value of the vertex
325 ClassDef(AliHBTVzCut,1)
329 class AliHBTPIDCut: public AliHbtBaseCut
332 AliHBTPIDCut():AliHbtBaseCut(0.0,0.0,kHbtPid),fPID(0){}
333 AliHBTPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliHbtBaseCut(min,max,kHbtPid),fPID(pid){}
334 virtual ~AliHBTPIDCut(){}
336 Double_t GetValue(AliHBTParticle * p)const{return p->GetPIDprobability(fPID);}
337 Int_t fPID; //pid of particle that the pid is set
338 ClassDef(AliHBTPIDCut,1)
340 //___________________________________________________
341 /////////////////////////////////////////////////////
343 // class AliHBTLogicalOperCut //
345 // This cut is base class fAnd class that perfAndms //
346 // logical operations on cuts //
348 /////////////////////////////////////////////////////
349 class AliHBTLogicalOperCut: public AliHbtBaseCut
352 AliHBTLogicalOperCut();
353 AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second);
354 virtual ~AliHBTLogicalOperCut();
356 Double_t GetValue(AliHBTParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
358 AliHbtBaseCut* fFirst; //second cut
359 AliHbtBaseCut* fSecond; //first cut
361 class AliHBTDummyBaseCut: public AliHbtBaseCut
363 Double_t GetValue(AliHBTParticle * /*part*/) const {return 0.0;}
364 Bool_t Pass(AliHBTParticle* /*part*/);
367 ClassDef(AliHBTLogicalOperCut,1)
370 class AliHBTOrCut: public AliHBTLogicalOperCut
374 AliHBTOrCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){}
375 virtual ~AliHBTOrCut(){}
376 Bool_t Pass(AliHBTParticle *p);
377 ClassDef(AliHBTOrCut,1)
380 class AliHBTAndCut: public AliHBTLogicalOperCut
384 AliHBTAndCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){}
385 virtual ~AliHBTAndCut(){}
386 Bool_t Pass(AliHBTParticle *p);
387 ClassDef(AliHBTAndCut,1)