New classes for selection of events using their tags (P.Christakoglou)
[u/mrichter/AliRoot.git] / STEER / AliEventTagCuts.cxx
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 }