db244e37c5f0b8942192e0f0d259ba1127e3e7de
[u/mrichter/AliRoot.git] / HBTAN / AliHBTParticleCut.cxx
1 #include "AliHBTParticleCut.h"
2
3 #include <Riostream.h>
4
5 ClassImp(AliHBTParticleCut)
6 const Int_t AliHBTParticleCut::fkgMaxCuts = 50;
7 /******************************************************************/
8
9 AliHBTParticleCut::AliHBTParticleCut()
10  {
11    fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property
12                                          //property enum => defines number of properties
13    fNCuts = 0;
14    fPID  = 0;
15  }
16 /******************************************************************/
17
18 AliHBTParticleCut::AliHBTParticleCut(const AliHBTParticleCut& in)
19 {
20   fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property
21                                          //property enum => defines number of properties
22   fNCuts = in.fNCuts;
23   fPID  = in.fPID;
24   for (Int_t i = 0;i<fNCuts;i++)
25    {
26      fCuts[i] = (AliHbtBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
27    }
28 }
29 /******************************************************************/
30
31 AliHBTParticleCut::~AliHBTParticleCut()
32 {
33   for (Int_t i = 0;i<fNCuts;i++)
34    {
35      delete fCuts[i];
36    }
37   delete []fCuts;
38
39 /******************************************************************/
40
41 Bool_t AliHBTParticleCut::Pass(AliHBTParticle* p)
42 {
43 //method checks all the cuts that are set (in the list)
44 //If any of the baseCuts rejects particle False(rejection) is returned
45  if(!p) 
46   {
47     Warning("Pass()","No Pasaran! We never accept NULL pointers");
48     return kTRUE;
49   }
50  if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE;
51  
52  for (Int_t i = 0;i<fNCuts;i++)
53    {
54     if ( (fCuts[i]->Pass(p)) ) return kTRUE; //if one of the cuts rejects, then reject
55    }
56   return kFALSE;
57 }
58 /******************************************************************/
59
60 void AliHBTParticleCut::AddBasePartCut(AliHbtBaseCut* basecut)
61 {
62   //adds the base pair cut (cut on one value)
63  
64    if (!basecut) return;
65    if( fNCuts == (fkgMaxCuts-1) )
66     {
67       Warning("AddBasePartCut","Not enough place for another cut");
68       return;
69     }
70    fCuts[fNCuts++]=basecut;
71  
72 }
73
74 /******************************************************************/
75 AliHbtBaseCut* AliHBTParticleCut::FindCut(AliHBTCutProperty property)
76 {
77  
78  for (Int_t i = 0;i<fNCuts;i++)
79   {
80     if (fCuts[i]->GetProperty() == property) 
81        return fCuts[i]; //we found the cut we were searching for
82   }
83  
84  return 0x0; //we did not found this cut
85  
86 }
87 /******************************************************************/
88
89 void AliHBTParticleCut::SetMomentumRange(Double_t min, Double_t max)
90 {
91   AliHBTMomentumCut* cut= (AliHBTMomentumCut*)FindCut(kHbtP);
92   if(cut) cut->SetRange(min,max);
93   else fCuts[fNCuts++] = new AliHBTMomentumCut(min,max);
94 }
95 /******************************************************************/
96
97
98 void AliHBTParticleCut::SetPtRange(Double_t min, Double_t max)
99 {
100   AliHBTPtCut* cut= (AliHBTPtCut*)FindCut(kHbtPt);
101   if(cut) cut->SetRange(min,max);
102   else fCuts[fNCuts++] = new AliHBTPtCut(min,max);
103
104 }
105 /******************************************************************/
106
107 void AliHBTParticleCut::SetEnergyRange(Double_t min, Double_t max)
108 {
109   AliHBTEnergyCut* cut= (AliHBTEnergyCut*)FindCut(kHbtE);
110   if(cut) cut->SetRange(min,max);
111   else fCuts[fNCuts++] = new AliHBTEnergyCut(min,max);
112  
113 }
114 /******************************************************************/
115
116 void AliHBTParticleCut::SetRapidityRange(Double_t min, Double_t max)
117 {
118   AliHbtBaseCut* cut = FindCut(kHbtRapidity);
119   if(cut) cut->SetRange(min,max);
120   else fCuts[fNCuts++] = new AliHBTRapidityCut(min,max);
121
122 }
123 /******************************************************************/
124
125 void AliHBTParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
126 {
127   AliHbtBaseCut* cut = FindCut(kHbtPseudoRapidity);
128   if(cut) cut->SetRange(min,max);
129   else fCuts[fNCuts++] = new AliHBTPseudoRapidityCut(min,max);
130  
131 }
132 /******************************************************************/
133
134 void AliHBTParticleCut::SetPxRange(Double_t min, Double_t max)
135 {
136   AliHbtBaseCut* cut = FindCut(kHbtPx);
137   if(cut) cut->SetRange(min,max);
138   else fCuts[fNCuts++] = new AliHBTPxCut(min,max);
139 }
140 /******************************************************************/
141
142 void AliHBTParticleCut::SetPyRange(Double_t min, Double_t max)
143 {  
144   AliHbtBaseCut* cut = FindCut(kHbtPy);
145   if(cut) cut->SetRange(min,max);
146   else fCuts[fNCuts++] = new AliHBTPyCut(min,max);
147 }
148 /******************************************************************/
149
150 void AliHBTParticleCut::SetPzRange(Double_t min, Double_t max)
151 {
152   AliHbtBaseCut* cut = FindCut(kHbtPz);
153   if(cut) cut->SetRange(min,max);
154   else fCuts[fNCuts++] = new AliHBTPzCut(min,max);
155 }
156 /******************************************************************/
157
158 void AliHBTParticleCut::SetPhiRange(Double_t min, Double_t max)
159 {
160   AliHbtBaseCut* cut = FindCut(kHbtPhi);
161   if(cut) cut->SetRange(min,max);
162   else fCuts[fNCuts++] = new AliHBTPhiCut(min,max);
163 }
164 /******************************************************************/
165
166 void AliHBTParticleCut::SetThetaRange(Double_t min, Double_t max)
167 {
168   AliHbtBaseCut* cut = FindCut(kHbtTheta);
169   if(cut) cut->SetRange(min,max);
170   else fCuts[fNCuts++] = new AliHBTThetaCut(min,max);
171 }
172 /******************************************************************/
173
174 void AliHBTParticleCut::SetVxRange(Double_t min, Double_t max)
175 {
176   AliHbtBaseCut* cut = FindCut(kHbtVx);
177   if(cut) cut->SetRange(min,max);
178   else fCuts[fNCuts++] = new AliHBTVxCut(min,max);
179 }
180 /******************************************************************/
181
182 void AliHBTParticleCut::SetVyRange(Double_t min, Double_t max)
183 {
184   AliHbtBaseCut* cut = FindCut(kHbtVy);
185   if(cut) cut->SetRange(min,max);
186   else fCuts[fNCuts++] = new AliHBTVyCut(min,max);
187 }
188 /******************************************************************/
189
190 void AliHBTParticleCut::SetVzRange(Double_t min, Double_t max)
191 {
192   AliHbtBaseCut* cut = FindCut(kHbtVz);
193   if(cut) cut->SetRange(min,max);
194   else fCuts[fNCuts++] = new AliHBTVzCut(min,max);
195 }
196
197 /******************************************************************/
198 void AliHBTParticleCut::Streamer(TBuffer &b)
199 {
200      // Stream all objects in the array to or from the I/O buffer.
201
202    UInt_t R__s, R__c;
203    if (b.IsReading()) 
204     {
205       /* Version_t v = */ b.ReadVersion(&R__s, &R__c);
206       TObject::Streamer(b);
207       b >> fPID;
208       b >> fNCuts;
209       for (Int_t i = 0;i<fNCuts;i++)
210        {
211         b >> fCuts[i];
212        }
213        b.CheckByteCount(R__s, R__c,AliHBTParticleCut::IsA());
214     } 
215    else 
216     {
217      R__c = b.WriteVersion(AliHBTParticleCut::IsA(), kTRUE);
218      TObject::Streamer(b);
219      b << fPID;
220      b << fNCuts;
221      for (Int_t i = 0;i<fNCuts;i++)
222       {
223        b << fCuts[i];
224       }
225      b.SetByteCount(R__c, kTRUE);
226    }
227 }
228
229 void AliHBTParticleCut::Print(void)
230 {
231   cout<<"Printing AliHBTParticleCut, this = "<<this<<endl;
232   cout<<"fPID  "<<fPID<<endl;
233   cout<<"fNCuts  "<<fNCuts <<endl;
234   for (Int_t i = 0;i<fNCuts;i++)
235       {
236        cout<<"  fCuts["<<i<<"]  "<<fCuts[i]<<endl<<"   ";
237        fCuts[i]->Print();
238       }
239 }
240
241 /******************************************************************/
242 /******************************************************************/
243
244 ClassImp(AliHBTEmptyParticleCut)
245 void AliHBTEmptyParticleCut::Streamer(TBuffer &b)
246  {
247   AliHBTParticleCut::Streamer(b);
248  }
249 /******************************************************************/
250 /******************************************************************/
251 /******************************************************************/
252
253 /******************************************************************/
254 /******************************************************************/
255 /******************************************************************/
256
257 ClassImp(AliHbtBaseCut)
258 void AliHbtBaseCut::Print(void)
259 {
260   cout<<"fMin="<<fMin <<", fMax=" <<fMax<<"    ";
261   PrintProperty();
262 }
263 void AliHbtBaseCut::PrintProperty(void)
264 {
265  switch (fProperty)
266   {
267    case  kHbtP: 
268      cout<<"kHbtP"; break;
269    case  kHbtPt: 
270      cout<<"kHbtPt"; break;
271    case  kHbtE: 
272      cout<<"kHbtE"; break;
273    case  kHbtRapidity: 
274      cout<<"kHbtRapidity"; break;
275    case  kHbtPseudoRapidity: 
276      cout<<"kHbtPseudoRapidity"; break;
277    case  kHbtPx: 
278      cout<<"kHbtPx"; break;
279    case  kHbtPy: 
280      cout<<"kHbtPy"; break;
281    case  kHbtPz: 
282      cout<<"kHbtPz"; break;   
283    case  kHbtPhi: 
284      cout<<"kHbtPhi"; break;
285    case  kHbtTheta: 
286      cout<<"kHbtTheta"; break;
287    case  kHbtVx: 
288      cout<<"kHbtVx"; break;
289    case  kHbtVy: 
290      cout<<"kHbtVy"; break;
291    case  kHbtVz: 
292      cout<<"kHbtVz"; break;
293    case  kHbtNone: 
294      cout<<"kHbtNone"; break;
295    default: 
296      cout<<"Property Not Found";
297   }
298  cout<<endl;
299 }
300 ClassImp( AliHBTMomentumCut )
301
302 ClassImp( AliHBTPtCut )
303 ClassImp( AliHBTEnergyCut )
304 ClassImp( AliHBTRapidityCut )
305 ClassImp( AliHBTPseudoRapidityCut )
306 ClassImp( AliHBTPxCut )
307 ClassImp( AliHBTPyCut )
308 ClassImp( AliHBTPzCut )
309 ClassImp( AliHBTPhiCut )
310 ClassImp( AliHBTThetaCut )
311 ClassImp( AliHBTVxCut )
312 ClassImp( AliHBTVyCut )
313 ClassImp( AliHBTVzCut )
314
315