git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- adding E_t - V0 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.),
a75a9dbe 64 fZnpBinning(200),fZnpBinningMin(0.),fZnpBinningMax(100.),
65 fProcessPhos(true), fProcessEmcal(true),
66 fPhosTotalEt(0.0), fEmcalTotalEt(0.0),
67 fCaloBinning(100),fCaloBinningMin(0.),fCaloBinningMax(100.){
06f2306d 68 // see header file for class documentation
69 // or
70 // refer to README to build package
71 // or
72 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
73
74}
75
76//##################################################################################
77AliHLTMultiplicityCorrelations::~AliHLTMultiplicityCorrelations() {
78 // see header file for class documentation
79
80 if ( fHistList ) {
81 fHistList->Clear();
82 delete fHistList;
83 }
84 fHistList = NULL;
85}
86
87/*
88 * ---------------------------------------------------------------------------------
89 * Initialize / Reset
90 * ---------------------------------------------------------------------------------
91 */
92
93//##################################################################################
94Int_t AliHLTMultiplicityCorrelations::Initialize() {
95 // see header file for class documentation
96
97 Int_t iResult = 0;
98
99 fHistList = new TList();
100 fHistList->SetOwner(kTRUE);
101
102 iResult = SetupHistograms();
103
104 return iResult;
105}
106
107/*
108 * ---------------------------------------------------------------------------------
109 * Output - public
110 * ---------------------------------------------------------------------------------
111 */
112
113//##################################################################################
114Int_t AliHLTMultiplicityCorrelations::ProcessEvent( AliESDEvent *esd ) {
115 // see header file for class documentation
116
117 Int_t iResult = 0;
118
119 if ( ! AddESDEvent(esd) ) {
120 HLTWarning("No ESD event.");
121 return -1;
122 }
123
124 // -- TPC .. To be done before the others
125 if (fESDEvent->GetNumberOfTracks() > 0)
126 iResult = ProcessTPC();
a75a9dbe 127
128 // -- CALO, process with or without clusters, we want the zero-bin
129 iResult = ProcessCALO();
130
06f2306d 131 // -- VZERO
132 if (fESDVZERO)
133 iResult = ProcessVZERO();
134
135 // -- ZDC and Correlations
136 if (fESDZDC)
137 iResult = ProcessZDC();
138
139
140 return iResult;
141}
142
143////////////////////////////////////////////////////////////////////////////////////
144////////////////////////////////////////////////////////////////////////////////////
145/// ///
146////// PRIVATE //////
147/// ///
148////////////////////////////////////////////////////////////////////////////////////
149////////////////////////////////////////////////////////////////////////////////////
150
151/*
152 * ---------------------------------------------------------------------------------
153 * Setup / Initialize - private
154 * ---------------------------------------------------------------------------------
155 */
156
157//##################################################################################
158Bool_t AliHLTMultiplicityCorrelations::AddESDEvent( AliESDEvent* esd ) {
159 // see header file for class documentation
160
161 fESDEvent = esd;
162
163 // -- Check for ESD
164 if ( !fESDEvent ) {
165 HLTWarning("No ESD event present.");
166 return kFALSE;
167 }
168
169 // -- Check for PrimaryVertex
170 if ( !esd->GetPrimaryVertexTracks() ){
171 HLTError("No Vertex present.");
172 return kFALSE;
173 }
174
175 fESDZDC = esd->GetESDZDC();
176 if ( !fESDZDC ) {
177 HLTInfo("No ZDC information !");
178 }
179
180 fESDVZERO = esd->GetVZEROData();
181 if ( !fESDVZERO ) {
182 HLTInfo("No VZERO information !");
183 }
184
185 return kTRUE;
186}
187
188//##################################################################################
189Int_t AliHLTMultiplicityCorrelations::SetupHistograms() {
190 // see header file for class documentation
191
192 Int_t iResult = 0;
193
194 iResult = SetupVZERO();
195 iResult = SetupZDC();
196 iResult = SetupTPC();
a75a9dbe 197 iResult = SetupCALO();
06f2306d 198 iResult = SetupCorrelations();
199
200 return iResult;
201}
202
203//##################################################################################
204Int_t AliHLTMultiplicityCorrelations::SetupVZERO() {
205 // see header file for class documentation
206
207 // VzeroMult
208 fHistList->Add(new TH1F("fVzeroMult", "Multiplicity^{VZERO};Multiplicity^{VZERO};N_{Events}",
209 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
210 fHistList->Add(new TH1F("fVzeroMultA", "Multiplicity^{VZERO} A;Multiplicity^{VZERO};N_{Events}",
211 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
212 fHistList->Add(new TH1F("fVzeroMultC", "Multiplicity^{VZERO} C;Multiplicity^{VZERO};N_{Events}",
213 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
214
215 // Flagged VzeroMult
216 fHistList->Add(new TH1F("fVzeroFlaggedMult", "Multiplicity_{flagged}^{VZERO};Multiplicity^{VZERO};N_{Events}",
217 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
218 fHistList->Add(new TH1F("fVzeroFlaggedMultA", "Multiplicity_{flagged}^{VZERO} A;Multiplicity^{VZERO};N_{Events}",
219 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
220 fHistList->Add(new TH1F("fVzeroFlaggedMultC", "Multiplicity_{flagged}^{VZERO} C;Multiplicity^{VZERO};N_{Events}",
221 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
222
223 fHistList->Add(new TH1F("fVzeroTime", "Time;Time;N_{Events}", 500, 0, 1000));
224 fHistList->Add(new TH1F("fVzeroTimeA", "Time A;Time;N_{Events}", 500, 0, 1000));
225 fHistList->Add(new TH1F("fVzeroTimeC", "Time B;Time;N_{Events}", 500, 0, 1000));
226
227 fHistList->Add(new TH1F("fVzeroADC", "ADC;ADC;N_{Events}", 500, 0, 150000));
228 fHistList->Add(new TH1F("fVzeroADCA", "ADC A;ADC;N_{Events}", 500, 0, 100000));
229 fHistList->Add(new TH1F("fVzeroADCC", "ADC B;ADC;N_{Events}", 500, 0, 100000));
230
231 return 0;
232}
233
234//##################################################################################
235Int_t AliHLTMultiplicityCorrelations::SetupZDC() {
236 // see header file for class documentation
237
238 // E_{ZN}
239 fHistList->Add(new TH1F("fZdcEzn", "E_{ZN};E_{ZN} (TeV);N_{Events}",
240 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
241 fHistList->Add(new TH1F("fZdcEznA", "E_{ZN} A;E_{ZN} (TeV);N_{Events}",
242 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
243 fHistList->Add(new TH1F("fZdcEznC", "E_{ZN} C;E_{ZN} (TeV);N_{Events}",
244 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
245
246 // E_{ZP}
247 fHistList->Add(new TH1F("fZdcEzp", "E_{ZP};E_{ZP} (TeV);N_{Events}",
248 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
249 fHistList->Add(new TH1F("fZdcEzpA", "E_{ZP} A;E_{ZP} (TeV);N_{Events}",
250 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
251 fHistList->Add(new TH1F("fZdcEzpC", "E_{ZP} C;E_{ZP} (TeV);N_{Events}",
252 fZnpBinning,fZnpBinningMin,fZnpBinningMax));
253
254 // E_{ZDC}
255 fHistList->Add(new TH1F("fZdcEzdc", "E_{ZDC};E_{ZDC} (TeV);N_{Events}",
256 fZdcBinning,fZdcBinningMin,fZdcBinningMax));
257 fHistList->Add(new TH1F("fZdcEzdcA", "E_{ZDC} A;E_{ZDC} (TeV);N_{Events}",
258 fZdcBinning,fZdcBinningMin,fZdcBinningMax));
259 fHistList->Add(new TH1F("fZdcEzdcC", "E_{ZDC} C;E_{ZDC} (TeV);N_{Events}",
260 fZdcBinning,fZdcBinningMin,fZdcBinningMax));
261
262 // E_{ZEM}
263 fHistList->Add(new TH1F("fZdcEzem", "E_{ZEM};E_{ZEM} (TeV);N_{Events}",
264 fZemBinning,fZemBinningMin,fZemBinningMax));
265 fHistList->Add(new TH1F("fZdcEzemA", "E_{ZEM} A;E_{ZEM} (TeV);N_{Events}",
266 fZemBinning,fZemBinningMin,fZemBinningMax));
267 fHistList->Add(new TH1F("fZdcEzemC", "E_{ZEM} C;E_{ZEM} (TeV);N_{Events}",
268 fZemBinning,fZemBinningMin,fZemBinningMax));
269
270 // N_{Part}
271 fHistList->Add(new TH1F("fZdcNpart", "N_{Part} ;N_{Part};N_{Events}", 50,0,499));
272 fHistList->Add(new TH1F("fZdcNpartA", "N_{Part} A;N_{Part};N_{Events}", 50,0,499));
273 fHistList->Add(new TH1F("fZdcNpartC", "N_{Part} C;N_{Part};N_{Events}", 50,0,499));
274
275 // b
276 fHistList->Add(new TH1F("fZdcB", "b;b {fm);N_{Events}", 31,0,30));
277 fHistList->Add(new TH1F("fZdcBA", "b A;b (fm);N_{Events}", 31,0,30));
278 fHistList->Add(new TH1F("fZdcBC", "b C;b (fm);N_{Events}", 31,0,30));
279
280 // E_{ZEM} vs E_{ZDC}
281 fHistList->Add(new TH2F("fZdcEzemEzdc", "E_{ZEM} vs E_{ZDC};E_{ZEM} (TeV); E_{ZDC} (TeV)",
282 fZemBinning,fZemBinningMin,fZemBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax));
283 fHistList->Add(new TH2F("fZdcEzemEzdcA","E_{ZEM} vs E_{ZDC} A;E_{ZEM} (TeV); E_{ZDC} (TeV)",
284 fZemBinning,fZemBinningMin,fZemBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax));
285 fHistList->Add(new TH2F("fZdcEzemEzdcC","E_{ZEM} vs E_{ZDC} C;E_{ZEM} (TeV); E_{ZDC} (TeV)",
286 fZemBinning,fZemBinningMin,fZemBinningMax, fZdcBinning,fZdcBinningMin,fZdcBinningMax));
287
288 return 0;
289}
290
291//##################################################################################
292Int_t AliHLTMultiplicityCorrelations::SetupTPC() {
293 // see header file for class documentation
294
295 Int_t n = 50;
296 Double_t s = 0.1;
297 Double_t e = 50.;
298
299 // -- Create LogPtBinning
300 // ------------------------
301 Double_t logMin = TMath::Log10(s);
302 Double_t logMax = TMath::Log10(e);
303 Double_t binwidth = (logMax-logMin)/n;
304
305 Double_t *logBinning = new Double_t[n+1];
306
307 logBinning[0] = s;
308 for (Int_t ii = 1; ii <= n; ii++)
309 logBinning[ii] = s + TMath::Power(10, logMin + ii*binwidth);
310 // - - - - - - - - - - - - - - - - - - - - - - - - - - -
311
312 // dN_{ch} / dP_{T}
313 fHistList->Add(new TH1F("fTpcPt0", "dN_{ch} / dP_{T} esdTracks; P_{T} (GeV/c);dN/dP_{T} (c/GeV)", n, logBinning));
314 fHistList->Add(new TH1F("fTpcPt1", "dN_{ch} / dP_{T} accepted esdTracks; P_{T} (GeV/c);dN/dP_{T} (c/GeV)", n, logBinning));
315 fHistList->Add(new TH1F("fTpcPt2", "dN_{ch} / dP_{T} tpcTracks; P_{T} (GeV/c);dN/dP_{T} (c/GeV)", n, logBinning));
316 fHistList->Add(new TH1F("fTpcPt3", "dN_{ch} / dP_{T} accepted tpcTracks; P_{T} (GeV/c);dN/dP_{T} (c/GeV)", n, logBinning));
317
318 // Multiplicty
319 fHistList->Add(new TH1F("fTpcNch0", "N_{ch} esdTracks; N_{ch};N_{Events}",
320 fTpcBinning,fTpcBinningMin,fTpcBinningMax));
321 fHistList->Add(new TH1F("fTpcNch1", "N_{ch} accepted esdTracks; N_{ch};N_{Events}",
322 fTpcBinning,fTpcBinningMin,fTpcBinningMax));
323 fHistList->Add(new TH1F("fTpcNch2", "N_{ch} tpcTracks; N_{ch};N_{Events}",
324 fTpcBinning,fTpcBinningMin,fTpcBinningMax));
325 fHistList->Add(new TH1F("fTpcNch3", "N_{ch} accepted tpcTracks; N_{ch};N_{Events}",
326 fTpcBinning,fTpcBinningMin,fTpcBinningMax));
327
328 return 0;
329}
330
331//##################################################################################
332Int_t AliHLTMultiplicityCorrelations::SetupCorrelations() {
333 // see header file for class documentation
334
335 // ----------------------------------------------------
336 // ZDC vs TPC
337 // ----------------------------------------------------
338
339 // E_{ZDC} vs N_{ch}
340 fHistList->Add(new TH2F("fCorrEzdcNch", "E_{ZDC} vs N_{ch}^{TPC};E_{ZDC} (TeV);N_{ch}^{TPC}",
341 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
342 fHistList->Add(new TH2F("fCorrEzdcANch","E_{ZDC} vs N_{ch}^{TPC} A;E_{ZDC} (TeV);N_{ch}^{TPC}",
343 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
344 fHistList->Add(new TH2F("fCorrEzdcCNch","E_{ZDC} vs N_{ch}^{TPC} C;E_{ZDC} (TeV);N_{ch}^{TPC}",
345 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
346
347 // E_{ZEM} vs N_{ch}
348 fHistList->Add(new TH2F("fCorrEzemNch", "E_{ZEM} vs N_{ch}^{TPC};E_{ZEM} (TeV);N_{ch}^{TPC}",
349 fZemBinning,fZemBinningMin,fZemBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
350 fHistList->Add(new TH2F("fCorrEzemANch","E_{ZEM} vs N_{ch}^{TPC} A;E_{ZEM} (TeV);N_{ch}^{TPC}",
351 fZemBinning,fZemBinningMin,fZemBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
352 fHistList->Add(new TH2F("fCorrEzemCNch","E_{ZEM} vs N_{ch}^{TPC} C;E_{ZEM} (TeV);N_{ch}^{TPC}",
353 fZemBinning,fZemBinningMin,fZemBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
354
355 // E_{ZP} vs N_{ch}
356 fHistList->Add(new TH2F("fCorrEzpNch", "E_{ZP} vs N_{ch}^{TPC};E_{ZP} (TeV);N_{ch}^{TPC}",
357 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
358 fHistList->Add(new TH2F("fCorrEzpANch","E_{ZP} vs N_{ch}^{TPC} A;E_{ZP} (TeV);N_{ch}^{TPC}",
359 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
360 fHistList->Add(new TH2F("fCorrEzpCNch","E_{ZP} vs N_{ch}^{TPC} C;E_{ZP} (TeV);N_{ch}^{TPC}",
361 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
362
363 // E_{ZN} vs N_{ch}
364 fHistList->Add(new TH2F("fCorrEznNch", "E_{ZN} vs N_{ch}^{TPC};E_{ZN} (TeV);N_{ch}^{TPC}",
365 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
366 fHistList->Add(new TH2F("fCorrEznANch","E_{ZN} vs N_{ch}^{TPC} A;E_{ZN} (TeV);N_{ch}^{TPC}",
367 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
368 fHistList->Add(new TH2F("fCorrEznCNch","E_{ZN} vs N_{ch}^{TPC} C;E_{ZN} (TeV);N_{ch}^{TPC}",
369 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
370
371 // N_{Part} vs N_{ch}
372 fHistList->Add(new TH2F("fCorrZdcNpartNch", "N_{part} vs N_{ch}^{TPC};N_{Events};N_{ch}^{TPC}",
373 50,0,499, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
374 fHistList->Add(new TH2F("fCorrZdcNpartANch","N_{part} vs N_{ch}^{TPC} A;N_{Events};N_{ch}^{TPC}",
375 50,0,499, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
376 fHistList->Add(new TH2F("fCorrZdcNpartCNch","N_{part} vs N_{ch}^{TPC} C;N_{Events};N_{ch}^{TPC}",
377 50,0,499, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
378
379 // b vs N_{ch}
380 fHistList->Add(new TH2F("fCorrZdcbNch", "b_{ZDC} vs N_{ch}^{TPC};b (fm);N_{ch}^{TPC}",
381 31,0,30, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
382 fHistList->Add(new TH2F("fCorrZdcbANch","b_{ZDC} vs N_{ch}^{TPC} A;b (fm);N_{ch}^{TPC}",
383 31,0,30, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
384 fHistList->Add(new TH2F("fCorrZdcbCNch","b_{ZDC} vs N_{ch}^{TPC} C;b (fm);N_{ch}^{TPC}",
385 31,0,30, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
386
387 // ----------------------------------------------------
388 // ZDC vs VZERO
389 // ----------------------------------------------------
390
391 // E_{ZDC} vs Multiplicty VZERO
392 fHistList->Add(new TH2F("fCorrEzdcVzero",
393 "E_{ZDC} vs Multiplicity^{VZERO};E_{ZDC} (TeV);Multiplicity^{VZERO}",
394 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
395 fHistList->Add(new TH2F("fCorrEzdcVzeroA",
396 "E_{ZDC} vs Multiplicity^{VZERO} A;E_{ZDC} (TeV);Multiplicity^{VZERO}",
397 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
398 fHistList->Add(new TH2F("fCorrEzdcVzeroC",
399 "E_{ZDC} vs Multiplicity^{VZERO} C;E_{ZDC} (TeV);Multiplicity^{VZERO}",
400 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
401
402 // E_{ZEM} vs Multiplicty VZERO
403 fHistList->Add(new TH2F("fCorrEzemVzero",
404 "E_{ZEM} vs Multiplicity^{VZERO};E_{ZEM} (TeV);Multiplicity^{VZERO}",
405 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
406 fHistList->Add(new TH2F("fCorrEzemVzeroA",
407 "E_{ZEM} vs Multiplicity^{VZERO} A;E_{ZEM} (TeV);Multiplicity^{VZERO}",
408 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
409 fHistList->Add(new TH2F("fCorrEzemVzeroC",
410 "E_{ZEM} vs Multiplicity^{VZERO} C;E_{ZEM} (TeV);Multiplicity^{VZERO}",
411 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
412
413 // E_{ZP} vs Multiplicty VZERO
414 fHistList->Add(new TH2F("fCorrEzpVzero",
415 "E_{ZP} vs Multiplicity^{VZERO};E_{ZP} (TeV);Multiplicity^{VZERO}",
416 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
417 fHistList->Add(new TH2F("fCorrEzpVzeroA",
418 "E_{ZP} vs Multiplicity^{VZERO} A;E_{ZP} (TeV);Multiplicity^{VZERO}",
419 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
420 fHistList->Add(new TH2F("fCorrEzpVzeroC",
421 "E_{ZP} vs Multiplicity^{VZERO} C;E_{ZP} (TeV);Multiplicity^{VZERO}",
422 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
423
424 // E_{ZN} vs Multiplicty VZERO
425 fHistList->Add(new TH2F("fCorrEznVzero",
426 "E_{ZN} vs Multiplicity^{VZERO};E_{ZN} (TeV);Multiplicity^{VZERO}",
427 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
428 fHistList->Add(new TH2F("fCorrEznVzeroA",
429 "E_{ZN} vs Multiplicity^{VZERO} A;E_{ZN} (TeV);Multiplicity^{VZERO}",
430 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
431 fHistList->Add(new TH2F("fCorrEznVzeroC",
432 "E_{ZN} vs Multiplicity^{VZERO} C;E_{ZN} (TeV);Multiplicity^{VZERO}",
433 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
434
435 // N_{Part} vs Multiplicty VZERO
436 fHistList->Add(new TH2F("fCorrZdcNpartVzero",
437 "N_{part} vs Multiplicity^{VZERO};N_{Events};Multiplicity^{VZERO}",
438 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
439 fHistList->Add(new TH2F("fCorrZdcNpartVzeroA",
440 "N_{part} vs Multiplicity^{VZERO} A;N_{Events};Multiplicity^{VZERO}",
441 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
442 fHistList->Add(new TH2F("fCorrZdcNpartVzeroC",
443 "N_{part} vs Multiplicity^{VZERO} C;N_{Events};Multiplicity^{VZERO}",
444 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
445
446 // b vs Multiplicty VZERO
447 fHistList->Add(new TH2F("fCorrZdcbVzero", "b_{ZDC} vs Multiplicity^{VZERO};b (fm);Multiplicity^{VZERO}",
448 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
449 fHistList->Add(new TH2F("fCorrZdcbVzeroA","b_{ZDC} vs Multiplicity^{VZERO} A;b (fm);Multiplicity^{VZERO}",
450 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
451 fHistList->Add(new TH2F("fCorrZdcbVzeroC","b_{ZDC} vs Multiplicity^{VZERO} C;b (fm);Multiplicity^{VZERO}",
452 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
453
454 // -- -- -- -- -- -- --
455
456 // E_{ZDC} vs Multiplicty VZERO flagged
457 fHistList->Add(new TH2F("fCorrEzdcVzeroF",
458 "E_{ZDC} vs Multiplicity_{flagged}^{VZERO};E_{ZDC} (TeV);Multiplicity^{VZERO}",
459 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
460 fHistList->Add(new TH2F("fCorrEzdcVzeroFA",
461 "E_{ZDC} vs Multiplicity_{flagged}^{VZERO} A;E_{ZDC} (TeV);Multiplicity^{VZERO}",
462 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
463 fHistList->Add(new TH2F("fCorrEzdcVzeroFC",
464 "E_{ZDC} vs Multiplicity_{flagged}^{VZERO} C;E_{ZDC} (TeV);Multiplicity^{VZERO}",
465 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
466
467 // E_{ZEM} vs Multiplicty VZERO flagged
468 fHistList->Add(new TH2F("fCorrEzemVzeroF",
469 "E_{ZEM} vs Multiplicity_{flagged}^{VZERO};E_{ZEM} (TeV);Multiplicity^{VZERO}",
470 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
471 fHistList->Add(new TH2F("fCorrEzemVzeroFA",
472 "E_{ZEM} vs Multiplicity_{flagged}^{VZERO} A;E_{ZEM} (TeV);Multiplicity^{VZERO}",
473 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
474 fHistList->Add(new TH2F("fCorrEzemVzeroFC",
475 "E_{ZEM} vs Multiplicity_{flagged}^{VZERO} C;E_{ZEM} (TeV);Multiplicity^{VZERO}",
476 fZemBinning,fZemBinningMin,fZemBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
477
478 // E_{ZP} vs Multiplicty VZERO flagged
479 fHistList->Add(new TH2F("fCorrEzpVzeroF",
480 "E_{ZP} vs Multiplicity_{flagged}^{VZERO};E_{ZP} (TeV);Multiplicity^{VZERO}",
481 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
482 fHistList->Add(new TH2F("fCorrEzpVzeroFA",
483 "E_{ZP} vs Multiplicity_{flagged}^{VZERO} A;E_{ZP} (TeV);Multiplicity^{VZERO}",
484 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
485 fHistList->Add(new TH2F("fCorrEzpVzeroFC",
486 "E_{ZP} vs Multiplicity_{flagged}^{VZERO} C;E_{ZP} (TeV);Multiplicity^{VZERO}",
487 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
488
489 // E_{ZN} vs Multiplicty VZERO flagged
490 fHistList->Add(new TH2F("fCorrEznVzeroF",
491 "E_{ZN} vs Multiplicity_{flagged}^{VZERO};E_{ZN} (TeV);Multiplicity^{VZERO}",
492 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
493 fHistList->Add(new TH2F("fCorrEznVzeroFA",
494 "E_{ZN} vs Multiplicity_{flagged}^{VZERO} A;E_{ZN} (TeV);Multiplicity^{VZERO}",
495 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
496 fHistList->Add(new TH2F("fCorrEznVzeroFC",
497 "E_{ZN} vs Multiplicity_{flagged}^{VZERO} C;E_{ZN} (TeV);Multiplicity^{VZERO}",
498 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
499
500 // N_{Part} vs Multiplicty VZERO flagged
501 fHistList->Add(new TH2F("fCorrZdcNpartVzeroF",
502 "N_{part} vs Multiplicity_{flagged}^{VZERO};N_{Events};Multiplicity^{VZERO}",
503 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
504 fHistList->Add(new TH2F("fCorrZdcNpartVzeroFA",
505 "N_{part} vs Multiplicity_{flagged}^{VZERO} A;N_{Events};Multiplicity^{VZERO}",
506 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
507 fHistList->Add(new TH2F("fCorrZdcNpartVzeroFC",
508 "N_{part} vs Multiplicity_{flagged}^{VZERO} C;N_{Events};Multiplicity^{VZERO}",
509 50,0,499, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
510
511 // b vs Multiplicty VZERO flagged
512 fHistList->Add(new TH2F("fCorrZdcbVzeroF",
513 "b_{ZDC} vs Multiplicity_{flagged}^{VZERO};b (fm);Multiplicity^{VZERO}",
514 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
515 fHistList->Add(new TH2F("fCorrZdcbVzeroFA",
516 "b_{ZDC} vs Multiplicity_{flagged}^{VZERO} A;b (fm);Multiplicity^{VZERO}",
517 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
518 fHistList->Add(new TH2F("fCorrZdcbVzeroFC",
519 "b_{ZDC} vs Multiplicity_{flagged}^{VZERO} C;b (fm);Multiplicity^{VZERO}",
520 31,0,30, fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax));
521
522 // ----------------------------------------------------
523 // VZERO vs TPC
524 // ----------------------------------------------------
525
526 fHistList->Add(new TH2F("fCorrVzeroNch",
527 "Multiplicity^{VZERO} vs N_{ch}^{TPC};Multiplicity^{VZERO};N_{ch}^{TPC}",
528 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
529 fHistList->Add(new TH2F("fCorrVzeroANch",
530 "Multiplicity^{VZERO} vs N_{ch}^{TPC} A;Multiplicity^{VZERO};N_{ch}^{TPC}",
531 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
532 fHistList->Add(new TH2F("fCorrVzeroCNch",
533 "Multiplicity^{VZERO} vs N_{ch}^{TPC} C;Multiplicity^{VZERO};N_{ch}^{TPC}",
534 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
535
536 fHistList->Add(new TH2F("fCorrVzeroFNch",
537 "Multiplicity^{VZERO} vs N_{ch}^{TPC};Multiplicity_{flagged}^{VZERO};N_{ch}^{TPC}",
538 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
539 fHistList->Add(new TH2F("fCorrVzeroFANch",
540 "Multiplicity^{VZERO} vs N_{ch}^{TPC} A;Multiplicity_{flagged}^{VZERO};N_{ch}^{TPC}",
541 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
542 fHistList->Add(new TH2F("fCorrVzeroFCNch",
543 "Multiplicity^{VZERO} vs N_{ch}^{TPC} C;Multiplicity_{flagged}^{VZERO};N_{ch}^{TPC}",
544 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
545
a75a9dbe 546 // ----------------------------------------------------
547 // ZDC vs CALO
548 // ----------------------------------------------------
549 fHistList->Add(new TH2F("fCorrZdcTotEvsPhosTotEt",
43653719 550 "Total E_{ZDC} vs Total E_{T} in PHOS;Total E_{ZDC} (TeV);E_{T} (GeV)",
a75a9dbe 551 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
552 fHistList->Add(new TH2F("fCorrZdcTotEvsEmcalTotEt",
43653719 553 "Total E_{ZDC} vs Total E_{T} in EMCAL;Total E_{ZDC} (TeV);E_{T} (GeV)",
a75a9dbe 554 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
555 fHistList->Add(new TH2F("fCorrZdcTotEvsTotEt",
43653719 556 "Total E_{ZDC} vs Total E_{T} in calorimeters;Total E_{ZDC} (TeV);E_{T} (GeV)",
a75a9dbe 557 fZdcBinning,fZdcBinningMin,fZdcBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
43653719 558
559 // ----------------------------------------------------
560 // VZERO vs CALO
561 // ----------------------------------------------------
562 fHistList->Add(new TH2F("fCorrVzerovsPhosTotEt",
563 "Multiplicity^{VZERO} vs Total E_{T} in PHOS;Multiplicity^{VZERO};E_{T} (GeV)",
564 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
565 fHistList->Add(new TH2F("fCorrVzerovsEmcalTotEt",
566 "Multiplicity^{VZERO} vs Total E_{T} in EMCAL;Multiplicity^{VZERO};E_{T} (GeV)",
567 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
568 fHistList->Add(new TH2F("fCorrVzerovsTotEt",
569 "Multiplicity^{VZERO} vs Total E_{T} in Calorimeters;Multiplicity^{VZERO};E_{T} (GeV)",
570 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
571
572 fHistList->Add(new TH2F("fCorrVzeroFlaggedvsPhosTotEt",
573 "Multiplicity_{flagged}^{VZERO} vs Total E_{T} in PHOS;Multiplicity_{flagged}^{VZERO};E_{T} (GeV)",
574 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
575 fHistList->Add(new TH2F("fCorrVzeroFlaggedvsEmcalTotEt",
576 "Multiplicity_{flagged}^{VZERO} vs Total E_{T} in EMCAL;Multiplicity_{flagged}^{VZERO};E_{T} (GeV)",
577 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
578 fHistList->Add(new TH2F("fCorrVzeroFlaggedvsTotEt",
579 "Multiplicity_{flagged}^{VZERO} vs Total E_{T} in Calorimeters;Multiplicity_{flagged}^{VZERO};E_{T} (GeV)",
580 fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
a75a9dbe 581
06f2306d 582 // ----------------------------------------------------
583 //
584 // ----------------------------------------------------
585
586 return 0;
587}
588
a75a9dbe 589//##################################################################################
590Int_t AliHLTMultiplicityCorrelations::SetupCALO()
591{
592 // Calo histos
593 if(fProcessPhos)
594 {
595 fHistList->Add(new TH1F("fPhosEt", "Total E_{T} in PHOS:E (GeV)",
596 fCaloBinning,fCaloBinningMin,fCaloBinningMax));
597 }
598 if(fProcessEmcal)
599 {
600 fHistList->Add(new TH1F("fEmcalEt", "Total E_{T} in EMCAL:E (GeV)",
601 fCaloBinning,fCaloBinningMin,fCaloBinningMax));
602 }
603 if(fProcessPhos || fProcessEmcal)
604 {
605 fHistList->Add(new TH1F("fTotalEt", "Total E_{T} in calorimeters:E (GeV)",
606 fCaloBinning,fCaloBinningMin,fCaloBinningMax));
607 }
608 return 0;
609}
610
06f2306d 611/*
612 * ---------------------------------------------------------------------------------
613 * Process - private
614 * ---------------------------------------------------------------------------------
615 */
616
617//##################################################################################
618Int_t AliHLTMultiplicityCorrelations::ProcessTPC() {
619
620 Int_t iResult = 0 ;
621
622 TH1F* hPt0 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt0")); // all
623 TH1F* hPt1 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt1")); // all accepted
624
625 TH1F* hPt2 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt2")); // GetTPCInnerParam
626 TH1F* hPt3 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt3")); // GetTPCInnerParam A
627
628 fEsdTracks = 0;
629 fEsdTracksA = 0;
630 fTpcTracks = 0;
631 fTpcTracksA = 0;
632
633 // -----------------------------------------------------------------
634 for (Int_t idx = 0; idx < fESDEvent->GetNumberOfTracks(); idx++) {
635
636 // -- check track
637 AliESDtrack* esdTrack = fESDEvent->GetTrack(idx);
638 if (!esdTrack) continue;
639
640 ++fEsdTracks;
641 hPt0->Fill(esdTrack->Pt());
642
643 //______________________________________________
644 if (!fESDTrackCuts->AcceptTrack(esdTrack)) continue;
645 ++fEsdTracksA;
646
647 hPt1->Fill(esdTrack->Pt());
648 }
649 // -----------------------------------------------------------------
650 for (Int_t idx = 0; idx < fESDEvent->GetNumberOfTracks(); idx++) {
651
652 // -- check track
653 AliESDtrack* esdTrack = fESDEvent->GetTrack(idx);
654 if (!esdTrack) continue;
655
656 // -- TPC only
657 const AliExternalTrackParam *tpcTrack = esdTrack->GetTPCInnerParam();
658 if (!tpcTrack) continue;
659 ++fTpcTracks;
660 hPt2->Fill(tpcTrack->Pt());
661
662 //______________________________________________
663 if (!fESDTrackCuts->AcceptTrack(esdTrack)) continue;
664 ++fTpcTracksA;
665
666 hPt3->Fill(tpcTrack->Pt());
667 }
668 // -----------------------------------------------------------------
669
670 (static_cast<TH1F*>(fHistList->FindObject("fTpcNch0")))->Fill(fEsdTracks);
671 (static_cast<TH1F*>(fHistList->FindObject("fTpcNch1")))->Fill(fEsdTracksA);
672 (static_cast<TH1F*>(fHistList->FindObject("fTpcNch2")))->Fill(fTpcTracks);
673 (static_cast<TH1F*>(fHistList->FindObject("fTpcNch3")))->Fill(fTpcTracksA);
674
675 return iResult;
676}
677
678//##################################################################################
679Int_t AliHLTMultiplicityCorrelations::ProcessVZERO() {
680
681 Int_t iResult = 0 ;
682
683 fVzeroMultA = fESDVZERO->GetMTotV0A();
684 fVzeroMultC = fESDVZERO->GetMTotV0C();
685 fVzeroMult = fVzeroMultA + fVzeroMultC;
686
687 (static_cast<TH1F*>(fHistList->FindObject("fVzeroMult")))->Fill(fVzeroMult);
688 (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultA")))->Fill(fVzeroMultA);
689 (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultC")))->Fill(fVzeroMultC);
690
691 fVzeroMultFlaggedA = 0.;
692 fVzeroMultFlaggedC = 0.;
693
694 Double_t vzeroTimeA = 0.;
695 Double_t vzeroTimeC = 0.;
696
697 Double_t vzeroAdcA = 0.;
698 Double_t vzeroAdcC = 0.;
699
700 for (Int_t idx = 0; idx < 32; idx++) {
701
702 if ( fESDVZERO->GetBBFlag(idx) )
703 fVzeroMultFlaggedC += fESDVZERO->GetMultiplicityV0C(idx);
704 if ( fESDVZERO->GetBBFlag(idx+32) )
705 fVzeroMultFlaggedA += fESDVZERO->GetMultiplicityV0A(idx);
706
707 vzeroTimeA += fESDVZERO->GetTimeV0A(idx);
708 vzeroTimeC += fESDVZERO->GetTimeV0C(idx);
709
710 vzeroAdcA += fESDVZERO->GetAdcV0A(idx);
711 vzeroAdcC += fESDVZERO->GetAdcV0C(idx);
712 }
713
714 fVzeroMultFlagged = fVzeroMultFlaggedA + fVzeroMultFlaggedC;
715
716 Double_t vzeroTime = vzeroTimeA + vzeroTimeC;
717 Double_t vzeroAdc = vzeroAdcA + vzeroAdcC;
718
719 (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMult")))->Fill(fVzeroMultFlagged);
720 (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMultA")))->Fill(fVzeroMultFlaggedA);
721 (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMultC")))->Fill(fVzeroMultFlaggedC);
722
723 (static_cast<TH1F*>(fHistList->FindObject("fVzeroTime")))->Fill(vzeroTime);
724 (static_cast<TH1F*>(fHistList->FindObject("fVzeroTimeA")))->Fill(vzeroTimeA);
725 (static_cast<TH1F*>(fHistList->FindObject("fVzeroTimeC")))->Fill(vzeroTimeC);
726
727 (static_cast<TH1F*>(fHistList->FindObject("fVzeroADC")))->Fill(vzeroAdc);
728 (static_cast<TH1F*>(fHistList->FindObject("fVzeroADCA")))->Fill(vzeroAdcA);
729 (static_cast<TH1F*>(fHistList->FindObject("fVzeroADCC")))->Fill(vzeroAdcC);
730
731 // -- VZERO - TPC correlations
732 if (fESDEvent->GetNumberOfTracks() > 0) {
733 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroNch")))->Fill(fVzeroMult, fTpcTracksA);
734 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroANch")))->Fill(fVzeroMultA, fTpcTracksA);
735 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroCNch")))->Fill(fVzeroMultC, fTpcTracksA);
736
737 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFNch")))->Fill(fVzeroMultFlagged, fTpcTracksA);
738 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFANch")))->Fill(fVzeroMultFlaggedA, fTpcTracksA);
739 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFCNch")))->Fill(fVzeroMultFlaggedC, fTpcTracksA);
740 }
43653719 741
742 // -- VZERO - CALO correlations
743 if (fProcessPhos || fProcessEmcal) {
744 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsTotEt")))->Fill(fVzeroMult, fPhosTotalEt + fEmcalTotalEt);
745 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsTotEt")))->Fill(fVzeroMultFlagged, fPhosTotalEt + fEmcalTotalEt);
746 if(fProcessPhos)
747 {
748 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsPhosTotEt")))->Fill(fVzeroMult, fPhosTotalEt);
749 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsPhosTotEt")))->Fill(fVzeroMultFlagged, fPhosTotalEt);
750 }
751 if(fProcessEmcal)
752 {
753 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsEmcalTotEt")))->Fill(fVzeroMult, fEmcalTotalEt);
754 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsEmcalTotEt")))->Fill(fVzeroMultFlagged, fEmcalTotalEt);
755 }
756 }
06f2306d 757 return iResult;
758}
759
760//##################################################################################
761Int_t AliHLTMultiplicityCorrelations::ProcessZDC() {
762
763 Int_t iResult = 0 ;
764
765 Double_t zdcEznA = fESDZDC->GetZDCN2Energy() / 1000.;
766 Double_t zdcEznC = fESDZDC->GetZDCN1Energy() / 1000.;
767 Double_t zdcEzn = zdcEznA + zdcEznC;
768
769 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzn")))->Fill(zdcEzn);
770 (static_cast<TH1F*>(fHistList->FindObject("fZdcEznA")))->Fill(zdcEznA);
771 (static_cast<TH1F*>(fHistList->FindObject("fZdcEznC")))->Fill(zdcEznC);
772
773 Double_t zdcEzpA = fESDZDC->GetZDCP2Energy() / 1000.;
774 Double_t zdcEzpC = fESDZDC->GetZDCP1Energy() / 1000.;
775 Double_t zdcEzp = zdcEzpA + zdcEzpC;
776
777 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzp")))->Fill(zdcEzp);
778 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzpA")))->Fill(zdcEzpA);
779 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzpC")))->Fill(zdcEzpC);
780
781 Double_t zdcEA = (zdcEznA + zdcEzpA);
782 Double_t zdcEC = (zdcEznC + zdcEzpC);
783 Double_t zdcE = zdcEA + zdcEC;
784
785 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdc")))->Fill(zdcE);
786 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdcA")))->Fill(zdcEA);
787 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdcC")))->Fill(zdcEC);
788
789 Double_t zdcEzemA = fESDZDC->GetZDCEMEnergy(1) / 1000.;
790 Double_t zdcEzemC = fESDZDC->GetZDCEMEnergy(0) / 1000.;
791 Double_t zdcEzem = zdcEzemA + zdcEzemC;
792
793 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzem")))->Fill(zdcEzem);
794 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzemA")))->Fill(zdcEzemA);
795 (static_cast<TH1F*>(fHistList->FindObject("fZdcEzemC")))->Fill(zdcEzemC);
796
797 (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdc")))->Fill(zdcEzem, zdcE);
798 (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdcA")))->Fill(zdcEzemA, zdcEA);
799 (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdcC")))->Fill(zdcEzemC, zdcEC);
800
801 (static_cast<TH1F*>(fHistList->FindObject("fZdcNpart")))->Fill(fESDZDC->GetZDCParticipants());
802 (static_cast<TH1F*>(fHistList->FindObject("fZdcNpartA")))->Fill(fESDZDC->GetZDCPartSideA());
803 (static_cast<TH1F*>(fHistList->FindObject("fZdcNpartC")))->Fill(fESDZDC->GetZDCPartSideC());
804
805 (static_cast<TH1F*>(fHistList->FindObject("fZdcB")))->Fill(fESDZDC->GetImpactParameter());
806 (static_cast<TH1F*>(fHistList->FindObject("fZdcBA")))->Fill(fESDZDC->GetImpactParamSideA());
807 (static_cast<TH1F*>(fHistList->FindObject("fZdcBC")))->Fill(fESDZDC->GetImpactParamSideC());
808
809 // -- ZDC - TPC correlations
810 if (fESDEvent->GetNumberOfTracks() > 0) {
811 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcNch")))->Fill(zdcE, fTpcTracksA);
812 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcANch")))->Fill(zdcEA, fTpcTracksA);
813 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcCNch")))->Fill(zdcEC, fTpcTracksA);
814
815 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemNch")))->Fill(zdcEzem, fTpcTracksA);
816 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemANch")))->Fill(zdcEzemA, fTpcTracksA);
817 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemCNch")))->Fill(zdcEzemC, fTpcTracksA);
818
819 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpNch")))->Fill(zdcEzp, fTpcTracksA);
820 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpANch")))->Fill(zdcEzpA, fTpcTracksA);
821 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpCNch")))->Fill(zdcEzpC, fTpcTracksA);
822
823 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznNch")))->Fill(zdcEzn, fTpcTracksA);
824 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznANch")))->Fill(zdcEznA, fTpcTracksA);
825 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznCNch")))->Fill(zdcEznC, fTpcTracksA);
826
827 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartNch")))->Fill(fESDZDC->GetZDCParticipants(), fTpcTracksA);
828 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartANch")))->Fill(fESDZDC->GetZDCPartSideA(), fTpcTracksA);
829 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartCNch")))->Fill(fESDZDC->GetZDCPartSideC(), fTpcTracksA);
830
831 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbNch")))->Fill(fESDZDC->GetImpactParameter(), fTpcTracksA);
832 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbANch")))->Fill(fESDZDC->GetImpactParamSideA(), fTpcTracksA);
833 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbCNch")))->Fill(fESDZDC->GetImpactParamSideC(), fTpcTracksA);
834 }
835
836 // -- VZERO - TPC correlations
837 if (fESDVZERO) {
838 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzero")))->Fill(zdcE, fVzeroMult);
839 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroA")))->Fill(zdcEA, fVzeroMultA);
840 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroC")))->Fill(zdcEC, fVzeroMultC);
841
842 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzero")))->Fill(zdcEzem, fVzeroMult);
843 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroA")))->Fill(zdcEzemA, fVzeroMultA);
844 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroC")))->Fill(zdcEzemC, fVzeroMultC);
845
846 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzero")))->Fill(zdcEzp, fVzeroMult);
847 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroA")))->Fill(zdcEzpA, fVzeroMultA);
848 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroC")))->Fill(zdcEzpC, fVzeroMultC);
849
850 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzero")))->Fill(zdcEzn, fVzeroMult);
851 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroA")))->Fill(zdcEznA, fVzeroMultA);
852 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroC")))->Fill(zdcEznC, fVzeroMultC);
853
854 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzero")))->Fill(fESDZDC->GetZDCParticipants(), fVzeroMult);
855 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroA")))->Fill(fESDZDC->GetZDCPartSideA(), fVzeroMultA);
856 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroC")))->Fill(fESDZDC->GetZDCPartSideC(), fVzeroMultC);
857
858 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzero")))->Fill(fESDZDC->GetImpactParameter(), fVzeroMult);
859 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroA")))->Fill(fESDZDC->GetImpactParamSideA(), fVzeroMultA);
860 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroC")))->Fill(fESDZDC->GetImpactParamSideC(), fVzeroMultC);
861
862 // -- -- -- --
863
864 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroF")))->Fill(zdcE, fVzeroMultFlagged);
865 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroFA")))->Fill(zdcEA, fVzeroMultFlaggedA);
866 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroFC")))->Fill(zdcEC, fVzeroMultFlaggedC);
867
868 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroF")))->Fill(zdcEzem, fVzeroMultFlagged);
869 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroFA")))->Fill(zdcEzemA, fVzeroMultFlaggedA);
870 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroFC")))->Fill(zdcEzemC, fVzeroMultFlaggedC);
871
872 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroF")))->Fill(zdcEzp, fVzeroMultFlagged);
873 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroFA")))->Fill(zdcEzpA, fVzeroMultFlaggedA);
874 (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroFC")))->Fill(zdcEzpC, fVzeroMultFlaggedC);
875
876 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroF")))->Fill(zdcEzn, fVzeroMultFlagged);
877 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroFA")))->Fill(zdcEznA, fVzeroMultFlaggedA);
878 (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroFC")))->Fill(zdcEznC, fVzeroMultFlaggedC);
879
880 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzero")))->Fill(fESDZDC->GetZDCParticipants(), fVzeroMultFlagged);
881 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroFA")))->Fill(fESDZDC->GetZDCPartSideA(), fVzeroMultFlaggedA);
882 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroFC")))->Fill(fESDZDC->GetZDCPartSideC(), fVzeroMultFlaggedC);
883
884 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroF")))->Fill(fESDZDC->GetImpactParameter(), fVzeroMultFlagged);
885 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroFA")))->Fill(fESDZDC->GetImpactParamSideA(), fVzeroMultFlaggedA);
886 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroFC")))->Fill(fESDZDC->GetImpactParamSideC(), fVzeroMultFlaggedC);
887 }
888
a75a9dbe 889 // -- ZDC - CALO correlations
890 if (fProcessPhos || fProcessEmcal) {
891 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsTotEt")))->Fill(zdcE, fPhosTotalEt + fEmcalTotalEt);
892 if(fProcessPhos)
893 {
894 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsPhosTotEt")))->Fill(zdcE, fPhosTotalEt);
895 }
896 if(fProcessEmcal)
897 {
898 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsEmcalTotEt")))->Fill(zdcE, fEmcalTotalEt);
899 }
900 }
901
06f2306d 902 return iResult;
903}
a75a9dbe 904
905//##################################################################################
906Int_t AliHLTMultiplicityCorrelations::ProcessCALO()
907{
908 // CALO
909
910 TH1F* hPhosEt = static_cast<TH1F*>(fHistList->FindObject("fPhosEt")); // PHOS Tot E_T
911 TH1F* hEmcalEt = static_cast<TH1F*>(fHistList->FindObject("fEmcalEt")); // EMCAL Tot E_T
912 TH1F* hTotalEt = static_cast<TH1F*>(fHistList->FindObject("fTotalEt")); // CALO Tot E_T
913
914 fPhosTotalEt = 0;
915 fEmcalTotalEt = 0;
916
917 for(Int_t cl = 0; cl < fESDEvent->GetNumberOfCaloClusters(); cl++)
918 {
919
920 AliESDCaloCluster *cluster = fESDEvent->GetCaloCluster(cl);
921 if(cluster->IsPHOS() && fProcessPhos)
922 {
923 fPhosTotalEt += cluster->E();
924 }
925 if(cluster->IsEMCAL() && fProcessEmcal)
926 {
927 fEmcalTotalEt += cluster->E();
928 }
929 }
930
931 if(hPhosEt)hPhosEt->Fill(fPhosTotalEt);
932 if(hEmcalEt)hEmcalEt->Fill(fEmcalTotalEt);
933 if(hTotalEt)hTotalEt->Fill(fPhosTotalEt + fEmcalTotalEt);
934
935 return 0;
936}