ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//_________________________________________________________________________
// Class to collect two-photon invariant mass distributions for
// extracting raw pi0 yield.
// Input is produced by AliAnaPhoton (or any other analysis producing output AliAODPWG4Particles),
// it will do nothing if executed alone
//
//-- Author: Dmitri Peressounko (RRC "KI")
//-- Adapted to CaloTrackCorr frame by Lamia Benhabib (SUBATECH)
//-- and Gustavo Conesa (INFN-Frascati)
//_________________________________________________________________________


// --- ROOT system ---
#include "TH3.h"
#include "TH2F.h"
//#include "Riostream.h"
#include "TCanvas.h"
#include "TPad.h"
#include "TROOT.h"
#include "TClonesArray.h"
#include "TObjString.h"
#include "TDatabasePDG.h"

//---- AliRoot system ----
#include "AliAnaPi0.h"
#include "AliCaloTrackReader.h"
#include "AliCaloPID.h"
#include "AliStack.h"
#include "AliFiducialCut.h"
#include "TParticle.h"
#include "AliVEvent.h"
#include "AliESDCaloCluster.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliNeutralMesonSelection.h"
#include "AliMixedEvent.h"
#include "AliAODMCParticle.h"

// --- Detectors ---
#include "AliPHOSGeoUtils.h"
#include "AliEMCALGeometry.h"

ClassImp(AliAnaPi0)

//______________________________________________________
AliAnaPi0::AliAnaPi0() : AliAnaCaloTrackCorrBaseClass(),
fEventsList(0x0),
fNModules(22),
fUseAngleCut(kFALSE),        fUseAngleEDepCut(kFALSE),     fAngleCut(0),                 fAngleMaxCut(7.),
fMultiCutAna(kFALSE),        fMultiCutAnaSim(kFALSE),
fNPtCuts(0),                 fNAsymCuts(0),                fNCellNCuts(0),               fNPIDBits(0),
fMakeInvPtPlots(kFALSE),     fSameSM(kFALSE),
fFillSMCombinations(kFALSE), fCheckConversion(kFALSE),
fFillBadDistHisto(kFALSE),   fFillSSCombinations(kFALSE),
fFillAngleHisto(kFALSE),     fFillAsymmetryHisto(kFALSE),  fFillOriginHisto(0),          fFillArmenterosThetaStar(0),
fCheckAccInSector(kFALSE),
fPhotonMom1(),               fPhotonMom1Boost(),           fPhotonMom2(),                fPi0Mom(),
fProdVertex(),

//Histograms
fhAverTotECluster(0),        fhAverTotECell(0),            fhAverTotECellvsCluster(0),
fhEDensityCluster(0),        fhEDensityCell(0),            fhEDensityCellvsCluster(0),
fhReMod(0x0),                fhReSameSideEMCALMod(0x0),    fhReSameSectorEMCALMod(0x0),  fhReDiffPHOSMod(0x0),
fhMiMod(0x0),                fhMiSameSideEMCALMod(0x0),    fhMiSameSectorEMCALMod(0x0),  fhMiDiffPHOSMod(0x0),
fhReConv(0x0),               fhMiConv(0x0),                fhReConv2(0x0),  fhMiConv2(0x0),
fhRe1(0x0),                  fhMi1(0x0),                   fhRe2(0x0),                   fhMi2(0x0),
fhRe3(0x0),                  fhMi3(0x0),                   fhReInvPt1(0x0),              fhMiInvPt1(0x0),
fhReInvPt2(0x0),             fhMiInvPt2(0x0),              fhReInvPt3(0x0),              fhMiInvPt3(0x0),
fhRePtNCellAsymCuts(0x0),    fhMiPtNCellAsymCuts(0x0),     fhRePtNCellAsymCutsSM(),
fhRePIDBits(0x0),            fhRePtMult(0x0),              fhReSS(),
fhRePtAsym(0x0),             fhRePtAsymPi0(0x0),           fhRePtAsymEta(0x0),
fhEventBin(0),               fhEventMixBin(0),
fhCentrality(0x0),           fhCentralityNoPair(0x0),
fhEventPlaneResolution(0x0),
fhRealOpeningAngle(0x0),     fhRealCosOpeningAngle(0x0),   fhMixedOpeningAngle(0x0),     fhMixedCosOpeningAngle(0x0),
// MC histograms
fhPrimPi0E(0x0),             fhPrimPi0Pt(0x0),
fhPrimPi0AccE(0x0),          fhPrimPi0AccPt(0x0),
fhPrimPi0Y(0x0),             fhPrimPi0AccY(0x0),
fhPrimPi0Yeta(0x0),          fhPrimPi0YetaYcut(0x0),       fhPrimPi0AccYeta(0x0),
fhPrimPi0Phi(0x0),           fhPrimPi0AccPhi(0x0),
fhPrimPi0OpeningAngle(0x0),  fhPrimPi0OpeningAngleAsym(0x0),fhPrimPi0CosOpeningAngle(0x0),
fhPrimPi0PtCentrality(0),    fhPrimPi0PtEventPlane(0),
fhPrimPi0AccPtCentrality(0), fhPrimPi0AccPtEventPlane(0),
fhPrimEtaE(0x0),             fhPrimEtaPt(0x0),
fhPrimEtaAccE(0x0),          fhPrimEtaAccPt(0x0),
fhPrimEtaY(0x0),             fhPrimEtaAccY(0x0),
fhPrimEtaYeta(0x0),          fhPrimEtaYetaYcut(0x0),       fhPrimEtaAccYeta(0x0),
fhPrimEtaPhi(0x0),           fhPrimEtaAccPhi(0x0),
fhPrimEtaOpeningAngle(0x0),  fhPrimEtaOpeningAngleAsym(0x0),fhPrimEtaCosOpeningAngle(0x0),
fhPrimEtaPtCentrality(0),    fhPrimEtaPtEventPlane(0),
fhPrimEtaAccPtCentrality(0), fhPrimEtaAccPtEventPlane(0),
fhPrimPi0PtOrigin(0x0),      fhPrimEtaPtOrigin(0x0),
fhMCOrgMass(),               fhMCOrgAsym(),                fhMCOrgDeltaEta(),            fhMCOrgDeltaPhi(),
fhMCPi0MassPtRec(),          fhMCPi0MassPtTrue(),          fhMCPi0PtTruePtRec(),
fhMCEtaMassPtRec(),          fhMCEtaMassPtTrue(),          fhMCEtaPtTruePtRec(),
fhMCPi0PtOrigin(0x0),        fhMCEtaPtOrigin(0x0),
fhMCPi0ProdVertex(0),        fhMCEtaProdVertex(0),
fhPrimPi0ProdVertex(0),      fhPrimEtaProdVertex(0),
fhReMCFromConversion(0),     fhReMCFromNotConversion(0),   fhReMCFromMixConversion(0),
fhCosThStarPrimPi0(0),       fhCosThStarPrimEta(0),
 fhEPairDiffTime(0)
{
  //Default Ctor
  
  InitParameters();
  
  for(Int_t i = 0; i < 4; i++)
  {
    fhArmPrimEta[i] = 0;
    fhArmPrimPi0[i] = 0;
  }
}

//_____________________
AliAnaPi0::~AliAnaPi0()
{
  // Remove event containers
  
  if(DoOwnMix() && fEventsList)
  {
    for(Int_t ic=0; ic<GetNCentrBin(); ic++)
    {
      for(Int_t iz=0; iz<GetNZvertBin(); iz++)
      {
        for(Int_t irp=0; irp<GetNRPBin(); irp++)
        {
          Int_t bin = GetEventMixBin(ic,iz,irp);
          fEventsList[bin]->Delete() ;
          delete fEventsList[bin] ;
        }
      }
    }
    delete[] fEventsList;
  }
  
}

//______________________________
void AliAnaPi0::InitParameters()
{
  //Init parameters when first called the analysis
  //Set default parameters
  SetInputAODName("PWG4Particle");
  
  AddToHistogramsName("AnaPi0_");
  
  fUseAngleCut = kFALSE;
  fUseAngleEDepCut = kFALSE;
  fAngleCut    = 0.;
  fAngleMaxCut = TMath::Pi();
  
  fMultiCutAna = kFALSE;
  
  fNPtCuts = 3;
  fPtCuts[0] = 0.; fPtCuts[1] = 0.3;   fPtCuts[2] = 0.5;
  for(Int_t i = fNPtCuts; i < 10; i++)fPtCuts[i] = 0.;
  
  fNAsymCuts = 2;
  fAsymCuts[0] = 1.;  fAsymCuts[1] = 0.7; //fAsymCuts[2] = 0.6; //  fAsymCuts[3] = 0.1;
  for(Int_t i = fNAsymCuts; i < 10; i++)fAsymCuts[i] = 0.;
  
  fNCellNCuts = 3;
  fCellNCuts[0] = 0; fCellNCuts[1] = 1;   fCellNCuts[2] = 2;
  for(Int_t i = fNCellNCuts; i < 10; i++)fCellNCuts[i]  = 0;
  
  fNPIDBits = 2;
  fPIDBits[0] = 0;   fPIDBits[1] = 2; //  fPIDBits[2] = 4; fPIDBits[3] = 6;// check, no cut,  dispersion, neutral, dispersion&&neutral
  for(Int_t i = fNPIDBits; i < 10; i++)fPIDBits[i] = 0;
  
}


//_______________________________________
TObjString * AliAnaPi0::GetAnalysisCuts()
{
  //Save parameters used for analysis
  TString parList ; //this will be list of parameters used for this analysis.
  const Int_t buffersize = 255;
  char onePar[buffersize] ;
  snprintf(onePar,buffersize,"--- AliAnaPi0 ---:") ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Number of bins in Centrality:  %d;",GetNCentrBin()) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Number of bins in Z vert. pos: %d;",GetNZvertBin()) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Number of bins in Reac. Plain: %d;",GetNRPBin()) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Depth of event buffer: %d;",GetNMaxEvMix()) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Select pairs with their angle: %d, edep %d, min angle %2.3f, max angle %2.3f;",fUseAngleCut, fUseAngleEDepCut,fAngleCut,fAngleMaxCut) ;
  parList+=onePar ;
  snprintf(onePar,buffersize," Asymmetry cuts: n = %d, asymmetry < ",fNAsymCuts) ;
  for(Int_t i = 0; i < fNAsymCuts; i++) snprintf(onePar,buffersize,"%s %2.2f;",onePar,fAsymCuts[i]);
  parList+=onePar ;
  snprintf(onePar,buffersize," PID selection bits: n = %d, PID bit =",fNPIDBits) ;
  for(Int_t i = 0; i < fNPIDBits; i++) snprintf(onePar,buffersize,"%s %d;",onePar,fPIDBits[i]);
  parList+=onePar ;
  snprintf(onePar,buffersize,"Cuts:") ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Z vertex position: -%f < z < %f;",GetZvertexCut(),GetZvertexCut()) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Calorimeter: %s;",GetCalorimeterString().Data()) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Number of modules: %d:",fNModules) ;
  parList+=onePar ;
  if(fMultiCutAna)
  {
    snprintf(onePar, buffersize," pT cuts: n = %d, pt > ",fNPtCuts) ;
    for(Int_t i = 0; i < fNPtCuts; i++) snprintf(onePar,buffersize,"%s %2.2f;",onePar,fPtCuts[i]);
    parList+=onePar ;
    snprintf(onePar,buffersize, " N cell in cluster cuts: n = %d, nCell > ",fNCellNCuts) ;
    for(Int_t i = 0; i < fNCellNCuts; i++) snprintf(onePar,buffersize,"%s %d;",onePar,fCellNCuts[i]);
    parList+=onePar ;
  }
  
  return new TObjString(parList) ;
}

//_________________________________________
TList * AliAnaPi0::GetCreateOutputObjects()
{
  // Create histograms to be saved in output file and
  // store them in fOutputContainer
  
  // Init the number of modules, set in the class AliCalorimeterUtils
  fNModules = GetCaloUtils()->GetNumberOfSuperModulesUsed();
  if(GetCalorimeter()==kPHOS && fNModules > 4) fNModules = 4;
  
  //create event containers
  fEventsList = new TList*[GetNCentrBin()*GetNZvertBin()*GetNRPBin()] ;
  
  for(Int_t ic=0; ic<GetNCentrBin(); ic++)
  {
    for(Int_t iz=0; iz<GetNZvertBin(); iz++)
    {
      for(Int_t irp=0; irp<GetNRPBin(); irp++)
      {
        Int_t bin = GetEventMixBin(ic,iz,irp);
        fEventsList[bin] = new TList() ;
        fEventsList[bin]->SetOwner(kFALSE);
      }
    }
  }
  
  TList * outputContainer = new TList() ;
  outputContainer->SetName(GetName());
  
  fhReMod                = new TH2F*[fNModules]   ;
  fhMiMod                = new TH2F*[fNModules]   ;
  
  if(GetCalorimeter() == kPHOS)
  {
    fhReDiffPHOSMod        = new TH2F*[fNModules]   ;
    fhMiDiffPHOSMod        = new TH2F*[fNModules]   ;
  }
  else
  {
    fhReSameSectorEMCALMod = new TH2F*[fNModules/2] ;
    fhReSameSideEMCALMod   = new TH2F*[fNModules-2] ;
    fhMiSameSectorEMCALMod = new TH2F*[fNModules/2] ;
    fhMiSameSideEMCALMod   = new TH2F*[fNModules-2] ;
  }
  
  
  fhRe1 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
  fhMi1 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
  if(fFillBadDistHisto)
  {
    fhRe2 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
    fhRe3 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
    fhMi2 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
    fhMi3 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
  }
  if(fMakeInvPtPlots)
  {
    fhReInvPt1 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
    fhMiInvPt1 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
    if(fFillBadDistHisto){
      fhReInvPt2 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
      fhReInvPt3 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
      fhMiInvPt2 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
      fhMiInvPt3 = new TH2F*[GetNCentrBin()*fNPIDBits*fNAsymCuts] ;
    }
  }
  
  const Int_t buffersize = 255;
  char key[buffersize] ;
  char title[buffersize] ;
  
  Int_t nptbins   = GetHistogramRanges()->GetHistoPtBins();
  Int_t nphibins  = GetHistogramRanges()->GetHistoPhiBins();
  Int_t netabins  = GetHistogramRanges()->GetHistoEtaBins();
  Float_t ptmax   = GetHistogramRanges()->GetHistoPtMax();
  Float_t phimax  = GetHistogramRanges()->GetHistoPhiMax();
  Float_t etamax  = GetHistogramRanges()->GetHistoEtaMax();
  Float_t ptmin   = GetHistogramRanges()->GetHistoPtMin();
  Float_t phimin  = GetHistogramRanges()->GetHistoPhiMin();
  Float_t etamin  = GetHistogramRanges()->GetHistoEtaMin();
  
  Int_t nmassbins = GetHistogramRanges()->GetHistoMassBins();
  Int_t nasymbins = GetHistogramRanges()->GetHistoAsymmetryBins();
  Float_t massmax = GetHistogramRanges()->GetHistoMassMax();
  Float_t asymmax = GetHistogramRanges()->GetHistoAsymmetryMax();
  Float_t massmin = GetHistogramRanges()->GetHistoMassMin();
  Float_t asymmin = GetHistogramRanges()->GetHistoAsymmetryMin();
  Int_t ntrmbins  = GetHistogramRanges()->GetHistoTrackMultiplicityBins();
  Int_t ntrmmax   = GetHistogramRanges()->GetHistoTrackMultiplicityMax();
  Int_t ntrmmin   = GetHistogramRanges()->GetHistoTrackMultiplicityMin();
  Int_t tdbins    = GetHistogramRanges()->GetHistoDiffTimeBins() ;
  Float_t tdmax   = GetHistogramRanges()->GetHistoDiffTimeMax();
  Float_t tdmin   = GetHistogramRanges()->GetHistoDiffTimeMin();

  if(fCheckConversion)
  {
    fhReConv = new TH2F("hReConv","Real Pair with one recombined conversion ",nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
    fhReConv->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhReConv->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
    outputContainer->Add(fhReConv) ;
    
    fhReConv2 = new TH2F("hReConv2","Real Pair with 2 recombined conversion ",nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
    fhReConv2->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhReConv2->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
    outputContainer->Add(fhReConv2) ;
    
    if(DoOwnMix())
    {
      fhMiConv = new TH2F("hMiConv","Mixed Pair with one recombined conversion ",nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
      fhMiConv->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhMiConv->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
      outputContainer->Add(fhMiConv) ;
      
      fhMiConv2 = new TH2F("hMiConv2","Mixed Pair with 2 recombined conversion ",nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
      fhMiConv2->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhMiConv2->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
      outputContainer->Add(fhMiConv2) ;
    }
  }
  
  for(Int_t ic=0; ic<GetNCentrBin(); ic++)
  {
    for(Int_t ipid=0; ipid<fNPIDBits; ipid++)
    {
      for(Int_t iasym=0; iasym<fNAsymCuts; iasym++)
      {
        Int_t index = ((ic*fNPIDBits)+ipid)*fNAsymCuts + iasym;
        //printf("cen %d, pid %d, asy %d, Index %d\n",ic,ipid,iasym,index);
        //Distance to bad module 1
        snprintf(key, buffersize,"hRe_cen%d_pidbit%d_asy%d_dist1",ic,ipid,iasym) ;
        snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 1",
                 ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
        fhRe1[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
        fhRe1[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
        fhRe1[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
        //printf("name: %s\n ",fhRe1[index]->GetName());
        outputContainer->Add(fhRe1[index]) ;
        
        if(fFillBadDistHisto)
        {
          //Distance to bad module 2
          snprintf(key, buffersize,"hRe_cen%d_pidbit%d_asy%d_dist2",ic,ipid,iasym) ;
          snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 2",
                   ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
          fhRe2[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhRe2[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhRe2[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhRe2[index]) ;
          
          //Distance to bad module 3
          snprintf(key, buffersize,"hRe_cen%d_pidbit%d_asy%d_dist3",ic,ipid,iasym) ;
          snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 3",
                   ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
          fhRe3[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhRe3[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhRe3[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhRe3[index]) ;
        }
        
        //Inverse pT
        if(fMakeInvPtPlots)
        {
          //Distance to bad module 1
          snprintf(key, buffersize,"hReInvPt_cen%d_pidbit%d_asy%d_dist1",ic,ipid,iasym) ;
          snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 1",
                   ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
          fhReInvPt1[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhReInvPt1[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhReInvPt1[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhReInvPt1[index]) ;
          
          if(fFillBadDistHisto){
            //Distance to bad module 2
            snprintf(key, buffersize,"hReInvPt_cen%d_pidbit%d_asy%d_dist2",ic,ipid,iasym) ;
            snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 2",
                     ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
            fhReInvPt2[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
            fhReInvPt2[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
            fhReInvPt2[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
            outputContainer->Add(fhReInvPt2[index]) ;
            
            //Distance to bad module 3
            snprintf(key, buffersize,"hReInvPt_cen%d_pidbit%d_asy%d_dist3",ic,ipid,iasym) ;
            snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 3",
                     ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
            fhReInvPt3[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
            fhReInvPt3[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
            fhReInvPt3[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
            outputContainer->Add(fhReInvPt3[index]) ;
          }
        }
        
        if(DoOwnMix())
        {
          //Distance to bad module 1
          snprintf(key, buffersize,"hMi_cen%d_pidbit%d_asy%d_dist1",ic,ipid,iasym) ;
          snprintf(title, buffersize,"Mixed #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 1",
                   ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
          fhMi1[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhMi1[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhMi1[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhMi1[index]) ;
          if(fFillBadDistHisto){
            //Distance to bad module 2
            snprintf(key, buffersize,"hMi_cen%d_pidbit%d_asy%d_dist2",ic,ipid,iasym) ;
            snprintf(title, buffersize,"Mixed #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 2",
                     ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
            fhMi2[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
            fhMi2[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
            fhMi2[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
            outputContainer->Add(fhMi2[index]) ;
            
            //Distance to bad module 3
            snprintf(key, buffersize,"hMi_cen%d_pidbit%d_asy%d_dist3",ic,ipid,iasym) ;
            snprintf(title, buffersize,"Mixed #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 3",
                     ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
            fhMi3[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
            fhMi3[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
            fhMi3[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
            outputContainer->Add(fhMi3[index]) ;
          }
          
          //Inverse pT
          if(fMakeInvPtPlots)
          {
            //Distance to bad module 1
            snprintf(key, buffersize,"hMiInvPt_cen%d_pidbit%d_asy%d_dist1",ic,ipid,iasym) ;
            snprintf(title, buffersize,"Mixed #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 1",
                     ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
            fhMiInvPt1[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
            fhMiInvPt1[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
            fhMiInvPt1[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
            outputContainer->Add(fhMiInvPt1[index]) ;
            if(fFillBadDistHisto){
              //Distance to bad module 2
              snprintf(key, buffersize,"hMiInvPt_cen%d_pidbit%d_asy%d_dist2",ic,ipid,iasym) ;
              snprintf(title, buffersize,"Mixed #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f, dist bad 2",
                       ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
              fhMiInvPt2[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
              fhMiInvPt2[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
              fhMiInvPt2[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
              outputContainer->Add(fhMiInvPt2[index]) ;
              
              //Distance to bad module 3
              snprintf(key, buffersize,"hMiInvPt_cen%d_pidbit%d_asy%d_dist3",ic,ipid,iasym) ;
              snprintf(title, buffersize,"Mixed #it{M}_{#gamma#gamma} distr. for centrality=%d, PID bit=%d and asymmetry %1.2f,dist bad 3",
                       ic,fPIDBits[ipid], fAsymCuts[iasym]) ;
              fhMiInvPt3[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
              fhMiInvPt3[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
              fhMiInvPt3[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
              outputContainer->Add(fhMiInvPt3[index]) ;
            }
          }
        }
      }
    }
  }
  
  fhEPairDiffTime = new TH2F("hEPairDiffTime","cluster pair time difference vs #it{p}_{T}",nptbins,ptmin,ptmax, tdbins,tdmin,tdmax);
  fhEPairDiffTime->SetXTitle("#it{p}_{T,pair} (GeV/#it{c})");
  fhEPairDiffTime->SetYTitle("#Delta t (ns)");
  outputContainer->Add(fhEPairDiffTime);
  
  if(fFillAsymmetryHisto)
  {
    fhRePtAsym = new TH2F("hRePtAsym","#it{Asymmetry} vs #it{p}_{T} , for pairs",nptbins,ptmin,ptmax,nasymbins,asymmin,asymmax) ;
    fhRePtAsym->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhRePtAsym->SetYTitle("#it{Asymmetry}");
    outputContainer->Add(fhRePtAsym);
    
    fhRePtAsymPi0 = new TH2F("hRePtAsymPi0","#it{Asymmetry} vs #it{p}_{T} , for pairs close to #pi^{0} mass",nptbins,ptmin,ptmax,nasymbins,asymmin,asymmax) ;
    fhRePtAsymPi0->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhRePtAsymPi0->SetYTitle("Asymmetry");
    outputContainer->Add(fhRePtAsymPi0);
    
    fhRePtAsymEta = new TH2F("hRePtAsymEta","#it{Asymmetry} vs #it{p}_{T} , for pairs close to #eta mass",nptbins,ptmin,ptmax,nasymbins,asymmin,asymmax) ;
    fhRePtAsymEta->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhRePtAsymEta->SetYTitle("#it{Asymmetry}");
    outputContainer->Add(fhRePtAsymEta);
  }
  
  if(fMultiCutAna)
  {
    fhRePIDBits         = new TH2F*[fNPIDBits];
    for(Int_t ipid=0; ipid<fNPIDBits; ipid++){
      snprintf(key,   buffersize,"hRe_pidbit%d",ipid) ;
      snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for PIDBit=%d",fPIDBits[ipid]) ;
      fhRePIDBits[ipid] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
      fhRePIDBits[ipid]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhRePIDBits[ipid]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
      outputContainer->Add(fhRePIDBits[ipid]) ;
    }// pid bit loop
    
    fhRePtNCellAsymCuts    = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
    fhMiPtNCellAsymCuts    = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
    
    if(fFillSMCombinations)
      for(Int_t iSM = 0; iSM < fNModules; iSM++) fhRePtNCellAsymCutsSM[iSM] = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
    
    
    for(Int_t ipt=0; ipt<fNPtCuts; ipt++)
    {
      for(Int_t icell=0; icell<fNCellNCuts; icell++)
      {
        for(Int_t iasym=0; iasym<fNAsymCuts; iasym++)
        {
          snprintf(key,   buffersize,"hRe_pt%d_cell%d_asym%d",ipt,icell,iasym) ;
          snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for pt >%2.2f, ncell>%d and asym >%1.2f ",fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym]) ;
          Int_t index = ((ipt*fNCellNCuts)+icell)*fNAsymCuts + iasym;
          //printf("ipt %d, icell %d, iassym %d, index %d\n",ipt, icell, iasym, index);
          fhRePtNCellAsymCuts[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhRePtNCellAsymCuts[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhRePtNCellAsymCuts[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhRePtNCellAsymCuts[index]) ;
          
          snprintf(key,   buffersize,"hMi_pt%d_cell%d_asym%d",ipt,icell,iasym) ;
          snprintf(title, buffersize,"Mixed #it{M}_{#gamma#gamma} distr. for pt >%2.2f, ncell>%d and asym >%1.2f",fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym]) ;
          fhMiPtNCellAsymCuts[index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhMiPtNCellAsymCuts[index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhMiPtNCellAsymCuts[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhMiPtNCellAsymCuts[index]) ;
          
          if(fFillSMCombinations)
          {
            for(Int_t iSM = 0; iSM < fNModules; iSM++)
            {
              snprintf(key,   buffersize,"hRe_pt%d_cell%d_asym%d_SM%d",ipt,icell,iasym,iSM) ;
              snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for pt >%2.2f, ncell>%d and asym >%1.2f, SM %d ",
                       fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym],iSM) ;
              fhRePtNCellAsymCutsSM[iSM][index] = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
              fhRePtNCellAsymCutsSM[iSM][index]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
              fhRePtNCellAsymCutsSM[iSM][index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
              outputContainer->Add(fhRePtNCellAsymCutsSM[iSM][index]) ;
            }
            
          }
        }
      }
    }
    
    if(ntrmbins!=0)
    {
      fhRePtMult = new TH3F*[fNAsymCuts] ;
      for(Int_t iasym = 0; iasym<fNAsymCuts; iasym++)
      {
        fhRePtMult[iasym] = new TH3F(Form("hRePtMult_asym%d",iasym),Form("(#it{p}_{T},C,M)_{#gamma#gamma}, A<%1.2f",fAsymCuts[iasym]),
                                     nptbins,ptmin,ptmax,ntrmbins,ntrmmin,ntrmmax,nmassbins,massmin,massmax);
        fhRePtMult[iasym]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
        fhRePtMult[iasym]->SetYTitle("Track multiplicity");
        fhRePtMult[iasym]->SetZTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
        outputContainer->Add(fhRePtMult[iasym]) ;
      }
    }
  }// multi cuts analysis
  
  if(fFillSSCombinations)
  {
    
    fhReSS[0] = new TH2F("hRe_SS_Tight"," 0.01 < #lambda_{0}^{2} < 0.4",
                         nptbins,ptmin,ptmax,nmassbins,massmin,massmax);
    fhReSS[0]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhReSS[0]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
    outputContainer->Add(fhReSS[0]) ;
    
    
    fhReSS[1] = new TH2F("hRe_SS_Loose"," #lambda_{0}^{2} > 0.4",
                         nptbins,ptmin,ptmax,nmassbins,massmin,massmax);
    fhReSS[1]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhReSS[1]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
    outputContainer->Add(fhReSS[1]) ;
    
    
    fhReSS[2] = new TH2F("hRe_SS_Both"," cluster_{1} #lambda_{0}^{2} > 0.4; cluster_{2} 0.01 < #lambda_{0}^{2} < 0.4",
                         nptbins,ptmin,ptmax,nmassbins,massmin,massmax);
    fhReSS[2]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhReSS[2]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
    outputContainer->Add(fhReSS[2]) ;
  }
  
  if(DoOwnMix())
  {
    fhEventBin=new TH1I("hEventBin","Number of real pairs per bin(cen,vz,rp)",
                        GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
                        GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
    fhEventBin->SetXTitle("bin");
    outputContainer->Add(fhEventBin) ;
    
    
    fhEventMixBin=new TH1I("hEventMixBin","Number of mixed pairs per bin(cen,vz,rp)",
                           GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1,0,
                           GetNCentrBin()*GetNZvertBin()*GetNRPBin()+1) ;
    fhEventMixBin->SetXTitle("bin");
    outputContainer->Add(fhEventMixBin) ;
  }
  
  if(GetNCentrBin()>1)
  {
    fhCentrality=new TH1F("hCentralityBin","Number of events in centrality bin",GetNCentrBin(),0.,1.*GetNCentrBin()) ;
    fhCentrality->SetXTitle("Centrality bin");
    outputContainer->Add(fhCentrality) ;
    
    fhCentralityNoPair=new TH1F("hCentralityBinNoPair","Number of events in centrality bin, with no cluster pairs",GetNCentrBin(),0.,1.*GetNCentrBin()) ;
    fhCentralityNoPair->SetXTitle("Centrality bin");
    outputContainer->Add(fhCentralityNoPair) ;
  }
  
  if(GetNRPBin() > 1 && GetNCentrBin()>1 )
  {
    fhEventPlaneResolution=new TH2F("hEventPlaneResolution","Event plane resolution",GetNCentrBin(),0,GetNCentrBin(),100,0.,TMath::TwoPi()) ;
    fhEventPlaneResolution->SetYTitle("Resolution");
    fhEventPlaneResolution->SetXTitle("Centrality Bin");
    outputContainer->Add(fhEventPlaneResolution) ;
  }
  
  if(fFillAngleHisto)
  {
    fhRealOpeningAngle  = new TH2F
    ("hRealOpeningAngle","Angle between all #gamma pair vs E_{#pi^{0}}",nptbins,ptmin,ptmax,300,0,TMath::Pi());
    fhRealOpeningAngle->SetYTitle("#theta(rad)");
    fhRealOpeningAngle->SetXTitle("E_{ #pi^{0}} (GeV)");
    outputContainer->Add(fhRealOpeningAngle) ;
    
    fhRealCosOpeningAngle  = new TH2F
    ("hRealCosOpeningAngle","Cosinus of angle between all #gamma pair vs E_{#pi^{0}}",nptbins,ptmin,ptmax,100,0,1);
    fhRealCosOpeningAngle->SetYTitle("cos (#theta) ");
    fhRealCosOpeningAngle->SetXTitle("E_{ #pi^{0}} (GeV)");
    outputContainer->Add(fhRealCosOpeningAngle) ;
    
    if(DoOwnMix())
    {
      fhMixedOpeningAngle  = new TH2F
      ("hMixedOpeningAngle","Angle between all #gamma pair vs E_{#pi^{0}}, Mixed pairs",nptbins,ptmin,ptmax,300,0,TMath::Pi());
      fhMixedOpeningAngle->SetYTitle("#theta(rad)");
      fhMixedOpeningAngle->SetXTitle("E_{ #pi^{0}} (GeV)");
      outputContainer->Add(fhMixedOpeningAngle) ;
      
      fhMixedCosOpeningAngle  = new TH2F
      ("hMixedCosOpeningAngle","Cosinus of angle between all #gamma pair vs E_{#pi^{0}}, Mixed pairs",nptbins,ptmin,ptmax,100,0,1);
      fhMixedCosOpeningAngle->SetYTitle("cos (#theta) ");
      fhMixedCosOpeningAngle->SetXTitle("E_{ #pi^{0}} (GeV)");
      outputContainer->Add(fhMixedCosOpeningAngle) ;
      
    }
  }
  
  //Histograms filled only if MC data is requested
  if(IsDataMC())
  {
    fhReMCFromConversion = new TH2F("hReMCFromConversion","Invariant mass of 2 clusters originated in conversions",
                                    nptbins,ptmin,ptmax,nmassbins,massmin,massmax);
    fhReMCFromConversion->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhReMCFromConversion->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
    outputContainer->Add(fhReMCFromConversion) ;
    
    fhReMCFromNotConversion = new TH2F("hReMCNotFromConversion","Invariant mass of 2 clusters not originated in conversions",
                                       nptbins,ptmin,ptmax,nmassbins,massmin,massmax);
    fhReMCFromNotConversion->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhReMCFromNotConversion->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
    outputContainer->Add(fhReMCFromNotConversion) ;
    
    fhReMCFromMixConversion = new TH2F("hReMCFromMixConversion","Invariant mass of 2 clusters one from conversion and the other not",
                                       nptbins,ptmin,ptmax,nmassbins,massmin,massmax);
    fhReMCFromMixConversion->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhReMCFromMixConversion->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
    outputContainer->Add(fhReMCFromMixConversion) ;
    
    //Pi0
    
    fhPrimPi0E     = new TH1F("hPrimPi0E","Primary #pi^{0} E, |#it{Y}|<1",nptbins,ptmin,ptmax) ;
    fhPrimPi0AccE  = new TH1F("hPrimPi0AccE","Primary #pi^{0} #it{E} with both photons in acceptance",nptbins,ptmin,ptmax) ;
    fhPrimPi0E   ->SetXTitle("#it{E} (GeV)");
    fhPrimPi0AccE->SetXTitle("#it{E} (GeV)");
    outputContainer->Add(fhPrimPi0E) ;
    outputContainer->Add(fhPrimPi0AccE) ;
    
    fhPrimPi0Pt     = new TH1F("hPrimPi0Pt","Primary #pi^{0} #it{p}_{T} , |#it{Y}|<1",nptbins,ptmin,ptmax) ;
    fhPrimPi0AccPt  = new TH1F("hPrimPi0AccPt","Primary #pi^{0} #it{p}_{T} with both photons in acceptance",nptbins,ptmin,ptmax) ;
    fhPrimPi0Pt   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimPi0AccPt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimPi0Pt) ;
    outputContainer->Add(fhPrimPi0AccPt) ;
    
    Int_t netabinsopen =  TMath::Nint(netabins*4/(etamax-etamin));
    fhPrimPi0Y      = new TH2F("hPrimPi0Rapidity","Rapidity of primary #pi^{0}",nptbins,ptmin,ptmax,netabinsopen,-2, 2) ;
    fhPrimPi0Y   ->SetYTitle("#it{Rapidity}");
    fhPrimPi0Y   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimPi0Y) ;
    
    fhPrimPi0Yeta      = new TH2F("hPrimPi0PseudoRapidity","PseudoRapidity of primary #pi^{0}",nptbins,ptmin,ptmax,netabinsopen,-2, 2) ;
    fhPrimPi0Yeta   ->SetYTitle("#eta");
    fhPrimPi0Yeta   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimPi0Yeta) ;
    
    fhPrimPi0YetaYcut      = new TH2F("hPrimPi0PseudoRapidityYcut","PseudoRapidity of primary #pi^{0}, |#it{Y}|<1",nptbins,ptmin,ptmax,netabinsopen,-2, 2) ;
    fhPrimPi0YetaYcut   ->SetYTitle("#eta");
    fhPrimPi0YetaYcut   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimPi0YetaYcut) ;
    
    fhPrimPi0AccY   = new TH2F("hPrimPi0AccRapidity","Rapidity of primary #pi^{0} with accepted daughters",nptbins,ptmin,ptmax,netabins,etamin,etamax) ;
    fhPrimPi0AccY->SetYTitle("Rapidity");
    fhPrimPi0AccY->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimPi0AccY) ;
    
    fhPrimPi0AccYeta      = new TH2F("hPrimPi0AccPseudoRapidity","PseudoRapidity of primary #pi^{0} with accepted daughters",nptbins,ptmin,ptmax,netabins,etamin,etamax) ;
    fhPrimPi0AccYeta   ->SetYTitle("#eta");
    fhPrimPi0AccYeta   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimPi0AccYeta) ;
    
    Int_t nphibinsopen = TMath::Nint(nphibins*TMath::TwoPi()/(phimax-phimin));
    fhPrimPi0Phi    = new TH2F("hPrimPi0Phi","#phi of primary #pi^{0}, |#it{Y}|<1",nptbins,ptmin,ptmax,nphibinsopen,0,360) ;
    fhPrimPi0Phi->SetYTitle("#phi (deg)");
    fhPrimPi0Phi->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimPi0Phi) ;
    
    fhPrimPi0AccPhi = new TH2F("hPrimPi0AccPhi","#phi of primary #pi^{0} with accepted daughters",nptbins,ptmin,ptmax,
                               nphibins,phimin*TMath::RadToDeg(),phimax*TMath::RadToDeg()) ;
    fhPrimPi0AccPhi->SetYTitle("#phi (deg)");
    fhPrimPi0AccPhi->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimPi0AccPhi) ;
    
    fhPrimPi0PtCentrality     = new TH2F("hPrimPi0PtCentrality","Primary #pi^{0} #it{p}_{T} vs reco centrality, |#it{Y}|<1",
                                         nptbins,ptmin,ptmax, 100, 0, 100) ;
    fhPrimPi0AccPtCentrality  = new TH2F("hPrimPi0AccPtCentrality","Primary #pi^{0} with both photons in acceptance #it{p}_{T} vs reco centrality",
                                         nptbins,ptmin,ptmax, 100, 0, 100) ;
    fhPrimPi0PtCentrality   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimPi0AccPtCentrality->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimPi0PtCentrality   ->SetYTitle("Centrality");
    fhPrimPi0AccPtCentrality->SetYTitle("Centrality");
    outputContainer->Add(fhPrimPi0PtCentrality) ;
    outputContainer->Add(fhPrimPi0AccPtCentrality) ;
    
    fhPrimPi0PtEventPlane     = new TH2F("hPrimPi0PtEventPlane","Primary #pi^{0} #it{p}_{T} vs reco event plane angle, |#it{Y}|<1",
                                         nptbins,ptmin,ptmax, 100, 0, TMath::Pi()) ;
    fhPrimPi0AccPtEventPlane  = new TH2F("hPrimPi0AccPtEventPlane","Primary #pi^{0} with both photons in acceptance #it{p}_{T} vs reco event plane angle",
                                         nptbins,ptmin,ptmax, 100, 0, TMath::Pi()) ;
    fhPrimPi0PtEventPlane   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimPi0AccPtEventPlane->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimPi0PtEventPlane   ->SetYTitle("Event Plane Angle (rad)");
    fhPrimPi0AccPtEventPlane->SetYTitle("Event Plane Angle (rad)");
    outputContainer->Add(fhPrimPi0PtEventPlane) ;
    outputContainer->Add(fhPrimPi0AccPtEventPlane) ;
    
    //Eta
    
    fhPrimEtaE     = new TH1F("hPrimEtaE","Primary eta E",nptbins,ptmin,ptmax) ;
    fhPrimEtaAccE  = new TH1F("hPrimEtaAccE","Primary #eta #it{E} with both photons in acceptance",nptbins,ptmin,ptmax) ;
    fhPrimEtaE   ->SetXTitle("#it{E} (GeV)");
    fhPrimEtaAccE->SetXTitle("#it{E} (GeV)");
    outputContainer->Add(fhPrimEtaE) ;
    outputContainer->Add(fhPrimEtaAccE) ;
    
    fhPrimEtaPt     = new TH1F("hPrimEtaPt","Primary #eta #it{p}_{T}",nptbins,ptmin,ptmax) ;
    fhPrimEtaAccPt  = new TH1F("hPrimEtaAccPt","Primary eta #it{p}_{T} with both photons in acceptance",nptbins,ptmin,ptmax) ;
    fhPrimEtaPt   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimEtaAccPt->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimEtaPt) ;
    outputContainer->Add(fhPrimEtaAccPt) ;
    
    fhPrimEtaY      = new TH2F("hPrimEtaRapidity","Rapidity of primary #eta",nptbins,ptmin,ptmax,netabinsopen,-2, 2) ;
    fhPrimEtaY->SetYTitle("#it{Rapidity}");
    fhPrimEtaY->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimEtaY) ;
    
    fhPrimEtaYeta      = new TH2F("hPrimEtaPseudoRapidityEta","PseudoRapidity of primary #eta",nptbins,ptmin,ptmax,netabinsopen,-2, 2) ;
    fhPrimEtaYeta->SetYTitle("#it{Rapidity}");
    fhPrimEtaYeta->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimEtaYeta) ;
    
    fhPrimEtaYetaYcut      = new TH2F("hPrimEtaPseudoRapidityEtaYcut","PseudoRapidity of primary #eta, |#it{Y}|<1",nptbins,ptmin,ptmax,netabinsopen,-2, 2) ;
    fhPrimEtaYetaYcut->SetYTitle("#it{Pseudorapidity}");
    fhPrimEtaYetaYcut->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimEtaYetaYcut) ;
    
    fhPrimEtaAccY   = new TH2F("hPrimEtaAccRapidity","Rapidity of primary #eta",nptbins,ptmin,ptmax, netabins,etamin,etamax) ;
    fhPrimEtaAccY->SetYTitle("#it{Rapidity}");
    fhPrimEtaAccY->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimEtaAccY) ;
    
    fhPrimEtaAccYeta  = new TH2F("hPrimEtaAccPseudoRapidity","PseudoRapidity of primary #eta",nptbins,ptmin,ptmax, netabins,etamin,etamax) ;
    fhPrimEtaAccYeta->SetYTitle("#it{Pseudorapidity}");
    fhPrimEtaAccYeta->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimEtaAccYeta) ;
    
    fhPrimEtaPhi    = new TH2F("hPrimEtaPhi","Azimuthal of primary #eta",nptbins,ptmin,ptmax, nphibins,phimin*TMath::RadToDeg(),phimax*TMath::RadToDeg()) ;
    fhPrimEtaPhi->SetYTitle("#phi (deg)");
    fhPrimEtaPhi->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimEtaPhi) ;
    
    fhPrimEtaAccPhi = new TH2F("hPrimEtaAccPhi","Azimuthal of primary #eta with accepted daughters",nptbins,ptmin,ptmax, nphibins,phimin*TMath::RadToDeg(),phimax*TMath::RadToDeg()) ;
    fhPrimEtaAccPhi->SetYTitle("#phi (deg)");
    fhPrimEtaAccPhi->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    outputContainer->Add(fhPrimEtaAccPhi) ;
    
    fhPrimEtaPtCentrality     = new TH2F("hPrimEtaPtCentrality","Primary #eta #it{p}_{T} vs reco centrality, |#it{Y}|<1",nptbins,ptmin,ptmax, 100, 0, 100) ;
    fhPrimEtaAccPtCentrality  = new TH2F("hPrimEtaAccPtCentrality","Primary #eta with both photons in acceptance #it{p}_{T} vs reco centrality",nptbins,ptmin,ptmax, 100, 0, 100) ;
    fhPrimEtaPtCentrality   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimEtaAccPtCentrality->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimEtaPtCentrality   ->SetYTitle("Centrality");
    fhPrimEtaAccPtCentrality->SetYTitle("Centrality");
    outputContainer->Add(fhPrimEtaPtCentrality) ;
    outputContainer->Add(fhPrimEtaAccPtCentrality) ;
    
    fhPrimEtaPtEventPlane     = new TH2F("hPrimEtaPtEventPlane","Primary #eta #it{p}_{T} vs reco event plane angle, |#it{Y}|<1",nptbins,ptmin,ptmax, 100, 0, TMath::Pi()) ;
    fhPrimEtaAccPtEventPlane  = new TH2F("hPrimEtaAccPtEventPlane","Primary #eta with both #gamma_{decay} in acceptance #it{p}_{T} vs reco event plane angle",nptbins,ptmin,ptmax, 100, 0, TMath::Pi()) ;
    fhPrimEtaPtEventPlane   ->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimEtaAccPtEventPlane->SetXTitle("#it{p}_{T} (GeV/#it{c})");
    fhPrimEtaPtEventPlane   ->SetYTitle("Event Plane Angle (rad)");
    fhPrimEtaAccPtEventPlane->SetYTitle("Event Plane Angle (rad)");
    outputContainer->Add(fhPrimEtaPtEventPlane) ;
    outputContainer->Add(fhPrimEtaAccPtEventPlane) ;
    
    if(fFillAngleHisto)
    {
      fhPrimPi0OpeningAngle  = new TH2F
      ("hPrimPi0OpeningAngle","Angle between all primary #gamma pair vs E_{#pi^{0}}",nptbins,ptmin,ptmax,100,0,0.5);
      fhPrimPi0OpeningAngle->SetYTitle("#theta(rad)");
      fhPrimPi0OpeningAngle->SetXTitle("E_{ #pi^{0}} (GeV)");
      outputContainer->Add(fhPrimPi0OpeningAngle) ;
      
      fhPrimPi0OpeningAngleAsym  = new TH2F
      ("hPrimPi0OpeningAngleAsym","Angle between all primary #gamma pair vs #it{Asymmetry}, #it{p}_{T}>5 GeV/#it{c}",100,0,1,100,0,0.5);
      fhPrimPi0OpeningAngleAsym->SetXTitle("|A|=| (E_{1}-E_{2}) / (E_{1}+E_{2}) |");
      fhPrimPi0OpeningAngleAsym->SetYTitle("#theta(rad)");
      outputContainer->Add(fhPrimPi0OpeningAngleAsym) ;
      
      fhPrimPi0CosOpeningAngle  = new TH2F
      ("hPrimPi0CosOpeningAngle","Cosinus of angle between all primary #gamma pair vs E_{#pi^{0}}",nptbins,ptmin,ptmax,100,-1,1);
      fhPrimPi0CosOpeningAngle->SetYTitle("cos (#theta) ");
      fhPrimPi0CosOpeningAngle->SetXTitle("E_{ #pi^{0}} (GeV)");
      outputContainer->Add(fhPrimPi0CosOpeningAngle) ;
      
      fhPrimEtaOpeningAngle  = new TH2F
      ("hPrimEtaOpeningAngle","Angle between all primary #gamma pair vs E_{#eta}",nptbins,ptmin,ptmax,100,0,0.5);
      fhPrimEtaOpeningAngle->SetYTitle("#theta(rad)");
      fhPrimEtaOpeningAngle->SetXTitle("E_{#eta} (GeV)");
      outputContainer->Add(fhPrimEtaOpeningAngle) ;
      
      fhPrimEtaOpeningAngleAsym  = new TH2F
      ("hPrimEtaOpeningAngleAsym","Angle between all primary #gamma pair vs #it{Asymmetry}, #it{p}_{T}>5 GeV/#it{c}",100,0,1,100,0,0.5);
      fhPrimEtaOpeningAngleAsym->SetXTitle("|#it{A}|=| (#it{E}_{1}-#it{E}_{2}) / (#it{E}_{1}+#it{E}_{2}) |");
      fhPrimEtaOpeningAngleAsym->SetYTitle("#theta(rad)");
      outputContainer->Add(fhPrimEtaOpeningAngleAsym) ;
      
      
      fhPrimEtaCosOpeningAngle  = new TH2F
      ("hPrimEtaCosOpeningAngle","Cosinus of angle between all primary #gamma pair vs E_{#eta}",nptbins,ptmin,ptmax,100,-1,1);
      fhPrimEtaCosOpeningAngle->SetYTitle("cos (#theta) ");
      fhPrimEtaCosOpeningAngle->SetXTitle("#it{E}_{ #eta} (GeV)");
      outputContainer->Add(fhPrimEtaCosOpeningAngle) ;
    }
    
    if(fFillOriginHisto)
    {
      //Prim origin
      //Pi0
      fhPrimPi0PtOrigin     = new TH2F("hPrimPi0PtOrigin","Primary #pi^{0} #it{p}_{T} vs origin",nptbins,ptmin,ptmax,11,0,11) ;
      fhPrimPi0PtOrigin->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhPrimPi0PtOrigin->SetYTitle("Origin");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(1 ,"Status 21");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(2 ,"Quark");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(3 ,"qq Resonances ");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(4 ,"Resonances");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(5 ,"#rho");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(6 ,"#omega");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(7 ,"K");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(8 ,"Other");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(9 ,"#eta");
      fhPrimPi0PtOrigin->GetYaxis()->SetBinLabel(10 ,"#eta prime");
      outputContainer->Add(fhPrimPi0PtOrigin) ;
      
      fhMCPi0PtOrigin     = new TH2F("hMCPi0PtOrigin","Reconstructed pair from generated #pi^{0} #it{p}_{T} vs origin",nptbins,ptmin,ptmax,11,0,11) ;
      fhMCPi0PtOrigin->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhMCPi0PtOrigin->SetYTitle("Origin");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(1 ,"Status 21");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(2 ,"Quark");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(3 ,"qq Resonances");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(4 ,"Resonances");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(5 ,"#rho");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(6 ,"#omega");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(7 ,"K");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(8 ,"Other");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(9 ,"#eta");
      fhMCPi0PtOrigin->GetYaxis()->SetBinLabel(10 ,"#eta prime");
      outputContainer->Add(fhMCPi0PtOrigin) ;
      
      //Eta
      fhPrimEtaPtOrigin     = new TH2F("hPrimEtaPtOrigin","Primary #pi^{0} #it{p}_{T} vs origin",nptbins,ptmin,ptmax,7,0,7) ;
      fhPrimEtaPtOrigin->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhPrimEtaPtOrigin->SetYTitle("Origin");
      fhPrimEtaPtOrigin->GetYaxis()->SetBinLabel(1 ,"Status 21");
      fhPrimEtaPtOrigin->GetYaxis()->SetBinLabel(2 ,"Quark");
      fhPrimEtaPtOrigin->GetYaxis()->SetBinLabel(3 ,"qq Resonances");
      fhPrimEtaPtOrigin->GetYaxis()->SetBinLabel(4 ,"Resonances");
      fhPrimEtaPtOrigin->GetYaxis()->SetBinLabel(5 ,"Other");
      fhPrimEtaPtOrigin->GetYaxis()->SetBinLabel(6 ,"#eta prime ");
      
      outputContainer->Add(fhPrimEtaPtOrigin) ;
      
      fhMCEtaPtOrigin     = new TH2F("hMCEtaPtOrigin","Reconstructed pair from generated #pi^{0} #it{p}_{T} vs origin",nptbins,ptmin,ptmax,7,0,7) ;
      fhMCEtaPtOrigin->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhMCEtaPtOrigin->SetYTitle("Origin");
      fhMCEtaPtOrigin->GetYaxis()->SetBinLabel(1 ,"Status 21");
      fhMCEtaPtOrigin->GetYaxis()->SetBinLabel(2 ,"Quark");
      fhMCEtaPtOrigin->GetYaxis()->SetBinLabel(3 ,"qq Resonances");
      fhMCEtaPtOrigin->GetYaxis()->SetBinLabel(4 ,"Resonances");
      fhMCEtaPtOrigin->GetYaxis()->SetBinLabel(5 ,"Other");
      fhMCEtaPtOrigin->GetYaxis()->SetBinLabel(6 ,"#eta prime");
      
      outputContainer->Add(fhMCEtaPtOrigin) ;
      
      fhMCPi0ProdVertex = new TH2F("hMCPi0ProdVertex","Selected reco pair from generated #pi^{0} #it{p}_{T} vs production vertex",
                                   200,0.,20.,5000,0,500) ;
      fhMCPi0ProdVertex->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhMCPi0ProdVertex->SetYTitle("#it{R} (cm)");
      outputContainer->Add(fhMCPi0ProdVertex) ;
      
      fhMCEtaProdVertex = new TH2F("hMCEtaProdVertex","Selected reco pair from generated #eta #it{p}_{T} vs production vertex",
                                   200,0.,20.,5000,0,500) ;
      fhMCEtaProdVertex->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhMCEtaProdVertex->SetYTitle("#it{R} (cm)");
      outputContainer->Add(fhMCEtaProdVertex) ;
      
      fhPrimPi0ProdVertex = new TH2F("hPrimPi0ProdVertex","generated #pi^{0} #it{p}_{T} vs production vertex",
                                     200,0.,20.,5000,0,500) ;
      fhPrimPi0ProdVertex->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhPrimPi0ProdVertex->SetYTitle("#it{R} (cm)");
      outputContainer->Add(fhPrimPi0ProdVertex) ;
      
      fhPrimEtaProdVertex = new TH2F("hPrimEtaProdVertex","generated #eta #it{p}_{T} vs production vertex",
                                     200,0.,20.,5000,0,500) ;
      fhPrimEtaProdVertex->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhPrimEtaProdVertex->SetYTitle("#it{R} (cm)");
      outputContainer->Add(fhPrimEtaProdVertex) ;
      
      for(Int_t i = 0; i<13; i++)
      {
        fhMCOrgMass[i] = new TH2F(Form("hMCOrgMass_%d",i),Form("#it{M} vs #it{p}_{T}, origin %d",i),nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
        fhMCOrgMass[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
        fhMCOrgMass[i]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
        outputContainer->Add(fhMCOrgMass[i]) ;
        
        fhMCOrgAsym[i]= new TH2F(Form("hMCOrgAsym_%d",i),Form("#it{Asymmetry} vs #it{p}_{T}, origin %d",i),nptbins,ptmin,ptmax,nasymbins,asymmin,asymmax) ;
        fhMCOrgAsym[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
        fhMCOrgAsym[i]->SetYTitle("A");
        outputContainer->Add(fhMCOrgAsym[i]) ;
        
        fhMCOrgDeltaEta[i] = new TH2F(Form("hMCOrgDeltaEta_%d",i),Form("#Delta #eta of pair vs #it{p}_{T}, origin %d",i),nptbins,ptmin,ptmax,netabins,-1.4,1.4) ;
        fhMCOrgDeltaEta[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
        fhMCOrgDeltaEta[i]->SetYTitle("#Delta #eta");
        outputContainer->Add(fhMCOrgDeltaEta[i]) ;
        
        fhMCOrgDeltaPhi[i]= new TH2F(Form("hMCOrgDeltaPhi_%d",i),Form("#Delta #phi of pair vs #it{p}_{T}, origin %d",i),nptbins,ptmin,ptmax,nphibins,-0.7,0.7) ;
        fhMCOrgDeltaPhi[i]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
        fhMCOrgDeltaPhi[i]->SetYTitle("#Delta #phi (rad)");
        outputContainer->Add(fhMCOrgDeltaPhi[i]) ;
        
      }
      
      if(fMultiCutAnaSim)
      {
        fhMCPi0MassPtTrue  = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
        fhMCPi0MassPtRec   = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
        fhMCPi0PtTruePtRec = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
        fhMCEtaMassPtRec   = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
        fhMCEtaMassPtTrue  = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
        fhMCEtaPtTruePtRec = new TH2F*[fNPtCuts*fNAsymCuts*fNCellNCuts];
        for(Int_t ipt=0; ipt<fNPtCuts; ipt++){
          for(Int_t icell=0; icell<fNCellNCuts; icell++){
            for(Int_t iasym=0; iasym<fNAsymCuts; iasym++){
              Int_t index = ((ipt*fNCellNCuts)+icell)*fNAsymCuts + iasym;
              
              fhMCPi0MassPtRec[index] = new TH2F(Form("hMCPi0MassPtRec_pt%d_cell%d_asym%d",ipt,icell,iasym),
                                                 Form("Reconstructed #it{M} vs reconstructed #it{p}_{T} of true #pi^{0} cluster pairs for #it{p}_{T} >%2.2f, #it{N}^{cluster}_{cell}>%d and |#it{A}|>%1.2f",fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym]),
                                                 nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
              fhMCPi0MassPtRec[index]->SetXTitle("#it{p}_{T, reconstructed} (GeV/#it{c})");
              fhMCPi0MassPtRec[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
              outputContainer->Add(fhMCPi0MassPtRec[index]) ;
              
              fhMCPi0MassPtTrue[index] = new TH2F(Form("hMCPi0MassPtTrue_pt%d_cell%d_asym%d",ipt,icell,iasym),
                                                  Form("Reconstructed #it{M} vs generated #it{p}_{T} of true #pi^{0} cluster pairs for #it{p}_{T} >%2.2f, #it{N}^{cluster}_{cell}>%d and |#it{A}|>%1.2f",fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym]),
                                                  nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
              fhMCPi0MassPtTrue[index]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
              fhMCPi0MassPtTrue[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
              outputContainer->Add(fhMCPi0MassPtTrue[index]) ;
              
              fhMCPi0PtTruePtRec[index] = new TH2F(Form("hMCPi0PtTruePtRec_pt%d_cell%d_asym%d",ipt,icell,iasym),
                                                   Form("Generated vs reconstructed #it{p}_{T} of true #pi^{0} cluster pairs, 0.01 < rec. mass < 0.17 MeV/#it{c}^{2} for #it{p}_{T} >%2.2f, #it{N}^{cluster}_{cell}>%d and |#it{A}|>%1.2f",fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym]),
                                                   nptbins,ptmin,ptmax,nptbins,ptmin,ptmax) ;
              fhMCPi0PtTruePtRec[index]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
              fhMCPi0PtTruePtRec[index]->SetYTitle("#it{p}_{T, reconstructed} (GeV/#it{c})");
              outputContainer->Add(fhMCPi0PtTruePtRec[index]) ;
              
              fhMCEtaMassPtRec[index] = new TH2F(Form("hMCEtaMassPtRec_pt%d_cell%d_asym%d",ipt,icell,iasym),
                                                 Form("Reconstructed #it{M} vs reconstructed #it{p}_{T} of true #eta cluster pairs for #it{p}_{T} >%2.2f, #it{N}^{cluster}_{cell}>%d and |#it{A}|>%1.2f",fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym]),
                                                 nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
              fhMCEtaMassPtRec[index]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
              fhMCEtaMassPtRec[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
              outputContainer->Add(fhMCEtaMassPtRec[index]) ;
              
              fhMCEtaMassPtTrue[index] = new TH2F(Form("hMCEtaMassPtTrue_pt%d_cell%d_asym%d",ipt,icell,iasym),
                                                  Form("Reconstructed #it{M} vs generated #it{p}_{T} of true #eta cluster pairs for #it{p}_{T} >%2.2f, #it{N}^{cluster}_{cell}>%d and |#it{A}|>%1.2f",fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym]),
                                                  nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
              fhMCEtaMassPtTrue[index]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
              fhMCEtaMassPtTrue[index]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
              outputContainer->Add(fhMCEtaMassPtTrue[index]) ;
              
              fhMCEtaPtTruePtRec[index] = new TH2F(Form("hMCEtaPtTruePtRec_pt%d_cell%d_asym%d",ipt,icell,iasym),
                                                   Form("Generated vs reconstructed #it{p}_{T} of true #eta cluster pairs, 0.01 < rec. mass < 0.17 MeV/#it{c}^{2} for #it{p}_{T} >%2.2f, ncell>%d and asym >%1.2f",fPtCuts[ipt],fCellNCuts[icell], fAsymCuts[iasym]),
                                                   nptbins,ptmin,ptmax,nptbins,ptmin,ptmax) ;
              fhMCEtaPtTruePtRec[index]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
              fhMCEtaPtTruePtRec[index]->SetYTitle("#it{p}_{T, reconstructed} (GeV/#it{c})");
              outputContainer->Add(fhMCEtaPtTruePtRec[index]) ;
            }
          }
        }
      }//multi cut ana
      else
      {
        fhMCPi0MassPtTrue  = new TH2F*[1];
        fhMCPi0PtTruePtRec = new TH2F*[1];
        fhMCEtaMassPtTrue  = new TH2F*[1];
        fhMCEtaPtTruePtRec = new TH2F*[1];
        
        fhMCPi0MassPtTrue[0] = new TH2F("hMCPi0MassPtTrue","Reconstructed Mass vs generated p_T of true #pi^{0} cluster pairs",nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
        fhMCPi0MassPtTrue[0]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
        fhMCPi0MassPtTrue[0]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
        outputContainer->Add(fhMCPi0MassPtTrue[0]) ;
        
        fhMCPi0PtTruePtRec[0]= new TH2F("hMCPi0PtTruePtRec","Generated vs reconstructed p_T of true #pi^{0} cluster pairs, 0.01 < rec. mass < 0.17 MeV/#it{c}^{2}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax) ;
        fhMCPi0PtTruePtRec[0]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
        fhMCPi0PtTruePtRec[0]->SetYTitle("#it{p}_{T, reconstructed} (GeV/#it{c})");
        outputContainer->Add(fhMCPi0PtTruePtRec[0]) ;
        
        fhMCEtaMassPtTrue[0] = new TH2F("hMCEtaMassPtTrue","Reconstructed Mass vs generated p_T of true #eta cluster pairs",nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
        fhMCEtaMassPtTrue[0]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
        fhMCEtaMassPtTrue[0]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
        outputContainer->Add(fhMCEtaMassPtTrue[0]) ;
        
        fhMCEtaPtTruePtRec[0]= new TH2F("hMCEtaPtTruePtRec","Generated vs reconstructed p_T of true #eta cluster pairs, 0.01 < rec. mass < 0.17 MeV/#it{c}^{2}",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax) ;
        fhMCEtaPtTruePtRec[0]->SetXTitle("#it{p}_{T, generated} (GeV/#it{c})");
        fhMCEtaPtTruePtRec[0]->SetYTitle("#it{p}_{T, reconstructed} (GeV/#it{c})");
        outputContainer->Add(fhMCEtaPtTruePtRec[0]) ;
      }
    }
  }
  
  if(fFillSMCombinations)
  {
    TString pairnamePHOS[] = {"(0-1)","(0-2)","(1-2)","(0-3)","(0-4)","(1-3)","(1-4)","(2-3)","(2-4)","(3-4)"};
    for(Int_t imod=0; imod<fNModules; imod++)
    {
      //Module dependent invariant mass
      snprintf(key, buffersize,"hReMod_%d",imod) ;
      snprintf(title, buffersize,"Real #it{M}_{#gamma#gamma} distr. for Module %d",imod) ;
      fhReMod[imod]  = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
      fhReMod[imod]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
      fhReMod[imod]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
      outputContainer->Add(fhReMod[imod]) ;
      if(GetCalorimeter()==kPHOS)
      {
        snprintf(key, buffersize,"hReDiffPHOSMod_%d",imod) ;
        snprintf(title, buffersize,"Real pairs PHOS, clusters in different Modules: %s",(pairnamePHOS[imod]).Data()) ;
        fhReDiffPHOSMod[imod]  = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
        fhReDiffPHOSMod[imod]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
        fhReDiffPHOSMod[imod]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
        outputContainer->Add(fhReDiffPHOSMod[imod]) ;
      }
      else
      {//EMCAL
        if(imod<fNModules/2)
        {
          snprintf(key, buffersize,"hReSameSectorEMCAL_%d",imod) ;
          snprintf(title, buffersize,"Real pairs EMCAL, clusters in same sector, SM(%d,%d)",imod*2,imod*2+1) ;
          fhReSameSectorEMCALMod[imod]  = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhReSameSectorEMCALMod[imod]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhReSameSectorEMCALMod[imod]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhReSameSectorEMCALMod[imod]) ;
        }
        if(imod<fNModules-2)
        {
          snprintf(key, buffersize,"hReSameSideEMCAL_%d",imod) ;
          snprintf(title, buffersize,"Real pairs EMCAL, clusters in same side SM(%d,%d)",imod, imod+2) ;
          fhReSameSideEMCALMod[imod]  = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhReSameSideEMCALMod[imod]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhReSameSideEMCALMod[imod]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhReSameSideEMCALMod[imod]) ;
        }
      }//EMCAL
      
      if(DoOwnMix())
      {
        snprintf(key, buffersize,"hMiMod_%d",imod) ;
        snprintf(title, buffersize,"Mixed #it{M}_{#gamma#gamma} distr. for Module %d",imod) ;
        fhMiMod[imod]  = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
        fhMiMod[imod]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
        fhMiMod[imod]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
        outputContainer->Add(fhMiMod[imod]) ;
        
        if(GetCalorimeter()==kPHOS)
        {
          snprintf(key, buffersize,"hMiDiffPHOSMod_%d",imod) ;
          snprintf(title, buffersize,"Mixed pairs PHOS, clusters in different Modules: %s",(pairnamePHOS[imod]).Data()) ;
          fhMiDiffPHOSMod[imod]  = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
          fhMiDiffPHOSMod[imod]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
          fhMiDiffPHOSMod[imod]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
          outputContainer->Add(fhMiDiffPHOSMod[imod]) ;
        }//PHOS
        else
        {//EMCAL
          if(imod<fNModules/2)
          {
            snprintf(key, buffersize,"hMiSameSectorEMCALMod_%d",imod) ;
            snprintf(title, buffersize,"Mixed pairs EMCAL, clusters in same sector, SM(%d,%d)",imod*2,imod*2+1) ;
            fhMiSameSectorEMCALMod[imod]  = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
            fhMiSameSectorEMCALMod[imod]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
            fhMiSameSectorEMCALMod[imod]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
            outputContainer->Add(fhMiSameSectorEMCALMod[imod]) ;
          }
          if(imod<fNModules-2){
            
            snprintf(key, buffersize,"hMiSameSideEMCALMod_%d",imod) ;
            snprintf(title, buffersize,"Mixed pairs EMCAL, clusters in same side SM(%d,%d)",imod, imod+2) ;
            fhMiSameSideEMCALMod[imod]  = new TH2F(key,title,nptbins,ptmin,ptmax,nmassbins,massmin,massmax) ;
            fhMiSameSideEMCALMod[imod]->SetXTitle("#it{p}_{T} (GeV/#it{c})");
            fhMiSameSideEMCALMod[imod]->SetYTitle("#it{M}_{#gamma,#gamma} (GeV/#it{c}^{2})");
            outputContainer->Add(fhMiSameSideEMCALMod[imod]) ;
          }
        }//EMCAL
      }// own mix
    }//loop combinations
  } // SM combinations
  
  if(fFillArmenterosThetaStar && IsDataMC())
  {
    TString ebin[] = {"8 < E < 12 GeV","12 < E < 16 GeV", "16 < E < 20 GeV", "E > 20 GeV" };
    Int_t narmbins = 400;
    Float_t armmin = 0;
    Float_t armmax = 0.4;
    
    for(Int_t i = 0; i < 4; i++)
    {
      fhArmPrimPi0[i] =  new TH2F(Form("hArmenterosPrimPi0EBin%d",i),
                                  Form("Armenteros of primary #pi^{0}, %s",ebin[i].Data()),
                                  200, -1, 1, narmbins,armmin,armmax);
      fhArmPrimPi0[i]->SetYTitle("#it{p}_{T}^{Arm}");
      fhArmPrimPi0[i]->SetXTitle("#alpha^{Arm}");
      outputContainer->Add(fhArmPrimPi0[i]) ;
      
      fhArmPrimEta[i] =  new TH2F(Form("hArmenterosPrimEtaEBin%d",i),
                                  Form("Armenteros of primary #eta, %s",ebin[i].Data()),
                                  200, -1, 1, narmbins,armmin,armmax);
      fhArmPrimEta[i]->SetYTitle("#it{p}_{T}^{Arm}");
      fhArmPrimEta[i]->SetXTitle("#alpha^{Arm}");
      outputContainer->Add(fhArmPrimEta[i]) ;
      
    }
    
    // Same as asymmetry ...
    fhCosThStarPrimPi0  = new TH2F
    ("hCosThStarPrimPi0","cos(#theta *) for primary #pi^{0}",nptbins,ptmin,ptmax,200,-1,1);
    fhCosThStarPrimPi0->SetYTitle("cos(#theta *)");
    fhCosThStarPrimPi0->SetXTitle("E_{ #pi^{0}} (GeV)");
    outputContainer->Add(fhCosThStarPrimPi0) ;
    
    fhCosThStarPrimEta  = new TH2F
    ("hCosThStarPrimEta","cos(#theta *) for primary #eta",nptbins,ptmin,ptmax,200,-1,1);
    fhCosThStarPrimEta->SetYTitle("cos(#theta *)");
    fhCosThStarPrimEta->SetXTitle("E_{ #eta} (GeV)");
    outputContainer->Add(fhCosThStarPrimEta) ;
    
  }
  
  //  for(Int_t i = 0; i < outputContainer->GetEntries() ; i++){
  //
  //    printf("Histogram %d, name: %s\n ",i, outputContainer->At(i)->GetName());
  //
  //  }
  
  return outputContainer;
}

//___________________________________________________
void AliAnaPi0::Print(const Option_t * /*opt*/) const
{
  //Print some relevant parameters set for the analysis
  printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
  AliAnaCaloTrackCorrBaseClass::Print(" ");
  
  printf("Number of bins in Centrality:  %d \n",GetNCentrBin()) ;
  printf("Number of bins in Z vert. pos: %d \n",GetNZvertBin()) ;
  printf("Number of bins in Reac. Plain: %d \n",GetNRPBin()) ;
  printf("Depth of event buffer: %d \n",GetNMaxEvMix()) ;
  printf("Pair in same Module: %d \n",fSameSM) ;
  printf("Cuts: \n") ;
  // printf("Z vertex position: -%2.3f < z < %2.3f \n",GetZvertexCut(),GetZvertexCut()) ; //It crashes here, why?
  printf("Number of modules:             %d \n",fNModules) ;
  printf("Select pairs with their angle: %d, edep %d, min angle %2.3f, max angle %2.3f \n",fUseAngleCut, fUseAngleEDepCut, fAngleCut, fAngleMaxCut) ;
  printf("Asymmetry cuts: n = %d, \n",fNAsymCuts) ;
  printf("\tasymmetry < ");
  for(Int_t i = 0; i < fNAsymCuts; i++) printf("%2.2f ",fAsymCuts[i]);
  printf("\n");
  
  printf("PID selection bits: n = %d, \n",fNPIDBits) ;
  printf("\tPID bit = ");
  for(Int_t i = 0; i < fNPIDBits; i++) printf("%d ",fPIDBits[i]);
  printf("\n");
  
  if(fMultiCutAna)
  {
    printf("pT cuts: n = %d, \n",fNPtCuts) ;
    printf("\tpT > ");
    for(Int_t i = 0; i < fNPtCuts; i++) printf("%2.2f ",fPtCuts[i]);
    printf("GeV/c\n");
    
    printf("N cell in cluster cuts: n = %d, \n",fNCellNCuts) ;
    printf("\tnCell > ");
    for(Int_t i = 0; i < fNCellNCuts; i++) printf("%d ",fCellNCuts[i]);
    printf("\n");
    
  }
  printf("------------------------------------------------------\n") ;
}

//________________________________________
void AliAnaPi0::FillAcceptanceHistograms()
{
  //Fill acceptance histograms if MC data is available
  
  Double_t mesonY   = -100 ;
  Double_t mesonE   = -1 ;
  Double_t mesonPt  = -1 ;
  Double_t mesonPhi =  100 ;
  Double_t mesonYeta= -1 ;
  
  Int_t    pdg     = 0 ;
  Int_t    nprim   = 0 ;
  Int_t    nDaught = 0 ;
  Int_t    iphot1  = 0 ;
  Int_t    iphot2  = 0 ;
  
  Float_t cen = GetEventCentrality();
  Float_t ep  = GetEventPlaneAngle();
  
  TParticle        * primStack = 0;
  AliAODMCParticle * primAOD   = 0;
  
  // Get the ESD MC particles container
  AliStack * stack = 0;
  if( GetReader()->ReadStack() )
  {
    stack = GetMCStack();
    if(!stack ) return;
    nprim = stack->GetNtrack();
  }
  
  // Get the AOD MC particles container
  TClonesArray * mcparticles = 0;
  if( GetReader()->ReadAODMCParticles() )
  {
    mcparticles = GetReader()->GetAODMCParticles();
    if( !mcparticles ) return;
    nprim = mcparticles->GetEntriesFast();
  }
  
  for(Int_t i=0 ; i < nprim; i++)
  {
    if(GetReader()->AcceptOnlyHIJINGLabels() && !GetReader()->IsHIJINGLabel(i)) continue ;
    
    if(GetReader()->ReadStack())
    {
      primStack = stack->Particle(i) ;
      if(!primStack)
      {
        AliWarning("ESD primaries pointer not available!!");
        continue;
      }
      
      // If too small  skip
      if( primStack->Energy() < 0.4 ) continue;
      
      pdg       = primStack->GetPdgCode();
      nDaught   = primStack->GetNDaughters();
      iphot1    = primStack->GetDaughter(0) ;
      iphot2    = primStack->GetDaughter(1) ;
      if(primStack->Energy() == TMath::Abs(primStack->Pz()))  continue ; //Protection against floating point exception
      
      //printf("i %d, %s %d  %s %d \n",i, stack->Particle(i)->GetName(), stack->Particle(i)->GetPdgCode(),
      //       prim->GetName(), prim->GetPdgCode());
      
      //Photon kinematics
      primStack->Momentum(fPi0Mom);
      
      mesonY = 0.5*TMath::Log((primStack->Energy()+primStack->Pz())/(primStack->Energy()-primStack->Pz())) ;
    }
    else
    {
      primAOD = (AliAODMCParticle *) mcparticles->At(i);
      if(!primAOD)
      {
        AliWarning("AOD primaries pointer not available!!");
        continue;
      }
      
      // If too small  skip
      if( primAOD->E() < 0.4 ) continue;
      
      pdg     = primAOD->GetPdgCode();
      nDaught = primAOD->GetNDaughters();
      iphot1  = primAOD->GetFirstDaughter() ;
      iphot2  = primAOD->GetLastDaughter() ;
      
      if(primAOD->E() == TMath::Abs(primAOD->Pz()))  continue ; //Protection against floating point exception
      
      //Photon kinematics
      fPi0Mom.SetPxPyPzE(primAOD->Px(),primAOD->Py(),primAOD->Pz(),primAOD->E());
      
      mesonY = 0.5*TMath::Log((primAOD->E()+primAOD->Pz())/(primAOD->E()-primAOD->Pz())) ;
    }
    
    // Select only pi0 or eta
    if( pdg != 111 && pdg != 221) continue ;
    
    mesonPt  = fPi0Mom.Pt () ;
    mesonE   = fPi0Mom.E  () ;
    mesonYeta= fPi0Mom.Eta() ;
    mesonPhi = fPi0Mom.Phi() ;
    if( mesonPhi < 0 ) mesonPhi+=TMath::TwoPi();
    mesonPhi *= TMath::RadToDeg();
    
    if(pdg == 111)
    {
      if(TMath::Abs(mesonY) < 1.0)
      {
        fhPrimPi0E  ->Fill(mesonE ) ;
        fhPrimPi0Pt ->Fill(mesonPt) ;
        fhPrimPi0Phi->Fill(mesonPt, mesonPhi) ;
        
        fhPrimPi0YetaYcut    ->Fill(mesonPt,mesonYeta) ;
        fhPrimPi0PtCentrality->Fill(mesonPt,cen) ;
        fhPrimPi0PtEventPlane->Fill(mesonPt,ep ) ;
      }
      
      fhPrimPi0Y   ->Fill(mesonPt, mesonY) ;
      fhPrimPi0Yeta->Fill(mesonPt, mesonYeta) ;
    }
    else if(pdg == 221)
    {
      if(TMath::Abs(mesonY) < 1.0)
      {
        fhPrimEtaE  ->Fill(mesonE ) ;
        fhPrimEtaPt ->Fill(mesonPt) ;
        fhPrimEtaPhi->Fill(mesonPt, mesonPhi) ;
        
        fhPrimEtaYetaYcut    ->Fill(mesonPt,mesonYeta) ;
        fhPrimEtaPtCentrality->Fill(mesonPt,cen) ;
        fhPrimEtaPtEventPlane->Fill(mesonPt,ep ) ;
      }
      
      fhPrimEtaY   ->Fill(mesonPt, mesonY) ;
      fhPrimEtaYeta->Fill(mesonPt, mesonYeta) ;
    }
    
    //Origin of meson
    if(fFillOriginHisto && TMath::Abs(mesonY) < 0.7)
    {
      Int_t momindex  = -1;
      Int_t mompdg    = -1;
      Int_t momstatus = -1;
      Float_t momR    =  0;
      if(GetReader()->ReadStack())          momindex = primStack->GetFirstMother();
      if(GetReader()->ReadAODMCParticles()) momindex = primAOD  ->GetMother();
      
      if(momindex >= 0 && momindex < nprim)
      {
        if(GetReader()->ReadStack())
        {
          TParticle* mother = stack->Particle(momindex);
          mompdg    = TMath::Abs(mother->GetPdgCode());
          momstatus = mother->GetStatusCode();
          momR      = mother->R();
        }
        
        if(GetReader()->ReadAODMCParticles())
        {
          AliAODMCParticle* mother = (AliAODMCParticle*) mcparticles->At(momindex);
          mompdg    = TMath::Abs(mother->GetPdgCode());
          momstatus = mother->GetStatus();
          momR      = TMath::Sqrt(mother->Xv()*mother->Xv()+mother->Yv()*mother->Yv());
        }
        
        if(pdg == 111)
        {
          if     (momstatus  == 21)fhPrimPi0PtOrigin->Fill(mesonPt,0.5);//parton
          else if(mompdg     < 22 ) fhPrimPi0PtOrigin->Fill(mesonPt,1.5);//quark
          else if(mompdg     > 2100  && mompdg   < 2210) fhPrimPi0PtOrigin->Fill(mesonPt,2.5);// resonances
          else if(mompdg    == 221) fhPrimPi0PtOrigin->Fill(mesonPt,8.5);//eta
          else if(mompdg    == 331) fhPrimPi0PtOrigin->Fill(mesonPt,9.5);//eta prime
          else if(mompdg    == 213) fhPrimPi0PtOrigin->Fill(mesonPt,4.5);//rho
          else if(mompdg    == 223) fhPrimPi0PtOrigin->Fill(mesonPt,5.5);//omega
          else if(mompdg    >= 310   && mompdg    <= 323) fhPrimPi0PtOrigin->Fill(mesonPt,6.5);//k0S, k+-,k*
          else if(mompdg    == 130) fhPrimPi0PtOrigin->Fill(mesonPt,6.5);//k0L
          else if(momstatus == 11 || momstatus  == 12 ) fhPrimPi0PtOrigin->Fill(mesonPt,3.5);//resonances
          else                      fhPrimPi0PtOrigin->Fill(mesonPt,7.5);//other?
          
          //printf("Prim Pi0: index %d, pt %2.2f Prod vertex %3.3f, origin pdg %d, origin status %d, origin UI %d\n",
          //                   momindex, mesonPt,mother->R(),mompdg,momstatus,mother->GetUniqueID());
          
          fhPrimPi0ProdVertex->Fill(mesonPt,momR);
          
        }//pi0
        else
        {
          if     (momstatus == 21 ) fhPrimEtaPtOrigin->Fill(mesonPt,0.5);//parton
          else if(mompdg    < 22  ) fhPrimEtaPtOrigin->Fill(mesonPt,1.5);//quark
          else if(mompdg    > 2100  && mompdg   < 2210) fhPrimEtaPtOrigin->Fill(mesonPt,2.5);//qq resonances
          else if(mompdg    == 331) fhPrimEtaPtOrigin->Fill(mesonPt,5.5);//eta prime
          else if(momstatus == 11 || momstatus  == 12 ) fhPrimEtaPtOrigin->Fill(mesonPt,3.5);//resonances
          else fhPrimEtaPtOrigin->Fill(mesonPt,4.5);//stable, conversions?
          //printf("Other Meson pdg %d, Mother %s, pdg %d, status %d\n",pdg, TDatabasePDG::Instance()->GetParticle(mompdg)->GetName(),mompdg, momstatus );
          
          fhPrimEtaProdVertex->Fill(mesonPt,momR);
          
        }
      } // pi0 has mother
    }
    
    //Check if both photons hit Calorimeter
    if(nDaught != 2 ) continue; //Only interested in 2 gamma decay
    
    if(iphot1 < 0 || iphot1 >= nprim || iphot2 < 0 || iphot2 >= nprim) continue ;
    
    Int_t pdg1 = 0;
    Int_t pdg2 = 0;
    Bool_t inacceptance1 = kTRUE;
    Bool_t inacceptance2 = kTRUE;
    
    if(GetReader()->ReadStack())
    {
      TParticle * phot1 = stack->Particle(iphot1) ;
      TParticle * phot2 = stack->Particle(iphot2) ;
      
      if(!phot1 || !phot2) continue ;
      
      pdg1 = phot1->GetPdgCode();
      pdg2 = phot2->GetPdgCode();
      
      phot1->Momentum(fPhotonMom1);
      phot2->Momentum(fPhotonMom2);
      
      // Check if photons hit the Calorimeter acceptance
      if(IsRealCaloAcceptanceOn())
      {
        if( !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance( GetCalorimeter(), phot1 )) inacceptance1 = kFALSE ;
        if( !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance( GetCalorimeter(), phot2 )) inacceptance2 = kFALSE ;
      }
    }
    
    if(GetReader()->ReadAODMCParticles())
    {
      AliAODMCParticle * phot1 = (AliAODMCParticle *) mcparticles->At(iphot1) ;
      AliAODMCParticle * phot2 = (AliAODMCParticle *) mcparticles->At(iphot2) ;
      
      if(!phot1 || !phot2) continue ;
      
      pdg1 = phot1->GetPdgCode();
      pdg2 = phot2->GetPdgCode();
      
      fPhotonMom1.SetPxPyPzE(phot1->Px(),phot1->Py(),phot1->Pz(),phot1->E());
      fPhotonMom2.SetPxPyPzE(phot2->Px(),phot2->Py(),phot2->Pz(),phot2->E());
      
      // Check if photons hit the Calorimeter acceptance
      if(IsRealCaloAcceptanceOn())
      {
        if( !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance( GetCalorimeter(), phot1 )) inacceptance1 = kFALSE ;
        if( !GetCaloUtils()->IsMCParticleInCalorimeterAcceptance( GetCalorimeter(), phot2 )) inacceptance2 = kFALSE ;
      }
    }
    
    if( pdg1 != 22 || pdg2 !=22) continue ;
    
    // Check if photons hit desired acceptance in the fidutial borders fixed in the analysis
    if(IsFiducialCutOn())
    {
      if( inacceptance1 && !GetFiducialCut()->IsInFiducialCut(fPhotonMom1.Eta(), fPhotonMom1.Phi(), GetCalorimeter()) ) inacceptance1 = kFALSE ;
      if( inacceptance2 && !GetFiducialCut()->IsInFiducialCut(fPhotonMom2.Eta(), fPhotonMom2.Phi(), GetCalorimeter()) ) inacceptance2 = kFALSE ;
    }
    
    if(fFillArmenterosThetaStar) FillArmenterosThetaStar(pdg);
    
    if(GetCalorimeter()==kEMCAL && inacceptance1 && inacceptance2 && fCheckAccInSector)
    {
      Int_t absID1=0;
      Int_t absID2=0;
      
      Float_t photonPhi1 = fPhotonMom1.Phi();
      Float_t photonPhi2 = fPhotonMom2.Phi();
      
      if(photonPhi1 < 0) photonPhi1+=TMath::TwoPi();
      if(photonPhi2 < 0) photonPhi2+=TMath::TwoPi();
      
      GetEMCALGeometry()->GetAbsCellIdFromEtaPhi(fPhotonMom1.Eta(),photonPhi1,absID1);
      GetEMCALGeometry()->GetAbsCellIdFromEtaPhi(fPhotonMom2.Eta(),photonPhi2,absID2);
      
      Int_t sm1 = GetEMCALGeometry()->GetSuperModuleNumber(absID1);
      Int_t sm2 = GetEMCALGeometry()->GetSuperModuleNumber(absID2);
      
      Int_t j=0;
      Bool_t sameSector = kFALSE;
      for(Int_t isector = 0; isector < fNModules/2; isector++)
      {
        j=2*isector;
        if((sm1==j && sm2==j+1) || (sm1==j+1 && sm2==j)) sameSector = kTRUE;
      }
      
      if(sm1!=sm2 && !sameSector)
      {
        inacceptance1 = kFALSE;
        inacceptance2 = kFALSE;
      }
      //if(sm1!=sm2)printf("sm1 %d, sm2 %d, same sector %d, in acceptance %d\n",sm1,sm2,sameSector,inacceptance);
      //                  if(GetEMCALGeometry()->Impact(phot1) && GetEMCALGeometry()->Impact(phot2))
      //                    inacceptance = kTRUE;
    }
    
    AliDebug(2,Form("Accepted in %s?: m (%2.2f,%2.2f,%2.2f), p1 (%2.2f,%2.2f,%2.2f), p2 (%2.2f,%2.2f,%2.2f) : in1 %d, in2 %d",
                    GetCalorimeterString().Data(),
                    mesonPt,mesonYeta,mesonPhi,
                    fPhotonMom1.Pt(),fPhotonMom1.Eta(),fPhotonMom1.Phi()*TMath::RadToDeg(),
                    fPhotonMom2.Pt(),fPhotonMom2.Eta(),fPhotonMom2.Phi()*TMath::RadToDeg(),
                    inacceptance1, inacceptance2));
    
    if(inacceptance1 && inacceptance2)
    {
      Float_t  asym  = TMath::Abs((fPhotonMom1.E()-fPhotonMom2.E()) / (fPhotonMom1.E()+fPhotonMom2.E()));
      Double_t angle = fPhotonMom1.Angle(fPhotonMom2.Vect());
      
      AliDebug(2,Form("\t ACCEPTED pdg %d: pt %2.2f, phi %2.2f, eta %2.2f",pdg,mesonPt,mesonPhi,mesonYeta));
      
      if(pdg==111)
      {
        fhPrimPi0AccE   ->Fill(mesonE) ;
        fhPrimPi0AccPt  ->Fill(mesonPt) ;
        fhPrimPi0AccPhi ->Fill(mesonPt, mesonPhi) ;
        fhPrimPi0AccY   ->Fill(mesonPt, mesonY) ;
        fhPrimPi0AccYeta->Fill(mesonPt, mesonYeta) ;
        fhPrimPi0AccPtCentrality->Fill(mesonPt,cen) ;
        fhPrimPi0AccPtEventPlane->Fill(mesonPt,ep ) ;
        
        if(fFillAngleHisto)
        {
          fhPrimPi0OpeningAngle    ->Fill(mesonPt,angle);
          if(mesonPt > 5)fhPrimPi0OpeningAngleAsym->Fill(asym,angle);
          fhPrimPi0CosOpeningAngle ->Fill(mesonPt,TMath::Cos(angle));
        }
      }
      else if(pdg==221)
      {
        fhPrimEtaAccE   ->Fill(mesonE ) ;
        fhPrimEtaAccPt  ->Fill(mesonPt) ;
        fhPrimEtaAccPhi ->Fill(mesonPt, mesonPhi) ;
        fhPrimEtaAccY   ->Fill(mesonPt, mesonY) ;
        fhPrimEtaAccYeta->Fill(mesonPt, mesonYeta) ;
        fhPrimEtaAccPtCentrality->Fill(mesonPt,cen) ;
        fhPrimEtaAccPtEventPlane->Fill(mesonPt,ep ) ;
        
        if(fFillAngleHisto)
        {
          fhPrimEtaOpeningAngle    ->Fill(mesonPt,angle);
          if(mesonPt > 5)fhPrimEtaOpeningAngleAsym->Fill(asym,angle);
          fhPrimEtaCosOpeningAngle ->Fill(mesonPt,TMath::Cos(angle));
        }
      }
    }//Accepted
    
  }//loop on primaries
  
}

//________________________________________________
void AliAnaPi0::FillArmenterosThetaStar(Int_t pdg)
{
  // Fill armenteros plots
  
  // Get pTArm and AlphaArm
  Float_t momentumSquaredMother = fPi0Mom.P()*fPi0Mom.P();
  Float_t momentumDaughter1AlongMother = 0.;
  Float_t momentumDaughter2AlongMother = 0.;
  
  if (momentumSquaredMother > 0.)
  {
    momentumDaughter1AlongMother = (fPhotonMom1.Px()*fPi0Mom.Px() + fPhotonMom1.Py()*fPi0Mom.Py()+ fPhotonMom1.Pz()*fPi0Mom.Pz()) / sqrt(momentumSquaredMother);
    momentumDaughter2AlongMother = (fPhotonMom2.Px()*fPi0Mom.Px() + fPhotonMom2.Py()*fPi0Mom.Py()+ fPhotonMom2.Pz()*fPi0Mom.Pz()) / sqrt(momentumSquaredMother);
  }
  
  Float_t momentumSquaredDaughter1 = fPhotonMom1.P()*fPhotonMom1.P();
  Float_t ptArmSquared = momentumSquaredDaughter1 - momentumDaughter1AlongMother*momentumDaughter1AlongMother;
  
  Float_t pTArm = 0.;
  if (ptArmSquared > 0.)
    pTArm = sqrt(ptArmSquared);
  
  Float_t alphaArm = 0.;
  if(momentumDaughter1AlongMother + momentumDaughter2AlongMother > 0)
    alphaArm = (momentumDaughter1AlongMother -momentumDaughter2AlongMother) / (momentumDaughter1AlongMother + momentumDaughter2AlongMother);
  
  fPhotonMom1Boost = fPhotonMom1;
  fPhotonMom1Boost.Boost(-fPi0Mom.BoostVector());
  Float_t  cosThStar=TMath::Cos(fPhotonMom1Boost.Vect().Angle(fPi0Mom.Vect()));
  
  Float_t en   = fPi0Mom.Energy();
  Int_t   ebin = -1;
  if(en > 8  && en <= 12) ebin = 0;
  if(en > 12 && en <= 16) ebin = 1;
  if(en > 16 && en <= 20) ebin = 2;
  if(en > 20)             ebin = 3;
  if(ebin < 0 || ebin > 3) return ;
  
  
  if(pdg==111)
  {
    fhCosThStarPrimPi0->Fill(en,cosThStar);
    fhArmPrimPi0[ebin]->Fill(alphaArm,pTArm);
  }
  else
  {
    fhCosThStarPrimEta->Fill(en,cosThStar);
    fhArmPrimEta[ebin]->Fill(alphaArm,pTArm);
  }
  
  //  if(GetDebug() > 2 )
  //  {
  //    Float_t asym = 0;
  //    if(fPhotonMom1.E()+fPhotonMom2.E() > 0) asym = TMath::Abs(fPhotonMom1.E()-fPhotonMom2.E())/(fPhotonMom1.E()+fPhotonMom2.E());
  //
  //    printf("AliAnaPi0::FillArmenterosThetaStar() - E %f, alphaArm %f, pTArm %f, cos(theta*) %f, asymmetry %1.3f\n",
  //         en,alphaArm,pTArm,cosThStar,asym);
  //  }
}

//_______________________________________________________________________________________
void AliAnaPi0::FillMCVersusRecDataHistograms(Int_t index1,  Int_t index2,
                                              Float_t pt1,   Float_t pt2,
                                              Int_t ncell1,  Int_t ncell2,
                                              Double_t mass, Double_t pt,  Double_t asym,
                                              Double_t deta, Double_t dphi)
{
  //Do some MC checks on the origin of the pair, is there any common ancestor and if there is one, who?
  //Adjusted for Pythia, need to see what to do for other generators.
  //Array of histograms ordered as follows: 0-Photon, 1-electron, 2-pi0, 3-eta, 4-a-proton, 5-a-neutron, 6-stable particles,
  // 7-other decays, 8-string, 9-final parton, 10-initial parton, intermediate, 11-colliding proton, 12-unrelated
  
  Int_t ancPDG    = 0;
  Int_t ancStatus = 0;
  Int_t ancLabel  = GetMCAnalysisUtils()->CheckCommonAncestor(index1, index2,
                                                              GetReader(), ancPDG, ancStatus,fPi0Mom, fProdVertex);
  
  Int_t momindex  = -1;
  Int_t mompdg    = -1;
  Int_t momstatus = -1;
  
  Float_t prodR = -1;
  Int_t mcIndex = -1;
  
  if(ancLabel > -1)
  {
    AliDebug(1,Form("Common ancestor label %d, pdg %d, name %s, status %d",
                    ancLabel,ancPDG,TDatabasePDG::Instance()->GetParticle(ancPDG)->GetName(),ancStatus));
    
    if(ancPDG==22)
    {//gamma
      mcIndex = 0;
    }
    else if(TMath::Abs(ancPDG)==11)
    {//e
      mcIndex = 1;
    }
    else if(ancPDG==111)
    {//Pi0
      mcIndex = 2;
      if(fMultiCutAnaSim)
      {
        for(Int_t ipt=0; ipt<fNPtCuts; ipt++)
        {
          for(Int_t icell=0; icell<fNCellNCuts; icell++)
          {
            for(Int_t iasym=0; iasym<fNAsymCuts; iasym++)
            {
              Int_t index = ((ipt*fNCellNCuts)+icell)*fNAsymCuts + iasym;
              if(pt1    >  fPtCuts[ipt]      && pt2    >  fPtCuts[ipt]        &&
                 asym   <  fAsymCuts[iasym]                                   &&
                 ncell1 >= fCellNCuts[icell] && ncell2 >= fCellNCuts[icell])
              {
                fhMCPi0MassPtRec [index]->Fill(pt,mass);
                fhMCPi0MassPtTrue[index]->Fill(fPi0Mom.Pt(),mass);
                if(mass < 0.17 && mass > 0.1) fhMCPi0PtTruePtRec[index]->Fill(fPi0Mom.Pt(),pt);
              }//pass the different cuts
            }// pid bit cut loop
          }// icell loop
        }// pt cut loop
      }//Multi cut ana sim
      else
      {
        fhMCPi0MassPtTrue[0]->Fill(fPi0Mom.Pt(),mass);
        
        if(mass < 0.17 && mass > 0.1)
        {
          fhMCPi0PtTruePtRec[0]->Fill(fPi0Mom.Pt(),pt);
          
          //Int_t uniqueId = -1;
          if(GetReader()->ReadStack())
          {
            TParticle* ancestor = GetMCStack()->Particle(ancLabel);
            momindex  = ancestor->GetFirstMother();
            if(momindex < 0) return;
            TParticle* mother = GetMCStack()->Particle(momindex);
            mompdg    = TMath::Abs(mother->GetPdgCode());
            momstatus = mother->GetStatusCode();
            prodR = mother->R();
            //uniqueId = mother->GetUniqueID();
          }
          else
          {
            TClonesArray * mcparticles = GetReader()->GetAODMCParticles();
            AliAODMCParticle* ancestor = (AliAODMCParticle *) mcparticles->At(ancLabel);
            momindex  = ancestor->GetMother();
            if(momindex < 0) return;
            AliAODMCParticle* mother = (AliAODMCParticle *) mcparticles->At(momindex);
            mompdg    = TMath::Abs(mother->GetPdgCode());
            momstatus = mother->GetStatus();
            prodR = TMath::Sqrt(mother->Xv()*mother->Xv()+mother->Yv()*mother->Yv());
            //uniqueId = mother->GetUniqueID();
          }
          
          //            printf("Reco Pi0: pt %2.2f Prod vertex %3.3f, origin pdg %d, origin status %d, origin UI %d\n",
          //                   pt,prodR,mompdg,momstatus,uniqueId);
          
          fhMCPi0ProdVertex->Fill(pt,prodR);
          
          if     (momstatus  == 21) fhMCPi0PtOrigin->Fill(pt,0.5);//parton
          else if(mompdg     < 22 ) fhMCPi0PtOrigin->Fill(pt,1.5);//quark
          else if(mompdg     > 2100  && mompdg   < 2210) fhMCPi0PtOrigin->Fill(pt,2.5);// resonances
          else if(mompdg    == 221) fhMCPi0PtOrigin->Fill(pt,8.5);//eta
          else if(mompdg    == 331) fhMCPi0PtOrigin->Fill(pt,9.5);//eta prime
          else if(mompdg    == 213) fhMCPi0PtOrigin->Fill(pt,4.5);//rho
          else if(mompdg    == 223) fhMCPi0PtOrigin->Fill(pt,5.5);//omega
          else if(mompdg    >= 310   && mompdg    <= 323) fhMCPi0PtOrigin->Fill(pt,6.5);//k0S, k+-,k*
          else if(mompdg    == 130) fhMCPi0PtOrigin->Fill(pt,6.5);//k0L
          else if(momstatus == 11 || momstatus  == 12 ) fhMCPi0PtOrigin->Fill(pt,3.5);//resonances
          else                      fhMCPi0PtOrigin->Fill(pt,7.5);//other?
          
          
        }//pi0 mass region
      }
    }
    else if(ancPDG==221)
    {//Eta
      mcIndex = 3;
      if(fMultiCutAnaSim)
      {
        for(Int_t ipt=0; ipt<fNPtCuts; ipt++)
        {
          for(Int_t icell=0; icell<fNCellNCuts; icell++)
          {
            for(Int_t iasym=0; iasym<fNAsymCuts; iasym++)
            {
              Int_t index = ((ipt*fNCellNCuts)+icell)*fNAsymCuts + iasym;
              if(pt1    >  fPtCuts[ipt]      && pt2    >  fPtCuts[ipt]        &&
                 asym   <  fAsymCuts[iasym]                                   &&
                 ncell1 >= fCellNCuts[icell] && ncell2 >= fCellNCuts[icell])
              {
                fhMCEtaMassPtRec [index]->Fill(pt,mass);
                fhMCEtaMassPtTrue[index]->Fill(fPi0Mom.Pt(),mass);
                if(mass < 0.65 && mass > 0.45) fhMCEtaPtTruePtRec[index]->Fill(fPi0Mom.Pt(),pt);
              }//pass the different cuts
            }// pid bit cut loop
          }// icell loop
        }// pt cut loop
      } //Multi cut ana sim
      else
      {
        fhMCEtaMassPtTrue[0]->Fill(fPi0Mom.Pt(),mass);
        if(mass < 0.65 && mass > 0.45) fhMCEtaPtTruePtRec[0]->Fill(fPi0Mom.Pt(),pt);
        
        if(GetReader()->ReadStack())
        {
          TParticle* ancestor = GetMCStack()->Particle(ancLabel);
          momindex  = ancestor->GetFirstMother();
          if(momindex < 0) return;
          TParticle* mother = GetMCStack()->Particle(momindex);
          mompdg    = TMath::Abs(mother->GetPdgCode());
          momstatus = mother->GetStatusCode();
          prodR = mother->R();
        }
        else
        {
          TClonesArray * mcparticles = GetReader()->GetAODMCParticles();
          AliAODMCParticle* ancestor = (AliAODMCParticle *) mcparticles->At(ancLabel);
          momindex  = ancestor->GetMother();
          if(momindex < 0) return;
          AliAODMCParticle* mother = (AliAODMCParticle *) mcparticles->At(momindex);
          mompdg    = TMath::Abs(mother->GetPdgCode());
          momstatus = mother->GetStatus();
          prodR = TMath::Sqrt(mother->Xv()*mother->Xv()+mother->Yv()*mother->Yv());
        }
        
        fhMCEtaProdVertex->Fill(pt,prodR);
        
        if     (momstatus == 21 ) fhMCEtaPtOrigin->Fill(pt,0.5);//parton
        else if(mompdg    < 22  ) fhMCEtaPtOrigin->Fill(pt,1.5);//quark
        else if(mompdg    > 2100  && mompdg   < 2210) fhMCEtaPtOrigin->Fill(pt,2.5);//qq resonances
        else if(mompdg    == 331) fhMCEtaPtOrigin->Fill(pt,5.5);//eta prime
        else if(momstatus == 11 || momstatus  == 12 ) fhMCEtaPtOrigin->Fill(pt,3.5);//resonances
        else fhMCEtaPtOrigin->Fill(pt,4.5);//stable, conversions?
        //printf("Other Meson pdg %d, Mother %s, pdg %d, status %d\n",pdg, TDatabasePDG::Instance()->GetParticle(mompdg)->GetName(),mompdg, momstatus );
        
      }// eta mass region
    }
    else if(ancPDG==-2212){//AProton
      mcIndex = 4;
    }
    else if(ancPDG==-2112){//ANeutron
      mcIndex = 5;
    }
    else if(TMath::Abs(ancPDG)==13){//muons
      mcIndex = 6;
    }
    else if (TMath::Abs(ancPDG) > 100 && ancLabel > 7)
    {
      if(ancStatus==1)
      {//Stable particles, converted? not decayed resonances
        mcIndex = 6;
      }
      else
      {//resonances and other decays, more hadron conversions?
        mcIndex = 7;
      }
    }
    else
    {//Partons, colliding protons, strings, intermediate corrections
      if(ancStatus==11 || ancStatus==12)
      {//String fragmentation
        mcIndex = 8;
      }
      else if (ancStatus==21){
        if(ancLabel < 2)
        {//Colliding protons
          mcIndex = 11;
        }//colliding protons
        else if(ancLabel < 6)
        {//partonic initial states interactions
          mcIndex = 9;
        }
        else if(ancLabel < 8)
        {//Final state partons radiations?
          mcIndex = 10;
        }
        // else {
        //   printf("AliAnaPi0::FillMCVersusRecDataHistograms() - Check ** Common ancestor label %d, pdg %d, name %s, status %d; \n",
        //          ancLabel,ancPDG,TDatabasePDG::Instance()->GetParticle(ancPDG)->GetName(),ancStatus);
        // }
      }//status 21
      //else {
      //  printf("AliAnaPi0::FillMCVersusRecDataHistograms() - Check *** Common ancestor label %d, pdg %d, name %s, status %d; \n",
      //         ancLabel,ancPDG,TDatabasePDG::Instance()->GetParticle(ancPDG)->GetName(),ancStatus);
      // }
    }////Partons, colliding protons, strings, intermediate corrections
  }//ancLabel > -1
  else
  { //ancLabel <= -1
    //printf("Not related at all label = %d\n",ancLabel);
    AliDebug(1,"Common ancestor not found");
    
    mcIndex = 12;
  }
  
  if(mcIndex >= 0 && mcIndex < 13)
  {
    fhMCOrgMass[mcIndex]->Fill(pt,mass);
    fhMCOrgAsym[mcIndex]->Fill(pt,asym);
    fhMCOrgDeltaEta[mcIndex]->Fill(pt,deta);
    fhMCOrgDeltaPhi[mcIndex]->Fill(pt,dphi);
  }
  
}

//__________________________________________
void AliAnaPi0::MakeAnalysisFillHistograms()
{
  //Process one event and extract photons from AOD branch
  // filled with AliAnaPhoton and fill histos with invariant mass
  
  //In case of simulated data, fill acceptance histograms
  if(IsDataMC())FillAcceptanceHistograms();
  
  //if (GetReader()->GetEventNumber()%10000 == 0)
  // printf("--- Event %d ---\n",GetReader()->GetEventNumber());
  
  if(!GetInputAODBranch())
  {
    AliFatal(Form("No input aod photons in AOD with name branch < %s >, STOP",GetInputAODName().Data()));
    return;
  }
  
  //Init some variables
  Int_t   nPhot    = GetInputAODBranch()->GetEntriesFast() ;
  
  AliDebug(1,Form("Photon entries %d", nPhot));
  
  //If less than photon 2 entries in the list, skip this event
  if ( nPhot < 2 )
  {
    AliDebug(1,Form("nPhotons %d, cent bin %d continue to next event",nPhot, GetEventCentrality()));
    
    if(GetNCentrBin() > 1) fhCentralityNoPair->Fill(GetEventCentrality() * GetNCentrBin() / GetReader()->GetCentralityOpt());
    
    return ;
  }
  
  Int_t ncentr = GetNCentrBin();
  if(GetNCentrBin()==0) ncentr = 1;
  
  //Init variables
  Int_t module1         = -1;
  Int_t module2         = -1;
  Double_t vert[]       = {0.0, 0.0, 0.0} ; //vertex
  Int_t evtIndex1       = 0 ;
  Int_t currentEvtIndex = -1;
  Int_t curCentrBin     = GetEventCentralityBin();
  //Int_t curVzBin        = GetEventVzBin();
  //Int_t curRPBin        = GetEventRPBin();
  Int_t eventbin        = GetEventMixBin();
  
  if(eventbin > GetNCentrBin()*GetNZvertBin()*GetNRPBin())
  {
    AliWarning(Form("Mix Bin not expected: cen bin %d, z bin %d, rp bin %d, total bin %d, Event Centrality %d, z vertex %2.3f, Reaction Plane %2.3f",
                    GetEventCentralityBin(),GetEventVzBin(), GetEventRPBin(),eventbin,GetEventCentrality(),vert[2],GetEventPlaneAngle()));
    return;
  }
  
  //Get shower shape information of clusters
//  TObjArray *clusters = 0;
//  if     (GetCalorimeter()==kEMCAL) clusters = GetEMCALClusters();
//  else if(GetCalorimeter()==kPHOS ) clusters = GetPHOSClusters() ;
  
  //---------------------------------
  //First loop on photons/clusters
  //---------------------------------
  for(Int_t i1=0; i1<nPhot-1; i1++)
  {
    AliAODPWG4Particle * p1 = (AliAODPWG4Particle*) (GetInputAODBranch()->At(i1)) ;
    //printf("AliAnaPi0::MakeAnalysisFillHistograms() : cluster1 id %d/%d\n",i1,nPhot-1);
    
    // get the event index in the mixed buffer where the photon comes from
    // in case of mixing with analysis frame, not own mixing
    evtIndex1 = GetEventIndex(p1, vert) ;
    if ( evtIndex1 == -1 )
      return ;
    if ( evtIndex1 == -2 )
      continue ;
    
    // Only effective in case of mixed event frame
    if(TMath::Abs(vert[2]) > GetZvertexCut()) continue ;   //vertex cut
    
    if (evtIndex1 != currentEvtIndex)
    {
      //Fill event bin info
      if(DoOwnMix()) fhEventBin->Fill(eventbin) ;
      if(GetNCentrBin() > 1)
      {
        fhCentrality->Fill(curCentrBin);
        if(GetNRPBin() > 1 && GetEventPlane()) fhEventPlaneResolution->Fill(curCentrBin,TMath::Cos(2.*GetEventPlane()->GetQsubRes()));
      }
      currentEvtIndex = evtIndex1 ;
    }
    
    //printf("AliAnaPi0::MakeAnalysisFillHistograms(): Photon 1 Evt %d  Vertex : %f,%f,%f\n",evtIndex1, GetVertex(evtIndex1)[0] ,GetVertex(evtIndex1)[1],GetVertex(evtIndex1)[2]);
    
    //Get the momentum of this cluster
    fPhotonMom1.SetPxPyPzE(p1->Px(),p1->Py(),p1->Pz(),p1->E());
    
    //Get (Super)Module number of this cluster
    module1 =  p1->GetSModNumber();// GetModuleNumber(p1);
    
    //------------------------------------------
    // Recover original cluster
//    Int_t iclus1 = -1 ;
//    AliVCluster * cluster1 = FindCluster(clusters,p1->GetCaloLabel(0),iclus1);
//    if(!cluster1) AliWarning("Cluster1 not found!");
    
    //---------------------------------
    //Second loop on photons/clusters
    //---------------------------------
    for(Int_t i2=i1+1; i2<nPhot; i2++)
    {
      AliAODPWG4Particle * p2 = (AliAODPWG4Particle*) (GetInputAODBranch()->At(i2)) ;
      //printf("AliAnaPi0::MakeAnalysisFillHistograms() : cluster2 i %d/%d\n",i2,nPhot);
      
      //In case of mixing frame, check we are not in the same event as the first cluster
      Int_t evtIndex2 = GetEventIndex(p2, vert) ;
      if ( evtIndex2 == -1 )
        return ;
      if ( evtIndex2 == -2 )
        continue ;
      if (GetMixedEvent() && (evtIndex1 == evtIndex2))
        continue ;
      
//      //------------------------------------------
//      // Recover original cluster
//      Int_t iclus2 = -1;
//      AliVCluster * cluster2 = FindCluster(clusters,p2->GetCaloLabel(0),iclus2,iclus1+1);
//      // start new loop from iclus1+1 to gain some time
//      if(!cluster2) AliWarning("Cluster2 not found!");
//      
//      // Get the TOF,l0 and ncells from the clusters
//      Float_t tof1  = -1;
//      Float_t l01   = -1;
//      Int_t ncell1  = 0;
//      if(cluster1)
//      {
//        tof1   = cluster1->GetTOF()*1e9;
//        l01    = cluster1->GetM02();
//        ncell1 = cluster1->GetNCells();
//        //printf("cluster1: E %2.2f (%2.2f), l0 %2.2f, tof %2.2f\n",cluster1->E(),p1->E(),l01,tof1);
//      }
//      //else printf("cluster1 not available: calo label %d / %d, cluster ID %d\n",
//      //            p1->GetCaloLabel(0),(GetReader()->GetInputEvent())->GetNumberOfCaloClusters()-1,cluster1->GetID());
//      
//      Float_t tof2  = -1;
//      Float_t l02   = -1;
//      Int_t ncell2  = 0;
//      if(cluster2)
//      {
//        tof2   = cluster2->GetTOF()*1e9;
//        l02    = cluster2->GetM02();
//        ncell2 = cluster2->GetNCells();
//        //printf("cluster2: E %2.2f (%2.2f), l0 %2.2f, tof %2.2f\n",cluster2->E(),p2->E(),l02,tof2);
//      }
//      //else printf("cluster2 not available: calo label %d / %d, cluster ID %d\n",
//      //            p2->GetCaloLabel(0),(GetReader()->GetInputEvent())->GetNumberOfCaloClusters()-1,cluster2->GetID());
//      
//      if(cluster1 && cluster2)
//      {
//        Double_t t12diff = tof1-tof2;
//        if(TMath::Abs(t12diff) > GetPairTimeCut()) continue;
//      }
      
      Float_t tof1   = p1->GetTime();
      Float_t l01    = p1->GetM02();
      Int_t   ncell1 = p1->GetNCells();
      //printf("cluster1: E %2.2f, l0 %2.2f, tof %2.2f\n",p1->E(),l01,tof1);
      
      Float_t tof2   = p2->GetTime();
      Float_t l02    = p2->GetM02();
      Int_t   ncell2 = p2->GetNCells();
      //printf("cluster2: E %2.2f, l0 %2.2f, tof %2.2f\n",p2->E(),l02,tof2);

      Double_t t12diff = tof1-tof2;
      fhEPairDiffTime->Fill((fPhotonMom1 + fPhotonMom2).Pt(),t12diff);
      if(TMath::Abs(t12diff) > GetPairTimeCut()) continue;

      //------------------------------------------
      
      //printf("AliAnaPi0::MakeAnalysisFillHistograms(): Photon 2 Evt %d  Vertex : %f,%f,%f\n",evtIndex2, GetVertex(evtIndex2)[0] ,GetVertex(evtIndex2)[1],GetVertex(evtIndex2)[2]);
      
      //Get the momentum of this cluster
      fPhotonMom2.SetPxPyPzE(p2->Px(),p2->Py(),p2->Pz(),p2->E());
      
      //Get module number
      module2 = p2->GetSModNumber(); //GetModuleNumber(p2);
      
      //---------------------------------
      // Get pair kinematics
      //---------------------------------
      Double_t m    = (fPhotonMom1 + fPhotonMom2).M() ;
      Double_t pt   = (fPhotonMom1 + fPhotonMom2).Pt();
      Double_t deta = fPhotonMom1.Eta() - fPhotonMom2.Eta();
      Double_t dphi = fPhotonMom1.Phi() - fPhotonMom2.Phi();
      Double_t a    = TMath::Abs(p1->E()-p2->E())/(p1->E()+p2->E()) ;
      
      AliDebug(2,Form("E: fPhotonMom1 %f, fPhotonMom2 %f; Pair: pT %f, mass %f, a %f", p1->E(), p2->E(), (fPhotonMom1 + fPhotonMom2).E(),m,a));
      
      //--------------------------------
      // Opening angle selection
      //--------------------------------
      //Check if opening angle is too large or too small compared to what is expected
      Double_t angle   = fPhotonMom1.Angle(fPhotonMom2.Vect());
      if(fUseAngleEDepCut && !GetNeutralMesonSelection()->IsAngleInWindow((fPhotonMom1+fPhotonMom2).E(),angle+0.05))
      {
        AliDebug(2,Form("Real pair angle %f not in E %f window",angle, (fPhotonMom1+fPhotonMom2).E()));
        continue;
      }
      
      if(fUseAngleCut && (angle < fAngleCut || angle > fAngleMaxCut))
      {
        AliDebug(2,Form("Real pair cut %f < angle %f < cut %f",fAngleCut, angle, fAngleMaxCut));
        continue;
      }
      
      //-------------------------------------------------------------------------------------------------
      //Fill module dependent histograms, put a cut on assymmetry on the first available cut in the array
      //-------------------------------------------------------------------------------------------------
      if(a < fAsymCuts[0] && fFillSMCombinations)
      {
        if(module1==module2 && module1 >=0 && module1<fNModules)
          fhReMod[module1]->Fill(pt,m) ;
        
        if(GetCalorimeter()==kEMCAL)
        {
          // Same sector
          Int_t j=0;
          for(Int_t i = 0; i < fNModules/2; i++)
          {
            j=2*i;
            if((module1==j && module2==j+1) || (module1==j+1 && module2==j)) fhReSameSectorEMCALMod[i]->Fill(pt,m) ;
          }
          
          // Same side
          for(Int_t i = 0; i < fNModules-2; i++){
            if((module1==i && module2==i+2) || (module1==i+2 && module2==i)) fhReSameSideEMCALMod[i]->Fill(pt,m);
          }
        }//EMCAL
        else {//PHOS
          if((module1==0 && module2==1) || (module1==1 && module2==0)) fhReDiffPHOSMod[0]->Fill(pt,m) ;
          if((module1==0 && module2==2) || (module1==2 && module2==0)) fhReDiffPHOSMod[1]->Fill(pt,m) ;
          if((module1==1 && module2==2) || (module1==2 && module2==1)) fhReDiffPHOSMod[2]->Fill(pt,m) ;
        }//PHOS
      }
      
      //In case we want only pairs in same (super) module, check their origin.
      Bool_t ok = kTRUE;
      if(fSameSM && module1!=module2) ok=kFALSE;
      if(ok)
      {
        //Check if one of the clusters comes from a conversion
        if(fCheckConversion)
        {
          if     (p1->IsTagged() && p2->IsTagged()) fhReConv2->Fill(pt,m);
          else if(p1->IsTagged() || p2->IsTagged()) fhReConv ->Fill(pt,m);
        }
        
        // Fill shower shape cut histograms
        if(fFillSSCombinations)
        {
          if     ( l01 > 0.01 && l01 < 0.4  &&
                   l02 > 0.01 && l02 < 0.4 )               fhReSS[0]->Fill(pt,m); // Tight
          else if( l01 > 0.4  && l02 > 0.4 )               fhReSS[1]->Fill(pt,m); // Loose
          else if( l01 > 0.01 && l01 < 0.4  && l02 > 0.4 ) fhReSS[2]->Fill(pt,m); // Both
          else if( l02 > 0.01 && l02 < 0.4  && l01 > 0.4 ) fhReSS[2]->Fill(pt,m); // Both
        }
        
        //Fill histograms for different bad channel distance, centrality, assymmetry cut and pid bit
        for(Int_t ipid=0; ipid<fNPIDBits; ipid++)
        {
          if((p1->IsPIDOK(fPIDBits[ipid],AliCaloPID::kPhoton)) && (p2->IsPIDOK(fPIDBits[ipid],AliCaloPID::kPhoton)))
          {
            for(Int_t iasym=0; iasym < fNAsymCuts; iasym++)
            {
              if(a < fAsymCuts[iasym])
              {
                Int_t index = ((curCentrBin*fNPIDBits)+ipid)*fNAsymCuts + iasym;
                //printf("index %d :(cen %d * nPID %d + ipid %d)*nasym %d + iasym %d - max index %d\n",index,curCentrBin,fNPIDBits,ipid,fNAsymCuts,iasym, curCentrBin*fNPIDBits*fNAsymCuts);
                
                if(index < 0 || index >= ncentr*fNPIDBits*fNAsymCuts) continue ;
                
                fhRe1     [index]->Fill(pt,m);
                if(fMakeInvPtPlots)fhReInvPt1[index]->Fill(pt,m,1./pt) ;
                if(fFillBadDistHisto)
                {
                  if(p1->DistToBad()>0 && p2->DistToBad()>0)
                  {
                    fhRe2     [index]->Fill(pt,m) ;
                    if(fMakeInvPtPlots)fhReInvPt2[index]->Fill(pt,m,1./pt) ;
                    if(p1->DistToBad()>1 && p2->DistToBad()>1)
                    {
                      fhRe3     [index]->Fill(pt,m) ;
                      if(fMakeInvPtPlots)fhReInvPt3[index]->Fill(pt,m,1./pt) ;
                    }// bad 3
                  }// bad2
                }// Fill bad dist histos
              }//assymetry cut
            }// asymmetry cut loop
          }// bad 1
        }// pid bit loop
        
        //Fill histograms with opening angle
        if(fFillAngleHisto)
        {
          fhRealOpeningAngle   ->Fill(pt,angle);
          fhRealCosOpeningAngle->Fill(pt,TMath::Cos(angle));
        }
        
        //Fill histograms with pair assymmetry
        if(fFillAsymmetryHisto)
        {
          fhRePtAsym->Fill(pt,a);
          if(m > 0.10 && m < 0.17) fhRePtAsymPi0->Fill(pt,a);
          if(m > 0.45 && m < 0.65) fhRePtAsymEta->Fill(pt,a);
        }
        
        //---------
        // MC data
        //---------
        //Do some MC checks on the origin of the pair, is there any common ancestor and if there is one, who?
        if(IsDataMC())
        {
          if(GetMCAnalysisUtils()->CheckTagBit(p1->GetTag(),AliMCAnalysisUtils::kMCConversion) &&
             GetMCAnalysisUtils()->CheckTagBit(p2->GetTag(),AliMCAnalysisUtils::kMCConversion))
          {
            fhReMCFromConversion->Fill(pt,m);
          }
          else if(!GetMCAnalysisUtils()->CheckTagBit(p1->GetTag(),AliMCAnalysisUtils::kMCConversion) &&
                  !GetMCAnalysisUtils()->CheckTagBit(p2->GetTag(),AliMCAnalysisUtils::kMCConversion))
          {
            fhReMCFromNotConversion->Fill(pt,m);
          }
          else
          {
            fhReMCFromMixConversion->Fill(pt,m);
          }
          
          if(fFillOriginHisto)
            FillMCVersusRecDataHistograms(p1->GetLabel(), p2->GetLabel(),p1->Pt(), p2->Pt(),ncell1, ncell2, m, pt, a,deta, dphi);
        }
        
        //-----------------------
        //Multi cuts analysis
        //-----------------------
        if(fMultiCutAna)
        {
          //Histograms for different PID bits selection
          for(Int_t ipid=0; ipid<fNPIDBits; ipid++)
          {
            if(p1->IsPIDOK(fPIDBits[ipid],AliCaloPID::kPhoton)    &&
               p2->IsPIDOK(fPIDBits[ipid],AliCaloPID::kPhoton))   fhRePIDBits[ipid]->Fill(pt,m) ;
            
            //printf("ipt %d, ipid%d, name %s\n",ipt, ipid, fhRePtPIDCuts[ipt*fNPIDBitsBits+ipid]->GetName());
          } // pid bit cut loop
          
          //Several pt,ncell and asymmetry cuts
          for(Int_t ipt=0; ipt<fNPtCuts; ipt++)
          {
            for(Int_t icell=0; icell<fNCellNCuts; icell++)
            {
              for(Int_t iasym=0; iasym<fNAsymCuts; iasym++)
              {
                Int_t index = ((ipt*fNCellNCuts)+icell)*fNAsymCuts + iasym;
                if(p1->E() >   fPtCuts[ipt]      && p2->E() > fPtCuts[ipt]        &&
                   a        <   fAsymCuts[iasym]                                  &&
                   ncell1   >=  fCellNCuts[icell] && ncell2   >= fCellNCuts[icell])
                {
                  fhRePtNCellAsymCuts[index]->Fill(pt,m) ;
                  //printf("ipt %d, icell%d, iasym %d, name %s\n",ipt, icell, iasym,  fhRePtNCellAsymCuts[((ipt*fNCellNCuts)+icell)*fNAsymCuts + iasym]->GetName());
                  if(fFillSMCombinations && module1==module2)
                  {
                    fhRePtNCellAsymCutsSM[module1][index]->Fill(pt,m) ;
                  }
                }
              }// pid bit cut loop
            }// icell loop
          }// pt cut loop
          
          if(GetHistogramRanges()->GetHistoTrackMultiplicityBins())
          {
            for(Int_t iasym = 0; iasym < fNAsymCuts; iasym++)
            {
              if(a < fAsymCuts[iasym]) fhRePtMult[iasym]->Fill(pt,GetTrackMultiplicity(),m) ;
            }
          }
        }// multiple cuts analysis
        
      }// ok if same sm
      
    }// second same event particle
  }// first cluster
  
  //-------------------------------------------------------------
  // Mixing
  //-------------------------------------------------------------
  if(DoOwnMix())
  {
    //Recover events in with same characteristics as the current event
    
    //Check that the bin exists, if not (bad determination of RP, centrality or vz bin) do nothing
    if(eventbin < 0) return ;
    
    TList * evMixList=fEventsList[eventbin] ;
    
    if(!evMixList)
    {
      AliWarning(Form("Mix event list not available, bin %d",eventbin));
      return;
    }
    
    Int_t nMixed = evMixList->GetSize() ;
    for(Int_t ii=0; ii<nMixed; ii++)
    {
      TClonesArray* ev2= (TClonesArray*) (evMixList->At(ii));
      Int_t nPhot2=ev2->GetEntriesFast() ;
      Double_t m = -999;
      AliDebug(1,Form("Mixed event %d photon entries %d, centrality bin %d",ii, nPhot2, GetEventCentralityBin()));
      
      fhEventMixBin->Fill(eventbin) ;
      
      //---------------------------------
      //First loop on photons/clusters
      //---------------------------------
      for(Int_t i1=0; i1<nPhot; i1++)
      {
        AliAODPWG4Particle * p1 = (AliAODPWG4Particle*) (GetInputAODBranch()->At(i1)) ;
        
        if(fSameSM && GetModuleNumber(p1)!=module1) continue;
        
        //Get kinematics of cluster and (super) module of this cluster
        fPhotonMom1.SetPxPyPzE(p1->Px(),p1->Py(),p1->Pz(),p1->E());
        module1 = GetModuleNumber(p1);
        
        //---------------------------------
        //First loop on photons/clusters
        //---------------------------------
        for(Int_t i2=0; i2<nPhot2; i2++)
        {
          AliAODPWG4Particle * p2 = (AliAODPWG4Particle*) (ev2->At(i2)) ;
          
          //Get kinematics of second cluster and calculate those of the pair
          fPhotonMom2.SetPxPyPzE(p2->Px(),p2->Py(),p2->Pz(),p2->E());
          m           = (fPhotonMom1+fPhotonMom2).M() ;
          Double_t pt = (fPhotonMom1 + fPhotonMom2).Pt();
          Double_t a  = TMath::Abs(p1->E()-p2->E())/(p1->E()+p2->E()) ;
          
          //Check if opening angle is too large or too small compared to what is expected
          Double_t angle   = fPhotonMom1.Angle(fPhotonMom2.Vect());
          if(fUseAngleEDepCut && !GetNeutralMesonSelection()->IsAngleInWindow((fPhotonMom1+fPhotonMom2).E(),angle+0.05))
          {
            AliDebug(2,Form("Mix pair angle %f not in E %f window",angle, (fPhotonMom1+fPhotonMom2).E()));
            continue;
          }
          
          if(fUseAngleCut && (angle < fAngleCut || angle > fAngleMaxCut))
          {
            AliDebug(2,Form("Mix pair angle %f < cut %f",angle,fAngleCut));
            continue;
          }
          
          AliDebug(2,Form("Mixed Event: pT: fPhotonMom1 %2.2f, fPhotonMom2 %2.2f; Pair: pT %2.2f, mass %2.3f, a %2.3f",p1->Pt(), p2->Pt(), pt,m,a));
          
          //In case we want only pairs in same (super) module, check their origin.
          module2 = GetModuleNumber(p2);
          
          //-------------------------------------------------------------------------------------------------
          //Fill module dependent histograms, put a cut on assymmetry on the first available cut in the array
          //-------------------------------------------------------------------------------------------------
          if(a < fAsymCuts[0] && fFillSMCombinations){
            if(module1==module2 && module1 >=0 && module1<fNModules)
              fhMiMod[module1]->Fill(pt,m) ;
            
            if(GetCalorimeter()==kEMCAL)
            {
              // Same sector
              Int_t j=0;
              for(Int_t i = 0; i < fNModules/2; i++)
              {
                j=2*i;
                if((module1==j && module2==j+1) || (module1==j+1 && module2==j)) fhMiSameSectorEMCALMod[i]->Fill(pt,m) ;
              }
              
              // Same side
              for(Int_t i = 0; i < fNModules-2; i++)
              {
                if((module1==i && module2==i+2) || (module1==i+2 && module2==i)) fhMiSameSideEMCALMod[i]->Fill(pt,m);
              }
            }//EMCAL
            else
            {//PHOS
              if((module1==0 && module2==1) || (module1==1 && module2==0)) fhMiDiffPHOSMod[0]->Fill(pt,m) ;
              if((module1==0 && module2==2) || (module1==2 && module2==0)) fhMiDiffPHOSMod[1]->Fill(pt,m) ;
              if((module1==1 && module2==2) || (module1==2 && module2==1)) fhMiDiffPHOSMod[2]->Fill(pt,m) ;
            }//PHOS
            
            
          }
          
          Bool_t ok = kTRUE;
          if(fSameSM && module1!=module2) ok=kFALSE;
          if(ok){
            
            //Check if one of the clusters comes from a conversion
            if(fCheckConversion)
            {
              if     (p1->IsTagged() && p2->IsTagged()) fhMiConv2->Fill(pt,m);
              else if(p1->IsTagged() || p2->IsTagged()) fhMiConv ->Fill(pt,m);
            }
            //Fill histograms for different bad channel distance, centrality, assymmetry cut and pid bit
            for(Int_t ipid=0; ipid<fNPIDBits; ipid++)
            {
              if((p1->IsPIDOK(ipid,AliCaloPID::kPhoton)) && (p2->IsPIDOK(ipid,AliCaloPID::kPhoton)))
              {
                for(Int_t iasym=0; iasym < fNAsymCuts; iasym++)
                {
                  if(a < fAsymCuts[iasym])
                  {
                    Int_t index = ((curCentrBin*fNPIDBits)+ipid)*fNAsymCuts + iasym;
                    
                    if(index < 0 || index >= ncentr*fNPIDBits*fNAsymCuts) continue ;
                    
                    fhMi1     [index]->Fill(pt,m) ;
                    
                    if(fMakeInvPtPlots)fhMiInvPt1[index]->Fill(pt,m,1./pt) ;
                    
                    if(fFillBadDistHisto)
                    {
                      if(p1->DistToBad()>0 && p2->DistToBad()>0)
                      {
                        fhMi2     [index]->Fill(pt,m) ;
                        if(fMakeInvPtPlots)fhMiInvPt2[index]->Fill(pt,m,1./pt) ;
                        if(p1->DistToBad()>1 && p2->DistToBad()>1)
                        {
                          fhMi3     [index]->Fill(pt,m) ;
                          if(fMakeInvPtPlots)fhMiInvPt3[index]->Fill(pt,m,1./pt) ;
                        }
                      }
                    }// Fill bad dist histo
                  }//Asymmetry cut
                }// Asymmetry loop
              }//PID cut
            }//loop for histograms
            
            //-----------------------
            //Multi cuts analysis
            //-----------------------
            if(fMultiCutAna){
              //Several pt,ncell and asymmetry cuts
              
              for(Int_t ipt=0; ipt<fNPtCuts; ipt++)
              {
                for(Int_t icell=0; icell<fNCellNCuts; icell++)
                {
                  for(Int_t iasym=0; iasym<fNAsymCuts; iasym++)
                  {
                    Int_t index = ((ipt*fNCellNCuts)+icell)*fNAsymCuts + iasym;
                    if(p1->Pt() >   fPtCuts[ipt]      && p2->Pt() > fPtCuts[ipt]        &&
                       a        <   fAsymCuts[iasym]                                    //&&
                       //p1->GetBtag() >=  fCellNCuts[icell] && p2->GetBtag() >= fCellNCuts[icell] // trick, correct it.
                       )
                    {
                      fhMiPtNCellAsymCuts[index]->Fill(pt,m) ;
                      //printf("ipt %d, icell%d, iasym %d, name %s\n",ipt, icell, iasym,  fhRePtNCellAsymCuts[((ipt*fNCellNCuts)+icell)*fNAsymCuts + iasym]->GetName());
                    }
                  }// pid bit cut loop
                }// icell loop
              }// pt cut loop
            } // Multi cut ana
            
            //Fill histograms with opening angle
            if(fFillAngleHisto)
            {
              fhMixedOpeningAngle   ->Fill(pt,angle);
              fhMixedCosOpeningAngle->Fill(pt,TMath::Cos(angle));
            }
            
          }//ok
        }// second cluster loop
      }//first cluster loop
    }//loop on mixed events
    
    //--------------------------------------------------------
    // Add the current event to the list of events for mixing
    //--------------------------------------------------------
    
    TClonesArray *currentEvent = new TClonesArray(*GetInputAODBranch());
    //Add current event to buffer and Remove redundant events
    if( currentEvent->GetEntriesFast() > 0 )
    {
      evMixList->AddFirst(currentEvent) ;
      currentEvent=0 ; //Now list of particles belongs to buffer and it will be deleted with buffer
      if( evMixList->GetSize() >= GetNMaxEvMix() )
      {
        TClonesArray * tmp = (TClonesArray*) (evMixList->Last()) ;
        evMixList->RemoveLast() ;
        delete tmp ;
      }
    }
    else
    { //empty event
      delete currentEvent ;
      currentEvent=0 ;
    }
  }// DoOwnMix
  
  AliDebug(1,"End fill histograms");
}

//________________________________________________________________________
Int_t AliAnaPi0::GetEventIndex(AliAODPWG4Particle * part, Double_t * vert)
{
  // retieves the event index and checks the vertex
  //    in the mixed buffer returns -2 if vertex NOK
  //    for normal events   returns 0 if vertex OK and -1 if vertex NOK
  
  Int_t evtIndex = -1 ;
  if(GetReader()->GetDataType()!=AliCaloTrackReader::kMC)
  {
    if (GetMixedEvent())
    {
      evtIndex = GetMixedEvent()->EventIndexForCaloCluster(part->GetCaloLabel(0)) ;
      GetVertex(vert,evtIndex);
      
      if(TMath::Abs(vert[2])> GetZvertexCut())
        evtIndex = -2 ; //Event can not be used (vertex, centrality,... cuts not fulfilled)
    }
    else
    {
      // Single event
      GetVertex(vert);
      
      if(TMath::Abs(vert[2])> GetZvertexCut())
        evtIndex = -1 ; //Event can not be used (vertex, centrality,... cuts not fulfilled)
      else
        evtIndex = 0 ;
    }
  }//No MC reader
  else
  {
    evtIndex = 0;
    vert[0] = 0. ; 
    vert[1] = 0. ; 
    vert[2] = 0. ; 
  }
  
  return evtIndex ; 
}

 AliAnaPi0.cxx:1
 AliAnaPi0.cxx:2
 AliAnaPi0.cxx:3
 AliAnaPi0.cxx:4
 AliAnaPi0.cxx:5
 AliAnaPi0.cxx:6
 AliAnaPi0.cxx:7
 AliAnaPi0.cxx:8
 AliAnaPi0.cxx:9
 AliAnaPi0.cxx:10
 AliAnaPi0.cxx:11
 AliAnaPi0.cxx:12
 AliAnaPi0.cxx:13
 AliAnaPi0.cxx:14
 AliAnaPi0.cxx:15
 AliAnaPi0.cxx:16
 AliAnaPi0.cxx:17
 AliAnaPi0.cxx:18
 AliAnaPi0.cxx:19
 AliAnaPi0.cxx:20
 AliAnaPi0.cxx:21
 AliAnaPi0.cxx:22
 AliAnaPi0.cxx:23
 AliAnaPi0.cxx:24
 AliAnaPi0.cxx:25
 AliAnaPi0.cxx:26
 AliAnaPi0.cxx:27
 AliAnaPi0.cxx:28
 AliAnaPi0.cxx:29
 AliAnaPi0.cxx:30
 AliAnaPi0.cxx:31
 AliAnaPi0.cxx:32
 AliAnaPi0.cxx:33
 AliAnaPi0.cxx:34
 AliAnaPi0.cxx:35
 AliAnaPi0.cxx:36
 AliAnaPi0.cxx:37
 AliAnaPi0.cxx:38
 AliAnaPi0.cxx:39
 AliAnaPi0.cxx:40
 AliAnaPi0.cxx:41
 AliAnaPi0.cxx:42
 AliAnaPi0.cxx:43
 AliAnaPi0.cxx:44
 AliAnaPi0.cxx:45
 AliAnaPi0.cxx:46
 AliAnaPi0.cxx:47
 AliAnaPi0.cxx:48
 AliAnaPi0.cxx:49
 AliAnaPi0.cxx:50
 AliAnaPi0.cxx:51
 AliAnaPi0.cxx:52
 AliAnaPi0.cxx:53
 AliAnaPi0.cxx:54
 AliAnaPi0.cxx:55
 AliAnaPi0.cxx:56
 AliAnaPi0.cxx:57
 AliAnaPi0.cxx:58
 AliAnaPi0.cxx:59
 AliAnaPi0.cxx:60
 AliAnaPi0.cxx:61
 AliAnaPi0.cxx:62
 AliAnaPi0.cxx:63
 AliAnaPi0.cxx:64
 AliAnaPi0.cxx:65
 AliAnaPi0.cxx:66
 AliAnaPi0.cxx:67
 AliAnaPi0.cxx:68
 AliAnaPi0.cxx:69
 AliAnaPi0.cxx:70
 AliAnaPi0.cxx:71
 AliAnaPi0.cxx:72
 AliAnaPi0.cxx:73
 AliAnaPi0.cxx:74
 AliAnaPi0.cxx:75
 AliAnaPi0.cxx:76
 AliAnaPi0.cxx:77
 AliAnaPi0.cxx:78
 AliAnaPi0.cxx:79
 AliAnaPi0.cxx:80
 AliAnaPi0.cxx:81
 AliAnaPi0.cxx:82
 AliAnaPi0.cxx:83
 AliAnaPi0.cxx:84
 AliAnaPi0.cxx:85
 AliAnaPi0.cxx:86
 AliAnaPi0.cxx:87
 AliAnaPi0.cxx:88
 AliAnaPi0.cxx:89
 AliAnaPi0.cxx:90
 AliAnaPi0.cxx:91
 AliAnaPi0.cxx:92
 AliAnaPi0.cxx:93
 AliAnaPi0.cxx:94
 AliAnaPi0.cxx:95
 AliAnaPi0.cxx:96
 AliAnaPi0.cxx:97
 AliAnaPi0.cxx:98
 AliAnaPi0.cxx:99
 AliAnaPi0.cxx:100
 AliAnaPi0.cxx:101
 AliAnaPi0.cxx:102
 AliAnaPi0.cxx:103
 AliAnaPi0.cxx:104
 AliAnaPi0.cxx:105
 AliAnaPi0.cxx:106
 AliAnaPi0.cxx:107
 AliAnaPi0.cxx:108
 AliAnaPi0.cxx:109
 AliAnaPi0.cxx:110
 AliAnaPi0.cxx:111
 AliAnaPi0.cxx:112
 AliAnaPi0.cxx:113
 AliAnaPi0.cxx:114
 AliAnaPi0.cxx:115
 AliAnaPi0.cxx:116
 AliAnaPi0.cxx:117
 AliAnaPi0.cxx:118
 AliAnaPi0.cxx:119
 AliAnaPi0.cxx:120
 AliAnaPi0.cxx:121
 AliAnaPi0.cxx:122
 AliAnaPi0.cxx:123
 AliAnaPi0.cxx:124
 AliAnaPi0.cxx:125
 AliAnaPi0.cxx:126
 AliAnaPi0.cxx:127
 AliAnaPi0.cxx:128
 AliAnaPi0.cxx:129
 AliAnaPi0.cxx:130
 AliAnaPi0.cxx:131
 AliAnaPi0.cxx:132
 AliAnaPi0.cxx:133
 AliAnaPi0.cxx:134
 AliAnaPi0.cxx:135
 AliAnaPi0.cxx:136
 AliAnaPi0.cxx:137
 AliAnaPi0.cxx:138
 AliAnaPi0.cxx:139
 AliAnaPi0.cxx:140
 AliAnaPi0.cxx:141
 AliAnaPi0.cxx:142
 AliAnaPi0.cxx:143
 AliAnaPi0.cxx:144
 AliAnaPi0.cxx:145
 AliAnaPi0.cxx:146
 AliAnaPi0.cxx:147
 AliAnaPi0.cxx:148
 AliAnaPi0.cxx:149
 AliAnaPi0.cxx:150
 AliAnaPi0.cxx:151
 AliAnaPi0.cxx:152
 AliAnaPi0.cxx:153
 AliAnaPi0.cxx:154
 AliAnaPi0.cxx:155
 AliAnaPi0.cxx:156
 AliAnaPi0.cxx:157
 AliAnaPi0.cxx:158
 AliAnaPi0.cxx:159
 AliAnaPi0.cxx:160
 AliAnaPi0.cxx:161
 AliAnaPi0.cxx:162
 AliAnaPi0.cxx:163
 AliAnaPi0.cxx:164
 AliAnaPi0.cxx:165
 AliAnaPi0.cxx:166
 AliAnaPi0.cxx:167
 AliAnaPi0.cxx:168
 AliAnaPi0.cxx:169
 AliAnaPi0.cxx:170
 AliAnaPi0.cxx:171
 AliAnaPi0.cxx:172
 AliAnaPi0.cxx:173
 AliAnaPi0.cxx:174
 AliAnaPi0.cxx:175
 AliAnaPi0.cxx:176
 AliAnaPi0.cxx:177
 AliAnaPi0.cxx:178
 AliAnaPi0.cxx:179
 AliAnaPi0.cxx:180
 AliAnaPi0.cxx:181
 AliAnaPi0.cxx:182
 AliAnaPi0.cxx:183
 AliAnaPi0.cxx:184
 AliAnaPi0.cxx:185
 AliAnaPi0.cxx:186
 AliAnaPi0.cxx:187
 AliAnaPi0.cxx:188
 AliAnaPi0.cxx:189
 AliAnaPi0.cxx:190
 AliAnaPi0.cxx:191
 AliAnaPi0.cxx:192
 AliAnaPi0.cxx:193
 AliAnaPi0.cxx:194
 AliAnaPi0.cxx:195
 AliAnaPi0.cxx:196
 AliAnaPi0.cxx:197
 AliAnaPi0.cxx:198
 AliAnaPi0.cxx:199
 AliAnaPi0.cxx:200
 AliAnaPi0.cxx:201
 AliAnaPi0.cxx:202
 AliAnaPi0.cxx:203
 AliAnaPi0.cxx:204
 AliAnaPi0.cxx:205
 AliAnaPi0.cxx:206
 AliAnaPi0.cxx:207
 AliAnaPi0.cxx:208
 AliAnaPi0.cxx:209
 AliAnaPi0.cxx:210
 AliAnaPi0.cxx:211
 AliAnaPi0.cxx:212
 AliAnaPi0.cxx:213
 AliAnaPi0.cxx:214
 AliAnaPi0.cxx:215
 AliAnaPi0.cxx:216
 AliAnaPi0.cxx:217
 AliAnaPi0.cxx:218
 AliAnaPi0.cxx:219
 AliAnaPi0.cxx:220
 AliAnaPi0.cxx:221
 AliAnaPi0.cxx:222
 AliAnaPi0.cxx:223
 AliAnaPi0.cxx:224
 AliAnaPi0.cxx:225
 AliAnaPi0.cxx:226
 AliAnaPi0.cxx:227
 AliAnaPi0.cxx:228
 AliAnaPi0.cxx:229
 AliAnaPi0.cxx:230
 AliAnaPi0.cxx:231
 AliAnaPi0.cxx:232
 AliAnaPi0.cxx:233
 AliAnaPi0.cxx:234
 AliAnaPi0.cxx:235
 AliAnaPi0.cxx:236
 AliAnaPi0.cxx:237
 AliAnaPi0.cxx:238
 AliAnaPi0.cxx:239
 AliAnaPi0.cxx:240
 AliAnaPi0.cxx:241
 AliAnaPi0.cxx:242
 AliAnaPi0.cxx:243
 AliAnaPi0.cxx:244
 AliAnaPi0.cxx:245
 AliAnaPi0.cxx:246
 AliAnaPi0.cxx:247
 AliAnaPi0.cxx:248
 AliAnaPi0.cxx:249
 AliAnaPi0.cxx:250
 AliAnaPi0.cxx:251
 AliAnaPi0.cxx:252
 AliAnaPi0.cxx:253
 AliAnaPi0.cxx:254
 AliAnaPi0.cxx:255
 AliAnaPi0.cxx:256
 AliAnaPi0.cxx:257
 AliAnaPi0.cxx:258
 AliAnaPi0.cxx:259
 AliAnaPi0.cxx:260
 AliAnaPi0.cxx:261
 AliAnaPi0.cxx:262
 AliAnaPi0.cxx:263
 AliAnaPi0.cxx:264
 AliAnaPi0.cxx:265
 AliAnaPi0.cxx:266
 AliAnaPi0.cxx:267
 AliAnaPi0.cxx:268
 AliAnaPi0.cxx:269
 AliAnaPi0.cxx:270
 AliAnaPi0.cxx:271
 AliAnaPi0.cxx:272
 AliAnaPi0.cxx:273
 AliAnaPi0.cxx:274
 AliAnaPi0.cxx:275
 AliAnaPi0.cxx:276
 AliAnaPi0.cxx:277
 AliAnaPi0.cxx:278
 AliAnaPi0.cxx:279
 AliAnaPi0.cxx:280
 AliAnaPi0.cxx:281
 AliAnaPi0.cxx:282
 AliAnaPi0.cxx:283
 AliAnaPi0.cxx:284
 AliAnaPi0.cxx:285
 AliAnaPi0.cxx:286
 AliAnaPi0.cxx:287
 AliAnaPi0.cxx:288
 AliAnaPi0.cxx:289
 AliAnaPi0.cxx:290
 AliAnaPi0.cxx:291
 AliAnaPi0.cxx:292
 AliAnaPi0.cxx:293
 AliAnaPi0.cxx:294
 AliAnaPi0.cxx:295
 AliAnaPi0.cxx:296
 AliAnaPi0.cxx:297
 AliAnaPi0.cxx:298
 AliAnaPi0.cxx:299
 AliAnaPi0.cxx:300
 AliAnaPi0.cxx:301
 AliAnaPi0.cxx:302
 AliAnaPi0.cxx:303
 AliAnaPi0.cxx:304
 AliAnaPi0.cxx:305
 AliAnaPi0.cxx:306
 AliAnaPi0.cxx:307
 AliAnaPi0.cxx:308
 AliAnaPi0.cxx:309
 AliAnaPi0.cxx:310
 AliAnaPi0.cxx:311
 AliAnaPi0.cxx:312
 AliAnaPi0.cxx:313
 AliAnaPi0.cxx:314
 AliAnaPi0.cxx:315
 AliAnaPi0.cxx:316
 AliAnaPi0.cxx:317
 AliAnaPi0.cxx:318
 AliAnaPi0.cxx:319
 AliAnaPi0.cxx:320
 AliAnaPi0.cxx:321
 AliAnaPi0.cxx:322
 AliAnaPi0.cxx:323
 AliAnaPi0.cxx:324
 AliAnaPi0.cxx:325
 AliAnaPi0.cxx:326
 AliAnaPi0.cxx:327
 AliAnaPi0.cxx:328
 AliAnaPi0.cxx:329
 AliAnaPi0.cxx:330
 AliAnaPi0.cxx:331
 AliAnaPi0.cxx:332
 AliAnaPi0.cxx:333
 AliAnaPi0.cxx:334
 AliAnaPi0.cxx:335
 AliAnaPi0.cxx:336
 AliAnaPi0.cxx:337
 AliAnaPi0.cxx:338
 AliAnaPi0.cxx:339
 AliAnaPi0.cxx:340
 AliAnaPi0.cxx:341
 AliAnaPi0.cxx:342
 AliAnaPi0.cxx:343
 AliAnaPi0.cxx:344
 AliAnaPi0.cxx:345
 AliAnaPi0.cxx:346
 AliAnaPi0.cxx:347
 AliAnaPi0.cxx:348
 AliAnaPi0.cxx:349
 AliAnaPi0.cxx:350
 AliAnaPi0.cxx:351
 AliAnaPi0.cxx:352
 AliAnaPi0.cxx:353
 AliAnaPi0.cxx:354
 AliAnaPi0.cxx:355
 AliAnaPi0.cxx:356
 AliAnaPi0.cxx:357
 AliAnaPi0.cxx:358
 AliAnaPi0.cxx:359
 AliAnaPi0.cxx:360
 AliAnaPi0.cxx:361
 AliAnaPi0.cxx:362
 AliAnaPi0.cxx:363
 AliAnaPi0.cxx:364
 AliAnaPi0.cxx:365
 AliAnaPi0.cxx:366
 AliAnaPi0.cxx:367
 AliAnaPi0.cxx:368
 AliAnaPi0.cxx:369
 AliAnaPi0.cxx:370
 AliAnaPi0.cxx:371
 AliAnaPi0.cxx:372
 AliAnaPi0.cxx:373
 AliAnaPi0.cxx:374
 AliAnaPi0.cxx:375
 AliAnaPi0.cxx:376
 AliAnaPi0.cxx:377
 AliAnaPi0.cxx:378
 AliAnaPi0.cxx:379
 AliAnaPi0.cxx:380
 AliAnaPi0.cxx:381
 AliAnaPi0.cxx:382
 AliAnaPi0.cxx:383
 AliAnaPi0.cxx:384
 AliAnaPi0.cxx:385
 AliAnaPi0.cxx:386
 AliAnaPi0.cxx:387
 AliAnaPi0.cxx:388
 AliAnaPi0.cxx:389
 AliAnaPi0.cxx:390
 AliAnaPi0.cxx:391
 AliAnaPi0.cxx:392
 AliAnaPi0.cxx:393
 AliAnaPi0.cxx:394
 AliAnaPi0.cxx:395
 AliAnaPi0.cxx:396
 AliAnaPi0.cxx:397
 AliAnaPi0.cxx:398
 AliAnaPi0.cxx:399
 AliAnaPi0.cxx:400
 AliAnaPi0.cxx:401
 AliAnaPi0.cxx:402
 AliAnaPi0.cxx:403
 AliAnaPi0.cxx:404
 AliAnaPi0.cxx:405
 AliAnaPi0.cxx:406
 AliAnaPi0.cxx:407
 AliAnaPi0.cxx:408
 AliAnaPi0.cxx:409
 AliAnaPi0.cxx:410
 AliAnaPi0.cxx:411
 AliAnaPi0.cxx:412
 AliAnaPi0.cxx:413
 AliAnaPi0.cxx:414
 AliAnaPi0.cxx:415
 AliAnaPi0.cxx:416
 AliAnaPi0.cxx:417
 AliAnaPi0.cxx:418
 AliAnaPi0.cxx:419
 AliAnaPi0.cxx:420
 AliAnaPi0.cxx:421
 AliAnaPi0.cxx:422
 AliAnaPi0.cxx:423
 AliAnaPi0.cxx:424
 AliAnaPi0.cxx:425
 AliAnaPi0.cxx:426
 AliAnaPi0.cxx:427
 AliAnaPi0.cxx:428
 AliAnaPi0.cxx:429
 AliAnaPi0.cxx:430
 AliAnaPi0.cxx:431
 AliAnaPi0.cxx:432
 AliAnaPi0.cxx:433
 AliAnaPi0.cxx:434
 AliAnaPi0.cxx:435
 AliAnaPi0.cxx:436
 AliAnaPi0.cxx:437
 AliAnaPi0.cxx:438
 AliAnaPi0.cxx:439
 AliAnaPi0.cxx:440
 AliAnaPi0.cxx:441
 AliAnaPi0.cxx:442
 AliAnaPi0.cxx:443
 AliAnaPi0.cxx:444
 AliAnaPi0.cxx:445
 AliAnaPi0.cxx:446
 AliAnaPi0.cxx:447
 AliAnaPi0.cxx:448
 AliAnaPi0.cxx:449
 AliAnaPi0.cxx:450
 AliAnaPi0.cxx:451
 AliAnaPi0.cxx:452
 AliAnaPi0.cxx:453
 AliAnaPi0.cxx:454
 AliAnaPi0.cxx:455
 AliAnaPi0.cxx:456
 AliAnaPi0.cxx:457
 AliAnaPi0.cxx:458
 AliAnaPi0.cxx:459
 AliAnaPi0.cxx:460
 AliAnaPi0.cxx:461
 AliAnaPi0.cxx:462
 AliAnaPi0.cxx:463
 AliAnaPi0.cxx:464
 AliAnaPi0.cxx:465
 AliAnaPi0.cxx:466
 AliAnaPi0.cxx:467
 AliAnaPi0.cxx:468
 AliAnaPi0.cxx:469
 AliAnaPi0.cxx:470
 AliAnaPi0.cxx:471
 AliAnaPi0.cxx:472
 AliAnaPi0.cxx:473
 AliAnaPi0.cxx:474
 AliAnaPi0.cxx:475
 AliAnaPi0.cxx:476
 AliAnaPi0.cxx:477
 AliAnaPi0.cxx:478
 AliAnaPi0.cxx:479
 AliAnaPi0.cxx:480
 AliAnaPi0.cxx:481
 AliAnaPi0.cxx:482
 AliAnaPi0.cxx:483
 AliAnaPi0.cxx:484
 AliAnaPi0.cxx:485
 AliAnaPi0.cxx:486
 AliAnaPi0.cxx:487
 AliAnaPi0.cxx:488
 AliAnaPi0.cxx:489
 AliAnaPi0.cxx:490
 AliAnaPi0.cxx:491
 AliAnaPi0.cxx:492
 AliAnaPi0.cxx:493
 AliAnaPi0.cxx:494
 AliAnaPi0.cxx:495
 AliAnaPi0.cxx:496
 AliAnaPi0.cxx:497
 AliAnaPi0.cxx:498
 AliAnaPi0.cxx:499
 AliAnaPi0.cxx:500
 AliAnaPi0.cxx:501
 AliAnaPi0.cxx:502
 AliAnaPi0.cxx:503
 AliAnaPi0.cxx:504
 AliAnaPi0.cxx:505
 AliAnaPi0.cxx:506
 AliAnaPi0.cxx:507
 AliAnaPi0.cxx:508
 AliAnaPi0.cxx:509
 AliAnaPi0.cxx:510
 AliAnaPi0.cxx:511
 AliAnaPi0.cxx:512
 AliAnaPi0.cxx:513
 AliAnaPi0.cxx:514
 AliAnaPi0.cxx:515
 AliAnaPi0.cxx:516
 AliAnaPi0.cxx:517
 AliAnaPi0.cxx:518
 AliAnaPi0.cxx:519
 AliAnaPi0.cxx:520
 AliAnaPi0.cxx:521
 AliAnaPi0.cxx:522
 AliAnaPi0.cxx:523
 AliAnaPi0.cxx:524
 AliAnaPi0.cxx:525
 AliAnaPi0.cxx:526
 AliAnaPi0.cxx:527
 AliAnaPi0.cxx:528
 AliAnaPi0.cxx:529
 AliAnaPi0.cxx:530
 AliAnaPi0.cxx:531
 AliAnaPi0.cxx:532
 AliAnaPi0.cxx:533
 AliAnaPi0.cxx:534
 AliAnaPi0.cxx:535
 AliAnaPi0.cxx:536
 AliAnaPi0.cxx:537
 AliAnaPi0.cxx:538
 AliAnaPi0.cxx:539
 AliAnaPi0.cxx:540
 AliAnaPi0.cxx:541
 AliAnaPi0.cxx:542
 AliAnaPi0.cxx:543
 AliAnaPi0.cxx:544
 AliAnaPi0.cxx:545
 AliAnaPi0.cxx:546
 AliAnaPi0.cxx:547
 AliAnaPi0.cxx:548
 AliAnaPi0.cxx:549
 AliAnaPi0.cxx:550
 AliAnaPi0.cxx:551
 AliAnaPi0.cxx:552
 AliAnaPi0.cxx:553
 AliAnaPi0.cxx:554
 AliAnaPi0.cxx:555
 AliAnaPi0.cxx:556
 AliAnaPi0.cxx:557
 AliAnaPi0.cxx:558
 AliAnaPi0.cxx:559
 AliAnaPi0.cxx:560
 AliAnaPi0.cxx:561
 AliAnaPi0.cxx:562
 AliAnaPi0.cxx:563
 AliAnaPi0.cxx:564
 AliAnaPi0.cxx:565
 AliAnaPi0.cxx:566
 AliAnaPi0.cxx:567
 AliAnaPi0.cxx:568
 AliAnaPi0.cxx:569
 AliAnaPi0.cxx:570
 AliAnaPi0.cxx:571
 AliAnaPi0.cxx:572
 AliAnaPi0.cxx:573
 AliAnaPi0.cxx:574
 AliAnaPi0.cxx:575
 AliAnaPi0.cxx:576
 AliAnaPi0.cxx:577
 AliAnaPi0.cxx:578
 AliAnaPi0.cxx:579
 AliAnaPi0.cxx:580
 AliAnaPi0.cxx:581
 AliAnaPi0.cxx:582
 AliAnaPi0.cxx:583
 AliAnaPi0.cxx:584
 AliAnaPi0.cxx:585
 AliAnaPi0.cxx:586
 AliAnaPi0.cxx:587
 AliAnaPi0.cxx:588
 AliAnaPi0.cxx:589
 AliAnaPi0.cxx:590
 AliAnaPi0.cxx:591
 AliAnaPi0.cxx:592
 AliAnaPi0.cxx:593
 AliAnaPi0.cxx:594
 AliAnaPi0.cxx:595
 AliAnaPi0.cxx:596
 AliAnaPi0.cxx:597
 AliAnaPi0.cxx:598
 AliAnaPi0.cxx:599
 AliAnaPi0.cxx:600
 AliAnaPi0.cxx:601
 AliAnaPi0.cxx:602
 AliAnaPi0.cxx:603
 AliAnaPi0.cxx:604
 AliAnaPi0.cxx:605
 AliAnaPi0.cxx:606
 AliAnaPi0.cxx:607
 AliAnaPi0.cxx:608
 AliAnaPi0.cxx:609
 AliAnaPi0.cxx:610
 AliAnaPi0.cxx:611
 AliAnaPi0.cxx:612
 AliAnaPi0.cxx:613
 AliAnaPi0.cxx:614
 AliAnaPi0.cxx:615
 AliAnaPi0.cxx:616
 AliAnaPi0.cxx:617
 AliAnaPi0.cxx:618
 AliAnaPi0.cxx:619
 AliAnaPi0.cxx:620
 AliAnaPi0.cxx:621
 AliAnaPi0.cxx:622
 AliAnaPi0.cxx:623
 AliAnaPi0.cxx:624
 AliAnaPi0.cxx:625
 AliAnaPi0.cxx:626
 AliAnaPi0.cxx:627
 AliAnaPi0.cxx:628
 AliAnaPi0.cxx:629
 AliAnaPi0.cxx:630
 AliAnaPi0.cxx:631
 AliAnaPi0.cxx:632
 AliAnaPi0.cxx:633
 AliAnaPi0.cxx:634
 AliAnaPi0.cxx:635
 AliAnaPi0.cxx:636
 AliAnaPi0.cxx:637
 AliAnaPi0.cxx:638
 AliAnaPi0.cxx:639
 AliAnaPi0.cxx:640
 AliAnaPi0.cxx:641
 AliAnaPi0.cxx:642
 AliAnaPi0.cxx:643
 AliAnaPi0.cxx:644
 AliAnaPi0.cxx:645
 AliAnaPi0.cxx:646
 AliAnaPi0.cxx:647
 AliAnaPi0.cxx:648
 AliAnaPi0.cxx:649
 AliAnaPi0.cxx:650
 AliAnaPi0.cxx:651
 AliAnaPi0.cxx:652
 AliAnaPi0.cxx:653
 AliAnaPi0.cxx:654
 AliAnaPi0.cxx:655
 AliAnaPi0.cxx:656
 AliAnaPi0.cxx:657
 AliAnaPi0.cxx:658
 AliAnaPi0.cxx:659
 AliAnaPi0.cxx:660
 AliAnaPi0.cxx:661
 AliAnaPi0.cxx:662
 AliAnaPi0.cxx:663
 AliAnaPi0.cxx:664
 AliAnaPi0.cxx:665
 AliAnaPi0.cxx:666
 AliAnaPi0.cxx:667
 AliAnaPi0.cxx:668
 AliAnaPi0.cxx:669
 AliAnaPi0.cxx:670
 AliAnaPi0.cxx:671
 AliAnaPi0.cxx:672
 AliAnaPi0.cxx:673
 AliAnaPi0.cxx:674
 AliAnaPi0.cxx:675
 AliAnaPi0.cxx:676
 AliAnaPi0.cxx:677
 AliAnaPi0.cxx:678
 AliAnaPi0.cxx:679
 AliAnaPi0.cxx:680
 AliAnaPi0.cxx:681
 AliAnaPi0.cxx:682
 AliAnaPi0.cxx:683
 AliAnaPi0.cxx:684
 AliAnaPi0.cxx:685
 AliAnaPi0.cxx:686
 AliAnaPi0.cxx:687
 AliAnaPi0.cxx:688
 AliAnaPi0.cxx:689
 AliAnaPi0.cxx:690
 AliAnaPi0.cxx:691
 AliAnaPi0.cxx:692
 AliAnaPi0.cxx:693
 AliAnaPi0.cxx:694
 AliAnaPi0.cxx:695
 AliAnaPi0.cxx:696
 AliAnaPi0.cxx:697
 AliAnaPi0.cxx:698
 AliAnaPi0.cxx:699
 AliAnaPi0.cxx:700
 AliAnaPi0.cxx:701
 AliAnaPi0.cxx:702
 AliAnaPi0.cxx:703
 AliAnaPi0.cxx:704
 AliAnaPi0.cxx:705
 AliAnaPi0.cxx:706
 AliAnaPi0.cxx:707
 AliAnaPi0.cxx:708
 AliAnaPi0.cxx:709
 AliAnaPi0.cxx:710
 AliAnaPi0.cxx:711
 AliAnaPi0.cxx:712
 AliAnaPi0.cxx:713
 AliAnaPi0.cxx:714
 AliAnaPi0.cxx:715
 AliAnaPi0.cxx:716
 AliAnaPi0.cxx:717
 AliAnaPi0.cxx:718
 AliAnaPi0.cxx:719
 AliAnaPi0.cxx:720
 AliAnaPi0.cxx:721
 AliAnaPi0.cxx:722
 AliAnaPi0.cxx:723
 AliAnaPi0.cxx:724
 AliAnaPi0.cxx:725
 AliAnaPi0.cxx:726
 AliAnaPi0.cxx:727
 AliAnaPi0.cxx:728
 AliAnaPi0.cxx:729
 AliAnaPi0.cxx:730
 AliAnaPi0.cxx:731
 AliAnaPi0.cxx:732
 AliAnaPi0.cxx:733
 AliAnaPi0.cxx:734
 AliAnaPi0.cxx:735
 AliAnaPi0.cxx:736
 AliAnaPi0.cxx:737
 AliAnaPi0.cxx:738
 AliAnaPi0.cxx:739
 AliAnaPi0.cxx:740
 AliAnaPi0.cxx:741
 AliAnaPi0.cxx:742
 AliAnaPi0.cxx:743
 AliAnaPi0.cxx:744
 AliAnaPi0.cxx:745
 AliAnaPi0.cxx:746
 AliAnaPi0.cxx:747
 AliAnaPi0.cxx:748
 AliAnaPi0.cxx:749
 AliAnaPi0.cxx:750
 AliAnaPi0.cxx:751
 AliAnaPi0.cxx:752
 AliAnaPi0.cxx:753
 AliAnaPi0.cxx:754
 AliAnaPi0.cxx:755
 AliAnaPi0.cxx:756
 AliAnaPi0.cxx:757
 AliAnaPi0.cxx:758
 AliAnaPi0.cxx:759
 AliAnaPi0.cxx:760
 AliAnaPi0.cxx:761
 AliAnaPi0.cxx:762
 AliAnaPi0.cxx:763
 AliAnaPi0.cxx:764
 AliAnaPi0.cxx:765
 AliAnaPi0.cxx:766
 AliAnaPi0.cxx:767
 AliAnaPi0.cxx:768
 AliAnaPi0.cxx:769
 AliAnaPi0.cxx:770
 AliAnaPi0.cxx:771
 AliAnaPi0.cxx:772
 AliAnaPi0.cxx:773
 AliAnaPi0.cxx:774
 AliAnaPi0.cxx:775
 AliAnaPi0.cxx:776
 AliAnaPi0.cxx:777
 AliAnaPi0.cxx:778
 AliAnaPi0.cxx:779
 AliAnaPi0.cxx:780
 AliAnaPi0.cxx:781
 AliAnaPi0.cxx:782
 AliAnaPi0.cxx:783
 AliAnaPi0.cxx:784
 AliAnaPi0.cxx:785
 AliAnaPi0.cxx:786
 AliAnaPi0.cxx:787
 AliAnaPi0.cxx:788
 AliAnaPi0.cxx:789
 AliAnaPi0.cxx:790
 AliAnaPi0.cxx:791
 AliAnaPi0.cxx:792
 AliAnaPi0.cxx:793
 AliAnaPi0.cxx:794
 AliAnaPi0.cxx:795
 AliAnaPi0.cxx:796
 AliAnaPi0.cxx:797
 AliAnaPi0.cxx:798
 AliAnaPi0.cxx:799
 AliAnaPi0.cxx:800
 AliAnaPi0.cxx:801
 AliAnaPi0.cxx:802
 AliAnaPi0.cxx:803
 AliAnaPi0.cxx:804
 AliAnaPi0.cxx:805
 AliAnaPi0.cxx:806
 AliAnaPi0.cxx:807
 AliAnaPi0.cxx:808
 AliAnaPi0.cxx:809
 AliAnaPi0.cxx:810
 AliAnaPi0.cxx:811
 AliAnaPi0.cxx:812
 AliAnaPi0.cxx:813
 AliAnaPi0.cxx:814
 AliAnaPi0.cxx:815
 AliAnaPi0.cxx:816
 AliAnaPi0.cxx:817
 AliAnaPi0.cxx:818
 AliAnaPi0.cxx:819
 AliAnaPi0.cxx:820
 AliAnaPi0.cxx:821
 AliAnaPi0.cxx:822
 AliAnaPi0.cxx:823
 AliAnaPi0.cxx:824
 AliAnaPi0.cxx:825
 AliAnaPi0.cxx:826
 AliAnaPi0.cxx:827
 AliAnaPi0.cxx:828
 AliAnaPi0.cxx:829
 AliAnaPi0.cxx:830
 AliAnaPi0.cxx:831
 AliAnaPi0.cxx:832
 AliAnaPi0.cxx:833
 AliAnaPi0.cxx:834
 AliAnaPi0.cxx:835
 AliAnaPi0.cxx:836
 AliAnaPi0.cxx:837
 AliAnaPi0.cxx:838
 AliAnaPi0.cxx:839
 AliAnaPi0.cxx:840
 AliAnaPi0.cxx:841
 AliAnaPi0.cxx:842
 AliAnaPi0.cxx:843
 AliAnaPi0.cxx:844
 AliAnaPi0.cxx:845
 AliAnaPi0.cxx:846
 AliAnaPi0.cxx:847
 AliAnaPi0.cxx:848
 AliAnaPi0.cxx:849
 AliAnaPi0.cxx:850
 AliAnaPi0.cxx:851
 AliAnaPi0.cxx:852
 AliAnaPi0.cxx:853
 AliAnaPi0.cxx:854
 AliAnaPi0.cxx:855
 AliAnaPi0.cxx:856
 AliAnaPi0.cxx:857
 AliAnaPi0.cxx:858
 AliAnaPi0.cxx:859
 AliAnaPi0.cxx:860
 AliAnaPi0.cxx:861
 AliAnaPi0.cxx:862
 AliAnaPi0.cxx:863
 AliAnaPi0.cxx:864
 AliAnaPi0.cxx:865
 AliAnaPi0.cxx:866
 AliAnaPi0.cxx:867
 AliAnaPi0.cxx:868
 AliAnaPi0.cxx:869
 AliAnaPi0.cxx:870
 AliAnaPi0.cxx:871
 AliAnaPi0.cxx:872
 AliAnaPi0.cxx:873
 AliAnaPi0.cxx:874
 AliAnaPi0.cxx:875
 AliAnaPi0.cxx:876
 AliAnaPi0.cxx:877
 AliAnaPi0.cxx:878
 AliAnaPi0.cxx:879
 AliAnaPi0.cxx:880
 AliAnaPi0.cxx:881
 AliAnaPi0.cxx:882
 AliAnaPi0.cxx:883
 AliAnaPi0.cxx:884
 AliAnaPi0.cxx:885
 AliAnaPi0.cxx:886
 AliAnaPi0.cxx:887
 AliAnaPi0.cxx:888
 AliAnaPi0.cxx:889
 AliAnaPi0.cxx:890
 AliAnaPi0.cxx:891
 AliAnaPi0.cxx:892
 AliAnaPi0.cxx:893
 AliAnaPi0.cxx:894
 AliAnaPi0.cxx:895
 AliAnaPi0.cxx:896
 AliAnaPi0.cxx:897
 AliAnaPi0.cxx:898
 AliAnaPi0.cxx:899
 AliAnaPi0.cxx:900
 AliAnaPi0.cxx:901
 AliAnaPi0.cxx:902
 AliAnaPi0.cxx:903
 AliAnaPi0.cxx:904
 AliAnaPi0.cxx:905
 AliAnaPi0.cxx:906
 AliAnaPi0.cxx:907
 AliAnaPi0.cxx:908
 AliAnaPi0.cxx:909
 AliAnaPi0.cxx:910
 AliAnaPi0.cxx:911
 AliAnaPi0.cxx:912
 AliAnaPi0.cxx:913
 AliAnaPi0.cxx:914
 AliAnaPi0.cxx:915
 AliAnaPi0.cxx:916
 AliAnaPi0.cxx:917
 AliAnaPi0.cxx:918
 AliAnaPi0.cxx:919
 AliAnaPi0.cxx:920
 AliAnaPi0.cxx:921
 AliAnaPi0.cxx:922
 AliAnaPi0.cxx:923
 AliAnaPi0.cxx:924
 AliAnaPi0.cxx:925
 AliAnaPi0.cxx:926
 AliAnaPi0.cxx:927
 AliAnaPi0.cxx:928
 AliAnaPi0.cxx:929
 AliAnaPi0.cxx:930
 AliAnaPi0.cxx:931
 AliAnaPi0.cxx:932
 AliAnaPi0.cxx:933
 AliAnaPi0.cxx:934
 AliAnaPi0.cxx:935
 AliAnaPi0.cxx:936
 AliAnaPi0.cxx:937
 AliAnaPi0.cxx:938
 AliAnaPi0.cxx:939
 AliAnaPi0.cxx:940
 AliAnaPi0.cxx:941
 AliAnaPi0.cxx:942
 AliAnaPi0.cxx:943
 AliAnaPi0.cxx:944
 AliAnaPi0.cxx:945
 AliAnaPi0.cxx:946
 AliAnaPi0.cxx:947
 AliAnaPi0.cxx:948
 AliAnaPi0.cxx:949
 AliAnaPi0.cxx:950
 AliAnaPi0.cxx:951
 AliAnaPi0.cxx:952
 AliAnaPi0.cxx:953
 AliAnaPi0.cxx:954
 AliAnaPi0.cxx:955
 AliAnaPi0.cxx:956
 AliAnaPi0.cxx:957
 AliAnaPi0.cxx:958
 AliAnaPi0.cxx:959
 AliAnaPi0.cxx:960
 AliAnaPi0.cxx:961
 AliAnaPi0.cxx:962
 AliAnaPi0.cxx:963
 AliAnaPi0.cxx:964
 AliAnaPi0.cxx:965
 AliAnaPi0.cxx:966
 AliAnaPi0.cxx:967
 AliAnaPi0.cxx:968
 AliAnaPi0.cxx:969
 AliAnaPi0.cxx:970
 AliAnaPi0.cxx:971
 AliAnaPi0.cxx:972
 AliAnaPi0.cxx:973
 AliAnaPi0.cxx:974
 AliAnaPi0.cxx:975
 AliAnaPi0.cxx:976
 AliAnaPi0.cxx:977
 AliAnaPi0.cxx:978
 AliAnaPi0.cxx:979
 AliAnaPi0.cxx:980
 AliAnaPi0.cxx:981
 AliAnaPi0.cxx:982
 AliAnaPi0.cxx:983
 AliAnaPi0.cxx:984
 AliAnaPi0.cxx:985
 AliAnaPi0.cxx:986
 AliAnaPi0.cxx:987
 AliAnaPi0.cxx:988
 AliAnaPi0.cxx:989
 AliAnaPi0.cxx:990
 AliAnaPi0.cxx:991
 AliAnaPi0.cxx:992
 AliAnaPi0.cxx:993
 AliAnaPi0.cxx:994
 AliAnaPi0.cxx:995
 AliAnaPi0.cxx:996
 AliAnaPi0.cxx:997
 AliAnaPi0.cxx:998
 AliAnaPi0.cxx:999
 AliAnaPi0.cxx:1000
 AliAnaPi0.cxx:1001
 AliAnaPi0.cxx:1002
 AliAnaPi0.cxx:1003
 AliAnaPi0.cxx:1004
 AliAnaPi0.cxx:1005
 AliAnaPi0.cxx:1006
 AliAnaPi0.cxx:1007
 AliAnaPi0.cxx:1008
 AliAnaPi0.cxx:1009
 AliAnaPi0.cxx:1010
 AliAnaPi0.cxx:1011
 AliAnaPi0.cxx:1012
 AliAnaPi0.cxx:1013
 AliAnaPi0.cxx:1014
 AliAnaPi0.cxx:1015
 AliAnaPi0.cxx:1016
 AliAnaPi0.cxx:1017
 AliAnaPi0.cxx:1018
 AliAnaPi0.cxx:1019
 AliAnaPi0.cxx:1020
 AliAnaPi0.cxx:1021
 AliAnaPi0.cxx:1022
 AliAnaPi0.cxx:1023
 AliAnaPi0.cxx:1024
 AliAnaPi0.cxx:1025
 AliAnaPi0.cxx:1026
 AliAnaPi0.cxx:1027
 AliAnaPi0.cxx:1028
 AliAnaPi0.cxx:1029
 AliAnaPi0.cxx:1030
 AliAnaPi0.cxx:1031
 AliAnaPi0.cxx:1032
 AliAnaPi0.cxx:1033
 AliAnaPi0.cxx:1034
 AliAnaPi0.cxx:1035
 AliAnaPi0.cxx:1036
 AliAnaPi0.cxx:1037
 AliAnaPi0.cxx:1038
 AliAnaPi0.cxx:1039
 AliAnaPi0.cxx:1040
 AliAnaPi0.cxx:1041
 AliAnaPi0.cxx:1042
 AliAnaPi0.cxx:1043
 AliAnaPi0.cxx:1044
 AliAnaPi0.cxx:1045
 AliAnaPi0.cxx:1046
 AliAnaPi0.cxx:1047
 AliAnaPi0.cxx:1048
 AliAnaPi0.cxx:1049
 AliAnaPi0.cxx:1050
 AliAnaPi0.cxx:1051
 AliAnaPi0.cxx:1052
 AliAnaPi0.cxx:1053
 AliAnaPi0.cxx:1054
 AliAnaPi0.cxx:1055
 AliAnaPi0.cxx:1056
 AliAnaPi0.cxx:1057
 AliAnaPi0.cxx:1058
 AliAnaPi0.cxx:1059
 AliAnaPi0.cxx:1060
 AliAnaPi0.cxx:1061
 AliAnaPi0.cxx:1062
 AliAnaPi0.cxx:1063
 AliAnaPi0.cxx:1064
 AliAnaPi0.cxx:1065
 AliAnaPi0.cxx:1066
 AliAnaPi0.cxx:1067
 AliAnaPi0.cxx:1068
 AliAnaPi0.cxx:1069
 AliAnaPi0.cxx:1070
 AliAnaPi0.cxx:1071
 AliAnaPi0.cxx:1072
 AliAnaPi0.cxx:1073
 AliAnaPi0.cxx:1074
 AliAnaPi0.cxx:1075
 AliAnaPi0.cxx:1076
 AliAnaPi0.cxx:1077
 AliAnaPi0.cxx:1078
 AliAnaPi0.cxx:1079
 AliAnaPi0.cxx:1080
 AliAnaPi0.cxx:1081
 AliAnaPi0.cxx:1082
 AliAnaPi0.cxx:1083
 AliAnaPi0.cxx:1084
 AliAnaPi0.cxx:1085
 AliAnaPi0.cxx:1086
 AliAnaPi0.cxx:1087
 AliAnaPi0.cxx:1088
 AliAnaPi0.cxx:1089
 AliAnaPi0.cxx:1090
 AliAnaPi0.cxx:1091
 AliAnaPi0.cxx:1092
 AliAnaPi0.cxx:1093
 AliAnaPi0.cxx:1094
 AliAnaPi0.cxx:1095
 AliAnaPi0.cxx:1096
 AliAnaPi0.cxx:1097
 AliAnaPi0.cxx:1098
 AliAnaPi0.cxx:1099
 AliAnaPi0.cxx:1100
 AliAnaPi0.cxx:1101
 AliAnaPi0.cxx:1102
 AliAnaPi0.cxx:1103
 AliAnaPi0.cxx:1104
 AliAnaPi0.cxx:1105
 AliAnaPi0.cxx:1106
 AliAnaPi0.cxx:1107
 AliAnaPi0.cxx:1108
 AliAnaPi0.cxx:1109
 AliAnaPi0.cxx:1110
 AliAnaPi0.cxx:1111
 AliAnaPi0.cxx:1112
 AliAnaPi0.cxx:1113
 AliAnaPi0.cxx:1114
 AliAnaPi0.cxx:1115
 AliAnaPi0.cxx:1116
 AliAnaPi0.cxx:1117
 AliAnaPi0.cxx:1118
 AliAnaPi0.cxx:1119
 AliAnaPi0.cxx:1120
 AliAnaPi0.cxx:1121
 AliAnaPi0.cxx:1122
 AliAnaPi0.cxx:1123
 AliAnaPi0.cxx:1124
 AliAnaPi0.cxx:1125
 AliAnaPi0.cxx:1126
 AliAnaPi0.cxx:1127
 AliAnaPi0.cxx:1128
 AliAnaPi0.cxx:1129
 AliAnaPi0.cxx:1130
 AliAnaPi0.cxx:1131
 AliAnaPi0.cxx:1132
 AliAnaPi0.cxx:1133
 AliAnaPi0.cxx:1134
 AliAnaPi0.cxx:1135
 AliAnaPi0.cxx:1136
 AliAnaPi0.cxx:1137
 AliAnaPi0.cxx:1138
 AliAnaPi0.cxx:1139
 AliAnaPi0.cxx:1140
 AliAnaPi0.cxx:1141
 AliAnaPi0.cxx:1142
 AliAnaPi0.cxx:1143
 AliAnaPi0.cxx:1144
 AliAnaPi0.cxx:1145
 AliAnaPi0.cxx:1146
 AliAnaPi0.cxx:1147
 AliAnaPi0.cxx:1148
 AliAnaPi0.cxx:1149
 AliAnaPi0.cxx:1150
 AliAnaPi0.cxx:1151
 AliAnaPi0.cxx:1152
 AliAnaPi0.cxx:1153
 AliAnaPi0.cxx:1154
 AliAnaPi0.cxx:1155
 AliAnaPi0.cxx:1156
 AliAnaPi0.cxx:1157
 AliAnaPi0.cxx:1158
 AliAnaPi0.cxx:1159
 AliAnaPi0.cxx:1160
 AliAnaPi0.cxx:1161
 AliAnaPi0.cxx:1162
 AliAnaPi0.cxx:1163
 AliAnaPi0.cxx:1164
 AliAnaPi0.cxx:1165
 AliAnaPi0.cxx:1166
 AliAnaPi0.cxx:1167
 AliAnaPi0.cxx:1168
 AliAnaPi0.cxx:1169
 AliAnaPi0.cxx:1170
 AliAnaPi0.cxx:1171
 AliAnaPi0.cxx:1172
 AliAnaPi0.cxx:1173
 AliAnaPi0.cxx:1174
 AliAnaPi0.cxx:1175
 AliAnaPi0.cxx:1176
 AliAnaPi0.cxx:1177
 AliAnaPi0.cxx:1178
 AliAnaPi0.cxx:1179
 AliAnaPi0.cxx:1180
 AliAnaPi0.cxx:1181
 AliAnaPi0.cxx:1182
 AliAnaPi0.cxx:1183
 AliAnaPi0.cxx:1184
 AliAnaPi0.cxx:1185
 AliAnaPi0.cxx:1186
 AliAnaPi0.cxx:1187
 AliAnaPi0.cxx:1188
 AliAnaPi0.cxx:1189
 AliAnaPi0.cxx:1190
 AliAnaPi0.cxx:1191
 AliAnaPi0.cxx:1192
 AliAnaPi0.cxx:1193
 AliAnaPi0.cxx:1194
 AliAnaPi0.cxx:1195
 AliAnaPi0.cxx:1196
 AliAnaPi0.cxx:1197
 AliAnaPi0.cxx:1198
 AliAnaPi0.cxx:1199
 AliAnaPi0.cxx:1200
 AliAnaPi0.cxx:1201
 AliAnaPi0.cxx:1202
 AliAnaPi0.cxx:1203
 AliAnaPi0.cxx:1204
 AliAnaPi0.cxx:1205
 AliAnaPi0.cxx:1206
 AliAnaPi0.cxx:1207
 AliAnaPi0.cxx:1208
 AliAnaPi0.cxx:1209
 AliAnaPi0.cxx:1210
 AliAnaPi0.cxx:1211
 AliAnaPi0.cxx:1212
 AliAnaPi0.cxx:1213
 AliAnaPi0.cxx:1214
 AliAnaPi0.cxx:1215
 AliAnaPi0.cxx:1216
 AliAnaPi0.cxx:1217
 AliAnaPi0.cxx:1218
 AliAnaPi0.cxx:1219
 AliAnaPi0.cxx:1220
 AliAnaPi0.cxx:1221
 AliAnaPi0.cxx:1222
 AliAnaPi0.cxx:1223
 AliAnaPi0.cxx:1224
 AliAnaPi0.cxx:1225
 AliAnaPi0.cxx:1226
 AliAnaPi0.cxx:1227
 AliAnaPi0.cxx:1228
 AliAnaPi0.cxx:1229
 AliAnaPi0.cxx:1230
 AliAnaPi0.cxx:1231
 AliAnaPi0.cxx:1232
 AliAnaPi0.cxx:1233
 AliAnaPi0.cxx:1234
 AliAnaPi0.cxx:1235
 AliAnaPi0.cxx:1236
 AliAnaPi0.cxx:1237
 AliAnaPi0.cxx:1238
 AliAnaPi0.cxx:1239
 AliAnaPi0.cxx:1240
 AliAnaPi0.cxx:1241
 AliAnaPi0.cxx:1242
 AliAnaPi0.cxx:1243
 AliAnaPi0.cxx:1244
 AliAnaPi0.cxx:1245
 AliAnaPi0.cxx:1246
 AliAnaPi0.cxx:1247
 AliAnaPi0.cxx:1248
 AliAnaPi0.cxx:1249
 AliAnaPi0.cxx:1250
 AliAnaPi0.cxx:1251
 AliAnaPi0.cxx:1252
 AliAnaPi0.cxx:1253
 AliAnaPi0.cxx:1254
 AliAnaPi0.cxx:1255
 AliAnaPi0.cxx:1256
 AliAnaPi0.cxx:1257
 AliAnaPi0.cxx:1258
 AliAnaPi0.cxx:1259
 AliAnaPi0.cxx:1260
 AliAnaPi0.cxx:1261
 AliAnaPi0.cxx:1262
 AliAnaPi0.cxx:1263
 AliAnaPi0.cxx:1264
 AliAnaPi0.cxx:1265
 AliAnaPi0.cxx:1266
 AliAnaPi0.cxx:1267
 AliAnaPi0.cxx:1268
 AliAnaPi0.cxx:1269
 AliAnaPi0.cxx:1270
 AliAnaPi0.cxx:1271
 AliAnaPi0.cxx:1272
 AliAnaPi0.cxx:1273
 AliAnaPi0.cxx:1274
 AliAnaPi0.cxx:1275
 AliAnaPi0.cxx:1276
 AliAnaPi0.cxx:1277
 AliAnaPi0.cxx:1278
 AliAnaPi0.cxx:1279
 AliAnaPi0.cxx:1280
 AliAnaPi0.cxx:1281
 AliAnaPi0.cxx:1282
 AliAnaPi0.cxx:1283
 AliAnaPi0.cxx:1284
 AliAnaPi0.cxx:1285
 AliAnaPi0.cxx:1286
 AliAnaPi0.cxx:1287
 AliAnaPi0.cxx:1288
 AliAnaPi0.cxx:1289
 AliAnaPi0.cxx:1290
 AliAnaPi0.cxx:1291
 AliAnaPi0.cxx:1292
 AliAnaPi0.cxx:1293
 AliAnaPi0.cxx:1294
 AliAnaPi0.cxx:1295
 AliAnaPi0.cxx:1296
 AliAnaPi0.cxx:1297
 AliAnaPi0.cxx:1298
 AliAnaPi0.cxx:1299
 AliAnaPi0.cxx:1300
 AliAnaPi0.cxx:1301
 AliAnaPi0.cxx:1302
 AliAnaPi0.cxx:1303
 AliAnaPi0.cxx:1304
 AliAnaPi0.cxx:1305
 AliAnaPi0.cxx:1306
 AliAnaPi0.cxx:1307
 AliAnaPi0.cxx:1308
 AliAnaPi0.cxx:1309
 AliAnaPi0.cxx:1310
 AliAnaPi0.cxx:1311
 AliAnaPi0.cxx:1312
 AliAnaPi0.cxx:1313
 AliAnaPi0.cxx:1314
 AliAnaPi0.cxx:1315
 AliAnaPi0.cxx:1316
 AliAnaPi0.cxx:1317
 AliAnaPi0.cxx:1318
 AliAnaPi0.cxx:1319
 AliAnaPi0.cxx:1320
 AliAnaPi0.cxx:1321
 AliAnaPi0.cxx:1322
 AliAnaPi0.cxx:1323
 AliAnaPi0.cxx:1324
 AliAnaPi0.cxx:1325
 AliAnaPi0.cxx:1326
 AliAnaPi0.cxx:1327
 AliAnaPi0.cxx:1328
 AliAnaPi0.cxx:1329
 AliAnaPi0.cxx:1330
 AliAnaPi0.cxx:1331
 AliAnaPi0.cxx:1332
 AliAnaPi0.cxx:1333
 AliAnaPi0.cxx:1334
 AliAnaPi0.cxx:1335
 AliAnaPi0.cxx:1336
 AliAnaPi0.cxx:1337
 AliAnaPi0.cxx:1338
 AliAnaPi0.cxx:1339
 AliAnaPi0.cxx:1340
 AliAnaPi0.cxx:1341
 AliAnaPi0.cxx:1342
 AliAnaPi0.cxx:1343
 AliAnaPi0.cxx:1344
 AliAnaPi0.cxx:1345
 AliAnaPi0.cxx:1346
 AliAnaPi0.cxx:1347
 AliAnaPi0.cxx:1348
 AliAnaPi0.cxx:1349
 AliAnaPi0.cxx:1350
 AliAnaPi0.cxx:1351
 AliAnaPi0.cxx:1352
 AliAnaPi0.cxx:1353
 AliAnaPi0.cxx:1354
 AliAnaPi0.cxx:1355
 AliAnaPi0.cxx:1356
 AliAnaPi0.cxx:1357
 AliAnaPi0.cxx:1358
 AliAnaPi0.cxx:1359
 AliAnaPi0.cxx:1360
 AliAnaPi0.cxx:1361
 AliAnaPi0.cxx:1362
 AliAnaPi0.cxx:1363
 AliAnaPi0.cxx:1364
 AliAnaPi0.cxx:1365
 AliAnaPi0.cxx:1366
 AliAnaPi0.cxx:1367
 AliAnaPi0.cxx:1368
 AliAnaPi0.cxx:1369
 AliAnaPi0.cxx:1370
 AliAnaPi0.cxx:1371
 AliAnaPi0.cxx:1372
 AliAnaPi0.cxx:1373
 AliAnaPi0.cxx:1374
 AliAnaPi0.cxx:1375
 AliAnaPi0.cxx:1376
 AliAnaPi0.cxx:1377
 AliAnaPi0.cxx:1378
 AliAnaPi0.cxx:1379
 AliAnaPi0.cxx:1380
 AliAnaPi0.cxx:1381
 AliAnaPi0.cxx:1382
 AliAnaPi0.cxx:1383
 AliAnaPi0.cxx:1384
 AliAnaPi0.cxx:1385
 AliAnaPi0.cxx:1386
 AliAnaPi0.cxx:1387
 AliAnaPi0.cxx:1388
 AliAnaPi0.cxx:1389
 AliAnaPi0.cxx:1390
 AliAnaPi0.cxx:1391
 AliAnaPi0.cxx:1392
 AliAnaPi0.cxx:1393
 AliAnaPi0.cxx:1394
 AliAnaPi0.cxx:1395
 AliAnaPi0.cxx:1396
 AliAnaPi0.cxx:1397
 AliAnaPi0.cxx:1398
 AliAnaPi0.cxx:1399
 AliAnaPi0.cxx:1400
 AliAnaPi0.cxx:1401
 AliAnaPi0.cxx:1402
 AliAnaPi0.cxx:1403
 AliAnaPi0.cxx:1404
 AliAnaPi0.cxx:1405
 AliAnaPi0.cxx:1406
 AliAnaPi0.cxx:1407
 AliAnaPi0.cxx:1408
 AliAnaPi0.cxx:1409
 AliAnaPi0.cxx:1410
 AliAnaPi0.cxx:1411
 AliAnaPi0.cxx:1412
 AliAnaPi0.cxx:1413
 AliAnaPi0.cxx:1414
 AliAnaPi0.cxx:1415
 AliAnaPi0.cxx:1416
 AliAnaPi0.cxx:1417
 AliAnaPi0.cxx:1418
 AliAnaPi0.cxx:1419
 AliAnaPi0.cxx:1420
 AliAnaPi0.cxx:1421
 AliAnaPi0.cxx:1422
 AliAnaPi0.cxx:1423
 AliAnaPi0.cxx:1424
 AliAnaPi0.cxx:1425
 AliAnaPi0.cxx:1426
 AliAnaPi0.cxx:1427
 AliAnaPi0.cxx:1428
 AliAnaPi0.cxx:1429
 AliAnaPi0.cxx:1430
 AliAnaPi0.cxx:1431
 AliAnaPi0.cxx:1432
 AliAnaPi0.cxx:1433
 AliAnaPi0.cxx:1434
 AliAnaPi0.cxx:1435
 AliAnaPi0.cxx:1436
 AliAnaPi0.cxx:1437
 AliAnaPi0.cxx:1438
 AliAnaPi0.cxx:1439
 AliAnaPi0.cxx:1440
 AliAnaPi0.cxx:1441
 AliAnaPi0.cxx:1442
 AliAnaPi0.cxx:1443
 AliAnaPi0.cxx:1444
 AliAnaPi0.cxx:1445
 AliAnaPi0.cxx:1446
 AliAnaPi0.cxx:1447
 AliAnaPi0.cxx:1448
 AliAnaPi0.cxx:1449
 AliAnaPi0.cxx:1450
 AliAnaPi0.cxx:1451
 AliAnaPi0.cxx:1452
 AliAnaPi0.cxx:1453
 AliAnaPi0.cxx:1454
 AliAnaPi0.cxx:1455
 AliAnaPi0.cxx:1456
 AliAnaPi0.cxx:1457
 AliAnaPi0.cxx:1458
 AliAnaPi0.cxx:1459
 AliAnaPi0.cxx:1460
 AliAnaPi0.cxx:1461
 AliAnaPi0.cxx:1462
 AliAnaPi0.cxx:1463
 AliAnaPi0.cxx:1464
 AliAnaPi0.cxx:1465
 AliAnaPi0.cxx:1466
 AliAnaPi0.cxx:1467
 AliAnaPi0.cxx:1468
 AliAnaPi0.cxx:1469
 AliAnaPi0.cxx:1470
 AliAnaPi0.cxx:1471
 AliAnaPi0.cxx:1472
 AliAnaPi0.cxx:1473
 AliAnaPi0.cxx:1474
 AliAnaPi0.cxx:1475
 AliAnaPi0.cxx:1476
 AliAnaPi0.cxx:1477
 AliAnaPi0.cxx:1478
 AliAnaPi0.cxx:1479
 AliAnaPi0.cxx:1480
 AliAnaPi0.cxx:1481
 AliAnaPi0.cxx:1482
 AliAnaPi0.cxx:1483
 AliAnaPi0.cxx:1484
 AliAnaPi0.cxx:1485
 AliAnaPi0.cxx:1486
 AliAnaPi0.cxx:1487
 AliAnaPi0.cxx:1488
 AliAnaPi0.cxx:1489
 AliAnaPi0.cxx:1490
 AliAnaPi0.cxx:1491
 AliAnaPi0.cxx:1492
 AliAnaPi0.cxx:1493
 AliAnaPi0.cxx:1494
 AliAnaPi0.cxx:1495
 AliAnaPi0.cxx:1496
 AliAnaPi0.cxx:1497
 AliAnaPi0.cxx:1498
 AliAnaPi0.cxx:1499
 AliAnaPi0.cxx:1500
 AliAnaPi0.cxx:1501
 AliAnaPi0.cxx:1502
 AliAnaPi0.cxx:1503
 AliAnaPi0.cxx:1504
 AliAnaPi0.cxx:1505
 AliAnaPi0.cxx:1506
 AliAnaPi0.cxx:1507
 AliAnaPi0.cxx:1508
 AliAnaPi0.cxx:1509
 AliAnaPi0.cxx:1510
 AliAnaPi0.cxx:1511
 AliAnaPi0.cxx:1512
 AliAnaPi0.cxx:1513
 AliAnaPi0.cxx:1514
 AliAnaPi0.cxx:1515
 AliAnaPi0.cxx:1516
 AliAnaPi0.cxx:1517
 AliAnaPi0.cxx:1518
 AliAnaPi0.cxx:1519
 AliAnaPi0.cxx:1520
 AliAnaPi0.cxx:1521
 AliAnaPi0.cxx:1522
 AliAnaPi0.cxx:1523
 AliAnaPi0.cxx:1524
 AliAnaPi0.cxx:1525
 AliAnaPi0.cxx:1526
 AliAnaPi0.cxx:1527
 AliAnaPi0.cxx:1528
 AliAnaPi0.cxx:1529
 AliAnaPi0.cxx:1530
 AliAnaPi0.cxx:1531
 AliAnaPi0.cxx:1532
 AliAnaPi0.cxx:1533
 AliAnaPi0.cxx:1534
 AliAnaPi0.cxx:1535
 AliAnaPi0.cxx:1536
 AliAnaPi0.cxx:1537
 AliAnaPi0.cxx:1538
 AliAnaPi0.cxx:1539
 AliAnaPi0.cxx:1540
 AliAnaPi0.cxx:1541
 AliAnaPi0.cxx:1542
 AliAnaPi0.cxx:1543
 AliAnaPi0.cxx:1544
 AliAnaPi0.cxx:1545
 AliAnaPi0.cxx:1546
 AliAnaPi0.cxx:1547
 AliAnaPi0.cxx:1548
 AliAnaPi0.cxx:1549
 AliAnaPi0.cxx:1550
 AliAnaPi0.cxx:1551
 AliAnaPi0.cxx:1552
 AliAnaPi0.cxx:1553
 AliAnaPi0.cxx:1554
 AliAnaPi0.cxx:1555
 AliAnaPi0.cxx:1556
 AliAnaPi0.cxx:1557
 AliAnaPi0.cxx:1558
 AliAnaPi0.cxx:1559
 AliAnaPi0.cxx:1560
 AliAnaPi0.cxx:1561
 AliAnaPi0.cxx:1562
 AliAnaPi0.cxx:1563
 AliAnaPi0.cxx:1564
 AliAnaPi0.cxx:1565
 AliAnaPi0.cxx:1566
 AliAnaPi0.cxx:1567
 AliAnaPi0.cxx:1568
 AliAnaPi0.cxx:1569
 AliAnaPi0.cxx:1570
 AliAnaPi0.cxx:1571
 AliAnaPi0.cxx:1572
 AliAnaPi0.cxx:1573
 AliAnaPi0.cxx:1574
 AliAnaPi0.cxx:1575
 AliAnaPi0.cxx:1576
 AliAnaPi0.cxx:1577
 AliAnaPi0.cxx:1578
 AliAnaPi0.cxx:1579
 AliAnaPi0.cxx:1580
 AliAnaPi0.cxx:1581
 AliAnaPi0.cxx:1582
 AliAnaPi0.cxx:1583
 AliAnaPi0.cxx:1584
 AliAnaPi0.cxx:1585
 AliAnaPi0.cxx:1586
 AliAnaPi0.cxx:1587
 AliAnaPi0.cxx:1588
 AliAnaPi0.cxx:1589
 AliAnaPi0.cxx:1590
 AliAnaPi0.cxx:1591
 AliAnaPi0.cxx:1592
 AliAnaPi0.cxx:1593
 AliAnaPi0.cxx:1594
 AliAnaPi0.cxx:1595
 AliAnaPi0.cxx:1596
 AliAnaPi0.cxx:1597
 AliAnaPi0.cxx:1598
 AliAnaPi0.cxx:1599
 AliAnaPi0.cxx:1600
 AliAnaPi0.cxx:1601
 AliAnaPi0.cxx:1602
 AliAnaPi0.cxx:1603
 AliAnaPi0.cxx:1604
 AliAnaPi0.cxx:1605
 AliAnaPi0.cxx:1606
 AliAnaPi0.cxx:1607
 AliAnaPi0.cxx:1608
 AliAnaPi0.cxx:1609
 AliAnaPi0.cxx:1610
 AliAnaPi0.cxx:1611
 AliAnaPi0.cxx:1612
 AliAnaPi0.cxx:1613
 AliAnaPi0.cxx:1614
 AliAnaPi0.cxx:1615
 AliAnaPi0.cxx:1616
 AliAnaPi0.cxx:1617
 AliAnaPi0.cxx:1618
 AliAnaPi0.cxx:1619
 AliAnaPi0.cxx:1620
 AliAnaPi0.cxx:1621
 AliAnaPi0.cxx:1622
 AliAnaPi0.cxx:1623
 AliAnaPi0.cxx:1624
 AliAnaPi0.cxx:1625
 AliAnaPi0.cxx:1626
 AliAnaPi0.cxx:1627
 AliAnaPi0.cxx:1628
 AliAnaPi0.cxx:1629
 AliAnaPi0.cxx:1630
 AliAnaPi0.cxx:1631
 AliAnaPi0.cxx:1632
 AliAnaPi0.cxx:1633
 AliAnaPi0.cxx:1634
 AliAnaPi0.cxx:1635
 AliAnaPi0.cxx:1636
 AliAnaPi0.cxx:1637
 AliAnaPi0.cxx:1638
 AliAnaPi0.cxx:1639
 AliAnaPi0.cxx:1640
 AliAnaPi0.cxx:1641
 AliAnaPi0.cxx:1642
 AliAnaPi0.cxx:1643
 AliAnaPi0.cxx:1644
 AliAnaPi0.cxx:1645
 AliAnaPi0.cxx:1646
 AliAnaPi0.cxx:1647
 AliAnaPi0.cxx:1648
 AliAnaPi0.cxx:1649
 AliAnaPi0.cxx:1650
 AliAnaPi0.cxx:1651
 AliAnaPi0.cxx:1652
 AliAnaPi0.cxx:1653
 AliAnaPi0.cxx:1654
 AliAnaPi0.cxx:1655
 AliAnaPi0.cxx:1656
 AliAnaPi0.cxx:1657
 AliAnaPi0.cxx:1658
 AliAnaPi0.cxx:1659
 AliAnaPi0.cxx:1660
 AliAnaPi0.cxx:1661
 AliAnaPi0.cxx:1662
 AliAnaPi0.cxx:1663
 AliAnaPi0.cxx:1664
 AliAnaPi0.cxx:1665
 AliAnaPi0.cxx:1666
 AliAnaPi0.cxx:1667
 AliAnaPi0.cxx:1668
 AliAnaPi0.cxx:1669
 AliAnaPi0.cxx:1670
 AliAnaPi0.cxx:1671
 AliAnaPi0.cxx:1672
 AliAnaPi0.cxx:1673
 AliAnaPi0.cxx:1674
 AliAnaPi0.cxx:1675
 AliAnaPi0.cxx:1676
 AliAnaPi0.cxx:1677
 AliAnaPi0.cxx:1678
 AliAnaPi0.cxx:1679
 AliAnaPi0.cxx:1680
 AliAnaPi0.cxx:1681
 AliAnaPi0.cxx:1682
 AliAnaPi0.cxx:1683
 AliAnaPi0.cxx:1684
 AliAnaPi0.cxx:1685
 AliAnaPi0.cxx:1686
 AliAnaPi0.cxx:1687
 AliAnaPi0.cxx:1688
 AliAnaPi0.cxx:1689
 AliAnaPi0.cxx:1690
 AliAnaPi0.cxx:1691
 AliAnaPi0.cxx:1692
 AliAnaPi0.cxx:1693
 AliAnaPi0.cxx:1694
 AliAnaPi0.cxx:1695
 AliAnaPi0.cxx:1696
 AliAnaPi0.cxx:1697
 AliAnaPi0.cxx:1698
 AliAnaPi0.cxx:1699
 AliAnaPi0.cxx:1700
 AliAnaPi0.cxx:1701
 AliAnaPi0.cxx:1702
 AliAnaPi0.cxx:1703
 AliAnaPi0.cxx:1704
 AliAnaPi0.cxx:1705
 AliAnaPi0.cxx:1706
 AliAnaPi0.cxx:1707
 AliAnaPi0.cxx:1708
 AliAnaPi0.cxx:1709
 AliAnaPi0.cxx:1710
 AliAnaPi0.cxx:1711
 AliAnaPi0.cxx:1712
 AliAnaPi0.cxx:1713
 AliAnaPi0.cxx:1714
 AliAnaPi0.cxx:1715
 AliAnaPi0.cxx:1716
 AliAnaPi0.cxx:1717
 AliAnaPi0.cxx:1718
 AliAnaPi0.cxx:1719
 AliAnaPi0.cxx:1720
 AliAnaPi0.cxx:1721
 AliAnaPi0.cxx:1722
 AliAnaPi0.cxx:1723
 AliAnaPi0.cxx:1724
 AliAnaPi0.cxx:1725
 AliAnaPi0.cxx:1726
 AliAnaPi0.cxx:1727
 AliAnaPi0.cxx:1728
 AliAnaPi0.cxx:1729
 AliAnaPi0.cxx:1730
 AliAnaPi0.cxx:1731
 AliAnaPi0.cxx:1732
 AliAnaPi0.cxx:1733
 AliAnaPi0.cxx:1734
 AliAnaPi0.cxx:1735
 AliAnaPi0.cxx:1736
 AliAnaPi0.cxx:1737
 AliAnaPi0.cxx:1738
 AliAnaPi0.cxx:1739
 AliAnaPi0.cxx:1740
 AliAnaPi0.cxx:1741
 AliAnaPi0.cxx:1742
 AliAnaPi0.cxx:1743
 AliAnaPi0.cxx:1744
 AliAnaPi0.cxx:1745
 AliAnaPi0.cxx:1746
 AliAnaPi0.cxx:1747
 AliAnaPi0.cxx:1748
 AliAnaPi0.cxx:1749
 AliAnaPi0.cxx:1750
 AliAnaPi0.cxx:1751
 AliAnaPi0.cxx:1752
 AliAnaPi0.cxx:1753
 AliAnaPi0.cxx:1754
 AliAnaPi0.cxx:1755
 AliAnaPi0.cxx:1756
 AliAnaPi0.cxx:1757
 AliAnaPi0.cxx:1758
 AliAnaPi0.cxx:1759
 AliAnaPi0.cxx:1760
 AliAnaPi0.cxx:1761
 AliAnaPi0.cxx:1762
 AliAnaPi0.cxx:1763
 AliAnaPi0.cxx:1764
 AliAnaPi0.cxx:1765
 AliAnaPi0.cxx:1766
 AliAnaPi0.cxx:1767
 AliAnaPi0.cxx:1768
 AliAnaPi0.cxx:1769
 AliAnaPi0.cxx:1770
 AliAnaPi0.cxx:1771
 AliAnaPi0.cxx:1772
 AliAnaPi0.cxx:1773
 AliAnaPi0.cxx:1774
 AliAnaPi0.cxx:1775
 AliAnaPi0.cxx:1776
 AliAnaPi0.cxx:1777
 AliAnaPi0.cxx:1778
 AliAnaPi0.cxx:1779
 AliAnaPi0.cxx:1780
 AliAnaPi0.cxx:1781
 AliAnaPi0.cxx:1782
 AliAnaPi0.cxx:1783
 AliAnaPi0.cxx:1784
 AliAnaPi0.cxx:1785
 AliAnaPi0.cxx:1786
 AliAnaPi0.cxx:1787
 AliAnaPi0.cxx:1788
 AliAnaPi0.cxx:1789
 AliAnaPi0.cxx:1790
 AliAnaPi0.cxx:1791
 AliAnaPi0.cxx:1792
 AliAnaPi0.cxx:1793
 AliAnaPi0.cxx:1794
 AliAnaPi0.cxx:1795
 AliAnaPi0.cxx:1796
 AliAnaPi0.cxx:1797
 AliAnaPi0.cxx:1798
 AliAnaPi0.cxx:1799
 AliAnaPi0.cxx:1800
 AliAnaPi0.cxx:1801
 AliAnaPi0.cxx:1802
 AliAnaPi0.cxx:1803
 AliAnaPi0.cxx:1804
 AliAnaPi0.cxx:1805
 AliAnaPi0.cxx:1806
 AliAnaPi0.cxx:1807
 AliAnaPi0.cxx:1808
 AliAnaPi0.cxx:1809
 AliAnaPi0.cxx:1810
 AliAnaPi0.cxx:1811
 AliAnaPi0.cxx:1812
 AliAnaPi0.cxx:1813
 AliAnaPi0.cxx:1814
 AliAnaPi0.cxx:1815
 AliAnaPi0.cxx:1816
 AliAnaPi0.cxx:1817
 AliAnaPi0.cxx:1818
 AliAnaPi0.cxx:1819
 AliAnaPi0.cxx:1820
 AliAnaPi0.cxx:1821
 AliAnaPi0.cxx:1822
 AliAnaPi0.cxx:1823
 AliAnaPi0.cxx:1824
 AliAnaPi0.cxx:1825
 AliAnaPi0.cxx:1826
 AliAnaPi0.cxx:1827
 AliAnaPi0.cxx:1828
 AliAnaPi0.cxx:1829
 AliAnaPi0.cxx:1830
 AliAnaPi0.cxx:1831
 AliAnaPi0.cxx:1832
 AliAnaPi0.cxx:1833
 AliAnaPi0.cxx:1834
 AliAnaPi0.cxx:1835
 AliAnaPi0.cxx:1836
 AliAnaPi0.cxx:1837
 AliAnaPi0.cxx:1838
 AliAnaPi0.cxx:1839
 AliAnaPi0.cxx:1840
 AliAnaPi0.cxx:1841
 AliAnaPi0.cxx:1842
 AliAnaPi0.cxx:1843
 AliAnaPi0.cxx:1844
 AliAnaPi0.cxx:1845
 AliAnaPi0.cxx:1846
 AliAnaPi0.cxx:1847
 AliAnaPi0.cxx:1848
 AliAnaPi0.cxx:1849
 AliAnaPi0.cxx:1850
 AliAnaPi0.cxx:1851
 AliAnaPi0.cxx:1852
 AliAnaPi0.cxx:1853
 AliAnaPi0.cxx:1854
 AliAnaPi0.cxx:1855
 AliAnaPi0.cxx:1856
 AliAnaPi0.cxx:1857
 AliAnaPi0.cxx:1858
 AliAnaPi0.cxx:1859
 AliAnaPi0.cxx:1860
 AliAnaPi0.cxx:1861
 AliAnaPi0.cxx:1862
 AliAnaPi0.cxx:1863
 AliAnaPi0.cxx:1864
 AliAnaPi0.cxx:1865
 AliAnaPi0.cxx:1866
 AliAnaPi0.cxx:1867
 AliAnaPi0.cxx:1868
 AliAnaPi0.cxx:1869
 AliAnaPi0.cxx:1870
 AliAnaPi0.cxx:1871
 AliAnaPi0.cxx:1872
 AliAnaPi0.cxx:1873
 AliAnaPi0.cxx:1874
 AliAnaPi0.cxx:1875
 AliAnaPi0.cxx:1876
 AliAnaPi0.cxx:1877
 AliAnaPi0.cxx:1878
 AliAnaPi0.cxx:1879
 AliAnaPi0.cxx:1880
 AliAnaPi0.cxx:1881
 AliAnaPi0.cxx:1882
 AliAnaPi0.cxx:1883
 AliAnaPi0.cxx:1884
 AliAnaPi0.cxx:1885
 AliAnaPi0.cxx:1886
 AliAnaPi0.cxx:1887
 AliAnaPi0.cxx:1888
 AliAnaPi0.cxx:1889
 AliAnaPi0.cxx:1890
 AliAnaPi0.cxx:1891
 AliAnaPi0.cxx:1892
 AliAnaPi0.cxx:1893
 AliAnaPi0.cxx:1894
 AliAnaPi0.cxx:1895
 AliAnaPi0.cxx:1896
 AliAnaPi0.cxx:1897
 AliAnaPi0.cxx:1898
 AliAnaPi0.cxx:1899
 AliAnaPi0.cxx:1900
 AliAnaPi0.cxx:1901
 AliAnaPi0.cxx:1902
 AliAnaPi0.cxx:1903
 AliAnaPi0.cxx:1904
 AliAnaPi0.cxx:1905
 AliAnaPi0.cxx:1906
 AliAnaPi0.cxx:1907
 AliAnaPi0.cxx:1908
 AliAnaPi0.cxx:1909
 AliAnaPi0.cxx:1910
 AliAnaPi0.cxx:1911
 AliAnaPi0.cxx:1912
 AliAnaPi0.cxx:1913
 AliAnaPi0.cxx:1914
 AliAnaPi0.cxx:1915
 AliAnaPi0.cxx:1916
 AliAnaPi0.cxx:1917
 AliAnaPi0.cxx:1918
 AliAnaPi0.cxx:1919
 AliAnaPi0.cxx:1920
 AliAnaPi0.cxx:1921
 AliAnaPi0.cxx:1922
 AliAnaPi0.cxx:1923
 AliAnaPi0.cxx:1924
 AliAnaPi0.cxx:1925
 AliAnaPi0.cxx:1926
 AliAnaPi0.cxx:1927
 AliAnaPi0.cxx:1928
 AliAnaPi0.cxx:1929
 AliAnaPi0.cxx:1930
 AliAnaPi0.cxx:1931
 AliAnaPi0.cxx:1932
 AliAnaPi0.cxx:1933
 AliAnaPi0.cxx:1934
 AliAnaPi0.cxx:1935
 AliAnaPi0.cxx:1936
 AliAnaPi0.cxx:1937
 AliAnaPi0.cxx:1938
 AliAnaPi0.cxx:1939
 AliAnaPi0.cxx:1940
 AliAnaPi0.cxx:1941
 AliAnaPi0.cxx:1942
 AliAnaPi0.cxx:1943
 AliAnaPi0.cxx:1944
 AliAnaPi0.cxx:1945
 AliAnaPi0.cxx:1946
 AliAnaPi0.cxx:1947
 AliAnaPi0.cxx:1948
 AliAnaPi0.cxx:1949
 AliAnaPi0.cxx:1950
 AliAnaPi0.cxx:1951
 AliAnaPi0.cxx:1952
 AliAnaPi0.cxx:1953
 AliAnaPi0.cxx:1954
 AliAnaPi0.cxx:1955
 AliAnaPi0.cxx:1956
 AliAnaPi0.cxx:1957
 AliAnaPi0.cxx:1958
 AliAnaPi0.cxx:1959
 AliAnaPi0.cxx:1960
 AliAnaPi0.cxx:1961
 AliAnaPi0.cxx:1962
 AliAnaPi0.cxx:1963
 AliAnaPi0.cxx:1964
 AliAnaPi0.cxx:1965
 AliAnaPi0.cxx:1966
 AliAnaPi0.cxx:1967
 AliAnaPi0.cxx:1968
 AliAnaPi0.cxx:1969
 AliAnaPi0.cxx:1970
 AliAnaPi0.cxx:1971
 AliAnaPi0.cxx:1972
 AliAnaPi0.cxx:1973
 AliAnaPi0.cxx:1974
 AliAnaPi0.cxx:1975
 AliAnaPi0.cxx:1976
 AliAnaPi0.cxx:1977
 AliAnaPi0.cxx:1978
 AliAnaPi0.cxx:1979
 AliAnaPi0.cxx:1980
 AliAnaPi0.cxx:1981
 AliAnaPi0.cxx:1982
 AliAnaPi0.cxx:1983
 AliAnaPi0.cxx:1984
 AliAnaPi0.cxx:1985
 AliAnaPi0.cxx:1986
 AliAnaPi0.cxx:1987
 AliAnaPi0.cxx:1988
 AliAnaPi0.cxx:1989
 AliAnaPi0.cxx:1990
 AliAnaPi0.cxx:1991
 AliAnaPi0.cxx:1992
 AliAnaPi0.cxx:1993
 AliAnaPi0.cxx:1994
 AliAnaPi0.cxx:1995
 AliAnaPi0.cxx:1996
 AliAnaPi0.cxx:1997
 AliAnaPi0.cxx:1998
 AliAnaPi0.cxx:1999
 AliAnaPi0.cxx:2000
 AliAnaPi0.cxx:2001
 AliAnaPi0.cxx:2002
 AliAnaPi0.cxx:2003
 AliAnaPi0.cxx:2004
 AliAnaPi0.cxx:2005
 AliAnaPi0.cxx:2006
 AliAnaPi0.cxx:2007
 AliAnaPi0.cxx:2008
 AliAnaPi0.cxx:2009
 AliAnaPi0.cxx:2010
 AliAnaPi0.cxx:2011
 AliAnaPi0.cxx:2012
 AliAnaPi0.cxx:2013
 AliAnaPi0.cxx:2014
 AliAnaPi0.cxx:2015
 AliAnaPi0.cxx:2016
 AliAnaPi0.cxx:2017
 AliAnaPi0.cxx:2018
 AliAnaPi0.cxx:2019
 AliAnaPi0.cxx:2020
 AliAnaPi0.cxx:2021
 AliAnaPi0.cxx:2022
 AliAnaPi0.cxx:2023
 AliAnaPi0.cxx:2024
 AliAnaPi0.cxx:2025
 AliAnaPi0.cxx:2026
 AliAnaPi0.cxx:2027
 AliAnaPi0.cxx:2028
 AliAnaPi0.cxx:2029
 AliAnaPi0.cxx:2030
 AliAnaPi0.cxx:2031
 AliAnaPi0.cxx:2032
 AliAnaPi0.cxx:2033
 AliAnaPi0.cxx:2034
 AliAnaPi0.cxx:2035
 AliAnaPi0.cxx:2036
 AliAnaPi0.cxx:2037
 AliAnaPi0.cxx:2038
 AliAnaPi0.cxx:2039
 AliAnaPi0.cxx:2040
 AliAnaPi0.cxx:2041
 AliAnaPi0.cxx:2042
 AliAnaPi0.cxx:2043
 AliAnaPi0.cxx:2044
 AliAnaPi0.cxx:2045
 AliAnaPi0.cxx:2046
 AliAnaPi0.cxx:2047
 AliAnaPi0.cxx:2048
 AliAnaPi0.cxx:2049
 AliAnaPi0.cxx:2050
 AliAnaPi0.cxx:2051
 AliAnaPi0.cxx:2052
 AliAnaPi0.cxx:2053
 AliAnaPi0.cxx:2054
 AliAnaPi0.cxx:2055
 AliAnaPi0.cxx:2056
 AliAnaPi0.cxx:2057
 AliAnaPi0.cxx:2058
 AliAnaPi0.cxx:2059
 AliAnaPi0.cxx:2060
 AliAnaPi0.cxx:2061
 AliAnaPi0.cxx:2062
 AliAnaPi0.cxx:2063
 AliAnaPi0.cxx:2064
 AliAnaPi0.cxx:2065
 AliAnaPi0.cxx:2066
 AliAnaPi0.cxx:2067
 AliAnaPi0.cxx:2068
 AliAnaPi0.cxx:2069
 AliAnaPi0.cxx:2070
 AliAnaPi0.cxx:2071
 AliAnaPi0.cxx:2072
 AliAnaPi0.cxx:2073
 AliAnaPi0.cxx:2074
 AliAnaPi0.cxx:2075
 AliAnaPi0.cxx:2076
 AliAnaPi0.cxx:2077
 AliAnaPi0.cxx:2078
 AliAnaPi0.cxx:2079
 AliAnaPi0.cxx:2080
 AliAnaPi0.cxx:2081
 AliAnaPi0.cxx:2082
 AliAnaPi0.cxx:2083
 AliAnaPi0.cxx:2084
 AliAnaPi0.cxx:2085
 AliAnaPi0.cxx:2086
 AliAnaPi0.cxx:2087
 AliAnaPi0.cxx:2088
 AliAnaPi0.cxx:2089
 AliAnaPi0.cxx:2090
 AliAnaPi0.cxx:2091
 AliAnaPi0.cxx:2092
 AliAnaPi0.cxx:2093
 AliAnaPi0.cxx:2094
 AliAnaPi0.cxx:2095
 AliAnaPi0.cxx:2096
 AliAnaPi0.cxx:2097
 AliAnaPi0.cxx:2098
 AliAnaPi0.cxx:2099
 AliAnaPi0.cxx:2100
 AliAnaPi0.cxx:2101
 AliAnaPi0.cxx:2102
 AliAnaPi0.cxx:2103
 AliAnaPi0.cxx:2104
 AliAnaPi0.cxx:2105
 AliAnaPi0.cxx:2106
 AliAnaPi0.cxx:2107
 AliAnaPi0.cxx:2108
 AliAnaPi0.cxx:2109
 AliAnaPi0.cxx:2110
 AliAnaPi0.cxx:2111
 AliAnaPi0.cxx:2112
 AliAnaPi0.cxx:2113
 AliAnaPi0.cxx:2114
 AliAnaPi0.cxx:2115
 AliAnaPi0.cxx:2116
 AliAnaPi0.cxx:2117
 AliAnaPi0.cxx:2118
 AliAnaPi0.cxx:2119
 AliAnaPi0.cxx:2120
 AliAnaPi0.cxx:2121
 AliAnaPi0.cxx:2122
 AliAnaPi0.cxx:2123
 AliAnaPi0.cxx:2124
 AliAnaPi0.cxx:2125
 AliAnaPi0.cxx:2126
 AliAnaPi0.cxx:2127
 AliAnaPi0.cxx:2128
 AliAnaPi0.cxx:2129
 AliAnaPi0.cxx:2130
 AliAnaPi0.cxx:2131
 AliAnaPi0.cxx:2132
 AliAnaPi0.cxx:2133
 AliAnaPi0.cxx:2134
 AliAnaPi0.cxx:2135
 AliAnaPi0.cxx:2136
 AliAnaPi0.cxx:2137
 AliAnaPi0.cxx:2138
 AliAnaPi0.cxx:2139
 AliAnaPi0.cxx:2140
 AliAnaPi0.cxx:2141
 AliAnaPi0.cxx:2142
 AliAnaPi0.cxx:2143
 AliAnaPi0.cxx:2144
 AliAnaPi0.cxx:2145
 AliAnaPi0.cxx:2146
 AliAnaPi0.cxx:2147
 AliAnaPi0.cxx:2148
 AliAnaPi0.cxx:2149
 AliAnaPi0.cxx:2150
 AliAnaPi0.cxx:2151
 AliAnaPi0.cxx:2152
 AliAnaPi0.cxx:2153
 AliAnaPi0.cxx:2154
 AliAnaPi0.cxx:2155
 AliAnaPi0.cxx:2156
 AliAnaPi0.cxx:2157
 AliAnaPi0.cxx:2158
 AliAnaPi0.cxx:2159
 AliAnaPi0.cxx:2160
 AliAnaPi0.cxx:2161
 AliAnaPi0.cxx:2162
 AliAnaPi0.cxx:2163
 AliAnaPi0.cxx:2164
 AliAnaPi0.cxx:2165
 AliAnaPi0.cxx:2166
 AliAnaPi0.cxx:2167
 AliAnaPi0.cxx:2168
 AliAnaPi0.cxx:2169
 AliAnaPi0.cxx:2170
 AliAnaPi0.cxx:2171
 AliAnaPi0.cxx:2172
 AliAnaPi0.cxx:2173
 AliAnaPi0.cxx:2174
 AliAnaPi0.cxx:2175
 AliAnaPi0.cxx:2176
 AliAnaPi0.cxx:2177
 AliAnaPi0.cxx:2178
 AliAnaPi0.cxx:2179
 AliAnaPi0.cxx:2180
 AliAnaPi0.cxx:2181
 AliAnaPi0.cxx:2182
 AliAnaPi0.cxx:2183
 AliAnaPi0.cxx:2184
 AliAnaPi0.cxx:2185
 AliAnaPi0.cxx:2186
 AliAnaPi0.cxx:2187
 AliAnaPi0.cxx:2188
 AliAnaPi0.cxx:2189
 AliAnaPi0.cxx:2190
 AliAnaPi0.cxx:2191
 AliAnaPi0.cxx:2192
 AliAnaPi0.cxx:2193
 AliAnaPi0.cxx:2194
 AliAnaPi0.cxx:2195
 AliAnaPi0.cxx:2196
 AliAnaPi0.cxx:2197
 AliAnaPi0.cxx:2198
 AliAnaPi0.cxx:2199
 AliAnaPi0.cxx:2200
 AliAnaPi0.cxx:2201
 AliAnaPi0.cxx:2202
 AliAnaPi0.cxx:2203
 AliAnaPi0.cxx:2204
 AliAnaPi0.cxx:2205
 AliAnaPi0.cxx:2206
 AliAnaPi0.cxx:2207
 AliAnaPi0.cxx:2208
 AliAnaPi0.cxx:2209
 AliAnaPi0.cxx:2210
 AliAnaPi0.cxx:2211
 AliAnaPi0.cxx:2212
 AliAnaPi0.cxx:2213
 AliAnaPi0.cxx:2214
 AliAnaPi0.cxx:2215
 AliAnaPi0.cxx:2216
 AliAnaPi0.cxx:2217
 AliAnaPi0.cxx:2218
 AliAnaPi0.cxx:2219
 AliAnaPi0.cxx:2220
 AliAnaPi0.cxx:2221
 AliAnaPi0.cxx:2222
 AliAnaPi0.cxx:2223
 AliAnaPi0.cxx:2224
 AliAnaPi0.cxx:2225
 AliAnaPi0.cxx:2226
 AliAnaPi0.cxx:2227
 AliAnaPi0.cxx:2228
 AliAnaPi0.cxx:2229
 AliAnaPi0.cxx:2230
 AliAnaPi0.cxx:2231
 AliAnaPi0.cxx:2232
 AliAnaPi0.cxx:2233
 AliAnaPi0.cxx:2234
 AliAnaPi0.cxx:2235
 AliAnaPi0.cxx:2236
 AliAnaPi0.cxx:2237
 AliAnaPi0.cxx:2238
 AliAnaPi0.cxx:2239
 AliAnaPi0.cxx:2240
 AliAnaPi0.cxx:2241
 AliAnaPi0.cxx:2242
 AliAnaPi0.cxx:2243
 AliAnaPi0.cxx:2244
 AliAnaPi0.cxx:2245
 AliAnaPi0.cxx:2246
 AliAnaPi0.cxx:2247
 AliAnaPi0.cxx:2248
 AliAnaPi0.cxx:2249
 AliAnaPi0.cxx:2250
 AliAnaPi0.cxx:2251
 AliAnaPi0.cxx:2252
 AliAnaPi0.cxx:2253
 AliAnaPi0.cxx:2254
 AliAnaPi0.cxx:2255
 AliAnaPi0.cxx:2256
 AliAnaPi0.cxx:2257
 AliAnaPi0.cxx:2258
 AliAnaPi0.cxx:2259
 AliAnaPi0.cxx:2260
 AliAnaPi0.cxx:2261
 AliAnaPi0.cxx:2262
 AliAnaPi0.cxx:2263
 AliAnaPi0.cxx:2264
 AliAnaPi0.cxx:2265
 AliAnaPi0.cxx:2266
 AliAnaPi0.cxx:2267
 AliAnaPi0.cxx:2268
 AliAnaPi0.cxx:2269
 AliAnaPi0.cxx:2270
 AliAnaPi0.cxx:2271
 AliAnaPi0.cxx:2272
 AliAnaPi0.cxx:2273
 AliAnaPi0.cxx:2274
 AliAnaPi0.cxx:2275
 AliAnaPi0.cxx:2276
 AliAnaPi0.cxx:2277
 AliAnaPi0.cxx:2278
 AliAnaPi0.cxx:2279
 AliAnaPi0.cxx:2280
 AliAnaPi0.cxx:2281
 AliAnaPi0.cxx:2282
 AliAnaPi0.cxx:2283
 AliAnaPi0.cxx:2284
 AliAnaPi0.cxx:2285
 AliAnaPi0.cxx:2286
 AliAnaPi0.cxx:2287
 AliAnaPi0.cxx:2288
 AliAnaPi0.cxx:2289
 AliAnaPi0.cxx:2290
 AliAnaPi0.cxx:2291
 AliAnaPi0.cxx:2292
 AliAnaPi0.cxx:2293
 AliAnaPi0.cxx:2294
 AliAnaPi0.cxx:2295
 AliAnaPi0.cxx:2296
 AliAnaPi0.cxx:2297
 AliAnaPi0.cxx:2298
 AliAnaPi0.cxx:2299
 AliAnaPi0.cxx:2300
 AliAnaPi0.cxx:2301
 AliAnaPi0.cxx:2302
 AliAnaPi0.cxx:2303
 AliAnaPi0.cxx:2304
 AliAnaPi0.cxx:2305
 AliAnaPi0.cxx:2306
 AliAnaPi0.cxx:2307
 AliAnaPi0.cxx:2308
 AliAnaPi0.cxx:2309
 AliAnaPi0.cxx:2310
 AliAnaPi0.cxx:2311
 AliAnaPi0.cxx:2312
 AliAnaPi0.cxx:2313
 AliAnaPi0.cxx:2314
 AliAnaPi0.cxx:2315
 AliAnaPi0.cxx:2316
 AliAnaPi0.cxx:2317
 AliAnaPi0.cxx:2318
 AliAnaPi0.cxx:2319
 AliAnaPi0.cxx:2320
 AliAnaPi0.cxx:2321
 AliAnaPi0.cxx:2322
 AliAnaPi0.cxx:2323
 AliAnaPi0.cxx:2324
 AliAnaPi0.cxx:2325
 AliAnaPi0.cxx:2326
 AliAnaPi0.cxx:2327
 AliAnaPi0.cxx:2328
 AliAnaPi0.cxx:2329
 AliAnaPi0.cxx:2330
 AliAnaPi0.cxx:2331
 AliAnaPi0.cxx:2332
 AliAnaPi0.cxx:2333
 AliAnaPi0.cxx:2334
 AliAnaPi0.cxx:2335
 AliAnaPi0.cxx:2336
 AliAnaPi0.cxx:2337
 AliAnaPi0.cxx:2338
 AliAnaPi0.cxx:2339
 AliAnaPi0.cxx:2340
 AliAnaPi0.cxx:2341
 AliAnaPi0.cxx:2342
 AliAnaPi0.cxx:2343
 AliAnaPi0.cxx:2344
 AliAnaPi0.cxx:2345
 AliAnaPi0.cxx:2346
 AliAnaPi0.cxx:2347
 AliAnaPi0.cxx:2348
 AliAnaPi0.cxx:2349
 AliAnaPi0.cxx:2350
 AliAnaPi0.cxx:2351
 AliAnaPi0.cxx:2352
 AliAnaPi0.cxx:2353
 AliAnaPi0.cxx:2354
 AliAnaPi0.cxx:2355
 AliAnaPi0.cxx:2356
 AliAnaPi0.cxx:2357
 AliAnaPi0.cxx:2358
 AliAnaPi0.cxx:2359
 AliAnaPi0.cxx:2360
 AliAnaPi0.cxx:2361
 AliAnaPi0.cxx:2362
 AliAnaPi0.cxx:2363
 AliAnaPi0.cxx:2364
 AliAnaPi0.cxx:2365
 AliAnaPi0.cxx:2366
 AliAnaPi0.cxx:2367
 AliAnaPi0.cxx:2368
 AliAnaPi0.cxx:2369
 AliAnaPi0.cxx:2370
 AliAnaPi0.cxx:2371
 AliAnaPi0.cxx:2372
 AliAnaPi0.cxx:2373
 AliAnaPi0.cxx:2374
 AliAnaPi0.cxx:2375
 AliAnaPi0.cxx:2376
 AliAnaPi0.cxx:2377
 AliAnaPi0.cxx:2378
 AliAnaPi0.cxx:2379
 AliAnaPi0.cxx:2380
 AliAnaPi0.cxx:2381
 AliAnaPi0.cxx:2382
 AliAnaPi0.cxx:2383
 AliAnaPi0.cxx:2384
 AliAnaPi0.cxx:2385
 AliAnaPi0.cxx:2386
 AliAnaPi0.cxx:2387
 AliAnaPi0.cxx:2388
 AliAnaPi0.cxx:2389
 AliAnaPi0.cxx:2390
 AliAnaPi0.cxx:2391
 AliAnaPi0.cxx:2392
 AliAnaPi0.cxx:2393
 AliAnaPi0.cxx:2394
 AliAnaPi0.cxx:2395
 AliAnaPi0.cxx:2396
 AliAnaPi0.cxx:2397
 AliAnaPi0.cxx:2398
 AliAnaPi0.cxx:2399
 AliAnaPi0.cxx:2400
 AliAnaPi0.cxx:2401
 AliAnaPi0.cxx:2402
 AliAnaPi0.cxx:2403
 AliAnaPi0.cxx:2404
 AliAnaPi0.cxx:2405
 AliAnaPi0.cxx:2406
 AliAnaPi0.cxx:2407
 AliAnaPi0.cxx:2408
 AliAnaPi0.cxx:2409
 AliAnaPi0.cxx:2410
 AliAnaPi0.cxx:2411
 AliAnaPi0.cxx:2412
 AliAnaPi0.cxx:2413
 AliAnaPi0.cxx:2414
 AliAnaPi0.cxx:2415
 AliAnaPi0.cxx:2416
 AliAnaPi0.cxx:2417
 AliAnaPi0.cxx:2418
 AliAnaPi0.cxx:2419
 AliAnaPi0.cxx:2420
 AliAnaPi0.cxx:2421
 AliAnaPi0.cxx:2422
 AliAnaPi0.cxx:2423
 AliAnaPi0.cxx:2424
 AliAnaPi0.cxx:2425
 AliAnaPi0.cxx:2426
 AliAnaPi0.cxx:2427
 AliAnaPi0.cxx:2428
 AliAnaPi0.cxx:2429
 AliAnaPi0.cxx:2430
 AliAnaPi0.cxx:2431
 AliAnaPi0.cxx:2432
 AliAnaPi0.cxx:2433
 AliAnaPi0.cxx:2434
 AliAnaPi0.cxx:2435
 AliAnaPi0.cxx:2436
 AliAnaPi0.cxx:2437
 AliAnaPi0.cxx:2438
 AliAnaPi0.cxx:2439
 AliAnaPi0.cxx:2440
 AliAnaPi0.cxx:2441
 AliAnaPi0.cxx:2442
 AliAnaPi0.cxx:2443
 AliAnaPi0.cxx:2444
 AliAnaPi0.cxx:2445
 AliAnaPi0.cxx:2446
 AliAnaPi0.cxx:2447
 AliAnaPi0.cxx:2448
 AliAnaPi0.cxx:2449
 AliAnaPi0.cxx:2450
 AliAnaPi0.cxx:2451
 AliAnaPi0.cxx:2452
 AliAnaPi0.cxx:2453
 AliAnaPi0.cxx:2454
 AliAnaPi0.cxx:2455
 AliAnaPi0.cxx:2456
 AliAnaPi0.cxx:2457
 AliAnaPi0.cxx:2458
 AliAnaPi0.cxx:2459
 AliAnaPi0.cxx:2460
 AliAnaPi0.cxx:2461
 AliAnaPi0.cxx:2462
 AliAnaPi0.cxx:2463
 AliAnaPi0.cxx:2464
 AliAnaPi0.cxx:2465
 AliAnaPi0.cxx:2466
 AliAnaPi0.cxx:2467
 AliAnaPi0.cxx:2468
 AliAnaPi0.cxx:2469
 AliAnaPi0.cxx:2470
 AliAnaPi0.cxx:2471
 AliAnaPi0.cxx:2472
 AliAnaPi0.cxx:2473
 AliAnaPi0.cxx:2474
 AliAnaPi0.cxx:2475
 AliAnaPi0.cxx:2476
 AliAnaPi0.cxx:2477
 AliAnaPi0.cxx:2478
 AliAnaPi0.cxx:2479
 AliAnaPi0.cxx:2480
 AliAnaPi0.cxx:2481
 AliAnaPi0.cxx:2482
 AliAnaPi0.cxx:2483
 AliAnaPi0.cxx:2484
 AliAnaPi0.cxx:2485
 AliAnaPi0.cxx:2486
 AliAnaPi0.cxx:2487
 AliAnaPi0.cxx:2488
 AliAnaPi0.cxx:2489
 AliAnaPi0.cxx:2490
 AliAnaPi0.cxx:2491
 AliAnaPi0.cxx:2492
 AliAnaPi0.cxx:2493
 AliAnaPi0.cxx:2494
 AliAnaPi0.cxx:2495
 AliAnaPi0.cxx:2496
 AliAnaPi0.cxx:2497
 AliAnaPi0.cxx:2498
 AliAnaPi0.cxx:2499
 AliAnaPi0.cxx:2500
 AliAnaPi0.cxx:2501
 AliAnaPi0.cxx:2502
 AliAnaPi0.cxx:2503
 AliAnaPi0.cxx:2504
 AliAnaPi0.cxx:2505
 AliAnaPi0.cxx:2506
 AliAnaPi0.cxx:2507
 AliAnaPi0.cxx:2508
 AliAnaPi0.cxx:2509
 AliAnaPi0.cxx:2510
 AliAnaPi0.cxx:2511
 AliAnaPi0.cxx:2512
 AliAnaPi0.cxx:2513
 AliAnaPi0.cxx:2514
 AliAnaPi0.cxx:2515
 AliAnaPi0.cxx:2516
 AliAnaPi0.cxx:2517
 AliAnaPi0.cxx:2518
 AliAnaPi0.cxx:2519
 AliAnaPi0.cxx:2520
 AliAnaPi0.cxx:2521
 AliAnaPi0.cxx:2522
 AliAnaPi0.cxx:2523
 AliAnaPi0.cxx:2524
 AliAnaPi0.cxx:2525
 AliAnaPi0.cxx:2526
 AliAnaPi0.cxx:2527
 AliAnaPi0.cxx:2528
 AliAnaPi0.cxx:2529
 AliAnaPi0.cxx:2530
 AliAnaPi0.cxx:2531
 AliAnaPi0.cxx:2532
 AliAnaPi0.cxx:2533
 AliAnaPi0.cxx:2534
 AliAnaPi0.cxx:2535
 AliAnaPi0.cxx:2536
 AliAnaPi0.cxx:2537
 AliAnaPi0.cxx:2538
 AliAnaPi0.cxx:2539
 AliAnaPi0.cxx:2540
 AliAnaPi0.cxx:2541
 AliAnaPi0.cxx:2542
 AliAnaPi0.cxx:2543
 AliAnaPi0.cxx:2544
 AliAnaPi0.cxx:2545
 AliAnaPi0.cxx:2546
 AliAnaPi0.cxx:2547
 AliAnaPi0.cxx:2548
 AliAnaPi0.cxx:2549
 AliAnaPi0.cxx:2550
 AliAnaPi0.cxx:2551
 AliAnaPi0.cxx:2552
 AliAnaPi0.cxx:2553
 AliAnaPi0.cxx:2554
 AliAnaPi0.cxx:2555
 AliAnaPi0.cxx:2556
 AliAnaPi0.cxx:2557
 AliAnaPi0.cxx:2558
 AliAnaPi0.cxx:2559
 AliAnaPi0.cxx:2560
 AliAnaPi0.cxx:2561
 AliAnaPi0.cxx:2562
 AliAnaPi0.cxx:2563
 AliAnaPi0.cxx:2564
 AliAnaPi0.cxx:2565