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