e8b6f079760326c2ad3cabd8244d603ab764d93f
[u/mrichter/AliRoot.git] / HBTAN / AliHBTPairCut.h
1 #ifndef ALIHBTPAIRCUT_H
2 #define ALIHBTPAIRCUT_H
3
4 /* $Id$ */
5
6 //Piotr Skowronski@cern.ch
7 //Class implements cut on the pair of particles
8 //
9 //more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
10  
11 #include "AliHBTPair.h"
12
13 class AliHBTParticleCut;
14 class AliHbtBasePairCut;
15
16 enum AliHBTPairCutProperty
17 {
18   kHbtPairCutPropQInv, //Q invariant
19   kHbtPairCutPropKt,
20   kHbtPairCutPropKStar,
21   kHbtPairCutPropQSideCMSLC,
22   kHbtPairCutPropQOutCMSLC,
23   kHbtPairCutPropQLongCMSLC,
24   kHbtPairCutPropAvSepar,
25   kHbtPairCutPropClOverlap,
26   kHbtPairCutPropNone
27 };
28 /******************************************************************/
29
30 class AliHBTPairCut: public TNamed
31 {
32  public:
33   AliHBTPairCut();
34   AliHBTPairCut(const AliHBTPairCut& in);
35   AliHBTPairCut& operator = (const AliHBTPairCut& in);
36   
37   virtual ~AliHBTPairCut();
38   virtual Bool_t Pass(AliHBTPair* pair) const;
39   virtual Bool_t PassPairProp(AliHBTPair* pair) const;
40      
41   virtual Bool_t IsEmpty() const {return kFALSE;}
42   void SetFirstPartCut(AliHBTParticleCut* cut);  //sets the cut on the first particle
43   void SetSecondPartCut(AliHBTParticleCut* cut); //sets the cut on the second particle
44   
45   void SetPartCut(AliHBTParticleCut* cut);//sets the the same cut on both particles
46   
47   virtual void AddBasePairCut(AliHbtBasePairCut* cut);
48   
49   void SetQInvRange(Double_t min, Double_t max);
50   void SetKtRange(Double_t min, Double_t max);
51   void SetKStarRange(Double_t min, Double_t max);
52   void SetQOutCMSLRange(Double_t min, Double_t max);
53   void SetQSideCMSLRange(Double_t min, Double_t max);
54   void SetQLongCMSLRange(Double_t min, Double_t max);
55   void SetAvSeparationRange(Double_t min,Double_t max = 10e5);//Anti-Merging Cut
56   void SetClusterOverlapRange(Double_t min,Double_t max);//Anti-Splitting Max range -0.5 1.0
57       
58   AliHBTParticleCut* GetFirstPartCut() const {return fFirstPartCut;}
59   AliHBTParticleCut* GetSecondPartCut() const {return fSecondPartCut;}
60   
61  protected:
62   AliHBTParticleCut*      fFirstPartCut;//cut on first particle in pair
63   AliHBTParticleCut*      fSecondPartCut;//cut on second particle in pair
64   
65   AliHbtBasePairCut** fCuts; //! array of poiters to base cuts
66   Int_t fNCuts;//Number of cuts in fCuts array
67   
68   
69   AliHbtBasePairCut* FindCut(AliHBTPairCutProperty cut);
70  private:
71   static const Int_t fgkMaxCuts; // Max number of cuts
72   ClassDef(AliHBTPairCut,2)
73 };
74 /******************************************************************/
75 /******************************************************************/
76 /******************************************************************/
77
78 class AliHBTEmptyPairCut:  public AliHBTPairCut
79 {
80   //Empty - it passes possitively all particles - it means returns always False
81   //Class describing cut on pairs of particles
82  public:
83   AliHBTEmptyPairCut(){};
84   AliHBTEmptyPairCut(const AliHBTEmptyPairCut& in):AliHBTPairCut(in){};
85   virtual ~AliHBTEmptyPairCut(){};
86   
87   Bool_t Pass(AliHBTPair*) const {return kFALSE;} //accpept everything
88   Bool_t IsEmpty() const {return kTRUE;}
89   
90   ClassDef(AliHBTEmptyPairCut,1)
91 };
92
93
94
95 /******************************************************************/
96 /******************************************************************/
97 /******************************************************************/
98
99 class AliHbtBasePairCut: public TObject
100 {
101   //This class defines the range of some property - pure virtual
102   //Property is coded by AliHBTCutTypes type
103    
104  public:
105      
106   AliHbtBasePairCut(Double_t min = 0.0, Double_t max = 0.0, AliHBTPairCutProperty prop= kHbtPairCutPropNone):
107     fMin(min),fMax(max),fProperty(prop){}
108   
109   virtual   ~AliHbtBasePairCut(){}
110      
111   virtual Bool_t    Pass(AliHBTPair* pair) const;
112   
113   void      SetRange(Double_t min, Double_t max){fMin = min; fMax = max;}
114   
115   void      SetMinimum(Double_t min){fMin = min;}
116   void      SetMaximum(Double_t max){fMax = max;}
117   
118   Double_t  GetMinimum() const {return fMin;}
119   Double_t  GetMaximum() const {return fMax;}
120   
121   AliHBTPairCutProperty GetProperty() const {return fProperty;}
122   
123  protected:
124   virtual Double_t  GetValue(AliHBTPair* pair) const = 0;
125   
126   Double_t fMin; // Lower boundary of the range
127   Double_t fMax; // Upper boundary of the range
128   
129   AliHBTPairCutProperty fProperty; // The property itself
130   
131   ClassDef(AliHbtBasePairCut,1)
132  
133  };
134 /******************************************************************/
135
136 inline Bool_t AliHbtBasePairCut::Pass(AliHBTPair* pair) const
137 {
138   //checks if pair proprty is in range
139   //null pointer check is made by AliHBTPairCut, so here is unnecesary
140   
141   Double_t value = GetValue(pair);
142   if ( (value > fMin) && (value <fMax ) ) return kFALSE; //accepted
143   else return kTRUE; //rejected
144 }
145 /******************************************************************/
146 /******************************************************************/
147 /******************************************************************/
148
149 class AliHBTQInvCut: public AliHbtBasePairCut
150 {
151  public:
152   AliHBTQInvCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropQInv){}
153   virtual ~AliHBTQInvCut(){}
154  protected:
155   virtual Double_t  GetValue(AliHBTPair* pair) const {return pair->GetQInv();}
156   
157   ClassDef(AliHBTQInvCut,1)
158  };
159 /******************************************************************/
160
161 class AliHBTKtCut: public AliHbtBasePairCut {
162  public:
163   AliHBTKtCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropKt){}
164   virtual ~AliHBTKtCut(){}
165  protected:
166   virtual Double_t  GetValue(AliHBTPair* pair) const {return pair->GetKt();}
167
168   ClassDef(AliHBTKtCut,1)
169  };
170 /******************************************************************/
171
172 class AliHBTKStarCut: public AliHbtBasePairCut
173 {
174  public:
175   AliHBTKStarCut(Double_t min = 0.0, Double_t max = 0.0):AliHbtBasePairCut(min,max,kHbtPairCutPropKStar){}
176   virtual ~AliHBTKStarCut(){}
177  protected:
178   virtual Double_t  GetValue(AliHBTPair* pair) const {return pair->GetKStar();}
179
180   ClassDef(AliHBTKStarCut,1)
181 };
182 /******************************************************************/
183
184 class AliHBTQSideCMSLCCut: public AliHbtBasePairCut
185 {
186  public:
187   AliHBTQSideCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
188     AliHbtBasePairCut(min,max,kHbtPairCutPropQSideCMSLC){}
189   virtual ~AliHBTQSideCMSLCCut(){}
190  protected:
191   virtual Double_t  GetValue(AliHBTPair* pair) const 
192     {return pair->GetQSideCMSLC();}
193
194   ClassDef(AliHBTQSideCMSLCCut,1)
195 };
196 /******************************************************************/
197
198
199 class AliHBTQOutCMSLCCut: public AliHbtBasePairCut
200 {
201  public:
202   AliHBTQOutCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
203     AliHbtBasePairCut(min,max,kHbtPairCutPropQOutCMSLC){}
204   virtual ~AliHBTQOutCMSLCCut(){}
205  protected:
206   virtual Double_t  GetValue(AliHBTPair* pair) const 
207     {return pair->GetQOutCMSLC();}
208   
209   ClassDef(AliHBTQOutCMSLCCut,1)
210 };
211 /******************************************************************/
212
213 class AliHBTQLongCMSLCCut: public AliHbtBasePairCut
214 {
215  public:
216   AliHBTQLongCMSLCCut(Double_t min = 0.0, Double_t max = 0.0):
217     AliHbtBasePairCut(min,max,kHbtPairCutPropQLongCMSLC){}
218   virtual ~AliHBTQLongCMSLCCut(){}
219  protected:
220   virtual Double_t  GetValue(AliHBTPair* pair) const 
221     {return pair->GetQLongCMSLC();}
222
223   ClassDef(AliHBTQLongCMSLCCut,1)
224 };
225 /******************************************************************/
226
227 class AliHBTCluterOverlapCut: public AliHbtBasePairCut
228 {
229  public:
230   AliHBTCluterOverlapCut(Double_t min = 0.0, Double_t max = 1e5):
231     AliHbtBasePairCut(min,max,kHbtPairCutPropClOverlap){}
232   virtual ~AliHBTCluterOverlapCut(){}
233
234  protected:
235   virtual Double_t  GetValue(AliHBTPair* pair) const;
236   ClassDef(AliHBTCluterOverlapCut,1)
237 };
238 /******************************************************************/
239   
240 class AliHBTAvSeparationCut: public AliHbtBasePairCut
241 {
242  public:
243   AliHBTAvSeparationCut(Double_t min = 0.0, Double_t max = 1e5):
244     AliHbtBasePairCut(min,max,kHbtPairCutPropAvSepar){}
245   virtual ~AliHBTAvSeparationCut(){}
246   
247  protected:
248   virtual Double_t  GetValue(AliHBTPair* pair) const;
249   ClassDef(AliHBTAvSeparationCut,1)
250 };
251 /******************************************************************/
252
253 class AliHBTOutSideSameSignCut: public AliHbtBasePairCut
254 {
255  public:
256   AliHBTOutSideSameSignCut(){}
257   virtual ~AliHBTOutSideSameSignCut(){}
258   virtual Bool_t Pass(AliHBTPair *p) const;
259  protected:
260   virtual Double_t  GetValue(AliHBTPair* /*pair*/) const {return 0.0;}
261   ClassDef(AliHBTOutSideSameSignCut,1)
262 };
263 /******************************************************************/
264
265 class AliHBTOutSideDiffSignCut: public AliHbtBasePairCut
266 {
267  public:
268   AliHBTOutSideDiffSignCut(){}
269   virtual ~AliHBTOutSideDiffSignCut(){}
270   virtual Bool_t Pass(AliHBTPair *p) const;
271  protected:
272   virtual Double_t  GetValue(AliHBTPair* /*pair*/) const {return 0.0;}
273   ClassDef(AliHBTOutSideDiffSignCut,1)
274 };
275 /******************************************************************/
276
277 class AliHBTLogicalOperPairCut:  public AliHbtBasePairCut
278  {
279    public:
280      AliHBTLogicalOperPairCut();
281      AliHBTLogicalOperPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second);
282      virtual   ~AliHBTLogicalOperPairCut();
283    protected:
284      Double_t  GetValue(AliHBTPair * /*pair*/) const {MayNotUse("GetValue");return 0.0;}
285
286      AliHbtBasePairCut* fFirst;   //second cut
287      AliHbtBasePairCut* fSecond;  //first cut
288    private:
289     class  AliHBTDummyBasePairCut: public AliHbtBasePairCut
290      {
291        Double_t  GetValue(AliHBTPair* /*pair*/) const {return 0.0;}
292        Bool_t    Pass(AliHBTPair* /*pair*/) const;
293      };
294
295     ClassDef(AliHBTLogicalOperPairCut,1)
296  };
297 /******************************************************************/
298
299 class AliHBTOrPairCut: public AliHBTLogicalOperPairCut
300 {
301    public:
302      AliHBTOrPairCut(){}
303      AliHBTOrPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):AliHBTLogicalOperPairCut(first,second){}
304      virtual   ~AliHBTOrPairCut(){}
305      Bool_t    Pass(AliHBTPair *p) const;
306      ClassDef(AliHBTOrPairCut,1)
307 };
308 /******************************************************************/
309
310 class AliHBTAndPairCut: public AliHBTLogicalOperPairCut
311 {
312    public:
313      AliHBTAndPairCut(){}
314      AliHBTAndPairCut(AliHbtBasePairCut* first, AliHbtBasePairCut* second):AliHBTLogicalOperPairCut(first,second){}
315      virtual   ~AliHBTAndPairCut(){}
316      Bool_t    Pass(AliHBTPair *p) const;
317      ClassDef(AliHBTAndPairCut,1)
318 };
319
320 #endif