1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is 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 **************************************************************************/
16 //_________________________________________________________________________
18 // Split clusters with some criteria and calculate invariant mass
19 // to identify them as pi0 or conversion
22 //-- Author: Gustavo Conesa (LPSC-Grenoble)
23 //_________________________________________________________________________
25 //////////////////////////////////////////////////////////////////////////////
28 // --- ROOT system ---
30 #include <TClonesArray.h>
31 #include <TObjString.h>
34 // --- Analysis system ---
35 #include "AliAnaInsideClusterInvariantMass.h"
36 #include "AliCaloTrackReader.h"
37 #include "AliMCAnalysisUtils.h"
39 #include "AliFiducialCut.h"
40 #include "TParticle.h"
41 #include "AliVCluster.h"
42 #include "AliAODEvent.h"
43 #include "AliAODMCParticle.h"
44 #include "AliEMCALGeoParams.h"
47 //#include "AliPHOSGeoUtils.h"
48 #include "AliEMCALGeometry.h"
50 ClassImp(AliAnaInsideClusterInvariantMass)
52 //__________________________________________________________________
53 AliAnaInsideClusterInvariantMass::AliAnaInsideClusterInvariantMass() :
54 AliAnaCaloTrackCorrBaseClass(),
56 fM02MaxCut(0), fM02MinCut(0),
57 fMinNCells(0), fMinBadDist(0),
58 fFillAngleHisto(kFALSE),
59 fFillTMResidualHisto(kFALSE),
60 fFillSSExtraHisto(kFALSE),
61 fFillMCFractionHisto(kFALSE),
62 fFillSSWeightHisto(kFALSE),
64 fSSWeightN(0), fSSECellCutN(0),
65 fhMassM02CutNLocMax1(0), fhMassM02CutNLocMax2(0), fhMassM02CutNLocMaxN(0),
66 fhAsymM02CutNLocMax1(0), fhAsymM02CutNLocMax2(0), fhAsymM02CutNLocMaxN(0),
67 fhMassSplitECutNLocMax1(0), fhMassSplitECutNLocMax2(0), fhMassSplitECutNLocMaxN(0),
68 fhMCGenFracAfterCutsNLocMax1MCPi0(0),
69 fhMCGenFracAfterCutsNLocMax2MCPi0(0),
70 fhMCGenFracAfterCutsNLocMaxNMCPi0(0),
71 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0(0),
72 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0(0),
73 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0(0),
74 fhEventPlanePi0NLocMax1(0), fhEventPlaneEtaNLocMax1(0),
75 fhEventPlanePi0NLocMax2(0), fhEventPlaneEtaNLocMax2(0),
76 fhEventPlanePi0NLocMaxN(0), fhEventPlaneEtaNLocMaxN(0),
77 fhClusterEtaPhiNLocMax1(0), fhClusterEtaPhiNLocMax2(0), fhClusterEtaPhiNLocMaxN(0),
78 fhPi0EtaPhiNLocMax1(0), fhPi0EtaPhiNLocMax2(0), fhPi0EtaPhiNLocMaxN(0),
79 fhEtaEtaPhiNLocMax1(0), fhEtaEtaPhiNLocMax2(0), fhEtaEtaPhiNLocMaxN(0)
83 // Init array of histograms
84 for(Int_t i = 0; i < 8; i++)
86 for(Int_t j = 0; j < 2; j++)
88 fhMassNLocMax1[i][j] = 0;
89 fhMassNLocMax2[i][j] = 0;
90 fhMassNLocMaxN[i][j] = 0;
92 fhNLocMaxM02Cut[i][j] = 0;
93 fhM02NLocMax1[i][j] = 0;
94 fhM02NLocMax2[i][j] = 0;
95 fhM02NLocMaxN[i][j] = 0;
96 fhNCellNLocMax1[i][j] = 0;
97 fhNCellNLocMax2[i][j] = 0;
98 fhNCellNLocMaxN[i][j] = 0;
99 fhM02Pi0NLocMax1[i][j] = 0;
100 fhM02EtaNLocMax1[i][j] = 0;
101 fhM02ConNLocMax1[i][j] = 0;
102 fhM02Pi0NLocMax2[i][j] = 0;
103 fhM02EtaNLocMax2[i][j] = 0;
104 fhM02ConNLocMax2[i][j] = 0;
105 fhM02Pi0NLocMaxN[i][j] = 0;
106 fhM02EtaNLocMaxN[i][j] = 0;
107 fhM02ConNLocMaxN[i][j] = 0;
109 fhMassPi0NLocMax1[i][j] = 0;
110 fhMassEtaNLocMax1[i][j] = 0;
111 fhMassConNLocMax1[i][j] = 0;
112 fhMassPi0NLocMax2[i][j] = 0;
113 fhMassEtaNLocMax2[i][j] = 0;
114 fhMassConNLocMax2[i][j] = 0;
115 fhMassPi0NLocMaxN[i][j] = 0;
116 fhMassEtaNLocMaxN[i][j] = 0;
117 fhMassConNLocMaxN[i][j] = 0;
120 fhAsyPi0NLocMax1[i][j] = 0;
121 fhAsyEtaNLocMax1[i][j] = 0;
122 fhAsyConNLocMax1[i][j] = 0;
123 fhAsyPi0NLocMax2[i][j] = 0;
124 fhAsyEtaNLocMax2[i][j] = 0;
125 fhAsyConNLocMax2[i][j] = 0;
126 fhAsyPi0NLocMaxN[i][j] = 0;
127 fhAsyEtaNLocMaxN[i][j] = 0;
128 fhAsyConNLocMaxN[i][j] = 0;
130 fhMassM02NLocMax1[i][j]= 0;
131 fhMassM02NLocMax2[i][j]= 0;
132 fhMassM02NLocMaxN[i][j]= 0;
133 fhMassDispEtaNLocMax1[i][j]= 0;
134 fhMassDispEtaNLocMax2[i][j]= 0;
135 fhMassDispEtaNLocMaxN[i][j]= 0;
136 fhMassDispPhiNLocMax1[i][j]= 0;
137 fhMassDispPhiNLocMax2[i][j]= 0;
138 fhMassDispPhiNLocMaxN[i][j]= 0;
139 fhMassDispAsyNLocMax1[i][j]= 0;
140 fhMassDispAsyNLocMax2[i][j]= 0;
141 fhMassDispAsyNLocMaxN[i][j]= 0;
143 fhSplitEFractionNLocMax1[i][j]=0;
144 fhSplitEFractionNLocMax2[i][j]=0;
145 fhSplitEFractionNLocMaxN[i][j]=0;
147 fhMCGenFracNLocMax1[i][j]= 0;
148 fhMCGenFracNLocMax2[i][j]= 0;
149 fhMCGenFracNLocMaxN[i][j]= 0;
151 fhMCGenSplitEFracNLocMax1[i][j]= 0;
152 fhMCGenSplitEFracNLocMax2[i][j]= 0;
153 fhMCGenSplitEFracNLocMaxN[i][j]= 0;
155 fhMCGenEFracvsSplitEFracNLocMax1[i][j]= 0;
156 fhMCGenEFracvsSplitEFracNLocMax2[i][j]= 0;
157 fhMCGenEFracvsSplitEFracNLocMaxN[i][j]= 0;
159 fhMCGenEvsSplitENLocMax1[i][j]= 0;
160 fhMCGenEvsSplitENLocMax2[i][j]= 0;
161 fhMCGenEvsSplitENLocMaxN[i][j]= 0;
163 fhAsymNLocMax1 [i][j] = 0;
164 fhAsymNLocMax2 [i][j] = 0;
165 fhAsymNLocMaxN [i][j] = 0;
167 fhMassAfterCutsNLocMax1[i][j] = 0;
168 fhMassAfterCutsNLocMax2[i][j] = 0;
169 fhMassAfterCutsNLocMaxN[i][j] = 0;
171 fhSplitEFractionAfterCutsNLocMax1[i][j] = 0 ;
172 fhSplitEFractionAfterCutsNLocMax2[i][j] = 0 ;
173 fhSplitEFractionAfterCutsNLocMaxN[i][j] = 0 ;
175 fhCentralityPi0NLocMax1[i][j] = 0 ;
176 fhCentralityEtaNLocMax1[i][j] = 0 ;
178 fhCentralityPi0NLocMax2[i][j] = 0 ;
179 fhCentralityEtaNLocMax2[i][j] = 0 ;
181 fhCentralityPi0NLocMaxN[i][j] = 0 ;
182 fhCentralityEtaNLocMaxN[i][j] = 0 ;
185 for(Int_t jj = 0; jj < 4; jj++)
187 fhM02MCGenFracNLocMax1Ebin[i][jj] = 0;
188 fhM02MCGenFracNLocMax2Ebin[i][jj] = 0;
189 fhM02MCGenFracNLocMaxNEbin[i][jj] = 0;
191 fhMassMCGenFracNLocMax1Ebin[i][jj]= 0;
192 fhMassMCGenFracNLocMax2Ebin[i][jj]= 0;
193 fhMassMCGenFracNLocMaxNEbin[i][jj]= 0;
195 fhMCGenFracNLocMaxEbin[i][jj] = 0;
196 fhMCGenFracNLocMaxEbinMatched[i][jj]= 0;
198 fhMassSplitEFractionNLocMax1Ebin[i][jj] = 0;
199 fhMassSplitEFractionNLocMax2Ebin[i][jj] = 0;
200 fhMassSplitEFractionNLocMaxNEbin[i][jj] = 0;
203 fhTrackMatchedDEtaNLocMax1[i] = 0;
204 fhTrackMatchedDPhiNLocMax1[i] = 0;
205 fhTrackMatchedDEtaNLocMax2[i] = 0;
206 fhTrackMatchedDPhiNLocMax2[i] = 0;
207 fhTrackMatchedDEtaNLocMaxN[i] = 0;
208 fhTrackMatchedDPhiNLocMaxN[i] = 0;
212 for(Int_t i = 0; i < 2; i++)
214 fhAnglePairNLocMax1 [i] = 0;
215 fhAnglePairNLocMax2 [i] = 0;
216 fhAnglePairNLocMaxN [i] = 0;
217 fhAnglePairMassNLocMax1[i] = 0;
218 fhAnglePairMassNLocMax2[i] = 0;
219 fhAnglePairMassNLocMaxN[i] = 0;
220 fhSplitEFractionvsAsyNLocMax1[i] = 0;
221 fhSplitEFractionvsAsyNLocMax2[i] = 0;
222 fhSplitEFractionvsAsyNLocMaxN[i] = 0;
225 for(Int_t i = 0; i < 4; i++)
227 fhMassM02NLocMax1Ebin[i] = 0 ;
228 fhMassM02NLocMax2Ebin[i] = 0 ;
229 fhMassM02NLocMaxNEbin[i] = 0 ;
231 fhMassAsyNLocMax1Ebin[i] = 0 ;
232 fhMassAsyNLocMax2Ebin[i] = 0 ;
233 fhMassAsyNLocMaxNEbin[i] = 0 ;
235 fhAsyMCGenRecoNLocMax1EbinPi0[i] = 0 ;
236 fhAsyMCGenRecoNLocMax2EbinPi0[i] = 0 ;
237 fhAsyMCGenRecoNLocMaxNEbinPi0[i] = 0 ;
239 fhMassDispEtaNLocMax1Ebin[i] = 0 ;
240 fhMassDispEtaNLocMax2Ebin[i] = 0 ;
241 fhMassDispEtaNLocMaxNEbin[i] = 0 ;
243 fhMassDispPhiNLocMax1Ebin[i] = 0 ;
244 fhMassDispPhiNLocMax2Ebin[i] = 0 ;
245 fhMassDispPhiNLocMaxNEbin[i] = 0 ;
247 fhMassDispAsyNLocMax1Ebin[i] = 0 ;
248 fhMassDispAsyNLocMax2Ebin[i] = 0 ;
249 fhMassDispAsyNLocMaxNEbin[i] = 0 ;
251 fhMCAsymM02NLocMax1MCPi0Ebin[i] = 0 ;
252 fhMCAsymM02NLocMax2MCPi0Ebin[i] = 0 ;
253 fhMCAsymM02NLocMaxNMCPi0Ebin[i] = 0 ;
257 for(Int_t nlm = 0; nlm < 3; nlm++)
259 fhPi0CellE [nlm] = 0 ;
260 fhPi0CellEFrac [nlm] = 0 ;
261 fhPi0CellLogEFrac[nlm] = 0 ;
263 fhPi0CellEMaxEMax2Frac [nlm] = 0 ;
264 fhPi0CellEMaxClusterFrac [nlm] = 0 ;
265 fhPi0CellEMax2ClusterFrac[nlm] = 0 ;
267 fhPi0CellEMaxFrac [nlm] = 0 ;
268 fhPi0CellEMax2Frac[nlm] = 0 ;
270 for(Int_t i = 0; i < 10; i++)
272 fhM02WeightPi0 [nlm][i] = 0;
273 fhM02ECellCutPi0[nlm][i] = 0;
281 //__________________________________________________________________________________________________
282 void AliAnaInsideClusterInvariantMass::FillSSWeightHistograms(AliVCluster *clus, const Int_t nlm,
283 const Int_t absId1, const Int_t absId2)
285 // Calculate weights and fill histograms
287 if(!fFillSSWeightHisto) return;
289 AliVCaloCells* cells = 0;
290 if(fCalorimeter == "EMCAL") cells = GetEMCALCells();
291 else cells = GetPHOSCells();
293 // First recalculate energy in case non linearity was applied
295 for (Int_t ipos = 0; ipos < clus->GetNCells(); ipos++)
298 Int_t id = clus->GetCellsAbsId()[ipos];
300 //Recalibrate cell energy if needed
301 Float_t amp = cells->GetCellAmplitude(id);
302 GetCaloUtils()->RecalibrateCellAmplitude(amp,fCalorimeter, id);
310 printf("AliAnaInsideClusterInvatiantMass::WeightHistograms()- Wrong calculated energy %f\n",energy);
314 //Get amplitude of main local maxima, recalibrate if needed
315 Float_t amp1 = cells->GetCellAmplitude(absId1);
316 GetCaloUtils()->RecalibrateCellAmplitude(amp1,fCalorimeter, absId1);
317 Float_t amp2 = cells->GetCellAmplitude(absId2);
318 GetCaloUtils()->RecalibrateCellAmplitude(amp2,fCalorimeter, absId2);
320 if(amp1 < amp2) printf("Bad local maxima E ordering : id1 E %f, id2 E %f\n ",amp1,amp2);
321 if(amp1==0 || amp2==0) printf("Null E local maxima : id1 E %f, id2 E %f\n " ,amp1,amp2);
323 if(amp1>0)fhPi0CellEMaxEMax2Frac [nlm]->Fill(energy,amp2/amp1);
324 fhPi0CellEMaxClusterFrac [nlm]->Fill(energy,amp1/energy);
325 fhPi0CellEMax2ClusterFrac[nlm]->Fill(energy,amp2/energy);
327 //Get the ratio and log ratio to all cells in cluster
328 for (Int_t ipos = 0; ipos < clus->GetNCells(); ipos++)
330 Int_t id = clus->GetCellsAbsId()[ipos];
332 //Recalibrate cell energy if needed
333 Float_t amp = cells->GetCellAmplitude(id);
334 GetCaloUtils()->RecalibrateCellAmplitude(amp,fCalorimeter, id);
336 if(amp > 0)fhPi0CellE [nlm]->Fill(energy,amp);
337 fhPi0CellEFrac [nlm]->Fill(energy,amp/energy);
338 fhPi0CellLogEFrac[nlm]->Fill(energy,TMath::Log(amp/energy));
340 if (id!=absId1 && id!=absId2)
342 if(amp1>0)fhPi0CellEMaxFrac [nlm]->Fill(energy,amp/amp1);
343 if(amp2>0)fhPi0CellEMax2Frac[nlm]->Fill(energy,amp/amp2);
348 //Recalculate shower shape for different W0
349 if(fCalorimeter=="EMCAL")
351 Float_t l0org = clus->GetM02();
352 Float_t l1org = clus->GetM20();
353 Float_t dorg = clus->GetDispersion();
354 Float_t w0org = GetCaloUtils()->GetEMCALRecoUtils()->GetW0();
356 for(Int_t iw = 0; iw < fSSWeightN; iw++)
358 GetCaloUtils()->GetEMCALRecoUtils()->SetW0(fSSWeight[iw]);
359 GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), cells, clus);
361 fhM02WeightPi0[nlm][iw]->Fill(energy,clus->GetM02());
365 // Set the original values back
368 clus->SetDispersion(dorg);
369 GetCaloUtils()->GetEMCALRecoUtils()->SetW0(w0org);
371 for(Int_t iec = 0; iec < fSSECellCutN; iec++)
373 Float_t l0 = 0., l1 = 0.;
374 Float_t disp = 0., dEta = 0., dPhi = 0.;
375 Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
376 // GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), cells, clus,l0,l1,disp,
377 // dEta, dPhi, sEta, sPhi, sEtaPhi,fSSECellCut[iec]);
379 RecalculateClusterShowerShapeParametersWithCellCut(GetEMCALGeometry(), cells, clus,l0,l1,disp,
380 dEta, dPhi, sEta, sPhi, sEtaPhi,fSSECellCut[iec]);
383 fhM02ECellCutPi0[nlm][iec]->Fill(energy,l0);
392 //_______________________________________________________________
393 TObjString * AliAnaInsideClusterInvariantMass::GetAnalysisCuts()
395 //Save parameters used for analysis
396 TString parList ; //this will be list of parameters used for this analysis.
397 const Int_t buffersize = 255;
398 char onePar[buffersize] ;
400 snprintf(onePar,buffersize,"--- AliAnaInsideClusterInvariantMass ---\n") ;
403 snprintf(onePar,buffersize,"Calorimeter: %s\n", fCalorimeter.Data()) ;
405 snprintf(onePar,buffersize,"fNLocMaxCutE =%2.2f \n", GetCaloUtils()->GetLocalMaximaCutE()) ;
407 snprintf(onePar,buffersize,"fNLocMaxCutEDiff =%2.2f \n",GetCaloUtils()->GetLocalMaximaCutEDiff()) ;
409 snprintf(onePar,buffersize,"%2.2f< M02 < %2.2f \n", fM02MinCut, fM02MaxCut) ;
411 snprintf(onePar,buffersize,"fMinNCells =%d \n", fMinNCells) ;
413 snprintf(onePar,buffersize,"fMinBadDist =%1.1f \n", fMinBadDist) ;
415 if(fFillSSWeightHisto)
417 snprintf(onePar,buffersize," N w %d - N e cut %d \n",fSSWeightN,fSSECellCutN);
421 return new TObjString(parList) ;
425 //________________________________________________________________
426 TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
428 // Create histograms to be saved in output file and
429 // store them in outputContainer
430 TList * outputContainer = new TList() ;
431 outputContainer->SetName("InsideClusterHistos") ;
433 Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t ptmin = GetHistogramRanges()->GetHistoPtMin();
434 Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins(); Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax(); Float_t ssmin = GetHistogramRanges()->GetHistoShowerShapeMin();
435 Int_t mbins = GetHistogramRanges()->GetHistoMassBins(); Float_t mmax = GetHistogramRanges()->GetHistoMassMax(); Float_t mmin = GetHistogramRanges()->GetHistoMassMin();
436 Int_t ncbins = GetHistogramRanges()->GetHistoNClusterCellBins(); Int_t ncmax = GetHistogramRanges()->GetHistoNClusterCellMax(); Int_t ncmin = GetHistogramRanges()->GetHistoNClusterCellMin();
437 Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins(); Float_t phimax = GetHistogramRanges()->GetHistoPhiMax(); Float_t phimin = GetHistogramRanges()->GetHistoPhiMin();
438 Int_t netabins = GetHistogramRanges()->GetHistoEtaBins(); Float_t etamax = GetHistogramRanges()->GetHistoEtaMax(); Float_t etamin = GetHistogramRanges()->GetHistoEtaMin();
440 Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
441 Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
442 Float_t resetamin = GetHistogramRanges()->GetHistoTrackResidualEtaMin();
443 Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
444 Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
445 Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
447 TString ptype[] ={"","#gamma","#gamma->e^{#pm}","#pi^{0}","#eta","e^{#pm}", "hadron","#pi^{0} (#gamma->e^{#pm})"};
448 TString pname[] ={"","Photon","Conversion", "Pi0", "Eta", "Electron","Hadron","Pi0Conv"};
452 if(IsDataMC()) n = 8;
456 TString sMatched[] = {"","Matched"};
458 for(Int_t i = 0; i < n; i++)
460 for(Int_t j = 0; j < 2; j++)
463 fhMassNLocMax1[i][j] = new TH2F(Form("hMassNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
464 Form("Invariant mass of splitted cluster with NLM=1 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
465 nptbins,ptmin,ptmax,mbins,mmin,mmax);
466 fhMassNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
467 fhMassNLocMax1[i][j]->SetXTitle("E (GeV)");
468 outputContainer->Add(fhMassNLocMax1[i][j]) ;
470 fhMassNLocMax2[i][j] = new TH2F(Form("hMassNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
471 Form("Invariant mass of splitted cluster with NLM=2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
472 nptbins,ptmin,ptmax,mbins,mmin,mmax);
473 fhMassNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
474 fhMassNLocMax2[i][j]->SetXTitle("E (GeV)");
475 outputContainer->Add(fhMassNLocMax2[i][j]) ;
477 fhMassNLocMaxN[i][j] = new TH2F(Form("hMassNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
478 Form("Invariant mass of splitted cluster with NLM>2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
479 nptbins,ptmin,ptmax,mbins,mmin,mmax);
480 fhMassNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
481 fhMassNLocMaxN[i][j]->SetXTitle("E (GeV)");
482 outputContainer->Add(fhMassNLocMaxN[i][j]) ;
484 fhMassAfterCutsNLocMax1[i][j] = new TH2F(Form("hMassAfterCutsNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
485 Form("Mass vs E, %s %s, for N Local max = 1, M02 and asy cut",ptype[i].Data(),sMatched[j].Data()),
486 nptbins,ptmin,ptmax,mbins,mmin,mmax);
487 fhMassAfterCutsNLocMax1[i][j] ->SetYTitle("Mass (GeV/c^{2})");
488 fhMassAfterCutsNLocMax1[i][j] ->SetXTitle("E (GeV)");
489 outputContainer->Add(fhMassAfterCutsNLocMax1[i][j]) ;
491 fhMassAfterCutsNLocMax2[i][j] = new TH2F(Form("hMassAfterCutsNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
492 Form("Mass vs E, %s %s, for N Local max = 2, M02 and asy cut",ptype[i].Data(),sMatched[j].Data()),
493 nptbins,ptmin,ptmax,mbins,mmin,mmax);
494 fhMassAfterCutsNLocMax2[i][j] ->SetYTitle("Mass (GeV/c^{2})");
495 fhMassAfterCutsNLocMax2[i][j] ->SetXTitle("E (GeV)");
496 outputContainer->Add(fhMassAfterCutsNLocMax2[i][j]) ;
499 fhMassAfterCutsNLocMaxN[i][j] = new TH2F(Form("hMassAfterCutsNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
500 Form("Mass vs E, %s %s, for N Local max > 2, M02 and asy cut",ptype[i].Data(),sMatched[j].Data()),
501 nptbins,ptmin,ptmax,mbins,mmin,mmax);
502 fhMassAfterCutsNLocMaxN[i][j] ->SetYTitle("Mass (GeV/c^{2})");
503 fhMassAfterCutsNLocMaxN[i][j] ->SetXTitle("E (GeV)");
504 outputContainer->Add(fhMassAfterCutsNLocMaxN[i][j]) ;
506 fhSplitEFractionAfterCutsNLocMax1[i][j] = new TH2F(Form("hSplitEFractionAfterCutsNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
507 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 1, M02 and Asy cut on, %s %s",ptype[i].Data(),sMatched[j].Data()),
508 nptbins,ptmin,ptmax,120,0,1.2);
509 fhSplitEFractionAfterCutsNLocMax1[i][j] ->SetXTitle("E_{cluster} (GeV)");
510 fhSplitEFractionAfterCutsNLocMax1[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
511 outputContainer->Add(fhSplitEFractionAfterCutsNLocMax1[i][j]) ;
513 fhSplitEFractionAfterCutsNLocMax2[i][j] = new TH2F(Form("hSplitEFractionAfterCutsNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
514 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 2, M02 and Asy cut on, %s %s",ptype[i].Data(),sMatched[j].Data()),
515 nptbins,ptmin,ptmax,120,0,1.2);
516 fhSplitEFractionAfterCutsNLocMax2[i][j] ->SetXTitle("E_{cluster} (GeV)");
517 fhSplitEFractionAfterCutsNLocMax2[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
518 outputContainer->Add(fhSplitEFractionAfterCutsNLocMax2[i][j]) ;
520 fhSplitEFractionAfterCutsNLocMaxN[i][j] = new TH2F(Form("hSplitEFractionAfterCutsNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
521 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max > 2, M02 and Asy cut on, %s %s",ptype[i].Data(),sMatched[j].Data()),
522 nptbins,ptmin,ptmax,120,0,1.2);
523 fhSplitEFractionAfterCutsNLocMaxN[i][j] ->SetXTitle("E_{cluster} (GeV)");
524 fhSplitEFractionAfterCutsNLocMaxN[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
525 outputContainer->Add(fhSplitEFractionAfterCutsNLocMaxN[i][j]) ;
528 fhMassM02NLocMax1[i][j] = new TH2F(Form("hMassM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
529 Form("Invariant mass of splitted cluster with NLM=1, #lambda_{0}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
530 ssbins,ssmin,ssmax,mbins,mmin,mmax);
531 fhMassM02NLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
532 fhMassM02NLocMax1[i][j]->SetXTitle("#lambda_{0}^{2}");
533 outputContainer->Add(fhMassM02NLocMax1[i][j]) ;
535 fhMassM02NLocMax2[i][j] = new TH2F(Form("hMassM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
536 Form("Invariant mass of splitted cluster with NLM=2, #lambda_{0}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
537 ssbins,ssmin,ssmax,mbins,mmin,mmax);
538 fhMassM02NLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
539 fhMassM02NLocMax2[i][j]->SetXTitle("#lambda_{0}^{2}");
540 outputContainer->Add(fhMassM02NLocMax2[i][j]) ;
542 fhMassM02NLocMaxN[i][j] = new TH2F(Form("hMassM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
543 Form("Invariant mass of splitted cluster with NLM>2, vs #lambda_{0}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
544 ssbins,ssmin,ssmax,mbins,mmin,mmax);
545 fhMassM02NLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
546 fhMassM02NLocMaxN[i][j]->SetXTitle("#lambda_{0}^{2}");
547 outputContainer->Add(fhMassM02NLocMaxN[i][j]) ;
550 fhAsymNLocMax1[i][j] = new TH2F(Form("hAsymNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
551 Form("Asymmetry of NLM=1 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
552 nptbins,ptmin,ptmax,200,-1,1);
553 fhAsymNLocMax1[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
554 fhAsymNLocMax1[i][j]->SetXTitle("E (GeV)");
555 outputContainer->Add(fhAsymNLocMax1[i][j]) ;
557 fhAsymNLocMax2[i][j] = new TH2F(Form("hAsymNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
558 Form("Asymmetry of NLM=2 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
559 nptbins,ptmin,ptmax,200,-1,1);
560 fhAsymNLocMax2[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
561 fhAsymNLocMax2[i][j]->SetXTitle("E (GeV)");
562 outputContainer->Add(fhAsymNLocMax2[i][j]) ;
564 fhAsymNLocMaxN[i][j] = new TH2F(Form("hAsymNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
565 Form("Asymmetry of NLM>2 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
566 nptbins,ptmin,ptmax,200,-1,1);
567 fhAsymNLocMaxN[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
568 fhAsymNLocMaxN[i][j]->SetXTitle("E (GeV)");
569 outputContainer->Add(fhAsymNLocMaxN[i][j]) ;
572 if(fFillSSExtraHisto)
574 fhMassDispEtaNLocMax1[i][j] = new TH2F(Form("hMassDispEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
575 Form("Invariant mass of splitted cluster with NLM=1, #sigma_{#eta #eta}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
576 ssbins,ssmin,ssmax,mbins,mmin,mmax);
577 fhMassDispEtaNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
578 fhMassDispEtaNLocMax1[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
579 outputContainer->Add(fhMassDispEtaNLocMax1[i][j]) ;
581 fhMassDispEtaNLocMax2[i][j] = new TH2F(Form("hMassDispEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
582 Form("Invariant mass of splitted cluster with NLM=2 #sigma_{#eta #eta}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
583 ssbins,ssmin,ssmax,mbins,mmin,mmax);
584 fhMassDispEtaNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
585 fhMassDispEtaNLocMax2[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
586 outputContainer->Add(fhMassDispEtaNLocMax2[i][j]) ;
588 fhMassDispEtaNLocMaxN[i][j] = new TH2F(Form("hMassDispEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
589 Form("Invariant mass of splitted cluster with NLM>2, #sigma_{#eta #eta}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
590 ssbins,ssmin,ssmax,mbins,mmin,mmax);
591 fhMassDispEtaNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
592 fhMassDispEtaNLocMaxN[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
593 outputContainer->Add(fhMassDispEtaNLocMaxN[i][j]) ;
595 fhMassDispPhiNLocMax1[i][j] = new TH2F(Form("hMassDispPhiNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
596 Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
597 ssbins,ssmin,ssmax,mbins,mmin,mmax);
598 fhMassDispPhiNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
599 fhMassDispPhiNLocMax1[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
600 outputContainer->Add(fhMassDispPhiNLocMax1[i][j]) ;
602 fhMassDispPhiNLocMax2[i][j] = new TH2F(Form("hMassDispPhiNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
603 Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
604 ssbins,ssmin,ssmax,mbins,mmin,mmax);
605 fhMassDispPhiNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
606 fhMassDispPhiNLocMax2[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
607 outputContainer->Add(fhMassDispPhiNLocMax2[i][j]) ;
609 fhMassDispPhiNLocMaxN[i][j] = new TH2F(Form("hMassDispPhiNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
610 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
611 ssbins,ssmin,ssmax,mbins,mmin,mmax);
612 fhMassDispPhiNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
613 fhMassDispPhiNLocMaxN[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
614 outputContainer->Add(fhMassDispPhiNLocMaxN[i][j]) ;
616 fhMassDispAsyNLocMax1[i][j] = new TH2F(Form("hMassDispAsyNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
617 Form("Invariant mass of 2 highest energy cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
618 200,-1,1,mbins,mmin,mmax);
619 fhMassDispAsyNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
620 fhMassDispAsyNLocMax1[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
621 outputContainer->Add(fhMassDispAsyNLocMax1[i][j]) ;
623 fhMassDispAsyNLocMax2[i][j] = new TH2F(Form("hMassDispAsyNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
624 Form("Invariant mass of 2 local maxima cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
625 200,-1,1,mbins,mmin,mmax);
626 fhMassDispAsyNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
627 fhMassDispAsyNLocMax2[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
628 outputContainer->Add(fhMassDispAsyNLocMax2[i][j]) ;
630 fhMassDispAsyNLocMaxN[i][j] = new TH2F(Form("hMassDispAsyNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
631 Form("Invariant mass of N>2 local maxima cells vsA = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), %s %s",ptype[i].Data(),sMatched[j].Data()),
632 200,-1,1,mbins,mmin,mmax);
633 fhMassDispAsyNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
634 fhMassDispAsyNLocMaxN[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
635 outputContainer->Add(fhMassDispAsyNLocMaxN[i][j]) ;
638 fhNLocMax[i][j] = new TH2F(Form("hNLocMax%s%s",pname[i].Data(),sMatched[j].Data()),
639 Form("Number of local maxima in cluster %s %s",ptype[i].Data(),sMatched[j].Data()),
640 nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
641 fhNLocMax[i][j] ->SetYTitle("N maxima");
642 fhNLocMax[i][j] ->SetXTitle("E (GeV)");
643 outputContainer->Add(fhNLocMax[i][j]) ;
645 fhNLocMaxM02Cut[i][j] = new TH2F(Form("hNLocMaxM02Cut%s%s",pname[i].Data(),sMatched[j].Data()),
646 Form("Number of local maxima in cluster %s for %2.2f < M02 < %2.2f",ptype[i].Data(),fM02MinCut,fM02MaxCut),
647 nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
648 fhNLocMaxM02Cut[i][j]->SetYTitle("N maxima");
649 fhNLocMaxM02Cut[i][j]->SetXTitle("E (GeV)");
650 outputContainer->Add(fhNLocMaxM02Cut[i][j]) ;
653 fhM02NLocMax1[i][j] = new TH2F(Form("hM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
654 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
655 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
656 fhM02NLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
657 fhM02NLocMax1[i][j] ->SetXTitle("E (GeV)");
658 outputContainer->Add(fhM02NLocMax1[i][j]) ;
660 fhM02NLocMax2[i][j] = new TH2F(Form("hM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
661 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
662 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
663 fhM02NLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
664 fhM02NLocMax2[i][j] ->SetXTitle("E (GeV)");
665 outputContainer->Add(fhM02NLocMax2[i][j]) ;
667 fhM02NLocMaxN[i][j] = new TH2F(Form("hM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
668 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
669 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
670 fhM02NLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
671 fhM02NLocMaxN[i][j] ->SetXTitle("E (GeV)");
672 outputContainer->Add(fhM02NLocMaxN[i][j]) ;
675 fhSplitEFractionNLocMax1[i][j] = new TH2F(Form("hSplitEFractionNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
676 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
677 nptbins,ptmin,ptmax,120,0,1.2);
678 fhSplitEFractionNLocMax1[i][j] ->SetXTitle("E_{cluster} (GeV)");
679 fhSplitEFractionNLocMax1[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
680 outputContainer->Add(fhSplitEFractionNLocMax1[i][j]) ;
682 fhSplitEFractionNLocMax2[i][j] = new TH2F(Form("hSplitEFractionNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
683 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
684 nptbins,ptmin,ptmax,120,0,1.2);
685 fhSplitEFractionNLocMax2[i][j] ->SetXTitle("E_{cluster} (GeV)");
686 fhSplitEFractionNLocMax2[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
687 outputContainer->Add(fhSplitEFractionNLocMax2[i][j]) ;
689 fhSplitEFractionNLocMaxN[i][j] = new TH2F(Form("hSplitEFractionNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
690 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
691 nptbins,ptmin,ptmax,120,0,1.2);
692 fhSplitEFractionNLocMaxN[i][j] ->SetXTitle("E_{cluster} (GeV)");
693 fhSplitEFractionNLocMaxN[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
694 outputContainer->Add(fhSplitEFractionNLocMaxN[i][j]) ;
697 if(i > 0 && fFillMCFractionHisto) // skip first entry in array, general case not filled
699 fhMCGenFracNLocMax1[i][j] = new TH2F(Form("hMCGenFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
700 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
701 nptbins,ptmin,ptmax,200,0,2);
702 fhMCGenFracNLocMax1[i][j] ->SetYTitle("E_{gen} / E_{reco}");
703 fhMCGenFracNLocMax1[i][j] ->SetXTitle("E (GeV)");
704 outputContainer->Add(fhMCGenFracNLocMax1[i][j]) ;
706 fhMCGenFracNLocMax2[i][j] = new TH2F(Form("hMCGenFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
707 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
708 nptbins,ptmin,ptmax,200,0,2);
709 fhMCGenFracNLocMax2[i][j] ->SetYTitle("E_{gen} / E_{reco}");
710 fhMCGenFracNLocMax2[i][j] ->SetXTitle("E (GeV)");
711 outputContainer->Add(fhMCGenFracNLocMax2[i][j]) ;
714 fhMCGenFracNLocMaxN[i][j] = new TH2F(Form("hMCGenFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
715 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
716 nptbins,ptmin,ptmax,200,0,2);
717 fhMCGenFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / E_{reco}");
718 fhMCGenFracNLocMaxN[i][j] ->SetXTitle("E (GeV)");
719 outputContainer->Add(fhMCGenFracNLocMaxN[i][j]) ;
721 fhMCGenSplitEFracNLocMax1[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
722 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
723 nptbins,ptmin,ptmax,200,0,2);
724 fhMCGenSplitEFracNLocMax1[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
725 fhMCGenSplitEFracNLocMax1[i][j] ->SetXTitle("E (GeV)");
726 outputContainer->Add(fhMCGenSplitEFracNLocMax1[i][j]) ;
728 fhMCGenSplitEFracNLocMax2[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
729 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
730 nptbins,ptmin,ptmax,200,0,2);
731 fhMCGenSplitEFracNLocMax2[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
732 fhMCGenSplitEFracNLocMax2[i][j] ->SetXTitle("E (GeV)");
733 outputContainer->Add(fhMCGenSplitEFracNLocMax2[i][j]) ;
736 fhMCGenSplitEFracNLocMaxN[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
737 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
738 nptbins,ptmin,ptmax,200,0,2);
739 fhMCGenSplitEFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
740 fhMCGenSplitEFracNLocMaxN[i][j] ->SetXTitle("E (GeV)");
741 outputContainer->Add(fhMCGenSplitEFracNLocMaxN[i][j]) ;
743 fhMCGenEFracvsSplitEFracNLocMax1[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
744 Form("(E_{1 split}+E_{2 split})/E_{reco} vs E_{gen} / E_{reco} for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
746 fhMCGenEFracvsSplitEFracNLocMax1[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
747 fhMCGenEFracvsSplitEFracNLocMax1[i][j] ->SetXTitle("E_{gen} / E_{reco}");
748 outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMax1[i][j]) ;
750 fhMCGenEFracvsSplitEFracNLocMax2[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
751 Form("(E_{1 split}+E_{2 split})/E_{reco} vs E_{gen} / E_{reco} for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
753 fhMCGenEFracvsSplitEFracNLocMax2[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
754 fhMCGenEFracvsSplitEFracNLocMax2[i][j] ->SetXTitle("E_{gen} / E_{reco}");
755 outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMax2[i][j]) ;
758 fhMCGenEFracvsSplitEFracNLocMaxN[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
759 Form("(E_{1 split}+E_{2 split})/E_{reco} vs E_{gen} / E_{reco} for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
761 fhMCGenEFracvsSplitEFracNLocMaxN[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
762 fhMCGenEFracvsSplitEFracNLocMaxN[i][j] ->SetXTitle("E_{gen} / E_{reco}");
763 outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMaxN[i][j]) ;
766 fhMCGenEvsSplitENLocMax1[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
767 Form("E_{1 split}+E_{2 split} vs E_{gen} for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
768 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
769 fhMCGenEvsSplitENLocMax1[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
770 fhMCGenEvsSplitENLocMax1[i][j] ->SetXTitle("E_{gen} (GeV)");
771 outputContainer->Add(fhMCGenEvsSplitENLocMax1[i][j]) ;
773 fhMCGenEvsSplitENLocMax2[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
774 Form("E_{1 split}+E_{2 split} vs E_{gen} for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
775 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
776 fhMCGenEvsSplitENLocMax2[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
777 fhMCGenEvsSplitENLocMax2[i][j] ->SetXTitle("E_{gen} (GeV)");
778 outputContainer->Add(fhMCGenEvsSplitENLocMax2[i][j]) ;
781 fhMCGenEvsSplitENLocMaxN[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
782 Form("E_{1 split}+E_{2 split} vs E_{gen} for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
783 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
784 fhMCGenEvsSplitENLocMaxN[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
785 fhMCGenEvsSplitENLocMaxN[i][j] ->SetXTitle("E_{gen} (GeV)");
786 outputContainer->Add(fhMCGenEvsSplitENLocMaxN[i][j]) ;
790 if(fFillSSExtraHisto)
792 fhNCellNLocMax1[i][j] = new TH2F(Form("hNCellNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
793 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
794 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
795 fhNCellNLocMax1[i][j] ->SetYTitle("N cells");
796 fhNCellNLocMax1[i][j] ->SetXTitle("E (GeV)");
797 outputContainer->Add(fhNCellNLocMax1[i][j]) ;
799 fhNCellNLocMax2[i][j] = new TH2F(Form("hNCellNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
800 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
801 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
802 fhNCellNLocMax2[i][j] ->SetYTitle("N cells");
803 fhNCellNLocMax2[i][j] ->SetXTitle("E (GeV)");
804 outputContainer->Add(fhNCellNLocMax2[i][j]) ;
807 fhNCellNLocMaxN[i][j] = new TH2F(Form("hNCellNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
808 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
809 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
810 fhNCellNLocMaxN[i][j] ->SetYTitle("N cells");
811 fhNCellNLocMaxN[i][j] ->SetXTitle("E (GeV)");
812 outputContainer->Add(fhNCellNLocMaxN[i][j]) ;
818 fhCentralityPi0NLocMax1[i][j] = new TH2F(Form("hCentralityPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
819 Form("E vs Centrality, selected pi0 cluster with NLM=1, %s",ptype[i].Data()),
820 nptbins,ptmin,ptmax,100,0,100);
821 fhCentralityPi0NLocMax1[i][j]->SetYTitle("Centrality");
822 fhCentralityPi0NLocMax1[i][j]->SetXTitle("E (GeV)");
823 outputContainer->Add(fhCentralityPi0NLocMax1[i][j]) ;
825 fhCentralityPi0NLocMax2[i][j] = new TH2F(Form("hCentralityPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
826 Form("E vs Centrality, selected pi0 cluster with NLM=2, %s",ptype[i].Data()),
827 nptbins,ptmin,ptmax,100,0,100);
828 fhCentralityPi0NLocMax2[i][j]->SetYTitle("Centrality");
829 fhCentralityPi0NLocMax2[i][j]->SetXTitle("E (GeV)");
830 outputContainer->Add(fhCentralityPi0NLocMax2[i][j]) ;
832 fhCentralityPi0NLocMaxN[i][j] = new TH2F(Form("hCentralityPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
833 Form("E vs Centrality, selected pi0 cluster with NLM>1, %s",ptype[i].Data()),
834 nptbins,ptmin,ptmax,100,0,100);
835 fhCentralityPi0NLocMaxN[i][j]->SetYTitle("Centrality");
836 fhCentralityPi0NLocMaxN[i][j]->SetXTitle("E (GeV)");
837 outputContainer->Add(fhCentralityPi0NLocMaxN[i][j]) ;
839 fhCentralityEtaNLocMax1[i][j] = new TH2F(Form("hCentralityEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
840 Form("E vs Centrality, selected pi0 cluster with NLM=1, %s",ptype[i].Data()),
841 nptbins,ptmin,ptmax,100,0,100);
842 fhCentralityEtaNLocMax1[i][j]->SetYTitle("Centrality");
843 fhCentralityEtaNLocMax1[i][j]->SetXTitle("E (GeV)");
844 outputContainer->Add(fhCentralityEtaNLocMax1[i][j]) ;
846 fhCentralityEtaNLocMax2[i][j] = new TH2F(Form("hCentralityEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
847 Form("E vs Centrality, selected pi0 cluster with NLM=2, %s",ptype[i].Data()),
848 nptbins,ptmin,ptmax,100,0,100);
849 fhCentralityEtaNLocMax2[i][j]->SetYTitle("Centrality");
850 fhCentralityEtaNLocMax2[i][j]->SetXTitle("E (GeV)");
851 outputContainer->Add(fhCentralityEtaNLocMax2[i][j]) ;
853 fhCentralityEtaNLocMaxN[i][j] = new TH2F(Form("hCentralityEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
854 Form("E vs Centrality, selected pi0 cluster with NLM>1, %s",ptype[i].Data()),
855 nptbins,ptmin,ptmax,100,0,100);
856 fhCentralityEtaNLocMaxN[i][j]->SetYTitle("Centrality");
857 fhCentralityEtaNLocMaxN[i][j]->SetXTitle("E (GeV)");
858 outputContainer->Add(fhCentralityEtaNLocMaxN[i][j]) ;
861 fhM02Pi0NLocMax1[i][j] = new TH2F(Form("hM02Pi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
862 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max = 1",
863 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
864 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
865 fhM02Pi0NLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
866 fhM02Pi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
867 outputContainer->Add(fhM02Pi0NLocMax1[i][j]) ;
869 fhM02EtaNLocMax1[i][j] = new TH2F(Form("hM02EtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
870 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 1",
871 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
872 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
873 fhM02EtaNLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
874 fhM02EtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
875 outputContainer->Add(fhM02EtaNLocMax1[i][j]) ;
877 fhM02ConNLocMax1[i][j] = new TH2F(Form("hM02ConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
878 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 1",
879 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
880 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
881 fhM02ConNLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
882 fhM02ConNLocMax1[i][j] ->SetXTitle("E (GeV)");
883 outputContainer->Add(fhM02ConNLocMax1[i][j]) ;
885 fhM02Pi0NLocMax2[i][j] = new TH2F(Form("hM02Pi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
886 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max = 2",
887 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
888 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
889 fhM02Pi0NLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
890 fhM02Pi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
891 outputContainer->Add(fhM02Pi0NLocMax2[i][j]) ;
893 fhM02EtaNLocMax2[i][j] = new TH2F(Form("hM02EtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
894 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 2",
895 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
896 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
897 fhM02EtaNLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
898 fhM02EtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
899 outputContainer->Add(fhM02EtaNLocMax2[i][j]) ;
901 fhM02ConNLocMax2[i][j] = new TH2F(Form("hM02ConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
902 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 2",
903 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
904 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
905 fhM02ConNLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
906 fhM02ConNLocMax2[i][j] ->SetXTitle("E (GeV)");
907 outputContainer->Add(fhM02ConNLocMax2[i][j]) ;
909 fhM02Pi0NLocMaxN[i][j] = new TH2F(Form("hM02Pi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
910 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max > 2",
911 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
912 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
913 fhM02Pi0NLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
914 fhM02Pi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
915 outputContainer->Add(fhM02Pi0NLocMaxN[i][j]) ;
917 fhM02EtaNLocMaxN[i][j] = new TH2F(Form("hM02EtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
918 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max > 2",
919 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
920 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
921 fhM02EtaNLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
922 fhM02EtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
923 outputContainer->Add(fhM02EtaNLocMaxN[i][j]) ;
925 fhM02ConNLocMaxN[i][j] = new TH2F(Form("hM02ConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
926 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2",
927 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
928 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
929 fhM02ConNLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
930 fhM02ConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
931 outputContainer->Add(fhM02ConNLocMaxN[i][j]) ;
934 fhMassPi0NLocMax1[i][j] = new TH2F(Form("hMassPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
935 Form("Mass vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max = 1",
936 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
937 nptbins,ptmin,ptmax,mbins,mmin,mmax);
938 fhMassPi0NLocMax1[i][j] ->SetYTitle("Mass (GeV/c^{2})");
939 fhMassPi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
940 outputContainer->Add(fhMassPi0NLocMax1[i][j]) ;
943 fhMassEtaNLocMax1[i][j] = new TH2F(Form("hMassEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
944 Form("Mass vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 1",
945 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
946 nptbins,ptmin,ptmax,mbins,mmin,mmax);
947 fhMassEtaNLocMax1[i][j] ->SetYTitle("Mass (GeV/c^{2})");
948 fhMassEtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
949 outputContainer->Add(fhMassEtaNLocMax1[i][j]) ;
951 fhMassConNLocMax1[i][j] = new TH2F(Form("hMassConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
952 Form("Mass vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 1",
953 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
954 nptbins,ptmin,ptmax,mbins,mmin,mmax);
955 fhMassConNLocMax1[i][j] ->SetYTitle("Mass (GeV/c^{2})");
956 fhMassConNLocMax1[i][j] ->SetXTitle("E (GeV)");
957 outputContainer->Add(fhMassConNLocMax1[i][j]) ;
959 fhMassPi0NLocMax2[i][j] = new TH2F(Form("hMassPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
960 Form("Mass vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max = 2",
961 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
962 nptbins,ptmin,ptmax,mbins,mmin,mmax);
963 fhMassPi0NLocMax2[i][j] ->SetYTitle("Mass (GeV/c^{2})");
964 fhMassPi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
965 outputContainer->Add(fhMassPi0NLocMax2[i][j]) ;
968 fhMassEtaNLocMax2[i][j] = new TH2F(Form("hMassEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
969 Form("Mass vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 2",
970 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
971 nptbins,ptmin,ptmax,mbins,mmin,mmax);
972 fhMassEtaNLocMax2[i][j] ->SetYTitle("Mass (GeV/c^{2})");
973 fhMassEtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
974 outputContainer->Add(fhMassEtaNLocMax2[i][j]) ;
976 fhMassConNLocMax2[i][j] = new TH2F(Form("hMassConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
977 Form("Mass vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 2",
978 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
979 nptbins,ptmin,ptmax,mbins,mmin,mmax);
980 fhMassConNLocMax2[i][j] ->SetYTitle("Mass (GeV/c^{2})");
981 fhMassConNLocMax2[i][j] ->SetXTitle("E (GeV)");
982 outputContainer->Add(fhMassConNLocMax2[i][j]) ;
984 fhMassPi0NLocMaxN[i][j] = new TH2F(Form("hMassPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
985 Form("Mass vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max > 2",
986 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
987 nptbins,ptmin,ptmax,mbins,mmin,mmax);
988 fhMassPi0NLocMaxN[i][j] ->SetYTitle("Mass (GeV/c^{2})");
989 fhMassPi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
990 outputContainer->Add(fhMassPi0NLocMaxN[i][j]) ;
992 fhMassEtaNLocMaxN[i][j] = new TH2F(Form("hMassEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
993 Form("Mass vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max > 2",
994 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
995 nptbins,ptmin,ptmax,mbins,mmin,mmax);
996 fhMassEtaNLocMaxN[i][j] ->SetYTitle("Mass (GeV/c^{2})");
997 fhMassEtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
998 outputContainer->Add(fhMassEtaNLocMaxN[i][j]) ;
1000 fhMassConNLocMaxN[i][j] = new TH2F(Form("hMassConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
1001 Form("Mass vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2",
1002 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
1003 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1004 fhMassConNLocMaxN[i][j] ->SetYTitle("Mass (GeV/c^{2})");
1005 fhMassConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
1006 outputContainer->Add(fhMassConNLocMaxN[i][j]) ;
1009 fhAsyPi0NLocMax1[i][j] = new TH2F(Form("hAsyPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
1010 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max = 1",
1011 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
1012 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1013 fhAsyPi0NLocMax1[i][j] ->SetYTitle("Asymmetry");
1014 fhAsyPi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
1015 outputContainer->Add(fhAsyPi0NLocMax1[i][j]) ;
1017 fhAsyEtaNLocMax1[i][j] = new TH2F(Form("hAsyEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
1018 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 1",
1019 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
1020 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1021 fhAsyEtaNLocMax1[i][j] ->SetYTitle("Asymmetry");
1022 fhAsyEtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
1023 outputContainer->Add(fhAsyEtaNLocMax1[i][j]) ;
1025 fhAsyConNLocMax1[i][j] = new TH2F(Form("hAsyConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
1026 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 1",
1027 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
1028 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1029 fhAsyConNLocMax1[i][j] ->SetYTitle("Asymmetry");
1030 fhAsyConNLocMax1[i][j] ->SetXTitle("E (GeV)");
1031 outputContainer->Add(fhAsyConNLocMax1[i][j]) ;
1033 fhAsyPi0NLocMax2[i][j] = new TH2F(Form("hAsyPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
1034 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max = 2",
1035 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
1036 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1037 fhAsyPi0NLocMax2[i][j] ->SetYTitle("Asymmetry");
1038 fhAsyPi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
1039 outputContainer->Add(fhAsyPi0NLocMax2[i][j]) ;
1041 fhAsyEtaNLocMax2[i][j] = new TH2F(Form("hAsyEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
1042 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 2",
1043 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
1044 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1045 fhAsyEtaNLocMax2[i][j] ->SetYTitle("Asymmetry");
1046 fhAsyEtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
1047 outputContainer->Add(fhAsyEtaNLocMax2[i][j]) ;
1049 fhAsyConNLocMax2[i][j] = new TH2F(Form("hAsyConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
1050 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max = 2",
1051 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
1052 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1053 fhAsyConNLocMax2[i][j] ->SetYTitle("Asymmetry");
1054 fhAsyConNLocMax2[i][j] ->SetXTitle("E (GeV)");
1055 outputContainer->Add(fhAsyConNLocMax2[i][j]) ;
1057 fhAsyPi0NLocMaxN[i][j] = new TH2F(Form("hAsyPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
1058 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] GeV/c^{2} %s, for N Local max > 2",
1059 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
1060 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1061 fhAsyPi0NLocMaxN[i][j] ->SetYTitle("Asymmetry");
1062 fhAsyPi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
1063 outputContainer->Add(fhAsyPi0NLocMaxN[i][j]) ;
1065 fhAsyEtaNLocMaxN[i][j] = new TH2F(Form("hAsyEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
1066 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] GeV/c^{2}, %s, for N Local max > 2",
1067 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
1068 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1069 fhAsyEtaNLocMaxN[i][j] ->SetYTitle("Asymmetry");
1070 fhAsyEtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
1071 outputContainer->Add(fhAsyEtaNLocMaxN[i][j]) ;
1073 fhAsyConNLocMaxN[i][j] = new TH2F(Form("hAsyConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
1074 Form("Asymmetry vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2",
1075 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
1076 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1077 fhAsyConNLocMaxN[i][j] ->SetYTitle("Asymmetry");
1078 fhAsyConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
1079 outputContainer->Add(fhAsyConNLocMaxN[i][j]) ;
1081 } // matched, not matched
1085 for(Int_t j = 0; j < 4; j++)
1088 fhMassSplitEFractionNLocMax1Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax1%sEbin%d",pname[i].Data(),j),
1089 Form("Invariant mass of 2 highest energy cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
1090 120,0,1.2,mbins,mmin,mmax);
1091 fhMassSplitEFractionNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
1092 fhMassSplitEFractionNLocMax1Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
1093 outputContainer->Add(fhMassSplitEFractionNLocMax1Ebin[i][j]) ;
1095 fhMassSplitEFractionNLocMax2Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax2%sEbin%d",pname[i].Data(),j),
1096 Form("Invariant mass of 2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
1097 120,0,1.2,mbins,mmin,mmax);
1098 fhMassSplitEFractionNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
1099 fhMassSplitEFractionNLocMax2Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
1100 outputContainer->Add(fhMassSplitEFractionNLocMax2Ebin[i][j]) ;
1102 fhMassSplitEFractionNLocMaxNEbin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMaxN%sEbin%d",pname[i].Data(),j),
1103 Form("Invariant mass of N>2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
1104 120,0,1.2,mbins,mmin,mmax);
1105 fhMassSplitEFractionNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
1106 fhMassSplitEFractionNLocMaxNEbin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
1107 outputContainer->Add(fhMassSplitEFractionNLocMaxNEbin[i][j]) ;
1109 if(i>0 && fFillMCFractionHisto) // skip first entry in array, general case not filled
1111 fhMCGenFracNLocMaxEbin[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%d",pname[i].Data(),j),
1112 Form("NLM vs E, %s, E bin %d",ptype[i].Data(),j),
1113 200,0,2,nMaxBins,0,nMaxBins);
1114 fhMCGenFracNLocMaxEbin[i][j]->SetYTitle("NLM");
1115 fhMCGenFracNLocMaxEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
1116 outputContainer->Add(fhMCGenFracNLocMaxEbin[i][j]) ;
1118 fhMCGenFracNLocMaxEbinMatched[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%dMatched",pname[i].Data(),j),
1119 Form("NLM vs E, %s, E bin %d, matched to a track",ptype[i].Data(),j),
1120 200,0,2,nMaxBins,0,nMaxBins);
1121 fhMCGenFracNLocMaxEbinMatched[i][j]->SetYTitle("NLM");
1122 fhMCGenFracNLocMaxEbinMatched[i][j]->SetXTitle("E_{gen} / E_{reco}");
1123 outputContainer->Add(fhMCGenFracNLocMaxEbinMatched[i][j]) ;
1125 fhMassMCGenFracNLocMax1Ebin[i][j] = new TH2F(Form("hMassMCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
1126 Form("Invariant mass of 2 highest energy cells vs E, %s, E bin %d",ptype[i].Data(),j),
1127 200,0,2,mbins,mmin,mmax);
1128 fhMassMCGenFracNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
1129 fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
1130 outputContainer->Add(fhMassMCGenFracNLocMax1Ebin[i][j]) ;
1132 fhMassMCGenFracNLocMax2Ebin[i][j] = new TH2F(Form("hMassMCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
1133 Form("Invariant mass of 2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
1134 200,0,2,mbins,mmin,mmax);
1135 fhMassMCGenFracNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
1136 fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
1137 outputContainer->Add(fhMassMCGenFracNLocMax2Ebin[i][j]) ;
1139 fhMassMCGenFracNLocMaxNEbin[i][j] = new TH2F(Form("hMassMCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
1140 Form("Invariant mass of N>2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
1141 200,0,2,mbins,mmin,mmax);
1142 fhMassMCGenFracNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
1143 fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
1144 outputContainer->Add(fhMassMCGenFracNLocMaxNEbin[i][j]) ;
1146 fhM02MCGenFracNLocMax1Ebin[i][j] = new TH2F(Form("hM02MCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
1147 Form("#lambda_{0}^{2} vs E for N max = 1 %s, E bin %d",ptype[i].Data(), j),
1148 200,0,2,ssbins,ssmin,ssmax);
1149 fhM02MCGenFracNLocMax1Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}");
1150 fhM02MCGenFracNLocMax1Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
1151 outputContainer->Add(fhM02MCGenFracNLocMax1Ebin[i][j]) ;
1153 fhM02MCGenFracNLocMax2Ebin[i][j] = new TH2F(Form("hM02MCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
1154 Form("#lambda_{0}^{2} vs E for N max = 2 %s, E bin %d",ptype[i].Data(),j),
1155 200,0,2,ssbins,ssmin,ssmax);
1156 fhM02MCGenFracNLocMax2Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}");
1157 fhM02MCGenFracNLocMax2Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
1158 outputContainer->Add(fhM02MCGenFracNLocMax2Ebin[i][j]) ;
1160 fhM02MCGenFracNLocMaxNEbin[i][j] = new TH2F(Form("hM02MCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
1161 Form("#lambda_{0}^{2} vs E for N max > 2 %s, E bin %d",ptype[i].Data(),j),
1162 200,0,2,ssbins,ssmin,ssmax);
1163 fhM02MCGenFracNLocMaxNEbin[i][j] ->SetYTitle("#lambda_{0}^{2}");
1164 fhM02MCGenFracNLocMaxNEbin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
1165 outputContainer->Add(fhM02MCGenFracNLocMaxNEbin[i][j]) ;
1169 } // MC particle list
1171 // E vs Event plane angle
1173 fhEventPlanePi0NLocMax1 = new TH2F("hEventPlanePi0NLocMax1","E vs Event Plane Angle, selected pi0 cluster with NLM=1",
1174 nptbins,ptmin,ptmax,100,0,TMath::Pi());
1175 fhEventPlanePi0NLocMax1->SetYTitle("Event Plane Angle (rad)");
1176 fhEventPlanePi0NLocMax1->SetXTitle("E (GeV)");
1177 outputContainer->Add(fhEventPlanePi0NLocMax1) ;
1179 fhEventPlanePi0NLocMax2 = new TH2F("hEventPlanePi0NLocMax2","E vs Event Plane Angle, selected pi0 cluster with NLM=2",
1180 nptbins,ptmin,ptmax,100,0,TMath::Pi());
1181 fhEventPlanePi0NLocMax2->SetYTitle("Event Plane Angle (rad)");
1182 fhEventPlanePi0NLocMax2->SetXTitle("E (GeV)");
1183 outputContainer->Add(fhEventPlanePi0NLocMax2) ;
1185 fhEventPlanePi0NLocMaxN = new TH2F("hEventPlanePi0NLocMaxN","E vs Event Plane Angle, selected pi0 cluster with NLM>1",
1186 nptbins,ptmin,ptmax,100,0,TMath::Pi());
1187 fhEventPlanePi0NLocMaxN->SetYTitle("Event Plane Angle (rad)");
1188 fhEventPlanePi0NLocMaxN->SetXTitle("E (GeV)");
1189 outputContainer->Add(fhEventPlanePi0NLocMaxN) ;
1191 fhEventPlaneEtaNLocMax1 = new TH2F("hEventPlaneEtaNLocMax1","E vs Event Plane Angle, selected pi0 cluster with NLM=1",
1192 nptbins,ptmin,ptmax,100,0,TMath::Pi());
1193 fhEventPlaneEtaNLocMax1->SetYTitle("Event Plane Angle (rad)");
1194 fhEventPlaneEtaNLocMax1->SetXTitle("E (GeV)");
1195 outputContainer->Add(fhEventPlaneEtaNLocMax1) ;
1197 fhEventPlaneEtaNLocMax2 = new TH2F("hEventPlaneEtaNLocMax2","E vs Event Plane Angle, selected pi0 cluster with NLM=2",
1198 nptbins,ptmin,ptmax,100,0,TMath::Pi());
1199 fhEventPlaneEtaNLocMax2->SetYTitle("Event Plane Angle (rad)");
1200 fhEventPlaneEtaNLocMax2->SetXTitle("E (GeV)");
1201 outputContainer->Add(fhEventPlaneEtaNLocMax2) ;
1203 fhEventPlaneEtaNLocMaxN = new TH2F("hEventPlaneEtaNLocMaxN","E vs Event Plane Angle, selected pi0 cluster with NLM>1",
1204 nptbins,ptmin,ptmax,100,0,TMath::Pi());
1205 fhEventPlaneEtaNLocMaxN->SetYTitle("Event Plane Angle (rad)");
1206 fhEventPlaneEtaNLocMaxN->SetXTitle("E (GeV)");
1207 outputContainer->Add(fhEventPlaneEtaNLocMaxN) ;
1211 for(Int_t i = 0; i < 4; i++)
1213 fhMassM02NLocMax1Ebin[i] = new TH2F(Form("hMassM02NLocMax1Ebin%d",i),
1214 Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
1215 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1216 fhMassM02NLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1217 fhMassM02NLocMax1Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1218 outputContainer->Add(fhMassM02NLocMax1Ebin[i]) ;
1220 fhMassM02NLocMax2Ebin[i] = new TH2F(Form("hMassM02NLocMax2Ebin%d",i),
1221 Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
1222 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1223 fhMassM02NLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1224 fhMassM02NLocMax2Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1225 outputContainer->Add(fhMassM02NLocMax2Ebin[i]) ;
1227 fhMassM02NLocMaxNEbin[i] = new TH2F(Form("hMassM02NLocMaxNEbin%d",i),
1228 Form("Invariant mass of split clusters vs vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
1229 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1230 fhMassM02NLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1231 fhMassM02NLocMaxNEbin[i]->SetXTitle("#lambda_{0}^{2}");
1232 outputContainer->Add(fhMassM02NLocMaxNEbin[i]) ;
1235 fhMassAsyNLocMax1Ebin[i] = new TH2F(Form("hMassAsyNLocMax1Ebin%d",i),
1236 Form("Invariant mass of split clusters vs split asymmetry, NLM=1, E bin %d",i),
1237 200,-1,1,mbins,mmin,mmax);
1238 fhMassAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1239 fhMassAsyNLocMax1Ebin[i]->SetXTitle("asymmetry");
1240 outputContainer->Add(fhMassAsyNLocMax1Ebin[i]) ;
1242 fhMassAsyNLocMax2Ebin[i] = new TH2F(Form("hMassAsyNLocMax2Ebin%d",i),
1243 Form("Invariant mass of split clusters vs split asymmetry, NLM=2, E bin %d",i),
1244 200,-1,1,mbins,mmin,mmax);
1245 fhMassAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1246 fhMassAsyNLocMax2Ebin[i]->SetXTitle("asymmetry");
1247 outputContainer->Add(fhMassAsyNLocMax2Ebin[i]) ;
1249 fhMassAsyNLocMaxNEbin[i] = new TH2F(Form("hMassAsyNLocMaxNEbin%d",i),
1250 Form("Invariant mass of split clusters vs split asymmetry, NLM>2, E bin %d",i),
1251 200,-1,1,mbins,mmin,mmax);
1252 fhMassAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1253 fhMassAsyNLocMaxNEbin[i]->SetXTitle("asymmetry");
1254 outputContainer->Add(fhMassAsyNLocMaxNEbin[i]) ;
1259 fhMCAsymM02NLocMax1MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax1MCPi0Ebin%d",i),
1260 Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
1261 ssbins,ssmin,ssmax,100,0,1);
1262 fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
1263 fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1264 outputContainer->Add(fhMCAsymM02NLocMax1MCPi0Ebin[i]) ;
1266 fhMCAsymM02NLocMax2MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax2MCPi0Ebin%d",i),
1267 Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
1268 ssbins,ssmin,ssmax,100,0,1);
1269 fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
1270 fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1271 outputContainer->Add(fhMCAsymM02NLocMax2MCPi0Ebin[i]) ;
1273 fhMCAsymM02NLocMaxNMCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMaxNMCPi0Ebin%d",i),
1274 Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
1275 ssbins,ssmin,ssmax,100,0,1);
1276 fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetYTitle("Decay asymmetry");
1277 fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1278 outputContainer->Add(fhMCAsymM02NLocMaxNMCPi0Ebin[i]) ;
1281 fhAsyMCGenRecoNLocMax1EbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMax1Ebin%dPi0",i),
1282 Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=1, E bin %d",i),
1284 fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1285 fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetXTitle("asymmetry");
1286 outputContainer->Add(fhAsyMCGenRecoNLocMax1EbinPi0[i]) ;
1288 fhAsyMCGenRecoNLocMax2EbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMax2Ebin%dPi0",i),
1289 Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=2, E bin %d",i),
1291 fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1292 fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetXTitle("asymmetry");
1293 outputContainer->Add(fhAsyMCGenRecoNLocMax2EbinPi0[i]) ;
1295 fhAsyMCGenRecoNLocMaxNEbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMaxNEbin%dPi0",i),
1296 Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM>2, E bin %d",i),
1298 fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1299 fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetXTitle("asymmetry");
1300 outputContainer->Add(fhAsyMCGenRecoNLocMaxNEbinPi0[i]) ;
1303 if(fFillSSExtraHisto)
1305 fhMassDispEtaNLocMax1Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax1Ebin%d",i),
1306 Form("Invariant mass of 2 highest energy cells #sigma_{#eta #eta}^{2}, E bin %d",i),
1307 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1308 fhMassDispEtaNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1309 fhMassDispEtaNLocMax1Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
1310 outputContainer->Add(fhMassDispEtaNLocMax1Ebin[i]) ;
1312 fhMassDispEtaNLocMax2Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax2Ebin%d",i),
1313 Form("Invariant mass of 2 local maxima cells #sigma_{#eta #eta}^{2}, E bin %d",i),
1314 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1315 fhMassDispEtaNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1316 fhMassDispEtaNLocMax2Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
1317 outputContainer->Add(fhMassDispEtaNLocMax2Ebin[i]) ;
1319 fhMassDispEtaNLocMaxNEbin[i] = new TH2F(Form("hMassDispEtaNLocMaxNEbin%d",i),
1320 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#eta #eta}^{2}, E bin %d",i),
1321 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1322 fhMassDispEtaNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1323 fhMassDispEtaNLocMaxNEbin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
1324 outputContainer->Add(fhMassDispEtaNLocMaxNEbin[i]) ;
1326 fhMassDispPhiNLocMax1Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax1Ebin%d",i),
1327 Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E bin %d",i),
1328 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1329 fhMassDispPhiNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1330 fhMassDispPhiNLocMax1Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
1331 outputContainer->Add(fhMassDispPhiNLocMax1Ebin[i]) ;
1333 fhMassDispPhiNLocMax2Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax2Ebin%d",i),
1334 Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E bin %d",i),
1335 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1336 fhMassDispPhiNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1337 fhMassDispPhiNLocMax2Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
1338 outputContainer->Add(fhMassDispPhiNLocMax2Ebin[i]) ;
1340 fhMassDispPhiNLocMaxNEbin[i] = new TH2F(Form("hMassDispPhiNLocMaxNEbin%d",i),
1341 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, E bin %d",i),
1342 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1343 fhMassDispPhiNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1344 fhMassDispPhiNLocMaxNEbin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
1345 outputContainer->Add(fhMassDispPhiNLocMaxNEbin[i]) ;
1347 fhMassDispAsyNLocMax1Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax1Ebin%d",i),
1348 Form("Invariant mass of 2 highest energy cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
1349 200,-1,1,mbins,mmin,mmax);
1350 fhMassDispAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1351 fhMassDispAsyNLocMax1Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
1352 outputContainer->Add(fhMassDispAsyNLocMax1Ebin[i]) ;
1354 fhMassDispAsyNLocMax2Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax2Ebin%d",i),
1355 Form("Invariant mass of 2 local maxima cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
1356 200,-1,1,mbins,mmin,mmax);
1357 fhMassDispAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1358 fhMassDispAsyNLocMax2Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
1359 outputContainer->Add(fhMassDispAsyNLocMax2Ebin[i]) ;
1361 fhMassDispAsyNLocMaxNEbin[i] = new TH2F(Form("hMassDispAsyNLocMaxNEbin%d",i),
1362 Form("Invariant mass of N>2 local maxima cells vs A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
1363 200,-1,1,mbins,mmin,mmax);
1364 fhMassDispAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1365 fhMassDispAsyNLocMaxNEbin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
1366 outputContainer->Add(fhMassDispAsyNLocMaxNEbin[i]) ;
1371 fhMassSplitECutNLocMax1 = new TH2F("hMassSplitECutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, (E1+E2)/E cut",
1372 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1373 fhMassSplitECutNLocMax1->SetYTitle("M (GeV/c^{2})");
1374 fhMassSplitECutNLocMax1->SetXTitle("E (GeV)");
1375 outputContainer->Add(fhMassSplitECutNLocMax1) ;
1377 fhMassSplitECutNLocMax2 = new TH2F("hMassSplitECutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, (E1+E2)/E cut",
1378 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1379 fhMassSplitECutNLocMax2->SetYTitle("M (GeV/c^{2})");
1380 fhMassSplitECutNLocMax2->SetXTitle("E (GeV)");
1381 outputContainer->Add(fhMassSplitECutNLocMax2) ;
1383 fhMassSplitECutNLocMaxN = new TH2F("hMassSplitECutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, (E1+E2)/E cut",
1384 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1385 fhMassSplitECutNLocMaxN->SetYTitle("M (GeV/c^{2})");
1386 fhMassSplitECutNLocMaxN->SetXTitle("E (GeV)");
1387 outputContainer->Add(fhMassSplitECutNLocMaxN) ;
1389 fhMassM02CutNLocMax1 = new TH2F("hMassM02CutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, M02 cut",
1390 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1391 fhMassM02CutNLocMax1->SetYTitle("M (GeV/c^{2})");
1392 fhMassM02CutNLocMax1->SetXTitle("E (GeV)");
1393 outputContainer->Add(fhMassM02CutNLocMax1) ;
1395 fhMassM02CutNLocMax2 = new TH2F("hMassM02CutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, M02 cut",
1396 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1397 fhMassM02CutNLocMax2->SetYTitle("M (GeV/c^{2})");
1398 fhMassM02CutNLocMax2->SetXTitle("E (GeV)");
1399 outputContainer->Add(fhMassM02CutNLocMax2) ;
1401 fhMassM02CutNLocMaxN = new TH2F("hMassM02CutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, M02 cut",
1402 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1403 fhMassM02CutNLocMaxN->SetYTitle("M (GeV/c^{2})");
1404 fhMassM02CutNLocMaxN->SetXTitle("E (GeV)");
1405 outputContainer->Add(fhMassM02CutNLocMaxN) ;
1407 fhAsymM02CutNLocMax1 = new TH2F("hAsymM02CutNLocMax1","Asymmetry of NLM=1 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1);
1408 fhAsymM02CutNLocMax1->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
1409 fhAsymM02CutNLocMax1->SetXTitle("E (GeV)");
1410 outputContainer->Add(fhAsymM02CutNLocMax1) ;
1412 fhAsymM02CutNLocMax2 = new TH2F("hAsymM02CutNLocMax2","Asymmetry of NLM=2 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1);
1413 fhAsymM02CutNLocMax2->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
1414 fhAsymM02CutNLocMax2->SetXTitle("E (GeV)");
1415 outputContainer->Add(fhAsymM02CutNLocMax2) ;
1417 fhAsymM02CutNLocMaxN = new TH2F("hAsymM02CutNLocMaxN","Asymmetry of NLM>2 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1);
1418 fhAsymM02CutNLocMaxN->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
1419 fhAsymM02CutNLocMaxN->SetXTitle("E (GeV)");
1420 outputContainer->Add(fhAsymM02CutNLocMaxN) ;
1422 if(IsDataMC() && fFillMCFractionHisto)
1424 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMax1MCPi0",
1425 "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 1 MC Pi0, after M02 and Asym cut",
1426 nptbins,ptmin,ptmax,200,0,2);
1427 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
1428 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 ->SetXTitle("E (GeV)");
1429 outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMax1MCPi0) ;
1431 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMax2MCPi0",
1432 "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 2 MC Pi0, after M02 and Asym cut",
1433 nptbins,ptmin,ptmax,200,0,2);
1434 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
1435 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 ->SetXTitle("E (GeV)");
1436 outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMax2MCPi0) ;
1439 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMaxNMCPi0",
1440 "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max > 2 MC Pi0, after M02 and Asym cut",
1441 nptbins,ptmin,ptmax,200,0,2);
1442 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
1443 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 ->SetXTitle("E (GeV)");
1444 outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0) ;
1446 fhMCGenFracAfterCutsNLocMax1MCPi0 = new TH2F("hMCGenFracAfterCutsNLocMax1MCPi0",
1447 "E_{gen} / E_{reco} vs E_{reco} for N max = 1 MC Pi0, after M02 and Asym cut",
1448 nptbins,ptmin,ptmax,200,0,2);
1449 fhMCGenFracAfterCutsNLocMax1MCPi0 ->SetYTitle("E_{gen} / E_{reco}");
1450 fhMCGenFracAfterCutsNLocMax1MCPi0 ->SetXTitle("E (GeV)");
1451 outputContainer->Add(fhMCGenFracAfterCutsNLocMax1MCPi0) ;
1453 fhMCGenFracAfterCutsNLocMax2MCPi0 = new TH2F("hMCGenFracAfterCutsNLocMax2MCPi0",
1454 " E_{gen} / E_{reco} vs E_{reco} for N max = 2 MC Pi0, after M02 and Asym cut",
1455 nptbins,ptmin,ptmax,200,0,2);
1456 fhMCGenFracAfterCutsNLocMax2MCPi0 ->SetYTitle("E_{gen} / E_{reco}");
1457 fhMCGenFracAfterCutsNLocMax2MCPi0 ->SetXTitle("E (GeV)");
1458 outputContainer->Add(fhMCGenFracAfterCutsNLocMax2MCPi0) ;
1461 fhMCGenFracAfterCutsNLocMaxNMCPi0 = new TH2F("hMCGenFracAfterCutsNLocMaxNMCPi0",
1462 " E_{gen} / E_{reco} vs E_{reco} for N max > 2 MC Pi0, after M02 and Asym cut",
1463 nptbins,ptmin,ptmax,200,0,2);
1464 fhMCGenFracAfterCutsNLocMaxNMCPi0 ->SetYTitle("E_{gen} / E_{reco}");
1465 fhMCGenFracAfterCutsNLocMaxNMCPi0 ->SetXTitle("E (GeV)");
1466 outputContainer->Add(fhMCGenFracAfterCutsNLocMaxNMCPi0) ;
1470 if(fFillTMResidualHisto)
1472 for(Int_t i = 0; i < n; i++)
1475 fhTrackMatchedDEtaNLocMax1[i] = new TH2F
1476 (Form("hTrackMatchedDEtaNLocMax1%s",pname[i].Data()),
1477 Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
1478 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1479 fhTrackMatchedDEtaNLocMax1[i]->SetYTitle("d#eta");
1480 fhTrackMatchedDEtaNLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
1482 fhTrackMatchedDPhiNLocMax1[i] = new TH2F
1483 (Form("hTrackMatchedDPhiNLocMax1%s",pname[i].Data()),
1484 Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
1485 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1486 fhTrackMatchedDPhiNLocMax1[i]->SetYTitle("d#phi (rad)");
1487 fhTrackMatchedDPhiNLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
1489 outputContainer->Add(fhTrackMatchedDEtaNLocMax1[i]) ;
1490 outputContainer->Add(fhTrackMatchedDPhiNLocMax1[i]) ;
1492 fhTrackMatchedDEtaNLocMax2[i] = new TH2F
1493 (Form("hTrackMatchedDEtaNLocMax2%s",pname[i].Data()),
1494 Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
1495 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1496 fhTrackMatchedDEtaNLocMax2[i]->SetYTitle("d#eta");
1497 fhTrackMatchedDEtaNLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
1499 fhTrackMatchedDPhiNLocMax2[i] = new TH2F
1500 (Form("hTrackMatchedDPhiNLocMax2%s",pname[i].Data()),
1501 Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
1502 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1503 fhTrackMatchedDPhiNLocMax2[i]->SetYTitle("d#phi (rad)");
1504 fhTrackMatchedDPhiNLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
1506 outputContainer->Add(fhTrackMatchedDEtaNLocMax2[i]) ;
1507 outputContainer->Add(fhTrackMatchedDPhiNLocMax2[i]) ;
1509 fhTrackMatchedDEtaNLocMaxN[i] = new TH2F
1510 (Form("hTrackMatchedDEtaNLocMaxN%s",pname[i].Data()),
1511 Form("d#eta of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
1512 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1513 fhTrackMatchedDEtaNLocMaxN[i]->SetYTitle("d#eta");
1514 fhTrackMatchedDEtaNLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
1516 fhTrackMatchedDPhiNLocMaxN[i] = new TH2F
1517 (Form("hTrackMatchedDPhiNLocMaxN%s",pname[i].Data()),
1518 Form("d#phi of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
1519 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1520 fhTrackMatchedDPhiNLocMaxN[i]->SetYTitle("d#phi (rad)");
1521 fhTrackMatchedDPhiNLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
1523 outputContainer->Add(fhTrackMatchedDEtaNLocMaxN[i]) ;
1524 outputContainer->Add(fhTrackMatchedDPhiNLocMaxN[i]) ;
1530 for(Int_t j = 0; j < 2; j++)
1533 fhAnglePairNLocMax1[j] = new TH2F(Form("hAnglePairNLocMax1%s",sMatched[j].Data()),
1534 Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()),
1535 nptbins,ptmin,ptmax,200,0,0.2);
1536 fhAnglePairNLocMax1[j]->SetYTitle("#alpha (rad)");
1537 fhAnglePairNLocMax1[j]->SetXTitle("E (GeV)");
1538 outputContainer->Add(fhAnglePairNLocMax1[j]) ;
1540 fhAnglePairNLocMax2[j] = new TH2F(Form("hAnglePairNLocMax2%s",sMatched[j].Data()),
1541 Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()),
1542 nptbins,ptmin,ptmax,200,0,0.2);
1543 fhAnglePairNLocMax2[j]->SetYTitle("#alpha (rad)");
1544 fhAnglePairNLocMax2[j]->SetXTitle("E (GeV)");
1545 outputContainer->Add(fhAnglePairNLocMax2[j]) ;
1547 fhAnglePairNLocMaxN[j] = new TH2F(Form("hAnglePairNLocMaxN%s",sMatched[j].Data()),
1548 Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()),
1549 nptbins,ptmin,ptmax,200,0,0.2);
1550 fhAnglePairNLocMaxN[j]->SetYTitle("#alpha (rad)");
1551 fhAnglePairNLocMaxN[j]->SetXTitle("E (GeV)");
1552 outputContainer->Add(fhAnglePairNLocMaxN[j]) ;
1554 fhAnglePairMassNLocMax1[j] = new TH2F(Form("hAnglePairMassNLocMax1%s",sMatched[j].Data()),
1555 Form("Opening angle of 2 highest energy cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
1556 mbins,mmin,mmax,200,0,0.2);
1557 fhAnglePairMassNLocMax1[j]->SetXTitle("M (GeV/c^{2})");
1558 fhAnglePairMassNLocMax1[j]->SetYTitle("#alpha (rad)");
1559 outputContainer->Add(fhAnglePairMassNLocMax1[j]) ;
1561 fhAnglePairMassNLocMax2[j] = new TH2F(Form("hAnglePairMassNLocMax2%s",sMatched[j].Data()),
1562 Form("Opening angle of 2 local maxima cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
1563 mbins,mmin,mmax,200,0,0.2);
1564 fhAnglePairMassNLocMax2[j]->SetXTitle("M (GeV/c^{2})");
1565 fhAnglePairMassNLocMax2[j]->SetYTitle("#alpha (rad)");
1566 outputContainer->Add(fhAnglePairMassNLocMax2[j]) ;
1568 fhAnglePairMassNLocMaxN[j] = new TH2F(Form("hAnglePairMassNLocMaxN%s",sMatched[j].Data()),
1569 Form("Opening angle of N>2 local maxima cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
1570 mbins,mmin,mmax,200,0,0.2);
1571 fhAnglePairMassNLocMaxN[j]->SetXTitle("M (GeV/c^{2})");
1572 fhAnglePairMassNLocMaxN[j]->SetYTitle("#alpha (rad)");
1573 outputContainer->Add(fhAnglePairMassNLocMaxN[j]) ;
1578 for(Int_t j = 0; j < 2; j++)
1580 fhSplitEFractionvsAsyNLocMax1[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMax1%s",sMatched[j].Data()),
1581 Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max = 1, E>12, %s",sMatched[j].Data()),
1582 100,-1,1,120,0,1.2);
1583 fhSplitEFractionvsAsyNLocMax1[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
1584 fhSplitEFractionvsAsyNLocMax1[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
1585 outputContainer->Add(fhSplitEFractionvsAsyNLocMax1[j]) ;
1587 fhSplitEFractionvsAsyNLocMax2[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMax2%s",sMatched[j].Data()),
1588 Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max = 2,E>12, %s",sMatched[j].Data()),
1589 100,-1,1,120,0,1.2);
1590 fhSplitEFractionvsAsyNLocMax2[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
1591 fhSplitEFractionvsAsyNLocMax2[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
1592 outputContainer->Add(fhSplitEFractionvsAsyNLocMax2[j]) ;
1594 fhSplitEFractionvsAsyNLocMaxN[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMaxN%s",sMatched[j].Data()),
1595 Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max > 2, E>12, %s",sMatched[j].Data()),
1596 100,-1,1,120,0,1.2);
1597 fhSplitEFractionvsAsyNLocMaxN[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
1598 fhSplitEFractionvsAsyNLocMaxN[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
1599 outputContainer->Add(fhSplitEFractionvsAsyNLocMaxN[j]) ;
1603 fhClusterEtaPhiNLocMax1 = new TH2F
1604 ("hClusterEtaPhiNLocMax1","Neutral Clusters with E > 8 GeV, NLM = 1: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1605 fhClusterEtaPhiNLocMax1->SetYTitle("#phi (rad)");
1606 fhClusterEtaPhiNLocMax1->SetXTitle("#eta");
1607 outputContainer->Add(fhClusterEtaPhiNLocMax1) ;
1609 fhClusterEtaPhiNLocMax2 = new TH2F
1610 ("hClusterEtaPhiNLocMax2","Neutral Clusters with E > 8 GeV, NLM = 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1611 fhClusterEtaPhiNLocMax2->SetYTitle("#phi (rad)");
1612 fhClusterEtaPhiNLocMax2->SetXTitle("#eta");
1613 outputContainer->Add(fhClusterEtaPhiNLocMax2) ;
1615 fhClusterEtaPhiNLocMaxN = new TH2F
1616 ("hClusterEtaPhiNLocMaxN","Neutral Clusters with E > 8 GeV, NLM > 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1617 fhClusterEtaPhiNLocMaxN->SetYTitle("#phi (rad)");
1618 fhClusterEtaPhiNLocMaxN->SetXTitle("#eta");
1619 outputContainer->Add(fhClusterEtaPhiNLocMaxN) ;
1621 fhPi0EtaPhiNLocMax1 = new TH2F
1622 ("hPi0EtaPhiNLocMax1","Selected #pi^{0}'s with E > 8 GeV, NLM = 1: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1623 fhPi0EtaPhiNLocMax1->SetYTitle("#phi (rad)");
1624 fhPi0EtaPhiNLocMax1->SetXTitle("#eta");
1625 outputContainer->Add(fhPi0EtaPhiNLocMax1) ;
1627 fhPi0EtaPhiNLocMax2 = new TH2F
1628 ("hPi0EtaPhiNLocMax2","Selected #pi^{0}'s with E > 8 GeV, NLM = 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1629 fhPi0EtaPhiNLocMax2->SetYTitle("#phi (rad)");
1630 fhPi0EtaPhiNLocMax2->SetXTitle("#eta");
1631 outputContainer->Add(fhPi0EtaPhiNLocMax2) ;
1633 fhPi0EtaPhiNLocMaxN = new TH2F
1634 ("hPi0EtaPhiNLocMaxN","Selected #pi^{0}'s with E > 8 GeV, NLM > 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1635 fhPi0EtaPhiNLocMaxN->SetYTitle("#phi (rad)");
1636 fhPi0EtaPhiNLocMaxN->SetXTitle("#eta");
1637 outputContainer->Add(fhPi0EtaPhiNLocMaxN) ;
1639 fhEtaEtaPhiNLocMax1 = new TH2F
1640 ("hEtaEtaPhiNLocMax1","Selected #eta's with E > 8 GeV, NLM = 1: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1641 fhEtaEtaPhiNLocMax1->SetYTitle("#phi (rad)");
1642 fhEtaEtaPhiNLocMax1->SetXTitle("#eta");
1643 outputContainer->Add(fhEtaEtaPhiNLocMax1) ;
1645 fhEtaEtaPhiNLocMax2 = new TH2F
1646 ("hEtaEtaPhiNLocMax2","Selected #eta's with E > 8 GeV, NLM = 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1647 fhEtaEtaPhiNLocMax2->SetYTitle("#phi (rad)");
1648 fhEtaEtaPhiNLocMax2->SetXTitle("#eta");
1649 outputContainer->Add(fhEtaEtaPhiNLocMax2) ;
1651 fhEtaEtaPhiNLocMaxN = new TH2F
1652 ("hEtaEtaPhiNLocMaxN","Selected #eta's with E > 8 GeV, NLM > 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
1653 fhEtaEtaPhiNLocMaxN->SetYTitle("#phi (rad)");
1654 fhEtaEtaPhiNLocMaxN->SetXTitle("#eta");
1655 outputContainer->Add(fhEtaEtaPhiNLocMaxN) ;
1658 if(fFillSSWeightHisto)
1660 TString snlm[] = {"1","2","N"};
1661 for(Int_t nlm = 0; nlm < 3; nlm++)
1663 fhPi0CellE[nlm] = new TH2F(Form("hPi0CellENLocMax%s",snlm[nlm].Data()),
1664 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs cell E",snlm[nlm].Data()),
1665 nptbins,ptmin,ptmax, nptbins,ptmin,ptmax);
1666 fhPi0CellE[nlm]->SetYTitle("E_{cell}");
1667 fhPi0CellE[nlm]->SetXTitle("E_{cluster}");
1668 outputContainer->Add(fhPi0CellE[nlm]) ;
1670 fhPi0CellEFrac[nlm] = new TH2F(Form("hPi0CellEFracNLocMax%s",snlm[nlm].Data()),
1671 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs cell E / cluster E",snlm[nlm].Data()),
1672 nptbins,ptmin,ptmax, 100,0,1);
1673 fhPi0CellEFrac[nlm]->SetYTitle("E_{cell} / E_{cluster}");
1674 fhPi0CellEFrac[nlm]->SetXTitle("E_{cluster}");
1675 outputContainer->Add(fhPi0CellEFrac[nlm]) ;
1677 fhPi0CellLogEFrac[nlm] = new TH2F(Form("hPi0CellLogEFracNLocMax%s",snlm[nlm].Data()),
1678 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs Log(cell E / cluster E)",snlm[nlm].Data()),
1679 nptbins,ptmin,ptmax, 100,-10,0);
1680 fhPi0CellLogEFrac[nlm]->SetYTitle("Log(E_{cell} / E_{cluster})");
1681 fhPi0CellLogEFrac[nlm]->SetXTitle("E_{cluster}");
1682 outputContainer->Add(fhPi0CellLogEFrac[nlm]) ;
1685 fhPi0CellEMaxEMax2Frac[nlm] = new TH2F(Form("hPi0CellEMaxEMax2FracNLocMax%s",snlm[nlm].Data()),
1686 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 2nd loc. max. E / 1st loc. max. E",snlm[nlm].Data()),
1687 nptbins,ptmin,ptmax, 100,0,1);
1688 fhPi0CellEMaxEMax2Frac[nlm]->SetYTitle("E_{Loc Max 2} / E_{Loc Max 1}");
1689 fhPi0CellEMaxEMax2Frac[nlm]->SetXTitle("E_{cluster}");
1690 outputContainer->Add(fhPi0CellEMaxEMax2Frac[nlm]) ;
1692 fhPi0CellEMaxClusterFrac[nlm] = new TH2F(Form("hPi0CellEMaxClusterFracNLocMax%s",snlm[nlm].Data()),
1693 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 1st loc. max. E / E cluster",snlm[nlm].Data()),
1694 nptbins,ptmin,ptmax, 100,0,1);
1695 fhPi0CellEMaxClusterFrac[nlm]->SetYTitle("E_{Loc Max 1} / E_{cluster}");
1696 fhPi0CellEMaxClusterFrac[nlm]->SetXTitle("E_{cluster}");
1697 outputContainer->Add(fhPi0CellEMaxClusterFrac[nlm]) ;
1699 fhPi0CellEMax2ClusterFrac[nlm] = new TH2F(Form("hPi0CellEMax2ClusterFracNLocMax%s",snlm[nlm].Data()),
1700 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 2nd loc. max. E / E cluster",snlm[nlm].Data()),
1701 nptbins,ptmin,ptmax, 100,0,1);
1702 fhPi0CellEMax2ClusterFrac[nlm]->SetYTitle("E_{Loc Max 2} / E_{cluster}");
1703 fhPi0CellEMax2ClusterFrac[nlm]->SetXTitle("E_{cluster}");
1704 outputContainer->Add(fhPi0CellEMax2ClusterFrac[nlm]) ;
1706 fhPi0CellEMaxFrac[nlm] = new TH2F(Form("hPi0CellEMaxFracNLocMax%s",snlm[nlm].Data()),
1707 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 1st loc. max. E / E cell i",snlm[nlm].Data()),
1708 nptbins,ptmin,ptmax, 100,0,1);
1709 fhPi0CellEMaxFrac[nlm]->SetYTitle("E_{Loc Max 1} / E_{cell 1}");
1710 fhPi0CellEMaxFrac[nlm]->SetXTitle("E_{cluster}");
1711 outputContainer->Add(fhPi0CellEMaxFrac[nlm]) ;
1713 fhPi0CellEMax2Frac[nlm] = new TH2F(Form("hPi0CellEMax2FracNLocMax%s",snlm[nlm].Data()),
1714 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 2nd loc. max. E / E cell i",snlm[nlm].Data()),
1715 nptbins,ptmin,ptmax, 200,0,2);
1716 fhPi0CellEMax2Frac[nlm]->SetYTitle("E_{Loc Max 2} / E_{cell i}");
1717 fhPi0CellEMax2Frac[nlm]->SetXTitle("E_{cluster}");
1718 outputContainer->Add(fhPi0CellEMax2Frac[nlm]) ;
1721 for(Int_t i = 0; i < fSSWeightN; i++)
1723 fhM02WeightPi0[nlm][i] = new TH2F(Form("hM02Pi0NLocMax%s_W%d",snlm[nlm].Data(),i),
1724 Form("#lambda_{0}^{2} vs E, with W0 = %2.2f, for N Local max = %s", fSSWeight[i], snlm[nlm].Data()),
1725 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1726 fhM02WeightPi0[nlm][i] ->SetYTitle("#lambda_{0}^{2}");
1727 fhM02WeightPi0[nlm][i] ->SetXTitle("E (GeV)");
1728 outputContainer->Add(fhM02WeightPi0[nlm][i]) ;
1731 for(Int_t i = 0; i < fSSECellCutN; i++)
1733 fhM02ECellCutPi0[nlm][i] = new TH2F(Form("hM02Pi0NLocMax%s_Ecell%d",snlm[nlm].Data(),i),
1734 Form("#lambda_{0}^{2} vs E, with Ecell > %2.2f, for N Local max = %s", fSSECellCut[i], snlm[nlm].Data()),
1735 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
1736 fhM02ECellCutPi0[nlm][i] ->SetYTitle("#lambda_{0}^{2}");
1737 fhM02ECellCutPi0[nlm][i] ->SetXTitle("E (GeV)");
1738 outputContainer->Add(fhM02ECellCutPi0[nlm][i]) ;
1744 return outputContainer ;
1748 //___________________________________________
1749 void AliAnaInsideClusterInvariantMass::Init()
1753 if(fCalorimeter == "PHOS" && !GetReader()->IsPHOSSwitchedOn() && NewOutputAOD())
1755 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!\n");
1758 else if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn() && NewOutputAOD())
1760 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!\n");
1764 if( GetReader()->GetDataType() == AliCaloTrackReader::kMC )
1766 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use pure MC data!!\n");
1773 //_____________________________________________________
1774 void AliAnaInsideClusterInvariantMass::InitParameters()
1776 //Initialize the parameters of the analysis.
1777 AddToHistogramsName("AnaPi0InsideClusterInvariantMass_");
1779 fCalorimeter = "EMCAL" ;
1788 fSSWeight[0] = 4.6; fSSWeight[1] = 4.7; fSSWeight[2] = 4.8; fSSWeight[3] = 4.9; fSSWeight[4] = 5.0;
1789 fSSWeight[5] = 5.1; fSSWeight[6] = 5.2; fSSWeight[7] = 5.3; fSSWeight[8] = 5.4; fSSWeight[9] = 5.5;
1792 fSSECellCut[0] = 0.16; fSSECellCut[1] = 0.18; fSSECellCut[2] = 0.2; fSSECellCut[3] = 0.22; fSSECellCut[4] = 0.24;
1793 fSSECellCut[5] = 0.26; fSSECellCut[6] = 0.28; fSSECellCut[7] = 0.3; fSSECellCut[8] = 0.32; fSSECellCut[9] = 0.34;
1798 //__________________________________________________________________
1799 void AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
1801 //Search for pi0 in fCalorimeter with shower shape analysis
1803 TObjArray * pl = 0x0;
1804 AliVCaloCells* cells = 0x0;
1806 //Select the Calorimeter of the photon
1807 if(fCalorimeter == "PHOS")
1809 pl = GetPHOSClusters();
1810 cells = GetPHOSCells();
1812 else if (fCalorimeter == "EMCAL")
1814 pl = GetEMCALClusters();
1815 cells = GetEMCALCells();
1818 const Float_t ecut = 8.; // Fixed cut for some histograms
1822 Info("MakeAnalysisFillHistograms","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data());
1826 if(fCalorimeter == "PHOS") return; // Not implemented for PHOS yet
1828 for(Int_t icluster = 0; icluster < pl->GetEntriesFast(); icluster++)
1830 AliVCluster * cluster = (AliVCluster*) (pl->At(icluster));
1832 // Study clusters with large shape parameter
1833 Float_t en = cluster->E();
1834 Float_t l0 = cluster->GetM02();
1835 Int_t nc = cluster->GetNCells();
1836 Float_t bd = cluster->GetDistanceToBadChannel() ;
1839 //If too small or big E or low number of cells, or close to a bad channel skip it
1840 if( en < GetMinEnergy() || en > GetMaxEnergy() || nc < fMinNCells || bd < fMinBadDist) continue ;
1843 cluster->GetMomentum(lv, GetVertex(0));
1844 Float_t eta = lv.Eta();
1845 Float_t phi = lv.Phi();
1846 if(phi<0) phi=+TMath::TwoPi();
1848 //printf("en %2.2f, GetMinEnergy() %2.2f, GetMaxEnergy() %2.2f, nc %d, fMinNCells %d, bd %2.2f, fMinBadDist %2.2f\n",
1849 // en,GetMinEnergy(), GetMaxEnergy(), nc, fMinNCells, bd, fMinBadDist);
1851 // Get more Shower Shape parameters
1852 Float_t ll0 = 0., ll1 = 0.;
1853 Float_t disp= 0., dispEta = 0., dispPhi = 0.;
1854 Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
1856 GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), GetReader()->GetInputEvent()->GetEMCALCells(), cluster,
1857 ll0, ll1, disp, dispEta, dispPhi, sEta, sPhi, sEtaPhi);
1859 Float_t dispAsy = -1;
1860 if(dispEta+dispPhi >0 ) dispAsy = (dispPhi-dispEta) / (dispPhi+dispEta);
1863 Double_t mass = 0., angle = 0.;
1864 Double_t e1 = 0., e2 = 0.;
1865 Int_t absId1 = -1; Int_t absId2 = -1;
1867 Int_t pidTag = GetCaloPID()->GetIdentifiedParticleTypeFromClusterSplitting(cluster,cells,GetCaloUtils(),
1868 GetVertex(0), nMax, mass, angle,
1869 e1,e2,absId1,absId2);
1873 printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - No local maximum found! It did not pass CaloPID selection criteria \n");
1878 Float_t splitFrac = (e1+e2)/en;
1880 if(e1+e2>0) asym = (e1-e2)/(e1+e2);
1882 Bool_t matched = IsTrackMatched(cluster,GetReader()->GetInputEvent());
1884 fhNLocMax[0][matched]->Fill(en,nMax);
1887 if (nMax == 1) inlm = 0;
1888 else if(nMax == 2) inlm = 1;
1889 else if(nMax > 2 ) inlm = 2;
1893 fhM02NLocMax1[0][matched]->Fill(en,l0) ;
1894 fhSplitEFractionNLocMax1[0][matched]->Fill(en,splitFrac) ;
1897 fhSplitEFractionvsAsyNLocMax1[matched]->Fill(asym,splitFrac) ;
1898 if(!matched)fhClusterEtaPhiNLocMax1->Fill(eta,phi);
1900 if(fFillSSExtraHisto) fhNCellNLocMax1[0][matched]->Fill(en,nc) ;
1902 else if( nMax == 2 )
1904 fhM02NLocMax2[0][matched]->Fill(en,l0) ;
1905 fhSplitEFractionNLocMax2[0][matched]->Fill(en,splitFrac) ;
1908 fhSplitEFractionvsAsyNLocMax2[matched]->Fill(asym,splitFrac) ;
1909 if(!matched)fhClusterEtaPhiNLocMax2->Fill(eta,phi);
1911 if(fFillSSExtraHisto) fhNCellNLocMax2[0][matched]->Fill(en,nc) ; }
1912 else if( nMax >= 3 )
1914 fhM02NLocMaxN[0][matched]->Fill(en,l0) ;
1915 fhSplitEFractionNLocMaxN[0][matched]->Fill(en,splitFrac) ;
1918 fhSplitEFractionvsAsyNLocMaxN[matched]->Fill(asym,splitFrac) ;
1919 if(!matched)fhClusterEtaPhiNLocMaxN->Fill(eta,phi);
1921 if(fFillSSExtraHisto) fhNCellNLocMaxN[0][matched]->Fill(en,nc) ;
1923 else printf("N max smaller than 1 -> %d \n",nMax);
1926 Float_t dZ = cluster->GetTrackDz();
1927 Float_t dR = cluster->GetTrackDx();
1929 if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
1931 dR = 2000., dZ = 2000.;
1932 GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
1934 //printf("Pi0EbE: dPhi %f, dEta %f\n",dR,dZ);
1936 if(TMath::Abs(dR) < 999 && fFillTMResidualHisto)
1938 if ( nMax == 1 ) { fhTrackMatchedDEtaNLocMax1[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1[0]->Fill(en,dR); }
1939 else if( nMax == 2 ) { fhTrackMatchedDEtaNLocMax2[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2[0]->Fill(en,dR); }
1940 else if( nMax >= 3 ) { fhTrackMatchedDEtaNLocMaxN[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxN[0]->Fill(en,dR); }
1943 // Play with the MC stack if available
1944 // Check origin of the candidates
1947 Float_t asymGen = -2;
1948 Int_t mcLabel = cluster->GetLabel();
1951 Int_t tag = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(), GetReader());
1953 if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) &&
1954 !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPi0;
1955 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ) mcindex = kmcPi0Conv;
1956 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ) mcindex = kmcEta;
1957 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
1958 !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPhoton;
1959 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
1960 GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcConversion;
1961 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) mcindex = kmcElectron;
1962 else mcindex = kmcHadron;
1964 fhNLocMax[mcindex][matched]->Fill(en,nMax);
1966 if (nMax == 1 ) { fhM02NLocMax1[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax1[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax1[mcindex][matched]->Fill(en,nc) ; }
1967 else if(nMax == 2 ) { fhM02NLocMax2[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax2[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax2[mcindex][matched]->Fill(en,nc) ; }
1968 else if(nMax >= 3 ) { fhM02NLocMaxN[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMaxN[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMaxN[mcindex][matched]->Fill(en,nc) ; }
1970 if(TMath::Abs(dR) < 999 && fFillTMResidualHisto)
1972 if ( nMax == 1 ) { fhTrackMatchedDEtaNLocMax1[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1[mcindex]->Fill(en,dR); }
1973 else if( nMax == 2 ) { fhTrackMatchedDEtaNLocMax2[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2[mcindex]->Fill(en,dR); }
1974 else if( nMax >= 3 ) { fhTrackMatchedDEtaNLocMaxN[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxN[mcindex]->Fill(en,dR); }
1978 TLorentzVector primary = GetMCAnalysisUtils()->GetMother(mcLabel,GetReader(),ok);
1979 eprim = primary.E();
1981 if(mcindex == kmcPi0 || mcindex == kmcEta)
1983 if(mcindex == kmcPi0)
1985 asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,111,GetReader(),ok));
1986 TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,111,GetReader(),ok);
1987 if(grandmom.E() > 0 && ok) eprim = grandmom.E();
1991 asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,221,GetReader(),ok));
1992 TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,221,GetReader(),ok);
1993 if(grandmom.E() > 0 && ok) eprim = grandmom.E();
1998 Float_t efrac = eprim/en;
1999 Float_t efracSplit = 0;
2000 if(e1+e2 > 0) efracSplit = eprim/(e1+e2);
2002 //printf("e1 %2.2f, e2 %2.2f, eprim %2.2f, ereco %2.2f, esplit/ereco %2.2f, egen/ereco %2.2f, egen/esplit %2.2f\n",
2003 // e1,e2,eprim,en,splitFrac,efrac,efracSplit);
2006 if(en > 8 && en <= 12) ebin = 0;
2007 if(en > 12 && en <= 16) ebin = 1;
2008 if(en > 16 && en <= 20) ebin = 2;
2009 if(en > 20) ebin = 3;
2011 if(fFillEbinHisto && ebin >= 0 && IsDataMC() && fFillMCFractionHisto)
2013 if( !matched ) fhMCGenFracNLocMaxEbin [mcindex][ebin]->Fill(efrac,nMax);
2014 else fhMCGenFracNLocMaxEbinMatched[mcindex][ebin]->Fill(efrac,nMax);
2021 fhMassM02NLocMax1 [0][matched]->Fill(l0 , mass );
2022 if(fFillSSExtraHisto)
2024 fhMassDispEtaNLocMax1[0][matched]->Fill(dispEta, mass );
2025 fhMassDispPhiNLocMax1[0][matched]->Fill(dispPhi, mass );
2026 fhMassDispAsyNLocMax1[0][matched]->Fill(dispAsy, mass );
2031 fhMassM02NLocMax1 [mcindex][matched]->Fill(l0 , mass );
2032 if(fFillMCFractionHisto)
2034 fhMCGenFracNLocMax1 [mcindex][matched]->Fill(en , efrac );
2035 fhMCGenSplitEFracNLocMax1 [mcindex][matched]->Fill(en , efracSplit );
2036 fhMCGenEvsSplitENLocMax1 [mcindex][matched]->Fill(eprim , e1+e2);
2037 fhMCGenEFracvsSplitEFracNLocMax1[mcindex][matched]->Fill(efrac,splitFrac );
2040 if(!matched && ebin >= 0 && fFillEbinHisto)
2042 if(fFillMCFractionHisto)
2044 fhM02MCGenFracNLocMax1Ebin [mcindex][ebin]->Fill(efrac , l0 );
2045 fhMassMCGenFracNLocMax1Ebin[mcindex][ebin]->Fill(efrac , mass );
2047 fhMCAsymM02NLocMax1MCPi0Ebin [ebin]->Fill(l0 , asymGen );
2048 fhAsyMCGenRecoNLocMax1EbinPi0[ebin]->Fill(asym, asymGen );
2051 if(fFillSSExtraHisto)
2053 fhMassDispEtaNLocMax1[mcindex][matched]->Fill(dispEta, mass );
2054 fhMassDispPhiNLocMax1[mcindex][matched]->Fill(dispPhi, mass );
2055 fhMassDispAsyNLocMax1[mcindex][matched]->Fill(dispAsy, mass );
2060 if(!matched && ebin >= 0 && fFillEbinHisto)
2062 fhMassSplitEFractionNLocMax1Ebin[0][ebin]->Fill(splitFrac, mass);
2063 if(IsDataMC())fhMassSplitEFractionNLocMax1Ebin[mcindex][ebin]->Fill(splitFrac, mass);
2065 fhMassM02NLocMax1Ebin [ebin]->Fill(l0 , mass );
2066 fhMassAsyNLocMax1Ebin [ebin]->Fill(asym, mass );
2068 if(fFillSSExtraHisto)
2070 fhMassDispEtaNLocMax1Ebin[ebin]->Fill(dispEta, mass );
2071 fhMassDispPhiNLocMax1Ebin[ebin]->Fill(dispPhi, mass );
2072 fhMassDispAsyNLocMax1Ebin[ebin]->Fill(dispAsy, mass );
2080 fhMassM02NLocMax2 [0][matched]->Fill(l0 , mass );
2081 if(fFillSSExtraHisto)
2083 fhMassDispEtaNLocMax2[0][matched]->Fill(dispEta, mass );
2084 fhMassDispPhiNLocMax2[0][matched]->Fill(dispPhi, mass );
2085 fhMassDispAsyNLocMax2[0][matched]->Fill(dispAsy, mass );
2090 fhMassM02NLocMax2 [mcindex][matched]->Fill(l0 , mass );
2091 if(fFillMCFractionHisto)
2093 fhMCGenFracNLocMax2 [mcindex][matched]->Fill(en , efrac );
2094 fhMCGenSplitEFracNLocMax2[mcindex][matched]->Fill(en , efracSplit );
2095 fhMCGenEvsSplitENLocMax2 [mcindex][matched]->Fill(eprim , e1+e2);
2096 fhMCGenEFracvsSplitEFracNLocMax2[mcindex][matched]->Fill(efrac,splitFrac );
2099 if(!matched && ebin >= 0 && fFillEbinHisto )
2101 if(fFillMCFractionHisto)
2103 fhM02MCGenFracNLocMax2Ebin [mcindex][ebin]->Fill(efrac , l0 );
2104 fhMassMCGenFracNLocMax2Ebin[mcindex][ebin]->Fill(efrac , mass );
2106 fhMCAsymM02NLocMax2MCPi0Ebin [ebin]->Fill(l0 , asymGen );
2107 fhAsyMCGenRecoNLocMax2EbinPi0[ebin]->Fill(asym, asymGen );
2110 if(fFillSSExtraHisto)
2112 fhMassDispEtaNLocMax2[mcindex][matched]->Fill(dispEta, mass );
2113 fhMassDispPhiNLocMax2[mcindex][matched]->Fill(dispPhi, mass );
2114 fhMassDispAsyNLocMax2[mcindex][matched]->Fill(dispAsy, mass );
2119 if(!matched && ebin >= 0 && fFillEbinHisto)
2121 fhMassSplitEFractionNLocMax2Ebin[0][ebin]->Fill(splitFrac, mass);
2122 if(IsDataMC())fhMassSplitEFractionNLocMax2Ebin[mcindex][ebin]->Fill(splitFrac, mass);
2124 fhMassM02NLocMax2Ebin [ebin]->Fill(l0 , mass );
2125 fhMassAsyNLocMax2Ebin [ebin]->Fill(asym, mass );
2127 if(fFillSSExtraHisto)
2129 fhMassDispEtaNLocMax2Ebin[ebin]->Fill(dispEta, mass );
2130 fhMassDispPhiNLocMax2Ebin[ebin]->Fill(dispPhi, mass );
2131 fhMassDispAsyNLocMax2Ebin[ebin]->Fill(dispAsy, mass );
2139 fhMassM02NLocMaxN [0][matched]->Fill(l0 , mass );
2140 if(fFillSSExtraHisto)
2142 fhMassDispEtaNLocMaxN[0][matched]->Fill(dispEta, mass );
2143 fhMassDispPhiNLocMaxN[0][matched]->Fill(dispPhi, mass );
2144 fhMassDispAsyNLocMaxN[0][matched]->Fill(dispAsy, mass );
2149 fhMassM02NLocMaxN [mcindex][matched]->Fill(l0 , mass );
2150 if(fFillMCFractionHisto)
2152 fhMCGenFracNLocMaxN [mcindex][matched]->Fill(en , efrac );
2153 fhMCGenSplitEFracNLocMaxN[mcindex][matched]->Fill(en , efracSplit );
2154 fhMCGenEvsSplitENLocMaxN [mcindex][matched]->Fill(eprim , e1+e2);
2155 fhMCGenEFracvsSplitEFracNLocMaxN[mcindex][matched]->Fill(efrac, splitFrac );
2158 if(!matched && ebin >= 0 && fFillEbinHisto)
2160 if(fFillMCFractionHisto)
2162 fhM02MCGenFracNLocMaxNEbin [mcindex][ebin]->Fill(efrac , l0 );
2163 fhMassMCGenFracNLocMaxNEbin[mcindex][ebin]->Fill(efrac , mass );
2165 fhMCAsymM02NLocMaxNMCPi0Ebin [ebin]->Fill(l0 , asymGen );
2166 fhAsyMCGenRecoNLocMaxNEbinPi0[ebin]->Fill(asym, asymGen );
2168 if(fFillSSExtraHisto)
2170 fhMassDispEtaNLocMaxN[mcindex][matched]->Fill(dispEta, mass );
2171 fhMassDispPhiNLocMaxN[mcindex][matched]->Fill(dispPhi, mass );
2172 fhMassDispAsyNLocMaxN[mcindex][matched]->Fill(dispAsy, mass );
2177 if(!matched && ebin >= 0 && fFillEbinHisto)
2179 fhMassSplitEFractionNLocMaxNEbin[0][ebin]->Fill(splitFrac, mass);
2180 if(IsDataMC())fhMassSplitEFractionNLocMaxNEbin[mcindex][ebin]->Fill(splitFrac, mass);
2182 fhMassM02NLocMaxNEbin [ebin]->Fill(l0 , mass );
2183 fhMassAsyNLocMaxNEbin [ebin]->Fill(asym, mass );
2185 if(fFillSSExtraHisto)
2187 fhMassDispEtaNLocMaxNEbin[ebin]->Fill(dispEta, mass );
2188 fhMassDispPhiNLocMaxNEbin[ebin]->Fill(dispPhi, mass );
2189 fhMassDispAsyNLocMaxNEbin[ebin]->Fill(dispAsy, mass );
2194 //---------------------------------------------------------------------
2195 // From here only if M02 is large but not too large, fill histograms
2196 //---------------------------------------------------------------------
2198 if( l0 < fM02MinCut || l0 > fM02MaxCut ) continue ;
2200 Bool_t m02OK = GetCaloPID()->IsInPi0M02Range(en,l0,nMax);
2201 Bool_t asyOK = GetCaloPID()->IsInPi0SplitAsymmetryRange(en,asym,nMax);
2203 Float_t cent = GetEventCentrality();
2204 Float_t evp = GetEventPlaneAngle();
2206 fhNLocMaxM02Cut[0][matched]->Fill(en,nMax);
2207 if(IsDataMC()) fhNLocMaxM02Cut[mcindex][matched]->Fill(en,nMax);
2209 Float_t splitFracMin = GetCaloPID()->GetSplitEnergyFractionMinimum(inlm) ;
2213 fhMassNLocMax1[0][matched]->Fill(en,mass );
2214 fhAsymNLocMax1[0][matched]->Fill(en,asym );
2216 // Effect of cuts in mass histograms
2222 fhMassM02CutNLocMax1->Fill(en,mass);
2223 fhAsymM02CutNLocMax1->Fill(en,asym );
2224 if(splitFrac > splitFracMin) fhMassSplitECutNLocMax1->Fill(en,mass );
2230 fhSplitEFractionAfterCutsNLocMax1[0][matched]->Fill(en,splitFrac);
2231 if(splitFrac > splitFracMin) fhMassAfterCutsNLocMax1[0][matched]->Fill(en,mass);
2233 if(!matched && IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
2236 fhMCGenFracAfterCutsNLocMax1MCPi0 ->Fill(en , efrac );
2237 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0->Fill(en , efracSplit);
2243 fhAnglePairNLocMax1[matched]->Fill(en,angle);
2245 fhAnglePairMassNLocMax1[matched]->Fill(mass,angle);
2248 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMax1[0][matched]->Fill(en,l0); fhMassConNLocMax1[0][matched]->Fill(en,mass); fhAsyConNLocMax1[0][matched]->Fill(en,asym); }
2249 else if(pidTag==AliCaloPID::kPi0 )
2251 fhM02Pi0NLocMax1[0][matched]->Fill(en,l0); fhMassPi0NLocMax1[0][matched]->Fill(en,mass); fhAsyPi0NLocMax1[0][matched]->Fill(en,asym);
2252 fhCentralityPi0NLocMax1[0][matched]->Fill(en,cent) ;
2255 fhEventPlanePi0NLocMax1->Fill(en,evp) ;
2256 if(en > ecut)fhPi0EtaPhiNLocMax1->Fill(eta,phi);
2257 FillSSWeightHistograms(cluster, 0, absId1, absId2);
2260 else if(pidTag==AliCaloPID::kEta)
2262 fhM02EtaNLocMax1[0][matched]->Fill(en,l0); fhMassEtaNLocMax1[0][matched]->Fill(en,mass); fhAsyEtaNLocMax1[0][matched]->Fill(en,asym);
2263 fhCentralityEtaNLocMax1[0][matched]->Fill(en,cent) ;
2266 fhEventPlaneEtaNLocMax1->Fill(en,evp) ;
2267 if(en > ecut)fhEtaEtaPhiNLocMax1->Fill(eta,phi);
2274 fhMassNLocMax2[0][matched]->Fill(en,mass );
2275 fhAsymNLocMax2[0][matched]->Fill(en,asym );
2277 // Effect of cuts in mass histograms
2282 fhMassM02CutNLocMax2->Fill(en,mass);
2283 fhAsymM02CutNLocMax2->Fill(en,asym );
2284 if(splitFrac > splitFracMin) fhMassSplitECutNLocMax2->Fill(en,mass );
2290 fhSplitEFractionAfterCutsNLocMax2[0][matched]->Fill(en,splitFrac);
2291 if(splitFrac >splitFracMin) fhMassAfterCutsNLocMax2[0][matched]->Fill(en,mass);
2293 if(!matched && IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
2296 fhMCGenFracAfterCutsNLocMax2MCPi0 ->Fill(en , efrac );
2297 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0->Fill(en , efracSplit);
2303 fhAnglePairNLocMax2[matched]->Fill(en,angle);
2305 fhAnglePairMassNLocMax2[matched]->Fill(mass,angle);
2308 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMax2[0][matched]->Fill(en,l0); fhMassConNLocMax2[0][matched]->Fill(en,mass); fhAsyConNLocMax2[0][matched]->Fill(en,asym); }
2309 else if(pidTag==AliCaloPID::kPi0 )
2311 fhM02Pi0NLocMax2[0][matched]->Fill(en,l0); fhMassPi0NLocMax2[0][matched]->Fill(en,mass); fhAsyPi0NLocMax2[0][matched]->Fill(en,asym);
2312 fhCentralityPi0NLocMax2[0][matched]->Fill(en,cent) ;
2315 fhEventPlanePi0NLocMax2->Fill(en,evp) ;
2316 if(en > ecut)fhPi0EtaPhiNLocMax2->Fill(eta,phi);
2317 FillSSWeightHistograms(cluster, 1, absId1, absId2);
2320 else if(pidTag==AliCaloPID::kEta)
2322 fhM02EtaNLocMax2[0][matched]->Fill(en,l0); fhMassEtaNLocMax2[0][matched]->Fill(en,mass); fhAsyEtaNLocMax2[0][matched]->Fill(en,asym);
2323 fhCentralityEtaNLocMax2[0][matched]->Fill(en,cent) ;
2326 fhEventPlaneEtaNLocMax2->Fill(en,evp) ;
2327 if(en > ecut)fhEtaEtaPhiNLocMax2->Fill(eta,phi);
2334 fhMassNLocMaxN[0][matched]->Fill(en,mass);
2335 fhAsymNLocMaxN[0][matched]->Fill(en,asym);
2337 // Effect of cuts in mass histograms
2342 fhMassM02CutNLocMaxN->Fill(en,mass);
2343 fhAsymM02CutNLocMaxN->Fill(en,asym );
2344 if(splitFrac > splitFracMin)fhMassSplitECutNLocMaxN->Fill(en,mass );
2350 fhSplitEFractionAfterCutsNLocMaxN[0][matched]->Fill(en,splitFrac);
2351 if(splitFrac > splitFracMin) fhMassAfterCutsNLocMaxN[0][matched]->Fill(en,mass);
2353 if(!matched && IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
2356 fhMCGenFracAfterCutsNLocMaxNMCPi0 ->Fill(en , efrac );
2357 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0->Fill(en , efracSplit);
2363 fhAnglePairNLocMaxN[matched]->Fill(en,angle);
2365 fhAnglePairMassNLocMaxN[matched]->Fill(mass,angle);
2368 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMaxN[0][matched]->Fill(en,l0); fhMassConNLocMaxN[0][matched]->Fill(en,mass); fhAsyConNLocMaxN[0][matched]->Fill(en,asym); }
2369 else if(pidTag==AliCaloPID::kPi0 )
2371 fhM02Pi0NLocMaxN[0][matched]->Fill(en,l0); fhMassPi0NLocMaxN[0][matched]->Fill(en,mass); fhAsyPi0NLocMaxN[0][matched]->Fill(en,asym);
2372 fhCentralityPi0NLocMaxN[0][matched]->Fill(en,cent) ;
2375 fhEventPlanePi0NLocMaxN->Fill(en,evp) ;
2376 if(en > ecut)fhPi0EtaPhiNLocMaxN->Fill(eta,phi);
2377 FillSSWeightHistograms(cluster, 2, absId1, absId2);
2380 else if(pidTag==AliCaloPID::kEta)
2382 fhM02EtaNLocMaxN[0][matched]->Fill(en,l0); fhMassEtaNLocMaxN[0][matched]->Fill(en,mass); fhAsyEtaNLocMaxN[0][matched]->Fill(en,asym);
2383 fhCentralityEtaNLocMaxN[0][matched]->Fill(en,cent) ;
2386 fhEventPlaneEtaNLocMaxN->Fill(en,evp) ;
2387 if(en > ecut)fhEtaEtaPhiNLocMaxN->Fill(eta,phi);
2398 fhMassNLocMax1[mcindex][matched]->Fill(en,mass);
2399 fhAsymNLocMax1[mcindex][matched]->Fill(en,asym);
2403 fhSplitEFractionAfterCutsNLocMax1[mcindex][matched]->Fill(en,splitFrac);
2404 if(splitFrac > splitFracMin)
2405 fhMassAfterCutsNLocMax1[mcindex][matched]->Fill(en,mass);
2408 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMax1[mcindex][matched]->Fill(en,l0); fhMassConNLocMax1[mcindex][matched]->Fill(en,mass); fhAsyConNLocMax1[mcindex][matched]->Fill(en,asym); }
2409 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMax1[mcindex][matched]->Fill(en,l0); fhMassPi0NLocMax1[mcindex][matched]->Fill(en,mass); fhAsyPi0NLocMax1[mcindex][matched]->Fill(en,asym); }
2410 else if(pidTag==AliCaloPID::kEta ) { fhM02EtaNLocMax1[mcindex][matched]->Fill(en,l0); fhMassEtaNLocMax1[mcindex][matched]->Fill(en,mass); fhAsyEtaNLocMax1[mcindex][matched]->Fill(en,asym); }
2412 if (pidTag==AliCaloPID::kPi0) fhCentralityPi0NLocMax1[mcindex][matched]->Fill(en,cent) ;
2413 else if(pidTag==AliCaloPID::kEta) fhCentralityEtaNLocMax1[mcindex][matched]->Fill(en,cent) ;
2417 fhMassNLocMax2[mcindex][matched]->Fill(en,mass);
2418 fhAsymNLocMax2[mcindex][matched]->Fill(en,asym);
2422 fhSplitEFractionAfterCutsNLocMax2[mcindex][matched]->Fill(en,splitFrac);
2423 if(splitFrac >splitFracMin)
2424 fhMassAfterCutsNLocMax2[mcindex][matched]->Fill(en,mass);
2427 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMax2[mcindex][matched]->Fill(en,l0); fhMassConNLocMax2[mcindex][matched]->Fill(en,mass); fhAsyConNLocMax2[mcindex][matched]->Fill(en,asym); }
2428 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMax2[mcindex][matched]->Fill(en,l0); fhMassPi0NLocMax2[mcindex][matched]->Fill(en,mass); fhAsyPi0NLocMax2[mcindex][matched]->Fill(en,asym); }
2429 else if(pidTag==AliCaloPID::kEta ) { fhM02EtaNLocMax2[mcindex][matched]->Fill(en,l0); fhMassEtaNLocMax2[mcindex][matched]->Fill(en,mass); fhAsyEtaNLocMax2[mcindex][matched]->Fill(en,asym); }
2431 if (pidTag==AliCaloPID::kPi0) fhCentralityPi0NLocMax2[mcindex][matched]->Fill(en,cent) ;
2432 else if(pidTag==AliCaloPID::kEta) fhCentralityEtaNLocMax2[mcindex][matched]->Fill(en,cent) ;
2437 fhMassNLocMaxN[mcindex][matched]->Fill(en,mass);
2438 fhAsymNLocMaxN[mcindex][matched]->Fill(en,asym);
2442 fhSplitEFractionAfterCutsNLocMaxN[mcindex][matched]->Fill(en,splitFrac);
2443 if(splitFrac > splitFracMin )
2444 fhMassAfterCutsNLocMaxN[mcindex][matched]->Fill(en,mass);
2447 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMaxN[mcindex][matched]->Fill(en,l0); fhMassConNLocMaxN[mcindex][matched]->Fill(en,mass); fhAsyConNLocMaxN[mcindex][matched]->Fill(en,asym); }
2448 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMaxN[mcindex][matched]->Fill(en,l0); fhMassPi0NLocMaxN[mcindex][matched]->Fill(en,mass); fhAsyPi0NLocMaxN[mcindex][matched]->Fill(en,asym); }
2449 else if(pidTag==AliCaloPID::kEta ) { fhM02EtaNLocMaxN[mcindex][matched]->Fill(en,l0); fhMassEtaNLocMaxN[mcindex][matched]->Fill(en,mass); fhAsyEtaNLocMaxN[mcindex][matched]->Fill(en,asym); }
2451 if (pidTag==AliCaloPID::kPi0) fhCentralityPi0NLocMaxN[mcindex][matched]->Fill(en,cent) ;
2452 else if(pidTag==AliCaloPID::kEta) fhCentralityEtaNLocMaxN[mcindex][matched]->Fill(en,cent) ;
2455 }//Work with MC truth first
2459 if(GetDebug() > 1) printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - END \n");
2463 //______________________________________________________________________
2464 void AliAnaInsideClusterInvariantMass::Print(const Option_t * opt) const
2466 //Print some relevant parameters set for the analysis
2470 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
2471 AliAnaCaloTrackCorrBaseClass::Print("");
2472 printf("Calorimeter = %s\n", fCalorimeter.Data()) ;
2473 if(GetCaloUtils()) printf("Loc. Max. E > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutE());
2474 if(GetCaloUtils()) printf("Loc. Max. E Diff > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutEDiff());
2475 printf("Min. N Cells =%d \n", fMinNCells) ;
2476 printf("Min. Dist. to Bad =%1.1f \n", fMinBadDist) ;
2477 printf("%2.2f < lambda_0^2 <%2.2f \n",fM02MinCut,fM02MaxCut);
2478 if(fFillSSWeightHisto) printf(" N w %d - N e cut %d \n",fSSWeightN,fSSECellCutN);
2485 //___________________________________________________________________________________________________________________
2486 void AliAnaInsideClusterInvariantMass::RecalculateClusterShowerShapeParametersWithCellCut(const AliEMCALGeometry * geom,
2487 AliVCaloCells* cells,
2488 AliVCluster * cluster,
2489 Float_t & l0, Float_t & l1,
2490 Float_t & disp, Float_t & dEta, Float_t & dPhi,
2491 Float_t & sEta, Float_t & sPhi, Float_t & sEtaPhi,
2494 // Calculates new center of gravity in the local EMCAL-module coordinates
2495 // and tranfers into global ALICE coordinates
2496 // Calculates Dispersion and main axis
2500 AliInfo("Cluster pointer null!");
2504 Double_t eCell = 0.;
2505 Float_t fraction = 1.;
2506 Float_t recalFactor = 1.;
2514 Double_t etai = -1.;
2515 Double_t phii = -1.;
2520 Double_t etaMean = 0.;
2521 Double_t phiMean = 0.;
2523 Float_t energy = cluster->E();
2525 //Loop on cells, calculate the cluster energy, in case a cut on cell energy is added
2529 for(Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++)
2531 //Get from the absid the supermodule, tower and eta/phi numbers
2532 geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta);
2533 geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);
2535 //Get the cell energy, if recalibration is on, apply factors
2536 fraction = cluster->GetCellAmplitudeFraction(iDigit);
2537 if(fraction < 1e-4) fraction = 1.; // in case unfolding is off
2539 if(GetCaloUtils()->GetEMCALRecoUtils()->IsRecalibrationOn())
2541 recalFactor = GetCaloUtils()->GetEMCALRecoUtils()->GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
2544 eCell = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
2546 if(eCell > eCellMin) energy += eCell;
2551 //Loop on cells, get weighted parameters
2552 for(Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++)
2554 //Get from the absid the supermodule, tower and eta/phi numbers
2555 geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta);
2556 geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);
2558 //Get the cell energy, if recalibration is on, apply factors
2559 fraction = cluster->GetCellAmplitudeFraction(iDigit);
2560 if(fraction < 1e-4) fraction = 1.; // in case unfolding is off
2562 if(GetCaloUtils()->GetEMCALRecoUtils()->IsRecalibrationOn())
2564 recalFactor = GetCaloUtils()->GetEMCALRecoUtils()->GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
2567 eCell = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
2569 if(energy > 0 && eCell > eCellMin)
2571 w = GetCaloUtils()->GetEMCALRecoUtils()->GetCellWeight(eCell,energy);
2573 etai=(Double_t)ieta;
2574 phii=(Double_t)iphi;
2581 sEta += w * etai * etai ;
2582 etaMean += w * etai ;
2583 sPhi += w * phii * phii ;
2584 phiMean += w * phii ;
2585 sEtaPhi += w * etai * phii ;
2588 else if(energy == 0 || (eCellMin <0.01 && eCell == 0)) AliError(Form("Wrong energy %f and/or amplitude %f\n", eCell, energy));
2592 //Normalize to the weight
2599 AliError(Form("Wrong weight %f\n", wtot));
2601 //Calculate dispersion
2602 for(Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++)
2604 //Get from the absid the supermodule, tower and eta/phi numbers
2605 geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta);
2606 geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);
2608 //Get the cell energy, if recalibration is on, apply factors
2609 fraction = cluster->GetCellAmplitudeFraction(iDigit);
2610 if(fraction < 1e-4) fraction = 1.; // in case unfolding is off
2611 if (GetCaloUtils()->GetEMCALRecoUtils()->IsRecalibrationOn())
2613 recalFactor = GetCaloUtils()->GetEMCALRecoUtils()->GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
2615 eCell = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
2617 if(energy > 0 && eCell > eCellMin)
2619 w = GetCaloUtils()->GetEMCALRecoUtils()->GetCellWeight(eCell,energy);
2621 etai=(Double_t)ieta;
2622 phii=(Double_t)iphi;
2625 disp += w *((etai-etaMean)*(etai-etaMean)+(phii-phiMean)*(phii-phiMean));
2626 dEta += w * (etai-etaMean)*(etai-etaMean) ;
2627 dPhi += w * (phii-phiMean)*(phii-phiMean) ;
2630 else if(energy == 0 || (eCellMin <0.01 && eCell == 0)) AliError(Form("Wrong energy %f and/or amplitude %f\n", eCell, energy));
2633 //Normalize to the weigth and set shower shape parameters
2634 if (wtot > 0 && nstat > 1)
2643 sEta -= etaMean * etaMean ;
2644 sPhi -= phiMean * phiMean ;
2645 sEtaPhi -= etaMean * phiMean ;
2647 l0 = (0.5 * (sEta + sPhi) + TMath::Sqrt( 0.25 * (sEta - sPhi) * (sEta - sPhi) + sEtaPhi * sEtaPhi ));
2648 l1 = (0.5 * (sEta + sPhi) - TMath::Sqrt( 0.25 * (sEta - sPhi) * (sEta - sPhi) + sEtaPhi * sEtaPhi ));
2654 dEta = 0. ; dPhi = 0. ; disp = 0. ;
2655 sEta = 0. ; sPhi = 0. ; sEtaPhi = 0. ;
git://git.uio.no / u / mrichter / AliRoot.git / blob