fSelectLeadingHadronAngle(0),
fMinLeadHadPhi(0), fMaxLeadHadPhi(0),
fMinLeadHadPt(0), fMaxLeadHadPt(0),
-
+ fFillEtaGapsHisto(1), fFillMomImbalancePtAssocBinsHisto(0),
//Histograms
fhPtTriggerInput(0), fhPtTriggerSSCut(0),
fhPtTriggerIsoCut(0), fhPtTriggerFidCut(0),
fhXEChargedVtxBC0(), fhXEUeChargedVtxBC0(),
fhZTChargedVtxBC0(), fhZTUeChargedVtxBC0(),
fhPtTrigChargedVtxBC0(),
- fhDeltaPhiUeLeftCharged(0), fhDeltaPhiUeRightCharged(0),
+ fhDeltaPhiUeLeftCharged(0),
fhDeltaPhiUeLeftUpCharged(0), fhDeltaPhiUeRightUpCharged(0),
fhDeltaPhiUeLeftDownCharged(0), fhDeltaPhiUeRightDownCharged(0),
- fhXEUeLeftCharged(0), fhXEUeRightCharged(0),
+ fhXEUeLeftCharged(0),
fhXEUeLeftUpCharged(0), fhXEUeRightUpCharged(0),
fhXEUeLeftDownCharged(0), fhXEUeRightDownCharged(0),
- fhPtHbpXEUeLeftCharged(0), fhPtHbpXEUeRightCharged(0),
- fhZTUeLeftCharged(0), fhZTUeRightCharged(0),
- fhPtHbpZTUeLeftCharged(0), fhPtHbpZTUeRightCharged(0),
+ fhPtHbpXEUeLeftCharged(0), fhZTUeLeftCharged(0),
+ fhPtHbpZTUeLeftCharged(0),
fhPtTrigPout(0), fhPtTrigCharged(0),
fhDeltaPhiChargedMult(0x0), fhDeltaEtaChargedMult(0x0),
fhXEMult(0x0), fhXEUeMult(0x0),
fhDeltaPhiAssocPtBinDEta08(0), fhDeltaPhiAssocPtBinDEta0(0),
fhDeltaPhiAssocPtBinHMPID(0), fhDeltaPhiAssocPtBinHMPIDAcc(0),
fhDeltaPhiBradAssocPtBin(0), fhDeltaPhiBrad(0),
- fhXEAssocPtBin(0), fhZTAssocPtBin(0),
- fhDeltaPhiDeltaEtaNeutral(0),
+ fhXEAssocPtBin(0), fhZTAssocPtBin(0),
+ fhXEVZ(0), fhZTVZ(0),
+ fhDeltaPhiDeltaEtaNeutral(0),
fhPhiNeutral(0), fhEtaNeutral(0),
fhDeltaPhiNeutral(0), fhDeltaEtaNeutral(0),
fhDeltaPhiNeutralPt(0), fhDeltaPhiUeNeutralPt(0),
fhPtHbpXENeutral(0), fhPtHbpXEUeNeutral(0),
fhZTNeutral(0), fhZTUeNeutral(0),
fhPtHbpZTNeutral(0), fhPtHbpZTUeNeutral(0),
- fhDeltaPhiUeLeftNeutral(0), fhDeltaPhiUeRightNeutral(0),
- fhXEUeLeftNeutral(0), fhXEUeRightNeutral(0),
- fhPtHbpXEUeLeftNeutral(0), fhPtHbpXEUeRightNeutral(0),
- fhZTUeLeftNeutral(0), fhZTUeRightNeutral(0),
- fhPtHbpZTUeLeftNeutral(0), fhPtHbpZTUeRightNeutral(0),
- fhPtPi0DecayRatio(0),
- fhDeltaPhiDecayCharged(0), fhXEDecayCharged(0), fhZTDecayCharged(0),
- fhDeltaPhiDecayNeutral(0), fhXEDecayNeutral(0), fhZTDecayNeutral(0),
+ 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),
- fhMCEtaCharged(0), fhMCPhiCharged(0),
+ 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), fhMCPtXEUeRightCharged(0),
+ fhMCPtXEUeLeftCharged(0),
fhMCPtHbpXECharged(0), fhMCPtHbpXEUeCharged(0),
- fhMCPtHbpXEUeLeftCharged(0), fhMCPtHbpXEUeRightCharged(0),
+ fhMCPtHbpXEUeLeftCharged(0),
fhMCUePart(0),
fhMCPtZTCharged(0), fhMCPtZTUeCharged(0),
- fhMCPtZTUeLeftCharged(0), fhMCPtZTUeRightCharged(0),
+ fhMCPtZTUeLeftCharged(0),
fhMCPtHbpZTCharged(0), fhMCPtHbpZTUeCharged(0),
- fhMCPtHbpZTUeLeftCharged(0), fhMCPtHbpZTUeRightCharged(0),
+ fhMCPtHbpZTUeLeftCharged(0),
fhMCPtTrigPout(0), fhMCPtAssocDeltaPhi(0),
//Mixing
fhNEventsTrigger(0), fhNtracksMB(0), fhNclustersMB(0),
fhMixDeltaPhiChargedAssocPtBinDEta08(),
fhMixDeltaPhiChargedAssocPtBinDEta0(),
fhMixDeltaPhiDeltaEtaChargedAssocPtBin(),
- fhEventBin(0), fhEventMixBin(0)
+ fhEventBin(0), fhEventMixBin(0), fhEventMBBin(0)
{
//Default Ctor
//__________________________________________________________________________________________________________________________________________
void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig, Int_t bin,
- Float_t phiAssoc, Float_t phiTrig, Float_t & deltaPhi,
+ 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 cen, Int_t mcTag)
// Fill angular correlation related histograms
Float_t deltaEta = etaTrig-etaAssoc;
- deltaPhi = phiTrig-phiAssoc;
- Float_t deltaPhiOrg = deltaPhi;
-
- if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
- if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
+ Float_t deltaPhiOrg = phiTrig-phiAssoc;
fhEtaCharged ->Fill(ptAssoc,etaAssoc);
fhPhiCharged ->Fill(ptAssoc,phiAssoc);
if(fFillBradHisto)
{
dphiBrad = atan2(sin(deltaPhiOrg), cos(deltaPhiOrg))/TMath::Pi();//-1 to 1
- if(TMath::Abs(dphiBrad)>0.325 && TMath::Abs(dphiBrad)<0.475) //Hardcoded values, BAD, FIXME
+ if( TMath::Abs(dphiBrad) > 0.325 && TMath::Abs(dphiBrad) < 0.475 ) //Hardcoded values, BAD, FIXME
{
fhAssocPtBkg->Fill(ptTrig, ptAssoc);
}
- if(dphiBrad<-1./3) dphiBrad += 2;
+ if( dphiBrad < -1./3 ) dphiBrad += 2;
fhDeltaPhiBrad->Fill(ptTrig, dphiBrad);
}
fhDeltaPhiAssocPtBin [bin]->Fill(ptTrig, deltaPhi);
- if(TMath::Abs(deltaEta)> 0.8)
- fhDeltaPhiAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi);
-
- if(TMath::Abs(deltaEta)< 0.01)
- fhDeltaPhiAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi);
+ if(fFillEtaGapsHisto)
+ {
+ if(TMath::Abs(deltaEta)> 0.8)
+ fhDeltaPhiAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi);
+
+ if(TMath::Abs(deltaEta)< 0.01)
+ fhDeltaPhiAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi);
+ }
if (fFillBradHisto)
fhDeltaPhiBradAssocPtBin [bin]->Fill(ptTrig, dphiBrad);
{
// Fill MC histograms independently of AOD or ESD
- //Select only hadrons in pt range
- if( mcAssocPt < fMinAssocPt || mcAssocPt > fMaxAssocPt ) return kTRUE ; // exclude but continue
+ Bool_t lead = kTRUE;
+
+ // In case we requested the trigger to be a leading particle,
+ // check if this is true at the MC level.
+ // Not sure if it is correct to skip or not skip this.
+ // Absolute leading?
+ if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) 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
+
+ //
+ // 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
+ //
+ // Remove trigger itself for correlation when use charged triggers
if(TMath::Abs(mcAssocPt -mcTrigPt ) < 1e-6 &&
TMath::Abs(mcAssocPhi-mcTrigPhi) < 1e-6 &&
- TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return kTRUE ; // exclude but continue
-
- // Absolute leading?
- if( fMakeAbsoluteLeading && mcAssocPt > mcTrigPt ) return 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() ) return kFALSE; // skip event
+ TMath::Abs(mcAssocEta-mcTrigEta) < 1e-6) return lead ; // exclude but continue
- Float_t mcdeltaPhi= mcTrigPhi-mcAssocPhi;
+ Float_t mcdeltaPhi= mcTrigPhi-mcAssocPhi;
if(mcdeltaPhi <= -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
- if(mcdeltaPhi > 3*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 ;
Float_t mchbpZT =-100 ;
if(mczT > 0 ) mchbpZT = TMath::Log(1./mczT);
- //Selection within angular range
- if( mcdeltaPhi< -TMath::PiOver2()) mcdeltaPhi+=TMath::TwoPi();
- if( mcdeltaPhi>3*TMath::PiOver2()) mcdeltaPhi-=TMath::TwoPi();
-
Double_t mcpout = mcAssocPt*TMath::Sin(mcdeltaPhi) ;
if(GetDebug() > 0 )
fhMCPtTrigPout ->Fill(mcTrigPt, mcpout) ;
}
- //underlying event
+ // Underlying event
+ // Right
if ( (mcdeltaPhi > fUeDeltaPhiMinCut) && (mcdeltaPhi < fUeDeltaPhiMaxCut) )
{
//Double_t randomphi = gRandom->Uniform(TMath::Pi()/2,3*TMath::Pi()/2);
Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
Double_t mcUezT = mcAssocPt/mcTrigPt;
-
- if(mcUexE < 0.) mcUexE = -mcUexE;
+ 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());
+
fhMCPtXEUeCharged->Fill(mcTrigPt,mcUexE);
if(mcUexE > 0) fhMCPtHbpXEUeCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
-
+
fhMCPtZTUeCharged->Fill(mcTrigPt,mcUezT);
if(mcUezT > 0) fhMCPtHbpZTUeCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
fhMCUePart->Fill(mcTrigPt);
}
-
- //left
- if((mcdeltaPhi<-fUeDeltaPhiMinCut) || (mcdeltaPhi >2*fUeDeltaPhiMaxCut))
- {
- Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
- Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
- Double_t mcUezT = mcAssocPt/mcTrigPt;
-
- if(mcUexE < 0.) mcUexE = -mcUexE;
-
- fhMCPtXEUeLeftCharged->Fill(mcTrigPt,mcUexE);
- if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
-
- fhMCPtZTUeLeftCharged->Fill(mcTrigPt,mcUezT);
- if(mcUexE > 0) fhMCPtHbpZTUeLeftCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
-
- }
-
- //right
- if((mcdeltaPhi > fUeDeltaPhiMinCut) && (mcdeltaPhi < fUeDeltaPhiMaxCut))
+
+ if(fMakeSeveralUE)
{
- Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
- Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
- Double_t mcUezT = mcAssocPt/mcTrigPt;
-
- if(mcUexE < 0.) mcUexE = -mcUexE;
-
- fhMCPtXEUeRightCharged->Fill(mcTrigPt,mcUexE);
- if(mcUexE > 0) fhMCPtHbpXEUeRightCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
-
- fhMCPtZTUeRightCharged->Fill(mcTrigPt,mcUezT);
- if(mcUexE > 0) fhMCPtHbpZTUeRightCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
+ // Left
+ if((mcdeltaPhi<-fUeDeltaPhiMinCut) || (mcdeltaPhi >2*fUeDeltaPhiMaxCut))
+ {
+ Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
+ Double_t mcUexE = -(mcAssocPt/mcTrigPt)*TMath::Cos(randomphi);
+ Double_t mcUezT = mcAssocPt/mcTrigPt;
+
+ if(mcUexE < 0.)
+ 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());
+
+ fhMCPtXEUeLeftCharged->Fill(mcTrigPt,mcUexE);
+ if(mcUexE > 0) fhMCPtHbpXEUeLeftCharged->Fill(mcTrigPt,TMath::Log(1/mcUexE));
+
+ fhMCPtZTUeLeftCharged->Fill(mcTrigPt,mcUezT);
+ if(mcUexE > 0) fhMCPtHbpZTUeLeftCharged->Fill(mcTrigPt,TMath::Log(1/mcUezT));
+ }
}
- return kTRUE;
-}
+ return lead;
+}
//___________________________________________________________________________________________________________________
void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(Float_t ptTrig, Float_t ptAssoc,
Float_t xE =-ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
Float_t hbpXE = -100;
- //if(xE <0.)xE =-xE;
+
+ 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());
+
if(xE > 0 ) hbpXE = TMath::Log(1./xE);
else hbpXE =-100;
fhZTDecayCharged->Fill(ptTrig,zT);
} // photon decay pi0/eta trigger
- if(bin >= 0 )//away side
+ if(bin >= 0 && fFillMomImbalancePtAssocBinsHisto)//away side
{
fhXEAssocPtBin[bin]->Fill(ptTrig, xE) ;
fhZTAssocPtBin[bin]->Fill(ptTrig, zT) ;
}
+ if(fCorrelVzBin)
+ {
+ Int_t vz = GetEventVzBin();
+ fhXEVZ[vz]->Fill(ptTrig, xE) ;
+ fhZTVZ[vz]->Fill(ptTrig, zT) ;
+ }
+
if(charge > 0)
{
fhXEPosCharged->Fill(ptTrig,xE) ;
{
// Fill underlying event histograms
+ fhUePart->Fill(ptTrig);
+
fhDeltaPhiUeChargedPt->Fill(ptAssoc,deltaPhi);
Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
Double_t uezT = ptAssoc/ptTrig;
- if(uexE < 0.) uexE = -uexE;
-
+ if(uexE < 0.)
+ 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());
+
fhXEUeCharged->Fill(ptTrig,uexE);
if(uexE > 0) fhPtHbpXEUeCharged->Fill(ptTrig,TMath::Log(1/uexE));
Float_t ptAssoc,
Float_t deltaPhi)
{
- // Fill underlying event histograms to the left and right of trigger
+ // Fill underlying event histograms to the left and right of trigger
+ // Right cone is the default UE.
+
if((deltaPhi<-fUeDeltaPhiMinCut) || (deltaPhi >2*fUeDeltaPhiMaxCut))
- {
- fhDeltaPhiUeLeftCharged->Fill(ptAssoc,deltaPhi);
+ {
+ fhDeltaPhiUeLeftCharged->Fill(ptAssoc,deltaPhi);
Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
Double_t uezT = ptAssoc/ptTrig;
-
- if(uexE < 0.) uexE = -uexE;
+
+ if(uexE < 0.)
+ 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());
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));
fhDeltaPhiUeLeftCharged->Fill(ptAssoc, deltaPhi);
}
- if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut))
- {
- fhDeltaPhiUeRightCharged->Fill(ptAssoc,deltaPhi);
- Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
- Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
- Double_t uezT = ptAssoc/ptTrig;
-
- if(uexE < 0.) uexE = -uexE;
-
- fhXEUeRightCharged->Fill(ptTrig,uexE);
- if(uexE > 0) fhPtHbpXEUeRightCharged->Fill(ptTrig,TMath::Log(1/uexE));
-
- fhZTUeRightCharged->Fill(ptTrig,uezT);
- if(uexE > 0) fhPtHbpZTUeRightCharged->Fill(ptTrig,TMath::Log(1/uezT));
- fhDeltaPhiUeRightCharged->Fill(ptAssoc, deltaPhi);
- }
-
if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-TMath::Pi()/2))
- {
- fhDeltaPhiUeLeftDownCharged->Fill(ptAssoc,deltaPhi);
+ {
+ fhDeltaPhiUeLeftDownCharged->Fill(ptAssoc,deltaPhi);
Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
- if(uexE < 0.) uexE = -uexE;
+ if(uexE < 0.)
+ 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());
fhXEUeLeftDownCharged->Fill(ptTrig,uexE);
}
if((deltaPhi>2*fUeDeltaPhiMaxCut) && (deltaPhi <3*TMath::Pi()/2))
- {
- fhDeltaPhiUeLeftUpCharged->Fill(ptAssoc,deltaPhi);
+ {
+ fhDeltaPhiUeLeftUpCharged->Fill(ptAssoc,deltaPhi);
Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
- if(uexE < 0.) uexE = -uexE;
+ if(uexE < 0.)
+ 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());
fhXEUeLeftUpCharged->Fill(ptTrig,uexE);
}
if((deltaPhi > TMath::Pi()/2) && (deltaPhi < fUeDeltaPhiMaxCut))
- {
- fhDeltaPhiUeRightUpCharged->Fill(ptAssoc,deltaPhi);
+ {
+ fhDeltaPhiUeRightUpCharged->Fill(ptAssoc,deltaPhi);
Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
- if(uexE < 0.) uexE = -uexE;
+ if(uexE < 0.)
+ 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());
fhXEUeRightUpCharged->Fill(ptTrig,uexE);
}
if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < TMath::Pi()/2))
- {
- fhDeltaPhiUeRightDownCharged->Fill(ptAssoc,deltaPhi);
+ {
+ fhDeltaPhiUeRightDownCharged->Fill(ptAssoc,deltaPhi);
Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
- if(uexE < 0.) uexE = -uexE;
+ if(uexE < 0.)
+ 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());
fhXEUeRightDownCharged->Fill(ptTrig,uexE);
- }
+ }
}
//______________________________________________________________________________________________________________________________
}
}
-//______________________________________________________________________________________________________________________________________________________
-void AliAnaParticleHadronCorrelation::FillNeutralAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig,
- Float_t phiAssoc, Float_t phiTrig, Float_t & deltaPhi,
- Float_t etaAssoc, Float_t etaTrig)
-{
- // Fill angular correlation related histograms
-
- Float_t deltaEta = etaTrig-etaAssoc;
- deltaPhi = phiTrig-phiAssoc;
-
- if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
- if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
-
- fhEtaNeutral ->Fill(ptAssoc,etaAssoc);
- fhPhiNeutral ->Fill(ptAssoc,phiAssoc);
- fhDeltaEtaNeutral->Fill(ptTrig ,deltaEta);
- fhDeltaPhiNeutral->Fill(ptTrig ,deltaPhi);
-
- if(ptAssoc > 2 ) fhDeltaPhiDeltaEtaNeutral->Fill(deltaPhi, deltaEta);
-
-}
-
//_____________________________________________________________________________________________________________________________
void AliAnaParticleHadronCorrelation::FillNeutralUnderlyingEventSidesHistograms(Float_t ptTrig, Float_t ptAssoc,
- Float_t xE, Float_t hbpXE,
- Float_t zT, Float_t hbpZT,
+ Float_t zT, Float_t hbpZT,
Float_t deltaPhi)
{
- // Fill underlying event histograms to the left and right of trigger
+ // Fill underlying event histograms to the left of trigger
+ // Right is the default case
+
+ Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
+
+ Float_t xE =-ptAssoc/ptTrig*TMath::Cos(randomphi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
+ Float_t hbpXE = -100;
+ if(xE > 0 ) hbpXE = TMath::Log(1./xE);
if((deltaPhi<-fUeDeltaPhiMinCut) && (deltaPhi >-fUeDeltaPhiMaxCut))
- {
+ {
fhDeltaPhiUeLeftNeutral->Fill(ptAssoc, deltaPhi);
fhXEUeLeftNeutral ->Fill(ptTrig , xE);
fhPtHbpXEUeLeftNeutral ->Fill(ptTrig , hbpXE);
fhZTUeLeftNeutral ->Fill(ptTrig , zT);
fhPtHbpZTUeLeftNeutral ->Fill(ptTrig , hbpZT);
}
-
- if((deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut))
- {
- fhDeltaPhiUeRightNeutral->Fill(ptAssoc, deltaPhi);
- fhXEUeRightNeutral ->Fill(ptTrig , xE);
- fhPtHbpXEUeRightNeutral ->Fill(ptTrig , hbpXE);
- fhZTUeRightNeutral ->Fill(ptTrig , zT);
- fhPtHbpZTUeRightNeutral ->Fill(ptTrig , hbpZT);
- }
}
//______________________________________________________
void AliAnaParticleHadronCorrelation::FillEventMixPool()
{
- // Fill the pool with tracks if requested
+ // Fill the pool with tracks or clusters if requested
- if(DoOwnMix())
- {
- FillChargedEventMixPool();
-
- if(OnlyIsolated() || fFillNeutralEventMixPool)
- FillNeutralEventMixPool();
- }
+ if ( !DoOwnMix() ) return;
+ FillChargedEventMixPool();
+
+ // Do the cluster pool filling only if requested
+ // or in case of isolation cut using clusters in the cone.
+ Bool_t isoCase = OnlyIsolated() && (GetIsolationCut()->GetParticleTypeInCone() != AliIsolationCut::kOnlyCharged);
+
+ if( !fFillNeutralEventMixPool && !isoCase) return;
+
+ FillNeutralEventMixPool();
}
//_____________________________________________________________
return ; // pool filled previously for another trigger
}
- Int_t nTracks = GetCTSTracks()->GetEntriesFast();
-
AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
// Do mixing only with MB event (or the chosen mask), if not skip
if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
- fhNtracksMB->Fill(nTracks);
-
Int_t eventBin = GetEventMixBin();
//Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
if(eventBin < 0) return;
+ fhEventMBBin->Fill(eventBin);
+
TObjArray * mixEventTracks = new TObjArray;
if(fUseMixStoredInReader)
mixEventTracks->Add(mixedTrack);
}
+ fhNtracksMB->Fill(mixEventTracks->GetEntriesFast(),eventBin);
+
//Set the event number where the last event was added, to avoid double pool filling
GetReader()->SetLastTracksMixedEvent(GetEventNumber());
//printf("FillNeutralEventMixPool for %s\n",GetInputAODName().Data());
- TObjArray * pl = GetEMCALClusters();
- //if (GetAODObjArrayName.Contains("PHOS") )pl = GetPHOSClusters();
- //else pl = GetEMCALClusters();
-
- Int_t nClusters = pl->GetEntriesFast();
-
if(fUseMixStoredInReader && GetReader()->GetLastCaloMixedEvent() == GetEventNumber())
{
//printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
return ; // pool filled previously for another trigger
}
+ TObjArray * pl = GetEMCALClusters();
+ //if (GetAODObjArrayName.Contains("PHOS") )pl = GetPHOSClusters();
+ //else pl = GetEMCALClusters();
+
AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
// Do mixing only with MB event (or the chosen mask), if not skip
if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
- fhNclustersMB->Fill(nClusters);
-
Int_t eventBin = GetEventMixBin();
//Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
TLorentzVector mom;
- for(Int_t ipr = 0;ipr < nClusters ; ipr ++ )
+ for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
{
AliVCluster * calo = (AliVCluster *) (pl->At(ipr)) ;
mixEventCalo->Add(mixedCalo);
}
+ fhNclustersMB->Fill(mixEventCalo->GetEntriesFast(),eventBin);
+
//Set the event number where the last event was added, to avoid double pool filling
GetReader()->SetLastCaloMixedEvent(GetEventNumber());
}
if( ptLeadHad < fMinLeadHadPt ||
- ptLeadHad > fMaxLeadHadPt ) return kFALSE;
+ ptLeadHad > fMaxLeadHadPt ) return kFALSE;
//printf("Accept leading hadron pT \n");
if( TMath::Abs(phiLeadHad-phiTrig) < fMinLeadHadPhi ||
- TMath::Abs(phiLeadHad-phiTrig) > fMaxLeadHadPhi ) return kFALSE;
+ TMath::Abs(phiLeadHad-phiTrig) > fMaxLeadHadPhi ) return kFALSE;
//printf("Accept leading hadron phi \n");
const Int_t buffersize = 560;
char onePar[buffersize] ;
- snprintf(onePar,buffersize,"--- AliAnaPaticleHadronCorrelation ---\n") ;
+ snprintf(onePar,buffersize,"--- AliAnaPaticleHadronCorrelation ---:") ;
parList+=onePar ;
- snprintf(onePar,buffersize," %3.2f < Pt associated < %3.2f ", fMinAssocPt, fMaxAssocPt) ;
+ snprintf(onePar,buffersize," %3.2f < Pt associated < %3.2f; ", fMinAssocPt, fMaxAssocPt) ;
parList+=onePar ;
- snprintf(onePar,buffersize," %3.2f < Phi trigger particle-Hadron < %3.2f ", fDeltaPhiMinCut, fDeltaPhiMaxCut) ;
+ snprintf(onePar,buffersize," %3.2f < Phi trigger particle-Hadron < %3.2f; ", fDeltaPhiMinCut, fDeltaPhiMaxCut) ;
parList+=onePar ;
- snprintf(onePar,buffersize," %3.2f < Phi trigger particle-UeHadron < %3.2f ", fUeDeltaPhiMinCut, fUeDeltaPhiMaxCut) ;
+ snprintf(onePar,buffersize," %3.2f < Phi trigger particle-UeHadron < %3.2f; ", fUeDeltaPhiMinCut, fUeDeltaPhiMaxCut) ;
parList+=onePar ;
- snprintf(onePar,buffersize,"Isolated Trigger? %d\n", fSelectIsolated) ;
+ snprintf(onePar,buffersize,"Isolated Trigger? %d;", fSelectIsolated) ;
parList+=onePar ;
- snprintf(onePar,buffersize,"Several UE? %d\n", fMakeSeveralUE) ;
+ snprintf(onePar,buffersize,"Several UE? %d;", fMakeSeveralUE) ;
parList+=onePar ;
- snprintf(onePar,buffersize,"Name of AOD Pi0 Branch %s ", fPi0AODBranchName.Data());
+ snprintf(onePar,buffersize,"Name of AOD Pi0 Branch %s;", fPi0AODBranchName.Data());
parList+=onePar ;
- snprintf(onePar,buffersize,"Do Decay-hadron correlation ? pi0 %d, decay %d", fPi0Trigger, fDecayTrigger) ;
+ snprintf(onePar,buffersize,"Do Decay-hadron correlation ? pi0 %d, decay %d;", fPi0Trigger, fDecayTrigger) ;
parList+=onePar ;
- snprintf(onePar,buffersize,"Select absolute leading for cluster triggers ? %d or Near Side Leading %d \n",
+ snprintf(onePar,buffersize,"Select absolute leading for cluster triggers ? %d or Near Side Leading %d;",
fMakeAbsoluteLeading, fMakeNearSideLeading) ;
parList+=onePar ;
snprintf(onePar,buffersize,"Associated particle pt bins %d: ", fNAssocPtBins) ;
TList * outputContainer = new TList() ;
outputContainer->SetName("CorrelationHistos") ;
- Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Int_t netabins = GetHistogramRanges()->GetHistoEtaBins(); Int_t ndeltaphibins = GetHistogramRanges()->GetHistoDeltaPhiBins(); Int_t ndeltaetabins = GetHistogramRanges()->GetHistoDeltaEtaBins();
- Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax(); Float_t deltaphimax = GetHistogramRanges()->GetHistoDeltaPhiMax(); Float_t deltaetamax = GetHistogramRanges()->GetHistoDeltaEtaMax();
- Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin(); Float_t deltaphimin = GetHistogramRanges()->GetHistoDeltaPhiMin(); Float_t deltaetamin = GetHistogramRanges()->GetHistoDeltaEtaMin();
+ Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Int_t netabins = GetHistogramRanges()->GetHistoEtaBins();
+ Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax();
+ Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin();
+
+ Int_t ndeltaphibins = GetHistogramRanges()->GetHistoDeltaPhiBins(); Int_t ndeltaetabins = GetHistogramRanges()->GetHistoDeltaEtaBins();
+ Float_t deltaphimax = GetHistogramRanges()->GetHistoDeltaPhiMax(); Float_t deltaetamax = GetHistogramRanges()->GetHistoDeltaEtaMax();
+ Float_t deltaphimin = GetHistogramRanges()->GetHistoDeltaPhiMin(); Float_t deltaetamin = GetHistogramRanges()->GetHistoDeltaEtaMin();
+
+ Int_t ntrbins = GetHistogramRanges()->GetHistoTrackMultiplicityBins(); Int_t nclbins = GetHistogramRanges()->GetHistoNClustersBins();
+ Int_t trmax = GetHistogramRanges()->GetHistoTrackMultiplicityMax(); Int_t clmax = GetHistogramRanges()->GetHistoNClustersMax();
+ Int_t trmin = GetHistogramRanges()->GetHistoTrackMultiplicityMin(); Int_t clmin = GetHistogramRanges()->GetHistoNClustersMin();
+
+ Int_t nxeztbins = GetHistogramRanges()->GetHistoRatioBins(); Int_t nhbpbins = GetHistogramRanges()->GetHistoHBPBins();
+ Float_t xeztmax = GetHistogramRanges()->GetHistoRatioMax(); Float_t hbpmax = GetHistogramRanges()->GetHistoHBPMax();
+ Float_t xeztmin = GetHistogramRanges()->GetHistoRatioMin(); Float_t hbpmin = GetHistogramRanges()->GetHistoHBPMin();
Int_t nMixBins = GetNCentrBin()*GetNZvertBin()*GetNRPBin();
TString sz = "" ;
TString tz = "" ;
+ // Fill histograms for neutral clusters in mixing?
+ Bool_t isoCase = OnlyIsolated() && (GetIsolationCut()->GetParticleTypeInCone() != AliIsolationCut::kOnlyCharged);
+ Bool_t neutralMix = fFillNeutralEventMixPool || isoCase ;
+
fhPtTriggerInput = new TH1F("hPtTriggerInput","Input trigger #it{p}_{T}", nptbins,ptmin,ptmax);
fhPtTriggerInput->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
outputContainer->Add(fhPtTriggerInput);
if( OnlyIsolated() )
{
- fhPtTriggerIsoCut = new TH1F("hPtTriggerIsoCut","Trigger #it{p}_{T} after isolation (and #lambda^{2}_{0}) cut", nptbins,ptmin,ptmax);
+ fhPtTriggerIsoCut = new TH1F("hPtTriggerIsoCut","Trigger #it{p}_{T} after isolation (and #lambda^{2}_{0} cut)", nptbins,ptmin,ptmax);
fhPtTriggerIsoCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
outputContainer->Add(fhPtTriggerIsoCut);
}
fhPtTriggerFidCut->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
outputContainer->Add(fhPtTriggerFidCut);
- fhPtTrigger = new TH1F("hPtTrigger","#it{p}_{T} distribution of trigger particles", nptbins,ptmin,ptmax);
+ fhPtTrigger = new TH1F("hPtTrigger","#it{p}_{T} distribution of trigger particles (after opposite hadron leading cut and rest)", nptbins,ptmin,ptmax);
fhPtTrigger->SetXTitle("#it{p}_{T}^{trig} (GeV/#it{c})");
outputContainer->Add(fhPtTrigger);
fhTriggerEventPlaneCentrality->SetYTitle("EP angle (rad)");
outputContainer->Add(fhTriggerEventPlaneCentrality) ;
}
-
+
// Leading hadron in oposite side
if(fSelectLeadingHadronAngle)
{
fhPhiCharged = new TH2F
("hPhiCharged","#phi_{h^{#pm}} vs #it{p}_{T #pm}",
- nptbins,ptmin,ptmax,nphibins,phimin,phimax);
+ nptbins,ptmin,ptmax,180,0,TMath::TwoPi());
fhPhiCharged->SetYTitle("#phi_{h^{#pm}} (rad)");
fhPhiCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
fhEtaCharged = new TH2F
("hEtaCharged","#eta_{h^{#pm}} vs #it{p}_{T #pm}",
- nptbins,ptmin,ptmax,netabins,etamin,etamax);
+ nptbins,ptmin,ptmax,100,-1.,1.);
fhEtaCharged->SetYTitle("#eta_{h^{#pm}} (rad)");
fhEtaCharged->SetXTitle("#it{p}_{T #pm} (GeV/#it{c})");
fhDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
- fhDeltaPhiUeChargedPt = new TH2F
- ("hDeltaPhiUeChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}}",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
-
- fhUePart = new TH1F("hUePart","UE particles distribution vs pt trig",
- nptbins,ptmin,ptmax);
- fhUePart->SetYTitle("dNch");
- fhUePart->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
-
fhDeltaEtaCharged = new TH2F
("hDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #it{p}_{T trigger}",
nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
fhXECharged =
new TH2F("hXECharged","#it{x}_{#it{E}} for charged tracks",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXECharged->SetYTitle("#it{x}_{#it{E}}");
fhXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhXECharged_Cone2 =
new TH2F("hXECharged_Cone2","#it{x}_{#it{E}} for charged tracks in cone 2 (5#pi/6-7#pi/6)",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXECharged_Cone2->SetYTitle("#it{x}_{#it{E}}");
fhXECharged_Cone2->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhXEUeCharged =
- new TH2F("hXEUeCharged","#it{x}_{#it{E}} for Underlying Event",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
- fhXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
fhXEPosCharged =
new TH2F("hXEPositiveCharged","#it{x}_{#it{E}} for positive charged tracks",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEPosCharged->SetYTitle("#it{x}_{#it{E}}");
fhXEPosCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhXENegCharged =
new TH2F("hXENegativeCharged","#it{x}_{#it{E}} for negative charged tracks",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXENegCharged->SetYTitle("#it{x}_{#it{E}}");
fhXENegCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhPtHbpXECharged =
new TH2F("hHbpXECharged","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",
- nptbins,ptmin,ptmax,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhPtHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
fhPtHbpXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhPtHbpXECharged_Cone2 =
new TH2F("hHbpXECharged_Cone2","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons in cone 2 (5#pi/6-7#pi/6)",
- nptbins,ptmin,ptmax,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhPtHbpXECharged_Cone2->SetYTitle("ln(1/#it{x}_{#it{E}})");
fhPtHbpXECharged_Cone2->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhPtHbpXEUeCharged =
- new TH2F("hHbpXEUeCharged","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons,Underlying Event",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpXEUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhPtHbpXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
fhZTCharged =
new TH2F("hZTCharged","#it{z}_{T} for charged tracks",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTCharged->SetYTitle("#it{z}_{T}");
fhZTCharged->SetXTitle("#it{p}_{T trigger}");
- fhZTUeCharged =
- new TH2F("hZTUeCharged","#it{z}_{T} for Underlying Event",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTUeCharged->SetYTitle("#it{z}_{T}");
- fhZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
fhZTPosCharged =
new TH2F("hZTPositiveCharged","#it{z}_{T} for positive charged tracks",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTPosCharged->SetYTitle("#it{z}_{T}");
fhZTPosCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhZTNegCharged =
new TH2F("hZTNegativeCharged","#it{z}_{T} for negative charged tracks",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTNegCharged->SetYTitle("#it{z}_{T}");
fhZTNegCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhPtHbpZTCharged =
new TH2F("hHbpZTCharged","#xi = ln(1/#it{z}_{T}) with charged hadrons",
- nptbins,ptmin,ptmax,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhPtHbpZTCharged->SetYTitle("ln(1/#it{z}_{T})");
fhPtHbpZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhPtHbpZTUeCharged =
- new TH2F("hHbpZTUeCharged","#xi = ln(1/#it{z}_{T}) with charged hadrons,Underlying Event",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpZTUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhPtHbpZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
fhPtTrigPout =
new TH2F("hPtTrigPout","Pout with triggers",
- nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax);
+ nptbins,ptmin,ptmax,nptbins,-1.*ptmax/2.,ptmax/2.);
fhPtTrigPout->SetYTitle("#it{p}_{out} (GeV/#it{c})");
fhPtTrigPout->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhDeltaEtaCharged) ;
outputContainer->Add(fhDeltaEtaChargedPtA3GeV) ;
outputContainer->Add(fhDeltaPhiChargedPt) ;
- outputContainer->Add(fhDeltaPhiUeChargedPt) ;
- outputContainer->Add(fhUePart);
outputContainer->Add(fhXECharged) ;
outputContainer->Add(fhXECharged_Cone2) ;
+
if(IsDataMC())
{
for(Int_t i=0; i < 7; i++)
fhXEChargedMC[i] = new TH2F(Form("hXECharged_MC%s",nameMC[i].Data()),
Form("#it{x}_{#it{E}} for charged tracks, trigger origin is %s",nameMC[i].Data()),
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEChargedMC[i]->SetYTitle("#it{x}_{#it{E}}");
fhXEChargedMC[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhXEChargedMC[i]) ;
outputContainer->Add(fhXEPosCharged) ;
outputContainer->Add(fhXENegCharged) ;
- outputContainer->Add(fhXEUeCharged) ;
outputContainer->Add(fhPtHbpXECharged) ;
outputContainer->Add(fhPtHbpXECharged_Cone2) ;
- outputContainer->Add(fhPtHbpXEUeCharged) ;
outputContainer->Add(fhZTCharged) ;
outputContainer->Add(fhZTPosCharged) ;
outputContainer->Add(fhZTNegCharged) ;
- outputContainer->Add(fhZTUeCharged) ;
outputContainer->Add(fhPtHbpZTCharged) ;
- outputContainer->Add(fhPtHbpZTUeCharged) ;
outputContainer->Add(fhPtTrigPout) ;
outputContainer->Add(fhPtTrigCharged) ;
- if(fFillPileUpHistograms)
+ TString right = "";
+ if(fMakeSeveralUE) right = "Right";
+
+ fhUePart = new TH1F("hUePart","UE particles distribution vs pt trig",
+ nptbins,ptmin,ptmax);
+ fhUePart->SetYTitle("dNch");
+ fhUePart->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhDeltaPhiUeChargedPt = new TH2F
+ (Form("hDeltaPhiUe%sChargedPt",right.Data()),"#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}}",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiUeChargedPt->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
+
+ fhXEUeCharged =
+ new TH2F(Form("hXEUeCharged%s",right.Data()),"#it{x}_{#it{E}} for Underlying Event",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
+ fhXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhPtHbpXEUeCharged =
+ new TH2F(Form("hHbpXEUeCharged%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for Underlying Event",
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
+ fhPtHbpXEUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
+ fhPtHbpXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhZTUeCharged =
+ new TH2F(Form("hZTUeCharged%s",right.Data()),"#it{z}_{T} for Underlying Event",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhZTUeCharged->SetYTitle("#it{z}_{T}");
+ fhZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhPtHbpZTUeCharged =
+ new TH2F(Form("hHbpZTUeCharged%s",right.Data()),"#xi = ln(1/#it{z}_{T}) for Underlying Event",
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
+ fhPtHbpZTUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
+ fhPtHbpZTUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ outputContainer->Add(fhUePart);
+ outputContainer->Add(fhDeltaPhiUeChargedPt) ;
+ outputContainer->Add(fhXEUeCharged) ;
+ outputContainer->Add(fhPtHbpXEUeCharged) ;
+ outputContainer->Add(fhZTUeCharged) ;
+ outputContainer->Add(fhPtHbpZTUeCharged) ;
+
+ if(fMakeSeveralUE)
{
- fhDeltaPhiChargedOtherBC = new TH2F
- ("hDeltaPhiChargedOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC!=0",
+ fhDeltaPhiUeLeftCharged = new TH2F
+ ("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiChargedOtherBC->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiUeLeftCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
+ outputContainer->Add(fhDeltaPhiUeLeftCharged) ;
- fhDeltaPhiChargedPtA3GeVOtherBC = new TH2F
- ("hDeltaPhiChargedPtA3GeVOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC!=0",
+ fhDeltaPhiUeLeftUpCharged = new TH2F
+ ("hDeltaPhiUeLeftUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Up side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiChargedPtA3GeVOtherBC->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiChargedPtA3GeVOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiUeLeftUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
+ outputContainer->Add(fhDeltaPhiUeLeftUpCharged) ;
- fhPtTrigChargedOtherBC =
- new TH2F("hPtTrigChargedOtherBC","trigger and charged tracks pt distribution, track BC!=0",
- nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
- fhPtTrigChargedOtherBC->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
- fhPtTrigChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhDeltaPhiUeRightUpCharged = new TH2F
+ ("hDeltaPhiUeRightUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Up side range of trigger particles",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiUeRightUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
+ outputContainer->Add(fhDeltaPhiUeRightUpCharged) ;
- fhXEChargedOtherBC =
- new TH2F("hXEChargedOtherBC","#it{x}_{#it{E}} for charged tracks, track BC!=0",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEChargedOtherBC->SetYTitle("#it{x}_{#it{E}}");
- fhXEChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhDeltaPhiUeLeftDownCharged = new TH2F
+ ("hDeltaPhiUeLeftDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Down side range of trigger particles",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiUeLeftDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
+ outputContainer->Add(fhDeltaPhiUeLeftDownCharged) ;
- fhXEUeChargedOtherBC =
- new TH2F("hXEUeChargedOtherBC","#it{x}_{#it{E}} for Underlying Event, track BC!=0",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeChargedOtherBC->SetYTitle("#it{x}_{#it{E}}");
- fhXEUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhDeltaPhiUeRightDownCharged = new TH2F
+ ("hDeltaPhiUeRightDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Down side range of trigger particles",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiUeRightDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
+ outputContainer->Add(fhDeltaPhiUeRightDownCharged) ;
- fhZTChargedOtherBC =
- new TH2F("hZTChargedOtherBC","#it{z}_{T} for charged tracks, track BC!=0",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTChargedOtherBC->SetYTitle("#it{z}_{T}");
- fhZTChargedOtherBC->SetXTitle("#it{p}_{T trigger}");
+ fhXEUeLeftCharged =
+ new TH2F("hXEUeChargedLeft","#it{x}_{#it{E}} with UE left side of trigger",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEUeLeftCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
+ fhXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ outputContainer->Add(fhXEUeLeftCharged) ;
- fhZTUeChargedOtherBC =
- new TH2F("hZTUeChargedOtherBC","#it{z}_{T} for Underlying Event, track BC!=0",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTUeChargedOtherBC->SetYTitle("#it{z}_{T}");
- fhZTUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhXEUeLeftUpCharged =
+ new TH2F("hXEUeChargedLeftUp","#it{x}_{#it{E}} with UE left Up side of trigger",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEUeLeftUpCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
+ fhXEUeLeftUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ outputContainer->Add(fhXEUeLeftUpCharged) ;
+
+ fhXEUeRightUpCharged =
+ new TH2F("hXEUeChargedRightUp","#it{x}_{#it{E} h^{#pm}} with UE right Up side of trigger",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEUeRightUpCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
+ fhXEUeRightUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ outputContainer->Add(fhXEUeRightUpCharged) ;
+
+ fhXEUeLeftDownCharged =
+ new TH2F("hXEUeChargedLeftDown","#it{x}_{#it{E}} with UE left Down side of trigger",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEUeLeftDownCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
+ fhXEUeLeftDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ outputContainer->Add(fhXEUeLeftDownCharged) ;
+
+ fhXEUeRightDownCharged =
+ new TH2F("hXEUeChargedRightDown","#it{x}_{#it{E} h^{#pm}} with UE right Down side of trigger",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEUeRightDownCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
+ fhXEUeRightDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ outputContainer->Add(fhXEUeRightDownCharged) ;
+
+ fhPtHbpXEUeLeftCharged =
+ new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/#it{x}_{#it{E}}) with charged UE left side of trigger",
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
+ fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
+ fhPtHbpXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ outputContainer->Add(fhPtHbpXEUeLeftCharged) ;
+
+ fhZTUeLeftCharged =
+ new TH2F("hZTUeChargedLeft","#it{z}_{trigger h^{#pm}} = #it{p}_{T Ueh^{#pm}} / #it{p}_{T trigger} with UE left side of trigger",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhZTUeLeftCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
+ fhZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ outputContainer->Add(fhZTUeLeftCharged) ;
+
+ fhPtHbpZTUeLeftCharged =
+ new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/#it{z}_{T}) with charged UE left side of trigger",
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
+ fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/#it{z}_{T})");
+ fhPtHbpZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ outputContainer->Add(fhPtHbpZTUeLeftCharged) ;
+ }
+
+ if(fFillPileUpHistograms)
+ {
+ fhDeltaPhiChargedOtherBC = new TH2F
+ ("hDeltaPhiChargedOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, track BC!=0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedOtherBC->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhDeltaPhiChargedPtA3GeVOtherBC = new TH2F
+ ("hDeltaPhiChargedPtA3GeVOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs #it{p}_{T trigger}, #it{p}_{TA}>3 GeV/#it{c}, track BC!=0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedPtA3GeVOtherBC->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedPtA3GeVOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhPtTrigChargedOtherBC =
+ new TH2F("hPtTrigChargedOtherBC","trigger and charged tracks pt distribution, track BC!=0",
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhPtTrigChargedOtherBC->SetYTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
+ fhPtTrigChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhXEChargedOtherBC =
+ new TH2F("hXEChargedOtherBC","#it{x}_{#it{E}} for charged tracks, track BC!=0",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEChargedOtherBC->SetYTitle("#it{x}_{#it{E}}");
+ fhXEChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhXEUeChargedOtherBC =
+ new TH2F("hXEUeChargedOtherBC","#it{x}_{#it{E}} for Underlying Event, track BC!=0",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEUeChargedOtherBC->SetYTitle("#it{x}_{#it{E}}");
+ fhXEUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhZTChargedOtherBC =
+ new TH2F("hZTChargedOtherBC","#it{z}_{T} for charged tracks, track BC!=0",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhZTChargedOtherBC->SetYTitle("#it{z}_{T}");
+ fhZTChargedOtherBC->SetXTitle("#it{p}_{T trigger}");
+
+ fhZTUeChargedOtherBC =
+ new TH2F("hZTUeChargedOtherBC","#it{z}_{T} for Underlying Event, track BC!=0",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhZTUeChargedOtherBC->SetYTitle("#it{z}_{T}");
+ fhZTUeChargedOtherBC->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhDeltaPhiChargedOtherBC) ;
outputContainer->Add(fhDeltaPhiChargedPtA3GeVOtherBC) ;
fhXEChargedBC0 =
new TH2F("hXEChargedBC0","#it{x}_{#it{E}} for charged tracks, track BC==0",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEChargedBC0->SetYTitle("#it{x}_{#it{E}}");
fhXEChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhXEUeChargedBC0 =
new TH2F("hXEUeChargedBC0","#it{x}_{#it{E}} for Underlying Event, track BC==0",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEUeChargedBC0->SetYTitle("#it{x}_{#it{E}}");
fhXEUeChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhZTChargedBC0 =
new TH2F("hZTChargedBC0","#it{z}_{T} for charged tracks, track BC==0",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTChargedBC0->SetYTitle("#it{z}_{T}");
fhZTChargedBC0->SetXTitle("#it{p}_{T trigger}");
fhZTUeChargedBC0 =
new TH2F("hZTUeChargedBC0","#it{z}_{T} for Underlying Event, track BC==0",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTUeChargedBC0->SetYTitle("#it{z}_{T}");
fhZTUeChargedBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhXEChargedVtxBC0 =
new TH2F("hXEChargedVtxBC0","#it{x}_{#it{E}} for charged tracks, track BC==0",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEChargedVtxBC0->SetYTitle("#it{x}_{#it{E}}");
fhXEChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhXEUeChargedVtxBC0 =
new TH2F("hXEUeChargedVtxBC0","#it{x}_{#it{E}} for Underlying Event, track BC==0",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEUeChargedVtxBC0->SetYTitle("#it{x}_{#it{E}}");
fhXEUeChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhZTChargedVtxBC0 =
new TH2F("hZTChargedVtxBC0","#it{z}_{T} for charged tracks, track BC==0",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTChargedVtxBC0->SetYTitle("#it{z}_{T}");
fhZTChargedVtxBC0->SetXTitle("#it{p}_{T trigger}");
fhZTUeChargedVtxBC0 =
new TH2F("hZTUeChargedVtxBC0","#it{z}_{T} for Underlying Event, track BC==0",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTUeChargedVtxBC0->SetYTitle("#it{z}_{T}");
fhZTUeChargedVtxBC0->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhXEChargedPileUp[i] = new TH2F(Form("hXEChargedPileUp%s",pileUpName[i].Data()),
Form("#it{x}_{#it{E}} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEChargedPileUp[i]->SetYTitle("#it{x}_{#it{E}}");
fhXEChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhXEChargedPileUp[i]) ;
fhXEUeChargedPileUp[i] = new TH2F(Form("hXEUeChargedPileUp%s",pileUpName[i].Data()),
Form("#it{x}_{#it{E}} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEUeChargedPileUp[i]->SetYTitle("#it{x}_{#it{E}}");
fhXEUeChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhXEUeChargedPileUp[i]) ;
fhZTChargedPileUp[i] = new TH2F(Form("hZTChargedPileUp%s",pileUpName[i].Data()),
Form("#it{z}_{T} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTChargedPileUp[i]->SetYTitle("#it{z}_{T}");
fhZTChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhZTChargedPileUp[i]) ;
fhZTUeChargedPileUp[i] = new TH2F(Form("hZTUeChargedPileUp%s",pileUpName[i].Data()),
Form("#it{z}_{T} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTUeChargedPileUp[i]->SetYTitle("#it{z}_{T}");
fhZTUeChargedPileUp[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhZTUeChargedPileUp[i]) ;
}
}
-
+
if(fFillHighMultHistograms)
{
Int_t nMultiBins = GetNCentrBin();
fhDeltaEtaChargedMult[im]->SetYTitle("#Delta #eta");
fhXEMult[im] = new TH2F
- (Form("hXECharged_Mult%d",im),Form("#it{x}_{E} charged Mult bin %d",im), nptbins,ptmin,ptmax,200,0.,2.);
+ (Form("hXECharged_Mult%d",im),Form("#it{x}_{E} charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEMult[im]->SetYTitle("#it{x}_{E}");
fhXEMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhXEUeMult[im] = new TH2F
- (Form("hXEUeCharged_Mult%d",im),Form("#it{x}_{E} UE charged Mult bin %d",im), nptbins,ptmin,ptmax,200,0.,2.);
+ (Form("hXEUeCharged_Mult%d",im),Form("#it{x}_{E} UE charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEUeMult[im]->SetYTitle("#it{x}_{E}");
fhXEUeMult[im]->SetXTitle("#it{p}_{T trigger}(GeV/#it{c})");
fhZTMult[im] = new TH2F
- (Form("hZTCharged_Mult%d",im),Form("#it{z}_{T} charged Mult bin %d",im), nptbins,ptmin,ptmax,200,0.,2.);
+ (Form("hZTCharged_Mult%d",im),Form("#it{z}_{T} charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTMult[im]->SetYTitle("#it{z}_{T}");
fhZTMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhZTUeMult[im] = new TH2F
- (Form("hZTUeCharged_Mult%d",im),Form("#it{z}_{T} UE charged Mult bin %d",im), nptbins,ptmin,ptmax,200,0.,2.);
+ (Form("hZTUeCharged_Mult%d",im),Form("#it{z}_{T} UE charged Mult bin %d",im), nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTUeMult[im]->SetYTitle("#it{z}_{T}");
fhZTUeMult[im]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhDeltaPhiAssocPtBin = new TH2F*[fNAssocPtBins*nz];
fhDeltaPhiAssocPtBinDEta08 = new TH2F*[fNAssocPtBins*nz];
fhDeltaPhiAssocPtBinDEta0 = new TH2F*[fNAssocPtBins*nz];
- fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz];
- fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz];
+ if(fFillMomImbalancePtAssocBinsHisto)
+ {
+ fhXEAssocPtBin = new TH2F*[fNAssocPtBins*nz];
+ fhZTAssocPtBin = new TH2F*[fNAssocPtBins*nz];
+ }
+
+ if(fCorrelVzBin)
+ {
+ fhXEVZ = new TH2F*[nz];
+ fhZTVZ = new TH2F*[nz];
+ }
if(fFillBradHisto)
fhDeltaPhiBradAssocPtBin = new TH2F*[fNAssocPtBins*nz];
fhDeltaPhiAssocPtBinHMPID = new TH2F*[fNAssocPtBins*nz];
fhDeltaPhiAssocPtBinHMPIDAcc= new TH2F*[fNAssocPtBins*nz];
}
-
+
for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
{
for(Int_t z = 0 ; z < nz ; z++)
fhDeltaPhiAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhDeltaPhiAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiAssocPtBinDEta08[bin] = new TH2F(Form("hDeltaPhiDeltaEta0.8PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
- Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
- nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhDeltaPhiAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
-
- fhDeltaPhiAssocPtBinDEta0[bin] = new TH2F(Form("hDeltaPhiDeltaEta0PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
- Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0.", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
- nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhDeltaPhiAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
-
- fhXEAssocPtBin[bin] = new TH2F(Form("hXEAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
- Form("#it{x}_{#it{E}} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
- nptbins, ptmin, ptmax,200, 0.0, 2.0);
- fhXEAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhXEAssocPtBin[bin]->SetYTitle("#it{x}_{#it{E}}");
-
- fhZTAssocPtBin[bin] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
- Form("#it{z}_{T} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
- nptbins, ptmin, ptmax,200, 0.0, 2.0);
- fhZTAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhZTAssocPtBin[bin]->SetYTitle("#it{z}_{T}");
-
outputContainer->Add(fhDeltaPhiDeltaEtaAssocPtBin[bin]) ;
outputContainer->Add(fhDeltaPhiAssocPtBin[bin]) ;
- outputContainer->Add(fhDeltaPhiAssocPtBinDEta08[bin]) ;
- outputContainer->Add(fhDeltaPhiAssocPtBinDEta0[bin]) ;
- outputContainer->Add(fhXEAssocPtBin[bin]);
- outputContainer->Add(fhZTAssocPtBin[bin]);
+
+ if(fFillEtaGapsHisto)
+ {
+ fhDeltaPhiAssocPtBinDEta08[bin] = new TH2F(Form("hDeltaPhiDeltaEta0.8PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
+ Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
+ nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhDeltaPhiAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
+
+ fhDeltaPhiAssocPtBinDEta0[bin] = new TH2F(Form("hDeltaPhiDeltaEta0PtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
+ Form("#Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0.", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
+ nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhDeltaPhiAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
+
+ outputContainer->Add(fhDeltaPhiAssocPtBinDEta08[bin]) ;
+ outputContainer->Add(fhDeltaPhiAssocPtBinDEta0[bin]) ;
+ }
if(fPi0Trigger || fDecayTrigger)
{
fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetYTitle("#Delta #phi (rad)");
- outputContainer->Add(fhDeltaPhiAssocPtBinHMPID[bin]) ;
+ outputContainer->Add(fhDeltaPhiAssocPtBinHMPID [bin]) ;
outputContainer->Add(fhDeltaPhiAssocPtBinHMPIDAcc[bin]) ;
-
}
}
}
+ if(fFillMomImbalancePtAssocBinsHisto)
+ {
+ for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
+ {
+ fhXEAssocPtBin[i] = new TH2F(Form("hXEAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
+ Form("#it{x}_{#it{E}} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
+ nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEAssocPtBin[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhXEAssocPtBin[i]->SetYTitle("#it{x}_{#it{E}}");
+
+ fhZTAssocPtBin[i] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
+ Form("#it{z}_{T} vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1]),
+ nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax);
+ fhZTAssocPtBin[i]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhZTAssocPtBin[i]->SetYTitle("#it{z}_{T}");
+
+
+ outputContainer->Add(fhXEAssocPtBin[i]);
+ outputContainer->Add(fhZTAssocPtBin[i]);
+ }
+ }
+
+ if(fCorrelVzBin)
+ {
+ for(Int_t z = 0 ; z < nz ; z++)
+ {
+ sz = Form("_vz%d",z);
+ tz = Form(", #it{v}_{#it{z}} bin %d",z);
+
+ fhXEVZ[z] = new TH2F(Form("hXE%s", sz.Data()),
+ Form("#it{x}_{#it{E}} vs #it{p}_{T trigger}%s", tz.Data()),
+ nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEVZ[z]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhXEVZ[z]->SetYTitle("#it{x}_{#it{E}}");
+
+ fhZTVZ[z] = new TH2F(Form("hZT%s",sz.Data()),
+ Form("#it{z}_{T} vs #it{p}_{T trigger}%s", tz.Data()),
+ nptbins, ptmin, ptmax,nxeztbins,xeztmin,xeztmax);
+ fhZTVZ[z]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhZTVZ[z]->SetYTitle("#it{z}_{T}");
+
+ outputContainer->Add(fhXEVZ[z]);
+ outputContainer->Add(fhZTVZ[z]);
+ }
+ }
+
if(fPi0Trigger || fDecayTrigger)
{
if(fPi0Trigger)
fhXEDecayCharged =
new TH2F("hXEDecayCharged","#it{x}_{#it{E}} Decay",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEDecayCharged->SetYTitle("#it{x}_{#it{E}}");
fhXEDecayCharged->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}",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTDecayCharged->SetYTitle("#it{z}_{decay h^{#pm}}");
fhZTDecayCharged->SetXTitle("#it{p}_{T decay} (GeV/#it{c})");
outputContainer->Add(fhZTDecayCharged) ;
}
- if(fMakeSeveralUE)
- {
- fhDeltaPhiUeLeftCharged = new TH2F
- ("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left side range of trigger particles",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeLeftCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
- outputContainer->Add(fhDeltaPhiUeLeftCharged) ;
-
- fhDeltaPhiUeRightCharged = new TH2F
- ("hDeltaPhiUeRightChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right side range of trigger particles",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeRightCharged->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeRightCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
- outputContainer->Add(fhDeltaPhiUeRightCharged) ;
-
- fhDeltaPhiUeLeftUpCharged = new TH2F
- ("hDeltaPhiUeLeftUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Up side range of trigger particles",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeLeftUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
- outputContainer->Add(fhDeltaPhiUeLeftUpCharged) ;
-
- fhDeltaPhiUeRightUpCharged = new TH2F
- ("hDeltaPhiUeRightUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Up side range of trigger particles",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeRightUpCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
- outputContainer->Add(fhDeltaPhiUeRightUpCharged) ;
-
- fhDeltaPhiUeLeftDownCharged = new TH2F
- ("hDeltaPhiUeLeftDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE left Down side range of trigger particles",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeLeftDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
- outputContainer->Add(fhDeltaPhiUeLeftDownCharged) ;
-
- fhDeltaPhiUeRightDownCharged = new TH2F
- ("hDeltaPhiUeRightDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs #it{p}_{T Ueh^{#pm}} with UE right Down side range of trigger particles",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeRightDownCharged->SetXTitle("#it{p}_{T h^{#pm}} (GeV/#it{c})");
- outputContainer->Add(fhDeltaPhiUeRightDownCharged) ;
-
- fhXEUeLeftCharged =
- new TH2F("hXEUeChargedLeft","#it{x}_{#it{E}} with UE left side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeLeftCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
- fhXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhXEUeLeftCharged) ;
-
- fhXEUeRightCharged =
- new TH2F("hXEUeChargedRight","#it{x}_{#it{E} h^{#pm}} with UE right side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeRightCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
- fhXEUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhXEUeRightCharged) ;
-
- fhXEUeLeftUpCharged =
- new TH2F("hXEUeChargedLeftUp","#it{x}_{#it{E}} with UE left Up side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeLeftUpCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
- fhXEUeLeftUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhXEUeLeftUpCharged) ;
-
- fhXEUeRightUpCharged =
- new TH2F("hXEUeChargedRightUp","#it{x}_{#it{E} h^{#pm}} with UE right Up side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeRightUpCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
- fhXEUeRightUpCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhXEUeRightUpCharged) ;
-
- fhXEUeLeftDownCharged =
- new TH2F("hXEUeChargedLeftDown","#it{x}_{#it{E}} with UE left Down side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeLeftDownCharged->SetYTitle("#it{x}_{#it{E} Ueh^{#pm}}");
- fhXEUeLeftDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhXEUeLeftDownCharged) ;
-
- fhXEUeRightDownCharged =
- new TH2F("hXEUeChargedRightDown","#it{x}_{#it{E} h^{#pm}} with UE right Down side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeRightDownCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
- fhXEUeRightDownCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhXEUeRightDownCharged) ;
-
- fhPtHbpXEUeLeftCharged =
- new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/#it{x}_{#it{E}}) with charged UE left side of trigger",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhPtHbpXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhPtHbpXEUeLeftCharged) ;
-
- fhPtHbpXEUeRightCharged =
- new TH2F("hHbpXEUeChargedRight","#xi = ln(1/#it{x}_{#it{E}}) with charged UE right side of trigger",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpXEUeRightCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhPtHbpXEUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhPtHbpXEUeRightCharged) ;
-
- fhZTUeLeftCharged =
- new TH2F("hZTUeChargedLeft","#it{z}_{trigger h^{#pm}} = #it{p}_{T Ueh^{#pm}} / #it{p}_{T trigger} with UE left side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTUeLeftCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
- fhZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhZTUeLeftCharged) ;
-
- fhZTUeRightCharged =
- new TH2F("hZTUeChargedRight","#it{z}_{trigger h^{#pm}} = #it{p}_{T Ueh^{#pm}} / #it{p}_{T trigger} with UE right side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTUeRightCharged->SetYTitle("#it{z}_{trigger Ueh^{#pm}}");
- fhZTUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhZTUeRightCharged) ;
-
- fhPtHbpZTUeLeftCharged =
- new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/#it{z}_{T}) with charged UE left side of trigger",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/#it{z}_{T})");
- fhPtHbpZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhPtHbpZTUeLeftCharged) ;
-
- fhPtHbpZTUeRightCharged =
- new TH2F("hHbpZTUeChargedRight","#xi = ln(1/#it{z}_{T}) with charged UE right side of trigger",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpZTUeRightCharged->SetYTitle("ln(1/#it{z}_{T})");
- fhPtHbpZTUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhPtHbpZTUeRightCharged) ;
-
- }
-
//Correlation with neutral hadrons
if(fNeutralCorr)
{
fhPhiNeutral = new TH2F
("hPhiNeutral","#phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}",
- nptbins,ptmin,ptmax,nphibins,phimin,phimax);
+ nptbins,ptmin,ptmax,180,0,TMath::TwoPi());
fhPhiNeutral->SetYTitle("#phi_{#pi^{0}} (rad)");
fhPhiNeutral->SetXTitle("#it{p}_{T #pi^{0}} (GeV/#it{c})");
fhEtaNeutral = new TH2F
("hEtaNeutral","#eta_{#pi^{0}} vs #it{p}_{T #pi^{0}}",
- nptbins,ptmin,ptmax,netabins,etamin,etamax);
+ nptbins,ptmin,ptmax,200,-1.,1.);
fhEtaNeutral->SetYTitle("#eta_{#pi^{0}} (rad)");
fhEtaNeutral->SetXTitle("#it{p}_{T #pi^{0}} (GeV/#it{c})");
fhDeltaPhiNeutral = new TH2F
("hDeltaPhiNeutral","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T trigger}",
- nptbins,ptmin,ptmax,nphibins,phimin,phimax);
+ nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
fhDeltaPhiNeutral->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
- fhDeltaPhiUeNeutralPt = new TH2F
- ("hDeltaPhiUeNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}}",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
-
fhDeltaEtaNeutral = new TH2F
("hDeltaEtaNeutral","#eta_{trigger} - #eta_{#pi^{0}} vs #it{p}_{T trigger}",
nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
fhXENeutral =
new TH2F("hXENeutral","#it{x}_{#it{E}} for #pi^{0} associated",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXENeutral->SetYTitle("#it{x}_{#it{E}}");
fhXENeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhXEUeNeutral =
- new TH2F("hXEUeNeutral","#it{x}_{#it{E}} for #pi^{0} associated",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeNeutral->SetYTitle("#it{x}_{#it{E}}");
- fhXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
fhPtHbpXENeutral =
new TH2F("hHbpXENeutral","#xi = ln(1/#it{x}_{#it{E}})for #pi^{0} associated",
- nptbins,ptmin,ptmax,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhPtHbpXENeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
fhPtHbpXENeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhPtHbpXEUeNeutral =
- new TH2F("hHbpXEUeNeutral","#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
fhZTNeutral =
new TH2F("hZTNeutral","#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}");
fhZTNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhZTUeNeutral =
- new TH2F("hZTUeNeutral","#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTUeNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}");
- fhZTUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
fhPtHbpZTNeutral =
new TH2F("hHbpZTNeutral","#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
- nptbins,ptmin,ptmax,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhPtHbpZTNeutral->SetYTitle("ln(1/#it{z}_{T})");
fhPtHbpZTNeutral->SetXTitle("#it{p}_{T trigger}");
- fhPtHbpZTUeNeutral =
- new TH2F("hHbpZTUeNeutral","#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{z}_{T})");
- fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
outputContainer->Add(fhDeltaPhiDeltaEtaNeutral);
outputContainer->Add(fhPhiNeutral) ;
outputContainer->Add(fhEtaNeutral) ;
outputContainer->Add(fhDeltaPhiNeutral) ;
outputContainer->Add(fhDeltaPhiNeutralPt) ;
- outputContainer->Add(fhDeltaPhiUeNeutralPt) ;
outputContainer->Add(fhDeltaEtaNeutral) ;
outputContainer->Add(fhXENeutral) ;
- outputContainer->Add(fhXEUeNeutral) ;
outputContainer->Add(fhPtHbpXENeutral) ;
- outputContainer->Add(fhPtHbpXEUeNeutral) ;
outputContainer->Add(fhZTNeutral) ;
- outputContainer->Add(fhZTUeNeutral) ;
outputContainer->Add(fhPtHbpZTNeutral) ;
- outputContainer->Add(fhPtHbpZTUeNeutral) ;
- if(fPi0Trigger || fDecayTrigger)
- {
- fhDeltaPhiDecayNeutral = new TH2F
- ("hDeltaPhiDecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs #it{p}_{T Decay}",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiDecayNeutral->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiDecayNeutral->SetXTitle("#it{p}_{T Decay} (GeV/#it{c})");
-
- fhXEDecayNeutral =
- new TH2F("hXEDecayNeutral","#it{x}_{#it{E}} for decay trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEDecayNeutral->SetYTitle("#it{x}_{#it{E}}");
- fhXEDecayNeutral->SetXTitle("#it{p}_{T decay}");
-
- fhZTDecayNeutral =
- new TH2F("hZTDecayNeutral","#it{z}_{trigger h^{0}} = #it{p}_{T h^{0}} / #it{p}_{T Decay}",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTDecayNeutral->SetYTitle("#it{z}_{h^{0}}");
- fhZTDecayNeutral->SetXTitle("#it{p}_{T decay}");
-
- outputContainer->Add(fhDeltaPhiDecayNeutral) ;
- outputContainer->Add(fhXEDecayNeutral) ;
- outputContainer->Add(fhZTDecayNeutral) ;
-
- }
+ fhDeltaPhiUeNeutralPt = new TH2F
+ (Form("hDeltaPhiUe%sNeutralPt",right.Data()),"#phi_{trigger} - #phi_{#pi^{0}} vs #it{p}_{T #pi^{0}}}",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiUeNeutralPt->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
+ fhXEUeNeutral =
+ new TH2F(Form("hXEUeNeutral%s",right.Data()),"#it{x}_{#it{E}} for #pi^{0} associated",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhXEUeNeutral->SetYTitle("#it{x}_{#it{E}}");
+ fhXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhPtHbpXEUeNeutral =
+ new TH2F(Form("hHbpXEUeNeutral%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
+ fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
+ fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhZTUeNeutral =
+ new TH2F(Form("hZTUeNeutral%s",right.Data()),"#it{z}_{trigger #pi} = #it{p}_{T #pi^{0}} / #it{p}_{T trigger} for #pi^{0} associated",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhZTUeNeutral->SetYTitle("#it{z}_{trigger #pi^{0}}");
+ fhZTUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ fhPtHbpZTUeNeutral =
+ new TH2F(Form("hHbpZTUeNeutral%s",right.Data()),"#xi = ln(1/#it{x}_{#it{E}}) for #pi^{0} associated",
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
+ fhPtHbpXEUeNeutral->SetYTitle("ln(1/#it{z}_{T})");
+ fhPtHbpXEUeNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+
+ outputContainer->Add(fhDeltaPhiUeNeutralPt) ;
+ outputContainer->Add(fhXEUeNeutral) ;
+ outputContainer->Add(fhPtHbpXEUeNeutral) ;
+ outputContainer->Add(fhZTUeNeutral) ;
+ outputContainer->Add(fhPtHbpZTUeNeutral) ;
+
if(fMakeSeveralUE)
{
fhDeltaPhiUeLeftNeutral = new TH2F
fhDeltaPhiUeLeftNeutral->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
outputContainer->Add(fhDeltaPhiUeLeftNeutral) ;
- fhDeltaPhiUeRightNeutral = new TH2F
- ("hDeltaPhiUeRightNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs #it{p}_{T Ueh^{0}} with neutral UE right side range of trigger particles",
- nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeRightNeutral->SetYTitle("#Delta #phi (rad)");
- fhDeltaPhiUeRightNeutral->SetXTitle("#it{p}_{T h^{0}} (GeV/#it{c})");
- outputContainer->Add(fhDeltaPhiUeRightNeutral) ;
-
fhXEUeLeftNeutral =
new TH2F("hXEUeNeutralLeft","#it{x}_{#it{E}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE left side of trigger",
- nptbins,ptmin,ptmax,140,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhXEUeLeftNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
fhXEUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhXEUeLeftNeutral) ;
- fhXEUeRightNeutral =
- new TH2F("hXEUeNeutralRight","#it{x}_{#it{E}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE right side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeRightNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
- fhXEUeRightNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhXEUeRightNeutral) ;
-
fhPtHbpXEUeLeftNeutral =
new TH2F("hHbpXEUeNeutralLeft","#xi = ln(1/#it{x}_{#it{E}}) with neutral UE left side of trigger",
- nptbins,ptmin,ptmax,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhPtHbpXEUeLeftNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
fhPtHbpXEUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhPtHbpXEUeLeftNeutral) ;
- fhPtHbpXEUeRightNeutral =
- new TH2F("hHbpXEUeNeutralRight","#xi = ln(1/#it{x}_{#it{E}}) with neutral UE right side of trigger",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpXEUeRightNeutral->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhPtHbpXEUeRightNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhPtHbpXEUeRightNeutral) ;
-
fhZTUeLeftNeutral =
new TH2F("hZTUeNeutralLeft","#it{z}_{trigger h^{0}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE left side of trigger",
- nptbins,ptmin,ptmax,140,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhZTUeLeftNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
fhZTUeLeftNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhZTUeLeftNeutral) ;
- fhZTUeRightNeutral =
- new TH2F("hZTUeNeutralRight","#it{z}_{trigger h^{0}} = #it{p}_{T Ueh^{0}} / #it{p}_{T trigger} with neutral UE right side of trigger",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTUeRightNeutral->SetYTitle("#it{z}_{trigger Ueh^{0}}");
- fhZTUeRightNeutral->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- outputContainer->Add(fhZTUeRightNeutral) ;
-
fhPtHbpZTUeLeftNeutral =
new TH2F("hHbpZTUeNeutralLeft","#xi = ln(1/#it{z}_{T}) with neutral UE left side of trigger",
- nptbins,ptmin,ptmax,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhPtHbpZTUeLeftNeutral->SetYTitle("ln(1/#it{z}_{T})");
fhPtHbpZTUeLeftNeutral->SetXTitle("#it{p}_{T trigger}");
outputContainer->Add(fhPtHbpZTUeLeftNeutral) ;
+ }
+
+ if(fPi0Trigger || fDecayTrigger)
+ {
+ fhDeltaPhiDecayNeutral = new TH2F
+ ("hDeltaPhiDecayNeutral","#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})");
+
+ fhXEDecayNeutral =
+ new TH2F("hXEDecayNeutral","#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}");
+
+ fhZTDecayNeutral =
+ new TH2F("hZTDecayNeutral","#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}");
- fhPtHbpZTUeRightNeutral =
- new TH2F("hHbpZTUeNeutralRight","#xi = ln(1/#it{z}_{T}) with neutral UE right side of trigger",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhPtHbpZTUeRightNeutral->SetYTitle("ln(1/#it{z}_{T})");
- fhPtHbpZTUeRightNeutral->SetXTitle("#it{p}_{T trigger}");
- outputContainer->Add(fhPtHbpZTUeRightNeutral) ;
+ outputContainer->Add(fhDeltaPhiDecayNeutral) ;
+ outputContainer->Add(fhXEDecayNeutral) ;
+ outputContainer->Add(fhZTDecayNeutral) ;
}
-
}//Correlation with neutral hadrons
//if data is MC, fill more histograms
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 : #it{p}_{T} distribution of trigger particles", nptbins,ptmin,ptmax);
+ 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 : #phi distribution of trigger Particles",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
+ fhMCPhiTrigger = new TH2F ("hMCPhiTrigger","MC : trigger #phi",nptbins,ptmin,ptmax, nphibins,phimin,phimax);
fhMCPhiTrigger->SetYTitle("#phi (rad)");
-
- fhMCEtaTrigger = new TH2F ("hMCEtaTrigger","MC : #eta distribution of trigger",nptbins,ptmin,ptmax, netabins,etamin,etamax);
- fhMCEtaTrigger->SetYTitle("#eta ");
-
+ 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)
+ {
+ 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})");
+
+ 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})");
+
+
+ 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,netabins,etamin,etamax);
+ 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}",
- 200,ptmin,ptmax,nphibins,phimin,phimax);
+ 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}}",
- 140,-2.,5.,200,-2,2);
+ 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,200,-2,2);
+ nptbins,ptmin,ptmax,ndeltaetabins ,deltaetamin,deltaetamax);
fhMCDeltaEtaCharged->SetYTitle("#Delta #eta");
fhMCDeltaEtaCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
fhMCPtXECharged =
new TH2F("hMCPtXECharged","#it{x}_{#it{E}} with charged hadrons",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhMCPtXECharged->SetYTitle("#it{x}_{#it{E}}");
fhMCPtXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhMCPtXEUeCharged =
- new TH2F("hMCPtXEUeCharged","#it{x}_{#it{E}} with charged hadrons, Underlying Event",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhMCPtXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
- fhMCPtXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtXEUeLeftCharged =
- new TH2F("hMCPtXEUeChargedLeft","#it{x}_{#it{E}} with charged hadrons, with UE left side range of trigger particles",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhMCPtXEUeLeftCharged->SetYTitle("#it{x}_{#it{E}}");
- fhMCPtXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtXEUeRightCharged =
- new TH2F("hMCPtXEUeChargedRight","#it{x}_{#it{E}} with charged hadrons, with UE left side range of trigger particles",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhMCPtXEUeRightCharged->SetYTitle("#it{x}_{#it{E}}");
- fhMCPtXEUeRightCharged->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,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhMCPtHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
fhMCPtHbpXECharged->SetXTitle("#it{p}_{T trigger}");
- fhMCPtHbpXEUeCharged =
- new TH2F("hMCPtHbpXEUeCharged","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, Underlying Event",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhMCPtHbpXEUeCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhMCPtHbpXEUeCharged->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",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhMCPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhMCPtHbpXEUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtHbpXEUeRightCharged =
- new TH2F("hMCPtHbpXEUeChargedRight","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, with UE right side range of trigger particles",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhMCPtHbpXEUeRightCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
- fhMCPtHbpXEUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
-
- 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})");
-
fhMCPtZTCharged =
new TH2F("hMCPtZTCharged","#it{z}_{T} with charged hadrons",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhMCPtZTCharged->SetYTitle("#it{z}_{T}");
- fhMCPtZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtZTUeCharged =
- new TH2F("hMCPtZTUeCharged","#it{z}_{T} with charged hadrons, Underlying Event",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhMCPtZTUeCharged->SetYTitle("#it{z}_{T}");
- fhMCPtZTUeCharged->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",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhMCPtZTUeLeftCharged->SetYTitle("#it{z}_{T}");
- fhMCPtZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtZTUeRightCharged =
- new TH2F("hMCPtZTUeChargedRight","#it{z}_{T} with charged hadrons, with UE right side range of trigger particles",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhMCPtZTUeRightCharged->SetYTitle("#it{z}_{T}");
- fhMCPtZTUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ 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,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhMCPtHbpZTCharged->SetYTitle("ln(1/#it{z}_{T})");
fhMCPtHbpZTCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhMCPtHbpZTUeCharged =
- new TH2F("hMCPtHbpZTUeCharged","#xi = ln(1/#it{z}_{T}) with charged hadrons, Underlying Event",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhMCPtHbpZTUeCharged->SetYTitle("ln(1/#it{z}_{T})");
- fhMCPtHbpZTUeCharged->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",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhMCPtHbpZTUeLeftCharged->SetYTitle("ln(1/#it{z}_{T})");
- fhMCPtHbpZTUeLeftCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
- fhMCPtHbpZTUeRightCharged =
- new TH2F("hMCPtHbpZTUeChargedRight","#xi = ln(1/#it{z}_{T}) with charged hadrons, with UE right side range of trigger particles",
- nptbins,ptmin,ptmax,200,0.,10.);
- fhMCPtHbpZTUeRightCharged->SetYTitle("ln(1/#it{z}_{T})");
- fhMCPtHbpZTUeRightCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
-
fhMCPtTrigPout =
new TH2F("hMCPtTrigPout","AOD MC Pout with triggers",
- nptbins,ptmin,ptmax,2*nptbins,-ptmax,ptmax);
+ 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->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(fhMCDeltaPhiChargedPt) ;
outputContainer->Add(fhMCPtXECharged) ;
- outputContainer->Add(fhMCPtXEUeCharged) ;
- outputContainer->Add(fhMCPtXEUeLeftCharged) ;
- outputContainer->Add(fhMCPtXEUeRightCharged) ;
outputContainer->Add(fhMCPtZTCharged) ;
- outputContainer->Add(fhMCPtZTUeCharged) ;
- outputContainer->Add(fhMCPtZTUeLeftCharged) ;
- outputContainer->Add(fhMCPtZTUeRightCharged) ;
outputContainer->Add(fhMCPtHbpXECharged) ;
- outputContainer->Add(fhMCPtHbpXEUeCharged);
- outputContainer->Add(fhMCPtHbpXEUeLeftCharged);
- outputContainer->Add(fhMCPtHbpXEUeRightCharged);
- outputContainer->Add(fhMCUePart);
outputContainer->Add(fhMCPtHbpZTCharged) ;
- outputContainer->Add(fhMCPtHbpZTUeCharged) ;
- outputContainer->Add(fhMCPtHbpZTUeLeftCharged) ;
- outputContainer->Add(fhMCPtHbpZTUeRightCharged) ;
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})");
+
+ 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);
+
+ 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})");
+
+
+ fhMCPtHbpXEUeLeftCharged =
+ new TH2F("hMCPtHbpXEUeChargedLeft","#xi = ln(1/#it{x}_{#it{E}}) with charged hadrons, with UE left side range of trigger particles",
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
+ fhMCPtHbpXEUeLeftCharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
+ fhMCPtHbpXEUeLeftCharged->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",
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
+ fhMCPtZTUeLeftCharged->SetYTitle("#it{z}_{T}");
+ fhMCPtZTUeLeftCharged->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",
+ 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) ;
+
+ }
} //for MC histogram
if(DoOwnMix())
outputContainer->Add(fhEtaTriggerMixed);
// Fill the cluster pool only in isolation analysis or if requested
- if( ( OnlyIsolated() || fFillNeutralEventMixPool) &&
- (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists())))
+ if( neutralMix && (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists())))
{
Int_t nvz = GetNZvertBin();
Int_t nrp = GetNRPBin();
GetReader()->SetListWithMixedEventsForCalo (fListMixCaloEvents );
}
- fhEventBin=new TH1I("hEventBin","Number of real events per bin(cen,vz,rp)",
+ fhEventBin=new TH1I("hEventBin","Number of triggers per bin(cen,vz,rp)",
GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
- fhEventBin->SetXTitle("bin");
+ fhEventBin->SetXTitle("event bin");
outputContainer->Add(fhEventBin) ;
- fhEventMixBin=new TH1I("hEventMixBin","Number of events per bin(cen,vz,rp)",
+ fhEventMixBin=new TH1I("hEventMixBin","Number of triggers mixed per event bin(cen,vz,rp)",
GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
- fhEventMixBin->SetXTitle("bin");
+ fhEventMixBin->SetXTitle("event bin");
outputContainer->Add(fhEventMixBin) ;
-
- fhNtracksMB=new TH1F("hNtracksMBEvent","Number of tracks w/ event trigger kMB",2000,0,2000);
+
+ fhEventMBBin=new TH1I("hEventMBBin","Number of min bias events per bin(cen,vz,rp)",
+ GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
+ GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
+ fhEventMBBin->SetXTitle("event bin");
+ outputContainer->Add(fhEventMBBin) ;
+
+ fhNtracksMB=new TH2F("hNtracksMBEvent","Number of filtered tracks in MB event per event bin",ntrbins,trmin,trmax,
+ GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
+ GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
+ fhNtracksMB->SetYTitle("event bin");
+ fhNtracksMB->SetXTitle("#it{N}_{track}");
outputContainer->Add(fhNtracksMB);
-
- if(fFillNeutralEventMixPool || OnlyIsolated())
+
+ if( neutralMix )
{
- fhNclustersMB=new TH1F("hNclustersMBEvent","Number of clusters w/ event trigger kMB",2000,0,2000);
+ fhNclustersMB=new TH2F("hNclustersMBEvent","Number of filtered clusters in MB events per event bin",nclbins,clmin,clmax,
+ GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
+ GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
+ fhNclustersMB->SetYTitle("event bin");
+ fhNclustersMB->SetXTitle("#it{N}_{cluster}");
outputContainer->Add(fhNclustersMB);
}
fhMixXECharged =
new TH2F("hMixXECharged","Mixed event : #it{x}_{#it{E}} for charged tracks",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhMixXECharged->SetYTitle("#it{x}_{#it{E}}");
fhMixXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhMixXECharged);
fhMixXEUeCharged =
new TH2F("hMixXEUeCharged","Mixed event : #it{x}_{#it{E}} for charged tracks in Ue region",
- nptbins,ptmin,ptmax,200,0.,2.);
+ nptbins,ptmin,ptmax,nxeztbins,xeztmin,xeztmax);
fhMixXEUeCharged->SetYTitle("#it{x}_{#it{E}}");
fhMixXEUeCharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhMixXEUeCharged);
fhMixHbpXECharged =
new TH2F("hMixHbpXECharged","mixed event : #xi = ln(1/#it{x}_{#it{E}}) with charged hadrons",
- nptbins,ptmin,ptmax,200,0.,10.);
+ nptbins,ptmin,ptmax,nhbpbins,hbpmin,hbpmax);
fhMixHbpXECharged->SetYTitle("ln(1/#it{x}_{#it{E}})");
fhMixHbpXECharged->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
outputContainer->Add(fhMixHbpXECharged);
//printf("MIX : iAssoc %d, Vz %d, bin %d - sz %s, tz %s \n",i,z,bin,sz.Data(),tz.Data());
- fhMixDeltaPhiChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
- Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
- nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhMixDeltaPhiChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
-
- fhMixDeltaPhiChargedAssocPtBinDEta08[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0.8ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
- Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
- nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
-
- fhMixDeltaPhiChargedAssocPtBinDEta0[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
- Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
- nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
- fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
-
fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiDeltaEtaChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetYTitle("#Delta #eta");
- outputContainer->Add(fhMixDeltaPhiChargedAssocPtBin[bin]);
- outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta08[bin]);
- outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta0[bin]);
outputContainer->Add(fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]);
+
+ fhMixDeltaPhiChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
+ Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
+ nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhMixDeltaPhiChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
+
+ outputContainer->Add(fhMixDeltaPhiChargedAssocPtBin[bin]);
+
+ if(fFillEtaGapsHisto)
+ {
+ fhMixDeltaPhiChargedAssocPtBinDEta08[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0.8ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
+ Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
+ nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi (rad)");
+
+ fhMixDeltaPhiChargedAssocPtBinDEta0[bin] = new TH2F(Form("hMixDeltaPhiDeltaEta0ChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
+ Form("Mixed event #Delta #phi vs #it{p}_{T trigger} for associated #it{p}_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
+ nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("#it{p}_{T trigger} (GeV/#it{c})");
+ fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi (rad)");
+
+ outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta08[bin]);
+ outputContainer->Add(fhMixDeltaPhiChargedAssocPtBinDEta0[bin]);
+ }
}
}
}
Int_t indexPhoton1 = trigger->GetCaloLabel(0);
Int_t indexPhoton2 = trigger->GetCaloLabel(1);
- Float_t ptTrig = trigger->Pt();
if(indexPhoton1!=-1 || indexPhoton2!=-1) return kFALSE;
for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++)
{
- AliVCluster * photon = (AliVCluster*) (clusters->At(iclus));
- if(photon->GetID()==indexPhoton1)
- {
- photon->GetMomentum(mom1,GetVertex(0)) ;
- if(ptTrig) fhPtPi0DecayRatio->Fill(ptTrig, mom1.Pt()/ptTrig);
- }
- if(photon->GetID()==indexPhoton2)
- {
- photon->GetMomentum(mom1,GetVertex(0)) ;
- if(ptTrig > 0) fhPtPi0DecayRatio->Fill(ptTrig, mom2.Pt()/ptTrig);
- }
+ AliVCluster * photon = (AliVCluster*) (clusters->At(iclus));
+
+ if(photon->GetID()==indexPhoton1) photon->GetMomentum(mom1,GetVertex(0)) ;
+ if(photon->GetID()==indexPhoton2) photon->GetMomentum(mom1,GetVertex(0)) ;
if(GetDebug() > 1)printf("AliAnaParticleHadronCorrelation::GetDecayPhotonMomentum() - Photon1 = %f, Photon2 = %f \n", mom1.Pt(), mom2.Pt());
if(!GetReader()->IsCTSSwitchedOn())
AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!\n");
-
}
-
//____________________________________________________
void AliAnaParticleHadronCorrelation::InitParameters()
{
else
{
// Select only the leading in the trigger AOD loop
- naod = 1 ;
- iaod = fLeadingTriggerIndex;
+ naod = fLeadingTriggerIndex+1 ;
+ iaod = fLeadingTriggerIndex ;
}
}
// Neutral particles correlation
//
if(fNeutralCorr)
- {
- Bool_t okneutral = MakeNeutralCorrelation(particle);
- // If the correlation did not succeed.
- if(!okneutral) continue ;
- }
+ MakeNeutralCorrelation(particle);
//----------------------------------------------------------------
- // Fill trigger pT related histograms if correlation went well and
- // no problem was found, like not absolute leading
+ // Fill trigger pT related histograms if not absolute leading
+
//
// pT of the trigger, vs trigger origin if MC
//
-
fhPtTrigger->Fill(pt);
if(IsDataMC())
{
// Acceptance of the trigger
//
Float_t phi = particle->Phi();
- if( phi<0 ) phi+=TMath::TwoPi();
+ if( phi < 0 ) phi+=TMath::TwoPi();
fhPhiTrigger->Fill(pt, phi);
fhEtaTrigger->Fill(pt, particle->Eta());
if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtTriggerPileUp[5]->Fill(pt);
if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtTriggerPileUp[6]->Fill(pt);
}
- }
+ } // AOD trigger loop
//Reinit for next event
fLeadingTriggerIndex = -1;
evtIndex13 = GetMixedEvent()->EventIndex(aodParticle->GetTrackLabel(0)) ;
}
+ //
// 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,decayMom1, decayMom2);
+ if(decayFound)
+ {
+ fhPtPi0DecayRatio->Fill(ptTrig, decayMom1.Pt()/ptTrig);
+ fhPtPi0DecayRatio->Fill(ptTrig, decayMom2.Pt()/ptTrig);
+ }
+ }
+
//-----------------------------------------------------------------------
// Track loop, select tracks with good pt, phi and fill AODs or histograms
//-----------------------------------------------------------------------
//
// Azimuthal Angle histograms
//
- // calculate deltaPhi for later, shift when needed
+
+ 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();
+
FillChargedAngularCorrelationHistograms(pt, ptTrig, bin, phi, phiTrig, deltaPhi,
eta, etaTrig, decay, track->GetHMPIDsignal(),
outTOF, cenbin, mcTag);
+
//
// Imbalance zT/xE/pOut histograms
//
//
if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
FillChargedMomentumImbalanceHistograms(ptTrig, pt, deltaPhi, cenbin, track->Charge(),
- bin, decay, outTOF, mcTag);
-
+ assocBin, decay, outTOF, mcTag);
+ //
+ // Underlying event, right side, default case
+ //
if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
- { //UE study
-
FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, cenbin, outTOF);
-
- fhUePart->Fill(ptTrig);
- }
//
// Several UE calculation, in different perpendicular regions, up to 6:
}
-
//_________________________________________________________________________________________________________
void AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation(AliAODPWG4ParticleCorrelation *aodParticle)
{
if(!inputHandler) return;
if(!(inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask())) return;
-
+
// Get the pool, check if it exits
Int_t eventBin = GetEventMixBin();
-
- fhEventBin->Fill(eventBin);
//Check that the bin exists, if not (bad determination of RP, ntrality or vz bin) do nothing
if(eventBin < 0) return;
+
+ fhEventBin->Fill(eventBin);
+ // get neutral clusters pool?
+ Bool_t isoCase = OnlyIsolated() && (GetIsolationCut()->GetParticleTypeInCone() != AliIsolationCut::kOnlyCharged);
+ Bool_t neutralMix = fFillNeutralEventMixPool || isoCase ;
+
TList * pool = 0;
TList * poolCalo = 0;
if(fUseMixStoredInReader)
{
pool = GetReader()->GetListWithMixedEventsForTracks(eventBin);
- if(OnlyIsolated() || fFillNeutralEventMixPool) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin);
+ if(neutralMix) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin);
}
else
{
pool = fListMixTrackEvents[eventBin];
- if(OnlyIsolated() || fFillNeutralEventMixPool) poolCalo = fListMixCaloEvents [eventBin];
+ if(neutralMix) poolCalo = fListMixCaloEvents [eventBin];
}
if(!pool) return ;
- if((OnlyIsolated() || fFillNeutralEventMixPool ) && !poolCalo &&
- (GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::AliIsolationCut::kOnlyCharged))
+ if( neutralMix && !poolCalo )
printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Careful, cluster pool not available\n");
Double_t ptTrig = aodParticle->Pt();
Double_t etaAssoc = -999.;
Double_t deltaPhi = -999.;
Double_t deltaEta = -999.;
- Double_t xE = -999.;
- Double_t hbpXE = -999.;
-
- //Start from first event in pool except if in this same event the pool was filled
+ Double_t xE = -999.;
+
+ // Start from first event in pool except if in this same event the pool was filled
Int_t ev0 = 0;
if(GetReader()->GetLastTracksMixedEvent() == GetEventNumber()) ev0 = 1;
for(Int_t ev=ev0; ev < pool->GetSize(); ev++)
{
+ //
+ // Recover the lists of tracks or clusters
+ //
TObjArray* bgTracks = static_cast<TObjArray*>(pool->At(ev));
TObjArray* bgCalo = 0;
- // Check if the particle is isolated in the mixed event, it not, do not fill the histograms
- if((OnlyIsolated() || fFillNeutralEventMixPool) && poolCalo)
+ // Recover the clusters list if requested
+ if( neutralMix && poolCalo )
{
if(pool->GetSize()!=poolCalo->GetSize())
printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Different size of calo and track pools\n");
if(!bgCalo)
printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Event %d in calo pool not available?\n",ev);
-
- if(OnlyIsolated())
- {
- Int_t n=0; Int_t nfrac = 0; Bool_t isolated = kFALSE; Float_t coneptsum = 0;
- GetIsolationCut()->MakeIsolationCut(bgTracks,bgCalo,
- GetReader(), GetCaloPID(),
- kFALSE, aodParticle, "",
- n,nfrac,coneptsum, isolated);
-
- //printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Isolated? %d - cone %f, ptthres %f",
- // isolated,GetIsolationCut()->GetConeSize(),GetIsolationCut()->GetPtThreshold());
- //if(bgTracks)printf(" - n track %d", bgTracks->GetEntriesFast());
- //printf("\n");
-
- if(!isolated) continue ;
- }
}
- fhEventMixBin->Fill(eventBin);
+ //
+ // Isolate the trigger in the mixed event with mixed tracks and clusters
+ //
+ if( OnlyIsolated() )
+ {
+ Int_t n=0; Int_t nfrac = 0; Bool_t isolated = kFALSE; Float_t coneptsum = 0;
+ GetIsolationCut()->MakeIsolationCut(bgTracks,bgCalo,
+ GetReader(), GetCaloPID(),
+ kFALSE, aodParticle, "",
+ n,nfrac,coneptsum, isolated);
+
+ //printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Isolated? %d - cone %f, ptthres %f",
+ // isolated,GetIsolationCut()->GetConeSize(),GetIsolationCut()->GetPtThreshold());
+ //if(bgTracks)printf(" - n track %d", bgTracks->GetEntriesFast());
+ //printf("\n");
+
+ if(!isolated) continue ;
+ }
+ //
+ // Check if the trigger is leading of mixed event
+ //
Int_t nTracks=bgTracks->GetEntriesFast();
- //printf("\t Read Pool event %d, nTracks %d\n",ev,nTracks);
- //Check if it is leading if mixed event
if(fMakeNearSideLeading || fMakeAbsoluteLeading)
{
Bool_t leading = kTRUE;
- for(Int_t jlead = 0;jlead <nTracks; jlead++ )
+ for(Int_t jlead = 0;jlead < nTracks; jlead++ )
{
AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(jlead) ;
ptAssoc = track->Pt();
phiAssoc = track->Phi() ;
-
if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
+
if (fMakeNearSideLeading)
{
if(ptAssoc > ptTrig && TMath::Abs(phiAssoc-phiTrig) < TMath::PiOver2())
}
}
- if(fFillNeutralEventMixPool && bgCalo)
+ if( !neutralMix && fCheckLeadingWithNeutralClusters )
+ printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Leading of clusters requested but no clusters in mixed event\n");
+
+ if(neutralMix && fCheckLeadingWithNeutralClusters && bgCalo)
{
Int_t nClusters=bgCalo->GetEntriesFast();
TLorentzVector mom ;
ptAssoc = cluster->Pt();
phiAssoc = cluster->Phi() ;
-
if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
+
if (fMakeNearSideLeading)
{
if(ptAssoc > ptTrig && TMath::Abs(phiAssoc-phiTrig) < TMath::PiOver2())
}
if(!leading) continue; // not leading, check the next event in pool
-
}
+ //
+ // Fill histograms for selected triggers
+ //
+
+ fhEventMixBin->Fill(eventBin);
+
+ //printf("\t Read Pool event %d, nTracks %d\n",ev,nTracks);
+
fhPtTriggerMixed ->Fill(ptTrig);
fhPhiTriggerMixed ->Fill(ptTrig, phiTrig);
fhEtaTriggerMixed ->Fill(ptTrig, etaTrig);
fhPtTriggerMixedBin->Fill(ptTrig,eventBin);
if(fCorrelVzBin)fhPtTriggerMixedVzBin->Fill(ptTrig, GetEventVzBin());
+ //
+ // Correlation histograms
+ //
for(Int_t j1 = 0;j1 <nTracks; j1++ )
{
AliAODPWG4Particle *track = (AliAODPWG4Particle*) bgTracks->At(j1) ;
etaAssoc = track->Eta();
phiAssoc = track->Phi() ;
if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
-
- if(IsFiducialCutOn())
- {
- Bool_t in = GetFiducialCut()->IsInFiducialCut(*aodParticle->Momentum(),"CTS") ;
- if(!in) continue ;
- }
deltaPhi = phiTrig-phiAssoc;
if(deltaPhi < -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
if(GetDebug()>0)
printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation(): deltaPhi= %f, deltaEta=%f\n",deltaPhi, deltaEta);
- // Set the pt associated bin for the defined bins
- Int_t assocBin = -1;
- for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
- {
- if(ptAssoc > fAssocPtBinLimit[i] && ptAssoc < fAssocPtBinLimit[i+1]) assocBin= i;
- }
-
- // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins
- Int_t nz = 1;
- Int_t vz = 0;
-
- if(fCorrelVzBin)
- {
- nz = GetNZvertBin();
- vz = GetEventVzBin();
- }
-
- Int_t bin = assocBin*nz+vz;
-
- fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi);
- fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
-
- fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi);
+ // Angular correlation
+ fhMixDeltaPhiCharged ->Fill(ptTrig, deltaPhi);
fhMixDeltaPhiDeltaEtaCharged->Fill(deltaPhi, deltaEta);
- xE =-ptAssoc/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
- //if(xE <0.)xE =-xE;
- if(xE > 0 ) hbpXE = TMath::Log(1./xE);
- else hbpXE =-100;
-
+ //
+ // Momentum imbalance
+ //
if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
{
+ 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());
+
fhMixXECharged->Fill(ptTrig,xE);
- fhMixHbpXECharged->Fill(ptTrig,hbpXE);
+ if(xE > 0 ) fhMixHbpXECharged->Fill(ptTrig, TMath::Log(1./xE));
}
+ //
+ // Underlying event momentum imbalance
+ //
if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
{
//Underlying event region
Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
Double_t uexE = -(ptAssoc/ptTrig)*TMath::Cos(randomphi);
- if(uexE < 0.) uexE = -uexE;
+ 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());
fhMixXEUeCharged->Fill(ptTrig,uexE);
}
- if(bin < 0) continue ; // this pt bin was not considered
+ // Set the pt associated bin for the defined bins
+ Int_t assocBin = -1;
+ for(Int_t i = 0 ; i < fNAssocPtBins ; i++)
+ {
+ if(ptAssoc > fAssocPtBinLimit[i] && ptAssoc < fAssocPtBinLimit[i+1]) assocBin= i;
+ }
+
+ //
+ // Assign to the histogram array a bin corresponding to a combination of pTa and vz bins
+ //
+ Int_t nz = 1;
+ Int_t vz = 0;
+
+ if(fCorrelVzBin)
+ {
+ nz = GetNZvertBin();
+ vz = GetEventVzBin();
+ }
+
+ Int_t bin = assocBin*nz+vz;
- if(TMath::Abs(deltaEta) > 0.8)
- fhMixDeltaPhiChargedAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi);
- if(TMath::Abs(deltaEta) < 0.01)
- fhMixDeltaPhiChargedAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi);
+ if(bin < 0) continue ; // this pt bin was not considered
- fhMixDeltaPhiChargedAssocPtBin [bin]->Fill(ptTrig, deltaPhi);
- fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->Fill(deltaPhi, deltaEta);
+ fhMixDeltaPhiChargedAssocPtBin [bin]->Fill(ptTrig, deltaPhi);
+ fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->Fill(deltaPhi, deltaEta);
+ if(fFillEtaGapsHisto)
+ {
+ if(TMath::Abs(deltaEta) > 0.8)
+ fhMixDeltaPhiChargedAssocPtBinDEta08 [bin]->Fill(ptTrig, deltaPhi);
+ if(TMath::Abs(deltaEta) < 0.01)
+ fhMixDeltaPhiChargedAssocPtBinDEta0 [bin]->Fill(ptTrig, deltaPhi);
+ }
+
} // track loop
} // mixed event loop
}
-//__________________________________________________________________________________________________________
-Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * aodParticle)
+//_______________________________________________________________________________________________________
+void AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * aodParticle)
{
// Neutral Pion Correlation Analysis
TObjArray * pi0list = (TObjArray*) GetAODBranch(fPi0AODBranchName); // For the future, foresee more possible pi0 lists
- if(!pi0list) return kFALSE;
+ if(!pi0list) return ;
Int_t npi0 = pi0list->GetEntriesFast();
- if(npi0 == 0) return kFALSE;
+ if(npi0 == 0) return ;
if(GetDebug() > 1)
printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Particle - pi0 correlation, %d pi0's\n",npi0);
}
Float_t pt = -100. ;
-// Float_t zT = -100. ;
+ Float_t zT = -100. ;
Float_t phi = -100. ;
Float_t eta = -100. ;
Float_t xE = -100. ;
Float_t hbpXE= -100. ;
- //Float_t hbpZT= -100. ;
+ Float_t hbpZT= -100. ;
Float_t ptTrig = aodParticle->Pt();
Float_t phiTrig = aodParticle->Phi();
Float_t etaTrig = aodParticle->Eta();
Float_t deltaPhi= -100. ;
+ Float_t deltaEta= -100. ;
TLorentzVector photonMom ;
}
pt = pi0->Pt();
-
- if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
-
- phi = pi0->Phi() ;
- eta = pi0->Eta() ;
- FillNeutralAngularCorrelationHistograms(pt, ptTrig, phi, phiTrig, deltaPhi, eta, etaTrig);
+ if(pt < fMinAssocPt || pt > fMaxAssocPt) continue ;
- //zT = pt/ptTrig ;
- xE =-pt/ptTrig*TMath::Cos(deltaPhi); // -(px*pxTrig+py*pyTrig)/(ptTrig*ptTrig);
+ //remove trigger itself for correlation when use charged triggers
+ if(aodParticle->GetCaloLabel(0) >= 0 &&
+ (pi0->GetCaloLabel(0) == aodParticle->GetCaloLabel(0) || pi0->GetCaloLabel(1) == aodParticle->GetCaloLabel(0))) continue ;
- //if(xE <0.)xE =-xE;
+ if( aodParticle->GetCaloLabel(1) >= 0 &&
+ (pi0->GetCaloLabel(0) == aodParticle->GetCaloLabel(1) || pi0->GetCaloLabel(1) == aodParticle->GetCaloLabel(1))) continue ;
+
+ //
+ // Angular correlations
+ //
+ phi = pi0->Phi() ;
+ eta = pi0->Eta() ;
+ deltaEta = etaTrig-eta;
+ deltaPhi = phiTrig-phi;
+ if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
+ if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
- hbpXE = -100;
- //hbpZT = -100;
+ fhEtaNeutral ->Fill(pt , eta );
+ fhPhiNeutral ->Fill(pt , phi );
+ fhDeltaEtaNeutral->Fill(ptTrig, deltaEta);
+ fhDeltaPhiNeutral->Fill(ptTrig, deltaPhi);
- if(xE > 0 ) hbpXE = TMath::Log(1./xE);
- //if(zT > 0 ) hbpZT = TMath::Log(1./zT);
+ if(pt > 2 ) fhDeltaPhiDeltaEtaNeutral->Fill(deltaPhi, deltaEta);
+
+ //
+ // Momentum imbalance
+ //
+ zT = pt/ptTrig ;
- if(fPi0Trigger && decayFound)
- FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2,kFALSE) ;
+ hbpZT = -100;
+ hbpXE = -100;
+
+ if(zT > 0 ) hbpZT = TMath::Log(1./zT);
//delta phi cut for correlation
if( (deltaPhi > fDeltaPhiMinCut) && ( deltaPhi < fDeltaPhiMaxCut) )
{
+ 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());
+
+ if(xE > 0 ) hbpXE = TMath::Log(1./xE);
+
fhDeltaPhiNeutralPt->Fill(pt,deltaPhi);
fhXENeutral ->Fill(ptTrig,xE);
fhPtHbpXENeutral ->Fill(ptTrig,hbpXE);
+ fhZTNeutral ->Fill(ptTrig,zT);
+ fhPtHbpZTNeutral ->Fill(ptTrig,hbpZT);
}
else if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
{
+ // Randomize angle for xE calculation
+ Double_t randomphi = gRandom->Uniform(fDeltaPhiMinCut,fDeltaPhiMaxCut);
+
+ xE = -(pt/ptTrig)*TMath::Cos(randomphi);
+ if(xE > 0 ) hbpXE = TMath::Log(1./xE);
+
fhDeltaPhiUeNeutralPt->Fill(pt,deltaPhi);
+ fhZTUeNeutral ->Fill(ptTrig,zT);
+ fhPtHbpZTUeNeutral ->Fill(ptTrig,hbpZT);
fhXEUeNeutral ->Fill(ptTrig,xE);
fhPtHbpXEUeNeutral ->Fill(ptTrig,hbpXE);
}
+
+ // Several UE calculation, not sure it is useful
+ // with partical calorimter acceptance
+ if(fMakeSeveralUE) FillNeutralUnderlyingEventSidesHistograms(ptTrig,pt,zT,hbpZT,deltaPhi);
- //several UE calculation
- if(fMakeSeveralUE) FillChargedUnderlyingEventSidesHistograms(ptTrig,pt,deltaPhi);
+ //
+ // Decay photon correlations
+ //
+ if(fPi0Trigger && decayFound)
+ FillDecayPhotonCorrelationHistograms(pt, phi, decayMom1,decayMom2,kFALSE) ;
if(fFillAODWithReferences)
{
{
aodParticle->AddObjArray(refpi0);
}
-
- return kTRUE;
}
//__________________________________________________________________________
if ( GetDebug() > 1 )
AliInfo("Make trigger particle - charged hadron correlation in AOD MC level");
+ if( label < 0 )
+ {
+ if( GetDebug() > 0 ) AliInfo(Form(" *** bad label ***: label %d", label));
+ return;
+ }
+
AliStack * stack = 0x0 ;
TParticle * primary = 0x0 ;
TClonesArray * mcparticles = 0x0 ;
Int_t nTracks = 0 ;
Int_t iParticle = 0 ;
- Bool_t lead = kFALSE;
-
- if( label < 0 )
- {
- if( GetDebug() > 0 ) AliInfo(Form(" *** bad label ***: label %d", label));
- return;
- }
+ Bool_t leadTrig = kTRUE;
if( GetReader()->ReadStack() )
{
eprim = primary->Energy();
ptprim = primary->Pt();
- phiprim = primary->Phi();
etaprim = primary->Eta();
-
+ phiprim = primary->Phi();
+ if(phiprim < 0) phiprim+=TMath::TwoPi();
+
if(ptprim < 0.01 || eprim < 0.01) return ;
for (iParticle = 0 ; iParticle < nTracks ; iParticle++)
//keep only final state particles
if( particle->GetStatusCode() != 1 ) continue ;
-
- if ( particle->Pt() < GetReader()->GetCTSPtMin()) continue;
-
+
//---------- Charged particles ----------------------
Int_t pdg = particle->GetPdgCode();
Int_t charge = (Int_t) TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
if ( label == iParticle ) continue; // avoid trigger particle
- lead = FillChargedMCCorrelationHistograms(particle->Pt(),particle->Phi(),particle->Eta(),ptprim,phiprim,etaprim);
- if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading) ) return;
+ Float_t phi = particle->Phi();
+ if(phi < 0) phi+=TMath::TwoPi();
+
+ Bool_t lead = FillChargedMCCorrelationHistograms(particle->Pt(),phi,particle->Eta(),ptprim,phiprim,etaprim);
+ if(!lead) leadTrig = kFALSE;
+ //if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading) ) return;
} //track loop
return;
}
+ eprim = aodprimary->E();
ptprim = aodprimary->Pt();
- phiprim = aodprimary->Phi();
etaprim = aodprimary->Eta();
- eprim = aodprimary->E();
-
+ phiprim = aodprimary->Phi();
+ if(phiprim < 0) phiprim+=TMath::TwoPi();
+
if(ptprim < 0.01 || eprim < 0.01) return ;
for (iParticle = 0; iParticle < nTracks; iParticle++)
if ( part->Charge() == 0 ) continue;
- if ( part->Pt() < GetReader()->GetCTSPtMin()) continue;
-
TLorentzVector momentum(part->Px(),part->Py(),part->Pz(),part->E());
//Particles in CTS acceptance, make sure to use the same selection as in the reader
if ( label == iParticle ) continue; // avoid trigger particle
- lead = FillChargedMCCorrelationHistograms(part->Pt(),part->Phi(),part->Eta(),ptprim,phiprim,etaprim);
- if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return;
+ Float_t phi = part->Phi();
+ if(phi < 0) phi+=TMath::TwoPi();
+
+ Bool_t lead = FillChargedMCCorrelationHistograms(part->Pt(),phi,part->Eta(),ptprim,phiprim,etaprim);
+ if(!lead) leadTrig = kFALSE;
+ //if ( !lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return;
} //MC particle loop
}// AOD MC
// Trigger MC particle histograms
- if (!lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return;
+ //if (!lead && (fMakeAbsoluteLeading || fMakeNearSideLeading)) return;
fhMCPtTrigger ->Fill(ptprim);
fhMCPhiTrigger->Fill(ptprim,phiprim);
fhMCEtaTrigger->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);
+
+ fhMCPtTriggerNotLeading ->Fill(ptprim);
+ fhMCPhiTriggerNotLeading->Fill(ptprim,phiprim);
+ fhMCEtaTriggerNotLeading->Fill(ptprim,etaprim);
+ }
}
//_____________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff