]>
Commit | Line | Data |
---|---|---|
c7e89ea3 | 1 | /************************************************************************** |
2 | * Author: Panos Christakoglou. * | |
3 | * Contributors are mentioned in the code where appropriate. * | |
4 | * * | |
5 | * Permission to use, copy, modify and distribute this software and its * | |
6 | * documentation strictly for non-commercial purposes is hereby granted * | |
7 | * without fee, provided that the above copyright notice appears in all * | |
8 | * copies and that both the copyright notice and this permission notice * | |
9 | * appear in the supporting documentation. The authors make no claims * | |
10 | * about the suitability of this software for any purpose. It is * | |
11 | * provided "as is" without express or implied warranty. * | |
12 | **************************************************************************/ | |
13 | ||
14 | /* $Id$ */ | |
15 | ||
16 | //----------------------------------------------------------------- | |
17 | // AliEventTagCuts class | |
18 | // This is the class to deal with the event tag level cuts | |
19 | // Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch | |
20 | //----------------------------------------------------------------- | |
21 | ||
22 | class AliLog; | |
23 | class AliESD; | |
24 | ||
25 | #include "AliEventTag.h" | |
26 | #include "AliEventTagCuts.h" | |
27 | ||
28 | ClassImp(AliEventTagCuts) | |
29 | ||
30 | ||
31 | //----------------------------------------// | |
32 | AliEventTagCuts::AliEventTagCuts() | |
33 | { | |
34 | //Default constructor which calls the Reset method. | |
35 | Reset(); | |
36 | } | |
37 | ||
38 | //----------------------------------------// | |
39 | AliEventTagCuts::~AliEventTagCuts() | |
40 | { | |
41 | //Defaut destructor. | |
42 | } | |
43 | ||
44 | //----------------------------------------// | |
45 | void AliEventTagCuts::Reset() | |
46 | { | |
47 | //Sets dummy values to every private member. | |
48 | fVxFlag = kFALSE; | |
49 | fVyFlag = kFALSE; | |
50 | fVzFlag = kFALSE; | |
51 | fParticipantsFlag = kFALSE; | |
52 | fImpactParamFlag = kFALSE; | |
53 | fPVFlag = kFALSE; | |
54 | fZDCNeutronEnergyFlag = kFALSE; | |
55 | fZDCProtonEnergyFlag = kFALSE; | |
56 | fZDCEMEnergyFlag = kFALSE; | |
57 | fT0VertexZFlag = kFALSE; | |
58 | fMultFlag = kFALSE; | |
59 | fMultPosFlag = kFALSE; | |
60 | fMultNegFlag = kFALSE; | |
61 | fMultNeutrFlag = kFALSE; | |
62 | fV0sFlag = kFALSE; | |
63 | fCascadesFlag = kFALSE; | |
64 | fkinksFlag = kFALSE; | |
65 | fMaxJetEnergyFlag = kFALSE; | |
66 | fNHardPhotonsCandidatesFlag = kFALSE; | |
67 | fMaxNeutralFlag = kFALSE; | |
68 | fChargedAbove1GeVFlag = kFALSE; | |
69 | fChargedAbove3GeVFlag = kFALSE; | |
70 | fChargedAbove10GeVFlag = kFALSE; | |
71 | fMuonsAbove1GeVFlag = kFALSE; | |
72 | fMuonsAbove3GeVFlag = kFALSE; | |
73 | fMuonsAbove10GeVFlag = kFALSE; | |
74 | fElectronsAbove1GeVFlag = kFALSE; | |
75 | fElectronsAbove3GeVFlag = kFALSE; | |
76 | fElectronsAbove10GeVFlag = kFALSE; | |
77 | fElectronsFlag = kFALSE; | |
78 | fMuonsFlag = kFALSE; | |
79 | fPionsFlag = kFALSE; | |
80 | fKaonsFlag = kFALSE; | |
81 | fProtonsFlag = kFALSE; | |
82 | fLambdasFlag = kFALSE; | |
83 | fPhotonFlag = kFALSE; | |
84 | fPi0sFlag = kFALSE; | |
85 | fNeutronsFlag = kFALSE; | |
86 | fKaon0sFlag = kFALSE; | |
87 | fTotalPFlag = kFALSE; | |
88 | fMeanPtFlag = kFALSE; | |
89 | fMaxPtFlag = kFALSE; | |
90 | fTotalNeutralPFlag = kFALSE; | |
91 | fMeanNeutralPtFlag = kFALSE; | |
92 | fMaxNeutralPtFlag = kFALSE; | |
93 | fEventPlaneAngleFlag = kFALSE; | |
94 | fHBTRadiiFlag = kFALSE; | |
95 | ||
96 | fVxMin = -1000.0; | |
97 | fVxMax = 1000.0; | |
98 | fVyMin = -1000.0; | |
99 | fVyMax = 1000.0; | |
100 | fVzMin = -1000.0; | |
101 | fVzMax = 1000.0; | |
102 | ||
103 | fMultMin = 0; | |
104 | fMultMax = 100000; | |
105 | ||
106 | fParticipantsMin = -1; | |
107 | fParticipantMax = 10000; | |
108 | fImpactParamMin = -1.0; | |
109 | fImpactParamMax = 1000.0; | |
110 | fPrimaryVertexFlag = 1; | |
111 | ||
112 | fZDCNeutronEnergyMin = -1.0; | |
113 | fZDCNeutronEnergyMax = 100000.0; | |
114 | fZDCProtonEnergyMin = -1.0; | |
115 | fZDCProtonEnergyMax = 100000.0; | |
116 | fZDCEMEnergyMin = -1.0; | |
117 | fZDCEMEnergyMax = 100000.0; | |
118 | fT0VertexZMin = -10000.0; | |
119 | fT0VertexZMax = 10000.0; | |
120 | ||
121 | fMultPosMin = -1; | |
122 | fMultPosMax = 100000; | |
123 | fMultNegMin = -1; | |
124 | fMultNegMax = 100000; | |
125 | fMultNeutrMin = -1; | |
126 | fMultNeutrMax = 100000; | |
127 | fV0sMin = -1; | |
128 | fV0sMax = 1000000; | |
129 | fCascadesMin = -1; | |
130 | fCascadesMax = 100000; | |
131 | fkinksMin = -1; | |
132 | fkinksMax = 1000000; | |
133 | ||
134 | fMaxJetEnergy = -1.0; | |
135 | ||
136 | fNHardPhotonsCandidatesMin = -1; | |
137 | fNHardPhotonsCandidatesMax = 100000; | |
138 | fMaxNeutralEnergy = -1.0; | |
139 | ||
140 | fChargedAbove1GeVMin = -1; | |
141 | fChargedAbove1GeVMax = 100000; | |
142 | fChargedAbove3GeVMin = -1; | |
143 | fChargedAbove3GeVMax = 100000; | |
144 | fChargedAbove10GeVMin = -1; | |
145 | fChargedAbove10GeVMax = 100000; | |
146 | fMuonsAbove1GeVMin = -1; | |
147 | fMuonsAbove1GeVMax = 100000; | |
148 | fMuonsAbove3GeVMin = -1; | |
149 | fMuonsAbove3GeVMax = 100000; | |
150 | fMuonsAbove10GeVMin = -1; | |
151 | fMuonsAbove10GeVMax = 100000; | |
152 | fElectronsAbove1GeVMin = -1; | |
153 | fElectronsAbove1GeVMax = 100000; | |
154 | fElectronsAbove3GeVMin = -1; | |
155 | fElectronsAbove3GeVMax = 100000; | |
156 | fElectronsAbove10GeVMin = -1; | |
157 | fElectronsAbove10GeVMax = 100000; | |
158 | ||
159 | fElectronsMin = -1; | |
160 | fElectronsMax = 100000; | |
161 | fMuonsMin = -1; | |
162 | fMuonsMax = 100000; | |
163 | fPionsMin = -1; | |
164 | fPionsMax = 100000; | |
165 | fKaonsMin = -1; | |
166 | fKaonsMax = 100000; | |
167 | fProtonsMin = -1; | |
168 | fProtonsMax = 100000; | |
169 | fLambdasMin = -1; | |
170 | fLambdasMax = 100000; | |
171 | fPhotonsMin = -1; | |
172 | fPhotonsMax = 100000; | |
173 | fPi0sMin = -1; | |
174 | fPi0sMax = 100000; | |
175 | fNeutronsMin = -1; | |
176 | fNeutronsMax = 100000; | |
177 | fKaon0sMin = -1; | |
178 | fKaon0sMax = 100000; | |
179 | ||
180 | fTotalPMin = -1.0; | |
181 | fTotalPMax = 1000000.0; | |
182 | fMeanPtMin = -1.0; | |
183 | fMeanPtMax = 100000.0; | |
184 | fMaxPt = -1.0; | |
185 | fTotalNeutralPMin = -1.0; | |
186 | fTotalNeutralPMax = 1000000.0; | |
187 | fMeanNeutralPtMin = -1.0; | |
188 | fMeanNeutralPtMax = 1000000.0; | |
189 | fMaxNeutralPt = -1.0; | |
190 | fEventPlaneAngleMin = -10000000.0; | |
191 | fEventPlaneAngleMax = 10000000.0; | |
192 | fHBTRadiiMin = -1.0; | |
193 | fHBTRadiiMax = 100000.0; | |
194 | } | |
195 | ||
196 | //----------------------------------------// | |
197 | void AliEventTagCuts::SetPrimaryVertexXRange(Float_t r1, Float_t r2) | |
198 | { | |
199 | //Sets the primary vertex x range | |
200 | //and the corresponding flag to kTRUE if the cut is used. | |
201 | fVxMin = r1; | |
202 | fVxMax = r2; | |
203 | fVxFlag = kTRUE; | |
204 | } | |
205 | ||
206 | //----------------------------------------// | |
207 | void AliEventTagCuts::SetPrimaryVertexYRange(Float_t r1, Float_t r2) | |
208 | { | |
209 | //Sets the primary vertex y range | |
210 | //and the corresponding flag to kTRUE if the cut is used. | |
211 | fVyMin = r1; | |
212 | fVyMax = r2; | |
213 | fVyFlag = kTRUE; | |
214 | } | |
215 | ||
216 | //----------------------------------------// | |
217 | void AliEventTagCuts::SetPrimaryVertexZRange(Float_t r1, Float_t r2) | |
218 | { | |
219 | //Sets the primary vertex z range | |
220 | //and the corresponding flag to kTRUE if the cut is used. | |
221 | fVzMin = r1; | |
222 | fVzMax = r2; | |
223 | fVzFlag = kTRUE; | |
224 | } | |
225 | ||
226 | //----------------------------------------// | |
227 | void AliEventTagCuts::SetMultiplicityRange(Int_t n1, Int_t n2) | |
228 | { | |
229 | //Sets the primary multiplicity range | |
230 | //and the corresponding flag to kTRUE if the cut is used. | |
231 | fMultMin = n1; | |
232 | fMultMax = n2; | |
233 | fMultFlag = kTRUE; | |
234 | } | |
235 | ||
236 | //----------------------------------------// | |
237 | void AliEventTagCuts::SetParticipantsRange(Int_t i1, Int_t i2) | |
238 | { | |
239 | //Sets the number of participants range | |
240 | //and the corresponding flag to kTRUE if the cut is used. | |
241 | fParticipantsMin = i1; | |
242 | fParticipantMax = i2; | |
243 | fParticipantsFlag = kTRUE; | |
244 | } | |
245 | ||
246 | //----------------------------------------// | |
247 | void AliEventTagCuts::SetImpactParamRange(Float_t r1, Float_t r2) | |
248 | { | |
249 | //Sets the impact parameter range | |
250 | //and the corresponding flag to kTRUE if the cut is used. | |
251 | fImpactParamMin = r1; | |
252 | fImpactParamMax = r2; | |
253 | fImpactParamFlag = kTRUE; | |
254 | } | |
255 | ||
256 | ||
257 | //----------------------------------------// | |
258 | void AliEventTagCuts::SetPrimaryVertexFlag(Int_t i) | |
259 | { | |
260 | //Sets the primary vertex flag cut | |
261 | //and the corresponding flag to kTRUE if the cut is used. | |
262 | fPrimaryVertexFlag = i; | |
263 | fPVFlag = kTRUE; | |
264 | } | |
265 | ||
266 | //----------------------------------------// | |
267 | void AliEventTagCuts::SetZDCNeutrRange(Float_t r1, Float_t r2) | |
268 | { | |
269 | //Sets the ZDC's neutron energy range | |
270 | //and the corresponding flag to kTRUE if the cut is used. | |
271 | fZDCNeutronEnergyMin = r1; | |
272 | fZDCNeutronEnergyMax = r2; | |
273 | fZDCNeutronEnergyFlag = kTRUE; | |
274 | } | |
275 | //----------------------------------------// | |
276 | void AliEventTagCuts::SetZDCProtRange(Float_t r1, Float_t r2) | |
277 | { | |
278 | //Sets the ZDC's proton energy range | |
279 | //and the corresponding flag to kTRUE if the cut is used. | |
280 | fZDCProtonEnergyMin = r1; | |
281 | fZDCProtonEnergyMax = r2; | |
282 | fZDCProtonEnergyFlag = kTRUE; | |
283 | } | |
284 | //----------------------------------------// | |
285 | void AliEventTagCuts::SetZDCEMRange(Float_t r1, Float_t r2) | |
286 | { | |
287 | //Sets the ZDC's e/m energy range | |
288 | //and the corresponding flag to kTRUE if the cut is used. | |
289 | fZDCEMEnergyMin = r1; | |
290 | fZDCEMEnergyMax = r2; | |
291 | fZDCEMEnergyFlag = kTRUE; | |
292 | } | |
293 | ||
294 | //----------------------------------------// | |
295 | void AliEventTagCuts::SetT0VertexZRange(Float_t r1, Float_t r2) | |
296 | { | |
297 | //Sets the T0's Vz range | |
298 | //and the corresponding flag to kTRUE if the cut is used. | |
299 | fT0VertexZMin = r1; | |
300 | fT0VertexZMax = r2; | |
301 | fT0VertexZFlag = kTRUE; | |
302 | } | |
303 | ||
304 | //----------------------------------------// | |
305 | void AliEventTagCuts::SetPosMultiplicityRange(Int_t n1, Int_t n2) | |
306 | { | |
307 | //Sets the positive multiplicity range | |
308 | //and the corresponding flag to kTRUE if the cut is used. | |
309 | fMultPosMin = n1; | |
310 | fMultPosMax = n2; | |
311 | fMultPosFlag = kTRUE; | |
312 | } | |
313 | ||
314 | ||
315 | //----------------------------------------// | |
316 | void AliEventTagCuts::SetNegMultiplicityRange(Int_t n1, Int_t n2) | |
317 | { | |
318 | //Sets the negative multiplicity range | |
319 | //and the corresponding flag to kTRUE if the cut is used. | |
320 | fMultNegMin = n1; | |
321 | fMultNegMax = n2; | |
322 | fMultNegFlag = kTRUE; | |
323 | } | |
324 | ||
325 | ||
326 | //----------------------------------------// | |
327 | void AliEventTagCuts::SetNeutrMultiplicityRange(Int_t n1, Int_t n2) | |
328 | { | |
329 | //Sets the neutral particle multiplicity range | |
330 | //and the corresponding flag to kTRUE if the cut is used. | |
331 | fMultNeutrMin = n1; | |
332 | fMultNeutrMax = n2; | |
333 | fMultNeutrFlag = kTRUE; | |
334 | } | |
335 | ||
336 | //----------------------------------------// | |
337 | void AliEventTagCuts::SetV0sRange(Int_t n1, Int_t n2) | |
338 | { | |
339 | //Sets the v0s multiplicity range | |
340 | //and the corresponding flag to kTRUE if the cut is used. | |
341 | fV0sMin = n1; | |
342 | fV0sMax = n2; | |
343 | fV0sFlag = kTRUE; | |
344 | } | |
345 | ||
346 | //----------------------------------------// | |
347 | void AliEventTagCuts::SetCascadesRange(Int_t n1, Int_t n2) | |
348 | { | |
349 | //Sets the cascades multiplicity range | |
350 | //and the corresponding flag to kTRUE if the cut is used. | |
351 | fCascadesMin = n1; | |
352 | fCascadesMax = n2; | |
353 | fCascadesFlag = kTRUE; | |
354 | } | |
355 | ||
356 | //----------------------------------------// | |
357 | void AliEventTagCuts::SetKinksRange(Int_t n1, Int_t n2) | |
358 | { | |
359 | //Sets the kinks multipliicity range | |
360 | //and the corresponding flag to kTRUE if the cut is used. | |
361 | fkinksMin = n1; | |
362 | fkinksMax = n2; | |
363 | fkinksFlag = kTRUE; | |
364 | } | |
365 | ||
366 | //----------------------------------------// | |
367 | void AliEventTagCuts::SetMaxJetEnergy(Float_t r1) | |
368 | { | |
369 | //Sets the lower limit of the maximum jet energy | |
370 | //and the corresponding flag to kTRUE if the cut is used. | |
371 | fMaxJetEnergy = r1; | |
372 | fMaxJetEnergyFlag = kTRUE; | |
373 | } | |
374 | //----------------------------------------// | |
375 | void AliEventTagCuts::SetMaxNeutralEnergy(Float_t r1) | |
376 | { | |
377 | //Sets the lower limit of the maximum neutral jet energy | |
378 | //and the corresponding flag to kTRUE if the cut is used. | |
379 | fMaxNeutralEnergy = r1; | |
380 | fMaxNeutralFlag = kTRUE; | |
381 | } | |
382 | //----------------------------------------// | |
383 | void AliEventTagCuts::SetHardPhotonsRange(Int_t i1, Int_t i2) | |
384 | { | |
385 | //Sets the hard photons multiplicity range | |
386 | //and the corresponding flag to kTRUE if the cut is used. | |
387 | fNHardPhotonsCandidatesMin = i1; | |
388 | fNHardPhotonsCandidatesMax = i2; | |
389 | fNHardPhotonsCandidatesFlag = kTRUE; | |
390 | } | |
391 | ||
392 | //----------------------------------------// | |
393 | void AliEventTagCuts::SetNChargedAbove1GeVRange(Int_t i1, Int_t i2) | |
394 | { | |
395 | //Sets the number of charged above 1GeV range | |
396 | //and the corresponding flag to kTRUE if the cut is used. | |
397 | fChargedAbove1GeVMin = i1; | |
398 | fChargedAbove1GeVMax = i2; | |
399 | fChargedAbove1GeVFlag = kTRUE; | |
400 | } | |
401 | ||
402 | //----------------------------------------// | |
403 | void AliEventTagCuts::SetNChargedAbove3GeVRange(Int_t i1, Int_t i2) | |
404 | { | |
405 | //Sets the number of charged above 3GeV range | |
406 | //and the corresponding flag to kTRUE if the cut is used. | |
407 | fChargedAbove3GeVMin = i1; | |
408 | fChargedAbove3GeVMax = i2; | |
409 | fChargedAbove3GeVFlag = kTRUE; | |
410 | } | |
411 | ||
412 | ||
413 | //----------------------------------------// | |
414 | void AliEventTagCuts::SetNChargedAbove10GeVRange(Int_t i1, Int_t i2) | |
415 | { | |
416 | //Sets the number of charged above 10GeV range | |
417 | //and the corresponding flag to kTRUE if the cut is used. | |
418 | fChargedAbove10GeVMin = i1; | |
419 | fChargedAbove10GeVMax = i2; | |
420 | fChargedAbove10GeVFlag = kTRUE; | |
421 | } | |
422 | ||
423 | ||
424 | //----------------------------------------// | |
425 | void AliEventTagCuts::SetNMuonsAbove1GeVRange(Int_t i1, Int_t i2) | |
426 | { | |
427 | //Sets the number of muons above 1GeV range | |
428 | //and the corresponding flag to kTRUE if the cut is used. | |
429 | fMuonsAbove1GeVMin = i1; | |
430 | fMuonsAbove1GeVMax = i2; | |
431 | fMuonsAbove1GeVFlag = kTRUE; | |
432 | } | |
433 | ||
434 | ||
435 | //----------------------------------------// | |
436 | void AliEventTagCuts::SetNMuonsAbove3GeVRange(Int_t i1, Int_t i2) | |
437 | { | |
438 | //Sets the number of muons above 3GeV range | |
439 | //and the corresponding flag to kTRUE if the cut is used. | |
440 | fMuonsAbove3GeVMin = i1; | |
441 | fMuonsAbove3GeVMax = i2; | |
442 | fMuonsAbove3GeVFlag = kTRUE; | |
443 | } | |
444 | ||
445 | //----------------------------------------// | |
446 | void AliEventTagCuts::SetNMuonsAbove10GeVRange(Int_t i1, Int_t i2) | |
447 | { | |
448 | //Sets the number of muons above 10GeV range | |
449 | //and the corresponding flag to kTRUE if the cut is used. | |
450 | fMuonsAbove10GeVMin = i1; | |
451 | fMuonsAbove10GeVMax = i2; | |
452 | fMuonsAbove10GeVFlag = kTRUE; | |
453 | } | |
454 | ||
455 | ||
456 | //----------------------------------------// | |
457 | void AliEventTagCuts::SetNElectronsAbove1GeVRange(Int_t i1, Int_t i2) | |
458 | { | |
459 | //Sets the number of electrons above 1GeV range | |
460 | //and the corresponding flag to kTRUE if the cut is used. | |
461 | fElectronsAbove1GeVMin = i1; | |
462 | fElectronsAbove1GeVMax = i2; | |
463 | fElectronsAbove1GeVFlag = kTRUE; | |
464 | } | |
465 | ||
466 | //----------------------------------------// | |
467 | void AliEventTagCuts::SetNElectronsAbove3GeVRange(Int_t i1, Int_t i2) | |
468 | { | |
469 | //Sets the number of electrons above 3GeV range | |
470 | //and the corresponding flag to kTRUE if the cut is used. | |
471 | fElectronsAbove3GeVMin = i1; | |
472 | fElectronsAbove3GeVMax = i2; | |
473 | fElectronsAbove3GeVFlag = kTRUE; | |
474 | } | |
475 | ||
476 | //----------------------------------------// | |
477 | void AliEventTagCuts::SetNElectronsAbove10GeVRange(Int_t i1, Int_t i2) | |
478 | { | |
479 | //Sets the number of electrons above 10GeV range | |
480 | //and the corresponding flag to kTRUE if the cut is used. | |
481 | fElectronsAbove10GeVMin = i1; | |
482 | fElectronsAbove10GeVMax = i2; | |
483 | fElectronsAbove10GeVFlag = kTRUE; | |
484 | } | |
485 | //----------------------------------------// | |
486 | void AliEventTagCuts::SetNElectronRange(Int_t n1, Int_t n2) | |
487 | { | |
488 | //Sets the electron multiplicity range | |
489 | //and the corresponding flag to kTRUE if the cut is used. | |
490 | fElectronsMin = n1; | |
491 | fElectronsMax = n2; | |
492 | fElectronsFlag = kTRUE; | |
493 | } | |
494 | //----------------------------------------// | |
495 | void AliEventTagCuts::SetNMuonRange(Int_t n1, Int_t n2) | |
496 | { | |
497 | //Sets the muon multiplicity range | |
498 | //and the corresponding flag to kTRUE if the cut is used. | |
499 | fMuonsMin = n1; | |
500 | fMuonsMax = n2; | |
501 | fMuonsFlag = kTRUE; | |
502 | } | |
503 | ||
504 | //----------------------------------------// | |
505 | void AliEventTagCuts::SetNPionRange(Int_t n1, Int_t n2) | |
506 | { | |
507 | //Sets the pion multiplicity range | |
508 | //and the corresponding flag to kTRUE if the cut is used. | |
509 | fPionsMin = n1; | |
510 | fPionsMax = n2; | |
511 | fPionsFlag = kTRUE; | |
512 | } | |
513 | ||
514 | //----------------------------------------// | |
515 | void AliEventTagCuts::SetNKaonRange(Int_t n1, Int_t n2) | |
516 | { | |
517 | //Sets the kaon multiplicity range | |
518 | //and the corresponding flag to kTRUE if the cut is used. | |
519 | fKaonsMin = n1; | |
520 | fKaonsMax = n2; | |
521 | fKaonsFlag = kTRUE; | |
522 | } | |
523 | ||
524 | //----------------------------------------// | |
525 | void AliEventTagCuts::SetNProtonRange(Int_t n1, Int_t n2) | |
526 | { | |
527 | //Sets the proton multiplicity range | |
528 | //and the corresponding flag to kTRUE if the cut is used. | |
529 | fProtonsMin = n1; | |
530 | fProtonsMax = n2; | |
531 | fProtonsFlag = kTRUE; | |
532 | } | |
533 | ||
534 | //----------------------------------------// | |
535 | void AliEventTagCuts::SetNLambdaRange(Int_t n1, Int_t n2) | |
536 | { | |
537 | //Sets the lambda multiplicity range | |
538 | //and the corresponding flag to kTRUE if the cut is used. | |
539 | fLambdasMin = n1; | |
540 | fLambdasMax = n2; | |
541 | fLambdasFlag = kTRUE; | |
542 | } | |
543 | //----------------------------------------// | |
544 | void AliEventTagCuts::SetNPhotonRange(Int_t n1, Int_t n2) | |
545 | { | |
546 | //Sets the photon multiplicity range | |
547 | //and the corresponding flag to kTRUE if the cut is used. | |
548 | fPhotonsMin = n1; | |
549 | fPhotonsMax = n2; | |
550 | fPhotonFlag = kTRUE; | |
551 | } | |
552 | //----------------------------------------// | |
553 | void AliEventTagCuts::SetNPi0Range(Int_t n1, Int_t n2) | |
554 | { | |
555 | //Sets the pi0 multiplicity range | |
556 | //and the corresponding flag to kTRUE if the cut is used. | |
557 | fPi0sMin = n1; | |
558 | fPi0sMax = n2; | |
559 | fPi0sFlag = kTRUE; | |
560 | } | |
561 | ||
562 | //----------------------------------------// | |
563 | void AliEventTagCuts::SetNNeutronRange(Int_t n1, Int_t n2) | |
564 | { | |
565 | //Sets the neutron multiplicity range | |
566 | //and the corresponding flag to kTRUE if the cut is used. | |
567 | fNeutronsMin = n1; | |
568 | fNeutronsMax = n2; | |
569 | fNeutronsFlag = kTRUE; | |
570 | } | |
571 | ||
572 | //----------------------------------------// | |
573 | void AliEventTagCuts::SetNKaon0Range(Int_t n1, Int_t n2) | |
574 | { | |
575 | //Sets the K0s multiplicity range | |
576 | //and the corresponding flag to kTRUE if the cut is used. | |
577 | fKaon0sMin = n1; | |
578 | fKaon0sMax = n2; | |
579 | fKaon0sFlag = kTRUE; | |
580 | } | |
581 | ||
582 | //----------------------------------------// | |
583 | void AliEventTagCuts::SetTotalPRange(Float_t r1, Float_t r2) | |
584 | { | |
585 | //Sets the total momentum range | |
586 | //and the corresponding flag to kTRUE if the cut is used. | |
587 | fTotalPMin = r1; | |
588 | fTotalPMax = r2; | |
589 | fTotalPFlag = kTRUE; | |
590 | } | |
591 | ||
592 | //----------------------------------------// | |
593 | void AliEventTagCuts::SetMeanPtRange(Float_t r1, Float_t r2) | |
594 | { | |
595 | //Sets the mean Pt range | |
596 | //and the corresponding flag to kTRUE if the cut is used. | |
597 | fMeanPtMin = r1; | |
598 | fMeanPtMax = r2; | |
599 | fMeanPtFlag = kTRUE; | |
600 | } | |
601 | ||
602 | //----------------------------------------// | |
603 | void AliEventTagCuts::SetMaxPt(Float_t r1) | |
604 | { | |
605 | //Sets the lower limit of the max Pt value | |
606 | //and the corresponding flag to kTRUE if the cut is used. | |
607 | fMaxPt = r1; | |
608 | fMaxPtFlag = kTRUE; | |
609 | } | |
610 | ||
611 | //----------------------------------------// | |
612 | void AliEventTagCuts::SetTotalNeutralPRange(Float_t r1, Float_t r2) | |
613 | { | |
614 | //Sets the total momentum of neutral particles range | |
615 | //and the corresponding flag to kTRUE if the cut is used. | |
616 | fTotalNeutralPMin =r1 ; | |
617 | fTotalNeutralPMax = r2; | |
618 | fTotalNeutralPFlag = kTRUE; | |
619 | } | |
620 | //----------------------------------------// | |
621 | void AliEventTagCuts::SetMeanNeutralPtPRange(Float_t r1, Float_t r2) | |
622 | { | |
623 | //Sets the mean Pt of neutral particles range | |
624 | //and the corresponding flag to kTRUE if the cut is used. | |
625 | fMeanNeutralPtMin = r1; | |
626 | fMeanNeutralPtMax = r2; | |
627 | fMeanNeutralPtFlag = kTRUE; | |
628 | } | |
629 | //----------------------------------------// | |
630 | void AliEventTagCuts::SetMaxNeutralPt(Float_t r1) | |
631 | { | |
632 | //Sets the lower limit of the maximum Pt of neutral particles | |
633 | //and the corresponding flag to kTRUE if the cut is used. | |
634 | fMaxNeutralPt = r1; | |
635 | fMaxNeutralPtFlag = kTRUE; | |
636 | } | |
637 | ||
638 | //----------------------------------------// | |
639 | void AliEventTagCuts::SetEvPlaneAngleRange(Float_t r1, Float_t r2) | |
640 | { | |
641 | //Sets the event plane range | |
642 | //and the corresponding flag to kTRUE if the cut is used. | |
643 | fEventPlaneAngleMin = r1; | |
644 | fEventPlaneAngleMax = r2; | |
645 | fEventPlaneAngleFlag = kTRUE; | |
646 | } | |
647 | ||
648 | //----------------------------------------// | |
649 | void AliEventTagCuts::SetHBTRadiiRange(Float_t r1, Float_t r2) | |
650 | { | |
651 | //Sets the HBT radii range | |
652 | //and the corresponding flag to kTRUE if the cut is used. | |
653 | fHBTRadiiMin = r1; | |
654 | fHBTRadiiMax = r2; | |
655 | fHBTRadiiFlag = kTRUE; | |
656 | } | |
657 | ||
658 | //----------------------------------------// | |
659 | Bool_t AliEventTagCuts::IsAccepted(AliEventTag *EvTag) const | |
660 | { | |
661 | //Returns true if the event is accepted otherwise false. | |
662 | if(fMultFlag) | |
663 | if((EvTag->GetNumOfTracks() < fMultMin) || (EvTag->GetNumOfTracks() > fMultMax)) | |
664 | return kFALSE; | |
665 | ||
666 | if(fVzFlag) | |
667 | if((EvTag->GetVertexZ() < fVzMin) || (EvTag->GetVertexZ() > fVzMax)) | |
668 | return kFALSE; | |
669 | ||
670 | if(fVyFlag) | |
671 | if((EvTag->GetVertexY() < fVyMin) || (EvTag->GetVertexY() > fVyMax)) | |
672 | return kFALSE; | |
673 | ||
674 | if(fVxFlag) | |
675 | if((EvTag->GetVertexX() < fVxMin) || (EvTag->GetVertexX() > fVxMax)) | |
676 | return kFALSE; | |
677 | ||
678 | if(fParticipantsFlag) | |
679 | if((EvTag->GetNumOfParticipants() < fParticipantsMin) || (EvTag->GetNumOfParticipants() > fParticipantMax)) | |
680 | return kFALSE; | |
681 | ||
682 | if(fImpactParamFlag) | |
683 | if((EvTag->GetImpactParameter() < fImpactParamMin) || (EvTag->GetImpactParameter() > fImpactParamMax)) | |
684 | return kFALSE; | |
685 | ||
686 | if(fPVFlag) | |
687 | if((EvTag->GetVertexFlag() != fPrimaryVertexFlag)) | |
688 | return kFALSE; | |
689 | ||
690 | if(fZDCNeutronEnergyFlag) | |
691 | if((EvTag->GetZDCNeutronEnergy() < fZDCNeutronEnergyMin) || (EvTag->GetZDCNeutronEnergy() > fZDCNeutronEnergyMax)) | |
692 | return kFALSE; | |
693 | ||
694 | if(fZDCProtonEnergyFlag) | |
695 | if((EvTag->GetZDCProtonEnergy() < fZDCProtonEnergyMin) || (EvTag->GetZDCProtonEnergy() > fZDCProtonEnergyMax)) | |
696 | return kFALSE; | |
697 | ||
698 | if(fZDCEMEnergyFlag) | |
699 | if((EvTag->GetZDCEMEnergy() < fZDCEMEnergyMin) || (EvTag->GetZDCEMEnergy() > fZDCEMEnergyMax)) | |
700 | return kFALSE; | |
701 | ||
702 | if(fT0VertexZFlag) | |
703 | if((EvTag->GetT0VertexZ() < fT0VertexZMin) || (EvTag->GetT0VertexZ() > fT0VertexZMax)) | |
704 | return kFALSE; | |
705 | ||
706 | if(fMultPosFlag) | |
707 | if((EvTag->GetNumOfPosTracks() < fMultPosMin) || (EvTag->GetNumOfPosTracks() > fMultPosMax)) | |
708 | return kFALSE; | |
709 | ||
710 | if(fMultNegFlag) | |
711 | if((EvTag->GetNumOfNegTracks() < fMultNegMin) || (EvTag->GetNumOfNegTracks() > fMultNegMax)) | |
712 | return kFALSE; | |
713 | ||
714 | if(fMultNeutrFlag) | |
715 | if((EvTag->GetNumOfNeutrTracks() < fMultNeutrMin) || (EvTag->GetNumOfNeutrTracks() > fMultNeutrMax)) | |
716 | return kFALSE; | |
717 | ||
718 | if(fV0sFlag) | |
719 | if((EvTag->GetNumOfV0s() < fV0sMin) || (EvTag->GetNumOfV0s() > fV0sMax)) | |
720 | return kFALSE; | |
721 | ||
722 | if(fCascadesFlag) | |
723 | if((EvTag->GetNumOfCascades() < fCascadesMin) || (EvTag->GetNumOfCascades() > fCascadesMax)) | |
724 | return kFALSE; | |
725 | ||
726 | if(fkinksFlag) | |
727 | if((EvTag->GetNumOfKinks() < fkinksMin) || (EvTag->GetNumOfKinks() > fkinksMax)) | |
728 | return kFALSE; | |
729 | ||
730 | if(fMaxJetEnergyFlag) | |
731 | if((EvTag->GetMaxJetEnergy() < fMaxJetEnergy)) | |
732 | return kFALSE; | |
733 | ||
734 | if(fNHardPhotonsCandidatesFlag) | |
735 | if((EvTag->GetNumOfHardPhotonsCandidates() < fNHardPhotonsCandidatesMin) || (EvTag->GetNumOfHardPhotonsCandidates() > fNHardPhotonsCandidatesMax)) | |
736 | return kFALSE; | |
737 | ||
738 | if(fMaxNeutralFlag) | |
739 | if((EvTag->GetMaxNeutralEnergy() < fMaxNeutralEnergy)) | |
740 | return kFALSE; | |
741 | ||
742 | if(fChargedAbove1GeVFlag) | |
743 | if((EvTag->GetNumOfChargedAbove1GeV() < fChargedAbove1GeVMin) || (EvTag->GetNumOfChargedAbove1GeV() > fChargedAbove1GeVMax)) | |
744 | return kFALSE; | |
745 | ||
746 | if(fChargedAbove3GeVFlag) | |
747 | if((EvTag->GetNumOfChargedAbove3GeV() < fChargedAbove3GeVMin) || (EvTag->GetNumOfChargedAbove3GeV() > fChargedAbove3GeVMax)) | |
748 | return kFALSE; | |
749 | ||
750 | if(fChargedAbove10GeVFlag) | |
751 | if((EvTag->GetNumOfChargedAbove10GeV() < fChargedAbove10GeVMin) || (EvTag->GetNumOfChargedAbove10GeV() > fChargedAbove10GeVMax)) | |
752 | return kFALSE; | |
753 | ||
754 | if(fMuonsAbove1GeVFlag) | |
755 | if((EvTag->GetNumOfMuonsAbove1GeV() < fMuonsAbove1GeVMin) || (EvTag->GetNumOfMuonsAbove1GeV() > fMuonsAbove1GeVMax)) | |
756 | return kFALSE; | |
757 | ||
758 | if(fMuonsAbove3GeVFlag) | |
759 | if((EvTag->GetNumOfMuonsAbove3GeV() < fMuonsAbove3GeVMin) || (EvTag->GetNumOfMuonsAbove3GeV() > fMuonsAbove3GeVMax)) | |
760 | return kFALSE; | |
761 | ||
762 | if(fMuonsAbove10GeVFlag) | |
763 | if((EvTag->GetNumOfMuonsAbove10GeV() < fMuonsAbove10GeVMin) || (EvTag->GetNumOfMuonsAbove10GeV() > fMuonsAbove10GeVMax)) | |
764 | return kFALSE; | |
765 | ||
766 | if(fElectronsAbove1GeVFlag) | |
767 | if((EvTag->GetNumOfElectronsAbove1GeV() < fElectronsAbove1GeVMin) || (EvTag->GetNumOfElectronsAbove1GeV() > fElectronsAbove1GeVMax)) | |
768 | return kFALSE; | |
769 | ||
770 | if(fElectronsAbove3GeVFlag) | |
771 | if((EvTag->GetNumOfElectronsAbove3GeV() < fElectronsAbove3GeVMin) || (EvTag->GetNumOfElectronsAbove3GeV() > fElectronsAbove3GeVMax)) | |
772 | return kFALSE; | |
773 | ||
774 | if(fElectronsAbove10GeVFlag) | |
775 | if((EvTag->GetNumOfElectronsAbove10GeV() < fElectronsAbove10GeVMin) || (EvTag->GetNumOfElectronsAbove10GeV() > fElectronsAbove10GeVMax)) | |
776 | return kFALSE; | |
777 | ||
778 | if(fElectronsFlag) | |
779 | if((EvTag->GetNumOfElectrons() < fElectronsMin) || (EvTag->GetNumOfElectrons() > fElectronsMax)) | |
780 | return kFALSE; | |
781 | ||
782 | if(fMuonsFlag) | |
783 | if((EvTag->GetNumOfMuons() < fMuonsMin) || (EvTag->GetNumOfMuons() > fMuonsMax)) | |
784 | return kFALSE; | |
785 | ||
786 | if(fPionsFlag) | |
787 | if((EvTag->GetNumOfPions() < fPionsMin) || (EvTag->GetNumOfPions() > fPionsMax)) | |
788 | return kFALSE; | |
789 | ||
790 | if(fKaonsFlag) | |
791 | if((EvTag->GetNumOfKaons() < fKaonsMin) || (EvTag->GetNumOfKaons() > fKaonsMax)) | |
792 | return kFALSE; | |
793 | ||
794 | if(fProtonsFlag) | |
795 | if((EvTag->GetNumOfProtons() < fProtonsMin) || (EvTag->GetNumOfProtons() > fProtonsMax)) | |
796 | return kFALSE; | |
797 | ||
798 | if(fLambdasFlag) | |
799 | if((EvTag->GetNumOfLambdas() < fLambdasMin) || (EvTag->GetNumOfLambdas() > fLambdasMax)) | |
800 | return kFALSE; | |
801 | ||
802 | if(fPhotonFlag) | |
803 | if((EvTag->GetNumOfPhotons() < fPhotonsMin) || (EvTag->GetNumOfPhotons() > fPhotonsMax)) | |
804 | return kFALSE; | |
805 | ||
806 | if(fPi0sFlag) | |
807 | if((EvTag->GetNumOfPi0s() < fPi0sMin) || (EvTag->GetNumOfPi0s() > fPi0sMax)) | |
808 | return kFALSE; | |
809 | ||
810 | if(fNeutronsFlag) | |
811 | if((EvTag->GetNumOfNeutrons() < fNeutronsMin) || (EvTag->GetNumOfNeutrons() > fNeutronsMax)) | |
812 | return kFALSE; | |
813 | ||
814 | if(fKaon0sFlag) | |
815 | if((EvTag->GetNumOfKaon0s() < fKaon0sMin) || (EvTag->GetNumOfKaon0s() > fKaon0sMax)) | |
816 | return kFALSE; | |
817 | ||
818 | if(fTotalPFlag) | |
819 | if((EvTag->GetTotalMomentum() < fTotalPMin) || (EvTag->GetTotalMomentum() > fTotalPMax)) | |
820 | return kFALSE; | |
821 | ||
822 | if(fMeanPtFlag) | |
823 | if((EvTag->GetMeanPt() < fMeanPtMin) || (EvTag->GetMeanPt() > fMeanPtMax)) | |
824 | return kFALSE; | |
825 | ||
826 | if(fMaxPtFlag) | |
827 | if((EvTag->GetMaxPt() < fMaxPt)) | |
828 | return kFALSE; | |
829 | ||
830 | if(fTotalNeutralPFlag) | |
831 | if((EvTag->GetNeutralTotalMomentum() < fTotalNeutralPMin) || (EvTag->GetNeutralTotalMomentum() > fTotalNeutralPMax)) | |
832 | return kFALSE; | |
833 | ||
834 | if(fMeanNeutralPtFlag) | |
835 | if((EvTag->GetNeutralMeanPt() < fMeanNeutralPtMin) || (EvTag->GetNeutralMeanPt() >fMeanNeutralPtMax )) | |
836 | return kFALSE; | |
837 | ||
838 | if(fMaxNeutralPtFlag) | |
839 | if((EvTag->GetNeutralMaxPt() < fMaxNeutralPt)) | |
840 | return kFALSE; | |
841 | ||
842 | if(fEventPlaneAngleFlag) | |
843 | if((EvTag->GetEventPlaneAngle() < fEventPlaneAngleMin) || (EvTag->GetEventPlaneAngle() > fEventPlaneAngleMax)) | |
844 | return kFALSE; | |
845 | ||
846 | if(fHBTRadiiFlag) | |
847 | if((EvTag->GetHBTRadii() < fHBTRadiiMin) || (EvTag->GetHBTRadii() > fHBTRadiiMax)) | |
848 | return kFALSE; | |
849 | ||
850 | return kTRUE; | |
851 | } |