fix mem leak and compiler warning
[u/mrichter/AliRoot.git] / ANALYSIS / AliAODPairCut.cxx
1 #include "AliAODPairCut.h"
2 /* $Id$ */
3
4 /////////////////////////////////////////////////////////////////////////
5 //
6 // Class AliAODPairCut:
7 // implements cut on the pair of particles
8 // more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
9 // Author: Piotr.Skowronski@cern.ch
10 //-------------------------------------------------------------------
11
12 #include "AliAODPair.h"
13 #include "AliAODParticleCut.h"
14 //#include "AliTrackPoints.h"
15 //#include "AliClusterMap.h"
16
17 ClassImp(AliAODPairCut)
18 const Int_t AliAODPairCut::fgkMaxCuts = 50;
19 /**********************************************************/
20
21 AliAODPairCut::AliAODPairCut():
22   fFirstPartCut(new AliAODParticleEmptyCut()), //empty cuts
23   fSecondPartCut(new AliAODParticleEmptyCut()), //empty cuts
24   fCuts(new AliAODPairBaseCut*[fgkMaxCuts]),
25   fNCuts(0)
26 {
27   //constructor
28     
29   for (Int_t i = 0;i<fNCuts;i++)
30    {
31      fCuts[i] = 0x0;
32    }
33 }
34 /**********************************************************/
35
36 AliAODPairCut::AliAODPairCut(const AliAODPairCut& in):
37   TNamed(in),
38   fFirstPartCut((AliAODParticleCut*)in.fFirstPartCut->Clone()),
39   fSecondPartCut((AliAODParticleCut*)in.fSecondPartCut->Clone()),
40   fCuts(new AliAODPairBaseCut*[fgkMaxCuts]),
41   fNCuts(in.fNCuts)
42 {
43   //copy constructor
44
45  
46   for (Int_t i = 0;i<fNCuts;i++)
47     {
48       fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
49     }
50 }
51 /**********************************************************/
52
53 AliAODPairCut&  AliAODPairCut::operator=(const AliAODPairCut& in)
54 {
55   //assignment operator
56   fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
57   fNCuts = in.fNCuts;
58
59   fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
60   fSecondPartCut = (AliAODParticleCut*)in.fSecondPartCut->Clone();
61  
62   for (Int_t i = 0;i<fNCuts;i++)
63     {
64       fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
65     }
66   return * this;
67 }
68 /**********************************************************/
69
70 AliAODPairCut::~AliAODPairCut()
71 {
72   //destructor
73   if (fFirstPartCut != fSecondPartCut)
74     {
75       delete fSecondPartCut;
76     }
77   delete fFirstPartCut;
78   for (Int_t i = 0;i<fNCuts;i++)
79     {
80       delete fCuts[i];
81     }
82   delete []fCuts;
83
84 /**********************************************************/
85
86 /**********************************************************/
87
88 void AliAODPairCut::AddBasePairCut(AliAODPairBaseCut* basecut)
89 {
90   //adds the base pair cut (cut on one value)
91   
92   if (!basecut) return;
93   if( fNCuts == (fgkMaxCuts-1) )
94     {
95       Warning("AddBasePairCut","Not enough place for another cut");
96       return;
97     }
98   fCuts[fNCuts++]=basecut;
99 }
100 /**********************************************************/
101
102 Bool_t AliAODPairCut::Rejected(AliAODPair* pair) const
103 {
104   //methods which checks if given pair meets all criteria of the cut
105   //if it meets returns FALSE
106   //if NOT   returns    TRUE
107   if(!pair) 
108     {
109       Warning("Pass","No Pasaran! We never accept NULL pointers");
110       return kTRUE;
111     }
112   
113   //check particle's cuts
114   if( ( fFirstPartCut->Rejected( pair->Particle1()) ) || 
115       ( fSecondPartCut->Rejected(pair->Particle2()) )   )
116     {  
117       return kTRUE;
118     }
119   return PassPairProp(pair);
120 }
121 /**********************************************************/
122
123 Bool_t AliAODPairCut::PassPairProp(AliAODPair* pair) const
124 {
125   //methods which checks if given pair meets all criteria of the cut
126   //if it meets returns FALSE
127   //if NOT   returns    TRUE
128   //examine all base pair cuts
129   for (Int_t i = 0;i<fNCuts;i++)
130     {
131       if ( (fCuts[i]->Rejected(pair)) ) return kTRUE; //if one of the cuts reject, then reject
132     }
133   return kFALSE;
134 }
135 /**********************************************************/
136
137 void AliAODPairCut::Print()
138 {
139  //Prints the cut
140   for (Int_t i = 0;i<fNCuts;i++)
141     {
142       fCuts[i]->Dump();
143     }
144 }
145 /**********************************************************/
146
147 void AliAODPairCut::SetFirstPartCut(AliAODParticleCut* cut)
148 {
149   // set cut for the first particle
150   if(!cut) 
151     {
152       Error("SetFirstPartCut","argument is NULL");
153       return;
154     }
155   delete fFirstPartCut;
156   fFirstPartCut = (AliAODParticleCut*)cut->Clone();
157   
158 }
159 /**********************************************************/
160
161 void AliAODPairCut::SetSecondPartCut(AliAODParticleCut* cut)
162 {
163   // set cut for the second particle
164   if(!cut) 
165     {
166       Error("SetSecondPartCut","argument is NULL");
167       return;
168     }
169   delete fSecondPartCut;
170   fSecondPartCut = (AliAODParticleCut*)cut->Clone();
171 }
172 /**********************************************************/
173
174 void AliAODPairCut::SetPartCut(AliAODParticleCut* cut)
175 {
176   //sets the the same cut on both particles
177   if(!cut) 
178     {
179       Error("SetFirstPartCut","argument is NULL");
180       return;
181     }
182   if (fFirstPartCut == fSecondPartCut) fSecondPartCut = 0x0;
183   
184   delete fFirstPartCut;
185   fFirstPartCut = (AliAODParticleCut*)cut->Clone();
186   
187   delete fSecondPartCut; //even if null should not be harmful
188   fSecondPartCut = fFirstPartCut;
189 }
190 /**********************************************************/
191
192 void AliAODPairCut::SetQInvRange(Double_t min, Double_t max)
193 {
194   // set range of accepted invariant masses
195   AliAODQInvCut* cut= (AliAODQInvCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQInv);
196   if(cut) cut->SetRange(min,max);
197   else fCuts[fNCuts++] = new AliAODQInvCut(min,max);
198 }
199 /**********************************************************/
200
201 void AliAODPairCut::SetQOutLCMSRange(Double_t min, Double_t max)
202 {
203   // set range of accepted QOut in CMS
204   AliAODQOutLCMSCut* cut= (AliAODQOutLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQOutLCMS);
205   if(cut) cut->SetRange(min,max);
206   else fCuts[fNCuts++] = new AliAODQOutLCMSCut(min,max);
207 }
208 /**********************************************************/
209
210 void AliAODPairCut::SetQSideLCMSRange(Double_t min, Double_t max)
211 {
212   // set range of accepted QSide in CMS
213   AliAODQSideLCMSCut* cut= (AliAODQSideLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQSideLCMS);
214   if(cut) cut->SetRange(min,max);
215   else fCuts[fNCuts++] = new AliAODQSideLCMSCut(min,max);
216 }
217
218 /**********************************************************/
219
220 void AliAODPairCut::SetQLongLCMSRange(Double_t min, Double_t max)
221 {
222   // set range of accepted QLong in CMS
223   AliAODQLongLCMSCut* cut= (AliAODQLongLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQLongLCMS);
224   if(cut) cut->SetRange(min,max);
225   else fCuts[fNCuts++] = new AliAODQLongLCMSCut(min,max);
226 }
227 /**********************************************************/
228
229 void AliAODPairCut::SetDeltaERange(Double_t min, Double_t max)
230 {
231   // set range of accepted DeltaE
232   AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropDeltaE);
233   if(cut) cut->SetRange(min,max);
234   else fCuts[fNCuts++] = new AliAODDeltaECut(min,max);
235 }
236 /**********************************************************/
237
238 void AliAODPairCut::SetDeltaPRange(Double_t min, Double_t max)
239 {
240   // set range of accepted DeltaP
241   AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropDeltaP);
242   if(cut) cut->SetRange(min,max);
243   else fCuts[fNCuts++] = new AliAODDeltaPCut(min,max);
244 }
245 /**********************************************************/
246
247 void AliAODPairCut::SetKtRange(Double_t min, Double_t max)
248 {
249   // set range of accepted Kt (avarage transverse pair momentum)
250   AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKt);
251   if(cut) cut->SetRange(min,max);
252   else fCuts[fNCuts++] = new AliAODKtCut(min,max);
253 }
254 /**********************************************************/
255
256 void AliAODPairCut::SetKStarRange(Double_t min, Double_t max)
257 {
258   // set range of accepted KStar (invariant pair momentum difference (fourvector))
259   AliAODKStarCut* cut= (AliAODKStarCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStar);
260   if(cut) cut->SetRange(min,max);
261   else fCuts[fNCuts++] = new AliAODKStarCut(min,max);
262 }
263 /**********************************************************/
264
265 void AliAODPairCut::SetKStarOutRange(Double_t min, Double_t max)
266 {
267   // set range of accepted KStar (invariant pair momentum difference (fourvector))
268   AliAODKStarOutCut* cut= (AliAODKStarOutCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarOut);
269   if(cut) cut->SetRange(min,max);
270   else fCuts[fNCuts++] = new AliAODKStarOutCut(min,max);
271 }
272 /**********************************************************/
273
274 void AliAODPairCut::SetKStarSideRange(Double_t min, Double_t max)
275 {
276   // set range of accepted KStar (invariant pair momentum difference (fourvector))
277   AliAODKStarSideCut* cut= (AliAODKStarSideCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarSide);
278   if(cut) cut->SetRange(min,max);
279   else fCuts[fNCuts++] = new AliAODKStarSideCut(min,max);
280 }
281 /**********************************************************/
282
283 void AliAODPairCut::SetKStarLongRange(Double_t min, Double_t max)
284 {
285   // set range of accepted KStar (invariant pair momentum difference (fourvector))
286   AliAODKStarLongCut* cut= (AliAODKStarLongCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarLong);
287   if(cut) cut->SetRange(min,max);
288   else fCuts[fNCuts++] = new AliAODKStarLongCut(min,max);
289 }
290 /**********************************************************/
291
292 void AliAODPairCut::SetAvSeparationRange(Double_t min, Double_t max)
293 {
294   //sets avarage separation cut ->Anti-Merging cut
295   AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropAvSepar);
296   if(cut) cut->SetRange(min,max);
297   else fCuts[fNCuts++] = new AliAODAvSeparationCut(min,max);
298 }
299 /**********************************************************/
300
301 void AliAODPairCut::SetITSSeparation(Int_t layer, Double_t drphi, Double_t dz)
302 {
303   //Anti-Merging Cut for first pixel layer
304   AliAODITSSeparationCut* cut= dynamic_cast<AliAODITSSeparationCut*>(FindCut(AliAODPairBaseCut::kHbtPairCutPropPixelSepar));
305   if(cut) 
306    {
307      if (layer == cut->GetLayer())
308       {
309         cut->SetRange(drphi,dz);//In this cut fMin is drphi, and fMax dz
310         return;
311       }
312    }
313   fCuts[fNCuts++] = new AliAODITSSeparationCut(layer,drphi,dz);
314 //  Info("SetITSSeparation","Added %d at address %#x",fNCuts-1,fCuts[fNCuts-1]);
315 }
316 /**********************************************************/
317
318 void AliAODPairCut::SetClusterOverlapRange(Double_t min,Double_t max)
319 {
320   //sets cluster overlap factor cut ->Anti-Splitting cut
321   //cluster overlap factor ranges between 
322   // -0.5 (in all padrows both tracks have cluters) 
323   // and 1 (in all padrows one track has cluter and second has not)
324   // When Overlap Factor is 1 this pair of tracks in highly probable to be
325   // splitted track: one particle that is recontructed twise
326   // STAR uses range from -0.5 to 0.6 
327   
328   AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropClOverlap);
329   if(cut) cut->SetRange(min,max);
330   else fCuts[fNCuts++] = new AliAODCluterOverlapCut(min,max);
331 }
332 /**********************************************************/
333
334 AliAODPairBaseCut* AliAODPairCut::FindCut(AliAODPairBaseCut::EAODPairCutProperty property)
335 {
336   // Find the cut corresponding to "property"
337   for (Int_t i = 0;i<fNCuts;i++)
338     {
339       if (fCuts[i]->GetProperty() == property) 
340         return fCuts[i]; //we found the cut we were searching for
341     }
342   
343   return 0x0; //we did not found this cut
344   
345 }
346 /**********************************************************/
347
348 void AliAODPairCut::Streamer(TBuffer &b)
349 {
350   // Stream all objects in the array to or from the I/O buffer.
351   
352   UInt_t R__s, R__c;
353   if (b.IsReading()) 
354     {
355       Version_t v = b.ReadVersion(&R__s, &R__c);
356       if (v > -1)
357        {
358           delete fFirstPartCut;
359           delete fSecondPartCut;
360           fFirstPartCut = 0x0;
361           fSecondPartCut = 0x0;
362           TObject::Streamer(b);
363           b >> fFirstPartCut;
364           b >> fSecondPartCut;
365           b >> fNCuts;
366           for (Int_t i = 0;i<fNCuts;i++)
367            {
368              b >> fCuts[i];
369            }
370         }
371       b.CheckByteCount(R__s, R__c,AliAODPairCut::IsA());
372     } 
373   else 
374     {
375       R__c = b.WriteVersion(AliAODPairCut::IsA(), kTRUE);
376       TObject::Streamer(b);
377       
378 //      printf("Streamer Cut 1 %#x Cut 2 %#x\n",fFirstPartCut,fSecondPartCut);
379 //      this->Dump();
380 //      fFirstPartCut->Dump();
381       
382       b << fFirstPartCut;
383       b << fSecondPartCut;
384       b << fNCuts;
385       for (Int_t i = 0;i<fNCuts;i++)
386         {
387           b << fCuts[i];
388         }
389       b.SetByteCount(R__c, kTRUE);
390     }
391 }
392 /******************************************************************/
393
394 ClassImp(AliAODPairEmptyCut)
395   
396 void AliAODPairEmptyCut::Streamer(TBuffer &b)
397 {
398 //streamer for empty pair cut
399   AliAODPairCut::Streamer(b);
400 }
401 /******************************************************************/
402