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;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;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;Total E_{ZDC} (TeV);E_{T} (GeV)",
 557                           fZdcBinning,fZdcBinningMin,fZdcBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 558
 559   // ----------------------------------------------------
 560   //   VZERO vs CALO
 561   // ----------------------------------------------------
 562   fHistList->Add(new TH2F("fCorrVzerovsPhosTotEt",
 563                           "Multiplicity^{VZERO} vs Total E_{T} in PHOS;Multiplicity^{VZERO};E_{T} (GeV)",
 564                           fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 565   fHistList->Add(new TH2F("fCorrVzerovsEmcalTotEt",
 566                           "Multiplicity^{VZERO} vs Total E_{T} in EMCAL;Multiplicity^{VZERO};E_{T} (GeV)",
 567                           fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 568   fHistList->Add(new TH2F("fCorrVzerovsTotEt",
 569                           "Multiplicity^{VZERO} vs Total E_{T} in Calorimeters;Multiplicity^{VZERO};E_{T} (GeV)",
 570                           fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 571
 572   fHistList->Add(new TH2F("fCorrVzeroFlaggedvsPhosTotEt",
 573                           "Multiplicity_{flagged}^{VZERO} vs Total E_{T} in PHOS;Multiplicity_{flagged}^{VZERO};E_{T} (GeV)",
 574                           fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 575   fHistList->Add(new TH2F("fCorrVzeroFlaggedvsEmcalTotEt",
 576                           "Multiplicity_{flagged}^{VZERO} vs Total E_{T} in EMCAL;Multiplicity_{flagged}^{VZERO};E_{T} (GeV)",
 577                           fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 578   fHistList->Add(new TH2F("fCorrVzeroFlaggedvsTotEt",
 579                           "Multiplicity_{flagged}^{VZERO} vs Total E_{T} in Calorimeters;Multiplicity_{flagged}^{VZERO};E_{T} (GeV)",
 580                           fVzeroBinning,fVzeroBinningMin,fVzeroBinningMax, fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 581
 582   // ----------------------------------------------------
 583   //
 584   // ----------------------------------------------------
 585
 586   return 0;
 587 }
 588
 589 //##################################################################################
 590 Int_t AliHLTMultiplicityCorrelations::SetupCALO()
 591 {
 592   // Calo histos
 593   if(fProcessPhos)
 594   {
 595     fHistList->Add(new TH1F("fPhosEt",  "Total E_{T} in PHOS:E (GeV)",
 596                             fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 597   }
 598   if(fProcessEmcal)
 599   {
 600     fHistList->Add(new TH1F("fEmcalEt",  "Total E_{T} in EMCAL:E (GeV)",
 601                             fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 602   }
 603   if(fProcessPhos || fProcessEmcal)
 604   {
 605     fHistList->Add(new TH1F("fTotalEt",  "Total E_{T} in calorimeters:E (GeV)",
 606                             fCaloBinning,fCaloBinningMin,fCaloBinningMax));
 607   }
 608   return 0;
 609 }
 610
 611 /*
 612  * ---------------------------------------------------------------------------------
 613  *                               Process - private
 614  * ---------------------------------------------------------------------------------
 615  */
 616
 617 //##################################################################################
 618 Int_t AliHLTMultiplicityCorrelations::ProcessTPC() {
 619
 620   Int_t iResult = 0 ;
 621
 622   TH1F* hPt0 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt0")); // all
 623   TH1F* hPt1 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt1")); // all accepted
 624
 625   TH1F* hPt2 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt2")); // GetTPCInnerParam
 626   TH1F* hPt3 = static_cast<TH1F*>(fHistList->FindObject("fTpcPt3")); // GetTPCInnerParam A
 627
 628   fEsdTracks = 0;
 629   fEsdTracksA = 0;
 630   fTpcTracks = 0;
 631   fTpcTracksA = 0;
 632
 633   // -----------------------------------------------------------------
 634   for (Int_t idx = 0; idx < fESDEvent->GetNumberOfTracks(); idx++) {
 635
 636     // -- check  track
 637     AliESDtrack* esdTrack = fESDEvent->GetTrack(idx);
 638     if (!esdTrack) continue;
 639
 640     ++fEsdTracks;
 641     hPt0->Fill(esdTrack->Pt());
 642
 643     //______________________________________________
 644     if (!fESDTrackCuts->AcceptTrack(esdTrack)) continue;
 645     ++fEsdTracksA;
 646
 647     hPt1->Fill(esdTrack->Pt());
 648   }
 649   // -----------------------------------------------------------------
 650   for (Int_t idx = 0; idx < fESDEvent->GetNumberOfTracks(); idx++) {
 651
 652     // -- check  track
 653     AliESDtrack* esdTrack = fESDEvent->GetTrack(idx);
 654     if (!esdTrack) continue;
 655
 656     // -- TPC only
 657     const AliExternalTrackParam *tpcTrack = esdTrack->GetTPCInnerParam();
 658     if (!tpcTrack) continue;
 659     ++fTpcTracks;
 660     hPt2->Fill(tpcTrack->Pt());
 661
 662     //______________________________________________
 663     if (!fESDTrackCuts->AcceptTrack(esdTrack)) continue;
 664     ++fTpcTracksA;
 665
 666     hPt3->Fill(tpcTrack->Pt());
 667   }
 668   // -----------------------------------------------------------------
 669
 670   (static_cast<TH1F*>(fHistList->FindObject("fTpcNch0")))->Fill(fEsdTracks);
 671   (static_cast<TH1F*>(fHistList->FindObject("fTpcNch1")))->Fill(fEsdTracksA);
 672   (static_cast<TH1F*>(fHistList->FindObject("fTpcNch2")))->Fill(fTpcTracks);
 673   (static_cast<TH1F*>(fHistList->FindObject("fTpcNch3")))->Fill(fTpcTracksA);
 674
 675   return iResult;
 676 }
 677
 678 //##################################################################################
 679 Int_t AliHLTMultiplicityCorrelations::ProcessVZERO() {
 680
 681   Int_t iResult = 0 ;
 682
 683   fVzeroMultA = fESDVZERO->GetMTotV0A();
 684   fVzeroMultC = fESDVZERO->GetMTotV0C();
 685   fVzeroMult  = fVzeroMultA + fVzeroMultC;
 686
 687   (static_cast<TH1F*>(fHistList->FindObject("fVzeroMult")))->Fill(fVzeroMult);
 688   (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultA")))->Fill(fVzeroMultA);
 689   (static_cast<TH1F*>(fHistList->FindObject("fVzeroMultC")))->Fill(fVzeroMultC);
 690
 691   fVzeroMultFlaggedA = 0.;
 692   fVzeroMultFlaggedC = 0.;
 693
 694   Double_t vzeroTimeA = 0.;
 695   Double_t vzeroTimeC = 0.;
 696
 697   Double_t vzeroAdcA = 0.;
 698   Double_t vzeroAdcC = 0.;
 699
 700   for (Int_t idx = 0; idx < 32; idx++) {
 701
 702     if ( fESDVZERO->GetBBFlag(idx) )
 703       fVzeroMultFlaggedC += fESDVZERO->GetMultiplicityV0C(idx);
 704     if ( fESDVZERO->GetBBFlag(idx+32) )
 705       fVzeroMultFlaggedA += fESDVZERO->GetMultiplicityV0A(idx);
 706
 707     vzeroTimeA += fESDVZERO->GetTimeV0A(idx);
 708     vzeroTimeC += fESDVZERO->GetTimeV0C(idx);
 709
 710     vzeroAdcA += fESDVZERO->GetAdcV0A(idx);
 711     vzeroAdcC += fESDVZERO->GetAdcV0C(idx);
 712   }
 713
 714   fVzeroMultFlagged = fVzeroMultFlaggedA + fVzeroMultFlaggedC;
 715
 716   Double_t vzeroTime     = vzeroTimeA + vzeroTimeC;
 717   Double_t vzeroAdc      = vzeroAdcA + vzeroAdcC;
 718
 719   (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMult")))->Fill(fVzeroMultFlagged);
 720   (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMultA")))->Fill(fVzeroMultFlaggedA);
 721   (static_cast<TH1F*>(fHistList->FindObject("fVzeroFlaggedMultC")))->Fill(fVzeroMultFlaggedC);
 722
 723   (static_cast<TH1F*>(fHistList->FindObject("fVzeroTime")))->Fill(vzeroTime);
 724   (static_cast<TH1F*>(fHistList->FindObject("fVzeroTimeA")))->Fill(vzeroTimeA);
 725   (static_cast<TH1F*>(fHistList->FindObject("fVzeroTimeC")))->Fill(vzeroTimeC);
 726
 727   (static_cast<TH1F*>(fHistList->FindObject("fVzeroADC")))->Fill(vzeroAdc);
 728   (static_cast<TH1F*>(fHistList->FindObject("fVzeroADCA")))->Fill(vzeroAdcA);
 729   (static_cast<TH1F*>(fHistList->FindObject("fVzeroADCC")))->Fill(vzeroAdcC);
 730
 731   // -- VZERO - TPC correlations
 732   if (fESDEvent->GetNumberOfTracks() > 0) {
 733     (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroNch")))->Fill(fVzeroMult, fTpcTracksA);
 734     (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroANch")))->Fill(fVzeroMultA, fTpcTracksA);
 735     (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroCNch")))->Fill(fVzeroMultC, fTpcTracksA);
 736
 737     (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFNch")))->Fill(fVzeroMultFlagged, fTpcTracksA);
 738     (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFANch")))->Fill(fVzeroMultFlaggedA, fTpcTracksA);
 739     (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFCNch")))->Fill(fVzeroMultFlaggedC, fTpcTracksA);
 740   }
 741
 742   // -- VZERO - CALO correlations
 743   if (fProcessPhos || fProcessEmcal) {
 744     (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsTotEt")))->Fill(fVzeroMult, fPhosTotalEt + fEmcalTotalEt);
 745     (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsTotEt")))->Fill(fVzeroMultFlagged, fPhosTotalEt + fEmcalTotalEt);
 746     if(fProcessPhos)
 747     {
 748       (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsPhosTotEt")))->Fill(fVzeroMult, fPhosTotalEt);
 749       (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsPhosTotEt")))->Fill(fVzeroMultFlagged, fPhosTotalEt);
 750     }
 751     if(fProcessEmcal)
 752     {
 753       (static_cast<TH2F*>(fHistList->FindObject("fCorrVzerovsEmcalTotEt")))->Fill(fVzeroMult, fEmcalTotalEt);
 754       (static_cast<TH2F*>(fHistList->FindObject("fCorrVzeroFlaggedvsEmcalTotEt")))->Fill(fVzeroMultFlagged, fEmcalTotalEt);
 755     }
 756   }
 757   return iResult;
 758 }
 759
 760 //##################################################################################
 761 Int_t AliHLTMultiplicityCorrelations::ProcessZDC() {
 762
 763   Int_t iResult = 0 ;
 764
 765   Double_t zdcEznA = fESDZDC->GetZDCN2Energy() / 1000.;
 766   Double_t zdcEznC = fESDZDC->GetZDCN1Energy() / 1000.;
 767   Double_t zdcEzn  = zdcEznA + zdcEznC;
 768
 769   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzn")))->Fill(zdcEzn);
 770   (static_cast<TH1F*>(fHistList->FindObject("fZdcEznA")))->Fill(zdcEznA);
 771   (static_cast<TH1F*>(fHistList->FindObject("fZdcEznC")))->Fill(zdcEznC);
 772
 773   Double_t zdcEzpA = fESDZDC->GetZDCP2Energy() / 1000.;
 774   Double_t zdcEzpC = fESDZDC->GetZDCP1Energy() / 1000.;
 775   Double_t zdcEzp  = zdcEzpA + zdcEzpC;
 776
 777   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzp")))->Fill(zdcEzp);
 778   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzpA")))->Fill(zdcEzpA);
 779   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzpC")))->Fill(zdcEzpC);
 780
 781   Double_t zdcEA = (zdcEznA + zdcEzpA);
 782   Double_t zdcEC = (zdcEznC + zdcEzpC);
 783   Double_t zdcE = zdcEA + zdcEC;
 784
 785   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdc")))->Fill(zdcE);
 786   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdcA")))->Fill(zdcEA);
 787   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzdcC")))->Fill(zdcEC);
 788
 789   Double_t zdcEzemA = fESDZDC->GetZDCEMEnergy(1) / 1000.;
 790   Double_t zdcEzemC = fESDZDC->GetZDCEMEnergy(0) / 1000.;
 791   Double_t zdcEzem  = zdcEzemA + zdcEzemC;
 792
 793   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzem")))->Fill(zdcEzem);
 794   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzemA")))->Fill(zdcEzemA);
 795   (static_cast<TH1F*>(fHistList->FindObject("fZdcEzemC")))->Fill(zdcEzemC);
 796
 797   (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdc")))->Fill(zdcEzem, zdcE);
 798   (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdcA")))->Fill(zdcEzemA, zdcEA);
 799   (static_cast<TH2F*>(fHistList->FindObject("fZdcEzemEzdcC")))->Fill(zdcEzemC, zdcEC);
 800
 801   (static_cast<TH1F*>(fHistList->FindObject("fZdcNpart")))->Fill(fESDZDC->GetZDCParticipants());
 802   (static_cast<TH1F*>(fHistList->FindObject("fZdcNpartA")))->Fill(fESDZDC->GetZDCPartSideA());
 803   (static_cast<TH1F*>(fHistList->FindObject("fZdcNpartC")))->Fill(fESDZDC->GetZDCPartSideC());
 804
 805   (static_cast<TH1F*>(fHistList->FindObject("fZdcB")))->Fill(fESDZDC->GetImpactParameter());
 806   (static_cast<TH1F*>(fHistList->FindObject("fZdcBA")))->Fill(fESDZDC->GetImpactParamSideA());
 807   (static_cast<TH1F*>(fHistList->FindObject("fZdcBC")))->Fill(fESDZDC->GetImpactParamSideC());
 808
 809   // -- ZDC - TPC correlations
 810   if (fESDEvent->GetNumberOfTracks() > 0) {
 811     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcNch")))->Fill(zdcE, fTpcTracksA);
 812     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcANch")))->Fill(zdcEA, fTpcTracksA);
 813     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcCNch")))->Fill(zdcEC, fTpcTracksA);
 814
 815     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemNch")))->Fill(zdcEzem, fTpcTracksA);
 816     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemANch")))->Fill(zdcEzemA, fTpcTracksA);
 817     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemCNch")))->Fill(zdcEzemC, fTpcTracksA);
 818
 819     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpNch")))->Fill(zdcEzp, fTpcTracksA);
 820     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpANch")))->Fill(zdcEzpA, fTpcTracksA);
 821     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpCNch")))->Fill(zdcEzpC, fTpcTracksA);
 822
 823     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznNch")))->Fill(zdcEzn, fTpcTracksA);
 824     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznANch")))->Fill(zdcEznA, fTpcTracksA);
 825     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznCNch")))->Fill(zdcEznC, fTpcTracksA);
 826
 827     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartNch")))->Fill(fESDZDC->GetZDCParticipants(), fTpcTracksA);
 828     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartANch")))->Fill(fESDZDC->GetZDCPartSideA(),   fTpcTracksA);
 829     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartCNch")))->Fill(fESDZDC->GetZDCPartSideC(),   fTpcTracksA);
 830
 831     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbNch")))->Fill(fESDZDC->GetImpactParameter(),   fTpcTracksA);
 832     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbANch")))->Fill(fESDZDC->GetImpactParamSideA(), fTpcTracksA);
 833     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbCNch")))->Fill(fESDZDC->GetImpactParamSideC(), fTpcTracksA);
 834   }
 835
 836   // -- VZERO - TPC correlations
 837   if (fESDVZERO) {
 838     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzero")))->Fill(zdcE, fVzeroMult);
 839     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroA")))->Fill(zdcEA, fVzeroMultA);
 840     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroC")))->Fill(zdcEC, fVzeroMultC);
 841
 842     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzero")))->Fill(zdcEzem, fVzeroMult);
 843     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroA")))->Fill(zdcEzemA, fVzeroMultA);
 844     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroC")))->Fill(zdcEzemC, fVzeroMultC);
 845
 846     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzero")))->Fill(zdcEzp, fVzeroMult);
 847     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroA")))->Fill(zdcEzpA, fVzeroMultA);
 848     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroC")))->Fill(zdcEzpC, fVzeroMultC);
 849
 850     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzero")))->Fill(zdcEzn, fVzeroMult);
 851     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroA")))->Fill(zdcEznA, fVzeroMultA);
 852     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroC")))->Fill(zdcEznC, fVzeroMultC);
 853
 854     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzero")))->Fill(fESDZDC->GetZDCParticipants(), fVzeroMult);
 855     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroA")))->Fill(fESDZDC->GetZDCPartSideA(),   fVzeroMultA);
 856     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroC")))->Fill(fESDZDC->GetZDCPartSideC(),   fVzeroMultC);
 857
 858     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzero")))->Fill(fESDZDC->GetImpactParameter(),   fVzeroMult);
 859     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroA")))->Fill(fESDZDC->GetImpactParamSideA(), fVzeroMultA);
 860     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroC")))->Fill(fESDZDC->GetImpactParamSideC(), fVzeroMultC);
 861
 862     // -- -- -- --
 863
 864     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroF")))->Fill(zdcE, fVzeroMultFlagged);
 865     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroFA")))->Fill(zdcEA, fVzeroMultFlaggedA);
 866     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzdcVzeroFC")))->Fill(zdcEC, fVzeroMultFlaggedC);
 867
 868     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroF")))->Fill(zdcEzem, fVzeroMultFlagged);
 869     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroFA")))->Fill(zdcEzemA, fVzeroMultFlaggedA);
 870     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzemVzeroFC")))->Fill(zdcEzemC, fVzeroMultFlaggedC);
 871
 872     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroF")))->Fill(zdcEzp, fVzeroMultFlagged);
 873     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroFA")))->Fill(zdcEzpA, fVzeroMultFlaggedA);
 874     (static_cast<TH2F*>(fHistList->FindObject("fCorrEzpVzeroFC")))->Fill(zdcEzpC, fVzeroMultFlaggedC);
 875
 876     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroF")))->Fill(zdcEzn, fVzeroMultFlagged);
 877     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroFA")))->Fill(zdcEznA, fVzeroMultFlaggedA);
 878     (static_cast<TH2F*>(fHistList->FindObject("fCorrEznVzeroFC")))->Fill(zdcEznC, fVzeroMultFlaggedC);
 879
 880     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzero")))->Fill(fESDZDC->GetZDCParticipants(), fVzeroMultFlagged);
 881     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroFA")))->Fill(fESDZDC->GetZDCPartSideA(),   fVzeroMultFlaggedA);
 882     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcNpartVzeroFC")))->Fill(fESDZDC->GetZDCPartSideC(),   fVzeroMultFlaggedC);
 883
 884     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroF")))->Fill(fESDZDC->GetImpactParameter(),   fVzeroMultFlagged);
 885     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroFA")))->Fill(fESDZDC->GetImpactParamSideA(), fVzeroMultFlaggedA);
 886     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcbVzeroFC")))->Fill(fESDZDC->GetImpactParamSideC(), fVzeroMultFlaggedC);
 887   }
 888
 889   // -- ZDC - CALO correlations
 890   if (fProcessPhos || fProcessEmcal) {
 891     (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsTotEt")))->Fill(zdcE, fPhosTotalEt + fEmcalTotalEt);
 892     if(fProcessPhos)
 893     {
 894       (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsPhosTotEt")))->Fill(zdcE, fPhosTotalEt);
 895     }
 896     if(fProcessEmcal)
 897     {
 898       (static_cast<TH2F*>(fHistList->FindObject("fCorrZdcTotEvsEmcalTotEt")))->Fill(zdcE, fEmcalTotalEt);
 899     }
 900   }
 901
 902   return iResult;
 903 }
 904
 905 //##################################################################################
 906 Int_t AliHLTMultiplicityCorrelations::ProcessCALO()
 907 {
 908   // CALO
 909
 910   TH1F* hPhosEt = static_cast<TH1F*>(fHistList->FindObject("fPhosEt")); // PHOS Tot E_T
 911   TH1F* hEmcalEt = static_cast<TH1F*>(fHistList->FindObject("fEmcalEt")); // EMCAL Tot E_T
 912   TH1F* hTotalEt = static_cast<TH1F*>(fHistList->FindObject("fTotalEt")); // CALO Tot E_T
 913
 914   fPhosTotalEt = 0;
 915   fEmcalTotalEt = 0;
 916
 917   for(Int_t cl = 0; cl < fESDEvent->GetNumberOfCaloClusters(); cl++)
 918   {
 919
 920     AliESDCaloCluster *cluster = fESDEvent->GetCaloCluster(cl);
 921     if(cluster->IsPHOS() && fProcessPhos)
 922     {
 923       fPhosTotalEt += cluster->E();
 924     }
 925     if(cluster->IsEMCAL() && fProcessEmcal)
 926     {
 927       fEmcalTotalEt += cluster->E();
 928     }
 929   }
 930
 931   if(hPhosEt)hPhosEt->Fill(fPhosTotalEt);
 932   if(hEmcalEt)hEmcalEt->Fill(fEmcalTotalEt);
 933   if(hTotalEt)hTotalEt->Fill(fPhosTotalEt + fEmcalTotalEt);
 934
 935   return 0;
 936 }