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

/* $Id:$ */

#include <TROOT.h>
#include <TChain.h>
#include <TFile.h>
#include <TList.h>
#include <TMath.h>
#include <TTree.h>
#include <TH2F.h>
#include <TRandom.h>
//#include <TVector3.h>

#include "AliAnalysisTaskLeadingTrackUE.h"
#include "AliAnalyseLeadingTrackUE.h"
#include "AliUEHistograms.h"
#include "AliUEHist.h"

#include "AliAnalysisHelperJetTasks.h"
#include "AliAnalysisManager.h"
#include "AliAODHandler.h"
#include "AliAODInputHandler.h"
#include "AliAODMCParticle.h"
#include "AliGenPythiaEventHeader.h"
#include "AliInputEventHandler.h"
#include "AliLog.h"
#include "AliMCEventHandler.h"
#include "AliVParticle.h"


////////////////////////////////////////////////////////////////////////
//
// Analysis class for Underlying Event studies w.r.t. leading track
//
// Look for correlations on the tranverse regions w.r.t
// the leading track in the event
//
// This class needs input AODs.
// The output is a list of analysis-specific containers.
//
// The AOD can be either connected to the InputEventHandler  
// for a chain of AOD files 
// or 
// to the OutputEventHandler
// for a chain of ESD files,
// in this case the class should be in the train after the jet-finder
//
//    Authors:
//    Arian Abrahantes Quintana 
//    Jan Fiete Grosse-Oetringhaus
//    Ernesto Lopez Torres
//    Sara Vallero
// 
////////////////////////////////////////////////////////////////////////


ClassImp( AliAnalysisTaskLeadingTrackUE )

// Define global pointer
AliAnalysisTaskLeadingTrackUE* AliAnalysisTaskLeadingTrackUE::fgTaskLeadingTrackUE=NULL;

//____________________________________________________________________
AliAnalysisTaskLeadingTrackUE:: AliAnalysisTaskLeadingTrackUE(const char* name):
AliAnalysisTask(name,""),
// general configuration
fDebug(0),
fMode(0),
fReduceMemoryFootprint(kFALSE),
// pointers to UE classes
fAnalyseUE(0x0),
fHistosUE(0x0),
fkTrackingEfficiency(0x0),
// handlers and events
fAOD(0x0),           
fArrayMC(0x0),
fInputHandler(0x0),
fMcEvent(0x0),
fMcHandler(0x0),
// histogram settings
fListOfHistos(0x0), 
fBinsPtInHist(30),     
fMinJetPtInHist(0.),
fMaxJetPtInHist(300.), 
// event QA
fnTracksVertex(1),  // QA tracks pointing to principal vertex (= 3 default) 
fZVertex(10.),
// track cuts
fTrackEtaCut(0.8),
fLeadingTrackEtaCut(0.8),
fFilterBit(0xFF),
fSelectBit(0),
fUseChargeHadrons(kFALSE),
//For MC weighting
fAvgTrials(1)
{
  // Default constructor
  // Define input and output slots here
  // Input slot #0 works with a TChain
  DefineInput(0, TChain::Class());
  // Output slot #0 writes into a TList container
  DefineOutput(0, TList::Class());

}

AliAnalysisTaskLeadingTrackUE::~AliAnalysisTaskLeadingTrackUE() 
{ 
  // destructor
  
  if (fListOfHistos  && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) 
    delete fListOfHistos;
}

/************** INTERFACE METHODS *****************************/

//______________________________________________________________
Bool_t AliAnalysisTaskLeadingTrackUE::Notify()
{
  
  // Implemented Notify() to read the cross sections
  // and number of trials from pyxsec.root.
  // This will be used when merging different MC samples.
  // (Copied from AliAnalysisTaskJFSystematics)
  
  fAvgTrials = 1;
  TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree();
  Float_t xsection = 0;
  Float_t trials  = 1;
  if(tree){
  	TFile *curfile = tree->GetCurrentFile();
  	if (!curfile) {
  		Error("Notify","No current file");
  		return kFALSE;
  		}
  	
	AliAnalysisHelperJetTasks::PythiaInfoFromFile(curfile->GetName(),xsection,trials); 
        
	//TO-DO
        //fHistosUE->GetXsec()->Fill("<#sigma>",xsection);

  	// construct average trials
  	Float_t nEntries = (Float_t)tree->GetTree()->GetEntries();
  	if(trials>=nEntries && nEntries>0.)fAvgTrials = trials/nEntries;
  	}
  
  return kTRUE;
}

//____________________________________________________________________
void AliAnalysisTaskLeadingTrackUE::ConnectInputData(Option_t* /*option*/)
{
  
  // Connect the input data  
  if (fDebug > 1) AliInfo("ConnectInputData() ");
  
  // Since AODs can either be connected to the InputEventHandler
  // or to the OutputEventHandler ( the AOD is created by a previus task in the train )
  // we need to get the pointer to the AODEvent correctly.
  
  // Delta AODs are also accepted.
  
  TObject* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
  
  if( handler && handler->InheritsFrom("AliAODInputHandler") ) { // input AOD
  	fAOD = ((AliAODInputHandler*)handler)->GetEvent();
	if (fDebug > 1) AliInfo(" ==== Tracks and Jets from AliAODInputHandler");
  } else {  //output AOD
  	handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();
  	if( handler && handler->InheritsFrom("AliAODHandler") ) {
  		fAOD = ((AliAODHandler*)handler)->GetAOD();
  		if (fDebug > 1) AliInfo(" ==== Tracks and Jets from AliAODHandler");
 	} else {  // no AOD
		AliFatal("I can't get any AOD Event Handler");
  		return;
  		}
  	}	
  
  // Initialize common pointers
  Initialize();
   
}

//____________________________________________________________________
void  AliAnalysisTaskLeadingTrackUE::CreateOutputObjects()
{
  // Create the output container
  
  if (fDebug > 1) AliInfo("CreateOutputObjects()");
   
  // Initialize class with main algorithms, event and track selection. 
  fAnalyseUE = new AliAnalyseLeadingTrackUE();
  fAnalyseUE->SetParticleSelectionCriteria(fFilterBit, fUseChargeHadrons, fLeadingTrackEtaCut);
  fAnalyseUE->SetDebug(fDebug); 

  // Initialize output list of containers
  if (fListOfHistos != NULL){
	delete fListOfHistos;
        fListOfHistos = NULL;
  	}
  if (!fListOfHistos){
  	fListOfHistos = new TList();
  	fListOfHistos->SetOwner(kTRUE); 
  	}

  // Initialize class to handle histograms 
  fHistosUE = new AliUEHistograms("AliUEHistograms", "123");
  
  // add histograms to list
  fListOfHistos->Add(fHistosUE);
  
  //fListOfHistos->Add(new TH2F("multVsLeadStep5", ";multiplicity;leading pT", 100, -0.5, 99.5, 20, 0, 10));
  
  // Add task configuration to output list 
  AddSettingsTree();
  

  PostData(0,fListOfHistos);
}

//____________________________________________________________________
void  AliAnalysisTaskLeadingTrackUE::Exec(Option_t */*option*/)
{
  // array of MC particles
  if (fMcHandler){
  	fArrayMC = dynamic_cast<TClonesArray*>(fAOD->FindListObject(AliAODMCParticle::StdBranchName()));
  	if (!fArrayMC)AliFatal("No array of MC particles found !!!");
	}

  // Get number of trials from MC header
  
//   Float_t nTrials = 1;
  if (fMcHandler) {
  	fMcEvent = fMcHandler->MCEvent();
//   	if (fMcEvent) {
                // TO-DO: extend to PHOJET
//   		AliGenPythiaEventHeader*  pythiaGenHeader = AliAnalysisHelperJetTasks::GetPythiaEventHeader(fMcEvent);
//   		if(pythiaGenHeader){
//   			nTrials = pythiaGenHeader->Trials();
//   			}
//   		}
  	}

  // TO-DO	
  //fHistosUE->GetTrials()->Fill("#sum{ntrials}",fAvgTrials);
  
  // Analyse the event
  if (fMode) AnalyseCorrectionMode();
  else AnalyseDataMode();

  PostData(0,fListOfHistos);
}

//____________________________________________________________________
void  AliAnalysisTaskLeadingTrackUE::Terminate(Option_t */*option*/)
{
  
  // Terminate analysis
  if( fDebug > 1 ) AliInfo("End analysis");

  if (!gROOT->IsBatch()){
  	fListOfHistos = dynamic_cast<TList*> (GetOutputData(0));
  	if (!fListOfHistos){
		AliError("Histogram List is not available");
		return;
  	}else{
	// Draw something
	}
  } else {
        AliInfo(" Batch mode, not histograms will be shown...");
  	}

}


/******************** ANALYSIS METHODS *****************************/

