]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/CaloTrackCorrelations/AliAnaParticleIsolation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
remove setting of leading particle bool, already done before when looking for it
[u/mrichter/AliRoot.git] / PWGGA / CaloTrackCorrelations / AliAnaParticleIsolation.cxx
CommitLineData
1a31a9ab 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
1a31a9ab 15
16//_________________________________________________________________________
17// Class for analysis of particle isolation
18// Input is selected particles put in AOD branch (AliAODPWG4ParticleCorrelation)
19//
6ae3345d 20// Class created from old AliPHOSGammaJet
1a31a9ab 21// (see AliRoot versions previous Release 4-09)
22//
6ae3345d 23// -- Author: Gustavo Conesa (LNF-INFN)
1a31a9ab 24
25//-Yaxian Mao (add the possibility for different IC method with different pt range, 01/10/2010)
26//////////////////////////////////////////////////////////////////////////////
db6fb352 27
6ae3345d 28// --- ROOT system ---
1a31a9ab 29#include <TClonesArray.h>
30#include <TList.h>
31#include <TObjString.h>
32#include <TH2F.h>
1a31a9ab 33#include <TClass.h>
dc9c6e78 34#include <TH2F.h>
35#include "TParticle.h"
36#include "TDatabasePDG.h"
37
6ae3345d 38// --- Analysis system ---
39#include "AliAnaParticleIsolation.h"
1a31a9ab 40#include "AliCaloTrackReader.h"
dc9c6e78 41#include "AliStack.h"
1a31a9ab 42#include "AliIsolationCut.h"
dc9c6e78 43#include "AliFiducialCut.h"
44#include "AliMCAnalysisUtils.h"
1a31a9ab 45#include "AliNeutralMesonSelection.h"
dc9c6e78 46#include "AliAODMCParticle.h"
1a31a9ab 47#include "AliAODPWG4ParticleCorrelation.h"
48#include "AliMCAnalysisUtils.h"
49#include "AliVTrack.h"
50#include "AliVCluster.h"
2ad19c3d 51#include "AliESDEvent.h"
52#include "AliAODEvent.h"
dc9c6e78 53// --- Detectors ---
6ae3345d 54#include "AliEMCALGeometry.h"
dc9c6e78 55#include "AliPHOSGeoUtils.h"
1a31a9ab 56
57ClassImp(AliAnaParticleIsolation)
db6fb352 58
803d06a8 59//______________________________________________________________________________
6ae3345d 60AliAnaParticleIsolation::AliAnaParticleIsolation() :
4b6cb0f2 61AliAnaCaloTrackCorrBaseClass(),
62fCalorimeter(""), fIsoDetector(""),
6ae3345d 63fReMakeIC(0), fMakeSeveralIC(0),
2ad19c3d 64fFillPileUpHistograms(0),
977564f5 65fFillTMHisto(0), fFillSSHisto(1),
66fFillUEBandSubtractHistograms(1), fFillCellHistograms(0),
67fFillHighMultHistograms(0), fFillTaggedDecayHistograms(0),
8913c8c4 68fNDecayBits(0), fDecayBits(),
4d1d8f00 69fFillNLMHistograms(0),
64373095 70fLeadingOnly(0), fCheckLeadingWithNeutralClusters(0),
dc1966bb 71fFillBackgroundBinHistograms(0), fNBkgBin(0),
db6fb352 72// Several IC
6ae3345d 73fNCones(0), fNPtThresFrac(0),
74fConeSizes(), fPtThresholds(),
db6fb352 75fPtFractions(), fSumPtThresholds(),
76// Histograms
c8710850 77fhEIso(0), fhPtIso(0),
78fhPtCentralityIso(0), fhPtEventPlaneIso(0),
79fhPtNLocMaxIso(0),
6ae3345d 80fhPhiIso(0), fhEtaIso(0), fhEtaPhiIso(0),
81fhEtaPhiNoIso(0),
9b01dc66 82fhENoIso(0), fhPtNoIso(0), fhPtNLocMaxNoIso(0),
23130491 83fhPtInCone(0),
9b01dc66 84fhPtClusterInCone(0), fhPtCellInCone(0), fhPtTrackInCone(0),
2a9171b5 85fhPtTrackInConeOtherBC(0), fhPtTrackInConeOtherBCPileUpSPD(0),
cc944149 86fhPtTrackInConeBC0(0), fhPtTrackInConeVtxBC0(0),
87fhPtTrackInConeBC0PileUpSPD(0),
17af6e24 88fhPtInConePileUp(), fhPtInConeCent(0),
23130491 89fhPerpConeSumPt(0), fhPtInPerpCone(0),
977564f5 90fhEtaPhiInConeCluster(0), fhEtaPhiCluster(0),
91fhEtaPhiInConeTrack(0), fhEtaPhiTrack(0),
23130491 92fhEtaBandCluster(0), fhPhiBandCluster(0),
93fhEtaBandTrack(0), fhPhiBandTrack(0),
9b01dc66 94fhEtaBandCell(0), fhPhiBandCell(0),
1b1a1b2e 95fhConePtLead(0), fhConePtLeadCluster(0), fhConePtLeadTrack(0),
dc1966bb 96fhConePtLeadClustervsTrack(0), fhConePtLeadClusterTrackFrac(0),
9b01dc66 97fhConeSumPt(0), fhConeSumPtCellTrack(0),
98fhConeSumPtCell(0), fhConeSumPtCluster(0), fhConeSumPtTrack(0),
23130491 99fhConeSumPtEtaBandUECluster(0), fhConeSumPtPhiBandUECluster(0),
100fhConeSumPtEtaBandUETrack(0), fhConeSumPtPhiBandUETrack(0),
9b01dc66 101fhConeSumPtEtaBandUECell(0), fhConeSumPtPhiBandUECell(0),
23130491 102fhConeSumPtTrigEtaPhi(0),
9b01dc66 103fhConeSumPtCellTrackTrigEtaPhi(0),
23130491 104fhConeSumPtEtaBandUEClusterTrigEtaPhi(0), fhConeSumPtPhiBandUEClusterTrigEtaPhi(0),
105fhConeSumPtEtaBandUETrackTrigEtaPhi(0), fhConeSumPtPhiBandUETrackTrigEtaPhi(0),
67b42f6d 106fhConeSumPtEtaBandUECellTrigEtaPhi(0), fhConeSumPtPhiBandUECellTrigEtaPhi(0),
23130491 107fhConeSumPtEtaUESub(0), fhConeSumPtPhiUESub(0),
108fhConeSumPtEtaUESubTrigEtaPhi(0), fhConeSumPtPhiUESubTrigEtaPhi(0),
9b01dc66 109fhConeSumPtEtaUESubTrackCell(0), fhConeSumPtPhiUESubTrackCell(0),
110fhConeSumPtEtaUESubTrackCellTrigEtaPhi(0), fhConeSumPtPhiUESubTrackCellTrigEtaPhi(0),
23130491 111fhConeSumPtEtaUESubCluster(0), fhConeSumPtPhiUESubCluster(0),
112fhConeSumPtEtaUESubClusterTrigEtaPhi(0), fhConeSumPtPhiUESubClusterTrigEtaPhi(0),
9b01dc66 113fhConeSumPtEtaUESubCell(0), fhConeSumPtPhiUESubCell(0),
114fhConeSumPtEtaUESubCellTrigEtaPhi(0), fhConeSumPtPhiUESubCellTrigEtaPhi(0),
23130491 115fhConeSumPtEtaUESubTrack(0), fhConeSumPtPhiUESubTrack(0),
116fhConeSumPtEtaUESubTrackTrigEtaPhi(0), fhConeSumPtPhiUESubTrackTrigEtaPhi(0),
117fhFractionTrackOutConeEta(0), fhFractionTrackOutConeEtaTrigEtaPhi(0),
118fhFractionClusterOutConeEta(0), fhFractionClusterOutConeEtaTrigEtaPhi(0),
119fhFractionClusterOutConePhi(0), fhFractionClusterOutConePhiTrigEtaPhi(0),
9b01dc66 120fhFractionCellOutConeEta(0), fhFractionCellOutConeEtaTrigEtaPhi(0),
121fhFractionCellOutConePhi(0), fhFractionCellOutConePhiTrigEtaPhi(0),
dc1966bb 122fhConeSumPtClustervsTrack(0), fhConeSumPtClusterTrackFrac(0),
814d1087 123fhConeSumPtEtaUESubClustervsTrack(0), fhConeSumPtPhiUESubClustervsTrack(0),
9b01dc66 124fhConeSumPtCellvsTrack(0),
125fhConeSumPtEtaUESubCellvsTrack(0), fhConeSumPtPhiUESubCellvsTrack(0),
814d1087 126fhEtaBandClustervsTrack(0), fhPhiBandClustervsTrack(0),
127fhEtaBandNormClustervsTrack(0), fhPhiBandNormClustervsTrack(0),
9b01dc66 128fhEtaBandCellvsTrack(0), fhPhiBandCellvsTrack(0),
129fhEtaBandNormCellvsTrack(0), fhPhiBandNormCellvsTrack(0),
b5d10017 130fhConeSumPtSubvsConeSumPtTotPhiTrack(0), fhConeSumPtSubNormvsConeSumPtTotPhiTrack(0),
131fhConeSumPtSubvsConeSumPtTotEtaTrack(0), fhConeSumPtSubNormvsConeSumPtTotEtaTrack(0),
132fhConeSumPtSubvsConeSumPtTotPhiCluster(0), fhConeSumPtSubNormvsConeSumPtTotPhiCluster(0),
133fhConeSumPtSubvsConeSumPtTotEtaCluster(0), fhConeSumPtSubNormvsConeSumPtTotEtaCluster(0),
134fhConeSumPtSubvsConeSumPtTotPhiCell(0), fhConeSumPtSubNormvsConeSumPtTotPhiCell(0),
135fhConeSumPtSubvsConeSumPtTotEtaCell(0), fhConeSumPtSubNormvsConeSumPtTotEtaCell(0),
727a309a 136fhConeSumPtVSUETracksEtaBand(0), fhConeSumPtVSUETracksPhiBand(0),
137fhConeSumPtVSUEClusterEtaBand(0), fhConeSumPtVSUEClusterPhiBand(0),
dc1966bb 138fhPtLeadConeBinLambda0(0), fhSumPtConeBinLambda0(0),
139fhPtLeadConeBinLambda0MC(0), fhSumPtConeBinLambda0MC(0),
db6fb352 140// Number of local maxima in cluster
ca134929 141fhNLocMax(),
142fhELambda0LocMax1(), fhELambda1LocMax1(),
143fhELambda0LocMax2(), fhELambda1LocMax2(),
144fhELambda0LocMaxN(), fhELambda1LocMaxN(),
2ad19c3d 145// PileUp
17af6e24 146fhEIsoPileUp(), fhPtIsoPileUp(),
147fhENoIsoPileUp(), fhPtNoIsoPileUp(),
2ad19c3d 148fhTimeENoCut(0), fhTimeESPD(0), fhTimeESPDMulti(0),
149fhTimeNPileUpVertSPD(0), fhTimeNPileUpVertTrack(0),
150fhTimeNPileUpVertContributors(0),
98287a43 151fhTimePileUpMainVertexZDistance(0), fhTimePileUpMainVertexZDiamond(0)
1a31a9ab 152{
153 //default ctor
154
155 //Initialize parameters
156 InitParameters();
db6fb352 157
b5dbb99b 158 for(Int_t i = 0; i < 5 ; i++)
dc9c6e78 159 {
160 fConeSizes[i] = 0 ;
161
124bffb3 162 for(Int_t imc = 0; imc < 9; imc++)
f5b702a0 163 fhSumPtLeadingPtMC[imc][i] = 0 ;
1a31a9ab 164
b5dbb99b 165 for(Int_t j = 0; j < 5 ; j++)
dc9c6e78 166 {
23130491 167 fhPtThresIsolated [i][j] = 0 ;
168 fhPtFracIsolated [i][j] = 0 ;
f5b702a0 169 fhSumPtIsolated [i][j] = 0 ;
23130491 170
171 fhEtaPhiPtThresIso [i][j] = 0 ;
172 fhEtaPhiPtThresDecayIso [i][j] = 0 ;
173 fhPtPtThresDecayIso [i][j] = 0 ;
174
175 fhEtaPhiPtFracIso [i][j] = 0 ;
176 fhEtaPhiPtFracDecayIso [i][j] = 0 ;
177 fhPtPtFracDecayIso [i][j] = 0 ;
178 fhPtPtSumDecayIso [i][j] = 0 ;
179 fhPtSumDensityIso [i][j] = 0 ;
180 fhPtSumDensityDecayIso [i][j] = 0 ;
181 fhEtaPhiSumDensityIso [i][j] = 0 ;
182 fhEtaPhiSumDensityDecayIso [i][j] = 0 ;
183 fhPtFracPtSumIso [i][j] = 0 ;
184 fhPtFracPtSumDecayIso [i][j] = 0 ;
185 fhEtaPhiFracPtSumIso [i][j] = 0 ;
186 fhEtaPhiFracPtSumDecayIso [i][j] = 0 ;
db6fb352 187
124bffb3 188 for(Int_t imc = 0; imc < 9; imc++)
189 {
190 fhPtThresIsolatedMC[imc][i][j] = 0 ;
191 fhPtFracIsolatedMC [imc][i][j] = 0 ;
f5b702a0 192 fhSumPtIsolatedMC [imc][i][j] = 0 ;
124bffb3 193
194 }
dc9c6e78 195 }
196 }
1a31a9ab 197
8913c8c4 198 for(Int_t ibit =0; ibit< 4; ibit++)
199 {
200 fhPtDecayIso [ibit] = 0;
201 fhPtDecayNoIso [ibit] = 0;
202 fhEtaPhiDecayIso [ibit] = 0;
203 fhEtaPhiDecayNoIso[ibit] = 0;
204 for(Int_t imc = 0; imc < 9; imc++)
205 {
206 fhPtDecayIsoMC [ibit][imc] = 0;
207 fhPtDecayNoIsoMC[ibit][imc] = 0;
208 }
209 }
210
db6fb352 211 for(Int_t i = 0; i < 5 ; i++)
dc9c6e78 212 {
213 fPtFractions [i] = 0 ;
db6fb352 214 fPtThresholds [i] = 0 ;
215 fSumPtThresholds[i] = 0 ;
ddaa6315 216
217 fhSumPtLeadingPt [i] = 0 ;
218 fhPtLeadingPt [i] = 0 ;
219 fhPerpSumPtLeadingPt[i] = 0 ;
6ae3345d 220 fhPerpPtLeadingPt [i] = 0 ;
dc9c6e78 221 }
222
124bffb3 223 for(Int_t imc = 0; imc < 9; imc++)
224 {
225 fhPtNoIsoMC [imc] = 0;
226 fhPtIsoMC [imc] = 0;
227 fhPhiIsoMC [imc] = 0;
228 fhEtaIsoMC [imc] = 0;
229 fhPtLambda0MC[imc][0] = 0;
230 fhPtLambda0MC[imc][1] = 0;
231 }
ca134929 232
233 for(Int_t i = 0; i < 2 ; i++)
dc9c6e78 234 {
ddaa6315 235 fhTrackMatchedDEta[i] = 0 ; fhTrackMatchedDPhi[i] = 0 ; fhTrackMatchedDEtaDPhi [i] = 0 ;
236 fhdEdx [i] = 0 ; fhEOverP [i] = 0 ; fhTrackMatchedMCParticle[i] = 0 ;
237 fhELambda0 [i] = 0 ; fhELambda1 [i] = 0 ; fhPtLambda0 [i] = 0 ;
238 fhELambda0TRD [i] = 0 ; fhELambda1TRD [i] = 0 ; fhPtLambda0TRD [i] = 0 ;
ca134929 239
240 // Number of local maxima in cluster
241 fhNLocMax [i] = 0 ;
242 fhELambda0LocMax1[i] = 0 ; fhELambda1LocMax1[i] = 0 ;
243 fhELambda0LocMax2[i] = 0 ; fhELambda1LocMax2[i] = 0 ;
244 fhELambda0LocMaxN[i] = 0 ; fhELambda1LocMaxN[i] = 0 ;
dc9c6e78 245 }
246
dc9c6e78 247 // Acceptance
bf8a7dac 248 for(Int_t i = 0; i < 6; i++)
dc9c6e78 249 {
250 fhPtPrimMCiso[i] = 0;
251 fhEPrimMC [i] = 0;
252 fhEtaPrimMC [i] = 0;
db4ffddf 253 fhPhiPrimMC [i] = 0;
dc9c6e78 254 }
db6fb352 255
17af6e24 256 // Pile-Up
257
258 for(Int_t i = 0 ; i < 7 ; i++)
259 {
260 fhPtInConePileUp[i] = 0 ;
261 fhEIsoPileUp [i] = 0 ;
262 fhPtIsoPileUp [i] = 0 ;
263 fhENoIsoPileUp [i] = 0 ;
264 fhPtNoIsoPileUp [i] = 0 ;
265 }
1a31a9ab 266}
267
23130491 268//_______________________________________________________________________________________________
269void AliAnaParticleIsolation::CalculateCaloUEBand(AliAODPWG4ParticleCorrelation * pCandidate,
270 Float_t & etaBandPtSum, Float_t & phiBandPtSum)
271{
272 // Get the clusters pT or sum of pT in phi/eta bands or at 45 degrees from trigger
273
72433939 274 if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
275
23130491 276 Float_t conesize = GetIsolationCut()->GetConeSize();
277 TLorentzVector mom ;
278
6ae3345d 279 //Select the Calorimeter
23130491 280 TObjArray * pl = 0x0;
281 if (fCalorimeter == "PHOS" )
282 pl = GetPHOSClusters();
283 else if (fCalorimeter == "EMCAL")
284 pl = GetEMCALClusters();
285
286 if(!pl) return ;
287
288 //Get vertex for cluster momentum calculation
289 Double_t vertex[] = {0,0,0} ; //vertex ;
290 if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
291 GetReader()->GetVertex(vertex);
292
293 Float_t ptTrig = pCandidate->Pt() ;
294 Float_t phiTrig = pCandidate->Phi();
295 Float_t etaTrig = pCandidate->Eta();
296
297 for(Int_t icluster=0; icluster < pl->GetEntriesFast(); icluster++)
298 {
299 AliVCluster* cluster = (AliVCluster *) pl->At(icluster);
300
301 if(!cluster)
302 {
303 printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Cluster not available?");
304 continue;
305 }
6ae3345d 306
23130491 307 //Do not count the candidate (photon or pi0) or the daughters of the candidate
308 if(cluster->GetID() == pCandidate->GetCaloLabel(0) ||
309 cluster->GetID() == pCandidate->GetCaloLabel(1) ) continue ;
310
72433939 311 //Remove matched clusters to tracks if Neutral and Track info is used
312 if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged &&
6ae3345d 313 IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ;
73378bcc 314
23130491 315 cluster->GetMomentum(mom,vertex) ;//Assume that come from vertex in straight line
316
317 //exclude particles in cone
318 Float_t rad = GetIsolationCut()->Radius(etaTrig, phiTrig, mom.Eta(), mom.Phi());
23130491 319
9004af1c 320 // histo of eta and phi for all clusters
321 fhEtaPhiCluster->Fill(mom.Eta(), mom.Phi());
322 if(rad < conesize) {
323 // histos for all clusters in cone
6ae3345d 324 fhEtaPhiInConeCluster->Fill(mom.Eta(), mom.Phi());
325 continue ;
9004af1c 326 }
23130491 327 //fill histogram for UE in phi band in EMCal acceptance
328 if(mom.Eta() > (etaTrig-conesize) && mom.Eta() < (etaTrig+conesize))
329 {
330 phiBandPtSum+=mom.Pt();
331 fhPhiBandCluster->Fill(mom.Eta(),mom.Phi());
9004af1c 332
6ae3345d 333 }
23130491 334
335 //fill histogram for UE in eta band in EMCal acceptance
336 if(mom.Phi() > (phiTrig-conesize) && mom.Phi() < (phiTrig+conesize))
337 {
338 etaBandPtSum+=mom.Pt();
339 fhEtaBandCluster->Fill(mom.Eta(),mom.Phi());
340 }
341 }
342
814d1087 343 fhConeSumPtEtaBandUECluster ->Fill(ptTrig , etaBandPtSum);
344 fhConeSumPtPhiBandUECluster ->Fill(ptTrig , phiBandPtSum);
23130491 345 fhConeSumPtEtaBandUEClusterTrigEtaPhi->Fill(etaTrig,phiTrig,etaBandPtSum);
346 fhConeSumPtPhiBandUEClusterTrigEtaPhi->Fill(etaTrig,phiTrig,phiBandPtSum);
6ae3345d 347
23130491 348}
349
b5d10017 350//________________________________________________________________________________________________
9b01dc66 351void AliAnaParticleIsolation::CalculateCaloCellUEBand(AliAODPWG4ParticleCorrelation * pCandidate,
352 Float_t & etaBandPtSumCells, Float_t & phiBandPtSumCells)
353{
354 // Get the cells amplitude or sum of amplitude in phi/eta bands or at 45 degrees from trigger
355
356 if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
b5d10017 357
358 Float_t conesize = GetIsolationCut()->GetConeSize();
9b01dc66 359
360 Float_t phiTrig = pCandidate->Phi();
b5d10017 361 if(phiTrig<0) phiTrig += TMath::TwoPi();
9b01dc66 362 Float_t etaTrig = pCandidate->Eta();
9b01dc66 363
b5d10017 364 if(pCandidate->GetDetector()=="EMCAL")
9b01dc66 365 {
b5d10017 366 AliEMCALGeometry* eGeom = AliEMCALGeometry::GetInstance();
367 Int_t absId = -999;
368
369 if (eGeom->GetAbsCellIdFromEtaPhi(etaTrig,phiTrig,absId))
e0ddcd8e 370 {
b5d10017 371 if(!eGeom->CheckAbsCellId(absId)) return ;
9b01dc66 372
b5d10017 373 // Get absolute (col,row) of trigger particle
374 Int_t nSupMod = eGeom->GetSuperModuleNumber(absId);
375 Int_t nModule = -1;
376 Int_t imEta=-1, imPhi=-1;
377 Int_t ieta =-1, iphi =-1;
6ae3345d 378
b5d10017 379 if (eGeom->GetCellIndex(absId,nSupMod,nModule,imPhi,imEta))
380 {
381 eGeom->GetCellPhiEtaIndexInSModule(nSupMod,nModule,imPhi,imEta,iphi,ieta);
382
383 Int_t colTrig = ieta;
384 if (nSupMod % 2) colTrig = AliEMCALGeoParams::fgkEMCALCols + ieta ;
385 Int_t rowTrig = iphi + AliEMCALGeoParams::fgkEMCALRows*int(nSupMod/2);
386
387 Int_t sqrSize = int(conesize/0.0143);
388
389 AliVCaloCells * cells = GetEMCALCells();
390
10a65cc6 391 Int_t nTotalRows = AliEMCALGeoParams::fgkEMCALRows*16/3 ; // 24*(16/3) 5 full-size Sectors (2 SM) + 1 one-third Sector (2 SM)
392 Int_t nTotalCols = 2*AliEMCALGeoParams::fgkEMCALCols;
6ae3345d 393 // printf("nTotalRows %i, nTotalCols %i\n",nTotalRows,nTotalCols);
b5d10017 394 // Loop on cells in eta band
6ae3345d 395
10a65cc6 396 Int_t irowmin = rowTrig-sqrSize;
6ae3345d 397 if(irowmin<0) irowmin=0;
398 Int_t irowmax = rowTrig+sqrSize;
399 if(irowmax>AliEMCALGeoParams::fgkEMCALRows) irowmax=AliEMCALGeoParams::fgkEMCALRows;
400
401
10a65cc6 402 for(Int_t irow = irowmin; irow <irowmax; irow++)
b5d10017 403 {
10a65cc6 404 for(Int_t icol = 0; icol < nTotalCols; icol++)
b5d10017 405 {
406 Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
6ae3345d 407 if(inSector==5) continue;
408 Int_t inSupMod = -1;
b5d10017 409 Int_t icolLoc = -1;
410 if(icol < AliEMCALGeoParams::fgkEMCALCols)
411 {
ea051413 412 inSupMod = 2*inSector + 1;
b5d10017 413 icolLoc = icol;
414 }
415 else if(icol > AliEMCALGeoParams::fgkEMCALCols - 1)
416 {
ea051413 417 inSupMod = 2*inSector;
b5d10017 418 icolLoc = icol-AliEMCALGeoParams::fgkEMCALCols;
419 }
420
b5c8089d 421 Int_t irowLoc = irow - AliEMCALGeoParams::fgkEMCALRows*inSector ;
6ae3345d 422
b5d10017 423 // Exclude cells in cone
9004af1c 424 if(TMath::Abs(icol-colTrig) < sqrSize || TMath::Abs(irow-rowTrig) < sqrSize){
6ae3345d 425 continue ;
9004af1c 426 }
b5d10017 427 Int_t iabsId = eGeom->GetAbsCellIdFromCellIndexes(inSupMod,irowLoc,icolLoc);
428 if(!eGeom->CheckAbsCellId(iabsId)) continue;
429 etaBandPtSumCells += cells->GetCellAmplitude(iabsId);
6ae3345d 430 fhEtaBandCell->Fill(colTrig,rowTrig);
431
432 // printf("ETA inSupMod %i,irowLoc %i,icolLoc %i, iabsId %i, etaBandPtSumCells %f\n",nSupMod,irowLoc,icolLoc,iabsId,etaBandPtSumCells);
433 }
b5d10017 434 }
6ae3345d 435 Int_t icolmin = colTrig-sqrSize;
436 if(icolmin<0) icolmin=0;
437 Int_t icolmax = colTrig+sqrSize;
438 if(icolmax>AliEMCALGeoParams::fgkEMCALCols) icolmax=AliEMCALGeoParams::fgkEMCALCols;
10a65cc6 439
b5d10017 440 // Loop on cells in phi band
10a65cc6 441 for(Int_t icol = icolmin; icol < icolmax; icol++)
b5d10017 442 {
443 for(Int_t irow = 0; irow < nTotalRows; irow++)
6ae3345d 444 {
b5d10017 445 Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
6ae3345d 446 if(inSector==5) continue;
b5d10017 447 Int_t inSupMod = -1;
448 Int_t icolLoc = -1;
6ae3345d 449 // printf("icol %i, irow %i, inSector %i\n",icol,irow ,inSector);
b5d10017 450 if(icol < AliEMCALGeoParams::fgkEMCALCols)
451 {
6ae3345d 452 // printf("icol < AliEMCALGeoParams::fgkEMCALCols %i\n",AliEMCALGeoParams::fgkEMCALCols );
ea051413 453 inSupMod = 2*inSector + 1;
b5d10017 454 icolLoc = icol;
455 }
456 else if(icol > AliEMCALGeoParams::fgkEMCALCols - 1)
457 {
6ae3345d 458 // printf("icol > AliEMCALGeoParams::fgkEMCALCols -1 %i\n",AliEMCALGeoParams::fgkEMCALCols -1 );
459 inSupMod = 2*inSector;
b5d10017 460 icolLoc = icol-AliEMCALGeoParams::fgkEMCALCols;
461 }
462
ea051413 463 Int_t irowLoc = irow - AliEMCALGeoParams::fgkEMCALRows*inSector ; // Stesso problema di sopra //
6ae3345d 464
b5d10017 465 // Exclude cells in cone
10a65cc6 466 if(TMath::Abs(icol-colTrig) < sqrSize) {
6ae3345d 467 //printf("TMath::Abs(icol-colTrig) %i < sqrSize %i\n",TMath::Abs(icol-colTrig) ,sqrSize);continue ;
468 }
10a65cc6 469 if(TMath::Abs(irow-rowTrig) < sqrSize) {
6ae3345d 470 //printf("TMath::Abs(irow-rowTrig) %i < sqrSize %i\n",TMath::Abs(irow-rowTrig) ,sqrSize);continue ;
471 }
b5d10017 472
473 Int_t iabsId = eGeom->GetAbsCellIdFromCellIndexes(inSupMod,irowLoc,icolLoc);
10a65cc6 474 if(!eGeom->CheckAbsCellId(iabsId)) {printf("!eGeom->CheckAbsCellId(iabsId=%i) inSupMod %i irowLoc %i icolLoc %i \n",iabsId,inSupMod, irowLoc, icolLoc);continue;}
b5d10017 475 phiBandPtSumCells += cells->GetCellAmplitude(iabsId);
6ae3345d 476 fhPhiBandCell->Fill(colTrig,rowTrig);
477 //printf("inSupMod %i,irowLoc %i,icolLoc %i, iabsId %i, phiBandPtSumCells %f\n",nSupMod,irowLoc,icolLoc,iabsId,phiBandPtSumCells);
478 }
b5d10017 479 }
480 }
9b01dc66 481 }
482 }
483
484 Float_t ptTrig = pCandidate->Pt();
485
486 fhConeSumPtEtaBandUECell ->Fill(ptTrig , etaBandPtSumCells);
487 fhConeSumPtPhiBandUECell ->Fill(ptTrig , phiBandPtSumCells);
488 fhConeSumPtEtaBandUECellTrigEtaPhi->Fill(etaTrig,phiTrig,etaBandPtSumCells);
489 fhConeSumPtPhiBandUECellTrigEtaPhi->Fill(etaTrig,phiTrig,phiBandPtSumCells);
490
491}
492
23130491 493//________________________________________________________________________________________________
494void AliAnaParticleIsolation::CalculateTrackUEBand(AliAODPWG4ParticleCorrelation * pCandidate,
495 Float_t & etaBandPtSum, Float_t & phiBandPtSum)
496{
497 // Get the track pT or sum of pT in phi/eta bands or at 45 degrees from trigger
498
72433939 499 if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyNeutral ) return ;
500
23130491 501 Float_t conesize = GetIsolationCut()->GetConeSize();
502
503 Double_t sumptPerp= 0. ;
504 Float_t ptTrig = pCandidate->Pt() ;
505 Float_t phiTrig = pCandidate->Phi();
506 Float_t etaTrig = pCandidate->Eta();
507
508 TObjArray * trackList = GetCTSTracks() ;
509 for(Int_t itrack=0; itrack < trackList->GetEntriesFast(); itrack++)
510 {
511 AliVTrack* track = (AliVTrack *) trackList->At(itrack);
512
513 if(!track)
514 {
727a309a 515 printf("AliAnaParticleIsolation::CalculateTrackUEBand() - Track not available?");
23130491 516 continue;
517 }
518
519 //Do not count the candidate (pion, conversion photon) or the daughters of the candidate
520 if(track->GetID() == pCandidate->GetTrackLabel(0) || track->GetID() == pCandidate->GetTrackLabel(1) ||
521 track->GetID() == pCandidate->GetTrackLabel(2) || track->GetID() == pCandidate->GetTrackLabel(3) ) continue ;
6ae3345d 522
523 // histo of eta:phi for all tracks
9004af1c 524 fhEtaPhiTrack->Fill(track->Eta(),track->Phi());
6ae3345d 525
23130491 526 //exclude particles in cone
527 Float_t rad = GetIsolationCut()->Radius(etaTrig, phiTrig, track->Eta(), track->Phi());
9004af1c 528 if(rad < conesize) {
529 // histo of eta:phi for all tracks in cone
6ae3345d 530 fhEtaPhiInConeTrack->Fill(track->Eta(),track->Phi());
9004af1c 531 continue ;
532 }
23130491 533
534 //fill histogram for UE in phi band
535 if(track->Eta() > (etaTrig-conesize) && track->Eta() < (etaTrig+conesize))
536 {
537 phiBandPtSum+=track->Pt();
538 fhPhiBandTrack->Fill(track->Eta(),track->Phi());
539 }
540
541 //fill histogram for UE in eta band in EMCal acceptance
6ae3345d 542 if(track->Phi() > (phiTrig-conesize) && track->Phi() < (phiTrig+conesize))
23130491 543 {
544 etaBandPtSum+=track->Pt();
545 fhEtaBandTrack->Fill(track->Eta(),track->Phi());
546 }
547
548 //fill the histograms at +-45 degrees in phi from trigger particle, perpedicular to trigger axis in phi
549 Double_t dPhi = phiTrig - track->Phi() + TMath::PiOver2();
550 Double_t dEta = etaTrig - track->Eta();
551 Double_t arg = dPhi*dPhi + dEta*dEta;
552 if(TMath::Sqrt(arg) < conesize)
553 {
554 fhPtInPerpCone->Fill(ptTrig,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
555 sumptPerp+=track->Pt();
556 }
557
558 dPhi = phiTrig - track->Phi() - TMath::PiOver2();
559 arg = dPhi*dPhi + dEta*dEta;
560 if(TMath::Sqrt(arg) < conesize)
561 {
562 fhPtInPerpCone->Fill(ptTrig,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
563 sumptPerp+=track->Pt();
564 }
565 }
566
814d1087 567 fhPerpConeSumPt ->Fill(ptTrig , sumptPerp );
568 fhConeSumPtEtaBandUETrack ->Fill(ptTrig , etaBandPtSum);
569 fhConeSumPtPhiBandUETrack ->Fill(ptTrig , phiBandPtSum);
23130491 570 fhConeSumPtEtaBandUETrackTrigEtaPhi->Fill(etaTrig,phiTrig,etaBandPtSum);
571 fhConeSumPtPhiBandUETrackTrigEtaPhi->Fill(etaTrig,phiTrig,phiBandPtSum);
6ae3345d 572
23130491 573}
574
0e7a6570 575
0e7a6570 576
b94e038e 577//_____________________________________________________________________________________________________________________________________
578void AliAnaParticleIsolation::CalculateNormalizeUEBandPerUnitArea(AliAODPWG4ParticleCorrelation * pCandidate, Float_t coneptsumCluster,
579 Float_t coneptsumCell, Float_t coneptsumTrack,
580 Float_t &etaBandptsumTrackNorm, Float_t &etaBandptsumClusterNorm)
23130491 581{
582 //normalize phi/eta band per area unit
6ae3345d 583
23130491 584 Float_t etaUEptsumTrack = 0 ;
585 Float_t phiUEptsumTrack = 0 ;
586 Float_t etaUEptsumCluster = 0 ;
587 Float_t phiUEptsumCluster = 0 ;
9b01dc66 588 Float_t etaUEptsumCell = 0 ;
589 Float_t phiUEptsumCell = 0 ;
590
72433939 591 Int_t partTypeInCone = GetIsolationCut()->GetParticleTypeInCone();
23130491 592
23130491 593 // Do the normalization
594
595 Float_t conesize = GetIsolationCut()->GetConeSize();
596 Float_t coneA = conesize*conesize*TMath::Pi(); // A = pi R^2, isolation cone area
597 Float_t ptTrig = pCandidate->Pt() ;
598 Float_t phiTrig = pCandidate->Phi();
599 Float_t etaTrig = pCandidate->Eta();
727a309a 600
6ae3345d 601
23130491 602 // ------ //
603 // Tracks //
604 // ------ //
72433939 605 Float_t phiUEptsumTrackNorm = 0 ;
606 Float_t etaUEptsumTrackNorm = 0 ;
607 Float_t coneptsumTrackSubPhi = 0 ;
608 Float_t coneptsumTrackSubEta = 0 ;
b5d10017 609 Float_t coneptsumTrackSubPhiNorm = 0 ;
610 Float_t coneptsumTrackSubEtaNorm = 0 ;
727a309a 611 etaBandptsumTrackNorm = 0 ;
6ae3345d 612
72433939 613 if( partTypeInCone!=AliIsolationCut::kOnlyNeutral )
23130491 614 {
727a309a 615 // Sum the pT in the phi or eta band for clusters or tracks
616 CalculateTrackUEBand (pCandidate,etaUEptsumTrack ,phiUEptsumTrack );// rajouter ici l'histo eta phi
6ae3345d 617
618 //Fill histos
619 fhConeSumPtVSUETracksEtaBand->Fill(coneptsumTrack,etaUEptsumTrack);
620 fhConeSumPtVSUETracksPhiBand->Fill(coneptsumTrack,phiUEptsumTrack);
621
622
727a309a 623 Float_t correctConeSumTrack = 1;
624 Float_t correctConeSumTrackPhi = 1;
6ae3345d 625
727a309a 626 GetIsolationCut()->CalculateUEBandTrackNormalization(GetReader(),etaTrig, phiTrig,
6ae3345d 627 phiUEptsumTrack,etaUEptsumTrack,
628 phiUEptsumTrackNorm,etaUEptsumTrackNorm,
629 correctConeSumTrack,correctConeSumTrackPhi);
630
727a309a 631 coneptsumTrackSubPhi = coneptsumTrack - phiUEptsumTrackNorm;
632 coneptsumTrackSubEta = coneptsumTrack - etaUEptsumTrackNorm;
6ae3345d 633
727a309a 634 etaBandptsumTrackNorm = etaUEptsumTrackNorm;
72433939 635
636 fhConeSumPtPhiUESubTrack ->Fill(ptTrig , coneptsumTrackSubPhi);
637 fhConeSumPtPhiUESubTrackTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumTrackSubPhi);
638 fhConeSumPtEtaUESubTrack ->Fill(ptTrig , coneptsumTrackSubEta);
639 fhConeSumPtEtaUESubTrackTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumTrackSubEta);
640
641 fhFractionTrackOutConeEta ->Fill(ptTrig , correctConeSumTrack-1);
642 fhFractionTrackOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig,correctConeSumTrack-1);
b5d10017 643
727a309a 644 if(coneptsumTrack > 0)
645 {
646 coneptsumTrackSubPhiNorm = coneptsumTrackSubPhi/coneptsumTrack;
10a65cc6 647 coneptsumTrackSubEtaNorm = coneptsumTrackSubEta/coneptsumTrack;
648 }
727a309a 649
b5d10017 650 fhConeSumPtSubvsConeSumPtTotPhiTrack ->Fill(coneptsumTrack,coneptsumTrackSubPhi);
651 fhConeSumPtSubNormvsConeSumPtTotPhiTrack->Fill(coneptsumTrack,coneptsumTrackSubPhiNorm);
652 fhConeSumPtSubvsConeSumPtTotEtaTrack ->Fill(coneptsumTrack,coneptsumTrackSubEta);
653 fhConeSumPtSubNormvsConeSumPtTotEtaTrack->Fill(coneptsumTrack,coneptsumTrackSubEtaNorm);
654
72433939 655 }
23130491 656
9b01dc66 657 // ------------------------ //
658 // EMCal Clusters and cells //
659 // ------------------------ //
72433939 660 Float_t phiUEptsumClusterNorm = 0 ;
661 Float_t etaUEptsumClusterNorm = 0 ;
662 Float_t coneptsumClusterSubPhi = 0 ;
663 Float_t coneptsumClusterSubEta = 0 ;
b5d10017 664 Float_t coneptsumClusterSubPhiNorm = 0 ;
665 Float_t coneptsumClusterSubEtaNorm = 0 ;
9b01dc66 666 Float_t phiUEptsumCellNorm = 0 ;
667 Float_t etaUEptsumCellNorm = 0 ;
668 Float_t coneptsumCellSubPhi = 0 ;
669 Float_t coneptsumCellSubEta = 0 ;
b5d10017 670 Float_t coneptsumCellSubPhiNorm = 0 ;
671 Float_t coneptsumCellSubEtaNorm = 0 ;
727a309a 672 etaBandptsumClusterNorm = 0;
6ae3345d 673
72433939 674 if( partTypeInCone!=AliIsolationCut::kOnlyCharged )
23130491 675 {
977564f5 676
9b01dc66 677 // -------------- //
678 // EMCal clusters //
679 // -------------- //
72433939 680
727a309a 681 // Sum the pT in the phi or eta band for clusters or tracks
682 CalculateCaloUEBand (pCandidate,etaUEptsumCluster,phiUEptsumCluster);// rajouter ici l'histo eta phi
977564f5 683
684 //Fill histos
685 fhConeSumPtVSUEClusterEtaBand->Fill(coneptsumCluster,etaUEptsumCluster);
686 fhConeSumPtVSUEClusterPhiBand->Fill(coneptsumCluster,phiUEptsumCluster);
687
688
727a309a 689 Float_t correctConeSumClusterEta = 1;
72433939 690 Float_t correctConeSumClusterPhi = 1;
977564f5 691
727a309a 692 GetIsolationCut()->CalculateUEBandClusterNormalization(GetReader(),etaTrig, phiTrig,
693 phiUEptsumCluster,etaUEptsumCluster,
694 phiUEptsumClusterNorm,etaUEptsumClusterNorm,
695 correctConeSumClusterEta,correctConeSumClusterPhi);
72433939 696
697 // In case that cone is out of eta and phi side, we are over correcting, not too often with the current cuts ...
727a309a 698 // Comment if not used
699 // Float_t coneBadCellsCoeff =1;
700 // Float_t etaBandBadCellsCoeff=1;
701 // Float_t phiBandBadCellsCoeff=1;
702 // GetIsolationCut()->GetCoeffNormBadCell(pCandidate, GetReader(),coneBadCellsCoeff,etaBandBadCellsCoeff,phiBandBadCellsCoeff) ;
977564f5 703
727a309a 704 //coneptsumCluster=coneptsumCluster*coneBadCellsCoeff*correctConeSumClusterEta*correctConeSumClusterPhi;
705
706 coneptsumClusterSubPhi = coneptsumCluster - phiUEptsumClusterNorm;
26a8bf11 707 coneptsumClusterSubEta = coneptsumCluster - etaUEptsumClusterNorm;
72433939 708
727a309a 709 etaBandptsumClusterNorm = etaUEptsumClusterNorm;
977564f5 710
72433939 711 fhConeSumPtPhiUESubCluster ->Fill(ptTrig , coneptsumClusterSubPhi);
712 fhConeSumPtPhiUESubClusterTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumClusterSubPhi);
713 fhConeSumPtEtaUESubCluster ->Fill(ptTrig , coneptsumClusterSubEta);
714 fhConeSumPtEtaUESubClusterTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumClusterSubEta);
715
716 fhFractionClusterOutConeEta ->Fill(ptTrig , correctConeSumClusterEta-1);
717 fhFractionClusterOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumClusterEta-1);
718 fhFractionClusterOutConePhi ->Fill(ptTrig , correctConeSumClusterPhi-1);
719 fhFractionClusterOutConePhiTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumClusterPhi-1);
9b01dc66 720
727a309a 721 if(coneptsumCluster!=0)
722 {
10a65cc6 723 coneptsumClusterSubPhiNorm = coneptsumClusterSubPhi/coneptsumCluster;
724 coneptsumClusterSubEtaNorm = coneptsumClusterSubEta/coneptsumCluster;
725 }
727a309a 726
b5d10017 727 fhConeSumPtSubvsConeSumPtTotPhiCluster ->Fill(coneptsumCluster,coneptsumClusterSubPhi);
728 fhConeSumPtSubNormvsConeSumPtTotPhiCluster->Fill(coneptsumCluster,coneptsumClusterSubPhiNorm);
729 fhConeSumPtSubvsConeSumPtTotEtaCluster ->Fill(coneptsumCluster,coneptsumClusterSubEta);
730 fhConeSumPtSubNormvsConeSumPtTotEtaCluster->Fill(coneptsumCluster,coneptsumClusterSubEtaNorm);
731
9b01dc66 732 // ----------- //
733 // EMCal Cells //
734 // ----------- //
727a309a 735
977564f5 736 if(fFillCellHistograms)
9b01dc66 737 {
977564f5 738 // Sum the pT in the phi or eta band for clusters or tracks
739 CalculateCaloCellUEBand(pCandidate,etaUEptsumCell ,phiUEptsumCell );
9b01dc66 740
977564f5 741 // Move to AliIsolationCut the calculation not the histograms??
b5d10017 742
977564f5 743 //Careful here if EMCal limits changed .. 2010 (4 SM) to 2011-12 (10 SM), for the moment consider 100 deg in phi
744 Float_t emcEtaSize = 0.7*2; // TO FIX
745 Float_t emcPhiSize = TMath::DegToRad()*100.; // TO FIX
746
747 if(((2*conesize*emcPhiSize)-coneA)!=0)phiUEptsumCellNorm = phiUEptsumCell*(coneA / ((2*conesize*emcPhiSize)-coneA));
748 if(((2*conesize*emcEtaSize)-coneA)!=0)etaUEptsumCellNorm = etaUEptsumCell*(coneA / ((2*conesize*emcEtaSize)-coneA));
749
750 // Need to correct coneptsumCluster by the fraction of the cone out of the calorimeter cut acceptance!
751
752 Float_t correctConeSumCellEta = 1;
753 if(TMath::Abs(etaTrig)+conesize > emcEtaSize/2.)
754 {
755 Float_t excess = TMath::Abs(etaTrig) + conesize - emcEtaSize/2.;
756 correctConeSumCellEta = GetIsolationCut()->CalculateExcessAreaFraction(excess);
757 //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);
758 // Need to correct phi band surface if part of the cone falls out of track cut acceptance!
759 if(((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumCellEta))!=0)phiUEptsumCellNorm = phiUEptsumCell*(coneA / ((2*(conesize-excess)*emcPhiSize)-(coneA-correctConeSumCellEta)));
760 }
761
762 Float_t correctConeSumCellPhi = 1;
763 //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() );
764 if((phiTrig+conesize > 180*TMath::DegToRad()) ||
765 (phiTrig-conesize < 80*TMath::DegToRad()))
766 {
767 Float_t excess = 0;
768 if( phiTrig+conesize > 180*TMath::DegToRad() ) excess = conesize + phiTrig - 180*TMath::DegToRad() ;
769 else excess = conesize - phiTrig + 80*TMath::DegToRad() ;
770
771 correctConeSumCellPhi = GetIsolationCut()->CalculateExcessAreaFraction(excess);
772 //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);
773
774 // Need to correct eta band surface if part of the cone falls out of track cut acceptance!
775 if(((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumCellPhi))!=0)etaUEptsumCellNorm = etaUEptsumCell*(coneA / ((2*(conesize-excess)*emcEtaSize)-(coneA-correctConeSumCellPhi)));
776
777 }
778
779 // In case that cone is out of eta and phi side, we are over correcting, not too often with the current cuts ...
780 coneptsumCellSubPhi = coneptsumCell*correctConeSumCellEta*correctConeSumCellPhi - phiUEptsumCellNorm;
781 coneptsumCellSubEta = coneptsumCell*correctConeSumCellEta*correctConeSumCellPhi - etaUEptsumCellNorm;
782
783 fhConeSumPtPhiUESubCell ->Fill(ptTrig , coneptsumCellSubPhi);
784 fhConeSumPtPhiUESubCellTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumCellSubPhi);
785 fhConeSumPtEtaUESubCell ->Fill(ptTrig , coneptsumCellSubEta);
786 fhConeSumPtEtaUESubCellTrigEtaPhi ->Fill(etaTrig, phiTrig, coneptsumCellSubEta);
787
788 fhFractionCellOutConeEta ->Fill(ptTrig , correctConeSumCellEta-1);
789 fhFractionCellOutConeEtaTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumCellEta-1);
790 fhFractionCellOutConePhi ->Fill(ptTrig , correctConeSumCellPhi-1);
791 fhFractionCellOutConePhiTrigEtaPhi->Fill(etaTrig, phiTrig, correctConeSumCellPhi-1);
792 if(coneptsumCell!=0)
793 {
794 coneptsumCellSubPhiNorm = coneptsumCellSubPhi/coneptsumCell;
795 coneptsumCellSubEtaNorm = coneptsumCellSubEta/coneptsumCell;
796 }
797
798 fhConeSumPtSubvsConeSumPtTotPhiCell ->Fill(coneptsumCell,coneptsumCellSubPhi);
799 fhConeSumPtSubNormvsConeSumPtTotPhiCell->Fill(coneptsumCell,coneptsumCellSubPhiNorm);
800 fhConeSumPtSubvsConeSumPtTotEtaCell ->Fill(coneptsumCell,coneptsumCellSubEta);
801 fhConeSumPtSubNormvsConeSumPtTotEtaCell->Fill(coneptsumCell,coneptsumCellSubEtaNorm);
10a65cc6 802 }
23130491 803 }
977564f5 804
72433939 805 if( partTypeInCone==AliIsolationCut::kNeutralAndCharged )
806 {
9b01dc66 807 // --------------------------- //
808 // Tracks and clusters in cone //
809 // --------------------------- //
72433939 810
811 Double_t sumPhiUESub = coneptsumClusterSubPhi + coneptsumTrackSubPhi;
812 Double_t sumEtaUESub = coneptsumClusterSubEta + coneptsumTrackSubEta;
813
814 fhConeSumPtPhiUESub ->Fill(ptTrig , sumPhiUESub);
815 fhConeSumPtPhiUESubTrigEtaPhi->Fill(etaTrig, phiTrig, sumPhiUESub);
816 fhConeSumPtEtaUESub ->Fill(ptTrig , sumEtaUESub);
817 fhConeSumPtEtaUESubTrigEtaPhi->Fill(etaTrig, phiTrig, sumEtaUESub);
818
9b01dc66 819 fhEtaBandClustervsTrack ->Fill(etaUEptsumCluster ,etaUEptsumTrack );
820 fhPhiBandClustervsTrack ->Fill(phiUEptsumCluster ,phiUEptsumTrack );
72433939 821 fhEtaBandNormClustervsTrack->Fill(etaUEptsumClusterNorm,etaUEptsumTrackNorm);
822 fhPhiBandNormClustervsTrack->Fill(phiUEptsumClusterNorm,phiUEptsumTrackNorm);
823
824 fhConeSumPtEtaUESubClustervsTrack->Fill(coneptsumClusterSubEta,coneptsumTrackSubEta);
825 fhConeSumPtPhiUESubClustervsTrack->Fill(coneptsumClusterSubPhi,coneptsumTrackSubPhi);
977564f5 826
9b01dc66 827 // ------------------------ //
828 // Tracks and cells in cone //
829 // ------------------------ //
830
977564f5 831 if(fFillCellHistograms)
832 {
833 Double_t sumPhiUESubTrackCell = coneptsumCellSubPhi + coneptsumTrackSubPhi;
834 Double_t sumEtaUESubTrackCell = coneptsumCellSubEta + coneptsumTrackSubEta;
835
836 fhConeSumPtPhiUESubTrackCell ->Fill(ptTrig , sumPhiUESubTrackCell);
837 fhConeSumPtPhiUESubTrackCellTrigEtaPhi->Fill(etaTrig, phiTrig, sumPhiUESubTrackCell);
838 fhConeSumPtEtaUESubTrackCell ->Fill(ptTrig , sumEtaUESubTrackCell);
839 fhConeSumPtEtaUESubTrackCellTrigEtaPhi->Fill(etaTrig, phiTrig, sumEtaUESubTrackCell);
840
841 fhEtaBandCellvsTrack ->Fill(etaUEptsumCell ,etaUEptsumTrack );
842 fhPhiBandCellvsTrack ->Fill(phiUEptsumCell ,phiUEptsumTrack );
843 fhEtaBandNormCellvsTrack->Fill(etaUEptsumCellNorm,etaUEptsumTrackNorm);
844 fhPhiBandNormCellvsTrack->Fill(phiUEptsumCellNorm,phiUEptsumTrackNorm);
845
846 fhConeSumPtEtaUESubCellvsTrack->Fill(coneptsumCellSubEta,coneptsumTrackSubEta);
847 fhConeSumPtPhiUESubCellvsTrack->Fill(coneptsumCellSubPhi,coneptsumTrackSubPhi);
848 }
9b01dc66 849
72433939 850 }
23130491 851}
852
853
1b1a1b2e 854//______________________________________________________________________________________________________________
23130491 855void AliAnaParticleIsolation::CalculateCaloSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
1b1a1b2e 856 Float_t & coneptsumCluster, Float_t & coneptLeadCluster)
23130491 857{
858 // Get the cluster pT or sum of pT in isolation cone
1b1a1b2e 859 coneptLeadCluster = 0;
860 coneptsumCluster = 0;
23130491 861
72433939 862 if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
863
23130491 864 //Recover reference arrays with clusters and tracks
6ae3345d 865 TObjArray * refclusters = aodParticle->GetObjArray(GetAODObjArrayName()+"Clusters");
23130491 866 if(!refclusters) return ;
867
868 Float_t ptTrig = aodParticle->Pt();
6ae3345d 869
23130491 870 //Get vertex for cluster momentum calculation
871 Double_t vertex[] = {0,0,0} ; //vertex ;
872 if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
873 GetReader()->GetVertex(vertex);
874
875 TLorentzVector mom ;
876 for(Int_t icalo=0; icalo < refclusters->GetEntriesFast(); icalo++)
877 {
878 AliVCluster* calo = (AliVCluster *) refclusters->At(icalo);
879 calo->GetMomentum(mom,vertex) ;//Assume that come from vertex in straight line
880
881 fhPtInCone ->Fill(ptTrig, mom.Pt());
882 fhPtClusterInCone->Fill(ptTrig, mom.Pt());
883
884 if(fFillPileUpHistograms)
885 {
886 if(GetReader()->IsPileUpFromSPD()) fhPtInConePileUp[0]->Fill(ptTrig,mom.Pt());
887 if(GetReader()->IsPileUpFromEMCal()) fhPtInConePileUp[1]->Fill(ptTrig,mom.Pt());
888 if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtInConePileUp[2]->Fill(ptTrig,mom.Pt());
889 if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtInConePileUp[3]->Fill(ptTrig,mom.Pt());
890 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtInConePileUp[4]->Fill(ptTrig,mom.Pt());
891 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtInConePileUp[5]->Fill(ptTrig,mom.Pt());
892 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtInConePileUp[6]->Fill(ptTrig,mom.Pt());
893 }
894
977564f5 895 if(fFillHighMultHistograms) fhPtInConeCent->Fill(GetEventCentrality(),mom.Pt());
896
23130491 897 coneptsumCluster+=mom.Pt();
1b1a1b2e 898 if(mom.Pt() > coneptLeadCluster) coneptLeadCluster = mom.Pt();
72433939 899 }
6ae3345d 900
1b1a1b2e 901 fhConeSumPtCluster ->Fill(ptTrig, coneptsumCluster );
902 fhConePtLeadCluster->Fill(ptTrig, coneptLeadCluster);
23130491 903}
904
b94e038e 905//______________________________________________________________________________________________________
9b01dc66 906void AliAnaParticleIsolation::CalculateCaloCellSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
907 Float_t & coneptsumCell)
908{
b5d10017 909 // Get the cell amplityde or sum of amplitudes in isolation cone
910 // Mising: Remove signal cells in cone in case the trigger is a cluster!
9b01dc66 911
912 if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyCharged ) return ;
b5d10017 913
9b01dc66 914 Float_t conesize = GetIsolationCut()->GetConeSize();
915
916 Float_t ptTrig = aodParticle->Pt();
917 Float_t phiTrig = aodParticle->Phi();
b5d10017 918 if(phiTrig<0) phiTrig += TMath::TwoPi();
9b01dc66 919 Float_t etaTrig = aodParticle->Eta();
920
b5d10017 921 if(aodParticle->GetDetector()=="EMCAL")
9b01dc66 922 {
b5d10017 923 AliEMCALGeometry* eGeom = AliEMCALGeometry::GetInstance();
924 Int_t absId = -999;
925
926 if (eGeom->GetAbsCellIdFromEtaPhi(etaTrig,phiTrig,absId))
9b01dc66 927 {
b5d10017 928 if(!eGeom->CheckAbsCellId(absId)) return ;
9b01dc66 929
b5d10017 930 // Get absolute (col,row) of trigger particle
931 Int_t nSupMod = eGeom->GetSuperModuleNumber(absId);
932 Int_t nModule = -1;
933 Int_t imEta=-1, imPhi=-1;
934 Int_t ieta =-1, iphi =-1;
6ae3345d 935
b5d10017 936 if (eGeom->GetCellIndex(absId,nSupMod,nModule,imPhi,imEta))
937 {
938 Int_t iEta=-1, iPhi=-1;
939 eGeom->GetCellPhiEtaIndexInSModule(nSupMod,nModule,imPhi,imEta,iphi,ieta);
940
941 Int_t colTrig = iEta;
942 if (nSupMod % 2) colTrig = AliEMCALGeoParams::fgkEMCALCols + iEta ;
943 Int_t rowTrig = iPhi + AliEMCALGeoParams::fgkEMCALRows*int(nSupMod/2);
944
945 Int_t sqrSize = int(conesize/0.0143);
946
947 AliVCaloCells * cells = GetEMCALCells();
948
949 // Loop on cells in cone
950 for(Int_t irow = rowTrig-sqrSize; irow < rowTrig+sqrSize; irow++)
951 {
10a65cc6 952 for(Int_t icol = colTrig-sqrSize; icol < colTrig+sqrSize; icol++)
b5d10017 953 {
954 Int_t inSector = int(irow/AliEMCALGeoParams::fgkEMCALRows);
6ae3345d 955 if(inSector==5) continue;
956
957 Int_t inSupMod = -1;
b5d10017 958 Int_t icolLoc = -1;
959 if(icol < AliEMCALGeoParams::fgkEMCALCols)
960 {
ea051413 961 inSupMod = 2*inSector + 1;
b5d10017 962 icolLoc = icol;
963 }
964 else if(icol > AliEMCALGeoParams::fgkEMCALCols - 1)
965 {
ea051413 966 inSupMod = 2*inSector;
b5d10017 967 icolLoc = icol-AliEMCALGeoParams::fgkEMCALCols;
968 }
969
b5c8089d 970 Int_t irowLoc = irow - AliEMCALGeoParams::fgkEMCALRows*inSector ;
b5d10017 971
972 Int_t iabsId = eGeom->GetAbsCellIdFromCellIndexes(inSupMod,irowLoc,icolLoc);
973 if(!eGeom->CheckAbsCellId(iabsId)) continue;
974
975 fhPtCellInCone->Fill(ptTrig, cells->GetCellAmplitude(iabsId));
976 coneptsumCell += cells->GetCellAmplitude(iabsId);
977 }
978 }
979 }
9b01dc66 980 }
981 }
982
983 fhConeSumPtCell->Fill(ptTrig,coneptsumCell);
b5d10017 984
9b01dc66 985}
986
1b1a1b2e 987//___________________________________________________________________________________________________________
23130491 988void AliAnaParticleIsolation::CalculateTrackSignalInCone(AliAODPWG4ParticleCorrelation * aodParticle,
1b1a1b2e 989 Float_t & coneptsumTrack, Float_t & coneptLeadTrack)
23130491 990{
991 // Get the track pT or sum of pT in isolation cone
992
72433939 993 if( GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kOnlyNeutral ) return ;
994
23130491 995 //Recover reference arrays with clusters and tracks
996 TObjArray * reftracks = aodParticle->GetObjArray(GetAODObjArrayName()+"Tracks");
997 if(!reftracks) return ;
998
999 Float_t ptTrig = aodParticle->Pt();
1000 Double_t bz = GetReader()->GetInputEvent()->GetMagneticField();
6ae3345d 1001
23130491 1002 for(Int_t itrack=0; itrack < reftracks->GetEntriesFast(); itrack++)
1003 {
1004 AliVTrack* track = (AliVTrack *) reftracks->At(itrack);
1005 Float_t pTtrack = track->Pt();
1006
1007 fhPtInCone ->Fill(ptTrig,pTtrack);
1008 fhPtTrackInCone->Fill(ptTrig,pTtrack);
1009
1010 if(fFillPileUpHistograms)
1011 {
1012 ULong_t status = track->GetStatus();
1013 Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
1014 //Double32_t tof = track->GetTOFsignal()*1e-3;
1015 Int_t trackBC = track->GetTOFBunchCrossing(bz);
1016
1017 if ( okTOF && trackBC!=0 ) fhPtTrackInConeOtherBC->Fill(ptTrig,pTtrack);
1018 else if( okTOF && trackBC==0 ) fhPtTrackInConeBC0 ->Fill(ptTrig,pTtrack);
1019
1020 Int_t vtxBC = GetReader()->GetVertexBC();
1021 if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtTrackInConeVtxBC0->Fill(ptTrig,pTtrack);
1022
1023 if(GetReader()->IsPileUpFromSPD()) { fhPtInConePileUp[0]->Fill(ptTrig,pTtrack);
6ae3345d 1024 if(okTOF && trackBC!=0 ) fhPtTrackInConeOtherBCPileUpSPD->Fill(ptTrig,pTtrack);
1025 if(okTOF && trackBC==0 ) fhPtTrackInConeBC0PileUpSPD ->Fill(ptTrig,pTtrack); }
23130491 1026 if(GetReader()->IsPileUpFromEMCal()) fhPtInConePileUp[1]->Fill(ptTrig,pTtrack);
1027 if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtInConePileUp[2]->Fill(ptTrig,pTtrack);
1028 if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtInConePileUp[3]->Fill(ptTrig,pTtrack);
1029 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtInConePileUp[4]->Fill(ptTrig,pTtrack);
1030 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtInConePileUp[5]->Fill(ptTrig,pTtrack);
1031 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtInConePileUp[6]->Fill(ptTrig,pTtrack);
1032 }
1033
977564f5 1034 if(fFillHighMultHistograms) fhPtInConeCent->Fill(GetEventCentrality(),pTtrack);
1035
23130491 1036 coneptsumTrack+=pTtrack;
1b1a1b2e 1037 if(pTtrack > coneptLeadTrack) coneptLeadTrack = pTtrack;
23130491 1038 }
1b1a1b2e 1039
1040 fhConeSumPtTrack ->Fill(ptTrig, coneptsumTrack );
1041 fhConePtLeadTrack->Fill(ptTrig, coneptLeadTrack);
1042
23130491 1043}
1044
2ad19c3d 1045//_________________________________________________________________
23130491 1046void AliAnaParticleIsolation::FillPileUpHistograms(Int_t clusterID)
2ad19c3d 1047{
1048 // Fill some histograms to understand pile-up
2ad19c3d 1049
6ae3345d 1050 if(clusterID < 0 )
2ad19c3d 1051 {
1052 printf("AliAnaParticleIsolation::FillPileUpHistograms(), ID of cluster = %d, not possible! ", clusterID);
1053 return;
1054 }
1055
1056 Int_t iclus = -1;
1057 TObjArray* clusters = 0x0;
1058 if (fCalorimeter == "EMCAL") clusters = GetEMCALClusters();
1059 else if(fCalorimeter == "PHOS" ) clusters = GetPHOSClusters();
1060
1061 Float_t energy = 0;
1062 Float_t time = -1000;
6ae3345d 1063
2ad19c3d 1064 if(clusters)
1065 {
6ae3345d 1066 AliVCluster *cluster = FindCluster(clusters,clusterID,iclus);
2ad19c3d 1067 energy = cluster->E();
994051fa 1068 time = cluster->GetTOF()*1e9;
6ae3345d 1069 }
2ad19c3d 1070
1071 //printf("E %f, time %f\n",energy,time);
1072 AliVEvent * event = GetReader()->GetInputEvent();
1073
1074 fhTimeENoCut->Fill(energy,time);
1075 if(GetReader()->IsPileUpFromSPD()) fhTimeESPD ->Fill(energy,time);
1076 if(event->IsPileupFromSPDInMultBins()) fhTimeESPDMulti->Fill(energy,time);
1077
de101942 1078 if(energy < 8) return; // Fill time figures for high energy clusters not too close to trigger threshold
2ad19c3d 1079
1080 AliESDEvent* esdEv = dynamic_cast<AliESDEvent*> (event);
1081 AliAODEvent* aodEv = dynamic_cast<AliAODEvent*> (event);
1082
1083 // N pile up vertices
1084 Int_t nVerticesSPD = -1;
1085 Int_t nVerticesTracks = -1;
1086
1087 if (esdEv)
1088 {
1089 nVerticesSPD = esdEv->GetNumberOfPileupVerticesSPD();
1090 nVerticesTracks = esdEv->GetNumberOfPileupVerticesTracks();
1091
1092 }//ESD
1093 else if (aodEv)
1094 {
1095 nVerticesSPD = aodEv->GetNumberOfPileupVerticesSPD();
1096 nVerticesTracks = aodEv->GetNumberOfPileupVerticesTracks();
1097 }//AOD
1098
1099 fhTimeNPileUpVertSPD ->Fill(time,nVerticesSPD);
1100 fhTimeNPileUpVertTrack->Fill(time,nVerticesTracks);
1101
6ae3345d 1102 //printf("Is SPD %d, Is SPD Multi %d, n spd %d, n track %d\n",
2ad19c3d 1103 // GetReader()->IsPileUpFromSPD(),event->IsPileupFromSPDInMultBins(),nVerticesSPD,nVerticesTracks);
1104
1105 Int_t ncont = -1;
5559f30a 1106 Float_t z1 = -1, z2 = -1;
2ad19c3d 1107 Float_t diamZ = -1;
1108 for(Int_t iVert=0; iVert<nVerticesSPD;iVert++)
1109 {
1110 if (esdEv)
1111 {
1112 const AliESDVertex* pv=esdEv->GetPileupVertexSPD(iVert);
1113 ncont=pv->GetNContributors();
1114 z1 = esdEv->GetPrimaryVertexSPD()->GetZ();
1115 z2 = pv->GetZ();
1116 diamZ = esdEv->GetDiamondZ();
1117 }//ESD
1118 else if (aodEv)
1119 {
1120 AliAODVertex *pv=aodEv->GetVertex(iVert);
1121 if(pv->GetType()!=AliAODVertex::kPileupSPD) continue;
1122 ncont=pv->GetNContributors();
1123 z1=aodEv->GetPrimaryVertexSPD()->GetZ();
1124 z2=pv->GetZ();
1125 diamZ = aodEv->GetDiamondZ();
1126 }// AOD
1127
1128 Double_t distZ = TMath::Abs(z2-z1);
1129 diamZ = TMath::Abs(z2-diamZ);
1130
1131 fhTimeNPileUpVertContributors ->Fill(time,ncont);
1132 fhTimePileUpMainVertexZDistance->Fill(time,distZ);
1133 fhTimePileUpMainVertexZDiamond ->Fill(time,diamZ);
1134
1135 }// loop
1136}
1137
23130491 1138//_____________________________________________________________________________________________________________________
124bffb3 1139void AliAnaParticleIsolation::FillTrackMatchingShowerShapeControlHistograms(AliAODPWG4ParticleCorrelation *pCandidate,
dc1966bb 1140 Float_t coneptsum, Float_t coneleadpt,
124bffb3 1141 Int_t mcIndex)
b5dbb99b 1142{
6ae3345d 1143 // Fill Track matching and Shower Shape control histograms
dc1966bb 1144 if(!fFillTMHisto && !fFillSSHisto && !fFillBackgroundBinHistograms) return;
b5dbb99b 1145
23130491 1146 Int_t clusterID = pCandidate->GetCaloLabel(0) ;
1147 Int_t nMaxima = pCandidate->GetFiducialArea(); // bad name, just place holder for the moment
1148 Int_t mcTag = pCandidate->GetTag() ;
1149 Bool_t isolated = pCandidate->IsIsolated();
1150
1151 if(clusterID < 0 )
547c2f01 1152 {
81a5e27b 1153 printf("AliAnaParticleIsolation::FillTrackMatchingShowerShapeControlHistograms(), ID of cluster = %d, not possible! \n", clusterID);
547c2f01 1154 return;
1155 }
1156
b5dbb99b 1157 Int_t iclus = -1;
1158 TObjArray* clusters = 0x0;
1159 if (fCalorimeter == "EMCAL") clusters = GetEMCALClusters();
1160 else if(fCalorimeter == "PHOS" ) clusters = GetPHOSClusters();
1161
32d244b0 1162 Float_t energy = pCandidate->E();
1163 Float_t pt = pCandidate->Pt();
1164
b5dbb99b 1165 if(clusters)
1166 {
6ae3345d 1167 AliVCluster *cluster = FindCluster(clusters,clusterID,iclus);
b5dbb99b 1168
dc1966bb 1169 // Get the max pt leading in cone or the sum of pt in cone
1170 // assign a bin to the candidate, depending on both quantities
1171 // see the shower shape in those bins.
1172 if(fFillBackgroundBinHistograms)
1173 {
1174 // Get the background bin for this cone and trigger
1175 Int_t ptsumBin = -1;
1176 Int_t leadptBin = -1;
1177
1178 if( GetDebug() > 1 )
1179 printf("AliAnaParticleIsolation::FillTrackMatchingShowerShapeControlHistograms() - pT cand: %2.2f, In cone pT: Sum %2.2f, Lead %2.2f, n bins %d\n",
1180 pt,coneptsum,coneleadpt,fNBkgBin);
1181
1182 for(Int_t ibin = 0; ibin < fNBkgBin; ibin++)
1183 {
1184 if( coneptsum >= fBkgBinLimit[ibin] && coneptsum < fBkgBinLimit[ibin+1]) ptsumBin = ibin;
1185 if( coneleadpt >= fBkgBinLimit[ibin] && coneleadpt < fBkgBinLimit[ibin+1]) leadptBin = ibin;
1186 }
1187
1188 // Fill the histograms per bin of pt lead or pt sum
1189 if( GetDebug() > 1 && ptsumBin >=0 ) printf("\t Sum bin %d [%2.2f,%2.2f]\n" , ptsumBin ,fBkgBinLimit[ptsumBin],fBkgBinLimit[ptsumBin+1]);
1190 if( GetDebug() > 1 && leadptBin >=0 ) printf("\t Lead bin %d [%2.2f,%2.2f]\n", leadptBin,fBkgBinLimit[leadptBin],fBkgBinLimit[leadptBin+1]);
1191
1192 if( leadptBin >=0 ) fhPtLeadConeBinLambda0[leadptBin]->Fill(pt,cluster->GetM02());
1193 if( ptsumBin >=0 ) fhSumPtConeBinLambda0 [ ptsumBin]->Fill(pt,cluster->GetM02());
1194
760007e8 1195 if( GetDebug() > 1 && leadptBin == 0 )
1196 printf("No track/clusters in isolation cone: cand pt %2.2f GeV/c, track multiplicity %d, N clusters %d\n",
1197 pt, GetTrackMultiplicity(),GetEMCALClusters()->GetEntriesFast());
1198
dc1966bb 1199 if(IsDataMC())
1200 {
1201 Int_t leadptBinMC = leadptBin+mcIndex*fNBkgBin;
1202 Int_t ptsumBinMC = ptsumBin+mcIndex*fNBkgBin;
1203 if( leadptBin >=0 ) fhPtLeadConeBinLambda0MC[leadptBinMC]->Fill(pt,cluster->GetM02());
1204 if( ptsumBin >=0 ) fhSumPtConeBinLambda0MC [ ptsumBinMC]->Fill(pt,cluster->GetM02());
1205 if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
1206 {
1207 leadptBinMC = leadptBin+kmcPhoton*fNBkgBin;
1208 ptsumBinMC = ptsumBin+kmcPhoton*fNBkgBin;
1209 if( leadptBin >=0 ) fhPtLeadConeBinLambda0MC[leadptBinMC]->Fill(pt,cluster->GetM02());
1210 if( ptsumBin >=0 ) fhSumPtConeBinLambda0MC [ ptsumBinMC]->Fill(pt,cluster->GetM02());
1211 }
1212 }
1213 }
1214
1215
b5dbb99b 1216 if(fFillSSHisto)
1217 {
32d244b0 1218 fhELambda0 [isolated]->Fill(energy, cluster->GetM02() );
6ae3345d 1219 fhPtLambda0[isolated]->Fill(pt, cluster->GetM02() );
32d244b0 1220 fhELambda1 [isolated]->Fill(energy, cluster->GetM20() );
b5dbb99b 1221
764ab1f4 1222 if(IsDataMC())
1223 {
124bffb3 1224 if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
1225 fhPtLambda0MC[kmcPhoton][isolated]->Fill(pt, cluster->GetM02());
6ae3345d 1226
1227 fhPtLambda0MC[mcIndex][isolated]->Fill(pt, cluster->GetM02());
764ab1f4 1228 }
1229
4d1d8f00 1230 if(fCalorimeter == "EMCAL" && GetFirstSMCoveredByTRD() >= 0 &&
1231 GetModuleNumber(cluster) >= GetFirstSMCoveredByTRD() )
b5dbb99b 1232 {
32d244b0 1233 fhELambda0TRD [isolated]->Fill(energy, cluster->GetM02() );
6ae3345d 1234 fhPtLambda0TRD[isolated]->Fill(pt , cluster->GetM02() );
32d244b0 1235 fhELambda1TRD [isolated]->Fill(energy, cluster->GetM20() );
b5dbb99b 1236 }
5c46c992 1237
977564f5 1238 if(fFillNLMHistograms)
1239 {
1240 fhNLocMax[isolated]->Fill(energy,nMaxima);
1241 if (nMaxima==1) { fhELambda0LocMax1[isolated]->Fill(energy,cluster->GetM02()); fhELambda1LocMax1[isolated]->Fill(energy,cluster->GetM20()); }
1242 else if(nMaxima==2) { fhELambda0LocMax2[isolated]->Fill(energy,cluster->GetM02()); fhELambda1LocMax2[isolated]->Fill(energy,cluster->GetM20()); }
1243 else { fhELambda0LocMaxN[isolated]->Fill(energy,cluster->GetM02()); fhELambda1LocMaxN[isolated]->Fill(energy,cluster->GetM20()); }
1244 }
1245 } // SS histo fill
b5dbb99b 1246
b5dbb99b 1247 if(fFillTMHisto)
1248 {
1249 Float_t dZ = cluster->GetTrackDz();
1250 Float_t dR = cluster->GetTrackDx();
1251
1252 if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
1253 {
1254 dR = 2000., dZ = 2000.;
1255 GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
1256 }
1257
1258 //printf("ParticleIsolation: dPhi %f, dEta %f\n",dR,dZ);
ec58c056 1259 if(fhTrackMatchedDEta[isolated] && TMath::Abs(dR) < 999)
b5dbb99b 1260 {
ca134929 1261 fhTrackMatchedDEta[isolated]->Fill(energy,dZ);
1262 fhTrackMatchedDPhi[isolated]->Fill(energy,dR);
1263 if(energy > 0.5) fhTrackMatchedDEtaDPhi[isolated]->Fill(dZ,dR);
b5dbb99b 1264 }
1265
1266 // Check dEdx and E/p of matched clusters
1267
1268 if(TMath::Abs(dZ) < 0.05 && TMath::Abs(dR) < 0.05)
1269 {
db6fb352 1270
4bfeae64 1271 AliVTrack *track = GetCaloUtils()->GetMatchedTrack(cluster, GetReader()->GetInputEvent());
b5dbb99b 1272
6ae3345d 1273 if(track)
b5dbb99b 1274 {
1275 Float_t dEdx = track->GetTPCsignal();
ca134929 1276 fhdEdx[isolated]->Fill(cluster->E(), dEdx);
b5dbb99b 1277
1278 Float_t eOverp = cluster->E()/track->P();
ca134929 1279 fhEOverP[isolated]->Fill(cluster->E(), eOverp);
b5dbb99b 1280 }
6ae3345d 1281 //else
4bfeae64 1282 // printf("AliAnaParticleIsolation::FillTrackMatchingShowerShapeHistograms() - Residual OK but (dR, dZ)= (%2.4f,%2.4f) no track associated WHAT? \n", dR,dZ);
b5dbb99b 1283
db6fb352 1284
1285 if(IsDataMC())
1286 {
b5dbb99b 1287 if ( !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) )
1288 {
1289 if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ||
dc1966bb 1290 GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 2.5 );
ca134929 1291 else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 0.5 );
1292 else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 1.5 );
1293 else fhTrackMatchedMCParticle[isolated]->Fill(energy, 3.5 );
b5dbb99b 1294
1295 }
1296 else
1297 {
1298 if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) ||
dc1966bb 1299 GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 6.5 );
ca134929 1300 else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 4.5 );
1301 else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron) ) fhTrackMatchedMCParticle[isolated]->Fill(energy, 5.5 );
1302 else fhTrackMatchedMCParticle[isolated]->Fill(energy, 7.5 );
6ae3345d 1303 }
b5dbb99b 1304
6ae3345d 1305 } // MC
b5dbb99b 1306
6ae3345d 1307 } // match window
b5dbb99b 1308
1309 }// TM histos fill
1310
1311 } // clusters array available
1312
1313}
1314
803d06a8 1315//______________________________________________________
1a31a9ab 1316TObjString * AliAnaParticleIsolation::GetAnalysisCuts()
6ae3345d 1317{
b0a31c92 1318 //Save parameters used for analysis
1a31a9ab 1319 TString parList ; //this will be list of parameters used for this analysis.
1320 const Int_t buffersize = 255;
1321 char onePar[buffersize] ;
1322
1323 snprintf(onePar, buffersize,"--- AliAnaParticleIsolation ---\n") ;
6ae3345d 1324 parList+=onePar ;
1a31a9ab 1325 snprintf(onePar, buffersize,"Calorimeter: %s\n",fCalorimeter.Data()) ;
1326 parList+=onePar ;
4b6cb0f2 1327 snprintf(onePar, buffersize,"Isolation Cand Detector: %s\n",fIsoDetector.Data()) ;
1328 parList+=onePar ;
1a31a9ab 1329 snprintf(onePar, buffersize,"fReMakeIC =%d (Flag for reisolation during histogram filling) \n",fReMakeIC) ;
1330 parList+=onePar ;
1331 snprintf(onePar, buffersize,"fMakeSeveralIC=%d (Flag for isolation with several cuts at the same time ) \n",fMakeSeveralIC) ;
6ae3345d 1332 parList+=onePar ;
09273901 1333 snprintf(onePar, buffersize,"fFillTMHisto=%d (Flag for track matching histograms) \n",fFillTMHisto) ;
1a31a9ab 1334 parList+=onePar ;
09273901 1335 snprintf(onePar, buffersize,"fFillSSHisto=%d (Flag for shower shape histograms) \n",fFillSSHisto) ;
1336 parList+=onePar ;
db6fb352 1337
b5dbb99b 1338 if(fMakeSeveralIC)
1339 {
1a31a9ab 1340 snprintf(onePar, buffersize,"fNCones =%d (Number of cone sizes) \n",fNCones) ;
1341 parList+=onePar ;
1342 snprintf(onePar, buffersize,"fNPtThresFrac=%d (Flag for isolation with several cuts at the same time ) \n",fNPtThresFrac) ;
1343 parList+=onePar ;
1344
b5dbb99b 1345 for(Int_t icone = 0; icone < fNCones ; icone++)
1346 {
1a31a9ab 1347 snprintf(onePar, buffersize,"fConeSizes[%d]=%1.2f (isolation cone size) \n",icone, fConeSizes[icone]) ;
6ae3345d 1348 parList+=onePar ;
1a31a9ab 1349 }
b5dbb99b 1350 for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
1351 {
1a31a9ab 1352 snprintf(onePar, buffersize,"fPtThresholds[%d]=%1.2f (isolation pt threshold) \n",ipt, fPtThresholds[ipt]) ;
6ae3345d 1353 parList+=onePar ;
1a31a9ab 1354 }
b5dbb99b 1355 for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
1356 {
1a31a9ab 1357 snprintf(onePar, buffersize,"fPtFractions[%d]=%1.2f (isolation pt fraction threshold) \n",ipt, fPtFractions[ipt]) ;
6ae3345d 1358 parList+=onePar ;
db6fb352 1359 }
1360 for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
1361 {
1362 snprintf(onePar, buffersize,"fSumPtThresholds[%d]=%1.2f (isolation sum pt threshold) \n",ipt, fSumPtThresholds[ipt]) ;
6ae3345d 1363 parList+=onePar ;
1364 }
1a31a9ab 1365 }
1366
1367 //Get parameters set in base class.
1368 parList += GetBaseParametersList() ;
1369
1370 //Get parameters set in IC class.
1371 if(!fMakeSeveralIC)parList += GetIsolationCut()->GetICParametersList() ;
1372
1373 return new TObjString(parList) ;
b0a31c92 1374
1a31a9ab 1375}
1376
803d06a8 1377//________________________________________________________
1a31a9ab 1378TList * AliAnaParticleIsolation::GetCreateOutputObjects()
6ae3345d 1379{
1380 // Create histograms to be saved in output file and
1a31a9ab 1381 // store them in outputContainer
6ae3345d 1382 TList * outputContainer = new TList() ;
1383 outputContainer->SetName("IsolatedParticleHistos") ;
1a31a9ab 1384
745913ae 1385 Int_t nptbins = GetHistogramRanges()->GetHistoPtBins();
1386 Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins();
1387 Int_t netabins = GetHistogramRanges()->GetHistoEtaBins();
1388 Float_t ptmax = GetHistogramRanges()->GetHistoPtMax();
1389 Float_t phimax = GetHistogramRanges()->GetHistoPhiMax();
1390 Float_t etamax = GetHistogramRanges()->GetHistoEtaMax();
1391 Float_t ptmin = GetHistogramRanges()->GetHistoPtMin();
1392 Float_t phimin = GetHistogramRanges()->GetHistoPhiMin();
6ae3345d 1393 Float_t etamin = GetHistogramRanges()->GetHistoEtaMin();
1394 Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins();
1395 Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax();
09273901 1396 Float_t ssmin = GetHistogramRanges()->GetHistoShowerShapeMin();
6ae3345d 1397 Int_t ntimebins= GetHistogramRanges()->GetHistoTimeBins();
1398 Float_t timemax = GetHistogramRanges()->GetHistoTimeMax();
1399 Float_t timemin = GetHistogramRanges()->GetHistoTimeMin();
1400
1401 Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
1402 Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
09273901 1403 Float_t resetamin = GetHistogramRanges()->GetHistoTrackResidualEtaMin();
6ae3345d 1404 Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
1405 Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
1406 Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
803d06a8 1407
6ae3345d 1408 Int_t ndedxbins = GetHistogramRanges()->GetHistodEdxBins();
1409 Float_t dedxmax = GetHistogramRanges()->GetHistodEdxMax();
31ae6d59 1410 Float_t dedxmin = GetHistogramRanges()->GetHistodEdxMin();
6ae3345d 1411 Int_t nPoverEbins = GetHistogramRanges()->GetHistoPOverEBins();
1412 Float_t pOverEmax = GetHistogramRanges()->GetHistoPOverEMax();
31ae6d59 1413 Float_t pOverEmin = GetHistogramRanges()->GetHistoPOverEMin();
1414
98287a43 1415 Int_t nptsumbins = GetHistogramRanges()->GetHistoNPtSumBins();
1416 Float_t ptsummax = GetHistogramRanges()->GetHistoPtSumMax();
1417 Float_t ptsummin = GetHistogramRanges()->GetHistoPtSumMin();
1418 Int_t nptinconebins = GetHistogramRanges()->GetHistoNPtInConeBins();
1419 Float_t ptinconemax = GetHistogramRanges()->GetHistoPtInConeMax();
1420 Float_t ptinconemin = GetHistogramRanges()->GetHistoPtInConeMin();
1a31a9ab 1421
7726e3a3 1422 //Float_t ptthre = GetIsolationCut()->GetPtThreshold();
1423 //Float_t ptsumthre = GetIsolationCut()->GetSumPtThreshold();
1424 //Float_t ptfrac = GetIsolationCut()->GetPtFraction();
1425 Float_t r = GetIsolationCut()->GetConeSize();
1426 Int_t method = GetIsolationCut()->GetICMethod() ;
1427 Int_t particle = GetIsolationCut()->GetParticleTypeInCone() ;
1428
1429 TString sThreshold = "";
124bffb3 1430 if ( method == AliIsolationCut::kSumPtIC )
1431 {
1432 sThreshold = Form(", %2.2f < #Sigma #it{p}_{T}^{in cone} < %2.2f GeV/#it{c}",
1433 GetIsolationCut()->GetSumPtThreshold(), GetIsolationCut()->GetSumPtThresholdMax());
1434 if(GetIsolationCut()->GetSumPtThresholdMax() > 200)
1435 sThreshold = Form(", #Sigma #it{p}_{T}^{in cone} = %2.2f GeV/#it{c}",
1436 GetIsolationCut()->GetSumPtThreshold());
1437 }
1438 else if ( method == AliIsolationCut::kPtThresIC)
1439 {
1440 sThreshold = Form(", %2.2f < #it{p}_{T}^{th} < %2.2f GeV/#it{c}",
1441 GetIsolationCut()->GetPtThreshold(),GetIsolationCut()->GetPtThresholdMax());
1442 if(GetIsolationCut()->GetSumPtThreshold() > 200)
1443 sThreshold = Form(", #it{p}_{T}^{th} = %2.2f GeV/#it{c}",
1444 GetIsolationCut()->GetPtThreshold());
1445 }
1446 else if ( method == AliIsolationCut::kPtFracIC)
1447 sThreshold = Form(", #Sigma #it{p}_{T}^{in cone}/#it{p}_{T}^{trig} = %2.2f" ,
1448 GetIsolationCut()->GetPtFraction());
6ae3345d 1449
7726e3a3 1450 TString sParticle = ", x^{0,#pm}";
1451 if ( particle == AliIsolationCut::kOnlyNeutral ) sParticle = ", x^{0}";
1452 else if ( particle == AliIsolationCut::kOnlyCharged ) sParticle = ", x^{#pm}";
1453
1454 TString parTitle = Form("#it{R} = %2.2f%s%s",GetIsolationCut()->GetConeSize(), sThreshold.Data(),sParticle.Data());
db6fb352 1455
17af6e24 1456 TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
1457
124bffb3 1458 // MC histograms title and name
1459 TString mcPartType[] = { "#gamma", "#gamma_{prompt}", "#gamma_{fragmentation}",
6ae3345d 1460 "#pi^{0} (merged #gamma)","#gamma_{#pi decay}",
1461 "#gamma_{#eta decay}","#gamma_{other decay}",
1462 "e^{#pm}","hadrons?"} ;
124bffb3 1463
1464 TString mcPartName[] = { "Photon","PhotonPrompt","PhotonFrag",
6ae3345d 1465 "Pi0","Pi0Decay","EtaDecay","OtherDecay",
1466 "Electron","Hadron"} ;
124bffb3 1467
1468 // Primary MC histograms title and name
bf8a7dac 1469 TString pptype[] = { "#gamma", "#gamma_{#pi decay}","#gamma_{other decay}",
6ae3345d 1470 "#gamma_{prompt}","#gamma_{fragmentation}","#gamma_{ISR}"} ;
124bffb3 1471
bf8a7dac 1472 TString ppname[] = { "Photon","PhotonPi0Decay","PhotonOtherDecay",
6ae3345d 1473 "PhotonPrompt","PhotonFrag","PhotonISR"} ;
1474
be703b18 1475 // Not Isolated histograms, reference histograms
1476
1477 fhENoIso = new TH1F("hENoIso",
1478 Form("Number of not isolated leading particles vs #it{p}_{T}, %s",parTitle.Data()),
1479 nptbins,ptmin,ptmax);
1480 fhENoIso->SetYTitle("#it{counts}");
1481 fhENoIso->SetXTitle("E (GeV/#it{c})");
1482 outputContainer->Add(fhENoIso) ;
1483
1484 fhPtNoIso = new TH1F("hPtNoIso",
1485 Form("Number of not isolated leading particles vs #it{p}_{T}, %s",parTitle.Data()),
1486 nptbins,ptmin,ptmax);
1487 fhPtNoIso->SetYTitle("#it{counts}");
1488 fhPtNoIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1489 outputContainer->Add(fhPtNoIso) ;
1490
1491 fhEtaPhiNoIso = new TH2F("hEtaPhiNoIso",
1492 Form("Number of not isolated leading particles #eta vs #phi, %s",parTitle.Data()),
1493 netabins,etamin,etamax,nphibins,phimin,phimax);
1494 fhEtaPhiNoIso->SetXTitle("#eta");
1495 fhEtaPhiNoIso->SetYTitle("#phi");
1496 outputContainer->Add(fhEtaPhiNoIso) ;
6ae3345d 1497
be703b18 1498 if(IsDataMC())
1499 {
1500 // For histograms in arrays, index in the array, corresponding to any particle origin
1501
1502 for(Int_t imc = 0; imc < 9; imc++)
1503 {
1504
1505 fhPtNoIsoMC[imc] = new TH1F(Form("hPtNoIsoMC%s",mcPartName[imc].Data()),
1506 Form("#it{p}_{T} of NOT isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
1507 nptbins,ptmin,ptmax);
1508 fhPtNoIsoMC[imc]->SetYTitle("#it{counts}");
1509 fhPtNoIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1510 outputContainer->Add(fhPtNoIsoMC[imc]) ;
1511
1512 fhPtIsoMC[imc] = new TH1F(Form("hPtMC%s",mcPartName[imc].Data()),
1513 Form("#it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
1514 nptbins,ptmin,ptmax);
1515 fhPtIsoMC[imc]->SetYTitle("#it{counts}");
1516 fhPtIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1517 outputContainer->Add(fhPtIsoMC[imc]) ;
1518
1519 fhPhiIsoMC[imc] = new TH2F(Form("hPhiMC%s",mcPartName[imc].Data()),
1520 Form("#phi vs #it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
1521 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1522 fhPhiIsoMC[imc]->SetYTitle("#phi");
1523 fhPhiIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1524 outputContainer->Add(fhPhiIsoMC[imc]) ;
1525
1526 fhEtaIsoMC[imc] = new TH2F(Form("hEtaMC%s",mcPartName[imc].Data()),
1527 Form("#phi vs #it{p}_{T} of isolated %s, %s",mcPartType[imc].Data(),parTitle.Data()),
1528 nptbins,ptmin,ptmax,netabins,etamin,etamax);
1529 fhEtaIsoMC[imc]->SetYTitle("#eta");
1530 fhEtaIsoMC[imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1531 outputContainer->Add(fhEtaIsoMC[imc]) ;
1532 }
1533 }
1534
1535 // Histograms for tagged candidates as decay
1536 if(fFillTaggedDecayHistograms)
1537 {
8913c8c4 1538 for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
aa2e58e4 1539 {
8913c8c4 1540 fhPtDecayNoIso[ibit] =
1541 new TH1F(Form("hPtDecayNoIso_bit%d",fDecayBits[ibit]),
1542 Form("Number of not isolated leading pi0 decay particles vs #it{p}_{T}, bit %d, %s",fDecayBits[ibit],parTitle.Data()),
1543 nptbins,ptmin,ptmax);
1544 fhPtDecayNoIso[ibit]->SetYTitle("#it{counts}");
1545 fhPtDecayNoIso[ibit]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1546 outputContainer->Add(fhPtDecayNoIso[ibit]) ;
1547
1548 fhEtaPhiDecayNoIso[ibit] =
1549 new TH2F(Form("hEtaPhiDecayNoIso_bit%d",fDecayBits[ibit]),
1550 Form("Number of not isolated leading Pi0 decay particles #eta vs #phi, bit %d, %s",fDecayBits[ibit],parTitle.Data()),
1551 netabins,etamin,etamax,nphibins,phimin,phimax);
1552 fhEtaPhiDecayNoIso[ibit]->SetXTitle("#eta");
1553 fhEtaPhiDecayNoIso[ibit]->SetYTitle("#phi");
1554 outputContainer->Add(fhEtaPhiDecayNoIso[ibit]) ;
1555
1556 if(!fMakeSeveralIC)
aa2e58e4 1557 {
8913c8c4 1558 fhPtDecayIso[ibit] =
1559 new TH1F(Form("hPtDecayIso_bit%d",fDecayBits[ibit]),
1560 Form("Number of isolated #pi^{0} decay particles vs #it{p}_{T}, bit %d, %s",fDecayBits[ibit],parTitle.Data()),
1561 nptbins,ptmin,ptmax);
1562 fhPtDecayIso[ibit]->SetYTitle("#it{counts}");
1563 fhPtDecayIso[ibit]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1564 outputContainer->Add(fhPtDecayIso[ibit]) ;
1565
1566 fhEtaPhiDecayIso[ibit] =
1567 new TH2F(Form("hEtaPhiDecayIso_bit%d",fDecayBits[ibit]),
1568 Form("Number of isolated Pi0 decay particles #eta vs #phi, bit %d, %s",fDecayBits[ibit],parTitle.Data()),
1569 netabins,etamin,etamax,nphibins,phimin,phimax);
1570 fhEtaPhiDecayIso[ibit]->SetXTitle("#eta");
1571 fhEtaPhiDecayIso[ibit]->SetYTitle("#phi");
1572 outputContainer->Add(fhEtaPhiDecayIso[ibit]) ;
1573 }
1574
1575 if(IsDataMC())
1576 {
1577 for(Int_t imc = 0; imc < 9; imc++)
aa2e58e4 1578 {
8913c8c4 1579
1580 fhPtDecayNoIsoMC[ibit][imc] =
1581 new TH1F(Form("hPtDecayNoIso_bit%d_MC%s",fDecayBits[ibit],mcPartName[imc].Data()),
1582 Form("#it{p}_{T} of NOT isolated, decay bit %d, %s, %s",fDecayBits[ibit],mcPartType[imc].Data(),parTitle.Data()),
1583 nptbins,ptmin,ptmax);
1584 fhPtDecayNoIsoMC[ibit][imc]->SetYTitle("#it{counts}");
1585 fhPtDecayNoIsoMC[ibit][imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1586 outputContainer->Add(fhPtDecayNoIsoMC[ibit][imc]) ;
1587
1588 if(!fMakeSeveralIC)
1589 {
1590 fhPtDecayIsoMC[ibit][imc] =
1591 new TH1F(Form("hPtDecay_bit%d_MC%s",fDecayBits[ibit],mcPartName[imc].Data()),
1592 Form("#it{p}_{T} of isolated %s, decay bit %d, %s",mcPartType[imc].Data(),fDecayBits[ibit],parTitle.Data()),
1593 nptbins,ptmin,ptmax);
1594 fhPtDecayIsoMC[ibit][imc]->SetYTitle("#it{counts}");
1595 fhPtDecayIsoMC[ibit][imc]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1596 outputContainer->Add(fhPtDecayIsoMC[ibit][imc]) ;
1597 }
1598 }// MC particle loop
1599 }// MC
1600 } // bit loop
aa2e58e4 1601 }// decay
be703b18 1602
b5dbb99b 1603 if(!fMakeSeveralIC)
1604 {
7726e3a3 1605 TString isoName [] = {"NoIso",""};
1606 TString isoTitle[] = {"Not isolated" ,"isolated"};
c8710850 1607
72433939 1608 fhEIso = new TH1F("hE",
7726e3a3 1609 Form("Number of isolated particles vs E, %s",parTitle.Data()),
72433939 1610 nptbins,ptmin,ptmax);
977564f5 1611 fhEIso->SetYTitle("d#it{N} / d#it{E}");
9a97f32f 1612 fhEIso->SetXTitle("#it{E} (GeV/#it{c})");
72433939 1613 outputContainer->Add(fhEIso) ;
1614
1615 fhPtIso = new TH1F("hPt",
7726e3a3 1616 Form("Number of isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
72433939 1617 nptbins,ptmin,ptmax);
9a97f32f 1618 fhPtIso->SetYTitle("d#it{N} / #it{p}_{T}");
dc9c6e78 1619 fhPtIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
72433939 1620 outputContainer->Add(fhPtIso) ;
1621
124bffb3 1622 fhPhiIso = new TH2F("hPhi",
1623 Form("Number of isolated particles vs #phi, %s",parTitle.Data()),
1624 nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1625 fhPhiIso->SetYTitle("#phi");
1626 fhPhiIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1627 outputContainer->Add(fhPhiIso) ;
1628
1629 fhEtaIso = new TH2F("hEta",
1630 Form("Number of isolated particles vs #eta, %s",parTitle.Data()),
1631 nptbins,ptmin,ptmax,netabins,etamin,etamax);
1632 fhEtaIso->SetYTitle("#eta");
1633 fhEtaIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1634 outputContainer->Add(fhEtaIso) ;
1635
1636 fhEtaPhiIso = new TH2F("hEtaPhiIso",
1637 Form("Number of isolated particles #eta vs #phi, %s",parTitle.Data()),
1638 netabins,etamin,etamax,nphibins,phimin,phimax);
1639 fhEtaPhiIso->SetXTitle("#eta");
1640 fhEtaPhiIso->SetYTitle("#phi");
1641 outputContainer->Add(fhEtaPhiIso) ;
1642
977564f5 1643 if(fFillHighMultHistograms)
1644 {
1645 fhPtCentralityIso = new TH2F("hPtCentrality",
1646 Form("centrality vs #it{p}_{T} for isolated particles, %s",parTitle.Data()),
1647 nptbins,ptmin,ptmax, 100,0,100);
1648 fhPtCentralityIso->SetYTitle("centrality");
1649 fhPtCentralityIso->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1650 outputContainer->Add(fhPtCentralityIso) ;
1651
1652 fhPtEventPlaneIso = new TH2F("hPtEventPlane",
1653 Form("event plane angle vs #it{p}_{T} for isolated particles, %s",parTitle.Data()),
1654 nptbins,ptmin,ptmax, 100,0,TMath::Pi());
1655 fhPtEventPlaneIso->SetYTitle("Event plane angle (rad)");
1656 fhPtEventPlaneIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1657 outputContainer->Add(fhPtEventPlaneIso) ;
1658 }
72433939 1659
977564f5 1660 if(fFillNLMHistograms)
1661 {
1662 fhPtNLocMaxIso = new TH2F("hPtNLocMax",
1663 Form("Number of isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
1664 nptbins,ptmin,ptmax,10,0,10);
1665 fhPtNLocMaxIso->SetYTitle("#it{NLM}");
1666 fhPtNLocMaxIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
6ae3345d 1667
124bffb3 1668 fhPtNLocMaxNoIso = new TH2F("hPtNLocMaxNoIso",
1669 Form("Number of not isolated particles vs #it{p}_{T}, %s",parTitle.Data()),
1670 nptbins,ptmin,ptmax,10,0,10);
1671 fhPtNLocMaxNoIso->SetYTitle("#it{NLM}");
1672 fhPtNLocMaxNoIso->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1673 outputContainer->Add(fhPtNLocMaxNoIso) ;
977564f5 1674 }
1b1a1b2e 1675
1676 fhConePtLead = new TH2F("hConePtLead",
1677 Form("Track or Cluster leading #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
1678 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
1679 fhConePtLead->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
1680 fhConePtLead->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1681 outputContainer->Add(fhConePtLead) ;
1682
72433939 1683
72433939 1684 fhConeSumPt = new TH2F("hConePtSum",
9a97f32f 1685 Form("Track and Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
72433939 1686 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
dc9c6e78 1687 fhConeSumPt->SetYTitle("#Sigma #it{p}_{T}");
9a97f32f 1688 fhConeSumPt->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
72433939 1689 outputContainer->Add(fhConeSumPt) ;
1690
1691 fhConeSumPtTrigEtaPhi = new TH2F("hConePtSumTrigEtaPhi",
6ae3345d 1692 Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
1693 netabins,etamin,etamax,nphibins,phimin,phimax);
dc9c6e78 1694 fhConeSumPtTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
72433939 1695 fhConeSumPtTrigEtaPhi->SetXTitle("#eta_{trigger}");
1696 fhConeSumPtTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1697 outputContainer->Add(fhConeSumPtTrigEtaPhi) ;
1698
1699 fhPtInCone = new TH2F("hPtInCone",
9a97f32f 1700 Form("#it{p}_{T} of clusters and tracks in isolation cone for #it{R} = %2.2f",r),
72433939 1701 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 1702 fhPtInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 1703 fhPtInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
72433939 1704 outputContainer->Add(fhPtInCone) ;
1705
dc1966bb 1706 if(fFillBackgroundBinHistograms)
1707 {
1708 fhPtLeadConeBinLambda0 = new TH2F*[fNBkgBin];
1709 fhSumPtConeBinLambda0 = new TH2F*[fNBkgBin];
1710
1711 if(IsDataMC())
1712 {
1713 fhPtLeadConeBinLambda0MC = new TH2F*[fNBkgBin*9];
1714 fhSumPtConeBinLambda0MC = new TH2F*[fNBkgBin*9];
1715 }
1716
1717 for(Int_t ibin = 0; ibin < fNBkgBin; ibin++)
1718 {
1719 fhPtLeadConeBinLambda0[ibin] = new TH2F
1720 (Form("hPtLeadConeLambda0_Bin%d",ibin),
1721 Form("#lambda_{0}, in cone %2.2f<#it{p}_{T}^{leading}<%2.2f (GeV/#it{c}), %s",
1722 fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1723 fhPtLeadConeBinLambda0[ibin]->SetYTitle("#lambda_{0}^{2}");
1724 fhPtLeadConeBinLambda0[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1725 outputContainer->Add(fhPtLeadConeBinLambda0[ibin]) ;
1726
1727 fhSumPtConeBinLambda0[ibin] = new TH2F
1728 (Form("hSumPtConeLambda0_Bin%d",ibin),
1729 Form("#lambda_{0}, in cone %2.2f <#Sigma #it{p}_{T}< %2.2f (GeV/#it{c}), %s",
1730 fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1731 fhSumPtConeBinLambda0[ibin]->SetYTitle("#lambda_{0}^{2}");
1732 fhSumPtConeBinLambda0[ibin]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1733 outputContainer->Add(fhSumPtConeBinLambda0[ibin]) ;
1734
1735 if(IsDataMC())
1736 {
1737 for(Int_t imc = 0; imc < 9; imc++)
1738 {
1739 Int_t binmc = ibin+imc*fNBkgBin;
1740 fhPtLeadConeBinLambda0MC[binmc] = new TH2F
1741 (Form("hPtLeadConeLambda0_Bin%d_MC%s",ibin, mcPartName[imc].Data()),
1742 Form("#lambda_{0}, in cone %2.2f<#it{p}_{T}^{leading}<%2.2f (GeV/#it{c}), MC %s, %s",
1743 fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1744 fhPtLeadConeBinLambda0MC[binmc]->SetYTitle("#lambda_{0}^{2}");
1745 fhPtLeadConeBinLambda0MC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1746 outputContainer->Add(fhPtLeadConeBinLambda0MC[binmc]) ;
1747
1748 fhSumPtConeBinLambda0MC[binmc] = new TH2F
1749 (Form("hSumPtConeLambda0_Bin%d_MC%s",ibin,mcPartName[imc].Data()),
1750 Form("#lambda_{0}, in cone %2.2f <#Sigma #it{p}_{T}< %2.2f (GeV/#it{c}), MC %s, %s",
1751 fBkgBinLimit[ibin],fBkgBinLimit[ibin+1], mcPartType[imc].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1752 fhSumPtConeBinLambda0MC[binmc]->SetYTitle("#lambda_{0}^{2}");
1753 fhSumPtConeBinLambda0MC[binmc]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1754 outputContainer->Add(fhSumPtConeBinLambda0MC[binmc]) ;
1755 } // MC particle loop
1756 }
1757
1758 }// pt bin loop
1759 } // bkg cone pt bin histograms
1760
977564f5 1761 if(fFillHighMultHistograms)
1762 {
1763 fhPtInConeCent = new TH2F("hPtInConeCent",
1764 Form("#it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
1765 100,0,100,nptinconebins,ptinconemin,ptinconemax);
1766 fhPtInConeCent->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
1767 fhPtInConeCent->SetXTitle("centrality");
1768 outputContainer->Add(fhPtInConeCent) ;
1769 }
72433939 1770
1771 // Cluster only histograms
1772 if(GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyCharged)
1773 {
1774 fhConeSumPtCluster = new TH2F("hConePtSumCluster",
9a97f32f 1775 Form("Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
72433939 1776 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
dc9c6e78 1777 fhConeSumPtCluster->SetYTitle("#Sigma #it{p}_{T}");
9a97f32f 1778 fhConeSumPtCluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
72433939 1779 outputContainer->Add(fhConeSumPtCluster) ;
1780
1b1a1b2e 1781 fhConePtLeadCluster = new TH2F("hConeLeadPtCluster",
1782 Form("Cluster leading in isolation cone for #it{R} = %2.2f",r),
1783 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
1784 fhConePtLeadCluster->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
1785 fhConePtLeadCluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1786 outputContainer->Add(fhConePtLeadCluster) ;
1787
1788
977564f5 1789 if(fFillCellHistograms)
1790 {
1791 fhConeSumPtCell = new TH2F("hConePtSumCell",
1792 Form("Cell #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
1793 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
1794 fhConeSumPtCell->SetYTitle("#Sigma #it{p}_{T}");
1795 fhConeSumPtCell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1796 outputContainer->Add(fhConeSumPtCell) ;
1797 }
72433939 1798
977564f5 1799 if(fFillUEBandSubtractHistograms)
1800 {
1801 fhConeSumPtEtaBandUECluster = new TH2F("hConePtSumEtaBandUECluster",
1802 "#Sigma cluster #it{p}_{T} in UE Eta Band",
1803 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
1804 fhConeSumPtEtaBandUECluster->SetYTitle("#Sigma #it{p}_{T}");
1805 fhConeSumPtEtaBandUECluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1806 outputContainer->Add(fhConeSumPtEtaBandUECluster) ;
1807
1808 fhConeSumPtPhiBandUECluster = new TH2F("hConePtSumPhiBandUECluster",
1809 "#Sigma cluster #it{p}_{T} UE Phi Band",
1810 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
1811 fhConeSumPtPhiBandUECluster->SetYTitle("#Sigma #it{p}_{T}");
1812 fhConeSumPtPhiBandUECluster->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1813 outputContainer->Add(fhConeSumPtPhiBandUECluster) ;
1814
1815 fhConeSumPtEtaBandUEClusterTrigEtaPhi = new TH2F("hConePtSumEtaBandUEClusterTrigEtaPhi",
1816 "Trigger #eta vs #phi, #Sigma cluster #it{p}_{T} in UE Eta Band",
1817 netabins,etamin,etamax,nphibins,phimin,phimax);
1818 fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1819 fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
1820 fhConeSumPtEtaBandUEClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1821 outputContainer->Add(fhConeSumPtEtaBandUEClusterTrigEtaPhi) ;
1822
1823 fhConeSumPtPhiBandUEClusterTrigEtaPhi = new TH2F("hConePtSumPhiBandUEClusterTrigEtaPhi",
1824 "Trigger #eta vs #phi, #Sigma cluster #it{p}_{T} UE Phi Band",
1825 netabins,etamin,etamax,nphibins,phimin,phimax);
1826 fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1827 fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
1828 fhConeSumPtPhiBandUEClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1829 outputContainer->Add(fhConeSumPtPhiBandUEClusterTrigEtaPhi) ;
1830 if(fFillCellHistograms)
1831 {
1832
1833 fhConeSumPtEtaBandUECell = new TH2F("hConePtSumEtaBandUECell",
1834 "#Sigma cell #it{p}_{T} in UE Eta Band",
1835 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
1836 fhConeSumPtEtaBandUECell->SetYTitle("#Sigma #it{p}_{T}");
1837 fhConeSumPtEtaBandUECell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1838 outputContainer->Add(fhConeSumPtEtaBandUECell) ;
1839
1840 fhConeSumPtPhiBandUECell = new TH2F("hConePtSumPhiBandUECell",
1841 "#Sigma cell #it{p}_{T} UE Phi Band",
1842 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
1843 fhConeSumPtPhiBandUECell->SetYTitle("#Sigma #it{p}_{T}");
1844 fhConeSumPtPhiBandUECell->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
1845 outputContainer->Add(fhConeSumPtPhiBandUECell) ;
1846
1847 fhConeSumPtEtaBandUECellTrigEtaPhi = new TH2F("hConePtSumEtaBandUECellTrigEtaPhi",
1848 "Trigger #eta vs #phi, #Sigma cell #it{p}_{T} in UE Eta Band",
1849 netabins,etamin,etamax,nphibins,phimin,phimax);
1850 fhConeSumPtEtaBandUECellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1851 fhConeSumPtEtaBandUECellTrigEtaPhi->SetXTitle("#eta_{trigger}");
1852 fhConeSumPtEtaBandUECellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1853 outputContainer->Add(fhConeSumPtEtaBandUECellTrigEtaPhi) ;
1854
1855 fhConeSumPtPhiBandUECellTrigEtaPhi = new TH2F("hConePtSumPhiBandUECellTrigEtaPhi",
1856 "Trigger #eta vs #phi, #Sigma cell #it{p}_{T} UE Phi Band",
1857 netabins,etamin,etamax,nphibins,phimin,phimax);
1858 fhConeSumPtPhiBandUECellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1859 fhConeSumPtPhiBandUECellTrigEtaPhi->SetXTitle("#eta_{trigger}");
1860 fhConeSumPtPhiBandUECellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1861 outputContainer->Add(fhConeSumPtPhiBandUECellTrigEtaPhi) ;
1862 }
124bffb3 1863
977564f5 1864 fhEtaBandCluster = new TH2F("hEtaBandCluster",
1865 Form("#eta vs #phi of clusters in #eta band isolation cone for #it{R} = %2.2f",r),
1866 netabins,-1,1,nphibins,0,TMath::TwoPi());
1867 fhEtaBandCluster->SetXTitle("#eta");
1868 fhEtaBandCluster->SetYTitle("#phi");
1869 outputContainer->Add(fhEtaBandCluster) ;
1870
1871 fhPhiBandCluster = new TH2F("hPhiBandCluster",
1872 Form("#eta vs #phi of clusters in #phi band isolation cone for #it{R} = %2.2f",r),
1873 netabins,-1,1,nphibins,0,TMath::TwoPi());
1874 fhPhiBandCluster->SetXTitle("#eta");
1875 fhPhiBandCluster->SetYTitle("#phi");
1876 outputContainer->Add(fhPhiBandCluster) ;
1877
1878 fhEtaPhiInConeCluster= new TH2F("hEtaPhiInConeCluster",
1879 Form("#eta vs #phi of clusters in cone for #it{R} = %2.2f",r),
1880 netabins,-1,1,nphibins,0,TMath::TwoPi());
1881 fhEtaPhiInConeCluster->SetXTitle("#eta");
1882 fhEtaPhiInConeCluster->SetYTitle("#phi");
1883 outputContainer->Add(fhEtaPhiInConeCluster) ;
1884
1885 fhEtaPhiCluster= new TH2F("hEtaPhiCluster",
1886 Form("#eta vs #phi of all clusters"),
1887 netabins,-1,1,nphibins,0,TMath::TwoPi());
1888 fhEtaPhiCluster->SetXTitle("#eta");
1889 fhEtaPhiCluster->SetYTitle("#phi");
1890 outputContainer->Add(fhEtaPhiCluster) ;
6ae3345d 1891
977564f5 1892 }
9b01dc66 1893
72433939 1894 fhPtClusterInCone = new TH2F("hPtClusterInCone",
9a97f32f 1895 Form("#it{p}_{T} of clusters in isolation cone for #it{R} = %2.2f",r),
72433939 1896 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 1897 fhPtClusterInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 1898 fhPtClusterInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
72433939 1899 outputContainer->Add(fhPtClusterInCone) ;
1900
977564f5 1901 if(fFillCellHistograms)
1902 {
1903 fhPtCellInCone = new TH2F("hPtCellInCone",
1904 Form("#it{p}_{T} of cells in isolation cone for #it{R} = %2.2f",r),
1905 nptbins,ptmin,ptmax,1000,0,50);
1906 fhPtCellInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
1907 fhPtCellInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1908 outputContainer->Add(fhPtCellInCone) ;
1909
1910 fhEtaBandCell = new TH2F("hEtaBandCell",
1911 Form("#col vs #row of cells in #eta band isolation cone for #it{R} = %2.2f",r),
1912 96,0,95,128,0,127);
1913 fhEtaBandCell->SetXTitle("#col");
1914 fhEtaBandCell->SetYTitle("#row");
1915 outputContainer->Add(fhEtaBandCell) ;
1916
1917 fhPhiBandCell = new TH2F("hPhiBandCell",
1918 Form("#col vs #row of cells in #phi band isolation cone for #it{R} = %2.2f",r),
1919 96,0,95,128,0,127);
1920 fhPhiBandCell->SetXTitle("#col");
1921 fhPhiBandCell->SetYTitle("#row");
1922 outputContainer->Add(fhPhiBandCell) ;
1923 }
72433939 1924
977564f5 1925 if(fFillUEBandSubtractHistograms)
1926 {
1927 fhConeSumPtEtaUESubCluster = new TH2F("hConeSumPtEtaUESubCluster",
1928 Form("Clusters #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
1929 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
1930 fhConeSumPtEtaUESubCluster->SetYTitle("#Sigma #it{p}_{T}");
1931 fhConeSumPtEtaUESubCluster->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1932 outputContainer->Add(fhConeSumPtEtaUESubCluster) ;
1933
1934 fhConeSumPtPhiUESubCluster = new TH2F("hConeSumPtPhiUESubCluster",
1935 Form("Clusters #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
1936 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
1937 fhConeSumPtPhiUESubCluster->SetYTitle("#Sigma #it{p}_{T}");
1938 fhConeSumPtPhiUESubCluster->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1939 outputContainer->Add(fhConeSumPtPhiUESubCluster) ;
1940
1941 fhConeSumPtEtaUESubClusterTrigEtaPhi = new TH2F("hConeSumPtEtaUESubClusterTrigEtaPhi",
1942 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),
1943 netabins,etamin,etamax,nphibins,phimin,phimax);
1944 fhConeSumPtEtaUESubClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1945 fhConeSumPtEtaUESubClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
1946 fhConeSumPtEtaUESubClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1947 outputContainer->Add(fhConeSumPtEtaUESubClusterTrigEtaPhi) ;
1948
1949 fhConeSumPtPhiUESubClusterTrigEtaPhi = new TH2F("hConeSumPtPhiUESubClusterTrigEtaPhi",
1950 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),
1951 netabins,etamin,etamax,nphibins,phimin,phimax);
1952 fhConeSumPtPhiUESubClusterTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1953 fhConeSumPtPhiUESubClusterTrigEtaPhi->SetXTitle("#eta_{trigger}");
1954 fhConeSumPtPhiUESubClusterTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1955 outputContainer->Add(fhConeSumPtPhiUESubClusterTrigEtaPhi) ;
1956
1957 if(fFillCellHistograms)
1958 {
1959 fhConeSumPtEtaUESubCell = new TH2F("hConeSumPtEtaUESubCell",
1960 Form("Cells #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
1961 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
1962 fhConeSumPtEtaUESubCell->SetYTitle("#Sigma #it{p}_{T}");
1963 fhConeSumPtEtaUESubCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1964 outputContainer->Add(fhConeSumPtEtaUESubCell) ;
1965
1966 fhConeSumPtPhiUESubCell = new TH2F("hConeSumPtPhiUESubCell",
1967 Form("Cells #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
1968 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
1969 fhConeSumPtPhiUESubCell->SetYTitle("#Sigma #it{p}_{T}");
1970 fhConeSumPtPhiUESubCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1971 outputContainer->Add(fhConeSumPtPhiUESubCell) ;
1972
1973 fhConeSumPtEtaUESubCellTrigEtaPhi = new TH2F("hConeSumPtEtaUESubCellTrigEtaPhi",
1974 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),
72433939 1975 netabins,etamin,etamax,nphibins,phimin,phimax);
977564f5 1976 fhConeSumPtEtaUESubCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1977 fhConeSumPtEtaUESubCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
1978 fhConeSumPtEtaUESubCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1979 outputContainer->Add(fhConeSumPtEtaUESubCellTrigEtaPhi) ;
1980
1981 fhConeSumPtPhiUESubCellTrigEtaPhi = new TH2F("hConeSumPtPhiUESubCellTrigEtaPhi",
1982 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),
72433939 1983 netabins,etamin,etamax,nphibins,phimin,phimax);
977564f5 1984 fhConeSumPtPhiUESubCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
1985 fhConeSumPtPhiUESubCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
1986 fhConeSumPtPhiUESubCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
1987 outputContainer->Add(fhConeSumPtPhiUESubCellTrigEtaPhi) ;
1988 }
1989
1990 fhFractionClusterOutConeEta = new TH2F("hFractionClusterOutConeEta",
1991 Form("Fraction of the isolation cone #it{R} = %2.2f, out of clusters #eta acceptance",r),
1992 nptbins,ptmin,ptmax,100,0,1);
1993 fhFractionClusterOutConeEta->SetYTitle("#it{fraction}");
1994 fhFractionClusterOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
1995 outputContainer->Add(fhFractionClusterOutConeEta) ;
1996
1997 fhFractionClusterOutConeEtaTrigEtaPhi = new TH2F("hFractionClusterOutConeEtaTrigEtaPhi",
1998 Form("Fraction of the isolation cone #it{R} = %2.2f, out of clusters #eta acceptance, in trigger #eta-#phi ",r),
1999 netabins,etamin,etamax,nphibins,phimin,phimax);
2000 fhFractionClusterOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
2001 fhFractionClusterOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
2002 fhFractionClusterOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2003 outputContainer->Add(fhFractionClusterOutConeEtaTrigEtaPhi) ;
2004
2005 fhFractionClusterOutConePhi = new TH2F("hFractionClusterOutConePhi",
2006 Form("Fraction of the isolation cone #it{R} = %2.2f, out of clusters #phi acceptance",r),
2007 nptbins,ptmin,ptmax,100,0,1);
2008 fhFractionClusterOutConePhi->SetYTitle("#it{fraction}");
2009 fhFractionClusterOutConePhi->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2010 outputContainer->Add(fhFractionClusterOutConePhi) ;
2011
2012 fhFractionClusterOutConePhiTrigEtaPhi = new TH2F("hFractionClusterOutConePhiTrigEtaPhi",
2013 Form("Fraction of the isolation cone #it{R} = %2.2f, out of clusters #phi acceptance, in trigger #eta-#phi ",r),
2014 netabins,etamin,etamax,nphibins,phimin,phimax);
2015 fhFractionClusterOutConePhiTrigEtaPhi->SetZTitle("#it{fraction}");
2016 fhFractionClusterOutConePhiTrigEtaPhi->SetXTitle("#eta_{trigger}");
2017 fhFractionClusterOutConePhiTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2018 outputContainer->Add(fhFractionClusterOutConePhiTrigEtaPhi) ;
2019
2020 fhConeSumPtSubvsConeSumPtTotPhiCluster = new TH2F("hConeSumPtSubvsConeSumPtTotPhiCluster",
2021 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),
2022 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2023 fhConeSumPtSubvsConeSumPtTotPhiCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2024 fhConeSumPtSubvsConeSumPtTotPhiCluster->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2025 outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiCluster);
2026
2027 fhConeSumPtSubNormvsConeSumPtTotPhiCluster = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiCluster",
2028 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),
2029 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2030 fhConeSumPtSubNormvsConeSumPtTotPhiCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2031 fhConeSumPtSubNormvsConeSumPtTotPhiCluster->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2032 outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiCluster);
2033
2034 fhConeSumPtSubvsConeSumPtTotEtaCluster = new TH2F("hConeSumPtSubvsConeSumPtTotEtaCluster",
2035 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),
2036 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2037 fhConeSumPtSubvsConeSumPtTotEtaCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2038 fhConeSumPtSubvsConeSumPtTotEtaCluster->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2039 outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaCluster);
2040
2041 fhConeSumPtSubNormvsConeSumPtTotEtaCluster = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaCluster",
2042 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),
2043 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2044 fhConeSumPtSubNormvsConeSumPtTotEtaCluster->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2045 fhConeSumPtSubNormvsConeSumPtTotEtaCluster->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2046 outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaCluster);
2047
2048 fhConeSumPtVSUEClusterEtaBand = new TH2F("hConeSumPtVSUEClusterEtaBand",
2049 Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in eta band for cluster (before normalization), R=%2.2f",r),
2050 nptsumbins,ptsummin,ptsummax,2*nptsumbins,ptsummin,2*ptsummax);
2051 fhConeSumPtVSUEClusterEtaBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
2052 fhConeSumPtVSUEClusterEtaBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
2053 outputContainer->Add(fhConeSumPtVSUEClusterEtaBand);
2054
2055 fhConeSumPtVSUEClusterPhiBand = new TH2F("hConeSumPtVSUEClusterPhiBand",
2056 Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in phi band for cluster (before normalization), R=%2.2f",r),
2057 nptsumbins,ptsummin,ptsummax,8*nptsumbins,ptsummin,8*ptsummax);
2058 fhConeSumPtVSUEClusterPhiBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
2059 fhConeSumPtVSUEClusterPhiBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
2060 outputContainer->Add(fhConeSumPtVSUEClusterPhiBand);
6ae3345d 2061
977564f5 2062 if(fFillCellHistograms)
2063 {
2064 fhFractionCellOutConeEta = new TH2F("hFractionCellOutConeEta",
2065 Form("Fraction of the isolation cone #it{R} = %2.2f, out of cells #eta acceptance",r),
2066 nptbins,ptmin,ptmax,100,0,1);
2067 fhFractionCellOutConeEta->SetYTitle("#it{fraction}");
2068 fhFractionCellOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2069 outputContainer->Add(fhFractionCellOutConeEta) ;
2070
2071 fhFractionCellOutConeEtaTrigEtaPhi = new TH2F("hFractionCellOutConeEtaTrigEtaPhi",
2072 Form("Fraction of the isolation cone #it{R} = %2.2f, out of cells #eta acceptance, in trigger #eta-#phi ",r),
2073 netabins,etamin,etamax,nphibins,phimin,phimax);
2074 fhFractionCellOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
2075 fhFractionCellOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
2076 fhFractionCellOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2077 outputContainer->Add(fhFractionCellOutConeEtaTrigEtaPhi) ;
2078
2079 fhFractionCellOutConePhi = new TH2F("hFractionCellOutConePhi",
2080 Form("Fraction of the isolation cone #it{R} = %2.2f, out of cells #phi acceptance",r),
2081 nptbins,ptmin,ptmax,100,0,1);
2082 fhFractionCellOutConePhi->SetYTitle("#it{fraction}");
2083 fhFractionCellOutConePhi->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2084 outputContainer->Add(fhFractionCellOutConePhi) ;
2085
2086 fhFractionCellOutConePhiTrigEtaPhi = new TH2F("hFractionCellOutConePhiTrigEtaPhi",
2087 Form("Fraction of the isolation cone #it{R} = %2.2f, out of cells #phi acceptance, in trigger #eta-#phi ",r),
2088 netabins,etamin,etamax,nphibins,phimin,phimax);
2089 fhFractionCellOutConePhiTrigEtaPhi->SetZTitle("#it{fraction}");
2090 fhFractionCellOutConePhiTrigEtaPhi->SetXTitle("#eta_{trigger}");
2091 fhFractionCellOutConePhiTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2092 outputContainer->Add(fhFractionCellOutConePhiTrigEtaPhi) ;
2093
2094
2095 fhConeSumPtSubvsConeSumPtTotPhiCell = new TH2F("hConeSumPtSubvsConeSumPtTotPhiCell",
2096 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),
b5d10017 2097 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
977564f5 2098 fhConeSumPtSubvsConeSumPtTotPhiCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2099 fhConeSumPtSubvsConeSumPtTotPhiCell->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2100 outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiCell);
2101
2102 fhConeSumPtSubNormvsConeSumPtTotPhiCell = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiCell",
2103 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),
2104 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2105 fhConeSumPtSubNormvsConeSumPtTotPhiCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2106 fhConeSumPtSubNormvsConeSumPtTotPhiCell->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2107 outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiCell);
2108
2109 fhConeSumPtSubvsConeSumPtTotEtaCell = new TH2F("hConeSumPtSubvsConeSumPtTotEtaCell",
2110 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),
b5d10017 2111 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
977564f5 2112 fhConeSumPtSubvsConeSumPtTotEtaCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2113 fhConeSumPtSubvsConeSumPtTotEtaCell->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2114 outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaCell);
2115
2116 fhConeSumPtSubNormvsConeSumPtTotEtaCell = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaCell",
2117 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),
2118 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2119 fhConeSumPtSubNormvsConeSumPtTotEtaCell->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2120 fhConeSumPtSubNormvsConeSumPtTotEtaCell->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2121 outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaCell);
2122 }
2123 }
72433939 2124 }
2125
2126 // Track only histograms
2127 if(GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyNeutral)
2128 {
2129 fhConeSumPtTrack = new TH2F("hConePtSumTrack",
9a97f32f 2130 Form("Track #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
72433939 2131 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
dc9c6e78 2132 fhConeSumPtTrack->SetYTitle("#Sigma #it{p}_{T}");
9a97f32f 2133 fhConeSumPtTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
72433939 2134 outputContainer->Add(fhConeSumPtTrack) ;
1b1a1b2e 2135
2136 fhConePtLeadTrack = new TH2F("hConeLeadPtTrack",
2137 Form("Track leading in isolation cone for #it{R} = %2.2f",r),
2138 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2139 fhConePtLeadTrack->SetYTitle("#it{p}_{T, leading} (GeV/#it{c})");
2140 fhConePtLeadTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2141 outputContainer->Add(fhConePtLeadTrack) ;
72433939 2142
72433939 2143 fhPtTrackInCone = new TH2F("hPtTrackInCone",
9a97f32f 2144 Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f",r),
72433939 2145 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 2146 fhPtTrackInCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 2147 fhPtTrackInCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
72433939 2148 outputContainer->Add(fhPtTrackInCone) ;
6ae3345d 2149
72433939 2150
977564f5 2151 if(fFillUEBandSubtractHistograms)
2152 {
2153 fhConeSumPtEtaBandUETrack = new TH2F("hConePtSumEtaBandUETrack",
2154 "#Sigma track #it{p}_{T} in UE Eta Band",
2155 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2156 fhConeSumPtEtaBandUETrack->SetYTitle("#Sigma #it{p}_{T}");
2157 fhConeSumPtEtaBandUETrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2158 outputContainer->Add(fhConeSumPtEtaBandUETrack) ;
2159
2160 fhConeSumPtPhiBandUETrack = new TH2F("hConePtSumPhiBandUETrack",
2161 "#Sigma track #it{p}_{T} in UE Phi Band",
2162 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax*8);
2163 fhConeSumPtPhiBandUETrack->SetYTitle("#Sigma #it{p}_{T}");
2164 fhConeSumPtPhiBandUETrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2165 outputContainer->Add(fhConeSumPtPhiBandUETrack) ;
2166
2167
2168 fhConeSumPtEtaBandUETrackTrigEtaPhi = new TH2F("hConePtSumEtaBandUETrackTrigEtaPhi",
2169 "Trigger #eta vs #phi, #Sigma track #it{p}_{T} in UE Eta Band",
2170 netabins,etamin,etamax,nphibins,phimin,phimax);
2171 fhConeSumPtEtaBandUETrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2172 fhConeSumPtEtaBandUETrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2173 fhConeSumPtEtaBandUETrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2174 outputContainer->Add(fhConeSumPtEtaBandUETrackTrigEtaPhi) ;
2175
2176 fhConeSumPtPhiBandUETrackTrigEtaPhi = new TH2F("hConePtSumPhiBandUETrackTrigEtaPhi",
2177 "Trigger #eta vs #phi, #Sigma track #it{p}_{T} in UE Phi Band",
2178 netabins,etamin,etamax,nphibins,phimin,phimax);
2179 fhConeSumPtPhiBandUETrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2180 fhConeSumPtPhiBandUETrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2181 fhConeSumPtPhiBandUETrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2182 outputContainer->Add(fhConeSumPtPhiBandUETrackTrigEtaPhi) ;
2183
2184 fhEtaBandTrack = new TH2F("hEtaBandTrack",
2185 Form("#eta vs #phi of tracks in #eta band isolation cone for #it{R} = %2.2f",r),
2186 netabins,-1,1,nphibins,0,TMath::TwoPi());
2187 fhEtaBandTrack->SetXTitle("#eta");
2188 fhEtaBandTrack->SetYTitle("#phi");
2189 outputContainer->Add(fhEtaBandTrack) ;
2190
2191 fhPhiBandTrack = new TH2F("hPhiBandTrack",
2192 Form("#eta vs #phi of tracks in #phi band isolation cone for #it{R} = %2.2f",r),
2193 netabins,-1,1,nphibins,0,TMath::TwoPi());
2194 fhPhiBandTrack->SetXTitle("#eta");
2195 fhPhiBandTrack->SetYTitle("#phi");
2196 outputContainer->Add(fhPhiBandTrack) ;
2197
2198 fhConeSumPtEtaUESubTrack = new TH2F("hConeSumPtEtaUESubTrack",
2199 Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
2200 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2201 fhConeSumPtEtaUESubTrack->SetYTitle("#Sigma #it{p}_{T}");
2202 fhConeSumPtEtaUESubTrack->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2203 outputContainer->Add(fhConeSumPtEtaUESubTrack) ;
2204
2205 fhConeSumPtPhiUESubTrack = new TH2F("hConeSumPtPhiUESubTrack",
2206 Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
2207 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2208 fhConeSumPtPhiUESubTrack->SetYTitle("#Sigma #it{p}_{T}");
2209 fhConeSumPtPhiUESubTrack->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2210 outputContainer->Add(fhConeSumPtPhiUESubTrack) ;
2211
2212 fhConeSumPtEtaUESubTrackTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrackTrigEtaPhi",
2213 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),
2214 netabins,etamin,etamax,nphibins,phimin,phimax);
2215 fhConeSumPtEtaUESubTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2216 fhConeSumPtEtaUESubTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2217 fhConeSumPtEtaUESubTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2218 outputContainer->Add(fhConeSumPtEtaUESubTrackTrigEtaPhi) ;
2219
2220 fhConeSumPtPhiUESubTrackTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrackTrigEtaPhi",
2221 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),
2222 netabins,etamin,etamax,nphibins,phimin,phimax);
2223 fhConeSumPtPhiUESubTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2224 fhConeSumPtPhiUESubTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2225 fhConeSumPtPhiUESubTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2226 outputContainer->Add(fhConeSumPtPhiUESubTrackTrigEtaPhi) ;
2227
2228 fhFractionTrackOutConeEta = new TH2F("hFractionTrackOutConeEta",
2229 Form("Fraction of the isolation cone #it{R} = %2.2f, out of tracks #eta acceptance",r),
2230 nptbins,ptmin,ptmax,100,0,1);
2231 fhFractionTrackOutConeEta->SetYTitle("#it{fraction}");
2232 fhFractionTrackOutConeEta->SetXTitle("#it{p}_{T,trigger} (GeV/#it{c})");
2233 outputContainer->Add(fhFractionTrackOutConeEta) ;
2234
2235 fhFractionTrackOutConeEtaTrigEtaPhi = new TH2F("hFractionTrackOutConeEtaTrigEtaPhi",
2236 Form("Fraction of the isolation cone #it{R} = %2.2f, out of tracks #eta acceptance, in trigger #eta-#phi ",r),
2237 netabins,etamin,etamax,nphibins,phimin,phimax);
2238 fhFractionTrackOutConeEtaTrigEtaPhi->SetZTitle("#it{fraction}");
2239 fhFractionTrackOutConeEtaTrigEtaPhi->SetXTitle("#eta_{trigger}");
2240 fhFractionTrackOutConeEtaTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2241 outputContainer->Add(fhFractionTrackOutConeEtaTrigEtaPhi) ;
2242
2243 fhConeSumPtSubvsConeSumPtTotPhiTrack = new TH2F("hConeSumPtSubvsConeSumPtTotPhiTrack",
2244 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),
2245 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2246 fhConeSumPtSubvsConeSumPtTotPhiTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2247 fhConeSumPtSubvsConeSumPtTotPhiTrack->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2248 outputContainer->Add(fhConeSumPtSubvsConeSumPtTotPhiTrack);
2249
2250 fhConeSumPtSubNormvsConeSumPtTotPhiTrack = new TH2F("hConeSumPtSubNormvsConeSumPtTotPhiTrack",
2251 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),
2252 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2253 fhConeSumPtSubNormvsConeSumPtTotPhiTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2254 fhConeSumPtSubNormvsConeSumPtTotPhiTrack->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2255 outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotPhiTrack);
2256
2257 fhConeSumPtSubvsConeSumPtTotEtaTrack = new TH2F("hConeSumPtSubvsConeSumPtTotEtaTrack",
2258 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),
2259 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2260 fhConeSumPtSubvsConeSumPtTotEtaTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2261 fhConeSumPtSubvsConeSumPtTotEtaTrack->SetYTitle("#Sigma #it{p}_{T, sub} (GeV/#it{c})");
2262 outputContainer->Add(fhConeSumPtSubvsConeSumPtTotEtaTrack);
2263
2264 fhConeSumPtSubNormvsConeSumPtTotEtaTrack = new TH2F("hConeSumPtSubNormvsConeSumPtTotEtaTrack",
2265 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),
2266 nptsumbins,ptsummin,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2267 fhConeSumPtSubNormvsConeSumPtTotEtaTrack->SetXTitle("#Sigma #it{p}_{T, tot} (GeV/#it{c})");
2268 fhConeSumPtSubNormvsConeSumPtTotEtaTrack->SetYTitle("#Sigma #it{p}_{T, sub norm} (GeV/#it{c})");
2269 outputContainer->Add(fhConeSumPtSubNormvsConeSumPtTotEtaTrack);
2270
2271
2272 // UE in perpendicular cone
2273 fhPerpConeSumPt = new TH2F("hPerpConePtSum",
2274 Form("#Sigma #it{p}_{T} in isolation cone at #pm 45 degree phi from trigger particle, #it{R} = %2.2f",r),
2275 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2276 fhPerpConeSumPt->SetYTitle("#Sigma #it{p}_{T}");
2277 fhPerpConeSumPt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2278 outputContainer->Add(fhPerpConeSumPt) ;
2279
2280 fhPtInPerpCone = new TH2F("hPtInPerpCone",
2281 Form("#it{p}_{T} in isolation cone at #pm 45 degree phi from trigger particle, #it{R} = %2.2f",r),
2282 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
2283 fhPtInPerpCone->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
2284 fhPtInPerpCone->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2285 outputContainer->Add(fhPtInPerpCone) ;
2286
2287 fhEtaPhiTrack= new TH2F("hEtaPhiTrack",
2288 Form("#eta vs #phi of all Tracks"),
2289 netabins,-1,1,nphibins,0,TMath::TwoPi());
2290 fhEtaPhiTrack->SetXTitle("#eta");
2291 fhEtaPhiTrack->SetYTitle("#phi");
2292 outputContainer->Add(fhEtaPhiTrack) ;
2293
2294 fhEtaPhiInConeTrack= new TH2F("hEtaPhiInConeTrack",
2295 Form("#eta vs #phi of Tracks in cone for #it{R} = %2.2f",r),
2296 netabins,-1,1,nphibins,0,TMath::TwoPi());
2297 fhEtaPhiInConeTrack->SetXTitle("#eta");
2298 fhEtaPhiInConeTrack->SetYTitle("#phi");
2299 outputContainer->Add(fhEtaPhiInConeTrack) ;
2300
2301 fhConeSumPtVSUETracksEtaBand = new TH2F("hConeSumPtVSUETracksEtaBand",
2302 Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in eta band for tracks (before normalization), R=%2.2f",r),
2303 nptsumbins,ptsummin,ptsummax,2*nptsumbins,ptsummin,2*ptsummax);
2304 fhConeSumPtVSUETracksEtaBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
2305 fhConeSumPtVSUETracksEtaBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
2306 outputContainer->Add(fhConeSumPtVSUETracksEtaBand);
2307
2308 fhConeSumPtVSUETracksPhiBand = new TH2F("hConeSumPtVSUETracksPhiBand",
2309 Form("#Sigma #it{p}_{T} in cone versus #Sigma #it{p}_{T} in phi band for tracks (before normalization), R=%2.2f",r),
2310 nptsumbins,ptsummin,ptsummax,8*nptsumbins,ptsummin,8*ptsummax);
2311 fhConeSumPtVSUETracksPhiBand->SetXTitle("#Sigma #it{p}_{T} cone (GeV/#it{c})");
2312 fhConeSumPtVSUETracksPhiBand->SetYTitle("#Sigma #it{p}_{T} UE (GeV/#it{c})");
2313 outputContainer->Add(fhConeSumPtVSUETracksPhiBand);
2314 }
72433939 2315 }
2316
977564f5 2317 if(GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged )
72433939 2318 {
72433939 2319 fhConeSumPtClustervsTrack = new TH2F("hConePtSumClustervsTrack",
9a97f32f 2320 Form("Track vs Cluster #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
72433939 2321 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
dc1966bb 2322 fhConeSumPtClustervsTrack->SetXTitle("#Sigma #it{p}_{T}^{cluster} (GeV/#it{c})");
2323 fhConeSumPtClustervsTrack->SetYTitle("#Sigma #it{p}_{T}^{track} (GeV/#it{c})");
72433939 2324 outputContainer->Add(fhConeSumPtClustervsTrack) ;
dc1966bb 2325
2326 fhConeSumPtClusterTrackFrac = new TH2F("hConePtSumClusterTrackFraction",
2327 Form("#Sigma #it{p}_{T}^{cluster}/#Sigma #it{p}_{T}^{track} in isolation cone for #it{R} = %2.2f",r),
2328 nptbins,ptmin,ptmax,200,0,4);
2329 fhConeSumPtClusterTrackFrac->SetYTitle("#Sigma #it{p}^{cluster}_{T} /#Sigma #it{p}_{T}^{track}");
2330 fhConeSumPtClusterTrackFrac->SetXTitle("#it{p}^{trigger}_{T} (GeV/#it{c})");
2331 outputContainer->Add(fhConeSumPtClusterTrackFrac) ;
2332
2333
2334 fhConePtLeadClustervsTrack = new TH2F("hConePtLeadClustervsTrack",
2335 Form("Track vs Cluster lead #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
2336 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2337 fhConePtLeadClustervsTrack->SetXTitle("#it{p}^{leading cluster}_{T} (GeV/#it{c})");
2338 fhConePtLeadClustervsTrack->SetYTitle("#it{p}^{leading track}_{T} (GeV/#it{c})");
2339 outputContainer->Add(fhConePtLeadClustervsTrack) ;
2340
2341 fhConePtLeadClusterTrackFrac = new TH2F("hConePtLeadClusterTrackFraction",
2342 Form(" #it{p}^{leading cluster}_{T}/#it{p}^{leading track}_{T} in isolation cone for #it{R} = %2.2f",r),
2343 nptbins,ptmin,ptmax,200,0,4);
2344 fhConePtLeadClusterTrackFrac->SetYTitle("#it{p}^{leading cluster}_{T}/ #it{p}^{leading track}_{T}");
2345 fhConePtLeadClusterTrackFrac->SetXTitle("#it{p}^{trigger}_{T} (GeV/#it{c})");
2346 outputContainer->Add(fhConePtLeadClusterTrackFrac) ;
2347
72433939 2348
977564f5 2349 if(fFillCellHistograms)
2350 {
2351 fhConeSumPtCellvsTrack = new TH2F("hConePtSumCellvsTrack",
2352 Form("Track vs cell #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
2353 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2354 fhConeSumPtCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2355 fhConeSumPtCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2356 outputContainer->Add(fhConeSumPtCellvsTrack) ;
2357
2358 fhConeSumPtCellTrack = new TH2F("hConePtSumCellTrack",
2359 Form("Track and Cell #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
2360 nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2361 fhConeSumPtCellTrack->SetYTitle("#Sigma #it{p}_{T}");
2362 fhConeSumPtCellTrack->SetXTitle("#it{p}_{T, trigger} (GeV/#it{c})");
2363 outputContainer->Add(fhConeSumPtCellTrack) ;
2364
2365 fhConeSumPtCellTrackTrigEtaPhi = new TH2F("hConePtSumCellTrackTrigEtaPhi",
2366 Form("Trigger #eta vs #phi, #Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",r),
2367 netabins,etamin,etamax,nphibins,phimin,phimax);
2368 fhConeSumPtCellTrackTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2369 fhConeSumPtCellTrackTrigEtaPhi->SetXTitle("#eta_{trigger}");
2370 fhConeSumPtCellTrackTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2371 outputContainer->Add(fhConeSumPtCellTrackTrigEtaPhi) ;
2372
2373 }
9b01dc66 2374
977564f5 2375 if(fFillUEBandSubtractHistograms)
2376 {
2377 fhConeSumPtEtaUESub = new TH2F("hConeSumPtEtaUESub",
2378 Form("#Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
2379 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2380 fhConeSumPtEtaUESub->SetYTitle("#Sigma #it{p}_{T}");
2381 fhConeSumPtEtaUESub->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2382 outputContainer->Add(fhConeSumPtEtaUESub) ;
2383
2384 fhConeSumPtPhiUESub = new TH2F("hConeSumPtPhiUESub",
2385 Form("#Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
2386 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2387 fhConeSumPtPhiUESub->SetYTitle("#Sigma #it{p}_{T}");
2388 fhConeSumPtPhiUESub->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2389 outputContainer->Add(fhConeSumPtPhiUESub) ;
2390
2391 fhConeSumPtEtaUESubTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrigEtaPhi",
2392 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),
2393 netabins,etamin,etamax,nphibins,phimin,phimax);
2394 fhConeSumPtEtaUESubTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2395 fhConeSumPtEtaUESubTrigEtaPhi->SetXTitle("#eta_{trigger}");
2396 fhConeSumPtEtaUESubTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2397 outputContainer->Add(fhConeSumPtEtaUESubTrigEtaPhi) ;
2398
2399 fhConeSumPtPhiUESubTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrigEtaPhi",
2400 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),
2401 netabins,etamin,etamax,nphibins,phimin,phimax);
2402 fhConeSumPtPhiUESubTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2403 fhConeSumPtPhiUESubTrigEtaPhi->SetXTitle("#eta_{trigger}");
2404 fhConeSumPtPhiUESubTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2405 outputContainer->Add(fhConeSumPtPhiUESubTrigEtaPhi) ;
2406
2407 fhConeSumPtEtaUESubClustervsTrack = new TH2F("hConePtSumEtaUESubClustervsTrack",
2408 Form("Track vs Cluster #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} = %2.2f",r),
2409 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2410 fhConeSumPtEtaUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2411 fhConeSumPtEtaUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2412 outputContainer->Add(fhConeSumPtEtaUESubClustervsTrack) ;
2413
2414 fhConeSumPtPhiUESubClustervsTrack = new TH2F("hConePhiUESubPtSumClustervsTrack",
2415 Form("Track vs Cluster #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} = %2.2f",r),
2416 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2417 fhConeSumPtPhiUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2418 fhConeSumPtPhiUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2419 outputContainer->Add(fhConeSumPtPhiUESubClustervsTrack) ;
2420
2421 fhEtaBandClustervsTrack = new TH2F("hEtaBandClustervsTrack",
2422 Form("Track vs Cluster #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} = %2.2f",r),
9b01dc66 2423 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
977564f5 2424 fhEtaBandClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2425 fhEtaBandClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2426 outputContainer->Add(fhEtaBandClustervsTrack) ;
2427
2428 fhPhiBandClustervsTrack = new TH2F("hPhiBandClustervsTrack",
2429 Form("Track vs Cluster #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} = %2.2f",r),
2430 nptsumbins,ptsummin,ptsummax*4,nptsumbins,ptsummin,ptsummax*8);
2431 fhPhiBandClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2432 fhPhiBandClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2433 outputContainer->Add(fhPhiBandClustervsTrack) ;
2434
2435 fhEtaBandNormClustervsTrack = new TH2F("hEtaBandNormClustervsTrack",
2436 Form("Track vs Cluster #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} = %2.2f",r),
2437 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2438 fhEtaBandNormClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2439 fhEtaBandNormClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2440 outputContainer->Add(fhEtaBandNormClustervsTrack) ;
2441
2442 fhPhiBandNormClustervsTrack = new TH2F("hPhiBandNormClustervsTrack",
2443 Form("Track vs Cluster #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} = %2.2f",r),
2444 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2445 fhPhiBandNormClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2446 fhPhiBandNormClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2447 outputContainer->Add(fhPhiBandNormClustervsTrack) ;
2448
2449 fhConeSumPtEtaUESubClustervsTrack = new TH2F("hConePtSumEtaUESubClustervsTrack",
2450 Form("Track vs Cluster #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} = %2.2f",r),
2451 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2452 fhConeSumPtEtaUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2453 fhConeSumPtEtaUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2454 outputContainer->Add(fhConeSumPtEtaUESubClustervsTrack) ;
2455
2456 fhConeSumPtPhiUESubClustervsTrack = new TH2F("hConePhiUESubPtSumClustervsTrack",
2457 Form("Track vs Cluster #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} = %2.2f",r),
2458 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2459 fhConeSumPtPhiUESubClustervsTrack->SetXTitle("#Sigma #it{p}_{T} cluster");
2460 fhConeSumPtPhiUESubClustervsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2461 outputContainer->Add(fhConeSumPtPhiUESubClustervsTrack) ;
2462
2463 if(fFillCellHistograms)
2464 {
2465
2466 fhConeSumPtEtaUESubCellvsTrack = new TH2F("hConePtSumEtaUESubCellvsTrack",
2467 Form("Track vs Cell #Sigma #it{p}_{T} UE sub eta band in isolation cone for #it{R} = %2.2f",r),
2468 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2469 fhConeSumPtEtaUESubCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2470 fhConeSumPtEtaUESubCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2471 outputContainer->Add(fhConeSumPtEtaUESubCellvsTrack) ;
2472
2473 fhConeSumPtPhiUESubCellvsTrack = new TH2F("hConePhiUESubPtSumCellvsTrack",
2474 Form("Track vs Cell #Sigma #it{p}_{T} UE sub phi band in isolation cone for #it{R} = %2.2f",r),
2475 2*nptsumbins,-ptsummax,ptsummax,2*nptsumbins,-ptsummax,ptsummax);
2476 fhConeSumPtPhiUESubCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2477 fhConeSumPtPhiUESubCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2478 outputContainer->Add(fhConeSumPtPhiUESubCellvsTrack) ;
2479
2480 fhEtaBandCellvsTrack = new TH2F("hEtaBandCellvsTrack",
7726e3a3 2481 Form("Track vs Cell #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} = %2.2f",r),
9b01dc66 2482 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
977564f5 2483 fhEtaBandCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2484 fhEtaBandCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2485 outputContainer->Add(fhEtaBandCellvsTrack) ;
2486
2487 fhPhiBandCellvsTrack = new TH2F("hPhiBandCellvsTrack",
7726e3a3 2488 Form("Track vs Cell #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} = %2.2f",r),
977564f5 2489 nptsumbins,ptsummin,ptsummax*4,nptsumbins,ptsummin,ptsummax*8);
2490 fhPhiBandCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2491 fhPhiBandCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2492 outputContainer->Add(fhPhiBandCellvsTrack) ;
2493
2494 fhEtaBandNormCellvsTrack = new TH2F("hEtaBandNormCellvsTrack",
2495 Form("Track vs Cell #Sigma #it{p}_{T} in Eta band in isolation cone for #it{R} = %2.2f",r),
2496 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2497 fhEtaBandNormCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2498 fhEtaBandNormCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2499 outputContainer->Add(fhEtaBandNormCellvsTrack) ;
2500
2501 fhPhiBandNormCellvsTrack = new TH2F("hPhiBandNormCellvsTrack",
2502 Form("Track vs Cell #Sigma #it{p}_{T} in Phi band in isolation cone for #it{R} = %2.2f",r),
2503 nptsumbins,ptsummin,ptsummax,nptsumbins,ptsummin,ptsummax);
2504 fhPhiBandNormCellvsTrack->SetXTitle("#Sigma #it{p}_{T} cell");
2505 fhPhiBandNormCellvsTrack->SetYTitle("#Sigma #it{p}_{T} track");
2506 outputContainer->Add(fhPhiBandNormCellvsTrack) ;
2507
2508 fhConeSumPtEtaUESubTrackCell = new TH2F("hConeSumPtEtaUESubTrackCell",
2509 Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from eta band in the isolation cone for #it{R} = %2.2f",r),
2510 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2511 fhConeSumPtEtaUESubTrackCell->SetYTitle("#Sigma #it{p}_{T}");
2512 fhConeSumPtEtaUESubTrackCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2513 outputContainer->Add(fhConeSumPtEtaUESubTrackCell) ;
2514
2515 fhConeSumPtPhiUESubTrackCell = new TH2F("hConeSumPtPhiUESubTrackCell",
2516 Form("Tracks #Sigma #it{p}_{T} after bkg subtraction from phi band in the isolation cone for #it{R} = %2.2f",r),
2517 nptbins,ptmin,ptmax,2*nptsumbins,-ptsummax,ptsummax);
2518 fhConeSumPtPhiUESubTrackCell->SetYTitle("#Sigma #it{p}_{T}");
2519 fhConeSumPtPhiUESubTrackCell->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2520 outputContainer->Add(fhConeSumPtPhiUESubTrackCell) ;
2521
2522 fhConeSumPtEtaUESubTrackCellTrigEtaPhi = new TH2F("hConeSumPtEtaUESubTrackCellTrigEtaPhi",
2523 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),
2524 netabins,etamin,etamax,nphibins,phimin,phimax);
2525 fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2526 fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
2527 fhConeSumPtEtaUESubTrackCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2528 outputContainer->Add(fhConeSumPtEtaUESubTrackCellTrigEtaPhi) ;
2529
2530 fhConeSumPtPhiUESubTrackCellTrigEtaPhi = new TH2F("hConeSumPtPhiUESubTrackCellTrigEtaPhi",
2531 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),
2532 netabins,etamin,etamax,nphibins,phimin,phimax);
2533 fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetZTitle("#Sigma #it{p}_{T}");
2534 fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetXTitle("#eta_{trigger}");
2535 fhConeSumPtPhiUESubTrackCellTrigEtaPhi->SetYTitle("#phi_{trigger} (rad)");
2536 outputContainer->Add(fhConeSumPtPhiUESubTrackCellTrigEtaPhi) ;
2537 }
2538 }
72433939 2539 }
977564f5 2540
ca134929 2541 for(Int_t iso = 0; iso < 2; iso++)
b5dbb99b 2542 {
ca134929 2543 if(fFillTMHisto)
31ae6d59 2544 {
ca134929 2545 fhTrackMatchedDEta[iso] = new TH2F
7726e3a3 2546 (Form("hTrackMatchedDEta%s",isoName[iso].Data()),
2547 Form("%s - d#eta of cluster-track vs cluster energy, %s",isoTitle[iso].Data(),parTitle.Data()),
72433939 2548 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
ca134929 2549 fhTrackMatchedDEta[iso]->SetYTitle("d#eta");
2550 fhTrackMatchedDEta[iso]->SetXTitle("E_{cluster} (GeV)");
2551
2552 fhTrackMatchedDPhi[iso] = new TH2F
7726e3a3 2553 (Form("hTrackMatchedDPhi%s",isoName[iso].Data()),
2554 Form("%s - d#phi of cluster-track vs cluster energy, %s",isoTitle[iso].Data(),parTitle.Data()),
72433939 2555 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
ca134929 2556 fhTrackMatchedDPhi[iso]->SetYTitle("d#phi (rad)");
2557 fhTrackMatchedDPhi[iso]->SetXTitle("E_{cluster} (GeV)");
2558
2559 fhTrackMatchedDEtaDPhi[iso] = new TH2F
7726e3a3 2560 (Form("hTrackMatchedDEtaDPhi%s",isoName[iso].Data()),
2561 Form("%s - d#eta vs d#phi of cluster-track, %s",isoTitle[iso].Data(),parTitle.Data()),
72433939 2562 nresetabins,resetamin,resetamax,nresphibins,resphimin,resphimax);
ca134929 2563 fhTrackMatchedDEtaDPhi[iso]->SetYTitle("d#phi (rad)");
72433939 2564 fhTrackMatchedDEtaDPhi[iso]->SetXTitle("d#eta");
ca134929 2565
72433939 2566 outputContainer->Add(fhTrackMatchedDEta[iso]) ;
ca134929 2567 outputContainer->Add(fhTrackMatchedDPhi[iso]) ;
2568 outputContainer->Add(fhTrackMatchedDEtaDPhi[iso]) ;
31ae6d59 2569
ca134929 2570 fhdEdx[iso] = new TH2F
7726e3a3 2571 (Form("hdEdx%s",isoName[iso].Data()),
2572 Form("%s - Matched track <d#it{E}/d#it{x}> vs cluster #it{E}, %s",isoTitle[iso].Data(),parTitle.Data()),
72433939 2573 nptbins,ptmin,ptmax,ndedxbins, dedxmin, dedxmax);
dc9c6e78 2574 fhdEdx[iso]->SetXTitle("#it{E} (GeV)");
9a97f32f 2575 fhdEdx[iso]->SetYTitle("<d#it{E}/d#it{x}>");
72433939 2576 outputContainer->Add(fhdEdx[iso]);
31ae6d59 2577
ca134929 2578 fhEOverP[iso] = new TH2F
7726e3a3 2579 (Form("hEOverP%s",isoName[iso].Data()),
2580 Form("%s - Matched track #it{E}/#it{p} vs cluster, %s",isoTitle[iso].Data(),parTitle.Data()),
72433939 2581 nptbins,ptmin,ptmax,nPoverEbins,pOverEmin,pOverEmax);
dc9c6e78 2582 fhEOverP[iso]->SetXTitle("#it{E} (GeV)");
9a97f32f 2583 fhEOverP[iso]->SetYTitle("#it{E}/#it{p}");
72433939 2584 outputContainer->Add(fhEOverP[iso]);
ca134929 2585
2586 if(IsDataMC())
2587 {
2588 fhTrackMatchedMCParticle[iso] = new TH2F
7726e3a3 2589 (Form("hTrackMatchedMCParticle%s",isoName[iso].Data()),
2590 Form("%s - Origin of particle vs cluster #it{E}, %s",isoTitle[iso].Data(),parTitle.Data()),
72433939 2591 nptbins,ptmin,ptmax,8,0,8);
dc9c6e78 2592 fhTrackMatchedMCParticle[iso]->SetXTitle("#it{E} (GeV)");
ca134929 2593 //fhTrackMatchedMCParticle[iso]->SetYTitle("Particle type");
2594
2595 fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(1 ,"Photon");
2596 fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(2 ,"Electron");
2597 fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(3 ,"Meson Merged");
2598 fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(4 ,"Rest");
2599 fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(5 ,"Conv. Photon");
2600 fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(6 ,"Conv. Electron");
2601 fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(7 ,"Conv. Merged");
2602 fhTrackMatchedMCParticle[iso]->GetYaxis()->SetBinLabel(8 ,"Conv. Rest");
2603
72433939 2604 outputContainer->Add(fhTrackMatchedMCParticle[iso]);
ca134929 2605 }
31ae6d59 2606 }
b5dbb99b 2607
ca134929 2608 if(fFillSSHisto)
b5dbb99b 2609 {
ca134929 2610 fhELambda0[iso] = new TH2F
7726e3a3 2611 (Form("hELambda0%s",isoName[iso].Data()),
2612 Form("%s cluster : #it{E} vs #lambda_{0}, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
ca134929 2613 fhELambda0[iso]->SetYTitle("#lambda_{0}^{2}");
dc9c6e78 2614 fhELambda0[iso]->SetXTitle("#it{E} (GeV)");
72433939 2615 outputContainer->Add(fhELambda0[iso]) ;
6ae3345d 2616
124bffb3 2617 fhELambda1[iso] = new TH2F
2618 (Form("hELambda1%s",isoName[iso].Data()),
2619 Form("%s cluster: #it{E} vs #lambda_{1}, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2620 fhELambda1[iso]->SetYTitle("#lambda_{1}^{2}");
2621 fhELambda1[iso]->SetXTitle("#it{E} (GeV)");
2622 outputContainer->Add(fhELambda1[iso]) ;
6ae3345d 2623
32d244b0 2624 fhPtLambda0[iso] = new TH2F
7726e3a3 2625 (Form("hPtLambda0%s",isoName[iso].Data()),
2626 Form("%s cluster : #it{p}_{T} vs #lambda_{0}, %s",isoTitle[iso].Data(), parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
32d244b0 2627 fhPtLambda0[iso]->SetYTitle("#lambda_{0}^{2}");
dc9c6e78 2628 fhPtLambda0[iso]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
32d244b0 2629 outputContainer->Add(fhPtLambda0[iso]) ;
ca134929 2630
764ab1f4 2631 if(IsDataMC())
2632 {
124bffb3 2633 for(Int_t imc = 0; imc < 9; imc++)
2634 {
2635 fhPtLambda0MC[imc][iso] = new TH2F(Form("hPtLambda0%s_MC%s",isoName[iso].Data(),mcPartName[imc].Data()),
6ae3345d 2636 Form("%s cluster : #it{p}_{T} vs #lambda_{0}: %s %s",isoTitle[iso].Data(),mcPartType[imc].Data(),parTitle.Data()),
2637 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
124bffb3 2638 fhPtLambda0MC[imc][iso]->SetYTitle("#lambda_{0}^{2}");
2639 fhPtLambda0MC[imc][iso]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
2640 outputContainer->Add( fhPtLambda0MC[imc][iso]) ;
2641 }
6ae3345d 2642 }
ca134929 2643
4d1d8f00 2644 if(fIsoDetector=="EMCAL" && GetFirstSMCoveredByTRD() >= 0)
7726e3a3 2645 {
32d244b0 2646 fhPtLambda0TRD[iso] = new TH2F
7726e3a3 2647 (Form("hPtLambda0TRD%s",isoName[iso].Data()),
2648 Form("%s cluster: #it{p}_{T} vs #lambda_{0}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
32d244b0 2649 fhPtLambda0TRD[iso]->SetYTitle("#lambda_{0}^{2}");
dc9c6e78 2650 fhPtLambda0TRD[iso]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
32d244b0 2651 outputContainer->Add(fhPtLambda0TRD[iso]) ;
6ae3345d 2652
ca134929 2653 fhELambda0TRD[iso] = new TH2F
7726e3a3 2654 (Form("hELambda0TRD%s",isoName[iso].Data()),
2655 Form("%s cluster: #it{E} vs #lambda_{0}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
ca134929 2656 fhELambda0TRD[iso]->SetYTitle("#lambda_{0}^{2}");
dc9c6e78 2657 fhELambda0TRD[iso]->SetXTitle("#it{E} (GeV)");
72433939 2658 outputContainer->Add(fhELambda0TRD[iso]) ;
ca134929 2659
2660 fhELambda1TRD[iso] = new TH2F
7726e3a3 2661 (Form("hELambda1TRD%s",isoName[iso].Data()),
2662 Form("%s cluster: #it{E} vs #lambda_{1}, SM behind TRD, %s",isoTitle[iso].Data(),parTitle.Data()),nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
ca134929 2663 fhELambda1TRD[iso]->SetYTitle("#lambda_{1}^{2}");
dc9c6e78 2664 fhELambda1TRD[iso]->SetXTitle("#it{E} (GeV)");
72433939 2665 outputContainer->Add(fhELambda1TRD[iso]) ;
ca134929 2666 }
2667
977564f5 2668 if(fFillNLMHistograms)
2669 {
2670 fhNLocMax[iso] = new TH2F
2671 (Form("hNLocMax%s",isoName[iso].Data()),
2672 Form("%s - Number of local maxima in cluster, %s",isoTitle[iso].Data(),parTitle.Data()),
2673 nptbins,ptmin,ptmax,10,0,10);
2674 fhNLocMax[iso]->SetYTitle("#it{NLM}");
2675 fhNLocMax[iso]->SetXTitle("#it{E} (GeV)");
2676 outputContainer->Add(fhNLocMax[iso]) ;
2677
2678 fhELambda0LocMax1[iso] = new TH2F
2679 (Form("hELambda0LocMax1%s",isoName[iso].Data()),
2680 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);
2681 fhELambda0LocMax1[iso]->SetYTitle("#lambda_{0}^{2}");
2682 fhELambda0LocMax1[iso]->SetXTitle("#it{E} (GeV)");
2683 outputContainer->Add(fhELambda0LocMax1[iso]) ;
2684
2685 fhELambda1LocMax1[iso] = new TH2F
2686 (Form("hELambda1LocMax1%s",isoName[iso].Data()),
2687 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);
2688 fhELambda1LocMax1[iso]->SetYTitle("#lambda_{1}^{2}");
2689 fhELambda1LocMax1[iso]->SetXTitle("#it{E} (GeV)");
2690 outputContainer->Add(fhELambda1LocMax1[iso]) ;
2691
2692 fhELambda0LocMax2[iso] = new TH2F
2693 (Form("hELambda0LocMax2%s",isoName[iso].Data()),
2694 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);
2695 fhELambda0LocMax2[iso]->SetYTitle("#lambda_{0}^{2}");
2696 fhELambda0LocMax2[iso]->SetXTitle("#it{E} (GeV)");
2697 outputContainer->Add(fhELambda0LocMax2[iso]) ;
2698
2699 fhELambda1LocMax2[iso] = new TH2F
2700 (Form("hELambda1LocMax2%s",isoName[iso].Data()),
2701 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);
2702 fhELambda1LocMax2[iso]->SetYTitle("#lambda_{1}^{2}");
2703 fhELambda1LocMax2[iso]->SetXTitle("#it{E} (GeV)");
2704 outputContainer->Add(fhELambda1LocMax2[iso]) ;
2705
2706 fhELambda0LocMaxN[iso] = new TH2F
2707 ( Form("hELambda0LocMaxN%s",isoName[iso].Data()),
2708 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);
2709 fhELambda0LocMaxN[iso]->SetYTitle("#lambda_{0}^{2}");
2710 fhELambda0LocMaxN[iso]->SetXTitle("#it{E} (GeV)");
2711 outputContainer->Add(fhELambda0LocMaxN[iso]) ;
2712
2713 fhELambda1LocMaxN[iso] = new TH2F
2714 (Form("hELambda1LocMaxN%s",isoName[iso].Data()),
2715 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);
2716 fhELambda1LocMaxN[iso]->SetYTitle("#lambda_{1}^{2}");
2717 fhELambda1LocMaxN[iso]->SetXTitle("#it{E} (GeV)");
2718 outputContainer->Add(fhELambda1LocMaxN[iso]) ;
2719 } // NLM
2720 } // SS histo
ca134929 2721 } // control histograms for isolated and non isolated objects
764ab1f4 2722
fedea415 2723
6c80c1bf 2724 if(fFillPileUpHistograms)
2725 {
fedea415 2726 fhPtTrackInConeOtherBC = new TH2F("hPtTrackInConeOtherBC",
9a97f32f 2727 Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC!=0",r),
fedea415 2728 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 2729 fhPtTrackInConeOtherBC->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 2730 fhPtTrackInConeOtherBC->SetXTitle("#it{p}_{T} (GeV/#it{c})");
fedea415 2731 outputContainer->Add(fhPtTrackInConeOtherBC) ;
2732
2733 fhPtTrackInConeOtherBCPileUpSPD = new TH2F("hPtTrackInConeOtherBCPileUpSPD",
9a97f32f 2734 Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC!=0, pile-up from SPD",r),
72433939 2735 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 2736 fhPtTrackInConeOtherBCPileUpSPD->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 2737 fhPtTrackInConeOtherBCPileUpSPD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
fedea415 2738 outputContainer->Add(fhPtTrackInConeOtherBCPileUpSPD) ;
72433939 2739
2a9171b5 2740 fhPtTrackInConeBC0 = new TH2F("hPtTrackInConeBC0",
9a97f32f 2741 Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC==0",r),
72433939 2742 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 2743 fhPtTrackInConeBC0->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 2744 fhPtTrackInConeBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2a9171b5 2745 outputContainer->Add(fhPtTrackInConeBC0) ;
2746
cc944149 2747 fhPtTrackInConeVtxBC0 = new TH2F("hPtTrackInConeVtxBC0",
9a97f32f 2748 Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC==0",r),
72433939 2749 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 2750 fhPtTrackInConeVtxBC0->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 2751 fhPtTrackInConeVtxBC0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
cc944149 2752 outputContainer->Add(fhPtTrackInConeVtxBC0) ;
72433939 2753
cc944149 2754
2a9171b5 2755 fhPtTrackInConeBC0PileUpSPD = new TH2F("hPtTrackInConeBC0PileUpSPD",
9a97f32f 2756 Form("#it{p}_{T} of tracks in isolation cone for #it{R} = %2.2f, TOF from BC==0, pile-up from SPD",r),
72433939 2757 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 2758 fhPtTrackInConeBC0PileUpSPD->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 2759 fhPtTrackInConeBC0PileUpSPD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2a9171b5 2760 outputContainer->Add(fhPtTrackInConeBC0PileUpSPD) ;
72433939 2761
fedea415 2762
17af6e24 2763 for (Int_t i = 0; i < 7 ; i++)
2764 {
2765 fhPtInConePileUp[i] = new TH2F(Form("hPtInConePileUp%s",pileUpName[i].Data()),
9a97f32f 2766 Form("#it{p}_{T} in isolation cone for #it{R} = %2.2f, from pile-up (%s)",r,pileUpName[i].Data()),
17af6e24 2767 nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
9a97f32f 2768 fhPtInConePileUp[i]->SetYTitle("#it{p}_{T in cone} (GeV/#it{c})");
dc9c6e78 2769 fhPtInConePileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
17af6e24 2770 outputContainer->Add(fhPtInConePileUp[i]) ;
2771 }
6c80c1bf 2772 }
2773
b5dbb99b 2774 if(IsDataMC())
2775 {
124bffb3 2776 // For histograms in arrays, index in the array, corresponding to any particle origin
6ae3345d 2777
bf8a7dac 2778 for(Int_t i = 0; i < 6; i++)
dc9c6e78 2779 {
2780 fhEPrimMC[i] = new TH1F(Form("hEPrim_MC%s",ppname[i].Data()),
7726e3a3 2781 Form("primary photon %s : #it{E}, %s",pptype[i].Data(),parTitle.Data()),
dc9c6e78 2782 nptbins,ptmin,ptmax);
2783 fhEPrimMC[i]->SetXTitle("#it{E} (GeV)");
2784 outputContainer->Add(fhEPrimMC[i]) ;
2785
2786 fhPtPrimMCiso[i] = new TH1F(Form("hPtPrim_MCiso%s",ppname[i].Data()),
7726e3a3 2787 Form("primary isolated photon %s : #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
dc9c6e78 2788 nptbins,ptmin,ptmax);
2789 fhPtPrimMCiso[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2790 outputContainer->Add(fhPtPrimMCiso[i]) ;
2791
2792 fhEtaPrimMC[i] = new TH2F(Form("hEtaPrim_MC%s",ppname[i].Data()),
7726e3a3 2793 Form("primary photon %s : #eta vs #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
dc9c6e78 2794 nptbins,ptmin,ptmax,200,-2,2);
2795 fhEtaPrimMC[i]->SetYTitle("#eta");
2796 fhEtaPrimMC[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2797 outputContainer->Add(fhEtaPrimMC[i]) ;
db4ffddf 2798
2799 fhPhiPrimMC[i] = new TH2F(Form("hPhiPrim_MC%s",ppname[i].Data()),
7726e3a3 2800 Form("primary photon %s : #phi vs #it{p}_{T}, %s",pptype[i].Data(),parTitle.Data()),
db4ffddf 2801 nptbins,ptmin,ptmax,200,0.,TMath::TwoPi());
2802 fhPhiPrimMC[i]->SetYTitle("#phi");
2803 fhPhiPrimMC[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2804 outputContainer->Add(fhPhiPrimMC[i]) ;
dc9c6e78 2805 }
1a31a9ab 2806
1a31a9ab 2807 }//Histos with MC
2808
2809 }
2810
b5dbb99b 2811 if(fMakeSeveralIC)
2812 {
1a31a9ab 2813 const Int_t buffersize = 255;
e4ef72be 2814 char name[buffersize];
2815 char title[buffersize];
2816 for(Int_t icone = 0; icone<fNCones; icone++)
6ae3345d 2817 {
44e48e82 2818 // sum pt in cone vs. pt leading
2819 snprintf(name, buffersize,"hSumPtLeadingPt_Cone_%d",icone);
9a97f32f 2820 snprintf(title, buffersize,"#Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",fConeSizes[icone]);
44e48e82 2821 fhSumPtLeadingPt[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
dc9c6e78 2822 fhSumPtLeadingPt[icone] ->SetYTitle("#sum_{cone}#it{p}_{T} (GeV/#it{c})");//#Sigma #it{p}_{T}
2823 fhSumPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
44e48e82 2824 outputContainer->Add(fhSumPtLeadingPt[icone]) ;
6ae3345d 2825
2826 // pt in cone vs. pt leading
44e48e82 2827 snprintf(name, buffersize,"hPtLeadingPt_Cone_%d",icone);
9a97f32f 2828 snprintf(title, buffersize,"#it{p}_{T} in isolation cone for #it{R} = %2.2f",fConeSizes[icone]);
6ae3345d 2829 fhPtLeadingPt[icone] = new TH2F(name, title, nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
dc9c6e78 2830 fhPtLeadingPt[icone] ->SetYTitle("#it{p}_{T}^{cone} (GeV/#it{c})");
2831 fhPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
6ae3345d 2832 outputContainer->Add(fhPtLeadingPt[icone]) ;
2833
2834 // sum pt in cone vs. pt leading in the forward region (for background subtraction studies)
2835 snprintf(name, buffersize,"hPerpSumPtLeadingPt_Cone_%d",icone);
9a97f32f 2836 snprintf(title, buffersize,"#Sigma #it{p}_{T} in isolation cone for #it{R} = %2.2f",fConeSizes[icone]);
23130491 2837 fhPerpSumPtLeadingPt[icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
dc9c6e78 2838 fhPerpSumPtLeadingPt[icone] ->SetYTitle("#sum_{cone}#it{p}_{T} (GeV/#it{c})");//#Sigma #it{p}_{T}
2839 fhPerpSumPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
23130491 2840 outputContainer->Add(fhPerpSumPtLeadingPt[icone]) ;
44e48e82 2841
6ae3345d 2842 // pt in cone vs. pt leading in the forward region (for background subtraction studies)
2843 snprintf(name, buffersize,"hPerpPtLeadingPt_Cone_%d",icone);
9a97f32f 2844 snprintf(title, buffersize,"#it{p}_{T} in isolation cone for #it{R} = %2.2f",fConeSizes[icone]);
6ae3345d 2845 fhPerpPtLeadingPt[icone] = new TH2F(name, title, nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
dc9c6e78 2846 fhPerpPtLeadingPt[icone] ->SetYTitle("#it{p}_{T}^{cone} (GeV/#it{c})");
2847 fhPerpPtLeadingPt[icone] ->SetXTitle("#it{p}_{T}^{leading} (GeV/#it{c})");
6ae3345d 2848 outputContainer->Add(fhPerpPtLeadingPt[icone]) ;
2849
e4ef72be 2850 if(IsDataMC())
db6fb352 2851 {
124bffb3 2852 for(Int_t imc = 0; imc < 9; imc++)
2853 {
f5b702a0 2854 snprintf(name , buffersize,"hSumPtLeadingPt_MC%s_Cone_%d",mcPartName[imc].Data(),icone);
124bffb3 2855 snprintf(title, buffersize,"Candidate %s #it{p}_{T} vs cone #Sigma #it{p}_{T} for #it{R}=%2.2f",mcPartType[imc].Data(),fConeSizes[icone]);
f5b702a0 2856 fhSumPtLeadingPtMC[imc][icone] = new TH2F(name, title,nptbins,ptmin,ptmax,nptsumbins,ptsummin,ptsummax);
2857 fhSumPtLeadingPtMC[imc][icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
2858 fhSumPtLeadingPtMC[imc][icone]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
2859 outputContainer->Add(fhSumPtLeadingPtMC[imc][icone]) ;
124bffb3 2860 }
e4ef72be 2861 }//Histos with MC
2862
2863 for(Int_t ipt = 0; ipt<fNPtThresFrac;ipt++)
124bffb3 2864 {
b0a31c92 2865 snprintf(name, buffersize,"hPtThres_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2866 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]);
b0a31c92 2867 fhPtThresIsolated[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
dc9c6e78 2868 fhPtThresIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
6ae3345d 2869 outputContainer->Add(fhPtThresIsolated[icone][ipt]) ;
b0a31c92 2870
2871 snprintf(name, buffersize,"hPtFrac_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2872 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]);
b0a31c92 2873 fhPtFracIsolated[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
dc9c6e78 2874 fhPtFracIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
6ae3345d 2875 outputContainer->Add(fhPtFracIsolated[icone][ipt]) ;
b0a31c92 2876
f5b702a0 2877 snprintf(name, buffersize,"hSumPt_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2878 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]);
f5b702a0 2879 fhSumPtIsolated[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
2880 // fhSumPtIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
2881 fhSumPtIsolated[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2882 outputContainer->Add(fhSumPtIsolated[icone][ipt]) ;
b0a31c92 2883
2884 snprintf(name, buffersize,"hPtSumDensity_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2885 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]);
b0a31c92 2886 fhPtSumDensityIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
dc9c6e78 2887 //fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
2888 fhPtSumDensityIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
b0a31c92 2889 outputContainer->Add(fhPtSumDensityIso[icone][ipt]) ;
2890
2891 snprintf(name, buffersize,"hPtFracPtSum_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2892 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]);
b0a31c92 2893 fhPtFracPtSumIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
dc9c6e78 2894 //fhPtSumIsolated[icone][ipt]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
2895 fhPtFracPtSumIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
b0a31c92 2896 outputContainer->Add(fhPtFracPtSumIso[icone][ipt]) ;
2897
b0a31c92 2898 // eta:phi
2899 snprintf(name, buffersize,"hEtaPhiPtThres_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2900 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]);
b0a31c92 2901 fhEtaPhiPtThresIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2902 fhEtaPhiPtThresIso[icone][ipt]->SetXTitle("#eta");
2903 fhEtaPhiPtThresIso[icone][ipt]->SetYTitle("#phi");
2904 outputContainer->Add(fhEtaPhiPtThresIso[icone][ipt]) ;
2905
2906 snprintf(name, buffersize,"hEtaPhiPtFrac_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2907 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]);
b0a31c92 2908 fhEtaPhiPtFracIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2909 fhEtaPhiPtFracIso[icone][ipt]->SetXTitle("#eta");
2910 fhEtaPhiPtFracIso[icone][ipt]->SetYTitle("#phi");
2911 outputContainer->Add(fhEtaPhiPtFracIso[icone][ipt]) ;
2912
2913 snprintf(name, buffersize,"hEtaPhiPtSum_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2914 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]);
b0a31c92 2915 fhEtaPhiPtSumIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2916 fhEtaPhiPtSumIso[icone][ipt]->SetXTitle("#eta");
2917 fhEtaPhiPtSumIso[icone][ipt]->SetYTitle("#phi");
2918 outputContainer->Add(fhEtaPhiPtSumIso[icone][ipt]) ;
2919
2920 snprintf(name, buffersize,"hEtaPhiSumDensity_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2921 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]);
b0a31c92 2922 fhEtaPhiSumDensityIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2923 fhEtaPhiSumDensityIso[icone][ipt]->SetXTitle("#eta");
2924 fhEtaPhiSumDensityIso[icone][ipt]->SetYTitle("#phi");
2925 outputContainer->Add(fhEtaPhiSumDensityIso[icone][ipt]) ;
2926
2927 snprintf(name, buffersize,"hEtaPhiFracPtSum_Cone_%d_Pt%d",icone,ipt);
9a97f32f 2928 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]);
b0a31c92 2929 fhEtaPhiFracPtSumIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2930 fhEtaPhiFracPtSumIso[icone][ipt]->SetXTitle("#eta");
2931 fhEtaPhiFracPtSumIso[icone][ipt]->SetYTitle("#phi");
2932 outputContainer->Add(fhEtaPhiFracPtSumIso[icone][ipt]) ;
2933
be703b18 2934 if(fFillTaggedDecayHistograms)
2935 {
2936 // pt decays isolated
2937 snprintf(name, buffersize,"hPtThres_Decay_Cone_%d_Pt%d",icone,ipt);
2938 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]);
2939 fhPtPtThresDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
2940 fhPtPtThresDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2941 outputContainer->Add(fhPtPtThresDecayIso[icone][ipt]) ;
2942
2943 snprintf(name, buffersize,"hPtFrac_Decay_Cone_%d_Pt%d",icone,ipt);
2944 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]);
2945 fhPtPtFracDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
2946 fhPtPtFracDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2947 outputContainer->Add(fhPtPtFracDecayIso[icone][ipt]) ;
2948
2949 snprintf(name, buffersize,"hPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
2950 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]);
2951 fhPtPtSumDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
2952 // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
2953 fhPtPtSumDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2954 outputContainer->Add(fhPtPtSumDecayIso[icone][ipt]) ;
2955
2956 snprintf(name, buffersize,"hPtSumDensity_Decay_Cone_%d_Pt%d",icone,ipt);
2957 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]);
2958 fhPtSumDensityDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
2959 // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
2960 fhPtSumDensityDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2961 outputContainer->Add(fhPtSumDensityDecayIso[icone][ipt]) ;
2962
2963 snprintf(name, buffersize,"hPtFracPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
2964 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]);
2965 fhPtFracPtSumDecayIso[icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);//,nptsumbins,ptsummin,ptsummax);
2966 // fhPtPtSumDecayIso[icone]->SetYTitle("#Sigma #it{p}_{T} (GeV/#it{c})");
2967 fhPtFracPtSumDecayIso[icone][ipt]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2968 outputContainer->Add(fhPtFracPtSumDecayIso[icone][ipt]) ;
2969
2970 // eta:phi decays
2971 snprintf(name, buffersize,"hEtaPhiPtThres_Decay_Cone_%d_Pt%d",icone,ipt);
2972 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]);
2973 fhEtaPhiPtThresDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2974 fhEtaPhiPtThresDecayIso[icone][ipt]->SetXTitle("#eta");
2975 fhEtaPhiPtThresDecayIso[icone][ipt]->SetYTitle("#phi");
2976 outputContainer->Add(fhEtaPhiPtThresDecayIso[icone][ipt]) ;
2977
2978 snprintf(name, buffersize,"hEtaPhiPtFrac_Decay_Cone_%d_Pt%d",icone,ipt);
2979 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]);
2980 fhEtaPhiPtFracDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2981 fhEtaPhiPtFracDecayIso[icone][ipt]->SetXTitle("#eta");
2982 fhEtaPhiPtFracDecayIso[icone][ipt]->SetYTitle("#phi");
2983 outputContainer->Add(fhEtaPhiPtFracDecayIso[icone][ipt]) ;
2984
2985
2986 snprintf(name, buffersize,"hEtaPhiPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
2987 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]);
2988 fhEtaPhiPtSumDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2989 fhEtaPhiPtSumDecayIso[icone][ipt]->SetXTitle("#eta");
2990 fhEtaPhiPtSumDecayIso[icone][ipt]->SetYTitle("#phi");
2991 outputContainer->Add(fhEtaPhiPtSumDecayIso[icone][ipt]) ;
2992
2993 snprintf(name, buffersize,"hEtaPhiSumDensity_Decay_Cone_%d_Pt%d",icone,ipt);
2994 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]);
2995 fhEtaPhiSumDensityDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
2996 fhEtaPhiSumDensityDecayIso[icone][ipt]->SetXTitle("#eta");
2997 fhEtaPhiSumDensityDecayIso[icone][ipt]->SetYTitle("#phi");
2998 outputContainer->Add(fhEtaPhiSumDensityDecayIso[icone][ipt]) ;
2999
3000 snprintf(name, buffersize,"hEtaPhiFracPtSum_Decay_Cone_%d_Pt%d",icone,ipt);
3001 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]);
3002 fhEtaPhiFracPtSumDecayIso[icone][ipt] = new TH2F(name, title,netabins,etamin,etamax,nphibins,phimin,phimax);
3003 fhEtaPhiFracPtSumDecayIso[icone][ipt]->SetXTitle("#eta");
3004 fhEtaPhiFracPtSumDecayIso[icone][ipt]->SetYTitle("#phi");
3005 outputContainer->Add(fhEtaPhiFracPtSumDecayIso[icone][ipt]) ;
6ae3345d 3006
be703b18 3007 }
b0a31c92 3008
3009 if(IsDataMC())
3010 {
124bffb3 3011 for(Int_t imc = 0; imc < 9; imc++)
3012 {
3013 snprintf(name , buffersize,"hPtThreshMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
3014 snprintf(title, buffersize,"Isolated %s #it{p}_{T} for #it{R}=%2.2f and #it{p}_{T}^{th}=%2.2f",
3015 mcPartType[imc].Data(),fConeSizes[icone], fPtThresholds[ipt]);
3016 fhPtThresIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
3017 fhPtThresIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
3018 fhPtThresIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
3019 outputContainer->Add(fhPtThresIsolatedMC[imc][icone][ipt]) ;
3020
3021
3022 snprintf(name , buffersize,"hPtFracMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
3023 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",
3024 mcPartType[imc].Data(),fConeSizes[icone], fPtFractions[ipt]);
3025 fhPtFracIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
3026 fhPtFracIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
3027 fhPtFracIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
3028 outputContainer->Add(fhPtFracIsolatedMC[imc][icone][ipt]) ;
f5b702a0 3029
3030 snprintf(name , buffersize,"hSumPtMC%s_Cone_%d_Pt%d",mcPartName[imc].Data(),icone,ipt);
3031 snprintf(title, buffersize,"Isolated %s #it{p}_{T} for #it{R}=%2.2f and #Sigma #it{p}_{T}^{in cone}=%2.2f",
3032 mcPartType[imc].Data(),fConeSizes[icone], fSumPtThresholds[ipt]);
3033 fhSumPtIsolatedMC[imc][icone][ipt] = new TH1F(name, title,nptbins,ptmin,ptmax);
3034 fhSumPtIsolatedMC[imc][icone][ipt]->SetYTitle("#it{counts}");
3035 fhSumPtIsolatedMC[imc][icone][ipt]->SetXTitle("#it{p}_{T}(GeV/#it{c})");
3036 outputContainer->Add(fhSumPtIsolatedMC[imc][icone][ipt]) ;
124bffb3 3037 }
e4ef72be 3038 }//Histos with MC
3039 }//icone loop
3040 }//ipt loop
1a31a9ab 3041 }
3042
2ad19c3d 3043 if(fFillPileUpHistograms)
3044 {
17af6e24 3045 for (Int_t i = 0; i < 7 ; i++)
3046 {
3047 fhEIsoPileUp[i] = new TH1F(Form("hEPileUp%s",pileUpName[i].Data()),
6ae3345d 3048 Form("Number of isolated particles vs E, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
3049 nptbins,ptmin,ptmax);
03b86424 3050 fhEIsoPileUp[i]->SetYTitle("d#it{N} / d#it{E}");
dc9c6e78 3051 fhEIsoPileUp[i]->SetXTitle("#it{E} (GeV)");
6ae3345d 3052 outputContainer->Add(fhEIsoPileUp[i]) ;
17af6e24 3053
3054 fhPtIsoPileUp[i] = new TH1F(Form("hPtPileUp%s",pileUpName[i].Data()),
6ae3345d 3055 Form("Number of isolated particles vs #it{p}_{T}, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
3056 nptbins,ptmin,ptmax);
03b86424 3057 fhPtIsoPileUp[i]->SetYTitle("d#it{N} / #it{p}_{T}");
dc9c6e78 3058 fhPtIsoPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
6ae3345d 3059 outputContainer->Add(fhPtIsoPileUp[i]) ;
17af6e24 3060
3061 fhENoIsoPileUp[i] = new TH1F(Form("hENoIsoPileUp%s",pileUpName[i].Data()),
6ae3345d 3062 Form("Number of not isolated particles vs E, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
3063 nptbins,ptmin,ptmax);
03b86424 3064 fhENoIsoPileUp[i]->SetYTitle("d#it{N} / dE");
dc9c6e78 3065 fhENoIsoPileUp[i]->SetXTitle("#it{E} (GeV)");
6ae3345d 3066 outputContainer->Add(fhENoIsoPileUp[i]) ;
17af6e24 3067
3068 fhPtNoIsoPileUp[i] = new TH1F(Form("hPtNoIsoPileUp%s",pileUpName[i].Data()),
6ae3345d 3069 Form("Number of not isolated particles vs #it{p}_{T}, %s, pile-up event by %s",parTitle.Data(),pileUpName[i].Data()),
3070 nptbins,ptmin,ptmax);
03b86424 3071 fhPtNoIsoPileUp[i]->SetYTitle("d#it{N} / #it{p}_{T}");
dc9c6e78 3072 fhPtNoIsoPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
6ae3345d 3073 outputContainer->Add(fhPtNoIsoPileUp[i]) ;
17af6e24 3074 }
b1f720a7 3075
6ae3345d 3076 fhTimeENoCut = new TH2F ("hTimeE_NoCut","time of cluster vs E of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
dc9c6e78 3077 fhTimeENoCut->SetXTitle("#it{E} (GeV)");
03b86424 3078 fhTimeENoCut->SetYTitle("#it{time} (ns)");
6ae3345d 3079 outputContainer->Add(fhTimeENoCut);
2ad19c3d 3080
6ae3345d 3081 fhTimeESPD = new TH2F ("hTimeE_SPD","time of cluster vs E of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
dc9c6e78 3082 fhTimeESPD->SetXTitle("#it{E} (GeV)");
03b86424 3083 fhTimeESPD->SetYTitle("#it{time} (ns)");
6ae3345d 3084 outputContainer->Add(fhTimeESPD);
2ad19c3d 3085
6ae3345d 3086 fhTimeESPDMulti = new TH2F ("hTimeE_SPDMulti","time of cluster vs E of clusters, SPD multi cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
dc9c6e78 3087 fhTimeESPDMulti->SetXTitle("#it{E} (GeV)");
03b86424 3088 fhTimeESPDMulti->SetYTitle("#it{time} (ns)");
6ae3345d 3089 outputContainer->Add(fhTimeESPDMulti);
2ad19c3d 3090
6ae3345d 3091 fhTimeNPileUpVertSPD = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
2ad19c3d 3092 fhTimeNPileUpVertSPD->SetYTitle("# vertex ");
03b86424 3093 fhTimeNPileUpVertSPD->SetXTitle("#it{time} (ns)");
6ae3345d 3094 outputContainer->Add(fhTimeNPileUpVertSPD);
2ad19c3d 3095
6ae3345d 3096 fhTimeNPileUpVertTrack = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 50,0,50 );
2ad19c3d 3097 fhTimeNPileUpVertTrack->SetYTitle("# vertex ");
03b86424 3098 fhTimeNPileUpVertTrack->SetXTitle("#it{time} (ns)");
6ae3345d 3099 outputContainer->Add(fhTimeNPileUpVertTrack);
2ad19c3d 3100
6ae3345d 3101 fhTimeNPileUpVertContributors = new TH2F ("hTime_NPileUpVertContributors","time of cluster vs N constributors to pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
2ad19c3d 3102 fhTimeNPileUpVertContributors->SetYTitle("# vertex ");
03b86424 3103 fhTimeNPileUpVertContributors->SetXTitle("#it{time} (ns)");
6ae3345d 3104 outputContainer->Add(fhTimeNPileUpVertContributors);
2ad19c3d 3105
6ae3345d 3106 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);
03b86424 3107 fhTimePileUpMainVertexZDistance->SetYTitle("distance #it{z} (cm) ");
3108 fhTimePileUpMainVertexZDistance->SetXTitle("#it{time} (ns)");
6ae3345d 3109 outputContainer->Add(fhTimePileUpMainVertexZDistance);
2ad19c3d 3110
6ae3345d 3111 fhTimePileUpMainVertexZDiamond = new TH2F ("hTime_PileUpMainVertexZDiamond","time of cluster vs distance in Z pile-up SPD vertex - z diamond",ntimebins,timemin,timemax,100,0,50);
03b86424 3112 fhTimePileUpMainVertexZDiamond->SetYTitle("diamond distance #it{z} (cm) ");
3113 fhTimePileUpMainVertexZDiamond->SetXTitle("#it{time} (ns)");
6ae3345d 3114 outputContainer->Add(fhTimePileUpMainVertexZDiamond);
2ad19c3d 3115 }
3116
1a31a9ab 3117 return outputContainer ;
3118
3119}
3120
124bffb3 3121//____________________________________________________
3122Int_t AliAnaParticleIsolation::GetMCIndex(Int_t mcTag)
3123{
6ae3345d 3124 // Histogram index depending on origin of candidate
124bffb3 3125
3126 if(!IsDataMC()) return -1;
3127
3128 if (GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPrompt))
3129 {
3130 return kmcPrompt;
3131 }
dc1966bb 3132 else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCFragmentation) ||
3133 GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCISR))
124bffb3 3134 {
3135 return kmcFragment;
3136 }
3137 else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0))
3138 {
3139 return kmcPi0;
3140 }
3141 else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0Decay))
3142 {
3143 return kmcPi0Decay;
3144 }
3145 else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEtaDecay))
3146 {
3147 return kmcEtaDecay;
3148 }
3149 else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCOtherDecay))
3150 {
3151 return kmcOtherDecay;
3152 }
3153 else if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron))
3154 {
3155 return kmcElectron;
3156 }
3157 else // anything else
3158 {
bf8a7dac 3159 // careful can contain also other decays, to be checked.
124bffb3 3160 return kmcHadron;
3161 }
3162}
3163
03bae431 3164//__________________________________
3165void AliAnaParticleIsolation::Init()
3166{
3167 // Do some checks and init stuff
3168
124bffb3 3169 // In case of several cone and thresholds analysis, open the cuts for the filling of the
6ae3345d 3170 // track and cluster reference arrays in cone when done in the MakeAnalysisFillAOD().
03bae431 3171 // The different cones, thresholds are tested for this list of tracks, clusters.
3172 if(fMakeSeveralIC)
3173 {
3174 printf("AliAnaParticleIsolation::Init() - Open default isolation cuts for multiple Isolation analysis\n");
3175 GetIsolationCut()->SetPtThreshold(100);
3176 GetIsolationCut()->SetPtFraction(100);
3177 GetIsolationCut()->SetConeSize(1);
3178 }
373ffbac 3179
3180 if(!GetReader()->IsCTSSwitchedOn() && GetIsolationCut()->GetParticleTypeInCone()!=AliIsolationCut::kOnlyNeutral)
3181 AliFatal("STOP!: You want to use CTS tracks in analysis but not read!! \n!!Check the configuration file!!\n");
3182
03bae431 3183}
3184
803d06a8 3185//____________________________________________
3186void AliAnaParticleIsolation::InitParameters()
3187{
3188
3189 //Initialize the parameters of the analysis.
3190 SetInputAODName("PWG4Particle");
6ae3345d 3191 SetAODObjArrayName("IsolationCone");
803d06a8 3192 AddToHistogramsName("AnaIsolation_");
3193
4b6cb0f2 3194 fCalorimeter = "EMCAL" ;
3195 fIsoDetector = "EMCAL" ;
3196
803d06a8 3197 fReMakeIC = kFALSE ;
3198 fMakeSeveralIC = kFALSE ;
3199
64373095 3200 fLeadingOnly = kTRUE;
3201 fCheckLeadingWithNeutralClusters = kTRUE;
3202
8913c8c4 3203 fNDecayBits = 1;
3204 fDecayBits[0] = AliNeutralMesonSelection::kPi0;
3205 fDecayBits[1] = AliNeutralMesonSelection::kEta;
3206 fDecayBits[2] = AliNeutralMesonSelection::kPi0Side;
3207 fDecayBits[3] = AliNeutralMesonSelection::kEtaSide;
3208
dc1966bb 3209 fNBkgBin = 11;
3210 fBkgBinLimit[ 0] = 00.0; fBkgBinLimit[ 1] = 00.2; fBkgBinLimit[ 2] = 00.3; fBkgBinLimit[ 3] = 00.4; fBkgBinLimit[ 4] = 00.5;
3211 fBkgBinLimit[ 5] = 01.0; fBkgBinLimit[ 6] = 01.5; fBkgBinLimit[ 7] = 02.0; fBkgBinLimit[ 8] = 03.0; fBkgBinLimit[ 9] = 05.0;
3212 fBkgBinLimit[10] = 10.0; fBkgBinLimit[11] = 100.;
3213 for(Int_t ibin = 12; ibin < 20; ibin++) fBkgBinLimit[ibin] = 00.0;
3214
803d06a8 3215 //----------- Several IC-----------------
6ae3345d 3216 fNCones = 5 ;
3217 fNPtThresFrac = 5 ;
db6fb352 3218 fConeSizes [0] = 0.1; fConeSizes [1] = 0.2; fConeSizes [2] = 0.3; fConeSizes [3] = 0.4; fConeSizes [4] = 0.5;
6ae3345d 3219 fPtThresholds [0] = 1.; fPtThresholds [1] = 2.; fPtThresholds [2] = 3.; fPtThresholds [3] = 4.; fPtThresholds [4] = 5.;
3220 fPtFractions [0] = 0.05; fPtFractions [1] = 0.075; fPtFractions [2] = 0.1; fPtFractions [3] = 1.25; fPtFractions [4] = 1.5;
3221 fSumPtThresholds[0] = 1.; fSumPtThresholds[1] = 2.; fSumPtThresholds[2] = 3.; fSumPtThresholds[3] = 4.; fSumPtThresholds[4] = 5.;
803d06a8 3222
803d06a8 3223}
3224
64373095 3225//_________________________________________________________________________________________
3226Bool_t AliAnaParticleIsolation::IsTriggerTheNearSideEventLeadingParticle(Int_t & idLeading)
3227{
3228 // Check if the what of the selected isolation candidates is leading particle in the same hemisphere
3229 // comparing with all the candidates, all the tracks or all the clusters.
3230
3231 Double_t ptTrig = GetMinPt();
3232 Double_t phiTrig = 0 ;
3233 Int_t index =-1 ;
3234 AliAODPWG4ParticleCorrelation* pLeading = 0;
3235
3236 // Loop on stored AOD particles, find leading trigger on the selected list, with at least min pT.
3237
3238 for(Int_t iaod = 0; iaod < GetInputAODBranch()->GetEntriesFast() ; iaod++)
3239 {
3240 AliAODPWG4ParticleCorrelation* particle = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
3241 particle->SetLeadingParticle(kFALSE); // set it later
3242
3243 // Vertex cut in case of mixing
3244 if(GetMixedEvent())
3245 {
3246 Int_t check = CheckMixedEventVertex(particle->GetCaloLabel(0), particle->GetTrackLabel(0));
3247 if(check == 0) continue;
3248 if(check == -1) return kFALSE; // not sure if it is correct.
3249 }
3250
3251 //check if it is low pt trigger particle
3252 if((particle->Pt() < GetIsolationCut()->GetPtThreshold() ||
3253 particle->Pt() < GetIsolationCut()->GetSumPtThreshold()) &&
3254 !fMakeSeveralIC)
3255 {
3256 continue ; //trigger should not come from underlying event
3257 }
3258
3259 // find the leading particles with highest momentum
3260 if (particle->Pt() > ptTrig)
3261 {
3262 ptTrig = particle->Pt() ;
3263 phiTrig = particle->Phi();
3264 index = iaod ;
3265 pLeading = particle ;
3266 }
3267 }// finish search of leading trigger particle on the AOD branch.
3268
3269 if(index < 0) return kFALSE;
3270
3271 idLeading = index;
3272
3273 //printf("AOD leading pT %2.2f, ID %d\n", pLeading->Pt(),pLeading->GetCaloLabel(0));
3274
3275 if(phiTrig < 0 ) phiTrig += TMath::TwoPi();
3276
3277 // Compare if it is the leading of all tracks
3278
3279 TVector3 p3;
3280 for(Int_t ipr = 0;ipr < GetCTSTracks()->GetEntriesFast() ; ipr ++ )
3281 {
3282 AliVTrack * track = (AliVTrack *) (GetCTSTracks()->At(ipr)) ;
3283
3284 if(track->GetID() == pLeading->GetTrackLabel(0) || track->GetID() == pLeading->GetTrackLabel(1) ||
3285 track->GetID() == pLeading->GetTrackLabel(2) || track->GetID() == pLeading->GetTrackLabel(3) ) continue ;
3286
3287 Double_t mom[3] = {track->Px(),track->Py(),track->Pz()};
3288 p3.SetXYZ(mom[0],mom[1],mom[2]);
3289 Float_t pt = p3.Pt();
3290 Float_t phi = p3.Phi() ;
3291 if(phi < 0) phi+=TMath::TwoPi();
3292
3293 //skip this event if near side associated particle pt larger than trigger
3294
7719619a 3295 Float_t deltaPhi = phiTrig-phi;
3296 //
3297 // Calculate deltaPhi shift so that for the particles on the opposite side
3298 // it is defined between 90 and 270 degrees
3299 // Shift [-360,-90] to [0, 270]
3300 // and [270,360] to [-90,0]
3301 if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
3302 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
3303
3304 if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE;
3305
64373095 3306 }// track loop
3307
3308 // Compare if it is leading of all calorimeter clusters
3309
3310 if(fCheckLeadingWithNeutralClusters)
3311 {
3312 // Select the calorimeter cluster list
3313 TObjArray * nePl = 0x0;
3314 if (pLeading->GetDetector() == "PHOS" )
3315 nePl = GetPHOSClusters();
3316 else
3317 nePl = GetEMCALClusters();
3318
3319 if(!nePl) return kTRUE; // Do the selection just with the tracks if no calorimeter is available.
3320
3321 TLorentzVector lv;
3322 for(Int_t ipr = 0;ipr < nePl->GetEntriesFast() ; ipr ++ )
3323 {
3324 AliVCluster * cluster = (AliVCluster *) (nePl->At(ipr)) ;
3325
3326 if(cluster->GetID() == pLeading->GetCaloLabel(0) || cluster->GetID() == pLeading->GetCaloLabel(1) ) continue ;
3327
3328 cluster->GetMomentum(lv,GetVertex(0));
3329
3330 Float_t pt = lv.Pt();
3331 Float_t phi = lv.Phi() ;
3332 if(phi < 0) phi+=TMath::TwoPi();
3333
3334 if(IsTrackMatched(cluster,GetReader()->GetInputEvent())) continue ; // avoid charged clusters, already covered by tracks, or cluster merging with track.
3335
3336 // skip this event if near side associated particle pt larger than trigger
3337 // not really needed for calorimeter, unless DCal is included
3338
7719619a 3339 Float_t deltaPhi = phiTrig-phi;
3340 if(deltaPhi <= -TMath::PiOver2()) deltaPhi+=TMath::TwoPi();
3341 if(deltaPhi > 3*TMath::PiOver2()) deltaPhi-=TMath::TwoPi();
3342
3343 if(pt > ptTrig && deltaPhi < TMath::PiOver2()) return kFALSE ;
64373095 3344
3345 }// cluster loop
3346 } // check neutral clusters
3347
3348 idLeading = index ;
3349 pLeading->SetLeadingParticle(kTRUE);
3350
3351 if( GetDebug() > 1 )
3352 printf("AliAnaParticleIsolation::IsTriggerTheNearSideEventLeadingParticle() - Particle AOD with index %d is leading with pT %2.2f\n",
3353 idLeading, pLeading->Pt());
3354
3355 return kTRUE;
3356
3357}
3358
803d06a8 3359//__________________________________________________
6ae3345d 3360void AliAnaParticleIsolation::MakeAnalysisFillAOD()
1a31a9ab 3361{
64373095 3362 // Do analysis and fill aods
3363 // Search for the isolated photon in fCalorimeter with GetMinPt() < pt < GetMaxPt()
3364 // and if the particle is leading in the near side (if requested)
1a31a9ab 3365
b5dbb99b 3366 if(!GetInputAODBranch())
373ffbac 3367 AliFatal(Form("No input particles in AOD with name branch < %s >, STOP",GetInputAODName().Data()));
3368
b5dbb99b 3369 if(strcmp(GetInputAODBranch()->GetClass()->GetName(), "AliAODPWG4ParticleCorrelation"))
373ffbac 3370 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()));
b0a31c92 3371
1a31a9ab 3372 Int_t n = 0, nfrac = 0;
3373 Bool_t isolated = kFALSE ;
3c12e375 3374 Float_t coneptsum = 0, coneptlead = 0;
6ae3345d 3375 TObjArray * pl = 0x0; ;
1a31a9ab 3376
3377 //Select the calorimeter for candidate isolation with neutral particles
b5dbb99b 3378 if (fCalorimeter == "PHOS" )
1a31a9ab 3379 pl = GetPHOSClusters();
3380 else if (fCalorimeter == "EMCAL")
3381 pl = GetEMCALClusters();
3382
3383 //Loop on AOD branch, filled previously in AliAnaPhoton, find leading particle to do isolation only with it
1a31a9ab 3384 TLorentzVector mom ;
64373095 3385 Int_t idLeading = -1 ;
3386 Int_t iaod0 = 0;
3387 Int_t naod = GetInputAODBranch()->GetEntriesFast();
3388
be703b18 3389 if(GetDebug() > 0)
3390 printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - Input aod branch entries %d\n", naod);
1a31a9ab 3391
64373095 3392 if(IsLeadingOnlyOn())
3393 {
3394 Bool_t leading = IsTriggerTheNearSideEventLeadingParticle(idLeading);
3395 if(!leading)
3396 {
3397 if(GetDebug() > 1) printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - Not leading; End fill AODs \n");
3398 return;
3399 }
3400 iaod0 = idLeading ; // first entry in particle loop
3401 naod = idLeading+1; // last entry in particle loop
3402 }
3403
3404 // Check isolation of list of candidate particles or leading particle
3405
3406 for(Int_t iaod = iaod0; iaod < naod; iaod++)
b5dbb99b 3407 {
1a31a9ab 3408 AliAODPWG4ParticleCorrelation * aodinput = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
6ae3345d 3409
64373095 3410 // Check isolation only of clusters in fiducial region
3411 if(IsFiducialCutOn())
3412 {
3413 Bool_t in = GetFiducialCut()->IsInFiducialCut(*aodinput->Momentum(),aodinput->GetDetector()) ;
3414 if(! in ) return ;
3415 }
1a31a9ab 3416
64373095 3417 //If too small or too large pt, skip
3418 Float_t pt = aodinput->Pt();
3419 if(pt < GetMinPt() || pt > GetMaxPt() ) continue ;
3420
03bae431 3421 //check if it is low pt trigger particle
64373095 3422 if( ( pt < GetIsolationCut()->GetPtThreshold() || pt < GetIsolationCut()->GetSumPtThreshold() ) &&
03bae431 3423 !fMakeSeveralIC)
b5dbb99b 3424 {
1a31a9ab 3425 continue ; //trigger should not come from underlying event
b5dbb99b 3426 }
1a31a9ab 3427
64373095 3428 //After cuts, study isolation
3c12e375 3429 n=0; nfrac = 0; isolated = kFALSE; coneptsum = 0; coneptlead = 0;
64373095 3430 GetIsolationCut()->MakeIsolationCut(GetCTSTracks(),pl,
3431 GetReader(), GetCaloPID(),
3432 kTRUE, aodinput, GetAODObjArrayName(),
3c12e375 3433 n,nfrac,coneptsum,coneptlead,isolated);
1a31a9ab 3434
64373095 3435 if(!fMakeSeveralIC) aodinput->SetIsolated(isolated);
3436 } // particle isolationloop
6ae3345d 3437
be703b18 3438 if(GetDebug() > 1)
b5dbb99b 3439 {
64373095 3440 if(isolated) printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() : Particle %d IS ISOLATED \n",idLeading);
6ae3345d 3441 printf("AliAnaParticleIsolation::MakeAnalysisFillAOD() - End fill AODs \n");
1a31a9ab 3442 }
3443
3444}
3445
803d06a8 3446//_________________________________________________________
6ae3345d 3447void AliAnaParticleIsolation::MakeAnalysisFillHistograms()
1a31a9ab 3448{
64373095 3449 // Do analysis and fill histograms
6ae3345d 3450
be703b18 3451 // In case of simulated data, fill acceptance histograms
3452 // Not ready for multiple case analysis.
3453 if(IsDataMC() && !fMakeSeveralIC) FillAcceptanceHistograms();
6ae3345d 3454
23130491 3455 //Loop on stored AOD
1a31a9ab 3456 Int_t naod = GetInputAODBranch()->GetEntriesFast();
be703b18 3457 if(GetDebug() > 0)
3458 printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Histo aod branch entries %d\n", naod);
6ae3345d 3459
b5dbb99b 3460 for(Int_t iaod = 0; iaod < naod ; iaod++)
3461 {
1a31a9ab 3462 AliAODPWG4ParticleCorrelation* aod = (AliAODPWG4ParticleCorrelation*) (GetInputAODBranch()->At(iaod));
3463
64373095 3464 if(IsLeadingOnlyOn() && !aod->IsLeadingParticle()) continue; // Try to isolate only leading cluster or track
1a31a9ab 3465
547c2f01 3466 // Check isolation only of clusters in fiducial region
3467 if(IsFiducialCutOn())
3468 {
050ad675 3469 Bool_t in = GetFiducialCut()->IsInFiducialCut(*aod->Momentum(),aod->GetDetector()) ;
547c2f01 3470 if(! in ) continue ;
3471 }
3472
23130491 3473 Float_t pt = aod->Pt();
124bffb3 3474
23130491 3475 //If too small or too large pt, skip
3476 if(pt < GetMinPt() || pt > GetMaxPt() ) continue ;
3477
124bffb3 3478 Int_t mcTag = aod->GetTag() ;
3479 Int_t mcIndex = GetMCIndex(mcTag);
db6fb352 3480
124bffb3 3481 // --- In case of redoing isolation from delta AOD ----
3482 // Not standard case, not used since its implementation
3483 if(fMakeSeveralIC)
03bae431 3484 {
1a31a9ab 3485 //Analysis of multiple IC at same time
124bffb3 3486 MakeSeveralICAnalysis(aod,mcIndex);
03bae431 3487 continue;
1a31a9ab 3488 }
6ae3345d 3489
124bffb3 3490 // --- In case of redoing isolation multiple cuts ----
6ae3345d 3491
124bffb3 3492 if(fReMakeIC)
b5dbb99b 3493 {
1a31a9ab 3494 //In case a more strict IC is needed in the produced AOD
124bffb3 3495 Bool_t isolated = kFALSE;
23130491 3496 Int_t n = 0, nfrac = 0;
3c12e375 3497 Float_t coneptsum = 0, coneptlead = 0;
727a309a 3498
23130491 3499 //Recover reference arrays with clusters and tracks
3500 TObjArray * refclusters = aod->GetObjArray(GetAODObjArrayName()+"Clusters");
3501 TObjArray * reftracks = aod->GetObjArray(GetAODObjArrayName()+"Tracks");
6ae3345d 3502
3503 GetIsolationCut()->MakeIsolationCut(reftracks, refclusters,
ac5111f9 3504 GetReader(), GetCaloPID(),
6ae3345d 3505 kFALSE, aod, "",
3c12e375 3506 n,nfrac,coneptsum,coneptlead,isolated);
1a31a9ab 3507 }
124bffb3 3508
3509 Bool_t isolated = aod->IsIsolated();
124bffb3 3510 Float_t energy = aod->E();
3511 Float_t phi = aod->Phi();
3512 Float_t eta = aod->Eta();
8913c8c4 3513
3514 Int_t decayTag = 0;
3515 if(fFillTaggedDecayHistograms)
3516 {
3517 decayTag = aod->GetBtag(); // temporary
3518 if(decayTag < 0) decayTag = 0; // temporary
3519 }
124bffb3 3520
e54e9250 3521 if(GetDebug() > 0)
3522 printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - pt %1.1f, eta %1.1f, phi %1.1f, Isolated %d\n",
3523 pt, eta, phi, isolated);
124bffb3 3524
124bffb3 3525 //---------------------------------------------------------------
3526 // Fill pt/sum pT distribution of particles in cone or in UE band
3527 //---------------------------------------------------------------
3528
1b1a1b2e 3529 Float_t coneptLeadCluster= 0;
3530 Float_t coneptLeadTrack = 0;
124bffb3 3531 Float_t coneptsumCluster = 0;
3532 Float_t coneptsumTrack = 0;
3533 Float_t coneptsumCell = 0;
3534 Float_t etaBandptsumClusterNorm = 0;
3535 Float_t etaBandptsumTrackNorm = 0;
3536
1b1a1b2e 3537 CalculateTrackSignalInCone (aod,coneptsumTrack , coneptLeadTrack );
3538 CalculateCaloSignalInCone (aod,coneptsumCluster, coneptLeadCluster);
124bffb3 3539 if(fFillCellHistograms)
3540 CalculateCaloCellSignalInCone(aod,coneptsumCell );
3541
3542 if(GetIsolationCut()->GetParticleTypeInCone()==AliIsolationCut::kNeutralAndCharged)
3543 {
dc1966bb 3544 fhConeSumPtClustervsTrack ->Fill(coneptsumCluster, coneptsumTrack );
3545 fhConePtLeadClustervsTrack->Fill(coneptLeadCluster,coneptLeadTrack);
3546
3547 if(coneptsumTrack > 0) fhConeSumPtClusterTrackFrac ->Fill(pt, coneptsumCluster /coneptsumTrack );
3548 if(coneptLeadTrack > 0) fhConePtLeadClusterTrackFrac->Fill(pt, coneptLeadCluster/coneptLeadTrack);
3549
977564f5 3550 if(fFillCellHistograms)
9b01dc66 3551 {
124bffb3 3552 fhConeSumPtCellvsTrack ->Fill(coneptsumCell, coneptsumTrack);
3553 fhConeSumPtCellTrack ->Fill(pt, coneptsumTrack+coneptsumCell);
3554 fhConeSumPtCellTrackTrigEtaPhi->Fill(eta,phi,coneptsumTrack+coneptsumCell);
977564f5 3555 }
1a31a9ab 3556 }
6c80c1bf 3557
124bffb3 3558 fhConeSumPt ->Fill(pt, coneptsumTrack+coneptsumCluster);
3559 fhConeSumPtTrigEtaPhi ->Fill(eta,phi,coneptsumTrack+coneptsumCluster);
3560
dc1966bb 3561 Float_t coneptLead = coneptLeadTrack;
3562 if(coneptLeadCluster > coneptLeadTrack) coneptLead = coneptLeadCluster;
3563 fhConePtLead->Fill(pt, coneptLead );
1b1a1b2e 3564
124bffb3 3565 if(GetDebug() > 1)
dc1966bb 3566 printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d Energy Sum in Isolation Cone %2.2f, Leading pT in cone %2.2f\n",
3567 iaod, coneptsumTrack+coneptsumCluster, coneptLead);
124bffb3 3568
3569 //normalize phi/eta band per area unit
3570 if(fFillUEBandSubtractHistograms)
3571 CalculateNormalizeUEBandPerUnitArea(aod, coneptsumCluster, coneptsumCell, coneptsumTrack, etaBandptsumTrackNorm, etaBandptsumClusterNorm) ;
3572
3573 // printf("Histograms analysis : cluster pt = %f, etaBandTrack = %f, etaBandCluster = %f, isolation = %d\n",aod->Pt(),etaBandptsumTrackNorm,etaBandptsumClusterNorm,aod->IsIsolated());
3574
dc1966bb 3575 //---------------------------------------------------------------
3576 // Fill Shower shape and track matching histograms
3577 //---------------------------------------------------------------
3578
3579 FillTrackMatchingShowerShapeControlHistograms(aod, coneptsumTrack+coneptsumCluster, coneptLead, mcIndex);
124bffb3 3580
3581 //---------------------------------------------------------------
3582 // Isolated/ Non isolated histograms
3583 //---------------------------------------------------------------
3584
23130491 3585 if(isolated)
3586 {
aa2e58e4 3587 if(GetDebug() > 1)
3588 printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d ISOLATED: fill histograms\n", iaod);
2ad19c3d 3589
b5dbb99b 3590 fhEIso ->Fill(energy);
3591 fhPtIso ->Fill(pt);
3592 fhPhiIso ->Fill(pt,phi);
3593 fhEtaIso ->Fill(pt,eta);
0fb69ade 3594 fhEtaPhiIso ->Fill(eta,phi);
c8710850 3595
aa2e58e4 3596 if(IsDataMC())
977564f5 3597 {
aa2e58e4 3598 // For histograms in arrays, index in the array, corresponding to any particle origin
3599 if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
3600 {
3601 fhPtIsoMC [kmcPhoton]->Fill(pt);
3602 fhPhiIsoMC[kmcPhoton]->Fill(pt,phi);
3603 fhEtaIsoMC[kmcPhoton]->Fill(pt,eta);
3604 }
3605
3606 fhPtIsoMC [mcIndex]->Fill(pt);
3607 fhPhiIsoMC[mcIndex]->Fill(pt,phi);
3608 fhEtaIsoMC[mcIndex]->Fill(pt,eta);
3609 }//Histograms with MC
977564f5 3610
aa2e58e4 3611 // Candidates tagged as decay in another analysis (AliAnaPi0EbE)
8913c8c4 3612 if(fFillTaggedDecayHistograms && decayTag > 0)
3f150b4b 3613 {
8913c8c4 3614 for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
aa2e58e4 3615 {
8913c8c4 3616 if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
3617 {
3618 fhPtDecayIso[ibit] ->Fill(pt);
3619 fhEtaPhiDecayIso[ibit]->Fill(eta,phi);
3620
3621 if(IsDataMC())
3622 {
3623 if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
3624 fhPtDecayIsoMC[ibit][kmcPhoton]->Fill(pt);
3625
3626 fhPtDecayIsoMC[ibit][mcIndex]->Fill(pt);
3627 }
3628 } // bit ok
3629 } // bit loop
3630 } // decay histograms
3631
aa2e58e4 3632 if(fFillNLMHistograms)
3633 fhPtNLocMaxIso ->Fill(pt,aod->GetFiducialArea()) ; // remember to change method name
1a31a9ab 3634
aa2e58e4 3635 if(fFillHighMultHistograms)
3636 {
3637 fhPtCentralityIso ->Fill(pt,GetEventCentrality()) ;
3638 fhPtEventPlaneIso ->Fill(pt,GetEventPlaneAngle() ) ;
3639 }
3640
17af6e24 3641 if(fFillPileUpHistograms)
b1f720a7 3642 {
17af6e24 3643 if(GetReader()->IsPileUpFromSPD()) { fhEIsoPileUp[0] ->Fill(energy) ; fhPtIsoPileUp[0]->Fill(pt) ; }
3644 if(GetReader()->IsPileUpFromEMCal()) { fhEIsoPileUp[1] ->Fill(energy) ; fhPtIsoPileUp[1]->Fill(pt) ; }
3645 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhEIsoPileUp[2] ->Fill(energy) ; fhPtIsoPileUp[2]->Fill(pt) ; }
3646 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhEIsoPileUp[3] ->Fill(energy) ; fhPtIsoPileUp[3]->Fill(pt) ; }
3647 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhEIsoPileUp[4] ->Fill(energy) ; fhPtIsoPileUp[4]->Fill(pt) ; }
3648 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhEIsoPileUp[5] ->Fill(energy) ; fhPtIsoPileUp[5]->Fill(pt) ; }
3649 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhEIsoPileUp[6] ->Fill(energy) ; fhPtIsoPileUp[6]->Fill(pt) ; }
124bffb3 3650
aa2e58e4 3651 // Fill histograms to undertand pile-up before other cuts applied
3652 // Remember to relax time cuts in the reader
3653 FillPileUpHistograms(aod->GetCaloLabel(0));
3654 }
3655
1a31a9ab 3656 }//Isolated histograms
ca134929 3657 else // NON isolated
1a31a9ab 3658 {
aa2e58e4 3659 if(GetDebug() > 1)
3660 printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Particle %d NOT ISOLATED, fill histograms\n", iaod);
db6fb352 3661
b1f720a7 3662 fhENoIso ->Fill(energy);
3663 fhPtNoIso ->Fill(pt);
3664 fhEtaPhiNoIso ->Fill(eta,phi);
977564f5 3665
aa2e58e4 3666 if(IsDataMC())
3667 {
3668 if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) )
3669 fhPtNoIsoMC[kmcPhoton]->Fill(pt);
3670
3671 fhPtNoIsoMC[mcIndex]->Fill(pt);
3672 }
3673
3674 // Candidates tagged as decay in another analysis (AliAnaPi0EbE)
8913c8c4 3675 if(fFillTaggedDecayHistograms && decayTag > 0)
aa2e58e4 3676 {
8913c8c4 3677 for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
aa2e58e4 3678 {
8913c8c4 3679 if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
3680 {
3681 fhPtDecayNoIso[ibit] ->Fill(pt);
3682 fhEtaPhiDecayNoIso[ibit]->Fill(eta,phi);
3683
3684 if(IsDataMC())
3685 {
3686 if(GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton))
3687 fhPtDecayNoIsoMC[ibit][kmcPhoton]->Fill(pt);
3688
3689 fhPtDecayNoIsoMC[ibit][mcIndex]->Fill(pt);
3690 }
3691 } // bit ok
3692 } // bit loop
3693 } // decay histograms
aa2e58e4 3694
3695 if(fFillNLMHistograms)
3696 fhPtNLocMaxNoIso ->Fill(pt,aod->GetFiducialArea()); // remember to change method name
23130491 3697
17af6e24 3698 if(fFillPileUpHistograms)
b1f720a7 3699 {
17af6e24 3700 if(GetReader()->IsPileUpFromSPD()) { fhENoIsoPileUp[0] ->Fill(energy) ; fhPtNoIsoPileUp[0]->Fill(pt) ; }
3701 if(GetReader()->IsPileUpFromEMCal()) { fhENoIsoPileUp[1] ->Fill(energy) ; fhPtNoIsoPileUp[1]->Fill(pt) ; }
3702 if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhENoIsoPileUp[2] ->Fill(energy) ; fhPtNoIsoPileUp[2]->Fill(pt) ; }
3703 if(GetReader()->IsPileUpFromSPDAndEMCal()) { fhENoIsoPileUp[3] ->Fill(energy) ; fhPtNoIsoPileUp[3]->Fill(pt) ; }
3704 if(GetReader()->IsPileUpFromSPDAndNotEMCal()) { fhENoIsoPileUp[4] ->Fill(energy) ; fhPtNoIsoPileUp[4]->Fill(pt) ; }
3705 if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhENoIsoPileUp[5] ->Fill(energy) ; fhPtNoIsoPileUp[5]->Fill(pt) ; }
3706 if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhENoIsoPileUp[6] ->Fill(energy) ; fhPtNoIsoPileUp[6]->Fill(pt) ; }
b1f720a7 3707 }
aa2e58e4 3708 } // non iso
1a31a9ab 3709 }// aod loop
aa2e58e4 3710
1a31a9ab 3711}
3712
4b6cb0f2 3713//______________________________________________________________________
dc9c6e78 3714void AliAnaParticleIsolation::FillAcceptanceHistograms()
3715{
4b6cb0f2 3716 // Fill acceptance histograms if MC data is available
3717 // Only when particle is in the calorimeter. Rethink if CTS is used.
dc9c6e78 3718
be703b18 3719 if(GetDebug() > 0) printf("AliAnaParticleIsolation::FillAcceptanceHistograms() - Start \n");
3720
6aac3409 3721 //Double_t photonY = -100 ;
dc9c6e78 3722 Double_t photonE = -1 ;
3723 Double_t photonPt = -1 ;
3724 Double_t photonPhi = 100 ;
3725 Double_t photonEta = -1 ;
3726
3727 Int_t pdg = 0 ;
d2d42179 3728 Int_t status = 0 ;
dc9c6e78 3729 Int_t tag = 0 ;
3730 Int_t mcIndex = 0 ;
d2d42179 3731 Int_t nprim = 0;
3732
3733 TParticle * primStack = 0;
3734 AliAODMCParticle * primAOD = 0;
3735 TLorentzVector lv;
dc9c6e78 3736
d2d42179 3737 // Get the ESD MC particles container
3738 AliStack * stack = 0;
3739 if( GetReader()->ReadStack() )
dc9c6e78 3740 {
d2d42179 3741 stack = GetMCStack();
3742 if(!stack ) return;
3743 nprim = stack->GetNtrack();
3744 }
dc9c6e78 3745
d2d42179 3746 // Get the AOD MC particles container
3747 TClonesArray * mcparticles = 0;
3748 if( GetReader()->ReadAODMCParticles() )
dc9c6e78 3749 {
d2d42179 3750 mcparticles = GetReader()->GetAODMCParticles();
3751 if( !mcparticles ) return;
3752 nprim = mcparticles->GetEntriesFast();
3753 }
3754
3755 for(Int_t i=0 ; i < nprim; i++)
3756 {
3757 if(GetReader()->AcceptOnlyHIJINGLabels() && !GetReader()->IsHIJINGLabel(i)) continue ;
3758
3759 if(GetReader()->ReadStack())
3760 {
3761 primStack = stack->Particle(i) ;
ddaa6315 3762 if(!primStack)
3763 {
3764 printf("AliAnaParticleIsolation::FillAcceptanceHistograms() - ESD primaries pointer not available!!\n");
3765 continue;
3766 }
3767
d2d42179 3768 pdg = primStack->GetPdgCode();
3769 status = primStack->GetStatusCode();
3770
3771 if(primStack->Energy() == TMath::Abs(primStack->Pz())) continue ; //Protection against floating point exception
3772
3773 //printf("i %d, %s %d %s %d \n",i, stack->Particle(i)->GetName(), stack->Particle(i)->GetPdgCode(),
3774 // prim->GetName(), prim->GetPdgCode());
3775
3776 //photonY = 0.5*TMath::Log((prim->Energy()-prim->Pz())/(prim->Energy()+prim->Pz())) ;
3777
3778 //Photon kinematics
3779 primStack->Momentum(lv);
3780
3781 }
3782 else
3783 {
3784 primAOD = (AliAODMCParticle *) mcparticles->At(i);
ddaa6315 3785 if(!primAOD)
3786 {
3787 printf("AliAnaParticleIsolation::FillAcceptanceHistograms() - AOD primaries pointer not available!!\n");
3788 continue;
3789 }
3790
d2d42179 3791 pdg = primAOD->GetPdgCode();
3792 status = primAOD->GetStatus();
3793
3794 if(primAOD->E() == TMath::Abs(primAOD->Pz())) continue ; //Protection against floating point exception
3795
3796 //photonY = 0.5*TMath::Log((prim->Energy()-prim->Pz())/(prim->Energy()+prim->Pz())) ;
3797
3798 //Photon kinematics
3799 lv.SetPxPyPzE(primAOD->Px(),primAOD->Py(),primAOD->Pz(),primAOD->E());
3800 }
3801
3802 // Select only photons in the final state
4b6cb0f2 3803 if(pdg != 22 ) continue ;
d2d42179 3804
4b6cb0f2 3805 // Consider only final state particles, but this depends on generator,
3806 // status 1 is the usual one, in case of not being ok, leave the possibility
3807 // to not consider this.
3808 if(status != 1 && GetMCAnalysisUtils()->GetMCGenerator()!="" ) continue ;
d2d42179 3809
3810 // If too small or too large pt, skip, same cut as for data analysis
3811 photonPt = lv.Pt () ;
3812
3813 if(photonPt < GetMinPt() || photonPt > GetMaxPt() ) continue ;
3814
3815 photonE = lv.E () ;
3816 photonEta = lv.Eta() ;
3817 photonPhi = lv.Phi() ;
3818
3819 if(photonPhi < 0) photonPhi+=TMath::TwoPi();
3820
bf8a7dac 3821 // Check if photons hit the Calorimeter acceptance
4b6cb0f2 3822 if(IsRealCaloAcceptanceOn() && fIsoDetector!="CTS") // defined on base class
3823 {
3824 if(GetReader()->ReadStack() &&
3825 !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(fIsoDetector, primStack)) continue ;
3826 if(GetReader()->ReadAODMCParticles() &&
3827 !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(fIsoDetector, primAOD )) continue ;
3828 }
6ae3345d 3829
4b6cb0f2 3830 // Check same fidutial borders as in data analysis on top of real acceptance if real was requested.
3831 if(!GetFiducialCut()->IsInFiducialCut(lv,fIsoDetector)) continue ;
6ae3345d 3832
d2d42179 3833 // Get tag of this particle photon from fragmentation, decay, prompt ...
3834 // Set the origin of the photon.
3835 tag = GetMCAnalysisUtils()->CheckOrigin(i,GetReader());
3836
3837 if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
3838 {
3839 // A conversion photon from a hadron, skip this kind of photon
3840 // printf("AliAnaPhoton::FillAcceptanceHistograms() - not a photon, weird!\n ");
3841 // GetMCAnalysisUtils()->PrintMCTag(tag);
3842
3843 continue;
3844 }
3845
3846 //
3847 if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) )
3848 {
3849 mcIndex = kmcPrimPrompt;
3850 }
3851 else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation) )
3852 {
3853 mcIndex = kmcPrimFrag ;
3854 }
3855 else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR))
3856 {
3857 mcIndex = kmcPrimISR;
3858 }
3859 else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay))
3860 {
3861 mcIndex = kmcPrimPi0Decay;
3862 }
3863 else if( (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) ||
3864 GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)))
3865 {
3866 mcIndex = kmcPrimOtherDecay;
3867 }
3868 else
3869 {
bf8a7dac 3870 // Other decay but from non final state particle
3871 mcIndex = kmcPrimOtherDecay;
d2d42179 3872 }//Other origin
3873
3874 // ////////////////////ISO MC/////////////////////////
3875 Double_t sumPtInCone = 0; Double_t dR=0. ;
3876 TParticle * mcisopStack = 0;
3877 AliAODMCParticle * mcisopAOD = 0;
3878 Int_t partInConeStatus = -1, partInConeMother = -1;
3879 Double_t partInConePt = 0, partInConeEta = 0, partInConePhi = 0;
3880 Int_t npart = 0;
3881 for(Int_t ip = 0; ip < nprim ; ip++)
dc9c6e78 3882 {
d2d42179 3883 if(ip==i) continue;
dc9c6e78 3884
d2d42179 3885 if( GetReader()->ReadStack() )
dc9c6e78 3886 {
d2d42179 3887 mcisopStack = static_cast<TParticle*>(stack->Particle(ip));
3888 if( !mcisopStack ) continue;
3889 partInConeStatus = mcisopStack->GetStatusCode();
3890 partInConeMother = mcisopStack->GetMother(0);
3891 partInConePt = mcisopStack->Pt();
3892 partInConeEta = mcisopStack->Eta();
3893 partInConePhi = mcisopStack->Phi();
3894 }
3895 else
3896 {
3897 mcisopAOD = (AliAODMCParticle *) mcparticles->At(ip);
3898 if( !mcisopAOD ) continue;
3899 partInConeStatus = mcisopAOD->GetStatus();
3900 partInConeMother = mcisopAOD->GetMother();
3901 partInConePt = mcisopAOD->Pt();
3902 partInConeEta = mcisopAOD->Eta();
3903 partInConePhi = mcisopAOD->Phi();
3904 }
dc9c6e78 3905
4b6cb0f2 3906 // Consider only final state particles, but this depends on generator,
3907 // status 1 is the usual one, in case of not being ok, leave the possibility
3908 // to not consider this.
3909 if( partInConeStatus != 1 && GetMCAnalysisUtils()->GetMCGenerator()!="" ) continue ;
d2d42179 3910
3911 if( partInConeMother == i ) continue;
3912
3913 if( partInConePt < GetReader()->GetCTSPtMin() ) continue;
3914 // Careful!!!, cut for TPC tracks and calorimeter clusters in cone can be different
3915
3916 // TVector3 vmcv(mcisop->Px(),mcisop->Py(), mcisop->Pz());
3917 // if(vmcv.Perp()>1)
3918 // continue;
3919
4b6cb0f2 3920 //
3921 // Add here Acceptance cut???, charged particles CTS fid cut, neutral Calo real acceptance.
3922 //
3923
d2d42179 3924 dR = GetIsolationCut()->Radius(photonEta, photonPhi, partInConeEta, partInConePhi);
3925
3926 if(dR > GetIsolationCut()->GetConeSize())
3927 continue;
3928
3929 sumPtInCone += partInConePt;
3930 if(partInConePt > GetIsolationCut()->GetPtThreshold() &&
3931 partInConePt < GetIsolationCut()->GetPtThresholdMax()) npart++;
3932 }
3933
3934 ///////END ISO MC/////////////////////////
3935
3936 // Fill the histograms, only those in the defined calorimeter acceptance
3937
3938 fhEtaPrimMC[kmcPrimPhoton]->Fill(photonPt , photonEta) ;
3939 fhPhiPrimMC[kmcPrimPhoton]->Fill(photonPt , photonPhi) ;
3940 fhEPrimMC [kmcPrimPhoton]->Fill(photonE) ;
3941
3942 fhEtaPrimMC[mcIndex]->Fill(photonPt , photonEta) ;
3943 fhPhiPrimMC[mcIndex]->Fill(photonPt , photonPhi) ;
3944 fhEPrimMC [mcIndex]->Fill(photonE ) ;
3945
3946 // Isolated?
3947 Bool_t isolated = kFALSE;
3948 if(GetIsolationCut()->GetICMethod() == AliIsolationCut::kSumPtIC &&
3949 (sumPtInCone < GetIsolationCut()->GetSumPtThreshold() ||
3950 sumPtInCone > GetIsolationCut()->GetSumPtThresholdMax()))
3951 isolated = kTRUE;
3952
3953 if(GetIsolationCut()->GetICMethod() == AliIsolationCut::kPtThresIC &&
3954 npart == 0)
3955 isolated = kTRUE;
3956
3957 if(isolated)
3958 {
3959 fhPtPrimMCiso [mcIndex] ->Fill(photonPt) ;
3960 fhPtPrimMCiso [kmcPrimPhoton]->Fill(photonPt) ;
3961 }
3962
3963 }//loop on primaries
be703b18 3964
3965 if(GetDebug() > 0) printf("AliAnaParticleIsolation::FillAcceptanceHistograms() - End \n");
6ae3345d 3966
dc9c6e78 3967}
3968
3969
803d06a8 3970//_____________________________________________________________________________________
124bffb3 3971void AliAnaParticleIsolation::MakeSeveralICAnalysis(AliAODPWG4ParticleCorrelation* ph,
3972 Int_t mcIndex)
1a31a9ab 3973{
1a31a9ab 3974
db6fb352 3975 //Isolation Cut Analysis for both methods and different pt cuts and cones
d2d42179 3976 Float_t ptC = ph->Pt();
db6fb352 3977 Float_t etaC = ph->Eta();
3978 Float_t phiC = ph->Phi();
d2d42179 3979 Int_t tag = ph->GetTag();
8913c8c4 3980
3981 Int_t decayTag = 0;
3982 if(fFillTaggedDecayHistograms)
3983 {
3984 decayTag = ph->GetBtag(); // temporary
3985 if(decayTag < 0) decayTag = 0; // temporary
3986 }
3987
be703b18 3988 if(GetDebug() > 0)
8913c8c4 3989 printf("AliAnaParticleIsolation::MakeSeveralICAnalysis() - Isolate pT %2.2f, decay tag %d\n",ptC, decayTag);
03bae431 3990
124bffb3 3991 //Keep original setting used when filling AODs, reset at end of analysis
1a31a9ab 3992 Float_t ptthresorg = GetIsolationCut()->GetPtThreshold();
3993 Float_t ptfracorg = GetIsolationCut()->GetPtFraction();
f5b702a0 3994 Float_t ptsumcorg = GetIsolationCut()->GetSumPtThreshold();
1a31a9ab 3995 Float_t rorg = GetIsolationCut()->GetConeSize();
3996
3c12e375 3997 Float_t coneptsum = 0, coneptlead = 0;
db6fb352 3998 Int_t n [10][10];//[fNCones][fNPtThresFrac];
3999 Int_t nfrac[10][10];//[fNCones][fNPtThresFrac];
ca134929 4000 Bool_t isolated = kFALSE;
6ae3345d 4001
727a309a 4002 // Fill hist with all particles before isolation criteria
be703b18 4003 fhENoIso ->Fill(ph->E());
db6fb352 4004 fhPtNoIso ->Fill(ptC);
4005 fhEtaPhiNoIso->Fill(etaC,phiC);
4006
4007 if(IsDataMC())
4008 {
124bffb3 4009 if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4010 fhPtNoIsoMC[kmcPhoton]->Fill(ptC);
4011
4012 fhPtNoIsoMC[mcIndex]->Fill(ptC);
db6fb352 4013 }
4014
aa2e58e4 4015 // Candidates tagged as decay in another analysis (AliAnaPi0EbE)
8913c8c4 4016 if(fFillTaggedDecayHistograms && decayTag > 0)
db6fb352 4017 {
8913c8c4 4018 for(Int_t ibit = 0; ibit < fNDecayBits; ibit++)
aa2e58e4 4019 {
8913c8c4 4020 if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[ibit]))
4021 {
4022 fhPtDecayNoIso[ibit] ->Fill(ptC);
4023 fhEtaPhiDecayNoIso[ibit]->Fill(etaC,phiC);
4024
4025 if(IsDataMC())
4026 {
4027 if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4028 fhPtDecayNoIsoMC[ibit][kmcPhoton]->Fill(ptC);
4029
4030 fhPtDecayNoIsoMC[ibit][mcIndex]->Fill(ptC);
4031 }
4032 } // bit ok
4033 } // bit loop
4034 } // decay histograms
be703b18 4035
44e48e82 4036 //Get vertex for photon momentum calculation
4037 Double_t vertex[] = {0,0,0} ; //vertex ;
124bffb3 4038 if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
4039 GetReader()->GetVertex(vertex);
6ae3345d 4040
1a31a9ab 4041 //Loop on cone sizes
b5dbb99b 4042 for(Int_t icone = 0; icone<fNCones; icone++)
4043 {
44e48e82 4044 //Recover reference arrays with clusters and tracks
4045 TObjArray * refclusters = ph->GetObjArray(GetAODObjArrayName()+"Clusters");
4046 TObjArray * reftracks = ph->GetObjArray(GetAODObjArrayName()+"Tracks");
4047
4048 //If too small or too large pt, skip
124bffb3 4049 if(ptC < GetMinPt() || ptC > GetMaxPt() ) continue ;
4050
4051 //In case a more strict IC is needed in the produced AOD
4052
3c12e375 4053 isolated = kFALSE; coneptsum = 0; coneptlead = 0;
124bffb3 4054
4055 GetIsolationCut()->SetSumPtThreshold(100);
4056 GetIsolationCut()->SetPtThreshold(100);
4057 GetIsolationCut()->SetPtFraction(100);
4058 GetIsolationCut()->SetConeSize(fConeSizes[icone]);
db6fb352 4059
44e48e82 4060 // retreive pt tracks to fill histo vs. pt leading
4061 //Fill pt distribution of particles in cone
23130491 4062 //fhPtLeadingPt(),fhPerpSumPtLeadingPt(),fhPerpPtLeadingPt(),
44e48e82 4063
be703b18 4064 // Tracks in perpendicular cones
23130491 4065 Double_t sumptPerp = 0. ;
44e48e82 4066 TObjArray * trackList = GetCTSTracks() ;
4067 for(Int_t itrack=0; itrack < trackList->GetEntriesFast(); itrack++)
4068 {
4069 AliVTrack* track = (AliVTrack *) trackList->At(itrack);
4070 //fill the histograms at forward range
4071 if(!track)
4072 {
4073 printf("AliAnaParticleIsolation::MakeAnalysisFillHistograms() - Track not available?");
4074 continue;
4075 }
4076
4077 Double_t dPhi = phiC - track->Phi() + TMath::PiOver2();
4078 Double_t dEta = etaC - track->Eta();
4079 Double_t arg = dPhi*dPhi + dEta*dEta;
4080 if(TMath::Sqrt(arg) < fConeSizes[icone])
4081 {
23130491 4082 fhPerpPtLeadingPt[icone]->Fill(ptC,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
4083 sumptPerp+=track->Pt();
44e48e82 4084 }
4085
4086 dPhi = phiC - track->Phi() - TMath::PiOver2();
4087 arg = dPhi*dPhi + dEta*dEta;
4088 if(TMath::Sqrt(arg) < fConeSizes[icone])
4089 {
23130491 4090 fhPerpPtLeadingPt[icone]->Fill(ptC,TMath::Sqrt(track->Px()*track->Px()+track->Py()*track->Py()));
4091 sumptPerp+=track->Pt();
124bffb3 4092 }
44e48e82 4093 }
23130491 4094
4095 fhPerpSumPtLeadingPt[icone]->Fill(ptC,sumptPerp);
4096
be703b18 4097 // Tracks in isolation cone, pT distribution and sum
4098 if(reftracks && GetIsolationCut()->GetParticleTypeInCone()!= AliIsolationCut::kOnlyNeutral)
124bffb3 4099 {
44e48e82 4100 for(Int_t itrack=0; itrack < reftracks->GetEntriesFast(); itrack++)
4101 {
4102 AliVTrack* track = (AliVTrack *) reftracks->At(itrack);
be703b18 4103
4104 Float_t rad = GetIsolationCut()->Radius(etaC, phiC, track->Eta(), track->Phi());
4105
4106 if(rad > fConeSizes[icone]) continue ;
4107
4108 fhPtLeadingPt[icone]->Fill(ptC, track->Pt());
4109 coneptsum += track->Pt();
44e48e82 4110 }
23130491 4111 }
4112
be703b18 4113 // Clusters in isolation cone, pT distribution and sum
4114 if(refclusters && GetIsolationCut()->GetParticleTypeInCone()!= AliIsolationCut::kOnlyCharged)
124bffb3 4115 {
44e48e82 4116 TLorentzVector mom ;
4117 for(Int_t icalo=0; icalo < refclusters->GetEntriesFast(); icalo++)
4118 {
4119 AliVCluster* calo = (AliVCluster *) refclusters->At(icalo);
6ae3345d 4120
44e48e82 4121 calo->GetMomentum(mom,vertex) ;//Assume that come from vertex in straight line
6ae3345d 4122
be703b18 4123 Float_t rad = GetIsolationCut()->Radius(etaC, phiC, mom.Eta(), mom.Phi());
6ae3345d 4124
be703b18 4125 if(rad > fConeSizes[icone]) continue ;
44e48e82 4126
4127 fhPtLeadingPt[icone]->Fill(ptC, mom.Pt());
be703b18 4128 coneptsum += mom.Pt();
44e48e82 4129 }
4130 }
124bffb3 4131
be703b18 4132 fhSumPtLeadingPt[icone]->Fill(ptC,coneptsum);
f5b702a0 4133
4134 if(IsDataMC())
4135 {
4136 if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4137 fhSumPtLeadingPtMC[kmcPhoton][icone]->Fill(ptC,coneptsum) ;
4138
4139 fhSumPtLeadingPtMC[mcIndex][icone]->Fill(ptC,coneptsum) ;
4140 }
6ae3345d 4141
be703b18 4142 ///////////////////
124bffb3 4143
be703b18 4144 //Loop on pt thresholds
4145 for(Int_t ipt = 0; ipt < fNPtThresFrac ; ipt++)
b5dbb99b 4146 {
db6fb352 4147 n [icone][ipt]=0;
1a31a9ab 4148 nfrac[icone][ipt]=0;
4149 GetIsolationCut()->SetPtThreshold(fPtThresholds[ipt]);
db6fb352 4150 GetIsolationCut()->SetPtFraction(fPtFractions[ipt]) ;
4151 GetIsolationCut()->SetSumPtThreshold(fSumPtThresholds[ipt]);
4152
44e48e82 4153 GetIsolationCut()->MakeIsolationCut(reftracks, refclusters,
ac5111f9 4154 GetReader(), GetCaloPID(),
b5dbb99b 4155 kFALSE, ph, "",
3c12e375 4156 n[icone][ipt],nfrac[icone][ipt],
4157 coneptsum, coneptlead, isolated);
1a31a9ab 4158
be703b18 4159 // Normal pT threshold cut
4160
4161 if(GetDebug() > 0)
4162 {
4163 printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - cone size %1.1f, ptThres %1.1f, sumptThresh %1.1f\n",
4164 fConeSizes[icone],fPtThresholds[ipt],fSumPtThresholds[ipt]);
f5b702a0 4165 printf("\t n %d, nfrac %d, coneptsum %2.2f\n",
4166 n[icone][ipt],nfrac[icone][ipt],coneptsum);
be703b18 4167
4168 printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - pt %1.1f, eta %1.1f, phi %1.1f\n",ptC, etaC, phiC);
4169 }
db6fb352 4170
124bffb3 4171 if(n[icone][ipt] == 0)
b5dbb99b 4172 {
be703b18 4173 if(GetDebug() > 0)
4174 printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling pt threshold loop\n");
4175
4176 fhPtThresIsolated [icone][ipt]->Fill(ptC);
db6fb352 4177 fhEtaPhiPtThresIso[icone][ipt]->Fill(etaC,phiC);
4178
8913c8c4 4179 if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
db6fb352 4180 {
8913c8c4 4181 if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4182 {
4183 fhPtPtThresDecayIso [icone][ipt]->Fill(ptC);
4184 fhEtaPhiPtThresDecayIso[icone][ipt]->Fill(etaC,phiC);
4185 }
db6fb352 4186 }
4187
b5dbb99b 4188 if(IsDataMC())
4189 {
124bffb3 4190 if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) )
4191 fhPtThresIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
4192
4193 fhPtThresIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
4194
1a31a9ab 4195 }
4196 }
4197
db6fb352 4198 // pt in cone fraction
b5dbb99b 4199 if(nfrac[icone][ipt] == 0)
4200 {
be703b18 4201 if(GetDebug() > 0)
4202 printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling frac loop\n");
4203
4204 fhPtFracIsolated [icone][ipt]->Fill(ptC);
db6fb352 4205 fhEtaPhiPtFracIso[icone][ipt]->Fill(etaC,phiC);
4206
8913c8c4 4207 if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
db6fb352 4208 {
8913c8c4 4209 if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4210 {
4211 fhPtPtFracDecayIso [icone][ipt]->Fill(ptC);
4212 fhEtaPhiPtFracDecayIso[icone][ipt]->Fill(etaC,phiC);
4213 }
db6fb352 4214 }
4215
b5dbb99b 4216 if(IsDataMC())
4217 {
124bffb3 4218 if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4219 fhPtFracIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
4220
4221 fhPtFracIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
1a31a9ab 4222 }
4223 }
db6fb352 4224
be703b18 4225 if(GetDebug()>0)
4226 printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - checking IC method : %i\n",GetIsolationCut()->GetICMethod());
db6fb352 4227
4228 //Pt threshold on pt cand/ sum in cone histograms
be703b18 4229 if(coneptsum < fSumPtThresholds[ipt])
4230 {
4231 if(GetDebug() > 0 )
4232 printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling sum loop\n");
6ae3345d 4233
f5b702a0 4234 fhSumPtIsolated [icone][ipt]->Fill(ptC) ;
b0a31c92 4235 fhEtaPhiPtSumIso[icone][ipt]->Fill(etaC, phiC) ;
be703b18 4236
8913c8c4 4237 if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
db6fb352 4238 {
8913c8c4 4239 if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4240 {
4241 fhPtPtSumDecayIso[icone][ipt]->Fill(ptC);
4242 fhEtaPhiPtSumDecayIso[icone][ipt]->Fill(etaC, phiC) ;
4243 }
db6fb352 4244 }
f5b702a0 4245
4246 if(IsDataMC())
4247 {
4248 if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
4249 fhSumPtIsolatedMC[kmcPhoton][icone][ipt]->Fill(ptC) ;
4250
4251 fhSumPtIsolatedMC[mcIndex][icone][ipt]->Fill(ptC) ;
4252 }
db6fb352 4253 }
4254
124bffb3 4255 // pt sum pt frac method
4256 // if( ((fPtFractions[ipt]*ptC < fSumPtThresholds[ipt]) && (coneptsum < fSumPtThresholds[ipt])) || ((fPtFractions[ipt]*ptC > fSumPtThresholds[ipt]) && (coneptsum < fPtFractions[ipt]*ptC)) )
4257
bb5fc123 4258 if(coneptsum < fPtFractions[ipt]*ptC)
124bffb3 4259 {
be703b18 4260 if(GetDebug() > 0)
4261 printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling PtFrac PtSum loop\n");
4262
4263 fhPtFracPtSumIso [icone][ipt]->Fill(ptC) ;
b0a31c92 4264 fhEtaPhiFracPtSumIso[icone][ipt]->Fill(etaC,phiC) ;
4265
8913c8c4 4266 if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
b0a31c92 4267 {
8913c8c4 4268 if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4269 {
4270 fhPtFracPtSumDecayIso [icone][ipt]->Fill(ptC);
4271 fhEtaPhiFracPtSumDecayIso[icone][ipt]->Fill(etaC,phiC);
4272 }
b0a31c92 4273 }
4274 }
4275
4276 // density method
db6fb352 4277 Float_t cellDensity = GetIsolationCut()->GetCellDensity( ph, GetReader());
be703b18 4278 if(coneptsum < fSumPtThresholds[ipt]*cellDensity)
4279 {
4280 if(GetDebug() > 0)
4281 printf(" AliAnaParticleIsolation::MakeSeveralICAnalysis() - filling density loop\n");
4282
4283 fhPtSumDensityIso [icone][ipt]->Fill(ptC) ;
b0a31c92 4284 fhEtaPhiSumDensityIso[icone][ipt]->Fill(etaC,phiC) ;
4285
8913c8c4 4286 if( fFillTaggedDecayHistograms && decayTag > 0 && fNDecayBits > 0)
db6fb352 4287 {
8913c8c4 4288 if(GetNeutralMesonSelection()->CheckDecayBit(decayTag,fDecayBits[0]))
4289 {
4290 fhPtSumDensityDecayIso [icone][ipt]->Fill(ptC);
4291 fhEtaPhiSumDensityDecayIso[icone][ipt]->Fill(etaC, phiC);
4292 }
db6fb352 4293 }
db6fb352 4294 }
1a31a9ab 4295 }//pt thresh loop
4296
1a31a9ab 4297
4298 }//cone size loop
4299
4300 //Reset original parameters for AOD analysis
4301 GetIsolationCut()->SetPtThreshold(ptthresorg);
4302 GetIsolationCut()->SetPtFraction(ptfracorg);
f5b702a0 4303 GetIsolationCut()->SetSumPtThreshold(ptsumcorg);
1a31a9ab 4304 GetIsolationCut()->SetConeSize(rorg);
4305
4306}
4307
803d06a8 4308//_____________________________________________________________
1a31a9ab 4309void AliAnaParticleIsolation::Print(const Option_t * opt) const
4310{
4311
4312 //Print some relevant parameters set for the analysis
4313 if(! opt)
4314 return;
4315
4316 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
745913ae 4317 AliAnaCaloTrackCorrBaseClass::Print(" ");
1a31a9ab 4318
4319 printf("ReMake Isolation = %d \n", fReMakeIC) ;
4320 printf("Make Several Isolation = %d \n", fMakeSeveralIC) ;
4321 printf("Calorimeter for isolation = %s \n", fCalorimeter.Data()) ;
4b6cb0f2 4322 printf("Detector for candidate isolation = %s \n", fIsoDetector.Data()) ;
1a31a9ab 4323
b5dbb99b 4324 if(fMakeSeveralIC)
4325 {
6ae3345d 4326 printf("N Cone Sizes = %d\n", fNCones) ;
1a31a9ab 4327 printf("Cone Sizes = \n") ;
4328 for(Int_t i = 0; i < fNCones; i++)
4329 printf(" %1.2f;", fConeSizes[i]) ;
4330 printf(" \n") ;
4331
4332 printf("N pT thresholds/fractions = %d\n", fNPtThresFrac) ;
4333 printf(" pT thresholds = \n") ;
4334 for(Int_t i = 0; i < fNPtThresFrac; i++)
4335 printf(" %2.2f;", fPtThresholds[i]) ;
4336
4337 printf(" \n") ;
4338
4339 printf(" pT fractions = \n") ;
4340 for(Int_t i = 0; i < fNPtThresFrac; i++)
4341 printf(" %2.2f;", fPtFractions[i]) ;
4342
db6fb352 4343 printf(" \n") ;
4344
4345 printf("sum pT thresholds = \n") ;
4346 for(Int_t i = 0; i < fNPtThresFrac; i++)
4347 printf(" %2.2f;", fSumPtThresholds[i]) ;
4348
4349
6ae3345d 4350 }
1a31a9ab 4351
1a31a9ab 4352 printf(" \n") ;
4353
4354}
4355