ROOT logo
#include "AliAnalysisMuMuNch.h"

/**
 *
 * \ingroup pwg-muon-mumu
 *
 * \class AliAnalysisMuMuNch
 *
 * SPD tracklet to Nch analysis
 *
 * The idea is that this sub-analysis is used first (within the AliAnalysisTaskMuMu sub-framework)
 * in order to compute the number of charged particles within an event, so that information
 * can be used in subsequent sub-analysis, like the invariant mass or mean pt ones.
 *
 */

#include "AliInputEventHandler.h"
#include "AliMultiplicity.h"
#include "AliAODTracklets.h"
#include "AliAnalysisMuonUtility.h"
#include "AliLog.h"
#include "AliAODEvent.h"
#include "AliESDEvent.h"
#include "AliESDUtils.h"
#include "TMath.h"
#include "AliAnalysisMuMuCutRegistry.h"
#include "AliAnalysisMuMuEventCutter.h"
#include "AliAnalysisMuMuCutElement.h"
#include "AliAnalysisMuMuBinning.h"
#include "Riostream.h"
#include "TParameter.h"
#include <set>
#include <utility>
#include "AliMergeableCollection.h"
#include "AliMCEvent.h"
#include "AliAODMCParticle.h"
#include "TAxis.h"
#include "TCanvas.h"
#include "TH2F.h"
#include "TF1.h"
#include "TProfile.h"
#include "TObjString.h"
#include "TRandom3.h"

#include "AliAODMCHeader.h"
#include "AliGenEventHeader.h"
#include "AliGenHijingEventHeader.h"
#include "AliGenDPMjetEventHeader.h"
#include "AliGenPythiaEventHeader.h"
#include "AliGenCocktailEventHeader.h"


namespace {

  Double_t SPDgeomR(Double_t* x,Double_t* par) // Eta position of the SPD right edge eta as "seen" from a z vertex position
  {
    // par[0] = radius of SPD layer
    
    Double_t d = x[0];
    Double_t z(0.);
    Double_t theta(0.);
    
    if( d < 14.09999 )
    {
      z = 14.1 - d;
      theta = TMath::ATan(par[0]/z);
    }
    
    else if( d > 14.09999 )
    {
      z = d - 14.1;
      theta = TMath::Pi() - TMath::ATan(par[0]/z);
    }
    
    return -TMath::Log(TMath::Tan(theta/2.));
  }
  
  Double_t SPDgeomL(Double_t* x,Double_t* par) // Eta position of the SPD left edge eta as "seen" from a z vertex position
  {
    // par[0] = radius of SPD layer
    
    Double_t d = x[0];
    Double_t z(0.);
    Double_t theta(0.);
    
    if( d > -14.09999 )
    {
      z = 14.1 + d;
      theta = TMath::Pi() - TMath::ATan(par[0]/z);
    }
    
    if( d < -14.09999 )
    {
      z = -14.1 - d;
      theta = TMath::ATan(par[0]/z);
    }
    
    return -TMath::Log(TMath::Tan(theta/2.));
  }

}

////_____________________________________________________________________________
//AliAnalysisMuMuNch::AliAnalysisMuMuNch(TH2* spdCorrection, Double_t etaMin, Double_t etaMax
//                                      , Double_t zMin, Double_t zMax,Bool_t disableHistos, Bool_t computeResolution)
//: AliAnalysisMuMuBase(),
//fSPDCorrection(0x0),
//fEtaAxis(new TAxis(TMath::Nint(10./0.1),-5.,5.)),
//fZAxis(new TAxis(TMath::Nint(80/0.25),-40.,40.)),
//fCurrentEvent(0x0),
//fEtaMin(etaMin),
//fEtaMax(etaMax),
//fZMin(zMin),
//fZMax(zMax),
//fResolution(computeResolution)
//{
//  if ( spdCorrection )
//  {
//    fSPDCorrection = static_cast<TH2F*>(spdCorrection->Clone());
//    fSPDCorrection->SetDirectory(0);
//  }
//  DefineSPDAcceptance();
//  
//  if ( disableHistos )
//  {
//    DisableHistograms("*");
//  }
//}

//FIXME: First and second constructor may be ambiguous if we do not set all the arguments

//_____________________________________________________________________________
AliAnalysisMuMuNch::AliAnalysisMuMuNch(TH2F* spdCorrection, TProfile* spdMeanCorrection, Double_t meanTrRef, Double_t etaMin, Double_t etaMax
                                       , Double_t zMin, Double_t zMax, Bool_t disableHistos, Bool_t computeResolution)
: AliAnalysisMuMuBase(),
fSPDOneOverAccxEff(0x0),
fSPDCorrectionMap(0x0),
fSPDCorrectionList(0x0),
fSPDMeanTracklets(0x0),
fSPDMeanTrackletsCorrToCompare(0x0),
fEtaAxis(new TAxis(TMath::Nint(10./0.1),-5.,5.)),
fZAxis(new TAxis(TMath::Nint(80/0.25),-40.,40.)),
fCurrentEvent(0x0),
fMeanTrRef(meanTrRef),
fEtaMin(etaMin),
fEtaMax(etaMax),
fEtaMinToCompare(0.),
fEtaMaxToCompare(0.),
fetaRange(),
fZMin(zMin),
fZMax(zMax),
fResolution(computeResolution),
frand(0x0),
fGeneratorHeaderClass(new TString("AliGenDPMjetEventHeader"))
{
  //FIXME: Add a protection to avoid an etamin or etamax non multiple of the eta bin size
  
  //FIXME: Add fluctuations to the SPD AccxEff correction method
  
  if ( spdCorrection && spdMeanCorrection )
  {
    AliWarning("Two methods used to correct tracklets: Data-driven and SPDAccxEff corrected tracklets will be available in the event list, but the histograms in this class will be filled just with the AccxEff corrected values");
//    AliFatal("Cannot use 2 different methods for tracklets correction");
  }
//  else if ( spdCorrection )
  if ( spdCorrection )
  {
    AliWarning("SPD AccxEff correction method not ready to be used, fluctuations are missing. Do not trust the results");
    
    if ( fMeanTrRef > 0. && !spdMeanCorrection ) AliWarning("Reference mean nof tracklets argument will not be used: SPD AccxEff correction method in use");
    
    fSPDOneOverAccxEff = static_cast<TH2F*>(spdCorrection->Clone());
    fSPDOneOverAccxEff->SetDirectory(0);
  }
//  else if ( spdMeanCorrection )
  if ( spdMeanCorrection )
  {
    if ( fMeanTrRef < 0. ) AliWarning("Reference mean nof tracklets argument set to -1: Maximum of the spdMeanCorrection will be used");
    else AliWarning(Form("Using %f as reference mean nof tracklets for correction",fMeanTrRef));
    
    frand = new TRandom3();
    fSPDMeanTracklets = static_cast<TProfile*>(spdMeanCorrection->Clone());
    fSPDMeanTracklets->SetDirectory(0);
  }
  
  DefineSPDAcceptance();
  
  if ( disableHistos ) // FIXME: Is this really useful? it breaks when setting to ktrue due to non existence of histos in SetEvent(). Answer: It is useful, it will speed up the task when we want to execute only SetEvent and not fill all the multiplicity histos (i.e. doing J/psi vs multiplicity analysis). The problem is that disabling the histos the method CreateHisto() does not create histosm thats why the task breaks in SetEvent, so fix this
  {
    DisableHistograms("*");
  }
}

//_____________________________________________________________________________
AliAnalysisMuMuNch::AliAnalysisMuMuNch(TProfile* spdMeanCorrection, TProfile* spdMeanCorrectionToCompare, Double_t meanTrRef, Double_t etaMin,
                                       Double_t etaMax, Double_t zMin, Double_t zMax, Double_t etaMinToCompare, Double_t etaMaxToCompare,Bool_t disableHistos, Bool_t computeResolution)
: AliAnalysisMuMuBase(),
fSPDOneOverAccxEff(0x0),
fSPDCorrectionMap(0x0),
fSPDCorrectionList(0x0),
fSPDMeanTracklets(0x0),
fSPDMeanTrackletsCorrToCompare(0x0),
fEtaAxis(new TAxis(TMath::Nint(10./0.1),-5.,5.)),
fZAxis(new TAxis(TMath::Nint(80/0.25),-40.,40.)),
fCurrentEvent(0x0),
fMeanTrRef(meanTrRef),
fEtaMin(etaMin),
fEtaMax(etaMax),
fEtaMinToCompare(etaMinToCompare),
fEtaMaxToCompare(etaMaxToCompare),
fetaRange(),
fZMin(zMin),
fZMax(zMax),
fResolution(computeResolution),
frand(0x0),
fGeneratorHeaderClass(new TString("AliGenDPMjetEventHeader"))
{
  //FIXME: Add a protection to avoid an etamin or etamax non multiple of the eta bin size
  
  /// This construction is designed to compute everything in etaMin < eta < etaMax and correct with spdMeanCorrection (main eta tange and correction), but when filling the histos in FillHistosForEvent is able to compute the number of tracklets in etaMinToCompare < eta < etaMaxToCompare and correct them with spdMeanCorrectionToCompare (secondary eta range and correction) in order to compare N_{tr}^{|eta|< etaMax} vs N_{tr}^{|eta|< etaMaxToCompare}
  
  if ( !spdMeanCorrection || !spdMeanCorrectionToCompare )
  {
    AliFatal("Need the two corrections to compare. Maybe you are using the wrong constructor");
  }
  if ( fEtaMinToCompare < fEtaMin || fEtaMaxToCompare > fEtaMax )
  {
    AliFatal("Cannot select a eta range to compare wider than the main eta range");
  }
  
  if ( fMeanTrRef < 0. ) AliWarning("Reference mean nof tracklets argument set to -1: Maximum of the spdMeanCorrection will be used");
  else AliWarning(Form("Using %f as reference mean nof tracklets for correction",fMeanTrRef));
  
  frand = new TRandom3();
  fSPDMeanTracklets = static_cast<TProfile*>(spdMeanCorrection->Clone());
  fSPDMeanTracklets->SetDirectory(0);
  
  fSPDMeanTrackletsCorrToCompare = static_cast<TProfile*>(spdMeanCorrectionToCompare->Clone());
  fSPDMeanTrackletsCorrToCompare->SetDirectory(0);
    
  DefineSPDAcceptance();
  
  if ( disableHistos ) // FIXME: Is this really useful? it breaks when setting to ktrue due to non existence of histos in SetEvent()
  {
    DisableHistograms("*");
  }
}

//_____________________________________________________________________________
AliAnalysisMuMuNch::AliAnalysisMuMuNch(TObjArray* spdCorrectionList, Double_t meanTrRef, Double_t etaMin, Double_t etaMax
                                       , Double_t zMin, Double_t zMax,Bool_t disableHistos, Bool_t computeResolution)
: AliAnalysisMuMuBase(),
fSPDOneOverAccxEff(0x0),
fSPDCorrectionMap(0x0),
fSPDCorrectionList(0x0),
fSPDMeanTracklets(0x0),
fSPDMeanTrackletsCorrToCompare(0x0),
fEtaAxis(new TAxis(TMath::Nint(10./0.1),-5.,5.)),
fZAxis(new TAxis(TMath::Nint(80/0.25),-40.,40.)),
fCurrentEvent(0x0),
fMeanTrRef(meanTrRef),
fEtaMin(etaMin),
fEtaMax(etaMax),
fEtaMinToCompare(0.),
fEtaMaxToCompare(0.),
fetaRange(),
fZMin(zMin),
fZMax(zMax),
fResolution(computeResolution),
frand(0x0),
fGeneratorHeaderClass(new TString("AliGenDPMjetEventHeader"))
{
  //FIXME: Add a protection to avoid an etamin or etamax non multiple of the eta bin size
  
  // Uses a different correction for each group of runs (both SPD AccxEff OR mean tracklets are supported)
  
  if ( spdCorrectionList ) DefineSPDCorrectionMap(spdCorrectionList);
  else AliFatal("No SPD correction list provided");
  
  if ( fMeanTrRef < 0. ) AliWarning("Reference mean nof tracklets argument set to -1: Maximum of the spdMeanCorrection will be used");
  else AliWarning(Form("Using %f as reference mean nof tracklets for correction",fMeanTrRef));

  frand = new TRandom3();
  
  DefineSPDAcceptance();
  
  if ( disableHistos ) // FIXME: Is this really useful? it breaks when setting to ktrue due to non existence of histos in SetEvent()
  {
    DisableHistograms("*");
  }
}

//_____________________________________________________________________________
AliAnalysisMuMuNch::~AliAnalysisMuMuNch()
{
  delete fSPDOneOverAccxEff;
  delete fSPDCorrectionMap;
  delete fSPDCorrectionList;
  delete fSPDMeanTracklets;
  delete fSPDMeanTrackletsCorrToCompare;
  delete fEtaAxis;
  delete fZAxis;
  delete fSPD1LR;
  delete fSPD1LL;
  delete fSPD2LR;
  delete fSPD2LL;
  delete frand;
  delete fGeneratorHeaderClass;
}

//_____________________________________________________________________________
void AliAnalysisMuMuNch::DefineGeneratorName(const char* genName)
{
//  TString sgenName(genName);
//  if ( sgenNam.Contains("pythia") ) fGeneratorHeaderClass = "AliGenPythiaEventHeader";
//  else if ( sgenNam.Contains("dpmjet") ) fGeneratorHeaderClass = "AliGenDPMjetEventHeader";
//  else if ( sgenNam.Contains("dpmjet") ) fGeneratorHeaderClass = "AliGenHijingEventHeader";
  
  fGeneratorHeaderClass->Form("%s",genName);
  
  std::cout << " Will use " << fGeneratorHeaderClass->Data() << " tracks" << std::endl;
}
                                                   
//_____________________________________________________________________________
void AliAnalysisMuMuNch::DefineHistogramCollection(const char* eventSelection,
                                                   const char* triggerClassName,
                                                   const char* centrality)
{
  // Define multiplicity histos
  
  if ( Histo(eventSelection,triggerClassName,centrality,"AliAnalysisMuMuNch") )
  {
    return;
  }

  // dummy histogram to signal that we already defined all our histograms (see above)
  CreateEventHistos(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"AliAnalysisMuMuNch","Dummy semaphore",1,0,1);

  Double_t multMin = -0.5;  //Tracklets multiplicity range
  Double_t multMax = 500.5;
  Int_t nbinsMult = GetNbins(multMin,multMax,1.);
  
  Double_t phimin = 0.; //Phi range
  Double_t phimax = 2*TMath::Pi();
  Int_t nphibins = GetNbins(phimin,phimax,0.05);

  if ( !fSPDMeanTracklets && !fSPDOneOverAccxEff && fResolution ) // Resolution histos
  {
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"EtaRes","#eta resolution;#eta_{Reco} - #eta_{MC};Counts",(fEtaAxis->GetNbins())*2,fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"PhiRes","#phi resolution;#phi_{Reco} - #phi_{MC};Counts",nphibins*2,-phimax,phimax);
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"PhiResShifted","#phi resolution;#phi_{Reco} - #phi_{MC};Counts",nphibins*4,-phimax/4,phimax/4);
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"EtaResVsZ","#eta resolution vs MC Zvertex;ZVertex (cm);#eta_{Reco} - #eta_{MC}",(fZAxis->GetNbins())*20,fZAxis->GetXmin(),fZAxis->GetXmax(),(fEtaAxis->GetNbins())*8,fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"PhiResVsZ","#phi resolution vs MC Zvertex;ZVertex (cm);#phi_{Reco} - #phi_{MC}",(fZAxis->GetNbins())*20,fZAxis->GetXmin(),fZAxis->GetXmax(),nphibins*4,-phimax/4,phimax/4);
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"EtaResVsnC","#eta resolution vs Nof contributors to SPD vertex;NofContributors;#eta_{Reco} - #eta_{MC}",200,0,200,(fEtaAxis->GetNbins())*8,fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"PhiResVsnC","#phi resolution vs Nof contributors to SPD vertex;NofContributors;#phi_{Reco} - #phi_{MC}",200,0,200,nphibins*4,-phimax/4,phimax/4);
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"SPDZvResVsnC","SPD Zvertex resolution vs Nof contributors;NofContributors;Zvertex_{Reco} - Zvertex_{MC} (cm)",200,0,200,(fZAxis->GetNbins())*20,fZAxis->GetXmin(),fZAxis->GetXmax());
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"SPDZvResVsMCz","SPD Zvertex resolution vs MC z vertex;MC Zvertex (cm);Zvertex_{Reco} - Zvertex_{MC} (cm)",(fZAxis->GetNbins())*20,fZAxis->GetXmin(),fZAxis->GetXmax(),(fZAxis->GetNbins())*10,fZAxis->GetXmin(),fZAxis->GetXmax());
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"Phi","Reco #phi distribution;#phi;Counts",nphibins,phimin,phimax);
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"MCPhi","MC #phi distribution;#phi;Counts",nphibins,phimin,phimax);
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"Eta","Reco #eta distribution;#phi;Counts",(fEtaAxis->GetNbins())*2,fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"MCEta","MC #eta distribution;#phi;Counts",(fEtaAxis->GetNbins())*2,fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
    
    return; // When computing resolutions we don't want to create the rest of histos
  }

  TString TrackletsCorrectedName("");
  TString TrackletsCorrectedAxisName("");
  if ( fSPDMeanTracklets && !fSPDOneOverAccxEff )
  {
    TrackletsCorrectedName = "Number of corrected tracklets";
    TrackletsCorrectedAxisName = "N_{tr}^{corr}";
  }
  else if( fSPDOneOverAccxEff )
  {
    TrackletsCorrectedName = "Number of charged particles";
    TrackletsCorrectedAxisName = "N_{ch}";
  }
  
  CreateEventHistos(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"TrackletsVsZVertexVsPhi","Number of tracklets vs Z vertex vs #phi;Z vertex;#phi",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),nphibins,phimin,phimax);
  
  CreateEventHistos(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"TrackletsVsZVertexVsEta","Number of tracklets vs ZVertex vs #eta;ZVertex;#eta",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
  AttachSPDAcceptance(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"TrackletsVsZVertexVsEta");
  
  CreateEventHistos(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"Tracklets",Form("Number of tracklets in |#eta| < %1.1f distribution;N_{Tracklets};N_{events}",fEtaMax),nbinsMult,multMin,multMax);
    
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"NBkgTrackletsVsZVertexVsEta","Number of background tracklets vs ZVertex vs #eta;ZVertex;#eta",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
  AttachSPDAcceptance(kHistoForMCInput,eventSelection,triggerClassName,centrality,"NBkgTrackletsVsZVertexVsEta");
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"NchVsZVertexVsEta","Number of charged particles vs ZVertex vs #eta;ZVertex;#eta",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"NchVsRecoZVertexVsEta","Number of gen. charged particles vs reco. ZVertex vs gen. #eta;ZVertex;#eta",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"NchVsZVertexVsEta",Form("%s vs ZVertex vs #eta;ZVertex;#eta",TrackletsCorrectedName.Data()),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
  AttachSPDAcceptance(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"NchVsZVertexVsEta");
  AttachSPDAcceptance(kHistoForMCInput,eventSelection,triggerClassName,centrality,"NchVsRecoZVertexVsEta");
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"NchVsZVertexVsPhi","Number of charged particles vs ZVertex vs #phi;ZVertex;#phi",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),nphibins,phimin,phimax);
  
  CreateEventHistos(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"EventsVsZVertexVsEta","Effective number of events vs ZVertex vs #eta;ZVertex;#eta",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax()); // Fill 1 unit in each "touched" eta bin per event (represents the eta bins in which each event contributes)
  AttachSPDAcceptance(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"EventsVsZVertexVsEta");
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"Nch",Form("Number of charged particles in |#eta| < %1.1f distribution;N_{ch};N_{events}",fEtaMax),nbinsMult,multMin,multMax);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"Nch",Form("%s in |#eta| < %1.1f distribution;%s;N_{events}",TrackletsCorrectedName.Data(),fEtaMax,TrackletsCorrectedAxisName.Data()),nbinsMult,multMin,multMax);
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"dNchdEta",Form("<dNchd#eta> in |#eta| < %1.1f distribution;dN_{ch}/d#eta;N_{events}",fEtaMax),nbinsMult,multMin,multMax);
   CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"dNchdEta",Form("<d%sd#eta> in |#eta| < %1.1f distribution;d%s/d#eta;N_{events}",TrackletsCorrectedAxisName.Data(),fEtaMax,TrackletsCorrectedAxisName.Data()),nbinsMult,multMin,multMax);
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"TrackletsVsNch",Form("Number of tracklets vs number of generated charged particles in |#eta| < %1.1f;N_{ch};N_{tracklets}",fEtaMax),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax); //Response matrix
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"TrackletsVsNch",Form("Number of tracklets vs %s in |#eta| < %1.1f;%s;N_{tracklets}",TrackletsCorrectedName.Data(),fEtaMax,TrackletsCorrectedAxisName.Data()),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  
   CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"dNchdetaVsMCdNchdeta",Form("Corrected dN_{ch}/d#eta vs MC dN_{ch}/d#eta in |#eta| < %1.1f;(dN_{ch}/d#eta)_{MC};dN_{ch}/d#eta",fEtaMax),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"V0AMultVsNch",Form("V0A multiplicity vs number of generated charged particles in |#eta| < %1.1f;N_{ch};V0A Mult",fEtaMax),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V0AMultVsNch",Form("V0A multiplicity vs %s in |#eta| < %1.1f;%s;V0A Mult",TrackletsCorrectedName.Data(),fEtaMax,TrackletsCorrectedAxisName.Data()),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"V0CMultVsNch",Form("V0C multiplicity vs number of generated charged particles in |#eta| < %1.1f;N_{ch};V0C Mult",fEtaMax),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V0CMultVsNch",Form("V0C multiplicity vs %s in |#eta| < %1.1f;%s;V0A Mult",TrackletsCorrectedName.Data(),fEtaMax,TrackletsCorrectedAxisName.Data()),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  
//  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"NchVsTracklets","Number of generated charged particles vs reco tracklets;N_{tracklets};N_{ch}",nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  
  if ( fSPDMeanTrackletsCorrToCompare )
  {
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"CorrTrackletsEtaSecVsCorrTrackletsEtaPrim",Form("N_{tr}^{corr} in |#eta|< %1.1f vs N_{tr}^{corr} in |#eta|< %1.1f;N_{tracklets}^{|#eta|<%1.1f};N_{tracklets}^{|#eta|<%1.1f}",fEtaMaxToCompare,fEtaMax,fEtaMax,fEtaMaxToCompare),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"MeanNchEtaSecVsZVertex",Form("Mean number of corrected tracklets in |#eta| < %1.1f vs Z vertex;Z vertex;<N_{tr}^{corr}>",fEtaMaxToCompare),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"MeanTrackletsEtaSecVsZVertex",Form("Mean number of tracklets in |#eta| < %1.1f vs Z vertex;Z vertex;<N_{tr}^{corr}>",fEtaMaxToCompare),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"TrackletsSecVsZVertexVsEta","Number of tracklets vs ZVertex vs #eta;ZVertex;#eta",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
  }
  
  if ( fSPDMeanTracklets && fSPDOneOverAccxEff )
  {
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"dNchdetaComparison2Corrections","dN_{ch}/d#eta comparison with SPD AccxEff and data-driven corrections;dN_{ch}/d#eta;A*N^{corr}_{Tracklets}",151,multMin,150.5,151,multMin,150.5);
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"DispersiondNchdetaComparison2Corrections","dN_{ch}/d#eta dispersion with SPD AccxEff and data-driven corrections;(dN_{ch}/d#eta - A*N^{corr}_{Tracklets}) /dN_{ch}/d#eta;N_{events}",201,-1.005,1.005);
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"CheckMeanNtrCorrVsZVertex","Check for NtrCorr",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"CheckNtrCorr","Check for NtrCorr distribution;N^{corr}_{tr};N_{events}",nbinsMult,multMin,multMax);
  }
  
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"RelDispersiondNchdetaFromNtrCorrVsdNchdEtaMC",Form("Relative dispersion of dN_{ch}/d#eta from N_{tr}^{corr} vs MC dN_{ch}/d#eta in |#eta| < %1.1f;((dN_{ch}/d#eta)_{gen} - A*N^{corr}_{Tracklets}) /(dN_{ch}/d#eta)_{gen}",fEtaMax),201,-1.005,1.005);
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"DispersiondNchdetaFromNtrCorrVsdNchdEtaMC",Form("Dispersion of dN_{ch}/d#eta from N_{tr}^{corr} vs MC dN_{ch}/d#eta in |#eta| < %1.1f;(dN_{ch}/d#eta)_{gen} - A*N^{corr}_{Tracklets}",fEtaMax),402,-100.5,100.5);
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"dNchdetaFromNtrCorrVsdNchdEtaMC",Form("dN_{ch}/d#eta from N_{tr}^{corr} vs MC dN_{ch}/d#eta in |#eta| < %1.1f;(dN_{ch}/d#eta)_{gen};dN_{ch}/d#eta",fEtaMax),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
    
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"RelDispersiondNchdetaFromAccEffVsdNchdEtaMC",Form("Relative dispersion of dN_{ch}/d#eta from N_{tr}^{AccxEff} vs MC dN_{ch}/d#eta in |#eta| < %1.1f;((dN_{ch}/d#eta)_{gen} - dN_{ch}/d#eta) /(dN_{ch}/d#eta)_{gen};N_{events}",fEtaMax),201,-1.005,1.005);
     CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"DispersiondNchdetaFromAccEffVsdNchdEtaMC",Form("Dispersion of dN_{ch}/d#eta from N_{tr}^{AccxEff} vs MC dN_{ch}/d#eta in |#eta| < %1.1f;(dN_{ch}/d#eta)_{gen} - dN_{ch}/d#eta;N_{events}",fEtaMax),402,-100.5,100.5);
    CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"dNchdetaFromAccEffVsdNchdEtaMC",Form("dN_{ch}/d#eta from N_{tr}^{AccxEff} vs MC dN_{ch}/d#eta in |#eta| < %1.1f;(dN_{ch}/d#eta)_{gen};dN_{ch}/d#eta",fEtaMax),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  
  
//   CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"CorrTrackletsVsNch","Reco tracklets corrected vs number of generated charged particles;N_{ch};N_{tracklets}^{corr}",nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"CorrTrackletsVsNch",Form("%s vs number of generated charged particles in |#eta| < %1.1f;N_{ch};%s",TrackletsCorrectedName.Data(),fEtaMax,TrackletsCorrectedAxisName.Data()),nbinsMult,multMin,multMax,nbinsMult,multMin,multMax);
  
  // profile histograms
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"MeanTrackletsVsEta","Mean number of tracklets vs #eta;#eta;<N_{Tracklets}>",fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax(),0);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"MeandNchdEtaVsEta","Mean dN_{ch}/d#eta vs #eta;#eta;<dN_{ch}/d#eta>",fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax(),0);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"MeanTrackletsVsZVertex",Form("Mean number of tracklets in |#eta| < %1.1f vs Z vertex;Z vertex;<N_{Tracklets}>",fEtaMax),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);

  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"MeanNchVsEta","Mean number of generated charged particles vs #eta;#eta;<N_{ch}>",fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax(),0); // Each bin has to be divided by the binwidth to became dNch/dEta (Done in the terminate and stored in MeandNchdEta histo)
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"MeanNchVsEta",Form("Mean %s vs #eta;#eta;<%s>",TrackletsCorrectedName.Data(),TrackletsCorrectedAxisName.Data()),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax(),0); // Each bin has to be divided by the binwidth to became dNch/dEta (Done in the terminate and stored in MeandNchdEta histo)
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,"MeanNchVsZVertex",Form("Mean number of generated charged particles in |#eta| < %1.1f vs Z vertex;Z vertex;<N_{ch}>",fEtaMax),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"MeanNchVsZVertex",Form("Mean %s in |#eta| < %1.1f vs Z vertex;Z vertex;<%s>",TrackletsCorrectedName.Data(),fEtaMax,TrackletsCorrectedAxisName.Data()),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"MeandNchdEtaVsZVertex",Form("Mean d%s/d#eta in |#eta| < %1.1f vs Z vertex;Z vertex;<%s>",TrackletsCorrectedAxisName.Data(),fEtaMax,TrackletsCorrectedAxisName.Data()),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);
  
  
  TObjArray* bins = Binning()->CreateBinObjArray("psi","dnchdeta","");
  TIter nextBin(bins);
  AliAnalysisMuMuBinning::Range* r;
  
  while ( ( r = static_cast<AliAnalysisMuMuBinning::Range*>(nextBin()) ) )
  {
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,Form("EventsIn%s",r->AsString().Data()),Form("Number of %s events in %s bin",triggerClassName,r->AsString().Data()),1,0.,2);
  }

  delete bins;
  
  TObjArray* binsntr = Binning()->CreateBinObjArray("psi","ntrcorr","");
  TIter nextBinNtr(binsntr);
  AliAnalysisMuMuBinning::Range* rNtr;
  
  while ( ( rNtr = static_cast<AliAnalysisMuMuBinning::Range*>(nextBinNtr()) ) )
  {
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,Form("MeanNchVsZVertex%s",rNtr->AsString().Data()),Form("Mean %s in |#eta| < %1.1f vs Z vertex in bin %s;Z vertex;<%s>",TrackletsCorrectedName.Data(),fEtaMax,rNtr->AsString().Data(),TrackletsCorrectedAxisName.Data()),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);
    
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,Form("MeanTrackletsVsZVertex%s",rNtr->AsString().Data()),Form("Mean number of tracklets in |#eta| < %1.1f vs Z vertex in bin %s;Z vertex;<N_{Tracklets}>",fEtaMax,rNtr->AsString().Data()),fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),0);
  }
  
  delete binsntr;
  
  TObjArray* binsRel = Binning()->CreateBinObjArray("psi","relntrcorr","");
  TIter nextBinRel(binsRel);
  AliAnalysisMuMuBinning::Range* rRel;
  
  while ( ( rRel = static_cast<AliAnalysisMuMuBinning::Range*>(nextBinRel()) ) )
  {
    CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,Form("EventsIn%s",rRel->AsString().Data()),Form("Number of %s events in %s bin",triggerClassName,rRel->AsString().Data()),1,0.,2);
  }
  
  delete binsRel;
  
}

//_____________________________________________________________________________
void AliAnalysisMuMuNch::DefineSPDAcceptance()
{
  // Defines the functions ( eta = f(z) ) of the edges (right/left) of the inner and outer SPD layers
  // R_in = 3.9 cm ; R_out = 7.6 cm
  
  fSPD1LR = new TF1("fSPD1LR",SPDgeomR,-40,40,1);
  fSPD1LR->SetParameter(0,3.9);
  fSPD1LL = new TF1("fSPD1LL",SPDgeomL,-40,40,1);
  fSPD1LL->SetParameter(0,3.9);
  fSPD2LR = new TF1("fSPD2LR",SPDgeomR,-40,40,1);
  fSPD2LR->SetParameter(0,7.6);
  fSPD2LL = new TF1("fSPD2LL",SPDgeomL,-40,40,1);
  fSPD2LL->SetParameter(0,7.6);
  
}

//_____________________________________________________________________________
void AliAnalysisMuMuNch::DefineSPDCorrectionMap(TObjArray* spdCorrectionList)
{
  // Defines a TMap of the SPD periods and the corresponding correction
  // Each SPD correction in the list must contain in the name the 1st run for which is valid and respect the naming convention:
  // (SPDCorrection_1stValidRunNumber_lastValidRunNumber).
  // The list must be ordered from smaller to bigger run number
  // This is usable with both types of corrections
  
  if ( !fSPDCorrectionMap ) // Creates a TMap for the run->Correction correspondance
  {
    fSPDCorrectionMap = new TMap;
    fSPDCorrectionMap->SetOwnerKeyValue(kTRUE,kTRUE);
  }
  
  TIter next(spdCorrectionList);
  TH1* SPDCorrection(0x0);
  Int_t runRef(0);
  Int_t i(0); // SPDCorrection index in the list
  while ( (SPDCorrection = static_cast<TH1*>(next())) ) // Checks if the correction list format is ok and if it is ordered
  {
    if ( static_cast<TH1*>(SPDCorrection)->IsA() != TH2::Class() && static_cast<TH1*>(SPDCorrection)->IsA() != TProfile::Class() )
    {
      AliFatal("Unrecognized SPD correction Class");
    }
      
    TString name = SPDCorrection->GetName();
    if ( !name.BeginsWith("SPDCorrection_") ) AliFatal(Form("Incorrect SPD correction at %d format: Objects in list must named as 'SPDCorrection_1stValidRunNumber_lastValidRunNumber'",i));
    
    name.Remove(0,name.First("_") + 1);
    TString nameLast = name;
    name.Remove(name.First("_"),name.Length());
    nameLast.Remove(0,nameLast.First("_") + 1);
    if ( !name.IsDigit() ) AliFatal(Form("Incorrect SPD correction at %d format: Impossible to retrieve first valid run number",i));
    if ( !nameLast.IsDigit() ) AliFatal(Form("Incorrect SPD correction at %d format: Impossible to retrieve last valid run number",i));
    
    Int_t runLow = name.Atoi();
    Int_t runHigh = nameLast.Atoi();
    if ( runHigh < runLow ) AliFatal(Form("SPD correction at %d validity range not valid",i));
    if ( runLow <= runRef ) AliFatal("SPD correction list not in correct order. Should be ordered from smaller to bigger run number");
    else runRef = runHigh;
    
    for ( Int_t j = runLow ; j <= runHigh ; j++ )
    {
      fSPDCorrectionMap->Add(new TObjString(Form("%d",j)),new TObjString(Form("%d",i))); // The mapping is done between the runs and the index of the correction in the spdCorrection List
    }
    
    i++;
  }
  
  fSPDCorrectionList = static_cast<TObjArray*>(spdCorrectionList->Clone());
}

//_____________________________________________________________________________
void AliAnalysisMuMuNch::AddHisto(const char* eventSelection,
                                  const char* triggerClassName,
                                  const char* centrality,
                                  const char* histoname,
                                  Double_t z,
                                  TH1* h,Bool_t isMC)
{
  // Adds the content of a 1D histo to a 2D histo a the z position
  
  Int_t zbin = fZAxis->FindBin(z);
  TH2F* h2;
  if (isMC) h2 = static_cast<TH2F*>(MCHisto(eventSelection,triggerClassName,centrality,histoname));
  else h2 = static_cast<TH2F*>(Histo(eventSelection,triggerClassName,centrality,histoname));
  
  for ( Int_t i = 1; i <= h->GetXaxis()->GetNbins(); ++i )
  {
    Double_t content = h2->GetCellContent(zbin,i);
    
    if ( h->GetBinContent(i) >  0 )
    {
      h2->SetCellContent(zbin,i,content + h->GetBinContent(i));
    }
  }
  
  h2->SetEntries(h2->GetSumOfWeights());
}


//_____________________________________________________________________________
void AliAnalysisMuMuNch::AttachSPDAcceptance(UInt_t dataType,
                                             const char* eventSelection,
                                             const char* triggerClassName,
                                             const char* centrality,const char* histoname)
{
  // Attachs AccxEff curves to the histogram
  
  if ( dataType & kHistoForData )
  {
    if( !Histo(eventSelection,triggerClassName,centrality,histoname) )
    {
      AliError(Form("ERROR: SPD Acceptance curves attach failed. Histo /%s/%s/%s/%s not found",eventSelection,triggerClassName,centrality,histoname));
      return;
    }
    
    Histo(eventSelection,triggerClassName,centrality,histoname)->GetListOfFunctions()->Add(fSPD1LR->Clone());
    Histo(eventSelection,triggerClassName,centrality,histoname)->GetListOfFunctions()->Add(fSPD1LL->Clone());
    Histo(eventSelection,triggerClassName,centrality,histoname)->GetListOfFunctions()->Add(fSPD2LR->Clone());
    Histo(eventSelection,triggerClassName,centrality,histoname)->GetListOfFunctions()->Add(fSPD2LL->Clone());
  }
  if ( (dataType & kHistoForMCInput) && HasMC() )
  {
    if( !MCHisto(eventSelection,triggerClassName,centrality,histoname) )
    {
      AliError(Form("ERROR: SPD Acceptance curves attach failed. MC Histo /%s/%s/%s/%s not found",eventSelection,triggerClassName,centrality,histoname));
      return;
    }
    
    MCHisto(eventSelection,triggerClassName,centrality,histoname)->GetListOfFunctions()->Add(fSPD1LR->Clone());
    MCHisto(eventSelection,triggerClassName,centrality,histoname)->GetListOfFunctions()->Add(fSPD1LL->Clone());
    MCHisto(eventSelection,triggerClassName,centrality,histoname)->GetListOfFunctions()->Add(fSPD2LR->Clone());
    MCHisto(eventSelection,triggerClassName,centrality,histoname)->GetListOfFunctions()->Add(fSPD2LL->Clone());
    
  }
  
}


//_____________________________________________________________________________
void AliAnalysisMuMuNch::FillHistosForEvent(const char* eventSelection,
                                            const char* triggerClassName,
                                            const char* centrality)
{
  // Fills the data (or reco if simu) multiplicity histos
  
  if ( IsHistogrammingDisabled() ) return;
  
  if ( fResolution ) return; //When computing resolutions we skip this method

//  if ( !AliAnalysisMuonUtility::IsAODEvent(Event()) )
//  {
//    AliError("Don't know how to deal with ESDs...");
//    return;
//  }
  
//  if ( HasMC() && !fSPDOneOverAccxEff && !fSPDMeanTracklets ) // We have MC but no correction (SPD correction computation mode)so we skip the method
//  {
//    return;
//  }

//  AliAODEvent* aod = static_cast<AliAODEvent*>(Event());
//
//  AliVVertex* vertex = aod->GetPrimaryVertexSPD();
  
  AliVVertex* vertex = AliAnalysisMuonUtility::GetVertexSPD(Event());
  
  TList* nchList = static_cast<TList*>(Event()->FindListObject("NCH"));
  
  if (!nchList || nchList->IsEmpty() ) // Empty NCH means that there is no SPD vertex ( see SetEvent() ) when runing on data.
  {
    AliError("Empty Nch list in event");
    return;
  }
//  nchList->Print();
  Double_t SPDZv;
  
  if ( !vertex || vertex->GetZ() == 0.0 ) // Running in Simu the spdZ == 0 means no SPD info. In data, avoid breaks in events w/o SPD vertex
  {
    SPDZv = -40.;
  } 
  else SPDZv = vertex->GetZ();
  
  TH1* hSPDcorrectionVsEta = static_cast<TH1*>(nchList->FindObject("SPDcorrectionVsEta"));
  TH1* hNTrackletVsEta = static_cast<TH1*>(nchList->FindObject("NTrackletVsEta"));
  TH1* hNTrackletVsPhi = static_cast<TH1*>(nchList->FindObject("NTrackletVsPhi"));
  
  TH1* hNTrackletSecVsEta(0x0);
  if ( fSPDMeanTrackletsCorrToCompare ) // In case we have a secondary eta range we clone the tracklets vs eta histo
  {
    hNTrackletSecVsEta = static_cast<TH1*>(hNTrackletVsEta->Clone());
    hNTrackletSecVsEta->Reset();
  }
  
  TH1* hNchVsEta = static_cast<TH1*>(hNTrackletVsEta->Clone("NchVsEta"));
  
  TProfile* hMeanTrackletsVsEta = static_cast<TProfile*>(Histo(eventSelection,triggerClassName,centrality,"MeanTrackletsVsEta"));
  TProfile* hMeanNchVsEta = static_cast<TProfile*>(Histo(eventSelection,triggerClassName,centrality,"MeanNchVsEta"));
  TProfile* hMeandNchdEtaVsEta = static_cast<TProfile*>(Histo(eventSelection,triggerClassName,centrality,"MeandNchdEtaVsEta"));

  TH2* hEventsVsZVertexVsEta = static_cast<TH2*>(Histo(eventSelection,triggerClassName,centrality,"EventsVsZVertexVsEta"));
    
  Int_t nBins(0);
  
  Int_t nTracklets[2] = {0,0}; // {nTracklets_Eta_fetaRange,nTracklets_Eta_fetaRangeComp} The first component is the number of tracklets in the primary eta range and the second is  the number of tracklets in the secondary eta range
  Double_t nch[2] = {0.,0.}; // {nCorrTracklets_Eta_fetaRange,nCorrTracklets_Eta_fetaRangeComp} The first component is the corrected(with the primary correction) number of tracklets in the primary eta range and the second is  the number of corrected(with the secondary correction) tracklets in the secondary eta range
  
  Int_t etaBinMin[2] = {fEtaAxis->FindBin(fetaRange[0]),fEtaAxis->FindBin(fEtaMinToCompare)}; // Primary and secondary (if any) eta ranges 
  Int_t etaBinMax[2] = {fEtaAxis->FindBin(fetaRange[1]),fEtaAxis->FindBin(fEtaMaxToCompare)-1}; // Note that the binMax is the bin-1 because the upper extreme of a bin belongs to the next bin (i.e. the bin containing -0.5 has as center -0.45, the bin is [-0.5,-0.4) but the bin containing 0.5 has as center 1.05, the bin is [0.5,1.1) so we have to take the previous bin [0.4,0.5)) This is already taken into account in the GetEtaRangeSPD method
  
  for (Int_t j = etaBinMin[0] ; j <= etaBinMax[0] ; j++) // Loop over eta bins.
  {
    Double_t correction = hSPDcorrectionVsEta->GetBinContent(j);
    
    Double_t eta = fEtaAxis->GetBinCenter(j);
    
    if ( correction < 0 ) continue;
    else if ( correction == 0.0 ) // No tracklets found in this eta bin.
    {
      correction = GetSPDCorrection(SPDZv,eta); //FIXME: Here eta is the bincenter not the exact one, will be a problem if the SPD AccxEff binning is not the same as the fEtaAxis one

      if ( correction == 0. || correction > 2.5) continue; // We need to know if the eta bin is in a region we want to take into account to count or not the zero
    }
  
    Int_t ntr = hNTrackletVsEta->GetBinContent(j); // Tracklets in eta bin
    nTracklets[0] += ntr;
    if ( j >= etaBinMin[1] && j <= etaBinMax[1] )
    {
      nTracklets[1] += ntr; // number of tracklets in the secondary eta range
      hNTrackletSecVsEta->SetBinContent(j,ntr);
    }
    
    hMeanTrackletsVsEta->Fill(eta,ntr); // Fill the number of tracklets of each eta bin in the profile

    if ( fSPDOneOverAccxEff )
    {
      nch[0] += ntr * correction; // Number of charged particles (SPD AccxEff corrected tracklets)
      hMeanNchVsEta->Fill(eta,ntr*correction);
      hMeandNchdEtaVsEta->Fill(eta,ntr*correction/fEtaAxis->GetBinWidth(5));
      hNchVsEta->SetBinContent(j,hNchVsEta->GetBinContent(j) * correction ); // Fill the number of charged particles of each eta bin in the profile
    }

    ++nBins; // We sum up the number of bins entering in the computation

    hEventsVsZVertexVsEta->Fill(SPDZv,eta,1.0); // Fill 1 count each eta bin where the events contributes
  }
  
  AddHisto(eventSelection,triggerClassName,centrality,"TrackletsVsZVertexVsPhi",SPDZv,hNTrackletVsPhi);
  AddHisto(eventSelection,triggerClassName,centrality,"TrackletsVsZVertexVsEta",SPDZv,hNTrackletVsEta);

  AddHisto(eventSelection,triggerClassName,centrality,"NchVsZVertexVsEta",SPDZv,hNchVsEta);
  
  Histo(eventSelection,triggerClassName,centrality,"Tracklets")->Fill(nTracklets[0]);
  Histo(eventSelection,triggerClassName,centrality,"MeanTrackletsVsZVertex")->Fill(SPDZv,nTracklets[0]);
  
    
  if ( fSPDMeanTracklets && !fSPDOneOverAccxEff ) // Just correct by SPDMeanTracklets method if there is no SPD AccxEff correction
  {
    Double_t SPDr = GetTrackletsMeanCorrection(SPDZv,nTracklets[0]); // Get 'mean correction' for the zvtx
    
    if ( SPDr < -999.) nch[0] = -1;
    else nch[0] = nTracklets[0] + SPDr; // In case of 'mean correction' nch has not be filled in the eta bins loop
    
    if ( fSPDMeanTrackletsCorrToCompare ) // Comparison of corrected tracklets in the primary and secondary eta ranges
    {
      AddHisto(eventSelection,triggerClassName,centrality,"TrackletsSecVsZVertexVsEta",SPDZv,hNTrackletSecVsEta);
      
      Double_t SPDrEtaComp = GetTrackletsMeanCorrection(SPDZv,nTracklets[1],kTRUE); // Get secondary 'mean correction' for the zvtx
      
      if ( SPDrEtaComp < -999.) nch[1] = -1;
      else nch[1] = nTracklets[1] + SPDrEtaComp; // In case of 'mean correction' nch has not be filled in the eta bins loop
      
      Histo(eventSelection,triggerClassName,centrality,"CorrTrackletsEtaSecVsCorrTrackletsEtaPrim")->Fill(nch[0],nch[1]);
      Histo(eventSelection,triggerClassName,centrality,"MeanNchEtaSecVsZVertex")->Fill(SPDZv,nch[1]); // Control plot to check if the secondary correction is applied correctly
      Histo(eventSelection,triggerClassName,centrality,"MeanTrackletsEtaSecVsZVertex")->Fill(SPDZv,nTracklets[1]);
    }
    
  }
  else if ( fSPDMeanTracklets && fSPDOneOverAccxEff ) // Here we compare the Corrected tracklets with the two correction methods
  {
    Int_t i(-1);
    Bool_t parFound1(kFALSE),parFound2(kFALSE);
    Double_t NtrCorr(0.),dNchdeta(0.);
    while ( i < nchList->GetEntries() - 1 && !(parFound1 && parFound2) )
    {
      i++;
      while ( nchList->At(i)->IsA() != TParameter<Double_t>::Class() && i < nchList->GetEntries() - 1 ) // In case there is a diferent object, just to skip it
      {
        i++;
      }
      
      TParameter<Double_t>* p = static_cast<TParameter<Double_t>*>(nchList->At(i));
      
      if ( TString(p->GetName()).Contains("NtrCorr") )
      {
        parFound1 = kTRUE;
        NtrCorr = p->GetVal();
      }
      else if ( TString(p->GetName()).Contains("MeandNchdEta") )
      {
        parFound2 = kTRUE;
        dNchdeta = p->GetVal();
      }
    }
    
    if ( parFound1 && parFound2 )
    {
//      Double_t dNchdetaPubli = 17.35; //FIXME: hardcoded (pPb value)
      Double_t ctToNch = 1.11; //FIXME: hardcoded (value for Nch vs NtrCorr(eta<0.5) in pPb)
      
      Histo(eventSelection,triggerClassName,centrality,"dNchdetaComparison2Corrections")->Fill(dNchdeta,ctToNch*NtrCorr/(2*fEtaMax));
      Histo(eventSelection,triggerClassName,centrality,"CheckMeanNtrCorrVsZVertex")->Fill(SPDZv,NtrCorr);
      if ( dNchdeta !=0 )
      {
        Histo(eventSelection,triggerClassName,centrality,"DispersiondNchdetaComparison2Corrections")->Fill((dNchdeta - ctToNch*NtrCorr/(2*fEtaMax)) / dNchdeta);
      }
      
      Histo(eventSelection,triggerClassName,centrality,"CheckNtrCorr")->Fill(NtrCorr);
      
    }
  }
  
  
  Histo(eventSelection,triggerClassName,centrality,"TrackletsVsNch")->Fill(nch[0],nTracklets[0]);
  Histo(eventSelection,triggerClassName,centrality,"Nch")->Fill(nch[0]);
  Histo(eventSelection,triggerClassName,centrality,"MeanNchVsZVertex")->Fill(SPDZv,nch[0]);
  
  
  Double_t V0AMult = 0.;
  Double_t V0CMult = 0.;
  
//  AliVVZERO* vzero = aod->GetVZEROData();
  AliVVZERO* vzero = Event()->GetVZEROData();
  if (vzero)
  {
    Double_t multV0A = vzero->GetMTotV0A();
    V0AMult = AliESDUtils::GetCorrV0A(multV0A,SPDZv);
    Double_t multV0C = vzero->GetMTotV0C();
    V0CMult = AliESDUtils::GetCorrV0C(multV0C,SPDZv);
    
    Histo(eventSelection,triggerClassName,centrality,"V0AMultVsNch")->Fill(V0AMult,nch[0]);
    Histo(eventSelection,triggerClassName,centrality,"V0CMultVsNch")->Fill(V0CMult,nch[0]);

  }

  
  delete hNchVsEta;
  
  // Mean dNch/dEta computation. In case the correction is the 'mean' one, this is not really dNch/deta, we have to multiply it by a factor <Nch>/<Ntrkls_corr> (we get <Nch> from a MC)
  Double_t meandNchdEta(0.);
  
  if ( nBins >  0 )
  {
    if ( fSPDOneOverAccxEff ) meandNchdEta = nch[0] / (nBins*fEtaAxis->GetBinWidth(5)); // Divide by nBins to get the mean and by the binWidht to get the d/dEta
    else if ( fSPDMeanTracklets ) meandNchdEta = nch[0] / (2.*fEtaMax); //fEtaAxis->GetBinWidth(5);
  }
  
  Histo(eventSelection,triggerClassName,centrality,"dNchdEta")->Fill(meandNchdEta);
  Histo(eventSelection,triggerClassName,centrality,"MeandNchdEtaVsZVertex")->Fill(SPDZv,meandNchdEta);
  
  
  //_____________These were tests //FIXME: Check if this tests are still neccesary_____________
  TObjArray* bins = Binning()->CreateBinObjArray("psi","dnchdeta","");
  TIter nextBin(bins);
  AliAnalysisMuMuBinning::Range* r;
  
  while ( ( r = static_cast<AliAnalysisMuMuBinning::Range*>(nextBin()) ) )
  {
    Bool_t ok(kFALSE);
    if ( r->Quantity() == "DNCHDETA" )
    {
      ok = r->IsInRange(meandNchdEta);
    }
    
    if ( ok )
    {
      Histo(eventSelection,triggerClassName,centrality,Form("EventsIn%s",r->AsString().Data()))->Fill(1.);
    }
  }
  
  delete bins;
  
  
  TObjArray* binsNtrRaw = Binning()->CreateBinObjArray("psi","ntrraw","");
  TIter nextBinNtrRaw(binsNtrRaw);
  AliAnalysisMuMuBinning::Range* rNtrRaw;
  
  while ( ( rNtrRaw = static_cast<AliAnalysisMuMuBinning::Range*>(nextBinNtrRaw()) ) )
  {
    Bool_t ok(kFALSE);
    if ( rNtrRaw->Quantity() == "NTRRAW" )
    {
      ok = rNtrRaw->IsInRange(nTracklets[0]);
    }
    
    if ( ok )
    {
      Histo(eventSelection,triggerClassName,centrality,Form("MeanTrackletsVsZVertex%s",rNtrRaw->AsString().Data()))->Fill(SPDZv,nTracklets[0]);
    }
  }

  delete binsNtrRaw;
  
  
  TObjArray* binsNtr = Binning()->CreateBinObjArray("psi","ntrcorr","");
  TIter nextBinNtr(binsNtr);
  AliAnalysisMuMuBinning::Range* rNtr;

  while ( ( rNtr = static_cast<AliAnalysisMuMuBinning::Range*>(nextBinNtr()) ) )
  {
    Bool_t ok(kFALSE);
    if ( rNtr->Quantity() == "NTRCORR" )
    {
      ok = rNtr->IsInRange(nch[0]);
    }
    
    if ( ok )
    {
      Histo(eventSelection,triggerClassName,centrality,Form("MeanNchVsZVertex%s",rNtr->AsString().Data()))->Fill(SPDZv,nch[0]);
    }
  }
  
  delete binsNtr;
  
  
  TObjArray* binsRel = Binning()->CreateBinObjArray("psi","relntrcorr","");
  TIter nextBinRel(binsRel);
  AliAnalysisMuMuBinning::Range* rRel;
  while ( ( rRel = static_cast<AliAnalysisMuMuBinning::Range*>(nextBinRel()) ) )
  {
    Bool_t ok(kFALSE);
    if ( rRel->Quantity() == "RELNTRCORR" )
    {
      ok = rRel->IsInRange(nch[0]/fMeanTrRef);
    }
    
    if ( ok )
    {
      Histo(eventSelection,triggerClassName,centrality,Form("EventsIn%s",rRel->AsString().Data()))->Fill(1.);
    }
  }
  
  delete binsRel;
  //_________________________________________________________________________________________
  
}

