HLT/global/physics/AliHLTMultiplicityCorrelations.cxx

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