//___________________________________________________________________________
AliEventTagCuts::AliEventTagCuts() :
TObject(),
-
-
-
fVxMin(-1000.0), fVxMax(1000.0),
fVxFlag(kFALSE),
fVyFlag(kFALSE),
fVzMin(-1000.0), fVzMax(1000.0),
fVzFlag(kFALSE),
- fParticipantsMin(-1), fParticipantMax(10000),
- fParticipantsFlag(kFALSE),
+ fNParticipantsMin(-1), fNParticipantsMax(10000),
+ fNParticipantsFlag(kFALSE),
fImpactParamMin(-1.0), fImpactParamMax(1000.0),
fImpactParamFlag(kFALSE),
fPrimaryVertexFlag(1),
fT0VertexZFlag(kFALSE),
fMultMin(0), fMultMax(100000),
fMultFlag(kFALSE),
- fMultPosMin(-1), fMultPosMax(100000),
- fMultPosFlag(kFALSE),
- fMultNegMin(-1), fMultNegMax(100000),
- fMultNegFlag(kFALSE),
- fMultNeutrMin(-1), fMultNeutrMax(100000),
- fMultNeutrFlag(kFALSE),
- fV0sMin(-1), fV0sMax(1000000),
- fV0sFlag(kFALSE),
- fCascadesMin(-1), fCascadesMax(100000),
- fCascadesFlag(kFALSE),
- fkinksMin(-1), fkinksMax(1000000),
- fkinksFlag(kFALSE),
-
- fPMDTracksMin(-1), fPMDTracksMax(100000),
- fPMDTracksFlag(kFALSE),
- fFMDTracksMin(-1), fFMDTracksMax(100000),
- fFMDTracksFlag(kFALSE),
- fPHOSClustersMin(-1), fPHOSClustersMax(100000),
- fPHOSClustersFlag(kFALSE),
- fEMCALClustersMin(-1), fEMCALClustersMax(100000),
- fEMCALClustersFlag(kFALSE),
- fJetCandidatesMin(-1), fJetCandidatesMax(100000),
- fJetCandidatesFlag(kFALSE),
-
- fMaxJetEnergy(-1.0),
- fMaxJetEnergyFlag(kFALSE),
- fNHardPhotonsCandidatesMin(-1), fNHardPhotonsCandidatesMax(100000),
- fNHardPhotonsCandidatesFlag(kFALSE),
- fMaxNeutralEnergy(-1.0),
- fMaxNeutralFlag(kFALSE),
- fChargedAbove1GeVMin(-1), fChargedAbove1GeVMax(100000),
- fChargedAbove1GeVFlag(kFALSE),
- fChargedAbove3GeVMin(-1), fChargedAbove3GeVMax(100000),
- fChargedAbove3GeVFlag(kFALSE),
- fChargedAbove10GeVMin(-1), fChargedAbove10GeVMax(100000),
- fChargedAbove10GeVFlag(kFALSE),
- fMuonsAbove1GeVMin(-1), fMuonsAbove1GeVMax(100000),
- fMuonsAbove1GeVFlag(kFALSE),
- fMuonsAbove3GeVMin(-1), fMuonsAbove3GeVMax(100000),
- fMuonsAbove3GeVFlag(kFALSE),
- fMuonsAbove10GeVMin(-1), fMuonsAbove10GeVMax(100000),
- fMuonsAbove10GeVFlag(kFALSE),
- fElectronsAbove1GeVMin(-1), fElectronsAbove1GeVMax(100000),
- fElectronsAbove1GeVFlag(kFALSE),
- fElectronsAbove3GeVMin(-1), fElectronsAbove3GeVMax(100000),
- fElectronsAbove3GeVFlag(kFALSE),
- fElectronsAbove10GeVMin(-1), fElectronsAbove10GeVMax(100000),
- fElectronsAbove10GeVFlag(kFALSE),
- fElectronsMin(-1), fElectronsMax(100000),
- fElectronsFlag(kFALSE),
- fMuonsMin(-1), fMuonsMax(100000),
- fMuonsFlag(kFALSE),
- fPionsMin(-1), fPionsMax(100000),
- fPionsFlag(kFALSE),
- fKaonsMin(-1), fKaonsMax(100000),
- fKaonsFlag(kFALSE),
- fProtonsMin(-1), fProtonsMax(100000),
- fProtonsFlag(kFALSE),
- fLambdasMin(-1), fLambdasMax(100000),
- fLambdasFlag(kFALSE),
- fPhotonsMin(-1), fPhotonsMax(100000),
- fPhotonFlag(kFALSE),
- fPi0sMin(-1), fPi0sMax(100000),
- fPi0sFlag(kFALSE),
- fNeutronsMin(-1), fNeutronsMax(100000),
- fNeutronsFlag(kFALSE),
- fKaon0sMin(-1), fKaon0sMax(100000),
- fKaon0sFlag(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),
+ fNHardPhotonCandidatesMin(-1), fNHardPhotonCandidatesMax(100000),
+ fNHardPhotonCandidatesFlag(kFALSE),
+ fTopNeutralEnergyMin(-1.0),
+ fTopNeutralEnergyMinFlag(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),
+ 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),
- fMaxPt(-1.0),
- fMaxPtFlag(kFALSE),
+ fTopPtMin(-1.0),
+ fTopPtMinFlag(kFALSE),
fTotalNeutralPMin(-1.0), fTotalNeutralPMax(1000000.0),
fTotalNeutralPFlag(kFALSE),
fMeanNeutralPtMin(-1.0), fMeanNeutralPtMax(1000000.0),
fMeanNeutralPtFlag(kFALSE),
- fMaxNeutralPt(-1.0),
- fMaxNeutralPtFlag(kFALSE),
+ fTopNeutralPtMin(-1.0),
+ fTopNeutralPtMinFlag(kFALSE),
fEventPlaneAngleMin(-10000000.0), fEventPlaneAngleMax(10000000.0),
fEventPlaneAngleFlag(kFALSE),
fHBTRadiiMin(-1.0), fHBTRadiiMax(100000.0),
//___________________________________________________________________________
void AliEventTagCuts::Reset() {
//Sets dummy values to every private member.
+ fNParticipantsFlag = kFALSE;
+ fImpactParamFlag = kFALSE;
+
fVxFlag = kFALSE;
fVyFlag = kFALSE;
fVzFlag = kFALSE;
- fParticipantsFlag = kFALSE;
- fImpactParamFlag = kFALSE;
fPVFlag = kFALSE;
-
fPVzErrorFlag = kFALSE;
+
fTriggerMaskFlag = kFALSE;
fTriggerClusterFlag = kFALSE;
fZDCEMEnergyFlag = kFALSE;
fT0VertexZFlag = kFALSE;
fMultFlag = kFALSE;
- fMultPosFlag = kFALSE;
- fMultNegFlag = kFALSE;
- fMultNeutrFlag = kFALSE;
- fV0sFlag = kFALSE;
- fCascadesFlag = kFALSE;
- fkinksFlag = kFALSE;
-
- fPMDTracksFlag = kFALSE;
- fFMDTracksFlag = kFALSE;
- fPHOSClustersFlag = kFALSE;
- fEMCALClustersFlag = kFALSE;
- fJetCandidatesFlag = 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;
+ 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;
- fParticipantsMin = -1; fParticipantMax = 10000;
+ fNParticipantsMin = -1; fNParticipantsMax = 10000;
fImpactParamMin = -1.0; fImpactParamMax = 1000.0;
fPrimaryVertexFlag = 1;
fZDCEMEnergyMin = -1.0; fZDCEMEnergyMax = 100000.0;
fT0VertexZMin = -10000.0; fT0VertexZMax = 10000.0;
fMultMin = 0; fMultMax = 100000;
- fMultPosMin = -1; fMultPosMax = 100000;
- fMultNegMin = -1; fMultNegMax = 100000;
- fMultNeutrMin = -1; fMultNeutrMax = 100000;
- fV0sMin = -1; fV0sMax = 1000000;
- fCascadesMin = -1; fCascadesMax = 100000;
- fkinksMin = -1; fkinksMax = 1000000;
-
- fPMDTracksMin = -1, fPMDTracksMax = 100000;
- fFMDTracksMin = -1, fFMDTracksMax = 100000;
- fPHOSClustersMin = -1, fPHOSClustersMax = 100000;
- fEMCALClustersMin = -1, fEMCALClustersMax = 100000;
- fJetCandidatesMin = -1, fJetCandidatesMax = 100000;
-
- 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;
+ 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;
+ 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;
- fMaxPt = -1.0; fTotalNeutralPMin = -1.0;
+ fTopPtMin = -1.0; fTotalNeutralPMin = -1.0;
fTotalNeutralPMax = 1000000.0;
fMeanNeutralPtMin = -1.0; fMeanNeutralPtMax = 1000000.0;
- fMaxNeutralPt = -1.0;
+ fTopNeutralPtMin = -1.0;
fEventPlaneAngleMin = -10000000.0; fEventPlaneAngleMax = 10000000.0;
fHBTRadiiMin = -1.0; fHBTRadiiMax = 100000.0;
}
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 = low;
- fParticipantMax = high;
- fParticipantsFlag = kTRUE;
+ fNParticipantsMin = low;
+ fNParticipantsMax = high;
+ fNParticipantsFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fMultPosMax = high;
- fMultPosFlag = kTRUE;
+ fPosMultMin = low;
+ fPosMultMax = high;
+ fPosMultFlag = kTRUE;
}
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 = low;
- fMultNegMax = high;
- fMultNegFlag = kTRUE;
+ fNegMultMin = low;
+ fNegMultMax = high;
+ fNegMultFlag = kTRUE;
}
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 = low;
- fMultNeutrMax = high;
- fMultNeutrFlag = kTRUE;
+ fNeutrMultMin = low;
+ fNeutrMultMax = high;
+ fNeutrMultFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fV0sMax = high;
- fV0sFlag = kTRUE;
+ fNV0sMin = low;
+ fNV0sMax = high;
+ fNV0sFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fCascadesMax = high;
- fCascadesFlag = kTRUE;
+ fNCascadesMin = low;
+ fNCascadesMax = high;
+ fNCascadesFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fkinksMax = high;
- fkinksFlag = kTRUE;
+ fNKinksMin = low;
+ fNKinksMax = high;
+ fNKinksFlag = kTRUE;
}
//___________________________________________________________________________
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.
- fPMDTracksMin = low;
- fPMDTracksMax = high;
- fPMDTracksFlag = kTRUE;
+ 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.
- fFMDTracksMin = low;
- fFMDTracksMax = high;
- fFMDTracksFlag = kTRUE;
+ 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.
- fPHOSClustersMin = low;
- fPHOSClustersMax = high;
- fPHOSClustersFlag = kTRUE;
+ 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.
- fEMCALClustersMin = low;
- fEMCALClustersMax = high;
- fEMCALClustersFlag = kTRUE;
+ 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.
- fJetCandidatesMin = low;
- fJetCandidatesMax = high;
- fJetCandidatesFlag = kTRUE;
+ 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 = low;
- fMaxJetEnergyFlag = kTRUE;
+ fTopJetEnergyMin = low;
+ fTopJetEnergyMinFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fMaxNeutralFlag = kTRUE;
+ fTopNeutralEnergyMin = low;
+ fTopNeutralEnergyMinFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fNHardPhotonsCandidatesMax = high;
- fNHardPhotonsCandidatesFlag = kTRUE;
+ fNHardPhotonCandidatesMin = low;
+ fNHardPhotonCandidatesMax = high;
+ fNHardPhotonCandidatesFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fChargedAbove1GeVMax = high;
- fChargedAbove1GeVFlag = kTRUE;
+ fNChargedAbove1GeVMin = low;
+ fNChargedAbove1GeVMax = high;
+ fNChargedAbove1GeVFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fChargedAbove3GeVMax = high;
- fChargedAbove3GeVFlag = kTRUE;
+ fNChargedAbove3GeVMin = low;
+ fNChargedAbove3GeVMax = high;
+ fNChargedAbove3GeVFlag = kTRUE;
}
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 = low;
- fChargedAbove10GeVMax = high;
- fChargedAbove10GeVFlag = kTRUE;
+ fNChargedAbove10GeVMin = low;
+ fNChargedAbove10GeVMax = high;
+ fNChargedAbove10GeVFlag = kTRUE;
}
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 = low;
- fMuonsAbove1GeVMax = high;
- fMuonsAbove1GeVFlag = kTRUE;
+ fNMuonsAbove1GeVMin = low;
+ fNMuonsAbove1GeVMax = high;
+ fNMuonsAbove1GeVFlag = kTRUE;
}
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 = low;
- fMuonsAbove3GeVMax = high;
- fMuonsAbove3GeVFlag = kTRUE;
+ fNMuonsAbove3GeVMin = low;
+ fNMuonsAbove3GeVMax = high;
+ fNMuonsAbove3GeVFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fMuonsAbove10GeVMax = high;
- fMuonsAbove10GeVFlag = kTRUE;
+ fNMuonsAbove10GeVMin = low;
+ fNMuonsAbove10GeVMax = high;
+ fNMuonsAbove10GeVFlag = kTRUE;
}
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 = low;
- fElectronsAbove1GeVMax = high;
- fElectronsAbove1GeVFlag = kTRUE;
+ fNElectronsAbove1GeVMin = low;
+ fNElectronsAbove1GeVMax = high;
+ fNElectronsAbove1GeVFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fElectronsAbove3GeVMax = high;
- fElectronsAbove3GeVFlag = kTRUE;
+ fNElectronsAbove3GeVMin = low;
+ fNElectronsAbove3GeVMax = high;
+ fNElectronsAbove3GeVFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fElectronsAbove10GeVMax = high;
- fElectronsAbove10GeVFlag = kTRUE;
+ fNElectronsAbove10GeVMin = low;
+ fNElectronsAbove10GeVMax = high;
+ fNElectronsAbove10GeVFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fElectronsMax = high;
- fElectronsFlag = kTRUE;
+ fNElectronsMin = low;
+ fNElectronsMax = high;
+ fNElectronsFlag = 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 = low;
- fMuonsMax = high;
- fMuonsFlag = kTRUE;
+ fNMuonsMin = low;
+ fNMuonsMax = high;
+ fNMuonsFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fPionsMax = high;
- fPionsFlag = kTRUE;
+ fNPionsMin = low;
+ fNPionsMax = high;
+ fNPionsFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fKaonsMax = high;
- fKaonsFlag = kTRUE;
+ fNKaonsMin = low;
+ fNKaonsMax = high;
+ fNKaonsFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fProtonsMax = high;
- fProtonsFlag = kTRUE;
+ fNProtonsMin = low;
+ fNProtonsMax = high;
+ fNProtonsFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fLambdasMax = high;
- fLambdasFlag = kTRUE;
+ fNLambdasMin = low;
+ fNLambdasMax = high;
+ fNLambdasFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fPhotonsMax = high;
- fPhotonFlag = kTRUE;
+ fNPhotonsMin = low;
+ fNPhotonsMax = high;
+ fNPhotonFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fPi0sMax = high;
- fPi0sFlag = kTRUE;
+ fNPi0sMin = low;
+ fNPi0sMax = high;
+ fNPi0sFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fNeutronsMax = high;
- fNeutronsFlag = kTRUE;
+ fNNeutronsMin = low;
+ fNNeutronsMax = high;
+ fNNeutronsFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fKaon0sMax = high;
- fKaon0sFlag = kTRUE;
+ fNKaon0sMin = low;
+ fNKaon0sMax = high;
+ fNKaon0sFlag = kTRUE;
}
//___________________________________________________________________________
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 = low;
- fMaxPtFlag = kTRUE;
+ fTopPtMin = low;
+ fTopPtMinFlag = kTRUE;
}
//___________________________________________________________________________
fMeanNeutralPtMin = low;
fMeanNeutralPtMax = high;
fMeanNeutralPtFlag = kTRUE;
-}
+}
//___________________________________________________________________________
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 = low;
- fMaxNeutralPtFlag = kTRUE;
+ fTopNeutralPtMin = low;
+ fTopNeutralPtMinFlag = kTRUE;
}
//___________________________________________________________________________
-void AliEventTagCuts::SetEvPlaneAngleRange(Float_t low, Float_t high) {
+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 = low;
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(fMultFlag)
if((EvTag->GetNumOfTracks() < fMultMin) || (EvTag->GetNumOfTracks() > fMultMax))
return kFALSE;
- if(fMultPosFlag)
- if((EvTag->GetNumOfPosTracks() < fMultPosMin) || (EvTag->GetNumOfPosTracks() > fMultPosMax))
+
+ if(fPosMultFlag)
+ if((EvTag->GetNumOfPosTracks() < fPosMultMin) || (EvTag->GetNumOfPosTracks() > fPosMultMax))
return kFALSE;
- if(fMultNegFlag)
- if((EvTag->GetNumOfNegTracks() < fMultNegMin) || (EvTag->GetNumOfNegTracks() > fMultNegMax))
+ if(fNegMultFlag)
+ if((EvTag->GetNumOfNegTracks() < fNegMultMin) || (EvTag->GetNumOfNegTracks() > fNegMultMax))
return kFALSE;
- if(fMultNeutrFlag)
- if((EvTag->GetNumOfNeutrTracks() < fMultNeutrMin) || (EvTag->GetNumOfNeutrTracks() > fMultNeutrMax))
+ if(fNeutrMultFlag)
+ if((EvTag->GetNumOfNeutrTracks() < fNeutrMultMin) || (EvTag->GetNumOfNeutrTracks() > fNeutrMultMax))
return kFALSE;
- if(fV0sFlag)
- if((EvTag->GetNumOfV0s() < fV0sMin) || (EvTag->GetNumOfV0s() > fV0sMax))
+ if(fNV0sFlag)
+ if((EvTag->GetNumOfV0s() < fNV0sMin) || (EvTag->GetNumOfV0s() > fNV0sMax))
return kFALSE;
- if(fCascadesFlag)
- if((EvTag->GetNumOfCascades() < fCascadesMin) || (EvTag->GetNumOfCascades() > fCascadesMax))
+ if(fNCascadesFlag)
+ if((EvTag->GetNumOfCascades() < fNCascadesMin) || (EvTag->GetNumOfCascades() > fNCascadesMax))
return kFALSE;
- if(fkinksFlag)
- if((EvTag->GetNumOfKinks() < fkinksMin) || (EvTag->GetNumOfKinks() > fkinksMax))
+ if(fNKinksFlag)
+ if((EvTag->GetNumOfKinks() < fNKinksMin) || (EvTag->GetNumOfKinks() > fNKinksMax))
return kFALSE;
- if(fPMDTracksFlag)
- if((EvTag->GetNumOfPMDTracks() < fPMDTracksMin) || (EvTag->GetNumOfPMDTracks() > fPMDTracksMax))
+ if(fNPMDTracksFlag)
+ if((EvTag->GetNumOfPMDTracks() < fNPMDTracksMin) || (EvTag->GetNumOfPMDTracks() > fNPMDTracksMax))
return kFALSE;
- if(fFMDTracksFlag)
- if((EvTag->GetNumOfFMDTracks() < fFMDTracksMin) || (EvTag->GetNumOfFMDTracks() > fFMDTracksMax))
+ if(fNFMDTracksFlag)
+ if((EvTag->GetNumOfFMDTracks() < fNFMDTracksMin) || (EvTag->GetNumOfFMDTracks() > fNFMDTracksMax))
return kFALSE;
- if(fPHOSClustersFlag)
- if((EvTag->GetNumOfPHOSClusters() < fPHOSClustersMin) || (EvTag->GetNumOfPHOSClusters() > fPHOSClustersMax))
+ if(fNPHOSClustersFlag)
+ if((EvTag->GetNumOfPHOSClusters() < fNPHOSClustersMin) || (EvTag->GetNumOfPHOSClusters() > fNPHOSClustersMax))
return kFALSE;
- if(fEMCALClustersFlag)
- if((EvTag->GetNumOfEMCALClusters() < fEMCALClustersMin) || (EvTag->GetNumOfEMCALClusters() > fEMCALClustersMax))
+ if(fNEMCALClustersFlag)
+ if((EvTag->GetNumOfEMCALClusters() < fNEMCALClustersMin) || (EvTag->GetNumOfEMCALClusters() > fNEMCALClustersMax))
return kFALSE;
- if(fJetCandidatesFlag)
- if((EvTag->GetNumOfJetCandidates() < fJetCandidatesMin) || (EvTag->GetNumOfJetCandidates() > fJetCandidatesMax))
+ if(fNJetCandidatesFlag)
+ if((EvTag->GetNumOfJetCandidates() < fNJetCandidatesMin) || (EvTag->GetNumOfJetCandidates() > fNJetCandidatesMax))
return kFALSE;
- if(fMaxJetEnergyFlag)
- if((EvTag->GetMaxJetEnergy() < fMaxJetEnergy))
+ if(fTopJetEnergyMinFlag)
+ if((EvTag->GetMaxJetEnergy() < fTopJetEnergyMin))
return kFALSE;
- if(fNHardPhotonsCandidatesFlag)
- if((EvTag->GetNumOfHardPhotonsCandidates() < fNHardPhotonsCandidatesMin) || (EvTag->GetNumOfHardPhotonsCandidates() > fNHardPhotonsCandidatesMax))
+ if(fNHardPhotonCandidatesFlag)
+ if((EvTag->GetNumOfHardPhotonsCandidates() < fNHardPhotonCandidatesMin) || (EvTag->GetNumOfHardPhotonsCandidates() > fNHardPhotonCandidatesMax))
return kFALSE;
- if(fMaxNeutralFlag)
- if((EvTag->GetMaxNeutralEnergy() < fMaxNeutralEnergy))
+ if(fTopNeutralEnergyMinFlag)
+ if((EvTag->GetMaxNeutralEnergy() < fTopNeutralEnergyMin))
return kFALSE;
- if(fChargedAbove1GeVFlag)
- if((EvTag->GetNumOfChargedAbove1GeV() < fChargedAbove1GeVMin) || (EvTag->GetNumOfChargedAbove1GeV() > fChargedAbove1GeVMax))
+ if(fNChargedAbove1GeVFlag)
+ if((EvTag->GetNumOfChargedAbove1GeV() < fNChargedAbove1GeVMin) || (EvTag->GetNumOfChargedAbove1GeV() > fNChargedAbove1GeVMax))
return kFALSE;
- if(fChargedAbove3GeVFlag)
- if((EvTag->GetNumOfChargedAbove3GeV() < fChargedAbove3GeVMin) || (EvTag->GetNumOfChargedAbove3GeV() > fChargedAbove3GeVMax))
+ if(fNChargedAbove3GeVFlag)
+ if((EvTag->GetNumOfChargedAbove3GeV() < fNChargedAbove3GeVMin) || (EvTag->GetNumOfChargedAbove3GeV() > fNChargedAbove3GeVMax))
return kFALSE;
- if(fChargedAbove10GeVFlag)
- if((EvTag->GetNumOfChargedAbove10GeV() < fChargedAbove10GeVMin) || (EvTag->GetNumOfChargedAbove10GeV() > fChargedAbove10GeVMax))
+ if(fNChargedAbove10GeVFlag)
+ if((EvTag->GetNumOfChargedAbove10GeV() < fNChargedAbove10GeVMin) || (EvTag->GetNumOfChargedAbove10GeV() > fNChargedAbove10GeVMax))
return kFALSE;
- if(fMuonsAbove1GeVFlag)
- if((EvTag->GetNumOfMuonsAbove1GeV() < fMuonsAbove1GeVMin) || (EvTag->GetNumOfMuonsAbove1GeV() > fMuonsAbove1GeVMax))
+ if(fNMuonsAbove1GeVFlag)
+ if((EvTag->GetNumOfMuonsAbove1GeV() < fNMuonsAbove1GeVMin) || (EvTag->GetNumOfMuonsAbove1GeV() > fNMuonsAbove1GeVMax))
return kFALSE;
- if(fMuonsAbove3GeVFlag)
- if((EvTag->GetNumOfMuonsAbove3GeV() < fMuonsAbove3GeVMin) || (EvTag->GetNumOfMuonsAbove3GeV() > fMuonsAbove3GeVMax))
+ if(fNMuonsAbove3GeVFlag)
+ if((EvTag->GetNumOfMuonsAbove3GeV() < fNMuonsAbove3GeVMin) || (EvTag->GetNumOfMuonsAbove3GeV() > fNMuonsAbove3GeVMax))
return kFALSE;
- if(fMuonsAbove10GeVFlag)
- if((EvTag->GetNumOfMuonsAbove10GeV() < fMuonsAbove10GeVMin) || (EvTag->GetNumOfMuonsAbove10GeV() > fMuonsAbove10GeVMax))
+ if(fNMuonsAbove10GeVFlag)
+ if((EvTag->GetNumOfMuonsAbove10GeV() < fNMuonsAbove10GeVMin) || (EvTag->GetNumOfMuonsAbove10GeV() > fNMuonsAbove10GeVMax))
return kFALSE;
- if(fElectronsAbove1GeVFlag)
- if((EvTag->GetNumOfElectronsAbove1GeV() < fElectronsAbove1GeVMin) || (EvTag->GetNumOfElectronsAbove1GeV() > fElectronsAbove1GeVMax))
+ if(fNElectronsAbove1GeVFlag)
+ if((EvTag->GetNumOfElectronsAbove1GeV() < fNElectronsAbove1GeVMin) || (EvTag->GetNumOfElectronsAbove1GeV() > fNElectronsAbove1GeVMax))
return kFALSE;
- if(fElectronsAbove3GeVFlag)
- if((EvTag->GetNumOfElectronsAbove3GeV() < fElectronsAbove3GeVMin) || (EvTag->GetNumOfElectronsAbove3GeV() > fElectronsAbove3GeVMax))
+ if(fNElectronsAbove3GeVFlag)
+ if((EvTag->GetNumOfElectronsAbove3GeV() < fNElectronsAbove3GeVMin) || (EvTag->GetNumOfElectronsAbove3GeV() > fNElectronsAbove3GeVMax))
return kFALSE;
- if(fElectronsAbove10GeVFlag)
- if((EvTag->GetNumOfElectronsAbove10GeV() < fElectronsAbove10GeVMin) || (EvTag->GetNumOfElectronsAbove10GeV() > fElectronsAbove10GeVMax))
+ if(fNElectronsAbove10GeVFlag)
+ if((EvTag->GetNumOfElectronsAbove10GeV() < fNElectronsAbove10GeVMin) || (EvTag->GetNumOfElectronsAbove10GeV() > fNElectronsAbove10GeVMax))
return kFALSE;
- if(fElectronsFlag)
- if((EvTag->GetNumOfElectrons() < fElectronsMin) || (EvTag->GetNumOfElectrons() > fElectronsMax))
+ if(fNElectronsFlag)
+ if((EvTag->GetNumOfElectrons() < fNElectronsMin) || (EvTag->GetNumOfElectrons() > fNElectronsMax))
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)
void SetTotalNeutralPRange(Float_t low, Float_t high);
void SetMeanNeutralPtPRange(Float_t low, Float_t high);
void SetTopNeutralPtMin(Float_t low);
- void SetEvPlaneAngleRange(Float_t low, Float_t high);
+ void SetEventPlaneAngleRange(Float_t low, Float_t high);
void SetHBTRadiiRange(Float_t low, Float_t high);
Bool_t IsAccepted(AliEventTag *EvTag) const;
//____________________________________________________//
private:
- Float_t fVxMin, fVxMax; //Definition of the range of the Vx
- Bool_t fVxFlag; //Shows whether this cut is used or not
- Float_t fVyMin, fVyMax; //Definition of the range of the Vy
- Bool_t fVyFlag; //Shows whether this cut is used or not
- Float_t fVzMin, fVzMax; //Definition of the range of the Vz
- Bool_t fVzFlag; //Shows whether this cut is used or not
- Int_t fParticipantsMin, fParticipantMax; //# participants range
- Bool_t fParticipantsFlag;//Shows whether this cut is used or not
- Float_t fImpactParamMin, fImpactParamMax; //Impact parameter range
- Bool_t fImpactParamFlag; //Shows whether this cut is used or not
- Int_t fPrimaryVertexFlag; //Primary vertex flag: 0->not found, 1->found
- Bool_t fPVFlag; //Shows whether this cut is used or not
-
- Float_t fPrimaryVertexZErrorMin, fPrimaryVertexZErrorMax; //Range of the primary vertex z error
- Bool_t fPVzErrorFlag; //Shows whether this cut is used or not
- ULong64_t fTriggerMask; //trigger mask definition
- Bool_t fTriggerMaskFlag; //Shows whether this cut is used or not
- UChar_t fTriggerCluster; //trigger cluster definition
- Bool_t fTriggerClusterFlag; //Shows whether this cut is used or not
+ Int_t fNParticipantsMin, fNParticipantsMax; // # participants range
+ Bool_t fNParticipantsFlag; // Shows whether this cut is used or not
+ Float_t fImpactParamMin, fImpactParamMax; // Impact parameter range
+ Bool_t fImpactParamFlag; // Shows whether this cut is used or not
+
+ Float_t fVxMin, fVxMax; // Definition of the range of the Vx
+ Bool_t fVxFlag; // Shows whether this cut is used or not
+ Float_t fVyMin, fVyMax; // Definition of the range of the Vy
+ Bool_t fVyFlag; // Shows whether this cut is used or not
+ Float_t fVzMin, fVzMax; // Definition of the range of the Vz
+ Bool_t fVzFlag; // Shows whether this cut is used or not
+ Int_t fPrimaryVertexFlag; // Primary vertex flag: 0->not found, 1->found
+ Bool_t fPVFlag; // Shows whether this cut is used or not
+ Float_t fPrimaryVertexZErrorMin, fPrimaryVertexZErrorMax; // Range of the primary vertex z error
+ Bool_t fPVzErrorFlag; // Shows whether this cut is used or not
+
+ ULong64_t fTriggerMask; // trigger mask definition
+ Bool_t fTriggerMaskFlag; // Shows whether this cut is used or not
+ UChar_t fTriggerCluster; // trigger cluster definition
+ Bool_t fTriggerClusterFlag; // Shows whether this cut is used or not
- Float_t fZDCNeutron1EnergyMin, fZDCNeutron1EnergyMax; //ZDC min,max - neutron
- Bool_t fZDCNeutron1EnergyFlag;//Shows whether this cut is used or not
- Float_t fZDCProton1EnergyMin, fZDCProton1EnergyMax; //ZDC min,max - proton
- Bool_t fZDCProton1EnergyFlag;//Shows whether this cut is used or not
- Float_t fZDCNeutron2EnergyMin, fZDCNeutron2EnergyMax; //ZDC min,max - neutron
- Bool_t fZDCNeutron2EnergyFlag;//Shows whether this cut is used or not
- Float_t fZDCProton2EnergyMin, fZDCProton2EnergyMax; //ZDC min,max - proton
- Bool_t fZDCProton2EnergyFlag;//Shows whether this cut is used or not
- Float_t fZDCEMEnergyMin, fZDCEMEnergyMax; //ZDC min,max - em
- Bool_t fZDCEMEnergyFlag;//Shows whether this cut is used or not
- Float_t fT0VertexZMin, fT0VertexZMax; //T0 min, max
- Bool_t fT0VertexZFlag;//Shows whether this cut is used or not
- Int_t fMultMin, fMultMax; //Definition of the range of the multiplicity
- Bool_t fMultFlag;//Shows whether this cut is used or not
- Int_t fMultPosMin, fMultPosMax; //Positive tracks multiplicity range
- Bool_t fMultPosFlag;//Shows whether this cut is used or not
- Int_t fMultNegMin, fMultNegMax; //Negative tracks multiplicity range
- Bool_t fMultNegFlag;//Shows whether this cut is used or not
- Int_t fMultNeutrMin, fMultNeutrMax; //Neutral tracks multiplicity range
- Bool_t fMultNeutrFlag;//Shows whether this cut is used or not
- Int_t fV0sMin, fV0sMax; //Range of V0s
- Bool_t fV0sFlag;//Shows whether this cut is used or not
- Int_t fCascadesMin, fCascadesMax; //Range of cascades
- Bool_t fCascadesFlag;//Shows whether this cut is used or not
- Int_t fkinksMin, fkinksMax; //Range of kinks
- Bool_t fkinksFlag;//Shows whether this cut is used or not
+ Float_t fZDCNeutron1EnergyMin, fZDCNeutron1EnergyMax; // ZDC min,max - neutron
+ Bool_t fZDCNeutron1EnergyFlag; // Shows whether this cut is used or not
+ Float_t fZDCProton1EnergyMin, fZDCProton1EnergyMax; // ZDC min,max - proton
+ Bool_t fZDCProton1EnergyFlag; // Shows whether this cut is used or not
+ Float_t fZDCNeutron2EnergyMin, fZDCNeutron2EnergyMax; // ZDC min,max - neutron
+ Bool_t fZDCNeutron2EnergyFlag; // Shows whether this cut is used or not
+ Float_t fZDCProton2EnergyMin, fZDCProton2EnergyMax; // ZDC min,max - proton
+ Bool_t fZDCProton2EnergyFlag; // Shows whether this cut is used or not
+ Float_t fZDCEMEnergyMin, fZDCEMEnergyMax; // ZDC min,max - em
+ Bool_t fZDCEMEnergyFlag; // Shows whether this cut is used or not
+ Float_t fT0VertexZMin, fT0VertexZMax; // T0 min, max
+ Bool_t fT0VertexZFlag; // Shows whether this cut is used or not
+
+ Int_t fMultMin, fMultMax; // Definition of the range of the multiplicity
+ Bool_t fMultFlag; // Shows whether this cut is used or not
+ Int_t fPosMultMin, fPosMultMax; // Positive tracks multiplicity range
+ Bool_t fPosMultFlag; // Shows whether this cut is used or not
+ Int_t fNegMultMin, fNegMultMax; // Negative tracks multiplicity range
+ Bool_t fNegMultFlag; // Shows whether this cut is used or not
+ Int_t fNeutrMultMin, fNeutrMultMax; // Neutral tracks multiplicity range
+ Bool_t fNeutrMultFlag; // Shows whether this cut is used or not
+ Int_t fNV0sMin, fNV0sMax; // Range of # of V0s
+ Bool_t fNV0sFlag; // Shows whether this cut is used or not
+ Int_t fNCascadesMin, fNCascadesMax; // Range of # of cascades
+ Bool_t fNCascadesFlag; // Shows whether this cut is used or not
+ Int_t fNKinksMin, fNKinksMax; // Range of # of kinks
+ Bool_t fNKinksFlag; // Shows whether this cut is used or not
- Int_t fPMDTracksMin, fPMDTracksMax; //Range of PMD tracks
- Bool_t fPMDTracksFlag;//Shows whether this cut is used or not
- Int_t fFMDTracksMin, fFMDTracksMax; //Range of FMD tracks
- Bool_t fFMDTracksFlag;//Shows whether this cut is used or not
- Int_t fPHOSClustersMin, fPHOSClustersMax; //Range of PHOS clusters
- Bool_t fPHOSClustersFlag;//Shows whether this cut is used or not
- Int_t fEMCALClustersMin, fEMCALClustersMax; //Range of EMCAL clusters
- Bool_t fEMCALClustersFlag;//Shows whether this cut is used or not
- Int_t fJetCandidatesMin, fJetCandidatesMax; //Range of jet candidates
- Bool_t fJetCandidatesFlag;//Shows whether this cut is used or not
-
- Float_t fMaxJetEnergy; //max jet energy info
- Bool_t fMaxJetEnergyFlag;//Shows whether this cut is used or not
+ Int_t fNPMDTracksMin, fNPMDTracksMax; // Range of # of PMD tracks
+ Bool_t fNPMDTracksFlag; // Shows whether this cut is used or not
+ Int_t fNFMDTracksMin, fNFMDTracksMax; // Range of # of FMD tracks
+ Bool_t fNFMDTracksFlag; // Shows whether this cut is used or not
+ Int_t fNPHOSClustersMin, fNPHOSClustersMax; // Range of # of PHOS clusters
+ Bool_t fNPHOSClustersFlag; // Shows whether this cut is used or not
+ Int_t fNEMCALClustersMin, fNEMCALClustersMax; // Range of # of EMCAL clusters
+ Bool_t fNEMCALClustersFlag; // Shows whether this cut is used or not
+ Int_t fNJetCandidatesMin, fNJetCandidatesMax; // Range of # of jet candidates
+ Bool_t fNJetCandidatesFlag; // Shows whether this cut is used or not
+
+ Float_t fTopJetEnergyMin; // top jet energy minimum value
+ Bool_t fTopJetEnergyMinFlag; // Shows whether this cut is used or not
+ Float_t fTopNeutralEnergyMin; // top neutral energy minimum value
+ Bool_t fTopNeutralEnergyMinFlag; // Shows whether this cut is used or not
- Int_t fNHardPhotonsCandidatesMin, fNHardPhotonsCandidatesMax; //Hard photons candidates
- Bool_t fNHardPhotonsCandidatesFlag;//Shows whether this cut is used or not
- Float_t fMaxNeutralEnergy; //max neutral energy info
- Bool_t fMaxNeutralFlag;//Shows whether this cut is used or not
- Int_t fChargedAbove1GeVMin, fChargedAbove1GeVMax;//Definition of the range of the number of charged above 1GeV
- Bool_t fChargedAbove1GeVFlag;//Shows whether this cut is used or not
- Int_t fChargedAbove3GeVMin, fChargedAbove3GeVMax;//Definition of the range of the number of charged above 3GeV
- Bool_t fChargedAbove3GeVFlag;//Shows whether this cut is used or not
- Int_t fChargedAbove10GeVMin, fChargedAbove10GeVMax;//Definition of the range of the number of charged above 10GeV
- Bool_t fChargedAbove10GeVFlag;//Shows whether this cut is used or not
- Int_t fMuonsAbove1GeVMin, fMuonsAbove1GeVMax;//Definition of the range of the number of muons above 1GeV
- Bool_t fMuonsAbove1GeVFlag;//Shows whether this cut is used or not
- Int_t fMuonsAbove3GeVMin, fMuonsAbove3GeVMax;//Definition of the range of the number of muons above 3GeV
- Bool_t fMuonsAbove3GeVFlag;//Shows whether this cut is used or not
- Int_t fMuonsAbove10GeVMin, fMuonsAbove10GeVMax; //Definition of the range of the number of muons above 10GeV
- Bool_t fMuonsAbove10GeVFlag;//Shows whether this cut is used or not
- Int_t fElectronsAbove1GeVMin, fElectronsAbove1GeVMax;//Definition of the range of the number of electorns above 1GeV
- Bool_t fElectronsAbove1GeVFlag;//Shows whether this cut is used or not
- Int_t fElectronsAbove3GeVMin, fElectronsAbove3GeVMax;//Definition of the range of the number of electorns above 3GeV
- Bool_t fElectronsAbove3GeVFlag;//Shows whether this cut is used or not
- Int_t fElectronsAbove10GeVMin,fElectronsAbove10GeVMax;//Definition of the range of the number of electorns above 10GeV
- Bool_t fElectronsAbove10GeVFlag;//Shows whether this cut is used or not
- Int_t fElectronsMin, fElectronsMax; //Number of electrons range
- Bool_t fElectronsFlag;//Shows whether this cut is used or not
- Int_t fMuonsMin, fMuonsMax; //Number of muons range
- Bool_t fMuonsFlag;//Shows whether this cut is used or not
- Int_t fPionsMin, fPionsMax; //Number of pions range
- Bool_t fPionsFlag;//Shows whether this cut is used or not
- Int_t fKaonsMin, fKaonsMax; //Number of kaons range
- Bool_t fKaonsFlag;//Shows whether this cut is used or not
- Int_t fProtonsMin, fProtonsMax; //Number of protons range
- Bool_t fProtonsFlag;//Shows whether this cut is used or not
- Int_t fLambdasMin, fLambdasMax; //Number of lambdas range
- Bool_t fLambdasFlag;//Shows whether this cut is used or not
- Int_t fPhotonsMin, fPhotonsMax; //Number of photons range
- Bool_t fPhotonFlag;//Shows whether this cut is used or not
- Int_t fPi0sMin, fPi0sMax; //Number of Pi0s range
- Bool_t fPi0sFlag;//Shows whether this cut is used or not
- Int_t fNeutronsMin, fNeutronsMax; //Number of neutrons range
- Bool_t fNeutronsFlag;//Shows whether this cut is used or not
- Int_t fKaon0sMin, fKaon0sMax; //Number of K0s range
- Bool_t fKaon0sFlag;//Shows whether this cut is used or not
- Float_t fTotalPMin, fTotalPMax; //Range of the sum of the momentum per event
- Bool_t fTotalPFlag;//Shows whether this cut is used or not
- Float_t fMeanPtMin, fMeanPtMax; //Range of mean Pt per event
- Bool_t fMeanPtFlag;//Shows whether this cut is used or not
- Float_t fMaxPt; //Max Pt for each event
- Bool_t fMaxPtFlag;//Shows whether this cut is used or not
- Float_t fTotalNeutralPMin, fTotalNeutralPMax; //Sum of the momentum per event for neutral
- Bool_t fTotalNeutralPFlag;//Shows whether this cut is used or not
- Float_t fMeanNeutralPtMin, fMeanNeutralPtMax; //Mean Pt per event for neutral
- Bool_t fMeanNeutralPtFlag;//Shows whether this cut is used or not
- Float_t fMaxNeutralPt; //Max Pt for each event for neutral
- Bool_t fMaxNeutralPtFlag;//Shows whether this cut is used or not
- Float_t fEventPlaneAngleMin, fEventPlaneAngleMax; //event plane info
- Bool_t fEventPlaneAngleFlag;//Shows whether this cut is used or not
- Float_t fHBTRadiiMin, fHBTRadiiMax; //HBT info
- Bool_t fHBTRadiiFlag;//Shows whether this cut is used or not
+ Int_t fNHardPhotonCandidatesMin, fNHardPhotonCandidatesMax; // # of hard photons candidates
+ Bool_t fNHardPhotonCandidatesFlag; // Shows whether this cut is used or not
+ Int_t fNChargedAbove1GeVMin, fNChargedAbove1GeVMax; // Definition of the range of the # of charged above 1GeV
+ Bool_t fNChargedAbove1GeVFlag; // Shows whether this cut is used or not
+ Int_t fNChargedAbove3GeVMin, fNChargedAbove3GeVMax; // Definition of the range of the # of charged above 3GeV
+ Bool_t fNChargedAbove3GeVFlag; // Shows whether this cut is used or not
+ Int_t fNChargedAbove10GeVMin, fNChargedAbove10GeVMax; // Definition of the range of the # of charged above 10GeV
+ Bool_t fNChargedAbove10GeVFlag; // Shows whether this cut is used or not
+ Int_t fNMuonsAbove1GeVMin, fNMuonsAbove1GeVMax; // Definition of the range of the # of muons above 1GeV
+ Bool_t fNMuonsAbove1GeVFlag; // Shows whether this cut is used or not
+ Int_t fNMuonsAbove3GeVMin, fNMuonsAbove3GeVMax; // Definition of the range of the # of muons above 3GeV
+ Bool_t fNMuonsAbove3GeVFlag; // Shows whether this cut is used or not
+ Int_t fNMuonsAbove10GeVMin, fNMuonsAbove10GeVMax; // Definition of the range of the # of muons above 10GeV
+ Bool_t fNMuonsAbove10GeVFlag; // Shows whether this cut is used or not
+ Int_t fNElectronsAbove1GeVMin, fNElectronsAbove1GeVMax; // Definition of the range of the # of electorns above 1GeV
+ Bool_t fNElectronsAbove1GeVFlag; // Shows whether this cut is used or not
+ Int_t fNElectronsAbove3GeVMin, fNElectronsAbove3GeVMax; // Definition of the range of the # of electorns above 3GeV
+ Bool_t fNElectronsAbove3GeVFlag; // Shows whether this cut is used or not
+ Int_t fNElectronsAbove10GeVMin,fNElectronsAbove10GeVMax; // Definition of the range of the # of electorns above 10GeV
+ Bool_t fNElectronsAbove10GeVFlag; // Shows whether this cut is used or not
+ Int_t fNElectronsMin, fNElectronsMax; // # of electrons range
+ Bool_t fNElectronsFlag; // Shows whether this cut is used or not
+ Int_t fNMuonsMin, fNMuonsMax; // # of muons range
+ Bool_t fNMuonsFlag; // Shows whether this cut is used or not
+ Int_t fNPionsMin, fNPionsMax; // # of pions range
+ Bool_t fNPionsFlag; // Shows whether this cut is used or not
+ Int_t fNKaonsMin, fNKaonsMax; // # of kaons range
+ Bool_t fNKaonsFlag; // Shows whether this cut is used or not
+ Int_t fNProtonsMin, fNProtonsMax; // # of protons range
+ Bool_t fNProtonsFlag; // Shows whether this cut is used or not
+ Int_t fNLambdasMin, fNLambdasMax; // # of lambdas range
+ Bool_t fNLambdasFlag; // Shows whether this cut is used or not
+ Int_t fNPhotonsMin, fNPhotonsMax; // # of photons range
+ Bool_t fNPhotonFlag; // Shows whether this cut is used or not
+ Int_t fNPi0sMin, fNPi0sMax; // # of Pi0s range
+ Bool_t fNPi0sFlag; // Shows whether this cut is used or not
+ Int_t fNNeutronsMin, fNNeutronsMax; // # of neutrons range
+ Bool_t fNNeutronsFlag; // Shows whether this cut is used or not
+ Int_t fNKaon0sMin, fNKaon0sMax; // # of K0s range
+ Bool_t fNKaon0sFlag; // Shows whether this cut is used or not
+ Float_t fTotalPMin, fTotalPMax; // Range of the sum of the momentum per event
+ Bool_t fTotalPFlag; // Shows whether this cut is used or not
+ Float_t fMeanPtMin, fMeanPtMax; // Range of mean Pt per event
+ Bool_t fMeanPtFlag; // Shows whether this cut is used or not
+ Float_t fTopPtMin; // Max Pt for each event
+ Bool_t fTopPtMinFlag; // Shows whether this cut is used or not
+ Float_t fTotalNeutralPMin, fTotalNeutralPMax; // Sum of the momentum per event for neutral
+ Bool_t fTotalNeutralPFlag; // Shows whether this cut is used or not
+ Float_t fMeanNeutralPtMin, fMeanNeutralPtMax; // Mean Pt per event for neutral
+ Bool_t fMeanNeutralPtFlag; // Shows whether this cut is used or not
+ Float_t fTopNeutralPtMin; // Minimum value for highest Pt for the event for neutral
+ Bool_t fTopNeutralPtMinFlag; // Shows whether this cut is used or not
+ Float_t fEventPlaneAngleMin, fEventPlaneAngleMax; // event plane info
+ Bool_t fEventPlaneAngleFlag; // Shows whether this cut is used or not
+ Float_t fHBTRadiiMin, fHBTRadiiMax; // HBT info
+ Bool_t fHBTRadiiFlag; // Shows whether this cut is used or not
ClassDef(AliEventTagCuts, 2)
};
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff