class AliLog;
class AliESD;
+#include "TMath.h"
#include "AliEventTag.h"
#include "AliEventTagCuts.h"
ClassImp(AliEventTagCuts)
-//----------------------------------------//
-AliEventTagCuts::AliEventTagCuts()
+//___________________________________________________________________________
+AliEventTagCuts::AliEventTagCuts() :
+ TObject(),
+ fPeriodNumberMin(0), fPeriodNumberMax(0xFFFFFFFF), fPeriodNumberFlag(kFALSE),
+ fOrbitNumberMin(0), fOrbitNumberMax(0xFFFFFFFF), fOrbitNumberFlag(kFALSE),
+ fBunchCrossNumberMin(0), fBunchCrossNumberMax(0xFFFF),
+ fBunchCrossNumberFlag(kFALSE),
+ fEventType(7), fEventTypeFlag(kFALSE),
+ fNParticipantsMin(-1), fNParticipantsMax(10000),
+ fNParticipantsFlag(kFALSE),
+ fImpactParamMin(-1.0), fImpactParamMax(1000.0),
+ fImpactParamFlag(kFALSE),
+ fEtaMin(-13.0), fEtaMax(13.0),
+ fEtaFlag(kFALSE),
+ fPhiMin(0.), fPhiMax(2*(TMath::Pi())),
+ fPhiFlag(kFALSE),
+ fVxMin(-1000.0), fVxMax(1000.0),
+ fVxFlag(kFALSE),
+ fVyMin(-1000.0), fVyMax(1000.0),
+ fVyFlag(kFALSE),
+ fVzMin(-1000.0), fVzMax(1000.0),
+ fVzFlag(kFALSE),
+ fPrimaryVertexFlag(1),
+ fPVFlag(kFALSE),
+
+ fPrimaryVertexZErrorMin(-10000.), fPrimaryVertexZErrorMax(10000.),
+ fPVzErrorFlag(kFALSE),
+ fTriggerMask(0),
+ fTriggerMaskFlag(kFALSE),
+ fTriggerCluster(0),
+ fTriggerClusterFlag(kFALSE),
+
+ fZDCNeutron1EnergyMin(-1.0), fZDCNeutron1EnergyMax(100000.0),
+ fZDCNeutron1EnergyFlag(kFALSE),
+ fZDCProton1EnergyMin(-1.0), fZDCProton1EnergyMax(100000.0),
+ fZDCProton1EnergyFlag(kFALSE),
+ fZDCNeutron2EnergyMin(-1.0), fZDCNeutron2EnergyMax(100000.0),
+ fZDCNeutron2EnergyFlag(kFALSE),
+ fZDCProton2EnergyMin(-1.0), fZDCProton2EnergyMax(100000.0),
+ fZDCProton2EnergyFlag(kFALSE),
+ fZDCEMEnergyMin(-1.0), fZDCEMEnergyMax(100000.0),
+ fZDCEMEnergyFlag(kFALSE),
+ fT0VertexZMin(-10000.0), fT0VertexZMax(10000.0),
+ fT0VertexZFlag(kFALSE),
+ fMultMin(0), fMultMax(100000),
+ fMultFlag(kFALSE),
+ fPosMultMin(-1), fPosMultMax(100000),
+ fPosMultFlag(kFALSE),
+ fNegMultMin(-1), fNegMultMax(100000),
+ fNegMultFlag(kFALSE),
+ fNeutrMultMin(-1), fNeutrMultMax(100000),
+ fNeutrMultFlag(kFALSE),
+ fNV0sMin(-1), fNV0sMax(1000000),
+ fNV0sFlag(kFALSE),
+ fNCascadesMin(-1), fNCascadesMax(100000),
+ fNCascadesFlag(kFALSE),
+ fNKinksMin(-1), fNKinksMax(1000000),
+ fNKinksFlag(kFALSE),
+
+ fNPMDTracksMin(-1), fNPMDTracksMax(100000),
+ fNPMDTracksFlag(kFALSE),
+ fNFMDTracksMin(-1), fNFMDTracksMax(100000),
+ fNFMDTracksFlag(kFALSE),
+ fNPHOSClustersMin(-1), fNPHOSClustersMax(100000),
+ fNPHOSClustersFlag(kFALSE),
+ fNEMCALClustersMin(-1), fNEMCALClustersMax(100000),
+ fNEMCALClustersFlag(kFALSE),
+ fNJetCandidatesMin(-1), fNJetCandidatesMax(100000),
+ fNJetCandidatesFlag(kFALSE),
+
+ fTopJetEnergyMin(-1.0),
+ fTopJetEnergyMinFlag(kFALSE),
+ fTopNeutralEnergyMin(-1.0),
+ fTopNeutralEnergyMinFlag(kFALSE),
+ fNHardPhotonCandidatesMin(-1), fNHardPhotonCandidatesMax(100000),
+ fNHardPhotonCandidatesFlag(kFALSE),
+ fNChargedAbove1GeVMin(-1), fNChargedAbove1GeVMax(100000),
+ fNChargedAbove1GeVFlag(kFALSE),
+ fNChargedAbove3GeVMin(-1), fNChargedAbove3GeVMax(100000),
+ fNChargedAbove3GeVFlag(kFALSE),
+ fNChargedAbove10GeVMin(-1), fNChargedAbove10GeVMax(100000),
+ fNChargedAbove10GeVFlag(kFALSE),
+ fNMuonsAbove1GeVMin(-1), fNMuonsAbove1GeVMax(100000),
+ fNMuonsAbove1GeVFlag(kFALSE),
+ fNMuonsAbove3GeVMin(-1), fNMuonsAbove3GeVMax(100000),
+ fNMuonsAbove3GeVFlag(kFALSE),
+ fNMuonsAbove10GeVMin(-1), fNMuonsAbove10GeVMax(100000),
+ fNMuonsAbove10GeVFlag(kFALSE),
+ fNElectronsAbove1GeVMin(-1), fNElectronsAbove1GeVMax(100000),
+ fNElectronsAbove1GeVFlag(kFALSE),
+ fNElectronsAbove3GeVMin(-1), fNElectronsAbove3GeVMax(100000),
+ fNElectronsAbove3GeVFlag(kFALSE),
+ fNElectronsAbove10GeVMin(-1), fNElectronsAbove10GeVMax(100000),
+ fNElectronsAbove10GeVFlag(kFALSE),
+ fNElectronsMin(-1), fNElectronsMax(100000),
+ fNElectronsFlag(kFALSE),
+ fNFWMuonsMin(-1), fNFWMuonsMax(100000),
+ fNFWMuonsFlag(kFALSE),
+ fNFWMatchedMuonsMin(-1), fNFWMatchedMuonsMax(100000),
+ fNFWMatchedMuonsFlag(kFALSE),
+ fNMuonsMin(-1), fNMuonsMax(100000),
+ fNMuonsFlag(kFALSE),
+ fNPionsMin(-1), fNPionsMax(100000),
+ fNPionsFlag(kFALSE),
+ fNKaonsMin(-1), fNKaonsMax(100000),
+ fNKaonsFlag(kFALSE),
+ fNProtonsMin(-1), fNProtonsMax(100000),
+ fNProtonsFlag(kFALSE),
+ fNLambdasMin(-1), fNLambdasMax(100000),
+ fNLambdasFlag(kFALSE),
+ fNPhotonsMin(-1), fNPhotonsMax(100000),
+ fNPhotonFlag(kFALSE),
+ fNPi0sMin(-1), fNPi0sMax(100000),
+ fNPi0sFlag(kFALSE),
+ fNNeutronsMin(-1), fNNeutronsMax(100000),
+ fNNeutronsFlag(kFALSE),
+ fNKaon0sMin(-1), fNKaon0sMax(100000),
+ fNKaon0sFlag(kFALSE),
+ fTotalPMin(-1.0), fTotalPMax(1000000.0),
+ fTotalPFlag(kFALSE),
+ fMeanPtMin(-1.0), fMeanPtMax(100000.0),
+ fMeanPtFlag(kFALSE),
+ fTopPtMin(-1.0),
+ fTopPtMinFlag(kFALSE),
+ fTotalNeutralPMin(-1.0), fTotalNeutralPMax(1000000.0),
+ fTotalNeutralPFlag(kFALSE),
+ fMeanNeutralPtMin(-1.0), fMeanNeutralPtMax(1000000.0),
+ fMeanNeutralPtFlag(kFALSE),
+ fTopNeutralPtMin(-1.0),
+ fTopNeutralPtMinFlag(kFALSE),
+ fEventPlaneAngleMin(-10000000.0), fEventPlaneAngleMax(10000000.0),
+ fEventPlaneAngleFlag(kFALSE),
+ fHBTRadiiMin(-1.0), fHBTRadiiMax(100000.0),
+ fHBTRadiiFlag(kFALSE),
+
+ fNumberOfFiredChipsLayer1Min(0), fNumberOfFiredChipsLayer1Max(100000),
+ fNumberOfFiredChipsLayer1Flag(kFALSE),
+ fNumberOfFiredChipsLayer2Min(0), fNumberOfFiredChipsLayer2Max(100000),
+ fNumberOfFiredChipsLayer2Flag(kFALSE),
+ fNumberOfSPDTrackletsMin(0), fNumberOfSPDTrackletsMax(100000),
+ fNumberOfSPDTrackletsFlag(kFALSE),
+
+ fFiredTriggerCleassFlag(kFALSE), fFiredTriggerCleass("")
+
{
//Default constructor which calls the Reset method.
Reset();
}
-//----------------------------------------//
-AliEventTagCuts::~AliEventTagCuts()
-{
+//___________________________________________________________________________
+AliEventTagCuts::~AliEventTagCuts() {
//Defaut destructor.
}
-//----------------------------------------//
-void AliEventTagCuts::Reset()
-{
+//___________________________________________________________________________
+void AliEventTagCuts::Reset() {
//Sets dummy values to every private member.
+ fPeriodNumberFlag = kFALSE;
+ fOrbitNumberFlag = kFALSE;
+ fBunchCrossNumberFlag = kFALSE;
+
+ fEventTypeFlag = kFALSE;
+
+ fNParticipantsFlag = kFALSE;
+ fImpactParamFlag = kFALSE;
+
+ fEtaFlag = kFALSE;
+ fPhiFlag = kFALSE;
fVxFlag = kFALSE;
fVyFlag = kFALSE;
fVzFlag = kFALSE;
- fParticipantsFlag = kFALSE;
- fImpactParamFlag = kFALSE;
fPVFlag = kFALSE;
- fZDCNeutronEnergyFlag = kFALSE;
- fZDCProtonEnergyFlag = kFALSE;
+ fPVzErrorFlag = kFALSE;
+
+ fTriggerMaskFlag = kFALSE;
+ fTriggerClusterFlag = kFALSE;
+
+ fZDCNeutron1EnergyFlag = kFALSE;
+ fZDCProton1EnergyFlag = kFALSE;
+ fZDCNeutron2EnergyFlag = kFALSE;
+ fZDCProton2EnergyFlag = kFALSE;
fZDCEMEnergyFlag = kFALSE;
fT0VertexZFlag = kFALSE;
fMultFlag = kFALSE;
- fMultPosFlag = kFALSE;
- fMultNegFlag = kFALSE;
- fMultNeutrFlag = kFALSE;
- fV0sFlag = kFALSE;
- fCascadesFlag = kFALSE;
- fkinksFlag = kFALSE;
- fMaxJetEnergyFlag = kFALSE;
- fNHardPhotonsCandidatesFlag = kFALSE;
- fMaxNeutralFlag = kFALSE;
- fChargedAbove1GeVFlag = kFALSE;
- fChargedAbove3GeVFlag = kFALSE;
- fChargedAbove10GeVFlag = kFALSE;
- fMuonsAbove1GeVFlag = kFALSE;
- fMuonsAbove3GeVFlag = kFALSE;
- fMuonsAbove10GeVFlag = kFALSE;
- fElectronsAbove1GeVFlag = kFALSE;
- fElectronsAbove3GeVFlag = kFALSE;
- fElectronsAbove10GeVFlag = kFALSE;
- fElectronsFlag = kFALSE;
- fMuonsFlag = kFALSE;
- fPionsFlag = kFALSE;
- fKaonsFlag = kFALSE;
- fProtonsFlag = kFALSE;
- fLambdasFlag = kFALSE;
- fPhotonFlag = kFALSE;
- fPi0sFlag = kFALSE;
- fNeutronsFlag = kFALSE;
- fKaon0sFlag = kFALSE;
+ fPosMultFlag = kFALSE;
+ fNegMultFlag = kFALSE;
+ fNeutrMultFlag = kFALSE;
+ fNV0sFlag = kFALSE;
+ fNCascadesFlag = kFALSE;
+ fNKinksFlag = kFALSE;
+
+ fNPMDTracksFlag = kFALSE;
+ fNFMDTracksFlag = kFALSE;
+ fNPHOSClustersFlag = kFALSE;
+ fNEMCALClustersFlag = kFALSE;
+ fNJetCandidatesFlag = kFALSE;
+
+ fTopJetEnergyMinFlag = kFALSE;
+ fNHardPhotonCandidatesFlag = kFALSE;
+ fTopNeutralEnergyMinFlag = kFALSE;
+ fNChargedAbove1GeVFlag = kFALSE;
+ fNChargedAbove3GeVFlag = kFALSE;
+ fNChargedAbove10GeVFlag = kFALSE;
+ fNMuonsAbove1GeVFlag = kFALSE;
+ fNMuonsAbove3GeVFlag = kFALSE;
+ fNMuonsAbove10GeVFlag = kFALSE;
+ fNElectronsAbove1GeVFlag = kFALSE;
+ fNElectronsAbove3GeVFlag = kFALSE;
+ fNElectronsAbove10GeVFlag = kFALSE;
+ fNElectronsFlag = kFALSE;
+ fNFWMuonsFlag = kFALSE;
+ fNFWMatchedMuonsFlag = kFALSE;
+ fNMuonsFlag = kFALSE;
+ fNPionsFlag = kFALSE;
+ fNKaonsFlag = kFALSE;
+ fNProtonsFlag = kFALSE;
+ fNLambdasFlag = kFALSE;
+ fNPhotonFlag = kFALSE;
+ fNPi0sFlag = kFALSE;
+ fNNeutronsFlag = kFALSE;
+ fNKaon0sFlag = kFALSE;
fTotalPFlag = kFALSE;
fMeanPtFlag = kFALSE;
- fMaxPtFlag = kFALSE;
+ fTopPtMinFlag = kFALSE;
fTotalNeutralPFlag = kFALSE;
fMeanNeutralPtFlag = kFALSE;
- fMaxNeutralPtFlag = kFALSE;
+ fTopNeutralPtMinFlag = kFALSE;
fEventPlaneAngleFlag = kFALSE;
fHBTRadiiFlag = kFALSE;
-
- fVxMin = -1000.0;
- fVxMax = 1000.0;
- fVyMin = -1000.0;
- fVyMax = 1000.0;
- fVzMin = -1000.0;
- fVzMax = 1000.0;
- fMultMin = 0;
- fMultMax = 100000;
+ fNumberOfFiredChipsLayer1Flag = kFALSE;
+ fNumberOfFiredChipsLayer2Flag = kFALSE;
+ fNumberOfSPDTrackletsFlag = kFALSE;
- fParticipantsMin = -1;
- fParticipantMax = 10000;
- fImpactParamMin = -1.0;
- fImpactParamMax = 1000.0;
+ fPeriodNumberMin = 0, fPeriodNumberMax = 0xFFFFFFFF;
+ fOrbitNumberMin = 0, fOrbitNumberMax = 0xFFFFFFFF;
+ fBunchCrossNumberMin = 0, fBunchCrossNumberMax = 0xFFFF;
+
+ fEventType = 7;
+
+ fEtaMin = -13.0; fEtaMax = 13.0;
+ fPhiMin = 0.; fPhiMax = 2*(TMath::Pi());
+ fVxMin = -1000.0; fVxMax = 1000.0;
+ fVyMin = -1000.0; fVyMax = 1000.0;
+ fVzMin = -1000.0; fVzMax = 1000.0;
+ fNParticipantsMin = -1; fNParticipantsMax = 10000;
+ fImpactParamMin = -1.0; fImpactParamMax = 1000.0;
fPrimaryVertexFlag = 1;
+
+ fPrimaryVertexZErrorMin = -10000.; fPrimaryVertexZErrorMax = 10000.;
+ fTriggerMask = 0;
+ fTriggerCluster = 0;
- fZDCNeutronEnergyMin = -1.0;
- fZDCNeutronEnergyMax = 100000.0;
- fZDCProtonEnergyMin = -1.0;
- fZDCProtonEnergyMax = 100000.0;
- fZDCEMEnergyMin = -1.0;
- fZDCEMEnergyMax = 100000.0;
- fT0VertexZMin = -10000.0;
- fT0VertexZMax = 10000.0;
-
- fMultPosMin = -1;
- fMultPosMax = 100000;
- fMultNegMin = -1;
- fMultNegMax = 100000;
- fMultNeutrMin = -1;
- fMultNeutrMax = 100000;
- fV0sMin = -1;
- fV0sMax = 1000000;
- fCascadesMin = -1;
- fCascadesMax = 100000;
- fkinksMin = -1;
- fkinksMax = 1000000;
-
- fMaxJetEnergy = -1.0;
-
- fNHardPhotonsCandidatesMin = -1;
- fNHardPhotonsCandidatesMax = 100000;
- fMaxNeutralEnergy = -1.0;
-
- fChargedAbove1GeVMin = -1;
- fChargedAbove1GeVMax = 100000;
- fChargedAbove3GeVMin = -1;
- fChargedAbove3GeVMax = 100000;
- fChargedAbove10GeVMin = -1;
- fChargedAbove10GeVMax = 100000;
- fMuonsAbove1GeVMin = -1;
- fMuonsAbove1GeVMax = 100000;
- fMuonsAbove3GeVMin = -1;
- fMuonsAbove3GeVMax = 100000;
- fMuonsAbove10GeVMin = -1;
- fMuonsAbove10GeVMax = 100000;
- fElectronsAbove1GeVMin = -1;
- fElectronsAbove1GeVMax = 100000;
- fElectronsAbove3GeVMin = -1;
- fElectronsAbove3GeVMax = 100000;
- fElectronsAbove10GeVMin = -1;
- fElectronsAbove10GeVMax = 100000;
-
- fElectronsMin = -1;
- fElectronsMax = 100000;
- fMuonsMin = -1;
- fMuonsMax = 100000;
- fPionsMin = -1;
- fPionsMax = 100000;
- fKaonsMin = -1;
- fKaonsMax = 100000;
- fProtonsMin = -1;
- fProtonsMax = 100000;
- fLambdasMin = -1;
- fLambdasMax = 100000;
- fPhotonsMin = -1;
- fPhotonsMax = 100000;
- fPi0sMin = -1;
- fPi0sMax = 100000;
- fNeutronsMin = -1;
- fNeutronsMax = 100000;
- fKaon0sMin = -1;
- fKaon0sMax = 100000;
-
- fTotalPMin = -1.0;
- fTotalPMax = 1000000.0;
- fMeanPtMin = -1.0;
- fMeanPtMax = 100000.0;
- fMaxPt = -1.0;
- fTotalNeutralPMin = -1.0;
- fTotalNeutralPMax = 1000000.0;
- fMeanNeutralPtMin = -1.0;
- fMeanNeutralPtMax = 1000000.0;
- fMaxNeutralPt = -1.0;
- fEventPlaneAngleMin = -10000000.0;
- fEventPlaneAngleMax = 10000000.0;
- fHBTRadiiMin = -1.0;
- fHBTRadiiMax = 100000.0;
-}
-
-//----------------------------------------//
-void AliEventTagCuts::SetPrimaryVertexXRange(Float_t r1, Float_t r2)
-{
+ fZDCNeutron1EnergyMin = -1.0; fZDCNeutron1EnergyMax = 100000.0;
+ fZDCProton1EnergyMin = -1.0; fZDCProton1EnergyMax = 100000.0;
+ fZDCNeutron2EnergyMin = -1.0; fZDCNeutron2EnergyMax = 100000.0;
+ fZDCProton2EnergyMin = -1.0; fZDCProton2EnergyMax = 100000.0;
+ fZDCEMEnergyMin = -1.0; fZDCEMEnergyMax = 100000.0;
+ fT0VertexZMin = -10000.0; fT0VertexZMax = 10000.0;
+ fMultMin = 0; fMultMax = 100000;
+ fPosMultMin = -1; fPosMultMax = 100000;
+ fNegMultMin = -1; fNegMultMax = 100000;
+ fNeutrMultMin = -1; fNeutrMultMax = 100000;
+ fNV0sMin = -1; fNV0sMax = 1000000;
+ fNCascadesMin = -1; fNCascadesMax = 100000;
+ fNKinksMin = -1; fNKinksMax = 1000000;
+
+ fNPMDTracksMin = -1, fNPMDTracksMax = 100000;
+ fNFMDTracksMin = -1, fNFMDTracksMax = 100000;
+ fNPHOSClustersMin = -1, fNPHOSClustersMax = 100000;
+ fNEMCALClustersMin = -1, fNEMCALClustersMax = 100000;
+ fNJetCandidatesMin = -1, fNJetCandidatesMax = 100000;
+
+ fTopJetEnergyMin = -1.0;
+ fNHardPhotonCandidatesMin = -1; fNHardPhotonCandidatesMax = 100000;
+ fTopNeutralEnergyMin = -1.0;
+ fNChargedAbove1GeVMin = -1; fNChargedAbove1GeVMax = 100000;
+ fNChargedAbove3GeVMin = -1; fNChargedAbove3GeVMax = 100000;
+ fNChargedAbove10GeVMin = -1; fNChargedAbove10GeVMax = 100000;
+ fNMuonsAbove1GeVMin = -1; fNMuonsAbove1GeVMax = 100000;
+ fNMuonsAbove3GeVMin = -1; fNMuonsAbove3GeVMax = 100000;
+ fNMuonsAbove10GeVMin = -1; fNMuonsAbove10GeVMax = 100000;
+ fNElectronsAbove1GeVMin = -1; fNElectronsAbove1GeVMax = 100000;
+ fNElectronsAbove3GeVMin = -1; fNElectronsAbove3GeVMax = 100000;
+ fNElectronsAbove10GeVMin = -1; fNElectronsAbove10GeVMax = 100000;
+ fNElectronsMin = -1; fNElectronsMax = 100000;
+ fNFWMuonsMin = -1; fNFWMuonsMax = 100000;
+ fNFWMatchedMuonsMin = -1; fNFWMatchedMuonsMax = 100000;
+ fNMuonsMin = -1; fNMuonsMax = 100000;
+ fNPionsMin = -1; fNPionsMax = 100000;
+ fNKaonsMin = -1; fNKaonsMax = 100000;
+ fNProtonsMin = -1; fNProtonsMax = 100000;
+ fNLambdasMin = -1; fNLambdasMax = 100000;
+ fNPhotonsMin = -1; fNPhotonsMax = 100000;
+ fNPi0sMin = -1; fNPi0sMax = 100000;
+ fNNeutronsMin = -1; fNNeutronsMax = 100000;
+ fNKaon0sMin = -1; fNKaon0sMax = 100000;
+ fTotalPMin = -1.0; fTotalPMax = 1000000.0;
+ fMeanPtMin = -1.0; fMeanPtMax = 100000.0;
+ fTopPtMin = -1.0; fTotalNeutralPMin = -1.0;
+ fTotalNeutralPMax = 1000000.0;
+ fMeanNeutralPtMin = -1.0; fMeanNeutralPtMax = 1000000.0;
+ fTopNeutralPtMin = -1.0;
+ fEventPlaneAngleMin = -10000000.0; fEventPlaneAngleMax = 10000000.0;
+ fHBTRadiiMin = -1.0; fHBTRadiiMax = 100000.0;
+
+ fNumberOfFiredChipsLayer1Min = 0, fNumberOfFiredChipsLayer1Max = 100000;
+ fNumberOfFiredChipsLayer2Min = 0, fNumberOfFiredChipsLayer2Max = 100000;
+ fNumberOfSPDTrackletsMin = 0, fNumberOfSPDTrackletsMax = 100000;
+
+ fFiredTriggerCleass = "";
+ fFiredTriggerCleassFlag = kFALSE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetEventType(UInt_t ntype) {
+ //Sets the event type
+ //and the corresponding flag to kTRUE if the cut is used.
+ fEventType = ntype;
+ fEventTypeFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNumberOfFiredChipsLayer1Range(Int_t low, Int_t high) {
+ //Sets the range for the number of fired chips of layer 1
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNumberOfFiredChipsLayer1Min = low;
+ fNumberOfFiredChipsLayer1Max = high;
+ fNumberOfFiredChipsLayer1Flag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNumberOfFiredChipsLayer2Range(Int_t low, Int_t high) {
+ //Sets the range for the number of fired chips of layer 2
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNumberOfFiredChipsLayer2Min = low;
+ fNumberOfFiredChipsLayer2Max = high;
+ fNumberOfFiredChipsLayer2Flag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNumberOfSPDTrackletsRange(Int_t low, Int_t high) {
+ //Sets the range for the number of fired chips of layer 1
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNumberOfSPDTrackletsMin = low;
+ fNumberOfSPDTrackletsMax = high;
+ fNumberOfSPDTrackletsFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetPeriodNumberRange(UInt_t low, UInt_t high) {
+ //Sets the period number range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fPeriodNumberMin = low;
+ fPeriodNumberMax = high;
+ fPeriodNumberFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetOrbitNumberRange(UInt_t low, UInt_t high) {
+ //Sets the orbit number range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fOrbitNumberMin = low;
+ fOrbitNumberMax = high;
+ fOrbitNumberFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetBunchCrossNumberRange(UShort_t low, UShort_t high) {
+ //Sets the BC number range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fBunchCrossNumberMin = low;
+ fBunchCrossNumberMax = high;
+ fBunchCrossNumberFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetPrimaryVertexXRange(Float_t low, Float_t high) {
//Sets the primary vertex x range
//and the corresponding flag to kTRUE if the cut is used.
- fVxMin = r1;
- fVxMax = r2;
+ fVxMin = low;
+ fVxMax = high;
fVxFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetPrimaryVertexYRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetPrimaryVertexYRange(Float_t low, Float_t high) {
//Sets the primary vertex y range
//and the corresponding flag to kTRUE if the cut is used.
- fVyMin = r1;
- fVyMax = r2;
+ fVyMin = low;
+ fVyMax = high;
fVyFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetPrimaryVertexZRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetPrimaryVertexZRange(Float_t low, Float_t high) {
//Sets the primary vertex z range
//and the corresponding flag to kTRUE if the cut is used.
- fVzMin = r1;
- fVzMax = r2;
+ fVzMin = low;
+ fVzMax = high;
fVzFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetMultiplicityRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+ void AliEventTagCuts::SetEtaLeadingParticleRange(Float_t low, Float_t high) {
+ //Sets the eta range of LP
+ //and the corresponding flag to kTRUE if the cut is used.
+ fEtaMin = low;
+ fEtaMax = high;
+ fEtaFlag = kTRUE;
+}
+//__________________________________________________________________________
+void AliEventTagCuts::SetPhiLeadingParticleRange(Float_t low, Float_t high) {
+ //Sets the eta range of LP
+ //and the corresponding flag to kTRUE if the cut is used.
+ fPhiMin = low;
+ fPhiMax = high;
+ fPhiFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetPrimaryVertexZErrorRange(Float_t low, Float_t high) {
+ //Sets the primary vertex z error range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fPrimaryVertexZErrorMin = low;
+ fPrimaryVertexZErrorMax = high;
+ fPVzErrorFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetTriggerMask(ULong64_t trmask) {
+ //Sets the trigger mask
+ //and the corresponding flag to kTRUE if the cut is used.
+ fTriggerMask = trmask;
+ fTriggerMaskFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetTriggerCluster(UChar_t trcluster) {
+ //Sets the trigger cluster
+ //and the corresponding flag to kTRUE if the cut is used.
+ fTriggerCluster = trcluster;
+ fTriggerClusterFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetMultiplicityRange(Int_t low, Int_t high) {
//Sets the primary multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fMultMin = n1;
- fMultMax = n2;
+ fMultMin = low;
+ fMultMax = high;
fMultFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetParticipantsRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNParticipantsRange(Int_t low, Int_t high) {
//Sets the number of participants range
//and the corresponding flag to kTRUE if the cut is used.
- fParticipantsMin = i1;
- fParticipantMax = i2;
- fParticipantsFlag = kTRUE;
+ fNParticipantsMin = low;
+ fNParticipantsMax = high;
+ fNParticipantsFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetImpactParamRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetImpactParamRange(Float_t low, Float_t high) {
//Sets the impact parameter range
//and the corresponding flag to kTRUE if the cut is used.
- fImpactParamMin = r1;
- fImpactParamMax = r2;
+ fImpactParamMin = low;
+ fImpactParamMax = high;
fImpactParamFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetPrimaryVertexFlag(Int_t i)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetPrimaryVertexFlag(Int_t flag) {
//Sets the primary vertex flag cut
//and the corresponding flag to kTRUE if the cut is used.
- fPrimaryVertexFlag = i;
+ fPrimaryVertexFlag = flag;
fPVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetZDCNeutrRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetZDCNeutron1Range(Float_t low, Float_t high) {
//Sets the ZDC's neutron energy range
//and the corresponding flag to kTRUE if the cut is used.
- fZDCNeutronEnergyMin = r1;
- fZDCNeutronEnergyMax = r2;
- fZDCNeutronEnergyFlag = kTRUE;
+ fZDCNeutron1EnergyMin = low;
+ fZDCNeutron1EnergyMax = high;
+ fZDCNeutron1EnergyFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetZDCProtRange(Float_t r1, Float_t r2)
-{
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetZDCProton1Range(Float_t low, Float_t high) {
//Sets the ZDC's proton energy range
//and the corresponding flag to kTRUE if the cut is used.
- fZDCProtonEnergyMin = r1;
- fZDCProtonEnergyMax = r2;
- fZDCProtonEnergyFlag = kTRUE;
+ fZDCProton1EnergyMin = low;
+ fZDCProton1EnergyMax = high;
+ fZDCProton1EnergyFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetZDCEMRange(Float_t r1, Float_t r2)
-{
- //Sets the ZDC's e/m energy range
+//___________________________________________________________________________
+void AliEventTagCuts::SetZDCNeutron2Range(Float_t low, Float_t high) {
+ //Sets the ZDC's neutron energy range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fZDCNeutron2EnergyMin = low;
+ fZDCNeutron2EnergyMax = high;
+ fZDCNeutron2EnergyFlag = kTRUE;
+}
+//___________________________________________________________________________
+void AliEventTagCuts::SetZDCProton2Range(Float_t low, Float_t high) {
+ //Sets the ZDC's proton energy range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fZDCProton2EnergyMin = low;
+ fZDCProton2EnergyMax = high;
+ fZDCProton2EnergyFlag = kTRUE;
+}
+//___________________________________________________________________________
+void AliEventTagCuts::SetZDCEMRange(Float_t low, Float_t high) {
+ //Sets the ZDC's em energy range
//and the corresponding flag to kTRUE if the cut is used.
- fZDCEMEnergyMin = r1;
- fZDCEMEnergyMax = r2;
+ fZDCEMEnergyMin = low;
+ fZDCEMEnergyMax = high;
fZDCEMEnergyFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetT0VertexZRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetT0VertexZRange(Float_t low, Float_t high) {
//Sets the T0's Vz range
//and the corresponding flag to kTRUE if the cut is used.
- fT0VertexZMin = r1;
- fT0VertexZMax = r2;
+ fT0VertexZMin = low;
+ fT0VertexZMax = high;
fT0VertexZFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetPosMultiplicityRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetPosMultiplicityRange(Int_t low, Int_t high) {
//Sets the positive multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fMultPosMin = n1;
- fMultPosMax = n2;
- fMultPosFlag = kTRUE;
+ fPosMultMin = low;
+ fPosMultMax = high;
+ fPosMultFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNegMultiplicityRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNegMultiplicityRange(Int_t low, Int_t high) {
//Sets the negative multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fMultNegMin = n1;
- fMultNegMax = n2;
- fMultNegFlag = kTRUE;
+ fNegMultMin = low;
+ fNegMultMax = high;
+ fNegMultFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNeutrMultiplicityRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNeutrMultiplicityRange(Int_t low, Int_t high) {
//Sets the neutral particle multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fMultNeutrMin = n1;
- fMultNeutrMax = n2;
- fMultNeutrFlag = kTRUE;
+ fNeutrMultMin = low;
+ fNeutrMultMax = high;
+ fNeutrMultFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetV0sRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNV0sRange(Int_t low, Int_t high) {
//Sets the v0s multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fV0sMin = n1;
- fV0sMax = n2;
- fV0sFlag = kTRUE;
+ fNV0sMin = low;
+ fNV0sMax = high;
+ fNV0sFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetCascadesRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNCascadesRange(Int_t low, Int_t high) {
//Sets the cascades multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fCascadesMin = n1;
- fCascadesMax = n2;
- fCascadesFlag = kTRUE;
+ fNCascadesMin = low;
+ fNCascadesMax = high;
+ fNCascadesFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetKinksRange(Int_t n1, Int_t n2)
-{
- //Sets the kinks multipliicity range
+//___________________________________________________________________________
+void AliEventTagCuts::SetNKinksRange(Int_t low, Int_t high) {
+ //Sets the kinks multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fkinksMin = n1;
- fkinksMax = n2;
- fkinksFlag = kTRUE;
+ fNKinksMin = low;
+ fNKinksMax = high;
+ fNKinksFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetMaxJetEnergy(Float_t r1)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNPMDTracksRange(Int_t low, Int_t high) {
+ //Sets the number of PMD tracks range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNPMDTracksMin = low;
+ fNPMDTracksMax = high;
+ fNPMDTracksFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNFMDTracksRange(Int_t low, Int_t high) {
+ //Sets the number of FMD tracks range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNFMDTracksMin = low;
+ fNFMDTracksMax = high;
+ fNFMDTracksFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNPHOSClustersRange(Int_t low, Int_t high) {
+ //Sets the number of PHOS clusters range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNPHOSClustersMin = low;
+ fNPHOSClustersMax = high;
+ fNPHOSClustersFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNEMCALClustersRange(Int_t low, Int_t high) {
+ //Sets the number of EMCAL clusters range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNEMCALClustersMin = low;
+ fNEMCALClustersMax = high;
+ fNEMCALClustersFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNJetCandidatesRange(Int_t low, Int_t high) {
+ //Sets the number of jet candidates range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNJetCandidatesMin = low;
+ fNJetCandidatesMax = high;
+ fNJetCandidatesFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetTopJetEnergyMin(Float_t low) {
//Sets the lower limit of the maximum jet energy
//and the corresponding flag to kTRUE if the cut is used.
- fMaxJetEnergy = r1;
- fMaxJetEnergyFlag = kTRUE;
+ fTopJetEnergyMin = low;
+ fTopJetEnergyMinFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetMaxNeutralEnergy(Float_t r1)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetTopNeutralEnergyMin(Float_t low) {
//Sets the lower limit of the maximum neutral jet energy
//and the corresponding flag to kTRUE if the cut is used.
- fMaxNeutralEnergy = r1;
- fMaxNeutralFlag = kTRUE;
+ fTopNeutralEnergyMin = low;
+ fTopNeutralEnergyMinFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetHardPhotonsRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNHardPhotonsRange(Int_t low, Int_t high) {
//Sets the hard photons multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fNHardPhotonsCandidatesMin = i1;
- fNHardPhotonsCandidatesMax = i2;
- fNHardPhotonsCandidatesFlag = kTRUE;
+ fNHardPhotonCandidatesMin = low;
+ fNHardPhotonCandidatesMax = high;
+ fNHardPhotonCandidatesFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNChargedAbove1GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNChargedAbove1GeVRange(Int_t low, Int_t high) {
//Sets the number of charged above 1GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fChargedAbove1GeVMin = i1;
- fChargedAbove1GeVMax = i2;
- fChargedAbove1GeVFlag = kTRUE;
+ fNChargedAbove1GeVMin = low;
+ fNChargedAbove1GeVMax = high;
+ fNChargedAbove1GeVFlag = kTRUE;
}
-//----------------------------------------//
- void AliEventTagCuts::SetNChargedAbove3GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+ void AliEventTagCuts::SetNChargedAbove3GeVRange(Int_t low, Int_t high) {
//Sets the number of charged above 3GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fChargedAbove3GeVMin = i1;
- fChargedAbove3GeVMax = i2;
- fChargedAbove3GeVFlag = kTRUE;
+ fNChargedAbove3GeVMin = low;
+ fNChargedAbove3GeVMax = high;
+ fNChargedAbove3GeVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNChargedAbove10GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNChargedAbove10GeVRange(Int_t low, Int_t high) {
//Sets the number of charged above 10GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fChargedAbove10GeVMin = i1;
- fChargedAbove10GeVMax = i2;
- fChargedAbove10GeVFlag = kTRUE;
+ fNChargedAbove10GeVMin = low;
+ fNChargedAbove10GeVMax = high;
+ fNChargedAbove10GeVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNMuonsAbove1GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNMuonsAbove1GeVRange(Int_t low, Int_t high) {
//Sets the number of muons above 1GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fMuonsAbove1GeVMin = i1;
- fMuonsAbove1GeVMax = i2;
- fMuonsAbove1GeVFlag = kTRUE;
+ fNMuonsAbove1GeVMin = low;
+ fNMuonsAbove1GeVMax = high;
+ fNMuonsAbove1GeVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNMuonsAbove3GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNMuonsAbove3GeVRange(Int_t low, Int_t high) {
//Sets the number of muons above 3GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fMuonsAbove3GeVMin = i1;
- fMuonsAbove3GeVMax = i2;
- fMuonsAbove3GeVFlag = kTRUE;
+ fNMuonsAbove3GeVMin = low;
+ fNMuonsAbove3GeVMax = high;
+ fNMuonsAbove3GeVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNMuonsAbove10GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNMuonsAbove10GeVRange(Int_t low, Int_t high) {
//Sets the number of muons above 10GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fMuonsAbove10GeVMin = i1;
- fMuonsAbove10GeVMax = i2;
- fMuonsAbove10GeVFlag = kTRUE;
+ fNMuonsAbove10GeVMin = low;
+ fNMuonsAbove10GeVMax = high;
+ fNMuonsAbove10GeVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNElectronsAbove1GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNElectronsAbove1GeVRange(Int_t low, Int_t high) {
//Sets the number of electrons above 1GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fElectronsAbove1GeVMin = i1;
- fElectronsAbove1GeVMax = i2;
- fElectronsAbove1GeVFlag = kTRUE;
+ fNElectronsAbove1GeVMin = low;
+ fNElectronsAbove1GeVMax = high;
+ fNElectronsAbove1GeVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNElectronsAbove3GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNElectronsAbove3GeVRange(Int_t low, Int_t high) {
//Sets the number of electrons above 3GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fElectronsAbove3GeVMin = i1;
- fElectronsAbove3GeVMax = i2;
- fElectronsAbove3GeVFlag = kTRUE;
+ fNElectronsAbove3GeVMin = low;
+ fNElectronsAbove3GeVMax = high;
+ fNElectronsAbove3GeVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNElectronsAbove10GeVRange(Int_t i1, Int_t i2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNElectronsAbove10GeVRange(Int_t low, Int_t high) {
//Sets the number of electrons above 10GeV range
//and the corresponding flag to kTRUE if the cut is used.
- fElectronsAbove10GeVMin = i1;
- fElectronsAbove10GeVMax = i2;
- fElectronsAbove10GeVFlag = kTRUE;
+ fNElectronsAbove10GeVMin = low;
+ fNElectronsAbove10GeVMax = high;
+ fNElectronsAbove10GeVFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNElectronRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNElectronRange(Int_t low, Int_t high) {
//Sets the electron multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fElectronsMin = n1;
- fElectronsMax = n2;
- fElectronsFlag = kTRUE;
+ fNElectronsMin = low;
+ fNElectronsMax = high;
+ fNElectronsFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNMuonRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNFWMuonRange(Int_t low, Int_t high) {
+ //Sets the forward muon multiplicity range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNFWMuonsMin = low;
+ fNFWMuonsMax = high;
+ fNFWMuonsFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNFWMatchedMuonRange(Int_t low, Int_t high) {
+ //Sets the forward trigger matched muon multiplicity range
+ //and the corresponding flag to kTRUE if the cut is used.
+ fNFWMatchedMuonsMin = low;
+ fNFWMatchedMuonsMax = high;
+ fNFWMatchedMuonsFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+void AliEventTagCuts::SetNMuonRange(Int_t low, Int_t high) {
//Sets the muon multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fMuonsMin = n1;
- fMuonsMax = n2;
- fMuonsFlag = kTRUE;
+ fNMuonsMin = low;
+ fNMuonsMax = high;
+ fNMuonsFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNPionRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNPionRange(Int_t low, Int_t high) {
//Sets the pion multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fPionsMin = n1;
- fPionsMax = n2;
- fPionsFlag = kTRUE;
+ fNPionsMin = low;
+ fNPionsMax = high;
+ fNPionsFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNKaonRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNKaonRange(Int_t low, Int_t high) {
//Sets the kaon multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fKaonsMin = n1;
- fKaonsMax = n2;
- fKaonsFlag = kTRUE;
+ fNKaonsMin = low;
+ fNKaonsMax = high;
+ fNKaonsFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNProtonRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNProtonRange(Int_t low, Int_t high) {
//Sets the proton multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fProtonsMin = n1;
- fProtonsMax = n2;
- fProtonsFlag = kTRUE;
+ fNProtonsMin = low;
+ fNProtonsMax = high;
+ fNProtonsFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNLambdaRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNLambdaRange(Int_t low, Int_t high) {
//Sets the lambda multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fLambdasMin = n1;
- fLambdasMax = n2;
- fLambdasFlag = kTRUE;
+ fNLambdasMin = low;
+ fNLambdasMax = high;
+ fNLambdasFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNPhotonRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNPhotonRange(Int_t low, Int_t high) {
//Sets the photon multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fPhotonsMin = n1;
- fPhotonsMax = n2;
- fPhotonFlag = kTRUE;
+ fNPhotonsMin = low;
+ fNPhotonsMax = high;
+ fNPhotonFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNPi0Range(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNPi0Range(Int_t low, Int_t high) {
//Sets the pi0 multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fPi0sMin = n1;
- fPi0sMax = n2;
- fPi0sFlag = kTRUE;
+ fNPi0sMin = low;
+ fNPi0sMax = high;
+ fNPi0sFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNNeutronRange(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNNeutronRange(Int_t low, Int_t high) {
//Sets the neutron multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fNeutronsMin = n1;
- fNeutronsMax = n2;
- fNeutronsFlag = kTRUE;
+ fNNeutronsMin = low;
+ fNNeutronsMax = high;
+ fNNeutronsFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetNKaon0Range(Int_t n1, Int_t n2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetNKaon0Range(Int_t low, Int_t high) {
//Sets the K0s multiplicity range
//and the corresponding flag to kTRUE if the cut is used.
- fKaon0sMin = n1;
- fKaon0sMax = n2;
- fKaon0sFlag = kTRUE;
+ fNKaon0sMin = low;
+ fNKaon0sMax = high;
+ fNKaon0sFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetTotalPRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetTotalPRange(Float_t low, Float_t high) {
//Sets the total momentum range
//and the corresponding flag to kTRUE if the cut is used.
- fTotalPMin = r1;
- fTotalPMax = r2;
+ fTotalPMin = low;
+ fTotalPMax = high;
fTotalPFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetMeanPtRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetMeanPtRange(Float_t low, Float_t high) {
//Sets the mean Pt range
//and the corresponding flag to kTRUE if the cut is used.
- fMeanPtMin = r1;
- fMeanPtMax = r2;
+ fMeanPtMin = low;
+ fMeanPtMax = high;
fMeanPtFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetMaxPt(Float_t r1)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetTopPtMin(Float_t low) {
//Sets the lower limit of the max Pt value
//and the corresponding flag to kTRUE if the cut is used.
- fMaxPt = r1;
- fMaxPtFlag = kTRUE;
+ fTopPtMin = low;
+ fTopPtMinFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetTotalNeutralPRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetTotalNeutralPRange(Float_t low, Float_t high) {
//Sets the total momentum of neutral particles range
//and the corresponding flag to kTRUE if the cut is used.
- fTotalNeutralPMin =r1 ;
- fTotalNeutralPMax = r2;
+ fTotalNeutralPMin =low ;
+ fTotalNeutralPMax = high;
fTotalNeutralPFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetMeanNeutralPtPRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetMeanNeutralPtPRange(Float_t low, Float_t high) {
//Sets the mean Pt of neutral particles range
//and the corresponding flag to kTRUE if the cut is used.
- fMeanNeutralPtMin = r1;
- fMeanNeutralPtMax = r2;
+ fMeanNeutralPtMin = low;
+ fMeanNeutralPtMax = high;
fMeanNeutralPtFlag = kTRUE;
-}
-//----------------------------------------//
-void AliEventTagCuts::SetMaxNeutralPt(Float_t r1)
-{
+}
+//___________________________________________________________________________
+void AliEventTagCuts::SetTopNeutralPtMin(Float_t low) {
//Sets the lower limit of the maximum Pt of neutral particles
//and the corresponding flag to kTRUE if the cut is used.
- fMaxNeutralPt = r1;
- fMaxNeutralPtFlag = kTRUE;
+ fTopNeutralPtMin = low;
+ fTopNeutralPtMinFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetEvPlaneAngleRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetEventPlaneAngleRange(Float_t low, Float_t high) {
//Sets the event plane range
//and the corresponding flag to kTRUE if the cut is used.
- fEventPlaneAngleMin = r1;
- fEventPlaneAngleMax = r2;
+ fEventPlaneAngleMin = low;
+ fEventPlaneAngleMax = high;
fEventPlaneAngleFlag = kTRUE;
}
-//----------------------------------------//
-void AliEventTagCuts::SetHBTRadiiRange(Float_t r1, Float_t r2)
-{
+//___________________________________________________________________________
+void AliEventTagCuts::SetHBTRadiiRange(Float_t low, Float_t high) {
//Sets the HBT radii range
//and the corresponding flag to kTRUE if the cut is used.
- fHBTRadiiMin = r1;
- fHBTRadiiMax = r2;
+ fHBTRadiiMin = low;
+ fHBTRadiiMax = high;
fHBTRadiiFlag = kTRUE;
}
-//----------------------------------------//
-Bool_t AliEventTagCuts::IsAccepted(AliEventTag *EvTag) const
+void AliEventTagCuts::SetFiredTriggerClass(TString aclass)
{
+ fFiredTriggerCleass = aclass;
+ fFiredTriggerCleassFlag = kTRUE;
+}
+
+//___________________________________________________________________________
+Bool_t AliEventTagCuts::IsAccepted(AliEventTag *EvTag) const {
//Returns true if the event is accepted otherwise false.
- if(fMultFlag)
- if((EvTag->GetNumOfTracks() < fMultMin) || (EvTag->GetNumOfTracks() > fMultMax))
- return kFALSE;
+ if(fEventTypeFlag)
+ if(EvTag->GetEventType() != fEventType)
+ return kFALSE;
+ if(fNumberOfFiredChipsLayer1Flag)
+ if((EvTag->GetNumberOfFiredChipsLayer1() < fNumberOfFiredChipsLayer1Min) || (EvTag->GetNumberOfFiredChipsLayer1() > fNumberOfFiredChipsLayer1Max))
+ return kFALSE;
+
+ if(fNumberOfFiredChipsLayer2Flag)
+ if((EvTag->GetNumberOfFiredChipsLayer2() < fNumberOfFiredChipsLayer2Min) || (EvTag->GetNumberOfFiredChipsLayer2() > fNumberOfFiredChipsLayer2Max))
+ return kFALSE;
+
+ if(fNumberOfSPDTrackletsFlag)
+ if((EvTag->GetNumberOfSPDTracklets() < fNumberOfSPDTrackletsMin) || (EvTag->GetNumberOfSPDTracklets() > fNumberOfSPDTrackletsMax))
+ return kFALSE;
+
+ if(fPeriodNumberFlag)
+ if((EvTag->GetPeriodNumber() < fPeriodNumberMin) || (EvTag->GetPeriodNumber() > fPeriodNumberMax))
+ return kFALSE;
+
+ if(fOrbitNumberFlag)
+ if((EvTag->GetOrbitNumber() < fOrbitNumberMin) || (EvTag->GetOrbitNumber() > fOrbitNumberMax))
+ return kFALSE;
+
+ if(fBunchCrossNumberFlag)
+ if((EvTag->GetBunchCrossNumber() < fBunchCrossNumberMin) || (EvTag->GetBunchCrossNumber() > fBunchCrossNumberMax))
+ return kFALSE;
+
+
+ if(fEtaFlag)
+ if((EvTag->GetEtaMaxPt() < fEtaMin) || (EvTag->GetEtaMaxPt() > fEtaMax))
+ return kFALSE;
+
+ if(fPhiFlag)
+ if((EvTag->GetPhiMaxPt() < fPhiMin) || (EvTag->GetPhiMaxPt() > fPhiMax))
+ return kFALSE;
+
if(fVzFlag)
if((EvTag->GetVertexZ() < fVzMin) || (EvTag->GetVertexZ() > fVzMax))
return kFALSE;
if((EvTag->GetVertexX() < fVxMin) || (EvTag->GetVertexX() > fVxMax))
return kFALSE;
- if(fParticipantsFlag)
- if((EvTag->GetNumOfParticipants() < fParticipantsMin) || (EvTag->GetNumOfParticipants() > fParticipantMax))
+ if(fNParticipantsFlag)
+ if((EvTag->GetNumOfParticipants() < fNParticipantsMin) || (EvTag->GetNumOfParticipants() > fNParticipantsMax))
return kFALSE;
if(fImpactParamFlag)
if((EvTag->GetVertexFlag() != fPrimaryVertexFlag))
return kFALSE;
- if(fZDCNeutronEnergyFlag)
- if((EvTag->GetZDCNeutronEnergy() < fZDCNeutronEnergyMin) || (EvTag->GetZDCNeutronEnergy() > fZDCNeutronEnergyMax))
+ if(fPVzErrorFlag)
+ if((EvTag->GetVertexZError() < fPrimaryVertexZErrorMin) || (EvTag->GetVertexZError() > fPrimaryVertexZErrorMax))
+ return kFALSE;
+ if(fTriggerMaskFlag)
+ if((EvTag->GetTriggerMask() & fTriggerMask) != fTriggerMask)
+ return kFALSE;
+ if(fTriggerClusterFlag)
+ if((EvTag->GetTriggerCluster() != fTriggerCluster))
+ return kFALSE;
+
+ if(fZDCNeutron1EnergyFlag)
+ if((EvTag->GetZDCNeutron1Energy() < fZDCNeutron1EnergyMin) || (EvTag->GetZDCNeutron1Energy() > fZDCNeutron1EnergyMax))
return kFALSE;
- if(fZDCProtonEnergyFlag)
- if((EvTag->GetZDCProtonEnergy() < fZDCProtonEnergyMin) || (EvTag->GetZDCProtonEnergy() > fZDCProtonEnergyMax))
+ if(fZDCProton1EnergyFlag)
+ if((EvTag->GetZDCProton1Energy() < fZDCProton1EnergyMin) || (EvTag->GetZDCProton1Energy() > fZDCProton1EnergyMax))
+ return kFALSE;
+
+ if(fZDCNeutron2EnergyFlag)
+ if((EvTag->GetZDCNeutron2Energy() < fZDCNeutron2EnergyMin) || (EvTag->GetZDCNeutron2Energy() > fZDCNeutron2EnergyMax))
+ return kFALSE;
+
+ if(fZDCProton2EnergyFlag)
+ if((EvTag->GetZDCProton2Energy() < fZDCProton2EnergyMin) || (EvTag->GetZDCProton2Energy() > fZDCProton2EnergyMax))
return kFALSE;
if(fZDCEMEnergyFlag)
- if((EvTag->GetZDCEMEnergy() < fZDCEMEnergyMin) || (EvTag->GetZDCEMEnergy() > fZDCEMEnergyMax))
+ if((EvTag->GetZDCEMEnergy(1) < fZDCEMEnergyMin) || (EvTag->GetZDCEMEnergy(1) > fZDCEMEnergyMax))
return kFALSE;
if(fT0VertexZFlag)
if((EvTag->GetT0VertexZ() < fT0VertexZMin) || (EvTag->GetT0VertexZ() > fT0VertexZMax))
return kFALSE;
- if(fMultPosFlag)
- if((EvTag->GetNumOfPosTracks() < fMultPosMin) || (EvTag->GetNumOfPosTracks() > fMultPosMax))
+ if(fMultFlag)
+ if((EvTag->GetNumOfTracks() < fMultMin) || (EvTag->GetNumOfTracks() > fMultMax))
return kFALSE;
- if(fMultNegFlag)
- if((EvTag->GetNumOfNegTracks() < fMultNegMin) || (EvTag->GetNumOfNegTracks() > fMultNegMax))
+ if(fPosMultFlag)
+ if((EvTag->GetNumOfPosTracks() < fPosMultMin) || (EvTag->GetNumOfPosTracks() > fPosMultMax))
return kFALSE;
- if(fMultNeutrFlag)
- if((EvTag->GetNumOfNeutrTracks() < fMultNeutrMin) || (EvTag->GetNumOfNeutrTracks() > fMultNeutrMax))
+ if(fNegMultFlag)
+ if((EvTag->GetNumOfNegTracks() < fNegMultMin) || (EvTag->GetNumOfNegTracks() > fNegMultMax))
return kFALSE;
- if(fV0sFlag)
- if((EvTag->GetNumOfV0s() < fV0sMin) || (EvTag->GetNumOfV0s() > fV0sMax))
+ if(fNeutrMultFlag)
+ if((EvTag->GetNumOfNeutrTracks() < fNeutrMultMin) || (EvTag->GetNumOfNeutrTracks() > fNeutrMultMax))
return kFALSE;
- if(fCascadesFlag)
- if((EvTag->GetNumOfCascades() < fCascadesMin) || (EvTag->GetNumOfCascades() > fCascadesMax))
+ if(fNV0sFlag)
+ if((EvTag->GetNumOfV0s() < fNV0sMin) || (EvTag->GetNumOfV0s() > fNV0sMax))
+ return kFALSE;
+
+ if(fNCascadesFlag)
+ if((EvTag->GetNumOfCascades() < fNCascadesMin) || (EvTag->GetNumOfCascades() > fNCascadesMax))
+ return kFALSE;
+
+ if(fNKinksFlag)
+ if((EvTag->GetNumOfKinks() < fNKinksMin) || (EvTag->GetNumOfKinks() > fNKinksMax))
+ return kFALSE;
+
+
+ if(fNPMDTracksFlag)
+ if((EvTag->GetNumOfPMDTracks() < fNPMDTracksMin) || (EvTag->GetNumOfPMDTracks() > fNPMDTracksMax))
+ return kFALSE;
+ if(fNFMDTracksFlag)
+ if((EvTag->GetNumOfFMDTracks() < fNFMDTracksMin) || (EvTag->GetNumOfFMDTracks() > fNFMDTracksMax))
+ return kFALSE;
+ if(fNPHOSClustersFlag)
+ if((EvTag->GetNumOfPHOSClusters() < fNPHOSClustersMin) || (EvTag->GetNumOfPHOSClusters() > fNPHOSClustersMax))
+ return kFALSE;
+ if(fNEMCALClustersFlag)
+ if((EvTag->GetNumOfEMCALClusters() < fNEMCALClustersMin) || (EvTag->GetNumOfEMCALClusters() > fNEMCALClustersMax))
+ return kFALSE;
+ if(fNJetCandidatesFlag)
+ if((EvTag->GetNumOfJetCandidates() < fNJetCandidatesMin) || (EvTag->GetNumOfJetCandidates() > fNJetCandidatesMax))
+ return kFALSE;
+
+
+ if(fTopJetEnergyMinFlag)
+ if((EvTag->GetMaxJetEnergy() < fTopJetEnergyMin))
return kFALSE;
- if(fkinksFlag)
- if((EvTag->GetNumOfKinks() < fkinksMin) || (EvTag->GetNumOfKinks() > fkinksMax))
+ if(fNHardPhotonCandidatesFlag)
+ if((EvTag->GetNumOfHardPhotonsCandidates() < fNHardPhotonCandidatesMin) || (EvTag->GetNumOfHardPhotonsCandidates() > fNHardPhotonCandidatesMax))
return kFALSE;
- if(fMaxJetEnergyFlag)
- if((EvTag->GetMaxJetEnergy() < fMaxJetEnergy))
+ if(fTopNeutralEnergyMinFlag)
+ if((EvTag->GetMaxNeutralEnergy() < fTopNeutralEnergyMin))
return kFALSE;
- if(fNHardPhotonsCandidatesFlag)
- if((EvTag->GetNumOfHardPhotonsCandidates() < fNHardPhotonsCandidatesMin) || (EvTag->GetNumOfHardPhotonsCandidates() > fNHardPhotonsCandidatesMax))
+ if(fNChargedAbove1GeVFlag)
+ if((EvTag->GetNumOfChargedAbove1GeV() < fNChargedAbove1GeVMin) || (EvTag->GetNumOfChargedAbove1GeV() > fNChargedAbove1GeVMax))
return kFALSE;
- if(fMaxNeutralFlag)
- if((EvTag->GetMaxNeutralEnergy() < fMaxNeutralEnergy))
+ if(fNChargedAbove3GeVFlag)
+ if((EvTag->GetNumOfChargedAbove3GeV() < fNChargedAbove3GeVMin) || (EvTag->GetNumOfChargedAbove3GeV() > fNChargedAbove3GeVMax))
return kFALSE;
- if(fChargedAbove1GeVFlag)
- if((EvTag->GetNumOfChargedAbove1GeV() < fChargedAbove1GeVMin) || (EvTag->GetNumOfChargedAbove1GeV() > fChargedAbove1GeVMax))
+ if(fNChargedAbove10GeVFlag)
+ if((EvTag->GetNumOfChargedAbove10GeV() < fNChargedAbove10GeVMin) || (EvTag->GetNumOfChargedAbove10GeV() > fNChargedAbove10GeVMax))
return kFALSE;
- if(fChargedAbove3GeVFlag)
- if((EvTag->GetNumOfChargedAbove3GeV() < fChargedAbove3GeVMin) || (EvTag->GetNumOfChargedAbove3GeV() > fChargedAbove3GeVMax))
+ if(fNMuonsAbove1GeVFlag)
+ if((EvTag->GetNumOfMuonsAbove1GeV() < fNMuonsAbove1GeVMin) || (EvTag->GetNumOfMuonsAbove1GeV() > fNMuonsAbove1GeVMax))
return kFALSE;
- if(fChargedAbove10GeVFlag)
- if((EvTag->GetNumOfChargedAbove10GeV() < fChargedAbove10GeVMin) || (EvTag->GetNumOfChargedAbove10GeV() > fChargedAbove10GeVMax))
+ if(fNMuonsAbove3GeVFlag)
+ if((EvTag->GetNumOfMuonsAbove3GeV() < fNMuonsAbove3GeVMin) || (EvTag->GetNumOfMuonsAbove3GeV() > fNMuonsAbove3GeVMax))
return kFALSE;
- if(fMuonsAbove1GeVFlag)
- if((EvTag->GetNumOfMuonsAbove1GeV() < fMuonsAbove1GeVMin) || (EvTag->GetNumOfMuonsAbove1GeV() > fMuonsAbove1GeVMax))
+ if(fNMuonsAbove10GeVFlag)
+ if((EvTag->GetNumOfMuonsAbove10GeV() < fNMuonsAbove10GeVMin) || (EvTag->GetNumOfMuonsAbove10GeV() > fNMuonsAbove10GeVMax))
return kFALSE;
- if(fMuonsAbove3GeVFlag)
- if((EvTag->GetNumOfMuonsAbove3GeV() < fMuonsAbove3GeVMin) || (EvTag->GetNumOfMuonsAbove3GeV() > fMuonsAbove3GeVMax))
+ if(fNElectronsAbove1GeVFlag)
+ if((EvTag->GetNumOfElectronsAbove1GeV() < fNElectronsAbove1GeVMin) || (EvTag->GetNumOfElectronsAbove1GeV() > fNElectronsAbove1GeVMax))
return kFALSE;
- if(fMuonsAbove10GeVFlag)
- if((EvTag->GetNumOfMuonsAbove10GeV() < fMuonsAbove10GeVMin) || (EvTag->GetNumOfMuonsAbove10GeV() > fMuonsAbove10GeVMax))
+ if(fNElectronsAbove3GeVFlag)
+ if((EvTag->GetNumOfElectronsAbove3GeV() < fNElectronsAbove3GeVMin) || (EvTag->GetNumOfElectronsAbove3GeV() > fNElectronsAbove3GeVMax))
return kFALSE;
- if(fElectronsAbove1GeVFlag)
- if((EvTag->GetNumOfElectronsAbove1GeV() < fElectronsAbove1GeVMin) || (EvTag->GetNumOfElectronsAbove1GeV() > fElectronsAbove1GeVMax))
+ if(fNElectronsAbove10GeVFlag)
+ if((EvTag->GetNumOfElectronsAbove10GeV() < fNElectronsAbove10GeVMin) || (EvTag->GetNumOfElectronsAbove10GeV() > fNElectronsAbove10GeVMax))
return kFALSE;
- if(fElectronsAbove3GeVFlag)
- if((EvTag->GetNumOfElectronsAbove3GeV() < fElectronsAbove3GeVMin) || (EvTag->GetNumOfElectronsAbove3GeV() > fElectronsAbove3GeVMax))
+ if(fNElectronsFlag)
+ if((EvTag->GetNumOfElectrons() < fNElectronsMin) || (EvTag->GetNumOfElectrons() > fNElectronsMax))
return kFALSE;
- if(fElectronsAbove10GeVFlag)
- if((EvTag->GetNumOfElectronsAbove10GeV() < fElectronsAbove10GeVMin) || (EvTag->GetNumOfElectronsAbove10GeV() > fElectronsAbove10GeVMax))
+ if(fNFWMuonsFlag)
+ if((EvTag->GetNumOfFWMuons() < fNFWMuonsMin) || (EvTag->GetNumOfFWMuons() > fNFWMuonsMax))
return kFALSE;
- if(fElectronsFlag)
- if((EvTag->GetNumOfElectrons() < fElectronsMin) || (EvTag->GetNumOfElectrons() > fElectronsMax))
+ if(fNFWMatchedMuonsFlag)
+ if((EvTag->GetNumOfFWMatchedMuons() < fNFWMatchedMuonsMin) || (EvTag->GetNumOfFWMatchedMuons() > fNFWMatchedMuonsMax))
return kFALSE;
- if(fMuonsFlag)
- if((EvTag->GetNumOfMuons() < fMuonsMin) || (EvTag->GetNumOfMuons() > fMuonsMax))
+ if(fNMuonsFlag)
+ if((EvTag->GetNumOfMuons() < fNMuonsMin) || (EvTag->GetNumOfMuons() > fNMuonsMax))
return kFALSE;
- if(fPionsFlag)
- if((EvTag->GetNumOfPions() < fPionsMin) || (EvTag->GetNumOfPions() > fPionsMax))
+ if(fNPionsFlag)
+ if((EvTag->GetNumOfPions() < fNPionsMin) || (EvTag->GetNumOfPions() > fNPionsMax))
return kFALSE;
- if(fKaonsFlag)
- if((EvTag->GetNumOfKaons() < fKaonsMin) || (EvTag->GetNumOfKaons() > fKaonsMax))
+ if(fNKaonsFlag)
+ if((EvTag->GetNumOfKaons() < fNKaonsMin) || (EvTag->GetNumOfKaons() > fNKaonsMax))
return kFALSE;
- if(fProtonsFlag)
- if((EvTag->GetNumOfProtons() < fProtonsMin) || (EvTag->GetNumOfProtons() > fProtonsMax))
+ if(fNProtonsFlag)
+ if((EvTag->GetNumOfProtons() < fNProtonsMin) || (EvTag->GetNumOfProtons() > fNProtonsMax))
return kFALSE;
- if(fLambdasFlag)
- if((EvTag->GetNumOfLambdas() < fLambdasMin) || (EvTag->GetNumOfLambdas() > fLambdasMax))
+ if(fNLambdasFlag)
+ if((EvTag->GetNumOfLambdas() < fNLambdasMin) || (EvTag->GetNumOfLambdas() > fNLambdasMax))
return kFALSE;
- if(fPhotonFlag)
- if((EvTag->GetNumOfPhotons() < fPhotonsMin) || (EvTag->GetNumOfPhotons() > fPhotonsMax))
+ if(fNPhotonFlag)
+ if((EvTag->GetNumOfPhotons() < fNPhotonsMin) || (EvTag->GetNumOfPhotons() > fNPhotonsMax))
return kFALSE;
- if(fPi0sFlag)
- if((EvTag->GetNumOfPi0s() < fPi0sMin) || (EvTag->GetNumOfPi0s() > fPi0sMax))
+ if(fNPi0sFlag)
+ if((EvTag->GetNumOfPi0s() < fNPi0sMin) || (EvTag->GetNumOfPi0s() > fNPi0sMax))
return kFALSE;
- if(fNeutronsFlag)
- if((EvTag->GetNumOfNeutrons() < fNeutronsMin) || (EvTag->GetNumOfNeutrons() > fNeutronsMax))
+ if(fNNeutronsFlag)
+ if((EvTag->GetNumOfNeutrons() < fNNeutronsMin) || (EvTag->GetNumOfNeutrons() > fNNeutronsMax))
return kFALSE;
- if(fKaon0sFlag)
- if((EvTag->GetNumOfKaon0s() < fKaon0sMin) || (EvTag->GetNumOfKaon0s() > fKaon0sMax))
+ if(fNKaon0sFlag)
+ if((EvTag->GetNumOfKaon0s() < fNKaon0sMin) || (EvTag->GetNumOfKaon0s() > fNKaon0sMax))
return kFALSE;
if(fTotalPFlag)
if((EvTag->GetMeanPt() < fMeanPtMin) || (EvTag->GetMeanPt() > fMeanPtMax))
return kFALSE;
- if(fMaxPtFlag)
- if((EvTag->GetMaxPt() < fMaxPt))
+ if(fTopPtMinFlag)
+ if((EvTag->GetMaxPt() < fTopPtMin))
return kFALSE;
if(fTotalNeutralPFlag)
if((EvTag->GetNeutralMeanPt() < fMeanNeutralPtMin) || (EvTag->GetNeutralMeanPt() >fMeanNeutralPtMax ))
return kFALSE;
- if(fMaxNeutralPtFlag)
- if((EvTag->GetNeutralMaxPt() < fMaxNeutralPt))
+ if(fTopNeutralPtMinFlag)
+ if((EvTag->GetNeutralMaxPt() < fTopNeutralPtMin))
return kFALSE;
if(fEventPlaneAngleFlag)
if(fHBTRadiiFlag)
if((EvTag->GetHBTRadii() < fHBTRadiiMin) || (EvTag->GetHBTRadii() > fHBTRadiiMax))
return kFALSE;
+
+ if (fFiredTriggerCleassFlag)
+ if (!EvTag->GetFiredTriggerClasses().Contains(fFiredTriggerCleass))
+ return kFALSE;
return kTRUE;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff