fFillPileUpHistograms(0),
//Histograms
fhPtInput(0), fhPtFidCut(0),
- fhPtLeading(0), fhPtLeadingPileUp(),
+ fhPtLeading(0), fhPtLeadingVtxBC0(0),
fhPtLeadingVzBin(0), fhPtLeadingBin(0),
fhPhiLeading(0), fhEtaLeading(0),
fhPtLeadingMC(),
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(),
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) ; }
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); }
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::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(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++)
{
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})");
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);
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,outTOF,mcTag);
- }
+ }
+
if ( (deltaPhi > fUeDeltaPhiMinCut) && (deltaPhi < fUeDeltaPhiMaxCut) )
{ //UE study
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)
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