- Add new class for multiplicity correlations
[u/mrichter/AliRoot.git] / HLT / global / physics / AliHLTMultiplicityCorrelations.cxx
CommitLineData
06f2306d 1//-*- Mode: C++ -*-
2// $Id: AliHLTMultiplicityCorrelations.cxx $
3//**************************************************************************
4//* This file is property of and copyright by the ALICE HLT Project *
5//* ALICE Experiment at CERN, All rights reserved. *
6//* *
7//* Primary Authors: Jochen Thaeder <jochen@thaeder.de> *
8//* for The ALICE HLT Project. *
9//* *
10//* Permission to use, copy, modify and distribute this software and its *
11//* documentation strictly for non-commercial purposes is hereby granted *
12//* without fee, provided that the above copyright notice appears in all *
13//* copies and that both the copyright notice and this permission notice *
14//* appear in the supporting documentation. The authors make no claims *
15//* about the suitability of this software for any purpose. It is *
16//* provided "as is" without express or implied warranty. *
17//**************************************************************************
18
19/** @file AliHLTMultiplicityCorrelations.cxx
20 @author Jochen Thaeder <jochen@thaeder.de>
21 @brief Correlation plots for multiplicity studies
22*/
23
24// see header file for class documentation
25// or
26// refer to README to build package
27// or
28// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
29
30#if __GNUC__>= 3
31 using namespace std;
32#endif
33
34#include "TH1F.h"
35#include "TH2F.h"
36#include "TList.h"
37
38#include "AliHLTMultiplicityCorrelations.h"
39
40/** ROOT macro for the implementation of ROOT specific class methods */
41ClassImp(AliHLTMultiplicityCorrelations)
42
43/*
44 * ---------------------------------------------------------------------------------
45 * Constructor / Destructor
46 * ---------------------------------------------------------------------------------
47 */
48
49//##################################################################################
50AliHLTMultiplicityCorrelations::AliHLTMultiplicityCorrelations() :
51 fHistList(NULL),
52 fESDEvent(NULL),
53 fESDZDC(NULL),
54 fESDVZERO(NULL),
55 fESDTrackCuts(NULL),
56 fEsdTracks(0), fEsdTracksA(0),
57 fTpcTracks(0), fTpcTracksA(0),
58 fVzeroMult(0.), fVzeroMultA(0.), fVzeroMultC(0.),
59 fVzeroMultFlagged(0.), fVzeroMultFlaggedA(0.), fVzeroMultFlaggedC(0.),
60 fVzeroBinning(350), fVzeroBinningMin(0.), fVzeroBinningMax(35000.),
61 fTpcBinning(200),fTpcBinningMin(0.),fTpcBinningMax(8000.),
62 fZdcBinning(280),fZdcBinningMin(0.),fZdcBinningMax(140.),
63 fZemBinning(100),fZemBinningMin(0.),fZemBinningMax(5.),
64 fZnpBinning(200),fZnpBinningMin(0.),fZnpBinningMax(100.) {
65 // see header file for class documentation
66 // or
67 // refer to README to build package
68 // or
69 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
70
71}
72
73//##################################################################################
74AliHLTMultiplicityCorrelations::~AliHLTMultiplicityCorrelations() {
75 // see header file for class documentation
76
77 if ( fHistList ) {
78 fHistList->Clear();
79 delete fHistList;
80 }
81 fHistList = NULL;
82}
83
84/*
85 * ---------------------------------------------------------------------------------
86 * Initialize / Reset
87 * ---------------------------------------------------------------------------------
88 */
89
90//##################################################################################
91Int_t AliHLTMultiplicityCorrelations::Initialize() {
92 // see header file for class documentation
93
94 Int_t iResult = 0;
95
96 fHistList = new TList();
97 fHistList->SetOwner(kTRUE);
98
99 iResult = SetupHistograms();
100
101 return iResult;
102}
103
104/*
105 * ---------------------------------------------------------------------------------
106 * Output - public
107 * ---------------------------------------------------------------------------------
108 */
109
110//##################################################################################
111Int_t AliHLTMultiplicityCorrelations::ProcessEvent( AliESDEvent *esd ) {
112 // see header file for class documentation
113
114 Int_t iResult = 0;
115
116 if ( ! AddESDEvent(esd) ) {
117 HLTWarning("No ESD event.");
118 return -1;
119 }
120
121 // -- TPC .. To be done before the others
122 if (fESDEvent->GetNumberOfTracks() > 0)
123 iResult = ProcessTPC();
124
125 // -- VZERO
126 if (fESDVZERO)
127 iResult = ProcessVZERO();
128
129 // -- ZDC and Correlations
130 if (fESDZDC)
131 iResult = ProcessZDC();
132
133
134 return iResult;
135}
136
137////////////////////////////////////////////////////////////////////////////////////
138////////////////////////////////////////////////////////////////////////////////////
139/// ///
140////// PRIVATE //////
141/// ///
142////////////////////////////////////////////////////////////////////////////////////
143////////////////////////////////////////////////////////////////////////////////////
144
145/*
146 * ---------------------------------------------------------------------------------
147 * Setup / Initialize - private
148 * ---------------------------------------------------------------------------------
149 */
150
151//##################################################################################
152Bool_t AliHLTMultiplicityCorrelations::AddESDEvent( AliESDEvent* esd ) {
153 // see header file for class documentation
154
155 fESDEvent = esd;
156
157 // -- Check for ESD
158 if ( !fESDEvent ) {
159 HLTWarning("No ESD event present.");
160 return kFALSE;
161 }
162
163 // -- Check for PrimaryVertex
164 if ( !esd->GetPrimaryVertexTracks() ){
165 HLTError("No Vertex present.");
166 return kFALSE;
167 }
168
169 fESDZDC = esd->GetESDZDC();
170 if ( !fESDZDC ) {
171 HLTInfo("No ZDC information !");
172 }
173
174 fESDVZERO = esd->GetVZEROData();
175 if ( !fESDVZERO ) {
176 HLTInfo("No VZERO information !");
177 }
178
179 return kTRUE;
180}
181
182//##################################################################################
183Int_t AliHLTMultiplicityCorrelations::SetupHistograms() {
184 // see header file for class documentation
185
186 Int_t iResult = 0;
187
188 iResult = SetupVZERO();
189 iResult = SetupZDC();
190 iResult = SetupTPC();
191 iResult = SetupCorrelations();
192
193 return iResult;
194}
195
196//##################################################################################
197Int_t AliHLTMultiplicityCorrelations::SetupVZERO() {
198 // see header file for class documentation
199
200 // VzeroMult
201 fHistList->Add(new TH1F("fVzeroMult", "Multiplicity^{VZERO};Multiplicity^{VZERO};N_{Events}",
202 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
203 fHistList->Add(new TH1F("fVzeroMultA", "Multiplicity^{VZERO} A;Multiplicity^{VZERO};N_{Events}",
204 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
205 fHistList->Add(new TH1F("fVzeroMultC", "Multiplicity^{VZERO} C;Multiplicity^{VZERO};N_{Events}",
206 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
207
208 // Flagged VzeroMult
209 fHistList->Add(new TH1F("fVzeroFlaggedMult", "Multiplicity_{flagged}^{VZERO};Multiplicity^{VZERO};N_{Events}",
210 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
211 fHistList->Add(new TH1F("fVzeroFlaggedMultA", "Multiplicity_{flagged}^{VZERO} A;Multiplicity^{VZERO};N_{Events}",
212 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
213 fHistList->Add(new TH1F("fVzeroFlaggedMultC", "Multiplicity_{flagged}^{VZERO} C;Multiplicity^{VZERO};N_{Events}",
214 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
215
216 fHistList->Add(new TH1F("fVzeroTime", "Time;Time;N_{Events}", 500, 0, 1000));
217 fHistList->Add(new TH1F("fVzeroTimeA", "Time A;Time;N_{Events}", 500, 0, 1000));
218 fHistList->Add(new TH1F("fVzeroTimeC", "Time B;Time;N_{Events}", 500, 0, 1000));
219
220 fHistList->Add(new TH1F("fVzeroADC", "ADC;ADC;N_{Events}", 500, 0, 150000));
221 fHistList->Add(new TH1F("fVzeroADCA", "ADC A;ADC;N_{Events}", 500, 0, 100000));
222 fHistList->Add(new TH1F("fVzeroADCC", "ADC B;ADC;N_{Events}", 500, 0, 100000));
223
224 return 0;
225}
226
227//##################################################################################
228Int_t AliHLTMultiplicityCorrelations::SetupZDC() {
229 // see header file for class documentation
230
231 // E_{ZN}
232 fHistList->Add(new TH1F("fZdcEzn", "E_{ZN};E_{ZN} (TeV);N_{Events}",
233 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
234 fHistList->Add(new TH1F("fZdcEznA", "E_{ZN} A;E_{ZN} (TeV);N_{Events}",
235 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
236 fHistList->Add(new TH1F("fZdcEznC", "E_{ZN} C;E_{ZN} (TeV);N_{Events}",
237 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
238
239 // E_{ZP}
240 fHistList->Add(new TH1F("fZdcEzp", "E_{ZP};E_{ZP} (TeV);N_{Events}",
241 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
242 fHistList->Add(new TH1F("fZdcEzpA", "E_{ZP} A;E_{ZP} (TeV);N_{Events}",
243 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
244 fHistList->Add(new TH1F("fZdcEzpC", "E_{ZP} C;E_{ZP} (TeV);N_{Events}",
245 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
246
247 // E_{ZDC}
248 fHistList->Add(new TH1F("fZdcEzdc", "E_{ZDC};E_{ZDC} (TeV);N_{Events}",
249 fZdcBinning,fZdcBinningMin,fZdcBinningMax));
250 fHistList->Add(new TH1F("fZdcEzdcA", "E_{ZDC} A;E_{ZDC} (TeV);N_{Events}",
251 fZdcBinning,fZdcBinningMin,fZdcBinningMax));
252 fHistList->Add(new TH1F("fZdcEzdcC", "E_{ZDC} C;E_{ZDC} (TeV);N_{Events}",
253 fZdcBinning,fZdcBinningMin,fZdcBinningMax));
254
255 // E_{ZEM}
256 fHistList->Add(new TH1F("fZdcEzem", "E_{ZEM};E_{ZEM} (TeV);N_{Events}",
257 fZemBinning,fZemBinningMin,fZemBinningMax));
258 fHistList->Add(new TH1F("fZdcEzemA", "E_{ZEM} A;E_{ZEM} (TeV);N_{Events}",
259 fZemBinning,fZemBinningMin,fZemBinningMax));
260 fHistList->Add(new TH1F("fZdcEzemC", "E_{ZEM} C;E_{ZEM} (TeV);N_{Events}",
261 fZemBinning,fZemBinningMin,fZemBinningMax));
262
263 // N_{Part}
264 fHistList->Add(new TH1F("fZdcNpart", "N_{Part} ;N_{Part};N_{Events}", 50,0,499));
265 fHistList->Add(new TH1F("fZdcNpartA", "N_{Part} A;N_{Part};N_{Events}", 50,0,499));
266 fHistList->Add(new TH1F("fZdcNpartC", "N_{Part} C;N_{Part};N_{Events}", 50,0,499));
267
268 // b
269 fHistList->Add(new TH1F("fZdcB", "b;b {fm);N_{Events}", 31,0,30));
270 fHistList->Add(new TH1F("fZdcBA", "b A;b (fm);N_{Events}", 31,0,30));
271 fHistList->Add(new TH1F("fZdcBC", "b C;b (fm);N_{Events}", 31,0,30));
272
273 // E_{ZEM} vs E_{ZDC}
274 fHistList->Add(new TH2F("fZdcEzemEzdc", "E_{ZEM} vs E_{ZDC};E_{ZEM} (TeV); E_{ZDC} (TeV)",
275 fZemBinning,fZemBinningMin,fZemBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax));
276 fHistList->Add(new TH2F("fZdcEzemEzdcA","E_{ZEM} vs E_{ZDC} A;E_{ZEM} (TeV); E_{ZDC} (TeV)",
277 fZemBinning,fZemBinningMin,fZemBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax));
278 fHistList->Add(new TH2F("fZdcEzemEzdcC","E_{ZEM} vs E_{ZDC} C;E_{ZEM} (TeV); E_{ZDC} (TeV)",
279 fZemBinning,fZemBinningMin,fZemBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax));
280
281 return 0;
282}
283
284//##################################################################################
285Int_t AliHLTMultiplicityCorrelations::SetupTPC() {
286 // see header file for class documentation
287
288 Int_t n = 50;
289 Double_t s = 0.1;
290 Double_t e = 50.;
291
292 // -- Create LogPtBinning
293 // ------------------------
294 Double_t logMin = TMath::Log10(s);
295 Double_t logMax = TMath::Log10(e);
296 Double_t binwidth = (logMax-logMin)/n;
297
298 Double_t *logBinning = new Double_t[n+1];
299
300 logBinning[0] = s;
301 for (Int_t ii = 1; ii <= n; ii++)
302 logBinning[ii] = s + TMath::Power(10, logMin + ii*binwidth);
303 // - - - - - - - - - - - - - - - - - - - - - - - - - - -
304
305 // dN_{ch} / dP_{T}
306 fHistList->Add(new TH1F("fTpcPt0", "dN_{ch} / dP_{T} esdTracks; P_{T} (GeV/c);dN/dP_{T} (c/GeV)", n, logBinning));
307 fHistList->Add(new TH1F("fTpcPt1", "dN_{ch} / dP_{T} accepted esdTracks; P_{T} (GeV/c);dN/dP_{T} (c/GeV)", n, logBinning));
308 fHistList->Add(new TH1F("fTpcPt2", "dN_{ch} / dP_{T} tpcTracks; P_{T} (GeV/c);dN/dP_{T} (c/GeV)", n, logBinning));
309 fHistList->Add(new TH1F("fTpcPt3", "dN_{ch} / dP_{T} accepted tpcTracks; P_{T} (GeV/c);dN/dP_{T} (c/GeV)", n, logBinning));
310
311 // Multiplicty
312 fHistList->Add(new TH1F("fTpcNch0", "N_{ch} esdTracks; N_{ch};N_{Events}",
313 fTpcBinning,fTpcBinningMin,fTpcBinningMax));
314 fHistList->Add(new TH1F("fTpcNch1", "N_{ch} accepted esdTracks; N_{ch};N_{Events}",
315 fTpcBinning,fTpcBinningMin,fTpcBinningMax));
316 fHistList->Add(new TH1F("fTpcNch2", "N_{ch} tpcTracks; N_{ch};N_{Events}",
317 fTpcBinning,fTpcBinningMin,fTpcBinningMax));
318 fHistList->Add(new TH1F("fTpcNch3", "N_{ch} accepted tpcTracks; N_{ch};N_{Events}",
319 fTpcBinning,fTpcBinningMin,fTpcBinningMax));
320
321 return 0;
322}
323
324//##################################################################################
325Int_t AliHLTMultiplicityCorrelations::SetupCorrelations() {
326 // see header file for class documentation
327
328 // ----------------------------------------------------
329 // ZDC vs TPC
330 // ----------------------------------------------------
331
332 // E_{ZDC} vs N_{ch}
333 fHistList->Add(new TH2F("fCorrEzdcNch", "E_{ZDC} vs N_{ch}^{TPC};E_{ZDC} (TeV);N_{ch}^{TPC}",
334 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
335 fHistList->Add(new TH2F("fCorrEzdcANch","E_{ZDC} vs N_{ch}^{TPC} A;E_{ZDC} (TeV);N_{ch}^{TPC}",
336 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
337 fHistList->Add(new TH2F("fCorrEzdcCNch","E_{ZDC} vs N_{ch}^{TPC} C;E_{ZDC} (TeV);N_{ch}^{TPC}",
338 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
339
340 // E_{ZEM} vs N_{ch}
341 fHistList->Add(new TH2F("fCorrEzemNch", "E_{ZEM} vs N_{ch}^{TPC};E_{ZEM} (TeV);N_{ch}^{TPC}",
342 fZemBinning,fZemBinningMin,fZemBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
343 fHistList->Add(new TH2F("fCorrEzemANch","E_{ZEM} vs N_{ch}^{TPC} A;E_{ZEM} (TeV);N_{ch}^{TPC}",
344 fZemBinning,fZemBinningMin,fZemBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
345 fHistList->Add(new TH2F("fCorrEzemCNch","E_{ZEM} vs N_{ch}^{TPC} C;E_{ZEM} (TeV);N_{ch}^{TPC}",
346 fZemBinning,fZemBinningMin,fZemBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
347
348 // E_{ZP} vs N_{ch}
349 fHistList->Add(new TH2F("fCorrEzpNch", "E_{ZP} vs N_{ch}^{TPC};E_{ZP} (TeV);N_{ch}^{TPC}",
350 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
351 fHistList->Add(new TH2F("fCorrEzpANch","E_{ZP} vs N_{ch}^{TPC} A;E_{ZP} (TeV);N_{ch}^{TPC}",
352 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
353 fHistList->Add(new TH2F("fCorrEzpCNch","E_{ZP} vs N_{ch}^{TPC} C;E_{ZP} (TeV);N_{ch}^{TPC}",
354 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
355
356 // E_{ZN} vs N_{ch}
357 fHistList->Add(new TH2F("fCorrEznNch", "E_{ZN} vs N_{ch}^{TPC};E_{ZN} (TeV);N_{ch}^{TPC}",
358 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
359 fHistList->Add(new TH2F("fCorrEznANch","E_{ZN} vs N_{ch}^{TPC} A;E_{ZN} (TeV);N_{ch}^{TPC}",
360 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
361 fHistList->Add(new TH2F("fCorrEznCNch","E_{ZN} vs N_{ch}^{TPC} C;E_{ZN} (TeV);N_{ch}^{TPC}",
362 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
363
364 // N_{Part} vs N_{ch}
365 fHistList->Add(new TH2F("fCorrZdcNpartNch", "N_{part} vs N_{ch}^{TPC};N_{Events};N_{ch}^{TPC}",
366 50,0,499, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
367 fHistList->Add(new TH2F("fCorrZdcNpartANch","N_{part} vs N_{ch}^{TPC} A;N_{Events};N_{ch}^{TPC}",
368 50,0,499, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
369 fHistList->Add(new TH2F("fCorrZdcNpartCNch","N_{part} vs N_{ch}^{TPC} C;N_{Events};N_{ch}^{TPC}",
370 50,0,499, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
371
372 // b vs N_{ch}
373 fHistList->Add(new TH2F("fCorrZdcbNch", "b_{ZDC} vs N_{ch}^{TPC};b (fm);N_{ch}^{TPC}",
374 31,0,30, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
375 fHistList->Add(new TH2F("fCorrZdcbANch","b_{ZDC} vs N_{ch}^{TPC} A;b (fm);N_{ch}^{TPC}",
376 31,0,30, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
377 fHistList->Add(new TH2F("fCorrZdcbCNch","b_{ZDC} vs N_{ch}^{TPC} C;b (fm);N_{ch}^{TPC}",
378 31,0,30, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
379
380 // ----------------------------------------------------
381 // ZDC vs VZERO
382 // ----------------------------------------------------
383
384 // E_{ZDC} vs Multiplicty VZERO
385 fHistList->Add(new TH2F("fCorrEzdcVzero",
386 "E_{ZDC} vs Multiplicity^{VZERO};E_{ZDC} (TeV);Multiplicity^{VZERO}",
387 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
388 fHistList->Add(new TH2F("fCorrEzdcVzeroA",
389 "E_{ZDC} vs Multiplicity^{VZERO} A;E_{ZDC} (TeV);Multiplicity^{VZERO}",
390 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
391 fHistList->Add(new TH2F("fCorrEzdcVzeroC",
392 "E_{ZDC} vs Multiplicity^{VZERO} C;E_{ZDC} (TeV);Multiplicity^{VZERO}",
393 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
394
395 // E_{ZEM} vs Multiplicty VZERO
396 fHistList->Add(new TH2F("fCorrEzemVzero",
397 "E_{ZEM} vs Multiplicity^{VZERO};E_{ZEM} (TeV);Multiplicity^{VZERO}",
398 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
399 fHistList->Add(new TH2F("fCorrEzemVzeroA",
400 "E_{ZEM} vs Multiplicity^{VZERO} A;E_{ZEM} (TeV);Multiplicity^{VZERO}",
401 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
402 fHistList->Add(new TH2F("fCorrEzemVzeroC",
403 "E_{ZEM} vs Multiplicity^{VZERO} C;E_{ZEM} (TeV);Multiplicity^{VZERO}",
404 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
405
406 // E_{ZP} vs Multiplicty VZERO
407 fHistList->Add(new TH2F("fCorrEzpVzero",
408 "E_{ZP} vs Multiplicity^{VZERO};E_{ZP} (TeV);Multiplicity^{VZERO}",
409 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
410 fHistList->Add(new TH2F("fCorrEzpVzeroA",
411 "E_{ZP} vs Multiplicity^{VZERO} A;E_{ZP} (TeV);Multiplicity^{VZERO}",
412 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
413 fHistList->Add(new TH2F("fCorrEzpVzeroC",
414 "E_{ZP} vs Multiplicity^{VZERO} C;E_{ZP} (TeV);Multiplicity^{VZERO}",
415 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
416
417 // E_{ZN} vs Multiplicty VZERO
418 fHistList->Add(new TH2F("fCorrEznVzero",
419 "E_{ZN} vs Multiplicity^{VZERO};E_{ZN} (TeV);Multiplicity^{VZERO}",
420 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
421 fHistList->Add(new TH2F("fCorrEznVzeroA",
422 "E_{ZN} vs Multiplicity^{VZERO} A;E_{ZN} (TeV);Multiplicity^{VZERO}",
423 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
424 fHistList->Add(new TH2F("fCorrEznVzeroC",
425 "E_{ZN} vs Multiplicity^{VZERO} C;E_{ZN} (TeV);Multiplicity^{VZERO}",
426 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
427
428 // N_{Part} vs Multiplicty VZERO
429 fHistList->Add(new TH2F("fCorrZdcNpartVzero",
430 "N_{part} vs Multiplicity^{VZERO};N_{Events};Multiplicity^{VZERO}",
431 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
432 fHistList->Add(new TH2F("fCorrZdcNpartVzeroA",
433 "N_{part} vs Multiplicity^{VZERO} A;N_{Events};Multiplicity^{VZERO}",
434 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
435 fHistList->Add(new TH2F("fCorrZdcNpartVzeroC",
436 "N_{part} vs Multiplicity^{VZERO} C;N_{Events};Multiplicity^{VZERO}",
437 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
438
439 // b vs Multiplicty VZERO
440 fHistList->Add(new TH2F("fCorrZdcbVzero", "b_{ZDC} vs Multiplicity^{VZERO};b (fm);Multiplicity^{VZERO}",
441 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
442 fHistList->Add(new TH2F("fCorrZdcbVzeroA","b_{ZDC} vs Multiplicity^{VZERO} A;b (fm);Multiplicity^{VZERO}",
443 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
444 fHistList->Add(new TH2F("fCorrZdcbVzeroC","b_{ZDC} vs Multiplicity^{VZERO} C;b (fm);Multiplicity^{VZERO}",
445 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
446
447 // -- -- -- -- -- -- --
448
449 // E_{ZDC} vs Multiplicty VZERO flagged
450 fHistList->Add(new TH2F("fCorrEzdcVzeroF",
451 "E_{ZDC} vs Multiplicity_{flagged}^{VZERO};E_{ZDC} (TeV);Multiplicity^{VZERO}",
452 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
453 fHistList->Add(new TH2F("fCorrEzdcVzeroFA",
454 "E_{ZDC} vs Multiplicity_{flagged}^{VZERO} A;E_{ZDC} (TeV);Multiplicity^{VZERO}",
455 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
456 fHistList->Add(new TH2F("fCorrEzdcVzeroFC",
457 "E_{ZDC} vs Multiplicity_{flagged}^{VZERO} C;E_{ZDC} (TeV);Multiplicity^{VZERO}",
458 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
459
460 // E_{ZEM} vs Multiplicty VZERO flagged
461 fHistList->Add(new TH2F("fCorrEzemVzeroF",
462 "E_{ZEM} vs Multiplicity_{flagged}^{VZERO};E_{ZEM} (TeV);Multiplicity^{VZERO}",
463 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
464 fHistList->Add(new TH2F("fCorrEzemVzeroFA",
465 "E_{ZEM} vs Multiplicity_{flagged}^{VZERO} A;E_{ZEM} (TeV);Multiplicity^{VZERO}",
466 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
467 fHistList->Add(new TH2F("fCorrEzemVzeroFC",
468 "E_{ZEM} vs Multiplicity_{flagged}^{VZERO} C;E_{ZEM} (TeV);Multiplicity^{VZERO}",
469 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
470
471 // E_{ZP} vs Multiplicty VZERO flagged
472 fHistList->Add(new TH2F("fCorrEzpVzeroF",
473 "E_{ZP} vs Multiplicity_{flagged}^{VZERO};E_{ZP} (TeV);Multiplicity^{VZERO}",
474 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
475 fHistList->Add(new TH2F("fCorrEzpVzeroFA",
476 "E_{ZP} vs Multiplicity_{flagged}^{VZERO} A;E_{ZP} (TeV);Multiplicity^{VZERO}",
477 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
478 fHistList->Add(new TH2F("fCorrEzpVzeroFC",
479 "E_{ZP} vs Multiplicity_{flagged}^{VZERO} C;E_{ZP} (TeV);Multiplicity^{VZERO}",
480 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
481
482 // E_{ZN} vs Multiplicty VZERO flagged
483 fHistList->Add(new TH2F("fCorrEznVzeroF",
484 "E_{ZN} vs Multiplicity_{flagged}^{VZERO};E_{ZN} (TeV);Multiplicity^{VZERO}",
485 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
486 fHistList->Add(new TH2F("fCorrEznVzeroFA",
487 "E_{ZN} vs Multiplicity_{flagged}^{VZERO} A;E_{ZN} (TeV);Multiplicity^{VZERO}",
488 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
489 fHistList->Add(new TH2F("fCorrEznVzeroFC",
490 "E_{ZN} vs Multiplicity_{flagged}^{VZERO} C;E_{ZN} (TeV);Multiplicity^{VZERO}",
491 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
492
493 // N_{Part} vs Multiplicty VZERO flagged
494 fHistList->Add(new TH2F("fCorrZdcNpartVzeroF",
495 "N_{part} vs Multiplicity_{flagged}^{VZERO};N_{Events};Multiplicity^{VZERO}",
496 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
497 fHistList->Add(new TH2F("fCorrZdcNpartVzeroFA",
498 "N_{part} vs Multiplicity_{flagged}^{VZERO} A;N_{Events};Multiplicity^{VZERO}",
499 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
500 fHistList->Add(new TH2F("fCorrZdcNpartVzeroFC",
501 "N_{part} vs Multiplicity_{flagged}^{VZERO} C;N_{Events};Multiplicity^{VZERO}",
502 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
503
504 // b vs Multiplicty VZERO flagged
505 fHistList->Add(new TH2F("fCorrZdcbVzeroF",
506 "b_{ZDC} vs Multiplicity_{flagged}^{VZERO};b (fm);Multiplicity^{VZERO}",
507 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
508 fHistList->Add(new TH2F("fCorrZdcbVzeroFA",
509 "b_{ZDC} vs Multiplicity_{flagged}^{VZERO} A;b (fm);Multiplicity^{VZERO}",
510 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
511 fHistList->Add(new TH2F("fCorrZdcbVzeroFC",
512 "b_{ZDC} vs Multiplicity_{flagged}^{VZERO} C;b (fm);Multiplicity^{VZERO}",
513 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
514
515 // ----------------------------------------------------
516 // VZERO vs TPC
517 // ----------------------------------------------------
518
519 fHistList->Add(new TH2F("fCorrVzeroNch",
520 "Multiplicity^{VZERO} vs N_{ch}^{TPC};Multiplicity^{VZERO};N_{ch}^{TPC}",
521 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
522 fHistList->Add(new TH2F("fCorrVzeroANch",
523 "Multiplicity^{VZERO} vs N_{ch}^{TPC} A;Multiplicity^{VZERO};N_{ch}^{TPC}",
524 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
525 fHistList->Add(new TH2F("fCorrVzeroCNch",
526 "Multiplicity^{VZERO} vs N_{ch}^{TPC} C;Multiplicity^{VZERO};N_{ch}^{TPC}",
527 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
528
529 fHistList->Add(new TH2F("fCorrVzeroFNch",
530 "Multiplicity^{VZERO} vs N_{ch}^{TPC};Multiplicity_{flagged}^{VZERO};N_{ch}^{TPC}",
531 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
532 fHistList->Add(new TH2F("fCorrVzeroFANch",
533 "Multiplicity^{VZERO} vs N_{ch}^{TPC} A;Multiplicity_{flagged}^{VZERO};N_{ch}^{TPC}",
534 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
535 fHistList->Add(new TH2F("fCorrVzeroFCNch",
536 "Multiplicity^{VZERO} vs N_{ch}^{TPC} C;Multiplicity_{flagged}^{VZERO};N_{ch}^{TPC}",
537 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
538
539 // ----------------------------------------------------
540 //
541 // ----------------------------------------------------
542
543 return 0;
544}
545
546/*
547 * ---------------------------------------------------------------------------------
548 * Process - private
549 * ---------------------------------------------------------------------------------
550 */
551
552//##################################################################################
553Int_t AliHLTMultiplicityCorrelations::ProcessTPC() {
554
555 Int_t iResult = 0 ;
556
557 TH1F* hPt0 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt0")); // all
558 TH1F* hPt1 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt1")); // all accepted
559
560 TH1F* hPt2 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt2")); // GetTPCInnerParam
561 TH1F* hPt3 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt3")); // GetTPCInnerParam A
562
563 fEsdTracks = 0;
564 fEsdTracksA = 0;
565 fTpcTracks = 0;
566 fTpcTracksA = 0;
567
568 // -----------------------------------------------------------------
569 for (Int_t idx = 0; idx < fESDEvent->GetNumberOfTracks(); idx++) {
570
571 // -- check track
572 AliESDtrack* esdTrack = fESDEvent->GetTrack(idx);
573 if (!esdTrack) continue;
574
575 ++fEsdTracks;
576 hPt0->Fill(esdTrack->Pt());
577
578 //______________________________________________
579 if (!fESDTrackCuts->AcceptTrack(esdTrack)) continue;
580 ++fEsdTracksA;
581
582 hPt1->Fill(esdTrack->Pt());
583 }
584 // -----------------------------------------------------------------
585 for (Int_t idx = 0; idx < fESDEvent->GetNumberOfTracks(); idx++) {
586
587 // -- check track
588 AliESDtrack* esdTrack = fESDEvent->GetTrack(idx);
589 if (!esdTrack) continue;
590
591 // -- TPC only
592 const AliExternalTrackParam *tpcTrack = esdTrack->GetTPCInnerParam();
593 if (!tpcTrack) continue;
594 ++fTpcTracks;
595 hPt2->Fill(tpcTrack->Pt());
596
597 //______________________________________________
598 if (!fESDTrackCuts->AcceptTrack(esdTrack)) continue;
599 ++fTpcTracksA;
600
601 hPt3->Fill(tpcTrack->Pt());
602 }
603 // -----------------------------------------------------------------
604
605 (static_cast<TH1F*>(fHistList->FindObject("fTpcNch0")))->Fill(fEsdTracks);
606 (static_cast<TH1F*>(fHistList->FindObject("fTpcNch1")))->Fill(fEsdTracksA);
607 (static_cast<TH1F*>(fHistList->FindObject("fTpcNch2")))->Fill(fTpcTracks);
608 (static_cast<TH1F*>(fHistList->FindObject("fTpcNch3")))->Fill(fTpcTracksA);
609
610 return iResult;
611}
612
613//##################################################################################
614Int_t AliHLTMultiplicityCorrelations::ProcessVZERO() {
615
616 Int_t iResult = 0 ;
617
618 fVzeroMultA = fESDVZERO->GetMTotV0A();
619 fVzeroMultC = fESDVZERO->GetMTotV0C();
620 fVzeroMult = fVzeroMultA + fVzeroMultC;
621
622 (static_cast<TH1F*>(fHistList->FindObject("fVzeroMult")))->Fill(fVzeroMult);
623 (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultA")))->Fill(fVzeroMultA);
624 (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultC")))->Fill(fVzeroMultC);
625
626 fVzeroMultFlaggedA = 0.;
627 fVzeroMultFlaggedC = 0.;
628
629 Double_t vzeroTimeA = 0.;
630 Double_t vzeroTimeC = 0.;
631
632 Double_t vzeroAdcA = 0.;
633 Double_t vzeroAdcC = 0.;
634
635 for (Int_t idx = 0; idx < 32; idx++) {
636
637 if ( fESDVZERO->GetBBFlag(idx) )
638 fVzeroMultFlaggedC += fESDVZERO->GetMultiplicityV0C(idx);
639 if ( fESDVZERO->GetBBFlag(idx+32) )
640 fVzeroMultFlaggedA += fESDVZERO->GetMultiplicityV0A(idx);
641
642 vzeroTimeA += fESDVZERO->GetTimeV0A(idx);
643 vzeroTimeC += fESDVZERO->GetTimeV0C(idx);
644
645 vzeroAdcA += fESDVZERO->GetAdcV0A(idx);
646 vzeroAdcC += fESDVZERO->GetAdcV0C(idx);
647 }
648
649 fVzeroMultFlagged = fVzeroMultFlaggedA + fVzeroMultFlaggedC;
650
651 Double_t vzeroTime = vzeroTimeA + vzeroTimeC;
652 Double_t vzeroAdc = vzeroAdcA + vzeroAdcC;
653
654 (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMult")))->Fill(fVzeroMultFlagged);
655 (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMultA")))->Fill(fVzeroMultFlaggedA);
656 (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMultC")))->Fill(fVzeroMultFlaggedC);
657
658 (static_cast<TH1F*>(fHistList->FindObject("fVzeroTime")))->Fill(vzeroTime);
659 (static_cast<TH1F*>(fHistList->FindObject("fVzeroTimeA")))->Fill(vzeroTimeA);
660 (static_cast<TH1F*>(fHistList->FindObject("fVzeroTimeC")))->Fill(vzeroTimeC);
661
662 (static_cast<TH1F*>(fHistList->FindObject("fVzeroADC")))->Fill(vzeroAdc);
663 (static_cast<TH1F*>(fHistList->FindObject("fVzeroADCA")))->Fill(vzeroAdcA);
664 (static_cast<TH1F*>(fHistList->FindObject("fVzeroADCC")))->Fill(vzeroAdcC);
665
666 // -- VZERO - TPC correlations
667 if (fESDEvent->GetNumberOfTracks() > 0) {
668 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroNch")))->Fill(fVzeroMult, fTpcTracksA);
669 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroANch")))->Fill(fVzeroMultA, fTpcTracksA);
670 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroCNch")))->Fill(fVzeroMultC, fTpcTracksA);
671
672 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFNch")))->Fill(fVzeroMultFlagged, fTpcTracksA);
673 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFANch")))->Fill(fVzeroMultFlaggedA, fTpcTracksA);
674 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFCNch")))->Fill(fVzeroMultFlaggedC, fTpcTracksA);
675 }
676
677 return iResult;
678}
679
680//##################################################################################
681Int_t AliHLTMultiplicityCorrelations::ProcessZDC() {
682
683 Int_t iResult = 0 ;
684
685 Double_t zdcEznA = fESDZDC->GetZDCN2Energy() / 1000.;
686 Double_t zdcEznC = fESDZDC->GetZDCN1Energy() / 1000.;
687 Double_t zdcEzn = zdcEznA + zdcEznC;
688
689 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzn")))->Fill(zdcEzn);
690 (static_cast<TH1F*>(fHistList->FindObject("fZdcEznA")))->Fill(zdcEznA);
691 (static_cast<TH1F*>(fHistList->FindObject("fZdcEznC")))->Fill(zdcEznC);
692
693 Double_t zdcEzpA = fESDZDC->GetZDCP2Energy() / 1000.;
694 Double_t zdcEzpC = fESDZDC->GetZDCP1Energy() / 1000.;
695 Double_t zdcEzp = zdcEzpA + zdcEzpC;
696
697 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzp")))->Fill(zdcEzp);
698 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzpA")))->Fill(zdcEzpA);
699 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzpC")))->Fill(zdcEzpC);
700
701 Double_t zdcEA = (zdcEznA + zdcEzpA);
702 Double_t zdcEC = (zdcEznC + zdcEzpC);
703 Double_t zdcE = zdcEA + zdcEC;
704
705 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdc")))->Fill(zdcE);
706 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdcA")))->Fill(zdcEA);
707 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdcC")))->Fill(zdcEC);
708
709 Double_t zdcEzemA = fESDZDC->GetZDCEMEnergy(1) / 1000.;
710 Double_t zdcEzemC = fESDZDC->GetZDCEMEnergy(0) / 1000.;
711 Double_t zdcEzem = zdcEzemA + zdcEzemC;
712
713 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzem")))->Fill(zdcEzem);
714 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzemA")))->Fill(zdcEzemA);
715 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzemC")))->Fill(zdcEzemC);
716
717 (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdc")))->Fill(zdcEzem, zdcE);
718 (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdcA")))->Fill(zdcEzemA, zdcEA);
719 (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdcC")))->Fill(zdcEzemC, zdcEC);
720
721 (static_cast<TH1F*>(fHistList->FindObject("fZdcNpart")))->Fill(fESDZDC->GetZDCParticipants());
722 (static_cast<TH1F*>(fHistList->FindObject("fZdcNpartA")))->Fill(fESDZDC->GetZDCPartSideA());
723 (static_cast<TH1F*>(fHistList->FindObject("fZdcNpartC")))->Fill(fESDZDC->GetZDCPartSideC());
724
725 (static_cast<TH1F*>(fHistList->FindObject("fZdcB")))->Fill(fESDZDC->GetImpactParameter());
726 (static_cast<TH1F*>(fHistList->FindObject("fZdcBA")))->Fill(fESDZDC->GetImpactParamSideA());
727 (static_cast<TH1F*>(fHistList->FindObject("fZdcBC")))->Fill(fESDZDC->GetImpactParamSideC());
728
729 // -- ZDC - TPC correlations
730 if (fESDEvent->GetNumberOfTracks() > 0) {
731 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcNch")))->Fill(zdcE, fTpcTracksA);
732 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcANch")))->Fill(zdcEA, fTpcTracksA);
733 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcCNch")))->Fill(zdcEC, fTpcTracksA);
734
735 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemNch")))->Fill(zdcEzem, fTpcTracksA);
736 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemANch")))->Fill(zdcEzemA, fTpcTracksA);
737 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemCNch")))->Fill(zdcEzemC, fTpcTracksA);
738
739 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpNch")))->Fill(zdcEzp, fTpcTracksA);
740 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpANch")))->Fill(zdcEzpA, fTpcTracksA);
741 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpCNch")))->Fill(zdcEzpC, fTpcTracksA);
742
743 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznNch")))->Fill(zdcEzn, fTpcTracksA);
744 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznANch")))->Fill(zdcEznA, fTpcTracksA);
745 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznCNch")))->Fill(zdcEznC, fTpcTracksA);
746
747 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartNch")))->Fill(fESDZDC->GetZDCParticipants(), fTpcTracksA);
748 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartANch")))->Fill(fESDZDC->GetZDCPartSideA(), fTpcTracksA);
749 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartCNch")))->Fill(fESDZDC->GetZDCPartSideC(), fTpcTracksA);
750
751 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbNch")))->Fill(fESDZDC->GetImpactParameter(), fTpcTracksA);
752 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbANch")))->Fill(fESDZDC->GetImpactParamSideA(), fTpcTracksA);
753 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbCNch")))->Fill(fESDZDC->GetImpactParamSideC(), fTpcTracksA);
754 }
755
756 // -- VZERO - TPC correlations
757 if (fESDVZERO) {
758 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzero")))->Fill(zdcE, fVzeroMult);
759 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroA")))->Fill(zdcEA, fVzeroMultA);
760 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroC")))->Fill(zdcEC, fVzeroMultC);
761
762 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzero")))->Fill(zdcEzem, fVzeroMult);
763 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroA")))->Fill(zdcEzemA, fVzeroMultA);
764 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroC")))->Fill(zdcEzemC, fVzeroMultC);
765
766 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzero")))->Fill(zdcEzp, fVzeroMult);
767 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroA")))->Fill(zdcEzpA, fVzeroMultA);
768 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroC")))->Fill(zdcEzpC, fVzeroMultC);
769
770 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzero")))->Fill(zdcEzn, fVzeroMult);
771 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroA")))->Fill(zdcEznA, fVzeroMultA);
772 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroC")))->Fill(zdcEznC, fVzeroMultC);
773
774 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzero")))->Fill(fESDZDC->GetZDCParticipants(), fVzeroMult);
775 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroA")))->Fill(fESDZDC->GetZDCPartSideA(), fVzeroMultA);
776 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroC")))->Fill(fESDZDC->GetZDCPartSideC(), fVzeroMultC);
777
778 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzero")))->Fill(fESDZDC->GetImpactParameter(), fVzeroMult);
779 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroA")))->Fill(fESDZDC->GetImpactParamSideA(), fVzeroMultA);
780 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroC")))->Fill(fESDZDC->GetImpactParamSideC(), fVzeroMultC);
781
782 // -- -- -- --
783
784 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroF")))->Fill(zdcE, fVzeroMultFlagged);
785 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroFA")))->Fill(zdcEA, fVzeroMultFlaggedA);
786 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroFC")))->Fill(zdcEC, fVzeroMultFlaggedC);
787
788 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroF")))->Fill(zdcEzem, fVzeroMultFlagged);
789 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroFA")))->Fill(zdcEzemA, fVzeroMultFlaggedA);
790 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroFC")))->Fill(zdcEzemC, fVzeroMultFlaggedC);
791
792 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroF")))->Fill(zdcEzp, fVzeroMultFlagged);
793 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroFA")))->Fill(zdcEzpA, fVzeroMultFlaggedA);
794 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroFC")))->Fill(zdcEzpC, fVzeroMultFlaggedC);
795
796 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroF")))->Fill(zdcEzn, fVzeroMultFlagged);
797 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroFA")))->Fill(zdcEznA, fVzeroMultFlaggedA);
798 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroFC")))->Fill(zdcEznC, fVzeroMultFlaggedC);
799
800 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzero")))->Fill(fESDZDC->GetZDCParticipants(), fVzeroMultFlagged);
801 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroFA")))->Fill(fESDZDC->GetZDCPartSideA(), fVzeroMultFlaggedA);
802 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroFC")))->Fill(fESDZDC->GetZDCPartSideC(), fVzeroMultFlaggedC);
803
804 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroF")))->Fill(fESDZDC->GetImpactParameter(), fVzeroMultFlagged);
805 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroFA")))->Fill(fESDZDC->GetImpactParamSideA(), fVzeroMultFlaggedA);
806 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroFC")))->Fill(fESDZDC->GetImpactParamSideC(), fVzeroMultFlaggedC);
807 }
808
809 return iResult;
810}