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 }