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