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(),
fListMixTrackEvents(), fListMixCaloEvents(),
fUseMixStoredInReader(0), fFillNeutralEventMixPool(0),
fM02MaxCut(0), fM02MinCut(0),
- fFillPileUpHistograms(0),
- fSelectLeadingHadronAngle(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
fhPtTriggerInput(0), fhPtTriggerSSCut(0),
fhPtTriggerIsoCut(0), fhPtTriggerFidCut(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),
fhDeltaPhiUeLeftNeutral(0), fhXEUeLeftNeutral(0),
fhPtHbpXEUeLeftNeutral(0), fhZTUeLeftNeutral(0),
fhPtHbpZTUeLeftNeutral(0), fhPtPi0DecayRatio(0),
- fhDeltaPhiDecayCharged(0), fhXEDecayCharged(0), fhZTDecayCharged(0),
- fhDeltaPhiDecayNeutral(0), fhXEDecayNeutral(0), fhZTDecayNeutral(0),
- fhDeltaPhiDecayChargedAssocPtBin(0),
- fh2phiTriggerParticle(0x0),
- fhMCPtTrigger(0), fhMCPhiTrigger(0), fhMCEtaTrigger(0),
- fhMCPtTriggerNotLeading(0), fhMCPhiTriggerNotLeading(0), fhMCEtaTriggerNotLeading(0),
- fhMCEtaCharged(0), fhMCPhiCharged(0),
- fhMCDeltaEtaCharged(0), fhMCDeltaPhiCharged(0x0),
- fhMCDeltaPhiDeltaEtaCharged(0), fhMCDeltaPhiChargedPt(0),
- fhMCPtXECharged(0), fhMCPtXEUeCharged(0),
- fhMCPtXEUeLeftCharged(0),
- fhMCPtHbpXECharged(0), fhMCPtHbpXEUeCharged(0),
- fhMCPtHbpXEUeLeftCharged(0),
- fhMCUePart(0),
- fhMCPtZTCharged(0), fhMCPtZTUeCharged(0),
- fhMCPtZTUeLeftCharged(0),
- fhMCPtHbpZTCharged(0), fhMCPtHbpZTUeCharged(0),
- fhMCPtHbpZTUeLeftCharged(0),
- fhMCPtTrigPout(0), fhMCPtAssocDeltaPhi(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), fhNtracksMB(0), fhNclustersMB(0),
fhMixDeltaPhiCharged(0), fhMixDeltaPhiDeltaEtaCharged(0),
//Initialize parameters
InitParameters();
- for(Int_t i = 0; i < 7; i++)
+ 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 ;
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,
- Bool_t decay, Float_t hmpidSignal, Int_t outTOF,
+ Int_t decayTag, Float_t hmpidSignal, Int_t outTOF,
Int_t cen, Int_t mcTag)
{
// Fill angular correlation related histograms
// Pile up studies
- if(fFillPileUpHistograms)
+ if(IsPileUpAnalysisOn())
{
if (outTOF==1)
{
{
Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
fhDeltaPhiChargedMC[mcIndex]->Fill(ptTrig , deltaPhi);
- }
+ if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) )
+ {
+ // check index in GetMCTagIndexHistogram
+ if ( mcIndex == 2 ) fhDeltaPhiChargedMC[8]->Fill(ptTrig , deltaPhi); // pi0 decay
+ else if( mcIndex == 4 ) fhDeltaPhiChargedMC[9]->Fill(ptTrig , deltaPhi); // eta decay
+ }
+ }
- if(fDecayTrigger && decay) fhDeltaPhiDecayCharged ->Fill(ptTrig , deltaPhi);
+ if(fDecayTrigger && decayTag > 0)
+ {
+ for(Int_t ibit = 0; ibit<fNDecayBits; ibit++)
+ {
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit])) fhDeltaPhiDecayCharged[ibit]->Fill(ptTrig,deltaPhi);
+ }
+ }
Double_t dphiBrad = -100;
if(fFillBradHisto)
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)
}
//fill different multiplicity/centrality histogram
- if(fFillHighMultHistograms)
+ if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin())
{
fhDeltaPhiChargedMult[cen]->Fill(ptTrig,deltaPhi);
fhDeltaEtaChargedMult[cen]->Fill(ptTrig,deltaEta);
//___________________________________________________________________________________________________________________________________
Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(Float_t mcAssocPt, Float_t mcAssocPhi, Float_t mcAssocEta,
- Float_t mcTrigPt, Float_t mcTrigPhi, Float_t mcTrigEta)
+ Float_t mcTrigPt, Float_t mcTrigPhi, Float_t mcTrigEta,
+ Int_t histoIndex, Bool_t lostDecayPair)
{
// Fill MC histograms independently of AOD or ESD
if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) lead = kFALSE; // skip event
// Skip this event if near side associated particle pt larger than trigger
- if( fMakeNearSideLeading && mcAssocPt > mcTrigPt &&
- TMath::Abs(mcAssocPhi-mcTrigPhi)<TMath::PiOver2() ) lead = kFALSE; // skip event
+ if( mcAssocPhi < 0 ) mcAssocPhi+=TMath::TwoPi();
+
+ Float_t mcdeltaPhi= mcTrigPhi-mcAssocPhi;
+ if(mcdeltaPhi <= -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 ;
- 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 &&
+ mcdeltaPhi < 1e-6 &&
TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return lead ; // exclude but continue
- Float_t mcdeltaPhi= mcTrigPhi-mcAssocPhi;
- if(mcdeltaPhi <= -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
- if(mcdeltaPhi > 3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
-
Float_t mcxE =-mcAssocPt/mcTrigPt*TMath::Cos(mcdeltaPhi);// -(mcAssocPx*pxprim+mcAssocPy*pyprim)/(mcTrigPt*mcTrigPt);
Float_t mchbpXE =-100 ;
if(mcxE > 0 ) mchbpXE = TMath::Log(1./mcxE);
Double_t mcpout = mcAssocPt*TMath::Sin(mcdeltaPhi) ;
- if(GetDebug() > 0 )
- {
- AliInfo(Form("Charged hadron: track Pt %f, track Phi %f, phi trigger %f. Cuts: delta phi %2.2f < %2.2f < %2.2f \n",
- mcAssocPt,mcAssocPhi, mcTrigPhi,fDeltaPhiMinCut, mcdeltaPhi, fDeltaPhiMaxCut));
- }
+ 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) ;
}
+ if(lostDecayPair)
+ {
+ // check index in GetMCTagIndexHistogram
+ if(histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
+ {
+ // pi0 decay
+ fhMCEtaCharged [8]->Fill(mcAssocPt, mcAssocEta);
+ fhMCPhiCharged [8]->Fill(mcAssocPt, mcAssocPhi);
+ fhMCDeltaEtaCharged[8]->Fill(mcTrigPt , mcTrigEta-mcAssocEta);
+ fhMCDeltaPhiCharged[8]->Fill(mcTrigPt , mcdeltaPhi);
+ fhMCPtAssocDeltaPhi[8]->Fill(mcAssocPt, mcdeltaPhi);
+
+ fhMCDeltaPhiDeltaEtaCharged[8]->Fill(mcdeltaPhi,mcTrigEta-mcAssocEta);
+
+ //delta phi cut for correlation
+ if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) )
+ {
+ fhMCDeltaPhiChargedPt[8]->Fill(mcAssocPt,mcdeltaPhi);
+ fhMCPtXECharged [8]->Fill(mcTrigPt, mcxE);
+ fhMCPtHbpXECharged [8]->Fill(mcTrigPt, mchbpXE);
+ fhMCPtZTCharged [8]->Fill(mcTrigPt, mczT);
+ fhMCPtHbpZTCharged [8]->Fill(mcTrigPt, mchbpZT);
+ fhMCPtTrigPout [8]->Fill(mcTrigPt, mcpout) ;
+ }
+ } // pi0 decay lost pair
+ if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
+ {
+ // eta decay
+ fhMCEtaCharged [9]->Fill(mcAssocPt, mcAssocEta);
+ fhMCPhiCharged [9]->Fill(mcAssocPt, mcAssocPhi);
+ fhMCDeltaEtaCharged[9]->Fill(mcTrigPt , mcTrigEta-mcAssocEta);
+ fhMCDeltaPhiCharged[9]->Fill(mcTrigPt , mcdeltaPhi);
+ fhMCPtAssocDeltaPhi[9]->Fill(mcAssocPt, mcdeltaPhi);
+
+ fhMCDeltaPhiDeltaEtaCharged[9]->Fill(mcdeltaPhi,mcTrigEta-mcAssocEta);
+
+ //delta phi cut for correlation
+ if( (mcdeltaPhi > fDeltaPhiMinCut) && (mcdeltaPhi < fDeltaPhiMaxCut) )
+ {
+ fhMCDeltaPhiChargedPt[9]->Fill(mcAssocPt,mcdeltaPhi);
+ fhMCPtXECharged [9]->Fill(mcTrigPt, mcxE);
+ fhMCPtHbpXECharged [9]->Fill(mcTrigPt, mchbpXE);
+ fhMCPtZTCharged [9]->Fill(mcTrigPt, mczT);
+ fhMCPtHbpZTCharged [9]->Fill(mcTrigPt, mchbpZT);
+ fhMCPtTrigPout [9]->Fill(mcTrigPt, mcpout) ;
+ }
+ } // eta decay lost pair
+ }
// Underlying event
// Right
Double_t mcUezT = mcAssocPt/mcTrigPt;
if(mcUexE < 0.)
- printf("FillChargedMCCorrelationHistograms(): Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- mcUexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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->Fill(mcTrigPt,mcUexE);
- if(mcUexE > 0) fhMCPtHbpXEUeCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
+ fhMCPtXEUeCharged[histoIndex]->Fill(mcTrigPt,mcUexE);
+ if(mcUexE > 0) fhMCPtHbpXEUeCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUexE));
+
+ fhMCPtZTUeCharged[histoIndex]->Fill(mcTrigPt,mcUezT);
+ if(mcUezT > 0) fhMCPtHbpZTUeCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUezT));
- fhMCPtZTUeCharged->Fill(mcTrigPt,mcUezT);
- if(mcUezT > 0) fhMCPtHbpZTUeCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
+ fhMCUePart[histoIndex]->Fill(mcTrigPt);
- fhMCUePart->Fill(mcTrigPt);
+ if(lostDecayPair)
+ {
+ // check index in GetMCTagIndexHistogram
+ if(histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
+ {
+ // pi0 decay
+ fhMCPtXEUeCharged[8]->Fill(mcTrigPt,mcUexE);
+ if(mcUexE > 0) fhMCPtHbpXEUeCharged[8]->Fill(mcTrigPt,TMath::Log(1/mcUexE));
+
+ fhMCPtZTUeCharged[8]->Fill(mcTrigPt,mcUezT);
+ if(mcUezT > 0) fhMCPtHbpZTUeCharged[8]->Fill(mcTrigPt,TMath::Log(1/mcUezT));
+
+ fhMCUePart[8]->Fill(mcTrigPt);
+ }
+ else if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
+ {
+ // eta decay
+ fhMCPtXEUeCharged[9]->Fill(mcTrigPt,mcUexE);
+ if(mcUexE > 0) fhMCPtHbpXEUeCharged[9]->Fill(mcTrigPt,TMath::Log(1/mcUexE));
+
+ fhMCPtZTUeCharged[9]->Fill(mcTrigPt,mcUezT);
+ if(mcUezT > 0) fhMCPtHbpZTUeCharged[9]->Fill(mcTrigPt,TMath::Log(1/mcUezT));
+
+ fhMCUePart[9]->Fill(mcTrigPt);
+ }
+ }
}
if(fMakeSeveralUE)
Double_t mcUezT = mcAssocPt/mcTrigPt;
if(mcUexE < 0.)
- printf("FillChargedMCCorrelationHistograms(): Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- mcUexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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));
- fhMCPtXEUeLeftCharged->Fill(mcTrigPt,mcUexE);
- if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
+ fhMCPtZTUeLeftCharged[histoIndex]->Fill(mcTrigPt,mcUezT);
+ if(mcUezT > 0) fhMCPtHbpZTUeLeftCharged[histoIndex]->Fill(mcTrigPt,TMath::Log(1/mcUezT));
- fhMCPtZTUeLeftCharged->Fill(mcTrigPt,mcUezT);
- if(mcUexE > 0) fhMCPtHbpZTUeLeftCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
+ if(lostDecayPair)
+ {
+ // check index in GetMCTagIndexHistogram
+ if(histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
+ {
+ // pi0 decay
+ fhMCPtXEUeLeftCharged[8]->Fill(mcTrigPt,mcUexE);
+ if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged[8]->Fill(mcTrigPt,TMath::Log(1/mcUexE));
+
+ fhMCPtZTUeLeftCharged[8]->Fill(mcTrigPt,mcUezT);
+ if(mcUezT > 0) fhMCPtHbpZTUeLeftCharged[8]->Fill(mcTrigPt,TMath::Log(1/mcUezT));
+ }
+ else if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
+ {
+ // eta decay
+ fhMCPtXEUeLeftCharged[9]->Fill(mcTrigPt,mcUexE);
+ if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged[9]->Fill(mcTrigPt,TMath::Log(1/mcUexE));
+
+ fhMCPtZTUeLeftCharged[9]->Fill(mcTrigPt,mcUezT);
+ if(mcUezT > 0) fhMCPtHbpZTUeLeftCharged[9]->Fill(mcTrigPt,TMath::Log(1/mcUezT));
+ }
+ }
}
}
void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(Float_t ptTrig, Float_t ptAssoc,
Float_t deltaPhi,
Int_t cen, Int_t charge,
- Int_t bin, Bool_t decay,
+ Int_t bin, Int_t decayTag,
Int_t outTOF, Int_t mcTag)
{
// Fill mostly momentum imbalance related histograms
- Float_t zT = ptAssoc/ptTrig ;
- Float_t hbpZT = -100;
- if(zT > 0 ) hbpZT = TMath::Log(1./zT);
- else hbpZT =-100;
-
- Float_t xE =-ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
- Float_t hbpXE = -100;
+ 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.)
- printf("FillChargedMomentumImbalanceHistograms(): Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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);
- else hbpXE =-100;
-
- Float_t pout = ptAssoc*TMath::Sin(deltaPhi) ;
+ if(zT > 0 ) hbpZT = TMath::Log(1./zT);
fhXECharged ->Fill(ptTrig , xE);
fhPtHbpXECharged ->Fill(ptTrig , hbpXE);
fhPtHbpXECharged_Cone2 ->Fill(ptTrig , hbpXE);
}
+ // MC
+ if(IsDataMC())
+ {
+ Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
+ fhXEChargedMC[mcIndex]->Fill(ptTrig , xE);
+ if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCDecayPairLost) )
+ {
+ // check index in GetMCTagIndexHistogram
+ if ( mcIndex == 2 ) fhXEChargedMC[8]->Fill(ptTrig , xE); // pi0 decay
+ else if ( mcIndex == 4 ) fhXEChargedMC[9]->Fill(ptTrig , xE); // eta decay
+ }
+ }
+
// Pile up studies
- if(fFillPileUpHistograms)
+ if(IsPileUpAnalysisOn())
{
if (outTOF==1)
{
if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEChargedPileUp[6]->Fill(ptTrig,xE); fhZTChargedPileUp[6]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[6]->Fill(ptTrig,ptAssoc); }
}
- if(IsDataMC())
+ if(fDecayTrigger && decayTag > 0)
{
- Int_t mcIndex = GetMCTagHistogramIndex(mcTag);
- fhXEChargedMC[mcIndex]->Fill(ptTrig , xE);
- }
-
- if(fDecayTrigger && decay)
- {
- fhXEDecayCharged->Fill(ptTrig,xE);
- fhZTDecayCharged->Fill(ptTrig,zT);
- } // photon decay pi0/eta trigger
+ for(Int_t ibit = 0; ibit<fNDecayBits; ibit++)
+ {
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
+ {
+ fhXEDecayCharged[ibit]->Fill(ptTrig,xE);
+ fhZTDecayCharged[ibit]->Fill(ptTrig,zT);
+ }
+ }
+ } // photon decay pi0/eta trigger
if(bin >= 0 && fFillMomImbalancePtAssocBinsHisto)//away side
{
}
//fill different multiplicity/centrality histogram
- if(fFillHighMultHistograms)
+ if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin())
{
fhXEMult[cen]->Fill(ptTrig,xE);
fhZTMult[cen]->Fill(ptTrig,zT);
Double_t uezT = ptAssoc/ptTrig;
if(uexE < 0.)
- printf("FillChargedUnderlyingEventHistograms(): Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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));
// Pile up studies
- if(fFillPileUpHistograms)
+ if(IsPileUpAnalysisOn())
{
if (outTOF==1)
{
}
//fill different multiplicity/centrality histogram
- if(fFillHighMultHistograms)
+ if(IsHighMultiplicityAnalysisOn() && cen >= 0 && cen < GetNCentrBin())
{
fhXEUeMult[cen]->Fill(ptTrig,uexE);
fhZTUeMult[cen]->Fill(ptTrig,uezT);
Double_t uezT = ptAssoc/ptTrig;
if(uexE < 0.)
- printf("FillChargedUnderlyingEventSidesHistograms(): Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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);
}
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
if(uexE < 0.)
- printf("FillChargedUnderlyingEventSidesHistograms(): Careful!!, negative xE %2.2f for left-down UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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);
}
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
if(uexE < 0.)
- printf("FillChargedUnderlyingEventSidesHistograms(): Careful!!, negative xE %2.2f for left-up UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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);
}
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
if(uexE < 0.)
- printf("FillChargedUnderlyingEventSidesHistograms(): Careful!!, negative xE %2.2f for right-up UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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);
}
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
if(uexE < 0.)
- printf("FillChargedUnderlyingEventSidesHistograms(): Careful!!, negative xE %2.2f for right-down UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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(Float_t ptAssoc, Float_t phiAssoc,
- TLorentzVector mom1, TLorentzVector mom2,
- 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 > 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();
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
{
- fhDeltaPhiDecayNeutral->Fill(ptDecay1, deltaPhiDecay1);
- fhDeltaPhiDecayNeutral->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) )
{
- fhZTDecayNeutral->Fill(ptDecay1,zTDecay1);
- fhXEDecayNeutral->Fill(ptDecay1,xEDecay1);
+ fhZTPi0DecayNeutral->Fill(ptDecay1,zTDecay1);
+ fhXEPi0DecayNeutral->Fill(ptDecay1,xEDecay1);
}
if( (deltaPhiDecay2 > fDeltaPhiMinCut) && ( deltaPhiDecay2 < fDeltaPhiMaxCut) )
{
- fhZTDecayNeutral->Fill(ptDecay2,zTDecay2);
- fhXEDecayNeutral->Fill(ptDecay2,xEDecay2);
+ fhZTPi0DecayNeutral->Fill(ptDecay2,zTDecay2);
+ fhXEPi0DecayNeutral->Fill(ptDecay2,xEDecay2);
}
}
}
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);
}
TList * poolCalo = fListMixCaloEvents[eventBin];
- TLorentzVector mom;
-
for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
{
AliVCluster * calo = (AliVCluster *) (pl->At(ipr)) ;
//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);
}
// 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 phiTrig = particle->Phi();
Float_t etaTrig = particle->Eta();
Float_t ptTrig = particle->Pt();
- Float_t ptLeadHad = -100 ;
+ 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 ;
- TVector3 p3;
-
+ Int_t nTrack = 0;
+
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]);
+ fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
- Float_t pt = p3.Pt();
- Float_t phi = p3.Phi() ;
+ Float_t pt = fTrackVector.Pt();
+ Float_t phi = fTrackVector.Phi() ;
if(phi < 0 ) phi+= TMath::TwoPi();
- if(pt > ptLeadHad && TMath::Abs(phi-phiTrig) > TMath::PiOver2()) // in opposite hemisphere
+ 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;
- etaLeadHad = p3.Eta();
+ dphiLeadHad= deltaPhi;
+ etaLeadHad = fTrackVector.Eta();
+ nTrack++;
}
}// track loop
- fhPtLeadingOppositeHadron ->Fill(ptTrig, ptLeadHad);
- fhPtDiffPhiLeadingOppositeHadron->Fill(ptTrig,phiLeadHad-phiTrig);
- fhPtDiffEtaLeadingOppositeHadron->Fill(ptTrig,etaLeadHad-etaTrig);
-
- if(GetDebug() > 1 )
+ if(fFillLeadHadOppositeHisto)
{
- printf("AliAnaParticleHadronCorrelation::FindLeadingOppositeHadronInWindow() pT %2.2f, phi %2.2f, eta %2.2f\n",
- ptLeadHad,phiLeadHad*TMath::RadToDeg(),etaLeadHad);
-
- printf("\t pT trig %2.2f, Dphi (trigger-hadron) %2.2f, Deta (trigger-hadron) %2.2f\n",
- ptTrig, (phiLeadHad-phiTrig)*TMath::RadToDeg(), etaLeadHad-etaTrig);
- printf("\t cuts pT: min %2.2f, max %2.2f; DPhi: min %2.2f, max %2.2f\n",fMinLeadHadPt,fMaxLeadHadPt,fMinLeadHadPhi*TMath::RadToDeg(),fMaxLeadHadPhi*TMath::RadToDeg());
+ if(nTrack == 0)
+ {
+ fhPtNoLeadingOppositeHadron ->Fill(ptTrig);
+ fhEtaPhiNoLeadingOppositeHadron->Fill(etaTrig,phiTrig);
+ }
+ else
+ {
+ fhPtLeadingOppositeHadron ->Fill(ptTrig, ptLeadHad);
+ fhPtDiffPhiLeadingOppositeHadron->Fill(ptTrig,dphiLeadHad);
+ fhPtDiffEtaLeadingOppositeHadron->Fill(ptTrig, etaLeadHad-etaTrig);
+ }
}
- if( ptLeadHad < fMinLeadHadPt ||
- ptLeadHad > fMaxLeadHadPt ) return kFALSE;
+
+ 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( TMath::Abs(phiLeadHad-phiTrig) < fMinLeadHadPhi ||
- TMath::Abs(phiLeadHad-phiTrig) > fMaxLeadHadPhi ) return kFALSE;
+ if( dphiLeadHad < fMinLeadHadPhi || dphiLeadHad > fMaxLeadHadPhi ) return kFALSE;
//printf("Accept leading hadron phi \n");
+
return kTRUE ;
}
Int_t nMixBins = GetNCentrBin()*GetNZvertBin()*GetNRPBin();
- TString nameMC[] = {"Photon","Pi0","Pi0Decay","EtaDecay","OtherDecay","Electron","Hadron"};
+ TString nameMC[] = {"Photon","Pi0","Pi0Decay","Eta","EtaDecay","OtherDecay","Electron","Hadron","Pi0DecayLostPair","EtaDecayLostPair"};
TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
// For vz dependent histograms, if option ON
if(IsDataMC())
{
- for(Int_t i=0; i < 7; i++)
+ for(Int_t i=0; i < fgkNmcTypes; i++)
{
fhPtTriggerMC[i] = new TH1F(Form("hPtTrigger_MC%s",nameMC[i].Data()),
Form("#it{p}_{T} distribution of trigger particles, trigger origin is %s",nameMC[i].Data()),
}
}
+ 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())
+ {
+ 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());
fhEtaTrigger->SetYTitle("#eta ");
outputContainer->Add(fhEtaTrigger);
- if(fFillHighMultHistograms)
+ 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})");
}
// Leading hadron in oposite side
- if(fSelectLeadingHadronAngle)
+ 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);
+
fhPtDiffPhiLeadingOppositeHadron = new TH2F("hPtTriggerDiffPhiTriggerLeadingOppositeHadron","#phi_{trigger}-#phi_{leading opposite hadron} vs #it{p}_{T}^{trig}",
- nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
+ 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);
if(IsDataMC())
{
- for(Int_t i=0; i < 7; i++)
+ for(Int_t i=0; i < fgkNmcTypes; i++)
{
fhDeltaPhiChargedMC[i] = new TH2F(Form("hDeltaPhiCharged_MC%s",nameMC[i].Data()),
outputContainer->Add(fhPtHbpZTUeLeftCharged) ;
}
- if(fFillPileUpHistograms)
+ if(IsPileUpAnalysisOn())
{
fhDeltaPhiChargedOtherBC = new TH2F
("hDeltaPhiChargedOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC!=0",
}
}
- if(fFillHighMultHistograms)
+ if(IsHighMultiplicityAnalysisOn())
{
Int_t nMultiBins = GetNCentrBin();
fhDeltaPhiChargedMult = new TH2F*[nMultiBins] ;
if(fFillBradHisto)
fhDeltaPhiBradAssocPtBin = new TH2F*[fNAssocPtBins*nz];
- if(fPi0Trigger || fDecayTrigger)
- {
- fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz];
- fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
- fhDeltaPhiDecayChargedAssocPtBin = 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)
{
outputContainer->Add(fhDeltaPhiAssocPtBinDEta0[bin]) ;
}
- if(fPi0Trigger || fDecayTrigger)
+ if(fDecayTrigger)
{
- fhDeltaPhiDecayChargedAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtDecayChargedAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
- Form("#Delta #phi vs #it{p}_{T trigger} tagged as decay for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
+ 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("#it{p}_{T trigger} (GeV/#it{c})");
fhDeltaPhiDecayChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
}
}
- if(fPi0Trigger || fDecayTrigger)
+
+ if(fPi0Trigger)
{
- 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) ;
- }
-
- fhDeltaPhiDecayCharged = new TH2F
- ("hDeltaPhiDecayCharged","#phi_{Decay} - #phi_{h^{#pm}} vs #it{p}_{T Decay}",
+ 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);
- fhDeltaPhiDecayCharged->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiDecayCharged->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
+ fhDeltaPhiPi0DecayCharged->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiPi0DecayCharged->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
- fhXEDecayCharged =
- new TH2F("hXEDecayCharged","#it{x}_{#it{E}} Decay",
+ fhXEPi0DecayCharged =
+ new TH2F("hXEPi0DecayCharged","#it{x}_{#it{E}} Decay",
nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
- fhXEDecayCharged->SetYTitle("#it{x}_{#it{E}}");
- fhXEDecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
+ fhXEPi0DecayCharged->SetYTitle("#it{x}_{#it{E}}");
+ fhXEPi0DecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
- fhZTDecayCharged =
- new TH2F("hZTDecayCharged","#it{z}_{trigger h^{#pm}} = #it{p}_{T h^{#pm}} / #it{p}_{T Decay}",
+ fhZTPi0DecayCharged =
+ new TH2F("hZTPi0DecayCharged","#it{z}_{trigger h^{#pm}} = #it{p}_{T h^{#pm}} / #it{p}_{T Decay}",
nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
- fhZTDecayCharged->SetYTitle("#it{z}_{decay h^{#pm}}");
- fhZTDecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
+ fhZTPi0DecayCharged->SetYTitle("#it{z}_{decay h^{#pm}}");
+ fhZTPi0DecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
- outputContainer->Add(fhDeltaPhiDecayCharged) ;
- outputContainer->Add(fhXEDecayCharged) ;
- outputContainer->Add(fhZTDecayCharged) ;
+ 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
outputContainer->Add(fhPtHbpZTUeLeftNeutral) ;
}
- if(fPi0Trigger || fDecayTrigger)
+ if(fPi0Trigger)
{
- fhDeltaPhiDecayNeutral = new TH2F
- ("hDeltaPhiDecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs #it{p}_{T Decay}",
+ fhDeltaPhiPi0DecayNeutral = new TH2F
+ ("hDeltaPhiPi0DecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs #it{p}_{T Decay}",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiDecayNeutral->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiDecayNeutral->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
+ fhDeltaPhiPi0DecayNeutral->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiPi0DecayNeutral->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
- fhXEDecayNeutral =
- new TH2F("hXEDecayNeutral","#it{x}_{#it{E}} for decay trigger",
+ fhXEPi0DecayNeutral =
+ new TH2F("hXEPi0DecayNeutral","#it{x}_{#it{E}} for decay trigger",
nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
- fhXEDecayNeutral->SetYTitle("#it{x}_{#it{E}}");
- fhXEDecayNeutral->SetXTitle("#it{p}_{T decay}");
+ fhXEPi0DecayNeutral->SetYTitle("#it{x}_{#it{E}}");
+ fhXEPi0DecayNeutral->SetXTitle("#it{p}_{T decay}");
- fhZTDecayNeutral =
- new TH2F("hZTDecayNeutral","#it{z}_{trigger h^{0}} = #it{p}_{T h^{0}} / #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);
- fhZTDecayNeutral->SetYTitle("#it{z}_{h^{0}}");
- fhZTDecayNeutral->SetXTitle("#it{p}_{T decay}");
-
- outputContainer->Add(fhDeltaPhiDecayNeutral) ;
- outputContainer->Add(fhXEDecayNeutral) ;
- outputContainer->Add(fhZTDecayNeutral) ;
+ 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())
{
- fh2phiTriggerParticle = new TH2F("h2PhiTriggerParticle","#phi resolution for trigger particles",nptbins,ptmin,ptmax,100,-1,1);
- fh2phiTriggerParticle->GetXaxis()->SetTitle("#it{p}_{T gen Trigger} (GeV/#it{c})");
- fh2phiTriggerParticle->GetYaxis()->SetTitle("(#phi_{rec}-#phi_{gen})/#phi_{gen}");
-
- fhMCPtTrigger = new TH1F ("hMCPtTrigger","MC : trigger #it{p}_{T}", nptbins,ptmin,ptmax);
- fhMCPtTrigger->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
-
- fhMCPhiTrigger = new TH2F ("hMCPhiTrigger","MC : trigger #phi",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
- fhMCPhiTrigger->SetYTitle("#phi (rad)");
- fhMCPhiTrigger->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
-
- fhMCEtaTrigger = new TH2F ("hMCEtaTrigger","MC : trigger #eta",nptbins,ptmin,ptmax, netabins,etamin,etamax);
- fhMCEtaTrigger->SetYTitle("#eta");
- fhMCEtaTrigger->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
-
- if(fMakeAbsoluteLeading || fMakeNearSideLeading)
+ for(Int_t i= fMCGenTypeMin; i <= fMCGenTypeMax; i++)
{
- fhMCPtTriggerNotLeading = new TH1F ("hMCPtTriggerNotLeading","MC : trigger #it{p}_{T}, when not leading of primaries",
- nptbins,ptmin,ptmax);
- fhMCPtTriggerNotLeading->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
+ 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})");
- fhMCPhiTriggerNotLeading = new TH2F ("hMCPhiTriggerNotLeading","MC : trigger #phi, when not leading of primaries",
- nptbins,ptmin,ptmax, nphibins,phimin,phimax);
- fhMCPhiTriggerNotLeading->SetYTitle("#phi (rad)");
- fhMCPhiTriggerNotLeading->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})");
- fhMCEtaTriggerNotLeading = new TH2F ("hMCEtaTriggerNotLeading","MC : triogger #eta, when not leading of primaries",
- nptbins,ptmin,ptmax, netabins,etamin,etamax);
- fhMCEtaTriggerNotLeading->SetYTitle("#eta ");
- fhMCEtaTriggerNotLeading->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
- }
-
- fhMCEtaCharged = new TH2F
- ("hMCEtaCharged","MC #eta_{h^{#pm}} vs #it{p}_{T #pm}",
- nptbins,ptmin,ptmax,100,-1.,1.);
- fhMCEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
- fhMCEtaCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
-
- fhMCPhiCharged = new TH2F
- ("hMCPhiCharged","#MC phi_{h^{#pm}} vs #it{p}_{T #pm}",
- nptbins,ptmin,ptmax,180,0,TMath::TwoPi());
- fhMCPhiCharged->SetYTitle("MC #phi_{h^{#pm}} (rad)");
- fhMCPhiCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
-
- fhMCDeltaPhiDeltaEtaCharged = new TH2F
- ("hMCDeltaPhiDeltaEtaCharged","#MC phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
- ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
- fhMCDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
- fhMCDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
-
- fhMCDeltaEtaCharged = new TH2F
- ("hMCDeltaEtaCharged","MC #eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger} and #it{p}_{T assoc}",
- nptbins,ptmin,ptmax,ndeltaetabins ,deltaetamin,deltaetamax);
- fhMCDeltaEtaCharged->SetYTitle("#Delta #eta");
- fhMCDeltaEtaCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCDeltaPhiCharged = new TH2F
- ("hMCDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}",
- nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
- fhMCDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
- fhMCDeltaPhiCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCDeltaPhiChargedPt = new TH2F
- ("hMCDeltaPhiChargedPt","MC #phi_{trigger} - #phi_{#h^{#pm}} vs #it{p}_{T h^{#pm}}",
- nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
- fhMCDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
- fhMCDeltaPhiChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
-
- fhMCPtXECharged =
- new TH2F("hMCPtXECharged","#it{x}_{#it{E}} with charged hadrons",
- nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
- fhMCPtXECharged->SetYTitle("#it{x}_{#it{E}}");
- fhMCPtXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtHbpXECharged =
- new TH2F("hMCHbpXECharged","MC #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",
- nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
- fhMCPtHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhMCPtHbpXECharged->SetXTitle("#it{p}_{T trigger}");
-
- fhMCPtZTCharged =
- new TH2F("hMCPtZTCharged","#it{z}_{T} with charged hadrons",
- nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
- fhMCPtZTCharged->SetYTitle("#it{z}_{T}");
- fhMCPtZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtHbpZTCharged =
- new TH2F("hMCHbpZTCharged","MC #xi = ln(1/#it{z}_{T}) with charged hadrons",
- nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
- fhMCPtHbpZTCharged->SetYTitle("ln(1/#it{z}_{T})");
- fhMCPtHbpZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtTrigPout =
- new TH2F("hMCPtTrigPout","AOD MC Pout with triggers",
- nptbins,ptmin,ptmax,nptbins,-1.*ptmax/2.,ptmax/2.);
- fhMCPtTrigPout->SetYTitle("#it{p}_{out} (GeV/#it{c})");
- fhMCPtTrigPout->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtAssocDeltaPhi =
- new TH2F("hMCPtAssocDeltaPhi","AOD MC delta phi with associated charged hadrons",
- nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
- fhMCPtAssocDeltaPhi->SetYTitle("#Delta #phi (rad)");
- fhMCPtAssocDeltaPhi->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- outputContainer->Add(fh2phiTriggerParticle);
- outputContainer->Add(fhMCPtTrigger);
- outputContainer->Add(fhMCPhiTrigger);
- outputContainer->Add(fhMCEtaTrigger);
-
- if(fMakeAbsoluteLeading || fMakeNearSideLeading)
- {
- outputContainer->Add(fhMCPtTriggerNotLeading);
- outputContainer->Add(fhMCPhiTriggerNotLeading);
- outputContainer->Add(fhMCEtaTriggerNotLeading);
- }
-
- outputContainer->Add(fhMCDeltaPhiDeltaEtaCharged);
- outputContainer->Add(fhMCPhiCharged) ;
- outputContainer->Add(fhMCEtaCharged) ;
- outputContainer->Add(fhMCDeltaEtaCharged) ;
- outputContainer->Add(fhMCDeltaPhiCharged) ;
-
- outputContainer->Add(fhMCDeltaPhiChargedPt) ;
- outputContainer->Add(fhMCPtXECharged) ;
- outputContainer->Add(fhMCPtZTCharged) ;
- outputContainer->Add(fhMCPtHbpXECharged) ;
- outputContainer->Add(fhMCPtHbpZTCharged) ;
- outputContainer->Add(fhMCPtTrigPout) ;
- outputContainer->Add(fhMCPtAssocDeltaPhi) ;
-
- // Underlying event
-
- fhMCUePart =
- new TH1F("hMCUePart","MC UE particles distribution vs pt trig",
- nptbins,ptmin,ptmax);
- fhMCUePart->SetYTitle("#it{dN}^{ch}");
- fhMCUePart->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtXEUeCharged =
- new TH2F(Form("hMCPtXEUeCharged%s",right.Data()),"#it{x}_{#it{E}} with charged hadrons, Underlying Event",
- nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
- fhMCPtXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
- fhMCPtXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtHbpXEUeCharged =
- new TH2F(Form("hMCPtHbpXEUeCharged%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, Underlying Event",
- nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
- fhMCPtHbpXEUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhMCPtHbpXEUeCharged->SetXTitle("#it{p}_{T trigger} (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})");
+
+ 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})");
- fhMCPtZTUeCharged =
- new TH2F(Form("hMCPtZTUeCharged%s",right.Data()),"#it{z}_{T} with charged hadrons, Underlying Event",
- nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
- fhMCPtZTUeCharged->SetYTitle("#it{z}_{T}");
- fhMCPtZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtHbpZTUeCharged =
- new TH2F(Form("hMCPtHbpZTUeCharged%s",right.Data()),"#xi = ln(1/#it{z}_{T}) with charged hadrons, Underlying Event",
- nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
- fhMCPtHbpZTUeCharged->SetYTitle("ln(1/#it{z}_{T})");
- fhMCPtHbpZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- outputContainer->Add(fhMCUePart);
- outputContainer->Add(fhMCPtXEUeCharged) ;
- outputContainer->Add(fhMCPtZTUeCharged) ;
- outputContainer->Add(fhMCPtHbpZTUeCharged);
- outputContainer->Add(fhMCPtHbpXEUeCharged);
+ 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]) ;
- if(fMakeSeveralUE)
- {
- fhMCPtXEUeLeftCharged =
- new TH2F("hMCPtXEUeChargedLeft","#it{x}_{#it{E}} with charged hadrons, with UE left side range of trigger particles",
- nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
- fhMCPtXEUeLeftCharged->SetYTitle("#it{x}_{#it{E}}");
- fhMCPtXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ // 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})");
- fhMCPtHbpXEUeLeftCharged =
- new TH2F("hMCPtHbpXEUeChargedLeft","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, with UE left side range of trigger particles",
+ 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);
- fhMCPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhMCPtHbpXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhMCPtHbpXEUeCharged[i]->SetYTitle("ln(1/#it{x}_{#it{E}})");
+ fhMCPtHbpXEUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhMCPtZTUeLeftCharged =
- new TH2F("hMCPtZTUeChargedLeft","#it{z}_{T} with charged hadrons, with UE left side range of trigger particles",
+ 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);
- fhMCPtZTUeLeftCharged->SetYTitle("#it{z}_{T}");
- fhMCPtZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhMCPtZTUeCharged[i]->SetYTitle("#it{z}_{T}");
+ fhMCPtZTUeCharged[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhMCPtHbpZTUeLeftCharged =
- new TH2F("hMCPtHbpZTUeChargedLeft","#xi = ln(1/#it{z}_{T}) with charged hadrons, with UE left side range of trigger particles",
+ 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);
- fhMCPtHbpZTUeLeftCharged->SetYTitle("ln(1/#it{z}_{T})");
- fhMCPtHbpZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- outputContainer->Add(fhMCPtXEUeLeftCharged) ;
- outputContainer->Add(fhMCPtZTUeLeftCharged) ;
- outputContainer->Add(fhMCPtHbpXEUeLeftCharged);
- outputContainer->Add(fhMCPtHbpZTUeLeftCharged) ;
+ 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
}
-//_________________________________________________________________________________________________
-Bool_t AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum(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,
// get their decay children
- Int_t indexPhoton1 = trigger->GetCaloLabel(0);
- Int_t indexPhoton2 = trigger->GetCaloLabel(1);
-
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() ;
+ 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(photon->GetID()==indexPhoton2) photon->GetMomentum(mom1,GetVertex(0)) ;
+ 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
// 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::kMCEtaDecay)) return 3;
- else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay)) return 4;
- else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)) return 5;
- else return 6;
+ GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation) ||
+ GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCISR) ) 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) ) return 3;
+ else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay) ) return 4;
+ else if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) ) return 5; // other decays
+ else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) ) return 6;
+ else return 7;
}
//Do some checks
if(!GetReader()->IsCTSSwitchedOn())
- AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!\n");
+ AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!");
}
//____________________________________________________
fM02MaxCut = -1 ;
fSelectLeadingHadronAngle = kFALSE;
+ fFillLeadHadOppositeHisto = kFALSE;
fMinLeadHadPhi = 150*TMath::DegToRad();
fMaxLeadHadPhi = 210*TMath::DegToRad();
fMinLeadHadPt = 1;
fMaxLeadHadPt = 100;
+ fMCGenTypeMin = 0;
+ fMCGenTypeMax = 10;
+
+ fNDecayBits = 1;
+ fDecayBits[0] = AliNeutralMesonSelection::kPi0;
+ fDecayBits[1] = AliNeutralMesonSelection::kEta;
+ fDecayBits[2] = AliNeutralMesonSelection::kPi0Side;
+ fDecayBits[3] = AliNeutralMesonSelection::kEtaSide;
}
//_________________________________________________________________________
// Compare if it is the leading of all tracks
- TVector3 p3;
for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
{
AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
if(track->GetID() == pLeading->GetTrackLabel(0) || track->GetID() == pLeading->GetTrackLabel(1) ||
track->GetID() == pLeading->GetTrackLabel(2) || track->GetID() == pLeading->GetTrackLabel(3) ) continue ;
- Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
- p3.SetXYZ(mom[0],mom[1],mom[2]);
- Float_t pt = p3.Pt();
- Float_t phi = p3.Phi() ;
+ fTrackVector.SetXYZ(track->Px(),track->Py(),track->Pz());
+ Float_t pt = fTrackVector.Pt();
+ Float_t phi = fTrackVector.Phi() ;
if(phi < 0) phi+=TMath::TwoPi();
//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;
+ 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
{
// Select the calorimeter cluster list
TObjArray * nePl = 0x0;
- if (pLeading->GetDetector() == "PHOS" )
+ if (pLeading->GetDetectorTag() == kPHOS )
nePl = GetPHOSClusters();
else
nePl = GetEMCALClusters();
if(!nePl) return kTRUE; // Do the selection just with the tracks if no calorimeter is available.
- TLorentzVector lv;
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(lv,GetVertex(0));
+ cluster->GetMomentum(fMomentum,GetVertex(0));
- Float_t pt = lv.Pt();
- Float_t phi = lv.Phi() ;
+ 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.
// not really needed for calorimeter, unless DCal is included
if (fMakeNearSideLeading)
{
- if(pt > ptTrig && TMath::Abs(phi-phiTrig) < TMath::PiOver2()) return kFALSE ;
+ 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
fLeadingTriggerIndex = index ;
pLeading->SetLeadingParticle(kTRUE);
- if( GetDebug() > 1 ) printf("\t particle AOD with index %d is leading with pT %2.2f\n", fLeadingTriggerIndex, pLeading->Pt());
+ AliDebug(1,Form("\t particle AOD with index %d is leading with pT %2.2f", fLeadingTriggerIndex, pLeading->Pt()));
return kTRUE;
if(!GetInputAODBranch())
{
- AliFatal(Form("No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data()));
+ AliFatal(Form("No input particles in AOD with name branch < %s >, STOP",GetInputAODName().Data()));
return ; // coverity
}
Int_t naod = GetInputAODBranch()->GetEntriesFast();
if( naod == 0 )
{
- if(GetDebug() > 1)
- printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillAOD() - No particle AOD found! \n");
-
+ AliWarning("No particle AOD found!");
return ; // no trigger particles found.
}
- if(GetDebug() > 1)
- {
- printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Begin hadron correlation analysis, fill histograms \n");
- printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - In particle branch aod entries %d\n", naod);
- printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - In CTS aod entries %d\n", GetCTSTracks()->GetEntriesFast());
- }
+ 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()));
//------------------------------------------------------
// Find leading trigger if analysis request only leading,
{
Bool_t leading = IsTriggerTheEventLeadingParticle();
- if(GetDebug() > 1)
- printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - AOD Leading trigger? %d, with index %d\n",leading,fLeadingTriggerIndex);
+ AliDebug(1,Form("AOD Leading trigger? %d, with index %d",leading,fLeadingTriggerIndex));
if(!leading)
{
- if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - Leading was requested and not found\n");
+ AliDebug(1,"Leading was requested and not found");
return ;
}
else
Float_t cen = GetEventCentrality();
Float_t ep = GetEventPlaneAngle();
- if(fFillHighMultHistograms) fhTriggerEventPlaneCentrality->Fill(cen,ep);
+ if(IsHighMultiplicityAnalysisOn()) fhTriggerEventPlaneCentrality->Fill(cen,ep);
Int_t mixEventBin = GetEventMixBin();
Int_t vzbin = GetEventVzBin();
// 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.
- if( GetDebug() > 1 ) printf("%s Trigger : id1 %d, id2 %d, min %f, max %f, det %s\n",
- GetInputAODName().Data(),clID1,clID2,fM02MinCut,fM02MaxCut,(particle->GetDetector()).Data());
-
- if(clID1 > 0 && clID2 < 0 && fM02MaxCut > 0 && fM02MinCut > 0)
+
+ AliDebug(1,Form("%s Trigger : min %f, max %f, det %d",
+ GetInputAODName().Data(),fM02MinCut,fM02MaxCut,particle->GetDetectorTag()));
+
+ if(fM02MaxCut > 0 && fM02MinCut > 0) //clID1 > 0 && clID2 < 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();
- if(m02 > fM02MaxCut || m02 < fM02MinCut) continue ;
- }
+ Float_t m02 = particle->GetM02();
+
+ if(m02 > fM02MaxCut || m02 < fM02MinCut) continue ;
fhPtTriggerSSCut->Fill(pt);
+
+ AliDebug(1,"Pass the shower shape cut");
}
//
if(OnlyIsolated())
{
if( !particle->IsIsolated() ) continue;
+
fhPtTriggerIsoCut->Fill(pt);
+
+ AliDebug(1,"Pass the isolation cut");
}
//
//
if(IsFiducialCutOn())
{
- Bool_t in = GetFiducialCut()->IsInFiducialCut(*particle->Momentum(),particle->GetDetector()) ;
+ Bool_t in = GetFiducialCut()->IsInFiducialCut(particle->Eta(),particle->Phi(),particle->GetDetectorTag()) ;
+
if(! in ) continue ;
+
+ AliDebug(1,"Pass the fiducial cut");
}
fhPtTriggerFidCut->Fill(pt);
// 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)
+ if(fSelectLeadingHadronAngle || fFillLeadHadOppositeHisto)
+ {
okLeadHad = FindLeadingOppositeHadronInWindow(particle);
- if(!okLeadHad) continue;
+ if(!okLeadHad && fSelectLeadingHadronAngle) continue;
+ }
//
// Charged particles correlation
MakeChargedCorrelation(particle);
// MC
+ Int_t mcIndex = -1;
+ Int_t mcTag = particle->GetTag();
+ Bool_t lostDecayPair = kFALSE;
if(IsDataMC())
- MakeMCChargedCorrelation(particle->GetLabel());
+ {
+ 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
// pT of the trigger, vs trigger origin if MC
//
fhPtTrigger->Fill(pt);
- if(IsDataMC())
+ if(IsDataMC() && mcIndex >=0 && mcIndex < fgkNmcTypes)
{
- Int_t mcIndex = GetMCTagHistogramIndex(particle->GetTag());
fhPtTriggerMC[mcIndex]->Fill(pt);
+ if( lostDecayPair )
+ {
+ // check index in GetMCTagIndexHistogram
+ if ( mcIndex == 2 ) fhPtTriggerMC[8]->Fill(pt); // pi0 decay
+ else if( mcIndex == 4 ) fhPtTriggerMC[9]->Fill(pt); // eta decay
+ }
+ }
+
+ if(fDecayTrigger)
+ {
+ Int_t decayTag = particle->DecayTag();
+ if(decayTag < 0) decayTag = 0;
+
+ for(Int_t ibit = 0; ibit<fNDecayBits; ibit++)
+ {
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
+ {
+ fhPtDecayTrigger[ibit]->Fill(pt);
+
+ if(IsDataMC() && mcIndex >=0 && mcIndex < fgkNmcTypes)
+ {
+ fhPtDecayTriggerMC[ibit][mcIndex]->Fill(pt);
+ if( lostDecayPair )
+ {
+ // check index in GetMCTagIndexHistogram
+ if( mcIndex == 2 ) fhPtDecayTriggerMC[ibit][8]->Fill(pt); // pi0 decay
+ if( mcIndex == 4 ) fhPtDecayTriggerMC[ibit][9]->Fill(pt); // eta decay
+ }
+ }
+ }// check bit
+ }// bit loop
}
//
if(fCorrelVzBin)
fhPtTriggerVzBin->Fill(pt,vzbin);
- if(fFillHighMultHistograms)
+ if(IsHighMultiplicityAnalysisOn())
{
fhPtTriggerCentrality->Fill(pt,cen);
fhPtTriggerEventPlane->Fill(pt,ep);
//----------------------------------
// Trigger particle pT vs pile-up
- if(fFillPileUpHistograms)
+ if(IsPileUpAnalysisOn())
{
Int_t vtxBC = GetReader()->GetVertexBC();
if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtTriggerVtxBC0->Fill(pt);
//Reinit for next event
fLeadingTriggerIndex = -1;
- if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeAnalysisFillHistograms() - End fill histograms \n");
+ AliDebug(1,"End fill histograms");
}
//_______________________________________________________________________________________________________
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 phi = -100. ;
Float_t eta = -100. ;
Float_t deltaPhi = -100. ;
- TVector3 p3;
- TLorentzVector photonMom ;
TObjArray * reftracks = 0x0;
Int_t nrefs = 0;
evtIndex13 = GetMixedEvent()->EventIndex(aodParticle->GetTrackLabel(0)) ;
}
+ // 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,
+ // 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 )
{
- decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2);
+ decayFound = GetDecayPhotonMomentum(aodParticle->GetCaloLabel(0),aodParticle->GetCaloLabel(1),aodParticle->GetDetectorTag());
if(decayFound)
{
- fhPtPi0DecayRatio->Fill(ptTrig, decayMom1.Pt()/ptTrig);
- fhPtPi0DecayRatio->Fill(ptTrig, decayMom2.Pt()/ptTrig);
+ fhPtPi0DecayRatio->Fill(ptTrig, fDecayMom1.Pt()/ptTrig);
+ fhPtPi0DecayRatio->Fill(ptTrig, fDecayMom2.Pt()/ptTrig);
}
}
{
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
continue;
}
- if(GetDebug() > 2 )
- printf("AliAnaParticleHadronCorrelation::MakeChargedCorrelation() - Selected charge for momentum imbalance: pt %2.2f, phi %2.2f, eta %2.2f \n",pt,phi,eta);
+ 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
if (okTOF && trackBC!=0) outTOF = 1;
else if(okTOF && trackBC==0) outTOF = 0;
- // Track multiplicity or cent bin
- Int_t cenbin = GetEventCentralityBin(); // combine with vz assoc bin???
-
//----------------
// Fill Histograms
if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
FillChargedAngularCorrelationHistograms(pt, ptTrig, bin, phi, phiTrig, deltaPhi,
- eta, etaTrig, decay, track->GetHMPIDsignal(),
+ eta, etaTrig, decayTag, track->GetHMPIDsignal(),
outTOF, cenbin, mcTag);
//
//
if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
FillChargedMomentumImbalanceHistograms(ptTrig, pt, deltaPhi, cenbin, track->Charge(),
- assocBin, decay, outTOF, mcTag);
+ assocBin, decayTag, outTOF, mcTag);
//
// Underlying event, right side, default case
//
if(fPi0Trigger && decayFound)
- FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2, kTRUE) ;
+ FillDecayPhotonCorrelationHistograms(pt, phi, kTRUE) ;
//
// Add track reference to array
{
// 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
if(!pool) return ;
if( neutralMix && !poolCalo )
- printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Careful, cluster pool not available\n");
+ 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, trigger 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.;
if( neutralMix && poolCalo )
{
if(pool->GetSize()!=poolCalo->GetSize())
- printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Different size of calo and track pools\n");
+ AliWarning("Different size of calo and track pools");
bgCalo = static_cast<TObjArray*>(poolCalo->At(ev));
- if(!bgCalo)
- printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Event %d in calo pool not available?\n",ev);
+ if(!bgCalo) AliDebug(1,Form("Event %d in calo pool not available?",ev));
}
//
//
if( OnlyIsolated() )
{
- Int_t n=0; Int_t nfrac = 0; Bool_t isolated = kFALSE; Float_t coneptsum = 0;
+ 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);
+ n,nfrac,coneptsum,coneptlead,isolated);
//printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Isolated? %d - cone %f, ptthres %f",
// isolated,GetIsolationCut()->GetConeSize(),GetIsolationCut()->GetPtThreshold());
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;
}
if( !neutralMix && fCheckLeadingWithNeutralClusters )
- printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Leading of clusters requested but no clusters in mixed event\n");
+ AliWarning("Leading of clusters requested but no clusters in mixed event");
if(neutralMix && fCheckLeadingWithNeutralClusters && bgCalo)
{
Int_t nClusters=bgCalo->GetEntriesFast();
- TLorentzVector mom ;
for(Int_t jlead = 0;jlead <nClusters; jlead++ )
{
AliAODPWG4Particle *cluster= (AliAODPWG4Particle*) bgCalo->At(jlead) ;
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;
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);
xE = -ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
if(xE < 0.)
- printf("MakeChargedMixCorrelation(): Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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));
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
if(uexE < 0.)
- printf("MakeChargedMixCorrelation(): Careful!!, negative xE %2.2f for left UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- uexE,randomphi*TMath::RadToDeg(),TMath::Cos(randomphi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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);
}
Int_t npi0 = pi0list->GetEntriesFast();
if(npi0 == 0) return ;
- if(GetDebug() > 1)
- printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Particle - pi0 correlation, %d pi0's\n",npi0);
+ AliDebug(1,Form("Particle - pi0 correlation, %d pi0's",npi0));
Int_t evtIndex11 = 0 ;
Int_t evtIndex12 = 0 ;
Float_t etaTrig = aodParticle->Eta();
Float_t deltaPhi= -100. ;
Float_t deltaEta= -100. ;
-
- TLorentzVector photonMom ;
// 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) decayFound = GetDecayPhotonMomentum(aodParticle,decayMom1, decayMom2);
+ if(fPi0Trigger) decayFound = GetDecayPhotonMomentum(aodParticle->GetCaloLabel(0),aodParticle->GetCaloLabel(1),aodParticle->GetDetectorTag());
TObjArray * refpi0 = 0x0;
Int_t nrefs = 0;
xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
if(xE < 0.)
- printf("MakeNeutralCorrelation(): Careful!!, negative xE %2.2f for right UE cos(dPhi %2.2f) = %2.2f, check correlation dPhi limits %f to %f\n",
- xE,deltaPhi*TMath::RadToDeg(),TMath::Cos(deltaPhi),fDeltaPhiMinCut*TMath::RadToDeg(),fDeltaPhiMaxCut*TMath::RadToDeg());
+ 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 ) hbpXE = TMath::Log(1./xE);
// Decay photon correlations
//
if(fPi0Trigger && decayFound)
- FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2,kFALSE) ;
+ FillDecayPhotonCorrelationHistograms(pt, phi, kFALSE) ;
if(fFillAODWithReferences)
{
refpi0->SetOwner(kFALSE);
}
refpi0->Add(pi0);
- }//put references in trigger AOD
+ } // put references in trigger AOD
- if(GetDebug() > 2 )
- printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Selected pi0: 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
}
}
-//__________________________________________________________________________
-void AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(Int_t label)
+//__________________________________________________________________________________________________________________
+void AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(Int_t label, Int_t histoIndex, Bool_t lostDecayPair)
{
// Charged Hadron Correlation Analysis with MC information
- if ( GetDebug() > 1 )
- AliInfo("Make trigger particle - charged hadron correlation in AOD MC level");
+ AliDebug(1,"Make trigger particle - charged hadron correlation in AOD MC level");
if( label < 0 )
{
- if( GetDebug() > 0 ) AliInfo(Form(" *** bad label ***: label %d", label));
+ 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 * mcparticles = 0x0 ;
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 charge = (Int_t) TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
if(charge == 0) continue;
- particle->Momentum(momentum);
+ particle->Momentum(fMomentum);
//Particles in CTS acceptance, make sure to use the same selection as in the reader
- Bool_t inCTS = GetReader()->GetFiducialCut()->IsInFiducialCut(momentum,"CTS");
- //printf("Accepted? %d; pt %2.2f, eta %2.2f, phi %2.2f\n",inCTS,momentum.Pt(),momentum.Eta(),momentum.Phi()*TMath::RadToDeg());
+ 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
Float_t phi = particle->Phi();
if(phi < 0) phi+=TMath::TwoPi();
- Bool_t lead = FillChargedMCCorrelationHistograms(particle->Pt(),phi,particle->Eta(),ptprim,phiprim,etaprim);
+ Bool_t lead = FillChargedMCCorrelationHistograms(particle->Pt(),phi,particle->Eta(),ptprim,phiprim,etaprim,histoIndex,lostDecayPair);
if(!lead) leadTrig = kFALSE;
//if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading) ) return;
if ( part->Charge() == 0 ) continue;
- TLorentzVector momentum(part->Px(),part->Py(),part->Pz(),part->E());
+ 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(momentum,"CTS");
- //printf("Accepted? %d; pt %2.2f, eta %2.2f, phi %2.2f\n",inCTS,momentum.Pt(),momentum.Eta(),momentum.Phi()*TMath::RadToDeg());
+ 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
Float_t phi = part->Phi();
if(phi < 0) phi+=TMath::TwoPi();
- Bool_t lead = FillChargedMCCorrelationHistograms(part->Pt(),phi,part->Eta(),ptprim,phiprim,etaprim);
+ Bool_t lead = FillChargedMCCorrelationHistograms(part->Pt(),phi,part->Eta(),ptprim,phiprim,etaprim, histoIndex,lostDecayPair);
if(!lead) leadTrig = kFALSE;
//if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return;
// Trigger MC particle histograms
//if (!lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return;
- fhMCPtTrigger ->Fill(ptprim);
- fhMCPhiTrigger->Fill(ptprim,phiprim);
- fhMCEtaTrigger->Fill(ptprim,etaprim);
+ fhMCPtTrigger [histoIndex]->Fill(ptprim);
+ fhMCPhiTrigger[histoIndex]->Fill(ptprim,phiprim);
+ fhMCEtaTrigger[histoIndex]->Fill(ptprim,etaprim);
+
+ if(lostDecayPair)
+ {
+ // check index in GetMCTagIndexHistogram
+ if (histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
+ {
+ // pi0 decay
+ fhMCPtTrigger [8]->Fill(ptprim);
+ fhMCPhiTrigger[8]->Fill(ptprim,phiprim);
+ fhMCEtaTrigger[8]->Fill(ptprim,etaprim);
+ }
+ else if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
+ {
+ // eta decay
+ fhMCPtTrigger [9]->Fill(ptprim);
+ fhMCPhiTrigger[9]->Fill(ptprim,phiprim);
+ fhMCEtaTrigger[9]->Fill(ptprim,etaprim);
+ }
+ }
if(!leadTrig && (fMakeAbsoluteLeading || fMakeNearSideLeading) )
{
- if(GetDebug() > 1)
- printf("AliAnaParticleHadronCorrelation::MakeMCChargedCorrelation(): Not leading primary trigger: pT %2.2f, phi %2.2f, eta %2.2f\n",
- ptprim,phiprim*TMath::RadToDeg(),etaprim);
+ 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);
- fhMCPtTriggerNotLeading ->Fill(ptprim);
- fhMCPhiTriggerNotLeading->Fill(ptprim,phiprim);
- fhMCEtaTriggerNotLeading->Fill(ptprim,etaprim);
+ if(lostDecayPair)
+ {
+ // check index in GetMCTagIndexHistogram
+ if (histoIndex == 2 && 8 >= fMCGenTypeMin && 8 <= fMCGenTypeMax )
+ {
+ // pi0 decay
+ fhMCPtTriggerNotLeading [8]->Fill(ptprim);
+ fhMCPhiTriggerNotLeading[8]->Fill(ptprim,phiprim);
+ fhMCEtaTriggerNotLeading[8]->Fill(ptprim,etaprim);
+ }
+ else if(histoIndex == 4 && 9 >= fMCGenTypeMin && 9 <= fMCGenTypeMax )
+ {
+ // eta decay
+ fhMCPtTriggerNotLeading [9]->Fill(ptprim);
+ fhMCPhiTriggerNotLeading[9]->Fill(ptprim,phiprim);
+ fhMCEtaTriggerNotLeading[9]->Fill(ptprim,etaprim);
+ }
+ }
}
}
}
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;
}
}
}
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)) ;
}
}