PWGGA/CaloTrackCorrelations/AliAnaInsideClusterInvariantMass.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 //_________________________________________________________________________
  17 //
  18 // Split clusters with some criteria and calculate invariant mass
  19 // to identify them as pi0 or conversion
  20 //
  21 //
  22 //-- Author: Gustavo Conesa (LPSC-Grenoble)
  23 //_________________________________________________________________________
  24
  25 //////////////////////////////////////////////////////////////////////////////
  26
  27
  28 // --- ROOT system ---
  29 #include <TList.h>
  30 #include <TClonesArray.h>
  31 #include <TObjString.h>
  32 #include <TH2F.h>
  33 #include <TDatabasePDG.h>
  34
  35 // --- Analysis system ---
  36 #include "AliAnaInsideClusterInvariantMass.h"
  37 #include "AliCaloTrackReader.h"
  38 #include "AliMCAnalysisUtils.h"
  39 #include "AliStack.h"
  40 #include "AliFiducialCut.h"
  41 #include "TParticle.h"
  42 #include "AliVCluster.h"
  43 #include "AliAODEvent.h"
  44 #include "AliAODMCParticle.h"
  45 #include "AliEMCALGeoParams.h"
  46
  47 // --- Detectors ---
  48 //#include "AliPHOSGeoUtils.h"
  49 #include "AliEMCALGeometry.h"
  50
  51 ClassImp(AliAnaInsideClusterInvariantMass)
  52
  53 //__________________________________________________________________
  54 AliAnaInsideClusterInvariantMass::AliAnaInsideClusterInvariantMass() :
  55   AliAnaCaloTrackCorrBaseClass(),
  56   fCalorimeter(""),
  57   fMinNCells(0),    fMinBadDist(0),
  58   fHistoECut(0),    fCheckSplitDistToBad(0),
  59   fFillAngleHisto(kFALSE),
  60   fFillTMHisto(kFALSE),
  61   fFillTMResidualHisto(kFALSE),
  62   fFillSSExtraHisto(kFALSE),
  63   fFillMCHisto(kFALSE),
  64   fFillSSWeightHisto(kFALSE),
  65   fFillEbinHisto(0),
  66   fFillMCOverlapHisto(0),
  67   fFillNCellHisto(0),
  68   fFillIdConvHisto(0),
  69   fFillIdEtaHisto(0),
  70   fFillHighMultHisto(0),
  71   fSSWeightN(0),              fSSECellCutN(0),
  72   fWSimu(0),
  73   fhMassM02CutNLocMax1(0),    fhMassM02CutNLocMax2(0),    fhMassM02CutNLocMaxN(0),
  74   fhAsymM02CutNLocMax1(0),    fhAsymM02CutNLocMax2(0),    fhAsymM02CutNLocMaxN(0),
  75   fhMassSplitECutNLocMax1(0), fhMassSplitECutNLocMax2(0), fhMassSplitECutNLocMaxN(0),
  76   fhMCGenFracAfterCutsNLocMax1MCPi0(0),
  77   fhMCGenFracAfterCutsNLocMax2MCPi0(0),
  78   fhMCGenFracAfterCutsNLocMaxNMCPi0(0),
  79   fhMCGenSplitEFracAfterCutsNLocMax1MCPi0(0),
  80   fhMCGenSplitEFracAfterCutsNLocMax2MCPi0(0),
  81   fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0(0),
  82   fhNCellMassEHighNLocMax1MCPi0(0), fhNCellM02EHighNLocMax1MCPi0(0),
  83   fhNCellMassELowNLocMax1MCPi0(0),  fhNCellM02ELowNLocMax1MCPi0(0),
  84   fhNCellMassEHighNLocMax2MCPi0(0), fhNCellM02EHighNLocMax2MCPi0(0),
  85   fhNCellMassELowNLocMax2MCPi0(0),  fhNCellM02ELowNLocMax2MCPi0(0),
  86   fhNCellMassEHighNLocMaxNMCPi0(0), fhNCellM02EHighNLocMaxNMCPi0(0),
  87   fhNCellMassELowNLocMaxNMCPi0(0),  fhNCellM02ELowNLocMaxNMCPi0(0),
  88   fhCentralityPi0NLocMax1(0), fhCentralityEtaNLocMax1(0),
  89   fhCentralityPi0NLocMax2(0), fhCentralityEtaNLocMax2(0),
  90   fhCentralityPi0NLocMaxN(0), fhCentralityEtaNLocMaxN(0),
  91   fhEventPlanePi0NLocMax1(0), fhEventPlaneEtaNLocMax1(0),
  92   fhEventPlanePi0NLocMax2(0), fhEventPlaneEtaNLocMax2(0),
  93   fhEventPlanePi0NLocMaxN(0), fhEventPlaneEtaNLocMaxN(0),
  94   fhClusterEtaPhiNLocMax1(0), fhClusterEtaPhiNLocMax2(0),  fhClusterEtaPhiNLocMaxN(0),
  95   fhPi0EtaPhiNLocMax1(0),     fhPi0EtaPhiNLocMax2(0),      fhPi0EtaPhiNLocMaxN(0),
  96   fhEtaEtaPhiNLocMax1(0),     fhEtaEtaPhiNLocMax2(0),      fhEtaEtaPhiNLocMaxN(0),
  97   fhPi0EPairDiffTimeNLM1(0),  fhPi0EPairDiffTimeNLM2(0),   fhPi0EPairDiffTimeNLMN(0),
  98   fhEtaEPairDiffTimeNLM1(0),  fhEtaEPairDiffTimeNLM2(0),   fhEtaEPairDiffTimeNLMN(0),
  99   fhMCPi0HighNLMPair(0),                  fhMCPi0LowNLMPair(0),
 100   fhMCPi0AnyNLMPair(0),                   fhMCPi0NoneNLMPair(0),
 101   fhMCPi0HighNLMPairNoMCMatch(0),         fhMCPi0LowNLMPairNoMCMatch(0),
 102   fhMCPi0AnyNLMPairNoMCMatch(0),          fhMCPi0NoneNLMPairNoMCMatch(0),
 103   fhMCPi0HighNLMPairOverlap(0),           fhMCPi0LowNLMPairOverlap(0),
 104   fhMCPi0AnyNLMPairOverlap(0),            fhMCPi0NoneNLMPairOverlap(0),
 105   fhMCPi0HighNLMPairNoMCMatchOverlap(0),  fhMCPi0LowNLMPairNoMCMatchOverlap(0),
 106   fhMCPi0AnyNLMPairNoMCMatchOverlap(0),   fhMCPi0NoneNLMPairNoMCMatchOverlap(0),
 107   fhMCPi0DecayPhotonHitHighLM(0),         fhMCPi0DecayPhotonAdjHighLM(0),
 108   fhMCPi0DecayPhotonHitOtherLM(0),        fhMCPi0DecayPhotonAdjOtherLM(0),
 109   fhMCPi0DecayPhotonAdjacent(0),          fhMCPi0DecayPhotonHitNoLM(0),
 110   fhMCPi0DecayPhotonHitHighLMOverlap(0),  fhMCPi0DecayPhotonAdjHighLMOverlap(0),
 111   fhMCPi0DecayPhotonHitOtherLMOverlap(0), fhMCPi0DecayPhotonAdjOtherLMOverlap(0),
 112   fhMCPi0DecayPhotonAdjacentOverlap(0),   fhMCPi0DecayPhotonHitNoLMOverlap(0),
 113   fhMCEOverlapType(0),                    fhMCEOverlapTypeMatch(0)
 114 {
 115   //default ctor
 116
 117   // Init array of histograms
 118   for(Int_t i = 0; i < 8; i++)
 119   {
 120     for(Int_t j = 0; j < 2; j++)
 121     {
 122       fhMassNLocMax1[i][j]  = 0;
 123       fhMassNLocMax2[i][j]  = 0;
 124       fhMassNLocMaxN[i][j]  = 0;
 125       fhNLocMax[i][j]       = 0;
 126       fhNLocMaxM02Cut[i][j] = 0;
 127       fhSplitClusterENLocMax   [i][j] = 0;
 128       fhSplitClusterEPi0NLocMax[i][j] = 0;
 129       fhM02NLocMax1[i][j]   = 0;
 130       fhM02NLocMax2[i][j]   = 0;
 131       fhM02NLocMaxN[i][j]   = 0;
 132       fhNCellNLocMax1[i][j] = 0;
 133       fhNCellNLocMax2[i][j] = 0;
 134       fhNCellNLocMaxN[i][j] = 0;
 135       fhM02Pi0NLocMax1[i][j] = 0;
 136       fhM02EtaNLocMax1[i][j] = 0;
 137       fhM02ConNLocMax1[i][j] = 0;
 138       fhM02Pi0NLocMax2[i][j] = 0;
 139       fhM02EtaNLocMax2[i][j] = 0;
 140       fhM02ConNLocMax2[i][j] = 0;
 141       fhM02Pi0NLocMaxN[i][j] = 0;
 142       fhM02EtaNLocMaxN[i][j] = 0;
 143       fhM02ConNLocMaxN[i][j] = 0;
 144
 145       fhMassPi0NLocMax1[i][j] = 0;
 146       fhMassEtaNLocMax1[i][j] = 0;
 147       fhMassConNLocMax1[i][j] = 0;
 148       fhMassPi0NLocMax2[i][j] = 0;
 149       fhMassEtaNLocMax2[i][j] = 0;
 150       fhMassConNLocMax2[i][j] = 0;
 151       fhMassPi0NLocMaxN[i][j] = 0;
 152       fhMassEtaNLocMaxN[i][j] = 0;
 153       fhMassConNLocMaxN[i][j] = 0;
 154
 155       fhNCellPi0NLocMax1[i][j] = 0;
 156       fhNCellEtaNLocMax1[i][j] = 0;
 157       fhNCellPi0NLocMax2[i][j] = 0;
 158       fhNCellEtaNLocMax2[i][j] = 0;
 159       fhNCellPi0NLocMaxN[i][j] = 0;
 160       fhNCellEtaNLocMaxN[i][j] = 0;
 161
 162       fhAsyPi0NLocMax1[i][j] = 0;
 163       fhAsyEtaNLocMax1[i][j] = 0;
 164       fhAsyConNLocMax1[i][j] = 0;
 165       fhAsyPi0NLocMax2[i][j] = 0;
 166       fhAsyEtaNLocMax2[i][j] = 0;
 167       fhAsyConNLocMax2[i][j] = 0;
 168       fhAsyPi0NLocMaxN[i][j] = 0;
 169       fhAsyEtaNLocMaxN[i][j] = 0;
 170       fhAsyConNLocMaxN[i][j] = 0;
 171
 172       fhMassM02NLocMax1[i][j]= 0;
 173       fhMassM02NLocMax2[i][j]= 0;
 174       fhMassM02NLocMaxN[i][j]= 0;
 175       fhMassDispEtaNLocMax1[i][j]= 0;
 176       fhMassDispEtaNLocMax2[i][j]= 0;
 177       fhMassDispEtaNLocMaxN[i][j]= 0;
 178       fhMassDispPhiNLocMax1[i][j]= 0;
 179       fhMassDispPhiNLocMax2[i][j]= 0;
 180       fhMassDispPhiNLocMaxN[i][j]= 0;
 181       fhMassDispAsyNLocMax1[i][j]= 0;
 182       fhMassDispAsyNLocMax2[i][j]= 0;
 183       fhMassDispAsyNLocMaxN[i][j]= 0;
 184
 185       fhSplitEFractionNLocMax1[i][j]=0;
 186       fhSplitEFractionNLocMax2[i][j]=0;
 187       fhSplitEFractionNLocMaxN[i][j]=0;
 188
 189       fhMCGenFracNLocMax1[i][j]= 0;
 190       fhMCGenFracNLocMax2[i][j]= 0;
 191       fhMCGenFracNLocMaxN[i][j]= 0;
 192
 193       fhMCGenFracNLocMax1NoOverlap[i][j]= 0;
 194       fhMCGenFracNLocMax2NoOverlap[i][j]= 0;
 195       fhMCGenFracNLocMaxNNoOverlap[i][j]= 0;
 196
 197       fhMCGenSplitEFracNLocMax1[i][j]= 0;
 198       fhMCGenSplitEFracNLocMax2[i][j]= 0;
 199       fhMCGenSplitEFracNLocMaxN[i][j]= 0;
 200
 201       fhMCGenSplitEFracNLocMax1NoOverlap[i][j]= 0;
 202       fhMCGenSplitEFracNLocMax2NoOverlap[i][j]= 0;
 203       fhMCGenSplitEFracNLocMaxNNoOverlap[i][j]= 0;
 204
 205       fhMCGenEFracvsSplitEFracNLocMax1[i][j]= 0;
 206       fhMCGenEFracvsSplitEFracNLocMax2[i][j]= 0;
 207       fhMCGenEFracvsSplitEFracNLocMaxN[i][j]= 0;
 208
 209       fhMCGenEvsSplitENLocMax1[i][j]= 0;
 210       fhMCGenEvsSplitENLocMax2[i][j]= 0;
 211       fhMCGenEvsSplitENLocMaxN[i][j]= 0;
 212
 213       fhAsymNLocMax1 [i][j] = 0;
 214       fhAsymNLocMax2 [i][j] = 0;
 215       fhAsymNLocMaxN [i][j] = 0;
 216
 217       fhMassAfterCutsNLocMax1[i][j] = 0;
 218       fhMassAfterCutsNLocMax2[i][j] = 0;
 219       fhMassAfterCutsNLocMaxN[i][j] = 0;
 220
 221       fhSplitEFractionAfterCutsNLocMax1[i][j] = 0 ;
 222       fhSplitEFractionAfterCutsNLocMax2[i][j] = 0 ;
 223       fhSplitEFractionAfterCutsNLocMaxN[i][j] = 0 ;
 224     }
 225
 226     for(Int_t jj = 0; jj < 4; jj++)
 227     {
 228       fhM02MCGenFracNLocMax1Ebin[i][jj] = 0;
 229       fhM02MCGenFracNLocMax2Ebin[i][jj] = 0;
 230       fhM02MCGenFracNLocMaxNEbin[i][jj] = 0;
 231
 232       fhMassMCGenFracNLocMax1Ebin[i][jj]= 0;
 233       fhMassMCGenFracNLocMax2Ebin[i][jj]= 0;
 234       fhMassMCGenFracNLocMaxNEbin[i][jj]= 0;
 235
 236       fhMCGenFracNLocMaxEbin[i][jj]       = 0;
 237       fhMCGenFracNLocMaxEbinMatched[i][jj]= 0;
 238
 239       fhMassSplitEFractionNLocMax1Ebin[i][jj] = 0;
 240       fhMassSplitEFractionNLocMax2Ebin[i][jj] = 0;
 241       fhMassSplitEFractionNLocMaxNEbin[i][jj] = 0;
 242     }
 243
 244     fhTrackMatchedDEtaNLocMax1[i] = 0;
 245     fhTrackMatchedDPhiNLocMax1[i] = 0;
 246     fhTrackMatchedDEtaNLocMax2[i] = 0;
 247     fhTrackMatchedDPhiNLocMax2[i] = 0;
 248     fhTrackMatchedDEtaNLocMaxN[i] = 0;
 249     fhTrackMatchedDPhiNLocMaxN[i] = 0;
 250
 251     fhTrackMatchedDEtaNLocMax1Pos[i] = 0;
 252     fhTrackMatchedDPhiNLocMax1Pos[i] = 0;
 253     fhTrackMatchedDEtaNLocMax2Pos[i] = 0;
 254     fhTrackMatchedDPhiNLocMax2Pos[i] = 0;
 255     fhTrackMatchedDEtaNLocMaxNPos[i] = 0;
 256     fhTrackMatchedDPhiNLocMaxNPos[i] = 0;
 257
 258     fhTrackMatchedDEtaNLocMax1Neg[i] = 0;
 259     fhTrackMatchedDPhiNLocMax1Neg[i] = 0;
 260     fhTrackMatchedDEtaNLocMax2Neg[i] = 0;
 261     fhTrackMatchedDPhiNLocMax2Neg[i] = 0;
 262     fhTrackMatchedDEtaNLocMaxNNeg[i] = 0;
 263     fhTrackMatchedDPhiNLocMaxNNeg[i] = 0;
 264
 265     for(Int_t nlm = 0; nlm < 3; nlm++)
 266     {
 267       fhMCEM02Overlap0     [nlm][i] = 0;
 268       fhMCEM02Overlap1     [nlm][i] = 0;
 269       fhMCEM02OverlapN     [nlm][i] = 0;
 270       fhMCEM02Overlap0Match[nlm][i] = 0;
 271       fhMCEM02Overlap1Match[nlm][i] = 0;
 272       fhMCEM02OverlapNMatch[nlm][i] = 0;
 273
 274       fhMCEMassOverlap0     [nlm][i] = 0;
 275       fhMCEMassOverlap1     [nlm][i] = 0;
 276       fhMCEMassOverlapN     [nlm][i] = 0;
 277       fhMCEMassOverlap0Match[nlm][i] = 0;
 278       fhMCEMassOverlap1Match[nlm][i] = 0;
 279       fhMCEMassOverlapNMatch[nlm][i] = 0;
 280
 281       fhMCEAsymOverlap0     [nlm][i] = 0;
 282       fhMCEAsymOverlap1     [nlm][i] = 0;
 283       fhMCEAsymOverlapN     [nlm][i] = 0;
 284       fhMCEAsymOverlap0Match[nlm][i] = 0;
 285       fhMCEAsymOverlap1Match[nlm][i] = 0;
 286       fhMCEAsymOverlapNMatch[nlm][i] = 0;
 287
 288       fhMCENCellOverlap0     [nlm][i] = 0;
 289       fhMCENCellOverlap1     [nlm][i] = 0;
 290       fhMCENCellOverlapN     [nlm][i] = 0;
 291       fhMCENCellOverlap0Match[nlm][i] = 0;
 292       fhMCENCellOverlap1Match[nlm][i] = 0;
 293       fhMCENCellOverlapNMatch[nlm][i] = 0;
 294
 295       fhMCEEpriOverlap0     [nlm][i] = 0;
 296       fhMCEEpriOverlap1     [nlm][i] = 0;
 297       fhMCEEpriOverlapN     [nlm][i] = 0;
 298       fhMCEEpriOverlap0Match[nlm][i] = 0;
 299       fhMCEEpriOverlap1Match[nlm][i] = 0;
 300       fhMCEEpriOverlapNMatch[nlm][i] = 0;
 301
 302       fhMCEEpriOverlap0IdPi0[nlm][i] = 0;
 303       fhMCEEpriOverlap1IdPi0[nlm][i] = 0;
 304       fhMCEEpriOverlapNIdPi0[nlm][i] = 0;
 305
 306       fhMCESplitEFracOverlap0     [nlm][i] = 0;
 307       fhMCESplitEFracOverlap1     [nlm][i] = 0;
 308       fhMCESplitEFracOverlapN     [nlm][i] = 0;
 309       fhMCESplitEFracOverlap0Match[nlm][i] = 0;
 310       fhMCESplitEFracOverlap1Match[nlm][i] = 0;
 311       fhMCESplitEFracOverlapNMatch[nlm][i] = 0;
 312
 313       fhMCENOverlaps       [nlm][i] = 0;
 314       fhMCENOverlapsMatch  [nlm][i] = 0;
 315
 316       if(i > 3) continue ;
 317
 318       fhMCPi0MassM02Overlap0     [nlm][i] = 0;
 319       fhMCPi0MassM02Overlap1     [nlm][i] = 0;
 320       fhMCPi0MassM02OverlapN     [nlm][i] = 0;
 321       fhMCPi0MassM02Overlap0Match[nlm][i] = 0;
 322       fhMCPi0MassM02Overlap1Match[nlm][i] = 0;
 323       fhMCPi0MassM02OverlapNMatch[nlm][i] = 0;
 324     }
 325   }
 326
 327   for(Int_t i = 0; i < 2; i++)
 328   {
 329     fhAnglePairNLocMax1    [i] = 0;
 330     fhAnglePairNLocMax2    [i] = 0;
 331     fhAnglePairNLocMaxN    [i] = 0;
 332     fhAnglePairMassNLocMax1[i] = 0;
 333     fhAnglePairMassNLocMax2[i] = 0;
 334     fhAnglePairMassNLocMaxN[i] = 0;
 335     fhSplitEFractionvsAsyNLocMax1[i] = 0;
 336     fhSplitEFractionvsAsyNLocMax2[i] = 0;
 337     fhSplitEFractionvsAsyNLocMaxN[i] = 0;
 338   }
 339
 340   for(Int_t i = 0; i < 4; i++)
 341   {
 342     fhMassM02NLocMax1Ebin[i] = 0 ;
 343     fhMassM02NLocMax2Ebin[i] = 0 ;
 344     fhMassM02NLocMaxNEbin[i] = 0 ;
 345
 346     fhMassAsyNLocMax1Ebin[i] = 0 ;
 347     fhMassAsyNLocMax2Ebin[i] = 0 ;
 348     fhMassAsyNLocMaxNEbin[i] = 0 ;
 349
 350     fhAsyMCGenRecoNLocMax1EbinPi0[i] = 0 ;
 351     fhAsyMCGenRecoNLocMax2EbinPi0[i] = 0 ;
 352     fhAsyMCGenRecoNLocMaxNEbinPi0[i] = 0 ;
 353
 354     fhMassDispEtaNLocMax1Ebin[i] = 0 ;
 355     fhMassDispEtaNLocMax2Ebin[i] = 0 ;
 356     fhMassDispEtaNLocMaxNEbin[i] = 0 ;
 357
 358     fhMassDispPhiNLocMax1Ebin[i] = 0 ;
 359     fhMassDispPhiNLocMax2Ebin[i] = 0 ;
 360     fhMassDispPhiNLocMaxNEbin[i] = 0 ;
 361
 362     fhMassDispAsyNLocMax1Ebin[i] = 0 ;
 363     fhMassDispAsyNLocMax2Ebin[i] = 0 ;
 364     fhMassDispAsyNLocMaxNEbin[i] = 0 ;
 365
 366     fhMCAsymM02NLocMax1MCPi0Ebin[i] = 0 ;
 367     fhMCAsymM02NLocMax2MCPi0Ebin[i] = 0 ;
 368     fhMCAsymM02NLocMaxNMCPi0Ebin[i] = 0 ;
 369   }
 370
 371   for(Int_t nlm = 0; nlm < 3; nlm++)
 372   {
 373     fhPi0CellE       [nlm] = 0 ;
 374     fhPi0CellEFrac   [nlm] = 0 ;
 375     fhPi0CellLogEFrac[nlm] = 0 ;
 376
 377     fhPi0CellEMaxEMax2Frac   [nlm] = 0 ;
 378     fhPi0CellEMaxClusterFrac [nlm] = 0 ;
 379     fhPi0CellEMax2ClusterFrac[nlm] = 0 ;
 380
 381     fhPi0CellEMaxFrac [nlm] = 0 ;
 382     fhPi0CellEMax2Frac[nlm] = 0 ;
 383
 384     for(Int_t i = 0; i < 10; i++)
 385     {
 386       fhM02WeightPi0  [nlm][i] = 0;
 387       fhM02ECellCutPi0[nlm][i] = 0;
 388     }
 389   }
 390
 391   InitParameters();
 392
 393 }
 394
 395 //_______________________________________________________________________________________________________
 396 void AliAnaInsideClusterInvariantMass::CheckLocalMaximaMCOrigin(AliVCluster* cluster,
 397                                                                 const Int_t mcindex, const Int_t noverlaps)
 398                                                                 //Float_t mass, Float_t m02,
 399                                                                 //TLorentzVector l1, TLorentzVector l2)
 400 {
 401   // Check origin NLM tower of the cluster, when MC gives merged pi0
 402
 403   if(mcindex != kmcPi0 && mcindex != kmcPi0Conv) return;
 404
 405   const UInt_t nc = cluster->GetNCells();
 406   Int_t   list[nc];
 407   Float_t elist[nc];
 408   Int_t nMax = GetCaloUtils()->GetNumberOfLocalMaxima(cluster, GetEMCALCells(),list, elist);
 409
 410
 411   //// PRINTS /////
 412
 413   //if(mcindex==kmcPi0)     printf("** Normal Pi0 **\n");
 414   //if(mcindex==kmcPi0Conv) printf("** Converted Pi0 **\n");
 415
 416 //  if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 417 //  {
 418 //     printf("** N max %d - Overlaps = %d **, mass %2.2f, m02 %2.2f, Cl1(E,eta,phi)=(%2.2f,%2.2f,%2.2f),Cl2(E,eta,phi)=(%2.2f,%2.2f,%2.2f), mass(1,2) %2.2f \n",
 419 //            nMax, noverlaps,mass,m02,
 420 //            l1.E(),l1.Eta(),l1.Phi()*TMath::RadToDeg(),
 421 //            l2.E(),l2.Eta(),l2.Phi()*TMath::RadToDeg(), (l1+l2).M());
 422 //
 423 //    // Study the mothers of cluster
 424 //    printf("Cluster MC labels %d \n", cluster->GetNLabels());
 425 //    for (UInt_t ilab = 0; ilab < cluster->GetNLabels(); ilab++ )
 426 //    {
 427 //      Int_t mclabel = cluster->GetLabels()[ilab];
 428 //
 429 //      Bool_t  mOK = 0;
 430 //      Int_t   mpdg = -999999;
 431 //      Int_t   mstatus = -1;
 432 //      Int_t   grandLabel = -1;
 433 //      TLorentzVector mother = GetMCAnalysisUtils()->GetMother(mclabel,GetReader(),mpdg,mstatus,mOK,grandLabel);
 434 //
 435 //      printf("******** mother %d : Label %d, pdg %d; status %d, E %2.2f, Eta %2.2f, Phi %2.2f, ok %d, mother label %d\n",
 436 //             ilab, mclabel, mpdg, mstatus,mother.E(), mother.Eta(),mother.Phi()*TMath::RadToDeg(),mOK,grandLabel);
 437 //
 438 //      if( ( mpdg == 22 || TMath::Abs(mpdg)==11 ) && grandLabel >=0 )
 439 //      {
 440 //        while( ( mpdg == 22 || TMath::Abs(mpdg)==11 ) && grandLabel >=0 )
 441 //        {
 442 //          Int_t newLabel = -1;
 443 //          TLorentzVector grandmother = GetMCAnalysisUtils()->GetMother(grandLabel,GetReader(),mpdg,mstatus,mOK,newLabel);
 444 //          printf("\t grandmother %d : Label %d, pdg %d; status %d, E %2.2f, Eta %2.2f, Phi %2.2f, ok %d, mother label %d\n",
 445 //                 ilab, grandLabel, mpdg, mstatus,grandmother.E(), grandmother.Eta(), grandmother.Phi()*TMath::RadToDeg(),mOK,newLabel);
 446 //          grandLabel = newLabel;
 447 //
 448 //        }
 449 //      }
 450 //    }
 451 //
 452 //    printf("Cells in cluster %d\n",cluster->GetNCells() );
 453 //    for(Int_t icell = 0; icell < cluster->GetNCells(); icell++)
 454 //    {
 455 //      Int_t absIdCell = cluster->GetCellAbsId(icell);
 456 //      Int_t mcLabel   = GetEMCALCells()->GetCellMCLabel(absIdCell);
 457 //      GetReader()->RemapMCLabelForAODs(mcLabel);
 458 //      Int_t ietac=-1; Int_t iphic = 0; Int_t rcuc = 0;
 459 //      Int_t smc = GetModuleNumberCellIndexes(absIdCell,fCalorimeter, ietac, iphic, rcuc);
 460 //
 461 //      printf(" \t cell i %d, abs %d, amp %2.3f, mclabel %d, (sm,ieta,iphi)=(%d,%d,%d)\n",icell,absIdCell,GetEMCALCells()->GetCellAmplitude(absIdCell),mcLabel,smc,ietac,iphic);
 462 //    }
 463 //  }
 464   //// PRINTS /////
 465
 466
 467   //If only one maxima, consider all the towers in the cluster
 468   if(nMax==1)
 469   {
 470     for (UInt_t icell = 0; icell < nc; icell++ )
 471     {
 472       list [icell] = cluster->GetCellAbsId(icell);
 473       elist[icell] = GetEMCALCells()->GetCellAmplitude(list[icell]);
 474     }
 475   }
 476
 477   Int_t nmaxima = nMax;
 478   if(nMax==1) nmaxima = nc ;
 479
 480   //Find highest energy Local Maxima Towers
 481   Int_t   imax  = -1;
 482   Int_t   imax2 = -1;
 483   Float_t emax  = -1;
 484   Float_t emax2 = -1;
 485   for(Int_t i = 0; i < nmaxima; i++)
 486   {
 487     //printf("i %d: AbsId %d; E %2.3f\n",i,list[i],elist[i]);
 488     if(elist[i] > emax)
 489     {
 490       imax = i;
 491       emax = elist[i];
 492     }
 493   }
 494   //Find second highest
 495   for(Int_t i = 0; i < nmaxima; i++)
 496   {
 497     if(i==imax) continue;
 498
 499     //printf("j %d: AbsId %d; E %2.3f\n",i,list[i],elist[i]);
 500
 501
 502     if(elist[i] > emax2)
 503     {
 504       imax2 = i;
 505       emax2 = elist[i];
 506     }
 507   }
 508
 509 // if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 510 //    printf("Local maxima: a) index %d, absId %d; b) index %d, absId %d\n",imax, list[imax], imax2, list[imax2]);
 511
 512   //---------------------------------------------------------
 513   //---------------------------------------------------------
 514   // Compare ancestors of all local maxima at cell MC level
 515   //---------------------------------------------------------
 516   //---------------------------------------------------------
 517
 518   // Check that the highest mc label and the max cluster label are the same
 519   Int_t mcLabelMax = -1 ;
 520   if(imax >=0 )
 521   {
 522     mcLabelMax = GetEMCALCells()->GetCellMCLabel(list[imax]);
 523     GetReader()->RemapMCLabelForAODs(mcLabelMax);
 524   }
 525
 526   Int_t mcLabelMax2 = -1 ;
 527   if(imax >=0 )
 528   {
 529     mcLabelMax2 = GetEMCALCells()->GetCellMCLabel(list[imax2]);
 530     GetReader()->RemapMCLabelForAODs(mcLabelMax2);
 531   }
 532
 533   Int_t mcLabelclusterMax = cluster->GetLabels()[0];
 534   Bool_t matchHighLMAndHighMC = kFALSE;
 535
 536   //printf("MC label: LM1 %d, LM2 %d, cluster %d\n",mcLabelMax,mcLabelMax2,mcLabelclusterMax);
 537
 538   if(mcLabelclusterMax == mcLabelMax && mcLabelclusterMax >= 0)
 539   {
 540     matchHighLMAndHighMC = kTRUE;
 541     //printf("\t *** MATCH cluster and LM maximum ***\n");
 542   }
 543   else
 544   {
 545      //printf("\t *** NO MATCH cluster and LM maximum, check second ***\n");
 546     if(mcLabelclusterMax == mcLabelMax2 && mcLabelclusterMax >= 0)
 547     {
 548       //printf("\t \t *** MATCH cluster and 2nd LM maximum ***\n");
 549       matchHighLMAndHighMC = kTRUE;
 550     }
 551     else
 552     {
 553       //printf("\t \t *** NO MATCH***\n");
 554       matchHighLMAndHighMC = kFALSE;
 555     }
 556   }
 557
 558   // Compare the common ancestors of the 2 highest energy local maxima
 559   Int_t ancPDG = 0, ancStatus = -1;
 560   TLorentzVector momentum; TVector3 prodVertex;
 561   Int_t ancLabel = 0;
 562   Bool_t high = kFALSE;
 563   Bool_t low  = kFALSE;
 564
 565 //  // print maxima origin
 566 //  for(Int_t i = 0; i < nMax; i++)
 567 //  {
 568 //    Int_t mcLabel1 = GetEMCALCells()->GetCellMCLabel(list[i]);
 569 //    GetReader()->RemapMCLabelForAODs(mcLabel1);
 570 //
 571 //    Bool_t ok  =kFALSE,gok = kFALSE;
 572 //    Int_t pdg    = -22222, status   = -1;
 573 //    Int_t gpdg   = -22222, gstatus  = -1;
 574 //    Int_t ggpdg  = -22222, ggstatus = -1;
 575 //    Int_t gLabel = -1, ggLabel = -1;
 576 //    TLorentzVector primary   =GetMCAnalysisUtils()->GetMother     (mcLabel1,GetReader(),  pdg,  status, ok);
 577 //    TLorentzVector gprimary  =GetMCAnalysisUtils()->GetGrandMother(mcLabel1,GetReader(), gpdg, gstatus,gok, gLabel,ggLabel);
 578 //    TLorentzVector ggprimary =GetMCAnalysisUtils()->GetMother(ggLabel  ,GetReader(),ggpdg,ggstatus,gok);
 579 //    printf("Max index %d; mother: Label %d; PDG %d; E %2.2f - grand mother label %d; PDG %d; E %2.2f- great grand mother label %d; PDG %d; E %2.2f\n",
 580 //           i,mcLabel1,pdg,primary.E(), gLabel,gpdg,gprimary.E(), ggLabel,ggpdg,ggprimary.E());
 581 //  }
 582
 583   for(Int_t i = 0; i < nmaxima-1; i++)
 584   {
 585     Int_t mcLabel1 = GetEMCALCells()->GetCellMCLabel(list[i]);
 586     GetReader()->RemapMCLabelForAODs(mcLabel1);
 587
 588     for(Int_t j = i+1; j < nmaxima; j++)
 589     {
 590       Int_t mcLabel2 = GetEMCALCells()->GetCellMCLabel(list[j]);
 591       GetReader()->RemapMCLabelForAODs(mcLabel2);
 592
 593       if(mcLabel1 < 0 || mcLabel2 < 0 )
 594       {
 595         //printf("\t i %d label %d - j %d label %d; skip!\n",i,mcLabel1,j,mcLabel2);
 596         continue;
 597       }
 598
 599       ancLabel = GetMCAnalysisUtils()->CheckCommonAncestor(mcLabel1,mcLabel2,
 600                                                            GetReader(),ancPDG,ancStatus,momentum,prodVertex);
 601       if(ancPDG==111)
 602       {
 603         if((i==imax && j==imax2) ||  (j==imax && i==imax2))
 604           high = kTRUE;
 605         else
 606           low = kTRUE;
 607       }
 608       else if(ancPDG==22 || TMath::Abs(ancPDG)==11)
 609       {
 610         // If both bits are set, it could be that one of the maxima had a conversion
 611         // reset the bit in this case
 612         if(high && low)
 613         {
 614           //printf("\t Reset low bit\n");
 615           low = kFALSE;
 616         }
 617       }
 618
 619       Bool_t ok  =kFALSE;
 620       Int_t pdg = -22222, status = -1;
 621       TLorentzVector primary  =GetMCAnalysisUtils()->GetMother(ancLabel,GetReader(), pdg, status, ok);
 622       //printf("\t i %d label %d - j %d label %d; ancestor label %d, PDG %d-%d; E %2.2f; high %d, any %d \n",i,mcLabel1,j,mcLabel2, ancLabel, ancPDG,pdg, primary.E(), high, low);
 623
 624     }
 625   }
 626
 627   Float_t en = cluster->E();
 628
 629 // if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 630 //    printf("Cell MC match: nMax %d; Match MC? %d; high %d; low %d\n",nMax,matchHighLMAndHighMC,high,low);
 631
 632   if(!noverlaps)
 633   {
 634     if(matchHighLMAndHighMC)
 635     {
 636       if     (high && !low)  fhMCPi0HighNLMPair->Fill(en,nMax);
 637       else if(low  && !high) fhMCPi0LowNLMPair ->Fill(en,nMax);
 638       else if(low  &&  high) fhMCPi0AnyNLMPair ->Fill(en,nMax);
 639       else                   fhMCPi0NoneNLMPair->Fill(en,nMax);
 640     }
 641     else
 642     {
 643       if     (high && !low)  fhMCPi0HighNLMPairNoMCMatch->Fill(en,nMax);
 644       else if(low  && !high) fhMCPi0LowNLMPairNoMCMatch ->Fill(en,nMax);
 645       else if(low  &&  high) fhMCPi0AnyNLMPairNoMCMatch ->Fill(en,nMax);
 646       else                   fhMCPi0NoneNLMPairNoMCMatch->Fill(en,nMax);
 647     }
 648   }
 649   else
 650   {
 651     if(matchHighLMAndHighMC)
 652     {
 653       if     (high && !low)  fhMCPi0HighNLMPairOverlap->Fill(en,nMax);
 654       else if(low  && !high) fhMCPi0LowNLMPairOverlap->Fill(en,nMax);
 655       else if(low  &&  high) fhMCPi0AnyNLMPairOverlap->Fill(en,nMax);
 656       else                   fhMCPi0NoneNLMPairOverlap->Fill(en,nMax);
 657     }
 658     else
 659     {
 660       if     (high && !low)  fhMCPi0HighNLMPairNoMCMatchOverlap->Fill(en,nMax);
 661       else if(low  && !high) fhMCPi0LowNLMPairNoMCMatchOverlap->Fill(en,nMax);
 662       else if(low  &&  high) fhMCPi0AnyNLMPairNoMCMatchOverlap->Fill(en,nMax);
 663       else                   fhMCPi0NoneNLMPairNoMCMatchOverlap->Fill(en,nMax);
 664     }
 665   }
 666
 667   //----------------------------------------------------------------------
 668   //----------------------------------------------------------------------
 669   // Compare MC decay photon projection to cell location and Local Maxima
 670   //----------------------------------------------------------------------
 671   //----------------------------------------------------------------------
 672
 673   // Get the mother pi0
 674
 675   Bool_t ok     = kFALSE;
 676   Int_t pdg    = -22222, status   = -1;
 677   Int_t gLabel = -1;
 678
 679   Int_t label = cluster->GetLabel();
 680   TLorentzVector pi0Kine;
 681
 682   while( pdg!=111 && label>=0 )
 683   {
 684     pi0Kine = GetMCAnalysisUtils()->GetGrandMother(label,GetReader(),pdg,status,ok, label,gLabel);
 685   }
 686
 687   if(pdg!=111 || label < 0)
 688   {
 689     printf("AliAnaInsideClusterInvariantMass::CheckLocalMaximaMCOrigin(() - Mother Pi0 not found!\n");
 690     return;
 691   }
 692
 693   Int_t nDaugthers = GetMCAnalysisUtils()->GetNDaughters(label,GetReader(),ok);
 694
 695   if(nDaugthers != 2)
 696   {
 697     printf("AliAnaInsideClusterInvariantMass::CheckLocalMaximaMCOrigin(() - N daughters %d !=2!\n",nDaugthers);
 698     return;
 699   }
 700
 701   // Get daughter photon kinematics
 702   Int_t pdg0 = -22222, status0   = -1; Int_t label0 = -1;
 703   TLorentzVector photon0Kine = GetMCAnalysisUtils()->GetDaughter(0,label,GetReader(),pdg0,status0,ok,label0);
 704   Int_t pdg1 = -22222, status1   = -1; Int_t label1 = -1;
 705   TLorentzVector photon1Kine = GetMCAnalysisUtils()->GetDaughter(1,label,GetReader(),pdg1,status1,ok,label1);
 706
 707   if(pdg1!=22 || pdg0 != 22)
 708   {
 709     printf("AliAnaInsideClusterInvariantMass::CheckLocalMaximaMCOrigin(() - Wrong daughters PDG: photon0 %d - photon1 %d\n",pdg0,pdg1);
 710     return;
 711   }
 712
 713   // In what cells did the photons hit
 714   Float_t eta0 = photon0Kine.Eta();
 715   Float_t eta1 = photon1Kine.Eta();
 716
 717   Float_t phi0 = photon0Kine.Phi();
 718   Float_t phi1 = photon1Kine.Phi();
 719
 720 // if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 721 //  {
 722 //    printf("MC pi0 label %d E  %2.2f, eta %2.2f, phi %2.2f, mass (ph1, ph2) %2.2f: \n \t photon0 label %d E %2.2f, eta %2.2f, phi %2.2f \n \t photon1 label %d E %2.2f eta %2.2f, phi %2.2f\n",
 723 //           label , pi0Kine.E()    , pi0Kine.Eta(),pi0Kine.Phi()*TMath::RadToDeg(), (photon0Kine+photon1Kine).M(),
 724 //           label0, photon0Kine.E(),          eta0,         phi0*TMath::RadToDeg(),
 725 //           label1, photon1Kine.E(),          eta1,         phi1*TMath::RadToDeg());
 726 //
 727 //    TLorentzVector momclus;
 728 //    cluster->GetMomentum(momclus,GetVertex(0));
 729 //    printf("Cluster E %2.2F eta %2.2f, phi %2.2f, dist to bad %2.2f\n",momclus.E(),momclus.Eta(),momclus.Phi()*TMath::RadToDeg(), cluster->GetDistanceToBadChannel());
 730 //  }
 731
 732   if(phi0 < 0 ) phi0+=TMath::TwoPi();
 733   if(phi1 < 0 ) phi1+=TMath::TwoPi();
 734
 735   Int_t absId0=-1, absId1=-1;
 736   GetEMCALGeometry()->GetAbsCellIdFromEtaPhi(eta0, phi0, absId0);
 737   GetEMCALGeometry()->GetAbsCellIdFromEtaPhi(eta1, phi1, absId1);
 738
 739   if(absId1 < 0 || absId1 < 0)
 740   {
 741     //printf("AliAnaInsideClusterInvariantMass::CheckLocalMaximaMCOrigin(() -  Photon hit AbsId: photon0 %d - photon1 %d\n",absId0,absId1);
 742     return;
 743   }
 744
 745   //-----------------------------------------------
 746   // Check that the 2 photons hit the Local Maxima
 747   //-----------------------------------------------
 748
 749
 750 // if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 751 //  {
 752 //    printf("Photons AbsId (%d,%d); Local Maxima AbsId(%d,%d)\n",absId0,absId1,list[imax],list[imax2]);
 753 //    printf("Photon1 (eta,phi)=(%f,%f); Photon2 (eta,phi)=(%f,%f);\n",eta0,phi0*TMath::RadToDeg(),eta1,phi1*TMath::RadToDeg());
 754 //
 755 //    Int_t ieta0=-1; Int_t iphi0 = 0; Int_t rcu0 = 0;
 756 //    Int_t sm0 = GetModuleNumberCellIndexes(absId0,fCalorimeter, ieta0, iphi0, rcu0);
 757 //    Int_t ieta1=-1; Int_t iphi1 = 0; Int_t rcu1 = 0;
 758 //    Int_t sm1 = GetModuleNumberCellIndexes(absId1,fCalorimeter, ieta1, iphi1, rcu1);
 759 //
 760 //    printf("Photon1 (id,sm,eta,phi)=(%d,%d,%d,%d), Photon2 (id,sm,eta,phi)=(%d,%d,%d,%d)\n",
 761 //           absId0,sm0,ieta0,iphi0,absId1,sm1,ieta1,iphi1);
 762 //
 763 //    Int_t ietam0=-1; Int_t iphim0 = 0; Int_t rcum0 = 0; Int_t smm0 = -1 ;
 764 //    if(imax  >= 0) smm0 = GetModuleNumberCellIndexes(list[imax] ,fCalorimeter, ietam0, iphim0, rcum0);
 765 //    Int_t ietam1=-1; Int_t iphim1 = 0; Int_t rcum1 = 0; Int_t smm1 = -1 ;
 766 //    if(imax2 >= 0) smm1 = GetModuleNumberCellIndexes(list[imax2],fCalorimeter, ietam1, iphim1, rcum1);
 767 //
 768 //    printf("Max (id, sm,eta,phi)=(%d,%d,%d,%d), Max2 (id, sm,eta,phi)=(%d,%d,%d,%d)\n",
 769 //           list[imax],smm0,ietam0,iphim0,list[imax2],smm1,ietam1,iphim1);
 770 //  }
 771
 772
 773   Bool_t match0  = kFALSE;
 774   Bool_t match1  = kFALSE;
 775   Int_t imatch0  = -1;
 776   Int_t imatch1  = -1;
 777   if(imax >= 0 && imax2 >=0 && absId0 > 0 && absId1 > 0 )
 778   {
 779     if     (absId0 == list[imax] ) { match0 = kTRUE ; imatch0 = imax  ; }
 780     else if(absId0 == list[imax2]) { match0 = kTRUE ; imatch0 = imax2 ; }
 781
 782     if     (absId1 == list[imax] ) { match1 = kTRUE ; imatch1 = imax  ; }
 783     else if(absId1 == list[imax2]) { match1 = kTRUE ; imatch1 = imax2 ; }
 784   }
 785
 786   //printf("primary imatch0 %d, imatch1 %d\n",imatch0,imatch1);
 787
 788   // If one or the 2 not matched, check with the other MC labels
 789   // only in case there was a conversion
 790
 791   Int_t   absId0second  = -1;
 792   Int_t   absId1second  = -1;
 793   Int_t   secLabel0     = -1;
 794   Int_t   secLabel1     = -1;
 795   Int_t   mcLabel0      = -1;
 796   Int_t   mcLabel1      = -1;
 797   Bool_t  secOK         = 0;
 798   Int_t   secpdg        = -999999;
 799   Int_t   secstatus     = -1;
 800   Int_t   secgrandLabel = -1;
 801
 802   if(match0) { secLabel0 = label0 ; mcLabel0 = label0 ; }
 803   if(match1) { secLabel1 = label1 ; mcLabel1 = label1 ; }
 804
 805   if((!match0 || !match1) && mcindex == kmcPi0Conv)
 806   {
 807     for (UInt_t ilab = 0; ilab < cluster->GetNLabels(); ilab++ )
 808     {
 809       Int_t mclabel = cluster->GetLabels()[ilab];
 810
 811       //printf("Check label %d - %d\n",ilab,mclabel);
 812
 813       if(mclabel == label0 || mclabel == label1)
 814       {
 815         //printf("continue: secLabel %d, label0 %d, label1 %d\n",mclabel,label0,label1);
 816         if(mclabel == label0 && secLabel0 < 0) { secLabel0 = label0 ; mcLabel0 = label0 ; }
 817         if(mclabel == label1 && secLabel1 < 0) { secLabel1 = label1 ; mcLabel1 = label1 ; }
 818         continue ;
 819       }
 820
 821       //printf("Before while: secLabel0 %d, secLabel1 %d\n",secLabel0,secLabel1);
 822
 823       // match mc label and parent photon
 824       Int_t tmplabel   = mclabel;
 825       while((secLabel0 < 0 || secLabel1 < 0) && tmplabel > 0 )
 826       {
 827         TLorentzVector mother = GetMCAnalysisUtils()->GetMother(tmplabel,GetReader(),secpdg,secstatus,secOK,secgrandLabel);
 828
 829         //printf("\t \t while secLabel %d, mom %d, granmom %d\n",mclabel,tmplabel,secgrandLabel);
 830
 831         if((secgrandLabel == label0) || (secgrandLabel == label1 ))
 832         {
 833           //printf("mcMatch! grand label %d, secLabel %d\n",secgrandLabel, mclabel);
 834           if(!match0 && mcLabel1 != secgrandLabel) { secLabel0 = mclabel; mcLabel0 = secgrandLabel; }
 835           if(!match1 && mcLabel0 != secgrandLabel) { secLabel1 = mclabel; mcLabel1 = secgrandLabel; }
 836         }
 837
 838         //printf("\t GrandMother %d, secLabel0 %d, secLabel1 %d \n",secgrandLabel, secLabel0,secLabel1);
 839
 840         tmplabel = secgrandLabel;
 841       }
 842     }
 843
 844     // Get the position of the found secondaries mother
 845     if(!match0 && secLabel0 > 0)
 846     {
 847       TLorentzVector mother = GetMCAnalysisUtils()->GetMother(secLabel0,GetReader(),secpdg,secstatus,secOK,secgrandLabel);
 848
 849       //Float_t eta = mother.Eta();
 850       //Float_t phi = mother.Phi();
 851       //if(phi < 0 ) phi+=TMath::TwoPi();
 852       //GetEMCALGeometry()->GetAbsCellIdFromEtaPhi(eta, phi, absId0second);
 853
 854       //printf("Secondary MC0 label %d, absId %d E %2.2F eta %2.2f, phi %f\n", secLabel0,absId0second, mother.E(),mother.Eta(),mother.Phi()*TMath::RadToDeg());
 855
 856       if(absId0second == list[imax] ) { match0 = kTRUE ; imatch0 = imax  ; }
 857       if(absId0second == list[imax2]) { match0 = kTRUE ; imatch0 = imax2 ; }
 858     }
 859
 860     if(!match1 && secLabel1 > 0)
 861     {
 862       TLorentzVector mother = GetMCAnalysisUtils()->GetMother(secLabel1,GetReader(),secpdg,secstatus,secOK,secgrandLabel);
 863
 864       //Float_t eta = mother.Eta();
 865       //Float_t phi = mother.Phi();
 866       //if(phi < 0 ) phi+=TMath::TwoPi();
 867       //GetEMCALGeometry()->GetAbsCellIdFromEtaPhi(eta, phi, absId1second);
 868
 869       //printf("Secondary MC1 label %d absId %d E %2.2F eta %2.2f, phi %f\n",secLabel1, absId1second, mother.E(),mother.Eta(),mother.Phi()*TMath::RadToDeg());
 870
 871       if(absId1second == list[imax] ) { match1 = kTRUE ; imatch1 = imax  ; }
 872       if(absId1second == list[imax2]) { match1 = kTRUE ; imatch1 = imax2 ; }
 873     }
 874
 875     //printf("secondary label mc0 %d, mc1 %d, imatch0 %d, imatch1 %d\n",secLabel0,secLabel1,imatch0,imatch1);
 876
 877   }
 878
 879   //printf("imatch0 %d, imatch1 %d\n",imatch0,imatch1);
 880   if( match0 && match1 )
 881   {
 882 //   if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 883 //      printf("a) Both Photons hit local maxima \n");
 884
 885     if(!noverlaps)fhMCPi0DecayPhotonHitHighLM       ->Fill(en,nMax);
 886     else          fhMCPi0DecayPhotonHitHighLMOverlap->Fill(en,nMax);
 887
 888     return ;
 889   }
 890
 891   //printf("Any match? photon0 %d, photon1 %d\n",match0,match1);
 892   //if(!match0 && !match1) printf("WARNING, LM not matched to any photon decay!\n");
 893
 894   //---------------------------------------------
 895   // Check the adjacent cells to the local maxima
 896   //---------------------------------------------
 897
 898   if(!match0)
 899   {
 900     if(imatch1!=imax  && GetCaloUtils()->AreNeighbours(fCalorimeter,absId0,list[imax])) match0 = kTRUE;
 901     //printf("imax - match0? (%d-%d)=%d, (%d-%d)=%d\n",ieta0,ietam0,ieta0-ietam0, iphi0,iphim0,iphi0-iphim0);
 902     if(imatch1!=imax2 && GetCaloUtils()->AreNeighbours(fCalorimeter,absId0,list[imax2]) ) match0 = kTRUE;
 903     //printf("imax2 - match0? (%d-%d)=%d, (%d-%d)=%d\n",ieta0,ietam1,ieta0-ietam1, iphi0,iphim1,iphi0-iphim1);
 904   }
 905
 906   if(!match1)
 907   {
 908     if(imatch0!=imax  && GetCaloUtils()->AreNeighbours(fCalorimeter,absId1,list[imax]) ) match1 = kTRUE;
 909     //printf("imax - match1? (%d-%d)=%d, (%d-%d)=%d\n",ieta1,ietam0,ieta1-ietam0, iphi1,iphim0,iphi1-iphim0);
 910
 911     if(imatch0!=imax2 && GetCaloUtils()->AreNeighbours(fCalorimeter,absId1,list[imax2])) match1 = kTRUE;
 912     //printf("imax2 - match1? (%d-%d)=%d, (%d-%d)=%d\n",ieta1,ietam1,ieta1-ietam1, iphi1,iphim1,iphi1-iphim1);
 913   }
 914
 915   //printf("Local Maxima: adjacent0 %d,adjacent1 %d \n",match0,match1);
 916
 917   if(match0 && match1)
 918   {
 919 //   if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 920 //      printf("b) Both Photons hit local maxima or cell adjacent or 2 cells adjacent \n");
 921
 922     if(!noverlaps) fhMCPi0DecayPhotonAdjHighLM       ->Fill(en,nMax);
 923     else           fhMCPi0DecayPhotonAdjHighLMOverlap->Fill(en,nMax);
 924
 925     return;
 926   }
 927
 928
 929   // Decay photon cells are adjacent?
 930
 931   if( (match0 || match1) && GetCaloUtils()->AreNeighbours(fCalorimeter,absId0,absId1) )
 932   {
 933 //   if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 934 //      printf("c) Both Photons hit a local maxima and in adjacent cells \n");
 935     if(!noverlaps)  fhMCPi0DecayPhotonAdjacent        ->Fill(en,nMax);
 936     else            fhMCPi0DecayPhotonAdjacentOverlap ->Fill(en,nMax);
 937
 938     return;
 939   }
 940
 941   //--------------------
 942   // Other Local maxima
 943   //--------------------
 944
 945   Bool_t matchMCHitOtherLM = kFALSE;
 946   if(!match1)
 947   {
 948     for(Int_t i = 0; i < nmaxima; i++)
 949     {
 950       if(imax!=i && imax2!=i && absId1 == list[i]) { match1 = kTRUE; matchMCHitOtherLM = kTRUE; }
 951     }
 952   }
 953
 954   if(!match0)
 955   {
 956     for(Int_t i = 0; i < nmaxima; i++)
 957     {
 958       if(imax!=i && imax2!=i && absId0 == list[i]) { match0 = kTRUE; matchMCHitOtherLM = kTRUE; }
 959     }
 960   }
 961
 962   if(matchMCHitOtherLM)
 963   {
 964 //   if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
 965 //      printf("d) One Photon hits a local maxima, the other another not high \n");
 966
 967     if(!noverlaps) fhMCPi0DecayPhotonHitOtherLM       ->Fill(en,nMax);
 968     else           fhMCPi0DecayPhotonHitOtherLMOverlap->Fill(en,nMax);
 969
 970     return ;
 971   }
 972
 973   // Adjacent to other maxima
 974
 975   Bool_t adjacentOther1 = kFALSE;
 976   if(match0)
 977   {
 978     for(Int_t i = 0; i < nmaxima; i++)
 979     {
 980       Int_t ieta=-1; Int_t iphi = 0; Int_t rcu = 0;
 981       GetModuleNumberCellIndexes(list[i] ,fCalorimeter, ieta, iphi, rcu);
 982
 983       //printf(" Other Max (eta,phi)=(%d,%d)\n",ieta,iphi);
 984
 985       if(GetCaloUtils()->AreNeighbours(fCalorimeter,absId1,list[i]) ) adjacentOther1 = kTRUE;
 986
 987       //printf("Other Maxima: adjacentOther1 %d\n",adjacentOther1);
 988     }
 989   }
 990
 991   Bool_t adjacentOther0 = kFALSE;
 992   if(match1)
 993   {
 994     for(Int_t i = 0; i < nmaxima; i++)
 995     {
 996       Int_t ieta=-1; Int_t iphi = 0; Int_t rcu = 0;
 997       GetModuleNumberCellIndexes(list[i] ,fCalorimeter, ieta, iphi, rcu);
 998
 999       //printf(" Other Max (eta,phi)=(%d,%d)\n",ieta,iphi);
1000
1001       if(GetCaloUtils()->AreNeighbours(fCalorimeter,absId0,list[i]) ) adjacentOther0 = kTRUE;
1002
1003       //printf("Other Maxima: adjacentOther0 %d\n",adjacentOther0);
1004     }
1005   }
1006
1007   if((match0 && adjacentOther1) || (match1 && adjacentOther0))
1008   {
1009
1010 //   if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
1011 //      printf("e) One Photon hits a local maxima, the other another not high, adjacent \n");
1012
1013     if(!noverlaps) fhMCPi0DecayPhotonAdjOtherLM       ->Fill(en,nMax);
1014     else           fhMCPi0DecayPhotonAdjOtherLMOverlap->Fill(en,nMax);
1015
1016     return;
1017   }
1018
1019 // if((mass < 0.06 || mass > 1.8) && mcindex==kmcPi0 && noverlaps == 0)
1020 //    printf("f) No hit found \n");
1021   if(!noverlaps) fhMCPi0DecayPhotonHitNoLM       ->Fill(en,nMax);
1022   else           fhMCPi0DecayPhotonHitNoLMOverlap->Fill(en,nMax);
1023
1024 }
1025
1026 //___________________________________________________________________________________________________________________
1027 void AliAnaInsideClusterInvariantMass::FillAngleHistograms(const Int_t nMax, const Bool_t matched,
1028                                                            const Float_t en, const Float_t angle, const Float_t mass)
1029 {
1030   // Fill histograms related to opening angle
1031
1032   if     (nMax==1)
1033   {
1034     fhAnglePairNLocMax1[matched]->Fill(en,angle);
1035     if( en > fHistoECut ) fhAnglePairMassNLocMax1[matched]->Fill(mass,angle);
1036   }
1037   else if(nMax==2)
1038   {
1039     fhAnglePairNLocMax2[matched]->Fill(en,angle);
1040     if( en > fHistoECut ) fhAnglePairMassNLocMax2[matched]->Fill(mass,angle);
1041   }
1042   else if(nMax >2)
1043   {
1044     fhAnglePairNLocMaxN[matched]->Fill(en,angle);
1045     if( en > fHistoECut ) fhAnglePairMassNLocMaxN[matched]->Fill(mass,angle);
1046   }
1047
1048 }
1049
1050 //__________________________________________________________________________________________________________________________________________
1051 void AliAnaInsideClusterInvariantMass::FillEBinHistograms(const Int_t   ebin     , const Int_t   nMax, const Int_t mcindex,
1052                                                           const Float_t splitFrac, const Float_t mass, const Float_t asym, const Float_t l0)
1053 {
1054   // Fill some histograms integrating in few energy bins
1055
1056   if     (nMax==1)
1057   {
1058     fhMassSplitEFractionNLocMax1Ebin[0][ebin]->Fill(splitFrac,  mass);
1059     if(IsDataMC())fhMassSplitEFractionNLocMax1Ebin[mcindex][ebin]->Fill(splitFrac,  mass);
1060
1061     fhMassM02NLocMax1Ebin    [ebin]->Fill(l0  ,  mass );
1062     fhMassAsyNLocMax1Ebin    [ebin]->Fill(asym,  mass );
1063   }
1064   else if(nMax==2)
1065   {
1066     fhMassSplitEFractionNLocMax2Ebin[0][ebin]->Fill(splitFrac,  mass);
1067     if(IsDataMC())fhMassSplitEFractionNLocMax2Ebin[mcindex][ebin]->Fill(splitFrac,  mass);
1068
1069     fhMassM02NLocMax2Ebin    [ebin]->Fill(l0  ,  mass );
1070     fhMassAsyNLocMax2Ebin    [ebin]->Fill(asym,  mass );
1071   }
1072   else if(nMax > 2 )
1073   {
1074     fhMassSplitEFractionNLocMaxNEbin[0][ebin]->Fill(splitFrac,  mass);
1075     if(IsDataMC())fhMassSplitEFractionNLocMaxNEbin[mcindex][ebin]->Fill(splitFrac,  mass);
1076
1077     fhMassM02NLocMaxNEbin    [ebin]->Fill(l0  ,  mass );
1078     fhMassAsyNLocMaxNEbin    [ebin]->Fill(asym,  mass );
1079   }
1080
1081 }
1082
1083 //________________________________________________________________________________________________________________________
1084 void AliAnaInsideClusterInvariantMass::FillHistograms1(const Float_t en,     const Float_t e1,     const Float_t e2,
1085                                                        const Int_t nMax,     const Float_t mass,   const Float_t l0,
1086                                                        const Float_t eta,    const Float_t phi,
1087                                                        const Bool_t matched, const Int_t mcindex)
1088 {
1089   // Fill histograms for clusters before any selection after spliting
1090
1091   Float_t splitFrac = (e1+e2)/en;
1092
1093   Float_t asym = -10;
1094   if(e1+e2>0) asym = (e1-e2)/(e1+e2);
1095
1096   fhNLocMax[0][matched]->Fill(en,nMax);
1097   fhSplitClusterENLocMax[0][matched]->Fill(e1,nMax);
1098   fhSplitClusterENLocMax[0][matched]->Fill(e2,nMax);
1099
1100   if(IsDataMC())
1101   {
1102     fhNLocMax[mcindex][matched]->Fill(en,nMax);
1103     fhSplitClusterENLocMax[0][matched]->Fill(e1,nMax);
1104     fhSplitClusterENLocMax[0][matched]->Fill(e2,nMax);
1105   }
1106
1107   if     ( nMax == 1  )
1108   {
1109     fhM02NLocMax1[0][matched]->Fill(en,l0) ;
1110     fhSplitEFractionNLocMax1[0][matched]->Fill(en,splitFrac) ;
1111
1112     if(IsDataMC())
1113     {
1114       fhM02NLocMax1[mcindex][matched]->Fill(en,l0) ;
1115       fhSplitEFractionNLocMax1[mcindex][matched]->Fill(en,splitFrac) ;
1116     }
1117
1118     if(en > fHistoECut)
1119     {
1120       fhMassM02NLocMax1[0][matched]->Fill(l0, mass);
1121       if( IsDataMC() ) fhMassM02NLocMax1[mcindex][matched]->Fill(l0, mass);
1122
1123       fhSplitEFractionvsAsyNLocMax1[matched]->Fill(asym,splitFrac) ;
1124       if(!matched)fhClusterEtaPhiNLocMax1->Fill(eta,phi);
1125     }
1126   }
1127   else if( nMax == 2  )
1128   {
1129     fhM02NLocMax2[0][matched]->Fill(en,l0) ;
1130     fhSplitEFractionNLocMax2[0][matched]->Fill(en,splitFrac) ;
1131
1132     if(IsDataMC())
1133     {
1134       fhM02NLocMax2[mcindex][matched]->Fill(en,l0) ;
1135       fhSplitEFractionNLocMax2[mcindex][matched]->Fill(en,splitFrac) ;
1136     }
1137
1138     if(en > fHistoECut)
1139     {
1140       fhMassM02NLocMax2[0][matched]->Fill(l0,  mass );
1141       if( IsDataMC() ) fhMassM02NLocMax2[mcindex][matched]->Fill(l0,mass);
1142
1143       fhSplitEFractionvsAsyNLocMax2[matched]->Fill(asym,splitFrac) ;
1144       if(!matched)fhClusterEtaPhiNLocMax2->Fill(eta,phi);
1145     }
1146   }
1147   else if( nMax >= 3  )
1148   {
1149     fhM02NLocMaxN[0][matched]->Fill(en,l0) ;
1150     fhSplitEFractionNLocMaxN[0][matched]->Fill(en,splitFrac) ;
1151
1152     if(IsDataMC())
1153     {
1154       fhM02NLocMaxN[mcindex][matched]->Fill(en,l0) ;
1155       fhSplitEFractionNLocMaxN[mcindex][matched]->Fill(en,splitFrac) ;
1156     }
1157
1158     if(en > fHistoECut)
1159     {
1160
1161       fhMassM02NLocMaxN[0][matched]->Fill(l0,mass);
1162       if( IsDataMC() ) fhMassM02NLocMaxN[mcindex][matched]->Fill(l0,mass);
1163
1164       fhSplitEFractionvsAsyNLocMaxN[matched]->Fill(asym,splitFrac) ;
1165       if(!matched)fhClusterEtaPhiNLocMaxN->Fill(eta,phi);
1166     }
1167   }
1168
1169
1170 }
1171
1172 //________________________________________________________________________________________________________________________
1173 void AliAnaInsideClusterInvariantMass::FillHistograms2(const Float_t en,     const Float_t eprim,
1174                                                        const Float_t e1,     const Float_t e2,
1175                                                        const Int_t nMax,     const Float_t mass,   const Float_t l0,
1176                                                        const Bool_t matched, const Int_t mcindex)
1177 {
1178   // Fill histograms for clusters passing the first M02 selection
1179
1180   Float_t efrac      = eprim/en;
1181   Float_t efracSplit = 0;
1182   if(e1+e2 > 0) efracSplit = eprim/(e1+e2);
1183
1184   Float_t splitFrac = (e1+e2)/en;
1185
1186   Float_t asym = -10;
1187   if(e1+e2>0) asym = (e1-e2)/(e1+e2);
1188
1189   Int_t inlm = nMax-1;
1190   if(inlm > 2) inlm = 2;
1191   Float_t splitFracMin = GetCaloPID()->GetSplitEnergyFractionMinimum(inlm) ;
1192
1193   Bool_t m02OK = GetCaloPID()->IsInPi0M02Range(en,l0,nMax);
1194   Bool_t asyOK = GetCaloPID()->IsInPi0SplitAsymmetryRange(en,asym,nMax);
1195   Bool_t m02On = GetCaloPID()->IsSplitShowerShapeCutOn();
1196   Bool_t asyOn = GetCaloPID()->IsSplitAsymmetryCutOn();
1197
1198   //printf("splitFracMin %f, val %f, m02ok %d, asyok %d\n",splitFracMin,splitFrac,m02OK,asyOK);
1199
1200   if(m02On && m02OK)
1201   {
1202     fhNLocMaxM02Cut[0][matched]->Fill(en,nMax);
1203     if(IsDataMC()) fhNLocMaxM02Cut[mcindex][matched]->Fill(en,nMax);
1204   }
1205
1206   if     (nMax==1)
1207   {
1208     fhMassNLocMax1[0][matched]->Fill(en,mass );
1209     fhAsymNLocMax1[0][matched]->Fill(en,asym );
1210
1211     // Effect of cuts in mass histograms
1212
1213     if(!matched && m02OK && m02On )
1214     {
1215       fhMassM02CutNLocMax1->Fill(en,mass);
1216       fhAsymM02CutNLocMax1->Fill(en,asym );
1217       if(splitFrac > splitFracMin && fhMassSplitECutNLocMax1) fhMassSplitECutNLocMax1->Fill(en,mass );
1218     }
1219
1220     if((m02OK && asyOK) && (asyOn || m02On))
1221     {
1222       fhSplitEFractionAfterCutsNLocMax1[0][matched]->Fill(en,splitFrac);
1223       if(splitFrac > splitFracMin) fhMassAfterCutsNLocMax1[0][matched]->Fill(en,mass);
1224
1225       if(!matched && IsDataMC() && fFillMCHisto && mcindex==kmcPi0)
1226       {
1227         fhMCGenFracAfterCutsNLocMax1MCPi0      ->Fill(en   ,  efrac     );
1228         fhMCGenSplitEFracAfterCutsNLocMax1MCPi0->Fill(en   ,  efracSplit);
1229       }
1230     }
1231   }
1232   else if(nMax==2)
1233   {
1234     fhMassNLocMax2[0][matched]->Fill(en,mass );
1235     fhAsymNLocMax2[0][matched]->Fill(en,asym );
1236
1237     // Effect of cuts in mass histograms
1238
1239     if(!matched && m02OK && m02On )
1240     {
1241       fhMassM02CutNLocMax2->Fill(en,mass);
1242       fhAsymM02CutNLocMax2->Fill(en,asym );
1243       if(splitFrac > splitFracMin && fhMassSplitECutNLocMax2) fhMassSplitECutNLocMax2->Fill(en,mass );
1244     }
1245
1246     if((m02OK && asyOK) && (asyOn || m02On))
1247     {
1248       fhSplitEFractionAfterCutsNLocMax2[0][matched]->Fill(en,splitFrac);
1249       if(splitFrac >splitFracMin) fhMassAfterCutsNLocMax2[0][matched]->Fill(en,mass);
1250
1251       if(!matched && IsDataMC() && fFillMCHisto && mcindex==kmcPi0)
1252       {
1253         fhMCGenFracAfterCutsNLocMax2MCPi0      ->Fill(en   ,  efrac     );
1254         fhMCGenSplitEFracAfterCutsNLocMax2MCPi0->Fill(en   ,  efracSplit);
1255       }
1256     }
1257   }
1258   else if(nMax >2)
1259   {
1260     fhMassNLocMaxN[0][matched]->Fill(en,mass);
1261     fhAsymNLocMaxN[0][matched]->Fill(en,asym);
1262
1263     // Effect of cuts in mass histograms
1264     if(!matched && m02OK && m02On )
1265     {
1266       fhMassM02CutNLocMaxN->Fill(en,mass);
1267       fhAsymM02CutNLocMaxN->Fill(en,asym );
1268       if(splitFrac > splitFracMin && fhMassSplitECutNLocMaxN) fhMassSplitECutNLocMaxN->Fill(en,mass );
1269     }
1270
1271     if((m02OK && asyOK) && (asyOn || m02On))
1272     {
1273       fhSplitEFractionAfterCutsNLocMaxN[0][matched]->Fill(en,splitFrac);
1274       if(splitFrac > splitFracMin) fhMassAfterCutsNLocMaxN[0][matched]->Fill(en,mass);
1275
1276       if(!matched && IsDataMC() && fFillMCHisto && mcindex==kmcPi0)
1277       {
1278         fhMCGenFracAfterCutsNLocMaxNMCPi0      ->Fill(en   ,  efrac     );
1279         fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0->Fill(en   ,  efracSplit);
1280       }
1281     }
1282   }
1283
1284   if(IsDataMC())
1285   {
1286     if     (nMax==1)
1287     {
1288       fhMassNLocMax1[mcindex][matched]->Fill(en,mass);
1289       fhAsymNLocMax1[mcindex][matched]->Fill(en,asym);
1290
1291       if((m02OK && asyOK) && (asyOn || m02On))
1292       {
1293         fhSplitEFractionAfterCutsNLocMax1[mcindex][matched]->Fill(en,splitFrac);
1294         if(splitFrac > splitFracMin)
1295           fhMassAfterCutsNLocMax1[mcindex][matched]->Fill(en,mass);
1296       }
1297     }
1298     else if(nMax==2)
1299     {
1300       fhMassNLocMax2[mcindex][matched]->Fill(en,mass);
1301       fhAsymNLocMax2[mcindex][matched]->Fill(en,asym);
1302
1303       if((m02OK && asyOK) && (asyOn || m02On))
1304       {
1305         fhSplitEFractionAfterCutsNLocMax2[mcindex][matched]->Fill(en,splitFrac);
1306         if(splitFrac >splitFracMin)
1307           fhMassAfterCutsNLocMax2[mcindex][matched]->Fill(en,mass);
1308       }
1309     }
1310     else if(nMax >2)
1311     {
1312       fhMassNLocMaxN[mcindex][matched]->Fill(en,mass);
1313       fhAsymNLocMaxN[mcindex][matched]->Fill(en,asym);
1314
1315       if((m02OK && asyOK) && (asyOn || m02On))
1316       {
1317         fhSplitEFractionAfterCutsNLocMaxN[mcindex][matched]->Fill(en,splitFrac);
1318         if(splitFrac > splitFracMin )
1319           fhMassAfterCutsNLocMaxN[mcindex][matched]->Fill(en,mass);
1320       }
1321     }
1322   }//Work with MC truth
1323 }
1324
1325
1326 //________________________________________________________________________________________________________________________
1327 void AliAnaInsideClusterInvariantMass::FillIdPi0Histograms(const Float_t en,     const Float_t e1,     const Float_t e2,
1328                                                            const Int_t nc,       const Int_t nMax,     const Float_t t12diff,
1329                                                            const Float_t mass,   const Float_t l0,
1330                                                            const Float_t eta,    const Float_t phi,
1331                                                            const Bool_t matched, const Int_t mcindex)
1332 {
1333   // Fill histograms for clusters passing the pi0 selection
1334
1335   Float_t asym = -10;
1336   if(e1+e2>0) asym = (e1-e2)/(e1+e2);
1337
1338   fhSplitClusterEPi0NLocMax[0][matched]->Fill(e1,nMax);
1339   fhSplitClusterEPi0NLocMax[0][matched]->Fill(e2,nMax);
1340
1341   if(IsDataMC())
1342   {
1343     fhSplitClusterEPi0NLocMax[mcindex][matched]->Fill(e1,nMax);
1344     fhSplitClusterEPi0NLocMax[mcindex][matched]->Fill(e2,nMax);
1345   }
1346
1347   if     (nMax==1)
1348   {
1349     fhM02Pi0NLocMax1 [0][matched]->Fill(en,l0);
1350     fhMassPi0NLocMax1[0][matched]->Fill(en,mass);
1351     fhAsyPi0NLocMax1 [0][matched]->Fill(en,asym);
1352     if(fFillNCellHisto) fhNCellPi0NLocMax1[0][matched]->Fill(en,nc);
1353
1354     if(!matched)
1355     {
1356       if(fFillHighMultHisto)
1357       {
1358         fhCentralityPi0NLocMax1->Fill(en,GetEventCentrality()) ;
1359         fhEventPlanePi0NLocMax1->Fill(en,GetEventPlaneAngle()) ;
1360       }
1361       if(en > fHistoECut)fhPi0EtaPhiNLocMax1->Fill(eta,phi);
1362       fhPi0EPairDiffTimeNLM1->Fill(e1+e2,t12diff);
1363     }
1364   }
1365   else if(nMax==2)
1366   {
1367     fhM02Pi0NLocMax2 [0][matched]->Fill(en,l0);
1368     fhMassPi0NLocMax2[0][matched]->Fill(en,mass);
1369     fhAsyPi0NLocMax2 [0][matched]->Fill(en,asym);
1370     if(fFillNCellHisto) fhNCellPi0NLocMax2[0][matched]->Fill(en,nc);
1371
1372     if(!matched)
1373     {
1374       if(fFillHighMultHisto)
1375       {
1376         fhCentralityPi0NLocMax2->Fill(en,GetEventCentrality()) ;
1377         fhEventPlanePi0NLocMax2->Fill(en,GetEventPlaneAngle()) ;
1378       }
1379       if(en > fHistoECut)fhPi0EtaPhiNLocMax2->Fill(eta,phi);
1380       fhPi0EPairDiffTimeNLM2->Fill(e1+e2,t12diff);
1381     }
1382   }
1383   else if(nMax >2)
1384   {
1385     fhM02Pi0NLocMaxN [0][matched]->Fill(en,l0);
1386     fhMassPi0NLocMaxN[0][matched]->Fill(en,mass);
1387     fhAsyPi0NLocMaxN [0][matched]->Fill(en,asym);
1388     if(fFillNCellHisto) fhNCellPi0NLocMaxN[0][matched]->Fill(en,nc);
1389
1390     if(!matched)
1391     {
1392       if(fFillHighMultHisto)
1393       {
1394         fhCentralityPi0NLocMaxN->Fill(en,GetEventCentrality()) ;
1395         fhEventPlanePi0NLocMaxN->Fill(en,GetEventPlaneAngle()) ;
1396       }
1397       if(en > fHistoECut)fhPi0EtaPhiNLocMaxN->Fill(eta,phi);
1398       fhPi0EPairDiffTimeNLMN->Fill(e1+e2,t12diff);
1399     }
1400   }
1401
1402   if(IsDataMC())
1403   {
1404     if     (nMax==1)
1405     {
1406       fhM02Pi0NLocMax1 [mcindex][matched]->Fill(en,l0);
1407       fhMassPi0NLocMax1[mcindex][matched]->Fill(en,mass);
1408       fhAsyPi0NLocMax1 [mcindex][matched]->Fill(en,asym);
1409       if(fFillNCellHisto) fhNCellPi0NLocMax1[mcindex][matched]->Fill(en,nc);
1410
1411     }
1412     else if(nMax==2)
1413     {
1414       fhM02Pi0NLocMax2 [mcindex][matched]->Fill(en,l0);
1415       fhMassPi0NLocMax2[mcindex][matched]->Fill(en,mass);
1416       fhAsyPi0NLocMax2 [mcindex][matched]->Fill(en,asym);
1417       if(fFillNCellHisto) fhNCellPi0NLocMax2[mcindex][matched]->Fill(en,nc);
1418     }
1419     else if(nMax >2)
1420     {
1421       fhM02Pi0NLocMaxN [mcindex][matched]->Fill(en,l0);
1422       fhMassPi0NLocMaxN[mcindex][matched]->Fill(en,mass);
1423       fhAsyPi0NLocMaxN [mcindex][matched]->Fill(en,asym);
1424       if(fFillNCellHisto) fhNCellPi0NLocMaxN[mcindex][matched]->Fill(en,nc);
1425     }
1426   }//Work with MC truth
1427 }
1428
1429 //________________________________________________________________________________________________________________________
1430 void AliAnaInsideClusterInvariantMass::FillIdEtaHistograms(const Float_t en,     const Float_t e1,  const Float_t e2,
1431                                                            const Int_t nc,       const Int_t nMax,  const Float_t t12diff,
1432                                                            const Float_t mass,   const Float_t l0,
1433                                                            const Float_t eta,    const Float_t phi,
1434                                                            const Bool_t matched, const Int_t mcindex)
1435 {
1436   // Fill histograms for clusters passing the eta selection
1437
1438   Float_t asym = -10;
1439   if(e1+e2>0) asym = (e1-e2)/(e1+e2);
1440
1441   if     (nMax==1)
1442   {
1443     fhM02EtaNLocMax1 [0][matched]->Fill(en,l0);
1444     fhMassEtaNLocMax1[0][matched]->Fill(en,mass);
1445     fhAsyEtaNLocMax1 [0][matched]->Fill(en,asym);
1446     if(fFillNCellHisto) fhNCellEtaNLocMax1[0][matched]->Fill(en,nc);
1447
1448     if(!matched)
1449     {
1450       if(fFillHighMultHisto)
1451       {
1452         fhCentralityEtaNLocMax1->Fill(en,GetEventCentrality()) ;
1453         fhEventPlaneEtaNLocMax1->Fill(en,GetEventPlaneAngle()) ;
1454       }
1455       if(en > fHistoECut)fhEtaEtaPhiNLocMax1->Fill(eta,phi);
1456       fhEtaEPairDiffTimeNLM1->Fill(e1+e2,t12diff);
1457     }
1458   }
1459   else if(nMax==2)
1460   {
1461     fhM02EtaNLocMax2 [0][matched]->Fill(en,l0);
1462     fhMassEtaNLocMax2[0][matched]->Fill(en,mass);
1463     fhAsyEtaNLocMax2 [0][matched]->Fill(en,asym);
1464     if(fFillNCellHisto) fhNCellEtaNLocMax2[0][matched]->Fill(en,nc);
1465
1466     if(!matched)
1467     {
1468       if(fFillHighMultHisto)
1469       {
1470         fhCentralityEtaNLocMax2->Fill(en,GetEventCentrality()) ;
1471         fhEventPlaneEtaNLocMax2->Fill(en,GetEventPlaneAngle()) ;
1472       }
1473       if(en > fHistoECut)fhEtaEtaPhiNLocMax2->Fill(eta,phi);
1474       fhEtaEPairDiffTimeNLM2->Fill(e1+e2,t12diff);
1475     }
1476   }
1477   else if(nMax >2)
1478   {
1479     fhM02EtaNLocMaxN [0][matched]->Fill(en,l0);
1480     fhMassEtaNLocMaxN[0][matched]->Fill(en,mass);
1481     fhAsyEtaNLocMaxN [0][matched]->Fill(en,asym);
1482     if(fFillNCellHisto) fhNCellEtaNLocMaxN[0][matched]->Fill(en,nc);
1483
1484     if(!matched)
1485     {
1486       if(fFillHighMultHisto)
1487       {
1488         fhCentralityEtaNLocMaxN->Fill(en,GetEventCentrality()) ;
1489         fhEventPlaneEtaNLocMaxN->Fill(en,GetEventPlaneAngle()) ;
1490       }
1491       if(en > fHistoECut)fhEtaEtaPhiNLocMaxN->Fill(eta,phi);
1492       fhEtaEPairDiffTimeNLMN->Fill(e1+e2,t12diff);
1493     }
1494   }
1495
1496   if(IsDataMC())
1497   {
1498     if     (nMax==1)
1499     {
1500       fhM02EtaNLocMax1[mcindex][matched]->Fill(en,l0);
1501       fhMassEtaNLocMax1[mcindex][matched]->Fill(en,mass);
1502       fhAsyEtaNLocMax1[mcindex][matched]->Fill(en,asym);
1503       if(fFillNCellHisto) fhNCellEtaNLocMax1[mcindex][matched]->Fill(en,nc);
1504     }
1505     else if(nMax==2)
1506     {
1507       fhM02EtaNLocMax2 [mcindex][matched]->Fill(en,l0);
1508       fhMassEtaNLocMax2[mcindex][matched]->Fill(en,mass);
1509       fhAsyEtaNLocMax2 [mcindex][matched]->Fill(en,asym);
1510       if(fFillNCellHisto) fhNCellEtaNLocMax2[mcindex][matched]->Fill(en,nc);
1511
1512     }
1513     else if(nMax >2)
1514     {
1515       fhM02Pi0NLocMaxN[mcindex][matched]->Fill(en,l0);
1516       fhMassPi0NLocMaxN[mcindex][matched]->Fill(en,mass);
1517       fhAsyPi0NLocMaxN[mcindex][matched]->Fill(en,asym);
1518       if(fFillNCellHisto) fhNCellPi0NLocMaxN[mcindex][matched]->Fill(en,nc);
1519     }
1520   }//Work with MC truth
1521 }
1522
1523
1524 //_____________________________________________________________________________________________________________________
1525 void AliAnaInsideClusterInvariantMass::FillIdConvHistograms(const Float_t en,    const Int_t nMax, const Float_t asym,
1526                                                             const Float_t mass,   const Float_t l0,
1527                                                             const Bool_t matched, const Int_t mcindex)
1528 {
1529   // Fill histograms for clusters passing the photon selection
1530
1531   if     (nMax==1)
1532   {
1533     fhM02ConNLocMax1 [0][matched]->Fill(en,l0);
1534     fhMassConNLocMax1[0][matched]->Fill(en,mass);
1535     fhAsyConNLocMax1 [0][matched]->Fill(en,asym);
1536   }
1537   else if(nMax==2)
1538   {
1539     fhM02ConNLocMax2 [0][matched]->Fill(en,l0);
1540     fhMassConNLocMax2[0][matched]->Fill(en,mass);
1541     fhAsyConNLocMax2 [0][matched]->Fill(en,asym);
1542   }
1543   else if(nMax >2)
1544   {
1545     fhM02ConNLocMaxN [0][matched]->Fill(en,l0);
1546     fhMassConNLocMaxN[0][matched]->Fill(en,mass);
1547     fhAsyConNLocMaxN [0][matched]->Fill(en,asym);
1548   }
1549
1550   if(IsDataMC())
1551   {
1552     if     (nMax==1)
1553     {
1554       fhM02ConNLocMax1 [mcindex][matched]->Fill(en,l0);
1555       fhMassConNLocMax1[mcindex][matched]->Fill(en,mass);
1556       fhAsyConNLocMax1 [mcindex][matched]->Fill(en,asym);
1557     }
1558     else if(nMax==2)
1559     {
1560       fhM02ConNLocMax2 [mcindex][matched]->Fill(en,l0);
1561       fhMassConNLocMax2[mcindex][matched]->Fill(en,mass);
1562       fhAsyConNLocMax2 [mcindex][matched]->Fill(en,asym);
1563     }
1564     else if(nMax >2)
1565     {
1566       fhM02ConNLocMaxN [mcindex][matched]->Fill(en,l0);
1567       fhMassConNLocMaxN[mcindex][matched]->Fill(en,mass);
1568       fhAsyConNLocMaxN [mcindex][matched]->Fill(en,asym);
1569     }
1570
1571   }//Work with MC truth
1572 }
1573
1574 //_____________________________________________________________________________________________________________________
1575 void AliAnaInsideClusterInvariantMass::FillMCHistograms(const Float_t en,        const Float_t e1  , const Float_t e2,
1576                                                         const Int_t ebin,        const Int_t mcindex,const Int_t noverlaps,
1577                                                         const Float_t l0,        const Float_t mass,
1578                                                         const Int_t nMax,        const Bool_t  matched,
1579                                                         const Float_t splitFrac, const Float_t asym,
1580                                                         const Float_t eprim,     const Float_t asymGen)
1581 {
1582   // Fill histograms needing some MC input
1583
1584   Float_t efrac      = eprim/en;
1585   Float_t efracSplit = 0;
1586   if(e1+e2 > 0) efracSplit = eprim/(e1+e2);
1587
1588   //printf("e1 %2.2f, e2 %2.2f, eprim %2.2f, ereco %2.2f, esplit/ereco %2.2f, egen/ereco %2.2f, egen/esplit %2.2f\n",
1589   //       e1,e2,eprim,en,splitFrac,efrac,efracSplit);
1590
1591   if(ebin >= 0 && fFillEbinHisto)
1592   {
1593     if( !matched ) fhMCGenFracNLocMaxEbin       [mcindex][ebin]->Fill(efrac,nMax);
1594     else           fhMCGenFracNLocMaxEbinMatched[mcindex][ebin]->Fill(efrac,nMax);
1595   }
1596
1597   if     (nMax==1)
1598   {
1599     fhMCGenFracNLocMax1      [mcindex][matched]->Fill(en     ,  efrac );
1600     fhMCGenSplitEFracNLocMax1[mcindex][matched]->Fill(en     ,  efracSplit );
1601     fhMCGenEvsSplitENLocMax1 [mcindex][matched]->Fill(eprim  ,  e1+e2);
1602
1603     if(noverlaps==0)
1604     {
1605       fhMCGenFracNLocMax1NoOverlap      [mcindex][matched]->Fill(en ,  efrac );
1606       fhMCGenSplitEFracNLocMax1NoOverlap[mcindex][matched]->Fill(en ,  efracSplit );
1607     }
1608
1609     if( en > fHistoECut )
1610     {
1611       fhMCGenEFracvsSplitEFracNLocMax1[mcindex][matched]->Fill(efrac,splitFrac );
1612
1613       if(!matched && ebin >= 0 && fFillEbinHisto)
1614       {
1615         fhM02MCGenFracNLocMax1Ebin [mcindex][ebin]->Fill(efrac  ,  l0    );
1616         fhMassMCGenFracNLocMax1Ebin[mcindex][ebin]->Fill(efrac  ,  mass  );
1617
1618         fhMCAsymM02NLocMax1MCPi0Ebin [ebin]->Fill(l0  ,  asymGen );
1619         fhAsyMCGenRecoNLocMax1EbinPi0[ebin]->Fill(asym,  asymGen );
1620       }
1621     }
1622   }
1623   else if(nMax==2)
1624   {
1625     fhMCGenFracNLocMax2      [mcindex][matched]->Fill(en     ,  efrac );
1626     fhMCGenSplitEFracNLocMax2[mcindex][matched]->Fill(en     ,  efracSplit );
1627     fhMCGenEvsSplitENLocMax2 [mcindex][matched]->Fill(eprim  ,  e1+e2);
1628
1629     if(noverlaps==0)
1630     {
1631       fhMCGenFracNLocMax2NoOverlap      [mcindex][matched]->Fill(en ,  efrac );
1632       fhMCGenSplitEFracNLocMax2NoOverlap[mcindex][matched]->Fill(en ,  efracSplit );
1633     }
1634
1635     if( en > fHistoECut )
1636     {
1637       fhMCGenEFracvsSplitEFracNLocMax2[mcindex][matched]->Fill(efrac,splitFrac );
1638
1639       if(!matched && ebin >= 0 && fFillEbinHisto)
1640       {
1641         fhM02MCGenFracNLocMax2Ebin [mcindex][ebin]->Fill(efrac  ,  l0    );
1642         fhMassMCGenFracNLocMax2Ebin[mcindex][ebin]->Fill(efrac  ,  mass  );
1643
1644         fhMCAsymM02NLocMax2MCPi0Ebin [ebin]->Fill(l0  ,  asymGen );
1645         fhAsyMCGenRecoNLocMax2EbinPi0[ebin]->Fill(asym,  asymGen );
1646       }
1647     }
1648
1649   }
1650   else if(nMax > 2 )
1651   {
1652     fhMCGenFracNLocMaxN      [mcindex][matched]->Fill(en     ,  efrac );
1653     fhMCGenSplitEFracNLocMaxN[mcindex][matched]->Fill(en     ,  efracSplit );
1654     fhMCGenEvsSplitENLocMaxN [mcindex][matched]->Fill(eprim  ,  e1+e2);
1655
1656     if(noverlaps==0)
1657     {
1658       fhMCGenFracNLocMaxNNoOverlap      [mcindex][matched]->Fill(en ,  efrac );
1659       fhMCGenSplitEFracNLocMaxNNoOverlap[mcindex][matched]->Fill(en ,  efracSplit );
1660     }
1661
1662     if( en > fHistoECut )
1663     {
1664       fhMCGenEFracvsSplitEFracNLocMaxN[mcindex][matched]->Fill(efrac,splitFrac );
1665
1666       if(!matched && ebin >= 0 && fFillEbinHisto)
1667       {
1668         fhM02MCGenFracNLocMaxNEbin [mcindex][ebin]->Fill(efrac  ,  l0    );
1669         fhMassMCGenFracNLocMaxNEbin[mcindex][ebin]->Fill(efrac  ,  mass  );
1670
1671         fhMCAsymM02NLocMaxNMCPi0Ebin [ebin]->Fill(l0  ,  asymGen );
1672         fhAsyMCGenRecoNLocMaxNEbinPi0[ebin]->Fill(asym,  asymGen );
1673       }
1674     }
1675   }
1676 }
1677
1678 //__________________________________________________________________________________________________________________________________________________
1679 void AliAnaInsideClusterInvariantMass::FillMCOverlapHistograms(const Float_t en,      const Float_t enprim,
1680                                                                const Int_t   nc,      const Float_t mass,    const Float_t l0,
1681                                                                const Float_t asym,    const Float_t splitFrac,
1682                                                                const Int_t   inlm,    const Int_t ebin, const Bool_t matched,
1683                                                                const Int_t   mcindex, const Int_t noverlaps)
1684 {
1685   // Fill histograms for MC Overlaps
1686
1687   //printf("en %f,mass %f,l0 %f,inlm %d,ebin %d,matched %d,mcindex %d,noverlaps %d \n",en,mass,l0,inlm,ebin,matched,mcindex,noverlaps);
1688
1689   //printf("AliAnaInsideClusterInvariantMass::FillMCOverlapHistograms - NLM bin=%d, mcIndex %d, n Overlaps %d\n",inlm,mcindex,noverlaps);
1690
1691   if(!matched)
1692   {
1693     fhMCENOverlaps[inlm][mcindex]->Fill(en,noverlaps);
1694
1695     if     (noverlaps == 0)
1696     {
1697       fhMCEM02Overlap0  [inlm][mcindex]->Fill(en, l0);
1698       fhMCEMassOverlap0 [inlm][mcindex]->Fill(en, mass);
1699       fhMCEEpriOverlap0 [inlm][mcindex]->Fill(en, enprim);
1700       fhMCEAsymOverlap0 [inlm][mcindex]->Fill(en, TMath::Abs(asym));
1701       fhMCENCellOverlap0[inlm][mcindex]->Fill(en, nc);
1702       fhMCESplitEFracOverlap0[inlm][mcindex]->Fill(en, splitFrac);
1703       if((mcindex==kmcPi0 || mcindex == kmcPi0Conv) && ebin >=0) fhMCPi0MassM02Overlap0[inlm][ebin]->Fill(l0,mass);
1704     }
1705     else if(noverlaps == 1)
1706     {
1707       fhMCEM02Overlap1  [inlm][mcindex]->Fill(en, l0);
1708       fhMCEMassOverlap1 [inlm][mcindex]->Fill(en, mass);
1709       fhMCEEpriOverlap1 [inlm][mcindex]->Fill(en, enprim);
1710       fhMCEAsymOverlap1 [inlm][mcindex]->Fill(en, TMath::Abs(asym));
1711       fhMCENCellOverlap1[inlm][mcindex]->Fill(en, nc);
1712       fhMCESplitEFracOverlap1[inlm][mcindex]->Fill(en, splitFrac);
1713       if((mcindex==kmcPi0 || mcindex == kmcPi0Conv) && ebin >=0) fhMCPi0MassM02Overlap1[inlm][ebin]->Fill(l0,mass);
1714     }
1715     else if(noverlaps  > 1)
1716     {
1717       fhMCEM02OverlapN  [inlm][mcindex]->Fill(en, l0);
1718       fhMCEMassOverlapN [inlm][mcindex]->Fill(en, mass);
1719       fhMCEEpriOverlapN [inlm][mcindex]->Fill(en, enprim);
1720       fhMCEAsymOverlapN [inlm][mcindex]->Fill(en, TMath::Abs(asym));
1721       fhMCENCellOverlapN[inlm][mcindex]->Fill(en, nc);
1722       fhMCESplitEFracOverlapN[inlm][mcindex]->Fill(en, splitFrac);
1723       if((mcindex==kmcPi0 || mcindex == kmcPi0Conv) && ebin >=0) fhMCPi0MassM02OverlapN[inlm][ebin]->Fill(l0,mass);
1724     }
1725     else
1726       printf("AliAnaInsideClusterInvariantMass::FillMCOverlapHistograms() - n overlaps = %d!!", noverlaps);
1727   }
1728   else if(fFillTMHisto)
1729   {
1730     fhMCENOverlapsMatch[inlm][mcindex]->Fill(en,noverlaps);
1731
1732     if     (noverlaps == 0)
1733     {
1734       fhMCEM02Overlap0Match  [inlm][mcindex]->Fill(en, l0);
1735       fhMCEMassOverlap0Match [inlm][mcindex]->Fill(en, mass);
1736       fhMCEEpriOverlap0Match [inlm][mcindex]->Fill(en, enprim);
1737       fhMCEAsymOverlap0Match [inlm][mcindex]->Fill(en, TMath::Abs(asym));
1738       fhMCENCellOverlap0Match[inlm][mcindex]->Fill(en, nc);
1739       fhMCESplitEFracOverlap0Match[inlm][mcindex]->Fill(en, splitFrac);
1740       if((mcindex==kmcPi0 || mcindex == kmcPi0Conv) && ebin >=0) fhMCPi0MassM02Overlap0Match[inlm][ebin]->Fill(l0,mass);
1741     }
1742     else if(noverlaps == 1)
1743     {
1744       fhMCEM02Overlap1Match  [inlm][mcindex]->Fill(en, l0);
1745       fhMCEMassOverlap1Match [inlm][mcindex]->Fill(en, mass);
1746       fhMCEEpriOverlap1Match [inlm][mcindex]->Fill(en, enprim);
1747       fhMCEAsymOverlap1Match [inlm][mcindex]->Fill(en, TMath::Abs(asym));
1748       fhMCENCellOverlap1Match[inlm][mcindex]->Fill(en, nc);
1749       fhMCESplitEFracOverlap1Match[inlm][mcindex]->Fill(en, splitFrac);
1750       if((mcindex==kmcPi0 || mcindex == kmcPi0Conv) && ebin >=0) fhMCPi0MassM02Overlap1Match[inlm][ebin]->Fill(l0,mass);
1751     }
1752     else if(noverlaps  > 1)
1753     {
1754       fhMCEM02OverlapNMatch  [inlm][mcindex]->Fill(en, l0);
1755       fhMCEMassOverlapNMatch [inlm][mcindex]->Fill(en, mass);
1756       fhMCEEpriOverlapNMatch [inlm][mcindex]->Fill(en, enprim);
1757       fhMCEAsymOverlapNMatch [inlm][mcindex]->Fill(en, TMath::Abs(asym));
1758       fhMCENCellOverlapNMatch[inlm][mcindex]->Fill(en, nc);
1759       fhMCESplitEFracOverlapN[inlm][mcindex]->Fill(en, splitFrac);
1760       if((mcindex==kmcPi0 || mcindex == kmcPi0Conv) && ebin >=0) fhMCPi0MassM02OverlapNMatch[inlm][ebin]->Fill(l0,mass);
1761     }
1762     else
1763         printf("AliAnaInsideClusterInvariantMass::FillMCOverlapHistograms() - n overlaps in matched = %d!!", noverlaps);
1764   }
1765 }
1766
1767
1768 //__________________________________________________________________________________________________
1769 void AliAnaInsideClusterInvariantMass::FillNCellHistograms(const Int_t   ncells,  const Float_t energy, const Int_t nMax,
1770                                                            const Bool_t  matched, const Int_t mcindex,
1771                                                            const Float_t mass   , const Float_t l0)
1772
1773 {
1774   // Fill optional histograms with more SS parameters
1775
1776   if     (nMax==1)
1777   {
1778     fhNCellNLocMax1[0][matched]->Fill(energy,ncells) ;
1779     if(mcindex > 0 )  fhNCellNLocMax1[mcindex][matched]->Fill(energy,ncells) ;
1780
1781     if (mcindex==kmcPi0 && !matched)
1782     {
1783       if( energy > fHistoECut)
1784       {
1785         fhNCellMassEHighNLocMax1MCPi0->Fill(ncells,mass);
1786         fhNCellM02EHighNLocMax1MCPi0 ->Fill(ncells,l0);
1787       }
1788       else
1789       {
1790         fhNCellMassELowNLocMax1MCPi0->Fill(ncells,mass);
1791         fhNCellM02ELowNLocMax1MCPi0 ->Fill(ncells,l0);
1792       }
1793     }
1794   }
1795   else if( nMax == 2  )
1796   {
1797     fhNCellNLocMax2[0][matched]->Fill(energy,ncells) ;
1798     if(mcindex > 0 )  fhNCellNLocMax2[mcindex][matched]->Fill(energy,ncells) ;
1799
1800
1801     if (mcindex==kmcPi0 && !matched)
1802     {
1803       if( energy > fHistoECut)
1804       {
1805         fhNCellMassEHighNLocMax2MCPi0->Fill(ncells,mass);
1806         fhNCellM02EHighNLocMax2MCPi0 ->Fill(ncells,l0);
1807       }
1808       else
1809       {
1810         fhNCellMassELowNLocMax2MCPi0->Fill(ncells,mass);
1811         fhNCellM02ELowNLocMax2MCPi0 ->Fill(ncells,l0);
1812       }
1813     }
1814   }
1815   else if( nMax >= 3  )
1816   {
1817     fhNCellNLocMaxN[0][matched]->Fill(energy,ncells) ;
1818     if(mcindex > 0 )  fhNCellNLocMaxN[mcindex][matched]->Fill(energy,ncells) ;
1819
1820     if (mcindex==kmcPi0 && !matched)
1821     {
1822       if( energy > fHistoECut)
1823       {
1824         fhNCellMassEHighNLocMaxNMCPi0->Fill(ncells,mass);
1825         fhNCellM02EHighNLocMaxNMCPi0 ->Fill(ncells,l0);
1826       }
1827       else
1828       {
1829         fhNCellMassELowNLocMaxNMCPi0->Fill(ncells,mass);
1830         fhNCellM02ELowNLocMaxNMCPi0 ->Fill(ncells,l0);
1831       }
1832     }
1833   }
1834 }
1835
1836 //______________________________________________________________________________________________________
1837 void AliAnaInsideClusterInvariantMass::FillSSExtraHistograms(AliVCluster  *cluster, const Int_t nMax,
1838                                                              const Bool_t  matched, const Int_t mcindex,
1839                                                              const Float_t mass   , const Int_t ebin)
1840 {
1841   // Fill optional histograms with more SS parameters
1842
1843   Float_t en = cluster->E();
1844
1845   // Get more Shower Shape parameters
1846   Float_t ll0  = 0., ll1  = 0.;
1847   Float_t disp= 0., dispEta = 0., dispPhi    = 0.;
1848   Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
1849
1850   GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), GetReader()->GetInputEvent()->GetEMCALCells(), cluster,
1851                                                                                ll0, ll1, disp, dispEta, dispPhi, sEta, sPhi, sEtaPhi);
1852
1853   Float_t dispAsy = -1;
1854   if(dispEta+dispPhi >0 ) dispAsy = (dispPhi-dispEta) / (dispPhi+dispEta);
1855
1856   if     (nMax==1)
1857   {
1858     if( en > fHistoECut )
1859     {
1860       fhMassDispEtaNLocMax1[0][matched]->Fill(dispEta,  mass );
1861       fhMassDispPhiNLocMax1[0][matched]->Fill(dispPhi,  mass );
1862       fhMassDispAsyNLocMax1[0][matched]->Fill(dispAsy,  mass );
1863
1864       if(IsDataMC())
1865       {
1866         fhMassDispEtaNLocMax1[mcindex][matched]->Fill(dispEta,  mass );
1867         fhMassDispPhiNLocMax1[mcindex][matched]->Fill(dispPhi,  mass );
1868         fhMassDispAsyNLocMax1[mcindex][matched]->Fill(dispAsy,  mass );
1869       }
1870     }
1871
1872     if(!matched && ebin >= 0 && fFillEbinHisto)
1873     {
1874       fhMassDispEtaNLocMax1Ebin[ebin]->Fill(dispEta,  mass );
1875       fhMassDispPhiNLocMax1Ebin[ebin]->Fill(dispPhi,  mass );
1876       fhMassDispAsyNLocMax1Ebin[ebin]->Fill(dispAsy,  mass );
1877     }
1878   }
1879   else if( nMax == 2  )
1880   {
1881     if( en > fHistoECut )
1882     {
1883       fhMassDispEtaNLocMax2[0][matched]->Fill(dispEta,  mass );
1884       fhMassDispPhiNLocMax2[0][matched]->Fill(dispPhi,  mass );
1885       fhMassDispAsyNLocMax2[0][matched]->Fill(dispAsy,  mass );
1886
1887       if(IsDataMC())
1888       {
1889         fhMassDispEtaNLocMax2[mcindex][matched]->Fill(dispEta,  mass );
1890         fhMassDispPhiNLocMax2[mcindex][matched]->Fill(dispPhi,  mass );
1891         fhMassDispAsyNLocMax2[mcindex][matched]->Fill(dispAsy,  mass );
1892       }
1893     }
1894
1895     if(!matched && ebin >= 0 && fFillEbinHisto)
1896     {
1897       fhMassDispEtaNLocMax2Ebin[ebin]->Fill(dispEta,  mass );
1898       fhMassDispPhiNLocMax2Ebin[ebin]->Fill(dispPhi,  mass );
1899       fhMassDispAsyNLocMax2Ebin[ebin]->Fill(dispAsy,  mass );
1900     }
1901
1902   }
1903   else if( nMax >= 3  )
1904   {
1905     if( en > fHistoECut )
1906     {
1907       fhMassDispEtaNLocMaxN[0][matched]->Fill(dispEta,  mass );
1908       fhMassDispPhiNLocMaxN[0][matched]->Fill(dispPhi,  mass );
1909       fhMassDispAsyNLocMaxN[0][matched]->Fill(dispAsy,  mass );
1910
1911       if(IsDataMC())
1912       {
1913         fhMassDispEtaNLocMaxN[mcindex][matched]->Fill(dispEta,  mass );
1914         fhMassDispPhiNLocMaxN[mcindex][matched]->Fill(dispPhi,  mass );
1915         fhMassDispAsyNLocMaxN[mcindex][matched]->Fill(dispAsy,  mass );
1916       }
1917     }
1918
1919     if(!matched && ebin >= 0 && fFillEbinHisto)
1920     {
1921       fhMassDispEtaNLocMaxNEbin[ebin]->Fill(dispEta,  mass );
1922       fhMassDispPhiNLocMaxNEbin[ebin]->Fill(dispPhi,  mass );
1923       fhMassDispAsyNLocMaxNEbin[ebin]->Fill(dispAsy,  mass );
1924     }
1925
1926   }
1927
1928 }
1929
1930 //__________________________________________________________________________________________________
1931 void AliAnaInsideClusterInvariantMass::FillSSWeightHistograms(AliVCluster *clus,  const Int_t nlm,
1932                                                               const Int_t absId1, const Int_t absId2)
1933 {
1934   // Calculate weights and fill histograms
1935
1936   AliVCaloCells* cells = 0;
1937   if(fCalorimeter == "EMCAL") cells = GetEMCALCells();
1938   else                        cells = GetPHOSCells();
1939
1940   // First recalculate energy in case non linearity was applied
1941   Float_t  energy = 0;
1942   for (Int_t ipos = 0; ipos < clus->GetNCells(); ipos++)
1943   {
1944
1945     Int_t id       = clus->GetCellsAbsId()[ipos];
1946
1947     //Recalibrate cell energy if needed
1948     Float_t amp = cells->GetCellAmplitude(id);
1949     GetCaloUtils()->RecalibrateCellAmplitude(amp,fCalorimeter, id);
1950
1951     energy    += amp;
1952
1953   } // energy loop
1954
1955   if(energy <=0 )
1956   {
1957     printf("AliAnaInsideClusterInvatiantMass::WeightHistograms()- Wrong calculated energy %f\n",energy);
1958     return;
1959   }
1960
1961   //Get amplitude of  main local maxima, recalibrate if needed
1962   Float_t amp1 = cells->GetCellAmplitude(absId1);
1963   GetCaloUtils()->RecalibrateCellAmplitude(amp1,fCalorimeter, absId1);
1964   Float_t amp2 = cells->GetCellAmplitude(absId2);
1965   GetCaloUtils()->RecalibrateCellAmplitude(amp2,fCalorimeter, absId2);
1966
1967   if(amp1 < amp2)        printf("Bad local maxima E ordering : id1 E %f, id2 E %f\n ",amp1,amp2);
1968   if(amp1==0 || amp2==0) printf("Null E local maxima : id1 E %f, id2 E %f\n "        ,amp1,amp2);
1969
1970   if(amp1>0)fhPi0CellEMaxEMax2Frac   [nlm]->Fill(energy,amp2/amp1);
1971   fhPi0CellEMaxClusterFrac [nlm]->Fill(energy,amp1/energy);
1972   fhPi0CellEMax2ClusterFrac[nlm]->Fill(energy,amp2/energy);
1973
1974   //Get the ratio and log ratio to all cells in cluster
1975   for (Int_t ipos = 0; ipos < clus->GetNCells(); ipos++)
1976   {
1977     Int_t id       = clus->GetCellsAbsId()[ipos];
1978
1979     //Recalibrate cell energy if needed
1980     Float_t amp = cells->GetCellAmplitude(id);
1981     GetCaloUtils()->RecalibrateCellAmplitude(amp,fCalorimeter, id);
1982
1983     if(amp > 0)fhPi0CellE       [nlm]->Fill(energy,amp);
1984     fhPi0CellEFrac   [nlm]->Fill(energy,amp/energy);
1985     fhPi0CellLogEFrac[nlm]->Fill(energy,TMath::Log(amp/energy));
1986
1987     if     (id!=absId1 && id!=absId2)
1988     {
1989       if(amp1>0)fhPi0CellEMaxFrac [nlm]->Fill(energy,amp/amp1);
1990       if(amp2>0)fhPi0CellEMax2Frac[nlm]->Fill(energy,amp/amp2);
1991     }
1992
1993   }
1994
1995   //Recalculate shower shape for different W0
1996   if(fCalorimeter=="EMCAL")
1997   {
1998     Float_t l0org = clus->GetM02();
1999     Float_t l1org = clus->GetM20();
2000     Float_t dorg  = clus->GetDispersion();
2001     Float_t w0org =  GetCaloUtils()->GetEMCALRecoUtils()->GetW0();
2002
2003     for(Int_t iw = 0; iw < fSSWeightN; iw++)
2004     {
2005       GetCaloUtils()->GetEMCALRecoUtils()->SetW0(fSSWeight[iw]);
2006       //GetCaloUtils()->GetEMCALRecoUtils()->RecalculateClusterShowerShapeParameters(GetEMCALGeometry(), cells, clus);
2007
2008       Float_t l0   = 0., l1   = 0.;
2009       Float_t disp = 0., dEta = 0., dPhi    = 0.;
2010       Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
2011
2012       RecalculateClusterShowerShapeParametersWithCellCut(GetEMCALGeometry(), cells, clus,l0,l1,disp,
2013                                                          dEta, dPhi, sEta, sPhi, sEtaPhi,0);
2014
2015
2016       fhM02WeightPi0[nlm][iw]->Fill(energy,clus->GetM02());
2017
2018     } // w0 loop
2019
2020     // Set the original values back
2021     clus->SetM02(l0org);
2022     clus->SetM20(l1org);
2023     clus->SetDispersion(dorg);
2024     GetCaloUtils()->GetEMCALRecoUtils()->SetW0(w0org);
2025
2026     for(Int_t iec = 0; iec < fSSECellCutN; iec++)
2027     {
2028       Float_t l0   = 0., l1   = 0.;
2029       Float_t disp = 0., dEta = 0., dPhi    = 0.;
2030       Float_t sEta = 0., sPhi = 0., sEtaPhi = 0.;
2031
2032       RecalculateClusterShowerShapeParametersWithCellCut(GetEMCALGeometry(), cells, clus,l0,l1,disp,
2033                                                          dEta, dPhi, sEta, sPhi, sEtaPhi,fSSECellCut[iec]);
2034
2035       //printf("E %f, l0 org %f, l0 new %f, slope %f\n",clus->E(),l0org,l0,fSSECellCut[iec]);
2036       fhM02ECellCutPi0[nlm][iec]->Fill(energy,l0);
2037
2038     } // w0 loop
2039
2040   }// EMCAL
2041 }
2042
2043 //________________________________________________________________________________________
2044 void  AliAnaInsideClusterInvariantMass::FillTrackMatchingHistograms(AliVCluster * cluster, const Int_t nMax,
2045                                                                     const Int_t mcindex)
2046 {
2047   // Fill histograms related to track matching
2048
2049   Float_t dZ  = cluster->GetTrackDz();
2050   Float_t dR  = cluster->GetTrackDx();
2051   Float_t en  = cluster->E();
2052
2053   if(cluster->IsEMCAL() && GetCaloUtils()->IsRecalculationOfClusterTrackMatchingOn())
2054   {
2055     dR = 2000., dZ = 2000.;
2056     GetCaloUtils()->GetEMCALRecoUtils()->GetMatchedResiduals(cluster->GetID(),dZ,dR);
2057   }
2058
2059   //printf("Pi0EbE: dPhi %f, dEta %f\n",dR,dZ);
2060
2061   if(TMath::Abs(dR) < 999)
2062   {
2063     if     ( nMax == 1  ) { fhTrackMatchedDEtaNLocMax1[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1[0]->Fill(en,dR); }
2064     else if( nMax == 2  ) { fhTrackMatchedDEtaNLocMax2[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2[0]->Fill(en,dR); }
2065     else if( nMax >= 3  ) { fhTrackMatchedDEtaNLocMaxN[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxN[0]->Fill(en,dR); }
2066
2067     if(IsDataMC())
2068     {
2069       if     ( nMax == 1  ) { fhTrackMatchedDEtaNLocMax1[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1[mcindex]->Fill(en,dR); }
2070       else if( nMax == 2  ) { fhTrackMatchedDEtaNLocMax2[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2[mcindex]->Fill(en,dR); }
2071       else if( nMax >= 3  ) { fhTrackMatchedDEtaNLocMaxN[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxN[mcindex]->Fill(en,dR); }
2072     }
2073
2074     AliVTrack *track = GetCaloUtils()->GetMatchedTrack(cluster, GetReader()->GetInputEvent());
2075
2076     Bool_t positive = kFALSE;
2077     if(track) positive = (track->Charge()>0);
2078
2079     if(track)
2080     {
2081       if(positive)
2082       {
2083         if     ( nMax == 1  ) { fhTrackMatchedDEtaNLocMax1Pos[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1Pos[0]->Fill(en,dR); }
2084         else if( nMax == 2  ) { fhTrackMatchedDEtaNLocMax2Pos[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2Pos[0]->Fill(en,dR); }
2085         else if( nMax >= 3  ) { fhTrackMatchedDEtaNLocMaxNPos[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxNPos[0]->Fill(en,dR); }
2086
2087         if(IsDataMC())
2088         {
2089           if     ( nMax == 1  ) { fhTrackMatchedDEtaNLocMax1Pos[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1Pos[mcindex]->Fill(en,dR); }
2090           else if( nMax == 2  ) { fhTrackMatchedDEtaNLocMax2Pos[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2Pos[mcindex]->Fill(en,dR); }
2091           else if( nMax >= 3  ) { fhTrackMatchedDEtaNLocMaxNPos[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxNPos[mcindex]->Fill(en,dR); }
2092         }
2093       }
2094       else
2095       {
2096         if     ( nMax == 1  ) { fhTrackMatchedDEtaNLocMax1Neg[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1Neg[0]->Fill(en,dR); }
2097         else if( nMax == 2  ) { fhTrackMatchedDEtaNLocMax2Neg[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2Neg[0]->Fill(en,dR); }
2098         else if( nMax >= 3  ) { fhTrackMatchedDEtaNLocMaxNNeg[0]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxNNeg[0]->Fill(en,dR); }
2099
2100         if(IsDataMC())
2101         {
2102           if     ( nMax == 1  ) { fhTrackMatchedDEtaNLocMax1Neg[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax1Neg[mcindex]->Fill(en,dR); }
2103           else if( nMax == 2  ) { fhTrackMatchedDEtaNLocMax2Neg[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMax2Neg[mcindex]->Fill(en,dR); }
2104           else if( nMax >= 3  ) { fhTrackMatchedDEtaNLocMaxNNeg[mcindex]->Fill(en,dZ); fhTrackMatchedDPhiNLocMaxNNeg[mcindex]->Fill(en,dR); }
2105         }
2106       }
2107
2108     }// track exists
2109
2110   }
2111 }
2112
2113 //_______________________________________________________________
2114 TObjString *  AliAnaInsideClusterInvariantMass::GetAnalysisCuts()
2115 {
2116         //Save parameters used for analysis
2117   TString parList ; //this will be list of parameters used for this analysis.
2118   const Int_t buffersize = 255;
2119   char onePar[buffersize] ;
2120
2121   snprintf(onePar,buffersize,"--- AliAnaInsideClusterInvariantMass ---\n") ;
2122   parList+=onePar ;
2123
2124   snprintf(onePar,buffersize,"Calorimeter: %s\n",        fCalorimeter.Data()) ;
2125   parList+=onePar ;
2126   snprintf(onePar,buffersize,"fNLocMaxCutE =%2.2f \n",    GetCaloUtils()->GetLocalMaximaCutE()) ;
2127   parList+=onePar ;
2128   snprintf(onePar,buffersize,"fNLocMaxCutEDiff =%2.2f \n",GetCaloUtils()->GetLocalMaximaCutEDiff()) ;
2129   parList+=onePar ;
2130   snprintf(onePar,buffersize,"fMinNCells =%d \n",        fMinNCells) ;
2131   parList+=onePar ;
2132   snprintf(onePar,buffersize,"fMinBadDist =%1.1f \n",    fMinBadDist) ;
2133   parList+=onePar ;
2134   if(fFillSSWeightHisto)
2135   {
2136     snprintf(onePar,buffersize," N w %d - N e cut %d \n",fSSWeightN,fSSECellCutN);
2137     parList+=onePar ;
2138   }
2139
2140   return new TObjString(parList) ;
2141
2142 }
2143
2144 //________________________________________________________________
2145 TList * AliAnaInsideClusterInvariantMass::GetCreateOutputObjects()
2146 {
2147   // Create histograms to be saved in output file and
2148   // store them in outputContainer
2149   TList * outputContainer = new TList() ;
2150   outputContainer->SetName("InsideClusterHistos") ;
2151
2152   Int_t nptbins  = GetHistogramRanges()->GetHistoPtBins();           Float_t ptmax  = GetHistogramRanges()->GetHistoPtMax();           Float_t ptmin  = GetHistogramRanges()->GetHistoPtMin();
2153   Int_t ssbins   = GetHistogramRanges()->GetHistoShowerShapeBins();  Float_t ssmax  = GetHistogramRanges()->GetHistoShowerShapeMax();  Float_t ssmin  = GetHistogramRanges()->GetHistoShowerShapeMin();
2154   Int_t mbins    = GetHistogramRanges()->GetHistoMassBins();         Float_t mmax   = GetHistogramRanges()->GetHistoMassMax();         Float_t mmin   = GetHistogramRanges()->GetHistoMassMin();
2155   Int_t ncbins   = GetHistogramRanges()->GetHistoNClusterCellBins(); Int_t   ncmax  = GetHistogramRanges()->GetHistoNClusterCellMax(); Int_t   ncmin  = GetHistogramRanges()->GetHistoNClusterCellMin();
2156   Int_t nphibins = GetHistogramRanges()->GetHistoPhiBins();          Float_t phimax = GetHistogramRanges()->GetHistoPhiMax();          Float_t phimin = GetHistogramRanges()->GetHistoPhiMin();
2157   Int_t netabins = GetHistogramRanges()->GetHistoEtaBins();          Float_t etamax = GetHistogramRanges()->GetHistoEtaMax();          Float_t etamin = GetHistogramRanges()->GetHistoEtaMin();
2158
2159   Int_t   nresetabins = GetHistogramRanges()->GetHistoTrackResidualEtaBins();
2160   Float_t resetamax   = GetHistogramRanges()->GetHistoTrackResidualEtaMax();
2161   Float_t resetamin   = GetHistogramRanges()->GetHistoTrackResidualEtaMin();
2162   Int_t   nresphibins = GetHistogramRanges()->GetHistoTrackResidualPhiBins();
2163   Float_t resphimax   = GetHistogramRanges()->GetHistoTrackResidualPhiMax();
2164   Float_t resphimin   = GetHistogramRanges()->GetHistoTrackResidualPhiMin();
2165
2166   Bool_t m02On   = GetCaloPID()->IsSplitShowerShapeCutOn();
2167   Bool_t asyOn   = GetCaloPID()->IsSplitAsymmetryCutOn();
2168   Bool_t splitOn = kFALSE;
2169   if(GetCaloPID()->GetSplitEnergyFractionMinimum(0) > 0 ||
2170      GetCaloPID()->GetSplitEnergyFractionMinimum(1) > 0 ||
2171      GetCaloPID()->GetSplitEnergyFractionMinimum(2) > 0) splitOn = kTRUE;
2172
2173   TString ptype[] ={"","#gamma","#gamma->e^{#pm}","#pi^{0}","#eta","e^{#pm}", "hadron","#pi^{0} (#gamma->e^{#pm})"};
2174   TString pname[] ={"","Photon","Conversion",     "Pi0",    "Eta", "Electron","Hadron","Pi0Conv"};
2175
2176   Int_t n = 1;
2177
2178   if(IsDataMC()) n = 8;
2179
2180   Int_t nMaxBins = 10;
2181
2182   TString sMatched[] = {"","Matched"};
2183
2184   Int_t nMatched = 2;
2185   if(!fFillTMHisto) nMatched = 1;
2186
2187   for(Int_t i = 0; i < n; i++)
2188   {
2189     for(Int_t j = 0; j < nMatched; j++)
2190     {
2191
2192       fhMassNLocMax1[i][j]  = new TH2F(Form("hMassNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2193                                        Form("Invariant mass of splitted cluster with NLM=1 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
2194                                        nptbins,ptmin,ptmax,mbins,mmin,mmax);
2195       fhMassNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
2196       fhMassNLocMax1[i][j]->SetXTitle("E (GeV)");
2197       outputContainer->Add(fhMassNLocMax1[i][j]) ;
2198
2199       fhMassNLocMax2[i][j]  = new TH2F(Form("hMassNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2200                                        Form("Invariant mass of splitted cluster with NLM=2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
2201                                        nptbins,ptmin,ptmax,mbins,mmin,mmax);
2202       fhMassNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
2203       fhMassNLocMax2[i][j]->SetXTitle("E (GeV)");
2204       outputContainer->Add(fhMassNLocMax2[i][j]) ;
2205
2206       fhMassNLocMaxN[i][j]  = new TH2F(Form("hMassNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2207                                        Form("Invariant mass of splitted cluster with NLM>2 vs E, %s %s",ptype[i].Data(),sMatched[j].Data()),
2208                                        nptbins,ptmin,ptmax,mbins,mmin,mmax);
2209       fhMassNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
2210       fhMassNLocMaxN[i][j]->SetXTitle("E (GeV)");
2211       outputContainer->Add(fhMassNLocMaxN[i][j]) ;
2212
2213       fhM02NLocMax1[i][j]     = new TH2F(Form("hM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2214                                          Form("#lambda_{0}^{2} vs E for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2215                                          nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2216       fhM02NLocMax1[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2217       fhM02NLocMax1[i][j]   ->SetXTitle("E (GeV)");
2218       outputContainer->Add(fhM02NLocMax1[i][j]) ;
2219
2220       fhM02NLocMax2[i][j]     = new TH2F(Form("hM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2221                                          Form("#lambda_{0}^{2} vs E for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2222                                          nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2223       fhM02NLocMax2[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2224       fhM02NLocMax2[i][j]   ->SetXTitle("E (GeV)");
2225       outputContainer->Add(fhM02NLocMax2[i][j]) ;
2226
2227       fhM02NLocMaxN[i][j]    = new TH2F(Form("hM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2228                                         Form("#lambda_{0}^{2} vs E for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2229                                         nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2230       fhM02NLocMaxN[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2231       fhM02NLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2232       outputContainer->Add(fhM02NLocMaxN[i][j]) ;
2233
2234       fhAsymNLocMax1[i][j]  = new TH2F(Form("hAsymNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2235                                        Form("Asymmetry of NLM=1  vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
2236                                        nptbins,ptmin,ptmax,200,-1,1);
2237       fhAsymNLocMax1[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
2238       fhAsymNLocMax1[i][j]->SetXTitle("E (GeV)");
2239       outputContainer->Add(fhAsymNLocMax1[i][j]) ;
2240
2241       fhAsymNLocMax2[i][j]  = new TH2F(Form("hAsymNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2242                                        Form("Asymmetry of NLM=2  vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
2243                                        nptbins,ptmin,ptmax,200,-1,1);
2244       fhAsymNLocMax2[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
2245       fhAsymNLocMax2[i][j]->SetXTitle("E (GeV)");
2246       outputContainer->Add(fhAsymNLocMax2[i][j]) ;
2247
2248       fhAsymNLocMaxN[i][j]  = new TH2F(Form("hAsymNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2249                                        Form("Asymmetry of NLM>2  vs cluster Energy, %s %s",ptype[i].Data(),sMatched[j].Data()),
2250                                        nptbins,ptmin,ptmax,200,-1,1);
2251       fhAsymNLocMaxN[i][j]->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
2252       fhAsymNLocMaxN[i][j]->SetXTitle("E (GeV)");
2253       outputContainer->Add(fhAsymNLocMaxN[i][j]) ;
2254
2255       fhSplitEFractionNLocMax1[i][j]     = new TH2F(Form("hSplitEFractionNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2256                                                     Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2257                                                     nptbins,ptmin,ptmax,120,0,1.2);
2258       fhSplitEFractionNLocMax1[i][j]   ->SetXTitle("E_{cluster} (GeV)");
2259       fhSplitEFractionNLocMax1[i][j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
2260       outputContainer->Add(fhSplitEFractionNLocMax1[i][j]) ;
2261
2262       fhSplitEFractionNLocMax2[i][j]     = new TH2F(Form("hSplitEFractionNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2263                                                     Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2264                                                     nptbins,ptmin,ptmax,120,0,1.2);
2265       fhSplitEFractionNLocMax2[i][j]   ->SetXTitle("E_{cluster} (GeV)");
2266       fhSplitEFractionNLocMax2[i][j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
2267       outputContainer->Add(fhSplitEFractionNLocMax2[i][j]) ;
2268
2269       fhSplitEFractionNLocMaxN[i][j]    = new TH2F(Form("hSplitEFractionNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2270                                                    Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2271                                                    nptbins,ptmin,ptmax,120,0,1.2);
2272       fhSplitEFractionNLocMaxN[i][j]   ->SetXTitle("E_{cluster} (GeV)");
2273       fhSplitEFractionNLocMaxN[i][j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
2274       outputContainer->Add(fhSplitEFractionNLocMaxN[i][j]) ;
2275
2276
2277       if(i==0 && j==0 && m02On)
2278       {
2279         if(splitOn)
2280         {
2281           fhMassSplitECutNLocMax1  = new TH2F("hMassSplitECutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, (E1+E2)/E cut, M02 cut, no TM",
2282                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2283           fhMassSplitECutNLocMax1->SetYTitle("M (GeV/c^{2})");
2284           fhMassSplitECutNLocMax1->SetXTitle("E (GeV)");
2285           outputContainer->Add(fhMassSplitECutNLocMax1) ;
2286
2287           fhMassSplitECutNLocMax2  = new TH2F("hMassSplitECutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, (E1+E2)/E cut, M02 cut, no TM",
2288                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2289           fhMassSplitECutNLocMax2->SetYTitle("M (GeV/c^{2})");
2290           fhMassSplitECutNLocMax2->SetXTitle("E (GeV)");
2291           outputContainer->Add(fhMassSplitECutNLocMax2) ;
2292
2293           fhMassSplitECutNLocMaxN  = new TH2F("hMassSplitECutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, (E1+E2)/E cut, M02 cut, no TM",
2294                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2295           fhMassSplitECutNLocMaxN->SetYTitle("M (GeV/c^{2})");
2296           fhMassSplitECutNLocMaxN->SetXTitle("E (GeV)");
2297           outputContainer->Add(fhMassSplitECutNLocMaxN) ;
2298         }
2299
2300         fhMassM02CutNLocMax1  = new TH2F("hMassM02CutNLocMax1","Invariant mass of splitted cluster with NLM=1 vs E, M02 cut, no TM",
2301                                          nptbins,ptmin,ptmax,mbins,mmin,mmax);
2302         fhMassM02CutNLocMax1->SetYTitle("M (GeV/c^{2})");
2303         fhMassM02CutNLocMax1->SetXTitle("E (GeV)");
2304         outputContainer->Add(fhMassM02CutNLocMax1) ;
2305
2306         fhMassM02CutNLocMax2  = new TH2F("hMassM02CutNLocMax2","Invariant mass of splitted cluster with NLM=2 vs E, M02 cut, no TM",
2307                                          nptbins,ptmin,ptmax,mbins,mmin,mmax);
2308         fhMassM02CutNLocMax2->SetYTitle("M (GeV/c^{2})");
2309         fhMassM02CutNLocMax2->SetXTitle("E (GeV)");
2310         outputContainer->Add(fhMassM02CutNLocMax2) ;
2311
2312         fhMassM02CutNLocMaxN  = new TH2F("hMassM02CutNLocMaxN","Invariant mass of splitted cluster with NLM>2 vs E, M02 cut, no TM",
2313                                          nptbins,ptmin,ptmax,mbins,mmin,mmax);
2314         fhMassM02CutNLocMaxN->SetYTitle("M (GeV/c^{2})");
2315         fhMassM02CutNLocMaxN->SetXTitle("E (GeV)");
2316         outputContainer->Add(fhMassM02CutNLocMaxN) ;
2317
2318         fhAsymM02CutNLocMax1  = new TH2F("hAsymM02CutNLocMax1","Asymmetry of NLM=1  vs cluster Energy, M02Cut, no TM", nptbins,ptmin,ptmax,200,-1,1);
2319         fhAsymM02CutNLocMax1->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
2320         fhAsymM02CutNLocMax1->SetXTitle("E (GeV)");
2321         outputContainer->Add(fhAsymM02CutNLocMax1) ;
2322
2323         fhAsymM02CutNLocMax2  = new TH2F("hAsymM02CutNLocMax2","Asymmetry of NLM=2  vs cluster Energy, M02Cut, no TM", nptbins,ptmin,ptmax,200,-1,1);
2324         fhAsymM02CutNLocMax2->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
2325         fhAsymM02CutNLocMax2->SetXTitle("E (GeV)");
2326         outputContainer->Add(fhAsymM02CutNLocMax2) ;
2327
2328         fhAsymM02CutNLocMaxN  = new TH2F("hAsymM02CutNLocMaxN","Asymmetry of NLM>2  vs cluster Energy, M02Cut, no TM", nptbins,ptmin,ptmax,200,-1,1);
2329         fhAsymM02CutNLocMaxN->SetYTitle("(E_{1}-E_{2})/(E_{1}+E_{2})");
2330         fhAsymM02CutNLocMaxN->SetXTitle("E (GeV)");
2331         outputContainer->Add(fhAsymM02CutNLocMaxN) ;
2332       }
2333
2334       if(asyOn || m02On)
2335       {
2336         fhMassAfterCutsNLocMax1[i][j]     = new TH2F(Form("hMassAfterCutsNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2337                                                      Form("Mass vs E, %s %s, for NLM = 1, M02 and asy cut",ptype[i].Data(),sMatched[j].Data()),
2338                                                      nptbins,ptmin,ptmax,mbins,mmin,mmax);
2339         fhMassAfterCutsNLocMax1[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2340         fhMassAfterCutsNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2341         outputContainer->Add(fhMassAfterCutsNLocMax1[i][j]) ;
2342
2343         fhMassAfterCutsNLocMax2[i][j]     = new TH2F(Form("hMassAfterCutsNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2344                                                      Form("Mass vs E, %s %s, for NLM = 2, M02 and asy cut",ptype[i].Data(),sMatched[j].Data()),
2345                                                      nptbins,ptmin,ptmax,mbins,mmin,mmax);
2346         fhMassAfterCutsNLocMax2[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2347         fhMassAfterCutsNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2348         outputContainer->Add(fhMassAfterCutsNLocMax2[i][j]) ;
2349
2350
2351         fhMassAfterCutsNLocMaxN[i][j]     = new TH2F(Form("hMassAfterCutsNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2352                                                      Form("Mass vs E, %s %s, for NLM > 2, M02 and asy cut",ptype[i].Data(),sMatched[j].Data()),
2353                                                      nptbins,ptmin,ptmax,mbins,mmin,mmax);
2354         fhMassAfterCutsNLocMaxN[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2355         fhMassAfterCutsNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2356         outputContainer->Add(fhMassAfterCutsNLocMaxN[i][j]) ;
2357
2358         fhSplitEFractionAfterCutsNLocMax1[i][j]     = new TH2F(Form("hSplitEFractionAfterCutsNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2359                                                                Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max  = 1, M02 and Asy cut on, %s %s",ptype[i].Data(),sMatched[j].Data()),
2360                                                                nptbins,ptmin,ptmax,120,0,1.2);
2361         fhSplitEFractionAfterCutsNLocMax1[i][j]   ->SetXTitle("E_{cluster} (GeV)");
2362         fhSplitEFractionAfterCutsNLocMax1[i][j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
2363         outputContainer->Add(fhSplitEFractionAfterCutsNLocMax1[i][j]) ;
2364
2365         fhSplitEFractionAfterCutsNLocMax2[i][j]     = new TH2F(Form("hSplitEFractionAfterCutsNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2366                                                                Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max  = 2, M02 and Asy cut on, %s %s",ptype[i].Data(),sMatched[j].Data()),
2367                                                                nptbins,ptmin,ptmax,120,0,1.2);
2368         fhSplitEFractionAfterCutsNLocMax2[i][j]   ->SetXTitle("E_{cluster} (GeV)");
2369         fhSplitEFractionAfterCutsNLocMax2[i][j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
2370         outputContainer->Add(fhSplitEFractionAfterCutsNLocMax2[i][j]) ;
2371
2372         fhSplitEFractionAfterCutsNLocMaxN[i][j]    = new TH2F(Form("hSplitEFractionAfterCutsNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2373                                                               Form("(E1+E2)/E_{cluster} vs E_{cluster} for N max  > 2, M02 and Asy cut on, %s %s",ptype[i].Data(),sMatched[j].Data()),
2374                                                               nptbins,ptmin,ptmax,120,0,1.2);
2375         fhSplitEFractionAfterCutsNLocMaxN[i][j]   ->SetXTitle("E_{cluster} (GeV)");
2376         fhSplitEFractionAfterCutsNLocMaxN[i][j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
2377         outputContainer->Add(fhSplitEFractionAfterCutsNLocMaxN[i][j]) ;
2378       }
2379
2380       fhMassM02NLocMax1[i][j]  = new TH2F(Form("hMassM02NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2381                                           Form("Invariant mass of splitted cluster with NLM=1, #lambda_{0}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
2382                                           ssbins,ssmin,ssmax,mbins,mmin,mmax);
2383       fhMassM02NLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
2384       fhMassM02NLocMax1[i][j]->SetXTitle("#lambda_{0}^{2}");
2385       outputContainer->Add(fhMassM02NLocMax1[i][j]) ;
2386
2387       fhMassM02NLocMax2[i][j]  = new TH2F(Form("hMassM02NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2388                                           Form("Invariant mass of splitted cluster with NLM=2, #lambda_{0}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
2389                                           ssbins,ssmin,ssmax,mbins,mmin,mmax);
2390       fhMassM02NLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
2391       fhMassM02NLocMax2[i][j]->SetXTitle("#lambda_{0}^{2}");
2392       outputContainer->Add(fhMassM02NLocMax2[i][j]) ;
2393
2394       fhMassM02NLocMaxN[i][j]  = new TH2F(Form("hMassM02NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2395                                           Form("Invariant mass of splitted cluster with NLM>2, vs #lambda_{0}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
2396                                           ssbins,ssmin,ssmax,mbins,mmin,mmax);
2397       fhMassM02NLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
2398       fhMassM02NLocMaxN[i][j]->SetXTitle("#lambda_{0}^{2}");
2399       outputContainer->Add(fhMassM02NLocMaxN[i][j]) ;
2400
2401       if(fFillSSExtraHisto)
2402       {
2403         fhMassDispEtaNLocMax1[i][j]  = new TH2F(Form("hMassDispEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2404                                                 Form("Invariant mass of splitted cluster with NLM=1, #sigma_{#eta #eta}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
2405                                                 ssbins,ssmin,ssmax,mbins,mmin,mmax);
2406         fhMassDispEtaNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
2407         fhMassDispEtaNLocMax1[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
2408         outputContainer->Add(fhMassDispEtaNLocMax1[i][j]) ;
2409
2410         fhMassDispEtaNLocMax2[i][j]  = new TH2F(Form("hMassDispEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2411                                                 Form("Invariant mass of splitted cluster with NLM=2 #sigma_{#eta #eta}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
2412                                                 ssbins,ssmin,ssmax,mbins,mmin,mmax);
2413         fhMassDispEtaNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
2414         fhMassDispEtaNLocMax2[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
2415         outputContainer->Add(fhMassDispEtaNLocMax2[i][j]) ;
2416
2417         fhMassDispEtaNLocMaxN[i][j]  = new TH2F(Form("hMassDispEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2418                                                 Form("Invariant mass of splitted cluster with NLM>2, #sigma_{#eta #eta}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
2419                                                 ssbins,ssmin,ssmax,mbins,mmin,mmax);
2420         fhMassDispEtaNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
2421         fhMassDispEtaNLocMaxN[i][j]->SetXTitle("#sigma_{#eta #eta}^{2}");
2422         outputContainer->Add(fhMassDispEtaNLocMaxN[i][j]) ;
2423
2424         fhMassDispPhiNLocMax1[i][j]  = new TH2F(Form("hMassDispPhiNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2425                                                 Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
2426                                                 ssbins,ssmin,ssmax,mbins,mmin,mmax);
2427         fhMassDispPhiNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
2428         fhMassDispPhiNLocMax1[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
2429         outputContainer->Add(fhMassDispPhiNLocMax1[i][j]) ;
2430
2431         fhMassDispPhiNLocMax2[i][j]  = new TH2F(Form("hMassDispPhiNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2432                                                 Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
2433                                                 ssbins,ssmin,ssmax,mbins,mmin,mmax);
2434         fhMassDispPhiNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
2435         fhMassDispPhiNLocMax2[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
2436         outputContainer->Add(fhMassDispPhiNLocMax2[i][j]) ;
2437
2438         fhMassDispPhiNLocMaxN[i][j]  = new TH2F(Form("hMassDispPhiNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2439                                                 Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, %s %s",ptype[i].Data(),sMatched[j].Data()),
2440                                                 ssbins,ssmin,ssmax,mbins,mmin,mmax);
2441         fhMassDispPhiNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
2442         fhMassDispPhiNLocMaxN[i][j]->SetXTitle("#sigma_{#phi #phi}^{2}");
2443         outputContainer->Add(fhMassDispPhiNLocMaxN[i][j]) ;
2444
2445         fhMassDispAsyNLocMax1[i][j]  = new TH2F(Form("hMassDispAsyNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2446                                                 Form("Invariant mass of 2 highest energy cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E > 12 GeV,%s %s",ptype[i].Data(),sMatched[j].Data()),
2447                                                 200,-1,1,mbins,mmin,mmax);
2448         fhMassDispAsyNLocMax1[i][j]->SetYTitle("M (GeV/c^{2})");
2449         fhMassDispAsyNLocMax1[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
2450         outputContainer->Add(fhMassDispAsyNLocMax1[i][j]) ;
2451
2452         fhMassDispAsyNLocMax2[i][j]  = new TH2F(Form("hMassDispAsyNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2453                                                 Form("Invariant mass of 2 local maxima cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E > 12 GeV, %s %s",ptype[i].Data(),sMatched[j].Data()),
2454                                                 200,-1,1,mbins,mmin,mmax);
2455         fhMassDispAsyNLocMax2[i][j]->SetYTitle("M (GeV/c^{2})");
2456         fhMassDispAsyNLocMax2[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
2457         outputContainer->Add(fhMassDispAsyNLocMax2[i][j]) ;
2458
2459         fhMassDispAsyNLocMaxN[i][j]  = new TH2F(Form("hMassDispAsyNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2460                                                 Form("Invariant mass of N>2 local maxima cells vsA = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), %s %s",ptype[i].Data(),sMatched[j].Data()),
2461                                                 200,-1,1,mbins,mmin,mmax);
2462         fhMassDispAsyNLocMaxN[i][j]->SetYTitle("M (GeV/c^{2})");
2463         fhMassDispAsyNLocMaxN[i][j]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
2464         outputContainer->Add(fhMassDispAsyNLocMaxN[i][j]) ;
2465       }
2466
2467       fhNLocMax[i][j]     = new TH2F(Form("hNLocMax%s%s",pname[i].Data(),sMatched[j].Data()),
2468                                      Form("Number of local maxima in cluster %s %s",ptype[i].Data(),sMatched[j].Data()),
2469                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
2470       fhNLocMax[i][j]   ->SetYTitle("N maxima");
2471       fhNLocMax[i][j]   ->SetXTitle("E (GeV)");
2472       outputContainer->Add(fhNLocMax[i][j]) ;
2473
2474       fhSplitClusterENLocMax[i][j]     = new TH2F(Form("hSplitEClusterNLocMax%s%s",pname[i].Data(),sMatched[j].Data()),
2475                                      Form("Number of local maxima vs E of split clusters %s %s",ptype[i].Data(),sMatched[j].Data()),
2476                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
2477       fhSplitClusterENLocMax[i][j]   ->SetYTitle("N maxima");
2478       fhSplitClusterENLocMax[i][j]   ->SetXTitle("E (GeV)");
2479       outputContainer->Add(fhSplitClusterENLocMax[i][j]) ;
2480
2481
2482       fhSplitClusterEPi0NLocMax[i][j]     = new TH2F(Form("hSplitEClusterPi0NLocMax%s%s",pname[i].Data(),sMatched[j].Data()),
2483                                                   Form("Number of local maxima vs E of split clusters, id as pi0, %s %s",ptype[i].Data(),sMatched[j].Data()),
2484                                                   nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
2485       fhSplitClusterEPi0NLocMax[i][j]   ->SetYTitle("N maxima");
2486       fhSplitClusterEPi0NLocMax[i][j]   ->SetXTitle("E (GeV)");
2487       outputContainer->Add(fhSplitClusterEPi0NLocMax[i][j]) ;
2488
2489
2490       if(m02On)
2491       {
2492         fhNLocMaxM02Cut[i][j] = new TH2F(Form("hNLocMaxM02Cut%s%s",pname[i].Data(),sMatched[j].Data()),
2493                                          Form("Number of local maxima in cluster %s, M02 cut",ptype[i].Data()),
2494                                          nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
2495         fhNLocMaxM02Cut[i][j]->SetYTitle("N maxima");
2496         fhNLocMaxM02Cut[i][j]->SetXTitle("E (GeV)");
2497         outputContainer->Add(fhNLocMaxM02Cut[i][j]) ;
2498       }
2499
2500       if(i > 0 && fFillMCHisto) // skip first entry in array, general case not filled
2501       {
2502         fhMCGenFracNLocMax1[i][j]     = new TH2F(Form("hMCGenFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2503                                                  Form("#lambda_{0}^{2} vs E for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2504                                                  nptbins,ptmin,ptmax,200,0,2);
2505         fhMCGenFracNLocMax1[i][j]   ->SetYTitle("E_{gen} / E_{reco}");
2506         fhMCGenFracNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2507         outputContainer->Add(fhMCGenFracNLocMax1[i][j]) ;
2508
2509         fhMCGenFracNLocMax2[i][j]     = new TH2F(Form("hMCGenFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2510                                                  Form("#lambda_{0}^{2} vs E for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2511                                                  nptbins,ptmin,ptmax,200,0,2);
2512         fhMCGenFracNLocMax2[i][j]   ->SetYTitle("E_{gen} / E_{reco}");
2513         fhMCGenFracNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2514         outputContainer->Add(fhMCGenFracNLocMax2[i][j]) ;
2515
2516         fhMCGenFracNLocMaxN[i][j]    = new TH2F(Form("hMCGenFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2517                                                 Form("#lambda_{0}^{2} vs E for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2518                                                 nptbins,ptmin,ptmax,200,0,2);
2519         fhMCGenFracNLocMaxN[i][j]   ->SetYTitle("E_{gen} / E_{reco}");
2520         fhMCGenFracNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2521         outputContainer->Add(fhMCGenFracNLocMaxN[i][j]) ;
2522
2523         fhMCGenFracNLocMax1NoOverlap[i][j]     = new TH2F(Form("hMCGenFracNoOverlapNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2524                                                           Form("#lambda_{0}^{2} vs E for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2525                                                           nptbins,ptmin,ptmax,200,0,2);
2526         fhMCGenFracNLocMax1NoOverlap[i][j]   ->SetYTitle("E_{gen} / E_{reco}");
2527         fhMCGenFracNLocMax1NoOverlap[i][j]   ->SetXTitle("E (GeV)");
2528         outputContainer->Add(fhMCGenFracNLocMax1NoOverlap[i][j]) ;
2529
2530         fhMCGenFracNLocMax2NoOverlap[i][j]     = new TH2F(Form("hMCGenFracNoOverlapNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2531                                                           Form("#lambda_{0}^{2} vs E for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2532                                                           nptbins,ptmin,ptmax,200,0,2);
2533         fhMCGenFracNLocMax2NoOverlap[i][j]   ->SetYTitle("E_{gen} / E_{reco}");
2534         fhMCGenFracNLocMax2NoOverlap[i][j]   ->SetXTitle("E (GeV)");
2535         outputContainer->Add(fhMCGenFracNLocMax2NoOverlap[i][j]) ;
2536
2537         fhMCGenFracNLocMaxNNoOverlap[i][j]    = new TH2F(Form("hMCGenFracNoOverlapNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2538                                                          Form("#lambda_{0}^{2} vs E for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2539                                                          nptbins,ptmin,ptmax,200,0,2);
2540         fhMCGenFracNLocMaxNNoOverlap[i][j]   ->SetYTitle("E_{gen} / E_{reco}");
2541         fhMCGenFracNLocMaxNNoOverlap[i][j]   ->SetXTitle("E (GeV)");
2542         outputContainer->Add(fhMCGenFracNLocMaxNNoOverlap[i][j]) ;
2543
2544
2545         fhMCGenSplitEFracNLocMax1[i][j]     = new TH2F(Form("hMCGenSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2546                                                        Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2547                                                        nptbins,ptmin,ptmax,200,0,2);
2548         fhMCGenSplitEFracNLocMax1[i][j]   ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
2549         fhMCGenSplitEFracNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2550         outputContainer->Add(fhMCGenSplitEFracNLocMax1[i][j]) ;
2551
2552         fhMCGenSplitEFracNLocMax2[i][j]     = new TH2F(Form("hMCGenSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2553                                                        Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2554                                                        nptbins,ptmin,ptmax,200,0,2);
2555         fhMCGenSplitEFracNLocMax2[i][j]   ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
2556         fhMCGenSplitEFracNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2557         outputContainer->Add(fhMCGenSplitEFracNLocMax2[i][j]) ;
2558
2559         fhMCGenSplitEFracNLocMaxN[i][j]    = new TH2F(Form("hMCGenSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2560                                                       Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2561                                                       nptbins,ptmin,ptmax,200,0,2);
2562         fhMCGenSplitEFracNLocMaxN[i][j]   ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
2563         fhMCGenSplitEFracNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2564         outputContainer->Add(fhMCGenSplitEFracNLocMaxN[i][j]) ;
2565
2566         fhMCGenSplitEFracNLocMax1NoOverlap[i][j]     = new TH2F(Form("hMCGenSplitEFracNoOverlapNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2567                                                                 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2568                                                                 nptbins,ptmin,ptmax,200,0,2);
2569         fhMCGenSplitEFracNLocMax1NoOverlap[i][j]   ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
2570         fhMCGenSplitEFracNLocMax1NoOverlap[i][j]   ->SetXTitle("E (GeV)");
2571         outputContainer->Add(fhMCGenSplitEFracNLocMax1NoOverlap[i][j]) ;
2572
2573         fhMCGenSplitEFracNLocMax2NoOverlap[i][j]     = new TH2F(Form("hMCGenSplitEFracNoOverlapNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2574                                                                 Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2575                                                                 nptbins,ptmin,ptmax,200,0,2);
2576         fhMCGenSplitEFracNLocMax2NoOverlap[i][j]   ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
2577         fhMCGenSplitEFracNLocMax2NoOverlap[i][j]   ->SetXTitle("E (GeV)");
2578         outputContainer->Add(fhMCGenSplitEFracNLocMax2NoOverlap[i][j]) ;
2579
2580         fhMCGenSplitEFracNLocMaxNNoOverlap[i][j]    = new TH2F(Form("hMCGenSplitEFracNoOverlapNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2581                                                                Form("E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2582                                                                nptbins,ptmin,ptmax,200,0,2);
2583         fhMCGenSplitEFracNLocMaxNNoOverlap[i][j]   ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
2584         fhMCGenSplitEFracNLocMaxNNoOverlap[i][j]   ->SetXTitle("E (GeV)");
2585         outputContainer->Add(fhMCGenSplitEFracNLocMaxNNoOverlap[i][j]) ;
2586
2587         fhMCGenEFracvsSplitEFracNLocMax1[i][j]     = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2588                                                               Form("(E_{1 split}+E_{2 split})/E_{reco} vs E_{gen} / E_{reco} for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2589                                                               200,0,2,200,0,2);
2590         fhMCGenEFracvsSplitEFracNLocMax1[i][j]   ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
2591         fhMCGenEFracvsSplitEFracNLocMax1[i][j]   ->SetXTitle("E_{gen} / E_{reco}");
2592         outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMax1[i][j]) ;
2593
2594         fhMCGenEFracvsSplitEFracNLocMax2[i][j]     = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2595                                                               Form("(E_{1 split}+E_{2 split})/E_{reco} vs E_{gen} / E_{reco} for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2596                                                               200,0,2,200,0,2);
2597         fhMCGenEFracvsSplitEFracNLocMax2[i][j]   ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
2598         fhMCGenEFracvsSplitEFracNLocMax2[i][j]   ->SetXTitle("E_{gen} / E_{reco}");
2599         outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMax2[i][j]) ;
2600
2601
2602         fhMCGenEFracvsSplitEFracNLocMaxN[i][j]    = new TH2F(Form("hMCGenEFracvsSplitEFracNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2603                                                              Form("(E_{1 split}+E_{2 split})/E_{reco} vs E_{gen} / E_{reco} for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2604                                                              200,0,2,200,0,2);
2605         fhMCGenEFracvsSplitEFracNLocMaxN[i][j]   ->SetYTitle("(E_{1 split}+E_{2 split})/E_{reco}");
2606         fhMCGenEFracvsSplitEFracNLocMaxN[i][j]   ->SetXTitle("E_{gen} / E_{reco}");
2607         outputContainer->Add(fhMCGenEFracvsSplitEFracNLocMaxN[i][j]) ;
2608
2609
2610         fhMCGenEvsSplitENLocMax1[i][j]     = new TH2F(Form("hMCGenEvsSplitENLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2611                                                       Form("E_{1 split}+E_{2 split} vs E_{gen} for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2612                                                       nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2613         fhMCGenEvsSplitENLocMax1[i][j]   ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
2614         fhMCGenEvsSplitENLocMax1[i][j]   ->SetXTitle("E_{gen} (GeV)");
2615         outputContainer->Add(fhMCGenEvsSplitENLocMax1[i][j]) ;
2616
2617         fhMCGenEvsSplitENLocMax2[i][j]     = new TH2F(Form("hMCGenEvsSplitENLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2618                                                       Form("E_{1 split}+E_{2 split} vs E_{gen} for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2619                                                       nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2620         fhMCGenEvsSplitENLocMax2[i][j]   ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
2621         fhMCGenEvsSplitENLocMax2[i][j]   ->SetXTitle("E_{gen} (GeV)");
2622         outputContainer->Add(fhMCGenEvsSplitENLocMax2[i][j]) ;
2623
2624
2625         fhMCGenEvsSplitENLocMaxN[i][j]    = new TH2F(Form("hMCGenEvsSplitENLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2626                                                      Form("E_{1 split}+E_{2 split} vs E_{gen} for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2627                                                      nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
2628         fhMCGenEvsSplitENLocMaxN[i][j]   ->SetYTitle("E_{1 split}+E_{2 split} (GeV)");
2629         fhMCGenEvsSplitENLocMaxN[i][j]   ->SetXTitle("E_{gen} (GeV)");
2630         outputContainer->Add(fhMCGenEvsSplitENLocMaxN[i][j]) ;
2631
2632       }
2633
2634       if(fFillNCellHisto)
2635       {
2636         fhNCellNLocMax1[i][j]  = new TH2F(Form("hNCellNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2637                                           Form("n cells vs E for N max  = 1 %s %s",ptype[i].Data(),sMatched[j].Data()),
2638                                           nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2639         fhNCellNLocMax1[i][j] ->SetYTitle("N cells");
2640         fhNCellNLocMax1[i][j] ->SetXTitle("E (GeV)");
2641         outputContainer->Add(fhNCellNLocMax1[i][j]) ;
2642
2643         fhNCellNLocMax2[i][j]     = new TH2F(Form("hNCellNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2644                                              Form("n cells vs E for N max  = 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2645                                              nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2646         fhNCellNLocMax2[i][j]   ->SetYTitle("N cells");
2647         fhNCellNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2648         outputContainer->Add(fhNCellNLocMax2[i][j]) ;
2649
2650
2651         fhNCellNLocMaxN[i][j]     = new TH2F(Form("hNCellNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2652                                              Form("n cells vs E for N max  > 2 %s %s",ptype[i].Data(),sMatched[j].Data()),
2653                                              nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2654         fhNCellNLocMaxN[i][j]   ->SetYTitle("N cells");
2655         fhNCellNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2656         outputContainer->Add(fhNCellNLocMaxN[i][j]) ;
2657       }
2658
2659       // Histograms after cluster identification
2660
2661
2662       // Pi0 //
2663
2664       fhM02Pi0NLocMax1[i][j]     = new TH2F(Form("hM02Pi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2665                                             Form("#lambda_{0}^{2} vs E, %s, for NLM = 1",ptype[i].Data()),
2666                                             nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2667       fhM02Pi0NLocMax1[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2668       fhM02Pi0NLocMax1[i][j]   ->SetXTitle("E (GeV)");
2669       outputContainer->Add(fhM02Pi0NLocMax1[i][j]) ;
2670
2671       fhM02Pi0NLocMax2[i][j]     = new TH2F(Form("hM02Pi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2672                                             Form("#lambda_{0}^{2} vs E, %s, for NLM = 2",ptype[i].Data()),
2673                                             nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2674       fhM02Pi0NLocMax2[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2675       fhM02Pi0NLocMax2[i][j]   ->SetXTitle("E (GeV)");
2676       outputContainer->Add(fhM02Pi0NLocMax2[i][j]) ;
2677
2678       fhM02Pi0NLocMaxN[i][j]     = new TH2F(Form("hM02Pi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2679                                             Form("#lambda_{0}^{2} vs E, %s, for NLM > 2",ptype[i].Data()),
2680                                             nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2681       fhM02Pi0NLocMaxN[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2682       fhM02Pi0NLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2683       outputContainer->Add(fhM02Pi0NLocMaxN[i][j]) ;
2684
2685       fhMassPi0NLocMax1[i][j]     = new TH2F(Form("hMassPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2686                                              Form("Mass vs E, %s, for NLM = 1",ptype[i].Data()),
2687                                              nptbins,ptmin,ptmax,mbins,mmin,mmax);
2688       fhMassPi0NLocMax1[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2689       fhMassPi0NLocMax1[i][j]   ->SetXTitle("E (GeV)");
2690       outputContainer->Add(fhMassPi0NLocMax1[i][j]) ;
2691
2692       fhMassPi0NLocMax2[i][j]     = new TH2F(Form("hMassPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2693                                              Form("Mass vs E , %s, for NLM = 2",ptype[i].Data()),
2694                                              nptbins,ptmin,ptmax,mbins,mmin,mmax);
2695       fhMassPi0NLocMax2[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2696       fhMassPi0NLocMax2[i][j]   ->SetXTitle("E (GeV)");
2697       outputContainer->Add(fhMassPi0NLocMax2[i][j]) ;
2698
2699       fhMassPi0NLocMaxN[i][j]     = new TH2F(Form("hMassPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2700                                              Form("Mass vs E, %s, for NLM > 2",ptype[i].Data()),
2701                                              nptbins,ptmin,ptmax,mbins,mmin,mmax);
2702       fhMassPi0NLocMaxN[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2703       fhMassPi0NLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2704       outputContainer->Add(fhMassPi0NLocMaxN[i][j]) ;
2705
2706       fhAsyPi0NLocMax1[i][j]     = new TH2F(Form("hAsyPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2707                                             Form("Asymmetry vs E, %s, for NLM = 1",ptype[i].Data()),
2708                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
2709       fhAsyPi0NLocMax1[i][j]   ->SetYTitle("Asymmetry");
2710       fhAsyPi0NLocMax1[i][j]   ->SetXTitle("E (GeV)");
2711       outputContainer->Add(fhAsyPi0NLocMax1[i][j]) ;
2712
2713       fhAsyPi0NLocMax2[i][j]     = new TH2F(Form("hAsyPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2714                                             Form("Asymmetry vs E, %s, for NLM = 2",ptype[i].Data()),
2715                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
2716       fhAsyPi0NLocMax2[i][j]   ->SetYTitle("Asymmetry");
2717       fhAsyPi0NLocMax2[i][j]   ->SetXTitle("E (GeV)");
2718       outputContainer->Add(fhAsyPi0NLocMax2[i][j]) ;
2719
2720       fhAsyPi0NLocMaxN[i][j]     = new TH2F(Form("hAsyPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2721                                             Form("Asymmetry vs E, %s, for NLM > 2",ptype[i].Data()),
2722                                             nptbins,ptmin,ptmax,mbins,mmin,mmax);
2723       fhAsyPi0NLocMaxN[i][j]   ->SetYTitle("Asymmetry");
2724       fhAsyPi0NLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2725       outputContainer->Add(fhAsyPi0NLocMaxN[i][j]) ;
2726
2727       if(fFillNCellHisto)
2728       {
2729         fhNCellPi0NLocMax1[i][j]     = new TH2F(Form("hNCellPi0NLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2730                                                 Form("n cells vs E, %s, for NLM = 1",ptype[i].Data()),
2731                                                 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2732         fhNCellPi0NLocMax1[i][j]   ->SetYTitle("n cells");
2733         fhNCellPi0NLocMax1[i][j]   ->SetXTitle("E (GeV)");
2734         outputContainer->Add(fhNCellPi0NLocMax1[i][j]) ;
2735
2736         fhNCellPi0NLocMax2[i][j]     = new TH2F(Form("hNCellPi0NLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2737                                                 Form("n cells vs E, %s, for NLM = 2",ptype[i].Data()),
2738                                                 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2739         fhNCellPi0NLocMax2[i][j]   ->SetYTitle("n cells");
2740         fhNCellPi0NLocMax2[i][j]   ->SetXTitle("E (GeV)");
2741         outputContainer->Add(fhNCellPi0NLocMax2[i][j]) ;
2742
2743         fhNCellPi0NLocMaxN[i][j]     = new TH2F(Form("hNCellPi0NLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2744                                                 Form("n cells vs E, %s, for NLM > 2",ptype[i].Data()),
2745                                                 nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2746         fhNCellPi0NLocMaxN[i][j]   ->SetYTitle("n cells");
2747         fhNCellPi0NLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2748         outputContainer->Add(fhNCellPi0NLocMaxN[i][j]) ;
2749       }
2750
2751       // Eta
2752
2753       if(fFillIdEtaHisto)
2754       {
2755         fhM02EtaNLocMax1[i][j]     = new TH2F(Form("hM02EtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2756                                               Form("#lambda_{0}^{2} vs E, %s, for NLM = 1",ptype[i].Data()),
2757                                               nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2758         fhM02EtaNLocMax1[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2759         fhM02EtaNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2760         outputContainer->Add(fhM02EtaNLocMax1[i][j]) ;
2761
2762
2763         fhM02EtaNLocMax2[i][j]     = new TH2F(Form("hM02EtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2764                                               Form("#lambda_{0}^{2} vs E, %s, for NLM = 2",ptype[i].Data()),
2765                                               nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2766         fhM02EtaNLocMax2[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2767         fhM02EtaNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2768         outputContainer->Add(fhM02EtaNLocMax2[i][j]) ;
2769
2770         fhM02EtaNLocMaxN[i][j]     = new TH2F(Form("hM02EtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2771                                               Form("#lambda_{0}^{2} vs E, %s, for NLM > 2",ptype[i].Data()),
2772                                               nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2773         fhM02EtaNLocMaxN[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2774         fhM02EtaNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2775         outputContainer->Add(fhM02EtaNLocMaxN[i][j]) ;
2776
2777         fhMassEtaNLocMax1[i][j]     = new TH2F(Form("hMassEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2778                                                Form("Mass vs E, %s, for NLM = 1",ptype[i].Data()),
2779                                                nptbins,ptmin,ptmax,mbins,mmin,mmax);
2780         fhMassEtaNLocMax1[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2781         fhMassEtaNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2782         outputContainer->Add(fhMassEtaNLocMax1[i][j]) ;
2783
2784         fhMassEtaNLocMax2[i][j]     = new TH2F(Form("hMassEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2785                                                Form("Mass vs E, %s, for NLM = 2",ptype[i].Data()),
2786                                                nptbins,ptmin,ptmax,mbins,mmin,mmax);
2787         fhMassEtaNLocMax2[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2788         fhMassEtaNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2789         outputContainer->Add(fhMassEtaNLocMax2[i][j]) ;
2790
2791         fhMassEtaNLocMaxN[i][j]     = new TH2F(Form("hMassEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2792                                                Form("Mass vs E, %s, for NLM > 2",ptype[i].Data()),
2793                                                nptbins,ptmin,ptmax,mbins,mmin,mmax);
2794         fhMassEtaNLocMaxN[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2795         fhMassEtaNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2796         outputContainer->Add(fhMassEtaNLocMaxN[i][j]) ;
2797
2798         fhAsyEtaNLocMax1[i][j]     = new TH2F(Form("hAsyEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2799                                               Form("Asymmetry vs E, %s, for NLM = 1",ptype[i].Data()),
2800                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2801         fhAsyEtaNLocMax1[i][j]   ->SetYTitle("Asymmetry");
2802         fhAsyEtaNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2803         outputContainer->Add(fhAsyEtaNLocMax1[i][j]) ;
2804
2805         fhAsyEtaNLocMax2[i][j]     = new TH2F(Form("hAsyEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2806                                               Form("Asymmetry vs E, %s, for NLM = 2",ptype[i].Data()),
2807                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2808         fhAsyEtaNLocMax2[i][j]   ->SetYTitle("Asymmetry");
2809         fhAsyEtaNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2810         outputContainer->Add(fhAsyEtaNLocMax2[i][j]) ;
2811
2812         fhAsyEtaNLocMaxN[i][j]     = new TH2F(Form("hAsyEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2813                                               Form("Asymmetry vs E, %s, for NLM > 2",ptype[i].Data()),
2814                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2815         fhAsyEtaNLocMaxN[i][j]   ->SetYTitle("Asymmetry");
2816         fhAsyEtaNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2817         outputContainer->Add(fhAsyEtaNLocMaxN[i][j]) ;
2818
2819         if(fFillNCellHisto)
2820         {
2821           fhNCellEtaNLocMax1[i][j]     = new TH2F(Form("hNCellEtaNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2822                                                   Form("n cells vs E, %s, for NLM = 1",ptype[i].Data()),
2823                                                   nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2824           fhNCellEtaNLocMax1[i][j]   ->SetYTitle("n cells");
2825           fhNCellEtaNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2826           outputContainer->Add(fhNCellEtaNLocMax1[i][j]) ;
2827
2828           fhNCellEtaNLocMax2[i][j]     = new TH2F(Form("hNCellEtaNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2829                                                   Form("n cells vs E, %s, for NLM = 2",ptype[i].Data()),
2830                                                   nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2831           fhNCellEtaNLocMax2[i][j]   ->SetYTitle("n cells");
2832           fhNCellEtaNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2833           outputContainer->Add(fhNCellEtaNLocMax2[i][j]) ;
2834
2835           fhNCellEtaNLocMaxN[i][j]     = new TH2F(Form("hNCellEtaNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2836                                                   Form("n cells vs E, %s, for NLM > 2",ptype[i].Data()),
2837                                                   nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
2838           fhNCellEtaNLocMaxN[i][j]   ->SetYTitle("n cells");
2839           fhNCellEtaNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2840           outputContainer->Add(fhNCellEtaNLocMaxN[i][j]) ;
2841
2842         }
2843       }
2844
2845       if(fFillIdConvHisto)
2846       {
2847         fhM02ConNLocMax1[i][j]    = new TH2F(Form("hM02ConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2848                                              Form("#lambda_{0}^{2} vs E, %s, for NLM = 1",ptype[i].Data()),
2849                                              nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2850         fhM02ConNLocMax1[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2851         fhM02ConNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2852         outputContainer->Add(fhM02ConNLocMax1[i][j]) ;
2853
2854         fhM02ConNLocMax2[i][j]    = new TH2F(Form("hM02ConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2855                                              Form("#lambda_{0}^{2} vs E, %s, for NLM = 2",ptype[i].Data()),
2856                                              nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2857         fhM02ConNLocMax2[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2858         fhM02ConNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2859         outputContainer->Add(fhM02ConNLocMax2[i][j]) ;
2860
2861         fhM02ConNLocMaxN[i][j]    = new TH2F(Form("hM02ConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2862                                              Form("#lambda_{0}^{2} vs E, %s, for NLM > 2",ptype[i].Data()),
2863                                              nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
2864         fhM02ConNLocMaxN[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2865         fhM02ConNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2866         outputContainer->Add(fhM02ConNLocMaxN[i][j]) ;
2867
2868
2869         fhMassConNLocMax1[i][j]    = new TH2F(Form("hMassConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2870                                               Form("Mass vs E, %s, for NLM = 1",ptype[i].Data()),
2871                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2872         fhMassConNLocMax1[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2873         fhMassConNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2874         outputContainer->Add(fhMassConNLocMax1[i][j]) ;
2875
2876         fhMassConNLocMax2[i][j]    = new TH2F(Form("hMassConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2877                                               Form("Mass vs E, %s, for NLM = 2",ptype[i].Data()),
2878                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2879         fhMassConNLocMax2[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2880         fhMassConNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2881         outputContainer->Add(fhMassConNLocMax2[i][j]) ;
2882
2883         fhMassConNLocMaxN[i][j]    = new TH2F(Form("hMassConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2884                                               Form("Mass vs E, %s, for NLM > 2",ptype[i].Data()),
2885                                               nptbins,ptmin,ptmax,mbins,mmin,mmax);
2886         fhMassConNLocMaxN[i][j]   ->SetYTitle("Mass (GeV/c^{2})");
2887         fhMassConNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2888         outputContainer->Add(fhMassConNLocMaxN[i][j]) ;
2889
2890         fhAsyConNLocMax1[i][j]    = new TH2F(Form("hAsyConNLocMax1%s%s",pname[i].Data(),sMatched[j].Data()),
2891                                              Form("Asymmetry vs E, %s, for NLM = 1",ptype[i].Data()),
2892                                              nptbins,ptmin,ptmax,mbins,mmin,mmax);
2893         fhAsyConNLocMax1[i][j]   ->SetYTitle("Asymmetry");
2894         fhAsyConNLocMax1[i][j]   ->SetXTitle("E (GeV)");
2895         outputContainer->Add(fhAsyConNLocMax1[i][j]) ;
2896
2897         fhAsyConNLocMax2[i][j]    = new TH2F(Form("hAsyConNLocMax2%s%s",pname[i].Data(),sMatched[j].Data()),
2898                                              Form("Asymmetry vs E, %s, for NLM = 2",ptype[i].Data()),
2899                                              nptbins,ptmin,ptmax,mbins,mmin,mmax);
2900         fhAsyConNLocMax2[i][j]   ->SetYTitle("Asymmetry");
2901         fhAsyConNLocMax2[i][j]   ->SetXTitle("E (GeV)");
2902         outputContainer->Add(fhAsyConNLocMax2[i][j]) ;
2903
2904         fhAsyConNLocMaxN[i][j]    = new TH2F(Form("hAsyConNLocMaxN%s%s",pname[i].Data(),sMatched[j].Data()),
2905                                              Form("Asymmetry vs E, %s, for NLM > 2",ptype[i].Data()),
2906                                              nptbins,ptmin,ptmax,mbins,mmin,mmax);
2907         fhAsyConNLocMaxN[i][j]   ->SetYTitle("Asymmetry");
2908         fhAsyConNLocMaxN[i][j]   ->SetXTitle("E (GeV)");
2909         outputContainer->Add(fhAsyConNLocMaxN[i][j]) ;
2910
2911       }
2912
2913     } // matched, not matched
2914
2915     if(fFillEbinHisto)
2916     {
2917       for(Int_t j = 0; j < 4; j++)
2918       {
2919
2920         fhMassSplitEFractionNLocMax1Ebin[i][j]  = new TH2F(Form("hMassSplitEFractionNLocMax1%sEbin%d",pname[i].Data(),j),
2921                                                            Form("Invariant mass of 2 highest energy cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
2922                                                            120,0,1.2,mbins,mmin,mmax);
2923         fhMassSplitEFractionNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
2924         fhMassSplitEFractionNLocMax1Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
2925         outputContainer->Add(fhMassSplitEFractionNLocMax1Ebin[i][j]) ;
2926
2927         fhMassSplitEFractionNLocMax2Ebin[i][j]  = new TH2F(Form("hMassSplitEFractionNLocMax2%sEbin%d",pname[i].Data(),j),
2928                                                            Form("Invariant mass of 2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
2929                                                            120,0,1.2,mbins,mmin,mmax);
2930         fhMassSplitEFractionNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
2931         fhMassSplitEFractionNLocMax2Ebin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
2932         outputContainer->Add(fhMassSplitEFractionNLocMax2Ebin[i][j]) ;
2933
2934         fhMassSplitEFractionNLocMaxNEbin[i][j]  = new TH2F(Form("hMassSplitEFractionNLocMaxN%sEbin%d",pname[i].Data(),j),
2935                                                            Form("Invariant mass of N>2 local maxima cells vs (E1+E2)/Ecluster, %s, E bin %d",ptype[i].Data(),j),
2936                                                            120,0,1.2,mbins,mmin,mmax);
2937         fhMassSplitEFractionNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
2938         fhMassSplitEFractionNLocMaxNEbin[i][j]->SetXTitle("(E_{split1}+E_{split2})/E_{cluster}");
2939         outputContainer->Add(fhMassSplitEFractionNLocMaxNEbin[i][j]) ;
2940
2941         if(i>0 && fFillMCHisto) // skip first entry in array, general case not filled
2942         {
2943           fhMCGenFracNLocMaxEbin[i][j]  = new TH2F(Form("hMCGenFracNLocMax%sEbin%d",pname[i].Data(),j),
2944                                                    Form("NLM vs E, %s, E bin %d",ptype[i].Data(),j),
2945                                                    200,0,2,nMaxBins,0,nMaxBins);
2946           fhMCGenFracNLocMaxEbin[i][j]->SetYTitle("NLM");
2947           fhMCGenFracNLocMaxEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
2948           outputContainer->Add(fhMCGenFracNLocMaxEbin[i][j]) ;
2949
2950           fhMCGenFracNLocMaxEbinMatched[i][j]  = new TH2F(Form("hMCGenFracNLocMax%sEbin%dMatched",pname[i].Data(),j),
2951                                                           Form("NLM vs E, %s, E bin %d, matched to a track",ptype[i].Data(),j),
2952                                                           200,0,2,nMaxBins,0,nMaxBins);
2953           fhMCGenFracNLocMaxEbinMatched[i][j]->SetYTitle("NLM");
2954           fhMCGenFracNLocMaxEbinMatched[i][j]->SetXTitle("E_{gen} / E_{reco}");
2955           outputContainer->Add(fhMCGenFracNLocMaxEbinMatched[i][j]) ;
2956
2957           fhMassMCGenFracNLocMax1Ebin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
2958                                                         Form("Invariant mass of 2 highest energy cells vs E, %s, E bin %d",ptype[i].Data(),j),
2959                                                         200,0,2,mbins,mmin,mmax);
2960           fhMassMCGenFracNLocMax1Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
2961           fhMassMCGenFracNLocMax1Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
2962           outputContainer->Add(fhMassMCGenFracNLocMax1Ebin[i][j]) ;
2963
2964           fhMassMCGenFracNLocMax2Ebin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
2965                                                         Form("Invariant mass of 2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
2966                                                         200,0,2,mbins,mmin,mmax);
2967           fhMassMCGenFracNLocMax2Ebin[i][j]->SetYTitle("M (GeV/c^{2})");
2968           fhMassMCGenFracNLocMax2Ebin[i][j]->SetXTitle("E_{gen} / E_{reco}");
2969           outputContainer->Add(fhMassMCGenFracNLocMax2Ebin[i][j]) ;
2970
2971           fhMassMCGenFracNLocMaxNEbin[i][j]  = new TH2F(Form("hMassMCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
2972                                                         Form("Invariant mass of N>2 local maxima cells vs E, %s, E bin %d",ptype[i].Data(),j),
2973                                                         200,0,2,mbins,mmin,mmax);
2974           fhMassMCGenFracNLocMaxNEbin[i][j]->SetYTitle("M (GeV/c^{2})");
2975           fhMassMCGenFracNLocMaxNEbin[i][j]->SetXTitle("E_{gen} / E_{reco}");
2976           outputContainer->Add(fhMassMCGenFracNLocMaxNEbin[i][j]) ;
2977
2978           fhM02MCGenFracNLocMax1Ebin[i][j]     = new TH2F(Form("hM02MCGenFracNLocMax1%sEbin%d",pname[i].Data(),j),
2979                                                           Form("#lambda_{0}^{2} vs E for N max  = 1 %s, E bin %d",ptype[i].Data(), j),
2980                                                           200,0,2,ssbins,ssmin,ssmax);
2981           fhM02MCGenFracNLocMax1Ebin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2982           fhM02MCGenFracNLocMax1Ebin[i][j]   ->SetXTitle("E_{gen} / E_{reco}");
2983           outputContainer->Add(fhM02MCGenFracNLocMax1Ebin[i][j]) ;
2984
2985           fhM02MCGenFracNLocMax2Ebin[i][j]     = new TH2F(Form("hM02MCGenFracNLocMax2%sEbin%d",pname[i].Data(),j),
2986                                                           Form("#lambda_{0}^{2} vs E for N max  = 2 %s, E bin %d",ptype[i].Data(),j),
2987                                                           200,0,2,ssbins,ssmin,ssmax);
2988           fhM02MCGenFracNLocMax2Ebin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2989           fhM02MCGenFracNLocMax2Ebin[i][j]   ->SetXTitle("E_{gen} / E_{reco}");
2990           outputContainer->Add(fhM02MCGenFracNLocMax2Ebin[i][j]) ;
2991
2992           fhM02MCGenFracNLocMaxNEbin[i][j]    = new TH2F(Form("hM02MCGenFracNLocMaxN%sEbin%d",pname[i].Data(),j),
2993                                                          Form("#lambda_{0}^{2} vs E for N max  > 2 %s, E bin %d",ptype[i].Data(),j),
2994                                                          200,0,2,ssbins,ssmin,ssmax);
2995           fhM02MCGenFracNLocMaxNEbin[i][j]   ->SetYTitle("#lambda_{0}^{2}");
2996           fhM02MCGenFracNLocMaxNEbin[i][j]   ->SetXTitle("E_{gen} / E_{reco}");
2997           outputContainer->Add(fhM02MCGenFracNLocMaxNEbin[i][j]) ;
2998         }
2999       }
3000     }
3001   } // MC particle list
3002
3003   if(fFillHighMultHisto)
3004   {
3005     // E vs centrality
3006
3007     fhCentralityPi0NLocMax1  = new TH2F("hCentralityPi0NLocMax1",
3008                                         "E vs Centrality, selected pi0 cluster with NLM=1",
3009                                         nptbins,ptmin,ptmax,100,0,100);
3010     fhCentralityPi0NLocMax1->SetYTitle("Centrality");
3011     fhCentralityPi0NLocMax1->SetXTitle("E (GeV)");
3012     outputContainer->Add(fhCentralityPi0NLocMax1) ;
3013
3014     fhCentralityPi0NLocMax2  = new TH2F("hCentralityPi0NLocMax2",
3015                                         "E vs Centrality, selected pi0 cluster with NLM=2",
3016                                         nptbins,ptmin,ptmax,100,0,100);
3017     fhCentralityPi0NLocMax2->SetYTitle("Centrality");
3018     fhCentralityPi0NLocMax2->SetXTitle("E (GeV)");
3019     outputContainer->Add(fhCentralityPi0NLocMax2) ;
3020
3021     fhCentralityPi0NLocMaxN  = new TH2F("hCentralityPi0NLocMaxN",
3022                                         "E vs Centrality, selected pi0 cluster with NLM>1",
3023                                         nptbins,ptmin,ptmax,100,0,100);
3024     fhCentralityPi0NLocMaxN->SetYTitle("Centrality");
3025     fhCentralityPi0NLocMaxN->SetXTitle("E (GeV)");
3026     outputContainer->Add(fhCentralityPi0NLocMaxN) ;
3027
3028     if(fFillIdEtaHisto)
3029     {
3030       fhCentralityEtaNLocMax1  = new TH2F("hCentralityEtaNLocMax1",
3031                                           "E vs Centrality, selected pi0 cluster with NLM=1",
3032                                           nptbins,ptmin,ptmax,100,0,100);
3033       fhCentralityEtaNLocMax1->SetYTitle("Centrality");
3034       fhCentralityEtaNLocMax1->SetXTitle("E (GeV)");
3035       outputContainer->Add(fhCentralityEtaNLocMax1) ;
3036
3037       fhCentralityEtaNLocMax2  = new TH2F("hCentralityEtaNLocMax2",
3038                                           "E vs Centrality, selected pi0 cluster with NLM=2",
3039                                           nptbins,ptmin,ptmax,100,0,100);
3040       fhCentralityEtaNLocMax2->SetYTitle("Centrality");
3041       fhCentralityEtaNLocMax2->SetXTitle("E (GeV)");
3042       outputContainer->Add(fhCentralityEtaNLocMax2) ;
3043
3044       fhCentralityEtaNLocMaxN  = new TH2F("hCentralityEtaNLocMaxN",
3045                                           "E vs Centrality, selected pi0 cluster with NLM>1",
3046                                           nptbins,ptmin,ptmax,100,0,100);
3047       fhCentralityEtaNLocMaxN->SetYTitle("Centrality");
3048       fhCentralityEtaNLocMaxN->SetXTitle("E (GeV)");
3049       outputContainer->Add(fhCentralityEtaNLocMaxN) ;
3050     }
3051
3052     // E vs Event plane angle
3053
3054     fhEventPlanePi0NLocMax1  = new TH2F("hEventPlanePi0NLocMax1","E vs Event Plane Angle, selected pi0 cluster with NLM=1",
3055                                         nptbins,ptmin,ptmax,100,0,TMath::Pi());
3056     fhEventPlanePi0NLocMax1->SetYTitle("Event Plane Angle (rad)");
3057     fhEventPlanePi0NLocMax1->SetXTitle("E (GeV)");
3058     outputContainer->Add(fhEventPlanePi0NLocMax1) ;
3059
3060     fhEventPlanePi0NLocMax2  = new TH2F("hEventPlanePi0NLocMax2","E vs Event Plane Angle, selected pi0 cluster with NLM=2",
3061                                         nptbins,ptmin,ptmax,100,0,TMath::Pi());
3062     fhEventPlanePi0NLocMax2->SetYTitle("Event Plane Angle (rad)");
3063     fhEventPlanePi0NLocMax2->SetXTitle("E (GeV)");
3064     outputContainer->Add(fhEventPlanePi0NLocMax2) ;
3065
3066     fhEventPlanePi0NLocMaxN  = new TH2F("hEventPlanePi0NLocMaxN","E vs Event Plane Angle, selected pi0 cluster with NLM>1",
3067                                         nptbins,ptmin,ptmax,100,0,TMath::Pi());
3068     fhEventPlanePi0NLocMaxN->SetYTitle("Event Plane Angle (rad)");
3069     fhEventPlanePi0NLocMaxN->SetXTitle("E (GeV)");
3070     outputContainer->Add(fhEventPlanePi0NLocMaxN) ;
3071
3072     if(fFillIdEtaHisto)
3073     {
3074       fhEventPlaneEtaNLocMax1  = new TH2F("hEventPlaneEtaNLocMax1","E vs Event Plane Angle, selected pi0 cluster with NLM=1",
3075                                           nptbins,ptmin,ptmax,100,0,TMath::Pi());
3076       fhEventPlaneEtaNLocMax1->SetYTitle("Event Plane Angle (rad)");
3077       fhEventPlaneEtaNLocMax1->SetXTitle("E (GeV)");
3078       outputContainer->Add(fhEventPlaneEtaNLocMax1) ;
3079
3080       fhEventPlaneEtaNLocMax2  = new TH2F("hEventPlaneEtaNLocMax2","E vs Event Plane Angle, selected pi0 cluster with NLM=2",
3081                                           nptbins,ptmin,ptmax,100,0,TMath::Pi());
3082       fhEventPlaneEtaNLocMax2->SetYTitle("Event Plane Angle (rad)");
3083       fhEventPlaneEtaNLocMax2->SetXTitle("E (GeV)");
3084       outputContainer->Add(fhEventPlaneEtaNLocMax2) ;
3085
3086       fhEventPlaneEtaNLocMaxN  = new TH2F("hEventPlaneEtaNLocMaxN","E vs Event Plane Angle, selected pi0 cluster with NLM>1",
3087                                           nptbins,ptmin,ptmax,100,0,TMath::Pi());
3088       fhEventPlaneEtaNLocMaxN->SetYTitle("Event Plane Angle (rad)");
3089       fhEventPlaneEtaNLocMaxN->SetXTitle("E (GeV)");
3090       outputContainer->Add(fhEventPlaneEtaNLocMaxN) ;
3091     }
3092   }
3093
3094   if(fFillEbinHisto)
3095   {
3096     for(Int_t i = 0; i < 4; i++)
3097     {
3098       fhMassM02NLocMax1Ebin[i]  = new TH2F(Form("hMassM02NLocMax1Ebin%d",i),
3099                                            Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
3100                                            ssbins,ssmin,ssmax,mbins,mmin,mmax);
3101       fhMassM02NLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
3102       fhMassM02NLocMax1Ebin[i]->SetXTitle("#lambda_{0}^{2}");
3103       outputContainer->Add(fhMassM02NLocMax1Ebin[i]) ;
3104
3105       fhMassM02NLocMax2Ebin[i]  = new TH2F(Form("hMassM02NLocMax2Ebin%d",i),
3106                                            Form("Invariant mass of split clusters vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
3107                                            ssbins,ssmin,ssmax,mbins,mmin,mmax);
3108       fhMassM02NLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
3109       fhMassM02NLocMax2Ebin[i]->SetXTitle("#lambda_{0}^{2}");
3110       outputContainer->Add(fhMassM02NLocMax2Ebin[i]) ;
3111
3112       fhMassM02NLocMaxNEbin[i]  = new TH2F(Form("hMassM02NLocMaxNEbin%d",i),
3113                                            Form("Invariant mass of split clusters vs vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
3114                                            ssbins,ssmin,ssmax,mbins,mmin,mmax);
3115       fhMassM02NLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
3116       fhMassM02NLocMaxNEbin[i]->SetXTitle("#lambda_{0}^{2}");
3117       outputContainer->Add(fhMassM02NLocMaxNEbin[i]) ;
3118
3119
3120       fhMassAsyNLocMax1Ebin[i]  = new TH2F(Form("hMassAsyNLocMax1Ebin%d",i),
3121                                            Form("Invariant mass of split clusters vs split asymmetry, NLM=1, E bin %d",i),
3122                                            200,-1,1,mbins,mmin,mmax);
3123       fhMassAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
3124       fhMassAsyNLocMax1Ebin[i]->SetXTitle("asymmetry");
3125       outputContainer->Add(fhMassAsyNLocMax1Ebin[i]) ;
3126
3127       fhMassAsyNLocMax2Ebin[i]  = new TH2F(Form("hMassAsyNLocMax2Ebin%d",i),
3128                                            Form("Invariant mass of split clusters vs split asymmetry, NLM=2, E bin %d",i),
3129                                            200,-1,1,mbins,mmin,mmax);
3130       fhMassAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
3131       fhMassAsyNLocMax2Ebin[i]->SetXTitle("asymmetry");
3132       outputContainer->Add(fhMassAsyNLocMax2Ebin[i]) ;
3133
3134       fhMassAsyNLocMaxNEbin[i]  = new TH2F(Form("hMassAsyNLocMaxNEbin%d",i),
3135                                            Form("Invariant mass of split clusters vs split asymmetry, NLM>2, E bin %d",i),
3136                                            200,-1,1,mbins,mmin,mmax);
3137       fhMassAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
3138       fhMassAsyNLocMaxNEbin[i]->SetXTitle("asymmetry");
3139       outputContainer->Add(fhMassAsyNLocMaxNEbin[i]) ;
3140
3141
3142       if(IsDataMC() && fFillMCHisto)
3143       {
3144         fhMCAsymM02NLocMax1MCPi0Ebin[i]  = new TH2F(Form("hMCAsymM02NLocMax1MCPi0Ebin%d",i),
3145                                                     Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=1, E bin %d",i),
3146                                                     ssbins,ssmin,ssmax,100,0,1);
3147         fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
3148         fhMCAsymM02NLocMax1MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
3149         outputContainer->Add(fhMCAsymM02NLocMax1MCPi0Ebin[i]) ;
3150
3151         fhMCAsymM02NLocMax2MCPi0Ebin[i]  = new TH2F(Form("hMCAsymM02NLocMax2MCPi0Ebin%d",i),
3152                                                     Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM=2, E bin %d",i),
3153                                                     ssbins,ssmin,ssmax,100,0,1);
3154         fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetYTitle("Decay asymmetry");
3155         fhMCAsymM02NLocMax2MCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
3156         outputContainer->Add(fhMCAsymM02NLocMax2MCPi0Ebin[i]) ;
3157
3158         fhMCAsymM02NLocMaxNMCPi0Ebin[i]  = new TH2F(Form("hMCAsymM02NLocMaxNMCPi0Ebin%d",i),
3159                                                     Form("Asymmetry of MC #pi^{0} vs #lambda_{0}^{2}, NLM>2, E bin %d",i),
3160                                                     ssbins,ssmin,ssmax,100,0,1);
3161         fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetYTitle("Decay asymmetry");
3162         fhMCAsymM02NLocMaxNMCPi0Ebin[i]->SetXTitle("#lambda_{0}^{2}");
3163         outputContainer->Add(fhMCAsymM02NLocMaxNMCPi0Ebin[i]) ;
3164
3165
3166         fhAsyMCGenRecoNLocMax1EbinPi0[i]  = new TH2F(Form("hAsyMCGenRecoNLocMax1Ebin%dPi0",i),
3167                                                      Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=1, E bin %d",i),
3168                                                      200,-1,1,200,-1,1);
3169         fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
3170         fhAsyMCGenRecoNLocMax1EbinPi0[i]->SetXTitle("asymmetry");
3171         outputContainer->Add(fhAsyMCGenRecoNLocMax1EbinPi0[i]) ;
3172
3173         fhAsyMCGenRecoNLocMax2EbinPi0[i]  = new TH2F(Form("hAsyMCGenRecoNLocMax2Ebin%dPi0",i),
3174                                                      Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM=2, E bin %d",i),
3175                                                      200,-1,1,200,-1,1);
3176         fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetYTitle("M (GeV/c^{2})");
3177         fhAsyMCGenRecoNLocMax2EbinPi0[i]->SetXTitle("asymmetry");
3178         outputContainer->Add(fhAsyMCGenRecoNLocMax2EbinPi0[i]) ;
3179
3180         fhAsyMCGenRecoNLocMaxNEbinPi0[i]  = new TH2F(Form("hAsyMCGenRecoNLocMaxNEbin%dPi0",i),
3181                                                      Form("Generated vs reconstructed asymmetry of split clusters from pi0, NLM>2, E bin %d",i),
3182                                                      200,-1,1,200,-1,1);
3183         fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetYTitle("M (GeV/c^{2})");
3184         fhAsyMCGenRecoNLocMaxNEbinPi0[i]->SetXTitle("asymmetry");
3185         outputContainer->Add(fhAsyMCGenRecoNLocMaxNEbinPi0[i]) ;
3186       }
3187
3188       if(fFillSSExtraHisto)
3189       {
3190         fhMassDispEtaNLocMax1Ebin[i]  = new TH2F(Form("hMassDispEtaNLocMax1Ebin%d",i),
3191                                                  Form("Invariant mass of 2 highest energy cells #sigma_{#eta #eta}^{2}, E bin %d",i),
3192                                                  ssbins,ssmin,ssmax,mbins,mmin,mmax);
3193         fhMassDispEtaNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
3194         fhMassDispEtaNLocMax1Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
3195         outputContainer->Add(fhMassDispEtaNLocMax1Ebin[i]) ;
3196
3197         fhMassDispEtaNLocMax2Ebin[i]  = new TH2F(Form("hMassDispEtaNLocMax2Ebin%d",i),
3198                                                  Form("Invariant mass of 2 local maxima cells #sigma_{#eta #eta}^{2}, E bin %d",i),
3199                                                  ssbins,ssmin,ssmax,mbins,mmin,mmax);
3200         fhMassDispEtaNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
3201         fhMassDispEtaNLocMax2Ebin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
3202         outputContainer->Add(fhMassDispEtaNLocMax2Ebin[i]) ;
3203
3204         fhMassDispEtaNLocMaxNEbin[i]  = new TH2F(Form("hMassDispEtaNLocMaxNEbin%d",i),
3205                                                  Form("Invariant mass of N>2 local maxima cells vs #sigma_{#eta #eta}^{2}, E bin %d",i),
3206                                                  ssbins,ssmin,ssmax,mbins,mmin,mmax);
3207         fhMassDispEtaNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
3208         fhMassDispEtaNLocMaxNEbin[i]->SetXTitle("#sigma_{#eta #eta}^{2}");
3209         outputContainer->Add(fhMassDispEtaNLocMaxNEbin[i]) ;
3210
3211         fhMassDispPhiNLocMax1Ebin[i]  = new TH2F(Form("hMassDispPhiNLocMax1Ebin%d",i),
3212                                                  Form("Invariant mass of 2 highest energy cells #sigma_{#phi #phi}^{2}, E bin %d",i),
3213                                                  ssbins,ssmin,ssmax,mbins,mmin,mmax);
3214         fhMassDispPhiNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
3215         fhMassDispPhiNLocMax1Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
3216         outputContainer->Add(fhMassDispPhiNLocMax1Ebin[i]) ;
3217
3218         fhMassDispPhiNLocMax2Ebin[i]  = new TH2F(Form("hMassDispPhiNLocMax2Ebin%d",i),
3219                                                  Form("Invariant mass of 2 local maxima cells #sigma_{#phi #phi}^{2}, E bin %d",i),
3220                                                  ssbins,ssmin,ssmax,mbins,mmin,mmax);
3221         fhMassDispPhiNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
3222         fhMassDispPhiNLocMax2Ebin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
3223         outputContainer->Add(fhMassDispPhiNLocMax2Ebin[i]) ;
3224
3225         fhMassDispPhiNLocMaxNEbin[i]  = new TH2F(Form("hMassDispPhiNLocMaxNEbin%d",i),
3226                                                  Form("Invariant mass of N>2 local maxima cells vs #sigma_{#phi #phi}^{2}, E bin %d",i),
3227                                                  ssbins,ssmin,ssmax,mbins,mmin,mmax);
3228         fhMassDispPhiNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
3229         fhMassDispPhiNLocMaxNEbin[i]->SetXTitle("#sigma_{#phi #phi}^{2}");
3230         outputContainer->Add(fhMassDispPhiNLocMaxNEbin[i]) ;
3231
3232         fhMassDispAsyNLocMax1Ebin[i]  = new TH2F(Form("hMassDispAsyNLocMax1Ebin%d",i),
3233                                                  Form("Invariant mass of 2 highest energy cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
3234                                                  200,-1,1,mbins,mmin,mmax);
3235         fhMassDispAsyNLocMax1Ebin[i]->SetYTitle("M (GeV/c^{2})");
3236         fhMassDispAsyNLocMax1Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
3237         outputContainer->Add(fhMassDispAsyNLocMax1Ebin[i]) ;
3238
3239         fhMassDispAsyNLocMax2Ebin[i]  = new TH2F(Form("hMassDispAsyNLocMax2Ebin%d",i),
3240                                                  Form("Invariant mass of 2 local maxima cells A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
3241                                                  200,-1,1,mbins,mmin,mmax);
3242         fhMassDispAsyNLocMax2Ebin[i]->SetYTitle("M (GeV/c^{2})");
3243         fhMassDispAsyNLocMax2Ebin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
3244         outputContainer->Add(fhMassDispAsyNLocMax2Ebin[i]) ;
3245
3246         fhMassDispAsyNLocMaxNEbin[i]  = new TH2F(Form("hMassDispAsyNLocMaxNEbin%d",i),
3247                                                  Form("Invariant mass of N>2 local maxima cells vs A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2}), E bin %d",i),
3248                                                  200,-1,1,mbins,mmin,mmax);
3249         fhMassDispAsyNLocMaxNEbin[i]->SetYTitle("M (GeV/c^{2})");
3250         fhMassDispAsyNLocMaxNEbin[i]->SetXTitle("A = (#sigma_{#phi #phi}^{2} - #sigma_{#eta #eta}^{2}) / (#sigma_{#phi #phi}^{2} + #sigma_{#eta #eta}^{2})");
3251         outputContainer->Add(fhMassDispAsyNLocMaxNEbin[i]) ;
3252       }
3253     }
3254   }
3255
3256   if(IsDataMC() && fFillMCHisto && (asyOn || m02On))
3257   {
3258     fhMCGenSplitEFracAfterCutsNLocMax1MCPi0     = new TH2F("hMCGenSplitEFracAfterCutsNLocMax1MCPi0",
3259                                                            "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  = 1 MC Pi0, after M02 and Asym cut",
3260                                                            nptbins,ptmin,ptmax,200,0,2);
3261     fhMCGenSplitEFracAfterCutsNLocMax1MCPi0   ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
3262     fhMCGenSplitEFracAfterCutsNLocMax1MCPi0   ->SetXTitle("E (GeV)");
3263     outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMax1MCPi0) ;
3264
3265     fhMCGenSplitEFracAfterCutsNLocMax2MCPi0    = new TH2F("hMCGenSplitEFracAfterCutsNLocMax2MCPi0",
3266                                                           "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  = 2 MC Pi0, after M02 and Asym cut",
3267                                                           nptbins,ptmin,ptmax,200,0,2);
3268     fhMCGenSplitEFracAfterCutsNLocMax2MCPi0  ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
3269     fhMCGenSplitEFracAfterCutsNLocMax2MCPi0  ->SetXTitle("E (GeV)");
3270     outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMax2MCPi0) ;
3271
3272
3273     fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0    = new TH2F("hMCGenSplitEFracAfterCutsNLocMaxNMCPi0",
3274                                                           "E_{gen} / (E_{1 split}+E_{2 split}) vs E for N max  > 2 MC Pi0, after M02 and Asym cut",
3275                                                           nptbins,ptmin,ptmax,200,0,2);
3276     fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0  ->SetYTitle("E_{gen} / (E_{1 split}+E_{2 split})");
3277     fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0  ->SetXTitle("E (GeV)");
3278     outputContainer->Add(fhMCGenSplitEFracAfterCutsNLocMaxNMCPi0) ;
3279
3280     fhMCGenFracAfterCutsNLocMax1MCPi0     = new TH2F("hMCGenFracAfterCutsNLocMax1MCPi0",
3281                                                      "E_{gen} / E_{reco} vs E_{reco} for N max  = 1 MC Pi0, after M02 and Asym cut",
3282                                                      nptbins,ptmin,ptmax,200,0,2);
3283     fhMCGenFracAfterCutsNLocMax1MCPi0   ->SetYTitle("E_{gen} / E_{reco}");
3284     fhMCGenFracAfterCutsNLocMax1MCPi0   ->SetXTitle("E (GeV)");
3285     outputContainer->Add(fhMCGenFracAfterCutsNLocMax1MCPi0) ;
3286
3287     fhMCGenFracAfterCutsNLocMax2MCPi0    = new TH2F("hMCGenFracAfterCutsNLocMax2MCPi0",
3288                                                     " E_{gen} / E_{reco} vs E_{reco} for N max  = 2 MC Pi0, after M02 and Asym cut",
3289                                                     nptbins,ptmin,ptmax,200,0,2);
3290     fhMCGenFracAfterCutsNLocMax2MCPi0   ->SetYTitle("E_{gen} / E_{reco}");
3291     fhMCGenFracAfterCutsNLocMax2MCPi0   ->SetXTitle("E (GeV)");
3292     outputContainer->Add(fhMCGenFracAfterCutsNLocMax2MCPi0) ;
3293
3294
3295     fhMCGenFracAfterCutsNLocMaxNMCPi0   = new TH2F("hMCGenFracAfterCutsNLocMaxNMCPi0",
3296                                                    " E_{gen} / E_{reco}  vs E_{reco} for N max  > 2 MC Pi0, after M02 and Asym cut",
3297                                                    nptbins,ptmin,ptmax,200,0,2);
3298     fhMCGenFracAfterCutsNLocMaxNMCPi0   ->SetYTitle("E_{gen} / E_{reco}");
3299     fhMCGenFracAfterCutsNLocMaxNMCPi0   ->SetXTitle("E (GeV)");
3300     outputContainer->Add(fhMCGenFracAfterCutsNLocMaxNMCPi0) ;
3301
3302   }
3303
3304   if(fFillTMResidualHisto && fFillTMHisto)
3305   {
3306     for(Int_t i = 0; i < n; i++)
3307     {
3308
3309       fhTrackMatchedDEtaNLocMax1[i]  = new TH2F
3310       (Form("hTrackMatchedDEtaNLocMax1%s",pname[i].Data()),
3311        Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
3312        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3313       fhTrackMatchedDEtaNLocMax1[i]->SetYTitle("d#eta");
3314       fhTrackMatchedDEtaNLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
3315
3316       fhTrackMatchedDPhiNLocMax1[i]  = new TH2F
3317       (Form("hTrackMatchedDPhiNLocMax1%s",pname[i].Data()),
3318        Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
3319        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3320       fhTrackMatchedDPhiNLocMax1[i]->SetYTitle("d#phi (rad)");
3321       fhTrackMatchedDPhiNLocMax1[i]->SetXTitle("E_{cluster} (GeV)");
3322
3323       outputContainer->Add(fhTrackMatchedDEtaNLocMax1[i]) ;
3324       outputContainer->Add(fhTrackMatchedDPhiNLocMax1[i]) ;
3325
3326       fhTrackMatchedDEtaNLocMax2[i]  = new TH2F
3327       (Form("hTrackMatchedDEtaNLocMax2%s",pname[i].Data()),
3328        Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
3329        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3330       fhTrackMatchedDEtaNLocMax2[i]->SetYTitle("d#eta");
3331       fhTrackMatchedDEtaNLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
3332
3333       fhTrackMatchedDPhiNLocMax2[i]  = new TH2F
3334       (Form("hTrackMatchedDPhiNLocMax2%s",pname[i].Data()),
3335        Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
3336        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3337       fhTrackMatchedDPhiNLocMax2[i]->SetYTitle("d#phi (rad)");
3338       fhTrackMatchedDPhiNLocMax2[i]->SetXTitle("E_{cluster} (GeV)");
3339
3340       outputContainer->Add(fhTrackMatchedDEtaNLocMax2[i]) ;
3341       outputContainer->Add(fhTrackMatchedDPhiNLocMax2[i]) ;
3342
3343       fhTrackMatchedDEtaNLocMaxN[i]  = new TH2F
3344       (Form("hTrackMatchedDEtaNLocMaxN%s",pname[i].Data()),
3345        Form("d#eta of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
3346        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3347       fhTrackMatchedDEtaNLocMaxN[i]->SetYTitle("d#eta");
3348       fhTrackMatchedDEtaNLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
3349
3350       fhTrackMatchedDPhiNLocMaxN[i]  = new TH2F
3351       (Form("hTrackMatchedDPhiNLocMaxN%s",pname[i].Data()),
3352        Form("d#phi of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
3353        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3354       fhTrackMatchedDPhiNLocMaxN[i]->SetYTitle("d#phi (rad)");
3355       fhTrackMatchedDPhiNLocMaxN[i]->SetXTitle("E_{cluster} (GeV)");
3356
3357       outputContainer->Add(fhTrackMatchedDEtaNLocMaxN[i]) ;
3358       outputContainer->Add(fhTrackMatchedDPhiNLocMaxN[i]) ;
3359
3360       fhTrackMatchedDEtaNLocMax1Pos[i]  = new TH2F
3361       (Form("hTrackMatchedDEtaNLocMax1Pos%s",pname[i].Data()),
3362        Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
3363        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3364       fhTrackMatchedDEtaNLocMax1Pos[i]->SetYTitle("d#eta");
3365       fhTrackMatchedDEtaNLocMax1Pos[i]->SetXTitle("E_{cluster} (GeV)");
3366
3367       fhTrackMatchedDPhiNLocMax1Pos[i]  = new TH2F
3368       (Form("hTrackMatchedDPhiNLocMax1Pos%s",pname[i].Data()),
3369        Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
3370        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3371       fhTrackMatchedDPhiNLocMax1Pos[i]->SetYTitle("d#phi (rad)");
3372       fhTrackMatchedDPhiNLocMax1Pos[i]->SetXTitle("E_{cluster} (GeV)");
3373
3374       outputContainer->Add(fhTrackMatchedDEtaNLocMax1Pos[i]) ;
3375       outputContainer->Add(fhTrackMatchedDPhiNLocMax1Pos[i]) ;
3376
3377       fhTrackMatchedDEtaNLocMax2Pos[i]  = new TH2F
3378       (Form("hTrackMatchedDEtaNLocMax2Pos%s",pname[i].Data()),
3379        Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
3380        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3381       fhTrackMatchedDEtaNLocMax2Pos[i]->SetYTitle("d#eta");
3382       fhTrackMatchedDEtaNLocMax2Pos[i]->SetXTitle("E_{cluster} (GeV)");
3383
3384       fhTrackMatchedDPhiNLocMax2Pos[i]  = new TH2F
3385       (Form("hTrackMatchedDPhiNLocMax2Pos%s",pname[i].Data()),
3386        Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
3387        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3388       fhTrackMatchedDPhiNLocMax2Pos[i]->SetYTitle("d#phi (rad)");
3389       fhTrackMatchedDPhiNLocMax2Pos[i]->SetXTitle("E_{cluster} (GeV)");
3390
3391       outputContainer->Add(fhTrackMatchedDEtaNLocMax2Pos[i]) ;
3392       outputContainer->Add(fhTrackMatchedDPhiNLocMax2Pos[i]) ;
3393
3394       fhTrackMatchedDEtaNLocMaxNPos[i]  = new TH2F
3395       (Form("hTrackMatchedDEtaNLocMaxNPos%s",pname[i].Data()),
3396        Form("d#eta of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
3397        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3398       fhTrackMatchedDEtaNLocMaxNPos[i]->SetYTitle("d#eta");
3399       fhTrackMatchedDEtaNLocMaxNPos[i]->SetXTitle("E_{cluster} (GeV)");
3400
3401       fhTrackMatchedDPhiNLocMaxNPos[i]  = new TH2F
3402       (Form("hTrackMatchedDPhiNLocMaxNPos%s",pname[i].Data()),
3403        Form("d#phi of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
3404        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3405       fhTrackMatchedDPhiNLocMaxNPos[i]->SetYTitle("d#phi (rad)");
3406       fhTrackMatchedDPhiNLocMaxNPos[i]->SetXTitle("E_{cluster} (GeV)");
3407
3408       outputContainer->Add(fhTrackMatchedDEtaNLocMaxNPos[i]) ;
3409       outputContainer->Add(fhTrackMatchedDPhiNLocMaxNPos[i]) ;
3410
3411       fhTrackMatchedDEtaNLocMax1Neg[i]  = new TH2F
3412       (Form("hTrackMatchedDEtaNLocMax1Neg%s",pname[i].Data()),
3413        Form("d#eta of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
3414        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3415       fhTrackMatchedDEtaNLocMax1Neg[i]->SetYTitle("d#eta");
3416       fhTrackMatchedDEtaNLocMax1Neg[i]->SetXTitle("E_{cluster} (GeV)");
3417
3418       fhTrackMatchedDPhiNLocMax1Neg[i]  = new TH2F
3419       (Form("hTrackMatchedDPhiNLocMax1Neg%s",pname[i].Data()),
3420        Form("d#phi of cluster-track vs cluster energy, 1 Local Maxima, %s",ptype[i].Data()),
3421        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3422       fhTrackMatchedDPhiNLocMax1Neg[i]->SetYTitle("d#phi (rad)");
3423       fhTrackMatchedDPhiNLocMax1Neg[i]->SetXTitle("E_{cluster} (GeV)");
3424
3425       outputContainer->Add(fhTrackMatchedDEtaNLocMax1Neg[i]) ;
3426       outputContainer->Add(fhTrackMatchedDPhiNLocMax1Neg[i]) ;
3427
3428       fhTrackMatchedDEtaNLocMax2Neg[i]  = new TH2F
3429       (Form("hTrackMatchedDEtaNLocMax2Neg%s",pname[i].Data()),
3430        Form("d#eta of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
3431        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3432       fhTrackMatchedDEtaNLocMax2Neg[i]->SetYTitle("d#eta");
3433       fhTrackMatchedDEtaNLocMax2Neg[i]->SetXTitle("E_{cluster} (GeV)");
3434
3435       fhTrackMatchedDPhiNLocMax2Neg[i]  = new TH2F
3436       (Form("hTrackMatchedDPhiNLocMax2Neg%s",pname[i].Data()),
3437        Form("d#phi of cluster-track vs cluster energy, 2 Local Maxima, %s",ptype[i].Data()),
3438        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3439       fhTrackMatchedDPhiNLocMax2Neg[i]->SetYTitle("d#phi (rad)");
3440       fhTrackMatchedDPhiNLocMax2Neg[i]->SetXTitle("E_{cluster} (GeV)");
3441
3442       outputContainer->Add(fhTrackMatchedDEtaNLocMax2Neg[i]) ;
3443       outputContainer->Add(fhTrackMatchedDPhiNLocMax2Neg[i]) ;
3444
3445       fhTrackMatchedDEtaNLocMaxNNeg[i]  = new TH2F
3446       (Form("hTrackMatchedDEtaNLocMaxNNeg%s",pname[i].Data()),
3447        Form("d#eta of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
3448        nptbins,ptmin,ptmax,nresetabins,resetamin,resetamax);
3449       fhTrackMatchedDEtaNLocMaxNNeg[i]->SetYTitle("d#eta");
3450       fhTrackMatchedDEtaNLocMaxNNeg[i]->SetXTitle("E_{cluster} (GeV)");
3451
3452       fhTrackMatchedDPhiNLocMaxNNeg[i]  = new TH2F
3453       (Form("hTrackMatchedDPhiNLocMaxNNeg%s",pname[i].Data()),
3454        Form("d#phi of cluster-track vs cluster energy, N>2 Local Maxima, %s",ptype[i].Data()),
3455        nptbins,ptmin,ptmax,nresphibins,resphimin,resphimax);
3456       fhTrackMatchedDPhiNLocMaxNNeg[i]->SetYTitle("d#phi (rad)");
3457       fhTrackMatchedDPhiNLocMaxNNeg[i]->SetXTitle("E_{cluster} (GeV)");
3458
3459       outputContainer->Add(fhTrackMatchedDEtaNLocMaxNNeg[i]) ;
3460       outputContainer->Add(fhTrackMatchedDPhiNLocMaxNNeg[i]) ;
3461
3462     }
3463   }
3464
3465   if(fFillAngleHisto)
3466   {
3467     for(Int_t j = 0; j < nMatched; j++)
3468     {
3469
3470       fhAnglePairNLocMax1[j]  = new TH2F(Form("hAnglePairNLocMax1%s",sMatched[j].Data()),
3471                                          Form("Opening angle of 2 highest energy cells vs pair Energy, %s",sMatched[j].Data()),
3472                                          nptbins,ptmin,ptmax,200,0,0.2);
3473       fhAnglePairNLocMax1[j]->SetYTitle("#alpha (rad)");
3474       fhAnglePairNLocMax1[j]->SetXTitle("E (GeV)");
3475       outputContainer->Add(fhAnglePairNLocMax1[j]) ;
3476
3477       fhAnglePairNLocMax2[j]  = new TH2F(Form("hAnglePairNLocMax2%s",sMatched[j].Data()),
3478                                          Form("Opening angle of 2 local maxima cells vs Energy, %s",sMatched[j].Data()),
3479                                          nptbins,ptmin,ptmax,200,0,0.2);
3480       fhAnglePairNLocMax2[j]->SetYTitle("#alpha (rad)");
3481       fhAnglePairNLocMax2[j]->SetXTitle("E (GeV)");
3482       outputContainer->Add(fhAnglePairNLocMax2[j]) ;
3483
3484       fhAnglePairNLocMaxN[j]  = new TH2F(Form("hAnglePairNLocMaxN%s",sMatched[j].Data()),
3485                                          Form("Opening angle of N>2 local maxima cells vs Energy, %s",sMatched[j].Data()),
3486                                          nptbins,ptmin,ptmax,200,0,0.2);
3487       fhAnglePairNLocMaxN[j]->SetYTitle("#alpha (rad)");
3488       fhAnglePairNLocMaxN[j]->SetXTitle("E (GeV)");
3489       outputContainer->Add(fhAnglePairNLocMaxN[j]) ;
3490
3491       fhAnglePairMassNLocMax1[j]  = new TH2F(Form("hAnglePairMassNLocMax1%s",sMatched[j].Data()),
3492                                              Form("Opening angle of 2 highest energy cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
3493                                              mbins,mmin,mmax,200,0,0.2);
3494       fhAnglePairMassNLocMax1[j]->SetXTitle("M (GeV/c^{2})");
3495       fhAnglePairMassNLocMax1[j]->SetYTitle("#alpha (rad)");
3496       outputContainer->Add(fhAnglePairMassNLocMax1[j]) ;
3497
3498       fhAnglePairMassNLocMax2[j]  = new TH2F(Form("hAnglePairMassNLocMax2%s",sMatched[j].Data()),
3499                                              Form("Opening angle of 2 local maxima cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
3500                                              mbins,mmin,mmax,200,0,0.2);
3501       fhAnglePairMassNLocMax2[j]->SetXTitle("M (GeV/c^{2})");
3502       fhAnglePairMassNLocMax2[j]->SetYTitle("#alpha (rad)");
3503       outputContainer->Add(fhAnglePairMassNLocMax2[j]) ;
3504
3505       fhAnglePairMassNLocMaxN[j]  = new TH2F(Form("hAnglePairMassNLocMaxN%s",sMatched[j].Data()),
3506                                              Form("Opening angle of N>2 local maxima cells vs Mass for E > 12 GeV, %s",sMatched[j].Data()),
3507                                              mbins,mmin,mmax,200,0,0.2);
3508       fhAnglePairMassNLocMaxN[j]->SetXTitle("M (GeV/c^{2})");
3509       fhAnglePairMassNLocMaxN[j]->SetYTitle("#alpha (rad)");
3510       outputContainer->Add(fhAnglePairMassNLocMaxN[j]) ;
3511
3512     }
3513   }
3514
3515   for(Int_t j = 0; j < nMatched; j++)
3516   {
3517     fhSplitEFractionvsAsyNLocMax1[j]     = new TH2F(Form("hSplitEFractionvsAsyNLocMax1%s",sMatched[j].Data()),
3518                                                     Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max  = 1, E>12, %s",sMatched[j].Data()),
3519                                                     100,-1,1,120,0,1.2);
3520     fhSplitEFractionvsAsyNLocMax1[j]   ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
3521     fhSplitEFractionvsAsyNLocMax1[j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
3522     outputContainer->Add(fhSplitEFractionvsAsyNLocMax1[j]) ;
3523
3524     fhSplitEFractionvsAsyNLocMax2[j]     = new TH2F(Form("hSplitEFractionvsAsyNLocMax2%s",sMatched[j].Data()),
3525                                                     Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max  = 2,E>12, %s",sMatched[j].Data()),
3526                                                     100,-1,1,120,0,1.2);
3527     fhSplitEFractionvsAsyNLocMax2[j]   ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
3528     fhSplitEFractionvsAsyNLocMax2[j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
3529     outputContainer->Add(fhSplitEFractionvsAsyNLocMax2[j]) ;
3530
3531     fhSplitEFractionvsAsyNLocMaxN[j]    = new TH2F(Form("hSplitEFractionvsAsyNLocMaxN%s",sMatched[j].Data()),
3532                                                    Form("(E1+E2)/E_{cluster} vs (E_{split1}-E_{split2})/(E_{split1}+E_{split2}) for N max  > 2, E>12, %s",sMatched[j].Data()),
3533                                                    100,-1,1,120,0,1.2);
3534     fhSplitEFractionvsAsyNLocMaxN[j]   ->SetXTitle("(E_{split1}-E_{split2})/(E_{split1}+E_{split2})");
3535     fhSplitEFractionvsAsyNLocMaxN[j]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
3536     outputContainer->Add(fhSplitEFractionvsAsyNLocMaxN[j]) ;
3537   }
3538
3539
3540   fhClusterEtaPhiNLocMax1  = new TH2F
3541   ("hClusterEtaPhiNLocMax1","Neutral Clusters with E > 8 GeV, NLM = 1: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3542   fhClusterEtaPhiNLocMax1->SetYTitle("#phi (rad)");
3543   fhClusterEtaPhiNLocMax1->SetXTitle("#eta");
3544   outputContainer->Add(fhClusterEtaPhiNLocMax1) ;
3545
3546   fhClusterEtaPhiNLocMax2  = new TH2F
3547   ("hClusterEtaPhiNLocMax2","Neutral Clusters with E > 8 GeV, NLM = 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3548   fhClusterEtaPhiNLocMax2->SetYTitle("#phi (rad)");
3549   fhClusterEtaPhiNLocMax2->SetXTitle("#eta");
3550   outputContainer->Add(fhClusterEtaPhiNLocMax2) ;
3551
3552   fhClusterEtaPhiNLocMaxN  = new TH2F
3553   ("hClusterEtaPhiNLocMaxN","Neutral Clusters with E > 8 GeV, NLM > 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3554   fhClusterEtaPhiNLocMaxN->SetYTitle("#phi (rad)");
3555   fhClusterEtaPhiNLocMaxN->SetXTitle("#eta");
3556   outputContainer->Add(fhClusterEtaPhiNLocMaxN) ;
3557
3558   fhPi0EtaPhiNLocMax1  = new TH2F
3559   ("hPi0EtaPhiNLocMax1","Selected #pi^{0}'s with E > 8 GeV, NLM = 1: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3560   fhPi0EtaPhiNLocMax1->SetYTitle("#phi (rad)");
3561   fhPi0EtaPhiNLocMax1->SetXTitle("#eta");
3562   outputContainer->Add(fhPi0EtaPhiNLocMax1) ;
3563
3564   fhPi0EtaPhiNLocMax2  = new TH2F
3565   ("hPi0EtaPhiNLocMax2","Selected #pi^{0}'s with E > 8 GeV, NLM = 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3566   fhPi0EtaPhiNLocMax2->SetYTitle("#phi (rad)");
3567   fhPi0EtaPhiNLocMax2->SetXTitle("#eta");
3568   outputContainer->Add(fhPi0EtaPhiNLocMax2) ;
3569
3570   fhPi0EtaPhiNLocMaxN  = new TH2F
3571   ("hPi0EtaPhiNLocMaxN","Selected #pi^{0}'s with E > 8 GeV, NLM > 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3572   fhPi0EtaPhiNLocMaxN->SetYTitle("#phi (rad)");
3573   fhPi0EtaPhiNLocMaxN->SetXTitle("#eta");
3574   outputContainer->Add(fhPi0EtaPhiNLocMaxN) ;
3575
3576   if(fFillIdEtaHisto)
3577   {
3578     fhEtaEtaPhiNLocMax1  = new TH2F
3579     ("hEtaEtaPhiNLocMax1","Selected #eta's with E > 8 GeV, NLM = 1: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3580     fhEtaEtaPhiNLocMax1->SetYTitle("#phi (rad)");
3581     fhEtaEtaPhiNLocMax1->SetXTitle("#eta");
3582     outputContainer->Add(fhEtaEtaPhiNLocMax1) ;
3583
3584     fhEtaEtaPhiNLocMax2  = new TH2F
3585     ("hEtaEtaPhiNLocMax2","Selected #eta's with E > 8 GeV, NLM = 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3586     fhEtaEtaPhiNLocMax2->SetYTitle("#phi (rad)");
3587     fhEtaEtaPhiNLocMax2->SetXTitle("#eta");
3588     outputContainer->Add(fhEtaEtaPhiNLocMax2) ;
3589
3590     fhEtaEtaPhiNLocMaxN  = new TH2F
3591     ("hEtaEtaPhiNLocMaxN","Selected #eta's with E > 8 GeV, NLM > 2: #eta vs #phi",netabins,etamin,etamax, nphibins,phimin,phimax);
3592     fhEtaEtaPhiNLocMaxN->SetYTitle("#phi (rad)");
3593     fhEtaEtaPhiNLocMaxN->SetXTitle("#eta");
3594     outputContainer->Add(fhEtaEtaPhiNLocMaxN) ;
3595   }
3596
3597   TString snlm[] = {"1","2","N"};
3598
3599   if(fFillSSWeightHisto)
3600   {
3601     for(Int_t nlm = 0; nlm < 3; nlm++)
3602     {
3603       fhPi0CellE[nlm]  = new TH2F(Form("hPi0CellENLocMax%s",snlm[nlm].Data()),
3604                                   Form("Selected #pi^{0}'s, NLM = %s: cluster E vs cell E",snlm[nlm].Data()),
3605                                   nptbins,ptmin,ptmax, nptbins,ptmin,ptmax);
3606       fhPi0CellE[nlm]->SetYTitle("E_{cell}");
3607       fhPi0CellE[nlm]->SetXTitle("E_{cluster}");
3608       outputContainer->Add(fhPi0CellE[nlm]) ;
3609
3610       fhPi0CellEFrac[nlm]  = new TH2F(Form("hPi0CellEFracNLocMax%s",snlm[nlm].Data()),
3611                                       Form("Selected #pi^{0}'s, NLM = %s: cluster E vs cell E / cluster E",snlm[nlm].Data()),
3612                                       nptbins,ptmin,ptmax, 100,0,1);
3613       fhPi0CellEFrac[nlm]->SetYTitle("E_{cell} / E_{cluster}");
3614       fhPi0CellEFrac[nlm]->SetXTitle("E_{cluster}");
3615       outputContainer->Add(fhPi0CellEFrac[nlm]) ;
3616
3617       fhPi0CellLogEFrac[nlm]  = new TH2F(Form("hPi0CellLogEFracNLocMax%s",snlm[nlm].Data()),
3618                                          Form("Selected #pi^{0}'s, NLM = %s: cluster E vs Log(cell E / cluster E)",snlm[nlm].Data()),
3619                                          nptbins,ptmin,ptmax, 100,-10,0);
3620       fhPi0CellLogEFrac[nlm]->SetYTitle("Log(E_{cell} / E_{cluster})");
3621       fhPi0CellLogEFrac[nlm]->SetXTitle("E_{cluster}");
3622       outputContainer->Add(fhPi0CellLogEFrac[nlm]) ;
3623
3624
3625       fhPi0CellEMaxEMax2Frac[nlm]  = new TH2F(Form("hPi0CellEMaxEMax2FracNLocMax%s",snlm[nlm].Data()),
3626                                               Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 2nd loc. max. E / 1st loc. max.  E",snlm[nlm].Data()),
3627                                               nptbins,ptmin,ptmax, 100,0,1);
3628       fhPi0CellEMaxEMax2Frac[nlm]->SetYTitle("E_{Loc Max 2} / E_{Loc Max 1}");
3629       fhPi0CellEMaxEMax2Frac[nlm]->SetXTitle("E_{cluster}");
3630       outputContainer->Add(fhPi0CellEMaxEMax2Frac[nlm]) ;
3631
3632       fhPi0CellEMaxClusterFrac[nlm]  = new TH2F(Form("hPi0CellEMaxClusterFracNLocMax%s",snlm[nlm].Data()),
3633                                                 Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 1st loc. max. E / E cluster",snlm[nlm].Data()),
3634                                                 nptbins,ptmin,ptmax, 100,0,1);
3635       fhPi0CellEMaxClusterFrac[nlm]->SetYTitle("E_{Loc Max 1} / E_{cluster}");
3636       fhPi0CellEMaxClusterFrac[nlm]->SetXTitle("E_{cluster}");
3637       outputContainer->Add(fhPi0CellEMaxClusterFrac[nlm]) ;
3638
3639       fhPi0CellEMax2ClusterFrac[nlm]  = new TH2F(Form("hPi0CellEMax2ClusterFracNLocMax%s",snlm[nlm].Data()),
3640                                                  Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 2nd loc. max. E / E cluster",snlm[nlm].Data()),
3641                                                  nptbins,ptmin,ptmax, 100,0,1);
3642       fhPi0CellEMax2ClusterFrac[nlm]->SetYTitle("E_{Loc Max 2} / E_{cluster}");
3643       fhPi0CellEMax2ClusterFrac[nlm]->SetXTitle("E_{cluster}");
3644       outputContainer->Add(fhPi0CellEMax2ClusterFrac[nlm]) ;
3645
3646       fhPi0CellEMaxFrac[nlm]  = new TH2F(Form("hPi0CellEMaxFracNLocMax%s",snlm[nlm].Data()),
3647                                          Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 1st loc. max. E / E cell i",snlm[nlm].Data()),
3648                                          nptbins,ptmin,ptmax, 100,0,1);
3649       fhPi0CellEMaxFrac[nlm]->SetYTitle("E_{Loc Max 1} / E_{cell i}");
3650       fhPi0CellEMaxFrac[nlm]->SetXTitle("E_{cluster}");
3651       outputContainer->Add(fhPi0CellEMaxFrac[nlm]) ;
3652
3653       fhPi0CellEMax2Frac[nlm]  = new TH2F(Form("hPi0CellEMax2FracNLocMax%s",snlm[nlm].Data()),
3654                                           Form("Selected #pi^{0}'s, NLM = %s: cluster E vs 2nd loc. max. E / E cell i",snlm[nlm].Data()),
3655                                           nptbins,ptmin,ptmax, 200,0,2);
3656       fhPi0CellEMax2Frac[nlm]->SetYTitle("E_{Loc Max 2} / E_{cell i}");
3657       fhPi0CellEMax2Frac[nlm]->SetXTitle("E_{cluster}");
3658       outputContainer->Add(fhPi0CellEMax2Frac[nlm]) ;
3659
3660
3661       for(Int_t i = 0; i < fSSWeightN; i++)
3662       {
3663         fhM02WeightPi0[nlm][i]     = new TH2F(Form("hM02Pi0NLocMax%s_W%d",snlm[nlm].Data(),i),
3664                                               Form("#lambda_{0}^{2} vs E, with W0 = %2.2f, for NLM = %s", fSSWeight[i], snlm[nlm].Data()),
3665                                               nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3666         fhM02WeightPi0[nlm][i]   ->SetYTitle("#lambda_{0}^{2}");
3667         fhM02WeightPi0[nlm][i]   ->SetXTitle("E (GeV)");
3668         outputContainer->Add(fhM02WeightPi0[nlm][i]) ;
3669       }
3670
3671       for(Int_t i = 0; i < fSSECellCutN; i++)
3672       {
3673         fhM02ECellCutPi0[nlm][i]     = new TH2F(Form("hM02Pi0NLocMax%s_Ecell%d",snlm[nlm].Data(),i),
3674                                                 Form("#lambda_{0}^{2} vs E, with Ecell > %2.2f, for NLM = %s", fSSECellCut[i], snlm[nlm].Data()),
3675                                                 nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3676         fhM02ECellCutPi0[nlm][i]   ->SetYTitle("#lambda_{0}^{2}");
3677         fhM02ECellCutPi0[nlm][i]   ->SetXTitle("E (GeV)");
3678         outputContainer->Add(fhM02ECellCutPi0[nlm][i]) ;
3679       }
3680
3681     }
3682   }
3683
3684   Int_t tdbins   = GetHistogramRanges()->GetHistoDiffTimeBins() ;    Float_t tdmax  = GetHistogramRanges()->GetHistoDiffTimeMax();     Float_t tdmin  = GetHistogramRanges()->GetHistoDiffTimeMin();
3685
3686   fhPi0EPairDiffTimeNLM1 = new TH2F("hPi0EPairDiffTimeNLocMax1","cluster pair time difference vs E, selected #pi, NLM=1",nptbins,ptmin,ptmax, tdbins,tdmin,tdmax);
3687   fhPi0EPairDiffTimeNLM1->SetXTitle("E_{pair} (GeV)");
3688   fhPi0EPairDiffTimeNLM1->SetYTitle("#Delta t (ns)");
3689   outputContainer->Add(fhPi0EPairDiffTimeNLM1);
3690
3691   fhPi0EPairDiffTimeNLM2 = new TH2F("hPi0EPairDiffTimeNLocMax2","cluster pair time difference vs E, selected #pi, NLM=2",nptbins,ptmin,ptmax, tdbins,tdmin,tdmax);
3692   fhPi0EPairDiffTimeNLM2->SetXTitle("E_{pair} (GeV)");
3693   fhPi0EPairDiffTimeNLM2->SetYTitle("#Delta t (ns)");
3694   outputContainer->Add(fhPi0EPairDiffTimeNLM2);
3695
3696   fhPi0EPairDiffTimeNLMN = new TH2F("hPi0EPairDiffTimeNLocMaxN","cluster pair time difference vs E, selected #pi, NLM>2",nptbins,ptmin,ptmax, tdbins,tdmin,tdmax);
3697   fhPi0EPairDiffTimeNLMN->SetXTitle("E_{pair} (GeV)");
3698   fhPi0EPairDiffTimeNLMN->SetYTitle("#Delta t (ns)");
3699   outputContainer->Add(fhPi0EPairDiffTimeNLMN);
3700
3701   if(fFillIdEtaHisto)
3702   {
3703     fhEtaEPairDiffTimeNLM1 = new TH2F("hEtaEPairDiffTimeNLocMax1","cluster pair time difference vs E, selected #eta, NLM=1",nptbins,ptmin,ptmax, tdbins,tdmin,tdmax);
3704     fhEtaEPairDiffTimeNLM1->SetXTitle("E_{pair} (GeV)");
3705     fhEtaEPairDiffTimeNLM1->SetYTitle("#Delta t (ns)");
3706     outputContainer->Add(fhEtaEPairDiffTimeNLM1);
3707
3708     fhEtaEPairDiffTimeNLM2 = new TH2F("hEtaEPairDiffTimeNLocMax2","cluster pair time difference vs E, selected #eta, NLM=2",nptbins,ptmin,ptmax, tdbins,tdmin,tdmax);
3709     fhEtaEPairDiffTimeNLM2->SetXTitle("E_{pair} (GeV)");
3710     fhEtaEPairDiffTimeNLM2->SetYTitle("#Delta t (ns)");
3711     outputContainer->Add(fhEtaEPairDiffTimeNLM2);
3712
3713     fhEtaEPairDiffTimeNLMN = new TH2F("hEtaEPairDiffTimeNLocMaxN","cluster pair time difference vs E, selected #eta, NLM>2",nptbins,ptmin,ptmax, tdbins,tdmin,tdmax);
3714     fhEtaEPairDiffTimeNLMN->SetXTitle("E_{pair} (GeV)");
3715     fhEtaEPairDiffTimeNLMN->SetYTitle("#Delta t (ns)");
3716     outputContainer->Add(fhEtaEPairDiffTimeNLMN);
3717   }
3718
3719   if(fFillNCellHisto && IsDataMC())
3720   {
3721
3722     fhNCellMassEHighNLocMax1MCPi0 = new TH2F("hNCellMassEHighNLocMax1MCPi0","n cells vs mass for MC pi0, high energy, NLM=1",ncbins,ncmin,ncmax,mbins,mmin,mmax);
3723     fhNCellMassEHighNLocMax1MCPi0->SetYTitle("M (GeV/c^{2})");
3724     fhNCellMassEHighNLocMax1MCPi0->SetXTitle("n cells");
3725     outputContainer->Add(fhNCellMassEHighNLocMax1MCPi0) ;
3726
3727     fhNCellMassELowNLocMax1MCPi0 = new TH2F("hNCellMassELowNLocMax1MCPi0","n cells vs mass for MC pi0, low energy, NLM=1",ncbins,ncmin,ncmax,mbins,mmin,mmax);
3728     fhNCellMassELowNLocMax1MCPi0->SetYTitle("M (GeV/c^{2})");
3729     fhNCellMassELowNLocMax1MCPi0->SetXTitle("n cells");
3730     outputContainer->Add(fhNCellMassELowNLocMax1MCPi0) ;
3731
3732     fhNCellM02EHighNLocMax1MCPi0 = new TH2F("hNCellM02EHighNLocMax1MCPi0","n cells vs #lambda_{0}^{2} for MC pi0, high energy, NLM=1",ncbins,ncmin,ncmax,ssbins,ssmin,ssmax);
3733     fhNCellM02EHighNLocMax1MCPi0->SetYTitle("#lambda_{0}^{2}");
3734     fhNCellM02EHighNLocMax1MCPi0->SetXTitle("n cells");
3735     outputContainer->Add(fhNCellM02EHighNLocMax1MCPi0) ;
3736
3737     fhNCellM02ELowNLocMax1MCPi0 = new TH2F("hNCellM02ELowNLocMax1MCPi0","n cells vs #lambda_{0}^{2} for MC pi0, low energy, NLM=1",ncbins,ncmin,ncmax,ssbins,ssmin,ssmax);
3738     fhNCellM02ELowNLocMax1MCPi0->SetYTitle("#lambda_{0}^{2}");
3739     fhNCellM02ELowNLocMax1MCPi0->SetXTitle("n cells");
3740     outputContainer->Add(fhNCellM02ELowNLocMax1MCPi0) ;
3741
3742     fhNCellMassEHighNLocMax2MCPi0 = new TH2F("hNCellMassEHighNLocMax2MCPi0","n cells vs mass for MC pi0, high energy, NLM=2",ncbins,ncmin,ncmax,mbins,mmin,mmax);
3743     fhNCellMassEHighNLocMax2MCPi0->SetYTitle("M (GeV/c^{2})");
3744     fhNCellMassEHighNLocMax2MCPi0->SetXTitle("n cells");
3745     outputContainer->Add(fhNCellMassEHighNLocMax2MCPi0) ;
3746
3747     fhNCellMassELowNLocMax2MCPi0 = new TH2F("hNCellMassELowNLocMax2MCPi0","n cells vs mass for MC pi0, low energy, NLM=2",ncbins,ncmin,ncmax,mbins,mmin,mmax);
3748     fhNCellMassELowNLocMax2MCPi0->SetYTitle("M (GeV/c^{2})");
3749     fhNCellMassELowNLocMax2MCPi0->SetXTitle("n cells");
3750     outputContainer->Add(fhNCellMassELowNLocMax2MCPi0) ;
3751
3752     fhNCellM02EHighNLocMax2MCPi0 = new TH2F("hNCellM02EHighNLocMax2MCPi0","n cells vs #lambda_{0}^{2} for MC pi0, high energy, NLM=2",ncbins,ncmin,ncmax,ssbins,ssmin,ssmax);
3753     fhNCellM02EHighNLocMax2MCPi0->SetYTitle("#lambda_{0}^{2}");
3754     fhNCellM02EHighNLocMax2MCPi0->SetXTitle("n cells");
3755     outputContainer->Add(fhNCellM02EHighNLocMax2MCPi0) ;
3756
3757     fhNCellM02ELowNLocMax2MCPi0 = new TH2F("hNCellM02ELowNLocMax2MCPi0","n cells vs #lambda_{0}^{2} for MC pi0, low energy, NLM=2",ncbins,ncmin,ncmax,ssbins,ssmin,ssmax);
3758     fhNCellM02ELowNLocMax2MCPi0->SetYTitle("#lambda_{0}^{2}");
3759     fhNCellM02ELowNLocMax2MCPi0->SetXTitle("n cells");
3760     outputContainer->Add(fhNCellM02ELowNLocMax2MCPi0) ;
3761
3762     fhNCellMassEHighNLocMaxNMCPi0 = new TH2F("hNCellMassEHighNLocMaxNMCPi0","n cells vs mass for MC pi0, high energy, NLM>2",ncbins,ncmin,ncmax,mbins,mmin,mmax);
3763     fhNCellMassEHighNLocMaxNMCPi0->SetYTitle("M (GeV/c^{2})");
3764     fhNCellMassEHighNLocMaxNMCPi0->SetXTitle("n cells");
3765     outputContainer->Add(fhNCellMassEHighNLocMaxNMCPi0) ;
3766
3767     fhNCellMassELowNLocMaxNMCPi0 = new TH2F("hNCellMassELowNLocMaxNMCPi0","n cells vs mass for MC pi0, low energy, NLM>2",ncbins,ncmin,ncmax,mbins,mmin,mmax);
3768     fhNCellMassELowNLocMaxNMCPi0->SetYTitle("M (GeV/c^{2})");
3769     fhNCellMassELowNLocMaxNMCPi0->SetXTitle("n cells");
3770     outputContainer->Add(fhNCellMassELowNLocMaxNMCPi0) ;
3771
3772     fhNCellM02EHighNLocMaxNMCPi0 = new TH2F("hNCellM02EHighNLocMaxNMCPi0","n cells vs #lambda_{0}^{2} for MC pi0, high energy, NLM>2",ncbins,ncmin,ncmax,ssbins,ssmin,ssmax);
3773     fhNCellM02EHighNLocMaxNMCPi0->SetYTitle("#lambda_{0}^{2}");
3774     fhNCellM02EHighNLocMaxNMCPi0->SetXTitle("n cells");
3775     outputContainer->Add(fhNCellM02EHighNLocMaxNMCPi0) ;
3776
3777     fhNCellM02ELowNLocMaxNMCPi0 = new TH2F("hNCellM02ELowNLocMaxNMCPi0","n cells vs #lambda_{0}^{2} for MC pi0, low energy, NLM>2",ncbins,ncmin,ncmax,ssbins,ssmin,ssmax);
3778     fhNCellM02ELowNLocMaxNMCPi0->SetYTitle("#lambda_{0}^{2}");
3779     fhNCellM02ELowNLocMaxNMCPi0->SetXTitle("n cells");
3780     outputContainer->Add(fhNCellM02ELowNLocMaxNMCPi0) ;
3781
3782   }
3783
3784   if(IsDataMC() && fFillMCOverlapHisto)
3785   {
3786     for(Int_t i = 1; i < n; i++)
3787     {
3788       for(Int_t j = 0; j < 3; j++)
3789       {
3790         fhMCENOverlaps[j][i]     = new TH2F(Form("hMCENOverlapsNLocMax%s%s",snlm[j].Data(),pname[i].Data()),
3791                                             Form("# overlaps vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3792                                             nptbins,ptmin,ptmax,10,0,10);
3793         fhMCENOverlaps[j][i]   ->SetYTitle("# overlaps");
3794         fhMCENOverlaps[j][i]   ->SetXTitle("E (GeV)");
3795         outputContainer->Add(fhMCENOverlaps[j][i]) ;
3796
3797         fhMCEM02Overlap0[j][i]     = new TH2F(Form("hMCEM02Overlap0NLocMax%s%s",snlm[j].Data(),pname[i].Data()),
3798                                               Form("Overlap 0, #lambda_{0}^{2} vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3799                                               nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3800         fhMCEM02Overlap0[j][i]   ->SetYTitle("#lambda_{0}^{2}");
3801         fhMCEM02Overlap0[j][i]   ->SetXTitle("E (GeV)");
3802         outputContainer->Add(fhMCEM02Overlap0[j][i]) ;
3803
3804         fhMCEM02Overlap1[j][i]     = new TH2F(Form("hMCEM02Overlap1NLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3805                                               Form("Overlap 1, #lambda_{0}^{2} vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3806                                               nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3807         fhMCEM02Overlap1[j][i]   ->SetYTitle("#lambda_{0}^{2}");
3808         fhMCEM02Overlap1[j][i]   ->SetXTitle("E (GeV)");
3809         outputContainer->Add(fhMCEM02Overlap1[j][i]) ;
3810
3811         fhMCEM02OverlapN[j][i]     = new TH2F(Form("hMCEM02OverlapNNLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3812                                               Form("Overlap N, #lambda_{0}^{2} vs E for NLM=%s %s",snlm[j].Data(),ptype[i].Data()),
3813                                               nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3814         fhMCEM02OverlapN[j][i]   ->SetYTitle("#lambda_{0}^{2}");
3815         fhMCEM02OverlapN[j][i]   ->SetXTitle("E (GeV)");
3816         outputContainer->Add(fhMCEM02OverlapN[j][i]) ;
3817
3818         fhMCEMassOverlap0[j][i]     = new TH2F(Form("hMCEMassOverlap0NLocMax%s%s",snlm[j].Data(),pname[i].Data()),
3819                                                Form("Overlap 0, Mass vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3820                                                nptbins,ptmin,ptmax,mbins,mmin,mmax);
3821         fhMCEMassOverlap0[j][i]   ->SetYTitle("Mass (GeV/c^{2}");
3822         fhMCEMassOverlap0[j][i]   ->SetXTitle("E (GeV)");
3823         outputContainer->Add(fhMCEMassOverlap0[j][i]) ;
3824
3825         fhMCEMassOverlap1[j][i]     = new TH2F(Form("hMCEMassOverlap1NLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3826                                                Form("Overalap 1, Mass vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3827                                                nptbins,ptmin,ptmax,mbins,mmin,mmax);
3828         fhMCEMassOverlap1[j][i]   ->SetYTitle("Mass (GeV/c^{2}");
3829         fhMCEMassOverlap1[j][i]   ->SetXTitle("E (GeV)");
3830         outputContainer->Add(fhMCEMassOverlap1[j][i]) ;
3831
3832         fhMCEMassOverlapN[j][i]     = new TH2F(Form("hMCEMassOverlapNNLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3833                                                Form("Overlap N, Mass vs E for NLM=%s %s",snlm[j].Data(),ptype[i].Data()),
3834                                                nptbins,ptmin,ptmax,mbins,mmin,mmax);
3835         fhMCEMassOverlapN[j][i]   ->SetYTitle("Mass (GeV/c^{2})");
3836         fhMCEMassOverlapN[j][i]   ->SetXTitle("E (GeV)");
3837         outputContainer->Add(fhMCEMassOverlapN[j][i]) ;
3838
3839         fhMCEAsymOverlap0[j][i]     = new TH2F(Form("hMCEAsymOverlap0NLocMax%s%s",snlm[j].Data(),pname[i].Data()),
3840                                                Form("Overlap 0, Asymmetry vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3841                                                nptbins,ptmin,ptmax,100,0,1);
3842         fhMCEAsymOverlap0[j][i]   ->SetYTitle("|A|");
3843         fhMCEAsymOverlap0[j][i]   ->SetXTitle("E (GeV)");
3844         outputContainer->Add(fhMCEAsymOverlap0[j][i]) ;
3845
3846         fhMCEAsymOverlap1[j][i]     = new TH2F(Form("hMCEAsymOverlap1NLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3847                                                Form("Overalap 1, Asymmetry vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3848                                                nptbins,ptmin,ptmax,100,0,1);
3849         fhMCEAsymOverlap1[j][i]   ->SetYTitle("|A|");
3850         fhMCEAsymOverlap1[j][i]   ->SetXTitle("E (GeV)");
3851         outputContainer->Add(fhMCEAsymOverlap1[j][i]) ;
3852
3853         fhMCEAsymOverlapN[j][i]     = new TH2F(Form("hMCEAsymOverlapNNLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3854                                                Form("Overlap N, Asymmetry vs E for NLM=%s %s",snlm[j].Data(),ptype[i].Data()),
3855                                                nptbins,ptmin,ptmax,100,0,1);
3856         fhMCEAsymOverlapN[j][i]   ->SetYTitle("|A|");
3857         fhMCEAsymOverlapN[j][i]   ->SetXTitle("E (GeV)");
3858         outputContainer->Add(fhMCEAsymOverlapN[j][i]) ;
3859
3860
3861         fhMCENCellOverlap0[j][i]     = new TH2F(Form("hMCENCellOverlap0NLocMax%s%s",snlm[j].Data(),pname[i].Data()),
3862                                                Form("Overlap 0, n cells vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3863                                                nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
3864         fhMCENCellOverlap0[j][i]   ->SetYTitle("n cells");
3865         fhMCENCellOverlap0[j][i]   ->SetXTitle("E (GeV)");
3866         outputContainer->Add(fhMCENCellOverlap0[j][i]) ;
3867
3868         fhMCENCellOverlap1[j][i]     = new TH2F(Form("hMCENCellOverlap1NLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3869                                                Form("Overalap 1, n cells vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3870                                                nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
3871         fhMCENCellOverlap1[j][i]   ->SetYTitle("n cells");
3872         fhMCENCellOverlap1[j][i]   ->SetXTitle("E (GeV)");
3873         outputContainer->Add(fhMCENCellOverlap1[j][i]) ;
3874
3875         fhMCENCellOverlapN[j][i]     = new TH2F(Form("hMCENCellOverlapNNLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3876                                                Form("Overlap N, n cells vs E for NLM=%s %s",snlm[j].Data(),ptype[i].Data()),
3877                                                nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
3878         fhMCENCellOverlapN[j][i]   ->SetYTitle("n cells");
3879         fhMCENCellOverlapN[j][i]   ->SetXTitle("E (GeV)");
3880         outputContainer->Add(fhMCENCellOverlapN[j][i]) ;
3881
3882
3883         fhMCEEpriOverlap0[j][i]     = new TH2F(Form("hMCEEpriOverlap0NLocMax%s%s",snlm[j].Data(),pname[i].Data()),
3884                                                Form("Overlap 0, E reco vs E prim for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3885                                                nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
3886         fhMCEEpriOverlap0[j][i]   ->SetYTitle("E_{gen} (GeV)");
3887         fhMCEEpriOverlap0[j][i]   ->SetXTitle("E_{reco} (GeV)");
3888         outputContainer->Add(fhMCEEpriOverlap0[j][i]) ;
3889
3890         fhMCEEpriOverlap1[j][i]     = new TH2F(Form("hMCEEpriOverlap1NLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3891                                                Form("Overalap 1, E reco vs E prim for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3892                                                nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
3893         fhMCEEpriOverlap1[j][i]   ->SetYTitle("E_{gen} (GeV)");
3894         fhMCEEpriOverlap1[j][i]   ->SetXTitle("E_{reco} (GeV)");
3895         outputContainer->Add(fhMCEEpriOverlap1[j][i]) ;
3896
3897         fhMCEEpriOverlapN[j][i]     = new TH2F(Form("hMCEEpriOverlapNNLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3898                                                Form("Overlap N, E reco vs E prim for NLM=%s %s",snlm[j].Data(),ptype[i].Data()),
3899                                                nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
3900         fhMCEEpriOverlapN[j][i]   ->SetYTitle("E_{gen} (GeV)");
3901         fhMCEEpriOverlapN[j][i]   ->SetXTitle("E_{reco} (GeV)");
3902         outputContainer->Add(fhMCEEpriOverlapN[j][i]) ;
3903
3904
3905         fhMCEEpriOverlap0IdPi0[j][i]     = new TH2F(Form("hMCEEpriOverlap0IdPi0NLocMax%s%s",snlm[j].Data(),pname[i].Data()),
3906                                                Form("Overlap 0, E reco vs E prim for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3907                                                nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
3908         fhMCEEpriOverlap0IdPi0[j][i]   ->SetYTitle("E_{gen} (GeV)");
3909         fhMCEEpriOverlap0IdPi0[j][i]   ->SetXTitle("E_{reco} (GeV)");
3910         outputContainer->Add(fhMCEEpriOverlap0IdPi0[j][i]) ;
3911
3912         fhMCEEpriOverlap1IdPi0[j][i]     = new TH2F(Form("hMCEEpriOverlap1IdPi0NLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3913                                                Form("Overalap 1, E reco vs E prim for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3914                                                nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
3915         fhMCEEpriOverlap1IdPi0[j][i]   ->SetYTitle("E_{gen} (GeV)");
3916         fhMCEEpriOverlap1IdPi0[j][i]   ->SetXTitle("E_{reco} (GeV)");
3917         outputContainer->Add(fhMCEEpriOverlap1IdPi0[j][i]) ;
3918
3919         fhMCEEpriOverlapNIdPi0[j][i]     = new TH2F(Form("hMCEEpriOverlapNIdPi0NLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3920                                                Form("Overlap N, E reco vs E prim for NLM=%s %s",snlm[j].Data(),ptype[i].Data()),
3921                                                nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
3922         fhMCEEpriOverlapNIdPi0[j][i]   ->SetYTitle("E_{gen} (GeV)");
3923         fhMCEEpriOverlapNIdPi0[j][i]   ->SetXTitle("E_{reco} (GeV)");
3924         outputContainer->Add(fhMCEEpriOverlapNIdPi0[j][i]) ;
3925
3926
3927         fhMCESplitEFracOverlap0[j][i]     = new TH2F(Form("hMCESplitEFracOverlap0NLocMax%s%s",snlm[j].Data(),pname[i].Data()),
3928                                                      Form("Overlap 0, SplitEFrac vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3929                                                      nptbins,ptmin,ptmax,120,0,1.2);
3930         fhMCESplitEFracOverlap0[j][i]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
3931         fhMCESplitEFracOverlap0[j][i]   ->SetXTitle("E (GeV)");
3932         outputContainer->Add(fhMCESplitEFracOverlap0[j][i]) ;
3933
3934         fhMCESplitEFracOverlap1[j][i]     = new TH2F(Form("hMCESplitEFracOverlap1NLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3935                                                      Form("Overalap 1, SplitEFrac vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3936                                                      nptbins,ptmin,ptmax,120,0,1.2);
3937         fhMCESplitEFracOverlap1[j][i]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
3938         fhMCESplitEFracOverlap1[j][i]   ->SetXTitle("E (GeV)");
3939         outputContainer->Add(fhMCESplitEFracOverlap1[j][i]) ;
3940
3941         fhMCESplitEFracOverlapN[j][i]     = new TH2F(Form("hMCESplitEFracOverlapNNLocMax%s%s",snlm[j].Data(), pname[i].Data()),
3942                                                      Form("Overlap N, SplitEFrac vs E for NLM=%s %s",snlm[j].Data(),ptype[i].Data()),
3943                                                      nptbins,ptmin,ptmax,120,0,1.2);
3944         fhMCESplitEFracOverlapN[j][i]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
3945         fhMCESplitEFracOverlapN[j][i]   ->SetXTitle("E (GeV)");
3946         outputContainer->Add(fhMCESplitEFracOverlapN[j][i]) ;
3947
3948         if(i < 5)
3949         {
3950           fhMCPi0MassM02Overlap0[j][i-1]  = new TH2F(Form("hMCPi0MassM02Overlap0NLocMax%sEbin%d",snlm[j].Data(),i-1),
3951                                                      Form("Overlap 0, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d",snlm[j].Data(),i-1),
3952                                                      ssbins,ssmin,ssmax,mbins,mmin,mmax);
3953           fhMCPi0MassM02Overlap0[j][i-1]->SetYTitle("M (GeV/c^{2})");
3954           fhMCPi0MassM02Overlap0[j][i-1]->SetXTitle("#lambda_{0}^{2}");
3955           outputContainer->Add(fhMCPi0MassM02Overlap0[j][i-1]) ;
3956
3957           fhMCPi0MassM02Overlap1[j][i-1]  = new TH2F(Form("hMCPi0MassM02Overlap1NLocMax%sEbin%d",snlm[j].Data(),i-1),
3958                                                      Form("Overlap 1, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d",snlm[j].Data(),i-1),
3959                                                      ssbins,ssmin,ssmax,mbins,mmin,mmax);
3960           fhMCPi0MassM02Overlap1[j][i-1]->SetYTitle("M (GeV/c^{2})");
3961           fhMCPi0MassM02Overlap1[j][i-1]->SetXTitle("#lambda_{0}^{2}");
3962           outputContainer->Add(fhMCPi0MassM02Overlap1[j][i-1]) ;
3963
3964           fhMCPi0MassM02OverlapN[j][i-1]  = new TH2F(Form("hMCPi0MassM02OverlapNNLocMax%sEbin%d",snlm[j].Data(),i-1),
3965                                                      Form("Overlap N, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d",snlm[j].Data(),i-1),
3966                                                      ssbins,ssmin,ssmax,mbins,mmin,mmax);
3967           fhMCPi0MassM02OverlapN[j][i-1]->SetYTitle("M (GeV/c^{2})");
3968           fhMCPi0MassM02OverlapN[j][i-1]->SetXTitle("#lambda_{0}^{2}");
3969           outputContainer->Add(fhMCPi0MassM02OverlapN[j][i-1]) ;
3970         }
3971
3972         if(fFillTMHisto)
3973         {
3974           fhMCENOverlapsMatch[j][i]     = new TH2F(Form("hMCENOverlapsNLocMax%s%sMatched",snlm[j].Data(),pname[i].Data()),
3975                                                    Form("# overlaps vs E for NLM=%s, %s",snlm[j].Data(),ptype[i].Data()),
3976                                                    nptbins,ptmin,ptmax,10,0,10);
3977           fhMCENOverlapsMatch[j][i]   ->SetYTitle("# overlaps");
3978           fhMCENOverlapsMatch[j][i]   ->SetXTitle("E (GeV)");
3979           outputContainer->Add(fhMCENOverlapsMatch[j][i]) ;
3980
3981           fhMCEM02Overlap0Match[j][i]     = new TH2F(Form("hMCEM02Overlap0NLocMax%s%sMatched",snlm[j].Data(),pname[i].Data()),
3982                                                      Form("#lambda_{0}^{2} vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
3983                                                      nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3984           fhMCEM02Overlap0Match[j][i]   ->SetYTitle("#lambda_{0}^{2}");
3985           fhMCEM02Overlap0Match[j][i]   ->SetXTitle("E (GeV)");
3986           outputContainer->Add(fhMCEM02Overlap0Match[j][i]) ;
3987
3988           fhMCEM02Overlap1Match[j][i]     = new TH2F(Form("hMCEM02Overlap1NLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
3989                                                      Form("#lambda_{0}^{2} vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
3990                                                      nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3991           fhMCEM02Overlap1Match[j][i]   ->SetYTitle("#lambda_{0}^{2}");
3992           fhMCEM02Overlap1Match[j][i]   ->SetXTitle("E (GeV)");
3993           outputContainer->Add(fhMCEM02Overlap1Match[j][i]) ;
3994
3995           fhMCEM02OverlapNMatch[j][i]     = new TH2F(Form("hMCEM02OverlapNNLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
3996                                                      Form("#lambda_{0}^{2} vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
3997                                                      nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
3998           fhMCEM02OverlapNMatch[j][i]   ->SetYTitle("#lambda_{0}^{2}");
3999           fhMCEM02OverlapNMatch[j][i]   ->SetXTitle("E (GeV)");
4000           outputContainer->Add(fhMCEM02OverlapNMatch[j][i]) ;
4001
4002           fhMCEMassOverlap0Match[j][i]     = new TH2F(Form("hMCEMassOverlap0NLocMax%s%sMatched",snlm[j].Data(),pname[i].Data()),
4003                                                       Form("Mass vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4004                                                       nptbins,ptmin,ptmax,mbins,mmin,mmax);
4005           fhMCEMassOverlap0Match[j][i]   ->SetYTitle("Mass (GeV/c^{2}");
4006           fhMCEMassOverlap0Match[j][i]   ->SetXTitle("E (GeV)");
4007           outputContainer->Add(fhMCEMassOverlap0Match[j][i]) ;
4008
4009           fhMCEMassOverlap1Match[j][i]     = new TH2F(Form("hMCEMassOverlap1NLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4010                                                       Form("Mass vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4011                                                       nptbins,ptmin,ptmax,mbins,mmin,mmax);
4012           fhMCEMassOverlap1Match[j][i]   ->SetYTitle("Mass (GeV/c^{2}");
4013           fhMCEMassOverlap1Match[j][i]   ->SetXTitle("E (GeV)");
4014           outputContainer->Add(fhMCEMassOverlap1Match[j][i]) ;
4015
4016           fhMCEMassOverlapNMatch[j][i]     = new TH2F(Form("hMCEMassOverlapNNLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4017                                                       Form("Mass vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4018                                                       nptbins,ptmin,ptmax,mbins,mmin,mmax);
4019           fhMCEMassOverlapNMatch[j][i]   ->SetYTitle("Mass (GeV/c^{2}");
4020           fhMCEMassOverlapNMatch[j][i]   ->SetXTitle("E (GeV)");
4021           outputContainer->Add(fhMCEMassOverlapNMatch[j][i]) ;
4022
4023
4024           fhMCEAsymOverlap0Match[j][i]     = new TH2F(Form("hMCEAsymOverlap0NLocMax%s%sMatched",snlm[j].Data(),pname[i].Data()),
4025                                                       Form("Overlap 0, Asymmetry vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4026                                                       nptbins,ptmin,ptmax,100,0,1);
4027           fhMCEAsymOverlap0Match[j][i]   ->SetYTitle("|A|");
4028           fhMCEAsymOverlap0Match[j][i]   ->SetXTitle("E (GeV)");
4029           outputContainer->Add(fhMCEAsymOverlap0Match[j][i]) ;
4030
4031           fhMCEAsymOverlap1Match[j][i]     = new TH2F(Form("hMCEAsymOverlap1NLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4032                                                       Form("Overalap 1, Asymmetry vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4033                                                       nptbins,ptmin,ptmax,100,0,1);
4034           fhMCEAsymOverlap1Match[j][i]   ->SetYTitle("|A|");
4035           fhMCEAsymOverlap1Match[j][i]   ->SetXTitle("E (GeV)");
4036           outputContainer->Add(fhMCEAsymOverlap1Match[j][i]) ;
4037
4038           fhMCEAsymOverlapNMatch[j][i]     = new TH2F(Form("hMCEAsymOverlapNNLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4039                                                       Form("Overlap N, Asymmetry vs E for NLM=%s %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4040                                                       nptbins,ptmin,ptmax,100,0,1);
4041           fhMCEAsymOverlapNMatch[j][i]   ->SetYTitle("|A|");
4042           fhMCEAsymOverlapNMatch[j][i]   ->SetXTitle("E (GeV)");
4043           outputContainer->Add(fhMCEAsymOverlapNMatch[j][i]) ;
4044
4045
4046           fhMCENCellOverlap0Match[j][i]     = new TH2F(Form("hMCENCellOverlap0NLocMax%s%sMatched",snlm[j].Data(),pname[i].Data()),
4047                                                       Form("Overlap 0, n cells vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4048                                                       nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
4049           fhMCENCellOverlap0Match[j][i]   ->SetYTitle("n cells");
4050           fhMCENCellOverlap0Match[j][i]   ->SetXTitle("E (GeV)");
4051           outputContainer->Add(fhMCENCellOverlap0Match[j][i]) ;
4052
4053           fhMCENCellOverlap1Match[j][i]     = new TH2F(Form("hMCENCellOverlap1NLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4054                                                       Form("Overalap 1, n cell vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4055                                                       nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
4056           fhMCENCellOverlap1Match[j][i]   ->SetYTitle("n cells");
4057           fhMCENCellOverlap1Match[j][i]   ->SetXTitle("E (GeV)");
4058           outputContainer->Add(fhMCENCellOverlap1Match[j][i]) ;
4059
4060           fhMCENCellOverlapNMatch[j][i]     = new TH2F(Form("hMCENCellOverlapNNLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4061                                                       Form("Overlap N, n cell vs E for NLM=%s %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4062                                                       nptbins,ptmin,ptmax,ncbins,ncmin,ncmax);
4063           fhMCENCellOverlapNMatch[j][i]   ->SetYTitle("n cells");
4064           fhMCENCellOverlapNMatch[j][i]   ->SetXTitle("E (GeV)");
4065           outputContainer->Add(fhMCENCellOverlapNMatch[j][i]) ;
4066
4067           fhMCEEpriOverlap0Match[j][i]     = new TH2F(Form("hMCEEpriOverlap0NLocMax%s%sMatched",snlm[j].Data(),pname[i].Data()),
4068                                                       Form("Overlap 0, Asymmetry vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4069                                                       nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
4070           fhMCEEpriOverlap0Match[j][i]   ->SetYTitle("E_{gen} (GeV)");
4071           fhMCEEpriOverlap0Match[j][i]   ->SetXTitle("E_{reco} (GeV)");
4072           outputContainer->Add(fhMCEEpriOverlap0Match[j][i]) ;
4073
4074           fhMCEEpriOverlap1Match[j][i]     = new TH2F(Form("hMCEEpriOverlap1NLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4075                                                       Form("Overalap 1, Asymmetry vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4076                                                       nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
4077           fhMCEEpriOverlap1Match[j][i]   ->SetYTitle("E_{gen} (GeV)");
4078           fhMCEEpriOverlap1Match[j][i]   ->SetXTitle("E_{reco} (GeV)");
4079           outputContainer->Add(fhMCEEpriOverlap1Match[j][i]) ;
4080
4081           fhMCEEpriOverlapNMatch[j][i]     = new TH2F(Form("hMCEEpriOverlapNNLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4082                                                       Form("Overlap N, Asymmetry vs E for NLM=%s %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4083                                                       nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
4084           fhMCEEpriOverlapNMatch[j][i]   ->SetYTitle("E_{gen} (GeV)");
4085           fhMCEEpriOverlapNMatch[j][i]   ->SetXTitle("E_{reco} (GeV)");
4086           outputContainer->Add(fhMCEEpriOverlapNMatch[j][i]) ;
4087
4088
4089           fhMCESplitEFracOverlap0Match[j][i]     = new TH2F(Form("hMCESplitEFracOverlap0NLocMax%s%sMatched",snlm[j].Data(),pname[i].Data()),
4090                                                             Form("SplitEFrac vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4091                                                             nptbins,ptmin,ptmax,120,0,1.2);
4092           fhMCESplitEFracOverlap0Match[j][i]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
4093           fhMCESplitEFracOverlap0Match[j][i]   ->SetXTitle("E (GeV)");
4094           outputContainer->Add(fhMCESplitEFracOverlap0Match[j][i]) ;
4095
4096           fhMCESplitEFracOverlap1Match[j][i]     = new TH2F(Form("hMCESplitEFracOverlap1NLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4097                                                             Form("SplitEFrac vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4098                                                             nptbins,ptmin,ptmax,120,0,1.2);
4099           fhMCESplitEFracOverlap1Match[j][i]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
4100           fhMCESplitEFracOverlap1Match[j][i]   ->SetXTitle("E (GeV)");
4101           outputContainer->Add(fhMCESplitEFracOverlap1Match[j][i]) ;
4102
4103           fhMCESplitEFracOverlapNMatch[j][i]     = new TH2F(Form("hMCESplitEFracOverlapNNLocMax%s%sMatched",snlm[j].Data(), pname[i].Data()),
4104                                                             Form("SplitEFrac vs E for NLM=%s, %s, Track Matched",snlm[j].Data(),ptype[i].Data()),
4105                                                             nptbins,ptmin,ptmax,120,0,1.2);
4106           fhMCESplitEFracOverlapNMatch[j][i]   ->SetYTitle("(E_{split1}+E_{split2})/E_{cluster}");
4107           fhMCESplitEFracOverlapNMatch[j][i]   ->SetXTitle("E (GeV)");
4108           outputContainer->Add(fhMCESplitEFracOverlapNMatch[j][i]) ;
4109
4110
4111           if(i < 5)
4112           {
4113             fhMCPi0MassM02Overlap0Match[j][i-1]  = new TH2F(Form("hMCPi0MassM02Overlap0NLocMax%sEbin%dMatched",snlm[j].Data(),i-1),
4114                                                             Form("Overlap 0, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d, Track Matched",snlm[j].Data(),i-1),
4115                                                             ssbins,ssmin,ssmax,mbins,mmin,mmax);
4116             fhMCPi0MassM02Overlap0Match[j][i-1]->SetYTitle("M (GeV/c^{2})");
4117             fhMCPi0MassM02Overlap0Match[j][i-1]->SetXTitle("#lambda_{0}^{2}");
4118             outputContainer->Add(fhMCPi0MassM02Overlap0Match[j][i-1]) ;
4119
4120             fhMCPi0MassM02Overlap1Match[j][i-1]  = new TH2F(Form("hMCPi0MassM02Overlap1NLocMax%sEbin%dMatched",snlm[j].Data(),i-1),
4121                                                             Form("Overlap 1, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d, Track Matched",snlm[j].Data(),i-1),
4122                                                             ssbins,ssmin,ssmax,mbins,mmin,mmax);
4123             fhMCPi0MassM02Overlap1Match[j][i-1]->SetYTitle("M (GeV/c^{2})");
4124             fhMCPi0MassM02Overlap1Match[j][i-1]->SetXTitle("#lambda_{0}^{2}");
4125             outputContainer->Add(fhMCPi0MassM02Overlap1Match[j][i-1]) ;
4126
4127             fhMCPi0MassM02OverlapNMatch[j][i-1]  = new TH2F(Form("hMCPi0MassM02OverlapNNLocMax%sEbin%dMatched",snlm[j].Data(),i-1),
4128                                                             Form("Overlap N, Mass vs #lambda_{0}^{2}, NLM=%s, E bin %d, Track Matched",snlm[j].Data(),i-1),
4129                                                             ssbins,ssmin,ssmax,mbins,mmin,mmax);
4130             fhMCPi0MassM02OverlapNMatch[j][i-1]->SetYTitle("M (GeV/c^{2})");
4131             fhMCPi0MassM02OverlapNMatch[j][i-1]->SetXTitle("#lambda_{0}^{2}");
4132             outputContainer->Add(fhMCPi0MassM02OverlapNMatch[j][i-1]) ;
4133
4134           }
4135
4136         }
4137       }
4138     }
4139
4140     fhMCPi0HighNLMPair    = new TH2F("hMCPi0HighNLMPair","NLM vs E for merged pi0 cluster, high energy NLM pair are decays",
4141                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4142     fhMCPi0HighNLMPair   ->SetYTitle("N maxima");
4143     fhMCPi0HighNLMPair   ->SetXTitle("E (GeV)");
4144     outputContainer->Add(fhMCPi0HighNLMPair) ;
4145
4146     fhMCPi0LowNLMPair     = new TH2F("hMCPi0LowNLMPair","NLM vs E for merged pi0 cluster, lower energy NLM pair are decays",
4147                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4148     fhMCPi0LowNLMPair   ->SetYTitle("N maxima");
4149     fhMCPi0LowNLMPair   ->SetXTitle("E (GeV)");
4150     outputContainer->Add(fhMCPi0LowNLMPair) ;
4151
4152     fhMCPi0AnyNLMPair     = new TH2F("hMCPi0AnyNLMPair","NLM vs E for merged pi0 cluster, both high and other energy NLM pair are decays",
4153                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4154     fhMCPi0AnyNLMPair   ->SetYTitle("N maxima");
4155     fhMCPi0AnyNLMPair   ->SetXTitle("E (GeV)");
4156     outputContainer->Add(fhMCPi0AnyNLMPair) ;
4157
4158     fhMCPi0NoneNLMPair     = new TH2F("hMCPi0NoneNLMPair","NLM vs E for merged pi0 cluster, no NLM pair are decays",
4159                                       nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4160     fhMCPi0NoneNLMPair   ->SetYTitle("N maxima");
4161     fhMCPi0NoneNLMPair   ->SetXTitle("E (GeV)");
4162     outputContainer->Add(fhMCPi0NoneNLMPair) ;
4163
4164
4165     fhMCPi0HighNLMPairNoMCMatch    = new TH2F("hMCPi0HighNLMPairNoMCMatch","NLM vs E for merged pi0 cluster, high energy NLM pair are decays",
4166                                               nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4167     fhMCPi0HighNLMPairNoMCMatch   ->SetYTitle("N maxima");
4168     fhMCPi0HighNLMPairNoMCMatch   ->SetXTitle("E (GeV)");
4169     outputContainer->Add(fhMCPi0HighNLMPairNoMCMatch) ;
4170
4171     fhMCPi0LowNLMPairNoMCMatch     = new TH2F("hMCPi0LowNLMPairNoMCMatch","NLM vs E for merged pi0 cluster, lower energy NLM pair are decays",
4172                                               nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4173     fhMCPi0LowNLMPairNoMCMatch   ->SetYTitle("N maxima");
4174     fhMCPi0LowNLMPairNoMCMatch   ->SetXTitle("E (GeV)");
4175     outputContainer->Add(fhMCPi0LowNLMPairNoMCMatch) ;
4176
4177     fhMCPi0AnyNLMPairNoMCMatch     = new TH2F("hMCPi0AnyNLMPairNoMCMatch","NLM vs E for merged pi0 cluster, both high and other energy NLM pair are decays",
4178                                               nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4179     fhMCPi0AnyNLMPairNoMCMatch   ->SetYTitle("N maxima");
4180     fhMCPi0AnyNLMPairNoMCMatch   ->SetXTitle("E (GeV)");
4181     outputContainer->Add(fhMCPi0AnyNLMPairNoMCMatch) ;
4182
4183     fhMCPi0NoneNLMPairNoMCMatch     = new TH2F("hMCPi0NoneNLMPairNoMCMatch","NLM vs E for merged pi0 cluster, no NLM pair are decays",
4184                                                nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4185     fhMCPi0NoneNLMPairNoMCMatch   ->SetYTitle("N maxima");
4186     fhMCPi0NoneNLMPairNoMCMatch   ->SetXTitle("E (GeV)");
4187     outputContainer->Add(fhMCPi0NoneNLMPairNoMCMatch) ;
4188
4189
4190
4191
4192
4193     fhMCPi0HighNLMPairOverlap    = new TH2F("hMCPi0HighNLMPairOverlap","NLM vs E for merged pi0 cluster, high energy NLM pair are decays",
4194                                             nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4195     fhMCPi0HighNLMPairOverlap   ->SetYTitle("N maxima");
4196     fhMCPi0HighNLMPairOverlap   ->SetXTitle("E (GeV)");
4197     outputContainer->Add(fhMCPi0HighNLMPairOverlap) ;
4198
4199     fhMCPi0LowNLMPairOverlap     = new TH2F("hMCPi0LowNLMPairOverlap","NLM vs E for merged pi0 cluster, lower energy NLM pair are decays",
4200                                             nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4201     fhMCPi0LowNLMPairOverlap   ->SetYTitle("N maxima");
4202     fhMCPi0LowNLMPairOverlap   ->SetXTitle("E (GeV)");
4203     outputContainer->Add(fhMCPi0LowNLMPairOverlap) ;
4204
4205     fhMCPi0AnyNLMPairOverlap     = new TH2F("hMCPi0AnyNLMPairOverlap","NLM vs E for merged pi0 cluster, both high and other energy NLM pair are decays",
4206                                             nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4207     fhMCPi0AnyNLMPairOverlap   ->SetYTitle("N maxima");
4208     fhMCPi0AnyNLMPairOverlap   ->SetXTitle("E (GeV)");
4209     outputContainer->Add(fhMCPi0AnyNLMPairOverlap) ;
4210
4211     fhMCPi0NoneNLMPairOverlap     = new TH2F("hMCPi0NoneNLMPairOverlap","NLM vs E for merged pi0 cluster, no NLM pair are decays",
4212                                              nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4213     fhMCPi0NoneNLMPairOverlap   ->SetYTitle("N maxima");
4214     fhMCPi0NoneNLMPairOverlap   ->SetXTitle("E (GeV)");
4215     outputContainer->Add(fhMCPi0NoneNLMPairOverlap) ;
4216
4217     fhMCPi0HighNLMPairNoMCMatchOverlap    = new TH2F("hMCPi0HighNLMPairNoMCMatchOverlap","NLM vs E for merged pi0 cluster, high energy NLM pair are decays",
4218                                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4219     fhMCPi0HighNLMPairNoMCMatchOverlap   ->SetYTitle("N maxima");
4220     fhMCPi0HighNLMPairNoMCMatchOverlap   ->SetXTitle("E (GeV)");
4221     outputContainer->Add(fhMCPi0HighNLMPairNoMCMatchOverlap) ;
4222
4223     fhMCPi0LowNLMPairNoMCMatchOverlap     = new TH2F("hMCPi0LowNLMPairNoMCMatchOverlap","NLM vs E for merged pi0 cluster, lower energy NLM pair are decays",
4224                                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4225     fhMCPi0LowNLMPairNoMCMatchOverlap   ->SetYTitle("N maxima");
4226     fhMCPi0LowNLMPairNoMCMatchOverlap   ->SetXTitle("E (GeV)");
4227     outputContainer->Add(fhMCPi0LowNLMPairNoMCMatchOverlap) ;
4228
4229     fhMCPi0AnyNLMPairNoMCMatchOverlap     = new TH2F("hMCPi0AnyNLMPairNoMCMatchOverlap","NLM vs E for merged pi0 cluster, both high and other energy NLM pair are decays",
4230                                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4231     fhMCPi0AnyNLMPairNoMCMatchOverlap   ->SetYTitle("N maxima");
4232     fhMCPi0AnyNLMPairNoMCMatchOverlap   ->SetXTitle("E (GeV)");
4233     outputContainer->Add(fhMCPi0AnyNLMPairNoMCMatchOverlap) ;
4234
4235     fhMCPi0NoneNLMPairNoMCMatchOverlap     = new TH2F("hMCPi0NoneNLMPairNoMCMatchOverlap","NLM vs E for merged pi0 cluster, no NLM pair are decays",
4236                                                       nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4237     fhMCPi0NoneNLMPairNoMCMatchOverlap   ->SetYTitle("N maxima");
4238     fhMCPi0NoneNLMPairNoMCMatchOverlap   ->SetXTitle("E (GeV)");
4239     outputContainer->Add(fhMCPi0NoneNLMPairNoMCMatchOverlap) ;
4240
4241     fhMCPi0DecayPhotonHitHighLM    = new TH2F("hMCPi0DecayPhotonHitHighLM","NLM vs E for merged pi0 cluster, decay photon hit High Local Maxima",
4242                                               nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4243     fhMCPi0DecayPhotonHitHighLM    ->SetYTitle("N maxima");
4244     fhMCPi0DecayPhotonHitHighLM    ->SetXTitle("E (GeV)");
4245     outputContainer->Add(fhMCPi0DecayPhotonHitHighLM ) ;
4246
4247     fhMCPi0DecayPhotonAdjHighLM    = new TH2F("hMCPi0DecayPhotonAdjHighLM","NLM vs E for merged pi0 cluster, decay photon hit cells adjacent to High Local Maxima",
4248                                               nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4249     fhMCPi0DecayPhotonAdjHighLM    ->SetYTitle("N maxima");
4250     fhMCPi0DecayPhotonAdjHighLM    ->SetXTitle("E (GeV)");
4251     outputContainer->Add(fhMCPi0DecayPhotonAdjHighLM ) ;
4252
4253     fhMCPi0DecayPhotonHitOtherLM    = new TH2F("hMCPi0DecayPhotonHitOtherLM","NLM vs E for merged pi0 cluster, decay photon hit Other Local Maxima",
4254                                                nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4255     fhMCPi0DecayPhotonHitOtherLM    ->SetYTitle("N maxima");
4256     fhMCPi0DecayPhotonHitOtherLM    ->SetXTitle("E (GeV)");
4257     outputContainer->Add(fhMCPi0DecayPhotonHitOtherLM ) ;
4258
4259     fhMCPi0DecayPhotonAdjOtherLM    = new TH2F("hMCPi0DecayPhotonAdjOtherLM","NLM vs E for merged pi0 cluster, decay photon hit cells adjacent to Other Local Maxima",
4260                                                nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4261     fhMCPi0DecayPhotonAdjOtherLM    ->SetYTitle("N maxima");
4262     fhMCPi0DecayPhotonAdjOtherLM    ->SetXTitle("E (GeV)");
4263     outputContainer->Add(fhMCPi0DecayPhotonAdjOtherLM ) ;
4264
4265     fhMCPi0DecayPhotonAdjacent   = new TH2F("hMCPi0DecayPhotonAdjacent","NLM vs E for merged pi0 cluster, decay photon hit adjacent cells",
4266                                             nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4267     fhMCPi0DecayPhotonAdjacent    ->SetYTitle("N maxima");
4268     fhMCPi0DecayPhotonAdjacent    ->SetXTitle("E (GeV)");
4269     outputContainer->Add(fhMCPi0DecayPhotonAdjacent ) ;
4270
4271     fhMCPi0DecayPhotonHitNoLM    = new TH2F("hMCPi0DecayPhotonHitNoLM","NLM vs E for merged pi0 cluster, decay photon do not hit Local Maxima",
4272                                             nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4273     fhMCPi0DecayPhotonHitNoLM    ->SetYTitle("N maxima");
4274     fhMCPi0DecayPhotonHitNoLM    ->SetXTitle("E (GeV)");
4275     outputContainer->Add(fhMCPi0DecayPhotonHitNoLM ) ;
4276
4277
4278     fhMCPi0DecayPhotonHitHighLMOverlap    = new TH2F("hMCPi0DecayPhotonHitHighLMOverlap","NLM vs E for merged pi0 cluster, decay photon hit High Local Maxima, there was an overlap",
4279                                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4280     fhMCPi0DecayPhotonHitHighLMOverlap    ->SetYTitle("N maxima");
4281     fhMCPi0DecayPhotonHitHighLMOverlap    ->SetXTitle("E (GeV)");
4282     outputContainer->Add(fhMCPi0DecayPhotonHitHighLMOverlap ) ;
4283
4284     fhMCPi0DecayPhotonAdjHighLMOverlap    = new TH2F("hMCPi0DecayPhotonAdjHighLMOverlap","NLM vs E for merged pi0 cluster, decay photon hit cells adjacent to High Local Maxima, there was an overlap",
4285                                                      nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4286     fhMCPi0DecayPhotonAdjHighLMOverlap    ->SetYTitle("N maxima");
4287     fhMCPi0DecayPhotonAdjHighLMOverlap    ->SetXTitle("E (GeV)");
4288     outputContainer->Add(fhMCPi0DecayPhotonAdjHighLMOverlap ) ;
4289
4290     fhMCPi0DecayPhotonHitOtherLMOverlap    = new TH2F("hMCPi0DecayPhotonHitOtherLMOverlap","NLM vs E for merged pi0 cluster, decay photon hit Other Local Maxima, there was an overlap",
4291                                                       nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4292     fhMCPi0DecayPhotonHitOtherLMOverlap    ->SetYTitle("N maxima");
4293     fhMCPi0DecayPhotonHitOtherLMOverlap    ->SetXTitle("E (GeV)");
4294     outputContainer->Add(fhMCPi0DecayPhotonHitOtherLMOverlap ) ;
4295
4296     fhMCPi0DecayPhotonAdjOtherLMOverlap    = new TH2F("hMCPi0DecayPhotonAdjOtherLMOverlap","NLM vs E for merged pi0 cluster, decay photon hit cells adjacent to Other Local Maxima, there was an overlap",
4297                                                       nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4298     fhMCPi0DecayPhotonAdjOtherLMOverlap    ->SetYTitle("N maxima");
4299     fhMCPi0DecayPhotonAdjOtherLMOverlap    ->SetXTitle("E (GeV)");
4300     outputContainer->Add(fhMCPi0DecayPhotonAdjOtherLMOverlap ) ;
4301
4302     fhMCPi0DecayPhotonAdjacentOverlap   = new TH2F("hMCPi0DecayPhotonAdjacentOverlap","NLM vs E for merged pi0 cluster, decay photon hit adjacent cells, there was an overlap",
4303                                                    nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4304     fhMCPi0DecayPhotonAdjacentOverlap    ->SetYTitle("N maxima");
4305     fhMCPi0DecayPhotonAdjacentOverlap    ->SetXTitle("E (GeV)");
4306     outputContainer->Add(fhMCPi0DecayPhotonAdjacentOverlap ) ;
4307
4308     fhMCPi0DecayPhotonHitNoLMOverlap    = new TH2F("hMCPi0DecayPhotonHitNoLMOverlap","NLM vs E for merged pi0 cluster, decay photon do not hit Local Maxima, there was an overlap",
4309                                                    nptbins,ptmin,ptmax,nMaxBins,0,nMaxBins);
4310     fhMCPi0DecayPhotonHitNoLMOverlap    ->SetYTitle("N maxima");
4311     fhMCPi0DecayPhotonHitNoLMOverlap    ->SetXTitle("E (GeV)");
4312     outputContainer->Add(fhMCPi0DecayPhotonHitNoLMOverlap ) ;
4313
4314
4315     fhMCEOverlapType = new TH2F("hMCEOverlapType","Kind of overlap particle, neutral clusters",
4316                                 nptbins,ptmin,ptmax,5,0,5);
4317     //fhMCEOverlapType   ->SetYTitle("Overlap Type");
4318     fhMCEOverlapType->GetYaxis()->SetBinLabel(1 ,"#gamma");
4319     fhMCEOverlapType->GetYaxis()->SetBinLabel(2 ,"e^{#pm}");
4320     fhMCEOverlapType->GetYaxis()->SetBinLabel(3 ,"hadron^{#pm}");
4321     fhMCEOverlapType->GetYaxis()->SetBinLabel(4 ,"hadron^{0}");
4322     fhMCEOverlapType->GetYaxis()->SetBinLabel(5 ,"??");
4323     fhMCEOverlapType->SetXTitle("Cluster E (GeV)");
4324     outputContainer->Add(fhMCEOverlapType) ;
4325
4326     fhMCEOverlapTypeMatch = new TH2F("hMCEOverlapTypeMatched","Kind of overlap particle, charged clusters",
4327                                      nptbins,ptmin,ptmax,5,0,5);
4328     //fhMCEOverlapTypeMatch   ->SetYTitle("Overlap Type");
4329     fhMCEOverlapTypeMatch->GetYaxis()->SetBinLabel(1 ,"#gamma");
4330     fhMCEOverlapTypeMatch->GetYaxis()->SetBinLabel(2 ,"e^{#pm}");
4331     fhMCEOverlapTypeMatch->GetYaxis()->SetBinLabel(3 ,"hadron^{#pm}");
4332     fhMCEOverlapTypeMatch->GetYaxis()->SetBinLabel(4 ,"hadron^{0}");
4333     fhMCEOverlapTypeMatch->GetYaxis()->SetBinLabel(5 ,"??");
4334     fhMCEOverlapTypeMatch->SetXTitle("Cluster E (GeV)");
4335     outputContainer->Add(fhMCEOverlapTypeMatch) ;
4336
4337   }// MC analysis, check overlaps
4338
4339   return outputContainer ;
4340
4341 }
4342
4343 //_____________________________________________________________________________
4344 void AliAnaInsideClusterInvariantMass::GetMCIndex(AliVCluster* cluster,
4345                                                   Int_t & mcindex, Int_t & tag)
4346 {
4347
4348   // Assign mc index depending on MC bit set, to be used in histograms arrays
4349
4350   tag   = GetMCAnalysisUtils()->CheckOrigin(cluster->GetLabels(),cluster->GetNLabels(), GetReader());
4351
4352   if      ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0) &&
4353            !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPi0;
4354   else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0)  )      mcindex = kmcPi0Conv;
4355   else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEta)  )      mcindex = kmcEta;
4356   else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
4357            !GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcPhoton;
4358   else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPhoton) &&
4359             GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)) mcindex = kmcConversion;
4360   else if ( GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron))   mcindex = kmcElectron;
4361   else                                                                                mcindex = kmcHadron;
4362
4363 }
4364
4365
4366 //______________________________________________________________________________________________________________
4367 void AliAnaInsideClusterInvariantMass::GetMCPrimaryKine(AliVCluster* cluster, const Int_t mcindex,
4368                                                         const Int_t mctag, const Bool_t matched,
4369                                                         Float_t & eprim, Float_t & asymGen, Int_t & noverlaps )
4370 {
4371   // Check origin of the candidates, get primary kinematics if overlapped meson decay
4372
4373   Bool_t ok      = kFALSE;
4374   Int_t  mcLabel = cluster->GetLabel();
4375
4376   TLorentzVector primary = GetMCAnalysisUtils()->GetMother(mcLabel,GetReader(),ok);
4377   eprim = primary.E();
4378
4379   Int_t mesonLabel = -1;
4380
4381   if(mcindex == kmcPi0 || mcindex == kmcEta || mcindex == kmcPi0Conv)
4382   {
4383     if(mcindex == kmcPi0 || mcindex == kmcPi0Conv)
4384     {
4385       asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,111,GetReader(),ok));
4386       TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,111,GetReader(),ok,mesonLabel);
4387       if(grandmom.E() > 0 && ok) eprim =  grandmom.E();
4388     }
4389     else
4390     {
4391       asymGen = TMath::Abs(GetMCAnalysisUtils()->GetMCDecayAsymmetryForPDG(mcLabel,221,GetReader(),ok));
4392       TLorentzVector grandmom = GetMCAnalysisUtils()->GetMotherWithPDG(mcLabel,221,GetReader(),ok,mesonLabel);
4393       if(grandmom.E() > 0 && ok) eprim =  grandmom.E();
4394     }
4395   }
4396
4397   if(!fFillMCOverlapHisto) return;
4398
4399   const UInt_t nlabels = cluster->GetNLabels();
4400   Int_t overpdg[nlabels];
4401   noverlaps = GetMCAnalysisUtils()->GetNOverlaps(cluster->GetLabels(), nlabels,mctag,mesonLabel,GetReader(),overpdg);
4402
4403   for(Int_t iover = 0; iover < noverlaps; iover++)
4404   {
4405     Float_t histobin = -1;
4406     Int_t   mpdg     = overpdg[iover];
4407
4408     if     (mpdg==22)      histobin = 0.5;
4409     else if(TMath::Abs(mpdg)==11) histobin = 1.5;
4410     else if(mpdg==-999999) histobin = 4.5;
4411     else
4412     {
4413       Double_t charge = TDatabasePDG::Instance()->GetParticle(mpdg)->Charge();
4414       if(TMath::Abs(charge) > 0 ) histobin = 2.5;
4415       else                        histobin = 3.5;
4416       //printf("charge %f\n",charge);
4417     }
4418
4419     //printf("\t pdg = %d, histobin %2.1f\n",mpdg,histobin);
4420     if(histobin > 0)
4421     {
4422       if(matched)fhMCEOverlapType     ->Fill(cluster->E(),histobin);
4423       else       fhMCEOverlapTypeMatch->Fill(cluster->E(),histobin);
4424     }
4425   }
4426 }
4427
4428 //___________________________________________
4429 void AliAnaInsideClusterInvariantMass::Init()
4430 {
4431   //Init
4432   //Do some checks
4433   if(fCalorimeter == "PHOS" && !GetReader()->IsPHOSSwitchedOn() && NewOutputAOD())
4434   {
4435     printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!\n");
4436     abort();
4437   }
4438   else  if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn() && NewOutputAOD())
4439   {
4440     printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!\n");
4441     abort();
4442   }
4443
4444   if( GetReader()->GetDataType() == AliCaloTrackReader::kMC )
4445   {
4446     printf("AliAnaInsideClusterInvariantMass::Init() - !!STOP: You want to use pure MC data!!\n");
4447     abort();
4448
4449   }
4450
4451 }
4452
4453 //_____________________________________________________
4454 void AliAnaInsideClusterInvariantMass::InitParameters()
4455 {
4456   //Initialize the parameters of the analysis.
4457   AddToHistogramsName("AnaPi0InsideClusterInvariantMass_");
4458
4459   fCalorimeter = "EMCAL" ;
4460
4461   fMinNCells   = 4 ;
4462   fMinBadDist  = 2 ;
4463
4464   fHistoECut   = 8 ;
4465
4466   fSSWeightN   = 5;
4467   fSSWeight[0] = 4.6;  fSSWeight[1] = 4.7; fSSWeight[2] = 4.8; fSSWeight[3] = 4.9; fSSWeight[4] = 5.0;
4468   fSSWeight[5] = 5.1;  fSSWeight[6] = 5.2; fSSWeight[7] = 5.3; fSSWeight[8] = 5.4; fSSWeight[9] = 5.5;
4469
4470   fSSECellCutN   = 10;
4471   fSSECellCut[0] = 0.16;  fSSECellCut[1] = 0.18; fSSECellCut[2] = 0.2; fSSECellCut[3] = 0.22; fSSECellCut[4] = 0.24;
4472   fSSECellCut[5] = 0.26;  fSSECellCut[6] = 0.28; fSSECellCut[7] = 0.3; fSSECellCut[8] = 0.32; fSSECellCut[9] = 0.34;
4473
4474 }
4475
4476
4477 //__________________________________________________________________
4478 void  AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()
4479 {
4480   //Search for pi0 in fCalorimeter with shower shape analysis
4481
4482   TObjArray * pl       = 0x0;
4483   AliVCaloCells* cells = 0x0;
4484
4485   //Select the Calorimeter of the photon
4486   if(fCalorimeter == "PHOS")
4487   {
4488     pl    = GetPHOSClusters();
4489     cells = GetPHOSCells();
4490   }
4491   else if (fCalorimeter == "EMCAL")
4492   {
4493     pl    = GetEMCALClusters();
4494     cells = GetEMCALCells();
4495   }
4496
4497   if(!pl || !cells)
4498   {
4499     Info("MakeAnalysisFillHistograms","TObjArray with %s clusters is NULL!\n",fCalorimeter.Data());
4500     return;
4501   }
4502
4503         if(fCalorimeter == "PHOS") return; // Not implemented for PHOS yet
4504
4505   for(Int_t icluster = 0; icluster < pl->GetEntriesFast(); icluster++)
4506   {
4507     AliVCluster * cluster = (AliVCluster*) (pl->At(icluster));
4508
4509     //-------------------------------------------
4510     // Get cluster parameters, do some rejection
4511     //-------------------------------------------
4512
4513     Float_t en = cluster->E();
4514     Float_t l0 = cluster->GetM02();
4515     Int_t   nc = cluster->GetNCells();
4516     Float_t bd = cluster->GetDistanceToBadChannel() ;
4517
4518     //If too small or big E or low number of cells, or close to a bad channel skip it
4519
4520     if( en < GetMinEnergy() || en > GetMaxEnergy() || nc < fMinNCells || bd < fMinBadDist) continue ;
4521
4522     //printf("en %2.3f  GetMinEnergy() %2.3f, GetMaxEnergy() %2.3f , nc %d fMinNCells %d\n",en, GetMinEnergy(),GetMaxEnergy(),nc ,fMinNCells);
4523
4524     // Track-cluster matching
4525
4526     Bool_t  matched   = IsTrackMatched(cluster,GetReader()->GetInputEvent());
4527     if(!fFillTMHisto && matched) continue ;
4528
4529     // Get cluster angles
4530
4531     TLorentzVector lv;
4532     cluster->GetMomentum(lv, GetVertex(0));
4533     Float_t eta = lv.Eta();
4534     Float_t phi = lv.Phi();
4535     if(phi<0) phi=+TMath::TwoPi();
4536
4537     //printf("en %2.2f, GetMinEnergy() %2.2f, GetMaxEnergy() %2.2f, nc %d, fMinNCells %d,  bd %2.2f, fMinBadDist %2.2f\n",
4538     //       en,GetMinEnergy(), GetMaxEnergy(), nc, fMinNCells, bd, fMinBadDist);
4539
4540     // Get PID, N local maximum, *** split cluster ***
4541
4542     Int_t    nMax = 0;
4543     Double_t mass = 0., angle = 0.;
4544     TLorentzVector    l1, l2;
4545     Int_t    absId1   =-1; Int_t   absId2   =-1;
4546     Float_t  distbad1 =-1; Float_t distbad2 =-1;
4547     Bool_t   fidcut1  = 0; Bool_t  fidcut2  = 0;
4548
4549     Int_t pidTag = GetCaloPID()->GetIdentifiedParticleTypeFromClusterSplitting(cluster,cells,GetCaloUtils(),
4550                                                                                GetVertex(0), nMax, mass, angle,
4551                                                                                l1,l2,absId1,absId2,
4552                                                                                distbad1,distbad2,fidcut1,fidcut2);
4553     if (nMax <= 0)
4554     {
4555       if(GetDebug() > 0 )
4556         printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - No local maximum found! It did not pass CaloPID selection criteria \n");
4557
4558       continue;
4559     }
4560
4561     // Skip events where one of the new clusters (lowest energy) is close to an EMCal border or a bad channel
4562     if( (fCheckSplitDistToBad) &&
4563         (!fidcut2 || !fidcut1 || distbad1 < fMinBadDist || distbad2 < fMinBadDist))
4564     {
4565       if(GetDebug() > 1)
4566         printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms()  - Dist to bad channel cl1 %f, cl2 %f; fid cl1 %d, cl2 %d \n",
4567                                  distbad1,distbad2, fidcut1,fidcut2);
4568       continue ;
4569     }
4570
4571     // Set some index for array histograms
4572
4573     Int_t inlm = -1;
4574     if     (nMax == 1) inlm = 0;
4575     else if(nMax == 2) inlm = 1;
4576     else if(nMax >  2) inlm = 2;
4577     else printf("Wrong N local maximum -> %d, n cells in cluster %d \n",nMax,nc);
4578
4579     // Get sub-cluster parameters
4580
4581     Float_t e1 = l1.Energy();
4582     Float_t e2 = l2.Energy();
4583
4584     Double_t tof1  = cells->GetCellTime(absId1);
4585     GetCaloUtils()->RecalibrateCellTime(tof1, fCalorimeter, absId1,GetReader()->GetInputEvent()->GetBunchCrossNumber());
4586     tof1*=1.e9;
4587
4588     Double_t tof2  = cells->GetCellTime(absId2);
4589     GetCaloUtils()->RecalibrateCellTime(tof2, fCalorimeter, absId2,GetReader()->GetInputEvent()->GetBunchCrossNumber());
4590     tof2*=1.e9;
4591
4592     Double_t t12diff = tof1-tof2;
4593
4594     Float_t splitFrac = (e1+e2)/en;
4595
4596     Float_t asym = -10;
4597     if(e1+e2>0) asym = (e1-e2)/(e1+e2);
4598
4599     //
4600
4601     Int_t ebin = -1;
4602     if(en > 8  && en <= 12) ebin = 0;
4603     if(en > 12 && en <= 16) ebin = 1;
4604     if(en > 16 && en <= 20) ebin = 2;
4605     if(en > 20)             ebin = 3;
4606
4607     // MC data histograms and some related calculations
4608     // mc tag, n overlaps, asym of generated mesons
4609
4610     Int_t mcindex   = -1;
4611     Int_t mctag     = -1;
4612     Float_t eprim   = -1;
4613     Float_t asymGen = -2;
4614     Int_t noverlaps =  0;
4615
4616     if(IsDataMC())
4617     {
4618       // MC indexes
4619
4620       GetMCIndex(cluster,mcindex,mctag);
4621
4622       // MC primary kine, generation fractions
4623
4624       GetMCPrimaryKine(cluster,mcindex,mctag,matched,eprim,asymGen,noverlaps);
4625
4626       // For cluster with MC pi0 and more than 1 maxima
4627
4628       if(fFillMCOverlapHisto)
4629         CheckLocalMaximaMCOrigin(cluster, mcindex,noverlaps);
4630                                  //mass, l0, l1, l2);
4631
4632       //
4633
4634      if(fFillMCHisto)
4635        FillMCHistograms(en,e1,e2,ebin,mcindex,noverlaps,l0,mass,
4636                         nMax,matched,splitFrac, asym, eprim,asymGen);
4637
4638       //
4639
4640       if(fFillMCOverlapHisto)
4641         FillMCOverlapHistograms(en,eprim,nc,mass,l0,asym,splitFrac,inlm,ebin,matched,mcindex,noverlaps);
4642     }
4643
4644     //
4645
4646     FillHistograms1(en, e1, e2, nMax, mass, l0, eta, phi, matched, mcindex);
4647
4648     //
4649
4650     if(fFillNCellHisto)
4651       FillNCellHistograms(nc,en, nMax,matched, mcindex,mass,l0);
4652
4653     //
4654
4655     if(fFillSSExtraHisto)
4656     FillSSExtraHistograms(cluster, nMax, matched,mcindex,mass,ebin)  ;
4657
4658     //
4659
4660     if(!matched && ebin > 0 && fFillEbinHisto)
4661       FillEBinHistograms(ebin,nMax,mcindex,splitFrac,mass,asym,l0);
4662
4663     //
4664
4665     if(fFillAngleHisto)
4666       FillAngleHistograms(matched,nMax,en,angle,mass);
4667
4668     //---------------------------------------------------------------------
4669     // From here start applying some cuts
4670     //---------------------------------------------------------------------
4671
4672     FillHistograms2(en, eprim, e1, e2, nMax, mass, l0, matched, mcindex);
4673
4674     if(pidTag==AliCaloPID::kPi0)
4675     {
4676       FillIdPi0Histograms(en, e1, e2, nc, nMax, t12diff, mass, l0, eta, phi, matched, mcindex);
4677
4678       if(fFillSSWeightHisto)
4679         FillSSWeightHistograms(cluster, inlm, absId1, absId2);
4680
4681       if(fFillTMHisto && fFillTMResidualHisto)
4682         FillTrackMatchingHistograms(cluster,nMax,mcindex);
4683
4684       if(fFillMCOverlapHisto && IsDataMC() && !matched)
4685       {
4686         if     (noverlaps == 0) fhMCEEpriOverlap0IdPi0 [inlm][mcindex]->Fill(en, eprim);
4687         else if(noverlaps == 1) fhMCEEpriOverlap1IdPi0 [inlm][mcindex]->Fill(en, eprim);
4688         else if(noverlaps  > 1) fhMCEEpriOverlapNIdPi0 [inlm][mcindex]->Fill(en, eprim);
4689       }
4690     }
4691     else if(fFillIdEtaHisto && pidTag==AliCaloPID::kEta)
4692     {
4693       FillIdEtaHistograms(en, e1, e2, nc, nMax, t12diff, mass, l0, eta, phi, matched, mcindex);
4694     }
4695     else if(fFillIdConvHisto && pidTag==AliCaloPID::kPhoton)
4696     {
4697       FillIdConvHistograms(en, nMax, asym, mass, l0, matched, mcindex);
4698     }
4699
4700   }//loop
4701
4702   if(GetDebug() > 1) printf("AliAnaInsideClusterInvariantMass::MakeAnalysisFillHistograms() - END \n");
4703
4704 }
4705
4706 //______________________________________________________________________
4707 void AliAnaInsideClusterInvariantMass::Print(const Option_t * opt) const
4708 {
4709   //Print some relevant parameters set for the analysis
4710   if(! opt)
4711     return;
4712
4713   printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
4714   AliAnaCaloTrackCorrBaseClass::Print("");
4715   printf("Calorimeter     =     %s\n",  fCalorimeter.Data()) ;
4716   if(GetCaloUtils()) printf("Loc. Max. E > %2.2f\n",       GetCaloUtils()->GetLocalMaximaCutE());
4717   if(GetCaloUtils()) printf("Loc. Max. E Diff > %2.2f\n",  GetCaloUtils()->GetLocalMaximaCutEDiff());
4718   printf("Min. N Cells =%d \n",         fMinNCells) ;
4719   printf("Min. Dist. to Bad =%1.1f \n", fMinBadDist) ;
4720   if(fFillSSWeightHisto) printf(" N w %d - N e cut %d \n",fSSWeightN,fSSECellCutN);
4721
4722   printf("    \n") ;
4723
4724 }
4725
4726 //___________________________________________________________________________________________________________________
4727 void AliAnaInsideClusterInvariantMass::RecalculateClusterShowerShapeParametersWithCellCut(const AliEMCALGeometry * geom,
4728                                                                                           AliVCaloCells* cells,
4729                                                                                           AliVCluster * cluster,
4730                                                                                           Float_t & l0,   Float_t & l1,
4731                                                                                           Float_t & disp, Float_t & dEta, Float_t & dPhi,
4732                                                                                           Float_t & sEta, Float_t & sPhi, Float_t & sEtaPhi,
4733                                                                                           Float_t eCellMin)
4734 {
4735   // Calculates new center of gravity in the local EMCAL-module coordinates
4736   // and tranfers into global ALICE coordinates
4737   // Calculates Dispersion and main axis
4738
4739   if(!cluster)
4740   {
4741     AliInfo("Cluster pointer null!");
4742     return;
4743   }
4744
4745   Double_t eCell       = 0.;
4746   Float_t  fraction    = 1.;
4747   Float_t  recalFactor = 1.;
4748
4749   Int_t    iSupMod = -1;
4750   Int_t    iTower  = -1;
4751   Int_t    iIphi   = -1;
4752   Int_t    iIeta   = -1;
4753   Int_t    iphi    = -1;
4754   Int_t    ieta    = -1;
4755   Double_t etai    = -1.;
4756   Double_t phii    = -1.;
4757
4758   Int_t    nstat   = 0 ;
4759   Float_t  wtot    = 0.;
4760   Double_t w       = 0.;
4761   Double_t etaMean = 0.;
4762   Double_t phiMean = 0.;
4763
4764   //Loop on cells, calculate the cluster energy, in case a cut on cell energy is added
4765   // and to check if the cluster is between 2 SM in eta
4766   Int_t   iSM0   = -1;
4767   Bool_t  shared = kFALSE;
4768   Float_t energy = 0;
4769
4770   for(Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++)
4771   {
4772     //Get from the absid the supermodule, tower and eta/phi numbers
4773     geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta);
4774     geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);
4775
4776     //Check if there are cells of different SM
4777     if     (iDigit == 0   ) iSM0 = iSupMod;
4778     else if(iSupMod!= iSM0) shared = kTRUE;
4779
4780     //Get the cell energy, if recalibration is on, apply factors
4781     fraction  = cluster->GetCellAmplitudeFraction(iDigit);
4782     if(fraction < 1e-4) fraction = 1.; // in case unfolding is off
4783
4784     if(GetCaloUtils()->GetEMCALRecoUtils()->IsRecalibrationOn())
4785     {
4786       recalFactor = GetCaloUtils()->GetEMCALRecoUtils()->GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
4787     }
4788
4789     eCell  = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
4790
4791     if(eCell > eCellMin) energy += eCell;
4792
4793   }//cell loop
4794
4795   //Loop on cells, get weighted parameters
4796   for(Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++)
4797   {
4798     //Get from the absid the supermodule, tower and eta/phi numbers
4799     geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta);
4800     geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);
4801
4802     //Get the cell energy, if recalibration is on, apply factors
4803     fraction  = cluster->GetCellAmplitudeFraction(iDigit);
4804     if(fraction < 1e-4) fraction = 1.; // in case unfolding is off
4805
4806     if(GetCaloUtils()->GetEMCALRecoUtils()->IsRecalibrationOn())
4807     {
4808       recalFactor = GetCaloUtils()->GetEMCALRecoUtils()->GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
4809     }
4810
4811     eCell  = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
4812
4813     // In case of a shared cluster, index of SM in C side, columns start at 48 and ends at 48*2
4814     // C Side impair SM, nSupMod%2=1; A side pair SM, nSupMod%2=0
4815     if(shared && iSupMod%2) ieta+=AliEMCALGeoParams::fgkEMCALCols;
4816
4817     if(energy > 0 && eCell > eCellMin)
4818     {
4819       w  = GetCaloUtils()->GetEMCALRecoUtils()->GetCellWeight(eCell,energy);
4820
4821       //correct weight, ONLY in simulation
4822       w *= (1 - fWSimu * w );
4823
4824       etai=(Double_t)ieta;
4825       phii=(Double_t)iphi;
4826
4827       if(w > 0.0)
4828       {
4829         wtot += w ;
4830         nstat++;
4831         //Shower shape
4832         sEta     += w * etai * etai ;
4833         etaMean  += w * etai ;
4834         sPhi     += w * phii * phii ;
4835         phiMean  += w * phii ;
4836         sEtaPhi  += w * etai * phii ;
4837       }
4838     }
4839     else if(energy == 0 || (eCellMin <0.01 && eCell == 0)) AliError(Form("Wrong energy %f and/or amplitude %f\n", eCell, energy));
4840
4841   }//cell loop
4842
4843   //Normalize to the weight
4844   if (wtot > 0)
4845   {
4846     etaMean /= wtot ;
4847     phiMean /= wtot ;
4848   }
4849   else
4850     AliError(Form("Wrong weight %f\n", wtot));
4851
4852   //Calculate dispersion
4853   for(Int_t iDigit=0; iDigit < cluster->GetNCells(); iDigit++)
4854   {
4855     //Get from the absid the supermodule, tower and eta/phi numbers
4856     geom->GetCellIndex(cluster->GetCellAbsId(iDigit),iSupMod,iTower,iIphi,iIeta);
4857     geom->GetCellPhiEtaIndexInSModule(iSupMod,iTower,iIphi,iIeta, iphi,ieta);
4858
4859     //Get the cell energy, if recalibration is on, apply factors
4860     fraction  = cluster->GetCellAmplitudeFraction(iDigit);
4861     if(fraction < 1e-4) fraction = 1.; // in case unfolding is off
4862     if (GetCaloUtils()->GetEMCALRecoUtils()->IsRecalibrationOn())
4863     {
4864       recalFactor = GetCaloUtils()->GetEMCALRecoUtils()->GetEMCALChannelRecalibrationFactor(iSupMod,ieta,iphi);
4865     }
4866
4867     eCell  = cells->GetCellAmplitude(cluster->GetCellAbsId(iDigit))*fraction*recalFactor;
4868
4869     // In case of a shared cluster, index of SM in C side, columns start at 48 and ends at 48*2
4870     // C Side impair SM, nSupMod%2=1; A side pair SM, nSupMod%2=0
4871     if(shared && iSupMod%2) ieta+=AliEMCALGeoParams::fgkEMCALCols;
4872
4873     if(energy > 0 && eCell > eCellMin)
4874     {
4875       w  = GetCaloUtils()->GetEMCALRecoUtils()->GetCellWeight(eCell,energy);
4876
4877       //correct weight, ONLY in simulation
4878       w *= (1 - fWSimu * w );
4879
4880       etai=(Double_t)ieta;
4881       phii=(Double_t)iphi;
4882       if(w > 0.0)
4883       {
4884         disp +=  w *((etai-etaMean)*(etai-etaMean)+(phii-phiMean)*(phii-phiMean));
4885         dEta +=  w * (etai-etaMean)*(etai-etaMean) ;
4886         dPhi +=  w * (phii-phiMean)*(phii-phiMean) ;
4887       }
4888     }
4889     else if(energy == 0 || (eCellMin <0.01 && eCell == 0)) AliError(Form("Wrong energy %f and/or amplitude %f\n", eCell, energy));
4890   }// cell loop
4891
4892   //Normalize to the weigth and set shower shape parameters
4893   if (wtot > 0 && nstat > 1)
4894   {
4895     disp    /= wtot ;
4896     dEta    /= wtot ;
4897     dPhi    /= wtot ;
4898     sEta    /= wtot ;
4899     sPhi    /= wtot ;
4900     sEtaPhi /= wtot ;
4901
4902     sEta    -= etaMean * etaMean ;
4903     sPhi    -= phiMean * phiMean ;
4904     sEtaPhi -= etaMean * phiMean ;
4905
4906     l0 = (0.5 * (sEta + sPhi) + TMath::Sqrt( 0.25 * (sEta - sPhi) * (sEta - sPhi) + sEtaPhi * sEtaPhi ));
4907     l1 = (0.5 * (sEta + sPhi) - TMath::Sqrt( 0.25 * (sEta - sPhi) * (sEta - sPhi) + sEtaPhi * sEtaPhi ));
4908   }
4909   else
4910   {
4911     l0   = 0. ;
4912     l1   = 0. ;
4913     dEta = 0. ; dPhi = 0. ; disp    = 0. ;
4914     sEta = 0. ; sPhi = 0. ; sEtaPhi = 0. ;
4915   }
4916
4917 }
4918
4919