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