// Class for analysis of particle isolation
// Input is selected particles put in AOD branch (AliAODPWG4ParticleCorrelation)
//
-// Class created from old AliPHOSGammaJet
+// Class created from old AliPHOSGammaJet
// (see AliRoot versions previous Release 4-09)
//
-// -- Author: Gustavo Conesa (LNF-INFN)
+// -- Author: Gustavo Conesa (LNF-INFN)
//-Yaxian Mao (add the possibility for different IC method with different pt range, 01/10/2010)
//////////////////////////////////////////////////////////////////////////////
-
-// --- ROOT system ---
+// --- ROOT system ---
#include <TClonesArray.h>
#include <TList.h>
#include <TObjString.h>
#include <TH2F.h>
#include <TClass.h>
+#include <TH2F.h>
+#include "TParticle.h"
+#include "TDatabasePDG.h"
-// --- Analysis system ---
-#include "AliAnaParticleIsolation.h"
+// --- Analysis system ---
+#include "AliAnaParticleIsolation.h"
#include "AliCaloTrackReader.h"
+#include "AliStack.h"
#include "AliIsolationCut.h"
+#include "AliFiducialCut.h"
+#include "AliMCAnalysisUtils.h"
#include "AliNeutralMesonSelection.h"
+#include "AliAODMCParticle.h"
#include "AliAODPWG4ParticleCorrelation.h"
#include "AliMCAnalysisUtils.h"
#include "AliVTrack.h"
#include "AliVCluster.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
-#include "AliEMCALGeometry.h"
+// --- Detectors ---
+#include "AliEMCALGeometry.h"
+#include "AliPHOSGeoUtils.h"
ClassImp(AliAnaParticleIsolation)
//______________________________________________________________________________
-AliAnaParticleIsolation::AliAnaParticleIsolation() :
-AliAnaCaloTrackCorrBaseClass(), fCalorimeter(""),
-fReMakeIC(0), fMakeSeveralIC(0),
+AliAnaParticleIsolation::AliAnaParticleIsolation() :
+AliAnaCaloTrackCorrBaseClass(),
+fCalorimeter(""), fIsoDetector(""),
+fReMakeIC(0), fMakeSeveralIC(0),
fFillPileUpHistograms(0),
-fFillTMHisto(0), fFillSSHisto(0),
+fFillTMHisto(0), fFillSSHisto(1),
+fFillUEBandSubtractHistograms(1), fFillCellHistograms(0),
+fFillHighMultHistograms(0), fFillTaggedDecayHistograms(0),
+fNDecayBits(0), fDecayBits(),
+fFillNLMHistograms(0),
+fLeadingOnly(0), fCheckLeadingWithNeutralClusters(0),
+fFillBackgroundBinHistograms(0), fNBkgBin(0),
// Several IC
-fNCones(0), fNPtThresFrac(0),
-fConeSizes(), fPtThresholds(),
+fNCones(0), fNPtThresFrac(0),
+fConeSizes(), fPtThresholds(),
fPtFractions(), fSumPtThresholds(),
// Histograms
fhEIso(0), fhPtIso(0),
fhPtCentralityIso(0), fhPtEventPlaneIso(0),
fhPtNLocMaxIso(0),
-fhPhiIso(0), fhEtaIso(0), fhEtaPhiIso(0),
-fhEtaPhiNoIso(0),
+fhPhiIso(0), fhEtaIso(0), fhEtaPhiIso(0),
+fhEtaPhiNoIso(0),
fhENoIso(0), fhPtNoIso(0), fhPtNLocMaxNoIso(0),
-fhPtDecayIso(0), fhPtDecayNoIso(0),
-fhEtaPhiDecayIso(0), fhEtaPhiDecayNoIso(0),
fhPtInCone(0),
fhPtClusterInCone(0), fhPtCellInCone(0), fhPtTrackInCone(0),
fhPtTrackInConeOtherBC(0), fhPtTrackInConeOtherBCPileUpSPD(0),
fhPtTrackInConeBC0PileUpSPD(0),
fhPtInConePileUp(), fhPtInConeCent(0),
fhPerpConeSumPt(0), fhPtInPerpCone(0),
-fhEtaPhiInConeCluster(0),fhEtaPhiCluster(0),fhEtaPhiInConeTrack(0),fhEtaPhiTrack(0),
+fhEtaPhiInConeCluster(0), fhEtaPhiCluster(0),
+fhEtaPhiInConeTrack(0), fhEtaPhiTrack(0),
fhEtaBandCluster(0), fhPhiBandCluster(0),
fhEtaBandTrack(0), fhPhiBandTrack(0),
fhEtaBandCell(0), fhPhiBandCell(0),
+fhConePtLead(0), fhConePtLeadCluster(0), fhConePtLeadTrack(0),
+fhConePtLeadClustervsTrack(0), fhConePtLeadClusterTrackFrac(0),
fhConeSumPt(0), fhConeSumPtCellTrack(0),
fhConeSumPtCell(0), fhConeSumPtCluster(0), fhConeSumPtTrack(0),
fhConeSumPtEtaBandUECluster(0), fhConeSumPtPhiBandUECluster(0),
fhFractionClusterOutConePhi(0), fhFractionClusterOutConePhiTrigEtaPhi(0),
fhFractionCellOutConeEta(0), fhFractionCellOutConeEtaTrigEtaPhi(0),
fhFractionCellOutConePhi(0), fhFractionCellOutConePhiTrigEtaPhi(0),
-fhConeSumPtClustervsTrack(0),
+fhConeSumPtClustervsTrack(0), fhConeSumPtClusterTrackFrac(0),
fhConeSumPtEtaUESubClustervsTrack(0), fhConeSumPtPhiUESubClustervsTrack(0),
fhConeSumPtCellvsTrack(0),
fhConeSumPtEtaUESubCellvsTrack(0), fhConeSumPtPhiUESubCellvsTrack(0),
fhConeSumPtSubvsConeSumPtTotEtaCluster(0), fhConeSumPtSubNormvsConeSumPtTotEtaCluster(0),
fhConeSumPtSubvsConeSumPtTotPhiCell(0), fhConeSumPtSubNormvsConeSumPtTotPhiCell(0),
fhConeSumPtSubvsConeSumPtTotEtaCell(0), fhConeSumPtSubNormvsConeSumPtTotEtaCell(0),
-// MC histograms
-fhPtIsoPrompt(0), fhPhiIsoPrompt(0), fhEtaIsoPrompt(0),
-fhPtThresIsolatedPrompt(), fhPtFracIsolatedPrompt(), fhPtSumIsolatedPrompt(),
-fhPtIsoFragmentation(0), fhPhiIsoFragmentation(0), fhEtaIsoFragmentation(0),
-fhPtThresIsolatedFragmentation(), fhPtFracIsolatedFragmentation(), fhPtSumIsolatedFragmentation(),
-fhPtIsoPi0(0), fhPhiIsoPi0(0), fhEtaIsoPi0(0),
-fhPtThresIsolatedPi0(), fhPtFracIsolatedPi0(), fhPtSumIsolatedPi0(),
-fhPtIsoPi0Decay(0), fhPhiIsoPi0Decay(0), fhEtaIsoPi0Decay(0),
-fhPtThresIsolatedPi0Decay(), fhPtFracIsolatedPi0Decay(), fhPtSumIsolatedPi0Decay(),
-fhPtIsoEtaDecay(0), fhPhiIsoEtaDecay(0), fhEtaIsoEtaDecay(0),
-fhPtThresIsolatedEtaDecay(), fhPtFracIsolatedEtaDecay(), fhPtSumIsolatedEtaDecay(),
-fhPtIsoOtherDecay(0), fhPhiIsoOtherDecay(0), fhEtaIsoOtherDecay(0),
-fhPtThresIsolatedOtherDecay(), fhPtFracIsolatedOtherDecay(), fhPtSumIsolatedOtherDecay(),
-//fhPtIsoConversion(0), fhPhiIsoConversion(0), fhEtaIsoConversion(0),
-//fhPtThresIsolatedConversion(), fhPtFracIsolatedConversion(), fhPtSumIsolatedConversion(),
-fhPtIsoHadron(0), fhPhiIsoHadron(0), fhEtaIsoHadron(0),
-fhPtThresIsolatedHadron(), fhPtFracIsolatedHadron(), fhPtSumIsolatedHadron(),
-fhPtNoIsoPi0(0), fhPtNoIsoPi0Decay(0),
-fhPtNoIsoEtaDecay(0), fhPtNoIsoOtherDecay(0),
-fhPtNoIsoPrompt(0), fhPtIsoMCPhoton(0), fhPtNoIsoMCPhoton(0),
-//fhPtNoIsoConversion(0),
-fhPtNoIsoFragmentation(0), fhPtNoIsoHadron(0),
-// Hist several IC
-fhSumPtLeadingPt(), fhPtLeadingPt(),
-fhPerpSumPtLeadingPt(), fhPerpPtLeadingPt(),
-fhPtThresIsolated(), fhPtFracIsolated(), fhPtSumIsolated(),
-fhEtaPhiPtThresIso(), fhEtaPhiPtThresDecayIso(), fhPtPtThresDecayIso(),
-fhEtaPhiPtFracIso(), fhEtaPhiPtFracDecayIso(), fhPtPtFracDecayIso(),
-fhPtPtSumDecayIso(), fhEtaPhiSumDensityIso(), fhEtaPhiSumDensityDecayIso(),
-fhPtSumDensityIso(), fhPtSumDensityDecayIso(),
-fhPtFracPtSumIso(), fhPtFracPtSumDecayIso(),
-fhEtaPhiFracPtSumIso(), fhEtaPhiFracPtSumDecayIso(),
-// Cluster control histograms
-fhTrackMatchedDEta(), fhTrackMatchedDPhi(), fhTrackMatchedDEtaDPhi(),
-fhdEdx(), fhEOverP(), fhTrackMatchedMCParticle(),
-fhELambda0() , fhELambda1(), fhELambda0SSBkg(),
-fhELambda0TRD(), fhELambda1TRD(),
-fhELambda0MCPhoton(), fhELambda0MCPi0(), fhELambda0MCPi0Decay(),
-fhELambda0MCEtaDecay(), fhELambda0MCOtherDecay(), fhELambda0MCHadron(),
+fhConeSumPtVSUETracksEtaBand(0), fhConeSumPtVSUETracksPhiBand(0),
+fhConeSumPtVSUEClusterEtaBand(0), fhConeSumPtVSUEClusterPhiBand(0),
+fhPtLeadConeBinLambda0(0), fhSumPtConeBinLambda0(0),
+fhPtLeadConeBinLambda0MC(0), fhSumPtConeBinLambda0MC(0),
// Number of local maxima in cluster
fhNLocMax(),
fhELambda0LocMax1(), fhELambda1LocMax1(),
fhTimeENoCut(0), fhTimeESPD(0), fhTimeESPDMulti(0),
fhTimeNPileUpVertSPD(0), fhTimeNPileUpVertTrack(0),
fhTimeNPileUpVertContributors(0),
-fhTimePileUpMainVertexZDistance(0), fhTimePileUpMainVertexZDiamond(0),
-// Histograms settings
-fHistoNPtSumBins(0), fHistoPtSumMax(0.), fHistoPtSumMin(0.),
-fHistoNPtInConeBins(0), fHistoPtInConeMax(0.), fHistoPtInConeMin(0.)
+fhTimePileUpMainVertexZDistance(0), fhTimePileUpMainVertexZDiamond(0)
{
//default ctor
InitParameters();
for(Int_t i = 0; i < 5 ; i++)
- {
- fConeSizes[i] = 0 ;
-
- fhPtSumIsolatedPrompt [i] = 0 ;
- fhPtSumIsolatedFragmentation[i] = 0 ;
- fhPtSumIsolatedPi0Decay [i] = 0 ;
- fhPtSumIsolatedPi0 [i] = 0 ;
- fhPtSumIsolatedEtaDecay [i] = 0 ;
- fhPtSumIsolatedOtherDecay [i] = 0 ;
-// fhPtSumIsolatedConversion [i] = 0 ;
- fhPtSumIsolatedHadron [i] = 0 ;
+ {
+ fConeSizes[i] = 0 ;
+
+ for(Int_t imc = 0; imc < 9; imc++)
+ fhSumPtLeadingPtMC[imc][i] = 0 ;
for(Int_t j = 0; j < 5 ; j++)
- {
+ {
fhPtThresIsolated [i][j] = 0 ;
fhPtFracIsolated [i][j] = 0 ;
- fhPtSumIsolated [i][j] = 0 ;
+ fhSumPtIsolated [i][j] = 0 ;
fhEtaPhiPtThresIso [i][j] = 0 ;
fhEtaPhiPtThresDecayIso [i][j] = 0 ;
fhEtaPhiFracPtSumIso [i][j] = 0 ;
fhEtaPhiFracPtSumDecayIso [i][j] = 0 ;
- fhPtThresIsolatedPrompt [i][j] = 0 ;
- fhPtThresIsolatedFragmentation[i][j] = 0 ;
- fhPtThresIsolatedPi0Decay [i][j] = 0 ;
- fhPtThresIsolatedPi0 [i][j] = 0 ;
- fhPtThresIsolatedEtaDecay [i][j] = 0 ;
- fhPtThresIsolatedOtherDecay [i][j] = 0 ;
-// fhPtThresIsolatedConversion [i][j] = 0 ;
- fhPtThresIsolatedHadron [ i][j] = 0 ;
-
- fhPtFracIsolatedPrompt [i][j] = 0 ;
- fhPtFracIsolatedFragmentation [i][j] = 0 ;
- fhPtFracIsolatedPi0 [i][j] = 0 ;
- fhPtFracIsolatedPi0Decay [i][j] = 0 ;
- fhPtFracIsolatedEtaDecay [i][j] = 0 ;
- fhPtFracIsolatedOtherDecay [i][j] = 0 ;
-// fhPtFracIsolatedConversion [i][j] = 0 ;
- fhPtFracIsolatedHadron [i][j] = 0 ;
-
- }
- }
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+ fhPtThresIsolatedMC[imc][i][j] = 0 ;
+ fhPtFracIsolatedMC [imc][i][j] = 0 ;
+ fhSumPtIsolatedMC [imc][i][j] = 0 ;
+
+ }
+ }
+ }
+
+ for(Int_t ibit =0; ibit< 4; ibit++)
+ {
+ fhPtDecayIso [ibit] = 0;
+ fhPtLambda0Decay[0][ibit] = 0;
+ fhPtLambda0Decay[1][ibit] = 0;
+ fhPtDecayNoIso [ibit] = 0;
+ fhEtaPhiDecayIso [ibit] = 0;
+ fhEtaPhiDecayNoIso [ibit] = 0;
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+ fhPtDecayIsoMC [ibit][imc] = 0;
+ fhPtDecayNoIsoMC[ibit][imc] = 0;
+ }
+ }
for(Int_t i = 0; i < 5 ; i++)
- {
- fPtFractions [i] = 0 ;
+ {
+ fPtFractions [i] = 0 ;
fPtThresholds [i] = 0 ;
fSumPtThresholds[i] = 0 ;
- }
-
+
+ fhSumPtLeadingPt [i] = 0 ;
+ fhPtLeadingPt [i] = 0 ;
+ fhPerpSumPtLeadingPt[i] = 0 ;
+ fhPerpPtLeadingPt [i] = 0 ;
+ }
+
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+ fhPtNoIsoMC [imc] = 0;
+ fhPtIsoMC [imc] = 0;
+ fhPhiIsoMC [imc] = 0;
+ fhEtaIsoMC [imc] = 0;
+ fhPtLambda0MC[imc][0] = 0;
+ fhPtLambda0MC[imc][1] = 0;
+ }
for(Int_t i = 0; i < 2 ; i++)
- {
- fhTrackMatchedDEta[i] = 0 ; fhTrackMatchedDPhi[i] = 0 ; fhTrackMatchedDEtaDPhi [i] = 0 ;
- fhdEdx [i] = 0 ; fhEOverP [i] = 0 ; fhTrackMatchedMCParticle[i] = 0 ;
- fhELambda0 [i] = 0 ; fhELambda1 [i] = 0 ;
- fhELambda0TRD [i] = 0 ; fhELambda1TRD [i] = 0 ;
-
- fhELambda0MCPhoton [i] = 0 ; fhELambda0MCPi0 [i] = 0 ; fhELambda0MCPi0Decay[i] = 0 ;
- fhELambda0MCEtaDecay[i] = 0 ; fhELambda0MCOtherDecay[i] = 0 ; fhELambda0MCHadron [i] = 0 ;
-
+ {
+ fhTrackMatchedDEta[i] = 0 ; fhTrackMatchedDPhi[i] = 0 ; fhTrackMatchedDEtaDPhi [i] = 0 ;
+ fhdEdx [i] = 0 ; fhEOverP [i] = 0 ; fhTrackMatchedMCParticle[i] = 0 ;
+ fhELambda0 [i] = 0 ; fhELambda1 [i] = 0 ; fhPtLambda0 [i] = 0 ;
+ fhELambda0TRD [i] = 0 ; fhELambda1TRD [i] = 0 ; fhPtLambda0TRD [i] = 0 ;
// Number of local maxima in cluster
fhNLocMax [i] = 0 ;
fhELambda0LocMax1[i] = 0 ; fhELambda1LocMax1[i] = 0 ;
fhELambda0LocMax2[i] = 0 ; fhELambda1LocMax2[i] = 0 ;
fhELambda0LocMaxN[i] = 0 ; fhELambda1LocMaxN[i] = 0 ;
-
- }
+ }
+
+ // Acceptance
+ for(Int_t i = 0; i < 6; i++)
+ {
+ fhPtPrimMCiso[i] = 0;
+ fhEPrimMC [i] = 0;
+ fhEtaPrimMC [i] = 0;
+ fhPhiPrimMC [i] = 0;
+ }
// Pile-Up
fhENoIsoPileUp [i] = 0 ;
fhPtNoIsoPileUp [i] = 0 ;
}
-
}
//_______________________________________________________________________________________________
Float_t conesize = GetIsolationCut()->GetConeSize();
TLorentzVector mom ;
- //Select the Calorimeter
+ //Select the Calorimeter
TObjArray * pl = 0x0;
if (fCalorimeter == "PHOS" )
pl = GetPHOSClusters();
printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Cluster not available?");
continue;
}
-
+
//Do not count the candidate (photon or pi0) or the daughters of the candidate
if(cluster->GetID() == pCandidate->GetCaloLabel(0) ||
cluster->GetID() == pCandidate->GetCaloLabel(1) ) continue ;
//Remove matched clusters to tracks if Neutral and Track info is used
if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged &&
- IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ;
+ IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ;
cluster->GetMomentum(mom,vertex) ;//Assume that come from vertex in straight line
fhEtaPhiCluster->Fill(mom.Eta(), mom.Phi());
if(rad < conesize) {
// histos for all clusters in cone
- fhEtaPhiInConeCluster->Fill(mom.Eta(), mom.Phi());
- continue ;
+ fhEtaPhiInConeCluster->Fill(mom.Eta(), mom.Phi());
+ continue ;
}
//fill histogram for UE in phi band in EMCal acceptance
if(mom.Eta() > (etaTrig-conesize) && mom.Eta() < (etaTrig+conesize))
phiBandPtSum+=mom.Pt();
fhPhiBandCluster->Fill(mom.Eta(),mom.Phi());
-}
+ }
//fill histogram for UE in eta band in EMCal acceptance
if(mom.Phi() > (phiTrig-conesize) && mom.Phi() < (phiTrig+conesize))
fhConeSumPtPhiBandUECluster ->Fill(ptTrig , phiBandPtSum);
fhConeSumPtEtaBandUEClusterTrigEtaPhi->Fill(etaTrig,phiTrig,etaBandPtSum);
fhConeSumPtPhiBandUEClusterTrigEtaPhi->Fill(etaTrig,phiTrig,phiBandPtSum);
-
+
}
//________________________________________________________________________________________________
Int_t nModule = -1;
Int_t imEta=-1, imPhi=-1;
Int_t ieta =-1, iphi =-1;
-
+
if (eGeom->GetCellIndex(absId,nSupMod,nModule,imPhi,imEta))
{
eGeom->GetCellPhiEtaIndexInSModule(nSupMod,nModule,imPhi,imEta,iphi,ieta);
Int_t nTotalRows = AliEMCALGeoParams::fgkEMCALRows*16/3 ; // 24*(16/3) 5 full-size Sectors (2 SM) + 1 one-third Sector (2 SM)
Int_t nTotalCols = 2*AliEMCALGeoParams::fgkEMCALCols;
- // printf("nTotalRows %i, nTotalCols %i\n",nTotalRows,nTotalCols);
+ // printf("nTotalRows %i, nTotalCols %i\n",nTotalRows,nTotalCols);
// Loop on cells in eta band
-
+
Int_t irowmin = rowTrig-sqrSize;
- if(irowmin<0) irowmin=0;
- Int_t irowmax = rowTrig+sqrSize;
- if(irowmax>AliEMCALGeoParams::fgkEMCALRows) irowmax=AliEMCALGeoParams::fgkEMCALRows;
-
-
+ if(irowmin<0) irowmin=0;
+ Int_t irowmax = rowTrig+sqrSize;
+ if(irowmax>AliEMCALGeoParams::fgkEMCALRows) irowmax=AliEMCALGeoParams::fgkEMCALRows;
+
+
for(Int_t irow = irowmin; irow <irowmax; irow++)
{
for(Int_t icol = 0; icol < nTotalCols; icol++)
{
Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
- if(inSector==5) continue;
- Int_t inSupMod = -1;
+ if(inSector==5) continue;
+ Int_t inSupMod = -1;
Int_t icolLoc = -1;
if(icol < AliEMCALGeoParams::fgkEMCALCols)
{
}
Int_t irowLoc = irow - AliEMCALGeoParams::fgkEMCALRows*inSector ;
-
+
// Exclude cells in cone
if(TMath::Abs(icol-colTrig) < sqrSize || TMath::Abs(irow-rowTrig) < sqrSize){
- continue ;
+ continue ;
}
Int_t iabsId = eGeom->GetAbsCellIdFromCellIndexes(inSupMod,irowLoc,icolLoc);
if(!eGeom->CheckAbsCellId(iabsId)) continue;
etaBandPtSumCells += cells->GetCellAmplitude(iabsId);
- fhEtaBandCell->Fill(colTrig,rowTrig);
-
- // printf("ETA inSupMod %i,irowLoc %i,icolLoc %i, iabsId %i, etaBandPtSumCells %f\n",nSupMod,irowLoc,icolLoc,iabsId,etaBandPtSumCells);
- }
+ fhEtaBandCell->Fill(colTrig,rowTrig);
+
+ // printf("ETA inSupMod %i,irowLoc %i,icolLoc %i, iabsId %i, etaBandPtSumCells %f\n",nSupMod,irowLoc,icolLoc,iabsId,etaBandPtSumCells);
+ }
}
- Int_t icolmin = colTrig-sqrSize;
- if(icolmin<0) icolmin=0;
- Int_t icolmax = colTrig+sqrSize;
- if(icolmax>AliEMCALGeoParams::fgkEMCALCols) icolmax=AliEMCALGeoParams::fgkEMCALCols;
+ Int_t icolmin = colTrig-sqrSize;
+ if(icolmin<0) icolmin=0;
+ Int_t icolmax = colTrig+sqrSize;
+ if(icolmax>AliEMCALGeoParams::fgkEMCALCols) icolmax=AliEMCALGeoParams::fgkEMCALCols;
// Loop on cells in phi band
for(Int_t icol = icolmin; icol < icolmax; icol++)
{
for(Int_t irow = 0; irow < nTotalRows; irow++)
- {
+ {
Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
- if(inSector==5) continue;
+ if(inSector==5) continue;
Int_t inSupMod = -1;
Int_t icolLoc = -1;
- // printf("icol %i, irow %i, inSector %i\n",icol,irow ,inSector);
+ // printf("icol %i, irow %i, inSector %i\n",icol,irow ,inSector);
if(icol < AliEMCALGeoParams::fgkEMCALCols)
{
- // printf("icol < AliEMCALGeoParams::fgkEMCALCols %i\n",AliEMCALGeoParams::fgkEMCALCols );
+ // printf("icol < AliEMCALGeoParams::fgkEMCALCols %i\n",AliEMCALGeoParams::fgkEMCALCols );
inSupMod = 2*inSector + 1;
icolLoc = icol;
}
else if(icol > AliEMCALGeoParams::fgkEMCALCols - 1)
{
- // printf("icol > AliEMCALGeoParams::fgkEMCALCols -1 %i\n",AliEMCALGeoParams::fgkEMCALCols -1 );
- inSupMod = 2*inSector;
+ // printf("icol > AliEMCALGeoParams::fgkEMCALCols -1 %i\n",AliEMCALGeoParams::fgkEMCALCols -1 );
+ inSupMod = 2*inSector;
icolLoc = icol-AliEMCALGeoParams::fgkEMCALCols;
}
Int_t irowLoc = irow - AliEMCALGeoParams::fgkEMCALRows*inSector ; // Stesso problema di sopra //
-
+
// Exclude cells in cone
if(TMath::Abs(icol-colTrig) < sqrSize) {
- //printf("TMath::Abs(icol-colTrig) %i < sqrSize %i\n",TMath::Abs(icol-colTrig) ,sqrSize);continue ;
- }
+ //printf("TMath::Abs(icol-colTrig) %i < sqrSize %i\n",TMath::Abs(icol-colTrig) ,sqrSize);continue ;
+ }
if(TMath::Abs(irow-rowTrig) < sqrSize) {
- //printf("TMath::Abs(irow-rowTrig) %i < sqrSize %i\n",TMath::Abs(irow-rowTrig) ,sqrSize);continue ;
- }
+ //printf("TMath::Abs(irow-rowTrig) %i < sqrSize %i\n",TMath::Abs(irow-rowTrig) ,sqrSize);continue ;
+ }
Int_t iabsId = eGeom->GetAbsCellIdFromCellIndexes(inSupMod,irowLoc,icolLoc);
if(!eGeom->CheckAbsCellId(iabsId)) {printf("!eGeom->CheckAbsCellId(iabsId=%i) inSupMod %i irowLoc %i icolLoc %i \n",iabsId,inSupMod, irowLoc, icolLoc);continue;}
phiBandPtSumCells += cells->GetCellAmplitude(iabsId);
- fhPhiBandCell->Fill(colTrig,rowTrig);
- //printf("inSupMod %i,irowLoc %i,icolLoc %i, iabsId %i, phiBandPtSumCells %f\n",nSupMod,irowLoc,icolLoc,iabsId,phiBandPtSumCells);
- }
+ fhPhiBandCell->Fill(colTrig,rowTrig);
+ //printf("inSupMod %i,irowLoc %i,icolLoc %i, iabsId %i, phiBandPtSumCells %f\n",nSupMod,irowLoc,icolLoc,iabsId,phiBandPtSumCells);
+ }
}
}
}
if(!track)
{
- printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Track not available?");
+ printf("AliAnaParticleIsolation::CalculateTrackUEBand() - Track not available?");
continue;
}
//Do not count the candidate (pion, conversion photon) or the daughters of the candidate
if(track->GetID() == pCandidate->GetTrackLabel(0) || track->GetID() == pCandidate->GetTrackLabel(1) ||
track->GetID() == pCandidate->GetTrackLabel(2) || track->GetID() == pCandidate->GetTrackLabel(3) ) continue ;
-
- // histo of eta:phi for all tracks
+
+ // histo of eta:phi for all tracks
fhEtaPhiTrack->Fill(track->Eta(),track->Phi());
-
+
//exclude particles in cone
Float_t rad = GetIsolationCut()->Radius(etaTrig, phiTrig, track->Eta(), track->Phi());
if(rad < conesize) {
// histo of eta:phi for all tracks in cone
- fhEtaPhiInConeTrack->Fill(track->Eta(),track->Phi());
+ fhEtaPhiInConeTrack->Fill(track->Eta(),track->Phi());
continue ;
}
}
//fill histogram for UE in eta band in EMCal acceptance
- if(track->Phi() > (phiTrig-conesize) && track->Phi() < (phiTrig+conesize))
+ if(track->Phi() > (phiTrig-conesize) && track->Phi() < (phiTrig+conesize))
{
etaBandPtSum+=track->Pt();
fhEtaBandTrack->Fill(track->Eta(),track->Phi());
fhConeSumPtPhiBandUETrack ->Fill(ptTrig , phiBandPtSum);
fhConeSumPtEtaBandUETrackTrigEtaPhi->Fill(etaTrig,phiTrig,etaBandPtSum);
fhConeSumPtPhiBandUETrackTrigEtaPhi->Fill(etaTrig,phiTrig,phiBandPtSum);
-
+
}
-//________________________________________________________________________________________________________
-Float_t AliAnaParticleIsolation::CalculateExcessAreaFraction(const Float_t excess, const Float_t conesize)
-{
- // Area of a circunference segment segment 1/2 R^2 (angle-sin(angle)), angle = 2*ACos((R-excess)/R)
-
-
- Float_t angle = 2*TMath::ACos( (conesize-excess) / conesize );
-
- Float_t coneA = conesize*conesize*TMath::Pi(); // A = pi R^2, isolation cone area
-
- Float_t excessA = conesize*conesize / 2 * (angle-TMath::Sin(angle));
-
- if(coneA > excessA) return coneA / (coneA-excessA);
- else
- {
- printf("AliAnaParticleIsolation::CalculateExcessAreaFraction() - Please Check : Excess Track %2.3f, coneA %2.2f, excessA %2.2f, angle %2.2f,factor %2.2f\n",
- excess,coneA, excessA, angle*TMath::RadToDeg(), coneA / (coneA-excessA));
- return 1;
- }
-}
-//__________________________________________________________________________________
-void AliAnaParticleIsolation::GetCoeffNormBadCell(const AliAODPWG4ParticleCorrelation * pCandidate,
- const AliCaloTrackReader * reader, Float_t & coneBadCellsCoeff, Float_t & etaBandBadCellsCoeff, Float_t & phiBandBadCellsCoeff, const Float_t conesize)
-{
- // Get good cell density (number of active cells over all cells in cone)
-
- Double_t coneCells = 0.; //number of cells in cone with radius fConeSize
- Double_t phiBandCells = 0.; //number of cells in band phi
- Double_t etaBandCells = 0.; //number of cells in band eta
- Float_t phiC = pCandidate->Phi() ;
- if(phiC<0) phiC+=TMath::TwoPi();
- Float_t etaC = pCandidate->Eta() ;
-
- if(pCandidate->GetDetector()=="EMCAL")
- {
- AliEMCALGeometry* eGeom = AliEMCALGeometry::GetInstance();
- AliCalorimeterUtils *cu = reader->GetCaloUtils();
-
- Int_t absId = -999;
- if (eGeom->GetAbsCellIdFromEtaPhi(etaC,phiC,absId))
- {
- //Get absolute (col,row) of candidate
- Int_t iEta=-1, iPhi=-1, iRCU = -1;
- Int_t nSupMod = cu->GetModuleNumberCellIndexes(absId, pCandidate->GetDetector(), iEta, iPhi, iRCU);
-
- Int_t colC = iEta;
- if (nSupMod % 2) colC = AliEMCALGeoParams::fgkEMCALCols + iEta ;
- Int_t rowC = iPhi + AliEMCALGeoParams::fgkEMCALRows*int(nSupMod/2);
-
- Int_t sqrSize = int(conesize/0.0143) ; // Size of cell in radians
- for(Int_t icol = 0; icol < 2*AliEMCALGeoParams::fgkEMCALCols-1;icol++)
- {
- for(Int_t irow = 0; irow < 5*AliEMCALGeoParams::fgkEMCALRows -1; irow++)
- {
- //loop on cells in a square of side fConeSize to check cells in cone
- if ( GetIsolationCut()->Radius(colC, rowC, icol, irow) < sqrSize) { coneCells += 1.;}
- else if(icol>colC-sqrSize && icol<colC+sqrSize ){ phiBandCells +=1;}
- else if(irow>rowC-sqrSize && irow<rowC+sqrSize ){ etaBandCells +=1;}
-
- Int_t cellSM = -999;
- Int_t cellEta = -999;
- Int_t cellPhi = -999;
- if(icol > AliEMCALGeoParams::fgkEMCALCols-1)
- {
- cellSM = 0+int(irow/AliEMCALGeoParams::fgkEMCALRows)*2;
- cellEta = icol-AliEMCALGeoParams::fgkEMCALCols;
- cellPhi = irow-AliEMCALGeoParams::fgkEMCALRows*int(cellSM/2);
- }
- if(icol < AliEMCALGeoParams::fgkEMCALCols)
- {
- cellSM = 1+int(irow/AliEMCALGeoParams::fgkEMCALRows)*2;
- cellEta = icol;
- cellPhi = irow-AliEMCALGeoParams::fgkEMCALRows*int(cellSM/2);
- }
-
- if( (icol < 0 || icol > AliEMCALGeoParams::fgkEMCALCols*2-1 ||
- irow < 0 || irow > AliEMCALGeoParams::fgkEMCALRows*5 - 1) //5*nRows+1/3*nRows //Count as bad "cells" out of EMCAL acceptance
- || (cu->GetEMCALChannelStatus(cellSM,cellEta,cellPhi)==1)) //Count as bad "cells" marked as bad in the DataBase
- {
- if (GetIsolationCut()->Radius(colC, rowC, icol, irow) < sqrSize) coneBadCellsCoeff += 1.;
- else if(icol>colC-sqrSize && icol<colC+sqrSize ) phiBandBadCellsCoeff +=1;
- else if(irow>rowC-sqrSize && irow<rowC+sqrSize ) etaBandBadCellsCoeff +=1;
- }
- }
- }//end of cells loop
- }
-
- else if(GetDebug()>0) printf("cluster with bad (eta,phi) in EMCal for energy density coeff calculation\n");
-
- if (coneCells > 0.)
- {
- // printf("Energy density coneBadCellsCoeff= %.2f coneCells%.2f\n", coneBadCellsCoeff,coneCells);
- coneBadCellsCoeff = (coneCells-coneBadCellsCoeff)/coneCells;
- // printf("coneBadCellsCoeff= %.2f\n", coneBadCellsCoeff);
- }
- if (phiBandCells > 0.)
- {
- printf("Energy density phiBandBadCellsCoeff = %.2f phiBandCells%.2f\n", phiBandBadCellsCoeff,phiBandCells);
- phiBandBadCellsCoeff = (phiBandCells-phiBandBadCellsCoeff)/phiBandCells;
- printf("phiBandBadCellsCoeff = %.2f\n", phiBandBadCellsCoeff);
- }
- if (etaBandCells > 0.)
- {
- printf("Energy density etaBandBadCellsCoeff = %.2f etaBandCells%.2f\n", etaBandBadCellsCoeff,etaBandCells);
- etaBandBadCellsCoeff = (etaBandCells-etaBandBadCellsCoeff)/etaBandCells;
- printf("etaBandBadCellsCoeff = %.2f\n",etaBandBadCellsCoeff);
- }
-
- }
-
-}
-//___________________________________________________________________________________________________________________________________
-void AliAnaParticleIsolation::CalculateNormalizeUEBandPerUnitArea(AliAODPWG4ParticleCorrelation * pCandidate,
- Float_t coneptsumCluster, Float_t coneptsumCell, Float_t coneptsumTrack)
+//_____________________________________________________________________________________________________________________________________
+void AliAnaParticleIsolation::CalculateNormalizeUEBandPerUnitArea(AliAODPWG4ParticleCorrelation * pCandidate, Float_t coneptsumCluster,
+ Float_t coneptsumCell, Float_t coneptsumTrack,
+ Float_t &etaBandptsumTrackNorm, Float_t &etaBandptsumClusterNorm)
{
//normalize phi/eta band per area unit
-
+
Float_t etaUEptsumTrack = 0 ;
Float_t phiUEptsumTrack = 0 ;
Float_t etaUEptsumCluster = 0 ;
Float_t etaUEptsumCell = 0 ;
Float_t phiUEptsumCell = 0 ;
-
Int_t partTypeInCone = GetIsolationCut()->GetParticleTypeInCone();
- // Sum the pT in the phi or eta band for clusters or tracks
-
- CalculateTrackUEBand (pCandidate,etaUEptsumTrack ,phiUEptsumTrack );// rajouter ici l'histo eta phi
- CalculateCaloUEBand (pCandidate,etaUEptsumCluster,phiUEptsumCluster);// rajouter ici l'histo eta phi
- CalculateCaloCellUEBand(pCandidate,etaUEptsumCell ,phiUEptsumCell );
-
// Do the normalization
Float_t conesize = GetIsolationCut()->GetConeSize();
Float_t ptTrig = pCandidate->Pt() ;
Float_t phiTrig = pCandidate->Phi();
Float_t etaTrig = pCandidate->Eta();
-
-Float_t coneBadCellsCoeff=1;
-Float_t etaBandBadCellsCoeff=1;
-Float_t phiBandBadCellsCoeff=1;
-GetCoeffNormBadCell(pCandidate, GetReader(),coneBadCellsCoeff,etaBandBadCellsCoeff,phiBandBadCellsCoeff,conesize) ;
-
+
+
// ------ //
// Tracks //
// ------ //
Float_t coneptsumTrackSubEta = 0 ;
Float_t coneptsumTrackSubPhiNorm = 0 ;
Float_t coneptsumTrackSubEtaNorm = 0 ;
-
+ etaBandptsumTrackNorm = 0 ;
+
if( partTypeInCone!=AliIsolationCut::kOnlyNeutral )
{
- // Get the cut used for the TPC tracks in the reader, +-0.8, +-0.9 ...
- // Only valid in simple fidutial cut case and if the cut is applied, careful!
- Float_t tpcEtaSize = GetReader()->GetFiducialCut()->GetCTSFidCutMaxEtaArray()->At(0) -
- GetReader()->GetFiducialCut()->GetCTSFidCutMinEtaArray()->At(0) ;
- Float_t tpcPhiSize = TMath::TwoPi();
+ // Sum the pT in the phi or eta band for clusters or tracks
+ CalculateTrackUEBand (pCandidate,etaUEptsumTrack ,phiUEptsumTrack );// rajouter ici l'histo eta phi
+ //Fill histos
+ fhConeSumPtVSUETracksEtaBand->Fill(coneptsumTrack,etaUEptsumTrack);
+ fhConeSumPtVSUETracksPhiBand->Fill(coneptsumTrack,phiUEptsumTrack);
- //printf("tracks eta fiducial acceptance %f\n",tpcEtaSize);
-/* phiUEptsumTrackNorm = phiUEptsumTrack*(coneA*coneBadCellsCoeff / (((2*conesize*tpcPhiSize)-coneA))*phiBandBadCellsCoeff); // pi * R^2 / (2 R * 2 pi) - trigger cone
- etaUEptsumTrackNorm = etaUEptsumTrack*(coneA*coneBadCellsCoeff / (((2*conesize*tpcEtaSize)-coneA))*etaBandBadCellsCoeff); // pi * R^2 / (2 R * 1.6) - trigger cone
- */
- if((2*conesize*tpcPhiSize-coneA)!=0)phiUEptsumTrackNorm = phiUEptsumTrack*(coneA / (((2*conesize*tpcPhiSize)-coneA))); // pi * R^2 / (2 R * 2 pi) - trigger cone
- if((2*conesize*tpcEtaSize-coneA)!=0)etaUEptsumTrackNorm = etaUEptsumTrack*(coneA / (((2*conesize*tpcEtaSize)-coneA))); // pi * R^2 / (2 R * 1.6) - trigger cone
-
- // Need to correct coneptsumTrack by the fraction of the cone out of track cut acceptance!
- Float_t correctConeSumTrack = 1;
- if(TMath::Abs(etaTrig)+conesize > tpcEtaSize/2.)
- {
- Float_t excess = TMath::Abs(etaTrig) + conesize - tpcEtaSize/2.;
- correctConeSumTrack = CalculateExcessAreaFraction(excess,conesize);
- //printf("Excess Track %2.3f, coneA %2.2f, excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumTrack);
-
- // Need to correct phi band surface if part of the cone falls out of track cut acceptance! Not sure this will happen.
- if((2*(conesize-excess)*tpcPhiSize)-(coneA-correctConeSumTrack)!=0)phiUEptsumTrackNorm = phiUEptsumTrack*(coneA / (((2*(conesize-excess)*tpcPhiSize)-(coneA/correctConeSumTrack))));
- // phiUEptsumTrackNorm = phiUEptsumTrack*(coneA *coneBadCellsCoeff/ (((2*(conesize-excess)*tpcPhiSize)-(coneA-correctConeSumTrack))*phiBandBadCellsCoeff));
- }
+ Float_t correctConeSumTrack = 1;
+ Float_t correctConeSumTrackPhi = 1;
+
+ GetIsolationCut()->CalculateUEBandTrackNormalization(GetReader(),etaTrig, phiTrig,
+ phiUEptsumTrack,etaUEptsumTrack,
+ phiUEptsumTrackNorm,etaUEptsumTrackNorm,
+ correctConeSumTrack,correctConeSumTrackPhi);
- coneptsumTrackSubPhi = coneptsumTrack*correctConeSumTrack - phiUEptsumTrackNorm;
- coneptsumTrackSubEta = coneptsumTrack*correctConeSumTrack - etaUEptsumTrackNorm;
+ coneptsumTrackSubPhi = coneptsumTrack - phiUEptsumTrackNorm;
+ coneptsumTrackSubEta = coneptsumTrack - etaUEptsumTrackNorm;
+
+ etaBandptsumTrackNorm = etaUEptsumTrackNorm;
fhConeSumPtPhiUESubTrack ->Fill(ptTrig , coneptsumTrackSubPhi);
fhConeSumPtPhiUESubTrackTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumTrackSubPhi);
fhFractionTrackOutConeEta ->Fill(ptTrig , correctConeSumTrack-1);
fhFractionTrackOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig,correctConeSumTrack-1);
- if(coneptsumTrack!=0){
- coneptsumTrackSubPhiNorm = coneptsumTrackSubPhi/coneptsumTrack;
+ if(coneptsumTrack > 0)
+ {
+ coneptsumTrackSubPhiNorm = coneptsumTrackSubPhi/coneptsumTrack;
coneptsumTrackSubEtaNorm = coneptsumTrackSubEta/coneptsumTrack;
}
+
fhConeSumPtSubvsConeSumPtTotPhiTrack ->Fill(coneptsumTrack,coneptsumTrackSubPhi);
fhConeSumPtSubNormvsConeSumPtTotPhiTrack->Fill(coneptsumTrack,coneptsumTrackSubPhiNorm);
fhConeSumPtSubvsConeSumPtTotEtaTrack ->Fill(coneptsumTrack,coneptsumTrackSubEta);
Float_t coneptsumCellSubEta = 0 ;
Float_t coneptsumCellSubPhiNorm = 0 ;
Float_t coneptsumCellSubEtaNorm = 0 ;
-
+ etaBandptsumClusterNorm = 0;
+
if( partTypeInCone!=AliIsolationCut::kOnlyCharged )
{
- //Careful here if EMCal limits changed .. 2010 (4 SM) to 2011-12 (10 SM), for the moment consider 100 deg in phi
- Float_t emcEtaSize = 0.7*2;
- Float_t emcPhiSize = TMath::DegToRad()*100;
-
+
// -------------- //
// EMCal clusters //
// -------------- //
-
- if(((((2*conesize*emcPhiSize)-coneA))*phiBandBadCellsCoeff)!=0)phiUEptsumClusterNorm = phiUEptsumCluster*(coneA*coneBadCellsCoeff / (((2*conesize*emcPhiSize)-coneA))*phiBandBadCellsCoeff); // pi * R^2 / (2 R * 2 100 deg) - trigger cone
- if(((((2*conesize*emcEtaSize)-coneA))*etaBandBadCellsCoeff)!=0) etaUEptsumClusterNorm = etaUEptsumCluster*(coneA*coneBadCellsCoeff / (((2*conesize*emcEtaSize)-coneA))*etaBandBadCellsCoeff); // pi * R^2 / (2 R * 2*1.7) - trigger cone
-
- // Need to correct coneptsumCluster by the fraction of the cone out of the calorimeter cut acceptance!
- Float_t correctConeSumClusterEta = 1;
- if(TMath::Abs(etaTrig)+conesize > emcEtaSize/2.)
- {
- Float_t excess = TMath::Abs(etaTrig) + conesize - emcEtaSize/2.;
- correctConeSumClusterEta = CalculateExcessAreaFraction(excess,conesize);
- //printf("Excess EMC-Eta %2.3f, coneA %2.2f, excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumClusterEta);
-
- // Need to correct phi band surface if part of the cone falls out of track cut acceptance!
- if(((((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumClusterEta))*etaBandBadCellsCoeff))!=0)phiUEptsumClusterNorm = phiUEptsumCluster*(coneA *coneBadCellsCoeff/ (((2*(conesize-excess)*emcPhiSize)-(coneA/correctConeSumClusterEta))*etaBandBadCellsCoeff));
- }
+ // Sum the pT in the phi or eta band for clusters or tracks
+ CalculateCaloUEBand (pCandidate,etaUEptsumCluster,phiUEptsumCluster);// rajouter ici l'histo eta phi
+
+ //Fill histos
+ fhConeSumPtVSUEClusterEtaBand->Fill(coneptsumCluster,etaUEptsumCluster);
+ fhConeSumPtVSUEClusterPhiBand->Fill(coneptsumCluster,phiUEptsumCluster);
+
+
+ Float_t correctConeSumClusterEta = 1;
Float_t correctConeSumClusterPhi = 1;
- //printf("EMCPhiTrig %2.2f, conesize %2.2f, sum %2.2f, rest %2.2f \n",phiTrig*TMath::RadToDeg(),conesize*TMath::RadToDeg(),(phiTrig+conesize)*TMath::RadToDeg(),(phiTrig-conesize)*TMath::RadToDeg() );
- if((phiTrig+conesize > 180*TMath::DegToRad()) ||
- (phiTrig-conesize < 80*TMath::DegToRad()))
- {
- Float_t excess = 0;
- if( phiTrig+conesize > 180*TMath::DegToRad() ) excess = conesize + phiTrig - 180*TMath::DegToRad() ;
- else excess = conesize - phiTrig + 80*TMath::DegToRad() ;
-
- correctConeSumClusterPhi = CalculateExcessAreaFraction(excess,conesize);
- //printf("Excess EMC-Phi %2.3f, coneA %2.2f, excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumClusterPhi);
-
- // Need to correct eta band surface if part of the cone falls out of track cut acceptance!
- if(((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumClusterPhi))*phiBandBadCellsCoeff!=0) etaUEptsumClusterNorm = etaUEptsumCluster*(coneA*coneBadCellsCoeff / (((2*(conesize-excess)*emcEtaSize)-(coneA/correctConeSumClusterPhi))*phiBandBadCellsCoeff));
- }
+
+ GetIsolationCut()->CalculateUEBandClusterNormalization(GetReader(),etaTrig, phiTrig,
+ phiUEptsumCluster,etaUEptsumCluster,
+ phiUEptsumClusterNorm,etaUEptsumClusterNorm,
+ correctConeSumClusterEta,correctConeSumClusterPhi);
// In case that cone is out of eta and phi side, we are over correcting, not too often with the current cuts ...
- coneptsumCluster=coneptsumCluster*coneBadCellsCoeff*correctConeSumClusterEta*correctConeSumClusterPhi;
- coneptsumClusterSubPhi = coneptsumCluster - phiUEptsumClusterNorm;
+ // Comment if not used
+ // Float_t coneBadCellsCoeff =1;
+ // Float_t etaBandBadCellsCoeff=1;
+ // Float_t phiBandBadCellsCoeff=1;
+ // GetIsolationCut()->GetCoeffNormBadCell(pCandidate, GetReader(),coneBadCellsCoeff,etaBandBadCellsCoeff,phiBandBadCellsCoeff) ;
+
+ //coneptsumCluster=coneptsumCluster*coneBadCellsCoeff*correctConeSumClusterEta*correctConeSumClusterPhi;
+
+ coneptsumClusterSubPhi = coneptsumCluster - phiUEptsumClusterNorm;
coneptsumClusterSubEta = coneptsumCluster - etaUEptsumClusterNorm;
-
-
+ etaBandptsumClusterNorm = etaUEptsumClusterNorm;
+
fhConeSumPtPhiUESubCluster ->Fill(ptTrig , coneptsumClusterSubPhi);
fhConeSumPtPhiUESubClusterTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumClusterSubPhi);
fhConeSumPtEtaUESubCluster ->Fill(ptTrig , coneptsumClusterSubEta);
fhFractionClusterOutConePhi ->Fill(ptTrig , correctConeSumClusterPhi-1);
fhFractionClusterOutConePhiTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumClusterPhi-1);
- if(coneptsumCluster!=0){
+ if(coneptsumCluster!=0)
+ {
coneptsumClusterSubPhiNorm = coneptsumClusterSubPhi/coneptsumCluster;
coneptsumClusterSubEtaNorm = coneptsumClusterSubEta/coneptsumCluster;
}
+
fhConeSumPtSubvsConeSumPtTotPhiCluster ->Fill(coneptsumCluster,coneptsumClusterSubPhi);
fhConeSumPtSubNormvsConeSumPtTotPhiCluster->Fill(coneptsumCluster,coneptsumClusterSubPhiNorm);
fhConeSumPtSubvsConeSumPtTotEtaCluster ->Fill(coneptsumCluster,coneptsumClusterSubEta);
// ----------- //
// EMCal Cells //
// ----------- //
-
- if(((2*conesize*emcPhiSize)-coneA)!=0)phiUEptsumCellNorm = phiUEptsumCell*(coneA / ((2*conesize*emcPhiSize)-coneA));
- if((((2*conesize*emcEtaSize)-coneA))!=0)etaUEptsumCellNorm = etaUEptsumCell*(coneA / ((2*conesize*emcEtaSize)-coneA));
-
- // Need to correct coneptsumCluster by the fraction of the cone out of the calorimeter cut acceptance!
-
- Float_t correctConeSumCellEta = 1;
- if(TMath::Abs(etaTrig)+conesize > emcEtaSize/2.)
- {
- Float_t excess = TMath::Abs(etaTrig) + conesize - emcEtaSize/2.;
- correctConeSumCellEta = CalculateExcessAreaFraction(excess,conesize);
- //printf("Excess EMC-Eta %2.3f, coneA %2.2f, excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumClusterEta);
- // Need to correct phi band surface if part of the cone falls out of track cut acceptance!
- if(((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumCellEta))!=0)phiUEptsumCellNorm = phiUEptsumCell*(coneA / ((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumCellEta)));
- }
- Float_t correctConeSumCellPhi = 1;
- //printf("EMCPhiTrig %2.2f, conesize %2.2f, sum %2.2f, rest %2.2f \n",phiTrig*TMath::RadToDeg(),conesize*TMath::RadToDeg(),(phiTrig+conesize)*TMath::RadToDeg(),(phiTrig-conesize)*TMath::RadToDeg() );
- if((phiTrig+conesize > 180*TMath::DegToRad()) ||
- (phiTrig-conesize < 80*TMath::DegToRad()))
+ if(fFillCellHistograms)
{
- Float_t excess = 0;
- if( phiTrig+conesize > 180*TMath::DegToRad() ) excess = conesize + phiTrig - 180*TMath::DegToRad() ;
- else excess = conesize - phiTrig + 80*TMath::DegToRad() ;
+ // Sum the pT in the phi or eta band for clusters or tracks
+ CalculateCaloCellUEBand(pCandidate,etaUEptsumCell ,phiUEptsumCell );
- correctConeSumCellPhi = CalculateExcessAreaFraction(excess,conesize);
- //printf("Excess EMC-Phi %2.3f, coneA %2.2f, excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumClusterPhi);
+ // Move to AliIsolationCut the calculation not the histograms??
- // Need to correct eta band surface if part of the cone falls out of track cut acceptance!
- if(((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumCellPhi))!=0)etaUEptsumCellNorm = etaUEptsumCell*(coneA / ((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumCellPhi)));
-
+ //Careful here if EMCal limits changed .. 2010 (4 SM) to 2011-12 (10 SM), for the moment consider 100 deg in phi
+ Float_t emcEtaSize = 0.7*2; // TO FIX
+ Float_t emcPhiSize = TMath::DegToRad()*100.; // TO FIX
+
+ if(((2*conesize*emcPhiSize)-coneA)!=0)phiUEptsumCellNorm = phiUEptsumCell*(coneA / ((2*conesize*emcPhiSize)-coneA));
+ if(((2*conesize*emcEtaSize)-coneA)!=0)etaUEptsumCellNorm = etaUEptsumCell*(coneA / ((2*conesize*emcEtaSize)-coneA));
+
+ // Need to correct coneptsumCluster by the fraction of the cone out of the calorimeter cut acceptance!
+
+ Float_t correctConeSumCellEta = 1;
+ if(TMath::Abs(etaTrig)+conesize > emcEtaSize/2.)
+ {
+ Float_t excess = TMath::Abs(etaTrig) + conesize - emcEtaSize/2.;
+ correctConeSumCellEta = GetIsolationCut()->CalculateExcessAreaFraction(excess);
+ //printf("Excess EMC-Eta %2.3f, coneA %2.2f, excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumClusterEta);
+ // Need to correct phi band surface if part of the cone falls out of track cut acceptance!
+ if(((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumCellEta))!=0)phiUEptsumCellNorm = phiUEptsumCell*(coneA / ((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumCellEta)));
+ }
+
+ Float_t correctConeSumCellPhi = 1;
+ //printf("EMCPhiTrig %2.2f, conesize %2.2f, sum %2.2f, rest %2.2f \n",phiTrig*TMath::RadToDeg(),conesize*TMath::RadToDeg(),(phiTrig+conesize)*TMath::RadToDeg(),(phiTrig-conesize)*TMath::RadToDeg() );
+ if((phiTrig+conesize > 180*TMath::DegToRad()) ||
+ (phiTrig-conesize < 80*TMath::DegToRad()))
+ {
+ Float_t excess = 0;
+ if( phiTrig+conesize > 180*TMath::DegToRad() ) excess = conesize + phiTrig - 180*TMath::DegToRad() ;
+ else excess = conesize - phiTrig + 80*TMath::DegToRad() ;
+
+ correctConeSumCellPhi = GetIsolationCut()->CalculateExcessAreaFraction(excess);
+ //printf("Excess EMC-Phi %2.3f, coneA %2.2f, excessA %2.2f, angle %2.2f,factor %2.2f\n",excess,coneA, excessA, angle*TMath::RadToDeg(), correctConeSumClusterPhi);
+
+ // Need to correct eta band surface if part of the cone falls out of track cut acceptance!
+ if(((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumCellPhi))!=0)etaUEptsumCellNorm = etaUEptsumCell*(coneA / ((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumCellPhi)));
+
+ }
+
+ // In case that cone is out of eta and phi side, we are over correcting, not too often with the current cuts ...
+ coneptsumCellSubPhi = coneptsumCell*correctConeSumCellEta*correctConeSumCellPhi - phiUEptsumCellNorm;
+ coneptsumCellSubEta = coneptsumCell*correctConeSumCellEta*correctConeSumCellPhi - etaUEptsumCellNorm;
+
+ fhConeSumPtPhiUESubCell ->Fill(ptTrig , coneptsumCellSubPhi);
+ fhConeSumPtPhiUESubCellTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumCellSubPhi);
+ fhConeSumPtEtaUESubCell ->Fill(ptTrig , coneptsumCellSubEta);
+ fhConeSumPtEtaUESubCellTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumCellSubEta);
+
+ fhFractionCellOutConeEta ->Fill(ptTrig , correctConeSumCellEta-1);
+ fhFractionCellOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumCellEta-1);
+ fhFractionCellOutConePhi ->Fill(ptTrig , correctConeSumCellPhi-1);
+ fhFractionCellOutConePhiTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumCellPhi-1);
+ if(coneptsumCell!=0)
+ {
+ coneptsumCellSubPhiNorm = coneptsumCellSubPhi/coneptsumCell;
+ coneptsumCellSubEtaNorm = coneptsumCellSubEta/coneptsumCell;
+ }
+
+ fhConeSumPtSubvsConeSumPtTotPhiCell ->Fill(coneptsumCell,coneptsumCellSubPhi);
+ fhConeSumPtSubNormvsConeSumPtTotPhiCell->Fill(coneptsumCell,coneptsumCellSubPhiNorm);
+ fhConeSumPtSubvsConeSumPtTotEtaCell ->Fill(coneptsumCell,coneptsumCellSubEta);
+ fhConeSumPtSubNormvsConeSumPtTotEtaCell->Fill(coneptsumCell,coneptsumCellSubEtaNorm);
}
-
- // In case that cone is out of eta and phi side, we are over correcting, not too often with the current cuts ...
- coneptsumCellSubPhi = coneptsumCell*correctConeSumCellEta*correctConeSumCellPhi - phiUEptsumCellNorm;
- coneptsumCellSubEta = coneptsumCell*correctConeSumCellEta*correctConeSumCellPhi - etaUEptsumCellNorm;
-
- fhConeSumPtPhiUESubCell ->Fill(ptTrig , coneptsumCellSubPhi);
- fhConeSumPtPhiUESubCellTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumCellSubPhi);
- fhConeSumPtEtaUESubCell ->Fill(ptTrig , coneptsumCellSubEta);
- fhConeSumPtEtaUESubCellTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumCellSubEta);
-
- fhFractionCellOutConeEta ->Fill(ptTrig , correctConeSumCellEta-1);
- fhFractionCellOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumCellEta-1);
- fhFractionCellOutConePhi ->Fill(ptTrig , correctConeSumCellPhi-1);
- fhFractionCellOutConePhiTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumCellPhi-1);
- if(coneptsumCell!=0){
- coneptsumCellSubPhiNorm = coneptsumCellSubPhi/coneptsumCell;
- coneptsumCellSubEtaNorm = coneptsumCellSubEta/coneptsumCell;
- }
- fhConeSumPtSubvsConeSumPtTotPhiCell ->Fill(coneptsumCell,coneptsumCellSubPhi);
- fhConeSumPtSubNormvsConeSumPtTotPhiCell->Fill(coneptsumCell,coneptsumCellSubPhiNorm);
- fhConeSumPtSubvsConeSumPtTotEtaCell ->Fill(coneptsumCell,coneptsumCellSubEta);
- fhConeSumPtSubNormvsConeSumPtTotEtaCell->Fill(coneptsumCell,coneptsumCellSubEtaNorm);
-
}
-
+
if( partTypeInCone==AliIsolationCut::kNeutralAndCharged )
{
-
// --------------------------- //
// Tracks and clusters in cone //
// --------------------------- //
fhConeSumPtEtaUESubClustervsTrack->Fill(coneptsumClusterSubEta,coneptsumTrackSubEta);
fhConeSumPtPhiUESubClustervsTrack->Fill(coneptsumClusterSubPhi,coneptsumTrackSubPhi);
-
+
// ------------------------ //
// Tracks and cells in cone //
// ------------------------ //
- Double_t sumPhiUESubTrackCell = coneptsumCellSubPhi + coneptsumTrackSubPhi;
- Double_t sumEtaUESubTrackCell = coneptsumCellSubEta + coneptsumTrackSubEta;
-
- fhConeSumPtPhiUESubTrackCell ->Fill(ptTrig , sumPhiUESubTrackCell);
- fhConeSumPtPhiUESubTrackCellTrigEtaPhi->Fill(etaTrig, phiTrig, sumPhiUESubTrackCell);
- fhConeSumPtEtaUESubTrackCell ->Fill(ptTrig , sumEtaUESubTrackCell);
- fhConeSumPtEtaUESubTrackCellTrigEtaPhi->Fill(etaTrig, phiTrig, sumEtaUESubTrackCell);
-
- fhEtaBandCellvsTrack ->Fill(etaUEptsumCell ,etaUEptsumTrack );
- fhPhiBandCellvsTrack ->Fill(phiUEptsumCell ,phiUEptsumTrack );
- fhEtaBandNormCellvsTrack->Fill(etaUEptsumCellNorm,etaUEptsumTrackNorm);
- fhPhiBandNormCellvsTrack->Fill(phiUEptsumCellNorm,phiUEptsumTrackNorm);
-
- fhConeSumPtEtaUESubCellvsTrack->Fill(coneptsumCellSubEta,coneptsumTrackSubEta);
- fhConeSumPtPhiUESubCellvsTrack->Fill(coneptsumCellSubPhi,coneptsumTrackSubPhi);
-
+ if(fFillCellHistograms)
+ {
+ Double_t sumPhiUESubTrackCell = coneptsumCellSubPhi + coneptsumTrackSubPhi;
+ Double_t sumEtaUESubTrackCell = coneptsumCellSubEta + coneptsumTrackSubEta;
+
+ fhConeSumPtPhiUESubTrackCell ->Fill(ptTrig , sumPhiUESubTrackCell);
+ fhConeSumPtPhiUESubTrackCellTrigEtaPhi->Fill(etaTrig, phiTrig, sumPhiUESubTrackCell);
+ fhConeSumPtEtaUESubTrackCell ->Fill(ptTrig , sumEtaUESubTrackCell);
+ fhConeSumPtEtaUESubTrackCellTrigEtaPhi->Fill(etaTrig, phiTrig, sumEtaUESubTrackCell);
+
+ fhEtaBandCellvsTrack ->Fill(etaUEptsumCell ,etaUEptsumTrack );
+ fhPhiBandCellvsTrack ->Fill(phiUEptsumCell ,phiUEptsumTrack );
+ fhEtaBandNormCellvsTrack->Fill(etaUEptsumCellNorm,etaUEptsumTrackNorm);
+ fhPhiBandNormCellvsTrack->Fill(phiUEptsumCellNorm,phiUEptsumTrackNorm);
+
+ fhConeSumPtEtaUESubCellvsTrack->Fill(coneptsumCellSubEta,coneptsumTrackSubEta);
+ fhConeSumPtPhiUESubCellvsTrack->Fill(coneptsumCellSubPhi,coneptsumTrackSubPhi);
+ }
}
}
-//__________________________________________________________________________________________________
+//______________________________________________________________________________________________________________
void AliAnaParticleIsolation::CalculateCaloSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
- Float_t & coneptsumCluster)
+ Float_t & coneptsumCluster, Float_t & coneptLeadCluster)
{
// Get the cluster pT or sum of pT in isolation cone
+ coneptLeadCluster = 0;
+ coneptsumCluster = 0;
if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
//Recover reference arrays with clusters and tracks
- TObjArray * refclusters = aodParticle->GetObjArray(GetAODObjArrayName()+"Clusters");
+ TObjArray * refclusters = aodParticle->GetObjArray(GetAODObjArrayName()+"Clusters");
if(!refclusters) return ;
Float_t ptTrig = aodParticle->Pt();
-
+
//Get vertex for cluster momentum calculation
Double_t vertex[] = {0,0,0} ; //vertex ;
if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtInConePileUp[6]->Fill(ptTrig,mom.Pt());
}
- fhPtInConeCent->Fill(GetEventCentrality(),mom.Pt());
+ if(fFillHighMultHistograms) fhPtInConeCent->Fill(GetEventCentrality(),mom.Pt());
+
coneptsumCluster+=mom.Pt();
+ if(mom.Pt() > coneptLeadCluster) coneptLeadCluster = mom.Pt();
}
-
- fhConeSumPtCluster ->Fill(ptTrig, coneptsumCluster);
+
+ fhConeSumPtCluster ->Fill(ptTrig, coneptsumCluster );
+ fhConePtLeadCluster->Fill(ptTrig, coneptLeadCluster);
}
-//__________________________________________________________________________________________________
+//______________________________________________________________________________________________________
void AliAnaParticleIsolation::CalculateCaloCellSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
Float_t & coneptsumCell)
{
Int_t nModule = -1;
Int_t imEta=-1, imPhi=-1;
Int_t ieta =-1, iphi =-1;
-
+
if (eGeom->GetCellIndex(absId,nSupMod,nModule,imPhi,imEta))
{
Int_t iEta=-1, iPhi=-1;
for(Int_t icol = colTrig-sqrSize; icol < colTrig+sqrSize; icol++)
{
Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
- if(inSector==5) continue;
-
- Int_t inSupMod = -1;
+ if(inSector==5) continue;
+
+ Int_t inSupMod = -1;
Int_t icolLoc = -1;
if(icol < AliEMCALGeoParams::fgkEMCALCols)
{
}
-//___________________________________________________________________________________________________
+//___________________________________________________________________________________________________________
void AliAnaParticleIsolation::CalculateTrackSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
- Float_t & coneptsumTrack)
+ Float_t & coneptsumTrack, Float_t & coneptLeadTrack)
{
// Get the track pT or sum of pT in isolation cone
Float_t ptTrig = aodParticle->Pt();
Double_t bz = GetReader()->GetInputEvent()->GetMagneticField();
-
+
for(Int_t itrack=0; itrack < reftracks->GetEntriesFast(); itrack++)
{
AliVTrack* track = (AliVTrack *) reftracks->At(itrack);
if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtTrackInConeVtxBC0->Fill(ptTrig,pTtrack);
if(GetReader()->IsPileUpFromSPD()) { fhPtInConePileUp[0]->Fill(ptTrig,pTtrack);
- if(okTOF && trackBC!=0 ) fhPtTrackInConeOtherBCPileUpSPD->Fill(ptTrig,pTtrack);
- if(okTOF && trackBC==0 ) fhPtTrackInConeBC0PileUpSPD ->Fill(ptTrig,pTtrack); }
+ if(okTOF && trackBC!=0 ) fhPtTrackInConeOtherBCPileUpSPD->Fill(ptTrig,pTtrack);
+ if(okTOF && trackBC==0 ) fhPtTrackInConeBC0PileUpSPD ->Fill(ptTrig,pTtrack); }
if(GetReader()->IsPileUpFromEMCal()) fhPtInConePileUp[1]->Fill(ptTrig,pTtrack);
if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtInConePileUp[2]->Fill(ptTrig,pTtrack);
if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtInConePileUp[3]->Fill(ptTrig,pTtrack);
if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtInConePileUp[6]->Fill(ptTrig,pTtrack);
}
- fhPtInConeCent->Fill(GetEventCentrality(),pTtrack);
+ if(fFillHighMultHistograms) fhPtInConeCent->Fill(GetEventCentrality(),pTtrack);
+
coneptsumTrack+=pTtrack;
+ if(pTtrack > coneptLeadTrack) coneptLeadTrack = pTtrack;
}
-
- fhConeSumPtTrack->Fill(ptTrig, coneptsumTrack);
+
+ fhConeSumPtTrack ->Fill(ptTrig, coneptsumTrack );
+ fhConePtLeadTrack->Fill(ptTrig, coneptLeadTrack);
}
void AliAnaParticleIsolation::FillPileUpHistograms(Int_t clusterID)
{
// Fill some histograms to understand pile-up
- if(!fFillPileUpHistograms) return;
- if(clusterID < 0 )
+ if(clusterID < 0 )
{
printf("AliAnaParticleIsolation::FillPileUpHistograms(), ID of cluster = %d, not possible! ", clusterID);
return;
Float_t energy = 0;
Float_t time = -1000;
-
+
if(clusters)
{
- AliVCluster *cluster = FindCluster(clusters,clusterID,iclus);
+ AliVCluster *cluster = FindCluster(clusters,clusterID,iclus);
energy = cluster->E();
time = cluster->GetTOF()*1e9;
- }
+ }
//printf("E %f, time %f\n",energy,time);
AliVEvent * event = GetReader()->GetInputEvent();
fhTimeNPileUpVertSPD ->Fill(time,nVerticesSPD);
fhTimeNPileUpVertTrack->Fill(time,nVerticesTracks);
- //printf("Is SPD %d, Is SPD Multi %d, n spd %d, n track %d\n",
+ //printf("Is SPD %d, Is SPD Multi %d, n spd %d, n track %d\n",
// GetReader()->IsPileUpFromSPD(),event->IsPileupFromSPDInMultBins(),nVerticesSPD,nVerticesTracks);
Int_t ncont = -1;
//_____________________________________________________________________________________________________________________
void AliAnaParticleIsolation::FillTrackMatchingShowerShapeControlHistograms(AliAODPWG4ParticleCorrelation *pCandidate,
- const AliCaloTrackReader * reader,
- const AliCaloPID * pid)
+ Float_t coneptsum, Float_t coneleadpt,
+ Int_t mcIndex)
{
- // Fill Track matching and Shower Shape control histograms
- if(!fFillTMHisto && !fFillSSHisto) return;
+ // Fill Track matching and Shower Shape control histograms
+ if(!fFillTMHisto && !fFillSSHisto && !fFillBackgroundBinHistograms) return;
Int_t clusterID = pCandidate->GetCaloLabel(0) ;
Int_t nMaxima = pCandidate->GetFiducialArea(); // bad name, just place holder for the moment
if (fCalorimeter == "EMCAL") clusters = GetEMCALClusters();
else if(fCalorimeter == "PHOS" ) clusters = GetPHOSClusters();
- if(clusters)
+ if(!clusters) return;
+
+ AliVCluster *cluster = FindCluster(clusters,clusterID,iclus);
+
+ Float_t m02 = cluster->GetM02() ;
+ Float_t energy = pCandidate->E();
+ Float_t pt = pCandidate->Pt();
+
+ // Get the max pt leading in cone or the sum of pt in cone
+ // assign a bin to the candidate, depending on both quantities
+ // see the shower shape in those bins.
+ if(fFillBackgroundBinHistograms)
{
- AliVCluster *cluster = FindCluster(clusters,clusterID,iclus);
- Float_t energy = cluster->E();
+ // Get the background bin for this cone and trigger
+ Int_t ptsumBin = -1;
+ Int_t leadptBin = -1;
- if(fFillSSHisto)
+ if( GetDebug() > 1 )
+ printf("AliAnaParticleIsolation::FillTrackMatchingShowerShapeControlHistograms() - pT cand: %2.2f, In cone pT: Sum %2.2f, Lead %2.2f, n bins %d\n",
+ pt,coneptsum,coneleadpt,fNBkgBin);
+
+ for(Int_t ibin = 0; ibin < fNBkgBin; ibin++)
{
- fhELambda0[isolated]->Fill(energy, cluster->GetM02() );
- fhELambda1[isolated]->Fill(energy, cluster->GetM20() );
-
- if(IsDataMC())
+ if( coneptsum >= fBkgBinLimit[ibin] && coneptsum < fBkgBinLimit[ibin+1]) ptsumBin = ibin;
+ if( coneleadpt >= fBkgBinLimit[ibin] && coneleadpt < fBkgBinLimit[ibin+1]) leadptBin = ibin;
+ }
+
+ // Fill the histograms per bin of pt lead or pt sum
+ if( GetDebug() > 1 && ptsumBin >=0 ) printf("\t Sum bin %d [%2.2f,%2.2f]\n" , ptsumBin ,fBkgBinLimit[ptsumBin] ,fBkgBinLimit[ptsumBin +1]);
+ if( GetDebug() > 1 && leadptBin >=0 ) printf("\t Lead bin %d [%2.2f,%2.2f]\n", leadptBin,fBkgBinLimit[leadptBin],fBkgBinLimit[leadptBin+1]);
+
+ if( leadptBin >=0 ) fhPtLeadConeBinLambda0[leadptBin]->Fill(pt,m02);
+ if( ptsumBin >=0 ) fhSumPtConeBinLambda0 [ ptsumBin]->Fill(pt,m02);
+
+ if( GetDebug() > 1 && leadptBin == 0 )
+ printf("No track/clusters in isolation cone: cand pt %2.2f GeV/c, track multiplicity %d, N clusters %d\n",
+ pt, GetTrackMultiplicity(),GetEMCALClusters()->GetEntriesFast());
+
+ if(IsDataMC())
+ {
+ Int_t leadptBinMC = leadptBin+mcIndex*fNBkgBin;
+ Int_t ptsumBinMC = ptsumBin+mcIndex*fNBkgBin;
+ if( leadptBin >=0 ) fhPtLeadConeBinLambda0MC[leadptBinMC]->Fill(pt,m02);
+ if( ptsumBin >=0 ) fhSumPtConeBinLambda0MC [ ptsumBinMC]->Fill(pt,m02);
+ if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
{
- if (GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt) ||
- GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation)) fhELambda0MCPhoton [isolated]->Fill(energy, cluster->GetM02());
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0)) fhELambda0MCPi0 [isolated]->Fill(energy, cluster->GetM02());
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay)) fhELambda0MCPi0Decay [isolated]->Fill(energy, cluster->GetM02());
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay)) fhELambda0MCEtaDecay [isolated]->Fill(energy, cluster->GetM02());
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay)) fhELambda0MCOtherDecay[isolated]->Fill(energy, cluster->GetM02());
-
- // else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion)) fhPtNoIsoConversion ->Fill(energy, cluster->GetM02());
- else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)) fhELambda0MCHadron [isolated]->Fill(energy, cluster->GetM02());
-
+ leadptBinMC = leadptBin+kmcPhoton*fNBkgBin;
+ ptsumBinMC = ptsumBin+kmcPhoton*fNBkgBin;
+ if( leadptBin >=0 ) fhPtLeadConeBinLambda0MC[leadptBinMC]->Fill(pt,m02);
+ if( ptsumBin >=0 ) fhSumPtConeBinLambda0MC [ ptsumBinMC]->Fill(pt,m02);
}
-
- if(fCalorimeter == "EMCAL" && GetModuleNumber(cluster) > 5) // TO DO: CHANGE FOR 2012
+ }
+ }
+
+ if(fFillSSHisto)
+ {
+ fhELambda0 [isolated]->Fill(energy, m02);
+ fhPtLambda0[isolated]->Fill(pt, m02);
+ fhELambda1 [isolated]->Fill(energy, m02);
+ if(fFillTaggedDecayHistograms)
+ {
+ Int_t decayTag = pCandidate->GetBtag(); // temporary
+ if(decayTag < 0) decayTag = 0; // temporary
+ for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
{
- fhELambda0TRD[isolated]->Fill(energy, cluster->GetM02() );
- fhELambda1TRD[isolated]->Fill(energy, cluster->GetM20() );
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
+ fhPtLambda0Decay[isolated][ibit]->Fill(pt,m02);
}
+ }
+
+ if(IsDataMC())
+ {
+ if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
+ fhPtLambda0MC[kmcPhoton][isolated]->Fill(pt,m02);
+ fhPtLambda0MC[mcIndex][isolated]->Fill(pt,m02);
+ }
+
+ if(fCalorimeter == "EMCAL" && GetFirstSMCoveredByTRD() >= 0 &&
+ GetModuleNumber(cluster) >= GetFirstSMCoveredByTRD() )
+ {
+ fhELambda0TRD [isolated]->Fill(energy, m02 );
+ fhPtLambda0TRD[isolated]->Fill(pt , m02 );
+ fhELambda1TRD [isolated]->Fill(energy, m02 );
+ }
+
+ if(fFillNLMHistograms)
+ {
fhNLocMax[isolated]->Fill(energy,nMaxima);
- if (nMaxima==1) { fhELambda0LocMax1[isolated]->Fill(energy,cluster->GetM02()); fhELambda1LocMax1[isolated]->Fill(energy,cluster->GetM20()); }
- else if(nMaxima==2) { fhELambda0LocMax2[isolated]->Fill(energy,cluster->GetM02()); fhELambda1LocMax2[isolated]->Fill(energy,cluster->GetM20()); }
- else { fhELambda0LocMaxN[isolated]->Fill(energy,cluster->GetM02()); fhELambda1LocMaxN[isolated]->Fill(energy,cluster->GetM20()); }
-
- if(isolated==0)
- {
- //Analyse non-isolated events
- Int_t n = 0;
- Int_t nfrac = 0;
- Bool_t iso = kFALSE ;
- Float_t coneptsum = 0 ;
-
- TObjArray * plNe = pCandidate->GetObjArray(GetAODObjArrayName()+"Clusters");
- TObjArray * plCTS = pCandidate->GetObjArray(GetAODObjArrayName()+"Tracks");
-
- GetIsolationCut()->SetPtThresholdMax(1.);
- GetIsolationCut()->MakeIsolationCut(plCTS, plNe,
- reader, pid,
- kFALSE, pCandidate, "",
- n,nfrac,coneptsum, iso);
-
- if (!iso) fhELambda0SSBkg->Fill(energy, cluster->GetM02());
-
- if(GetDebug() > 0) printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Energy Sum in Isolation Cone %2.2f\n", coneptsum);
- }
-
- GetIsolationCut()->SetPtThresholdMax(10000.);
-
- } // SS histo fill
+ if (nMaxima==1) { fhELambda0LocMax1[isolated]->Fill(energy,m02); fhELambda1LocMax1[isolated]->Fill(energy,m02); }
+ else if(nMaxima==2) { fhELambda0LocMax2[isolated]->Fill(energy,m02); fhELambda1LocMax2[isolated]->Fill(energy,m02); }
+ else { fhELambda0LocMaxN[isolated]->Fill(energy,m02); fhELambda1LocMaxN[isolated]->Fill(energy,m02); }
+ }
+ } // SS histo fill
+
+ if(fFillTMHisto)
+ {
+ Float_t dZ = cluster->GetTrackDz();
+ Float_t dR = cluster->GetTrackDx();
+
+ if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
+ {
+ dR = 2000., dZ = 2000.;
+ GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
+ }
+
+ //printf("ParticleIsolation: dPhi %f, dEta %f\n",dR,dZ);
+ if(fhTrackMatchedDEta[isolated] && TMath::Abs(dR) < 999)
+ {
+ fhTrackMatchedDEta[isolated]->Fill(energy,dZ);
+ fhTrackMatchedDPhi[isolated]->Fill(energy,dR);
+ if(energy > 0.5) fhTrackMatchedDEtaDPhi[isolated]->Fill(dZ,dR);
+ }
+ // Check dEdx and E/p of matched clusters
- if(fFillTMHisto)
+ if(TMath::Abs(dZ) < 0.05 && TMath::Abs(dR) < 0.05)
{
- Float_t dZ = cluster->GetTrackDz();
- Float_t dR = cluster->GetTrackDx();
- if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
- {
- dR = 2000., dZ = 2000.;
- GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
- }
+ AliVTrack *track = GetCaloUtils()->GetMatchedTrack(cluster, GetReader()->GetInputEvent());
- //printf("ParticleIsolation: dPhi %f, dEta %f\n",dR,dZ);
- if(fhTrackMatchedDEta[isolated] && TMath::Abs(dR) < 999)
+ if(track)
{
- fhTrackMatchedDEta[isolated]->Fill(energy,dZ);
- fhTrackMatchedDPhi[isolated]->Fill(energy,dR);
- if(energy > 0.5) fhTrackMatchedDEtaDPhi[isolated]->Fill(dZ,dR);
+ Float_t dEdx = track->GetTPCsignal();
+ fhdEdx[isolated]->Fill(cluster->E(), dEdx);
+
+ Float_t eOverp = cluster->E()/track->P();
+ fhEOverP[isolated]->Fill(cluster->E(), eOverp);
}
+ //else
+ // printf("AliAnaParticleIsolation::FillTrackMatchingShowerShapeHistograms() - Residual OK but (dR, dZ)= (%2.4f,%2.4f) no track associated WHAT? \n", dR,dZ);
- // Check dEdx and E/p of matched clusters
- if(TMath::Abs(dZ) < 0.05 && TMath::Abs(dR) < 0.05)
+ if(IsDataMC())
{
-
- AliVTrack *track = GetCaloUtils()->GetMatchedTrack(cluster, GetReader()->GetInputEvent());
-
- if(track)
+ if ( !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) )
{
- Float_t dEdx = track->GetTPCsignal();
- fhdEdx[isolated]->Fill(cluster->E(), dEdx);
+ if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ||
+ GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 2.5 );
+ else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 0.5 );
+ else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 1.5 );
+ else fhTrackMatchedMCParticle[isolated]->Fill(energy, 3.5 );
- Float_t eOverp = cluster->E()/track->P();
- fhEOverP[isolated]->Fill(cluster->E(), eOverp);
}
- //else
- // printf("AliAnaParticleIsolation::FillTrackMatchingShowerShapeHistograms() - Residual OK but (dR, dZ)= (%2.4f,%2.4f) no track associated WHAT? \n", dR,dZ);
-
-
- if(IsDataMC())
+ else
{
- if ( !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) )
- {
- if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ||
- GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 2.5 );
- else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 0.5 );
- else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 1.5 );
- else fhTrackMatchedMCParticle[isolated]->Fill(energy, 3.5 );
-
- }
- else
- {
- if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ||
- GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 6.5 );
- else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 4.5 );
- else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 5.5 );
- else fhTrackMatchedMCParticle[isolated]->Fill(energy, 7.5 );
- }
-
- } // MC
-
- } // match window
+ if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ||
+ GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 6.5 );
+ else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 4.5 );
+ else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 5.5 );
+ else fhTrackMatchedMCParticle[isolated]->Fill(energy, 7.5 );
+ }
+ } // MC
- }// TM histos fill
+ } // match window
- } // clusters array available
+ }// TM histos fill
}
//______________________________________________________
TObjString * AliAnaParticleIsolation::GetAnalysisCuts()
-{
+{
//Save parameters used for analysis
TString parList ; //this will be list of parameters used for this analysis.
const Int_t buffersize = 255;
char onePar[buffersize] ;
snprintf(onePar, buffersize,"--- AliAnaParticleIsolation ---\n") ;
- parList+=onePar ;
+ parList+=onePar ;
snprintf(onePar, buffersize,"Calorimeter: %s\n",fCalorimeter.Data()) ;
parList+=onePar ;
+ snprintf(onePar, buffersize,"Isolation Cand Detector: %s\n",fIsoDetector.Data()) ;
+ parList+=onePar ;
snprintf(onePar, buffersize,"fReMakeIC =%d (Flag for reisolation during histogram filling) \n",fReMakeIC) ;
parList+=onePar ;
snprintf(onePar, buffersize,"fMakeSeveralIC=%d (Flag for isolation with several cuts at the same time ) \n",fMakeSeveralIC) ;
- parList+=onePar ;
+ parList+=onePar ;
snprintf(onePar, buffersize,"fFillTMHisto=%d (Flag for track matching histograms) \n",fFillTMHisto) ;
parList+=onePar ;
snprintf(onePar, buffersize,"fFillSSHisto=%d (Flag for shower shape histograms) \n",fFillSSHisto) ;
for(Int_t icone = 0; icone < fNCones ; icone++)
{
snprintf(onePar, buffersize,"fConeSizes[%d]=%1.2f (isolation cone size) \n",icone, fConeSizes[icone]) ;
- parList+=onePar ;
+ parList+=onePar ;
}
for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
{
snprintf(onePar, buffersize,"fPtThresholds[%d]=%1.2f (isolation pt threshold) \n",ipt, fPtThresholds[ipt]) ;
- parList+=onePar ;
+ parList+=onePar ;
}
for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
{
snprintf(onePar, buffersize,"fPtFractions[%d]=%1.2f (isolation pt fraction threshold) \n",ipt, fPtFractions[ipt]) ;
- parList+=onePar ;
+ parList+=onePar ;
}
for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
{
snprintf(onePar, buffersize,"fSumPtThresholds[%d]=%1.2f (isolation sum pt threshold) \n",ipt, fSumPtThresholds[ipt]) ;
- parList+=onePar ;
- }
+ parList+=onePar ;
+ }
}
//Get parameters set in base class.
//________________________________________________________
TList * AliAnaParticleIsolation::GetCreateOutputObjects()
-{
- // Create histograms to be saved in output file and
+{
+ // Create histograms to be saved in output file and
// store them in outputContainer
- TList * outputContainer = new TList() ;
- outputContainer->SetName("IsolatedParticleHistos") ;
+ TList * outputContainer = new TList() ;
+ outputContainer->SetName("IsolatedParticleHistos") ;
Int_t nptbins = GetHistogramRanges()->GetHistoPtBins();
Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins();
Float_t etamax = GetHistogramRanges()->GetHistoEtaMax();
Float_t ptmin = GetHistogramRanges()->GetHistoPtMin();
Float_t phimin = GetHistogramRanges()->GetHistoPhiMin();
- Float_t etamin = GetHistogramRanges()->GetHistoEtaMin();
- Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins();
- Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax();
+ Float_t etamin = GetHistogramRanges()->GetHistoEtaMin();
+ Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins();
+ Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax();
Float_t ssmin = GetHistogramRanges()->GetHistoShowerShapeMin();
- Int_t ntimebins= GetHistogramRanges()->GetHistoTimeBins();
- Float_t timemax = GetHistogramRanges()->GetHistoTimeMax();
- Float_t timemin = GetHistogramRanges()->GetHistoTimeMin();
-
- Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
- Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
+ Int_t ntimebins= GetHistogramRanges()->GetHistoTimeBins();
+ Float_t timemax = GetHistogramRanges()->GetHistoTimeMax();
+ Float_t timemin = GetHistogramRanges()->GetHistoTimeMin();
+
+ Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
+ Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
Float_t resetamin = GetHistogramRanges()->GetHistoTrackResidualEtaMin();
- Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
- Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
- Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
+ Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
+ Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
+ Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
- Int_t ndedxbins = GetHistogramRanges()->GetHistodEdxBins();
- Float_t dedxmax = GetHistogramRanges()->GetHistodEdxMax();
+ Int_t ndedxbins = GetHistogramRanges()->GetHistodEdxBins();
+ Float_t dedxmax = GetHistogramRanges()->GetHistodEdxMax();
Float_t dedxmin = GetHistogramRanges()->GetHistodEdxMin();
- Int_t nPoverEbins = GetHistogramRanges()->GetHistoPOverEBins();
- Float_t pOverEmax = GetHistogramRanges()->GetHistoPOverEMax();
+ Int_t nPoverEbins = GetHistogramRanges()->GetHistoPOverEBins();
+ Float_t pOverEmax = GetHistogramRanges()->GetHistoPOverEMax();
Float_t pOverEmin = GetHistogramRanges()->GetHistoPOverEMin();
- Int_t nptsumbins = fHistoNPtSumBins;
- Float_t ptsummax = fHistoPtSumMax;
- Float_t ptsummin = fHistoPtSumMin;
- Int_t nptinconebins = fHistoNPtInConeBins;
- Float_t ptinconemax = fHistoPtInConeMax;
- Float_t ptinconemin = fHistoPtInConeMin;
+ Int_t nptsumbins = GetHistogramRanges()->GetHistoNPtSumBins();
+ Float_t ptsummax = GetHistogramRanges()->GetHistoPtSumMax();
+ Float_t ptsummin = GetHistogramRanges()->GetHistoPtSumMin();
+ Int_t nptinconebins = GetHistogramRanges()->GetHistoNPtInConeBins();
+ Float_t ptinconemax = GetHistogramRanges()->GetHistoPtInConeMax();
+ Float_t ptinconemin = GetHistogramRanges()->GetHistoPtInConeMin();
+
+ //Float_t ptthre = GetIsolationCut()->GetPtThreshold();
+ //Float_t ptsumthre = GetIsolationCut()->GetSumPtThreshold();
+ //Float_t ptfrac = GetIsolationCut()->GetPtFraction();
+ Float_t r = GetIsolationCut()->GetConeSize();
+ Int_t method = GetIsolationCut()->GetICMethod() ;
+ Int_t particle = GetIsolationCut()->GetParticleTypeInCone() ;
+
+ TString sThreshold = "";
+ if ( method == AliIsolationCut::kSumPtIC )
+ {
+ sThreshold = Form(", %2.2f < #Sigma #it{p}_{T}^{in cone} < %2.2f GeV/#it{c}",
+ GetIsolationCut()->GetSumPtThreshold(), GetIsolationCut()->GetSumPtThresholdMax());
+ if(GetIsolationCut()->GetSumPtThresholdMax() > 200)
+ sThreshold = Form(", #Sigma #it{p}_{T}^{in cone} = %2.2f GeV/#it{c}",
+ GetIsolationCut()->GetSumPtThreshold());
+ }
+ else if ( method == AliIsolationCut::kPtThresIC)
+ {
+ sThreshold = Form(", %2.2f < #it{p}_{T}^{th} < %2.2f GeV/#it{c}",
+ GetIsolationCut()->GetPtThreshold(),GetIsolationCut()->GetPtThresholdMax());
+ if(GetIsolationCut()->GetSumPtThreshold() > 200)
+ sThreshold = Form(", #it{p}_{T}^{th} = %2.2f GeV/#it{c}",
+ GetIsolationCut()->GetPtThreshold());
+ }
+ else if ( method == AliIsolationCut::kPtFracIC)
+ sThreshold = Form(", #Sigma #it{p}_{T}^{in cone}/#it{p}_{T}^{trig} = %2.2f" ,
+ GetIsolationCut()->GetPtFraction());
- Float_t ptthre = GetIsolationCut()->GetPtThreshold();
- Float_t ptfrac = GetIsolationCut()->GetPtFraction();
- Float_t r = GetIsolationCut()->GetConeSize();
+ TString sParticle = ", x^{0,#pm}";
+ if ( particle == AliIsolationCut::kOnlyNeutral ) sParticle = ", x^{0}";
+ else if ( particle == AliIsolationCut::kOnlyCharged ) sParticle = ", x^{#pm}";
+
+ TString parTitle = Form("#it{R} = %2.2f%s%s",GetIsolationCut()->GetConeSize(), sThreshold.Data(),sParticle.Data());
TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
+ // MC histograms title and name
+ TString mcPartType[] = { "#gamma", "#gamma_{prompt}", "#gamma_{fragmentation}",
+ "#pi^{0} (merged #gamma)","#gamma_{#pi decay}",
+ "#gamma_{#eta decay}","#gamma_{other decay}",
+ "e^{#pm}","hadrons?"} ;
+
+ TString mcPartName[] = { "Photon","PhotonPrompt","PhotonFrag",
+ "Pi0","Pi0Decay","EtaDecay","OtherDecay",
+ "Electron","Hadron"} ;
+
+ // Primary MC histograms title and name
+ TString pptype[] = { "#gamma", "#gamma_{#pi decay}","#gamma_{other decay}",
+ "#gamma_{prompt}","#gamma_{fragmentation}","#gamma_{ISR}"} ;
+
+ TString ppname[] = { "Photon","PhotonPi0Decay","PhotonOtherDecay",
+ "PhotonPrompt","PhotonFrag","PhotonISR"} ;
+
+ // Not Isolated histograms, reference histograms
+
+ fhENoIso = new TH1F("hENoIso",
+ Form("Number of not isolated leading particles vs #it{p}_{T}, %s",parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhENoIso->SetYTitle("#it{counts}");
+ fhENoIso->SetXTitle("E (GeV/#it{c})");
+ outputContainer->Add(fhENoIso) ;
+
+ fhPtNoIso = new TH1F("hPtNoIso",
+ Form("Number of not isolated leading particles vs #it{p}_{T}, %s",parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhPtNoIso->SetYTitle("#it{counts}");
+ fhPtNoIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtNoIso) ;
+
+ fhEtaPhiNoIso = new TH2F("hEtaPhiNoIso",
+ Form("Number of not isolated leading particles #eta vs #phi, %s",parTitle.Data()),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhEtaPhiNoIso->SetXTitle("#eta");
+ fhEtaPhiNoIso->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiNoIso) ;
+
+ if(IsDataMC())
+ {
+ // For histograms in arrays, index in the array, corresponding to any particle origin
+
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+
+ fhPtNoIsoMC[imc] = new TH1F(Form("hPtNoIsoMC%s",mcPartName[imc].Data()),
+ Form("#it{p}_{T} of NOT isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhPtNoIsoMC[imc]->SetYTitle("#it{counts}");
+ fhPtNoIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPtNoIsoMC[imc]) ;
+
+ fhPtIsoMC[imc] = new TH1F(Form("hPtMC%s",mcPartName[imc].Data()),
+ Form("#it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhPtIsoMC[imc]->SetYTitle("#it{counts}");
+ fhPtIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPtIsoMC[imc]) ;
+
+ fhPhiIsoMC[imc] = new TH2F(Form("hPhiMC%s",mcPartName[imc].Data()),
+ Form("#phi vs #it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax,nphibins,phimin,phimax);
+ fhPhiIsoMC[imc]->SetYTitle("#phi");
+ fhPhiIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPhiIsoMC[imc]) ;
+
+ fhEtaIsoMC[imc] = new TH2F(Form("hEtaMC%s",mcPartName[imc].Data()),
+ Form("#phi vs #it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax,netabins,etamin,etamax);
+ fhEtaIsoMC[imc]->SetYTitle("#eta");
+ fhEtaIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhEtaIsoMC[imc]) ;
+ }
+ }
+
+ // Histograms for tagged candidates as decay
+ if(fFillTaggedDecayHistograms)
+ {
+ for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
+ {
+ fhPtDecayNoIso[ibit] =
+ new TH1F(Form("hPtDecayNoIso_bit%d",fDecayBits[ibit]),
+ Form("Number of not isolated leading pi0 decay particles vs #it{p}_{T}, bit %d, %s",fDecayBits[ibit],parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhPtDecayNoIso[ibit]->SetYTitle("#it{counts}");
+ fhPtDecayNoIso[ibit]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtDecayNoIso[ibit]) ;
+
+ fhEtaPhiDecayNoIso[ibit] =
+ new TH2F(Form("hEtaPhiDecayNoIso_bit%d",fDecayBits[ibit]),
+ Form("Number of not isolated leading Pi0 decay particles #eta vs #phi, bit %d, %s",fDecayBits[ibit],parTitle.Data()),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhEtaPhiDecayNoIso[ibit]->SetXTitle("#eta");
+ fhEtaPhiDecayNoIso[ibit]->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiDecayNoIso[ibit]) ;
+
+ if(!fMakeSeveralIC)
+ {
+ fhPtDecayIso[ibit] =
+ new TH1F(Form("hPtDecayIso_bit%d",fDecayBits[ibit]),
+ Form("Number of isolated #pi^{0} decay particles vs #it{p}_{T}, bit %d, %s",fDecayBits[ibit],parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhPtDecayIso[ibit]->SetYTitle("#it{counts}");
+ fhPtDecayIso[ibit]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPtDecayIso[ibit]) ;
+
+ fhEtaPhiDecayIso[ibit] =
+ new TH2F(Form("hEtaPhiDecayIso_bit%d",fDecayBits[ibit]),
+ Form("Number of isolated Pi0 decay particles #eta vs #phi, bit %d, %s",fDecayBits[ibit],parTitle.Data()),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhEtaPhiDecayIso[ibit]->SetXTitle("#eta");
+ fhEtaPhiDecayIso[ibit]->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiDecayIso[ibit]) ;
+ }
+
+ if(IsDataMC())
+ {
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+
+ fhPtDecayNoIsoMC[ibit][imc] =
+ new TH1F(Form("hPtDecayNoIso_bit%d_MC%s",fDecayBits[ibit],mcPartName[imc].Data()),
+ Form("#it{p}_{T} of NOT isolated, decay bit %d, %s, %s",fDecayBits[ibit],mcPartType[imc].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhPtDecayNoIsoMC[ibit][imc]->SetYTitle("#it{counts}");
+ fhPtDecayNoIsoMC[ibit][imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPtDecayNoIsoMC[ibit][imc]) ;
+
+ if(!fMakeSeveralIC)
+ {
+ fhPtDecayIsoMC[ibit][imc] =
+ new TH1F(Form("hPtDecay_bit%d_MC%s",fDecayBits[ibit],mcPartName[imc].Data()),
+ Form("#it{p}_{T} of isolated %s, decay bit %d, %s",mcPartType[imc].Data(),fDecayBits[ibit],parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhPtDecayIsoMC[ibit][imc]->SetYTitle("#it{counts}");
+ fhPtDecayIsoMC[ibit][imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPtDecayIsoMC[ibit][imc]) ;
+ }
+ }// MC particle loop
+ }// MC
+ } // bit loop
+ }// decay
+
if(!fMakeSeveralIC)
{
- TString hName [] = {"NoIso",""};
- TString hTitle[] = {"Not isolated" ,"isolated"};
+ TString isoName [] = {"NoIso",""};
+ TString isoTitle[] = {"Not isolated" ,"isolated"};
fhEIso = new TH1F("hE",
- Form("Number of isolated particles vs E for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
+ Form("Number of isolated particles vs E, %s",parTitle.Data()),
nptbins,ptmin,ptmax);
- fhEIso->SetYTitle("dN / dE");
- fhEIso->SetXTitle("E (GeV/c)");
+ fhEIso->SetYTitle("d#it{N} / d#it{E}");
+ fhEIso->SetXTitle("#it{E} (GeV/#it{c})");
outputContainer->Add(fhEIso) ;
fhPtIso = new TH1F("hPt",
- Form("Number of isolated particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
+ Form("Number of isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
nptbins,ptmin,ptmax);
- fhPtIso->SetYTitle("dN / p_{T}");
- fhPtIso->SetXTitle("p_{T} (GeV/c)");
+ fhPtIso->SetYTitle("d#it{N} / #it{p}_{T}");
+ fhPtIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtIso) ;
- fhPtCentralityIso = new TH2F("hPtCentrality","centrality vs p_{T} for isolated particles",nptbins,ptmin,ptmax, 100,0,100);
- fhPtCentralityIso->SetYTitle("centrality");
- fhPtCentralityIso->SetXTitle("p_{T}(GeV/c)");
- outputContainer->Add(fhPtCentralityIso) ;
-
- fhPtEventPlaneIso = new TH2F("hPtEventPlane","event plane angle vs p_{T} for isolated particles",nptbins,ptmin,ptmax, 100,0,TMath::Pi());
- fhPtEventPlaneIso->SetYTitle("Event plane angle (rad)");
- fhPtEventPlaneIso->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtEventPlaneIso) ;
-
-
- fhPtNLocMaxIso = new TH2F("hPtNLocMax",
- Form("Number of isolated particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f vs NLM, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- nptbins,ptmin,ptmax,10,0,10);
- fhPtNLocMaxIso->SetYTitle("NLM");
- fhPtNLocMaxIso->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNLocMaxIso) ;
-
fhPhiIso = new TH2F("hPhi",
- Form("Number of isolated particles vs #phi for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
+ Form("Number of isolated particles vs #phi, %s",parTitle.Data()),
nptbins,ptmin,ptmax,nphibins,phimin,phimax);
fhPhiIso->SetYTitle("#phi");
- fhPhiIso->SetXTitle("p_{T} (GeV/c)");
+ fhPhiIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPhiIso) ;
fhEtaIso = new TH2F("hEta",
- Form("Number of isolated particles vs #eta for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
+ Form("Number of isolated particles vs #eta, %s",parTitle.Data()),
nptbins,ptmin,ptmax,netabins,etamin,etamax);
fhEtaIso->SetYTitle("#eta");
- fhEtaIso->SetXTitle("p_{T} (GeV/c)");
+ fhEtaIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhEtaIso) ;
fhEtaPhiIso = new TH2F("hEtaPhiIso",
- Form("Number of isolated particles #eta vs #phi for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
+ Form("Number of isolated particles #eta vs #phi, %s",parTitle.Data()),
netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiIso->SetXTitle("#eta");
fhEtaPhiIso->SetYTitle("#phi");
outputContainer->Add(fhEtaPhiIso) ;
- fhPtDecayIso = new TH1F("hPtDecayIso",
- Form("Number of isolated #pi^{0} decay particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- nptbins,ptmin,ptmax);
- fhPtDecayIso->SetYTitle("N");
- fhPtDecayIso->SetXTitle("p_{T}(GeV/c)");
- outputContainer->Add(fhPtDecayIso) ;
+ if(fFillHighMultHistograms)
+ {
+ fhPtCentralityIso = new TH2F("hPtCentrality",
+ Form("centrality vs #it{p}_{T} for isolated particles, %s",parTitle.Data()),
+ nptbins,ptmin,ptmax, 100,0,100);
+ fhPtCentralityIso->SetYTitle("centrality");
+ fhPtCentralityIso->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPtCentralityIso) ;
+
+ fhPtEventPlaneIso = new TH2F("hPtEventPlane",
+ Form("event plane angle vs #it{p}_{T} for isolated particles, %s",parTitle.Data()),
+ nptbins,ptmin,ptmax, 100,0,TMath::Pi());
+ fhPtEventPlaneIso->SetYTitle("Event plane angle (rad)");
+ fhPtEventPlaneIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtEventPlaneIso) ;
+ }
- fhEtaPhiDecayIso = new TH2F("hEtaPhiDecayIso",
- Form("Number of isolated Pi0 decay particles #eta vs #phi for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhEtaPhiDecayIso->SetXTitle("#eta");
- fhEtaPhiDecayIso->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiDecayIso) ;
+ if(fFillNLMHistograms)
+ {
+ fhPtNLocMaxIso = new TH2F("hPtNLocMax",
+ Form("Number of isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
+ nptbins,ptmin,ptmax,10,0,10);
+ fhPtNLocMaxIso->SetYTitle("#it{NLM}");
+ fhPtNLocMaxIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+
+ fhPtNLocMaxNoIso = new TH2F("hPtNLocMaxNoIso",
+ Form("Number of not isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
+ nptbins,ptmin,ptmax,10,0,10);
+ fhPtNLocMaxNoIso->SetYTitle("#it{NLM}");
+ fhPtNLocMaxNoIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtNLocMaxNoIso) ;
+ }
+
+ fhConePtLead = new TH2F("hConePtLead",
+ Form("Track or Cluster leading #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhConePtLead->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
+ fhConePtLead->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConePtLead) ;
fhConeSumPt = new TH2F("hConePtSum",
- Form("Track and Cluster #Sigma p_{T} in isolation cone for R = %2.2f",r),
+ Form("Track and Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPt->SetYTitle("#Sigma p_{T}");
- fhConeSumPt->SetXTitle("p_{T, trigger} (GeV/c)");
+ fhConeSumPt->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPt->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
outputContainer->Add(fhConeSumPt) ;
fhConeSumPtTrigEtaPhi = new TH2F("hConePtSumTrigEtaPhi",
- Form("Trigger #eta vs #phi, #Sigma p_{T} in isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtTrigEtaPhi->SetZTitle("#Sigma p_{T}");
+ Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
fhConeSumPtTrigEtaPhi->SetXTitle("#eta_{trigger}");
fhConeSumPtTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
outputContainer->Add(fhConeSumPtTrigEtaPhi) ;
fhPtInCone = new TH2F("hPtInCone",
- Form("p_{T} of clusters and tracks in isolation cone for R = %2.2f",r),
+ Form("#it{p}_{T} of clusters and tracks in isolation cone for #it{R} = %2.2f",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtInCone->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtInCone->SetXTitle("p_{T} (GeV/c)");
+ fhPtInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtInCone) ;
- fhPtInConeCent = new TH2F("hPtInConeCent",
- Form("p_{T} in isolation cone for R = %2.2f",r),
- 100,0,100,nptinconebins,ptinconemin,ptinconemax);
- fhPtInConeCent->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtInConeCent->SetXTitle("centrality");
- outputContainer->Add(fhPtInConeCent) ;
+ if(fFillBackgroundBinHistograms)
+ {
+ fhPtLeadConeBinLambda0 = new TH2F*[fNBkgBin];
+ fhSumPtConeBinLambda0 = new TH2F*[fNBkgBin];
+
+ if(IsDataMC())
+ {
+ fhPtLeadConeBinLambda0MC = new TH2F*[fNBkgBin*9];
+ fhSumPtConeBinLambda0MC = new TH2F*[fNBkgBin*9];
+ }
+
+ for(Int_t ibin = 0; ibin < fNBkgBin; ibin++)
+ {
+ fhPtLeadConeBinLambda0[ibin] = new TH2F
+ (Form("hPtLeadConeLambda0_Bin%d",ibin),
+ Form("#lambda_{0}, in cone %2.2f<#it{p}_{T}^{leading}<%2.2f (GeV/#it{c}), %s",
+ fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhPtLeadConeBinLambda0[ibin]->SetYTitle("#lambda_{0}^{2}");
+ fhPtLeadConeBinLambda0[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtLeadConeBinLambda0[ibin]) ;
+
+ fhSumPtConeBinLambda0[ibin] = new TH2F
+ (Form("hSumPtConeLambda0_Bin%d",ibin),
+ Form("#lambda_{0}, in cone %2.2f <#Sigma #it{p}_{T}< %2.2f (GeV/#it{c}), %s",
+ fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhSumPtConeBinLambda0[ibin]->SetYTitle("#lambda_{0}^{2}");
+ fhSumPtConeBinLambda0[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhSumPtConeBinLambda0[ibin]) ;
+
+ if(IsDataMC())
+ {
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+ Int_t binmc = ibin+imc*fNBkgBin;
+ fhPtLeadConeBinLambda0MC[binmc] = new TH2F
+ (Form("hPtLeadConeLambda0_Bin%d_MC%s",ibin, mcPartName[imc].Data()),
+ Form("#lambda_{0}, in cone %2.2f<#it{p}_{T}^{leading}<%2.2f (GeV/#it{c}), MC %s, %s",
+ fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhPtLeadConeBinLambda0MC[binmc]->SetYTitle("#lambda_{0}^{2}");
+ fhPtLeadConeBinLambda0MC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtLeadConeBinLambda0MC[binmc]) ;
+
+ fhSumPtConeBinLambda0MC[binmc] = new TH2F
+ (Form("hSumPtConeLambda0_Bin%d_MC%s",ibin,mcPartName[imc].Data()),
+ Form("#lambda_{0}, in cone %2.2f <#Sigma #it{p}_{T}< %2.2f (GeV/#it{c}), MC %s, %s",
+ fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhSumPtConeBinLambda0MC[binmc]->SetYTitle("#lambda_{0}^{2}");
+ fhSumPtConeBinLambda0MC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhSumPtConeBinLambda0MC[binmc]) ;
+ } // MC particle loop
+ }
+
+ }// pt bin loop
+ } // bkg cone pt bin histograms
+
+ if(fFillHighMultHistograms)
+ {
+ fhPtInConeCent = new TH2F("hPtInConeCent",
+ Form("#it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
+ 100,0,100,nptinconebins,ptinconemin,ptinconemax);
+ fhPtInConeCent->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtInConeCent->SetXTitle("centrality");
+ outputContainer->Add(fhPtInConeCent) ;
+ }
// Cluster only histograms
if(GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyCharged)
{
fhConeSumPtCluster = new TH2F("hConePtSumCluster",
- Form("Cluster #Sigma p_{T} in isolation cone for R = %2.2f",r),
+ Form("Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtCluster->SetYTitle("#Sigma p_{T}");
- fhConeSumPtCluster->SetXTitle("p_{T, trigger} (GeV/c)");
+ fhConeSumPtCluster->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtCluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
outputContainer->Add(fhConeSumPtCluster) ;
- fhConeSumPtCell = new TH2F("hConePtSumCell",
- Form("Cell #Sigma p_{T} in isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtCell->SetYTitle("#Sigma p_{T}");
- fhConeSumPtCell->SetXTitle("p_{T, trigger} (GeV/c)");
- outputContainer->Add(fhConeSumPtCell) ;
-
- fhConeSumPtEtaBandUECluster = new TH2F("hConePtSumEtaBandUECluster",
- "#Sigma cluster p_{T} in UE Eta Band",
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtEtaBandUECluster->SetYTitle("#Sigma p_{T}");
- fhConeSumPtEtaBandUECluster->SetXTitle("p_{T, trigger} (GeV/c)");
- outputContainer->Add(fhConeSumPtEtaBandUECluster) ;
-
- fhConeSumPtPhiBandUECluster = new TH2F("hConePtSumPhiBandUECluster",
- "#Sigma cluster p_{T} UE Phi Band",
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtPhiBandUECluster->SetYTitle("#Sigma p_{T}");
- fhConeSumPtPhiBandUECluster->SetXTitle("p_{T, trigger} (GeV/c)");
- outputContainer->Add(fhConeSumPtPhiBandUECluster) ;
+ fhConePtLeadCluster = new TH2F("hConeLeadPtCluster",
+ Form("Cluster leading in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhConePtLeadCluster->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
+ fhConePtLeadCluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConePtLeadCluster) ;
+
- fhConeSumPtEtaBandUEClusterTrigEtaPhi = new TH2F("hConePtSumEtaBandUEClusterTrigEtaPhi",
- "Trigger #eta vs #phi, #Sigma cluster p_{T} in UE Eta Band",
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtEtaBandUEClusterTrigEtaPhi) ;
+ if(fFillCellHistograms)
+ {
+ fhConeSumPtCell = new TH2F("hConePtSumCell",
+ Form("Cell #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhConeSumPtCell->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtCell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtCell) ;
+ }
- fhConeSumPtPhiBandUEClusterTrigEtaPhi = new TH2F("hConePtSumPhiBandUEClusterTrigEtaPhi",
- "Trigger #eta vs #phi, #Sigma cluster p_{T} UE Phi Band",
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtPhiBandUEClusterTrigEtaPhi) ;
-
-
- fhConeSumPtEtaBandUECell = new TH2F("hConePtSumEtaBandUECell",
- "#Sigma cell p_{T} in UE Eta Band",
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtEtaBandUECell->SetYTitle("#Sigma p_{T}");
- fhConeSumPtEtaBandUECell->SetXTitle("p_{T, trigger} (GeV/c)");
- outputContainer->Add(fhConeSumPtEtaBandUECell) ;
-
- fhConeSumPtPhiBandUECell = new TH2F("hConePtSumPhiBandUECell",
- "#Sigma cell p_{T} UE Phi Band",
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtPhiBandUECell->SetYTitle("#Sigma p_{T}");
- fhConeSumPtPhiBandUECell->SetXTitle("p_{T, trigger} (GeV/c)");
- outputContainer->Add(fhConeSumPtPhiBandUECell) ;
-
- fhConeSumPtEtaBandUECellTrigEtaPhi = new TH2F("hConePtSumEtaBandUECellTrigEtaPhi",
- "Trigger #eta vs #phi, #Sigma cell p_{T} in UE Eta Band",
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtEtaBandUECellTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtEtaBandUECellTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtEtaBandUECellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtEtaBandUECellTrigEtaPhi) ;
-
- fhConeSumPtPhiBandUECellTrigEtaPhi = new TH2F("hConePtSumPhiBandUECellTrigEtaPhi",
- "Trigger #eta vs #phi, #Sigma cell p_{T} UE Phi Band",
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtPhiBandUECellTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtPhiBandUECellTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtPhiBandUECellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtPhiBandUECellTrigEtaPhi) ;
-
+ if(fFillUEBandSubtractHistograms)
+ {
+ fhConeSumPtEtaBandUECluster = new TH2F("hConePtSumEtaBandUECluster",
+ "#Sigma cluster #it{p}_{T} in UE Eta Band",
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhConeSumPtEtaBandUECluster->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaBandUECluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtEtaBandUECluster) ;
+
+ fhConeSumPtPhiBandUECluster = new TH2F("hConePtSumPhiBandUECluster",
+ "#Sigma cluster #it{p}_{T} UE Phi Band",
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhConeSumPtPhiBandUECluster->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiBandUECluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtPhiBandUECluster) ;
+
+ fhConeSumPtEtaBandUEClusterTrigEtaPhi = new TH2F("hConePtSumEtaBandUEClusterTrigEtaPhi",
+ "Trigger #eta vs #phi, #Sigma cluster #it{p}_{T} in UE Eta Band",
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtEtaBandUEClusterTrigEtaPhi) ;
+
+ fhConeSumPtPhiBandUEClusterTrigEtaPhi = new TH2F("hConePtSumPhiBandUEClusterTrigEtaPhi",
+ "Trigger #eta vs #phi, #Sigma cluster #it{p}_{T} UE Phi Band",
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtPhiBandUEClusterTrigEtaPhi) ;
+ if(fFillCellHistograms)
+ {
+
+ fhConeSumPtEtaBandUECell = new TH2F("hConePtSumEtaBandUECell",
+ "#Sigma cell #it{p}_{T} in UE Eta Band",
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhConeSumPtEtaBandUECell->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaBandUECell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtEtaBandUECell) ;
+
+ fhConeSumPtPhiBandUECell = new TH2F("hConePtSumPhiBandUECell",
+ "#Sigma cell #it{p}_{T} UE Phi Band",
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhConeSumPtPhiBandUECell->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiBandUECell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtPhiBandUECell) ;
+
+ fhConeSumPtEtaBandUECellTrigEtaPhi = new TH2F("hConePtSumEtaBandUECellTrigEtaPhi",
+ "Trigger #eta vs #phi, #Sigma cell #it{p}_{T} in UE Eta Band",
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtEtaBandUECellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaBandUECellTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtEtaBandUECellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtEtaBandUECellTrigEtaPhi) ;
+
+ fhConeSumPtPhiBandUECellTrigEtaPhi = new TH2F("hConePtSumPhiBandUECellTrigEtaPhi",
+ "Trigger #eta vs #phi, #Sigma cell #it{p}_{T} UE Phi Band",
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtPhiBandUECellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiBandUECellTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtPhiBandUECellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtPhiBandUECellTrigEtaPhi) ;
+ }
+
+ fhEtaBandCluster = new TH2F("hEtaBandCluster",
+ Form("#eta vs #phi of clusters in #eta band isolation cone for #it{R} = %2.2f",r),
+ netabins,-1,1,nphibins,0,TMath::TwoPi());
+ fhEtaBandCluster->SetXTitle("#eta");
+ fhEtaBandCluster->SetYTitle("#phi");
+ outputContainer->Add(fhEtaBandCluster) ;
+
+ fhPhiBandCluster = new TH2F("hPhiBandCluster",
+ Form("#eta vs #phi of clusters in #phi band isolation cone for #it{R} = %2.2f",r),
+ netabins,-1,1,nphibins,0,TMath::TwoPi());
+ fhPhiBandCluster->SetXTitle("#eta");
+ fhPhiBandCluster->SetYTitle("#phi");
+ outputContainer->Add(fhPhiBandCluster) ;
+
+ fhEtaPhiInConeCluster= new TH2F("hEtaPhiInConeCluster",
+ Form("#eta vs #phi of clusters in cone for #it{R} = %2.2f",r),
+ netabins,-1,1,nphibins,0,TMath::TwoPi());
+ fhEtaPhiInConeCluster->SetXTitle("#eta");
+ fhEtaPhiInConeCluster->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiInConeCluster) ;
+
+ fhEtaPhiCluster= new TH2F("hEtaPhiCluster",
+ Form("#eta vs #phi of all clusters"),
+ netabins,-1,1,nphibins,0,TMath::TwoPi());
+ fhEtaPhiCluster->SetXTitle("#eta");
+ fhEtaPhiCluster->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiCluster) ;
+
+ }
fhPtClusterInCone = new TH2F("hPtClusterInCone",
- Form("p_{T} of clusters in isolation cone for R = %2.2f",r),
+ Form("#it{p}_{T} of clusters in isolation cone for #it{R} = %2.2f",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtClusterInCone->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtClusterInCone->SetXTitle("p_{T} (GeV/c)");
+ fhPtClusterInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtClusterInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtClusterInCone) ;
- fhEtaBandCluster = new TH2F("hEtaBandCluster",
- Form("#eta vs #phi of clusters in #eta band isolation cone for R = %2.2f",r),
- netabins,-1,1,nphibins,0,TMath::TwoPi());
- fhEtaBandCluster->SetXTitle("#eta");
- fhEtaBandCluster->SetYTitle("#phi");
- outputContainer->Add(fhEtaBandCluster) ;
-
- fhPhiBandCluster = new TH2F("hPhiBandCluster",
- Form("#eta vs #phi of clusters in #phi band isolation cone for R = %2.2f",r),
- netabins,-1,1,nphibins,0,TMath::TwoPi());
- fhPhiBandCluster->SetXTitle("#eta");
- fhPhiBandCluster->SetYTitle("#phi");
- outputContainer->Add(fhPhiBandCluster) ;
-
- fhEtaPhiInConeCluster= new TH2F("hEtaPhiInConeCluster",
- Form("#eta vs #phi of clusters in cone for R = %2.2f",r),
- netabins,-1,1,nphibins,0,TMath::TwoPi());
- fhEtaPhiInConeCluster->SetXTitle("#eta");
- fhEtaPhiInConeCluster->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiInConeCluster) ;
-
- fhEtaPhiCluster= new TH2F("hEtaPhiCluster",
- Form("#eta vs #phi of all clusters"),
- netabins,-1,1,nphibins,0,TMath::TwoPi());
- fhEtaPhiCluster->SetXTitle("#eta");
- fhEtaPhiCluster->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiCluster) ;
-
- fhEtaPhiInConeTrack= new TH2F("hEtaPhiInConeTrack",
- Form("#eta vs #phi of Tracks in cone for R = %2.2f",r),
- netabins,-1,1,nphibins,0,TMath::TwoPi());
- fhEtaPhiInConeTrack->SetXTitle("#eta");
- fhEtaPhiInConeTrack->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiInConeTrack) ;
-
- fhEtaPhiTrack= new TH2F("hEtaPhiTrack",
- Form("#eta vs #phi of all Tracks"),
- netabins,-1,1,nphibins,0,TMath::TwoPi());
- fhEtaPhiTrack->SetXTitle("#eta");
- fhEtaPhiTrack->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiTrack) ;
-
- fhPtCellInCone = new TH2F("hPtCellInCone",
- Form("p_{T} of cells in isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,1000,0,50);
- fhPtCellInCone->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtCellInCone->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtCellInCone) ;
-
- fhEtaBandCell = new TH2F("hEtaBandCell",
- Form("#col vs #row of cells in #eta band isolation cone for R = %2.2f",r),
- 96,0,95,128,0,127);
- fhEtaBandCell->SetXTitle("#col");
- fhEtaBandCell->SetYTitle("#row");
- outputContainer->Add(fhEtaBandCell) ;
-
- fhPhiBandCell = new TH2F("hPhiBandCell",
- Form("#col vs #row of cells in #phi band isolation cone for R = %2.2f",r),
- 96,0,95,128,0,127);
- fhPhiBandCell->SetXTitle("#col");
- fhPhiBandCell->SetYTitle("#row");
- outputContainer->Add(fhPhiBandCell) ;
-
- fhConeSumPtEtaUESubCluster = new TH2F("hConeSumPtEtaUESubCluster",
- Form("Clusters #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtEtaUESubCluster->SetYTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubCluster->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtEtaUESubCluster) ;
-
- fhConeSumPtPhiUESubCluster = new TH2F("hConeSumPtPhiUESubCluster",
- Form("Clusters #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtPhiUESubCluster->SetYTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubCluster->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtPhiUESubCluster) ;
-
- fhConeSumPtEtaUESubClusterTrigEtaPhi = new TH2F("hConeSumPtEtaUESubClusterTrigEtaPhi",
- Form("Trigger #eta vs #phi, Clusters #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtEtaUESubClusterTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtEtaUESubClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtEtaUESubClusterTrigEtaPhi) ;
-
- fhConeSumPtPhiUESubClusterTrigEtaPhi = new TH2F("hConeSumPtPhiUESubClusterTrigEtaPhi",
- Form("Trigger #eta vs #phi, Clusters #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtPhiUESubClusterTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtPhiUESubClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtPhiUESubClusterTrigEtaPhi) ;
-
-
- fhConeSumPtEtaUESubCell = new TH2F("hConeSumPtEtaUESubCell",
- Form("Cells #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtEtaUESubCell->SetYTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubCell->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtEtaUESubCell) ;
-
- fhConeSumPtPhiUESubCell = new TH2F("hConeSumPtPhiUESubCell",
- Form("Cells #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtPhiUESubCell->SetYTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubCell->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtPhiUESubCell) ;
-
- fhConeSumPtEtaUESubCellTrigEtaPhi = new TH2F("hConeSumPtEtaUESubCellTrigEtaPhi",
- Form("Trigger #eta vs #phi, Cells #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtEtaUESubCellTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtEtaUESubCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtEtaUESubCellTrigEtaPhi) ;
-
- fhConeSumPtPhiUESubCellTrigEtaPhi = new TH2F("hConeSumPtPhiUESubCellTrigEtaPhi",
- Form("Trigger #eta vs #phi, Cells #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtPhiUESubCellTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtPhiUESubCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtPhiUESubCellTrigEtaPhi) ;
-
-
- fhFractionClusterOutConeEta = new TH2F("hFractionClusterOutConeEta",
- Form("Fraction of the isolation cone R = %2.2f, out of clusters #eta acceptance",r),
- nptbins,ptmin,ptmax,100,0,1);
- fhFractionClusterOutConeEta->SetYTitle("fraction");
- fhFractionClusterOutConeEta->SetXTitle("p_{T,trigger} (GeV/c)");
- outputContainer->Add(fhFractionClusterOutConeEta) ;
+ if(fFillCellHistograms)
+ {
+ fhPtCellInCone = new TH2F("hPtCellInCone",
+ Form("#it{p}_{T} of cells in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,1000,0,50);
+ fhPtCellInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtCellInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtCellInCone) ;
+
+ fhEtaBandCell = new TH2F("hEtaBandCell",
+ Form("#col vs #row of cells in #eta band isolation cone for #it{R} = %2.2f",r),
+ 96,0,95,128,0,127);
+ fhEtaBandCell->SetXTitle("#col");
+ fhEtaBandCell->SetYTitle("#row");
+ outputContainer->Add(fhEtaBandCell) ;
+
+ fhPhiBandCell = new TH2F("hPhiBandCell",
+ Form("#col vs #row of cells in #phi band isolation cone for #it{R} = %2.2f",r),
+ 96,0,95,128,0,127);
+ fhPhiBandCell->SetXTitle("#col");
+ fhPhiBandCell->SetYTitle("#row");
+ outputContainer->Add(fhPhiBandCell) ;
+ }
- fhFractionClusterOutConeEtaTrigEtaPhi = new TH2F("hFractionClusterOutConeEtaTrigEtaPhi",
- Form("Fraction of the isolation cone R = %2.2f, out of clusters #eta acceptance, in trigger #eta-#phi ",r),
+ if(fFillUEBandSubtractHistograms)
+ {
+ fhConeSumPtEtaUESubCluster = new TH2F("hConeSumPtEtaUESubCluster",
+ Form("Clusters #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtEtaUESubCluster->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubCluster->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtEtaUESubCluster) ;
+
+ fhConeSumPtPhiUESubCluster = new TH2F("hConeSumPtPhiUESubCluster",
+ Form("Clusters #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtPhiUESubCluster->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubCluster->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtPhiUESubCluster) ;
+
+ fhConeSumPtEtaUESubClusterTrigEtaPhi = new TH2F("hConeSumPtEtaUESubClusterTrigEtaPhi",
+ Form("Trigger #eta vs #phi, Clusters #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtEtaUESubClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtEtaUESubClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtEtaUESubClusterTrigEtaPhi) ;
+
+ fhConeSumPtPhiUESubClusterTrigEtaPhi = new TH2F("hConeSumPtPhiUESubClusterTrigEtaPhi",
+ Form("Trigger #eta vs #phi, Clusters #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtPhiUESubClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtPhiUESubClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtPhiUESubClusterTrigEtaPhi) ;
+
+ if(fFillCellHistograms)
+ {
+ fhConeSumPtEtaUESubCell = new TH2F("hConeSumPtEtaUESubCell",
+ Form("Cells #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtEtaUESubCell->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtEtaUESubCell) ;
+
+ fhConeSumPtPhiUESubCell = new TH2F("hConeSumPtPhiUESubCell",
+ Form("Cells #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtPhiUESubCell->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtPhiUESubCell) ;
+
+ fhConeSumPtEtaUESubCellTrigEtaPhi = new TH2F("hConeSumPtEtaUESubCellTrigEtaPhi",
+ Form("Trigger #eta vs #phi, Cells #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
netabins,etamin,etamax,nphibins,phimin,phimax);
- fhFractionClusterOutConeEtaTrigEtaPhi->SetZTitle("fraction");
- fhFractionClusterOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhFractionClusterOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhFractionClusterOutConeEtaTrigEtaPhi) ;
-
- fhFractionClusterOutConePhi = new TH2F("hFractionClusterOutConePhi",
- Form("Fraction of the isolation cone R = %2.2f, out of clusters #phi acceptance",r),
- nptbins,ptmin,ptmax,100,0,1);
- fhFractionClusterOutConePhi->SetYTitle("fraction");
- fhFractionClusterOutConePhi->SetXTitle("p_{T,trigger} (GeV/c)");
- outputContainer->Add(fhFractionClusterOutConePhi) ;
-
- fhFractionClusterOutConePhiTrigEtaPhi = new TH2F("hFractionClusterOutConePhiTrigEtaPhi",
- Form("Fraction of the isolation cone R = %2.2f, out of clusters #phi acceptance, in trigger #eta-#phi ",r),
+ fhConeSumPtEtaUESubCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtEtaUESubCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtEtaUESubCellTrigEtaPhi) ;
+
+ fhConeSumPtPhiUESubCellTrigEtaPhi = new TH2F("hConeSumPtPhiUESubCellTrigEtaPhi",
+ Form("Trigger #eta vs #phi, Cells #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
netabins,etamin,etamax,nphibins,phimin,phimax);
- fhFractionClusterOutConePhiTrigEtaPhi->SetZTitle("fraction");
- fhFractionClusterOutConePhiTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhFractionClusterOutConePhiTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhFractionClusterOutConePhiTrigEtaPhi) ;
-
- fhConeSumPtSubvsConeSumPtTotPhiCluster = new TH2F("hConeSumPtSubvsConeSumPtTotPhiCluster",
- Form("#Sigma p_{T} in cone after bkg sub from #phi band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubvsConeSumPtTotPhiCluster->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubvsConeSumPtTotPhiCluster->SetYTitle("#Sigma p_{T, sub} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiCluster);
-
- fhConeSumPtSubNormvsConeSumPtTotPhiCluster = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiCluster",
- Form("#Sigma p_{T, norm} in cone after bkg sub from #phi band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubNormvsConeSumPtTotPhiCluster->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubNormvsConeSumPtTotPhiCluster->SetYTitle("#Sigma p_{T, sub norm} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiCluster);
-
- fhConeSumPtSubvsConeSumPtTotEtaCluster = new TH2F("hConeSumPtSubvsConeSumPtTotEtaCluster",
- Form("#Sigma p_{T} in cone after bkg sub from #eta band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubvsConeSumPtTotEtaCluster->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubvsConeSumPtTotEtaCluster->SetYTitle("#Sigma p_{T, sub} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaCluster);
-
- fhConeSumPtSubNormvsConeSumPtTotEtaCluster = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaCluster",
- Form("#Sigma p_{T, norm} in cone after bkg sub from #eta band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubNormvsConeSumPtTotEtaCluster->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubNormvsConeSumPtTotEtaCluster->SetYTitle("#Sigma p_{T, sub norm} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaCluster);
-
-
- fhFractionCellOutConeEta = new TH2F("hFractionCellOutConeEta",
- Form("Fraction of the isolation cone R = %2.2f, out of cells #eta acceptance",r),
- nptbins,ptmin,ptmax,100,0,1);
- fhFractionCellOutConeEta->SetYTitle("fraction");
- fhFractionCellOutConeEta->SetXTitle("p_{T,trigger} (GeV/c)");
- outputContainer->Add(fhFractionCellOutConeEta) ;
-
- fhFractionCellOutConeEtaTrigEtaPhi = new TH2F("hFractionCellOutConeEtaTrigEtaPhi",
- Form("Fraction of the isolation cone R = %2.2f, out of cells #eta acceptance, in trigger #eta-#phi ",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhFractionCellOutConeEtaTrigEtaPhi->SetZTitle("fraction");
- fhFractionCellOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhFractionCellOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhFractionCellOutConeEtaTrigEtaPhi) ;
-
- fhFractionCellOutConePhi = new TH2F("hFractionCellOutConePhi",
- Form("Fraction of the isolation cone R = %2.2f, out of cells #phi acceptance",r),
- nptbins,ptmin,ptmax,100,0,1);
- fhFractionCellOutConePhi->SetYTitle("fraction");
- fhFractionCellOutConePhi->SetXTitle("p_{T,trigger} (GeV/c)");
- outputContainer->Add(fhFractionCellOutConePhi) ;
-
- fhFractionCellOutConePhiTrigEtaPhi = new TH2F("hFractionCellOutConePhiTrigEtaPhi",
- Form("Fraction of the isolation cone R = %2.2f, out of cells #phi acceptance, in trigger #eta-#phi ",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhFractionCellOutConePhiTrigEtaPhi->SetZTitle("fraction");
- fhFractionCellOutConePhiTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhFractionCellOutConePhiTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhFractionCellOutConePhiTrigEtaPhi) ;
-
-
- fhConeSumPtSubvsConeSumPtTotPhiCell = new TH2F("hConeSumPtSubvsConeSumPtTotPhiCell",
- Form("#Sigma p_{T} in cone after bkg sub from #phi band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubvsConeSumPtTotPhiCell->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubvsConeSumPtTotPhiCell->SetYTitle("#Sigma p_{T, sub} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiCell);
-
- fhConeSumPtSubNormvsConeSumPtTotPhiCell = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiCell",
- Form("#Sigma p_{T, norm} in cone after bkg sub from #phi band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
+ fhConeSumPtPhiUESubCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtPhiUESubCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtPhiUESubCellTrigEtaPhi) ;
+ }
+
+ fhFractionClusterOutConeEta = new TH2F("hFractionClusterOutConeEta",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of clusters #eta acceptance",r),
+ nptbins,ptmin,ptmax,100,0,1);
+ fhFractionClusterOutConeEta->SetYTitle("#it{fraction}");
+ fhFractionClusterOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
+ outputContainer->Add(fhFractionClusterOutConeEta) ;
+
+ fhFractionClusterOutConeEtaTrigEtaPhi = new TH2F("hFractionClusterOutConeEtaTrigEtaPhi",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of clusters #eta acceptance, in trigger #eta-#phi ",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhFractionClusterOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
+ fhFractionClusterOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhFractionClusterOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhFractionClusterOutConeEtaTrigEtaPhi) ;
+
+ fhFractionClusterOutConePhi = new TH2F("hFractionClusterOutConePhi",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of clusters #phi acceptance",r),
+ nptbins,ptmin,ptmax,100,0,1);
+ fhFractionClusterOutConePhi->SetYTitle("#it{fraction}");
+ fhFractionClusterOutConePhi->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
+ outputContainer->Add(fhFractionClusterOutConePhi) ;
+
+ fhFractionClusterOutConePhiTrigEtaPhi = new TH2F("hFractionClusterOutConePhiTrigEtaPhi",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of clusters #phi acceptance, in trigger #eta-#phi ",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhFractionClusterOutConePhiTrigEtaPhi->SetZTitle("#it{fraction}");
+ fhFractionClusterOutConePhiTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhFractionClusterOutConePhiTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhFractionClusterOutConePhiTrigEtaPhi) ;
+
+ fhConeSumPtSubvsConeSumPtTotPhiCluster = new TH2F("hConeSumPtSubvsConeSumPtTotPhiCluster",
+ Form("#Sigma #it{p}_{T} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubvsConeSumPtTotPhiCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubvsConeSumPtTotPhiCluster->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiCluster);
+
+ fhConeSumPtSubNormvsConeSumPtTotPhiCluster = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiCluster",
+ Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubNormvsConeSumPtTotPhiCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubNormvsConeSumPtTotPhiCluster->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiCluster);
+
+ fhConeSumPtSubvsConeSumPtTotEtaCluster = new TH2F("hConeSumPtSubvsConeSumPtTotEtaCluster",
+ Form("#Sigma #it{p}_{T} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubvsConeSumPtTotEtaCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubvsConeSumPtTotEtaCluster->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaCluster);
+
+ fhConeSumPtSubNormvsConeSumPtTotEtaCluster = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaCluster",
+ Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubNormvsConeSumPtTotEtaCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubNormvsConeSumPtTotEtaCluster->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaCluster);
+
+ fhConeSumPtVSUEClusterEtaBand = new TH2F("hConeSumPtVSUEClusterEtaBand",
+ Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in eta band for cluster (before normalization), R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,ptsummin,2*ptsummax);
+ fhConeSumPtVSUEClusterEtaBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
+ fhConeSumPtVSUEClusterEtaBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtVSUEClusterEtaBand);
+
+ fhConeSumPtVSUEClusterPhiBand = new TH2F("hConeSumPtVSUEClusterPhiBand",
+ Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in phi band for cluster (before normalization), R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,8*nptsumbins,ptsummin,8*ptsummax);
+ fhConeSumPtVSUEClusterPhiBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
+ fhConeSumPtVSUEClusterPhiBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtVSUEClusterPhiBand);
+
+ if(fFillCellHistograms)
+ {
+ fhFractionCellOutConeEta = new TH2F("hFractionCellOutConeEta",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of cells #eta acceptance",r),
+ nptbins,ptmin,ptmax,100,0,1);
+ fhFractionCellOutConeEta->SetYTitle("#it{fraction}");
+ fhFractionCellOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
+ outputContainer->Add(fhFractionCellOutConeEta) ;
+
+ fhFractionCellOutConeEtaTrigEtaPhi = new TH2F("hFractionCellOutConeEtaTrigEtaPhi",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of cells #eta acceptance, in trigger #eta-#phi ",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhFractionCellOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
+ fhFractionCellOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhFractionCellOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhFractionCellOutConeEtaTrigEtaPhi) ;
+
+ fhFractionCellOutConePhi = new TH2F("hFractionCellOutConePhi",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of cells #phi acceptance",r),
+ nptbins,ptmin,ptmax,100,0,1);
+ fhFractionCellOutConePhi->SetYTitle("#it{fraction}");
+ fhFractionCellOutConePhi->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
+ outputContainer->Add(fhFractionCellOutConePhi) ;
+
+ fhFractionCellOutConePhiTrigEtaPhi = new TH2F("hFractionCellOutConePhiTrigEtaPhi",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of cells #phi acceptance, in trigger #eta-#phi ",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhFractionCellOutConePhiTrigEtaPhi->SetZTitle("#it{fraction}");
+ fhFractionCellOutConePhiTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhFractionCellOutConePhiTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhFractionCellOutConePhiTrigEtaPhi) ;
+
+
+ fhConeSumPtSubvsConeSumPtTotPhiCell = new TH2F("hConeSumPtSubvsConeSumPtTotPhiCell",
+ Form("#Sigma #it{p}_{T} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubNormvsConeSumPtTotPhiCell->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubNormvsConeSumPtTotPhiCell->SetYTitle("#Sigma p_{T, sub norm} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiCell);
-
- fhConeSumPtSubvsConeSumPtTotEtaCell = new TH2F("hConeSumPtSubvsConeSumPtTotEtaCell",
- Form("#Sigma p_{T} in cone after bkg sub from #eta band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubvsConeSumPtTotEtaCell->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubvsConeSumPtTotEtaCell->SetYTitle("#Sigma p_{T, sub} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaCell);
-
- fhConeSumPtSubNormvsConeSumPtTotEtaCell = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaCell",
- Form("#Sigma p_{T, norm} in cone after bkg sub from #eta band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
+ fhConeSumPtSubvsConeSumPtTotPhiCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubvsConeSumPtTotPhiCell->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiCell);
+
+ fhConeSumPtSubNormvsConeSumPtTotPhiCell = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiCell",
+ Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubNormvsConeSumPtTotPhiCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubNormvsConeSumPtTotPhiCell->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiCell);
+
+ fhConeSumPtSubvsConeSumPtTotEtaCell = new TH2F("hConeSumPtSubvsConeSumPtTotEtaCell",
+ Form("#Sigma #it{p}_{T} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubNormvsConeSumPtTotEtaCell->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubNormvsConeSumPtTotEtaCell->SetYTitle("#Sigma p_{T, sub norm} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaCell);
-
+ fhConeSumPtSubvsConeSumPtTotEtaCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubvsConeSumPtTotEtaCell->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaCell);
+
+ fhConeSumPtSubNormvsConeSumPtTotEtaCell = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaCell",
+ Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubNormvsConeSumPtTotEtaCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubNormvsConeSumPtTotEtaCell->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaCell);
+ }
+ }
}
// Track only histograms
if(GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyNeutral)
{
fhConeSumPtTrack = new TH2F("hConePtSumTrack",
- Form("Track #Sigma p_{T} in isolation cone for R = %2.2f",r),
+ Form("Track #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtTrack->SetYTitle("#Sigma p_{T}");
- fhConeSumPtTrack->SetXTitle("p_{T, trigger} (GeV/c)");
+ fhConeSumPtTrack->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
outputContainer->Add(fhConeSumPtTrack) ;
-
-
- fhConeSumPtEtaBandUETrack = new TH2F("hConePtSumEtaBandUETrack",
- "#Sigma track p_{T} in UE Eta Band",
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtEtaBandUETrack->SetYTitle("#Sigma p_{T}");
- fhConeSumPtEtaBandUETrack->SetXTitle("p_{T, trigger} (GeV/c)");
- outputContainer->Add(fhConeSumPtEtaBandUETrack) ;
-
- fhConeSumPtPhiBandUETrack = new TH2F("hConePtSumPhiBandUETrack",
- "#Sigma track p_{T} in UE Phi Band",
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax*8);
- fhConeSumPtPhiBandUETrack->SetYTitle("#Sigma p_{T}");
- fhConeSumPtPhiBandUETrack->SetXTitle("p_{T, trigger} (GeV/c)");
- outputContainer->Add(fhConeSumPtPhiBandUETrack) ;
-
-
- fhConeSumPtEtaBandUETrackTrigEtaPhi = new TH2F("hConePtSumEtaBandUETrackTrigEtaPhi",
- "Trigger #eta vs #phi, #Sigma track p_{T} in UE Eta Band",
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtEtaBandUETrackTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtEtaBandUETrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtEtaBandUETrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtEtaBandUETrackTrigEtaPhi) ;
-
- fhConeSumPtPhiBandUETrackTrigEtaPhi = new TH2F("hConePtSumPhiBandUETrackTrigEtaPhi",
- "Trigger #eta vs #phi, #Sigma track p_{T} in UE Phi Band",
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtPhiBandUETrackTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtPhiBandUETrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtPhiBandUETrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtPhiBandUETrackTrigEtaPhi) ;
-
+
+ fhConePtLeadTrack = new TH2F("hConeLeadPtTrack",
+ Form("Track leading in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhConePtLeadTrack->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
+ fhConePtLeadTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConePtLeadTrack) ;
fhPtTrackInCone = new TH2F("hPtTrackInCone",
- Form("p_{T} of tracks in isolation cone for R = %2.2f",r),
+ Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtTrackInCone->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtTrackInCone->SetXTitle("p_{T} (GeV/c)");
+ fhPtTrackInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtTrackInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtTrackInCone) ;
- fhEtaBandTrack = new TH2F("hEtaBandTrack",
- Form("#eta vs #phi of tracks in #eta band isolation cone for R = %2.2f",r),
- netabins,-1,1,nphibins,0,TMath::TwoPi());
- fhEtaBandTrack->SetXTitle("#eta");
- fhEtaBandTrack->SetYTitle("#phi");
- outputContainer->Add(fhEtaBandTrack) ;
-
- fhPhiBandTrack = new TH2F("hPhiBandTrack",
- Form("#eta vs #phi of tracks in #phi band isolation cone for R = %2.2f",r),
- netabins,-1,1,nphibins,0,TMath::TwoPi());
- fhPhiBandTrack->SetXTitle("#eta");
- fhPhiBandTrack->SetYTitle("#phi");
- outputContainer->Add(fhPhiBandTrack) ;
-
-
- fhConeSumPtEtaUESubTrack = new TH2F("hConeSumPtEtaUESubTrack",
- Form("Tracks #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtEtaUESubTrack->SetYTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubTrack->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtEtaUESubTrack) ;
-
- fhConeSumPtPhiUESubTrack = new TH2F("hConeSumPtPhiUESubTrack",
- Form("Tracks #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtPhiUESubTrack->SetYTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubTrack->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtPhiUESubTrack) ;
-
- fhConeSumPtEtaUESubTrackTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrackTrigEtaPhi",
- Form("Trigger #eta vs #phi, Tracks #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtEtaUESubTrackTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtEtaUESubTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtEtaUESubTrackTrigEtaPhi) ;
-
- fhConeSumPtPhiUESubTrackTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrackTrigEtaPhi",
- Form("Trigger #eta vs #phi, Tracks #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtPhiUESubTrackTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtPhiUESubTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtPhiUESubTrackTrigEtaPhi) ;
-
- fhFractionTrackOutConeEta = new TH2F("hFractionTrackOutConeEta",
- Form("Fraction of the isolation cone R = %2.2f, out of tracks #eta acceptance",r),
- nptbins,ptmin,ptmax,100,0,1);
- fhFractionTrackOutConeEta->SetYTitle("fraction");
- fhFractionTrackOutConeEta->SetXTitle("p_{T,trigger} (GeV/c)");
- outputContainer->Add(fhFractionTrackOutConeEta) ;
-
- fhFractionTrackOutConeEtaTrigEtaPhi = new TH2F("hFractionTrackOutConeEtaTrigEtaPhi",
- Form("Fraction of the isolation cone R = %2.2f, out of tracks #eta acceptance, in trigger #eta-#phi ",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhFractionTrackOutConeEtaTrigEtaPhi->SetZTitle("fraction");
- fhFractionTrackOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhFractionTrackOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhFractionTrackOutConeEtaTrigEtaPhi) ;
-
- fhConeSumPtSubvsConeSumPtTotPhiTrack = new TH2F("hConeSumPtSubvsConeSumPtTotPhiTrack",
- Form("#Sigma p_{T} in cone after bkg sub from #phi band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubvsConeSumPtTotPhiTrack->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubvsConeSumPtTotPhiTrack->SetYTitle("#Sigma p_{T, sub} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiTrack);
-
- fhConeSumPtSubNormvsConeSumPtTotPhiTrack = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiTrack",
- Form("#Sigma p_{T, norm} in cone after bkg sub from #phi band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubNormvsConeSumPtTotPhiTrack->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubNormvsConeSumPtTotPhiTrack->SetYTitle("#Sigma p_{T, sub norm} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiTrack);
-
- fhConeSumPtSubvsConeSumPtTotEtaTrack = new TH2F("hConeSumPtSubvsConeSumPtTotEtaTrack",
- Form("#Sigma p_{T} in cone after bkg sub from #eta band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubvsConeSumPtTotEtaTrack->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubvsConeSumPtTotEtaTrack->SetYTitle("#Sigma p_{T, sub} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaTrack);
-
- fhConeSumPtSubNormvsConeSumPtTotEtaTrack = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaTrack",
- Form("#Sigma p_{T, norm} in cone after bkg sub from #eta band vs #Sigma p_{T} in cone before bkg sub, R=%2.2f",r),
- nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtSubNormvsConeSumPtTotEtaTrack->SetXTitle("#Sigma p_{T, tot} (GeV/c)");
- fhConeSumPtSubNormvsConeSumPtTotEtaTrack->SetYTitle("#Sigma p_{T, sub norm} (GeV/c)");
- outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaTrack);
-
- // UE in perpendicular cone
- fhPerpConeSumPt = new TH2F("hPerpConePtSum",
- Form("#Sigma p_{T} in isolation cone at #pm 45 degree phi from trigger particle, R = %2.2f",r),
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPerpConeSumPt->SetYTitle("#Sigma p_{T}");
- fhPerpConeSumPt->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPerpConeSumPt) ;
-
- fhPtInPerpCone = new TH2F("hPtInPerpCone",
- Form("p_{T} in isolation cone at #pm 45 degree phi from trigger particle, R = %2.2f",r),
- nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtInPerpCone->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtInPerpCone->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtInPerpCone) ;
+ if(fFillUEBandSubtractHistograms)
+ {
+ fhConeSumPtEtaBandUETrack = new TH2F("hConePtSumEtaBandUETrack",
+ "#Sigma track #it{p}_{T} in UE Eta Band",
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhConeSumPtEtaBandUETrack->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaBandUETrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtEtaBandUETrack) ;
+
+ fhConeSumPtPhiBandUETrack = new TH2F("hConePtSumPhiBandUETrack",
+ "#Sigma track #it{p}_{T} in UE Phi Band",
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax*8);
+ fhConeSumPtPhiBandUETrack->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiBandUETrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtPhiBandUETrack) ;
+
+
+ fhConeSumPtEtaBandUETrackTrigEtaPhi = new TH2F("hConePtSumEtaBandUETrackTrigEtaPhi",
+ "Trigger #eta vs #phi, #Sigma track #it{p}_{T} in UE Eta Band",
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtEtaBandUETrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaBandUETrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtEtaBandUETrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtEtaBandUETrackTrigEtaPhi) ;
+
+ fhConeSumPtPhiBandUETrackTrigEtaPhi = new TH2F("hConePtSumPhiBandUETrackTrigEtaPhi",
+ "Trigger #eta vs #phi, #Sigma track #it{p}_{T} in UE Phi Band",
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtPhiBandUETrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiBandUETrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtPhiBandUETrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtPhiBandUETrackTrigEtaPhi) ;
+
+ fhEtaBandTrack = new TH2F("hEtaBandTrack",
+ Form("#eta vs #phi of tracks in #eta band isolation cone for #it{R} = %2.2f",r),
+ netabins,-1,1,nphibins,0,TMath::TwoPi());
+ fhEtaBandTrack->SetXTitle("#eta");
+ fhEtaBandTrack->SetYTitle("#phi");
+ outputContainer->Add(fhEtaBandTrack) ;
+
+ fhPhiBandTrack = new TH2F("hPhiBandTrack",
+ Form("#eta vs #phi of tracks in #phi band isolation cone for #it{R} = %2.2f",r),
+ netabins,-1,1,nphibins,0,TMath::TwoPi());
+ fhPhiBandTrack->SetXTitle("#eta");
+ fhPhiBandTrack->SetYTitle("#phi");
+ outputContainer->Add(fhPhiBandTrack) ;
+
+ fhConeSumPtEtaUESubTrack = new TH2F("hConeSumPtEtaUESubTrack",
+ Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtEtaUESubTrack->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubTrack->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtEtaUESubTrack) ;
+
+ fhConeSumPtPhiUESubTrack = new TH2F("hConeSumPtPhiUESubTrack",
+ Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtPhiUESubTrack->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubTrack->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtPhiUESubTrack) ;
+
+ fhConeSumPtEtaUESubTrackTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrackTrigEtaPhi",
+ Form("Trigger #eta vs #phi, Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtEtaUESubTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtEtaUESubTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtEtaUESubTrackTrigEtaPhi) ;
+
+ fhConeSumPtPhiUESubTrackTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrackTrigEtaPhi",
+ Form("Trigger #eta vs #phi, Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtPhiUESubTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtPhiUESubTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtPhiUESubTrackTrigEtaPhi) ;
+
+ fhFractionTrackOutConeEta = new TH2F("hFractionTrackOutConeEta",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of tracks #eta acceptance",r),
+ nptbins,ptmin,ptmax,100,0,1);
+ fhFractionTrackOutConeEta->SetYTitle("#it{fraction}");
+ fhFractionTrackOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
+ outputContainer->Add(fhFractionTrackOutConeEta) ;
+
+ fhFractionTrackOutConeEtaTrigEtaPhi = new TH2F("hFractionTrackOutConeEtaTrigEtaPhi",
+ Form("Fraction of the isolation cone #it{R} = %2.2f, out of tracks #eta acceptance, in trigger #eta-#phi ",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhFractionTrackOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
+ fhFractionTrackOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhFractionTrackOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhFractionTrackOutConeEtaTrigEtaPhi) ;
+
+ fhConeSumPtSubvsConeSumPtTotPhiTrack = new TH2F("hConeSumPtSubvsConeSumPtTotPhiTrack",
+ Form("#Sigma #it{p}_{T} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubvsConeSumPtTotPhiTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubvsConeSumPtTotPhiTrack->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiTrack);
+
+ fhConeSumPtSubNormvsConeSumPtTotPhiTrack = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiTrack",
+ Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #phi band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubNormvsConeSumPtTotPhiTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubNormvsConeSumPtTotPhiTrack->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiTrack);
+
+ fhConeSumPtSubvsConeSumPtTotEtaTrack = new TH2F("hConeSumPtSubvsConeSumPtTotEtaTrack",
+ Form("#Sigma #it{p}_{T} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubvsConeSumPtTotEtaTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubvsConeSumPtTotEtaTrack->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaTrack);
+
+ fhConeSumPtSubNormvsConeSumPtTotEtaTrack = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaTrack",
+ Form("#Sigma #it{p}_{T, norm} in cone after bkg sub from #eta band vs #Sigma #it{p}_{T} in cone before bkg sub, R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtSubNormvsConeSumPtTotEtaTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
+ fhConeSumPtSubNormvsConeSumPtTotEtaTrack->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaTrack);
+
+
+ // UE in perpendicular cone
+ fhPerpConeSumPt = new TH2F("hPerpConePtSum",
+ Form("#Sigma #it{p}_{T} in isolation cone at #pm 45 degree phi from trigger particle, #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhPerpConeSumPt->SetYTitle("#Sigma #it{p}_{T}");
+ fhPerpConeSumPt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPerpConeSumPt) ;
+
+ fhPtInPerpCone = new TH2F("hPtInPerpCone",
+ Form("#it{p}_{T} in isolation cone at #pm 45 degree phi from trigger particle, #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
+ fhPtInPerpCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtInPerpCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtInPerpCone) ;
+
+ fhEtaPhiTrack= new TH2F("hEtaPhiTrack",
+ Form("#eta vs #phi of all Tracks"),
+ netabins,-1,1,nphibins,0,TMath::TwoPi());
+ fhEtaPhiTrack->SetXTitle("#eta");
+ fhEtaPhiTrack->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiTrack) ;
+
+ fhEtaPhiInConeTrack= new TH2F("hEtaPhiInConeTrack",
+ Form("#eta vs #phi of Tracks in cone for #it{R} = %2.2f",r),
+ netabins,-1,1,nphibins,0,TMath::TwoPi());
+ fhEtaPhiInConeTrack->SetXTitle("#eta");
+ fhEtaPhiInConeTrack->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiInConeTrack) ;
+
+ fhConeSumPtVSUETracksEtaBand = new TH2F("hConeSumPtVSUETracksEtaBand",
+ Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in eta band for tracks (before normalization), R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,2*nptsumbins,ptsummin,2*ptsummax);
+ fhConeSumPtVSUETracksEtaBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
+ fhConeSumPtVSUETracksEtaBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtVSUETracksEtaBand);
+
+ fhConeSumPtVSUETracksPhiBand = new TH2F("hConeSumPtVSUETracksPhiBand",
+ Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in phi band for tracks (before normalization), R=%2.2f",r),
+ nptsumbins,ptsummin,ptsummax,8*nptsumbins,ptsummin,8*ptsummax);
+ fhConeSumPtVSUETracksPhiBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
+ fhConeSumPtVSUETracksPhiBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtVSUETracksPhiBand);
+ }
}
- if(GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged)
+ if(GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged )
{
- fhConeSumPtEtaUESub = new TH2F("hConeSumPtEtaUESub",
- Form("#Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtEtaUESub->SetYTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESub->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtEtaUESub) ;
-
- fhConeSumPtPhiUESub = new TH2F("hConeSumPtPhiUESub",
- Form("#Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtPhiUESub->SetYTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESub->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtPhiUESub) ;
-
- fhConeSumPtEtaUESubTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrigEtaPhi",
- Form("Trigger #eta vs #phi, #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtEtaUESubTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtEtaUESubTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtEtaUESubTrigEtaPhi) ;
-
- fhConeSumPtPhiUESubTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrigEtaPhi",
- Form("Trigger #eta vs #phi, #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtPhiUESubTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtPhiUESubTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtPhiUESubTrigEtaPhi) ;
-
fhConeSumPtClustervsTrack = new TH2F("hConePtSumClustervsTrack",
- Form("Track vs Cluster #Sigma p_{T} in isolation cone for R = %2.2f",r),
+ Form("Track vs Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhConeSumPtClustervsTrack->SetYTitle("#Sigma p_{T} track");
+ fhConeSumPtClustervsTrack->SetXTitle("#Sigma #it{p}_{T}^{cluster} (GeV/#it{c})");
+ fhConeSumPtClustervsTrack->SetYTitle("#Sigma #it{p}_{T}^{track} (GeV/#it{c})");
outputContainer->Add(fhConeSumPtClustervsTrack) ;
-
- fhConeSumPtEtaUESubClustervsTrack = new TH2F("hConePtSumEtaUESubClustervsTrack",
- Form("Track vs Cluster #Sigma p_{T} UE sub eta band in isolation cone for R = %2.2f",r),
- 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtEtaUESubClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhConeSumPtEtaUESubClustervsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhConeSumPtEtaUESubClustervsTrack) ;
-
- fhConeSumPtPhiUESubClustervsTrack = new TH2F("hConePhiUESubPtSumClustervsTrack",
- Form("Track vs Cluster #Sigma p_{T} UE sub phi band in isolation cone for R = %2.2f",r),
- 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtPhiUESubClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhConeSumPtPhiUESubClustervsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhConeSumPtPhiUESubClustervsTrack) ;
-
- fhEtaBandClustervsTrack = new TH2F("hEtaBandClustervsTrack",
- "Track vs Cluster #Sigma p_{T} in Eta band in isolation cone for R = %2.2f",
- nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
- fhEtaBandClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhEtaBandClustervsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhEtaBandClustervsTrack) ;
-
- fhPhiBandClustervsTrack = new TH2F("hPhiBandClustervsTrack",
- "Track vs Cluster #Sigma p_{T} in Phi band in isolation cone for R = %2.2f",
- nptsumbins,ptsummin,ptsummax*4,nptsumbins,ptsummin,ptsummax*8);
- fhPhiBandClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhPhiBandClustervsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhPhiBandClustervsTrack) ;
-
- fhEtaBandNormClustervsTrack = new TH2F("hEtaBandNormClustervsTrack",
- "Track vs Cluster #Sigma p_{T} in Eta band in isolation cone for R = %2.2f",
- nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
- fhEtaBandNormClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhEtaBandNormClustervsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhEtaBandNormClustervsTrack) ;
-
- fhPhiBandNormClustervsTrack = new TH2F("hPhiBandNormClustervsTrack",
- "Track vs Cluster #Sigma p_{T} in Phi band in isolation cone for R = %2.2f",
- nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
- fhPhiBandNormClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhPhiBandNormClustervsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhPhiBandNormClustervsTrack) ;
-
-
- fhConeSumPtCellTrack = new TH2F("hConePtSumCellTrack",
- Form("Track and Cell #Sigma p_{T} in isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtCellTrack->SetYTitle("#Sigma p_{T}");
- fhConeSumPtCellTrack->SetXTitle("p_{T, trigger} (GeV/c)");
- outputContainer->Add(fhConeSumPtCellTrack) ;
- fhConeSumPtCellTrackTrigEtaPhi = new TH2F("hConePtSumCellTrackTrigEtaPhi",
- Form("Trigger #eta vs #phi, #Sigma p_{T} in isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtCellTrackTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtCellTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtCellTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtCellTrackTrigEtaPhi) ;
+ fhConeSumPtClusterTrackFrac = new TH2F("hConePtSumClusterTrackFraction",
+ Form("#Sigma #it{p}_{T}^{cluster}/#Sigma #it{p}_{T}^{track} in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,200,0,5);
+ fhConeSumPtClusterTrackFrac->SetYTitle("#Sigma #it{p}^{cluster}_{T} /#Sigma #it{p}_{T}^{track}");
+ fhConeSumPtClusterTrackFrac->SetXTitle("#it{p}^{trigger}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtClusterTrackFrac) ;
- fhConeSumPtEtaUESubClustervsTrack = new TH2F("hConePtSumEtaUESubClustervsTrack",
- Form("Track vs Cluster #Sigma p_{T} UE sub eta band in isolation cone for R = %2.2f",r),
- 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtEtaUESubClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhConeSumPtEtaUESubClustervsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhConeSumPtEtaUESubClustervsTrack) ;
-
- fhConeSumPtPhiUESubClustervsTrack = new TH2F("hConePhiUESubPtSumClustervsTrack",
- Form("Track vs Cluster #Sigma p_{T} UE sub phi band in isolation cone for R = %2.2f",r),
- 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtPhiUESubClustervsTrack->SetXTitle("#Sigma p_{T} cluster");
- fhConeSumPtPhiUESubClustervsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhConeSumPtPhiUESubClustervsTrack) ;
-
- fhConeSumPtCellvsTrack = new TH2F("hConePtSumCellvsTrack",
- Form("Track vs cell #Sigma p_{T} in isolation cone for R = %2.2f",r),
- nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
- fhConeSumPtCellvsTrack->SetXTitle("#Sigma p_{T} cell");
- fhConeSumPtCellvsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhConeSumPtCellvsTrack) ;
-
- fhConeSumPtEtaUESubCellvsTrack = new TH2F("hConePtSumEtaUESubCellvsTrack",
- Form("Track vs Cell #Sigma p_{T} UE sub eta band in isolation cone for R = %2.2f",r),
- 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtEtaUESubCellvsTrack->SetXTitle("#Sigma p_{T} cell");
- fhConeSumPtEtaUESubCellvsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhConeSumPtEtaUESubCellvsTrack) ;
-
- fhConeSumPtPhiUESubCellvsTrack = new TH2F("hConePhiUESubPtSumCellvsTrack",
- Form("Track vs Cell #Sigma p_{T} UE sub phi band in isolation cone for R = %2.2f",r),
- 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtPhiUESubCellvsTrack->SetXTitle("#Sigma p_{T} cell");
- fhConeSumPtPhiUESubCellvsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhConeSumPtPhiUESubCellvsTrack) ;
-
- fhEtaBandCellvsTrack = new TH2F("hEtaBandCellvsTrack",
- "Track vs Cell #Sigma p_{T} in Eta band in isolation cone for R = %2.2f",
- nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
- fhEtaBandCellvsTrack->SetXTitle("#Sigma p_{T} cell");
- fhEtaBandCellvsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhEtaBandCellvsTrack) ;
-
- fhPhiBandCellvsTrack = new TH2F("hPhiBandCellvsTrack",
- "Track vs Cell #Sigma p_{T} in Phi band in isolation cone for R = %2.2f",
- nptsumbins,ptsummin,ptsummax*4,nptsumbins,ptsummin,ptsummax*8);
- fhPhiBandCellvsTrack->SetXTitle("#Sigma p_{T} cell");
- fhPhiBandCellvsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhPhiBandCellvsTrack) ;
+ fhConePtLeadClustervsTrack = new TH2F("hConePtLeadClustervsTrack",
+ Form("Track vs Cluster lead #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhConePtLeadClustervsTrack->SetXTitle("#it{p}^{leading cluster}_{T} (GeV/#it{c})");
+ fhConePtLeadClustervsTrack->SetYTitle("#it{p}^{leading track}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConePtLeadClustervsTrack) ;
+
+ fhConePtLeadClusterTrackFrac = new TH2F("hConePtLeadClusterTrackFraction",
+ Form(" #it{p}^{leading cluster}_{T}/#it{p}^{leading track}_{T} in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,200,0,5);
+ fhConePtLeadClusterTrackFrac->SetYTitle("#it{p}^{leading cluster}_{T}/ #it{p}^{leading track}_{T}");
+ fhConePtLeadClusterTrackFrac->SetXTitle("#it{p}^{trigger}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConePtLeadClusterTrackFrac) ;
- fhEtaBandNormCellvsTrack = new TH2F("hEtaBandNormCellvsTrack",
- "Track vs Cell #Sigma p_{T} in Eta band in isolation cone for R = %2.2f",
+
+ if(fFillCellHistograms)
+ {
+ fhConeSumPtCellvsTrack = new TH2F("hConePtSumCellvsTrack",
+ Form("Track vs cell #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
- fhEtaBandNormCellvsTrack->SetXTitle("#Sigma p_{T} cell");
- fhEtaBandNormCellvsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhEtaBandNormCellvsTrack) ;
+ fhConeSumPtCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
+ fhConeSumPtCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhConeSumPtCellvsTrack) ;
+
+ fhConeSumPtCellTrack = new TH2F("hConePtSumCellTrack",
+ Form("Track and Cell #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhConeSumPtCellTrack->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtCellTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtCellTrack) ;
+
+ fhConeSumPtCellTrackTrigEtaPhi = new TH2F("hConePtSumCellTrackTrigEtaPhi",
+ Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtCellTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtCellTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtCellTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtCellTrackTrigEtaPhi) ;
+
+ }
- fhPhiBandNormCellvsTrack = new TH2F("hPhiBandNormCellvsTrack",
- "Track vs Cell #Sigma p_{T} in Phi band in isolation cone for R = %2.2f",
+ if(fFillUEBandSubtractHistograms)
+ {
+ fhConeSumPtEtaUESub = new TH2F("hConeSumPtEtaUESub",
+ Form("#Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtEtaUESub->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESub->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtEtaUESub) ;
+
+ fhConeSumPtPhiUESub = new TH2F("hConeSumPtPhiUESub",
+ Form("#Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtPhiUESub->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESub->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtPhiUESub) ;
+
+ fhConeSumPtEtaUESubTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrigEtaPhi",
+ Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtEtaUESubTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtEtaUESubTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtEtaUESubTrigEtaPhi) ;
+
+ fhConeSumPtPhiUESubTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrigEtaPhi",
+ Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtPhiUESubTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtPhiUESubTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtPhiUESubTrigEtaPhi) ;
+
+ fhConeSumPtEtaUESubClustervsTrack = new TH2F("hConePtSumEtaUESubClustervsTrack",
+ Form("Track vs Cluster #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} = %2.2f",r),
+ 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtEtaUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
+ fhConeSumPtEtaUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhConeSumPtEtaUESubClustervsTrack) ;
+
+ fhConeSumPtPhiUESubClustervsTrack = new TH2F("hConePhiUESubPtSumClustervsTrack",
+ Form("Track vs Cluster #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} = %2.2f",r),
+ 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtPhiUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
+ fhConeSumPtPhiUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhConeSumPtPhiUESubClustervsTrack) ;
+
+ fhEtaBandClustervsTrack = new TH2F("hEtaBandClustervsTrack",
+ Form("Track vs Cluster #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} = %2.2f",r),
+ nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
+ fhEtaBandClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
+ fhEtaBandClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhEtaBandClustervsTrack) ;
+
+ fhPhiBandClustervsTrack = new TH2F("hPhiBandClustervsTrack",
+ Form("Track vs Cluster #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} = %2.2f",r),
+ nptsumbins,ptsummin,ptsummax*4,nptsumbins,ptsummin,ptsummax*8);
+ fhPhiBandClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
+ fhPhiBandClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhPhiBandClustervsTrack) ;
+
+ fhEtaBandNormClustervsTrack = new TH2F("hEtaBandNormClustervsTrack",
+ Form("Track vs Cluster #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} = %2.2f",r),
+ nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
+ fhEtaBandNormClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
+ fhEtaBandNormClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhEtaBandNormClustervsTrack) ;
+
+ fhPhiBandNormClustervsTrack = new TH2F("hPhiBandNormClustervsTrack",
+ Form("Track vs Cluster #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} = %2.2f",r),
+ nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
+ fhPhiBandNormClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
+ fhPhiBandNormClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhPhiBandNormClustervsTrack) ;
+
+ fhConeSumPtEtaUESubClustervsTrack = new TH2F("hConePtSumEtaUESubClustervsTrack",
+ Form("Track vs Cluster #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} = %2.2f",r),
+ 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtEtaUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
+ fhConeSumPtEtaUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhConeSumPtEtaUESubClustervsTrack) ;
+
+ fhConeSumPtPhiUESubClustervsTrack = new TH2F("hConePhiUESubPtSumClustervsTrack",
+ Form("Track vs Cluster #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} = %2.2f",r),
+ 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtPhiUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
+ fhConeSumPtPhiUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhConeSumPtPhiUESubClustervsTrack) ;
+
+ if(fFillCellHistograms)
+ {
+
+ fhConeSumPtEtaUESubCellvsTrack = new TH2F("hConePtSumEtaUESubCellvsTrack",
+ Form("Track vs Cell #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} = %2.2f",r),
+ 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtEtaUESubCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
+ fhConeSumPtEtaUESubCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhConeSumPtEtaUESubCellvsTrack) ;
+
+ fhConeSumPtPhiUESubCellvsTrack = new TH2F("hConePhiUESubPtSumCellvsTrack",
+ Form("Track vs Cell #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} = %2.2f",r),
+ 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtPhiUESubCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
+ fhConeSumPtPhiUESubCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhConeSumPtPhiUESubCellvsTrack) ;
+
+ fhEtaBandCellvsTrack = new TH2F("hEtaBandCellvsTrack",
+ Form("Track vs Cell #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} = %2.2f",r),
nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
- fhPhiBandNormCellvsTrack->SetXTitle("#Sigma p_{T} cell");
- fhPhiBandNormCellvsTrack->SetYTitle("#Sigma p_{T} track");
- outputContainer->Add(fhPhiBandNormCellvsTrack) ;
-
- fhConeSumPtEtaUESubTrackCell = new TH2F("hConeSumPtEtaUESubTrackCell",
- Form("Tracks #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtEtaUESubTrackCell->SetYTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubTrackCell->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtEtaUESubTrackCell) ;
-
- fhConeSumPtPhiUESubTrackCell = new TH2F("hConeSumPtPhiUESubTrackCell",
- Form("Tracks #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
- fhConeSumPtPhiUESubTrackCell->SetYTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubTrackCell->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhConeSumPtPhiUESubTrackCell) ;
-
- fhConeSumPtEtaUESubTrackCellTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrackCellTrigEtaPhi",
- Form("Trigger #eta vs #phi, Tracks #Sigma p_{T} after bkg subtraction from eta band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtEtaUESubTrackCellTrigEtaPhi) ;
-
- fhConeSumPtPhiUESubTrackCellTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrackCellTrigEtaPhi",
- Form("Trigger #eta vs #phi, Tracks #Sigma p_{T} after bkg subtraction from phi band in the isolation cone for R = %2.2f",r),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetZTitle("#Sigma p_{T}");
- fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
- fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
- outputContainer->Add(fhConeSumPtPhiUESubTrackCellTrigEtaPhi) ;
-
- }
-
- if(fFillSSHisto)
- {
- fhELambda0SSBkg = new TH2F
- ("hELambda0SSBkg","Non isolated clusters : E vs #lambda_{0}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0SSBkg->SetYTitle("#lambda_{0}^{2}");
- fhELambda0SSBkg->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0SSBkg) ;
+ fhEtaBandCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
+ fhEtaBandCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhEtaBandCellvsTrack) ;
+
+ fhPhiBandCellvsTrack = new TH2F("hPhiBandCellvsTrack",
+ Form("Track vs Cell #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} = %2.2f",r),
+ nptsumbins,ptsummin,ptsummax*4,nptsumbins,ptsummin,ptsummax*8);
+ fhPhiBandCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
+ fhPhiBandCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhPhiBandCellvsTrack) ;
+
+ fhEtaBandNormCellvsTrack = new TH2F("hEtaBandNormCellvsTrack",
+ Form("Track vs Cell #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} = %2.2f",r),
+ nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
+ fhEtaBandNormCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
+ fhEtaBandNormCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhEtaBandNormCellvsTrack) ;
+
+ fhPhiBandNormCellvsTrack = new TH2F("hPhiBandNormCellvsTrack",
+ Form("Track vs Cell #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} = %2.2f",r),
+ nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
+ fhPhiBandNormCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
+ fhPhiBandNormCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
+ outputContainer->Add(fhPhiBandNormCellvsTrack) ;
+
+ fhConeSumPtEtaUESubTrackCell = new TH2F("hConeSumPtEtaUESubTrackCell",
+ Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtEtaUESubTrackCell->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubTrackCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtEtaUESubTrackCell) ;
+
+ fhConeSumPtPhiUESubTrackCell = new TH2F("hConeSumPtPhiUESubTrackCell",
+ Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
+ fhConeSumPtPhiUESubTrackCell->SetYTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubTrackCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhConeSumPtPhiUESubTrackCell) ;
+
+ fhConeSumPtEtaUESubTrackCellTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrackCellTrigEtaPhi",
+ Form("Trigger #eta vs #phi, Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtEtaUESubTrackCellTrigEtaPhi) ;
+
+ fhConeSumPtPhiUESubTrackCellTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrackCellTrigEtaPhi",
+ Form("Trigger #eta vs #phi, Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
+ netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
+ fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
+ fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
+ outputContainer->Add(fhConeSumPtPhiUESubTrackCellTrigEtaPhi) ;
+ }
+ }
}
for(Int_t iso = 0; iso < 2; iso++)
if(fFillTMHisto)
{
fhTrackMatchedDEta[iso] = new TH2F
- (Form("hTrackMatchedDEta%s",hName[iso].Data()),
- Form("%s - d#eta of cluster-track vs cluster energy for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",hTitle[iso].Data(),r,ptthre,ptfrac),
+ (Form("hTrackMatchedDEta%s",isoName[iso].Data()),
+ Form("%s - d#eta of cluster-track vs cluster energy, %s",isoTitle[iso].Data(),parTitle.Data()),
nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
fhTrackMatchedDEta[iso]->SetYTitle("d#eta");
fhTrackMatchedDEta[iso]->SetXTitle("E_{cluster} (GeV)");
fhTrackMatchedDPhi[iso] = new TH2F
- (Form("hTrackMatchedDPhi%s",hName[iso].Data()),
- Form("%s - d#phi of cluster-track vs cluster energy for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",hTitle[iso].Data(),r,ptthre,ptfrac),
+ (Form("hTrackMatchedDPhi%s",isoName[iso].Data()),
+ Form("%s - d#phi of cluster-track vs cluster energy, %s",isoTitle[iso].Data(),parTitle.Data()),
nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
fhTrackMatchedDPhi[iso]->SetYTitle("d#phi (rad)");
fhTrackMatchedDPhi[iso]->SetXTitle("E_{cluster} (GeV)");
fhTrackMatchedDEtaDPhi[iso] = new TH2F
- (Form("hTrackMatchedDEtaDPhi%s",hName[iso].Data()),
- Form("%s - d#eta vs d#phi of cluster-track for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",hTitle[iso].Data(),r,ptthre,ptfrac),
+ (Form("hTrackMatchedDEtaDPhi%s",isoName[iso].Data()),
+ Form("%s - d#eta vs d#phi of cluster-track, %s",isoTitle[iso].Data(),parTitle.Data()),
nresetabins,resetamin,resetamax,nresphibins,resphimin,resphimax);
fhTrackMatchedDEtaDPhi[iso]->SetYTitle("d#phi (rad)");
fhTrackMatchedDEtaDPhi[iso]->SetXTitle("d#eta");
outputContainer->Add(fhTrackMatchedDEtaDPhi[iso]) ;
fhdEdx[iso] = new TH2F
- (Form("hdEdx%s",hName[iso].Data()),
- Form("%s - Matched track <dE/dx> vs cluster E for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",hTitle[iso].Data(),r,ptthre,ptfrac),
+ (Form("hdEdx%s",isoName[iso].Data()),
+ Form("%s - Matched track <d#it{E}/d#it{x}> vs cluster #it{E}, %s",isoTitle[iso].Data(),parTitle.Data()),
nptbins,ptmin,ptmax,ndedxbins, dedxmin, dedxmax);
- fhdEdx[iso]->SetXTitle("E (GeV)");
- fhdEdx[iso]->SetYTitle("<dE/dx>");
+ fhdEdx[iso]->SetXTitle("#it{E} (GeV)");
+ fhdEdx[iso]->SetYTitle("<d#it{E}/d#it{x}>");
outputContainer->Add(fhdEdx[iso]);
fhEOverP[iso] = new TH2F
- (Form("hEOverP%s",hName[iso].Data()),
- Form("%s - Matched track E/p vs cluster E for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",hTitle[iso].Data(),r,ptthre,ptfrac),
+ (Form("hEOverP%s",isoName[iso].Data()),
+ Form("%s - Matched track #it{E}/#it{p} vs cluster, %s",isoTitle[iso].Data(),parTitle.Data()),
nptbins,ptmin,ptmax,nPoverEbins,pOverEmin,pOverEmax);
- fhEOverP[iso]->SetXTitle("E (GeV)");
- fhEOverP[iso]->SetYTitle("E/p");
+ fhEOverP[iso]->SetXTitle("#it{E} (GeV)");
+ fhEOverP[iso]->SetYTitle("#it{E}/#it{p}");
outputContainer->Add(fhEOverP[iso]);
if(IsDataMC())
{
fhTrackMatchedMCParticle[iso] = new TH2F
- (Form("hTrackMatchedMCParticle%s",hName[iso].Data()),
- Form("%s - Origin of particle vs energy vs cluster E for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",hTitle[iso].Data(),r,ptthre,ptfrac),
+ (Form("hTrackMatchedMCParticle%s",isoName[iso].Data()),
+ Form("%s - Origin of particle vs cluster #it{E}, %s",isoTitle[iso].Data(),parTitle.Data()),
nptbins,ptmin,ptmax,8,0,8);
- fhTrackMatchedMCParticle[iso]->SetXTitle("E (GeV)");
+ fhTrackMatchedMCParticle[iso]->SetXTitle("#it{E} (GeV)");
//fhTrackMatchedMCParticle[iso]->SetYTitle("Particle type");
fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(1 ,"Photon");
if(fFillSSHisto)
{
fhELambda0[iso] = new TH2F
- (Form("hELambda0%s",hName[iso].Data()),
- Form("%s cluster : E vs #lambda_{0}",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ (Form("hELambda0%s",isoName[iso].Data()),
+ Form("%s cluster : #it{E} vs #lambda_{0}, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhELambda0[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0[iso]->SetXTitle("E (GeV)");
+ fhELambda0[iso]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhELambda0[iso]) ;
- if(IsDataMC())
- {
- fhELambda0MCPhoton[iso] = new TH2F
- (Form("hELambda0%s_MCPhoton",hName[iso].Data()),
- Form("%s cluster : E vs #lambda_{0}: Origin is final state photon",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0MCPhoton[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0MCPhoton[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0MCPhoton[iso]) ;
-
- fhELambda0MCPi0[iso] = new TH2F
- (Form("hELambda0%s_MCPi0",hName[iso].Data()),
- Form("%s cluster : E vs #lambda_{0}: Origin is pi0 (2 #gamma)",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0MCPi0[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0MCPi0[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0MCPi0[iso]) ;
-
- fhELambda0MCPi0Decay[iso] = new TH2F
- (Form("hELambda0%s_MCPi0Decay",hName[iso].Data()),
- Form("%s cluster : E vs #lambda_{0}: Origin is pi0 decay",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0MCPi0Decay[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0MCPi0Decay[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0MCPi0Decay[iso]) ;
-
- fhELambda0MCEtaDecay[iso] = new TH2F
- (Form("hELambda0%s_MCEtaDecay",hName[iso].Data()),
- Form("%s cluster : E vs #lambda_{0}: Origin is eta decay",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0MCEtaDecay[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0MCEtaDecay[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0MCEtaDecay[iso]) ;
-
- fhELambda0MCOtherDecay[iso] = new TH2F
- (Form("hELambda0%s_MCOtherDecay",hName[iso].Data()),
- Form("%s cluster : E vs #lambda_{0}: Origin is other decay",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0MCOtherDecay[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0MCOtherDecay[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0MCOtherDecay[iso]) ;
-
- fhELambda0MCHadron[iso] = new TH2F
- (Form("hELambda0%s_MCHadron",hName[iso].Data()),
- Form("%s cluster : E vs #lambda_{0}: Origin is hadron",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0MCHadron[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0MCHadron[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0MCHadron[iso]) ;
- }
-
fhELambda1[iso] = new TH2F
- (Form("hELambda1%s",hName[iso].Data()),
- Form("%s cluster: E vs #lambda_{1}",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ (Form("hELambda1%s",isoName[iso].Data()),
+ Form("%s cluster: #it{E} vs #lambda_{1}, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhELambda1[iso]->SetYTitle("#lambda_{1}^{2}");
- fhELambda1[iso]->SetXTitle("E (GeV)");
+ fhELambda1[iso]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhELambda1[iso]) ;
- if(fCalorimeter=="EMCAL")
+ fhPtLambda0[iso] = new TH2F
+ (Form("hPtLambda0%s",isoName[iso].Data()),
+ Form("%s cluster : #it{p}_{T} vs #lambda_{0}, %s",isoTitle[iso].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhPtLambda0[iso]->SetYTitle("#lambda_{0}^{2}");
+ fhPtLambda0[iso]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtLambda0[iso]) ;
+
+ if(fFillTaggedDecayHistograms)
+ {
+ for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
+ {
+ fhPtLambda0Decay[iso][ibit] = new TH2F
+ (Form("hPtLambda0Decay%s_bit%d",isoName[iso].Data(),fDecayBits[ibit]),
+ Form("%s cluster : #it{p}_{T} vs #lambda_{0}, decay bit %d, %s",isoTitle[iso].Data(), fDecayBits[ibit], parTitle.Data()),
+ nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhPtLambda0Decay[iso][ibit]->SetYTitle("#lambda_{0}^{2}");
+ fhPtLambda0Decay[iso][ibit]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtLambda0Decay[iso][ibit]) ;
+ }
+ }
+
+ if(IsDataMC())
{
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+ fhPtLambda0MC[imc][iso] = new TH2F(Form("hPtLambda0%s_MC%s",isoName[iso].Data(),mcPartName[imc].Data()),
+ Form("%s cluster : #it{p}_{T} vs #lambda_{0}: %s %s",isoTitle[iso].Data(),mcPartType[imc].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhPtLambda0MC[imc][iso]->SetYTitle("#lambda_{0}^{2}");
+ fhPtLambda0MC[imc][iso]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add( fhPtLambda0MC[imc][iso]) ;
+ }
+ }
+
+ if(fIsoDetector=="EMCAL" && GetFirstSMCoveredByTRD() >= 0)
+ {
+ fhPtLambda0TRD[iso] = new TH2F
+ (Form("hPtLambda0TRD%s",isoName[iso].Data()),
+ Form("%s cluster: #it{p}_{T} vs #lambda_{0}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhPtLambda0TRD[iso]->SetYTitle("#lambda_{0}^{2}");
+ fhPtLambda0TRD[iso]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtLambda0TRD[iso]) ;
+
fhELambda0TRD[iso] = new TH2F
- (Form("hELambda0TRD%s",hName[iso].Data()),
- Form("%s cluster: E vs #lambda_{0}, SM behind TRD",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ (Form("hELambda0TRD%s",isoName[iso].Data()),
+ Form("%s cluster: #it{E} vs #lambda_{0}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhELambda0TRD[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0TRD[iso]->SetXTitle("E (GeV)");
+ fhELambda0TRD[iso]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhELambda0TRD[iso]) ;
fhELambda1TRD[iso] = new TH2F
- (Form("hELambda1TRD%s",hName[iso].Data()),
- Form("%s cluster: E vs #lambda_{1}, SM behind TRD",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ (Form("hELambda1TRD%s",isoName[iso].Data()),
+ Form("%s cluster: #it{E} vs #lambda_{1}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
fhELambda1TRD[iso]->SetYTitle("#lambda_{1}^{2}");
- fhELambda1TRD[iso]->SetXTitle("E (GeV)");
+ fhELambda1TRD[iso]->SetXTitle("#it{E} (GeV)");
outputContainer->Add(fhELambda1TRD[iso]) ;
}
- fhNLocMax[iso] = new TH2F
- (Form("hNLocMax%s",hName[iso].Data()),
- Form("%s - Number of local maxima in cluster",hTitle[iso].Data()),
- nptbins,ptmin,ptmax,10,0,10);
- fhNLocMax[iso]->SetYTitle("N maxima");
- fhNLocMax[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhNLocMax[iso]) ;
-
- fhELambda0LocMax1[iso] = new TH2F
- (Form("hELambda0LocMax1%s",hName[iso].Data()),
- Form("%s cluster (#eta) pairs: E vs #lambda_{0}, 1 Local maxima",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0LocMax1[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0LocMax1[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0LocMax1[iso]) ;
-
- fhELambda1LocMax1[iso] = new TH2F
- (Form("hELambda1LocMax1%s",hName[iso].Data()),
- Form("%s cluster (#eta) pairs: E vs #lambda_{1}, 1 Local maxima",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda1LocMax1[iso]->SetYTitle("#lambda_{1}^{2}");
- fhELambda1LocMax1[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda1LocMax1[iso]) ;
-
- fhELambda0LocMax2[iso] = new TH2F
- (Form("hELambda0LocMax2%s",hName[iso].Data()),
- Form("%s cluster (#eta) pairs: E vs #lambda_{0}, 2 Local maxima",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0LocMax2[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0LocMax2[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0LocMax2[iso]) ;
-
- fhELambda1LocMax2[iso] = new TH2F
- (Form("hELambda1LocMax2%s",hName[iso].Data()),
- Form("%s cluster (#eta) pairs: E vs #lambda_{1}, 2 Local maxima",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda1LocMax2[iso]->SetYTitle("#lambda_{1}^{2}");
- fhELambda1LocMax2[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda1LocMax2[iso]) ;
-
- fhELambda0LocMaxN[iso] = new TH2F
- ( Form("hELambda0LocMaxN%s",hName[iso].Data()),
- Form("%s cluster (#eta) pairs: E vs #lambda_{0}, N>2 Local maxima",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda0LocMaxN[iso]->SetYTitle("#lambda_{0}^{2}");
- fhELambda0LocMaxN[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda0LocMaxN[iso]) ;
-
- fhELambda1LocMaxN[iso] = new TH2F
- (Form("hELambda1LocMaxN%s",hName[iso].Data()),
- Form("%s cluster (#eta) pairs: E vs #lambda_{1}, N>2 Local maxima",hTitle[iso].Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
- fhELambda1LocMaxN[iso]->SetYTitle("#lambda_{1}^{2}");
- fhELambda1LocMaxN[iso]->SetXTitle("E (GeV)");
- outputContainer->Add(fhELambda1LocMaxN[iso]) ;
-
- }
+ if(fFillNLMHistograms)
+ {
+ fhNLocMax[iso] = new TH2F
+ (Form("hNLocMax%s",isoName[iso].Data()),
+ Form("%s - Number of local maxima in cluster, %s",isoTitle[iso].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax,10,0,10);
+ fhNLocMax[iso]->SetYTitle("#it{NLM}");
+ fhNLocMax[iso]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhNLocMax[iso]) ;
+
+ fhELambda0LocMax1[iso] = new TH2F
+ (Form("hELambda0LocMax1%s",isoName[iso].Data()),
+ Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{0}, #it{NLM}=1, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhELambda0LocMax1[iso]->SetYTitle("#lambda_{0}^{2}");
+ fhELambda0LocMax1[iso]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhELambda0LocMax1[iso]) ;
+
+ fhELambda1LocMax1[iso] = new TH2F
+ (Form("hELambda1LocMax1%s",isoName[iso].Data()),
+ Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{1}, #it{NLM}=1, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhELambda1LocMax1[iso]->SetYTitle("#lambda_{1}^{2}");
+ fhELambda1LocMax1[iso]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhELambda1LocMax1[iso]) ;
+
+ fhELambda0LocMax2[iso] = new TH2F
+ (Form("hELambda0LocMax2%s",isoName[iso].Data()),
+ Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{0}, #it{NLM}=2, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhELambda0LocMax2[iso]->SetYTitle("#lambda_{0}^{2}");
+ fhELambda0LocMax2[iso]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhELambda0LocMax2[iso]) ;
+
+ fhELambda1LocMax2[iso] = new TH2F
+ (Form("hELambda1LocMax2%s",isoName[iso].Data()),
+ Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{1}, #it{NLM}=2, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhELambda1LocMax2[iso]->SetYTitle("#lambda_{1}^{2}");
+ fhELambda1LocMax2[iso]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhELambda1LocMax2[iso]) ;
+
+ fhELambda0LocMaxN[iso] = new TH2F
+ ( Form("hELambda0LocMaxN%s",isoName[iso].Data()),
+ Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{0}, #it{NLM}>2, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhELambda0LocMaxN[iso]->SetYTitle("#lambda_{0}^{2}");
+ fhELambda0LocMaxN[iso]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhELambda0LocMaxN[iso]) ;
+
+ fhELambda1LocMaxN[iso] = new TH2F
+ (Form("hELambda1LocMaxN%s",isoName[iso].Data()),
+ Form("%s cluster (#eta) pairs: #it{E} vs #lambda_{1}, #it{NLM}>2, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+ fhELambda1LocMaxN[iso]->SetYTitle("#lambda_{1}^{2}");
+ fhELambda1LocMaxN[iso]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhELambda1LocMaxN[iso]) ;
+ } // NLM
+ } // SS histo
} // control histograms for isolated and non isolated objects
if(fFillPileUpHistograms)
{
fhPtTrackInConeOtherBC = new TH2F("hPtTrackInConeOtherBC",
- Form("p_{T} of tracks in isolation cone for R = %2.2f, TOF from BC!=0",r),
+ Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC!=0",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtTrackInConeOtherBC->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtTrackInConeOtherBC->SetXTitle("p_{T} (GeV/c)");
+ fhPtTrackInConeOtherBC->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtTrackInConeOtherBC->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtTrackInConeOtherBC) ;
fhPtTrackInConeOtherBCPileUpSPD = new TH2F("hPtTrackInConeOtherBCPileUpSPD",
- Form("p_{T} of tracks in isolation cone for R = %2.2f, TOF from BC!=0, pile-up from SPD",r),
+ Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC!=0, pile-up from SPD",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtTrackInConeOtherBCPileUpSPD->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtTrackInConeOtherBCPileUpSPD->SetXTitle("p_{T} (GeV/c)");
+ fhPtTrackInConeOtherBCPileUpSPD->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtTrackInConeOtherBCPileUpSPD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtTrackInConeOtherBCPileUpSPD) ;
fhPtTrackInConeBC0 = new TH2F("hPtTrackInConeBC0",
- Form("p_{T} of tracks in isolation cone for R = %2.2f, TOF from BC==0",r),
+ Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC==0",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtTrackInConeBC0->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtTrackInConeBC0->SetXTitle("p_{T} (GeV/c)");
+ fhPtTrackInConeBC0->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtTrackInConeBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtTrackInConeBC0) ;
fhPtTrackInConeVtxBC0 = new TH2F("hPtTrackInConeVtxBC0",
- Form("p_{T} of tracks in isolation cone for R = %2.2f, TOF from BC==0",r),
+ Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC==0",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtTrackInConeVtxBC0->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtTrackInConeVtxBC0->SetXTitle("p_{T} (GeV/c)");
+ fhPtTrackInConeVtxBC0->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtTrackInConeVtxBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtTrackInConeVtxBC0) ;
fhPtTrackInConeBC0PileUpSPD = new TH2F("hPtTrackInConeBC0PileUpSPD",
- Form("p_{T} of tracks in isolation cone for R = %2.2f, TOF from BC==0, pile-up from SPD",r),
+ Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC==0, pile-up from SPD",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtTrackInConeBC0PileUpSPD->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtTrackInConeBC0PileUpSPD->SetXTitle("p_{T} (GeV/c)");
+ fhPtTrackInConeBC0PileUpSPD->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtTrackInConeBC0PileUpSPD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtTrackInConeBC0PileUpSPD) ;
for (Int_t i = 0; i < 7 ; i++)
{
fhPtInConePileUp[i] = new TH2F(Form("hPtInConePileUp%s",pileUpName[i].Data()),
- Form("p_{T} in isolation cone for R = %2.2f, from pile-up (%s)",r,pileUpName[i].Data()),
+ Form("#it{p}_{T} in isolation cone for #it{R} = %2.2f, from pile-up (%s)",r,pileUpName[i].Data()),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtInConePileUp[i]->SetYTitle("p_{T in cone} (GeV/c)");
- fhPtInConePileUp[i]->SetXTitle("p_{T} (GeV/c)");
+ fhPtInConePileUp[i]->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
+ fhPtInConePileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtInConePileUp[i]) ;
}
}
if(IsDataMC())
{
- fhPtIsoPrompt = new TH1F("hPtMCPrompt","Number of isolated prompt #gamma",nptbins,ptmin,ptmax);
- fhPtIsoPrompt->SetYTitle("N");
- fhPtIsoPrompt->SetXTitle("p_{T #gamma}(GeV/c)");
- outputContainer->Add(fhPtIsoPrompt) ;
-
- fhPhiIsoPrompt = new TH2F
- ("hPhiMCPrompt","Number of isolated prompt #gamma",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- fhPhiIsoPrompt->SetYTitle("#phi");
- fhPhiIsoPrompt->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhPhiIsoPrompt) ;
-
- fhEtaIsoPrompt = new TH2F
- ("hEtaMCPrompt","Number of isolated prompt #gamma",nptbins,ptmin,ptmax,netabins,etamin,etamax);
- fhEtaIsoPrompt->SetYTitle("#eta");
- fhEtaIsoPrompt->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhEtaIsoPrompt) ;
-
- fhPtIsoFragmentation = new TH1F("hPtMCFragmentation","Number of isolated #gamma",nptbins,ptmin,ptmax);
- fhPtIsoFragmentation->SetYTitle("N");
- fhPtIsoFragmentation->SetXTitle("p_{T #gamma}(GeV/c)");
- outputContainer->Add(fhPtIsoFragmentation) ;
-
- fhPhiIsoFragmentation = new TH2F
- ("hPhiMCFragmentation","Number of isolated fragmentation #gamma",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- fhPhiIsoFragmentation->SetYTitle("#phi");
- fhPhiIsoFragmentation->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhPhiIsoFragmentation) ;
-
- fhEtaIsoFragmentation = new TH2F
- ("hEtaMCFragmentation","Number of isolated fragmentation #gamma",nptbins,ptmin,ptmax,netabins,etamin,etamax);
- fhEtaIsoFragmentation->SetYTitle("#eta");
- fhEtaIsoFragmentation->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhEtaIsoFragmentation) ;
-
- fhPtIsoPi0 = new TH1F("hPtMCPi0","Number of isolated #gamma from #pi^{0} (2 #gamma)",nptbins,ptmin,ptmax);
- fhPtIsoPi0->SetYTitle("N");
- fhPtIsoPi0->SetXTitle("p_{T #gamma}(GeV/c)");
- outputContainer->Add(fhPtIsoPi0) ;
-
- fhPhiIsoPi0 = new TH2F
- ("hPhiMCPi0","Number of isolated #gamma from #pi^{0} (2 #gamma)",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- fhPhiIsoPi0->SetYTitle("#phi");
- fhPhiIsoPi0->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhPhiIsoPi0) ;
-
- fhEtaIsoPi0 = new TH2F
- ("hEtaMCPi0","Number of isolated #gamma from #pi^{0} (2 #gamma)",nptbins,ptmin,ptmax,netabins,etamin,etamax);
- fhEtaIsoPi0->SetYTitle("#eta");
- fhEtaIsoPi0->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhEtaIsoPi0) ;
-
- fhPtIsoPi0Decay = new TH1F("hPtMCPi0Decay","Number of isolated #gamma from #pi^{0} decay",nptbins,ptmin,ptmax);
- fhPtIsoPi0Decay->SetYTitle("N");
- fhPtIsoPi0Decay->SetXTitle("p_{T #gamma}(GeV/c)");
- outputContainer->Add(fhPtIsoPi0Decay) ;
-
- fhPhiIsoPi0Decay = new TH2F
- ("hPhiMCPi0Decay","Number of isolated #gamma from #pi^{0} decay",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- fhPhiIsoPi0Decay->SetYTitle("#phi");
- fhPhiIsoPi0Decay->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhPhiIsoPi0Decay) ;
-
- fhEtaIsoPi0Decay = new TH2F
- ("hEtaMCPi0Decay","Number of isolated #gamma from #pi^{0} decay",nptbins,ptmin,ptmax,netabins,etamin,etamax);
- fhEtaIsoPi0Decay->SetYTitle("#eta");
- fhEtaIsoPi0Decay->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhEtaIsoPi0Decay) ;
-
- fhPtIsoEtaDecay = new TH1F("hPtMCEtaDecay","Number of isolated #gamma from #eta decay",nptbins,ptmin,ptmax);
- fhPtIsoEtaDecay->SetYTitle("N");
- fhPtIsoEtaDecay->SetXTitle("p_{T #gamma}(GeV/c)");
- outputContainer->Add(fhPtIsoEtaDecay) ;
-
- fhPhiIsoEtaDecay = new TH2F
- ("hPhiMCEtaDecay","Number of isolated #gamma from #eta decay",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- fhPhiIsoEtaDecay->SetYTitle("#phi");
- fhPhiIsoEtaDecay->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhPhiIsoEtaDecay) ;
-
- fhEtaIsoEtaDecay = new TH2F
- ("hEtaMCEtaDecay","Number of isolated #gamma from #eta decay",nptbins,ptmin,ptmax,netabins,etamin,etamax);
- fhEtaIsoEtaDecay->SetYTitle("#eta");
- fhEtaIsoEtaDecay->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhEtaIsoEtaDecay) ;
-
- fhPtIsoOtherDecay = new TH1F("hPtMCOtherDecay","Number of isolated #gamma from non-#pi^{0} decay",nptbins,ptmin,ptmax);
- fhPtIsoOtherDecay->SetYTitle("N");
- fhPtIsoOtherDecay->SetXTitle("p_{T #gamma}(GeV/c)");
- outputContainer->Add(fhPtIsoOtherDecay) ;
-
- fhPhiIsoOtherDecay = new TH2F
- ("hPhiMCOtherDecay","Number of isolated #gamma from non-#pi^{0} decay",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- fhPhiIsoOtherDecay->SetYTitle("#phi");
- fhPhiIsoOtherDecay->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhPhiIsoOtherDecay) ;
-
- fhEtaIsoOtherDecay = new TH2F
- ("hEtaMCOtherDecay","Number of isolated #gamma non-#pi^{0} decay",nptbins,ptmin,ptmax,netabins,etamin,etamax);
- fhEtaIsoOtherDecay->SetYTitle("#eta");
- fhEtaIsoOtherDecay->SetXTitle("p_{T #gamma} (GeV/c)");
- outputContainer->Add(fhEtaIsoOtherDecay) ;
-
- // fhPtIsoConversion = new TH1F("hPtMCConversion","Number of isolated converted #gamma",nptbins,ptmin,ptmax);
- // fhPtIsoConversion->SetYTitle("N");
- // fhPtIsoConversion->SetXTitle("p_{T #gamma}(GeV/c)");
- // outputContainer->Add(fhPtIsoConversion) ;
- //
- // fhPhiIsoConversion = new TH2F
- // ("hPhiMCConversion","Number of isolated converted #gamma",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- // fhPhiIsoConversion->SetYTitle("#phi");
- // fhPhiIsoConversion->SetXTitle("p_{T #gamma} (GeV/c)");
- // outputContainer->Add(fhPhiIsoConversion) ;
- //
- // fhEtaIsoConversion = new TH2F
- // ("hEtaMCConversion","Number of isolated converted #gamma",nptbins,ptmin,ptmax,netabins,etamin,etamax);
- // fhEtaIsoConversion->SetYTitle("#eta");
- // fhEtaIsoConversion->SetXTitle("p_{T #gamma} (GeV/c)");
- // outputContainer->Add(fhEtaIsoConversion) ;
-
- fhPtIsoHadron = new TH1F("hPtMCHadron","Number of isolated non-#gamma particles",nptbins,ptmin,ptmax);
- fhPtIsoHadron->SetYTitle("N");
- fhPtIsoHadron->SetXTitle("p_{T}(GeV/c)");
- outputContainer->Add(fhPtIsoHadron) ;
-
-
- fhPhiIsoHadron = new TH2F
- ("hPhiMCHadron","Number of isolated non-#gamma particles",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
- fhPhiIsoHadron->SetYTitle("#phi");
- fhPhiIsoHadron->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPhiIsoHadron) ;
-
- fhEtaIsoHadron = new TH2F
- ("hEtaMCHadron","Number of isolated non-#gamma particles",nptbins,ptmin,ptmax,netabins,etamin,etamax);
- fhEtaIsoHadron->SetYTitle("#eta");
- fhEtaIsoHadron->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhEtaIsoHadron) ;
+ // For histograms in arrays, index in the array, corresponding to any particle origin
+
+ for(Int_t i = 0; i < 6; i++)
+ {
+ fhEPrimMC[i] = new TH1F(Form("hEPrim_MC%s",ppname[i].Data()),
+ Form("primary photon %s : #it{E}, %s",pptype[i].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhEPrimMC[i]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhEPrimMC[i]) ;
+
+ fhPtPrimMCiso[i] = new TH1F(Form("hPtPrim_MCiso%s",ppname[i].Data()),
+ Form("primary isolated photon %s : #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax);
+ fhPtPrimMCiso[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtPrimMCiso[i]) ;
+
+ fhEtaPrimMC[i] = new TH2F(Form("hEtaPrim_MC%s",ppname[i].Data()),
+ Form("primary photon %s : #eta vs #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax,200,-2,2);
+ fhEtaPrimMC[i]->SetYTitle("#eta");
+ fhEtaPrimMC[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhEtaPrimMC[i]) ;
+
+ fhPhiPrimMC[i] = new TH2F(Form("hPhiPrim_MC%s",ppname[i].Data()),
+ Form("primary photon %s : #phi vs #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
+ nptbins,ptmin,ptmax,200,0.,TMath::TwoPi());
+ fhPhiPrimMC[i]->SetYTitle("#phi");
+ fhPhiPrimMC[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPhiPrimMC[i]) ;
+ }
}//Histos with MC
}
- // Not Isolated histograms, reference histograms
-
- fhENoIso = new TH1F("hENoIso",
- Form("Number of not isolated leading particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- nptbins,ptmin,ptmax);
- fhENoIso->SetYTitle("N");
- fhENoIso->SetXTitle("E (GeV/c)");
- outputContainer->Add(fhENoIso) ;
-
- fhPtNoIso = new TH1F("hPtNoIso",
- Form("Number of not isolated leading particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- nptbins,ptmin,ptmax);
- fhPtNoIso->SetYTitle("N");
- fhPtNoIso->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIso) ;
-
- fhPtNLocMaxNoIso = new TH2F("hPtNLocMaxNoIso",
- Form("Number of not isolated particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f vs NLM, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- nptbins,ptmin,ptmax,10,0,10);
- fhPtNLocMaxNoIso->SetYTitle("NLM");
- fhPtNLocMaxNoIso->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNLocMaxNoIso) ;
-
- fhEtaPhiNoIso = new TH2F("hEtaPhiNoIso",
- Form("Number of not isolated leading particles #eta vs #phi for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhEtaPhiNoIso->SetXTitle("#eta");
- fhEtaPhiNoIso->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiNoIso) ;
-
- fhPtDecayNoIso = new TH1F("hPtDecayNoIso",
- Form("Number of not isolated leading pi0 decay particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- nptbins,ptmin,ptmax);
- fhPtDecayNoIso->SetYTitle("N");
- fhPtDecayNoIso->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtDecayNoIso) ;
-
- fhEtaPhiDecayNoIso = new TH2F("hEtaPhiDecayNoIso",
- Form("Number of not isolated leading Pi0 decay particles #eta vs #phi for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f",r,ptthre,ptfrac),
- netabins,etamin,etamax,nphibins,phimin,phimax);
- fhEtaPhiDecayNoIso->SetXTitle("#eta");
- fhEtaPhiDecayNoIso->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiDecayNoIso) ;
-
-
- if(IsDataMC())
- {
- fhPtNoIsoPi0 = new TH1F
- ("hPtNoIsoPi0","Number of not isolated leading #gamma from #pi^{0} (2 #gamma)",nptbins,ptmin,ptmax);
- fhPtNoIsoPi0->SetYTitle("N");
- fhPtNoIsoPi0->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoPi0) ;
-
- fhPtNoIsoPi0Decay = new TH1F
- ("hPtNoIsoPi0Decay","Number of not isolated leading #gamma from #pi^{0} decay",nptbins,ptmin,ptmax);
- fhPtNoIsoPi0Decay->SetYTitle("N");
- fhPtNoIsoPi0Decay->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoPi0Decay) ;
-
- fhPtNoIsoEtaDecay = new TH1F
- ("hPtNoIsoEtaDecay","Number of not isolated leading #gamma from eta decay",nptbins,ptmin,ptmax);
- fhPtNoIsoEtaDecay->SetYTitle("N");
- fhPtNoIsoEtaDecay->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoEtaDecay) ;
-
- fhPtNoIsoOtherDecay = new TH1F
- ("hPtNoIsoOtherDecay","Number of not isolated leading #gamma from other decay",nptbins,ptmin,ptmax);
- fhPtNoIsoOtherDecay->SetYTitle("N");
- fhPtNoIsoOtherDecay->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoOtherDecay) ;
-
- fhPtNoIsoPrompt = new TH1F
- ("hPtNoIsoPrompt","Number of not isolated leading prompt #gamma",nptbins,ptmin,ptmax);
- fhPtNoIsoPrompt->SetYTitle("N");
- fhPtNoIsoPrompt->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoPrompt) ;
-
- fhPtIsoMCPhoton = new TH1F
- ("hPtIsoMCPhoton","Number of isolated leading #gamma",nptbins,ptmin,ptmax);
- fhPtIsoMCPhoton->SetYTitle("N");
- fhPtIsoMCPhoton->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtIsoMCPhoton) ;
-
- fhPtNoIsoMCPhoton = new TH1F
- ("hPtNoIsoMCPhoton","Number of not isolated leading #gamma",nptbins,ptmin,ptmax);
- fhPtNoIsoMCPhoton->SetYTitle("N");
- fhPtNoIsoMCPhoton->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoMCPhoton) ;
-
-// fhPtNoIsoConversion = new TH1F
-// ("hPtNoIsoConversion","Number of not isolated leading conversion #gamma",nptbins,ptmin,ptmax);
-// fhPtNoIsoConversion->SetYTitle("N");
-// fhPtNoIsoConversion->SetXTitle("p_{T} (GeV/c)");
-// outputContainer->Add(fhPtNoIsoConversion) ;
-
- fhPtNoIsoFragmentation = new TH1F
- ("hPtNoIsoFragmentation","Number of not isolated leading fragmentation #gamma",nptbins,ptmin,ptmax);
- fhPtNoIsoFragmentation->SetYTitle("N");
- fhPtNoIsoFragmentation->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoFragmentation) ;
-
- fhPtNoIsoHadron = new TH1F
- ("hPtNoIsoHadron","Number of not isolated leading hadrons",nptbins,ptmin,ptmax);
- fhPtNoIsoHadron->SetYTitle("N");
- fhPtNoIsoHadron->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoHadron) ;
-
- }//Histos with MC
-
-
if(fMakeSeveralIC)
{
const Int_t buffersize = 255;
char name[buffersize];
char title[buffersize];
for(Int_t icone = 0; icone<fNCones; icone++)
- {
+ {
// sum pt in cone vs. pt leading
snprintf(name, buffersize,"hSumPtLeadingPt_Cone_%d",icone);
- snprintf(title, buffersize,"#Sigma p_{T} in isolation cone for R = %2.2f",fConeSizes[icone]);
+ snprintf(title, buffersize,"#Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",fConeSizes[icone]);
fhSumPtLeadingPt[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhSumPtLeadingPt[icone] ->SetYTitle("#sum_{cone}p_{T} (GeV/c)");//#Sigma p_{T}
- fhSumPtLeadingPt[icone] ->SetXTitle("p_{T}^{leading} (GeV/c)");
+ fhSumPtLeadingPt[icone] ->SetYTitle("#sum_{cone}#it{p}_{T} (GeV/#it{c})");//#Sigma #it{p}_{T}
+ fhSumPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
outputContainer->Add(fhSumPtLeadingPt[icone]) ;
-
- // pt in cone vs. pt leading
+
+ // pt in cone vs. pt leading
snprintf(name, buffersize,"hPtLeadingPt_Cone_%d",icone);
- snprintf(title, buffersize,"p_{T} in isolation cone for R = %2.2f",fConeSizes[icone]);
- fhPtLeadingPt[icone] = new TH2F(name, title, nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPtLeadingPt[icone] ->SetYTitle("p_{T}^{cone} (GeV/c)");
- fhPtLeadingPt[icone] ->SetXTitle("p_{T}^{leading} (GeV/c)");
- outputContainer->Add(fhPtLeadingPt[icone]) ;
-
- // sum pt in cone vs. pt leading in the forward region (for background subtraction studies)
- snprintf(name, buffersize,"hPerpSumPtLeadingPt_Cone_%d",icone);
- snprintf(title, buffersize,"#Sigma p_{T} in isolation cone for R = %2.2f",fConeSizes[icone]);
+ snprintf(title, buffersize,"#it{p}_{T} in isolation cone for #it{R} = %2.2f",fConeSizes[icone]);
+ fhPtLeadingPt[icone] = new TH2F(name, title, nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
+ fhPtLeadingPt[icone] ->SetYTitle("#it{p}_{T}^{cone} (GeV/#it{c})");
+ fhPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
+ outputContainer->Add(fhPtLeadingPt[icone]) ;
+
+ // sum pt in cone vs. pt leading in the forward region (for background subtraction studies)
+ snprintf(name, buffersize,"hPerpSumPtLeadingPt_Cone_%d",icone);
+ snprintf(title, buffersize,"#Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",fConeSizes[icone]);
fhPerpSumPtLeadingPt[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPerpSumPtLeadingPt[icone] ->SetYTitle("#sum_{cone}p_{T} (GeV/c)");//#Sigma p_{T}
- fhPerpSumPtLeadingPt[icone] ->SetXTitle("p_{T}^{leading} (GeV/c)");
+ fhPerpSumPtLeadingPt[icone] ->SetYTitle("#sum_{cone}#it{p}_{T} (GeV/#it{c})");//#Sigma #it{p}_{T}
+ fhPerpSumPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
outputContainer->Add(fhPerpSumPtLeadingPt[icone]) ;
- // pt in cone vs. pt leading in the forward region (for background subtraction studies)
- snprintf(name, buffersize,"hPerpPtLeadingPt_Cone_%d",icone);
- snprintf(title, buffersize,"p_{T} in isolation cone for R = %2.2f",fConeSizes[icone]);
- fhPerpPtLeadingPt[icone] = new TH2F(name, title, nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
- fhPerpPtLeadingPt[icone] ->SetYTitle("p_{T}^{cone} (GeV/c)");
- fhPerpPtLeadingPt[icone] ->SetXTitle("p_{T}^{leading} (GeV/c)");
- outputContainer->Add(fhPerpPtLeadingPt[icone]) ;
-
-
+ // pt in cone vs. pt leading in the forward region (for background subtraction studies)
+ snprintf(name, buffersize,"hPerpPtLeadingPt_Cone_%d",icone);
+ snprintf(title, buffersize,"#it{p}_{T} in isolation cone for #it{R} = %2.2f",fConeSizes[icone]);
+ fhPerpPtLeadingPt[icone] = new TH2F(name, title, nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
+ fhPerpPtLeadingPt[icone] ->SetYTitle("#it{p}_{T}^{cone} (GeV/#it{c})");
+ fhPerpPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
+ outputContainer->Add(fhPerpPtLeadingPt[icone]) ;
+
if(IsDataMC())
{
- snprintf(name, buffersize,"hPtSumPrompt_Cone_%d",icone);
- snprintf(title, buffersize,"Candidate Prompt cone sum p_{T} for R = %2.2f vs candidate p_{T}",fConeSizes[icone]);
- fhPtSumIsolatedPrompt[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPtSumIsolatedPrompt[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumIsolatedPrompt[icone]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumIsolatedPrompt[icone]) ;
-
- snprintf(name, buffersize,"hPtSumFragmentation_Cone_%d",icone);
- snprintf(title, buffersize,"Candidate Fragmentation cone sum p_{T} for R = %2.2fvs candidate p_{T}",fConeSizes[icone]);
- fhPtSumIsolatedFragmentation[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPtSumIsolatedFragmentation[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumIsolatedFragmentation[icone]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumIsolatedFragmentation[icone]) ;
-
- snprintf(name, buffersize,"hPtSumPi0_Cone_%d",icone);
- snprintf(title, buffersize,"Candidate Pi0 cone sum p_{T} for R = %2.2f vs candidate p_{T}",fConeSizes[icone]);
- fhPtSumIsolatedPi0[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPtSumIsolatedPi0[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumIsolatedPi0[icone]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumIsolatedPi0[icone]) ;
-
- snprintf(name, buffersize,"hPtSumPi0Decay_Cone_%d",icone);
- snprintf(title, buffersize,"Candidate Pi0Decay cone sum p_{T} for R = %2.2f vs candidate p_{T}",fConeSizes[icone]);
- fhPtSumIsolatedPi0Decay[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPtSumIsolatedPi0Decay[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumIsolatedPi0Decay[icone]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumIsolatedPi0Decay[icone]) ;
-
- snprintf(name, buffersize,"hPtSumEtaDecay_Cone_%d",icone);
- snprintf(title, buffersize,"Candidate EtaDecay cone sum p_{T} for R = %2.2f vs candidate p_{T}",fConeSizes[icone]);
- fhPtSumIsolatedEtaDecay[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPtSumIsolatedEtaDecay[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumIsolatedEtaDecay[icone]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumIsolatedEtaDecay[icone]) ;
-
- snprintf(name, buffersize,"hPtSumOtherDecay_Cone_%d",icone);
- snprintf(title, buffersize,"Candidate OtherDecay cone sum p_{T} for R = %2.2f vs candidate p_{T}",fConeSizes[icone]);
- fhPtSumIsolatedOtherDecay[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPtSumIsolatedOtherDecay[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumIsolatedOtherDecay[icone]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumIsolatedOtherDecay[icone]) ;
-
-// snprintf(name, buffersize,"hPtSumConversion_Cone_%d",icone);
-// snprintf(title, buffersize,"Candidate Conversion cone sum p_{T} for R = %2.2f vs candidate p_{T}",fConeSizes[icone]);
-// fhPtSumIsolatedConversion[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
-// fhPtSumIsolatedConversion[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
-// fhPtSumIsolatedConversion[icone]->SetXTitle("p_{T} (GeV/c)");
-// outputContainer->Add(fhPtSumIsolatedConversion[icone]) ;
-
- snprintf(name, buffersize,"hPtSumHadron_Cone_%d",icone);
- snprintf(title, buffersize,"Candidate Hadron cone sum p_{T} for R = %2.2f vs candidate p_{T}",fConeSizes[icone]);
- fhPtSumIsolatedHadron[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
- fhPtSumIsolatedHadron[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumIsolatedHadron[icone]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumIsolatedHadron[icone]) ;
-
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+ snprintf(name , buffersize,"hSumPtLeadingPt_MC%s_Cone_%d",mcPartName[imc].Data(),icone);
+ snprintf(title, buffersize,"Candidate %s #it{p}_{T} vs cone #Sigma #it{p}_{T} for #it{R}=%2.2f",mcPartType[imc].Data(),fConeSizes[icone]);
+ fhSumPtLeadingPtMC[imc][icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
+ fhSumPtLeadingPtMC[imc][icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
+ fhSumPtLeadingPtMC[imc][icone]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhSumPtLeadingPtMC[imc][icone]) ;
+ }
}//Histos with MC
for(Int_t ipt = 0; ipt<fNPtThresFrac;ipt++)
- {
-
+ {
snprintf(name, buffersize,"hPtThres_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate p_{T} distribution for R = %2.2f and p_{T}^{th} = %2.2f GeV/c",fConeSizes[icone],fPtThresholds[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for #it{R} = %2.2f and #it{p}_{T}^{th} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtThresholds[ipt]);
fhPtThresIsolated[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtThresIsolated[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtThresIsolated[icone][ipt]) ;
+ fhPtThresIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtThresIsolated[icone][ipt]) ;
snprintf(name, buffersize,"hPtFrac_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate p_{T} distribution for R = %2.2f and p_{T}^{fr} = %2.2f GeV/c",fConeSizes[icone],fPtFractions[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for #it{R} = %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
fhPtFracIsolated[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtFracIsolated[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracIsolated[icone][ipt]) ;
-
+ fhPtFracIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtFracIsolated[icone][ipt]) ;
- snprintf(name, buffersize,"hPtSum_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate p_{T} distribution for R = %2.2f and p_{T}^{sum} = %2.2f GeV/c",fConeSizes[icone],fSumPtThresholds[ipt]);
- fhPtSumIsolated[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- // fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumIsolated[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumIsolated[icone][ipt]) ;
+ snprintf(name, buffersize,"hSumPt_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for #it{R} = %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
+ fhSumPtIsolated[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
+ // fhSumPtIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
+ fhSumPtIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhSumPtIsolated[icone][ipt]) ;
snprintf(name, buffersize,"hPtSumDensity_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate p_{T} distribution for density in R = %2.2f and p_{T}^{sum} = %2.2f GeV/c",fConeSizes[icone],fSumPtThresholds[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for density in #it{R} = %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
fhPtSumDensityIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
- //fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumDensityIso[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
+ //fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
+ fhPtSumDensityIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtSumDensityIso[icone][ipt]) ;
snprintf(name, buffersize,"hPtFracPtSum_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate p_{T} distribution for PtFracPtSum in R = %2.2f and p_{T}^{fr} = %2.2f GeV/c",fConeSizes[icone],fPtFractions[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #it{p}_{T} distribution for PtFracPtSum in #it{R} = %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
fhPtFracPtSumIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
- //fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtFracPtSumIso[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
+ //fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
+ fhPtFracPtSumIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
outputContainer->Add(fhPtFracPtSumIso[icone][ipt]) ;
- // pt decays isolated
- snprintf(name, buffersize,"hPtThres_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate p_{T} distribution for R = %2.2f and p_{T}^{th} = %2.2f GeV/c",fConeSizes[icone],fPtThresholds[ipt]);
- fhPtPtThresDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtPtThresDecayIso[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtPtThresDecayIso[icone][ipt]) ;
-
- snprintf(name, buffersize,"hPtFrac_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate p_{T} distribution for R = %2.2f and p_{T}^{fr} = %2.2f GeV/c",fConeSizes[icone],fPtFractions[ipt]);
- fhPtPtFracDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtPtFracDecayIso[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtPtFracDecayIso[icone][ipt]) ;
-
- snprintf(name, buffersize,"hPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate p_{T} distribution for R = %2.2f and p_{T}^{sum} = %2.2f GeV/c",fConeSizes[icone],fSumPtThresholds[ipt]);
- fhPtPtSumDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
- // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtPtSumDecayIso[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtPtSumDecayIso[icone][ipt]) ;
-
- snprintf(name, buffersize,"hPtSumDensity_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate p_{T} distribution for density in R = %2.2f and p_{T}^{sum} = %2.2f GeV/c",fConeSizes[icone],fSumPtThresholds[ipt]);
- fhPtSumDensityDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
- // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtSumDensityDecayIso[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtSumDensityDecayIso[icone][ipt]) ;
-
- snprintf(name, buffersize,"hPtFracPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate p_{T} distribution for PtFracPtSum in R = %2.2f and p_{T}^{fr} = %2.2f GeV/c",fConeSizes[icone],fPtFractions[ipt]);
- fhPtFracPtSumDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
- // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma p_{T} (GeV/c)");
- fhPtFracPtSumDecayIso[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracPtSumDecayIso[icone][ipt]) ;
-
-
// eta:phi
snprintf(name, buffersize,"hEtaPhiPtThres_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for R = %2.2f and p_{T}^{th} = %2.2f GeV/c",fConeSizes[icone],fPtThresholds[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for #it{R} = %2.2f and #it{p}_{T}^{th} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtThresholds[ipt]);
fhEtaPhiPtThresIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiPtThresIso[icone][ipt]->SetXTitle("#eta");
fhEtaPhiPtThresIso[icone][ipt]->SetYTitle("#phi");
outputContainer->Add(fhEtaPhiPtThresIso[icone][ipt]) ;
snprintf(name, buffersize,"hEtaPhiPtFrac_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for R = %2.2f and p_{T}^{fr} = %2.2f GeV/c",fConeSizes[icone],fPtFractions[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for #it{R} = %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
fhEtaPhiPtFracIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiPtFracIso[icone][ipt]->SetXTitle("#eta");
fhEtaPhiPtFracIso[icone][ipt]->SetYTitle("#phi");
outputContainer->Add(fhEtaPhiPtFracIso[icone][ipt]) ;
snprintf(name, buffersize,"hEtaPhiPtSum_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for R = %2.2f and p_{T}^{sum} = %2.2f GeV/c",fConeSizes[icone],fSumPtThresholds[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for #it{R} = %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
fhEtaPhiPtSumIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiPtSumIso[icone][ipt]->SetXTitle("#eta");
fhEtaPhiPtSumIso[icone][ipt]->SetYTitle("#phi");
outputContainer->Add(fhEtaPhiPtSumIso[icone][ipt]) ;
snprintf(name, buffersize,"hEtaPhiSumDensity_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for density R = %2.2f and p_{T}^{sum} = %2.2f GeV/c",fConeSizes[icone],fSumPtThresholds[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for density #it{R} = %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
fhEtaPhiSumDensityIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiSumDensityIso[icone][ipt]->SetXTitle("#eta");
fhEtaPhiSumDensityIso[icone][ipt]->SetYTitle("#phi");
outputContainer->Add(fhEtaPhiSumDensityIso[icone][ipt]) ;
snprintf(name, buffersize,"hEtaPhiFracPtSum_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for FracPtSum R = %2.2f and p_{T}^{fr} = %2.2f GeV/c",fConeSizes[icone],fPtFractions[ipt]);
+ snprintf(title, buffersize,"Isolated candidate #eta:#phi distribution for FracPtSum #it{R} = %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
fhEtaPhiFracPtSumIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
fhEtaPhiFracPtSumIso[icone][ipt]->SetXTitle("#eta");
fhEtaPhiFracPtSumIso[icone][ipt]->SetYTitle("#phi");
outputContainer->Add(fhEtaPhiFracPtSumIso[icone][ipt]) ;
- // eta:phi decays
- snprintf(name, buffersize,"hEtaPhiPtThres_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for R = %2.2f and p_{T}^{th} = %2.2f GeV/c",fConeSizes[icone],fPtThresholds[ipt]);
- fhEtaPhiPtThresDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
- fhEtaPhiPtThresDecayIso[icone][ipt]->SetXTitle("#eta");
- fhEtaPhiPtThresDecayIso[icone][ipt]->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiPtThresDecayIso[icone][ipt]) ;
-
- snprintf(name, buffersize,"hEtaPhiPtFrac_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for R = %2.2f and p_{T}^{fr} = %2.2f GeV/c",fConeSizes[icone],fPtFractions[ipt]);
- fhEtaPhiPtFracDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
- fhEtaPhiPtFracDecayIso[icone][ipt]->SetXTitle("#eta");
- fhEtaPhiPtFracDecayIso[icone][ipt]->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiPtFracDecayIso[icone][ipt]) ;
-
-
- snprintf(name, buffersize,"hEtaPhiPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for R = %2.2f and p_{T}^{sum} = %2.2f GeV/c",fConeSizes[icone],fSumPtThresholds[ipt]);
- fhEtaPhiPtSumDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
- fhEtaPhiPtSumDecayIso[icone][ipt]->SetXTitle("#eta");
- fhEtaPhiPtSumDecayIso[icone][ipt]->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiPtSumDecayIso[icone][ipt]) ;
-
- snprintf(name, buffersize,"hEtaPhiSumDensity_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for density R = %2.2f and p_{T}^{sum} = %2.2f GeV/c",fConeSizes[icone],fSumPtThresholds[ipt]);
- fhEtaPhiSumDensityDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
- fhEtaPhiSumDensityDecayIso[icone][ipt]->SetXTitle("#eta");
- fhEtaPhiSumDensityDecayIso[icone][ipt]->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiSumDensityDecayIso[icone][ipt]) ;
-
- snprintf(name, buffersize,"hEtaPhiFracPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for FracPtSum R = %2.2f and p_{T}^{fr} = %2.2f GeV/c",fConeSizes[icone],fPtFractions[ipt]);
- fhEtaPhiFracPtSumDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
- fhEtaPhiFracPtSumDecayIso[icone][ipt]->SetXTitle("#eta");
- fhEtaPhiFracPtSumDecayIso[icone][ipt]->SetYTitle("#phi");
- outputContainer->Add(fhEtaPhiFracPtSumDecayIso[icone][ipt]) ;
-
-
- if(IsDataMC())
+ if(fFillTaggedDecayHistograms)
{
- snprintf(name, buffersize,"hPtThresMCPrompt_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Prompt p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtThresIsolatedPrompt[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtThresIsolatedPrompt[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtThresIsolatedPrompt[icone][ipt]) ;
-
- snprintf(name, buffersize,"hPtFracMCPrompt_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Prompt p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtFracIsolatedPrompt[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtFracIsolatedPrompt[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracIsolatedPrompt[icone][ipt]) ;
+ // pt decays isolated
+ snprintf(name, buffersize,"hPtThres_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for #it{R} = %2.2f and #it{p}_{T}^{th} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtThresholds[ipt]);
+ fhPtPtThresDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
+ fhPtPtThresDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtPtThresDecayIso[icone][ipt]) ;
- snprintf(name, buffersize,"hPtThresMCFragmentation_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Fragmentation p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtThresIsolatedFragmentation[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtThresIsolatedFragmentation[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtThresIsolatedFragmentation[icone][ipt]) ;
+ snprintf(name, buffersize,"hPtFrac_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for #it{R} = %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
+ fhPtPtFracDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
+ fhPtPtFracDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtPtFracDecayIso[icone][ipt]) ;
- snprintf(name, buffersize,"hPtFracMCFragmentation_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Fragmentation p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtFracIsolatedFragmentation[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtFracIsolatedFragmentation[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracIsolatedFragmentation[icone][ipt]) ;
+ snprintf(name, buffersize,"hPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for #it{R} = %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
+ fhPtPtSumDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
+ // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
+ fhPtPtSumDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtPtSumDecayIso[icone][ipt]) ;
- snprintf(name, buffersize,"hPtThresMCPi0_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Pi0 p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtThresIsolatedPi0[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtThresIsolatedPi0[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtThresIsolatedPi0[icone][ipt]) ;
+ snprintf(name, buffersize,"hPtSumDensity_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for density in #it{R} = %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
+ fhPtSumDensityDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
+ // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
+ fhPtSumDensityDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtSumDensityDecayIso[icone][ipt]) ;
- snprintf(name, buffersize,"hPtFracMCPi0_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Pi0 p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtFracIsolatedPi0[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtFracIsolatedPi0[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracIsolatedPi0[icone][ipt]) ;
+ snprintf(name, buffersize,"hPtFracPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #it{p}_{T} distribution for PtFracPtSum in #it{R} = %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
+ fhPtFracPtSumDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
+ // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
+ fhPtFracPtSumDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtFracPtSumDecayIso[icone][ipt]) ;
- snprintf(name, buffersize,"hPtThresMCPi0Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Pi0Decay p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtThresIsolatedPi0Decay[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtThresIsolatedPi0Decay[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtThresIsolatedPi0Decay[icone][ipt]) ;
+ // eta:phi decays
+ snprintf(name, buffersize,"hEtaPhiPtThres_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for #it{R} = %2.2f and #it{p}_{T}^{th} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtThresholds[ipt]);
+ fhEtaPhiPtThresDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhEtaPhiPtThresDecayIso[icone][ipt]->SetXTitle("#eta");
+ fhEtaPhiPtThresDecayIso[icone][ipt]->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiPtThresDecayIso[icone][ipt]) ;
- snprintf(name, buffersize,"hPtFracMCPi0Decay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Pi0Decay p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtFracIsolatedPi0Decay[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtFracIsolatedPi0Decay[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracIsolatedPi0Decay[icone][ipt]) ;
+ snprintf(name, buffersize,"hEtaPhiPtFrac_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for #it{R} = %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
+ fhEtaPhiPtFracDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhEtaPhiPtFracDecayIso[icone][ipt]->SetXTitle("#eta");
+ fhEtaPhiPtFracDecayIso[icone][ipt]->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiPtFracDecayIso[icone][ipt]) ;
- snprintf(name, buffersize,"hPtThresMCEtaDecay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate EtaDecay p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtThresIsolatedEtaDecay[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtThresIsolatedEtaDecay[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtThresIsolatedEtaDecay[icone][ipt]) ;
- snprintf(name, buffersize,"hPtFracMCEtaDecay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate EtaDecay p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtFracIsolatedEtaDecay[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtFracIsolatedEtaDecay[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracIsolatedEtaDecay[icone][ipt]) ;
+ snprintf(name, buffersize,"hEtaPhiPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for #it{R} = %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
+ fhEtaPhiPtSumDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhEtaPhiPtSumDecayIso[icone][ipt]->SetXTitle("#eta");
+ fhEtaPhiPtSumDecayIso[icone][ipt]->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiPtSumDecayIso[icone][ipt]) ;
+ snprintf(name, buffersize,"hEtaPhiSumDensity_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for density #it{R} = %2.2f and #it{p}_{T}^{sum} = %2.2f GeV/#it{c}",fConeSizes[icone],fSumPtThresholds[ipt]);
+ fhEtaPhiSumDensityDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhEtaPhiSumDensityDecayIso[icone][ipt]->SetXTitle("#eta");
+ fhEtaPhiSumDensityDecayIso[icone][ipt]->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiSumDensityDecayIso[icone][ipt]) ;
- snprintf(name, buffersize,"hPtThresMCOtherDecay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate OtherDecay p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtThresIsolatedOtherDecay[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtThresIsolatedOtherDecay[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtThresIsolatedOtherDecay[icone][ipt]) ;
-
- snprintf(name, buffersize,"hPtFracMCOtherDecay_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate OtherDecay p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtFracIsolatedOtherDecay[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtFracIsolatedOtherDecay[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracIsolatedOtherDecay[icone][ipt]) ;
-
-// snprintf(name, buffersize,"hPtThresMCConversion_Cone_%d_Pt%d",icone,ipt);
-// snprintf(title, buffersize,"Isolated candidate Conversion p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
-// fhPtThresIsolatedConversion[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
-// fhPtThresIsolatedConversion[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
-// outputContainer->Add(fhPtThresIsolatedConversion[icone][ipt]) ;
-
-// snprintf(name, buffersize,"hPtFracMCConversion_Cone_%d_Pt%d",icone,ipt);
-// snprintf(title, buffersize,"Isolated candidate Conversion p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
-// fhPtFracIsolatedConversion[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
-// fhPtFracIsolatedConversion[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
-// outputContainer->Add(fhPtFracIsolatedConversion[icone][ipt]) ;
-
- snprintf(name, buffersize,"hPtThresMCHadron_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Hadron p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtThresIsolatedHadron[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtThresIsolatedHadron[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtThresIsolatedHadron[icone][ipt]) ;
-
- snprintf(name, buffersize,"hPtFracMCHadron_Cone_%d_Pt%d",icone,ipt);
- snprintf(title, buffersize,"Isolated candidate Hadron p_{T} distribution for cone size %d and p_{T}^{th} %d",icone,ipt);
- fhPtFracIsolatedHadron[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
- fhPtFracIsolatedHadron[icone][ipt]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtFracIsolatedHadron[icone][ipt]) ;
+ snprintf(name, buffersize,"hEtaPhiFracPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
+ snprintf(title, buffersize,"Isolated decay candidate #eta:#phi distribution for FracPtSum #it{R} = %2.2f and #it{p}_{T}^{fr} = %2.2f GeV/#it{c}",fConeSizes[icone],fPtFractions[ipt]);
+ fhEtaPhiFracPtSumDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
+ fhEtaPhiFracPtSumDecayIso[icone][ipt]->SetXTitle("#eta");
+ fhEtaPhiFracPtSumDecayIso[icone][ipt]->SetYTitle("#phi");
+ outputContainer->Add(fhEtaPhiFracPtSumDecayIso[icone][ipt]) ;
+ }
+
+ if(IsDataMC())
+ {
+ for(Int_t imc = 0; imc < 9; imc++)
+ {
+ snprintf(name , buffersize,"hPtThreshMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
+ snprintf(title, buffersize,"Isolated %s #it{p}_{T} for #it{R}=%2.2f and #it{p}_{T}^{th}=%2.2f",
+ mcPartType[imc].Data(),fConeSizes[icone], fPtThresholds[ipt]);
+ fhPtThresIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
+ fhPtThresIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
+ fhPtThresIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPtThresIsolatedMC[imc][icone][ipt]) ;
+
+
+ snprintf(name , buffersize,"hPtFracMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
+ snprintf(title, buffersize,"Isolated %s #it{p}_{T} for #it{R}=%2.2f and #Sigma #it{p}_{T}^{in cone}/#it{p}_{T}^{trig}=%2.2f",
+ mcPartType[imc].Data(),fConeSizes[icone], fPtFractions[ipt]);
+ fhPtFracIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
+ fhPtFracIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
+ fhPtFracIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhPtFracIsolatedMC[imc][icone][ipt]) ;
+
+ snprintf(name , buffersize,"hSumPtMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
+ snprintf(title, buffersize,"Isolated %s #it{p}_{T} for #it{R}=%2.2f and #Sigma #it{p}_{T}^{in cone}=%2.2f",
+ mcPartType[imc].Data(),fConeSizes[icone], fSumPtThresholds[ipt]);
+ fhSumPtIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
+ fhSumPtIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
+ fhSumPtIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
+ outputContainer->Add(fhSumPtIsolatedMC[imc][icone][ipt]) ;
+ }
}//Histos with MC
}//icone loop
}//ipt loop
for (Int_t i = 0; i < 7 ; i++)
{
fhEIsoPileUp[i] = new TH1F(Form("hEPileUp%s",pileUpName[i].Data()),
- Form("Number of isolated particles vs E for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f, pile-up event by %s",r,ptthre,ptfrac,pileUpName[i].Data()),
- nptbins,ptmin,ptmax);
- fhEIsoPileUp[i]->SetYTitle("dN / dE");
- fhEIsoPileUp[i]->SetXTitle("E (GeV)");
- outputContainer->Add(fhEIsoPileUp[i]) ;
+ Form("Number of isolated particles vs E, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
+ nptbins,ptmin,ptmax);
+ fhEIsoPileUp[i]->SetYTitle("d#it{N} / d#it{E}");
+ fhEIsoPileUp[i]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhEIsoPileUp[i]) ;
fhPtIsoPileUp[i] = new TH1F(Form("hPtPileUp%s",pileUpName[i].Data()),
- Form("Number of isolated particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr}= %2.2f, pile-up event by %s ",r,ptthre,ptfrac,pileUpName[i].Data()),
- nptbins,ptmin,ptmax);
- fhPtIsoPileUp[i]->SetYTitle("dN / p_{T}");
- fhPtIsoPileUp[i]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtIsoPileUp[i]) ;
+ Form("Number of isolated particles vs #it{p}_{T}, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
+ nptbins,ptmin,ptmax);
+ fhPtIsoPileUp[i]->SetYTitle("d#it{N} / #it{p}_{T}");
+ fhPtIsoPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtIsoPileUp[i]) ;
fhENoIsoPileUp[i] = new TH1F(Form("hENoIsoPileUp%s",pileUpName[i].Data()),
- Form("Number of not isolated particles vs E for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr} = %2.2f, pile-up event by %s",r,ptthre,ptfrac,pileUpName[i].Data()),
- nptbins,ptmin,ptmax);
- fhENoIsoPileUp[i]->SetYTitle("dN / dE");
- fhENoIsoPileUp[i]->SetXTitle("E (GeV)");
- outputContainer->Add(fhENoIsoPileUp[i]) ;
+ Form("Number of not isolated particles vs E, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
+ nptbins,ptmin,ptmax);
+ fhENoIsoPileUp[i]->SetYTitle("d#it{N} / dE");
+ fhENoIsoPileUp[i]->SetXTitle("#it{E} (GeV)");
+ outputContainer->Add(fhENoIsoPileUp[i]) ;
fhPtNoIsoPileUp[i] = new TH1F(Form("hPtNoIsoPileUp%s",pileUpName[i].Data()),
- Form("Number of not isolated particles vs p_{T} for R = %2.2f, p_{T}^{th} = %2.2f, p_{T}^{fr}= %2.2f, pile-up event by %s ",r,ptthre,ptfrac,pileUpName[i].Data()),
- nptbins,ptmin,ptmax);
- fhPtNoIsoPileUp[i]->SetYTitle("dN / p_{T}");
- fhPtNoIsoPileUp[i]->SetXTitle("p_{T} (GeV/c)");
- outputContainer->Add(fhPtNoIsoPileUp[i]) ;
+ Form("Number of not isolated particles vs #it{p}_{T}, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
+ nptbins,ptmin,ptmax);
+ fhPtNoIsoPileUp[i]->SetYTitle("d#it{N} / #it{p}_{T}");
+ fhPtNoIsoPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
+ outputContainer->Add(fhPtNoIsoPileUp[i]) ;
}
- fhTimeENoCut = new TH2F ("hTimeE_NoCut","time of cluster vs E of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeENoCut->SetXTitle("E (GeV)");
- fhTimeENoCut->SetYTitle("time (ns)");
- outputContainer->Add(fhTimeENoCut);
+ fhTimeENoCut = new TH2F ("hTimeE_NoCut","time of cluster vs E of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+ fhTimeENoCut->SetXTitle("#it{E} (GeV)");
+ fhTimeENoCut->SetYTitle("#it{time} (ns)");
+ outputContainer->Add(fhTimeENoCut);
- fhTimeESPD = new TH2F ("hTimeE_SPD","time of cluster vs E of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeESPD->SetXTitle("E (GeV)");
- fhTimeESPD->SetYTitle("time (ns)");
- outputContainer->Add(fhTimeESPD);
+ fhTimeESPD = new TH2F ("hTimeE_SPD","time of cluster vs E of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+ fhTimeESPD->SetXTitle("#it{E} (GeV)");
+ fhTimeESPD->SetYTitle("#it{time} (ns)");
+ outputContainer->Add(fhTimeESPD);
- fhTimeESPDMulti = new TH2F ("hTimeE_SPDMulti","time of cluster vs E of clusters, SPD multi cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
- fhTimeESPDMulti->SetXTitle("E (GeV)");
- fhTimeESPDMulti->SetYTitle("time (ns)");
- outputContainer->Add(fhTimeESPDMulti);
+ fhTimeESPDMulti = new TH2F ("hTimeE_SPDMulti","time of cluster vs E of clusters, SPD multi cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+ fhTimeESPDMulti->SetXTitle("#it{E} (GeV)");
+ fhTimeESPDMulti->SetYTitle("#it{time} (ns)");
+ outputContainer->Add(fhTimeESPDMulti);
- fhTimeNPileUpVertSPD = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
+ fhTimeNPileUpVertSPD = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
fhTimeNPileUpVertSPD->SetYTitle("# vertex ");
- fhTimeNPileUpVertSPD->SetXTitle("time (ns)");
- outputContainer->Add(fhTimeNPileUpVertSPD);
+ fhTimeNPileUpVertSPD->SetXTitle("#it{time} (ns)");
+ outputContainer->Add(fhTimeNPileUpVertSPD);
- fhTimeNPileUpVertTrack = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 50,0,50 );
+ fhTimeNPileUpVertTrack = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 50,0,50 );
fhTimeNPileUpVertTrack->SetYTitle("# vertex ");
- fhTimeNPileUpVertTrack->SetXTitle("time (ns)");
- outputContainer->Add(fhTimeNPileUpVertTrack);
+ fhTimeNPileUpVertTrack->SetXTitle("#it{time} (ns)");
+ outputContainer->Add(fhTimeNPileUpVertTrack);
- fhTimeNPileUpVertContributors = new TH2F ("hTime_NPileUpVertContributors","time of cluster vs N constributors to pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
+ fhTimeNPileUpVertContributors = new TH2F ("hTime_NPileUpVertContributors","time of cluster vs N constributors to pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
fhTimeNPileUpVertContributors->SetYTitle("# vertex ");
- fhTimeNPileUpVertContributors->SetXTitle("time (ns)");
- outputContainer->Add(fhTimeNPileUpVertContributors);
-
- fhTimePileUpMainVertexZDistance = new TH2F ("hTime_PileUpMainVertexZDistance","time of cluster vs distance in Z pile-up SPD vertex - main SPD vertex",ntimebins,timemin,timemax,100,0,50);
- fhTimePileUpMainVertexZDistance->SetYTitle("distance Z (cm) ");
- fhTimePileUpMainVertexZDistance->SetXTitle("time (ns)");
- outputContainer->Add(fhTimePileUpMainVertexZDistance);
-
- fhTimePileUpMainVertexZDiamond = new TH2F ("hTime_PileUpMainVertexZDiamond","time of cluster vs distance in Z pile-up SPD vertex - z diamond",ntimebins,timemin,timemax,100,0,50);
- fhTimePileUpMainVertexZDiamond->SetYTitle("diamond distance Z (cm) ");
- fhTimePileUpMainVertexZDiamond->SetXTitle("time (ns)");
- outputContainer->Add(fhTimePileUpMainVertexZDiamond);
+ fhTimeNPileUpVertContributors->SetXTitle("#it{time} (ns)");
+ outputContainer->Add(fhTimeNPileUpVertContributors);
+
+ fhTimePileUpMainVertexZDistance = new TH2F ("hTime_PileUpMainVertexZDistance","time of cluster vs distance in Z pile-up SPD vertex - main SPD vertex",ntimebins,timemin,timemax,100,0,50);
+ fhTimePileUpMainVertexZDistance->SetYTitle("distance #it{z} (cm) ");
+ fhTimePileUpMainVertexZDistance->SetXTitle("#it{time} (ns)");
+ outputContainer->Add(fhTimePileUpMainVertexZDistance);
+
+ fhTimePileUpMainVertexZDiamond = new TH2F ("hTime_PileUpMainVertexZDiamond","time of cluster vs distance in Z pile-up SPD vertex - z diamond",ntimebins,timemin,timemax,100,0,50);
+ fhTimePileUpMainVertexZDiamond->SetYTitle("diamond distance #it{z} (cm) ");
+ fhTimePileUpMainVertexZDiamond->SetXTitle("#it{time} (ns)");
+ outputContainer->Add(fhTimePileUpMainVertexZDiamond);
}
return outputContainer ;
}
+//____________________________________________________
+Int_t AliAnaParticleIsolation::GetMCIndex(Int_t mcTag)
+{
+ // Histogram index depending on origin of candidate
+
+ if(!IsDataMC()) return -1;
+
+ if (GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt))
+ {
+ return kmcPrompt;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation) ||
+ GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCISR))
+ {
+ return kmcFragment;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0))
+ {
+ return kmcPi0;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay))
+ {
+ return kmcPi0Decay;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay))
+ {
+ return kmcEtaDecay;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay))
+ {
+ return kmcOtherDecay;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron))
+ {
+ return kmcElectron;
+ }
+ else // anything else
+ {
+ // careful can contain also other decays, to be checked.
+ return kmcHadron;
+ }
+}
+
//__________________________________
void AliAnaParticleIsolation::Init()
{
// Do some checks and init stuff
- // In case of several cone and thresholds analysis, open the cuts for the filling of the
- // track and cluster reference arrays in cone when done in the MakeAnalysisFillAOD().
+ // In case of several cone and thresholds analysis, open the cuts for the filling of the
+ // track and cluster reference arrays in cone when done in the MakeAnalysisFillAOD().
// The different cones, thresholds are tested for this list of tracks, clusters.
if(fMakeSeveralIC)
{
GetIsolationCut()->SetPtFraction(100);
GetIsolationCut()->SetConeSize(1);
}
+
+ if(!GetReader()->IsCTSSwitchedOn() && GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyNeutral)
+ AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!\n");
+
}
//____________________________________________
//Initialize the parameters of the analysis.
SetInputAODName("PWG4Particle");
- SetAODObjArrayName("IsolationCone");
+ SetAODObjArrayName("IsolationCone");
AddToHistogramsName("AnaIsolation_");
- fCalorimeter = "PHOS" ;
+ fCalorimeter = "EMCAL" ;
+ fIsoDetector = "EMCAL" ;
+
fReMakeIC = kFALSE ;
fMakeSeveralIC = kFALSE ;
+ fLeadingOnly = kTRUE;
+ fCheckLeadingWithNeutralClusters = kTRUE;
+
+ fNDecayBits = 1;
+ fDecayBits[0] = AliNeutralMesonSelection::kPi0;
+ fDecayBits[1] = AliNeutralMesonSelection::kEta;
+ fDecayBits[2] = AliNeutralMesonSelection::kPi0Side;
+ fDecayBits[3] = AliNeutralMesonSelection::kEtaSide;
+
+ fNBkgBin = 11;
+ fBkgBinLimit[ 0] = 00.0; fBkgBinLimit[ 1] = 00.2; fBkgBinLimit[ 2] = 00.3; fBkgBinLimit[ 3] = 00.4; fBkgBinLimit[ 4] = 00.5;
+ fBkgBinLimit[ 5] = 01.0; fBkgBinLimit[ 6] = 01.5; fBkgBinLimit[ 7] = 02.0; fBkgBinLimit[ 8] = 03.0; fBkgBinLimit[ 9] = 05.0;
+ fBkgBinLimit[10] = 10.0; fBkgBinLimit[11] = 100.;
+ for(Int_t ibin = 12; ibin < 20; ibin++) fBkgBinLimit[ibin] = 00.0;
+
//----------- Several IC-----------------
- fNCones = 5 ;
- fNPtThresFrac = 5 ;
+ fNCones = 5 ;
+ fNPtThresFrac = 5 ;
fConeSizes [0] = 0.1; fConeSizes [1] = 0.2; fConeSizes [2] = 0.3; fConeSizes [3] = 0.4; fConeSizes [4] = 0.5;
- fPtThresholds [0] = 1.; fPtThresholds [1] = 2.; fPtThresholds [2] = 3.; fPtThresholds [3] = 4.; fPtThresholds [4] = 5.;
- fPtFractions [0] = 0.05; fPtFractions [1] = 0.075; fPtFractions [2] = 0.1; fPtFractions [3] = 1.25; fPtFractions [4] = 1.5;
- fSumPtThresholds[0] = 1.; fSumPtThresholds[1] = 2.; fSumPtThresholds[2] = 3.; fSumPtThresholds[3] = 4.; fSumPtThresholds[4] = 5.;
+ fPtThresholds [0] = 1.; fPtThresholds [1] = 2.; fPtThresholds [2] = 3.; fPtThresholds [3] = 4.; fPtThresholds [4] = 5.;
+ fPtFractions [0] = 0.05; fPtFractions [1] = 0.075; fPtFractions [2] = 0.1; fPtFractions [3] = 1.25; fPtFractions [4] = 1.5;
+ fSumPtThresholds[0] = 1.; fSumPtThresholds[1] = 2.; fSumPtThresholds[2] = 3.; fSumPtThresholds[3] = 4.; fSumPtThresholds[4] = 5.;
+
+}
+
+//_________________________________________________________________________________________
+Bool_t AliAnaParticleIsolation::IsTriggerTheNearSideEventLeadingParticle(Int_t & idLeading)
+{
+ // Check if the what of the selected isolation candidates is leading particle in the same hemisphere
+ // comparing with all the candidates, all the tracks or all the clusters.
+
+ Double_t ptTrig = GetMinPt();
+ Double_t phiTrig = 0 ;
+ Int_t index =-1 ;
+ AliAODPWG4ParticleCorrelation* pLeading = 0;
+
+ // Loop on stored AOD particles, find leading trigger on the selected list, with at least min pT.
+
+ for(Int_t iaod = 0; iaod < GetInputAODBranch()->GetEntriesFast() ; iaod++)
+ {
+ AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
+ particle->SetLeadingParticle(kFALSE); // set it later
+
+ // Vertex cut in case of mixing
+ if(GetMixedEvent())
+ {
+ Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
+ if(check == 0) continue;
+ if(check == -1) return kFALSE; // not sure if it is correct.
+ }
+
+ //check if it is low pt trigger particle
+ if((particle->Pt() < GetIsolationCut()->GetPtThreshold() ||
+ particle->Pt() < GetIsolationCut()->GetSumPtThreshold()) &&
+ !fMakeSeveralIC)
+ {
+ continue ; //trigger should not come from underlying event
+ }
+
+ // find the leading particles with highest momentum
+ if (particle->Pt() > ptTrig)
+ {
+ ptTrig = particle->Pt() ;
+ phiTrig = particle->Phi();
+ index = iaod ;
+ pLeading = particle ;
+ }
+ }// finish search of leading trigger particle on the AOD branch.
+
+ if(index < 0) return kFALSE;
+
+ idLeading = index;
+
+ //printf("AOD leading pT %2.2f, ID %d\n", pLeading->Pt(),pLeading->GetCaloLabel(0));
+
+ if(phiTrig < 0 ) phiTrig += TMath::TwoPi();
+
+ // Compare if it is the leading of all tracks
+
+ TVector3 p3;
+ for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
+ {
+ AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
+
+ if(track->GetID() == pLeading->GetTrackLabel(0) || track->GetID() == pLeading->GetTrackLabel(1) ||
+ track->GetID() == pLeading->GetTrackLabel(2) || track->GetID() == pLeading->GetTrackLabel(3) ) continue ;
+
+ Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
+ p3.SetXYZ(mom[0],mom[1],mom[2]);
+ Float_t pt = p3.Pt();
+ Float_t phi = p3.Phi() ;
+ if(phi < 0) phi+=TMath::TwoPi();
+
+ //skip this event if near side associated particle pt larger than trigger
+
+ Float_t deltaPhi = phiTrig-phi;
+ //
+ // Calculate deltaPhi shift so that for the particles on the opposite side
+ // it is defined between 90 and 270 degrees
+ // Shift [-360,-90] to [0, 270]
+ // and [270,360] to [-90,0]
+ if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
+ if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
+
+ if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE;
+
+ }// track loop
+
+ // Compare if it is leading of all calorimeter clusters
+
+ if(fCheckLeadingWithNeutralClusters)
+ {
+ // Select the calorimeter cluster list
+ TObjArray * nePl = 0x0;
+ if (pLeading->GetDetector() == "PHOS" )
+ nePl = GetPHOSClusters();
+ else
+ nePl = GetEMCALClusters();
+
+ if(!nePl) return kTRUE; // Do the selection just with the tracks if no calorimeter is available.
+
+ TLorentzVector lv;
+ for(Int_t ipr = 0;ipr < nePl->GetEntriesFast() ; ipr ++ )
+ {
+ AliVCluster * cluster = (AliVCluster *) (nePl->At(ipr)) ;
+
+ if(cluster->GetID() == pLeading->GetCaloLabel(0) || cluster->GetID() == pLeading->GetCaloLabel(1) ) continue ;
+
+ cluster->GetMomentum(lv,GetVertex(0));
+
+ Float_t pt = lv.Pt();
+ Float_t phi = lv.Phi() ;
+ if(phi < 0) phi+=TMath::TwoPi();
+
+ if(IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ; // avoid charged clusters, already covered by tracks, or cluster merging with track.
+
+ // skip this event if near side associated particle pt larger than trigger
+ // not really needed for calorimeter, unless DCal is included
+
+ Float_t deltaPhi = phiTrig-phi;
+ if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
+ if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
+
+ if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE ;
+
+ }// cluster loop
+ } // check neutral clusters
+
+ idLeading = index ;
+ pLeading->SetLeadingParticle(kTRUE);
- //------------- Histograms settings -------
- fHistoNPtSumBins = 100 ;
- fHistoPtSumMax = 50 ;
- fHistoPtSumMin = 0. ;
+ if( GetDebug() > 1 )
+ printf("AliAnaParticleIsolation::IsTriggerTheNearSideEventLeadingParticle() - Particle AOD with index %d is leading with pT %2.2f\n",
+ idLeading, pLeading->Pt());
- fHistoNPtInConeBins = 100 ;
- fHistoPtInConeMax = 50 ;
- fHistoPtInConeMin = 0. ;
+ return kTRUE;
}
//__________________________________________________
-void AliAnaParticleIsolation::MakeAnalysisFillAOD()
+void AliAnaParticleIsolation::MakeAnalysisFillAOD()
{
- //Do analysis and fill aods
- //Search for the isolated photon in fCalorimeter with pt > GetMinPt()
+ // Do analysis and fill aods
+ // Search for the isolated photon in fCalorimeter with GetMinPt() < pt < GetMaxPt()
+ // and if the particle is leading in the near side (if requested)
if(!GetInputAODBranch())
- {
- printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - No input particles in AOD with name branch < %s >, STOP \n",GetInputAODName().Data());
- abort();
- }
+ AliFatal(Form("No input particles in AOD with name branch < %s >, STOP",GetInputAODName().Data()));
if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation"))
- {
- printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - Wrong type of AOD object, change AOD class name in input AOD: It should be <AliAODPWG4ParticleCorrelation> and not <%s> \n",GetInputAODBranch()->GetClass()->GetName());
- abort();
- }
+ AliFatal(Form("Wrong type of AOD object, change AOD class name in input AOD: It should be <AliAODPWG4ParticleCorrelation> and not <%s> \n",GetInputAODBranch()->GetClass()->GetName()));
Int_t n = 0, nfrac = 0;
Bool_t isolated = kFALSE ;
- Float_t coneptsum = 0 ;
- TObjArray * pl = 0x0; ;
+ Float_t coneptsum = 0, coneptlead = 0;
+ TObjArray * pl = 0x0; ;
//Select the calorimeter for candidate isolation with neutral particles
if (fCalorimeter == "PHOS" )
pl = GetEMCALClusters();
//Loop on AOD branch, filled previously in AliAnaPhoton, find leading particle to do isolation only with it
- Double_t ptLeading = 0. ;
- Int_t idLeading = -1 ;
TLorentzVector mom ;
- Int_t naod = GetInputAODBranch()->GetEntriesFast();
- if(GetDebug() > 0) printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - Input aod branch entries %d\n", naod);
+ Int_t idLeading = -1 ;
+ Int_t iaod0 = 0;
+ Int_t naod = GetInputAODBranch()->GetEntriesFast();
+
+ if(GetDebug() > 0)
+ printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - Input aod branch entries %d\n", naod);
- for(Int_t iaod = 0; iaod < naod; iaod++)
+ if(IsLeadingOnlyOn())
+ {
+ Bool_t leading = IsTriggerTheNearSideEventLeadingParticle(idLeading);
+ if(!leading)
+ {
+ if(GetDebug() > 1) printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - Not leading; End fill AODs \n");
+ return;
+ }
+ iaod0 = idLeading ; // first entry in particle loop
+ naod = idLeading+1; // last entry in particle loop
+ }
+
+ // Check isolation of list of candidate particles or leading particle
+
+ for(Int_t iaod = iaod0; iaod < naod; iaod++)
{
AliAODPWG4ParticleCorrelation * aodinput = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
-
+
+ // Check isolation only of clusters in fiducial region
+
+ if(IsFiducialCutOn())
+ {
+ Bool_t in = GetFiducialCut()->IsInFiducialCut(*aodinput->Momentum(),aodinput->GetDetector()) ;
+ if(! in ) continue ;
+ }
+
//If too small or too large pt, skip
- if(aodinput->Pt() < GetMinPt() || aodinput->Pt() > GetMaxPt() ) continue ;
+ Float_t pt = aodinput->Pt();
+ if(pt < GetMinPt() || pt > GetMaxPt() ) continue ;
+
//check if it is low pt trigger particle
- if((aodinput->Pt() < GetIsolationCut()->GetPtThreshold() ||
- aodinput->Pt() < GetIsolationCut()->GetSumPtThreshold()) &&
+ if( ( pt < GetIsolationCut()->GetPtThreshold() || pt < GetIsolationCut()->GetSumPtThreshold() ) &&
!fMakeSeveralIC)
{
continue ; //trigger should not come from underlying event
}
- //vertex cut in case of mixing
- Int_t check = CheckMixedEventVertex(aodinput->GetCaloLabel(0), aodinput->GetTrackLabel(0));
- if(check == 0) continue;
- if(check == -1) return;
+ //After cuts, study isolation
+ n=0; nfrac = 0; isolated = kFALSE; coneptsum = 0; coneptlead = 0;
+ GetIsolationCut()->MakeIsolationCut(GetCTSTracks(),pl,
+ GetReader(), GetCaloPID(),
+ kTRUE, aodinput, GetAODObjArrayName(),
+ n,nfrac,coneptsum,coneptlead,isolated);
- //find the leading particles with highest momentum
- if ( aodinput->Pt() > ptLeading )
+ if(!fMakeSeveralIC) aodinput->SetIsolated(isolated);
+
+ if(GetDebug() > 1)
{
- ptLeading = aodinput->Pt() ;
- idLeading = iaod ;
+ if(isolated) printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() : Particle %d IS ISOLATED \n",iaod);
+ printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - End fill AODs \n");
}
-
- aodinput->SetLeadingParticle(kFALSE);
-
- }//finish searching for leading trigger particle
-
- // Check isolation of leading particle
- if(idLeading < 0) return;
-
- AliAODPWG4ParticleCorrelation * aodinput = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(idLeading));
- aodinput->SetLeadingParticle(kTRUE);
-
- // Check isolation only of clusters in fiducial region
- if(IsFiducialCutOn())
- {
- Bool_t in = GetFiducialCut()->IsInFiducialCut(*aodinput->Momentum(),aodinput->GetDetector()) ;
- if(! in ) return ;
- }
-
- //After cuts, study isolation
- n=0; nfrac = 0; isolated = kFALSE; coneptsum = 0;
- GetIsolationCut()->MakeIsolationCut(GetCTSTracks(),pl,
- GetReader(), GetCaloPID(),
- kTRUE, aodinput, GetAODObjArrayName(),
- n,nfrac,coneptsum, isolated);
-
- if(!fMakeSeveralIC) aodinput->SetIsolated(isolated);
-
- if(GetDebug() > 1)
- {
- if(isolated)printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() : Particle %d IS ISOLATED \n",idLeading);
- printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - End fill AODs \n");
- }
+
+ } // particle isolation loop
}
//_________________________________________________________
-void AliAnaParticleIsolation::MakeAnalysisFillHistograms()
+void AliAnaParticleIsolation::MakeAnalysisFillHistograms()
{
- //Do analysis and fill histograms
+ // Do analysis and fill histograms
+
+ // In case of simulated data, fill acceptance histograms
+ // Not ready for multiple case analysis.
+ if(IsDataMC() && !fMakeSeveralIC) FillAcceptanceHistograms();
//Loop on stored AOD
Int_t naod = GetInputAODBranch()->GetEntriesFast();
- if(GetDebug() > 0) printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Histo aod branch entries %d\n", naod);
-
+ if(GetDebug() > 0)
+ printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Histo aod branch entries %d\n", naod);
+
for(Int_t iaod = 0; iaod < naod ; iaod++)
{
AliAODPWG4ParticleCorrelation* aod = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
- if(!aod->IsLeadingParticle()) continue; // Try to isolate only leading cluster or track
+ if(IsLeadingOnlyOn() && !aod->IsLeadingParticle()) continue; // Try to isolate only leading cluster or track
// Check isolation only of clusters in fiducial region
if(IsFiducialCutOn())
}
Float_t pt = aod->Pt();
+
//If too small or too large pt, skip
if(pt < GetMinPt() || pt > GetMaxPt() ) continue ;
- Bool_t isolated = aod->IsIsolated();
- Bool_t decay = aod->IsTagged();
- Float_t energy = aod->E();
- Float_t phi = aod->Phi();
- Float_t eta = aod->Eta();
-
- // --- In case of redoing isolation from delta AOD ----
+ Int_t mcTag = aod->GetTag() ;
+ Int_t mcIndex = GetMCIndex(mcTag);
- if (fMakeSeveralIC)
+ // --- In case of redoing isolation from delta AOD ----
+ // Not standard case, not used since its implementation
+ if(fMakeSeveralIC)
{
//Analysis of multiple IC at same time
- MakeSeveralICAnalysis(aod);
+ MakeSeveralICAnalysis(aod,mcIndex);
continue;
}
- else if(fReMakeIC)
+
+ // --- In case of redoing isolation multiple cuts ----
+
+ if(fReMakeIC)
{
//In case a more strict IC is needed in the produced AOD
- isolated = kFALSE;
+ Bool_t isolated = kFALSE;
Int_t n = 0, nfrac = 0;
- Float_t coneptsum = 0 ;
-
+ Float_t coneptsum = 0, coneptlead = 0;
+
//Recover reference arrays with clusters and tracks
TObjArray * refclusters = aod->GetObjArray(GetAODObjArrayName()+"Clusters");
TObjArray * reftracks = aod->GetObjArray(GetAODObjArrayName()+"Tracks");
+
+ GetIsolationCut()->MakeIsolationCut(reftracks, refclusters,
+ GetReader(), GetCaloPID(),
+ kFALSE, aod, "",
+ n,nfrac,coneptsum,coneptlead,isolated);
+ }
+
+ Bool_t isolated = aod->IsIsolated();
+ Float_t energy = aod->E();
+ Float_t phi = aod->Phi();
+ Float_t eta = aod->Eta();
- GetIsolationCut()->MakeIsolationCut(reftracks, refclusters,
- GetReader(), GetCaloPID(),
- kFALSE, aod, "",
- n,nfrac,coneptsum, isolated);
-
- fhConeSumPt ->Fill(pt, coneptsum);
- fhConeSumPtTrigEtaPhi->Fill(eta,phi,coneptsum);
-
- if(GetDebug() > 0) printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Energy Sum in Isolation Cone %2.2f\n", coneptsum);
+ Int_t decayTag = 0;
+ if(fFillTaggedDecayHistograms)
+ {
+ decayTag = aod->GetBtag(); // temporary
+ if(decayTag < 0) decayTag = 0; // temporary
}
- else
+
+ if(GetDebug() > 0)
+ printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - pt %1.1f, eta %1.1f, phi %1.1f, Isolated %d\n",
+ pt, eta, phi, isolated);
+
+ //---------------------------------------------------------------
+ // Fill pt/sum pT distribution of particles in cone or in UE band
+ //---------------------------------------------------------------
+
+ Float_t coneptLeadCluster= 0;
+ Float_t coneptLeadTrack = 0;
+ Float_t coneptsumCluster = 0;
+ Float_t coneptsumTrack = 0;
+ Float_t coneptsumCell = 0;
+ Float_t etaBandptsumClusterNorm = 0;
+ Float_t etaBandptsumTrackNorm = 0;
+
+ CalculateTrackSignalInCone (aod,coneptsumTrack , coneptLeadTrack );
+ CalculateCaloSignalInCone (aod,coneptsumCluster, coneptLeadCluster);
+ if(fFillCellHistograms)
+ CalculateCaloCellSignalInCone(aod,coneptsumCell );
+
+ if(GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged)
{
- if(GetDebug() > 0) printf(" AliAnaParticleIsolation::MakeAnalysisFillHistograms() - pt %1.1f, eta %1.1f, phi %1.1f\n",pt, eta, phi);
-
- FillTrackMatchingShowerShapeControlHistograms(aod,GetReader(), GetCaloPID());
+ fhConeSumPtClustervsTrack ->Fill(coneptsumCluster, coneptsumTrack );
+ fhConePtLeadClustervsTrack->Fill(coneptLeadCluster,coneptLeadTrack);
- //Fill pt/sum pT distribution of particles in cone or in UE band
- Float_t coneptsumCluster = 0;
- Float_t coneptsumTrack = 0;
- Float_t coneptsumCell = 0;
-
- CalculateTrackSignalInCone (aod,coneptsumTrack );
- CalculateCaloSignalInCone (aod,coneptsumCluster);
- CalculateCaloCellSignalInCone(aod,coneptsumCell );
-
- if(GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged)
+ if(coneptsumTrack > 0) fhConeSumPtClusterTrackFrac ->Fill(pt, coneptsumCluster /coneptsumTrack );
+ if(coneptLeadTrack > 0) fhConePtLeadClusterTrackFrac->Fill(pt, coneptLeadCluster/coneptLeadTrack);
+
+ if(fFillCellHistograms)
{
- fhConeSumPtClustervsTrack ->Fill(coneptsumCluster,coneptsumTrack);
fhConeSumPtCellvsTrack ->Fill(coneptsumCell, coneptsumTrack);
fhConeSumPtCellTrack ->Fill(pt, coneptsumTrack+coneptsumCell);
fhConeSumPtCellTrackTrigEtaPhi->Fill(eta,phi,coneptsumTrack+coneptsumCell);
- }
-
- fhConeSumPt ->Fill(pt, coneptsumTrack+coneptsumCluster);
- fhConeSumPtTrigEtaPhi ->Fill(eta,phi,coneptsumTrack+coneptsumCluster);
-
- if(GetDebug() > 1)
- printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d Energy Sum in Isolation Cone %2.2f\n", iaod, coneptsumTrack+coneptsumCluster);
-
- //normalize phi/eta band per area unit
- CalculateNormalizeUEBandPerUnitArea(aod, coneptsumCluster, coneptsumCell, coneptsumTrack) ;
+ }
}
- Int_t mcTag = aod->GetTag() ;
-
+ fhConeSumPt ->Fill(pt, coneptsumTrack+coneptsumCluster);
+ fhConeSumPtTrigEtaPhi ->Fill(eta,phi,coneptsumTrack+coneptsumCluster);
+
+ Float_t coneptLead = coneptLeadTrack;
+ if(coneptLeadCluster > coneptLeadTrack) coneptLead = coneptLeadCluster;
+ fhConePtLead->Fill(pt, coneptLead );
+
+ if(GetDebug() > 1)
+ printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d Energy Sum in Isolation Cone %2.2f, Leading pT in cone %2.2f\n",
+ iaod, coneptsumTrack+coneptsumCluster, coneptLead);
+
+ //normalize phi/eta band per area unit
+ if(fFillUEBandSubtractHistograms)
+ CalculateNormalizeUEBandPerUnitArea(aod, coneptsumCluster, coneptsumCell, coneptsumTrack, etaBandptsumTrackNorm, etaBandptsumClusterNorm) ;
+
+ // printf("Histograms analysis : cluster pt = %f, etaBandTrack = %f, etaBandCluster = %f, isolation = %d\n",aod->Pt(),etaBandptsumTrackNorm,etaBandptsumClusterNorm,aod->IsIsolated());
+
+ //---------------------------------------------------------------
+ // Fill Shower shape and track matching histograms
+ //---------------------------------------------------------------
+
+ FillTrackMatchingShowerShapeControlHistograms(aod, coneptsumTrack+coneptsumCluster, coneptLead, mcIndex);
+
+ //---------------------------------------------------------------
+ // Isolated/ Non isolated histograms
+ //---------------------------------------------------------------
+
if(isolated)
{
- if(GetDebug() > 1) printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d ISOLATED: fill histograms\n", iaod);
-
- // Fill histograms to undertand pile-up before other cuts applied
- // Remember to relax time cuts in the reader
- FillPileUpHistograms(aod->GetCaloLabel(0));
+ if(GetDebug() > 1)
+ printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d ISOLATED: fill histograms\n", iaod);
fhEIso ->Fill(energy);
fhPtIso ->Fill(pt);
fhEtaIso ->Fill(pt,eta);
fhEtaPhiIso ->Fill(eta,phi);
- fhPtNLocMaxIso ->Fill(pt,aod->GetFiducialArea()) ;
- fhPtCentralityIso ->Fill(pt,GetEventCentrality()) ;
- fhPtEventPlaneIso ->Fill(pt,GetEventPlaneAngle() ) ;
+ if(IsDataMC())
+ {
+ // For histograms in arrays, index in the array, corresponding to any particle origin
+ if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
+ {
+ fhPtIsoMC [kmcPhoton]->Fill(pt);
+ fhPhiIsoMC[kmcPhoton]->Fill(pt,phi);
+ fhEtaIsoMC[kmcPhoton]->Fill(pt,eta);
+ }
+
+ fhPtIsoMC [mcIndex]->Fill(pt);
+ fhPhiIsoMC[mcIndex]->Fill(pt,phi);
+ fhEtaIsoMC[mcIndex]->Fill(pt,eta);
+ }//Histograms with MC
+
+ // Candidates tagged as decay in another analysis (AliAnaPi0EbE)
+ if(fFillTaggedDecayHistograms && decayTag > 0)
+ {
+ for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
+ {
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
+ {
+ fhPtDecayIso [ibit]->Fill(pt);
+ fhEtaPhiDecayIso [ibit]->Fill(eta,phi);
+
+ if(IsDataMC())
+ {
+ if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
+ fhPtDecayIsoMC[ibit][kmcPhoton]->Fill(pt);
+
+ fhPtDecayIsoMC[ibit][mcIndex]->Fill(pt);
+ }
+ } // bit ok
+ } // bit loop
+ } // decay histograms
+
+ if(fFillNLMHistograms)
+ fhPtNLocMaxIso ->Fill(pt,aod->GetFiducialArea()) ; // remember to change method name
- if(decay)
+ if(fFillHighMultHistograms)
{
- fhPtDecayIso ->Fill(pt);
- fhEtaPhiDecayIso->Fill(eta,phi);
+ fhPtCentralityIso ->Fill(pt,GetEventCentrality()) ;
+ fhPtEventPlaneIso ->Fill(pt,GetEventPlaneAngle() ) ;
}
-
+
if(fFillPileUpHistograms)
{
if(GetReader()->IsPileUpFromSPD()) { fhEIsoPileUp[0] ->Fill(energy) ; fhPtIsoPileUp[0]->Fill(pt) ; }
if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhEIsoPileUp[4] ->Fill(energy) ; fhPtIsoPileUp[4]->Fill(pt) ; }
if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhEIsoPileUp[5] ->Fill(energy) ; fhPtIsoPileUp[5]->Fill(pt) ; }
if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhEIsoPileUp[6] ->Fill(energy) ; fhPtIsoPileUp[6]->Fill(pt) ; }
- }
-
- if(IsDataMC())
- {
-
- if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
- {
- fhPtIsoMCPhoton ->Fill(pt);
- }
- if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt))
- {
- fhPtIsoPrompt ->Fill(pt);
- fhPhiIsoPrompt ->Fill(pt,phi);
- fhEtaIsoPrompt ->Fill(pt,eta);
- }
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation))
- {
- fhPtIsoFragmentation ->Fill(pt);
- fhPhiIsoFragmentation ->Fill(pt,phi);
- fhEtaIsoFragmentation ->Fill(pt,eta);
- }
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0))
- {
- fhPtIsoPi0 ->Fill(pt);
- fhPhiIsoPi0 ->Fill(pt,phi);
- fhEtaIsoPi0 ->Fill(pt,eta);
- }
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay))
- {
- fhPtIsoPi0Decay ->Fill(pt);
- fhPhiIsoPi0Decay ->Fill(pt,phi);
- fhEtaIsoPi0Decay ->Fill(pt,eta);
- }
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay))
- {
- fhPtIsoEtaDecay ->Fill(pt);
- fhPhiIsoEtaDecay ->Fill(pt,phi);
- fhEtaIsoEtaDecay ->Fill(pt,eta);
- }
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay))
- {
- fhPtIsoOtherDecay ->Fill(pt);
- fhPhiIsoOtherDecay ->Fill(pt,phi);
- fhEtaIsoOtherDecay ->Fill(pt,eta);
- }
- // else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion))
- // {
- // fhPtIsoConversion ->Fill(pt);
- // fhPhiIsoConversion ->Fill(pt,phi);
- // fhEtaIsoConversion ->Fill(pt,eta);
- // }
- else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron))// anything else but electrons
- {
- fhPtIsoHadron ->Fill(pt);
- fhPhiIsoHadron ->Fill(pt,phi);
- fhEtaIsoHadron ->Fill(pt,eta);
- }
- }//Histograms with MC
-
+ // Fill histograms to undertand pile-up before other cuts applied
+ // Remember to relax time cuts in the reader
+ FillPileUpHistograms(aod->GetCaloLabel(0));
+ }
+
}//Isolated histograms
else // NON isolated
{
- if(GetDebug() > 1) printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d NOT ISOLATED, fill histograms\n", iaod);
+ if(GetDebug() > 1)
+ printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d NOT ISOLATED, fill histograms\n", iaod);
fhENoIso ->Fill(energy);
fhPtNoIso ->Fill(pt);
fhEtaPhiNoIso ->Fill(eta,phi);
- fhPtNLocMaxNoIso->Fill(pt,aod->GetFiducialArea());
+
+ if(IsDataMC())
+ {
+ if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) )
+ fhPtNoIsoMC[kmcPhoton]->Fill(pt);
+
+ fhPtNoIsoMC[mcIndex]->Fill(pt);
+ }
+
+ // Candidates tagged as decay in another analysis (AliAnaPi0EbE)
+ if(fFillTaggedDecayHistograms && decayTag > 0)
+ {
+ for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
+ {
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
+ {
+ fhPtDecayNoIso[ibit] ->Fill(pt);
+ fhEtaPhiDecayNoIso[ibit]->Fill(eta,phi);
+
+ if(IsDataMC())
+ {
+ if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
+ fhPtDecayNoIsoMC[ibit][kmcPhoton]->Fill(pt);
+
+ fhPtDecayNoIsoMC[ibit][mcIndex]->Fill(pt);
+ }
+ } // bit ok
+ } // bit loop
+ } // decay histograms
+
+ if(fFillNLMHistograms)
+ fhPtNLocMaxNoIso ->Fill(pt,aod->GetFiducialArea()); // remember to change method name
if(fFillPileUpHistograms)
{
if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhENoIsoPileUp[5] ->Fill(energy) ; fhPtNoIsoPileUp[5]->Fill(pt) ; }
if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhENoIsoPileUp[6] ->Fill(energy) ; fhPtNoIsoPileUp[6]->Fill(pt) ; }
}
+ } // non iso
+ }// aod loop
+
+}
+
+//______________________________________________________________________
+void AliAnaParticleIsolation::FillAcceptanceHistograms()
+{
+ // Fill acceptance histograms if MC data is available
+ // Only when particle is in the calorimeter. Rethink if CTS is used.
+
+ if(GetDebug() > 0) printf("AliAnaParticleIsolation::FillAcceptanceHistograms() - Start \n");
+
+ //Double_t photonY = -100 ;
+ Double_t photonE = -1 ;
+ Double_t photonPt = -1 ;
+ Double_t photonPhi = 100 ;
+ Double_t photonEta = -1 ;
+
+ Int_t pdg = 0 ;
+ Int_t status = 0 ;
+ Int_t tag = 0 ;
+ Int_t mcIndex = 0 ;
+ Int_t nprim = 0;
+
+ TParticle * primStack = 0;
+ AliAODMCParticle * primAOD = 0;
+ TLorentzVector lv;
+
+ // Get the ESD MC particles container
+ AliStack * stack = 0;
+ if( GetReader()->ReadStack() )
+ {
+ stack = GetMCStack();
+ if(!stack ) return;
+ nprim = stack->GetNtrack();
+ }
+
+ // Get the AOD MC particles container
+ TClonesArray * mcparticles = 0;
+ if( GetReader()->ReadAODMCParticles() )
+ {
+ mcparticles = GetReader()->GetAODMCParticles();
+ if( !mcparticles ) return;
+ nprim = mcparticles->GetEntriesFast();
+ }
+
+ for(Int_t i=0 ; i < nprim; i++)
+ {
+ if(GetReader()->AcceptOnlyHIJINGLabels() && !GetReader()->IsHIJINGLabel(i)) continue ;
+
+ if(GetReader()->ReadStack())
+ {
+ primStack = stack->Particle(i) ;
+ if(!primStack)
+ {
+ printf("AliAnaParticleIsolation::FillAcceptanceHistograms() - ESD primaries pointer not available!!\n");
+ continue;
+ }
+
+ pdg = primStack->GetPdgCode();
+ status = primStack->GetStatusCode();
+
+ if(primStack->Energy() == TMath::Abs(primStack->Pz())) continue ; //Protection against floating point exception
+
+ //printf("i %d, %s %d %s %d \n",i, stack->Particle(i)->GetName(), stack->Particle(i)->GetPdgCode(),
+ // prim->GetName(), prim->GetPdgCode());
+
+ //photonY = 0.5*TMath::Log((prim->Energy()-prim->Pz())/(prim->Energy()+prim->Pz())) ;
- if(decay)
+ //Photon kinematics
+ primStack->Momentum(lv);
+
+ }
+ else
+ {
+ primAOD = (AliAODMCParticle *) mcparticles->At(i);
+ if(!primAOD)
{
- fhPtDecayNoIso ->Fill(pt);
- fhEtaPhiDecayNoIso->Fill(eta,phi);
+ printf("AliAnaParticleIsolation::FillAcceptanceHistograms() - AOD primaries pointer not available!!\n");
+ continue;
}
- if(IsDataMC())
+ pdg = primAOD->GetPdgCode();
+ status = primAOD->GetStatus();
+
+ if(primAOD->E() == TMath::Abs(primAOD->Pz())) continue ; //Protection against floating point exception
+
+ //photonY = 0.5*TMath::Log((prim->Energy()-prim->Pz())/(prim->Energy()+prim->Pz())) ;
+
+ //Photon kinematics
+ lv.SetPxPyPzE(primAOD->Px(),primAOD->Py(),primAOD->Pz(),primAOD->E());
+ }
+
+ // Select only photons in the final state
+ if(pdg != 22 ) continue ;
+
+ // Consider only final state particles, but this depends on generator,
+ // status 1 is the usual one, in case of not being ok, leave the possibility
+ // to not consider this.
+ if(status != 1 && GetMCAnalysisUtils()->GetMCGenerator()!="" ) continue ;
+
+ // If too small or too large pt, skip, same cut as for data analysis
+ photonPt = lv.Pt () ;
+
+ if(photonPt < GetMinPt() || photonPt > GetMaxPt() ) continue ;
+
+ photonE = lv.E () ;
+ photonEta = lv.Eta() ;
+ photonPhi = lv.Phi() ;
+
+ if(photonPhi < 0) photonPhi+=TMath::TwoPi();
+
+ // Check if photons hit the Calorimeter acceptance
+ if(IsRealCaloAcceptanceOn() && fIsoDetector!="CTS") // defined on base class
+ {
+ if(GetReader()->ReadStack() &&
+ !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(fIsoDetector, primStack)) continue ;
+ if(GetReader()->ReadAODMCParticles() &&
+ !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(fIsoDetector, primAOD )) continue ;
+ }
+
+ // Check same fidutial borders as in data analysis on top of real acceptance if real was requested.
+ if(!GetFiducialCut()->IsInFiducialCut(lv,fIsoDetector)) continue ;
+
+ // Get tag of this particle photon from fragmentation, decay, prompt ...
+ // Set the origin of the photon.
+ tag = GetMCAnalysisUtils()->CheckOrigin(i,GetReader());
+
+ if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
+ {
+ // A conversion photon from a hadron, skip this kind of photon
+ // printf("AliAnaPhoton::FillAcceptanceHistograms() - not a photon, weird!\n ");
+ // GetMCAnalysisUtils()->PrintMCTag(tag);
+
+ continue;
+ }
+
+ //
+ if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) )
+ {
+ mcIndex = kmcPrimPrompt;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation) )
+ {
+ mcIndex = kmcPrimFrag ;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR))
+ {
+ mcIndex = kmcPrimISR;
+ }
+ else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay))
+ {
+ mcIndex = kmcPrimPi0Decay;
+ }
+ else if( (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) ||
+ GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)))
+ {
+ mcIndex = kmcPrimOtherDecay;
+ }
+ else
+ {
+ // Other decay but from non final state particle
+ mcIndex = kmcPrimOtherDecay;
+ }//Other origin
+
+ // ////////////////////ISO MC/////////////////////////
+ Double_t sumPtInCone = 0; Double_t dR=0. ;
+ TParticle * mcisopStack = 0;
+ AliAODMCParticle * mcisopAOD = 0;
+ Int_t partInConeStatus = -1, partInConeMother = -1;
+ Double_t partInConePt = 0, partInConeEta = 0, partInConePhi = 0;
+ Int_t npart = 0;
+ for(Int_t ip = 0; ip < nprim ; ip++)
+ {
+ if(ip==i) continue;
+
+ if( GetReader()->ReadStack() )
+ {
+ mcisopStack = static_cast<TParticle*>(stack->Particle(ip));
+ if( !mcisopStack ) continue;
+ partInConeStatus = mcisopStack->GetStatusCode();
+ partInConeMother = mcisopStack->GetMother(0);
+ partInConePt = mcisopStack->Pt();
+ partInConeEta = mcisopStack->Eta();
+ partInConePhi = mcisopStack->Phi();
+ }
+ else
{
- if (GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton)) fhPtNoIsoMCPhoton ->Fill(pt);
- if (GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0)) fhPtNoIsoPi0 ->Fill(pt);
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay)) fhPtNoIsoPi0Decay ->Fill(pt);
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay)) fhPtNoIsoEtaDecay ->Fill(pt);
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay)) fhPtNoIsoOtherDecay ->Fill(pt);
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt)) fhPtNoIsoPrompt ->Fill(pt);
- else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation)) fhPtNoIsoFragmentation->Fill(pt);
- // else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion)) fhPtNoIsoConversion ->Fill(pt);
- else if(!GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron)) fhPtNoIsoHadron ->Fill(pt);
+ mcisopAOD = (AliAODMCParticle *) mcparticles->At(ip);
+ if( !mcisopAOD ) continue;
+ partInConeStatus = mcisopAOD->GetStatus();
+ partInConeMother = mcisopAOD->GetMother();
+ partInConePt = mcisopAOD->Pt();
+ partInConeEta = mcisopAOD->Eta();
+ partInConePhi = mcisopAOD->Phi();
}
+
+ // Consider only final state particles, but this depends on generator,
+ // status 1 is the usual one, in case of not being ok, leave the possibility
+ // to not consider this.
+ if( partInConeStatus != 1 && GetMCAnalysisUtils()->GetMCGenerator()!="" ) continue ;
+
+ if( partInConeMother == i ) continue;
+
+ if( partInConePt < GetReader()->GetCTSPtMin() ) continue;
+ // Careful!!!, cut for TPC tracks and calorimeter clusters in cone can be different
+
+ // TVector3 vmcv(mcisop->Px(),mcisop->Py(), mcisop->Pz());
+ // if(vmcv.Perp()>1)
+ // continue;
+
+ //
+ // Add here Acceptance cut???, charged particles CTS fid cut, neutral Calo real acceptance.
+ //
+
+ dR = GetIsolationCut()->Radius(photonEta, photonPhi, partInConeEta, partInConePhi);
+
+ if(dR > GetIsolationCut()->GetConeSize())
+ continue;
+
+ sumPtInCone += partInConePt;
+ if(partInConePt > GetIsolationCut()->GetPtThreshold() &&
+ partInConePt < GetIsolationCut()->GetPtThresholdMax()) npart++;
}
- }// aod loop
+
+ ///////END ISO MC/////////////////////////
+
+ // Fill the histograms, only those in the defined calorimeter acceptance
+
+ fhEtaPrimMC[kmcPrimPhoton]->Fill(photonPt , photonEta) ;
+ fhPhiPrimMC[kmcPrimPhoton]->Fill(photonPt , photonPhi) ;
+ fhEPrimMC [kmcPrimPhoton]->Fill(photonE) ;
+
+ fhEtaPrimMC[mcIndex]->Fill(photonPt , photonEta) ;
+ fhPhiPrimMC[mcIndex]->Fill(photonPt , photonPhi) ;
+ fhEPrimMC [mcIndex]->Fill(photonE ) ;
+
+ // Isolated?
+ Bool_t isolated = kFALSE;
+ if(GetIsolationCut()->GetICMethod() == AliIsolationCut::kSumPtIC &&
+ (sumPtInCone < GetIsolationCut()->GetSumPtThreshold() ||
+ sumPtInCone > GetIsolationCut()->GetSumPtThresholdMax()))
+ isolated = kTRUE;
+
+ if(GetIsolationCut()->GetICMethod() == AliIsolationCut::kPtThresIC &&
+ npart == 0)
+ isolated = kTRUE;
+
+ if(isolated)
+ {
+ fhPtPrimMCiso [mcIndex] ->Fill(photonPt) ;
+ fhPtPrimMCiso [kmcPrimPhoton]->Fill(photonPt) ;
+ }
+
+ }//loop on primaries
+
+ if(GetDebug() > 0) printf("AliAnaParticleIsolation::FillAcceptanceHistograms() - End \n");
}
+
//_____________________________________________________________________________________
-void AliAnaParticleIsolation::MakeSeveralICAnalysis(AliAODPWG4ParticleCorrelation* ph)
+void AliAnaParticleIsolation::MakeSeveralICAnalysis(AliAODPWG4ParticleCorrelation* ph,
+ Int_t mcIndex)
{
//Isolation Cut Analysis for both methods and different pt cuts and cones
- Float_t ptC = ph->Pt();
+ Float_t ptC = ph->Pt();
Float_t etaC = ph->Eta();
Float_t phiC = ph->Phi();
- Int_t tag = ph->GetTag();
- Bool_t decay = ph->IsTagged();
-
- if(GetDebug() > 0) printf("AliAnaParticleIsolation::MakeSeveralICAnalysis() - Isolate pT %2.2f\n",ptC);
+ Int_t tag = ph->GetTag();
+
+ Int_t decayTag = 0;
+ if(fFillTaggedDecayHistograms)
+ {
+ decayTag = ph->GetBtag(); // temporary
+ if(decayTag < 0) decayTag = 0; // temporary
+ }
+
+ if(GetDebug() > 0)
+ printf("AliAnaParticleIsolation::MakeSeveralICAnalysis() - Isolate pT %2.2f, decay tag %d\n",ptC, decayTag);
- //Keep original setting used when filling AODs, reset at end of analysis
+ //Keep original setting used when filling AODs, reset at end of analysis
Float_t ptthresorg = GetIsolationCut()->GetPtThreshold();
Float_t ptfracorg = GetIsolationCut()->GetPtFraction();
+ Float_t ptsumcorg = GetIsolationCut()->GetSumPtThreshold();
Float_t rorg = GetIsolationCut()->GetConeSize();
- Float_t coneptsum = 0 ;
+ Float_t coneptsum = 0, coneptlead = 0;
Int_t n [10][10];//[fNCones][fNPtThresFrac];
Int_t nfrac[10][10];//[fNCones][fNPtThresFrac];
Bool_t isolated = kFALSE;
- Int_t nCone = 0;
- Int_t nFracCone = 0;
-
- // fill hist with all particles before isolation criteria
+
+ // Fill hist with all particles before isolation criteria
+ fhENoIso ->Fill(ph->E());
fhPtNoIso ->Fill(ptC);
fhEtaPhiNoIso->Fill(etaC,phiC);
if(IsDataMC())
{
- if (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton)) fhPtNoIsoMCPhoton ->Fill(ptC);
- if (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0)) fhPtNoIsoPi0 ->Fill(ptC);
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay)) fhPtNoIsoPi0Decay ->Fill(ptC);
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay)) fhPtNoIsoEtaDecay ->Fill(ptC);
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)) fhPtNoIsoOtherDecay ->Fill(ptC);
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt)) fhPtNoIsoPrompt ->Fill(ptC);
- else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation)) fhPtNoIsoFragmentation->Fill(ptC);
-// else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) fhPtNoIsoConversion ->Fill(ptC);
- else if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) fhPtNoIsoHadron ->Fill(ptC);
+ if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
+ fhPtNoIsoMC[kmcPhoton]->Fill(ptC);
+
+ fhPtNoIsoMC[mcIndex]->Fill(ptC);
}
- if(decay)
+ // Candidates tagged as decay in another analysis (AliAnaPi0EbE)
+ if(fFillTaggedDecayHistograms && decayTag > 0)
{
- fhPtDecayNoIso ->Fill(ptC);
- fhEtaPhiDecayNoIso->Fill(etaC,phiC);
- }
+ for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
+ {
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
+ {
+ fhPtDecayNoIso[ibit] ->Fill(ptC);
+ fhEtaPhiDecayNoIso[ibit]->Fill(etaC,phiC);
+
+ if(IsDataMC())
+ {
+ if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
+ fhPtDecayNoIsoMC[ibit][kmcPhoton]->Fill(ptC);
+
+ fhPtDecayNoIsoMC[ibit][mcIndex]->Fill(ptC);
+ }
+ } // bit ok
+ } // bit loop
+ } // decay histograms
+
//Get vertex for photon momentum calculation
Double_t vertex[] = {0,0,0} ; //vertex ;
- if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
- GetReader()->GetVertex(vertex);
-
+ if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
+ GetReader()->GetVertex(vertex);
+
//Loop on cone sizes
for(Int_t icone = 0; icone<fNCones; icone++)
{
TObjArray * reftracks = ph->GetObjArray(GetAODObjArrayName()+"Tracks");
//If too small or too large pt, skip
- if(ptC < GetMinPt() || ptC > GetMaxPt() ) continue ;
-
- //In case a more strict IC is needed in the produced AOD
-
- nCone=0; nFracCone = 0; isolated = kFALSE; coneptsum = 0;
-
- GetIsolationCut()->SetSumPtThreshold(100);
- GetIsolationCut()->SetPtThreshold(100);
- GetIsolationCut()->SetPtFraction(100);
- GetIsolationCut()->SetConeSize(fConeSizes[icone]);
- GetIsolationCut()->MakeIsolationCut(reftracks, refclusters,
- GetReader(), GetCaloPID(),
- kFALSE, ph, "",
- nCone,nFracCone,coneptsum, isolated);
-
-
- fhSumPtLeadingPt[icone]->Fill(ptC,coneptsum);
+ if(ptC < GetMinPt() || ptC > GetMaxPt() ) continue ;
+
+ //In case a more strict IC is needed in the produced AOD
+
+ isolated = kFALSE; coneptsum = 0; coneptlead = 0;
+
+ GetIsolationCut()->SetSumPtThreshold(100);
+ GetIsolationCut()->SetPtThreshold(100);
+ GetIsolationCut()->SetPtFraction(100);
+ GetIsolationCut()->SetConeSize(fConeSizes[icone]);
// retreive pt tracks to fill histo vs. pt leading
//Fill pt distribution of particles in cone
//fhPtLeadingPt(),fhPerpSumPtLeadingPt(),fhPerpPtLeadingPt(),
- //Tracks
- coneptsum = 0;
+ // Tracks in perpendicular cones
Double_t sumptPerp = 0. ;
TObjArray * trackList = GetCTSTracks() ;
for(Int_t itrack=0; itrack < trackList->GetEntriesFast(); itrack++)
{
fhPerpPtLeadingPt[icone]->Fill(ptC,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
sumptPerp+=track->Pt();
- }
+ }
}
fhPerpSumPtLeadingPt[icone]->Fill(ptC,sumptPerp);
- if(reftracks)
- {
+ // Tracks in isolation cone, pT distribution and sum
+ if(reftracks && GetIsolationCut()->GetParticleTypeInCone()!= AliIsolationCut::kOnlyNeutral)
+ {
for(Int_t itrack=0; itrack < reftracks->GetEntriesFast(); itrack++)
{
AliVTrack* track = (AliVTrack *) reftracks->At(itrack);
- fhPtLeadingPt[icone]->Fill(ptC,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
- coneptsum+=track->Pt();
+
+ Float_t rad = GetIsolationCut()->Radius(etaC, phiC, track->Eta(), track->Phi());
+
+ if(rad > fConeSizes[icone]) continue ;
+
+ fhPtLeadingPt[icone]->Fill(ptC, track->Pt());
+ coneptsum += track->Pt();
}
}
- //CaloClusters
- if(refclusters)
- {
+ // Clusters in isolation cone, pT distribution and sum
+ if(refclusters && GetIsolationCut()->GetParticleTypeInCone()!= AliIsolationCut::kOnlyCharged)
+ {
TLorentzVector mom ;
for(Int_t icalo=0; icalo < refclusters->GetEntriesFast(); icalo++)
{
AliVCluster* calo = (AliVCluster *) refclusters->At(icalo);
+
calo->GetMomentum(mom,vertex) ;//Assume that come from vertex in straight line
+ Float_t rad = GetIsolationCut()->Radius(etaC, phiC, mom.Eta(), mom.Phi());
+
+ if(rad > fConeSizes[icone]) continue ;
+
fhPtLeadingPt[icone]->Fill(ptC, mom.Pt());
- coneptsum+=mom.Pt();
+ coneptsum += mom.Pt();
}
}
+
+ fhSumPtLeadingPt[icone]->Fill(ptC,coneptsum);
+
+ if(IsDataMC())
+ {
+ if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
+ fhSumPtLeadingPtMC[kmcPhoton][icone]->Fill(ptC,coneptsum) ;
+
+ fhSumPtLeadingPtMC[mcIndex][icone]->Fill(ptC,coneptsum) ;
+ }
+
///////////////////
-
-
- //Loop on ptthresholds
- for(Int_t ipt = 0; ipt<fNPtThresFrac ;ipt++)
+
+ //Loop on pt thresholds
+ for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
{
n [icone][ipt]=0;
nfrac[icone][ipt]=0;
GetIsolationCut()->MakeIsolationCut(reftracks, refclusters,
GetReader(), GetCaloPID(),
kFALSE, ph, "",
- n[icone][ipt],nfrac[icone][ipt],coneptsum, isolated);
+ n[icone][ipt],nfrac[icone][ipt],
+ coneptsum, coneptlead, isolated);
- if(!isolated) continue;
- //Normal ptThreshold cut
+ // Normal pT threshold cut
- if(GetDebug() > 0) printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - cone size %1.1f, ptThres %1.1f, sumptThresh %1.1f, n %d, nfrac %d, coneptsum %2.2f, isolated %d\n",
- fConeSizes[icone],fPtThresholds[ipt],fSumPtThresholds[ipt],n[icone][ipt],nfrac[icone][ipt],coneptsum, isolated);
- if(GetDebug() > 0) printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - pt %1.1f, eta %1.1f, phi %1.1f\n",ptC, etaC, phiC);
+ if(GetDebug() > 0)
+ {
+ printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - cone size %1.1f, ptThres %1.1f, sumptThresh %1.1f\n",
+ fConeSizes[icone],fPtThresholds[ipt],fSumPtThresholds[ipt]);
+ printf("\t n %d, nfrac %d, coneptsum %2.2f\n",
+ n[icone][ipt],nfrac[icone][ipt],coneptsum);
+
+ printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - pt %1.1f, eta %1.1f, phi %1.1f\n",ptC, etaC, phiC);
+ }
- if(n[icone][ipt] == 0)
+ if(n[icone][ipt] == 0)
{
- if(GetDebug()>0) printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling pt threshold loop\n");
- fhPtThresIsolated[icone][ipt]->Fill(ptC);
+ if(GetDebug() > 0)
+ printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling pt threshold loop\n");
+
+ fhPtThresIsolated [icone][ipt]->Fill(ptC);
fhEtaPhiPtThresIso[icone][ipt]->Fill(etaC,phiC);
- if(decay)
+ if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
{
- fhPtPtThresDecayIso[icone][ipt]->Fill(ptC);
- // fhEtaPhiPtThresDecayIso[icone][ipt]->Fill(etaC,phiC);
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
+ {
+ fhPtPtThresDecayIso [icone][ipt]->Fill(ptC);
+ fhEtaPhiPtThresDecayIso[icone][ipt]->Fill(etaC,phiC);
+ }
}
if(IsDataMC())
{
- if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt)) fhPtThresIsolatedPrompt[icone][ipt] ->Fill(ptC) ;
-// else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) fhPtThresIsolatedConversion[icone][ipt] ->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation)) fhPtThresIsolatedFragmentation[icone][ipt]->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0)) fhPtThresIsolatedPi0[icone][ipt] ->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay)) fhPtThresIsolatedPi0Decay[icone][ipt] ->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay)) fhPtThresIsolatedEtaDecay[icone][ipt] ->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)) fhPtThresIsolatedOtherDecay[icone][ipt] ->Fill(ptC) ;
- else if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) fhPtThresIsolatedHadron[icone][ipt] ->Fill(ptC) ;
+ if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) )
+ fhPtThresIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
+
+ fhPtThresIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
+
}
}
// pt in cone fraction
if(nfrac[icone][ipt] == 0)
{
- if(GetDebug()>0) printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling frac loop\n");
- fhPtFracIsolated[icone][ipt]->Fill(ptC);
+ if(GetDebug() > 0)
+ printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling frac loop\n");
+
+ fhPtFracIsolated [icone][ipt]->Fill(ptC);
fhEtaPhiPtFracIso[icone][ipt]->Fill(etaC,phiC);
- if(decay)
+ if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
{
- fhPtPtFracDecayIso[icone][ipt]->Fill(ptC);
- fhEtaPhiPtFracDecayIso[icone][ipt]->Fill(etaC,phiC);
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
+ {
+ fhPtPtFracDecayIso [icone][ipt]->Fill(ptC);
+ fhEtaPhiPtFracDecayIso[icone][ipt]->Fill(etaC,phiC);
+ }
}
if(IsDataMC())
{
- if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt)) fhPtFracIsolatedPrompt[icone][ipt] ->Fill(ptC) ;
-// else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) fhPtFracIsolatedConversion[icone][ipt] ->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation)) fhPtFracIsolatedFragmentation[icone][ipt]->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0)) fhPtFracIsolatedPi0[icone][ipt] ->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay)) fhPtFracIsolatedPi0Decay[icone][ipt] ->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay)) fhPtFracIsolatedEtaDecay[icone][ipt] ->Fill(ptC) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)) fhPtFracIsolatedOtherDecay[icone][ipt] ->Fill(ptC) ;
- else if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) fhPtFracIsolatedHadron[icone][ipt]->Fill(ptC) ;
+ if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
+ fhPtFracIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
+
+ fhPtFracIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
}
}
- if(GetDebug()>0) printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - checking IC method : %i\n",GetIsolationCut()->GetICMethod());
+ if(GetDebug()>0)
+ printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - checking IC method : %i\n",GetIsolationCut()->GetICMethod());
//Pt threshold on pt cand/ sum in cone histograms
- if(coneptsum<fSumPtThresholds[ipt])
- {// if((GetIsolationCut()->GetICMethod())==1){//kSumPtIC){
- if(GetDebug()>0) printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling sum loop\n");
- fhPtSumIsolated[icone][ipt]->Fill(ptC) ;
+ if(coneptsum < fSumPtThresholds[ipt])
+ {
+ if(GetDebug() > 0 )
+ printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling sum loop\n");
+
+ fhSumPtIsolated [icone][ipt]->Fill(ptC) ;
fhEtaPhiPtSumIso[icone][ipt]->Fill(etaC, phiC) ;
- if(decay)
+
+ if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
+ {
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
+ {
+ fhPtPtSumDecayIso[icone][ipt]->Fill(ptC);
+ fhEtaPhiPtSumDecayIso[icone][ipt]->Fill(etaC, phiC) ;
+ }
+ }
+
+ if(IsDataMC())
{
- fhPtPtSumDecayIso[icone][ipt]->Fill(ptC);
- fhEtaPhiPtSumDecayIso[icone][ipt]->Fill(etaC, phiC) ;
+ if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
+ fhSumPtIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
+
+ fhSumPtIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
}
}
- // pt sum pt frac method
-// if( ((fPtFractions[ipt]*ptC < fSumPtThresholds[ipt]) && (coneptsum < fSumPtThresholds[ipt])) || ((fPtFractions[ipt]*ptC > fSumPtThresholds[ipt]) && (coneptsum < fPtFractions[ipt]*ptC)) )
-
+ // pt sum pt frac method
+ // if( ((fPtFractions[ipt]*ptC < fSumPtThresholds[ipt]) && (coneptsum < fSumPtThresholds[ipt])) || ((fPtFractions[ipt]*ptC > fSumPtThresholds[ipt]) && (coneptsum < fPtFractions[ipt]*ptC)) )
+
if(coneptsum < fPtFractions[ipt]*ptC)
- {
- if(GetDebug()>0) printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling PtFrac PtSum loop\n");
- fhPtFracPtSumIso[icone][ipt]->Fill(ptC) ;
+ {
+ if(GetDebug() > 0)
+ printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling PtFrac PtSum loop\n");
+
+ fhPtFracPtSumIso [icone][ipt]->Fill(ptC) ;
fhEtaPhiFracPtSumIso[icone][ipt]->Fill(etaC,phiC) ;
- if(decay)
+ if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
{
- fhPtFracPtSumDecayIso[icone][ipt]->Fill(ptC);
- fhEtaPhiFracPtSumDecayIso[icone][ipt]->Fill(etaC,phiC);
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
+ {
+ fhPtFracPtSumDecayIso [icone][ipt]->Fill(ptC);
+ fhEtaPhiFracPtSumDecayIso[icone][ipt]->Fill(etaC,phiC);
+ }
}
}
// density method
Float_t cellDensity = GetIsolationCut()->GetCellDensity( ph, GetReader());
- if(coneptsum<fSumPtThresholds[ipt]*cellDensity)
- {//(GetIsolationCut()->GetICMethod())==4){//kSumDensityIC) {
- if(GetDebug()>0) printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling density loop\n");
- fhPtSumDensityIso[icone][ipt]->Fill(ptC) ;
+ if(coneptsum < fSumPtThresholds[ipt]*cellDensity)
+ {
+ if(GetDebug() > 0)
+ printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling density loop\n");
+
+ fhPtSumDensityIso [icone][ipt]->Fill(ptC) ;
fhEtaPhiSumDensityIso[icone][ipt]->Fill(etaC,phiC) ;
- if(decay)
+ if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
{
- fhPtSumDensityDecayIso[icone][ipt]->Fill(ptC);
- fhEtaPhiSumDensityDecayIso[icone][ipt]->Fill(etaC, phiC);
+ if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
+ {
+ fhPtSumDensityDecayIso [icone][ipt]->Fill(ptC);
+ fhEtaPhiSumDensityDecayIso[icone][ipt]->Fill(etaC, phiC);
+ }
}
-
}
}//pt thresh loop
- if(IsDataMC())
- {
- if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt)) fhPtSumIsolatedPrompt[icone] ->Fill(ptC,coneptsum) ;
-// else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) fhPtSumIsolatedConversion[icone] ->Fill(ptC,coneptsum) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation)) fhPtSumIsolatedFragmentation[icone]->Fill(ptC,coneptsum) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0)) fhPtSumIsolatedPi0[icone] ->Fill(ptC,coneptsum) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay)) fhPtSumIsolatedPi0Decay[icone] ->Fill(ptC,coneptsum) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay)) fhPtSumIsolatedEtaDecay[icone] ->Fill(ptC,coneptsum) ;
- else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)) fhPtSumIsolatedOtherDecay[icone] ->Fill(ptC,coneptsum) ;
- else if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) fhPtSumIsolatedHadron[icone]->Fill(ptC,coneptsum) ;
- }
}//cone size loop
//Reset original parameters for AOD analysis
GetIsolationCut()->SetPtThreshold(ptthresorg);
GetIsolationCut()->SetPtFraction(ptfracorg);
+ GetIsolationCut()->SetSumPtThreshold(ptsumcorg);
GetIsolationCut()->SetConeSize(rorg);
}
printf("ReMake Isolation = %d \n", fReMakeIC) ;
printf("Make Several Isolation = %d \n", fMakeSeveralIC) ;
printf("Calorimeter for isolation = %s \n", fCalorimeter.Data()) ;
+ printf("Detector for candidate isolation = %s \n", fIsoDetector.Data()) ;
if(fMakeSeveralIC)
{
- printf("N Cone Sizes = %d\n", fNCones) ;
+ printf("N Cone Sizes = %d\n", fNCones) ;
printf("Cone Sizes = \n") ;
for(Int_t i = 0; i < fNCones; i++)
printf(" %1.2f;", fConeSizes[i]) ;
printf(" %2.2f;", fSumPtThresholds[i]) ;
- }
-
- printf("Histograms: %3.1f < pT sum < %3.1f, Nbin = %d\n", fHistoPtSumMin, fHistoPtSumMax, fHistoNPtSumBins );
- printf("Histograms: %3.1f < pT in cone < %3.1f, Nbin = %d\n", fHistoPtInConeMin, fHistoPtInConeMax, fHistoNPtInConeBins);
+ }
printf(" \n") ;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff