git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
enable and disable detectors
[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),
60f79eda 56 fProcessTPC(kTRUE), fProcessSPD(kTRUE),
57 fProcessVZERO(kTRUE), fProcessZDC(kTRUE), fProcessCALO(kTRUE),
06f2306d 58 fEsdTracks(0), fEsdTracksA(0),
59 fTpcTracks(0), fTpcTracksA(0),
60 fVzeroMult(0.), fVzeroMultA(0.), fVzeroMultC(0.),
61 fVzeroMultFlagged(0.), fVzeroMultFlaggedA(0.), fVzeroMultFlaggedC(0.),
571ad3a5 62 fSpdNClusters(0), fSpdNClustersInner(0), fSpdNClustersOuter(0),
06f2306d 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.),
a75a9dbe 67 fZnpBinning(200),fZnpBinningMin(0.),fZnpBinningMax(100.),
68 fProcessPhos(true), fProcessEmcal(true),
69 fPhosTotalEt(0.0), fEmcalTotalEt(0.0),
6c552baa 70 fCaloBinning(100),fCaloBinningMin(0.),fCaloBinningMax(100.),
71 fSpdBinning(200),fSpdBinningMin(0.),fSpdBinningMax(15000.) {
06f2306d 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);
7690ff22 105 fHistList->SetName("MultiplicityCorrelations");
06f2306d 106 iResult = SetupHistograms();
60f79eda 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"); }
06f2306d 113
114 return iResult;
115}
116
117/*
118 * ---------------------------------------------------------------------------------
119 * Output - public
120 * ---------------------------------------------------------------------------------
121 */
122
123//##################################################################################
11e88ff8 124Int_t AliHLTMultiplicityCorrelations::ProcessEvent( AliESDEvent *esd, AliESDVZERO* esdVZERO,
125 Int_t nSpdClusters) {
06f2306d 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 }
11e88ff8 134
135 if ( esdVZERO )
136 fESDVZERO = esdVZERO;
06f2306d 137
138 // -- TPC .. To be done before the others
60f79eda 139 if (fESDEvent->GetNumberOfTracks() > 0 && fProcessTPC)
06f2306d 140 iResult = ProcessTPC();
60f79eda 141
6c552baa 142 fSpdNClusters = nSpdClusters;
60f79eda 143 if (fProcessSPD)
144 iResult = ProcessSPD();
a75a9dbe 145
146 // -- CALO, process with or without clusters, we want the zero-bin
60f79eda 147 if (fProcessCALO)
148 iResult = ProcessCALO();
a75a9dbe 149
06f2306d 150 // -- VZERO
60f79eda 151 if (fESDVZERO && fProcessVZERO)
06f2306d 152 iResult = ProcessVZERO();
153
154 // -- ZDC and Correlations
60f79eda 155 if (fESDZDC && fProcessZDC)
06f2306d 156 iResult = ProcessZDC();
60f79eda 157
06f2306d 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
60f79eda 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
06f2306d 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
7690ff22 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
06f2306d 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
7690ff22 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
06f2306d 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 // ----------------------------------------------------
60f79eda 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));
06f2306d 381
60f79eda 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}",
06f2306d 394 fZnpBinning,fZnpBinningMin,fZnpBinningMax, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
60f79eda 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}",
06f2306d 408 31,0,30, fTpcBinning,fTpcBinningMin,fTpcBinningMax));
60f79eda 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 }
06f2306d 414 // ----------------------------------------------------
415 // ZDC vs VZERO
416 // ----------------------------------------------------
60f79eda 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 }
06f2306d 550 // ----------------------------------------------------
551 // VZERO vs TPC
552 // ----------------------------------------------------
60f79eda 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 }
a75a9dbe 575 // ----------------------------------------------------
576 // ZDC vs CALO
577 // ----------------------------------------------------
60f79eda 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 }
43653719 589 // ----------------------------------------------------
590 // VZERO vs CALO
591 // ----------------------------------------------------
60f79eda 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 }
6c552baa 614 // ----------------------------------------------------
615 // SPD vs TPC
616 // ----------------------------------------------------
60f79eda 617 if ( fProcessSPD && fProcessTPC ) {
6c552baa 618
60f79eda 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 }
6c552baa 622 // ----------------------------------------------------
623 // SPD vs VZERO
624 // ----------------------------------------------------
60f79eda 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 }
06f2306d 647 // ----------------------------------------------------
6c552baa 648 // SPD vs ZDC
06f2306d 649 // ----------------------------------------------------
60f79eda 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 }
6c552baa 660
06f2306d 661 return 0;
662}
663
a75a9dbe 664//##################################################################################
6c552baa 665Int_t AliHLTMultiplicityCorrelations::SetupCALO() {
666 // see header file for class documentation
667
668 if(fProcessPhos) {
a75a9dbe 669 fHistList->Add(new TH1F("fPhosEt", "Total E_{T} in PHOS:E (GeV)",
670 fCaloBinning,fCaloBinningMin,fCaloBinningMax));
671 }
6c552baa 672 if(fProcessEmcal) {
a75a9dbe 673 fHistList->Add(new TH1F("fEmcalEt", "Total E_{T} in EMCAL:E (GeV)",
674 fCaloBinning,fCaloBinningMin,fCaloBinningMax));
675 }
6c552baa 676 if(fProcessPhos || fProcessEmcal) {
a75a9dbe 677 fHistList->Add(new TH1F("fTotalEt", "Total E_{T} in calorimeters:E (GeV)",
678 fCaloBinning,fCaloBinningMin,fCaloBinningMax));
679 }
680 return 0;
681}
682
6c552baa 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
571ad3a5 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
6c552baa 696 return 0;
697}
698
699
06f2306d 700/*
701 * ---------------------------------------------------------------------------------
702 * Process - private
703 * ---------------------------------------------------------------------------------
704 */
705
706//##################################################################################
707Int_t AliHLTMultiplicityCorrelations::ProcessTPC() {
6c552baa 708 // see header file for class documentation
06f2306d 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() {
6c552baa 770 // see header file for class documentation
06f2306d 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);
7690ff22 781 (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultAC")))->Fill(fVzeroMultA,fVzeroMultC);
782
06f2306d 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);
7690ff22 814 (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMultAC")))->Fill(fVzeroMultFlaggedA,fVzeroMultFlaggedC);
815
06f2306d 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
60f79eda 825 if (fESDEvent->GetNumberOfTracks() > 0 && fProcessTPC) {
06f2306d 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 }
6c552baa 834
835 // -- VZERO - SPD correlations
60f79eda 836 if (fESDEvent->GetNumberOfTracks() > 0 && fProcessSPD) {
6c552baa 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 }
43653719 845
846 // -- VZERO - CALO correlations
60f79eda 847 if ((fProcessPhos || fProcessEmcal) && fProcessCALO ){
43653719 848 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsTotEt")))->Fill(fVzeroMult, fPhosTotalEt + fEmcalTotalEt);
849 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsTotEt")))->Fill(fVzeroMultFlagged, fPhosTotalEt + fEmcalTotalEt);
60f79eda 850 if(fProcessPhos) {
43653719 851 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsPhosTotEt")))->Fill(fVzeroMult, fPhosTotalEt);
852 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsPhosTotEt")))->Fill(fVzeroMultFlagged, fPhosTotalEt);
853 }
60f79eda 854 if(fProcessEmcal) {
43653719 855 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsEmcalTotEt")))->Fill(fVzeroMult, fEmcalTotalEt);
856 (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsEmcalTotEt")))->Fill(fVzeroMultFlagged, fEmcalTotalEt);
857 }
858 }
06f2306d 859 return iResult;
860}
861
862//##################################################################################
863Int_t AliHLTMultiplicityCorrelations::ProcessZDC() {
6c552baa 864 // see header file for class documentation
06f2306d 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
60f79eda 913 if (fESDEvent->GetNumberOfTracks() > 0 && fProcessTPC) {
06f2306d 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 }
6c552baa 938
939 // -- ZDC - SPD correlations
60f79eda 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 }
06f2306d 945
6c552baa 946 // -- VZERO - ZDC correlations
60f79eda 947 if (fESDVZERO && fProcessVZERO) {
06f2306d 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
a75a9dbe 999 // -- ZDC - CALO correlations
60f79eda 1000 if ((fProcessPhos || fProcessEmcal) && fProcessCALO){
a75a9dbe 1001 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsTotEt")))->Fill(zdcE, fPhosTotalEt + fEmcalTotalEt);
60f79eda 1002 if(fProcessPhos) {
a75a9dbe 1003 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsPhosTotEt")))->Fill(zdcE, fPhosTotalEt);
1004 }
60f79eda 1005 if(fProcessEmcal) {
a75a9dbe 1006 (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsEmcalTotEt")))->Fill(zdcE, fEmcalTotalEt);
1007 }
1008 }
1009
06f2306d 1010 return iResult;
1011}
a75a9dbe 1012
1013//##################################################################################
6c552baa 1014Int_t AliHLTMultiplicityCorrelations::ProcessCALO() {
1015 // see header file for class documentation
a75a9dbe 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);
60f79eda 1028 if(cluster->IsPHOS() && fProcessPhos) {
a75a9dbe 1029 fPhosTotalEt += cluster->E();
1030 }
60f79eda 1031 if(cluster->IsEMCAL() && fProcessEmcal) {
a75a9dbe 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}
6c552baa 1042
1043//##################################################################################
1044Int_t AliHLTMultiplicityCorrelations::ProcessSPD() {
1045 // see header file for class documentation
1046
1047 (static_cast<TH2F*>(fHistList->FindObject("fSpdNClusters")))->Fill(fSpdNClusters);
571ad3a5 1048 (static_cast<TH2F*>(fHistList->FindObject("fSpdNClustersInner")))->Fill(fSpdNClustersInner);
1049 (static_cast<TH2F*>(fHistList->FindObject("fSpdNClustersOuter")))->Fill(fSpdNClustersOuter);
60f79eda 1050
1051
1052 // -- SPD vs TPC correlations
1053 if (fProcessTPC) {
1054 (static_cast<TH2F*>(fHistList->FindObject("fCorrSpdTpcNch")))->Fill(fSpdNClusters,fTpcTracksA);
1055 }
6c552baa 1056
1057 return 0;
1058}