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