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