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