]>
Commit | Line | Data |
---|---|---|
02f0b8e7 | 1 | #include "TChain.h" |
2 | #include "TTree.h" | |
3 | #include "TObjArray.h" | |
4 | #include "TF1.h" | |
5 | #include "TFile.h" | |
6 | #include "TH1F.h" | |
7 | #include "TH2F.h" | |
8 | #include "TH2I.h" | |
9 | #include "TH3F.h" | |
10 | #include "TParticle.h" | |
11 | #include "TCanvas.h" | |
12 | #include "TStyle.h" | |
13 | #include "TRandom.h" | |
14 | ||
15 | #include "AliAODMCParticle.h" | |
16 | #include "AliAnalysisManager.h" | |
17 | #include "AliMCEventHandler.h" | |
18 | #include "AliMCEvent.h" | |
19 | #include "AliStack.h" | |
20 | #include "AliAnalysisTaskSE.h" | |
21 | #include "AliAnalysisTaskPi0DiffEfficiency.h" | |
22 | #include "AliCaloPhoton.h" | |
23 | #include "AliPHOSGeometry.h" | |
6e4947dd | 24 | #include "AliPHOSAodCluster.h" |
02f0b8e7 | 25 | #include "AliPHOSCalibData.h" |
26 | #include "AliAODEvent.h" | |
27 | #include "AliAODCaloCluster.h" | |
28 | #include "AliAODVertex.h" | |
29 | #include "AliESDtrackCuts.h" | |
30 | #include "AliLog.h" | |
31 | #include "AliPID.h" | |
32 | #include "AliCDBManager.h" | |
33 | #include "AliCentrality.h" | |
34 | ||
6e4947dd | 35 | // Analysis task to calculate pi0 registration efficiency |
36 | // as a difference between spectra before and after embedding | |
37 | // Authors: Dmitri Peressounko | |
38 | // Date : Aug.2011 | |
02f0b8e7 | 39 | |
40 | ClassImp(AliAnalysisTaskPi0DiffEfficiency) | |
41 | ||
42 | //________________________________________________________________________ | |
43 | AliAnalysisTaskPi0DiffEfficiency::AliAnalysisTaskPi0DiffEfficiency(const char *name) | |
6e4947dd | 44 | : AliAnalysisTaskPi0Efficiency(name), |
02f0b8e7 | 45 | fPHOSEvent1(0), |
6e4947dd | 46 | fPHOSEvent2(0) |
02f0b8e7 | 47 | { |
02f0b8e7 | 48 | |
02f0b8e7 | 49 | |
50 | ||
51 | } | |
52 | ||
53 | //________________________________________________________________________ | |
54 | void AliAnalysisTaskPi0DiffEfficiency::UserCreateOutputObjects() | |
55 | { | |
56 | // Create histograms | |
57 | // Called once | |
58 | ||
59 | // ESD histograms | |
60 | if(fOutputContainer != NULL){ | |
61 | delete fOutputContainer; | |
62 | } | |
63 | fOutputContainer = new TList(); | |
64 | fOutputContainer->SetOwner(kTRUE); | |
65 | ||
66 | //Event selection | |
67 | fOutputContainer->Add(new TH1F("hSelEvents","Event celection", 10,0.,10.)) ; | |
68 | ||
69 | //vertex distribution | |
70 | fOutputContainer->Add(new TH1F("hZvertex","Z vertex position", 50,-25.,25.)) ; | |
71 | ||
72 | //Centrality | |
73 | fOutputContainer->Add(new TH1F("hCentrality","Event centrality", 100,0.,100.)) ; | |
74 | ||
75 | //QA histograms | |
76 | fOutputContainer->Add(new TH2F("hCluM1","Cell (X,Z), M1" ,64,0.5,64.5, 56,0.5,56.5)); | |
77 | fOutputContainer->Add(new TH2F("hCluM2","Cell (X,Z), M2" ,64,0.5,64.5, 56,0.5,56.5)); | |
78 | fOutputContainer->Add(new TH2F("hCluM3","Cell (X,Z), M3" ,64,0.5,64.5, 56,0.5,56.5)); | |
79 | ||
80 | Int_t nM = 500; | |
81 | Double_t mMin = 0.0; | |
82 | Double_t mMax = 1.0; | |
83 | Int_t nPt = 200; | |
84 | Double_t ptMin = 0; | |
85 | Double_t ptMax = 20; | |
86 | ||
87 | char key[55] ; | |
88 | for(Int_t cent=0; cent<6; cent++){ | |
89 | //Single photon | |
90 | snprintf(key,55,"hPhotAll_cen%d",cent) ; | |
91 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
92 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 93 | snprintf(key,55,"hPhotAllcore_cen%d",cent) ; |
94 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
95 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
96 | snprintf(key,55,"hPhotAllwou_cen%d",cent) ; | |
97 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
98 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 99 | snprintf(key,55,"hPhotCPV_cen%d",cent) ; |
100 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
6e4947dd | 101 | snprintf(key,55,"hPhotCPVcore_cen%d",cent) ; |
102 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
103 | snprintf(key,55,"hPhotCPV2_cen%d",cent) ; | |
104 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
02f0b8e7 | 105 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; |
106 | snprintf(key,55,"hPhotDisp_cen%d",cent) ; | |
107 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
108 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 109 | snprintf(key,55,"hPhotDisp2_cen%d",cent) ; |
110 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
111 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
112 | snprintf(key,55,"hPhotDispwou_cen%d",cent) ; | |
113 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
114 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 115 | snprintf(key,55,"hPhotBoth_cen%d",cent) ; |
116 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
117 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 118 | snprintf(key,55,"hPhotBothcore_cen%d",cent) ; |
119 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
120 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 121 | |
6e4947dd | 122 | snprintf(key,55,"hNegPhotAll_cen%d",cent) ; |
123 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
124 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
125 | snprintf(key,55,"hNegPhotAllcore_cen%d",cent) ; | |
126 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
127 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
128 | snprintf(key,55,"hNegPhotAllwou_cen%d",cent) ; | |
129 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
130 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
131 | snprintf(key,55,"hNegPhotCPV_cen%d",cent) ; | |
132 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
133 | snprintf(key,55,"hNegPhotCPVcore_cen%d",cent) ; | |
134 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
135 | snprintf(key,55,"hNegPhotCPV2_cen%d",cent) ; | |
136 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
137 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
138 | snprintf(key,55,"hNegPhotDisp_cen%d",cent) ; | |
139 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
140 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
141 | snprintf(key,55,"hNegPhotDisp2_cen%d",cent) ; | |
142 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
143 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
144 | snprintf(key,55,"hNegPhotDispwou_cen%d",cent) ; | |
145 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
146 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
147 | snprintf(key,55,"hNegPhotBoth_cen%d",cent) ; | |
148 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
149 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
150 | snprintf(key,55,"hNegPhotBothcore_cen%d",cent) ; | |
151 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
152 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
153 | ||
02f0b8e7 | 154 | snprintf(key,55,"hOldMassPtAll_cen%d",cent) ; |
155 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
156 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 157 | snprintf(key,55,"hOldMassPtAllcore_cen%d",cent) ; |
158 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
159 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
160 | snprintf(key,55,"hOldMassPtAllwou_cen%d",cent) ; | |
161 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
162 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 163 | snprintf(key,55,"hOldMassPtCPV_cen%d",cent) ; |
164 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 165 | snprintf(key,55,"hOldMassPtCPVcore_cen%d",cent) ; |
166 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
167 | snprintf(key,55,"hOldMassPtCPV2_cen%d",cent) ; | |
168 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 169 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; |
170 | snprintf(key,55,"hOldMassPtDisp_cen%d",cent) ; | |
171 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
172 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 173 | snprintf(key,55,"hOldMassPtDisp2_cen%d",cent) ; |
174 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
175 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
176 | snprintf(key,55,"hOldMassPtDispwou_cen%d",cent) ; | |
177 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
178 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 179 | snprintf(key,55,"hOldMassPtBoth_cen%d",cent) ; |
180 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
181 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 182 | snprintf(key,55,"hOldMassPtBothcore_cen%d",cent) ; |
183 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
184 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 185 | |
186 | snprintf(key,55,"hNewMassPtAll_cen%d",cent) ; | |
187 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
188 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 189 | snprintf(key,55,"hNewMassPtAllcore_cen%d",cent) ; |
190 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
191 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
192 | snprintf(key,55,"hNewMassPtAllwou_cen%d",cent) ; | |
193 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
194 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 195 | snprintf(key,55,"hNewMassPtCPV_cen%d",cent) ; |
196 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
197 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 198 | snprintf(key,55,"hNewMassPtCPVcore_cen%d",cent) ; |
199 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
200 | snprintf(key,55,"hNewMassPtCPV2_cen%d",cent) ; | |
201 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
202 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
203 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 204 | snprintf(key,55,"hNewMassPtDisp_cen%d",cent) ; |
205 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
206 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 207 | snprintf(key,55,"hNewMassPtDisp2_cen%d",cent) ; |
208 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
209 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
210 | snprintf(key,55,"hNewMassPtDispwou_cen%d",cent) ; | |
211 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
212 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 213 | snprintf(key,55,"hNewMassPtBoth_cen%d",cent) ; |
214 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
215 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 216 | snprintf(key,55,"hNewMassPtBothcore_cen%d",cent) ; |
217 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
218 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
219 | ||
220 | snprintf(key,55,"hNegMassPtAll_cen%d",cent) ; | |
221 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
222 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
223 | snprintf(key,55,"hNegMassPtAllcore_cen%d",cent) ; | |
224 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
225 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
226 | snprintf(key,55,"hNegMassPtAllwou_cen%d",cent) ; | |
227 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
228 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
229 | snprintf(key,55,"hNegMassPtCPV_cen%d",cent) ; | |
230 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
231 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
232 | snprintf(key,55,"hNegMassPtCPVcore_cen%d",cent) ; | |
233 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
234 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
235 | snprintf(key,55,"hNegMassPtCPV2_cen%d",cent) ; | |
236 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
237 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
238 | snprintf(key,55,"hNegMassPtDisp_cen%d",cent) ; | |
239 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
240 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
241 | snprintf(key,55,"hNegMassPtDisp2_cen%d",cent) ; | |
242 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
243 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
244 | snprintf(key,55,"hNegMassPtDispwou_cen%d",cent) ; | |
245 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
246 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
247 | snprintf(key,55,"hNegMassPtBoth_cen%d",cent) ; | |
248 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
249 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
250 | snprintf(key,55,"hNegMassPtBothcore_cen%d",cent) ; | |
251 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
252 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
253 | ||
02f0b8e7 | 254 | |
255 | snprintf(key,55,"hMassPtAll_cen%d",cent) ; | |
256 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
257 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 258 | snprintf(key,55,"hMassPtAllcore_cen%d",cent) ; |
259 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
260 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
261 | snprintf(key,55,"hMassPtAllwou_cen%d",cent) ; | |
262 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
263 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 264 | snprintf(key,55,"hMassPtCPV_cen%d",cent) ; |
265 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
266 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 267 | snprintf(key,55,"hMassPtCPVcore_cen%d",cent) ; |
268 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
269 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
270 | snprintf(key,55,"hMassPtCPV2_cen%d",cent) ; | |
271 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
272 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 273 | snprintf(key,55,"hMassPtDisp_cen%d",cent) ; |
274 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
275 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 276 | snprintf(key,55,"hMassPtDisp2_cen%d",cent) ; |
277 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
278 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
279 | snprintf(key,55,"hMassPtDispwou_cen%d",cent) ; | |
280 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
281 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 282 | snprintf(key,55,"hMassPtBoth_cen%d",cent) ; |
283 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
284 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 285 | snprintf(key,55,"hMassPtBothcore_cen%d",cent) ; |
286 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
287 | ((TH2F*)fOutputContainer->Last())->Sumw2() ; | |
288 | ||
289 | snprintf(key,55,"hMassPtAll_a07_cen%d",cent) ; | |
290 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
291 | snprintf(key,55,"hMassPtCPV_a07_cen%d",cent) ; | |
292 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
293 | snprintf(key,55,"hMassPtCPV2_a07_cen%d",cent) ; | |
294 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
295 | snprintf(key,55,"hMassPtDisp_a07_cen%d",cent) ; | |
296 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
297 | snprintf(key,55,"hMassPtBoth_a07_cen%d",cent) ; | |
298 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
299 | ||
300 | snprintf(key,55,"hMassPtAll_a08_cen%d",cent) ; | |
301 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
302 | snprintf(key,55,"hMassPtCPV_a08_cen%d",cent) ; | |
303 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
304 | snprintf(key,55,"hMassPtCPV2_a08_cen%d",cent) ; | |
305 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
306 | snprintf(key,55,"hMassPtDisp_a08_cen%d",cent) ; | |
307 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
308 | snprintf(key,55,"hMassPtBoth_a08_cen%d",cent) ; | |
309 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
310 | ||
311 | snprintf(key,55,"hMassPtAll_a09_cen%d",cent) ; | |
312 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
313 | snprintf(key,55,"hMassPtCPV_a09_cen%d",cent) ; | |
314 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
315 | snprintf(key,55,"hMassPtCPV2_a09_cen%d",cent) ; | |
316 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
317 | snprintf(key,55,"hMassPtDisp_a09_cen%d",cent) ; | |
318 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
319 | snprintf(key,55,"hMassPtBoth_a09_cen%d",cent) ; | |
320 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
321 | ||
02f0b8e7 | 322 | |
323 | //Mixed | |
324 | snprintf(key,55,"hMiMassPtAll_cen%d",cent) ; | |
325 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 326 | snprintf(key,55,"hMiMassPtAllcore_cen%d",cent) ; |
327 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
328 | snprintf(key,55,"hMiMassPtAllwou_cen%d",cent) ; | |
329 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 330 | snprintf(key,55,"hMiMassPtCPV_cen%d",cent) ; |
331 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 332 | snprintf(key,55,"hMiMassPtCPVcore_cen%d",cent) ; |
333 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
334 | snprintf(key,55,"hMiMassPtCPV2_cen%d",cent) ; | |
335 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 336 | snprintf(key,55,"hMiMassPtDisp_cen%d",cent) ; |
337 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 338 | snprintf(key,55,"hMiMassPtDisp2_cen%d",cent) ; |
339 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
340 | snprintf(key,55,"hMiMassPtDispwou_cen%d",cent) ; | |
341 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 342 | snprintf(key,55,"hMiMassPtBoth_cen%d",cent) ; |
343 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 344 | snprintf(key,55,"hMiMassPtBothcore_cen%d",cent) ; |
345 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 346 | |
6e4947dd | 347 | snprintf(key,55,"hMiMassPtAll_a07_cen%d",cent) ; |
348 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
349 | snprintf(key,55,"hMiMassPtCPV_a07_cen%d",cent) ; | |
350 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
351 | snprintf(key,55,"hMiMassPtCPV2_a07_cen%d",cent) ; | |
352 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
353 | snprintf(key,55,"hMiMassPtDisp_a07_cen%d",cent) ; | |
354 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
355 | snprintf(key,55,"hMiMassPtBoth_a07_cen%d",cent) ; | |
356 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
357 | ||
358 | snprintf(key,55,"hMiMassPtAll_a08_cen%d",cent) ; | |
359 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
360 | snprintf(key,55,"hMiMassPtCPV_a08_cen%d",cent) ; | |
361 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
362 | snprintf(key,55,"hMiMassPtCPV2_a08_cen%d",cent) ; | |
363 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
364 | snprintf(key,55,"hMiMassPtDisp_a08_cen%d",cent) ; | |
365 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
366 | snprintf(key,55,"hMiMassPtBoth_a08_cen%d",cent) ; | |
367 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
368 | ||
369 | snprintf(key,55,"hMiMassPtAll_a09_cen%d",cent) ; | |
370 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
371 | snprintf(key,55,"hMiMassPtCPV_a09_cen%d",cent) ; | |
372 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
373 | snprintf(key,55,"hMiMassPtCPV2_a09_cen%d",cent) ; | |
374 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
375 | snprintf(key,55,"hMiMassPtDisp_a09_cen%d",cent) ; | |
376 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
377 | snprintf(key,55,"hMiMassPtBoth_a09_cen%d",cent) ; | |
378 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
379 | ||
02f0b8e7 | 380 | snprintf(key,55,"hMCMassPtAll_cen%d",cent) ; |
381 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 382 | snprintf(key,55,"hMCMassPtAllcore_cen%d",cent) ; |
383 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
384 | snprintf(key,55,"hMCMassPtAllwou_cen%d",cent) ; | |
385 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 386 | snprintf(key,55,"hMCMassPtCPV_cen%d",cent) ; |
387 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 388 | snprintf(key,55,"hMCMassPtCPVcore_cen%d",cent) ; |
389 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
390 | snprintf(key,55,"hMCMassPtCPV2_cen%d",cent) ; | |
391 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 392 | snprintf(key,55,"hMCMassPtDisp_cen%d",cent) ; |
393 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 394 | snprintf(key,55,"hMCMassPtDisp2_cen%d",cent) ; |
395 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
396 | snprintf(key,55,"hMCMassPtDispwou_cen%d",cent) ; | |
397 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 398 | snprintf(key,55,"hMCMassPtBoth_cen%d",cent) ; |
399 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
6e4947dd | 400 | snprintf(key,55,"hMCMassPtBothcore_cen%d",cent) ; |
401 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
402 | ||
403 | snprintf(key,55,"hMCMassPtAll_a07_cen%d",cent) ; | |
404 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
405 | snprintf(key,55,"hMCMassPtCPV_a07_cen%d",cent) ; | |
406 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
407 | snprintf(key,55,"hMCMassPtCPV2_a07_cen%d",cent) ; | |
408 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
409 | snprintf(key,55,"hMCMassPtDisp_a07_cen%d",cent) ; | |
410 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
411 | snprintf(key,55,"hMCMassPtBoth_a07_cen%d",cent) ; | |
412 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
413 | ||
414 | snprintf(key,55,"hMCMassPtAll_a08_cen%d",cent) ; | |
415 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
416 | snprintf(key,55,"hMCMassPtCPV_a08_cen%d",cent) ; | |
417 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
418 | snprintf(key,55,"hMCMassPtCPV2_a08_cen%d",cent) ; | |
419 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
420 | snprintf(key,55,"hMCMassPtDisp_a08_cen%d",cent) ; | |
421 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
422 | snprintf(key,55,"hMCMassPtBoth_a08_cen%d",cent) ; | |
423 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
424 | ||
425 | snprintf(key,55,"hMCMassPtAll_a09_cen%d",cent) ; | |
426 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
427 | snprintf(key,55,"hMCMassPtCPV_a09_cen%d",cent) ; | |
428 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
429 | snprintf(key,55,"hMCMassPtCPV2_a09_cen%d",cent) ; | |
430 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
431 | snprintf(key,55,"hMCMassPtDisp_a09_cen%d",cent) ; | |
432 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
433 | snprintf(key,55,"hMCMassPtBoth_a09_cen%d",cent) ; | |
434 | fOutputContainer->Add(new TH2F(key,"(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 435 | |
436 | //Single photon | |
437 | snprintf(key,55,"hMCPhotAll_cen%d",cent) ; | |
438 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
439 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 440 | snprintf(key,55,"hMCPhotAllcore_cen%d",cent) ; |
441 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
442 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
443 | snprintf(key,55,"hMCPhotAllwou_cen%d",cent) ; | |
444 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
445 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 446 | snprintf(key,55,"hMCPhotCPV_cen%d",cent) ; |
447 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
448 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 449 | snprintf(key,55,"hMCPhotCPVcore_cen%d",cent) ; |
450 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
451 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
452 | snprintf(key,55,"hMCPhotCPV2_cen%d",cent) ; | |
453 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
454 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 455 | snprintf(key,55,"hMCPhotDisp_cen%d",cent) ; |
456 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
457 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 458 | snprintf(key,55,"hMCPhotDisp2_cen%d",cent) ; |
02f0b8e7 | 459 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); |
460 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
6e4947dd | 461 | snprintf(key,55,"hMCPhotDispwou_cen%d",cent) ; |
462 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
463 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
464 | snprintf(key,55,"hMCPhotBoth_cen%d",cent) ; | |
465 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
466 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
467 | snprintf(key,55,"hMCPhotBothcore_cen%d",cent) ; | |
468 | fOutputContainer->Add(new TH1F(key,"dN/dpt" ,nPt,ptMin,ptMax)); | |
469 | ((TH1F*)fOutputContainer->Last())->Sumw2() ; | |
02f0b8e7 | 470 | |
471 | } | |
472 | ||
6e4947dd | 473 | fOutputContainer->Add(new TH2F("hMCPi0M11","(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); |
474 | fOutputContainer->Add(new TH2F("hMCPi0M22","(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
475 | fOutputContainer->Add(new TH2F("hMCPi0M33","(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
476 | fOutputContainer->Add(new TH2F("hMCPi0M12","(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
477 | fOutputContainer->Add(new TH2F("hMCPi0M13","(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
478 | fOutputContainer->Add(new TH2F("hMCPi0M23","(M,p_{T},d#phi)_{#gamma#gamma}" ,nM,mMin,mMax,nPt,ptMin,ptMax)); | |
02f0b8e7 | 479 | |
480 | //MC | |
481 | for(Int_t cent=0; cent<6; cent++){ | |
482 | snprintf(key,55,"hMC_rap_gamma_cen%d",cent) ; | |
483 | fOutputContainer->Add(new TH1F(key,"Rapidity pi0",200,-1.,1.)) ; | |
484 | snprintf(key,55,"hMC_rap_pi0_cen%d",cent) ; | |
485 | fOutputContainer->Add(new TH1F(key,"Rapidity pi0",200,-1.,1.)) ; | |
486 | snprintf(key,55,"hMC_rap_eta_cen%d",cent) ; | |
487 | fOutputContainer->Add(new TH1F("hMC_rap_eta","Rapidity eta",200,-1.,1.)) ; | |
488 | snprintf(key,55,"hMC_phi_gamma_cen%d",cent) ; | |
489 | fOutputContainer->Add(new TH1F(key,"Phi pi0",200,0.,TMath::TwoPi())) ; | |
490 | snprintf(key,55,"hMC_phi_pi0_cen%d",cent) ; | |
491 | fOutputContainer->Add(new TH1F(key,"Phi pi0",200,0.,TMath::TwoPi())) ; | |
492 | snprintf(key,55,"hMC_phi_eta_cen%d",cent) ; | |
493 | fOutputContainer->Add(new TH1F(key,"Phi eta",200,0.,TMath::TwoPi())) ; | |
494 | snprintf(key,55,"hMC_all_gamma_cen%d",cent) ; | |
495 | fOutputContainer->Add(new TH1F(key,"Rapidity photon",250,0.,25.)) ; | |
496 | snprintf(key,55,"hMC_all_pi0_cen%d",cent) ; | |
497 | fOutputContainer->Add(new TH1F(key,"Rapidity pi0",250,0.,25.)) ; | |
498 | snprintf(key,55,"hMC_all_eta_cen%d",cent) ; | |
499 | fOutputContainer->Add(new TH1F(key,"Rapidity eta",250,0.,25.)) ; | |
500 | snprintf(key,55,"hMC_unitEta_gamma_cen%d",cent) ; | |
501 | fOutputContainer->Add(new TH1F(key,"Pt photon",250,0.,25.)) ; | |
502 | snprintf(key,55,"hMC_unitEta_pi0_cen%d",cent) ; | |
503 | fOutputContainer->Add(new TH1F(key,"Rapidity eta",250,0.,25.)) ; | |
504 | snprintf(key,55,"hMC_unitEta_eta_cen%d",cent) ; | |
505 | fOutputContainer->Add(new TH1F(key,"Rapidity eta",250,0.,25.)) ; | |
506 | } | |
507 | ||
508 | PostData(1, fOutputContainer); | |
509 | ||
510 | } | |
511 | ||
512 | //________________________________________________________________________ | |
513 | void AliAnalysisTaskPi0DiffEfficiency::UserExec(Option_t *) | |
514 | { | |
515 | // Main loop, called for each event | |
516 | // Analyze ESD/AOD | |
517 | ||
518 | FillHistogram("hSelEvents",0.5) ; | |
519 | ||
520 | AliAODEvent *event = dynamic_cast<AliAODEvent*>(InputEvent()); | |
521 | if (!event) { | |
522 | Printf("ERROR: Could not retrieve event"); | |
523 | PostData(1, fOutputContainer); | |
524 | return; | |
525 | } | |
526 | ||
527 | FillHistogram("hSelEvents",1.5) ; | |
528 | AliAODHeader *header = event->GetHeader() ; | |
529 | ||
530 | // Checks if we have a primary vertex | |
531 | // Get primary vertices form ESD | |
532 | const AliAODVertex *esdVertex5 = event->GetPrimaryVertex(); | |
533 | ||
534 | // don't rely on ESD vertex, assume (0,0,0) | |
535 | Double_t vtx0[3] ={0.,0.,0.}; | |
02f0b8e7 | 536 | |
537 | ||
538 | FillHistogram("hZvertex",esdVertex5->GetZ()); | |
539 | if (TMath::Abs(esdVertex5->GetZ()) > 10. ){ | |
540 | PostData(1, fOutputContainer); | |
541 | return; | |
542 | } | |
543 | FillHistogram("hSelEvents",2.5) ; | |
544 | ||
545 | //Vtx class z-bin | |
546 | // Int_t zvtx = (Int_t)((vtx5[2]+10.)/2.) ; | |
547 | // if(zvtx<0)zvtx=0 ; | |
548 | // if(zvtx>9)zvtx=9 ; | |
549 | Int_t zvtx=0 ; | |
550 | ||
551 | // fCentrality=header->GetCentralityP()->GetCentralityPercentile("V0M"); // returns the centrality percentile, | |
552 | // //a float from 0 to 100 (or to the trigger efficiency) | |
553 | fCentrality=header->GetZDCN2Energy() ; | |
554 | ||
555 | if( fCentrality < 0. || fCentrality>80.){ | |
556 | PostData(1, fOutputContainer); | |
557 | return; | |
558 | } | |
559 | FillHistogram("hSelEvents",3.5) ; | |
560 | Float_t bins[7]={0.,5.,10.,20.,40.,60.,80.} ; | |
561 | fCenBin=0 ; | |
562 | while(fCenBin<6 && fCentrality > bins[fCenBin+1]) | |
563 | fCenBin++ ; | |
564 | ||
565 | ||
566 | //reaction plain | |
567 | fRPfull= header->GetZDCN1Energy() ; | |
568 | if(fRPfull==999){ //reaction plain was not defined | |
569 | PostData(1, fOutputContainer); | |
570 | return; | |
571 | } | |
572 | ||
573 | FillHistogram("hSelEvents",4.5) ; | |
574 | //All event selections done | |
575 | FillHistogram("hCentrality",fCentrality) ; | |
576 | //Reaction plain is defined in the range (-pi/2;pi/2) | |
577 | //We have 10 bins | |
6e4947dd | 578 | Int_t irp=Int_t(10.*fRPfull/TMath::Pi()); |
02f0b8e7 | 579 | if(irp>9)irp=9 ; |
580 | ||
581 | if(!fPHOSEvents[zvtx][fCenBin][irp]) | |
582 | fPHOSEvents[zvtx][fCenBin][irp]=new TList() ; | |
583 | TList * prevPHOS = fPHOSEvents[zvtx][fCenBin][irp] ; | |
584 | ||
585 | // Get PHOS rotation matrices from ESD and set them to the PHOS geometry | |
586 | if(fEventCounter == 0) { | |
587 | for(Int_t mod=0; mod<5; mod++) { | |
588 | const TGeoHMatrix* m =header->GetPHOSMatrix(mod) ; | |
589 | fPHOSGeo->SetMisalMatrix(m,mod) ; | |
590 | Printf("PHOS geo matrix for module # %d is set: %p\n", mod,m); | |
591 | } | |
592 | fEventCounter++ ; | |
593 | } | |
594 | ||
595 | ProcessMC() ; | |
596 | ||
597 | if(fPHOSEvent1){ | |
598 | fPHOSEvent1->Clear() ; | |
599 | fPHOSEvent2->Clear() ; | |
600 | } | |
601 | else{ | |
602 | fPHOSEvent1 = new TClonesArray("AliCaloPhoton",200) ; | |
603 | fPHOSEvent2 = new TClonesArray("AliCaloPhoton",200) ; | |
604 | } | |
605 | ||
606 | TClonesArray * clustersEmb = (TClonesArray*)event->FindListObject("EmbeddedCaloClusters") ; | |
6e4947dd | 607 | AliAODCaloCells * cellsEmb = (AliAODCaloCells *)event->FindListObject("EmbeddedPHOScells") ; |
02f0b8e7 | 608 | TClonesArray * clustersOld = event->GetCaloClusters() ; |
6e4947dd | 609 | AliAODCaloCells * cellsOld = event->GetPHOSCells() ; |
02f0b8e7 | 610 | TVector3 vertex(vtx0); |
611 | char key[55] ; | |
612 | //Before Embedding | |
613 | Int_t multClustOld = clustersOld->GetEntriesFast(); | |
614 | Int_t multClustEmb = clustersEmb->GetEntriesFast(); | |
615 | Int_t inPHOSold=0 ; | |
616 | Int_t inPHOSemb=0 ; | |
617 | for (Int_t i=0; i<multClustOld; i++) { | |
618 | AliAODCaloCluster *clu = (AliAODCaloCluster*)clustersOld->At(i); | |
619 | if ( !clu->IsPHOS() || clu->E()<0.3) continue; | |
620 | ||
621 | Bool_t survive=kFALSE ; | |
622 | for(Int_t ii=0;(ii<multClustEmb)&&(!survive);ii++){ | |
623 | AliAODCaloCluster *clu2 = (AliAODCaloCluster*)clustersEmb->At(ii); | |
624 | survive=IsSameCluster(clu,clu2); | |
625 | } | |
626 | ||
627 | ||
628 | Float_t position[3]; | |
629 | clu->GetPosition(position); | |
630 | TVector3 global(position) ; | |
631 | Int_t relId[4] ; | |
632 | fPHOSGeo->GlobalPos2RelId(global,relId) ; | |
633 | Int_t mod = relId[0] ; | |
634 | Int_t cellX = relId[2]; | |
635 | Int_t cellZ = relId[3] ; | |
636 | if ( !IsGoodChannel("PHOS",mod,cellX,cellZ) ) | |
637 | continue ; | |
638 | if(clu->GetNCells()<3) | |
639 | continue ; | |
640 | ||
1f77ed3b | 641 | snprintf(key,55,"hCluM%d",mod) ; |
02f0b8e7 | 642 | FillHistogram(key,cellX,cellZ,1.); |
643 | ||
644 | TLorentzVector pv1 ; | |
645 | clu->GetMomentum(pv1 ,vtx0); | |
646 | ||
647 | if(inPHOSold>=fPHOSEvent1->GetSize()){ | |
648 | fPHOSEvent1->Expand(inPHOSold+50) ; | |
649 | } | |
650 | AliCaloPhoton * ph = new((*fPHOSEvent1)[inPHOSold]) AliCaloPhoton(pv1.X(),pv1.Py(),pv1.Z(),pv1.E()) ; | |
651 | ph->SetModule(mod) ; | |
6e4947dd | 652 | AliPHOSAodCluster cluPHOS1(*clu); |
653 | cluPHOS1.Recalibrate(fPHOSCalibData,cellsOld); // modify the cell energies | |
654 | Double_t ecore=CoreEnergy(&cluPHOS1) ; | |
655 | pv1*= ecore/pv1.E() ; | |
02f0b8e7 | 656 | ph->SetMomV2(&pv1) ; |
657 | ph->SetNCells(clu->GetNCells()); | |
6e4947dd | 658 | ph->SetDispBit(TestLambda(clu->E(),clu->GetM20(),clu->GetM02())) ; |
659 | ph->SetDisp2Bit(TestLambda2(clu->E(),clu->GetM20(),clu->GetM02())) ; | |
660 | ph->SetCPVBit(clu->GetEmcCpvDistance()>2.) ; | |
661 | ph->SetCPV2Bit(clu->GetEmcCpvDistance()>4.) ; | |
02f0b8e7 | 662 | if(!survive) //this cluster found in list after embedding, skipping it |
6e4947dd | 663 | ph->SetTagged(1) ; |
664 | ph->SetPhoton(clu->GetNExMax()<2); // Remember, if it is unfolded | |
02f0b8e7 | 665 | |
666 | inPHOSold++ ; | |
667 | } | |
668 | ||
669 | for (Int_t i=0; i<multClustEmb; i++) { | |
670 | AliAODCaloCluster *clu = (AliAODCaloCluster*)clustersEmb->At(i); | |
671 | if ( !clu->IsPHOS() || clu->E()<0.3) continue; | |
672 | ||
673 | Bool_t survive=kFALSE ; | |
674 | for(Int_t ii=0;(ii<multClustOld)&&(!survive);ii++){ | |
675 | AliAODCaloCluster *clu2 = (AliAODCaloCluster*)clustersOld->At(ii); | |
676 | survive=IsSameCluster(clu,clu2); | |
677 | } | |
678 | ||
679 | Float_t position[3]; | |
680 | clu->GetPosition(position); | |
681 | TVector3 global(position) ; | |
682 | Int_t relId[4] ; | |
683 | fPHOSGeo->GlobalPos2RelId(global,relId) ; | |
684 | Int_t mod = relId[0] ; | |
685 | Int_t cellX = relId[2]; | |
686 | Int_t cellZ = relId[3] ; | |
687 | if ( !IsGoodChannel("PHOS",mod,cellX,cellZ) ) | |
688 | continue ; | |
689 | if(clu->GetNCells()<3) | |
690 | continue ; | |
691 | ||
1f77ed3b | 692 | snprintf(key,55,"hCluM%d",mod) ; |
02f0b8e7 | 693 | FillHistogram(key,cellX,cellZ,1.); |
694 | ||
695 | TLorentzVector pv1 ; | |
696 | clu->GetMomentum(pv1 ,vtx0); | |
697 | ||
698 | if(inPHOSemb>=fPHOSEvent2->GetSize()){ | |
699 | fPHOSEvent2->Expand(inPHOSemb+50) ; | |
700 | } | |
701 | AliCaloPhoton * ph = new((*fPHOSEvent2)[inPHOSemb]) AliCaloPhoton(pv1.X(),pv1.Py(),pv1.Z(),pv1.E()) ; | |
702 | ph->SetModule(mod) ; | |
6e4947dd | 703 | AliPHOSAodCluster cluPHOS1(*clu); |
704 | cluPHOS1.Recalibrate(fPHOSCalibData,cellsEmb); // modify the cell energies | |
705 | Double_t ecore=CoreEnergy(&cluPHOS1) ; | |
706 | pv1*= ecore/pv1.E() ; | |
02f0b8e7 | 707 | ph->SetMomV2(&pv1) ; |
708 | ph->SetNCells(clu->GetNCells()); | |
6e4947dd | 709 | ph->SetDispBit(TestLambda(clu->E(),clu->GetM20(),clu->GetM02())) ; |
710 | ph->SetDisp2Bit(TestLambda2(clu->E(),clu->GetM20(),clu->GetM02())) ; | |
711 | ph->SetCPVBit(clu->GetEmcCpvDistance()>2.) ; | |
712 | ph->SetCPV2Bit(clu->GetEmcCpvDistance()>4.) ; | |
02f0b8e7 | 713 | if(!survive) //this cluster found in list after embedding, skipping it |
6e4947dd | 714 | ph->SetTagged(1) ; |
715 | ph->SetPhoton(clu->GetNExMax()<2); // Remember, if it is unfolded | |
02f0b8e7 | 716 | |
717 | inPHOSemb++ ; | |
718 | } | |
719 | ||
720 | //Single photon | |
721 | for (Int_t i1=0; i1<inPHOSold; i1++) { | |
722 | AliCaloPhoton * ph1=(AliCaloPhoton*)fPHOSEvent1->At(i1) ; | |
723 | if(!ph1->IsTagged()) | |
724 | continue ; | |
725 | snprintf(key,55,"hPhotAll_cen%d",fCenBin) ; | |
726 | FillHistogram(key,ph1->Pt(),-1.) ; | |
6e4947dd | 727 | snprintf(key,55,"hNegPhotAll_cen%d",fCenBin) ; |
728 | FillHistogram(key,ph1->Pt(),-1.) ; | |
729 | snprintf(key,55,"hPhotAllcore_cen%d",fCenBin) ; | |
730 | FillHistogram(key,ph1->GetMomV2()->Pt(),-1.) ; | |
731 | snprintf(key,55,"hNegPhotAllcore_cen%d",fCenBin) ; | |
732 | FillHistogram(key,ph1->GetMomV2()->Pt(),-1.) ; | |
733 | if(ph1->IsPhoton()){ | |
734 | snprintf(key,55,"hPhotAllwou_cen%d",fCenBin) ; | |
735 | FillHistogram(key,ph1->Pt(),-1.) ; | |
736 | snprintf(key,55,"hNegPhotAllwou_cen%d",fCenBin) ; | |
737 | FillHistogram(key,ph1->Pt(),-1.) ; | |
738 | } | |
02f0b8e7 | 739 | if(ph1->IsCPVOK() ){ |
740 | snprintf(key,55,"hPhotCPV_cen%d",fCenBin) ; | |
741 | FillHistogram(key,ph1->Pt(),-1.) ; | |
6e4947dd | 742 | snprintf(key,55,"hNegPhotCPV_cen%d",fCenBin) ; |
743 | FillHistogram(key,ph1->Pt(),-1.) ; | |
744 | snprintf(key,55,"hPhotCPVcore_cen%d",fCenBin) ; | |
745 | FillHistogram(key,ph1->GetMomV2()->Pt(),-1.) ; | |
746 | snprintf(key,55,"hNegPhotCPVcore_cen%d",fCenBin) ; | |
747 | FillHistogram(key,ph1->GetMomV2()->Pt(),-1.) ; | |
748 | } | |
749 | if(ph1->IsCPV2OK() ){ | |
750 | snprintf(key,55,"hPhotCPV2_cen%d",fCenBin) ; | |
751 | FillHistogram(key,ph1->Pt(),-1.) ; | |
752 | snprintf(key,55,"hNegPhotCPV2_cen%d",fCenBin) ; | |
753 | FillHistogram(key,ph1->Pt(),-1.) ; | |
754 | } | |
755 | if(ph1->IsDisp2OK()){ | |
756 | snprintf(key,55,"hPhotDisp2_cen%d",fCenBin) ; | |
757 | FillHistogram(key,ph1->Pt(),-1.) ; | |
758 | snprintf(key,55,"hNegPhotDisp2_cen%d",fCenBin) ; | |
759 | FillHistogram(key,ph1->Pt(),-1.) ; | |
02f0b8e7 | 760 | } |
761 | if(ph1->IsDispOK()){ | |
762 | snprintf(key,55,"hPhotDisp_cen%d",fCenBin) ; | |
763 | FillHistogram(key,ph1->Pt(),-1.) ; | |
6e4947dd | 764 | snprintf(key,55,"hNegPhotDisp_cen%d",fCenBin) ; |
765 | FillHistogram(key,ph1->Pt(),-1.) ; | |
766 | if(ph1->IsPhoton()){ | |
767 | snprintf(key,55,"hPhotDispwou_cen%d",fCenBin) ; | |
768 | FillHistogram(key,ph1->Pt(),-1.) ; | |
769 | snprintf(key,55,"hNegPhotDispwou_cen%d",fCenBin) ; | |
770 | FillHistogram(key,ph1->Pt(),-1.) ; | |
771 | } | |
02f0b8e7 | 772 | if(ph1->IsCPVOK()){ |
773 | snprintf(key,55,"hPhotBoth_cen%d",fCenBin) ; | |
774 | FillHistogram(key,ph1->Pt(),-1.) ; | |
6e4947dd | 775 | snprintf(key,55,"hNegPhotBoth_cen%d",fCenBin) ; |
776 | FillHistogram(key,ph1->Pt(),-1.) ; | |
777 | snprintf(key,55,"hPhotBothcore_cen%d",fCenBin) ; | |
778 | FillHistogram(key,ph1->GetMomV2()->Pt(),-1.) ; | |
779 | snprintf(key,55,"hNegPhotBothcore_cen%d",fCenBin) ; | |
780 | FillHistogram(key,ph1->GetMomV2()->Pt(),-1.) ; | |
02f0b8e7 | 781 | } |
782 | } // end of loop i2 | |
783 | } // end of loop i1 | |
784 | ||
785 | for (Int_t i1=0; i1<inPHOSemb; i1++) { | |
786 | AliCaloPhoton * ph1=(AliCaloPhoton*)fPHOSEvent2->At(i1) ; | |
787 | if(!ph1->IsTagged()) | |
788 | continue ; | |
789 | snprintf(key,55,"hPhotAll_cen%d",fCenBin) ; | |
790 | FillHistogram(key,ph1->Pt(),1.) ; | |
6e4947dd | 791 | snprintf(key,55,"hPhotAllcore_cen%d",fCenBin) ; |
792 | FillHistogram(key,ph1->GetMomV2()->Pt(),1.) ; | |
793 | if(ph1->IsPhoton()){ | |
794 | snprintf(key,55,"hPhotAllwou_cen%d",fCenBin) ; | |
795 | FillHistogram(key,ph1->Pt(),1.) ; | |
796 | } | |
02f0b8e7 | 797 | if(ph1->IsCPVOK() ){ |
798 | snprintf(key,55,"hPhotCPV_cen%d",fCenBin) ; | |
799 | FillHistogram(key,ph1->Pt(),1.) ; | |
6e4947dd | 800 | snprintf(key,55,"hPhotCPVcore_cen%d",fCenBin) ; |
801 | FillHistogram(key,ph1->GetMomV2()->Pt(),1.) ; | |
802 | } | |
803 | if(ph1->IsCPV2OK() ){ | |
804 | snprintf(key,55,"hPhotCPV2_cen%d",fCenBin) ; | |
805 | FillHistogram(key,ph1->Pt(),1.) ; | |
806 | } | |
807 | if(ph1->IsDisp2OK()){ | |
808 | snprintf(key,55,"hPhotDisp2_cen%d",fCenBin) ; | |
809 | FillHistogram(key,ph1->Pt(),1.) ; | |
02f0b8e7 | 810 | } |
811 | if(ph1->IsDispOK()){ | |
812 | snprintf(key,55,"hPhotDisp_cen%d",fCenBin) ; | |
813 | FillHistogram(key,ph1->Pt(),1.) ; | |
6e4947dd | 814 | if(ph1->IsPhoton()){ |
815 | snprintf(key,55,"hPhotDispwou_cen%d",fCenBin) ; | |
816 | FillHistogram(key,ph1->Pt(),1.) ; | |
817 | } | |
02f0b8e7 | 818 | if(ph1->IsCPVOK()){ |
819 | snprintf(key,55,"hPhotBoth_cen%d",fCenBin) ; | |
820 | FillHistogram(key,ph1->Pt(),1.) ; | |
6e4947dd | 821 | snprintf(key,55,"hPhotBothcore_cen%d",fCenBin) ; |
822 | FillHistogram(key,ph1->GetMomV2()->Pt(),1.) ; | |
02f0b8e7 | 823 | } |
824 | } // end of loop i2 | |
825 | } // end of loop i1 | |
826 | ||
827 | ||
828 | ||
829 | // Fill Real disribution: | |
830 | // Disappeared clusters enter with negative contribution | |
831 | // In addition fill control histogam with Real before embedding | |
832 | for (Int_t i1=0; i1<inPHOSold-1; i1++) { | |
833 | AliCaloPhoton * ph1=(AliCaloPhoton*)fPHOSEvent1->At(i1) ; | |
834 | for (Int_t i2=i1+1; i2<inPHOSold; i2++) { | |
835 | AliCaloPhoton * ph2=(AliCaloPhoton*)fPHOSEvent1->At(i2) ; | |
836 | ||
837 | TLorentzVector p12 = *ph1 + *ph2; | |
838 | TLorentzVector pv12 = *(ph1->GetMomV2()) + *(ph2->GetMomV2()); | |
6e4947dd | 839 | Double_t a=TMath::Abs((ph1->E()-ph2->E())/(ph1->E()+ph2->E())) ; |
840 | ||
02f0b8e7 | 841 | //Fill Controll histogram: Real before embedding |
842 | snprintf(key,55,"hOldMassPtAll_cen%d",fCenBin) ; | |
843 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
6e4947dd | 844 | snprintf(key,55,"hOldMassPtAllcore_cen%d",fCenBin) ; |
845 | FillHistogram(key,pv12.M() ,pv12.Pt(),-1.) ; | |
846 | if(ph1->IsPhoton() && ph2->IsPhoton()){ | |
847 | snprintf(key,55,"hOldMassPtAllwou_cen%d",fCenBin) ; | |
848 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
849 | } | |
02f0b8e7 | 850 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ |
851 | snprintf(key,55,"hOldMassPtCPV_cen%d",fCenBin) ; | |
852 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
6e4947dd | 853 | snprintf(key,55,"hOldMassPtCPV_cen%d",fCenBin) ; |
854 | FillHistogram(key,pv12.M(), pv12.Pt(),-1) ; | |
855 | } | |
856 | if(ph1->IsCPV2OK() && ph2->IsCPV2OK()){ | |
857 | snprintf(key,55,"hOldMassPtCPV2_cen%d",fCenBin) ; | |
858 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
859 | } | |
860 | if(ph1->IsDisp2OK() && ph2->IsDisp2OK()){ | |
861 | snprintf(key,55,"hOldMassPtDisp2_cen%d",fCenBin) ; | |
862 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
02f0b8e7 | 863 | } |
864 | if(ph1->IsDispOK() && ph2->IsDispOK()){ | |
865 | snprintf(key,55,"hOldMassPtDisp_cen%d",fCenBin) ; | |
866 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
6e4947dd | 867 | if(ph1->IsPhoton() && ph2->IsPhoton()){ |
868 | snprintf(key,55,"hOldMassPtDispwou_cen%d",fCenBin) ; | |
869 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
870 | } | |
02f0b8e7 | 871 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ |
872 | snprintf(key,55,"hOldMassPtBoth_cen%d",fCenBin) ; | |
873 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
6e4947dd | 874 | snprintf(key,55,"hOldMassPtBothcore_cen%d",fCenBin) ; |
875 | FillHistogram(key,pv12.M() ,pv12.Pt(),-1) ; | |
02f0b8e7 | 876 | } |
877 | } | |
878 | ||
6e4947dd | 879 | //Now fill main histograms with negative contributions |
02f0b8e7 | 880 | if(!(ph1->IsTagged() || ph2->IsTagged()) ) |
881 | continue ; | |
882 | snprintf(key,55,"hMassPtAll_cen%d",fCenBin) ; | |
883 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
6e4947dd | 884 | snprintf(key,55,"hMassPtAllcore_cen%d",fCenBin) ; |
885 | FillHistogram(key,pv12.M() ,pv12.Pt(),-1.) ; | |
886 | if(ph1->IsPhoton() && ph2->IsPhoton()){ | |
887 | snprintf(key,55,"hMassPtAllwou_cen%d",fCenBin) ; | |
888 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
889 | } | |
890 | if(a<0.9){ | |
891 | snprintf(key,55,"hMassPtAll_a09_cen%d",fCenBin) ; | |
892 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
893 | if(a<0.8){ | |
894 | snprintf(key,55,"hMassPtAll_a08_cen%d",fCenBin) ; | |
895 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
896 | if(a<0.7){ | |
897 | snprintf(key,55,"hMassPtAll_a07_cen%d",fCenBin) ; | |
898 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
899 | } | |
900 | } | |
901 | } | |
902 | snprintf(key,55,"hNegMassPtAll_cen%d",fCenBin) ; | |
903 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
904 | snprintf(key,55,"hNegMassPtAllcore_cen%d",fCenBin) ; | |
905 | FillHistogram(key,pv12.M() ,pv12.Pt(),-1.) ; | |
906 | if(ph1->IsPhoton() && ph2->IsPhoton()){ | |
907 | snprintf(key,55,"hNegMassPtAllwou_cen%d",fCenBin) ; | |
908 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
909 | } | |
910 | ||
02f0b8e7 | 911 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ |
912 | snprintf(key,55,"hMassPtCPV_cen%d",fCenBin) ; | |
913 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
6e4947dd | 914 | snprintf(key,55,"hMassPtCPVcore_cen%d",fCenBin) ; |
915 | FillHistogram(key,pv12.M() ,pv12.Pt(),-1) ; | |
916 | if(a<0.9){ | |
917 | snprintf(key,55,"hMassPtCPV_a09_cen%d",fCenBin) ; | |
918 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
919 | if(a<0.8){ | |
920 | snprintf(key,55,"hMassPtCPV_a08_cen%d",fCenBin) ; | |
921 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
922 | if(a<0.7){ | |
923 | snprintf(key,55,"hMassPtCPV_a07_cen%d",fCenBin) ; | |
924 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
925 | } | |
926 | } | |
927 | } | |
928 | snprintf(key,55,"hNegMassPtCPV_cen%d",fCenBin) ; | |
929 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
930 | snprintf(key,55,"hNegMassPtCPVcore_cen%d",fCenBin) ; | |
931 | FillHistogram(key,pv12.M() ,pv12.Pt(),-1) ; | |
932 | } | |
933 | if(ph1->IsCPV2OK() && ph2->IsCPV2OK()){ | |
934 | snprintf(key,55,"hMassPtCPV2_cen%d",fCenBin) ; | |
935 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
936 | if(a<0.9){ | |
937 | snprintf(key,55,"hMassPtCPV2_a09_cen%d",fCenBin) ; | |
938 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
939 | if(a<0.8){ | |
940 | snprintf(key,55,"hMassPtCPV2_a08_cen%d",fCenBin) ; | |
941 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
942 | if(a<0.7){ | |
943 | snprintf(key,55,"hMassPtCPV2_a07_cen%d",fCenBin) ; | |
944 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
945 | } | |
946 | } | |
947 | } | |
948 | snprintf(key,55,"hNegMassPtCPV2_cen%d",fCenBin) ; | |
949 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
950 | } | |
951 | ||
952 | if(ph1->IsDisp2OK() && ph2->IsDisp2OK()){ | |
953 | snprintf(key,55,"hMassPtDisp2_cen%d",fCenBin) ; | |
954 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
02f0b8e7 | 955 | } |
956 | if(ph1->IsDispOK() && ph2->IsDispOK()){ | |
957 | snprintf(key,55,"hMassPtDisp_cen%d",fCenBin) ; | |
958 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
6e4947dd | 959 | if(ph1->IsPhoton() && ph2->IsPhoton()){ |
960 | snprintf(key,55,"hMassPtDispwou_cen%d",fCenBin) ; | |
961 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
962 | } | |
963 | if(a<0.9){ | |
964 | snprintf(key,55,"hMassPtDisp_a09_cen%d",fCenBin) ; | |
965 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
966 | if(a<0.8){ | |
967 | snprintf(key,55,"hMassPtDisp_a08_cen%d",fCenBin) ; | |
968 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
969 | if(a<0.7){ | |
970 | snprintf(key,55,"hMassPtDisp_a07_cen%d",fCenBin) ; | |
971 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
972 | } | |
973 | } | |
974 | } | |
975 | snprintf(key,55,"hNegMassPtDisp_cen%d",fCenBin) ; | |
976 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
977 | if(ph1->IsPhoton() && ph2->IsPhoton()){ | |
978 | snprintf(key,55,"hNegMassPtDispwou_cen%d",fCenBin) ; | |
979 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
980 | } | |
02f0b8e7 | 981 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ |
982 | snprintf(key,55,"hMassPtBoth_cen%d",fCenBin) ; | |
983 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
6e4947dd | 984 | snprintf(key,55,"hMassPtBothcore_cen%d",fCenBin) ; |
985 | FillHistogram(key,pv12.M() ,pv12.Pt(),-1) ; | |
986 | if(a<0.9){ | |
987 | snprintf(key,55,"hMassPtBoth_a09_cen%d",fCenBin) ; | |
988 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
989 | if(a<0.8){ | |
990 | snprintf(key,55,"hMassPtBoth_a08_cen%d",fCenBin) ; | |
991 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
992 | if(a<0.7){ | |
993 | snprintf(key,55,"hMassPtBoth_a07_cen%d",fCenBin) ; | |
994 | FillHistogram(key,p12.M() ,p12.Pt(),-1.) ; | |
995 | } | |
996 | } | |
997 | } | |
998 | snprintf(key,55,"hNegMassPtBoth_cen%d",fCenBin) ; | |
999 | FillHistogram(key,p12.M() ,p12.Pt(),-1) ; | |
1000 | snprintf(key,55,"hNegMassPtBothcore_cen%d",fCenBin) ; | |
1001 | FillHistogram(key,pv12.M() ,pv12.Pt(),-1) ; | |
02f0b8e7 | 1002 | } |
1003 | } | |
1004 | } // end of loop i2 | |
1005 | } // end of loop i1 | |
1006 | ||
1007 | ||
1008 | // Further fill Real disribution | |
1009 | // now with positive contribution from new clusters | |
1010 | // ass well fill controll histogram | |
1011 | for (Int_t i1=0; i1<inPHOSemb-1; i1++) { | |
1012 | AliCaloPhoton * ph1=(AliCaloPhoton*)fPHOSEvent2->At(i1) ; | |
1013 | for (Int_t i2=i1+1; i2<inPHOSemb; i2++) { | |
1014 | AliCaloPhoton * ph2=(AliCaloPhoton*)fPHOSEvent2->At(i2) ; | |
1015 | ||
1016 | TLorentzVector p12 = *ph1 + *ph2; | |
1017 | TLorentzVector pv12 = *(ph1->GetMomV2()) + *(ph2->GetMomV2()); | |
6e4947dd | 1018 | Double_t a=TMath::Abs((ph1->E()-ph2->E())/(ph1->E()+ph2->E())) ; |
02f0b8e7 | 1019 | |
1020 | // Controll histogram: Real after embedding | |
1021 | snprintf(key,55,"hNewMassPtAll_cen%d",fCenBin) ; | |
1022 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
6e4947dd | 1023 | snprintf(key,55,"hNewMassPtAllcore_cen%d",fCenBin) ; |
1024 | FillHistogram(key,pv12.M() ,pv12.Pt(),1.) ; | |
1025 | if(ph1->IsPhoton() && ph2->IsPhoton()){ | |
1026 | snprintf(key,55,"hNewMassPtAllwou_cen%d",fCenBin) ; | |
1027 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
1028 | } | |
02f0b8e7 | 1029 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ |
1030 | snprintf(key,55,"hNewMassPtCPV_cen%d",fCenBin) ; | |
1031 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
6e4947dd | 1032 | snprintf(key,55,"hNewMassPtCPVcore_cen%d",fCenBin) ; |
1033 | FillHistogram(key,pv12.M() ,pv12.Pt(),1) ; | |
1034 | } | |
1035 | if(ph1->IsCPV2OK() && ph2->IsCPV2OK()){ | |
1036 | snprintf(key,55,"hNewMassPtCPV2_cen%d",fCenBin) ; | |
1037 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
1038 | } | |
1039 | if(ph1->IsDisp2OK() && ph2->IsDisp2OK()){ | |
1040 | snprintf(key,55,"hNewMassPtDisp2_cen%d",fCenBin) ; | |
1041 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
02f0b8e7 | 1042 | } |
1043 | if(ph1->IsDispOK() && ph2->IsDispOK()){ | |
1044 | snprintf(key,55,"hNewMassPtDisp_cen%d",fCenBin) ; | |
1045 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
6e4947dd | 1046 | if(ph1->IsPhoton() && ph2->IsPhoton()){ |
1047 | snprintf(key,55,"hNewMassPtDispwou_cen%d",fCenBin) ; | |
1048 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
1049 | } | |
02f0b8e7 | 1050 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ |
1051 | snprintf(key,55,"hNewMassPtBoth_cen%d",fCenBin) ; | |
1052 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
6e4947dd | 1053 | snprintf(key,55,"hNewMassPtBothcore_cen%d",fCenBin) ; |
1054 | FillHistogram(key,pv12.M() ,pv12.Pt(),1) ; | |
02f0b8e7 | 1055 | } |
1056 | } | |
1057 | ||
1058 | //Now fill main histogamm | |
1059 | //new clusters with positive contribution | |
1060 | if(!(ph1->IsTagged() || ph2->IsTagged()) ) | |
1061 | continue ; | |
1062 | snprintf(key,55,"hMassPtAll_cen%d",fCenBin) ; | |
1063 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
6e4947dd | 1064 | snprintf(key,55,"hMassPtAllcore_cen%d",fCenBin) ; |
1065 | FillHistogram(key,pv12.M() ,pv12.Pt(),1.) ; | |
1066 | if(ph1->IsPhoton() && ph2->IsPhoton()){ | |
1067 | snprintf(key,55,"hMassPtAllwou_cen%d",fCenBin) ; | |
1068 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
1069 | } | |
1070 | if(a<0.9){ | |
1071 | snprintf(key,55,"hMassPtAll_a09_cen%d",fCenBin) ; | |
1072 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1073 | if(a<0.8){ | |
1074 | snprintf(key,55,"hMassPtAll_a08_cen%d",fCenBin) ; | |
1075 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1076 | if(a<0.7){ | |
1077 | snprintf(key,55,"hMassPtAll_a07_cen%d",fCenBin) ; | |
1078 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1079 | } | |
1080 | } | |
1081 | } | |
02f0b8e7 | 1082 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ |
1083 | snprintf(key,55,"hMassPtCPV_cen%d",fCenBin) ; | |
1084 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
6e4947dd | 1085 | snprintf(key,55,"hMassPtCPVcore_cen%d",fCenBin) ; |
1086 | FillHistogram(key,pv12.M() ,pv12.Pt(),1) ; | |
1087 | if(a<0.9){ | |
1088 | snprintf(key,55,"hMassPtCPV_a09_cen%d",fCenBin) ; | |
1089 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1090 | if(a<0.8){ | |
1091 | snprintf(key,55,"hMassPtCPV_a08_cen%d",fCenBin) ; | |
1092 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1093 | if(a<0.7){ | |
1094 | snprintf(key,55,"hMassPtCPV_a07_cen%d",fCenBin) ; | |
1095 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1096 | } | |
1097 | } | |
1098 | } | |
1099 | } | |
1100 | if(ph1->IsCPV2OK() && ph2->IsCPV2OK()){ | |
1101 | snprintf(key,55,"hMassPtCPV2_cen%d",fCenBin) ; | |
1102 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
1103 | if(a<0.9){ | |
1104 | snprintf(key,55,"hMassPtCPV2_a09_cen%d",fCenBin) ; | |
1105 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1106 | if(a<0.8){ | |
1107 | snprintf(key,55,"hMassPtCPV2_a08_cen%d",fCenBin) ; | |
1108 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1109 | if(a<0.7){ | |
1110 | snprintf(key,55,"hMassPtCPV2_a07_cen%d",fCenBin) ; | |
1111 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1112 | } | |
1113 | } | |
1114 | } | |
1115 | } | |
1116 | if(ph1->IsDisp2OK() && ph2->IsDisp2OK()){ | |
1117 | snprintf(key,55,"hMassPtDisp2_cen%d",fCenBin) ; | |
1118 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
02f0b8e7 | 1119 | } |
1120 | if(ph1->IsDispOK() && ph2->IsDispOK()){ | |
1121 | snprintf(key,55,"hMassPtDisp_cen%d",fCenBin) ; | |
1122 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
6e4947dd | 1123 | if(ph1->IsPhoton() && ph2->IsPhoton()){ |
1124 | snprintf(key,55,"hMassPtDispwou_cen%d",fCenBin) ; | |
1125 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
1126 | } | |
1127 | if(a<0.9){ | |
1128 | snprintf(key,55,"hMassPtDisp_a09_cen%d",fCenBin) ; | |
1129 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1130 | if(a<0.8){ | |
1131 | snprintf(key,55,"hMassPtDisp_a08_cen%d",fCenBin) ; | |
1132 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1133 | if(a<0.7){ | |
1134 | snprintf(key,55,"hMassPtDisp_a07_cen%d",fCenBin) ; | |
1135 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1136 | } | |
1137 | } | |
1138 | } | |
02f0b8e7 | 1139 | |
1140 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ | |
1141 | snprintf(key,55,"hMassPtBoth_cen%d",fCenBin) ; | |
1142 | FillHistogram(key,p12.M() ,p12.Pt(),1) ; | |
6e4947dd | 1143 | snprintf(key,55,"hMassPtBothcore_cen%d",fCenBin) ; |
1144 | FillHistogram(key,pv12.M() ,pv12.Pt(),1) ; | |
1145 | if(a<0.9){ | |
1146 | snprintf(key,55,"hMassPtBoth_a09_cen%d",fCenBin) ; | |
1147 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1148 | if(a<0.8){ | |
1149 | snprintf(key,55,"hMassPtBoth_a08_cen%d",fCenBin) ; | |
1150 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1151 | if(a<0.7){ | |
1152 | snprintf(key,55,"hMassPtBoth_a07_cen%d",fCenBin) ; | |
1153 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1154 | } | |
1155 | } | |
1156 | } | |
02f0b8e7 | 1157 | } |
1158 | } | |
1159 | } // end of loop i2 | |
1160 | } // end of loop i1 | |
1161 | ||
1162 | ||
1163 | //now mixed, does not really matter old or new list of clusters | |
1164 | for (Int_t i1=0; i1<inPHOSemb; i1++) { | |
1165 | AliCaloPhoton * ph1=(AliCaloPhoton*)fPHOSEvent2->At(i1) ; | |
1166 | for(Int_t ev=0; ev<prevPHOS->GetSize();ev++){ | |
1167 | TClonesArray * mixPHOS = static_cast<TClonesArray*>(prevPHOS->At(ev)) ; | |
1168 | for(Int_t i2=0; i2<mixPHOS->GetEntriesFast();i2++){ | |
1169 | AliCaloPhoton * ph2=(AliCaloPhoton*)mixPHOS->At(i2) ; | |
1170 | TLorentzVector p12 = *ph1 + *ph2; | |
1171 | TLorentzVector pv12 = *(ph1->GetMomV2()) + *(ph2->GetMomV2()); | |
6e4947dd | 1172 | Double_t a=TMath::Abs((ph1->E()-ph2->E())/(ph1->E()+ph2->E())) ; |
02f0b8e7 | 1173 | |
1174 | snprintf(key,55,"hMiMassPtAll_cen%d",fCenBin) ; | |
1175 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
6e4947dd | 1176 | snprintf(key,55,"hMiMassPtAllcore_cen%d",fCenBin) ; |
1177 | FillHistogram(key,pv12.M() ,pv12.Pt(),1.) ; | |
1178 | if(ph1->IsPhoton() && ph2->IsPhoton()){ | |
1179 | snprintf(key,55,"hMiMassPtAllwou_cen%d",fCenBin) ; | |
1180 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
1181 | } | |
1182 | if(a<0.9){ | |
1183 | snprintf(key,55,"hMiMassPtAll_a09_cen%d",fCenBin) ; | |
1184 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1185 | if(a<0.8){ | |
1186 | snprintf(key,55,"hMiMassPtAll_a08_cen%d",fCenBin) ; | |
1187 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1188 | if(a<0.7){ | |
1189 | snprintf(key,55,"hMiMassPtAll_a07_cen%d",fCenBin) ; | |
1190 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1191 | } | |
1192 | } | |
1193 | } | |
02f0b8e7 | 1194 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ |
1195 | snprintf(key,55,"hMiMassPtCPV_cen%d",fCenBin) ; | |
1196 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
6e4947dd | 1197 | snprintf(key,55,"hMiMassPtCPVcore_cen%d",fCenBin) ; |
1198 | FillHistogram(key,pv12.M() ,pv12.Pt(),1.) ; | |
1199 | if(a<0.9){ | |
1200 | snprintf(key,55,"hMiMassPtCPV_a09_cen%d",fCenBin) ; | |
1201 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1202 | if(a<0.8){ | |
1203 | snprintf(key,55,"hMiMassPtCPV_a08_cen%d",fCenBin) ; | |
1204 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1205 | if(a<0.7){ | |
1206 | snprintf(key,55,"hMiMassPtCPV_a07_cen%d",fCenBin) ; | |
1207 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1208 | } | |
1209 | } | |
1210 | } | |
1211 | } | |
1212 | if(ph1->IsCPV2OK() && ph2->IsCPV2OK()){ | |
1213 | snprintf(key,55,"hMiMassPtCPV2_cen%d",fCenBin) ; | |
1214 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
1215 | if(a<0.9){ | |
1216 | snprintf(key,55,"hMiMassPtCPV2_a09_cen%d",fCenBin) ; | |
1217 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1218 | if(a<0.8){ | |
1219 | snprintf(key,55,"hMiMassPtCPV2_a08_cen%d",fCenBin) ; | |
1220 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1221 | if(a<0.7){ | |
1222 | snprintf(key,55,"hMiMassPtCPV2_a07_cen%d",fCenBin) ; | |
1223 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1224 | } | |
1225 | } | |
1226 | } | |
1227 | } | |
1228 | if(ph1->IsDisp2OK() && ph2->IsDisp2OK()){ | |
1229 | snprintf(key,55,"hMiMassPtDisp2_cen%d",fCenBin) ; | |
1230 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
02f0b8e7 | 1231 | } |
1232 | if(ph1->IsDispOK() && ph2->IsDispOK()){ | |
1233 | snprintf(key,55,"hMiMassPtDisp_cen%d",fCenBin) ; | |
1234 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
6e4947dd | 1235 | if(ph1->IsPhoton() && ph2->IsPhoton()){ |
1236 | snprintf(key,55,"hMiMassPtDispwou_cen%d",fCenBin) ; | |
1237 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
1238 | } | |
1239 | if(a<0.9){ | |
1240 | snprintf(key,55,"hMiMassPtDisp_a09_cen%d",fCenBin) ; | |
1241 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1242 | if(a<0.8){ | |
1243 | snprintf(key,55,"hMiMassPtDisp_a08_cen%d",fCenBin) ; | |
1244 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1245 | if(a<0.7){ | |
1246 | snprintf(key,55,"hMiMassPtDisp_a07_cen%d",fCenBin) ; | |
1247 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1248 | } | |
1249 | } | |
1250 | } | |
02f0b8e7 | 1251 | |
1252 | if(ph1->IsCPVOK() && ph2->IsCPVOK()){ | |
1253 | snprintf(key,55,"hMiMassPtBoth_cen%d",fCenBin) ; | |
1254 | FillHistogram(key,p12.M() ,p12.Pt(),1.) ; | |
6e4947dd | 1255 | snprintf(key,55,"hMiMassPtBothcore_cen%d",fCenBin) ; |
1256 | FillHistogram(key,pv12.M() ,pv12.Pt(),1.) ; | |
1257 | if(a<0.9){ | |
1258 | snprintf(key,55,"hMiMassPtBoth_a09_cen%d",fCenBin) ; | |
1259 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1260 | if(a<0.8){ | |
1261 | snprintf(key,55,"hMiMassPtBoth_a08_cen%d",fCenBin) ; | |
1262 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1263 | if(a<0.7){ | |
1264 | snprintf(key,55,"hMiMassPtBoth_a07_cen%d",fCenBin) ; | |
1265 | FillHistogram(key,p12.M() ,p12.Pt()) ; | |
1266 | } | |
1267 | } | |
1268 | } | |
02f0b8e7 | 1269 | } |
1270 | } | |
1271 | } // end of loop i2 | |
1272 | } | |
1273 | } // end of loop i1 | |
1274 | ||
1275 | ||
1276 | //Now we either add current events to stack or remove | |
1277 | //If no photons in current event - no need to add it to mixed | |
1278 | if(fPHOSEvent2->GetEntriesFast()>0){ | |
1279 | prevPHOS->AddFirst(fPHOSEvent2) ; | |
1280 | fPHOSEvent2=0; | |
1281 | delete fPHOSEvent1; | |
1282 | fPHOSEvent1=0; | |
1283 | if(prevPHOS->GetSize()>100){//Remove redundant events | |
1284 | TClonesArray * tmp = static_cast<TClonesArray*>(prevPHOS->Last()) ; | |
1285 | prevPHOS->RemoveLast() ; | |
1286 | delete tmp ; | |
1287 | } | |
1288 | } | |
1289 | // Post output data. | |
1290 | PostData(1, fOutputContainer); | |
1291 | fEventCounter++; | |
1292 | } | |
02f0b8e7 | 1293 | //___________________________________________________________________________ |
1294 | Bool_t AliAnalysisTaskPi0DiffEfficiency::IsSameCluster(AliAODCaloCluster * c1, AliAODCaloCluster * c2)const{ | |
1295 | //Compare clusters before and after embedding | |
1296 | //clusters are the same if | |
1297 | // - Energy changed less than 0.1% (numerical accuracy in reconstruction) | |
1298 | // - lists of digits are the same | |
1299 | ||
1300 | if(c1->GetNCells() != c2->GetNCells()) | |
1301 | return kFALSE ; | |
1302 | ||
6e4947dd | 1303 | if(TMath::Abs(c1->E()-c2->E())>0.01*c1->E()) |
02f0b8e7 | 1304 | return kFALSE ; |
1305 | ||
1306 | UShort_t *list1 = c1->GetCellsAbsId() ; | |
1307 | UShort_t *list2 = c2->GetCellsAbsId() ; | |
1308 | for(Int_t i=0; i<c1->GetNCells(); i++){ | |
1309 | if(list1[i] != list2[i]) | |
1310 | return kFALSE ; | |
1311 | } | |
1312 | return kTRUE ; | |
1313 | ||
1314 | } | |
1315 | ||
1316 | ||
1317 |