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 fhMassM02CutNLocMax1(0), fhMassM02CutNLocMax2(0), fhMassM02CutNLocMaxN(0),
63 fhAsymM02CutNLocMax1(0), fhAsymM02CutNLocMax2(0), fhAsymM02CutNLocMaxN(0),
64 fhMassSplitECutNLocMax1(0), fhMassSplitECutNLocMax2(0), fhMassSplitECutNLocMaxN(0),
65 fhMCGenFracAfterCutsNLocMax1MCPi0(0),
66 fhMCGenFracAfterCutsNLocMax2MCPi0(0),
67 fhMCGenFracAfterCutsNLocMaxNMCPi0(0),
68 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0(0),
69 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0(0),
70 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0(0),
71 fhCentralityPi0NLocMax1(0), fhCentralityEtaNLocMax1(0),
72 fhCentralityPi0NLocMax2(0), fhCentralityEtaNLocMax2(0),
73 fhCentralityPi0NLocMaxN(0), fhCentralityEtaNLocMaxN(0),
74 fhEventPlanePi0NLocMax1(0), fhEventPlaneEtaNLocMax1(0),
75 fhEventPlanePi0NLocMax2(0), fhEventPlaneEtaNLocMax2(0),
76 fhEventPlanePi0NLocMaxN(0), fhEventPlaneEtaNLocMaxN(0)
80 // Init array of histograms
81 for(Int_t i = 0; i < 8; i++)
83 fhMassAfterCutsNLocMax1[i] = 0;
84 fhMassAfterCutsNLocMax2[i] = 0;
85 fhMassAfterCutsNLocMaxN[i] = 0;
87 fhSplitEFractionAfterCutsNLocMax1[i] = 0 ;
88 fhSplitEFractionAfterCutsNLocMax2[i] = 0 ;
89 fhSplitEFractionAfterCutsNLocMaxN[i] = 0 ;
91 for(Int_t j = 0; j < 2; j++)
93 fhMassNLocMax1[i][j] = 0;
94 fhMassNLocMax2[i][j] = 0;
95 fhMassNLocMaxN[i][j] = 0;
97 fhNLocMaxM02Cut[i][j] = 0;
98 fhM02NLocMax1[i][j] = 0;
99 fhM02NLocMax2[i][j] = 0;
100 fhM02NLocMaxN[i][j] = 0;
101 fhNCellNLocMax1[i][j] = 0;
102 fhNCellNLocMax2[i][j] = 0;
103 fhNCellNLocMaxN[i][j] = 0;
104 fhM02Pi0NLocMax1[i][j] = 0;
105 fhM02EtaNLocMax1[i][j] = 0;
106 fhM02ConNLocMax1[i][j] = 0;
107 fhM02Pi0NLocMax2[i][j] = 0;
108 fhM02EtaNLocMax2[i][j] = 0;
109 fhM02ConNLocMax2[i][j] = 0;
110 fhM02Pi0NLocMaxN[i][j] = 0;
111 fhM02EtaNLocMaxN[i][j] = 0;
112 fhM02ConNLocMaxN[i][j] = 0;
114 fhMassPi0NLocMax1[i][j] = 0;
115 fhMassEtaNLocMax1[i][j] = 0;
116 fhMassConNLocMax1[i][j] = 0;
117 fhMassPi0NLocMax2[i][j] = 0;
118 fhMassEtaNLocMax2[i][j] = 0;
119 fhMassConNLocMax2[i][j] = 0;
120 fhMassPi0NLocMaxN[i][j] = 0;
121 fhMassEtaNLocMaxN[i][j] = 0;
122 fhMassConNLocMaxN[i][j] = 0;
125 fhAsyPi0NLocMax1[i][j] = 0;
126 fhAsyEtaNLocMax1[i][j] = 0;
127 fhAsyConNLocMax1[i][j] = 0;
128 fhAsyPi0NLocMax2[i][j] = 0;
129 fhAsyEtaNLocMax2[i][j] = 0;
130 fhAsyConNLocMax2[i][j] = 0;
131 fhAsyPi0NLocMaxN[i][j] = 0;
132 fhAsyEtaNLocMaxN[i][j] = 0;
133 fhAsyConNLocMaxN[i][j] = 0;
135 fhMassM02NLocMax1[i][j]= 0;
136 fhMassM02NLocMax2[i][j]= 0;
137 fhMassM02NLocMaxN[i][j]= 0;
138 fhMassDispEtaNLocMax1[i][j]= 0;
139 fhMassDispEtaNLocMax2[i][j]= 0;
140 fhMassDispEtaNLocMaxN[i][j]= 0;
141 fhMassDispPhiNLocMax1[i][j]= 0;
142 fhMassDispPhiNLocMax2[i][j]= 0;
143 fhMassDispPhiNLocMaxN[i][j]= 0;
144 fhMassDispAsyNLocMax1[i][j]= 0;
145 fhMassDispAsyNLocMax2[i][j]= 0;
146 fhMassDispAsyNLocMaxN[i][j]= 0;
148 fhSplitEFractionNLocMax1[i][j]=0;
149 fhSplitEFractionNLocMax2[i][j]=0;
150 fhSplitEFractionNLocMaxN[i][j]=0;
152 fhMCGenFracNLocMax1[i][j]= 0;
153 fhMCGenFracNLocMax2[i][j]= 0;
154 fhMCGenFracNLocMaxN[i][j]= 0;
156 fhMCGenSplitEFracNLocMax1[i][j]= 0;
157 fhMCGenSplitEFracNLocMax2[i][j]= 0;
158 fhMCGenSplitEFracNLocMaxN[i][j]= 0;
160 fhMCGenEFracvsSplitEFracNLocMax1[i][j]= 0;
161 fhMCGenEFracvsSplitEFracNLocMax2[i][j]= 0;
162 fhMCGenEFracvsSplitEFracNLocMaxN[i][j]= 0;
164 fhMCGenEvsSplitENLocMax1[i][j]= 0;
165 fhMCGenEvsSplitENLocMax2[i][j]= 0;
166 fhMCGenEvsSplitENLocMaxN[i][j]= 0;
168 fhAsymNLocMax1 [i][j] = 0;
169 fhAsymNLocMax2 [i][j] = 0;
170 fhAsymNLocMaxN [i][j] = 0;
173 for(Int_t jj = 0; jj < 4; jj++)
175 fhM02MCGenFracNLocMax1Ebin[i][jj] = 0;
176 fhM02MCGenFracNLocMax2Ebin[i][jj] = 0;
177 fhM02MCGenFracNLocMaxNEbin[i][jj] = 0;
179 fhMassMCGenFracNLocMax1Ebin[i][jj]= 0;
180 fhMassMCGenFracNLocMax2Ebin[i][jj]= 0;
181 fhMassMCGenFracNLocMaxNEbin[i][jj]= 0;
183 fhMCGenFracNLocMaxEbin[i][jj] = 0;
184 fhMCGenFracNLocMaxEbinMatched[i][jj]= 0;
186 fhMassSplitEFractionNLocMax1Ebin[i][jj] = 0;
187 fhMassSplitEFractionNLocMax2Ebin[i][jj] = 0;
188 fhMassSplitEFractionNLocMaxNEbin[i][jj] = 0;
191 fhTrackMatchedDEtaNLocMax1[i] = 0;
192 fhTrackMatchedDPhiNLocMax1[i] = 0;
193 fhTrackMatchedDEtaNLocMax2[i] = 0;
194 fhTrackMatchedDPhiNLocMax2[i] = 0;
195 fhTrackMatchedDEtaNLocMaxN[i] = 0;
196 fhTrackMatchedDPhiNLocMaxN[i] = 0;
200 for(Int_t i = 0; i < 2; i++)
202 fhAnglePairNLocMax1 [i] = 0;
203 fhAnglePairNLocMax2 [i] = 0;
204 fhAnglePairNLocMaxN [i] = 0;
205 fhAnglePairMassNLocMax1[i] = 0;
206 fhAnglePairMassNLocMax2[i] = 0;
207 fhAnglePairMassNLocMaxN[i] = 0;
208 fhSplitEFractionvsAsyNLocMax1[i] = 0;
209 fhSplitEFractionvsAsyNLocMax2[i] = 0;
210 fhSplitEFractionvsAsyNLocMaxN[i] = 0;
213 for(Int_t i = 0; i < 4; i++)
215 fhMassM02NLocMax1Ebin[i] = 0 ;
216 fhMassM02NLocMax2Ebin[i] = 0 ;
217 fhMassM02NLocMaxNEbin[i] = 0 ;
219 fhMassAsyNLocMax1Ebin[i] = 0 ;
220 fhMassAsyNLocMax2Ebin[i] = 0 ;
221 fhMassAsyNLocMaxNEbin[i] = 0 ;
223 fhAsyMCGenRecoNLocMax1EbinPi0[i] = 0 ;
224 fhAsyMCGenRecoNLocMax2EbinPi0[i] = 0 ;
225 fhAsyMCGenRecoNLocMaxNEbinPi0[i] = 0 ;
227 fhMassDispEtaNLocMax1Ebin[i] = 0 ;
228 fhMassDispEtaNLocMax2Ebin[i] = 0 ;
229 fhMassDispEtaNLocMaxNEbin[i] = 0 ;
231 fhMassDispPhiNLocMax1Ebin[i] = 0 ;
232 fhMassDispPhiNLocMax2Ebin[i] = 0 ;
233 fhMassDispPhiNLocMaxNEbin[i] = 0 ;
235 fhMassDispAsyNLocMax1Ebin[i] = 0 ;
236 fhMassDispAsyNLocMax2Ebin[i] = 0 ;
237 fhMassDispAsyNLocMaxNEbin[i] = 0 ;
239 fhMCAsymM02NLocMax1MCPi0Ebin[i] = 0 ;
240 fhMCAsymM02NLocMax2MCPi0Ebin[i] = 0 ;
241 fhMCAsymM02NLocMaxNMCPi0Ebin[i] = 0 ;
248 //_______________________________________________________________
249 TObjString * AliAnaInsideClusterInvariantMass::GetAnalysisCuts()
251 //Save parameters used for analysis
252 TString parList ; //this will be list of parameters used for this analysis.
253 const Int_t buffersize = 255;
254 char onePar[buffersize] ;
256 snprintf(onePar,buffersize,"--- AliAnaInsideClusterInvariantMass ---\n") ;
259 snprintf(onePar,buffersize,"Calorimeter: %s\n", fCalorimeter.Data()) ;
261 snprintf(onePar,buffersize,"fNLocMaxCutE =%2.2f \n", GetCaloUtils()->GetLocalMaximaCutE()) ;
263 snprintf(onePar,buffersize,"fNLocMaxCutEDiff =%2.2f \n",GetCaloUtils()->GetLocalMaximaCutEDiff()) ;
265 snprintf(onePar,buffersize,"%2.2f< M02 < %2.2f \n", fM02MinCut, fM02MaxCut) ;
267 snprintf(onePar,buffersize,"fMinNCells =%d \n", fMinNCells) ;
269 snprintf(onePar,buffersize,"fMinBadDist =%1.1f \n", fMinBadDist) ;
272 return new TObjString(parList) ;
276 //________________________________________________________________
277 TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
279 // Create histograms to be saved in output file and
280 // store them in outputContainer
281 TList * outputContainer = new TList() ;
282 outputContainer->SetName("InsideClusterHistos") ;
284 Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t ptmin = GetHistogramRanges()->GetHistoPtMin();
285 Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins(); Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax(); Float_t ssmin = GetHistogramRanges()->GetHistoShowerShapeMin();
286 Int_t mbins = GetHistogramRanges()->GetHistoMassBins(); Float_t mmax = GetHistogramRanges()->GetHistoMassMax(); Float_t mmin = GetHistogramRanges()->GetHistoMassMin();
287 Int_t ncbins = GetHistogramRanges()->GetHistoNClusterCellBins(); Int_t ncmax = GetHistogramRanges()->GetHistoNClusterCellMax(); Int_t ncmin = GetHistogramRanges()->GetHistoNClusterCellMin();
289 Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
290 Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
291 Float_t resetamin = GetHistogramRanges()->GetHistoTrackResidualEtaMin();
292 Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
293 Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
294 Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
296 TString ptype[] ={"","#gamma","#gamma->e^{#pm}","#pi^{0}","#eta","e^{#pm}", "hadron","#pi^{0} (#gamma->e^{#pm})"};
297 TString pname[] ={"","Photon","Conversion", "Pi0", "Eta", "Electron","Hadron","Pi0Conv"};
301 if(IsDataMC()) n = 8;
305 TString sMatched[] = {"","Matched"};
310 fhCentralityPi0NLocMax1 = new TH2F("hCentralityPi0NLocMax1","E vs Centrality, selected pi0 cluster with NLM=1",
311 nptbins,ptmin,ptmax,100,0,100);
312 fhCentralityPi0NLocMax1->SetYTitle("Centrality");
313 fhCentralityPi0NLocMax1->SetXTitle("E (GeV)");
314 outputContainer->Add(fhCentralityPi0NLocMax1) ;
316 fhCentralityPi0NLocMax2 = new TH2F("hCentralityPi0NLocMax2","E vs Centrality, selected pi0 cluster with NLM=2",
317 nptbins,ptmin,ptmax,100,0,100);
318 fhCentralityPi0NLocMax2->SetYTitle("Centrality");
319 fhCentralityPi0NLocMax2->SetXTitle("E (GeV)");
320 outputContainer->Add(fhCentralityPi0NLocMax2) ;
322 fhCentralityPi0NLocMaxN = new TH2F("hCentralityPi0NLocMaxN","E vs Centrality, selected pi0 cluster with NLM>1",
323 nptbins,ptmin,ptmax,100,0,100);
324 fhCentralityPi0NLocMaxN->SetYTitle("Centrality");
325 fhCentralityPi0NLocMaxN->SetXTitle("E (GeV)");
326 outputContainer->Add(fhCentralityPi0NLocMaxN) ;
328 fhCentralityEtaNLocMax1 = new TH2F("hCentralityEtaNLocMax1","E vs Centrality, selected pi0 cluster with NLM=1",
329 nptbins,ptmin,ptmax,100,0,100);
330 fhCentralityEtaNLocMax1->SetYTitle("Centrality");
331 fhCentralityEtaNLocMax1->SetXTitle("E (GeV)");
332 outputContainer->Add(fhCentralityEtaNLocMax1) ;
334 fhCentralityEtaNLocMax2 = new TH2F("hCentralityEtaNLocMax2","E vs Centrality, selected pi0 cluster with NLM=2",
335 nptbins,ptmin,ptmax,100,0,100);
336 fhCentralityEtaNLocMax2->SetYTitle("Centrality");
337 fhCentralityEtaNLocMax2->SetXTitle("E (GeV)");
338 outputContainer->Add(fhCentralityEtaNLocMax2) ;
340 fhCentralityEtaNLocMaxN = new TH2F("hCentralityEtaNLocMaxN","E vs Centrality, selected pi0 cluster with NLM>1",
341 nptbins,ptmin,ptmax,100,0,100);
342 fhCentralityEtaNLocMaxN->SetYTitle("Centrality");
343 fhCentralityEtaNLocMaxN->SetXTitle("E (GeV)");
344 outputContainer->Add(fhCentralityEtaNLocMaxN) ;
346 // E vs Event plane angle
348 fhEventPlanePi0NLocMax1 = new TH2F("hEventPlanePi0NLocMax1","E vs Event Plane Angle, selected pi0 cluster with NLM=1",
349 nptbins,ptmin,ptmax,100,0,TMath::Pi());
350 fhEventPlanePi0NLocMax1->SetYTitle("Event Plane Angle (rad)");
351 fhEventPlanePi0NLocMax1->SetXTitle("E (GeV)");
352 outputContainer->Add(fhEventPlanePi0NLocMax1) ;
354 fhEventPlanePi0NLocMax2 = new TH2F("hEventPlanePi0NLocMax2","E vs Event Plane Angle, selected pi0 cluster with NLM=2",
355 nptbins,ptmin,ptmax,100,0,TMath::Pi());
356 fhEventPlanePi0NLocMax2->SetYTitle("Event Plane Angle (rad)");
357 fhEventPlanePi0NLocMax2->SetXTitle("E (GeV)");
358 outputContainer->Add(fhEventPlanePi0NLocMax2) ;
360 fhEventPlanePi0NLocMaxN = new TH2F("hEventPlanePi0NLocMaxN","E vs Event Plane Angle, selected pi0 cluster with NLM>1",
361 nptbins,ptmin,ptmax,100,0,TMath::Pi());
362 fhEventPlanePi0NLocMaxN->SetYTitle("Event Plane Angle (rad)");
363 fhEventPlanePi0NLocMaxN->SetXTitle("E (GeV)");
364 outputContainer->Add(fhEventPlanePi0NLocMaxN) ;
366 fhEventPlaneEtaNLocMax1 = new TH2F("hEventPlaneEtaNLocMax1","E vs Event Plane Angle, selected pi0 cluster with NLM=1",
367 nptbins,ptmin,ptmax,100,0,TMath::Pi());
368 fhEventPlaneEtaNLocMax1->SetYTitle("Event Plane Angle (rad)");
369 fhEventPlaneEtaNLocMax1->SetXTitle("E (GeV)");
370 outputContainer->Add(fhEventPlaneEtaNLocMax1) ;
372 fhEventPlaneEtaNLocMax2 = new TH2F("hEventPlaneEtaNLocMax2","E vs Event Plane Angle, selected pi0 cluster with NLM=2",
373 nptbins,ptmin,ptmax,100,0,TMath::Pi());
374 fhEventPlaneEtaNLocMax2->SetYTitle("Event Plane Angle (rad)");
375 fhEventPlaneEtaNLocMax2->SetXTitle("E (GeV)");
376 outputContainer->Add(fhEventPlaneEtaNLocMax2) ;
378 fhEventPlaneEtaNLocMaxN = new TH2F("hEventPlaneEtaNLocMaxN","E vs Event Plane Angle, selected pi0 cluster with NLM>1",
379 nptbins,ptmin,ptmax,100,0,TMath::Pi());
380 fhEventPlaneEtaNLocMaxN->SetYTitle("Event Plane Angle (rad)");
381 fhEventPlaneEtaNLocMaxN->SetXTitle("E (GeV)");
382 outputContainer->Add(fhEventPlaneEtaNLocMaxN) ;
385 for(Int_t i = 0; i < n; i++)
387 for(Int_t j = 0; j < 2; j++)
390 fhMassNLocMax1[i][j] = new TH2F(Form("hMassNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
391 Form("Invariant mass of splitted cluster with NLM=1 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
392 nptbins,ptmin,ptmax,mbins,mmin,mmax);
393 fhMassNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
394 fhMassNLocMax1[i][j]->SetXTitle("E (GeV)");
395 outputContainer->Add(fhMassNLocMax1[i][j]) ;
397 fhMassNLocMax2[i][j] = new TH2F(Form("hMassNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
398 Form("Invariant mass of splitted cluster with NLM=2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
399 nptbins,ptmin,ptmax,mbins,mmin,mmax);
400 fhMassNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
401 fhMassNLocMax2[i][j]->SetXTitle("E (GeV)");
402 outputContainer->Add(fhMassNLocMax2[i][j]) ;
404 fhMassNLocMaxN[i][j] = new TH2F(Form("hMassNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
405 Form("Invariant mass of splitted cluster with NLM>2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
406 nptbins,ptmin,ptmax,mbins,mmin,mmax);
407 fhMassNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
408 fhMassNLocMaxN[i][j]->SetXTitle("E (GeV)");
409 outputContainer->Add(fhMassNLocMaxN[i][j]) ;
413 fhMassAfterCutsNLocMax1[i] = new TH2F(Form("hMassAfterCutsNLocMax1%s",pname[i].Data()),
414 Form("Mass vs E, %s, for N Local max = 1, m02 and asy cut",ptype[i].Data()),
415 nptbins,ptmin,ptmax,mbins,mmin,mmax);
416 fhMassAfterCutsNLocMax1[i] ->SetYTitle("Mass (MeV/c^{2})");
417 fhMassAfterCutsNLocMax1[i] ->SetXTitle("E (GeV)");
418 outputContainer->Add(fhMassAfterCutsNLocMax1[i]) ;
420 fhMassAfterCutsNLocMax2[i] = new TH2F(Form("hMassAfterCutsNLocMax2%s",pname[i].Data()),
421 Form("Mass vs E, %s, for N Local max = 2, asy cut",ptype[i].Data()),
422 nptbins,ptmin,ptmax,mbins,mmin,mmax);
423 fhMassAfterCutsNLocMax2[i] ->SetYTitle("Mass (MeV/c^{2})");
424 fhMassAfterCutsNLocMax2[i] ->SetXTitle("E (GeV)");
425 outputContainer->Add(fhMassAfterCutsNLocMax2[i]) ;
428 fhMassAfterCutsNLocMaxN[i] = new TH2F(Form("hMassAfterCutsNLocMaxN%s",pname[i].Data()),
429 Form("Mass vs E, %s, for N Local max > 2, asy cut",ptype[i].Data()),
430 nptbins,ptmin,ptmax,mbins,mmin,mmax);
431 fhMassAfterCutsNLocMaxN[i] ->SetYTitle("Mass (MeV/c^{2})");
432 fhMassAfterCutsNLocMaxN[i] ->SetXTitle("E (GeV)");
433 outputContainer->Add(fhMassAfterCutsNLocMaxN[i]) ;
435 fhSplitEFractionAfterCutsNLocMax1[i] = new TH2F(Form("hSplitEFractionAfterCutsNLocMax1%s",pname[i].Data()),
436 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 1, M02 and Asy cut on, %s",ptype[i].Data()),
437 nptbins,ptmin,ptmax,120,0,1.2);
438 fhSplitEFractionAfterCutsNLocMax1[i] ->SetXTitle("E_{cluster} (GeV)");
439 fhSplitEFractionAfterCutsNLocMax1[i] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
440 outputContainer->Add(fhSplitEFractionAfterCutsNLocMax1[i]) ;
442 fhSplitEFractionAfterCutsNLocMax2[i] = new TH2F(Form("hSplitEFractionAfterCutsNLocMax2%s",pname[i].Data()),
443 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 2, M02 and Asy cut on, %s",ptype[i].Data()),
444 nptbins,ptmin,ptmax,120,0,1.2);
445 fhSplitEFractionAfterCutsNLocMax2[i] ->SetXTitle("E_{cluster} (GeV)");
446 fhSplitEFractionAfterCutsNLocMax2[i] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
447 outputContainer->Add(fhSplitEFractionAfterCutsNLocMax2[i]) ;
449 fhSplitEFractionAfterCutsNLocMaxN[i] = new TH2F(Form("hSplitEFractionAfterCutsNLocMaxN%s",pname[i].Data()),
450 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max > 2, M02 and Asy cut on, %s",ptype[i].Data()),
451 nptbins,ptmin,ptmax,120,0,1.2);
452 fhSplitEFractionAfterCutsNLocMaxN[i] ->SetXTitle("E_{cluster} (GeV)");
453 fhSplitEFractionAfterCutsNLocMaxN[i] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
454 outputContainer->Add(fhSplitEFractionAfterCutsNLocMaxN[i]) ;
459 fhMassM02NLocMax1[i][j] = new TH2F(Form("hMassM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
460 Form("Invariant mass of splitted cluster with NLM=1, #lambda_{0}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
461 ssbins,ssmin,ssmax,mbins,mmin,mmax);
462 fhMassM02NLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
463 fhMassM02NLocMax1[i][j]->SetXTitle("#lambda_{0}^{2}");
464 outputContainer->Add(fhMassM02NLocMax1[i][j]) ;
466 fhMassM02NLocMax2[i][j] = new TH2F(Form("hMassM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
467 Form("Invariant mass of splitted cluster with NLM=2, #lambda_{0}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
468 ssbins,ssmin,ssmax,mbins,mmin,mmax);
469 fhMassM02NLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
470 fhMassM02NLocMax2[i][j]->SetXTitle("#lambda_{0}^{2}");
471 outputContainer->Add(fhMassM02NLocMax2[i][j]) ;
473 fhMassM02NLocMaxN[i][j] = new TH2F(Form("hMassM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
474 Form("Invariant mass of splitted cluster with NLM>2, vs #lambda_{0}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
475 ssbins,ssmin,ssmax,mbins,mmin,mmax);
476 fhMassM02NLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
477 fhMassM02NLocMaxN[i][j]->SetXTitle("#lambda_{0}^{2}");
478 outputContainer->Add(fhMassM02NLocMaxN[i][j]) ;
481 fhAsymNLocMax1[i][j] = new TH2F(Form("hAsymNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
482 Form("Asymmetry of NLM=1 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
483 nptbins,ptmin,ptmax,200,-1,1);
484 fhAsymNLocMax1[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
485 fhAsymNLocMax1[i][j]->SetXTitle("E (GeV)");
486 outputContainer->Add(fhAsymNLocMax1[i][j]) ;
488 fhAsymNLocMax2[i][j] = new TH2F(Form("hAsymNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
489 Form("Asymmetry of NLM=2 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
490 nptbins,ptmin,ptmax,200,-1,1);
491 fhAsymNLocMax2[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
492 fhAsymNLocMax2[i][j]->SetXTitle("E (GeV)");
493 outputContainer->Add(fhAsymNLocMax2[i][j]) ;
495 fhAsymNLocMaxN[i][j] = new TH2F(Form("hAsymNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
496 Form("Asymmetry of NLM>2 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
497 nptbins,ptmin,ptmax,200,-1,1);
498 fhAsymNLocMaxN[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
499 fhAsymNLocMaxN[i][j]->SetXTitle("E (GeV)");
500 outputContainer->Add(fhAsymNLocMaxN[i][j]) ;
503 if(fFillSSExtraHisto)
505 fhMassDispEtaNLocMax1[i][j] = new TH2F(Form("hMassDispEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
506 Form("Invariant mass of splitted cluster with NLM=1, #sigma_{#eta #eta}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
507 ssbins,ssmin,ssmax,mbins,mmin,mmax);
508 fhMassDispEtaNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
509 fhMassDispEtaNLocMax1[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
510 outputContainer->Add(fhMassDispEtaNLocMax1[i][j]) ;
512 fhMassDispEtaNLocMax2[i][j] = new TH2F(Form("hMassDispEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
513 Form("Invariant mass of splitted cluster with NLM=2 #sigma_{#eta #eta}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
514 ssbins,ssmin,ssmax,mbins,mmin,mmax);
515 fhMassDispEtaNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
516 fhMassDispEtaNLocMax2[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
517 outputContainer->Add(fhMassDispEtaNLocMax2[i][j]) ;
519 fhMassDispEtaNLocMaxN[i][j] = new TH2F(Form("hMassDispEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
520 Form("Invariant mass of splitted cluster with NLM>2, #sigma_{#eta #eta}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
521 ssbins,ssmin,ssmax,mbins,mmin,mmax);
522 fhMassDispEtaNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
523 fhMassDispEtaNLocMaxN[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
524 outputContainer->Add(fhMassDispEtaNLocMaxN[i][j]) ;
526 fhMassDispPhiNLocMax1[i][j] = new TH2F(Form("hMassDispPhiNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
527 Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
528 ssbins,ssmin,ssmax,mbins,mmin,mmax);
529 fhMassDispPhiNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
530 fhMassDispPhiNLocMax1[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
531 outputContainer->Add(fhMassDispPhiNLocMax1[i][j]) ;
533 fhMassDispPhiNLocMax2[i][j] = new TH2F(Form("hMassDispPhiNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
534 Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
535 ssbins,ssmin,ssmax,mbins,mmin,mmax);
536 fhMassDispPhiNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
537 fhMassDispPhiNLocMax2[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
538 outputContainer->Add(fhMassDispPhiNLocMax2[i][j]) ;
540 fhMassDispPhiNLocMaxN[i][j] = new TH2F(Form("hMassDispPhiNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
541 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
542 ssbins,ssmin,ssmax,mbins,mmin,mmax);
543 fhMassDispPhiNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
544 fhMassDispPhiNLocMaxN[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
545 outputContainer->Add(fhMassDispPhiNLocMaxN[i][j]) ;
547 fhMassDispAsyNLocMax1[i][j] = new TH2F(Form("hMassDispAsyNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
548 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()),
549 200,-1,1,mbins,mmin,mmax);
550 fhMassDispAsyNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
551 fhMassDispAsyNLocMax1[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
552 outputContainer->Add(fhMassDispAsyNLocMax1[i][j]) ;
554 fhMassDispAsyNLocMax2[i][j] = new TH2F(Form("hMassDispAsyNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
555 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()),
556 200,-1,1,mbins,mmin,mmax);
557 fhMassDispAsyNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
558 fhMassDispAsyNLocMax2[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
559 outputContainer->Add(fhMassDispAsyNLocMax2[i][j]) ;
561 fhMassDispAsyNLocMaxN[i][j] = new TH2F(Form("hMassDispAsyNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
562 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()),
563 200,-1,1,mbins,mmin,mmax);
564 fhMassDispAsyNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
565 fhMassDispAsyNLocMaxN[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
566 outputContainer->Add(fhMassDispAsyNLocMaxN[i][j]) ;
569 fhNLocMax[i][j] = new TH2F(Form("hNLocMax%s%s",pname[i].Data(),sMatched[j].Data()),
570 Form("Number of local maxima in cluster %s %s",ptype[i].Data(),sMatched[j].Data()),
571 nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
572 fhNLocMax[i][j] ->SetYTitle("N maxima");
573 fhNLocMax[i][j] ->SetXTitle("E (GeV)");
574 outputContainer->Add(fhNLocMax[i][j]) ;
576 fhNLocMaxM02Cut[i][j] = new TH2F(Form("hNLocMaxM02Cut%s%s",pname[i].Data(),sMatched[j].Data()),
577 Form("Number of local maxima in cluster %s for %2.2f < M02 < %2.2f",ptype[i].Data(),fM02MinCut,fM02MaxCut),
578 nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
579 fhNLocMaxM02Cut[i][j]->SetYTitle("N maxima");
580 fhNLocMaxM02Cut[i][j]->SetXTitle("E (GeV)");
581 outputContainer->Add(fhNLocMaxM02Cut[i][j]) ;
584 fhM02NLocMax1[i][j] = new TH2F(Form("hM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
585 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
586 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
587 fhM02NLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
588 fhM02NLocMax1[i][j] ->SetXTitle("E (GeV)");
589 outputContainer->Add(fhM02NLocMax1[i][j]) ;
591 fhM02NLocMax2[i][j] = new TH2F(Form("hM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
592 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
593 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
594 fhM02NLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
595 fhM02NLocMax2[i][j] ->SetXTitle("E (GeV)");
596 outputContainer->Add(fhM02NLocMax2[i][j]) ;
598 fhM02NLocMaxN[i][j] = new TH2F(Form("hM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
599 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
600 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
601 fhM02NLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
602 fhM02NLocMaxN[i][j] ->SetXTitle("E (GeV)");
603 outputContainer->Add(fhM02NLocMaxN[i][j]) ;
606 fhSplitEFractionNLocMax1[i][j] = new TH2F(Form("hSplitEFractionNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
607 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
608 nptbins,ptmin,ptmax,120,0,1.2);
609 fhSplitEFractionNLocMax1[i][j] ->SetXTitle("E_{cluster} (GeV)");
610 fhSplitEFractionNLocMax1[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
611 outputContainer->Add(fhSplitEFractionNLocMax1[i][j]) ;
613 fhSplitEFractionNLocMax2[i][j] = new TH2F(Form("hSplitEFractionNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
614 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
615 nptbins,ptmin,ptmax,120,0,1.2);
616 fhSplitEFractionNLocMax2[i][j] ->SetXTitle("E_{cluster} (GeV)");
617 fhSplitEFractionNLocMax2[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
618 outputContainer->Add(fhSplitEFractionNLocMax2[i][j]) ;
620 fhSplitEFractionNLocMaxN[i][j] = new TH2F(Form("hSplitEFractionNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
621 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
622 nptbins,ptmin,ptmax,120,0,1.2);
623 fhSplitEFractionNLocMaxN[i][j] ->SetXTitle("E_{cluster} (GeV)");
624 fhSplitEFractionNLocMaxN[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
625 outputContainer->Add(fhSplitEFractionNLocMaxN[i][j]) ;
628 if(i > 0 && fFillMCFractionHisto) // skip first entry in array, general case not filled
630 fhMCGenFracNLocMax1[i][j] = new TH2F(Form("hMCGenFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
631 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
632 nptbins,ptmin,ptmax,200,0,2);
633 fhMCGenFracNLocMax1[i][j] ->SetYTitle("E_{gen} / E_{reco}");
634 fhMCGenFracNLocMax1[i][j] ->SetXTitle("E (GeV)");
635 outputContainer->Add(fhMCGenFracNLocMax1[i][j]) ;
637 fhMCGenFracNLocMax2[i][j] = new TH2F(Form("hMCGenFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
638 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
639 nptbins,ptmin,ptmax,200,0,2);
640 fhMCGenFracNLocMax2[i][j] ->SetYTitle("E_{gen} / E_{reco}");
641 fhMCGenFracNLocMax2[i][j] ->SetXTitle("E (GeV)");
642 outputContainer->Add(fhMCGenFracNLocMax2[i][j]) ;
645 fhMCGenFracNLocMaxN[i][j] = new TH2F(Form("hMCGenFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
646 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
647 nptbins,ptmin,ptmax,200,0,2);
648 fhMCGenFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / E_{reco}");
649 fhMCGenFracNLocMaxN[i][j] ->SetXTitle("E (GeV)");
650 outputContainer->Add(fhMCGenFracNLocMaxN[i][j]) ;
652 fhMCGenSplitEFracNLocMax1[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
653 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
654 nptbins,ptmin,ptmax,200,0,2);
655 fhMCGenSplitEFracNLocMax1[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
656 fhMCGenSplitEFracNLocMax1[i][j] ->SetXTitle("E (GeV)");
657 outputContainer->Add(fhMCGenSplitEFracNLocMax1[i][j]) ;
659 fhMCGenSplitEFracNLocMax2[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
660 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
661 nptbins,ptmin,ptmax,200,0,2);
662 fhMCGenSplitEFracNLocMax2[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
663 fhMCGenSplitEFracNLocMax2[i][j] ->SetXTitle("E (GeV)");
664 outputContainer->Add(fhMCGenSplitEFracNLocMax2[i][j]) ;
667 fhMCGenSplitEFracNLocMaxN[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
668 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
669 nptbins,ptmin,ptmax,200,0,2);
670 fhMCGenSplitEFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
671 fhMCGenSplitEFracNLocMaxN[i][j] ->SetXTitle("E (GeV)");
672 outputContainer->Add(fhMCGenSplitEFracNLocMaxN[i][j]) ;
674 fhMCGenEFracvsSplitEFracNLocMax1[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
675 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()),
677 fhMCGenEFracvsSplitEFracNLocMax1[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
678 fhMCGenEFracvsSplitEFracNLocMax1[i][j] ->SetXTitle("E_{gen} / E_{reco}");
679 outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMax1[i][j]) ;
681 fhMCGenEFracvsSplitEFracNLocMax2[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
682 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()),
684 fhMCGenEFracvsSplitEFracNLocMax2[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
685 fhMCGenEFracvsSplitEFracNLocMax2[i][j] ->SetXTitle("E_{gen} / E_{reco}");
686 outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMax2[i][j]) ;
689 fhMCGenEFracvsSplitEFracNLocMaxN[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
690 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()),
692 fhMCGenEFracvsSplitEFracNLocMaxN[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
693 fhMCGenEFracvsSplitEFracNLocMaxN[i][j] ->SetXTitle("E_{gen} / E_{reco}");
694 outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMaxN[i][j]) ;
697 fhMCGenEvsSplitENLocMax1[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
698 Form("E_{1 split}+E_{2 split} vs E_{gen} for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
699 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
700 fhMCGenEvsSplitENLocMax1[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
701 fhMCGenEvsSplitENLocMax1[i][j] ->SetXTitle("E_{gen} (GeV)");
702 outputContainer->Add(fhMCGenEvsSplitENLocMax1[i][j]) ;
704 fhMCGenEvsSplitENLocMax2[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
705 Form("E_{1 split}+E_{2 split} vs E_{gen} for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
706 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
707 fhMCGenEvsSplitENLocMax2[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
708 fhMCGenEvsSplitENLocMax2[i][j] ->SetXTitle("E_{gen} (GeV)");
709 outputContainer->Add(fhMCGenEvsSplitENLocMax2[i][j]) ;
712 fhMCGenEvsSplitENLocMaxN[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
713 Form("E_{1 split}+E_{2 split} vs E_{gen} for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
714 nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
715 fhMCGenEvsSplitENLocMaxN[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
716 fhMCGenEvsSplitENLocMaxN[i][j] ->SetXTitle("E_{gen} (GeV)");
717 outputContainer->Add(fhMCGenEvsSplitENLocMaxN[i][j]) ;
721 if(fFillSSExtraHisto)
723 fhNCellNLocMax1[i][j] = new TH2F(Form("hNCellNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
724 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
725 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
726 fhNCellNLocMax1[i][j] ->SetYTitle("N cells");
727 fhNCellNLocMax1[i][j] ->SetXTitle("E (GeV)");
728 outputContainer->Add(fhNCellNLocMax1[i][j]) ;
730 fhNCellNLocMax2[i][j] = new TH2F(Form("hNCellNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
731 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
732 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
733 fhNCellNLocMax2[i][j] ->SetYTitle("N cells");
734 fhNCellNLocMax2[i][j] ->SetXTitle("E (GeV)");
735 outputContainer->Add(fhNCellNLocMax2[i][j]) ;
738 fhNCellNLocMaxN[i][j] = new TH2F(Form("hNCellNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
739 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
740 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
741 fhNCellNLocMaxN[i][j] ->SetYTitle("N cells");
742 fhNCellNLocMaxN[i][j] ->SetXTitle("E (GeV)");
743 outputContainer->Add(fhNCellNLocMaxN[i][j]) ;
746 fhM02Pi0NLocMax1[i][j] = new TH2F(Form("hM02Pi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
747 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1",
748 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
749 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
750 fhM02Pi0NLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
751 fhM02Pi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
752 outputContainer->Add(fhM02Pi0NLocMax1[i][j]) ;
754 fhM02EtaNLocMax1[i][j] = new TH2F(Form("hM02EtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
755 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1",
756 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
757 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
758 fhM02EtaNLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
759 fhM02EtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
760 outputContainer->Add(fhM02EtaNLocMax1[i][j]) ;
762 fhM02ConNLocMax1[i][j] = new TH2F(Form("hM02ConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
763 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1",
764 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
765 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
766 fhM02ConNLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
767 fhM02ConNLocMax1[i][j] ->SetXTitle("E (GeV)");
768 outputContainer->Add(fhM02ConNLocMax1[i][j]) ;
770 fhM02Pi0NLocMax2[i][j] = new TH2F(Form("hM02Pi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
771 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2",
772 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
773 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
774 fhM02Pi0NLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
775 fhM02Pi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
776 outputContainer->Add(fhM02Pi0NLocMax2[i][j]) ;
778 fhM02EtaNLocMax2[i][j] = new TH2F(Form("hM02EtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
779 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2",
780 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
781 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
782 fhM02EtaNLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
783 fhM02EtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
784 outputContainer->Add(fhM02EtaNLocMax2[i][j]) ;
786 fhM02ConNLocMax2[i][j] = new TH2F(Form("hM02ConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
787 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2",
788 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
789 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
790 fhM02ConNLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
791 fhM02ConNLocMax2[i][j] ->SetXTitle("E (GeV)");
792 outputContainer->Add(fhM02ConNLocMax2[i][j]) ;
794 fhM02Pi0NLocMaxN[i][j] = new TH2F(Form("hM02Pi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
795 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2",
796 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
797 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
798 fhM02Pi0NLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
799 fhM02Pi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
800 outputContainer->Add(fhM02Pi0NLocMaxN[i][j]) ;
802 fhM02EtaNLocMaxN[i][j] = new TH2F(Form("hM02EtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
803 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max > 2",
804 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
805 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
806 fhM02EtaNLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
807 fhM02EtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
808 outputContainer->Add(fhM02EtaNLocMaxN[i][j]) ;
810 fhM02ConNLocMaxN[i][j] = new TH2F(Form("hM02ConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
811 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2",
812 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
813 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
814 fhM02ConNLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
815 fhM02ConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
816 outputContainer->Add(fhM02ConNLocMaxN[i][j]) ;
819 fhMassPi0NLocMax1[i][j] = new TH2F(Form("hMassPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
820 Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1",
821 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
822 nptbins,ptmin,ptmax,mbins,mmin,mmax);
823 fhMassPi0NLocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})");
824 fhMassPi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
825 outputContainer->Add(fhMassPi0NLocMax1[i][j]) ;
828 fhMassEtaNLocMax1[i][j] = new TH2F(Form("hMassEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
829 Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1",
830 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
831 nptbins,ptmin,ptmax,mbins,mmin,mmax);
832 fhMassEtaNLocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})");
833 fhMassEtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
834 outputContainer->Add(fhMassEtaNLocMax1[i][j]) ;
836 fhMassConNLocMax1[i][j] = new TH2F(Form("hMassConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
837 Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1",
838 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
839 nptbins,ptmin,ptmax,mbins,mmin,mmax);
840 fhMassConNLocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})");
841 fhMassConNLocMax1[i][j] ->SetXTitle("E (GeV)");
842 outputContainer->Add(fhMassConNLocMax1[i][j]) ;
844 fhMassPi0NLocMax2[i][j] = new TH2F(Form("hMassPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
845 Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2",
846 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
847 nptbins,ptmin,ptmax,mbins,mmin,mmax);
848 fhMassPi0NLocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})");
849 fhMassPi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
850 outputContainer->Add(fhMassPi0NLocMax2[i][j]) ;
853 fhMassEtaNLocMax2[i][j] = new TH2F(Form("hMassEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
854 Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2",
855 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
856 nptbins,ptmin,ptmax,mbins,mmin,mmax);
857 fhMassEtaNLocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})");
858 fhMassEtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
859 outputContainer->Add(fhMassEtaNLocMax2[i][j]) ;
861 fhMassConNLocMax2[i][j] = new TH2F(Form("hMassConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
862 Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2",
863 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
864 nptbins,ptmin,ptmax,mbins,mmin,mmax);
865 fhMassConNLocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})");
866 fhMassConNLocMax2[i][j] ->SetXTitle("E (GeV)");
867 outputContainer->Add(fhMassConNLocMax2[i][j]) ;
869 fhMassPi0NLocMaxN[i][j] = new TH2F(Form("hMassPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
870 Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2",
871 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
872 nptbins,ptmin,ptmax,mbins,mmin,mmax);
873 fhMassPi0NLocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})");
874 fhMassPi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
875 outputContainer->Add(fhMassPi0NLocMaxN[i][j]) ;
877 fhMassEtaNLocMaxN[i][j] = new TH2F(Form("hMassEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
878 Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max > 2",
879 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
880 nptbins,ptmin,ptmax,mbins,mmin,mmax);
881 fhMassEtaNLocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})");
882 fhMassEtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
883 outputContainer->Add(fhMassEtaNLocMaxN[i][j]) ;
885 fhMassConNLocMaxN[i][j] = new TH2F(Form("hMassConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
886 Form("Mass vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2",
887 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
888 nptbins,ptmin,ptmax,mbins,mmin,mmax);
889 fhMassConNLocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})");
890 fhMassConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
891 outputContainer->Add(fhMassConNLocMaxN[i][j]) ;
894 fhAsyPi0NLocMax1[i][j] = new TH2F(Form("hAsyPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
895 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1",
896 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
897 nptbins,ptmin,ptmax,mbins,mmin,mmax);
898 fhAsyPi0NLocMax1[i][j] ->SetYTitle("Asymmetry");
899 fhAsyPi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
900 outputContainer->Add(fhAsyPi0NLocMax1[i][j]) ;
902 fhAsyEtaNLocMax1[i][j] = new TH2F(Form("hAsyEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
903 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1",
904 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
905 nptbins,ptmin,ptmax,mbins,mmin,mmax);
906 fhAsyEtaNLocMax1[i][j] ->SetYTitle("Asymmetry");
907 fhAsyEtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
908 outputContainer->Add(fhAsyEtaNLocMax1[i][j]) ;
910 fhAsyConNLocMax1[i][j] = new TH2F(Form("hAsyConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
911 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1",
912 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
913 nptbins,ptmin,ptmax,mbins,mmin,mmax);
914 fhAsyConNLocMax1[i][j] ->SetYTitle("Asymmetry");
915 fhAsyConNLocMax1[i][j] ->SetXTitle("E (GeV)");
916 outputContainer->Add(fhAsyConNLocMax1[i][j]) ;
918 fhAsyPi0NLocMax2[i][j] = new TH2F(Form("hAsyPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
919 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2",
920 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
921 nptbins,ptmin,ptmax,mbins,mmin,mmax);
922 fhAsyPi0NLocMax2[i][j] ->SetYTitle("Asymmetry");
923 fhAsyPi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
924 outputContainer->Add(fhAsyPi0NLocMax2[i][j]) ;
926 fhAsyEtaNLocMax2[i][j] = new TH2F(Form("hAsyEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
927 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2",
928 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
929 nptbins,ptmin,ptmax,mbins,mmin,mmax);
930 fhAsyEtaNLocMax2[i][j] ->SetYTitle("Asymmetry");
931 fhAsyEtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
932 outputContainer->Add(fhAsyEtaNLocMax2[i][j]) ;
934 fhAsyConNLocMax2[i][j] = new TH2F(Form("hAsyConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
935 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2",
936 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
937 nptbins,ptmin,ptmax,mbins,mmin,mmax);
938 fhAsyConNLocMax2[i][j] ->SetYTitle("Asymmetry");
939 fhAsyConNLocMax2[i][j] ->SetXTitle("E (GeV)");
940 outputContainer->Add(fhAsyConNLocMax2[i][j]) ;
942 fhAsyPi0NLocMaxN[i][j] = new TH2F(Form("hAsyPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
943 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2",
944 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
945 nptbins,ptmin,ptmax,mbins,mmin,mmax);
946 fhAsyPi0NLocMaxN[i][j] ->SetYTitle("Asymmetry");
947 fhAsyPi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
948 outputContainer->Add(fhAsyPi0NLocMaxN[i][j]) ;
950 fhAsyEtaNLocMaxN[i][j] = new TH2F(Form("hAsyEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
951 Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max > 2",
952 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
953 nptbins,ptmin,ptmax,mbins,mmin,mmax);
954 fhAsyEtaNLocMaxN[i][j] ->SetYTitle("Asymmetry");
955 fhAsyEtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
956 outputContainer->Add(fhAsyEtaNLocMaxN[i][j]) ;
958 fhAsyConNLocMaxN[i][j] = new TH2F(Form("hAsyConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
959 Form("Asymmetry vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2",
960 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
961 nptbins,ptmin,ptmax,mbins,mmin,mmax);
962 fhAsyConNLocMaxN[i][j] ->SetYTitle("Asymmetry");
963 fhAsyConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
964 outputContainer->Add(fhAsyConNLocMaxN[i][j]) ;
966 } // matched, not matched
968 for(Int_t j = 0; j < 4; j++)
971 fhMassSplitEFractionNLocMax1Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax1%sEbin%d",pname[i].Data(),j),
972 Form("Invariant mass of 2 highest energy cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
973 120,0,1.2,mbins,mmin,mmax);
974 fhMassSplitEFractionNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
975 fhMassSplitEFractionNLocMax1Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
976 outputContainer->Add(fhMassSplitEFractionNLocMax1Ebin[i][j]) ;
978 fhMassSplitEFractionNLocMax2Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax2%sEbin%d",pname[i].Data(),j),
979 Form("Invariant mass of 2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
980 120,0,1.2,mbins,mmin,mmax);
981 fhMassSplitEFractionNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
982 fhMassSplitEFractionNLocMax2Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
983 outputContainer->Add(fhMassSplitEFractionNLocMax2Ebin[i][j]) ;
985 fhMassSplitEFractionNLocMaxNEbin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMaxN%sEbin%d",pname[i].Data(),j),
986 Form("Invariant mass of N>2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
987 120,0,1.2,mbins,mmin,mmax);
988 fhMassSplitEFractionNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
989 fhMassSplitEFractionNLocMaxNEbin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
990 outputContainer->Add(fhMassSplitEFractionNLocMaxNEbin[i][j]) ;
992 if(i>0 && fFillMCFractionHisto) // skip first entry in array, general case not filled
994 fhMCGenFracNLocMaxEbin[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%d",pname[i].Data(),j),
995 Form("NLM vs E, %s, E bin %d",ptype[i].Data(),j),
996 200,0,2,nMaxBins,0,nMaxBins);
997 fhMCGenFracNLocMaxEbin[i][j]->SetYTitle("NLM");
998 fhMCGenFracNLocMaxEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
999 outputContainer->Add(fhMCGenFracNLocMaxEbin[i][j]) ;
1001 fhMCGenFracNLocMaxEbinMatched[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%dMatched",pname[i].Data(),j),
1002 Form("NLM vs E, %s, E bin %d, matched to a track",ptype[i].Data(),j),
1003 200,0,2,nMaxBins,0,nMaxBins);
1004 fhMCGenFracNLocMaxEbinMatched[i][j]->SetYTitle("NLM");
1005 fhMCGenFracNLocMaxEbinMatched[i][j]->SetXTitle("E_{gen} / E_{reco}");
1006 outputContainer->Add(fhMCGenFracNLocMaxEbinMatched[i][j]) ;
1008 fhMassMCGenFracNLocMax1Ebin[i][j] = new TH2F(Form("hMassMCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
1009 Form("Invariant mass of 2 highest energy cells vs E, %s, E bin %d",ptype[i].Data(),j),
1010 200,0,2,mbins,mmin,mmax);
1011 fhMassMCGenFracNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
1012 fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
1013 outputContainer->Add(fhMassMCGenFracNLocMax1Ebin[i][j]) ;
1015 fhMassMCGenFracNLocMax2Ebin[i][j] = new TH2F(Form("hMassMCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
1016 Form("Invariant mass of 2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
1017 200,0,2,mbins,mmin,mmax);
1018 fhMassMCGenFracNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
1019 fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
1020 outputContainer->Add(fhMassMCGenFracNLocMax2Ebin[i][j]) ;
1022 fhMassMCGenFracNLocMaxNEbin[i][j] = new TH2F(Form("hMassMCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
1023 Form("Invariant mass of N>2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
1024 200,0,2,mbins,mmin,mmax);
1025 fhMassMCGenFracNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
1026 fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
1027 outputContainer->Add(fhMassMCGenFracNLocMaxNEbin[i][j]) ;
1029 fhM02MCGenFracNLocMax1Ebin[i][j] = new TH2F(Form("hM02MCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
1030 Form("#lambda_{0}^{2} vs E for N max = 1 %s, E bin %d",ptype[i].Data(), j),
1031 200,0,2,ssbins,ssmin,ssmax);
1032 fhM02MCGenFracNLocMax1Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}");
1033 fhM02MCGenFracNLocMax1Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
1034 outputContainer->Add(fhM02MCGenFracNLocMax1Ebin[i][j]) ;
1036 fhM02MCGenFracNLocMax2Ebin[i][j] = new TH2F(Form("hM02MCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
1037 Form("#lambda_{0}^{2} vs E for N max = 2 %s, E bin %d",ptype[i].Data(),j),
1038 200,0,2,ssbins,ssmin,ssmax);
1039 fhM02MCGenFracNLocMax2Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}");
1040 fhM02MCGenFracNLocMax2Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
1041 outputContainer->Add(fhM02MCGenFracNLocMax2Ebin[i][j]) ;
1043 fhM02MCGenFracNLocMaxNEbin[i][j] = new TH2F(Form("hM02MCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
1044 Form("#lambda_{0}^{2} vs E for N max > 2 %s, E bin %d",ptype[i].Data(),j),
1045 200,0,2,ssbins,ssmin,ssmax);
1046 fhM02MCGenFracNLocMaxNEbin[i][j] ->SetYTitle("#lambda_{0}^{2}");
1047 fhM02MCGenFracNLocMaxNEbin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
1048 outputContainer->Add(fhM02MCGenFracNLocMaxNEbin[i][j]) ;
1051 } // MC particle list
1053 for(Int_t i = 0; i < 4; i++)
1055 fhMassM02NLocMax1Ebin[i] = new TH2F(Form("hMassM02NLocMax1Ebin%d",i),
1056 Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
1057 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1058 fhMassM02NLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1059 fhMassM02NLocMax1Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1060 outputContainer->Add(fhMassM02NLocMax1Ebin[i]) ;
1062 fhMassM02NLocMax2Ebin[i] = new TH2F(Form("hMassM02NLocMax2Ebin%d",i),
1063 Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
1064 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1065 fhMassM02NLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1066 fhMassM02NLocMax2Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1067 outputContainer->Add(fhMassM02NLocMax2Ebin[i]) ;
1069 fhMassM02NLocMaxNEbin[i] = new TH2F(Form("hMassM02NLocMaxNEbin%d",i),
1070 Form("Invariant mass of split clusters vs vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
1071 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1072 fhMassM02NLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1073 fhMassM02NLocMaxNEbin[i]->SetXTitle("#lambda_{0}^{2}");
1074 outputContainer->Add(fhMassM02NLocMaxNEbin[i]) ;
1077 fhMassAsyNLocMax1Ebin[i] = new TH2F(Form("hMassAsyNLocMax1Ebin%d",i),
1078 Form("Invariant mass of split clusters vs split asymmetry, NLM=1, E bin %d",i),
1079 200,-1,1,mbins,mmin,mmax);
1080 fhMassAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1081 fhMassAsyNLocMax1Ebin[i]->SetXTitle("asymmetry");
1082 outputContainer->Add(fhMassAsyNLocMax1Ebin[i]) ;
1084 fhMassAsyNLocMax2Ebin[i] = new TH2F(Form("hMassAsyNLocMax2Ebin%d",i),
1085 Form("Invariant mass of split clusters vs split asymmetry, NLM=2, E bin %d",i),
1086 200,-1,1,mbins,mmin,mmax);
1087 fhMassAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1088 fhMassAsyNLocMax2Ebin[i]->SetXTitle("asymmetry");
1089 outputContainer->Add(fhMassAsyNLocMax2Ebin[i]) ;
1091 fhMassAsyNLocMaxNEbin[i] = new TH2F(Form("hMassAsyNLocMaxNEbin%d",i),
1092 Form("Invariant mass of split clusters vs split asymmetry, NLM>2, E bin %d",i),
1093 200,-1,1,mbins,mmin,mmax);
1094 fhMassAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1095 fhMassAsyNLocMaxNEbin[i]->SetXTitle("asymmetry");
1096 outputContainer->Add(fhMassAsyNLocMaxNEbin[i]) ;
1101 fhMCAsymM02NLocMax1MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax1MCPi0Ebin%d",i),
1102 Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
1103 ssbins,ssmin,ssmax,100,0,1);
1104 fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
1105 fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1106 outputContainer->Add(fhMCAsymM02NLocMax1MCPi0Ebin[i]) ;
1108 fhMCAsymM02NLocMax2MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax2MCPi0Ebin%d",i),
1109 Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
1110 ssbins,ssmin,ssmax,100,0,1);
1111 fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
1112 fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1113 outputContainer->Add(fhMCAsymM02NLocMax2MCPi0Ebin[i]) ;
1115 fhMCAsymM02NLocMaxNMCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMaxNMCPi0Ebin%d",i),
1116 Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
1117 ssbins,ssmin,ssmax,100,0,1);
1118 fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetYTitle("Decay asymmetry");
1119 fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
1120 outputContainer->Add(fhMCAsymM02NLocMaxNMCPi0Ebin[i]) ;
1123 fhAsyMCGenRecoNLocMax1EbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMax1Ebin%dPi0",i),
1124 Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=1, E bin %d",i),
1126 fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1127 fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetXTitle("asymmetry");
1128 outputContainer->Add(fhAsyMCGenRecoNLocMax1EbinPi0[i]) ;
1130 fhAsyMCGenRecoNLocMax2EbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMax2Ebin%dPi0",i),
1131 Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=2, E bin %d",i),
1133 fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1134 fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetXTitle("asymmetry");
1135 outputContainer->Add(fhAsyMCGenRecoNLocMax2EbinPi0[i]) ;
1137 fhAsyMCGenRecoNLocMaxNEbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMaxNEbin%dPi0",i),
1138 Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM>2, E bin %d",i),
1140 fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1141 fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetXTitle("asymmetry");
1142 outputContainer->Add(fhAsyMCGenRecoNLocMaxNEbinPi0[i]) ;
1145 if(fFillSSExtraHisto)
1147 fhMassDispEtaNLocMax1Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax1Ebin%d",i),
1148 Form("Invariant mass of 2 highest energy cells #sigma_{#eta #eta}^{2}, E bin %d",i),
1149 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1150 fhMassDispEtaNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1151 fhMassDispEtaNLocMax1Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
1152 outputContainer->Add(fhMassDispEtaNLocMax1Ebin[i]) ;
1154 fhMassDispEtaNLocMax2Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax2Ebin%d",i),
1155 Form("Invariant mass of 2 local maxima cells #sigma_{#eta #eta}^{2}, E bin %d",i),
1156 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1157 fhMassDispEtaNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1158 fhMassDispEtaNLocMax2Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
1159 outputContainer->Add(fhMassDispEtaNLocMax2Ebin[i]) ;
1161 fhMassDispEtaNLocMaxNEbin[i] = new TH2F(Form("hMassDispEtaNLocMaxNEbin%d",i),
1162 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#eta #eta}^{2}, E bin %d",i),
1163 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1164 fhMassDispEtaNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1165 fhMassDispEtaNLocMaxNEbin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
1166 outputContainer->Add(fhMassDispEtaNLocMaxNEbin[i]) ;
1168 fhMassDispPhiNLocMax1Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax1Ebin%d",i),
1169 Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E bin %d",i),
1170 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1171 fhMassDispPhiNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1172 fhMassDispPhiNLocMax1Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
1173 outputContainer->Add(fhMassDispPhiNLocMax1Ebin[i]) ;
1175 fhMassDispPhiNLocMax2Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax2Ebin%d",i),
1176 Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E bin %d",i),
1177 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1178 fhMassDispPhiNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1179 fhMassDispPhiNLocMax2Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
1180 outputContainer->Add(fhMassDispPhiNLocMax2Ebin[i]) ;
1182 fhMassDispPhiNLocMaxNEbin[i] = new TH2F(Form("hMassDispPhiNLocMaxNEbin%d",i),
1183 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, E bin %d",i),
1184 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1185 fhMassDispPhiNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1186 fhMassDispPhiNLocMaxNEbin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
1187 outputContainer->Add(fhMassDispPhiNLocMaxNEbin[i]) ;
1189 fhMassDispAsyNLocMax1Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax1Ebin%d",i),
1190 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),
1191 200,-1,1,mbins,mmin,mmax);
1192 fhMassDispAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
1193 fhMassDispAsyNLocMax1Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
1194 outputContainer->Add(fhMassDispAsyNLocMax1Ebin[i]) ;
1196 fhMassDispAsyNLocMax2Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax2Ebin%d",i),
1197 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),
1198 200,-1,1,mbins,mmin,mmax);
1199 fhMassDispAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
1200 fhMassDispAsyNLocMax2Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
1201 outputContainer->Add(fhMassDispAsyNLocMax2Ebin[i]) ;
1203 fhMassDispAsyNLocMaxNEbin[i] = new TH2F(Form("hMassDispAsyNLocMaxNEbin%d",i),
1204 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),
1205 200,-1,1,mbins,mmin,mmax);
1206 fhMassDispAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1207 fhMassDispAsyNLocMaxNEbin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
1208 outputContainer->Add(fhMassDispAsyNLocMaxNEbin[i]) ;
1212 fhMassSplitECutNLocMax1 = new TH2F("hMassSplitECutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, (E1+E2)/E cut",
1213 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1214 fhMassSplitECutNLocMax1->SetYTitle("M (GeV/c^{2})");
1215 fhMassSplitECutNLocMax1->SetXTitle("E (GeV)");
1216 outputContainer->Add(fhMassSplitECutNLocMax1) ;
1218 fhMassSplitECutNLocMax2 = new TH2F("hMassSplitECutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, (E1+E2)/E cut",
1219 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1220 fhMassSplitECutNLocMax2->SetYTitle("M (GeV/c^{2})");
1221 fhMassSplitECutNLocMax2->SetXTitle("E (GeV)");
1222 outputContainer->Add(fhMassSplitECutNLocMax2) ;
1224 fhMassSplitECutNLocMaxN = new TH2F("hMassSplitECutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, (E1+E2)/E cut",
1225 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1226 fhMassSplitECutNLocMaxN->SetYTitle("M (GeV/c^{2})");
1227 fhMassSplitECutNLocMaxN->SetXTitle("E (GeV)");
1228 outputContainer->Add(fhMassSplitECutNLocMaxN) ;
1230 fhMassM02CutNLocMax1 = new TH2F("hMassM02CutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, M02 cut",
1231 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1232 fhMassM02CutNLocMax1->SetYTitle("M (GeV/c^{2})");
1233 fhMassM02CutNLocMax1->SetXTitle("E (GeV)");
1234 outputContainer->Add(fhMassM02CutNLocMax1) ;
1236 fhMassM02CutNLocMax2 = new TH2F("hMassM02CutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, M02 cut",
1237 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1238 fhMassM02CutNLocMax2->SetYTitle("M (GeV/c^{2})");
1239 fhMassM02CutNLocMax2->SetXTitle("E (GeV)");
1240 outputContainer->Add(fhMassM02CutNLocMax2) ;
1242 fhMassM02CutNLocMaxN = new TH2F("hMassM02CutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, M02 cut",
1243 nptbins,ptmin,ptmax,mbins,mmin,mmax);
1244 fhMassM02CutNLocMaxN->SetYTitle("M (GeV/c^{2})");
1245 fhMassM02CutNLocMaxN->SetXTitle("E (GeV)");
1246 outputContainer->Add(fhMassM02CutNLocMaxN) ;
1248 fhAsymM02CutNLocMax1 = new TH2F("hAsymM02CutNLocMax1","Asymmetry of NLM=1 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1);
1249 fhAsymM02CutNLocMax1->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
1250 fhAsymM02CutNLocMax1->SetXTitle("E (GeV)");
1251 outputContainer->Add(fhAsymM02CutNLocMax1) ;
1253 fhAsymM02CutNLocMax2 = new TH2F("hAsymM02CutNLocMax2","Asymmetry of NLM=2 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1);
1254 fhAsymM02CutNLocMax2->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
1255 fhAsymM02CutNLocMax2->SetXTitle("E (GeV)");
1256 outputContainer->Add(fhAsymM02CutNLocMax2) ;
1258 fhAsymM02CutNLocMaxN = new TH2F("hAsymM02CutNLocMaxN","Asymmetry of NLM>2 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1);
1259 fhAsymM02CutNLocMaxN->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
1260 fhAsymM02CutNLocMaxN->SetXTitle("E (GeV)");
1261 outputContainer->Add(fhAsymM02CutNLocMaxN) ;
1263 if(IsDataMC() && fFillMCFractionHisto)
1265 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMax1MCPi0",
1266 "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 1 MC Pi0, after M02 and Asym cut",
1267 nptbins,ptmin,ptmax,200,0,2);
1268 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
1269 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 ->SetXTitle("E (GeV)");
1270 outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMax1MCPi0) ;
1272 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMax2MCPi0",
1273 "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 2 MC Pi0, after M02 and Asym cut",
1274 nptbins,ptmin,ptmax,200,0,2);
1275 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
1276 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 ->SetXTitle("E (GeV)");
1277 outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMax2MCPi0) ;
1280 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMaxNMCPi0",
1281 "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max > 2 MC Pi0, after M02 and Asym cut",
1282 nptbins,ptmin,ptmax,200,0,2);
1283 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
1284 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 ->SetXTitle("E (GeV)");
1285 outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0) ;
1287 fhMCGenFracAfterCutsNLocMax1MCPi0 = new TH2F("hMCGenFracAfterCutsNLocMax1MCPi0",
1288 "E_{gen} / E_{reco} vs E_{reco} for N max = 1 MC Pi0, after M02 and Asym cut",
1289 nptbins,ptmin,ptmax,200,0,2);
1290 fhMCGenFracAfterCutsNLocMax1MCPi0 ->SetYTitle("E_{gen} / E_{reco}");
1291 fhMCGenFracAfterCutsNLocMax1MCPi0 ->SetXTitle("E (GeV)");
1292 outputContainer->Add(fhMCGenFracAfterCutsNLocMax1MCPi0) ;
1294 fhMCGenFracAfterCutsNLocMax2MCPi0 = new TH2F("hMCGenFracAfterCutsNLocMax2MCPi0",
1295 " E_{gen} / E_{reco} vs E_{reco} for N max = 2 MC Pi0, after M02 and Asym cut",
1296 nptbins,ptmin,ptmax,200,0,2);
1297 fhMCGenFracAfterCutsNLocMax2MCPi0 ->SetYTitle("E_{gen} / E_{reco}");
1298 fhMCGenFracAfterCutsNLocMax2MCPi0 ->SetXTitle("E (GeV)");
1299 outputContainer->Add(fhMCGenFracAfterCutsNLocMax2MCPi0) ;
1302 fhMCGenFracAfterCutsNLocMaxNMCPi0 = new TH2F("hMCGenFracAfterCutsNLocMaxNMCPi0",
1303 " E_{gen} / E_{reco} vs E_{reco} for N max > 2 MC Pi0, after M02 and Asym cut",
1304 nptbins,ptmin,ptmax,200,0,2);
1305 fhMCGenFracAfterCutsNLocMaxNMCPi0 ->SetYTitle("E_{gen} / E_{reco}");
1306 fhMCGenFracAfterCutsNLocMaxNMCPi0 ->SetXTitle("E (GeV)");
1307 outputContainer->Add(fhMCGenFracAfterCutsNLocMaxNMCPi0) ;
1311 if(fFillTMResidualHisto)
1313 for(Int_t i = 0; i < n; i++)
1316 fhTrackMatchedDEtaNLocMax1[i] = new TH2F
1317 (Form("hTrackMatchedDEtaNLocMax1%s",pname[i].Data()),
1318 Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
1319 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1320 fhTrackMatchedDEtaNLocMax1[i]->SetYTitle("d#eta");
1321 fhTrackMatchedDEtaNLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
1323 fhTrackMatchedDPhiNLocMax1[i] = new TH2F
1324 (Form("hTrackMatchedDPhiNLocMax1%s",pname[i].Data()),
1325 Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
1326 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1327 fhTrackMatchedDPhiNLocMax1[i]->SetYTitle("d#phi (rad)");
1328 fhTrackMatchedDPhiNLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
1330 outputContainer->Add(fhTrackMatchedDEtaNLocMax1[i]) ;
1331 outputContainer->Add(fhTrackMatchedDPhiNLocMax1[i]) ;
1333 fhTrackMatchedDEtaNLocMax2[i] = new TH2F
1334 (Form("hTrackMatchedDEtaNLocMax2%s",pname[i].Data()),
1335 Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
1336 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1337 fhTrackMatchedDEtaNLocMax2[i]->SetYTitle("d#eta");
1338 fhTrackMatchedDEtaNLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
1340 fhTrackMatchedDPhiNLocMax2[i] = new TH2F
1341 (Form("hTrackMatchedDPhiNLocMax2%s",pname[i].Data()),
1342 Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
1343 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1344 fhTrackMatchedDPhiNLocMax2[i]->SetYTitle("d#phi (rad)");
1345 fhTrackMatchedDPhiNLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
1347 outputContainer->Add(fhTrackMatchedDEtaNLocMax2[i]) ;
1348 outputContainer->Add(fhTrackMatchedDPhiNLocMax2[i]) ;
1350 fhTrackMatchedDEtaNLocMaxN[i] = new TH2F
1351 (Form("hTrackMatchedDEtaNLocMaxN%s",pname[i].Data()),
1352 Form("d#eta of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
1353 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
1354 fhTrackMatchedDEtaNLocMaxN[i]->SetYTitle("d#eta");
1355 fhTrackMatchedDEtaNLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
1357 fhTrackMatchedDPhiNLocMaxN[i] = new TH2F
1358 (Form("hTrackMatchedDPhiNLocMaxN%s",pname[i].Data()),
1359 Form("d#phi of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
1360 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
1361 fhTrackMatchedDPhiNLocMaxN[i]->SetYTitle("d#phi (rad)");
1362 fhTrackMatchedDPhiNLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
1364 outputContainer->Add(fhTrackMatchedDEtaNLocMaxN[i]) ;
1365 outputContainer->Add(fhTrackMatchedDPhiNLocMaxN[i]) ;
1371 for(Int_t j = 0; j < 2; j++)
1374 fhAnglePairNLocMax1[j] = new TH2F(Form("hAnglePairNLocMax1%s",sMatched[j].Data()),
1375 Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()),
1376 nptbins,ptmin,ptmax,200,0,0.2);
1377 fhAnglePairNLocMax1[j]->SetYTitle("#alpha (rad)");
1378 fhAnglePairNLocMax1[j]->SetXTitle("E (GeV)");
1379 outputContainer->Add(fhAnglePairNLocMax1[j]) ;
1381 fhAnglePairNLocMax2[j] = new TH2F(Form("hAnglePairNLocMax2%s",sMatched[j].Data()),
1382 Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()),
1383 nptbins,ptmin,ptmax,200,0,0.2);
1384 fhAnglePairNLocMax2[j]->SetYTitle("#alpha (rad)");
1385 fhAnglePairNLocMax2[j]->SetXTitle("E (GeV)");
1386 outputContainer->Add(fhAnglePairNLocMax2[j]) ;
1388 fhAnglePairNLocMaxN[j] = new TH2F(Form("hAnglePairNLocMaxN%s",sMatched[j].Data()),
1389 Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()),
1390 nptbins,ptmin,ptmax,200,0,0.2);
1391 fhAnglePairNLocMaxN[j]->SetYTitle("#alpha (rad)");
1392 fhAnglePairNLocMaxN[j]->SetXTitle("E (GeV)");
1393 outputContainer->Add(fhAnglePairNLocMaxN[j]) ;
1395 fhAnglePairMassNLocMax1[j] = new TH2F(Form("hAnglePairMassNLocMax1%s",sMatched[j].Data()),
1396 Form("Opening angle of 2 highest energy cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
1397 mbins,mmin,mmax,200,0,0.2);
1398 fhAnglePairMassNLocMax1[j]->SetXTitle("M (GeV/c^{2})");
1399 fhAnglePairMassNLocMax1[j]->SetYTitle("#alpha (rad)");
1400 outputContainer->Add(fhAnglePairMassNLocMax1[j]) ;
1402 fhAnglePairMassNLocMax2[j] = new TH2F(Form("hAnglePairMassNLocMax2%s",sMatched[j].Data()),
1403 Form("Opening angle of 2 local maxima cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
1404 mbins,mmin,mmax,200,0,0.2);
1405 fhAnglePairMassNLocMax2[j]->SetXTitle("M (GeV/c^{2})");
1406 fhAnglePairMassNLocMax2[j]->SetYTitle("#alpha (rad)");
1407 outputContainer->Add(fhAnglePairMassNLocMax2[j]) ;
1409 fhAnglePairMassNLocMaxN[j] = new TH2F(Form("hAnglePairMassNLocMaxN%s",sMatched[j].Data()),
1410 Form("Opening angle of N>2 local maxima cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
1411 mbins,mmin,mmax,200,0,0.2);
1412 fhAnglePairMassNLocMaxN[j]->SetXTitle("M (GeV/c^{2})");
1413 fhAnglePairMassNLocMaxN[j]->SetYTitle("#alpha (rad)");
1414 outputContainer->Add(fhAnglePairMassNLocMaxN[j]) ;
1419 for(Int_t j = 0; j < 2; j++)
1421 fhSplitEFractionvsAsyNLocMax1[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMax1%s",sMatched[j].Data()),
1422 Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max = 1, E>12, %s",sMatched[j].Data()),
1423 100,-1,1,120,0,1.2);
1424 fhSplitEFractionvsAsyNLocMax1[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
1425 fhSplitEFractionvsAsyNLocMax1[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
1426 outputContainer->Add(fhSplitEFractionvsAsyNLocMax1[j]) ;
1428 fhSplitEFractionvsAsyNLocMax2[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMax2%s",sMatched[j].Data()),
1429 Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max = 2,E>12, %s",sMatched[j].Data()),
1430 100,-1,1,120,0,1.2);
1431 fhSplitEFractionvsAsyNLocMax2[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
1432 fhSplitEFractionvsAsyNLocMax2[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
1433 outputContainer->Add(fhSplitEFractionvsAsyNLocMax2[j]) ;
1435 fhSplitEFractionvsAsyNLocMaxN[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMaxN%s",sMatched[j].Data()),
1436 Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max > 2, E>12, %s",sMatched[j].Data()),
1437 100,-1,1,120,0,1.2);
1438 fhSplitEFractionvsAsyNLocMaxN[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
1439 fhSplitEFractionvsAsyNLocMaxN[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
1440 outputContainer->Add(fhSplitEFractionvsAsyNLocMaxN[j]) ;
1444 return outputContainer ;
1448 //___________________________________________
1449 void AliAnaInsideClusterInvariantMass::Init()
1453 if(fCalorimeter == "PHOS" && !GetReader()->IsPHOSSwitchedOn() && NewOutputAOD())
1455 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!\n");
1458 else if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn() && NewOutputAOD())
1460 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!\n");
1464 if( GetReader()->GetDataType() == AliCaloTrackReader::kMC )
1466 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use pure MC data!!\n");
1473 //_____________________________________________________
1474 void AliAnaInsideClusterInvariantMass::InitParameters()
1476 //Initialize the parameters of the analysis.
1477 AddToHistogramsName("AnaPi0InsideClusterInvariantMass_");
1479 fCalorimeter = "EMCAL" ;
1490 //__________________________________________________________________
1491 void AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
1493 //Search for pi0 in fCalorimeter with shower shape analysis
1495 TObjArray * pl = 0x0;
1496 AliVCaloCells* cells = 0x0;
1498 //Select the Calorimeter of the photon
1499 if(fCalorimeter == "PHOS")
1501 pl = GetPHOSClusters();
1502 cells = GetPHOSCells();
1504 else if (fCalorimeter == "EMCAL")
1506 pl = GetEMCALClusters();
1507 cells = GetEMCALCells();
1510 const Float_t ecut = 12.; // Fixed cut for some histograms
1514 Info("MakeAnalysisFillHistograms","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data());
1518 if(fCalorimeter == "PHOS") return; // Not implemented for PHOS yet
1520 for(Int_t icluster = 0; icluster < pl->GetEntriesFast(); icluster++)
1522 AliVCluster * cluster = (AliVCluster*) (pl->At(icluster));
1524 // Study clusters with large shape parameter
1525 Float_t en = cluster->E();
1526 Float_t l0 = cluster->GetM02();
1527 Int_t nc = cluster->GetNCells();
1528 Float_t bd = cluster->GetDistanceToBadChannel() ;
1531 //If too small or big E or low number of cells, or close to a bad channel skip it
1532 if( en < GetMinEnergy() || en > GetMaxEnergy() || nc < fMinNCells || bd < fMinBadDist) continue ;
1534 //printf("en %2.2f, GetMinEnergy() %2.2f, GetMaxEnergy() %2.2f, nc %d, fMinNCells %d, bd %2.2f, fMinBadDist %2.2f\n",
1535 // en,GetMinEnergy(), GetMaxEnergy(), nc, fMinNCells, bd, fMinBadDist);
1537 // Get more Shower Shape parameters
1538 Float_t ll0 = 0., ll1 = 0.;
1539 Float_t disp= 0., dispEta = 0., dispPhi = 0.;
1540 Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
1542 GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), GetReader()->GetInputEvent()->GetEMCALCells(), cluster,
1543 ll0, ll1, disp, dispEta, dispPhi, sEta, sPhi, sEtaPhi);
1545 Float_t dispAsy = -1;
1546 if(dispEta+dispPhi >0 ) dispAsy = (dispPhi-dispEta) / (dispPhi+dispEta);
1549 Double_t mass = 0., angle = 0.;
1550 Double_t e1 = 0., e2 = 0.;
1551 Int_t pidTag = GetCaloPID()->GetIdentifiedParticleTypeFromClusterSplitting(cluster,cells,GetCaloUtils(),
1552 GetVertex(0), nMax, mass, angle,e1,e2);
1556 printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - No local maximum found! It did not pass CaloPID selection criteria \n");
1561 Float_t splitFrac = (e1+e2)/en;
1563 if(e1+e2>0) asym = (e1-e2)/(e1+e2);
1565 Bool_t matched = IsTrackMatched(cluster,GetReader()->GetInputEvent());
1567 fhNLocMax[0][matched]->Fill(en,nMax);
1571 fhM02NLocMax1[0][matched]->Fill(en,l0) ;
1572 fhSplitEFractionNLocMax1[0][matched]->Fill(en,splitFrac) ;
1573 if(en > ecut) fhSplitEFractionvsAsyNLocMax1[matched]->Fill(asym,splitFrac) ;
1574 if(fFillSSExtraHisto) fhNCellNLocMax1[0][matched]->Fill(en,nc) ;
1576 else if( nMax == 2 )
1578 fhM02NLocMax2[0][matched]->Fill(en,l0) ;
1579 fhSplitEFractionNLocMax2[0][matched]->Fill(en,splitFrac) ;
1580 if(en > ecut) fhSplitEFractionvsAsyNLocMax2[matched]->Fill(asym,splitFrac) ;
1581 if(fFillSSExtraHisto) fhNCellNLocMax2[0][matched]->Fill(en,nc) ; }
1582 else if( nMax >= 3 )
1584 fhM02NLocMaxN[0][matched]->Fill(en,l0) ;
1585 fhSplitEFractionNLocMaxN[0][matched]->Fill(en,splitFrac) ;
1586 if(en > ecut) fhSplitEFractionvsAsyNLocMaxN[matched]->Fill(asym,splitFrac) ;
1587 if(fFillSSExtraHisto) fhNCellNLocMaxN[0][matched]->Fill(en,nc) ;
1589 else printf("N max smaller than 1 -> %d \n",nMax);
1592 Float_t dZ = cluster->GetTrackDz();
1593 Float_t dR = cluster->GetTrackDx();
1595 if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
1597 dR = 2000., dZ = 2000.;
1598 GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
1600 //printf("Pi0EbE: dPhi %f, dEta %f\n",dR,dZ);
1602 if(TMath::Abs(dR) < 999 && fFillTMResidualHisto)
1604 if ( nMax == 1 ) { fhTrackMatchedDEtaNLocMax1[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1[0]->Fill(en,dR); }
1605 else if( nMax == 2 ) { fhTrackMatchedDEtaNLocMax2[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2[0]->Fill(en,dR); }
1606 else if( nMax >= 3 ) { fhTrackMatchedDEtaNLocMaxN[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxN[0]->Fill(en,dR); }
1609 // Play with the MC stack if available
1610 // Check origin of the candidates
1613 Float_t asymGen = -2;
1614 Int_t mcLabel = cluster->GetLabel();
1617 Int_t tag = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(), GetReader());
1619 if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) &&
1620 !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPi0;
1621 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ) mcindex = kmcPi0Conv;
1622 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ) mcindex = kmcEta;
1623 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
1624 !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPhoton;
1625 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
1626 GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcConversion;
1627 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) mcindex = kmcElectron;
1628 else mcindex = kmcHadron;
1630 fhNLocMax[mcindex][matched]->Fill(en,nMax);
1632 if (nMax == 1 ) { fhM02NLocMax1[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax1[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax1[mcindex][matched]->Fill(en,nc) ; }
1633 else if(nMax == 2 ) { fhM02NLocMax2[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax2[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax2[mcindex][matched]->Fill(en,nc) ; }
1634 else if(nMax >= 3 ) { fhM02NLocMaxN[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMaxN[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMaxN[mcindex][matched]->Fill(en,nc) ; }
1636 if(TMath::Abs(dR) < 999 && fFillTMResidualHisto)
1638 if ( nMax == 1 ) { fhTrackMatchedDEtaNLocMax1[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1[mcindex]->Fill(en,dR); }
1639 else if( nMax == 2 ) { fhTrackMatchedDEtaNLocMax2[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2[mcindex]->Fill(en,dR); }
1640 else if( nMax >= 3 ) { fhTrackMatchedDEtaNLocMaxN[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxN[mcindex]->Fill(en,dR); }
1644 TLorentzVector primary = GetMCAnalysisUtils()->GetMother(mcLabel,GetReader(),ok);
1645 eprim = primary.E();
1647 if(mcindex == kmcPi0 || mcindex == kmcEta)
1649 if(mcindex == kmcPi0)
1651 asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,111,GetReader(),ok));
1652 TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,111,GetReader(),ok);
1653 if(grandmom.E() > 0 && ok) eprim = grandmom.E();
1657 asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,221,GetReader(),ok));
1658 TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,221,GetReader(),ok);
1659 if(grandmom.E() > 0 && ok) eprim = grandmom.E();
1664 Float_t efrac = eprim/en;
1665 Float_t efracSplit = 0;
1666 if(e1+e2 > 0) efracSplit = eprim/(e1+e2);
1668 //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",
1669 // e1,e2,eprim,en,splitFrac,efrac,efracSplit);
1672 if(en > 8 && en <= 12) ebin = 0;
1673 if(en > 12 && en <= 16) ebin = 1;
1674 if(en > 16 && en <= 20) ebin = 2;
1675 if(en > 20) ebin = 3;
1677 if(ebin >= 0 && IsDataMC() && fFillMCFractionHisto)
1679 if( !matched ) fhMCGenFracNLocMaxEbin [mcindex][ebin]->Fill(efrac,nMax);
1680 else fhMCGenFracNLocMaxEbinMatched[mcindex][ebin]->Fill(efrac,nMax);
1687 fhMassM02NLocMax1 [0][matched]->Fill(l0 , mass );
1688 if(fFillSSExtraHisto)
1690 fhMassDispEtaNLocMax1[0][matched]->Fill(dispEta, mass );
1691 fhMassDispPhiNLocMax1[0][matched]->Fill(dispPhi, mass );
1692 fhMassDispAsyNLocMax1[0][matched]->Fill(dispAsy, mass );
1697 fhMassM02NLocMax1 [mcindex][matched]->Fill(l0 , mass );
1698 if(fFillMCFractionHisto)
1700 fhMCGenFracNLocMax1 [mcindex][matched]->Fill(en , efrac );
1701 fhMCGenSplitEFracNLocMax1 [mcindex][matched]->Fill(en , efracSplit );
1702 fhMCGenEvsSplitENLocMax1 [mcindex][matched]->Fill(eprim , e1+e2);
1703 fhMCGenEFracvsSplitEFracNLocMax1[mcindex][matched]->Fill(efrac,splitFrac );
1706 if(!matched && ebin >= 0)
1708 if(fFillMCFractionHisto)
1710 fhM02MCGenFracNLocMax1Ebin [mcindex][ebin]->Fill(efrac , l0 );
1711 fhMassMCGenFracNLocMax1Ebin[mcindex][ebin]->Fill(efrac , mass );
1713 fhMCAsymM02NLocMax1MCPi0Ebin [ebin]->Fill(l0 , asymGen );
1714 fhAsyMCGenRecoNLocMax1EbinPi0[ebin]->Fill(asym, asymGen );
1717 if(fFillSSExtraHisto)
1719 fhMassDispEtaNLocMax1[mcindex][matched]->Fill(dispEta, mass );
1720 fhMassDispPhiNLocMax1[mcindex][matched]->Fill(dispPhi, mass );
1721 fhMassDispAsyNLocMax1[mcindex][matched]->Fill(dispAsy, mass );
1726 if(!matched && ebin >= 0)
1728 fhMassSplitEFractionNLocMax1Ebin[0][ebin]->Fill(splitFrac, mass);
1729 if(IsDataMC())fhMassSplitEFractionNLocMax1Ebin[mcindex][ebin]->Fill(splitFrac, mass);
1731 fhMassM02NLocMax1Ebin [ebin]->Fill(l0 , mass );
1732 fhMassAsyNLocMax1Ebin [ebin]->Fill(asym, mass );
1734 if(fFillSSExtraHisto)
1736 fhMassDispEtaNLocMax1Ebin[ebin]->Fill(dispEta, mass );
1737 fhMassDispPhiNLocMax1Ebin[ebin]->Fill(dispPhi, mass );
1738 fhMassDispAsyNLocMax1Ebin[ebin]->Fill(dispAsy, mass );
1746 fhMassM02NLocMax2 [0][matched]->Fill(l0 , mass );
1747 if(fFillSSExtraHisto)
1749 fhMassDispEtaNLocMax2[0][matched]->Fill(dispEta, mass );
1750 fhMassDispPhiNLocMax2[0][matched]->Fill(dispPhi, mass );
1751 fhMassDispAsyNLocMax2[0][matched]->Fill(dispAsy, mass );
1756 fhMassM02NLocMax2 [mcindex][matched]->Fill(l0 , mass );
1757 if(fFillMCFractionHisto)
1759 fhMCGenFracNLocMax2 [mcindex][matched]->Fill(en , efrac );
1760 fhMCGenSplitEFracNLocMax2[mcindex][matched]->Fill(en , efracSplit );
1761 fhMCGenEvsSplitENLocMax2 [mcindex][matched]->Fill(eprim , e1+e2);
1762 fhMCGenEFracvsSplitEFracNLocMax2[mcindex][matched]->Fill(efrac,splitFrac );
1765 if(!matched && ebin >= 0)
1767 if(fFillMCFractionHisto)
1769 fhM02MCGenFracNLocMax2Ebin [mcindex][ebin]->Fill(efrac , l0 );
1770 fhMassMCGenFracNLocMax2Ebin[mcindex][ebin]->Fill(efrac , mass );
1772 fhMCAsymM02NLocMax2MCPi0Ebin [ebin]->Fill(l0 , asymGen );
1773 fhAsyMCGenRecoNLocMax2EbinPi0[ebin]->Fill(asym, asymGen );
1775 if(fFillSSExtraHisto)
1777 fhMassDispEtaNLocMax2[mcindex][matched]->Fill(dispEta, mass );
1778 fhMassDispPhiNLocMax2[mcindex][matched]->Fill(dispPhi, mass );
1779 fhMassDispAsyNLocMax2[mcindex][matched]->Fill(dispAsy, mass );
1784 if(!matched && ebin >= 0)
1786 fhMassSplitEFractionNLocMax2Ebin[0][ebin]->Fill(splitFrac, mass);
1787 if(IsDataMC())fhMassSplitEFractionNLocMax2Ebin[mcindex][ebin]->Fill(splitFrac, mass);
1789 fhMassM02NLocMax2Ebin [ebin]->Fill(l0 , mass );
1790 fhMassAsyNLocMax2Ebin [ebin]->Fill(asym, mass );
1792 if(fFillSSExtraHisto)
1794 fhMassDispEtaNLocMax2Ebin[ebin]->Fill(dispEta, mass );
1795 fhMassDispPhiNLocMax2Ebin[ebin]->Fill(dispPhi, mass );
1796 fhMassDispAsyNLocMax2Ebin[ebin]->Fill(dispAsy, mass );
1804 fhMassM02NLocMaxN [0][matched]->Fill(l0 , mass );
1805 if(fFillSSExtraHisto)
1807 fhMassDispEtaNLocMaxN[0][matched]->Fill(dispEta, mass );
1808 fhMassDispPhiNLocMaxN[0][matched]->Fill(dispPhi, mass );
1809 fhMassDispAsyNLocMaxN[0][matched]->Fill(dispAsy, mass );
1814 fhMassM02NLocMaxN [mcindex][matched]->Fill(l0 , mass );
1815 if(fFillMCFractionHisto)
1817 fhMCGenFracNLocMaxN [mcindex][matched]->Fill(en , efrac );
1818 fhMCGenSplitEFracNLocMaxN[mcindex][matched]->Fill(en , efracSplit );
1819 fhMCGenEvsSplitENLocMaxN [mcindex][matched]->Fill(eprim , e1+e2);
1820 fhMCGenEFracvsSplitEFracNLocMaxN[mcindex][matched]->Fill(efrac, splitFrac );
1823 if(!matched && ebin >= 0)
1825 if(fFillMCFractionHisto)
1827 fhM02MCGenFracNLocMaxNEbin [mcindex][ebin]->Fill(efrac , l0 );
1828 fhMassMCGenFracNLocMaxNEbin[mcindex][ebin]->Fill(efrac , mass );
1830 fhMCAsymM02NLocMaxNMCPi0Ebin [ebin]->Fill(l0 , asymGen );
1831 fhAsyMCGenRecoNLocMaxNEbinPi0[ebin]->Fill(asym, asymGen );
1833 if(fFillSSExtraHisto)
1835 fhMassDispEtaNLocMaxN[mcindex][matched]->Fill(dispEta, mass );
1836 fhMassDispPhiNLocMaxN[mcindex][matched]->Fill(dispPhi, mass );
1837 fhMassDispAsyNLocMaxN[mcindex][matched]->Fill(dispAsy, mass );
1842 if(!matched && ebin >= 0)
1844 fhMassSplitEFractionNLocMaxNEbin[0][ebin]->Fill(splitFrac, mass);
1845 if(IsDataMC())fhMassSplitEFractionNLocMaxNEbin[mcindex][ebin]->Fill(splitFrac, mass);
1847 fhMassM02NLocMaxNEbin [ebin]->Fill(l0 , mass );
1848 fhMassAsyNLocMaxNEbin [ebin]->Fill(asym, mass );
1850 if(fFillSSExtraHisto)
1852 fhMassDispEtaNLocMaxNEbin[ebin]->Fill(dispEta, mass );
1853 fhMassDispPhiNLocMaxNEbin[ebin]->Fill(dispPhi, mass );
1854 fhMassDispAsyNLocMaxNEbin[ebin]->Fill(dispAsy, mass );
1859 //---------------------------------------------------------------------
1860 // From here only if M02 is large but not too large, fill histograms
1861 //---------------------------------------------------------------------
1863 if( l0 < fM02MinCut || l0 > fM02MaxCut ) continue ;
1865 Bool_t m02OK = GetCaloPID()->IsInPi0M02Range(en,l0,nMax);
1866 Bool_t asyOK = GetCaloPID()->IsInPi0SplitAsymmetryRange(en,asym,nMax);
1868 Float_t cent = GetEventCentrality();
1869 Float_t evp = GetEventPlaneAngle();
1871 fhNLocMaxM02Cut[0][matched]->Fill(en,nMax);
1872 if(IsDataMC()) fhNLocMaxM02Cut[mcindex][matched]->Fill(en,nMax);
1876 fhMassNLocMax1[0][matched]->Fill(en,mass );
1877 fhAsymNLocMax1[0][matched]->Fill(en,asym );
1879 // Effect of cuts in mass histograms
1880 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched)
1882 fhMassSplitECutNLocMax1->Fill(en,mass );
1885 fhMassM02CutNLocMax1->Fill(en,mass);
1886 fhAsymM02CutNLocMax1->Fill(en,asym );
1887 if(asyOK) fhMassAfterCutsNLocMax1[0]->Fill(en,mass);
1891 if(m02OK && asyOK && !matched)
1893 fhSplitEFractionAfterCutsNLocMax1[0]->Fill(en,splitFrac);
1894 if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
1896 fhMCGenFracAfterCutsNLocMax1MCPi0 ->Fill(en , efrac );
1897 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0->Fill(en , efracSplit);
1903 fhAnglePairNLocMax1[matched]->Fill(en,angle);
1905 fhAnglePairMassNLocMax1[matched]->Fill(mass,angle);
1912 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMax1[0][matched]->Fill(en,l0); fhMassConNLocMax1[0][matched]->Fill(en,mass); fhAsyConNLocMax1[0][matched]->Fill(en,asym); }
1913 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMax1[0][matched]->Fill(en,l0); fhMassPi0NLocMax1[0][matched]->Fill(en,mass); fhAsyPi0NLocMax1[0][matched]->Fill(en,asym); }
1914 else if(pidTag==AliCaloPID::kEta) { fhM02EtaNLocMax1[0][matched]->Fill(en,l0); fhMassEtaNLocMax1[0][matched]->Fill(en,mass); fhAsyEtaNLocMax1[0][matched]->Fill(en,asym); }
1918 if (pidTag==AliCaloPID::kPi0) { fhCentralityPi0NLocMax1->Fill(en,cent) ; fhEventPlanePi0NLocMax1->Fill(en,evp) ; }
1919 else if(pidTag==AliCaloPID::kEta) { fhCentralityEtaNLocMax1->Fill(en,cent) ; fhEventPlaneEtaNLocMax1->Fill(en,evp) ; }
1924 fhMassNLocMax2[0][matched]->Fill(en,mass );
1925 fhAsymNLocMax2[0][matched]->Fill(en,asym );
1927 // Effect of cuts in mass histograms
1928 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched)
1930 fhMassSplitECutNLocMax2->Fill(en,mass );
1933 fhMassM02CutNLocMax2->Fill(en,mass);
1934 fhAsymM02CutNLocMax2->Fill(en,asym );
1935 if(asyOK) fhMassAfterCutsNLocMax2[0]->Fill(en,mass);
1939 if(m02OK && asyOK && !matched)
1941 fhSplitEFractionAfterCutsNLocMax2[0]->Fill(en,splitFrac);
1942 if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
1944 fhMCGenFracAfterCutsNLocMax2MCPi0 ->Fill(en , efrac );
1945 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0->Fill(en , efracSplit);
1951 fhAnglePairNLocMax2[matched]->Fill(en,angle);
1953 fhAnglePairMassNLocMax2[matched]->Fill(mass,angle);
1956 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMax2[0][matched]->Fill(en,l0); fhMassConNLocMax2[0][matched]->Fill(en,mass); fhAsyConNLocMax2[0][matched]->Fill(en,asym); }
1957 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMax2[0][matched]->Fill(en,l0); fhMassPi0NLocMax2[0][matched]->Fill(en,mass); fhAsyPi0NLocMax2[0][matched]->Fill(en,asym); }
1958 else if(pidTag==AliCaloPID::kEta) { fhM02EtaNLocMax2[0][matched]->Fill(en,l0); fhMassEtaNLocMax2[0][matched]->Fill(en,mass); fhAsyEtaNLocMax2[0][matched]->Fill(en,asym); }
1962 if (pidTag==AliCaloPID::kPi0) { fhCentralityPi0NLocMax2->Fill(en,cent) ; fhEventPlanePi0NLocMax2->Fill(en,evp) ; }
1963 else if(pidTag==AliCaloPID::kEta) { fhCentralityEtaNLocMax2->Fill(en,cent) ; fhEventPlaneEtaNLocMax2->Fill(en,evp) ; }
1968 fhMassNLocMaxN[0][matched]->Fill(en,mass);
1969 fhAsymNLocMaxN[0][matched]->Fill(en,asym);
1971 // Effect of cuts in mass histograms
1972 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched)
1974 fhMassSplitECutNLocMaxN->Fill(en,mass );
1977 fhMassM02CutNLocMaxN->Fill(en,mass);
1978 fhAsymM02CutNLocMaxN->Fill(en,asym );
1979 if(asyOK) fhMassAfterCutsNLocMaxN[0]->Fill(en,mass);
1983 if(m02OK && asyOK && !matched)
1985 fhSplitEFractionAfterCutsNLocMaxN[0]->Fill(en,splitFrac);
1986 if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
1988 fhMCGenFracAfterCutsNLocMaxNMCPi0 ->Fill(en , efrac );
1989 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0->Fill(en , efracSplit);
1995 fhAnglePairNLocMaxN[matched]->Fill(en,angle);
1997 fhAnglePairMassNLocMaxN[matched]->Fill(mass,angle);
2000 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMaxN[0][matched]->Fill(en,l0); fhMassConNLocMaxN[0][matched]->Fill(en,mass); fhAsyConNLocMaxN[0][matched]->Fill(en,asym); }
2001 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMaxN[0][matched]->Fill(en,l0); fhMassPi0NLocMaxN[0][matched]->Fill(en,mass); fhAsyPi0NLocMaxN[0][matched]->Fill(en,asym); }
2002 else if(pidTag==AliCaloPID::kEta) { fhM02EtaNLocMaxN[0][matched]->Fill(en,l0); fhMassEtaNLocMaxN[0][matched]->Fill(en,mass); fhAsyEtaNLocMaxN[0][matched]->Fill(en,asym); }
2006 if (pidTag==AliCaloPID::kPi0) { fhCentralityPi0NLocMaxN->Fill(en,cent) ; fhEventPlanePi0NLocMaxN->Fill(en,evp) ; }
2007 else if(pidTag==AliCaloPID::kEta) { fhCentralityEtaNLocMaxN->Fill(en,cent) ; fhEventPlaneEtaNLocMaxN->Fill(en,evp) ; }
2017 fhMassNLocMax1[mcindex][matched]->Fill(en,mass);
2018 fhAsymNLocMax1[mcindex][matched]->Fill(en,asym);
2020 if(asyOK && m02OK && !matched)
2022 fhSplitEFractionAfterCutsNLocMax1[mcindex]->Fill(en,splitFrac);
2023 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum())
2024 fhMassAfterCutsNLocMax1[mcindex]->Fill(en,mass);
2027 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMax1[mcindex][matched]->Fill(en,l0); fhMassConNLocMax1[mcindex][matched]->Fill(en,mass); fhAsyConNLocMax1[mcindex][matched]->Fill(en,asym); }
2028 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMax1[mcindex][matched]->Fill(en,l0); fhMassPi0NLocMax1[mcindex][matched]->Fill(en,mass); fhAsyPi0NLocMax1[mcindex][matched]->Fill(en,asym); }
2029 else if(pidTag==AliCaloPID::kEta ) { fhM02EtaNLocMax1[mcindex][matched]->Fill(en,l0); fhMassEtaNLocMax1[mcindex][matched]->Fill(en,mass); fhAsyEtaNLocMax1[mcindex][matched]->Fill(en,asym); }
2033 fhMassNLocMax2[mcindex][matched]->Fill(en,mass);
2034 fhAsymNLocMax2[mcindex][matched]->Fill(en,asym);
2036 if(asyOK && m02OK && !matched)
2038 fhSplitEFractionAfterCutsNLocMax2[mcindex]->Fill(en,splitFrac);
2039 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum())
2040 fhMassAfterCutsNLocMax2[mcindex]->Fill(en,mass);
2043 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMax2[mcindex][matched]->Fill(en,l0); fhMassConNLocMax2[mcindex][matched]->Fill(en,mass); fhAsyConNLocMax2[mcindex][matched]->Fill(en,asym); }
2044 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMax2[mcindex][matched]->Fill(en,l0); fhMassPi0NLocMax2[mcindex][matched]->Fill(en,mass); fhAsyPi0NLocMax2[mcindex][matched]->Fill(en,asym); }
2045 else if(pidTag==AliCaloPID::kEta ) { fhM02EtaNLocMax2[mcindex][matched]->Fill(en,l0); fhMassEtaNLocMax2[mcindex][matched]->Fill(en,mass); fhAsyEtaNLocMax2[mcindex][matched]->Fill(en,asym); }
2050 fhMassNLocMaxN[mcindex][matched]->Fill(en,mass);
2051 fhAsymNLocMaxN[mcindex][matched]->Fill(en,asym);
2053 if(asyOK && m02OK && !matched)
2055 fhSplitEFractionAfterCutsNLocMaxN[mcindex]->Fill(en,splitFrac);
2056 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum())
2057 fhMassAfterCutsNLocMaxN[mcindex]->Fill(en,mass);
2060 if (pidTag==AliCaloPID::kPhoton) { fhM02ConNLocMaxN[mcindex][matched]->Fill(en,l0); fhMassConNLocMaxN[mcindex][matched]->Fill(en,mass); fhAsyConNLocMaxN[mcindex][matched]->Fill(en,asym); }
2061 else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0NLocMaxN[mcindex][matched]->Fill(en,l0); fhMassPi0NLocMaxN[mcindex][matched]->Fill(en,mass); fhAsyPi0NLocMaxN[mcindex][matched]->Fill(en,asym); }
2062 else if(pidTag==AliCaloPID::kEta ) { fhM02EtaNLocMaxN[mcindex][matched]->Fill(en,l0); fhMassEtaNLocMaxN[mcindex][matched]->Fill(en,mass); fhAsyEtaNLocMaxN[mcindex][matched]->Fill(en,asym); }
2065 }//Work with MC truth first
2069 if(GetDebug() > 1) printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - END \n");
2073 //______________________________________________________________________
2074 void AliAnaInsideClusterInvariantMass::Print(const Option_t * opt) const
2076 //Print some relevant parameters set for the analysis
2080 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
2081 AliAnaCaloTrackCorrBaseClass::Print("");
2082 printf("Calorimeter = %s\n", fCalorimeter.Data()) ;
2083 printf("Loc. Max. E > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutE());
2084 printf("Loc. Max. E Diff > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutEDiff());
2085 printf("Min. N Cells =%d \n", fMinNCells) ;
2086 printf("Min. Dist. to Bad =%1.1f \n", fMinBadDist) ;
2087 printf("%2.2f < lambda_0^2 <%2.2f \n",fM02MinCut,fM02MaxCut);
git://git.uio.no / u / mrichter / AliRoot.git / blob