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