]>
Commit | Line | Data |
---|---|---|
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 | 50 | ClassImp(AliAnaInsideClusterInvariantMass) |
51 | ||
52 | //__________________________________________________________________ | |
53 | AliAnaInsideClusterInvariantMass::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), | |
71 | fhSplitEFractionAfterCutsNLocMax1(0), | |
72 | fhSplitEFractionAfterCutsNLocMax2(0), | |
73 | fhSplitEFractionAfterCutsNLocMaxN(0) | |
992b14a7 | 74 | { |
75 | //default ctor | |
76 | ||
77 | // Init array of histograms | |
5c46c992 | 78 | for(Int_t i = 0; i < 7; i++) |
79 | { | |
667432ef | 80 | fhMassAfterCutsNLocMax1[i] = 0; |
81 | fhMassAfterCutsNLocMax2[i] = 0; | |
82 | fhMassAfterCutsNLocMaxN[i] = 0; | |
83 | ||
5c46c992 | 84 | for(Int_t j = 0; j < 2; j++) |
85 | { | |
5c46c992 | 86 | fhMassNLocMax1[i][j] = 0; |
87 | fhMassNLocMax2[i][j] = 0; | |
88 | fhMassNLocMaxN[i][j] = 0; | |
89 | fhNLocMax[i][j] = 0; | |
5c46c992 | 90 | fhNLocMaxM02Cut[i][j] = 0; |
91 | fhM02NLocMax1[i][j] = 0; | |
92 | fhM02NLocMax2[i][j] = 0; | |
93 | fhM02NLocMaxN[i][j] = 0; | |
94 | fhNCellNLocMax1[i][j] = 0; | |
95 | fhNCellNLocMax2[i][j] = 0; | |
96 | fhNCellNLocMaxN[i][j] = 0; | |
97 | fhM02Pi0LocMax1[i][j] = 0; | |
98 | fhM02EtaLocMax1[i][j] = 0; | |
99 | fhM02ConLocMax1[i][j] = 0; | |
100 | fhM02Pi0LocMax2[i][j] = 0; | |
101 | fhM02EtaLocMax2[i][j] = 0; | |
102 | fhM02ConLocMax2[i][j] = 0; | |
103 | fhM02Pi0LocMaxN[i][j] = 0; | |
104 | fhM02EtaLocMaxN[i][j] = 0; | |
105 | fhM02ConLocMaxN[i][j] = 0; | |
667432ef | 106 | |
bb2d339b | 107 | fhMassPi0LocMax1[i][j] = 0; |
108 | fhMassEtaLocMax1[i][j] = 0; | |
109 | fhMassConLocMax1[i][j] = 0; | |
110 | fhMassPi0LocMax2[i][j] = 0; | |
111 | fhMassEtaLocMax2[i][j] = 0; | |
112 | fhMassConLocMax2[i][j] = 0; | |
113 | fhMassPi0LocMaxN[i][j] = 0; | |
114 | fhMassEtaLocMaxN[i][j] = 0; | |
115 | fhMassConLocMaxN[i][j] = 0; | |
5c46c992 | 116 | |
667432ef | 117 | |
e671adc2 | 118 | fhAsyPi0LocMax1[i][j] = 0; |
119 | fhAsyEtaLocMax1[i][j] = 0; | |
120 | fhAsyConLocMax1[i][j] = 0; | |
121 | fhAsyPi0LocMax2[i][j] = 0; | |
122 | fhAsyEtaLocMax2[i][j] = 0; | |
123 | fhAsyConLocMax2[i][j] = 0; | |
124 | fhAsyPi0LocMaxN[i][j] = 0; | |
125 | fhAsyEtaLocMaxN[i][j] = 0; | |
126 | fhAsyConLocMaxN[i][j] = 0; | |
127 | ||
0137016b | 128 | fhMassM02NLocMax1[i][j]= 0; |
129 | fhMassM02NLocMax2[i][j]= 0; | |
d2655d46 | 130 | fhMassM02NLocMaxN[i][j]= 0; |
131 | fhMassDispEtaNLocMax1[i][j]= 0; | |
132 | fhMassDispEtaNLocMax2[i][j]= 0; | |
133 | fhMassDispEtaNLocMaxN[i][j]= 0; | |
134 | fhMassDispPhiNLocMax1[i][j]= 0; | |
135 | fhMassDispPhiNLocMax2[i][j]= 0; | |
136 | fhMassDispPhiNLocMaxN[i][j]= 0; | |
137 | fhMassDispAsyNLocMax1[i][j]= 0; | |
138 | fhMassDispAsyNLocMax2[i][j]= 0; | |
139 | fhMassDispAsyNLocMaxN[i][j]= 0; | |
8e81c2cf | 140 | |
fc01318e | 141 | fhSplitEFractionNLocMax1[i][j]=0; |
142 | fhSplitEFractionNLocMax2[i][j]=0; | |
143 | fhSplitEFractionNLocMaxN[i][j]=0; | |
144 | ||
8e81c2cf | 145 | fhMCGenFracNLocMax1[i][j]= 0; |
146 | fhMCGenFracNLocMax2[i][j]= 0; | |
147 | fhMCGenFracNLocMaxN[i][j]= 0; | |
5094c724 | 148 | |
149 | fhMCGenSplitEFracNLocMax1[i][j]= 0; | |
150 | fhMCGenSplitEFracNLocMax2[i][j]= 0; | |
bb2d339b | 151 | fhMCGenSplitEFracNLocMaxN[i][j]= 0; |
152 | ||
153 | fhMCGenEFracvsSplitEFracNLocMax1[i][j]= 0; | |
154 | fhMCGenEFracvsSplitEFracNLocMax2[i][j]= 0; | |
155 | fhMCGenEFracvsSplitEFracNLocMaxN[i][j]= 0; | |
156 | ||
157 | fhMCGenEvsSplitENLocMax1[i][j]= 0; | |
158 | fhMCGenEvsSplitENLocMax2[i][j]= 0; | |
e671adc2 | 159 | fhMCGenEvsSplitENLocMaxN[i][j]= 0; |
160 | ||
161 | fhAsymNLocMax1 [i][j] = 0; | |
162 | fhAsymNLocMax2 [i][j] = 0; | |
163 | fhAsymNLocMaxN [i][j] = 0; | |
8e81c2cf | 164 | } |
165 | ||
166 | for(Int_t jj = 0; jj < 4; jj++) | |
167 | { | |
53f2c382 | 168 | fhM02MCGenFracNLocMax1Ebin[i][jj] = 0; |
169 | fhM02MCGenFracNLocMax2Ebin[i][jj] = 0; | |
170 | fhM02MCGenFracNLocMaxNEbin[i][jj] = 0; | |
8e81c2cf | 171 | |
172 | fhMassMCGenFracNLocMax1Ebin[i][jj]= 0; | |
173 | fhMassMCGenFracNLocMax2Ebin[i][jj]= 0; | |
174 | fhMassMCGenFracNLocMaxNEbin[i][jj]= 0; | |
53f2c382 | 175 | |
fc01318e | 176 | fhMCGenFracNLocMaxEbin[i][jj] = 0; |
53f2c382 | 177 | fhMCGenFracNLocMaxEbinMatched[i][jj]= 0; |
fc01318e | 178 | |
179 | fhMassSplitEFractionNLocMax1Ebin[i][jj] = 0; | |
180 | fhMassSplitEFractionNLocMax2Ebin[i][jj] = 0; | |
181 | fhMassSplitEFractionNLocMaxNEbin[i][jj] = 0; | |
5c46c992 | 182 | } |
183 | ||
184 | fhTrackMatchedDEtaLocMax1[i] = 0; | |
185 | fhTrackMatchedDPhiLocMax1[i] = 0; | |
186 | fhTrackMatchedDEtaLocMax2[i] = 0; | |
187 | fhTrackMatchedDPhiLocMax2[i] = 0; | |
188 | fhTrackMatchedDEtaLocMaxN[i] = 0; | |
189 | fhTrackMatchedDPhiLocMaxN[i] = 0; | |
243c2909 | 190 | |
992b14a7 | 191 | } |
192 | ||
5c46c992 | 193 | for(Int_t i = 0; i < 2; i++) |
194 | { | |
195 | fhAnglePairLocMax1 [i] = 0; | |
196 | fhAnglePairLocMax2 [i] = 0; | |
197 | fhAnglePairLocMaxN [i] = 0; | |
198 | fhAnglePairMassLocMax1[i] = 0; | |
199 | fhAnglePairMassLocMax2[i] = 0; | |
200 | fhAnglePairMassLocMaxN[i] = 0; | |
e671adc2 | 201 | fhSplitEFractionvsAsyNLocMax1[i] = 0; |
202 | fhSplitEFractionvsAsyNLocMax2[i] = 0; | |
203 | fhSplitEFractionvsAsyNLocMaxN[i] = 0; | |
5c46c992 | 204 | } |
205 | ||
7b686344 | 206 | for(Int_t i = 0; i < 4; i++) |
207 | { | |
208 | fhMassM02NLocMax1Ebin[i] = 0 ; | |
209 | fhMassM02NLocMax2Ebin[i] = 0 ; | |
210 | fhMassM02NLocMaxNEbin[i] = 0 ; | |
b8eb40fc | 211 | |
212 | fhMassAsyNLocMax1Ebin[i] = 0 ; | |
213 | fhMassAsyNLocMax2Ebin[i] = 0 ; | |
214 | fhMassAsyNLocMaxNEbin[i] = 0 ; | |
215 | ||
216 | fhAsyMCGenRecoNLocMax1EbinPi0[i] = 0 ; | |
217 | fhAsyMCGenRecoNLocMax2EbinPi0[i] = 0 ; | |
218 | fhAsyMCGenRecoNLocMaxNEbinPi0[i] = 0 ; | |
d2655d46 | 219 | |
220 | fhMassDispEtaNLocMax1Ebin[i] = 0 ; | |
221 | fhMassDispEtaNLocMax2Ebin[i] = 0 ; | |
222 | fhMassDispEtaNLocMaxNEbin[i] = 0 ; | |
223 | ||
224 | fhMassDispPhiNLocMax1Ebin[i] = 0 ; | |
225 | fhMassDispPhiNLocMax2Ebin[i] = 0 ; | |
226 | fhMassDispPhiNLocMaxNEbin[i] = 0 ; | |
227 | ||
228 | fhMassDispAsyNLocMax1Ebin[i] = 0 ; | |
229 | fhMassDispAsyNLocMax2Ebin[i] = 0 ; | |
230 | fhMassDispAsyNLocMaxNEbin[i] = 0 ; | |
8e81c2cf | 231 | |
232 | fhMCAsymM02NLocMax1MCPi0Ebin[i] = 0 ; | |
233 | fhMCAsymM02NLocMax2MCPi0Ebin[i] = 0 ; | |
234 | fhMCAsymM02NLocMaxNMCPi0Ebin[i] = 0 ; | |
7b686344 | 235 | } |
236 | ||
992b14a7 | 237 | InitParameters(); |
238 | ||
239 | } | |
240 | ||
241 | //_______________________________________________________________ | |
242 | TObjString * AliAnaInsideClusterInvariantMass::GetAnalysisCuts() | |
243 | { | |
244 | //Save parameters used for analysis | |
245 | TString parList ; //this will be list of parameters used for this analysis. | |
246 | const Int_t buffersize = 255; | |
247 | char onePar[buffersize] ; | |
248 | ||
249 | snprintf(onePar,buffersize,"--- AliAnaInsideClusterInvariantMass ---\n") ; | |
250 | parList+=onePar ; | |
251 | ||
243c2909 | 252 | snprintf(onePar,buffersize,"Calorimeter: %s\n", fCalorimeter.Data()) ; |
992b14a7 | 253 | parList+=onePar ; |
dbba06ca | 254 | snprintf(onePar,buffersize,"fLocMaxCutE =%2.2f \n", GetCaloUtils()->GetLocalMaximaCutE()) ; |
29ca9cad | 255 | parList+=onePar ; |
dbba06ca | 256 | snprintf(onePar,buffersize,"fLocMaxCutEDiff =%2.2f \n",GetCaloUtils()->GetLocalMaximaCutEDiff()) ; |
29ca9cad | 257 | parList+=onePar ; |
71e3889f | 258 | snprintf(onePar,buffersize,"%2.2f< M02 < %2.2f \n", fM02MinCut, fM02MaxCut) ; |
992b14a7 | 259 | parList+=onePar ; |
e23a0471 | 260 | snprintf(onePar,buffersize,"fMinNCells =%d \n", fMinNCells) ; |
2cb134fb | 261 | parList+=onePar ; |
3c1d9afb | 262 | snprintf(onePar,buffersize,"fMinBadDist =%1.1f \n", fMinBadDist) ; |
992b14a7 | 263 | parList+=onePar ; |
243c2909 | 264 | |
992b14a7 | 265 | return new TObjString(parList) ; |
266 | ||
267 | } | |
268 | ||
992b14a7 | 269 | //________________________________________________________________ |
270 | TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects() | |
271 | { | |
272 | // Create histograms to be saved in output file and | |
273 | // store them in outputContainer | |
274 | TList * outputContainer = new TList() ; | |
667432ef | 275 | outputContainer->SetName("InsideClusterHistos") ; |
992b14a7 | 276 | |
745913ae | 277 | Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); |
278 | Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins(); Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax(); Float_t ssmin = GetHistogramRanges()->GetHistoShowerShapeMin(); | |
279 | Int_t mbins = GetHistogramRanges()->GetHistoMassBins(); Float_t mmax = GetHistogramRanges()->GetHistoMassMax(); Float_t mmin = GetHistogramRanges()->GetHistoMassMin(); | |
280 | Int_t ncbins = GetHistogramRanges()->GetHistoNClusterCellBins(); Int_t ncmax = GetHistogramRanges()->GetHistoNClusterCellMax(); Int_t ncmin = GetHistogramRanges()->GetHistoNClusterCellMin(); | |
992b14a7 | 281 | |
5c46c992 | 282 | Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins(); |
283 | Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax(); | |
284 | Float_t resetamin = GetHistogramRanges()->GetHistoTrackResidualEtaMin(); | |
285 | Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins(); | |
286 | Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax(); | |
287 | Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin(); | |
288 | ||
992b14a7 | 289 | TString ptype[] ={"","#gamma","#gamma->e^{#pm}","#pi^{0}","#eta","e^{#pm}", "hadron"}; |
290 | TString pname[] ={"","Photon","Conversion", "Pi0", "Eta", "Electron","Hadron"}; | |
291 | ||
292 | Int_t n = 1; | |
293 | ||
294 | if(IsDataMC()) n = 7; | |
295 | ||
243c2909 | 296 | Int_t nMaxBins = 10; |
297 | ||
5c46c992 | 298 | TString sMatched[] = {"","Matched"}; |
299 | ||
2a77f6f4 | 300 | |
e671adc2 | 301 | fhMassSplitECutNLocMax1 = new TH2F("hMassSplitECutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, (E1+E2)/E cut", |
2a77f6f4 | 302 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
303 | fhMassSplitECutNLocMax1->SetYTitle("M (GeV/c^{2})"); | |
304 | fhMassSplitECutNLocMax1->SetXTitle("E (GeV)"); | |
305 | outputContainer->Add(fhMassSplitECutNLocMax1) ; | |
306 | ||
e671adc2 | 307 | fhMassSplitECutNLocMax2 = new TH2F("hMassSplitECutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, (E1+E2)/E cut", |
2a77f6f4 | 308 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
309 | fhMassSplitECutNLocMax2->SetYTitle("M (GeV/c^{2})"); | |
310 | fhMassSplitECutNLocMax2->SetXTitle("E (GeV)"); | |
311 | outputContainer->Add(fhMassSplitECutNLocMax2) ; | |
312 | ||
e671adc2 | 313 | fhMassSplitECutNLocMaxN = new TH2F("hMassSplitECutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, (E1+E2)/E cut", |
2a77f6f4 | 314 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
315 | fhMassSplitECutNLocMaxN->SetYTitle("M (GeV/c^{2})"); | |
316 | fhMassSplitECutNLocMaxN->SetXTitle("E (GeV)"); | |
317 | outputContainer->Add(fhMassSplitECutNLocMaxN) ; | |
318 | ||
e671adc2 | 319 | fhMassM02CutNLocMax1 = new TH2F("hMassM02CutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, M02 cut", |
2a77f6f4 | 320 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
321 | fhMassM02CutNLocMax1->SetYTitle("M (GeV/c^{2})"); | |
322 | fhMassM02CutNLocMax1->SetXTitle("E (GeV)"); | |
323 | outputContainer->Add(fhMassM02CutNLocMax1) ; | |
324 | ||
e671adc2 | 325 | fhMassM02CutNLocMax2 = new TH2F("hMassM02CutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, M02 cut", |
2a77f6f4 | 326 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
327 | fhMassM02CutNLocMax2->SetYTitle("M (GeV/c^{2})"); | |
328 | fhMassM02CutNLocMax2->SetXTitle("E (GeV)"); | |
329 | outputContainer->Add(fhMassM02CutNLocMax2) ; | |
330 | ||
e671adc2 | 331 | fhMassM02CutNLocMaxN = new TH2F("hMassM02CutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, M02 cut", |
2a77f6f4 | 332 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
333 | fhMassM02CutNLocMaxN->SetYTitle("M (GeV/c^{2})"); | |
334 | fhMassM02CutNLocMaxN->SetXTitle("E (GeV)"); | |
667432ef | 335 | outputContainer->Add(fhMassM02CutNLocMaxN) ; |
2a77f6f4 | 336 | |
77cadd95 | 337 | fhAsymM02CutNLocMax1 = new TH2F("hAsymM02CutNLocMax1","Asymmetry of NLM=1 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1); |
338 | fhAsymM02CutNLocMax1->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})"); | |
339 | fhAsymM02CutNLocMax1->SetXTitle("E (GeV)"); | |
340 | outputContainer->Add(fhAsymM02CutNLocMax1) ; | |
341 | ||
342 | fhAsymM02CutNLocMax2 = new TH2F("hAsymM02CutNLocMax2","Asymmetry of NLM=2 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1); | |
343 | fhAsymM02CutNLocMax2->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})"); | |
344 | fhAsymM02CutNLocMax2->SetXTitle("E (GeV)"); | |
345 | outputContainer->Add(fhAsymM02CutNLocMax2) ; | |
346 | ||
347 | fhAsymM02CutNLocMaxN = new TH2F("hAsymM02CutNLocMaxN","Asymmetry of NLM>2 vs cluster Energy, M02Cut", nptbins,ptmin,ptmax,200,-1,1); | |
348 | fhAsymM02CutNLocMaxN->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})"); | |
349 | fhAsymM02CutNLocMaxN->SetXTitle("E (GeV)"); | |
350 | outputContainer->Add(fhAsymM02CutNLocMaxN) ; | |
351 | ||
667432ef | 352 | fhSplitEFractionAfterCutsNLocMax1 = new TH2F("hSplitEFractionAfterCutsNLocMax1", |
353 | "(E1+E2)/E_{cluster} vs E_{cluster} for N max = 1, M02 and Asy cut on", | |
354 | nptbins,ptmin,ptmax,120,0,1.2); | |
355 | fhSplitEFractionAfterCutsNLocMax1 ->SetXTitle("E_{cluster} (GeV)"); | |
356 | fhSplitEFractionAfterCutsNLocMax1 ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
357 | outputContainer->Add(fhSplitEFractionAfterCutsNLocMax1) ; | |
358 | ||
359 | fhSplitEFractionAfterCutsNLocMax2 = new TH2F("hSplitEFractionAfterCutsNLocMax2", | |
360 | "(E1+E2)/E_{cluster} vs E_{cluster} for N max = 2, M02 and Asy cut on", | |
361 | nptbins,ptmin,ptmax,120,0,1.2); | |
362 | fhSplitEFractionAfterCutsNLocMax2 ->SetXTitle("E_{cluster} (GeV)"); | |
363 | fhSplitEFractionAfterCutsNLocMax2 ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
364 | outputContainer->Add(fhSplitEFractionAfterCutsNLocMax2) ; | |
e671adc2 | 365 | |
667432ef | 366 | fhSplitEFractionAfterCutsNLocMaxN = new TH2F("hSplitEFractionAfterCutsNLocMaxN", |
367 | "(E1+E2)/E_{cluster} vs E_{cluster} for N max > 2, M02 and Asy cut on", | |
368 | nptbins,ptmin,ptmax,120,0,1.2); | |
369 | fhSplitEFractionAfterCutsNLocMaxN ->SetXTitle("E_{cluster} (GeV)"); | |
370 | fhSplitEFractionAfterCutsNLocMaxN ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
371 | outputContainer->Add(fhSplitEFractionAfterCutsNLocMaxN) ; | |
e671adc2 | 372 | |
667432ef | 373 | if(IsDataMC() && fFillMCFractionHisto) |
374 | { | |
375 | ||
376 | fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMax1MCPi0", | |
377 | "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 1 MC Pi0, after M02 and Asym cut", | |
378 | nptbins,ptmin,ptmax,200,0,2); | |
379 | fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})"); | |
380 | fhMCGenSplitEFracAfterCutsNLocMax1MCPi0 ->SetXTitle("E (GeV)"); | |
381 | outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMax1MCPi0) ; | |
382 | ||
383 | fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMax2MCPi0", | |
384 | "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 2 MC Pi0, after M02 and Asym cut", | |
385 | nptbins,ptmin,ptmax,200,0,2); | |
386 | fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})"); | |
387 | fhMCGenSplitEFracAfterCutsNLocMax2MCPi0 ->SetXTitle("E (GeV)"); | |
388 | outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMax2MCPi0) ; | |
389 | ||
390 | ||
391 | fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 = new TH2F("hMCGenSplitEFracAfterCutsNLocMaxNMCPi0", | |
392 | "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max > 2 MC Pi0, after M02 and Asym cut", | |
393 | nptbins,ptmin,ptmax,200,0,2); | |
394 | fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})"); | |
395 | fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0 ->SetXTitle("E (GeV)"); | |
396 | outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0) ; | |
397 | ||
398 | fhMCGenFracAfterCutsNLocMax1MCPi0 = new TH2F("hMCGenFracAfterCutsNLocMax1MCPi0", | |
399 | "E_{gen} / E_{reco} vs E_{reco} for N max = 1 MC Pi0, after M02 and Asym cut", | |
400 | nptbins,ptmin,ptmax,200,0,2); | |
401 | fhMCGenFracAfterCutsNLocMax1MCPi0 ->SetYTitle("E_{gen} / E_{reco}"); | |
402 | fhMCGenFracAfterCutsNLocMax1MCPi0 ->SetXTitle("E (GeV)"); | |
403 | outputContainer->Add(fhMCGenFracAfterCutsNLocMax1MCPi0) ; | |
404 | ||
405 | fhMCGenFracAfterCutsNLocMax2MCPi0 = new TH2F("hMCGenFracAfterCutsNLocMax2MCPi0", | |
406 | " E_{gen} / E_{reco} vs E_{reco} for N max = 2 MC Pi0, after M02 and Asym cut", | |
407 | nptbins,ptmin,ptmax,200,0,2); | |
408 | fhMCGenFracAfterCutsNLocMax2MCPi0 ->SetYTitle("E_{gen} / E_{reco}"); | |
409 | fhMCGenFracAfterCutsNLocMax2MCPi0 ->SetXTitle("E (GeV)"); | |
410 | outputContainer->Add(fhMCGenFracAfterCutsNLocMax2MCPi0) ; | |
411 | ||
412 | ||
413 | fhMCGenFracAfterCutsNLocMaxNMCPi0 = new TH2F("hMCGenFracAfterCutsNLocMaxNMCPi0", | |
414 | " E_{gen} / E_{reco} vs E_{reco} for N max > 2 MC Pi0, after M02 and Asym cut", | |
415 | nptbins,ptmin,ptmax,200,0,2); | |
416 | fhMCGenFracAfterCutsNLocMaxNMCPi0 ->SetYTitle("E_{gen} / E_{reco}"); | |
417 | fhMCGenFracAfterCutsNLocMaxNMCPi0 ->SetXTitle("E (GeV)"); | |
418 | outputContainer->Add(fhMCGenFracAfterCutsNLocMaxNMCPi0) ; | |
419 | ||
420 | } | |
e671adc2 | 421 | |
5c46c992 | 422 | for(Int_t i = 0; i < n; i++) |
667432ef | 423 | { |
5c46c992 | 424 | for(Int_t j = 0; j < 2; j++) |
667432ef | 425 | { |
5c46c992 | 426 | |
427 | fhMassNLocMax1[i][j] = new TH2F(Form("hMassNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
2a77f6f4 | 428 | Form("Invariant mass of splitted cluster with NLM=1 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()), |
5c46c992 | 429 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
430 | fhMassNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})"); | |
431 | fhMassNLocMax1[i][j]->SetXTitle("E (GeV)"); | |
432 | outputContainer->Add(fhMassNLocMax1[i][j]) ; | |
433 | ||
434 | fhMassNLocMax2[i][j] = new TH2F(Form("hMassNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
2a77f6f4 | 435 | Form("Invariant mass of splitted cluster with NLM=2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()), |
5c46c992 | 436 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
437 | fhMassNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})"); | |
438 | fhMassNLocMax2[i][j]->SetXTitle("E (GeV)"); | |
439 | outputContainer->Add(fhMassNLocMax2[i][j]) ; | |
440 | ||
441 | fhMassNLocMaxN[i][j] = new TH2F(Form("hMassNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
2a77f6f4 | 442 | Form("Invariant mass of splitted cluster with NLM>2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()), |
5c46c992 | 443 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
444 | fhMassNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})"); | |
445 | fhMassNLocMaxN[i][j]->SetXTitle("E (GeV)"); | |
667432ef | 446 | outputContainer->Add(fhMassNLocMaxN[i][j]) ; |
447 | ||
448 | if(j==0) | |
449 | { | |
450 | fhMassAfterCutsNLocMax1[i] = new TH2F(Form("hMassAfterCutsNLocMax1%s",pname[i].Data()), | |
451 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1, m02 and asy cut", | |
452 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
453 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
454 | fhMassAfterCutsNLocMax1[i] ->SetYTitle("Mass (MeV/c^{2})"); | |
455 | fhMassAfterCutsNLocMax1[i] ->SetXTitle("E (GeV)"); | |
456 | outputContainer->Add(fhMassAfterCutsNLocMax1[i]) ; | |
457 | ||
458 | fhMassAfterCutsNLocMax2[i] = new TH2F(Form("hMassAfterCutsNLocMax2%s",pname[i].Data()), | |
459 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2, asy cut", | |
460 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
461 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
462 | fhMassAfterCutsNLocMax2[i] ->SetYTitle("Mass (MeV/c^{2})"); | |
463 | fhMassAfterCutsNLocMax2[i] ->SetXTitle("E (GeV)"); | |
464 | outputContainer->Add(fhMassAfterCutsNLocMax2[i]) ; | |
465 | ||
466 | ||
467 | fhMassAfterCutsNLocMaxN[i] = new TH2F(Form("hMassAfterCutsNLocMaxN%s",pname[i].Data()), | |
468 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2, asy cut", | |
469 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
470 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
471 | fhMassAfterCutsNLocMaxN[i] ->SetYTitle("Mass (MeV/c^{2})"); | |
472 | fhMassAfterCutsNLocMaxN[i] ->SetXTitle("E (GeV)"); | |
473 | outputContainer->Add(fhMassAfterCutsNLocMaxN[i]) ; | |
474 | } | |
5c46c992 | 475 | |
0137016b | 476 | fhMassM02NLocMax1[i][j] = new TH2F(Form("hMassM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), |
e671adc2 | 477 | Form("Invariant mass of splitted cluster with NLM=1, #lambda_{0}^{2}, E > 8 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()), |
0137016b | 478 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
479 | fhMassM02NLocMax1[i][j]->SetYTitle("M (GeV/c^{2})"); | |
480 | fhMassM02NLocMax1[i][j]->SetXTitle("#lambda_{0}^{2}"); | |
481 | outputContainer->Add(fhMassM02NLocMax1[i][j]) ; | |
482 | ||
483 | fhMassM02NLocMax2[i][j] = new TH2F(Form("hMassM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
e671adc2 | 484 | Form("Invariant mass of splitted cluster with NLM=2, #lambda_{0}^{2}, E > 8 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()), |
0137016b | 485 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
486 | fhMassM02NLocMax2[i][j]->SetYTitle("M (GeV/c^{2})"); | |
487 | fhMassM02NLocMax2[i][j]->SetXTitle("#lambda_{0}^{2}"); | |
488 | outputContainer->Add(fhMassM02NLocMax2[i][j]) ; | |
489 | ||
490 | fhMassM02NLocMaxN[i][j] = new TH2F(Form("hMassM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
2a77f6f4 | 491 | Form("Invariant mass of splitted cluster with NLM>2, vs #lambda_{0}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()), |
0137016b | 492 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
493 | fhMassM02NLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})"); | |
494 | fhMassM02NLocMaxN[i][j]->SetXTitle("#lambda_{0}^{2}"); | |
495 | outputContainer->Add(fhMassM02NLocMaxN[i][j]) ; | |
496 | ||
e671adc2 | 497 | |
498 | fhAsymNLocMax1[i][j] = new TH2F(Form("hAsymNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
499 | Form("Asymmetry of NLM=1 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()), | |
500 | nptbins,ptmin,ptmax,200,-1,1); | |
acd56ca4 | 501 | fhAsymNLocMax1[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})"); |
e671adc2 | 502 | fhAsymNLocMax1[i][j]->SetXTitle("E (GeV)"); |
503 | outputContainer->Add(fhAsymNLocMax1[i][j]) ; | |
504 | ||
505 | fhAsymNLocMax2[i][j] = new TH2F(Form("hAsymNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
506 | Form("Asymmetry of NLM=2 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()), | |
507 | nptbins,ptmin,ptmax,200,-1,1); | |
acd56ca4 | 508 | fhAsymNLocMax2[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})"); |
e671adc2 | 509 | fhAsymNLocMax2[i][j]->SetXTitle("E (GeV)"); |
510 | outputContainer->Add(fhAsymNLocMax2[i][j]) ; | |
511 | ||
512 | fhAsymNLocMaxN[i][j] = new TH2F(Form("hAsymNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
513 | Form("Asymmetry of NLM>2 vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()), | |
514 | nptbins,ptmin,ptmax,200,-1,1); | |
515 | fhAsymNLocMaxN[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})"); | |
516 | fhAsymNLocMaxN[i][j]->SetXTitle("E (GeV)"); | |
517 | outputContainer->Add(fhAsymNLocMaxN[i][j]) ; | |
518 | ||
519 | ||
8e81c2cf | 520 | if(fFillSSExtraHisto) |
521 | { | |
522 | fhMassDispEtaNLocMax1[i][j] = new TH2F(Form("hMassDispEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
e671adc2 | 523 | Form("Invariant mass of splitted cluster with NLM=1, #sigma_{#eta #eta}^{2}, E > 8 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()), |
8e81c2cf | 524 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
525 | fhMassDispEtaNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})"); | |
526 | fhMassDispEtaNLocMax1[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}"); | |
527 | outputContainer->Add(fhMassDispEtaNLocMax1[i][j]) ; | |
528 | ||
529 | fhMassDispEtaNLocMax2[i][j] = new TH2F(Form("hMassDispEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
e671adc2 | 530 | Form("Invariant mass of splitted cluster with NLM=2 #sigma_{#eta #eta}^{2}, E > 8 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()), |
8e81c2cf | 531 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
532 | fhMassDispEtaNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})"); | |
533 | fhMassDispEtaNLocMax2[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}"); | |
534 | outputContainer->Add(fhMassDispEtaNLocMax2[i][j]) ; | |
535 | ||
536 | fhMassDispEtaNLocMaxN[i][j] = new TH2F(Form("hMassDispEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
2a77f6f4 | 537 | Form("Invariant mass of splitted cluster with NLM>2, #sigma_{#eta #eta}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()), |
8e81c2cf | 538 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
539 | fhMassDispEtaNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})"); | |
540 | fhMassDispEtaNLocMaxN[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}"); | |
541 | outputContainer->Add(fhMassDispEtaNLocMaxN[i][j]) ; | |
542 | ||
543 | fhMassDispPhiNLocMax1[i][j] = new TH2F(Form("hMassDispPhiNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
e671adc2 | 544 | Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E > 8 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()), |
8e81c2cf | 545 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
546 | fhMassDispPhiNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})"); | |
547 | fhMassDispPhiNLocMax1[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}"); | |
548 | outputContainer->Add(fhMassDispPhiNLocMax1[i][j]) ; | |
549 | ||
550 | fhMassDispPhiNLocMax2[i][j] = new TH2F(Form("hMassDispPhiNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
e671adc2 | 551 | Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E > 8 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()), |
8e81c2cf | 552 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
553 | fhMassDispPhiNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})"); | |
554 | fhMassDispPhiNLocMax2[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}"); | |
555 | outputContainer->Add(fhMassDispPhiNLocMax2[i][j]) ; | |
556 | ||
557 | fhMassDispPhiNLocMaxN[i][j] = new TH2F(Form("hMassDispPhiNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
558 | Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()), | |
559 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
560 | fhMassDispPhiNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})"); | |
561 | fhMassDispPhiNLocMaxN[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}"); | |
562 | outputContainer->Add(fhMassDispPhiNLocMaxN[i][j]) ; | |
563 | ||
564 | fhMassDispAsyNLocMax1[i][j] = new TH2F(Form("hMassDispAsyNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
e671adc2 | 565 | 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 > 8 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()), |
8e81c2cf | 566 | 200,-1,1,mbins,mmin,mmax); |
567 | fhMassDispAsyNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})"); | |
568 | fhMassDispAsyNLocMax1[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})"); | |
569 | outputContainer->Add(fhMassDispAsyNLocMax1[i][j]) ; | |
570 | ||
571 | fhMassDispAsyNLocMax2[i][j] = new TH2F(Form("hMassDispAsyNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
e671adc2 | 572 | 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 > 8 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()), |
8e81c2cf | 573 | 200,-1,1,mbins,mmin,mmax); |
574 | fhMassDispAsyNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})"); | |
575 | fhMassDispAsyNLocMax2[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})"); | |
576 | outputContainer->Add(fhMassDispAsyNLocMax2[i][j]) ; | |
577 | ||
578 | fhMassDispAsyNLocMaxN[i][j] = new TH2F(Form("hMassDispAsyNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
579 | 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()), | |
580 | 200,-1,1,mbins,mmin,mmax); | |
581 | fhMassDispAsyNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})"); | |
582 | fhMassDispAsyNLocMaxN[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})"); | |
583 | outputContainer->Add(fhMassDispAsyNLocMaxN[i][j]) ; | |
584 | } | |
d2655d46 | 585 | |
5c46c992 | 586 | fhNLocMax[i][j] = new TH2F(Form("hNLocMax%s%s",pname[i].Data(),sMatched[j].Data()), |
587 | Form("Number of local maxima in cluster %s %s",ptype[i].Data(),sMatched[j].Data()), | |
588 | nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins); | |
589 | fhNLocMax[i][j] ->SetYTitle("N maxima"); | |
590 | fhNLocMax[i][j] ->SetXTitle("E (GeV)"); | |
591 | outputContainer->Add(fhNLocMax[i][j]) ; | |
3c1d9afb | 592 | |
5c46c992 | 593 | fhNLocMaxM02Cut[i][j] = new TH2F(Form("hNLocMaxM02Cut%s%s",pname[i].Data(),sMatched[j].Data()), |
71e3889f | 594 | Form("Number of local maxima in cluster %s for %2.2f < M02 < %2.2f",ptype[i].Data(),fM02MinCut,fM02MaxCut), |
5c46c992 | 595 | nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins); |
596 | fhNLocMaxM02Cut[i][j]->SetYTitle("N maxima"); | |
597 | fhNLocMaxM02Cut[i][j]->SetXTitle("E (GeV)"); | |
598 | outputContainer->Add(fhNLocMaxM02Cut[i][j]) ; | |
599 | ||
600 | ||
601 | fhM02NLocMax1[i][j] = new TH2F(Form("hM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
602 | Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
603 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); | |
604 | fhM02NLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
605 | fhM02NLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
606 | outputContainer->Add(fhM02NLocMax1[i][j]) ; | |
607 | ||
608 | fhM02NLocMax2[i][j] = new TH2F(Form("hM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
609 | Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
610 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); | |
611 | fhM02NLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
612 | fhM02NLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
613 | outputContainer->Add(fhM02NLocMax2[i][j]) ; | |
614 | ||
5c46c992 | 615 | fhM02NLocMaxN[i][j] = new TH2F(Form("hM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), |
616 | Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
617 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); | |
618 | fhM02NLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
619 | fhM02NLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
620 | outputContainer->Add(fhM02NLocMaxN[i][j]) ; | |
621 | ||
fc01318e | 622 | |
623 | fhSplitEFractionNLocMax1[i][j] = new TH2F(Form("hSplitEFractionNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
624 | Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
625 | nptbins,ptmin,ptmax,120,0,1.2); | |
626 | fhSplitEFractionNLocMax1[i][j] ->SetXTitle("E_{cluster} (GeV)"); | |
627 | fhSplitEFractionNLocMax1[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
628 | outputContainer->Add(fhSplitEFractionNLocMax1[i][j]) ; | |
629 | ||
630 | fhSplitEFractionNLocMax2[i][j] = new TH2F(Form("hSplitEFractionNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
631 | Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
632 | nptbins,ptmin,ptmax,120,0,1.2); | |
633 | fhSplitEFractionNLocMax2[i][j] ->SetXTitle("E_{cluster} (GeV)"); | |
634 | fhSplitEFractionNLocMax2[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
635 | outputContainer->Add(fhSplitEFractionNLocMax2[i][j]) ; | |
636 | ||
637 | fhSplitEFractionNLocMaxN[i][j] = new TH2F(Form("hSplitEFractionNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
638 | Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
639 | nptbins,ptmin,ptmax,120,0,1.2); | |
640 | fhSplitEFractionNLocMaxN[i][j] ->SetXTitle("E_{cluster} (GeV)"); | |
641 | fhSplitEFractionNLocMaxN[i][j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
642 | outputContainer->Add(fhSplitEFractionNLocMaxN[i][j]) ; | |
643 | ||
644 | ||
2a77f6f4 | 645 | if(i > 0 && fFillMCFractionHisto) // skip first entry in array, general case not filled |
883411b2 | 646 | { |
647 | fhMCGenFracNLocMax1[i][j] = new TH2F(Form("hMCGenFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
648 | Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
649 | nptbins,ptmin,ptmax,200,0,2); | |
fb51265c | 650 | fhMCGenFracNLocMax1[i][j] ->SetYTitle("E_{gen} / E_{reco}"); |
883411b2 | 651 | fhMCGenFracNLocMax1[i][j] ->SetXTitle("E (GeV)"); |
652 | outputContainer->Add(fhMCGenFracNLocMax1[i][j]) ; | |
653 | ||
654 | fhMCGenFracNLocMax2[i][j] = new TH2F(Form("hMCGenFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
655 | Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
656 | nptbins,ptmin,ptmax,200,0,2); | |
fb51265c | 657 | fhMCGenFracNLocMax2[i][j] ->SetYTitle("E_{gen} / E_{reco}"); |
883411b2 | 658 | fhMCGenFracNLocMax2[i][j] ->SetXTitle("E (GeV)"); |
659 | outputContainer->Add(fhMCGenFracNLocMax2[i][j]) ; | |
660 | ||
661 | ||
662 | fhMCGenFracNLocMaxN[i][j] = new TH2F(Form("hMCGenFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
663 | Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
664 | nptbins,ptmin,ptmax,200,0,2); | |
fb51265c | 665 | fhMCGenFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / E_{reco}"); |
883411b2 | 666 | fhMCGenFracNLocMaxN[i][j] ->SetXTitle("E (GeV)"); |
667 | outputContainer->Add(fhMCGenFracNLocMaxN[i][j]) ; | |
5094c724 | 668 | |
669 | fhMCGenSplitEFracNLocMax1[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
bb2d339b | 670 | Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()), |
5094c724 | 671 | nptbins,ptmin,ptmax,200,0,2); |
672 | fhMCGenSplitEFracNLocMax1[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})"); | |
673 | fhMCGenSplitEFracNLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
674 | outputContainer->Add(fhMCGenSplitEFracNLocMax1[i][j]) ; | |
675 | ||
676 | fhMCGenSplitEFracNLocMax2[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
bb2d339b | 677 | Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()), |
5094c724 | 678 | nptbins,ptmin,ptmax,200,0,2); |
679 | fhMCGenSplitEFracNLocMax2[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})"); | |
680 | fhMCGenSplitEFracNLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
681 | outputContainer->Add(fhMCGenSplitEFracNLocMax2[i][j]) ; | |
682 | ||
683 | ||
684 | fhMCGenSplitEFracNLocMaxN[i][j] = new TH2F(Form("hMCGenSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
bb2d339b | 685 | Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()), |
5094c724 | 686 | nptbins,ptmin,ptmax,200,0,2); |
687 | fhMCGenSplitEFracNLocMaxN[i][j] ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})"); | |
688 | fhMCGenSplitEFracNLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
689 | outputContainer->Add(fhMCGenSplitEFracNLocMaxN[i][j]) ; | |
bb2d339b | 690 | |
691 | fhMCGenEFracvsSplitEFracNLocMax1[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
692 | 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()), | |
693 | 200,0,2,200,0,2); | |
694 | fhMCGenEFracvsSplitEFracNLocMax1[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}"); | |
695 | fhMCGenEFracvsSplitEFracNLocMax1[i][j] ->SetXTitle("E_{gen} / E_{reco}"); | |
696 | outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMax1[i][j]) ; | |
697 | ||
698 | fhMCGenEFracvsSplitEFracNLocMax2[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
699 | 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()), | |
700 | 200,0,2,200,0,2); | |
701 | fhMCGenEFracvsSplitEFracNLocMax2[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}"); | |
702 | fhMCGenEFracvsSplitEFracNLocMax2[i][j] ->SetXTitle("E_{gen} / E_{reco}"); | |
703 | outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMax2[i][j]) ; | |
704 | ||
705 | ||
706 | fhMCGenEFracvsSplitEFracNLocMaxN[i][j] = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
707 | 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()), | |
708 | 200,0,2,200,0,2); | |
709 | fhMCGenEFracvsSplitEFracNLocMaxN[i][j] ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}"); | |
710 | fhMCGenEFracvsSplitEFracNLocMaxN[i][j] ->SetXTitle("E_{gen} / E_{reco}"); | |
711 | outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMaxN[i][j]) ; | |
712 | ||
713 | ||
714 | fhMCGenEvsSplitENLocMax1[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
715 | Form("E_{1 split}+E_{2 split} vs E_{gen} for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
716 | nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); | |
717 | fhMCGenEvsSplitENLocMax1[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)"); | |
718 | fhMCGenEvsSplitENLocMax1[i][j] ->SetXTitle("E_{gen} (GeV)"); | |
719 | outputContainer->Add(fhMCGenEvsSplitENLocMax1[i][j]) ; | |
720 | ||
721 | fhMCGenEvsSplitENLocMax2[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
722 | Form("E_{1 split}+E_{2 split} vs E_{gen} for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
723 | nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); | |
724 | fhMCGenEvsSplitENLocMax2[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)"); | |
725 | fhMCGenEvsSplitENLocMax2[i][j] ->SetXTitle("E_{gen} (GeV)"); | |
726 | outputContainer->Add(fhMCGenEvsSplitENLocMax2[i][j]) ; | |
727 | ||
728 | ||
729 | fhMCGenEvsSplitENLocMaxN[i][j] = new TH2F(Form("hMCGenEvsSplitENLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
730 | Form("E_{1 split}+E_{2 split} vs E_{gen} for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
731 | nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); | |
732 | fhMCGenEvsSplitENLocMaxN[i][j] ->SetYTitle("E_{1 split}+E_{2 split} (GeV)"); | |
733 | fhMCGenEvsSplitENLocMaxN[i][j] ->SetXTitle("E_{gen} (GeV)"); | |
734 | outputContainer->Add(fhMCGenEvsSplitENLocMaxN[i][j]) ; | |
735 | ||
883411b2 | 736 | } |
5c46c992 | 737 | |
8e81c2cf | 738 | if(fFillSSExtraHisto) |
739 | { | |
740 | fhNCellNLocMax1[i][j] = new TH2F(Form("hNCellNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
741 | Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
742 | nptbins,ptmin,ptmax,ncbins,ncmin,ncmax); | |
743 | fhNCellNLocMax1[i][j] ->SetYTitle("N cells"); | |
744 | fhNCellNLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
745 | outputContainer->Add(fhNCellNLocMax1[i][j]) ; | |
746 | ||
747 | fhNCellNLocMax2[i][j] = new TH2F(Form("hNCellNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
748 | Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
749 | nptbins,ptmin,ptmax,ncbins,ncmin,ncmax); | |
750 | fhNCellNLocMax2[i][j] ->SetYTitle("N cells"); | |
751 | fhNCellNLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
752 | outputContainer->Add(fhNCellNLocMax2[i][j]) ; | |
753 | ||
754 | ||
755 | fhNCellNLocMaxN[i][j] = new TH2F(Form("hNCellNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
756 | Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
757 | nptbins,ptmin,ptmax,ncbins,ncmin,ncmax); | |
758 | fhNCellNLocMaxN[i][j] ->SetYTitle("N cells"); | |
759 | fhNCellNLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
760 | outputContainer->Add(fhNCellNLocMaxN[i][j]) ; | |
761 | } | |
5c46c992 | 762 | |
763 | fhM02Pi0LocMax1[i][j] = new TH2F(Form("hM02Pi0LocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 764 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1", |
765 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
5c46c992 | 766 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
767 | fhM02Pi0LocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
768 | fhM02Pi0LocMax1[i][j] ->SetXTitle("E (GeV)"); | |
769 | outputContainer->Add(fhM02Pi0LocMax1[i][j]) ; | |
770 | ||
771 | fhM02EtaLocMax1[i][j] = new TH2F(Form("hM02EtaLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 772 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1", |
773 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
5c46c992 | 774 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
775 | fhM02EtaLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
776 | fhM02EtaLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
777 | outputContainer->Add(fhM02EtaLocMax1[i][j]) ; | |
778 | ||
779 | fhM02ConLocMax1[i][j] = new TH2F(Form("hM02ConLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 780 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1", |
781 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
5c46c992 | 782 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
783 | fhM02ConLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
784 | fhM02ConLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
785 | outputContainer->Add(fhM02ConLocMax1[i][j]) ; | |
786 | ||
787 | fhM02Pi0LocMax2[i][j] = new TH2F(Form("hM02Pi0LocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 788 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2", |
789 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
5c46c992 | 790 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
791 | fhM02Pi0LocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
792 | fhM02Pi0LocMax2[i][j] ->SetXTitle("E (GeV)"); | |
793 | outputContainer->Add(fhM02Pi0LocMax2[i][j]) ; | |
794 | ||
795 | fhM02EtaLocMax2[i][j] = new TH2F(Form("hM02EtaLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 796 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2", |
797 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
5c46c992 | 798 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
799 | fhM02EtaLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
800 | fhM02EtaLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
667432ef | 801 | outputContainer->Add(fhM02EtaLocMax2[i][j]) ; |
5c46c992 | 802 | |
803 | fhM02ConLocMax2[i][j] = new TH2F(Form("hM02ConLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 804 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2", |
805 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
5c46c992 | 806 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
807 | fhM02ConLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
808 | fhM02ConLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
809 | outputContainer->Add(fhM02ConLocMax2[i][j]) ; | |
810 | ||
811 | fhM02Pi0LocMaxN[i][j] = new TH2F(Form("hM02Pi0LocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 812 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2", |
813 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
5c46c992 | 814 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
815 | fhM02Pi0LocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
816 | fhM02Pi0LocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
817 | outputContainer->Add(fhM02Pi0LocMaxN[i][j]) ; | |
818 | ||
819 | fhM02EtaLocMaxN[i][j] = new TH2F(Form("hM02EtaLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 820 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max > 2", |
821 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
5c46c992 | 822 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
823 | fhM02EtaLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
824 | fhM02EtaLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
825 | outputContainer->Add(fhM02EtaLocMaxN[i][j]) ; | |
826 | ||
827 | fhM02ConLocMaxN[i][j] = new TH2F(Form("hM02ConLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 828 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2", |
829 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
5c46c992 | 830 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
831 | fhM02ConLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
832 | fhM02ConLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
667432ef | 833 | outputContainer->Add(fhM02ConLocMaxN[i][j]) ; |
bb2d339b | 834 | |
835 | ||
836 | fhMassPi0LocMax1[i][j] = new TH2F(Form("hMassPi0LocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
837 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1", | |
838 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
839 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
840 | fhMassPi0LocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
841 | fhMassPi0LocMax1[i][j] ->SetXTitle("E (GeV)"); | |
842 | outputContainer->Add(fhMassPi0LocMax1[i][j]) ; | |
167f2534 | 843 | |
844 | ||
bb2d339b | 845 | fhMassEtaLocMax1[i][j] = new TH2F(Form("hMassEtaLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), |
846 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1", | |
847 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
848 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
849 | fhMassEtaLocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
850 | fhMassEtaLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
851 | outputContainer->Add(fhMassEtaLocMax1[i][j]) ; | |
852 | ||
853 | fhMassConLocMax1[i][j] = new TH2F(Form("hMassConLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
854 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1", | |
855 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
856 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
857 | fhMassConLocMax1[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
858 | fhMassConLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
859 | outputContainer->Add(fhMassConLocMax1[i][j]) ; | |
860 | ||
861 | fhMassPi0LocMax2[i][j] = new TH2F(Form("hMassPi0LocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
862 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2", | |
863 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
864 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
865 | fhMassPi0LocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
866 | fhMassPi0LocMax2[i][j] ->SetXTitle("E (GeV)"); | |
867 | outputContainer->Add(fhMassPi0LocMax2[i][j]) ; | |
868 | ||
167f2534 | 869 | |
bb2d339b | 870 | fhMassEtaLocMax2[i][j] = new TH2F(Form("hMassEtaLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), |
871 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2", | |
872 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
873 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
874 | fhMassEtaLocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
875 | fhMassEtaLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
876 | outputContainer->Add(fhMassEtaLocMax2[i][j]) ; | |
877 | ||
878 | fhMassConLocMax2[i][j] = new TH2F(Form("hMassConLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
879 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2", | |
880 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
881 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
882 | fhMassConLocMax2[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
883 | fhMassConLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
884 | outputContainer->Add(fhMassConLocMax2[i][j]) ; | |
885 | ||
886 | fhMassPi0LocMaxN[i][j] = new TH2F(Form("hMassPi0LocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
887 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2", | |
888 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
889 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
890 | fhMassPi0LocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
891 | fhMassPi0LocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
892 | outputContainer->Add(fhMassPi0LocMaxN[i][j]) ; | |
893 | ||
894 | fhMassEtaLocMaxN[i][j] = new TH2F(Form("hMassEtaLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
895 | Form("Mass vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max > 2", | |
896 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
897 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
898 | fhMassEtaLocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
899 | fhMassEtaLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
900 | outputContainer->Add(fhMassEtaLocMaxN[i][j]) ; | |
901 | ||
902 | fhMassConLocMaxN[i][j] = new TH2F(Form("hMassConLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
903 | Form("Mass vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2", | |
904 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
905 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
906 | fhMassConLocMaxN[i][j] ->SetYTitle("Mass (MeV/c^{2})"); | |
907 | fhMassConLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
908 | outputContainer->Add(fhMassConLocMaxN[i][j]) ; | |
5c46c992 | 909 | |
e671adc2 | 910 | |
911 | fhAsyPi0LocMax1[i][j] = new TH2F(Form("hAsyPi0LocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
912 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1", | |
913 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
914 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
915 | fhAsyPi0LocMax1[i][j] ->SetYTitle("Asymmetry"); | |
916 | fhAsyPi0LocMax1[i][j] ->SetXTitle("E (GeV)"); | |
917 | outputContainer->Add(fhAsyPi0LocMax1[i][j]) ; | |
918 | ||
919 | fhAsyEtaLocMax1[i][j] = new TH2F(Form("hAsyEtaLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
920 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1", | |
921 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
922 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
923 | fhAsyEtaLocMax1[i][j] ->SetYTitle("Asymmetry"); | |
924 | fhAsyEtaLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
925 | outputContainer->Add(fhAsyEtaLocMax1[i][j]) ; | |
926 | ||
927 | fhAsyConLocMax1[i][j] = new TH2F(Form("hAsyConLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
928 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1", | |
929 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
930 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
931 | fhAsyConLocMax1[i][j] ->SetYTitle("Asymmetry"); | |
932 | fhAsyConLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
933 | outputContainer->Add(fhAsyConLocMax1[i][j]) ; | |
934 | ||
935 | fhAsyPi0LocMax2[i][j] = new TH2F(Form("hAsyPi0LocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
936 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2", | |
937 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
938 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
939 | fhAsyPi0LocMax2[i][j] ->SetYTitle("Asymmetry"); | |
940 | fhAsyPi0LocMax2[i][j] ->SetXTitle("E (GeV)"); | |
941 | outputContainer->Add(fhAsyPi0LocMax2[i][j]) ; | |
942 | ||
943 | fhAsyEtaLocMax2[i][j] = new TH2F(Form("hAsyEtaLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
944 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2", | |
945 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
946 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
947 | fhAsyEtaLocMax2[i][j] ->SetYTitle("Asymmetry"); | |
948 | fhAsyEtaLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
949 | outputContainer->Add(fhAsyEtaLocMax2[i][j]) ; | |
950 | ||
951 | fhAsyConLocMax2[i][j] = new TH2F(Form("hAsyConLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
952 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2", | |
953 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
954 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
955 | fhAsyConLocMax2[i][j] ->SetYTitle("Asymmetry"); | |
956 | fhAsyConLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
957 | outputContainer->Add(fhAsyConLocMax2[i][j]) ; | |
958 | ||
959 | fhAsyPi0LocMaxN[i][j] = new TH2F(Form("hAsyPi0LocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
960 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2", | |
961 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
962 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
963 | fhAsyPi0LocMaxN[i][j] ->SetYTitle("Asymmetry"); | |
964 | fhAsyPi0LocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
965 | outputContainer->Add(fhAsyPi0LocMaxN[i][j]) ; | |
966 | ||
967 | fhAsyEtaLocMaxN[i][j] = new TH2F(Form("hAsyEtaLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
968 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max > 2", | |
969 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
970 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
971 | fhAsyEtaLocMaxN[i][j] ->SetYTitle("Asymmetry"); | |
972 | fhAsyEtaLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
973 | outputContainer->Add(fhAsyEtaLocMaxN[i][j]) ; | |
974 | ||
975 | fhAsyConLocMaxN[i][j] = new TH2F(Form("hAsyConLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
976 | Form("Asymmetry vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2", | |
977 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
978 | nptbins,ptmin,ptmax,mbins,mmin,mmax); | |
979 | fhAsyConLocMaxN[i][j] ->SetYTitle("Asymmetry"); | |
980 | fhAsyConLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
981 | outputContainer->Add(fhAsyConLocMaxN[i][j]) ; | |
982 | ||
5c46c992 | 983 | } // matched, not matched |
984 | ||
883411b2 | 985 | for(Int_t j = 0; j < 4; j++) |
986 | { | |
53f2c382 | 987 | |
fc01318e | 988 | fhMassSplitEFractionNLocMax1Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax1%sEbin%d",pname[i].Data(),j), |
989 | Form("Invariant mass of 2 highest energy cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j), | |
990 | 120,0,1.2,mbins,mmin,mmax); | |
991 | fhMassSplitEFractionNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})"); | |
992 | fhMassSplitEFractionNLocMax1Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
993 | outputContainer->Add(fhMassSplitEFractionNLocMax1Ebin[i][j]) ; | |
883411b2 | 994 | |
fc01318e | 995 | fhMassSplitEFractionNLocMax2Ebin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMax2%sEbin%d",pname[i].Data(),j), |
996 | Form("Invariant mass of 2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j), | |
997 | 120,0,1.2,mbins,mmin,mmax); | |
998 | fhMassSplitEFractionNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})"); | |
999 | fhMassSplitEFractionNLocMax2Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
1000 | outputContainer->Add(fhMassSplitEFractionNLocMax2Ebin[i][j]) ; | |
883411b2 | 1001 | |
fc01318e | 1002 | fhMassSplitEFractionNLocMaxNEbin[i][j] = new TH2F(Form("hMassSplitEFractionNLocMaxN%sEbin%d",pname[i].Data(),j), |
1003 | Form("Invariant mass of N>2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j), | |
1004 | 120,0,1.2,mbins,mmin,mmax); | |
1005 | fhMassSplitEFractionNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})"); | |
1006 | fhMassSplitEFractionNLocMaxNEbin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
1007 | outputContainer->Add(fhMassSplitEFractionNLocMaxNEbin[i][j]) ; | |
883411b2 | 1008 | |
2a77f6f4 | 1009 | if(i>0 && fFillMCFractionHisto) // skip first entry in array, general case not filled |
fc01318e | 1010 | { |
1011 | fhMCGenFracNLocMaxEbin[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%d",pname[i].Data(),j), | |
1012 | Form("NLM vs E, %s, E bin %d",ptype[i].Data(),j), | |
1013 | 200,0,2,nMaxBins,0,nMaxBins); | |
1014 | fhMCGenFracNLocMaxEbin[i][j]->SetYTitle("NLM"); | |
fb51265c | 1015 | fhMCGenFracNLocMaxEbin[i][j]->SetXTitle("E_{gen} / E_{reco}"); |
fc01318e | 1016 | outputContainer->Add(fhMCGenFracNLocMaxEbin[i][j]) ; |
1017 | ||
1018 | fhMCGenFracNLocMaxEbinMatched[i][j] = new TH2F(Form("hMCGenFracNLocMax%sEbin%dMatched",pname[i].Data(),j), | |
1019 | Form("NLM vs E, %s, E bin %d, matched to a track",ptype[i].Data(),j), | |
1020 | 200,0,2,nMaxBins,0,nMaxBins); | |
1021 | fhMCGenFracNLocMaxEbinMatched[i][j]->SetYTitle("NLM"); | |
fb51265c | 1022 | fhMCGenFracNLocMaxEbinMatched[i][j]->SetXTitle("E_{gen} / E_{reco}"); |
fc01318e | 1023 | outputContainer->Add(fhMCGenFracNLocMaxEbinMatched[i][j]) ; |
1024 | ||
1025 | fhMassMCGenFracNLocMax1Ebin[i][j] = new TH2F(Form("hMassMCGenFracNLocMax1%sEbin%d",pname[i].Data(),j), | |
1026 | Form("Invariant mass of 2 highest energy cells vs E, %s, E bin %d",ptype[i].Data(),j), | |
1027 | 200,0,2,mbins,mmin,mmax); | |
1028 | fhMassMCGenFracNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})"); | |
fb51265c | 1029 | fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}"); |
fc01318e | 1030 | outputContainer->Add(fhMassMCGenFracNLocMax1Ebin[i][j]) ; |
1031 | ||
1032 | fhMassMCGenFracNLocMax2Ebin[i][j] = new TH2F(Form("hMassMCGenFracNLocMax2%sEbin%d",pname[i].Data(),j), | |
1033 | Form("Invariant mass of 2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j), | |
1034 | 200,0,2,mbins,mmin,mmax); | |
1035 | fhMassMCGenFracNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})"); | |
fb51265c | 1036 | fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}"); |
fc01318e | 1037 | outputContainer->Add(fhMassMCGenFracNLocMax2Ebin[i][j]) ; |
1038 | ||
1039 | fhMassMCGenFracNLocMaxNEbin[i][j] = new TH2F(Form("hMassMCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j), | |
1040 | Form("Invariant mass of N>2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j), | |
1041 | 200,0,2,mbins,mmin,mmax); | |
1042 | fhMassMCGenFracNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})"); | |
fb51265c | 1043 | fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{gen} / E_{reco}"); |
fc01318e | 1044 | outputContainer->Add(fhMassMCGenFracNLocMaxNEbin[i][j]) ; |
1045 | ||
1046 | fhM02MCGenFracNLocMax1Ebin[i][j] = new TH2F(Form("hM02MCGenFracNLocMax1%sEbin%d",pname[i].Data(),j), | |
1047 | Form("#lambda_{0}^{2} vs E for N max = 1 %s, E bin %d",ptype[i].Data(), j), | |
1048 | 200,0,2,ssbins,ssmin,ssmax); | |
1049 | fhM02MCGenFracNLocMax1Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
fb51265c | 1050 | fhM02MCGenFracNLocMax1Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}"); |
fc01318e | 1051 | outputContainer->Add(fhM02MCGenFracNLocMax1Ebin[i][j]) ; |
1052 | ||
1053 | fhM02MCGenFracNLocMax2Ebin[i][j] = new TH2F(Form("hM02MCGenFracNLocMax2%sEbin%d",pname[i].Data(),j), | |
1054 | Form("#lambda_{0}^{2} vs E for N max = 2 %s, E bin %d",ptype[i].Data(),j), | |
1055 | 200,0,2,ssbins,ssmin,ssmax); | |
1056 | fhM02MCGenFracNLocMax2Ebin[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
fb51265c | 1057 | fhM02MCGenFracNLocMax2Ebin[i][j] ->SetXTitle("E_{gen} / E_{reco}"); |
fc01318e | 1058 | outputContainer->Add(fhM02MCGenFracNLocMax2Ebin[i][j]) ; |
1059 | ||
1060 | fhM02MCGenFracNLocMaxNEbin[i][j] = new TH2F(Form("hM02MCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j), | |
1061 | Form("#lambda_{0}^{2} vs E for N max > 2 %s, E bin %d",ptype[i].Data(),j), | |
1062 | 200,0,2,ssbins,ssmin,ssmax); | |
1063 | fhM02MCGenFracNLocMaxNEbin[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
fb51265c | 1064 | fhM02MCGenFracNLocMaxNEbin[i][j] ->SetXTitle("E_{gen} / E_{reco}"); |
fc01318e | 1065 | outputContainer->Add(fhM02MCGenFracNLocMaxNEbin[i][j]) ; |
1066 | } | |
883411b2 | 1067 | } |
5c46c992 | 1068 | } // MC particle list |
1069 | ||
7b686344 | 1070 | for(Int_t i = 0; i < 4; i++) |
1071 | { | |
1072 | fhMassM02NLocMax1Ebin[i] = new TH2F(Form("hMassM02NLocMax1Ebin%d",i), | |
b8eb40fc | 1073 | Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=1, E bin %d",i), |
7b686344 | 1074 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
1075 | fhMassM02NLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1076 | fhMassM02NLocMax1Ebin[i]->SetXTitle("#lambda_{0}^{2}"); | |
1077 | outputContainer->Add(fhMassM02NLocMax1Ebin[i]) ; | |
1078 | ||
1079 | fhMassM02NLocMax2Ebin[i] = new TH2F(Form("hMassM02NLocMax2Ebin%d",i), | |
b8eb40fc | 1080 | Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=2, E bin %d",i), |
7b686344 | 1081 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
1082 | fhMassM02NLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1083 | fhMassM02NLocMax2Ebin[i]->SetXTitle("#lambda_{0}^{2}"); | |
1084 | outputContainer->Add(fhMassM02NLocMax2Ebin[i]) ; | |
1085 | ||
1086 | fhMassM02NLocMaxNEbin[i] = new TH2F(Form("hMassM02NLocMaxNEbin%d",i), | |
b8eb40fc | 1087 | Form("Invariant mass of split clusters vs vs #lambda_{0}^{2}, NLM>2, E bin %d",i), |
7b686344 | 1088 | ssbins,ssmin,ssmax,mbins,mmin,mmax); |
1089 | fhMassM02NLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})"); | |
1090 | fhMassM02NLocMaxNEbin[i]->SetXTitle("#lambda_{0}^{2}"); | |
d2655d46 | 1091 | outputContainer->Add(fhMassM02NLocMaxNEbin[i]) ; |
1092 | ||
b8eb40fc | 1093 | |
1094 | fhMassAsyNLocMax1Ebin[i] = new TH2F(Form("hMassAsyNLocMax1Ebin%d",i), | |
1095 | Form("Invariant mass of split clusters vs split asymmetry, NLM=1, E bin %d",i), | |
1096 | 200,-1,1,mbins,mmin,mmax); | |
1097 | fhMassAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1098 | fhMassAsyNLocMax1Ebin[i]->SetXTitle("asymmetry"); | |
1099 | outputContainer->Add(fhMassAsyNLocMax1Ebin[i]) ; | |
1100 | ||
1101 | fhMassAsyNLocMax2Ebin[i] = new TH2F(Form("hMassAsyNLocMax2Ebin%d",i), | |
1102 | Form("Invariant mass of split clusters vs split asymmetry, NLM=2, E bin %d",i), | |
1103 | 200,-1,1,mbins,mmin,mmax); | |
1104 | fhMassAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1105 | fhMassAsyNLocMax2Ebin[i]->SetXTitle("asymmetry"); | |
1106 | outputContainer->Add(fhMassAsyNLocMax2Ebin[i]) ; | |
1107 | ||
1108 | fhMassAsyNLocMaxNEbin[i] = new TH2F(Form("hMassAsyNLocMaxNEbin%d",i), | |
1109 | Form("Invariant mass of split clusters vs split asymmetry, NLM>2, E bin %d",i), | |
1110 | 200,-1,1,mbins,mmin,mmax); | |
1111 | fhMassAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})"); | |
1112 | fhMassAsyNLocMaxNEbin[i]->SetXTitle("asymmetry"); | |
1113 | outputContainer->Add(fhMassAsyNLocMaxNEbin[i]) ; | |
1114 | ||
1115 | ||
1116 | if(IsDataMC()) | |
1117 | { | |
1118 | fhMCAsymM02NLocMax1MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax1MCPi0Ebin%d",i), | |
1119 | Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=1, E bin %d",i), | |
1120 | ssbins,ssmin,ssmax,100,0,1); | |
1121 | fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetYTitle("Decay asymmetry"); | |
1122 | fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}"); | |
1123 | outputContainer->Add(fhMCAsymM02NLocMax1MCPi0Ebin[i]) ; | |
1124 | ||
1125 | fhMCAsymM02NLocMax2MCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMax2MCPi0Ebin%d",i), | |
1126 | Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=2, E bin %d",i), | |
1127 | ssbins,ssmin,ssmax,100,0,1); | |
1128 | fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetYTitle("Decay asymmetry"); | |
1129 | fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}"); | |
1130 | outputContainer->Add(fhMCAsymM02NLocMax2MCPi0Ebin[i]) ; | |
1131 | ||
1132 | fhMCAsymM02NLocMaxNMCPi0Ebin[i] = new TH2F(Form("hMCAsymM02NLocMaxNMCPi0Ebin%d",i), | |
1133 | Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM>2, E bin %d",i), | |
1134 | ssbins,ssmin,ssmax,100,0,1); | |
1135 | fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetYTitle("Decay asymmetry"); | |
1136 | fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}"); | |
1137 | outputContainer->Add(fhMCAsymM02NLocMaxNMCPi0Ebin[i]) ; | |
1138 | ||
1139 | ||
1140 | fhAsyMCGenRecoNLocMax1EbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMax1Ebin%dPi0",i), | |
1141 | Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=1, E bin %d",i), | |
1142 | 200,-1,1,200,-1,1); | |
1143 | fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetYTitle("M (GeV/c^{2})"); | |
1144 | fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetXTitle("asymmetry"); | |
1145 | outputContainer->Add(fhAsyMCGenRecoNLocMax1EbinPi0[i]) ; | |
1146 | ||
1147 | fhAsyMCGenRecoNLocMax2EbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMax2Ebin%dPi0",i), | |
1148 | Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=2, E bin %d",i), | |
1149 | 200,-1,1,200,-1,1); | |
1150 | fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetYTitle("M (GeV/c^{2})"); | |
1151 | fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetXTitle("asymmetry"); | |
1152 | outputContainer->Add(fhAsyMCGenRecoNLocMax2EbinPi0[i]) ; | |
1153 | ||
1154 | fhAsyMCGenRecoNLocMaxNEbinPi0[i] = new TH2F(Form("hAsyMCGenRecoNLocMaxNEbin%dPi0",i), | |
1155 | Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM>2, E bin %d",i), | |
1156 | 200,-1,1,200,-1,1); | |
1157 | fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetYTitle("M (GeV/c^{2})"); | |
1158 | fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetXTitle("asymmetry"); | |
1159 | outputContainer->Add(fhAsyMCGenRecoNLocMaxNEbinPi0[i]) ; | |
1160 | } | |
1161 | ||
8e81c2cf | 1162 | if(fFillSSExtraHisto) |
1163 | { | |
1164 | fhMassDispEtaNLocMax1Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax1Ebin%d",i), | |
1165 | Form("Invariant mass of 2 highest energy cells #sigma_{#eta #eta}^{2}, E bin %d",i), | |
1166 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
1167 | fhMassDispEtaNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1168 | fhMassDispEtaNLocMax1Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}"); | |
1169 | outputContainer->Add(fhMassDispEtaNLocMax1Ebin[i]) ; | |
1170 | ||
1171 | fhMassDispEtaNLocMax2Ebin[i] = new TH2F(Form("hMassDispEtaNLocMax2Ebin%d",i), | |
1172 | Form("Invariant mass of 2 local maxima cells #sigma_{#eta #eta}^{2}, E bin %d",i), | |
1173 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
1174 | fhMassDispEtaNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1175 | fhMassDispEtaNLocMax2Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}"); | |
1176 | outputContainer->Add(fhMassDispEtaNLocMax2Ebin[i]) ; | |
1177 | ||
1178 | fhMassDispEtaNLocMaxNEbin[i] = new TH2F(Form("hMassDispEtaNLocMaxNEbin%d",i), | |
1179 | Form("Invariant mass of N>2 local maxima cells vs #sigma_{#eta #eta}^{2}, E bin %d",i), | |
1180 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
1181 | fhMassDispEtaNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})"); | |
1182 | fhMassDispEtaNLocMaxNEbin[i]->SetXTitle("#sigma_{#eta #eta}^{2}"); | |
1183 | outputContainer->Add(fhMassDispEtaNLocMaxNEbin[i]) ; | |
1184 | ||
1185 | fhMassDispPhiNLocMax1Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax1Ebin%d",i), | |
1186 | Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E bin %d",i), | |
1187 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
1188 | fhMassDispPhiNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1189 | fhMassDispPhiNLocMax1Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}"); | |
1190 | outputContainer->Add(fhMassDispPhiNLocMax1Ebin[i]) ; | |
1191 | ||
1192 | fhMassDispPhiNLocMax2Ebin[i] = new TH2F(Form("hMassDispPhiNLocMax2Ebin%d",i), | |
1193 | Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E bin %d",i), | |
1194 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
1195 | fhMassDispPhiNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1196 | fhMassDispPhiNLocMax2Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}"); | |
1197 | outputContainer->Add(fhMassDispPhiNLocMax2Ebin[i]) ; | |
1198 | ||
1199 | fhMassDispPhiNLocMaxNEbin[i] = new TH2F(Form("hMassDispPhiNLocMaxNEbin%d",i), | |
1200 | Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, E bin %d",i), | |
1201 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
1202 | fhMassDispPhiNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})"); | |
1203 | fhMassDispPhiNLocMaxNEbin[i]->SetXTitle("#sigma_{#phi #phi}^{2}"); | |
1204 | outputContainer->Add(fhMassDispPhiNLocMaxNEbin[i]) ; | |
1205 | ||
1206 | fhMassDispAsyNLocMax1Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax1Ebin%d",i), | |
1207 | 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), | |
1208 | 200,-1,1,mbins,mmin,mmax); | |
1209 | fhMassDispAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1210 | fhMassDispAsyNLocMax1Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})"); | |
1211 | outputContainer->Add(fhMassDispAsyNLocMax1Ebin[i]) ; | |
1212 | ||
1213 | fhMassDispAsyNLocMax2Ebin[i] = new TH2F(Form("hMassDispAsyNLocMax2Ebin%d",i), | |
1214 | 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), | |
1215 | 200,-1,1,mbins,mmin,mmax); | |
1216 | fhMassDispAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
1217 | fhMassDispAsyNLocMax2Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})"); | |
1218 | outputContainer->Add(fhMassDispAsyNLocMax2Ebin[i]) ; | |
1219 | ||
1220 | fhMassDispAsyNLocMaxNEbin[i] = new TH2F(Form("hMassDispAsyNLocMaxNEbin%d",i), | |
1221 | 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), | |
1222 | 200,-1,1,mbins,mmin,mmax); | |
1223 | fhMassDispAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})"); | |
1224 | fhMassDispAsyNLocMaxNEbin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})"); | |
1225 | outputContainer->Add(fhMassDispAsyNLocMaxNEbin[i]) ; | |
1226 | } | |
7b686344 | 1227 | } |
1228 | ||
8e81c2cf | 1229 | if(fFillTMResidualHisto) |
1230 | { | |
1231 | for(Int_t i = 0; i < n; i++) | |
1232 | { | |
1233 | ||
1234 | fhTrackMatchedDEtaLocMax1[i] = new TH2F | |
1235 | (Form("hTrackMatchedDEtaLocMax1%s",pname[i].Data()), | |
1236 | Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()), | |
1237 | nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax); | |
1238 | fhTrackMatchedDEtaLocMax1[i]->SetYTitle("d#eta"); | |
1239 | fhTrackMatchedDEtaLocMax1[i]->SetXTitle("E_{cluster} (GeV)"); | |
1240 | ||
1241 | fhTrackMatchedDPhiLocMax1[i] = new TH2F | |
1242 | (Form("hTrackMatchedDPhiLocMax1%s",pname[i].Data()), | |
1243 | Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()), | |
1244 | nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax); | |
1245 | fhTrackMatchedDPhiLocMax1[i]->SetYTitle("d#phi (rad)"); | |
1246 | fhTrackMatchedDPhiLocMax1[i]->SetXTitle("E_{cluster} (GeV)"); | |
1247 | ||
1248 | outputContainer->Add(fhTrackMatchedDEtaLocMax1[i]) ; | |
1249 | outputContainer->Add(fhTrackMatchedDPhiLocMax1[i]) ; | |
1250 | ||
1251 | fhTrackMatchedDEtaLocMax2[i] = new TH2F | |
1252 | (Form("hTrackMatchedDEtaLocMax2%s",pname[i].Data()), | |
1253 | Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()), | |
1254 | nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax); | |
1255 | fhTrackMatchedDEtaLocMax2[i]->SetYTitle("d#eta"); | |
1256 | fhTrackMatchedDEtaLocMax2[i]->SetXTitle("E_{cluster} (GeV)"); | |
1257 | ||
1258 | fhTrackMatchedDPhiLocMax2[i] = new TH2F | |
1259 | (Form("hTrackMatchedDPhiLocMax2%s",pname[i].Data()), | |
1260 | Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()), | |
1261 | nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax); | |
1262 | fhTrackMatchedDPhiLocMax2[i]->SetYTitle("d#phi (rad)"); | |
1263 | fhTrackMatchedDPhiLocMax2[i]->SetXTitle("E_{cluster} (GeV)"); | |
1264 | ||
1265 | outputContainer->Add(fhTrackMatchedDEtaLocMax2[i]) ; | |
1266 | outputContainer->Add(fhTrackMatchedDPhiLocMax2[i]) ; | |
1267 | ||
1268 | fhTrackMatchedDEtaLocMaxN[i] = new TH2F | |
1269 | (Form("hTrackMatchedDEtaLocMaxN%s",pname[i].Data()), | |
1270 | Form("d#eta of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()), | |
1271 | nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax); | |
1272 | fhTrackMatchedDEtaLocMaxN[i]->SetYTitle("d#eta"); | |
1273 | fhTrackMatchedDEtaLocMaxN[i]->SetXTitle("E_{cluster} (GeV)"); | |
1274 | ||
1275 | fhTrackMatchedDPhiLocMaxN[i] = new TH2F | |
1276 | (Form("hTrackMatchedDPhiLocMaxN%s",pname[i].Data()), | |
1277 | Form("d#phi of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()), | |
1278 | nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax); | |
1279 | fhTrackMatchedDPhiLocMaxN[i]->SetYTitle("d#phi (rad)"); | |
1280 | fhTrackMatchedDPhiLocMaxN[i]->SetXTitle("E_{cluster} (GeV)"); | |
1281 | ||
1282 | outputContainer->Add(fhTrackMatchedDEtaLocMaxN[i]) ; | |
1283 | outputContainer->Add(fhTrackMatchedDPhiLocMaxN[i]) ; | |
1284 | } | |
5c46c992 | 1285 | } |
1286 | ||
883411b2 | 1287 | if(fFillAngleHisto) |
1288 | { | |
1289 | for(Int_t j = 0; j < 2; j++) | |
1290 | { | |
1291 | ||
1292 | fhAnglePairLocMax1[j] = new TH2F(Form("hAnglePairLocMax1%s",sMatched[j].Data()), | |
1293 | Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()), | |
1294 | nptbins,ptmin,ptmax,200,0,0.2); | |
1295 | fhAnglePairLocMax1[j]->SetYTitle("#alpha (rad)"); | |
1296 | fhAnglePairLocMax1[j]->SetXTitle("E (GeV)"); | |
1297 | outputContainer->Add(fhAnglePairLocMax1[j]) ; | |
1298 | ||
1299 | fhAnglePairLocMax2[j] = new TH2F(Form("hAnglePairLocMax2%s",sMatched[j].Data()), | |
1300 | Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()), | |
1301 | nptbins,ptmin,ptmax,200,0,0.2); | |
1302 | fhAnglePairLocMax2[j]->SetYTitle("#alpha (rad)"); | |
1303 | fhAnglePairLocMax2[j]->SetXTitle("E (GeV)"); | |
1304 | outputContainer->Add(fhAnglePairLocMax2[j]) ; | |
1305 | ||
1306 | fhAnglePairLocMaxN[j] = new TH2F(Form("hAnglePairLocMaxN%s",sMatched[j].Data()), | |
1307 | Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()), | |
1308 | nptbins,ptmin,ptmax,200,0,0.2); | |
1309 | fhAnglePairLocMaxN[j]->SetYTitle("#alpha (rad)"); | |
1310 | fhAnglePairLocMaxN[j]->SetXTitle("E (GeV)"); | |
1311 | outputContainer->Add(fhAnglePairLocMaxN[j]) ; | |
1312 | ||
1313 | fhAnglePairMassLocMax1[j] = new TH2F(Form("hAnglePairMassLocMax1%s",sMatched[j].Data()), | |
e671adc2 | 1314 | Form("Opening angle of 2 highest energy cells vs Mass for E > 8 GeV, %s",sMatched[j].Data()), |
883411b2 | 1315 | mbins,mmin,mmax,200,0,0.2); |
1316 | fhAnglePairMassLocMax1[j]->SetXTitle("M (GeV/c^{2})"); | |
1317 | fhAnglePairMassLocMax1[j]->SetYTitle("#alpha (rad)"); | |
1318 | outputContainer->Add(fhAnglePairMassLocMax1[j]) ; | |
1319 | ||
1320 | fhAnglePairMassLocMax2[j] = new TH2F(Form("hAnglePairMassLocMax2%s",sMatched[j].Data()), | |
e671adc2 | 1321 | Form("Opening angle of 2 local maxima cells vs Mass for E > 8 GeV, %s",sMatched[j].Data()), |
883411b2 | 1322 | mbins,mmin,mmax,200,0,0.2); |
1323 | fhAnglePairMassLocMax2[j]->SetXTitle("M (GeV/c^{2})"); | |
1324 | fhAnglePairMassLocMax2[j]->SetYTitle("#alpha (rad)"); | |
1325 | outputContainer->Add(fhAnglePairMassLocMax2[j]) ; | |
1326 | ||
1327 | fhAnglePairMassLocMaxN[j] = new TH2F(Form("hAnglePairMassLocMaxN%s",sMatched[j].Data()), | |
e671adc2 | 1328 | Form("Opening angle of N>2 local maxima cells vs Mass for E > 8 GeV, %s",sMatched[j].Data()), |
883411b2 | 1329 | mbins,mmin,mmax,200,0,0.2); |
1330 | fhAnglePairMassLocMaxN[j]->SetXTitle("M (GeV/c^{2})"); | |
1331 | fhAnglePairMassLocMaxN[j]->SetYTitle("#alpha (rad)"); | |
1332 | outputContainer->Add(fhAnglePairMassLocMaxN[j]) ; | |
1333 | ||
1334 | } | |
992b14a7 | 1335 | } |
1336 | ||
e671adc2 | 1337 | for(Int_t j = 0; j < 2; j++) |
1338 | { | |
1339 | fhSplitEFractionvsAsyNLocMax1[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMax1%s",sMatched[j].Data()), | |
1340 | Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max = 1, E>8, %s",sMatched[j].Data()), | |
1341 | 100,-1,1,120,0,1.2); | |
1342 | fhSplitEFractionvsAsyNLocMax1[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})"); | |
1343 | fhSplitEFractionvsAsyNLocMax1[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
1344 | outputContainer->Add(fhSplitEFractionvsAsyNLocMax1[j]) ; | |
1345 | ||
1346 | fhSplitEFractionvsAsyNLocMax2[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMax2%s",sMatched[j].Data()), | |
1347 | Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max = 2,E>8, %s",sMatched[j].Data()), | |
1348 | 100,-1,1,120,0,1.2); | |
1349 | fhSplitEFractionvsAsyNLocMax2[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})"); | |
1350 | fhSplitEFractionvsAsyNLocMax2[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
1351 | outputContainer->Add(fhSplitEFractionvsAsyNLocMax2[j]) ; | |
1352 | ||
1353 | fhSplitEFractionvsAsyNLocMaxN[j] = new TH2F(Form("hSplitEFractionvsAsyNLocMaxN%s",sMatched[j].Data()), | |
1354 | Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max > 2, E>8, %s",sMatched[j].Data()), | |
1355 | 100,-1,1,120,0,1.2); | |
1356 | fhSplitEFractionvsAsyNLocMaxN[j] ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})"); | |
1357 | fhSplitEFractionvsAsyNLocMaxN[j] ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}"); | |
1358 | outputContainer->Add(fhSplitEFractionvsAsyNLocMaxN[j]) ; | |
1359 | } | |
1360 | ||
1361 | ||
992b14a7 | 1362 | return outputContainer ; |
1363 | ||
1364 | } | |
1365 | ||
992b14a7 | 1366 | //___________________________________________ |
1367 | void AliAnaInsideClusterInvariantMass::Init() | |
1368 | { | |
1369 | //Init | |
1370 | //Do some checks | |
3c1d9afb | 1371 | if(fCalorimeter == "PHOS" && !GetReader()->IsPHOSSwitchedOn() && NewOutputAOD()) |
1372 | { | |
992b14a7 | 1373 | printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!\n"); |
1374 | abort(); | |
1375 | } | |
3c1d9afb | 1376 | else if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn() && NewOutputAOD()) |
1377 | { | |
992b14a7 | 1378 | printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!\n"); |
1379 | abort(); | |
1380 | } | |
1381 | ||
3c1d9afb | 1382 | if( GetReader()->GetDataType() == AliCaloTrackReader::kMC ) |
1383 | { | |
992b14a7 | 1384 | printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use pure MC data!!\n"); |
1385 | abort(); | |
1386 | ||
1387 | } | |
1388 | ||
1389 | } | |
1390 | ||
1391 | //_____________________________________________________ | |
1392 | void AliAnaInsideClusterInvariantMass::InitParameters() | |
1393 | { | |
1394 | //Initialize the parameters of the analysis. | |
1395 | AddToHistogramsName("AnaPi0InsideClusterInvariantMass_"); | |
1396 | ||
1397 | fCalorimeter = "EMCAL" ; | |
29ca9cad | 1398 | |
71e3889f | 1399 | fM02MinCut = 0.26 ; |
1400 | fM02MaxCut = 10 ; | |
1401 | ||
992b14a7 | 1402 | fMinNCells = 4 ; |
2cb134fb | 1403 | fMinBadDist = 2 ; |
3c1d9afb | 1404 | |
992b14a7 | 1405 | } |
1406 | ||
1407 | ||
1408 | //__________________________________________________________________ | |
1409 | void AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() | |
1410 | { | |
1411 | //Search for pi0 in fCalorimeter with shower shape analysis | |
1412 | ||
1413 | TObjArray * pl = 0x0; | |
1414 | AliVCaloCells* cells = 0x0; | |
1415 | ||
1416 | //Select the Calorimeter of the photon | |
2cb134fb | 1417 | if(fCalorimeter == "PHOS") |
1418 | { | |
992b14a7 | 1419 | pl = GetPHOSClusters(); |
1420 | cells = GetPHOSCells(); | |
1421 | } | |
2cb134fb | 1422 | else if (fCalorimeter == "EMCAL") |
1423 | { | |
992b14a7 | 1424 | pl = GetEMCALClusters(); |
1425 | cells = GetEMCALCells(); | |
1426 | } | |
1427 | ||
e671adc2 | 1428 | const Float_t ecut = 8.; // Fixed cut for some histograms |
1429 | ||
3c1d9afb | 1430 | if(!pl || !cells) |
1431 | { | |
992b14a7 | 1432 | Info("MakeAnalysisFillHistograms","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data()); |
1433 | return; | |
1434 | } | |
1435 | ||
1436 | if(fCalorimeter == "PHOS") return; // Not implemented for PHOS yet | |
1437 | ||
2cb134fb | 1438 | for(Int_t icluster = 0; icluster < pl->GetEntriesFast(); icluster++) |
1439 | { | |
992b14a7 | 1440 | AliVCluster * cluster = (AliVCluster*) (pl->At(icluster)); |
1441 | ||
1442 | // Study clusters with large shape parameter | |
1443 | Float_t en = cluster->E(); | |
1444 | Float_t l0 = cluster->GetM02(); | |
1445 | Int_t nc = cluster->GetNCells(); | |
2cb134fb | 1446 | Float_t bd = cluster->GetDistanceToBadChannel() ; |
243c2909 | 1447 | |
d2655d46 | 1448 | |
2cb134fb | 1449 | //If too small or big E or low number of cells, or close to a bad channel skip it |
1450 | if( en < GetMinEnergy() || en > GetMaxEnergy() || nc < fMinNCells || bd < fMinBadDist) continue ; | |
1451 | ||
1452 | //printf("en %2.2f, GetMinEnergy() %2.2f, GetMaxEnergy() %2.2f, nc %d, fMinNCells %d, bd %2.2f, fMinBadDist %2.2f\n", | |
1453 | // en,GetMinEnergy(), GetMaxEnergy(), nc, fMinNCells, bd, fMinBadDist); | |
1454 | ||
d2655d46 | 1455 | // Get more Shower Shape parameters |
1456 | Float_t ll0 = 0., ll1 = 0.; | |
1457 | Float_t disp= 0., dispEta = 0., dispPhi = 0.; | |
1458 | Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.; | |
1459 | ||
1460 | GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), GetReader()->GetInputEvent()->GetEMCALCells(), cluster, | |
1461 | ll0, ll1, disp, dispEta, dispPhi, sEta, sPhi, sEtaPhi); | |
1462 | ||
1463 | Float_t dispAsy = -1; | |
1464 | if(dispEta+dispPhi >0 ) dispAsy = (dispPhi-dispEta) / (dispPhi+dispEta); | |
1465 | ||
3c1d9afb | 1466 | Int_t nMax = 0; |
bfdcf7fb | 1467 | Double_t mass = 0., angle = 0.; |
1468 | Double_t e1 = 0., e2 = 0.; | |
3c1d9afb | 1469 | Int_t pidTag = GetCaloPID()->GetIdentifiedParticleTypeFromClusterSplitting(cluster,cells,GetCaloUtils(), |
fc01318e | 1470 | GetVertex(0), nMax, mass, angle,e1,e2); |
5c46c992 | 1471 | if (nMax <= 0) |
1472 | { | |
de454976 | 1473 | if(GetDebug() > 0 ) |
1474 | printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - No local maximum found! It did not pass CaloPID selection criteria \n"); | |
5c46c992 | 1475 | |
992b14a7 | 1476 | return; |
1477 | } | |
1478 | ||
fc01318e | 1479 | Float_t splitFrac = (e1+e2)/en; |
e671adc2 | 1480 | Float_t asym = -10; |
1481 | if(e1+e2>0) asym = (e1-e2)/(e1+e2); | |
1482 | ||
fc01318e | 1483 | Bool_t matched = IsTrackMatched(cluster,GetReader()->GetInputEvent()); |
cfc19369 | 1484 | |
3c1d9afb | 1485 | fhNLocMax[0][matched]->Fill(en,nMax); |
29ca9cad | 1486 | |
2a77f6f4 | 1487 | if ( nMax == 1 ) |
1488 | { | |
1489 | fhM02NLocMax1[0][matched]->Fill(en,l0) ; | |
1490 | fhSplitEFractionNLocMax1[0][matched]->Fill(en,splitFrac) ; | |
e671adc2 | 1491 | if(en > ecut) fhSplitEFractionvsAsyNLocMax1[matched]->Fill(asym,splitFrac) ; |
2a77f6f4 | 1492 | if(fFillSSExtraHisto) fhNCellNLocMax1[0][matched]->Fill(en,nc) ; |
1493 | } | |
1494 | else if( nMax == 2 ) | |
1495 | { | |
1496 | fhM02NLocMax2[0][matched]->Fill(en,l0) ; | |
1497 | fhSplitEFractionNLocMax2[0][matched]->Fill(en,splitFrac) ; | |
e671adc2 | 1498 | if(en > ecut) fhSplitEFractionvsAsyNLocMax2[matched]->Fill(asym,splitFrac) ; |
2a77f6f4 | 1499 | if(fFillSSExtraHisto) fhNCellNLocMax2[0][matched]->Fill(en,nc) ; } |
1500 | else if( nMax >= 3 ) | |
1501 | { | |
1502 | fhM02NLocMaxN[0][matched]->Fill(en,l0) ; | |
1503 | fhSplitEFractionNLocMaxN[0][matched]->Fill(en,splitFrac) ; | |
e671adc2 | 1504 | if(en > ecut) fhSplitEFractionvsAsyNLocMaxN[matched]->Fill(asym,splitFrac) ; |
2a77f6f4 | 1505 | if(fFillSSExtraHisto) fhNCellNLocMaxN[0][matched]->Fill(en,nc) ; |
1506 | } | |
992b14a7 | 1507 | else printf("N max smaller than 1 -> %d \n",nMax); |
5c46c992 | 1508 | |
2a77f6f4 | 1509 | |
5c46c992 | 1510 | Float_t dZ = cluster->GetTrackDz(); |
1511 | Float_t dR = cluster->GetTrackDx(); | |
1512 | ||
1513 | if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn()) | |
1514 | { | |
1515 | dR = 2000., dZ = 2000.; | |
1516 | GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR); | |
1517 | } | |
1518 | //printf("Pi0EbE: dPhi %f, dEta %f\n",dR,dZ); | |
1519 | ||
8e81c2cf | 1520 | if(TMath::Abs(dR) < 999 && fFillTMResidualHisto) |
5c46c992 | 1521 | { |
1522 | if ( nMax == 1 ) { fhTrackMatchedDEtaLocMax1[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMax1[0]->Fill(en,dR); } | |
1523 | else if( nMax == 2 ) { fhTrackMatchedDEtaLocMax2[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMax2[0]->Fill(en,dR); } | |
1524 | else if( nMax >= 3 ) { fhTrackMatchedDEtaLocMaxN[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMaxN[0]->Fill(en,dR); } | |
1525 | } | |
fc01318e | 1526 | |
992b14a7 | 1527 | // Play with the MC stack if available |
1528 | // Check origin of the candidates | |
8e81c2cf | 1529 | Int_t mcindex = -1; |
1530 | Float_t eprim = 0; | |
1531 | Float_t asymGen = -2; | |
53f2c382 | 1532 | Int_t mcLabel = cluster->GetLabel(); |
3c1d9afb | 1533 | if(IsDataMC()) |
1534 | { | |
2644ead9 | 1535 | Int_t tag = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(), GetReader()); |
992b14a7 | 1536 | |
c5693f62 | 1537 | if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ) mcindex = kmcPi0; |
1538 | else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ) mcindex = kmcEta; | |
992b14a7 | 1539 | else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && |
c5693f62 | 1540 | !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPhoton; |
992b14a7 | 1541 | else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && |
c5693f62 | 1542 | GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcConversion; |
1543 | else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) mcindex = kmcElectron; | |
1544 | else mcindex = kmcHadron; | |
71e3889f | 1545 | |
5c46c992 | 1546 | fhNLocMax[mcindex][matched]->Fill(en,nMax); |
3c1d9afb | 1547 | |
fc01318e | 1548 | if (nMax == 1 ) { fhM02NLocMax1[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax1[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax1[mcindex][matched]->Fill(en,nc) ; } |
1549 | else if(nMax == 2 ) { fhM02NLocMax2[mcindex][matched]->Fill(en,l0) ; fhSplitEFractionNLocMax2[mcindex][matched]->Fill(en,splitFrac) ; if(fFillSSExtraHisto) fhNCellNLocMax2[mcindex][matched]->Fill(en,nc) ; } | |
1550 | 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 | 1551 | |
8e81c2cf | 1552 | if(TMath::Abs(dR) < 999 && fFillTMResidualHisto) |
5c46c992 | 1553 | { |
1554 | if ( nMax == 1 ) { fhTrackMatchedDEtaLocMax1[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMax1[mcindex]->Fill(en,dR); } | |
1555 | else if( nMax == 2 ) { fhTrackMatchedDEtaLocMax2[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMax2[mcindex]->Fill(en,dR); } | |
1556 | else if( nMax >= 3 ) { fhTrackMatchedDEtaLocMaxN[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMaxN[mcindex]->Fill(en,dR); } | |
29ca9cad | 1557 | } |
992b14a7 | 1558 | |
8e81c2cf | 1559 | Bool_t ok = kFALSE; |
53f2c382 | 1560 | TLorentzVector primary = GetMCAnalysisUtils()->GetMother(mcLabel,GetReader(),ok); |
8e81c2cf | 1561 | eprim = primary.E(); |
1562 | ||
883411b2 | 1563 | if(mcindex == kmcPi0 || mcindex == kmcEta) |
8e81c2cf | 1564 | { |
53f2c382 | 1565 | if(mcindex == kmcPi0) |
1566 | { | |
1567 | asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,111,GetReader(),ok)); | |
1568 | TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,111,GetReader(),ok); | |
1569 | if(grandmom.E() > 0 && ok) eprim = grandmom.E(); | |
1570 | } | |
1571 | else | |
1572 | { | |
1573 | asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,221,GetReader(),ok)); | |
1574 | TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,221,GetReader(),ok); | |
1575 | if(grandmom.E() > 0 && ok) eprim = grandmom.E(); | |
1576 | } | |
8e81c2cf | 1577 | } |
d2655d46 | 1578 | } |
1579 | ||
5094c724 | 1580 | Float_t efrac = eprim/en; |
bb2d339b | 1581 | Float_t efracSplit = 0; |
1582 | if(e1+e2 > 0) efracSplit = eprim/(e1+e2); | |
5094c724 | 1583 | |
bb2d339b | 1584 | //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", |
1585 | // e1,e2,eprim,en,splitFrac,efrac,efracSplit); | |
1586 | ||
d2655d46 | 1587 | Int_t ebin = -1; |
8e81c2cf | 1588 | if(en > 8 && en <= 12) ebin = 0; |
1589 | if(en > 12 && en <= 16) ebin = 1; | |
1590 | if(en > 16 && en <= 20) ebin = 2; | |
d2655d46 | 1591 | if(en > 20) ebin = 3; |
1592 | ||
2a77f6f4 | 1593 | if(ebin >= 0 && IsDataMC() && fFillMCFractionHisto) |
53f2c382 | 1594 | { |
1595 | if( !matched ) fhMCGenFracNLocMaxEbin [mcindex][ebin]->Fill(efrac,nMax); | |
1596 | else fhMCGenFracNLocMaxEbinMatched[mcindex][ebin]->Fill(efrac,nMax); | |
1597 | } | |
1598 | ||
26680f06 | 1599 | if (nMax==1) |
1600 | { | |
e671adc2 | 1601 | if( en > ecut ) |
26680f06 | 1602 | { |
d2655d46 | 1603 | fhMassM02NLocMax1 [0][matched]->Fill(l0 , mass ); |
8e81c2cf | 1604 | if(fFillSSExtraHisto) |
1605 | { | |
1606 | fhMassDispEtaNLocMax1[0][matched]->Fill(dispEta, mass ); | |
1607 | fhMassDispPhiNLocMax1[0][matched]->Fill(dispPhi, mass ); | |
1608 | fhMassDispAsyNLocMax1[0][matched]->Fill(dispAsy, mass ); | |
1609 | } | |
1610 | ||
a700f620 | 1611 | if(IsDataMC()) |
d2655d46 | 1612 | { |
8e81c2cf | 1613 | fhMassM02NLocMax1 [mcindex][matched]->Fill(l0 , mass ); |
2a77f6f4 | 1614 | if(fFillMCFractionHisto) |
1615 | { | |
1616 | fhMCGenFracNLocMax1 [mcindex][matched]->Fill(en , efrac ); | |
1617 | fhMCGenSplitEFracNLocMax1 [mcindex][matched]->Fill(en , efracSplit ); | |
1618 | fhMCGenEvsSplitENLocMax1 [mcindex][matched]->Fill(eprim , e1+e2); | |
1619 | fhMCGenEFracvsSplitEFracNLocMax1[mcindex][matched]->Fill(efrac,splitFrac ); | |
1620 | } | |
1621 | ||
8e81c2cf | 1622 | if(!matched && ebin >= 0) |
1623 | { | |
2a77f6f4 | 1624 | if(fFillMCFractionHisto) |
1625 | { | |
1626 | fhM02MCGenFracNLocMax1Ebin [mcindex][ebin]->Fill(efrac , l0 ); | |
1627 | fhMassMCGenFracNLocMax1Ebin[mcindex][ebin]->Fill(efrac , mass ); | |
1628 | } | |
b8eb40fc | 1629 | fhMCAsymM02NLocMax1MCPi0Ebin [ebin]->Fill(l0 , asymGen ); |
1630 | fhAsyMCGenRecoNLocMax1EbinPi0[ebin]->Fill(asym, asymGen ); | |
8e81c2cf | 1631 | } |
1632 | ||
1633 | if(fFillSSExtraHisto) | |
1634 | { | |
1635 | fhMassDispEtaNLocMax1[mcindex][matched]->Fill(dispEta, mass ); | |
1636 | fhMassDispPhiNLocMax1[mcindex][matched]->Fill(dispPhi, mass ); | |
1637 | fhMassDispAsyNLocMax1[mcindex][matched]->Fill(dispAsy, mass ); | |
1638 | } | |
d2655d46 | 1639 | } |
26680f06 | 1640 | } |
1641 | ||
d2655d46 | 1642 | if(!matched && ebin >= 0) |
26680f06 | 1643 | { |
fc01318e | 1644 | fhMassSplitEFractionNLocMax1Ebin[0][ebin]->Fill(splitFrac, mass); |
1645 | if(IsDataMC())fhMassSplitEFractionNLocMax1Ebin[mcindex][ebin]->Fill(splitFrac, mass); | |
1646 | ||
b8eb40fc | 1647 | fhMassM02NLocMax1Ebin [ebin]->Fill(l0 , mass ); |
1648 | fhMassAsyNLocMax1Ebin [ebin]->Fill(asym, mass ); | |
1649 | ||
8e81c2cf | 1650 | if(fFillSSExtraHisto) |
1651 | { | |
1652 | fhMassDispEtaNLocMax1Ebin[ebin]->Fill(dispEta, mass ); | |
1653 | fhMassDispPhiNLocMax1Ebin[ebin]->Fill(dispPhi, mass ); | |
1654 | fhMassDispAsyNLocMax1Ebin[ebin]->Fill(dispAsy, mass ); | |
1655 | } | |
26680f06 | 1656 | } |
1657 | } | |
1658 | else if(nMax==2) | |
1659 | { | |
e671adc2 | 1660 | if( en > ecut ) |
d2655d46 | 1661 | { |
1662 | fhMassM02NLocMax2 [0][matched]->Fill(l0 , mass ); | |
8e81c2cf | 1663 | if(fFillSSExtraHisto) |
1664 | { | |
1665 | fhMassDispEtaNLocMax2[0][matched]->Fill(dispEta, mass ); | |
1666 | fhMassDispPhiNLocMax2[0][matched]->Fill(dispPhi, mass ); | |
1667 | fhMassDispAsyNLocMax2[0][matched]->Fill(dispAsy, mass ); | |
1668 | } | |
d2655d46 | 1669 | |
a700f620 | 1670 | if(IsDataMC()) |
d2655d46 | 1671 | { |
5094c724 | 1672 | fhMassM02NLocMax2 [mcindex][matched]->Fill(l0 , mass ); |
2a77f6f4 | 1673 | if(fFillMCFractionHisto) |
1674 | { | |
1675 | fhMCGenFracNLocMax2 [mcindex][matched]->Fill(en , efrac ); | |
1676 | fhMCGenSplitEFracNLocMax2[mcindex][matched]->Fill(en , efracSplit ); | |
1677 | fhMCGenEvsSplitENLocMax2 [mcindex][matched]->Fill(eprim , e1+e2); | |
1678 | fhMCGenEFracvsSplitEFracNLocMax2[mcindex][matched]->Fill(efrac,splitFrac ); | |
1679 | } | |
1680 | ||
8e81c2cf | 1681 | if(!matched && ebin >= 0) |
1682 | { | |
2a77f6f4 | 1683 | if(fFillMCFractionHisto) |
1684 | { | |
1685 | fhM02MCGenFracNLocMax2Ebin [mcindex][ebin]->Fill(efrac , l0 ); | |
1686 | fhMassMCGenFracNLocMax2Ebin[mcindex][ebin]->Fill(efrac , mass ); | |
1687 | } | |
b8eb40fc | 1688 | fhMCAsymM02NLocMax2MCPi0Ebin [ebin]->Fill(l0 , asymGen ); |
1689 | fhAsyMCGenRecoNLocMax2EbinPi0[ebin]->Fill(asym, asymGen ); | |
8e81c2cf | 1690 | } |
1691 | if(fFillSSExtraHisto) | |
1692 | { | |
1693 | fhMassDispEtaNLocMax2[mcindex][matched]->Fill(dispEta, mass ); | |
1694 | fhMassDispPhiNLocMax2[mcindex][matched]->Fill(dispPhi, mass ); | |
1695 | fhMassDispAsyNLocMax2[mcindex][matched]->Fill(dispAsy, mass ); | |
1696 | } | |
d2655d46 | 1697 | } |
26680f06 | 1698 | } |
1699 | ||
d2655d46 | 1700 | if(!matched && ebin >= 0) |
26680f06 | 1701 | { |
fc01318e | 1702 | fhMassSplitEFractionNLocMax2Ebin[0][ebin]->Fill(splitFrac, mass); |
1703 | if(IsDataMC())fhMassSplitEFractionNLocMax2Ebin[mcindex][ebin]->Fill(splitFrac, mass); | |
1704 | ||
b8eb40fc | 1705 | fhMassM02NLocMax2Ebin [ebin]->Fill(l0 , mass ); |
1706 | fhMassAsyNLocMax2Ebin [ebin]->Fill(asym, mass ); | |
1707 | ||
8e81c2cf | 1708 | if(fFillSSExtraHisto) |
1709 | { | |
1710 | fhMassDispEtaNLocMax2Ebin[ebin]->Fill(dispEta, mass ); | |
1711 | fhMassDispPhiNLocMax2Ebin[ebin]->Fill(dispPhi, mass ); | |
1712 | fhMassDispAsyNLocMax2Ebin[ebin]->Fill(dispAsy, mass ); | |
1713 | } | |
d2655d46 | 1714 | } |
26680f06 | 1715 | } |
8e81c2cf | 1716 | else if(nMax > 2 ) |
26680f06 | 1717 | { |
e671adc2 | 1718 | if( en > ecut ) |
26680f06 | 1719 | { |
d2655d46 | 1720 | fhMassM02NLocMaxN [0][matched]->Fill(l0 , mass ); |
8e81c2cf | 1721 | if(fFillSSExtraHisto) |
1722 | { | |
1723 | fhMassDispEtaNLocMaxN[0][matched]->Fill(dispEta, mass ); | |
1724 | fhMassDispPhiNLocMaxN[0][matched]->Fill(dispPhi, mass ); | |
1725 | fhMassDispAsyNLocMaxN[0][matched]->Fill(dispAsy, mass ); | |
1726 | } | |
d2655d46 | 1727 | |
a700f620 | 1728 | if(IsDataMC()) |
d2655d46 | 1729 | { |
5094c724 | 1730 | fhMassM02NLocMaxN [mcindex][matched]->Fill(l0 , mass ); |
2a77f6f4 | 1731 | if(fFillMCFractionHisto) |
1732 | { | |
1733 | fhMCGenFracNLocMaxN [mcindex][matched]->Fill(en , efrac ); | |
1734 | fhMCGenSplitEFracNLocMaxN[mcindex][matched]->Fill(en , efracSplit ); | |
1735 | fhMCGenEvsSplitENLocMaxN [mcindex][matched]->Fill(eprim , e1+e2); | |
1736 | fhMCGenEFracvsSplitEFracNLocMaxN[mcindex][matched]->Fill(efrac, splitFrac ); | |
1737 | } | |
1738 | ||
8e81c2cf | 1739 | if(!matched && ebin >= 0) |
1740 | { | |
2a77f6f4 | 1741 | if(fFillMCFractionHisto) |
1742 | { | |
1743 | fhM02MCGenFracNLocMaxNEbin [mcindex][ebin]->Fill(efrac , l0 ); | |
1744 | fhMassMCGenFracNLocMaxNEbin[mcindex][ebin]->Fill(efrac , mass ); | |
1745 | } | |
b8eb40fc | 1746 | fhMCAsymM02NLocMaxNMCPi0Ebin [ebin]->Fill(l0 , asymGen ); |
1747 | fhAsyMCGenRecoNLocMaxNEbinPi0[ebin]->Fill(asym, asymGen ); | |
8e81c2cf | 1748 | } |
1749 | if(fFillSSExtraHisto) | |
1750 | { | |
1751 | fhMassDispEtaNLocMaxN[mcindex][matched]->Fill(dispEta, mass ); | |
1752 | fhMassDispPhiNLocMaxN[mcindex][matched]->Fill(dispPhi, mass ); | |
1753 | fhMassDispAsyNLocMaxN[mcindex][matched]->Fill(dispAsy, mass ); | |
1754 | } | |
d2655d46 | 1755 | } |
26680f06 | 1756 | } |
1757 | ||
d2655d46 | 1758 | if(!matched && ebin >= 0) |
26680f06 | 1759 | { |
fc01318e | 1760 | fhMassSplitEFractionNLocMaxNEbin[0][ebin]->Fill(splitFrac, mass); |
1761 | if(IsDataMC())fhMassSplitEFractionNLocMaxNEbin[mcindex][ebin]->Fill(splitFrac, mass); | |
1762 | ||
b8eb40fc | 1763 | fhMassM02NLocMaxNEbin [ebin]->Fill(l0 , mass ); |
1764 | fhMassAsyNLocMaxNEbin [ebin]->Fill(asym, mass ); | |
1765 | ||
8e81c2cf | 1766 | if(fFillSSExtraHisto) |
1767 | { | |
1768 | fhMassDispEtaNLocMaxNEbin[ebin]->Fill(dispEta, mass ); | |
1769 | fhMassDispPhiNLocMaxNEbin[ebin]->Fill(dispPhi, mass ); | |
1770 | fhMassDispAsyNLocMaxNEbin[ebin]->Fill(dispAsy, mass ); | |
1771 | } | |
26680f06 | 1772 | } |
1773 | } | |
1774 | ||
26680f06 | 1775 | //--------------------------------------------------------------------- |
1776 | // From here only if M02 is large but not too large, fill histograms | |
1777 | //--------------------------------------------------------------------- | |
1778 | ||
3c1d9afb | 1779 | if( l0 < fM02MinCut || l0 > fM02MaxCut ) continue ; |
26680f06 | 1780 | |
b8eb40fc | 1781 | Bool_t m02OK = GetCaloPID()->IsInPi0M02Range(en,l0,nMax); |
167f2534 | 1782 | Bool_t asyOK = GetCaloPID()->IsInPi0SplitAsymmetryRange(en,asym,nMax); |
1783 | ||
26680f06 | 1784 | fhNLocMaxM02Cut[0][matched]->Fill(en,nMax); |
1785 | if(IsDataMC()) fhNLocMaxM02Cut[mcindex][matched]->Fill(en,nMax); | |
e671adc2 | 1786 | |
243c2909 | 1787 | if (nMax==1) |
1788 | { | |
2a77f6f4 | 1789 | fhMassNLocMax1[0][matched]->Fill(en,mass ); |
667432ef | 1790 | fhAsymNLocMax1[0][matched]->Fill(en,asym ); |
1791 | ||
1792 | // Effect of cuts in mass histograms | |
1793 | if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched) | |
2a77f6f4 | 1794 | { |
667432ef | 1795 | fhMassSplitECutNLocMax1->Fill(en,mass ); |
1796 | if(m02OK) | |
e671adc2 | 1797 | { |
1798 | fhMassM02CutNLocMax1->Fill(en,mass); | |
77cadd95 | 1799 | fhAsymM02CutNLocMax1->Fill(en,asym ); |
667432ef | 1800 | if(asyOK) fhMassAfterCutsNLocMax1[0]->Fill(en,mass); |
1801 | } // m02 | |
1802 | } // split frac | |
1803 | ||
1804 | if(m02OK && asyOK && !matched) | |
1805 | { | |
1806 | fhSplitEFractionAfterCutsNLocMax1->Fill(en,splitFrac); | |
316212f7 | 1807 | if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0) |
667432ef | 1808 | { |
1809 | fhMCGenFracAfterCutsNLocMax1MCPi0 ->Fill(en , efrac ); | |
1810 | fhMCGenSplitEFracAfterCutsNLocMax1MCPi0->Fill(en , efracSplit); | |
e671adc2 | 1811 | } |
2a77f6f4 | 1812 | } |
26680f06 | 1813 | |
883411b2 | 1814 | if(fFillAngleHisto) |
1815 | { | |
1816 | fhAnglePairLocMax1[matched]->Fill(en,angle); | |
e671adc2 | 1817 | if( en > ecut ) |
5c46c992 | 1818 | fhAnglePairMassLocMax1[matched]->Fill(mass,angle); |
0137016b | 1819 | } |
5c46c992 | 1820 | |
667432ef | 1821 | if(asyOK && m02OK) |
1822 | { | |
167f2534 | 1823 | } |
667432ef | 1824 | |
1825 | if (pidTag==AliCaloPID::kPhoton) { fhM02ConLocMax1[0][matched]->Fill(en,l0); fhMassConLocMax1[0][matched]->Fill(en,mass); fhAsyConLocMax1[0][matched]->Fill(en,asym); } | |
1826 | else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0LocMax1[0][matched]->Fill(en,l0); fhMassPi0LocMax1[0][matched]->Fill(en,mass); fhAsyPi0LocMax1[0][matched]->Fill(en,asym); } | |
e671adc2 | 1827 | else if(pidTag==AliCaloPID::kEta) { fhM02EtaLocMax1[0][matched]->Fill(en,l0); fhMassEtaLocMax1[0][matched]->Fill(en,mass); fhAsyEtaLocMax1[0][matched]->Fill(en,asym); } |
167f2534 | 1828 | } |
5c46c992 | 1829 | else if(nMax==2) |
1830 | { | |
2a77f6f4 | 1831 | fhMassNLocMax2[0][matched]->Fill(en,mass ); |
667432ef | 1832 | fhAsymNLocMax2[0][matched]->Fill(en,asym ); |
1833 | ||
1834 | // Effect of cuts in mass histograms | |
1835 | if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched) | |
2a77f6f4 | 1836 | { |
667432ef | 1837 | fhMassSplitECutNLocMax2->Fill(en,mass ); |
1838 | if(m02OK) | |
e671adc2 | 1839 | { |
1840 | fhMassM02CutNLocMax2->Fill(en,mass); | |
77cadd95 | 1841 | fhAsymM02CutNLocMax2->Fill(en,asym ); |
667432ef | 1842 | if(asyOK) fhMassAfterCutsNLocMax2[0]->Fill(en,mass); |
1843 | } // m02 | |
1844 | } // split frac | |
1845 | ||
1846 | if(m02OK && asyOK && !matched) | |
1847 | { | |
1848 | fhSplitEFractionAfterCutsNLocMax2->Fill(en,splitFrac); | |
316212f7 | 1849 | if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0) |
667432ef | 1850 | { |
1851 | fhMCGenFracAfterCutsNLocMax2MCPi0 ->Fill(en , efrac ); | |
1852 | fhMCGenSplitEFracAfterCutsNLocMax2MCPi0->Fill(en , efracSplit); | |
e671adc2 | 1853 | } |
2a77f6f4 | 1854 | } |
26680f06 | 1855 | |
883411b2 | 1856 | if(fFillAngleHisto) |
0137016b | 1857 | { |
883411b2 | 1858 | fhAnglePairLocMax2[matched]->Fill(en,angle); |
e671adc2 | 1859 | if( en > ecut ) |
883411b2 | 1860 | fhAnglePairMassLocMax2[matched]->Fill(mass,angle); |
0137016b | 1861 | } |
667432ef | 1862 | |
e671adc2 | 1863 | if (pidTag==AliCaloPID::kPhoton) { fhM02ConLocMax2[0][matched]->Fill(en,l0); fhMassConLocMax2[0][matched]->Fill(en,mass); fhAsyConLocMax2[0][matched]->Fill(en,asym); } |
667432ef | 1864 | else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0LocMax2[0][matched]->Fill(en,l0); fhMassPi0LocMax2[0][matched]->Fill(en,mass); fhAsyPi0LocMax2[0][matched]->Fill(en,asym); } |
167f2534 | 1865 | else if(pidTag==AliCaloPID::kEta) { fhM02EtaLocMax2[0][matched]->Fill(en,l0); fhMassEtaLocMax2[0][matched]->Fill(en,mass); fhAsyEtaLocMax2[0][matched]->Fill(en,asym); } |
243c2909 | 1866 | } |
5c46c992 | 1867 | else if(nMax >2) |
1868 | { | |
2a77f6f4 | 1869 | fhMassNLocMaxN[0][matched]->Fill(en,mass); |
667432ef | 1870 | fhAsymNLocMaxN[0][matched]->Fill(en,asym); |
1871 | ||
2a77f6f4 | 1872 | // Effect of cuts in mass histograms |
667432ef | 1873 | if(splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched) |
2a77f6f4 | 1874 | { |
667432ef | 1875 | fhMassSplitECutNLocMaxN->Fill(en,mass ); |
1876 | if(m02OK) | |
e671adc2 | 1877 | { |
1878 | fhMassM02CutNLocMaxN->Fill(en,mass); | |
77cadd95 | 1879 | fhAsymM02CutNLocMaxN->Fill(en,asym ); |
667432ef | 1880 | if(asyOK) fhMassAfterCutsNLocMaxN[0]->Fill(en,mass); |
1881 | } // m02 | |
1882 | } // split frac | |
1883 | ||
1884 | if(m02OK && asyOK && !matched) | |
1885 | { | |
1886 | fhSplitEFractionAfterCutsNLocMaxN->Fill(en,splitFrac); | |
316212f7 | 1887 | if(IsDataMC() && fFillMCFractionHisto && mcindex==kmcPi0) |
667432ef | 1888 | { |
1889 | fhMCGenFracAfterCutsNLocMaxNMCPi0 ->Fill(en , efrac ); | |
1890 | fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0->Fill(en , efracSplit); | |
e671adc2 | 1891 | } |
2a77f6f4 | 1892 | } |
26680f06 | 1893 | |
667432ef | 1894 | if(fFillAngleHisto) |
883411b2 | 1895 | { |
1896 | fhAnglePairLocMaxN[matched]->Fill(en,angle); | |
e671adc2 | 1897 | if( en > ecut ) |
883411b2 | 1898 | fhAnglePairMassLocMaxN[matched]->Fill(mass,angle); |
0137016b | 1899 | } |
667432ef | 1900 | |
e671adc2 | 1901 | if (pidTag==AliCaloPID::kPhoton) { fhM02ConLocMaxN[0][matched]->Fill(en,l0); fhMassConLocMaxN[0][matched]->Fill(en,mass); fhAsyConLocMaxN[0][matched]->Fill(en,asym); } |
667432ef | 1902 | else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0LocMaxN[0][matched]->Fill(en,l0); fhMassPi0LocMaxN[0][matched]->Fill(en,mass); fhAsyPi0LocMaxN[0][matched]->Fill(en,asym); } |
e671adc2 | 1903 | else if(pidTag==AliCaloPID::kEta) { fhM02EtaLocMaxN[0][matched]->Fill(en,l0); fhMassEtaLocMaxN[0][matched]->Fill(en,mass); fhAsyEtaLocMaxN[0][matched]->Fill(en,asym); } |
243c2909 | 1904 | } |
1905 | ||
26680f06 | 1906 | |
3c1d9afb | 1907 | if(IsDataMC()) |
1908 | { | |
243c2909 | 1909 | if (nMax==1) |
1910 | { | |
667432ef | 1911 | fhMassNLocMax1[mcindex][matched]->Fill(en,mass); |
1912 | fhAsymNLocMax1[mcindex][matched]->Fill(en,asym); | |
1913 | ||
1914 | if(asyOK && m02OK && splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched) fhMassAfterCutsNLocMax1[mcindex]->Fill(en,mass); | |
1915 | ||
e671adc2 | 1916 | if (pidTag==AliCaloPID::kPhoton) { fhM02ConLocMax1[mcindex][matched]->Fill(en,l0); fhMassConLocMax1[mcindex][matched]->Fill(en,mass); fhAsyConLocMax1[mcindex][matched]->Fill(en,asym); } |
667432ef | 1917 | else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0LocMax1[mcindex][matched]->Fill(en,l0); fhMassPi0LocMax1[mcindex][matched]->Fill(en,mass); fhAsyPi0LocMax1[mcindex][matched]->Fill(en,asym); } |
1918 | else if(pidTag==AliCaloPID::kEta ) { fhM02EtaLocMax1[mcindex][matched]->Fill(en,l0); fhMassEtaLocMax1[mcindex][matched]->Fill(en,mass); fhAsyEtaLocMax1[mcindex][matched]->Fill(en,asym); } | |
243c2909 | 1919 | } |
0137016b | 1920 | else if(nMax==2) |
1921 | { | |
5c46c992 | 1922 | fhMassNLocMax2[mcindex][matched]->Fill(en,mass); |
667432ef | 1923 | fhAsymNLocMax2[mcindex][matched]->Fill(en,asym); |
1924 | ||
1925 | if(asyOK && m02OK && splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched) fhMassAfterCutsNLocMax2[mcindex]->Fill(en,mass); | |
1926 | ||
e671adc2 | 1927 | if (pidTag==AliCaloPID::kPhoton) { fhM02ConLocMax2[mcindex][matched]->Fill(en,l0); fhMassConLocMax2[mcindex][matched]->Fill(en,mass); fhAsyConLocMax2[mcindex][matched]->Fill(en,asym); } |
667432ef | 1928 | else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0LocMax2[mcindex][matched]->Fill(en,l0); fhMassPi0LocMax2[mcindex][matched]->Fill(en,mass); fhAsyPi0LocMax2[mcindex][matched]->Fill(en,asym); } |
1929 | else if(pidTag==AliCaloPID::kEta ) { fhM02EtaLocMax2[mcindex][matched]->Fill(en,l0); fhMassEtaLocMax2[mcindex][matched]->Fill(en,mass); fhAsyEtaLocMax2[mcindex][matched]->Fill(en,asym); } | |
bb2d339b | 1930 | |
243c2909 | 1931 | } |
0137016b | 1932 | else if(nMax >2) |
1933 | { | |
5c46c992 | 1934 | fhMassNLocMaxN[mcindex][matched]->Fill(en,mass); |
667432ef | 1935 | fhAsymNLocMaxN[mcindex][matched]->Fill(en,asym); |
1936 | ||
1937 | if(asyOK && m02OK && splitFrac > GetCaloPID()->GetSplitEnergyFractionMinimum() && !matched) fhMassAfterCutsNLocMaxN[mcindex]->Fill(en,mass); | |
1938 | ||
e671adc2 | 1939 | if (pidTag==AliCaloPID::kPhoton) { fhM02ConLocMaxN[mcindex][matched]->Fill(en,l0); fhMassConLocMaxN[mcindex][matched]->Fill(en,mass); fhAsyConLocMaxN[mcindex][matched]->Fill(en,asym); } |
667432ef | 1940 | else if(pidTag==AliCaloPID::kPi0 ) { fhM02Pi0LocMaxN[mcindex][matched]->Fill(en,l0); fhMassPi0LocMaxN[mcindex][matched]->Fill(en,mass); fhAsyPi0LocMaxN[mcindex][matched]->Fill(en,asym); } |
1941 | else if(pidTag==AliCaloPID::kEta ) { fhM02EtaLocMaxN[mcindex][matched]->Fill(en,l0); fhMassEtaLocMaxN[mcindex][matched]->Fill(en,mass); fhAsyEtaLocMaxN[mcindex][matched]->Fill(en,asym); } | |
243c2909 | 1942 | } |
992b14a7 | 1943 | |
1944 | }//Work with MC truth first | |
5c46c992 | 1945 | |
992b14a7 | 1946 | }//loop |
1947 | ||
1948 | if(GetDebug() > 1) printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - END \n"); | |
e23a0471 | 1949 | |
992b14a7 | 1950 | } |
1951 | ||
1952 | //______________________________________________________________________ | |
1953 | void AliAnaInsideClusterInvariantMass::Print(const Option_t * opt) const | |
1954 | { | |
1955 | //Print some relevant parameters set for the analysis | |
1956 | if(! opt) | |
1957 | return; | |
1958 | ||
1959 | printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ; | |
745913ae | 1960 | AliAnaCaloTrackCorrBaseClass::Print(""); |
243c2909 | 1961 | printf("Calorimeter = %s\n", fCalorimeter.Data()) ; |
dbba06ca | 1962 | printf("Loc. Max. E > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutE()); |
1963 | printf("Loc. Max. E Diff > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutEDiff()); | |
cfc19369 | 1964 | printf("Min. N Cells =%d \n", fMinNCells) ; |
1965 | printf("Min. Dist. to Bad =%1.1f \n", fMinBadDist) ; | |
71e3889f | 1966 | printf("%2.2f < lambda_0^2 <%2.2f \n",fM02MinCut,fM02MaxCut); |
3c1d9afb | 1967 | |
992b14a7 | 1968 | printf(" \n") ; |
1969 | ||
1970 | } | |
1971 | ||
dbba06ca | 1972 | |
992b14a7 | 1973 |