]> 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
Fix how the trigger histogram is filled
[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),
60 fFillSSExtraHisto(kFALSE)
992b14a7 61{
62 //default ctor
63
64 // Init array of histograms
5c46c992 65 for(Int_t i = 0; i < 7; i++)
66 {
67 for(Int_t j = 0; j < 2; j++)
68 {
5c46c992 69 fhMassNLocMax1[i][j] = 0;
70 fhMassNLocMax2[i][j] = 0;
71 fhMassNLocMaxN[i][j] = 0;
72 fhNLocMax[i][j] = 0;
5c46c992 73 fhNLocMaxM02Cut[i][j] = 0;
74 fhM02NLocMax1[i][j] = 0;
75 fhM02NLocMax2[i][j] = 0;
76 fhM02NLocMaxN[i][j] = 0;
77 fhNCellNLocMax1[i][j] = 0;
78 fhNCellNLocMax2[i][j] = 0;
79 fhNCellNLocMaxN[i][j] = 0;
80 fhM02Pi0LocMax1[i][j] = 0;
81 fhM02EtaLocMax1[i][j] = 0;
82 fhM02ConLocMax1[i][j] = 0;
83 fhM02Pi0LocMax2[i][j] = 0;
84 fhM02EtaLocMax2[i][j] = 0;
85 fhM02ConLocMax2[i][j] = 0;
86 fhM02Pi0LocMaxN[i][j] = 0;
87 fhM02EtaLocMaxN[i][j] = 0;
88 fhM02ConLocMaxN[i][j] = 0;
89
0137016b 90 fhMassM02NLocMax1[i][j]= 0;
91 fhMassM02NLocMax2[i][j]= 0;
d2655d46 92 fhMassM02NLocMaxN[i][j]= 0;
93 fhMassDispEtaNLocMax1[i][j]= 0;
94 fhMassDispEtaNLocMax2[i][j]= 0;
95 fhMassDispEtaNLocMaxN[i][j]= 0;
96 fhMassDispPhiNLocMax1[i][j]= 0;
97 fhMassDispPhiNLocMax2[i][j]= 0;
98 fhMassDispPhiNLocMaxN[i][j]= 0;
99 fhMassDispAsyNLocMax1[i][j]= 0;
100 fhMassDispAsyNLocMax2[i][j]= 0;
101 fhMassDispAsyNLocMaxN[i][j]= 0;
8e81c2cf 102
fc01318e 103 fhSplitEFractionNLocMax1[i][j]=0;
104 fhSplitEFractionNLocMax2[i][j]=0;
105 fhSplitEFractionNLocMaxN[i][j]=0;
106
8e81c2cf 107 fhMCGenFracNLocMax1[i][j]= 0;
108 fhMCGenFracNLocMax2[i][j]= 0;
109 fhMCGenFracNLocMaxN[i][j]= 0;
5094c724 110
111 fhMCGenSplitEFracNLocMax1[i][j]= 0;
112 fhMCGenSplitEFracNLocMax2[i][j]= 0;
113 fhMCGenSplitEFracNLocMaxN[i][j]= 0;
8e81c2cf 114 }
115
116 for(Int_t jj = 0; jj < 4; jj++)
117 {
53f2c382 118 fhM02MCGenFracNLocMax1Ebin[i][jj] = 0;
119 fhM02MCGenFracNLocMax2Ebin[i][jj] = 0;
120 fhM02MCGenFracNLocMaxNEbin[i][jj] = 0;
8e81c2cf 121
122 fhMassMCGenFracNLocMax1Ebin[i][jj]= 0;
123 fhMassMCGenFracNLocMax2Ebin[i][jj]= 0;
124 fhMassMCGenFracNLocMaxNEbin[i][jj]= 0;
53f2c382 125
fc01318e 126 fhMCGenFracNLocMaxEbin[i][jj] = 0;
53f2c382 127 fhMCGenFracNLocMaxEbinMatched[i][jj]= 0;
fc01318e 128
129 fhMassSplitEFractionNLocMax1Ebin[i][jj] = 0;
130 fhMassSplitEFractionNLocMax2Ebin[i][jj] = 0;
131 fhMassSplitEFractionNLocMaxNEbin[i][jj] = 0;
5c46c992 132 }
133
134 fhTrackMatchedDEtaLocMax1[i] = 0;
135 fhTrackMatchedDPhiLocMax1[i] = 0;
136 fhTrackMatchedDEtaLocMax2[i] = 0;
137 fhTrackMatchedDPhiLocMax2[i] = 0;
138 fhTrackMatchedDEtaLocMaxN[i] = 0;
139 fhTrackMatchedDPhiLocMaxN[i] = 0;
243c2909 140
992b14a7 141 }
142
5c46c992 143 for(Int_t i = 0; i < 2; i++)
144 {
145 fhAnglePairLocMax1 [i] = 0;
146 fhAnglePairLocMax2 [i] = 0;
147 fhAnglePairLocMaxN [i] = 0;
148 fhAnglePairMassLocMax1[i] = 0;
149 fhAnglePairMassLocMax2[i] = 0;
150 fhAnglePairMassLocMaxN[i] = 0;
151 }
152
7b686344 153 for(Int_t i = 0; i < 4; i++)
154 {
155 fhMassM02NLocMax1Ebin[i] = 0 ;
156 fhMassM02NLocMax2Ebin[i] = 0 ;
157 fhMassM02NLocMaxNEbin[i] = 0 ;
d2655d46 158
159 fhMassDispEtaNLocMax1Ebin[i] = 0 ;
160 fhMassDispEtaNLocMax2Ebin[i] = 0 ;
161 fhMassDispEtaNLocMaxNEbin[i] = 0 ;
162
163 fhMassDispPhiNLocMax1Ebin[i] = 0 ;
164 fhMassDispPhiNLocMax2Ebin[i] = 0 ;
165 fhMassDispPhiNLocMaxNEbin[i] = 0 ;
166
167 fhMassDispAsyNLocMax1Ebin[i] = 0 ;
168 fhMassDispAsyNLocMax2Ebin[i] = 0 ;
169 fhMassDispAsyNLocMaxNEbin[i] = 0 ;
8e81c2cf 170
171 fhMCAsymM02NLocMax1MCPi0Ebin[i] = 0 ;
172 fhMCAsymM02NLocMax2MCPi0Ebin[i] = 0 ;
173 fhMCAsymM02NLocMaxNMCPi0Ebin[i] = 0 ;
7b686344 174 }
175
992b14a7 176 InitParameters();
177
178}
179
180//_______________________________________________________________
181TObjString * AliAnaInsideClusterInvariantMass::GetAnalysisCuts()
182{
183 //Save parameters used for analysis
184 TString parList ; //this will be list of parameters used for this analysis.
185 const Int_t buffersize = 255;
186 char onePar[buffersize] ;
187
188 snprintf(onePar,buffersize,"--- AliAnaInsideClusterInvariantMass ---\n") ;
189 parList+=onePar ;
190
243c2909 191 snprintf(onePar,buffersize,"Calorimeter: %s\n", fCalorimeter.Data()) ;
992b14a7 192 parList+=onePar ;
dbba06ca 193 snprintf(onePar,buffersize,"fLocMaxCutE =%2.2f \n", GetCaloUtils()->GetLocalMaximaCutE()) ;
29ca9cad 194 parList+=onePar ;
dbba06ca 195 snprintf(onePar,buffersize,"fLocMaxCutEDiff =%2.2f \n",GetCaloUtils()->GetLocalMaximaCutEDiff()) ;
29ca9cad 196 parList+=onePar ;
71e3889f 197 snprintf(onePar,buffersize,"%2.2f< M02 < %2.2f \n", fM02MinCut, fM02MaxCut) ;
992b14a7 198 parList+=onePar ;
e23a0471 199 snprintf(onePar,buffersize,"fMinNCells =%d \n", fMinNCells) ;
2cb134fb 200 parList+=onePar ;
3c1d9afb 201 snprintf(onePar,buffersize,"fMinBadDist =%1.1f \n", fMinBadDist) ;
992b14a7 202 parList+=onePar ;
243c2909 203
992b14a7 204 return new TObjString(parList) ;
205
206}
207
992b14a7 208//________________________________________________________________
209TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
210{
211 // Create histograms to be saved in output file and
212 // store them in outputContainer
213 TList * outputContainer = new TList() ;
214 outputContainer->SetName("InsideClusterHistos") ;
215
745913ae 216 Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t ptmin = GetHistogramRanges()->GetHistoPtMin();
217 Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins(); Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax(); Float_t ssmin = GetHistogramRanges()->GetHistoShowerShapeMin();
218 Int_t mbins = GetHistogramRanges()->GetHistoMassBins(); Float_t mmax = GetHistogramRanges()->GetHistoMassMax(); Float_t mmin = GetHistogramRanges()->GetHistoMassMin();
219 Int_t ncbins = GetHistogramRanges()->GetHistoNClusterCellBins(); Int_t ncmax = GetHistogramRanges()->GetHistoNClusterCellMax(); Int_t ncmin = GetHistogramRanges()->GetHistoNClusterCellMin();
992b14a7 220
5c46c992 221 Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
222 Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
223 Float_t resetamin = GetHistogramRanges()->GetHistoTrackResidualEtaMin();
224 Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
225 Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
226 Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
227
992b14a7 228 TString ptype[] ={"","#gamma","#gamma->e^{#pm}","#pi^{0}","#eta","e^{#pm}", "hadron"};
229 TString pname[] ={"","Photon","Conversion", "Pi0", "Eta", "Electron","Hadron"};
230
231 Int_t n = 1;
232
233 if(IsDataMC()) n = 7;
234
243c2909 235 Int_t nMaxBins = 10;
236
5c46c992 237 TString sMatched[] = {"","Matched"};
238
239 for(Int_t i = 0; i < n; i++)
240 {
5c46c992 241 for(Int_t j = 0; j < 2; j++)
242 {
243
244 fhMassNLocMax1[i][j] = new TH2F(Form("hMassNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
0137016b 245 Form("Invariant mass of 2 highest energy cells vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
5c46c992 246 nptbins,ptmin,ptmax,mbins,mmin,mmax);
247 fhMassNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
248 fhMassNLocMax1[i][j]->SetXTitle("E (GeV)");
249 outputContainer->Add(fhMassNLocMax1[i][j]) ;
250
251 fhMassNLocMax2[i][j] = new TH2F(Form("hMassNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
0137016b 252 Form("Invariant mass of 2 local maxima cells vs E,%s %s",ptype[i].Data(),sMatched[j].Data()),
5c46c992 253 nptbins,ptmin,ptmax,mbins,mmin,mmax);
254 fhMassNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
255 fhMassNLocMax2[i][j]->SetXTitle("E (GeV)");
256 outputContainer->Add(fhMassNLocMax2[i][j]) ;
257
258 fhMassNLocMaxN[i][j] = new TH2F(Form("hMassNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
0137016b 259 Form("Invariant mass of N>2 local maxima cells vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
5c46c992 260 nptbins,ptmin,ptmax,mbins,mmin,mmax);
261 fhMassNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
262 fhMassNLocMaxN[i][j]->SetXTitle("E (GeV)");
263 outputContainer->Add(fhMassNLocMaxN[i][j]) ;
264
0137016b 265 fhMassM02NLocMax1[i][j] = new TH2F(Form("hMassM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
266 Form("Invariant mass of 2 highest energy cells #lambda_{0}^{2}, E > 7 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
267 ssbins,ssmin,ssmax,mbins,mmin,mmax);
268 fhMassM02NLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
269 fhMassM02NLocMax1[i][j]->SetXTitle("#lambda_{0}^{2}");
270 outputContainer->Add(fhMassM02NLocMax1[i][j]) ;
271
272 fhMassM02NLocMax2[i][j] = new TH2F(Form("hMassM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
273 Form("Invariant mass of 2 local maxima cells #lambda_{0}^{2}, E > 7 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
274 ssbins,ssmin,ssmax,mbins,mmin,mmax);
275 fhMassM02NLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
276 fhMassM02NLocMax2[i][j]->SetXTitle("#lambda_{0}^{2}");
277 outputContainer->Add(fhMassM02NLocMax2[i][j]) ;
278
279 fhMassM02NLocMaxN[i][j] = new TH2F(Form("hMassM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
280 Form("Invariant mass of N>2 local maxima cells vs #lambda_{0}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
281 ssbins,ssmin,ssmax,mbins,mmin,mmax);
282 fhMassM02NLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
283 fhMassM02NLocMaxN[i][j]->SetXTitle("#lambda_{0}^{2}");
284 outputContainer->Add(fhMassM02NLocMaxN[i][j]) ;
285
8e81c2cf 286 if(fFillSSExtraHisto)
287 {
288 fhMassDispEtaNLocMax1[i][j] = new TH2F(Form("hMassDispEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
289 Form("Invariant mass of 2 highest energy cells #sigma_{#eta #eta}^{2}, E > 7 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
290 ssbins,ssmin,ssmax,mbins,mmin,mmax);
291 fhMassDispEtaNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
292 fhMassDispEtaNLocMax1[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
293 outputContainer->Add(fhMassDispEtaNLocMax1[i][j]) ;
294
295 fhMassDispEtaNLocMax2[i][j] = new TH2F(Form("hMassDispEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
296 Form("Invariant mass of 2 local maxima cells #sigma_{#eta #eta}^{2}, E > 7 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
297 ssbins,ssmin,ssmax,mbins,mmin,mmax);
298 fhMassDispEtaNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
299 fhMassDispEtaNLocMax2[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
300 outputContainer->Add(fhMassDispEtaNLocMax2[i][j]) ;
301
302 fhMassDispEtaNLocMaxN[i][j] = new TH2F(Form("hMassDispEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
303 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#eta #eta}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
304 ssbins,ssmin,ssmax,mbins,mmin,mmax);
305 fhMassDispEtaNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
306 fhMassDispEtaNLocMaxN[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
307 outputContainer->Add(fhMassDispEtaNLocMaxN[i][j]) ;
308
309 fhMassDispPhiNLocMax1[i][j] = new TH2F(Form("hMassDispPhiNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
310 Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E > 7 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
311 ssbins,ssmin,ssmax,mbins,mmin,mmax);
312 fhMassDispPhiNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
313 fhMassDispPhiNLocMax1[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
314 outputContainer->Add(fhMassDispPhiNLocMax1[i][j]) ;
315
316 fhMassDispPhiNLocMax2[i][j] = new TH2F(Form("hMassDispPhiNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
317 Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E > 7 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
318 ssbins,ssmin,ssmax,mbins,mmin,mmax);
319 fhMassDispPhiNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
320 fhMassDispPhiNLocMax2[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
321 outputContainer->Add(fhMassDispPhiNLocMax2[i][j]) ;
322
323 fhMassDispPhiNLocMaxN[i][j] = new TH2F(Form("hMassDispPhiNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
324 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
325 ssbins,ssmin,ssmax,mbins,mmin,mmax);
326 fhMassDispPhiNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
327 fhMassDispPhiNLocMaxN[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
328 outputContainer->Add(fhMassDispPhiNLocMaxN[i][j]) ;
329
330 fhMassDispAsyNLocMax1[i][j] = new TH2F(Form("hMassDispAsyNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
331 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 > 7 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
332 200,-1,1,mbins,mmin,mmax);
333 fhMassDispAsyNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
334 fhMassDispAsyNLocMax1[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
335 outputContainer->Add(fhMassDispAsyNLocMax1[i][j]) ;
336
337 fhMassDispAsyNLocMax2[i][j] = new TH2F(Form("hMassDispAsyNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
338 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 > 7 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
339 200,-1,1,mbins,mmin,mmax);
340 fhMassDispAsyNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
341 fhMassDispAsyNLocMax2[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
342 outputContainer->Add(fhMassDispAsyNLocMax2[i][j]) ;
343
344 fhMassDispAsyNLocMaxN[i][j] = new TH2F(Form("hMassDispAsyNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
345 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()),
346 200,-1,1,mbins,mmin,mmax);
347 fhMassDispAsyNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
348 fhMassDispAsyNLocMaxN[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
349 outputContainer->Add(fhMassDispAsyNLocMaxN[i][j]) ;
350 }
d2655d46 351
5c46c992 352 fhNLocMax[i][j] = new TH2F(Form("hNLocMax%s%s",pname[i].Data(),sMatched[j].Data()),
353 Form("Number of local maxima in cluster %s %s",ptype[i].Data(),sMatched[j].Data()),
354 nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
355 fhNLocMax[i][j] ->SetYTitle("N maxima");
356 fhNLocMax[i][j] ->SetXTitle("E (GeV)");
357 outputContainer->Add(fhNLocMax[i][j]) ;
3c1d9afb 358
5c46c992 359 fhNLocMaxM02Cut[i][j] = new TH2F(Form("hNLocMaxM02Cut%s%s",pname[i].Data(),sMatched[j].Data()),
71e3889f 360 Form("Number of local maxima in cluster %s for %2.2f < M02 < %2.2f",ptype[i].Data(),fM02MinCut,fM02MaxCut),
5c46c992 361 nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
362 fhNLocMaxM02Cut[i][j]->SetYTitle("N maxima");
363 fhNLocMaxM02Cut[i][j]->SetXTitle("E (GeV)");
364 outputContainer->Add(fhNLocMaxM02Cut[i][j]) ;
365
366
367 fhM02NLocMax1[i][j] = new TH2F(Form("hM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
368 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
369 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
370 fhM02NLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
371 fhM02NLocMax1[i][j] ->SetXTitle("E (GeV)");
372 outputContainer->Add(fhM02NLocMax1[i][j]) ;
373
374 fhM02NLocMax2[i][j] = new TH2F(Form("hM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
375 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
376 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
377 fhM02NLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
378 fhM02NLocMax2[i][j] ->SetXTitle("E (GeV)");
379 outputContainer->Add(fhM02NLocMax2[i][j]) ;
380
5c46c992 381 fhM02NLocMaxN[i][j] = new TH2F(Form("hM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
382 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
383 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
384 fhM02NLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
385 fhM02NLocMaxN[i][j] ->SetXTitle("E (GeV)");
386 outputContainer->Add(fhM02NLocMaxN[i][j]) ;
387
fc01318e 388
389 fhSplitEFractionNLocMax1[i][j] = new TH2F(Form("hSplitEFractionNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
390 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
391 nptbins,ptmin,ptmax,120,0,1.2);
392 fhSplitEFractionNLocMax1[i][j] ->SetXTitle("E_{cluster} (GeV)");
393 fhSplitEFractionNLocMax1[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
394 outputContainer->Add(fhSplitEFractionNLocMax1[i][j]) ;
395
396 fhSplitEFractionNLocMax2[i][j] = new TH2F(Form("hSplitEFractionNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
397 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
398 nptbins,ptmin,ptmax,120,0,1.2);
399 fhSplitEFractionNLocMax2[i][j] ->SetXTitle("E_{cluster} (GeV)");
400 fhSplitEFractionNLocMax2[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
401 outputContainer->Add(fhSplitEFractionNLocMax2[i][j]) ;
402
403 fhSplitEFractionNLocMaxN[i][j] = new TH2F(Form("hSplitEFractionNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
404 Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
405 nptbins,ptmin,ptmax,120,0,1.2);
406 fhSplitEFractionNLocMaxN[i][j] ->SetXTitle("E_{cluster} (GeV)");
407 fhSplitEFractionNLocMaxN[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
408 outputContainer->Add(fhSplitEFractionNLocMaxN[i][j]) ;
409
410
883411b2 411 if(i > 0) // skip first entry in array, general case not filled
412 {
413 fhMCGenFracNLocMax1[i][j] = new TH2F(Form("hMCGenFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
414 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
415 nptbins,ptmin,ptmax,200,0,2);
fb51265c 416 fhMCGenFracNLocMax1[i][j] ->SetYTitle("E_{gen} / E_{reco}");
883411b2 417 fhMCGenFracNLocMax1[i][j] ->SetXTitle("E (GeV)");
418 outputContainer->Add(fhMCGenFracNLocMax1[i][j]) ;
419
420 fhMCGenFracNLocMax2[i][j] = new TH2F(Form("hMCGenFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
421 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
422 nptbins,ptmin,ptmax,200,0,2);
fb51265c 423 fhMCGenFracNLocMax2[i][j] ->SetYTitle("E_{gen} / E_{reco}");
883411b2 424 fhMCGenFracNLocMax2[i][j] ->SetXTitle("E (GeV)");
425 outputContainer->Add(fhMCGenFracNLocMax2[i][j]) ;
426
427
428 fhMCGenFracNLocMaxN[i][j] = new TH2F(Form("hMCGenFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
429 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
430 nptbins,ptmin,ptmax,200,0,2);
fb51265c 431 fhMCGenFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / E_{reco}");
883411b2 432 fhMCGenFracNLocMaxN[i][j] ->SetXTitle("E (GeV)");
433 outputContainer->Add(fhMCGenFracNLocMaxN[i][j]) ;
5094c724 434
435 fhMCGenSplitEFracNLocMax1[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
436 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
437 nptbins,ptmin,ptmax,200,0,2);
438 fhMCGenSplitEFracNLocMax1[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
439 fhMCGenSplitEFracNLocMax1[i][j] ->SetXTitle("E (GeV)");
440 outputContainer->Add(fhMCGenSplitEFracNLocMax1[i][j]) ;
441
442 fhMCGenSplitEFracNLocMax2[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
443 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
444 nptbins,ptmin,ptmax,200,0,2);
445 fhMCGenSplitEFracNLocMax2[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
446 fhMCGenSplitEFracNLocMax2[i][j] ->SetXTitle("E (GeV)");
447 outputContainer->Add(fhMCGenSplitEFracNLocMax2[i][j]) ;
448
449
450 fhMCGenSplitEFracNLocMaxN[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
451 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
452 nptbins,ptmin,ptmax,200,0,2);
453 fhMCGenSplitEFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
454 fhMCGenSplitEFracNLocMaxN[i][j] ->SetXTitle("E (GeV)");
455 outputContainer->Add(fhMCGenSplitEFracNLocMaxN[i][j]) ;
53f2c382 456
883411b2 457 }
5c46c992 458
8e81c2cf 459 if(fFillSSExtraHisto)
460 {
461 fhNCellNLocMax1[i][j] = new TH2F(Form("hNCellNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
462 Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
463 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
464 fhNCellNLocMax1[i][j] ->SetYTitle("N cells");
465 fhNCellNLocMax1[i][j] ->SetXTitle("E (GeV)");
466 outputContainer->Add(fhNCellNLocMax1[i][j]) ;
467
468 fhNCellNLocMax2[i][j] = new TH2F(Form("hNCellNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
469 Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
470 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
471 fhNCellNLocMax2[i][j] ->SetYTitle("N cells");
472 fhNCellNLocMax2[i][j] ->SetXTitle("E (GeV)");
473 outputContainer->Add(fhNCellNLocMax2[i][j]) ;
474
475
476 fhNCellNLocMaxN[i][j] = new TH2F(Form("hNCellNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
477 Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
478 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
479 fhNCellNLocMaxN[i][j] ->SetYTitle("N cells");
480 fhNCellNLocMaxN[i][j] ->SetXTitle("E (GeV)");
481 outputContainer->Add(fhNCellNLocMaxN[i][j]) ;
482 }
5c46c992 483
484 fhM02Pi0LocMax1[i][j] = new TH2F(Form("hM02Pi0LocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 485 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1",
486 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
5c46c992 487 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
488 fhM02Pi0LocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
489 fhM02Pi0LocMax1[i][j] ->SetXTitle("E (GeV)");
490 outputContainer->Add(fhM02Pi0LocMax1[i][j]) ;
491
492 fhM02EtaLocMax1[i][j] = new TH2F(Form("hM02EtaLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 493 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1",
494 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
5c46c992 495 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
496 fhM02EtaLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
497 fhM02EtaLocMax1[i][j] ->SetXTitle("E (GeV)");
498 outputContainer->Add(fhM02EtaLocMax1[i][j]) ;
499
500 fhM02ConLocMax1[i][j] = new TH2F(Form("hM02ConLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 501 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1",
502 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
5c46c992 503 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
504 fhM02ConLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}");
505 fhM02ConLocMax1[i][j] ->SetXTitle("E (GeV)");
506 outputContainer->Add(fhM02ConLocMax1[i][j]) ;
507
508 fhM02Pi0LocMax2[i][j] = new TH2F(Form("hM02Pi0LocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 509 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2",
510 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
5c46c992 511 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
512 fhM02Pi0LocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
513 fhM02Pi0LocMax2[i][j] ->SetXTitle("E (GeV)");
514 outputContainer->Add(fhM02Pi0LocMax2[i][j]) ;
515
516 fhM02EtaLocMax2[i][j] = new TH2F(Form("hM02EtaLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 517 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2",
518 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
5c46c992 519 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
520 fhM02EtaLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
521 fhM02EtaLocMax2[i][j] ->SetXTitle("E (GeV)");
522 outputContainer->Add(fhM02EtaLocMax2[i][j]) ;
523
524 fhM02ConLocMax2[i][j] = new TH2F(Form("hM02ConLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 525 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2",
526 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
5c46c992 527 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
528 fhM02ConLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}");
529 fhM02ConLocMax2[i][j] ->SetXTitle("E (GeV)");
530 outputContainer->Add(fhM02ConLocMax2[i][j]) ;
531
532 fhM02Pi0LocMaxN[i][j] = new TH2F(Form("hM02Pi0LocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 533 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2",
534 GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()),
5c46c992 535 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
536 fhM02Pi0LocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
537 fhM02Pi0LocMaxN[i][j] ->SetXTitle("E (GeV)");
538 outputContainer->Add(fhM02Pi0LocMaxN[i][j]) ;
539
540 fhM02EtaLocMaxN[i][j] = new TH2F(Form("hM02EtaLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 541 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max > 2",
542 GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()),
5c46c992 543 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
544 fhM02EtaLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
545 fhM02EtaLocMaxN[i][j] ->SetXTitle("E (GeV)");
546 outputContainer->Add(fhM02EtaLocMaxN[i][j]) ;
547
548 fhM02ConLocMaxN[i][j] = new TH2F(Form("hM02ConLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
3c1d9afb 549 Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2",
550 GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()),
5c46c992 551 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
552 fhM02ConLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}");
553 fhM02ConLocMaxN[i][j] ->SetXTitle("E (GeV)");
554 outputContainer->Add(fhM02ConLocMaxN[i][j]) ;
555
556 } // matched, not matched
557
883411b2 558 for(Int_t j = 0; j < 4; j++)
559 {
53f2c382 560
fc01318e 561 fhMassSplitEFractionNLocMax1Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax1%sEbin%d",pname[i].Data(),j),
562 Form("Invariant mass of 2 highest energy cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
563 120,0,1.2,mbins,mmin,mmax);
564 fhMassSplitEFractionNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
565 fhMassSplitEFractionNLocMax1Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
566 outputContainer->Add(fhMassSplitEFractionNLocMax1Ebin[i][j]) ;
883411b2 567
fc01318e 568 fhMassSplitEFractionNLocMax2Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax2%sEbin%d",pname[i].Data(),j),
569 Form("Invariant mass of 2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
570 120,0,1.2,mbins,mmin,mmax);
571 fhMassSplitEFractionNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
572 fhMassSplitEFractionNLocMax2Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
573 outputContainer->Add(fhMassSplitEFractionNLocMax2Ebin[i][j]) ;
883411b2 574
fc01318e 575 fhMassSplitEFractionNLocMaxNEbin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMaxN%sEbin%d",pname[i].Data(),j),
576 Form("Invariant mass of N>2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
577 120,0,1.2,mbins,mmin,mmax);
578 fhMassSplitEFractionNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
579 fhMassSplitEFractionNLocMaxNEbin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
580 outputContainer->Add(fhMassSplitEFractionNLocMaxNEbin[i][j]) ;
883411b2 581
fc01318e 582 if(i>0) // skip first entry in array, general case not filled
583 {
584 fhMCGenFracNLocMaxEbin[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%d",pname[i].Data(),j),
585 Form("NLM vs E, %s, E bin %d",ptype[i].Data(),j),
586 200,0,2,nMaxBins,0,nMaxBins);
587 fhMCGenFracNLocMaxEbin[i][j]->SetYTitle("NLM");
fb51265c 588 fhMCGenFracNLocMaxEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 589 outputContainer->Add(fhMCGenFracNLocMaxEbin[i][j]) ;
590
591 fhMCGenFracNLocMaxEbinMatched[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%dMatched",pname[i].Data(),j),
592 Form("NLM vs E, %s, E bin %d, matched to a track",ptype[i].Data(),j),
593 200,0,2,nMaxBins,0,nMaxBins);
594 fhMCGenFracNLocMaxEbinMatched[i][j]->SetYTitle("NLM");
fb51265c 595 fhMCGenFracNLocMaxEbinMatched[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 596 outputContainer->Add(fhMCGenFracNLocMaxEbinMatched[i][j]) ;
597
598 fhMassMCGenFracNLocMax1Ebin[i][j] = new TH2F(Form("hMassMCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
599 Form("Invariant mass of 2 highest energy cells vs E, %s, E bin %d",ptype[i].Data(),j),
600 200,0,2,mbins,mmin,mmax);
601 fhMassMCGenFracNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
fb51265c 602 fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 603 outputContainer->Add(fhMassMCGenFracNLocMax1Ebin[i][j]) ;
604
605 fhMassMCGenFracNLocMax2Ebin[i][j] = new TH2F(Form("hMassMCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
606 Form("Invariant mass of 2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
607 200,0,2,mbins,mmin,mmax);
608 fhMassMCGenFracNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
fb51265c 609 fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 610 outputContainer->Add(fhMassMCGenFracNLocMax2Ebin[i][j]) ;
611
612 fhMassMCGenFracNLocMaxNEbin[i][j] = new TH2F(Form("hMassMCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
613 Form("Invariant mass of N>2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
614 200,0,2,mbins,mmin,mmax);
615 fhMassMCGenFracNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
fb51265c 616 fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
fc01318e 617 outputContainer->Add(fhMassMCGenFracNLocMaxNEbin[i][j]) ;
618
619 fhM02MCGenFracNLocMax1Ebin[i][j] = new TH2F(Form("hM02MCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
620 Form("#lambda_{0}^{2} vs E for N max = 1 %s, E bin %d",ptype[i].Data(), j),
621 200,0,2,ssbins,ssmin,ssmax);
622 fhM02MCGenFracNLocMax1Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}");
fb51265c 623 fhM02MCGenFracNLocMax1Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
fc01318e 624 outputContainer->Add(fhM02MCGenFracNLocMax1Ebin[i][j]) ;
625
626 fhM02MCGenFracNLocMax2Ebin[i][j] = new TH2F(Form("hM02MCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
627 Form("#lambda_{0}^{2} vs E for N max = 2 %s, E bin %d",ptype[i].Data(),j),
628 200,0,2,ssbins,ssmin,ssmax);
629 fhM02MCGenFracNLocMax2Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}");
fb51265c 630 fhM02MCGenFracNLocMax2Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
fc01318e 631 outputContainer->Add(fhM02MCGenFracNLocMax2Ebin[i][j]) ;
632
633 fhM02MCGenFracNLocMaxNEbin[i][j] = new TH2F(Form("hM02MCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
634 Form("#lambda_{0}^{2} vs E for N max > 2 %s, E bin %d",ptype[i].Data(),j),
635 200,0,2,ssbins,ssmin,ssmax);
636 fhM02MCGenFracNLocMaxNEbin[i][j] ->SetYTitle("#lambda_{0}^{2}");
fb51265c 637 fhM02MCGenFracNLocMaxNEbin[i][j] ->SetXTitle("E_{gen} / E_{reco}");
fc01318e 638 outputContainer->Add(fhM02MCGenFracNLocMaxNEbin[i][j]) ;
639 }
883411b2 640 }
5c46c992 641 } // MC particle list
642
7b686344 643 for(Int_t i = 0; i < 4; i++)
644 {
8e81c2cf 645
646 if(IsDataMC())
647 {
648 fhMCAsymM02NLocMax1MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax1MCPi0Ebin%d",i),
649 Form("Asymmetry of MC #pi^{0} of 2 highest energy cells #lambda_{0}^{2}, E bin %d",i),
883411b2 650 ssbins,ssmin,ssmax,100,0,1);
8e81c2cf 651 fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
652 fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
653 outputContainer->Add(fhMCAsymM02NLocMax1MCPi0Ebin[i]) ;
654
655 fhMCAsymM02NLocMax2MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax2MCPi0Ebin%d",i),
656 Form("Asymmetry of MC #pi^{0} of 2 local maxima cells #lambda_{0}^{2}, E bin %d",i),
883411b2 657 ssbins,ssmin,ssmax,100,0,1);
8e81c2cf 658 fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
659 fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
660 outputContainer->Add(fhMCAsymM02NLocMax2MCPi0Ebin[i]) ;
661
662 fhMCAsymM02NLocMaxNMCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMaxNMCPi0Ebin%d",i),
663 Form("Asymmetry of MC #pi^{0} of N>2 local maxima cells vs #lambda_{0}^{2}, E bin %d",i),
883411b2 664 ssbins,ssmin,ssmax,100,0,1);
8e81c2cf 665 fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetYTitle("Decay asymmetry");
666 fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
667 outputContainer->Add(fhMCAsymM02NLocMaxNMCPi0Ebin[i]) ;
668 }
669
7b686344 670 fhMassM02NLocMax1Ebin[i] = new TH2F(Form("hMassM02NLocMax1Ebin%d",i),
671 Form("Invariant mass of 2 highest energy cells #lambda_{0}^{2}, E bin %d",i),
672 ssbins,ssmin,ssmax,mbins,mmin,mmax);
673 fhMassM02NLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
674 fhMassM02NLocMax1Ebin[i]->SetXTitle("#lambda_{0}^{2}");
675 outputContainer->Add(fhMassM02NLocMax1Ebin[i]) ;
676
677 fhMassM02NLocMax2Ebin[i] = new TH2F(Form("hMassM02NLocMax2Ebin%d",i),
678 Form("Invariant mass of 2 local maxima cells #lambda_{0}^{2}, E bin %d",i),
679 ssbins,ssmin,ssmax,mbins,mmin,mmax);
680 fhMassM02NLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
681 fhMassM02NLocMax2Ebin[i]->SetXTitle("#lambda_{0}^{2}");
682 outputContainer->Add(fhMassM02NLocMax2Ebin[i]) ;
683
684 fhMassM02NLocMaxNEbin[i] = new TH2F(Form("hMassM02NLocMaxNEbin%d",i),
685 Form("Invariant mass of N>2 local maxima cells vs #lambda_{0}^{2}, E bin %d",i),
686 ssbins,ssmin,ssmax,mbins,mmin,mmax);
687 fhMassM02NLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
688 fhMassM02NLocMaxNEbin[i]->SetXTitle("#lambda_{0}^{2}");
d2655d46 689 outputContainer->Add(fhMassM02NLocMaxNEbin[i]) ;
690
8e81c2cf 691 if(fFillSSExtraHisto)
692 {
693 fhMassDispEtaNLocMax1Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax1Ebin%d",i),
694 Form("Invariant mass of 2 highest energy cells #sigma_{#eta #eta}^{2}, E bin %d",i),
695 ssbins,ssmin,ssmax,mbins,mmin,mmax);
696 fhMassDispEtaNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
697 fhMassDispEtaNLocMax1Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
698 outputContainer->Add(fhMassDispEtaNLocMax1Ebin[i]) ;
699
700 fhMassDispEtaNLocMax2Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax2Ebin%d",i),
701 Form("Invariant mass of 2 local maxima cells #sigma_{#eta #eta}^{2}, E bin %d",i),
702 ssbins,ssmin,ssmax,mbins,mmin,mmax);
703 fhMassDispEtaNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
704 fhMassDispEtaNLocMax2Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
705 outputContainer->Add(fhMassDispEtaNLocMax2Ebin[i]) ;
706
707 fhMassDispEtaNLocMaxNEbin[i] = new TH2F(Form("hMassDispEtaNLocMaxNEbin%d",i),
708 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#eta #eta}^{2}, E bin %d",i),
709 ssbins,ssmin,ssmax,mbins,mmin,mmax);
710 fhMassDispEtaNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
711 fhMassDispEtaNLocMaxNEbin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
712 outputContainer->Add(fhMassDispEtaNLocMaxNEbin[i]) ;
713
714 fhMassDispPhiNLocMax1Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax1Ebin%d",i),
715 Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E bin %d",i),
716 ssbins,ssmin,ssmax,mbins,mmin,mmax);
717 fhMassDispPhiNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
718 fhMassDispPhiNLocMax1Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
719 outputContainer->Add(fhMassDispPhiNLocMax1Ebin[i]) ;
720
721 fhMassDispPhiNLocMax2Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax2Ebin%d",i),
722 Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E bin %d",i),
723 ssbins,ssmin,ssmax,mbins,mmin,mmax);
724 fhMassDispPhiNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
725 fhMassDispPhiNLocMax2Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
726 outputContainer->Add(fhMassDispPhiNLocMax2Ebin[i]) ;
727
728 fhMassDispPhiNLocMaxNEbin[i] = new TH2F(Form("hMassDispPhiNLocMaxNEbin%d",i),
729 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, E bin %d",i),
730 ssbins,ssmin,ssmax,mbins,mmin,mmax);
731 fhMassDispPhiNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
732 fhMassDispPhiNLocMaxNEbin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
733 outputContainer->Add(fhMassDispPhiNLocMaxNEbin[i]) ;
734
735 fhMassDispAsyNLocMax1Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax1Ebin%d",i),
736 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),
737 200,-1,1,mbins,mmin,mmax);
738 fhMassDispAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
739 fhMassDispAsyNLocMax1Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
740 outputContainer->Add(fhMassDispAsyNLocMax1Ebin[i]) ;
741
742 fhMassDispAsyNLocMax2Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax2Ebin%d",i),
743 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),
744 200,-1,1,mbins,mmin,mmax);
745 fhMassDispAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
746 fhMassDispAsyNLocMax2Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
747 outputContainer->Add(fhMassDispAsyNLocMax2Ebin[i]) ;
748
749 fhMassDispAsyNLocMaxNEbin[i] = new TH2F(Form("hMassDispAsyNLocMaxNEbin%d",i),
750 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),
751 200,-1,1,mbins,mmin,mmax);
752 fhMassDispAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
753 fhMassDispAsyNLocMaxNEbin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
754 outputContainer->Add(fhMassDispAsyNLocMaxNEbin[i]) ;
755 }
7b686344 756 }
757
8e81c2cf 758 if(fFillTMResidualHisto)
759 {
760 for(Int_t i = 0; i < n; i++)
761 {
762
763 fhTrackMatchedDEtaLocMax1[i] = new TH2F
764 (Form("hTrackMatchedDEtaLocMax1%s",pname[i].Data()),
765 Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
766 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
767 fhTrackMatchedDEtaLocMax1[i]->SetYTitle("d#eta");
768 fhTrackMatchedDEtaLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
769
770 fhTrackMatchedDPhiLocMax1[i] = new TH2F
771 (Form("hTrackMatchedDPhiLocMax1%s",pname[i].Data()),
772 Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
773 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
774 fhTrackMatchedDPhiLocMax1[i]->SetYTitle("d#phi (rad)");
775 fhTrackMatchedDPhiLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
776
777 outputContainer->Add(fhTrackMatchedDEtaLocMax1[i]) ;
778 outputContainer->Add(fhTrackMatchedDPhiLocMax1[i]) ;
779
780 fhTrackMatchedDEtaLocMax2[i] = new TH2F
781 (Form("hTrackMatchedDEtaLocMax2%s",pname[i].Data()),
782 Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
783 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
784 fhTrackMatchedDEtaLocMax2[i]->SetYTitle("d#eta");
785 fhTrackMatchedDEtaLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
786
787 fhTrackMatchedDPhiLocMax2[i] = new TH2F
788 (Form("hTrackMatchedDPhiLocMax2%s",pname[i].Data()),
789 Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
790 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
791 fhTrackMatchedDPhiLocMax2[i]->SetYTitle("d#phi (rad)");
792 fhTrackMatchedDPhiLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
793
794 outputContainer->Add(fhTrackMatchedDEtaLocMax2[i]) ;
795 outputContainer->Add(fhTrackMatchedDPhiLocMax2[i]) ;
796
797 fhTrackMatchedDEtaLocMaxN[i] = new TH2F
798 (Form("hTrackMatchedDEtaLocMaxN%s",pname[i].Data()),
799 Form("d#eta of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
800 nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
801 fhTrackMatchedDEtaLocMaxN[i]->SetYTitle("d#eta");
802 fhTrackMatchedDEtaLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
803
804 fhTrackMatchedDPhiLocMaxN[i] = new TH2F
805 (Form("hTrackMatchedDPhiLocMaxN%s",pname[i].Data()),
806 Form("d#phi of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
807 nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
808 fhTrackMatchedDPhiLocMaxN[i]->SetYTitle("d#phi (rad)");
809 fhTrackMatchedDPhiLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
810
811 outputContainer->Add(fhTrackMatchedDEtaLocMaxN[i]) ;
812 outputContainer->Add(fhTrackMatchedDPhiLocMaxN[i]) ;
813 }
5c46c992 814 }
815
883411b2 816 if(fFillAngleHisto)
817 {
818 for(Int_t j = 0; j < 2; j++)
819 {
820
821 fhAnglePairLocMax1[j] = new TH2F(Form("hAnglePairLocMax1%s",sMatched[j].Data()),
822 Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()),
823 nptbins,ptmin,ptmax,200,0,0.2);
824 fhAnglePairLocMax1[j]->SetYTitle("#alpha (rad)");
825 fhAnglePairLocMax1[j]->SetXTitle("E (GeV)");
826 outputContainer->Add(fhAnglePairLocMax1[j]) ;
827
828 fhAnglePairLocMax2[j] = new TH2F(Form("hAnglePairLocMax2%s",sMatched[j].Data()),
829 Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()),
830 nptbins,ptmin,ptmax,200,0,0.2);
831 fhAnglePairLocMax2[j]->SetYTitle("#alpha (rad)");
832 fhAnglePairLocMax2[j]->SetXTitle("E (GeV)");
833 outputContainer->Add(fhAnglePairLocMax2[j]) ;
834
835 fhAnglePairLocMaxN[j] = new TH2F(Form("hAnglePairLocMaxN%s",sMatched[j].Data()),
836 Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()),
837 nptbins,ptmin,ptmax,200,0,0.2);
838 fhAnglePairLocMaxN[j]->SetYTitle("#alpha (rad)");
839 fhAnglePairLocMaxN[j]->SetXTitle("E (GeV)");
840 outputContainer->Add(fhAnglePairLocMaxN[j]) ;
841
842 fhAnglePairMassLocMax1[j] = new TH2F(Form("hAnglePairMassLocMax1%s",sMatched[j].Data()),
843 Form("Opening angle of 2 highest energy cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
844 mbins,mmin,mmax,200,0,0.2);
845 fhAnglePairMassLocMax1[j]->SetXTitle("M (GeV/c^{2})");
846 fhAnglePairMassLocMax1[j]->SetYTitle("#alpha (rad)");
847 outputContainer->Add(fhAnglePairMassLocMax1[j]) ;
848
849 fhAnglePairMassLocMax2[j] = new TH2F(Form("hAnglePairMassLocMax2%s",sMatched[j].Data()),
850 Form("Opening angle of 2 local maxima cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
851 mbins,mmin,mmax,200,0,0.2);
852 fhAnglePairMassLocMax2[j]->SetXTitle("M (GeV/c^{2})");
853 fhAnglePairMassLocMax2[j]->SetYTitle("#alpha (rad)");
854 outputContainer->Add(fhAnglePairMassLocMax2[j]) ;
855
856 fhAnglePairMassLocMaxN[j] = new TH2F(Form("hAnglePairMassLocMaxN%s",sMatched[j].Data()),
857 Form("Opening angle of N>2 local maxima cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()),
858 mbins,mmin,mmax,200,0,0.2);
859 fhAnglePairMassLocMaxN[j]->SetXTitle("M (GeV/c^{2})");
860 fhAnglePairMassLocMaxN[j]->SetYTitle("#alpha (rad)");
861 outputContainer->Add(fhAnglePairMassLocMaxN[j]) ;
862
863 }
992b14a7 864 }
865
866 return outputContainer ;
867
868}
869
992b14a7 870//___________________________________________
871void AliAnaInsideClusterInvariantMass::Init()
872{
873 //Init
874 //Do some checks
3c1d9afb 875 if(fCalorimeter == "PHOS" && !GetReader()->IsPHOSSwitchedOn() && NewOutputAOD())
876 {
992b14a7 877 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!\n");
878 abort();
879 }
3c1d9afb 880 else if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn() && NewOutputAOD())
881 {
992b14a7 882 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!\n");
883 abort();
884 }
885
3c1d9afb 886 if( GetReader()->GetDataType() == AliCaloTrackReader::kMC )
887 {
992b14a7 888 printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use pure MC data!!\n");
889 abort();
890
891 }
892
893}
894
895//_____________________________________________________
896void AliAnaInsideClusterInvariantMass::InitParameters()
897{
898 //Initialize the parameters of the analysis.
899 AddToHistogramsName("AnaPi0InsideClusterInvariantMass_");
900
901 fCalorimeter = "EMCAL" ;
29ca9cad 902
71e3889f 903 fM02MinCut = 0.26 ;
904 fM02MaxCut = 10 ;
905
992b14a7 906 fMinNCells = 4 ;
2cb134fb 907 fMinBadDist = 2 ;
3c1d9afb 908
992b14a7 909}
910
911
912//__________________________________________________________________
913void AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
914{
915 //Search for pi0 in fCalorimeter with shower shape analysis
916
917 TObjArray * pl = 0x0;
918 AliVCaloCells* cells = 0x0;
919
920 //Select the Calorimeter of the photon
2cb134fb 921 if(fCalorimeter == "PHOS")
922 {
992b14a7 923 pl = GetPHOSClusters();
924 cells = GetPHOSCells();
925 }
2cb134fb 926 else if (fCalorimeter == "EMCAL")
927 {
992b14a7 928 pl = GetEMCALClusters();
929 cells = GetEMCALCells();
930 }
931
3c1d9afb 932 if(!pl || !cells)
933 {
992b14a7 934 Info("MakeAnalysisFillHistograms","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data());
935 return;
936 }
937
938 if(fCalorimeter == "PHOS") return; // Not implemented for PHOS yet
939
2cb134fb 940 for(Int_t icluster = 0; icluster < pl->GetEntriesFast(); icluster++)
941 {
992b14a7 942 AliVCluster * cluster = (AliVCluster*) (pl->At(icluster));
943
944 // Study clusters with large shape parameter
945 Float_t en = cluster->E();
946 Float_t l0 = cluster->GetM02();
947 Int_t nc = cluster->GetNCells();
2cb134fb 948 Float_t bd = cluster->GetDistanceToBadChannel() ;
243c2909 949
d2655d46 950
2cb134fb 951 //If too small or big E or low number of cells, or close to a bad channel skip it
952 if( en < GetMinEnergy() || en > GetMaxEnergy() || nc < fMinNCells || bd < fMinBadDist) continue ;
953
954 //printf("en %2.2f, GetMinEnergy() %2.2f, GetMaxEnergy() %2.2f, nc %d, fMinNCells %d, bd %2.2f, fMinBadDist %2.2f\n",
955 // en,GetMinEnergy(), GetMaxEnergy(), nc, fMinNCells, bd, fMinBadDist);
956
d2655d46 957 // Get more Shower Shape parameters
958 Float_t ll0 = 0., ll1 = 0.;
959 Float_t disp= 0., dispEta = 0., dispPhi = 0.;
960 Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
961
962 GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), GetReader()->GetInputEvent()->GetEMCALCells(), cluster,
963 ll0, ll1, disp, dispEta, dispPhi, sEta, sPhi, sEtaPhi);
964
965 Float_t dispAsy = -1;
966 if(dispEta+dispPhi >0 ) dispAsy = (dispPhi-dispEta) / (dispPhi+dispEta);
967
3c1d9afb 968 Int_t nMax = 0;
bfdcf7fb 969 Double_t mass = 0., angle = 0.;
970 Double_t e1 = 0., e2 = 0.;
3c1d9afb 971 Int_t pidTag = GetCaloPID()->GetIdentifiedParticleTypeFromClusterSplitting(cluster,cells,GetCaloUtils(),
fc01318e 972 GetVertex(0), nMax, mass, angle,e1,e2);
5c46c992 973 if (nMax <= 0)
974 {
de454976 975 if(GetDebug() > 0 )
976 printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - No local maximum found! It did not pass CaloPID selection criteria \n");
5c46c992 977
992b14a7 978 return;
979 }
980
fc01318e 981 Float_t splitFrac = (e1+e2)/en;
982 //printf("e1 %f, e2 %f, sum %f, cluster %f, fract %f \n",e1,e2,e1+e2,en,splitFrac);
983
984 Bool_t matched = IsTrackMatched(cluster,GetReader()->GetInputEvent());
cfc19369 985
3c1d9afb 986 fhNLocMax[0][matched]->Fill(en,nMax);
29ca9cad 987
fc01318e 988 if ( nMax == 1 ) { fhM02NLocMax1[0][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax1[0][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax1[0][matched]->Fill(en,nc) ; }
989 else if( nMax == 2 ) { fhM02NLocMax2[0][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax2[0][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax2[0][matched]->Fill(en,nc) ; }
990 else if( nMax >= 3 ) { fhM02NLocMaxN[0][matched]->Fill(en,l0) ; fhSplitEFractionNLocMaxN[0][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMaxN[0][matched]->Fill(en,nc) ; }
992b14a7 991 else printf("N max smaller than 1 -> %d \n",nMax);
5c46c992 992
993 Float_t dZ = cluster->GetTrackDz();
994 Float_t dR = cluster->GetTrackDx();
995
996 if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
997 {
998 dR = 2000., dZ = 2000.;
999 GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
1000 }
1001 //printf("Pi0EbE: dPhi %f, dEta %f\n",dR,dZ);
1002
8e81c2cf 1003 if(TMath::Abs(dR) < 999 && fFillTMResidualHisto)
5c46c992 1004 {
1005 if ( nMax == 1 ) { fhTrackMatchedDEtaLocMax1[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMax1[0]->Fill(en,dR); }
1006 else if( nMax == 2 ) { fhTrackMatchedDEtaLocMax2[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMax2[0]->Fill(en,dR); }
1007 else if( nMax >= 3 ) { fhTrackMatchedDEtaLocMaxN[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMaxN[0]->Fill(en,dR); }
1008 }
fc01318e 1009
992b14a7 1010 // Play with the MC stack if available
1011 // Check origin of the candidates
8e81c2cf 1012 Int_t mcindex = -1;
1013 Float_t eprim = 0;
1014 Float_t asymGen = -2;
53f2c382 1015 Int_t mcLabel = cluster->GetLabel();
3c1d9afb 1016 if(IsDataMC())
1017 {
992b14a7 1018 Int_t tag = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(), GetReader(), 0);
1019
c5693f62 1020 if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ) mcindex = kmcPi0;
1021 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ) mcindex = kmcEta;
992b14a7 1022 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
c5693f62 1023 !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPhoton;
992b14a7 1024 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
c5693f62 1025 GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcConversion;
1026 else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) mcindex = kmcElectron;
1027 else mcindex = kmcHadron;
71e3889f 1028
5c46c992 1029 fhNLocMax[mcindex][matched]->Fill(en,nMax);
3c1d9afb 1030
fc01318e 1031 if (nMax == 1 ) { fhM02NLocMax1[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax1[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax1[mcindex][matched]->Fill(en,nc) ; }
1032 else if(nMax == 2 ) { fhM02NLocMax2[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax2[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax2[mcindex][matched]->Fill(en,nc) ; }
1033 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 1034
8e81c2cf 1035 if(TMath::Abs(dR) < 999 && fFillTMResidualHisto)
5c46c992 1036 {
1037 if ( nMax == 1 ) { fhTrackMatchedDEtaLocMax1[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMax1[mcindex]->Fill(en,dR); }
1038 else if( nMax == 2 ) { fhTrackMatchedDEtaLocMax2[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMax2[mcindex]->Fill(en,dR); }
1039 else if( nMax >= 3 ) { fhTrackMatchedDEtaLocMaxN[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMaxN[mcindex]->Fill(en,dR); }
29ca9cad 1040 }
992b14a7 1041
8e81c2cf 1042 Bool_t ok = kFALSE;
53f2c382 1043 TLorentzVector primary = GetMCAnalysisUtils()->GetMother(mcLabel,GetReader(),ok);
8e81c2cf 1044 eprim = primary.E();
1045
883411b2 1046 if(mcindex == kmcPi0 || mcindex == kmcEta)
8e81c2cf 1047 {
53f2c382 1048 if(mcindex == kmcPi0)
1049 {
1050 asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,111,GetReader(),ok));
1051 TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,111,GetReader(),ok);
1052 if(grandmom.E() > 0 && ok) eprim = grandmom.E();
1053 }
1054 else
1055 {
1056 asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,221,GetReader(),ok));
1057 TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,221,GetReader(),ok);
1058 if(grandmom.E() > 0 && ok) eprim = grandmom.E();
1059 }
8e81c2cf 1060 }
d2655d46 1061 }
1062
5094c724 1063 Float_t efrac = eprim/en;
1064 Float_t efracSplit = eprim/(e1+e2);
1065
d2655d46 1066 Int_t ebin = -1;
8e81c2cf 1067 if(en > 8 && en <= 12) ebin = 0;
1068 if(en > 12 && en <= 16) ebin = 1;
1069 if(en > 16 && en <= 20) ebin = 2;
d2655d46 1070 if(en > 20) ebin = 3;
1071
53f2c382 1072 if(ebin >= 0 && IsDataMC())
1073 {
1074 if( !matched ) fhMCGenFracNLocMaxEbin [mcindex][ebin]->Fill(efrac,nMax);
1075 else fhMCGenFracNLocMaxEbinMatched[mcindex][ebin]->Fill(efrac,nMax);
1076 }
1077
26680f06 1078 if (nMax==1)
1079 {
1080 if( en > 7 )
1081 {
d2655d46 1082 fhMassM02NLocMax1 [0][matched]->Fill(l0 , mass );
8e81c2cf 1083 if(fFillSSExtraHisto)
1084 {
1085 fhMassDispEtaNLocMax1[0][matched]->Fill(dispEta, mass );
1086 fhMassDispPhiNLocMax1[0][matched]->Fill(dispPhi, mass );
1087 fhMassDispAsyNLocMax1[0][matched]->Fill(dispAsy, mass );
1088 }
1089
a700f620 1090 if(IsDataMC())
d2655d46 1091 {
8e81c2cf 1092 fhMassM02NLocMax1 [mcindex][matched]->Fill(l0 , mass );
1093 fhMCGenFracNLocMax1 [mcindex][matched]->Fill(en , efrac );
5094c724 1094 fhMCGenSplitEFracNLocMax1 [mcindex][matched]->Fill(en , efracSplit );
1095
8e81c2cf 1096 if(!matched && ebin >= 0)
1097 {
1098 fhM02MCGenFracNLocMax1Ebin [mcindex][ebin]->Fill(efrac , l0 );
1099 fhMassMCGenFracNLocMax1Ebin[mcindex][ebin]->Fill(efrac , mass );
1100 fhMCAsymM02NLocMax1MCPi0Ebin [ebin]->Fill(l0 , asymGen );
1101 }
1102
1103 if(fFillSSExtraHisto)
1104 {
1105 fhMassDispEtaNLocMax1[mcindex][matched]->Fill(dispEta, mass );
1106 fhMassDispPhiNLocMax1[mcindex][matched]->Fill(dispPhi, mass );
1107 fhMassDispAsyNLocMax1[mcindex][matched]->Fill(dispAsy, mass );
1108 }
d2655d46 1109 }
26680f06 1110 }
1111
d2655d46 1112 if(!matched && ebin >= 0)
26680f06 1113 {
fc01318e 1114 fhMassSplitEFractionNLocMax1Ebin[0][ebin]->Fill(splitFrac, mass);
1115 if(IsDataMC())fhMassSplitEFractionNLocMax1Ebin[mcindex][ebin]->Fill(splitFrac, mass);
1116
8e81c2cf 1117 fhMassM02NLocMax1Ebin [ebin]->Fill(l0 , mass );
1118 if(fFillSSExtraHisto)
1119 {
1120 fhMassDispEtaNLocMax1Ebin[ebin]->Fill(dispEta, mass );
1121 fhMassDispPhiNLocMax1Ebin[ebin]->Fill(dispPhi, mass );
1122 fhMassDispAsyNLocMax1Ebin[ebin]->Fill(dispAsy, mass );
1123 }
26680f06 1124 }
1125 }
1126 else if(nMax==2)
1127 {
d2655d46 1128 if( en > 7 )
1129 {
1130 fhMassM02NLocMax2 [0][matched]->Fill(l0 , mass );
8e81c2cf 1131 if(fFillSSExtraHisto)
1132 {
1133 fhMassDispEtaNLocMax2[0][matched]->Fill(dispEta, mass );
1134 fhMassDispPhiNLocMax2[0][matched]->Fill(dispPhi, mass );
1135 fhMassDispAsyNLocMax2[0][matched]->Fill(dispAsy, mass );
1136 }
d2655d46 1137
a700f620 1138 if(IsDataMC())
d2655d46 1139 {
5094c724 1140 fhMassM02NLocMax2 [mcindex][matched]->Fill(l0 , mass );
1141 fhMCGenFracNLocMax2 [mcindex][matched]->Fill(en , efrac );
1142 fhMCGenSplitEFracNLocMax2[mcindex][matched]->Fill(en , efracSplit );
1143
8e81c2cf 1144 if(!matched && ebin >= 0)
1145 {
1146 fhM02MCGenFracNLocMax2Ebin [mcindex][ebin]->Fill(efrac , l0 );
1147 fhMassMCGenFracNLocMax2Ebin[mcindex][ebin]->Fill(efrac , mass );
1148 fhMCAsymM02NLocMax2MCPi0Ebin [ebin]->Fill(l0 , asymGen );
1149
1150 }
1151 if(fFillSSExtraHisto)
1152 {
1153 fhMassDispEtaNLocMax2[mcindex][matched]->Fill(dispEta, mass );
1154 fhMassDispPhiNLocMax2[mcindex][matched]->Fill(dispPhi, mass );
1155 fhMassDispAsyNLocMax2[mcindex][matched]->Fill(dispAsy, mass );
1156 }
d2655d46 1157 }
26680f06 1158 }
1159
d2655d46 1160 if(!matched && ebin >= 0)
26680f06 1161 {
fc01318e 1162 fhMassSplitEFractionNLocMax2Ebin[0][ebin]->Fill(splitFrac, mass);
1163 if(IsDataMC())fhMassSplitEFractionNLocMax2Ebin[mcindex][ebin]->Fill(splitFrac, mass);
1164
d2655d46 1165 fhMassM02NLocMax2Ebin [ebin]->Fill(l0 , mass );
8e81c2cf 1166 if(fFillSSExtraHisto)
1167 {
1168 fhMassDispEtaNLocMax2Ebin[ebin]->Fill(dispEta, mass );
1169 fhMassDispPhiNLocMax2Ebin[ebin]->Fill(dispPhi, mass );
1170 fhMassDispAsyNLocMax2Ebin[ebin]->Fill(dispAsy, mass );
1171 }
d2655d46 1172 }
26680f06 1173 }
8e81c2cf 1174 else if(nMax > 2 )
26680f06 1175 {
1176 if( en > 7 )
1177 {
d2655d46 1178 fhMassM02NLocMaxN [0][matched]->Fill(l0 , mass );
8e81c2cf 1179 if(fFillSSExtraHisto)
1180 {
1181 fhMassDispEtaNLocMaxN[0][matched]->Fill(dispEta, mass );
1182 fhMassDispPhiNLocMaxN[0][matched]->Fill(dispPhi, mass );
1183 fhMassDispAsyNLocMaxN[0][matched]->Fill(dispAsy, mass );
1184 }
d2655d46 1185
a700f620 1186 if(IsDataMC())
d2655d46 1187 {
5094c724 1188 fhMassM02NLocMaxN [mcindex][matched]->Fill(l0 , mass );
1189 fhMCGenFracNLocMaxN [mcindex][matched]->Fill(en , efrac );
1190 fhMCGenSplitEFracNLocMaxN[mcindex][matched]->Fill(en , efracSplit );
1191
8e81c2cf 1192 if(!matched && ebin >= 0)
1193 {
53f2c382 1194 fhM02MCGenFracNLocMaxNEbin [mcindex][ebin]->Fill(efrac , l0 );
1195 fhMassMCGenFracNLocMaxNEbin[mcindex][ebin]->Fill(efrac , mass );
8e81c2cf 1196 fhMCAsymM02NLocMaxNMCPi0Ebin [ebin]->Fill(l0 , asymGen);
1197 }
1198 if(fFillSSExtraHisto)
1199 {
1200 fhMassDispEtaNLocMaxN[mcindex][matched]->Fill(dispEta, mass );
1201 fhMassDispPhiNLocMaxN[mcindex][matched]->Fill(dispPhi, mass );
1202 fhMassDispAsyNLocMaxN[mcindex][matched]->Fill(dispAsy, mass );
1203 }
d2655d46 1204 }
26680f06 1205 }
1206
d2655d46 1207 if(!matched && ebin >= 0)
26680f06 1208 {
fc01318e 1209 fhMassSplitEFractionNLocMaxNEbin[0][ebin]->Fill(splitFrac, mass);
1210 if(IsDataMC())fhMassSplitEFractionNLocMaxNEbin[mcindex][ebin]->Fill(splitFrac, mass);
1211
d2655d46 1212 fhMassM02NLocMaxNEbin [ebin]->Fill(l0 , mass );
8e81c2cf 1213 if(fFillSSExtraHisto)
1214 {
1215 fhMassDispEtaNLocMaxNEbin[ebin]->Fill(dispEta, mass );
1216 fhMassDispPhiNLocMaxNEbin[ebin]->Fill(dispPhi, mass );
1217 fhMassDispAsyNLocMaxNEbin[ebin]->Fill(dispAsy, mass );
1218 }
26680f06 1219 }
1220 }
1221
26680f06 1222 //---------------------------------------------------------------------
1223 // From here only if M02 is large but not too large, fill histograms
1224 //---------------------------------------------------------------------
1225
3c1d9afb 1226 if( l0 < fM02MinCut || l0 > fM02MaxCut ) continue ;
26680f06 1227
1228 fhNLocMaxM02Cut[0][matched]->Fill(en,nMax);
1229 if(IsDataMC()) fhNLocMaxM02Cut[mcindex][matched]->Fill(en,nMax);
1230
243c2909 1231 if (nMax==1)
1232 {
0137016b 1233 fhMassNLocMax1[0][matched] ->Fill(en,mass );
26680f06 1234
883411b2 1235 if(fFillAngleHisto)
1236 {
1237 fhAnglePairLocMax1[matched]->Fill(en,angle);
0137016b 1238 if( en > 7 )
5c46c992 1239 fhAnglePairMassLocMax1[matched]->Fill(mass,angle);
0137016b 1240 }
5c46c992 1241
3c1d9afb 1242 if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax1[0][matched]->Fill(en,l0);
1243 else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMax1[0][matched]->Fill(en,l0);
1244 else if(pidTag==AliCaloPID::kEta) fhM02EtaLocMax1[0][matched]->Fill(en,l0);
243c2909 1245 }
5c46c992 1246 else if(nMax==2)
1247 {
0137016b 1248 fhMassNLocMax2[0] [matched]->Fill(en,mass );
26680f06 1249
883411b2 1250 if(fFillAngleHisto)
0137016b 1251 {
883411b2 1252 fhAnglePairLocMax2[matched]->Fill(en,angle);
1253 if( en > 7 )
1254 fhAnglePairMassLocMax2[matched]->Fill(mass,angle);
0137016b 1255 }
5c46c992 1256
3c1d9afb 1257 if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax2[0][matched]->Fill(en,l0);
1258 else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMax2[0][matched]->Fill(en,l0);
1259 else if(pidTag==AliCaloPID::kEta) fhM02EtaLocMax2[0][matched]->Fill(en,l0);
243c2909 1260 }
5c46c992 1261 else if(nMax >2)
1262 {
0137016b 1263 fhMassNLocMaxN[0] [matched]->Fill(en,mass );
26680f06 1264
883411b2 1265 if(fFillAngleHisto)
1266 {
1267 fhAnglePairLocMaxN[matched]->Fill(en,angle);
1268 if( en > 7 )
1269 fhAnglePairMassLocMaxN[matched]->Fill(mass,angle);
0137016b 1270 }
5c46c992 1271
3c1d9afb 1272 if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMaxN[0][matched]->Fill(en,l0);
1273 else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMaxN[0][matched]->Fill(en,l0);
1274 else if(pidTag==AliCaloPID::kEta ) fhM02EtaLocMaxN[0][matched]->Fill(en,l0);
243c2909 1275 }
1276
26680f06 1277
3c1d9afb 1278 if(IsDataMC())
1279 {
243c2909 1280 if (nMax==1)
1281 {
5c46c992 1282 fhMassNLocMax1[mcindex][matched]->Fill(en,mass);
3c1d9afb 1283 if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax1[mcindex][matched]->Fill(en,l0);
8e81c2cf 1284 else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMax1[mcindex][matched]->Fill(en,l0);
1285 else if(pidTag==AliCaloPID::kEta ) fhM02EtaLocMax1[mcindex][matched]->Fill(en,l0);
243c2909 1286 }
0137016b 1287 else if(nMax==2)
1288 {
5c46c992 1289 fhMassNLocMax2[mcindex][matched]->Fill(en,mass);
3c1d9afb 1290 if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax2[mcindex][matched]->Fill(en,l0);
1291 else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMax2[mcindex][matched]->Fill(en,l0);
1292 else if(pidTag==AliCaloPID::kEta ) fhM02EtaLocMax2[mcindex][matched]->Fill(en,l0);
243c2909 1293 }
0137016b 1294 else if(nMax >2)
1295 {
5c46c992 1296 fhMassNLocMaxN[mcindex][matched]->Fill(en,mass);
3c1d9afb 1297 if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMaxN[mcindex][matched]->Fill(en,l0);
1298 else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMaxN[mcindex][matched]->Fill(en,l0);
8e81c2cf 1299 else if(pidTag==AliCaloPID::kEta ) fhM02EtaLocMaxN[mcindex][matched]->Fill(en,l0);
243c2909 1300 }
992b14a7 1301
1302 }//Work with MC truth first
5c46c992 1303
992b14a7 1304 }//loop
1305
1306 if(GetDebug() > 1) printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - END \n");
e23a0471 1307
992b14a7 1308}
1309
1310//______________________________________________________________________
1311void AliAnaInsideClusterInvariantMass::Print(const Option_t * opt) const
1312{
1313 //Print some relevant parameters set for the analysis
1314 if(! opt)
1315 return;
1316
1317 printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
745913ae 1318 AliAnaCaloTrackCorrBaseClass::Print("");
243c2909 1319 printf("Calorimeter = %s\n", fCalorimeter.Data()) ;
dbba06ca 1320 printf("Loc. Max. E > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutE());
1321 printf("Loc. Max. E Diff > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutEDiff());
cfc19369 1322 printf("Min. N Cells =%d \n", fMinNCells) ;
1323 printf("Min. Dist. to Bad =%1.1f \n", fMinBadDist) ;
71e3889f 1324 printf("%2.2f < lambda_0^2 <%2.2f \n",fM02MinCut,fM02MaxCut);
3c1d9afb 1325
992b14a7 1326 printf(" \n") ;
1327
1328}
1329
dbba06ca 1330
992b14a7 1331