1 //Piotr Skowronski@cern.ch
2 //Classes fAnd single particle cuts
3 //User should use only AliHBTParticleCut, eventually EmptyCut which passes all particles
4 //There is all interface fAnd setting cuts on all particle properties
5 //The main method is Pass - which returns
6 // True in Andder to reject particle
7 // False in case it meets all the criteria of the given cut
9 //User should create (and also destroy) cuts himself
10 //and then pass them to the Analysis And Function by a proper method
12 //mAnde info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
15 #ifndef ALIHBTPARTICLECUT_H
16 #define ALIHBTPARTICLECUT_H
19 #include "AliHBTParticle.h"
22 class AliHBTEmptyParticleCut;
23 class AliHBTParticleCut;
29 /******************************************************************/
30 /******************************************************************/
31 /******************************************************************/
33 enum AliHBTCutProperty
35 //codes particle property
37 kHbtPt, //Transverse momentum
41 kHbtPx, //X coAnddinate of the momentum
42 kHbtPy, //Y coAnddinate of the momentum
43 kHbtPz, //Z coAnddinate of the momentum
46 kHbtVx, // vertex X coAnddinate
47 kHbtVy, // vertex Y coAnddinate
48 kHbtVz, // vertex Z coAnddinate
49 kHbtPid, // vertex Z coAnddinate
50 //_____________________________
54 /******************************************************************/
55 /******************************************************************/
56 /******************************************************************/
58 class AliHBTParticleCut: public TObject
60 //Class describing cut on pairs of particles
63 AliHBTParticleCut(const AliHBTParticleCut&);
64 virtual ~AliHBTParticleCut();
66 virtual Bool_t Pass(AliHBTParticle*);
67 Bool_t IsEmpty() {return kFALSE;}
69 void AddBasePartCut(AliHbtBaseCut*);
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);
92 AliHbtBaseCut* FindCut(AliHBTCutProperty);
94 AliHbtBaseCut ** fCuts;//! Array with cuts
97 Int_t fPID; //particle PID - if=0 (rootino) all pids are accepted
100 static const Int_t fkgMaxCuts;
102 ClassDef(AliHBTParticleCut,1)
105 /******************************************************************/
106 /******************************************************************/
107 /******************************************************************/
109 class AliHBTEmptyParticleCut: public AliHBTParticleCut
111 //Empty - it passes possitively all particles - it means returns always False
112 //Class describing cut on pairs of particles
114 AliHBTEmptyParticleCut(){};
115 virtual ~AliHBTEmptyParticleCut(){};
117 Bool_t Pass(AliHBTParticle*){return kFALSE;} //accpept everything
118 Bool_t IsEmpty() {return kTRUE;}
120 ClassDef(AliHBTEmptyParticleCut,1)
124 /******************************************************************/
125 /******************************************************************/
126 /******************************************************************/
128 class AliHbtBaseCut: public TObject
130 //This class defines the range of some property - pure virtual
131 //Property is coded by AliHBTCutTypes type
135 AliHbtBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliHBTCutProperty prop = kHbtNone):
136 fProperty(prop),fMin(min),fMax(max){}
138 virtual ~AliHbtBaseCut(){}
140 virtual Bool_t Pass(AliHBTParticle *p);
142 void SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
144 void SetMinimum(Double_t min){fMin = min;}
145 void SetMaximum(Double_t max){fMax = max;}
147 Double_t GetMinimum() const {return fMin;}
148 Double_t GetMaximum() const {return fMax;}
150 AliHBTCutProperty GetProperty() const {return fProperty;}
151 virtual void Print(void);
154 virtual Double_t GetValue(AliHBTParticle *) = 0;
156 AliHBTCutProperty fProperty;
161 void PrintProperty(void);
162 ClassDef(AliHbtBaseCut,1)
167 AliHbtBaseCut::Pass(AliHBTParticle *p)
169 if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
170 else return kFALSE; //accepted
172 /******************************************************************/
173 /******************************************************************/
174 /******************************************************************/
177 class AliHBTMomentumCut: public AliHbtBaseCut
180 AliHBTMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtP){}
181 virtual ~AliHBTMomentumCut(){}
183 Double_t GetValue(AliHBTParticle * p){return p->P();}
184 ClassDef(AliHBTMomentumCut,1)
187 class AliHBTPtCut: public AliHbtBaseCut
190 AliHBTPtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPt){}
191 virtual ~AliHBTPtCut(){}
193 Double_t GetValue(AliHBTParticle * p){return p->Pt();}
194 ClassDef(AliHBTPtCut,1)
198 class AliHBTEnergyCut: public AliHbtBaseCut
201 AliHBTEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtE){}
202 virtual ~AliHBTEnergyCut(){}
204 Double_t GetValue(AliHBTParticle * p){return p->Energy();}
205 ClassDef(AliHBTEnergyCut,1)
208 class AliHBTRapidityCut: public AliHbtBaseCut
211 AliHBTRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtRapidity){}
212 virtual ~AliHBTRapidityCut(){}
214 Double_t GetValue(AliHBTParticle * p){return p->Y();}
215 ClassDef(AliHBTRapidityCut,1)
218 class AliHBTPseudoRapidityCut: public AliHbtBaseCut
221 AliHBTPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPseudoRapidity){}
222 virtual ~AliHBTPseudoRapidityCut(){}
224 Double_t GetValue(AliHBTParticle * p){return p->Eta();}
225 ClassDef(AliHBTPseudoRapidityCut,1)
228 class AliHBTPxCut: public AliHbtBaseCut
231 AliHBTPxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPx){}
232 virtual ~AliHBTPxCut(){}
234 Double_t GetValue(AliHBTParticle * p){return p->Px();}
235 ClassDef(AliHBTPxCut,1)
238 class AliHBTPyCut: public AliHbtBaseCut
241 AliHBTPyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPy){}
242 virtual ~AliHBTPyCut(){}
244 Double_t GetValue(AliHBTParticle * p){return p->Py();}
245 ClassDef(AliHBTPyCut,1)
249 class AliHBTPzCut: public AliHbtBaseCut
252 AliHBTPzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPz){}
253 virtual ~AliHBTPzCut(){}
255 Double_t GetValue(AliHBTParticle * p){return p->Pz();}
256 ClassDef(AliHBTPzCut,1)
259 class AliHBTPhiCut: public AliHbtBaseCut
262 AliHBTPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPhi){}
263 virtual ~AliHBTPhiCut(){}
265 Double_t GetValue(AliHBTParticle * p){return p->Phi();}
266 ClassDef(AliHBTPhiCut,1)
270 class AliHBTThetaCut: public AliHbtBaseCut
273 AliHBTThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtTheta){}
274 virtual ~AliHBTThetaCut(){}
276 Double_t GetValue(AliHBTParticle * p){return p->Theta();}
277 ClassDef(AliHBTThetaCut,1)
281 class AliHBTVxCut: public AliHbtBaseCut
283 //Cut of the X coAnddinate of the vertex position
285 AliHBTVxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVx){}
286 virtual ~AliHBTVxCut(){}
288 Double_t GetValue(AliHBTParticle * p){return p->Vx();} //retruns value of the vertex
289 ClassDef(AliHBTVxCut,1)
294 class AliHBTVyCut: public AliHbtBaseCut
296 //Cut of the X coAnddinate of the vertex position
298 AliHBTVyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVy){}
299 virtual ~AliHBTVyCut(){}
301 Double_t GetValue(AliHBTParticle * p){return p->Vy();} //retruns value of the vertex
302 ClassDef(AliHBTVyCut,1)
306 class AliHBTVzCut: public AliHbtBaseCut
308 //Cut of the X coAnddinate of the vertex position
310 AliHBTVzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVz){}
311 virtual ~AliHBTVzCut(){}
313 Double_t GetValue(AliHBTParticle * p){return p->Vz();} //retruns value of the vertex
315 ClassDef(AliHBTVzCut,1)
319 class AliHBTPIDCut: public AliHbtBaseCut
322 AliHBTPIDCut():AliHbtBaseCut(0.0,0.0,kHbtPid),fPID(0){}
323 AliHBTPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliHbtBaseCut(min,max,kHbtPid),fPID(pid){}
324 virtual ~AliHBTPIDCut(){}
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)
330 //___________________________________________________
331 /////////////////////////////////////////////////////
333 // class AliHBTLogicalOperCut //
335 // This cut is base class fAnd class that perfAndms //
336 // logical operations on cuts //
338 /////////////////////////////////////////////////////
339 class AliHBTLogicalOperCut: public AliHbtBaseCut
342 AliHBTLogicalOperCut();
343 AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second);
344 virtual ~AliHBTLogicalOperCut();
346 Double_t GetValue(AliHBTParticle * /*part*/){MayNotUse("GetValue");return 0.0;}
348 AliHbtBaseCut* fFirst; //second cut
349 AliHbtBaseCut* fSecond; //first cut
351 class AliHBTDummyBaseCut: public AliHbtBaseCut
353 Double_t GetValue(AliHBTParticle * /*part*/){return 0.0;}
354 Bool_t Pass(AliHBTParticle* /*part*/);
357 ClassDef(AliHBTLogicalOperCut,1)
360 class AliHBTOrCut: public AliHBTLogicalOperCut
364 AliHBTOrCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){}
365 virtual ~AliHBTOrCut(){}
366 Bool_t Pass(AliHBTParticle *p);
367 ClassDef(AliHBTOrCut,1)
370 class AliHBTAndCut: public AliHBTLogicalOperCut
374 AliHBTAndCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){}
375 virtual ~AliHBTAndCut(){}
376 Bool_t Pass(AliHBTParticle *p);
377 ClassDef(AliHBTAndCut,1)