490058909a93b76aad1a52c47b2c7b038c00f5d4
[u/mrichter/AliRoot.git] / ANALYSIS / AliAODParticleCut.cxx
1 #include "AliAODParticleCut.h"
2 //__________________________________________________________________________
3 ////////////////////////////////////////////////////////////////////////////
4 //                                                                        //
5 // class AliAODParticleCut                                                //
6 //                                                                        //
7 // Classes for single particle cuts                                       //
8 // User should use only AliAODParticleCut, eventually                     //
9 // EmptyCut which passes all particles                                    //
10 // There is all interface for setting cuts on all particle properties     //
11 // The main method is Pass - which returns                                //
12 //         True to reject particle                                        //
13 //         False in case it meets all the criteria of the given cut       //
14 //                                                                        //
15 // User should create (and also destroy) cuts himself                     // 
16 // and then pass them to the Analysis And Function by a proper method     //
17 //                                                                        //
18 //                                                                        //
19 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html   //
20 // responsible: Piotr Skowronski@cern.ch                                   //
21 //                                                                        //
22 ////////////////////////////////////////////////////////////////////////////
23
24 #include <Riostream.h>
25
26
27 ClassImp(AliAODParticleCut)
28 const Int_t AliAODParticleCut::fgkMaxCuts = 50;
29 /******************************************************************/
30
31 AliAODParticleCut::AliAODParticleCut():
32  fCuts(new AliAODBaseCut* [fgkMaxCuts]),//last property in the property enum => defines number of properties
33  fNCuts(0),
34  fPID(0)
35 {
36   //default ctor
37 }
38 /******************************************************************/
39
40 AliAODParticleCut::AliAODParticleCut(const AliAODParticleCut& in):
41  TObject(in)
42 {
43   //cpy ctor
44   fCuts = new AliAODBaseCut* [fgkMaxCuts];//last property in the property
45                                          //property enum => defines number of properties
46   fNCuts = in.fNCuts;
47   fPID  = in.fPID;
48   for (Int_t i = 0;i<fNCuts;i++)
49    {
50      fCuts[i] = (AliAODBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
51    }
52 }
53 /******************************************************************/
54 AliAODParticleCut& AliAODParticleCut::operator=(const AliAODParticleCut& in)
55 {
56   //assigment operator
57   Info("operator=","operator=operator=operator=operator=\noperator=operator=operator=operator=");
58   for (Int_t i = 0;i<fNCuts;i++)
59    {
60      delete fCuts[i];
61    }
62
63   fNCuts = in.fNCuts;
64   fPID  = in.fPID;
65   for (Int_t i = 0;i<fNCuts;i++)
66    {
67      fCuts[i] = (AliAODBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
68    }
69   return *this;
70 }    
71
72 /******************************************************************/
73 AliAODParticleCut::~AliAODParticleCut()
74 {
75   //dtor
76   for (Int_t i = 0;i<fNCuts;i++)
77    {
78      delete fCuts[i];
79    }
80   delete []fCuts;
81
82 /******************************************************************/
83
84 Bool_t AliAODParticleCut::Pass(AliVAODParticle* p) const
85 {
86 //method checks all the cuts that are set (in the list)
87 //If any of the baseCuts rejects particle False(rejection) is returned
88
89  if(!p) 
90   {
91     Warning("Pass()","No Pasaran! We never accept NULL pointers");
92     return kTRUE;
93   }
94  if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE;
95  
96  for (Int_t i = 0;i<fNCuts;i++)
97    {
98     if ( (fCuts[i]->Pass(p)) )
99      {
100 //       fCuts[i]->Print();
101        return kTRUE; //if one of the cuts rejects, then reject
102      }
103    }
104   return kFALSE;
105 }
106 /******************************************************************/
107
108 void AliAODParticleCut::AddBasePartCut(AliAODBaseCut* basecut)
109 {
110   //adds the base pair cut (cut on one value)
111  
112    if (!basecut) return;
113    if( fNCuts == (fgkMaxCuts-1) )
114     {
115       Warning("AddBasePartCut","Not enough place for another cut");
116       return;
117     }
118    fCuts[fNCuts++]=basecut;
119  
120 }
121
122 /******************************************************************/
123 AliAODBaseCut* AliAODParticleCut::FindCut(AliAODCutProperty property)
124 {
125  //returns pointer to the cut checking the given property
126  for (Int_t i = 0;i<fNCuts;i++)
127   {
128     if (fCuts[i]->GetProperty() == property) 
129        return fCuts[i]; //we found the cut we were searching for
130   }
131  
132  return 0x0; //we did not found this cut
133  
134 }
135 /******************************************************************/
136
137 void AliAODParticleCut::SetMomentumRange(Double_t min, Double_t max)
138 {
139   //Sets momentum range
140   AliAODMomentumCut* cut= (AliAODMomentumCut*)FindCut(kAODP);
141   if(cut) cut->SetRange(min,max);
142   else fCuts[fNCuts++] = new AliAODMomentumCut(min,max);
143 }
144 /******************************************************************/
145
146
147 void AliAODParticleCut::SetPtRange(Double_t min, Double_t max)
148 {
149   //name self descriptive
150   AliAODPtCut* cut= (AliAODPtCut*)FindCut(kAODPt);
151   if(cut) cut->SetRange(min,max);
152   else fCuts[fNCuts++] = new AliAODPtCut(min,max);
153
154 }
155 /******************************************************************/
156
157 void AliAODParticleCut::SetEnergyRange(Double_t min, Double_t max)
158 {
159   //name self descriptive
160   AliAODEnergyCut* cut= (AliAODEnergyCut*)FindCut(kAODE);
161   if(cut) cut->SetRange(min,max);
162   else fCuts[fNCuts++] = new AliAODEnergyCut(min,max);
163  
164 }
165 /******************************************************************/
166
167 void AliAODParticleCut::SetRapidityRange(Double_t min, Double_t max)
168 {
169   //name self descriptive
170   AliAODBaseCut* cut = FindCut(kAODRapidity);
171   if(cut) cut->SetRange(min,max);
172   else fCuts[fNCuts++] = new AliAODRapidityCut(min,max);
173
174 }
175 /******************************************************************/
176
177 void AliAODParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
178 {
179   //name self descriptive
180   AliAODBaseCut* cut = FindCut(kAODPseudoRapidity);
181   if(cut) cut->SetRange(min,max);
182   else fCuts[fNCuts++] = new AliAODPseudoRapidityCut(min,max);
183  
184 }
185 /******************************************************************/
186
187 void AliAODParticleCut::SetPxRange(Double_t min, Double_t max)
188 {
189   //name self descriptive
190   AliAODBaseCut* cut = FindCut(kAODPx);
191   if(cut) cut->SetRange(min,max);
192   else fCuts[fNCuts++] = new AliAODPxCut(min,max);
193 }
194 /******************************************************************/
195
196 void AliAODParticleCut::SetPyRange(Double_t min, Double_t max)
197 {  
198   //name self descriptive
199   AliAODBaseCut* cut = FindCut(kAODPy);
200   if(cut) cut->SetRange(min,max);
201   else fCuts[fNCuts++] = new AliAODPyCut(min,max);
202 }
203 /******************************************************************/
204
205 void AliAODParticleCut::SetPzRange(Double_t min, Double_t max)
206 {
207   //name self descriptive
208   AliAODBaseCut* cut = FindCut(kAODPz);
209   if(cut) cut->SetRange(min,max);
210   else fCuts[fNCuts++] = new AliAODPzCut(min,max);
211 }
212 /******************************************************************/
213
214 void AliAODParticleCut::SetPhiRange(Double_t min, Double_t max)
215 {
216   //name self descriptive
217   AliAODBaseCut* cut = FindCut(kAODPhi);
218   if(cut) cut->SetRange(min,max);
219   else fCuts[fNCuts++] = new AliAODPhiCut(min,max);
220 }
221 /******************************************************************/
222
223 void AliAODParticleCut::SetThetaRange(Double_t min, Double_t max)
224 {
225   //name self descriptive
226   AliAODBaseCut* cut = FindCut(kAODTheta);
227   if(cut) cut->SetRange(min,max);
228   else fCuts[fNCuts++] = new AliAODThetaCut(min,max);
229 }
230 /******************************************************************/
231
232 void AliAODParticleCut::SetVxRange(Double_t min, Double_t max)
233 {
234   //name self descriptive
235   AliAODBaseCut* cut = FindCut(kAODVx);
236   if(cut) cut->SetRange(min,max);
237   else fCuts[fNCuts++] = new AliAODVxCut(min,max);
238 }
239 /******************************************************************/
240
241 void AliAODParticleCut::SetVyRange(Double_t min, Double_t max)
242 {
243   //name self descriptive
244   AliAODBaseCut* cut = FindCut(kAODVy);
245   if(cut) cut->SetRange(min,max);
246   else fCuts[fNCuts++] = new AliAODVyCut(min,max);
247 }
248 /******************************************************************/
249
250 void AliAODParticleCut::SetVzRange(Double_t min, Double_t max)
251 {
252   //name self descriptive
253   AliAODBaseCut* cut = FindCut(kAODVz);
254   if(cut) cut->SetRange(min,max);
255   else fCuts[fNCuts++] = new AliAODVzCut(min,max);
256 }
257
258 /******************************************************************/
259 void AliAODParticleCut::Streamer(TBuffer &b)
260 {
261   // Stream all objects in the array to or from the I/O buffer.
262
263    UInt_t R__s, R__c;
264    if (b.IsReading()) 
265     {
266       Int_t i;
267       for (i = 0;i<fNCuts;i++) delete fCuts[i];
268       b.ReadVersion(&R__s, &R__c);
269       TObject::Streamer(b);
270       b >> fPID;
271       b >> fNCuts;
272       for (i = 0;i<fNCuts;i++) 
273        {
274          b >> fCuts[i];
275        }
276        b.CheckByteCount(R__s, R__c,AliAODParticleCut::IsA());
277     } 
278    else 
279     {
280      R__c = b.WriteVersion(AliAODParticleCut::IsA(), kTRUE);
281      TObject::Streamer(b);
282      b << fPID;
283      b << fNCuts;
284      for (Int_t i = 0;i<fNCuts;i++)
285       {
286        b << fCuts[i];
287       }
288      b.SetByteCount(R__c, kTRUE);
289    }
290 }
291 /******************************************************************/
292
293 void AliAODParticleCut::Print(void) const
294 {
295   //prints all information about the cut to stdout
296   cout<<"Printing AliAODParticleCut, this = "<<this<<endl;
297   cout<<"fPID  "<<fPID<<endl;
298   cout<<"fNCuts  "<<fNCuts <<endl;
299   for (Int_t i = 0;i<fNCuts;i++)
300       {
301        cout<<"  fCuts["<<i<<"]  "<<fCuts[i]<<endl<<"   ";
302        fCuts[i]->Print();
303       }
304 }
305
306 /******************************************************************/
307 /******************************************************************/
308
309 ClassImp(AliAODEmptyParticleCut)
310 void AliAODEmptyParticleCut::Streamer(TBuffer &b)
311  {
312   //stramer
313   AliAODParticleCut::Streamer(b);
314  }
315 /******************************************************************/
316 /******************************************************************/
317 /******************************************************************/
318
319 /******************************************************************/
320 /******************************************************************/
321 /******************************************************************/
322
323 ClassImp(AliAODBaseCut)
324 void AliAODBaseCut::Print(void) const
325 {
326   // prints the information anout the base cut to stdout
327   cout<<"fMin="<<fMin <<", fMax=" <<fMax<<"    ";
328   PrintProperty();
329 }
330 /******************************************************************/
331
332 void AliAODBaseCut::PrintProperty(void) const
333 {
334  //prints the property name 
335  switch (fProperty)
336   {
337    case  kAODP: 
338      cout<<"kAODP"; break;
339    case  kAODPt: 
340      cout<<"kAODPt"; break;
341    case  kAODE: 
342      cout<<"kAODE"; break;
343    case  kAODRapidity: 
344      cout<<"kAODRapidity"; break;
345    case  kAODPseudoRapidity: 
346      cout<<"kAODPseudoRapidity"; break;
347    case  kAODPx: 
348      cout<<"kAODPx"; break;
349    case  kAODPy: 
350      cout<<"kAODPy"; break;
351    case  kAODPz: 
352      cout<<"kAODPz"; break;   
353    case  kAODPhi: 
354      cout<<"kAODPhi"; break;
355    case  kAODTheta: 
356      cout<<"kAODTheta"; break;
357    case  kAODVx: 
358      cout<<"kAODVx"; break;
359    case  kAODVy: 
360      cout<<"kAODVy"; break;
361    case  kAODVz: 
362      cout<<"kAODVz"; break;
363    case  kAODPid: 
364      cout<<"kAODPid"; break;
365    case  kAODNone: 
366      cout<<"kAODNone"; break;
367    default: 
368      cout<<"Property Not Found";
369   }
370  cout<<endl;
371 }
372 ClassImp( AliAODMomentumCut )
373
374 ClassImp( AliAODPtCut )
375 ClassImp( AliAODEnergyCut )
376 ClassImp( AliAODRapidityCut )
377 ClassImp( AliAODPseudoRapidityCut )
378 ClassImp( AliAODPxCut )
379 ClassImp( AliAODPyCut )
380 ClassImp( AliAODPzCut )
381 ClassImp( AliAODPhiCut )
382 ClassImp( AliAODThetaCut )
383 ClassImp( AliAODVxCut )
384 ClassImp( AliAODVyCut )
385 ClassImp( AliAODVzCut )
386
387 ClassImp( AliAODPIDCut )
388
389 void AliAODPIDCut::Print(void) const
390 {
391   cout<<"PID "<<fPID<<" ";
392   AliAODBaseCut::Print();
393 }
394
395 ClassImp( AliAODLogicalOperCut )
396
397 AliAODLogicalOperCut::AliAODLogicalOperCut():
398  AliAODBaseCut(-10e10,10e10,kAODNone),
399  fFirst(new AliAODDummyBaseCut),
400  fSecond(new AliAODDummyBaseCut)
401 {
402  //ctor
403 }
404 /******************************************************************/
405
406 AliAODLogicalOperCut::AliAODLogicalOperCut(AliAODBaseCut* first, AliAODBaseCut* second):
407  AliAODBaseCut(-10e10,10e10,kAODNone),
408  fFirst((first)?(AliAODBaseCut*)first->Clone():0x0),
409  fSecond((second)?(AliAODBaseCut*)second->Clone():0x0)
410 {
411   //ctor
412   if ( (fFirst && fSecond) == kFALSE) 
413    {
414      Fatal("AliAODLogicalOperCut","One of parameters is NULL!");
415    }
416 }
417 /******************************************************************/
418
419 AliAODLogicalOperCut::~AliAODLogicalOperCut()
420 {
421   //destructor
422   delete fFirst;
423   delete fSecond;
424 }
425 /******************************************************************/
426
427 Bool_t AliAODLogicalOperCut::AliAODDummyBaseCut::Pass(AliVAODParticle* /*part*/)  const
428 {
429   //checks if particles passes properties defined by this cut
430   Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
431   return kFALSE;//accept
432 }
433 /******************************************************************/
434
435 void AliAODLogicalOperCut::Streamer(TBuffer &b)
436 {
437   // Stream all objects in the array to or from the I/O buffer.
438   UInt_t R__s, R__c;
439   if (b.IsReading()) 
440    {
441      delete fFirst;
442      delete fSecond;
443      fFirst  = 0x0;
444      fSecond = 0x0;
445
446      b.ReadVersion(&R__s, &R__c);
447      TObject::Streamer(b);
448      b >> fFirst;
449      b >> fSecond;
450      b.CheckByteCount(R__s, R__c,AliAODLogicalOperCut::IsA());
451    } 
452   else 
453    {
454      R__c = b.WriteVersion(AliAODLogicalOperCut::IsA(), kTRUE);
455      TObject::Streamer(b);
456      b << fFirst;
457      b << fSecond;
458      b.SetByteCount(R__c, kTRUE);
459   }
460 }
461
462 /******************************************************************/
463 ClassImp(AliAODOrCut)
464
465 Bool_t AliAODOrCut::Pass(AliVAODParticle * p) const
466 {
467   //returns true when rejected 
468   //AND operation is a little bit misleading but is correct
469   //User wants to build logical cuts with natural (positive) logic
470   //while AODAN use inernally reverse (returns true when rejected)
471   if (fFirst->Pass(p) && fSecond->Pass(p)) return kTRUE;//rejected (both rejected, returned kTRUE)
472   return kFALSE;//accepted, at least one accepted (returned kFALSE)
473 }
474 /******************************************************************/
475
476 ClassImp(AliAODAndCut)
477
478 Bool_t AliAODAndCut::Pass(AliVAODParticle * p)  const
479 {
480   //returns true when rejected 
481   //OR operation is a little bit misleading but is correct
482   //User wants to build logical cuts with natural (positive) logic
483   //while AODAN use inernally reverse (returns true when rejected)
484   if (fFirst->Pass(p) || fSecond->Pass(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
485   return kFALSE;//accepted (both accepted (returned kFALSE))
486 }
487 /******************************************************************/