AliPhysics  ea71c62 (ea71c62)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnaPhoton.cxx
Go to the documentation of this file.
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  **************************************************************************/
15 
16 // --- ROOT system ---
17 #include <TH2F.h>
18 #include <TClonesArray.h>
19 #include <TObjString.h>
20 #include "TParticle.h"
21 #include "TDatabasePDG.h"
22 
23 // --- Analysis system ---
24 #include "AliAnaPhoton.h"
25 #include "AliCaloTrackReader.h"
26 #include "AliStack.h"
27 #include "AliCaloPID.h"
28 #include "AliMCAnalysisUtils.h"
29 #include "AliFiducialCut.h"
30 #include "AliVCluster.h"
31 #include "AliAODMCParticle.h"
32 #include "AliMixedEvent.h"
33 #include "AliAODEvent.h"
34 #include "AliESDEvent.h"
35 
36 // --- Detectors ---
37 #include "AliPHOSGeoUtils.h"
38 #include "AliEMCALGeometry.h"
39 
41 ClassImp(AliAnaPhoton) ;
43 
44 //____________________________
47 //____________________________
48 AliAnaPhoton::AliAnaPhoton() :
49 AliAnaCaloTrackCorrBaseClass(),
50 fMinDist(0.), fMinDist2(0.), fMinDist3(0.),
51 fRejectTrackMatch(0), fFillTMHisto(kFALSE),
52 fTimeCutMin(-10000), fTimeCutMax(10000),
53 fNCellsCut(0),
54 fNLMCutMin(-1), fNLMCutMax(10),
55 fFillSSHistograms(0), fFillEMCALRegionSSHistograms(0),
56 fFillConversionVertexHisto(0),fFillOnlySimpleSSHisto(1),
57 fNOriginHistograms(9), fNPrimaryHistograms(5),
58 fMomentum(), fPrimaryMom(), fProdVertex(),
59 fConstantTimeShift(0),
60 // Histograms
61 
62 // Control histograms
63 fhNCellsE(0), fhCellsE(0),
64 fhMaxCellDiffClusterE(0), fhTimePt(0), fhEtaPhi(0),
65 
66 fhEPhoton(0), fhPtPhoton(0),
67 fhPhiPhoton(0), fhEtaPhoton(0),
68 fhEtaPhiPhoton(0), fhEtaPhi05Photon(0),
69 fhPtCentralityPhoton(0), fhPtEventPlanePhoton(0),
70 
71 // Shower shape histograms
72 fhNLocMax(0),
73 fhDispE(0), fhLam0E(0), fhLam0Pt(0), fhLam1E(0),
74 fhDispETRD(0), fhLam0ETRD(0), fhLam0PtTRD(0), fhLam1ETRD(0),
75 fhDispETM(0), fhLam0ETM(0), fhLam0PtTM(0), fhLam1ETM(0),
76 fhDispETMTRD(0), fhLam0ETMTRD(0), fhLam0PtTMTRD(0), fhLam1ETMTRD(0),
77 
78 fhNCellsLam0LowE(0), fhNCellsLam1LowE(0), fhNCellsDispLowE(0),
79 fhNCellsLam0HighE(0), fhNCellsLam1HighE(0), fhNCellsDispHighE(0),
80 
81 fhEtaLam0LowE(0), fhPhiLam0LowE(0),
82 fhEtaLam0HighE(0), fhPhiLam0HighE(0),
83 fhLam0DispLowE(0), fhLam0DispHighE(0),
84 fhLam1Lam0LowE(0), fhLam1Lam0HighE(0),
85 fhDispLam1LowE(0), fhDispLam1HighE(0),
86 fhDispEtaE(0), fhDispPhiE(0),
87 fhSumEtaE(0), fhSumPhiE(0), fhSumEtaPhiE(0),
88 fhDispEtaPhiDiffE(0), fhSphericityE(0),
89 fhDispSumEtaDiffE(0), fhDispSumPhiDiffE(0),
90 
91 // MC histograms
92 fhMCPhotonELambda0NoOverlap(0), fhMCPhotonELambda0TwoOverlap(0), fhMCPhotonELambda0NOverlap(0),
93 // Embedding
94 fhEmbeddedSignalFractionEnergy(0),
95 fhEmbedPhotonELambda0FullSignal(0), fhEmbedPhotonELambda0MostlySignal(0),
96 fhEmbedPhotonELambda0MostlyBkg(0), fhEmbedPhotonELambda0FullBkg(0),
97 fhEmbedPi0ELambda0FullSignal(0), fhEmbedPi0ELambda0MostlySignal(0),
98 fhEmbedPi0ELambda0MostlyBkg(0), fhEmbedPi0ELambda0FullBkg(0),
99 
100 fhTimePtPhotonNoCut(0), fhTimePtPhotonSPD(0),
101 fhTimeNPileUpVertSPD(0), fhTimeNPileUpVertTrack(0),
102 fhPtPhotonNPileUpSPDVtx(0), fhPtPhotonNPileUpTrkVtx(0),
103 fhPtPhotonNPileUpSPDVtxTimeCut(0), fhPtPhotonNPileUpTrkVtxTimeCut(0),
104 fhPtPhotonNPileUpSPDVtxTimeCut2(0), fhPtPhotonNPileUpTrkVtxTimeCut2(0),
105 
106 fhEClusterSM(0), fhEPhotonSM(0),
107 fhPtClusterSM(0), fhPtPhotonSM(0),
108 fhMCConversionVertex(0), fhMCConversionVertexTRD(0)
109 {
110  for(Int_t i = 0; i < fgkNmcTypes; i++)
111  {
112  fhMCPt [i] = 0;
113  fhMCE [i] = 0;
114  fhMCPhi [i] = 0;
115  fhMCEta [i] = 0;
116  fhMCDeltaE [i] = 0;
117  fhMCDeltaPt[i] = 0;
118  fhMC2E [i] = 0;
119  fhMC2Pt [i] = 0;
120  }
121 
122  for(Int_t i = 0; i < fgkNmcPrimTypes; i++)
123  {
124  fhPtPrimMC [i] = 0;
125  fhEPrimMC [i] = 0;
126  fhPhiPrimMC[i] = 0;
127  fhEtaPrimMC[i] = 0;
128  fhYPrimMC [i] = 0;
129 
130  fhPtPrimMCAcc [i] = 0;
131  fhEPrimMCAcc [i] = 0;
132  fhPhiPrimMCAcc[i] = 0;
133  fhEtaPrimMCAcc[i] = 0;
134  fhYPrimMCAcc [i] = 0;
135  }
136 
137  for(Int_t i = 0; i < 7; i++)
138  {
139  fhDispEtaDispPhi[i] = 0;
140  fhLambda0DispPhi[i] = 0;
141  fhLambda0DispEta[i] = 0;
142 
143  fhPtPhotonPileUp[i] = 0;
144  fhClusterTimeDiffPhotonPileUp [i] = 0;
145 
146  for(Int_t j = 0; j < fgkNssTypes; j++)
147  {
148  fhMCDispEtaDispPhi[i][j] = 0;
149  fhMCLambda0DispEta[i][j] = 0;
150  fhMCLambda0DispPhi[i][j] = 0;
151  }
152  }
153 
154  for(Int_t i = 0; i < fgkNssTypes; i++)
155  {
156  fhMCELambda0 [i] = 0;
157  fhMCPtLambda0 [i] = 0;
158  fhMCELambda1 [i] = 0;
159  fhMCEDispersion [i] = 0;
160  fhMCNCellsE [i] = 0;
161  fhMCMaxCellDiffClusterE[i] = 0;
162  fhLambda0DispEta[i] = 0;
163  fhLambda0DispPhi[i] = 0;
164 
165  fhMCLambda0vsClusterMaxCellDiffE0[i] = 0;
166  fhMCLambda0vsClusterMaxCellDiffE2[i] = 0;
167  fhMCLambda0vsClusterMaxCellDiffE6[i] = 0;
168  fhMCNCellsvsClusterMaxCellDiffE0 [i] = 0;
169  fhMCNCellsvsClusterMaxCellDiffE2 [i] = 0;
170  fhMCNCellsvsClusterMaxCellDiffE6 [i] = 0;
171 
172  fhMCEDispEta [i] = 0;
173  fhMCEDispPhi [i] = 0;
174  fhMCESumEtaPhi [i] = 0;
175  fhMCEDispEtaPhiDiff[i] = 0;
176  fhMCESphericity [i] = 0;
177  }
178 
179  for(Int_t i = 0; i < 5; i++)
180  {
181  fhClusterCutsE [i] = 0;
182  fhClusterCutsPt[i] = 0;
183  }
184 
185  // Track matching residuals
186  for(Int_t i = 0; i < 2; i++)
187  {
188  fhTrackMatchedDEta [i] = 0; fhTrackMatchedDPhi [i] = 0; fhTrackMatchedDEtaDPhi [i] = 0;
189  fhTrackMatchedDEtaNeg[i] = 0; fhTrackMatchedDPhiNeg[i] = 0; fhTrackMatchedDEtaDPhiNeg[i] = 0;
190  fhTrackMatchedDEtaPos[i] = 0; fhTrackMatchedDPhiPos[i] = 0; fhTrackMatchedDEtaDPhiPos[i] = 0;
191  fhTrackMatchedDEtaTRD[i] = 0; fhTrackMatchedDPhiTRD[i] = 0;
192  fhTrackMatchedDEtaMCOverlap[i] = 0; fhTrackMatchedDPhiMCOverlap[i] = 0;
193  fhTrackMatchedDEtaMCNoOverlap[i] = 0; fhTrackMatchedDPhiMCNoOverlap[i] = 0;
194  fhTrackMatchedDEtaMCConversion[i] = 0; fhTrackMatchedDPhiMCConversion[i] = 0;
195  fhTrackMatchedMCParticle[i] = 0; fhTrackMatchedMCParticle[i] = 0;
196  fhdEdx[i] = 0; fhEOverP[i] = 0;
197  fhEOverPTRD[i] = 0;
198  }
199 
200  for(Int_t i = 0; i < 6; i++)
201  {
202  fhMCConversionLambda0Rcut [i] = 0;
203  fhMCConversionLambda0RcutTRD[i] = 0;
204  fhMCConversionLambda1Rcut [i] = 0;
205  fhMCConversionLambda1RcutTRD[i] = 0;
206  }
207 
208  for(Int_t ieta = 0; ieta < 4; ieta++)
209  {
210  for(Int_t iphi = 0; iphi < 3; iphi++)
211  {
212 // fhLam0EMCALRegion [ieta][iphi] = 0;
213 // fhLam0EMCALRegionTRD[ieta][iphi] = 0;
214 //
215 // for(Int_t i = 0; i < 6; i++)
216 // {
217 // fhLam0EMCALRegionMCConvRcut [ieta][iphi][i] = 0;
218 // fhLam0EMCALRegionTRDMCConvRcut[ieta][iphi][i] = 0;
219 // }
220  for(Int_t ism =0; ism < 20; ism++)
221  {
222  fhLam0EMCALRegionPerSM[ieta][iphi][ism] = 0;
223  fhLam1EMCALRegionPerSM[ieta][iphi][ism] = 0;
224  }
225  }
226  }
227 
228  for(Int_t il0 = 0; il0 < 2; il0++)
229  {
230  for(Int_t i = 0; i < 7; i++)
231  {
232  fhEtaPhiLam0BinPtBin [il0][i] = 0 ;
233  fhEtaPhiLargeTimeInClusterCell[il0][i] = 0 ;
234 
235  fhColRowLam0BinPtBin [il0][i] = 0 ;
236  fhColRowLam0BinPtBinWeighted [il0][i] = 0 ;
237  fhColRowLam0BinPtBinLargeTime [il0][i] = 0 ;
238  fhCellClusterIndexEAndTime [il0][i] = 0 ;
239  fhCellClusterEAndTime [il0][i] = 0 ;
240  fhCellClusterEFracAndTime [il0][i] = 0 ;
241  }
242 
243  for(Int_t ism =0; ism < 20; ism++)
244  {
245  fhLam1Lam0BinPerSM [il0][ism] = 0;
246  fhTimeLam0BinPerSM [il0][ism] = 0;
247  fhTimeLam0BinPerSMWeighted [il0][ism] = 0;
248  fhDTimeLam0BinPerSM [il0][ism] = 0;
249  fhDTimeLam0BinPerSMWeighted [il0][ism] = 0;
250  fhCellClusterEFracLam0BinPerSM [il0][ism] = 0;
251 // fhCellClusterEFracLam0BinPerSMWeighted[il0][ism] = 0;
252  fhCellClusterELam0BinPerSM [il0][ism] = 0;
253  fhCellClusterELam0BinPerSMWeighted[il0][ism] = 0;
254 
255  fhCellClusterEFracLam0BinPerSMLargeTime [il0][ism] = 0;
256  fhCellClusterEFracLam0BinPerSMLargeTimeTotal[il0][ism] = 0;
257  fhCellClusterELam0BinPerSMLargeTime [il0][ism] = 0;
258  fhCellClusterIndexELam0BinPerSMLargeTime[il0][ism] = 0;
259  fhNCellsWithLargeTimeInCluster [il0][ism] = 0;
260  }
261  }
262 
263 // for(Int_t il0 = 0; il0 < 2; il0++)
264 // {
265 // for(Int_t i = 0; i < 7; i++)
266 // {
267 // fhEtaPhiLam0BinPtBinSMShared [il0][i] = 0 ;
268 // fhColRowLam0BinPtBinSMShared [il0][i] = 0 ;
269 // }
270 //
271 // for(Int_t ism =0; ism < 12; ism++)
272 // {
273 // fhTimeLam0BinPerSMShared[il0][ism] = 0;
274 // fhLam0PerSMShared [ism] = 0;
275 // fhLam1PerSMShared [ism] = 0;
276 // }
277 // }
278 
279  for(Int_t ism = 0; ism < 20; ism++)
280  {
281  fhLam0PerSM [ism] = 0;
282  fhLam1PerSM [ism] = 0;
283  fhLam0PerSMLargeTimeInClusterCell[ism] = 0;
284  fhLam1PerSMLargeTimeInClusterCell[ism] = 0;
285 // fhLam0PerSMSPDPileUp [ism] = 0;
286 // fhLam1PerSMSPDPileUp [ism] = 0;
287  }
288 
289  for(Int_t ilarge = 0; ilarge < 5; ilarge++)
290  {
291  fhLam0PerNLargeTimeInClusterCell[ilarge] = 0;
292  fhLam1PerNLargeTimeInClusterCell[ilarge] = 0;
293  }
294 
295  // Initialize parameters
296  InitParameters();
297 }
298 
299 //_____________________________________________________________________
315 //_____________________________________________________________________
316 Bool_t AliAnaPhoton::ClusterSelected(AliVCluster* calo, Int_t nMaxima)
317 {
318  Float_t ptcluster = fMomentum.Pt();
319  Float_t ecluster = fMomentum.E();
320  Float_t etacluster = fMomentum.Eta();
321  Float_t phicluster = fMomentum.Phi();
322 
323  if(phicluster < 0) phicluster+=TMath::TwoPi();
324 
325  Bool_t matched = IsTrackMatched(calo,GetReader()->GetInputEvent());
326 
327  AliDebug(2,Form("Current Event %d; Before selection : E %2.2f, pT %2.2f, phi %2.2f, eta %2.2f",
328  GetReader()->GetEventNumber(),
329  ecluster,ptcluster, phicluster*TMath::RadToDeg(),etacluster));
330 
331  fhClusterCutsE [1]->Fill( ecluster, GetEventWeight());
332  fhClusterCutsPt[1]->Fill(ptcluster, GetEventWeight());
333 
334  if(ecluster > 0.5) fhEtaPhi->Fill(etacluster, phicluster, GetEventWeight());
335 
336  Int_t nSM = GetModuleNumber(calo);
337  if(nSM < GetCaloUtils()->GetNumberOfSuperModulesUsed() && nSM >=0)
338  {
339  fhEClusterSM ->Fill(ecluster , nSM, GetEventWeight());
340  fhPtClusterSM->Fill(ptcluster, nSM, GetEventWeight());
341  }
342 
343  //.......................................
344  //If too small or big energy, skip it
345  if(ecluster < GetMinEnergy() || ecluster > GetMaxEnergy() ) return kFALSE ;
346 
347  AliDebug(2,Form("\t Cluster %d Pass E Cut",calo->GetID()));
348 
349  fhClusterCutsE [2]->Fill( ecluster, GetEventWeight());
350  fhClusterCutsPt[2]->Fill(ptcluster, GetEventWeight());
351 
352  //.......................................
353  // TOF cut, BE CAREFUL WITH THIS CUT
354  Double_t tof = calo->GetTOF()*1e9;
355  if(tof > 400) tof-=fConstantTimeShift; // only for MC, rest shift = 0
356 
357  if(tof < fTimeCutMin || tof > fTimeCutMax) return kFALSE;
358 
359  AliDebug(2,Form("\t Cluster %d Pass Time Cut",calo->GetID()));
360 
361  fhClusterCutsE [3]->Fill( ecluster, GetEventWeight());
362  fhClusterCutsPt[3]->Fill(ptcluster, GetEventWeight());
363 
364  //.......................................
365  if(calo->GetNCells() <= fNCellsCut && GetReader()->GetDataType() != AliCaloTrackReader::kMC) return kFALSE;
366 
367  AliDebug(2,Form("\t Cluster %d Pass NCell Cut",calo->GetID()));
368 
369  fhClusterCutsE [4]->Fill( ecluster, GetEventWeight());
370  fhClusterCutsPt[4]->Fill(ptcluster, GetEventWeight());
371 
372  if(nMaxima < fNLMCutMin || nMaxima > fNLMCutMax) return kFALSE ;
373  AliDebug(2,Form("\t Cluster %d pass NLM %d of out of range",calo->GetID(), nMaxima));
374 
375  fhClusterCutsE [5]->Fill( ecluster, GetEventWeight());
376  fhClusterCutsPt[5]->Fill(ptcluster, GetEventWeight());
377 
378  //.......................................
379  //Check acceptance selection
380  if(IsFiducialCutOn())
381  {
382  Bool_t in = GetFiducialCut()->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),GetCalorimeter()) ;
383  if(! in ) return kFALSE ;
384  }
385 
386  AliDebug(2,Form("\t Fiducial cut passed"));
387 
388  fhClusterCutsE [6]->Fill( ecluster, GetEventWeight());
389  fhClusterCutsPt[6]->Fill(ptcluster, GetEventWeight());
390 
391  //.......................................
392  //Skip matched clusters with tracks
393 
394  // Fill matching residual histograms before PID cuts
395  if(fFillTMHisto) FillTrackMatchingResidualHistograms(calo,0);
396 
397  if(fRejectTrackMatch)
398  {
399  if(matched)
400  {
401  AliDebug(2,"\t Reject track-matched clusters");
402  return kFALSE ;
403  }
404  else
405  AliDebug(2,"\t Track-matching cut passed");
406  }// reject matched clusters
407 
408  fhClusterCutsE [7]->Fill( ecluster, GetEventWeight());
409  fhClusterCutsPt[7]->Fill(ptcluster, GetEventWeight());
410 
411  //.......................................
412  //Check Distance to Bad channel, set bit.
413  Double_t distBad=calo->GetDistanceToBadChannel() ; //Distance to bad channel
414  if(distBad < 0.) distBad=9999. ; //workout strange convension dist = -1. ;
415  if(distBad < fMinDist)
416  {//In bad channel (PHOS cristal size 2.2x2.2 cm), EMCAL ( cell units )
417  return kFALSE ;
418  }
419  else AliDebug(2,Form("\t Bad channel cut passed %4.2f > %2.2f",distBad, fMinDist));
420 
421  fhClusterCutsE [8]->Fill( ecluster, GetEventWeight());
422  fhClusterCutsPt[8]->Fill(ptcluster, GetEventWeight());
423 
424  AliDebug(1,Form("Current Event %d; After selection : E %2.2f, pT %2.2f, phi %2.2f, eta %2.2f",
425  GetReader()->GetEventNumber(),
426  ecluster, ptcluster,fMomentum.Phi()*TMath::RadToDeg(),fMomentum.Eta()));
427 
428  //All checks passed, cluster selected
429  return kTRUE;
430 
431 }
432 
433 //___________________________________________
438 //___________________________________________
439 void AliAnaPhoton::FillAcceptanceHistograms()
440 {
441  Double_t photonY = -100 ;
442  Double_t photonE = -1 ;
443  Double_t photonPt = -1 ;
444  Double_t photonPhi = 100 ;
445  Double_t photonEta = -1 ;
446 
447  Int_t pdg = 0 ;
448  Int_t tag = 0 ;
449  Int_t status = 0 ;
450  Int_t mcIndex = 0 ;
451  Int_t nprim = 0 ;
452  Bool_t inacceptance = kFALSE ;
453 
454  TParticle * primStack = 0;
455  AliAODMCParticle * primAOD = 0;
456 
457  // Get the ESD MC particles container
458  AliStack * stack = 0;
459  if( GetReader()->ReadStack() )
460  {
461  stack = GetMCStack();
462  if( !stack )
463  {
464  AliFatal("Stack not available, is the MC handler called? STOP");
465  return;
466  }
467  nprim = stack->GetNtrack();
468  }
469 
470  // Get the AOD MC particles container
471  TClonesArray * mcparticles = 0;
472  if( GetReader()->ReadAODMCParticles() )
473  {
474  mcparticles = GetReader()->GetAODMCParticles();
475  if( !mcparticles )
476  {
477  AliFatal("Standard MCParticles not available!");
478  return;
479  }
480  nprim = mcparticles->GetEntriesFast();
481  }
482 
483  for(Int_t i=0 ; i < nprim; i++)
484  {
485  if(GetReader()->AcceptOnlyHIJINGLabels() && !GetReader()->IsHIJINGLabel(i)) continue ;
486 
487  if(GetReader()->ReadStack())
488  {
489  primStack = stack->Particle(i) ;
490  if(!primStack)
491  {
492  AliWarning("ESD primaries pointer not available!!");
493  continue;
494  }
495 
496  pdg = primStack->GetPdgCode();
497  status = primStack->GetStatusCode();
498 
499  // Protection against floating point exception
500  if ( primStack->Energy() == TMath::Abs(primStack->Pz()) ||
501  (primStack->Energy() - primStack->Pz()) < 1e-3 ||
502  (primStack->Energy() + primStack->Pz()) < 0 ) continue ;
503 
504  //printf("i %d, %s %d %s %d \n",i, stack->Particle(i)->GetName(), stack->Particle(i)->GetPdgCode(),
505  // prim->GetName(), prim->GetPdgCode());
506 
507  // Photon kinematics
508  primStack->Momentum(fMomentum);
509 
510  photonY = 0.5*TMath::Log((primStack->Energy()+primStack->Pz())/(primStack->Energy()-primStack->Pz())) ;
511  }
512  else
513  {
514  primAOD = (AliAODMCParticle *) mcparticles->At(i);
515  if(!primAOD)
516  {
517  AliWarning("AOD primaries pointer not available!!");
518  continue;
519  }
520 
521  pdg = primAOD->GetPdgCode();
522  status = primAOD->GetStatus();
523 
524  // Protection against floating point exception
525  if ( primAOD->E() == TMath::Abs(primAOD->Pz()) ||
526  (primAOD->E() - primAOD->Pz()) < 1e-3 ||
527  (primAOD->E() + primAOD->Pz()) < 0 ) continue ;
528 
529  // Photon kinematics
530  fMomentum.SetPxPyPzE(primAOD->Px(),primAOD->Py(),primAOD->Pz(),primAOD->E());
531 
532  photonY = 0.5*TMath::Log((primAOD->E()+primAOD->Pz())/(primAOD->E()-primAOD->Pz())) ;
533  }
534 
535  // Select only photons in the final state
536  if(pdg != 22 ) continue ;
537 
538  // If too small or too large pt, skip, same cut as for data analysis
539  photonPt = fMomentum.Pt () ;
540 
541  if(photonPt < GetMinPt() || photonPt > GetMaxPt() ) continue ;
542 
543  photonE = fMomentum.E () ;
544  photonEta = fMomentum.Eta() ;
545  photonPhi = fMomentum.Phi() ;
546 
547  if(photonPhi < 0) photonPhi+=TMath::TwoPi();
548 
549  // Check if photons hit desired acceptance
550  inacceptance = kTRUE;
551 
552  // Check same fidutial borders as in data analysis on top of real acceptance if real was requested.
553  if( IsFiducialCutOn() && !GetFiducialCut()->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),GetCalorimeter())) inacceptance = kFALSE ;
554 
555  // Check if photons hit the Calorimeter acceptance
556  if(IsRealCaloAcceptanceOn()) // defined on base class
557  {
558  if(GetReader()->ReadStack() &&
559  !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(GetCalorimeter(), primStack)) inacceptance = kFALSE ;
560  if(GetReader()->ReadAODMCParticles() &&
561  !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance(GetCalorimeter(), primAOD )) inacceptance = kFALSE ;
562  }
563 
564  // Get tag of this particle photon from fragmentation, decay, prompt ...
565  // Set the origin of the photon.
566  tag = GetMCAnalysisUtils()->CheckOrigin(i,GetReader(),GetCalorimeter());
567 
568  if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton))
569  {
570  // A conversion photon from a hadron, skip this kind of photon
571  // printf("AliAnaPhoton::FillAcceptanceHistograms() - not a photon, weird!\n ");
572  // GetMCAnalysisUtils()->PrintMCTag(tag);
573 
574  continue;
575  }
576 
577  // Consider only final state particles, but this depends on generator,
578  // status 1 is the usual one, in case of not being ok, leave the possibility
579  // to not consider this.
580  if(status > 1) continue ; // Avoid "partonic" photons
581 
582  Bool_t takeIt = kFALSE ;
583  if(status == 1 && GetMCAnalysisUtils()->GetMCGenerator() != AliMCAnalysisUtils::kBoxLike ) takeIt = kTRUE ;
584 
585  if (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) continue;
586 
587  // Origin of photon
588  if (GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt))
589  {
590  mcIndex = kmcPPrompt;
591  }
592  else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation))
593  {
594  mcIndex = kmcPFragmentation ;
595  }
596  else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR))
597  {
598  mcIndex = kmcPISR;
599  }
600  else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay))
601  {
602  mcIndex = kmcPPi0Decay;
603  }
604  else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay))
605  {
606  mcIndex = kmcPEtaDecay;
607  }
608  else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay))
609  {
610  mcIndex = kmcPOtherDecay;
611  }
612  else
613  {
614  // Other decay but from non final state particle
615  mcIndex = kmcPOtherDecay;
616  } // Other origin
617 
618  if(!takeIt && (mcIndex == kmcPPi0Decay || mcIndex == kmcPOtherDecay)) takeIt = kTRUE ;
619 
620  if(!takeIt) continue ;
621 
622  // Fill histograms for all photons
623  fhYPrimMC[kmcPPhoton]->Fill(photonPt, photonY, GetEventWeight()) ;
624  if(TMath::Abs(photonY) < 1.0)
625  {
626  fhEPrimMC [kmcPPhoton]->Fill(photonE , GetEventWeight()) ;
627  fhPtPrimMC [kmcPPhoton]->Fill(photonPt, GetEventWeight()) ;
628  fhPhiPrimMC[kmcPPhoton]->Fill(photonE , photonPhi, GetEventWeight()) ;
629  fhEtaPrimMC[kmcPPhoton]->Fill(photonE , photonEta, GetEventWeight()) ;
630  }
631 
632  if(inacceptance)
633  {
634  fhEPrimMCAcc [kmcPPhoton]->Fill(photonE , GetEventWeight()) ;
635  fhPtPrimMCAcc [kmcPPhoton]->Fill(photonPt, GetEventWeight()) ;
636  fhPhiPrimMCAcc[kmcPPhoton]->Fill(photonE , photonPhi, GetEventWeight()) ;
637  fhEtaPrimMCAcc[kmcPPhoton]->Fill(photonE , photonEta, GetEventWeight()) ;
638  fhYPrimMCAcc [kmcPPhoton]->Fill(photonE , photonY , GetEventWeight()) ;
639  } // Accepted
640 
641  // Fill histograms for photons origin
642  if(mcIndex < fNPrimaryHistograms)
643  {
644  fhYPrimMC[mcIndex]->Fill(photonPt, photonY, GetEventWeight()) ;
645  if(TMath::Abs(photonY) < 1.0)
646  {
647  fhEPrimMC [mcIndex]->Fill(photonE , GetEventWeight()) ;
648  fhPtPrimMC [mcIndex]->Fill(photonPt, GetEventWeight()) ;
649  fhPhiPrimMC[mcIndex]->Fill(photonE , photonPhi, GetEventWeight()) ;
650  fhEtaPrimMC[mcIndex]->Fill(photonE , photonEta, GetEventWeight()) ;
651  }
652 
653  if(inacceptance)
654  {
655  fhEPrimMCAcc [mcIndex]->Fill(photonE , GetEventWeight()) ;
656  fhPtPrimMCAcc [mcIndex]->Fill(photonPt, GetEventWeight()) ;
657  fhPhiPrimMCAcc[mcIndex]->Fill(photonE , photonPhi, GetEventWeight()) ;
658  fhEtaPrimMCAcc[mcIndex]->Fill(photonE , photonEta, GetEventWeight()) ;
659  fhYPrimMCAcc [mcIndex]->Fill(photonE , photonY , GetEventWeight()) ;
660  } // Accepted
661  }
662  } // loop on primaries
663 }
664 
665 //________________________________________________________________________________
667 //________________________________________________________________________________
668 void AliAnaPhoton::FillPileUpHistograms(AliVCluster* cluster, AliVCaloCells *cells,
669  Int_t absIdMax)
670 {
671  Float_t pt = fMomentum.Pt();
672  Float_t time = cluster->GetTOF()*1.e9;
673  if ( time > 400 ) time-=fConstantTimeShift; // Only for MC, rest shift = 0
674 
675  AliVEvent * event = GetReader()->GetInputEvent();
676 
677  if(GetReader()->IsPileUpFromSPD()) fhPtPhotonPileUp[0]->Fill(pt, GetEventWeight()) ;
678  if(GetReader()->IsPileUpFromEMCal()) fhPtPhotonPileUp[1]->Fill(pt, GetEventWeight()) ;
679  if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtPhotonPileUp[2]->Fill(pt, GetEventWeight()) ;
680  if(GetReader()->IsPileUpFromSPDAndEMCal()) fhPtPhotonPileUp[3]->Fill(pt, GetEventWeight()) ;
681  if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhPtPhotonPileUp[4]->Fill(pt, GetEventWeight()) ;
682  if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhPtPhotonPileUp[5]->Fill(pt, GetEventWeight()) ;
683  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtPhotonPileUp[6]->Fill(pt, GetEventWeight()) ;
684 
685  fhTimePtPhotonNoCut->Fill(pt, time, GetEventWeight());
686  if(GetReader()->IsPileUpFromSPD()) fhTimePtPhotonSPD->Fill(pt, time, GetEventWeight());
687 
688  //
689  // Cells inside the cluster
690  //
691 
692  // Loop on cells inside cluster, max cell must be over 100 MeV and time in BC=0
693  if(cells->GetCellAmplitude(absIdMax) > 0.1 && TMath::Abs(time) < 30)
694  {
695  for (Int_t ipos = 0; ipos < cluster->GetNCells(); ipos++)
696  {
697  Int_t absId = cluster->GetCellsAbsId()[ipos];
698 
699  if( absId == absIdMax ) continue ;
700 
701  Double_t tcell = cells->GetCellTime(absId);
702  Float_t amp = cells->GetCellAmplitude(absId);
703  Int_t bc = GetReader()->GetInputEvent()->GetBunchCrossNumber();
704 
705  GetCaloUtils()->GetEMCALRecoUtils()->AcceptCalibrateCell(absId,bc,amp,tcell,cells);
706  tcell*=1e9;
707  tcell-=fConstantTimeShift;
708 
709  Float_t diff = (time-tcell);
710 
711  if( cells->GetCellAmplitude(absIdMax) < 0.1 ) continue ;
712 
713  if(GetReader()->IsPileUpFromSPD()) fhClusterTimeDiffPhotonPileUp[0]->Fill(pt, diff, GetEventWeight());
714  if(GetReader()->IsPileUpFromEMCal()) fhClusterTimeDiffPhotonPileUp[1]->Fill(pt, diff, GetEventWeight());
715  if(GetReader()->IsPileUpFromSPDOrEMCal()) fhClusterTimeDiffPhotonPileUp[2]->Fill(pt, diff, GetEventWeight());
716  if(GetReader()->IsPileUpFromSPDAndEMCal()) fhClusterTimeDiffPhotonPileUp[3]->Fill(pt, diff, GetEventWeight());
717  if(GetReader()->IsPileUpFromSPDAndNotEMCal()) fhClusterTimeDiffPhotonPileUp[4]->Fill(pt, diff, GetEventWeight());
718  if(GetReader()->IsPileUpFromEMCalAndNotSPD()) fhClusterTimeDiffPhotonPileUp[5]->Fill(pt, diff, GetEventWeight());
719  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhClusterTimeDiffPhotonPileUp[6]->Fill(pt, diff, GetEventWeight());
720 
721  } // loop
722  }
723 
724  AliESDEvent* esdEv = dynamic_cast<AliESDEvent*> (event);
725  AliAODEvent* aodEv = dynamic_cast<AliAODEvent*> (event);
726 
727  //
728  // N pile up vertices
729  //
730 
731  Int_t nVtxSPD = -1;
732  Int_t nVtxTrk = -1;
733 
734  if (esdEv)
735  {
736  nVtxSPD = esdEv->GetNumberOfPileupVerticesSPD();
737  nVtxTrk = esdEv->GetNumberOfPileupVerticesTracks();
738 
739  } // ESD
740  else if (aodEv)
741  {
742  nVtxSPD = aodEv->GetNumberOfPileupVerticesSPD();
743  nVtxTrk = aodEv->GetNumberOfPileupVerticesTracks();
744  } // AOD
745 
746  if(pt < 8)
747  {
748  fhTimeNPileUpVertSPD ->Fill(time, nVtxSPD, GetEventWeight());
749  fhTimeNPileUpVertTrack->Fill(time, nVtxTrk, GetEventWeight());
750  }
751 
752  fhPtPhotonNPileUpSPDVtx->Fill(pt, nVtxSPD, GetEventWeight());
753  fhPtPhotonNPileUpTrkVtx->Fill(pt, nVtxTrk, GetEventWeight());
754 
755  if(TMath::Abs(time) < 25)
756  {
757  fhPtPhotonNPileUpSPDVtxTimeCut->Fill(pt, nVtxSPD, GetEventWeight());
758  fhPtPhotonNPileUpTrkVtxTimeCut->Fill(pt, nVtxTrk, GetEventWeight());
759  }
760 
761  if(time < 75 && time > -25)
762  {
763  fhPtPhotonNPileUpSPDVtxTimeCut2->Fill(pt, nVtxSPD, GetEventWeight());
764  fhPtPhotonNPileUpTrkVtxTimeCut2->Fill(pt, nVtxTrk, GetEventWeight());
765  }
766 }
767 
768 //_________________________________________________________________________________
770 //_________________________________________________________________________________
771 void AliAnaPhoton::FillShowerShapeHistograms(AliVCluster* cluster, Int_t mcTag,
772  Float_t maxCellFraction, Int_t & largeTime)
773 {
774  if(!fFillSSHistograms || GetMixedEvent()) return;
775 
776  Float_t energy = cluster->E();
777  Int_t ncells = cluster->GetNCells();
778  Float_t lambda0 = cluster->GetM02();
779  Float_t lambda1 = cluster->GetM20();
780  Float_t disp = cluster->GetDispersion()*cluster->GetDispersion();
781 
782  Float_t pt = fMomentum.Pt();
783  Float_t eta = fMomentum.Eta();
784  Float_t phi = fMomentum.Phi();
785  if(phi < 0) phi+=TMath::TwoPi();
786 
787  fhLam0E ->Fill(energy, lambda0, GetEventWeight());
788  fhLam0Pt->Fill(pt , lambda0, GetEventWeight());
789  fhLam1E ->Fill(energy, lambda1, GetEventWeight());
790  fhDispE ->Fill(energy, disp , GetEventWeight());
791 
792  if(GetCalorimeter() == kEMCAL && GetFirstSMCoveredByTRD() >= 0 &&
793  GetModuleNumber(cluster) >= GetFirstSMCoveredByTRD() )
794  {
795  fhLam0ETRD ->Fill(energy, lambda0, GetEventWeight());
796  fhLam0PtTRD->Fill(pt , lambda0, GetEventWeight());
797  fhLam1ETRD ->Fill(energy, lambda1, GetEventWeight());
798  fhDispETRD ->Fill(energy, disp, GetEventWeight());
799  }
800 
801  //
802  // EMCal SM regions
803  //
804  if(cluster->IsEMCAL() && fFillEMCALRegionSSHistograms)
805  {
806  Int_t sm = GetModuleNumber(cluster);
807 
808 // Bool_t shared = GetCaloUtils()->IsClusterSharedByTwoSuperModules(GetEMCALGeometry(),cluster);
809 
810  fhLam0PerSM[sm]->Fill(pt, lambda0, GetEventWeight());
811  fhLam1PerSM[sm]->Fill(pt, lambda1, GetEventWeight());
812 
813 // if(GetReader()->IsPileUpFromSPD())
814 // {
815 // fhLam0PerSMSPDPileUp[sm]->Fill(pt, lambda0, GetEventWeight());
816 // fhLam1PerSMSPDPileUp[sm]->Fill(pt, lambda1, GetEventWeight());
817 // }
818 
819  Int_t etaRegion = -1, phiRegion = -1;
820  GetCaloUtils()->GetEMCALSubregion(cluster,GetReader()->GetEMCALCells(),etaRegion,phiRegion);
821  if(etaRegion >= 0 && etaRegion < 4 && phiRegion >=0 && phiRegion < 3)
822  {
823 
824  // fhLam0EMCALRegion[etaRegion][phiRegion]->Fill(pt,lambda0, GetEventWeight());
825  //
826  // if(GetFirstSMCoveredByTRD() >= 0 && sm >= GetFirstSMCoveredByTRD() )
827  // {
828  // fhLam0EMCALRegionTRD[etaRegion][phiRegion]->Fill(pt, lambda0, GetEventWeight());
829  // }
830 
831  fhLam0EMCALRegionPerSM[etaRegion][phiRegion][sm]->Fill(pt,lambda0, GetEventWeight());
832  fhLam1EMCALRegionPerSM[etaRegion][phiRegion][sm]->Fill(pt,lambda1, GetEventWeight());
833 
834 // if(shared)
835 // {
836 // fhLam0PerSMShared[sm]->Fill(pt,lambda0, GetEventWeight());
837 // fhLam1PerSMShared[sm]->Fill(pt,lambda1, GetEventWeight());
838 // }
839  }
840 
841  // Define l0 bin and cluster pt bin
842  Int_t l0bin = -1;
843  if ( lambda0 >=0.30 && lambda0 <= 0.40 ) l0bin = 1;
844  else if( lambda0 >=0.23 && lambda0 <= 0.26 ) l0bin = 0;
845 
846  Float_t ptLimit[] = {2,3,4,5,6,8,10,12};
847  Int_t ptbin = -1;
848  for(Int_t ipt = 0; ipt < 7; ipt++)
849  {
850  if( pt >= ptLimit[ipt] && pt < ptLimit[ipt+1] )
851  {
852  ptbin = ipt;
853  break;
854  }
855  }
856 
857  if(l0bin!=-1)
858  {
859  fhLam1Lam0BinPerSM[l0bin][sm]->Fill(pt,lambda1);
860 
861  if(ptbin >= 0)
862  {
863  fhEtaPhiLam0BinPtBin[l0bin][ptbin]->Fill(eta, phi, GetEventWeight());
864 // if(shared) fhEtaPhiLam0BinPtBinSMShared[l0bin][ptbin]->Fill(eta, phi, GetEventWeight());
865  }
866  }
867 
868  //
869  // Histograms with time of secondary cells, only if they contribute with a non null
870  // weight to the shower shape
871  //
872  AliVCaloCells* cells = GetReader()->GetEMCALCells();
873 
874  Int_t bc = GetReader()->GetInputEvent()->GetBunchCrossNumber();
875 
876  //
877  // Sort the cluster cells in energy, find maximum energy cell
878  //
879  Int_t ncell = cluster->GetNCells();
880  Int_t * sortList = new Int_t [ncell];
881  Float_t * enerList = new Float_t [ncell];
882  Double_t * timeList = new Double_t[ncell];
883 
884  for(Int_t icell = 0; icell < ncell; icell++)
885  {
886  Int_t absId = cluster->GetCellAbsId(icell);
887  Float_t cellE = cells->GetCellAmplitude(absId);
888  Double_t cellTime = cells->GetCellTime(absId);
889 
890  GetCaloUtils()->GetEMCALRecoUtils()->AcceptCalibrateCell(absId,bc,cellE,cellTime,cells);
891  cellTime*=1e9;
892  cellTime-=fConstantTimeShift;
893 
894  enerList[icell] = cellE;
895  timeList[icell] = cellTime;
896  }
897 
898  TMath::Sort(ncell,enerList,sortList);
899 
900  //
901  // Location of max cell
902  // First in sorted list.
903  //
904  Int_t absIdMax = cluster->GetCellAbsId(sortList[0]);
905  // Float_t cellEMax = enerList[sortList[0]];
906  Double_t cellTimeMax = timeList[sortList[0]];
907 
908  //
909  // Cluster cell loop, select only secondary cells with enough contribution to cluster
910  // Start from second highest energy cell
911  //
912  largeTime = 0;
913  Float_t largeTimeE = 0;
914  for(Int_t icell = 1; icell < ncell; icell++)
915  {
916  Int_t absId = cluster->GetCellAbsId(sortList[icell]);
917  Float_t cellE = enerList[sortList[icell]];
918  Double_t cellTime = timeList[sortList[icell]];
919 
920  //printf("\t icell %d, absId %d, ener %2.2f, time %2.2f, sort %d\n",icell,absId,cellE,cellTime,sortList[icell]);
921 
922  if ( absId == absIdMax ) continue;
923 
924  Float_t weight = GetCaloUtils()->GetEMCALRecoUtils()->GetCellWeight(cellE,cluster->E());
925 
926  //printf("Cluster E %2.2f, cell E %2.2f, time %2.2f, weight %2.3f\n",cluster->E(),cellE,cellTime,weight);
927  if(weight < 0.01) continue;
928 
929  if ( TMath::Abs(cellTime) > 50 )
930  {
931  largeTime++;
932  largeTimeE += cellE;
933  //printf(" cluster pT %2.2f, cell E %2.2f, large time %d; ",pt, cellE, largeTime);
934  }
935  if ( l0bin == -1 ) continue;
936 
937  fhTimeLam0BinPerSM [l0bin][sm]->Fill(pt, cellTime, GetEventWeight());
938  fhTimeLam0BinPerSMWeighted[l0bin][sm]->Fill(pt, cellTime, weight*GetEventWeight());
939 
940  fhDTimeLam0BinPerSM [l0bin][sm]->Fill(pt, cellTimeMax-cellTime, GetEventWeight());
941  fhDTimeLam0BinPerSMWeighted[l0bin][sm]->Fill(pt, cellTimeMax-cellTime, weight*GetEventWeight());
942 
943  fhCellClusterEFracLam0BinPerSM [l0bin][sm]->Fill(pt, cellE/cluster->E(), GetEventWeight());
944 // fhCellClusterEFracLam0BinPerSMWeighted[l0bin][sm]->Fill(pt, cellE/cluster->E(), weight*GetEventWeight());
945 
946  fhCellClusterELam0BinPerSM [l0bin][sm]->Fill(pt, cellE, GetEventWeight());
947  fhCellClusterELam0BinPerSMWeighted[l0bin][sm]->Fill(pt, cellE, weight*GetEventWeight());
948 
949  if(ptbin >= 0)
950  {
951  fhCellClusterIndexEAndTime[l0bin][ptbin] ->Fill(cellTime, icell , GetEventWeight());
952  fhCellClusterEAndTime [l0bin][ptbin] ->Fill(cellTime, cellE , GetEventWeight());
953  fhCellClusterEFracAndTime [l0bin][ptbin] ->Fill(cellTime, cellE/cluster->E(), GetEventWeight());
954  }
955 
956  if ( TMath::Abs(cellTime) > 50 )
957  {
958  fhCellClusterEFracLam0BinPerSMLargeTime [l0bin][sm]->Fill(pt, cellE/cluster->E(), GetEventWeight());
959  fhCellClusterELam0BinPerSMLargeTime [l0bin][sm]->Fill(pt, cellE , GetEventWeight());
960  fhCellClusterIndexELam0BinPerSMLargeTime[l0bin][sm]->Fill(pt, icell , GetEventWeight());
961  }
962 // if(shared)
963 // fhTimeLam0BinPerSMShared[l0bin][sm]->Fill(pt, cellTime, GetEventWeight());
964 
965  if(ptbin >= 0)
966  {
967  Int_t icol = -1, icolAbs = -1;
968  Int_t irow = -1, irowAbs = -1;
969  Int_t iRCU = -1;
970  GetModuleNumberCellIndexesAbsCaloMap(absId,GetCalorimeter(), icol, irow, iRCU, icolAbs, irowAbs);
971 
972  fhColRowLam0BinPtBin [l0bin][ptbin]->Fill(icolAbs, irowAbs, GetEventWeight());
973  fhColRowLam0BinPtBinWeighted[l0bin][ptbin]->Fill(icolAbs, irowAbs, weight*GetEventWeight());
974 
975  if ( TMath::Abs(cellTime) > 50 )
976  fhColRowLam0BinPtBinLargeTime[l0bin][ptbin]->Fill(icolAbs, irowAbs, GetEventWeight());
977 
978 // if(shared) fhColRowLam0BinPtBinSMShared[l0bin][ptbin]->Fill(icolAbs, irowAbs, GetEventWeight());
979  }
980 
981 
982  } // cluster cell loop
983  //if(largeTime > 0) printf("\n");
984 
985  if ( largeTime > 0 )
986  {
987  if ( l0bin != -1 )
988  {
989  if ( ptbin > 0 )
990  fhEtaPhiLargeTimeInClusterCell[l0bin][ptbin]->Fill(eta, phi, GetEventWeight());
991 
992  fhCellClusterEFracLam0BinPerSMLargeTimeTotal[l0bin][sm]->Fill(pt, largeTimeE/cluster->E(), GetEventWeight());
993  fhNCellsWithLargeTimeInCluster [l0bin][sm]->Fill(pt, largeTime , GetEventWeight());
994  }
995 
996  fhLam0PerSMLargeTimeInClusterCell[sm]->Fill(pt, lambda0, GetEventWeight());
997  fhLam1PerSMLargeTimeInClusterCell[sm]->Fill(pt, lambda1, GetEventWeight());
998 
999  if(largeTime < 6)
1000  {
1001  fhLam0PerNLargeTimeInClusterCell[largeTime-1]->Fill(pt, lambda0, GetEventWeight());
1002  fhLam1PerNLargeTimeInClusterCell[largeTime-1]->Fill(pt, lambda1, GetEventWeight());
1003  }
1004  }
1005 
1006  delete [] sortList ;
1007  delete [] enerList ;
1008  delete [] timeList ;
1009  //printf("Cluster %d, E %2.2f, sm %d, eta %2.2f, phi %2.2f ---> region %d %d\n",cluster->GetID(),cluster->E(),GetModuleNumber(cluster),eta,RadToDeg(phi),etaRegion,phiRegion);
1010  } // Check EMCal SM and regions
1011 
1012  Float_t l0 = 0., l1 = 0.;
1013  Float_t dispp= 0., dEta = 0., dPhi = 0.;
1014  Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
1015  if(GetCalorimeter() == kEMCAL && !fFillOnlySimpleSSHisto)
1016  {
1017  GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), GetReader()->GetInputEvent()->GetEMCALCells(), cluster,
1018  l0, l1, dispp, dEta, dPhi, sEta, sPhi, sEtaPhi);
1019  //printf("AliAnaPhoton::FillShowerShapeHistogram - l0 %2.6f, l1 %2.6f, disp %2.6f, dEta %2.6f, dPhi %2.6f, sEta %2.6f, sPhi %2.6f, sEtaPhi %2.6f \n",
1020  // l0, l1, dispp, dEta, dPhi, sEta, sPhi, sEtaPhi );
1021  //printf("AliAnaPhoton::FillShowerShapeHistogram - dispersion %f, dispersion eta+phi %f \n",
1022  // disp, dPhi+dEta );
1023  fhDispEtaE -> Fill(energy, dEta , GetEventWeight());
1024  fhDispPhiE -> Fill(energy, dPhi , GetEventWeight());
1025  fhSumEtaE -> Fill(energy, sEta , GetEventWeight());
1026  fhSumPhiE -> Fill(energy, sPhi , GetEventWeight());
1027  fhSumEtaPhiE -> Fill(energy, sEtaPhi , GetEventWeight());
1028  fhDispEtaPhiDiffE -> Fill(energy, dPhi-dEta, GetEventWeight());
1029 
1030  if(dEta+dPhi>0)fhSphericityE -> Fill(energy,(dPhi-dEta)/(dEta+dPhi) , GetEventWeight());
1031  if(dEta+sEta>0)fhDispSumEtaDiffE -> Fill(energy,(dEta-sEta)/((dEta+sEta)/2.), GetEventWeight());
1032  if(dPhi+sPhi>0)fhDispSumPhiDiffE -> Fill(energy,(dPhi-sPhi)/((dPhi+sPhi)/2.), GetEventWeight());
1033 
1034  Int_t ebin = -1;
1035  if (energy < 2 ) ebin = 0;
1036  else if (energy < 4 ) ebin = 1;
1037  else if (energy < 6 ) ebin = 2;
1038  else if (energy < 10) ebin = 3;
1039  else if (energy < 15) ebin = 4;
1040  else if (energy < 20) ebin = 5;
1041  else ebin = 6;
1042 
1043  fhDispEtaDispPhi[ebin]->Fill(dEta , dPhi, GetEventWeight());
1044  fhLambda0DispEta[ebin]->Fill(lambda0, dEta, GetEventWeight());
1045  fhLambda0DispPhi[ebin]->Fill(lambda0, dPhi, GetEventWeight());
1046  }
1047 
1048  // If track-matching was off, check effect of track-matching residual cut
1049 
1050  if(!fRejectTrackMatch)
1051  {
1052  Float_t dZ = cluster->GetTrackDz();
1053  Float_t dR = cluster->GetTrackDx();
1054 // if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
1055 // {
1056 // dR = 2000., dZ = 2000.;
1057 // GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
1058 // }
1059 
1060  if(TMath::Abs(dZ) < 0.05 && TMath::Abs(dR) < 0.05)
1061  {
1062  fhLam0ETM ->Fill(energy, lambda0, GetEventWeight());
1063  fhLam0PtTM->Fill(pt , lambda0, GetEventWeight());
1064  fhLam1ETM ->Fill(energy, lambda1, GetEventWeight());
1065  fhDispETM ->Fill(energy, disp , GetEventWeight());
1066 
1067  if(GetCalorimeter() == kEMCAL && GetFirstSMCoveredByTRD() >= 0 &&
1068  GetModuleNumber(cluster) >= GetFirstSMCoveredByTRD() )
1069  {
1070  fhLam0ETMTRD ->Fill(energy, lambda0, GetEventWeight());
1071  fhLam0PtTMTRD->Fill(pt , lambda0, GetEventWeight());
1072  fhLam1ETMTRD ->Fill(energy, lambda1, GetEventWeight());
1073  fhDispETMTRD ->Fill(energy, disp , GetEventWeight());
1074  }
1075  }
1076  } // If track-matching was off, check effect of matching residual cut
1077 
1078  if(!fFillOnlySimpleSSHisto)
1079  {
1080  if(energy < 2)
1081  {
1082  fhNCellsLam0LowE ->Fill(ncells, lambda0, GetEventWeight());
1083  fhNCellsLam1LowE ->Fill(ncells, lambda1, GetEventWeight());
1084  fhNCellsDispLowE ->Fill(ncells, disp , GetEventWeight());
1085 
1086  fhLam1Lam0LowE ->Fill(lambda1, lambda0, GetEventWeight());
1087  fhLam0DispLowE ->Fill(lambda0, disp , GetEventWeight());
1088  fhDispLam1LowE ->Fill(disp , lambda1, GetEventWeight());
1089  fhEtaLam0LowE ->Fill(eta , lambda0, GetEventWeight());
1090  fhPhiLam0LowE ->Fill(phi , lambda0, GetEventWeight());
1091  }
1092  else
1093  {
1094  fhNCellsLam0HighE ->Fill(ncells, lambda0, GetEventWeight());
1095  fhNCellsLam1HighE ->Fill(ncells, lambda1, GetEventWeight());
1096  fhNCellsDispHighE ->Fill(ncells, disp , GetEventWeight());
1097 
1098  fhLam1Lam0HighE ->Fill(lambda1, lambda0, GetEventWeight());
1099  fhLam0DispHighE ->Fill(lambda0, disp , GetEventWeight());
1100  fhDispLam1HighE ->Fill(disp , lambda1, GetEventWeight());
1101  fhEtaLam0HighE ->Fill(eta , lambda0, GetEventWeight());
1102  fhPhiLam0HighE ->Fill(phi , lambda0, GetEventWeight());
1103  }
1104  }
1105 
1106  if(IsDataMC())
1107  {
1108  AliVCaloCells* cells = 0;
1109  if(GetCalorimeter() == kEMCAL) cells = GetEMCALCells();
1110  else cells = GetPHOSCells();
1111 
1112  // Fill histograms to check shape of embedded clusters
1113  Float_t fraction = 0;
1114  // printf("check embedding %i\n",GetReader()->IsEmbeddedClusterSelectionOn());
1115 
1116  if(GetReader()->IsEmbeddedClusterSelectionOn())
1117  {
1118  // Only working for EMCAL
1119  // printf("embedded\n");
1120 
1121  Float_t clusterE = 0; // recalculate in case corrections applied.
1122  Float_t cellE = 0;
1123  for(Int_t icell = 0; icell < cluster->GetNCells(); icell++)
1124  {
1125  cellE = cells->GetCellAmplitude(cluster->GetCellAbsId(icell));
1126  clusterE+=cellE;
1127  fraction+=cellE*cluster->GetCellAmplitudeFraction(icell);
1128  }
1129 
1130  //Fraction of total energy due to the embedded signal
1131  fraction/=clusterE;
1132 
1133  AliDebug(1,Form("Energy fraction of embedded signal %2.3f, Energy %2.3f",fraction, clusterE));
1134 
1135  fhEmbeddedSignalFractionEnergy->Fill(clusterE, fraction, GetEventWeight());
1136  } // embedded fraction
1137 
1138  // Check the origin and fill histograms
1139 
1140  Int_t mcIndex = -1;
1141 
1142  if( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) &&
1143  !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) &&
1144  !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) &&
1145  !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta))
1146  {
1147  mcIndex = kmcssPhoton ;
1148 
1149  if(!GetReader()->IsEmbeddedClusterSelectionOn())
1150  {
1151  //Check particle overlaps in cluster
1152 
1153  // Compare the primary depositing more energy with the rest,
1154  // if no photon/electron as comon ancestor (conversions), count as other particle
1155  const UInt_t nlabels = cluster->GetNLabels();
1156  Int_t overpdg[nlabels];
1157  Int_t noverlaps = GetMCAnalysisUtils()->GetNOverlaps(cluster->GetLabels(), nlabels,mcTag,-1,GetReader(),overpdg);
1158 
1159  //printf("N overlaps %d \n",noverlaps);
1160 
1161  if(noverlaps == 0)
1162  {
1163  fhMCPhotonELambda0NoOverlap ->Fill(energy, lambda0, GetEventWeight());
1164  }
1165  else if(noverlaps == 1)
1166  {
1167  fhMCPhotonELambda0TwoOverlap ->Fill(energy, lambda0, GetEventWeight());
1168  }
1169  else if(noverlaps > 1)
1170  {
1171  fhMCPhotonELambda0NOverlap ->Fill(energy, lambda0, GetEventWeight());
1172  }
1173  else
1174  {
1175  AliWarning(Form("n overlaps = %d!!", noverlaps));
1176  }
1177  } // No embedding
1178 
1179  // Fill histograms to check shape of embedded clusters
1180  if(GetReader()->IsEmbeddedClusterSelectionOn())
1181  {
1182  if (fraction > 0.9)
1183  {
1184  fhEmbedPhotonELambda0FullSignal ->Fill(energy, lambda0, GetEventWeight());
1185  }
1186  else if(fraction > 0.5)
1187  {
1188  fhEmbedPhotonELambda0MostlySignal ->Fill(energy, lambda0, GetEventWeight());
1189  }
1190  else if(fraction > 0.1)
1191  {
1192  fhEmbedPhotonELambda0MostlyBkg ->Fill(energy, lambda0, GetEventWeight());
1193  }
1194  else
1195  {
1196  fhEmbedPhotonELambda0FullBkg ->Fill(energy, lambda0, GetEventWeight());
1197  }
1198  } // embedded
1199  } // photon no conversion
1200  else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPhoton) &&
1201  GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCConversion) &&
1202  !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) &&
1203  !GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta))
1204  {
1205  mcIndex = kmcssConversion ;
1206  }//conversion photon
1207 
1208  else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCElectron))
1209  {
1210  mcIndex = kmcssElectron ;
1211  }//electron
1212  else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCPi0) )
1213  {
1214  mcIndex = kmcssPi0 ;
1215 
1216  //Fill histograms to check shape of embedded clusters
1217  if(GetReader()->IsEmbeddedClusterSelectionOn())
1218  {
1219  if (fraction > 0.9)
1220  {
1221  fhEmbedPi0ELambda0FullSignal ->Fill(energy, lambda0, GetEventWeight());
1222  }
1223  else if(fraction > 0.5)
1224  {
1225  fhEmbedPi0ELambda0MostlySignal ->Fill(energy, lambda0, GetEventWeight());
1226  }
1227  else if(fraction > 0.1)
1228  {
1229  fhEmbedPi0ELambda0MostlyBkg ->Fill(energy, lambda0, GetEventWeight());
1230  }
1231  else
1232  {
1233  fhEmbedPi0ELambda0FullBkg ->Fill(energy, lambda0, GetEventWeight());
1234  }
1235  } // embedded
1236 
1237  }//pi0
1238  else if ( GetMCAnalysisUtils()->CheckTagBit(mcTag,AliMCAnalysisUtils::kMCEta) )
1239  {
1240  mcIndex = kmcssEta ;
1241  }//eta
1242  else
1243  {
1244  mcIndex = kmcssOther ;
1245  }//other particles
1246 
1247  fhMCELambda0 [mcIndex]->Fill(energy, lambda0, GetEventWeight());
1248  fhMCPtLambda0 [mcIndex]->Fill(pt , lambda0, GetEventWeight());
1249  fhMCELambda1 [mcIndex]->Fill(energy, lambda1, GetEventWeight());
1250  fhMCEDispersion [mcIndex]->Fill(energy, disp , GetEventWeight());
1251  fhMCNCellsE [mcIndex]->Fill(energy, ncells , GetEventWeight());
1252  fhMCMaxCellDiffClusterE[mcIndex]->Fill(energy, maxCellFraction, GetEventWeight());
1253 
1254  if(!fFillOnlySimpleSSHisto)
1255  {
1256  if (energy < 2.)
1257  {
1258  fhMCLambda0vsClusterMaxCellDiffE0[mcIndex]->Fill(lambda0, maxCellFraction, GetEventWeight());
1259  fhMCNCellsvsClusterMaxCellDiffE0 [mcIndex]->Fill(ncells, maxCellFraction, GetEventWeight());
1260  }
1261  else if(energy < 6.)
1262  {
1263  fhMCLambda0vsClusterMaxCellDiffE2[mcIndex]->Fill(lambda0, maxCellFraction, GetEventWeight());
1264  fhMCNCellsvsClusterMaxCellDiffE2 [mcIndex]->Fill(ncells, maxCellFraction, GetEventWeight());
1265  }
1266  else
1267  {
1268  fhMCLambda0vsClusterMaxCellDiffE6[mcIndex]->Fill(lambda0, maxCellFraction, GetEventWeight());
1269  fhMCNCellsvsClusterMaxCellDiffE6 [mcIndex]->Fill(ncells, maxCellFraction, GetEventWeight());
1270  }
1271 
1272  if(GetCalorimeter() == kEMCAL)
1273  {
1274  fhMCEDispEta [mcIndex]-> Fill(energy, dEta , GetEventWeight());
1275  fhMCEDispPhi [mcIndex]-> Fill(energy, dPhi , GetEventWeight());
1276  fhMCESumEtaPhi [mcIndex]-> Fill(energy, sEtaPhi , GetEventWeight());
1277  fhMCEDispEtaPhiDiff [mcIndex]-> Fill(energy, dPhi-dEta, GetEventWeight());
1278 
1279  if( dEta+dPhi > 0 ) fhMCESphericity[mcIndex]-> Fill(energy, (dPhi-dEta)/(dEta+dPhi), GetEventWeight());
1280 
1281  Int_t ebin = -1;
1282  if (energy < 2 ) ebin = 0;
1283  else if (energy < 4 ) ebin = 1;
1284  else if (energy < 6 ) ebin = 2;
1285  else if (energy < 10) ebin = 3;
1286  else if (energy < 15) ebin = 4;
1287  else if (energy < 20) ebin = 5;
1288  else ebin = 6;
1289 
1290  fhMCDispEtaDispPhi[ebin][mcIndex]->Fill(dEta , dPhi, GetEventWeight());
1291  fhMCLambda0DispEta[ebin][mcIndex]->Fill(lambda0, dEta, GetEventWeight());
1292  fhMCLambda0DispPhi[ebin][mcIndex]->Fill(lambda0, dPhi, GetEventWeight());
1293  }
1294  }
1295  }// MC data
1296 }
1297 
1298 //__________________________________________________________________________
1304 //__________________________________________________________________________
1305 void AliAnaPhoton::FillTrackMatchingResidualHistograms(AliVCluster* cluster,
1306  Int_t cut)
1307 {
1308  Float_t dZ = cluster->GetTrackDz();
1309  Float_t dR = cluster->GetTrackDx();
1310 
1311 // if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
1312 // {
1313 // dR = 2000., dZ = 2000.;
1314 // GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
1315 // }
1316 
1317  AliVTrack *track = GetCaloUtils()->GetMatchedTrack(cluster, GetReader()->GetInputEvent());
1318 
1319  Bool_t positive = kFALSE;
1320  if(track) positive = (track->Charge()>0);
1321 
1322  if(fhTrackMatchedDEta[cut] && TMath::Abs(dR) < 999)
1323  {
1324  fhTrackMatchedDEta[cut]->Fill(cluster->E(), dZ, GetEventWeight());
1325  fhTrackMatchedDPhi[cut]->Fill(cluster->E(), dR, GetEventWeight());
1326  if(cluster->E() > 0.5) fhTrackMatchedDEtaDPhi[cut]->Fill(dZ, dR, GetEventWeight());
1327 
1328  if(track)
1329  {
1330  if(positive)
1331  {
1332  fhTrackMatchedDEtaPos[cut]->Fill(cluster->E(), dZ, GetEventWeight());
1333  fhTrackMatchedDPhiPos[cut]->Fill(cluster->E(), dR, GetEventWeight());
1334  if(cluster->E() > 0.5) fhTrackMatchedDEtaDPhiPos[cut]->Fill(dZ,dR, GetEventWeight());
1335  }
1336  else
1337  {
1338  fhTrackMatchedDEtaNeg[cut]->Fill(cluster->E(), dZ, GetEventWeight());
1339  fhTrackMatchedDPhiNeg[cut]->Fill(cluster->E(), dR, GetEventWeight());
1340  if(cluster->E() > 0.5) fhTrackMatchedDEtaDPhiNeg[cut]->Fill(dZ, dR, GetEventWeight());
1341  }
1342  }
1343 
1344  Int_t nSMod = GetModuleNumber(cluster);
1345 
1346  if( GetCalorimeter() == kEMCAL && GetFirstSMCoveredByTRD() >= 0 &&
1347  nSMod >= GetFirstSMCoveredByTRD() )
1348  {
1349  fhTrackMatchedDEtaTRD[cut]->Fill(cluster->E(), dZ, GetEventWeight());
1350  fhTrackMatchedDPhiTRD[cut]->Fill(cluster->E(), dR, GetEventWeight());
1351  }
1352 
1353  // Check dEdx and E/p of matched clusters
1354 
1355  if(TMath::Abs(dZ) < 0.05 && TMath::Abs(dR) < 0.05)
1356  {
1357  if(track)
1358  {
1359  Float_t dEdx = track->GetTPCsignal();
1360  Float_t eOverp = cluster->E()/track->P();
1361 
1362  fhdEdx[cut] ->Fill(cluster->E(), dEdx , GetEventWeight());
1363  fhEOverP[cut]->Fill(cluster->E(), eOverp, GetEventWeight());
1364 
1365  if(GetCalorimeter()==kEMCAL && GetFirstSMCoveredByTRD() >= 0 &&
1366  nSMod >= GetFirstSMCoveredByTRD() )
1367  fhEOverPTRD[cut]->Fill(cluster->E(), eOverp, GetEventWeight());
1368 
1369 
1370  }
1371  else
1372  AliWarning(Form("Residual OK but (dR, dZ)= (%2.4f,%2.4f) no track associated WHAT?", dR,dZ));
1373 
1374  if(IsDataMC())
1375  {
1376 
1377  Int_t tag = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(),GetReader(),GetCalorimeter());
1378 
1379  if ( !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion) )
1380  {
1381  if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ||
1382  GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) )
1383  fhTrackMatchedMCParticle[cut]->Fill(cluster->E(), 2.5, GetEventWeight());
1384  else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) )
1385  fhTrackMatchedMCParticle[cut]->Fill(cluster->E(), 0.5, GetEventWeight());
1386  else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron) )
1387  fhTrackMatchedMCParticle[cut]->Fill(cluster->E(), 1.5, GetEventWeight());
1388  else
1389  fhTrackMatchedMCParticle[cut]->Fill(cluster->E(), 3.5, GetEventWeight());
1390 
1391  // Check if several particles contributed to cluster and discard overlapped mesons
1392  if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ||
1393  !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta))
1394  {
1395  if(cluster->GetNLabels()==1)
1396  {
1397  fhTrackMatchedDEtaMCNoOverlap[cut]->Fill(cluster->E(), dZ, GetEventWeight());
1398  fhTrackMatchedDPhiMCNoOverlap[cut]->Fill(cluster->E(), dR, GetEventWeight());
1399  }
1400  else
1401  {
1402  fhTrackMatchedDEtaMCOverlap[cut]->Fill(cluster->E(), dZ, GetEventWeight());
1403  fhTrackMatchedDPhiMCOverlap[cut]->Fill(cluster->E(), dR, GetEventWeight());
1404  }
1405 
1406  }// Check overlaps
1407 
1408  }
1409  else
1410  {
1411  if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ||
1412  GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) )
1413  fhTrackMatchedMCParticle[cut]->Fill(cluster->E(), 6.5, GetEventWeight());
1414  else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) )
1415  fhTrackMatchedMCParticle[cut]->Fill(cluster->E(), 4.5, GetEventWeight());
1416  else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron) )
1417  fhTrackMatchedMCParticle[cut]->Fill(cluster->E(), 5.5, GetEventWeight());
1418  else
1419  fhTrackMatchedMCParticle[cut]->Fill(cluster->E(), 7.5, GetEventWeight());
1420 
1421  // Check if several particles contributed to cluster
1422  if(!GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ||
1423  !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta))
1424  {
1425  fhTrackMatchedDEtaMCConversion[cut]->Fill(cluster->E(), dZ, GetEventWeight());
1426  fhTrackMatchedDPhiMCConversion[cut]->Fill(cluster->E(), dR, GetEventWeight());
1427 
1428  }// Check overlaps
1429 
1430  }
1431 
1432  } // MC
1433 
1434  } // residuals window
1435 
1436  } // Small residual
1437 }
1438 
1439 //___________________________________________
1441 //___________________________________________
1442 TObjString * AliAnaPhoton::GetAnalysisCuts()
1443 {
1444  TString parList ; //this will be list of parameters used for this analysis.
1445  const Int_t buffersize = 255;
1446  char onePar[buffersize] ;
1447 
1448  snprintf(onePar,buffersize,"--- AliAnaPhoton ---:") ;
1449  parList+=onePar ;
1450  snprintf(onePar,buffersize,"Calorimeter: %s;",GetCalorimeterString().Data()) ;
1451  parList+=onePar ;
1452  snprintf(onePar,buffersize,"fMinDist =%2.2f (Minimal distance to bad channel to accept cluster);",fMinDist) ;
1453  parList+=onePar ;
1454  snprintf(onePar,buffersize,"fMinDist2=%2.2f (Cuts on Minimal distance to study acceptance evaluation);",fMinDist2) ;
1455  parList+=onePar ;
1456  snprintf(onePar,buffersize,"fMinDist3=%2.2f (One more cut on distance used for acceptance-efficiency study);",fMinDist3) ;
1457  parList+=onePar ;
1458  snprintf(onePar,buffersize,"fRejectTrackMatch: %d",fRejectTrackMatch) ;
1459  parList+=onePar ;
1460 
1461  // Get parameters set in base class.
1462  parList += GetBaseParametersList() ;
1463 
1464  // Get parameters set in PID class.
1465  parList += GetCaloPID()->GetPIDParametersList() ;
1466 
1467  // Get parameters set in FiducialCut class (not available yet)
1468  //parlist += GetFidCut()->GetFidCutParametersList()
1469 
1470  return new TObjString(parList) ;
1471 }
1472 
1473 //_____________________________________________
1476 //_____________________________________________
1477 TList * AliAnaPhoton::GetCreateOutputObjects()
1478 {
1479  TList * outputContainer = new TList() ;
1480  outputContainer->SetName("PhotonHistos") ;
1481 
1482  Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t ptmin = GetHistogramRanges()->GetHistoPtMin();
1483  Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin();
1484  Int_t netabins = GetHistogramRanges()->GetHistoEtaBins(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin();
1485  Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins(); Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax(); Float_t ssmin = GetHistogramRanges()->GetHistoShowerShapeMin();
1486  Int_t nbins = GetHistogramRanges()->GetHistoNClusterCellBins(); Int_t nmax = GetHistogramRanges()->GetHistoNClusterCellMax(); Int_t nmin = GetHistogramRanges()->GetHistoNClusterCellMin();
1487  Int_t ntimebins= GetHistogramRanges()->GetHistoTimeBins(); Float_t timemax = GetHistogramRanges()->GetHistoTimeMax(); Float_t timemin = GetHistogramRanges()->GetHistoTimeMin();
1488 
1489  Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
1490  Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
1491  Float_t resetamin = GetHistogramRanges()->GetHistoTrackResidualEtaMin();
1492  Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
1493  Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
1494  Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
1495 
1496  Int_t ndedxbins = GetHistogramRanges()->GetHistodEdxBins();
1497  Float_t dedxmax = GetHistogramRanges()->GetHistodEdxMax();
1498  Float_t dedxmin = GetHistogramRanges()->GetHistodEdxMin();
1499  Int_t nPoverEbins = GetHistogramRanges()->GetHistoPOverEBins();
1500  Float_t pOverEmax = GetHistogramRanges()->GetHistoPOverEMax();
1501  Float_t pOverEmin = GetHistogramRanges()->GetHistoPOverEMin();
1502 
1503  Int_t bin[] = {0,2,4,6,10,15,20,100}; // energy bins for SS studies
1504 
1505  TString cut[] = {"Open","Reader","E","Time","NCells","NLM","Fidutial","Matching","Bad","PID"};
1506  for (Int_t i = 0; i < 10 ; i++)
1507  {
1508  fhClusterCutsE[i] = new TH1F(Form("hE_Cut_%d_%s", i, cut[i].Data()),
1509  Form("Number of clusters that pass cuts <= %d, %s", i, cut[i].Data()),
1510  nptbins,ptmin,ptmax);
1511  fhClusterCutsE[i]->SetYTitle("d#it{N}/d#it{E} ");
1512  fhClusterCutsE[i]->SetXTitle("#it{E} (GeV)");
1513  outputContainer->Add(fhClusterCutsE[i]) ;
1514 
1515  fhClusterCutsPt[i] = new TH1F(Form("hPt_Cut_%d_%s", i, cut[i].Data()),
1516  Form("Number of clusters that pass cuts <= %d, %s", i, cut[i].Data()),
1517  nptbins,ptmin,ptmax);
1518  fhClusterCutsPt[i]->SetYTitle("d#it{N}/d#it{E} ");
1519  fhClusterCutsPt[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1520  outputContainer->Add(fhClusterCutsPt[i]) ;
1521  }
1522 
1523  fhEClusterSM = new TH2F("hEClusterSM","Raw clusters E and super-module number",
1524  nptbins,ptmin,ptmax,
1525  GetCaloUtils()->GetNumberOfSuperModulesUsed(),0,GetCaloUtils()->GetNumberOfSuperModulesUsed());
1526  fhEClusterSM->SetYTitle("SuperModule ");
1527  fhEClusterSM->SetXTitle("#it{E} (GeV)");
1528  outputContainer->Add(fhEClusterSM) ;
1529 
1530  fhPtClusterSM = new TH2F("hPtClusterSM","Raw clusters #it{p}_{T} and super-module number",
1531  nptbins,ptmin,ptmax,
1532  GetCaloUtils()->GetNumberOfSuperModulesUsed(),0,GetCaloUtils()->GetNumberOfSuperModulesUsed());
1533  fhPtClusterSM->SetYTitle("SuperModule ");
1534  fhPtClusterSM->SetXTitle("#it{E} (GeV)");
1535  outputContainer->Add(fhPtClusterSM) ;
1536 
1537  fhEPhotonSM = new TH2F("hEPhotonSM","Selected clusters E and super-module number",
1538  nptbins,ptmin,ptmax,
1539  GetCaloUtils()->GetNumberOfSuperModulesUsed(),0,GetCaloUtils()->GetNumberOfSuperModulesUsed());
1540  fhEPhotonSM->SetYTitle("SuperModule ");
1541  fhEPhotonSM->SetXTitle("#it{E} (GeV)");
1542  outputContainer->Add(fhEPhotonSM) ;
1543 
1544  fhPtPhotonSM = new TH2F("hPtPhotonSM","Selected clusters #it{p}_{T} and super-module number",
1545  nptbins,ptmin,ptmax,
1546  GetCaloUtils()->GetNumberOfSuperModulesUsed(),0,GetCaloUtils()->GetNumberOfSuperModulesUsed());
1547  fhPtPhotonSM->SetYTitle("SuperModule ");
1548  fhPtPhotonSM->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1549  outputContainer->Add(fhPtPhotonSM) ;
1550 
1551  fhNCellsE = new TH2F ("hNCellsE","# of cells in cluster vs E of clusters", nptbins,ptmin,ptmax, nbins,nmin,nmax);
1552  fhNCellsE->SetXTitle("#it{E} (GeV)");
1553  fhNCellsE->SetYTitle("# of cells in cluster");
1554  outputContainer->Add(fhNCellsE);
1555 
1556  fhCellsE = new TH2F ("hCellsE","energy of cells in cluster vs E of clusters", nptbins,ptmin,ptmax, nptbins*2,ptmin,ptmax);
1557  fhCellsE->SetXTitle("#it{E}_{cluster} (GeV)");
1558  fhCellsE->SetYTitle("#it{E}_{cell} (GeV)");
1559  outputContainer->Add(fhCellsE);
1560 
1561  fhTimePt = new TH2F ("hTimePt","time of cluster vs pT of clusters", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
1562  fhTimePt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1563  fhTimePt->SetYTitle("#it{time} (ns)");
1564  outputContainer->Add(fhTimePt);
1565 
1566  fhMaxCellDiffClusterE = new TH2F ("hMaxCellDiffClusterE","energy vs difference of cluster energy - max cell energy / cluster energy, good clusters",
1567  nptbins,ptmin,ptmax, 500,0,1.);
1568  fhMaxCellDiffClusterE->SetXTitle("#it{E}_{cluster} (GeV) ");
1569  fhMaxCellDiffClusterE->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
1570  outputContainer->Add(fhMaxCellDiffClusterE);
1571 
1572  fhEPhoton = new TH1F("hEPhoton","Number of #gamma over calorimeter vs energy",nptbins,ptmin,ptmax);
1573  fhEPhoton->SetYTitle("#it{counts}");
1574  fhEPhoton->SetXTitle("#it{E}_{#gamma}(GeV)");
1575  outputContainer->Add(fhEPhoton) ;
1576 
1577  fhPtPhoton = new TH1F("hPtPhoton","Number of #gamma over calorimeter vs #it{p}_{T}",nptbins,ptmin,ptmax);
1578  fhPtPhoton->SetYTitle("#it{counts}");
1579  fhPtPhoton->SetXTitle("p_{T #gamma}(GeV/#it{c})");
1580  outputContainer->Add(fhPtPhoton) ;
1581 
1582  if(IsHighMultiplicityAnalysisOn())
1583  {
1584  fhPtCentralityPhoton = new TH2F("hPtCentralityPhoton","centrality vs #it{p}_{T}",nptbins,ptmin,ptmax, 100,0,100);
1585  fhPtCentralityPhoton->SetYTitle("Centrality");
1586  fhPtCentralityPhoton->SetXTitle("#it{p}_{T}(GeV/#it{c})");
1587  outputContainer->Add(fhPtCentralityPhoton) ;
1588 
1589  fhPtEventPlanePhoton = new TH2F("hPtEventPlanePhoton","centrality vs #it{p}_{T}",nptbins,ptmin,ptmax, 100,0,TMath::Pi());
1590  fhPtEventPlanePhoton->SetYTitle("Event plane angle (rad)");
1591  fhPtEventPlanePhoton->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1592  outputContainer->Add(fhPtEventPlanePhoton) ;
1593  }
1594 
1595  fhEtaPhi = new TH2F
1596  ("hEtaPhi","cluster,#it{E} > 0.5 GeV, #eta vs #phi",netabins,etamin,etamax,nphibins,phimin,phimax);
1597  fhEtaPhi->SetYTitle("#phi (rad)");
1598  fhEtaPhi->SetXTitle("#eta");
1599  outputContainer->Add(fhEtaPhi) ;
1600 
1601  fhPhiPhoton = new TH2F
1602  ("hPhiPhoton","#phi_{#gamma} vs #it{p}_{T}",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
1603  fhPhiPhoton->SetYTitle("#phi (rad)");
1604  fhPhiPhoton->SetXTitle("p_{T #gamma} (GeV/#it{c})");
1605  outputContainer->Add(fhPhiPhoton) ;
1606 
1607  fhEtaPhoton = new TH2F
1608  ("hEtaPhoton","#eta_{#gamma} vs #it{p}_{T}",nptbins,ptmin,ptmax,netabins,etamin,etamax);
1609  fhEtaPhoton->SetYTitle("#eta");
1610  fhEtaPhoton->SetXTitle("p_{T #gamma} (GeV/#it{c})");
1611  outputContainer->Add(fhEtaPhoton) ;
1612 
1613  fhEtaPhiPhoton = new TH2F
1614  ("hEtaPhiPhoton","#eta vs #phi",netabins,etamin,etamax,nphibins,phimin,phimax);
1615  fhEtaPhiPhoton->SetYTitle("#phi (rad)");
1616  fhEtaPhiPhoton->SetXTitle("#eta");
1617  outputContainer->Add(fhEtaPhiPhoton) ;
1618  if(GetMinPt() < 0.5)
1619  {
1620  fhEtaPhi05Photon = new TH2F
1621  ("hEtaPhi05Photon","#eta vs #phi, E < 0.5",netabins,etamin,etamax,nphibins,phimin,phimax);
1622  fhEtaPhi05Photon->SetYTitle("#phi (rad)");
1623  fhEtaPhi05Photon->SetXTitle("#eta");
1624  outputContainer->Add(fhEtaPhi05Photon) ;
1625  }
1626 
1627  fhNLocMax = new TH2F("hNLocMax","Number of local maxima in cluster",
1628  nptbins,ptmin,ptmax,10,0,10);
1629  fhNLocMax ->SetYTitle("N maxima");
1630  fhNLocMax ->SetXTitle("#it{E} (GeV)");
1631  outputContainer->Add(fhNLocMax) ;
1632 
1633  //Shower shape
1634  if(fFillSSHistograms)
1635  {
1636  fhLam0E = new TH2F ("hLam0E","#lambda_{0}^{2} vs E", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1637  fhLam0E->SetYTitle("#lambda_{0}^{2}");
1638  fhLam0E->SetXTitle("#it{E} (GeV)");
1639  outputContainer->Add(fhLam0E);
1640 
1641  fhLam0Pt = new TH2F ("hLam0Pt","#lambda_{0}^{2} vs #it{p}_{T}", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1642  fhLam0Pt->SetYTitle("#lambda_{0}^{2}");
1643  fhLam0Pt->SetXTitle("#it{p}_{T} (GeV)");
1644  outputContainer->Add(fhLam0Pt);
1645 
1646  fhLam1E = new TH2F ("hLam1E","#lambda_{1}^{2} vs E", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1647  fhLam1E->SetYTitle("#lambda_{1}^{2}");
1648  fhLam1E->SetXTitle("#it{E} (GeV)");
1649  outputContainer->Add(fhLam1E);
1650 
1651  fhDispE = new TH2F ("hDispE"," dispersion^{2} vs E", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1652  fhDispE->SetYTitle("D^{2}");
1653  fhDispE->SetXTitle("#it{E} (GeV) ");
1654  outputContainer->Add(fhDispE);
1655 
1656  if(!fRejectTrackMatch)
1657  {
1658  fhLam0ETM = new TH2F ("hLam0ETM","#lambda_{0}^{2} vs E, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1659  fhLam0ETM->SetYTitle("#lambda_{0}^{2}");
1660  fhLam0ETM->SetXTitle("#it{E} (GeV)");
1661  outputContainer->Add(fhLam0ETM);
1662 
1663  fhLam0PtTM = new TH2F ("hLam0PtTM","#lambda_{0}^{2} vs #it{p}_{T}, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1664  fhLam0PtTM->SetYTitle("#lambda_{0}^{2}");
1665  fhLam0PtTM->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1666  outputContainer->Add(fhLam0PtTM);
1667 
1668  fhLam1ETM = new TH2F ("hLam1ETM","#lambda_{1}^{2} vs E, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1669  fhLam1ETM->SetYTitle("#lambda_{1}^{2}");
1670  fhLam1ETM->SetXTitle("#it{E} (GeV)");
1671  outputContainer->Add(fhLam1ETM);
1672 
1673  fhDispETM = new TH2F ("hDispETM"," dispersion^{2} vs E, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1674  fhDispETM->SetYTitle("D^{2}");
1675  fhDispETM->SetXTitle("#it{E} (GeV) ");
1676  outputContainer->Add(fhDispETM);
1677  }
1678 
1679  if(GetCalorimeter() == kEMCAL && GetFirstSMCoveredByTRD() >= 0)
1680  {
1681  fhLam0ETRD = new TH2F ("hLam0ETRD","#lambda_{0}^{2} vs E, EMCAL SM covered by TRD", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1682  fhLam0ETRD->SetYTitle("#lambda_{0}^{2}");
1683  fhLam0ETRD->SetXTitle("#it{E} (GeV)");
1684  outputContainer->Add(fhLam0ETRD);
1685 
1686  fhLam0PtTRD = new TH2F ("hLam0PtTRD","#lambda_{0}^{2} vs #it{p}_{T}, EMCAL SM covered by TRD", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1687  fhLam0PtTRD->SetYTitle("#lambda_{0}^{2}");
1688  fhLam0PtTRD->SetXTitle("#it{E} (GeV)");
1689  outputContainer->Add(fhLam0PtTRD);
1690 
1691  fhLam1ETRD = new TH2F ("hLam1ETRD","#lambda_{1}^{2} vs E, EMCAL SM covered by TRD", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1692  fhLam1ETRD->SetYTitle("#lambda_{1}^{2}");
1693  fhLam1ETRD->SetXTitle("#it{E} (GeV)");
1694  outputContainer->Add(fhLam1ETRD);
1695 
1696  fhDispETRD = new TH2F ("hDispETRD"," dispersion^{2} vs E, EMCAL SM covered by TRD", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1697  fhDispETRD->SetYTitle("Dispersion^{2}");
1698  fhDispETRD->SetXTitle("#it{E} (GeV) ");
1699  outputContainer->Add(fhDispETRD);
1700 
1701  if(!fRejectTrackMatch && GetFirstSMCoveredByTRD() >=0 )
1702  {
1703  fhLam0ETMTRD = new TH2F ("hLam0ETMTRD","#lambda_{0}^{2} vs E, EMCAL SM covered by TRD, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1704  fhLam0ETMTRD->SetYTitle("#lambda_{0}^{2}");
1705  fhLam0ETMTRD->SetXTitle("#it{E} (GeV)");
1706  outputContainer->Add(fhLam0ETMTRD);
1707 
1708  fhLam0PtTMTRD = new TH2F ("hLam0PtTMTRD","#lambda_{0}^{2} vs #it{p}_{T}, EMCAL SM covered by TRD, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1709  fhLam0PtTMTRD->SetYTitle("#lambda_{0}^{2}");
1710  fhLam0PtTMTRD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
1711  outputContainer->Add(fhLam0PtTMTRD);
1712 
1713  fhLam1ETMTRD = new TH2F ("hLam1ETMTRD","#lambda_{1}^{2} vs E, EMCAL SM covered by TRD, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1714  fhLam1ETMTRD->SetYTitle("#lambda_{1}^{2}");
1715  fhLam1ETMTRD->SetXTitle("#it{E} (GeV)");
1716  outputContainer->Add(fhLam1ETMTRD);
1717 
1718  fhDispETMTRD = new TH2F ("hDispETMTRD"," dispersion^{2} vs E, EMCAL SM covered by TRD, cut on track-matching residual |#Delta #eta| < 0.05, |#Delta #phi| < 0.05", nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1719  fhDispETMTRD->SetYTitle("Dispersion^{2}");
1720  fhDispETMTRD->SetXTitle("#it{E} (GeV) ");
1721  outputContainer->Add(fhDispETMTRD);
1722  }
1723  }
1724 
1725  if(!fFillOnlySimpleSSHisto)
1726  {
1727  fhNCellsLam0LowE = new TH2F ("hNCellsLam0LowE","N_{cells} in cluster vs #lambda_{0}^{2}, E < 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
1728  fhNCellsLam0LowE->SetXTitle("N_{cells}");
1729  fhNCellsLam0LowE->SetYTitle("#lambda_{0}^{2}");
1730  outputContainer->Add(fhNCellsLam0LowE);
1731 
1732  fhNCellsLam0HighE = new TH2F ("hNCellsLam0HighE","N_{cells} in cluster vs #lambda_{0}^{2}, #it{E} > 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
1733  fhNCellsLam0HighE->SetXTitle("N_{cells}");
1734  fhNCellsLam0HighE->SetYTitle("#lambda_{0}^{2}");
1735  outputContainer->Add(fhNCellsLam0HighE);
1736 
1737  fhNCellsLam1LowE = new TH2F ("hNCellsLam1LowE","N_{cells} in cluster vs #lambda_{1}^{2}, E < 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
1738  fhNCellsLam1LowE->SetXTitle("N_{cells}");
1739  fhNCellsLam1LowE->SetYTitle("#lambda_{0}^{2}");
1740  outputContainer->Add(fhNCellsLam1LowE);
1741 
1742  fhNCellsLam1HighE = new TH2F ("hNCellsLam1HighE","N_{cells} in cluster vs #lambda_{1}^{2}, #it{E} > 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
1743  fhNCellsLam1HighE->SetXTitle("N_{cells}");
1744  fhNCellsLam1HighE->SetYTitle("#lambda_{0}^{2}");
1745  outputContainer->Add(fhNCellsLam1HighE);
1746 
1747  fhNCellsDispLowE = new TH2F ("hNCellsDispLowE","N_{cells} in cluster vs dispersion^{2}, E < 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
1748  fhNCellsDispLowE->SetXTitle("N_{cells}");
1749  fhNCellsDispLowE->SetYTitle("D^{2}");
1750  outputContainer->Add(fhNCellsDispLowE);
1751 
1752  fhNCellsDispHighE = new TH2F ("hNCellsDispHighE","N_{cells} in cluster vs dispersion^{2}, E < 2 GeV", nbins,nmin, nmax, ssbins,ssmin,ssmax);
1753  fhNCellsDispHighE->SetXTitle("N_{cells}");
1754  fhNCellsDispHighE->SetYTitle("D^{2}");
1755  outputContainer->Add(fhNCellsDispHighE);
1756 
1757  fhEtaLam0LowE = new TH2F ("hEtaLam0LowE","#eta vs #lambda_{0}^{2}, E < 2 GeV", netabins,etamin,etamax, ssbins,ssmin,ssmax);
1758  fhEtaLam0LowE->SetYTitle("#lambda_{0}^{2}");
1759  fhEtaLam0LowE->SetXTitle("#eta");
1760  outputContainer->Add(fhEtaLam0LowE);
1761 
1762  fhPhiLam0LowE = new TH2F ("hPhiLam0LowE","#phi vs #lambda_{0}^{2}, E < 2 GeV", nphibins,phimin,phimax, ssbins,ssmin,ssmax);
1763  fhPhiLam0LowE->SetYTitle("#lambda_{0}^{2}");
1764  fhPhiLam0LowE->SetXTitle("#phi");
1765  outputContainer->Add(fhPhiLam0LowE);
1766 
1767  fhEtaLam0HighE = new TH2F ("hEtaLam0HighE","#eta vs #lambda_{0}^{2}, #it{E} > 2 GeV", netabins,etamin,etamax, ssbins,ssmin,ssmax);
1768  fhEtaLam0HighE->SetYTitle("#lambda_{0}^{2}");
1769  fhEtaLam0HighE->SetXTitle("#eta");
1770  outputContainer->Add(fhEtaLam0HighE);
1771 
1772  fhPhiLam0HighE = new TH2F ("hPhiLam0HighE","#phi vs #lambda_{0}^{2}, #it{E} > 2 GeV", nphibins,phimin,phimax, ssbins,ssmin,ssmax);
1773  fhPhiLam0HighE->SetYTitle("#lambda_{0}^{2}");
1774  fhPhiLam0HighE->SetXTitle("#phi");
1775  outputContainer->Add(fhPhiLam0HighE);
1776 
1777  fhLam1Lam0LowE = new TH2F ("hLam1Lam0LowE","#lambda_{0}^{2} vs #lambda_{1}^{2} in cluster of E < 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
1778  fhLam1Lam0LowE->SetYTitle("#lambda_{0}^{2}");
1779  fhLam1Lam0LowE->SetXTitle("#lambda_{1}^{2}");
1780  outputContainer->Add(fhLam1Lam0LowE);
1781 
1782  fhLam1Lam0HighE = new TH2F ("hLam1Lam0HighE","#lambda_{0}^{2} vs #lambda_{1}^{2} in cluster of #it{E} > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
1783  fhLam1Lam0HighE->SetYTitle("#lambda_{0}^{2}");
1784  fhLam1Lam0HighE->SetXTitle("#lambda_{1}^{2}");
1785  outputContainer->Add(fhLam1Lam0HighE);
1786 
1787  fhLam0DispLowE = new TH2F ("hLam0DispLowE","#lambda_{0}^{2} vs dispersion^{2} in cluster of E < 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
1788  fhLam0DispLowE->SetXTitle("#lambda_{0}^{2}");
1789  fhLam0DispLowE->SetYTitle("D^{2}");
1790  outputContainer->Add(fhLam0DispLowE);
1791 
1792  fhLam0DispHighE = new TH2F ("hLam0DispHighE","#lambda_{0}^{2} vs dispersion^{2} in cluster of #it{E} > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
1793  fhLam0DispHighE->SetXTitle("#lambda_{0}^{2}");
1794  fhLam0DispHighE->SetYTitle("D^{2}");
1795  outputContainer->Add(fhLam0DispHighE);
1796 
1797  fhDispLam1LowE = new TH2F ("hDispLam1LowE","Dispersion^{2} vs #lambda_{1}^{2} in cluster of E < 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
1798  fhDispLam1LowE->SetXTitle("D^{2}");
1799  fhDispLam1LowE->SetYTitle("#lambda_{1}^{2}");
1800  outputContainer->Add(fhDispLam1LowE);
1801 
1802  fhDispLam1HighE = new TH2F ("hDispLam1HighE","Dispersion^{2} vs #lambda_{1^{2}} in cluster of #it{E} > 2 GeV", ssbins,ssmin,ssmax, ssbins,ssmin,ssmax);
1803  fhDispLam1HighE->SetXTitle("D^{2}");
1804  fhDispLam1HighE->SetYTitle("#lambda_{1}^{2}");
1805  outputContainer->Add(fhDispLam1HighE);
1806 
1807  if(GetCalorimeter() == kEMCAL)
1808  {
1809  fhDispEtaE = new TH2F ("hDispEtaE","#sigma^{2}_{#eta #eta} = #Sigma w_{i}(#eta_{i} - <#eta>)^{2}/ #Sigma w_{i} vs E", nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
1810  fhDispEtaE->SetXTitle("#it{E} (GeV)");
1811  fhDispEtaE->SetYTitle("#sigma^{2}_{#eta #eta}");
1812  outputContainer->Add(fhDispEtaE);
1813 
1814  fhDispPhiE = new TH2F ("hDispPhiE","#sigma^{2}_{#phi #phi} = #Sigma w_{i}(#phi_{i} - <#phi>)^{2} / #Sigma w_{i} vs E", nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
1815  fhDispPhiE->SetXTitle("#it{E} (GeV)");
1816  fhDispPhiE->SetYTitle("#sigma^{2}_{#phi #phi}");
1817  outputContainer->Add(fhDispPhiE);
1818 
1819  fhSumEtaE = new TH2F ("hSumEtaE","#delta^{2}_{#eta #eta} = #Sigma w_{i}(#eta_{i})^{2} / #Sigma w_{i} - <#eta>^{2} vs E", nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
1820  fhSumEtaE->SetXTitle("#it{E} (GeV)");
1821  fhSumEtaE->SetYTitle("#delta^{2}_{#eta #eta}");
1822  outputContainer->Add(fhSumEtaE);
1823 
1824  fhSumPhiE = new TH2F ("hSumPhiE","#delta^{2}_{#phi #phi} = #Sigma w_{i}(#phi_{i})^{2}/ #Sigma w_{i} - <#phi>^{2} vs E",
1825  nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
1826  fhSumPhiE->SetXTitle("#it{E} (GeV)");
1827  fhSumPhiE->SetYTitle("#delta^{2}_{#phi #phi}");
1828  outputContainer->Add(fhSumPhiE);
1829 
1830  fhSumEtaPhiE = new TH2F ("hSumEtaPhiE","#delta^{2}_{#eta #phi} = #Sigma w_{i}(#phi_{i} #eta_{i} ) / #Sigma w_{i} - <#phi><#eta> vs E",
1831  nptbins,ptmin,ptmax, 2*ssbins,-ssmax,ssmax);
1832  fhSumEtaPhiE->SetXTitle("#it{E} (GeV)");
1833  fhSumEtaPhiE->SetYTitle("#delta^{2}_{#eta #phi}");
1834  outputContainer->Add(fhSumEtaPhiE);
1835 
1836  fhDispEtaPhiDiffE = new TH2F ("hDispEtaPhiDiffE","#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta} vs E",
1837  nptbins,ptmin,ptmax,200, -10,10);
1838  fhDispEtaPhiDiffE->SetXTitle("#it{E} (GeV)");
1839  fhDispEtaPhiDiffE->SetYTitle("#sigma^{2}_{#phi #phi}-#sigma^{2}_{#eta #eta}");
1840  outputContainer->Add(fhDispEtaPhiDiffE);
1841 
1842  fhSphericityE = new TH2F ("hSphericityE","(#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta}) / (#sigma^{2}_{#eta #eta} + #sigma^{2}_{#phi #phi}) vs E",
1843  nptbins,ptmin,ptmax, 200, -1,1);
1844  fhSphericityE->SetXTitle("#it{E} (GeV)");
1845  fhSphericityE->SetYTitle("s = (#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta}) / (#sigma^{2}_{#eta #eta} + #sigma^{2}_{#phi #phi})");
1846  outputContainer->Add(fhSphericityE);
1847 
1848  fhDispSumEtaDiffE = new TH2F ("hDispSumEtaDiffE","#sigma^{2}_{#eta #eta} - #delta^{2}_{#eta #eta} / average vs E", nptbins,ptmin,ptmax, 200,-0.01,0.01);
1849  fhDispSumEtaDiffE->SetXTitle("#it{E} (GeV)");
1850  fhDispSumEtaDiffE->SetYTitle("#sigma^{2}_{#eta #eta} - #delta^{2}_{#eta #eta} / average");
1851  outputContainer->Add(fhDispSumEtaDiffE);
1852 
1853  fhDispSumPhiDiffE = new TH2F ("hDispSumPhiDiffE","#sigma^{2}_{#phi #phi} - #delta^{2}_{#phi #phi} / average vs E", nptbins,ptmin,ptmax, 200,-0.01,0.01);
1854  fhDispSumPhiDiffE->SetXTitle("#it{E} (GeV)");
1855  fhDispSumPhiDiffE->SetYTitle("#sigma^{2}_{#phi #phi} - #delta^{2}_{#phi #phi} / average");
1856  outputContainer->Add(fhDispSumPhiDiffE);
1857 
1858  for(Int_t i = 0; i < 7; i++)
1859  {
1860  fhDispEtaDispPhi[i] = new TH2F (Form("hDispEtaDispPhi_EBin%d",i),Form("#sigma^{2}_{#phi #phi} vs #sigma^{2}_{#eta #eta} for %d < E < %d GeV",bin[i],bin[i+1]),
1861  ssbins,ssmin,ssmax , ssbins,ssmin,ssmax);
1862  fhDispEtaDispPhi[i]->SetXTitle("#sigma^{2}_{#eta #eta}");
1863  fhDispEtaDispPhi[i]->SetYTitle("#sigma^{2}_{#phi #phi}");
1864  outputContainer->Add(fhDispEtaDispPhi[i]);
1865 
1866  fhLambda0DispEta[i] = new TH2F (Form("hLambda0DispEta_EBin%d",i),Form("#lambda^{2}_{0} vs #sigma^{2}_{#eta #eta} for %d < E < %d GeV",bin[i],bin[i+1]),
1867  ssbins,ssmin,ssmax , ssbins,ssmin,ssmax);
1868  fhLambda0DispEta[i]->SetXTitle("#lambda^{2}_{0}");
1869  fhLambda0DispEta[i]->SetYTitle("#sigma^{2}_{#eta #eta}");
1870  outputContainer->Add(fhLambda0DispEta[i]);
1871 
1872  fhLambda0DispPhi[i] = new TH2F (Form("hLambda0DispPhi_EBin%d",i),Form("#lambda^{2}_{0}} vs #sigma^{2}_{#phi #phi} for %d < E < %d GeV",bin[i],bin[i+1]),
1873  ssbins,ssmin,ssmax , ssbins,ssmin,ssmax);
1874  fhLambda0DispPhi[i]->SetXTitle("#lambda^{2}_{0}");
1875  fhLambda0DispPhi[i]->SetYTitle("#sigma^{2}_{#phi #phi}");
1876  outputContainer->Add(fhLambda0DispPhi[i]);
1877  }
1878  }
1879  }
1880  } // Shower shape
1881 
1882  // Track Matching
1883 
1884  if(fFillTMHisto)
1885  {
1886  TString cutTM [] = {"NoCut",""};
1887 
1888  for(Int_t i = 0; i < 2; i++)
1889  {
1890  fhTrackMatchedDEta[i] = new TH2F
1891  (Form("hTrackMatchedDEta%s",cutTM[i].Data()),
1892  Form("d#eta of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1893  nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1894  fhTrackMatchedDEta[i]->SetYTitle("d#eta");
1895  fhTrackMatchedDEta[i]->SetXTitle("#it{E}_{cluster} (GeV)");
1896 
1897  fhTrackMatchedDPhi[i] = new TH2F
1898  (Form("hTrackMatchedDPhi%s",cutTM[i].Data()),
1899  Form("d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1900  nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1901  fhTrackMatchedDPhi[i]->SetYTitle("d#phi (rad)");
1902  fhTrackMatchedDPhi[i]->SetXTitle("#it{E}_{cluster} (GeV)");
1903 
1904  fhTrackMatchedDEtaDPhi[i] = new TH2F
1905  (Form("hTrackMatchedDEtaDPhi%s",cutTM[i].Data()),
1906  Form("d#eta vs d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1907  nresetabins,resetamin,resetamax,nresphibins,resphimin,resphimax);
1908  fhTrackMatchedDEtaDPhi[i]->SetYTitle("d#phi (rad)");
1909  fhTrackMatchedDEtaDPhi[i]->SetXTitle("d#eta");
1910 
1911  fhTrackMatchedDEtaPos[i] = new TH2F
1912  (Form("hTrackMatchedDEtaPos%s",cutTM[i].Data()),
1913  Form("d#eta of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1914  nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1915  fhTrackMatchedDEtaPos[i]->SetYTitle("d#eta");
1916  fhTrackMatchedDEtaPos[i]->SetXTitle("#it{E}_{cluster} (GeV)");
1917 
1918  fhTrackMatchedDPhiPos[i] = new TH2F
1919  (Form("hTrackMatchedDPhiPos%s",cutTM[i].Data()),
1920  Form("d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1921  nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1922  fhTrackMatchedDPhiPos[i]->SetYTitle("d#phi (rad)");
1923  fhTrackMatchedDPhiPos[i]->SetXTitle("#it{E}_{cluster} (GeV)");
1924 
1925  fhTrackMatchedDEtaDPhiPos[i] = new TH2F
1926  (Form("hTrackMatchedDEtaDPhiPos%s",cutTM[i].Data()),
1927  Form("d#eta vs d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1928  nresetabins,resetamin,resetamax,nresphibins,resphimin,resphimax);
1929  fhTrackMatchedDEtaDPhiPos[i]->SetYTitle("d#phi (rad)");
1930  fhTrackMatchedDEtaDPhiPos[i]->SetXTitle("d#eta");
1931 
1932  fhTrackMatchedDEtaNeg[i] = new TH2F
1933  (Form("hTrackMatchedDEtaNeg%s",cutTM[i].Data()),
1934  Form("d#eta of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1935  nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1936  fhTrackMatchedDEtaNeg[i]->SetYTitle("d#eta");
1937  fhTrackMatchedDEtaNeg[i]->SetXTitle("#it{E}_{cluster} (GeV)");
1938 
1939  fhTrackMatchedDPhiNeg[i] = new TH2F
1940  (Form("hTrackMatchedDPhiNeg%s",cutTM[i].Data()),
1941  Form("d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1942  nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1943  fhTrackMatchedDPhiNeg[i]->SetYTitle("d#phi (rad)");
1944  fhTrackMatchedDPhiNeg[i]->SetXTitle("#it{E}_{cluster} (GeV)");
1945 
1946  fhTrackMatchedDEtaDPhiNeg[i] = new TH2F
1947  (Form("hTrackMatchedDEtaDPhiNeg%s",cutTM[i].Data()),
1948  Form("d#eta vs d#phi of cluster-track vs cluster energy, %s",cutTM[i].Data()),
1949  nresetabins,resetamin,resetamax,nresphibins,resphimin,resphimax);
1950  fhTrackMatchedDEtaDPhiNeg[i]->SetYTitle("d#phi (rad)");
1951  fhTrackMatchedDEtaDPhiNeg[i]->SetXTitle("d#eta");
1952 
1953  fhdEdx[i] = new TH2F (Form("hdEdx%s",cutTM[i].Data()),Form("matched track <dE/dx> vs cluster E, %s",cutTM[i].Data()),
1954  nptbins,ptmin,ptmax,ndedxbins, dedxmin, dedxmax);
1955  fhdEdx[i]->SetXTitle("#it{E} (GeV)");
1956  fhdEdx[i]->SetYTitle("<dE/dx>");
1957 
1958  fhEOverP[i] = new TH2F (Form("hEOverP%s",cutTM[i].Data()),Form("matched track E/p vs cluster E, %s",cutTM[i].Data()),
1959  nptbins,ptmin,ptmax,nPoverEbins,pOverEmin,pOverEmax);
1960  fhEOverP[i]->SetXTitle("#it{E} (GeV)");
1961  fhEOverP[i]->SetYTitle("E/p");
1962 
1963  outputContainer->Add(fhTrackMatchedDEta[i]) ;
1964  outputContainer->Add(fhTrackMatchedDPhi[i]) ;
1965  outputContainer->Add(fhTrackMatchedDEtaDPhi[i]) ;
1966  outputContainer->Add(fhTrackMatchedDEtaPos[i]) ;
1967  outputContainer->Add(fhTrackMatchedDPhiPos[i]) ;
1968  outputContainer->Add(fhTrackMatchedDEtaDPhiPos[i]) ;
1969  outputContainer->Add(fhTrackMatchedDEtaNeg[i]) ;
1970  outputContainer->Add(fhTrackMatchedDPhiNeg[i]) ;
1971  outputContainer->Add(fhTrackMatchedDEtaDPhiNeg[i]) ;
1972  outputContainer->Add(fhdEdx[i]);
1973  outputContainer->Add(fhEOverP[i]);
1974 
1975  if(GetCalorimeter()==kEMCAL && GetFirstSMCoveredByTRD() >=0 )
1976  {
1977  fhTrackMatchedDEtaTRD[i] = new TH2F
1978  (Form("hTrackMatchedDEtaTRD%s",cutTM[i].Data()),
1979  Form("d#eta of cluster-track vs cluster energy, SM behind TRD, %s",cutTM[i].Data()),
1980  nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1981  fhTrackMatchedDEtaTRD[i]->SetYTitle("d#eta");
1982  fhTrackMatchedDEtaTRD[i]->SetXTitle("#it{E}_{cluster} (GeV)");
1983 
1984  fhTrackMatchedDPhiTRD[i] = new TH2F
1985  (Form("hTrackMatchedDPhiTRD%s",cutTM[i].Data()),
1986  Form("d#phi of cluster-track vs cluster energy, SM behing TRD, %s",cutTM[i].Data()),
1987  nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1988  fhTrackMatchedDPhiTRD[i]->SetYTitle("d#phi (rad)");
1989  fhTrackMatchedDPhiTRD[i]->SetXTitle("#it{E}_{cluster} (GeV)");
1990 
1991  fhEOverPTRD[i] = new TH2F
1992  (Form("hEOverPTRD%s",cutTM[i].Data()),
1993  Form("matched track E/p vs cluster E, behind TRD, %s",cutTM[i].Data()),
1994  nptbins,ptmin,ptmax,nPoverEbins,pOverEmin,pOverEmax);
1995  fhEOverPTRD[i]->SetXTitle("#it{E} (GeV)");
1996  fhEOverPTRD[i]->SetYTitle("E/p");
1997 
1998  outputContainer->Add(fhTrackMatchedDEtaTRD[i]) ;
1999  outputContainer->Add(fhTrackMatchedDPhiTRD[i]) ;
2000  outputContainer->Add(fhEOverPTRD[i]);
2001  }
2002 
2003  if(IsDataMC())
2004  {
2005  fhTrackMatchedDEtaMCNoOverlap[i] = new TH2F
2006  (Form("hTrackMatchedDEtaMCNoOverlap%s",cutTM[i].Data()),
2007  Form("d#eta of cluster-track vs cluster energy, no other MC particles overlap %s",cutTM[i].Data()),
2008  nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
2009  fhTrackMatchedDEtaMCNoOverlap[i]->SetYTitle("d#eta");
2010  fhTrackMatchedDEtaMCNoOverlap[i]->SetXTitle("#it{E}_{cluster} (GeV)");
2011 
2012  fhTrackMatchedDPhiMCNoOverlap[i] = new TH2F
2013  (Form("hTrackMatchedDPhiMCNoOverlap%s",cutTM[i].Data()),
2014  Form("d#phi of cluster-track vs cluster energy, no other MC particles overlap %s",cutTM[i].Data()),
2015  nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
2016  fhTrackMatchedDPhiMCNoOverlap[i]->SetYTitle("d#phi (rad)");
2017  fhTrackMatchedDPhiMCNoOverlap[i]->SetXTitle("#it{E}_{cluster} (GeV)");
2018 
2019  outputContainer->Add(fhTrackMatchedDEtaMCNoOverlap[i]) ;
2020  outputContainer->Add(fhTrackMatchedDPhiMCNoOverlap[i]) ;
2021  fhTrackMatchedDEtaMCOverlap[i] = new TH2F
2022  (Form("hTrackMatchedDEtaMCOverlap%s",cutTM[i].Data()),
2023  Form("d#eta of cluster-track vs cluster energy, several MC particles overlap %s",cutTM[i].Data()),
2024  nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
2025  fhTrackMatchedDEtaMCOverlap[i]->SetYTitle("d#eta");
2026  fhTrackMatchedDEtaMCOverlap[i]->SetXTitle("#it{E}_{cluster} (GeV)");
2027 
2028  fhTrackMatchedDPhiMCOverlap[i] = new TH2F
2029  (Form("hTrackMatchedDPhiMCOverlap%s",cutTM[i].Data()),
2030  Form("d#phi of cluster-track vs cluster energy, several MC particles overlap %s",cutTM[i].Data()),
2031  nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
2032  fhTrackMatchedDPhiMCOverlap[i]->SetYTitle("d#phi (rad)");
2033  fhTrackMatchedDPhiMCOverlap[i]->SetXTitle("#it{E}_{cluster} (GeV)");
2034 
2035  outputContainer->Add(fhTrackMatchedDEtaMCOverlap[i]) ;
2036  outputContainer->Add(fhTrackMatchedDPhiMCOverlap[i]) ;
2037 
2038  fhTrackMatchedDEtaMCConversion[i] = new TH2F
2039  (Form("hTrackMatchedDEtaMCConversion%s",cutTM[i].Data()),
2040  Form("d#eta of cluster-track vs cluster energy, no other MC particles overlap appart from conversions %s",cutTM[i].Data()),
2041  nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
2042  fhTrackMatchedDEtaMCConversion[i]->SetYTitle("d#eta");
2043  fhTrackMatchedDEtaMCConversion[i]->SetXTitle("#it{E}_{cluster} (GeV)");
2044 
2045  fhTrackMatchedDPhiMCConversion[i] = new TH2F
2046  (Form("hTrackMatchedDPhiMCConversion%s",cutTM[i].Data()),
2047  Form("d#phi of cluster-track vs cluster energy, no other MC particles overlap appart from conversions %s",cutTM[i].Data()),
2048  nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
2049  fhTrackMatchedDPhiMCConversion[i]->SetYTitle("d#phi (rad)");
2050  fhTrackMatchedDPhiMCConversion[i]->SetXTitle("#it{E}_{cluster} (GeV)");
2051 
2052  outputContainer->Add(fhTrackMatchedDEtaMCConversion[i]) ;
2053  outputContainer->Add(fhTrackMatchedDPhiMCConversion[i]) ;
2054 
2055  fhTrackMatchedMCParticle[i] = new TH2F
2056  (Form("hTrackMatchedMCParticle%s",cutTM[i].Data()),
2057  Form("Origin of particle vs energy %s",cutTM[i].Data()),
2058  nptbins,ptmin,ptmax,8,0,8);
2059  fhTrackMatchedMCParticle[i]->SetXTitle("#it{E} (GeV)");
2060  //fhTrackMatchedMCParticle[i]->SetYTitle("Particle type");
2061 
2062  fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(1 ,"Photon");
2063  fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(2 ,"Electron");
2064  fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(3 ,"Meson Merged");
2065  fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(4 ,"Rest");
2066  fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(5 ,"Conv. Photon");
2067  fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(6 ,"Conv. Electron");
2068  fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(7 ,"Conv. Merged");
2069  fhTrackMatchedMCParticle[i]->GetYaxis()->SetBinLabel(8 ,"Conv. Rest");
2070 
2071  outputContainer->Add(fhTrackMatchedMCParticle[i]);
2072  }
2073  }
2074  }
2075 
2076  if(IsPileUpAnalysisOn())
2077  {
2078  TString pileUpName[] = {"SPD","EMCAL","SPDOrEMCAL","SPDAndEMCAL","SPDAndNotEMCAL","EMCALAndNotSPD","NotSPDAndNotEMCAL"} ;
2079 
2080  for(Int_t i = 0 ; i < 7 ; i++)
2081  {
2082  fhPtPhotonPileUp[i] = new TH1F(Form("hPtPhotonPileUp%s",pileUpName[i].Data()),
2083  Form("Selected photon #it{p}_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
2084  fhPtPhotonPileUp[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2085  outputContainer->Add(fhPtPhotonPileUp[i]);
2086 
2087  fhClusterTimeDiffPhotonPileUp[i] = new TH2F(Form("hClusterTimeDiffPhotonPileUp%s",pileUpName[i].Data()),
2088  Form("Photon cluster E vs #it{t}_{max}-#it{t}_{cell} in cluster, %s Pile-Up event",pileUpName[i].Data()),
2089  nptbins,ptmin,ptmax,400,-200,200);
2090  fhClusterTimeDiffPhotonPileUp[i]->SetXTitle("#it{E} (GeV)");
2091  fhClusterTimeDiffPhotonPileUp[i]->SetYTitle("#it{t}_{max}-#it{t}_{cell} (ns)");
2092  outputContainer->Add(fhClusterTimeDiffPhotonPileUp[i]);
2093  }
2094 
2095  fhTimePtPhotonNoCut = new TH2F ("hTimePtPhoton_NoCut","time of photon cluster vs pT of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
2096  fhTimePtPhotonNoCut->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2097  fhTimePtPhotonNoCut->SetYTitle("#it{time} (ns)");
2098  outputContainer->Add(fhTimePtPhotonNoCut);
2099 
2100  fhTimePtPhotonSPD = new TH2F ("hTimePtPhoton_SPD","time of photon cluster vs pT of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
2101  fhTimePtPhotonSPD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2102  fhTimePtPhotonSPD->SetYTitle("#it{time} (ns)");
2103  outputContainer->Add(fhTimePtPhotonSPD);
2104 
2105  fhTimeNPileUpVertSPD = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,20,0,20);
2106  fhTimeNPileUpVertSPD->SetYTitle("# vertex ");
2107  fhTimeNPileUpVertSPD->SetXTitle("#it{time} (ns)");
2108  outputContainer->Add(fhTimeNPileUpVertSPD);
2109 
2110  fhTimeNPileUpVertTrack = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 20,0,20 );
2111  fhTimeNPileUpVertTrack->SetYTitle("# vertex ");
2112  fhTimeNPileUpVertTrack->SetXTitle("#it{time} (ns)");
2113  outputContainer->Add(fhTimeNPileUpVertTrack);
2114 
2115  fhPtPhotonNPileUpSPDVtx = new TH2F ("hPtPhoton_NPileUpVertSPD","pT of cluster vs N pile-up SPD vertex",
2116  nptbins,ptmin,ptmax,20,0,20);
2117  fhPtPhotonNPileUpSPDVtx->SetYTitle("# vertex ");
2118  fhPtPhotonNPileUpSPDVtx->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2119  outputContainer->Add(fhPtPhotonNPileUpSPDVtx);
2120 
2121  fhPtPhotonNPileUpTrkVtx = new TH2F ("hPtPhoton_NPileUpVertTracks","pT of cluster vs N pile-up Tracks vertex",
2122  nptbins,ptmin,ptmax, 20,0,20 );
2123  fhPtPhotonNPileUpTrkVtx->SetYTitle("# vertex ");
2124  fhPtPhotonNPileUpTrkVtx->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2125  outputContainer->Add(fhPtPhotonNPileUpTrkVtx);
2126 
2127  fhPtPhotonNPileUpSPDVtxTimeCut = new TH2F ("hPtPhoton_NPileUpVertSPD_TimeCut","pT of cluster vs N pile-up SPD vertex, |tof| < 25 ns",
2128  nptbins,ptmin,ptmax,20,0,20);
2129  fhPtPhotonNPileUpSPDVtxTimeCut->SetYTitle("# vertex ");
2130  fhPtPhotonNPileUpSPDVtxTimeCut->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2131  outputContainer->Add(fhPtPhotonNPileUpSPDVtxTimeCut);
2132 
2133  fhPtPhotonNPileUpTrkVtxTimeCut = new TH2F ("hPtPhoton_NPileUpVertTracks_TimeCut","pT of cluster vs N pile-up Tracks vertex, |tof| < 25 ns",
2134  nptbins,ptmin,ptmax, 20,0,20 );
2135  fhPtPhotonNPileUpTrkVtxTimeCut->SetYTitle("# vertex ");
2136  fhPtPhotonNPileUpTrkVtxTimeCut->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2137  outputContainer->Add(fhPtPhotonNPileUpTrkVtxTimeCut);
2138 
2139  fhPtPhotonNPileUpSPDVtxTimeCut2 = new TH2F ("hPtPhoton_NPileUpVertSPD_TimeCut2","pT of cluster vs N pile-up SPD vertex, -25 < tof < 75 ns",
2140  nptbins,ptmin,ptmax,20,0,20);
2141  fhPtPhotonNPileUpSPDVtxTimeCut2->SetYTitle("# vertex ");
2142  fhPtPhotonNPileUpSPDVtxTimeCut2->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2143  outputContainer->Add(fhPtPhotonNPileUpSPDVtxTimeCut2);
2144 
2145  fhPtPhotonNPileUpTrkVtxTimeCut2 = new TH2F ("hPtPhoton_NPileUpVertTracks_TimeCut2","pT of cluster vs N pile-up Tracks vertex, -25 < tof < 75 ns",
2146  nptbins,ptmin,ptmax, 20,0,20 );
2147  fhPtPhotonNPileUpTrkVtxTimeCut2->SetYTitle("# vertex ");
2148  fhPtPhotonNPileUpTrkVtxTimeCut2->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2149  outputContainer->Add(fhPtPhotonNPileUpTrkVtxTimeCut2);
2150 
2151  }
2152 
2153  if(GetCalorimeter() == kEMCAL && fFillEMCALRegionSSHistograms && fFillSSHistograms)
2154  {
2155  for(Int_t ieta = 0; ieta < 4; ieta++)
2156  {
2157  for(Int_t iphi = 0; iphi < 3; iphi++)
2158  {
2159 // fhLam0EMCALRegion[ieta][iphi] =
2160 // new TH2F(Form("hLam0_eta%d_phi%d",ieta,iphi),
2161 // Form("cluster from converted photon, #it{p}_{T} vs #lambda_{0}^{2}, region eta %d, phi %d",ieta,iphi),
2162 // nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2163 // fhLam0EMCALRegion[ieta][iphi]->SetYTitle("#lambda_{0}^{2}");
2164 // fhLam0EMCALRegion[ieta][iphi]->SetXTitle("#it{p}_{T} (GeV)");
2165 // outputContainer->Add(fhLam0EMCALRegion[ieta][iphi]) ;
2166 //
2167 // if(GetFirstSMCoveredByTRD() >= 0)
2168 // {
2169 // fhLam0EMCALRegionTRD[ieta][iphi] =
2170 // new TH2F(Form("hLam0TRD_eta%d_phi%d",ieta,iphi),
2171 // Form("cluster from converted photon, #it{p}_{T} vs #lambda_{0}^{2}, region eta %d, phi %d, SM covered by TRD",ieta,iphi),
2172 // nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2173 // fhLam0EMCALRegionTRD[ieta][iphi]->SetYTitle("#lambda_{0}^{2}");
2174 // fhLam0EMCALRegionTRD[ieta][iphi]->SetXTitle("#it{p}_{T} (GeV)");
2175 // outputContainer->Add(fhLam0EMCALRegionTRD[ieta][iphi]) ;
2176 // } // TRD
2177 
2178  for(Int_t ism = 0; ism < GetCaloUtils()->GetNumberOfSuperModulesUsed(); ism++)
2179  {
2180  fhLam0EMCALRegionPerSM[ieta][iphi][ism] =
2181  new TH2F(Form("hLam0_eta%d_phi%d_sm%d",ieta,iphi,ism),
2182  Form("cluster from converted photon, #it{p}_{T} vs #lambda_{0}^{2}, sm %d, region eta %d, phi %d",ism,ieta,iphi),
2183  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2184  fhLam0EMCALRegionPerSM[ieta][iphi][ism]->SetYTitle("#lambda_{0}^{2}");
2185  fhLam0EMCALRegionPerSM[ieta][iphi][ism]->SetXTitle("#it{p}_{T} (GeV)");
2186  outputContainer->Add(fhLam0EMCALRegionPerSM[ieta][iphi][ism]) ;
2187 
2188  fhLam1EMCALRegionPerSM[ieta][iphi][ism] =
2189  new TH2F(Form("hLam1_eta%d_phi%d_sm%d",ieta,iphi,ism),
2190  Form("cluster from converted photon, #it{p}_{T} vs #lambda_{1}^{2}, sm %d, region eta %d, phi %d",ism,ieta,iphi),
2191  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2192  fhLam1EMCALRegionPerSM[ieta][iphi][ism]->SetYTitle("#lambda_{1}^{2}");
2193  fhLam1EMCALRegionPerSM[ieta][iphi][ism]->SetXTitle("#it{p}_{T} (GeV)");
2194  outputContainer->Add(fhLam1EMCALRegionPerSM[ieta][iphi][ism]) ;
2195  }
2196  } // iphi
2197  } // ieta
2198 
2199  Float_t ptLimit[] = {2,3,4,5,6,8,10,12};
2200  TString l0bin [] = {"0.23<#lambda^{2}_{0}<0.26","0.3<#lambda^{2}_{0}<0.4"};
2201 
2202  for(Int_t il0 = 0; il0 < 2; il0++)
2203  {
2204  for(Int_t ipt = 0; ipt < 7; ipt++)
2205  {
2206  fhEtaPhiLam0BinPtBin[il0][ipt] = new TH2F
2207  (Form("hEtaPhiLam0Bin%d_PtBin%d",il0,ipt),
2208  Form("#eta vs #phi in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, %s",
2209  ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2210  netabins,etamin,etamax,nphibins,phimin,phimax);
2211  fhEtaPhiLam0BinPtBin[il0][ipt]->SetYTitle("#phi (rad)");
2212  fhEtaPhiLam0BinPtBin[il0][ipt]->SetXTitle("#eta");
2213  outputContainer->Add(fhEtaPhiLam0BinPtBin[il0][ipt]) ;
2214 
2215  fhColRowLam0BinPtBin[il0][ipt] = new TH2F
2216  (Form("hColRowLam0Bin%d_PtBin%d",il0,ipt),
2217  Form("row vs column in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, %s, w > 0",
2218  ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2219  96,0,96,5*24,0,5*24); // fix to generalize to other periods
2220  fhColRowLam0BinPtBin[il0][ipt]->SetYTitle("row");
2221  fhColRowLam0BinPtBin[il0][ipt]->SetXTitle("column");
2222  outputContainer->Add(fhColRowLam0BinPtBin[il0][ipt]) ;
2223 
2224  fhColRowLam0BinPtBinWeighted[il0][ipt] = new TH2F
2225  (Form("hColRowLam0Bin%d_PtBin%dWeighted",il0,ipt),
2226  Form("cluster cell row vs column weighted in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, %s",
2227  ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2228  96,0,96,5*24,0,5*24); // fix to generalize to other periods
2229  fhColRowLam0BinPtBinWeighted[il0][ipt]->SetYTitle("row");
2230  fhColRowLam0BinPtBinWeighted[il0][ipt]->SetXTitle("column");
2231  outputContainer->Add(fhColRowLam0BinPtBinWeighted[il0][ipt]) ;
2232 
2233  fhColRowLam0BinPtBinLargeTime[il0][ipt] = new TH2F
2234  (Form("hColRowLam0Bin%d_PtBin%d_LargeTimeInClusterCell",il0,ipt),
2235  Form("row vs column in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, %s, |t| > 50 ns, w > 0",
2236  ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2237  96,0,96,5*24,0,5*24); // fix to generalize to other periods
2238  fhColRowLam0BinPtBinLargeTime[il0][ipt]->SetYTitle("row");
2239  fhColRowLam0BinPtBinLargeTime[il0][ipt]->SetXTitle("column");
2240  outputContainer->Add(fhColRowLam0BinPtBinLargeTime[il0][ipt]) ;
2241 
2242 // fhEtaPhiLam0BinPtBinSMShared[il0][ipt] = new TH2F
2243 // (Form("hEtaPhiLam0Bin%d_PtBin%d_SMShared",il0,ipt),
2244 // Form("#eta vs #phi in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, %s",
2245 // ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2246 // netabins,etamin,etamax,nphibins,phimin,phimax);
2247 // fhEtaPhiLam0BinPtBinSMShared[il0][ipt]->SetYTitle("#phi (rad)");
2248 // fhEtaPhiLam0BinPtBinSMShared[il0][ipt]->SetXTitle("#eta");
2249 // outputContainer->Add(fhEtaPhiLam0BinPtBinSMShared[il0][ipt]) ;
2250 //
2251 // fhColRowLam0BinPtBinSMShared[il0][ipt] = new TH2F
2252 // (Form("hColRowLam0Bin%d_PtBin%d_SMShared",il0,ipt),
2253 // Form("row vs column in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, %s, w > 0",
2254 // ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2255 // 96,0,96,5*24,0,5*24); // fix to generalize to other periods
2256 // fhColRowLam0BinPtBinSMShared[il0][ipt]->SetYTitle("row");
2257 // fhColRowLam0BinPtBinSMShared[il0][ipt]->SetXTitle("column");
2258 // outputContainer->Add(fhColRowLam0BinPtBinSMShared[il0][ipt]) ;
2259 
2260  fhEtaPhiLargeTimeInClusterCell[il0][ipt] = new TH2F
2261  (Form("hEtaPhiLam0Bin%d_PtBin%d_LargeTimeInClusterCell",il0,ipt),
2262  Form("#eta vs #phi in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, w > 0, t > 50 ns, %s",
2263  ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2264  netabins,etamin,etamax,nphibins,phimin,phimax);
2265  fhEtaPhiLargeTimeInClusterCell[il0][ipt]->SetYTitle("#phi (rad)");
2266  fhEtaPhiLargeTimeInClusterCell[il0][ipt]->SetXTitle("#eta");
2267  outputContainer->Add(fhEtaPhiLargeTimeInClusterCell[il0][ipt]) ;
2268 
2269  fhCellClusterIndexEAndTime[il0][ipt] = new TH2F
2270  (Form("hCellClusterIndexEAndTimeLam0Bin%d_PtBin%d",il0,ipt),
2271  Form("#it{t}_{cell} vs cell index (E sorted) in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, w > 0, %s",
2272  ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2273  ntimebins,timemin,timemax,30,0,30);
2274  fhCellClusterIndexEAndTime[il0][ipt] ->SetYTitle("Index (sorted #it{E})");
2275  fhCellClusterIndexEAndTime[il0][ipt] ->SetXTitle("#it{time}_{cell} (ns)");
2276  outputContainer->Add(fhCellClusterIndexEAndTime[il0][ipt] ) ;
2277 
2278  fhCellClusterEAndTime[il0][ipt] = new TH2F
2279  (Form("hCellClusterEAndTimeLam0Bin%d_PtBin%d",il0,ipt),
2280  Form("#it{E}_{cell} vs #it{t}_{cell} in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, w > 0, %s",
2281  ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2282  ntimebins,timemin,timemax,100,0,5);
2283  fhCellClusterEAndTime[il0][ipt] ->SetYTitle("#it{E}_{cell} (GeV)");
2284  fhCellClusterEAndTime[il0][ipt] ->SetXTitle("#it{time}_{cell} (ns)");
2285  outputContainer->Add(fhCellClusterEAndTime[il0][ipt] ) ;
2286 
2287  fhCellClusterEFracAndTime[il0][ipt] = new TH2F
2288  (Form("hCellClusterEFracAndTimeLam0Bin%d_PtBin%d",il0,ipt),
2289  Form("#it{E}_{cell} vs #it{t}_{cell} in #it{p}_{T}=[%2.1f,%2.1f] GeV/#it{c}, w > 0, %s",
2290  ptLimit[ipt],ptLimit[ipt+1],l0bin[il0].Data()),
2291  ntimebins,timemin,timemax,100,0,1);
2292  fhCellClusterEFracAndTime[il0][ipt] ->SetYTitle("#it{E}_{cell} (GeV)");
2293  fhCellClusterEFracAndTime[il0][ipt] ->SetXTitle("#it{time}_{cell} (ns)");
2294  outputContainer->Add(fhCellClusterEFracAndTime[il0][ipt] ) ;
2295  } // pt bin
2296 
2297  for(Int_t ism = 0; ism < GetCaloUtils()->GetNumberOfSuperModulesUsed(); ism++)
2298  {
2299  fhLam1Lam0BinPerSM[il0][ism] = new TH2F
2300  (Form("hLam1Lam0Bin%d_sm%d",il0,ism),
2301  Form("#it{p}_{T} vs #lambda^{2}_{1} in sm %d, %s",ism,l0bin[il0].Data()),
2302  nptbins,ptmin,ptmax,40,0,0.4);
2303  fhLam1Lam0BinPerSM[il0][ism]->SetYTitle("#lambda^{2}_{1}");
2304  fhLam1Lam0BinPerSM[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2305  outputContainer->Add(fhLam1Lam0BinPerSM[il0][ism]) ;
2306 
2307  fhTimeLam0BinPerSM[il0][ism] = new TH2F
2308  (Form("hTimeLam0Bin%d_sm%d",il0,ism),
2309  Form("#it{p}_{T} vs cluster cell time in sm %d, %s, w > 0",ism,l0bin[il0].Data()),
2310  nptbins,ptmin,ptmax,ntimebins,timemin,timemax);
2311  fhTimeLam0BinPerSM[il0][ism]->SetYTitle("cell time (ns)");
2312  fhTimeLam0BinPerSM[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2313  outputContainer->Add(fhTimeLam0BinPerSM[il0][ism]) ;
2314 
2315  fhTimeLam0BinPerSMWeighted[il0][ism] = new TH2F
2316  (Form("hTimeLam0Bin%d_sm%d_Weighted",il0,ism),
2317  Form("#it{p}_{T} vs cluster cell time weighted in sm %d, %s",ism,l0bin[il0].Data()),
2318  nptbins,ptmin,ptmax,ntimebins,timemin,timemax);
2319  fhTimeLam0BinPerSMWeighted[il0][ism]->SetYTitle("cell time (ns)");
2320  fhTimeLam0BinPerSMWeighted[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2321  outputContainer->Add(fhTimeLam0BinPerSMWeighted[il0][ism]) ;
2322 
2323  fhDTimeLam0BinPerSM[il0][ism] = new TH2F
2324  (Form("hDTimeLam0Bin%d_sm%d",il0,ism),
2325  Form("#it{p}_{T} vs t_{cluster}-t_{cell} in sm %d, %s, w > 0",ism,l0bin[il0].Data()),
2326  nptbins,ptmin,ptmax,ntimebins,timemin,timemax);
2327  fhDTimeLam0BinPerSM[il0][ism]->SetYTitle("t_{cluster}-t_{cell} (ns)");
2328  fhDTimeLam0BinPerSM[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2329  outputContainer->Add(fhDTimeLam0BinPerSM[il0][ism]) ;
2330 
2331  fhDTimeLam0BinPerSMWeighted[il0][ism] = new TH2F
2332  (Form("hDTimeLam0Bin%d_sm%d_Weighted",il0,ism),
2333  Form("#it{p}_{T} vs t_{cluster}-t_{cell} weighted in sm %d, %s",ism,l0bin[il0].Data()),
2334  nptbins,ptmin,ptmax,ntimebins,timemin,timemax);
2335  fhDTimeLam0BinPerSMWeighted[il0][ism]->SetYTitle("t_{cluster}-t_{cell} (ns)");
2336  fhDTimeLam0BinPerSMWeighted[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2337  outputContainer->Add(fhDTimeLam0BinPerSMWeighted[il0][ism]) ;
2338 
2339  fhCellClusterEFracLam0BinPerSM[il0][ism] = new TH2F
2340  (Form("hCellClusterEFracLam0Bin%d_sm%d",il0,ism),
2341  Form("#it{p}_{T} vs cell E / cluster E in sm %d, %s, w > 0",ism,l0bin[il0].Data()),
2342  nptbins,ptmin,ptmax,100,0,1);
2343  fhCellClusterEFracLam0BinPerSM[il0][ism]->SetYTitle("cell E / cluster E ");
2344  fhCellClusterEFracLam0BinPerSM[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2345  outputContainer->Add(fhCellClusterEFracLam0BinPerSM[il0][ism]) ;
2346 
2347 // fhCellClusterEFracLam0BinPerSMWeighted[il0][ism] = new TH2F
2348 // (Form("hCellClusterEFracLam0Bin%d_sm%d_Weighted",il0,ism),
2349 // Form("#it{p}_{T} vs cell E / cluster E weighted in sm %d, %s",ism,l0bin[il0].Data()),
2350 // nptbins,ptmin,ptmax,100,0,1);
2351 // fhCellClusterEFracLam0BinPerSMWeighted[il0][ism]->SetYTitle("cell E / cluster E ");
2352 // fhCellClusterEFracLam0BinPerSMWeighted[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2353 // outputContainer->Add(fhCellClusterEFracLam0BinPerSMWeighted[il0][ism]) ;
2354 
2355  fhCellClusterEFracLam0BinPerSMLargeTime[il0][ism] = new TH2F
2356  (Form("hCellClusterEFracLam0Bin%d_sm%d_LargeTimeInClusterCell",il0,ism),
2357  Form("#it{p}_{T} vs cell E / cluster E in sm %d, %s, w > 0, |t_{cell}| > 50 ns",ism,l0bin[il0].Data()),
2358  nptbins,ptmin,ptmax,100,0,1);
2359  fhCellClusterEFracLam0BinPerSMLargeTime[il0][ism]->SetYTitle("cell E / cluster E ");
2360  fhCellClusterEFracLam0BinPerSMLargeTime[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2361  outputContainer->Add(fhCellClusterEFracLam0BinPerSMLargeTime[il0][ism]) ;
2362 
2363  fhCellClusterEFracLam0BinPerSMLargeTimeTotal[il0][ism] = new TH2F
2364  (Form("hCellClusterEFracLam0Bin%d_sm%d_LargeTimeInClusterCell_Total",il0,ism),
2365  Form("#it{p}_{T} vs cell E / cluster E in sm %d, %s, w > 0, all |t_{cell}| > 50 ns",ism,l0bin[il0].Data()),
2366  nptbins,ptmin,ptmax,100,0,1);
2367  fhCellClusterEFracLam0BinPerSMLargeTimeTotal[il0][ism]->SetYTitle("cell E / cluster E ");
2368  fhCellClusterEFracLam0BinPerSMLargeTimeTotal[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2369  outputContainer->Add(fhCellClusterEFracLam0BinPerSMLargeTimeTotal[il0][ism]) ;
2370 
2371  fhCellClusterELam0BinPerSM[il0][ism] = new TH2F
2372  (Form("hCellClusterELam0Bin%d_sm%d",il0,ism),
2373  Form("#it{p}_{T} vs cell E in sm %d, %s, w > 0",ism,l0bin[il0].Data()),
2374  nptbins,ptmin,ptmax,500,0,10);
2375  fhCellClusterELam0BinPerSM[il0][ism]->SetYTitle("cell E (GeV)");
2376  fhCellClusterELam0BinPerSM[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2377  outputContainer->Add(fhCellClusterELam0BinPerSM[il0][ism]) ;
2378 
2379  fhCellClusterELam0BinPerSMWeighted[il0][ism] = new TH2F
2380  (Form("hCellClusterELam0Bin%d_sm%d_Weighted",il0,ism),
2381  Form("#it{p}_{T} vs cell E weighted in sm %d, %s",ism,l0bin[il0].Data()),
2382  nptbins,ptmin,ptmax,500,0,10);
2383  fhCellClusterELam0BinPerSMWeighted[il0][ism]->SetYTitle("cell E (GeV)");
2384  fhCellClusterELam0BinPerSMWeighted[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2385  outputContainer->Add(fhCellClusterELam0BinPerSMWeighted[il0][ism]) ;
2386 
2387  fhCellClusterELam0BinPerSMLargeTime[il0][ism] = new TH2F
2388  (Form("hCellClusterELam0Bin%d_sm%d_LargeTimeInClusterCell",il0,ism),
2389  Form("#it{p}_{T} vs cell E in sm %d, %s, w > 0, |t_{cell}| > 50 ns",ism,l0bin[il0].Data()),
2390  nptbins,ptmin,ptmax,500,0,10);
2391  fhCellClusterELam0BinPerSMLargeTime[il0][ism]->SetYTitle("cell E (GeV)");
2392  fhCellClusterELam0BinPerSMLargeTime[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2393  outputContainer->Add(fhCellClusterELam0BinPerSMLargeTime[il0][ism]) ;
2394 
2395  fhCellClusterIndexELam0BinPerSMLargeTime[il0][ism] = new TH2F
2396  (Form("hCellClusterIndexELam0Bin%d_sm%d_LargeTimeInClusterCell",il0,ism),
2397  Form("#it{p}_{T} vs cell index (E sorted) in sm %d, %s, w > 0, |t_{cell}| > 50 ns",ism,l0bin[il0].Data()),
2398  nptbins,ptmin,ptmax,30,0,30);
2399  fhCellClusterIndexELam0BinPerSMLargeTime[il0][ism]->SetYTitle("Index");
2400  fhCellClusterIndexELam0BinPerSMLargeTime[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2401  outputContainer->Add(fhCellClusterIndexELam0BinPerSMLargeTime[il0][ism]) ;
2402 
2403  fhNCellsWithLargeTimeInCluster[il0][ism] = new TH2F
2404  (Form("hNCellsWithLargeTimeInClusterLam0Bin%d_sm%d",il0,ism),
2405  Form("#it{p}_{T} vs number of cells in sm %d, %s, w > 0, |t_{cell}| > 50 ns",ism,l0bin[il0].Data()),
2406  nptbins,ptmin,ptmax,30,0,30);
2407  fhNCellsWithLargeTimeInCluster[il0][ism]->SetYTitle("#it{n}_{cells}");
2408  fhNCellsWithLargeTimeInCluster[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2409  outputContainer->Add(fhNCellsWithLargeTimeInCluster[il0][ism]) ;
2410 
2411 // if(ism < 12)
2412 // {
2413 // fhTimeLam0BinPerSMShared[il0][ism] = new TH2F
2414 // (Form("hTimeLam0Bin%d_sm%d_SMShared",il0,ism),
2415 // Form("#it{p}_{T} vs cluster cell time in sm %d, %s, w > 0",ism,l0bin[il0].Data()),
2416 // nptbins,ptmin,ptmax,ntimebins,timemin,timemax);
2417 // fhTimeLam0BinPerSMShared[il0][ism]->SetYTitle("cell time (ns)");
2418 // fhTimeLam0BinPerSMShared[il0][ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2419 // outputContainer->Add(fhTimeLam0BinPerSMShared[il0][ism]) ;
2420 // } // Run 1 SM
2421  } // sm
2422  } // l0 bin
2423 
2424  for(Int_t ism = 0; ism < GetCaloUtils()->GetNumberOfSuperModulesUsed(); ism++)
2425  {
2426  fhLam0PerSM[ism] = new TH2F
2427  (Form("hLam0_sm%d",ism),
2428  Form("#it{p}_{T} vs #lambda^{2}_{0} in sm %d",ism),
2429  nptbins,ptmin,ptmax,40,0,0.4);
2430  fhLam0PerSM[ism]->SetYTitle("#lambda^{2}_{0}");
2431  fhLam0PerSM[ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2432  outputContainer->Add(fhLam0PerSM[ism]) ;
2433 
2434  fhLam1PerSM[ism] = new TH2F
2435  (Form("hLam1_sm%d",ism),
2436  Form("#it{p}_{T} vs #lambda^{2}_{1} in sm %d",ism),
2437  nptbins,ptmin,ptmax,40,0,0.4);
2438  fhLam1PerSM[ism]->SetYTitle("#lambda^{2}_{1}");
2439  fhLam1PerSM[ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2440  outputContainer->Add(fhLam1PerSM[ism]) ;
2441 
2442  fhLam0PerSMLargeTimeInClusterCell[ism] = new TH2F
2443  (Form("hLam0_sm%d_LargeTimeInClusterCell",ism),
2444  Form("#it{p}_{T} vs #lambda^{2}_{0} in sm %d,|t_{secondary cell}| > 50 ns",ism),
2445  nptbins,ptmin,ptmax,40,0,0.4);
2446  fhLam0PerSMLargeTimeInClusterCell[ism]->SetYTitle("#lambda^{2}_{0}");
2447  fhLam0PerSMLargeTimeInClusterCell[ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2448  outputContainer->Add(fhLam0PerSMLargeTimeInClusterCell[ism]) ;
2449 
2450  fhLam1PerSMLargeTimeInClusterCell[ism] = new TH2F
2451  (Form("hLam1_sm%d_LargeTimeInClusterCell",ism),
2452  Form("#it{p}_{T} vs #lambda^{2}_{1} in sm %d, |t_{secondary cell}| > 50 ns",ism),
2453  nptbins,ptmin,ptmax,40,0,0.4);
2454  fhLam1PerSMLargeTimeInClusterCell[ism]->SetYTitle("#lambda^{2}_{1}");
2455  fhLam1PerSMLargeTimeInClusterCell[ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2456  outputContainer->Add(fhLam1PerSMLargeTimeInClusterCell[ism]) ;
2457 
2458 // fhLam0PerSMSPDPileUp[ism] = new TH2F
2459 // (Form("hLam0_sm%d_SPDPileUp",ism),
2460 // Form("#it{p}_{T} vs #lambda^{2}_{0} in sm %d, Pile-up event SPD",ism),
2461 // nptbins,ptmin,ptmax,40,0,0.4);
2462 // fhLam0PerSMSPDPileUp[ism]->SetYTitle("#lambda^{2}_{0}");
2463 // fhLam0PerSMSPDPileUp[ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2464 // outputContainer->Add(fhLam0PerSMSPDPileUp[ism]) ;
2465 //
2466 // fhLam1PerSMSPDPileUp[ism] = new TH2F
2467 // (Form("hLam1_sm%d_SPDPileUp",ism),
2468 // Form("#it{p}_{T} vs #lambda^{2}_{1} in sm %d, Pile-up event SPD",ism),
2469 // nptbins,ptmin,ptmax,40,0,0.4);
2470 // fhLam1PerSMSPDPileUp[ism]->SetYTitle("#lambda^{2}_{1}");
2471 // fhLam1PerSMSPDPileUp[ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2472 // outputContainer->Add(fhLam1PerSMSPDPileUp[ism]) ;
2473 
2474 // if(ism < 12)
2475 // {
2476 // fhLam0PerSMShared[ism] = new TH2F
2477 // (Form("hLam0_sm%d_SMShared",ism),
2478 // Form("#it{p}_{T} vs #lambda^{2}_{0} in sm %d, SM shared",ism),
2479 // nptbins,ptmin,ptmax,40,0,0.4);
2480 // fhLam0PerSMShared[ism]->SetYTitle("#lambda^{2}_{0}");
2481 // fhLam0PerSMShared[ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2482 // outputContainer->Add(fhLam0PerSMShared[ism]) ;
2483 //
2484 // fhLam1PerSMShared[ism] = new TH2F
2485 // (Form("hLam1_sm%d_SMShared",ism),
2486 // Form("#it{p}_{T} vs #lambda^{2}_{1} in sm %d, SM shared",ism),
2487 // nptbins,ptmin,ptmax,40,0,0.4);
2488 // fhLam1PerSMShared[ism]->SetYTitle("#lambda^{2}_{1}");
2489 // fhLam1PerSMShared[ism]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2490 // outputContainer->Add(fhLam1PerSMShared[ism]) ;
2491 // } // run1
2492  } // sm
2493 
2494  for(Int_t ilarge = 0; ilarge < 5; ilarge++)
2495  {
2496  fhLam0PerNLargeTimeInClusterCell[ilarge] = new TH2F
2497  (Form("hLam0_NLargeTimeInClusterCell%d",ilarge),
2498  Form("#it{p}_{T} vs #lambda^{2}_{0} in sm %d,|t_{secondary cell}| > 50 ns",ilarge),
2499  nptbins,ptmin,ptmax,40,0,0.4);
2500  fhLam0PerNLargeTimeInClusterCell[ilarge]->SetYTitle("#lambda^{2}_{0}");
2501  fhLam0PerNLargeTimeInClusterCell[ilarge]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2502  outputContainer->Add(fhLam0PerNLargeTimeInClusterCell[ilarge]) ;
2503 
2504  fhLam1PerNLargeTimeInClusterCell[ilarge] = new TH2F
2505  (Form("hLam1_NLargeTimeInClusterCell%d",ilarge),
2506  Form("#it{p}_{T} vs #lambda^{2}_{1} in sm %d, |t_{secondary cell}| > 50 ns",ilarge),
2507  nptbins,ptmin,ptmax,40,0,0.4);
2508  fhLam1PerNLargeTimeInClusterCell[ilarge]->SetYTitle("#lambda^{2}_{1}");
2509  fhLam1PerNLargeTimeInClusterCell[ilarge]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2510  outputContainer->Add(fhLam1PerNLargeTimeInClusterCell[ilarge]) ;
2511  }
2512 
2513  } // regions in EMCal
2514 
2515 
2516  if(IsDataMC())
2517  {
2518  TString ptype[] = { "#gamma" , "#gamma_{#pi decay}" , "#gamma_{#eta decay}", "#gamma_{other decay}",
2519  "#pi^{0}" , "#eta" , "e^{#pm}" , "#gamma->e^{#pm}" ,
2520  "hadron?" , "Anti-N" , "Anti-P" ,
2521  "#gamma_{prompt}", "#gamma_{fragmentation}", "#gamma_{ISR}" , "String" } ;
2522 
2523  TString pname[] = { "Photon" , "PhotonPi0Decay" , "PhotonEtaDecay", "PhotonOtherDecay",
2524  "Pi0" , "Eta" , "Electron" , "Conversion" ,
2525  "Hadron" , "AntiNeutron" , "AntiProton" ,
2526  "PhotonPrompt", "PhotonFragmentation", "PhotonISR" , "String" } ;
2527 
2528  for(Int_t i = 0; i < fNOriginHistograms; i++)
2529  {
2530  fhMCE[i] = new TH1F(Form("hE_MC%s",pname[i].Data()),
2531  Form("cluster from %s : E ",ptype[i].Data()),
2532  nptbins,ptmin,ptmax);
2533  fhMCE[i]->SetXTitle("#it{E} (GeV)");
2534  outputContainer->Add(fhMCE[i]) ;
2535 
2536  fhMCPt[i] = new TH1F(Form("hPt_MC%s",pname[i].Data()),
2537  Form("cluster from %s : #it{p}_{T} ",ptype[i].Data()),
2538  nptbins,ptmin,ptmax);
2539  fhMCPt[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2540  outputContainer->Add(fhMCPt[i]) ;
2541 
2542  fhMCEta[i] = new TH2F(Form("hEta_MC%s",pname[i].Data()),
2543  Form("cluster from %s : #eta ",ptype[i].Data()),
2544  nptbins,ptmin,ptmax,netabins,etamin,etamax);
2545  fhMCEta[i]->SetYTitle("#eta");
2546  fhMCEta[i]->SetXTitle("#it{E} (GeV)");
2547  outputContainer->Add(fhMCEta[i]) ;
2548 
2549  fhMCPhi[i] = new TH2F(Form("hPhi_MC%s",pname[i].Data()),
2550  Form("cluster from %s : #phi ",ptype[i].Data()),
2551  nptbins,ptmin,ptmax,nphibins,phimin,phimax);
2552  fhMCPhi[i]->SetYTitle("#phi (rad)");
2553  fhMCPhi[i]->SetXTitle("#it{E} (GeV)");
2554  outputContainer->Add(fhMCPhi[i]) ;
2555 
2556 
2557  fhMCDeltaE[i] = new TH2F (Form("hDeltaE_MC%s",pname[i].Data()),
2558  Form("MC - Reco E from %s",pname[i].Data()),
2559  nptbins,ptmin,ptmax, 200,-50,50);
2560  fhMCDeltaE[i]->SetYTitle("#Delta #it{E} (GeV)");
2561  fhMCDeltaE[i]->SetXTitle("#it{E} (GeV)");
2562  outputContainer->Add(fhMCDeltaE[i]);
2563 
2564  fhMCDeltaPt[i] = new TH2F (Form("hDeltaPt_MC%s",pname[i].Data()),
2565  Form("MC - Reco #it{p}_{T} from %s",pname[i].Data()),
2566  nptbins,ptmin,ptmax, 200,-50,50);
2567  fhMCDeltaPt[i]->SetXTitle("p_{T,rec} (GeV/#it{c})");
2568  fhMCDeltaPt[i]->SetYTitle("#Delta #it{p}_{T} (GeV/#it{c})");
2569  outputContainer->Add(fhMCDeltaPt[i]);
2570 
2571  fhMC2E[i] = new TH2F (Form("h2E_MC%s",pname[i].Data()),
2572  Form("E distribution, reconstructed vs generated from %s",pname[i].Data()),
2573  nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2574  fhMC2E[i]->SetXTitle("#it{E}_{rec} (GeV)");
2575  fhMC2E[i]->SetYTitle("#it{E}_{gen} (GeV)");
2576  outputContainer->Add(fhMC2E[i]);
2577 
2578  fhMC2Pt[i] = new TH2F (Form("h2Pt_MC%s",pname[i].Data()),
2579  Form("p_T distribution, reconstructed vs generated from %s",pname[i].Data()),
2580  nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2581  fhMC2Pt[i]->SetXTitle("p_{T,rec} (GeV/#it{c})");
2582  fhMC2Pt[i]->SetYTitle("p_{T,gen} (GeV/#it{c})");
2583  outputContainer->Add(fhMC2Pt[i]);
2584  }
2585 
2586  TString pptype[] = { "#gamma" , "#gamma_{#pi decay}" ,
2587  "#gamma_{#eta decay}", "#gamma_{other decay}" ,
2588  "#gamma_{prompt}" , "#gamma_{fragmentation}", "#gamma_{ISR}" } ;
2589 
2590  TString ppname[] = { "Photon" , "PhotonPi0Decay" ,
2591  "PhotonEtaDecay", "PhotonOtherDecay" ,
2592  "PhotonPrompt" , "PhotonFragmentation", "PhotonISR" } ;
2593 
2594  for(Int_t i = 0; i < fNPrimaryHistograms; i++)
2595  {
2596  fhEPrimMC[i] = new TH1F(Form("hEPrim_MC%s",ppname[i].Data()),
2597  Form("primary photon %s : E ",pptype[i].Data()),
2598  nptbins,ptmin,ptmax);
2599  fhEPrimMC[i]->SetXTitle("#it{E} (GeV)");
2600  outputContainer->Add(fhEPrimMC[i]) ;
2601 
2602  fhPtPrimMC[i] = new TH1F(Form("hPtPrim_MC%s",ppname[i].Data()),
2603  Form("primary photon %s : #it{p}_{T} ",pptype[i].Data()),
2604  nptbins,ptmin,ptmax);
2605  fhPtPrimMC[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2606  outputContainer->Add(fhPtPrimMC[i]) ;
2607 
2608  fhYPrimMC[i] = new TH2F(Form("hYPrim_MC%s",ppname[i].Data()),
2609  Form("primary photon %s : Rapidity ",pptype[i].Data()),
2610  nptbins,ptmin,ptmax,200,-2,2);
2611  fhYPrimMC[i]->SetYTitle("Rapidity");
2612  fhYPrimMC[i]->SetXTitle("#it{E} (GeV)");
2613  outputContainer->Add(fhYPrimMC[i]) ;
2614 
2615  fhEtaPrimMC[i] = new TH2F(Form("hEtaPrim_MC%s",ppname[i].Data()),
2616  Form("primary photon %s : #eta",pptype[i].Data()),
2617  nptbins,ptmin,ptmax,200,-2,2);
2618  fhEtaPrimMC[i]->SetYTitle("#eta");
2619  fhEtaPrimMC[i]->SetXTitle("#it{E} (GeV)");
2620  outputContainer->Add(fhEtaPrimMC[i]) ;
2621 
2622  fhPhiPrimMC[i] = new TH2F(Form("hPhiPrim_MC%s",ppname[i].Data()),
2623  Form("primary photon %s : #phi ",pptype[i].Data()),
2624  nptbins,ptmin,ptmax,nphibins,0,TMath::TwoPi());
2625  fhPhiPrimMC[i]->SetYTitle("#phi (rad)");
2626  fhPhiPrimMC[i]->SetXTitle("#it{E} (GeV)");
2627  outputContainer->Add(fhPhiPrimMC[i]) ;
2628 
2629 
2630  fhEPrimMCAcc[i] = new TH1F(Form("hEPrimAcc_MC%s",ppname[i].Data()),
2631  Form("primary photon %s in acceptance: E ",pptype[i].Data()),
2632  nptbins,ptmin,ptmax);
2633  fhEPrimMCAcc[i]->SetXTitle("#it{E} (GeV)");
2634  outputContainer->Add(fhEPrimMCAcc[i]) ;
2635 
2636  fhPtPrimMCAcc[i] = new TH1F(Form("hPtPrimAcc_MC%s",ppname[i].Data()),
2637  Form("primary photon %s in acceptance: #it{p}_{T} ",pptype[i].Data()),
2638  nptbins,ptmin,ptmax);
2639  fhPtPrimMCAcc[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2640  outputContainer->Add(fhPtPrimMCAcc[i]) ;
2641 
2642  fhYPrimMCAcc[i] = new TH2F(Form("hYPrimAcc_MC%s",ppname[i].Data()),
2643  Form("primary photon %s in acceptance: Rapidity ",pptype[i].Data()),
2644  nptbins,ptmin,ptmax,100,-1,1);
2645  fhYPrimMCAcc[i]->SetYTitle("Rapidity");
2646  fhYPrimMCAcc[i]->SetXTitle("#it{E} (GeV)");
2647  outputContainer->Add(fhYPrimMCAcc[i]) ;
2648 
2649  fhEtaPrimMCAcc[i] = new TH2F(Form("hEtaPrimAcc_MC%s",ppname[i].Data()),
2650  Form("primary photon %s in acceptance: #eta ",pptype[i].Data()),
2651  nptbins,ptmin,ptmax,netabins,etamin,etamax);
2652  fhEtaPrimMCAcc[i]->SetYTitle("#eta");
2653  fhEtaPrimMCAcc[i]->SetXTitle("#it{E} (GeV)");
2654  outputContainer->Add(fhEtaPrimMCAcc[i]) ;
2655 
2656  fhPhiPrimMCAcc[i] = new TH2F(Form("hPhiPrimAcc_MC%s",ppname[i].Data()),
2657  Form("primary photon %s in acceptance: #phi ",pptype[i].Data()),
2658  nptbins,ptmin,ptmax,nphibins,phimin,phimax);
2659  fhPhiPrimMCAcc[i]->SetYTitle("#phi (rad)");
2660  fhPhiPrimMCAcc[i]->SetXTitle("#it{E} (GeV)");
2661  outputContainer->Add(fhPhiPrimMCAcc[i]) ;
2662  }
2663 
2664  if(fFillSSHistograms)
2665  {
2666  TString ptypess[] = { "#gamma","hadron?","#pi^{0}","#eta","#gamma->e^{#pm}","e^{#pm}"} ;
2667 
2668  TString pnamess[] = { "Photon","Hadron","Pi0","Eta","Conversion","Electron"} ;
2669 
2670  for(Int_t i = 0; i < 6; i++)
2671  {
2672  fhMCELambda0[i] = new TH2F(Form("hELambda0_MC%s",pnamess[i].Data()),
2673  Form("cluster from %s : E vs #lambda_{0}^{2}",ptypess[i].Data()),
2674  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2675  fhMCELambda0[i]->SetYTitle("#lambda_{0}^{2}");
2676  fhMCELambda0[i]->SetXTitle("#it{E} (GeV)");
2677  outputContainer->Add(fhMCELambda0[i]) ;
2678 
2679  fhMCPtLambda0[i] = new TH2F(Form("hPtLambda0_MC%s",pnamess[i].Data()),
2680  Form("cluster from %s : #it{p}_{T} vs #lambda_{0}^{2}",ptypess[i].Data()),
2681  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2682  fhMCPtLambda0[i]->SetYTitle("#lambda_{0}^{2}");
2683  fhMCPtLambda0[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2684  outputContainer->Add(fhMCPtLambda0[i]) ;
2685 
2686  fhMCELambda1[i] = new TH2F(Form("hELambda1_MC%s",pnamess[i].Data()),
2687  Form("cluster from %s : E vs #lambda_{1}^{2}",ptypess[i].Data()),
2688  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2689  fhMCELambda1[i]->SetYTitle("#lambda_{1}^{2}");
2690  fhMCELambda1[i]->SetXTitle("#it{E} (GeV)");
2691  outputContainer->Add(fhMCELambda1[i]) ;
2692 
2693  fhMCEDispersion[i] = new TH2F(Form("hEDispersion_MC%s",pnamess[i].Data()),
2694  Form("cluster from %s : E vs dispersion^{2}",ptypess[i].Data()),
2695  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2696  fhMCEDispersion[i]->SetYTitle("D^{2}");
2697  fhMCEDispersion[i]->SetXTitle("#it{E} (GeV)");
2698  outputContainer->Add(fhMCEDispersion[i]) ;
2699 
2700  fhMCNCellsE[i] = new TH2F (Form("hNCellsE_MC%s",pnamess[i].Data()),
2701  Form("# of cells in cluster from %s vs E of clusters",ptypess[i].Data()),
2702  nptbins,ptmin,ptmax, nbins,nmin,nmax);
2703  fhMCNCellsE[i]->SetXTitle("#it{E} (GeV)");
2704  fhMCNCellsE[i]->SetYTitle("# of cells in cluster");
2705  outputContainer->Add(fhMCNCellsE[i]);
2706 
2707  fhMCMaxCellDiffClusterE[i] = new TH2F (Form("hMaxCellDiffClusterE_MC%s",pnamess[i].Data()),
2708  Form("energy vs difference of cluster energy from %s - max cell energy / cluster energy, good clusters",ptypess[i].Data()),
2709  nptbins,ptmin,ptmax, 500,0,1.);
2710  fhMCMaxCellDiffClusterE[i]->SetXTitle("#it{E}_{cluster} (GeV) ");
2711  fhMCMaxCellDiffClusterE[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
2712  outputContainer->Add(fhMCMaxCellDiffClusterE[i]);
2713 
2714  if(!fFillOnlySimpleSSHisto)
2715  {
2716  fhMCLambda0vsClusterMaxCellDiffE0[i] = new TH2F(Form("hLambda0vsClusterMaxCellDiffE0_MC%s",pnamess[i].Data()),
2717  Form("cluster from %s : #lambda^{2}_{0} vs fraction of energy carried by max cell, E < 2 GeV",ptypess[i].Data()),
2718  ssbins,ssmin,ssmax,500,0,1.);
2719  fhMCLambda0vsClusterMaxCellDiffE0[i]->SetXTitle("#lambda_{0}^{2}");
2720  fhMCLambda0vsClusterMaxCellDiffE0[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
2721  outputContainer->Add(fhMCLambda0vsClusterMaxCellDiffE0[i]) ;
2722 
2723  fhMCLambda0vsClusterMaxCellDiffE2[i] = new TH2F(Form("hLambda0vsClusterMaxCellDiffE2_MC%s",pnamess[i].Data()),
2724  Form("cluster from %s : #lambda^{2}_{0} vs fraction of energy carried by max cell, 2< E < 6 GeV",ptypess[i].Data()),
2725  ssbins,ssmin,ssmax,500,0,1.);
2726  fhMCLambda0vsClusterMaxCellDiffE2[i]->SetXTitle("#lambda_{0}^{2}");
2727  fhMCLambda0vsClusterMaxCellDiffE2[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
2728  outputContainer->Add(fhMCLambda0vsClusterMaxCellDiffE2[i]) ;
2729 
2730  fhMCLambda0vsClusterMaxCellDiffE6[i] = new TH2F(Form("hLambda0vsClusterMaxCellDiffE6_MC%s",pnamess[i].Data()),
2731  Form("cluster from %s : #lambda^{2}_{0} vs fraction of energy carried by max cell, #it{E} > 6 GeV",ptypess[i].Data()),
2732  ssbins,ssmin,ssmax,500,0,1.);
2733  fhMCLambda0vsClusterMaxCellDiffE6[i]->SetXTitle("#lambda_{0}^{2}");
2734  fhMCLambda0vsClusterMaxCellDiffE6[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
2735  outputContainer->Add(fhMCLambda0vsClusterMaxCellDiffE6[i]) ;
2736 
2737  fhMCNCellsvsClusterMaxCellDiffE0[i] = new TH2F(Form("hNCellsvsClusterMaxCellDiffE0_MC%s",pnamess[i].Data()),
2738  Form("cluster from %s : N cells in cluster vs fraction of energy carried by max cell, E < 2 GeV",ptypess[i].Data()),
2739  nbins/5,nmin,nmax/5,500,0,1.);
2740  fhMCNCellsvsClusterMaxCellDiffE0[i]->SetXTitle("N cells in cluster");
2741  fhMCNCellsvsClusterMaxCellDiffE0[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
2742  outputContainer->Add(fhMCNCellsvsClusterMaxCellDiffE0[i]) ;
2743 
2744  fhMCNCellsvsClusterMaxCellDiffE2[i] = new TH2F(Form("hNCellsvsClusterMaxCellDiffE2_MC%s",pnamess[i].Data()),
2745  Form("cluster from %s : N cells in cluster vs fraction of energy carried by max cell, 2< E < 6 GeV",ptypess[i].Data()),
2746  nbins/5,nmin,nmax/5,500,0,1.);
2747  fhMCNCellsvsClusterMaxCellDiffE2[i]->SetXTitle("N cells in cluster");
2748  fhMCNCellsvsClusterMaxCellDiffE2[i]->SetYTitle("(#it{E}_{cluster} - #it{E}_{cell max})/ #it{E}_{cluster}");
2749  outputContainer->Add(fhMCNCellsvsClusterMaxCellDiffE2[i]) ;
2750 
2751  fhMCNCellsvsClusterMaxCellDiffE6[i] = new TH2F(Form("hNCellsvsClusterMaxCellDiffE6_MC%s",pnamess[i].Data()),
2752  Form("cluster from %s : N cells in cluster vs fraction of energy carried by max cell, #it{E} > 6 GeV",ptypess[i].Data()),
2753  nbins/5,nmin,nmax/5,500,0,1.);
2754  fhMCNCellsvsClusterMaxCellDiffE6[i]->SetXTitle("N cells in cluster");
2755  fhMCNCellsvsClusterMaxCellDiffE6[i]->SetYTitle("#it{E} (GeV)");
2756  outputContainer->Add(fhMCNCellsvsClusterMaxCellDiffE6[i]) ;
2757 
2758  if(GetCalorimeter()==kEMCAL)
2759  {
2760  fhMCEDispEta[i] = new TH2F (Form("hEDispEtaE_MC%s",pnamess[i].Data()),
2761  Form("cluster from %s : #sigma^{2}_{#eta #eta} = #Sigma w_{i}(#eta_{i} - <#eta>)^{2}/ #Sigma w_{i} vs E",ptypess[i].Data()),
2762  nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
2763  fhMCEDispEta[i]->SetXTitle("#it{E} (GeV)");
2764  fhMCEDispEta[i]->SetYTitle("#sigma^{2}_{#eta #eta}");
2765  outputContainer->Add(fhMCEDispEta[i]);
2766 
2767  fhMCEDispPhi[i] = new TH2F (Form("hEDispPhiE_MC%s",pnamess[i].Data()),
2768  Form("cluster from %s : #sigma^{2}_{#phi #phi} = #Sigma w_{i}(#phi_{i} - <#phi>)^{2} / #Sigma w_{i} vs E",ptypess[i].Data()),
2769  nptbins,ptmin,ptmax, ssbins,ssmin,ssmax);
2770  fhMCEDispPhi[i]->SetXTitle("#it{E} (GeV)");
2771  fhMCEDispPhi[i]->SetYTitle("#sigma^{2}_{#phi #phi}");
2772  outputContainer->Add(fhMCEDispPhi[i]);
2773 
2774  fhMCESumEtaPhi[i] = new TH2F (Form("hESumEtaPhiE_MC%s",pnamess[i].Data()),
2775  Form("cluster from %s : #delta^{2}_{#eta #phi} = #Sigma w_{i}(#phi_{i} #eta_{i} ) / #Sigma w_{i} - <#phi><#eta> vs E",ptypess[i].Data()),
2776  nptbins,ptmin,ptmax, 2*ssbins,-ssmax,ssmax);
2777  fhMCESumEtaPhi[i]->SetXTitle("#it{E} (GeV)");
2778  fhMCESumEtaPhi[i]->SetYTitle("#delta^{2}_{#eta #phi}");
2779  outputContainer->Add(fhMCESumEtaPhi[i]);
2780 
2781  fhMCEDispEtaPhiDiff[i] = new TH2F (Form("hEDispEtaPhiDiffE_MC%s",pnamess[i].Data()),
2782  Form("cluster from %s : #sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta} vs E",ptypess[i].Data()),
2783  nptbins,ptmin,ptmax,200,-10,10);
2784  fhMCEDispEtaPhiDiff[i]->SetXTitle("#it{E} (GeV)");
2785  fhMCEDispEtaPhiDiff[i]->SetYTitle("#sigma^{2}_{#phi #phi}-#sigma^{2}_{#eta #eta}");
2786  outputContainer->Add(fhMCEDispEtaPhiDiff[i]);
2787 
2788  fhMCESphericity[i] = new TH2F (Form("hESphericity_MC%s",pnamess[i].Data()),
2789  Form("cluster from %s : (#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta}) / (#sigma^{2}_{#eta #eta} + #sigma^{2}_{#phi #phi}) vs E",ptypess[i].Data()),
2790  nptbins,ptmin,ptmax, 200,-1,1);
2791  fhMCESphericity[i]->SetXTitle("#it{E} (GeV)");
2792  fhMCESphericity[i]->SetYTitle("s = (#sigma^{2}_{#phi #phi} - #sigma^{2}_{#eta #eta}) / (#sigma^{2}_{#eta #eta} + #sigma^{2}_{#phi #phi})");
2793  outputContainer->Add(fhMCESphericity[i]);
2794 
2795  for(Int_t ie = 0; ie < 7; ie++)
2796  {
2797  fhMCDispEtaDispPhi[ie][i] = new TH2F (Form("hMCDispEtaDispPhi_EBin%d_MC%s",ie,pnamess[i].Data()),
2798  Form("cluster from %s : #sigma^{2}_{#phi #phi} vs #sigma^{2}_{#eta #eta} for %d < E < %d GeV",pnamess[i].Data(),bin[ie],bin[ie+1]),
2799  ssbins,ssmin,ssmax , ssbins,ssmin,ssmax);
2800  fhMCDispEtaDispPhi[ie][i]->SetXTitle("#sigma^{2}_{#eta #eta}");
2801  fhMCDispEtaDispPhi[ie][i]->SetYTitle("#sigma^{2}_{#phi #phi}");
2802  outputContainer->Add(fhMCDispEtaDispPhi[ie][i]);
2803 
2804  fhMCLambda0DispEta[ie][i] = new TH2F (Form("hMCLambda0DispEta_EBin%d_MC%s",ie,pnamess[i].Data()),
2805  Form("cluster from %s : #lambda^{2}_{0} vs #sigma^{2}_{#eta #eta} for %d < E < %d GeV",pnamess[i].Data(),bin[ie],bin[ie+1]),
2806  ssbins,ssmin,ssmax , ssbins,ssmin,ssmax);
2807  fhMCLambda0DispEta[ie][i]->SetXTitle("#lambda^{2}_{0}");
2808  fhMCLambda0DispEta[ie][i]->SetYTitle("#sigma^{2}_{#phi #phi}");
2809  outputContainer->Add(fhMCLambda0DispEta[ie][i]);
2810 
2811  fhMCLambda0DispPhi[ie][i] = new TH2F (Form("hMCLambda0DispPhi_EBin%d_MC%s",ie,pnamess[i].Data()),
2812  Form("cluster from %s :#lambda^{2}_{0} vs #sigma^{2}_{#phi #phi} for %d < E < %d GeV",pnamess[i].Data(),bin[ie],bin[ie+1]),
2813  ssbins,ssmin,ssmax , ssbins,ssmin,ssmax);
2814  fhMCLambda0DispPhi[ie][i]->SetXTitle("#lambda^{2}_{0}");
2815  fhMCLambda0DispPhi[ie][i]->SetYTitle("#sigma^{2}_{#phi #phi}");
2816  outputContainer->Add(fhMCLambda0DispPhi[ie][i]);
2817  }
2818  }
2819  }
2820  }// loop
2821 
2822  if(!GetReader()->IsEmbeddedClusterSelectionOn())
2823  {
2824  fhMCPhotonELambda0NoOverlap = new TH2F("hELambda0_MCPhoton_NoOverlap",
2825  "cluster from Photon : E vs #lambda_{0}^{2}",
2826  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2827  fhMCPhotonELambda0NoOverlap->SetYTitle("#lambda_{0}^{2}");
2828  fhMCPhotonELambda0NoOverlap->SetXTitle("#it{E} (GeV)");
2829  outputContainer->Add(fhMCPhotonELambda0NoOverlap) ;
2830 
2831  fhMCPhotonELambda0TwoOverlap = new TH2F("hELambda0_MCPhoton_TwoOverlap",
2832  "cluster from Photon : E vs #lambda_{0}^{2}",
2833  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2834  fhMCPhotonELambda0TwoOverlap->SetYTitle("#lambda_{0}^{2}");
2835  fhMCPhotonELambda0TwoOverlap->SetXTitle("#it{E} (GeV)");
2836  outputContainer->Add(fhMCPhotonELambda0TwoOverlap) ;
2837 
2838  fhMCPhotonELambda0NOverlap = new TH2F("hELambda0_MCPhoton_NOverlap",
2839  "cluster from Photon : E vs #lambda_{0}^{2}",
2840  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2841  fhMCPhotonELambda0NOverlap->SetYTitle("#lambda_{0}^{2}");
2842  fhMCPhotonELambda0NOverlap->SetXTitle("#it{E} (GeV)");
2843  outputContainer->Add(fhMCPhotonELambda0NOverlap) ;
2844  } // No embedding
2845 
2846  if(GetReader()->IsEmbeddedClusterSelectionOn())
2847  {
2848  fhEmbeddedSignalFractionEnergy = new TH2F("hEmbeddedSignal_FractionEnergy",
2849  "Energy Fraction of embedded signal versus cluster energy",
2850  nptbins,ptmin,ptmax,100,0.,1.);
2851  fhEmbeddedSignalFractionEnergy->SetYTitle("Fraction");
2852  fhEmbeddedSignalFractionEnergy->SetXTitle("#it{E} (GeV)");
2853  outputContainer->Add(fhEmbeddedSignalFractionEnergy) ;
2854 
2855  fhEmbedPhotonELambda0FullSignal = new TH2F("hELambda0_EmbedPhoton_FullSignal",
2856  "cluster from Photon embedded with more than 90% energy in cluster : E vs #lambda_{0}^{2}",
2857  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2858  fhEmbedPhotonELambda0FullSignal->SetYTitle("#lambda_{0}^{2}");
2859  fhEmbedPhotonELambda0FullSignal->SetXTitle("#it{E} (GeV)");
2860  outputContainer->Add(fhEmbedPhotonELambda0FullSignal) ;
2861 
2862  fhEmbedPhotonELambda0MostlySignal = new TH2F("hELambda0_EmbedPhoton_MostlySignal",
2863  "cluster from Photon embedded with 50% to 90% energy in cluster : E vs #lambda_{0}^{2}",
2864  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2865  fhEmbedPhotonELambda0MostlySignal->SetYTitle("#lambda_{0}^{2}");
2866  fhEmbedPhotonELambda0MostlySignal->SetXTitle("#it{E} (GeV)");
2867  outputContainer->Add(fhEmbedPhotonELambda0MostlySignal) ;
2868 
2869  fhEmbedPhotonELambda0MostlyBkg = new TH2F("hELambda0_EmbedPhoton_MostlyBkg",
2870  "cluster from Photon embedded with 10% to 50% energy in cluster : E vs #lambda_{0}^{2}",
2871  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2872  fhEmbedPhotonELambda0MostlyBkg->SetYTitle("#lambda_{0}^{2}");
2873  fhEmbedPhotonELambda0MostlyBkg->SetXTitle("#it{E} (GeV)");
2874  outputContainer->Add(fhEmbedPhotonELambda0MostlyBkg) ;
2875 
2876  fhEmbedPhotonELambda0FullBkg = new TH2F("hELambda0_EmbedPhoton_FullBkg",
2877  "cluster from Photonm embedded with 0% to 10% energy in cluster : E vs #lambda_{0}^{2}",
2878  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2879  fhEmbedPhotonELambda0FullBkg->SetYTitle("#lambda_{0}^{2}");
2880  fhEmbedPhotonELambda0FullBkg->SetXTitle("#it{E} (GeV)");
2881  outputContainer->Add(fhEmbedPhotonELambda0FullBkg) ;
2882 
2883  fhEmbedPi0ELambda0FullSignal = new TH2F("hELambda0_EmbedPi0_FullSignal",
2884  "cluster from Pi0 embedded with more than 90% energy in cluster : E vs #lambda_{0}^{2}",
2885  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2886  fhEmbedPi0ELambda0FullSignal->SetYTitle("#lambda_{0}^{2}");
2887  fhEmbedPi0ELambda0FullSignal->SetXTitle("#it{E} (GeV)");
2888  outputContainer->Add(fhEmbedPi0ELambda0FullSignal) ;
2889 
2890  fhEmbedPi0ELambda0MostlySignal = new TH2F("hELambda0_EmbedPi0_MostlySignal",
2891  "cluster from Pi0 embedded with 50% to 90% energy in cluster : E vs #lambda_{0}^{2}",
2892  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2893  fhEmbedPi0ELambda0MostlySignal->SetYTitle("#lambda_{0}^{2}");
2894  fhEmbedPi0ELambda0MostlySignal->SetXTitle("#it{E} (GeV)");
2895  outputContainer->Add(fhEmbedPi0ELambda0MostlySignal) ;
2896 
2897  fhEmbedPi0ELambda0MostlyBkg = new TH2F("hELambda0_EmbedPi0_MostlyBkg",
2898  "cluster from Pi0 embedded with 10% to 50% energy in cluster : E vs #lambda_{0}^{2}",
2899  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2900  fhEmbedPi0ELambda0MostlyBkg->SetYTitle("#lambda_{0}^{2}");
2901  fhEmbedPi0ELambda0MostlyBkg->SetXTitle("#it{E} (GeV)");
2902  outputContainer->Add(fhEmbedPi0ELambda0MostlyBkg) ;
2903 
2904  fhEmbedPi0ELambda0FullBkg = new TH2F("hELambda0_EmbedPi0_FullBkg",
2905  "cluster from Pi0 embedded with 0% to 10% energy in cluster : E vs #lambda_{0}^{2}",
2906  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2907  fhEmbedPi0ELambda0FullBkg->SetYTitle("#lambda_{0}^{2}");
2908  fhEmbedPi0ELambda0FullBkg->SetXTitle("#it{E} (GeV)");
2909  outputContainer->Add(fhEmbedPi0ELambda0FullBkg) ;
2910  }// embedded histograms
2911  }// Fill SS MC histograms
2912 
2913 
2914  if(fFillConversionVertexHisto)
2915  {
2916  fhMCConversionVertex = new TH2F("hMCPhotonConversionVertex","cluster from converted photon, #it{p}_{T} vs vertex distance",
2917  nptbins,ptmin,ptmax,500,0,500);
2918  fhMCConversionVertex->SetYTitle("#it{R} (cm)");
2919  fhMCConversionVertex->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2920  outputContainer->Add(fhMCConversionVertex) ;
2921 
2922  if(GetCalorimeter() == kEMCAL && GetFirstSMCoveredByTRD() >= 0)
2923  {
2924  fhMCConversionVertexTRD = new TH2F("hMCPhotonConversionVertexTRD","cluster from converted photon, #it{p}_{T} vs vertex distance, SM covered by TRD",
2925  nptbins,ptmin,ptmax,500,0,500);
2926  fhMCConversionVertexTRD->SetYTitle("#it{R} (cm)");
2927  fhMCConversionVertexTRD->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2928  outputContainer->Add(fhMCConversionVertexTRD) ;
2929  }
2930 
2931  if(fFillSSHistograms)
2932  {
2933  TString region[] = {"ITS","TPC","TRD","TOF","Top EMCal","In EMCal"};
2934  for(Int_t iR = 0; iR < 6; iR++)
2935  {
2936  fhMCConversionLambda0Rcut[iR] = new TH2F(Form("hMCPhotonConversionLambda0_R%d",iR),
2937  Form("cluster from converted photon, #it{p}_{T} vs #lambda_{0}^{2}, conversion in %s",region[iR].Data()),
2938  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2939  fhMCConversionLambda0Rcut[iR]->SetYTitle("#lambda_{0}^{2}");
2940  fhMCConversionLambda0Rcut[iR]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2941  outputContainer->Add(fhMCConversionLambda0Rcut[iR]) ;
2942 
2943  fhMCConversionLambda1Rcut[iR] = new TH2F(Form("hMCPhotonConversionLambda1_R%d",iR),
2944  Form("cluster from converted photon, #it{p}_{T} vs #lambda_{1}^{2}, conversion in %s",region[iR].Data()),
2945  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2946  fhMCConversionLambda1Rcut[iR]->SetYTitle("#lambda_{1}^{2}");
2947  fhMCConversionLambda1Rcut[iR]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2948  outputContainer->Add(fhMCConversionLambda1Rcut[iR]) ;
2949  } // R cut
2950 
2951 
2952  if(GetCalorimeter() == kEMCAL && GetFirstSMCoveredByTRD() >= 0)
2953  {
2954  for(Int_t iR = 0; iR < 6; iR++)
2955  {
2956  fhMCConversionLambda0RcutTRD[iR] = new TH2F(Form("hMCPhotonConversionLambda0TRD_R%d",iR),
2957  Form("cluster from converted photon, #it{p}_{T} vs #lambda_{0}^{2}, conversion in %s, SM covered by TRD",region[iR].Data()),
2958  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2959  fhMCConversionLambda0RcutTRD[iR]->SetYTitle("#lambda_{0}^{2}");
2960  fhMCConversionLambda0RcutTRD[iR]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2961  outputContainer->Add(fhMCConversionLambda0RcutTRD[iR]) ;
2962 
2963  fhMCConversionLambda1RcutTRD[iR] = new TH2F(Form("hMCPhotonConversionLambda1TRD_R%d",iR),
2964  Form("cluster from converted photon, #it{p}_{T} vs #lambda_{1}^{2}, conversion in %s, SM covered by TRD",region[iR].Data()),
2965  nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2966  fhMCConversionLambda1RcutTRD[iR]->SetYTitle("#lambda_{1}^{2}");
2967  fhMCConversionLambda1RcutTRD[iR]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2968  outputContainer->Add(fhMCConversionLambda1RcutTRD[iR]) ;
2969  } // R cut
2970  }
2971 
2972  // if(GetCalorimeter() == kEMCAL && fFillEMCALRegionSSHistograms)
2973  // {
2974  // for(Int_t ieta = 0; ieta < 4; ieta++)
2975  // {
2976  // for(Int_t iphi = 0; iphi < 3; iphi++)
2977  // {
2978  // for(Int_t iR = 0; iR < 6; iR++)
2979  // {
2980  // fhLam0EMCALRegionMCConvRcut[ieta][iphi][iR] =
2981  // new TH2F(Form("hMCPhotonConversionLambda0_R%d_eta%d_phi%d",iR,ieta,iphi),
2982  // Form("cluster from converted photon, #it{p}_{T} vs #lambda_{0}^{2}, conversion in %s, region eta %d, phi %d",region[iR].Data(),ieta,iphi),
2983  // nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2984  // fhLam0EMCALRegionMCConvRcut[ieta][iphi][iR]->SetYTitle("#lambda_{0}^{2}");
2985  // fhLam0EMCALRegionMCConvRcut[ieta][iphi][iR]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2986  // outputContainer->Add(fhLam0EMCALRegionMCConvRcut[ieta][iphi][iR]) ;
2987  //
2988  // if(GetFirstSMCoveredByTRD() >= 0)
2989  // {
2990  // fhLam0EMCALRegionTRDMCConvRcut[ieta][iphi][iR] =
2991  // new TH2F(Form("hMCPhotonConversionLambda0TRD_R%d_eta%d_phi%d",iR,ieta,iphi),
2992  // Form("cluster from converted photon, #it{p}_{T} vs #lambda_{0}^{2}, conversion in %s, region eta %d, phi %d, SM covered by TRD",region[iR].Data(),ieta,iphi),
2993  // nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2994  // fhLam0EMCALRegionTRDMCConvRcut[ieta][iphi][iR]->SetYTitle("#lambda_{0}^{2}");
2995  // fhLam0EMCALRegionTRDMCConvRcut[ieta][iphi][iR]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
2996  // outputContainer->Add(fhLam0EMCALRegionTRDMCConvRcut[ieta][iphi][iR]) ;
2997  // } // TRD
2998  //
2999  // } // iR
3000  // } // iphi
3001  // } // ieta
3002  // } // regions in EMCal
3003  } // shower shape
3004  } // conversion vertex
3005  } // Histos with MC
3006 
3007  return outputContainer ;
3008 }
3009 
3010 //_______________________
3012 //_______________________
3013 void AliAnaPhoton::Init()
3014 {
3015  if ( GetCalorimeter() == kPHOS && !GetReader()->IsPHOSSwitchedOn() && NewOutputAOD() )
3016  AliFatal("!!STOP: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!");
3017  else if( GetCalorimeter() == kEMCAL && !GetReader()->IsEMCALSwitchedOn() && NewOutputAOD() )
3018  AliFatal("!!STOP: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!");
3019 
3020  // Trick to select primary photon particles in the analysis of pure MC input
3021  if(GetReader()->GetDataType() == AliCaloTrackReader::kMC) GetCaloPID()->SwitchOnBayesian();
3022 }
3023 
3024 //_________________________________
3026 //_________________________________
3027 void AliAnaPhoton::InitParameters()
3028 {
3029  AddToHistogramsName("AnaPhoton_");
3030 
3031  fMinDist = 2.;
3032  fMinDist2 = 4.;
3033  fMinDist3 = 5.;
3034 
3035  fTimeCutMin =-1000000;
3036  fTimeCutMax = 1000000;
3037  fNCellsCut = 0;
3038 
3039  fRejectTrackMatch = kTRUE ;
3040 }
3041 
3042 //_______________________________________
3046 //_______________________________________
3047 void AliAnaPhoton::MakeAnalysisFillAOD()
3048 {
3049  // Get the vertex
3050  Double_t v[3] = {0,0,0}; //vertex ;
3051  GetReader()->GetVertex(v);
3052 
3053  // Select the Calorimeter of the photon
3054  TObjArray * pl = 0x0;
3055  AliVCaloCells* cells = 0;
3056  if (GetCalorimeter() == kPHOS )
3057  {
3058  pl = GetPHOSClusters();
3059  cells = GetPHOSCells();
3060  }
3061  else if (GetCalorimeter() == kEMCAL)
3062  {
3063  pl = GetEMCALClusters();
3064  cells = GetEMCALCells();
3065  }
3066 
3067  if(!pl)
3068  {
3069  AliWarning(Form("TObjArray with %s clusters is NULL!",GetCalorimeterString().Data()));
3070  return;
3071  }
3072 
3073  // Loop on raw clusters before filtering in the reader and fill control histogram
3074  if((GetReader()->GetEMCALClusterListName()=="" && GetCalorimeter()==kEMCAL) || GetCalorimeter()==kPHOS)
3075  {
3076  for(Int_t iclus = 0; iclus < GetReader()->GetInputEvent()->GetNumberOfCaloClusters(); iclus++ )
3077  {
3078  AliVCluster * clus = GetReader()->GetInputEvent()->GetCaloCluster(iclus);
3079 
3080  if (GetCalorimeter() == kPHOS && clus->IsPHOS() && clus->E() > GetReader()->GetPHOSPtMin() )
3081  {
3082  clus->GetMomentum(fMomentum,GetVertex(0)) ;
3083 
3084  fhClusterCutsE [0]->Fill(fMomentum.E() , GetEventWeight());
3085  fhClusterCutsPt[0]->Fill(fMomentum.Pt(), GetEventWeight());
3086  }
3087  else if(GetCalorimeter() == kEMCAL && clus->IsEMCAL() && clus->E() > GetReader()->GetEMCALPtMin())
3088  {
3089  clus->GetMomentum(fMomentum,GetVertex(0)) ;
3090 
3091  fhClusterCutsE [0]->Fill(fMomentum.E(), GetEventWeight());
3092  fhClusterCutsPt[0]->Fill(fMomentum.Pt(), GetEventWeight());
3093  }
3094  }
3095  }
3096  else
3097  { // reclusterized
3098  TClonesArray * clusterList = 0;
3099 
3100  if(GetReader()->GetInputEvent()->FindListObject(GetReader()->GetEMCALClusterListName()))
3101  clusterList = dynamic_cast<TClonesArray*> (GetReader()->GetInputEvent()->FindListObject(GetReader()->GetEMCALClusterListName()));
3102  else if(GetReader()->GetOutputEvent())
3103  clusterList = dynamic_cast<TClonesArray*> (GetReader()->GetOutputEvent()->FindListObject(GetReader()->GetEMCALClusterListName()));
3104 
3105  if(clusterList)
3106  {
3107  Int_t nclusters = clusterList->GetEntriesFast();
3108  for (Int_t iclus = 0; iclus < nclusters; iclus++)
3109  {
3110  AliVCluster * clus = dynamic_cast<AliVCluster*> (clusterList->At(iclus));
3111 
3112  if(clus && clus->E() > GetReader()->GetEMCALPtMin())
3113  {
3114  clus->GetMomentum(fMomentum,GetVertex(0)) ;
3115 
3116  fhClusterCutsE [0]->Fill(clus->E() , GetEventWeight());
3117  fhClusterCutsPt[0]->Fill(fMomentum.Pt(), GetEventWeight());
3118  }
3119  }
3120  }
3121  }
3122 
3123  // Init arrays, variables, get number of clusters
3124  Int_t nCaloClusters = pl->GetEntriesFast();
3125 
3126  AliDebug(1,Form("Input %s cluster entries %d", GetCalorimeterString().Data(), nCaloClusters));
3127 
3128  //----------------------------------------------------
3129  // Fill AOD with PHOS/EMCAL AliAODPWG4Particle objects
3130  //----------------------------------------------------
3131  // Loop on clusters
3132  for(Int_t icalo = 0; icalo < nCaloClusters; icalo++)
3133  {
3134  AliVCluster * calo = (AliVCluster*) (pl->At(icalo));
3135  //printf("calo %d, %f\n",icalo,calo->E());
3136 
3137  //Get the index where the cluster comes, to retrieve the corresponding vertex
3138  Int_t evtIndex = 0 ;
3139  if (GetMixedEvent())
3140  {
3141  evtIndex=GetMixedEvent()->EventIndexForCaloCluster(calo->GetID()) ;
3142  //Get the vertex and check it is not too large in z
3143  if(TMath::Abs(GetVertex(evtIndex)[2])> GetZvertexCut()) continue;
3144  }
3145 
3146  //Cluster selection, not charged, with photon id and in fiducial cut
3147  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC)
3148  {
3149  calo->GetMomentum(fMomentum,GetVertex(evtIndex)) ;
3150  }//Assume that come from vertex in straight line
3151  else
3152  {
3153  Double_t vertex[]={0,0,0};
3154  calo->GetMomentum(fMomentum,vertex) ;
3155  }
3156 
3157  //-----------------------------
3158  // Cluster selection
3159  //-----------------------------
3160  Int_t nMaxima = GetCaloUtils()->GetNumberOfLocalMaxima(calo, cells); // NLM
3161  if(!ClusterSelected(calo,nMaxima)) continue;
3162 
3163  //----------------------------
3164  // Create AOD for analysis
3165  //----------------------------
3166  AliAODPWG4Particle aodph = AliAODPWG4Particle(fMomentum);
3167 
3168  //...............................................
3169  // Set the indeces of the original caloclusters (MC, ID), and calorimeter
3170  Int_t label = calo->GetLabel();
3171  aodph.SetLabel(label);
3172  aodph.SetCaloLabel(calo->GetID(),-1);
3173  aodph.SetDetectorTag(GetCalorimeter());
3174  //printf("Index %d, Id %d, iaod %d\n",icalo, calo->GetID(),GetOutputAODBranch()->GetEntriesFast());
3175 
3176  //...............................................
3177  // Set bad channel distance bit
3178  Double_t distBad=calo->GetDistanceToBadChannel() ; //Distance to bad channel
3179  if (distBad > fMinDist3) aodph.SetDistToBad(2) ;
3180  else if(distBad > fMinDist2) aodph.SetDistToBad(1) ;
3181  else aodph.SetDistToBad(0) ;
3182  //printf("DistBad %f Bit %d\n",distBad, aodph.DistToBad());
3183 
3184  //-------------------------------------
3185  // Play with the MC stack if available
3186  //-------------------------------------
3187 
3188  // Check origin of the candidates
3189  Int_t tag = -1;
3190 
3191  if(IsDataMC())
3192  {
3193  tag = GetMCAnalysisUtils()->CheckOrigin(calo->GetLabels(),calo->GetNLabels(),GetReader(),GetCalorimeter());
3194  aodph.SetTag(tag);
3195 
3196  AliDebug(1,Form("Origin of candidate, bit map %d",aodph.GetTag()));
3197  }//Work with stack also
3198 
3199  //--------------------------------------------------------
3200  // Fill some shower shape histograms before PID is applied
3201  //--------------------------------------------------------
3202 
3203  Float_t maxCellFraction = 0;
3204  Int_t absIdMax = GetCaloUtils()->GetMaxEnergyCell(cells, calo, maxCellFraction);
3205  if( absIdMax < 0 ) AliFatal("Wrong absID");
3206 
3207  Int_t largeTimeInCellCluster = kFALSE;
3208  FillShowerShapeHistograms(calo,tag,maxCellFraction,largeTimeInCellCluster);
3209  aodph.SetFiducialArea(largeTimeInCellCluster); // Temporary use of this container, FIXME
3210  //if(largeTimeInCellCluster > 1) printf("Set n cells large time %d, pt %2.2f\n",aodph.GetFiducialArea(),aodph.Pt());
3211 
3212  aodph.SetM02(calo->GetM02());
3213  aodph.SetM20(calo->GetM20());
3214  aodph.SetNLM(nMaxima);
3215 
3216  Float_t time = calo->GetTOF()*1e9;
3217  if(time > 400) time-=fConstantTimeShift; // in case of clusterizer running before (calibrate clusters not cells)
3218  aodph.SetTime(time);
3219 
3220  aodph.SetNCells(calo->GetNCells());
3221  Int_t nSM = GetModuleNumber(calo);
3222  aodph.SetSModNumber(nSM);
3223 
3224  //-------------------------------------
3225  // PID selection or bit setting
3226  //-------------------------------------
3227 
3228  //...............................................
3229  // Data, PID check on
3230  if(IsCaloPIDOn())
3231  {
3232  // Get most probable PID, 2 options check bayesian PID weights or redo PID
3233  // By default, redo PID
3234 
3235  aodph.SetIdentifiedParticleType(GetCaloPID()->GetIdentifiedParticleType(calo));
3236 
3237  AliDebug(1,Form("PDG of identified particle %d",aodph.GetIdentifiedParticleType()));
3238 
3239  //If cluster does not pass pid, not photon, skip it.
3240  if(aodph.GetIdentifiedParticleType() != AliCaloPID::kPhoton) continue ;
3241  }
3242 
3243  //...............................................
3244  // Data, PID check off
3245  else
3246  {
3247  // Set PID bits for later selection (AliAnaPi0 for example)
3248  // GetIdentifiedParticleType already called in SetPIDBits.
3249 
3250  GetCaloPID()->SetPIDBits(calo,&aodph, GetCaloUtils(),GetReader()->GetInputEvent());
3251 
3252  AliDebug(1,"PID Bits set");
3253  }
3254 
3255  AliDebug(1,Form("Photon selection cuts passed: pT %3.2f, pdg %d",aodph.Pt(),aodph.GetIdentifiedParticleType()));
3256 
3257 
3258  Float_t en = fMomentum.E ();
3259  Float_t pt = fMomentum.Pt();
3260 
3261  fhClusterCutsE [9]->Fill(en, GetEventWeight());
3262  fhClusterCutsPt[9]->Fill(pt, GetEventWeight());
3263 
3264  if(nSM < GetCaloUtils()->GetNumberOfSuperModulesUsed() && nSM >=0)
3265  {
3266  fhEPhotonSM ->Fill(en, nSM, GetEventWeight());
3267  fhPtPhotonSM->Fill(pt, nSM, GetEventWeight());
3268  }
3269 
3270  fhNLocMax->Fill(calo->E(),nMaxima);
3271 
3272  // Few more control histograms for selected clusters
3273  fhMaxCellDiffClusterE->Fill(en, maxCellFraction , GetEventWeight());
3274  fhNCellsE ->Fill(en, calo->GetNCells() , GetEventWeight());
3275  fhTimePt ->Fill(pt, time , GetEventWeight());
3276 
3277  if(cells)
3278  {
3279  for(Int_t icell = 0; icell < calo->GetNCells(); icell++)
3280  fhCellsE->Fill(en, cells->GetCellAmplitude(calo->GetCellsAbsId()[icell]), GetEventWeight());
3281  }
3282 
3283  // Matching after cuts
3284  if( fFillTMHisto ) FillTrackMatchingResidualHistograms(calo,1);
3285 
3286  // Fill histograms to undertand pile-up before other cuts applied
3287  // Remember to relax time cuts in the reader
3288  if( IsPileUpAnalysisOn() ) FillPileUpHistograms(calo,cells, absIdMax);
3289 
3290  // Add AOD with photon object to aod branch
3291  AddAODParticle(aodph);
3292  }// loop
3293 
3294  AliDebug(1,Form("End fill AODs, with %d entries",GetOutputAODBranch()->GetEntriesFast()));
3295 }
3296 
3297 //______________________________________________
3298 // Fill histograms with selected clusters/output AOD particles.
3299 //______________________________________________
3300 void AliAnaPhoton::MakeAnalysisFillHistograms()
3301 {
3302  // In case of simulated data, fill acceptance histograms
3303  if(IsDataMC()) FillAcceptanceHistograms();
3304 
3305  // Get vertex
3306  Double_t v[3] = {0,0,0}; //vertex ;
3307  GetReader()->GetVertex(v);
3308  //fhVertex->Fill(v[0],v[1],v[2]);
3309  if(TMath::Abs(v[2]) > GetZvertexCut()) return ; // done elsewhere for Single Event analysis, but there for mixed event
3310 
3311  //----------------------------------
3312  // Loop on stored AOD photons
3313  Int_t naod = GetOutputAODBranch()->GetEntriesFast();
3314  AliDebug(1,Form("AOD branch entries %d", naod));
3315 
3316  Float_t cen = GetEventCentrality();
3317  // printf("++++++++++ GetEventCentrality() %f\n",cen);
3318 
3319  Float_t ep = GetEventPlaneAngle();
3320 
3321  for(Int_t iaod = 0; iaod < naod ; iaod++)
3322  {
3323  AliAODPWG4Particle* ph = (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));
3324  Int_t pdg = ph->GetIdentifiedParticleType();
3325 
3326  AliDebug(2,Form("PDG %d, MC TAG %d, Calorimeter <%d>",ph->GetIdentifiedParticleType(),ph->GetTag(), ph->GetDetectorTag())) ;
3327 
3328  // If PID used, fill histos with photons in Calorimeter GetCalorimeter()
3329  if(IsCaloPIDOn() && pdg != AliCaloPID::kPhoton) continue;
3330 
3331  if(((Int_t) ph->GetDetectorTag()) != GetCalorimeter()) continue;
3332 
3333  AliDebug(2,Form("ID Photon: pt %f, phi %f, eta %f", ph->Pt(),ph->Phi(),ph->Eta())) ;
3334 
3335  //................................
3336  //Fill photon histograms
3337  Float_t ptcluster = ph->Pt();
3338  Float_t phicluster = ph->Phi();
3339  Float_t etacluster = ph->Eta();
3340  Float_t ecluster = ph->E();
3341 
3342  fhEPhoton ->Fill(ecluster , GetEventWeight());
3343  fhPtPhoton ->Fill(ptcluster, GetEventWeight());
3344 
3345  fhPhiPhoton ->Fill(ptcluster, phicluster, GetEventWeight());
3346  fhEtaPhoton ->Fill(ptcluster, etacluster, GetEventWeight());
3347 
3348  if (ecluster > 0.5) fhEtaPhiPhoton ->Fill(etacluster, phicluster, GetEventWeight());
3349  else if(GetMinPt() < 0.5) fhEtaPhi05Photon->Fill(etacluster, phicluster, GetEventWeight());
3350 
3351  if(IsHighMultiplicityAnalysisOn())
3352  {
3353  fhPtCentralityPhoton ->Fill(ptcluster,cen, GetEventWeight()) ;
3354  fhPtEventPlanePhoton ->Fill(ptcluster,ep , GetEventWeight()) ;
3355  }
3356 
3357 // Comment this part, not needed but in case to know how to do it in the future
3358 // // Get original cluster, to recover some information
3359 // AliVCaloCells* cells = 0;
3360 // TObjArray * clusters = 0;
3361 // if(GetCalorimeter() == kEMCAL)
3362 // {
3363 // cells = GetEMCALCells();
3364 // clusters = GetEMCALClusters();
3365 // }
3366 // else
3367 // {
3368 // cells = GetPHOSCells();
3369 // clusters = GetPHOSClusters();
3370 // }
3371 //
3372 // Int_t iclus = -1;
3373 // AliVCluster *cluster = FindCluster(clusters,ph->GetCaloLabel(0),iclus);
3374 // if(cluster)
3375 
3376  //.......................................
3377  // Play with the MC data if available
3378  if(IsDataMC())
3379  {
3380  //....................................................................
3381  // Access MC information in stack if requested, check that it exists.
3382  Int_t label = ph->GetLabel();
3383 
3384  if(label < 0)
3385  {
3386  AliDebug(1,Form("*** bad label ***: label %d", label));
3387  continue;
3388  }
3389 
3390  Float_t eprim = 0;
3391  Float_t ptprim = 0;
3392  Bool_t ok = kFALSE;
3393  Int_t pdg = 0, status = 0, momLabel = -1;
3394 
3395  //fPrimaryMom = GetMCAnalysisUtils()->GetMother(label,GetReader(),ok);
3396  fPrimaryMom = GetMCAnalysisUtils()->GetMother(label,GetReader(), pdg, status, ok, momLabel);
3397 
3398  if(ok)
3399  {
3400  eprim = fPrimaryMom.Energy();
3401  ptprim = fPrimaryMom.Pt();
3402  }
3403 
3404  Int_t tag =ph->GetTag();
3405  Int_t mcParticleTag = -1;
3406  if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && fhMCE[kmcPhoton])
3407  {
3408  fhMCE [kmcPhoton] ->Fill(ecluster , GetEventWeight());
3409  fhMCPt [kmcPhoton] ->Fill(ptcluster, GetEventWeight());
3410 
3411  fhMCPhi[kmcPhoton] ->Fill(ecluster,phicluster, GetEventWeight());
3412  fhMCEta[kmcPhoton] ->Fill(ecluster,etacluster, GetEventWeight());
3413 
3414  fhMC2E [kmcPhoton] ->Fill(ecluster , eprim , GetEventWeight());
3415  fhMC2Pt [kmcPhoton] ->Fill(ptcluster, ptprim, GetEventWeight());
3416 
3417  fhMCDeltaE [kmcPhoton] ->Fill(ecluster , eprim-ecluster , GetEventWeight());
3418  fhMCDeltaPt[kmcPhoton] ->Fill(ptcluster, ptprim-ptcluster, GetEventWeight());
3419 
3420  if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion) &&
3421  fhMCE[kmcConversion])
3422  {
3423  fhMCE [kmcConversion] ->Fill(ecluster , GetEventWeight());
3424  fhMCPt [kmcConversion] ->Fill(ptcluster, GetEventWeight());
3425 
3426  fhMCPhi[kmcConversion] ->Fill(ecluster, phicluster, GetEventWeight());
3427  fhMCEta[kmcConversion] ->Fill(ecluster, etacluster, GetEventWeight());
3428 
3429  fhMC2E [kmcConversion] ->Fill(ecluster , eprim , GetEventWeight());
3430  fhMC2Pt [kmcConversion] ->Fill(ptcluster, ptprim, GetEventWeight());
3431 
3432  fhMCDeltaE [kmcConversion] ->Fill(ecluster , eprim-ecluster , GetEventWeight());
3433  fhMCDeltaPt[kmcConversion] ->Fill(ptcluster, ptprim-ptcluster, GetEventWeight());
3434 
3435  Int_t pdgD = 0, statusD = 0, daugLabel = -1;
3436  Bool_t okD = kFALSE;
3437 
3438  //fMomentum =
3439  GetMCAnalysisUtils()->GetDaughter(0,momLabel,GetReader(),pdgD, statusD, okD, daugLabel, fProdVertex);
3440 
3441  if(okD)
3442  {
3443  Float_t prodR = TMath::Sqrt(fProdVertex.X()*fProdVertex.X()+fProdVertex.Y()*fProdVertex.Y());
3444 
3445  //printf("Conversion: mom pdg %d (stat %d), 1st daugher %d (stat %d), mom label %d, org label %d, daugh label %d, prodR %f\n",pdg,status, pdgD, statusD,
3446  // momLabel, label,daugLabel,prodR);
3447 
3448  if(fFillConversionVertexHisto)
3449  {
3450 
3451  fhMCConversionVertex->Fill(ptcluster,prodR,GetEventWeight());
3452 
3453  if(GetCalorimeter() == kEMCAL && GetFirstSMCoveredByTRD() >= 0 && ph->GetSModNumber() >= GetFirstSMCoveredByTRD() )
3454  fhMCConversionVertexTRD->Fill(ptcluster,prodR,GetEventWeight());
3455  }
3456 
3457  if ( fFillSSHistograms )
3458  {
3459  Float_t m02 = ph->GetM02();
3460  Float_t m20 = ph->GetM20();
3461 
3462  // conversion vertex vs shower shape
3463  if(fFillConversionVertexHisto)
3464  {
3465  Int_t convR = -1;
3466  if ( prodR < 75. ) convR = 0;
3467  else if ( prodR < 275. ) convR = 1;
3468  else if ( prodR < 375. ) convR = 2;
3469  else if ( prodR < 400. ) convR = 3;
3470  else if ( prodR < 430. ) convR = 4;
3471  else convR = 5;
3472 
3473  if ( convR >= 0 )
3474  {
3475  fhMCConversionLambda0Rcut[convR]->Fill(ptcluster,m02,GetEventWeight());
3476  fhMCConversionLambda1Rcut[convR]->Fill(ptcluster,m20,GetEventWeight());
3477 
3478  if ( GetCalorimeter() == kEMCAL && GetFirstSMCoveredByTRD() >= 0 && ph->GetSModNumber() >= GetFirstSMCoveredByTRD() )
3479  {
3480  fhMCConversionLambda0RcutTRD[convR]->Fill(ptcluster,m02,GetEventWeight());
3481  fhMCConversionLambda1RcutTRD[convR]->Fill(ptcluster,m20,GetEventWeight());
3482  }
3483  // //
3484  // // EMCAL SM regions
3485  // //
3486  // if ( GetCalorimeter() == kEMCAL && fFillEMCALRegionSSHistograms )
3487  // {
3488  // // Get original cluster, needed to feed the subregion selection method
3489  //
3490  // Int_t iclus = -1;
3491  // AliVCluster *cluster = FindCluster(GetEMCALClusters(),ph->GetCaloLabel(0),iclus);
3492  //
3493  // Int_t etaRegion = -1, phiRegion = -1;
3494  //
3495  // if ( cluster ) GetCaloUtils()->GetEMCALSubregion(cluster,GetReader()->GetEMCALCells(),etaRegion,phiRegion);
3496  //
3497  // if( etaRegion >= 0 && etaRegion < 4 && phiRegion >=0 && phiRegion < 3 )
3498  // {
3499  // fhLam0EMCALRegionMCConvRcut[etaRegion][phiRegion][convR]->Fill(ptcluster,m02, GetEventWeight());
3500  //
3501  // if ( GetFirstSMCoveredByTRD() >= 0 && ph->GetSModNumber() >= GetFirstSMCoveredByTRD() )
3502  // fhLam0EMCALRegionTRDMCConvRcut[etaRegion][phiRegion][convR]->Fill(ptcluster, m02, GetEventWeight());
3503  //
3504  // } // region found
3505  // } // check region
3506  } // conv region
3507  } // check conv region
3508 
3509  } // fill Sh Sh histograms
3510  } // okD
3511  } // conversion
3512 
3513  if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPrompt) )
3514  {
3515  mcParticleTag = kmcPrompt;
3516  }
3517  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCFragmentation) )
3518  {
3519  mcParticleTag = kmcFragmentation;
3520  }
3521  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCISR) )
3522  {
3523  mcParticleTag = kmcISR;
3524  }
3525  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) )
3526  {
3527  mcParticleTag = kmcPi0;
3528  }
3529  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) )
3530  {
3531  mcParticleTag = kmcEta;
3532  }
3533  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay) )
3534  {
3535  mcParticleTag = kmcPi0Decay;
3536  }
3537  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) )
3538  {
3539  mcParticleTag = kmcEtaDecay;
3540  }
3541  else
3542  {
3543  mcParticleTag = kmcOtherDecay;
3544  }
3545  }
3546  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiNeutron) )
3547  {
3548  mcParticleTag = kmcAntiNeutron;
3549  }
3550  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCAntiProton) )
3551  {
3552  mcParticleTag = kmcAntiProton;
3553  }
3554  else if( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron) )
3555  {
3556  mcParticleTag = kmcElectron;
3557  }
3558  else if( fhMCE[kmcOther] )
3559  {
3560  mcParticleTag = kmcOther;
3561 
3562  // printf(" AliAnaPhoton::MakeAnalysisFillHistograms() - Label %d, pT %2.3f Unknown, bits set: ",
3563  // ph->GetLabel(),ph->Pt());
3564  // for(Int_t i = 0; i < 20; i++) {
3565  // if(GetMCAnalysisUtils()->CheckTagBit(tag,i)) printf(" %d, ",i);
3566  // }
3567  // printf("\n");
3568  }
3569 
3570  if(mcParticleTag >= 0 && fhMCE[mcParticleTag])
3571  {
3572  fhMCE [mcParticleTag]->Fill(ecluster , GetEventWeight());
3573  fhMCPt [mcParticleTag]->Fill(ptcluster, GetEventWeight());
3574 
3575  fhMCPhi [mcParticleTag]->Fill(ecluster, phicluster, GetEventWeight());
3576  fhMCEta [mcParticleTag]->Fill(ecluster, etacluster, GetEventWeight());
3577 
3578  fhMC2E [mcParticleTag]->Fill(ecluster , eprim , GetEventWeight());
3579  fhMC2Pt [mcParticleTag]->Fill(ptcluster, ptprim, GetEventWeight());
3580 
3581  fhMCDeltaE [mcParticleTag]->Fill(ecluster , eprim-ecluster , GetEventWeight());
3582  fhMCDeltaPt[mcParticleTag]->Fill(ptcluster, ptprim-ptcluster, GetEventWeight());
3583  }
3584  }// Histograms with MC
3585  }// aod loop
3586 }
3587 
3588 //__________________________________________________
3590 //__________________________________________________
3591 void AliAnaPhoton::Print(const Option_t * opt) const
3592 {
3593  if(! opt)
3594  return;
3595 
3596  printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
3597  AliAnaCaloTrackCorrBaseClass::Print(" ");
3598 
3599  printf("Calorimeter = %s\n", GetCalorimeterString().Data()) ;
3600  printf("Min Distance to Bad Channel = %2.1f\n",fMinDist);
3601  printf("Min Distance to Bad Channel 2 = %2.1f\n",fMinDist2);
3602  printf("Min Distance to Bad Channel 3 = %2.1f\n",fMinDist3);
3603  printf("Reject clusters with a track matched = %d\n",fRejectTrackMatch);
3604  printf("Time Cut: %3.1f < TOF < %3.1f\n", fTimeCutMin, fTimeCutMax);
3605  printf("Number of cells in cluster is > %d \n", fNCellsCut);
3606  printf(" \n") ;
3607 }
AliCaloTrackReader::IsPileUpFromSPD
Bool_t IsPileUpFromSPD() const
Definition: AliCaloTrackReader.cxx:1232
AliAnaPhoton::fFillOnlySimpleSSHisto
Bool_t fFillOnlySimpleSSHisto
Fill selected cluster histograms, selected SS histograms.
Definition: AliAnaPhoton.h:167
AliHistogramRanges::GetHistoPtMax
Float_t GetHistoPtMax() const
Definition: AliHistogramRanges.h:39
AliAnaPhoton::fhLam1ETMTRD
TH2F * fhLam1ETMTRD
! Cluster lambda1 vs E, SM covered by TRD, cut on Track Matching residual
Definition: AliAnaPhoton.h:221
AliAnaPhoton::fhClusterCutsE
TH1F * fhClusterCutsE[10]
! control histogram on the different photon selection cuts, E
Definition: AliAnaPhoton.h:182
AliAnaPhoton::fhPhiLam0LowE
TH2F * fhPhiLam0LowE
! Cluster phi vs lambda0, E<2
Definition: AliAnaPhoton.h:231
AliAnaPhoton::fhNCellsLam1HighE
TH2F * fhNCellsLam1HighE
! number of cells in cluster vs lambda1, E>2
Definition: AliAnaPhoton.h:227
AliAnaPhoton::fhLam1Lam0HighE
TH2F * fhLam1Lam0HighE
! Cluster lambda1 vs lambda0, E>2
Definition: AliAnaPhoton.h:237
pdg
Int_t pdg
Definition: charmCutsOptimization.C:34
AliAnaPhoton::fhTrackMatchedDEtaTRD
TH2F * fhTrackMatchedDEtaTRD[2]
! Eta distance between track and cluster vs cluster E, after and before photon cuts, behind TRD
Definition: AliAnaPhoton.h:334
AliAnaPhoton::fhMCPt
TH1F * fhMCPt[fgkNmcTypes]
! Number of identified photon vs cluster pT coming from MC particle
Definition: AliAnaPhoton.h:262
AliAnaPhoton::fhTrackMatchedDEtaDPhiNeg
TH2F * fhTrackMatchedDEtaDPhiNeg[2]
! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before photon cuts ...
Definition: AliAnaPhoton.h:332
AliAnaPhoton::fNCellsCut
Int_t fNCellsCut
Accept for the analysis clusters with more than fNCellsCut cells.
Definition: AliAnaPhoton.h:156
AliAnaPhoton::fhEmbedPi0ELambda0FullBkg
TH2F * fhEmbedPi0ELambda0FullBkg
! Lambda0 vs E for embedded photons with less than 10% of the cluster energy
Definition: AliAnaPhoton.h:318
AliAnaPhoton::fhDispE
TH2F * fhDispE
! Cluster dispersion vs E
Definition: AliAnaPhoton.h:203
AliAnaPhoton::fhMCEta
TH2F * fhMCEta[fgkNmcTypes]
! eta of identified photon coming from MC particle
Definition: AliAnaPhoton.h:264
AliAnaPhoton::fNLMCutMax
Int_t fNLMCutMax
Remove clusters/cells with number of local maxima larger than this value.
Definition: AliAnaPhoton.h:159
AliAnaPhoton::fhMCNCellsE
TH2F * fhMCNCellsE[fgkNssTypes]
! NCells per cluster vs energy
Definition: AliAnaPhoton.h:295
AliAnaPhoton::fhDTimeLam0BinPerSMWeighted
TH2F * fhDTimeLam0BinPerSMWeighted[2][20]
! t_max-t_cell, not maximum cluster cell, in a l0 bin per SM, log weight Cell E / Cluster E ...
Definition: AliAnaPhoton.h:392
AliHistogramRanges::GetHistoNClusterCellMin
Int_t GetHistoNClusterCellMin() const
Definition: AliHistogramRanges.h:159
AliHistogramRanges::GetHistoPtMin
Float_t GetHistoPtMin() const
Definition: AliHistogramRanges.h:38
AliAnaPhoton::fhDispEtaDispPhi
TH2F * fhDispEtaDispPhi[7]
! shower dispersion in eta direction vs phi direction for 5 E bins [0-2],[2-4],[4-6],[6-10],[> 10]
Definition: AliAnaPhoton.h:250
AliAnaPhoton::fhCellClusterEFracAndTime
TH2F * fhCellClusterEFracAndTime[2][7]
! Cell in Cluster E cell/ E cluster vs cell Time, in a l0 bin, different Pt bins
Definition: AliAnaPhoton.h:404
AliAnaPhoton::fhLam1ETRD
TH2F * fhLam1ETRD
! Cluster lambda1 vs E, SM covered by TRD
Definition: AliAnaPhoton.h:211
AliAnaPhoton::fhEClusterSM
TH2F * fhEClusterSM
! Cluster E distribution per SM, before any selection, after reader
Definition: AliAnaPhoton.h:365
AliAnaPhoton::fhMaxCellDiffClusterE
TH2F * fhMaxCellDiffClusterE
! Fraction of energy carried by cell with maximum energy
Definition: AliAnaPhoton.h:186
AliAnaPhoton::fhPtClusterSM
TH2F * fhPtClusterSM
! Cluster E distribution per SM, before any selection, after reader
Definition: AliAnaPhoton.h:367
AliCaloTrackReader.h
AliAnaPhoton::fhDispETRD
TH2F * fhDispETRD
! Cluster dispersion vs E, SM covered by TRD
Definition: AliAnaPhoton.h:208
AliHistogramRanges::GetHistoShowerShapeBins
Int_t GetHistoShowerShapeBins() const
Definition: AliHistogramRanges.h:259
AliHistogramRanges::GetHistodEdxMax
Float_t GetHistodEdxMax() const
Definition: AliHistogramRanges.h:142
AliAnaCaloTrackCorrBaseClass::AddToHistogramsName
virtual void AddToHistogramsName(TString add)
Definition: AliAnaCaloTrackCorrBaseClass.h:86
AliAnaCaloTrackCorrBaseClass::GetEMCALCells
virtual AliVCaloCells * GetEMCALCells() const
Definition: AliAnaCaloTrackCorrBaseClass.h:145
AliAnaPhoton::fhLam1PerNLargeTimeInClusterCell
TH2F * fhLam1PerNLargeTimeInClusterCell[5]
! Cluster lambda1 vs Pt, when any secondary cell has t > 50 ns, per number of large time secondary ce...
Definition: AliAnaPhoton.h:428
AliAnaPhoton::fhTrackMatchedDEtaDPhiPos
TH2F * fhTrackMatchedDEtaDPhiPos[2]
! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before ...
Definition: AliAnaPhoton.h:328
AliAnaPhoton::fhLam0PerNLargeTimeInClusterCell
TH2F * fhLam0PerNLargeTimeInClusterCell[5]
! Cluster lambda0 vs Pt, when any secondary cell has t > 50 ns, per number of large time secondary ce...
Definition: AliAnaPhoton.h:427
AliAnaPhoton::fhMCPtLambda0
TH2F * fhMCPtLambda0[fgkNssTypes]
! pT vs Lambda0 from MC particle
Definition: AliAnaPhoton.h:281
AliAnaPhoton::fhNCellsLam1LowE
TH2F * fhNCellsLam1LowE
! number of cells in cluster vs lambda1
Definition: AliAnaPhoton.h:224
AliAnaPhoton::fFillTMHisto
Bool_t fFillTMHisto
Fill track matching plots.
Definition: AliAnaPhoton.h:151
AliAnaPhoton::fhPtPhotonNPileUpSPDVtx
TH2F * fhPtPhotonNPileUpSPDVtx
! photon pt vs number of spd pile-up vertices
Definition: AliAnaPhoton.h:358
AliAnaPhoton::fhPtPhotonNPileUpTrkVtx
TH2F * fhPtPhotonNPileUpTrkVtx
! photon pt vs number of track pile-up vertices
Definition: AliAnaPhoton.h:359
AliCaloPID.h
AliAnaPhoton::fhNCellsDispLowE
TH2F * fhNCellsDispLowE
! number of cells in cluster vs dispersion
Definition: AliAnaPhoton.h:225
AliAnaPhoton::fhTrackMatchedDEtaPos
TH2F * fhTrackMatchedDEtaPos[2]
! Eta distance between track and cluster vs cluster E, after and before photon cuts ...
Definition: AliAnaPhoton.h:326
AliAnaPhoton::fhSphericityE
TH2F * fhSphericityE
! shower sphericity in eta vs phi
Definition: AliAnaPhoton.h:247
AliAnaPhoton::fhDispEtaE
TH2F * fhDispEtaE
! shower dispersion in eta direction
Definition: AliAnaPhoton.h:241
AliAnaPhoton::fhPtPhotonNPileUpTrkVtxTimeCut
TH2F * fhPtPhotonNPileUpTrkVtxTimeCut
! photon pt vs number of track pile-up vertices, time cut +- 25 ns
Definition: AliAnaPhoton.h:361
AliAnaCaloTrackCorrBaseClass::GetModuleNumberCellIndexesAbsCaloMap
virtual Int_t GetModuleNumberCellIndexesAbsCaloMap(Int_t absId, Int_t calo, Int_t &icol, Int_t &irow, Int_t &iRCU, Int_t &icolAbs, Int_t &irowAbs) const
Definition: AliAnaCaloTrackCorrBaseClass.h:300
AliAnaPhoton::fhEtaPrimMC
TH2F * fhEtaPrimMC[fgkNmcPrimTypes]
! Eta of generated photon
Definition: AliAnaPhoton.h:270
AliCalorimeterUtils::GetEMCALRecoUtils
AliEMCALRecoUtils * GetEMCALRecoUtils() const
Definition: AliCalorimeterUtils.h:292
AliAnaPhoton::fhPtPhotonSM
TH2F * fhPtPhotonSM
! photon-like cluster E distribution per SM
Definition: AliAnaPhoton.h:368
AliCaloTrackReader::ReadAODMCParticles
Bool_t ReadAODMCParticles() const
Definition: AliCaloTrackReader.h:645
AliAnaPhoton::fFillEMCALRegionSSHistograms
Bool_t fFillEMCALRegionSSHistograms
Fill shower shape histograms in EMCal slices.
Definition: AliAnaPhoton.h:163
AliAnaCaloTrackCorrBaseClass::GetVertex
virtual void GetVertex(Double_t vertex[3]) const
Definition: AliAnaCaloTrackCorrBaseClass.h:270
AliAnaPhoton::fhTrackMatchedDPhiTRD
TH2F * fhTrackMatchedDPhiTRD[2]
! Phi distance between track and cluster vs cluster E, after and before photon cuts, behind TRD
Definition: AliAnaPhoton.h:335
AliAnaPhoton::fMinDist2
Float_t fMinDist2
Cuts on Minimal distance to study acceptance evaluation.
Definition: AliAnaPhoton.h:146
AliAnaPhoton::fhPtPhotonPileUp
TH1F * fhPtPhotonPileUp[7]
! pT distribution of selected photons
Definition: AliAnaPhoton.h:351
AliAnaPhoton::fhPtPhoton
TH1F * fhPtPhoton
! Number of identified photon vs transerse momentum
Definition: AliAnaPhoton.h:191
AliAnaPhoton::fRejectTrackMatch
Bool_t fRejectTrackMatch
If PID on, reject clusters which have an associated TPC track.
Definition: AliAnaPhoton.h:149
AliAnaPhoton::MakeAnalysisFillAOD
void MakeAnalysisFillAOD()
Definition: AliAnaPhoton.cxx:3047
AliAnaPhoton::fhTrackMatchedDPhiMCNoOverlap
TH2F * fhTrackMatchedDPhiMCNoOverlap[2]
! Phi distance between track and cluster vs cluster E, not other particle overlap, after and before photon cuts
Definition: AliAnaPhoton.h:340
AliAnaPhoton::fhPtEventPlanePhoton
TH2F * fhPtEventPlanePhoton
! event plane vs photon pT
Definition: AliAnaPhoton.h:198
AliCaloTrackReader::GetInputEvent
virtual AliVEvent * GetInputEvent() const
Definition: AliCaloTrackReader.h:633
AliAnaPhoton::fhLam0PtTRD
TH2F * fhLam0PtTRD
! Cluster lambda0 vs pT, SM covered by TRD
Definition: AliAnaPhoton.h:210
AliAnaPhoton::fhMCConversionVertex
TH2F * fhMCConversionVertex
! Conversion distance for photon clusters that have at least a contributor from the conversion...
Definition: AliAnaPhoton.h:370
AliAnaPhoton::fhEmbedPi0ELambda0FullSignal
TH2F * fhEmbedPi0ELambda0FullSignal
! Lambda0 vs E for embedded photons with more than 90% of the cluster energy
Definition: AliAnaPhoton.h:315
AliCaloTrackReader::IsPileUpFromSPDAndNotEMCal
Bool_t IsPileUpFromSPDAndNotEMCal() const
Check if event is from pile-up determined by SPD and not by EMCal.
Definition: AliCaloTrackReader.cxx:1269
AliAnaPhoton::fhEmbedPi0ELambda0MostlyBkg
TH2F * fhEmbedPi0ELambda0MostlyBkg
! Lambda0 vs E for embedded photons with 50%<fraction<10%
Definition: AliAnaPhoton.h:317
AliAnaPhoton::fhMCESphericity
TH2F * fhMCESphericity[fgkNssTypes]
! shower sphericity, eta vs phi
Definition: AliAnaPhoton.h:302
AliAnaPhoton::fhEtaPhiLargeTimeInClusterCell
TH2F * fhEtaPhiLargeTimeInClusterCell[2][7]
! Cluster eta/phi, with at least one significant cell with large time
Definition: AliAnaPhoton.h:415
AliAnaPhoton::fhMC2Pt
TH2F * fhMC2Pt[fgkNmcTypes]
! pT distribution, Reco vs MC coming from MC particle
Definition: AliAnaPhoton.h:259
AliAnaPhoton::fhEtaPhiPhoton
TH2F * fhEtaPhiPhoton
! Pseudorapidity vs Phi of identified photon for E > 0.5
Definition: AliAnaPhoton.h:194
AliAnaCaloTrackCorrBaseClass::GetZvertexCut
virtual Float_t GetZvertexCut() const
Maximal number of events for mixin.
Definition: AliAnaCaloTrackCorrBaseClass.h:234
AliAnaPhoton::fhPhiPhoton
TH2F * fhPhiPhoton
! Azimuthal angle of identified photon vs transerse momentum
Definition: AliAnaPhoton.h:192
AliAnaCaloTrackCorrBaseClass::GetEventPlaneAngle
virtual Double_t GetEventPlaneAngle() const
Definition: AliAnaCaloTrackCorrBaseClass.h:111
AliAnaPhoton::fhYPrimMC
TH2F * fhYPrimMC[fgkNmcPrimTypes]
! Rapidity of generated photon
Definition: AliAnaPhoton.h:269
AliAnaPhoton::fhTrackMatchedDEtaDPhi
TH2F * fhTrackMatchedDEtaDPhi[2]
! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before ...
Definition: AliAnaPhoton.h:324
AliAnaPhoton::FillAcceptanceHistograms
void FillAcceptanceHistograms()
Definition: AliAnaPhoton.cxx:439
AliAnaPhoton::fhSumEtaE
TH2F * fhSumEtaE
! shower dispersion in eta direction
Definition: AliAnaPhoton.h:243
AliAnaCaloTrackCorrBaseClass::IsTrackMatched
virtual Bool_t IsTrackMatched(AliVCluster *cluster, AliVEvent *event)
Definition: AliAnaCaloTrackCorrBaseClass.h:294
AliAnaPhoton::fhMCEDispEtaPhiDiff
TH2F * fhMCEDispEtaPhiDiff[fgkNssTypes]
! shower dispersion in eta -phi direction
Definition: AliAnaPhoton.h:301
AliAnaPhoton::fhColRowLam0BinPtBin
TH2F * fhColRowLam0BinPtBin[2][7]
! Cell hits, not maximum cluster cell, in a l0 bin, different Pt bins
Definition: AliAnaPhoton.h:400
AliAnaPhoton::Print
void Print(const Option_t *opt) const
Print some relevant parameters set for the analysis.
Definition: AliAnaPhoton.cxx:3591
AliAnaPhoton::fhCellClusterELam0BinPerSM
TH2F * fhCellClusterELam0BinPerSM[2][20]
! Cell E vs cluster pT, not maximum cluster cell, in a l0 bin per SM
Definition: AliAnaPhoton.h:395
AliHistogramRanges::GetHistoPhiBins
Int_t GetHistoPhiBins() const
Definition: AliHistogramRanges.h:60
AliAnaPhoton::fhEtaLam0LowE
TH2F * fhEtaLam0LowE
! Cluster eta vs lambda0, E<2
Definition: AliAnaPhoton.h:230
AliAnaPhoton::fhPtPhotonNPileUpSPDVtxTimeCut
TH2F * fhPtPhotonNPileUpSPDVtxTimeCut
! photon pt vs number of spd pile-up vertices, time cut +-25 ns
Definition: AliAnaPhoton.h:360
AliAnaPhoton::fhMCConversionVertexTRD
TH2F * fhMCConversionVertexTRD
! Conversion distance for photon clusters that have at least a contributor from the conversion...
Definition: AliAnaPhoton.h:371
AliAnaPhoton::fFillSSHistograms
Bool_t fFillSSHistograms
Fill shower shape histograms.
Definition: AliAnaPhoton.h:161
AliFiducialCut.h
AliAnaPhoton::fhdEdx
TH2F * fhdEdx[2]
! Matched track dEdx vs cluster E, after and before photon cuts
Definition: AliAnaPhoton.h:345
AliAnaPhoton::fhLam0ETRD
TH2F * fhLam0ETRD
! Cluster lambda0 vs E, SM covered by TRD
Definition: AliAnaPhoton.h:209
AliAnaPhoton::fhDispETM
TH2F * fhDispETM
! Cluster dispersion vs E, cut on Track Matching residual
Definition: AliAnaPhoton.h:213
AliAnaPhoton::fhEmbedPhotonELambda0FullSignal
TH2F * fhEmbedPhotonELambda0FullSignal
! Lambda0 vs E for embedded photons with more than 90% of the cluster energy
Definition: AliAnaPhoton.h:310
AliHistogramRanges::GetHistoTrackResidualPhiMin
Float_t GetHistoTrackResidualPhiMin() const
Definition: AliHistogramRanges.h:294
AliAnaPhoton::fhEtaPhoton
TH2F * fhEtaPhoton
! Pseudorapidity of identified photon vs transerse momentum
Definition: AliAnaPhoton.h:193
AliAnaPhoton::fhDispSumEtaDiffE
TH2F * fhDispSumEtaDiffE
! difference of 2 eta dispersions
Definition: AliAnaPhoton.h:248
AliCaloPID::SwitchOnBayesian
void SwitchOnBayesian()
Definition: AliCaloPID.h:136
AliCaloTrackReader::IsPileUpFromNotSPDAndNotEMCal
Bool_t IsPileUpFromNotSPDAndNotEMCal() const
Check if event not from pile-up determined neither by SPD nor by EMCal.
Definition: AliCaloTrackReader.cxx:1287
AliAnaPhoton::fhTimePtPhotonSPD
TH2F * fhTimePtPhotonSPD
! Time of photon cluster vs Pt, IsSPDPileUp
Definition: AliAnaPhoton.h:354
AliAnaPhoton::fhMCDispEtaDispPhi
TH2F * fhMCDispEtaDispPhi[7][fgkNssTypes]
! shower dispersion in eta direction vs phi direction for 5 E bins [0-2],[2-4],[4-6],[6-10],[> 10]
Definition: AliAnaPhoton.h:303
AliHistogramRanges::GetHistoTrackResidualEtaMin
Float_t GetHistoTrackResidualEtaMin() const
Definition: AliHistogramRanges.h:287
AliHistogramRanges::GetHistoNClusterCellBins
Int_t GetHistoNClusterCellBins() const
Definition: AliHistogramRanges.h:158
AliAnaCaloTrackCorrBaseClass::GetOutputAODBranch
virtual TClonesArray * GetOutputAODBranch() const
Definition: AliAnaCaloTrackCorrBaseClass.h:137
AliAnaPhoton::fhLam0EMCALRegionPerSM
TH2F * fhLam0EMCALRegionPerSM[4][3][20]
! Cluster lambda0 vs Pt, in different EMCal regions
Definition: AliAnaPhoton.h:382
AliCaloTrackReader::GetVertex
virtual void GetVertex(Double_t v[3]) const
Definition: AliCaloTrackReader.cxx:1596
AliAnaPhoton::InitParameters
void InitParameters()
Initialize the parameters of the analysis.
Definition: AliAnaPhoton.cxx:3027
AliHistogramRanges::GetHistoPOverEBins
Int_t GetHistoPOverEBins() const
Definition: AliHistogramRanges.h:149
AliAnaPhoton::fhNCellsE
TH2F * fhNCellsE
! number of cells in cluster vs E
Definition: AliAnaPhoton.h:184
AliAnaPhoton::fhPtPrimMC
TH1F * fhPtPrimMC[fgkNmcPrimTypes]
! Number of generated photon vs pT
Definition: AliAnaPhoton.h:267
AliCalorimeterUtils::IsMCParticleInCalorimeterAcceptance
Bool_t IsMCParticleInCalorimeterAcceptance(Int_t calo, TParticle *particle)
Definition: AliCalorimeterUtils.cxx:1585
AliHistogramRanges::GetHistoPhiMin
Float_t GetHistoPhiMin() const
Definition: AliHistogramRanges.h:61
AliAnaPhoton::fhTimePt
TH2F * fhTimePt
! Time of photon cluster vs pt
Definition: AliAnaPhoton.h:187
AliAnaPhoton::fhEtaPhi
TH2F * fhEtaPhi
! Pseudorapidity vs Phi of clusters for E > 0.5
Definition: AliAnaPhoton.h:188
AliAnaPhoton::fhMCLambda0DispPhi
TH2F * fhMCLambda0DispPhi[7][fgkNssTypes]
! shower shape correlation l0 vs disp phi
Definition: AliAnaPhoton.h:305
AliAnaPhoton::fhLam0PerSMLargeTimeInClusterCell
TH2F * fhLam0PerSMLargeTimeInClusterCell[20]
! Cluster lambda0 vs Pt, when any secondary cell has t > 50 ns, in different SM
Definition: AliAnaPhoton.h:425
AliAnaPhoton::fhCellClusterEAndTime
TH2F * fhCellClusterEAndTime[2][7]
! Cell in Cluster E cell vs cell Time, in a l0 bin, different Pt bins
Definition: AliAnaPhoton.h:403
AliAnaPhoton::fhNCellsWithLargeTimeInCluster
TH2F * fhNCellsWithLargeTimeInCluster[2][20]
! Number of cells in cluster with large time
Definition: AliAnaPhoton.h:421
AliAnaPhoton::fhEPhotonSM
TH2F * fhEPhotonSM
! photon-like cluster E distribution per SM
Definition: AliAnaPhoton.h:366
AliAnaPhoton::fhEOverPTRD
TH2F * fhEOverPTRD[2]
! Matched track E cluster over P track vs cluster E, after dEdx cut, after and before photon cuts...
Definition: AliAnaPhoton.h:347
AliCaloPID::GetPIDParametersList
TString GetPIDParametersList()
Put data member values in string to keep in output container.
Definition: AliCaloPID.cxx:892
AliAnaPhoton::fhMCELambda0
TH2F * fhMCELambda0[fgkNssTypes]
! E vs Lambda0 from MC particle
Definition: AliAnaPhoton.h:280
AliMCAnalysisUtils::GetMother
TLorentzVector GetMother(Int_t label, const AliCaloTrackReader *reader, Bool_t &ok)
Definition: AliMCAnalysisUtils.cxx:1535
AliCaloTrackReader::IsPileUpFromSPDOrEMCal
Bool_t IsPileUpFromSPDOrEMCal() const
Check if event is from pile-up determined by SPD or EMCal.
Definition: AliCaloTrackReader.cxx:1260
AliAnaPhoton::fhTrackMatchedDPhiNeg
TH2F * fhTrackMatchedDPhiNeg[2]
! Phi distance between track and cluster vs cluster E, after and before photon cuts ...
Definition: AliAnaPhoton.h:331
AliCaloTrackReader::IsPileUpFromEMCalAndNotSPD
Bool_t IsPileUpFromEMCalAndNotSPD() const
Check if event is from pile-up determined by EMCal, not by SPD.
Definition: AliCaloTrackReader.cxx:1278
AliAnaPhoton::MakeAnalysisFillHistograms
void MakeAnalysisFillHistograms()
Definition: AliAnaPhoton.cxx:3300
AliAnaPhoton::fhMCELambda1
TH2F * fhMCELambda1[fgkNssTypes]
! E vs Lambda1 from MC particle
Definition: AliAnaPhoton.h:282
AliAnaPhoton::fhLambda0DispPhi
TH2F * fhLambda0DispPhi[7]
! shower shape correlation l0 vs disp phi
Definition: AliAnaPhoton.h:252
etamin
const Double_t etamin
Definition: AddTaskCFDStar.C:40
AliAnaPhoton::fhLambda0DispEta
TH2F * fhLambda0DispEta[7]
! shower shape correlation l0 vs disp eta
Definition: AliAnaPhoton.h:251
AliCaloTrackReader::GetEMCALCells
virtual AliVCaloCells * GetEMCALCells() const
Definition: AliCaloTrackReader.h:298
AliAnaCaloTrackCorrBaseClass
Base class for CaloTrackCorr analysis algorithms.
Definition: AliAnaCaloTrackCorrBaseClass.h:59
AliAnaPhoton::fhCellClusterEFracLam0BinPerSMLargeTime
TH2F * fhCellClusterEFracLam0BinPerSMLargeTime[2][20]
! Cell in Cluster E cell / Ecluster vs cluster pT, with large time
Definition: AliAnaPhoton.h:417
AliAnaCaloTrackCorrBaseClass::GetCalorimeterString
virtual TString GetCalorimeterString() const
Definition: AliAnaCaloTrackCorrBaseClass.h:168
AliMCAnalysisUtils.h
AliAnaPhoton::fNOriginHistograms
Int_t fNOriginHistograms
Fill only NOriginHistograms of the 14 defined types.
Definition: AliAnaPhoton.h:169
AliAnaPhoton::fgkNmcPrimTypes
static const Int_t fgkNmcPrimTypes
Total number of MC primary histograms.
Definition: AliAnaPhoton.h:134
AliAnaCaloTrackCorrBaseClass::IsRealCaloAcceptanceOn
virtual Bool_t IsRealCaloAcceptanceOn() const
Definition: AliAnaCaloTrackCorrBaseClass.h:182
AliHistogramRanges::GetHistodEdxMin
Float_t GetHistodEdxMin() const
Definition: AliHistogramRanges.h:141
AliAnaCaloTrackCorrBaseClass::GetFiducialCut
virtual AliFiducialCut * GetFiducialCut()
Definition: AliAnaCaloTrackCorrBaseClass.h:328
AliAnaPhoton::fhCellClusterEFracLam0BinPerSMLargeTimeTotal
TH2F * fhCellClusterEFracLam0BinPerSMLargeTimeTotal[2][20]
! Sum of all Cell in Cluster , with large time E cell / Ecluster vs cluster pT
Definition: AliAnaPhoton.h:418
AliAnaPhoton::fhTimePtPhotonNoCut
TH2F * fhTimePtPhotonNoCut
! Time of photon cluster vs Pt, no cut
Definition: AliAnaPhoton.h:353
AliAnaPhoton::fhPtPhotonNPileUpSPDVtxTimeCut2
TH2F * fhPtPhotonNPileUpSPDVtxTimeCut2
! photon pt vs number of spd pile-up vertices, time cut +-75 ns
Definition: AliAnaPhoton.h:362
AliAnaPhoton::fhEOverP
TH2F * fhEOverP[2]
! Matched track E cluster over P track vs cluster E, after dEdx cut, after and before photon cuts ...
Definition: AliAnaPhoton.h:346
AliAnaPhoton::fhTrackMatchedDEta
TH2F * fhTrackMatchedDEta[2]
! Eta distance between track and cluster vs cluster E, after and before photon cuts ...
Definition: AliAnaPhoton.h:322
AliAnaPhoton::fhEPrimMC
TH1F * fhEPrimMC[fgkNmcPrimTypes]
! Number of generated photon vs energy
Definition: AliAnaPhoton.h:266
AliCaloTrackReader::GetAODMCParticles
virtual TClonesArray * GetAODMCParticles() const
Definition: AliCaloTrackReader.cxx:882
AliAnaCaloTrackCorrBaseClass::GetHistogramRanges
virtual AliHistogramRanges * GetHistogramRanges()
Definition: AliAnaCaloTrackCorrBaseClass.h:330
AliAnaPhoton::fhCellsE
TH2F * fhCellsE
! energy of cells in cluster vs E of cluster
Definition: AliAnaPhoton.h:185
AliCaloTrackReader::ReadStack
Bool_t ReadStack() const
Definition: AliCaloTrackReader.h:644
AliAnaPhoton::fhDispETMTRD
TH2F * fhDispETMTRD
! Cluster dispersion vs E, SM covered by TRD, cut on Track Matching residual
Definition: AliAnaPhoton.h:218
AliAnaPhoton::fhPhiPrimMC
TH2F * fhPhiPrimMC[fgkNmcPrimTypes]
! Phi of generted photon
Definition: AliAnaPhoton.h:268
AliAnaPhoton::fhLam1ETM
TH2F * fhLam1ETM
! Cluster lambda1 vs E, cut on Track Matching residual
Definition: AliAnaPhoton.h:216
AliHistogramRanges::GetHistoTrackResidualPhiMax
Float_t GetHistoTrackResidualPhiMax() const
Definition: AliHistogramRanges.h:295
AliAnaPhoton
Filter EMCal/PHOS clusters for photon analysis.
Definition: AliAnaPhoton.h:32
ptmax
const Double_t ptmax
Definition: AddTaskCFDStar.C:39
AliAnaPhoton::fhLam1PerSM
TH2F * fhLam1PerSM[20]
! Cluster lambda0 vs Pt, in different SM
Definition: AliAnaPhoton.h:424
AliAnaPhoton::fhEtaPhi05Photon
TH2F * fhEtaPhi05Photon
! Pseudorapidity vs Phi of identified photon for E < 0.5
Definition: AliAnaPhoton.h:195
AliAnaCaloTrackCorrBaseClass::GetEMCALGeometry
virtual AliEMCALGeometry * GetEMCALGeometry() const
Definition: AliAnaCaloTrackCorrBaseClass.h:340
AliAnaPhoton::fhDispSumPhiDiffE
TH2F * fhDispSumPhiDiffE
! difference of 2 phi dispersions
Definition: AliAnaPhoton.h:249
AliAnaPhoton::FillShowerShapeHistograms
void FillShowerShapeHistograms(AliVCluster *cluster, Int_t mcTag, Float_t maxCellEFraction, Int_t &largeTimeInside)
Fill cluster Shower Shape histograms.
Definition: AliAnaPhoton.cxx:771
AliAnaPhoton::fhNCellsLam0HighE
TH2F * fhNCellsLam0HighE
! number of cells in cluster vs lambda0, E>2
Definition: AliAnaPhoton.h:226
AliFiducialCut::IsInFiducialCut
Bool_t IsInFiducialCut(Float_t eta, Float_t phi, Int_t det) const
Definition: AliFiducialCut.cxx:78
AliMCAnalysisUtils::CheckOrigin
Int_t CheckOrigin(Int_t label, const AliCaloTrackReader *reader, Int_t calorimeter)
Definition: AliMCAnalysisUtils.cxx:252
AliCaloTrackReader::GetOutputEvent
virtual AliAODEvent * GetOutputEvent() const
Definition: AliCaloTrackReader.h:635
AliHistogramRanges::GetHistoShowerShapeMin
Float_t GetHistoShowerShapeMin() const
Definition: AliHistogramRanges.h:260
AliAnaPhoton::GetCreateOutputObjects
TList * GetCreateOutputObjects()
Definition: AliAnaPhoton.cxx:1477
AliAnaPhoton::fhMCLambda0DispEta
TH2F * fhMCLambda0DispEta[7][fgkNssTypes]
! shower shape correlation l0 vs disp eta
Definition: AliAnaPhoton.h:304
AliHistogramRanges::GetHistodEdxBins
Int_t GetHistodEdxBins() const
Definition: AliHistogramRanges.h:140
AliAnaPhoton::fhMCNCellsvsClusterMaxCellDiffE6
TH2F * fhMCNCellsvsClusterMaxCellDiffE6[fgkNssTypes]
! NCells vs fraction of energy of max cell for E > 6
Definition: AliAnaPhoton.h:294
AliAnaCaloTrackCorrBaseClass::GetCaloUtils
virtual AliCalorimeterUtils * GetCaloUtils() const
Definition: AliAnaCaloTrackCorrBaseClass.h:326
AliHistogramRanges::GetHistoNClusterCellMax
Int_t GetHistoNClusterCellMax() const
Definition: AliHistogramRanges.h:160
AliAnaPhoton::fhCellClusterELam0BinPerSMLargeTime
TH2F * fhCellClusterELam0BinPerSMLargeTime[2][20]
! Cell in Cluster E cell vs cluster pT, with large time
Definition: AliAnaPhoton.h:419
AliHistogramRanges::GetHistoTrackResidualEtaBins
Int_t GetHistoTrackResidualEtaBins() const
Definition: AliHistogramRanges.h:286
AliAnaPhoton::fhLam1PerSMLargeTimeInClusterCell
TH2F * fhLam1PerSMLargeTimeInClusterCell[20]
! Cluster lambda1 vs Pt, when any secondary cell has t > 50 ns, in different SM
Definition: AliAnaPhoton.h:426
AliAnaPhoton::fMinDist3
Float_t fMinDist3
One more cut on distance used for acceptance-efficiency study.
Definition: AliAnaPhoton.h:147
AliHistogramRanges::GetHistoTrackResidualPhiBins
Int_t GetHistoTrackResidualPhiBins() const
Definition: AliHistogramRanges.h:293
AliAnaPhoton::fhMCPhotonELambda0TwoOverlap
TH2F * fhMCPhotonELambda0TwoOverlap
! E vs Lambda0 from MC photons, 2 particles overlap
Definition: AliAnaPhoton.h:286
AliCalorimeterUtils::GetNumberOfSuperModulesUsed
Int_t GetNumberOfSuperModulesUsed() const
Definition: AliCalorimeterUtils.h:370
AliAnaPhoton::fhMCConversionLambda1RcutTRD
TH2F * fhMCConversionLambda1RcutTRD[6]
! Shower shape M20 of photon conversions, depending on conversion vertex, SM covered by TRD ...
Definition: AliAnaPhoton.h:375
ptmin
const Double_t ptmin
Definition: AddTaskCFDStar.C:38
AliAnaCaloTrackCorrBaseClass::IsHighMultiplicityAnalysisOn
virtual Bool_t IsHighMultiplicityAnalysisOn() const
Definition: AliAnaCaloTrackCorrBaseClass.h:199
AliAnaPhoton::fhMCPhotonELambda0NOverlap
TH2F * fhMCPhotonELambda0NOverlap
! E vs Lambda0 from MC photons, N particles overlap
Definition: AliAnaPhoton.h:287
AliAnaPhoton::fhClusterCutsPt
TH1F * fhClusterCutsPt[10]
! control histogram on the different photon selection cuts, pT
Definition: AliAnaPhoton.h:183
AliAnaPhoton::fMinDist
Float_t fMinDist
Minimal distance to bad channel to accept cluster.
Definition: AliAnaPhoton.h:145
AliAnaPhoton::fhTrackMatchedMCParticle
TH2F * fhTrackMatchedMCParticle[2]
! Trace origin of matched particle
Definition: AliAnaPhoton.h:344
AliAnaPhoton::fhMCMaxCellDiffClusterE
TH2F * fhMCMaxCellDiffClusterE[fgkNssTypes]
! Fraction of energy carried by cell with maximum energy
Definition: AliAnaPhoton.h:296
AliAnaPhoton::fhMC2E
TH2F * fhMC2E[fgkNmcTypes]
! E distribution, Reco vs MC coming from MC particle
Definition: AliAnaPhoton.h:258
AliAnaPhoton::fhCellClusterEFracLam0BinPerSM
TH2F * fhCellClusterEFracLam0BinPerSM[2][20]
! Cell E / Cluster E vs cluster pT, not maximum cluster cell, in a l0 bin per SM
Definition: AliAnaPhoton.h:393
AliAnaPhoton::fConstantTimeShift
Float_t fConstantTimeShift
Apply a 600 ns time shift in case of simulation, shift in ns.
Definition: AliAnaPhoton.h:176
AliAnaPhoton::fhEmbedPhotonELambda0MostlySignal
TH2F * fhEmbedPhotonELambda0MostlySignal
! Lambda0 vs E for embedded photons with 90%<fraction<50%
Definition: AliAnaPhoton.h:311
AliAnaCaloTrackCorrBaseClass::GetEventWeight
virtual Double_t GetEventWeight() const
Definition: AliAnaCaloTrackCorrBaseClass.h:242
AliCaloPID::SetPIDBits
void SetPIDBits(AliVCluster *cluster, AliAODPWG4Particle *aodph, AliCalorimeterUtils *cu, AliVEvent *event)
Set Bits for PID selection.
Definition: AliCaloPID.cxx:1026
AliAnaPhoton::fNPrimaryHistograms
Int_t fNPrimaryHistograms
Fill only NPrimaryHistograms of the 7 defined types.
Definition: AliAnaPhoton.h:170
AliAnaPhoton.h
AliAnaPhoton::FillPileUpHistograms
void FillPileUpHistograms(AliVCluster *cluster, AliVCaloCells *cells, Int_t absIdMax)
Fill some histograms to understand effect of pile-up.
Definition: AliAnaPhoton.cxx:668
AliCalorimeterUtils::GetNumberOfLocalMaxima
Int_t GetNumberOfLocalMaxima(AliVCluster *cluster, AliVCaloCells *cells)
Find the number of local maxima in cluster.
Definition: AliCalorimeterUtils.cxx:1226
AliAnaPhoton::fhMCNCellsvsClusterMaxCellDiffE2
TH2F * fhMCNCellsvsClusterMaxCellDiffE2[fgkNssTypes]
! NCells vs fraction of energy of max cell for 2 < E < 6 GeV
Definition: AliAnaPhoton.h:293
AliAnaPhoton::fhNCellsDispHighE
TH2F * fhNCellsDispHighE
! number of cells in cluster vs dispersion, E>2
Definition: AliAnaPhoton.h:228
AliAnaPhoton::fhEmbeddedSignalFractionEnergy
TH2F * fhEmbeddedSignalFractionEnergy
! Fraction of photon energy of embedded signal vs cluster energy
Definition: AliAnaPhoton.h:308
AliAnaCaloTrackCorrBaseClass::GetPHOSClusters
virtual TObjArray * GetPHOSClusters() const
Definition: AliAnaCaloTrackCorrBaseClass.cxx:293
AliHistogramRanges::GetHistoEtaMin
Float_t GetHistoEtaMin() const
Definition: AliHistogramRanges.h:89
Data
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
Definition: charmCutsOptimization.C:371
AliAnaPhoton::fhEPhoton
TH1F * fhEPhoton
! Number of identified photon vs energy
Definition: AliAnaPhoton.h:190
AliAnaPhoton::fhTrackMatchedDEtaMCConversion
TH2F * fhTrackMatchedDEtaMCConversion[2]
! Eta distance between track and cluster vs cluster E, originated in conversion, after and before pho...
Definition: AliAnaPhoton.h:341
energy
energy
Definition: HFPtSpectrumRaa.C:55
AliAnaPhoton::fhLam0ETMTRD
TH2F * fhLam0ETMTRD
! Cluster lambda0 vs E, SM covered by TRD, cut on Track Matching residual
Definition: AliAnaPhoton.h:219
AliAnaPhoton::fhLam0DispLowE
TH2F * fhLam0DispLowE
! Cluster lambda0 vs dispersion, E<2
Definition: AliAnaPhoton.h:234
AliAnaCaloTrackCorrBaseClass::GetModuleNumber
virtual Int_t GetModuleNumber(AliAODPWG4Particle *part) const
Definition: AliAnaCaloTrackCorrBaseClass.h:305
AliAnaPhoton::fTimeCutMax
Double_t fTimeCutMax
Remove clusters/cells with time larger than this value, in ns.
Definition: AliAnaPhoton.h:154
AliAnaPhoton::fhTrackMatchedDPhiMCConversion
TH2F * fhTrackMatchedDPhiMCConversion[2]
! Phi distance between track and cluster vs cluster E, originated in conversion, after and before pho...
Definition: AliAnaPhoton.h:342
AliAnaPhoton::fhMCE
TH1F * fhMCE[fgkNmcTypes]
! Number of identified photon vs cluster energy coming from MC particle
Definition: AliAnaPhoton.h:261
AliAnaPhoton::fhCellClusterIndexEAndTime
TH2F * fhCellClusterIndexEAndTime[2][7]
! Cell in Cluster index (low index high energy, high index low energy) vs cell Time ...
Definition: AliAnaPhoton.h:402
AliAnaPhoton::fhColRowLam0BinPtBinLargeTime
TH2F * fhColRowLam0BinPtBinLargeTime[2][7]
! Cell hits, not maximum cluster cell, in a l0 bin, different Pt bins, cell with large time ...
Definition: AliAnaPhoton.h:416
AliAnaPhoton::fhDispLam1LowE
TH2F * fhDispLam1LowE
! Cluster disp vs lambda1, E<2
Definition: AliAnaPhoton.h:238
AliAnaPhoton::fhMCEDispEta
TH2F * fhMCEDispEta[fgkNssTypes]
! shower dispersion in eta direction
Definition: AliAnaPhoton.h:298
AliMCAnalysisUtils::GetDaughter
TLorentzVector GetDaughter(Int_t daughter, Int_t label, const AliCaloTrackReader *reader, Int_t &pdg, Int_t &status, Bool_t &ok, Int_t &daugLabel, TVector3 &prodVertex)
Definition: AliMCAnalysisUtils.cxx:1450
AliHistogramRanges::GetHistoEtaMax
Float_t GetHistoEtaMax() const
Definition: AliHistogramRanges.h:90
AliAnaPhoton::fhPtPrimMCAcc
TH1F * fhPtPrimMCAcc[fgkNmcPrimTypes]
! Number of generated photon vs pT, in calorimeter acceptance
Definition: AliAnaPhoton.h:273
AliAnaCaloTrackCorrBaseClass::AddAODParticle
virtual void AddAODParticle(AliAODPWG4Particle part)
Definition: AliAnaCaloTrackCorrBaseClass.cxx:87
AliCaloTrackReader::GetPHOSPtMin
Float_t GetPHOSPtMin() const
Definition: AliCaloTrackReader.h:129
AliAnaPhoton::fhLam0E
TH2F * fhLam0E
! Cluster lambda0 vs E
Definition: AliAnaPhoton.h:204
AliAnaPhoton::fhLam0PtTMTRD
TH2F * fhLam0PtTMTRD
! Cluster lambda0 vs pT, SM covered by TRD, cut on Track Matching residual
Definition: AliAnaPhoton.h:220
AliHistogramRanges::GetHistoPtBins
Int_t GetHistoPtBins() const
Definition: AliHistogramRanges.h:37
AliAnaPhoton::fTimeCutMin
Double_t fTimeCutMin
Remove clusters/cells with time smaller than this value, in ns.
Definition: AliAnaPhoton.h:153
AliAnaPhoton::fgkNssTypes
static const Int_t fgkNssTypes
Total number of MC histograms for shower shape studies.
Definition: AliAnaPhoton.h:141
AliAnaPhoton::fhTimeLam0BinPerSMWeighted
TH2F * fhTimeLam0BinPerSMWeighted[2][20]
! Cell time, not maximum cluster cell, in a l0 bin per SM, log weight Cell E / Cluster E ...
Definition: AliAnaPhoton.h:390
AliCaloTrackReader::GetEMCALPtMin
Float_t GetEMCALPtMin() const
Definition: AliCaloTrackReader.h:128
AliAnaPhoton::fhMCDeltaE
TH2F * fhMCDeltaE[fgkNmcTypes]
! MC-Reco E distribution coming from MC particle
Definition: AliAnaPhoton.h:256
AliAnaPhoton::fhTrackMatchedDEtaNeg
TH2F * fhTrackMatchedDEtaNeg[2]
! Eta distance between track and cluster vs cluster E, after and before photon cuts ...
Definition: AliAnaPhoton.h:330
AliAnaPhoton::fhLam1EMCALRegionPerSM
TH2F * fhLam1EMCALRegionPerSM[4][3][20]
! Cluster lambda1 vs Pt, in different EMCal regions
Definition: AliAnaPhoton.h:383
AliAnaPhoton::fhSumPhiE
TH2F * fhSumPhiE
! shower dispersion in phi direction
Definition: AliAnaPhoton.h:244
AliAnaPhoton::fhEmbedPhotonELambda0FullBkg
TH2F * fhEmbedPhotonELambda0FullBkg
! Lambda0 vs E for embedded photons with less than 10% of the cluster energy
Definition: AliAnaPhoton.h:313
AliAnaPhoton::fhLam0ETM
TH2F * fhLam0ETM
! Cluster lambda0 vs E, cut on Track Matching residual
Definition: AliAnaPhoton.h:214
AliAnaPhoton::fhMCEDispersion
TH2F * fhMCEDispersion[fgkNssTypes]
! E vs Dispersion from MC particle
Definition: AliAnaPhoton.h:283
AliMCAnalysisUtils::GetNOverlaps
Int_t GetNOverlaps(const Int_t *label, UInt_t nlabels, Int_t mctag, Int_t mesonLabel, AliCaloTrackReader *reader, Int_t *overpdg)
Definition: AliMCAnalysisUtils.cxx:1967
AliAnaPhoton::fhEtaLam0HighE
TH2F * fhEtaLam0HighE
! Cluster eta vs lambda0, E>2
Definition: AliAnaPhoton.h:232
AliCalorimeterUtils::GetMatchedTrack
AliVTrack * GetMatchedTrack(AliVCluster *cluster, AliVEvent *event, Int_t index=-1) const
Definition: AliCalorimeterUtils.cxx:924
AliAnaPhoton::fhLam1E
TH2F * fhLam1E
! Cluster lambda1 vs E
Definition: AliAnaPhoton.h:206
AliAnaPhoton::fhPtPhotonNPileUpTrkVtxTimeCut2
TH2F * fhPtPhotonNPileUpTrkVtxTimeCut2
! photon pt vs number of track pile-up vertices, time cut +- 75 ns
Definition: AliAnaPhoton.h:363
AliAnaPhoton::fhDispEtaPhiDiffE
TH2F * fhDispEtaPhiDiffE
! shower dispersion eta - phi
Definition: AliAnaPhoton.h:246
ClassImp
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Definition: AliAnalysisTaskCRC.cxx:44
AliAnaPhoton::fhMCDeltaPt
TH2F * fhMCDeltaPt[fgkNmcTypes]
! MC-Reco pT distribution coming from MC particle
Definition: AliAnaPhoton.h:257
AliAnaPhoton::fhDispPhiE
TH2F * fhDispPhiE
! shower dispersion in phi direction
Definition: AliAnaPhoton.h:242
AliAnaPhoton::fhMCLambda0vsClusterMaxCellDiffE0
TH2F * fhMCLambda0vsClusterMaxCellDiffE0[fgkNssTypes]
! Lambda0 vs fraction of energy of max cell for E < 2 GeV
Definition: AliAnaPhoton.h:289
AliHistogramRanges::GetHistoPOverEMax
Float_t GetHistoPOverEMax() const
Definition: AliHistogramRanges.h:151
AliAnaPhoton::fhYPrimMCAcc
TH2F * fhYPrimMCAcc[fgkNmcPrimTypes]
! Rapidity of generated photon, in calorimeter acceptance
Definition: AliAnaPhoton.h:276
AliAnaPhoton::fhPhiPrimMCAcc
TH2F * fhPhiPrimMCAcc[fgkNmcPrimTypes]
! Phi of generted photon, in calorimeter acceptance
Definition: AliAnaPhoton.h:274
AliAnaPhoton::fhNCellsLam0LowE
TH2F * fhNCellsLam0LowE
! number of cells in cluster vs lambda0
Definition: AliAnaPhoton.h:223
AliAnaPhoton::fhMCPhotonELambda0NoOverlap
TH2F * fhMCPhotonELambda0NoOverlap
! E vs Lambda0 from MC photons, no overlap
Definition: AliAnaPhoton.h:285
etamax
const Double_t etamax
Definition: AddTaskCFDStar.C:41
AliAnaPhoton::fhColRowLam0BinPtBinWeighted
TH2F * fhColRowLam0BinPtBinWeighted[2][7]
! Cell hits, not maximum cluster cell, in a l0 bin, different Pt bins and log weight Cell E / Cluster...
Definition: AliAnaPhoton.h:401
AliAnaCaloTrackCorrBaseClass::GetMCAnalysisUtils
virtual AliMCAnalysisUtils * GetMCAnalysisUtils()
Definition: AliAnaCaloTrackCorrBaseClass.h:334
AliAnaPhoton::fhSumEtaPhiE
TH2F * fhSumEtaPhiE
! shower dispersion in eta and phi direction
Definition: AliAnaPhoton.h:245
AliAnaPhoton::fhLam0PerSM
TH2F * fhLam0PerSM[20]
! Cluster lambda0 vs Pt, in different SM
Definition: AliAnaPhoton.h:423
AliAnaPhoton::Init
void Init()
Init. Do some checks, abort if the cluster is not the expected PHOS or EMCal.
Definition: AliAnaPhoton.cxx:3013
AliAnaPhoton::fhMCPhi
TH2F * fhMCPhi[fgkNmcTypes]
! Phi of identified photon coming from MC particle
Definition: AliAnaPhoton.h:263
AliAnaPhoton::fhClusterTimeDiffPhotonPileUp
TH2F * fhClusterTimeDiffPhotonPileUp[7]
! E vs Time difference inside cluster for selected photons
Definition: AliAnaPhoton.h:352
AliAnaPhoton::fPrimaryMom
TLorentzVector fPrimaryMom
! Primary MC momentum, temporary container
Definition: AliAnaPhoton.h:173
AliAnaCaloTrackCorrBaseClass::Print
virtual void Print(const Option_t *) const
Print some relevant parameters set for the analysis.
Definition: AliAnaCaloTrackCorrBaseClass.cxx:611
AliAnaPhoton::ClusterSelected
Bool_t ClusterSelected(AliVCluster *cl, Int_t nlm)
Definition: AliAnaPhoton.cxx:316
AliHistogramRanges::GetHistoTimeBins
Int_t GetHistoTimeBins() const
Definition: AliHistogramRanges.h:268
AliHistogramRanges::GetHistoPOverEMin
Float_t GetHistoPOverEMin() const
Definition: AliHistogramRanges.h:150
AliAnaPhoton::fhEPrimMCAcc
TH1F * fhEPrimMCAcc[fgkNmcPrimTypes]
! Number of generated photon vs energy, in calorimeter acceptance
Definition: AliAnaPhoton.h:272
AliAnaPhoton::fhTrackMatchedDEtaMCOverlap
TH2F * fhTrackMatchedDEtaMCOverlap[2]
! Eta distance between track and cluster vs cluster E, several particle overlap, after and before pho...
Definition: AliAnaPhoton.h:337
AliAnaPhoton::fhTimeNPileUpVertTrack
TH2F * fhTimeNPileUpVertTrack
! Time of cluster vs n pile-up vertices from Tracks
Definition: AliAnaPhoton.h:356
AliHistogramRanges::GetHistoTimeMax
Float_t GetHistoTimeMax() const
Definition: AliHistogramRanges.h:270
AliCaloTrackReader::GetDataType
virtual Int_t GetDataType() const
Definition: AliCaloTrackReader.h:82
AliHistogramRanges::GetHistoTimeMin
Float_t GetHistoTimeMin() const
Definition: AliHistogramRanges.h:269
AliHistogramRanges::GetHistoShowerShapeMax
Float_t GetHistoShowerShapeMax() const
Definition: AliHistogramRanges.h:261
AliCaloTrackReader::IsPileUpFromEMCal
Bool_t IsPileUpFromEMCal() const
Check if event is from pile-up determined by EMCal.
Definition: AliCaloTrackReader.cxx:1242
AliAnaPhoton::FillTrackMatchingResidualHistograms
void FillTrackMatchingResidualHistograms(AliVCluster *calo, Int_t cut)
Definition: AliAnaPhoton.cxx:1305
AliAnaPhoton::fhTrackMatchedDPhi
TH2F * fhTrackMatchedDPhi[2]
! Phi distance between track and cluster vs cluster E, after and before photon cuts ...
Definition: AliAnaPhoton.h:323
AliAnaPhoton::fhCellClusterELam0BinPerSMWeighted
TH2F * fhCellClusterELam0BinPerSMWeighted[2][20]
! Cell E vs cluster pT, not maximum cluster cell, in a l0 bin per SM, log weight Cell E / Cluster E ...
Definition: AliAnaPhoton.h:396
AliAnaPhoton::fhDispLam1HighE
TH2F * fhDispLam1HighE
! Cluster disp vs lambda1, E>2
Definition: AliAnaPhoton.h:239
AliAnaPhoton::fhPtCentralityPhoton
TH2F * fhPtCentralityPhoton
! centrality vs photon pT
Definition: AliAnaPhoton.h:197
AliAnaPhoton::fhCellClusterIndexELam0BinPerSMLargeTime
TH2F * fhCellClusterIndexELam0BinPerSMLargeTime[2][20]
! Cell in Cluster index (low index high energy, high index low energy) vs cluster pT...
Definition: AliAnaPhoton.h:420
nbins
const Int_t nbins
Definition: AverageDmesonRaa.C:63
AliHistogramRanges::GetHistoPhiMax
Float_t GetHistoPhiMax() const
Definition: AliHistogramRanges.h:62
AliAnaPhoton::fhTrackMatchedDPhiMCOverlap
TH2F * fhTrackMatchedDPhiMCOverlap[2]
! Phi distance between track and cluster vs cluster E, several particle overlap, after and before pho...
Definition: AliAnaPhoton.h:338
AliAnaCaloTrackCorrBaseClass::GetReader
virtual AliCaloTrackReader * GetReader() const
Definition: AliAnaCaloTrackCorrBaseClass.h:338
AliHistogramRanges::GetHistoEtaBins
Int_t GetHistoEtaBins() const
Definition: AliHistogramRanges.h:88
AliAnaPhoton::fhMCLambda0vsClusterMaxCellDiffE6
TH2F * fhMCLambda0vsClusterMaxCellDiffE6[fgkNssTypes]
! Lambda0 vs fraction of energy of max cell for E > 6 GeV
Definition: AliAnaPhoton.h:291
AliAnaPhoton::fhTrackMatchedDPhiPos
TH2F * fhTrackMatchedDPhiPos[2]
! Phi distance between track and cluster vs cluster E, after and before photon cuts ...
Definition: AliAnaPhoton.h:327
AliHistogramRanges::GetHistoTrackResidualEtaMax
Float_t GetHistoTrackResidualEtaMax() const
Definition: AliHistogramRanges.h:288
AliAnaPhoton::fMomentum
TLorentzVector fMomentum
! Cluster momentum, temporary container
Definition: AliAnaPhoton.h:172
AliAnaPhoton::fhLam0DispHighE
TH2F * fhLam0DispHighE
! Cluster lambda0 vs dispersion, E>2
Definition: AliAnaPhoton.h:235
AliAnaPhoton::fhEtaPhiLam0BinPtBin
TH2F * fhEtaPhiLam0BinPtBin[2][7]
! Cluster eta/phi in a l0 bin, different Pt bins
Definition: AliAnaPhoton.h:399
AliAnaCaloTrackCorrBaseClass::GetEMCALClusters
virtual TObjArray * GetEMCALClusters() const
Definition: AliAnaCaloTrackCorrBaseClass.cxx:301
AliAnaPhoton::fhMCESumEtaPhi
TH2F * fhMCESumEtaPhi[fgkNssTypes]
! shower dispersion in eta vs phi direction
Definition: AliAnaPhoton.h:300
AliAnaPhoton::fhTrackMatchedDEtaMCNoOverlap
TH2F * fhTrackMatchedDEtaMCNoOverlap[2]
! Eta distance between track and cluster vs cluster E, not other particle overlap, after and before photon cuts
Definition: AliAnaPhoton.h:339
AliAnaPhoton::fhLam0PtTM
TH2F * fhLam0PtTM
! Cluster lambda0 vs pT, cut on Track Matching residual
Definition: AliAnaPhoton.h:215
AliAnaPhoton::fhLam1Lam0BinPerSM
TH2F * fhLam1Lam0BinPerSM[2][20]
! Cluster lambda1, in a l0 bin per SM
Definition: AliAnaPhoton.h:388
AliAnaPhoton::fhLam0Pt
TH2F * fhLam0Pt
! Cluster lambda0 vs pT
Definition: AliAnaPhoton.h:205
AliAnaCaloTrackCorrBaseClass::GetPHOSCells
virtual AliVCaloCells * GetPHOSCells() const
Definition: AliAnaCaloTrackCorrBaseClass.h:144
AliAnaPhoton::fhTimeNPileUpVertSPD
TH2F * fhTimeNPileUpVertSPD
! Time of cluster vs n pile-up vertices from SPD
Definition: AliAnaPhoton.h:355
AliAnaPhoton::fhMCConversionLambda0RcutTRD
TH2F * fhMCConversionLambda0RcutTRD[6]
! Shower shape M02 of photon conversions, depending on conversion vertex, SM covered by TRD ...
Definition: AliAnaPhoton.h:373
AliAnaPhoton::fhEtaPrimMCAcc
TH2F * fhEtaPrimMCAcc[fgkNmcPrimTypes]
! Phi of generted photon, in calorimeter acceptance
Definition: AliAnaPhoton.h:275
AliAnaPhoton::fhNLocMax
TH2F * fhNLocMax
! number of maxima in selected clusters
Definition: AliAnaPhoton.h:201
AliAnaPhoton::fgkNmcTypes
static const Int_t fgkNmcTypes
Total number of cluster MC origin histograms.
Definition: AliAnaPhoton.h:127
AliAnaPhoton::fhEmbedPi0ELambda0MostlySignal
TH2F * fhEmbedPi0ELambda0MostlySignal
! Lambda0 vs E for embedded photons with 90%<fraction<50%
Definition: AliAnaPhoton.h:316
AliMCAnalysisUtils::CheckTagBit
Bool_t CheckTagBit(Int_t tag, UInt_t test) const
Definition: AliMCAnalysisUtils.h:105
AliCalorimeterUtils::GetMaxEnergyCell
Int_t GetMaxEnergyCell(AliVCaloCells *cells, AliVCluster *clu, Float_t &fraction) const
For a given CaloCluster, it gets the absId of the cell with maximum energy deposit.
Definition: AliCalorimeterUtils.cxx:861
nptbins
Int_t nptbins
Definition: CalculateAveragePt.C:56
AliAnaPhoton::fhPhiLam0HighE
TH2F * fhPhiLam0HighE
! Cluster phi vs lambda0, E>2
Definition: AliAnaPhoton.h:233
AliAnaPhoton::fhMCEDispPhi
TH2F * fhMCEDispPhi[fgkNssTypes]
! shower dispersion in phi direction
Definition: AliAnaPhoton.h:299
AliAnaCaloTrackCorrBaseClass::GetMixedEvent
virtual AliMixedEvent * GetMixedEvent() const
Definition: AliAnaCaloTrackCorrBaseClass.h:264
AliAnaPhoton::fhEmbedPhotonELambda0MostlyBkg
TH2F * fhEmbedPhotonELambda0MostlyBkg
! Lambda0 vs E for embedded photons with 50%<fraction<10%
Definition: AliAnaPhoton.h:312
AliAnaPhoton::fProdVertex
TVector3 fProdVertex
! Primary MC production vertex, temporary container
Definition: AliAnaPhoton.h:174
AliAnaPhoton::fhDTimeLam0BinPerSM
TH2F * fhDTimeLam0BinPerSM[2][20]
! t_max-t_cell, not maximum cluster cell, in a l0 bin per SM
Definition: AliAnaPhoton.h:391
AliAnaPhoton::fFillConversionVertexHisto
Bool_t fFillConversionVertexHisto
Fill histograms depending on the conversion vertex.
Definition: AliAnaPhoton.h:165
AliAnaPhoton::GetAnalysisCuts
TObjString * GetAnalysisCuts()
Save parameters used for analysis in a string.
Definition: AliAnaPhoton.cxx:1442
AliAnaPhoton::fhLam1Lam0LowE
TH2F * fhLam1Lam0LowE
! Cluster lambda1 vs lambda0, E<2
Definition: AliAnaPhoton.h:236
phimin
const Double_t phimin
Definition: AddTaskCFDStar.C:32
AliAnaPhoton::fhMCNCellsvsClusterMaxCellDiffE0
TH2F * fhMCNCellsvsClusterMaxCellDiffE0[fgkNssTypes]
! NCells vs fraction of energy of max cell for E < 2
Definition: AliAnaPhoton.h:292
AliCaloTrackReader::IsPileUpFromSPDAndEMCal
Bool_t IsPileUpFromSPDAndEMCal() const
Check if event is from pile-up determined by SPD and EMCal.
Definition: AliCaloTrackReader.cxx:1251
AliAnaPhoton::fhMCConversionLambda0Rcut
TH2F * fhMCConversionLambda0Rcut[6]
! Shower shape M02 of photon conversions, depending on conversion vertex.
Definition: AliAnaPhoton.h:372
AliAnaPhoton::fhMCLambda0vsClusterMaxCellDiffE2
TH2F * fhMCLambda0vsClusterMaxCellDiffE2[fgkNssTypes]
! Lambda0 vs fraction of energy of max cell for 2< E < 6 GeV
Definition: AliAnaPhoton.h:290
AliAnaPhoton::fhMCConversionLambda1Rcut
TH2F * fhMCConversionLambda1Rcut[6]
! Shower shape M20 of photon conversions, depending on conversion vertex.
Definition: AliAnaPhoton.h:374
AliAnaCaloTrackCorrBaseClass::GetFirstSMCoveredByTRD
Int_t GetFirstSMCoveredByTRD() const
Time cut in ns.
Definition: AliAnaCaloTrackCorrBaseClass.h:224
AliCalorimeterUtils::GetEMCALSubregion
void GetEMCALSubregion(AliVCluster *clus, AliVCaloCells *cells, Int_t &regEta, Int_t &regPhi) const
Definition: AliCalorimeterUtils.cxx:803
AliAnaPhoton::fhTimeLam0BinPerSM
TH2F * fhTimeLam0BinPerSM[2][20]
! Cell time, not maximum cluster cell, in a l0 bin per SM
Definition: AliAnaPhoton.h:389