]>
Commit | Line | Data |
---|---|---|
1b446896 | 1 | #include "AliHBTParticleCut.h" |
2 | ||
d0c23b58 | 3 | #include <Riostream.h> |
1b446896 | 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 | ||
bed069a4 | 18 | AliHBTParticleCut::AliHBTParticleCut(const AliHBTParticleCut& in): |
19 | TObject() | |
1b446896 | 20 | { |
21 | fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property | |
22 | //property enum => defines number of properties | |
23 | fNCuts = in.fNCuts; | |
24 | fPID = in.fPID; | |
25 | for (Int_t i = 0;i<fNCuts;i++) | |
26 | { | |
27 | fCuts[i] = (AliHbtBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it | |
28 | } | |
29 | } | |
30 | /******************************************************************/ | |
31 | ||
32 | AliHBTParticleCut::~AliHBTParticleCut() | |
33 | { | |
34 | for (Int_t i = 0;i<fNCuts;i++) | |
35 | { | |
36 | delete fCuts[i]; | |
37 | } | |
38 | delete []fCuts; | |
39 | } | |
40 | /******************************************************************/ | |
41 | ||
42 | Bool_t AliHBTParticleCut::Pass(AliHBTParticle* p) | |
43 | { | |
44 | //method checks all the cuts that are set (in the list) | |
45 | //If any of the baseCuts rejects particle False(rejection) is returned | |
46 | if(!p) | |
47 | { | |
48 | Warning("Pass()","No Pasaran! We never accept NULL pointers"); | |
49 | return kTRUE; | |
50 | } | |
51 | if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE; | |
52 | ||
53 | for (Int_t i = 0;i<fNCuts;i++) | |
54 | { | |
55 | if ( (fCuts[i]->Pass(p)) ) return kTRUE; //if one of the cuts rejects, then reject | |
56 | } | |
57 | return kFALSE; | |
58 | } | |
59 | /******************************************************************/ | |
60 | ||
61 | void AliHBTParticleCut::AddBasePartCut(AliHbtBaseCut* basecut) | |
62 | { | |
63 | //adds the base pair cut (cut on one value) | |
64 | ||
65 | if (!basecut) return; | |
66 | if( fNCuts == (fkgMaxCuts-1) ) | |
67 | { | |
68 | Warning("AddBasePartCut","Not enough place for another cut"); | |
69 | return; | |
70 | } | |
71 | fCuts[fNCuts++]=basecut; | |
72 | ||
73 | } | |
74 | ||
75 | /******************************************************************/ | |
76 | AliHbtBaseCut* AliHBTParticleCut::FindCut(AliHBTCutProperty property) | |
77 | { | |
78 | ||
79 | for (Int_t i = 0;i<fNCuts;i++) | |
80 | { | |
81 | if (fCuts[i]->GetProperty() == property) | |
82 | return fCuts[i]; //we found the cut we were searching for | |
83 | } | |
84 | ||
85 | return 0x0; //we did not found this cut | |
86 | ||
87 | } | |
88 | /******************************************************************/ | |
89 | ||
90 | void AliHBTParticleCut::SetMomentumRange(Double_t min, Double_t max) | |
91 | { | |
92 | AliHBTMomentumCut* cut= (AliHBTMomentumCut*)FindCut(kHbtP); | |
93 | if(cut) cut->SetRange(min,max); | |
94 | else fCuts[fNCuts++] = new AliHBTMomentumCut(min,max); | |
95 | } | |
96 | /******************************************************************/ | |
97 | ||
98 | ||
99 | void AliHBTParticleCut::SetPtRange(Double_t min, Double_t max) | |
100 | { | |
101 | AliHBTPtCut* cut= (AliHBTPtCut*)FindCut(kHbtPt); | |
102 | if(cut) cut->SetRange(min,max); | |
103 | else fCuts[fNCuts++] = new AliHBTPtCut(min,max); | |
104 | ||
105 | } | |
106 | /******************************************************************/ | |
107 | ||
108 | void AliHBTParticleCut::SetEnergyRange(Double_t min, Double_t max) | |
109 | { | |
110 | AliHBTEnergyCut* cut= (AliHBTEnergyCut*)FindCut(kHbtE); | |
111 | if(cut) cut->SetRange(min,max); | |
112 | else fCuts[fNCuts++] = new AliHBTEnergyCut(min,max); | |
113 | ||
114 | } | |
115 | /******************************************************************/ | |
116 | ||
117 | void AliHBTParticleCut::SetRapidityRange(Double_t min, Double_t max) | |
118 | { | |
119 | AliHbtBaseCut* cut = FindCut(kHbtRapidity); | |
120 | if(cut) cut->SetRange(min,max); | |
121 | else fCuts[fNCuts++] = new AliHBTRapidityCut(min,max); | |
122 | ||
123 | } | |
124 | /******************************************************************/ | |
125 | ||
126 | void AliHBTParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max) | |
127 | { | |
128 | AliHbtBaseCut* cut = FindCut(kHbtPseudoRapidity); | |
129 | if(cut) cut->SetRange(min,max); | |
130 | else fCuts[fNCuts++] = new AliHBTPseudoRapidityCut(min,max); | |
131 | ||
132 | } | |
133 | /******************************************************************/ | |
134 | ||
135 | void AliHBTParticleCut::SetPxRange(Double_t min, Double_t max) | |
136 | { | |
137 | AliHbtBaseCut* cut = FindCut(kHbtPx); | |
138 | if(cut) cut->SetRange(min,max); | |
139 | else fCuts[fNCuts++] = new AliHBTPxCut(min,max); | |
140 | } | |
141 | /******************************************************************/ | |
142 | ||
143 | void AliHBTParticleCut::SetPyRange(Double_t min, Double_t max) | |
144 | { | |
145 | AliHbtBaseCut* cut = FindCut(kHbtPy); | |
146 | if(cut) cut->SetRange(min,max); | |
147 | else fCuts[fNCuts++] = new AliHBTPyCut(min,max); | |
148 | } | |
149 | /******************************************************************/ | |
150 | ||
151 | void AliHBTParticleCut::SetPzRange(Double_t min, Double_t max) | |
152 | { | |
153 | AliHbtBaseCut* cut = FindCut(kHbtPz); | |
154 | if(cut) cut->SetRange(min,max); | |
155 | else fCuts[fNCuts++] = new AliHBTPzCut(min,max); | |
156 | } | |
157 | /******************************************************************/ | |
158 | ||
159 | void AliHBTParticleCut::SetPhiRange(Double_t min, Double_t max) | |
160 | { | |
161 | AliHbtBaseCut* cut = FindCut(kHbtPhi); | |
162 | if(cut) cut->SetRange(min,max); | |
163 | else fCuts[fNCuts++] = new AliHBTPhiCut(min,max); | |
164 | } | |
165 | /******************************************************************/ | |
166 | ||
167 | void AliHBTParticleCut::SetThetaRange(Double_t min, Double_t max) | |
168 | { | |
169 | AliHbtBaseCut* cut = FindCut(kHbtTheta); | |
170 | if(cut) cut->SetRange(min,max); | |
171 | else fCuts[fNCuts++] = new AliHBTThetaCut(min,max); | |
172 | } | |
173 | /******************************************************************/ | |
174 | ||
175 | void AliHBTParticleCut::SetVxRange(Double_t min, Double_t max) | |
176 | { | |
177 | AliHbtBaseCut* cut = FindCut(kHbtVx); | |
178 | if(cut) cut->SetRange(min,max); | |
179 | else fCuts[fNCuts++] = new AliHBTVxCut(min,max); | |
180 | } | |
181 | /******************************************************************/ | |
182 | ||
183 | void AliHBTParticleCut::SetVyRange(Double_t min, Double_t max) | |
184 | { | |
185 | AliHbtBaseCut* cut = FindCut(kHbtVy); | |
186 | if(cut) cut->SetRange(min,max); | |
187 | else fCuts[fNCuts++] = new AliHBTVyCut(min,max); | |
188 | } | |
189 | /******************************************************************/ | |
190 | ||
191 | void AliHBTParticleCut::SetVzRange(Double_t min, Double_t max) | |
192 | { | |
193 | AliHbtBaseCut* cut = FindCut(kHbtVz); | |
194 | if(cut) cut->SetRange(min,max); | |
195 | else fCuts[fNCuts++] = new AliHBTVzCut(min,max); | |
196 | } | |
197 | ||
198 | /******************************************************************/ | |
199 | void AliHBTParticleCut::Streamer(TBuffer &b) | |
200 | { | |
201 | // Stream all objects in the array to or from the I/O buffer. | |
202 | ||
203 | UInt_t R__s, R__c; | |
204 | if (b.IsReading()) | |
205 | { | |
e9b3bfa8 | 206 | Int_t i; |
207 | for (i = 0;i<fNCuts;i++) delete fCuts[i]; | |
208 | b.ReadVersion(&R__s, &R__c); | |
1b446896 | 209 | TObject::Streamer(b); |
210 | b >> fPID; | |
211 | b >> fNCuts; | |
e9b3bfa8 | 212 | for (i = 0;i<fNCuts;i++) |
1b446896 | 213 | { |
e9b3bfa8 | 214 | b >> fCuts[i]; |
1b446896 | 215 | } |
216 | b.CheckByteCount(R__s, R__c,AliHBTParticleCut::IsA()); | |
217 | } | |
218 | else | |
219 | { | |
220 | R__c = b.WriteVersion(AliHBTParticleCut::IsA(), kTRUE); | |
221 | TObject::Streamer(b); | |
222 | b << fPID; | |
223 | b << fNCuts; | |
224 | for (Int_t i = 0;i<fNCuts;i++) | |
225 | { | |
226 | b << fCuts[i]; | |
227 | } | |
228 | b.SetByteCount(R__c, kTRUE); | |
229 | } | |
230 | } | |
231 | ||
232 | void AliHBTParticleCut::Print(void) | |
233 | { | |
234 | cout<<"Printing AliHBTParticleCut, this = "<<this<<endl; | |
235 | cout<<"fPID "<<fPID<<endl; | |
236 | cout<<"fNCuts "<<fNCuts <<endl; | |
237 | for (Int_t i = 0;i<fNCuts;i++) | |
238 | { | |
239 | cout<<" fCuts["<<i<<"] "<<fCuts[i]<<endl<<" "; | |
240 | fCuts[i]->Print(); | |
241 | } | |
242 | } | |
243 | ||
244 | /******************************************************************/ | |
245 | /******************************************************************/ | |
246 | ||
247 | ClassImp(AliHBTEmptyParticleCut) | |
248 | void AliHBTEmptyParticleCut::Streamer(TBuffer &b) | |
249 | { | |
250 | AliHBTParticleCut::Streamer(b); | |
251 | } | |
252 | /******************************************************************/ | |
253 | /******************************************************************/ | |
254 | /******************************************************************/ | |
255 | ||
256 | /******************************************************************/ | |
257 | /******************************************************************/ | |
258 | /******************************************************************/ | |
259 | ||
260 | ClassImp(AliHbtBaseCut) | |
261 | void AliHbtBaseCut::Print(void) | |
262 | { | |
263 | cout<<"fMin="<<fMin <<", fMax=" <<fMax<<" "; | |
264 | PrintProperty(); | |
265 | } | |
266 | void AliHbtBaseCut::PrintProperty(void) | |
267 | { | |
268 | switch (fProperty) | |
269 | { | |
270 | case kHbtP: | |
271 | cout<<"kHbtP"; break; | |
272 | case kHbtPt: | |
273 | cout<<"kHbtPt"; break; | |
274 | case kHbtE: | |
275 | cout<<"kHbtE"; break; | |
276 | case kHbtRapidity: | |
277 | cout<<"kHbtRapidity"; break; | |
278 | case kHbtPseudoRapidity: | |
279 | cout<<"kHbtPseudoRapidity"; break; | |
280 | case kHbtPx: | |
281 | cout<<"kHbtPx"; break; | |
282 | case kHbtPy: | |
283 | cout<<"kHbtPy"; break; | |
284 | case kHbtPz: | |
285 | cout<<"kHbtPz"; break; | |
286 | case kHbtPhi: | |
287 | cout<<"kHbtPhi"; break; | |
288 | case kHbtTheta: | |
289 | cout<<"kHbtTheta"; break; | |
290 | case kHbtVx: | |
291 | cout<<"kHbtVx"; break; | |
292 | case kHbtVy: | |
293 | cout<<"kHbtVy"; break; | |
294 | case kHbtVz: | |
295 | cout<<"kHbtVz"; break; | |
296 | case kHbtNone: | |
297 | cout<<"kHbtNone"; break; | |
298 | default: | |
299 | cout<<"Property Not Found"; | |
300 | } | |
301 | cout<<endl; | |
302 | } | |
303 | ClassImp( AliHBTMomentumCut ) | |
304 | ||
305 | ClassImp( AliHBTPtCut ) | |
306 | ClassImp( AliHBTEnergyCut ) | |
307 | ClassImp( AliHBTRapidityCut ) | |
308 | ClassImp( AliHBTPseudoRapidityCut ) | |
309 | ClassImp( AliHBTPxCut ) | |
310 | ClassImp( AliHBTPyCut ) | |
311 | ClassImp( AliHBTPzCut ) | |
312 | ClassImp( AliHBTPhiCut ) | |
313 | ClassImp( AliHBTThetaCut ) | |
314 | ClassImp( AliHBTVxCut ) | |
315 | ClassImp( AliHBTVyCut ) | |
316 | ClassImp( AliHBTVzCut ) | |
317 | ||
4617f71a | 318 | ClassImp( AliHBTPIDCut ) |
1b446896 | 319 | |
4617f71a | 320 | ClassImp( AliHBTLogicalOperCut ) |
321 | ||
322 | AliHBTLogicalOperCut::AliHBTLogicalOperCut(): | |
323 | AliHbtBaseCut(-10e10,10e10,kHbtNone), | |
324 | fFirst(new AliHBTDummyBaseCut), | |
325 | fSecond(new AliHBTDummyBaseCut) | |
326 | { | |
327 | ||
328 | } | |
329 | /******************************************************************/ | |
330 | ||
331 | AliHBTLogicalOperCut::AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second): | |
332 | AliHbtBaseCut(-10e10,10e10,kHbtNone), | |
333 | fFirst((first)?(AliHbtBaseCut*)first->Clone():0x0), | |
334 | fSecond((second)?(AliHbtBaseCut*)second->Clone():0x0) | |
335 | { | |
336 | if ( (fFirst && fSecond) == kFALSE) | |
337 | { | |
338 | Fatal("AliHBTLogicalOperCut","One of parameters is NULL!"); | |
339 | } | |
340 | } | |
341 | /******************************************************************/ | |
342 | ||
343 | AliHBTLogicalOperCut::~AliHBTLogicalOperCut() | |
344 | { | |
345 | //destructor | |
346 | delete fFirst; | |
347 | delete fSecond; | |
348 | } | |
349 | /******************************************************************/ | |
350 | ||
bed069a4 | 351 | Bool_t AliHBTLogicalOperCut::AliHBTDummyBaseCut::Pass(AliHBTParticle* /*part*/) |
4617f71a | 352 | { |
353 | Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly"); | |
354 | return kFALSE;//accept | |
355 | } | |
356 | /******************************************************************/ | |
357 | ||
358 | void AliHBTLogicalOperCut::Streamer(TBuffer &b) | |
359 | { | |
360 | // Stream all objects in the array to or from the I/O buffer. | |
361 | UInt_t R__s, R__c; | |
362 | if (b.IsReading()) | |
363 | { | |
364 | delete fFirst; | |
365 | delete fSecond; | |
366 | fFirst = 0x0; | |
367 | fSecond = 0x0; | |
368 | ||
369 | b.ReadVersion(&R__s, &R__c); | |
370 | TObject::Streamer(b); | |
371 | b >> fFirst; | |
372 | b >> fSecond; | |
373 | b.CheckByteCount(R__s, R__c,AliHBTLogicalOperCut::IsA()); | |
374 | } | |
375 | else | |
376 | { | |
377 | R__c = b.WriteVersion(AliHBTLogicalOperCut::IsA(), kTRUE); | |
378 | TObject::Streamer(b); | |
379 | b << fFirst; | |
380 | b << fSecond; | |
381 | b.SetByteCount(R__c, kTRUE); | |
382 | } | |
383 | } | |
384 | ||
385 | /******************************************************************/ | |
386 | ClassImp(AliHBTOrCut) | |
387 | ||
388 | Bool_t AliHBTOrCut::Pass(AliHBTParticle * p) | |
389 | { | |
390 | //returns true when rejected | |
391 | //AND operation is a little bit misleading but is correct | |
392 | //User wants to build logical cuts with natural (positive) logic | |
393 | //while HBTAN use inernally reverse (returns true when rejected) | |
394 | if (fFirst->Pass(p) && fSecond->Pass(p)) return kTRUE;//rejected (both rejected, returned kTRUE) | |
395 | return kFALSE;//accepted, at least one accepted (returned kFALSE) | |
396 | } | |
397 | /******************************************************************/ | |
398 | ||
399 | ClassImp(AliHBTAndCut) | |
400 | ||
401 | Bool_t AliHBTAndCut::Pass(AliHBTParticle * p) | |
402 | { | |
403 | //returns true when rejected | |
404 | //OR operation is a little bit misleading but is correct | |
405 | //User wants to build logical cuts with natural (positive) logic | |
406 | //while HBTAN use inernally reverse (returns true when rejected) | |
407 | if (fFirst->Pass(p) || fSecond->Pass(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) ) | |
408 | return kFALSE;//accepted (both accepted (returned kFALSE)) | |
409 | } | |
410 | /******************************************************************/ |