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