4be147ae4fc528c5ddfd787635a7104ddc173e5d
[u/mrichter/AliRoot.git] / HLT / global / physics / AliHLTMultiplicityCorrelations.cxx
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 */
41 ClassImp(AliHLTMultiplicityCorrelations)
42
43 /*
44  * ---------------------------------------------------------------------------------
45  *                            Constructor / Destructor
46  * ---------------------------------------------------------------------------------
47  */
48
49 //##################################################################################
50 AliHLTMultiplicityCorrelations::AliHLTMultiplicityCorrelations() :
51   fHistList(NULL),
52   fESDEvent(NULL),
53   fESDZDC(NULL),
54   fESDVZERO(NULL),
55   fESDTrackCuts(NULL),
56   fEsdTracks(0), fEsdTracksA(0),
57   fTpcTracks(0), fTpcTracksA(0),
58   fVzeroMult(0.), fVzeroMultA(0.), fVzeroMultC(0.),
59   fVzeroMultFlagged(0.), fVzeroMultFlaggedA(0.), fVzeroMultFlaggedC(0.),
60   fSpdNClusters(0),
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.),
65   fZnpBinning(200),fZnpBinningMin(0.),fZnpBinningMax(100.),
66   fProcessPhos(true), fProcessEmcal(true),
67   fPhosTotalEt(0.0), fEmcalTotalEt(0.0),
68   fCaloBinning(100),fCaloBinningMin(0.),fCaloBinningMax(100.),
69   fSpdBinning(200),fSpdBinningMin(0.),fSpdBinningMax(15000.) {
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 //##################################################################################
79 AliHLTMultiplicityCorrelations::~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 //##################################################################################
96 Int_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);
103   fHistList->SetName("MultiplicityCorrelations");
104   iResult = SetupHistograms();
105
106   return iResult;
107 }
108
109 /*
110  * ---------------------------------------------------------------------------------
111  *                             Output - public
112  * ---------------------------------------------------------------------------------
113  */
114
115 //##################################################################################
116 Int_t AliHLTMultiplicityCorrelations::ProcessEvent( AliESDEvent *esd, AliESDVZERO* esdVZERO, 
117                                                     Int_t nSpdClusters) {
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   }
126   
127   if ( esdVZERO )
128     fESDVZERO = esdVZERO;
129
130   // -- TPC .. To be done before the others
131   if (fESDEvent->GetNumberOfTracks() > 0)
132     iResult = ProcessTPC();
133
134   fSpdNClusters = nSpdClusters;
135   iResult = ProcessSPD();
136   
137   // -- CALO, process with or without clusters, we want the zero-bin
138   iResult = ProcessCALO();
139   
140   // -- VZERO
141   if (fESDVZERO)
142     iResult = ProcessVZERO();
143
144   // -- ZDC and Correlations
145   if (fESDZDC)
146     iResult = ProcessZDC();
147
148   
149
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 //##################################################################################
169 Bool_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 //##################################################################################
200 Int_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();
208   iResult = SetupCALO();
209   iResult = SetupSPD();
210   iResult = SetupCorrelations();
211
212   return iResult;
213 }
214
215 //##################################################################################
216 Int_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
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
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   
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
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 //##################################################################################
253 Int_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 //##################################################################################
310 Int_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 //##################################################################################
350 Int_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
564   // ----------------------------------------------------
565   //   ZDC vs CALO
566   // ----------------------------------------------------
567   fHistList->Add(new TH2F("fCorrZdcTotEvsPhosTotEt", 
568                           "Total E_{ZDC} vs Total E_{T} in PHOS;Total E_{ZDC} (TeV);E_{T} (GeV)", 
569                           fZdcBinning,fZdcBinningMin,fZdcBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
570   fHistList->Add(new TH2F("fCorrZdcTotEvsEmcalTotEt", 
571                           "Total E_{ZDC} vs Total E_{T} in EMCAL;Total E_{ZDC} (TeV);E_{T} (GeV)", 
572                           fZdcBinning,fZdcBinningMin,fZdcBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
573   fHistList->Add(new TH2F("fCorrZdcTotEvsTotEt", 
574                           "Total E_{ZDC} vs Total E_{T} in calorimeters;Total E_{ZDC} (TeV);E_{T} (GeV)", 
575                           fZdcBinning,fZdcBinningMin,fZdcBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
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));
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
631   // ----------------------------------------------------
632   //   SPD vs ZDC
633   // ----------------------------------------------------
634
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
644   return 0;
645 }
646
647 //##################################################################################
648 Int_t AliHLTMultiplicityCorrelations::SetupCALO() {
649   // see header file for class documentation  
650
651   if(fProcessPhos) {
652     fHistList->Add(new TH1F("fPhosEt",  "Total E_{T} in PHOS:E (GeV)",   
653                             fCaloBinning,fCaloBinningMin,fCaloBinningMax));
654   }
655   if(fProcessEmcal) {
656     fHistList->Add(new TH1F("fEmcalEt",  "Total E_{T} in EMCAL:E (GeV)",   
657                             fCaloBinning,fCaloBinningMin,fCaloBinningMax));
658   }
659   if(fProcessPhos || fProcessEmcal) {
660     fHistList->Add(new TH1F("fTotalEt",  "Total E_{T} in calorimeters:E (GeV)",   
661                             fCaloBinning,fCaloBinningMin,fCaloBinningMax));
662   }
663   return 0;
664 }
665
666 //##################################################################################
667 Int_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
677 /*
678  * ---------------------------------------------------------------------------------
679  *                               Process - private
680  * ---------------------------------------------------------------------------------
681  */
682
683 //##################################################################################
684 Int_t AliHLTMultiplicityCorrelations::ProcessTPC() {
685   // see header file for class documentation  
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 //##################################################################################
746 Int_t AliHLTMultiplicityCorrelations::ProcessVZERO() {
747   // see header file for class documentation  
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);
758   (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultAC")))->Fill(fVzeroMultA,fVzeroMultC);
759
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);
791   (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMultAC")))->Fill(fVzeroMultFlaggedA,fVzeroMultFlaggedC);
792
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   }
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   }
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   }
838   return iResult;
839 }
840
841 //##################################################################################
842 Int_t AliHLTMultiplicityCorrelations::ProcessZDC() {
843   // see header file for class documentation  
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   }
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     
923
924   // -- VZERO - ZDC correlations
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
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
990   return iResult;
991 }
992
993 //##################################################################################
994 Int_t AliHLTMultiplicityCorrelations::ProcessCALO() {
995   // see header file for class documentation  
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 }
1024
1025 //##################################################################################
1026 Int_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 }