]>
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), |
3c1d9afb | 57 | fMinNCells(0), fMinBadDist(0) |
992b14a7 | 58 | { |
59 | //default ctor | |
60 | ||
61 | // Init array of histograms | |
5c46c992 | 62 | for(Int_t i = 0; i < 7; i++) |
63 | { | |
64 | for(Int_t j = 0; j < 2; j++) | |
65 | { | |
66 | ||
67 | fhMassNLocMax1[i][j] = 0; | |
68 | fhMassNLocMax2[i][j] = 0; | |
69 | fhMassNLocMaxN[i][j] = 0; | |
70 | fhNLocMax[i][j] = 0; | |
5c46c992 | 71 | fhNLocMaxM02Cut[i][j] = 0; |
72 | fhM02NLocMax1[i][j] = 0; | |
73 | fhM02NLocMax2[i][j] = 0; | |
74 | fhM02NLocMaxN[i][j] = 0; | |
75 | fhNCellNLocMax1[i][j] = 0; | |
76 | fhNCellNLocMax2[i][j] = 0; | |
77 | fhNCellNLocMaxN[i][j] = 0; | |
78 | fhM02Pi0LocMax1[i][j] = 0; | |
79 | fhM02EtaLocMax1[i][j] = 0; | |
80 | fhM02ConLocMax1[i][j] = 0; | |
81 | fhM02Pi0LocMax2[i][j] = 0; | |
82 | fhM02EtaLocMax2[i][j] = 0; | |
83 | fhM02ConLocMax2[i][j] = 0; | |
84 | fhM02Pi0LocMaxN[i][j] = 0; | |
85 | fhM02EtaLocMaxN[i][j] = 0; | |
86 | fhM02ConLocMaxN[i][j] = 0; | |
87 | ||
0137016b | 88 | fhMassM02NLocMax1[i][j]= 0; |
89 | fhMassM02NLocMax2[i][j]= 0; | |
90 | fhMassM02NLocMaxN[i][j]= 0; | |
91 | ||
5c46c992 | 92 | } |
93 | ||
94 | fhTrackMatchedDEtaLocMax1[i] = 0; | |
95 | fhTrackMatchedDPhiLocMax1[i] = 0; | |
96 | fhTrackMatchedDEtaLocMax2[i] = 0; | |
97 | fhTrackMatchedDPhiLocMax2[i] = 0; | |
98 | fhTrackMatchedDEtaLocMaxN[i] = 0; | |
99 | fhTrackMatchedDPhiLocMaxN[i] = 0; | |
243c2909 | 100 | |
992b14a7 | 101 | } |
102 | ||
5c46c992 | 103 | for(Int_t i = 0; i < 2; i++) |
104 | { | |
105 | fhAnglePairLocMax1 [i] = 0; | |
106 | fhAnglePairLocMax2 [i] = 0; | |
107 | fhAnglePairLocMaxN [i] = 0; | |
108 | fhAnglePairMassLocMax1[i] = 0; | |
109 | fhAnglePairMassLocMax2[i] = 0; | |
110 | fhAnglePairMassLocMaxN[i] = 0; | |
111 | } | |
112 | ||
7b686344 | 113 | for(Int_t i = 0; i < 4; i++) |
114 | { | |
115 | fhMassM02NLocMax1Ebin[i] = 0 ; | |
116 | fhMassM02NLocMax2Ebin[i] = 0 ; | |
117 | fhMassM02NLocMaxNEbin[i] = 0 ; | |
118 | } | |
119 | ||
992b14a7 | 120 | InitParameters(); |
121 | ||
122 | } | |
123 | ||
124 | //_______________________________________________________________ | |
125 | TObjString * AliAnaInsideClusterInvariantMass::GetAnalysisCuts() | |
126 | { | |
127 | //Save parameters used for analysis | |
128 | TString parList ; //this will be list of parameters used for this analysis. | |
129 | const Int_t buffersize = 255; | |
130 | char onePar[buffersize] ; | |
131 | ||
132 | snprintf(onePar,buffersize,"--- AliAnaInsideClusterInvariantMass ---\n") ; | |
133 | parList+=onePar ; | |
134 | ||
243c2909 | 135 | snprintf(onePar,buffersize,"Calorimeter: %s\n", fCalorimeter.Data()) ; |
992b14a7 | 136 | parList+=onePar ; |
dbba06ca | 137 | snprintf(onePar,buffersize,"fLocMaxCutE =%2.2f \n", GetCaloUtils()->GetLocalMaximaCutE()) ; |
29ca9cad | 138 | parList+=onePar ; |
dbba06ca | 139 | snprintf(onePar,buffersize,"fLocMaxCutEDiff =%2.2f \n",GetCaloUtils()->GetLocalMaximaCutEDiff()) ; |
29ca9cad | 140 | parList+=onePar ; |
71e3889f | 141 | snprintf(onePar,buffersize,"%2.2f< M02 < %2.2f \n", fM02MinCut, fM02MaxCut) ; |
992b14a7 | 142 | parList+=onePar ; |
e23a0471 | 143 | snprintf(onePar,buffersize,"fMinNCells =%d \n", fMinNCells) ; |
2cb134fb | 144 | parList+=onePar ; |
3c1d9afb | 145 | snprintf(onePar,buffersize,"fMinBadDist =%1.1f \n", fMinBadDist) ; |
992b14a7 | 146 | parList+=onePar ; |
243c2909 | 147 | |
992b14a7 | 148 | return new TObjString(parList) ; |
149 | ||
150 | } | |
151 | ||
992b14a7 | 152 | //________________________________________________________________ |
153 | TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects() | |
154 | { | |
155 | // Create histograms to be saved in output file and | |
156 | // store them in outputContainer | |
157 | TList * outputContainer = new TList() ; | |
158 | outputContainer->SetName("InsideClusterHistos") ; | |
159 | ||
745913ae | 160 | Int_t nptbins = GetHistogramRanges()->GetHistoPtBins(); Float_t ptmax = GetHistogramRanges()->GetHistoPtMax(); Float_t ptmin = GetHistogramRanges()->GetHistoPtMin(); |
161 | Int_t ssbins = GetHistogramRanges()->GetHistoShowerShapeBins(); Float_t ssmax = GetHistogramRanges()->GetHistoShowerShapeMax(); Float_t ssmin = GetHistogramRanges()->GetHistoShowerShapeMin(); | |
162 | Int_t mbins = GetHistogramRanges()->GetHistoMassBins(); Float_t mmax = GetHistogramRanges()->GetHistoMassMax(); Float_t mmin = GetHistogramRanges()->GetHistoMassMin(); | |
163 | Int_t ncbins = GetHistogramRanges()->GetHistoNClusterCellBins(); Int_t ncmax = GetHistogramRanges()->GetHistoNClusterCellMax(); Int_t ncmin = GetHistogramRanges()->GetHistoNClusterCellMin(); | |
992b14a7 | 164 | |
5c46c992 | 165 | Int_t nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins(); |
166 | Float_t resetamax = GetHistogramRanges()->GetHistoTrackResidualEtaMax(); | |
167 | Float_t resetamin = GetHistogramRanges()->GetHistoTrackResidualEtaMin(); | |
168 | Int_t nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins(); | |
169 | Float_t resphimax = GetHistogramRanges()->GetHistoTrackResidualPhiMax(); | |
170 | Float_t resphimin = GetHistogramRanges()->GetHistoTrackResidualPhiMin(); | |
171 | ||
992b14a7 | 172 | TString ptype[] ={"","#gamma","#gamma->e^{#pm}","#pi^{0}","#eta","e^{#pm}", "hadron"}; |
173 | TString pname[] ={"","Photon","Conversion", "Pi0", "Eta", "Electron","Hadron"}; | |
174 | ||
175 | Int_t n = 1; | |
176 | ||
177 | if(IsDataMC()) n = 7; | |
178 | ||
243c2909 | 179 | Int_t nMaxBins = 10; |
180 | ||
5c46c992 | 181 | TString sMatched[] = {"","Matched"}; |
182 | ||
183 | for(Int_t i = 0; i < n; i++) | |
184 | { | |
185 | ||
186 | for(Int_t j = 0; j < 2; j++) | |
187 | { | |
188 | ||
189 | fhMassNLocMax1[i][j] = new TH2F(Form("hMassNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
0137016b | 190 | Form("Invariant mass of 2 highest energy cells vs E, %s %s",ptype[i].Data(),sMatched[j].Data()), |
5c46c992 | 191 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
192 | fhMassNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})"); | |
193 | fhMassNLocMax1[i][j]->SetXTitle("E (GeV)"); | |
194 | outputContainer->Add(fhMassNLocMax1[i][j]) ; | |
195 | ||
196 | fhMassNLocMax2[i][j] = new TH2F(Form("hMassNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
0137016b | 197 | Form("Invariant mass of 2 local maxima cells vs E,%s %s",ptype[i].Data(),sMatched[j].Data()), |
5c46c992 | 198 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
199 | fhMassNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})"); | |
200 | fhMassNLocMax2[i][j]->SetXTitle("E (GeV)"); | |
201 | outputContainer->Add(fhMassNLocMax2[i][j]) ; | |
202 | ||
203 | fhMassNLocMaxN[i][j] = new TH2F(Form("hMassNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
0137016b | 204 | Form("Invariant mass of N>2 local maxima cells vs E, %s %s",ptype[i].Data(),sMatched[j].Data()), |
5c46c992 | 205 | nptbins,ptmin,ptmax,mbins,mmin,mmax); |
206 | fhMassNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})"); | |
207 | fhMassNLocMaxN[i][j]->SetXTitle("E (GeV)"); | |
208 | outputContainer->Add(fhMassNLocMaxN[i][j]) ; | |
209 | ||
0137016b | 210 | fhMassM02NLocMax1[i][j] = new TH2F(Form("hMassM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), |
211 | Form("Invariant mass of 2 highest energy cells #lambda_{0}^{2}, E > 7 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()), | |
212 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
213 | fhMassM02NLocMax1[i][j]->SetYTitle("M (GeV/c^{2})"); | |
214 | fhMassM02NLocMax1[i][j]->SetXTitle("#lambda_{0}^{2}"); | |
215 | outputContainer->Add(fhMassM02NLocMax1[i][j]) ; | |
216 | ||
217 | fhMassM02NLocMax2[i][j] = new TH2F(Form("hMassM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
218 | Form("Invariant mass of 2 local maxima cells #lambda_{0}^{2}, E > 7 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()), | |
219 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
220 | fhMassM02NLocMax2[i][j]->SetYTitle("M (GeV/c^{2})"); | |
221 | fhMassM02NLocMax2[i][j]->SetXTitle("#lambda_{0}^{2}"); | |
222 | outputContainer->Add(fhMassM02NLocMax2[i][j]) ; | |
223 | ||
224 | fhMassM02NLocMaxN[i][j] = new TH2F(Form("hMassM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
225 | Form("Invariant mass of N>2 local maxima cells vs #lambda_{0}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()), | |
226 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
227 | fhMassM02NLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})"); | |
228 | fhMassM02NLocMaxN[i][j]->SetXTitle("#lambda_{0}^{2}"); | |
229 | outputContainer->Add(fhMassM02NLocMaxN[i][j]) ; | |
230 | ||
5c46c992 | 231 | |
232 | fhNLocMax[i][j] = new TH2F(Form("hNLocMax%s%s",pname[i].Data(),sMatched[j].Data()), | |
233 | Form("Number of local maxima in cluster %s %s",ptype[i].Data(),sMatched[j].Data()), | |
234 | nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins); | |
235 | fhNLocMax[i][j] ->SetYTitle("N maxima"); | |
236 | fhNLocMax[i][j] ->SetXTitle("E (GeV)"); | |
237 | outputContainer->Add(fhNLocMax[i][j]) ; | |
3c1d9afb | 238 | |
5c46c992 | 239 | fhNLocMaxM02Cut[i][j] = new TH2F(Form("hNLocMaxM02Cut%s%s",pname[i].Data(),sMatched[j].Data()), |
71e3889f | 240 | Form("Number of local maxima in cluster %s for %2.2f < M02 < %2.2f",ptype[i].Data(),fM02MinCut,fM02MaxCut), |
5c46c992 | 241 | nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins); |
242 | fhNLocMaxM02Cut[i][j]->SetYTitle("N maxima"); | |
243 | fhNLocMaxM02Cut[i][j]->SetXTitle("E (GeV)"); | |
244 | outputContainer->Add(fhNLocMaxM02Cut[i][j]) ; | |
245 | ||
246 | ||
247 | fhM02NLocMax1[i][j] = new TH2F(Form("hM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
248 | Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
249 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); | |
250 | fhM02NLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
251 | fhM02NLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
252 | outputContainer->Add(fhM02NLocMax1[i][j]) ; | |
253 | ||
254 | fhM02NLocMax2[i][j] = new TH2F(Form("hM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
255 | Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
256 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); | |
257 | fhM02NLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
258 | fhM02NLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
259 | outputContainer->Add(fhM02NLocMax2[i][j]) ; | |
260 | ||
261 | ||
262 | fhM02NLocMaxN[i][j] = new TH2F(Form("hM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
263 | Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
264 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); | |
265 | fhM02NLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
266 | fhM02NLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
267 | outputContainer->Add(fhM02NLocMaxN[i][j]) ; | |
268 | ||
269 | ||
270 | fhNCellNLocMax1[i][j] = new TH2F(Form("hNCellNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
271 | Form("#lambda_{0}^{2} vs E for N max = 1 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
272 | nptbins,ptmin,ptmax,ncbins,ncmin,ncmax); | |
273 | fhNCellNLocMax1[i][j] ->SetYTitle("N cells"); | |
274 | fhNCellNLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
275 | outputContainer->Add(fhNCellNLocMax1[i][j]) ; | |
276 | ||
277 | fhNCellNLocMax2[i][j] = new TH2F(Form("hNCellNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
278 | Form("#lambda_{0}^{2} vs E for N max = 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
279 | nptbins,ptmin,ptmax,ncbins,ncmin,ncmax); | |
280 | fhNCellNLocMax2[i][j] ->SetYTitle("N cells"); | |
281 | fhNCellNLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
282 | outputContainer->Add(fhNCellNLocMax2[i][j]) ; | |
283 | ||
284 | ||
285 | fhNCellNLocMaxN[i][j] = new TH2F(Form("hNCellNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
286 | Form("#lambda_{0}^{2} vs E for N max > 2 %s %s",ptype[i].Data(),sMatched[j].Data()), | |
287 | nptbins,ptmin,ptmax,ncbins,ncmin,ncmax); | |
288 | fhNCellNLocMaxN[i][j] ->SetYTitle("N cells"); | |
289 | fhNCellNLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
290 | outputContainer->Add(fhNCellNLocMaxN[i][j]) ; | |
291 | ||
292 | ||
293 | fhM02Pi0LocMax1[i][j] = new TH2F(Form("hM02Pi0LocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 294 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 1", |
295 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
5c46c992 | 296 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
297 | fhM02Pi0LocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
298 | fhM02Pi0LocMax1[i][j] ->SetXTitle("E (GeV)"); | |
299 | outputContainer->Add(fhM02Pi0LocMax1[i][j]) ; | |
300 | ||
301 | fhM02EtaLocMax1[i][j] = new TH2F(Form("hM02EtaLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 302 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1", |
303 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
5c46c992 | 304 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
305 | fhM02EtaLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
306 | fhM02EtaLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
307 | outputContainer->Add(fhM02EtaLocMax1[i][j]) ; | |
308 | ||
309 | fhM02ConLocMax1[i][j] = new TH2F(Form("hM02ConLocMax1%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 310 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 1", |
311 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
5c46c992 | 312 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
313 | fhM02ConLocMax1[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
314 | fhM02ConLocMax1[i][j] ->SetXTitle("E (GeV)"); | |
315 | outputContainer->Add(fhM02ConLocMax1[i][j]) ; | |
316 | ||
317 | fhM02Pi0LocMax2[i][j] = new TH2F(Form("hM02Pi0LocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 318 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max = 2", |
319 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
5c46c992 | 320 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
321 | fhM02Pi0LocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
322 | fhM02Pi0LocMax2[i][j] ->SetXTitle("E (GeV)"); | |
323 | outputContainer->Add(fhM02Pi0LocMax2[i][j]) ; | |
324 | ||
325 | fhM02EtaLocMax2[i][j] = new TH2F(Form("hM02EtaLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 326 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2", |
327 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
5c46c992 | 328 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
329 | fhM02EtaLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
330 | fhM02EtaLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
331 | outputContainer->Add(fhM02EtaLocMax2[i][j]) ; | |
332 | ||
333 | fhM02ConLocMax2[i][j] = new TH2F(Form("hM02ConLocMax2%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 334 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max = 2", |
335 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
5c46c992 | 336 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
337 | fhM02ConLocMax2[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
338 | fhM02ConLocMax2[i][j] ->SetXTitle("E (GeV)"); | |
339 | outputContainer->Add(fhM02ConLocMax2[i][j]) ; | |
340 | ||
341 | fhM02Pi0LocMaxN[i][j] = new TH2F(Form("hM02Pi0LocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 342 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2} %s, for N Local max > 2", |
343 | GetCaloPID()->GetPi0MinMass(),GetCaloPID()->GetPi0MaxMass(),ptype[i].Data()), | |
5c46c992 | 344 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
345 | fhM02Pi0LocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
346 | fhM02Pi0LocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
347 | outputContainer->Add(fhM02Pi0LocMaxN[i][j]) ; | |
348 | ||
349 | fhM02EtaLocMaxN[i][j] = new TH2F(Form("hM02EtaLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 350 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f] MeV/c^{2}, %s, for N Local max > 2", |
351 | GetCaloPID()->GetEtaMinMass(),GetCaloPID()->GetEtaMaxMass(),ptype[i].Data()), | |
5c46c992 | 352 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
353 | fhM02EtaLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
354 | fhM02EtaLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
355 | outputContainer->Add(fhM02EtaLocMaxN[i][j]) ; | |
356 | ||
357 | fhM02ConLocMaxN[i][j] = new TH2F(Form("hM02ConLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()), | |
3c1d9afb | 358 | Form("#lambda_{0}^{2} vs E for mass range [%2.2f-%2.2f], %s, for N Local max > 2", |
359 | GetCaloPID()->GetPhotonMinMass(),GetCaloPID()->GetPhotonMaxMass(),ptype[i].Data()), | |
5c46c992 | 360 | nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); |
361 | fhM02ConLocMaxN[i][j] ->SetYTitle("#lambda_{0}^{2}"); | |
362 | fhM02ConLocMaxN[i][j] ->SetXTitle("E (GeV)"); | |
363 | outputContainer->Add(fhM02ConLocMaxN[i][j]) ; | |
364 | ||
365 | } // matched, not matched | |
366 | ||
7b686344 | 367 | |
5c46c992 | 368 | } // MC particle list |
369 | ||
7b686344 | 370 | for(Int_t i = 0; i < 4; i++) |
371 | { | |
372 | fhMassM02NLocMax1Ebin[i] = new TH2F(Form("hMassM02NLocMax1Ebin%d",i), | |
373 | Form("Invariant mass of 2 highest energy cells #lambda_{0}^{2}, E bin %d",i), | |
374 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
375 | fhMassM02NLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
376 | fhMassM02NLocMax1Ebin[i]->SetXTitle("#lambda_{0}^{2}"); | |
377 | outputContainer->Add(fhMassM02NLocMax1Ebin[i]) ; | |
378 | ||
379 | fhMassM02NLocMax2Ebin[i] = new TH2F(Form("hMassM02NLocMax2Ebin%d",i), | |
380 | Form("Invariant mass of 2 local maxima cells #lambda_{0}^{2}, E bin %d",i), | |
381 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
382 | fhMassM02NLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})"); | |
383 | fhMassM02NLocMax2Ebin[i]->SetXTitle("#lambda_{0}^{2}"); | |
384 | outputContainer->Add(fhMassM02NLocMax2Ebin[i]) ; | |
385 | ||
386 | fhMassM02NLocMaxNEbin[i] = new TH2F(Form("hMassM02NLocMaxNEbin%d",i), | |
387 | Form("Invariant mass of N>2 local maxima cells vs #lambda_{0}^{2}, E bin %d",i), | |
388 | ssbins,ssmin,ssmax,mbins,mmin,mmax); | |
389 | fhMassM02NLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})"); | |
390 | fhMassM02NLocMaxNEbin[i]->SetXTitle("#lambda_{0}^{2}"); | |
391 | outputContainer->Add(fhMassM02NLocMaxNEbin[i]) ; | |
392 | } | |
393 | ||
5c46c992 | 394 | for(Int_t i = 0; i < n; i++) |
395 | { | |
396 | fhTrackMatchedDEtaLocMax1[i] = new TH2F | |
397 | (Form("hTrackMatchedDEtaLocMax1%s",pname[i].Data()), | |
398 | Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()), | |
399 | nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax); | |
400 | fhTrackMatchedDEtaLocMax1[i]->SetYTitle("d#eta"); | |
401 | fhTrackMatchedDEtaLocMax1[i]->SetXTitle("E_{cluster} (GeV)"); | |
402 | ||
403 | fhTrackMatchedDPhiLocMax1[i] = new TH2F | |
404 | (Form("hTrackMatchedDPhiLocMax1%s",pname[i].Data()), | |
405 | Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()), | |
406 | nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax); | |
407 | fhTrackMatchedDPhiLocMax1[i]->SetYTitle("d#phi (rad)"); | |
408 | fhTrackMatchedDPhiLocMax1[i]->SetXTitle("E_{cluster} (GeV)"); | |
409 | ||
410 | outputContainer->Add(fhTrackMatchedDEtaLocMax1[i]) ; | |
411 | outputContainer->Add(fhTrackMatchedDPhiLocMax1[i]) ; | |
412 | ||
413 | fhTrackMatchedDEtaLocMax2[i] = new TH2F | |
414 | (Form("hTrackMatchedDEtaLocMax2%s",pname[i].Data()), | |
415 | Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()), | |
416 | nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax); | |
417 | fhTrackMatchedDEtaLocMax2[i]->SetYTitle("d#eta"); | |
418 | fhTrackMatchedDEtaLocMax2[i]->SetXTitle("E_{cluster} (GeV)"); | |
419 | ||
420 | fhTrackMatchedDPhiLocMax2[i] = new TH2F | |
421 | (Form("hTrackMatchedDPhiLocMax2%s",pname[i].Data()), | |
422 | Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()), | |
423 | nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax); | |
424 | fhTrackMatchedDPhiLocMax2[i]->SetYTitle("d#phi (rad)"); | |
425 | fhTrackMatchedDPhiLocMax2[i]->SetXTitle("E_{cluster} (GeV)"); | |
426 | ||
427 | outputContainer->Add(fhTrackMatchedDEtaLocMax2[i]) ; | |
428 | outputContainer->Add(fhTrackMatchedDPhiLocMax2[i]) ; | |
429 | ||
430 | fhTrackMatchedDEtaLocMaxN[i] = new TH2F | |
431 | (Form("hTrackMatchedDEtaLocMaxN%s",pname[i].Data()), | |
432 | Form("d#eta of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()), | |
433 | nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax); | |
434 | fhTrackMatchedDEtaLocMaxN[i]->SetYTitle("d#eta"); | |
435 | fhTrackMatchedDEtaLocMaxN[i]->SetXTitle("E_{cluster} (GeV)"); | |
436 | ||
437 | fhTrackMatchedDPhiLocMaxN[i] = new TH2F | |
438 | (Form("hTrackMatchedDPhiLocMaxN%s",pname[i].Data()), | |
439 | Form("d#phi of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()), | |
440 | nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax); | |
441 | fhTrackMatchedDPhiLocMaxN[i]->SetYTitle("d#phi (rad)"); | |
442 | fhTrackMatchedDPhiLocMaxN[i]->SetXTitle("E_{cluster} (GeV)"); | |
443 | ||
444 | outputContainer->Add(fhTrackMatchedDEtaLocMaxN[i]) ; | |
445 | outputContainer->Add(fhTrackMatchedDPhiLocMaxN[i]) ; | |
446 | ||
447 | } | |
448 | ||
449 | for(Int_t j = 0; j < 2; j++) | |
450 | { | |
451 | ||
452 | fhAnglePairLocMax1[j] = new TH2F(Form("hAnglePairLocMax1%s",sMatched[j].Data()), | |
453 | Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()), | |
454 | nptbins,ptmin,ptmax,200,0,0.2); | |
455 | fhAnglePairLocMax1[j]->SetYTitle("#alpha (rad)"); | |
456 | fhAnglePairLocMax1[j]->SetXTitle("E (GeV)"); | |
457 | outputContainer->Add(fhAnglePairLocMax1[j]) ; | |
458 | ||
459 | fhAnglePairLocMax2[j] = new TH2F(Form("hAnglePairLocMax2%s",sMatched[j].Data()), | |
460 | Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()), | |
461 | nptbins,ptmin,ptmax,200,0,0.2); | |
462 | fhAnglePairLocMax2[j]->SetYTitle("#alpha (rad)"); | |
463 | fhAnglePairLocMax2[j]->SetXTitle("E (GeV)"); | |
464 | outputContainer->Add(fhAnglePairLocMax2[j]) ; | |
465 | ||
466 | fhAnglePairLocMaxN[j] = new TH2F(Form("hAnglePairLocMaxN%s",sMatched[j].Data()), | |
467 | Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()), | |
468 | nptbins,ptmin,ptmax,200,0,0.2); | |
469 | fhAnglePairLocMaxN[j]->SetYTitle("#alpha (rad)"); | |
470 | fhAnglePairLocMaxN[j]->SetXTitle("E (GeV)"); | |
471 | outputContainer->Add(fhAnglePairLocMaxN[j]) ; | |
472 | ||
473 | fhAnglePairMassLocMax1[j] = new TH2F(Form("hAnglePairMassLocMax1%s",sMatched[j].Data()), | |
0137016b | 474 | Form("Opening angle of 2 highest energy cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()), |
5c46c992 | 475 | mbins,mmin,mmax,200,0,0.2); |
476 | fhAnglePairMassLocMax1[j]->SetXTitle("M (GeV/c^{2})"); | |
477 | fhAnglePairMassLocMax1[j]->SetYTitle("#alpha (rad)"); | |
478 | outputContainer->Add(fhAnglePairMassLocMax1[j]) ; | |
479 | ||
480 | fhAnglePairMassLocMax2[j] = new TH2F(Form("hAnglePairMassLocMax2%s",sMatched[j].Data()), | |
0137016b | 481 | Form("Opening angle of 2 local maxima cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()), |
5c46c992 | 482 | mbins,mmin,mmax,200,0,0.2); |
483 | fhAnglePairMassLocMax2[j]->SetXTitle("M (GeV/c^{2})"); | |
484 | fhAnglePairMassLocMax2[j]->SetYTitle("#alpha (rad)"); | |
485 | outputContainer->Add(fhAnglePairMassLocMax2[j]) ; | |
486 | ||
487 | fhAnglePairMassLocMaxN[j] = new TH2F(Form("hAnglePairMassLocMaxN%s",sMatched[j].Data()), | |
0137016b | 488 | Form("Opening angle of N>2 local maxima cells vs Mass for E > 7 GeV, %s",sMatched[j].Data()), |
5c46c992 | 489 | mbins,mmin,mmax,200,0,0.2); |
490 | fhAnglePairMassLocMaxN[j]->SetXTitle("M (GeV/c^{2})"); | |
491 | fhAnglePairMassLocMaxN[j]->SetYTitle("#alpha (rad)"); | |
492 | outputContainer->Add(fhAnglePairMassLocMaxN[j]) ; | |
992b14a7 | 493 | |
494 | } | |
495 | ||
496 | return outputContainer ; | |
497 | ||
498 | } | |
499 | ||
992b14a7 | 500 | //___________________________________________ |
501 | void AliAnaInsideClusterInvariantMass::Init() | |
502 | { | |
503 | //Init | |
504 | //Do some checks | |
3c1d9afb | 505 | if(fCalorimeter == "PHOS" && !GetReader()->IsPHOSSwitchedOn() && NewOutputAOD()) |
506 | { | |
992b14a7 | 507 | printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!\n"); |
508 | abort(); | |
509 | } | |
3c1d9afb | 510 | else if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn() && NewOutputAOD()) |
511 | { | |
992b14a7 | 512 | printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!\n"); |
513 | abort(); | |
514 | } | |
515 | ||
3c1d9afb | 516 | if( GetReader()->GetDataType() == AliCaloTrackReader::kMC ) |
517 | { | |
992b14a7 | 518 | printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use pure MC data!!\n"); |
519 | abort(); | |
520 | ||
521 | } | |
522 | ||
523 | } | |
524 | ||
525 | //_____________________________________________________ | |
526 | void AliAnaInsideClusterInvariantMass::InitParameters() | |
527 | { | |
528 | //Initialize the parameters of the analysis. | |
529 | AddToHistogramsName("AnaPi0InsideClusterInvariantMass_"); | |
530 | ||
531 | fCalorimeter = "EMCAL" ; | |
29ca9cad | 532 | |
71e3889f | 533 | fM02MinCut = 0.26 ; |
534 | fM02MaxCut = 10 ; | |
535 | ||
992b14a7 | 536 | fMinNCells = 4 ; |
2cb134fb | 537 | fMinBadDist = 2 ; |
3c1d9afb | 538 | |
992b14a7 | 539 | } |
540 | ||
541 | ||
542 | //__________________________________________________________________ | |
543 | void AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() | |
544 | { | |
545 | //Search for pi0 in fCalorimeter with shower shape analysis | |
546 | ||
547 | TObjArray * pl = 0x0; | |
548 | AliVCaloCells* cells = 0x0; | |
549 | ||
550 | //Select the Calorimeter of the photon | |
2cb134fb | 551 | if(fCalorimeter == "PHOS") |
552 | { | |
992b14a7 | 553 | pl = GetPHOSClusters(); |
554 | cells = GetPHOSCells(); | |
555 | } | |
2cb134fb | 556 | else if (fCalorimeter == "EMCAL") |
557 | { | |
992b14a7 | 558 | pl = GetEMCALClusters(); |
559 | cells = GetEMCALCells(); | |
560 | } | |
561 | ||
3c1d9afb | 562 | if(!pl || !cells) |
563 | { | |
992b14a7 | 564 | Info("MakeAnalysisFillHistograms","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data()); |
565 | return; | |
566 | } | |
567 | ||
568 | if(fCalorimeter == "PHOS") return; // Not implemented for PHOS yet | |
569 | ||
2cb134fb | 570 | for(Int_t icluster = 0; icluster < pl->GetEntriesFast(); icluster++) |
571 | { | |
992b14a7 | 572 | AliVCluster * cluster = (AliVCluster*) (pl->At(icluster)); |
573 | ||
574 | // Study clusters with large shape parameter | |
575 | Float_t en = cluster->E(); | |
576 | Float_t l0 = cluster->GetM02(); | |
577 | Int_t nc = cluster->GetNCells(); | |
2cb134fb | 578 | Float_t bd = cluster->GetDistanceToBadChannel() ; |
243c2909 | 579 | |
2cb134fb | 580 | //If too small or big E or low number of cells, or close to a bad channel skip it |
581 | if( en < GetMinEnergy() || en > GetMaxEnergy() || nc < fMinNCells || bd < fMinBadDist) continue ; | |
582 | ||
583 | //printf("en %2.2f, GetMinEnergy() %2.2f, GetMaxEnergy() %2.2f, nc %d, fMinNCells %d, bd %2.2f, fMinBadDist %2.2f\n", | |
584 | // en,GetMinEnergy(), GetMaxEnergy(), nc, fMinNCells, bd, fMinBadDist); | |
585 | ||
3c1d9afb | 586 | |
587 | Int_t nMax = 0; | |
588 | Double_t mass = 0; | |
589 | Double_t angle= 0; | |
590 | Int_t pidTag = GetCaloPID()->GetIdentifiedParticleTypeFromClusterSplitting(cluster,cells,GetCaloUtils(), | |
591 | GetVertex(0), nMax, mass, angle); | |
592 | ||
5c46c992 | 593 | if (nMax <= 0) |
594 | { | |
de454976 | 595 | if(GetDebug() > 0 ) |
596 | printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - No local maximum found! It did not pass CaloPID selection criteria \n"); | |
5c46c992 | 597 | |
992b14a7 | 598 | return; |
599 | } | |
600 | ||
3c1d9afb | 601 | Bool_t matched = IsTrackMatched(cluster,GetReader()->GetInputEvent()); |
cfc19369 | 602 | |
3c1d9afb | 603 | fhNLocMax[0][matched]->Fill(en,nMax); |
29ca9cad | 604 | |
5c46c992 | 605 | if ( nMax == 1 ) { fhM02NLocMax1[0][matched]->Fill(en,l0) ; fhNCellNLocMax1[0][matched]->Fill(en,nc) ; } |
606 | else if( nMax == 2 ) { fhM02NLocMax2[0][matched]->Fill(en,l0) ; fhNCellNLocMax2[0][matched]->Fill(en,nc) ; } | |
607 | else if( nMax >= 3 ) { fhM02NLocMaxN[0][matched]->Fill(en,l0) ; fhNCellNLocMaxN[0][matched]->Fill(en,nc) ; } | |
992b14a7 | 608 | else printf("N max smaller than 1 -> %d \n",nMax); |
5c46c992 | 609 | |
610 | Float_t dZ = cluster->GetTrackDz(); | |
611 | Float_t dR = cluster->GetTrackDx(); | |
612 | ||
613 | if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn()) | |
614 | { | |
615 | dR = 2000., dZ = 2000.; | |
616 | GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR); | |
617 | } | |
618 | //printf("Pi0EbE: dPhi %f, dEta %f\n",dR,dZ); | |
619 | ||
620 | if(TMath::Abs(dR) < 999) | |
621 | { | |
622 | if ( nMax == 1 ) { fhTrackMatchedDEtaLocMax1[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMax1[0]->Fill(en,dR); } | |
623 | else if( nMax == 2 ) { fhTrackMatchedDEtaLocMax2[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMax2[0]->Fill(en,dR); } | |
624 | else if( nMax >= 3 ) { fhTrackMatchedDEtaLocMaxN[0]->Fill(en,dZ); fhTrackMatchedDPhiLocMaxN[0]->Fill(en,dR); } | |
625 | } | |
992b14a7 | 626 | |
627 | // Play with the MC stack if available | |
628 | // Check origin of the candidates | |
629 | Int_t mcindex = -1; | |
3c1d9afb | 630 | if(IsDataMC()) |
631 | { | |
992b14a7 | 632 | Int_t tag = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(), GetReader(), 0); |
633 | ||
c5693f62 | 634 | if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) ) mcindex = kmcPi0; |
635 | else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta) ) mcindex = kmcEta; | |
992b14a7 | 636 | else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && |
c5693f62 | 637 | !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPhoton; |
992b14a7 | 638 | else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) && |
c5693f62 | 639 | GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcConversion; |
640 | else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) mcindex = kmcElectron; | |
641 | else mcindex = kmcHadron; | |
71e3889f | 642 | |
5c46c992 | 643 | fhNLocMax[mcindex][matched]->Fill(en,nMax); |
3c1d9afb | 644 | |
5c46c992 | 645 | if (nMax == 1 ) { fhM02NLocMax1[mcindex][matched]->Fill(en,l0) ; fhNCellNLocMax1[mcindex][matched]->Fill(en,nc) ; } |
646 | else if(nMax == 2 ) { fhM02NLocMax2[mcindex][matched]->Fill(en,l0) ; fhNCellNLocMax2[mcindex][matched]->Fill(en,nc) ; } | |
647 | else if(nMax >= 3 ) { fhM02NLocMaxN[mcindex][matched]->Fill(en,l0) ; fhNCellNLocMaxN[mcindex][matched]->Fill(en,nc) ; } | |
648 | ||
649 | if(TMath::Abs(dR) < 999) | |
650 | { | |
651 | if ( nMax == 1 ) { fhTrackMatchedDEtaLocMax1[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMax1[mcindex]->Fill(en,dR); } | |
652 | else if( nMax == 2 ) { fhTrackMatchedDEtaLocMax2[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMax2[mcindex]->Fill(en,dR); } | |
653 | else if( nMax >= 3 ) { fhTrackMatchedDEtaLocMaxN[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiLocMaxN[mcindex]->Fill(en,dR); } | |
29ca9cad | 654 | } |
992b14a7 | 655 | |
656 | } | |
5c46c992 | 657 | |
26680f06 | 658 | if (nMax==1) |
659 | { | |
660 | if( en > 7 ) | |
661 | { | |
662 | fhMassM02NLocMax1[0] [matched]->Fill(l0, mass ); | |
a700f620 | 663 | if(IsDataMC()) |
664 | fhMassM02NLocMax1[mcindex][matched]->Fill(l0, mass ); | |
26680f06 | 665 | } |
666 | ||
667 | if(!matched) | |
668 | { | |
669 | if(en > 6 && en <= 10) fhMassM02NLocMax1Ebin[0]->Fill(l0, mass ); | |
670 | if(en > 10 && en <= 15) fhMassM02NLocMax1Ebin[1]->Fill(l0, mass ); | |
671 | if(en > 15 && en <= 20) fhMassM02NLocMax1Ebin[2]->Fill(l0, mass ); | |
672 | if(en > 20) fhMassM02NLocMax1Ebin[3]->Fill(l0, mass ); | |
673 | } | |
674 | } | |
675 | else if(nMax==2) | |
676 | { | |
677 | if( en > 7 ) | |
678 | { | |
679 | fhMassM02NLocMax2[0][matched] ->Fill(l0, mass ); | |
a700f620 | 680 | if(IsDataMC()) |
681 | fhMassM02NLocMax2[mcindex][matched]->Fill(l0, mass ); | |
26680f06 | 682 | } |
683 | ||
684 | if(!matched) | |
685 | { | |
686 | if(en > 6 && en <= 10) fhMassM02NLocMax2Ebin[0]->Fill(l0, mass ); | |
687 | if(en > 10 && en <= 15) fhMassM02NLocMax2Ebin[1]->Fill(l0, mass ); | |
688 | if(en > 15 && en <= 20) fhMassM02NLocMax2Ebin[2]->Fill(l0, mass ); | |
689 | if(en > 20) fhMassM02NLocMax2Ebin[3]->Fill(l0, mass ); | |
690 | } | |
691 | } | |
692 | else if(nMax >2) | |
693 | { | |
694 | if( en > 7 ) | |
695 | { | |
696 | fhMassM02NLocMaxN[0] [matched]->Fill(l0 ,mass ); | |
a700f620 | 697 | if(IsDataMC()) |
698 | fhMassM02NLocMaxN[mcindex][matched]->Fill(l0, mass ); | |
26680f06 | 699 | } |
700 | ||
701 | if(!matched) | |
702 | { | |
703 | if(en > 6 && en <= 10) fhMassM02NLocMaxNEbin[0]->Fill(l0, mass ); | |
704 | if(en > 10 && en <= 15) fhMassM02NLocMaxNEbin[1]->Fill(l0, mass ); | |
705 | if(en > 15 && en <= 20) fhMassM02NLocMaxNEbin[2]->Fill(l0, mass ); | |
706 | if(en > 20) fhMassM02NLocMaxNEbin[3]->Fill(l0, mass ); | |
707 | } | |
708 | } | |
709 | ||
26680f06 | 710 | //--------------------------------------------------------------------- |
711 | // From here only if M02 is large but not too large, fill histograms | |
712 | //--------------------------------------------------------------------- | |
713 | ||
3c1d9afb | 714 | if( l0 < fM02MinCut || l0 > fM02MaxCut ) continue ; |
26680f06 | 715 | |
716 | fhNLocMaxM02Cut[0][matched]->Fill(en,nMax); | |
717 | if(IsDataMC()) fhNLocMaxM02Cut[mcindex][matched]->Fill(en,nMax); | |
718 | ||
243c2909 | 719 | if (nMax==1) |
720 | { | |
5c46c992 | 721 | fhAnglePairLocMax1[matched]->Fill(en,angle); |
0137016b | 722 | fhMassNLocMax1[0][matched] ->Fill(en,mass ); |
26680f06 | 723 | |
0137016b | 724 | if( en > 7 ) |
725 | { | |
5c46c992 | 726 | fhAnglePairMassLocMax1[matched]->Fill(mass,angle); |
0137016b | 727 | } |
5c46c992 | 728 | |
3c1d9afb | 729 | if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax1[0][matched]->Fill(en,l0); |
730 | else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMax1[0][matched]->Fill(en,l0); | |
731 | else if(pidTag==AliCaloPID::kEta) fhM02EtaLocMax1[0][matched]->Fill(en,l0); | |
243c2909 | 732 | } |
5c46c992 | 733 | else if(nMax==2) |
734 | { | |
735 | fhAnglePairLocMax2[matched]->Fill(en,angle); | |
0137016b | 736 | fhMassNLocMax2[0] [matched]->Fill(en,mass ); |
26680f06 | 737 | |
0137016b | 738 | if( en > 7 ) |
739 | { | |
26680f06 | 740 | fhAnglePairMassLocMax2[matched]->Fill(mass,angle); |
0137016b | 741 | } |
5c46c992 | 742 | |
3c1d9afb | 743 | if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax2[0][matched]->Fill(en,l0); |
744 | else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMax2[0][matched]->Fill(en,l0); | |
745 | else if(pidTag==AliCaloPID::kEta) fhM02EtaLocMax2[0][matched]->Fill(en,l0); | |
243c2909 | 746 | } |
5c46c992 | 747 | else if(nMax >2) |
748 | { | |
749 | fhAnglePairLocMaxN[matched]->Fill(en,angle); | |
0137016b | 750 | fhMassNLocMaxN[0] [matched]->Fill(en,mass ); |
26680f06 | 751 | |
0137016b | 752 | if( en > 7 ) |
753 | { | |
5c46c992 | 754 | fhAnglePairMassLocMaxN[matched]->Fill(mass,angle); |
0137016b | 755 | } |
5c46c992 | 756 | |
3c1d9afb | 757 | if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMaxN[0][matched]->Fill(en,l0); |
758 | else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMaxN[0][matched]->Fill(en,l0); | |
759 | else if(pidTag==AliCaloPID::kEta ) fhM02EtaLocMaxN[0][matched]->Fill(en,l0); | |
243c2909 | 760 | } |
761 | ||
26680f06 | 762 | |
3c1d9afb | 763 | if(IsDataMC()) |
764 | { | |
243c2909 | 765 | if (nMax==1) |
766 | { | |
5c46c992 | 767 | fhMassNLocMax1[mcindex][matched]->Fill(en,mass); |
3c1d9afb | 768 | if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax1[mcindex][matched]->Fill(en,l0); |
769 | else if(pidTag==AliCaloPID::kPi0) fhM02Pi0LocMax1[mcindex][matched]->Fill(en,l0); | |
770 | else if(pidTag==AliCaloPID::kEta) fhM02EtaLocMax1[mcindex][matched]->Fill(en,l0); | |
243c2909 | 771 | } |
0137016b | 772 | else if(nMax==2) |
773 | { | |
5c46c992 | 774 | fhMassNLocMax2[mcindex][matched]->Fill(en,mass); |
3c1d9afb | 775 | if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMax2[mcindex][matched]->Fill(en,l0); |
776 | else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMax2[mcindex][matched]->Fill(en,l0); | |
777 | else if(pidTag==AliCaloPID::kEta ) fhM02EtaLocMax2[mcindex][matched]->Fill(en,l0); | |
243c2909 | 778 | } |
0137016b | 779 | else if(nMax >2) |
780 | { | |
5c46c992 | 781 | fhMassNLocMaxN[mcindex][matched]->Fill(en,mass); |
3c1d9afb | 782 | if (pidTag==AliCaloPID::kPhoton) fhM02ConLocMaxN[mcindex][matched]->Fill(en,l0); |
783 | else if(pidTag==AliCaloPID::kPi0 ) fhM02Pi0LocMaxN[mcindex][matched]->Fill(en,l0); | |
784 | else if(pidTag==AliCaloPID::kEta) fhM02EtaLocMaxN[mcindex][matched]->Fill(en,l0); | |
243c2909 | 785 | } |
992b14a7 | 786 | |
787 | }//Work with MC truth first | |
5c46c992 | 788 | |
992b14a7 | 789 | }//loop |
790 | ||
791 | if(GetDebug() > 1) printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - END \n"); | |
e23a0471 | 792 | |
992b14a7 | 793 | } |
794 | ||
795 | //______________________________________________________________________ | |
796 | void AliAnaInsideClusterInvariantMass::Print(const Option_t * opt) const | |
797 | { | |
798 | //Print some relevant parameters set for the analysis | |
799 | if(! opt) | |
800 | return; | |
801 | ||
802 | printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ; | |
745913ae | 803 | AliAnaCaloTrackCorrBaseClass::Print(""); |
243c2909 | 804 | printf("Calorimeter = %s\n", fCalorimeter.Data()) ; |
dbba06ca | 805 | printf("Loc. Max. E > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutE()); |
806 | printf("Loc. Max. E Diff > %2.2f\n", GetCaloUtils()->GetLocalMaximaCutEDiff()); | |
cfc19369 | 807 | printf("Min. N Cells =%d \n", fMinNCells) ; |
808 | printf("Min. Dist. to Bad =%1.1f \n", fMinBadDist) ; | |
71e3889f | 809 | printf("%2.2f < lambda_0^2 <%2.2f \n",fM02MinCut,fM02MaxCut); |
3c1d9afb | 810 | |
992b14a7 | 811 | printf(" \n") ; |
812 | ||
813 | } | |
814 | ||
dbba06ca | 815 | |
992b14a7 | 816 |