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

///////////////////////////////////////////////////////////////////////////
//                                                                       //
//                                                                       //
// Analysis for identified charged hadron spectra.                       //
//                                                                       //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#include "Riostream.h"
#include "TChain.h"
#include "TTree.h"
#include "TH1F.h"
#include "TH2D.h"
#include "TH3F.h"
#include "TList.h"
#include "TMath.h"
#include "TCanvas.h"
#include "TObjArray.h"
#include "TF1.h"
#include "TFile.h"

#include "AliAnalysisTaskSE.h"
#include "AliAnalysisManager.h"

#include "AliHeader.h"
#include "AliGenPythiaEventHeader.h"
#include "AliGenCocktailEventHeader.h"

#include "AliPID.h"
#include "AliESDtrackCuts.h"
#include "AliESDVertex.h"
#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
#include "AliESDtrack.h"
#include "AliESDpid.h"
#include "AliCentrality.h"
#include "AliESDUtils.h"
#include "AliMultiplicity.h"

#include "AliMCEventHandler.h"
#include "AliMCEvent.h"
#include "AliStack.h"

#include "AliLog.h"

#include "AliAnalysisCombinedHadronSpectra.h"


ClassImp(AliAnalysisCombinedHadronSpectra)

//________________________________________________________________________
AliAnalysisCombinedHadronSpectra::AliAnalysisCombinedHadronSpectra() 
  : AliAnalysisTaskSE("TaskChargedHadron"), fESD(0), fListHist(0), fESDtrackCuts(0),fESDTrackCutsMult(0),fESDpid(0),
    fMCtrue(0),
    fOnlyQA(0),
    fUseHBTmultiplicity(0),
    fUseTPConlyTracks(0),
    fSaveMotherPDG(0),
  fSmallTHnSparse(0),
  fTPCnSigmaCutLow(0),
  fTPCnSigmaCutHigh(0),
  fRapidityCutLow(0),
  fRapidityCutHigh(0),
  fEvenDCAbinning(0),
    fAlephParameters(),
    fHistRealTracks(0),
    fHistMCparticles(0),
    fHistPidQA(0),
    fHistMult(0),
    fHistCentrality(0)
{
  // default Constructor
  /* fast compilation test
     gSystem->Load("libANALYSIS");
     gSystem->Load("libANALYSISalice");
     .L /d/alice09/akalweit/train/trunk/akalweit_hadronSpectra/AliAnalysisCombinedHadronSpectra.cxx++
   */
}


//________________________________________________________________________
AliAnalysisCombinedHadronSpectra::AliAnalysisCombinedHadronSpectra(const char *name) 
  : AliAnalysisTaskSE(name), fESD(0), fListHist(0), fESDtrackCuts(0),fESDTrackCutsMult(0),fESDpid(0),
    fMCtrue(0),
    fOnlyQA(0),
    fUseHBTmultiplicity(0),
    fUseTPConlyTracks(0),
    fSaveMotherPDG(0),
  fSmallTHnSparse(0),
  fTPCnSigmaCutLow(0),
  fTPCnSigmaCutHigh(0),
  fRapidityCutLow(0),
  fRapidityCutHigh(0),
  fEvenDCAbinning(0),
    fAlephParameters(),
    fHistRealTracks(0),
    fHistMCparticles(0),
    fHistPidQA(0),
    fHistMult(0),
    fHistCentrality(0)
    {
  //
  // standard constructur which should be used
  //
  Printf("*** CONSTRUCTOR CALLED ****");
  //
  fMCtrue = kTRUE; 
  fOnlyQA = kFALSE;
  fUseHBTmultiplicity = kTRUE;
  fUseTPConlyTracks = kFALSE;

  fSmallTHnSparse = kFALSE;
  fTPCnSigmaCutLow = -3.;
  fTPCnSigmaCutHigh = 3.;
  fRapidityCutLow = -0.2;
  fRapidityCutHigh = 0.2;
  fEvenDCAbinning = kFALSE;

  /* real */
  fAlephParameters[0] = 0.0283086;
  fAlephParameters[1] = 2.63394e+01;
  fAlephParameters[2] = 5.04114e-11;
  fAlephParameters[3] = 2.12543e+00;
  fAlephParameters[4] = 4.88663e+00;
  //
  // initialize PID object
  //
  //fESDpid = new AliESDpid();
  //
  // create track cuts
  //
  fESDtrackCuts = new AliESDtrackCuts("AliESDtrackCuts","AliESDtrackCuts");
  //
  //Initialize();
  // Output slot #0 writes into a TList container
  DefineOutput(1, TList::Class());

}


//________________________________________________________________________
void AliAnalysisCombinedHadronSpectra::Initialize()
{
  //
  // updating parameters in case of changes
  //
  // 1. pid parameters
  //
  //fESDpid->GetTPCResponse().SetBetheBlochParameters(fAlephParameters[0],fAlephParameters[1],fAlephParameters[2],fAlephParameters[3],fAlephParameters[4]);
  //
  // 2. track cuts
  //
  /*
  fESDtrackCuts->SetMaxCovDiagonalElements(2, 2, 0.5, 0.5, 2);  // BEWARE STANDARD VALUES ARE: 2, 2, 0.5, 0.5, 2
  fESDtrackCuts->SetMaxNsigmaToVertex(3);
  fESDtrackCuts->SetRequireSigmaToVertex(kTRUE);
  fESDtrackCuts->SetAcceptKinkDaughters(kFALSE);
  fESDtrackCuts->SetMinNClustersTPC(70);
  fESDtrackCuts->SetMaxChi2PerClusterTPC(4);
  fESDtrackCuts->SetMaxDCAToVertexXY(3);
  fESDtrackCuts->SetMaxDCAToVertexZ(3);
  fESDtrackCuts->SetRequireTPCRefit(kTRUE);
  fESDtrackCuts->SetRequireITSRefit(kTRUE);
  fESDtrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny); //TEMPORARY <-> REMOVE
  fESDtrackCuts->SetMinNClustersITS(3);
  */
  //fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE); // kTRUE = sel. primaries --> patch for the moment, do TFractionFitter later


  if (!fUseTPConlyTracks) {
	  fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kFALSE);
	  fESDtrackCuts->SetMaxDCAToVertexXY(3);
	  fESDtrackCuts->SetMaxDCAToVertexZ(2);
	  fESDtrackCuts->SetEtaRange(-0.9,0.9);
  }
  else {
	  //fESDtrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	  fESDtrackCuts->SetMinNClustersTPC(70);
	  fESDtrackCuts->SetMaxChi2PerClusterTPC(4);
	  fESDtrackCuts->SetAcceptKinkDaughters(kFALSE);
	  fESDtrackCuts->SetRequireTPCRefit(kFALSE);

	  fESDtrackCuts->SetMaxDCAToVertexXY(15);
	  fESDtrackCuts->SetMaxDCAToVertexZ(6);
	  fESDtrackCuts->SetDCAToVertex2D(kFALSE);
	  fESDtrackCuts->SetRequireSigmaToVertex(kFALSE);

	  fESDtrackCuts->SetEtaRange(-0.9,0.9);
  }
  //
  //
  //
  //
  fESDTrackCutsMult = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE);
  fESDTrackCutsMult->SetEtaRange(-1.2,+1.2);
  fESDTrackCutsMult->SetPtRange(0.15,1e10);

}


//________________________________________________________________________
void AliAnalysisCombinedHadronSpectra::UserCreateOutputObjects() 
{
  // Create histograms
  // Called once
  fListHist = new TList();
  fListHist->SetOwner(kTRUE);
  //
  const Int_t kPtBins = 35;
  const Int_t kMultBins = 11;

  Int_t kDcaBinsTemp = 76;
  if (fEvenDCAbinning) kDcaBinsTemp = 150;
  const Int_t kDcaBins = (const Int_t) kDcaBinsTemp;

  const Float_t kDcaBinsTPConlyFactor = 5; //need to change binning of DCA plot for tpconly
  // sort pT-bins ..
  Double_t binsPt[77] = {0., 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0};

  Double_t binsDca[77] =  {-3,-2.85,-2.7,-2.55,-2.4,-2.25,-2.1,-1.95,-1.8,-1.65,-1.5,-1.35,-1.2,-1.05,-0.9,-0.75,-0.6,-0.45,-0.3,-0.285,-0.27,-0.255,-0.24,-0.225,-0.21,-0.195,-0.18,-0.165,-0.15,-0.135,-0.12,-0.105,-0.09,-0.075,-0.06,-0.045,-0.03,-0.015,0,0.015,0.03,0.045,0.06,0.075,0.09,0.105,0.12,0.135,0.15,0.165,0.18,0.195,0.21,0.225,0.24,0.255,0.27,0.285,0.3,0.45,0.6,0.75,0.9,1.05,1.2,1.35,1.5,1.65,1.8,1.95,2.1,2.25,2.4,2.55,2.7,2.85,3};

  // DCA bins borders get multiplied by constant factor for TPConlyTracks
  Double_t binsDcaTPConly[77];
  for (Int_t i = 0; i< 77; i++) {
  	binsDcaTPConly[i] = kDcaBinsTPConlyFactor * binsDca[i];
  }

  //
  // create the histograms with all necessary information --> it is filled 4x for each particle assumption
  //
  // (0.) assumed particle: 0. pion, 1. kaon, 2. proton, 3. deuteron
  // (1.) multiplicity or centrality -- number of accepted ESD tracks per events (deprecated), but now classes from 1 to 10, 0: Min. Bias
  // (2.) pT
  // (3.) sign
  // (4.) rapidity --> filled 4x
  // (5.)  pull TPC dEx --> filled 4x
  // (6.) has valid TOF pid signal
  // (7.) nsigma TOF --> filled 4x
  // (8..) dca_xy
  // (9.) CODE -- only MC 0-generated, 1-true rec. primaries, 2-misident prim, 3-second weak, 4-second material, 5-misident sec, 6-sec. K0, 7-sec. lambda, 8-sec sigma+
  //
  
  //dimensions of standard THnSparse
  //                              0,           1,           2,  3,       4,    5,     6,   7,     8
  Int_t    binsHistReal[9] = {   3,   kMultBins,     kPtBins,  2,       10,    50,    2,  80,    kDcaBins};
  Double_t xminHistReal[9] = {-0.5,        -0.5,           0, -2,      -0.5,   -5, -0.5,  -8,       -3};
  Double_t xmaxHistReal[9] = { 2.5,        10.5,           3,  2,       0.5,    5,  1.5,   8,        3};

  //dimensions of small THnSparse
  //                              0,           1,           2,  3,                        4,   5,       6
  Int_t    binsHistRealSm[7] = {   3,   kMultBins,     kPtBins,  2,  /*    10,   50,*/    2,  80, kDcaBins};
  Double_t xminHistRealSm[7] = {-0.5,        -0.5,           0, -2,  /*  -0.5,   -5,*/ -0.5,  -8,       -3};
  Double_t xmaxHistRealSm[7] = { 2.5,        10.5,           3,  2,  /*   0.5,    5,*/  1.5,   8,        3};

  if (!fSmallTHnSparse) fHistRealTracks = new THnSparseF("fHistRealTracks","real tracks",9,binsHistReal,xminHistReal,xmaxHistReal);
  else                  fHistRealTracks = new THnSparseF("fHistRealTracks","real tracks",7,binsHistRealSm,xminHistRealSm,xmaxHistRealSm);
  //
  fHistRealTracks->GetAxis(2)->Set(kPtBins, binsPt);

  //different DCAxy binning for TPConlyTracks

  Int_t dcaAxisNumber = 8;
  if (fSmallTHnSparse) dcaAxisNumber = 6;

  if (!fUseTPConlyTracks){
    if (fEvenDCAbinning) fHistRealTracks->GetAxis(dcaAxisNumber)->Set(kDcaBins,-3.,3.);
    else fHistRealTracks->GetAxis(dcaAxisNumber)->Set(kDcaBins, binsDca);
  }
  else {
    if (fEvenDCAbinning) fHistRealTracks->GetAxis(dcaAxisNumber)->Set(kDcaBins,-15.,15.);
    else fHistRealTracks->GetAxis(dcaAxisNumber)->Set(kDcaBins, binsDcaTPConly);
   }
  fListHist->Add(fHistRealTracks);
  //
  //                      0.ptot,1.tpcSig,2.hasTOF, 3. assumed part., 4. nclDedx, 5. nSigmaTPC (4x), 6. nSigmaTOF (4x), 7. centrality
  fHistPidQA = new TH3D("fHistPidQA","PID QA",500,0.1,10,1000,0,1000,2,-2,2);
  BinLogAxis(fHistPidQA);
  fListHist->Add(fHistPidQA);
  
  // dimensions of standard THnSparse
  //                            0,            1,           2,  3,      4,   5,    6,   7,       8.,    9.
  Int_t    binsHistMC[10] = {   3,    kMultBins,     kPtBins,  2,     10,  50,    2,  80, kDcaBins,    6};
  Double_t xminHistMC[10] = {-0.5,         -0.5,           0, -2,   -0.5,  -5, -0.5,  -8,       -3, -0.5};
  Double_t xmaxHistMC[10] = { 2.5,         10.5,           3,  2,    0.5,   5,  1.5,   8,        3,  5.5};

  //dimensions of small THnSparse
  //                              0,           1,           2,  3,                     4,   5,       6.,    7.
  Int_t    binsHistMCSm[8] = {   3,    kMultBins,     kPtBins,  2,  /*   10,  50,*/    2,  80, kDcaBins,    6};
  Double_t xminHistMCSm[8] = {-0.5,         -0.5,           0, -2,  /* -0.5,  -5,*/ -0.5,  -8,       -3, -0.5};
  Double_t xmaxHistMCSm[8] = { 2.5,         10.5,           3,  2,  /*  0.5,   5,*/  1.5,   8,        3,  5.5};

  //different binning for CODE axis, if we want to save motherPDG
  if (fSaveMotherPDG) {
    binsHistMC[9] = 9;
    xmaxHistMC[9] = 8.5;
    binsHistMCSm[7] = 9;
    xmaxHistMCSm[7] = 8.5;
  }


  if (!fSmallTHnSparse) fHistMCparticles = new THnSparseF("fHistMCparticles","MC histogram",10,binsHistMC,xminHistMC,xmaxHistMC);
  else                  fHistMCparticles = new THnSparseF("fHistMCparticles","MC histogram",8,binsHistMCSm,xminHistMCSm,xmaxHistMCSm);


  fHistMCparticles->GetAxis(2)->Set(kPtBins, binsPt);

  /*
  //different DCAxy binning for TPConlyTracks
  if (!fEvenDCAbinning){
    if (!fUseTPConlyTracks) fHistMCparticles->GetAxis(dcaAxisNumber)->Set(kDcaBins, binsDca);
    else fHistMCparticles->GetAxis(dcaAxisNumber)->Set(kDcaBins, binsDcaTPConly);
  }
  */

  if (!fUseTPConlyTracks){
    if (fEvenDCAbinning) fHistMCparticles->GetAxis(dcaAxisNumber)->Set(kDcaBins,-3.,3.);
    else fHistMCparticles->GetAxis(dcaAxisNumber)->Set(kDcaBins, binsDca);
  }
  else {
    if (fEvenDCAbinning) fHistMCparticles->GetAxis(dcaAxisNumber)->Set(kDcaBins,-15.,15.);
    else fHistMCparticles->GetAxis(dcaAxisNumber)->Set(kDcaBins, binsDcaTPConly);
   }



  fListHist->Add(fHistMCparticles);
  //
  fHistMult = new TH2D("fHistMult", "control histogram to count number of events", 502, -2.5, 499.5,4,-0.5,3.5);
  fHistCentrality = new TH1D("fHistCentrality", "control histogram to count number of events", 22, -1.5, 20.5);
  fListHist->Add(fHistMult);
  fListHist->Add(fHistCentrality);
  
}