//____________________________________________________________________
void  AliAnalysisTaskLeadingTrackUE::AddSettingsTree()
{
  //Write settings to output list
  TTree *settingsTree   = new TTree("UEAnalysisSettings","Analysis Settings in UE estimation");
  settingsTree->Branch("fFilterBit", &fFilterBit,"FilterBit/I");
  settingsTree->Branch("fSelectBit", &fSelectBit,"EventSelectionBit/I");
  settingsTree->Branch("fLeadingTrackEtaCut", &fLeadingTrackEtaCut, "LeadingTrackEtaCut/D");
  settingsTree->Branch("fUseChargeHadrons", &fUseChargeHadrons,"UseChHadrons/O");
  settingsTree->Branch("fkTrackingEfficiency", "TH1D", &fkTrackingEfficiency);
  settingsTree->Fill();
  fListOfHistos->Add(settingsTree);
}  

//____________________________________________________________________
void  AliAnalysisTaskLeadingTrackUE::AnalyseCorrectionMode()
{
  // Run the analysis on MC to get the correction maps
  //
  // if fReduceMemoryFootprint step 3,4,5,7,9 are not filled

  PostData(0,fListOfHistos);
  
  if ( fDebug > 3 ) AliInfo( " Processing event in Corrections mode ..." );
  
  //PROCESS TYPE (ND,SD,DD)
  AliAnalysisHelperJetTasks::MCProcessType eventId = AliAnalysisHelperJetTasks::kInvalidProcess;
  AliGenEventHeader* genHeader = fMcEvent->GenEventHeader();
  eventId = AliAnalysisHelperJetTasks::GetPythiaEventProcessType(genHeader,kFALSE);
  if (eventId<0)
    eventId = AliAnalysisHelperJetTasks::GetDPMjetEventProcessType(genHeader,kFALSE);
  if (eventId<0 && fDebug>1)
    AliInfo("No Pythia or Phojet Header retrived!");
    
  Int_t fillId=-1;
  if (eventId == AliAnalysisHelperJetTasks::kND)fillId = 0; 
  if (eventId == AliAnalysisHelperJetTasks::kSD)fillId = 1; 
  if (eventId == AliAnalysisHelperJetTasks::kDD)fillId = 2; 
  
  // count all events
  fHistosUE->FillEvent(fillId, -1);
  
  // Only consider MC events within the vtx-z region used also as cut on the reconstructed vertex
  if (!fAnalyseUE->VertexSelection(fMcEvent, 0, fZVertex)) 
    return;
  
  // Get MC-true leading particle (but do not cut out events!)
  TObjArray *ltMC = (TObjArray*)fAnalyseUE->FindLeadingObjects(fArrayMC);
  AliVParticle* leadingMC = 0;
  if (ltMC)
    leadingMC = (AliVParticle*) ltMC->At(0);
    
  // it can happen that there is no MC leading particle in the acceptance required (|eta|<0.8)
  // and we do not want to base the event slection on MC information
  
  // Sort MC-true charged particles
  // as output you get an array of 3 lists of  particles belonging to different regions:
  // - at 0: towards
  // - at 1: away
  // - at 2: transverse MIN
  // - at 3: transverse MAX
  TObjArray *regionSortedParticlesMC = (TObjArray*)fAnalyseUE->SortRegions(leadingMC, fArrayMC, 0x0); 
  TObjArray *regionsMinMaxMC = (TObjArray*)fAnalyseUE->GetMinMaxRegion((TList*)regionSortedParticlesMC->At(2),(TList*)regionSortedParticlesMC->At(3));
  // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
  // (MC-true leading particle and MC-true all particles)
  // STEP 0
  fHistosUE->Fill(fillId,0,AliUEHist::kCFStepAll,leadingMC,(TList*)regionSortedParticlesMC->At(0),(TList*)regionSortedParticlesMC->At(1),(TList*)regionsMinMaxMC->At(0),(TList*)regionsMinMaxMC->At(1));
  
  // Trigger selection ************************************************
  if (fAnalyseUE->TriggerSelection(fInputHandler))
  {
    // PILEUP-CUT 
    Bool_t select = kFALSE;
    if (fSelectBit) select = AliAnalysisHelperJetTasks::TestSelectInfo(fSelectBit);
    if (select)
      fHistosUE->FillEvent(fillId, -2);
    else
    {
    
	    // Count events that pass AliPhysicsSelection
    
  	    // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
    	    // (MC-true leading particle and MC-true all particles)
    	    // STEP 1
	    fHistosUE->Fill(fillId,0,AliUEHist::kCFStepTriggered,leadingMC,(TList*)regionSortedParticlesMC->At(0),(TList*)regionSortedParticlesMC->At(1),(TList*)regionsMinMaxMC->At(0),(TList*)regionsMinMaxMC->At(1));
  
	    // count number of MC tracks above 150 MeV/c
	    Int_t nMCTracks = 0; 
	    if (leadingMC && leadingMC->Pt() > 0.15)
	      nMCTracks++;
	    for (Int_t i=0; i<4; i++)
	      for (Int_t j=0; j<((TList*)regionSortedParticlesMC->At(i))->GetEntries(); j++)
	        if (((AliVParticle*) ((TList*)regionSortedParticlesMC->At(i))->At(j))->Pt() > 0.15)
	          nMCTracks++;
      
	    //((TH2F*)fListOfHistos->FindObject("multVsLeadStep5"))->Fill(nMCTracks, leadingMC->Pt());
    
	    // Vertex selection *************************************************
    	    if (fAnalyseUE->VertexSelection(fAOD, fnTracksVertex, fZVertex))
	    {
	      // Count events that pass Vertex selection
            
	      // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
	      // (MC-true leading particle and MC-true all particles)
	      // STEP 2
	      fHistosUE->Fill(fillId,0,AliUEHist::kCFStepVertex,leadingMC,(TList*)regionSortedParticlesMC->At(0),(TList*)regionSortedParticlesMC->At(1),(TList*)regionsMinMaxMC->At(0),(TList*)regionsMinMaxMC->At(1));
    
              // fill here for tracking efficiency
              // loop over particle species
	      for (Int_t particleSpecies = 0; particleSpecies < 4; particleSpecies++)
              {
              	TObjArray* primMCParticles = fAnalyseUE->GetAcceptedParticles(fArrayMC, 0x0, kTRUE, particleSpecies);
              	TObjArray* primRecoTracksMatched = fAnalyseUE->GetAcceptedParticles(fAOD, fArrayMC, kTRUE, particleSpecies);
              	TObjArray* allRecoTracksMatched = fAnalyseUE->GetAcceptedParticles(fAOD, fArrayMC, kFALSE, particleSpecies);

              	fHistosUE->FillTrackingEfficiency(primMCParticles, primRecoTracksMatched, allRecoTracksMatched, 0, 0, 0, particleSpecies);
              
              	delete primMCParticles;
              	delete primRecoTracksMatched;
              	delete allRecoTracksMatched;
	      }
      
	      // Get Reconstructed leading particle *******************************
	      TObjArray *ltRECO = fAnalyseUE->FindLeadingObjects(fAOD);
	      if (ltRECO)
	      {
	        // Count events where a reconstructed track was found in |eta|<0.8
	        // the pT cut will be set when projecting output containers
	        // for leading particle correlation plots
	        if (leadingMC) {
	              fHistosUE->Fill(leadingMC, (AliVParticle*)ltRECO->At(0));
	              }
              
	        // If there is no MC leading track the container is not filled, so the number of entries in the container might be different  
	        // from the number of events after the selection, since the selection is based on RECO tracks
	        // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
	        // (MC-true leading particle and MC-true all particles)
	        // STEP 3
	        if (!fReduceMemoryFootprint)
	          fHistosUE->Fill(fillId,0,AliUEHist::kCFStepAnaTopology,leadingMC,(TList*)regionSortedParticlesMC->At(0),(TList*)regionSortedParticlesMC->At(1),(TList*)regionsMinMaxMC->At(0),(TList*)regionsMinMaxMC->At(1));
      
	        //Sort RECO particles w.r.t. MC-leading and return matched (primary) MC particle 
	        // (you cannot sort tracks w.r.t. RECO-leading and plot it vs. MC-leading ...)
	        TObjArray *regionSortedParticlesRECOLTMC = (TObjArray*)fAnalyseUE->SortRegions(leadingMC, fAOD, fArrayMC, kTRUE); 
	        TObjArray *regionsMinMaxRECOLTMC = (TObjArray*)fAnalyseUE->GetMinMaxRegion((TList*)regionSortedParticlesRECOLTMC->At(2),(TList*)regionSortedParticlesRECOLTMC->At(3));
	        // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
	        // (MC leading particle and RECO-matched (quantities from MC particle)  all particles)
	        // STEP 4
	        //if (!fReduceMemoryFootprint)
  	          fHistosUE->Fill(fillId,0,AliUEHist::kCFStepTrackedOnlyPrim,leadingMC,(TList*)regionSortedParticlesRECOLTMC->At(0),(TList*)regionSortedParticlesRECOLTMC->At(1),(TList*)regionsMinMaxRECOLTMC->At(0),(TList*)regionsMinMaxRECOLTMC->At(1));
	        // comparing this step with step 3 (for all-tracks observables) you get the tracking efficiency
        
	        //Sort RECO particles w.r.t. MC-leading and return matched (primary+secondary) MC particle 
	        // (you cannot sort tracks w.r.t. RECO-leading and plot it vs. MC-leading ...)
	        TObjArray *regionSortedParticlesRECOLTMC2 = (TObjArray*)fAnalyseUE->SortRegions(leadingMC, fAOD, fArrayMC,kFALSE); 
	        TObjArray *regionsMinMaxRECOLTMC2 = (TObjArray*)fAnalyseUE->GetMinMaxRegion((TList*)regionSortedParticlesRECOLTMC2->At(2),(TList*)regionSortedParticlesRECOLTMC2->At(3));
        
	        // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
	        // (MC leading particle and RECO-matched (quantities from MC particle)  all particles)
	        // STEP 5
	        //if (!fReduceMemoryFootprint)
                  fHistosUE->Fill(fillId,0,AliUEHist::kCFStepTracked,leadingMC,(TList*)regionSortedParticlesRECOLTMC2->At(0),(TList*)regionSortedParticlesRECOLTMC2->At(1),(TList*)regionsMinMaxRECOLTMC2->At(0),(TList*)regionsMinMaxRECOLTMC2->At(1));
	        // comparing this step with step 3 (for all-tracks observables) you get the tracking efficiency
          
	        // SWITCH TO RECONSTRUCTED TRACKS  ************************************
	        // The next steps correspond to track selections
	        // Sort RECO particles w.r.t. RECO-leading and return RECO particle  
	        TObjArray *regionSortedParticlesRECO = (TObjArray*)fAnalyseUE->SortRegions((AliVParticle*)ltRECO->At(0), fAOD,0); 
	        TObjArray *regionsMinMaxRECO = (TObjArray*)fAnalyseUE->GetMinMaxRegion((TList*)regionSortedParticlesRECO->At(2),(TList*)regionSortedParticlesRECO->At(3));
	        // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
	        // (RECO leading particle and RECO  all particles)
	        // STEP 6
	        fHistosUE->Fill(fillId,0,AliUEHist::kCFStepReconstructed,(AliVParticle*)ltRECO->At(0),(TList*)regionSortedParticlesRECO->At(0),(TList*)regionSortedParticlesRECO->At(1),(TList*)regionsMinMaxRECO->At(0),(TList*)regionsMinMaxRECO->At(1));
        
	        // STEP 8 for reduced efficiency study
	        FillReducedEfficiency(fillId, AliUEHist::kCFStepBiasStudy, ltRECO, kFALSE);
      	        if (!fReduceMemoryFootprint)
                  FillReducedEfficiency(fillId, AliUEHist::kCFStepBiasStudy2, ltRECO, kTRUE);
        
	        // count number of reco tracks above 150 MeV/c
	        Int_t nRecoTracks = 0; 
	        if (((AliVParticle*) ltRECO->At(0))->Pt() > 0.15)
	          nRecoTracks++;
	        for (Int_t i=0; i<4; i++)
	          for (Int_t j=0; j<((TList*)regionSortedParticlesRECO->At(i))->GetEntries(); j++)
	            if (((AliVParticle*) ((TList*)regionSortedParticlesRECO->At(i))->At(j))->Pt() > 0.15)
	              nRecoTracks++;
	        
	        if (leadingMC && leadingMC->Pt() > 0.5)
	          fHistosUE->GetCorrelationMultiplicity()->Fill(nMCTracks, nRecoTracks);
        
	        if (leadingMC)
	        {
	          // Match reco leading track with true *********************************
	          Int_t recoLabel = ((AliAODTrack*)ltRECO->At(0))->GetLabel();
	          Int_t mcLabel   = ((AliAODMCParticle*)leadingMC)->GetLabel();
	          if (recoLabel != mcLabel) 
	            return;
          
	          // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
	          // (RECO-MATCHED leading particle and RECO all particles)
	          // STEP 7
	          fHistosUE->Fill(fillId,0,AliUEHist::kCFStepRealLeading,(AliVParticle*)ltRECO->At(0),(TList*)regionSortedParticlesRECO->At(0),(TList*)regionSortedParticlesRECO->At(1),(TList*)regionsMinMaxRECO->At(0),(TList*)regionsMinMaxRECO->At(1));
	          // comparing this step with step 6 (for leading-track observables) you get the efficiency to reconstruct the leading track
          	  // comparing this step with step 6 (for all-tracks observables) you see how leading-track misidentification affects the final distributions
        	}
        
	        delete regionSortedParticlesRECOLTMC;
	        delete regionsMinMaxRECOLTMC;
	        delete regionSortedParticlesRECOLTMC2;
	        delete regionsMinMaxRECOLTMC2;
	        delete regionSortedParticlesRECO;
	        delete regionsMinMaxRECO;
	        delete ltRECO;
	      } // lt reco
    	} // vertex
    } // pileup
  } //phyiscs selection
  
  if (ltMC)
    delete ltMC;
  delete regionSortedParticlesMC;
  delete regionsMinMaxMC;
}

