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