X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=sidebyside;f=PWGGA%2FCaloTrackCorrelations%2FAliAnaParticleHadronCorrelation.cxx;h=80557e466cb4d469dd2bcc0bbf8a835905a82a54;hb=0af5b34f084ccf9d67fa3a8c52dc8a7b45c0c1c8;hp=4086475ea549bfd9c5fbcc08711c61fcd8498093;hpb=7d306daf646fbcfc87a601d833e722db9f627237;p=u%2Fmrichter%2FAliRoot.git diff --git a/PWGGA/CaloTrackCorrelations/AliAnaParticleHadronCorrelation.cxx b/PWGGA/CaloTrackCorrelations/AliAnaParticleHadronCorrelation.cxx index 4086475ea54..80557e466cb 100755 --- a/PWGGA/CaloTrackCorrelations/AliAnaParticleHadronCorrelation.cxx +++ b/PWGGA/CaloTrackCorrelations/AliAnaParticleHadronCorrelation.cxx @@ -15,18 +15,12 @@ //_________________________________________________________________________ // Class for the analysis of particle - hadron correlations -// Particle (for example direct gamma) must be found in a previous analysis -//-- Author: Gustavo Conesa (LNF-INFN) - -// Modified by Yaxian Mao: -// 1. add the UE subtraction for corrlation study -// 2. change the correlation variable -// 3. Only use leading particle(cluster/track) as trigger for correlation (2010/07/02) -// 4. Make decay photon-hadron correlations where decay contribute pi0 mass (2010/09/09) -// 5. fill the pout to extract kt at the end, also to study charge asymmetry(2010/10/06) -// 6. Add the possibility for event selection analysis based on vertex and multiplicity bins (10/10/2010) -// 7. change the way of delta phi cut for UE study due to memory issue (reduce histograms) -// 8. Add the possibility to request the absolute leading particle at the near side or not, set trigger bins, general clean-up (08/2011) +// Particle (for example direct gamma) must be found +// in a previous analysis +// +//-- Author: Gustavo Conesa (LNF-INFN) (LPSC-IN2P3-CNRS) +// Yaxian Mao (LPSC-IN2P3-CNRS) and (CNWU) first usable implementation. +// Xiangrong Zhu (CNWU), implementtion of own mixing. ////////////////////////////////////////////////////////////////////////////// @@ -60,58 +54,94 @@ ClassImp(AliAnaParticleHadronCorrelation) //___________________________________________________________________ AliAnaParticleHadronCorrelation::AliAnaParticleHadronCorrelation(): AliAnaCaloTrackCorrBaseClass(), - fMinTriggerPt(0.), - fMaxAssocPt(1000.), fMinAssocPt(0.), + fFillAODWithReferences(0), fCheckLeadingWithNeutralClusters(0), + fMaxAssocPt(1000.), fMinAssocPt(0.), fDeltaPhiMaxCut(0.), fDeltaPhiMinCut(0.), fSelectIsolated(0), fMakeSeveralUE(0), fUeDeltaPhiMaxCut(0.), fUeDeltaPhiMinCut(0.), fPi0AODBranchName(""), fNeutralCorr(0), fPi0Trigger(0), fDecayTrigger(0), + fNDecayBits(0), fDecayBits(), fMakeAbsoluteLeading(0), fMakeNearSideLeading(0), fLeadingTriggerIndex(-1), fHMPIDCorrelation(0), fFillBradHisto(0), fNAssocPtBins(0), fAssocPtBinLimit(), fCorrelVzBin(0), - fListMixTrackEvents(), fListMixCaloEvents(), fUseMixStoredInReader(0), - fM02MaxCut(0), fM02MinCut(0), + fListMixTrackEvents(), fListMixCaloEvents(), + fUseMixStoredInReader(0), fFillNeutralEventMixPool(0), + fM02MaxCut(0), fM02MinCut(0), + fSelectLeadingHadronAngle(0), fFillLeadHadOppositeHisto(0), + fMinLeadHadPhi(0), fMaxLeadHadPhi(0), + fMinLeadHadPt(0), fMaxLeadHadPt(0), + fFillEtaGapsHisto(1), fFillMomImbalancePtAssocBinsHisto(0), + fMCGenTypeMin(0), fMCGenTypeMax(0), + fTrackVector(), fMomentum(), + fDecayMom1(), fDecayMom2(), //Histograms - fhPtInput(0), fhPtFidCut(0), - fhPtLeading(0), fhPtLeadingVzBin(0), fhPtLeadingBin(0), - fhPhiLeading(0), fhEtaLeading(0), - fhPtLeadingCentrality(0), fhPtLeadingEventPlane(0), - fhLeadingEventPlaneCentrality(0), - fhPtLeadingMixed(0), fhPtLeadingMixedVzBin(0), fhPtLeadingMixedBin(0), - fhPhiLeadingMixed(0), fhEtaLeadingMixed(0), + fhPtTriggerInput(0), fhPtTriggerSSCut(0), + fhPtTriggerIsoCut(0), fhPtTriggerFidCut(0), + fhPtTrigger(0), fhPtTriggerVtxBC0(0), + fhPtTriggerVzBin(0), fhPtTriggerBin(0), + fhPhiTrigger(0), fhEtaTrigger(0), + fhPtTriggerMC(), + fhPtDecayTrigger(), fhPtDecayTriggerMC(), + fhPtTriggerCentrality(0), fhPtTriggerEventPlane(0), + fhTriggerEventPlaneCentrality(0), + fhPtTriggerMixed(0), fhPtTriggerMixedVzBin(0), fhPtTriggerMixedBin(0), + fhPhiTriggerMixed(0), fhEtaTriggerMixed(0), + fhPtLeadingOppositeHadron(0), fhPtDiffPhiLeadingOppositeHadron(0), fhPtDiffEtaLeadingOppositeHadron(0), + fhPtNoLeadingOppositeHadron(0), fhEtaPhiNoLeadingOppositeHadron(0), fhDeltaPhiDeltaEtaCharged(0), fhPhiCharged(0), fhEtaCharged(0), fhDeltaPhiCharged(0), fhDeltaEtaCharged(0), fhDeltaPhiChargedPt(0), fhDeltaPhiUeChargedPt(0), fhUePart(0), - fhXECharged(0), fhXEUeCharged(0), + fhXECharged(0), fhXECharged_Cone2(0), fhXEUeCharged(0), fhXEPosCharged(0), fhXENegCharged(0), - fhPtHbpXECharged(0), fhPtHbpXEUeCharged(0), + fhPtHbpXECharged(0), fhPtHbpXECharged_Cone2(0), fhPtHbpXEUeCharged(0), fhZTCharged(0), fhZTUeCharged(0), fhZTPosCharged(0), fhZTNegCharged(0), fhPtHbpZTCharged(0), fhPtHbpZTUeCharged(0), - fhDeltaPhiUeLeftCharged(0), fhDeltaPhiUeRightCharged(0), + fhXEChargedMC(), fhDeltaPhiChargedMC(), + fhDeltaPhiDeltaEtaChargedPtA3GeV(0), + fhDeltaPhiChargedPtA3GeV(0), fhDeltaEtaChargedPtA3GeV(0), + //Pile-Up + fhDeltaPhiChargedPileUp(), fhDeltaEtaChargedPileUp(), + fhDeltaPhiChargedPtA3GeVPileUp(), fhDeltaEtaChargedPtA3GeVPileUp(), + fhXEChargedPileUp(), fhXEUeChargedPileUp(), + fhZTChargedPileUp(), fhZTUeChargedPileUp(), + fhPtTrigChargedPileUp(), + fhDeltaPhiChargedOtherBC(), fhDeltaPhiChargedPtA3GeVOtherBC(), + fhXEChargedOtherBC(), fhXEUeChargedOtherBC(), + fhZTChargedOtherBC(), fhZTUeChargedOtherBC(), + fhPtTrigChargedOtherBC(), + fhDeltaPhiChargedBC0(), fhDeltaPhiChargedPtA3GeVBC0(), + fhXEChargedBC0(), fhXEUeChargedBC0(), + fhZTChargedBC0(), fhZTUeChargedBC0(), + fhPtTrigChargedBC0(), + fhDeltaPhiChargedVtxBC0(), fhDeltaPhiChargedPtA3GeVVtxBC0(), + fhXEChargedVtxBC0(), fhXEUeChargedVtxBC0(), + fhZTChargedVtxBC0(), fhZTUeChargedVtxBC0(), + fhPtTrigChargedVtxBC0(), + fhDeltaPhiUeLeftCharged(0), fhDeltaPhiUeLeftUpCharged(0), fhDeltaPhiUeRightUpCharged(0), fhDeltaPhiUeLeftDownCharged(0), fhDeltaPhiUeRightDownCharged(0), - fhXEUeLeftCharged(0), fhXEUeRightCharged(0), + fhXEUeLeftCharged(0), fhXEUeLeftUpCharged(0), fhXEUeRightUpCharged(0), fhXEUeLeftDownCharged(0), fhXEUeRightDownCharged(0), - fhPtHbpXEUeLeftCharged(0), fhPtHbpXEUeRightCharged(0), - fhZTUeLeftCharged(0), fhZTUeRightCharged(0), - fhPtHbpZTUeLeftCharged(0), fhPtHbpZTUeRightCharged(0), + fhPtHbpXEUeLeftCharged(0), fhZTUeLeftCharged(0), + fhPtHbpZTUeLeftCharged(0), fhPtTrigPout(0), fhPtTrigCharged(0), - fhTrigDeltaPhiCharged(0x0), fhTrigDeltaEtaCharged(0x0), - fhTrigXECorr(0x0), fhTrigXEUeCorr(0x0), - fhTrigZTCorr(0x0), fhTrigZTUeCorr(0x0), + fhDeltaPhiChargedMult(0x0), fhDeltaEtaChargedMult(0x0), + fhXEMult(0x0), fhXEUeMult(0x0), + fhZTMult(0x0), fhZTUeMult(0x0), fhAssocPtBkg(0), fhDeltaPhiDeltaEtaAssocPtBin(0), fhDeltaPhiAssocPtBin(0), fhDeltaPhiAssocPtBinDEta08(0), fhDeltaPhiAssocPtBinDEta0(0), fhDeltaPhiAssocPtBinHMPID(0), fhDeltaPhiAssocPtBinHMPIDAcc(0), fhDeltaPhiBradAssocPtBin(0), fhDeltaPhiBrad(0), - fhXEAssocPtBin(0), fhZTAssocPtBin(0), - fhDeltaPhiDeltaEtaNeutral(0), + fhXEAssocPtBin(0), fhZTAssocPtBin(0), + fhXEVZ(0), fhZTVZ(0), + fhDeltaPhiDeltaEtaNeutral(0), fhPhiNeutral(0), fhEtaNeutral(0), fhDeltaPhiNeutral(0), fhDeltaEtaNeutral(0), fhDeltaPhiNeutralPt(0), fhDeltaPhiUeNeutralPt(0), @@ -119,46 +149,67 @@ ClassImp(AliAnaParticleHadronCorrelation) fhPtHbpXENeutral(0), fhPtHbpXEUeNeutral(0), fhZTNeutral(0), fhZTUeNeutral(0), fhPtHbpZTNeutral(0), fhPtHbpZTUeNeutral(0), - fhDeltaPhiUeLeftNeutral(0), fhDeltaPhiUeRightNeutral(0), - fhXEUeLeftNeutral(0), fhXEUeRightNeutral(0), - fhPtHbpXEUeLeftNeutral(0), fhPtHbpXEUeRightNeutral(0), - fhZTUeLeftNeutral(0), fhZTUeRightNeutral(0), - fhPtHbpZTUeLeftNeutral(0), fhPtHbpZTUeRightNeutral(0), - fhPtPi0DecayRatio(0), - fhDeltaPhiDecayCharged(0), fhXEDecayCharged(0), fhZTDecayCharged(0), - fhDeltaPhiDecayNeutral(0), fhXEDecayNeutral(0), fhZTDecayNeutral(0), - fhDeltaPhiDecayChargedAssocPtBin(0), - fhXEDecayChargedAssocPtBin(0), fhZTDecayChargedAssocPtBin(0), - fh2phiLeadingParticle(0x0), fhMCPtLeading(0), - fhMCPhiLeading(0), fhMCEtaLeading(0), - fhMCEtaCharged(0), fhMCPhiCharged(0), - fhMCDeltaEtaCharged(0), fhMCDeltaPhiCharged(0x0), - fhMCDeltaPhiDeltaEtaCharged(0), fhMCDeltaPhiChargedPt(0), - fhMCPtXECharged(0), fhMCPtXEUeCharged(0), - fhMCPtHbpXECharged(0), fhMCPtHbpXEUeCharged(0), - fhMCUePart(0), - fhMCPtZTCharged(0), fhMCPtHbpZTCharged(0), - fhMCPtTrigPout(0), fhMCPtAssocDeltaPhi(0), + fhDeltaPhiUeLeftNeutral(0), fhXEUeLeftNeutral(0), + fhPtHbpXEUeLeftNeutral(0), fhZTUeLeftNeutral(0), + fhPtHbpZTUeLeftNeutral(0), fhPtPi0DecayRatio(0), + fhDeltaPhiPi0DecayCharged(0), fhXEPi0DecayCharged(0), fhZTPi0DecayCharged(0), + fhDeltaPhiPi0DecayNeutral(0), fhXEPi0DecayNeutral(0), fhZTPi0DecayNeutral(0), + fhDeltaPhiDecayCharged(), fhXEDecayCharged(), fhZTDecayCharged(), + fhDeltaPhiDecayChargedAssocPtBin(), + fhMCPtTrigger(), fhMCPhiTrigger(), fhMCEtaTrigger(), + fhMCPtTriggerNotLeading(), fhMCPhiTriggerNotLeading(), fhMCEtaTriggerNotLeading(), + fhMCEtaCharged(), fhMCPhiCharged(), + fhMCDeltaEtaCharged(), fhMCDeltaPhiCharged(), + fhMCDeltaPhiDeltaEtaCharged(), fhMCDeltaPhiChargedPt(), + fhMCPtXECharged(), fhMCPtXEUeCharged(), + fhMCPtXEUeLeftCharged(), + fhMCPtHbpXECharged(), fhMCPtHbpXEUeCharged(), + fhMCPtHbpXEUeLeftCharged(), + fhMCUePart(), + fhMCPtZTCharged(), fhMCPtZTUeCharged(), + fhMCPtZTUeLeftCharged(), + fhMCPtHbpZTCharged(), fhMCPtHbpZTUeCharged(), + fhMCPtHbpZTUeLeftCharged(), + fhMCPtTrigPout(), fhMCPtAssocDeltaPhi(), //Mixing - fhNEventsTrigger(0), - fhNtracksAll(0), fhNtracksTrigger(0), - fhNtracksMB(0), + fhNEventsTrigger(0), fhNtracksMB(0), fhNclustersMB(0), fhMixDeltaPhiCharged(0), fhMixDeltaPhiDeltaEtaCharged(0), - fhMixXECharged(0), fhMixHbpXECharged(0), + fhMixXECharged(0), fhMixXEUeCharged(0), fhMixHbpXECharged(0), fhMixDeltaPhiChargedAssocPtBin(), fhMixDeltaPhiChargedAssocPtBinDEta08(), fhMixDeltaPhiChargedAssocPtBinDEta0(), fhMixDeltaPhiDeltaEtaChargedAssocPtBin(), - fhEventBin(0), fhEventMixBin(0) + fhEventBin(0), fhEventMixBin(0), fhEventMBBin(0) { //Default Ctor //Initialize parameters InitParameters(); + + for(Int_t i = 0; i < fgkNmcTypes; i++) + { + fhPtTriggerMC[i] = 0; + fhXEChargedMC[i] = 0; + fhDeltaPhiChargedMC[i] = 0; + for(Int_t ib = 0; ib < 4; ib++) fhPtDecayTriggerMC[ib][i] = 0; + } + + for(Int_t ib = 0; ib < 4; ib++) fhPtDecayTrigger[ib] = 0; + + for(Int_t i = 0; i < 7; i++) + { + fhPtTriggerPileUp [i] = 0 ; + fhDeltaPhiChargedPileUp [i] = 0 ; fhDeltaEtaChargedPileUp [i] = 0 ; + fhXEChargedPileUp [i] = 0 ; fhXEUeChargedPileUp [i] = 0 ; + fhZTChargedPileUp [i] = 0 ; fhZTUeChargedPileUp [i] = 0 ; + fhPtTrigChargedPileUp [i] = 0 ; + fhDeltaPhiChargedPtA3GeVPileUp[i] = 0 ; fhDeltaEtaChargedPtA3GeVPileUp[i] = 0 ; + } + } //_________________________________________________________________ -AliAnaParticleHadronCorrelation::~AliAnaParticleHadronCorrelation() +AliAnaParticleHadronCorrelation::~AliAnaParticleHadronCorrelation() { // Remove event containers @@ -203,40 +254,100 @@ AliAnaParticleHadronCorrelation::~AliAnaParticleHadronCorrelation() } } -//______________________________________________________________________________________________________________________________________________________ -void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(const Float_t ptAssoc, const Float_t ptTrig, const Int_t bin, - const Float_t phiAssoc, const Float_t phiTrig, Float_t & deltaPhi, - const Float_t etaAssoc, const Float_t etaTrig, - const Bool_t decay, const Float_t hmpidSignal, const Int_t nTracks) +//__________________________________________________________________________________________________________________________________________ +void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig, Int_t bin, + Float_t phiAssoc, Float_t phiTrig, Float_t deltaPhi, + Float_t etaAssoc, Float_t etaTrig, + Int_t decayTag, Float_t hmpidSignal, Int_t outTOF, + Int_t cen, Int_t mcTag) { // Fill angular correlation related histograms Float_t deltaEta = etaTrig-etaAssoc; - deltaPhi = phiTrig-phiAssoc; - Float_t deltaPhiOrg = deltaPhi; + Float_t deltaPhiOrg = phiTrig-phiAssoc; + + fhEtaCharged ->Fill(ptAssoc,etaAssoc); + fhPhiCharged ->Fill(ptAssoc,phiAssoc); + fhDeltaEtaCharged ->Fill(ptTrig ,deltaEta); + fhDeltaPhiCharged ->Fill(ptTrig ,deltaPhi); + fhDeltaPhiChargedPt->Fill(ptAssoc, deltaPhi); + fhDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta); - if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); - if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); + if(ptAssoc > 3 ) + { + fhDeltaEtaChargedPtA3GeV ->Fill(ptTrig ,deltaEta); + fhDeltaPhiChargedPtA3GeV ->Fill(ptTrig ,deltaPhi); + fhDeltaPhiDeltaEtaChargedPtA3GeV->Fill(deltaPhi, deltaEta); + } + + // Pile up studies - fhEtaCharged ->Fill(ptAssoc,etaAssoc); - fhPhiCharged ->Fill(ptAssoc,phiAssoc); - fhDeltaEtaCharged->Fill(ptTrig ,deltaEta); - fhDeltaPhiCharged->Fill(ptTrig ,deltaPhi); + if(IsPileUpAnalysisOn()) + { + if (outTOF==1) + { + fhDeltaPhiChargedOtherBC->Fill(ptTrig ,deltaPhi) ; + if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVOtherBC->Fill(ptTrig ,deltaPhi) ; + } + else if(outTOF==0) + { + fhDeltaPhiChargedBC0->Fill(ptTrig ,deltaPhi) ; + if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVBC0->Fill(ptTrig ,deltaPhi) ; + } + + Int_t vtxBC = GetReader()->GetVertexBC(); + if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) + { + fhDeltaPhiChargedVtxBC0->Fill(ptTrig ,deltaPhi) ; + if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVVtxBC0->Fill(ptTrig ,deltaPhi) ; + } + + if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[0]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[1]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[2]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhDeltaEtaChargedPileUp[3]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[3]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[4]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[4]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[5]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[6]->Fill(ptTrig ,deltaPhi) ; } + + if(ptAssoc > 3 ) + { + if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[1]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[2]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[3]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[3]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[4]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[4]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[5]->Fill(ptTrig ,deltaPhi) ; } + if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[6]->Fill(ptTrig ,deltaPhi) ; } + } + } - if(ptAssoc > 2 ) fhDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta); + if(IsDataMC()) + { + Int_t mcIndex = GetMCTagHistogramIndex(mcTag); + fhDeltaPhiChargedMC[mcIndex]->Fill(ptTrig , deltaPhi); + if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==2 ) + fhDeltaPhiChargedMC[7]->Fill(ptTrig , deltaPhi); + } - if(fDecayTrigger && decay) fhDeltaPhiDecayCharged ->Fill(ptTrig , deltaPhi); + if(fDecayTrigger && decayTag > 0) + { + for(Int_t ibit = 0; ibitCheckDecayBit(decayTag,fDecayBits[ibit])) fhDeltaPhiDecayCharged[ibit]->Fill(ptTrig,deltaPhi); + } + } Double_t dphiBrad = -100; if(fFillBradHisto) { dphiBrad = atan2(sin(deltaPhiOrg), cos(deltaPhiOrg))/TMath::Pi();//-1 to 1 - if(TMath::Abs(dphiBrad)>0.325 && TMath::Abs(dphiBrad)<0.475) //Hardcoded values, BAD, FIXME + if( TMath::Abs(dphiBrad) > 0.325 && TMath::Abs(dphiBrad) < 0.475 ) //Hardcoded values, BAD, FIXME { fhAssocPtBkg->Fill(ptTrig, ptAssoc); } - if(dphiBrad<-1./3) dphiBrad += 2; + if( dphiBrad < -1./3 ) dphiBrad += 2; fhDeltaPhiBrad->Fill(ptTrig, dphiBrad); } @@ -247,16 +358,20 @@ void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(co fhDeltaPhiAssocPtBin [bin]->Fill(ptTrig, deltaPhi); - if(TMath::Abs(deltaEta)> 0.8) - fhDeltaPhiAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi); - - if(TMath::Abs(deltaEta)< 0.01) - fhDeltaPhiAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi); + if(fFillEtaGapsHisto) + { + if(TMath::Abs(deltaEta)> 0.8) + fhDeltaPhiAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi); + + if(TMath::Abs(deltaEta)< 0.01) + fhDeltaPhiAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi); + } if (fFillBradHisto) fhDeltaPhiBradAssocPtBin [bin]->Fill(ptTrig, dphiBrad); - if(fDecayTrigger && decay) + if(fDecayTrigger && decayTag > 0 && fNDecayBits > 0 && + GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0])) fhDeltaPhiDecayChargedAssocPtBin[bin]->Fill(ptTrig, deltaPhi); if(fHMPIDCorrelation) @@ -275,46 +390,52 @@ void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(co } } - //fill different multiplicity histogram - if(DoEventSelect()) + //fill different multiplicity/centrality histogram + if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin()) { - for(Int_t im = 0; imFill(ptTrig,deltaPhi); - fhTrigDeltaEtaCharged[im]->Fill(ptTrig,deltaEta); - } - } + fhDeltaPhiChargedMult[cen]->Fill(ptTrig,deltaPhi); + fhDeltaEtaChargedMult[cen]->Fill(ptTrig,deltaEta); } } -//____________________________________________________________________________________________________________________________________________________ -Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(const Float_t mcAssocPt, Float_t mcAssocPhi, const Float_t mcAssocEta, - const Float_t mcTrigPt, const Float_t mcTrigPhi, const Float_t mcTrigEta) +//___________________________________________________________________________________________________________________________________ +Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(Float_t mcAssocPt, Float_t mcAssocPhi, Float_t mcAssocEta, + Float_t mcTrigPt, Float_t mcTrigPhi, Float_t mcTrigEta, + Int_t histoIndex, Bool_t lostDecayPair) { // Fill MC histograms independently of AOD or ESD - //Select only hadrons in pt range - if(mcAssocPt < fMinAssocPt || mcAssocPt > fMaxAssocPt) return kTRUE ; // exclude but continue - - if(mcAssocPhi < 0) mcAssocPhi+=TMath::TwoPi(); - - //remove trigger itself for correlation when use charged triggers - if(TMath::Abs(mcAssocPt -mcTrigPt ) < 1e-6 && - TMath::Abs(mcAssocPhi-mcTrigPhi) < 1e-6 && - TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return kTRUE ; // exclude but continue + Bool_t lead = kTRUE; + // In case we requested the trigger to be a leading particle, + // check if this is true at the MC level. + // Not sure if it is correct to skip or not skip this. // Absolute leading? - if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) return kFALSE; // jump event + if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) lead = kFALSE; // skip event - //jump out this event if near side associated partile pt larger than trigger - if( fMakeNearSideLeading && mcAssocPt > mcTrigPt && - TMath::Abs(mcAssocPhi-mcTrigPhi) 3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi(); + if(mcdeltaPhi > 3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi(); + + if( fMakeNearSideLeading) + { + if( mcAssocPt > mcTrigPt && mcdeltaPhi < TMath::PiOver2() ) lead = kFALSE; // skip event + } + + // + // Select only hadrons in pt range + if ( mcAssocPt < fMinAssocPt || mcAssocPt > fMaxAssocPt ) return lead ; // exclude but continue + if ( mcAssocPt < GetReader()->GetCTSPtMin()) return lead ; + + + // + // Remove trigger itself for correlation when use charged triggers + if(TMath::Abs(mcAssocPt -mcTrigPt ) < 1e-6 && + mcdeltaPhi < 1e-6 && + TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return lead ; // exclude but continue Float_t mcxE =-mcAssocPt/mcTrigPt*TMath::Cos(mcdeltaPhi);// -(mcAssocPx*pxprim+mcAssocPy*pyprim)/(mcTrigPt*mcTrigPt); Float_t mchbpXE =-100 ; @@ -324,90 +445,224 @@ Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(const Float_t mchbpZT =-100 ; if(mczT > 0 ) mchbpZT = TMath::Log(1./mczT); - //Selection within angular range - if( mcdeltaPhi< -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi(); - if( mcdeltaPhi>3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi(); - Double_t mcpout = mcAssocPt*TMath::Sin(mcdeltaPhi) ; - if(GetDebug() > 0 ) - printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation() - Charged hadron: track Pt %f, track Phi %f, phi trigger %f. Cuts: delta phi %2.2f < %2.2f < %2.2f, pT min %2.2f \n", - mcAssocPt,mcAssocPhi, mcTrigPhi,fDeltaPhiMinCut, mcdeltaPhi, fDeltaPhiMaxCut, GetMinPt()); + AliDebug(1,Form("Charged hadron: track Pt %f, track Phi %f, phi trigger %f. Cuts: delta phi %2.2f < %2.2f < %2.2f", + mcAssocPt,mcAssocPhi, mcTrigPhi,fDeltaPhiMinCut, mcdeltaPhi, fDeltaPhiMaxCut)); + // Fill Histograms - fhMCEtaCharged ->Fill(mcAssocPt, mcAssocEta); - fhMCPhiCharged ->Fill(mcAssocPt, mcAssocPhi); - fhMCDeltaEtaCharged->Fill(mcTrigPt, mcTrigEta-mcAssocEta); - fhMCDeltaPhiCharged->Fill(mcTrigPt, mcdeltaPhi); - fhMCPtAssocDeltaPhi->Fill(mcAssocPt, mcdeltaPhi); + fhMCEtaCharged [histoIndex]->Fill(mcAssocPt, mcAssocEta); + fhMCPhiCharged [histoIndex]->Fill(mcAssocPt, mcAssocPhi); + fhMCDeltaEtaCharged[histoIndex]->Fill(mcTrigPt , mcTrigEta-mcAssocEta); + fhMCDeltaPhiCharged[histoIndex]->Fill(mcTrigPt , mcdeltaPhi); + fhMCPtAssocDeltaPhi[histoIndex]->Fill(mcAssocPt, mcdeltaPhi); - fhMCDeltaPhiDeltaEtaCharged->Fill(mcdeltaPhi,mcTrigEta-mcAssocEta); + fhMCDeltaPhiDeltaEtaCharged[histoIndex]->Fill(mcdeltaPhi,mcTrigEta-mcAssocEta); //delta phi cut for correlation if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) ) { - fhMCDeltaPhiChargedPt->Fill(mcAssocPt,mcdeltaPhi); - fhMCPtXECharged ->Fill(mcTrigPt,mcxE); - fhMCPtHbpXECharged ->Fill(mcTrigPt,mchbpXE); - fhMCPtZTCharged ->Fill(mcTrigPt,mczT); - fhMCPtHbpZTCharged ->Fill(mcTrigPt,mchbpZT); - fhMCPtTrigPout ->Fill(mcTrigPt, mcpout) ; + fhMCDeltaPhiChargedPt[histoIndex]->Fill(mcAssocPt,mcdeltaPhi); + fhMCPtXECharged [histoIndex]->Fill(mcTrigPt, mcxE); + fhMCPtHbpXECharged [histoIndex]->Fill(mcTrigPt, mchbpXE); + fhMCPtZTCharged [histoIndex]->Fill(mcTrigPt, mczT); + fhMCPtHbpZTCharged [histoIndex]->Fill(mcTrigPt, mchbpZT); + fhMCPtTrigPout [histoIndex]->Fill(mcTrigPt, mcpout) ; } - //underlying event - if ( (mcdeltaPhi > fUeDeltaPhiMinCut) && (mcdeltaPhi < fUeDeltaPhiMaxCut) ) + if(histoIndex==2 && lostDecayPair && 7 >= fMCGenTypeMin && 7 <= fMCGenTypeMax ) + { + fhMCEtaCharged [7]->Fill(mcAssocPt, mcAssocEta); + fhMCPhiCharged [7]->Fill(mcAssocPt, mcAssocPhi); + fhMCDeltaEtaCharged[7]->Fill(mcTrigPt , mcTrigEta-mcAssocEta); + fhMCDeltaPhiCharged[7]->Fill(mcTrigPt , mcdeltaPhi); + fhMCPtAssocDeltaPhi[7]->Fill(mcAssocPt, mcdeltaPhi); + + fhMCDeltaPhiDeltaEtaCharged[7]->Fill(mcdeltaPhi,mcTrigEta-mcAssocEta); + + //delta phi cut for correlation + if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) ) { - Double_t randomphi = gRandom->Uniform(TMath::Pi()/2,3*TMath::Pi()/2); - Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi); + fhMCDeltaPhiChargedPt[7]->Fill(mcAssocPt,mcdeltaPhi); + fhMCPtXECharged [7]->Fill(mcTrigPt, mcxE); + fhMCPtHbpXECharged [7]->Fill(mcTrigPt, mchbpXE); + fhMCPtZTCharged [7]->Fill(mcTrigPt, mczT); + fhMCPtHbpZTCharged [7]->Fill(mcTrigPt, mchbpZT); + fhMCPtTrigPout [7]->Fill(mcTrigPt, mcpout) ; + } + } + + // Underlying event - if(mcUexE < 0.) mcUexE = -mcUexE; + // Right + if ( (mcdeltaPhi > fUeDeltaPhiMinCut) && (mcdeltaPhi < fUeDeltaPhiMaxCut) ) + { + //Double_t randomphi = gRandom->Uniform(TMath::Pi()/2,3*TMath::Pi()/2); + Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); + Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi); + Double_t mcUezT = mcAssocPt/mcTrigPt; + + if(mcUexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + mcUexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); + + fhMCPtXEUeCharged[histoIndex]->Fill(mcTrigPt,mcUexE); + if(mcUexE > 0) fhMCPtHbpXEUeCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUexE)); - fhMCPtXEUeCharged->Fill(mcTrigPt,mcUexE); - if(mcUexE > 0) fhMCPtHbpXEUeCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE)); + fhMCPtZTUeCharged[histoIndex]->Fill(mcTrigPt,mcUezT); + if(mcUezT > 0) fhMCPtHbpZTUeCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUezT)); + + fhMCUePart[histoIndex]->Fill(mcTrigPt); + + if(histoIndex==2 && lostDecayPair && 7 >= fMCGenTypeMin && 7 <= fMCGenTypeMax ) + { + fhMCPtXEUeCharged[7]->Fill(mcTrigPt,mcUexE); + if(mcUexE > 0) fhMCPtHbpXEUeCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUexE)); + + fhMCPtZTUeCharged[7]->Fill(mcTrigPt,mcUezT); + if(mcUezT > 0) fhMCPtHbpZTUeCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUezT)); + + fhMCUePart[7]->Fill(mcTrigPt); + } + } - fhMCUePart->Fill(mcTrigPt); + if(fMakeSeveralUE) + { + // Left + if((mcdeltaPhi<-fUeDeltaPhiMinCut) || (mcdeltaPhi >2*fUeDeltaPhiMaxCut)) + { + Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); + Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi); + Double_t mcUezT = mcAssocPt/mcTrigPt; + + if(mcUexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + mcUexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); + + fhMCPtXEUeLeftCharged[histoIndex]->Fill(mcTrigPt,mcUexE); + if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUexE)); + + fhMCPtZTUeLeftCharged[histoIndex]->Fill(mcTrigPt,mcUezT); + if(mcUezT > 0) fhMCPtHbpZTUeLeftCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUezT)); + + if(histoIndex==2 && lostDecayPair && 7 >= fMCGenTypeMin && 7 <= fMCGenTypeMax ) + { + fhMCPtXEUeLeftCharged[7]->Fill(mcTrigPt,mcUexE); + if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged[7]->Fill(mcTrigPt,TMath::Log(1/mcUexE)); + + fhMCPtZTUeLeftCharged[7]->Fill(mcTrigPt,mcUezT); + if(mcUezT > 0) fhMCPtHbpZTUeLeftCharged[7]->Fill(mcTrigPt,TMath::Log(1/mcUezT)); + } } + } - return kTRUE; -} + return lead; +} //___________________________________________________________________________________________________________________ -void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(const Float_t ptTrig, const Float_t ptAssoc, - const Float_t xE, const Float_t hbpXE, - const Float_t zT, const Float_t hbpZT, - const Float_t pout, const Float_t deltaPhi, - const Int_t nTracks, const Int_t charge, - const Int_t bin, const Bool_t decay ) +void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(Float_t ptTrig, Float_t ptAssoc, + Float_t deltaPhi, + Int_t cen, Int_t charge, + Int_t bin, Int_t decayTag, + Int_t outTOF, Int_t mcTag) { // Fill mostly momentum imbalance related histograms - fhDeltaPhiChargedPt ->Fill(ptAssoc, deltaPhi); - fhXECharged ->Fill(ptTrig , xE); + Float_t zT = ptAssoc/ptTrig ; + Float_t xE =-ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig); + Float_t pout = ptAssoc*TMath::Sin(deltaPhi) ; + + if(xE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); + + Float_t hbpXE = -100; + Float_t hbpZT = -100; + + if(xE > 0 ) hbpXE = TMath::Log(1./xE); + if(zT > 0 ) hbpZT = TMath::Log(1./zT); + + fhXECharged ->Fill(ptTrig , xE); fhPtHbpXECharged ->Fill(ptTrig , hbpXE); fhZTCharged ->Fill(ptTrig , zT); fhPtHbpZTCharged ->Fill(ptTrig , hbpZT); fhPtTrigPout ->Fill(ptTrig , pout) ; fhPtTrigCharged ->Fill(ptTrig , ptAssoc) ; + if((deltaPhi > 5*TMath::Pi()/6.) && (deltaPhi < 7*TMath::Pi()/6.)) + { + fhXECharged_Cone2 ->Fill(ptTrig , xE); + fhPtHbpXECharged_Cone2 ->Fill(ptTrig , hbpXE); + } + + // MC + if(IsDataMC()) + { + Int_t mcIndex = GetMCTagHistogramIndex(mcTag); + fhXEChargedMC[mcIndex]->Fill(ptTrig , xE); + if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) && mcIndex==2 ) + fhXEChargedMC[7]->Fill(ptTrig , xE); + } + + // Pile up studies + if(IsPileUpAnalysisOn()) + { + if (outTOF==1) + { + fhXEChargedOtherBC ->Fill(ptTrig,xE); + fhZTChargedOtherBC ->Fill(ptTrig,zT); + fhPtTrigChargedOtherBC->Fill(ptTrig,ptAssoc); + } + else if(outTOF==0) + { + fhXEChargedBC0 ->Fill(ptTrig,xE); + fhZTChargedBC0 ->Fill(ptTrig,zT); + fhPtTrigChargedBC0->Fill(ptTrig,ptAssoc); + } + + Int_t vtxBC = GetReader()->GetVertexBC(); + if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) + { + fhXEChargedVtxBC0 ->Fill(ptTrig,xE); + fhZTChargedVtxBC0 ->Fill(ptTrig,zT); + fhPtTrigChargedVtxBC0->Fill(ptTrig,ptAssoc); + } + + if(GetReader()->IsPileUpFromSPD()) { fhXEChargedPileUp[0]->Fill(ptTrig,xE); fhZTChargedPileUp[0]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[0]->Fill(ptTrig,ptAssoc); } + if(GetReader()->IsPileUpFromEMCal()) { fhXEChargedPileUp[1]->Fill(ptTrig,xE); fhZTChargedPileUp[1]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[1]->Fill(ptTrig,ptAssoc); } + if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEChargedPileUp[2]->Fill(ptTrig,xE); fhZTChargedPileUp[2]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[2]->Fill(ptTrig,ptAssoc); } + if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEChargedPileUp[3]->Fill(ptTrig,xE); fhZTChargedPileUp[3]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[3]->Fill(ptTrig,ptAssoc); } + if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEChargedPileUp[4]->Fill(ptTrig,xE); fhZTChargedPileUp[4]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[4]->Fill(ptTrig,ptAssoc); } + if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEChargedPileUp[5]->Fill(ptTrig,xE); fhZTChargedPileUp[5]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[5]->Fill(ptTrig,ptAssoc); } + if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEChargedPileUp[6]->Fill(ptTrig,xE); fhZTChargedPileUp[6]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[6]->Fill(ptTrig,ptAssoc); } + } - if(fDecayTrigger && decay) - { - fhXEDecayCharged->Fill(ptTrig,xE); - fhZTDecayCharged->Fill(ptTrig,zT); - } // photon decay pi0/eta trigger + if(fDecayTrigger && decayTag > 0) + { + for(Int_t ibit = 0; ibitCheckDecayBit(decayTag,fDecayBits[ibit])) + { + fhXEDecayCharged[ibit]->Fill(ptTrig,xE); + fhZTDecayCharged[ibit]->Fill(ptTrig,zT); + } + } + } // photon decay pi0/eta trigger - if(bin >= 0 )//away side + if(bin >= 0 && fFillMomImbalancePtAssocBinsHisto)//away side { fhXEAssocPtBin[bin]->Fill(ptTrig, xE) ; fhZTAssocPtBin[bin]->Fill(ptTrig, zT) ; - - if(fDecayTrigger && decay) - { - fhXEDecayChargedAssocPtBin[bin]->Fill(ptTrig, xE); - fhZTDecayChargedAssocPtBin[bin]->Fill(ptTrig, zT); - } } + if(fCorrelVzBin) + { + Int_t vz = GetEventVzBin(); + fhXEVZ[vz]->Fill(ptTrig, xE) ; + fhZTVZ[vz]->Fill(ptTrig, zT) ; + } + if(charge > 0) { fhXEPosCharged->Fill(ptTrig,xE) ; @@ -419,158 +674,176 @@ void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(con fhZTNegCharged->Fill(ptTrig,zT) ; } - //fill different multiplicity histogram - if(DoEventSelect()) + //fill different multiplicity/centrality histogram + if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin()) { - for(Int_t im=0; imFill(ptTrig,xE); - fhTrigZTCorr[im]->Fill(ptTrig,zT); - } - } - } //multiplicity events selection + fhXEMult[cen]->Fill(ptTrig,xE); + fhZTMult[cen]->Fill(ptTrig,zT); + } //multiplicity/centrality events selection } //_______________________________________________________________________________________________________________________ -void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventHistograms(const Float_t ptTrig, const Float_t ptAssoc, - const Float_t deltaPhi, const Int_t nTracks) +void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventHistograms(Float_t ptTrig, Float_t ptAssoc, + Float_t deltaPhi, Int_t cen, Int_t outTOF) { // Fill underlying event histograms + fhUePart->Fill(ptTrig); + fhDeltaPhiUeChargedPt->Fill(ptAssoc,deltaPhi); Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi); Double_t uezT = ptAssoc/ptTrig; - if(uexE < 0.) uexE = -uexE; - + if(uexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); + fhXEUeCharged->Fill(ptTrig,uexE); if(uexE > 0) fhPtHbpXEUeCharged->Fill(ptTrig,TMath::Log(1/uexE)); fhZTUeCharged->Fill(ptTrig,uezT); - if(uexE > 0) fhPtHbpZTUeCharged->Fill(ptTrig,TMath::Log(1/uezT)); + if(uezT > 0) fhPtHbpZTUeCharged->Fill(ptTrig,TMath::Log(1/uezT)); - if(DoEventSelect()) + // Pile up studies + + if(IsPileUpAnalysisOn()) { - for(Int_t im=0; imFill(ptTrig,uexE); // xE? CHECK - fhTrigZTUeCorr[im]->Fill(ptTrig,uezT); // zT? CHECK - } + fhXEUeChargedOtherBC->Fill(ptTrig,uexE); + fhZTUeChargedOtherBC->Fill(ptTrig,uezT); + } + else if(outTOF==0) + { + fhXEUeChargedBC0->Fill(ptTrig,uexE); + fhZTUeChargedBC0->Fill(ptTrig,uezT); + } + + Int_t vtxBC = GetReader()->GetVertexBC(); + if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) + { + fhXEUeChargedVtxBC0->Fill(ptTrig,uexE); + fhZTUeChargedVtxBC0->Fill(ptTrig,uezT); } - } //multiplicity events selection + + if(GetReader()->IsPileUpFromSPD()) { fhXEUeChargedPileUp[0]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[0]->Fill(ptTrig,uezT);} + if(GetReader()->IsPileUpFromEMCal()) { fhXEUeChargedPileUp[1]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[1]->Fill(ptTrig,uezT);} + if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEUeChargedPileUp[2]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[2]->Fill(ptTrig,uezT);} + if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEUeChargedPileUp[3]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[3]->Fill(ptTrig,uezT);} + if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEUeChargedPileUp[4]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[4]->Fill(ptTrig,uezT);} + if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEUeChargedPileUp[5]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[5]->Fill(ptTrig,uezT);} + if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEUeChargedPileUp[6]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[6]->Fill(ptTrig,uezT);} + } + + //fill different multiplicity/centrality histogram + if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin()) + { + fhXEUeMult[cen]->Fill(ptTrig,uexE); + fhZTUeMult[cen]->Fill(ptTrig,uezT); + } } //_____________________________________________________________________________________________________ -void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventSidesHistograms(const Float_t ptTrig, - const Float_t ptAssoc, - const Float_t deltaPhi) +void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventSidesHistograms(Float_t ptTrig, + Float_t ptAssoc, + Float_t deltaPhi) { - // Fill underlying event histograms to the left and right of trigger + // Fill underlying event histograms to the left and right of trigger + // Right cone is the default UE. + if((deltaPhi<-fUeDeltaPhiMinCut) || (deltaPhi >2*fUeDeltaPhiMaxCut)) - { - fhDeltaPhiUeLeftCharged->Fill(ptAssoc,deltaPhi); + { + fhDeltaPhiUeLeftCharged->Fill(ptAssoc,deltaPhi); Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi); Double_t uezT = ptAssoc/ptTrig; - - if(uexE < 0.) uexE = -uexE; + + if(uexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); fhXEUeLeftCharged->Fill(ptTrig,uexE); if(uexE > 0) fhPtHbpXEUeLeftCharged->Fill(ptTrig,TMath::Log(1/uexE)); - + fhZTUeLeftCharged->Fill(ptTrig,uezT); - if(uexE > 0) fhPtHbpZTUeLeftCharged->Fill(ptTrig,TMath::Log(1/uezT)); + if(uezT > 0) fhPtHbpZTUeLeftCharged->Fill(ptTrig,TMath::Log(1/uezT)); + fhDeltaPhiUeLeftCharged->Fill(ptAssoc, deltaPhi); } - if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut)) - { - fhDeltaPhiUeRightCharged->Fill(ptAssoc,deltaPhi); - Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); - Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi); - Double_t uezT = ptAssoc/ptTrig; - - if(uexE < 0.) uexE = -uexE; - - fhXEUeRightCharged->Fill(ptTrig,uexE); - if(uexE > 0) fhPtHbpXEUeRightCharged->Fill(ptTrig,TMath::Log(1/uexE)); - - fhZTUeRightCharged->Fill(ptTrig,uezT); - if(uexE > 0) fhPtHbpZTUeRightCharged->Fill(ptTrig,TMath::Log(1/uezT)); - fhDeltaPhiUeRightCharged->Fill(ptAssoc, deltaPhi); - } - if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-TMath::Pi()/2)) - { - fhDeltaPhiUeLeftDownCharged->Fill(ptAssoc,deltaPhi); + { + fhDeltaPhiUeLeftDownCharged->Fill(ptAssoc,deltaPhi); Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi); - if(uexE < 0.) uexE = -uexE; + if(uexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for left-down UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); fhXEUeLeftDownCharged->Fill(ptTrig,uexE); } if((deltaPhi>2*fUeDeltaPhiMaxCut) && (deltaPhi <3*TMath::Pi()/2)) - { - fhDeltaPhiUeLeftUpCharged->Fill(ptAssoc,deltaPhi); + { + fhDeltaPhiUeLeftUpCharged->Fill(ptAssoc,deltaPhi); Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi); - if(uexE < 0.) uexE = -uexE; + if(uexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for left-up UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); fhXEUeLeftUpCharged->Fill(ptTrig,uexE); } if((deltaPhi > TMath::Pi()/2) && (deltaPhi < fUeDeltaPhiMaxCut)) - { - fhDeltaPhiUeRightUpCharged->Fill(ptAssoc,deltaPhi); + { + fhDeltaPhiUeRightUpCharged->Fill(ptAssoc,deltaPhi); Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi); - if(uexE < 0.) uexE = -uexE; + if(uexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for right-up UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); fhXEUeRightUpCharged->Fill(ptTrig,uexE); } if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < TMath::Pi()/2)) - { - fhDeltaPhiUeRightDownCharged->Fill(ptAssoc,deltaPhi); + { + fhDeltaPhiUeRightDownCharged->Fill(ptAssoc,deltaPhi); Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi); - if(uexE < 0.) uexE = -uexE; + if(uexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for right-down UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); fhXEUeRightDownCharged->Fill(ptTrig,uexE); - } + } } -//______________________________________________________________________________________________________________________________ -void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(const Float_t ptAssoc, const Float_t phiAssoc, - const TLorentzVector mom1, const TLorentzVector mom2, - const Bool_t bChargedOrNeutral) +//_____________________________________________________________________________________________________________________________________ +void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(Float_t ptAssoc, Float_t phiAssoc, Bool_t bChargedOrNeutral) { // Do correlation with decay photons of triggered pi0 or eta // Calculate the correlation parameters - Float_t ptDecay1 = mom1.Pt(); - Float_t ptDecay2 = mom2.Pt(); + Float_t ptDecay1 = fDecayMom1.Pt(); + Float_t ptDecay2 = fDecayMom2.Pt(); Float_t zTDecay1 = -100, zTDecay2 = -100; - if(ptDecay1) zTDecay1 = ptAssoc/ptDecay1 ; - if(ptDecay2) zTDecay2 = ptAssoc/ptDecay2 ; + if(ptDecay1 > 0) zTDecay1 = ptAssoc/ptDecay1 ; + if(ptDecay2 > 0) zTDecay2 = ptAssoc/ptDecay2 ; - Float_t deltaPhiDecay1 = mom1.Phi()-phiAssoc; + Float_t deltaPhiDecay1 = fDecayMom1.Phi()-phiAssoc; if(deltaPhiDecay1< -TMath::PiOver2()) deltaPhiDecay1+=TMath::TwoPi(); if(deltaPhiDecay1>3*TMath::PiOver2()) deltaPhiDecay1-=TMath::TwoPi(); - Float_t deltaPhiDecay2 = mom2.Phi()-phiAssoc; + Float_t deltaPhiDecay2 = fDecayMom2.Phi()-phiAssoc; if(deltaPhiDecay2< -TMath::PiOver2()) deltaPhiDecay2+=TMath::TwoPi(); if(deltaPhiDecay2>3*TMath::PiOver2()) deltaPhiDecay2-=TMath::TwoPi(); @@ -579,128 +852,110 @@ void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(const if(bChargedOrNeutral) // correlate with charges { - fhDeltaPhiDecayCharged->Fill(ptDecay1, deltaPhiDecay1); - fhDeltaPhiDecayCharged->Fill(ptDecay2, deltaPhiDecay2); + fhDeltaPhiPi0DecayCharged->Fill(ptDecay1, deltaPhiDecay1); + fhDeltaPhiPi0DecayCharged->Fill(ptDecay2, deltaPhiDecay2); - if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::FillDecayPhotonHistograms( Charged corr) - deltaPhoton1 = %f, deltaPhoton2 = %f \n", deltaPhiDecay1, deltaPhiDecay2); + AliDebug(2,Form("deltaPhoton1 = %f, deltaPhoton2 = %f", deltaPhiDecay1, deltaPhiDecay2)); if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) ) { - fhZTDecayCharged->Fill(ptDecay1,zTDecay1); - fhXEDecayCharged->Fill(ptDecay1,xEDecay1); + fhZTPi0DecayCharged->Fill(ptDecay1,zTDecay1); + fhXEPi0DecayCharged->Fill(ptDecay1,xEDecay1); } if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) ) { - fhZTDecayCharged->Fill(ptDecay2,zTDecay2); - fhXEDecayCharged->Fill(ptDecay2,xEDecay2); + fhZTPi0DecayCharged->Fill(ptDecay2,zTDecay2); + fhXEPi0DecayCharged->Fill(ptDecay2,xEDecay2); } } else // correlate with neutrals { - fhDeltaPhiDecayCharged->Fill(ptDecay1, deltaPhiDecay1); - fhDeltaPhiDecayCharged->Fill(ptDecay2, deltaPhiDecay2); + fhDeltaPhiPi0DecayNeutral->Fill(ptDecay1, deltaPhiDecay1); + fhDeltaPhiPi0DecayNeutral->Fill(ptDecay2, deltaPhiDecay2); - if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::FillDecayPhotonHistograms(Neutral corr) - deltaPhoton1 = %f, deltaPhoton2 = %f \n", deltaPhiDecay1, deltaPhiDecay2); + AliDebug(2,Form("deltaPhoton1 = %f, deltaPhoton2 = %f", deltaPhiDecay1, deltaPhiDecay2)); if( (deltaPhiDecay1 > fDeltaPhiMinCut) && ( deltaPhiDecay1 < fDeltaPhiMaxCut) ) { - fhZTDecayCharged->Fill(ptDecay1,zTDecay1); - fhXEDecayCharged->Fill(ptDecay1,xEDecay1); + fhZTPi0DecayNeutral->Fill(ptDecay1,zTDecay1); + fhXEPi0DecayNeutral->Fill(ptDecay1,xEDecay1); } if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) ) { - fhZTDecayCharged->Fill(ptDecay2,zTDecay2); - fhXEDecayCharged->Fill(ptDecay2,xEDecay2); + fhZTPi0DecayNeutral->Fill(ptDecay2,zTDecay2); + fhXEPi0DecayNeutral->Fill(ptDecay2,xEDecay2); } } } -//______________________________________________________________________________________________________________________________________________________ -void AliAnaParticleHadronCorrelation::FillNeutralAngularCorrelationHistograms(const Float_t ptAssoc, const Float_t ptTrig, - const Float_t phiAssoc, const Float_t phiTrig, Float_t & deltaPhi, - const Float_t etaAssoc, const Float_t etaTrig) +//_____________________________________________________________________________________________________________________________ +void AliAnaParticleHadronCorrelation::FillNeutralUnderlyingEventSidesHistograms(Float_t ptTrig, Float_t ptAssoc, + Float_t zT, Float_t hbpZT, + Float_t deltaPhi) { - // Fill angular correlation related histograms - - Float_t deltaEta = etaTrig-etaAssoc; - deltaPhi = phiTrig-phiAssoc; - - if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); - if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); - - fhEtaNeutral ->Fill(ptAssoc,etaAssoc); - fhPhiNeutral ->Fill(ptAssoc,phiAssoc); - fhDeltaEtaNeutral->Fill(ptTrig ,deltaEta); - fhDeltaPhiNeutral->Fill(ptTrig ,deltaPhi); - - if(ptAssoc > 2 ) fhDeltaPhiDeltaEtaNeutral->Fill(deltaPhi, deltaEta); + // Fill underlying event histograms to the left of trigger + // Right is the default case -} + Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); -//_____________________________________________________________________________________________________________________________ -void AliAnaParticleHadronCorrelation::FillNeutralUnderlyingEventSidesHistograms(const Float_t ptTrig, const Float_t ptAssoc, - const Float_t xE, const Float_t hbpXE, - const Float_t zT, const Float_t hbpZT, - const Float_t deltaPhi) -{ - // Fill underlying event histograms to the left and right of trigger + Float_t xE =-ptAssoc/ptTrig*TMath::Cos(randomphi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig); + Float_t hbpXE = -100; + if(xE > 0 ) hbpXE = TMath::Log(1./xE); if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-fUeDeltaPhiMaxCut)) - { + { fhDeltaPhiUeLeftNeutral->Fill(ptAssoc, deltaPhi); fhXEUeLeftNeutral ->Fill(ptTrig , xE); fhPtHbpXEUeLeftNeutral ->Fill(ptTrig , hbpXE); fhZTUeLeftNeutral ->Fill(ptTrig , zT); fhPtHbpZTUeLeftNeutral ->Fill(ptTrig , hbpZT); } - - if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut)) - { - fhDeltaPhiUeRightNeutral->Fill(ptAssoc, deltaPhi); - fhXEUeRightNeutral ->Fill(ptTrig , xE); - fhPtHbpXEUeRightNeutral ->Fill(ptTrig , hbpXE); - fhZTUeRightNeutral ->Fill(ptTrig , zT); - fhPtHbpZTUeRightNeutral ->Fill(ptTrig , hbpZT); - } } +//______________________________________________________ +void AliAnaParticleHadronCorrelation::FillEventMixPool() +{ + // Fill the pool with tracks or clusters if requested + + if ( !DoOwnMix() ) return; + + FillChargedEventMixPool(); + + // Do the cluster pool filling only if requested + // or in case of isolation cut using clusters in the cone. + Bool_t isoCase = OnlyIsolated() && (GetIsolationCut()->GetParticleTypeInCone() != AliIsolationCut::kOnlyCharged); + + if( !fFillNeutralEventMixPool && !isoCase) return; + + FillNeutralEventMixPool(); +} + //_____________________________________________________________ void AliAnaParticleHadronCorrelation::FillChargedEventMixPool() { // Mixed event pool filling for tracks - - //printf("FillChargedEventMixPool for %s\n",GetInputAODName().Data()); - + if(fUseMixStoredInReader && GetReader()->GetLastTracksMixedEvent() == GetEventNumber()) { //printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data()); return ; // pool filled previously for another trigger } - Int_t nTracks = GetCTSTracks()->GetEntriesFast(); - - fhNtracksAll->Fill(nTracks); - AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager(); AliInputEventHandler * inputHandler = dynamic_cast(manager->GetInputEventHandler()); if(!inputHandler) return ; - - if( inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask() ) - { - fhNtracksTrigger->Fill(nTracks); - } - + // Do mixing only with MB event (or the chosen mask), if not skip if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ; - fhNtracksMB->Fill(nTracks); - Int_t eventBin = GetEventMixBin(); //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing if(eventBin < 0) return; + fhEventMBBin->Fill(eventBin); + TObjArray * mixEventTracks = new TObjArray; if(fUseMixStoredInReader) @@ -714,24 +969,24 @@ void AliAnaParticleHadronCorrelation::FillChargedEventMixPool() TList * pool = fListMixTrackEvents[eventBin]; - TVector3 p3; for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ ) { AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ; - Double_t mom[3] = {track->Px(),track->Py(),track->Pz()}; - p3.SetXYZ(mom[0],mom[1],mom[2]); - Float_t pt = p3.Pt(); + fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz()); + Float_t pt = fTrackVector.Pt(); //Select only hadrons in pt range if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ; - AliAODPWG4Particle * mixedTrack = new AliAODPWG4Particle(mom[0],mom[1],mom[2],0); - mixedTrack->SetDetector("CTS"); + AliAODPWG4Particle * mixedTrack = new AliAODPWG4Particle(track->Px(),track->Py(),track->Pz(),0); + mixedTrack->SetDetectorTag(kCTS); mixedTrack->SetChargedBit(track->Charge()>0); mixEventTracks->Add(mixedTrack); } + fhNtracksMB->Fill(mixEventTracks->GetEntriesFast(),eventBin); + //Set the event number where the last event was added, to avoid double pool filling GetReader()->SetLastTracksMixedEvent(GetEventNumber()); @@ -763,25 +1018,18 @@ void AliAnaParticleHadronCorrelation::FillNeutralEventMixPool() return ; // pool filled previously for another trigger } - // Int_t nClusters = GetEMCALClusters()->GetEntriesFast(); - // - // fhNclustersAll->Fill(nClusters); + TObjArray * pl = GetEMCALClusters(); + //if (GetAODObjArrayName.Contains("PHOS") )pl = GetPHOSClusters(); + //else pl = GetEMCALClusters(); AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager(); AliInputEventHandler * inputHandler = dynamic_cast(manager->GetInputEventHandler()); if(!inputHandler) return ; - - // if( inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask() ) - // { - // fhNclustersTrigger->Fill(nClusters); - // } - + // Do mixing only with MB event (or the chosen mask), if not skip if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ; - // fhNClustersMB->Fill(nCluster); - Int_t eventBin = GetEventMixBin(); //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing @@ -798,39 +1046,35 @@ void AliAnaParticleHadronCorrelation::FillNeutralEventMixPool() TList * poolCalo = fListMixCaloEvents[eventBin]; - TObjArray * pl = GetEMCALClusters(); - //if (GetAODObjArrayName.Contains("PHOS") )pl = GetPHOSClusters(); - //else pl = GetEMCALClusters(); - - TLorentzVector mom; - //printf("NClusters before selection %d\n",pl->GetEntriesFast()); - for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ ) + for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ ) { AliVCluster * calo = (AliVCluster *) (pl->At(ipr)) ; // remove matched clusters if( IsTrackMatched( calo, GetReader()->GetInputEvent() ) ) continue ; - //Cluster momentum calculation + //Cluster momentum calculation if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) { - calo->GetMomentum(mom,GetVertex(0)) ; + calo->GetMomentum(fMomentum,GetVertex(0)) ; }//Assume that come from vertex in straight line else { Double_t vertex[]={0,0,0}; - calo->GetMomentum(mom,vertex) ; + calo->GetMomentum(fMomentum,vertex) ; } - Float_t pt = mom.Pt(); + Float_t pt = fMomentum.Pt(); //Select only clusters in pt range if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ; - AliAODPWG4Particle * mixedCalo = new AliAODPWG4Particle(mom); - mixedCalo->SetDetector("EMCAL"); + AliAODPWG4Particle * mixedCalo = new AliAODPWG4Particle(fMomentum); + mixedCalo->SetDetectorTag(kEMCAL); mixEventCalo->Add(mixedCalo); } + fhNclustersMB->Fill(mixEventCalo->GetEntriesFast(),eventBin); + //Set the event number where the last event was added, to avoid double pool filling GetReader()->SetLastCaloMixedEvent(GetEventNumber()); @@ -848,6 +1092,92 @@ void AliAnaParticleHadronCorrelation::FillNeutralEventMixPool() } } +//_________________________________________________________________________________________________________________ +Bool_t AliAnaParticleHadronCorrelation::FindLeadingOppositeHadronInWindow(AliAODPWG4ParticleCorrelation * particle) +{ + // Select events where the leading charged particle in the opposite hemisphere + // to the trigger particle is in a window centered at 180 from the trigger + + Float_t etaTrig = particle->Eta(); + Float_t ptTrig = particle->Pt(); + Float_t phiTrig = particle->Phi(); + if(phiTrig < 0 ) phiTrig+= TMath::TwoPi(); + + Float_t ptLeadHad = 0 ; + Float_t dphiLeadHad= -100 ; + Float_t phiLeadHad = -100 ; + Float_t etaLeadHad = -100 ; + Int_t nTrack = 0; + + for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ ) + { + AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ; + + fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz()); + + Float_t pt = fTrackVector.Pt(); + Float_t phi = fTrackVector.Phi() ; + if(phi < 0 ) phi+= TMath::TwoPi(); + + Float_t deltaPhi = phiTrig-phi; + // + // Calculate deltaPhi shift so that for the particles on the opposite side + // it is defined between 90 and 270 degrees + // Shift [-360,-90] to [0, 270] + // and [270,360] to [-90,0] + if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); + if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); + + if(pt > ptLeadHad && deltaPhi > TMath::PiOver2()) // in opposite hemisphere + { + ptLeadHad = pt ; + phiLeadHad = phi; + dphiLeadHad= deltaPhi; + etaLeadHad = fTrackVector.Eta(); + nTrack++; + } + }// track loop + + if(fFillLeadHadOppositeHisto) + { + if(nTrack == 0) + { + fhPtNoLeadingOppositeHadron ->Fill(ptTrig); + fhEtaPhiNoLeadingOppositeHadron->Fill(etaTrig,phiTrig); + } + else + { + fhPtLeadingOppositeHadron ->Fill(ptTrig, ptLeadHad); + fhPtDiffPhiLeadingOppositeHadron->Fill(ptTrig,dphiLeadHad); + fhPtDiffEtaLeadingOppositeHadron->Fill(ptTrig, etaLeadHad-etaTrig); + } + } + + + AliDebug(1,Form("pT %2.2f, phi %2.2f, eta %2.2f, nTracks away %d, total tracks %d", + ptLeadHad,phiLeadHad*TMath::RadToDeg(),etaLeadHad,nTrack, GetTrackMultiplicity())); + AliDebug(1,Form("\t pT trig %2.2f, Dphi (trigger-hadron) %2.2f, Deta (trigger-hadron) %2.2f", + ptTrig, dphiLeadHad*TMath::RadToDeg(), etaLeadHad-etaTrig)); + AliDebug(1,Form("\t cuts pT: min %2.2f, max %2.2f; DPhi: min %2.2f, max %2.2f", + fMinLeadHadPt,fMaxLeadHadPt,fMinLeadHadPhi*TMath::RadToDeg(),fMaxLeadHadPhi*TMath::RadToDeg())); + + + // reject the trigger if the leading hadron is not in the requested pt or phi window and + + if( nTrack == 0 ) return kFALSE; // No track found in opposite hemisphere + + if( ptLeadHad < fMinLeadHadPt || ptLeadHad > fMaxLeadHadPt ) return kFALSE; + + //printf("Accept leading hadron pT \n"); + + if( dphiLeadHad < fMinLeadHadPhi || dphiLeadHad > fMaxLeadHadPhi ) return kFALSE; + + //printf("Accept leading hadron phi \n"); + + + return kTRUE ; +} + //____________________________________________________________ TObjString* AliAnaParticleHadronCorrelation::GetAnalysisCuts() { @@ -856,25 +1186,23 @@ TObjString* AliAnaParticleHadronCorrelation::GetAnalysisCuts() const Int_t buffersize = 560; char onePar[buffersize] ; - snprintf(onePar,buffersize,"--- AliAnaPaticleHadronCorrelation ---\n") ; + snprintf(onePar,buffersize,"--- AliAnaPaticleHadronCorrelation ---:") ; parList+=onePar ; - snprintf(onePar,buffersize," Pt Trigger > %3.2f ", fMinTriggerPt) ; + snprintf(onePar,buffersize," %3.2f < Pt associated < %3.2f; ", fMinAssocPt, fMaxAssocPt) ; parList+=onePar ; - snprintf(onePar,buffersize," %3.2f < Pt associated < %3.2f ", fMinAssocPt, fMaxAssocPt) ; + snprintf(onePar,buffersize," %3.2f < Phi trigger particle-Hadron < %3.2f; ", fDeltaPhiMinCut, fDeltaPhiMaxCut) ; parList+=onePar ; - snprintf(onePar,buffersize," %3.2f < Phi trigger particle-Hadron < %3.2f ", fDeltaPhiMinCut, fDeltaPhiMaxCut) ; + snprintf(onePar,buffersize," %3.2f < Phi trigger particle-UeHadron < %3.2f; ", fUeDeltaPhiMinCut, fUeDeltaPhiMaxCut) ; parList+=onePar ; - snprintf(onePar,buffersize," %3.2f < Phi trigger particle-UeHadron < %3.2f ", fUeDeltaPhiMinCut, fUeDeltaPhiMaxCut) ; + snprintf(onePar,buffersize,"Isolated Trigger? %d;", fSelectIsolated) ; parList+=onePar ; - snprintf(onePar,buffersize,"Isolated Trigger? %d\n", fSelectIsolated) ; + snprintf(onePar,buffersize,"Several UE? %d;", fMakeSeveralUE) ; parList+=onePar ; - snprintf(onePar,buffersize,"Several UE? %d\n", fMakeSeveralUE) ; + snprintf(onePar,buffersize,"Name of AOD Pi0 Branch %s;", fPi0AODBranchName.Data()); parList+=onePar ; - snprintf(onePar,buffersize,"Name of AOD Pi0 Branch %s ", fPi0AODBranchName.Data()); + snprintf(onePar,buffersize,"Do Decay-hadron correlation ? pi0 %d, decay %d;", fPi0Trigger, fDecayTrigger) ; parList+=onePar ; - snprintf(onePar,buffersize,"Do Decay-hadron correlation ? pi0 %d, decay %d", fPi0Trigger, fDecayTrigger) ; - parList+=onePar ; - snprintf(onePar,buffersize,"Select absolute leading for cluster triggers ? %d or Near Side Leading %d \n", + snprintf(onePar,buffersize,"Select absolute leading for cluster triggers ? %d or Near Side Leading %d;", fMakeAbsoluteLeading, fMakeNearSideLeading) ; parList+=onePar ; snprintf(onePar,buffersize,"Associated particle pt bins %d: ", fNAssocPtBins) ; @@ -896,953 +1224,1415 @@ TObjString* AliAnaParticleHadronCorrelation::GetAnalysisCuts() //________________________________________________________________ TList * AliAnaParticleHadronCorrelation::GetCreateOutputObjects() -{ - - // Create histograms to be saved in output file and +{ + // Create histograms to be saved in output file and // store them in fOutputContainer - TList * outputContainer = new TList() ; - outputContainer->SetName("CorrelationHistos") ; + TList * outputContainer = new TList() ; + outputContainer->SetName("CorrelationHistos") ; - Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Int_t netabins = GetHistogramRanges()->GetHistoEtaBins(); Int_t ndeltaphibins = GetHistogramRanges()->GetHistoDeltaPhiBins(); Int_t ndeltaetabins = GetHistogramRanges()->GetHistoDeltaEtaBins(); - Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax(); Float_t deltaphimax = GetHistogramRanges()->GetHistoDeltaPhiMax(); Float_t deltaetamax = GetHistogramRanges()->GetHistoDeltaEtaMax(); - Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin(); Float_t deltaphimin = GetHistogramRanges()->GetHistoDeltaPhiMin(); Float_t deltaetamin = GetHistogramRanges()->GetHistoDeltaEtaMin(); + Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Int_t netabins = GetHistogramRanges()->GetHistoEtaBins(); + Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax(); + Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin(); + + Int_t ndeltaphibins = GetHistogramRanges()->GetHistoDeltaPhiBins(); Int_t ndeltaetabins = GetHistogramRanges()->GetHistoDeltaEtaBins(); + Float_t deltaphimax = GetHistogramRanges()->GetHistoDeltaPhiMax(); Float_t deltaetamax = GetHistogramRanges()->GetHistoDeltaEtaMax(); + Float_t deltaphimin = GetHistogramRanges()->GetHistoDeltaPhiMin(); Float_t deltaetamin = GetHistogramRanges()->GetHistoDeltaEtaMin(); + + Int_t ntrbins = GetHistogramRanges()->GetHistoTrackMultiplicityBins(); Int_t nclbins = GetHistogramRanges()->GetHistoNClustersBins(); + Int_t trmax = GetHistogramRanges()->GetHistoTrackMultiplicityMax(); Int_t clmax = GetHistogramRanges()->GetHistoNClustersMax(); + Int_t trmin = GetHistogramRanges()->GetHistoTrackMultiplicityMin(); Int_t clmin = GetHistogramRanges()->GetHistoNClustersMin(); + + Int_t nxeztbins = GetHistogramRanges()->GetHistoRatioBins(); Int_t nhbpbins = GetHistogramRanges()->GetHistoHBPBins(); + Float_t xeztmax = GetHistogramRanges()->GetHistoRatioMax(); Float_t hbpmax = GetHistogramRanges()->GetHistoHBPMax(); + Float_t xeztmin = GetHistogramRanges()->GetHistoRatioMin(); Float_t hbpmin = GetHistogramRanges()->GetHistoHBPMin(); Int_t nMixBins = GetNCentrBin()*GetNZvertBin()*GetNRPBin(); + TString nameMC[] = {"Photon","Pi0","Pi0Decay","EtaDecay","OtherDecay","Electron","Hadron","Pi0DecayLostPair"}; + TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ; + // For vz dependent histograms, if option ON Int_t nz = 1 ; if(fCorrelVzBin) nz = GetNZvertBin(); TString sz = "" ; TString tz = "" ; - fhPtInput = new TH1F("hPtInput","p_T distribution of input trigger particles", nptbins,ptmin,ptmax); - fhPtInput->SetXTitle("p_{T}^{trig} (GeV/c)"); - outputContainer->Add(fhPtInput); - - fhPtFidCut = new TH1F("hPtFidCut","p_T distribution of input trigger particles after fiducial cut", nptbins,ptmin,ptmax); - fhPtFidCut->SetXTitle("p_{T}^{trig} (GeV/c)"); - outputContainer->Add(fhPtFidCut); - - fhPtLeading = new TH1F("hPtLeading","p_T distribution of leading particles", nptbins,ptmin,ptmax); - fhPtLeading->SetXTitle("p_{T}^{trig} (GeV/c)"); - outputContainer->Add(fhPtLeading); - - if(fCorrelVzBin) + // Fill histograms for neutral clusters in mixing? + Bool_t isoCase = OnlyIsolated() && (GetIsolationCut()->GetParticleTypeInCone() != AliIsolationCut::kOnlyCharged); + Bool_t neutralMix = fFillNeutralEventMixPool || isoCase ; + + fhPtTriggerInput = new TH1F("hPtTriggerInput","Input trigger #it{p}_{T}", nptbins,ptmin,ptmax); + fhPtTriggerInput->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtTriggerInput); + + if( fM02MaxCut > 0 && fM02MinCut > 0 ) { - fhPtLeadingVzBin = new TH2F("hPtLeadingVzBin","p_T distribution of leading particles vs vz bin", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin()); - fhPtLeadingVzBin->SetXTitle("p_{T}^{trig} (GeV/c)"); - fhPtLeadingVzBin->SetYTitle("v_{z} bin"); - outputContainer->Add(fhPtLeadingVzBin); + fhPtTriggerSSCut = new TH1F("hPtTriggerSSCut","Trigger #it{p}_{T} after #lambda^{2}_{0} cut", nptbins,ptmin,ptmax); + fhPtTriggerSSCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtTriggerSSCut); } - fhPtLeadingBin = new TH2F ("hPtLeadingBin","p_T distribution of leading particles", nptbins,ptmin,ptmax,nMixBins,0,nMixBins); - fhPtLeadingBin->SetXTitle("p_{T}^{trig} (GeV/c)"); - fhPtLeadingBin->SetYTitle("Bin"); - outputContainer->Add(fhPtLeadingBin); - - fhPhiLeading = new TH2F ("hPhiLeading","#phi distribution of leading Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax); - fhPhiLeading->SetYTitle("#phi (rad)"); - outputContainer->Add(fhPhiLeading); - - fhEtaLeading = new TH2F ("hEtaLeading","#eta distribution of leading",nptbins,ptmin,ptmax, netabins,etamin,etamax); - fhEtaLeading->SetYTitle("#eta "); - outputContainer->Add(fhEtaLeading); - - fhPtLeadingCentrality = new TH2F("hPtLeadingCentrality","Leading particle p_{T} vs centrality",nptbins,ptmin,ptmax,100,0.,100) ; - fhPtLeadingCentrality->SetXTitle("p_{T}^{trig} (GeV/c)"); - fhPtLeadingCentrality->SetYTitle("Centrality (%)"); - outputContainer->Add(fhPtLeadingCentrality) ; + if( OnlyIsolated() ) + { + fhPtTriggerIsoCut = new TH1F("hPtTriggerIsoCut","Trigger #it{p}_{T} after isolation (and #lambda^{2}_{0} cut)", nptbins,ptmin,ptmax); + fhPtTriggerIsoCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtTriggerIsoCut); + } - fhPtLeadingEventPlane = new TH2F("hPtLeadingEventPlane","Leading particle p_{T} vs event plane angle",nptbins,ptmin,ptmax, 100,0.,TMath::Pi()) ; - fhPtLeadingEventPlane->SetXTitle("p_{T}^{trig} (GeV/c)"); - fhPtLeadingEventPlane->SetXTitle("EP angle (rad)"); - outputContainer->Add(fhPtLeadingEventPlane) ; + fhPtTriggerFidCut = new TH1F("hPtTriggerFidCut","Trigger #it{p}_{T} after fiducial (isolation and #lambda^{2}_{0}) cut", nptbins,ptmin,ptmax); + fhPtTriggerFidCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtTriggerFidCut); - fhLeadingEventPlaneCentrality = new TH2F("hLeadingEventPlane","Leading particle centrality vs event plane angle",100,0.,100,100,0.,TMath::Pi()) ; - fhLeadingEventPlaneCentrality->SetXTitle("Centrality (%)"); - fhLeadingEventPlaneCentrality->SetYTitle("EP angle (rad)"); - outputContainer->Add(fhLeadingEventPlaneCentrality) ; + fhPtTrigger = new TH1F("hPtTrigger","#it{p}_{T} distribution of trigger particles (after opposite hadron leading cut and rest)", nptbins,ptmin,ptmax); + fhPtTrigger->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtTrigger); - //Correlation with charged hadrons - if(GetReader()->IsCTSSwitchedOn()) - { - fhDeltaPhiDeltaEtaCharged = new TH2F - ("hDeltaPhiDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}}", - ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax); - fhDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi"); - fhDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta"); - - fhPhiCharged = new TH2F - ("hPhiCharged","#phi_{h^{#pm}} vs p_{T #pm}", - nptbins,ptmin,ptmax,nphibins,phimin,phimax); - fhPhiCharged->SetYTitle("#phi_{h^{#pm}} (rad)"); - fhPhiCharged->SetXTitle("p_{T #pm} (GeV/c)"); - - fhEtaCharged = new TH2F - ("hEtaCharged","#eta_{h^{#pm}} vs p_{T #pm}", - nptbins,ptmin,ptmax,netabins,etamin,etamax); - fhEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)"); - fhEtaCharged->SetXTitle("p_{T #pm} (GeV/c)"); - - fhDeltaPhiCharged = new TH2F - ("hDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiCharged->SetYTitle("#Delta #phi"); - fhDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)"); - - fhDeltaPhiChargedPt = new TH2F - ("hDeltaPhiChargedPt","#phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiChargedPt->SetYTitle("#Delta #phi"); - fhDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - - fhDeltaPhiUeChargedPt = new TH2F - ("hDeltaPhiUeChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}}", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi"); - fhDeltaPhiUeChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - - fhUePart = new TH1F("hUePart","UE particles distribution vs pt trig", - nptbins,ptmin,ptmax); - fhUePart->SetYTitle("dNch"); - fhUePart->SetXTitle("p_{T trigger}"); - - - fhDeltaEtaCharged = new TH2F - ("hDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}", - nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax); - fhDeltaEtaCharged->SetYTitle("#Delta #eta"); - fhDeltaEtaCharged->SetXTitle("p_{T trigger} (GeV/c)"); - - fhXECharged = - new TH2F("hXECharged","x_{E} for charged tracks", - nptbins,ptmin,ptmax,200,0.,2.); - fhXECharged->SetYTitle("x_{E}"); - fhXECharged->SetXTitle("p_{T trigger}"); - - fhXEUeCharged = - new TH2F("hXEUeCharged","x_{E} for Underlying Event", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeCharged->SetYTitle("x_{E}"); - fhXEUeCharged->SetXTitle("p_{T trigger}"); - - fhXEPosCharged = - new TH2F("hXEPositiveCharged","x_{E} for positive charged tracks", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEPosCharged->SetYTitle("x_{E}"); - fhXEPosCharged->SetXTitle("p_{T trigger}"); - - fhXENegCharged = - new TH2F("hXENegativeCharged","x_{E} for negative charged tracks", - nptbins,ptmin,ptmax,200,0.,2.); - fhXENegCharged->SetYTitle("x_{E}"); - fhXENegCharged->SetXTitle("p_{T trigger}"); - - fhPtHbpXECharged = - new TH2F("hHbpXECharged","#xi = ln(1/x_{E}) with charged hadrons", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXECharged->SetYTitle("ln(1/x_{E})"); - fhPtHbpXECharged->SetXTitle("p_{T trigger}"); - - fhPtHbpXEUeCharged = - new TH2F("hHbpXEUeCharged","#xi = ln(1/x_{E}) with charged hadrons,Underlying Event", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXEUeCharged->SetYTitle("ln(1/x_{E})"); - fhPtHbpXEUeCharged->SetXTitle("p_{T trigger}"); - - fhZTCharged = - new TH2F("hZTCharged","z_{T} for charged tracks", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTCharged->SetYTitle("z_{T}"); - fhZTCharged->SetXTitle("p_{T trigger}"); - - fhZTUeCharged = - new TH2F("hZTUeCharged","z_{T} for Underlying Event", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTUeCharged->SetYTitle("z_{T}"); - fhZTUeCharged->SetXTitle("p_{T trigger}"); - - fhZTPosCharged = - new TH2F("hZTPositiveCharged","z_{T} for positive charged tracks", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTPosCharged->SetYTitle("z_{T}"); - fhZTPosCharged->SetXTitle("p_{T trigger}"); - - fhZTNegCharged = - new TH2F("hZTNegativeCharged","z_{T} for negative charged tracks", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTNegCharged->SetYTitle("z_{T}"); - fhZTNegCharged->SetXTitle("p_{T trigger}"); - - fhPtHbpZTCharged = - new TH2F("hHbpZTCharged","#xi = ln(1/z_{T}) with charged hadrons", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpZTCharged->SetYTitle("ln(1/z_{T})"); - fhPtHbpZTCharged->SetXTitle("p_{T trigger}"); - - fhPtHbpZTUeCharged = - new TH2F("hHbpZTUeCharged","#xi = ln(1/z_{T}) with charged hadrons,Underlying Event", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpZTUeCharged->SetYTitle("ln(1/x_{E})"); - fhPtHbpZTUeCharged->SetXTitle("p_{T trigger}"); - - fhPtTrigPout = - new TH2F("hPtTrigPout","Pout with triggers", - nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax); - fhPtTrigPout->SetYTitle("p_{out} (GeV/c)"); - fhPtTrigPout->SetXTitle("p_{T trigger} (GeV/c)"); - - fhPtTrigCharged = - new TH2F("hPtTrigCharged","trgger and charged tracks pt distribution", - nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); - fhPtTrigCharged->SetYTitle("p_{T h^{#pm}} (GeV/c)"); - fhPtTrigCharged->SetXTitle("p_{T trigger} (GeV/c)"); - - outputContainer->Add(fhDeltaPhiDeltaEtaCharged); - outputContainer->Add(fhPhiCharged) ; - outputContainer->Add(fhEtaCharged) ; - outputContainer->Add(fhDeltaPhiCharged) ; - outputContainer->Add(fhDeltaEtaCharged) ; - outputContainer->Add(fhDeltaPhiChargedPt) ; - outputContainer->Add(fhDeltaPhiUeChargedPt) ; - outputContainer->Add(fhUePart); - - outputContainer->Add(fhXECharged) ; - outputContainer->Add(fhXEPosCharged) ; - outputContainer->Add(fhXENegCharged) ; - outputContainer->Add(fhXEUeCharged) ; - outputContainer->Add(fhPtHbpXECharged) ; - outputContainer->Add(fhPtHbpXEUeCharged) ; - - outputContainer->Add(fhZTCharged) ; - outputContainer->Add(fhZTPosCharged) ; - outputContainer->Add(fhZTNegCharged) ; - outputContainer->Add(fhZTUeCharged) ; - outputContainer->Add(fhPtHbpZTCharged) ; - outputContainer->Add(fhPtHbpZTUeCharged) ; - - outputContainer->Add(fhPtTrigPout) ; - outputContainer->Add(fhPtTrigCharged) ; - - if(DoEventSelect()) - { - Int_t nMultiBins = GetMultiBin(); - fhTrigDeltaPhiCharged = new TH2F*[nMultiBins] ; - fhTrigDeltaEtaCharged = new TH2F*[nMultiBins] ; - fhTrigXECorr = new TH2F*[nMultiBins] ; - fhTrigXEUeCorr = new TH2F*[nMultiBins] ; - fhTrigZTCorr = new TH2F*[nMultiBins] ; - fhTrigZTUeCorr = new TH2F*[nMultiBins] ; - - for(Int_t im=0; imSetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtTriggerMC[i]); + } + } + + if(fDecayTrigger) + { + for(Int_t ibit = 0; ibit < fNDecayBits; ibit++) + { + fhPtDecayTrigger[ibit] = new TH1F(Form("hPtDecayTrigger_bit%d",fDecayBits[ibit]), + Form("#it{p}_{T} distribution of trigger particles, decay Bit %d",fDecayBits[ibit]), + nptbins,ptmin,ptmax); + fhPtDecayTrigger[ibit]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtDecayTrigger[ibit]); + + if(IsDataMC()) { - fhTrigDeltaPhiCharged[im] = new TH2F - (Form("hTrigDeltaPhiCharged_%d",im),Form("hTrigDeltaPhiCharged_%d",im), nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhTrigDeltaPhiCharged[im]->SetXTitle("p_{T trigger} (GeV/c)"); - fhTrigDeltaPhiCharged[im]->SetYTitle("#Delta #phi"); - - fhTrigDeltaEtaCharged[im] = new TH2F - (Form("hTrigDeltaEtaCharged_%d",im),Form("hTrigDeltaEtaCharged_%d",im), nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax); - fhTrigDeltaEtaCharged[im]->SetXTitle("p_{T trigger} (GeV/c)"); - fhTrigDeltaEtaCharged[im]->SetYTitle("#Delta #eta"); - - fhTrigXECorr[im] = new TH2F - (Form("hTrigXEPtCorr_%d",im),Form("hTrigXEPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.); - fhTrigXECorr[im]->SetYTitle("x_{E trigger h^{#pm}}"); - fhTrigXECorr[im]->SetXTitle("p_{T trigger}"); - - fhTrigXEUeCorr[im] = new TH2F - (Form("hTrigXEPtUeCorr_%d",im),Form("hTrigXEPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.); - fhTrigXEUeCorr[im]->SetYTitle("x_{E trigger h^{#pm}}"); - fhTrigXEUeCorr[im]->SetXTitle("p_{T trigger}"); - - fhTrigZTCorr[im] = new TH2F - (Form("hTrigZTPtCorr_%d",im),Form("hTrigZTPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.); - fhTrigZTCorr[im]->SetYTitle("z_{trigger h^{#pm}}"); - fhTrigZTCorr[im]->SetXTitle("p_{T trigger}"); - - fhTrigZTUeCorr[im] = new TH2F - (Form("hTrigZTPtUeCorr_%d",im),Form("hTrigZTPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.); - fhTrigZTUeCorr[im]->SetYTitle("z_{trigger h^{#pm}}"); - fhTrigZTUeCorr[im]->SetXTitle("p_{T trigger}"); - - outputContainer->Add(fhTrigDeltaPhiCharged[im]) ; - outputContainer->Add(fhTrigDeltaEtaCharged[im]) ; - outputContainer->Add(fhTrigXECorr[im]); - outputContainer->Add(fhTrigXEUeCorr[im]); - outputContainer->Add(fhTrigZTCorr[im]); - outputContainer->Add(fhTrigZTUeCorr[im]); + for(Int_t i=0; i < fgkNmcTypes; i++) + { + fhPtDecayTriggerMC[ibit][i] = new TH1F(Form("hPtDecayTrigger_bit%d_MC%s",fDecayBits[ibit], nameMC[i].Data()), + Form("#it{p}_{T} distribution of trigger particles, decay Bit %d, trigger origin is %s",fDecayBits[ibit], nameMC[i].Data()), + nptbins,ptmin,ptmax); + fhPtDecayTriggerMC[ibit][i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtDecayTriggerMC[ibit][i]); + } } } + } + + if(fCorrelVzBin) + { + fhPtTriggerVzBin = new TH2F("hPtTriggerVzBin","#it{p}_{T} distribution of trigger particles vs vz bin", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin()); + fhPtTriggerVzBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtTriggerVzBin->SetYTitle("#it{v}_{#it{z}} bin"); + outputContainer->Add(fhPtTriggerVzBin); + } + + fhPtTriggerBin = new TH2F ("hPtTriggerBin","#it{p}_{T} distribution of trigger particles", nptbins,ptmin,ptmax,nMixBins,0,nMixBins); + fhPtTriggerBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtTriggerBin->SetYTitle("Bin"); + outputContainer->Add(fhPtTriggerBin); + + fhPhiTrigger = new TH2F ("hPhiTrigger","#phi distribution of trigger Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax); + fhPhiTrigger->SetYTitle("#phi (rad)"); + outputContainer->Add(fhPhiTrigger); + + fhEtaTrigger = new TH2F ("hEtaTrigger","#eta distribution of trigger",nptbins,ptmin,ptmax, netabins,etamin,etamax); + fhEtaTrigger->SetYTitle("#eta "); + outputContainer->Add(fhEtaTrigger); + + if(IsHighMultiplicityAnalysisOn()) + { + fhPtTriggerCentrality = new TH2F("hPtTriggerCentrality","Trigger particle #it{p}_{T} vs centrality",nptbins,ptmin,ptmax,100,0.,100) ; + fhPtTriggerCentrality->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtTriggerCentrality->SetYTitle("Centrality (%)"); + outputContainer->Add(fhPtTriggerCentrality) ; + + fhPtTriggerEventPlane = new TH2F("hPtTriggerEventPlane","Trigger particle #it{p}_{T} vs event plane angle",nptbins,ptmin,ptmax, 100,0.,TMath::Pi()) ; + fhPtTriggerEventPlane->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtTriggerEventPlane->SetXTitle("EP angle (rad)"); + outputContainer->Add(fhPtTriggerEventPlane) ; + + fhTriggerEventPlaneCentrality = new TH2F("hTriggerEventPlaneCentrality","Trigger particle centrality vs event plane angle",100,0.,100,100,0.,TMath::Pi()) ; + fhTriggerEventPlaneCentrality->SetXTitle("Centrality (%)"); + fhTriggerEventPlaneCentrality->SetYTitle("EP angle (rad)"); + outputContainer->Add(fhTriggerEventPlaneCentrality) ; + } + + // Leading hadron in oposite side + if(fFillLeadHadOppositeHisto) + { + fhPtLeadingOppositeHadron = new TH2F("hPtTriggerPtLeadingOppositeHadron","Leading hadron opposite to trigger vs trigger #it{p}_{T}", + nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); + fhPtLeadingOppositeHadron->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtLeadingOppositeHadron->SetYTitle("#it{p}_{T}^{lead hadron} (GeV/#it{c})"); + outputContainer->Add(fhPtLeadingOppositeHadron); + + fhPtNoLeadingOppositeHadron = new TH1F("hPtTriggerNoLeadingOppositeHadron","No Leading hadron opposite to trigger #it{p}_{T}", + nptbins,ptmin,ptmax); + fhPtNoLeadingOppositeHadron->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtNoLeadingOppositeHadron); + + fhEtaPhiNoLeadingOppositeHadron = new TH2F("hEtaPhiTriggerNoLeadingOppositeHadron","No Leading hadron opposite to trigger #eta:#phi", + netabins,etamin,etamax,nphibins,phimin,phimax); + fhEtaPhiNoLeadingOppositeHadron->SetXTitle("#eta"); + fhEtaPhiNoLeadingOppositeHadron->SetYTitle("#phi"); + outputContainer->Add(fhEtaPhiNoLeadingOppositeHadron); + - if(fFillBradHisto) + fhPtDiffPhiLeadingOppositeHadron = new TH2F("hPtTriggerDiffPhiTriggerLeadingOppositeHadron","#phi_{trigger}-#phi_{leading opposite hadron} vs #it{p}_{T}^{trig}", + nptbins,ptmin,ptmax,ndeltaphibins,deltaphimin,deltaphimax); + fhPtDiffPhiLeadingOppositeHadron->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtDiffPhiLeadingOppositeHadron->SetYTitle("#phi_{trigger}-#phi_{leading opposite hadron} (rad)"); + outputContainer->Add(fhPtDiffPhiLeadingOppositeHadron); + + fhPtDiffEtaLeadingOppositeHadron = new TH2F("hPtTriggerDiffEtaTriggerPhiLeadingOppositeHadron","#eta_{trigger}-#eta_{leading opposite hadron} vs #it{p}_{T}^{trig}", + nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax); + fhPtDiffEtaLeadingOppositeHadron->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtDiffEtaLeadingOppositeHadron->SetYTitle("#eta_{trigger}-#eta_{leading opposite hadron}"); + outputContainer->Add(fhPtDiffEtaLeadingOppositeHadron); + } + + //Correlation with charged hadrons + + fhDeltaPhiDeltaEtaCharged = new TH2F + ("hDeltaPhiDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}}", + ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax); + fhDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)"); + fhDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta"); + + fhDeltaPhiDeltaEtaChargedPtA3GeV = new TH2F + ("hDeltaPhiDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}, #it{p}_{TA}>3 GeV/#it{c}}", + ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax); + fhDeltaPhiDeltaEtaChargedPtA3GeV->SetXTitle("#Delta #phi (rad)"); + fhDeltaPhiDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta"); + + fhPhiCharged = new TH2F + ("hPhiCharged","#phi_{h^{#pm}} vs #it{p}_{T #pm}", + nptbins,ptmin,ptmax,180,0,TMath::TwoPi()); + fhPhiCharged->SetYTitle("#phi_{h^{#pm}} (rad)"); + fhPhiCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})"); + + fhEtaCharged = new TH2F + ("hEtaCharged","#eta_{h^{#pm}} vs #it{p}_{T #pm}", + nptbins,ptmin,ptmax,100,-1.,1.); + fhEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)"); + fhEtaCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})"); + + fhDeltaPhiCharged = new TH2F + ("hDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiCharged->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhDeltaPhiChargedPtA3GeV = new TH2F + ("hDeltaPhiChargedPtA3GeV","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedPtA3GeV->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedPtA3GeV->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + + fhDeltaPhiChargedPt = new TH2F + ("hDeltaPhiChargedPt","#phi_{trigger} - #phi_{#h^{#pm}} vs #it{p}_{T h^{#pm}}", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + + fhDeltaEtaCharged = new TH2F + ("hDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}", + nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax); + fhDeltaEtaCharged->SetYTitle("#Delta #eta"); + fhDeltaEtaCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhDeltaEtaChargedPtA3GeV = new TH2F + ("hDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}", + nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax); + fhDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta"); + fhDeltaEtaChargedPtA3GeV->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXECharged = + new TH2F("hXECharged","#it{x}_{#it{E}} for charged tracks", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXECharged->SetYTitle("#it{x}_{#it{E}}"); + fhXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXECharged_Cone2 = + new TH2F("hXECharged_Cone2","#it{x}_{#it{E}} for charged tracks in cone 2 (5#pi/6-7#pi/6)", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXECharged_Cone2->SetYTitle("#it{x}_{#it{E}}"); + fhXECharged_Cone2->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXEPosCharged = + new TH2F("hXEPositiveCharged","#it{x}_{#it{E}} for positive charged tracks", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEPosCharged->SetYTitle("#it{x}_{#it{E}}"); + fhXEPosCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXENegCharged = + new TH2F("hXENegativeCharged","#it{x}_{#it{E}} for negative charged tracks", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXENegCharged->SetYTitle("#it{x}_{#it{E}}"); + fhXENegCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpXECharged = + new TH2F("hHbpXECharged","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhPtHbpXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpXECharged_Cone2 = + new TH2F("hHbpXECharged_Cone2","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons in cone 2 (5#pi/6-7#pi/6)", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpXECharged_Cone2->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhPtHbpXECharged_Cone2->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTCharged = + new TH2F("hZTCharged","#it{z}_{T} for charged tracks", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTCharged->SetYTitle("#it{z}_{T}"); + fhZTCharged->SetXTitle("#it{p}_{T trigger}"); + + fhZTPosCharged = + new TH2F("hZTPositiveCharged","#it{z}_{T} for positive charged tracks", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTPosCharged->SetYTitle("#it{z}_{T}"); + fhZTPosCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTNegCharged = + new TH2F("hZTNegativeCharged","#it{z}_{T} for negative charged tracks", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTNegCharged->SetYTitle("#it{z}_{T}"); + fhZTNegCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpZTCharged = + new TH2F("hHbpZTCharged","#xi = ln(1/#it{z}_{T}) with charged hadrons", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpZTCharged->SetYTitle("ln(1/#it{z}_{T})"); + fhPtHbpZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtTrigPout = + new TH2F("hPtTrigPout","Pout with triggers", + nptbins,ptmin,ptmax,nptbins,-1.*ptmax/2.,ptmax/2.); + fhPtTrigPout->SetYTitle("#it{p}_{out} (GeV/#it{c})"); + fhPtTrigPout->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtTrigCharged = + new TH2F("hPtTrigCharged","trigger and charged tracks pt distribution", + nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); + fhPtTrigCharged->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + fhPtTrigCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhDeltaPhiDeltaEtaCharged); + outputContainer->Add(fhDeltaPhiDeltaEtaChargedPtA3GeV); + outputContainer->Add(fhPhiCharged) ; + outputContainer->Add(fhEtaCharged) ; + outputContainer->Add(fhDeltaPhiCharged) ; + outputContainer->Add(fhDeltaPhiChargedPtA3GeV) ; + outputContainer->Add(fhDeltaEtaCharged) ; + outputContainer->Add(fhDeltaEtaChargedPtA3GeV) ; + outputContainer->Add(fhDeltaPhiChargedPt) ; + + outputContainer->Add(fhXECharged) ; + outputContainer->Add(fhXECharged_Cone2) ; + + if(IsDataMC()) + { + for(Int_t i=0; i < fgkNmcTypes; i++) { - fhAssocPtBkg = new TH2F("hAssocPtBkg", " Trigger p_{T} vs associated hadron p_{T} from background", - nptbins, ptmin, ptmax,nptbins,ptmin,ptmax); - fhAssocPtBkg->SetXTitle("p_{T trigger}"); - fhAssocPtBkg->SetYTitle("p_{T associated}"); - outputContainer->Add(fhAssocPtBkg) ; - fhDeltaPhiBrad = new TH2F("hDeltaPhiBrad","atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs p_{T trigger} ", - nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0); - fhDeltaPhiBrad->SetXTitle("p_{T trigger}"); - fhDeltaPhiBrad->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi"); - outputContainer->Add(fhDeltaPhiBrad) ; + fhDeltaPhiChargedMC[i] = new TH2F(Form("hDeltaPhiCharged_MC%s",nameMC[i].Data()), + Form("#Delta #phi for charged tracks, trigger origin is %s",nameMC[i].Data()), + nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedMC[i]->SetYTitle("#it{x}_{#it{E}}"); + fhDeltaPhiChargedMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhDeltaPhiChargedMC[i]) ; + + fhXEChargedMC[i] = new TH2F(Form("hXECharged_MC%s",nameMC[i].Data()), + Form("#it{x}_{#it{E}} for charged tracks, trigger origin is %s",nameMC[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEChargedMC[i]->SetYTitle("#it{x}_{#it{E}}"); + fhXEChargedMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhXEChargedMC[i]) ; } - - fhDeltaPhiDeltaEtaAssocPtBin = new TH2F*[fNAssocPtBins*nz]; - fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz]; - fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz]; - fhDeltaPhiAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz]; - fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz]; - fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + } + + outputContainer->Add(fhXEPosCharged) ; + outputContainer->Add(fhXENegCharged) ; + outputContainer->Add(fhPtHbpXECharged) ; + outputContainer->Add(fhPtHbpXECharged_Cone2) ; + + outputContainer->Add(fhZTCharged) ; + outputContainer->Add(fhZTPosCharged) ; + outputContainer->Add(fhZTNegCharged) ; + outputContainer->Add(fhPtHbpZTCharged) ; + + outputContainer->Add(fhPtTrigPout) ; + outputContainer->Add(fhPtTrigCharged) ; + + TString right = ""; + if(fMakeSeveralUE) right = "Right"; + + fhUePart = new TH1F("hUePart","UE particles distribution vs pt trig", + nptbins,ptmin,ptmax); + fhUePart->SetYTitle("dNch"); + fhUePart->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhDeltaPhiUeChargedPt = new TH2F + (Form("hDeltaPhiUe%sChargedPt",right.Data()),"#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}}", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiUeChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + + fhXEUeCharged = + new TH2F(Form("hXEUeCharged%s",right.Data()),"#it{x}_{#it{E}} for Underlying Event", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeCharged->SetYTitle("#it{x}_{#it{E}}"); + fhXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpXEUeCharged = + new TH2F(Form("hHbpXEUeCharged%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for Underlying Event", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpXEUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhPtHbpXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTUeCharged = + new TH2F(Form("hZTUeCharged%s",right.Data()),"#it{z}_{T} for Underlying Event", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeCharged->SetYTitle("#it{z}_{T}"); + fhZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpZTUeCharged = + new TH2F(Form("hHbpZTUeCharged%s",right.Data()),"#xi = ln(1/#it{z}_{T}) for Underlying Event", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpZTUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhPtHbpZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhUePart); + outputContainer->Add(fhDeltaPhiUeChargedPt) ; + outputContainer->Add(fhXEUeCharged) ; + outputContainer->Add(fhPtHbpXEUeCharged) ; + outputContainer->Add(fhZTUeCharged) ; + outputContainer->Add(fhPtHbpZTUeCharged) ; + + if(fMakeSeveralUE) + { + fhDeltaPhiUeLeftCharged = new TH2F + ("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left side range of trigger particles", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiUeLeftCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + outputContainer->Add(fhDeltaPhiUeLeftCharged) ; + + fhDeltaPhiUeLeftUpCharged = new TH2F + ("hDeltaPhiUeLeftUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Up side range of trigger particles", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiUeLeftUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + outputContainer->Add(fhDeltaPhiUeLeftUpCharged) ; + + fhDeltaPhiUeRightUpCharged = new TH2F + ("hDeltaPhiUeRightUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Up side range of trigger particles", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiUeRightUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + outputContainer->Add(fhDeltaPhiUeRightUpCharged) ; - if(fFillBradHisto) - fhDeltaPhiBradAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + fhDeltaPhiUeLeftDownCharged = new TH2F + ("hDeltaPhiUeLeftDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Down side range of trigger particles", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiUeLeftDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + outputContainer->Add(fhDeltaPhiUeLeftDownCharged) ; - if(fPi0Trigger || fDecayTrigger) + fhDeltaPhiUeRightDownCharged = new TH2F + ("hDeltaPhiUeRightDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Down side range of trigger particles", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiUeRightDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + outputContainer->Add(fhDeltaPhiUeRightDownCharged) ; + + fhXEUeLeftCharged = + new TH2F("hXEUeChargedLeft","#it{x}_{#it{E}} with UE left side of trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeLeftCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}"); + fhXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhXEUeLeftCharged) ; + + fhXEUeLeftUpCharged = + new TH2F("hXEUeChargedLeftUp","#it{x}_{#it{E}} with UE left Up side of trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeLeftUpCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}"); + fhXEUeLeftUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhXEUeLeftUpCharged) ; + + fhXEUeRightUpCharged = + new TH2F("hXEUeChargedRightUp","#it{x}_{#it{E} h^{#pm}} with UE right Up side of trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeRightUpCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}"); + fhXEUeRightUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhXEUeRightUpCharged) ; + + fhXEUeLeftDownCharged = + new TH2F("hXEUeChargedLeftDown","#it{x}_{#it{E}} with UE left Down side of trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeLeftDownCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}"); + fhXEUeLeftDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhXEUeLeftDownCharged) ; + + fhXEUeRightDownCharged = + new TH2F("hXEUeChargedRightDown","#it{x}_{#it{E} h^{#pm}} with UE right Down side of trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeRightDownCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}"); + fhXEUeRightDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhXEUeRightDownCharged) ; + + fhPtHbpXEUeLeftCharged = + new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/#it{x}_{#it{E}}) with charged UE left side of trigger", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhPtHbpXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhPtHbpXEUeLeftCharged) ; + + fhZTUeLeftCharged = + new TH2F("hZTUeChargedLeft","#it{z}_{trigger h^{#pm}} = #it{p}_{T Ueh^{#pm}} / #it{p}_{T trigger} with UE left side of trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeLeftCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}"); + fhZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhZTUeLeftCharged) ; + + fhPtHbpZTUeLeftCharged = + new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/#it{z}_{T}) with charged UE left side of trigger", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/#it{z}_{T})"); + fhPtHbpZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhPtHbpZTUeLeftCharged) ; + } + + if(IsPileUpAnalysisOn()) + { + fhDeltaPhiChargedOtherBC = new TH2F + ("hDeltaPhiChargedOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC!=0", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedOtherBC->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhDeltaPhiChargedPtA3GeVOtherBC = new TH2F + ("hDeltaPhiChargedPtA3GeVOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC!=0", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedPtA3GeVOtherBC->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedPtA3GeVOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtTrigChargedOtherBC = + new TH2F("hPtTrigChargedOtherBC","trigger and charged tracks pt distribution, track BC!=0", + nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); + fhPtTrigChargedOtherBC->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + fhPtTrigChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXEChargedOtherBC = + new TH2F("hXEChargedOtherBC","#it{x}_{#it{E}} for charged tracks, track BC!=0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEChargedOtherBC->SetYTitle("#it{x}_{#it{E}}"); + fhXEChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXEUeChargedOtherBC = + new TH2F("hXEUeChargedOtherBC","#it{x}_{#it{E}} for Underlying Event, track BC!=0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeChargedOtherBC->SetYTitle("#it{x}_{#it{E}}"); + fhXEUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTChargedOtherBC = + new TH2F("hZTChargedOtherBC","#it{z}_{T} for charged tracks, track BC!=0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTChargedOtherBC->SetYTitle("#it{z}_{T}"); + fhZTChargedOtherBC->SetXTitle("#it{p}_{T trigger}"); + + fhZTUeChargedOtherBC = + new TH2F("hZTUeChargedOtherBC","#it{z}_{T} for Underlying Event, track BC!=0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeChargedOtherBC->SetYTitle("#it{z}_{T}"); + fhZTUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhDeltaPhiChargedOtherBC) ; + outputContainer->Add(fhDeltaPhiChargedPtA3GeVOtherBC) ; + outputContainer->Add(fhXEChargedOtherBC) ; + outputContainer->Add(fhXEUeChargedOtherBC) ; + outputContainer->Add(fhZTChargedOtherBC) ; + outputContainer->Add(fhZTUeChargedOtherBC) ; + outputContainer->Add(fhPtTrigChargedOtherBC) ; + + fhDeltaPhiChargedBC0 = new TH2F + ("hDeltaPhiChargedBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC==0", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedBC0->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhDeltaPhiChargedPtA3GeVBC0 = new TH2F + ("hDeltaPhiChargedPtA3GeVBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC==0", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedPtA3GeVBC0->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedPtA3GeVBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtTrigChargedBC0 = + new TH2F("hPtTrigChargedBC0","trigger and charged tracks pt distribution, track BC==0", + nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); + fhPtTrigChargedBC0->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + fhPtTrigChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXEChargedBC0 = + new TH2F("hXEChargedBC0","#it{x}_{#it{E}} for charged tracks, track BC==0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEChargedBC0->SetYTitle("#it{x}_{#it{E}}"); + fhXEChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXEUeChargedBC0 = + new TH2F("hXEUeChargedBC0","#it{x}_{#it{E}} for Underlying Event, track BC==0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeChargedBC0->SetYTitle("#it{x}_{#it{E}}"); + fhXEUeChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTChargedBC0 = + new TH2F("hZTChargedBC0","#it{z}_{T} for charged tracks, track BC==0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTChargedBC0->SetYTitle("#it{z}_{T}"); + fhZTChargedBC0->SetXTitle("#it{p}_{T trigger}"); + + fhZTUeChargedBC0 = + new TH2F("hZTUeChargedBC0","#it{z}_{T} for Underlying Event, track BC==0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeChargedBC0->SetYTitle("#it{z}_{T}"); + fhZTUeChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhDeltaPhiChargedBC0) ; + outputContainer->Add(fhDeltaPhiChargedPtA3GeVBC0) ; + outputContainer->Add(fhXEChargedBC0) ; + outputContainer->Add(fhXEUeChargedBC0) ; + outputContainer->Add(fhZTChargedBC0) ; + outputContainer->Add(fhZTUeChargedBC0) ; + outputContainer->Add(fhPtTrigChargedBC0) ; + + fhPtTriggerVtxBC0 = new TH1F("hPtTriggerVtxBC0","#it{p}_{T} distribution of trigger particles", nptbins,ptmin,ptmax); + fhPtTriggerVtxBC0->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + + fhDeltaPhiChargedVtxBC0 = new TH2F + ("hDeltaPhiChargedVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC==0", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedVtxBC0->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhDeltaPhiChargedPtA3GeVVtxBC0 = new TH2F + ("hDeltaPhiChargedPtA3GeVVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC==0", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedPtA3GeVVtxBC0->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedPtA3GeVVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtTrigChargedVtxBC0 = + new TH2F("hPtTrigChargedVtxBC0","trigger and charged tracks pt distribution, track BC==0", + nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); + fhPtTrigChargedVtxBC0->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + fhPtTrigChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXEChargedVtxBC0 = + new TH2F("hXEChargedVtxBC0","#it{x}_{#it{E}} for charged tracks, track BC==0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEChargedVtxBC0->SetYTitle("#it{x}_{#it{E}}"); + fhXEChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXEUeChargedVtxBC0 = + new TH2F("hXEUeChargedVtxBC0","#it{x}_{#it{E}} for Underlying Event, track BC==0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeChargedVtxBC0->SetYTitle("#it{x}_{#it{E}}"); + fhXEUeChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTChargedVtxBC0 = + new TH2F("hZTChargedVtxBC0","#it{z}_{T} for charged tracks, track BC==0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTChargedVtxBC0->SetYTitle("#it{z}_{T}"); + fhZTChargedVtxBC0->SetXTitle("#it{p}_{T trigger}"); + + fhZTUeChargedVtxBC0 = + new TH2F("hZTUeChargedVtxBC0","#it{z}_{T} for Underlying Event, track BC==0", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeChargedVtxBC0->SetYTitle("#it{z}_{T}"); + fhZTUeChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhPtTriggerVtxBC0); + outputContainer->Add(fhDeltaPhiChargedVtxBC0) ; + outputContainer->Add(fhDeltaPhiChargedPtA3GeVVtxBC0) ; + outputContainer->Add(fhXEChargedVtxBC0) ; + outputContainer->Add(fhXEUeChargedVtxBC0) ; + outputContainer->Add(fhZTChargedVtxBC0) ; + outputContainer->Add(fhZTUeChargedVtxBC0) ; + outputContainer->Add(fhPtTrigChargedVtxBC0) ; + + for(Int_t i = 0 ; i < 7 ; i++) { - fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz]; - fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz]; - fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz]; - fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz]; - fhXEDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz]; - fhZTDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz]; - fhDeltaPhiDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + fhPtTriggerPileUp[i] = new TH1F(Form("hPtTriggerPileUp%s",pileUpName[i].Data()), + Form("#it{p}_{T} distribution of trigger particles, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax); + fhPtTriggerPileUp[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + outputContainer->Add(fhPtTriggerPileUp[i]); + + fhDeltaPhiChargedPileUp[i] = new TH2F(Form("hDeltaPhiChargedPileUp%s",pileUpName[i].Data()), + Form("#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedPileUp[i]->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhDeltaPhiChargedPileUp[i]) ; + + fhDeltaPhiChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaPhiChargedPtA3GeVPileUp%s",pileUpName[i].Data()), + Form("#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiChargedPtA3GeVPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhDeltaPhiChargedPtA3GeVPileUp[i]) ; + + fhDeltaEtaChargedPileUp[i] = new TH2F(Form("hDeltaEtaChargedPileUp%s",pileUpName[i].Data()), + Form("#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax); + fhDeltaEtaChargedPileUp[i]->SetYTitle("#Delta #eta"); + fhDeltaEtaChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhDeltaEtaChargedPileUp[i]) ; + + fhDeltaEtaChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaEtaChargedPtA3GeVPileUp%s",pileUpName[i].Data()), + Form("#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax); + fhDeltaEtaChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #eta"); + fhDeltaEtaChargedPtA3GeVPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhDeltaEtaChargedPtA3GeVPileUp[i]) ; + + fhXEChargedPileUp[i] = new TH2F(Form("hXEChargedPileUp%s",pileUpName[i].Data()), + Form("#it{x}_{#it{E}} for charged tracks, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEChargedPileUp[i]->SetYTitle("#it{x}_{#it{E}}"); + fhXEChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhXEChargedPileUp[i]) ; + + fhXEUeChargedPileUp[i] = new TH2F(Form("hXEUeChargedPileUp%s",pileUpName[i].Data()), + Form("#it{x}_{#it{E}} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeChargedPileUp[i]->SetYTitle("#it{x}_{#it{E}}"); + fhXEUeChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhXEUeChargedPileUp[i]) ; + + fhZTChargedPileUp[i] = new TH2F(Form("hZTChargedPileUp%s",pileUpName[i].Data()), + Form("#it{z}_{T} for charged tracks, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTChargedPileUp[i]->SetYTitle("#it{z}_{T}"); + fhZTChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhZTChargedPileUp[i]) ; + + fhZTUeChargedPileUp[i] = new TH2F(Form("hZTUeChargedPileUp%s",pileUpName[i].Data()), + Form("#it{z}_{T} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeChargedPileUp[i]->SetYTitle("#it{z}_{T}"); + fhZTUeChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhZTUeChargedPileUp[i]) ; + + fhPtTrigChargedPileUp[i] = new TH2F(Form("hPtTrigChargedPileUp%s",pileUpName[i].Data()), + Form("trigger and charged tracks pt distribution, %s Pile-Up event",pileUpName[i].Data()), + nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); + fhPtTrigChargedPileUp[i]->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + fhPtTrigChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhPtTrigChargedPileUp[i]) ; + } + } - if(fHMPIDCorrelation) + if(IsHighMultiplicityAnalysisOn()) + { + Int_t nMultiBins = GetNCentrBin(); + fhDeltaPhiChargedMult = new TH2F*[nMultiBins] ; + fhDeltaEtaChargedMult = new TH2F*[nMultiBins] ; + fhXEMult = new TH2F*[nMultiBins] ; + fhXEUeMult = new TH2F*[nMultiBins] ; + fhZTMult = new TH2F*[nMultiBins] ; + fhZTUeMult = new TH2F*[nMultiBins] ; + + for(Int_t im=0; imSetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaPhiChargedMult[im]->SetYTitle("#Delta #phi (rad)"); + + fhDeltaEtaChargedMult[im] = new TH2F + (Form("hDeltaEtaCharged_Mult%d",im),Form("#Delta #eta charged Mult bin %d",im), nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax); + fhDeltaEtaChargedMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaEtaChargedMult[im]->SetYTitle("#Delta #eta"); + + fhXEMult[im] = new TH2F + (Form("hXECharged_Mult%d",im),Form("#it{x}_{E} charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEMult[im]->SetYTitle("#it{x}_{E}"); + fhXEMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXEUeMult[im] = new TH2F + (Form("hXEUeCharged_Mult%d",im),Form("#it{x}_{E} UE charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeMult[im]->SetYTitle("#it{x}_{E}"); + fhXEUeMult[im]->SetXTitle("#it{p}_{T trigger}(GeV/#it{c})"); + + fhZTMult[im] = new TH2F + (Form("hZTCharged_Mult%d",im),Form("#it{z}_{T} charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTMult[im]->SetYTitle("#it{z}_{T}"); + fhZTMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTUeMult[im] = new TH2F + (Form("hZTUeCharged_Mult%d",im),Form("#it{z}_{T} UE charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeMult[im]->SetYTitle("#it{z}_{T}"); + fhZTUeMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhDeltaPhiChargedMult[im]) ; + outputContainer->Add(fhDeltaEtaChargedMult[im]) ; + outputContainer->Add(fhXEMult [im]); + outputContainer->Add(fhXEUeMult[im]); + outputContainer->Add(fhZTMult [im]); + outputContainer->Add(fhZTUeMult[im]); } - - for(Int_t i = 0 ; i < fNAssocPtBins ; i++) + } + + if(fFillBradHisto) + { + fhAssocPtBkg = new TH2F("hAssocPtBkg", " Trigger #it{p}_{T} vs associated hadron #it{p}_{T} from background", + nptbins, ptmin, ptmax,nptbins,ptmin,ptmax); + fhAssocPtBkg->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhAssocPtBkg->SetYTitle("#it{p}_{T associated} (GeV/#it{c})"); + outputContainer->Add(fhAssocPtBkg) ; + + fhDeltaPhiBrad = new TH2F("hDeltaPhiBrad","atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs #it{p}_{T trigger} ", + nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0); + fhDeltaPhiBrad->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaPhiBrad->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi"); + outputContainer->Add(fhDeltaPhiBrad) ; + } + + fhDeltaPhiDeltaEtaAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz]; + fhDeltaPhiAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz]; + if(fFillMomImbalancePtAssocBinsHisto) + { + fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + } + + if(fCorrelVzBin) + { + fhXEVZ = new TH2F*[nz]; + fhZTVZ = new TH2F*[nz]; + } + + if(fFillBradHisto) + fhDeltaPhiBradAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + + + fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + if(fFillEtaGapsHisto)fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz]; + if(fDecayTrigger) fhDeltaPhiDecayChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz]; + + + if(fHMPIDCorrelation) + { + fhDeltaPhiAssocPtBinHMPID = new TH2F*[fNAssocPtBins*nz]; + fhDeltaPhiAssocPtBinHMPIDAcc= new TH2F*[fNAssocPtBins*nz]; + } + + for(Int_t i = 0 ; i < fNAssocPtBins ; i++) + { + for(Int_t z = 0 ; z < nz ; z++) { - for(Int_t z = 0 ; z < nz ; z++) + Int_t bin = i*nz+z; + + if(fCorrelVzBin) { - Int_t bin = i*nz+z; - - if(fCorrelVzBin) - { - sz = "_vz%d"+z; - tz = ", v_{z} bin "+z; - } - - //printf("iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data()); - - fhDeltaPhiDeltaEtaAssocPtBin[bin] = new TH2F(Form("hDeltaPhiDeltaEtaPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("#Delta #phi vs #Delta #eta for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax); - fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetXTitle("#Delta #phi"); - fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetYTitle("#Delta #eta"); - - fhDeltaPhiAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + sz = Form("_vz%d",z); + tz = Form(", #it{v}_{#it{z}} bin %d",z); + } + + //printf("iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data()); + + fhDeltaPhiDeltaEtaAssocPtBin[bin] = new TH2F(Form("hDeltaPhiDeltaEtaPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("#Delta #phi vs #Delta #eta for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax); + fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)"); + fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetYTitle("#Delta #eta"); + + fhDeltaPhiAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiAssocPtBin[bin]->SetXTitle("p_{T trigger}"); - fhDeltaPhiAssocPtBin[bin]->SetYTitle("#Delta #phi"); - - fhDeltaPhiAssocPtBinDEta08[bin] = new TH2F(Form("hDeltaPhiDeltaEta0.8PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("p_{T trigger}"); - fhDeltaPhiAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi"); - - fhDeltaPhiAssocPtBinDEta0[bin] = new TH2F(Form("hDeltaPhiDeltaEta0PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0.", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + fhDeltaPhiAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaPhiAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)"); + + outputContainer->Add(fhDeltaPhiDeltaEtaAssocPtBin[bin]) ; + outputContainer->Add(fhDeltaPhiAssocPtBin[bin]) ; + + if(fFillEtaGapsHisto) + { + fhDeltaPhiAssocPtBinDEta08[bin] = new TH2F(Form("hDeltaPhiDeltaEta0.8PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("p_{T trigger}"); - fhDeltaPhiAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi"); - - fhXEAssocPtBin[bin] = new TH2F(Form("hXEAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("x_{E} vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - nptbins, ptmin, ptmax,200, 0.0, 2.0); - fhXEAssocPtBin[bin]->SetXTitle("p_{T trigger}"); - fhXEAssocPtBin[bin]->SetYTitle("x_{E}"); + fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaPhiAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)"); - fhZTAssocPtBin[bin] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("z_{T} vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - nptbins, ptmin, ptmax,200, 0.0, 2.0); - fhZTAssocPtBin[bin]->SetXTitle("p_{T trigger}"); - fhZTAssocPtBin[bin]->SetYTitle("z_{T}"); + fhDeltaPhiAssocPtBinDEta0[bin] = new TH2F(Form("hDeltaPhiDeltaEta0PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0.", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaPhiAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)"); - outputContainer->Add(fhDeltaPhiDeltaEtaAssocPtBin[bin]) ; - outputContainer->Add(fhDeltaPhiAssocPtBin[bin]) ; outputContainer->Add(fhDeltaPhiAssocPtBinDEta08[bin]) ; outputContainer->Add(fhDeltaPhiAssocPtBinDEta0[bin]) ; - outputContainer->Add(fhXEAssocPtBin[bin]); - outputContainer->Add(fhZTAssocPtBin[bin]); - - if(fPi0Trigger || fDecayTrigger) - { - fhDeltaPhiDecayChargedAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtDecayChargedAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("#Delta #phi vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + } + + if(fDecayTrigger) + { + fhDeltaPhiDecayChargedAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtDecayChargedAssocPt%2.1f_%2.1f%s_bit%d", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data(),fDecayBits[0]), + Form("#Delta #phi vs #it{p}_{T trigger} tagged as decay for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, Bit %d", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data(),fDecayBits[0]), nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger}"); - fhDeltaPhiDecayChargedAssocPtBin[bin]->SetYTitle("#Delta #phi"); - - fhXEDecayChargedAssocPtBin[bin] = new TH2F(Form("hXEDecayChargedAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("x_{E} vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - nptbins, ptmin, ptmax,200, 0.0, 2.0); - fhXEDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger}"); - fhXEDecayChargedAssocPtBin[bin]->SetYTitle("x_{E}"); - - fhZTDecayChargedAssocPtBin[bin] = new TH2F(Form("hZTDecayChargedAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("z_{T} vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - nptbins, ptmin, ptmax,200, 0.0, 2.0); - fhZTDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger}"); - fhZTDecayChargedAssocPtBin[bin]->SetYTitle("z_{T}"); - - outputContainer->Add(fhDeltaPhiDecayChargedAssocPtBin[bin]) ; - outputContainer->Add(fhXEDecayChargedAssocPtBin[bin]); - outputContainer->Add(fhZTDecayChargedAssocPtBin[bin]); - - } + fhDeltaPhiDecayChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaPhiDecayChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)"); - if(fFillBradHisto) - { - fhDeltaPhiBradAssocPtBin[bin] = new TH2F(Form("hDeltaPhiBradPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + outputContainer->Add(fhDeltaPhiDecayChargedAssocPtBin[bin]) ; + } + + if(fFillBradHisto) + { + fhDeltaPhiBradAssocPtBin[bin] = new TH2F(Form("hDeltaPhiBradPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0); - fhDeltaPhiBradAssocPtBin[bin]->SetXTitle("p_{T trigger}"); - fhDeltaPhiBradAssocPtBin[bin]->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi"); - outputContainer->Add(fhDeltaPhiBradAssocPtBin[bin]) ; - } - - if(fHMPIDCorrelation) - { - fhDeltaPhiAssocPtBinHMPID[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPID", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, with track having HMPID signal", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + fhDeltaPhiBradAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaPhiBradAssocPtBin[bin]->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi"); + outputContainer->Add(fhDeltaPhiBradAssocPtBin[bin]) ; + } + + if(fHMPIDCorrelation) + { + fhDeltaPhiAssocPtBinHMPID[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPID", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, with track having HMPID signal", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiAssocPtBinHMPID[bin]->SetXTitle("p_{T trigger}"); - fhDeltaPhiAssocPtBinHMPID[bin]->SetYTitle("#Delta #phi"); - - fhDeltaPhiAssocPtBinHMPIDAcc[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPIDAcc", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, with track within 5SetXTitle("#it{p}_{T trigger} (GeV/#it{c})" ); + fhDeltaPhiAssocPtBinHMPID[bin]->SetYTitle("#Delta #phi (rad)"); + + fhDeltaPhiAssocPtBinHMPIDAcc[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPIDAcc", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, with track within 5SetXTitle("p_{T trigger}"); - fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetYTitle("#Delta #phi"); - - outputContainer->Add(fhDeltaPhiAssocPtBinHMPID[bin]) ; - outputContainer->Add(fhDeltaPhiAssocPtBinHMPIDAcc[bin]) ; - - } + fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetYTitle("#Delta #phi (rad)"); + + outputContainer->Add(fhDeltaPhiAssocPtBinHMPID [bin]) ; + outputContainer->Add(fhDeltaPhiAssocPtBinHMPIDAcc[bin]) ; } } - - if(fPi0Trigger || fDecayTrigger) + } + + if(fFillMomImbalancePtAssocBinsHisto) + { + for(Int_t i = 0 ; i < fNAssocPtBins ; i++) { - if(fPi0Trigger) - { - fhPtPi0DecayRatio = new TH2F - ("hPtPi0DecayRatio","p_T of #pi^{0} and the ratio of pt for two decay", - nptbins,ptmin,ptmax, 100,0.,2.); - fhPtPi0DecayRatio->SetXTitle("p_{T}^{#pi^{0}} (GeV/c)"); - fhPtPi0DecayRatio->SetYTitle("p_{T}^{Decay}/p_{T}^{#pi^{0}}"); - outputContainer->Add(fhPtPi0DecayRatio) ; - } + fhXEAssocPtBin[i] = new TH2F(Form("hXEAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]), + Form("#it{x}_{#it{E}} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]), + nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax); + fhXEAssocPtBin[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhXEAssocPtBin[i]->SetYTitle("#it{x}_{#it{E}}"); - fhDeltaPhiDecayCharged = new TH2F - ("hDeltaPhiDecayCharged","#phi_{Decay} - #phi_{h^{#pm}} vs p_{T Decay}", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiDecayCharged->SetYTitle("#Delta #phi"); - fhDeltaPhiDecayCharged->SetXTitle("p_{T Decay} (GeV/c)"); - - fhXEDecayCharged = - new TH2F("hXEDecayCharged","x_{E} Decay", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEDecayCharged->SetYTitle("x_{E}"); - fhXEDecayCharged->SetXTitle("p_{T decay}"); - - fhZTDecayCharged = - new TH2F("hZTDecayCharged","z_{trigger h^{#pm}} = p_{T h^{#pm}} / p_{T Decay}", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTDecayCharged->SetYTitle("z_{decay h^{#pm}}"); - fhZTDecayCharged->SetXTitle("p_{T decay}"); - - outputContainer->Add(fhDeltaPhiDecayCharged) ; - outputContainer->Add(fhXEDecayCharged) ; - outputContainer->Add(fhZTDecayCharged) ; - } - - if(fMakeSeveralUE) - { - fhDeltaPhiUeLeftCharged = new TH2F - ("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left side range of trigger particles", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi"); - fhDeltaPhiUeLeftCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - outputContainer->Add(fhDeltaPhiUeLeftCharged) ; + fhZTAssocPtBin[i] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]), + Form("#it{z}_{T} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]), + nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax); + fhZTAssocPtBin[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhZTAssocPtBin[i]->SetYTitle("#it{z}_{T}"); - fhDeltaPhiUeRightCharged = new TH2F - ("hDeltaPhiUeRightChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right side range of trigger particles", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeRightCharged->SetYTitle("#Delta #phi"); - fhDeltaPhiUeRightCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - outputContainer->Add(fhDeltaPhiUeRightCharged) ; - fhDeltaPhiUeLeftUpCharged = new TH2F - ("hDeltaPhiUeLeftUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left Up side range of trigger particles", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi"); - fhDeltaPhiUeLeftUpCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - outputContainer->Add(fhDeltaPhiUeLeftUpCharged) ; + outputContainer->Add(fhXEAssocPtBin[i]); + outputContainer->Add(fhZTAssocPtBin[i]); + } + } + + if(fCorrelVzBin) + { + for(Int_t z = 0 ; z < nz ; z++) + { + sz = Form("_vz%d",z); + tz = Form(", #it{v}_{#it{z}} bin %d",z); - fhDeltaPhiUeRightUpCharged = new TH2F - ("hDeltaPhiUeRightUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right Up side range of trigger particles", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi"); - fhDeltaPhiUeRightUpCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - outputContainer->Add(fhDeltaPhiUeRightUpCharged) ; + fhXEVZ[z] = new TH2F(Form("hXE%s", sz.Data()), + Form("#it{x}_{#it{E}} vs #it{p}_{T trigger}%s", tz.Data()), + nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax); + fhXEVZ[z]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhXEVZ[z]->SetYTitle("#it{x}_{#it{E}}"); - fhDeltaPhiUeLeftDownCharged = new TH2F - ("hDeltaPhiUeLeftDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left Down side range of trigger particles", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi"); - fhDeltaPhiUeLeftDownCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - outputContainer->Add(fhDeltaPhiUeLeftDownCharged) ; + fhZTVZ[z] = new TH2F(Form("hZT%s",sz.Data()), + Form("#it{z}_{T} vs #it{p}_{T trigger}%s", tz.Data()), + nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax); + fhZTVZ[z]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhZTVZ[z]->SetYTitle("#it{z}_{T}"); - fhDeltaPhiUeRightDownCharged = new TH2F - ("hDeltaPhiUeRightDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right Down side range of trigger particles", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi"); - fhDeltaPhiUeRightDownCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - outputContainer->Add(fhDeltaPhiUeRightDownCharged) ; - - fhXEUeLeftCharged = - new TH2F("hXEUeChargedLeft","x_{E} with UE left side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeLeftCharged->SetYTitle("x_{E Ueh^{#pm}}"); - fhXEUeLeftCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhXEUeLeftCharged) ; - - fhXEUeRightCharged = - new TH2F("hXEUeChargedRight","x_{E h^{#pm}} with UE right side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}"); - fhXEUeRightCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhXEUeRightCharged) ; - - fhXEUeLeftUpCharged = - new TH2F("hXEUeChargedLeftUp","x_{E} with UE left Up side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeLeftUpCharged->SetYTitle("x_{E Ueh^{#pm}}"); - fhXEUeLeftUpCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhXEUeLeftUpCharged) ; - - fhXEUeRightUpCharged = - new TH2F("hXEUeChargedRightUp","x_{E h^{#pm}} with UE right Up side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeRightUpCharged->SetYTitle("z_{trigger Ueh^{#pm}}"); - fhXEUeRightUpCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhXEUeRightUpCharged) ; - - fhXEUeLeftDownCharged = - new TH2F("hXEUeChargedLeftDown","x_{E} with UE left Down side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeLeftDownCharged->SetYTitle("x_{E Ueh^{#pm}}"); - fhXEUeLeftDownCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhXEUeLeftDownCharged) ; - - fhXEUeRightDownCharged = - new TH2F("hXEUeChargedRightDown","x_{E h^{#pm}} with UE right Down side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeRightDownCharged->SetYTitle("z_{trigger Ueh^{#pm}}"); - fhXEUeRightDownCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhXEUeRightDownCharged) ; - - fhPtHbpXEUeLeftCharged = - new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/x_{E}) with charged UE left side of trigger", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/x_{E})"); - fhPtHbpXEUeLeftCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhPtHbpXEUeLeftCharged) ; - - fhPtHbpXEUeRightCharged = - new TH2F("hHbpXEUeChargedRight","#xi = ln(1/x_{E}) with charged UE right side of trigger", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXEUeRightCharged->SetYTitle("ln(1/x_{E})"); - fhPtHbpXEUeRightCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhPtHbpXEUeRightCharged) ; - - fhZTUeLeftCharged = - new TH2F("hZTUeChargedLeft","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE left side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTUeLeftCharged->SetYTitle("z_{trigger Ueh^{#pm}}"); - fhZTUeLeftCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhZTUeLeftCharged) ; - - fhZTUeRightCharged = - new TH2F("hZTUeChargedRight","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE right side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}"); - fhZTUeRightCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhZTUeRightCharged) ; - - fhPtHbpZTUeLeftCharged = - new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/z_{T}) with charged UE left side of trigger", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/z_{T})"); - fhPtHbpZTUeLeftCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhPtHbpZTUeLeftCharged) ; - - fhPtHbpZTUeRightCharged = - new TH2F("hHbpZTUeChargedRight","#xi = ln(1/z_{T}) with charged UE right side of trigger", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpZTUeRightCharged->SetYTitle("ln(1/z_{T})"); - fhPtHbpZTUeRightCharged->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhPtHbpZTUeRightCharged) ; - - } - } //Correlation with charged hadrons + outputContainer->Add(fhXEVZ[z]); + outputContainer->Add(fhZTVZ[z]); + } + } + + if(fPi0Trigger) + { + fhPtPi0DecayRatio = new TH2F + ("hPtPi0DecayRatio","#it{p}_{T} of #pi^{0} and the ratio of pt for two decay", + nptbins,ptmin,ptmax, 100,0.,2.); + fhPtPi0DecayRatio->SetXTitle("#it{p}_{T}^{#pi^{0}} (GeV/#it{c})"); + fhPtPi0DecayRatio->SetYTitle("#it{p}_{T}^{Decay}/#it{p}_{T}^{#pi^{0}}"); + outputContainer->Add(fhPtPi0DecayRatio) ; + + fhDeltaPhiPi0DecayCharged = new TH2F + ("hDeltaPhiPi0DecayCharged","#phi_{Decay} - #phi_{h^{#pm}} vs #it{p}_{T Decay}", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiPi0DecayCharged->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiPi0DecayCharged->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})"); + + fhXEPi0DecayCharged = + new TH2F("hXEPi0DecayCharged","#it{x}_{#it{E}} Decay", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEPi0DecayCharged->SetYTitle("#it{x}_{#it{E}}"); + fhXEPi0DecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})"); + + fhZTPi0DecayCharged = + new TH2F("hZTPi0DecayCharged","#it{z}_{trigger h^{#pm}} = #it{p}_{T h^{#pm}} / #it{p}_{T Decay}", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTPi0DecayCharged->SetYTitle("#it{z}_{decay h^{#pm}}"); + fhZTPi0DecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})"); + + outputContainer->Add(fhDeltaPhiPi0DecayCharged) ; + outputContainer->Add(fhXEPi0DecayCharged) ; + outputContainer->Add(fhZTPi0DecayCharged) ; + } + + if(fDecayTrigger) + { + for(Int_t ibit = 0; ibit< fNDecayBits; ibit++) + { + fhDeltaPhiDecayCharged[ibit] = new TH2F + (Form("hDeltaPhiDecayCharged_bit%d",fDecayBits[ibit]), + Form("#phi_{Decay} - #phi_{h^{#pm}} vs #it{p}_{T Decay}, Bit %d",fDecayBits[ibit]), + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiDecayCharged[ibit]->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiDecayCharged[ibit]->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})"); + + fhXEDecayCharged[ibit] = + new TH2F(Form("hXEDecayCharged_bit%d",fDecayBits[ibit]), + Form("#it{x}_{#it{E}} Decay, Bit %d",fDecayBits[ibit]), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEDecayCharged[ibit]->SetYTitle("#it{x}_{#it{E}}"); + fhXEDecayCharged[ibit]->SetXTitle("#it{p}_{T decay} (GeV/#it{c})"); + + fhZTDecayCharged[ibit] = + new TH2F(Form("hZTDecayCharged_bit%d",fDecayBits[ibit]), + Form("#it{z}_{trigger h^{#pm}} = #it{p}_{T h^{#pm}} / #it{p}_{T Decay}, Bit %d",fDecayBits[ibit]), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTDecayCharged[ibit]->SetYTitle("#it{z}_{decay h^{#pm}}"); + fhZTDecayCharged[ibit]->SetXTitle("#it{p}_{T decay} (GeV/#it{c})"); + + outputContainer->Add(fhDeltaPhiDecayCharged[ibit]) ; + outputContainer->Add(fhXEDecayCharged[ibit]) ; + outputContainer->Add(fhZTDecayCharged[ibit]) ; + } + } + //Correlation with neutral hadrons if(fNeutralCorr) { fhDeltaPhiDeltaEtaNeutral = new TH2F ("hDeltaPhiDeltaEtaNeutral","#phi_{trigger} - #phi_{h^{0}} vs #eta_{trigger} - #eta_{h^{0}}", - ndeltaphibins ,deltaphimin,deltaphimax, ndeltaetabins ,deltaetamin,deltaetamax); - fhDeltaPhiDeltaEtaNeutral->SetXTitle("#Delta #phi"); - fhDeltaPhiDeltaEtaNeutral->SetYTitle("#Delta #eta"); + ndeltaphibins ,deltaphimin,deltaphimax, ndeltaetabins ,deltaetamin,deltaetamax); + fhDeltaPhiDeltaEtaNeutral->SetXTitle("#Delta #phi (rad)"); + fhDeltaPhiDeltaEtaNeutral->SetYTitle("#Delta #eta"); fhPhiNeutral = new TH2F - ("hPhiNeutral","#phi_{#pi^{0}} vs p_{T #pi^{0}}", - nptbins,ptmin,ptmax,nphibins,phimin,phimax); + ("hPhiNeutral","#phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}", + nptbins,ptmin,ptmax,180,0,TMath::TwoPi()); fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)"); - fhPhiNeutral->SetXTitle("p_{T #pi^{0}} (GeV/c)"); + fhPhiNeutral->SetXTitle("#it{p}_{T #pi^{0}} (GeV/#it{c})"); fhEtaNeutral = new TH2F - ("hEtaNeutral","#eta_{#pi^{0}} vs p_{T #pi^{0}}", - nptbins,ptmin,ptmax,netabins,etamin,etamax); + ("hEtaNeutral","#eta_{#pi^{0}} vs #it{p}_{T #pi^{0}}", + nptbins,ptmin,ptmax,200,-1.,1.); fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)"); - fhEtaNeutral->SetXTitle("p_{T #pi^{0}} (GeV/c)"); + fhEtaNeutral->SetXTitle("#it{p}_{T #pi^{0}} (GeV/#it{c})"); fhDeltaPhiNeutral = new TH2F - ("hDeltaPhiNeutral","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T trigger}", - nptbins,ptmin,ptmax,nphibins,phimin,phimax); - fhDeltaPhiNeutral->SetYTitle("#Delta #phi"); - fhDeltaPhiNeutral->SetXTitle("p_{T trigger} (GeV/c)"); + ("hDeltaPhiNeutral","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T trigger}", + nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiNeutral->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); fhDeltaPhiNeutralPt = new TH2F - ("hDeltaPhiNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi"); - fhDeltaPhiNeutralPt->SetXTitle("p_{T h^{0}} (GeV/c)"); - - fhDeltaPhiUeNeutralPt = new TH2F - ("hDeltaPhiUeNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi"); - fhDeltaPhiUeNeutralPt->SetXTitle("p_{T h^{0}} (GeV/c)"); + ("hDeltaPhiNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}}", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})"); fhDeltaEtaNeutral = new TH2F - ("hDeltaEtaNeutral","#eta_{trigger} - #eta_{#pi^{0}} vs p_{T trigger}", - nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax); + ("hDeltaEtaNeutral","#eta_{trigger} - #eta_{#pi^{0}} vs #it{p}_{T trigger}", + nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax); fhDeltaEtaNeutral->SetYTitle("#Delta #eta"); - fhDeltaEtaNeutral->SetXTitle("p_{T trigger} (GeV/c)"); - - fhXENeutral = - new TH2F("hXENeutral","x_{E} for #pi^{0} associated", - nptbins,ptmin,ptmax,200,0.,2.); - fhXENeutral->SetYTitle("x_{E}"); - fhXENeutral->SetXTitle("p_{T trigger}"); - - fhXEUeNeutral = - new TH2F("hXEUeNeutral","x_{E} for #pi^{0} associated", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeNeutral->SetYTitle("x_{E}"); - fhXEUeNeutral->SetXTitle("p_{T trigger}"); - - fhPtHbpXENeutral = - new TH2F("hHbpXENeutral","#xi = ln(1/x_{E})for #pi^{0} associated", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXENeutral->SetYTitle("ln(1/x_{E})"); - fhPtHbpXENeutral->SetXTitle("p_{T trigger}"); - - fhPtHbpXEUeNeutral = - new TH2F("hHbpXEUeNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXEUeNeutral->SetYTitle("ln(1/x_{E})"); - fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger}"); - - fhZTNeutral = - new TH2F("hZTNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger} for #pi^{0} associated", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTNeutral->SetYTitle("z_{trigger #pi^{0}}"); - fhZTNeutral->SetXTitle("p_{T trigger}"); - - fhZTUeNeutral = - new TH2F("hZTUeNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger} for #pi^{0} associated", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTUeNeutral->SetYTitle("z_{trigger #pi^{0}}"); - fhZTUeNeutral->SetXTitle("p_{T trigger}"); - - fhPtHbpZTNeutral = - new TH2F("hHbpZTNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpZTNeutral->SetYTitle("ln(1/z_{T})"); - fhPtHbpZTNeutral->SetXTitle("p_{T trigger}"); - - fhPtHbpZTUeNeutral = - new TH2F("hHbpZTUeNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXEUeNeutral->SetYTitle("ln(1/z_{T})"); - fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger}"); - - outputContainer->Add(fhDeltaPhiDeltaEtaNeutral); - outputContainer->Add(fhPhiNeutral) ; - outputContainer->Add(fhEtaNeutral) ; - outputContainer->Add(fhDeltaPhiNeutral) ; - outputContainer->Add(fhDeltaPhiNeutralPt) ; - outputContainer->Add(fhDeltaPhiUeNeutralPt) ; - outputContainer->Add(fhDeltaEtaNeutral) ; + fhDeltaEtaNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhXENeutral = + new TH2F("hXENeutral","#it{x}_{#it{E}} for #pi^{0} associated", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXENeutral->SetYTitle("#it{x}_{#it{E}}"); + fhXENeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpXENeutral = + new TH2F("hHbpXENeutral","#xi = ln(1/#it{x}_{#it{E}})for #pi^{0} associated", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpXENeutral->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhPtHbpXENeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTNeutral = + new TH2F("hZTNeutral","#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}"); + fhZTNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpZTNeutral = + new TH2F("hHbpZTNeutral","#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpZTNeutral->SetYTitle("ln(1/#it{z}_{T})"); + fhPtHbpZTNeutral->SetXTitle("#it{p}_{T trigger}"); + + outputContainer->Add(fhDeltaPhiDeltaEtaNeutral); + outputContainer->Add(fhPhiNeutral) ; + outputContainer->Add(fhEtaNeutral) ; + outputContainer->Add(fhDeltaPhiNeutral) ; + outputContainer->Add(fhDeltaPhiNeutralPt) ; + outputContainer->Add(fhDeltaEtaNeutral) ; outputContainer->Add(fhXENeutral) ; - outputContainer->Add(fhXEUeNeutral) ; outputContainer->Add(fhPtHbpXENeutral) ; - outputContainer->Add(fhPtHbpXEUeNeutral) ; outputContainer->Add(fhZTNeutral) ; - outputContainer->Add(fhZTUeNeutral) ; outputContainer->Add(fhPtHbpZTNeutral) ; - outputContainer->Add(fhPtHbpZTUeNeutral) ; - if(fPi0Trigger || fDecayTrigger) - { - fhDeltaPhiDecayNeutral = new TH2F - ("hDeltaPhiDecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs p_{T Decay}", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiDecayNeutral->SetYTitle("#Delta #phi"); - fhDeltaPhiDecayNeutral->SetXTitle("p_{T Decay} (GeV/c)"); - - fhXEDecayNeutral = - new TH2F("hXEDecayNeutral","x_{E} for decay trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEDecayNeutral->SetYTitle("x_{E}"); - fhXEDecayNeutral->SetXTitle("p_{T decay}"); - - fhZTDecayNeutral = - new TH2F("hZTDecayNeutral","z_{trigger h^{0}} = p_{T h^{0}} / p_{T Decay}", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTDecayNeutral->SetYTitle("z_{h^{0}}"); - fhZTDecayNeutral->SetXTitle("p_{T decay}"); - - outputContainer->Add(fhDeltaPhiDecayNeutral) ; - outputContainer->Add(fhXEDecayNeutral) ; - outputContainer->Add(fhZTDecayNeutral) ; + fhDeltaPhiUeNeutralPt = new TH2F + (Form("hDeltaPhiUe%sNeutralPt",right.Data()),"#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}}", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiUeNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})"); + + fhXEUeNeutral = + new TH2F(Form("hXEUeNeutral%s",right.Data()),"#it{x}_{#it{E}} for #pi^{0} associated", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeNeutral->SetYTitle("#it{x}_{#it{E}}"); + fhXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpXEUeNeutral = + new TH2F(Form("hHbpXEUeNeutral%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhZTUeNeutral = + new TH2F(Form("hZTUeNeutral%s",right.Data()),"#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}"); + fhZTUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhPtHbpZTUeNeutral = + new TH2F(Form("hHbpZTUeNeutral%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{z}_{T})"); + fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhDeltaPhiUeNeutralPt) ; + outputContainer->Add(fhXEUeNeutral) ; + outputContainer->Add(fhPtHbpXEUeNeutral) ; + outputContainer->Add(fhZTUeNeutral) ; + outputContainer->Add(fhPtHbpZTUeNeutral) ; - } - if(fMakeSeveralUE) - { + { fhDeltaPhiUeLeftNeutral = new TH2F - ("hDeltaPhiUeLeftNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs p_{T h^{0}} with neutral UE left side range of trigger particles", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeLeftNeutral->SetYTitle("#Delta #phi"); - fhDeltaPhiUeLeftNeutral->SetXTitle("p_{T h^{0}} (GeV/c)"); + ("hDeltaPhiUeLeftNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs #it{p}_{T h^{0}} with neutral UE left side range of trigger particles", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiUeLeftNeutral->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiUeLeftNeutral->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})"); outputContainer->Add(fhDeltaPhiUeLeftNeutral) ; - fhDeltaPhiUeRightNeutral = new TH2F - ("hDeltaPhiUeRightNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs p_{T Ueh^{0}} with neutral UE right side range of trigger particles", - nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhDeltaPhiUeRightNeutral->SetYTitle("#Delta #phi"); - fhDeltaPhiUeRightNeutral->SetXTitle("p_{T h^{0}} (GeV/c)"); - outputContainer->Add(fhDeltaPhiUeRightNeutral) ; - - fhXEUeLeftNeutral = - new TH2F("hXEUeNeutralLeft","x_{E} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE left side of trigger", - nptbins,ptmin,ptmax,140,0.,2.); - fhXEUeLeftNeutral->SetYTitle("z_{trigger Ueh^{0}}"); - fhXEUeLeftNeutral->SetXTitle("p_{T trigger}"); + fhXEUeLeftNeutral = + new TH2F("hXEUeNeutralLeft","#it{x}_{#it{E}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE left side of trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEUeLeftNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}"); + fhXEUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); outputContainer->Add(fhXEUeLeftNeutral) ; - fhXEUeRightNeutral = - new TH2F("hXEUeNeutralRight","x_{E} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE right side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhXEUeRightNeutral->SetYTitle("z_{trigger Ueh^{0}}"); - fhXEUeRightNeutral->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhXEUeRightNeutral) ; - - fhPtHbpXEUeLeftNeutral = - new TH2F("hHbpXEUeNeutralLeft","#xi = ln(1/x_{E}) with neutral UE left side of trigger", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXEUeLeftNeutral->SetYTitle("ln(1/x_{E})"); - fhPtHbpXEUeLeftNeutral->SetXTitle("p_{T trigger}"); + fhPtHbpXEUeLeftNeutral = + new TH2F("hHbpXEUeNeutralLeft","#xi = ln(1/#it{x}_{#it{E}}) with neutral UE left side of trigger", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpXEUeLeftNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhPtHbpXEUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); outputContainer->Add(fhPtHbpXEUeLeftNeutral) ; - fhPtHbpXEUeRightNeutral = - new TH2F("hHbpXEUeNeutralRight","#xi = ln(1/x_{E}) with neutral UE right side of trigger", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpXEUeRightNeutral->SetYTitle("ln(1/x_{E})"); - fhPtHbpXEUeRightNeutral->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhPtHbpXEUeRightNeutral) ; - - fhZTUeLeftNeutral = - new TH2F("hZTUeNeutralLeft","z_{trigger h^{0}} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE left side of trigger", - nptbins,ptmin,ptmax,140,0.,2.); - fhZTUeLeftNeutral->SetYTitle("z_{trigger Ueh^{0}}"); - fhZTUeLeftNeutral->SetXTitle("p_{T trigger}"); + fhZTUeLeftNeutral = + new TH2F("hZTUeNeutralLeft","#it{z}_{trigger h^{0}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE left side of trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTUeLeftNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}"); + fhZTUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); outputContainer->Add(fhZTUeLeftNeutral) ; - fhZTUeRightNeutral = - new TH2F("hZTUeNeutralRight","z_{trigger h^{0}} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE right side of trigger", - nptbins,ptmin,ptmax,200,0.,2.); - fhZTUeRightNeutral->SetYTitle("z_{trigger Ueh^{0}}"); - fhZTUeRightNeutral->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhZTUeRightNeutral) ; - - fhPtHbpZTUeLeftNeutral = - new TH2F("hHbpZTUeNeutralLeft","#xi = ln(1/z_{T}) with neutral UE left side of trigger", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpZTUeLeftNeutral->SetYTitle("ln(1/z_{T})"); - fhPtHbpZTUeLeftNeutral->SetXTitle("p_{T trigger}"); + fhPtHbpZTUeLeftNeutral = + new TH2F("hHbpZTUeNeutralLeft","#xi = ln(1/#it{z}_{T}) with neutral UE left side of trigger", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhPtHbpZTUeLeftNeutral->SetYTitle("ln(1/#it{z}_{T})"); + fhPtHbpZTUeLeftNeutral->SetXTitle("#it{p}_{T trigger}"); outputContainer->Add(fhPtHbpZTUeLeftNeutral) ; + } + + if(fPi0Trigger) + { + fhDeltaPhiPi0DecayNeutral = new TH2F + ("hDeltaPhiPi0DecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs #it{p}_{T Decay}", + nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhDeltaPhiPi0DecayNeutral->SetYTitle("#Delta #phi (rad)"); + fhDeltaPhiPi0DecayNeutral->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})"); - fhPtHbpZTUeRightNeutral = - new TH2F("hHbpZTUeNeutralRight","#xi = ln(1/z_{T}) with neutral UE right side of trigger", - nptbins,ptmin,ptmax,200,0.,10.); - fhPtHbpZTUeRightNeutral->SetYTitle("ln(1/z_{T})"); - fhPtHbpZTUeRightNeutral->SetXTitle("p_{T trigger}"); - outputContainer->Add(fhPtHbpZTUeRightNeutral) ; + fhXEPi0DecayNeutral = + new TH2F("hXEPi0DecayNeutral","#it{x}_{#it{E}} for decay trigger", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhXEPi0DecayNeutral->SetYTitle("#it{x}_{#it{E}}"); + fhXEPi0DecayNeutral->SetXTitle("#it{p}_{T decay}"); - } - + fhZTPi0DecayNeutral = + new TH2F("hZTPi0DecayNeutral","#it{z}_{trigger h^{0}} = #it{p}_{T h^{0}} / #it{p}_{T Decay}", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhZTPi0DecayNeutral->SetYTitle("#it{z}_{h^{0}}"); + fhZTPi0DecayNeutral->SetXTitle("#it{p}_{T decay}"); + + outputContainer->Add(fhDeltaPhiPi0DecayNeutral) ; + outputContainer->Add(fhXEPi0DecayNeutral) ; + outputContainer->Add(fhZTPi0DecayNeutral) ; + } }//Correlation with neutral hadrons - //if data is MC, fill more histograms + // If data is MC, fill more histograms, depending on origin if(IsDataMC()) { - fh2phiLeadingParticle=new TH2F("h2phiLeadingParticle","#phi resolustion for trigger particles",nptbins,ptmin,ptmax,100,-1,1); - fh2phiLeadingParticle->GetXaxis()->SetTitle("p_{T gen Leading} (GeV/c)"); - fh2phiLeadingParticle->GetYaxis()->SetTitle("(#phi_{rec}-#phi_{gen})/#phi_{gen}"); - - fhMCPtLeading = new TH1F ("hMCPtLeading","MC : p_T distribution of leading particles", nptbins,ptmin,ptmax); - fhMCPtLeading->SetXTitle("p_{T}^{trig} (GeV/c)"); - - fhMCPhiLeading = new TH2F ("hMCPhiLeading","MC : #phi distribution of leading Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax); - fhMCPhiLeading->SetYTitle("#phi (rad)"); - - fhMCEtaLeading = new TH2F ("hMCEtaLeading","MC : #eta distribution of leading",nptbins,ptmin,ptmax, netabins,etamin,etamax); - fhMCEtaLeading->SetYTitle("#eta "); - - - fhMCEtaCharged = new TH2F - ("hMCEtaCharged","MC #eta_{h^{#pm}} vs p_{T #pm}", - nptbins,ptmin,ptmax,netabins,etamin,etamax); - fhMCEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)"); - fhMCEtaCharged->SetXTitle("p_{T #pm} (GeV/c)"); - - fhMCPhiCharged = new TH2F - ("hMCPhiCharged","#MC phi_{h^{#pm}} vs p_{T #pm}", - 200,ptmin,ptmax,nphibins,phimin,phimax); - fhMCPhiCharged->SetYTitle("MC #phi_{h^{#pm}} (rad)"); - fhMCPhiCharged->SetXTitle("p_{T #pm} (GeV/c)"); - - fhMCDeltaPhiDeltaEtaCharged = new TH2F - ("hMCDeltaPhiDeltaEtaCharged","#MC phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}", - 140,-2.,5.,200,-2,2); - fhMCDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi"); - fhMCDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta"); - - fhMCDeltaEtaCharged = new TH2F - ("hMCDeltaEtaCharged","MC #eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger} and p_{T assoc}", - nptbins,ptmin,ptmax,200,-2,2); - fhMCDeltaEtaCharged->SetYTitle("#Delta #eta"); - fhMCDeltaEtaCharged->SetXTitle("p_{T trigger} (GeV/c)"); - - fhMCDeltaPhiCharged = new TH2F - ("hMCDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}", - nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); - fhMCDeltaPhiCharged->SetYTitle("#Delta #phi"); - fhMCDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)"); - - fhMCDeltaPhiChargedPt = new TH2F - ("hMCDeltaPhiChargedPt","MC #phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}", - nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); - fhMCDeltaPhiChargedPt->SetYTitle("#Delta #phi"); - fhMCDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)"); - - fhMCPtXECharged = - new TH2F("hMCPtXECharged","x_{E}", - nptbins,ptmin,ptmax,200,0.,2.); - fhMCPtXECharged->SetYTitle("x_{E}"); - fhMCPtXECharged->SetXTitle("p_{T trigger}"); - - fhMCPtXEUeCharged = - new TH2F("hMCPtXEUeCharged","x_{E}", - nptbins,ptmin,ptmax,200,0.,2.); - fhMCPtXEUeCharged->SetYTitle("x_{E}"); - fhMCPtXEUeCharged->SetXTitle("p_{T trigger}"); - - fhMCPtHbpXECharged = - new TH2F("hMCHbpXECharged","MC #xi = ln(1/x_{E}) with charged hadrons", - nptbins,ptmin,ptmax,200,0.,10.); - fhMCPtHbpXECharged->SetYTitle("ln(1/x_{E})"); - fhMCPtHbpXECharged->SetXTitle("p_{T trigger}"); - - fhMCPtHbpXEUeCharged = - new TH2F("hMCPtHbpXEUeCharged","#xi = ln(1/x_{E}) with charged hadrons,Underlying Event", - nptbins,ptmin,ptmax,200,0.,10.); - fhMCPtHbpXEUeCharged->SetYTitle("ln(1/x_{E})"); - fhMCPtHbpXEUeCharged->SetXTitle("p_{T trigger}"); - - fhMCUePart = - new TH1F("hMCUePart","MC UE particles distribution vs pt trig", - nptbins,ptmin,ptmax); - fhMCUePart->SetYTitle("dNch"); - fhMCUePart->SetXTitle("p_{T trigger}"); - - fhMCPtZTCharged = - new TH2F("hMCPtZTCharged","z_{T}", - nptbins,ptmin,ptmax,200,0.,2.); - fhMCPtZTCharged->SetYTitle("z_{T}"); - fhMCPtZTCharged->SetXTitle("p_{T trigger}"); - - fhMCPtHbpZTCharged = - new TH2F("hMCHbpZTCharged","MC #xi = ln(1/z_{T}) with charged hadrons", - nptbins,ptmin,ptmax,200,0.,10.); - fhMCPtHbpZTCharged->SetYTitle("ln(1/z_{T})"); - fhMCPtHbpZTCharged->SetXTitle("p_{T trigger}"); - - fhMCPtTrigPout = - new TH2F("hMCPtTrigPout","AOD MC Pout with triggers", - nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax); - fhMCPtTrigPout->SetYTitle("p_{out} (GeV/c)"); - fhMCPtTrigPout->SetXTitle("p_{T trigger} (GeV/c)"); - - fhMCPtAssocDeltaPhi = - new TH2F("hMCPtAssocDeltaPhi","AOD MC delta phi with associated charged hadrons", - nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); - fhMCPtAssocDeltaPhi->SetYTitle("#Delta #phi"); - fhMCPtAssocDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)"); + for(Int_t i= fMCGenTypeMin; i <= fMCGenTypeMax; i++) + { + fhMCPtTrigger[i] = new TH1F (Form("hMCPtTrigger_%s",nameMC[i].Data()), + Form("MC %s: generated trigger #it{p}_{T}",nameMC[i].Data()), + nptbins,ptmin,ptmax); + fhMCPtTrigger[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + + fhMCPhiTrigger[i] = new TH2F (Form("hMCPhiTrigger_%s",nameMC[i].Data()), + Form("MC %s: generated trigger #phi",nameMC[i].Data()), + nptbins,ptmin,ptmax, nphibins,phimin,phimax); + fhMCPhiTrigger[i]->SetYTitle("#phi (rad)"); + fhMCPhiTrigger[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + + fhMCEtaTrigger[i] = new TH2F (Form("hMCEtaTrigger_%s",nameMC[i].Data()), + Form("MC %s: generated trigger #eta",nameMC[i].Data()), + nptbins,ptmin,ptmax, netabins,etamin,etamax); + fhMCEtaTrigger[i]->SetYTitle("#eta"); + fhMCEtaTrigger[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + + if(fMakeAbsoluteLeading || fMakeNearSideLeading) + { + fhMCPtTriggerNotLeading[i] = new TH1F (Form("hMCPtTriggerNotLeading_%s",nameMC[i].Data()), + Form("MC %s: generated trigger #it{p}_{T}, when not leading of primaries",nameMC[i].Data()), + nptbins,ptmin,ptmax); + fhMCPtTriggerNotLeading[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); - outputContainer->Add(fh2phiLeadingParticle); - outputContainer->Add(fhMCPtLeading); - outputContainer->Add(fhMCPhiLeading); - outputContainer->Add(fhMCEtaLeading); - outputContainer->Add(fhMCDeltaPhiDeltaEtaCharged); - outputContainer->Add(fhMCPhiCharged) ; - outputContainer->Add(fhMCEtaCharged) ; - outputContainer->Add(fhMCDeltaEtaCharged) ; - outputContainer->Add(fhMCDeltaPhiCharged) ; - - outputContainer->Add(fhMCDeltaPhiChargedPt) ; - outputContainer->Add(fhMCPtXECharged) ; - outputContainer->Add(fhMCPtXEUeCharged) ; - outputContainer->Add(fhMCPtZTCharged) ; - outputContainer->Add(fhMCPtHbpXECharged) ; - outputContainer->Add(fhMCPtHbpXEUeCharged); - outputContainer->Add(fhMCUePart); - outputContainer->Add(fhMCPtHbpZTCharged) ; - outputContainer->Add(fhMCPtTrigPout) ; - outputContainer->Add(fhMCPtAssocDeltaPhi) ; + fhMCPhiTriggerNotLeading[i] = new TH2F (Form("hMCPhiTriggerNotLeading_%s",nameMC[i].Data()), + Form("MC %s: generated trigger #phi, when not leading of primaries",nameMC[i].Data()), + nptbins,ptmin,ptmax, nphibins,phimin,phimax); + fhMCPhiTriggerNotLeading[i]->SetYTitle("#phi (rad)"); + fhMCPhiTriggerNotLeading[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + + + fhMCEtaTriggerNotLeading[i] = new TH2F (Form("hMCEtaTriggerNotLeading_%s",nameMC[i].Data()), + Form("MC %s: generated triogger #eta, when not leading of primaries",nameMC[i].Data()), + nptbins,ptmin,ptmax, netabins,etamin,etamax); + fhMCEtaTriggerNotLeading[i]->SetYTitle("#eta "); + fhMCEtaTriggerNotLeading[i]->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + } + + fhMCEtaCharged[i] = new TH2F (Form("hMCEtaCharged_%s",nameMC[i].Data()), + Form("MC %s: #eta_{h^{#pm}} vs #it{p}_{T #pm}",nameMC[i].Data()), + nptbins,ptmin,ptmax,100,-1.,1.); + fhMCEtaCharged[i]->SetYTitle("#eta_{h^{#pm}} (rad)"); + fhMCEtaCharged[i]->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})"); + + fhMCPhiCharged[i] = new TH2F(Form("hMCPhiCharged_%s",nameMC[i].Data()), + Form("MC %s: phi_{h^{#pm}} vs #it{p}_{T #pm}",nameMC[i].Data()), + nptbins,ptmin,ptmax,180,0,TMath::TwoPi()); + fhMCPhiCharged[i]->SetYTitle("MC #phi_{h^{#pm}} (rad)"); + fhMCPhiCharged[i]->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})"); + + fhMCDeltaPhiDeltaEtaCharged[i] = new TH2F (Form("hMCDeltaPhiDeltaEtaCharged_%s",nameMC[i].Data()), + Form("MC %s: phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",nameMC[i].Data()), + ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax); + fhMCDeltaPhiDeltaEtaCharged[i]->SetXTitle("#Delta #phi (rad)"); + fhMCDeltaPhiDeltaEtaCharged[i]->SetYTitle("#Delta #eta"); + + fhMCDeltaEtaCharged[i] = new TH2F (Form("hMCDeltaEtaCharged_%s",nameMC[i].Data()), + Form("MC %s: #eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger} and #it{p}_{T assoc}",nameMC[i].Data()), + nptbins,ptmin,ptmax,ndeltaetabins ,deltaetamin,deltaetamax); + fhMCDeltaEtaCharged[i]->SetYTitle("#Delta #eta"); + fhMCDeltaEtaCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCDeltaPhiCharged[i] = new TH2F (Form("hMCDeltaPhiCharged_%s",nameMC[i].Data()), + Form("MC %s: #phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}",nameMC[i].Data()), + nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); + fhMCDeltaPhiCharged[i]->SetYTitle("#Delta #phi (rad)"); + fhMCDeltaPhiCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCDeltaPhiChargedPt[i] = new TH2F (Form("hMCDeltaPhiChargedPt_%s",nameMC[i].Data()), + Form("MC %s: #phi_{trigger} - #phi_{#h^{#pm}} vs #it{p}_{T h^{#pm}}",nameMC[i].Data()), + nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); + fhMCDeltaPhiChargedPt[i]->SetYTitle("#Delta #phi (rad)"); + fhMCDeltaPhiChargedPt[i]->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})"); + + fhMCPtXECharged[i] = new TH2F (Form("hMCPtXECharged_%s",nameMC[i].Data()), + Form("MC %s: #it{x}_{#it{E}} with charged hadrons",nameMC[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhMCPtXECharged[i]->SetYTitle("#it{x}_{#it{E}}"); + fhMCPtXECharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtHbpXECharged[i] = new TH2F(Form("hMCHbpXECharged_%s",nameMC[i].Data()), + Form("MC %s: #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",nameMC[i].Data()), + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhMCPtHbpXECharged[i]->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhMCPtHbpXECharged[i]->SetXTitle("#it{p}_{T trigger}"); + + fhMCPtZTCharged[i] = new TH2F(Form("hMCPtZTCharged_%s",nameMC[i].Data()), + Form("MC %s: #it{z}_{T} with charged hadrons",nameMC[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhMCPtZTCharged[i]->SetYTitle("#it{z}_{T}"); + fhMCPtZTCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtHbpZTCharged[i] = new TH2F(Form("hMCHbpZTCharged_%s",nameMC[i].Data()), + Form("MC %s: #xi = ln(1/#it{z}_{T}) with charged hadrons",nameMC[i].Data()), + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhMCPtHbpZTCharged[i]->SetYTitle("ln(1/#it{z}_{T})"); + fhMCPtHbpZTCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtTrigPout[i] = new TH2F(Form("hMCPtTrigPout_%s",nameMC[i].Data()), + Form("MC %s: #it{p}_{out} with triggers",nameMC[i].Data()), + nptbins,ptmin,ptmax,nptbins,-1.*ptmax/2.,ptmax/2.); + fhMCPtTrigPout[i]->SetYTitle("#it{p}_{out} (GeV/#it{c})"); + fhMCPtTrigPout[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtAssocDeltaPhi[i] = new TH2F(Form("hMCPtAssocDeltaPhi_%s",nameMC[i].Data()), + Form("MC %s: #Delta #phi with associated charged hadrons",nameMC[i].Data()), + nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); + fhMCPtAssocDeltaPhi[i]->SetYTitle("#Delta #phi (rad)"); + fhMCPtAssocDeltaPhi[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhMCPtTrigger[i]); + outputContainer->Add(fhMCPhiTrigger[i]); + outputContainer->Add(fhMCEtaTrigger[i]); + + if(fMakeAbsoluteLeading || fMakeNearSideLeading) + { + outputContainer->Add(fhMCPtTriggerNotLeading[i]); + outputContainer->Add(fhMCPhiTriggerNotLeading[i]); + outputContainer->Add(fhMCEtaTriggerNotLeading[i]); + } + + outputContainer->Add(fhMCDeltaPhiDeltaEtaCharged[i]); + outputContainer->Add(fhMCPhiCharged[i]) ; + outputContainer->Add(fhMCEtaCharged[i]) ; + outputContainer->Add(fhMCDeltaEtaCharged[i]) ; + outputContainer->Add(fhMCDeltaPhiCharged[i]) ; + + outputContainer->Add(fhMCDeltaPhiChargedPt[i]) ; + outputContainer->Add(fhMCPtXECharged[i]) ; + outputContainer->Add(fhMCPtZTCharged[i]) ; + outputContainer->Add(fhMCPtHbpXECharged[i]) ; + outputContainer->Add(fhMCPtHbpZTCharged[i]) ; + outputContainer->Add(fhMCPtTrigPout[i]) ; + outputContainer->Add(fhMCPtAssocDeltaPhi[i]) ; + + // Underlying event + + fhMCUePart[i] = + new TH1F(Form("hMCUePart_%s",nameMC[i].Data()), + Form("MC %s: UE particles distribution vs #it{p}_{T trigger}",nameMC[i].Data()), + nptbins,ptmin,ptmax); + fhMCUePart[i]->SetYTitle("#it{dN}^{ch}"); + fhMCUePart[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtXEUeCharged[i] = + new TH2F(Form("hMCPtXEUeCharged%s_%s",right.Data(),nameMC[i].Data()), + Form("MC %s: #it{x}_{#it{E}} with charged hadrons, Underlying Event %s",nameMC[i].Data(),right.Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhMCPtXEUeCharged[i]->SetYTitle("#it{x}_{#it{E}}"); + fhMCPtXEUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtHbpXEUeCharged[i] = + new TH2F(Form("hMCPtHbpXEUeCharged%s_%s",right.Data(),nameMC[i].Data()), + Form("MC %s: #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, Underlying Event %s",nameMC[i].Data(),right.Data()), + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhMCPtHbpXEUeCharged[i]->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhMCPtHbpXEUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtZTUeCharged[i] = + new TH2F(Form("hMCPtZTUeCharged%s_%s",right.Data(),nameMC[i].Data()), + Form("MC %s: #it{z}_{T} with charged hadrons, Underlying Event %s",nameMC[i].Data(),right.Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhMCPtZTUeCharged[i]->SetYTitle("#it{z}_{T}"); + fhMCPtZTUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtHbpZTUeCharged[i] = + new TH2F(Form("hMCPtHbpZTUeCharged%s_%s",right.Data(),nameMC[i].Data()), + Form("MC %s: #xi = ln(1/#it{z}_{T}) with charged hadrons, Underlying Event %s",nameMC[i].Data(),right.Data()), + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhMCPtHbpZTUeCharged[i]->SetYTitle("ln(1/#it{z}_{T})"); + fhMCPtHbpZTUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhMCUePart[i]); + outputContainer->Add(fhMCPtXEUeCharged[i]) ; + outputContainer->Add(fhMCPtZTUeCharged[i]) ; + outputContainer->Add(fhMCPtHbpZTUeCharged[i]); + outputContainer->Add(fhMCPtHbpXEUeCharged[i]); + + if(fMakeSeveralUE) + { + fhMCPtXEUeLeftCharged[i] = new TH2F(Form("hMCPtXEUeChargedLeft_%s",nameMC[i].Data()), + Form("MC %s: #it{x}_{#it{E}} with charged hadrons, with UE left side range of trigger particles",nameMC[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhMCPtXEUeLeftCharged[i]->SetYTitle("#it{x}_{#it{E}}"); + fhMCPtXEUeLeftCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtHbpXEUeLeftCharged[i] = new TH2F(Form("hMCPtHbpXEUeChargedLeft_%s",nameMC[i].Data()), + Form("MC %s: #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, with UE left side range of trigger particles",nameMC[i].Data()), + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhMCPtHbpXEUeLeftCharged[i]->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhMCPtHbpXEUeLeftCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtZTUeLeftCharged[i] = new TH2F(Form("hMCPtZTUeChargedLeft_%s",nameMC[i].Data()), + Form("MC %s: #it{z}_{T} with charged hadrons, with UE left side range of trigger particles",nameMC[i].Data()), + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhMCPtZTUeLeftCharged[i]->SetYTitle("#it{z}_{T}"); + fhMCPtZTUeLeftCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + fhMCPtHbpZTUeLeftCharged[i] = new TH2F(Form("hMCPtHbpZTUeChargedLeft_%s",nameMC[i].Data()), + Form("MC %s: #xi = ln(1/#it{z}_{T}) with charged hadrons, with UE left side range of trigger particles",nameMC[i].Data()), + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhMCPtHbpZTUeLeftCharged[i]->SetYTitle("ln(1/#it{z}_{T})"); + fhMCPtHbpZTUeLeftCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + + outputContainer->Add(fhMCPtXEUeLeftCharged[i]) ; + outputContainer->Add(fhMCPtZTUeLeftCharged[i]) ; + outputContainer->Add(fhMCPtHbpXEUeLeftCharged[i]); + outputContainer->Add(fhMCPtHbpZTUeLeftCharged[i]) ; + + } + } } //for MC histogram if(DoOwnMix()) { //create event containers - if(!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForTracksExists())) + if(!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForTracksExists())) { Int_t nvz = GetNZvertBin(); Int_t nrp = GetNRPBin(); @@ -1865,37 +2655,37 @@ TList * AliAnaParticleHadronCorrelation::GetCreateOutputObjects() fListMixTrackEvents[bin]->SetOwner(kFALSE); } } - } + } } - fhPtLeadingMixed = new TH1F ("hPtLeadingMixed","p_T distribution of leading particles, used for mixing", nptbins,ptmin,ptmax); - fhPtLeadingMixed->SetXTitle("p_{T}^{trig} (GeV/c)"); - + fhPtTriggerMixed = new TH1F ("hPtTriggerMixed","#it{p}_{T} distribution of trigger particles, used for mixing", nptbins,ptmin,ptmax); + fhPtTriggerMixed->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + if(fCorrelVzBin) { - fhPtLeadingMixedVzBin = new TH2F ("hPtLeadingMixedVzBin","p_T distribution of leading particles, used for mixing", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin()); - fhPtLeadingMixedVzBin->SetXTitle("p_{T}^{trig} (GeV/c)"); - fhPtLeadingMixedVzBin->SetYTitle("v_{z} bin"); - outputContainer->Add(fhPtLeadingMixedVzBin); + fhPtTriggerMixedVzBin = new TH2F ("hPtTriggerMixedVzBin","#it{p}_{T} distribution of trigger particles, used for mixing", nptbins,ptmin,ptmax,GetNZvertBin(),0,GetNZvertBin()); + fhPtTriggerMixedVzBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtTriggerMixedVzBin->SetYTitle("#it{v}_{#it{z}} bin"); + outputContainer->Add(fhPtTriggerMixedVzBin); } - fhPtLeadingMixedBin = new TH2F ("hPtLeadingMixedBin","p_T distribution of leading particles vs mixing bin", nptbins,ptmin,ptmax,nMixBins,0,nMixBins); - fhPtLeadingMixedBin->SetXTitle("p_{T}^{trig} (GeV/c)"); - fhPtLeadingMixedBin->SetYTitle("Bin"); - - fhPhiLeadingMixed = new TH2F ("hPhiLeadingMixed","#phi distribution of leading Particles, used for mixing",nptbins,ptmin,ptmax, nphibins,phimin,phimax); - fhPhiLeadingMixed->SetYTitle("#phi (rad)"); + fhPtTriggerMixedBin = new TH2F ("hPtTriggerMixedBin","#it{p}_{T} distribution of trigger particles vs mixing bin", nptbins,ptmin,ptmax,nMixBins,0,nMixBins); + fhPtTriggerMixedBin->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})"); + fhPtTriggerMixedBin->SetYTitle("Bin"); - fhEtaLeadingMixed = new TH2F ("hEtaLeadingMixed","#eta distribution of leading, used for mixing",nptbins,ptmin,ptmax, netabins,etamin,etamax); - fhEtaLeadingMixed->SetYTitle("#eta "); + fhPhiTriggerMixed = new TH2F ("hPhiTriggerMixed","#phi distribution of trigger Particles, used for mixing",nptbins,ptmin,ptmax, nphibins,phimin,phimax); + fhPhiTriggerMixed->SetYTitle("#phi (rad)"); - outputContainer->Add(fhPtLeadingMixed); - outputContainer->Add(fhPtLeadingMixedBin); - outputContainer->Add(fhPhiLeadingMixed); - outputContainer->Add(fhEtaLeadingMixed); + fhEtaTriggerMixed = new TH2F ("hEtaTriggerMixed","#eta distribution of trigger, used for mixing",nptbins,ptmin,ptmax, netabins,etamin,etamax); + fhEtaTriggerMixed->SetYTitle("#eta "); - // Fill the cluster pool only in isolation analysis - if( OnlyIsolated() && (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists()))) + outputContainer->Add(fhPtTriggerMixed); + outputContainer->Add(fhPtTriggerMixedBin); + outputContainer->Add(fhPhiTriggerMixed); + outputContainer->Add(fhEtaTriggerMixed); + + // Fill the cluster pool only in isolation analysis or if requested + if( neutralMix && (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists()))) { Int_t nvz = GetNZvertBin(); Int_t nrp = GetNRPBin(); @@ -1918,160 +2708,172 @@ TList * AliAnaParticleHadronCorrelation::GetCreateOutputObjects() fListMixCaloEvents[bin]->SetOwner(kFALSE); } } - } + } } //Init the list in the reader if not done previously if(fUseMixStoredInReader) { - if( !GetReader()->ListWithMixedEventsForTracksExists() ) + if( !GetReader()->ListWithMixedEventsForTracksExists() ) GetReader()->SetListWithMixedEventsForTracks(fListMixTrackEvents); - if( !GetReader()->ListWithMixedEventsForCaloExists() ) + if( !GetReader()->ListWithMixedEventsForCaloExists() ) GetReader()->SetListWithMixedEventsForCalo (fListMixCaloEvents ); } - fhEventBin=new TH1I("hEventBin","Number of real events per bin(cen,vz,rp)", - GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0, + fhEventBin=new TH1I("hEventBin","Number of triggers per bin(cen,vz,rp)", + GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0, GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ; - fhEventBin->SetXTitle("bin"); + fhEventBin->SetXTitle("event bin"); outputContainer->Add(fhEventBin) ; - fhEventMixBin=new TH1I("hEventMixBin","Number of events per bin(cen,vz,rp)", + fhEventMixBin=new TH1I("hEventMixBin","Number of triggers mixed per event bin(cen,vz,rp)", GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0, GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ; - fhEventMixBin->SetXTitle("bin"); + fhEventMixBin->SetXTitle("event bin"); outputContainer->Add(fhEventMixBin) ; - - fhNtracksAll=new TH1F("hNtracksAll","Number of tracks w/o event trigger",2000,0,2000); - outputContainer->Add(fhNtracksAll); - - fhNtracksTrigger=new TH1F("hNtracksTriggerEvent","Number of tracks w/ event trigger",2000,0,2000); - outputContainer->Add(fhNtracksTrigger); - - fhNtracksMB=new TH1F("hNtracksMBEvent","Number of tracks w/ event trigger kMB",2000,0,2000); + + fhEventMBBin=new TH1I("hEventMBBin","Number of min bias events per bin(cen,vz,rp)", + GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0, + GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ; + fhEventMBBin->SetXTitle("event bin"); + outputContainer->Add(fhEventMBBin) ; + + fhNtracksMB=new TH2F("hNtracksMBEvent","Number of filtered tracks in MB event per event bin",ntrbins,trmin,trmax, + GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0, + GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ; + fhNtracksMB->SetYTitle("event bin"); + fhNtracksMB->SetXTitle("#it{N}_{track}"); outputContainer->Add(fhNtracksMB); + + if( neutralMix ) + { + fhNclustersMB=new TH2F("hNclustersMBEvent","Number of filtered clusters in MB events per event bin",nclbins,clmin,clmax, + GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0, + GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ; + fhNclustersMB->SetYTitle("event bin"); + fhNclustersMB->SetXTitle("#it{N}_{cluster}"); + outputContainer->Add(fhNclustersMB); + } fhMixDeltaPhiCharged = new TH2F - ("hMixDeltaPhiCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}", - nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); - fhMixDeltaPhiCharged->SetYTitle("#Delta #phi"); - fhMixDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)"); + ("hMixDeltaPhiCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}", + nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax); + fhMixDeltaPhiCharged->SetYTitle("#Delta #phi (rad)"); + fhMixDeltaPhiCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); outputContainer->Add(fhMixDeltaPhiCharged); fhMixDeltaPhiDeltaEtaCharged = new TH2F ("hMixDeltaPhiDeltaEtaCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}", - ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax); - fhMixDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi"); + ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax); + fhMixDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)"); fhMixDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta"); outputContainer->Add(fhMixDeltaPhiDeltaEtaCharged); - fhMixXECharged = - new TH2F("hMixXECharged","Mixed event : x_{E} for charged tracks", - nptbins,ptmin,ptmax,200,0.,2.); - fhMixXECharged->SetYTitle("x_{E}"); - fhMixXECharged->SetXTitle("p_{T trigger}"); + fhMixXECharged = + new TH2F("hMixXECharged","Mixed event : #it{x}_{#it{E}} for charged tracks", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhMixXECharged->SetYTitle("#it{x}_{#it{E}}"); + fhMixXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); outputContainer->Add(fhMixXECharged); - - fhMixHbpXECharged = - new TH2F("hMixHbpXECharged","mixed event : #xi = ln(1/x_{E}) with charged hadrons", - nptbins,ptmin,ptmax,200,0.,10.); - fhMixHbpXECharged->SetYTitle("ln(1/x_{E})"); - fhMixHbpXECharged->SetXTitle("p_{T trigger}"); + + fhMixXEUeCharged = + new TH2F("hMixXEUeCharged","Mixed event : #it{x}_{#it{E}} for charged tracks in Ue region", + nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax); + fhMixXEUeCharged->SetYTitle("#it{x}_{#it{E}}"); + fhMixXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + outputContainer->Add(fhMixXEUeCharged); + + fhMixHbpXECharged = + new TH2F("hMixHbpXECharged","mixed event : #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons", + nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax); + fhMixHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})"); + fhMixHbpXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); outputContainer->Add(fhMixHbpXECharged); - + fhMixDeltaPhiChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz]; fhMixDeltaPhiChargedAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz]; fhMixDeltaPhiChargedAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz]; fhMixDeltaPhiDeltaEtaChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz]; for(Int_t i = 0 ; i < fNAssocPtBins ; i++) - { + { for(Int_t z = 0 ; z < nz ; z++) { Int_t bin = i*nz+z; if(fCorrelVzBin) { - sz = "_vz%d"+z; - tz = ", v_{z} bin "+z; + sz = Form("_vz%d",z); + tz = Form(", #it{v}_{#it{z}} bin %d",z); } //printf("MIX : iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data()); - fhMixDeltaPhiChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("p_{T trigger}"); - fhMixDeltaPhiChargedAssocPtBin[bin]->SetYTitle("#Delta #phi"); - - fhMixDeltaPhiChargedAssocPtBinDEta08[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0.8ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("p_{T trigger}"); - fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi"); + fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiDeltaEtaChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax); + fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)"); + fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetYTitle("#Delta #eta"); - fhMixDeltaPhiChargedAssocPtBinDEta0[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); - fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("p_{T trigger}"); - fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi"); + outputContainer->Add(fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]); - fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiDeltaEtaChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), - Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), - ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax); - fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetXTitle("#Delta #phi"); - fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetYTitle("#Delta #eta"); + fhMixDeltaPhiChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhMixDeltaPhiChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)"); outputContainer->Add(fhMixDeltaPhiChargedAssocPtBin[bin]); - outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta08[bin]); - outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta0[bin]); - outputContainer->Add(fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]); + + if(fFillEtaGapsHisto) + { + fhMixDeltaPhiChargedAssocPtBinDEta08[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0.8ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)"); + + fhMixDeltaPhiChargedAssocPtBinDEta0[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()), + Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()), + nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax); + fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})"); + fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)"); + + outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta08[bin]); + outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta0[bin]); + } } - } + } } return outputContainer; } -//_________________________________________________________________________________________________ -Bool_t AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum(const AliAODPWG4Particle* trigger, - TLorentzVector & mom1, - TLorentzVector & mom2) +//_____________________________________________________________________________________________________________________ +Bool_t AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum(Int_t indexPhoton1, Int_t indexPhoton2, Int_t idetector) { // Get the momentum of the pi0/eta assigned decay photons - // In case of pi0/eta trigger, we may want to check their decay correlation, + // In case of pi0/eta trigger, we may want to check their decay correlation, // get their decay children - Int_t indexPhoton1 = trigger->GetCaloLabel(0); - Int_t indexPhoton2 = trigger->GetCaloLabel(1); - Float_t ptTrig = trigger->Pt(); - if(indexPhoton1!=-1 || indexPhoton2!=-1) return kFALSE; - if(GetDebug() > 1) - printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - indexPhoton1 = %d, indexPhoton2 = %d \n", indexPhoton1, indexPhoton2); + AliDebug(1,Form("indexPhoton1 = %d, indexPhoton2 = %d", indexPhoton1, indexPhoton2)); - TObjArray * clusters = 0x0 ; - if(trigger->GetDetector()=="EMCAL") clusters = GetEMCALClusters() ; - else clusters = GetPHOSClusters() ; + TObjArray * clusters = 0x0 ; + if(idetector==kEMCAL) clusters = GetEMCALClusters() ; + else clusters = GetPHOSClusters() ; for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++) { - AliVCluster * photon = (AliVCluster*) (clusters->At(iclus)); - if(photon->GetID()==indexPhoton1) - { - photon->GetMomentum(mom1,GetVertex(0)) ; - if(ptTrig) fhPtPi0DecayRatio->Fill(ptTrig, mom1.Pt()/ptTrig); - } - if(photon->GetID()==indexPhoton2) - { - photon->GetMomentum(mom1,GetVertex(0)) ; - if(ptTrig > 0) fhPtPi0DecayRatio->Fill(ptTrig, mom2.Pt()/ptTrig); - } + AliVCluster * photon = (AliVCluster*) (clusters->At(iclus)); + + if(photon->GetID()==indexPhoton1) photon->GetMomentum(fDecayMom1,GetVertex(0)) ; + if(photon->GetID()==indexPhoton2) photon->GetMomentum(fDecayMom2,GetVertex(0)) ; - if(GetDebug() > 1)printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - Photon1 = %f, Photon2 = %f \n", mom1.Pt(), mom2.Pt()); + AliDebug(1,Form("Photon1 = %f, Photon2 = %f", fDecayMom1.Pt(), fDecayMom2.Pt())); } //cluster loop @@ -2079,6 +2881,33 @@ Bool_t AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum(const AliAODPWG4P } +//_____________________________________________________________ +Int_t AliAnaParticleHadronCorrelation::GetMCTagHistogramIndex(Int_t mcTag) +{ + // Index of MC histograms depending on MC origin + + if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt) || + GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation)) return 0; + else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0)) return 1; + else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay)) return 2; + else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) || + GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay)) return 3; + else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay)) return 4; + else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)) return 5; + else return 6; + +} + +//_________________________________________ +void AliAnaParticleHadronCorrelation::Init() +{ + //Init + //Do some checks + + if(!GetReader()->IsCTSSwitchedOn()) + AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!"); +} + //____________________________________________________ void AliAnaParticleHadronCorrelation::InitParameters() { @@ -2089,12 +2918,12 @@ void AliAnaParticleHadronCorrelation::InitParameters() AddToHistogramsName("AnaHadronCorr_"); SetPtCutRange(0.,300); - fDeltaPhiMinCut = 1.5 ; - fDeltaPhiMaxCut = 4.5 ; + fDeltaPhiMinCut = TMath::DegToRad()*120.; + fDeltaPhiMaxCut = TMath::DegToRad()*240. ; fSelectIsolated = kFALSE; fMakeSeveralUE = kFALSE; - fUeDeltaPhiMinCut = 1. ; - fUeDeltaPhiMaxCut = 1.5 ; + fUeDeltaPhiMinCut = TMath::DegToRad()*60.; + fUeDeltaPhiMaxCut = TMath::DegToRad()*120 ; fNeutralCorr = kFALSE ; fPi0Trigger = kFALSE ; @@ -2126,283 +2955,438 @@ void AliAnaParticleHadronCorrelation::InitParameters() fAssocPtBinLimit[18] = 50.0 ; fAssocPtBinLimit[19] = 200.0 ; - fUseMixStoredInReader = kTRUE; fM02MinCut = -1 ; fM02MaxCut = -1 ; -} + fSelectLeadingHadronAngle = kFALSE; + fFillLeadHadOppositeHisto = kFALSE; + fMinLeadHadPhi = 150*TMath::DegToRad(); + fMaxLeadHadPhi = 210*TMath::DegToRad(); -//__________________________________________________________ -void AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() -{ - //Particle-Hadron Correlation Analysis, fill AODs + fMinLeadHadPt = 1; + fMaxLeadHadPt = 100; - if(!GetInputAODBranch()) - { - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data()); - abort(); - } - - if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation")) - { - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - Wrong type of AOD object, change AOD class name in input AOD: It should be and not <%s> \n",GetInputAODBranch()->GetClass()->GetName()); - abort(); - } - - if(GetDebug() > 1) - { - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - Begin hadron correlation analysis, fill AODs \n"); - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast()); - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In CTS aod entries %d\n", GetCTSTracks() ->GetEntriesFast()); - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In EMCAL aod entries %d\n", GetEMCALClusters()->GetEntriesFast()); - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - In PHOS aod entries %d\n", GetPHOSClusters() ->GetEntriesFast()); - } - - //Get the vertex and check it is not too large in z - Double_t v[3] = {0,0,0}; //vertex ; - GetReader()->GetVertex(v); - if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ; + fMCGenTypeMin = 0; + fMCGenTypeMax = 6; - // Fill the pool with tracks if requested - if(DoOwnMix()) - { - FillChargedEventMixPool(); - if(OnlyIsolated()) - FillNeutralEventMixPool(); - } + fNDecayBits = 1; + fDecayBits[0] = AliNeutralMesonSelection::kPi0; + fDecayBits[1] = AliNeutralMesonSelection::kEta; + fDecayBits[2] = AliNeutralMesonSelection::kPi0Side; + fDecayBits[3] = AliNeutralMesonSelection::kEtaSide; +} + +//_________________________________________________________________________ +Bool_t AliAnaParticleHadronCorrelation::IsTriggerTheEventLeadingParticle() +{ + // Check if the what of the selected triggers is leading particle comparing + // with all the triggers, all the tracks or all the clusters (if requested for the clusters). + + Double_t ptTrig = GetMinPt(); + Double_t phiTrig = 0 ; + fLeadingTriggerIndex =-1 ; + Int_t index =-1 ; + AliAODPWG4ParticleCorrelation* pLeading = 0; + + // Loop on stored AOD particles, find leading trigger on the selected list, with at least min pT. - //Loop on stored AOD particles, find leading trigger - Double_t ptTrig = fMinTriggerPt ; - fLeadingTriggerIndex = -1 ; - Int_t naod = GetInputAODBranch()->GetEntriesFast() ; - for(Int_t iaod = 0; iaod < naod ; iaod++) + for(Int_t iaod = 0; iaod < GetInputAODBranch()->GetEntriesFast() ; iaod++) { AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod)); - + particle->SetLeadingParticle(kFALSE); // set it later + // Vertex cut in case of mixing Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0)); if(check == 0) continue; - if(check == -1) return; - + if(check == -1) return kFALSE; // not sure if it is correct. + // find the leading particles with highest momentum - if (particle->Pt() > ptTrig) + if (particle->Pt() > ptTrig) { - ptTrig = particle->Pt() ; - fLeadingTriggerIndex = iaod ; + ptTrig = particle->Pt() ; + phiTrig = particle->Phi(); + index = iaod ; + pLeading = particle ; } - }// finish search of leading trigger particle - + }// finish search of leading trigger particle on the AOD branch. + + if(index < 0) return kFALSE; + + //printf("AOD leading pT %2.2f, ID %d\n", pLeading->Pt(),pLeading->GetCaloLabel(0)); + + if(phiTrig < 0 ) phiTrig += TMath::TwoPi(); - //Do correlation with leading particle - if(fLeadingTriggerIndex >= 0) + // Compare if it is the leading of all tracks + + for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ ) { - - AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(fLeadingTriggerIndex)); + AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ; - //check if the particle is isolated or if we want to take the isolation into account - if(OnlyIsolated() && !particle->IsIsolated()) return; + if(track->GetID() == pLeading->GetTrackLabel(0) || track->GetID() == pLeading->GetTrackLabel(1) || + track->GetID() == pLeading->GetTrackLabel(2) || track->GetID() == pLeading->GetTrackLabel(3) ) continue ; - //Make correlation with charged hadrons - Bool_t okcharged = kTRUE; - Bool_t okneutral = kTRUE; - if(GetReader()->IsCTSSwitchedOn() ) - okcharged = MakeChargedCorrelation(particle, GetCTSTracks(),kFALSE); + fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz()); + Float_t pt = fTrackVector.Pt(); + Float_t phi = fTrackVector.Phi() ; + if(phi < 0) phi+=TMath::TwoPi(); - TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists - if(fNeutralCorr && pi0list && pi0list->GetEntriesFast() > 0) - okneutral = MakeNeutralCorrelation(particle, pi0list,kFALSE); + //jump out this event if near side associated particle pt larger than trigger + if (fMakeNearSideLeading) + { + Float_t deltaPhi = phiTrig-phi; + if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); + if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); + + if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE; + } + //jump out this event if there is any other particle with pt larger than trigger + else + { + if(pt > ptTrig) return kFALSE ; + } + }// track loop + + // Compare if it is leading of all calorimeter clusters + + if(fCheckLeadingWithNeutralClusters) + { + // Select the calorimeter cluster list + TObjArray * nePl = 0x0; + if (pLeading->GetDetectorTag() == kPHOS ) + nePl = GetPHOSClusters(); + else + nePl = GetEMCALClusters(); - }//Correlate leading + if(!nePl) return kTRUE; // Do the selection just with the tracks if no calorimeter is available. + + for(Int_t ipr = 0;ipr < nePl->GetEntriesFast() ; ipr ++ ) + { + AliVCluster * cluster = (AliVCluster *) (nePl->At(ipr)) ; + + if(cluster->GetID() == pLeading->GetCaloLabel(0) || cluster->GetID() == pLeading->GetCaloLabel(1) ) continue ; + + cluster->GetMomentum(fMomentum,GetVertex(0)); + + Float_t pt = fMomentum.Pt(); + Float_t phi = fMomentum.Phi() ; + if(phi < 0) phi+=TMath::TwoPi(); + + if(IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ; // avoid charged clusters, already covered by tracks, or cluster merging with track. + + //jump out this event if near side associated particle pt larger than trigger + // not really needed for calorimeter, unless DCal is included + if (fMakeNearSideLeading) + { + Float_t deltaPhi = phiTrig-phi; + if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); + if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); + + if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE ; + } + //jump out this event if there is any other particle with pt larger than trigger + else + { + if(pt > ptTrig) return kFALSE ; + } + }// cluster loop + } // check neutral clusters - if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - End fill AODs \n"); + fLeadingTriggerIndex = index ; + pLeading->SetLeadingParticle(kTRUE); + + AliDebug(1,Form("\t particle AOD with index %d is leading with pT %2.2f", fLeadingTriggerIndex, pLeading->Pt())); + + return kTRUE; } //_________________________________________________________________ -void AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() +void AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() { //Particle-Hadron Correlation Analysis, fill histograms if(!GetInputAODBranch()) { - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data()); - abort(); + AliFatal(Form("No input particles in AOD with name branch < %s >, STOP",GetInputAODName().Data())); + return ; // coverity } - if(GetDebug() > 1) + Int_t naod = GetInputAODBranch()->GetEntriesFast(); + if( naod == 0 ) { - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Begin hadron correlation analysis, fill histograms \n"); - printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - In particle branch aod entries %d\n", GetInputAODBranch()->GetEntriesFast()); + AliWarning("No particle AOD found!"); + return ; // no trigger particles found. } - - //Get the vertex and check it is not too large in z - Double_t v[3] = {0,0,0}; //vertex ; - GetReader()->GetVertex(v); - if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ; + + AliDebug(1,Form("Begin hadron correlation analysis, fill histograms")); + AliDebug(1,Form("n particle branch aod entries %d", naod)); + AliDebug(1,Form("In CTS aod entries %d",GetCTSTracks()->GetEntriesFast())); - //Loop on stored AOD particles, find leading - Double_t ptTrig = fMinTriggerPt; - if(fLeadingTriggerIndex < 0) + //------------------------------------------------------ + // Find leading trigger if analysis request only leading, + // if there is no leading trigger, then skip the event + + Int_t iaod = 0 ; + if( fMakeAbsoluteLeading || fMakeNearSideLeading ) { - //Search leading if not done before - Int_t naod = GetInputAODBranch()->GetEntriesFast() ; - for(Int_t iaod = 0; iaod < naod ; iaod++) - { //loop on input trigger AOD file - AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod)); + Bool_t leading = IsTriggerTheEventLeadingParticle(); + + AliDebug(1,Form("AOD Leading trigger? %d, with index %d",leading,fLeadingTriggerIndex)); + + if(!leading) + { + AliDebug(1,"Leading was requested and not found"); + return ; + } + else + { + // Select only the leading in the trigger AOD loop + naod = fLeadingTriggerIndex+1 ; + iaod = fLeadingTriggerIndex ; + } + } - // Vertex cut in case of mixing - Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0)); - if(check == 0) continue; - if(check == -1) return; - - //check if the particle is isolated or if we want to take the isolation into account - if(OnlyIsolated() && !particle->IsIsolated()) continue; - - //find the leading particles with highest momentum - if (particle->Pt() > ptTrig) - { - ptTrig = particle->Pt() ; - fLeadingTriggerIndex = iaod ; - } - - }// Finish search of leading trigger particle - }// Search leading if not done before + //------------------------------------------------------ + // Get event multiplicity and bins + + Float_t cen = GetEventCentrality(); + Float_t ep = GetEventPlaneAngle(); + if(IsHighMultiplicityAnalysisOn()) fhTriggerEventPlaneCentrality->Fill(cen,ep); + + Int_t mixEventBin = GetEventMixBin(); + Int_t vzbin = GetEventVzBin(); + + //------------------------------------------------------ + // Loop on trigger AOD - if(fLeadingTriggerIndex >= 0 ) - { //using trigger particle to do correlations + for( iaod = 0; iaod < naod; iaod++ ) + { + AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod)); + + // + // Trigger particle selection criteria: + // + Float_t pt = particle->Pt(); - AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(fLeadingTriggerIndex)); + if(pt < GetMinPt() || pt > GetMaxPt() ) continue ; - // check if it was a calorimeter cluster and if the SS cut was requested, if so, apply it + fhPtTriggerInput->Fill(pt); + + // + // check if it was a calorimeter cluster + // and if the shower shape cut was requested apply it. + // Not needed if already done at the particle identification level, + // but for isolation studies, it is preferred not to remove so we do it here + // Int_t clID1 = particle->GetCaloLabel(0) ; Int_t clID2 = particle->GetCaloLabel(1) ; // for photon clusters should not be set. - //printf("Leading for for %s: id1 %d, id2 %d, min %f, max %f, det %s\n", - // GetInputAODName().Data(),clID1,clID2,fM02MinCut,fM02MaxCut,(particle->GetDetector()).Data()); - + AliDebug(1,Form("%s Trigger : id1 %d, id2 %d, min %f, max %f, det %d", + GetInputAODName().Data(),clID1,clID2,fM02MinCut,fM02MaxCut,particle->GetDetectorTag())); + if(clID1 > 0 && clID2 < 0 && fM02MaxCut > 0 && fM02MinCut > 0) { - Int_t iclus = -1; - TObjArray* clusters = 0x0; - if (particle->GetDetector() == "EMCAL") clusters = GetEMCALClusters(); - else if(particle->GetDetector() == "PHOS" ) clusters = GetPHOSClusters(); +// Int_t iclus = -1; +// TObjArray* clusters = 0x0; +// if (particle->GetDetectorTag() == kEMCAL) clusters = GetEMCALClusters(); +// else if(particle->GetDetectorTag() == kPHOS ) clusters = GetPHOSClusters(); +// +// if(clusters) +// { +// AliVCluster *cluster = FindCluster(clusters,clID1,iclus); +// Float_t m02 = cluster->GetM02(); +// if(m02 > fM02MaxCut || m02 < fM02MinCut) continue ; +// } - if(clusters) - { - AliVCluster *cluster = FindCluster(clusters,clID1,iclus); - Float_t m02 = cluster->GetM02(); - //printf("\t Check m02 = %2.2f\n",m02); - if(m02 > fM02MaxCut || m02 < fM02MinCut) - { - //printf("\t \t Not accepted\n"); - return; - } - } + Float_t m02 = particle->GetM02(); + if(m02 > fM02MaxCut || m02 < fM02MinCut) continue ; + + fhPtTriggerSSCut->Fill(pt); } + // // Check if the particle is isolated or if we want to take the isolation into account - if(OnlyIsolated() && !particle->IsIsolated()) return; - - Float_t pt = particle->Pt(); - fhPtInput->Fill(pt); + // This bool is set in AliAnaParticleIsolation + // + if(OnlyIsolated()) + { + if( !particle->IsIsolated() ) continue; + fhPtTriggerIsoCut->Fill(pt); + } + // // Check if trigger is in fiducial region + // if(IsFiducialCutOn()) { - Bool_t in = GetFiducialCut()->IsInFiducialCut(*particle->Momentum(),particle->GetDetector()) ; - if(! in ) return ; + Bool_t in = GetFiducialCut()->IsInFiducialCut(particle->Eta(),particle->Phi(),particle->GetDetectorTag()) ; + if(! in ) continue ; } - fhPtFidCut->Fill(pt); - - // Make correlation with charged hadrons - Bool_t okcharged = kTRUE; - Bool_t okneutral = kTRUE; - if(GetReader()->IsCTSSwitchedOn() ) - { - okcharged = MakeChargedCorrelation(particle, GetCTSTracks(),kTRUE); - if(IsDataMC()) - { - MakeMCChargedCorrelation(particle); - } - } + fhPtTriggerFidCut->Fill(pt); + + //--------------------------------------- + // Make correlation - TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); //For the future, foresee more possible pi0 lists - if(fNeutralCorr && pi0list) + // Find the leading hadron in the opposite hemisphere to the triggeer + // and accept the trigger if leading is in defined window. + Bool_t okLeadHad = kTRUE; + if(fSelectLeadingHadronAngle || fFillLeadHadOppositeHisto) { - if(pi0list->GetEntriesFast() > 0) - okneutral = MakeNeutralCorrelation(particle, pi0list,kTRUE); + okLeadHad = FindLeadingOppositeHadronInWindow(particle); + if(!okLeadHad && fSelectLeadingHadronAngle) continue; } - // Fill leading particle histogram if correlation went well and - // no problem was found, like not absolute leading, or bad vertex in mixing. - if(okcharged && okneutral) + // + // Charged particles correlation + // + MakeChargedCorrelation(particle); + + // MC + Int_t mcIndex = -1; + Int_t mcTag = particle->GetTag(); + Bool_t lostDecayPair = kFALSE; + if(IsDataMC()) { - fhPtLeading->Fill(pt); - fhPtLeadingBin->Fill(pt,GetEventMixBin()); - if(fCorrelVzBin) fhPtLeadingVzBin->Fill(pt,GetEventVzBin()); + mcIndex = GetMCTagHistogramIndex(mcTag); + lostDecayPair = GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost); + MakeMCChargedCorrelation(particle->GetLabel(), mcIndex,lostDecayPair); + } + + // Do own mixed event with charged, + // add event and remove previous or fill the mixed histograms + if(DoOwnMix()) + MakeChargedMixCorrelation(particle); - Float_t phi = particle->Phi(); - if(phi<0)phi+=TMath::TwoPi(); - fhPhiLeading->Fill(pt, phi); - - fhEtaLeading->Fill(pt, particle->Eta()); - //printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Leading particle : pt %f, eta %f, phi %f\n",particle->Pt(),particle->Eta(),phi); - - Float_t cen = GetEventCentrality(); - Float_t ep = GetEventPlaneAngle(); + // + // Neutral particles correlation + // + if(fNeutralCorr) + MakeNeutralCorrelation(particle); + + //---------------------------------------------------------------- + // Fill trigger pT related histograms if not absolute leading + + // + // pT of the trigger, vs trigger origin if MC + // + fhPtTrigger->Fill(pt); + if(IsDataMC() && mcIndex >=0 && mcIndex < fgkNmcTypes) + { + fhPtTriggerMC[mcIndex]->Fill(pt); + if( lostDecayPair && mcIndex==2 ) + fhPtTriggerMC[7]->Fill(pt); + } + + if(fDecayTrigger) + { + Int_t decayTag = particle->DecayTag(); + if(decayTag < 0) decayTag = 0; - fhPtLeadingCentrality ->Fill(pt,cen); - fhPtLeadingEventPlane ->Fill(pt,ep); - fhLeadingEventPlaneCentrality->Fill(cen,ep); + for(Int_t ibit = 0; ibitCheckDecayBit(decayTag,fDecayBits[ibit])) + { + fhPtDecayTrigger[ibit]->Fill(pt); + + if(IsDataMC() && mcIndex >=0 && mcIndex < fgkNmcTypes) + { + fhPtDecayTriggerMC[ibit][mcIndex]->Fill(pt); + if(lostDecayPair && mcIndex==2 ) + fhPtDecayTriggerMC[ibit][7]->Fill(pt); + } + }// check bit + }// bit loop + } + + // + // Acceptance of the trigger + // + Float_t phi = particle->Phi(); + if( phi < 0 ) phi+=TMath::TwoPi(); + fhPhiTrigger->Fill(pt, phi); + + fhEtaTrigger->Fill(pt, particle->Eta()); + //printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Trigger particle : pt %f, eta %f, phi %f\n",particle->Pt(),particle->Eta(),phi); + + //---------------------------------- + // Trigger particle pT vs event bins + + fhPtTriggerBin->Fill(pt,mixEventBin); + if(fCorrelVzBin) + fhPtTriggerVzBin->Fill(pt,vzbin); + + if(IsHighMultiplicityAnalysisOn()) + { + fhPtTriggerCentrality->Fill(pt,cen); + fhPtTriggerEventPlane->Fill(pt,ep); + } + + //---------------------------------- + // Trigger particle pT vs pile-up + + if(IsPileUpAnalysisOn()) + { + Int_t vtxBC = GetReader()->GetVertexBC(); + if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtTriggerVtxBC0->Fill(pt); - }//ok charged && neutral - }//Aod branch loop + if(GetReader()->IsPileUpFromSPD()) fhPtTriggerPileUp[0]->Fill(pt); + if(GetReader()->IsPileUpFromEMCal()) fhPtTriggerPileUp[1]->Fill(pt); + if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtTriggerPileUp[2]->Fill(pt); + if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtTriggerPileUp[3]->Fill(pt); + if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtTriggerPileUp[4]->Fill(pt); + if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtTriggerPileUp[5]->Fill(pt); + if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtTriggerPileUp[6]->Fill(pt); + } + } // AOD trigger loop //Reinit for next event fLeadingTriggerIndex = -1; - if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - End fill histograms \n"); + AliDebug(1,"End fill histograms"); } -//___________________________________________________________________________________________________________ -Bool_t AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle, - const TObjArray* pl, const Bool_t bFillHisto) +//_______________________________________________________________________________________________________ +void AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle) { // Charged Hadron Correlation Analysis - if(GetDebug() > 1) - printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Make trigger particle - charged hadron correlation \n"); + AliDebug(1,"Make trigger particle - charged hadron correlation"); Float_t phiTrig = aodParticle->Phi(); Float_t etaTrig = aodParticle->Eta(); Float_t ptTrig = aodParticle->Pt(); - Bool_t decay = aodParticle->IsTagged(); + Int_t mcTag = aodParticle->GetTag(); + Double_t bz = GetReader()->GetInputEvent()->GetMagneticField(); + + + Int_t decayTag = 0; + if(fDecayTrigger) + { + //decay = aodParticle->IsTagged(); + decayTag = aodParticle->DecayTag(); + if(decayTag < 0) decayTag = 0; +// printf("Correlation: pT %2.2f, BTag %d, Tagged %d\n",ptTrig, decayTag, aodParticle->IsTagged()); +// printf("\t check bit Pi0 %d, Eta %d, Pi0Side %d, EtaSide %d\n", +// GetNeutralMesonSelection()->CheckDecayBit(decayTag,AliNeutralMesonSelection::kPi0), +// GetNeutralMesonSelection()->CheckDecayBit(decayTag,AliNeutralMesonSelection::kEta), +// GetNeutralMesonSelection()->CheckDecayBit(decayTag,AliNeutralMesonSelection::kPi0Side), +// GetNeutralMesonSelection()->CheckDecayBit(decayTag,AliNeutralMesonSelection::kEtaSide)); + } Float_t pt = -100. ; - Float_t zT = -100. ; - Float_t xE = -100. ; - Float_t hbpXE = -100. ; - Float_t hbpZT = -100. ; Float_t phi = -100. ; Float_t eta = -100. ; - Float_t pout = -100. ; Float_t deltaPhi = -100. ; - TVector3 p3; - TLorentzVector photonMom ; TObjArray * reftracks = 0x0; Int_t nrefs = 0; - Int_t nTracks = GetCTSTracks()->GetEntriesFast() ; // Mixed event settings Int_t evtIndex11 = -1 ; // cluster trigger or pi0 trigger Int_t evtIndex12 = -1 ; // pi0 trigger Int_t evtIndex13 = -1 ; // charged trigger - Double_t v[3] = {0,0,0}; //vertex ; - GetReader()->GetVertex(v); - if (GetMixedEvent()) { evtIndex11 = GetMixedEvent()->EventIndexForCaloCluster(aodParticle->GetCaloLabel(0)) ; @@ -2410,48 +3394,49 @@ Bool_t AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4Partic evtIndex13 = GetMixedEvent()->EventIndex(aodParticle->GetTrackLabel(0)) ; } - // In case of pi0/eta trigger, we may want to check their decay correlation, + // Track multiplicity or cent bin + Int_t cenbin = 0; + if(IsHighMultiplicityAnalysisOn()) cenbin = GetEventCentralityBin(); + + // + // In case of pi0/eta trigger, we may want to check their decay correlation, // get their decay children - TLorentzVector decayMom1; - TLorentzVector decayMom2; - Bool_t decayFound = kFALSE; - if(fPi0Trigger && bFillHisto) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2); + // + Bool_t decayFound = kFALSE; + if( fPi0Trigger ) + { + decayFound = GetDecayPhotonMomentum(aodParticle->GetCaloLabel(0),aodParticle->GetCaloLabel(1),aodParticle->GetDetectorTag()); + if(decayFound) + { + fhPtPi0DecayRatio->Fill(ptTrig, fDecayMom1.Pt()/ptTrig); + fhPtPi0DecayRatio->Fill(ptTrig, fDecayMom2.Pt()/ptTrig); + } + } + //----------------------------------------------------------------------- - //Track loop, select tracks with good pt, phi and fill AODs or histograms + // Track loop, select tracks with good pt, phi and fill AODs or histograms //----------------------------------------------------------------------- - - for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ ) + + for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ ) { - AliVTrack * track = (AliVTrack *) (pl->At(ipr)) ; + AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ; - Double_t mom[3] = {track->Px(),track->Py(),track->Pz()}; - p3.SetXYZ(mom[0],mom[1],mom[2]); - pt = p3.Pt(); - eta = p3.Eta(); - phi = p3.Phi() ; + fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz()); + pt = fTrackVector.Pt(); + eta = fTrackVector.Eta(); + phi = fTrackVector.Phi() ; if(phi < 0) phi+=TMath::TwoPi(); //Select only hadrons in pt range if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ; - //remove trigger itself for correlation when use charged triggers - if( track->GetID() == aodParticle->GetTrackLabel(0) || track->GetID() == aodParticle->GetTrackLabel(1) || - track->GetID() == aodParticle->GetTrackLabel(2) || track->GetID() == aodParticle->GetTrackLabel(3) ) - continue ; - - //jump out this event if near side associated particle pt larger than trigger - if (fMakeNearSideLeading) - { - if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE; - } - //jump out this event if there is any other particle with pt larger than trigger - else if(fMakeAbsoluteLeading) - { - if(pt > ptTrig) return kFALSE; - } - - //Only for mixed event + //remove trigger itself for correlation when use charged triggers + if( track->GetID() == aodParticle->GetTrackLabel(0) || track->GetID() == aodParticle->GetTrackLabel(1) || + track->GetID() == aodParticle->GetTrackLabel(2) || track->GetID() == aodParticle->GetTrackLabel(3) ) + continue ; + + //Only for mixed event frame Int_t evtIndex2 = 0 ; if (GetMixedEvent()) { @@ -2460,117 +3445,134 @@ Bool_t AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4Partic continue ; //vertex cut if (TMath::Abs(GetVertex(evtIndex2)[2]) > GetZvertexCut()) - return kFALSE; + continue; } + AliDebug(2,Form("Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f",pt,phi,eta)); + + // ------------------------------ + // Track type bin or bits setting + // + + // + // * Set the pt associated bin for the defined bins * + // + Int_t assocBin = -1; + for(Int_t i = 0 ; i < fNAssocPtBins ; i++) + { + if(pt > fAssocPtBinLimit[i] && pt < fAssocPtBinLimit[i+1]) assocBin= i; + } + + // + // * Assign to the histogram array a bin corresponding + // to a combination of pTa and vz bins * + // + Int_t nz = 1; + Int_t vz = 0; + + if(fCorrelVzBin) + { + nz = GetNZvertBin(); + vz = GetEventVzBin(); + } + + Int_t bin = assocBin*nz+vz; + + //printf("assoc Bin = %d, vZ bin = %d, bin = %d \n", assocBin,GetEventVzBin(),bin); + + // + // * Get the status of the TOF bit * + // + ULong_t status = track->GetStatus(); + Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ; + //Double32_t tof = track->GetTOFsignal()*1e-3; + Int_t trackBC = track->GetTOFBunchCrossing(bz); + + Int_t outTOF = -1; + if (okTOF && trackBC!=0) outTOF = 1; + else if(okTOF && trackBC==0) outTOF = 0; + + //---------------- // Fill Histograms - if(bFillHisto) - { - if(GetDebug() > 2 ) - printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta); - - // Set the pt associated bin for the defined bins - Int_t assocBin = -1; - for(Int_t i = 0 ; i < fNAssocPtBins ; i++) - { - if(pt > fAssocPtBinLimit[i] && pt < fAssocPtBinLimit[i+1]) assocBin= i; - } - - // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins - Int_t nz = 1; - Int_t vz = 0; - - if(fCorrelVzBin) - { - nz = GetNZvertBin(); - vz = GetEventVzBin(); - } - - Int_t bin = assocBin*nz+vz; - - //printf("assoc Bin = %d, vZ bin = %d, bin = %d \n", assocBin,GetEventVzBin(),bin); - - // Azimuthal Angle - // calculate deltaPhi for later, shift when needed - FillChargedAngularCorrelationHistograms(pt, ptTrig, bin, phi, phiTrig, deltaPhi, - eta, etaTrig, decay, track->GetHMPIDsignal(),nTracks); - - // Imbalance zT/xE/pOut - zT = pt/ptTrig ; - if(zT > 0 ) hbpZT = TMath::Log(1./zT); - else hbpZT =-100; - - xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig); - //if(xE <0.)xE =-xE; - if(xE > 0 ) hbpXE = TMath::Log(1./xE); - else hbpXE =-100; + // + // Azimuthal Angle histograms + // - pout = pt*TMath::Sin(deltaPhi) ; - - //delta phi cut for momentum imbalance correlation - if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) ) - { - - FillChargedMomentumImbalanceHistograms(ptTrig, pt, xE, hbpXE, zT, hbpZT, pout, deltaPhi, - nTracks, track->Charge(), bin, decay); - - } - if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) ) - { //UE study - - FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, nTracks); + deltaPhi = phiTrig-phi; - fhUePart->Fill(ptTrig); - - } - - if(fPi0Trigger && decayFound) - FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2, kTRUE) ; - - //several UE calculation - if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi); - - } //Fill histogram - else + // + // Calculate deltaPhi shift so that for the particles on the opposite side + // it is defined between 90 and 270 degrees + // Shift [-360,-90] to [0, 270] + // and [270,360] to [-90,0] + if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); + if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); + + FillChargedAngularCorrelationHistograms(pt, ptTrig, bin, phi, phiTrig, deltaPhi, + eta, etaTrig, decayTag, track->GetHMPIDsignal(), + outTOF, cenbin, mcTag); + + // + // Imbalance zT/xE/pOut histograms + // + + // + // Delta phi cut for momentum imbalance correlation + // + if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) ) + FillChargedMomentumImbalanceHistograms(ptTrig, pt, deltaPhi, cenbin, track->Charge(), + assocBin, decayTag, outTOF, mcTag); + + // + // Underlying event, right side, default case + // + if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) ) + FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, cenbin, outTOF); + + // + // Several UE calculation, in different perpendicular regions, up to 6: + // left, right, upper-left, lower left, upper-right, lower-right + // + if(fMakeSeveralUE) + FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi); + + // + if(fPi0Trigger && decayFound) + FillDecayPhotonCorrelationHistograms(pt, phi, kTRUE) ; + + // + // Add track reference to array + // + if(fFillAODWithReferences) { nrefs++; if(nrefs==1) { reftracks = new TObjArray(0); - TString trackname = Form("%s+Tracks", GetAODObjArrayName().Data()); + TString trackname = Form("%sTracks", GetAODObjArrayName().Data()); reftracks->SetName(trackname.Data()); - reftracks->SetOwner(kFALSE); + reftracks->SetOwner(kFALSE); } reftracks->Add(track); - - }//aod particle loop + }// reference track to AOD }// track loop //Fill AOD with reference tracks, if not filling histograms - if(!bFillHisto && reftracks) + if(fFillAODWithReferences && reftracks) { aodParticle->AddObjArray(reftracks); } - - //Own mixed event, add event and remove previous or fill the mixed histograms - if(DoOwnMix() && bFillHisto) - { - MakeChargedMixCorrelation(aodParticle); - } - - return kTRUE; } - //_________________________________________________________________________________________________________ void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4ParticleCorrelation *aodParticle) { // Mix current trigger with tracks in another MB event - if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Make trigger particle - charged hadron mixed event correlation \n"); + AliDebug(1,Form("Make trigger particle - charged hadron mixed event correlation")); if(GetMixedEvent()) return; // This is not the mixed event from general mixing frame @@ -2584,75 +3586,87 @@ void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4Partic if(!inputHandler) return; if(!(inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask())) return; - + // Get the pool, check if it exits Int_t eventBin = GetEventMixBin(); - - fhEventBin->Fill(eventBin); - //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing + //Check that the bin exists, if not (bad determination of RP, ntrality or vz bin) do nothing if(eventBin < 0) return; + + fhEventBin->Fill(eventBin); + // get neutral clusters pool? + Bool_t isoCase = OnlyIsolated() && (GetIsolationCut()->GetParticleTypeInCone() != AliIsolationCut::kOnlyCharged); + Bool_t neutralMix = fFillNeutralEventMixPool || isoCase ; + TList * pool = 0; TList * poolCalo = 0; if(fUseMixStoredInReader) { pool = GetReader()->GetListWithMixedEventsForTracks(eventBin); - if(OnlyIsolated()) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin); + if(neutralMix) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin); } else { pool = fListMixTrackEvents[eventBin]; - if(OnlyIsolated()) poolCalo = fListMixCaloEvents [eventBin]; + if(neutralMix) poolCalo = fListMixCaloEvents [eventBin]; } if(!pool) return ; - if(OnlyIsolated() && !poolCalo && - (GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::AliIsolationCut::kOnlyCharged)) - printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Careful, cluster pool not available\n"); + if( neutralMix && !poolCalo ) + AliWarning("Careful, cluster pool not available"); Double_t ptTrig = aodParticle->Pt(); Double_t etaTrig = aodParticle->Eta(); Double_t phiTrig = aodParticle->Phi(); if(phiTrig < 0.) phiTrig+=TMath::TwoPi(); - if(GetDebug() > 1) - printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Pool bin %d size %d, leading trigger pt=%f, phi=%f, eta=%f\n", - eventBin,pool->GetSize(), ptTrig,phiTrig,etaTrig); + AliDebug(1,Form("Pool bin %d size %d, trigger trigger pt=%f, phi=%f, eta=%f", + eventBin,pool->GetSize(), ptTrig,phiTrig,etaTrig)); Double_t ptAssoc = -999.; Double_t phiAssoc = -999.; Double_t etaAssoc = -999.; Double_t deltaPhi = -999.; Double_t deltaEta = -999.; - Double_t xE = -999.; - Double_t hbpXE = -999.; - - //Start from first event in pool except if in this same event the pool was filled + Double_t xE = -999.; + + // Start from first event in pool except if in this same event the pool was filled Int_t ev0 = 0; if(GetReader()->GetLastTracksMixedEvent() == GetEventNumber()) ev0 = 1; for(Int_t ev=ev0; ev < pool->GetSize(); ev++) { + // + // Recover the lists of tracks or clusters + // TObjArray* bgTracks = static_cast(pool->At(ev)); - - // Check if the particle is isolated in the mixed event, it not, do not fill the histograms - if(OnlyIsolated()) + TObjArray* bgCalo = 0; + + // Recover the clusters list if requested + if( neutralMix && poolCalo ) { if(pool->GetSize()!=poolCalo->GetSize()) - printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Different size of calo and track pools\n"); - - TObjArray* bgCalo = static_cast(poolCalo->At(ev)); + AliWarning("Different size of calo and track pools"); - if(!bgCalo) - printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Event %d in calo pool not available?\n",ev); + bgCalo = static_cast(poolCalo->At(ev)); - Int_t n=0; Int_t nfrac = 0; Bool_t isolated = kFALSE; Float_t coneptsum = 0; + if(!bgCalo) AliDebug(1,Form("Event %d in calo pool not available?",ev)); + } + + // + // Isolate the trigger in the mixed event with mixed tracks and clusters + // + if( OnlyIsolated() ) + { + Int_t n=0, nfrac = 0; + Bool_t isolated = kFALSE; + Float_t coneptsum = 0, coneptlead = 0; GetIsolationCut()->MakeIsolationCut(bgTracks,bgCalo, GetReader(), GetCaloPID(), - kFALSE, aodParticle, "", - n,nfrac,coneptsum, isolated); + kFALSE, aodParticle, "", + n,nfrac,coneptsum,coneptlead,isolated); //printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Isolated? %d - cone %f, ptthres %f", // isolated,GetIsolationCut()->GetConeSize(),GetIsolationCut()->GetPtThreshold()); @@ -2662,26 +3676,29 @@ void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4Partic if(!isolated) continue ; } - fhEventMixBin->Fill(eventBin); - + // + // Check if the trigger is leading of mixed event + // Int_t nTracks=bgTracks->GetEntriesFast(); - //printf("\t Read Pool event %d, nTracks %d\n",ev,nTracks); - //Check if it is leading if mixed event if(fMakeNearSideLeading || fMakeAbsoluteLeading) { Bool_t leading = kTRUE; - for(Int_t jlead = 0;jlead At(jlead) ; ptAssoc = track->Pt(); phiAssoc = track->Phi() ; - if(phiAssoc < 0) phiAssoc+=TMath::TwoPi(); + if (fMakeNearSideLeading) { - if(ptAssoc > ptTrig && TMath::Abs(phiAssoc-phiTrig) < TMath::PiOver2()) + deltaPhi = phiTrig-phiAssoc; + if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); + if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); + + if(ptAssoc > ptTrig && deltaPhi < TMath::PiOver2()) { leading = kFALSE; break; @@ -2697,15 +3714,65 @@ void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4Partic } } } + + if( !neutralMix && fCheckLeadingWithNeutralClusters ) + AliWarning("Leading of clusters requested but no clusters in mixed event"); + + if(neutralMix && fCheckLeadingWithNeutralClusters && bgCalo) + { + Int_t nClusters=bgCalo->GetEntriesFast(); + for(Int_t jlead = 0;jlead At(jlead) ; + + ptAssoc = cluster->Pt(); + phiAssoc = cluster->Phi() ; + if(phiAssoc < 0) phiAssoc+=TMath::TwoPi(); + + if (fMakeNearSideLeading) + { + deltaPhi = phiTrig-phiAssoc; + if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); + if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); + + if(ptAssoc > ptTrig && deltaPhi < TMath::PiOver2()) + { + leading = kFALSE; + break; + } + } + //jump out this event if there is any other particle with pt larger than trigger + else if(fMakeAbsoluteLeading) + { + if(ptAssoc > ptTrig) + { + leading = kFALSE; + break; + } + } + } + } + if(!leading) continue; // not leading, check the next event in pool } - fhPtLeadingMixed ->Fill(ptTrig); - fhPhiLeadingMixed ->Fill(ptTrig, phiTrig); - fhEtaLeadingMixed ->Fill(ptTrig, etaTrig); - fhPtLeadingMixedBin->Fill(ptTrig,eventBin); - if(fCorrelVzBin)fhPtLeadingMixedVzBin->Fill(ptTrig, GetEventVzBin()); + // + // Fill histograms for selected triggers + // + + fhEventMixBin->Fill(eventBin); + + //printf("\t Read Pool event %d, nTracks %d\n",ev,nTracks); + + fhPtTriggerMixed ->Fill(ptTrig); + fhPhiTriggerMixed ->Fill(ptTrig, phiTrig); + fhEtaTriggerMixed ->Fill(ptTrig, etaTrig); + fhPtTriggerMixedBin->Fill(ptTrig,eventBin); + if(fCorrelVzBin)fhPtTriggerMixedVzBin->Fill(ptTrig, GetEventVzBin()); + // + // Correlation histograms + // for(Int_t j1 = 0;j1 At(j1) ; @@ -2716,33 +3783,63 @@ void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4Partic etaAssoc = track->Eta(); phiAssoc = track->Phi() ; if(phiAssoc < 0) phiAssoc+=TMath::TwoPi(); - - if(IsFiducialCutOn()) - { - Bool_t in = GetFiducialCut()->IsInFiducialCut(*aodParticle->Momentum(),"CTS") ; - if(!in) continue ; - } deltaPhi = phiTrig-phiAssoc; if(deltaPhi < -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); deltaEta = etaTrig-etaAssoc; - if(GetDebug()>0) - printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation(): deltaPhi= %f, deltaEta=%f\n",deltaPhi, deltaEta); + AliDebug(1,Form("deltaPhi= %f, deltaEta=%f",deltaPhi, deltaEta)); + + // Angular correlation + fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi); + fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta); + + // + // Momentum imbalance + // + if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) ) + { + xE = -ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig); + + if(xE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); + + fhMixXECharged->Fill(ptTrig,xE); + if(xE > 0 ) fhMixHbpXECharged->Fill(ptTrig, TMath::Log(1./xE)); + } + + // + // Underlying event momentum imbalance + // + if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) ) + { + //Underlying event region + Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); + Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi); + + if(uexE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); + + fhMixXEUeCharged->Fill(ptTrig,uexE); + } // Set the pt associated bin for the defined bins - Int_t assocBin = -1; + Int_t assocBin = -1; for(Int_t i = 0 ; i < fNAssocPtBins ; i++) { - if(ptAssoc > fAssocPtBinLimit[i] && ptAssoc < fAssocPtBinLimit[i+1]) assocBin= i; - } - + if(ptAssoc > fAssocPtBinLimit[i] && ptAssoc < fAssocPtBinLimit[i+1]) assocBin= i; + } + + // // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins + // Int_t nz = 1; Int_t vz = 0; - if(fCorrelVzBin) + if(fCorrelVzBin) { nz = GetNZvertBin(); vz = GetEventVzBin(); @@ -2750,45 +3847,36 @@ void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4Partic Int_t bin = assocBin*nz+vz; - fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi); - fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta); - - fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi); - fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta); - - xE =-ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig); - //if(xE <0.)xE =-xE; - if(xE > 0 ) hbpXE = TMath::Log(1./xE); - else hbpXE =-100; - - if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) ) - { - fhMixXECharged->Fill(ptTrig,xE); - fhMixHbpXECharged->Fill(ptTrig,hbpXE); - } - if(bin < 0) continue ; // this pt bin was not considered - if(TMath::Abs(deltaEta) > 0.8) - fhMixDeltaPhiChargedAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi); - if(TMath::Abs(deltaEta) < 0.01) - fhMixDeltaPhiChargedAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi); - - fhMixDeltaPhiChargedAssocPtBin [bin]->Fill(ptTrig, deltaPhi); - fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->Fill(deltaPhi, deltaEta); + fhMixDeltaPhiChargedAssocPtBin [bin]->Fill(ptTrig, deltaPhi); + fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->Fill(deltaPhi, deltaEta); + if(fFillEtaGapsHisto) + { + if(TMath::Abs(deltaEta) > 0.8) + fhMixDeltaPhiChargedAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi); + if(TMath::Abs(deltaEta) < 0.01) + fhMixDeltaPhiChargedAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi); + } + } // track loop } // mixed event loop } -//________________________________________________________________________________________________________________ -Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * const aodParticle, - const TObjArray* pi0list, const Bool_t bFillHisto) +//_______________________________________________________________________________________________________ +void AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * aodParticle) { // Neutral Pion Correlation Analysis - if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Make trigger particle - pi0 correlation, %d pi0's \n", - pi0list->GetEntriesFast()); + + TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); // For the future, foresee more possible pi0 lists + if(!pi0list) return ; + + Int_t npi0 = pi0list->GetEntriesFast(); + if(npi0 == 0) return ; + + AliDebug(1,Form("Particle - pi0 correlation, %d pi0's",npi0)); Int_t evtIndex11 = 0 ; Int_t evtIndex12 = 0 ; @@ -2799,37 +3887,31 @@ Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4Partic } Float_t pt = -100. ; - Float_t zT = -100. ; + Float_t zT = -100. ; Float_t phi = -100. ; Float_t eta = -100. ; Float_t xE = -100. ; Float_t hbpXE= -100. ; - Float_t hbpZT= -100. ; + Float_t hbpZT= -100. ; Float_t ptTrig = aodParticle->Pt(); Float_t phiTrig = aodParticle->Phi(); Float_t etaTrig = aodParticle->Eta(); Float_t deltaPhi= -100. ; - - TLorentzVector photonMom ; + Float_t deltaEta= -100. ; // In case of pi0/eta trigger, we may want to check their decay correlation, // get their decay children - TLorentzVector decayMom1; - TLorentzVector decayMom2; + Bool_t decayFound = kFALSE; - if(fPi0Trigger && bFillHisto) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2); + if(fPi0Trigger) decayFound = GetDecayPhotonMomentum(aodParticle->GetCaloLabel(0),aodParticle->GetCaloLabel(1),aodParticle->GetDetectorTag()); TObjArray * refpi0 = 0x0; Int_t nrefs = 0; //Loop on stored AOD pi0 - Int_t naod = pi0list->GetEntriesFast(); - if(GetDebug() > 0) - printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelationFillHistograms() - aod branch entries %d\n", naod); - - for(Int_t iaod = 0; iaod < naod ; iaod++) + for(Int_t iaod = 0; iaod < npi0 ; iaod++) { AliAODPWG4Particle* pi0 = (AliAODPWG4Particle*) (pi0list->At(iaod)); @@ -2846,60 +3928,86 @@ Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4Partic } pt = pi0->Pt(); - + if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ; - //jump out this event if near side associated particle pt larger than trigger - if (fMakeNearSideLeading) - { - if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE; - } - //jump out this event if there is any other particle with pt larger than trigger - else if(fMakeAbsoluteLeading) - { - if(pt > ptTrig) return kFALSE; - } + //remove trigger itself for correlation when use charged triggers + if(aodParticle->GetCaloLabel(0) >= 0 && + (pi0->GetCaloLabel(0) == aodParticle->GetCaloLabel(0) || pi0->GetCaloLabel(1) == aodParticle->GetCaloLabel(0))) continue ; + + if( aodParticle->GetCaloLabel(1) >= 0 && + (pi0->GetCaloLabel(0) == aodParticle->GetCaloLabel(1) || pi0->GetCaloLabel(1) == aodParticle->GetCaloLabel(1))) continue ; + + // + // Angular correlations + // + phi = pi0->Phi() ; + eta = pi0->Eta() ; + deltaEta = etaTrig-eta; + deltaPhi = phiTrig-phi; + if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi(); + if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi(); + + fhEtaNeutral ->Fill(pt , eta ); + fhPhiNeutral ->Fill(pt , phi ); + fhDeltaEtaNeutral->Fill(ptTrig, deltaEta); + fhDeltaPhiNeutral->Fill(ptTrig, deltaPhi); + + if(pt > 2 ) fhDeltaPhiDeltaEtaNeutral->Fill(deltaPhi, deltaEta); + + // + // Momentum imbalance + // + zT = pt/ptTrig ; + + hbpZT = -100; + hbpXE = -100; + + if(zT > 0 ) hbpZT = TMath::Log(1./zT); - if(bFillHisto) + //delta phi cut for correlation + if( (deltaPhi > fDeltaPhiMinCut) && ( deltaPhi < fDeltaPhiMaxCut) ) { - phi = pi0->Phi() ; - eta = pi0->Eta() ; - - FillNeutralAngularCorrelationHistograms(pt, ptTrig, phi, phiTrig, deltaPhi, eta, etaTrig); - - zT = pt/ptTrig ; xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig); + + if(xE < 0.) + AliWarning(Form("Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f", + xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg())); - //if(xE <0.)xE =-xE; - - hbpXE = -100; - hbpZT = -100; - - if(xE > 0 ) hbpXE = TMath::Log(1./xE); - if(zT > 0 ) hbpZT = TMath::Log(1./zT); - - if(fPi0Trigger && decayFound) - FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2,kFALSE) ; + if(xE > 0 ) hbpXE = TMath::Log(1./xE); - //delta phi cut for correlation - if( (deltaPhi > fDeltaPhiMinCut) && ( deltaPhi < fDeltaPhiMaxCut) ) - { - fhDeltaPhiNeutralPt->Fill(pt,deltaPhi); - fhXENeutral ->Fill(ptTrig,xE); - fhPtHbpXENeutral ->Fill(ptTrig,hbpXE); - } - else if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) ) - { - fhDeltaPhiUeNeutralPt->Fill(pt,deltaPhi); - fhXEUeNeutral ->Fill(ptTrig,xE); - fhPtHbpXEUeNeutral ->Fill(ptTrig,hbpXE); - } + fhDeltaPhiNeutralPt->Fill(pt,deltaPhi); + fhXENeutral ->Fill(ptTrig,xE); + fhPtHbpXENeutral ->Fill(ptTrig,hbpXE); + fhZTNeutral ->Fill(ptTrig,zT); + fhPtHbpZTNeutral ->Fill(ptTrig,hbpZT); + } + else if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) ) + { + // Randomize angle for xE calculation + Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut); - //several UE calculation - if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi); + xE = -(pt/ptTrig)*TMath::Cos(randomphi); + if(xE > 0 ) hbpXE = TMath::Log(1./xE); - } - else + fhDeltaPhiUeNeutralPt->Fill(pt,deltaPhi); + fhZTUeNeutral ->Fill(ptTrig,zT); + fhPtHbpZTUeNeutral ->Fill(ptTrig,hbpZT); + fhXEUeNeutral ->Fill(ptTrig,xE); + fhPtHbpXEUeNeutral ->Fill(ptTrig,hbpXE); + } + + // Several UE calculation, not sure it is useful + // with partical calorimter acceptance + if(fMakeSeveralUE) FillNeutralUnderlyingEventSidesHistograms(ptTrig,pt,zT,hbpZT,deltaPhi); + + // + // Decay photon correlations + // + if(fPi0Trigger && decayFound) + FillDecayPhotonCorrelationHistograms(pt, phi, kFALSE) ; + + if(fFillAODWithReferences) { nrefs++; if(nrefs==1) @@ -2909,194 +4017,216 @@ Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4Partic refpi0->SetOwner(kFALSE); } refpi0->Add(pi0); - }//put references in trigger AOD + } // put references in trigger AOD - if(GetDebug() > 2 ) - printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Selected neutral for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta); + AliDebug(1,Form("Selected pi0: pt %2.2f, phi %2.2f, eta %2.2f",pt,phi,eta)); }//loop - return kTRUE; + //Fill AOD with reference tracks, if not filling histograms + if(fFillAODWithReferences && refpi0) + { + aodParticle->AddObjArray(refpi0); + } } -//_________________________________________________________________________________________________________ -void AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle) -{ +//__________________________________________________________________________________________________________________ +void AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(Int_t label, Int_t histoIndex, Bool_t lostDecayPair) +{ // Charged Hadron Correlation Analysis with MC information - if(GetDebug()>1) - printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation() - Make trigger particle - charged hadron correlation in AOD MC level\n"); + AliDebug(1,"Make trigger particle - charged hadron correlation in AOD MC level"); + if( label < 0 ) + { + AliDebug(1,Form(" *** bad label ***: label %d", label)); + return; + } + + // Do MC correlation for a given particle type range. + // Types defined in GetMCTagHistogramIndex: + // 0 direct gamma; 1 pi0; 2 pi0 decay; 3 eta decay; 4 other decay; 5 electron; 6 other (hadron) + if(histoIndex < fMCGenTypeMin || histoIndex > fMCGenTypeMax) return ; + AliStack * stack = 0x0 ; - TParticle * primary = 0x0 ; - TClonesArray * mcparticles0 = 0x0 ; + TParticle * primary = 0x0 ; TClonesArray * mcparticles = 0x0 ; - AliAODMCParticle * aodprimary = 0x0 ; + AliAODMCParticle * aodprimary = 0x0 ; Double_t eprim = 0 ; Double_t ptprim = 0 ; Double_t phiprim = 0 ; Double_t etaprim = 0 ; - Int_t nTracks = 0 ; + Int_t nTracks = 0 ; Int_t iParticle = 0 ; - Double_t charge = 0.; - - - if(GetReader()->ReadStack()) - { - nTracks = GetMCStack()->GetNtrack() ; - } - else - { - nTracks = GetReader()->GetAODMCParticles()->GetEntriesFast() ; - } - //Int_t trackIndex[nTracks]; - Int_t label= aodParticle->GetLabel(); - if(label < 0) - { - if(GetDebug() > 0) printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** bad label ***: label %d \n", label); - return; - } - + Bool_t leadTrig = kTRUE; - if(GetReader()->ReadStack()) + if( GetReader()->ReadStack() ) { stack = GetMCStack() ; - if(!stack) + if(!stack) { - printf(" AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation- Stack not available, is the MC handler called? STOP\n"); - abort(); + AliFatal("Stack not available, is the MC handler called? STOP"); + return; } - nTracks=stack->GetNprimary(); - if(label >= stack->GetNtrack()) + //nTracks = stack->GetNtrack() ; + nTracks = stack->GetNprimary(); + if( label >= stack->GetNtrack() ) { - if(GetDebug() > 2) printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** large label ***: label %d, n tracks %d \n", label, stack->GetNtrack()); + if(GetDebug() > 2) + AliInfo(Form("*** large label ***: label %d, n tracks %d", label, stack->GetNtrack())); return ; } primary = stack->Particle(label); - if(!primary) + if ( !primary ) { - printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** no primary ***: label %d \n", label); + AliInfo(Form(" *** no primary ***: label %d", label)); return; } - if(primary) + eprim = primary->Energy(); + ptprim = primary->Pt(); + etaprim = primary->Eta(); + phiprim = primary->Phi(); + if(phiprim < 0) phiprim+=TMath::TwoPi(); + + if(ptprim < 0.01 || eprim < 0.01) return ; + + for (iParticle = 0 ; iParticle < nTracks ; iParticle++) { - eprim = primary->Energy(); - ptprim = primary->Pt(); - phiprim = primary->Phi(); - etaprim = primary->Eta(); + TParticle * particle = stack->Particle(iParticle); - if(ptprim < 0.01 || eprim < 0.01) return ; + //keep only final state particles + if( particle->GetStatusCode() != 1 ) continue ; - for (iParticle = 0 ; iParticle < nTracks ; iParticle++) - { - TParticle * particle = stack->Particle(iParticle); - TLorentzVector momentum; - - //keep only final state particles - if(particle->GetStatusCode()!=1) continue ; - - Int_t pdg = particle->GetPdgCode(); - - charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge(); - - particle->Momentum(momentum); - - //---------- Charged particles ---------------------- - if(charge != 0) - { - //Particles in CTS acceptance - Bool_t inCTS = GetFiducialCut()->IsInFiducialCut(momentum,"CTS"); - - if(TMath::Abs(pdg) == 11 && stack->Particle(particle->GetFirstMother())->GetPdgCode()==22) continue ; - - if(inCTS) - { - if( label!=iParticle) // avoid trigger particle - { - if(!FillChargedMCCorrelationHistograms(particle->Pt(),particle->Phi(),particle->Eta(),ptprim,phiprim,etaprim)) return; - } - }// in CTS acceptance - }// charged - } //track loop - } //when the leading particles could trace back to MC + //---------- Charged particles ---------------------- + Int_t pdg = particle->GetPdgCode(); + Int_t charge = (Int_t) TDatabasePDG::Instance()->GetParticle(pdg)->Charge(); + if(charge == 0) continue; + + particle->Momentum(fMomentum); + + //Particles in CTS acceptance, make sure to use the same selection as in the reader + Bool_t inCTS = GetReader()->GetFiducialCut()->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kCTS); + //printf("Accepted? %d; pt %2.2f, eta %2.2f, phi %2.2f\n",inCTS,fMomentum.Pt(),fMomentum.Eta(),fMomentum.Phi()*TMath::RadToDeg()); + if( !inCTS ) continue; + + // Remove conversions + if ( TMath::Abs(pdg) == 11 && stack->Particle(particle->GetFirstMother())->GetPdgCode() == 22 ) continue ; + + if ( label == iParticle ) continue; // avoid trigger particle + + Float_t phi = particle->Phi(); + if(phi < 0) phi+=TMath::TwoPi(); + + Bool_t lead = FillChargedMCCorrelationHistograms(particle->Pt(),phi,particle->Eta(),ptprim,phiprim,etaprim,histoIndex,lostDecayPair); + if(!lead) leadTrig = kFALSE; + //if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading) ) return; + + } //track loop + } //ESD MC - else if(GetReader()->ReadAODMCParticles()) + + else if( GetReader()->ReadAODMCParticles() ) { //Get the list of MC particles - mcparticles0 = GetReader()->GetAODMCParticles(0); - if(!mcparticles0) return; - if(label >=mcparticles0->GetEntriesFast()) + mcparticles = GetReader()->GetAODMCParticles(); + if( !mcparticles ) return; + + nTracks = mcparticles->GetEntriesFast() ; + + if( label >= nTracks ) { - if(GetDebug() > 2) - printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** large label ***: label %d, n tracks %d \n", label,mcparticles0->GetEntriesFast()); + if(GetDebug() > 2) + AliInfo(Form(" *** large label ***: label %d, n tracks %d", label,nTracks)); return; } + //Get the particle - aodprimary = (AliAODMCParticle*) mcparticles0->At(label); - if(!aodprimary) + aodprimary = (AliAODMCParticle*) mcparticles->At(label); + if( !aodprimary ) { - printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation *** no AOD primary ***: label %d \n", label); + AliInfo(Form(" *** no AOD primary ***: label %d", label)); return; } + + eprim = aodprimary->E(); + ptprim = aodprimary->Pt(); + etaprim = aodprimary->Eta(); + phiprim = aodprimary->Phi(); + if(phiprim < 0) phiprim+=TMath::TwoPi(); - - if(aodprimary) + if(ptprim < 0.01 || eprim < 0.01) return ; + + for (iParticle = 0; iParticle < nTracks; iParticle++) { - ptprim = aodprimary->Pt(); - phiprim = aodprimary->Phi(); - etaprim = aodprimary->Eta(); - eprim = aodprimary->E(); - - Bool_t lead = kFALSE; + AliAODMCParticle *part = (AliAODMCParticle*) mcparticles->At(iParticle); - if(ptprim < 0.01 || eprim < 0.01) return ; - - mcparticles= GetReader()->GetAODMCParticles(); - for (Int_t i = 0; i < nTracks; i++) + if (!part->IsPhysicalPrimary() ) continue; // same as part->GetStatus() !=1 + + if ( part->Charge() == 0 ) continue; + + fMomentum.SetPxPyPzE(part->Px(),part->Py(),part->Pz(),part->E()); + + //Particles in CTS acceptance, make sure to use the same selection as in the reader + Bool_t inCTS = GetReader()->GetFiducialCut()->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kCTS); + //printf("Accepted? %d; pt %2.2f, eta %2.2f, phi %2.2f\n",inCTS,fMomentum.Pt(),fMomentum.Eta(),fMomentum.Phi()*TMath::RadToDeg()); + if( !inCTS ) continue; + + // Remove conversions + Int_t indexmother = part->GetMother(); + if ( indexmother > -1 ) { - AliAODMCParticle *part = (AliAODMCParticle*) mcparticles->At(i); - - if (!part->IsPhysicalPrimary()) continue; - Int_t pdg = part->GetPdgCode(); - charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge(); - TLorentzVector momentum(part->Px(),part->Py(),part->Pz(),part->E()); - if(charge != 0) - { - if(part->Pt()> GetReader()->GetCTSPtMin()) - { - //Particles in CTS acceptance - Bool_t inCTS = GetFiducialCut()->IsInFiducialCut(momentum,"CTS"); - Int_t indexmother=part->GetMother(); - if(indexmother>-1) - { - Int_t mPdg = ((AliAODMCParticle*) mcparticles->At(indexmother)) ->GetPdgCode(); - if(TMath::Abs(pdg) == 11 && mPdg == 22) continue; - } - - if(inCTS) - { - if( label!=iParticle) // avoid trigger particle - { - if(!FillChargedMCCorrelationHistograms(part->Pt(),part->Phi(),part->Eta(),ptprim,phiprim,etaprim)) return; - else lead = kTRUE; - } - } // in acceptance - } // min pt cut - } //only charged particles - } //MC particle loop - if (lead) - { - fhMCPtLeading->Fill(ptprim); - fhMCPhiLeading->Fill(ptprim,phiprim); - fhMCEtaLeading->Fill(ptprim,etaprim); - } - } //when the leading particles could trace back to MC + Int_t pdg = part->GetPdgCode(); + Int_t mPdg = ((AliAODMCParticle*) mcparticles->At(indexmother)) ->GetPdgCode(); + if (TMath::Abs(pdg) == 11 && mPdg == 22) continue; + } + + if ( label == iParticle ) continue; // avoid trigger particle + + Float_t phi = part->Phi(); + if(phi < 0) phi+=TMath::TwoPi(); + + Bool_t lead = FillChargedMCCorrelationHistograms(part->Pt(),phi,part->Eta(),ptprim,phiprim,etaprim, histoIndex,lostDecayPair); + if(!lead) leadTrig = kFALSE; + //if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return; + + } //MC particle loop }// AOD MC + + // Trigger MC particle histograms + //if (!lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return; + + fhMCPtTrigger [histoIndex]->Fill(ptprim); + fhMCPhiTrigger[histoIndex]->Fill(ptprim,phiprim); + fhMCEtaTrigger[histoIndex]->Fill(ptprim,etaprim); + + if(histoIndex==2 && lostDecayPair && 7 >= fMCGenTypeMin && 7 <= fMCGenTypeMax ) + { + fhMCPtTrigger [7]->Fill(ptprim); + fhMCPhiTrigger[7]->Fill(ptprim,phiprim); + fhMCEtaTrigger[7]->Fill(ptprim,etaprim); + } + + if(!leadTrig && (fMakeAbsoluteLeading || fMakeNearSideLeading) ) + { + AliDebug(1,Form("Not leading primary trigger: pT %2.2f, phi %2.2f, eta %2.2f", + ptprim,phiprim*TMath::RadToDeg(),etaprim)); + + fhMCPtTriggerNotLeading [histoIndex]->Fill(ptprim); + fhMCPhiTriggerNotLeading[histoIndex]->Fill(ptprim,phiprim); + fhMCEtaTriggerNotLeading[histoIndex]->Fill(ptprim,etaprim); + + if(histoIndex==2 && lostDecayPair && 7 >= fMCGenTypeMin && 7 <= fMCGenTypeMax ) + { + fhMCPtTriggerNotLeading [7]->Fill(ptprim); + fhMCPhiTriggerNotLeading[7]->Fill(ptprim,phiprim); + fhMCEtaTriggerNotLeading[7]->Fill(ptprim,etaprim); + } + } } //_____________________________________________________________________ @@ -3109,10 +4239,9 @@ void AliAnaParticleHadronCorrelation::Print(const Option_t * opt) const printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ; AliAnaCaloTrackCorrBaseClass::Print(" "); - printf("Pt trigger > %3.2f\n", fMinTriggerPt) ; - printf("Pt associated hadron < %3.2f\n", fMaxAssocPt) ; - printf("Pt associated hadron > %3.2f\n", fMinAssocPt) ; - printf("Phi trigger particle-Hadron < %3.2f\n", fDeltaPhiMaxCut) ; + printf("Pt trigger > %2.2f; < %2.2f\n", GetMinPt() , GetMaxPt()) ; + printf("Pt associa > %2.2f; < %2.2f\n", fMinAssocPt, fMaxAssocPt) ; + printf("Phi trigger particle-Hadron < %3.2f\n", fDeltaPhiMaxCut) ; printf("Phi trigger particle-Hadron > %3.2f\n", fDeltaPhiMinCut) ; printf("Phi trigger particle-UeHadron < %3.2f\n", fUeDeltaPhiMaxCut) ; printf("Phi trigger particle-UeHadron > %3.2f\n", fUeDeltaPhiMinCut) ; @@ -3134,8 +4263,7 @@ void AliAnaParticleHadronCorrelation::SetNAssocPtBins(Int_t n) { // Set number of bins - fNAssocPtBins = n ; - + fNAssocPtBins = n ; if(n < 20 && n > 0) { @@ -3143,7 +4271,7 @@ void AliAnaParticleHadronCorrelation::SetNAssocPtBins(Int_t n) } else { - printf("n = larger than 19 or too small, set to 19 \n"); + AliWarning("n = larger than 19 or too small, set to 19"); fNAssocPtBins = 19; } } @@ -3159,7 +4287,7 @@ void AliAnaParticleHadronCorrelation::SetAssocPtBinLimit(Int_t ibin, Float_t pt) } else { - printf("AliAnaParticleHadronCorrelation::SetAssocPtBinLimit() - bin number too large %d > %d or small, nothing done\n", ibin, fNAssocPtBins) ; + AliWarning(Form("Bin number too large %d > %d or small, nothing done", ibin, fNAssocPtBins)) ; } }