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