New classes for selection of events using their tags (P.Christakoglou)
[u/mrichter/AliRoot.git] / STEER / AliEventTagCuts.cxx
CommitLineData
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
22class AliLog;
23class AliESD;
24
25#include "AliEventTag.h"
26#include "AliEventTagCuts.h"
27
28ClassImp(AliEventTagCuts)
29
30
31//----------------------------------------//
32AliEventTagCuts::AliEventTagCuts()
33{
34 //Default constructor which calls the Reset method.
35 Reset();
36}
37
38//----------------------------------------//
39AliEventTagCuts::~AliEventTagCuts()
40{
41 //Defaut destructor.
42}
43
44//----------------------------------------//
45void 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//----------------------------------------//
197void 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//----------------------------------------//
207void 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//----------------------------------------//
217void 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//----------------------------------------//
227void 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//----------------------------------------//
237void 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//----------------------------------------//
247void 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//----------------------------------------//
258void 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//----------------------------------------//
267void 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//----------------------------------------//
276void 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//----------------------------------------//
285void 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//----------------------------------------//
295void 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//----------------------------------------//
305void 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//----------------------------------------//
316void 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//----------------------------------------//
327void 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//----------------------------------------//
337void 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//----------------------------------------//
347void 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//----------------------------------------//
357void 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//----------------------------------------//
367void 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//----------------------------------------//
375void 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//----------------------------------------//
383void 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//----------------------------------------//
393void 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//----------------------------------------//
414void 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//----------------------------------------//
425void 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//----------------------------------------//
436void 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//----------------------------------------//
446void 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//----------------------------------------//
457void 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//----------------------------------------//
467void 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//----------------------------------------//
477void 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//----------------------------------------//
486void 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//----------------------------------------//
495void 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//----------------------------------------//
505void 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//----------------------------------------//
515void 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//----------------------------------------//
525void 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//----------------------------------------//
535void 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//----------------------------------------//
544void 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//----------------------------------------//
553void 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//----------------------------------------//
563void 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//----------------------------------------//
573void 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//----------------------------------------//
583void 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//----------------------------------------//
593void 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//----------------------------------------//
603void 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//----------------------------------------//
612void 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//----------------------------------------//
621void 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//----------------------------------------//
630void 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//----------------------------------------//
639void 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//----------------------------------------//
649void 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//----------------------------------------//
659Bool_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}