fLeadingTriggerIndex(-1), fHMPIDCorrelation(0), fFillBradHisto(0),
fNAssocPtBins(0), fAssocPtBinLimit(),
fCorrelVzBin(0),
- fListMixTrackEvents(), fListMixCaloEvents(), fUseMixStoredInReader(0),
+ fListMixTrackEvents(), fListMixCaloEvents(),
+ fUseMixStoredInReader(0), fFillNeutralEventMixPool(0),
fM02MaxCut(0), fM02MinCut(0),
- fFillPileUpHistograms(0),
+ fFillPileUpHistograms(0),
//Histograms
fhPtInput(0), fhPtFidCut(0),
- fhPtLeading(0), fhPtLeadingPileUp(0),
+ fhPtLeading(0), fhPtLeadingVtxBC0(0),
fhPtLeadingVzBin(0), fhPtLeadingBin(0),
fhPhiLeading(0), fhEtaLeading(0),
fhPtLeadingMC(),
fhDeltaPhiDeltaEtaChargedPtA3GeV(0),
fhDeltaPhiChargedPtA3GeV(0), fhDeltaEtaChargedPtA3GeV(0),
//Pile-Up
- fhDeltaPhiChargedPileUp(0), fhDeltaEtaChargedPileUp(0),
- fhXEChargedPileUp(0), fhXEUeChargedPileUp(0),
- fhZTChargedPileUp(0), fhZTUeChargedPileUp(0),
- fhPtTrigChargedPileUp(0),
- fhDeltaPhiChargedPtA3GeVPileUp(0), fhDeltaEtaChargedPtA3GeVPileUp(0),
-
+ fhDeltaPhiChargedPileUp(), fhDeltaEtaChargedPileUp(),
+ fhDeltaPhiChargedPtA3GeVPileUp(), fhDeltaEtaChargedPtA3GeVPileUp(),
+ fhXEChargedPileUp(), fhXEUeChargedPileUp(),
+ fhZTChargedPileUp(), fhZTUeChargedPileUp(),
+ fhPtTrigChargedPileUp(),
+ fhDeltaPhiChargedOtherBC(), fhDeltaPhiChargedPtA3GeVOtherBC(),
+ fhXEChargedOtherBC(), fhXEUeChargedOtherBC(),
+ fhZTChargedOtherBC(), fhZTUeChargedOtherBC(),
+ fhPtTrigChargedOtherBC(),
+ fhDeltaPhiChargedBC0(), fhDeltaPhiChargedPtA3GeVBC0(),
+ fhXEChargedBC0(), fhXEUeChargedBC0(),
+ fhZTChargedBC0(), fhZTUeChargedBC0(),
+ fhPtTrigChargedBC0(),
+ fhDeltaPhiChargedVtxBC0(), fhDeltaPhiChargedPtA3GeVVtxBC0(),
+ fhXEChargedVtxBC0(), fhXEUeChargedVtxBC0(),
+ fhZTChargedVtxBC0(), fhZTUeChargedVtxBC0(),
+ fhPtTrigChargedVtxBC0(),
fhDeltaPhiUeLeftCharged(0), 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),
+ fhNEventsTrigger(0), fhNtracksMB(0), fhNclustersMB(0),
fhMixDeltaPhiCharged(0), fhMixDeltaPhiDeltaEtaCharged(0),
- fhMixXECharged(0), fhMixHbpXECharged(0),
+ fhMixXECharged(0), fhMixXEUeCharged(0), fhMixHbpXECharged(0),
fhMixDeltaPhiChargedAssocPtBin(),
fhMixDeltaPhiChargedAssocPtBinDEta08(),
fhMixDeltaPhiChargedAssocPtBinDEta0(),
fhDeltaPhiChargedMC[i] = 0;
}
+ for(Int_t i = 0; i < 7; i++)
+ {
+ fhPtLeadingPileUp [i] = 0 ;
+ fhDeltaPhiChargedPileUp [i] = 0 ; fhDeltaEtaChargedPileUp [i] = 0 ;
+ fhXEChargedPileUp [i] = 0 ; fhXEUeChargedPileUp [i] = 0 ;
+ fhZTChargedPileUp [i] = 0 ; fhZTUeChargedPileUp [i] = 0 ;
+ fhPtTrigChargedPileUp [i] = 0 ;
+ fhDeltaPhiChargedPtA3GeVPileUp[i] = 0 ; fhDeltaEtaChargedPtA3GeVPileUp[i] = 0 ;
+ }
+
}
//_________________________________________________________________
-AliAnaParticleHadronCorrelation::~AliAnaParticleHadronCorrelation()
+AliAnaParticleHadronCorrelation::~AliAnaParticleHadronCorrelation()
{
// Remove event containers
}
//______________________________________________________________________________________________________________________________________________________
-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
}
// Pile up studies
- if(fFillPileUpHistograms && GetReader()->IsPileUpFromSPD())
+
+ if(fFillPileUpHistograms)
{
- fhDeltaEtaChargedPileUp->Fill(ptTrig ,deltaEta);
- fhDeltaPhiChargedPileUp->Fill(ptTrig ,deltaPhi);
+ if (outTOF==1)
+ {
+ fhDeltaPhiChargedOtherBC->Fill(ptTrig ,deltaPhi) ;
+ if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVOtherBC->Fill(ptTrig ,deltaPhi) ;
+ }
+ else if(outTOF==0)
+ {
+ fhDeltaPhiChargedBC0->Fill(ptTrig ,deltaPhi) ;
+ if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVBC0->Fill(ptTrig ,deltaPhi) ;
+ }
+
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
+ {
+ fhDeltaPhiChargedVtxBC0->Fill(ptTrig ,deltaPhi) ;
+ if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVVtxBC0->Fill(ptTrig ,deltaPhi) ;
+ }
+
+ if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[1]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[2]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhDeltaEtaChargedPileUp[3]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[3]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[4]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[4]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[5]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[6]->Fill(ptTrig ,deltaPhi) ; }
+
if(ptAssoc > 3 )
{
- fhDeltaEtaChargedPtA3GeVPileUp->Fill(ptTrig ,deltaEta);
- fhDeltaPhiChargedPtA3GeVPileUp->Fill(ptTrig ,deltaPhi);
+ if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[1]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[2]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[3]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[3]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[4]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[4]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[5]->Fill(ptTrig ,deltaPhi) ; }
+ if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPtA3GeVPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[6]->Fill(ptTrig ,deltaPhi) ; }
}
}
}
//____________________________________________________________________________________________________________________________________________________
-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
fhPtTrigCharged ->Fill(ptTrig , ptAssoc) ;
// Pile up studies
- if(fFillPileUpHistograms && GetReader()->IsPileUpFromSPD())
+ if(fFillPileUpHistograms)
{
- fhXEChargedPileUp ->Fill(ptTrig , xE);
- fhZTChargedPileUp ->Fill(ptTrig , zT);
- fhPtTrigChargedPileUp->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(uexE > 0) fhPtHbpZTUeCharged->Fill(ptTrig,TMath::Log(1/uezT));
// Pile up studies
- if(fFillPileUpHistograms && GetReader()->IsPileUpFromSPD())
+
+ if(fFillPileUpHistograms)
{
- fhXEUeChargedPileUp->Fill(ptTrig,uexE);
- fhZTUeChargedPileUp->Fill(ptTrig,uezT);
- }
+ 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);}
+ if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhXEUeChargedPileUp[3]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[3]->Fill(ptTrig,uezT);}
+ if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhXEUeChargedPileUp[4]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[4]->Fill(ptTrig,uezT);}
+ if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhXEUeChargedPileUp[5]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[5]->Fill(ptTrig,uezT);}
+ if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhXEUeChargedPileUp[6]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[6]->Fill(ptTrig,uezT);}
+ }
if(DoEventSelect())
{
}
//_____________________________________________________________________________________________________
-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 ;
//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
}
- // Int_t nClusters = GetEMCALClusters()->GetEntriesFast();
- //
- // fhNclustersAll->Fill(nClusters);
-
AliAnalysisManager * manager = AliAnalysisManager::GetAnalysisManager();
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 ;
- // fhNClustersMB->Fill(nCluster);
+ fhNclustersMB->Fill(nClusters);
Int_t eventBin = GetEventMixBin();
TList * poolCalo = fListMixCaloEvents[eventBin];
- TObjArray * pl = GetEMCALClusters();
- //if (GetAODObjArrayName.Contains("PHOS") )pl = GetPHOSClusters();
- //else pl = GetEMCALClusters();
-
TLorentzVector mom;
- //printf("NClusters before selection %d\n",pl->GetEntriesFast());
- for(Int_t ipr = 0;ipr < pl->GetEntriesFast() ; ipr ++ )
+
+ for(Int_t ipr = 0;ipr < nClusters ; ipr ++ )
{
AliVCluster * calo = (AliVCluster *) (pl->At(ipr)) ;
// remove matched clusters
if( IsTrackMatched( calo, GetReader()->GetInputEvent() ) ) continue ;
- //Cluster momentum calculation
+ //Cluster momentum calculation
if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
{
calo->GetMomentum(mom,GetVertex(0)) ;
Int_t nMixBins = GetNCentrBin()*GetNZvertBin()*GetNRPBin();
- TString nameMC[] = {"Photon","Pi0","Pi0Decay","EtaDecay","OtherDecay","Electron","Hadron"};
-
+ TString nameMC[] = {"Photon","Pi0","Pi0Decay","EtaDecay","OtherDecay","Electron","Hadron"};
+ TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
+
// For vz dependent histograms, if option ON
Int_t nz = 1 ;
if(fCorrelVzBin) nz = GetNZvertBin();
fhDeltaPhiDeltaEtaCharged = new TH2F
("hDeltaPhiDeltaEtaCharged","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}}",
ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
- fhDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi");
+ fhDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
fhDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
fhDeltaPhiDeltaEtaChargedPtA3GeV = new TH2F
("hDeltaPhiDeltaEtaChargedPtA3GeV","#eta_{trigger} - #eta_{h^{#pm}} vs #phi_{trigger} - #phi_{h^{#pm}, p_{TA}>3 GeV/c}",
ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
- fhDeltaPhiDeltaEtaChargedPtA3GeV->SetXTitle("#Delta #phi");
+ fhDeltaPhiDeltaEtaChargedPtA3GeV->SetXTitle("#Delta #phi (rad)");
fhDeltaPhiDeltaEtaChargedPtA3GeV->SetYTitle("#Delta #eta");
fhPhiCharged = new TH2F
fhDeltaPhiCharged = new TH2F
("hDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiCharged->SetYTitle("#Delta #phi");
+ fhDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhDeltaPhiChargedPtA3GeV = new TH2F
("hDeltaPhiChargedPtA3GeV","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiChargedPtA3GeV->SetYTitle("#Delta #phi");
+ fhDeltaPhiChargedPtA3GeV->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiChargedPtA3GeV->SetXTitle("p_{T trigger} (GeV/c)");
fhDeltaPhiChargedPt = new TH2F
("hDeltaPhiChargedPt","#phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiChargedPt->SetYTitle("#Delta #phi");
+ fhDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
fhDeltaPhiUeChargedPt = new TH2F
("hDeltaPhiUeChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}}",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeChargedPt->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
fhUePart = new TH1F("hUePart","UE particles distribution vs pt trig",
nptbins,ptmin,ptmax);
fhUePart->SetYTitle("dNch");
- fhUePart->SetXTitle("p_{T trigger}");
+ fhUePart->SetXTitle("p_{T trigger} (GeV/c)");
fhDeltaEtaCharged = new TH2F
new TH2F("hXECharged","x_{E} for charged tracks",
nptbins,ptmin,ptmax,200,0.,2.);
fhXECharged->SetYTitle("x_{E}");
- fhXECharged->SetXTitle("p_{T trigger}");
+ fhXECharged->SetXTitle("p_{T trigger} (GeV/c)");
fhXEUeCharged =
new TH2F("hXEUeCharged","x_{E} for Underlying Event",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeCharged->SetYTitle("x_{E}");
- fhXEUeCharged->SetXTitle("p_{T trigger}");
+ fhXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhXEPosCharged =
new TH2F("hXEPositiveCharged","x_{E} for positive charged tracks",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEPosCharged->SetYTitle("x_{E}");
- fhXEPosCharged->SetXTitle("p_{T trigger}");
+ fhXEPosCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhXENegCharged =
new TH2F("hXENegativeCharged","x_{E} for negative charged tracks",
nptbins,ptmin,ptmax,200,0.,2.);
fhXENegCharged->SetYTitle("x_{E}");
- fhXENegCharged->SetXTitle("p_{T trigger}");
+ fhXENegCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhPtHbpXECharged =
new TH2F("hHbpXECharged","#xi = ln(1/x_{E}) with charged hadrons",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXECharged->SetYTitle("ln(1/x_{E})");
- fhPtHbpXECharged->SetXTitle("p_{T trigger}");
+ fhPtHbpXECharged->SetXTitle("p_{T trigger} (GeV/c)");
fhPtHbpXEUeCharged =
new TH2F("hHbpXEUeCharged","#xi = ln(1/x_{E}) with charged hadrons,Underlying Event",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXEUeCharged->SetYTitle("ln(1/x_{E})");
- fhPtHbpXEUeCharged->SetXTitle("p_{T trigger}");
+ fhPtHbpXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhZTCharged =
new TH2F("hZTCharged","z_{T} for charged tracks",
new TH2F("hZTUeCharged","z_{T} for Underlying Event",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTUeCharged->SetYTitle("z_{T}");
- fhZTUeCharged->SetXTitle("p_{T trigger}");
+ fhZTUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhZTPosCharged =
new TH2F("hZTPositiveCharged","z_{T} for positive charged tracks",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTPosCharged->SetYTitle("z_{T}");
- fhZTPosCharged->SetXTitle("p_{T trigger}");
+ fhZTPosCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhZTNegCharged =
new TH2F("hZTNegativeCharged","z_{T} for negative charged tracks",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTNegCharged->SetYTitle("z_{T}");
- fhZTNegCharged->SetXTitle("p_{T trigger}");
+ fhZTNegCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhPtHbpZTCharged =
new TH2F("hHbpZTCharged","#xi = ln(1/z_{T}) with charged hadrons",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpZTCharged->SetYTitle("ln(1/z_{T})");
- fhPtHbpZTCharged->SetXTitle("p_{T trigger}");
+ fhPtHbpZTCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhPtHbpZTUeCharged =
new TH2F("hHbpZTUeCharged","#xi = ln(1/z_{T}) with charged hadrons,Underlying Event",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpZTUeCharged->SetYTitle("ln(1/x_{E})");
- fhPtHbpZTUeCharged->SetXTitle("p_{T trigger}");
+ fhPtHbpZTUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhPtTrigPout =
new TH2F("hPtTrigPout","Pout with triggers",
outputContainer->Add(fhUePart);
outputContainer->Add(fhXECharged) ;
-
+
if(IsDataMC())
{
for(Int_t i=0; i < 7; i++)
Form("#Delta #phi for charged tracks, trigger origin is %s",nameMC[i].Data()),
nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
fhDeltaPhiChargedMC[i]->SetYTitle("x_{E}");
- fhDeltaPhiChargedMC[i]->SetXTitle("p_{T trigger}");
+ fhDeltaPhiChargedMC[i]->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhDeltaPhiChargedMC[i]) ;
fhXEChargedMC[i] = new TH2F(Form("hXECharged_MC%s",nameMC[i].Data()),
Form("x_{E} for charged tracks, trigger origin is %s",nameMC[i].Data()),
nptbins,ptmin,ptmax,200,0.,2.);
fhXEChargedMC[i]->SetYTitle("x_{E}");
- fhXEChargedMC[i]->SetXTitle("p_{T trigger}");
+ fhXEChargedMC[i]->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEChargedMC[i]) ;
}
}
outputContainer->Add(fhPtTrigPout) ;
outputContainer->Add(fhPtTrigCharged) ;
-
if(fFillPileUpHistograms)
{
- fhPtLeadingPileUp = new TH1F("hPtLeadingPileUp","p_{T} distribution of leading particles, SPD Pile-Up event", nptbins,ptmin,ptmax);
- fhPtLeadingPileUp->SetXTitle("p_{T}^{trig} (GeV/c)");
- outputContainer->Add(fhPtLeadingPileUp);
+ 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)");
- fhDeltaPhiChargedPileUp = new TH2F
- ("hDeltaPhiChargedPileUp","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, SPD Pile-Up event",
+ 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);
- fhDeltaPhiChargedPileUp->SetYTitle("#Delta #phi");
- fhDeltaPhiChargedPileUp->SetXTitle("p_{T trigger} (GeV/c)");
- outputContainer->Add(fhDeltaPhiChargedPileUp) ;
+ fhDeltaPhiChargedBC0->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedBC0->SetXTitle("p_{T trigger} (GeV/c)");
- fhDeltaPhiChargedPtA3GeVPileUp = new TH2F
- ("hDeltaPhiChargedPtA3GeVPileUp","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, SPD Pile-Up event",
+ 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);
- fhDeltaPhiChargedPtA3GeVPileUp->SetYTitle("#Delta #phi");
- fhDeltaPhiChargedPtA3GeVPileUp->SetXTitle("p_{T trigger} (GeV/c)");
- outputContainer->Add(fhDeltaPhiChargedPtA3GeVPileUp) ;
-
- fhDeltaEtaChargedPileUp = new TH2F
- ("hDeltaEtaChargedPileUp","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}, SPD Pile-Up event",
- nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
- fhDeltaEtaChargedPileUp->SetYTitle("#Delta #eta");
- fhDeltaEtaChargedPileUp->SetXTitle("p_{T trigger} (GeV/c)");
- outputContainer->Add(fhDeltaEtaChargedPileUp) ;
-
- fhDeltaEtaChargedPtA3GeVPileUp = new TH2F
- ("hDeltaEtaChargedPtA3GeVPileUp","#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, SPD Pile-Up event",
- nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
- fhDeltaEtaChargedPtA3GeVPileUp->SetYTitle("#Delta #eta");
- fhDeltaEtaChargedPtA3GeVPileUp->SetXTitle("p_{T trigger} (GeV/c)");
- outputContainer->Add(fhDeltaEtaChargedPtA3GeVPileUp) ;
-
- fhXEChargedPileUp =
- new TH2F("hXEChargedPileUp","x_{E} for charged tracks, SPD Pile-Up event",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEChargedPileUp->SetYTitle("x_{E}");
- fhXEChargedPileUp->SetXTitle("p_{T trigger}");
- outputContainer->Add(fhXEChargedPileUp) ;
-
- fhXEUeChargedPileUp =
- new TH2F("hXEUeChargedPileUp","x_{E} for Underlying Event, SPD Pile-Up event",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhXEUeChargedPileUp->SetYTitle("x_{E}");
- fhXEUeChargedPileUp->SetXTitle("p_{T trigger}");
- outputContainer->Add(fhXEUeChargedPileUp) ;
+ 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)");
- fhZTChargedPileUp =
- new TH2F("hZTChargedPileUp","z_{T} for charged tracks, SPD Pile-Up event",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTChargedPileUp->SetYTitle("z_{T}");
- fhZTChargedPileUp->SetXTitle("p_{T trigger}");
- outputContainer->Add(fhZTChargedPileUp) ;
-
- fhZTUeChargedPileUp =
- new TH2F("hZTUeChargedPileUp","z_{T} for Underlying Event, SPD Pile-Up event",
- nptbins,ptmin,ptmax,200,0.,2.);
- fhZTUeChargedPileUp->SetYTitle("z_{T}");
- fhZTUeChargedPileUp->SetXTitle("p_{T trigger}");
- outputContainer->Add(fhZTUeChargedPileUp) ;
-
- fhPtTrigChargedPileUp =
- new TH2F("hPtTrigChargedPileUp","trigger and charged tracks pt distribution, SPD Pile-Up event",
- nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
- fhPtTrigChargedPileUp->SetYTitle("p_{T h^{#pm}} (GeV/c)");
- fhPtTrigChargedPileUp->SetXTitle("p_{T trigger} (GeV/c)");
- outputContainer->Add(fhPtTrigChargedPileUp) ;
-
+ 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()),
+ Form("p_{T} distribution of leading particles, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
+ fhPtLeadingPileUp[i]->SetXTitle("p_{T}^{trig} (GeV/c)");
+ outputContainer->Add(fhPtLeadingPileUp[i]);
+
+ fhDeltaPhiChargedPileUp[i] = new TH2F(Form("hDeltaPhiChargedPileUp%s",pileUpName[i].Data()),
+ Form("#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedPileUp[i]->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhDeltaPhiChargedPileUp[i]) ;
+
+ fhDeltaPhiChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaPhiChargedPtA3GeVPileUp%s",pileUpName[i].Data()),
+ Form("#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedPtA3GeVPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhDeltaPhiChargedPtA3GeVPileUp[i]) ;
+
+ fhDeltaEtaChargedPileUp[i] = new TH2F(Form("hDeltaEtaChargedPileUp%s",pileUpName[i].Data()),
+ Form("#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
+ fhDeltaEtaChargedPileUp[i]->SetYTitle("#Delta #eta");
+ fhDeltaEtaChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhDeltaEtaChargedPileUp[i]) ;
+
+ fhDeltaEtaChargedPtA3GeVPileUp[i] = new TH2F(Form("hDeltaEtaChargedPtA3GeVPileUp%s",pileUpName[i].Data()),
+ Form("#eta_{trigger} - #eta_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax,ndeltaetabins,deltaetamin,deltaetamax);
+ fhDeltaEtaChargedPtA3GeVPileUp[i]->SetYTitle("#Delta #eta");
+ fhDeltaEtaChargedPtA3GeVPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhDeltaEtaChargedPtA3GeVPileUp[i]) ;
+
+ fhXEChargedPileUp[i] = new TH2F(Form("hXEChargedPileUp%s",pileUpName[i].Data()),
+ Form("x_{E} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEChargedPileUp[i]->SetYTitle("x_{E}");
+ fhXEChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhXEChargedPileUp[i]) ;
+
+ fhXEUeChargedPileUp[i] = new TH2F(Form("hXEUeChargedPileUp%s",pileUpName[i].Data()),
+ Form("x_{E} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEUeChargedPileUp[i]->SetYTitle("x_{E}");
+ fhXEUeChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhXEUeChargedPileUp[i]) ;
+
+ fhZTChargedPileUp[i] = new TH2F(Form("hZTChargedPileUp%s",pileUpName[i].Data()),
+ Form("z_{T} for charged tracks, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTChargedPileUp[i]->SetYTitle("z_{T}");
+ fhZTChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhZTChargedPileUp[i]) ;
+
+ fhZTUeChargedPileUp[i] = new TH2F(Form("hZTUeChargedPileUp%s",pileUpName[i].Data()),
+ Form("z_{T} for Underlying Event, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTUeChargedPileUp[i]->SetYTitle("z_{T}");
+ fhZTUeChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhZTUeChargedPileUp[i]) ;
+
+ fhPtTrigChargedPileUp[i] = new TH2F(Form("hPtTrigChargedPileUp%s",pileUpName[i].Data()),
+ Form("trigger and charged tracks pt distribution, %s Pile-Up event",pileUpName[i].Data()),
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhPtTrigChargedPileUp[i]->SetYTitle("p_{T h^{#pm}} (GeV/c)");
+ fhPtTrigChargedPileUp[i]->SetXTitle("p_{T trigger} (GeV/c)");
+ outputContainer->Add(fhPtTrigChargedPileUp[i]) ;
+
+ }
}
if(DoEventSelect())
fhTrigDeltaPhiCharged[im] = new TH2F
(Form("hTrigDeltaPhiCharged_%d",im),Form("hTrigDeltaPhiCharged_%d",im), nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
fhTrigDeltaPhiCharged[im]->SetXTitle("p_{T trigger} (GeV/c)");
- fhTrigDeltaPhiCharged[im]->SetYTitle("#Delta #phi");
+ fhTrigDeltaPhiCharged[im]->SetYTitle("#Delta #phi (rad)");
fhTrigDeltaEtaCharged[im] = new TH2F
(Form("hTrigDeltaEtaCharged_%d",im),Form("hTrigDeltaEtaCharged_%d",im), nptbins,ptmin,ptmax, ndeltaetabins ,deltaetamin,deltaetamax);
fhTrigXECorr[im] = new TH2F
(Form("hTrigXEPtCorr_%d",im),Form("hTrigXEPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
fhTrigXECorr[im]->SetYTitle("x_{E trigger h^{#pm}}");
- fhTrigXECorr[im]->SetXTitle("p_{T trigger}");
+ fhTrigXECorr[im]->SetXTitle("p_{T trigger} (GeV/c)");
fhTrigXEUeCorr[im] = new TH2F
(Form("hTrigXEPtUeCorr_%d",im),Form("hTrigXEPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
fhTrigXEUeCorr[im]->SetYTitle("x_{E trigger h^{#pm}}");
- fhTrigXEUeCorr[im]->SetXTitle("p_{T trigger}");
+ fhTrigXEUeCorr[im]->SetXTitle("p_{T trigger}(GeV/c)");
fhTrigZTCorr[im] = new TH2F
(Form("hTrigZTPtCorr_%d",im),Form("hTrigZTPtCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
fhTrigZTCorr[im]->SetYTitle("z_{trigger h^{#pm}}");
- fhTrigZTCorr[im]->SetXTitle("p_{T trigger}");
+ fhTrigZTCorr[im]->SetXTitle("p_{T trigger} (GeV/c)");
fhTrigZTUeCorr[im] = new TH2F
(Form("hTrigZTPtUeCorr_%d",im),Form("hTrigZTPtUeCorr_%d",im), nptbins,ptmin,ptmax,200,0.,2.);
fhTrigZTUeCorr[im]->SetYTitle("z_{trigger h^{#pm}}");
- fhTrigZTUeCorr[im]->SetXTitle("p_{T trigger}");
+ fhTrigZTUeCorr[im]->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhTrigDeltaPhiCharged[im]) ;
outputContainer->Add(fhTrigDeltaEtaCharged[im]) ;
{
fhAssocPtBkg = new TH2F("hAssocPtBkg", " Trigger p_{T} vs associated hadron p_{T} from background",
nptbins, ptmin, ptmax,nptbins,ptmin,ptmax);
- fhAssocPtBkg->SetXTitle("p_{T trigger}");
- fhAssocPtBkg->SetYTitle("p_{T associated}");
+ fhAssocPtBkg->SetXTitle("p_{T trigger} (GeV/c)");
+ fhAssocPtBkg->SetYTitle("p_{T associated} (GeV/c)");
outputContainer->Add(fhAssocPtBkg) ;
fhDeltaPhiBrad = new TH2F("hDeltaPhiBrad","atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs p_{T trigger} ",
nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
- fhDeltaPhiBrad->SetXTitle("p_{T trigger}");
+ fhDeltaPhiBrad->SetXTitle("p_{T trigger} (GeV/c)");
fhDeltaPhiBrad->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
outputContainer->Add(fhDeltaPhiBrad) ;
}
fhDeltaPhiDeltaEtaAssocPtBin[bin] = new TH2F(Form("hDeltaPhiDeltaEtaPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("#Delta #phi vs #Delta #eta for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins,deltaetamin,deltaetamax);
- fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetXTitle("#Delta #phi");
+ fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
fhDeltaPhiDeltaEtaAssocPtBin[bin]->SetYTitle("#Delta #eta");
fhDeltaPhiAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiAssocPtBin[bin]->SetXTitle("p_{T trigger}");
- fhDeltaPhiAssocPtBin[bin]->SetYTitle("#Delta #phi");
+ fhDeltaPhiAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/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 p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("p_{T trigger}");
- fhDeltaPhiAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi");
+ fhDeltaPhiAssocPtBinDEta08[bin]->SetXTitle("p_{T trigger} (GeV/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 p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0.", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("p_{T trigger}");
- fhDeltaPhiAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi");
+ fhDeltaPhiAssocPtBinDEta0[bin]->SetXTitle("p_{T trigger} (GeV/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("x_{E} vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax,200, 0.0, 2.0);
- fhXEAssocPtBin[bin]->SetXTitle("p_{T trigger}");
+ fhXEAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
fhXEAssocPtBin[bin]->SetYTitle("x_{E}");
fhZTAssocPtBin[bin] = new TH2F(Form("hZTAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("z_{T} vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax,200, 0.0, 2.0);
- fhZTAssocPtBin[bin]->SetXTitle("p_{T trigger}");
+ fhZTAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
fhZTAssocPtBin[bin]->SetYTitle("z_{T}");
outputContainer->Add(fhDeltaPhiDeltaEtaAssocPtBin[bin]) ;
fhDeltaPhiDecayChargedAssocPtBin[bin] = new TH2F(Form("hDeltaPhiPtDecayChargedAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("#Delta #phi vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger}");
- fhDeltaPhiDecayChargedAssocPtBin[bin]->SetYTitle("#Delta #phi");
+ fhDeltaPhiDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
+ fhDeltaPhiDecayChargedAssocPtBin[bin]->SetYTitle("#Delta #phi (rad)");
fhXEDecayChargedAssocPtBin[bin] = new TH2F(Form("hXEDecayChargedAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("x_{E} vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax,200, 0.0, 2.0);
- fhXEDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger}");
+ fhXEDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
fhXEDecayChargedAssocPtBin[bin]->SetYTitle("x_{E}");
fhZTDecayChargedAssocPtBin[bin] = new TH2F(Form("hZTDecayChargedAssocPtBin%1.f_%1.f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("z_{T} vs p_{T trigger} tagged as decay for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax,200, 0.0, 2.0);
- fhZTDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger}");
+ fhZTDecayChargedAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
fhZTDecayChargedAssocPtBin[bin]->SetYTitle("z_{T}");
outputContainer->Add(fhDeltaPhiDecayChargedAssocPtBin[bin]) ;
fhDeltaPhiBradAssocPtBin[bin] = new TH2F(Form("hDeltaPhiBradPtAssocPt%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax,288, -1.0/3.0, 5.0/3.0);
- fhDeltaPhiBradAssocPtBin[bin]->SetXTitle("p_{T trigger}");
+ fhDeltaPhiBradAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/c)");
fhDeltaPhiBradAssocPtBin[bin]->SetYTitle("atan2(sin(#Delta #phi), cos(#Delta #phi))/#pi");
outputContainer->Add(fhDeltaPhiBradAssocPtBin[bin]) ;
}
fhDeltaPhiAssocPtBinHMPID[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPID", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, with track having HMPID signal", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiAssocPtBinHMPID[bin]->SetXTitle("p_{T trigger}");
- fhDeltaPhiAssocPtBinHMPID[bin]->SetYTitle("#Delta #phi");
+ fhDeltaPhiAssocPtBinHMPID[bin]->SetXTitle("p_{T trigger} (GeV/c)" );
+ fhDeltaPhiAssocPtBinHMPID[bin]->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiAssocPtBinHMPIDAcc[bin] = new TH2F(Form("hDeltaPhiPtAssocPt%2.1f_%2.1f%sHMPIDAcc", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("#Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, with track within 5<phi<20 deg", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetXTitle("p_{T trigger}");
- fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetYTitle("#Delta #phi");
+ fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetXTitle("p_{T trigger} (GeV/c)");
+ fhDeltaPhiAssocPtBinHMPIDAcc[bin]->SetYTitle("#Delta #phi (rad)");
outputContainer->Add(fhDeltaPhiAssocPtBinHMPID[bin]) ;
outputContainer->Add(fhDeltaPhiAssocPtBinHMPIDAcc[bin]) ;
fhDeltaPhiDecayCharged = new TH2F
("hDeltaPhiDecayCharged","#phi_{Decay} - #phi_{h^{#pm}} vs p_{T Decay}",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiDecayCharged->SetYTitle("#Delta #phi");
+ fhDeltaPhiDecayCharged->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiDecayCharged->SetXTitle("p_{T Decay} (GeV/c)");
fhXEDecayCharged =
new TH2F("hXEDecayCharged","x_{E} Decay",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEDecayCharged->SetYTitle("x_{E}");
- fhXEDecayCharged->SetXTitle("p_{T decay}");
+ fhXEDecayCharged->SetXTitle("p_{T decay} (GeV/c)");
fhZTDecayCharged =
new TH2F("hZTDecayCharged","z_{trigger h^{#pm}} = p_{T h^{#pm}} / p_{T Decay}",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTDecayCharged->SetYTitle("z_{decay h^{#pm}}");
- fhZTDecayCharged->SetXTitle("p_{T decay}");
+ fhZTDecayCharged->SetXTitle("p_{T decay} (GeV/c)");
outputContainer->Add(fhDeltaPhiDecayCharged) ;
outputContainer->Add(fhXEDecayCharged) ;
fhDeltaPhiUeLeftCharged = new TH2F
("hDeltaPhiUeLeftChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeLeftCharged->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeLeftCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
outputContainer->Add(fhDeltaPhiUeLeftCharged) ;
fhDeltaPhiUeRightCharged = new TH2F
("hDeltaPhiUeRightChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeRightCharged->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeRightCharged->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeRightCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
outputContainer->Add(fhDeltaPhiUeRightCharged) ;
fhDeltaPhiUeLeftUpCharged = new TH2F
("hDeltaPhiUeLeftUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left Up side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeLeftUpCharged->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeLeftUpCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
outputContainer->Add(fhDeltaPhiUeLeftUpCharged) ;
fhDeltaPhiUeRightUpCharged = new TH2F
("hDeltaPhiUeRightUpChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right Up side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeRightUpCharged->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeRightUpCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
outputContainer->Add(fhDeltaPhiUeRightUpCharged) ;
fhDeltaPhiUeLeftDownCharged = new TH2F
("hDeltaPhiUeLeftDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE left Down side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeLeftDownCharged->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeLeftDownCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
outputContainer->Add(fhDeltaPhiUeLeftDownCharged) ;
fhDeltaPhiUeRightDownCharged = new TH2F
("hDeltaPhiUeRightDownChargedPt","#phi_{trigger} - #phi_{#Ueh^{#pm}} vs p_{T Ueh^{#pm}} with UE right Down side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeRightDownCharged->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeRightDownCharged->SetXTitle("p_{T h^{#pm}} (GeV/c)");
outputContainer->Add(fhDeltaPhiUeRightDownCharged) ;
new TH2F("hXEUeChargedLeft","x_{E} with UE left side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeLeftCharged->SetYTitle("x_{E Ueh^{#pm}}");
- fhXEUeLeftCharged->SetXTitle("p_{T trigger}");
+ fhXEUeLeftCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEUeLeftCharged) ;
fhXEUeRightCharged =
new TH2F("hXEUeChargedRight","x_{E h^{#pm}} with UE right side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
- fhXEUeRightCharged->SetXTitle("p_{T trigger}");
+ fhXEUeRightCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEUeRightCharged) ;
fhXEUeLeftUpCharged =
new TH2F("hXEUeChargedLeftUp","x_{E} with UE left Up side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeLeftUpCharged->SetYTitle("x_{E Ueh^{#pm}}");
- fhXEUeLeftUpCharged->SetXTitle("p_{T trigger}");
+ fhXEUeLeftUpCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEUeLeftUpCharged) ;
fhXEUeRightUpCharged =
new TH2F("hXEUeChargedRightUp","x_{E h^{#pm}} with UE right Up side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeRightUpCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
- fhXEUeRightUpCharged->SetXTitle("p_{T trigger}");
+ fhXEUeRightUpCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEUeRightUpCharged) ;
fhXEUeLeftDownCharged =
new TH2F("hXEUeChargedLeftDown","x_{E} with UE left Down side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeLeftDownCharged->SetYTitle("x_{E Ueh^{#pm}}");
- fhXEUeLeftDownCharged->SetXTitle("p_{T trigger}");
+ fhXEUeLeftDownCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEUeLeftDownCharged) ;
fhXEUeRightDownCharged =
new TH2F("hXEUeChargedRightDown","x_{E h^{#pm}} with UE right Down side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeRightDownCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
- fhXEUeRightDownCharged->SetXTitle("p_{T trigger}");
+ fhXEUeRightDownCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEUeRightDownCharged) ;
fhPtHbpXEUeLeftCharged =
new TH2F("hHbpXEUeChargedLeft","#xi = ln(1/x_{E}) with charged UE left side of trigger",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXEUeLeftCharged->SetYTitle("ln(1/x_{E})");
- fhPtHbpXEUeLeftCharged->SetXTitle("p_{T trigger}");
+ fhPtHbpXEUeLeftCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhPtHbpXEUeLeftCharged) ;
fhPtHbpXEUeRightCharged =
new TH2F("hHbpXEUeChargedRight","#xi = ln(1/x_{E}) with charged UE right side of trigger",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXEUeRightCharged->SetYTitle("ln(1/x_{E})");
- fhPtHbpXEUeRightCharged->SetXTitle("p_{T trigger}");
+ fhPtHbpXEUeRightCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhPtHbpXEUeRightCharged) ;
fhZTUeLeftCharged =
new TH2F("hZTUeChargedLeft","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE left side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTUeLeftCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
- fhZTUeLeftCharged->SetXTitle("p_{T trigger}");
+ fhZTUeLeftCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhZTUeLeftCharged) ;
fhZTUeRightCharged =
new TH2F("hZTUeChargedRight","z_{trigger h^{#pm}} = p_{T Ueh^{#pm}} / p_{T trigger} with UE right side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTUeRightCharged->SetYTitle("z_{trigger Ueh^{#pm}}");
- fhZTUeRightCharged->SetXTitle("p_{T trigger}");
+ fhZTUeRightCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhZTUeRightCharged) ;
fhPtHbpZTUeLeftCharged =
new TH2F("hHbpZTUeChargedLeft","#xi = ln(1/z_{T}) with charged UE left side of trigger",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpZTUeLeftCharged->SetYTitle("ln(1/z_{T})");
- fhPtHbpZTUeLeftCharged->SetXTitle("p_{T trigger}");
+ fhPtHbpZTUeLeftCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhPtHbpZTUeLeftCharged) ;
fhPtHbpZTUeRightCharged =
new TH2F("hHbpZTUeChargedRight","#xi = ln(1/z_{T}) with charged UE right side of trigger",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpZTUeRightCharged->SetYTitle("ln(1/z_{T})");
- fhPtHbpZTUeRightCharged->SetXTitle("p_{T trigger}");
+ fhPtHbpZTUeRightCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhPtHbpZTUeRightCharged) ;
}
fhDeltaPhiDeltaEtaNeutral = new TH2F
("hDeltaPhiDeltaEtaNeutral","#phi_{trigger} - #phi_{h^{0}} vs #eta_{trigger} - #eta_{h^{0}}",
ndeltaphibins ,deltaphimin,deltaphimax, ndeltaetabins ,deltaetamin,deltaetamax);
- fhDeltaPhiDeltaEtaNeutral->SetXTitle("#Delta #phi");
+ fhDeltaPhiDeltaEtaNeutral->SetXTitle("#Delta #phi (rad)");
fhDeltaPhiDeltaEtaNeutral->SetYTitle("#Delta #eta");
fhPhiNeutral = new TH2F
fhDeltaPhiNeutral = new TH2F
("hDeltaPhiNeutral","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T trigger}",
nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- fhDeltaPhiNeutral->SetYTitle("#Delta #phi");
+ fhDeltaPhiNeutral->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiNeutral->SetXTitle("p_{T trigger} (GeV/c)");
fhDeltaPhiNeutralPt = new TH2F
("hDeltaPhiNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi");
+ fhDeltaPhiNeutralPt->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiNeutralPt->SetXTitle("p_{T h^{0}} (GeV/c)");
fhDeltaPhiUeNeutralPt = new TH2F
("hDeltaPhiUeNeutralPt","#phi_{trigger} - #phi_{#pi^{0}} vs p_{T #pi^{0}}}",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeNeutralPt->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeNeutralPt->SetXTitle("p_{T h^{0}} (GeV/c)");
fhDeltaEtaNeutral = new TH2F
new TH2F("hXENeutral","x_{E} for #pi^{0} associated",
nptbins,ptmin,ptmax,200,0.,2.);
fhXENeutral->SetYTitle("x_{E}");
- fhXENeutral->SetXTitle("p_{T trigger}");
+ fhXENeutral->SetXTitle("p_{T trigger} (GeV/c)");
fhXEUeNeutral =
new TH2F("hXEUeNeutral","x_{E} for #pi^{0} associated",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeNeutral->SetYTitle("x_{E}");
- fhXEUeNeutral->SetXTitle("p_{T trigger}");
+ fhXEUeNeutral->SetXTitle("p_{T trigger} (GeV/c)");
fhPtHbpXENeutral =
new TH2F("hHbpXENeutral","#xi = ln(1/x_{E})for #pi^{0} associated",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXENeutral->SetYTitle("ln(1/x_{E})");
- fhPtHbpXENeutral->SetXTitle("p_{T trigger}");
+ fhPtHbpXENeutral->SetXTitle("p_{T trigger} (GeV/c)");
fhPtHbpXEUeNeutral =
new TH2F("hHbpXEUeNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXEUeNeutral->SetYTitle("ln(1/x_{E})");
- fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger}");
+ fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger} (GeV/c)");
fhZTNeutral =
new TH2F("hZTNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger} for #pi^{0} associated",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTNeutral->SetYTitle("z_{trigger #pi^{0}}");
- fhZTNeutral->SetXTitle("p_{T trigger}");
+ fhZTNeutral->SetXTitle("p_{T trigger} (GeV/c)");
fhZTUeNeutral =
new TH2F("hZTUeNeutral","z_{trigger #pi} = p_{T #pi^{0}} / p_{T trigger} for #pi^{0} associated",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTUeNeutral->SetYTitle("z_{trigger #pi^{0}}");
- fhZTUeNeutral->SetXTitle("p_{T trigger}");
+ fhZTUeNeutral->SetXTitle("p_{T trigger} (GeV/c)");
fhPtHbpZTNeutral =
new TH2F("hHbpZTNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
new TH2F("hHbpZTUeNeutral","#xi = ln(1/x_{E}) for #pi^{0} associated",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXEUeNeutral->SetYTitle("ln(1/z_{T})");
- fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger}");
+ fhPtHbpXEUeNeutral->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhDeltaPhiDeltaEtaNeutral);
outputContainer->Add(fhPhiNeutral) ;
fhDeltaPhiDecayNeutral = new TH2F
("hDeltaPhiDecayNeutral","#phi_{Decay} - #phi_{h^{0}} vs p_{T Decay}",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiDecayNeutral->SetYTitle("#Delta #phi");
+ fhDeltaPhiDecayNeutral->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiDecayNeutral->SetXTitle("p_{T Decay} (GeV/c)");
fhXEDecayNeutral =
fhDeltaPhiUeLeftNeutral = new TH2F
("hDeltaPhiUeLeftNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs p_{T h^{0}} with neutral UE left side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeLeftNeutral->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeLeftNeutral->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeLeftNeutral->SetXTitle("p_{T h^{0}} (GeV/c)");
outputContainer->Add(fhDeltaPhiUeLeftNeutral) ;
fhDeltaPhiUeRightNeutral = new TH2F
("hDeltaPhiUeRightNeutralPt","#phi_{trigger} - #phi_{#Ueh^{0}} vs p_{T Ueh^{0}} with neutral UE right side range of trigger particles",
nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhDeltaPhiUeRightNeutral->SetYTitle("#Delta #phi");
+ fhDeltaPhiUeRightNeutral->SetYTitle("#Delta #phi (rad)");
fhDeltaPhiUeRightNeutral->SetXTitle("p_{T h^{0}} (GeV/c)");
outputContainer->Add(fhDeltaPhiUeRightNeutral) ;
new TH2F("hXEUeNeutralLeft","x_{E} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE left side of trigger",
nptbins,ptmin,ptmax,140,0.,2.);
fhXEUeLeftNeutral->SetYTitle("z_{trigger Ueh^{0}}");
- fhXEUeLeftNeutral->SetXTitle("p_{T trigger}");
+ fhXEUeLeftNeutral->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEUeLeftNeutral) ;
fhXEUeRightNeutral =
new TH2F("hXEUeNeutralRight","x_{E} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE right side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhXEUeRightNeutral->SetYTitle("z_{trigger Ueh^{0}}");
- fhXEUeRightNeutral->SetXTitle("p_{T trigger}");
+ fhXEUeRightNeutral->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhXEUeRightNeutral) ;
fhPtHbpXEUeLeftNeutral =
new TH2F("hHbpXEUeNeutralLeft","#xi = ln(1/x_{E}) with neutral UE left side of trigger",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXEUeLeftNeutral->SetYTitle("ln(1/x_{E})");
- fhPtHbpXEUeLeftNeutral->SetXTitle("p_{T trigger}");
+ fhPtHbpXEUeLeftNeutral->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhPtHbpXEUeLeftNeutral) ;
fhPtHbpXEUeRightNeutral =
new TH2F("hHbpXEUeNeutralRight","#xi = ln(1/x_{E}) with neutral UE right side of trigger",
nptbins,ptmin,ptmax,200,0.,10.);
fhPtHbpXEUeRightNeutral->SetYTitle("ln(1/x_{E})");
- fhPtHbpXEUeRightNeutral->SetXTitle("p_{T trigger}");
+ fhPtHbpXEUeRightNeutral->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhPtHbpXEUeRightNeutral) ;
fhZTUeLeftNeutral =
new TH2F("hZTUeNeutralLeft","z_{trigger h^{0}} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE left side of trigger",
nptbins,ptmin,ptmax,140,0.,2.);
fhZTUeLeftNeutral->SetYTitle("z_{trigger Ueh^{0}}");
- fhZTUeLeftNeutral->SetXTitle("p_{T trigger}");
+ fhZTUeLeftNeutral->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhZTUeLeftNeutral) ;
fhZTUeRightNeutral =
new TH2F("hZTUeNeutralRight","z_{trigger h^{0}} = p_{T Ueh^{0}} / p_{T trigger} with neutral UE right side of trigger",
nptbins,ptmin,ptmax,200,0.,2.);
fhZTUeRightNeutral->SetYTitle("z_{trigger Ueh^{0}}");
- fhZTUeRightNeutral->SetXTitle("p_{T trigger}");
+ fhZTUeRightNeutral->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhZTUeRightNeutral) ;
fhPtHbpZTUeLeftNeutral =
fhMCDeltaPhiDeltaEtaCharged = new TH2F
("hMCDeltaPhiDeltaEtaCharged","#MC phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
140,-2.,5.,200,-2,2);
- fhMCDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi");
+ fhMCDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
fhMCDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
fhMCDeltaEtaCharged = new TH2F
fhMCDeltaPhiCharged = new TH2F
("hMCDeltaPhiCharged","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
- fhMCDeltaPhiCharged->SetYTitle("#Delta #phi");
+ fhMCDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
fhMCDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhMCDeltaPhiChargedPt = new TH2F
("hMCDeltaPhiChargedPt","MC #phi_{trigger} - #phi_{#h^{#pm}} vs p_{T h^{#pm}}",
nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
- fhMCDeltaPhiChargedPt->SetYTitle("#Delta #phi");
+ fhMCDeltaPhiChargedPt->SetYTitle("#Delta #phi (rad)");
fhMCDeltaPhiChargedPt->SetXTitle("p_{T h^{#pm}} (GeV/c)");
fhMCPtXECharged =
new TH2F("hMCPtXECharged","x_{E}",
nptbins,ptmin,ptmax,200,0.,2.);
fhMCPtXECharged->SetYTitle("x_{E}");
- fhMCPtXECharged->SetXTitle("p_{T trigger}");
+ fhMCPtXECharged->SetXTitle("p_{T trigger} (GeV/c)");
fhMCPtXEUeCharged =
new TH2F("hMCPtXEUeCharged","x_{E}",
nptbins,ptmin,ptmax,200,0.,2.);
fhMCPtXEUeCharged->SetYTitle("x_{E}");
- fhMCPtXEUeCharged->SetXTitle("p_{T trigger}");
+ fhMCPtXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhMCPtHbpXECharged =
new TH2F("hMCHbpXECharged","MC #xi = ln(1/x_{E}) with charged hadrons",
new TH2F("hMCPtHbpXEUeCharged","#xi = ln(1/x_{E}) with charged hadrons,Underlying Event",
nptbins,ptmin,ptmax,200,0.,10.);
fhMCPtHbpXEUeCharged->SetYTitle("ln(1/x_{E})");
- fhMCPtHbpXEUeCharged->SetXTitle("p_{T trigger}");
+ fhMCPtHbpXEUeCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhMCUePart =
new TH1F("hMCUePart","MC UE particles distribution vs pt trig",
nptbins,ptmin,ptmax);
fhMCUePart->SetYTitle("dNch");
- fhMCUePart->SetXTitle("p_{T trigger}");
+ fhMCUePart->SetXTitle("p_{T trigger} (GeV/c)");
fhMCPtZTCharged =
new TH2F("hMCPtZTCharged","z_{T}",
nptbins,ptmin,ptmax,200,0.,2.);
fhMCPtZTCharged->SetYTitle("z_{T}");
- fhMCPtZTCharged->SetXTitle("p_{T trigger}");
+ fhMCPtZTCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhMCPtHbpZTCharged =
new TH2F("hMCHbpZTCharged","MC #xi = ln(1/z_{T}) with charged hadrons",
nptbins,ptmin,ptmax,200,0.,10.);
fhMCPtHbpZTCharged->SetYTitle("ln(1/z_{T})");
- fhMCPtHbpZTCharged->SetXTitle("p_{T trigger}");
+ fhMCPtHbpZTCharged->SetXTitle("p_{T trigger} (GeV/c)");
fhMCPtTrigPout =
new TH2F("hMCPtTrigPout","AOD MC Pout with triggers",
fhMCPtAssocDeltaPhi =
new TH2F("hMCPtAssocDeltaPhi","AOD MC delta phi with associated charged hadrons",
nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
- fhMCPtAssocDeltaPhi->SetYTitle("#Delta #phi");
+ fhMCPtAssocDeltaPhi->SetYTitle("#Delta #phi (rad)");
fhMCPtAssocDeltaPhi->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fh2phiLeadingParticle);
outputContainer->Add(fhPhiLeadingMixed);
outputContainer->Add(fhEtaLeadingMixed);
- // Fill the cluster pool only in isolation analysis
- if( OnlyIsolated() && (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists())))
+ // Fill the cluster pool only in isolation analysis or if requested
+ if( ( OnlyIsolated() || fFillNeutralEventMixPool) &&
+ (!fUseMixStoredInReader || (fUseMixStoredInReader && !GetReader()->ListWithMixedEventsForCaloExists())))
{
Int_t nvz = GetNZvertBin();
Int_t nrp = GetNRPBin();
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())
+ {
+ fhNclustersMB=new TH1F("hNclustersMBEvent","Number of clusters w/ event trigger kMB",2000,0,2000);
+ outputContainer->Add(fhNclustersMB);
+ }
+
fhMixDeltaPhiCharged = new TH2F
("hMixDeltaPhiCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}",
nptbins,ptmin,ptmax,ndeltaphibins ,deltaphimin,deltaphimax);
- fhMixDeltaPhiCharged->SetYTitle("#Delta #phi");
+ fhMixDeltaPhiCharged->SetYTitle("#Delta #phi (rad)");
fhMixDeltaPhiCharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhMixDeltaPhiCharged);
fhMixDeltaPhiDeltaEtaCharged = new TH2F
("hMixDeltaPhiDeltaEtaCharged","Mixed event : #phi_{trigger} - #phi_{h^{#pm}} vs #eta_{trigger} - #eta_{h^{#pm}}",
ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
- fhMixDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi");
+ fhMixDeltaPhiDeltaEtaCharged->SetXTitle("#Delta #phi (rad)");
fhMixDeltaPhiDeltaEtaCharged->SetYTitle("#Delta #eta");
outputContainer->Add(fhMixDeltaPhiDeltaEtaCharged);
new TH2F("hMixXECharged","Mixed event : x_{E} for charged tracks",
nptbins,ptmin,ptmax,200,0.,2.);
fhMixXECharged->SetYTitle("x_{E}");
- fhMixXECharged->SetXTitle("p_{T trigger}");
+ fhMixXECharged->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})");
- fhMixHbpXECharged->SetXTitle("p_{T trigger}");
+ fhMixHbpXECharged->SetXTitle("p_{T trigger} (GeV/c)");
outputContainer->Add(fhMixHbpXECharged);
fhMixDeltaPhiChargedAssocPtBin = new TH2F*[fNAssocPtBins*nz];
fhMixDeltaPhiChargedAssocPtBin[bin] = new TH2F(Form("hMixDeltaPhiChargedAssocPtBin%2.1f_%2.1f%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],sz.Data()),
Form("Mixed event #Delta #phi vs p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("p_{T trigger}");
- fhMixDeltaPhiChargedAssocPtBin[bin]->SetYTitle("#Delta #phi");
+ fhMixDeltaPhiChargedAssocPtBin[bin]->SetXTitle("p_{T trigger} (GeV/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 p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta > 0.8", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("p_{T trigger}");
- fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetYTitle("#Delta #phi");
+ fhMixDeltaPhiChargedAssocPtBinDEta08[bin]->SetXTitle("p_{T trigger} (GeV/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 p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s, for #Delta #eta = 0", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
nptbins, ptmin, ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
- fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("p_{T trigger}");
- fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetYTitle("#Delta #phi");
+ fhMixDeltaPhiChargedAssocPtBinDEta0[bin]->SetXTitle("p_{T trigger} (GeV/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 p_{T trigger} for associated p_{T} bin [%2.1f,%2.1f]%s", fAssocPtBinLimit[i], fAssocPtBinLimit[i+1],tz.Data()),
ndeltaphibins ,deltaphimin,deltaphimax,ndeltaetabins ,deltaetamin,deltaetamax);
- fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetXTitle("#Delta #phi");
+ fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetXTitle("#Delta #phi (rad)");
fhMixDeltaPhiDeltaEtaChargedAssocPtBin[bin]->SetYTitle("#Delta #eta");
outputContainer->Add(fhMixDeltaPhiChargedAssocPtBin[bin]);
}
//_____________________________________________________________
-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())
- 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)
fhPtLeading->Fill(pt);
fhPtLeadingBin->Fill(pt,GetEventMixBin());
if(fCorrelVzBin) fhPtLeadingVzBin->Fill(pt,GetEventVzBin());
- if(fFillPileUpHistograms && GetReader()->IsPileUpFromSPD())
- fhPtLeadingPileUp->Fill(pt);
-
+
+ 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);
+ if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtLeadingPileUp[3]->Fill(pt);
+ if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtLeadingPileUp[4]->Fill(pt);
+ if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtLeadingPileUp[5]->Fill(pt);
+ if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtLeadingPileUp[6]->Fill(pt);
+ }
+
Float_t phi = particle->Phi();
if(phi<0)phi+=TMath::TwoPi();
fhPhiLeading->Fill(pt, phi);
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(fUseMixStoredInReader)
{
pool = GetReader()->GetListWithMixedEventsForTracks(eventBin);
- if(OnlyIsolated()) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin);
+ if(OnlyIsolated() || fFillNeutralEventMixPool) poolCalo = GetReader()->GetListWithMixedEventsForCalo (eventBin);
}
else
{
pool = fListMixTrackEvents[eventBin];
- if(OnlyIsolated()) poolCalo = fListMixCaloEvents [eventBin];
+ if(OnlyIsolated() || fFillNeutralEventMixPool) poolCalo = fListMixCaloEvents [eventBin];
}
if(!pool) return ;
- if(OnlyIsolated() && !poolCalo &&
+ if((OnlyIsolated() || fFillNeutralEventMixPool ) && !poolCalo &&
(GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::AliIsolationCut::kOnlyCharged))
printf("AliAnaParticleHadronCorrelation::MakeChargedMixCorrelation() - Careful, cluster pool not available\n");
for(Int_t ev=ev0; ev < pool->GetSize(); ev++)
{
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())
+ if(OnlyIsolated() || fFillNeutralEventMixPool)
{
if(pool->GetSize()!=poolCalo->GetSize())
printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Different size of calo and track pools\n");
- TObjArray* bgCalo = static_cast<TObjArray*>(poolCalo->At(ev));
+ bgCalo = static_cast<TObjArray*>(poolCalo->At(ev));
if(!bgCalo)
printf("AliAnaParticleHadronCorrelationNew::MakeChargedMixCorrelation() - Event %d in calo pool not available?\n",ev);
- 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 ;
+ if(OnlyIsolated() && bgCalo)
+ {
+ 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);
}
}
}
+
+ if(fFillNeutralEventMixPool && bgCalo)
+ {
+ Int_t nClusters=bgCalo->GetEntriesFast();
+ TLorentzVector mom ;
+ for(Int_t jlead = 0;jlead <nClusters; jlead++ )
+ {
+ AliVCluster *cluster = (AliVCluster*) bgCalo->At(jlead) ;
+
+ Double_t vertex[]={0,0,0}; // assume 0 vertex
+ cluster->GetMomentum(mom,vertex) ;
+
+ ptAssoc = mom.Pt();
+ phiAssoc = mom.Phi() ;
+
+ if(phiAssoc < 0) phiAssoc+=TMath::TwoPi();
+ if (fMakeNearSideLeading)
+ {
+ if(ptAssoc > ptTrig && TMath::Abs(phiAssoc-phiTrig) < TMath::PiOver2())
+ {
+ leading = kFALSE;
+ break;
+ }
+ }
+ //jump out this event if there is any other particle with pt larger than trigger
+ else if(fMakeAbsoluteLeading)
+ {
+ if(ptAssoc > ptTrig)
+ {
+ leading = kFALSE;
+ break;
+ }
+ }
+ }
+ }
+
if(!leading) continue; // not leading, check the next event in pool
+
}
fhPtLeadingMixed ->Fill(ptTrig);
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