//_____________________________________________________________________________
void AliAnalysisMuMuNch::FillHistosForMCEvent(const char* eventSelection,const char* triggerClassName,const char* centrality)
{
  /// Fill input MC multiplicity histos
  
  if ( IsHistogrammingDisabled() ) return;
  
  TList* nchList = static_cast<TList*>(Event()->FindListObject("NCH"));
  
  if (!nchList || nchList->IsEmpty())
  {
    AliError("Empty Nch list in event");
    return;
  }
  
  Double_t MCZv = AliAnalysisMuonUtility::GetMCVertexZ(Event(),MCEvent()); // Definition of MC generated z vertex
//  AliVVertex* vertex = static_cast<AliAODEvent*>(Event())->GetPrimaryVertexSPD();
  AliVVertex* vertex = AliAnalysisMuonUtility::GetVertexSPD(Event());
  
  Double_t SPDZv(0.);
  TParameter<Double_t>* p(0x0);
  
  //____Resolution Histos___
  if ( !fSPDOneOverAccxEff && !fSPDMeanTracklets && fResolution )
  {
    Int_t nContributors(0);
    if ( vertex )
    {
      nContributors  = vertex->GetNContributors();
      SPDZv = vertex->GetZ();
    }
    MCHisto(eventSelection,triggerClassName,centrality,"SPDZvResVsnC")->Fill(nContributors,SPDZv - MCZv);
    MCHisto(eventSelection,triggerClassName,centrality,"SPDZvResVsMCz")->Fill(MCZv,SPDZv - MCZv);
    
    Double_t EtaReco(0.),EtaMC(0.),PhiReco(0.),PhiMC(0.);
    Int_t i(-1),labelEtaReco(-1),labelEtaMC(-1),labelPhiReco(-1),labelPhiMC(-1);
    
    while ( i < nchList->GetEntries() - 1 )
    {
      i++;
      while ( nchList->At(i)->IsA() != TParameter<Double_t>::Class() ) // In case there is a diferent object, just to skip it
      {
        i++;
      }
      
      p = static_cast<TParameter<Double_t>*>(nchList->At(i));

      
         //Eta Resolution
      if ( TString(p->GetName()).Contains("EtaReco") ) // We take the reco eta
      {
        sscanf(p->GetName(),"EtaReco%d",&labelEtaReco);
        EtaReco = p->GetVal();
        MCHisto(eventSelection,triggerClassName,centrality,"Eta")->Fill(EtaReco);
      }
      else if ( TString(p->GetName()).Contains("EtaMC") ) // We take the generated eta
      {
        sscanf(p->GetName(),"EtaMC%d",&labelEtaMC);
        EtaMC = p->GetVal();
        MCHisto(eventSelection,triggerClassName,centrality,"MCEta")->Fill(EtaMC);
      }
      if ( labelEtaReco > 0 && labelEtaReco == labelEtaMC ) // To be sure we compute the difference for the same particle
      {
        labelEtaReco = -1; // Restart of the label value to avoid double count the eta difference when computing the phi one 
        Double_t EtaDif = EtaReco - EtaMC;
        MCHisto(eventSelection,triggerClassName,centrality,"EtaRes")->Fill(EtaDif);
        MCHisto(eventSelection,triggerClassName,centrality,"EtaResVsZ")->Fill(MCZv,EtaDif);
        MCHisto(eventSelection,triggerClassName,centrality,"EtaResVsnC")->Fill(nContributors,EtaDif);
      }
      
         //Phi Resolution
      else if ( TString(p->GetName()).Contains("PhiReco") ) // We take the reco phi
      {
        sscanf(p->GetName(),"PhiReco%d",&labelPhiReco);
        PhiReco = p->GetVal();
        MCHisto(eventSelection,triggerClassName,centrality,"Phi")->Fill(PhiReco);
      }
      else if ( TString(p->GetName()).Contains("PhiMC") ) // We take the generated phi
      {
        sscanf(p->GetName(),"PhiMC%d",&labelPhiMC);
        PhiMC = p->GetVal();
        MCHisto(eventSelection,triggerClassName,centrality,"MCPhi")->Fill(PhiMC);
      }
      
      if ( labelPhiReco > 0 && labelPhiReco == labelPhiMC ) // To be sure we compute the difference for the same particle
      {
        labelPhiReco = -1; // Restart of the label value to avoid double count the phi difference when computing the eta one
        Double_t PhiDif = PhiReco - PhiMC;
        MCHisto(eventSelection,triggerClassName,centrality,"PhiRes")->Fill(PhiDif);
        
        //___With the following algorithm we refer the differences to the interval [-Pi/2,Pi/2]
        if ( PhiDif < -TMath::PiOver2() && PhiDif > -TMath::Pi() )
        {
          PhiDif = -TMath::Pi() - PhiDif;
        }
        else if ( PhiDif < -TMath::Pi() )
        {
          PhiDif = -2.*TMath::Pi() - PhiDif;
          if ( PhiDif < -TMath::PiOver2() )
          {
            PhiDif = -TMath::Pi() - PhiDif;
          }
        }
        
        else if ( PhiDif > TMath::PiOver2() && PhiDif < TMath::Pi() )
        {
          PhiDif = TMath::Pi() - PhiDif;
        }  
        else if ( PhiDif > TMath::Pi() )
        {
          PhiDif = 2.*TMath::Pi() - PhiDif;
          if ( PhiDif > TMath::PiOver2() )
          {
            PhiDif = TMath::Pi() - PhiDif;
          }
        }
        //___
        
        MCHisto(eventSelection,triggerClassName,centrality,"PhiResVsZ")->Fill(MCZv,PhiDif);
        MCHisto(eventSelection,triggerClassName,centrality,"PhiResShifted")->Fill(PhiDif);
        MCHisto(eventSelection,triggerClassName,centrality,"PhiResVsnC")->Fill(nContributors,PhiDif);
      }
    }
    
    return; // When computing resolutions we skip the rest of the method
  }
  //_____
  
  //___Multiplicity histos (just when not computing resolutions)___
  TH1* hSPDcorrectionVsEta = static_cast<TH1*>(nchList->FindObject("MCSPDcorrectionVsEta"));
  TH1* hNBkgTrackletsVSEta = static_cast<TH1*>(nchList->FindObject("NBkgTrackletsVSEta"));
  TH1* hNchVsPhi = static_cast<TH1*>(nchList->FindObject("MCNchVsPhi"));
  TH1* hNchVsEta = static_cast<TH1*>(nchList->FindObject("MCNchVsEta"));
  TH1* hNTrackletVsEta = static_cast<TH1*>(nchList->FindObject("MCNTrackletVsEta"));
  TH1* hNTrackletVsPhi = static_cast<TH1*>(nchList->FindObject("MCNTrackletVsPhi"));
  
  TProfile* hMeanNchVsEta = static_cast<TProfile*>(MCHisto(eventSelection,triggerClassName,centrality,"MeanNchVsEta"));
  
  TH2* hEventsVsZVertexVsEta = static_cast<TH2*>(MCHisto(eventSelection,triggerClassName,centrality,"EventsVsZVertexVsEta"));

  Int_t nBins(0);
  
  Double_t nchSum(0.),nTracklets(0.);
  for (Int_t j = 1 ; j <= fEtaAxis->GetNbins() ; j++) //Loop over all eta bins 
  {
    Double_t correction = hSPDcorrectionVsEta->GetBinContent(j);
    
    if ( correction < 0 ) continue; // We count just the particles in the SPD acceptance. (MCSPDcorrectionVsEta is filled to -1 in SetEvent() for those bins out of range)
    
    nTracklets += hNTrackletVsEta->GetBinContent(j); // Reco tracklets
    
    ++nBins; // We sum up the number of bins entering in the computation
    
    Double_t eta = fEtaAxis->GetBinCenter(j);
    Double_t nch = hNchVsEta->GetBinContent(j); // Generated particles
    
    nchSum += nch;
    
    hMeanNchVsEta->Fill(eta,nch); // Fill the number of charged particles of each eta bin in the profile
    
    hEventsVsZVertexVsEta->Fill(MCZv,eta,1.0); // Fill 1 count each eta bin where the events contributes
  }
  
  MCHisto(eventSelection,triggerClassName,centrality,"Tracklets")->Fill(nTracklets); // Note that these are NOT the same tracklets as in the FillHistosForEvent() since here the SPD "dead" zones (the ones where correction > threshold) are not rejected
  
  if ( vertex )
  {
    SPDZv = vertex->GetZ();
  }

  Bool_t isMChisto = kTRUE; // Used to get the MC histos in the Add method
  
  AddHisto(eventSelection,triggerClassName,centrality,"NBkgTrackletsVsZVertexVsEta",SPDZv,hNBkgTrackletsVSEta,isMChisto);
  AddHisto(eventSelection,triggerClassName,centrality,"NchVsZVertexVsPhi",MCZv,hNchVsPhi,isMChisto);
  AddHisto(eventSelection,triggerClassName,centrality,"NchVsZVertexVsEta",MCZv,hNchVsEta,isMChisto);
  AddHisto(eventSelection,triggerClassName,centrality,"NchVsRecoZVertexVsEta",SPDZv,hNchVsEta,isMChisto);
  AddHisto(eventSelection,triggerClassName,centrality,"TrackletsVsZVertexVsEta",SPDZv,hNTrackletVsEta,isMChisto);
  AddHisto(eventSelection,triggerClassName,centrality,"TrackletsVsZVertexVsPhi",SPDZv,hNTrackletVsPhi,isMChisto);
  
  MCHisto(eventSelection,triggerClassName,centrality,"MeanNchVsZVertex")->Fill(MCZv,nchSum);
  MCHisto(eventSelection,triggerClassName,centrality,"Nch")->Fill(nchSum);
  
  
  // Mean dNch/dEta computation
  Double_t meandNchdEta(0.);
  if ( nBins >  0 )
  {
    meandNchdEta = nchSum / (nBins*fEtaAxis->GetBinWidth(5)); // Divide by nBins to get the mean and by the binWidht to get the d/dEta
  }
  
  MCHisto(eventSelection,triggerClassName,centrality,"dNchdEta")->Fill(meandNchdEta);
  
  
  Int_t i(-1);
  p = 0x0;
  Double_t nTrCorr(0.);
  Double_t dNchdetaReco(0.);
  Double_t ctToNch = 1.11; //FIXME: hardcoded (value for Nch vs NtrCorr(eta<0.5) in pPb)
  while ( i < nchList->GetEntries() - 1 )
  {
    i++;
    while ( nchList->At(i)->IsA() != TParameter<Double_t>::Class() && i < nchList->GetEntries() - 1 ) // In case there is a diferent object, just to skip it
    {
      i++;
    }
    
    p = static_cast<TParameter<Double_t>*>(nchList->At(i));
    
    if ( ( TString(p->GetName()).Contains("NtrCorr") || TString(p->GetName()).BeginsWith("Nch") ) && ( (fSPDMeanTracklets && !fSPDOneOverAccxEff) || (!fSPDMeanTracklets && fSPDOneOverAccxEff) ))
    {
      MCHisto(eventSelection,triggerClassName,centrality,"CorrTrackletsVsNch")->Fill(nchSum,p->GetVal());
    }
    else if ( TString(p->GetName()).Contains("NtrCorr") )
    {
      nTrCorr = p->GetVal();
      MCHisto(eventSelection,triggerClassName,centrality,"dNchdetaFromNtrCorrVsdNchdEtaMC")->Fill(meandNchdEta,ctToNch*nTrCorr/(2*fEtaMax));
      MCHisto(eventSelection,triggerClassName,centrality,"RelDispersiondNchdetaFromNtrCorrVsdNchdEtaMC")->Fill((meandNchdEta - ctToNch*nTrCorr/(2*fEtaMax)) / meandNchdEta);
      MCHisto(eventSelection,triggerClassName,centrality,"DispersiondNchdetaFromNtrCorrVsdNchdEtaMC")->Fill((meandNchdEta - ctToNch*nTrCorr/(2*fEtaMax)));
    }
    else if ( TString(p->GetName()).Contains("Ntr") && !TString(p->GetName()).Contains("SPDOk") && !TString(p->GetName()).Contains("Corr"))
    {
      MCHisto(eventSelection,triggerClassName,centrality,"TrackletsVsNch")->Fill(nchSum,p->GetVal());
    }
    else if ( TString(p->GetName()).Contains("MeandNchdEta") )
    {
      dNchdetaReco = p->GetVal();
      MCHisto(eventSelection,triggerClassName,centrality,"dNchdetaVsMCdNchdeta")->Fill(meandNchdEta,dNchdetaReco);
      MCHisto(eventSelection,triggerClassName,centrality,"dNchdetaFromAccEffVsdNchdEtaMC")->Fill(meandNchdEta,dNchdetaReco);
      MCHisto(eventSelection,triggerClassName,centrality,"RelDispersiondNchdetaFromAccEffVsdNchdEtaMC")->Fill((meandNchdEta - dNchdetaReco) / meandNchdEta);
      MCHisto(eventSelection,triggerClassName,centrality,"DispersiondNchdetaFromAccEffVsdNchdEtaMC")->Fill((meandNchdEta - dNchdetaReco));
    }
  }
  
  Double_t V0AMult = 0.;
  Double_t V0CMult = 0.;
  
  AliVVZERO* vzero = Event()->GetVZEROData();
  if (vzero)
  {
    Double_t multV0A = vzero->GetMTotV0A();
    V0AMult = AliESDUtils::GetCorrV0A(multV0A,MCZv);
    Double_t multV0C = vzero->GetMTotV0C();
    V0CMult = AliESDUtils::GetCorrV0C(multV0C,MCZv);
    
    MCHisto(eventSelection,triggerClassName,centrality,"V0AMultVsNch")->Fill(V0AMult,nchSum);
    MCHisto(eventSelection,triggerClassName,centrality,"V0CMultVsNch")->Fill(V0CMult,nchSum);
    
  }
  //____
}


//_____________________________________________________________________________
Bool_t AliAnalysisMuMuNch::GetEtaRangeSPD(Double_t spdZVertex, Double_t etaRange[])
{
  // Fill the SPD eta range for a given z vertex and returns whether the range is valid or not.
  
  if ( fSPDMeanTracklets || (!fSPDMeanTracklets && !fSPDOneOverAccxEff) )
  {
    // If we are using the mean correction or we want the raw distributions we should not apply the algorithm to restric the eta range, in order to avoid the effect of the eta-Zv bins on the distributions ( the algorithm makes that when an eta bin is partially out of the SPD acceptance we remove it. This makes that the mean raw tracklets distribution is not smooth for Zv in which the eta range is partially out of the SPD )
    
    //FIXME: Implement something to warning or reject events for which the selected eta range is completely out of the SPD acceptance
    etaRange[0] = fEtaMin;
    etaRange[1] = fEtaMax - 1E-6;
    
    return kTRUE;
  }
  
  Double_t etaMax(fEtaMax),etaMin(fEtaMin);
  
  Double_t vf1LR = fSPD1LR->Eval(spdZVertex); //Eta values for the z vertex over the SPD acceptance curves
  Double_t vf2LR = fSPD2LR->Eval(spdZVertex);
  Double_t vf1LL = fSPD1LL->Eval(spdZVertex);
  Double_t vf2LL = fSPD2LL->Eval(spdZVertex);
  
  //____We start by asigning the eta range as the eta values in the SPD acceptance curve
  if ( spdZVertex < 0. )
  {
    etaMax = vf2LR;
    etaMin = TMath::Max(vf1LL,vf2LL);
  }
  else
  {
    etaMax = TMath::Min(vf1LR,vf2LR);
    etaMin = vf2LL;
  }
  //____
  
  
  //____Algorithm to avoid taking bins which are crossed by the SPD acceptance curves
  Int_t binYMin = fEtaAxis->FindBin(etaMin); // Find the corresponding bins for eta max & min and z vertex
  Int_t binYMax = fEtaAxis->FindBin(etaMax);
  Int_t binX = fZAxis->FindBin(spdZVertex);
  
  // Define the values for the relevant edges of the eta and z bins
  Double_t upEdge = fEtaAxis->GetBinUpEdge(binYMax);  // up edge of the top eta bin
  Double_t lowEdge = fEtaAxis->GetBinLowEdge(binYMin); // low edge of the bottom eta bin
  Double_t leftEdge = fZAxis->GetBinLowEdge(binX); // left edge of the z bin
  Double_t rightEdge = fZAxis->GetBinUpEdge(binX); // right edge of the z bin
  
  Double_t etaMaxTemp(0.),etaMinTemp(0.);
  if ( spdZVertex < 0. )
  {
    etaMaxTemp = fSPD2LR->Eval(rightEdge); // Define the temporary eta max as the value of the curve int the righ edge of the bin
    etaMinTemp = TMath::Max(fSPD1LL->Eval(leftEdge),fSPD2LL->Eval(leftEdge));
  }
  else
  {
    etaMaxTemp = TMath::Min(fSPD1LR->Eval(rightEdge),fSPD2LR->Eval(rightEdge));
    etaMinTemp = fSPD2LL->Eval(leftEdge);
  }
  
  while ( upEdge > etaMaxTemp ) //We take eta max as the up edge of the 1st bin which is inside the SPD acceptance but not crossed by the curve
  {
    binYMax = binYMax - 1; // Since the up edge of the current bin is bigger than the SPD acc curve we move 1 bin below
    upEdge = fEtaAxis->GetBinUpEdge(binYMax); // Take the up edge of the new bin
    etaMax = upEdge - 1E-6; // We substract 1E-6 cause the up edge of the a bin belongs to the bin+1
    
  }
  
  //We take eta min as the low edge of the 1st bin which is inside the SPD acceptance but not crossed by the curve
  while ( lowEdge < etaMinTemp )
  {
    binYMin = binYMin + 1; // Since the low edge of the current bin is smaller than the SPD acc curve we move 1 bin above
    lowEdge = fEtaAxis->GetBinLowEdge(binYMin); // Take the low edge of the new bin
    etaMin = lowEdge + 1E-6;
  }
  //____
  
  // In case the eta range we want (given in the constructor) is smaller than the one found by the algorithm (max range) we redefine the values
  if ( etaMin < fEtaMin ) etaMin = fEtaMin + 1E-6;
  if ( etaMax > fEtaMax ) etaMax = fEtaMax - 1E-6;
  
  if ( etaMin > etaMax ) // If this happens, the event is not able to cover the desired eta range, so we set an invalid range
  {
    etaRange[0] = 999.;
    etaRange[1] = -999.;
    
    return kFALSE; //FIXME: Shall we add something to invalidate this event in SetEvent to dont count it in AliAnalysisTaskMuMu::FillCounters?
  }
  else
  {
    etaRange[0] = etaMin;
    etaRange[1] = etaMax;
    
    return kTRUE;
  }
}

//_____________________________________________________________________________
Double_t AliAnalysisMuMuNch::GetSPDCorrection(Double_t zvert, Double_t eta) const
{
  if ( !fSPDOneOverAccxEff )
  {
    return 1.; // Like this we will simply compute the raw tracklets or if we are correctiong by the mean tracklets the eta bin will be counted as valid
  }
  else
  {
    Int_t bin =fSPDOneOverAccxEff->FindBin(zvert,eta);
    return fSPDOneOverAccxEff->GetBinContent(bin);// Like this we will compute Nch from the SPD AccxEFf
  }
}

//_____________________________________________________________________________
Double_t AliAnalysisMuMuNch::GetTrackletsMeanCorrection(Double_t zvert, Int_t nTracklets, Bool_t corrToCompare) const
{
  if ( !fSPDMeanTracklets )
  {
    AliFatal("ERROR: No tracklets mean correction");
    return 0;
  }
  else
  {
    TProfile* h(0x0);
    if ( corrToCompare && fSPDMeanTrackletsCorrToCompare ) h = static_cast<TProfile*>(fSPDMeanTrackletsCorrToCompare);
    else h = static_cast<TProfile*>(fSPDMeanTracklets);

    Int_t bin = h->FindBin(zvert);
    Double_t mNTtklsZ = h->GetBinContent(bin);
    
    Double_t mNTtklsZref(0.);
    if ( fSPDMeanTrackletsCorrToCompare )
    {
      if ( corrToCompare ) mNTtklsZref = h->GetMaximum();
      else
      {
        if ( fMeanTrRef > 0. ) mNTtklsZref = fMeanTrRef;
        else mNTtklsZref = h->GetMaximum();
      }
    }
    else
    {
      if ( fMeanTrRef > 0. ) mNTtklsZref = fMeanTrRef;
      else mNTtklsZref = h->GetMaximum();
    }

    Double_t deltaN;
    if ( mNTtklsZ == 0. ) deltaN = -1000.; // If the zvertex is out of the correction range the correction is < -999 (non valid)
    else
    {
      Double_t coef(1.);
      if ( mNTtklsZref < mNTtklsZ ) coef = -1.;
      
      Double_t meanPoiss = nTracklets*(mNTtklsZref - mNTtklsZ)/mNTtklsZ;
      deltaN = coef*frand->PoissonD(TMath::Abs(meanPoiss));
    }
    return deltaN;
  }
}


//_____________________________________________________________________________
AliAODTracklets* AliAnalysisMuMuNch::GetTracklets(AliVEvent* event)
{
  /// Return AliAODTracklets if the event is an AOD event. If event is ESD event creates AliAODTracklets object from ESD AliMultiplicity and returns it
  
  AliAODTracklets* tracklets(0x0);
  
  if ( event->IsA() == AliAODEvent::Class() )
  {
    tracklets = static_cast<const AliAODEvent*>(Event())->GetTracklets(); // Tracklets object
  }
  else if ( event->IsA() == AliESDEvent::Class() )
  {
    const AliMultiplicity* mult = static_cast<const AliESDEvent*>(Event())->GetMultiplicity();
    
    if (mult)
    {
      tracklets = new AliAODTracklets();
      
      if ( mult->GetNumberOfTracklets() > 0 )
      {
        tracklets->CreateContainer(mult->GetNumberOfTracklets());
        for (Int_t n = 0 ; n < mult->GetNumberOfTracklets() ; n++)
        {
          tracklets->SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n, 0),mult->GetLabel(n, 1));
        }
      }
    }
  }
  else AliFatal("Unrecognized Event Type");
  
  return tracklets;

}

//==============================These methods are useless here, anyway they should go in the EventCutterClass=================
//_____________________________________________________________________________
Bool_t AliAnalysisMuMuNch::HasAtLeastNTrackletsInEtaRange(const AliVEvent& event, Int_t n, Double_t& etaMin, Double_t& etaMax) const
{
  if ( event.IsA() != AliAODEvent::Class() )
  {
    return kFALSE;
  }
  
  AliAODTracklets* tracklets = static_cast<const AliAODEvent&>(event).GetTracklets();
  
  if (!tracklets)
  {
    return kFALSE;
  }
  
  Int_t nTrackletsInRange(0);
  
  Int_t nTracklets = tracklets->GetNumberOfTracklets();
  
  for (Int_t i = 0 ; i < nTracklets && nTrackletsInRange < n; i++)
  {
    Double_t eta = -TMath::Log(TMath::Tan(tracklets->GetTheta(i)/2.0));
    
    if ( eta > etaMin && eta < etaMax )
    {
      ++nTrackletsInRange;
    }
  }
  
  return (nTrackletsInRange>=n);
}

//_____________________________________________________________________________
void AliAnalysisMuMuNch::NameOfHasAtLeastNTrackletsInEtaRange(TString& name, Int_t n, Double_t& etaMin, Double_t& etaMax) const
{
  if ( TMath::AreEqualAbs(TMath::Abs(etaMin),TMath::Abs(etaMax),1E-9 ) )
  {
    name.Form("ATLEAST%dTRKLINABSETALT%3.1f",n,TMath::Abs(etaMin));
  }
  else
  {
    name.Form("ATLEAST%dTRKLINETA%3.1f-%3.1f",n,etaMin,etaMax);
  }
}
//=======================================================================================

//_____________________________________________________________________________
Bool_t AliAnalysisMuMuNch::IsMCtrackFromGenerator(Int_t indexMC) const
{
  ///Checks if the MC particle corresponding to a track has been generated with a given generator.
  
  if ( !HasMC() )
  {
    AliWarning("There is no MC information in the event");
    return kFALSE;
  }
  
  if ( indexMC >= MCEvent()->GetNumberOfTracks() )
  {
    AliWarning("This MC track does not exist. Index out of range");
//    return kFALSE;
  }

//______________"MANUAL" METHOD___________//
  //It does not work since NProduced gives just the stable dpmjet produced particles. See AliMCEvent::GetGenerator
//  Int_t labelTemp(labelMC);
//  while ( labelTemp != -1 )
//  {
//    AODpartMCTemp = static_cast<AliAODMCParticle*>(MCEvent()->GetTrack(labelMC));
//    labelTemp = AODpartMCTemp->GetMother();
//    if ( labelTemp != -1 ) labelMC = labelTemp;
//    std::cout << labelTemp << " ===>" << labelMC <<std::endl;
//  }
//  
//  AliAODMCHeader* mcHeader = static_cast<AliAODMCHeader*>(Event()->FindListObject(AliAODMCHeader::StdBranchName()));
//  if(mcHeader)
//  {
//    TList* lheaders = mcHeader->GetCocktailHeaders();
//    lheaders->Print();
//
//    AliGenEventHeader* mcGenH(0x0);
//    TIter next(lheaders); // Get the iterator on the list of cocktail headers
//    Int_t nProduced(0);
//    while ( labelMC >= nProduced ) // Loop over the cocktail headers
//    {
//      mcGenH = static_cast<AliGenEventHeader*>(next());
//      if ( !mcGenH )
//      {
//        std::cout << "Generator header not found" << std::endl;
//        return kFALSE;
//      }
//      else nProduced += mcGenH->NProduced();
//    }
//  }
//  TString genName(mcGenH->GetName());
//  return genName.Contains("dpmjet_0");
 //_________________________________________
  
  TString genName;
  if ( !MCEvent()->GetCocktailGenerator(indexMC,genName) )
  {
    AliWarning("No cocktail generator found for this event");
    return kFALSE;
  }
//  std::cout << genName.Data() << std::endl;
  return genName.Contains(fGeneratorHeaderClass->Data());
}