//____________________________________________________________________
void  AliAnalysisTaskLeadingTrackUE::AnalyseDataMode()
{

  // Run the analysis on DATA or MC to get raw distributions
 
  PostData(0,fListOfHistos);
  
  if ( fDebug > 3 ) AliInfo( " Processing event in Data mode ..." );
  Int_t eventId = 0;

  // Fill the "event-counting-container", it is needed to get the number of events remaining after each event-selection cut
  fHistosUE->FillEvent(eventId, AliUEHist::kCFStepAll);

  // Trigger selection ************************************************
  if (!fAnalyseUE->TriggerSelection(fInputHandler)) return;
  // PILEUP-CUT 
  Bool_t select = kFALSE;
  if (fSelectBit) select = AliAnalysisHelperJetTasks::TestSelectInfo(fSelectBit);
  if (select) 
  {
    fHistosUE->FillEvent(eventId, -2);
    return;
  }
  // Fill the "event-counting-container", it is needed to get the number of events remaining after each event-selection cut
  fHistosUE->FillEvent(eventId, AliUEHist::kCFStepTriggered);
  
  // Vertex selection *************************************************
  if(!fAnalyseUE->VertexSelection(fAOD, fnTracksVertex, fZVertex)) return;
  // Fill the "event-counting-container", it is needed to get the number of events remaining after each event-selection cut
  fHistosUE->FillEvent(eventId, AliUEHist::kCFStepVertex);
  // comparing this step with previous one you get the vertex selection efficiency from data (?)
 

  // Get Reconstructed leading particle *******************************
  TObjArray *ltRECO = fAnalyseUE->FindLeadingObjects(fAOD);
  if (!ltRECO) return;
  
  // fill control distributions
  fHistosUE->Fill(0, (AliVParticle*)ltRECO->At(0));
  
  // Fill the "event-counting-container", it is needed to get the number of events remaining after each event-selection cut
  fHistosUE->FillEvent(eventId, AliUEHist::kCFStepAnaTopology);

  // Switch to reconstructed tracks ************************************
  // Sort RECO particles w.r.t. RECO-leading and return RECO particle  
  TObjArray *regionSortedParticlesRECO = (TObjArray*)fAnalyseUE->SortRegions((AliVParticle*)ltRECO->At(0), fAOD,0); 
  TObjArray *regionsMinMaxRECO = (TObjArray*)fAnalyseUE->GetMinMaxRegion((TList*)regionSortedParticlesRECO->At(2),(TList*)regionSortedParticlesRECO->At(3));
  // Fill UE containers (step, leading track, towards particles, away particles, transverse MIN and MAX particles)
  // (RECO leading particle and RECO  all particles)
  // STEP 6
  fHistosUE->Fill(eventId,0,AliUEHist::kCFStepReconstructed,(AliVParticle*)ltRECO->At(0),(TList*)regionSortedParticlesRECO->At(0),(TList*)regionSortedParticlesRECO->At(1),(TList*)regionsMinMaxRECO->At(0),(TList*)regionsMinMaxRECO->At(1));
  
  // STEP 8 and 9 for reduced efficiency study
  FillReducedEfficiency(eventId, AliUEHist::kCFStepBiasStudy, ltRECO, kFALSE);
  FillReducedEfficiency(eventId, AliUEHist::kCFStepBiasStudy2, ltRECO, kTRUE);
  
  delete ltRECO;
  delete regionSortedParticlesRECO;
  delete regionsMinMaxRECO;
}

