1 #ifndef ALIHBTPARTICLECUT_H
2 #define ALIHBTPARTICLECUT_H
3 //__________________________________________________________________________
4 ////////////////////////////////////////////////////////////////////////////
6 // class AliHBTParticleCut //
8 // Classes for single particle cuts //
9 // User should use only AliHBTParticleCut, eventually //
10 // EmptyCut which passes all particles //
11 // There is all interface for setting cuts on all particle properties //
12 // The main method is Pass - which returns //
13 // True to reject particle //
14 // False in case it meets all the criteria of the given cut //
16 // User should create (and also destroy) cuts himself //
17 // and then pass them to the Analysis And Function by a proper method //
20 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html //
21 // resonsible: Piotr Skowronski@cern.ch //
23 ////////////////////////////////////////////////////////////////////////////
27 #include "AliHBTParticle.h"
30 class AliHBTEmptyParticleCut;
31 class AliHBTParticleCut;
37 /******************************************************************/
38 /******************************************************************/
39 /******************************************************************/
41 enum AliHBTCutProperty
43 //codes particle property
45 kHbtPt, //Transverse momentum
49 kHbtPx, //X coAnddinate of the momentum
50 kHbtPy, //Y coAnddinate of the momentum
51 kHbtPz, //Z coAnddinate of the momentum
54 kHbtVx, // vertex X coAnddinate
55 kHbtVy, // vertex Y coAnddinate
56 kHbtVz, // vertex Z coAnddinate
57 kHbtPid, // vertex Z coAnddinate
58 //_____________________________
62 /******************************************************************/
63 /******************************************************************/
64 /******************************************************************/
66 class AliHBTParticleCut: public TObject
68 //Class describing cut on pairs of particles
71 AliHBTParticleCut(const AliHBTParticleCut& in);
72 virtual ~AliHBTParticleCut();
73 AliHBTParticleCut& operator = (const AliHBTParticleCut& in);
75 virtual Bool_t Pass(AliHBTParticle* p) const;
76 Bool_t IsEmpty() const {return kFALSE;}
78 void AddBasePartCut(AliHbtBaseCut* basecut);
80 Int_t GetPID() const { return fPID;}
81 void SetPID(Int_t pid){fPID=pid;}
82 void SetMomentumRange(Double_t min, Double_t max);
83 void SetPRange(Double_t min, Double_t max){SetMomentumRange(min,max);}
84 void SetPtRange(Double_t min, Double_t max);
85 void SetEnergyRange(Double_t min, Double_t max);
86 void SetRapidityRange(Double_t min, Double_t max);
87 void SetYRange(Double_t min, Double_t max){SetRapidityRange(min,max);}
88 void SetPseudoRapidityRange(Double_t min, Double_t max);
89 void SetPxRange(Double_t min, Double_t max);
90 void SetPyRange(Double_t min, Double_t max);
91 void SetPzRange(Double_t min, Double_t max);
92 void SetPhiRange(Double_t min, Double_t max);
93 void SetThetaRange(Double_t min, Double_t max);
94 void SetVxRange(Double_t min, Double_t max);
95 void SetVyRange(Double_t min, Double_t max);
96 void SetVzRange(Double_t min, Double_t max);
98 void Print(void) const;
101 AliHbtBaseCut* FindCut(AliHBTCutProperty property);
103 AliHbtBaseCut ** fCuts;//! Array with cuts
104 Int_t fNCuts; //number of base cuts stored in fCuts
106 Int_t fPID; //particle PID - if=0 (rootino) all pids are accepted
109 static const Int_t fgkMaxCuts; //Size of the fCuts array
111 ClassDef(AliHBTParticleCut,1)
113 /******************************************************************/
114 /******************************************************************/
115 /******************************************************************/
117 class AliHBTEmptyParticleCut: public AliHBTParticleCut
119 //Empty - it passes possitively all particles - it means returns always False
120 //Class describing cut on pairs of particles
122 AliHBTEmptyParticleCut(){};
123 virtual ~AliHBTEmptyParticleCut(){};
125 Bool_t Pass(AliHBTParticle*) const {return kFALSE;} //accept everything <<CAN NOT BE const!!!!>>
126 Bool_t IsEmpty() const {return kTRUE;}
128 ClassDef(AliHBTEmptyParticleCut,1)
132 /******************************************************************/
133 /******************************************************************/
134 /******************************************************************/
136 class AliHbtBaseCut: public TObject
138 //This class defines the range of some property - pure virtual
139 //Property is coded by AliHBTCutTypes type
143 AliHbtBaseCut(Double_t min = 0.0, Double_t max = 0.0,AliHBTCutProperty prop = kHbtNone):
144 fProperty(prop),fMin(min),fMax(max){}
146 virtual ~AliHbtBaseCut(){}
148 virtual Bool_t Pass(AliHBTParticle *p) const;
150 void SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
152 void SetMinimum(Double_t min){fMin = min;}
153 void SetMaximum(Double_t max){fMax = max;}
155 Double_t GetMinimum() const {return fMin;}
156 Double_t GetMaximum() const {return fMax;}
158 AliHBTCutProperty GetProperty() const {return fProperty;}
159 virtual void Print(void) const;
162 virtual Double_t GetValue(AliHBTParticle *) const = 0;
164 AliHBTCutProperty fProperty; //property that this cut describes
165 Double_t fMin;//minimum value
166 Double_t fMax;//maximum value
169 void PrintProperty(void) const;
170 ClassDef(AliHbtBaseCut,1)
175 AliHbtBaseCut::Pass(AliHBTParticle *p) const
177 //cjecks if particle property fits in range
178 if ( (GetValue(p) < fMin) || (GetValue(p) > fMax ) ) return kTRUE; //rejected
179 else return kFALSE; //accepted
181 /******************************************************************/
182 /******************************************************************/
183 /******************************************************************/
186 class AliHBTMomentumCut: public AliHbtBaseCut
189 AliHBTMomentumCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtP){}
190 virtual ~AliHBTMomentumCut(){}
192 Double_t GetValue(AliHBTParticle * p)const{return p->P();}
193 ClassDef(AliHBTMomentumCut,1)
196 class AliHBTPtCut: public AliHbtBaseCut
199 AliHBTPtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPt){}
200 virtual ~AliHBTPtCut(){}
202 Double_t GetValue(AliHBTParticle * p)const{return p->Pt();}
203 ClassDef(AliHBTPtCut,1)
207 class AliHBTEnergyCut: public AliHbtBaseCut
210 AliHBTEnergyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtE){}
211 virtual ~AliHBTEnergyCut(){}
213 Double_t GetValue(AliHBTParticle * p)const {return p->Energy();}
214 ClassDef(AliHBTEnergyCut,1)
217 class AliHBTRapidityCut: public AliHbtBaseCut
220 AliHBTRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtRapidity){}
221 virtual ~AliHBTRapidityCut(){}
223 Double_t GetValue(AliHBTParticle * p)const{return p->Y();}
224 ClassDef(AliHBTRapidityCut,1)
227 class AliHBTPseudoRapidityCut: public AliHbtBaseCut
230 AliHBTPseudoRapidityCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPseudoRapidity){}
231 virtual ~AliHBTPseudoRapidityCut(){}
233 Double_t GetValue(AliHBTParticle * p)const{return p->Eta();}
234 ClassDef(AliHBTPseudoRapidityCut,1)
237 class AliHBTPxCut: public AliHbtBaseCut
240 AliHBTPxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPx){}
241 virtual ~AliHBTPxCut(){}
243 Double_t GetValue(AliHBTParticle * p)const{return p->Px();}
244 ClassDef(AliHBTPxCut,1)
247 class AliHBTPyCut: public AliHbtBaseCut
250 AliHBTPyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPy){}
251 virtual ~AliHBTPyCut(){}
253 Double_t GetValue(AliHBTParticle * p)const{return p->Py();}
254 ClassDef(AliHBTPyCut,1)
258 class AliHBTPzCut: public AliHbtBaseCut
261 AliHBTPzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPz){}
262 virtual ~AliHBTPzCut(){}
264 Double_t GetValue(AliHBTParticle * p)const{return p->Pz();}
265 ClassDef(AliHBTPzCut,1)
268 class AliHBTPhiCut: public AliHbtBaseCut
271 AliHBTPhiCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtPhi){}
272 virtual ~AliHBTPhiCut(){}
274 Double_t GetValue(AliHBTParticle * p)const{return p->Phi();}
275 ClassDef(AliHBTPhiCut,1)
279 class AliHBTThetaCut: public AliHbtBaseCut
282 AliHBTThetaCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtTheta){}
283 virtual ~AliHBTThetaCut(){}
285 Double_t GetValue(AliHBTParticle * p)const{return p->Theta();}
286 ClassDef(AliHBTThetaCut,1)
290 class AliHBTVxCut: public AliHbtBaseCut
292 //Cut of the X coAnddinate of the vertex position
294 AliHBTVxCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVx){}
295 virtual ~AliHBTVxCut(){}
297 Double_t GetValue(AliHBTParticle * p)const{return p->Vx();} //retruns value of the vertex
298 ClassDef(AliHBTVxCut,1)
303 class AliHBTVyCut: public AliHbtBaseCut
305 //Cut of the X coAnddinate of the vertex position
307 AliHBTVyCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVy){}
308 virtual ~AliHBTVyCut(){}
310 Double_t GetValue(AliHBTParticle * p)const{return p->Vy();} //retruns value of the vertex
311 ClassDef(AliHBTVyCut,1)
315 class AliHBTVzCut: public AliHbtBaseCut
317 //Cut of the X coAnddinate of the vertex position
319 AliHBTVzCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBaseCut(min,max,kHbtVz){}
320 virtual ~AliHBTVzCut(){}
322 Double_t GetValue(AliHBTParticle * p)const{return p->Vz();} //retruns value of the vertex
324 ClassDef(AliHBTVzCut,1)
328 class AliHBTPIDCut: public AliHbtBaseCut
331 AliHBTPIDCut():AliHbtBaseCut(0.0,0.0,kHbtPid),fPID(0){}
332 AliHBTPIDCut(Int_t pid, Double_t min = 0.0, Double_t max = 1.0):AliHbtBaseCut(min,max,kHbtPid),fPID(pid){}
333 virtual ~AliHBTPIDCut(){}
335 Double_t GetValue(AliHBTParticle * p)const{return p->GetPIDprobability(fPID);}
336 Int_t fPID; //pid of particle that the pid is set
337 ClassDef(AliHBTPIDCut,1)
339 //___________________________________________________
340 /////////////////////////////////////////////////////
342 // class AliHBTLogicalOperCut //
344 // This cut is base class fAnd class that perfAndms //
345 // logical operations on cuts //
347 /////////////////////////////////////////////////////
348 class AliHBTLogicalOperCut: public AliHbtBaseCut
351 AliHBTLogicalOperCut();
352 AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second);
353 virtual ~AliHBTLogicalOperCut();
355 Double_t GetValue(AliHBTParticle * /*part*/) const {MayNotUse("GetValue");return 0.0;}
357 AliHbtBaseCut* fFirst; //second cut
358 AliHbtBaseCut* fSecond; //first cut
360 class AliHBTDummyBaseCut: public AliHbtBaseCut
362 Double_t GetValue(AliHBTParticle * /*part*/) const {return 0.0;}
363 Bool_t Pass(AliHBTParticle* /*part*/) const;
366 ClassDef(AliHBTLogicalOperCut,1)
369 class AliHBTOrCut: public AliHBTLogicalOperCut
373 AliHBTOrCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){}
374 virtual ~AliHBTOrCut(){}
375 Bool_t Pass(AliHBTParticle *p) const;
376 ClassDef(AliHBTOrCut,1)
379 class AliHBTAndCut: public AliHBTLogicalOperCut
383 AliHBTAndCut(AliHbtBaseCut* first, AliHbtBaseCut* second):AliHBTLogicalOperCut(first,second){}
384 virtual ~AliHBTAndCut(){}
385 Bool_t Pass(AliHBTParticle *p) const;
386 ClassDef(AliHBTAndCut,1)