//==============================This method is not used=====================
//_____________________________________________________________________________
Double_t AliAnalysisMuMuNch::NumberOfTrackletsInEtaRange(const AliVEvent& event, Double_t& etaMin, Double_t& etaMax, Bool_t /*corrected*/) const
{
  if ( event.IsA() != AliAODEvent::Class() )
  {
    AliError("Not working for ESDs...");
    return 0;
  }
  
  AliAODTracklets* tracklets = static_cast<const AliAODEvent&>(event).GetTracklets();
  
  if (!tracklets)
  {
    return 0;
  }
  
  Double_t nTrackletsInRange(0);

  Int_t nTracklets = tracklets->GetNumberOfTracklets();
  
  for (Int_t i = 0 ; i < nTracklets ; i++)
  {
    Double_t thetaTracklet = tracklets->GetTheta(i);
    Double_t etaTracklet = -TMath::Log(TMath::Tan(thetaTracklet/2.));
    
    if ( etaTracklet > etaMin && etaTracklet < etaMax )
    {
      nTrackletsInRange += 1.0;
    }
  }
  
  return nTrackletsInRange;
}
//==============================


//_____________________________________________________________________________
void AliAnalysisMuMuNch::SetEvent(AliVEvent* event, AliMCEvent* mcEvent)
{
  /// Set the event, compute multiplicities and add them as a list to the event
  
//  if ( event->IsA() != AliAODEvent::Class() )
//  {
//    AliError("Only working for AODs for the moment.");
//    return;
//  }
  
  AliAnalysisMuMuBase::SetEvent(event,mcEvent); // To have Event() and MCEvent() method working
  
  TList* nchList = static_cast<TList*>(event->FindListObject("NCH")); // Define the list with the NCH info for each event
  if (!nchList)
  {
    nchList = new TList;
    nchList->SetOwner(kTRUE);
    nchList->SetName("NCH");
    event->AddObject(nchList);
  }
  
  nchList->Clear(); // We clear the NCH list for this new event
  
  Double_t SPDZv(0.);
  Bool_t vertexSPDFound(kFALSE);
//  AliAODTracklets* tracklets(0x0);
  
  AliVVertex* vertexSPD = AliAnalysisMuonUtility::GetVertexSPD(event);
  if ( vertexSPD )
  {
    vertexSPDFound = kTRUE;
    SPDZv = vertexSPD->GetZ();
    if ( SPDZv == 0. ) SPDZv = -40.; // If SPDZv = 0. means that there is no reconstructed vertex. Setting the vertex to -40 allow us to get an invalid correction
  }
  
  AliAODTracklets* tracklets = GetTracklets(event);

//  if ( event->IsA() == AliAODEvent::Class() )
//  {
//    const AliAODVertex* vertexSPD = static_cast<const AliAODEvent*>(Event())->GetPrimaryVertexSPD(); // SPD vertex object
//    if ( vertexSPD )
//    {
//      vertexSPDFound = kTRUE;
//      SPDZv = vertexSPD->GetZ();
//      if ( SPDZv == 0. ) SPDZv = -40.; // If SPDZv = 0. means that there is no reconstructed vertex. Setting the vertex to -40 allow us to get an invalid correction
//    }
////    else return;
//    
//    tracklets = static_cast<const AliAODEvent*>(Event())->GetTracklets(); // Tracklets object
//  }
//
//  else if ( event->IsA() == AliESDEvent::Class() )
//  {
//    const AliESDVertex* vertexSPD = static_cast<const AliESDEvent*>(Event())->GetPrimaryVertexSPD(); // SPD vertex object
//    if ( vertexSPD )
//    {
//      vertexSPDFound = kTRUE;
//      SPDZv = vertexSPD->GetZ();
//    }
////    else return;
//    
//    tracklets = new AliAODTracklets();
//    const AliMultiplicity* mult = static_cast<const AliESDEvent*>(Event())->GetMultiplicity();
//    
//    if (mult)
//    {
//      if (mult->GetNumberOfTracklets()>0)
//      {
//        tracklets->CreateContainer(mult->GetNumberOfTracklets());
//        for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++)
//        {
////          if(fMChandler)
////          {
////            fMChandler->SelectParticle(mult->GetLabel(n, 0));
////            fMChandler->SelectParticle(mult->GetLabel(n, 1));
////          }
//          tracklets->SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n, 0),mult->GetLabel(n, 1));
//        }
//      }
//    }
//  }
//  else AliFatal("Unrecognized Event Type");
  
  TH1* hSPDcorrectionVsEta(0x0); // Pointers for the individual event histos
  TH1* hNchVsEta(0x0);
  TH1* hNTrackletVsEta(0x0);
  TH1* hNTrackletVsPhi(0x0);
  
  // Variables we will use in the multiplicity computation
  Int_t binMin,binMax;
  Int_t nTracklets(0);
  Double_t thetaTracklet(0.),phiTracklet(0.),etaTracklet(0.);
  Double_t nch(0.0);
  Int_t nTrackletsInRange(0);
  Int_t nTrackletsInRangeSPDOk(0);
  Int_t nBins(0);

  
  Bool_t isEtaRangeValid = GetEtaRangeSPD(SPDZv,fetaRange);
  
  //____Data (or reco) multiplicity computation ___
  if ( !fResolution ) // When computing resolutions we dont do anything else
  {
    //_______Create once the histos with the individual event "properties" (cleared at the beginning of each new event)_______
    if ( !Histo("AliAnalysisMuMuNch","SPDcorrectionVsEta") )
    {
      CreateEventHistos(kHistoForData | kHistoForMCInput,"AliAnalysisMuMuNch","SPDcorrectionVsEta","SPD correction-like vs #eta;#eta",fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
      
      CreateEventHistos(kHistoForMCInput,"AliAnalysisMuMuNch","NchVsEta","Nch vs #eta;#eta",fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());

      CreateEventHistos(kHistoForData | kHistoForMCInput,"AliAnalysisMuMuNch","NTrackletVsEta","Ntracklet vs #eta;#eta",fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
      
      CreateEventHistos(kHistoForData,"AliAnalysisMuMuNch","NBkgTrackletsVSEta","NBkg Tracklets vs #eta;#eta",fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
      
      Double_t phimin = 0.; //Phi range
      Double_t phimax = 2*TMath::Pi();
      Int_t nphibins = GetNbins(phimin,phimax,0.05);
      
      CreateEventHistos(kHistoForData | kHistoForMCInput,"AliAnalysisMuMuNch","NTrackletVsPhi","Ntracklet vs #phi;#phi",nphibins,phimin,phimax);
      
      CreateEventHistos(kHistoForMCInput,"AliAnalysisMuMuNch","NchVsPhi","Nch vs #phi;#phi",nphibins,phimin,phimax);
      
      CreateEventHistos(kHistoForData | kHistoForMCInput,"AliAnalysisMuMuNch","test","test",fZAxis->GetNbins(),fZAxis->GetXmin(),fZAxis->GetXmax(),fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());
      
      Histo("AliAnalysisMuMuNch","test")->GetListOfFunctions()->Add(fSPD1LR->Clone());
      Histo("AliAnalysisMuMuNch","test")->GetListOfFunctions()->Add(fSPD1LL->Clone());
      Histo("AliAnalysisMuMuNch","test")->GetListOfFunctions()->Add(fSPD2LR->Clone());
      Histo("AliAnalysisMuMuNch","test")->GetListOfFunctions()->Add(fSPD2LL->Clone());
    }
    //_________
        
    hSPDcorrectionVsEta = Histo("AliAnalysisMuMuNch","SPDcorrectionVsEta"); // Set the individual event histos
    hNTrackletVsEta = Histo("AliAnalysisMuMuNch","NTrackletVsEta");
    hNTrackletVsPhi = Histo("AliAnalysisMuMuNch","NTrackletVsPhi");
        
    hSPDcorrectionVsEta->Reset(); // Reset of the individual event histos
    hNTrackletVsEta->Reset();
    hNTrackletVsPhi->Reset();

    //____Data (or Reco if simu) tracklets computation___
    if ( tracklets && vertexSPDFound && isEtaRangeValid )
    {
      
      Histo("AliAnalysisMuMuNch","test")->Fill(SPDZv,fetaRange[1]);
      Histo("AliAnalysisMuMuNch","test")->Fill(SPDZv,fetaRange[0]);
      
      nTracklets = tracklets->GetNumberOfTracklets();
      
      Double_t SPDr; // SPD efficiency (If we use the 'mean correction' or no correction it will be always 1)
      for (Int_t i = 0 ; i < nTracklets ; i++)
      {
        thetaTracklet = tracklets->GetTheta(i);
        etaTracklet = -TMath::Log(TMath::Tan(thetaTracklet/2.));
        if ( etaTracklet < fetaRange[0] || etaTracklet > fetaRange[1] ) continue; // Avoid tracklets out of the eta SPD acceptance or out of the eta cut
        
        SPDr = GetSPDCorrection(SPDZv,etaTracklet); // Get SPD AccxEff for the corresponding [zvtx,eta] bin (If we use the 'mean correction' or no correction it will be always 1)
        
        Int_t bin = fEtaAxis->FindBin(etaTracklet);
        
        nTrackletsInRange++;
        if ( SPDr!=0. && SPDr <= 2.5) // Threshold to reduce border effects
        {
          hSPDcorrectionVsEta->SetBinContent(bin,SPDr);
          hNTrackletVsEta->Fill(etaTracklet);
          hNTrackletVsPhi->Fill(tracklets->GetPhi(i));
          
          nTrackletsInRangeSPDOk++;
        }
        else // If the correction is above the threshold we store a -1 in the correction to skip this eta bin int the fill method (can just happen using SPD AccxEff correction)
        {
          hSPDcorrectionVsEta->SetBinContent(bin,-1.0);
        }
      }
      
      nchList->Add(new TParameter<Double_t>("Ntr",nTrackletsInRange));
      nchList->Add(new TParameter<Double_t>("NtrSPDOk",nTrackletsInRangeSPDOk)); // if there is not SPD AccxEff correction this will be equal to Ntr
      
      //___ Fill the out-of-eta-range bins with -1.0
      
      binMin = fEtaAxis->FindBin(fetaRange[0]);
      binMax = fEtaAxis->FindBin(fetaRange[1]);
      
      for ( Int_t i = 1; i < binMin; ++i )
      {
        hSPDcorrectionVsEta->SetBinContent(i,-1.0);
      }
      for ( Int_t i = binMax + 1 ; i <= fEtaAxis->GetNbins(); ++i )
      {
        hSPDcorrectionVsEta->SetBinContent(i,-1.0);
      }

      if ( fSPDOneOverAccxEff || fSPDMeanTracklets ) // Here we correct the raw tracklets
      {
        if ( fSPDOneOverAccxEff ) // In this case the correction is the SPD accxEff
        {
          
          //----- Mean dNchdEta computation to set it into the event
          for (Int_t j = binMin/*1*/ ; j <= binMax/*fEtaAxis->GetNbins()*/ ; j++) // Loop over eta bins
          {
            Double_t correction = hSPDcorrectionVsEta->GetBinContent(j);
            
            Double_t eta = fEtaAxis->GetBinCenter(j);
            
            if ( correction < 0 ) continue; // If the correction is < 0 we skip that eta bin
            else if ( correction == 0.0 ) // If the correction is 0 we have no tracklets in that eta bin
            {
              Double_t spdCorr = GetSPDCorrection(SPDZv,eta);
              if ( spdCorr == 0. || spdCorr > 2.5) continue; // If the correction in the eta bin is not within the threshold we do not count the "0"(that eta bin will not count for nBins)
            }
            
            nch += hNTrackletVsEta->GetBinContent(j) * correction; // Number of charged particles (tracklets*(1/SPDAccxEff))
            
            ++nBins; // We sum up the number of bins entering in the computation
          }
          
          nchList->Add(new TParameter<Double_t>("Nch",nch));
          
          Double_t meandNchdEta(0.);// We compute the mean dNch/dEta in the event
          if ( nBins >  0 )
          {
            meandNchdEta = nch / (nBins*fEtaAxis->GetBinWidth(5));
          }
          
          nchList->Add(new TParameter<Double_t>("MeandNchdEta",meandNchdEta)); // We add the mean dNch/dEta to the event. It will serve us as a multiplicity estimator.
        }
//        else if( fSPDMeanTracklets ) // In this case the correction is the 'mean correction'
        if( fSPDMeanTracklets ) // In this case the correction is the 'mean correction'
        {
          SPDr = GetTrackletsMeanCorrection(SPDZv,nTrackletsInRange); // Get 'mean correction' for the zvtx
          
          if ( SPDr < -999.) nch = -1;
          else nch = nTrackletsInRange + SPDr;
          
          nchList->Add(new TParameter<Double_t>("NtrCorr",nch));// We add the corrected number of tracklets to the event. It will serve us as a multiplicity estimator.
        }
//        else AliFatal("Unknown tracklets correction class");
      }
      
    }
    else // If there is no tracklets or vertex object or the eta range is not valid everything is invalidated
    {
      for ( Int_t i = 1 ; i <= hSPDcorrectionVsEta->GetNbinsX() ; ++i )
      {
        hSPDcorrectionVsEta->SetBinContent(i,-1.0);
      }
      
      nchList->Add(new TParameter<Double_t>("Ntr",-1)); //We set an invalid Ntracklets
      
      if ( fSPDOneOverAccxEff ) // In this case the correction is the SPD accxEff
      {
        nchList->Add(new TParameter<Double_t>("MeandNchdEta",-1)); //We set an invalid dNch/deta
      }
      else if( fSPDMeanTracklets ) // In this case the correction is the 'mean correction'
      {
        nchList->Add(new TParameter<Double_t>("NtrCorr",-1)); //We set an invalid Ntracklets corrected
      }       
    }
    //_______

    //____ We add the tracklets histos to the event
    nchList->Add(hSPDcorrectionVsEta->Clone());
    nchList->Add(hNTrackletVsEta->Clone());
    nchList->Add(hNTrackletVsPhi->Clone());
    //_______
  }
  //_______
  
  //____Input MC multiplicity computation ___
  if ( HasMC() )
  {
    Double_t etaRange[2];
    if ( !fResolution ) //When computing resolutions we dont do anything else
    {
      Double_t MCZv = AliAnalysisMuonUtility::GetMCVertexZ(Event(),MCEvent());
      GetEtaRangeSPD(MCZv,etaRange);
      
      hNchVsEta = MCHisto("AliAnalysisMuMuNch","NchVsEta");
      hSPDcorrectionVsEta = MCHisto("AliAnalysisMuMuNch","SPDcorrectionVsEta");
      TH1* hNchVsPhi = MCHisto("AliAnalysisMuMuNch","NchVsPhi");
      hNTrackletVsEta = MCHisto("AliAnalysisMuMuNch","NTrackletVsEta");
      hNTrackletVsPhi = MCHisto("AliAnalysisMuMuNch","NTrackletVsPhi");
      
      hNTrackletVsEta->Reset();
      hNchVsEta->Reset();
      hNchVsPhi->Reset();
      hSPDcorrectionVsEta->Reset();
      hNTrackletVsPhi->Reset();
      
      //___ Fill the out-of-eta-range bins with -1.0
      binMin = fEtaAxis->FindBin(etaRange[0]);
      binMax = fEtaAxis->FindBin(etaRange[1]);
      
      for ( Int_t i = 1; i < binMin; ++i )
      {
        hSPDcorrectionVsEta->SetBinContent(i,-1.0);
      }
      for ( Int_t i = binMax + 1 ; i <= fEtaAxis->GetNbins(); ++i )
      {
        hSPDcorrectionVsEta->SetBinContent(i,-1.0);
      }
      for ( Int_t i = binMin; i <= binMax; ++i ) // Fill the bins inside the eta range with +1
      {
        hSPDcorrectionVsEta->SetBinContent(i,1.0); // FIXME: Do we really want all the tracklets to be counted for MC purposes? or we want to count only those in active regions of the SPD as for Data computations?
      }
      //___
      
      Int_t nMCTracks = MCEvent()->GetNumberOfTracks(); // number of MC tracks
      
      for ( Int_t i = 0; i < nMCTracks ; ++i ) //Loop over generated tracks
      {
//        AliAODMCParticle* AODpart = static_cast<AliAODMCParticle*>(mcEvent->GetTrack(i));
        AliMCParticle* MCpart = static_cast<AliMCParticle*>(mcEvent->GetTrack(i));
        
        Bool_t isPP(kFALSE);
        Int_t nGentorDex(-2); //Generator Index: -1 as default;
        //                  0 is for DPMJET;
        //                  1, 2 ... are for other generators
        
        if ( static_cast<const AliVEvent*>(event)->IsA() == AliAODEvent::Class() )
        {
          AliAODMCParticle* AODpart = static_cast<AliAODMCParticle*>(mcEvent->GetTrack(i));
          isPP = AODpart->IsPhysicalPrimary();
          nGentorDex = AODpart->GetGeneratorIndex();
        }
        else if ( static_cast<const AliVEvent*>(event)->IsA() == AliESDEvent::Class() )
        {
          isPP = MCEvent()->IsPhysicalPrimary(i);
          nGentorDex = MCpart->GetGeneratorIndex();
        }
        
        
//        if ( AODpart->IsPhysicalPrimary() ) // We take only particles produced in the collision (Particles produced in the collision including products of strong and electromagnetic decay and excluding feed-down from weak decays of strange particles)
        if ( isPP && nGentorDex==0 )
        {
//          if ( !IsMCtrackFromGenerator(i) ) continue; // Select only the particles generated by the desired generator
          
          if ( MCpart->Charge()!=0 ) // We take only charged particles
          {
            hNchVsEta->Fill(MCpart->Eta());
            hNchVsPhi->Fill(MCpart->Phi());
            
          }
        }
      }
      
      nchList->Add(hNchVsEta->Clone("MCNchVsEta"));
      nchList->Add(hNchVsPhi->Clone("MCNchVsPhi"));
      nchList->Add(hSPDcorrectionVsEta->Clone("MCSPDcorrectionVsEta"));
    }
              //__Bkg tracklets and Resolution estimation __
    if ( tracklets ) // We can compute the Bkg tracklets and resolution only if we have the tracklets object in the event
    {
      TH1* hNBkgTrackletsVSEta(0x0); // Pointer for the Bkg histo
      if ( !fResolution )
      {
        hNBkgTrackletsVSEta = Histo("AliAnalysisMuMuNch","NBkgTrackletsVSEta");
        
        hNBkgTrackletsVSEta->Reset();
      }
      
      nTracklets = tracklets->GetNumberOfTracklets();
      
      for (Int_t i = 0 ; i < nTracklets ; i++) // Loop over tracklets to check if they come or not from the same MC particle
      {
        Int_t label1 = tracklets->GetLabel(i,0);
        Int_t label2 = tracklets->GetLabel(i,1);

//        if ( !IsMCtrackFromGenerator(label1) || !IsMCtrackFromGenerator(label2) ) continue; // Select only the particles generated by the desired generator
        
        thetaTracklet = tracklets->GetTheta(i);
        etaTracklet = -TMath::Log(TMath::Tan(thetaTracklet/2.));
        phiTracklet = tracklets->GetPhi(i);
        
        if ( !fResolution )
        {
          hNTrackletVsEta->Fill(etaTracklet);
          hNTrackletVsPhi->Fill(phiTracklet);
        }
        
        if ( label1 != label2 && !fResolution ) hNBkgTrackletsVSEta->Fill(etaTracklet); // Tracklets not comming from the same MC particle are Bkg
        else if ( !fSPDOneOverAccxEff && !fSPDMeanTracklets && fResolution ) // Compute the resolutions with the tracklets comming from the same MC particle
        {
//          AliAODMCParticle* AODpartMC = static_cast<AliAODMCParticle*>(MCEvent()->GetTrack(label1));
          AliMCParticle* partMC = static_cast<AliMCParticle*>(MCEvent()->GetTrack(label1));
          Double_t etaTrackletMC = partMC->Eta();
          Double_t phiTrackletMC = partMC->Phi();
          
          // Resolution variables
          nchList->Add(new TParameter<Double_t>(Form("EtaReco%d",label1),etaTracklet));
          nchList->Add(new TParameter<Double_t>(Form("EtaMC%d",label1),etaTrackletMC));
          
          nchList->Add(new TParameter<Double_t>(Form("PhiReco%d",label1),phiTracklet));
          nchList->Add(new TParameter<Double_t>(Form("PhiMC%d",label1),phiTrackletMC));
                 
        }
      }
      
      if (!fResolution )
      {
        nchList->Add(hNTrackletVsEta->Clone("MCNTrackletVsEta"));
        nchList->Add(hNTrackletVsPhi->Clone("MCNTrackletVsPhi"));
        nchList->Add(hNBkgTrackletsVSEta->Clone());
      }
      
    }
    
  }
  //_______
  
}

//_____________________________________________________________________________
void AliAnalysisMuMuNch::SetRun(const AliInputEventHandler* eventHandler)
{
  // For each new run this method sets the corresponding SPD correction from SPDCorrection list using the SPDCorrection map

  if ( !fSPDCorrectionList ) return;
  
//  AliAODEvent* event = static_cast<AliAODEvent*>(eventHandler->GetEvent());
   AliVEvent* event = static_cast<AliVEvent*>(eventHandler->GetEvent());

  TString run(Form("%d",event->GetRunNumber())); // Get the run number
  TObjString*  SPDCorrectionKey = static_cast<TObjString*>(fSPDCorrectionMap->GetValue(run)); // Get the corresponding SPDCorrection map key for the run
  
  Int_t SPDCorrectionIndex(0);
  if ( SPDCorrectionKey ) SPDCorrectionIndex = SPDCorrectionKey->String().Atoi(); // Converts the key into Int, if found
  else AliFatal(Form("No SPD correction found for run %d",run.Atoi()));
  
  TH1* hSPDCorrection = static_cast<TH1*>(fSPDCorrectionList->At(SPDCorrectionIndex)); // Gets the SPD correction at key position from the list
  
  if ( static_cast<TH1*>(hSPDCorrection)->IsA() == TH2::Class() ) fSPDOneOverAccxEff = static_cast<TH2F*>(hSPDCorrection); // Sets the corresponding correction data member
  else if ( static_cast<TH1*>(hSPDCorrection)->IsA() == TProfile::Class() ) fSPDMeanTracklets = static_cast<TProfile*>(hSPDCorrection);
  else AliFatal("Unrecognized correction class");
  
  AliInfo(Form("Using correction %s for run %s",hSPDCorrection->GetName(),run.Data()));
  
}

//_____________________________________________________________________________
void AliAnalysisMuMuNch::Terminate(Option_t *)
{
  /// Called once at the end of the query
  if ( !HistogramCollection() ) return;

  if ( HistogramCollection()->FindObject(Form("/%s/AliAnalysisMuMuNch/NTrackletVsEta",MCInputPrefix())) )
  {
    HistogramCollection()->Remove(Form("/%s/AliAnalysisMuMuNch/NTrackletVsEta",MCInputPrefix()));
    HistogramCollection()->Remove(Form("/%s/AliAnalysisMuMuNch/NTrackletVsPhi",MCInputPrefix()));
    HistogramCollection()->Remove(Form("/%s/AliAnalysisMuMuNch/NchVsEta",MCInputPrefix()));
    HistogramCollection()->Remove(Form("/%s/AliAnalysisMuMuNch/NchVsPhi",MCInputPrefix()));
    HistogramCollection()->Remove(Form("/%s/AliAnalysisMuMuNch/SPDcorrectionVsEta",MCInputPrefix()));
    HistogramCollection()->Remove("/AliAnalysisMuMuNch/NBkgTrackletsVSEta");
  }
  
  if ( HistogramCollection()->FindObject("/AliAnalysisMuMuNch/NTrackletVsEta") )
  {
    HistogramCollection()->Remove("/AliAnalysisMuMuNch/NTrackletVsEta");
    HistogramCollection()->Remove("/AliAnalysisMuMuNch/test");
    HistogramCollection()->Remove("/AliAnalysisMuMuNch/NTrackletVsPhi");
    HistogramCollection()->Remove("/AliAnalysisMuMuNch/SPDcorrectionVsEta");
  }
  //____ Compute dNchdEta histo
  TObjArray* idArr =  HistogramCollection()->SortAllIdentifiers();

  TIter next(idArr);
  TObjString* id;
  
  while ( (id = static_cast<TObjString*>(next())) )
  {
    TProfile* p = static_cast<TProfile*>(HistogramCollection()->FindObject(Form("%s%s",id->GetName(),"MeanNchVsEta")));

    if ( !p ) continue;
    
    TH1* h = new TH1F("MeandNchdEta","Event averaged dN_{ch}/d#eta ;#eta;<dN_{ch}/d#eta>",fEtaAxis->GetNbins(),fEtaAxis->GetXmin(),fEtaAxis->GetXmax());

    if ( p->GetNbinsX() != h->GetNbinsX() || p->GetXaxis()->GetXmin() != h->GetXaxis()->GetXmin() || p->GetXaxis()->GetXmax() != h->GetXaxis()->GetXmax() )
    {
      AliError("ERROR: Cannot compute MeandNchdEta since the binning doesn't match with MeanNchVsEta histo");
      continue;
    }
    
    for ( Int_t i = 1 ; i < h->GetNbinsX() ; i++ )
    {
      h->SetBinContent(i,p->GetBinContent(i)/p->GetBinWidth(i));
      h->SetBinError(i,p->GetBinError(i)/p->GetBinWidth(i));
      h->SetEntries(p->GetEntries());
    }
  
    HistogramCollection()->Adopt(Form("%s",id->GetName()),h);
  }
    
  delete idArr;
  //___
}
 AliAnalysisMuMuNch.cxx:1
 AliAnalysisMuMuNch.cxx:2
 AliAnalysisMuMuNch.cxx:3
 AliAnalysisMuMuNch.cxx:4
 AliAnalysisMuMuNch.cxx:5
 AliAnalysisMuMuNch.cxx:6
 AliAnalysisMuMuNch.cxx:7
 AliAnalysisMuMuNch.cxx:8
 AliAnalysisMuMuNch.cxx:9
 AliAnalysisMuMuNch.cxx:10
 AliAnalysisMuMuNch.cxx:11
 AliAnalysisMuMuNch.cxx:12
 AliAnalysisMuMuNch.cxx:13
 AliAnalysisMuMuNch.cxx:14
 AliAnalysisMuMuNch.cxx:15
 AliAnalysisMuMuNch.cxx:16
 AliAnalysisMuMuNch.cxx:17
 AliAnalysisMuMuNch.cxx:18
 AliAnalysisMuMuNch.cxx:19
 AliAnalysisMuMuNch.cxx:20
 AliAnalysisMuMuNch.cxx:21
 AliAnalysisMuMuNch.cxx:22
 AliAnalysisMuMuNch.cxx:23
 AliAnalysisMuMuNch.cxx:24
 AliAnalysisMuMuNch.cxx:25
 AliAnalysisMuMuNch.cxx:26
 AliAnalysisMuMuNch.cxx:27
 AliAnalysisMuMuNch.cxx:28
 AliAnalysisMuMuNch.cxx:29
 AliAnalysisMuMuNch.cxx:30
 AliAnalysisMuMuNch.cxx:31
 AliAnalysisMuMuNch.cxx:32
 AliAnalysisMuMuNch.cxx:33
 AliAnalysisMuMuNch.cxx:34
 AliAnalysisMuMuNch.cxx:35
 AliAnalysisMuMuNch.cxx:36
 AliAnalysisMuMuNch.cxx:37
 AliAnalysisMuMuNch.cxx:38
 AliAnalysisMuMuNch.cxx:39
 AliAnalysisMuMuNch.cxx:40
 AliAnalysisMuMuNch.cxx:41
 AliAnalysisMuMuNch.cxx:42
 AliAnalysisMuMuNch.cxx:43
 AliAnalysisMuMuNch.cxx:44
 AliAnalysisMuMuNch.cxx:45
 AliAnalysisMuMuNch.cxx:46
 AliAnalysisMuMuNch.cxx:47
 AliAnalysisMuMuNch.cxx:48
 AliAnalysisMuMuNch.cxx:49
 AliAnalysisMuMuNch.cxx:50
 AliAnalysisMuMuNch.cxx:51
 AliAnalysisMuMuNch.cxx:52
 AliAnalysisMuMuNch.cxx:53
 AliAnalysisMuMuNch.cxx:54
 AliAnalysisMuMuNch.cxx:55
 AliAnalysisMuMuNch.cxx:56
 AliAnalysisMuMuNch.cxx:57
 AliAnalysisMuMuNch.cxx:58
 AliAnalysisMuMuNch.cxx:59
 AliAnalysisMuMuNch.cxx:60
 AliAnalysisMuMuNch.cxx:61
 AliAnalysisMuMuNch.cxx:62
 AliAnalysisMuMuNch.cxx:63
 AliAnalysisMuMuNch.cxx:64
 AliAnalysisMuMuNch.cxx:65
 AliAnalysisMuMuNch.cxx:66
 AliAnalysisMuMuNch.cxx:67
 AliAnalysisMuMuNch.cxx:68
 AliAnalysisMuMuNch.cxx:69
 AliAnalysisMuMuNch.cxx:70
 AliAnalysisMuMuNch.cxx:71
 AliAnalysisMuMuNch.cxx:72
 AliAnalysisMuMuNch.cxx:73
 AliAnalysisMuMuNch.cxx:74
 AliAnalysisMuMuNch.cxx:75
 AliAnalysisMuMuNch.cxx:76
 AliAnalysisMuMuNch.cxx:77
 AliAnalysisMuMuNch.cxx:78
 AliAnalysisMuMuNch.cxx:79
 AliAnalysisMuMuNch.cxx:80
 AliAnalysisMuMuNch.cxx:81
 AliAnalysisMuMuNch.cxx:82
 AliAnalysisMuMuNch.cxx:83
 AliAnalysisMuMuNch.cxx:84
 AliAnalysisMuMuNch.cxx:85
 AliAnalysisMuMuNch.cxx:86
 AliAnalysisMuMuNch.cxx:87
 AliAnalysisMuMuNch.cxx:88
 AliAnalysisMuMuNch.cxx:89
 AliAnalysisMuMuNch.cxx:90
 AliAnalysisMuMuNch.cxx:91
 AliAnalysisMuMuNch.cxx:92
 AliAnalysisMuMuNch.cxx:93
 AliAnalysisMuMuNch.cxx:94
 AliAnalysisMuMuNch.cxx:95
 AliAnalysisMuMuNch.cxx:96
 AliAnalysisMuMuNch.cxx:97
 AliAnalysisMuMuNch.cxx:98
 AliAnalysisMuMuNch.cxx:99
 AliAnalysisMuMuNch.cxx:100
 AliAnalysisMuMuNch.cxx:101
 AliAnalysisMuMuNch.cxx:102
 AliAnalysisMuMuNch.cxx:103
 AliAnalysisMuMuNch.cxx:104
 AliAnalysisMuMuNch.cxx:105
 AliAnalysisMuMuNch.cxx:106
 AliAnalysisMuMuNch.cxx:107
 AliAnalysisMuMuNch.cxx:108
 AliAnalysisMuMuNch.cxx:109
 AliAnalysisMuMuNch.cxx:110
 AliAnalysisMuMuNch.cxx:111
 AliAnalysisMuMuNch.cxx:112
 AliAnalysisMuMuNch.cxx:113
 AliAnalysisMuMuNch.cxx:114
 AliAnalysisMuMuNch.cxx:115
 AliAnalysisMuMuNch.cxx:116
 AliAnalysisMuMuNch.cxx:117
 AliAnalysisMuMuNch.cxx:118
 AliAnalysisMuMuNch.cxx:119
 AliAnalysisMuMuNch.cxx:120
 AliAnalysisMuMuNch.cxx:121
 AliAnalysisMuMuNch.cxx:122
 AliAnalysisMuMuNch.cxx:123
 AliAnalysisMuMuNch.cxx:124
 AliAnalysisMuMuNch.cxx:125
 AliAnalysisMuMuNch.cxx:126
 AliAnalysisMuMuNch.cxx:127
 AliAnalysisMuMuNch.cxx:128
 AliAnalysisMuMuNch.cxx:129
 AliAnalysisMuMuNch.cxx:130
 AliAnalysisMuMuNch.cxx:131
 AliAnalysisMuMuNch.cxx:132
 AliAnalysisMuMuNch.cxx:133
 AliAnalysisMuMuNch.cxx:134
 AliAnalysisMuMuNch.cxx:135
 AliAnalysisMuMuNch.cxx:136
 AliAnalysisMuMuNch.cxx:137
 AliAnalysisMuMuNch.cxx:138
 AliAnalysisMuMuNch.cxx:139
 AliAnalysisMuMuNch.cxx:140
 AliAnalysisMuMuNch.cxx:141
 AliAnalysisMuMuNch.cxx:142
 AliAnalysisMuMuNch.cxx:143
 AliAnalysisMuMuNch.cxx:144
 AliAnalysisMuMuNch.cxx:145
 AliAnalysisMuMuNch.cxx:146
 AliAnalysisMuMuNch.cxx:147
 AliAnalysisMuMuNch.cxx:148
 AliAnalysisMuMuNch.cxx:149
 AliAnalysisMuMuNch.cxx:150
 AliAnalysisMuMuNch.cxx:151
 AliAnalysisMuMuNch.cxx:152
 AliAnalysisMuMuNch.cxx:153
 AliAnalysisMuMuNch.cxx:154
 AliAnalysisMuMuNch.cxx:155
 AliAnalysisMuMuNch.cxx:156
 AliAnalysisMuMuNch.cxx:157
 AliAnalysisMuMuNch.cxx:158
 AliAnalysisMuMuNch.cxx:159
 AliAnalysisMuMuNch.cxx:160
 AliAnalysisMuMuNch.cxx:161
 AliAnalysisMuMuNch.cxx:162
 AliAnalysisMuMuNch.cxx:163
 AliAnalysisMuMuNch.cxx:164
 AliAnalysisMuMuNch.cxx:165
 AliAnalysisMuMuNch.cxx:166
 AliAnalysisMuMuNch.cxx:167
 AliAnalysisMuMuNch.cxx:168
 AliAnalysisMuMuNch.cxx:169
 AliAnalysisMuMuNch.cxx:170
 AliAnalysisMuMuNch.cxx:171
 AliAnalysisMuMuNch.cxx:172
 AliAnalysisMuMuNch.cxx:173
 AliAnalysisMuMuNch.cxx:174
 AliAnalysisMuMuNch.cxx:175
 AliAnalysisMuMuNch.cxx:176
 AliAnalysisMuMuNch.cxx:177
 AliAnalysisMuMuNch.cxx:178
 AliAnalysisMuMuNch.cxx:179
 AliAnalysisMuMuNch.cxx:180
 AliAnalysisMuMuNch.cxx:181
 AliAnalysisMuMuNch.cxx:182
 AliAnalysisMuMuNch.cxx:183
 AliAnalysisMuMuNch.cxx:184
 AliAnalysisMuMuNch.cxx:185
 AliAnalysisMuMuNch.cxx:186
 AliAnalysisMuMuNch.cxx:187
 AliAnalysisMuMuNch.cxx:188
 AliAnalysisMuMuNch.cxx:189
 AliAnalysisMuMuNch.cxx:190
 AliAnalysisMuMuNch.cxx:191
 AliAnalysisMuMuNch.cxx:192
 AliAnalysisMuMuNch.cxx:193
 AliAnalysisMuMuNch.cxx:194
 AliAnalysisMuMuNch.cxx:195
 AliAnalysisMuMuNch.cxx:196
 AliAnalysisMuMuNch.cxx:197
 AliAnalysisMuMuNch.cxx:198
 AliAnalysisMuMuNch.cxx:199
 AliAnalysisMuMuNch.cxx:200
 AliAnalysisMuMuNch.cxx:201
 AliAnalysisMuMuNch.cxx:202
 AliAnalysisMuMuNch.cxx:203
 AliAnalysisMuMuNch.cxx:204
 AliAnalysisMuMuNch.cxx:205
 AliAnalysisMuMuNch.cxx:206
 AliAnalysisMuMuNch.cxx:207
 AliAnalysisMuMuNch.cxx:208
 AliAnalysisMuMuNch.cxx:209
 AliAnalysisMuMuNch.cxx:210
 AliAnalysisMuMuNch.cxx:211
 AliAnalysisMuMuNch.cxx:212
 AliAnalysisMuMuNch.cxx:213
 AliAnalysisMuMuNch.cxx:214
 AliAnalysisMuMuNch.cxx:215
 AliAnalysisMuMuNch.cxx:216
 AliAnalysisMuMuNch.cxx:217
 AliAnalysisMuMuNch.cxx:218
 AliAnalysisMuMuNch.cxx:219
 AliAnalysisMuMuNch.cxx:220
 AliAnalysisMuMuNch.cxx:221
 AliAnalysisMuMuNch.cxx:222
 AliAnalysisMuMuNch.cxx:223
 AliAnalysisMuMuNch.cxx:224
 AliAnalysisMuMuNch.cxx:225
 AliAnalysisMuMuNch.cxx:226
 AliAnalysisMuMuNch.cxx:227
 AliAnalysisMuMuNch.cxx:228
 AliAnalysisMuMuNch.cxx:229
 AliAnalysisMuMuNch.cxx:230
 AliAnalysisMuMuNch.cxx:231
 AliAnalysisMuMuNch.cxx:232
 AliAnalysisMuMuNch.cxx:233
 AliAnalysisMuMuNch.cxx:234
 AliAnalysisMuMuNch.cxx:235
 AliAnalysisMuMuNch.cxx:236
 AliAnalysisMuMuNch.cxx:237
 AliAnalysisMuMuNch.cxx:238
 AliAnalysisMuMuNch.cxx:239
 AliAnalysisMuMuNch.cxx:240
 AliAnalysisMuMuNch.cxx:241
 AliAnalysisMuMuNch.cxx:242
 AliAnalysisMuMuNch.cxx:243
 AliAnalysisMuMuNch.cxx:244
 AliAnalysisMuMuNch.cxx:245
 AliAnalysisMuMuNch.cxx:246
 AliAnalysisMuMuNch.cxx:247
 AliAnalysisMuMuNch.cxx:248
 AliAnalysisMuMuNch.cxx:249
 AliAnalysisMuMuNch.cxx:250
 AliAnalysisMuMuNch.cxx:251
 AliAnalysisMuMuNch.cxx:252
 AliAnalysisMuMuNch.cxx:253
 AliAnalysisMuMuNch.cxx:254
 AliAnalysisMuMuNch.cxx:255
 AliAnalysisMuMuNch.cxx:256
 AliAnalysisMuMuNch.cxx:257
 AliAnalysisMuMuNch.cxx:258
 AliAnalysisMuMuNch.cxx:259
 AliAnalysisMuMuNch.cxx:260
 AliAnalysisMuMuNch.cxx:261
 AliAnalysisMuMuNch.cxx:262
 AliAnalysisMuMuNch.cxx:263
 AliAnalysisMuMuNch.cxx:264
 AliAnalysisMuMuNch.cxx:265
 AliAnalysisMuMuNch.cxx:266
 AliAnalysisMuMuNch.cxx:267
 AliAnalysisMuMuNch.cxx:268
 AliAnalysisMuMuNch.cxx:269
 AliAnalysisMuMuNch.cxx:270
 AliAnalysisMuMuNch.cxx:271
 AliAnalysisMuMuNch.cxx:272
 AliAnalysisMuMuNch.cxx:273
 AliAnalysisMuMuNch.cxx:274
 AliAnalysisMuMuNch.cxx:275
 AliAnalysisMuMuNch.cxx:276
 AliAnalysisMuMuNch.cxx:277
 AliAnalysisMuMuNch.cxx:278
 AliAnalysisMuMuNch.cxx:279
 AliAnalysisMuMuNch.cxx:280
 AliAnalysisMuMuNch.cxx:281
 AliAnalysisMuMuNch.cxx:282
 AliAnalysisMuMuNch.cxx:283
 AliAnalysisMuMuNch.cxx:284
 AliAnalysisMuMuNch.cxx:285
 AliAnalysisMuMuNch.cxx:286
 AliAnalysisMuMuNch.cxx:287
 AliAnalysisMuMuNch.cxx:288
 AliAnalysisMuMuNch.cxx:289
 AliAnalysisMuMuNch.cxx:290
 AliAnalysisMuMuNch.cxx:291
 AliAnalysisMuMuNch.cxx:292
 AliAnalysisMuMuNch.cxx:293
 AliAnalysisMuMuNch.cxx:294
 AliAnalysisMuMuNch.cxx:295
 AliAnalysisMuMuNch.cxx:296
 AliAnalysisMuMuNch.cxx:297
 AliAnalysisMuMuNch.cxx:298
 AliAnalysisMuMuNch.cxx:299
 AliAnalysisMuMuNch.cxx:300
 AliAnalysisMuMuNch.cxx:301
 AliAnalysisMuMuNch.cxx:302
 AliAnalysisMuMuNch.cxx:303
 AliAnalysisMuMuNch.cxx:304
 AliAnalysisMuMuNch.cxx:305
 AliAnalysisMuMuNch.cxx:306
 AliAnalysisMuMuNch.cxx:307
 AliAnalysisMuMuNch.cxx:308
 AliAnalysisMuMuNch.cxx:309
 AliAnalysisMuMuNch.cxx:310
 AliAnalysisMuMuNch.cxx:311
 AliAnalysisMuMuNch.cxx:312
 AliAnalysisMuMuNch.cxx:313
 AliAnalysisMuMuNch.cxx:314
 AliAnalysisMuMuNch.cxx:315
 AliAnalysisMuMuNch.cxx:316
 AliAnalysisMuMuNch.cxx:317
 AliAnalysisMuMuNch.cxx:318
 AliAnalysisMuMuNch.cxx:319
 AliAnalysisMuMuNch.cxx:320
 AliAnalysisMuMuNch.cxx:321
 AliAnalysisMuMuNch.cxx:322
 AliAnalysisMuMuNch.cxx:323
 AliAnalysisMuMuNch.cxx:324
 AliAnalysisMuMuNch.cxx:325
 AliAnalysisMuMuNch.cxx:326
 AliAnalysisMuMuNch.cxx:327
 AliAnalysisMuMuNch.cxx:328
 AliAnalysisMuMuNch.cxx:329
 AliAnalysisMuMuNch.cxx:330
 AliAnalysisMuMuNch.cxx:331
 AliAnalysisMuMuNch.cxx:332
 AliAnalysisMuMuNch.cxx:333
 AliAnalysisMuMuNch.cxx:334
 AliAnalysisMuMuNch.cxx:335
 AliAnalysisMuMuNch.cxx:336
 AliAnalysisMuMuNch.cxx:337
 AliAnalysisMuMuNch.cxx:338
 AliAnalysisMuMuNch.cxx:339
 AliAnalysisMuMuNch.cxx:340
 AliAnalysisMuMuNch.cxx:341
 AliAnalysisMuMuNch.cxx:342
 AliAnalysisMuMuNch.cxx:343
 AliAnalysisMuMuNch.cxx:344
 AliAnalysisMuMuNch.cxx:345
 AliAnalysisMuMuNch.cxx:346
 AliAnalysisMuMuNch.cxx:347
 AliAnalysisMuMuNch.cxx:348
 AliAnalysisMuMuNch.cxx:349
 AliAnalysisMuMuNch.cxx:350
 AliAnalysisMuMuNch.cxx:351
 AliAnalysisMuMuNch.cxx:352
 AliAnalysisMuMuNch.cxx:353
 AliAnalysisMuMuNch.cxx:354
 AliAnalysisMuMuNch.cxx:355
 AliAnalysisMuMuNch.cxx:356
 AliAnalysisMuMuNch.cxx:357
 AliAnalysisMuMuNch.cxx:358
 AliAnalysisMuMuNch.cxx:359
 AliAnalysisMuMuNch.cxx:360
 AliAnalysisMuMuNch.cxx:361
 AliAnalysisMuMuNch.cxx:362
 AliAnalysisMuMuNch.cxx:363
 AliAnalysisMuMuNch.cxx:364
 AliAnalysisMuMuNch.cxx:365
 AliAnalysisMuMuNch.cxx:366
 AliAnalysisMuMuNch.cxx:367
 AliAnalysisMuMuNch.cxx:368
 AliAnalysisMuMuNch.cxx:369
 AliAnalysisMuMuNch.cxx:370
 AliAnalysisMuMuNch.cxx:371
 AliAnalysisMuMuNch.cxx:372
 AliAnalysisMuMuNch.cxx:373
 AliAnalysisMuMuNch.cxx:374
 AliAnalysisMuMuNch.cxx:375
 AliAnalysisMuMuNch.cxx:376
 AliAnalysisMuMuNch.cxx:377
 AliAnalysisMuMuNch.cxx:378
 AliAnalysisMuMuNch.cxx:379
 AliAnalysisMuMuNch.cxx:380
 AliAnalysisMuMuNch.cxx:381
 AliAnalysisMuMuNch.cxx:382
 AliAnalysisMuMuNch.cxx:383
 AliAnalysisMuMuNch.cxx:384
 AliAnalysisMuMuNch.cxx:385
 AliAnalysisMuMuNch.cxx:386
 AliAnalysisMuMuNch.cxx:387
 AliAnalysisMuMuNch.cxx:388
 AliAnalysisMuMuNch.cxx:389
 AliAnalysisMuMuNch.cxx:390
 AliAnalysisMuMuNch.cxx:391
 AliAnalysisMuMuNch.cxx:392
 AliAnalysisMuMuNch.cxx:393
 AliAnalysisMuMuNch.cxx:394
 AliAnalysisMuMuNch.cxx:395
 AliAnalysisMuMuNch.cxx:396
 AliAnalysisMuMuNch.cxx:397
 AliAnalysisMuMuNch.cxx:398
 AliAnalysisMuMuNch.cxx:399
 AliAnalysisMuMuNch.cxx:400
 AliAnalysisMuMuNch.cxx:401
 AliAnalysisMuMuNch.cxx:402
 AliAnalysisMuMuNch.cxx:403
 AliAnalysisMuMuNch.cxx:404
 AliAnalysisMuMuNch.cxx:405
 AliAnalysisMuMuNch.cxx:406
 AliAnalysisMuMuNch.cxx:407
 AliAnalysisMuMuNch.cxx:408
 AliAnalysisMuMuNch.cxx:409
 AliAnalysisMuMuNch.cxx:410
 AliAnalysisMuMuNch.cxx:411
 AliAnalysisMuMuNch.cxx:412
 AliAnalysisMuMuNch.cxx:413
 AliAnalysisMuMuNch.cxx:414
 AliAnalysisMuMuNch.cxx:415
 AliAnalysisMuMuNch.cxx:416
 AliAnalysisMuMuNch.cxx:417
 AliAnalysisMuMuNch.cxx:418
 AliAnalysisMuMuNch.cxx:419
 AliAnalysisMuMuNch.cxx:420
 AliAnalysisMuMuNch.cxx:421
 AliAnalysisMuMuNch.cxx:422
 AliAnalysisMuMuNch.cxx:423
 AliAnalysisMuMuNch.cxx:424
 AliAnalysisMuMuNch.cxx:425
 AliAnalysisMuMuNch.cxx:426
 AliAnalysisMuMuNch.cxx:427
 AliAnalysisMuMuNch.cxx:428
 AliAnalysisMuMuNch.cxx:429
 AliAnalysisMuMuNch.cxx:430
 AliAnalysisMuMuNch.cxx:431
 AliAnalysisMuMuNch.cxx:432
 AliAnalysisMuMuNch.cxx:433
 AliAnalysisMuMuNch.cxx:434
 AliAnalysisMuMuNch.cxx:435
 AliAnalysisMuMuNch.cxx:436
 AliAnalysisMuMuNch.cxx:437
 AliAnalysisMuMuNch.cxx:438
 AliAnalysisMuMuNch.cxx:439
 AliAnalysisMuMuNch.cxx:440
 AliAnalysisMuMuNch.cxx:441
 AliAnalysisMuMuNch.cxx:442
 AliAnalysisMuMuNch.cxx:443
 AliAnalysisMuMuNch.cxx:444
 AliAnalysisMuMuNch.cxx:445
 AliAnalysisMuMuNch.cxx:446
 AliAnalysisMuMuNch.cxx:447
 AliAnalysisMuMuNch.cxx:448
 AliAnalysisMuMuNch.cxx:449
 AliAnalysisMuMuNch.cxx:450
 AliAnalysisMuMuNch.cxx:451
 AliAnalysisMuMuNch.cxx:452
 AliAnalysisMuMuNch.cxx:453
 AliAnalysisMuMuNch.cxx:454
 AliAnalysisMuMuNch.cxx:455
 AliAnalysisMuMuNch.cxx:456
 AliAnalysisMuMuNch.cxx:457
 AliAnalysisMuMuNch.cxx:458
 AliAnalysisMuMuNch.cxx:459
 AliAnalysisMuMuNch.cxx:460
 AliAnalysisMuMuNch.cxx:461
 AliAnalysisMuMuNch.cxx:462
 AliAnalysisMuMuNch.cxx:463
 AliAnalysisMuMuNch.cxx:464
 AliAnalysisMuMuNch.cxx:465
 AliAnalysisMuMuNch.cxx:466
 AliAnalysisMuMuNch.cxx:467
 AliAnalysisMuMuNch.cxx:468
 AliAnalysisMuMuNch.cxx:469
 AliAnalysisMuMuNch.cxx:470
 AliAnalysisMuMuNch.cxx:471
 AliAnalysisMuMuNch.cxx:472
 AliAnalysisMuMuNch.cxx:473
 AliAnalysisMuMuNch.cxx:474
 AliAnalysisMuMuNch.cxx:475
 AliAnalysisMuMuNch.cxx:476
 AliAnalysisMuMuNch.cxx:477
 AliAnalysisMuMuNch.cxx:478
 AliAnalysisMuMuNch.cxx:479
 AliAnalysisMuMuNch.cxx:480
 AliAnalysisMuMuNch.cxx:481
 AliAnalysisMuMuNch.cxx:482
 AliAnalysisMuMuNch.cxx:483
 AliAnalysisMuMuNch.cxx:484
 AliAnalysisMuMuNch.cxx:485
 AliAnalysisMuMuNch.cxx:486
 AliAnalysisMuMuNch.cxx:487
 AliAnalysisMuMuNch.cxx:488
 AliAnalysisMuMuNch.cxx:489
 AliAnalysisMuMuNch.cxx:490
 AliAnalysisMuMuNch.cxx:491
 AliAnalysisMuMuNch.cxx:492
 AliAnalysisMuMuNch.cxx:493
 AliAnalysisMuMuNch.cxx:494
 AliAnalysisMuMuNch.cxx:495
 AliAnalysisMuMuNch.cxx:496
 AliAnalysisMuMuNch.cxx:497
 AliAnalysisMuMuNch.cxx:498
 AliAnalysisMuMuNch.cxx:499
 AliAnalysisMuMuNch.cxx:500
 AliAnalysisMuMuNch.cxx:501
 AliAnalysisMuMuNch.cxx:502
 AliAnalysisMuMuNch.cxx:503
 AliAnalysisMuMuNch.cxx:504
 AliAnalysisMuMuNch.cxx:505
 AliAnalysisMuMuNch.cxx:506
 AliAnalysisMuMuNch.cxx:507
 AliAnalysisMuMuNch.cxx:508
 AliAnalysisMuMuNch.cxx:509
 AliAnalysisMuMuNch.cxx:510
 AliAnalysisMuMuNch.cxx:511
 AliAnalysisMuMuNch.cxx:512
 AliAnalysisMuMuNch.cxx:513
 AliAnalysisMuMuNch.cxx:514
 AliAnalysisMuMuNch.cxx:515
 AliAnalysisMuMuNch.cxx:516
 AliAnalysisMuMuNch.cxx:517
 AliAnalysisMuMuNch.cxx:518
 AliAnalysisMuMuNch.cxx:519
 AliAnalysisMuMuNch.cxx:520
 AliAnalysisMuMuNch.cxx:521
 AliAnalysisMuMuNch.cxx:522
 AliAnalysisMuMuNch.cxx:523
 AliAnalysisMuMuNch.cxx:524
 AliAnalysisMuMuNch.cxx:525
 AliAnalysisMuMuNch.cxx:526
 AliAnalysisMuMuNch.cxx:527
 AliAnalysisMuMuNch.cxx:528
 AliAnalysisMuMuNch.cxx:529
 AliAnalysisMuMuNch.cxx:530
 AliAnalysisMuMuNch.cxx:531
 AliAnalysisMuMuNch.cxx:532
 AliAnalysisMuMuNch.cxx:533
 AliAnalysisMuMuNch.cxx:534
 AliAnalysisMuMuNch.cxx:535
 AliAnalysisMuMuNch.cxx:536
 AliAnalysisMuMuNch.cxx:537
 AliAnalysisMuMuNch.cxx:538
 AliAnalysisMuMuNch.cxx:539
 AliAnalysisMuMuNch.cxx:540
 AliAnalysisMuMuNch.cxx:541
 AliAnalysisMuMuNch.cxx:542
 AliAnalysisMuMuNch.cxx:543
 AliAnalysisMuMuNch.cxx:544
 AliAnalysisMuMuNch.cxx:545
 AliAnalysisMuMuNch.cxx:546
 AliAnalysisMuMuNch.cxx:547
 AliAnalysisMuMuNch.cxx:548
 AliAnalysisMuMuNch.cxx:549
 AliAnalysisMuMuNch.cxx:550
 AliAnalysisMuMuNch.cxx:551
 AliAnalysisMuMuNch.cxx:552
 AliAnalysisMuMuNch.cxx:553
 AliAnalysisMuMuNch.cxx:554
 AliAnalysisMuMuNch.cxx:555
 AliAnalysisMuMuNch.cxx:556
 AliAnalysisMuMuNch.cxx:557
 AliAnalysisMuMuNch.cxx:558
 AliAnalysisMuMuNch.cxx:559
 AliAnalysisMuMuNch.cxx:560
 AliAnalysisMuMuNch.cxx:561
 AliAnalysisMuMuNch.cxx:562
 AliAnalysisMuMuNch.cxx:563
 AliAnalysisMuMuNch.cxx:564
 AliAnalysisMuMuNch.cxx:565
 AliAnalysisMuMuNch.cxx:566
 AliAnalysisMuMuNch.cxx:567
 AliAnalysisMuMuNch.cxx:568
 AliAnalysisMuMuNch.cxx:569
 AliAnalysisMuMuNch.cxx:570
 AliAnalysisMuMuNch.cxx:571
 AliAnalysisMuMuNch.cxx:572
 AliAnalysisMuMuNch.cxx:573
 AliAnalysisMuMuNch.cxx:574
 AliAnalysisMuMuNch.cxx:575
 AliAnalysisMuMuNch.cxx:576
 AliAnalysisMuMuNch.cxx:577
 AliAnalysisMuMuNch.cxx:578
 AliAnalysisMuMuNch.cxx:579
 AliAnalysisMuMuNch.cxx:580
 AliAnalysisMuMuNch.cxx:581
 AliAnalysisMuMuNch.cxx:582
 AliAnalysisMuMuNch.cxx:583
 AliAnalysisMuMuNch.cxx:584
 AliAnalysisMuMuNch.cxx:585
 AliAnalysisMuMuNch.cxx:586
 AliAnalysisMuMuNch.cxx:587
 AliAnalysisMuMuNch.cxx:588
 AliAnalysisMuMuNch.cxx:589
 AliAnalysisMuMuNch.cxx:590
 AliAnalysisMuMuNch.cxx:591
 AliAnalysisMuMuNch.cxx:592
 AliAnalysisMuMuNch.cxx:593
 AliAnalysisMuMuNch.cxx:594
 AliAnalysisMuMuNch.cxx:595
 AliAnalysisMuMuNch.cxx:596
 AliAnalysisMuMuNch.cxx:597
 AliAnalysisMuMuNch.cxx:598
 AliAnalysisMuMuNch.cxx:599
 AliAnalysisMuMuNch.cxx:600
 AliAnalysisMuMuNch.cxx:601
 AliAnalysisMuMuNch.cxx:602
 AliAnalysisMuMuNch.cxx:603
 AliAnalysisMuMuNch.cxx:604
 AliAnalysisMuMuNch.cxx:605
 AliAnalysisMuMuNch.cxx:606
 AliAnalysisMuMuNch.cxx:607
 AliAnalysisMuMuNch.cxx:608
 AliAnalysisMuMuNch.cxx:609
 AliAnalysisMuMuNch.cxx:610
 AliAnalysisMuMuNch.cxx:611
 AliAnalysisMuMuNch.cxx:612
 AliAnalysisMuMuNch.cxx:613
 AliAnalysisMuMuNch.cxx:614
 AliAnalysisMuMuNch.cxx:615
 AliAnalysisMuMuNch.cxx:616
 AliAnalysisMuMuNch.cxx:617
 AliAnalysisMuMuNch.cxx:618
 AliAnalysisMuMuNch.cxx:619
 AliAnalysisMuMuNch.cxx:620
 AliAnalysisMuMuNch.cxx:621
 AliAnalysisMuMuNch.cxx:622
 AliAnalysisMuMuNch.cxx:623
 AliAnalysisMuMuNch.cxx:624
 AliAnalysisMuMuNch.cxx:625
 AliAnalysisMuMuNch.cxx:626
 AliAnalysisMuMuNch.cxx:627
 AliAnalysisMuMuNch.cxx:628
 AliAnalysisMuMuNch.cxx:629
 AliAnalysisMuMuNch.cxx:630
 AliAnalysisMuMuNch.cxx:631
 AliAnalysisMuMuNch.cxx:632
 AliAnalysisMuMuNch.cxx:633
 AliAnalysisMuMuNch.cxx:634
 AliAnalysisMuMuNch.cxx:635
 AliAnalysisMuMuNch.cxx:636
 AliAnalysisMuMuNch.cxx:637
 AliAnalysisMuMuNch.cxx:638
 AliAnalysisMuMuNch.cxx:639
 AliAnalysisMuMuNch.cxx:640
 AliAnalysisMuMuNch.cxx:641
 AliAnalysisMuMuNch.cxx:642
 AliAnalysisMuMuNch.cxx:643
 AliAnalysisMuMuNch.cxx:644
 AliAnalysisMuMuNch.cxx:645
 AliAnalysisMuMuNch.cxx:646
 AliAnalysisMuMuNch.cxx:647
 AliAnalysisMuMuNch.cxx:648
 AliAnalysisMuMuNch.cxx:649
 AliAnalysisMuMuNch.cxx:650
 AliAnalysisMuMuNch.cxx:651
 AliAnalysisMuMuNch.cxx:652
 AliAnalysisMuMuNch.cxx:653
 AliAnalysisMuMuNch.cxx:654
 AliAnalysisMuMuNch.cxx:655
 AliAnalysisMuMuNch.cxx:656
 AliAnalysisMuMuNch.cxx:657
 AliAnalysisMuMuNch.cxx:658
 AliAnalysisMuMuNch.cxx:659
 AliAnalysisMuMuNch.cxx:660
 AliAnalysisMuMuNch.cxx:661
 AliAnalysisMuMuNch.cxx:662
 AliAnalysisMuMuNch.cxx:663
 AliAnalysisMuMuNch.cxx:664
 AliAnalysisMuMuNch.cxx:665
 AliAnalysisMuMuNch.cxx:666
 AliAnalysisMuMuNch.cxx:667
 AliAnalysisMuMuNch.cxx:668
 AliAnalysisMuMuNch.cxx:669
 AliAnalysisMuMuNch.cxx:670
 AliAnalysisMuMuNch.cxx:671
 AliAnalysisMuMuNch.cxx:672
 AliAnalysisMuMuNch.cxx:673
 AliAnalysisMuMuNch.cxx:674
 AliAnalysisMuMuNch.cxx:675
 AliAnalysisMuMuNch.cxx:676
 AliAnalysisMuMuNch.cxx:677
 AliAnalysisMuMuNch.cxx:678
 AliAnalysisMuMuNch.cxx:679
 AliAnalysisMuMuNch.cxx:680
 AliAnalysisMuMuNch.cxx:681
 AliAnalysisMuMuNch.cxx:682
 AliAnalysisMuMuNch.cxx:683
 AliAnalysisMuMuNch.cxx:684
 AliAnalysisMuMuNch.cxx:685
 AliAnalysisMuMuNch.cxx:686
 AliAnalysisMuMuNch.cxx:687
 AliAnalysisMuMuNch.cxx:688
 AliAnalysisMuMuNch.cxx:689
 AliAnalysisMuMuNch.cxx:690
 AliAnalysisMuMuNch.cxx:691
 AliAnalysisMuMuNch.cxx:692
 AliAnalysisMuMuNch.cxx:693
 AliAnalysisMuMuNch.cxx:694
 AliAnalysisMuMuNch.cxx:695
 AliAnalysisMuMuNch.cxx:696
 AliAnalysisMuMuNch.cxx:697
 AliAnalysisMuMuNch.cxx:698
 AliAnalysisMuMuNch.cxx:699
 AliAnalysisMuMuNch.cxx:700
 AliAnalysisMuMuNch.cxx:701
 AliAnalysisMuMuNch.cxx:702
 AliAnalysisMuMuNch.cxx:703
 AliAnalysisMuMuNch.cxx:704
 AliAnalysisMuMuNch.cxx:705
 AliAnalysisMuMuNch.cxx:706
 AliAnalysisMuMuNch.cxx:707
 AliAnalysisMuMuNch.cxx:708
 AliAnalysisMuMuNch.cxx:709
 AliAnalysisMuMuNch.cxx:710
 AliAnalysisMuMuNch.cxx:711
 AliAnalysisMuMuNch.cxx:712
 AliAnalysisMuMuNch.cxx:713
 AliAnalysisMuMuNch.cxx:714
 AliAnalysisMuMuNch.cxx:715
 AliAnalysisMuMuNch.cxx:716
 AliAnalysisMuMuNch.cxx:717
 AliAnalysisMuMuNch.cxx:718
 AliAnalysisMuMuNch.cxx:719
 AliAnalysisMuMuNch.cxx:720
 AliAnalysisMuMuNch.cxx:721
 AliAnalysisMuMuNch.cxx:722
 AliAnalysisMuMuNch.cxx:723
 AliAnalysisMuMuNch.cxx:724
 AliAnalysisMuMuNch.cxx:725
 AliAnalysisMuMuNch.cxx:726
 AliAnalysisMuMuNch.cxx:727
 AliAnalysisMuMuNch.cxx:728
 AliAnalysisMuMuNch.cxx:729
 AliAnalysisMuMuNch.cxx:730
 AliAnalysisMuMuNch.cxx:731
 AliAnalysisMuMuNch.cxx:732
 AliAnalysisMuMuNch.cxx:733
 AliAnalysisMuMuNch.cxx:734
 AliAnalysisMuMuNch.cxx:735
 AliAnalysisMuMuNch.cxx:736
 AliAnalysisMuMuNch.cxx:737
 AliAnalysisMuMuNch.cxx:738
 AliAnalysisMuMuNch.cxx:739
 AliAnalysisMuMuNch.cxx:740
 AliAnalysisMuMuNch.cxx:741
 AliAnalysisMuMuNch.cxx:742
 AliAnalysisMuMuNch.cxx:743
 AliAnalysisMuMuNch.cxx:744
 AliAnalysisMuMuNch.cxx:745
 AliAnalysisMuMuNch.cxx:746
 AliAnalysisMuMuNch.cxx:747
 AliAnalysisMuMuNch.cxx:748
 AliAnalysisMuMuNch.cxx:749
 AliAnalysisMuMuNch.cxx:750
 AliAnalysisMuMuNch.cxx:751
 AliAnalysisMuMuNch.cxx:752
 AliAnalysisMuMuNch.cxx:753
 AliAnalysisMuMuNch.cxx:754
 AliAnalysisMuMuNch.cxx:755
 AliAnalysisMuMuNch.cxx:756
 AliAnalysisMuMuNch.cxx:757
 AliAnalysisMuMuNch.cxx:758
 AliAnalysisMuMuNch.cxx:759
 AliAnalysisMuMuNch.cxx:760
 AliAnalysisMuMuNch.cxx:761
 AliAnalysisMuMuNch.cxx:762
 AliAnalysisMuMuNch.cxx:763
 AliAnalysisMuMuNch.cxx:764
 AliAnalysisMuMuNch.cxx:765
 AliAnalysisMuMuNch.cxx:766
 AliAnalysisMuMuNch.cxx:767
 AliAnalysisMuMuNch.cxx:768
 AliAnalysisMuMuNch.cxx:769
 AliAnalysisMuMuNch.cxx:770
 AliAnalysisMuMuNch.cxx:771
 AliAnalysisMuMuNch.cxx:772
 AliAnalysisMuMuNch.cxx:773
 AliAnalysisMuMuNch.cxx:774
 AliAnalysisMuMuNch.cxx:775
 AliAnalysisMuMuNch.cxx:776
 AliAnalysisMuMuNch.cxx:777
 AliAnalysisMuMuNch.cxx:778
 AliAnalysisMuMuNch.cxx:779
 AliAnalysisMuMuNch.cxx:780
 AliAnalysisMuMuNch.cxx:781
 AliAnalysisMuMuNch.cxx:782
 AliAnalysisMuMuNch.cxx:783
 AliAnalysisMuMuNch.cxx:784
 AliAnalysisMuMuNch.cxx:785
 AliAnalysisMuMuNch.cxx:786
 AliAnalysisMuMuNch.cxx:787
 AliAnalysisMuMuNch.cxx:788
 AliAnalysisMuMuNch.cxx:789
 AliAnalysisMuMuNch.cxx:790
 AliAnalysisMuMuNch.cxx:791
 AliAnalysisMuMuNch.cxx:792
 AliAnalysisMuMuNch.cxx:793
 AliAnalysisMuMuNch.cxx:794
 AliAnalysisMuMuNch.cxx:795
 AliAnalysisMuMuNch.cxx:796
 AliAnalysisMuMuNch.cxx:797
 AliAnalysisMuMuNch.cxx:798
 AliAnalysisMuMuNch.cxx:799
 AliAnalysisMuMuNch.cxx:800
 AliAnalysisMuMuNch.cxx:801
 AliAnalysisMuMuNch.cxx:802
 AliAnalysisMuMuNch.cxx:803
 AliAnalysisMuMuNch.cxx:804
 AliAnalysisMuMuNch.cxx:805
 AliAnalysisMuMuNch.cxx:806
 AliAnalysisMuMuNch.cxx:807
 AliAnalysisMuMuNch.cxx:808
 AliAnalysisMuMuNch.cxx:809
 AliAnalysisMuMuNch.cxx:810
 AliAnalysisMuMuNch.cxx:811
 AliAnalysisMuMuNch.cxx:812
 AliAnalysisMuMuNch.cxx:813
 AliAnalysisMuMuNch.cxx:814
 AliAnalysisMuMuNch.cxx:815
 AliAnalysisMuMuNch.cxx:816
 AliAnalysisMuMuNch.cxx:817
 AliAnalysisMuMuNch.cxx:818
 AliAnalysisMuMuNch.cxx:819
 AliAnalysisMuMuNch.cxx:820
 AliAnalysisMuMuNch.cxx:821
 AliAnalysisMuMuNch.cxx:822
 AliAnalysisMuMuNch.cxx:823
 AliAnalysisMuMuNch.cxx:824
 AliAnalysisMuMuNch.cxx:825
 AliAnalysisMuMuNch.cxx:826
 AliAnalysisMuMuNch.cxx:827
 AliAnalysisMuMuNch.cxx:828
 AliAnalysisMuMuNch.cxx:829
 AliAnalysisMuMuNch.cxx:830
 AliAnalysisMuMuNch.cxx:831
 AliAnalysisMuMuNch.cxx:832
 AliAnalysisMuMuNch.cxx:833
 AliAnalysisMuMuNch.cxx:834
 AliAnalysisMuMuNch.cxx:835
 AliAnalysisMuMuNch.cxx:836
 AliAnalysisMuMuNch.cxx:837
 AliAnalysisMuMuNch.cxx:838
 AliAnalysisMuMuNch.cxx:839
 AliAnalysisMuMuNch.cxx:840
 AliAnalysisMuMuNch.cxx:841
 AliAnalysisMuMuNch.cxx:842
 AliAnalysisMuMuNch.cxx:843
 AliAnalysisMuMuNch.cxx:844
 AliAnalysisMuMuNch.cxx:845
 AliAnalysisMuMuNch.cxx:846
 AliAnalysisMuMuNch.cxx:847
 AliAnalysisMuMuNch.cxx:848
 AliAnalysisMuMuNch.cxx:849
 AliAnalysisMuMuNch.cxx:850
 AliAnalysisMuMuNch.cxx:851
 AliAnalysisMuMuNch.cxx:852
 AliAnalysisMuMuNch.cxx:853
 AliAnalysisMuMuNch.cxx:854
 AliAnalysisMuMuNch.cxx:855
 AliAnalysisMuMuNch.cxx:856
 AliAnalysisMuMuNch.cxx:857
 AliAnalysisMuMuNch.cxx:858
 AliAnalysisMuMuNch.cxx:859
 AliAnalysisMuMuNch.cxx:860
 AliAnalysisMuMuNch.cxx:861
 AliAnalysisMuMuNch.cxx:862
 AliAnalysisMuMuNch.cxx:863
 AliAnalysisMuMuNch.cxx:864
 AliAnalysisMuMuNch.cxx:865
 AliAnalysisMuMuNch.cxx:866
 AliAnalysisMuMuNch.cxx:867
 AliAnalysisMuMuNch.cxx:868
 AliAnalysisMuMuNch.cxx:869
 AliAnalysisMuMuNch.cxx:870
 AliAnalysisMuMuNch.cxx:871
 AliAnalysisMuMuNch.cxx:872
 AliAnalysisMuMuNch.cxx:873
 AliAnalysisMuMuNch.cxx:874
 AliAnalysisMuMuNch.cxx:875
 AliAnalysisMuMuNch.cxx:876
 AliAnalysisMuMuNch.cxx:877
 AliAnalysisMuMuNch.cxx:878
 AliAnalysisMuMuNch.cxx:879
 AliAnalysisMuMuNch.cxx:880
 AliAnalysisMuMuNch.cxx:881
 AliAnalysisMuMuNch.cxx:882
 AliAnalysisMuMuNch.cxx:883
 AliAnalysisMuMuNch.cxx:884
 AliAnalysisMuMuNch.cxx:885
 AliAnalysisMuMuNch.cxx:886
 AliAnalysisMuMuNch.cxx:887
 AliAnalysisMuMuNch.cxx:888
 AliAnalysisMuMuNch.cxx:889
 AliAnalysisMuMuNch.cxx:890
 AliAnalysisMuMuNch.cxx:891
 AliAnalysisMuMuNch.cxx:892
 AliAnalysisMuMuNch.cxx:893
 AliAnalysisMuMuNch.cxx:894
 AliAnalysisMuMuNch.cxx:895
 AliAnalysisMuMuNch.cxx:896
 AliAnalysisMuMuNch.cxx:897
 AliAnalysisMuMuNch.cxx:898
 AliAnalysisMuMuNch.cxx:899
 AliAnalysisMuMuNch.cxx:900
 AliAnalysisMuMuNch.cxx:901
 AliAnalysisMuMuNch.cxx:902
 AliAnalysisMuMuNch.cxx:903
 AliAnalysisMuMuNch.cxx:904
 AliAnalysisMuMuNch.cxx:905
 AliAnalysisMuMuNch.cxx:906
 AliAnalysisMuMuNch.cxx:907
 AliAnalysisMuMuNch.cxx:908
 AliAnalysisMuMuNch.cxx:909
 AliAnalysisMuMuNch.cxx:910
 AliAnalysisMuMuNch.cxx:911
 AliAnalysisMuMuNch.cxx:912
 AliAnalysisMuMuNch.cxx:913
 AliAnalysisMuMuNch.cxx:914
 AliAnalysisMuMuNch.cxx:915
 AliAnalysisMuMuNch.cxx:916
 AliAnalysisMuMuNch.cxx:917
 AliAnalysisMuMuNch.cxx:918
 AliAnalysisMuMuNch.cxx:919
 AliAnalysisMuMuNch.cxx:920
 AliAnalysisMuMuNch.cxx:921
 AliAnalysisMuMuNch.cxx:922
 AliAnalysisMuMuNch.cxx:923
 AliAnalysisMuMuNch.cxx:924
 AliAnalysisMuMuNch.cxx:925
 AliAnalysisMuMuNch.cxx:926
 AliAnalysisMuMuNch.cxx:927
 AliAnalysisMuMuNch.cxx:928
 AliAnalysisMuMuNch.cxx:929
 AliAnalysisMuMuNch.cxx:930
 AliAnalysisMuMuNch.cxx:931
 AliAnalysisMuMuNch.cxx:932
 AliAnalysisMuMuNch.cxx:933
 AliAnalysisMuMuNch.cxx:934
 AliAnalysisMuMuNch.cxx:935
 AliAnalysisMuMuNch.cxx:936
 AliAnalysisMuMuNch.cxx:937
 AliAnalysisMuMuNch.cxx:938
 AliAnalysisMuMuNch.cxx:939
 AliAnalysisMuMuNch.cxx:940
 AliAnalysisMuMuNch.cxx:941
 AliAnalysisMuMuNch.cxx:942
 AliAnalysisMuMuNch.cxx:943
 AliAnalysisMuMuNch.cxx:944
 AliAnalysisMuMuNch.cxx:945
 AliAnalysisMuMuNch.cxx:946
 AliAnalysisMuMuNch.cxx:947
 AliAnalysisMuMuNch.cxx:948
 AliAnalysisMuMuNch.cxx:949
 AliAnalysisMuMuNch.cxx:950
 AliAnalysisMuMuNch.cxx:951
 AliAnalysisMuMuNch.cxx:952
 AliAnalysisMuMuNch.cxx:953
 AliAnalysisMuMuNch.cxx:954
 AliAnalysisMuMuNch.cxx:955
 AliAnalysisMuMuNch.cxx:956
 AliAnalysisMuMuNch.cxx:957
 AliAnalysisMuMuNch.cxx:958
 AliAnalysisMuMuNch.cxx:959
 AliAnalysisMuMuNch.cxx:960
 AliAnalysisMuMuNch.cxx:961
 AliAnalysisMuMuNch.cxx:962
 AliAnalysisMuMuNch.cxx:963
 AliAnalysisMuMuNch.cxx:964
 AliAnalysisMuMuNch.cxx:965
 AliAnalysisMuMuNch.cxx:966
 AliAnalysisMuMuNch.cxx:967
 AliAnalysisMuMuNch.cxx:968
 AliAnalysisMuMuNch.cxx:969
 AliAnalysisMuMuNch.cxx:970
 AliAnalysisMuMuNch.cxx:971
 AliAnalysisMuMuNch.cxx:972
 AliAnalysisMuMuNch.cxx:973
 AliAnalysisMuMuNch.cxx:974
 AliAnalysisMuMuNch.cxx:975
 AliAnalysisMuMuNch.cxx:976
 AliAnalysisMuMuNch.cxx:977
 AliAnalysisMuMuNch.cxx:978
 AliAnalysisMuMuNch.cxx:979
 AliAnalysisMuMuNch.cxx:980
 AliAnalysisMuMuNch.cxx:981
 AliAnalysisMuMuNch.cxx:982
 AliAnalysisMuMuNch.cxx:983
 AliAnalysisMuMuNch.cxx:984
 AliAnalysisMuMuNch.cxx:985
 AliAnalysisMuMuNch.cxx:986
 AliAnalysisMuMuNch.cxx:987
 AliAnalysisMuMuNch.cxx:988
 AliAnalysisMuMuNch.cxx:989
 AliAnalysisMuMuNch.cxx:990
 AliAnalysisMuMuNch.cxx:991
 AliAnalysisMuMuNch.cxx:992
 AliAnalysisMuMuNch.cxx:993
 AliAnalysisMuMuNch.cxx:994
 AliAnalysisMuMuNch.cxx:995
 AliAnalysisMuMuNch.cxx:996
 AliAnalysisMuMuNch.cxx:997
 AliAnalysisMuMuNch.cxx:998
 AliAnalysisMuMuNch.cxx:999
 AliAnalysisMuMuNch.cxx:1000
 AliAnalysisMuMuNch.cxx:1001
 AliAnalysisMuMuNch.cxx:1002
 AliAnalysisMuMuNch.cxx:1003
 AliAnalysisMuMuNch.cxx:1004
 AliAnalysisMuMuNch.cxx:1005
 AliAnalysisMuMuNch.cxx:1006
 AliAnalysisMuMuNch.cxx:1007
 AliAnalysisMuMuNch.cxx:1008
 AliAnalysisMuMuNch.cxx:1009
 AliAnalysisMuMuNch.cxx:1010
 AliAnalysisMuMuNch.cxx:1011
 AliAnalysisMuMuNch.cxx:1012
 AliAnalysisMuMuNch.cxx:1013
 AliAnalysisMuMuNch.cxx:1014
 AliAnalysisMuMuNch.cxx:1015
 AliAnalysisMuMuNch.cxx:1016
 AliAnalysisMuMuNch.cxx:1017
 AliAnalysisMuMuNch.cxx:1018
 AliAnalysisMuMuNch.cxx:1019
 AliAnalysisMuMuNch.cxx:1020
 AliAnalysisMuMuNch.cxx:1021
 AliAnalysisMuMuNch.cxx:1022
 AliAnalysisMuMuNch.cxx:1023
 AliAnalysisMuMuNch.cxx:1024
 AliAnalysisMuMuNch.cxx:1025
 AliAnalysisMuMuNch.cxx:1026
 AliAnalysisMuMuNch.cxx:1027
 AliAnalysisMuMuNch.cxx:1028
 AliAnalysisMuMuNch.cxx:1029
 AliAnalysisMuMuNch.cxx:1030
 AliAnalysisMuMuNch.cxx:1031
 AliAnalysisMuMuNch.cxx:1032
 AliAnalysisMuMuNch.cxx:1033
 AliAnalysisMuMuNch.cxx:1034
 AliAnalysisMuMuNch.cxx:1035
 AliAnalysisMuMuNch.cxx:1036
 AliAnalysisMuMuNch.cxx:1037
 AliAnalysisMuMuNch.cxx:1038
 AliAnalysisMuMuNch.cxx:1039
 AliAnalysisMuMuNch.cxx:1040
 AliAnalysisMuMuNch.cxx:1041
 AliAnalysisMuMuNch.cxx:1042
 AliAnalysisMuMuNch.cxx:1043
 AliAnalysisMuMuNch.cxx:1044
 AliAnalysisMuMuNch.cxx:1045
 AliAnalysisMuMuNch.cxx:1046
 AliAnalysisMuMuNch.cxx:1047
 AliAnalysisMuMuNch.cxx:1048
 AliAnalysisMuMuNch.cxx:1049
 AliAnalysisMuMuNch.cxx:1050
 AliAnalysisMuMuNch.cxx:1051
 AliAnalysisMuMuNch.cxx:1052
 AliAnalysisMuMuNch.cxx:1053
 AliAnalysisMuMuNch.cxx:1054
 AliAnalysisMuMuNch.cxx:1055
 AliAnalysisMuMuNch.cxx:1056
 AliAnalysisMuMuNch.cxx:1057
 AliAnalysisMuMuNch.cxx:1058
 AliAnalysisMuMuNch.cxx:1059
 AliAnalysisMuMuNch.cxx:1060
 AliAnalysisMuMuNch.cxx:1061
 AliAnalysisMuMuNch.cxx:1062
 AliAnalysisMuMuNch.cxx:1063
 AliAnalysisMuMuNch.cxx:1064
 AliAnalysisMuMuNch.cxx:1065
 AliAnalysisMuMuNch.cxx:1066
 AliAnalysisMuMuNch.cxx:1067
 AliAnalysisMuMuNch.cxx:1068
 AliAnalysisMuMuNch.cxx:1069
 AliAnalysisMuMuNch.cxx:1070
 AliAnalysisMuMuNch.cxx:1071
 AliAnalysisMuMuNch.cxx:1072
 AliAnalysisMuMuNch.cxx:1073
 AliAnalysisMuMuNch.cxx:1074
 AliAnalysisMuMuNch.cxx:1075
 AliAnalysisMuMuNch.cxx:1076
 AliAnalysisMuMuNch.cxx:1077
 AliAnalysisMuMuNch.cxx:1078
 AliAnalysisMuMuNch.cxx:1079
 AliAnalysisMuMuNch.cxx:1080
 AliAnalysisMuMuNch.cxx:1081
 AliAnalysisMuMuNch.cxx:1082
 AliAnalysisMuMuNch.cxx:1083
 AliAnalysisMuMuNch.cxx:1084
 AliAnalysisMuMuNch.cxx:1085
 AliAnalysisMuMuNch.cxx:1086
 AliAnalysisMuMuNch.cxx:1087
 AliAnalysisMuMuNch.cxx:1088
 AliAnalysisMuMuNch.cxx:1089
 AliAnalysisMuMuNch.cxx:1090
 AliAnalysisMuMuNch.cxx:1091
 AliAnalysisMuMuNch.cxx:1092
 AliAnalysisMuMuNch.cxx:1093
 AliAnalysisMuMuNch.cxx:1094
 AliAnalysisMuMuNch.cxx:1095
 AliAnalysisMuMuNch.cxx:1096
 AliAnalysisMuMuNch.cxx:1097
 AliAnalysisMuMuNch.cxx:1098
 AliAnalysisMuMuNch.cxx:1099
 AliAnalysisMuMuNch.cxx:1100
 AliAnalysisMuMuNch.cxx:1101
 AliAnalysisMuMuNch.cxx:1102
 AliAnalysisMuMuNch.cxx:1103
 AliAnalysisMuMuNch.cxx:1104
 AliAnalysisMuMuNch.cxx:1105
 AliAnalysisMuMuNch.cxx:1106
 AliAnalysisMuMuNch.cxx:1107
 AliAnalysisMuMuNch.cxx:1108
 AliAnalysisMuMuNch.cxx:1109
 AliAnalysisMuMuNch.cxx:1110
 AliAnalysisMuMuNch.cxx:1111
 AliAnalysisMuMuNch.cxx:1112
 AliAnalysisMuMuNch.cxx:1113
 AliAnalysisMuMuNch.cxx:1114
 AliAnalysisMuMuNch.cxx:1115
 AliAnalysisMuMuNch.cxx:1116
 AliAnalysisMuMuNch.cxx:1117
 AliAnalysisMuMuNch.cxx:1118
 AliAnalysisMuMuNch.cxx:1119
 AliAnalysisMuMuNch.cxx:1120
 AliAnalysisMuMuNch.cxx:1121
 AliAnalysisMuMuNch.cxx:1122
 AliAnalysisMuMuNch.cxx:1123
 AliAnalysisMuMuNch.cxx:1124
 AliAnalysisMuMuNch.cxx:1125
 AliAnalysisMuMuNch.cxx:1126
 AliAnalysisMuMuNch.cxx:1127
 AliAnalysisMuMuNch.cxx:1128
 AliAnalysisMuMuNch.cxx:1129
 AliAnalysisMuMuNch.cxx:1130
 AliAnalysisMuMuNch.cxx:1131
 AliAnalysisMuMuNch.cxx:1132
 AliAnalysisMuMuNch.cxx:1133
 AliAnalysisMuMuNch.cxx:1134
 AliAnalysisMuMuNch.cxx:1135
 AliAnalysisMuMuNch.cxx:1136
 AliAnalysisMuMuNch.cxx:1137
 AliAnalysisMuMuNch.cxx:1138
 AliAnalysisMuMuNch.cxx:1139
 AliAnalysisMuMuNch.cxx:1140
 AliAnalysisMuMuNch.cxx:1141
 AliAnalysisMuMuNch.cxx:1142
 AliAnalysisMuMuNch.cxx:1143
 AliAnalysisMuMuNch.cxx:1144
 AliAnalysisMuMuNch.cxx:1145
 AliAnalysisMuMuNch.cxx:1146
 AliAnalysisMuMuNch.cxx:1147
 AliAnalysisMuMuNch.cxx:1148
 AliAnalysisMuMuNch.cxx:1149
 AliAnalysisMuMuNch.cxx:1150
 AliAnalysisMuMuNch.cxx:1151
 AliAnalysisMuMuNch.cxx:1152
 AliAnalysisMuMuNch.cxx:1153
 AliAnalysisMuMuNch.cxx:1154
 AliAnalysisMuMuNch.cxx:1155
 AliAnalysisMuMuNch.cxx:1156
 AliAnalysisMuMuNch.cxx:1157
 AliAnalysisMuMuNch.cxx:1158
 AliAnalysisMuMuNch.cxx:1159
 AliAnalysisMuMuNch.cxx:1160
 AliAnalysisMuMuNch.cxx:1161
 AliAnalysisMuMuNch.cxx:1162
 AliAnalysisMuMuNch.cxx:1163
 AliAnalysisMuMuNch.cxx:1164
 AliAnalysisMuMuNch.cxx:1165
 AliAnalysisMuMuNch.cxx:1166
 AliAnalysisMuMuNch.cxx:1167
 AliAnalysisMuMuNch.cxx:1168
 AliAnalysisMuMuNch.cxx:1169
 AliAnalysisMuMuNch.cxx:1170
 AliAnalysisMuMuNch.cxx:1171
 AliAnalysisMuMuNch.cxx:1172
 AliAnalysisMuMuNch.cxx:1173
 AliAnalysisMuMuNch.cxx:1174
 AliAnalysisMuMuNch.cxx:1175
 AliAnalysisMuMuNch.cxx:1176
 AliAnalysisMuMuNch.cxx:1177
 AliAnalysisMuMuNch.cxx:1178
 AliAnalysisMuMuNch.cxx:1179
 AliAnalysisMuMuNch.cxx:1180
 AliAnalysisMuMuNch.cxx:1181
 AliAnalysisMuMuNch.cxx:1182
 AliAnalysisMuMuNch.cxx:1183
 AliAnalysisMuMuNch.cxx:1184
 AliAnalysisMuMuNch.cxx:1185
 AliAnalysisMuMuNch.cxx:1186
 AliAnalysisMuMuNch.cxx:1187
 AliAnalysisMuMuNch.cxx:1188
 AliAnalysisMuMuNch.cxx:1189
 AliAnalysisMuMuNch.cxx:1190
 AliAnalysisMuMuNch.cxx:1191
 AliAnalysisMuMuNch.cxx:1192
 AliAnalysisMuMuNch.cxx:1193
 AliAnalysisMuMuNch.cxx:1194
 AliAnalysisMuMuNch.cxx:1195
 AliAnalysisMuMuNch.cxx:1196
 AliAnalysisMuMuNch.cxx:1197
 AliAnalysisMuMuNch.cxx:1198
 AliAnalysisMuMuNch.cxx:1199
 AliAnalysisMuMuNch.cxx:1200
 AliAnalysisMuMuNch.cxx:1201
 AliAnalysisMuMuNch.cxx:1202
 AliAnalysisMuMuNch.cxx:1203
 AliAnalysisMuMuNch.cxx:1204
 AliAnalysisMuMuNch.cxx:1205
 AliAnalysisMuMuNch.cxx:1206
 AliAnalysisMuMuNch.cxx:1207
 AliAnalysisMuMuNch.cxx:1208
 AliAnalysisMuMuNch.cxx:1209
 AliAnalysisMuMuNch.cxx:1210
 AliAnalysisMuMuNch.cxx:1211
 AliAnalysisMuMuNch.cxx:1212
 AliAnalysisMuMuNch.cxx:1213
 AliAnalysisMuMuNch.cxx:1214
 AliAnalysisMuMuNch.cxx:1215
 AliAnalysisMuMuNch.cxx:1216
 AliAnalysisMuMuNch.cxx:1217
 AliAnalysisMuMuNch.cxx:1218
 AliAnalysisMuMuNch.cxx:1219
 AliAnalysisMuMuNch.cxx:1220
 AliAnalysisMuMuNch.cxx:1221
 AliAnalysisMuMuNch.cxx:1222
 AliAnalysisMuMuNch.cxx:1223
 AliAnalysisMuMuNch.cxx:1224
 AliAnalysisMuMuNch.cxx:1225
 AliAnalysisMuMuNch.cxx:1226
 AliAnalysisMuMuNch.cxx:1227
 AliAnalysisMuMuNch.cxx:1228
 AliAnalysisMuMuNch.cxx:1229
 AliAnalysisMuMuNch.cxx:1230
 AliAnalysisMuMuNch.cxx:1231
 AliAnalysisMuMuNch.cxx:1232
 AliAnalysisMuMuNch.cxx:1233
 AliAnalysisMuMuNch.cxx:1234
 AliAnalysisMuMuNch.cxx:1235
 AliAnalysisMuMuNch.cxx:1236
 AliAnalysisMuMuNch.cxx:1237
 AliAnalysisMuMuNch.cxx:1238
 AliAnalysisMuMuNch.cxx:1239
 AliAnalysisMuMuNch.cxx:1240
 AliAnalysisMuMuNch.cxx:1241
 AliAnalysisMuMuNch.cxx:1242
 AliAnalysisMuMuNch.cxx:1243
 AliAnalysisMuMuNch.cxx:1244
 AliAnalysisMuMuNch.cxx:1245
 AliAnalysisMuMuNch.cxx:1246
 AliAnalysisMuMuNch.cxx:1247
 AliAnalysisMuMuNch.cxx:1248
 AliAnalysisMuMuNch.cxx:1249
 AliAnalysisMuMuNch.cxx:1250
 AliAnalysisMuMuNch.cxx:1251
 AliAnalysisMuMuNch.cxx:1252
 AliAnalysisMuMuNch.cxx:1253
 AliAnalysisMuMuNch.cxx:1254
 AliAnalysisMuMuNch.cxx:1255
 AliAnalysisMuMuNch.cxx:1256
 AliAnalysisMuMuNch.cxx:1257
 AliAnalysisMuMuNch.cxx:1258
 AliAnalysisMuMuNch.cxx:1259
 AliAnalysisMuMuNch.cxx:1260
 AliAnalysisMuMuNch.cxx:1261
 AliAnalysisMuMuNch.cxx:1262
 AliAnalysisMuMuNch.cxx:1263
 AliAnalysisMuMuNch.cxx:1264
 AliAnalysisMuMuNch.cxx:1265
 AliAnalysisMuMuNch.cxx:1266
 AliAnalysisMuMuNch.cxx:1267
 AliAnalysisMuMuNch.cxx:1268
 AliAnalysisMuMuNch.cxx:1269
 AliAnalysisMuMuNch.cxx:1270
 AliAnalysisMuMuNch.cxx:1271
 AliAnalysisMuMuNch.cxx:1272
 AliAnalysisMuMuNch.cxx:1273
 AliAnalysisMuMuNch.cxx:1274
 AliAnalysisMuMuNch.cxx:1275
 AliAnalysisMuMuNch.cxx:1276
 AliAnalysisMuMuNch.cxx:1277
 AliAnalysisMuMuNch.cxx:1278
 AliAnalysisMuMuNch.cxx:1279
 AliAnalysisMuMuNch.cxx:1280
 AliAnalysisMuMuNch.cxx:1281
 AliAnalysisMuMuNch.cxx:1282
 AliAnalysisMuMuNch.cxx:1283
 AliAnalysisMuMuNch.cxx:1284
 AliAnalysisMuMuNch.cxx:1285
 AliAnalysisMuMuNch.cxx:1286
 AliAnalysisMuMuNch.cxx:1287
 AliAnalysisMuMuNch.cxx:1288
 AliAnalysisMuMuNch.cxx:1289
 AliAnalysisMuMuNch.cxx:1290
 AliAnalysisMuMuNch.cxx:1291
 AliAnalysisMuMuNch.cxx:1292
 AliAnalysisMuMuNch.cxx:1293
 AliAnalysisMuMuNch.cxx:1294
 AliAnalysisMuMuNch.cxx:1295
 AliAnalysisMuMuNch.cxx:1296
 AliAnalysisMuMuNch.cxx:1297
 AliAnalysisMuMuNch.cxx:1298
 AliAnalysisMuMuNch.cxx:1299
 AliAnalysisMuMuNch.cxx:1300
 AliAnalysisMuMuNch.cxx:1301
 AliAnalysisMuMuNch.cxx:1302
 AliAnalysisMuMuNch.cxx:1303
 AliAnalysisMuMuNch.cxx:1304
 AliAnalysisMuMuNch.cxx:1305
 AliAnalysisMuMuNch.cxx:1306
 AliAnalysisMuMuNch.cxx:1307
 AliAnalysisMuMuNch.cxx:1308
 AliAnalysisMuMuNch.cxx:1309
 AliAnalysisMuMuNch.cxx:1310
 AliAnalysisMuMuNch.cxx:1311
 AliAnalysisMuMuNch.cxx:1312
 AliAnalysisMuMuNch.cxx:1313
 AliAnalysisMuMuNch.cxx:1314
 AliAnalysisMuMuNch.cxx:1315
 AliAnalysisMuMuNch.cxx:1316
 AliAnalysisMuMuNch.cxx:1317
 AliAnalysisMuMuNch.cxx:1318
 AliAnalysisMuMuNch.cxx:1319
 AliAnalysisMuMuNch.cxx:1320
 AliAnalysisMuMuNch.cxx:1321
 AliAnalysisMuMuNch.cxx:1322
 AliAnalysisMuMuNch.cxx:1323
 AliAnalysisMuMuNch.cxx:1324
 AliAnalysisMuMuNch.cxx:1325
 AliAnalysisMuMuNch.cxx:1326
 AliAnalysisMuMuNch.cxx:1327
 AliAnalysisMuMuNch.cxx:1328
 AliAnalysisMuMuNch.cxx:1329
 AliAnalysisMuMuNch.cxx:1330
 AliAnalysisMuMuNch.cxx:1331
 AliAnalysisMuMuNch.cxx:1332
 AliAnalysisMuMuNch.cxx:1333
 AliAnalysisMuMuNch.cxx:1334
 AliAnalysisMuMuNch.cxx:1335
 AliAnalysisMuMuNch.cxx:1336
 AliAnalysisMuMuNch.cxx:1337
 AliAnalysisMuMuNch.cxx:1338
 AliAnalysisMuMuNch.cxx:1339
 AliAnalysisMuMuNch.cxx:1340
 AliAnalysisMuMuNch.cxx:1341
 AliAnalysisMuMuNch.cxx:1342
 AliAnalysisMuMuNch.cxx:1343
 AliAnalysisMuMuNch.cxx:1344
 AliAnalysisMuMuNch.cxx:1345
 AliAnalysisMuMuNch.cxx:1346
 AliAnalysisMuMuNch.cxx:1347
 AliAnalysisMuMuNch.cxx:1348
 AliAnalysisMuMuNch.cxx:1349
 AliAnalysisMuMuNch.cxx:1350
 AliAnalysisMuMuNch.cxx:1351
 AliAnalysisMuMuNch.cxx:1352
 AliAnalysisMuMuNch.cxx:1353
 AliAnalysisMuMuNch.cxx:1354
 AliAnalysisMuMuNch.cxx:1355
 AliAnalysisMuMuNch.cxx:1356
 AliAnalysisMuMuNch.cxx:1357
 AliAnalysisMuMuNch.cxx:1358
 AliAnalysisMuMuNch.cxx:1359
 AliAnalysisMuMuNch.cxx:1360
 AliAnalysisMuMuNch.cxx:1361
 AliAnalysisMuMuNch.cxx:1362
 AliAnalysisMuMuNch.cxx:1363
 AliAnalysisMuMuNch.cxx:1364
 AliAnalysisMuMuNch.cxx:1365
 AliAnalysisMuMuNch.cxx:1366
 AliAnalysisMuMuNch.cxx:1367
 AliAnalysisMuMuNch.cxx:1368
 AliAnalysisMuMuNch.cxx:1369
 AliAnalysisMuMuNch.cxx:1370
 AliAnalysisMuMuNch.cxx:1371
 AliAnalysisMuMuNch.cxx:1372
 AliAnalysisMuMuNch.cxx:1373
 AliAnalysisMuMuNch.cxx:1374
 AliAnalysisMuMuNch.cxx:1375
 AliAnalysisMuMuNch.cxx:1376
 AliAnalysisMuMuNch.cxx:1377
 AliAnalysisMuMuNch.cxx:1378
 AliAnalysisMuMuNch.cxx:1379
 AliAnalysisMuMuNch.cxx:1380
 AliAnalysisMuMuNch.cxx:1381
 AliAnalysisMuMuNch.cxx:1382
 AliAnalysisMuMuNch.cxx:1383
 AliAnalysisMuMuNch.cxx:1384
 AliAnalysisMuMuNch.cxx:1385
 AliAnalysisMuMuNch.cxx:1386
 AliAnalysisMuMuNch.cxx:1387
 AliAnalysisMuMuNch.cxx:1388
 AliAnalysisMuMuNch.cxx:1389
 AliAnalysisMuMuNch.cxx:1390
 AliAnalysisMuMuNch.cxx:1391
 AliAnalysisMuMuNch.cxx:1392
 AliAnalysisMuMuNch.cxx:1393
 AliAnalysisMuMuNch.cxx:1394
 AliAnalysisMuMuNch.cxx:1395
 AliAnalysisMuMuNch.cxx:1396
 AliAnalysisMuMuNch.cxx:1397
 AliAnalysisMuMuNch.cxx:1398
 AliAnalysisMuMuNch.cxx:1399
 AliAnalysisMuMuNch.cxx:1400
 AliAnalysisMuMuNch.cxx:1401
 AliAnalysisMuMuNch.cxx:1402
 AliAnalysisMuMuNch.cxx:1403
 AliAnalysisMuMuNch.cxx:1404
 AliAnalysisMuMuNch.cxx:1405
 AliAnalysisMuMuNch.cxx:1406
 AliAnalysisMuMuNch.cxx:1407
 AliAnalysisMuMuNch.cxx:1408
 AliAnalysisMuMuNch.cxx:1409
 AliAnalysisMuMuNch.cxx:1410
 AliAnalysisMuMuNch.cxx:1411
 AliAnalysisMuMuNch.cxx:1412
 AliAnalysisMuMuNch.cxx:1413
 AliAnalysisMuMuNch.cxx:1414
 AliAnalysisMuMuNch.cxx:1415
 AliAnalysisMuMuNch.cxx:1416
 AliAnalysisMuMuNch.cxx:1417
 AliAnalysisMuMuNch.cxx:1418
 AliAnalysisMuMuNch.cxx:1419
 AliAnalysisMuMuNch.cxx:1420
 AliAnalysisMuMuNch.cxx:1421
 AliAnalysisMuMuNch.cxx:1422
 AliAnalysisMuMuNch.cxx:1423
 AliAnalysisMuMuNch.cxx:1424
 AliAnalysisMuMuNch.cxx:1425
 AliAnalysisMuMuNch.cxx:1426
 AliAnalysisMuMuNch.cxx:1427
 AliAnalysisMuMuNch.cxx:1428
 AliAnalysisMuMuNch.cxx:1429
 AliAnalysisMuMuNch.cxx:1430
 AliAnalysisMuMuNch.cxx:1431
 AliAnalysisMuMuNch.cxx:1432
 AliAnalysisMuMuNch.cxx:1433
 AliAnalysisMuMuNch.cxx:1434
 AliAnalysisMuMuNch.cxx:1435
 AliAnalysisMuMuNch.cxx:1436
 AliAnalysisMuMuNch.cxx:1437
 AliAnalysisMuMuNch.cxx:1438
 AliAnalysisMuMuNch.cxx:1439
 AliAnalysisMuMuNch.cxx:1440
 AliAnalysisMuMuNch.cxx:1441
 AliAnalysisMuMuNch.cxx:1442
 AliAnalysisMuMuNch.cxx:1443
 AliAnalysisMuMuNch.cxx:1444
 AliAnalysisMuMuNch.cxx:1445
 AliAnalysisMuMuNch.cxx:1446
 AliAnalysisMuMuNch.cxx:1447
 AliAnalysisMuMuNch.cxx:1448
 AliAnalysisMuMuNch.cxx:1449
 AliAnalysisMuMuNch.cxx:1450
 AliAnalysisMuMuNch.cxx:1451
 AliAnalysisMuMuNch.cxx:1452
 AliAnalysisMuMuNch.cxx:1453
 AliAnalysisMuMuNch.cxx:1454
 AliAnalysisMuMuNch.cxx:1455
 AliAnalysisMuMuNch.cxx:1456
 AliAnalysisMuMuNch.cxx:1457
 AliAnalysisMuMuNch.cxx:1458
 AliAnalysisMuMuNch.cxx:1459
 AliAnalysisMuMuNch.cxx:1460
 AliAnalysisMuMuNch.cxx:1461
 AliAnalysisMuMuNch.cxx:1462
 AliAnalysisMuMuNch.cxx:1463
 AliAnalysisMuMuNch.cxx:1464
 AliAnalysisMuMuNch.cxx:1465
 AliAnalysisMuMuNch.cxx:1466
 AliAnalysisMuMuNch.cxx:1467
 AliAnalysisMuMuNch.cxx:1468
 AliAnalysisMuMuNch.cxx:1469
 AliAnalysisMuMuNch.cxx:1470
 AliAnalysisMuMuNch.cxx:1471
 AliAnalysisMuMuNch.cxx:1472
 AliAnalysisMuMuNch.cxx:1473
 AliAnalysisMuMuNch.cxx:1474
 AliAnalysisMuMuNch.cxx:1475
 AliAnalysisMuMuNch.cxx:1476
 AliAnalysisMuMuNch.cxx:1477
 AliAnalysisMuMuNch.cxx:1478
 AliAnalysisMuMuNch.cxx:1479
 AliAnalysisMuMuNch.cxx:1480
 AliAnalysisMuMuNch.cxx:1481
 AliAnalysisMuMuNch.cxx:1482
 AliAnalysisMuMuNch.cxx:1483
 AliAnalysisMuMuNch.cxx:1484
 AliAnalysisMuMuNch.cxx:1485
 AliAnalysisMuMuNch.cxx:1486
 AliAnalysisMuMuNch.cxx:1487
 AliAnalysisMuMuNch.cxx:1488
 AliAnalysisMuMuNch.cxx:1489
 AliAnalysisMuMuNch.cxx:1490
 AliAnalysisMuMuNch.cxx:1491
 AliAnalysisMuMuNch.cxx:1492
 AliAnalysisMuMuNch.cxx:1493
 AliAnalysisMuMuNch.cxx:1494
 AliAnalysisMuMuNch.cxx:1495
 AliAnalysisMuMuNch.cxx:1496
 AliAnalysisMuMuNch.cxx:1497
 AliAnalysisMuMuNch.cxx:1498
 AliAnalysisMuMuNch.cxx:1499
 AliAnalysisMuMuNch.cxx:1500
 AliAnalysisMuMuNch.cxx:1501
 AliAnalysisMuMuNch.cxx:1502
 AliAnalysisMuMuNch.cxx:1503
 AliAnalysisMuMuNch.cxx:1504
 AliAnalysisMuMuNch.cxx:1505
 AliAnalysisMuMuNch.cxx:1506
 AliAnalysisMuMuNch.cxx:1507
 AliAnalysisMuMuNch.cxx:1508
 AliAnalysisMuMuNch.cxx:1509
 AliAnalysisMuMuNch.cxx:1510
 AliAnalysisMuMuNch.cxx:1511
 AliAnalysisMuMuNch.cxx:1512
 AliAnalysisMuMuNch.cxx:1513
 AliAnalysisMuMuNch.cxx:1514
 AliAnalysisMuMuNch.cxx:1515
 AliAnalysisMuMuNch.cxx:1516
 AliAnalysisMuMuNch.cxx:1517
 AliAnalysisMuMuNch.cxx:1518
 AliAnalysisMuMuNch.cxx:1519
 AliAnalysisMuMuNch.cxx:1520
 AliAnalysisMuMuNch.cxx:1521
 AliAnalysisMuMuNch.cxx:1522
 AliAnalysisMuMuNch.cxx:1523
 AliAnalysisMuMuNch.cxx:1524
 AliAnalysisMuMuNch.cxx:1525
 AliAnalysisMuMuNch.cxx:1526
 AliAnalysisMuMuNch.cxx:1527
 AliAnalysisMuMuNch.cxx:1528
 AliAnalysisMuMuNch.cxx:1529
 AliAnalysisMuMuNch.cxx:1530
 AliAnalysisMuMuNch.cxx:1531
 AliAnalysisMuMuNch.cxx:1532
 AliAnalysisMuMuNch.cxx:1533
 AliAnalysisMuMuNch.cxx:1534
 AliAnalysisMuMuNch.cxx:1535
 AliAnalysisMuMuNch.cxx:1536
 AliAnalysisMuMuNch.cxx:1537
 AliAnalysisMuMuNch.cxx:1538
 AliAnalysisMuMuNch.cxx:1539
 AliAnalysisMuMuNch.cxx:1540
 AliAnalysisMuMuNch.cxx:1541
 AliAnalysisMuMuNch.cxx:1542
 AliAnalysisMuMuNch.cxx:1543
 AliAnalysisMuMuNch.cxx:1544
 AliAnalysisMuMuNch.cxx:1545
 AliAnalysisMuMuNch.cxx:1546
 AliAnalysisMuMuNch.cxx:1547
 AliAnalysisMuMuNch.cxx:1548
 AliAnalysisMuMuNch.cxx:1549
 AliAnalysisMuMuNch.cxx:1550
 AliAnalysisMuMuNch.cxx:1551
 AliAnalysisMuMuNch.cxx:1552
 AliAnalysisMuMuNch.cxx:1553
 AliAnalysisMuMuNch.cxx:1554
 AliAnalysisMuMuNch.cxx:1555
 AliAnalysisMuMuNch.cxx:1556
 AliAnalysisMuMuNch.cxx:1557
 AliAnalysisMuMuNch.cxx:1558
 AliAnalysisMuMuNch.cxx:1559
 AliAnalysisMuMuNch.cxx:1560
 AliAnalysisMuMuNch.cxx:1561
 AliAnalysisMuMuNch.cxx:1562
 AliAnalysisMuMuNch.cxx:1563
 AliAnalysisMuMuNch.cxx:1564
 AliAnalysisMuMuNch.cxx:1565
 AliAnalysisMuMuNch.cxx:1566
 AliAnalysisMuMuNch.cxx:1567
 AliAnalysisMuMuNch.cxx:1568
 AliAnalysisMuMuNch.cxx:1569
 AliAnalysisMuMuNch.cxx:1570
 AliAnalysisMuMuNch.cxx:1571
 AliAnalysisMuMuNch.cxx:1572
 AliAnalysisMuMuNch.cxx:1573
 AliAnalysisMuMuNch.cxx:1574
 AliAnalysisMuMuNch.cxx:1575
 AliAnalysisMuMuNch.cxx:1576
 AliAnalysisMuMuNch.cxx:1577
 AliAnalysisMuMuNch.cxx:1578
 AliAnalysisMuMuNch.cxx:1579
 AliAnalysisMuMuNch.cxx:1580
 AliAnalysisMuMuNch.cxx:1581
 AliAnalysisMuMuNch.cxx:1582
 AliAnalysisMuMuNch.cxx:1583
 AliAnalysisMuMuNch.cxx:1584
 AliAnalysisMuMuNch.cxx:1585
 AliAnalysisMuMuNch.cxx:1586
 AliAnalysisMuMuNch.cxx:1587
 AliAnalysisMuMuNch.cxx:1588
 AliAnalysisMuMuNch.cxx:1589
 AliAnalysisMuMuNch.cxx:1590
 AliAnalysisMuMuNch.cxx:1591
 AliAnalysisMuMuNch.cxx:1592
 AliAnalysisMuMuNch.cxx:1593
 AliAnalysisMuMuNch.cxx:1594
 AliAnalysisMuMuNch.cxx:1595
 AliAnalysisMuMuNch.cxx:1596
 AliAnalysisMuMuNch.cxx:1597
 AliAnalysisMuMuNch.cxx:1598
 AliAnalysisMuMuNch.cxx:1599
 AliAnalysisMuMuNch.cxx:1600
 AliAnalysisMuMuNch.cxx:1601
 AliAnalysisMuMuNch.cxx:1602
 AliAnalysisMuMuNch.cxx:1603
 AliAnalysisMuMuNch.cxx:1604
 AliAnalysisMuMuNch.cxx:1605
 AliAnalysisMuMuNch.cxx:1606
 AliAnalysisMuMuNch.cxx:1607
 AliAnalysisMuMuNch.cxx:1608
 AliAnalysisMuMuNch.cxx:1609
 AliAnalysisMuMuNch.cxx:1610
 AliAnalysisMuMuNch.cxx:1611
 AliAnalysisMuMuNch.cxx:1612
 AliAnalysisMuMuNch.cxx:1613
 AliAnalysisMuMuNch.cxx:1614
 AliAnalysisMuMuNch.cxx:1615
 AliAnalysisMuMuNch.cxx:1616
 AliAnalysisMuMuNch.cxx:1617
 AliAnalysisMuMuNch.cxx:1618
 AliAnalysisMuMuNch.cxx:1619
 AliAnalysisMuMuNch.cxx:1620
 AliAnalysisMuMuNch.cxx:1621
 AliAnalysisMuMuNch.cxx:1622
 AliAnalysisMuMuNch.cxx:1623
 AliAnalysisMuMuNch.cxx:1624
 AliAnalysisMuMuNch.cxx:1625
 AliAnalysisMuMuNch.cxx:1626
 AliAnalysisMuMuNch.cxx:1627
 AliAnalysisMuMuNch.cxx:1628
 AliAnalysisMuMuNch.cxx:1629
 AliAnalysisMuMuNch.cxx:1630
 AliAnalysisMuMuNch.cxx:1631
 AliAnalysisMuMuNch.cxx:1632
 AliAnalysisMuMuNch.cxx:1633
 AliAnalysisMuMuNch.cxx:1634
 AliAnalysisMuMuNch.cxx:1635
 AliAnalysisMuMuNch.cxx:1636
 AliAnalysisMuMuNch.cxx:1637
 AliAnalysisMuMuNch.cxx:1638
 AliAnalysisMuMuNch.cxx:1639
 AliAnalysisMuMuNch.cxx:1640
 AliAnalysisMuMuNch.cxx:1641
 AliAnalysisMuMuNch.cxx:1642
 AliAnalysisMuMuNch.cxx:1643
 AliAnalysisMuMuNch.cxx:1644
 AliAnalysisMuMuNch.cxx:1645
 AliAnalysisMuMuNch.cxx:1646
 AliAnalysisMuMuNch.cxx:1647
 AliAnalysisMuMuNch.cxx:1648
 AliAnalysisMuMuNch.cxx:1649
 AliAnalysisMuMuNch.cxx:1650
 AliAnalysisMuMuNch.cxx:1651
 AliAnalysisMuMuNch.cxx:1652
 AliAnalysisMuMuNch.cxx:1653
 AliAnalysisMuMuNch.cxx:1654
 AliAnalysisMuMuNch.cxx:1655
 AliAnalysisMuMuNch.cxx:1656
 AliAnalysisMuMuNch.cxx:1657
 AliAnalysisMuMuNch.cxx:1658
 AliAnalysisMuMuNch.cxx:1659
 AliAnalysisMuMuNch.cxx:1660
 AliAnalysisMuMuNch.cxx:1661
 AliAnalysisMuMuNch.cxx:1662
 AliAnalysisMuMuNch.cxx:1663
 AliAnalysisMuMuNch.cxx:1664
 AliAnalysisMuMuNch.cxx:1665
 AliAnalysisMuMuNch.cxx:1666
 AliAnalysisMuMuNch.cxx:1667
 AliAnalysisMuMuNch.cxx:1668
 AliAnalysisMuMuNch.cxx:1669
 AliAnalysisMuMuNch.cxx:1670
 AliAnalysisMuMuNch.cxx:1671
 AliAnalysisMuMuNch.cxx:1672
 AliAnalysisMuMuNch.cxx:1673
 AliAnalysisMuMuNch.cxx:1674
 AliAnalysisMuMuNch.cxx:1675
 AliAnalysisMuMuNch.cxx:1676
 AliAnalysisMuMuNch.cxx:1677
 AliAnalysisMuMuNch.cxx:1678
 AliAnalysisMuMuNch.cxx:1679
 AliAnalysisMuMuNch.cxx:1680
 AliAnalysisMuMuNch.cxx:1681
 AliAnalysisMuMuNch.cxx:1682
 AliAnalysisMuMuNch.cxx:1683
 AliAnalysisMuMuNch.cxx:1684
 AliAnalysisMuMuNch.cxx:1685
 AliAnalysisMuMuNch.cxx:1686
 AliAnalysisMuMuNch.cxx:1687
 AliAnalysisMuMuNch.cxx:1688
 AliAnalysisMuMuNch.cxx:1689
 AliAnalysisMuMuNch.cxx:1690
 AliAnalysisMuMuNch.cxx:1691
 AliAnalysisMuMuNch.cxx:1692
 AliAnalysisMuMuNch.cxx:1693
 AliAnalysisMuMuNch.cxx:1694
 AliAnalysisMuMuNch.cxx:1695
 AliAnalysisMuMuNch.cxx:1696
 AliAnalysisMuMuNch.cxx:1697
 AliAnalysisMuMuNch.cxx:1698
 AliAnalysisMuMuNch.cxx:1699
 AliAnalysisMuMuNch.cxx:1700
 AliAnalysisMuMuNch.cxx:1701
 AliAnalysisMuMuNch.cxx:1702
 AliAnalysisMuMuNch.cxx:1703
 AliAnalysisMuMuNch.cxx:1704
 AliAnalysisMuMuNch.cxx:1705
 AliAnalysisMuMuNch.cxx:1706
 AliAnalysisMuMuNch.cxx:1707
 AliAnalysisMuMuNch.cxx:1708
 AliAnalysisMuMuNch.cxx:1709
 AliAnalysisMuMuNch.cxx:1710
 AliAnalysisMuMuNch.cxx:1711
 AliAnalysisMuMuNch.cxx:1712
 AliAnalysisMuMuNch.cxx:1713
 AliAnalysisMuMuNch.cxx:1714
 AliAnalysisMuMuNch.cxx:1715
 AliAnalysisMuMuNch.cxx:1716
 AliAnalysisMuMuNch.cxx:1717
 AliAnalysisMuMuNch.cxx:1718
 AliAnalysisMuMuNch.cxx:1719
 AliAnalysisMuMuNch.cxx:1720
 AliAnalysisMuMuNch.cxx:1721
 AliAnalysisMuMuNch.cxx:1722
 AliAnalysisMuMuNch.cxx:1723
 AliAnalysisMuMuNch.cxx:1724
 AliAnalysisMuMuNch.cxx:1725
 AliAnalysisMuMuNch.cxx:1726
 AliAnalysisMuMuNch.cxx:1727
 AliAnalysisMuMuNch.cxx:1728
 AliAnalysisMuMuNch.cxx:1729
 AliAnalysisMuMuNch.cxx:1730
 AliAnalysisMuMuNch.cxx:1731
 AliAnalysisMuMuNch.cxx:1732
 AliAnalysisMuMuNch.cxx:1733
 AliAnalysisMuMuNch.cxx:1734
 AliAnalysisMuMuNch.cxx:1735
 AliAnalysisMuMuNch.cxx:1736
 AliAnalysisMuMuNch.cxx:1737
 AliAnalysisMuMuNch.cxx:1738
 AliAnalysisMuMuNch.cxx:1739
 AliAnalysisMuMuNch.cxx:1740
 AliAnalysisMuMuNch.cxx:1741
 AliAnalysisMuMuNch.cxx:1742
 AliAnalysisMuMuNch.cxx:1743
 AliAnalysisMuMuNch.cxx:1744
 AliAnalysisMuMuNch.cxx:1745
 AliAnalysisMuMuNch.cxx:1746
 AliAnalysisMuMuNch.cxx:1747
 AliAnalysisMuMuNch.cxx:1748
 AliAnalysisMuMuNch.cxx:1749
 AliAnalysisMuMuNch.cxx:1750
 AliAnalysisMuMuNch.cxx:1751
 AliAnalysisMuMuNch.cxx:1752
 AliAnalysisMuMuNch.cxx:1753
 AliAnalysisMuMuNch.cxx:1754
 AliAnalysisMuMuNch.cxx:1755
 AliAnalysisMuMuNch.cxx:1756
 AliAnalysisMuMuNch.cxx:1757
 AliAnalysisMuMuNch.cxx:1758
 AliAnalysisMuMuNch.cxx:1759
 AliAnalysisMuMuNch.cxx:1760
 AliAnalysisMuMuNch.cxx:1761
 AliAnalysisMuMuNch.cxx:1762
 AliAnalysisMuMuNch.cxx:1763
 AliAnalysisMuMuNch.cxx:1764
 AliAnalysisMuMuNch.cxx:1765
 AliAnalysisMuMuNch.cxx:1766
 AliAnalysisMuMuNch.cxx:1767
 AliAnalysisMuMuNch.cxx:1768
 AliAnalysisMuMuNch.cxx:1769
 AliAnalysisMuMuNch.cxx:1770
 AliAnalysisMuMuNch.cxx:1771
 AliAnalysisMuMuNch.cxx:1772
 AliAnalysisMuMuNch.cxx:1773
 AliAnalysisMuMuNch.cxx:1774
 AliAnalysisMuMuNch.cxx:1775
 AliAnalysisMuMuNch.cxx:1776
 AliAnalysisMuMuNch.cxx:1777
 AliAnalysisMuMuNch.cxx:1778
 AliAnalysisMuMuNch.cxx:1779
 AliAnalysisMuMuNch.cxx:1780
 AliAnalysisMuMuNch.cxx:1781
 AliAnalysisMuMuNch.cxx:1782
 AliAnalysisMuMuNch.cxx:1783
 AliAnalysisMuMuNch.cxx:1784
 AliAnalysisMuMuNch.cxx:1785
 AliAnalysisMuMuNch.cxx:1786
 AliAnalysisMuMuNch.cxx:1787
 AliAnalysisMuMuNch.cxx:1788
 AliAnalysisMuMuNch.cxx:1789
 AliAnalysisMuMuNch.cxx:1790
 AliAnalysisMuMuNch.cxx:1791
 AliAnalysisMuMuNch.cxx:1792
 AliAnalysisMuMuNch.cxx:1793
 AliAnalysisMuMuNch.cxx:1794
 AliAnalysisMuMuNch.cxx:1795
 AliAnalysisMuMuNch.cxx:1796
 AliAnalysisMuMuNch.cxx:1797
 AliAnalysisMuMuNch.cxx:1798
 AliAnalysisMuMuNch.cxx:1799
 AliAnalysisMuMuNch.cxx:1800
 AliAnalysisMuMuNch.cxx:1801
 AliAnalysisMuMuNch.cxx:1802
 AliAnalysisMuMuNch.cxx:1803
 AliAnalysisMuMuNch.cxx:1804
 AliAnalysisMuMuNch.cxx:1805
 AliAnalysisMuMuNch.cxx:1806
 AliAnalysisMuMuNch.cxx:1807
 AliAnalysisMuMuNch.cxx:1808
 AliAnalysisMuMuNch.cxx:1809
 AliAnalysisMuMuNch.cxx:1810
 AliAnalysisMuMuNch.cxx:1811
 AliAnalysisMuMuNch.cxx:1812
 AliAnalysisMuMuNch.cxx:1813
 AliAnalysisMuMuNch.cxx:1814
 AliAnalysisMuMuNch.cxx:1815
 AliAnalysisMuMuNch.cxx:1816
 AliAnalysisMuMuNch.cxx:1817
 AliAnalysisMuMuNch.cxx:1818
 AliAnalysisMuMuNch.cxx:1819
 AliAnalysisMuMuNch.cxx:1820
 AliAnalysisMuMuNch.cxx:1821
 AliAnalysisMuMuNch.cxx:1822
 AliAnalysisMuMuNch.cxx:1823
 AliAnalysisMuMuNch.cxx:1824
 AliAnalysisMuMuNch.cxx:1825
 AliAnalysisMuMuNch.cxx:1826
 AliAnalysisMuMuNch.cxx:1827
 AliAnalysisMuMuNch.cxx:1828
 AliAnalysisMuMuNch.cxx:1829
 AliAnalysisMuMuNch.cxx:1830
 AliAnalysisMuMuNch.cxx:1831
 AliAnalysisMuMuNch.cxx:1832
 AliAnalysisMuMuNch.cxx:1833
 AliAnalysisMuMuNch.cxx:1834
 AliAnalysisMuMuNch.cxx:1835
 AliAnalysisMuMuNch.cxx:1836
 AliAnalysisMuMuNch.cxx:1837
 AliAnalysisMuMuNch.cxx:1838
 AliAnalysisMuMuNch.cxx:1839
 AliAnalysisMuMuNch.cxx:1840
 AliAnalysisMuMuNch.cxx:1841
 AliAnalysisMuMuNch.cxx:1842
 AliAnalysisMuMuNch.cxx:1843
 AliAnalysisMuMuNch.cxx:1844
 AliAnalysisMuMuNch.cxx:1845
 AliAnalysisMuMuNch.cxx:1846
 AliAnalysisMuMuNch.cxx:1847
 AliAnalysisMuMuNch.cxx:1848
 AliAnalysisMuMuNch.cxx:1849
 AliAnalysisMuMuNch.cxx:1850
 AliAnalysisMuMuNch.cxx:1851
 AliAnalysisMuMuNch.cxx:1852
 AliAnalysisMuMuNch.cxx:1853
 AliAnalysisMuMuNch.cxx:1854
 AliAnalysisMuMuNch.cxx:1855
 AliAnalysisMuMuNch.cxx:1856
 AliAnalysisMuMuNch.cxx:1857
 AliAnalysisMuMuNch.cxx:1858
 AliAnalysisMuMuNch.cxx:1859
 AliAnalysisMuMuNch.cxx:1860
 AliAnalysisMuMuNch.cxx:1861
 AliAnalysisMuMuNch.cxx:1862
 AliAnalysisMuMuNch.cxx:1863
 AliAnalysisMuMuNch.cxx:1864
 AliAnalysisMuMuNch.cxx:1865
 AliAnalysisMuMuNch.cxx:1866
 AliAnalysisMuMuNch.cxx:1867
 AliAnalysisMuMuNch.cxx:1868
 AliAnalysisMuMuNch.cxx:1869
 AliAnalysisMuMuNch.cxx:1870
 AliAnalysisMuMuNch.cxx:1871
 AliAnalysisMuMuNch.cxx:1872
 AliAnalysisMuMuNch.cxx:1873
 AliAnalysisMuMuNch.cxx:1874
 AliAnalysisMuMuNch.cxx:1875
 AliAnalysisMuMuNch.cxx:1876
 AliAnalysisMuMuNch.cxx:1877
 AliAnalysisMuMuNch.cxx:1878
 AliAnalysisMuMuNch.cxx:1879
 AliAnalysisMuMuNch.cxx:1880
 AliAnalysisMuMuNch.cxx:1881
 AliAnalysisMuMuNch.cxx:1882
 AliAnalysisMuMuNch.cxx:1883
 AliAnalysisMuMuNch.cxx:1884
 AliAnalysisMuMuNch.cxx:1885
 AliAnalysisMuMuNch.cxx:1886
 AliAnalysisMuMuNch.cxx:1887
 AliAnalysisMuMuNch.cxx:1888
 AliAnalysisMuMuNch.cxx:1889
 AliAnalysisMuMuNch.cxx:1890
 AliAnalysisMuMuNch.cxx:1891
 AliAnalysisMuMuNch.cxx:1892
 AliAnalysisMuMuNch.cxx:1893
 AliAnalysisMuMuNch.cxx:1894
 AliAnalysisMuMuNch.cxx:1895
 AliAnalysisMuMuNch.cxx:1896
 AliAnalysisMuMuNch.cxx:1897
 AliAnalysisMuMuNch.cxx:1898
 AliAnalysisMuMuNch.cxx:1899
 AliAnalysisMuMuNch.cxx:1900
 AliAnalysisMuMuNch.cxx:1901
 AliAnalysisMuMuNch.cxx:1902
 AliAnalysisMuMuNch.cxx:1903
 AliAnalysisMuMuNch.cxx:1904
 AliAnalysisMuMuNch.cxx:1905
 AliAnalysisMuMuNch.cxx:1906
 AliAnalysisMuMuNch.cxx:1907
 AliAnalysisMuMuNch.cxx:1908
 AliAnalysisMuMuNch.cxx:1909
 AliAnalysisMuMuNch.cxx:1910
 AliAnalysisMuMuNch.cxx:1911
 AliAnalysisMuMuNch.cxx:1912
 AliAnalysisMuMuNch.cxx:1913
 AliAnalysisMuMuNch.cxx:1914
 AliAnalysisMuMuNch.cxx:1915
 AliAnalysisMuMuNch.cxx:1916
 AliAnalysisMuMuNch.cxx:1917
 AliAnalysisMuMuNch.cxx:1918
 AliAnalysisMuMuNch.cxx:1919
 AliAnalysisMuMuNch.cxx:1920
 AliAnalysisMuMuNch.cxx:1921
 AliAnalysisMuMuNch.cxx:1922
 AliAnalysisMuMuNch.cxx:1923
 AliAnalysisMuMuNch.cxx:1924
 AliAnalysisMuMuNch.cxx:1925
 AliAnalysisMuMuNch.cxx:1926
 AliAnalysisMuMuNch.cxx:1927
 AliAnalysisMuMuNch.cxx:1928
 AliAnalysisMuMuNch.cxx:1929
 AliAnalysisMuMuNch.cxx:1930
 AliAnalysisMuMuNch.cxx:1931
 AliAnalysisMuMuNch.cxx:1932
 AliAnalysisMuMuNch.cxx:1933
 AliAnalysisMuMuNch.cxx:1934
 AliAnalysisMuMuNch.cxx:1935
 AliAnalysisMuMuNch.cxx:1936
 AliAnalysisMuMuNch.cxx:1937
 AliAnalysisMuMuNch.cxx:1938
 AliAnalysisMuMuNch.cxx:1939
 AliAnalysisMuMuNch.cxx:1940
 AliAnalysisMuMuNch.cxx:1941
 AliAnalysisMuMuNch.cxx:1942
 AliAnalysisMuMuNch.cxx:1943
 AliAnalysisMuMuNch.cxx:1944
 AliAnalysisMuMuNch.cxx:1945
 AliAnalysisMuMuNch.cxx:1946
 AliAnalysisMuMuNch.cxx:1947
 AliAnalysisMuMuNch.cxx:1948
 AliAnalysisMuMuNch.cxx:1949
 AliAnalysisMuMuNch.cxx:1950
 AliAnalysisMuMuNch.cxx:1951
 AliAnalysisMuMuNch.cxx:1952
 AliAnalysisMuMuNch.cxx:1953
 AliAnalysisMuMuNch.cxx:1954
 AliAnalysisMuMuNch.cxx:1955
 AliAnalysisMuMuNch.cxx:1956
 AliAnalysisMuMuNch.cxx:1957
 AliAnalysisMuMuNch.cxx:1958
 AliAnalysisMuMuNch.cxx:1959
 AliAnalysisMuMuNch.cxx:1960
 AliAnalysisMuMuNch.cxx:1961
 AliAnalysisMuMuNch.cxx:1962
 AliAnalysisMuMuNch.cxx:1963
 AliAnalysisMuMuNch.cxx:1964
 AliAnalysisMuMuNch.cxx:1965
 AliAnalysisMuMuNch.cxx:1966
 AliAnalysisMuMuNch.cxx:1967
 AliAnalysisMuMuNch.cxx:1968
 AliAnalysisMuMuNch.cxx:1969
 AliAnalysisMuMuNch.cxx:1970
 AliAnalysisMuMuNch.cxx:1971
 AliAnalysisMuMuNch.cxx:1972
 AliAnalysisMuMuNch.cxx:1973
 AliAnalysisMuMuNch.cxx:1974
 AliAnalysisMuMuNch.cxx:1975
 AliAnalysisMuMuNch.cxx:1976
 AliAnalysisMuMuNch.cxx:1977
 AliAnalysisMuMuNch.cxx:1978
 AliAnalysisMuMuNch.cxx:1979
 AliAnalysisMuMuNch.cxx:1980
 AliAnalysisMuMuNch.cxx:1981
 AliAnalysisMuMuNch.cxx:1982
 AliAnalysisMuMuNch.cxx:1983
 AliAnalysisMuMuNch.cxx:1984
 AliAnalysisMuMuNch.cxx:1985
 AliAnalysisMuMuNch.cxx:1986
 AliAnalysisMuMuNch.cxx:1987
 AliAnalysisMuMuNch.cxx:1988
 AliAnalysisMuMuNch.cxx:1989
 AliAnalysisMuMuNch.cxx:1990
 AliAnalysisMuMuNch.cxx:1991
 AliAnalysisMuMuNch.cxx:1992
 AliAnalysisMuMuNch.cxx:1993
 AliAnalysisMuMuNch.cxx:1994
 AliAnalysisMuMuNch.cxx:1995
 AliAnalysisMuMuNch.cxx:1996
 AliAnalysisMuMuNch.cxx:1997
 AliAnalysisMuMuNch.cxx:1998
 AliAnalysisMuMuNch.cxx:1999
 AliAnalysisMuMuNch.cxx:2000
 AliAnalysisMuMuNch.cxx:2001
 AliAnalysisMuMuNch.cxx:2002
 AliAnalysisMuMuNch.cxx:2003
 AliAnalysisMuMuNch.cxx:2004
 AliAnalysisMuMuNch.cxx:2005
 AliAnalysisMuMuNch.cxx:2006
 AliAnalysisMuMuNch.cxx:2007
 AliAnalysisMuMuNch.cxx:2008
 AliAnalysisMuMuNch.cxx:2009
 AliAnalysisMuMuNch.cxx:2010
 AliAnalysisMuMuNch.cxx:2011
 AliAnalysisMuMuNch.cxx:2012
 AliAnalysisMuMuNch.cxx:2013
 AliAnalysisMuMuNch.cxx:2014
 AliAnalysisMuMuNch.cxx:2015
 AliAnalysisMuMuNch.cxx:2016
 AliAnalysisMuMuNch.cxx:2017
 AliAnalysisMuMuNch.cxx:2018
 AliAnalysisMuMuNch.cxx:2019
 AliAnalysisMuMuNch.cxx:2020
 AliAnalysisMuMuNch.cxx:2021
 AliAnalysisMuMuNch.cxx:2022
 AliAnalysisMuMuNch.cxx:2023
 AliAnalysisMuMuNch.cxx:2024
 AliAnalysisMuMuNch.cxx:2025
 AliAnalysisMuMuNch.cxx:2026
 AliAnalysisMuMuNch.cxx:2027
 AliAnalysisMuMuNch.cxx:2028
 AliAnalysisMuMuNch.cxx:2029
 AliAnalysisMuMuNch.cxx:2030
 AliAnalysisMuMuNch.cxx:2031
 AliAnalysisMuMuNch.cxx:2032
 AliAnalysisMuMuNch.cxx:2033
 AliAnalysisMuMuNch.cxx:2034
 AliAnalysisMuMuNch.cxx:2035
 AliAnalysisMuMuNch.cxx:2036
 AliAnalysisMuMuNch.cxx:2037
 AliAnalysisMuMuNch.cxx:2038
 AliAnalysisMuMuNch.cxx:2039
 AliAnalysisMuMuNch.cxx:2040
 AliAnalysisMuMuNch.cxx:2041
 AliAnalysisMuMuNch.cxx:2042