//____________________________________________________________________
void AliAnalysisTaskLeadingTrackUE::FillReducedEfficiency(Int_t eventId, AliUEHist::CFStep step, const TObjArray* ltRECO, Bool_t twoStep)
{
  // remove leading particle using fkTrackingEfficiency and use subleading particle to fill the histograms
  //
  // if twoStep is kTRUE, do a two step procedure where in each step only 50% of the loss due to the tracking efficiency is applied 
  
  if (!fkTrackingEfficiency)
    return;
    
  TObjArray* particleList =  new TObjArray(*ltRECO);
  AliVParticle* leading = (AliVParticle*) particleList->At(0);
  if (!leading)
  {
    delete particleList;
    return;
  }
  
  // remove particles depending on tracking efficiency
  Int_t count = (twoStep) ? 2 : 1;
  
  for (Int_t i=0; i<count; i++)
  {
    const TAxis * xax = fkTrackingEfficiency->GetXaxis();
    Float_t trackingEff = fkTrackingEfficiency->GetBinContent(xax->FindFixBin(leading->Pt()));
    if (twoStep)
      trackingEff = 0.5 * (trackingEff + 1);
      
    if (gRandom->Uniform() > trackingEff)
    {
      //Printf("LOWEFF: Removing leading particle");
      particleList->RemoveAt(0);
      particleList->Compress();
    }
      
    if (particleList->GetEntries() == 0)
    {
      delete particleList;
      return;
    }
    
    leading = (AliVParticle*) particleList->At(0);
  }
  
  TObjArray *regionSortedParticlesRECOLowEff = fAnalyseUE->SortRegions(leading, particleList, 0); 
  TObjArray *regionsMinMaxRECOLowEff = fAnalyseUE->GetMinMaxRegion((TList*)regionSortedParticlesRECOLowEff->At(2), (TList*)regionSortedParticlesRECOLowEff->At(3));
    
  fHistosUE->Fill(eventId,0,step,leading,(TList*)regionSortedParticlesRECOLowEff->At(0), (TList*)regionSortedParticlesRECOLowEff->At(1), (TList*)regionsMinMaxRECOLowEff->At(0), (TList*)regionsMinMaxRECOLowEff->At(1));

  delete regionSortedParticlesRECOLowEff;
  delete regionsMinMaxRECOLowEff;
  delete particleList;
}

