fListMixTrackEvents(), fListMixCaloEvents(),
fUseMixStoredInReader(0), fFillNeutralEventMixPool(0),
fM02MaxCut(0), fM02MinCut(0),
- fFillPileUpHistograms(0),
+ fFillPileUpHistograms(0),
//Histograms
fhPtInput(0), fhPtFidCut(0),
- fhPtLeading(0), fhPtLeadingPileUp(),
+ fhPtLeading(0), fhPtLeadingVtxBC0(0),
fhPtLeadingVzBin(0), fhPtLeadingBin(0),
fhPhiLeading(0), fhEtaLeading(0),
fhPtLeadingMC(),
fhDeltaPhiChargedPtA3GeV(0), fhDeltaEtaChargedPtA3GeV(0),
//Pile-Up
fhDeltaPhiChargedPileUp(), fhDeltaEtaChargedPileUp(),
- fhXEChargedPileUp(), fhXEUeChargedPileUp(),
+ fhDeltaPhiChargedPtA3GeVPileUp(), fhDeltaEtaChargedPtA3GeVPileUp(),
+ fhXEChargedPileUp(), fhXEUeChargedPileUp(),
fhZTChargedPileUp(), fhZTUeChargedPileUp(),
fhPtTrigChargedPileUp(),
- fhDeltaPhiChargedPtA3GeVPileUp(), fhDeltaEtaChargedPtA3GeVPileUp(),
+ fhDeltaPhiChargedOtherBC(), fhDeltaPhiChargedPtA3GeVOtherBC(),
+ fhXEChargedOtherBC(), fhXEUeChargedOtherBC(),
+ fhZTChargedOtherBC(), fhZTUeChargedOtherBC(),
+ fhPtTrigChargedOtherBC(),
+ fhDeltaPhiChargedBC0(), fhDeltaPhiChargedPtA3GeVBC0(),
+ fhXEChargedBC0(), fhXEUeChargedBC0(),
+ fhZTChargedBC0(), fhZTUeChargedBC0(),
+ fhPtTrigChargedBC0(),
+ fhDeltaPhiChargedVtxBC0(), fhDeltaPhiChargedPtA3GeVVtxBC0(),
+ fhXEChargedVtxBC0(), fhXEUeChargedVtxBC0(),
+ fhZTChargedVtxBC0(), fhZTUeChargedVtxBC0(),
+ fhPtTrigChargedVtxBC0(),
fhDeltaPhiUeLeftCharged(0), fhDeltaPhiUeRightCharged(0),
fhDeltaPhiUeLeftUpCharged(0), fhDeltaPhiUeRightUpCharged(0),
fhDeltaPhiUeLeftDownCharged(0), fhDeltaPhiUeRightDownCharged(0),
fhMCPtZTCharged(0), fhMCPtHbpZTCharged(0),
fhMCPtTrigPout(0), fhMCPtAssocDeltaPhi(0),
//Mixing
- fhNEventsTrigger(0),
- fhNtracksAll(0), fhNtracksTrigger(0), fhNtracksMB(0),
- fhNclustersAll(0), fhNclustersTrigger(0), fhNclustersMB(0),
+ fhNEventsTrigger(0), fhNtracksMB(0), fhNclustersMB(0),
fhMixDeltaPhiCharged(0), fhMixDeltaPhiDeltaEtaCharged(0),
- fhMixXECharged(0), fhMixHbpXECharged(0),
+ fhMixXECharged(0), fhMixXEUeCharged(0), fhMixHbpXECharged(0),
fhMixDeltaPhiChargedAssocPtBin(),
fhMixDeltaPhiChargedAssocPtBinDEta08(),
fhMixDeltaPhiChargedAssocPtBinDEta0(),
}
//______________________________________________________________________________________________________________________________________________________
-void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(const Float_t ptAssoc, const Float_t ptTrig, const Int_t bin,
- const Float_t phiAssoc, const Float_t phiTrig, Float_t & deltaPhi,
- const Float_t etaAssoc, const Float_t etaTrig,
- const Bool_t decay, const Float_t hmpidSignal, const Int_t nTracks,
- const Int_t mcTag)
+void AliAnaParticleHadronCorrelation::FillChargedAngularCorrelationHistograms(Float_t ptAssoc, Float_t ptTrig, Int_t bin,
+ Float_t phiAssoc, Float_t phiTrig, Float_t & deltaPhi,
+ Float_t etaAssoc, Float_t etaTrig,
+ Bool_t decay, Float_t hmpidSignal, Int_t outTOF,
+ Int_t nTracks, Int_t mcTag)
{
// Fill angular correlation related histograms
if(fFillPileUpHistograms)
{
+ if (outTOF==1)
+ {
+ fhDeltaPhiChargedOtherBC->Fill(ptTrig ,deltaPhi) ;
+ if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVOtherBC->Fill(ptTrig ,deltaPhi) ;
+ }
+ else if(outTOF==0)
+ {
+ fhDeltaPhiChargedBC0->Fill(ptTrig ,deltaPhi) ;
+ if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVBC0->Fill(ptTrig ,deltaPhi) ;
+ }
+
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
+ {
+ fhDeltaPhiChargedVtxBC0->Fill(ptTrig ,deltaPhi) ;
+ if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVVtxBC0->Fill(ptTrig ,deltaPhi) ;
+ }
+
if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[1]->Fill(ptTrig ,deltaPhi) ; }
if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[2]->Fill(ptTrig ,deltaPhi) ; }
if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[5]->Fill(ptTrig ,deltaPhi) ; }
if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[6]->Fill(ptTrig ,deltaPhi) ; }
-
-
if(ptAssoc > 3 )
{
if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
}
//____________________________________________________________________________________________________________________________________________________
-Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(const Float_t mcAssocPt, Float_t mcAssocPhi, const Float_t mcAssocEta,
- const Float_t mcTrigPt, const Float_t mcTrigPhi, const Float_t mcTrigEta)
+Bool_t AliAnaParticleHadronCorrelation::FillChargedMCCorrelationHistograms(Float_t mcAssocPt, Float_t mcAssocPhi, Float_t mcAssocEta,
+ Float_t mcTrigPt, Float_t mcTrigPhi, Float_t mcTrigEta)
{
// Fill MC histograms independently of AOD or ESD
}
//___________________________________________________________________________________________________________________
-void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(const Float_t ptTrig, const Float_t ptAssoc,
- const Float_t xE, const Float_t hbpXE,
- const Float_t zT, const Float_t hbpZT,
- const Float_t pout,
- const Int_t nTracks, const Int_t charge,
- const Int_t bin, const Bool_t decay,
- const Int_t mcTag)
+void AliAnaParticleHadronCorrelation::FillChargedMomentumImbalanceHistograms(Float_t ptTrig, Float_t ptAssoc,
+ Float_t xE, Float_t hbpXE,
+ Float_t zT, Float_t hbpZT,
+ Float_t pout,
+ Int_t nTracks, Int_t charge,
+ Int_t bin, Bool_t decay,
+ Int_t outTOF, Int_t mcTag)
{
// Fill mostly momentum imbalance related histograms
// Pile up studies
if(fFillPileUpHistograms)
{
- if(GetReader()->IsPileUpFromSPD()) { fhXEChargedPileUp[0]->Fill(ptTrig ,xE); fhZTChargedPileUp[0]->Fill(ptTrig,zT);fhPtTrigChargedPileUp[0]->Fill(ptTrig,ptAssoc); }
- if(GetReader()->IsPileUpFromEMCal()) { fhXEChargedPileUp[1]->Fill(ptTrig ,xE); fhZTChargedPileUp[1]->Fill(ptTrig,zT);fhPtTrigChargedPileUp[1]->Fill(ptTrig,ptAssoc); }
- if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEChargedPileUp[2]->Fill(ptTrig ,xE); fhZTChargedPileUp[2]->Fill(ptTrig,zT);fhPtTrigChargedPileUp[2]->Fill(ptTrig,ptAssoc); }
- if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEChargedPileUp[3]->Fill(ptTrig ,xE); fhZTChargedPileUp[3]->Fill(ptTrig,zT);fhPtTrigChargedPileUp[3]->Fill(ptTrig,ptAssoc); }
- if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEChargedPileUp[4]->Fill(ptTrig ,xE); fhZTChargedPileUp[4]->Fill(ptTrig,zT);fhPtTrigChargedPileUp[4]->Fill(ptTrig,ptAssoc); }
- if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEChargedPileUp[5]->Fill(ptTrig ,xE); fhZTChargedPileUp[5]->Fill(ptTrig,zT);fhPtTrigChargedPileUp[5]->Fill(ptTrig,ptAssoc); }
- if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEChargedPileUp[6]->Fill(ptTrig ,xE); fhZTChargedPileUp[6]->Fill(ptTrig,zT);fhPtTrigChargedPileUp[6]->Fill(ptTrig,ptAssoc); }
+ if (outTOF==1)
+ {
+ fhXEChargedOtherBC ->Fill(ptTrig,xE);
+ fhZTChargedOtherBC ->Fill(ptTrig,zT);
+ fhPtTrigChargedOtherBC->Fill(ptTrig,ptAssoc);
+ }
+ else if(outTOF==0)
+ {
+ fhXEChargedBC0 ->Fill(ptTrig,xE);
+ fhZTChargedBC0 ->Fill(ptTrig,zT);
+ fhPtTrigChargedBC0->Fill(ptTrig,ptAssoc);
+ }
+
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
+ {
+ fhXEChargedVtxBC0 ->Fill(ptTrig,xE);
+ fhZTChargedVtxBC0 ->Fill(ptTrig,zT);
+ fhPtTrigChargedVtxBC0->Fill(ptTrig,ptAssoc);
+ }
+
+ if(GetReader()->IsPileUpFromSPD()) { fhXEChargedPileUp[0]->Fill(ptTrig,xE); fhZTChargedPileUp[0]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[0]->Fill(ptTrig,ptAssoc); }
+ if(GetReader()->IsPileUpFromEMCal()) { fhXEChargedPileUp[1]->Fill(ptTrig,xE); fhZTChargedPileUp[1]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[1]->Fill(ptTrig,ptAssoc); }
+ if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEChargedPileUp[2]->Fill(ptTrig,xE); fhZTChargedPileUp[2]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[2]->Fill(ptTrig,ptAssoc); }
+ if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEChargedPileUp[3]->Fill(ptTrig,xE); fhZTChargedPileUp[3]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[3]->Fill(ptTrig,ptAssoc); }
+ if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEChargedPileUp[4]->Fill(ptTrig,xE); fhZTChargedPileUp[4]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[4]->Fill(ptTrig,ptAssoc); }
+ if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEChargedPileUp[5]->Fill(ptTrig,xE); fhZTChargedPileUp[5]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[5]->Fill(ptTrig,ptAssoc); }
+ if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEChargedPileUp[6]->Fill(ptTrig,xE); fhZTChargedPileUp[6]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[6]->Fill(ptTrig,ptAssoc); }
}
if(IsDataMC())
}
//_______________________________________________________________________________________________________________________
-void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventHistograms(const Float_t ptTrig, const Float_t ptAssoc,
- const Float_t deltaPhi, const Int_t nTracks)
+void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventHistograms(Float_t ptTrig, Float_t ptAssoc,
+ Float_t deltaPhi, Int_t nTracks, Int_t outTOF)
{
// Fill underlying event histograms
if(fFillPileUpHistograms)
{
+ if (outTOF==1)
+ {
+ fhXEUeChargedOtherBC->Fill(ptTrig,uexE);
+ fhZTUeChargedOtherBC->Fill(ptTrig,uezT);
+ }
+ else if(outTOF==0)
+ {
+ fhXEUeChargedBC0->Fill(ptTrig,uexE);
+ fhZTUeChargedBC0->Fill(ptTrig,uezT);
+ }
+
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
+ {
+ fhXEUeChargedVtxBC0->Fill(ptTrig,uexE);
+ fhZTUeChargedVtxBC0->Fill(ptTrig,uezT);
+ }
+
if(GetReader()->IsPileUpFromSPD()) { fhXEUeChargedPileUp[0]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[0]->Fill(ptTrig,uezT);}
if(GetReader()->IsPileUpFromEMCal()) { fhXEUeChargedPileUp[1]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[1]->Fill(ptTrig,uezT);}
if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEUeChargedPileUp[2]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[2]->Fill(ptTrig,uezT);}
}
//_____________________________________________________________________________________________________
-void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventSidesHistograms(const Float_t ptTrig,
- const Float_t ptAssoc,
- const Float_t deltaPhi)
+void AliAnaParticleHadronCorrelation::FillChargedUnderlyingEventSidesHistograms(Float_t ptTrig,
+ Float_t ptAssoc,
+ Float_t deltaPhi)
{
// Fill underlying event histograms to the left and right of trigger
if((deltaPhi<-fUeDeltaPhiMinCut) || (deltaPhi >2*fUeDeltaPhiMaxCut))
}
//______________________________________________________________________________________________________________________________
-void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(const Float_t ptAssoc, const Float_t phiAssoc,
- const TLorentzVector mom1, const TLorentzVector mom2,
- const Bool_t bChargedOrNeutral)
+void AliAnaParticleHadronCorrelation::FillDecayPhotonCorrelationHistograms(Float_t ptAssoc, Float_t phiAssoc,
+ TLorentzVector mom1, TLorentzVector mom2,
+ Bool_t bChargedOrNeutral)
{
// Do correlation with decay photons of triggered pi0 or eta
}
//______________________________________________________________________________________________________________________________________________________
-void AliAnaParticleHadronCorrelation::FillNeutralAngularCorrelationHistograms(const Float_t ptAssoc, const Float_t ptTrig,
- const Float_t phiAssoc, const Float_t phiTrig, Float_t & deltaPhi,
- const Float_t etaAssoc, const Float_t etaTrig)
+void AliAnaParticleHadronCorrelation::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
}
//_____________________________________________________________________________________________________________________________
-void AliAnaParticleHadronCorrelation::FillNeutralUnderlyingEventSidesHistograms(const Float_t ptTrig, const Float_t ptAssoc,
- const Float_t xE, const Float_t hbpXE,
- const Float_t zT, const Float_t hbpZT,
- const Float_t deltaPhi)
+void AliAnaParticleHadronCorrelation::FillNeutralUnderlyingEventSidesHistograms(Float_t ptTrig, Float_t ptAssoc,
+ Float_t xE, Float_t hbpXE,
+ Float_t zT, Float_t hbpZT,
+ Float_t deltaPhi)
{
// Fill underlying event histograms to the left and right of trigger
}
}
+//______________________________________________________
+void AliAnaParticleHadronCorrelation::FillEventMixPool()
+{
+ // Fill the pool with tracks if requested
+
+ if(DoOwnMix())
+ {
+ FillChargedEventMixPool();
+
+ if(OnlyIsolated() || fFillNeutralEventMixPool)
+ FillNeutralEventMixPool();
+ }
+
+}
+
//_____________________________________________________________
void AliAnaParticleHadronCorrelation::FillChargedEventMixPool()
{
// Mixed event pool filling for tracks
-
- //printf("FillChargedEventMixPool for %s\n",GetInputAODName().Data());
-
+
if(fUseMixStoredInReader && GetReader()->GetLastTracksMixedEvent() == GetEventNumber())
{
//printf("%s : Pool already filled for this event !!!\n",GetInputAODName().Data());
}
Int_t nTracks = GetCTSTracks()->GetEntriesFast();
-
- fhNtracksAll->Fill(nTracks);
-
+
AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
if(!inputHandler) return ;
-
- if( inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask() )
- {
- fhNtracksTrigger->Fill(nTracks);
- }
-
+
// Do mixing only with MB event (or the chosen mask), if not skip
if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
//else pl = GetEMCALClusters();
Int_t nClusters = pl->GetEntriesFast();
- fhNclustersAll->Fill(nClusters);
if(fUseMixStoredInReader && GetReader()->GetLastCaloMixedEvent() == GetEventNumber())
{
AliInputEventHandler * inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
if(!inputHandler) return ;
-
- if( inputHandler->IsEventSelected( ) & GetReader()->GetEventTriggerMask() )
- {
- fhNclustersTrigger->Fill(nClusters);
- }
-
+
// Do mixing only with MB event (or the chosen mask), if not skip
if( !(inputHandler->IsEventSelected( ) & GetReader()->GetMixEventTriggerMask()) ) return ;
outputContainer->Add(fhUePart);
outputContainer->Add(fhXECharged) ;
-
+
if(IsDataMC())
{
for(Int_t i=0; i < 7; i++)
outputContainer->Add(fhPtTrigPout) ;
outputContainer->Add(fhPtTrigCharged) ;
-
if(fFillPileUpHistograms)
{
+ fhDeltaPhiChargedOtherBC = new TH2F
+ ("hDeltaPhiChargedOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, track BC!=0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedOtherBC->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhDeltaPhiChargedPtA3GeVOtherBC = new TH2F
+ ("hDeltaPhiChargedPtA3GeVOtherBC","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, track BC!=0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedPtA3GeVOtherBC->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedPtA3GeVOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhPtTrigChargedOtherBC =
+ new TH2F("hPtTrigChargedOtherBC","trigger and charged tracks pt distribution, track BC!=0",
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhPtTrigChargedOtherBC->SetYTitle("p_{T h^{#pm}} (GeV/c)");
+ fhPtTrigChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhXEChargedOtherBC =
+ new TH2F("hXEChargedOtherBC","x_{E} for charged tracks, track BC!=0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEChargedOtherBC->SetYTitle("x_{E}");
+ fhXEChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhXEUeChargedOtherBC =
+ new TH2F("hXEUeChargedOtherBC","x_{E} for Underlying Event, track BC!=0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEUeChargedOtherBC->SetYTitle("x_{E}");
+ fhXEUeChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhZTChargedOtherBC =
+ new TH2F("hZTChargedOtherBC","z_{T} for charged tracks, track BC!=0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTChargedOtherBC->SetYTitle("z_{T}");
+ fhZTChargedOtherBC->SetXTitle("p_{T trigger}");
+
+ fhZTUeChargedOtherBC =
+ new TH2F("hZTUeChargedOtherBC","z_{T} for Underlying Event, track BC!=0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTUeChargedOtherBC->SetYTitle("z_{T}");
+ fhZTUeChargedOtherBC->SetXTitle("p_{T trigger} (GeV/c)");
+
+ outputContainer->Add(fhDeltaPhiChargedOtherBC) ;
+ outputContainer->Add(fhDeltaPhiChargedPtA3GeVOtherBC) ;
+ outputContainer->Add(fhXEChargedOtherBC) ;
+ outputContainer->Add(fhXEUeChargedOtherBC) ;
+ outputContainer->Add(fhZTChargedOtherBC) ;
+ outputContainer->Add(fhZTUeChargedOtherBC) ;
+ outputContainer->Add(fhPtTrigChargedOtherBC) ;
+
+ fhDeltaPhiChargedBC0 = new TH2F
+ ("hDeltaPhiChargedBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, track BC==0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedBC0->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhDeltaPhiChargedPtA3GeVBC0 = new TH2F
+ ("hDeltaPhiChargedPtA3GeVBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, track BC==0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedPtA3GeVBC0->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedPtA3GeVBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhPtTrigChargedBC0 =
+ new TH2F("hPtTrigChargedBC0","trigger and charged tracks pt distribution, track BC==0",
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhPtTrigChargedBC0->SetYTitle("p_{T h^{#pm}} (GeV/c)");
+ fhPtTrigChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhXEChargedBC0 =
+ new TH2F("hXEChargedBC0","x_{E} for charged tracks, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEChargedBC0->SetYTitle("x_{E}");
+ fhXEChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhXEUeChargedBC0 =
+ new TH2F("hXEUeChargedBC0","x_{E} for Underlying Event, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEUeChargedBC0->SetYTitle("x_{E}");
+ fhXEUeChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhZTChargedBC0 =
+ new TH2F("hZTChargedBC0","z_{T} for charged tracks, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTChargedBC0->SetYTitle("z_{T}");
+ fhZTChargedBC0->SetXTitle("p_{T trigger}");
+
+ fhZTUeChargedBC0 =
+ new TH2F("hZTUeChargedBC0","z_{T} for Underlying Event, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTUeChargedBC0->SetYTitle("z_{T}");
+ fhZTUeChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ outputContainer->Add(fhDeltaPhiChargedBC0) ;
+ outputContainer->Add(fhDeltaPhiChargedPtA3GeVBC0) ;
+ outputContainer->Add(fhXEChargedBC0) ;
+ outputContainer->Add(fhXEUeChargedBC0) ;
+ outputContainer->Add(fhZTChargedBC0) ;
+ outputContainer->Add(fhZTUeChargedBC0) ;
+ outputContainer->Add(fhPtTrigChargedBC0) ;
+
+ fhPtLeadingVtxBC0 = new TH1F("hPtLeadingVtxBC0","p_{T} distribution of leading particles", nptbins,ptmin,ptmax);
+ fhPtLeadingVtxBC0->SetXTitle("p_{T}^{trig} (GeV/c)");
+
+ fhDeltaPhiChargedVtxBC0 = new TH2F
+ ("hDeltaPhiChargedVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, track BC==0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedVtxBC0->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhDeltaPhiChargedPtA3GeVVtxBC0 = new TH2F
+ ("hDeltaPhiChargedPtA3GeVVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, track BC==0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedPtA3GeVVtxBC0->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedPtA3GeVVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhPtTrigChargedVtxBC0 =
+ new TH2F("hPtTrigChargedVtxBC0","trigger and charged tracks pt distribution, track BC==0",
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhPtTrigChargedVtxBC0->SetYTitle("p_{T h^{#pm}} (GeV/c)");
+ fhPtTrigChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhXEChargedVtxBC0 =
+ new TH2F("hXEChargedVtxBC0","x_{E} for charged tracks, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEChargedVtxBC0->SetYTitle("x_{E}");
+ fhXEChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhXEUeChargedVtxBC0 =
+ new TH2F("hXEUeChargedVtxBC0","x_{E} for Underlying Event, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEUeChargedVtxBC0->SetYTitle("x_{E}");
+ fhXEUeChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhZTChargedVtxBC0 =
+ new TH2F("hZTChargedVtxBC0","z_{T} for charged tracks, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTChargedVtxBC0->SetYTitle("z_{T}");
+ fhZTChargedVtxBC0->SetXTitle("p_{T trigger}");
+
+ fhZTUeChargedVtxBC0 =
+ new TH2F("hZTUeChargedVtxBC0","z_{T} for Underlying Event, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTUeChargedVtxBC0->SetYTitle("z_{T}");
+ fhZTUeChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ outputContainer->Add(fhPtLeadingVtxBC0);
+ outputContainer->Add(fhDeltaPhiChargedVtxBC0) ;
+ outputContainer->Add(fhDeltaPhiChargedPtA3GeVVtxBC0) ;
+ outputContainer->Add(fhXEChargedVtxBC0) ;
+ outputContainer->Add(fhXEUeChargedVtxBC0) ;
+ outputContainer->Add(fhZTChargedVtxBC0) ;
+ outputContainer->Add(fhZTUeChargedVtxBC0) ;
+ outputContainer->Add(fhPtTrigChargedVtxBC0) ;
+
for(Int_t i = 0 ; i < 7 ; i++)
{
fhPtLeadingPileUp[i] = new TH1F(Form("hPtLeadingPileUp%s",pileUpName[i].Data()),
fhEventMixBin->SetXTitle("bin");
outputContainer->Add(fhEventMixBin) ;
- fhNtracksAll=new TH1F("hNtracksAll","Number of tracks w/o event trigger",2000,0,2000);
- outputContainer->Add(fhNtracksAll);
-
- fhNtracksTrigger=new TH1F("hNtracksTriggerEvent","Number of tracks w/ event trigger",2000,0,2000);
- outputContainer->Add(fhNtracksTrigger);
-
fhNtracksMB=new TH1F("hNtracksMBEvent","Number of tracks w/ event trigger kMB",2000,0,2000);
outputContainer->Add(fhNtracksMB);
if(fFillNeutralEventMixPool || OnlyIsolated())
{
- fhNclustersAll=new TH1F("hNclustersAll","Number of clusters w/o event trigger",2000,0,2000);
- outputContainer->Add(fhNclustersAll);
-
- fhNclustersTrigger=new TH1F("hNclustersTriggerEvent","Number of clusters w/ event trigger",2000,0,2000);
- outputContainer->Add(fhNclustersTrigger);
-
fhNclustersMB=new TH1F("hNclustersMBEvent","Number of clusters w/ event trigger kMB",2000,0,2000);
outputContainer->Add(fhNclustersMB);
}
fhMixXECharged->SetYTitle("x_{E}");
fhMixXECharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhMixXECharged);
+
+ fhMixXEUeCharged =
+ new TH2F("hMixXEUeCharged","Mixed event : x_{E} for charged tracks in Ue region",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhMixXEUeCharged->SetYTitle("x_{E}");
+ fhMixXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhMixXEUeCharged);
- fhMixHbpXECharged =
+ fhMixHbpXECharged =
new TH2F("hMixHbpXECharged","mixed event : #xi = ln(1/x_{E}) with charged hadrons",
nptbins,ptmin,ptmax,200,0.,10.);
fhMixHbpXECharged->SetYTitle("ln(1/x_{E})");
}
//_____________________________________________________________
-Int_t AliAnaParticleHadronCorrelation::GetMCTagHistogramIndex(const Int_t mcTag)
+Int_t AliAnaParticleHadronCorrelation::GetMCTagHistogramIndex(Int_t mcTag)
{
// Index of MC histograms depending on MC origin
Double_t v[3] = {0,0,0}; //vertex ;
GetReader()->GetVertex(v);
if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;
-
- // Fill the pool with tracks if requested
- if(DoOwnMix())
- {
- FillChargedEventMixPool();
- if(OnlyIsolated() || fFillNeutralEventMixPool)
- FillNeutralEventMixPool();
- }
-
+
//Loop on stored AOD particles, find leading trigger
Double_t ptTrig = fMinTriggerPt ;
fLeadingTriggerIndex = -1 ;
GetReader()->GetVertex(v);
if(!GetMixedEvent() && TMath::Abs(v[2]) > GetZvertexCut()) return ;
+ Float_t cen = GetEventCentrality();
+ Float_t ep = GetEventPlaneAngle();
+
//Loop on stored AOD particles, find leading
Double_t ptTrig = fMinTriggerPt;
if(fLeadingTriggerIndex < 0)
if(fFillPileUpHistograms)
{
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtLeadingVtxBC0->Fill(pt);
+
if(GetReader()->IsPileUpFromSPD()) fhPtLeadingPileUp[0]->Fill(pt);
if(GetReader()->IsPileUpFromEMCal()) fhPtLeadingPileUp[1]->Fill(pt);
if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtLeadingPileUp[2]->Fill(pt);
Int_t mcIndex = GetMCTagHistogramIndex(particle->GetTag());
fhPtLeadingMC[mcIndex]->Fill(pt);
}
-
- Float_t cen = GetEventCentrality();
- Float_t ep = GetEventPlaneAngle();
-
+
fhPtLeadingCentrality ->Fill(pt,cen);
fhPtLeadingEventPlane ->Fill(pt,ep);
fhLeadingEventPlaneCentrality->Fill(cen,ep);
//___________________________________________________________________________________________________________
Bool_t AliAnaParticleHadronCorrelation::MakeChargedCorrelation(AliAODPWG4ParticleCorrelation *aodParticle,
- const TObjArray* pl, const Bool_t bFillHisto)
+ const TObjArray* pl, Bool_t bFillHisto)
{
// Charged Hadron Correlation Analysis
if(GetDebug() > 1)
Float_t ptTrig = aodParticle->Pt();
Bool_t decay = aodParticle->IsTagged();
Int_t mcTag = aodParticle->GetTag();
-
+ Double_t bz = GetReader()->GetInputEvent()->GetMagneticField();
+
Float_t pt = -100. ;
Float_t zT = -100. ;
Float_t xE = -100. ;
//printf("assoc Bin = %d, vZ bin = %d, bin = %d \n", assocBin,GetEventVzBin(),bin);
+ ULong_t status = track->GetStatus();
+ Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
+ //Double32_t tof = track->GetTOFsignal()*1e-3;
+ Int_t trackBC = track->GetTOFBunchCrossing(bz);
+
+ Int_t outTOF = -1;
+ if (okTOF && trackBC!=0) outTOF = 1;
+ else if(okTOF && trackBC==0) outTOF = 0;
+
// Azimuthal Angle
// calculate deltaPhi for later, shift when needed
FillChargedAngularCorrelationHistograms(pt, ptTrig, bin, phi, phiTrig, deltaPhi,
- eta, etaTrig, decay, track->GetHMPIDsignal(),nTracks,mcTag);
+ eta, etaTrig, decay, track->GetHMPIDsignal(),outTOF,nTracks,mcTag);
// Imbalance zT/xE/pOut
zT = pt/ptTrig ;
pout = pt*TMath::Sin(deltaPhi) ;
//delta phi cut for momentum imbalance correlation
- if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
+ if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
{
FillChargedMomentumImbalanceHistograms(ptTrig, pt, xE, hbpXE, zT, hbpZT, pout,
- nTracks, track->Charge(), bin, decay,mcTag);
+ nTracks, track->Charge(), bin, decay,outTOF,mcTag);
- }
- if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
+ }
+
+ if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
{ //UE study
- FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, nTracks);
+ FillChargedUnderlyingEventHistograms(ptTrig, pt, deltaPhi, nTracks,outTOF);
fhUePart->Fill(ptTrig);
if(xE > 0 ) hbpXE = TMath::Log(1./xE);
else hbpXE =-100;
- if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
+ if ( (deltaPhi > fDeltaPhiMinCut) && (deltaPhi < fDeltaPhiMaxCut) )
{
fhMixXECharged->Fill(ptTrig,xE);
fhMixHbpXECharged->Fill(ptTrig,hbpXE);
}
-
+
+ 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;
+
+ fhMixXEUeCharged->Fill(ptTrig,uexE);
+ }
+
if(bin < 0) continue ; // this pt bin was not considered
if(TMath::Abs(deltaEta) > 0.8)
//________________________________________________________________________________________________________________
Bool_t AliAnaParticleHadronCorrelation::MakeNeutralCorrelation(AliAODPWG4ParticleCorrelation * const aodParticle,
- const TObjArray* pi0list, const Bool_t bFillHisto)
+ const TObjArray* pi0list, Bool_t bFillHisto)
{
// Neutral Pion Correlation Analysis
if(GetDebug() > 1) printf("AliAnaParticleHadronCorrelation::MakeNeutralCorrelation() - Make trigger particle - pi0 correlation, %d pi0's \n",
else if(GetReader()->ReadAODMCParticles())
{
//Get the list of MC particles
- mcparticles0 = GetReader()->GetAODMCParticles(0);
+ mcparticles0 = GetReader()->GetAODMCParticles();
if(!mcparticles0) return;
if(label >=mcparticles0->GetEntriesFast())
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff