AntiMerging cut implemented
[u/mrichter/AliRoot.git] / HBTAN / AliHBTPairCut.cxx
1 /* $Id$ */
2 //____________________________________
3 /////////////////////////////////////////////////////////////////////////
4 //
5 // Class AliHBTPairCut:
6 //
7 // implements cut on the pair of particles
8 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
9 // Author: Piotr.Skowronski@cern.ch
10 //-------------------------------------------------------------------
11
12 #include "AliHBTPairCut.h"
13 #include "AliHBTPair.h"
14 #include "AliHBTParticleCut.h"
15 #include "AliHBTTrackPoints.h"
16
17 ClassImp(AliHBTPairCut)
18 const Int_t AliHBTPairCut::fgkMaxCuts = 50;
19 /**********************************************************/
20
21 AliHBTPairCut::AliHBTPairCut():
22   fNCuts(0)
23 {
24   //constructor
25   fFirstPartCut = new AliHBTEmptyParticleCut(); //empty cuts
26   fSecondPartCut= new AliHBTEmptyParticleCut(); //empty cuts
27     
28   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
29 }
30 /**********************************************************/
31
32 AliHBTPairCut::AliHBTPairCut(const AliHBTPairCut& in):
33  TNamed(in)
34 {
35   //copy constructor
36   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
37   fNCuts = in.fNCuts;
38
39   fFirstPartCut = (AliHBTParticleCut*)in.fFirstPartCut->Clone();
40   fSecondPartCut = (AliHBTParticleCut*)in.fSecondPartCut->Clone();
41  
42   for (Int_t i = 0;i<fNCuts;i++)
43     {
44       fCuts[i] = (AliHbtBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
45     }
46 }
47 /**********************************************************/
48
49 AliHBTPairCut&  AliHBTPairCut::operator=(const AliHBTPairCut& in)
50 {
51   //assignment operator
52   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
53   fNCuts = in.fNCuts;
54
55   fFirstPartCut = (AliHBTParticleCut*)in.fFirstPartCut->Clone();
56   fSecondPartCut = (AliHBTParticleCut*)in.fSecondPartCut->Clone();
57  
58   for (Int_t i = 0;i<fNCuts;i++)
59     {
60       fCuts[i] = (AliHbtBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
61     }
62   return * this;
63 }
64 /**********************************************************/
65
66 AliHBTPairCut::~AliHBTPairCut()
67 {
68   //destructor
69   if (fFirstPartCut != fSecondPartCut)
70     {
71       delete fSecondPartCut;
72     }
73   delete fFirstPartCut;
74   for (Int_t i = 0;i<fNCuts;i++)
75     {
76       delete fCuts[i];
77     }
78   delete []fCuts;
79
80 /**********************************************************/
81
82 /**********************************************************/
83
84 void AliHBTPairCut::AddBasePairCut(AliHbtBasePairCut* basecut)
85 {
86   //adds the base pair cut (cut on one value)
87   
88   if (!basecut) return;
89   if( fNCuts == (fgkMaxCuts-1) )
90     {
91       Warning("AddBasePairCut","Not enough place for another cut");
92       return;
93     }
94   fCuts[fNCuts++]=basecut;
95 }
96 /**********************************************************/
97
98 Bool_t AliHBTPairCut::Pass(AliHBTPair* pair) const
99 {
100   //methods which checks if given pair meets all criteria of the cut
101   //if it meets returns FALSE
102   //if NOT   returns    TRUE
103   if(!pair) 
104     {
105       Warning("Pass","No Pasaran! We never accept NULL pointers");
106       return kTRUE;
107     }
108   
109   //check particle's cuts
110   if( ( fFirstPartCut->Pass( pair->Particle1()) ) || 
111       ( fSecondPartCut->Pass(pair->Particle2()) )   )
112     {  
113       return kTRUE;
114     }
115   return PassPairProp(pair);
116 }
117 /**********************************************************/
118
119 Bool_t AliHBTPairCut::PassPairProp(AliHBTPair* pair) const
120 {
121   //methods which checks if given pair meets all criteria of the cut
122   //if it meets returns FALSE
123   //if NOT   returns    TRUE
124   //examine all base pair cuts
125   for (Int_t i = 0;i<fNCuts;i++)
126     {
127       if ( (fCuts[i]->Pass(pair)) ) return kTRUE; //if one of the cuts reject, then reject
128     }
129   return kFALSE;
130 }
131 /**********************************************************/
132
133 void AliHBTPairCut::SetFirstPartCut(AliHBTParticleCut* cut)
134 {
135   // set cut for the first particle
136   if(!cut) 
137     {
138       Error("SetFirstPartCut","argument is NULL");
139       return;
140     }
141   delete fFirstPartCut;
142   fFirstPartCut = (AliHBTParticleCut*)cut->Clone();
143   
144 }
145 /**********************************************************/
146
147 void AliHBTPairCut::SetSecondPartCut(AliHBTParticleCut* cut)
148 {
149   // set cut for the second particle
150   if(!cut) 
151     {
152       Error("SetSecondPartCut","argument is NULL");
153       return;
154     }
155   delete fSecondPartCut;
156   fSecondPartCut = (AliHBTParticleCut*)cut->Clone();
157 }
158 /**********************************************************/
159
160 void AliHBTPairCut::SetPartCut(AliHBTParticleCut* cut)
161 {
162   //sets the the same cut on both particles
163   if(!cut) 
164     {
165       Error("SetFirstPartCut","argument is NULL");
166       return;
167     }
168   if (fFirstPartCut == fSecondPartCut) fSecondPartCut = 0x0;
169   
170   delete fFirstPartCut;
171   fFirstPartCut = (AliHBTParticleCut*)cut->Clone();
172   
173   delete fSecondPartCut; //even if null should not be harmful
174   fSecondPartCut = fFirstPartCut;
175 }
176 /**********************************************************/
177
178 void AliHBTPairCut::SetQInvRange(Double_t min, Double_t max)
179 {
180   // set range of accepted invariant masses
181   AliHBTQInvCut* cut= (AliHBTQInvCut*)FindCut(kHbtPairCutPropQInv);
182   if(cut) cut->SetRange(min,max);
183   else fCuts[fNCuts++] = new AliHBTQInvCut(min,max);
184 }
185 /**********************************************************/
186 void AliHBTPairCut::SetQOutCMSLRange(Double_t min, Double_t max)
187 {
188   // set range of accepted QOut in CMS
189   AliHBTQOutCMSLCCut* cut= (AliHBTQOutCMSLCCut*)FindCut(kHbtPairCutPropQOutCMSLC);
190   if(cut) cut->SetRange(min,max);
191   else fCuts[fNCuts++] = new AliHBTQOutCMSLCCut(min,max);
192 }
193
194 /**********************************************************/
195 void AliHBTPairCut::SetQSideCMSLRange(Double_t min, Double_t max)
196 {
197   // set range of accepted QSide in CMS
198   AliHBTQSideCMSLCCut* cut= (AliHBTQSideCMSLCCut*)FindCut(kHbtPairCutPropQSideCMSLC);
199   if(cut) cut->SetRange(min,max);
200   else fCuts[fNCuts++] = new AliHBTQSideCMSLCCut(min,max);
201 }
202
203 /**********************************************************/
204 void AliHBTPairCut::SetQLongCMSLRange(Double_t min, Double_t max)
205 {
206   // set range of accepted QLong in CMS
207   AliHBTQLongCMSLCCut* cut= (AliHBTQLongCMSLCCut*)FindCut(kHbtPairCutPropQLongCMSLC);
208   if(cut) cut->SetRange(min,max);
209   else fCuts[fNCuts++] = new AliHBTQLongCMSLCCut(min,max);
210 }
211
212 /**********************************************************/
213
214 void AliHBTPairCut::SetKtRange(Double_t min, Double_t max)
215 {
216   // set range of accepted Kt (?)
217   AliHBTKtCut* cut= (AliHBTKtCut*)FindCut(kHbtPairCutPropKt);
218   if(cut) cut->SetRange(min,max);
219   else fCuts[fNCuts++] = new AliHBTKtCut(min,max);
220 }
221 /**********************************************************/
222
223 void AliHBTPairCut::SetKStarRange(Double_t min, Double_t max)
224 {
225   // set range of accepted KStar (?)
226   AliHBTKStarCut* cut= (AliHBTKStarCut*)FindCut(kHbtPairCutPropKStar);
227   if(cut) cut->SetRange(min,max);
228   else fCuts[fNCuts++] = new AliHBTKStarCut(min,max);
229 }
230 /**********************************************************/
231 void AliHBTPairCut::SetAvSeparationRange(Double_t min, Double_t max)
232 {
233   //sets avarage separation cut ->Anti-Merging cut
234   AliHbtBasePairCut* cut= FindCut(kHbtPairCutPropAvSepar);
235   if(cut) cut->SetRange(min,max);
236   else fCuts[fNCuts++] = new AliHBTAvSeparationCut(min,max);
237 }
238 /**********************************************************/
239
240 AliHbtBasePairCut* AliHBTPairCut::FindCut(AliHBTPairCutProperty property)
241 {
242   // Find the cut corresponding to "property"
243   for (Int_t i = 0;i<fNCuts;i++)
244     {
245       if (fCuts[i]->GetProperty() == property) 
246         return fCuts[i]; //we found the cut we were searching for
247     }
248   
249   return 0x0; //we did not found this cut
250   
251 }
252 /**********************************************************/
253
254 void AliHBTPairCut::Streamer(TBuffer &b)
255 {
256   // Stream all objects in the array to or from the I/O buffer.
257   
258   UInt_t R__s, R__c;
259   if (b.IsReading()) 
260     {
261       Version_t v = b.ReadVersion(&R__s, &R__c);
262       if (v > -1)
263        {
264           delete fFirstPartCut;
265           delete fSecondPartCut;
266           fFirstPartCut = 0x0;
267           fSecondPartCut = 0x0;
268           TObject::Streamer(b);
269           b >> fFirstPartCut;
270           b >> fSecondPartCut;
271           b >> fNCuts;
272           for (Int_t i = 0;i<fNCuts;i++)
273            {
274              b >> fCuts[i];
275            }
276         }
277       b.CheckByteCount(R__s, R__c,AliHBTPairCut::IsA());
278     } 
279   else 
280     {
281       R__c = b.WriteVersion(AliHBTPairCut::IsA(), kTRUE);
282       TObject::Streamer(b);
283       
284 //      printf("Streamer Cut 1 %#x Cut 2 %#x\n",fFirstPartCut,fSecondPartCut);
285 //      this->Dump();
286 //      fFirstPartCut->Dump();
287       
288       b << fFirstPartCut;
289       b << fSecondPartCut;
290       b << fNCuts;
291       for (Int_t i = 0;i<fNCuts;i++)
292         {
293           b << fCuts[i];
294         }
295       b.SetByteCount(R__c, kTRUE);
296     }
297 }
298
299 ClassImp(AliHBTEmptyPairCut)
300   
301 void AliHBTEmptyPairCut::Streamer(TBuffer &b)
302 {
303 //streamer for empty pair cut
304   AliHBTPairCut::Streamer(b);
305 }
306
307 ClassImp(AliHbtBasePairCut)
308 ClassImp(AliHBTQInvCut)
309 ClassImp(AliHBTKtCut)
310 ClassImp(AliHBTQSideCMSLCCut)
311 ClassImp(AliHBTQOutCMSLCCut)
312 ClassImp(AliHBTQLongCMSLCCut)
313 ClassImp(AliHBTAvSeparationCut)
314
315     
316 Double_t AliHBTAvSeparationCut::GetValue(AliHBTPair* pair) const 
317 {
318   //chacks if avarage distance of two tracks is in given range
319   Warning("Pass","Checking Av Separation."); 
320   AliHBTTrackPoints* tpts1 = pair->Particle1()->GetTrackPoints();
321   if ( tpts1 == 0x0)
322    {
323      Warning("Pass","Track 1 does not have Track Points. Pair NOT Passed.");
324      return -10e5;
325    }
326
327   AliHBTTrackPoints* tpts2 = pair->Particle2()->GetTrackPoints();
328   if ( tpts2 == 0x0)
329    {
330      Warning("Pass","Track 2 does not have Track Points. Pair NOT Passed.");
331      return -10e5;
332    }
333    
334   return tpts1->AvarageDistance(*tpts2);
335 }
336