Corrected sintax of the commands in ProcessLine (Yves)
[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 mainly AliAODParticleCut interface methods,            //
9 // eventually EmptyCut which passes all particles.                        //
10 //                                                                        //
11 // There is all interface for setting cuts on all particle properties     //
12 // The main method is Rejected - which returns                            //
13 //         True to reject particle                                        //
14 //         False in case it meets all the criteria of the given cut       //
15 //                                                                        //
16 // This class has the list of base particle  cuts that perform check on   //
17 // single property. Particle  is rejected if any of cuts rejects it.      //
18 // There are implemented logical base cuts that perform logical           //
19 // operations on results of two other base cuts. Using them user can      //
20 // create a tree structure of a base cuts that performs sophisticated     //
21 // cut.                                                                   //
22 //                                                                        //
23 // User can also implement a base cut that performs complicated           //
24 // calculations, if it is only more convenient and/or efficint.           //
25 //                                                                        //
26 // User should delete created cuts  himself                               //
27 // because when setting a cut, other objects (functions,analyses,         //
28 // readers, other cuts) make their own copy of a cut.                     //
29 //                                                                        //
30 // more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html    //
31 // responsible: Piotr Skowronski@cern.ch                                  //
32 //                                                                        //
33 ////////////////////////////////////////////////////////////////////////////
34
35 #include <Riostream.h>
36
37
38 ClassImp(AliAODParticleCut)
39 const Int_t AliAODParticleCut::fgkMaxCuts = 50;
40 /******************************************************************/
41
42 AliAODParticleCut::AliAODParticleCut():
43  fCuts(new AliAODParticleBaseCut* [fgkMaxCuts]),//last property in the property enum => defines number of properties
44  fNCuts(0),
45  fPID(0)
46 {
47   //default ctor
48 }
49 /******************************************************************/
50
51 AliAODParticleCut::AliAODParticleCut(const AliAODParticleCut& in):
52   TObject(in),
53   fCuts(new AliAODParticleBaseCut* [fgkMaxCuts]),//last property in the property
54                                                  //property enum => defines number of properties
55   fNCuts(in.fNCuts),
56   fPID(in.fPID)
57 {
58   //cpy ctor
59   for (Int_t i = 0;i<fNCuts;i++)
60    {
61      fCuts[i] = (AliAODParticleBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
62    }
63 }
64 /******************************************************************/
65 AliAODParticleCut& AliAODParticleCut::operator=(const AliAODParticleCut& in)
66 {
67   //assigment operator
68   Info("operator=","operator=operator=operator=operator=\noperator=operator=operator=operator=");
69   for (Int_t i = 0;i<fNCuts;i++)
70    {
71      delete fCuts[i];
72    }
73
74   fNCuts = in.fNCuts;
75   fPID  = in.fPID;
76   for (Int_t i = 0;i<fNCuts;i++)
77    {
78      fCuts[i] = (AliAODParticleBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
79    }
80   return *this;
81 }    
82
83 /******************************************************************/
84 AliAODParticleCut::~AliAODParticleCut()
85 {
86   //dtor
87   for (Int_t i = 0;i<fNCuts;i++)
88    {
89      delete fCuts[i];
90    }
91   delete []fCuts;
92
93 /******************************************************************/
94
95 Bool_t AliAODParticleCut::Rejected(AliVAODParticle* p) const
96 {
97 //method checks all the cuts that are set (in the list)
98 //If any of the baseCuts rejects particle False(rejection) is returned
99
100  if(!p) 
101   {
102     Warning("Rejected()","No Pasaran! We never accept NULL pointers");
103     return kTRUE;
104   }
105  if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE;
106  
107  for (Int_t i = 0;i<fNCuts;i++)
108    {
109     if ( (fCuts[i]->Rejected(p)) )
110      {
111 //       fCuts[i]->Print();
112        return kTRUE; //if one of the cuts rejects, then reject
113      }
114    }
115   return kFALSE;
116 }
117 /******************************************************************/
118
119 void AliAODParticleCut::AddBasePartCut(AliAODParticleBaseCut* basecut)
120 {
121   //adds the base pair cut (cut on one value)
122  
123    if (!basecut) return;
124    if( fNCuts == (fgkMaxCuts-1) )
125     {
126       Warning("AddBasePartCut","Not enough place for another cut");
127       return;
128     }
129    fCuts[fNCuts++]=basecut;
130  
131 }
132
133 /******************************************************************/
134 AliAODParticleBaseCut* AliAODParticleCut::FindCut(AliAODParticleBaseCut::EAODCutProperty property)
135 {
136  //returns pointer to the cut checking the given property
137  for (Int_t i = 0;i<fNCuts;i++)
138   {
139     if (fCuts[i]->GetProperty() == property) 
140        return fCuts[i]; //we found the cut we were searching for
141   }
142  
143  return 0x0; //we did not found this cut
144  
145 }
146 /******************************************************************/
147
148 void AliAODParticleCut::SetMomentumRange(Double_t min, Double_t max)
149 {
150   //Sets momentum range
151   AliAODMomentumCut* cut= (AliAODMomentumCut*)FindCut(AliAODParticleBaseCut::kAODP);
152   if(cut) cut->SetRange(min,max);
153   else fCuts[fNCuts++] = new AliAODMomentumCut(min,max);
154 }
155 /******************************************************************/
156
157
158 void AliAODParticleCut::SetPtRange(Double_t min, Double_t max)
159 {
160   //name self descriptive
161   AliAODPtCut* cut= (AliAODPtCut*)FindCut(AliAODParticleBaseCut::kAODPt);
162   if(cut) cut->SetRange(min,max);
163   else fCuts[fNCuts++] = new AliAODPtCut(min,max);
164
165 }
166 /******************************************************************/
167
168 void AliAODParticleCut::SetEnergyRange(Double_t min, Double_t max)
169 {
170   //name self descriptive
171   AliAODEnergyCut* cut= (AliAODEnergyCut*)FindCut(AliAODParticleBaseCut::kAODE);
172   if(cut) cut->SetRange(min,max);
173   else fCuts[fNCuts++] = new AliAODEnergyCut(min,max);
174  
175 }
176 /******************************************************************/
177
178 void AliAODParticleCut::SetRapidityRange(Double_t min, Double_t max)
179 {
180   //name self descriptive
181   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODRapidity);
182   if(cut) cut->SetRange(min,max);
183   else fCuts[fNCuts++] = new AliAODRapidityCut(min,max);
184
185 }
186 /******************************************************************/
187
188 void AliAODParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
189 {
190   //name self descriptive
191   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPseudoRapidity);
192   if(cut) cut->SetRange(min,max);
193   else fCuts[fNCuts++] = new AliAODPseudoRapidityCut(min,max);
194  
195 }
196 /******************************************************************/
197
198 void AliAODParticleCut::SetPxRange(Double_t min, Double_t max)
199 {
200   //name self descriptive
201   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPx);
202   if(cut) cut->SetRange(min,max);
203   else fCuts[fNCuts++] = new AliAODPxCut(min,max);
204 }
205 /******************************************************************/
206
207 void AliAODParticleCut::SetPyRange(Double_t min, Double_t max)
208 {  
209   //name self descriptive
210   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPy);
211   if(cut) cut->SetRange(min,max);
212   else fCuts[fNCuts++] = new AliAODPyCut(min,max);
213 }
214 /******************************************************************/
215
216 void AliAODParticleCut::SetPzRange(Double_t min, Double_t max)
217 {
218   //name self descriptive
219   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPz);
220   if(cut) cut->SetRange(min,max);
221   else fCuts[fNCuts++] = new AliAODPzCut(min,max);
222 }
223 /******************************************************************/
224
225 void AliAODParticleCut::SetPhiRange(Double_t min, Double_t max)
226 {
227   //name self descriptive
228   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODPhi);
229   if(cut) cut->SetRange(min,max);
230   else fCuts[fNCuts++] = new AliAODPhiCut(min,max);
231 }
232 /******************************************************************/
233
234 void AliAODParticleCut::SetThetaRange(Double_t min, Double_t max)
235 {
236   //name self descriptive
237   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODTheta);
238   if(cut) cut->SetRange(min,max);
239   else fCuts[fNCuts++] = new AliAODThetaCut(min,max);
240 }
241 /******************************************************************/
242
243 void AliAODParticleCut::SetVxRange(Double_t min, Double_t max)
244 {
245   //name self descriptive
246   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODVx);
247   if(cut) cut->SetRange(min,max);
248   else fCuts[fNCuts++] = new AliAODVxCut(min,max);
249 }
250 /******************************************************************/
251
252 void AliAODParticleCut::SetVyRange(Double_t min, Double_t max)
253 {
254   //name self descriptive
255   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODVy);
256   if(cut) cut->SetRange(min,max);
257   else fCuts[fNCuts++] = new AliAODVyCut(min,max);
258 }
259 /******************************************************************/
260
261 void AliAODParticleCut::SetVzRange(Double_t min, Double_t max)
262 {
263   //name self descriptive
264   AliAODParticleBaseCut* cut = FindCut(AliAODParticleBaseCut::kAODVz);
265   if(cut) cut->SetRange(min,max);
266   else fCuts[fNCuts++] = new AliAODVzCut(min,max);
267 }
268
269 /******************************************************************/
270 void AliAODParticleCut::Streamer(TBuffer &b)
271 {
272   // Stream all objects in the array to or from the I/O buffer.
273
274    UInt_t R__s, R__c;
275    if (b.IsReading()) 
276     {
277       Int_t i;
278       for (i = 0;i<fNCuts;i++) delete fCuts[i];
279       b.ReadVersion(&R__s, &R__c);
280       TObject::Streamer(b);
281       b >> fPID;
282       b >> fNCuts;
283       for (i = 0;i<fNCuts;i++) 
284        {
285          b >> fCuts[i];
286        }
287        b.CheckByteCount(R__s, R__c,AliAODParticleCut::IsA());
288     } 
289    else 
290     {
291      R__c = b.WriteVersion(AliAODParticleCut::IsA(), kTRUE);
292      TObject::Streamer(b);
293      b << fPID;
294      b << fNCuts;
295      for (Int_t i = 0;i<fNCuts;i++)
296       {
297        b << fCuts[i];
298       }
299      b.SetByteCount(R__c, kTRUE);
300    }
301 }
302 /******************************************************************/
303
304 void AliAODParticleCut::Print(const Option_t * /*opt*/) const
305 {
306   //prints all information about the cut to stdout
307   cout<<"Printing AliAODParticleCut, this = "<<this<<endl;
308   cout<<"fPID  "<<fPID<<endl;
309   cout<<"fNCuts  "<<fNCuts <<endl;
310   for (Int_t i = 0;i<fNCuts;i++)
311       {
312        cout<<"  fCuts["<<i<<"]  "<<fCuts[i]<<endl<<"   ";
313        fCuts[i]->Print();
314       }
315 }
316
317 /******************************************************************/
318 /******************************************************************/
319 ClassImp(AliAODParticleEmptyCut)
320
321 void AliAODParticleEmptyCut::Streamer(TBuffer &b)
322  {
323   //stramer
324   AliAODParticleCut::Streamer(b);
325  }
326 /******************************************************************/
327 /******************************************************************/
328 /******************************************************************/