//________________________________________________________________________
void AliAnalysisCombinedHadronSpectra::UserExec(Option_t *) 
{
  //
  // main event loop
  //
  if (!fESDpid) fESDpid = ((AliESDInputHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->GetESDpid();
  if (!fESDpid) {
    fESDpid = new AliESDpid(); // HACK FOR MC PBPB --> PLEASE REMOVE AS SOON AS POSSIBLE
    fESDpid->GetTPCResponse().SetBetheBlochParameters(1.28778e+00/50., 3.13539e+01, TMath::Exp(-3.16327e+01), 1.87901e+00, 6.41583e+00);
  }
  //AliLog::SetGlobalLogLevel(AliLog::kError);
  //
  // Check Monte Carlo information and other access first:
  //
  AliMCEventHandler* eventHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
  if (!eventHandler) {
    //Printf("ERROR: Could not retrieve MC event handler");
    fMCtrue = kFALSE;
  }
  //
  AliMCEvent* mcEvent = 0x0;
  AliStack* stack = 0x0;
  if (eventHandler) mcEvent = eventHandler->MCEvent();
  if (!mcEvent) {
    //Printf("ERROR: Could not retrieve MC event");
    if (fMCtrue) return;
  }
  if (fMCtrue) {
    stack = mcEvent->Stack();
    if (!stack) return;
  }
  //
  fESD = dynamic_cast<AliESDEvent*>( InputEvent() );
  if (!fESD) {
    //Printf("ERROR: fESD not available");
    return;
  }
  
  if (!fESDtrackCuts) {
    Printf("ERROR: fESDtrackCuts not available");
    return;
  }
  //
  // check if event is selected by physics selection class
  //
  Bool_t isSelected = kTRUE; // for reasons of backward compatibility --> check is now in AddTask macro
  /*
  Bool_t isSelected = kFALSE;
  isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB) == AliVEvent::kMB;
  */
  //
  // monitor vertex position
  //
  const AliESDVertex *vertex = fESD->GetPrimaryVertexTracks();
  if(vertex->GetNContributors()<1) {
    // SPD vertex
    vertex = fESD->GetPrimaryVertexSPD();
    if(vertex->GetNContributors()<1) vertex = 0x0;
  }  
  //
  // small track loop to determine trigger Pt, multiplicity or centrality
  //
  Double_t triggerPt = 0;
  for (Int_t i=0;i<fESD->GetNumberOfTracks();++i) {
    AliESDtrack *track =fESD->GetTrack(i);
    if (!fESDTrackCutsMult->AcceptTrack(track)) continue;
    if (track->Pt() > triggerPt) triggerPt = track->Pt();
  }
  Int_t trackCounter = fESDTrackCutsMult->CountAcceptedTracks(fESD);
  //
  // 2nd multiplicity estimator SPD hits; replaces multiplicity from HBT
  //
  Float_t spdCorr = -1;
  const AliMultiplicity *mult = fESD->GetMultiplicity();
  Float_t nClusters[6]={0.0,0.0,0.0,0.0,0.0,0.0};
  for(Int_t ilay=0; ilay<6; ilay++) nClusters[ilay] = (Float_t)mult->GetNumberOfITSClusters(ilay);
  if (vertex) spdCorr = AliESDUtils::GetCorrSPD2(nClusters[1],vertex->GetZ());
  //
  Float_t centrality = -1;
  //
  // IMPORTANT CENTRALITY DEFINITION FOR pp
  //
  if (!fUseHBTmultiplicity) {
    // test binning to check if multiplicity-dependence is due to diffractive events being s
    if (trackCounter >= 0  && trackCounter <= 0)  centrality = 0;
    if (trackCounter >= 1  && trackCounter <= 1)  centrality = 1;
    if (trackCounter >= 2  && trackCounter <= 2)  centrality = 2;
    if (trackCounter >= 3  && trackCounter <= 3)  centrality = 3;
    if (trackCounter >= 4  && trackCounter <= 4)  centrality = 4;
    if (trackCounter >= 5  && trackCounter <= 5)  centrality = 5;
    // this was all the original bin 1 being [0..5]
    if (trackCounter >= 6  && trackCounter <= 9)  centrality = 6;
    if (trackCounter >= 10 && trackCounter <= 14) centrality = 7;
    if (trackCounter >= 15 && trackCounter <= 22) centrality = 8;
    if (trackCounter >= 23 && trackCounter <= 32) centrality = 9;
    if (trackCounter >= 33 && trackCounter <= 42) centrality = 10;
    /*
    if (trackCounter >= 43 && trackCounter <= 52) centrality = 7
    if (trackCounter >= 53 && trackCounter <= 62) centrality = 8;
    if (trackCounter >= 63 && trackCounter <= 72) centrality = 9;
    if (trackCounter >= 73 && trackCounter <= 82) centrality = 10;
    */
  } else {
    if (spdCorr >= 0  && spdCorr <=  2)  centrality  = 0;
    if (spdCorr >= 3  && spdCorr <=  5)  centrality  = 1;
    if (spdCorr >= 6  && spdCorr <=  8)  centrality  = 2;
    if (spdCorr >= 9  && spdCorr <= 11)  centrality  = 3;
    if (spdCorr >= 12 && spdCorr <= 14)  centrality  = 4;
    if (spdCorr >= 15 && spdCorr <= 16)  centrality  = 5;
    // this was all the original bin 1 being [0..16]
    if (spdCorr >= 17 && spdCorr <= 30)  centrality =  6;
    if (spdCorr >= 31 && spdCorr <= 45)  centrality =  7;
    if (spdCorr >= 46 && spdCorr <= 68)  centrality =  8;
    if (spdCorr >= 69 && spdCorr <= 97)  centrality =  9;
    if (spdCorr >= 98)                   centrality = 10;
    /*
    if (spdCorr >= 17 && spdCorr <= 30)  centrality = 2;
    if (spdCorr >= 31 && spdCorr <= 45)  centrality = 3;
    if (spdCorr >= 46 && spdCorr <= 68)  centrality = 4;
    if (spdCorr >= 69 && spdCorr <= 97)  centrality = 5;
    if (spdCorr >= 98)                   centrality = 6;
    */
  }
  //
  Int_t rootS = fESD->GetBeamEnergy() < 1000 ? 0 : 1;
  if (fESD->GetEventSpecie() == 4) { // PbPb
    rootS = 2;
    AliCentrality *esdCentrality = fESD->GetCentrality();
    centrality = esdCentrality->GetCentralityClass10("V0M") + 1; // centrality percentile determined with V0
    if (TMath::Abs(centrality - 1) < 1e-5) {
      centrality = esdCentrality->GetCentralityClass5("V0M");
    }
  }
  Int_t nContributors = 0;
  if (fESD->GetPrimaryVertexTPC()) nContributors = fESD->GetPrimaryVertexTPC()->GetNContributors();
  //
  Int_t processtype = 0;
  Int_t processCode = 0;
  //
  // important change: fill generated only after vertex cut in case of heavy-ions
  //
  if (!vertex && fESD->GetEventSpecie() == 4) {
    fHistMult->Fill(-1, processCode);
    PostData(1, fListHist);
    return;
  } else {
    if (TMath::Abs(vertex->GetZ()) > 10 && fESD->GetEventSpecie() == 4) {
      fHistMult->Fill(-1, processCode);
      PostData(1, fListHist);
      return;
    }
  }
  //
  if (fMCtrue) {
    //
    //
    //
    AliHeader * header = mcEvent->Header();
    processtype = GetPythiaEventProcessType(header);
    // non diffractive
    if (processtype !=92 && processtype !=93 && processtype != 94) processCode = 1;
    // single diffractive
    if ((processtype == 92 || processtype == 93)) processCode = 2;
    // double diffractive
    if (processtype == 94) processCode = 3;
    //
    for(Int_t i = 0; i < stack->GetNtrack(); i++) {
      TParticle * trackMC = stack->Particle(i);
      Int_t pdg = trackMC->GetPdgCode();
      //
      Double_t xv = trackMC->Vx();
      Double_t yv = trackMC->Vy();
      Double_t zv = trackMC->Vz();
      Double_t dxy = 0;
      dxy = TMath::Sqrt(xv*xv + yv*yv); // so stupid to avoid warnings
      Double_t dz = 0;
      dz = TMath::Abs(zv); // so stupid to avoid warnings
      //
      // vertex cut - selection of primaries
      //
      //if (dxy > 3 || dz > 10) continue; // fixed cut at 3cm in r
      //
      if (!stack->IsPhysicalPrimary(i)) continue;
      //
      // fill MC histograms here...
      // 
      Double_t rap = trackMC->Y();
      Double_t pT  = trackMC->Pt();
      Int_t sign = pdg < 0 ? -1 : 1; // only works for charged pi,K,p !!
//      Double_t transMass = TMath::Sqrt(trackMC->Pt()*trackMC->Pt() + trackMC->GetMass()*trackMC->GetMass()) - trackMC->GetMass();
      //
      Int_t iPart = -1;
      if (TMath::Abs(pdg) == 211)  iPart = 0; // select Pi+/Pi- only
      if (TMath::Abs(pdg) == 321)  iPart = 1; // select K+/K- only
      if (TMath::Abs(pdg) == 2212) iPart = 2; // select p+/p- only
      if (iPart == -1) continue;
      //

      if (!fSmallTHnSparse){
	Double_t vecHistMC[10] = {static_cast<Double_t>(iPart), centrality,  pT, static_cast<Double_t>(sign), rap, 0, 1, 0, dxy, 0};
	if (!fOnlyQA) fHistMCparticles->Fill(vecHistMC);
      }
      else{
	if (rap>fRapidityCutLow && rap<fRapidityCutHigh){
	  Double_t vecHistMC[8] = {static_cast<Double_t>(iPart), centrality,  pT, static_cast<Double_t>(sign), 1, 0, dxy, 0};
	  if (!fOnlyQA) fHistMCparticles->Fill(vecHistMC);
	}
      }
    }
  }
  //
  if (!isSelected && !fOnlyQA) {
    PostData(1, fListHist);
    return;
  }
  //
  if (!vertex) {
    fHistMult->Fill(-1, processCode);
    PostData(1, fListHist);
    return;
  } else {
    if (TMath::Abs(vertex->GetZ()) > 10) {
      fHistMult->Fill(-1, processCode);
      PostData(1, fListHist);
      return;
    }
  }
  //
  // count events after physics selection and after vertex selection
  //
  //cout << "MULTIPLICITY " << trackCounter << " " << fESD->GetEventNumberInFile() <<endl;
  fHistMult->Fill(trackCounter, processCode);
  fHistCentrality->Fill(centrality);


  //***************************************************
  // track loop
  //***************************************************
  //const Float_t kNsigmaCut = 3;
  //const Float_t k2sigmaCorr = 1/(0.5*(TMath::Erf(kNsigmaCut/sqrt(2))-TMath::Erf(-kNsigmaCut/sqrt(2))))/*1/0.9545*/;
  //
  Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z for the vertex cut
  //
  for (Int_t i=0;i<fESD->GetNumberOfTracks();++i) {
	
	AliESDtrack *track = 0;
	AliESDtrack *trackForTOF = 0; //normal track for all TOF information needed when using tpconly-tracks
	
	//normal tracks, if tpconly flag is set, use tpconlytracks
	if (!fUseTPConlyTracks){
    	track =fESD->GetTrack(i); 
	}
	else {
   		track = fESDtrackCuts->GetTPCOnlyTrack(fESD,i);
		if (!track) continue;
		trackForTOF = fESD->GetTrack(i);
	}
    //
    if (!track->GetInnerParam()) {
		if (fUseTPConlyTracks) {delete track; track = 0;} //need to delete tpconlytrack
		continue;
	}
    Double_t ptot = track->GetInnerParam()->GetP(); // momentum for dEdx determination
    Double_t pT = track->Pt();
    track->GetImpactParameters(dca, cov);
    //
    //
    // cut for dead regions in the detector
    // if (track->Eta() > 0.1 && (track->Eta() < 0.2 && track->Phi() > 0.1 && track->Phi() < 0.1) continue;
    //
    // 2.a) apply some standard track cuts according to general recommendations
    //
    if (!fESDtrackCuts->AcceptTrack(track)) {
		if (fUseTPConlyTracks) {delete track; track = 0;} //need to delete tpconlytrack
		continue;
	}

	UInt_t status = 0;
    if (!fUseTPConlyTracks) status = track->GetStatus();
	else status = trackForTOF->GetStatus();
    Bool_t hasTOFout  = status&AliESDtrack::kTOFout; 
    Bool_t hasTOFtime = status&AliESDtrack::kTIME;
    Bool_t hasTOFpid  = status&AliESDtrack::kTOFpid;
    Bool_t hasTOF     = kFALSE;
    if (hasTOFout && hasTOFtime && hasTOFpid) hasTOF = kTRUE;
	Float_t length = 0.;
    if (!fUseTPConlyTracks) length = track->GetIntegratedLength(); 
    else length = trackForTOF->GetIntegratedLength();

    if (length < 350.) hasTOF = kFALSE;
    //
    // calculate rapidities and kinematics
    // 
    //
    Double_t pvec[3];
    track->GetPxPyPz(pvec);
    Double_t energyPion = TMath::Sqrt(track->GetP()*track->GetP() + AliPID::ParticleMass(AliPID::kPion)*AliPID::ParticleMass(AliPID::kPion));
    Double_t energyKaon = TMath::Sqrt(track->GetP()*track->GetP() + AliPID::ParticleMass(AliPID::kKaon)*AliPID::ParticleMass(AliPID::kKaon));
    Double_t energyProton = TMath::Sqrt(track->GetP()*track->GetP() + AliPID::ParticleMass(AliPID::kProton)*AliPID::ParticleMass(AliPID::kProton));
    Double_t energyDeuteron = TMath::Sqrt(track->GetP()*track->GetP() + 4*AliPID::ParticleMass(AliPID::kProton)*AliPID::ParticleMass(AliPID::kProton));
    //
    Double_t rapPion = 0.5*TMath::Log((energyPion + pvec[2])/(energyPion - pvec[2]));
    Double_t rapKaon = 0.5*TMath::Log((energyKaon + pvec[2])/(energyKaon - pvec[2]));
    Double_t rapProton = 0.5*TMath::Log((energyProton + pvec[2])/(energyProton - pvec[2]));
    Double_t rapDeuteron = 0.5*TMath::Log((energyDeuteron + pvec[2])/(energyDeuteron - pvec[2]));
    //
//    Double_t transMassPion = TMath::Sqrt(track->Pt()*track->Pt() + AliPID::ParticleMass(AliPID::kPion)*AliPID::ParticleMass(AliPID::kPion))      -  AliPID::ParticleMass(AliPID::kPion);
//    Double_t transMassKaon = TMath::Sqrt(track->Pt()*track->Pt() + AliPID::ParticleMass(AliPID::kKaon)*AliPID::ParticleMass(AliPID::kKaon))     -  AliPID::ParticleMass(AliPID::kKaon);
 //   Double_t transMassProton = TMath::Sqrt(track->Pt()*track->Pt() + AliPID::ParticleMass(AliPID::kProton)*AliPID::ParticleMass(AliPID::kProton))    -  AliPID::ParticleMass(AliPID::kProton);
//    Double_t transMassDeuteron = TMath::Sqrt(track->Pt()*track->Pt() + 4*AliPID::ParticleMass(AliPID::kProton)*AliPID::ParticleMass(AliPID::kProton))    -  2*AliPID::ParticleMass(AliPID::kProton);
    //
    // 3. make the PID
    //
    Double_t sign = track->GetSign();   
    Double_t tpcSignal = track->GetTPCsignal();
    //
    //
    // 3.a. calculate expected signals in nsigma
    //
    //  
    // (0.) assumed particle: 0. pion, 1. kaon, 2. proton, 3. deuteron
    // (1.) multiplicity or centrality -- number of accepted ESD tracks per events (deprecated), but now classes from 1 to 10, 0: Min. Bias
    // (2.) pT
    // (3.) sign
    // (4.) rapidity --> filled 4x
    // (5.)  pull TPC dEx --> filled 4x
    // (6.) has valid TOF pid signal
    // (7.) nsigma TOF --> filled 4x
    // (8..) dca_xy
    // (9.) CODE -- only MC 0-generated, 1-true rec. primaries, 2-misident, 3-second weak, 4-second material
    //
//    Double_t transMass[4] = {transMassPion,transMassKaon,transMassProton,transMassDeuteron};
    Double_t rap[4] = {rapPion,rapKaon,rapProton,rapDeuteron};
    Double_t pullsTPC[4] = {fESDpid->NumberOfSigmasTPC(track,AliPID::kPion),
			    fESDpid->NumberOfSigmasTPC(track,AliPID::kKaon),
			    fESDpid->NumberOfSigmasTPC(track,AliPID::kProton),
			    0}; // ASK FOR PUTTING THE DEUTERON TO AliPID !!!!!!!!!!!!!!
    Float_t time0 = fESDpid->GetTOFResponse().GetTimeZero();
    //fESDpid->GetTOFResponse().SetTimeResolution(130.);
    Double_t pullsTOF[4] ={0.,0.,0.,0.};
    if (!fUseTPConlyTracks) {
      pullsTOF[0] = fESDpid->NumberOfSigmasTOF(track,AliPID::kPion, time0);
      pullsTOF[1] = fESDpid->NumberOfSigmasTOF(track,AliPID::kKaon, time0);
      pullsTOF[2] = fESDpid->NumberOfSigmasTOF(track,AliPID::kProton, time0);
      pullsTOF[3] = 0; // ASK FOR PUTTING THE DEUTERON TO AliPID !!!!!!!!!!!!!!;
    }
    else {
      pullsTOF[0] = fESDpid->NumberOfSigmasTOF(trackForTOF,AliPID::kPion, time0);
      pullsTOF[1] = fESDpid->NumberOfSigmasTOF(trackForTOF,AliPID::kKaon, time0);
      pullsTOF[2] = fESDpid->NumberOfSigmasTOF(trackForTOF,AliPID::kProton, time0);
      pullsTOF[3] = 0; // ASK FOR PUTTING THE DEUTERON TO AliPID !!!!!!!!!!!!!!;
    }

    //
//    Double_t tpcQA[4] = {fESDpid->NumberOfSigmasTPC(track,AliPID::kElectron),
//			 fESDpid->NumberOfSigmasTPC(track,AliPID::kPion),
//			 fESDpid->NumberOfSigmasTPC(track,AliPID::kKaon),
//			 fESDpid->NumberOfSigmasTPC(track,AliPID::kProton)};

    Double_t tofQA[4] = {0.,0.,0.,0.}; 
    if (!fUseTPConlyTracks) {
      tofQA[0] = fESDpid->NumberOfSigmasTOF(track,AliPID::kElectron, time0);
      tofQA[0] = fESDpid->NumberOfSigmasTOF(track,AliPID::kPion, time0);
      tofQA[0] = fESDpid->NumberOfSigmasTOF(track,AliPID::kKaon, time0);
      tofQA[0] = fESDpid->NumberOfSigmasTOF(track,AliPID::kProton, time0);
    }
    else{
      tofQA[0] = fESDpid->NumberOfSigmasTOF(trackForTOF,AliPID::kElectron, time0);
      tofQA[0] = fESDpid->NumberOfSigmasTOF(trackForTOF,AliPID::kPion, time0);
      tofQA[0] = fESDpid->NumberOfSigmasTOF(trackForTOF,AliPID::kKaon, time0);
      tofQA[0] = fESDpid->NumberOfSigmasTOF(trackForTOF,AliPID::kProton, time0);
    }


    //save information for every particle type  // loop over assumed particle type
    for(Int_t iPart = 0; iPart < 3; iPart++) {

      if (!fSmallTHnSparse) {
	Double_t vecHistReal[9]  = {static_cast<Double_t>(iPart),  centrality,   pT, static_cast<Double_t>(sign),  rap[iPart], pullsTPC[iPart], static_cast<Double_t>(hasTOF), pullsTOF[iPart], dca[0]};
	if (!fOnlyQA) fHistRealTracks->Fill(vecHistReal);
      }
      else {
	if (pullsTPC[iPart]>fTPCnSigmaCutLow && pullsTPC[iPart]<fTPCnSigmaCutHigh && rap[iPart]>fRapidityCutLow && rap[iPart]<fRapidityCutHigh) {
	  Double_t vecHistReal[7]  = {static_cast<Double_t>(iPart),  centrality,   pT, static_cast<Double_t>(sign), static_cast<Double_t>(hasTOF), pullsTOF[iPart], dca[0]};
	  if (!fOnlyQA) fHistRealTracks->Fill(vecHistReal);
	}
      }


      // using MC truth for precise efficiencies...
      //
      if (fMCtrue && !fOnlyQA) {
	Int_t code = 9; // code: 0-generated, 1-true rec. primaries, 2-misident, 3-second weak, 4-second material
	Int_t assumedPdg = 0;//2212(proton); 321(Kaon); 211(pion);
	Int_t motherCode = -1;
	if (iPart == 0) assumedPdg = 211;
	if (iPart == 1) assumedPdg = 321;
	if (iPart == 2) assumedPdg = 2212;
	//
	//
	TParticle *trackMC = stack->Particle(TMath::Abs(track->GetLabel()));
	Int_t pdg = TMath::Abs(trackMC->GetPdgCode());
	//
	if (pdg != assumedPdg && stack->IsPhysicalPrimary(TMath::Abs(track->GetLabel()))) code = 2;
	if (pdg != assumedPdg && stack->IsSecondaryFromWeakDecay(TMath::Abs(track->GetLabel()))) code = 5;
	if (pdg == assumedPdg && stack->IsPhysicalPrimary(TMath::Abs(track->GetLabel()))) code = 1;
	if (pdg == assumedPdg && stack->IsSecondaryFromWeakDecay(TMath::Abs(track->GetLabel()))) {
	  code = 3;
	  if (fSaveMotherPDG){
	    TParticle *trackMother =  stack->Particle(TMath::Abs(trackMC->GetFirstMother()));
	    if (trackMother->GetPdgCode() == 310) motherCode = 6; //K0
	    if (trackMother->GetPdgCode() == 3122) motherCode = 7; //Lambda
	    if (trackMother->GetPdgCode() == 3222) motherCode = 8; //Sigma+
	  }
	}
	if (pdg == assumedPdg && stack->IsSecondaryFromMaterial(TMath::Abs(track->GetLabel()))) code = 4;
	
	//
	// muons need special treatment, because they are indistinguishable from pions
	//
	if (iPart == 0 && pdg == 13  && stack->IsPhysicalPrimary(TMath::Abs(track->GetLabel()))) code = 1;
	if (iPart == 0 && pdg == 13  && stack->IsSecondaryFromWeakDecay(TMath::Abs(track->GetLabel()))) code = 3;
	//
	// check TOF mismatch on MC basis with TOF label
	//
	Int_t tofLabel[3];
	if (!fUseTPConlyTracks) track->GetTOFLabel(tofLabel);
	else trackForTOF->GetTOFLabel(tofLabel);
	if (TMath::Abs(track->GetLabel()) != TMath::Abs(tofLabel[0]) || tofLabel[1] > 0) hasTOF = kFALSE;
	//
	// IMPORTANT BIG PROBLEM HERE THE PROBABLILITY TO HAVE A PID SIGNAL MUST BE IN !!!!!!!!!!!!
	//
	if (!fSmallTHnSparse){
	  Double_t vectorHistMC[10] = {static_cast<Double_t>(iPart),  centrality,  pT, static_cast<Double_t>(sign),  rap[iPart], pullsTPC[iPart], static_cast<Double_t>(hasTOF), pullsTOF[iPart], dca[0], static_cast<Double_t>(code)};
	  if (!fOnlyQA) { 
	    fHistMCparticles->Fill(vectorHistMC);
	    if (motherCode != -1 && fSaveMotherPDG) { //if mother of weak decay is K0, lambda or sigma+ add track again with this information
	      Double_t vectorHistMCmother[10] = {static_cast<Double_t>(iPart),  centrality,  pT, static_cast<Double_t>(sign),  rap[iPart], pullsTPC[iPart], static_cast<Double_t>(hasTOF), pullsTOF[iPart], dca[0], static_cast<Double_t>(motherCode)};
	      fHistMCparticles->Fill(vectorHistMCmother);
	    }
	  }
	}
	else{
	  if (pullsTPC[iPart]>fTPCnSigmaCutLow && pullsTPC[iPart]<fTPCnSigmaCutHigh && rap[iPart]>fRapidityCutLow && rap[iPart]<fRapidityCutHigh) {
	    //                              0,           1,   2,    3,           4,               5,      6,               7,      8,   9
	    Double_t vectorHistMC[8] = {static_cast<Double_t>(iPart),  centrality,  pT, static_cast<Double_t>(sign), static_cast<Double_t>(hasTOF), pullsTOF[iPart], dca[0], static_cast<Double_t>(code)};
	    if (!fOnlyQA) { 
	      fHistMCparticles->Fill(vectorHistMC);
	      if (motherCode != -1 && fSaveMotherPDG) { //if mother of weak decay is K0, lambda or sigma+ add track again with this information
		Double_t vectorHistMCmother[8] = {static_cast<Double_t>(iPart),  centrality,  pT, static_cast<Double_t>(sign), static_cast<Double_t>(hasTOF), pullsTOF[iPart], dca[0], static_cast<Double_t>(motherCode)};
		fHistMCparticles->Fill(vectorHistMCmother);
	      }
	    }
	  }
	}
      }
      //
      //
      Int_t tpcShared = track->GetTPCnclsS();
      if (TMath::Abs(track->Eta()) < 0.8 && iPart == 0 && tpcShared < 4) fHistPidQA->Fill(ptot,tpcSignal,sign);
    } // end loop over assumed particle type

	  //need to delete tpconlytrack
	  if (fUseTPConlyTracks){
 		delete track; 
  		track = 0;     
  	  }

  } // end of track loop
  
  // Post output data  
  PostData(1, fListHist);
  
}      


//________________________________________________________________________
void AliAnalysisCombinedHadronSpectra::Terminate(Option_t *) 
{
  // Draw result to the screen
  // Called once at the end of the query
  Printf("*** CONSTRUCTOR CALLED ****");

}


//________________________________________________________________________
Bool_t AliAnalysisCombinedHadronSpectra::SelectOnImpPar(AliESDtrack* t) {
  //
  // cut on transverse impact parameter // DEPRECATED
  //
  Float_t d0z0[2],covd0z0[3];
  t->GetImpactParameters(d0z0,covd0z0);
  Float_t sigma= 0.0050+0.0060/TMath::Power(t->Pt(),0.9);
  Float_t d0max = 7.*sigma;
  //
  Float_t sigmaZ = 0.0146+0.0070/TMath::Power(t->Pt(),1.114758);
  if (t->Pt() > 1) sigmaZ = 0.0216;
  Float_t d0maxZ = 5.*sigmaZ;
  //
  if(TMath::Abs(d0z0[0]) < d0max && TMath::Abs(d0z0[1]) < d0maxZ) return kTRUE;
  return kFALSE;
}


//________________________________________________________________________
void AliAnalysisCombinedHadronSpectra::BinLogAxis(const TH1 *h) {
  //
  // Method for the correct logarithmic binning of histograms
  //
  TAxis *axis = const_cast<TAxis*>(h->GetXaxis());
  int bins = axis->GetNbins();

  Double_t from = axis->GetXmin();
  Double_t to = axis->GetXmax();
  Double_t *newBins = new Double_t[bins + 1];
   
  newBins[0] = from;
  Double_t factor = pow(to/from, 1./bins);
  
  for (int i = 1; i <= bins; i++) {
   newBins[i] = factor * newBins[i-1];
  }
  axis->Set(bins, newBins);
  delete [] newBins;
  
}


//________________________________________________________________________
Int_t AliAnalysisCombinedHadronSpectra::GetPythiaEventProcessType(const AliHeader* aHeader, Bool_t adebug) const {
  //
  // get the process type of the event.
  //

  // can only read pythia headers, either directly or from cocktalil header
  AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(aHeader->GenEventHeader());

  if (!pythiaGenHeader) {

    AliGenCocktailEventHeader* genCocktailHeader = dynamic_cast<AliGenCocktailEventHeader*>(aHeader->GenEventHeader());
    if (!genCocktailHeader) {
      //printf("AliAnalysisCombinedHadronSpectra::GetProcessType : Unknown header type (not Pythia or Cocktail). \n");
      return -1;
    }

    TList* headerList = genCocktailHeader->GetHeaders();
    if (!headerList) {
      return -1;
    }

    for (Int_t i=0; i<headerList->GetEntries(); i++) {
      pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(headerList->At(i));
      if (pythiaGenHeader)
        break;
    }

    if (!pythiaGenHeader) {
      //printf("AliAnalysisCombinedHadronSpectra::GetProcessType : Could not find Pythia header. \n");
      return -1;
    }
  }

  if (adebug) {
    //printf("AliAnalysisCombinedHadronSpectra::GetProcessType : Pythia process type found: %d \n",pythiaGenHeader->ProcessType());
  }

  return pythiaGenHeader->ProcessType();
}
 AliAnalysisCombinedHadronSpectra.cxx:1
 AliAnalysisCombinedHadronSpectra.cxx:2
 AliAnalysisCombinedHadronSpectra.cxx:3
 AliAnalysisCombinedHadronSpectra.cxx:4
 AliAnalysisCombinedHadronSpectra.cxx:5
 AliAnalysisCombinedHadronSpectra.cxx:6
 AliAnalysisCombinedHadronSpectra.cxx:7
 AliAnalysisCombinedHadronSpectra.cxx:8
 AliAnalysisCombinedHadronSpectra.cxx:9
 AliAnalysisCombinedHadronSpectra.cxx:10
 AliAnalysisCombinedHadronSpectra.cxx:11
 AliAnalysisCombinedHadronSpectra.cxx:12
 AliAnalysisCombinedHadronSpectra.cxx:13
 AliAnalysisCombinedHadronSpectra.cxx:14
 AliAnalysisCombinedHadronSpectra.cxx:15
 AliAnalysisCombinedHadronSpectra.cxx:16
 AliAnalysisCombinedHadronSpectra.cxx:17
 AliAnalysisCombinedHadronSpectra.cxx:18
 AliAnalysisCombinedHadronSpectra.cxx:19
 AliAnalysisCombinedHadronSpectra.cxx:20
 AliAnalysisCombinedHadronSpectra.cxx:21
 AliAnalysisCombinedHadronSpectra.cxx:22
 AliAnalysisCombinedHadronSpectra.cxx:23
 AliAnalysisCombinedHadronSpectra.cxx:24
 AliAnalysisCombinedHadronSpectra.cxx:25
 AliAnalysisCombinedHadronSpectra.cxx:26
 AliAnalysisCombinedHadronSpectra.cxx:27
 AliAnalysisCombinedHadronSpectra.cxx:28
 AliAnalysisCombinedHadronSpectra.cxx:29
 AliAnalysisCombinedHadronSpectra.cxx:30
 AliAnalysisCombinedHadronSpectra.cxx:31
 AliAnalysisCombinedHadronSpectra.cxx:32
 AliAnalysisCombinedHadronSpectra.cxx:33
 AliAnalysisCombinedHadronSpectra.cxx:34
 AliAnalysisCombinedHadronSpectra.cxx:35
 AliAnalysisCombinedHadronSpectra.cxx:36
 AliAnalysisCombinedHadronSpectra.cxx:37
 AliAnalysisCombinedHadronSpectra.cxx:38
 AliAnalysisCombinedHadronSpectra.cxx:39
 AliAnalysisCombinedHadronSpectra.cxx:40
 AliAnalysisCombinedHadronSpectra.cxx:41
 AliAnalysisCombinedHadronSpectra.cxx:42
 AliAnalysisCombinedHadronSpectra.cxx:43
 AliAnalysisCombinedHadronSpectra.cxx:44
 AliAnalysisCombinedHadronSpectra.cxx:45
 AliAnalysisCombinedHadronSpectra.cxx:46
 AliAnalysisCombinedHadronSpectra.cxx:47
 AliAnalysisCombinedHadronSpectra.cxx:48
 AliAnalysisCombinedHadronSpectra.cxx:49
 AliAnalysisCombinedHadronSpectra.cxx:50
 AliAnalysisCombinedHadronSpectra.cxx:51
 AliAnalysisCombinedHadronSpectra.cxx:52
 AliAnalysisCombinedHadronSpectra.cxx:53
 AliAnalysisCombinedHadronSpectra.cxx:54
 AliAnalysisCombinedHadronSpectra.cxx:55
 AliAnalysisCombinedHadronSpectra.cxx:56
 AliAnalysisCombinedHadronSpectra.cxx:57
 AliAnalysisCombinedHadronSpectra.cxx:58
 AliAnalysisCombinedHadronSpectra.cxx:59
 AliAnalysisCombinedHadronSpectra.cxx:60
 AliAnalysisCombinedHadronSpectra.cxx:61
 AliAnalysisCombinedHadronSpectra.cxx:62
 AliAnalysisCombinedHadronSpectra.cxx:63
 AliAnalysisCombinedHadronSpectra.cxx:64
 AliAnalysisCombinedHadronSpectra.cxx:65
 AliAnalysisCombinedHadronSpectra.cxx:66
 AliAnalysisCombinedHadronSpectra.cxx:67
 AliAnalysisCombinedHadronSpectra.cxx:68
 AliAnalysisCombinedHadronSpectra.cxx:69
 AliAnalysisCombinedHadronSpectra.cxx:70
 AliAnalysisCombinedHadronSpectra.cxx:71
 AliAnalysisCombinedHadronSpectra.cxx:72
 AliAnalysisCombinedHadronSpectra.cxx:73
 AliAnalysisCombinedHadronSpectra.cxx:74
 AliAnalysisCombinedHadronSpectra.cxx:75
 AliAnalysisCombinedHadronSpectra.cxx:76
 AliAnalysisCombinedHadronSpectra.cxx:77
 AliAnalysisCombinedHadronSpectra.cxx:78
 AliAnalysisCombinedHadronSpectra.cxx:79
 AliAnalysisCombinedHadronSpectra.cxx:80
 AliAnalysisCombinedHadronSpectra.cxx:81
 AliAnalysisCombinedHadronSpectra.cxx:82
 AliAnalysisCombinedHadronSpectra.cxx:83
 AliAnalysisCombinedHadronSpectra.cxx:84
 AliAnalysisCombinedHadronSpectra.cxx:85
 AliAnalysisCombinedHadronSpectra.cxx:86
 AliAnalysisCombinedHadronSpectra.cxx:87
 AliAnalysisCombinedHadronSpectra.cxx:88
 AliAnalysisCombinedHadronSpectra.cxx:89
 AliAnalysisCombinedHadronSpectra.cxx:90
 AliAnalysisCombinedHadronSpectra.cxx:91
 AliAnalysisCombinedHadronSpectra.cxx:92
 AliAnalysisCombinedHadronSpectra.cxx:93
 AliAnalysisCombinedHadronSpectra.cxx:94
 AliAnalysisCombinedHadronSpectra.cxx:95
 AliAnalysisCombinedHadronSpectra.cxx:96
 AliAnalysisCombinedHadronSpectra.cxx:97
 AliAnalysisCombinedHadronSpectra.cxx:98
 AliAnalysisCombinedHadronSpectra.cxx:99
 AliAnalysisCombinedHadronSpectra.cxx:100
 AliAnalysisCombinedHadronSpectra.cxx:101
 AliAnalysisCombinedHadronSpectra.cxx:102
 AliAnalysisCombinedHadronSpectra.cxx:103
 AliAnalysisCombinedHadronSpectra.cxx:104
 AliAnalysisCombinedHadronSpectra.cxx:105
 AliAnalysisCombinedHadronSpectra.cxx:106
 AliAnalysisCombinedHadronSpectra.cxx:107
 AliAnalysisCombinedHadronSpectra.cxx:108
 AliAnalysisCombinedHadronSpectra.cxx:109
 AliAnalysisCombinedHadronSpectra.cxx:110
 AliAnalysisCombinedHadronSpectra.cxx:111
 AliAnalysisCombinedHadronSpectra.cxx:112
 AliAnalysisCombinedHadronSpectra.cxx:113
 AliAnalysisCombinedHadronSpectra.cxx:114
 AliAnalysisCombinedHadronSpectra.cxx:115
 AliAnalysisCombinedHadronSpectra.cxx:116
 AliAnalysisCombinedHadronSpectra.cxx:117
 AliAnalysisCombinedHadronSpectra.cxx:118
 AliAnalysisCombinedHadronSpectra.cxx:119
 AliAnalysisCombinedHadronSpectra.cxx:120
 AliAnalysisCombinedHadronSpectra.cxx:121
 AliAnalysisCombinedHadronSpectra.cxx:122
 AliAnalysisCombinedHadronSpectra.cxx:123
 AliAnalysisCombinedHadronSpectra.cxx:124
 AliAnalysisCombinedHadronSpectra.cxx:125
 AliAnalysisCombinedHadronSpectra.cxx:126
 AliAnalysisCombinedHadronSpectra.cxx:127
 AliAnalysisCombinedHadronSpectra.cxx:128
 AliAnalysisCombinedHadronSpectra.cxx:129
 AliAnalysisCombinedHadronSpectra.cxx:130
 AliAnalysisCombinedHadronSpectra.cxx:131
 AliAnalysisCombinedHadronSpectra.cxx:132
 AliAnalysisCombinedHadronSpectra.cxx:133
 AliAnalysisCombinedHadronSpectra.cxx:134
 AliAnalysisCombinedHadronSpectra.cxx:135
 AliAnalysisCombinedHadronSpectra.cxx:136
 AliAnalysisCombinedHadronSpectra.cxx:137
 AliAnalysisCombinedHadronSpectra.cxx:138
 AliAnalysisCombinedHadronSpectra.cxx:139
 AliAnalysisCombinedHadronSpectra.cxx:140
 AliAnalysisCombinedHadronSpectra.cxx:141
 AliAnalysisCombinedHadronSpectra.cxx:142
 AliAnalysisCombinedHadronSpectra.cxx:143
 AliAnalysisCombinedHadronSpectra.cxx:144
 AliAnalysisCombinedHadronSpectra.cxx:145
 AliAnalysisCombinedHadronSpectra.cxx:146
 AliAnalysisCombinedHadronSpectra.cxx:147
 AliAnalysisCombinedHadronSpectra.cxx:148
 AliAnalysisCombinedHadronSpectra.cxx:149
 AliAnalysisCombinedHadronSpectra.cxx:150
 AliAnalysisCombinedHadronSpectra.cxx:151
 AliAnalysisCombinedHadronSpectra.cxx:152
 AliAnalysisCombinedHadronSpectra.cxx:153
 AliAnalysisCombinedHadronSpectra.cxx:154
 AliAnalysisCombinedHadronSpectra.cxx:155
 AliAnalysisCombinedHadronSpectra.cxx:156
 AliAnalysisCombinedHadronSpectra.cxx:157
 AliAnalysisCombinedHadronSpectra.cxx:158
 AliAnalysisCombinedHadronSpectra.cxx:159
 AliAnalysisCombinedHadronSpectra.cxx:160
 AliAnalysisCombinedHadronSpectra.cxx:161
 AliAnalysisCombinedHadronSpectra.cxx:162
 AliAnalysisCombinedHadronSpectra.cxx:163
 AliAnalysisCombinedHadronSpectra.cxx:164
 AliAnalysisCombinedHadronSpectra.cxx:165
 AliAnalysisCombinedHadronSpectra.cxx:166
 AliAnalysisCombinedHadronSpectra.cxx:167
 AliAnalysisCombinedHadronSpectra.cxx:168
 AliAnalysisCombinedHadronSpectra.cxx:169
 AliAnalysisCombinedHadronSpectra.cxx:170
 AliAnalysisCombinedHadronSpectra.cxx:171
 AliAnalysisCombinedHadronSpectra.cxx:172
 AliAnalysisCombinedHadronSpectra.cxx:173
 AliAnalysisCombinedHadronSpectra.cxx:174
 AliAnalysisCombinedHadronSpectra.cxx:175
 AliAnalysisCombinedHadronSpectra.cxx:176
 AliAnalysisCombinedHadronSpectra.cxx:177
 AliAnalysisCombinedHadronSpectra.cxx:178
 AliAnalysisCombinedHadronSpectra.cxx:179
 AliAnalysisCombinedHadronSpectra.cxx:180
 AliAnalysisCombinedHadronSpectra.cxx:181
 AliAnalysisCombinedHadronSpectra.cxx:182
 AliAnalysisCombinedHadronSpectra.cxx:183
 AliAnalysisCombinedHadronSpectra.cxx:184
 AliAnalysisCombinedHadronSpectra.cxx:185
 AliAnalysisCombinedHadronSpectra.cxx:186
 AliAnalysisCombinedHadronSpectra.cxx:187
 AliAnalysisCombinedHadronSpectra.cxx:188
 AliAnalysisCombinedHadronSpectra.cxx:189
 AliAnalysisCombinedHadronSpectra.cxx:190
 AliAnalysisCombinedHadronSpectra.cxx:191
 AliAnalysisCombinedHadronSpectra.cxx:192
 AliAnalysisCombinedHadronSpectra.cxx:193
 AliAnalysisCombinedHadronSpectra.cxx:194
 AliAnalysisCombinedHadronSpectra.cxx:195
 AliAnalysisCombinedHadronSpectra.cxx:196
 AliAnalysisCombinedHadronSpectra.cxx:197
 AliAnalysisCombinedHadronSpectra.cxx:198
 AliAnalysisCombinedHadronSpectra.cxx:199
 AliAnalysisCombinedHadronSpectra.cxx:200
 AliAnalysisCombinedHadronSpectra.cxx:201
 AliAnalysisCombinedHadronSpectra.cxx:202
 AliAnalysisCombinedHadronSpectra.cxx:203
 AliAnalysisCombinedHadronSpectra.cxx:204
 AliAnalysisCombinedHadronSpectra.cxx:205
 AliAnalysisCombinedHadronSpectra.cxx:206
 AliAnalysisCombinedHadronSpectra.cxx:207
 AliAnalysisCombinedHadronSpectra.cxx:208
 AliAnalysisCombinedHadronSpectra.cxx:209
 AliAnalysisCombinedHadronSpectra.cxx:210
 AliAnalysisCombinedHadronSpectra.cxx:211
 AliAnalysisCombinedHadronSpectra.cxx:212
 AliAnalysisCombinedHadronSpectra.cxx:213
 AliAnalysisCombinedHadronSpectra.cxx:214
 AliAnalysisCombinedHadronSpectra.cxx:215
 AliAnalysisCombinedHadronSpectra.cxx:216
 AliAnalysisCombinedHadronSpectra.cxx:217
 AliAnalysisCombinedHadronSpectra.cxx:218
 AliAnalysisCombinedHadronSpectra.cxx:219
 AliAnalysisCombinedHadronSpectra.cxx:220
 AliAnalysisCombinedHadronSpectra.cxx:221
 AliAnalysisCombinedHadronSpectra.cxx:222
 AliAnalysisCombinedHadronSpectra.cxx:223
 AliAnalysisCombinedHadronSpectra.cxx:224
 AliAnalysisCombinedHadronSpectra.cxx:225
 AliAnalysisCombinedHadronSpectra.cxx:226
 AliAnalysisCombinedHadronSpectra.cxx:227
 AliAnalysisCombinedHadronSpectra.cxx:228
 AliAnalysisCombinedHadronSpectra.cxx:229
 AliAnalysisCombinedHadronSpectra.cxx:230
 AliAnalysisCombinedHadronSpectra.cxx:231
 AliAnalysisCombinedHadronSpectra.cxx:232
 AliAnalysisCombinedHadronSpectra.cxx:233
 AliAnalysisCombinedHadronSpectra.cxx:234
 AliAnalysisCombinedHadronSpectra.cxx:235
 AliAnalysisCombinedHadronSpectra.cxx:236
 AliAnalysisCombinedHadronSpectra.cxx:237
 AliAnalysisCombinedHadronSpectra.cxx:238
 AliAnalysisCombinedHadronSpectra.cxx:239
 AliAnalysisCombinedHadronSpectra.cxx:240
 AliAnalysisCombinedHadronSpectra.cxx:241
 AliAnalysisCombinedHadronSpectra.cxx:242
 AliAnalysisCombinedHadronSpectra.cxx:243
 AliAnalysisCombinedHadronSpectra.cxx:244
 AliAnalysisCombinedHadronSpectra.cxx:245
 AliAnalysisCombinedHadronSpectra.cxx:246
 AliAnalysisCombinedHadronSpectra.cxx:247
 AliAnalysisCombinedHadronSpectra.cxx:248
 AliAnalysisCombinedHadronSpectra.cxx:249
 AliAnalysisCombinedHadronSpectra.cxx:250
 AliAnalysisCombinedHadronSpectra.cxx:251
 AliAnalysisCombinedHadronSpectra.cxx:252
 AliAnalysisCombinedHadronSpectra.cxx:253
 AliAnalysisCombinedHadronSpectra.cxx:254
 AliAnalysisCombinedHadronSpectra.cxx:255
 AliAnalysisCombinedHadronSpectra.cxx:256
 AliAnalysisCombinedHadronSpectra.cxx:257
 AliAnalysisCombinedHadronSpectra.cxx:258
 AliAnalysisCombinedHadronSpectra.cxx:259
 AliAnalysisCombinedHadronSpectra.cxx:260
 AliAnalysisCombinedHadronSpectra.cxx:261
 AliAnalysisCombinedHadronSpectra.cxx:262
 AliAnalysisCombinedHadronSpectra.cxx:263
 AliAnalysisCombinedHadronSpectra.cxx:264
 AliAnalysisCombinedHadronSpectra.cxx:265
 AliAnalysisCombinedHadronSpectra.cxx:266
 AliAnalysisCombinedHadronSpectra.cxx:267
 AliAnalysisCombinedHadronSpectra.cxx:268
 AliAnalysisCombinedHadronSpectra.cxx:269
 AliAnalysisCombinedHadronSpectra.cxx:270
 AliAnalysisCombinedHadronSpectra.cxx:271
 AliAnalysisCombinedHadronSpectra.cxx:272
 AliAnalysisCombinedHadronSpectra.cxx:273
 AliAnalysisCombinedHadronSpectra.cxx:274
 AliAnalysisCombinedHadronSpectra.cxx:275
 AliAnalysisCombinedHadronSpectra.cxx:276
 AliAnalysisCombinedHadronSpectra.cxx:277
 AliAnalysisCombinedHadronSpectra.cxx:278
 AliAnalysisCombinedHadronSpectra.cxx:279
 AliAnalysisCombinedHadronSpectra.cxx:280
 AliAnalysisCombinedHadronSpectra.cxx:281
 AliAnalysisCombinedHadronSpectra.cxx:282
 AliAnalysisCombinedHadronSpectra.cxx:283
 AliAnalysisCombinedHadronSpectra.cxx:284
 AliAnalysisCombinedHadronSpectra.cxx:285
 AliAnalysisCombinedHadronSpectra.cxx:286
 AliAnalysisCombinedHadronSpectra.cxx:287
 AliAnalysisCombinedHadronSpectra.cxx:288
 AliAnalysisCombinedHadronSpectra.cxx:289
 AliAnalysisCombinedHadronSpectra.cxx:290
 AliAnalysisCombinedHadronSpectra.cxx:291
 AliAnalysisCombinedHadronSpectra.cxx:292
 AliAnalysisCombinedHadronSpectra.cxx:293
 AliAnalysisCombinedHadronSpectra.cxx:294
 AliAnalysisCombinedHadronSpectra.cxx:295
 AliAnalysisCombinedHadronSpectra.cxx:296
 AliAnalysisCombinedHadronSpectra.cxx:297
 AliAnalysisCombinedHadronSpectra.cxx:298
 AliAnalysisCombinedHadronSpectra.cxx:299
 AliAnalysisCombinedHadronSpectra.cxx:300
 AliAnalysisCombinedHadronSpectra.cxx:301
 AliAnalysisCombinedHadronSpectra.cxx:302
 AliAnalysisCombinedHadronSpectra.cxx:303
 AliAnalysisCombinedHadronSpectra.cxx:304
 AliAnalysisCombinedHadronSpectra.cxx:305
 AliAnalysisCombinedHadronSpectra.cxx:306
 AliAnalysisCombinedHadronSpectra.cxx:307
 AliAnalysisCombinedHadronSpectra.cxx:308
 AliAnalysisCombinedHadronSpectra.cxx:309
 AliAnalysisCombinedHadronSpectra.cxx:310
 AliAnalysisCombinedHadronSpectra.cxx:311
 AliAnalysisCombinedHadronSpectra.cxx:312
 AliAnalysisCombinedHadronSpectra.cxx:313
 AliAnalysisCombinedHadronSpectra.cxx:314
 AliAnalysisCombinedHadronSpectra.cxx:315
 AliAnalysisCombinedHadronSpectra.cxx:316
 AliAnalysisCombinedHadronSpectra.cxx:317
 AliAnalysisCombinedHadronSpectra.cxx:318
 AliAnalysisCombinedHadronSpectra.cxx:319
 AliAnalysisCombinedHadronSpectra.cxx:320
 AliAnalysisCombinedHadronSpectra.cxx:321
 AliAnalysisCombinedHadronSpectra.cxx:322
 AliAnalysisCombinedHadronSpectra.cxx:323
 AliAnalysisCombinedHadronSpectra.cxx:324
 AliAnalysisCombinedHadronSpectra.cxx:325
 AliAnalysisCombinedHadronSpectra.cxx:326
 AliAnalysisCombinedHadronSpectra.cxx:327
 AliAnalysisCombinedHadronSpectra.cxx:328
 AliAnalysisCombinedHadronSpectra.cxx:329
 AliAnalysisCombinedHadronSpectra.cxx:330
 AliAnalysisCombinedHadronSpectra.cxx:331
 AliAnalysisCombinedHadronSpectra.cxx:332
 AliAnalysisCombinedHadronSpectra.cxx:333
 AliAnalysisCombinedHadronSpectra.cxx:334
 AliAnalysisCombinedHadronSpectra.cxx:335
 AliAnalysisCombinedHadronSpectra.cxx:336
 AliAnalysisCombinedHadronSpectra.cxx:337
 AliAnalysisCombinedHadronSpectra.cxx:338
 AliAnalysisCombinedHadronSpectra.cxx:339
 AliAnalysisCombinedHadronSpectra.cxx:340
 AliAnalysisCombinedHadronSpectra.cxx:341
 AliAnalysisCombinedHadronSpectra.cxx:342
 AliAnalysisCombinedHadronSpectra.cxx:343
 AliAnalysisCombinedHadronSpectra.cxx:344
 AliAnalysisCombinedHadronSpectra.cxx:345
 AliAnalysisCombinedHadronSpectra.cxx:346
 AliAnalysisCombinedHadronSpectra.cxx:347
 AliAnalysisCombinedHadronSpectra.cxx:348
 AliAnalysisCombinedHadronSpectra.cxx:349
 AliAnalysisCombinedHadronSpectra.cxx:350
 AliAnalysisCombinedHadronSpectra.cxx:351
 AliAnalysisCombinedHadronSpectra.cxx:352
 AliAnalysisCombinedHadronSpectra.cxx:353
 AliAnalysisCombinedHadronSpectra.cxx:354
 AliAnalysisCombinedHadronSpectra.cxx:355
 AliAnalysisCombinedHadronSpectra.cxx:356
 AliAnalysisCombinedHadronSpectra.cxx:357
 AliAnalysisCombinedHadronSpectra.cxx:358
 AliAnalysisCombinedHadronSpectra.cxx:359
 AliAnalysisCombinedHadronSpectra.cxx:360
 AliAnalysisCombinedHadronSpectra.cxx:361
 AliAnalysisCombinedHadronSpectra.cxx:362
 AliAnalysisCombinedHadronSpectra.cxx:363
 AliAnalysisCombinedHadronSpectra.cxx:364
 AliAnalysisCombinedHadronSpectra.cxx:365
 AliAnalysisCombinedHadronSpectra.cxx:366
 AliAnalysisCombinedHadronSpectra.cxx:367
 AliAnalysisCombinedHadronSpectra.cxx:368
 AliAnalysisCombinedHadronSpectra.cxx:369
 AliAnalysisCombinedHadronSpectra.cxx:370
 AliAnalysisCombinedHadronSpectra.cxx:371
 AliAnalysisCombinedHadronSpectra.cxx:372
 AliAnalysisCombinedHadronSpectra.cxx:373
 AliAnalysisCombinedHadronSpectra.cxx:374
 AliAnalysisCombinedHadronSpectra.cxx:375
 AliAnalysisCombinedHadronSpectra.cxx:376
 AliAnalysisCombinedHadronSpectra.cxx:377
 AliAnalysisCombinedHadronSpectra.cxx:378
 AliAnalysisCombinedHadronSpectra.cxx:379
 AliAnalysisCombinedHadronSpectra.cxx:380
 AliAnalysisCombinedHadronSpectra.cxx:381
 AliAnalysisCombinedHadronSpectra.cxx:382
 AliAnalysisCombinedHadronSpectra.cxx:383
 AliAnalysisCombinedHadronSpectra.cxx:384
 AliAnalysisCombinedHadronSpectra.cxx:385
 AliAnalysisCombinedHadronSpectra.cxx:386
 AliAnalysisCombinedHadronSpectra.cxx:387
 AliAnalysisCombinedHadronSpectra.cxx:388
 AliAnalysisCombinedHadronSpectra.cxx:389
 AliAnalysisCombinedHadronSpectra.cxx:390
 AliAnalysisCombinedHadronSpectra.cxx:391
 AliAnalysisCombinedHadronSpectra.cxx:392
 AliAnalysisCombinedHadronSpectra.cxx:393
 AliAnalysisCombinedHadronSpectra.cxx:394
 AliAnalysisCombinedHadronSpectra.cxx:395
 AliAnalysisCombinedHadronSpectra.cxx:396
 AliAnalysisCombinedHadronSpectra.cxx:397
 AliAnalysisCombinedHadronSpectra.cxx:398
 AliAnalysisCombinedHadronSpectra.cxx:399
 AliAnalysisCombinedHadronSpectra.cxx:400
 AliAnalysisCombinedHadronSpectra.cxx:401
 AliAnalysisCombinedHadronSpectra.cxx:402
 AliAnalysisCombinedHadronSpectra.cxx:403
 AliAnalysisCombinedHadronSpectra.cxx:404
 AliAnalysisCombinedHadronSpectra.cxx:405
 AliAnalysisCombinedHadronSpectra.cxx:406
 AliAnalysisCombinedHadronSpectra.cxx:407
 AliAnalysisCombinedHadronSpectra.cxx:408
 AliAnalysisCombinedHadronSpectra.cxx:409
 AliAnalysisCombinedHadronSpectra.cxx:410
 AliAnalysisCombinedHadronSpectra.cxx:411
 AliAnalysisCombinedHadronSpectra.cxx:412
 AliAnalysisCombinedHadronSpectra.cxx:413
 AliAnalysisCombinedHadronSpectra.cxx:414
 AliAnalysisCombinedHadronSpectra.cxx:415
 AliAnalysisCombinedHadronSpectra.cxx:416
 AliAnalysisCombinedHadronSpectra.cxx:417
 AliAnalysisCombinedHadronSpectra.cxx:418
 AliAnalysisCombinedHadronSpectra.cxx:419
 AliAnalysisCombinedHadronSpectra.cxx:420
 AliAnalysisCombinedHadronSpectra.cxx:421
 AliAnalysisCombinedHadronSpectra.cxx:422
 AliAnalysisCombinedHadronSpectra.cxx:423
 AliAnalysisCombinedHadronSpectra.cxx:424
 AliAnalysisCombinedHadronSpectra.cxx:425
 AliAnalysisCombinedHadronSpectra.cxx:426
 AliAnalysisCombinedHadronSpectra.cxx:427
 AliAnalysisCombinedHadronSpectra.cxx:428
 AliAnalysisCombinedHadronSpectra.cxx:429
 AliAnalysisCombinedHadronSpectra.cxx:430
 AliAnalysisCombinedHadronSpectra.cxx:431
 AliAnalysisCombinedHadronSpectra.cxx:432
 AliAnalysisCombinedHadronSpectra.cxx:433
 AliAnalysisCombinedHadronSpectra.cxx:434
 AliAnalysisCombinedHadronSpectra.cxx:435
 AliAnalysisCombinedHadronSpectra.cxx:436
 AliAnalysisCombinedHadronSpectra.cxx:437
 AliAnalysisCombinedHadronSpectra.cxx:438
 AliAnalysisCombinedHadronSpectra.cxx:439
 AliAnalysisCombinedHadronSpectra.cxx:440
 AliAnalysisCombinedHadronSpectra.cxx:441
 AliAnalysisCombinedHadronSpectra.cxx:442
 AliAnalysisCombinedHadronSpectra.cxx:443
 AliAnalysisCombinedHadronSpectra.cxx:444
 AliAnalysisCombinedHadronSpectra.cxx:445
 AliAnalysisCombinedHadronSpectra.cxx:446
 AliAnalysisCombinedHadronSpectra.cxx:447
 AliAnalysisCombinedHadronSpectra.cxx:448
 AliAnalysisCombinedHadronSpectra.cxx:449
 AliAnalysisCombinedHadronSpectra.cxx:450
 AliAnalysisCombinedHadronSpectra.cxx:451
 AliAnalysisCombinedHadronSpectra.cxx:452
 AliAnalysisCombinedHadronSpectra.cxx:453
 AliAnalysisCombinedHadronSpectra.cxx:454
 AliAnalysisCombinedHadronSpectra.cxx:455
 AliAnalysisCombinedHadronSpectra.cxx:456
 AliAnalysisCombinedHadronSpectra.cxx:457
 AliAnalysisCombinedHadronSpectra.cxx:458
 AliAnalysisCombinedHadronSpectra.cxx:459
 AliAnalysisCombinedHadronSpectra.cxx:460
 AliAnalysisCombinedHadronSpectra.cxx:461
 AliAnalysisCombinedHadronSpectra.cxx:462
 AliAnalysisCombinedHadronSpectra.cxx:463
 AliAnalysisCombinedHadronSpectra.cxx:464
 AliAnalysisCombinedHadronSpectra.cxx:465
 AliAnalysisCombinedHadronSpectra.cxx:466
 AliAnalysisCombinedHadronSpectra.cxx:467
 AliAnalysisCombinedHadronSpectra.cxx:468
 AliAnalysisCombinedHadronSpectra.cxx:469
 AliAnalysisCombinedHadronSpectra.cxx:470
 AliAnalysisCombinedHadronSpectra.cxx:471
 AliAnalysisCombinedHadronSpectra.cxx:472
 AliAnalysisCombinedHadronSpectra.cxx:473
 AliAnalysisCombinedHadronSpectra.cxx:474
 AliAnalysisCombinedHadronSpectra.cxx:475
 AliAnalysisCombinedHadronSpectra.cxx:476
 AliAnalysisCombinedHadronSpectra.cxx:477
 AliAnalysisCombinedHadronSpectra.cxx:478
 AliAnalysisCombinedHadronSpectra.cxx:479
 AliAnalysisCombinedHadronSpectra.cxx:480
 AliAnalysisCombinedHadronSpectra.cxx:481
 AliAnalysisCombinedHadronSpectra.cxx:482
 AliAnalysisCombinedHadronSpectra.cxx:483
 AliAnalysisCombinedHadronSpectra.cxx:484
 AliAnalysisCombinedHadronSpectra.cxx:485
 AliAnalysisCombinedHadronSpectra.cxx:486
 AliAnalysisCombinedHadronSpectra.cxx:487
 AliAnalysisCombinedHadronSpectra.cxx:488
 AliAnalysisCombinedHadronSpectra.cxx:489
 AliAnalysisCombinedHadronSpectra.cxx:490
 AliAnalysisCombinedHadronSpectra.cxx:491
 AliAnalysisCombinedHadronSpectra.cxx:492
 AliAnalysisCombinedHadronSpectra.cxx:493
 AliAnalysisCombinedHadronSpectra.cxx:494
 AliAnalysisCombinedHadronSpectra.cxx:495
 AliAnalysisCombinedHadronSpectra.cxx:496
 AliAnalysisCombinedHadronSpectra.cxx:497
 AliAnalysisCombinedHadronSpectra.cxx:498
 AliAnalysisCombinedHadronSpectra.cxx:499
 AliAnalysisCombinedHadronSpectra.cxx:500
 AliAnalysisCombinedHadronSpectra.cxx:501
 AliAnalysisCombinedHadronSpectra.cxx:502
 AliAnalysisCombinedHadronSpectra.cxx:503
 AliAnalysisCombinedHadronSpectra.cxx:504
 AliAnalysisCombinedHadronSpectra.cxx:505
 AliAnalysisCombinedHadronSpectra.cxx:506
 AliAnalysisCombinedHadronSpectra.cxx:507
 AliAnalysisCombinedHadronSpectra.cxx:508
 AliAnalysisCombinedHadronSpectra.cxx:509
 AliAnalysisCombinedHadronSpectra.cxx:510
 AliAnalysisCombinedHadronSpectra.cxx:511
 AliAnalysisCombinedHadronSpectra.cxx:512
 AliAnalysisCombinedHadronSpectra.cxx:513
 AliAnalysisCombinedHadronSpectra.cxx:514
 AliAnalysisCombinedHadronSpectra.cxx:515
 AliAnalysisCombinedHadronSpectra.cxx:516
 AliAnalysisCombinedHadronSpectra.cxx:517
 AliAnalysisCombinedHadronSpectra.cxx:518
 AliAnalysisCombinedHadronSpectra.cxx:519
 AliAnalysisCombinedHadronSpectra.cxx:520
 AliAnalysisCombinedHadronSpectra.cxx:521
 AliAnalysisCombinedHadronSpectra.cxx:522
 AliAnalysisCombinedHadronSpectra.cxx:523
 AliAnalysisCombinedHadronSpectra.cxx:524
 AliAnalysisCombinedHadronSpectra.cxx:525
 AliAnalysisCombinedHadronSpectra.cxx:526
 AliAnalysisCombinedHadronSpectra.cxx:527
 AliAnalysisCombinedHadronSpectra.cxx:528
 AliAnalysisCombinedHadronSpectra.cxx:529
 AliAnalysisCombinedHadronSpectra.cxx:530
 AliAnalysisCombinedHadronSpectra.cxx:531
 AliAnalysisCombinedHadronSpectra.cxx:532
 AliAnalysisCombinedHadronSpectra.cxx:533
 AliAnalysisCombinedHadronSpectra.cxx:534
 AliAnalysisCombinedHadronSpectra.cxx:535
 AliAnalysisCombinedHadronSpectra.cxx:536
 AliAnalysisCombinedHadronSpectra.cxx:537
 AliAnalysisCombinedHadronSpectra.cxx:538
 AliAnalysisCombinedHadronSpectra.cxx:539
 AliAnalysisCombinedHadronSpectra.cxx:540
 AliAnalysisCombinedHadronSpectra.cxx:541
 AliAnalysisCombinedHadronSpectra.cxx:542
 AliAnalysisCombinedHadronSpectra.cxx:543
 AliAnalysisCombinedHadronSpectra.cxx:544
 AliAnalysisCombinedHadronSpectra.cxx:545
 AliAnalysisCombinedHadronSpectra.cxx:546
 AliAnalysisCombinedHadronSpectra.cxx:547
 AliAnalysisCombinedHadronSpectra.cxx:548
 AliAnalysisCombinedHadronSpectra.cxx:549
 AliAnalysisCombinedHadronSpectra.cxx:550
 AliAnalysisCombinedHadronSpectra.cxx:551
 AliAnalysisCombinedHadronSpectra.cxx:552
 AliAnalysisCombinedHadronSpectra.cxx:553
 AliAnalysisCombinedHadronSpectra.cxx:554
 AliAnalysisCombinedHadronSpectra.cxx:555
 AliAnalysisCombinedHadronSpectra.cxx:556
 AliAnalysisCombinedHadronSpectra.cxx:557
 AliAnalysisCombinedHadronSpectra.cxx:558
 AliAnalysisCombinedHadronSpectra.cxx:559
 AliAnalysisCombinedHadronSpectra.cxx:560
 AliAnalysisCombinedHadronSpectra.cxx:561
 AliAnalysisCombinedHadronSpectra.cxx:562
 AliAnalysisCombinedHadronSpectra.cxx:563
 AliAnalysisCombinedHadronSpectra.cxx:564
 AliAnalysisCombinedHadronSpectra.cxx:565
 AliAnalysisCombinedHadronSpectra.cxx:566
 AliAnalysisCombinedHadronSpectra.cxx:567
 AliAnalysisCombinedHadronSpectra.cxx:568
 AliAnalysisCombinedHadronSpectra.cxx:569
 AliAnalysisCombinedHadronSpectra.cxx:570
 AliAnalysisCombinedHadronSpectra.cxx:571
 AliAnalysisCombinedHadronSpectra.cxx:572
 AliAnalysisCombinedHadronSpectra.cxx:573
 AliAnalysisCombinedHadronSpectra.cxx:574
 AliAnalysisCombinedHadronSpectra.cxx:575
 AliAnalysisCombinedHadronSpectra.cxx:576
 AliAnalysisCombinedHadronSpectra.cxx:577
 AliAnalysisCombinedHadronSpectra.cxx:578
 AliAnalysisCombinedHadronSpectra.cxx:579
 AliAnalysisCombinedHadronSpectra.cxx:580
 AliAnalysisCombinedHadronSpectra.cxx:581
 AliAnalysisCombinedHadronSpectra.cxx:582
 AliAnalysisCombinedHadronSpectra.cxx:583
 AliAnalysisCombinedHadronSpectra.cxx:584
 AliAnalysisCombinedHadronSpectra.cxx:585
 AliAnalysisCombinedHadronSpectra.cxx:586
 AliAnalysisCombinedHadronSpectra.cxx:587
 AliAnalysisCombinedHadronSpectra.cxx:588
 AliAnalysisCombinedHadronSpectra.cxx:589
 AliAnalysisCombinedHadronSpectra.cxx:590
 AliAnalysisCombinedHadronSpectra.cxx:591
 AliAnalysisCombinedHadronSpectra.cxx:592
 AliAnalysisCombinedHadronSpectra.cxx:593
 AliAnalysisCombinedHadronSpectra.cxx:594
 AliAnalysisCombinedHadronSpectra.cxx:595
 AliAnalysisCombinedHadronSpectra.cxx:596
 AliAnalysisCombinedHadronSpectra.cxx:597
 AliAnalysisCombinedHadronSpectra.cxx:598
 AliAnalysisCombinedHadronSpectra.cxx:599
 AliAnalysisCombinedHadronSpectra.cxx:600
 AliAnalysisCombinedHadronSpectra.cxx:601
 AliAnalysisCombinedHadronSpectra.cxx:602
 AliAnalysisCombinedHadronSpectra.cxx:603
 AliAnalysisCombinedHadronSpectra.cxx:604
 AliAnalysisCombinedHadronSpectra.cxx:605
 AliAnalysisCombinedHadronSpectra.cxx:606
 AliAnalysisCombinedHadronSpectra.cxx:607
 AliAnalysisCombinedHadronSpectra.cxx:608
 AliAnalysisCombinedHadronSpectra.cxx:609
 AliAnalysisCombinedHadronSpectra.cxx:610
 AliAnalysisCombinedHadronSpectra.cxx:611
 AliAnalysisCombinedHadronSpectra.cxx:612
 AliAnalysisCombinedHadronSpectra.cxx:613
 AliAnalysisCombinedHadronSpectra.cxx:614
 AliAnalysisCombinedHadronSpectra.cxx:615
 AliAnalysisCombinedHadronSpectra.cxx:616
 AliAnalysisCombinedHadronSpectra.cxx:617
 AliAnalysisCombinedHadronSpectra.cxx:618
 AliAnalysisCombinedHadronSpectra.cxx:619
 AliAnalysisCombinedHadronSpectra.cxx:620
 AliAnalysisCombinedHadronSpectra.cxx:621
 AliAnalysisCombinedHadronSpectra.cxx:622
 AliAnalysisCombinedHadronSpectra.cxx:623
 AliAnalysisCombinedHadronSpectra.cxx:624
 AliAnalysisCombinedHadronSpectra.cxx:625
 AliAnalysisCombinedHadronSpectra.cxx:626
 AliAnalysisCombinedHadronSpectra.cxx:627
 AliAnalysisCombinedHadronSpectra.cxx:628
 AliAnalysisCombinedHadronSpectra.cxx:629
 AliAnalysisCombinedHadronSpectra.cxx:630
 AliAnalysisCombinedHadronSpectra.cxx:631
 AliAnalysisCombinedHadronSpectra.cxx:632
 AliAnalysisCombinedHadronSpectra.cxx:633
 AliAnalysisCombinedHadronSpectra.cxx:634
 AliAnalysisCombinedHadronSpectra.cxx:635
 AliAnalysisCombinedHadronSpectra.cxx:636
 AliAnalysisCombinedHadronSpectra.cxx:637
 AliAnalysisCombinedHadronSpectra.cxx:638
 AliAnalysisCombinedHadronSpectra.cxx:639
 AliAnalysisCombinedHadronSpectra.cxx:640
 AliAnalysisCombinedHadronSpectra.cxx:641
 AliAnalysisCombinedHadronSpectra.cxx:642
 AliAnalysisCombinedHadronSpectra.cxx:643
 AliAnalysisCombinedHadronSpectra.cxx:644
 AliAnalysisCombinedHadronSpectra.cxx:645
 AliAnalysisCombinedHadronSpectra.cxx:646
 AliAnalysisCombinedHadronSpectra.cxx:647
 AliAnalysisCombinedHadronSpectra.cxx:648
 AliAnalysisCombinedHadronSpectra.cxx:649
 AliAnalysisCombinedHadronSpectra.cxx:650
 AliAnalysisCombinedHadronSpectra.cxx:651
 AliAnalysisCombinedHadronSpectra.cxx:652
 AliAnalysisCombinedHadronSpectra.cxx:653
 AliAnalysisCombinedHadronSpectra.cxx:654
 AliAnalysisCombinedHadronSpectra.cxx:655
 AliAnalysisCombinedHadronSpectra.cxx:656
 AliAnalysisCombinedHadronSpectra.cxx:657
 AliAnalysisCombinedHadronSpectra.cxx:658
 AliAnalysisCombinedHadronSpectra.cxx:659
 AliAnalysisCombinedHadronSpectra.cxx:660
 AliAnalysisCombinedHadronSpectra.cxx:661
 AliAnalysisCombinedHadronSpectra.cxx:662
 AliAnalysisCombinedHadronSpectra.cxx:663
 AliAnalysisCombinedHadronSpectra.cxx:664
 AliAnalysisCombinedHadronSpectra.cxx:665
 AliAnalysisCombinedHadronSpectra.cxx:666
 AliAnalysisCombinedHadronSpectra.cxx:667
 AliAnalysisCombinedHadronSpectra.cxx:668
 AliAnalysisCombinedHadronSpectra.cxx:669
 AliAnalysisCombinedHadronSpectra.cxx:670
 AliAnalysisCombinedHadronSpectra.cxx:671
 AliAnalysisCombinedHadronSpectra.cxx:672
 AliAnalysisCombinedHadronSpectra.cxx:673
 AliAnalysisCombinedHadronSpectra.cxx:674
 AliAnalysisCombinedHadronSpectra.cxx:675
 AliAnalysisCombinedHadronSpectra.cxx:676
 AliAnalysisCombinedHadronSpectra.cxx:677
 AliAnalysisCombinedHadronSpectra.cxx:678
 AliAnalysisCombinedHadronSpectra.cxx:679
 AliAnalysisCombinedHadronSpectra.cxx:680
 AliAnalysisCombinedHadronSpectra.cxx:681
 AliAnalysisCombinedHadronSpectra.cxx:682
 AliAnalysisCombinedHadronSpectra.cxx:683
 AliAnalysisCombinedHadronSpectra.cxx:684
 AliAnalysisCombinedHadronSpectra.cxx:685
 AliAnalysisCombinedHadronSpectra.cxx:686
 AliAnalysisCombinedHadronSpectra.cxx:687
 AliAnalysisCombinedHadronSpectra.cxx:688
 AliAnalysisCombinedHadronSpectra.cxx:689
 AliAnalysisCombinedHadronSpectra.cxx:690
 AliAnalysisCombinedHadronSpectra.cxx:691
 AliAnalysisCombinedHadronSpectra.cxx:692
 AliAnalysisCombinedHadronSpectra.cxx:693
 AliAnalysisCombinedHadronSpectra.cxx:694
 AliAnalysisCombinedHadronSpectra.cxx:695
 AliAnalysisCombinedHadronSpectra.cxx:696
 AliAnalysisCombinedHadronSpectra.cxx:697
 AliAnalysisCombinedHadronSpectra.cxx:698
 AliAnalysisCombinedHadronSpectra.cxx:699
 AliAnalysisCombinedHadronSpectra.cxx:700
 AliAnalysisCombinedHadronSpectra.cxx:701
 AliAnalysisCombinedHadronSpectra.cxx:702
 AliAnalysisCombinedHadronSpectra.cxx:703
 AliAnalysisCombinedHadronSpectra.cxx:704
 AliAnalysisCombinedHadronSpectra.cxx:705
 AliAnalysisCombinedHadronSpectra.cxx:706
 AliAnalysisCombinedHadronSpectra.cxx:707
 AliAnalysisCombinedHadronSpectra.cxx:708
 AliAnalysisCombinedHadronSpectra.cxx:709
 AliAnalysisCombinedHadronSpectra.cxx:710
 AliAnalysisCombinedHadronSpectra.cxx:711
 AliAnalysisCombinedHadronSpectra.cxx:712
 AliAnalysisCombinedHadronSpectra.cxx:713
 AliAnalysisCombinedHadronSpectra.cxx:714
 AliAnalysisCombinedHadronSpectra.cxx:715
 AliAnalysisCombinedHadronSpectra.cxx:716
 AliAnalysisCombinedHadronSpectra.cxx:717
 AliAnalysisCombinedHadronSpectra.cxx:718
 AliAnalysisCombinedHadronSpectra.cxx:719
 AliAnalysisCombinedHadronSpectra.cxx:720
 AliAnalysisCombinedHadronSpectra.cxx:721
 AliAnalysisCombinedHadronSpectra.cxx:722
 AliAnalysisCombinedHadronSpectra.cxx:723
 AliAnalysisCombinedHadronSpectra.cxx:724
 AliAnalysisCombinedHadronSpectra.cxx:725
 AliAnalysisCombinedHadronSpectra.cxx:726
 AliAnalysisCombinedHadronSpectra.cxx:727
 AliAnalysisCombinedHadronSpectra.cxx:728
 AliAnalysisCombinedHadronSpectra.cxx:729
 AliAnalysisCombinedHadronSpectra.cxx:730
 AliAnalysisCombinedHadronSpectra.cxx:731
 AliAnalysisCombinedHadronSpectra.cxx:732
 AliAnalysisCombinedHadronSpectra.cxx:733
 AliAnalysisCombinedHadronSpectra.cxx:734
 AliAnalysisCombinedHadronSpectra.cxx:735
 AliAnalysisCombinedHadronSpectra.cxx:736
 AliAnalysisCombinedHadronSpectra.cxx:737
 AliAnalysisCombinedHadronSpectra.cxx:738
 AliAnalysisCombinedHadronSpectra.cxx:739
 AliAnalysisCombinedHadronSpectra.cxx:740
 AliAnalysisCombinedHadronSpectra.cxx:741
 AliAnalysisCombinedHadronSpectra.cxx:742
 AliAnalysisCombinedHadronSpectra.cxx:743
 AliAnalysisCombinedHadronSpectra.cxx:744
 AliAnalysisCombinedHadronSpectra.cxx:745
 AliAnalysisCombinedHadronSpectra.cxx:746
 AliAnalysisCombinedHadronSpectra.cxx:747
 AliAnalysisCombinedHadronSpectra.cxx:748
 AliAnalysisCombinedHadronSpectra.cxx:749
 AliAnalysisCombinedHadronSpectra.cxx:750
 AliAnalysisCombinedHadronSpectra.cxx:751
 AliAnalysisCombinedHadronSpectra.cxx:752
 AliAnalysisCombinedHadronSpectra.cxx:753
 AliAnalysisCombinedHadronSpectra.cxx:754
 AliAnalysisCombinedHadronSpectra.cxx:755
 AliAnalysisCombinedHadronSpectra.cxx:756
 AliAnalysisCombinedHadronSpectra.cxx:757
 AliAnalysisCombinedHadronSpectra.cxx:758
 AliAnalysisCombinedHadronSpectra.cxx:759
 AliAnalysisCombinedHadronSpectra.cxx:760
 AliAnalysisCombinedHadronSpectra.cxx:761
 AliAnalysisCombinedHadronSpectra.cxx:762
 AliAnalysisCombinedHadronSpectra.cxx:763
 AliAnalysisCombinedHadronSpectra.cxx:764
 AliAnalysisCombinedHadronSpectra.cxx:765
 AliAnalysisCombinedHadronSpectra.cxx:766
 AliAnalysisCombinedHadronSpectra.cxx:767
 AliAnalysisCombinedHadronSpectra.cxx:768
 AliAnalysisCombinedHadronSpectra.cxx:769
 AliAnalysisCombinedHadronSpectra.cxx:770
 AliAnalysisCombinedHadronSpectra.cxx:771
 AliAnalysisCombinedHadronSpectra.cxx:772
 AliAnalysisCombinedHadronSpectra.cxx:773
 AliAnalysisCombinedHadronSpectra.cxx:774
 AliAnalysisCombinedHadronSpectra.cxx:775
 AliAnalysisCombinedHadronSpectra.cxx:776
 AliAnalysisCombinedHadronSpectra.cxx:777
 AliAnalysisCombinedHadronSpectra.cxx:778
 AliAnalysisCombinedHadronSpectra.cxx:779
 AliAnalysisCombinedHadronSpectra.cxx:780
 AliAnalysisCombinedHadronSpectra.cxx:781
 AliAnalysisCombinedHadronSpectra.cxx:782
 AliAnalysisCombinedHadronSpectra.cxx:783
 AliAnalysisCombinedHadronSpectra.cxx:784
 AliAnalysisCombinedHadronSpectra.cxx:785
 AliAnalysisCombinedHadronSpectra.cxx:786
 AliAnalysisCombinedHadronSpectra.cxx:787
 AliAnalysisCombinedHadronSpectra.cxx:788
 AliAnalysisCombinedHadronSpectra.cxx:789
 AliAnalysisCombinedHadronSpectra.cxx:790
 AliAnalysisCombinedHadronSpectra.cxx:791
 AliAnalysisCombinedHadronSpectra.cxx:792
 AliAnalysisCombinedHadronSpectra.cxx:793
 AliAnalysisCombinedHadronSpectra.cxx:794
 AliAnalysisCombinedHadronSpectra.cxx:795
 AliAnalysisCombinedHadronSpectra.cxx:796
 AliAnalysisCombinedHadronSpectra.cxx:797
 AliAnalysisCombinedHadronSpectra.cxx:798
 AliAnalysisCombinedHadronSpectra.cxx:799
 AliAnalysisCombinedHadronSpectra.cxx:800
 AliAnalysisCombinedHadronSpectra.cxx:801
 AliAnalysisCombinedHadronSpectra.cxx:802
 AliAnalysisCombinedHadronSpectra.cxx:803
 AliAnalysisCombinedHadronSpectra.cxx:804
 AliAnalysisCombinedHadronSpectra.cxx:805
 AliAnalysisCombinedHadronSpectra.cxx:806
 AliAnalysisCombinedHadronSpectra.cxx:807
 AliAnalysisCombinedHadronSpectra.cxx:808
 AliAnalysisCombinedHadronSpectra.cxx:809
 AliAnalysisCombinedHadronSpectra.cxx:810
 AliAnalysisCombinedHadronSpectra.cxx:811
 AliAnalysisCombinedHadronSpectra.cxx:812
 AliAnalysisCombinedHadronSpectra.cxx:813
 AliAnalysisCombinedHadronSpectra.cxx:814
 AliAnalysisCombinedHadronSpectra.cxx:815
 AliAnalysisCombinedHadronSpectra.cxx:816
 AliAnalysisCombinedHadronSpectra.cxx:817
 AliAnalysisCombinedHadronSpectra.cxx:818
 AliAnalysisCombinedHadronSpectra.cxx:819
 AliAnalysisCombinedHadronSpectra.cxx:820
 AliAnalysisCombinedHadronSpectra.cxx:821
 AliAnalysisCombinedHadronSpectra.cxx:822
 AliAnalysisCombinedHadronSpectra.cxx:823
 AliAnalysisCombinedHadronSpectra.cxx:824
 AliAnalysisCombinedHadronSpectra.cxx:825
 AliAnalysisCombinedHadronSpectra.cxx:826
 AliAnalysisCombinedHadronSpectra.cxx:827
 AliAnalysisCombinedHadronSpectra.cxx:828
 AliAnalysisCombinedHadronSpectra.cxx:829
 AliAnalysisCombinedHadronSpectra.cxx:830
 AliAnalysisCombinedHadronSpectra.cxx:831
 AliAnalysisCombinedHadronSpectra.cxx:832
 AliAnalysisCombinedHadronSpectra.cxx:833
 AliAnalysisCombinedHadronSpectra.cxx:834
 AliAnalysisCombinedHadronSpectra.cxx:835
 AliAnalysisCombinedHadronSpectra.cxx:836
 AliAnalysisCombinedHadronSpectra.cxx:837
 AliAnalysisCombinedHadronSpectra.cxx:838
 AliAnalysisCombinedHadronSpectra.cxx:839
 AliAnalysisCombinedHadronSpectra.cxx:840
 AliAnalysisCombinedHadronSpectra.cxx:841
 AliAnalysisCombinedHadronSpectra.cxx:842
 AliAnalysisCombinedHadronSpectra.cxx:843
 AliAnalysisCombinedHadronSpectra.cxx:844
 AliAnalysisCombinedHadronSpectra.cxx:845
 AliAnalysisCombinedHadronSpectra.cxx:846
 AliAnalysisCombinedHadronSpectra.cxx:847
 AliAnalysisCombinedHadronSpectra.cxx:848
 AliAnalysisCombinedHadronSpectra.cxx:849
 AliAnalysisCombinedHadronSpectra.cxx:850
 AliAnalysisCombinedHadronSpectra.cxx:851
 AliAnalysisCombinedHadronSpectra.cxx:852
 AliAnalysisCombinedHadronSpectra.cxx:853
 AliAnalysisCombinedHadronSpectra.cxx:854
 AliAnalysisCombinedHadronSpectra.cxx:855
 AliAnalysisCombinedHadronSpectra.cxx:856
 AliAnalysisCombinedHadronSpectra.cxx:857
 AliAnalysisCombinedHadronSpectra.cxx:858
 AliAnalysisCombinedHadronSpectra.cxx:859
 AliAnalysisCombinedHadronSpectra.cxx:860
 AliAnalysisCombinedHadronSpectra.cxx:861
 AliAnalysisCombinedHadronSpectra.cxx:862
 AliAnalysisCombinedHadronSpectra.cxx:863
 AliAnalysisCombinedHadronSpectra.cxx:864
 AliAnalysisCombinedHadronSpectra.cxx:865
 AliAnalysisCombinedHadronSpectra.cxx:866
 AliAnalysisCombinedHadronSpectra.cxx:867
 AliAnalysisCombinedHadronSpectra.cxx:868
 AliAnalysisCombinedHadronSpectra.cxx:869
 AliAnalysisCombinedHadronSpectra.cxx:870
 AliAnalysisCombinedHadronSpectra.cxx:871
 AliAnalysisCombinedHadronSpectra.cxx:872
 AliAnalysisCombinedHadronSpectra.cxx:873
 AliAnalysisCombinedHadronSpectra.cxx:874
 AliAnalysisCombinedHadronSpectra.cxx:875
 AliAnalysisCombinedHadronSpectra.cxx:876
 AliAnalysisCombinedHadronSpectra.cxx:877
 AliAnalysisCombinedHadronSpectra.cxx:878
 AliAnalysisCombinedHadronSpectra.cxx:879
 AliAnalysisCombinedHadronSpectra.cxx:880
 AliAnalysisCombinedHadronSpectra.cxx:881
 AliAnalysisCombinedHadronSpectra.cxx:882
 AliAnalysisCombinedHadronSpectra.cxx:883
 AliAnalysisCombinedHadronSpectra.cxx:884
 AliAnalysisCombinedHadronSpectra.cxx:885
 AliAnalysisCombinedHadronSpectra.cxx:886
 AliAnalysisCombinedHadronSpectra.cxx:887
 AliAnalysisCombinedHadronSpectra.cxx:888
 AliAnalysisCombinedHadronSpectra.cxx:889
 AliAnalysisCombinedHadronSpectra.cxx:890
 AliAnalysisCombinedHadronSpectra.cxx:891
 AliAnalysisCombinedHadronSpectra.cxx:892
 AliAnalysisCombinedHadronSpectra.cxx:893
 AliAnalysisCombinedHadronSpectra.cxx:894
 AliAnalysisCombinedHadronSpectra.cxx:895
 AliAnalysisCombinedHadronSpectra.cxx:896
 AliAnalysisCombinedHadronSpectra.cxx:897
 AliAnalysisCombinedHadronSpectra.cxx:898
 AliAnalysisCombinedHadronSpectra.cxx:899
 AliAnalysisCombinedHadronSpectra.cxx:900
 AliAnalysisCombinedHadronSpectra.cxx:901
 AliAnalysisCombinedHadronSpectra.cxx:902
 AliAnalysisCombinedHadronSpectra.cxx:903
 AliAnalysisCombinedHadronSpectra.cxx:904
 AliAnalysisCombinedHadronSpectra.cxx:905
 AliAnalysisCombinedHadronSpectra.cxx:906
 AliAnalysisCombinedHadronSpectra.cxx:907
 AliAnalysisCombinedHadronSpectra.cxx:908
 AliAnalysisCombinedHadronSpectra.cxx:909
 AliAnalysisCombinedHadronSpectra.cxx:910
 AliAnalysisCombinedHadronSpectra.cxx:911
 AliAnalysisCombinedHadronSpectra.cxx:912
 AliAnalysisCombinedHadronSpectra.cxx:913
 AliAnalysisCombinedHadronSpectra.cxx:914
 AliAnalysisCombinedHadronSpectra.cxx:915
 AliAnalysisCombinedHadronSpectra.cxx:916
 AliAnalysisCombinedHadronSpectra.cxx:917
 AliAnalysisCombinedHadronSpectra.cxx:918
 AliAnalysisCombinedHadronSpectra.cxx:919