]>
Commit | Line | Data |
---|---|---|
44a84424 | 1 | //-*- Mode: C++ -*- |
2 | ||
3 | #if __GNUC__>= 3 | |
4 | using namespace std; | |
5 | #endif | |
6 | ||
7 | #include "TH1F.h" | |
8 | #include "TH2F.h" | |
9 | #include "TList.h" | |
10 | ||
11 | #include "AliMultiplicityCorrelations.h" | |
12 | ||
13 | // Task for HI Multiplicity correlation checks | |
14 | // Author: Jochen Thaeder <jochen@thaeder.de> | |
15 | ||
16 | /** ROOT macro for the implementation of ROOT specific class methods */ | |
17 | ClassImp(AliMultiplicityCorrelations) | |
18 | ||
19 | /* | |
20 | * --------------------------------------------------------------------------------- | |
21 | * Constructor / Destructor | |
22 | * --------------------------------------------------------------------------------- | |
23 | */ | |
24 | ||
25 | //################################################################################## | |
26 | AliMultiplicityCorrelations::AliMultiplicityCorrelations() : | |
27 | TNamed(), | |
28 | fHistList(NULL), | |
29 | fIsMC(kFALSE), | |
30 | fESDEvent(NULL), | |
31 | fESDZDC(NULL), fESDVZERO(NULL), fESDMultiplicity(NULL), | |
32 | fESDTrackCuts(NULL), fESDTrackCuts2(NULL), | |
33 | fCleanSample(kFALSE), fCleanMinKeep(0.),fCleanMaxKeep(999999999.), | |
34 | fRunNo(-1), fCurrentRunNo(-1), | |
35 | fProcessTPC(kTRUE), fProcessSPD(kTRUE), fProcessVZERO(kTRUE), fProcessZDC(kTRUE), | |
36 | fEsdTracks(0), fEsdTracksA(0), fTpcTracks(0), fTpcTracksA(0), | |
37 | fVzeroMult(0.), fVzeroMultA(0.), fVzeroMultC(0.), | |
38 | fSpdNClusters(0), fSpdNClustersInner(0), fSpdNClustersOuter(0), | |
39 | fVzeroBinning(1500), fVzeroBinningMin(0.), fVzeroBinningMax(30000.), | |
40 | fTpcBinning(800),fTpcBinningMin(0.),fTpcBinningMax(8000.), | |
41 | fZdcBinning(1000),fZdcBinningMin(0.),fZdcBinningMax(6000.), | |
42 | fZemBinning(500),fZemBinningMin(0.),fZemBinningMax(2500.), | |
43 | fSpdBinning(750),fSpdBinningMin(0.),fSpdBinningMax(15000.) { | |
44 | // see header file for class documentation | |
45 | ||
46 | } | |
47 | //################################################################################## | |
48 | AliMultiplicityCorrelations::AliMultiplicityCorrelations(Char_t* name, Char_t* title) : | |
49 | TNamed(name,title), | |
50 | fHistList(NULL), | |
51 | fIsMC(kFALSE), | |
52 | fESDEvent(NULL), | |
53 | fESDZDC(NULL), fESDVZERO(NULL), fESDMultiplicity(NULL), | |
54 | fESDTrackCuts(NULL), fESDTrackCuts2(NULL), | |
55 | fCleanSample(kFALSE), fCleanMinKeep(0.),fCleanMaxKeep(999999999.), | |
56 | fRunNo(-1), fCurrentRunNo(-1), | |
57 | fProcessTPC(kTRUE), fProcessSPD(kTRUE),fProcessVZERO(kTRUE), fProcessZDC(kTRUE), | |
58 | fEsdTracks(0), fEsdTracksA(0), fTpcTracks(0), fTpcTracksA(0), | |
59 | fVzeroMult(0.), fVzeroMultA(0.), fVzeroMultC(0.), | |
60 | fSpdNClusters(0), fSpdNClustersInner(0), fSpdNClustersOuter(0), | |
61 | fVzeroBinning(1000), fVzeroBinningMin(0.), fVzeroBinningMax(20000.), | |
62 | fTpcBinning(800),fTpcBinningMin(0.),fTpcBinningMax(8000.), | |
63 | fZdcBinning(280),fZdcBinningMin(0.),fZdcBinningMax(140.), | |
64 | fZemBinning(100),fZemBinningMin(0.),fZemBinningMax(5.), | |
65 | fSpdBinning(750),fSpdBinningMin(0.),fSpdBinningMax(15000.) { | |
66 | // see header file for class documentation | |
67 | ||
68 | } | |
69 | ||
70 | //################################################################################## | |
71 | AliMultiplicityCorrelations::~AliMultiplicityCorrelations() { | |
72 | // see header file for class documentation | |
73 | ||
74 | if ( fHistList ) { | |
75 | fHistList->Clear(); | |
76 | delete fHistList; | |
77 | } | |
78 | fHistList = NULL; | |
79 | } | |
80 | ||
81 | /* | |
82 | * --------------------------------------------------------------------------------- | |
83 | * Initialize / Reset | |
84 | * --------------------------------------------------------------------------------- | |
85 | */ | |
86 | ||
87 | //################################################################################## | |
88 | Int_t AliMultiplicityCorrelations::Initialize( const Char_t* listName) { | |
89 | // see header file for class documentation | |
90 | ||
91 | Int_t iResult = 0; | |
92 | ||
93 | fHistList = new TList(); | |
94 | fHistList->SetOwner(kTRUE); | |
95 | fHistList->SetName(Form("MultiplicityCorrelations_%s",listName)); | |
96 | iResult = SetupHistograms(); | |
97 | ||
98 | if (fProcessZDC) { AliInfo("Processing of ZDC enabled"); } | |
99 | if (fProcessTPC) { AliInfo("Processing of TPC enabled"); } | |
100 | if (fProcessSPD) { AliInfo("Processing of SPD enabled"); } | |
101 | if (fProcessVZERO) { AliInfo("Processing of VZERO enabled"); } | |
102 | ||
103 | return iResult; | |
104 | } | |
105 | ||
106 | /* | |
107 | * --------------------------------------------------------------------------------- | |
108 | * Output - public | |
109 | * --------------------------------------------------------------------------------- | |
110 | */ | |
111 | ||
112 | //################################################################################## | |
113 | Int_t AliMultiplicityCorrelations::ProcessEvent(AliESDEvent *esd) { | |
114 | // see header file for class documentation | |
115 | ||
116 | Int_t iResult = 0; | |
117 | ||
118 | if ( ! AddESDEvent(esd) ) { | |
119 | AliWarning("No ESD event."); | |
120 | return -1; | |
121 | } | |
122 | ||
123 | // -- TPC .. To be done before the others | |
124 | if (fESDEvent->GetNumberOfTracks() > 0 && fProcessTPC) | |
125 | iResult = ProcessTPC(); | |
126 | ||
127 | // -- TPC / global track cuts | |
128 | if (iResult == -3) | |
129 | return iResult; | |
130 | ||
131 | // -- check if cleaning | |
132 | if (iResult == -2) | |
133 | return iResult; | |
134 | ||
135 | // -- SPD | |
136 | if (fESDMultiplicity && fProcessSPD) | |
137 | iResult = ProcessSPD(); | |
138 | ||
139 | // -- VZERO | |
140 | if (fESDVZERO && fProcessVZERO) | |
141 | iResult = ProcessVZERO(); | |
142 | ||
143 | // -- ZDC and Correlations | |
144 | if (fESDZDC && fProcessZDC) | |
145 | iResult = ProcessZDC(); | |
146 | ||
147 | return iResult; | |
148 | } | |
149 | ||
150 | //////////////////////////////////////////////////////////////////////////////////// | |
151 | //////////////////////////////////////////////////////////////////////////////////// | |
152 | /// /// | |
153 | ////// PRIVATE ////// | |
154 | /// /// | |
155 | //////////////////////////////////////////////////////////////////////////////////// | |
156 | //////////////////////////////////////////////////////////////////////////////////// | |
157 | ||
158 | /* | |
159 | * --------------------------------------------------------------------------------- | |
160 | * Setup / Initialize - private | |
161 | * --------------------------------------------------------------------------------- | |
162 | */ | |
163 | ||
164 | //################################################################################## | |
165 | Bool_t AliMultiplicityCorrelations::AddESDEvent( AliESDEvent* esd ) { | |
166 | // see header file for class documentation | |
167 | ||
168 | fESDEvent = esd; | |
169 | ||
170 | // -- Check for ESD | |
171 | if ( !fESDEvent ) { | |
172 | AliWarning("No ESD event present."); | |
173 | return kFALSE; | |
174 | } | |
175 | ||
176 | fESDZDC = esd->GetESDZDC(); | |
177 | if ( !fESDZDC ) { | |
178 | AliInfo("No ZDC information !"); | |
179 | } | |
180 | ||
181 | fESDVZERO = esd->GetVZEROData(); | |
182 | if ( !fESDVZERO ) { | |
183 | AliInfo("No VZERO information !"); | |
184 | } | |
185 | ||
186 | fESDMultiplicity = const_cast<AliMultiplicity*>(esd->GetMultiplicity()); | |
187 | if ( !fESDMultiplicity ) { | |
188 | AliInfo("No Multiplicity information !"); | |
189 | } | |
190 | ||
191 | if (fCurrentRunNo == esd->GetRunNumber()) | |
192 | return kTRUE; | |
193 | ||
194 | fCurrentRunNo = esd->GetRunNumber(); | |
195 | fRunNo = fCurrentRunNo; | |
196 | ||
197 | // CHANGE HERE FOR RUN RANGES | |
198 | if ( fRunNo == 137162 ) fRunNo = 137161; | |
199 | else if ( fRunNo == 137365 ) fRunNo = 137366; | |
200 | else if ( fRunNo > 137366 ) fRunNo = 137366; | |
201 | // CHANGE HERE FOR RUN RANGES | |
202 | ||
203 | return kTRUE; | |
204 | } | |
205 | ||
206 | //################################################################################## | |
207 | Int_t AliMultiplicityCorrelations::SetupHistograms() { | |
208 | // see header file for class documentation | |
209 | ||
210 | Int_t iResult = 0; | |
211 | ||
212 | if (fProcessVZERO) iResult = SetupVZERO(); | |
213 | if (fProcessZDC) iResult = SetupZDC(); | |
214 | if (fProcessTPC) iResult = SetupTPC(); | |
215 | if (fProcessSPD) iResult = SetupSPD(); | |
216 | ||
217 | iResult = SetupCorrelations(); | |
218 | ||
219 | return iResult; | |
220 | } | |
221 | ||
222 | //################################################################################## | |
223 | Int_t AliMultiplicityCorrelations::SetupVZERO() { | |
224 | // see header file for class documentation | |
225 | ||
226 | // VzeroMult | |
227 | fHistList->Add(new TH1F("fVzeroMult", "Multiplicity^{VZERO};Multiplicity^{VZERO};N_{Events}", | |
228 | fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
229 | ||
230 | fHistList->Add(new TH1F("fVzeroMultUnCorr", "Multiplicity^{VZERO} uncorrected;Multiplicity^{VZERO};N_{Events}", | |
231 | fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
232 | ||
233 | fHistList->Add(new TH2F("fVzeroMultAC", "Multiplicity^{VZERO} A vs C;Multiplicity^{VZERO}A ;Multiplicity^{VZERO} C", | |
234 | fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
235 | ||
236 | return 0; | |
237 | } | |
238 | ||
239 | //################################################################################## | |
240 | Int_t AliMultiplicityCorrelations::SetupZDC() { | |
241 | // see header file for class documentation | |
242 | ||
243 | // E_{ZDC} | |
244 | fHistList->Add(new TH1F("fZdcEzdc", "E_{ZDC};E_{ZDC} (TeV);N_{Events}", | |
245 | fZdcBinning,fZdcBinningMin,fZdcBinningMax)); | |
246 | ||
247 | // E_{ZEM} | |
248 | fHistList->Add(new TH1F("fZdcEzem", "E_{ZEM};E_{ZEM} (TeV);N_{Events}", | |
249 | fZemBinning,fZemBinningMin,fZemBinningMax)); | |
250 | ||
251 | // E_{ZEM} vs E_{ZDC} | |
252 | fHistList->Add(new TH2F("fZdcEzemEzdc", "E_{ZEM} vs E_{ZDC};E_{ZEM} (TeV); E_{ZDC} (TeV)", | |
253 | fZemBinning,fZemBinningMin,fZemBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax)); | |
254 | ||
255 | return 0; | |
256 | } | |
257 | ||
258 | //################################################################################## | |
259 | Int_t AliMultiplicityCorrelations::SetupTPC() { | |
260 | // see header file for class documentation | |
261 | ||
262 | // Multiplicity | |
263 | fHistList->Add(new TH1F("fTpcNch0", "N_{ch} esdTracks; N_{ch};N_{Events}", | |
264 | fTpcBinning,fTpcBinningMin,fTpcBinningMax)); | |
265 | fHistList->Add(new TH1F("fTpcNch1", "N_{ch} accepted esdTracks; N_{ch};N_{Events}", | |
266 | fTpcBinning,fTpcBinningMin,fTpcBinningMax)); | |
267 | fHistList->Add(new TH1F("fTpcNch2", "N_{ch} tpcTracks; N_{ch};N_{Events}", | |
268 | fTpcBinning,fTpcBinningMin,fTpcBinningMax)); | |
269 | fHistList->Add(new TH1F("fTpcNch3", "N_{ch} accepted tpcTracks; N_{ch};N_{Events}", | |
270 | fTpcBinning,fTpcBinningMin,fTpcBinningMax)); | |
271 | ||
272 | fHistList->Add(new TH2F("fTpcCorrNch","N_{ch} accepted tpcTracks vs globalTracks; N_{tpc};N_{global}", | |
273 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax)); | |
274 | ||
275 | fHistList->Add(new TH1F("fTpcRatioNch","N_{ch} accepted tpcTracks/globalTracks; N_{ch};Ratio", | |
276 | 201,0.,2.)); | |
277 | ||
278 | fHistList->Add(new TH2F("fTpcCorrNchAll","N_{ch} accepted tpcTracks vs globalTracks - uncleaned ; N_{tpc};N_{global}", | |
279 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax)); | |
280 | ||
281 | fHistList->Add(new TH1F("fTpcRatioNchAll","N_{ch} accepted tpcTracks/globalTracks - uncleaned; N_{ch};Ratio", | |
282 | 201,0.,2.)); | |
283 | ||
284 | return 0; | |
285 | } | |
286 | ||
287 | //################################################################################## | |
288 | Int_t AliMultiplicityCorrelations::SetupCorrelations() { | |
289 | // see header file for class documentation | |
290 | ||
291 | // ---------------------------------------------------- | |
292 | // TPC vs ZDC | |
293 | // ---------------------------------------------------- | |
294 | if (fProcessTPC && fProcessZDC) { | |
295 | ||
296 | // N_{ch} vs E_{ZDC} | |
297 | fHistList->Add(new TH2F("fCorrEzdcNch", "N_{ch}^{TPC} vs E_{ZDC};N_{ch}^{TPC};E_{ZDC} (TeV)", | |
298 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax)); | |
299 | ||
300 | ||
301 | // N_{ch} vs E_{ZEM} | |
302 | fHistList->Add(new TH2F("fCorrEzemNch", "N_{ch}^{TPC} vs E_{ZEM};N_{ch}^{TPC};E_{ZEM} (TeV)", | |
303 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax)); | |
304 | } | |
305 | // ---------------------------------------------------- | |
306 | // ZDC vs VZERO | |
307 | // ---------------------------------------------------- | |
308 | if (fProcessZDC && fProcessVZERO) { | |
309 | ||
310 | // E_{ZDC} vs Multiplicity VZERO | |
311 | fHistList->Add(new TH2F("fCorrEzdcVzero", | |
312 | "E_{ZDC} vs Multiplicity^{VZERO};E_{ZDC} (TeV);Multiplicity^{VZERO}", | |
313 | fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
314 | ||
315 | // E_{ZEM} vs Multiplicity VZERO | |
316 | fHistList->Add(new TH2F("fCorrEzemVzero", | |
317 | "E_{ZEM} vs Multiplicity^{VZERO};E_{ZEM} (TeV);Multiplicity^{VZERO}", | |
318 | fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
319 | ||
320 | } | |
321 | // ---------------------------------------------------- | |
322 | // TPC vs VZERO | |
323 | // ---------------------------------------------------- | |
324 | if ( fProcessTPC && fProcessVZERO ) { | |
325 | ||
326 | fHistList->Add(new TH2F("fCorrVzeroNch", | |
327 | "N_{ch}^{TPC} vs Multiplicity^{VZERO};N_{ch}^{TPC};Multiplicity^{VZERO}", | |
328 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
329 | ||
330 | fHistList->Add(new TH2F("fCorrVzeroNchUnCorr", | |
331 | "N_{ch}^{TPC} vs Multiplicity^{VZERO} uncorrected;N_{ch}^{TPC};Multiplicity^{VZERO}", | |
332 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
333 | ||
334 | fHistList->Add(new TH2F("fCorrVzeroESDNch", | |
335 | "N_{ch}^{global} vs Multiplicity^{VZERO};N_{ch}^{TPC};Multiplicity^{VZERO}", | |
336 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
337 | ||
338 | fHistList->Add(new TH2F("fCorrVzeroESDNchUnCorr", | |
339 | "N_{ch}^{global} vs Multiplicity^{VZERO} uncorrected;N_{ch}^{TPC};Multiplicity^{VZERO}", | |
340 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax)); | |
341 | ||
342 | } | |
343 | // ---------------------------------------------------- | |
344 | // TPC vs SPD | |
345 | // ---------------------------------------------------- | |
346 | if ( fProcessSPD && fProcessTPC ) { | |
347 | ||
348 | fHistList->Add(new TH2F("fCorrSpdTpcNch", "N_{ch}^{TPC} vs N_{clusters}^{SPD};N_{ch}^{TPC};N_{clusters}^{SPD}", | |
349 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
350 | ||
351 | fHistList->Add(new TH2F("fCorrSpdOuterTpcNch"," N_{ch}^{TPC} vs N_{clusters}^{SPD}_{Outer};N_{ch}^{TPC};N_{clusters}^{SPD}", | |
352 | fTpcBinning,fTpcBinningMin,fTpcBinningMax, fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
353 | } | |
354 | // ---------------------------------------------------- | |
355 | // SPD vs VZERO | |
356 | // ---------------------------------------------------- | |
357 | if ( fProcessSPD && fProcessVZERO ) { | |
358 | ||
359 | fHistList->Add(new TH2F("fCorrVzeroSpd", | |
360 | "Multiplicity^{VZERO} vs N_{ch}^{SPD};Multiplicity^{VZERO};N^{SPD}", | |
361 | fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
362 | ||
363 | fHistList->Add(new TH2F("fCorrVzeroSpdOuter", | |
364 | "Multiplicity^{VZERO} vs N_{ch}^{SPD}_{Outer};Multiplicity^{VZERO};N^{SPD}", | |
365 | fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
366 | } | |
367 | // ---------------------------------------------------- | |
368 | // SPD vs ZDC | |
369 | // ---------------------------------------------------- | |
370 | if ( fProcessSPD && fProcessZDC) { | |
371 | ||
372 | // E_{ZDC} vs Multiplicity SPD | |
373 | fHistList->Add(new TH2F("fCorrEzdcSpd", "E_{ZDC} vs N_{ch}^{SPD};E_{ZDC} (TeV);N^{SPD}", | |
374 | fZdcBinning,fZdcBinningMin,fZdcBinningMax, fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
375 | ||
376 | fHistList->Add(new TH2F("fCorrEzdcSpdOuter", "E_{ZDC} vs N_{ch}^{SPD};E_{ZDC} (TeV);N^{SPD}", | |
377 | fZdcBinning,fZdcBinningMin,fZdcBinningMax, fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
378 | ||
379 | } | |
380 | ||
381 | return 0; | |
382 | } | |
383 | ||
384 | //################################################################################## | |
385 | Int_t AliMultiplicityCorrelations::SetupSPD() { | |
386 | // see header file for class documentation | |
387 | ||
388 | fHistList->Add(new TH1F("fSpdNClusters", "Multplicity_{SPD};Multplicity_{SPD};N_{Events}", | |
389 | fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
390 | ||
391 | fHistList->Add(new TH1F("fSpdNClustersInner", "Multplicity_{SPD} Layer 0;Multplicity_{SPD};N_{Events}", | |
392 | fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
393 | ||
394 | fHistList->Add(new TH1F("fSpdNClustersOuter", "Multplicity_{SPD} Layer 1;Multplicity_{SPD};N_{Events}", | |
395 | fSpdBinning,fSpdBinningMin,fSpdBinningMax)); | |
396 | return 0; | |
397 | } | |
398 | ||
399 | /* | |
400 | * --------------------------------------------------------------------------------- | |
401 | * Process - private | |
402 | * --------------------------------------------------------------------------------- | |
403 | */ | |
404 | ||
405 | //################################################################################## | |
406 | Int_t AliMultiplicityCorrelations::ProcessTPC() { | |
407 | // see header file for class documentation | |
408 | ||
409 | Int_t iResult = 0 ; | |
410 | ||
411 | fEsdTracks = 0; | |
412 | fEsdTracksA = 0; | |
413 | fTpcTracks = 0; | |
414 | fTpcTracksA = 0; | |
415 | ||
416 | // ----------------------------------------------------------------- | |
417 | ||
418 | for (Int_t idx = 0; idx < fESDEvent->GetNumberOfTracks(); idx++) { | |
419 | ||
420 | // -- check track | |
421 | AliESDtrack* esdTrack = fESDEvent->GetTrack(idx); | |
422 | if (!esdTrack) continue; | |
423 | ||
424 | ++fEsdTracks; | |
425 | ||
426 | if (!fESDTrackCuts2->AcceptTrack(esdTrack)) continue; | |
427 | ++fEsdTracksA; | |
428 | } | |
429 | ||
430 | // ----------------------------------------------------------------- | |
431 | ||
432 | for (Int_t idx = 0; idx < fESDEvent->GetNumberOfTracks(); idx++) { | |
433 | ||
434 | // -- check track | |
435 | AliESDtrack* esdTrack = fESDEvent->GetTrack(idx); | |
436 | if (!esdTrack) continue; | |
437 | ||
438 | // -- TPC only | |
439 | const AliExternalTrackParam *tpcTrack = esdTrack->GetTPCInnerParam(); | |
440 | if (!tpcTrack) continue; | |
441 | ++fTpcTracks; | |
442 | ||
443 | if (!fESDTrackCuts->AcceptTrack(esdTrack)) continue; | |
444 | ++fTpcTracksA; | |
445 | } | |
446 | ||
447 | // ----------------------------------------------------------------- | |
448 | ||
449 | if (fCleanSample) { | |
450 | if(fTpcTracksA < fCleanMinKeep || fTpcTracksA > fCleanMaxKeep) | |
451 | return -2; | |
452 | } | |
453 | ||
454 | Float_t nESD = (Float_t) fEsdTracksA; | |
455 | Float_t nTPC = (Float_t) fTpcTracksA; | |
456 | Float_t ratio = -1; | |
457 | ||
458 | if ( nESD != 0 ) | |
459 | ratio = nTPC/nESD; | |
460 | ||
461 | (static_cast<TH2F*>(fHistList->FindObject("fTpcCorrNchAll")))->Fill(fTpcTracksA,fEsdTracksA); | |
462 | (static_cast<TH1F*>(fHistList->FindObject("fTpcRatioNchAll")))->Fill(ratio); | |
463 | ||
464 | // Cleaning Cut tpcTracks and globalTracks | |
465 | if ( fEsdTracksA < (-39+0.5797*fTpcTracksA)) | |
466 | return -3; | |
467 | ||
468 | (static_cast<TH1F*>(fHistList->FindObject("fTpcNch0")))->Fill(fEsdTracks); | |
469 | (static_cast<TH1F*>(fHistList->FindObject("fTpcNch1")))->Fill(fEsdTracksA); | |
470 | (static_cast<TH1F*>(fHistList->FindObject("fTpcNch2")))->Fill(fTpcTracks); | |
471 | (static_cast<TH1F*>(fHistList->FindObject("fTpcNch3")))->Fill(fTpcTracksA); | |
472 | ||
473 | (static_cast<TH2F*>(fHistList->FindObject("fTpcCorrNch")))->Fill(fTpcTracksA,fEsdTracksA); | |
474 | (static_cast<TH1F*>(fHistList->FindObject("fTpcRatioNch")))->Fill(ratio); | |
475 | ||
476 | return iResult; | |
477 | } | |
478 | ||
479 | //################################################################################## | |
480 | Int_t AliMultiplicityCorrelations::ProcessVZERO() { | |
481 | // see header file for class documentation | |
482 | ||
483 | Int_t iResult = 0 ; | |
484 | Float_t vzeroCorr;; | |
485 | fVzeroMultA = fESDVZERO->GetMTotV0A(); | |
486 | fVzeroMultC = fESDVZERO->GetMTotV0C(); | |
487 | if (!fIsMC) | |
488 | fVzeroMult = GetCorrVZERO(vzeroCorr); | |
489 | else | |
490 | fVzeroMult = (fVzeroMultA+fVzeroMultC) * 0.85871; | |
491 | ||
492 | (static_cast<TH1F*>(fHistList->FindObject("fVzeroMult")))->Fill(fVzeroMult); | |
493 | (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultUnCorr")))->Fill(fVzeroMultA+fVzeroMultC); | |
494 | (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultAC")))->Fill(fVzeroMultA,fVzeroMultC); | |
495 | ||
496 | // -- VZERO - TPC correlations | |
497 | if (fESDEvent->GetNumberOfTracks() > 0 && fProcessTPC) { | |
498 | (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroNch")))->Fill(fTpcTracksA,fVzeroMult); | |
499 | (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroNchUnCorr")))->Fill(fTpcTracksA,fVzeroMultA+fVzeroMultC); | |
500 | ||
501 | (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroESDNch")))->Fill(fEsdTracksA,fVzeroMult); | |
502 | (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroESDNchUnCorr")))->Fill(fEsdTracksA,fVzeroMultA+fVzeroMultC); | |
503 | } | |
504 | ||
505 | // -- VZERO - SPD correlations | |
506 | if (fESDEvent->GetNumberOfTracks() > 0 && fProcessSPD) { | |
507 | (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroSpd")))->Fill(fVzeroMult, fSpdNClusters); | |
508 | (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroSpdOuter")))->Fill(fVzeroMult, fSpdNClustersOuter); | |
509 | } | |
510 | ||
511 | return iResult; | |
512 | } | |
513 | ||
514 | //################################################################################## | |
515 | Int_t AliMultiplicityCorrelations::ProcessZDC() { | |
516 | // see header file for class documentation | |
517 | ||
518 | Int_t iResult = 0 ; | |
519 | ||
520 | Double_t zdcEznA = fESDZDC->GetZDCN2Energy() / 8.; | |
521 | Double_t zdcEznC = fESDZDC->GetZDCN1Energy() / 8.; | |
522 | // Double_t zdcEznA = fESDZDC->GetZDCN2Energy() / 1000.; | |
523 | // Double_t zdcEznC = fESDZDC->GetZDCN1Energy() / 1000.; | |
524 | ||
525 | Double_t zdcEzpA = fESDZDC->GetZDCP2Energy() / 8.; | |
526 | Double_t zdcEzpC = fESDZDC->GetZDCP1Energy() / 8.; | |
527 | // Double_t zdcEzpA = fESDZDC->GetZDCP2Energy() / 1000.; | |
528 | // Double_t zdcEzpC = fESDZDC->GetZDCP1Energy() / 1000.; | |
529 | ||
530 | Double_t zdcEA = (zdcEznA + zdcEzpA); | |
531 | Double_t zdcEC = (zdcEznC + zdcEzpC); | |
532 | Double_t zdcE = zdcEA + zdcEC; | |
533 | ||
534 | Double_t zdcEzemA = fESDZDC->GetZDCEMEnergy(1) / 8.; | |
535 | Double_t zdcEzemC = fESDZDC->GetZDCEMEnergy(0) / 8.; | |
536 | // Double_t zdcEzemA = fESDZDC->GetZDCEMEnergy(1) / 1000.; | |
537 | // Double_t zdcEzemC = fESDZDC->GetZDCEMEnergy(0) / 1000.; | |
538 | Double_t zdcEzem = zdcEzemA + zdcEzemC; | |
539 | ||
540 | (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdc")))->Fill(zdcE); | |
541 | ||
542 | (static_cast<TH1F*>(fHistList->FindObject("fZdcEzem")))->Fill(zdcEzem); | |
543 | (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdc")))->Fill(zdcEzem, zdcE); | |
544 | ||
545 | // -- ZDC - TPC correlations | |
546 | if (fESDEvent->GetNumberOfTracks() > 0 && fProcessTPC) { | |
547 | (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcNch")))->Fill(fTpcTracksA, zdcE); | |
548 | (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemNch")))->Fill(fTpcTracksA, zdcEzem); | |
549 | } | |
550 | ||
551 | // -- ZDC - SPD correlations | |
552 | if (fProcessSPD) { | |
553 | (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcSpd")))->Fill(zdcE, fSpdNClusters); | |
554 | (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcSpdOuter")))->Fill(zdcE, fSpdNClustersOuter); | |
555 | } | |
556 | ||
557 | // -- VZERO - ZDC correlations | |
558 | if (fESDVZERO && fProcessVZERO) { | |
559 | (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzero")))->Fill(zdcE, fVzeroMult); | |
560 | (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzero")))->Fill(zdcEzem, fVzeroMult); | |
561 | } | |
562 | ||
563 | return iResult; | |
564 | } | |
565 | ||
566 | //################################################################################## | |
567 | Int_t AliMultiplicityCorrelations::ProcessSPD() { | |
568 | // see header file for class documentation | |
569 | ||
570 | const AliESDVertex* vtxESD = fESDEvent->GetPrimaryVertexSPD(); | |
571 | Float_t zvtx = vtxESD->GetZ(); | |
572 | ||
573 | if (!fIsMC) { | |
574 | fSpdNClustersInner = GetCorrSPD2(fESDMultiplicity->GetNumberOfITSClusters(0),zvtx); | |
575 | fSpdNClustersOuter = GetCorrSPD2(fESDMultiplicity->GetNumberOfITSClusters(1),zvtx); | |
576 | } | |
577 | else { | |
578 | fSpdNClustersInner = fESDMultiplicity->GetNumberOfITSClusters(0); | |
579 | fSpdNClustersOuter = fESDMultiplicity->GetNumberOfITSClusters(1); | |
580 | } | |
581 | ||
582 | fSpdNClusters = fSpdNClustersOuter + fSpdNClustersInner; | |
583 | ||
584 | (static_cast<TH2F*>(fHistList->FindObject("fSpdNClusters")))->Fill(fSpdNClusters); | |
585 | (static_cast<TH2F*>(fHistList->FindObject("fSpdNClustersInner")))->Fill(fSpdNClustersInner); | |
586 | (static_cast<TH2F*>(fHistList->FindObject("fSpdNClustersOuter")))->Fill(fSpdNClustersOuter); | |
587 | ||
588 | // -- SPD vs TPC correlations | |
589 | if (fProcessTPC) { | |
590 | (static_cast<TH2F*>(fHistList->FindObject("fCorrSpdTpcNch")))->Fill(fTpcTracksA, fSpdNClusters); | |
591 | (static_cast<TH2F*>(fHistList->FindObject("fCorrSpdOuterTpcNch")))->Fill(fTpcTracksA, fSpdNClustersOuter); | |
592 | } | |
593 | ||
594 | return 0; | |
595 | } | |
596 | ||
597 | //################################################################################## | |
598 | Float_t AliMultiplicityCorrelations::GetCorrVZERO(Float_t &v0CorrResc) { | |
599 | // correct V0 non-linearity, prepare a version rescaled to SPD2 corr | |
600 | ||
601 | Double_t *par0; | |
602 | Double_t *par1; | |
603 | Double_t *par2; | |
604 | ||
f8b4d737 | 605 | Double_t par0R137161[64] = { 6.71e-02 , 6.86e-02 , 7.06e-02 , 6.32e-02 , |
44a84424 | 606 | 5.91e-02 , 6.07e-02 , 5.78e-02 , 5.73e-02 , 5.91e-02 , 6.22e-02 , |
607 | 5.90e-02 , 6.11e-02 , 5.55e-02 , 5.29e-02 , 5.19e-02 , 5.56e-02 , | |
608 | 6.25e-02 , 7.03e-02 , 5.64e-02 , 5.81e-02 , 4.57e-02 , 5.30e-02 , | |
609 | 5.13e-02 , 6.43e-02 , 6.27e-02 , 6.48e-02 , 6.07e-02 , 1.01e-01 , | |
610 | 6.68e-02 , 7.16e-02 , 6.36e-02 , 5.95e-02 , 2.52e-02 , 2.82e-02 , | |
611 | 2.56e-02 , 2.86e-02 , 2.82e-02 , 2.10e-02 , 2.13e-02 , 2.32e-02 , | |
612 | 2.75e-02 , 4.34e-02 , 3.78e-02 , 4.52e-02 , 4.11e-02 , 3.89e-02 , | |
613 | 4.10e-02 , 3.73e-02 , 4.51e-02 , 5.07e-02 , 5.42e-02 , 4.74e-02 , | |
614 | 4.33e-02 , 4.44e-02 , 4.64e-02 , 3.01e-02 , 6.38e-02 , 5.26e-02 , | |
615 | 4.99e-02 , 5.26e-02 , 5.47e-02 , 3.84e-02 , 5.00e-02 , 5.20e-02 }; | |
f8b4d737 | 616 | Double_t par1R137161[64] = { -6.68e-05 , -7.78e-05 , -6.88e-05 , -5.92e-05 , |
44a84424 | 617 | -2.43e-05 , -3.54e-05 , -2.91e-05 , -1.99e-05 , -1.40e-05 , -4.01e-05 , |
618 | -2.29e-05 , -3.68e-05 , -2.53e-05 , -2.44e-06 , -9.22e-06 , -1.51e-05 , | |
619 | -2.80e-05 , -2.34e-05 , -1.72e-05 , -1.81e-05 , -1.29e-05 , -2.65e-05 , | |
620 | -1.61e-05 , -2.86e-05 , -1.74e-05 , -4.23e-05 , -3.41e-05 , -1.05e-04 , | |
621 | -2.76e-05 , -4.71e-05 , -3.06e-05 , -2.32e-05 , -1.55e-06 , 2.15e-05 , | |
622 | 1.40e-05 , 2.16e-05 , 1.21e-05 , 3.05e-06 , 1.67e-05 , -3.84e-06 , | |
623 | 3.09e-06 , 1.50e-05 , 3.47e-06 , 4.87e-06 , -3.71e-07 , -1.75e-06 , | |
624 | -1.80e-06 , 9.99e-06 , -6.46e-06 , -4.91e-06 , 1.33e-05 , -2.52e-07 , | |
625 | -3.85e-06 , 4.94e-06 , -2.48e-07 , -1.20e-05 , 2.07e-06 , 6.12e-06 , | |
626 | -1.18e-06 , 4.54e-06 , -1.54e-05 , -1.25e-05 , 1.46e-06 , -6.67e-06 }; | |
f8b4d737 | 627 | Double_t par2R137161[64] = { 1.29e-08 , 1.51e-08 , 1.43e-08 , 1.11e-08 , |
44a84424 | 628 | 5.04e-09 , 6.99e-09 , 5.58e-09 , 4.15e-09 , 4.00e-09 , 8.22e-09 , |
629 | 4.97e-09 , 7.66e-09 , 4.91e-09 , 1.10e-09 , 2.64e-09 , 3.64e-09 , | |
630 | 5.76e-09 , 5.46e-09 , 3.38e-09 , 3.47e-09 , 2.43e-09 , 4.13e-09 , | |
631 | 2.80e-09 , 5.80e-09 , 3.86e-09 , 7.46e-09 , 5.98e-09 , 2.58e-08 , | |
632 | 5.50e-09 , 8.72e-09 , 5.23e-09 , 4.37e-09 , 2.33e-09 , -6.01e-10 , | |
633 | 3.99e-11 , -2.02e-10 , 7.67e-10 , 2.03e-09 , 1.17e-10 , 2.56e-09 , | |
634 | 1.16e-09 , -4.75e-10 , 1.28e-09 , 1.23e-09 , 1.62e-09 , 1.61e-09 , | |
635 | 1.93e-09 , 2.97e-10 , 2.21e-09 , 2.16e-09 , 5.22e-10 , 1.03e-09 , | |
636 | 1.56e-09 , 5.00e-10 , 1.01e-09 , 2.93e-09 , 1.05e-09 , 9.96e-11 , | |
637 | 1.21e-09 , 7.45e-10 , 3.07e-09 , 2.31e-09 , 6.70e-10 , 1.89e-09 }; | |
638 | ||
f8b4d737 | 639 | Double_t par0R137366[64] = { 7.12e-02 , 7.34e-02 , 7.39e-02 , 6.54e-02 , 6.11e-02 , 6.31e-02 , 6.15e-02 , |
44a84424 | 640 | 6.00e-02 , 6.10e-02 , 6.49e-02 , 6.17e-02 , 6.33e-02 , 6.00e-02 , 5.48e-02 , |
641 | 5.44e-02 , 5.81e-02 , 6.49e-02 , 7.07e-02 , 5.91e-02 , 6.18e-02 , 4.82e-02 , | |
642 | 5.67e-02 , 5.36e-02 , 6.60e-02 , 6.37e-02 , 6.78e-02 , 6.31e-02 , 1.04e-01 , | |
643 | 6.91e-02 , 7.32e-02 , 6.61e-02 , 6.16e-02 , 2.64e-02 , 2.81e-02 , 2.64e-02 , | |
644 | 2.85e-02 , 2.87e-02 , 2.18e-02 , 2.19e-02 , 2.43e-02 , 2.81e-02 , 4.37e-02 , | |
645 | 3.90e-02 , 4.66e-02 , 4.24e-02 , 4.09e-02 , 4.21e-02 , 3.88e-02 , 4.83e-02 , | |
646 | 5.23e-02 , 5.44e-02 , 4.85e-02 , 4.42e-02 , 4.58e-02 , 4.74e-02 , 3.14e-02 , | |
647 | 6.31e-02 , 5.30e-02 , 5.01e-02 , 5.33e-02 , 5.70e-02 , 3.95e-02 , 4.98e-02 , 5.31e-02 }; | |
f8b4d737 | 648 | Double_t par1R137366[64] = { -6.99e-05 , -6.99e-05 , -6.94e-05 , -6.55e-05 , -3.55e-05 , -4.50e-05 , |
44a84424 | 649 | -3.10e-05 , -2.81e-05 , -2.29e-05 , -3.89e-05 , -2.53e-05 , -4.25e-05 , |
650 | -1.87e-05 , -2.01e-05 , -1.53e-05 , -2.14e-05 , -2.86e-05 , -4.70e-05 , | |
651 | -2.23e-05 , -3.30e-05 ,-9.74e-06 , -2.62e-05 , -1.76e-05 , -2.38e-05 , | |
652 | -2.40e-05 , -3.43e-05 , -2.75e-05 , -6.86e-05 ,-2.35e-05 , -4.45e-05 , | |
653 | -2.51e-05 , -2.20e-05 , -1.25e-16 , -2.04e-17 , -2.06e-17 , -3.74e-19 , | |
654 | -1.18e-18 , -2.02e-15 , -3.78e-06 , -1.26e-06 , -2.71e-06 , -6.23e-17 , | |
655 | -7.39e-08 , -1.76e-16 , -8.98e-06 , -4.10e-18 , -1.34e-05 , -1.06e-16 , | |
656 | -3.34e-06 , -1.04e-05 , -5.28e-06 , -7.34e-06 , -1.05e-05 , -7.68e-06 , | |
657 | -1.78e-05 , -1.19e-05 , -1.78e-05 , -1.34e-06 , -9.23e-06 , -3.34e-06 , | |
658 | -8.02e-06 , -1.39e-05 , -1.38e-05 , -1.40e-05 }; | |
f8b4d737 | 659 | Double_t par2R137366[64] = { 1.41e-08 , 1.47e-08 , 1.48e-08 , 1.24e-08 , 6.82e-09 , 8.73e-09 , 6.26e-09 , |
44a84424 | 660 | 5.53e-09 , 5.40e-09 , 7.93e-09 , 5.49e-09 , 8.77e-09 , 4.21e-09 , 3.93e-09 , |
661 | 3.60e-09 , 4.67e-09 , 5.59e-09 , 8.81e-09 , 3.89e-09 , 6.19e-09 , 1.97e-09 , | |
662 | 4.38e-09 , 3.26e-09 , 5.00e-09 , 4.58e-09 , 6.39e-09 , 5.03e-09 , 1.30e-08 , | |
663 | 4.95e-09 , 8.26e-09 , 4.57e-09 , 4.10e-09 , 2.35e-09 , 2.30e-09 , 2.15e-09 , | |
664 | 2.27e-09 , 2.17e-09 , 2.27e-09 , 2.97e-09 , 2.25e-09 , 1.69e-09 , 1.44e-09 , | |
665 | 1.66e-09 , 1.75e-09 , 2.88e-09 , 1.82e-09 , 3.64e-09 , 1.80e-09 , 1.71e-09 , | |
666 | 2.66e-09 , 3.01e-09 , 1.95e-09 , 2.64e-09 , 2.42e-09 , 3.68e-09 , 2.66e-09 , | |
667 | 3.92e-09 , 1.18e-09 , 2.26e-09 , 1.57e-09 , 2.02e-09 , 2.71e-09 , 2.99e-09 , 3.04e-09 }; | |
668 | ||
669 | ||
670 | ||
671 | if ( fRunNo == 137161 ) { | |
f8b4d737 | 672 | par0=par0R137161; |
673 | par1=par1R137161; | |
674 | par2=par2R137161; | |
44a84424 | 675 | } |
676 | else { | |
f8b4d737 | 677 | par0=par0R137366; |
678 | par1=par1R137366; | |
679 | par2=par2R137366; | |
44a84424 | 680 | } |
681 | ||
682 | Float_t multCorr = 0; | |
683 | Float_t multCorr2 = 0; | |
684 | Float_t multChCorr[64]; | |
685 | ||
686 | for(Int_t i = 0; i < 64; ++i) { | |
687 | Double_t b = (fESDVZERO->GetMultiplicity(i)*par1[i]-par0[i]); | |
688 | Double_t s = (b*b-4.*par2[i]*fESDVZERO->GetMultiplicity(i)*fESDVZERO->GetMultiplicity(i)); | |
689 | Double_t n; | |
690 | if (s<0) { | |
691 | printf("FPE %d %.2f %.2f %.2e\n",i,fESDVZERO->GetMultiplicity(i),b,(b*b-4.*par2[i]*fESDVZERO->GetMultiplicity(i)*fESDVZERO->GetMultiplicity(i))); | |
692 | n = -b; | |
693 | } | |
694 | else { | |
695 | n = (-b + TMath::Sqrt(s)); | |
696 | } | |
697 | multChCorr[i] = 2.*fESDVZERO->GetMultiplicity(i)/n*par0[i]; | |
698 | multCorr += multChCorr[i]; | |
699 | multCorr2 += (multChCorr[i]/par0[i]/64.); | |
700 | } | |
701 | v0CorrResc = multCorr2; | |
702 | return multCorr; | |
703 | } | |
704 | ||
705 | ||
706 | //################################################################################## | |
f8b4d737 | 707 | Float_t AliMultiplicityCorrelations::GetCorrSPD2(Float_t spd2raw,Float_t zv) const { |
44a84424 | 708 | // renormalize N spd2 clusters at given Zv to acceptance at Zv=0 |
709 | const double pars[] = {8.10030e-01,-2.80364e-03,-7.19504e-04}; | |
710 | zv -= pars[0]; | |
711 | float corr = 1 + zv*(pars[1] + zv*pars[2]); | |
712 | return corr>0 ? spd2raw/corr : -1; | |
713 | } |