//____________________________________________________________________
void  AliAnalysisTaskLeadingTrackUE::Initialize()
{
  // input handler
  fInputHandler = (AliInputEventHandler*)
         ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
  // MC handler
  fMcHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
}






 AliAnalysisTaskLeadingTrackUE.cxx:1
 AliAnalysisTaskLeadingTrackUE.cxx:2
 AliAnalysisTaskLeadingTrackUE.cxx:3
 AliAnalysisTaskLeadingTrackUE.cxx:4
 AliAnalysisTaskLeadingTrackUE.cxx:5
 AliAnalysisTaskLeadingTrackUE.cxx:6
 AliAnalysisTaskLeadingTrackUE.cxx:7
 AliAnalysisTaskLeadingTrackUE.cxx:8
 AliAnalysisTaskLeadingTrackUE.cxx:9
 AliAnalysisTaskLeadingTrackUE.cxx:10
 AliAnalysisTaskLeadingTrackUE.cxx:11
 AliAnalysisTaskLeadingTrackUE.cxx:12
 AliAnalysisTaskLeadingTrackUE.cxx:13
 AliAnalysisTaskLeadingTrackUE.cxx:14
 AliAnalysisTaskLeadingTrackUE.cxx:15
 AliAnalysisTaskLeadingTrackUE.cxx:16
 AliAnalysisTaskLeadingTrackUE.cxx:17
 AliAnalysisTaskLeadingTrackUE.cxx:18
 AliAnalysisTaskLeadingTrackUE.cxx:19
 AliAnalysisTaskLeadingTrackUE.cxx:20
 AliAnalysisTaskLeadingTrackUE.cxx:21
 AliAnalysisTaskLeadingTrackUE.cxx:22
 AliAnalysisTaskLeadingTrackUE.cxx:23
 AliAnalysisTaskLeadingTrackUE.cxx:24
 AliAnalysisTaskLeadingTrackUE.cxx:25
 AliAnalysisTaskLeadingTrackUE.cxx:26
 AliAnalysisTaskLeadingTrackUE.cxx:27
 AliAnalysisTaskLeadingTrackUE.cxx:28
 AliAnalysisTaskLeadingTrackUE.cxx:29
 AliAnalysisTaskLeadingTrackUE.cxx:30
 AliAnalysisTaskLeadingTrackUE.cxx:31
 AliAnalysisTaskLeadingTrackUE.cxx:32
 AliAnalysisTaskLeadingTrackUE.cxx:33
 AliAnalysisTaskLeadingTrackUE.cxx:34
 AliAnalysisTaskLeadingTrackUE.cxx:35
 AliAnalysisTaskLeadingTrackUE.cxx:36
 AliAnalysisTaskLeadingTrackUE.cxx:37
 AliAnalysisTaskLeadingTrackUE.cxx:38
 AliAnalysisTaskLeadingTrackUE.cxx:39
 AliAnalysisTaskLeadingTrackUE.cxx:40
 AliAnalysisTaskLeadingTrackUE.cxx:41
 AliAnalysisTaskLeadingTrackUE.cxx:42
 AliAnalysisTaskLeadingTrackUE.cxx:43
 AliAnalysisTaskLeadingTrackUE.cxx:44
 AliAnalysisTaskLeadingTrackUE.cxx:45
 AliAnalysisTaskLeadingTrackUE.cxx:46
 AliAnalysisTaskLeadingTrackUE.cxx:47
 AliAnalysisTaskLeadingTrackUE.cxx:48
 AliAnalysisTaskLeadingTrackUE.cxx:49
 AliAnalysisTaskLeadingTrackUE.cxx:50
 AliAnalysisTaskLeadingTrackUE.cxx:51
 AliAnalysisTaskLeadingTrackUE.cxx:52
 AliAnalysisTaskLeadingTrackUE.cxx:53
 AliAnalysisTaskLeadingTrackUE.cxx:54
 AliAnalysisTaskLeadingTrackUE.cxx:55
 AliAnalysisTaskLeadingTrackUE.cxx:56
 AliAnalysisTaskLeadingTrackUE.cxx:57
 AliAnalysisTaskLeadingTrackUE.cxx:58
 AliAnalysisTaskLeadingTrackUE.cxx:59
 AliAnalysisTaskLeadingTrackUE.cxx:60
 AliAnalysisTaskLeadingTrackUE.cxx:61
 AliAnalysisTaskLeadingTrackUE.cxx:62
 AliAnalysisTaskLeadingTrackUE.cxx:63
 AliAnalysisTaskLeadingTrackUE.cxx:64
 AliAnalysisTaskLeadingTrackUE.cxx:65
 AliAnalysisTaskLeadingTrackUE.cxx:66
 AliAnalysisTaskLeadingTrackUE.cxx:67
 AliAnalysisTaskLeadingTrackUE.cxx:68
 AliAnalysisTaskLeadingTrackUE.cxx:69
 AliAnalysisTaskLeadingTrackUE.cxx:70
 AliAnalysisTaskLeadingTrackUE.cxx:71
 AliAnalysisTaskLeadingTrackUE.cxx:72
 AliAnalysisTaskLeadingTrackUE.cxx:73
 AliAnalysisTaskLeadingTrackUE.cxx:74
 AliAnalysisTaskLeadingTrackUE.cxx:75
 AliAnalysisTaskLeadingTrackUE.cxx:76
 AliAnalysisTaskLeadingTrackUE.cxx:77
 AliAnalysisTaskLeadingTrackUE.cxx:78
 AliAnalysisTaskLeadingTrackUE.cxx:79
 AliAnalysisTaskLeadingTrackUE.cxx:80
 AliAnalysisTaskLeadingTrackUE.cxx:81
 AliAnalysisTaskLeadingTrackUE.cxx:82
 AliAnalysisTaskLeadingTrackUE.cxx:83
 AliAnalysisTaskLeadingTrackUE.cxx:84
 AliAnalysisTaskLeadingTrackUE.cxx:85
 AliAnalysisTaskLeadingTrackUE.cxx:86
 AliAnalysisTaskLeadingTrackUE.cxx:87
 AliAnalysisTaskLeadingTrackUE.cxx:88
 AliAnalysisTaskLeadingTrackUE.cxx:89
 AliAnalysisTaskLeadingTrackUE.cxx:90
 AliAnalysisTaskLeadingTrackUE.cxx:91
 AliAnalysisTaskLeadingTrackUE.cxx:92
 AliAnalysisTaskLeadingTrackUE.cxx:93
 AliAnalysisTaskLeadingTrackUE.cxx:94
 AliAnalysisTaskLeadingTrackUE.cxx:95
 AliAnalysisTaskLeadingTrackUE.cxx:96
 AliAnalysisTaskLeadingTrackUE.cxx:97
 AliAnalysisTaskLeadingTrackUE.cxx:98
 AliAnalysisTaskLeadingTrackUE.cxx:99
 AliAnalysisTaskLeadingTrackUE.cxx:100
 AliAnalysisTaskLeadingTrackUE.cxx:101
 AliAnalysisTaskLeadingTrackUE.cxx:102
 AliAnalysisTaskLeadingTrackUE.cxx:103
 AliAnalysisTaskLeadingTrackUE.cxx:104
 AliAnalysisTaskLeadingTrackUE.cxx:105
 AliAnalysisTaskLeadingTrackUE.cxx:106
 AliAnalysisTaskLeadingTrackUE.cxx:107
 AliAnalysisTaskLeadingTrackUE.cxx:108
 AliAnalysisTaskLeadingTrackUE.cxx:109
 AliAnalysisTaskLeadingTrackUE.cxx:110
 AliAnalysisTaskLeadingTrackUE.cxx:111
 AliAnalysisTaskLeadingTrackUE.cxx:112
 AliAnalysisTaskLeadingTrackUE.cxx:113
 AliAnalysisTaskLeadingTrackUE.cxx:114
 AliAnalysisTaskLeadingTrackUE.cxx:115
 AliAnalysisTaskLeadingTrackUE.cxx:116
 AliAnalysisTaskLeadingTrackUE.cxx:117
 AliAnalysisTaskLeadingTrackUE.cxx:118
 AliAnalysisTaskLeadingTrackUE.cxx:119
 AliAnalysisTaskLeadingTrackUE.cxx:120
 AliAnalysisTaskLeadingTrackUE.cxx:121
 AliAnalysisTaskLeadingTrackUE.cxx:122
 AliAnalysisTaskLeadingTrackUE.cxx:123
 AliAnalysisTaskLeadingTrackUE.cxx:124
 AliAnalysisTaskLeadingTrackUE.cxx:125
 AliAnalysisTaskLeadingTrackUE.cxx:126
 AliAnalysisTaskLeadingTrackUE.cxx:127
 AliAnalysisTaskLeadingTrackUE.cxx:128
 AliAnalysisTaskLeadingTrackUE.cxx:129
 AliAnalysisTaskLeadingTrackUE.cxx:130
 AliAnalysisTaskLeadingTrackUE.cxx:131
 AliAnalysisTaskLeadingTrackUE.cxx:132
 AliAnalysisTaskLeadingTrackUE.cxx:133
 AliAnalysisTaskLeadingTrackUE.cxx:134
 AliAnalysisTaskLeadingTrackUE.cxx:135
 AliAnalysisTaskLeadingTrackUE.cxx:136
 AliAnalysisTaskLeadingTrackUE.cxx:137
 AliAnalysisTaskLeadingTrackUE.cxx:138
 AliAnalysisTaskLeadingTrackUE.cxx:139
 AliAnalysisTaskLeadingTrackUE.cxx:140
 AliAnalysisTaskLeadingTrackUE.cxx:141
 AliAnalysisTaskLeadingTrackUE.cxx:142
 AliAnalysisTaskLeadingTrackUE.cxx:143
 AliAnalysisTaskLeadingTrackUE.cxx:144
 AliAnalysisTaskLeadingTrackUE.cxx:145
 AliAnalysisTaskLeadingTrackUE.cxx:146
 AliAnalysisTaskLeadingTrackUE.cxx:147
 AliAnalysisTaskLeadingTrackUE.cxx:148
 AliAnalysisTaskLeadingTrackUE.cxx:149
 AliAnalysisTaskLeadingTrackUE.cxx:150
 AliAnalysisTaskLeadingTrackUE.cxx:151
 AliAnalysisTaskLeadingTrackUE.cxx:152
 AliAnalysisTaskLeadingTrackUE.cxx:153
 AliAnalysisTaskLeadingTrackUE.cxx:154
 AliAnalysisTaskLeadingTrackUE.cxx:155
 AliAnalysisTaskLeadingTrackUE.cxx:156
 AliAnalysisTaskLeadingTrackUE.cxx:157
 AliAnalysisTaskLeadingTrackUE.cxx:158
 AliAnalysisTaskLeadingTrackUE.cxx:159
 AliAnalysisTaskLeadingTrackUE.cxx:160
 AliAnalysisTaskLeadingTrackUE.cxx:161
 AliAnalysisTaskLeadingTrackUE.cxx:162
 AliAnalysisTaskLeadingTrackUE.cxx:163
 AliAnalysisTaskLeadingTrackUE.cxx:164
 AliAnalysisTaskLeadingTrackUE.cxx:165
 AliAnalysisTaskLeadingTrackUE.cxx:166
 AliAnalysisTaskLeadingTrackUE.cxx:167
 AliAnalysisTaskLeadingTrackUE.cxx:168
 AliAnalysisTaskLeadingTrackUE.cxx:169
 AliAnalysisTaskLeadingTrackUE.cxx:170
 AliAnalysisTaskLeadingTrackUE.cxx:171
 AliAnalysisTaskLeadingTrackUE.cxx:172
 AliAnalysisTaskLeadingTrackUE.cxx:173
 AliAnalysisTaskLeadingTrackUE.cxx:174
 AliAnalysisTaskLeadingTrackUE.cxx:175
 AliAnalysisTaskLeadingTrackUE.cxx:176
 AliAnalysisTaskLeadingTrackUE.cxx:177
 AliAnalysisTaskLeadingTrackUE.cxx:178
 AliAnalysisTaskLeadingTrackUE.cxx:179
 AliAnalysisTaskLeadingTrackUE.cxx:180
 AliAnalysisTaskLeadingTrackUE.cxx:181
 AliAnalysisTaskLeadingTrackUE.cxx:182
 AliAnalysisTaskLeadingTrackUE.cxx:183
 AliAnalysisTaskLeadingTrackUE.cxx:184
 AliAnalysisTaskLeadingTrackUE.cxx:185
 AliAnalysisTaskLeadingTrackUE.cxx:186
 AliAnalysisTaskLeadingTrackUE.cxx:187
 AliAnalysisTaskLeadingTrackUE.cxx:188
 AliAnalysisTaskLeadingTrackUE.cxx:189
 AliAnalysisTaskLeadingTrackUE.cxx:190
 AliAnalysisTaskLeadingTrackUE.cxx:191
 AliAnalysisTaskLeadingTrackUE.cxx:192
 AliAnalysisTaskLeadingTrackUE.cxx:193
 AliAnalysisTaskLeadingTrackUE.cxx:194
 AliAnalysisTaskLeadingTrackUE.cxx:195
 AliAnalysisTaskLeadingTrackUE.cxx:196
 AliAnalysisTaskLeadingTrackUE.cxx:197
 AliAnalysisTaskLeadingTrackUE.cxx:198
 AliAnalysisTaskLeadingTrackUE.cxx:199
 AliAnalysisTaskLeadingTrackUE.cxx:200
 AliAnalysisTaskLeadingTrackUE.cxx:201
 AliAnalysisTaskLeadingTrackUE.cxx:202
 AliAnalysisTaskLeadingTrackUE.cxx:203
 AliAnalysisTaskLeadingTrackUE.cxx:204
 AliAnalysisTaskLeadingTrackUE.cxx:205
 AliAnalysisTaskLeadingTrackUE.cxx:206
 AliAnalysisTaskLeadingTrackUE.cxx:207
 AliAnalysisTaskLeadingTrackUE.cxx:208
 AliAnalysisTaskLeadingTrackUE.cxx:209
 AliAnalysisTaskLeadingTrackUE.cxx:210
 AliAnalysisTaskLeadingTrackUE.cxx:211
 AliAnalysisTaskLeadingTrackUE.cxx:212
 AliAnalysisTaskLeadingTrackUE.cxx:213
 AliAnalysisTaskLeadingTrackUE.cxx:214
 AliAnalysisTaskLeadingTrackUE.cxx:215
 AliAnalysisTaskLeadingTrackUE.cxx:216
 AliAnalysisTaskLeadingTrackUE.cxx:217
 AliAnalysisTaskLeadingTrackUE.cxx:218
 AliAnalysisTaskLeadingTrackUE.cxx:219
 AliAnalysisTaskLeadingTrackUE.cxx:220
 AliAnalysisTaskLeadingTrackUE.cxx:221
 AliAnalysisTaskLeadingTrackUE.cxx:222
 AliAnalysisTaskLeadingTrackUE.cxx:223
 AliAnalysisTaskLeadingTrackUE.cxx:224
 AliAnalysisTaskLeadingTrackUE.cxx:225
 AliAnalysisTaskLeadingTrackUE.cxx:226
 AliAnalysisTaskLeadingTrackUE.cxx:227
 AliAnalysisTaskLeadingTrackUE.cxx:228
 AliAnalysisTaskLeadingTrackUE.cxx:229
 AliAnalysisTaskLeadingTrackUE.cxx:230
 AliAnalysisTaskLeadingTrackUE.cxx:231
 AliAnalysisTaskLeadingTrackUE.cxx:232
 AliAnalysisTaskLeadingTrackUE.cxx:233
 AliAnalysisTaskLeadingTrackUE.cxx:234
 AliAnalysisTaskLeadingTrackUE.cxx:235
 AliAnalysisTaskLeadingTrackUE.cxx:236
 AliAnalysisTaskLeadingTrackUE.cxx:237
 AliAnalysisTaskLeadingTrackUE.cxx:238
 AliAnalysisTaskLeadingTrackUE.cxx:239
 AliAnalysisTaskLeadingTrackUE.cxx:240
 AliAnalysisTaskLeadingTrackUE.cxx:241
 AliAnalysisTaskLeadingTrackUE.cxx:242
 AliAnalysisTaskLeadingTrackUE.cxx:243
 AliAnalysisTaskLeadingTrackUE.cxx:244
 AliAnalysisTaskLeadingTrackUE.cxx:245
 AliAnalysisTaskLeadingTrackUE.cxx:246
 AliAnalysisTaskLeadingTrackUE.cxx:247
 AliAnalysisTaskLeadingTrackUE.cxx:248
 AliAnalysisTaskLeadingTrackUE.cxx:249
 AliAnalysisTaskLeadingTrackUE.cxx:250
 AliAnalysisTaskLeadingTrackUE.cxx:251
 AliAnalysisTaskLeadingTrackUE.cxx:252
 AliAnalysisTaskLeadingTrackUE.cxx:253
 AliAnalysisTaskLeadingTrackUE.cxx:254
 AliAnalysisTaskLeadingTrackUE.cxx:255
 AliAnalysisTaskLeadingTrackUE.cxx:256
 AliAnalysisTaskLeadingTrackUE.cxx:257
 AliAnalysisTaskLeadingTrackUE.cxx:258
 AliAnalysisTaskLeadingTrackUE.cxx:259
 AliAnalysisTaskLeadingTrackUE.cxx:260
 AliAnalysisTaskLeadingTrackUE.cxx:261
 AliAnalysisTaskLeadingTrackUE.cxx:262
 AliAnalysisTaskLeadingTrackUE.cxx:263
 AliAnalysisTaskLeadingTrackUE.cxx:264
 AliAnalysisTaskLeadingTrackUE.cxx:265
 AliAnalysisTaskLeadingTrackUE.cxx:266
 AliAnalysisTaskLeadingTrackUE.cxx:267
 AliAnalysisTaskLeadingTrackUE.cxx:268
 AliAnalysisTaskLeadingTrackUE.cxx:269
 AliAnalysisTaskLeadingTrackUE.cxx:270
 AliAnalysisTaskLeadingTrackUE.cxx:271
 AliAnalysisTaskLeadingTrackUE.cxx:272
 AliAnalysisTaskLeadingTrackUE.cxx:273
 AliAnalysisTaskLeadingTrackUE.cxx:274
 AliAnalysisTaskLeadingTrackUE.cxx:275
 AliAnalysisTaskLeadingTrackUE.cxx:276
 AliAnalysisTaskLeadingTrackUE.cxx:277
 AliAnalysisTaskLeadingTrackUE.cxx:278
 AliAnalysisTaskLeadingTrackUE.cxx:279
 AliAnalysisTaskLeadingTrackUE.cxx:280
 AliAnalysisTaskLeadingTrackUE.cxx:281
 AliAnalysisTaskLeadingTrackUE.cxx:282
 AliAnalysisTaskLeadingTrackUE.cxx:283
 AliAnalysisTaskLeadingTrackUE.cxx:284
 AliAnalysisTaskLeadingTrackUE.cxx:285
 AliAnalysisTaskLeadingTrackUE.cxx:286
 AliAnalysisTaskLeadingTrackUE.cxx:287
 AliAnalysisTaskLeadingTrackUE.cxx:288
 AliAnalysisTaskLeadingTrackUE.cxx:289
 AliAnalysisTaskLeadingTrackUE.cxx:290
 AliAnalysisTaskLeadingTrackUE.cxx:291
 AliAnalysisTaskLeadingTrackUE.cxx:292
 AliAnalysisTaskLeadingTrackUE.cxx:293
 AliAnalysisTaskLeadingTrackUE.cxx:294
 AliAnalysisTaskLeadingTrackUE.cxx:295
 AliAnalysisTaskLeadingTrackUE.cxx:296
 AliAnalysisTaskLeadingTrackUE.cxx:297
 AliAnalysisTaskLeadingTrackUE.cxx:298
 AliAnalysisTaskLeadingTrackUE.cxx:299
 AliAnalysisTaskLeadingTrackUE.cxx:300
 AliAnalysisTaskLeadingTrackUE.cxx:301
 AliAnalysisTaskLeadingTrackUE.cxx:302
 AliAnalysisTaskLeadingTrackUE.cxx:303
 AliAnalysisTaskLeadingTrackUE.cxx:304
 AliAnalysisTaskLeadingTrackUE.cxx:305
 AliAnalysisTaskLeadingTrackUE.cxx:306
 AliAnalysisTaskLeadingTrackUE.cxx:307
 AliAnalysisTaskLeadingTrackUE.cxx:308
 AliAnalysisTaskLeadingTrackUE.cxx:309
 AliAnalysisTaskLeadingTrackUE.cxx:310
 AliAnalysisTaskLeadingTrackUE.cxx:311
 AliAnalysisTaskLeadingTrackUE.cxx:312
 AliAnalysisTaskLeadingTrackUE.cxx:313
 AliAnalysisTaskLeadingTrackUE.cxx:314
 AliAnalysisTaskLeadingTrackUE.cxx:315
 AliAnalysisTaskLeadingTrackUE.cxx:316
 AliAnalysisTaskLeadingTrackUE.cxx:317
 AliAnalysisTaskLeadingTrackUE.cxx:318
 AliAnalysisTaskLeadingTrackUE.cxx:319
 AliAnalysisTaskLeadingTrackUE.cxx:320
 AliAnalysisTaskLeadingTrackUE.cxx:321
 AliAnalysisTaskLeadingTrackUE.cxx:322
 AliAnalysisTaskLeadingTrackUE.cxx:323
 AliAnalysisTaskLeadingTrackUE.cxx:324
 AliAnalysisTaskLeadingTrackUE.cxx:325
 AliAnalysisTaskLeadingTrackUE.cxx:326
 AliAnalysisTaskLeadingTrackUE.cxx:327
 AliAnalysisTaskLeadingTrackUE.cxx:328
 AliAnalysisTaskLeadingTrackUE.cxx:329
 AliAnalysisTaskLeadingTrackUE.cxx:330
 AliAnalysisTaskLeadingTrackUE.cxx:331
 AliAnalysisTaskLeadingTrackUE.cxx:332
 AliAnalysisTaskLeadingTrackUE.cxx:333
 AliAnalysisTaskLeadingTrackUE.cxx:334
 AliAnalysisTaskLeadingTrackUE.cxx:335
 AliAnalysisTaskLeadingTrackUE.cxx:336
 AliAnalysisTaskLeadingTrackUE.cxx:337
 AliAnalysisTaskLeadingTrackUE.cxx:338
 AliAnalysisTaskLeadingTrackUE.cxx:339
 AliAnalysisTaskLeadingTrackUE.cxx:340
 AliAnalysisTaskLeadingTrackUE.cxx:341
 AliAnalysisTaskLeadingTrackUE.cxx:342
 AliAnalysisTaskLeadingTrackUE.cxx:343
 AliAnalysisTaskLeadingTrackUE.cxx:344
 AliAnalysisTaskLeadingTrackUE.cxx:345
 AliAnalysisTaskLeadingTrackUE.cxx:346
 AliAnalysisTaskLeadingTrackUE.cxx:347
 AliAnalysisTaskLeadingTrackUE.cxx:348
 AliAnalysisTaskLeadingTrackUE.cxx:349
 AliAnalysisTaskLeadingTrackUE.cxx:350
 AliAnalysisTaskLeadingTrackUE.cxx:351
 AliAnalysisTaskLeadingTrackUE.cxx:352
 AliAnalysisTaskLeadingTrackUE.cxx:353
 AliAnalysisTaskLeadingTrackUE.cxx:354
 AliAnalysisTaskLeadingTrackUE.cxx:355
 AliAnalysisTaskLeadingTrackUE.cxx:356
 AliAnalysisTaskLeadingTrackUE.cxx:357
 AliAnalysisTaskLeadingTrackUE.cxx:358
 AliAnalysisTaskLeadingTrackUE.cxx:359
 AliAnalysisTaskLeadingTrackUE.cxx:360
 AliAnalysisTaskLeadingTrackUE.cxx:361
 AliAnalysisTaskLeadingTrackUE.cxx:362
 AliAnalysisTaskLeadingTrackUE.cxx:363
 AliAnalysisTaskLeadingTrackUE.cxx:364
 AliAnalysisTaskLeadingTrackUE.cxx:365
 AliAnalysisTaskLeadingTrackUE.cxx:366
 AliAnalysisTaskLeadingTrackUE.cxx:367
 AliAnalysisTaskLeadingTrackUE.cxx:368
 AliAnalysisTaskLeadingTrackUE.cxx:369
 AliAnalysisTaskLeadingTrackUE.cxx:370
 AliAnalysisTaskLeadingTrackUE.cxx:371
 AliAnalysisTaskLeadingTrackUE.cxx:372
 AliAnalysisTaskLeadingTrackUE.cxx:373
 AliAnalysisTaskLeadingTrackUE.cxx:374
 AliAnalysisTaskLeadingTrackUE.cxx:375
 AliAnalysisTaskLeadingTrackUE.cxx:376
 AliAnalysisTaskLeadingTrackUE.cxx:377
 AliAnalysisTaskLeadingTrackUE.cxx:378
 AliAnalysisTaskLeadingTrackUE.cxx:379
 AliAnalysisTaskLeadingTrackUE.cxx:380
 AliAnalysisTaskLeadingTrackUE.cxx:381
 AliAnalysisTaskLeadingTrackUE.cxx:382
 AliAnalysisTaskLeadingTrackUE.cxx:383
 AliAnalysisTaskLeadingTrackUE.cxx:384
 AliAnalysisTaskLeadingTrackUE.cxx:385
 AliAnalysisTaskLeadingTrackUE.cxx:386
 AliAnalysisTaskLeadingTrackUE.cxx:387
 AliAnalysisTaskLeadingTrackUE.cxx:388
 AliAnalysisTaskLeadingTrackUE.cxx:389
 AliAnalysisTaskLeadingTrackUE.cxx:390
 AliAnalysisTaskLeadingTrackUE.cxx:391
 AliAnalysisTaskLeadingTrackUE.cxx:392
 AliAnalysisTaskLeadingTrackUE.cxx:393
 AliAnalysisTaskLeadingTrackUE.cxx:394
 AliAnalysisTaskLeadingTrackUE.cxx:395
 AliAnalysisTaskLeadingTrackUE.cxx:396
 AliAnalysisTaskLeadingTrackUE.cxx:397
 AliAnalysisTaskLeadingTrackUE.cxx:398
 AliAnalysisTaskLeadingTrackUE.cxx:399
 AliAnalysisTaskLeadingTrackUE.cxx:400
 AliAnalysisTaskLeadingTrackUE.cxx:401
 AliAnalysisTaskLeadingTrackUE.cxx:402
 AliAnalysisTaskLeadingTrackUE.cxx:403
 AliAnalysisTaskLeadingTrackUE.cxx:404
 AliAnalysisTaskLeadingTrackUE.cxx:405
 AliAnalysisTaskLeadingTrackUE.cxx:406
 AliAnalysisTaskLeadingTrackUE.cxx:407
 AliAnalysisTaskLeadingTrackUE.cxx:408
 AliAnalysisTaskLeadingTrackUE.cxx:409
 AliAnalysisTaskLeadingTrackUE.cxx:410
 AliAnalysisTaskLeadingTrackUE.cxx:411
 AliAnalysisTaskLeadingTrackUE.cxx:412
 AliAnalysisTaskLeadingTrackUE.cxx:413
 AliAnalysisTaskLeadingTrackUE.cxx:414
 AliAnalysisTaskLeadingTrackUE.cxx:415
 AliAnalysisTaskLeadingTrackUE.cxx:416
 AliAnalysisTaskLeadingTrackUE.cxx:417
 AliAnalysisTaskLeadingTrackUE.cxx:418
 AliAnalysisTaskLeadingTrackUE.cxx:419
 AliAnalysisTaskLeadingTrackUE.cxx:420
 AliAnalysisTaskLeadingTrackUE.cxx:421
 AliAnalysisTaskLeadingTrackUE.cxx:422
 AliAnalysisTaskLeadingTrackUE.cxx:423
 AliAnalysisTaskLeadingTrackUE.cxx:424
 AliAnalysisTaskLeadingTrackUE.cxx:425
 AliAnalysisTaskLeadingTrackUE.cxx:426
 AliAnalysisTaskLeadingTrackUE.cxx:427
 AliAnalysisTaskLeadingTrackUE.cxx:428
 AliAnalysisTaskLeadingTrackUE.cxx:429
 AliAnalysisTaskLeadingTrackUE.cxx:430
 AliAnalysisTaskLeadingTrackUE.cxx:431
 AliAnalysisTaskLeadingTrackUE.cxx:432
 AliAnalysisTaskLeadingTrackUE.cxx:433
 AliAnalysisTaskLeadingTrackUE.cxx:434
 AliAnalysisTaskLeadingTrackUE.cxx:435
 AliAnalysisTaskLeadingTrackUE.cxx:436
 AliAnalysisTaskLeadingTrackUE.cxx:437
 AliAnalysisTaskLeadingTrackUE.cxx:438
 AliAnalysisTaskLeadingTrackUE.cxx:439
 AliAnalysisTaskLeadingTrackUE.cxx:440
 AliAnalysisTaskLeadingTrackUE.cxx:441
 AliAnalysisTaskLeadingTrackUE.cxx:442
 AliAnalysisTaskLeadingTrackUE.cxx:443
 AliAnalysisTaskLeadingTrackUE.cxx:444
 AliAnalysisTaskLeadingTrackUE.cxx:445
 AliAnalysisTaskLeadingTrackUE.cxx:446
 AliAnalysisTaskLeadingTrackUE.cxx:447
 AliAnalysisTaskLeadingTrackUE.cxx:448
 AliAnalysisTaskLeadingTrackUE.cxx:449
 AliAnalysisTaskLeadingTrackUE.cxx:450
 AliAnalysisTaskLeadingTrackUE.cxx:451
 AliAnalysisTaskLeadingTrackUE.cxx:452
 AliAnalysisTaskLeadingTrackUE.cxx:453
 AliAnalysisTaskLeadingTrackUE.cxx:454
 AliAnalysisTaskLeadingTrackUE.cxx:455
 AliAnalysisTaskLeadingTrackUE.cxx:456
 AliAnalysisTaskLeadingTrackUE.cxx:457
 AliAnalysisTaskLeadingTrackUE.cxx:458
 AliAnalysisTaskLeadingTrackUE.cxx:459
 AliAnalysisTaskLeadingTrackUE.cxx:460
 AliAnalysisTaskLeadingTrackUE.cxx:461
 AliAnalysisTaskLeadingTrackUE.cxx:462
 AliAnalysisTaskLeadingTrackUE.cxx:463
 AliAnalysisTaskLeadingTrackUE.cxx:464
 AliAnalysisTaskLeadingTrackUE.cxx:465
 AliAnalysisTaskLeadingTrackUE.cxx:466
 AliAnalysisTaskLeadingTrackUE.cxx:467
 AliAnalysisTaskLeadingTrackUE.cxx:468
 AliAnalysisTaskLeadingTrackUE.cxx:469
 AliAnalysisTaskLeadingTrackUE.cxx:470
 AliAnalysisTaskLeadingTrackUE.cxx:471
 AliAnalysisTaskLeadingTrackUE.cxx:472
 AliAnalysisTaskLeadingTrackUE.cxx:473
 AliAnalysisTaskLeadingTrackUE.cxx:474
 AliAnalysisTaskLeadingTrackUE.cxx:475
 AliAnalysisTaskLeadingTrackUE.cxx:476
 AliAnalysisTaskLeadingTrackUE.cxx:477
 AliAnalysisTaskLeadingTrackUE.cxx:478
 AliAnalysisTaskLeadingTrackUE.cxx:479
 AliAnalysisTaskLeadingTrackUE.cxx:480
 AliAnalysisTaskLeadingTrackUE.cxx:481
 AliAnalysisTaskLeadingTrackUE.cxx:482
 AliAnalysisTaskLeadingTrackUE.cxx:483
 AliAnalysisTaskLeadingTrackUE.cxx:484
 AliAnalysisTaskLeadingTrackUE.cxx:485
 AliAnalysisTaskLeadingTrackUE.cxx:486
 AliAnalysisTaskLeadingTrackUE.cxx:487
 AliAnalysisTaskLeadingTrackUE.cxx:488
 AliAnalysisTaskLeadingTrackUE.cxx:489
 AliAnalysisTaskLeadingTrackUE.cxx:490
 AliAnalysisTaskLeadingTrackUE.cxx:491
 AliAnalysisTaskLeadingTrackUE.cxx:492
 AliAnalysisTaskLeadingTrackUE.cxx:493
 AliAnalysisTaskLeadingTrackUE.cxx:494
 AliAnalysisTaskLeadingTrackUE.cxx:495
 AliAnalysisTaskLeadingTrackUE.cxx:496
 AliAnalysisTaskLeadingTrackUE.cxx:497
 AliAnalysisTaskLeadingTrackUE.cxx:498
 AliAnalysisTaskLeadingTrackUE.cxx:499
 AliAnalysisTaskLeadingTrackUE.cxx:500
 AliAnalysisTaskLeadingTrackUE.cxx:501
 AliAnalysisTaskLeadingTrackUE.cxx:502
 AliAnalysisTaskLeadingTrackUE.cxx:503
 AliAnalysisTaskLeadingTrackUE.cxx:504
 AliAnalysisTaskLeadingTrackUE.cxx:505
 AliAnalysisTaskLeadingTrackUE.cxx:506
 AliAnalysisTaskLeadingTrackUE.cxx:507
 AliAnalysisTaskLeadingTrackUE.cxx:508
 AliAnalysisTaskLeadingTrackUE.cxx:509
 AliAnalysisTaskLeadingTrackUE.cxx:510
 AliAnalysisTaskLeadingTrackUE.cxx:511
 AliAnalysisTaskLeadingTrackUE.cxx:512
 AliAnalysisTaskLeadingTrackUE.cxx:513
 AliAnalysisTaskLeadingTrackUE.cxx:514
 AliAnalysisTaskLeadingTrackUE.cxx:515
 AliAnalysisTaskLeadingTrackUE.cxx:516
 AliAnalysisTaskLeadingTrackUE.cxx:517
 AliAnalysisTaskLeadingTrackUE.cxx:518
 AliAnalysisTaskLeadingTrackUE.cxx:519
 AliAnalysisTaskLeadingTrackUE.cxx:520
 AliAnalysisTaskLeadingTrackUE.cxx:521
 AliAnalysisTaskLeadingTrackUE.cxx:522
 AliAnalysisTaskLeadingTrackUE.cxx:523
 AliAnalysisTaskLeadingTrackUE.cxx:524
 AliAnalysisTaskLeadingTrackUE.cxx:525
 AliAnalysisTaskLeadingTrackUE.cxx:526
 AliAnalysisTaskLeadingTrackUE.cxx:527
 AliAnalysisTaskLeadingTrackUE.cxx:528
 AliAnalysisTaskLeadingTrackUE.cxx:529
 AliAnalysisTaskLeadingTrackUE.cxx:530
 AliAnalysisTaskLeadingTrackUE.cxx:531
 AliAnalysisTaskLeadingTrackUE.cxx:532
 AliAnalysisTaskLeadingTrackUE.cxx:533
 AliAnalysisTaskLeadingTrackUE.cxx:534
 AliAnalysisTaskLeadingTrackUE.cxx:535
 AliAnalysisTaskLeadingTrackUE.cxx:536
 AliAnalysisTaskLeadingTrackUE.cxx:537
 AliAnalysisTaskLeadingTrackUE.cxx:538
 AliAnalysisTaskLeadingTrackUE.cxx:539
 AliAnalysisTaskLeadingTrackUE.cxx:540
 AliAnalysisTaskLeadingTrackUE.cxx:541
 AliAnalysisTaskLeadingTrackUE.cxx:542
 AliAnalysisTaskLeadingTrackUE.cxx:543
 AliAnalysisTaskLeadingTrackUE.cxx:544
 AliAnalysisTaskLeadingTrackUE.cxx:545
 AliAnalysisTaskLeadingTrackUE.cxx:546
 AliAnalysisTaskLeadingTrackUE.cxx:547
 AliAnalysisTaskLeadingTrackUE.cxx:548
 AliAnalysisTaskLeadingTrackUE.cxx:549
 AliAnalysisTaskLeadingTrackUE.cxx:550
 AliAnalysisTaskLeadingTrackUE.cxx:551
 AliAnalysisTaskLeadingTrackUE.cxx:552
 AliAnalysisTaskLeadingTrackUE.cxx:553
 AliAnalysisTaskLeadingTrackUE.cxx:554
 AliAnalysisTaskLeadingTrackUE.cxx:555
 AliAnalysisTaskLeadingTrackUE.cxx:556
 AliAnalysisTaskLeadingTrackUE.cxx:557
 AliAnalysisTaskLeadingTrackUE.cxx:558
 AliAnalysisTaskLeadingTrackUE.cxx:559
 AliAnalysisTaskLeadingTrackUE.cxx:560
 AliAnalysisTaskLeadingTrackUE.cxx:561
 AliAnalysisTaskLeadingTrackUE.cxx:562
 AliAnalysisTaskLeadingTrackUE.cxx:563
 AliAnalysisTaskLeadingTrackUE.cxx:564
 AliAnalysisTaskLeadingTrackUE.cxx:565
 AliAnalysisTaskLeadingTrackUE.cxx:566
 AliAnalysisTaskLeadingTrackUE.cxx:567
 AliAnalysisTaskLeadingTrackUE.cxx:568
 AliAnalysisTaskLeadingTrackUE.cxx:569
 AliAnalysisTaskLeadingTrackUE.cxx:570
 AliAnalysisTaskLeadingTrackUE.cxx:571
 AliAnalysisTaskLeadingTrackUE.cxx:572
 AliAnalysisTaskLeadingTrackUE.cxx:573
 AliAnalysisTaskLeadingTrackUE.cxx:574
 AliAnalysisTaskLeadingTrackUE.cxx:575
 AliAnalysisTaskLeadingTrackUE.cxx:576
 AliAnalysisTaskLeadingTrackUE.cxx:577
 AliAnalysisTaskLeadingTrackUE.cxx:578
 AliAnalysisTaskLeadingTrackUE.cxx:579
 AliAnalysisTaskLeadingTrackUE.cxx:580
 AliAnalysisTaskLeadingTrackUE.cxx:581
 AliAnalysisTaskLeadingTrackUE.cxx:582
 AliAnalysisTaskLeadingTrackUE.cxx:583
 AliAnalysisTaskLeadingTrackUE.cxx:584
 AliAnalysisTaskLeadingTrackUE.cxx:585
 AliAnalysisTaskLeadingTrackUE.cxx:586
 AliAnalysisTaskLeadingTrackUE.cxx:587
 AliAnalysisTaskLeadingTrackUE.cxx:588
 AliAnalysisTaskLeadingTrackUE.cxx:589
 AliAnalysisTaskLeadingTrackUE.cxx:590
 AliAnalysisTaskLeadingTrackUE.cxx:591
 AliAnalysisTaskLeadingTrackUE.cxx:592
 AliAnalysisTaskLeadingTrackUE.cxx:593
 AliAnalysisTaskLeadingTrackUE.cxx:594
 AliAnalysisTaskLeadingTrackUE.cxx:595
 AliAnalysisTaskLeadingTrackUE.cxx:596
 AliAnalysisTaskLeadingTrackUE.cxx:597
 AliAnalysisTaskLeadingTrackUE.cxx:598
 AliAnalysisTaskLeadingTrackUE.cxx:599
 AliAnalysisTaskLeadingTrackUE.cxx:600
 AliAnalysisTaskLeadingTrackUE.cxx:601
 AliAnalysisTaskLeadingTrackUE.cxx:602
 AliAnalysisTaskLeadingTrackUE.cxx:603
 AliAnalysisTaskLeadingTrackUE.cxx:604
 AliAnalysisTaskLeadingTrackUE.cxx:605
 AliAnalysisTaskLeadingTrackUE.cxx:606
 AliAnalysisTaskLeadingTrackUE.cxx:607
 AliAnalysisTaskLeadingTrackUE.cxx:608
 AliAnalysisTaskLeadingTrackUE.cxx:609
 AliAnalysisTaskLeadingTrackUE.cxx:610
 AliAnalysisTaskLeadingTrackUE.cxx:611
 AliAnalysisTaskLeadingTrackUE.cxx:612
 AliAnalysisTaskLeadingTrackUE.cxx:613
 AliAnalysisTaskLeadingTrackUE.cxx:614
 AliAnalysisTaskLeadingTrackUE.cxx:615
 AliAnalysisTaskLeadingTrackUE.cxx:616
 AliAnalysisTaskLeadingTrackUE.cxx:617
 AliAnalysisTaskLeadingTrackUE.cxx:618
 AliAnalysisTaskLeadingTrackUE.cxx:619
 AliAnalysisTaskLeadingTrackUE.cxx:620
 AliAnalysisTaskLeadingTrackUE.cxx:621
 AliAnalysisTaskLeadingTrackUE.cxx:622
 AliAnalysisTaskLeadingTrackUE.cxx:623
 AliAnalysisTaskLeadingTrackUE.cxx:624
 AliAnalysisTaskLeadingTrackUE.cxx:625
 AliAnalysisTaskLeadingTrackUE.cxx:626
 AliAnalysisTaskLeadingTrackUE.cxx:627
 AliAnalysisTaskLeadingTrackUE.cxx:628
 AliAnalysisTaskLeadingTrackUE.cxx:629
 AliAnalysisTaskLeadingTrackUE.cxx:630
 AliAnalysisTaskLeadingTrackUE.cxx:631
 AliAnalysisTaskLeadingTrackUE.cxx:632
 AliAnalysisTaskLeadingTrackUE.cxx:633
 AliAnalysisTaskLeadingTrackUE.cxx:634
 AliAnalysisTaskLeadingTrackUE.cxx:635
 AliAnalysisTaskLeadingTrackUE.cxx:636
 AliAnalysisTaskLeadingTrackUE.cxx:637
 AliAnalysisTaskLeadingTrackUE.cxx:638
 AliAnalysisTaskLeadingTrackUE.cxx:639
 AliAnalysisTaskLeadingTrackUE.cxx:640
 AliAnalysisTaskLeadingTrackUE.cxx:641
 AliAnalysisTaskLeadingTrackUE.cxx:642
 AliAnalysisTaskLeadingTrackUE.cxx:643
 AliAnalysisTaskLeadingTrackUE.cxx:644
 AliAnalysisTaskLeadingTrackUE.cxx:645