]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
add centrality and event plane histos per analysis
[u/mrichter/AliRoot.git] / PWGGA / CaloTrackCorrelations / AliAnaInsideClusterInvariantMass.cxx
CommitLineData
992b14a7 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes 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 **************************************************************************/
15
16//_________________________________________________________________________
17//
18// Split clusters with some criteria and calculate invariant mass
19// to identify them as pi0 or conversion
20//
21//
22//-- Author: Gustavo Conesa (LPSC-Grenoble)
23//_________________________________________________________________________
24
25//////////////////////////////////////////////////////////////////////////////
26
27
28// --- ROOT system ---
29#include <TList.h>
30#include <TClonesArray.h>
31#include <TObjString.h>
3c1d9afb 32#include <TH2F.h>
992b14a7 33
34// --- Analysis system ---
35#include "AliAnaInsideClusterInvariantMass.h"
36#include "AliCaloTrackReader.h"
37#include "AliMCAnalysisUtils.h"
38#include "AliStack.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"
45
c5693f62 46// --- Detectors ---
47//#include "AliPHOSGeoUtils.h"
48#include "AliEMCALGeometry.h"
49
992b14a7 50ClassImp(AliAnaInsideClusterInvariantMass)
51
52//__________________________________________________________________
53AliAnaInsideClusterInvariantMass::AliAnaInsideClusterInvariantMass() :
745913ae 54 AliAnaCaloTrackCorrBaseClass(),
29ca9cad 55 fCalorimeter(""),
71e3889f 56 fM02MaxCut(0), fM02MinCut(0),
8e81c2cf 57 fMinNCells(0), fMinBadDist(0),
883411b2 58 fFillAngleHisto(kFALSE),
8e81c2cf 59 fFillTMResidualHisto(kFALSE),
2a77f6f4 60 fFillSSExtraHisto(kFALSE),
61 fFillMCFractionHisto(kFALSE),
62 fhMassM02CutNLocMax1(0), fhMassM02CutNLocMax2(0), fhMassM02CutNLocMaxN(0),
77cadd95 63 fhAsymM02CutNLocMax1(0), fhAsymM02CutNLocMax2(0), fhAsymM02CutNLocMaxN(0),
e671adc2 64 fhMassSplitECutNLocMax1(0), fhMassSplitECutNLocMax2(0), fhMassSplitECutNLocMaxN(0),
667432ef 65 fhMCGenFracAfterCutsNLocMax1MCPi0(0),
66 fhMCGenFracAfterCutsNLocMax2MCPi0(0),
67 fhMCGenFracAfterCutsNLocMaxNMCPi0(0),
68 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0(0),
69 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0(0),
70 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0(0),
c8710850 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)
992b14a7 77{
78 //default ctor
79
80 // Init array of histograms
de7d73e6 81 for(Int_t i = 0; i < 8; i++)
5c46c992 82 {
667432ef 83 fhMassAfterCutsNLocMax1[i] = 0;
84 fhMassAfterCutsNLocMax2[i] = 0;
85 fhMassAfterCutsNLocMaxN[i] = 0;
86
c8710850 87 fhSplitEFractionAfterCutsNLocMax1[i] = 0 ;
88 fhSplitEFractionAfterCutsNLocMax2[i] = 0 ;
89 fhSplitEFractionAfterCutsNLocMaxN[i] = 0 ;
90
5c46c992 91 for(Int_t j = 0; j < 2; j++)
92 {
5c46c992 93 fhMassNLocMax1[i][j] = 0;
94 fhMassNLocMax2[i][j] = 0;
95 fhMassNLocMaxN[i][j] = 0;
96 fhNLocMax[i][j] = 0;
5c46c992 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;
c8710850 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;
113
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;
123
124
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;
e671adc2 134
0137016b 135 fhMassM02NLocMax1[i][j]= 0;
136 fhMassM02NLocMax2[i][j]= 0;
d2655d46 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;
8e81c2cf 147
fc01318e 148 fhSplitEFractionNLocMax1[i][j]=0;
149 fhSplitEFractionNLocMax2[i][j]=0;
150 fhSplitEFractionNLocMaxN[i][j]=0;
151
8e81c2cf 152 fhMCGenFracNLocMax1[i][j]= 0;
153 fhMCGenFracNLocMax2[i][j]= 0;
154 fhMCGenFracNLocMaxN[i][j]= 0;
5094c724 155
156 fhMCGenSplitEFracNLocMax1[i][j]= 0;
157 fhMCGenSplitEFracNLocMax2[i][j]= 0;
bb2d339b 158 fhMCGenSplitEFracNLocMaxN[i][j]= 0;
159
160 fhMCGenEFracvsSplitEFracNLocMax1[i][j]= 0;
161 fhMCGenEFracvsSplitEFracNLocMax2[i][j]= 0;
162 fhMCGenEFracvsSplitEFracNLocMaxN[i][j]= 0;
163
164 fhMCGenEvsSplitENLocMax1[i][j]= 0;
165 fhMCGenEvsSplitENLocMax2[i][j]= 0;
e671adc2 166 fhMCGenEvsSplitENLocMaxN[i][j]= 0;
167
168 fhAsymNLocMax1 [i][j] = 0;
169 fhAsymNLocMax2 [i][j] = 0;
170 fhAsymNLocMaxN [i][j] = 0;
8e81c2cf 171 }
172
173 for(Int_t jj = 0; jj < 4; jj++)
174 {
53f2c382 175 fhM02MCGenFracNLocMax1Ebin[i][jj] = 0;
176 fhM02MCGenFracNLocMax2Ebin[i][jj] = 0;
177 fhM02MCGenFracNLocMaxNEbin[i][jj] = 0;
8e81c2cf 178
179 fhMassMCGenFracNLocMax1Ebin[i][jj]= 0;
180 fhMassMCGenFracNLocMax2Ebin[i][jj]= 0;
181 fhMassMCGenFracNLocMaxNEbin[i][jj]= 0;
53f2c382 182
fc01318e 183 fhMCGenFracNLocMaxEbin[i][jj] = 0;
53f2c382 184 fhMCGenFracNLocMaxEbinMatched[i][jj]= 0;
fc01318e 185
186 fhMassSplitEFractionNLocMax1Ebin[i][jj] = 0;
187 fhMassSplitEFractionNLocMax2Ebin[i][jj] = 0;
188 fhMassSplitEFractionNLocMaxNEbin[i][jj] = 0;
5c46c992 189 }
190
c8710850 191 fhTrackMatchedDEtaNLocMax1[i] = 0;
192 fhTrackMatchedDPhiNLocMax1[i] = 0;
193 fhTrackMatchedDEtaNLocMax2[i] = 0;
194 fhTrackMatchedDPhiNLocMax2[i] = 0;
195 fhTrackMatchedDEtaNLocMaxN[i] = 0;
196 fhTrackMatchedDPhiNLocMaxN[i] = 0;
243c2909 197
992b14a7 198 }
199
5c46c992 200 for(Int_t i = 0; i < 2; i++)
201 {
c8710850 202 fhAnglePairNLocMax1 [i] = 0;
203 fhAnglePairNLocMax2 [i] = 0;
204 fhAnglePairNLocMaxN [i] = 0;
205 fhAnglePairMassNLocMax1[i] = 0;
206 fhAnglePairMassNLocMax2[i] = 0;
207 fhAnglePairMassNLocMaxN[i] = 0;
e671adc2 208 fhSplitEFractionvsAsyNLocMax1[i] = 0;
209 fhSplitEFractionvsAsyNLocMax2[i] = 0;
210 fhSplitEFractionvsAsyNLocMaxN[i] = 0;
5c46c992 211 }
212
7b686344 213 for(Int_t i = 0; i < 4; i++)
214 {
215 fhMassM02NLocMax1Ebin[i] = 0 ;
216 fhMassM02NLocMax2Ebin[i] = 0 ;
217 fhMassM02NLocMaxNEbin[i] = 0 ;
b8eb40fc 218
219 fhMassAsyNLocMax1Ebin[i] = 0 ;
220 fhMassAsyNLocMax2Ebin[i] = 0 ;
221 fhMassAsyNLocMaxNEbin[i] = 0 ;
222
223 fhAsyMCGenRecoNLocMax1EbinPi0[i] = 0 ;
224 fhAsyMCGenRecoNLocMax2EbinPi0[i] = 0 ;
225 fhAsyMCGenRecoNLocMaxNEbinPi0[i] = 0 ;
d2655d46 226
227 fhMassDispEtaNLocMax1Ebin[i] = 0 ;
228 fhMassDispEtaNLocMax2Ebin[i] = 0 ;
229 fhMassDispEtaNLocMaxNEbin[i] = 0 ;
230
231 fhMassDispPhiNLocMax1Ebin[i] = 0 ;
232 fhMassDispPhiNLocMax2Ebin[i] = 0 ;
233 fhMassDispPhiNLocMaxNEbin[i] = 0 ;
234
235 fhMassDispAsyNLocMax1Ebin[i] = 0 ;
236 fhMassDispAsyNLocMax2Ebin[i] = 0 ;
237 fhMassDispAsyNLocMaxNEbin[i] = 0 ;
8e81c2cf 238
239 fhMCAsymM02NLocMax1MCPi0Ebin[i] = 0 ;
240 fhMCAsymM02NLocMax2MCPi0Ebin[i] = 0 ;
241 fhMCAsymM02NLocMaxNMCPi0Ebin[i] = 0 ;
7b686344 242 }
243
992b14a7 244 InitParameters();
245
246}
247
248//_______________________________________________________________
249TObjString * AliAnaInsideClusterInvariantMass::GetAnalysisCuts()
250{
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] ;
255
256 snprintf(onePar,buffersize,"--- AliAnaInsideClusterInvariantMass ---\n") ;
257 parList+=onePar ;
258
243c2909 259 snprintf(onePar,buffersize,"Calorimeter: %s\n", fCalorimeter.Data()) ;
992b14a7 260 parList+=onePar ;
c8710850 261 snprintf(onePar,buffersize,"fNLocMaxCutE =%2.2f \n", GetCaloUtils()->GetLocalMaximaCutE()) ;
29ca9cad 262 parList+=onePar ;
c8710850 263 snprintf(onePar,buffersize,"fNLocMaxCutEDiff =%2.2f \n",GetCaloUtils()->GetLocalMaximaCutEDiff()) ;
29ca9cad 264 parList+=onePar ;
71e3889f 265 snprintf(onePar,buffersize,"%2.2f< M02 < %2.2f \n", fM02MinCut, fM02MaxCut) ;
992b14a7 266 parList+=onePar ;
e23a0471 267 snprintf(onePar,buffersize,"fMinNCells =%d \n", fMinNCells) ;
2cb134fb 268 parList+=onePar ;
3c1d9afb 269 snprintf(onePar,buffersize,"fMinBadDist =%1.1f \n", fMinBadDist) ;
992b14a7 270 parList+=onePar ;
243c2909 271
992b14a7 272 return new TObjString(parList) ;
273
274}
275
992b14a7 276//________________________________________________________________
277TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
278{
279 // Create histograms to be saved in output file and
280 // store them in outputContainer
281 TList * outputContainer = new TList() ;
667432ef 282 outputContainer->SetName("InsideClusterHistos") ;
992b14a7 283
745913ae 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();
992b14a7 288
5c46c992 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();
295
de7d73e6 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"};
992b14a7 298
299 Int_t n = 1;
300
de7d73e6 301 if(IsDataMC()) n = 8;
992b14a7 302
243c2909 303 Int_t nMaxBins = 10;
304
5c46c992 305 TString sMatched[] = {"","Matched"};
306
2a77f6f4 307
c8710850 308 // E vs centrality
2a77f6f4 309
c8710850 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) ;
2a77f6f4 315
c8710850 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) ;
2a77f6f4 321
c8710850 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) ;
2a77f6f4 327
c8710850 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) ;
2a77f6f4 333
c8710850 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) ;
77cadd95 339
c8710850 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) ;
77cadd95 345
c8710850 346 // E vs Event plane angle
e671adc2 347
c8710850 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) ;
e671adc2 353
c8710850 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) ;
359
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) ;
365
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) ;
371
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) ;
377
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) ;
383
e671adc2 384
5c46c992 385 for(Int_t i = 0; i < n; i++)
667432ef 386 {
5c46c992 387 for(Int_t j = 0; j < 2; j++)
667432ef 388 {
5c46c992 389
390 fhMassNLocMax1[i][j] = new TH2F(Form("hMassNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2a77f6f4 391 Form("Invariant mass of splitted cluster with NLM=1 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
5c46c992 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]) ;
396
397 fhMassNLocMax2[i][j] = new TH2F(Form("hMassNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2a77f6f4 398 Form("Invariant mass of splitted cluster with NLM=2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
5c46c992 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]) ;
403
404 fhMassNLocMaxN[i][j] = new TH2F(Form("hMassNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2a77f6f4 405 Form("Invariant mass of splitted cluster with NLM>2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
5c46c992 406 nptbins,ptmin,ptmax,mbins,mmin,mmax);
407 fhMassNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
408 fhMassNLocMaxN[i][j]->SetXTitle("E (GeV)");
667432ef 409 outputContainer->Add(fhMassNLocMaxN[i][j]) ;
410
411 if(j==0)
412 {
413 fhMassAfterCutsNLocMax1[i] = new TH2F(Form("hMassAfterCutsNLocMax1%s",pname[i].Data()),
c8710850 414 Form("Mass vs E, %s, for N Local max = 1, m02 and asy cut",ptype[i].Data()),
667432ef 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]) ;
419
420 fhMassAfterCutsNLocMax2[i] = new TH2F(Form("hMassAfterCutsNLocMax2%s",pname[i].Data()),
c8710850 421 Form("Mass vs E, %s, for N Local max = 2, asy cut",ptype[i].Data()),
667432ef 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]) ;
426
427
428 fhMassAfterCutsNLocMaxN[i] = new TH2F(Form("hMassAfterCutsNLocMaxN%s",pname[i].Data()),
c8710850 429 Form("Mass vs E, %s, for N Local max > 2, asy cut",ptype[i].Data()),
667432ef 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]) ;
c8710850 434
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]) ;
441
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]) ;
448
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]) ;
455
456
667432ef 457 }
5c46c992 458
0137016b 459 fhMassM02NLocMax1[i][j] = new TH2F(Form("hMassM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
c8710850 460 Form("Invariant mass of splitted cluster with NLM=1, #lambda_{0}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
0137016b 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]) ;
465
466 fhMassM02NLocMax2[i][j] = new TH2F(Form("hMassM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
c8710850 467 Form("Invariant mass of splitted cluster with NLM=2, #lambda_{0}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
0137016b 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]) ;
472
473 fhMassM02NLocMaxN[i][j] = new TH2F(Form("hMassM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2a77f6f4 474 Form("Invariant mass of splitted cluster with NLM>2, vs #lambda_{0}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
0137016b 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]) ;
479
e671adc2 480
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);
acd56ca4 484 fhAsymNLocMax1[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
e671adc2 485 fhAsymNLocMax1[i][j]->SetXTitle("E (GeV)");
486 outputContainer->Add(fhAsymNLocMax1[i][j]) ;
487
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);
acd56ca4 491 fhAsymNLocMax2[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
e671adc2 492 fhAsymNLocMax2[i][j]->SetXTitle("E (GeV)");
493 outputContainer->Add(fhAsymNLocMax2[i][j]) ;
494
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]) ;
501
502
8e81c2cf 503 if(fFillSSExtraHisto)
504 {
505 fhMassDispEtaNLocMax1[i][j] = new TH2F(Form("hMassDispEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
c8710850 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()),
8e81c2cf 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]) ;
511
512 fhMassDispEtaNLocMax2[i][j] = new TH2F(Form("hMassDispEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
c8710850 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()),
8e81c2cf 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]) ;
518
519 fhMassDispEtaNLocMaxN[i][j] = new TH2F(Form("hMassDispEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2a77f6f4 520 Form("Invariant mass of splitted cluster with NLM>2, #sigma_{#eta #eta}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
8e81c2cf 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]) ;
525
526 fhMassDispPhiNLocMax1[i][j] = new TH2F(Form("hMassDispPhiNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
c8710850 527 Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
8e81c2cf 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]) ;
532
533 fhMassDispPhiNLocMax2[i][j] = new TH2F(Form("hMassDispPhiNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
c8710850 534 Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
8e81c2cf 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]) ;
539
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]) ;
546
547 fhMassDispAsyNLocMax1[i][j] = new TH2F(Form("hMassDispAsyNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
c8710850 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()),
8e81c2cf 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]) ;
553
554 fhMassDispAsyNLocMax2[i][j] = new TH2F(Form("hMassDispAsyNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
c8710850 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()),
8e81c2cf 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]) ;
560
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]) ;
567 }
d2655d46 568
5c46c992 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]) ;
3c1d9afb 575
5c46c992 576 fhNLocMaxM02Cut[i][j] = new TH2F(Form("hNLocMaxM02Cut%s%s",pname[i].Data(),sMatched[j].Data()),
71e3889f 577 Form("Number of local maxima in cluster %s for %2.2f < M02 < %2.2f",ptype[i].Data(),fM02MinCut,fM02MaxCut),
5c46c992 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]) ;
582
583
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]) ;
590
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]) ;
597
5c46c992 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]) ;
604
fc01318e 605
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]) ;
612
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]) ;
619
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]) ;
626
627
2a77f6f4 628 if(i > 0 && fFillMCFractionHisto) // skip first entry in array, general case not filled
883411b2 629 {
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);
fb51265c 633 fhMCGenFracNLocMax1[i][j] ->SetYTitle("E_{gen} / E_{reco}");
883411b2 634 fhMCGenFracNLocMax1[i][j] ->SetXTitle("E (GeV)");
635 outputContainer->Add(fhMCGenFracNLocMax1[i][j]) ;
636
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);
fb51265c 640 fhMCGenFracNLocMax2[i][j] ->SetYTitle("E_{gen} / E_{reco}");
883411b2 641 fhMCGenFracNLocMax2[i][j] ->SetXTitle("E (GeV)");
642 outputContainer->Add(fhMCGenFracNLocMax2[i][j]) ;
643
644
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);
fb51265c 648 fhMCGenFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / E_{reco}");
883411b2 649 fhMCGenFracNLocMaxN[i][j] ->SetXTitle("E (GeV)");
650 outputContainer->Add(fhMCGenFracNLocMaxN[i][j]) ;
5094c724 651
652 fhMCGenSplitEFracNLocMax1[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 653 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
5094c724 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]) ;
658
659 fhMCGenSplitEFracNLocMax2[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 660 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
5094c724 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]) ;
665
666
667 fhMCGenSplitEFracNLocMaxN[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 668 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
5094c724 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]) ;
bb2d339b 673
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()),
676 200,0,2,200,0,2);
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]) ;
680
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()),
683 200,0,2,200,0,2);
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]) ;
687
688
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()),
691 200,0,2,200,0,2);
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]) ;
695
696
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]) ;
703
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]) ;
710
711
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]) ;
718
883411b2 719 }
5c46c992 720
8e81c2cf 721 if(fFillSSExtraHisto)
722 {
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]) ;
729
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]) ;
736
737
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]) ;
744 }
5c46c992 745
c8710850 746 fhM02Pi0NLocMax1[i][j] = new TH2F(Form("hM02Pi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 749 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 750 fhM02Pi0NLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
751 fhM02Pi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
752 outputContainer->Add(fhM02Pi0NLocMax1[i][j]) ;
5c46c992 753
c8710850 754 fhM02EtaNLocMax1[i][j] = new TH2F(Form("hM02EtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 757 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 758 fhM02EtaNLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
759 fhM02EtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
760 outputContainer->Add(fhM02EtaNLocMax1[i][j]) ;
5c46c992 761
c8710850 762 fhM02ConNLocMax1[i][j] = new TH2F(Form("hM02ConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 765 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 766 fhM02ConNLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
767 fhM02ConNLocMax1[i][j] ->SetXTitle("E (GeV)");
768 outputContainer->Add(fhM02ConNLocMax1[i][j]) ;
5c46c992 769
c8710850 770 fhM02Pi0NLocMax2[i][j] = new TH2F(Form("hM02Pi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 773 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 774 fhM02Pi0NLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
775 fhM02Pi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
776 outputContainer->Add(fhM02Pi0NLocMax2[i][j]) ;
5c46c992 777
c8710850 778 fhM02EtaNLocMax2[i][j] = new TH2F(Form("hM02EtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 781 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 782 fhM02EtaNLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
783 fhM02EtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
784 outputContainer->Add(fhM02EtaNLocMax2[i][j]) ;
5c46c992 785
c8710850 786 fhM02ConNLocMax2[i][j] = new TH2F(Form("hM02ConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 789 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 790 fhM02ConNLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
791 fhM02ConNLocMax2[i][j] ->SetXTitle("E (GeV)");
792 outputContainer->Add(fhM02ConNLocMax2[i][j]) ;
5c46c992 793
c8710850 794 fhM02Pi0NLocMaxN[i][j] = new TH2F(Form("hM02Pi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 797 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 798 fhM02Pi0NLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
799 fhM02Pi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
800 outputContainer->Add(fhM02Pi0NLocMaxN[i][j]) ;
5c46c992 801
c8710850 802 fhM02EtaNLocMaxN[i][j] = new TH2F(Form("hM02EtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 805 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 806 fhM02EtaNLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
807 fhM02EtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
808 outputContainer->Add(fhM02EtaNLocMaxN[i][j]) ;
5c46c992 809
c8710850 810 fhM02ConNLocMaxN[i][j] = new TH2F(Form("hM02ConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 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()),
5c46c992 813 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
c8710850 814 fhM02ConNLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
815 fhM02ConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
816 outputContainer->Add(fhM02ConNLocMaxN[i][j]) ;
bb2d339b 817
818
c8710850 819 fhMassPi0NLocMax1[i][j] = new TH2F(Form("hMassPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 823 fhMassPi0NLocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})");
824 fhMassPi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
825 outputContainer->Add(fhMassPi0NLocMax1[i][j]) ;
167f2534 826
827
c8710850 828 fhMassEtaNLocMax1[i][j] = new TH2F(Form("hMassEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 832 fhMassEtaNLocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})");
833 fhMassEtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
834 outputContainer->Add(fhMassEtaNLocMax1[i][j]) ;
bb2d339b 835
c8710850 836 fhMassConNLocMax1[i][j] = new TH2F(Form("hMassConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 840 fhMassConNLocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})");
841 fhMassConNLocMax1[i][j] ->SetXTitle("E (GeV)");
842 outputContainer->Add(fhMassConNLocMax1[i][j]) ;
bb2d339b 843
c8710850 844 fhMassPi0NLocMax2[i][j] = new TH2F(Form("hMassPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 848 fhMassPi0NLocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})");
849 fhMassPi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
850 outputContainer->Add(fhMassPi0NLocMax2[i][j]) ;
bb2d339b 851
167f2534 852
c8710850 853 fhMassEtaNLocMax2[i][j] = new TH2F(Form("hMassEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 857 fhMassEtaNLocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})");
858 fhMassEtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
859 outputContainer->Add(fhMassEtaNLocMax2[i][j]) ;
bb2d339b 860
c8710850 861 fhMassConNLocMax2[i][j] = new TH2F(Form("hMassConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 865 fhMassConNLocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})");
866 fhMassConNLocMax2[i][j] ->SetXTitle("E (GeV)");
867 outputContainer->Add(fhMassConNLocMax2[i][j]) ;
bb2d339b 868
c8710850 869 fhMassPi0NLocMaxN[i][j] = new TH2F(Form("hMassPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 873 fhMassPi0NLocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})");
874 fhMassPi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
875 outputContainer->Add(fhMassPi0NLocMaxN[i][j]) ;
bb2d339b 876
c8710850 877 fhMassEtaNLocMaxN[i][j] = new TH2F(Form("hMassEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 881 fhMassEtaNLocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})");
882 fhMassEtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
883 outputContainer->Add(fhMassEtaNLocMaxN[i][j]) ;
bb2d339b 884
c8710850 885 fhMassConNLocMaxN[i][j] = new TH2F(Form("hMassConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
bb2d339b 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);
c8710850 889 fhMassConNLocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})");
890 fhMassConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
891 outputContainer->Add(fhMassConNLocMaxN[i][j]) ;
5c46c992 892
e671adc2 893
c8710850 894 fhAsyPi0NLocMax1[i][j] = new TH2F(Form("hAsyPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 898 fhAsyPi0NLocMax1[i][j] ->SetYTitle("Asymmetry");
899 fhAsyPi0NLocMax1[i][j] ->SetXTitle("E (GeV)");
900 outputContainer->Add(fhAsyPi0NLocMax1[i][j]) ;
e671adc2 901
c8710850 902 fhAsyEtaNLocMax1[i][j] = new TH2F(Form("hAsyEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 906 fhAsyEtaNLocMax1[i][j] ->SetYTitle("Asymmetry");
907 fhAsyEtaNLocMax1[i][j] ->SetXTitle("E (GeV)");
908 outputContainer->Add(fhAsyEtaNLocMax1[i][j]) ;
e671adc2 909
c8710850 910 fhAsyConNLocMax1[i][j] = new TH2F(Form("hAsyConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 914 fhAsyConNLocMax1[i][j] ->SetYTitle("Asymmetry");
915 fhAsyConNLocMax1[i][j] ->SetXTitle("E (GeV)");
916 outputContainer->Add(fhAsyConNLocMax1[i][j]) ;
e671adc2 917
c8710850 918 fhAsyPi0NLocMax2[i][j] = new TH2F(Form("hAsyPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 922 fhAsyPi0NLocMax2[i][j] ->SetYTitle("Asymmetry");
923 fhAsyPi0NLocMax2[i][j] ->SetXTitle("E (GeV)");
924 outputContainer->Add(fhAsyPi0NLocMax2[i][j]) ;
e671adc2 925
c8710850 926 fhAsyEtaNLocMax2[i][j] = new TH2F(Form("hAsyEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 930 fhAsyEtaNLocMax2[i][j] ->SetYTitle("Asymmetry");
931 fhAsyEtaNLocMax2[i][j] ->SetXTitle("E (GeV)");
932 outputContainer->Add(fhAsyEtaNLocMax2[i][j]) ;
e671adc2 933
c8710850 934 fhAsyConNLocMax2[i][j] = new TH2F(Form("hAsyConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 938 fhAsyConNLocMax2[i][j] ->SetYTitle("Asymmetry");
939 fhAsyConNLocMax2[i][j] ->SetXTitle("E (GeV)");
940 outputContainer->Add(fhAsyConNLocMax2[i][j]) ;
e671adc2 941
c8710850 942 fhAsyPi0NLocMaxN[i][j] = new TH2F(Form("hAsyPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 946 fhAsyPi0NLocMaxN[i][j] ->SetYTitle("Asymmetry");
947 fhAsyPi0NLocMaxN[i][j] ->SetXTitle("E (GeV)");
948 outputContainer->Add(fhAsyPi0NLocMaxN[i][j]) ;
e671adc2 949
c8710850 950 fhAsyEtaNLocMaxN[i][j] = new TH2F(Form("hAsyEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 954 fhAsyEtaNLocMaxN[i][j] ->SetYTitle("Asymmetry");
955 fhAsyEtaNLocMaxN[i][j] ->SetXTitle("E (GeV)");
956 outputContainer->Add(fhAsyEtaNLocMaxN[i][j]) ;
e671adc2 957
c8710850 958 fhAsyConNLocMaxN[i][j] = new TH2F(Form("hAsyConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
e671adc2 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);
c8710850 962 fhAsyConNLocMaxN[i][j] ->SetYTitle("Asymmetry");
963 fhAsyConNLocMaxN[i][j] ->SetXTitle("E (GeV)");
964 outputContainer->Add(fhAsyConNLocMaxN[i][j]) ;
e671adc2 965
5c46c992 966 } // matched, not matched
967
883411b2 968 for(Int_t j = 0; j < 4; j++)
969 {
53f2c382 970
fc01318e 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]) ;
883411b2 977
fc01318e 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]) ;
883411b2 984
fc01318e 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]) ;
883411b2 991
2a77f6f4 992 if(i>0 && fFillMCFractionHisto) // skip first entry in array, general case not filled
fc01318e 993 {
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");
fb51265c 998 fhMCGenFracNLocMaxEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 999 outputContainer->Add(fhMCGenFracNLocMaxEbin[i][j]) ;
1000
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");
fb51265c 1005 fhMCGenFracNLocMaxEbinMatched[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 1006 outputContainer->Add(fhMCGenFracNLocMaxEbinMatched[i][j]) ;
1007
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})");
fb51265c 1012 fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 1013 outputContainer->Add(fhMassMCGenFracNLocMax1Ebin[i][j]) ;
1014
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})");
fb51265c 1019 fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 1020 outputContainer->Add(fhMassMCGenFracNLocMax2Ebin[i][j]) ;
1021
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})");
fb51265c 1026 fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 1027 outputContainer->Add(fhMassMCGenFracNLocMaxNEbin[i][j]) ;
1028
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}");
fb51265c 1033 fhM02MCGenFracNLocMax1Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
fc01318e 1034 outputContainer->Add(fhM02MCGenFracNLocMax1Ebin[i][j]) ;
1035
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}");
fb51265c 1040 fhM02MCGenFracNLocMax2Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
fc01318e 1041 outputContainer->Add(fhM02MCGenFracNLocMax2Ebin[i][j]) ;
1042
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}");
fb51265c 1047 fhM02MCGenFracNLocMaxNEbin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
fc01318e 1048 outputContainer->Add(fhM02MCGenFracNLocMaxNEbin[i][j]) ;
1049 }
883411b2 1050 }
5c46c992 1051 } // MC particle list
1052
7b686344 1053 for(Int_t i = 0; i < 4; i++)
1054 {
1055 fhMassM02NLocMax1Ebin[i] = new TH2F(Form("hMassM02NLocMax1Ebin%d",i),
b8eb40fc 1056 Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
7b686344 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]) ;
1061
1062 fhMassM02NLocMax2Ebin[i] = new TH2F(Form("hMassM02NLocMax2Ebin%d",i),
b8eb40fc 1063 Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
7b686344 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]) ;
1068
1069 fhMassM02NLocMaxNEbin[i] = new TH2F(Form("hMassM02NLocMaxNEbin%d",i),
b8eb40fc 1070 Form("Invariant mass of split clusters vs vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
7b686344 1071 ssbins,ssmin,ssmax,mbins,mmin,mmax);
1072 fhMassM02NLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
1073 fhMassM02NLocMaxNEbin[i]->SetXTitle("#lambda_{0}^{2}");
d2655d46 1074 outputContainer->Add(fhMassM02NLocMaxNEbin[i]) ;
1075
b8eb40fc 1076
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]) ;
1083
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]) ;
1090
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]) ;
1097
1098
1099 if(IsDataMC())
1100 {
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]) ;
1107
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]) ;
1114
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]) ;
1121
1122
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),
1125 200,-1,1,200,-1,1);
1126 fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1127 fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetXTitle("asymmetry");
1128 outputContainer->Add(fhAsyMCGenRecoNLocMax1EbinPi0[i]) ;
1129
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),
1132 200,-1,1,200,-1,1);
1133 fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1134 fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetXTitle("asymmetry");
1135 outputContainer->Add(fhAsyMCGenRecoNLocMax2EbinPi0[i]) ;
1136
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),
1139 200,-1,1,200,-1,1);
1140 fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetYTitle("M (GeV/c^{2})");
1141 fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetXTitle("asymmetry");
1142 outputContainer->Add(fhAsyMCGenRecoNLocMaxNEbinPi0[i]) ;
1143 }
1144
8e81c2cf 1145 if(fFillSSExtraHisto)
1146 {
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]) ;
1153
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]) ;
1160
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]) ;
1167
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]) ;
1174
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]) ;
1181
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]) ;
1188
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]) ;
1195
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]) ;
1202
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]) ;
1209 }
7b686344 1210 }
1211
c8710850 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) ;
1217
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) ;
1223
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) ;
1229
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) ;
1235
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) ;
1241
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) ;
1247
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) ;
1252
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) ;
1257
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) ;
1262
1263 if(IsDataMC() && fFillMCFractionHisto)
1264 {
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) ;
1271
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) ;
1278
1279
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) ;
1286
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) ;
1293
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) ;
1300
1301
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) ;
1308
1309 }
1310
8e81c2cf 1311 if(fFillTMResidualHisto)
1312 {
1313 for(Int_t i = 0; i < n; i++)
1314 {
1315
c8710850 1316 fhTrackMatchedDEtaNLocMax1[i] = new TH2F
1317 (Form("hTrackMatchedDEtaNLocMax1%s",pname[i].Data()),
8e81c2cf 1318 Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
1319 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
c8710850 1320 fhTrackMatchedDEtaNLocMax1[i]->SetYTitle("d#eta");
1321 fhTrackMatchedDEtaNLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
8e81c2cf 1322
c8710850 1323 fhTrackMatchedDPhiNLocMax1[i] = new TH2F
1324 (Form("hTrackMatchedDPhiNLocMax1%s",pname[i].Data()),
8e81c2cf 1325 Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
1326 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
c8710850 1327 fhTrackMatchedDPhiNLocMax1[i]->SetYTitle("d#phi (rad)");
1328 fhTrackMatchedDPhiNLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
8e81c2cf 1329
c8710850 1330 outputContainer->Add(fhTrackMatchedDEtaNLocMax1[i]) ;
1331 outputContainer->Add(fhTrackMatchedDPhiNLocMax1[i]) ;
8e81c2cf 1332
c8710850 1333 fhTrackMatchedDEtaNLocMax2[i] = new TH2F
1334 (Form("hTrackMatchedDEtaNLocMax2%s",pname[i].Data()),
8e81c2cf 1335 Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
1336 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
c8710850 1337 fhTrackMatchedDEtaNLocMax2[i]->SetYTitle("d#eta");
1338 fhTrackMatchedDEtaNLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
8e81c2cf 1339
c8710850 1340 fhTrackMatchedDPhiNLocMax2[i] = new TH2F
1341 (Form("hTrackMatchedDPhiNLocMax2%s",pname[i].Data()),
8e81c2cf 1342 Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
1343 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
c8710850 1344 fhTrackMatchedDPhiNLocMax2[i]->SetYTitle("d#phi (rad)");
1345 fhTrackMatchedDPhiNLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
8e81c2cf 1346
c8710850 1347 outputContainer->Add(fhTrackMatchedDEtaNLocMax2[i]) ;
1348 outputContainer->Add(fhTrackMatchedDPhiNLocMax2[i]) ;
8e81c2cf 1349
c8710850 1350 fhTrackMatchedDEtaNLocMaxN[i] = new TH2F
1351 (Form("hTrackMatchedDEtaNLocMaxN%s",pname[i].Data()),
8e81c2cf 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);
c8710850 1354 fhTrackMatchedDEtaNLocMaxN[i]->SetYTitle("d#eta");
1355 fhTrackMatchedDEtaNLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
8e81c2cf 1356
c8710850 1357 fhTrackMatchedDPhiNLocMaxN[i] = new TH2F
1358 (Form("hTrackMatchedDPhiNLocMaxN%s",pname[i].Data()),
8e81c2cf 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);
c8710850 1361 fhTrackMatchedDPhiNLocMaxN[i]->SetYTitle("d#phi (rad)");
1362 fhTrackMatchedDPhiNLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
8e81c2cf 1363
c8710850 1364 outputContainer->Add(fhTrackMatchedDEtaNLocMaxN[i]) ;
1365 outputContainer->Add(fhTrackMatchedDPhiNLocMaxN[i]) ;
8e81c2cf 1366 }
5c46c992 1367 }
1368
883411b2 1369 if(fFillAngleHisto)
1370 {
1371 for(Int_t j = 0; j < 2; j++)
1372 {
1373
c8710850 1374 fhAnglePairNLocMax1[j] = new TH2F(Form("hAnglePairNLocMax1%s",sMatched[j].Data()),
883411b2 1375 Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()),
1376 nptbins,ptmin,ptmax,200,0,0.2);
c8710850 1377 fhAnglePairNLocMax1[j]->SetYTitle("#alpha (rad)");
1378 fhAnglePairNLocMax1[j]->SetXTitle("E (GeV)");
1379 outputContainer->Add(fhAnglePairNLocMax1[j]) ;
883411b2 1380
c8710850 1381 fhAnglePairNLocMax2[j] = new TH2F(Form("hAnglePairNLocMax2%s",sMatched[j].Data()),
883411b2 1382 Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()),
1383 nptbins,ptmin,ptmax,200,0,0.2);
c8710850 1384 fhAnglePairNLocMax2[j]->SetYTitle("#alpha (rad)");
1385 fhAnglePairNLocMax2[j]->SetXTitle("E (GeV)");
1386 outputContainer->Add(fhAnglePairNLocMax2[j]) ;
883411b2 1387
c8710850 1388 fhAnglePairNLocMaxN[j] = new TH2F(Form("hAnglePairNLocMaxN%s",sMatched[j].Data()),
883411b2 1389 Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()),
1390 nptbins,ptmin,ptmax,200,0,0.2);
c8710850 1391 fhAnglePairNLocMaxN[j]->SetYTitle("#alpha (rad)");
1392 fhAnglePairNLocMaxN[j]->SetXTitle("E (GeV)");
1393 outputContainer->Add(fhAnglePairNLocMaxN[j]) ;
883411b2 1394
c8710850 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()),
883411b2 1397 mbins,mmin,mmax,200,0,0.2);
c8710850 1398 fhAnglePairMassNLocMax1[j]->SetXTitle("M (GeV/c^{2})");
1399 fhAnglePairMassNLocMax1[j]->SetYTitle("#alpha (rad)");
1400 outputContainer->Add(fhAnglePairMassNLocMax1[j]) ;
883411b2 1401
c8710850 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()),
883411b2 1404 mbins,mmin,mmax,200,0,0.2);
c8710850 1405 fhAnglePairMassNLocMax2[j]->SetXTitle("M (GeV/c^{2})");
1406 fhAnglePairMassNLocMax2[j]->SetYTitle("#alpha (rad)");
1407 outputContainer->Add(fhAnglePairMassNLocMax2[j]) ;
883411b2 1408
c8710850 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()),
883411b2 1411 mbins,mmin,mmax,200,0,0.2);
c8710850 1412 fhAnglePairMassNLocMaxN[j]->SetXTitle("M (GeV/c^{2})");
1413 fhAnglePairMassNLocMaxN[j]->SetYTitle("#alpha (rad)");
1414 outputContainer->Add(fhAnglePairMassNLocMaxN[j]) ;
883411b2 1415
1416 }
992b14a7 1417 }
1418
e671adc2 1419 for(Int_t j = 0; j < 2; j++)
1420 {
1421 fhSplitEFractionvsAsyNLocMax1[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMax1%s",sMatched[j].Data()),
c8710850 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()),
e671adc2 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]) ;
1427
1428 fhSplitEFractionvsAsyNLocMax2[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMax2%s",sMatched[j].Data()),
c8710850 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()),
e671adc2 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]) ;
1434
1435 fhSplitEFractionvsAsyNLocMaxN[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMaxN%s",sMatched[j].Data()),
c8710850 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()),
e671adc2 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]) ;
1441 }
1442
1443
992b14a7 1444 return outputContainer ;
1445
1446}
1447
992b14a7 1448//___________________________________________
1449void AliAnaInsideClusterInvariantMass::Init()
1450{
1451 //Init
1452 //Do some checks
3c1d9afb 1453 if(fCalorimeter == "PHOS" && !GetReader()->IsPHOSSwitchedOn() && NewOutputAOD())
1454 {
992b14a7 1455 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!\n");
1456 abort();
1457 }
3c1d9afb 1458 else if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn() && NewOutputAOD())
1459 {
992b14a7 1460 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!\n");
1461 abort();
1462 }
1463
3c1d9afb 1464 if( GetReader()->GetDataType() == AliCaloTrackReader::kMC )
1465 {
992b14a7 1466 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use pure MC data!!\n");
1467 abort();
1468
1469 }
1470
1471}
1472
1473//_____________________________________________________
1474void AliAnaInsideClusterInvariantMass::InitParameters()
1475{
1476 //Initialize the parameters of the analysis.
1477 AddToHistogramsName("AnaPi0InsideClusterInvariantMass_");
1478
1479 fCalorimeter = "EMCAL" ;
29ca9cad 1480
71e3889f 1481 fM02MinCut = 0.26 ;
1482 fM02MaxCut = 10 ;
1483
992b14a7 1484 fMinNCells = 4 ;
2cb134fb 1485 fMinBadDist = 2 ;
3c1d9afb 1486
992b14a7 1487}
1488
1489
1490//__________________________________________________________________
1491void AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
1492{
1493 //Search for pi0 in fCalorimeter with shower shape analysis
1494
1495 TObjArray * pl = 0x0;
1496 AliVCaloCells* cells = 0x0;
1497
1498 //Select the Calorimeter of the photon
2cb134fb 1499 if(fCalorimeter == "PHOS")
1500 {
992b14a7 1501 pl = GetPHOSClusters();
1502 cells = GetPHOSCells();
1503 }
2cb134fb 1504 else if (fCalorimeter == "EMCAL")
1505 {
992b14a7 1506 pl = GetEMCALClusters();
1507 cells = GetEMCALCells();
1508 }
1509
c8710850 1510 const Float_t ecut = 12.; // Fixed cut for some histograms
e671adc2 1511
3c1d9afb 1512 if(!pl || !cells)
1513 {
992b14a7 1514 Info("MakeAnalysisFillHistograms","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data());
1515 return;
1516 }
1517
1518 if(fCalorimeter == "PHOS") return; // Not implemented for PHOS yet
1519
2cb134fb 1520 for(Int_t icluster = 0; icluster < pl->GetEntriesFast(); icluster++)
1521 {
992b14a7 1522 AliVCluster * cluster = (AliVCluster*) (pl->At(icluster));
1523
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();
2cb134fb 1528 Float_t bd = cluster->GetDistanceToBadChannel() ;
243c2909 1529
d2655d46 1530
2cb134fb 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 ;
1533
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);
1536
d2655d46 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.;
1541
1542 GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), GetReader()->GetInputEvent()->GetEMCALCells(), cluster,
1543 ll0, ll1, disp, dispEta, dispPhi, sEta, sPhi, sEtaPhi);
1544
1545 Float_t dispAsy = -1;
1546 if(dispEta+dispPhi >0 ) dispAsy = (dispPhi-dispEta) / (dispPhi+dispEta);
1547
3c1d9afb 1548 Int_t nMax = 0;
bfdcf7fb 1549 Double_t mass = 0., angle = 0.;
1550 Double_t e1 = 0., e2 = 0.;
3c1d9afb 1551 Int_t pidTag = GetCaloPID()->GetIdentifiedParticleTypeFromClusterSplitting(cluster,cells,GetCaloUtils(),
fc01318e 1552 GetVertex(0), nMax, mass, angle,e1,e2);
5c46c992 1553 if (nMax <= 0)
1554 {
de454976 1555 if(GetDebug() > 0 )
1556 printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - No local maximum found! It did not pass CaloPID selection criteria \n");
5c46c992 1557
992b14a7 1558 return;
1559 }
1560
fc01318e 1561 Float_t splitFrac = (e1+e2)/en;
e671adc2 1562 Float_t asym = -10;
1563 if(e1+e2>0) asym = (e1-e2)/(e1+e2);
1564
fc01318e 1565 Bool_t matched = IsTrackMatched(cluster,GetReader()->GetInputEvent());
cfc19369 1566
3c1d9afb 1567 fhNLocMax[0][matched]->Fill(en,nMax);
29ca9cad 1568
2a77f6f4 1569 if ( nMax == 1 )
1570 {
1571 fhM02NLocMax1[0][matched]->Fill(en,l0) ;
1572 fhSplitEFractionNLocMax1[0][matched]->Fill(en,splitFrac) ;
e671adc2 1573 if(en > ecut) fhSplitEFractionvsAsyNLocMax1[matched]->Fill(asym,splitFrac) ;
2a77f6f4 1574 if(fFillSSExtraHisto) fhNCellNLocMax1[0][matched]->Fill(en,nc) ;
1575 }
1576 else if( nMax == 2 )
1577 {
1578 fhM02NLocMax2[0][matched]->Fill(en,l0) ;
1579 fhSplitEFractionNLocMax2[0][matched]->Fill(en,splitFrac) ;
e671adc2 1580 if(en > ecut) fhSplitEFractionvsAsyNLocMax2[matched]->Fill(asym,splitFrac) ;
2a77f6f4 1581 if(fFillSSExtraHisto) fhNCellNLocMax2[0][matched]->Fill(en,nc) ; }
1582 else if( nMax >= 3 )
1583 {
1584 fhM02NLocMaxN[0][matched]->Fill(en,l0) ;
1585 fhSplitEFractionNLocMaxN[0][matched]->Fill(en,splitFrac) ;
e671adc2 1586 if(en > ecut) fhSplitEFractionvsAsyNLocMaxN[matched]->Fill(asym,splitFrac) ;
2a77f6f4 1587 if(fFillSSExtraHisto) fhNCellNLocMaxN[0][matched]->Fill(en,nc) ;
1588 }
992b14a7 1589 else printf("N max smaller than 1 -> %d \n",nMax);
5c46c992 1590
2a77f6f4 1591
5c46c992 1592 Float_t dZ = cluster->GetTrackDz();
1593 Float_t dR = cluster->GetTrackDx();
1594
1595 if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
1596 {
1597 dR = 2000., dZ = 2000.;
1598 GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
1599 }
1600 //printf("Pi0EbE: dPhi %f, dEta %f\n",dR,dZ);
1601
8e81c2cf 1602 if(TMath::Abs(dR) < 999 && fFillTMResidualHisto)
5c46c992 1603 {
c8710850 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); }
5c46c992 1607 }
fc01318e 1608
992b14a7 1609 // Play with the MC stack if available
1610 // Check origin of the candidates
8e81c2cf 1611 Int_t mcindex = -1;
1612 Float_t eprim = 0;
1613 Float_t asymGen = -2;
53f2c382 1614 Int_t mcLabel = cluster->GetLabel();
3c1d9afb 1615 if(IsDataMC())
1616 {
2644ead9 1617 Int_t tag = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(), GetReader());
992b14a7 1618
de7d73e6 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;
c5693f62 1622 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ) mcindex = kmcEta;
992b14a7 1623 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
c5693f62 1624 !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPhoton;
992b14a7 1625 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
c5693f62 1626 GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcConversion;
1627 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) mcindex = kmcElectron;
1628 else mcindex = kmcHadron;
71e3889f 1629
5c46c992 1630 fhNLocMax[mcindex][matched]->Fill(en,nMax);
3c1d9afb 1631
fc01318e 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) ; }
5c46c992 1635
8e81c2cf 1636 if(TMath::Abs(dR) < 999 && fFillTMResidualHisto)
5c46c992 1637 {
c8710850 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); }
29ca9cad 1641 }
992b14a7 1642
8e81c2cf 1643 Bool_t ok = kFALSE;
53f2c382 1644 TLorentzVector primary = GetMCAnalysisUtils()->GetMother(mcLabel,GetReader(),ok);
8e81c2cf 1645 eprim = primary.E();
1646
883411b2 1647 if(mcindex == kmcPi0 || mcindex == kmcEta)
8e81c2cf 1648 {
53f2c382 1649 if(mcindex == kmcPi0)
1650 {
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();
1654 }
1655 else
1656 {
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();
1660 }
8e81c2cf 1661 }
d2655d46 1662 }
1663
5094c724 1664 Float_t efrac = eprim/en;
bb2d339b 1665 Float_t efracSplit = 0;
1666 if(e1+e2 > 0) efracSplit = eprim/(e1+e2);
5094c724 1667
bb2d339b 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);
1670
d2655d46 1671 Int_t ebin = -1;
8e81c2cf 1672 if(en > 8 && en <= 12) ebin = 0;
1673 if(en > 12 && en <= 16) ebin = 1;
1674 if(en > 16 && en <= 20) ebin = 2;
d2655d46 1675 if(en > 20) ebin = 3;
1676
2a77f6f4 1677 if(ebin >= 0 && IsDataMC() && fFillMCFractionHisto)
53f2c382 1678 {
1679 if( !matched ) fhMCGenFracNLocMaxEbin [mcindex][ebin]->Fill(efrac,nMax);
1680 else fhMCGenFracNLocMaxEbinMatched[mcindex][ebin]->Fill(efrac,nMax);
1681 }
1682
26680f06 1683 if (nMax==1)
1684 {
e671adc2 1685 if( en > ecut )
26680f06 1686 {
d2655d46 1687 fhMassM02NLocMax1 [0][matched]->Fill(l0 , mass );
8e81c2cf 1688 if(fFillSSExtraHisto)
1689 {
1690 fhMassDispEtaNLocMax1[0][matched]->Fill(dispEta, mass );
1691 fhMassDispPhiNLocMax1[0][matched]->Fill(dispPhi, mass );
1692 fhMassDispAsyNLocMax1[0][matched]->Fill(dispAsy, mass );
1693 }
1694
a700f620 1695 if(IsDataMC())
d2655d46 1696 {
8e81c2cf 1697 fhMassM02NLocMax1 [mcindex][matched]->Fill(l0 , mass );
2a77f6f4 1698 if(fFillMCFractionHisto)
1699 {
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 );
1704 }
1705
8e81c2cf 1706 if(!matched && ebin >= 0)
1707 {
2a77f6f4 1708 if(fFillMCFractionHisto)
1709 {
1710 fhM02MCGenFracNLocMax1Ebin [mcindex][ebin]->Fill(efrac , l0 );
1711 fhMassMCGenFracNLocMax1Ebin[mcindex][ebin]->Fill(efrac , mass );
1712 }
b8eb40fc 1713 fhMCAsymM02NLocMax1MCPi0Ebin [ebin]->Fill(l0 , asymGen );
1714 fhAsyMCGenRecoNLocMax1EbinPi0[ebin]->Fill(asym, asymGen );
8e81c2cf 1715 }
1716
1717 if(fFillSSExtraHisto)
1718 {
1719 fhMassDispEtaNLocMax1[mcindex][matched]->Fill(dispEta, mass );
1720 fhMassDispPhiNLocMax1[mcindex][matched]->Fill(dispPhi, mass );
1721 fhMassDispAsyNLocMax1[mcindex][matched]->Fill(dispAsy, mass );
1722 }
d2655d46 1723 }
26680f06 1724 }
1725
d2655d46 1726 if(!matched && ebin >= 0)
26680f06 1727 {
fc01318e 1728 fhMassSplitEFractionNLocMax1Ebin[0][ebin]->Fill(splitFrac, mass);
1729 if(IsDataMC())fhMassSplitEFractionNLocMax1Ebin[mcindex][ebin]->Fill(splitFrac, mass);
1730
b8eb40fc 1731 fhMassM02NLocMax1Ebin [ebin]->Fill(l0 , mass );
1732 fhMassAsyNLocMax1Ebin [ebin]->Fill(asym, mass );
1733
8e81c2cf 1734 if(fFillSSExtraHisto)
1735 {
1736 fhMassDispEtaNLocMax1Ebin[ebin]->Fill(dispEta, mass );
1737 fhMassDispPhiNLocMax1Ebin[ebin]->Fill(dispPhi, mass );
1738 fhMassDispAsyNLocMax1Ebin[ebin]->Fill(dispAsy, mass );
1739 }
26680f06 1740 }
1741 }
1742 else if(nMax==2)
1743 {
e671adc2 1744 if( en > ecut )
d2655d46 1745 {
1746 fhMassM02NLocMax2 [0][matched]->Fill(l0 , mass );
8e81c2cf 1747 if(fFillSSExtraHisto)
1748 {
1749 fhMassDispEtaNLocMax2[0][matched]->Fill(dispEta, mass );
1750 fhMassDispPhiNLocMax2[0][matched]->Fill(dispPhi, mass );
1751 fhMassDispAsyNLocMax2[0][matched]->Fill(dispAsy, mass );
1752 }
d2655d46 1753
a700f620 1754 if(IsDataMC())
d2655d46 1755 {
5094c724 1756 fhMassM02NLocMax2 [mcindex][matched]->Fill(l0 , mass );
2a77f6f4 1757 if(fFillMCFractionHisto)
1758 {
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 );
1763 }
1764
8e81c2cf 1765 if(!matched && ebin >= 0)
1766 {
2a77f6f4 1767 if(fFillMCFractionHisto)
1768 {
1769 fhM02MCGenFracNLocMax2Ebin [mcindex][ebin]->Fill(efrac , l0 );
1770 fhMassMCGenFracNLocMax2Ebin[mcindex][ebin]->Fill(efrac , mass );
1771 }
b8eb40fc 1772 fhMCAsymM02NLocMax2MCPi0Ebin [ebin]->Fill(l0 , asymGen );
1773 fhAsyMCGenRecoNLocMax2EbinPi0[ebin]->Fill(asym, asymGen );
8e81c2cf 1774 }
1775 if(fFillSSExtraHisto)
1776 {
1777 fhMassDispEtaNLocMax2[mcindex][matched]->Fill(dispEta, mass );
1778 fhMassDispPhiNLocMax2[mcindex][matched]->Fill(dispPhi, mass );
1779 fhMassDispAsyNLocMax2[mcindex][matched]->Fill(dispAsy, mass );
1780 }
d2655d46 1781 }
26680f06 1782 }
1783
d2655d46 1784 if(!matched && ebin >= 0)
26680f06 1785 {
fc01318e 1786 fhMassSplitEFractionNLocMax2Ebin[0][ebin]->Fill(splitFrac, mass);
1787 if(IsDataMC())fhMassSplitEFractionNLocMax2Ebin[mcindex][ebin]->Fill(splitFrac, mass);
1788
b8eb40fc 1789 fhMassM02NLocMax2Ebin [ebin]->Fill(l0 , mass );
1790 fhMassAsyNLocMax2Ebin [ebin]->Fill(asym, mass );
1791
8e81c2cf 1792 if(fFillSSExtraHisto)
1793 {
1794 fhMassDispEtaNLocMax2Ebin[ebin]->Fill(dispEta, mass );
1795 fhMassDispPhiNLocMax2Ebin[ebin]->Fill(dispPhi, mass );
1796 fhMassDispAsyNLocMax2Ebin[ebin]->Fill(dispAsy, mass );
1797 }
d2655d46 1798 }
26680f06 1799 }
8e81c2cf 1800 else if(nMax > 2 )
26680f06 1801 {
e671adc2 1802 if( en > ecut )
26680f06 1803 {
d2655d46 1804 fhMassM02NLocMaxN [0][matched]->Fill(l0 , mass );
8e81c2cf 1805 if(fFillSSExtraHisto)
1806 {
1807 fhMassDispEtaNLocMaxN[0][matched]->Fill(dispEta, mass );
1808 fhMassDispPhiNLocMaxN[0][matched]->Fill(dispPhi, mass );
1809 fhMassDispAsyNLocMaxN[0][matched]->Fill(dispAsy, mass );
1810 }
d2655d46 1811
a700f620 1812 if(IsDataMC())
d2655d46 1813 {
5094c724 1814 fhMassM02NLocMaxN [mcindex][matched]->Fill(l0 , mass );
2a77f6f4 1815 if(fFillMCFractionHisto)
1816 {
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 );
1821 }
1822
8e81c2cf 1823 if(!matched && ebin >= 0)
1824 {
2a77f6f4 1825 if(fFillMCFractionHisto)
1826 {
1827 fhM02MCGenFracNLocMaxNEbin [mcindex][ebin]->Fill(efrac , l0 );
1828 fhMassMCGenFracNLocMaxNEbin[mcindex][ebin]->Fill(efrac , mass );
1829 }
b8eb40fc 1830 fhMCAsymM02NLocMaxNMCPi0Ebin [ebin]->Fill(l0 , asymGen );
1831 fhAsyMCGenRecoNLocMaxNEbinPi0[ebin]->Fill(asym, asymGen );
8e81c2cf 1832 }
1833 if(fFillSSExtraHisto)
1834 {
1835 fhMassDispEtaNLocMaxN[mcindex][matched]->Fill(dispEta, mass );
1836 fhMassDispPhiNLocMaxN[mcindex][matched]->Fill(dispPhi, mass );
1837 fhMassDispAsyNLocMaxN[mcindex][matched]->Fill(dispAsy, mass );
1838 }
d2655d46 1839 }
26680f06 1840 }
1841
d2655d46 1842 if(!matched && ebin >= 0)
26680f06 1843 {
fc01318e 1844 fhMassSplitEFractionNLocMaxNEbin[0][ebin]->Fill(splitFrac, mass);
1845 if(IsDataMC())fhMassSplitEFractionNLocMaxNEbin[mcindex][ebin]->Fill(splitFrac, mass);
1846
b8eb40fc 1847 fhMassM02NLocMaxNEbin [ebin]->Fill(l0 , mass );
1848 fhMassAsyNLocMaxNEbin [ebin]->Fill(asym, mass );
1849
8e81c2cf 1850 if(fFillSSExtraHisto)
1851 {
1852 fhMassDispEtaNLocMaxNEbin[ebin]->Fill(dispEta, mass );
1853 fhMassDispPhiNLocMaxNEbin[ebin]->Fill(dispPhi, mass );
1854 fhMassDispAsyNLocMaxNEbin[ebin]->Fill(dispAsy, mass );
1855 }
26680f06 1856 }
1857 }
1858
26680f06 1859 //---------------------------------------------------------------------
1860 // From here only if M02 is large but not too large, fill histograms
1861 //---------------------------------------------------------------------
1862
3c1d9afb 1863 if( l0 < fM02MinCut || l0 > fM02MaxCut ) continue ;
26680f06 1864
b8eb40fc 1865 Bool_t m02OK = GetCaloPID()->IsInPi0M02Range(en,l0,nMax);
167f2534 1866 Bool_t asyOK = GetCaloPID()->IsInPi0SplitAsymmetryRange(en,asym,nMax);
1867
c8710850 1868 Float_t cent = GetEventCentrality();
1869 Float_t evp = GetEventPlaneAngle();
1870
26680f06 1871 fhNLocMaxM02Cut[0][matched]->Fill(en,nMax);
1872 if(IsDataMC()) fhNLocMaxM02Cut[mcindex][matched]->Fill(en,nMax);
e671adc2 1873
243c2909 1874 if (nMax==1)
1875 {
2a77f6f4 1876 fhMassNLocMax1[0][matched]->Fill(en,mass );
667432ef 1877 fhAsymNLocMax1[0][matched]->Fill(en,asym );
1878
1879 // Effect of cuts in mass histograms
1880 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched)
2a77f6f4 1881 {
667432ef 1882 fhMassSplitECutNLocMax1->Fill(en,mass );
1883 if(m02OK)
e671adc2 1884 {
1885 fhMassM02CutNLocMax1->Fill(en,mass);
77cadd95 1886 fhAsymM02CutNLocMax1->Fill(en,asym );
667432ef 1887 if(asyOK) fhMassAfterCutsNLocMax1[0]->Fill(en,mass);
1888 } // m02
1889 } // split frac
1890
1891 if(m02OK && asyOK && !matched)
1892 {
c8710850 1893 fhSplitEFractionAfterCutsNLocMax1[0]->Fill(en,splitFrac);
316212f7 1894 if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
667432ef 1895 {
1896 fhMCGenFracAfterCutsNLocMax1MCPi0 ->Fill(en , efrac );
1897 fhMCGenSplitEFracAfterCutsNLocMax1MCPi0->Fill(en , efracSplit);
e671adc2 1898 }
2a77f6f4 1899 }
26680f06 1900
883411b2 1901 if(fFillAngleHisto)
1902 {
c8710850 1903 fhAnglePairNLocMax1[matched]->Fill(en,angle);
e671adc2 1904 if( en > ecut )
c8710850 1905 fhAnglePairMassNLocMax1[matched]->Fill(mass,angle);
0137016b 1906 }
5c46c992 1907
667432ef 1908 if(asyOK && m02OK)
1909 {
167f2534 1910 }
667432ef 1911
c8710850 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); }
1915
1916 if(!matched)
1917 {
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) ; }
1920 }
167f2534 1921 }
5c46c992 1922 else if(nMax==2)
1923 {
2a77f6f4 1924 fhMassNLocMax2[0][matched]->Fill(en,mass );
667432ef 1925 fhAsymNLocMax2[0][matched]->Fill(en,asym );
1926
1927 // Effect of cuts in mass histograms
1928 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched)
2a77f6f4 1929 {
667432ef 1930 fhMassSplitECutNLocMax2->Fill(en,mass );
1931 if(m02OK)
e671adc2 1932 {
1933 fhMassM02CutNLocMax2->Fill(en,mass);
77cadd95 1934 fhAsymM02CutNLocMax2->Fill(en,asym );
667432ef 1935 if(asyOK) fhMassAfterCutsNLocMax2[0]->Fill(en,mass);
1936 } // m02
1937 } // split frac
1938
1939 if(m02OK && asyOK && !matched)
1940 {
c8710850 1941 fhSplitEFractionAfterCutsNLocMax2[0]->Fill(en,splitFrac);
316212f7 1942 if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
667432ef 1943 {
1944 fhMCGenFracAfterCutsNLocMax2MCPi0 ->Fill(en , efrac );
1945 fhMCGenSplitEFracAfterCutsNLocMax2MCPi0->Fill(en , efracSplit);
e671adc2 1946 }
2a77f6f4 1947 }
26680f06 1948
883411b2 1949 if(fFillAngleHisto)
0137016b 1950 {
c8710850 1951 fhAnglePairNLocMax2[matched]->Fill(en,angle);
e671adc2 1952 if( en > ecut )
c8710850 1953 fhAnglePairMassNLocMax2[matched]->Fill(mass,angle);
0137016b 1954 }
667432ef 1955
c8710850 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); }
1959
1960 if(!matched)
1961 {
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) ; }
1964 }
243c2909 1965 }
5c46c992 1966 else if(nMax >2)
1967 {
2a77f6f4 1968 fhMassNLocMaxN[0][matched]->Fill(en,mass);
667432ef 1969 fhAsymNLocMaxN[0][matched]->Fill(en,asym);
1970
2a77f6f4 1971 // Effect of cuts in mass histograms
667432ef 1972 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched)
2a77f6f4 1973 {
667432ef 1974 fhMassSplitECutNLocMaxN->Fill(en,mass );
1975 if(m02OK)
e671adc2 1976 {
1977 fhMassM02CutNLocMaxN->Fill(en,mass);
77cadd95 1978 fhAsymM02CutNLocMaxN->Fill(en,asym );
667432ef 1979 if(asyOK) fhMassAfterCutsNLocMaxN[0]->Fill(en,mass);
1980 } // m02
1981 } // split frac
1982
1983 if(m02OK && asyOK && !matched)
1984 {
c8710850 1985 fhSplitEFractionAfterCutsNLocMaxN[0]->Fill(en,splitFrac);
316212f7 1986 if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0)
667432ef 1987 {
1988 fhMCGenFracAfterCutsNLocMaxNMCPi0 ->Fill(en , efrac );
1989 fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0->Fill(en , efracSplit);
e671adc2 1990 }
2a77f6f4 1991 }
26680f06 1992
667432ef 1993 if(fFillAngleHisto)
883411b2 1994 {
c8710850 1995 fhAnglePairNLocMaxN[matched]->Fill(en,angle);
e671adc2 1996 if( en > ecut )
c8710850 1997 fhAnglePairMassNLocMaxN[matched]->Fill(mass,angle);
0137016b 1998 }
667432ef 1999
c8710850 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); }
2003
2004 if(!matched)
2005 {
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) ; }
2008 }
2009
243c2909 2010 }
2011
26680f06 2012
3c1d9afb 2013 if(IsDataMC())
2014 {
243c2909 2015 if (nMax==1)
2016 {
667432ef 2017 fhMassNLocMax1[mcindex][matched]->Fill(en,mass);
2018 fhAsymNLocMax1[mcindex][matched]->Fill(en,asym);
2019
c8710850 2020 if(asyOK && m02OK && !matched)
2021 {
2022 fhSplitEFractionAfterCutsNLocMax1[mcindex]->Fill(en,splitFrac);
2023 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum())
2024 fhMassAfterCutsNLocMax1[mcindex]->Fill(en,mass);
2025 }
667432ef 2026
c8710850 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); }
243c2909 2030 }
0137016b 2031 else if(nMax==2)
2032 {
5c46c992 2033 fhMassNLocMax2[mcindex][matched]->Fill(en,mass);
667432ef 2034 fhAsymNLocMax2[mcindex][matched]->Fill(en,asym);
2035
c8710850 2036 if(asyOK && m02OK && !matched)
2037 {
2038 fhSplitEFractionAfterCutsNLocMax2[mcindex]->Fill(en,splitFrac);
2039 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum())
2040 fhMassAfterCutsNLocMax2[mcindex]->Fill(en,mass);
2041 }
667432ef 2042
c8710850 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); }
bb2d339b 2046
243c2909 2047 }
0137016b 2048 else if(nMax >2)
2049 {
5c46c992 2050 fhMassNLocMaxN[mcindex][matched]->Fill(en,mass);
667432ef 2051 fhAsymNLocMaxN[mcindex][matched]->Fill(en,asym);
2052
c8710850 2053 if(asyOK && m02OK && !matched)
2054 {
2055 fhSplitEFractionAfterCutsNLocMaxN[mcindex]->Fill(en,splitFrac);
2056 if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum())
2057 fhMassAfterCutsNLocMaxN[mcindex]->Fill(en,mass);
2058 }
667432ef 2059
c8710850 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); }
243c2909 2063 }
992b14a7 2064
2065 }//Work with MC truth first
5c46c992 2066
992b14a7 2067 }//loop
2068
2069 if(GetDebug() > 1) printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - END \n");
e23a0471 2070
992b14a7 2071}
2072
2073//______________________________________________________________________
2074void AliAnaInsideClusterInvariantMass::Print(const Option_t * opt) const
2075{
2076 //Print some relevant parameters set for the analysis
2077 if(! opt)
2078 return;
2079
2080 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
745913ae 2081 AliAnaCaloTrackCorrBaseClass::Print("");
243c2909 2082 printf("Calorimeter = %s\n", fCalorimeter.Data()) ;
dbba06ca 2083 printf("Loc. Max. E > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutE());
2084 printf("Loc. Max. E Diff > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutEDiff());
cfc19369 2085 printf("Min. N Cells =%d \n", fMinNCells) ;
2086 printf("Min. Dist. to Bad =%1.1f \n", fMinBadDist) ;
71e3889f 2087 printf("%2.2f < lambda_0^2 <%2.2f \n",fM02MinCut,fM02MaxCut);
3c1d9afb 2088
992b14a7 2089 printf(" \n") ;
2090
2091}
2092
dbba06ca 2093
992b14a7 2094