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.                  *
 **************************************************************************/

//_________________________________________________________________________
// Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and
// Central Barrel Tracking detectors (CTS).
// Not all MC particles/tracks/clusters are kept, some kinematical/fiducial restrictions are done.
// Mother class of : AliCaloTrackESDReader: Fills ESD data in 3 TObjArrays (PHOS, EMCAL, CTS)
//                 : AliCaloTrackMCReader : Fills Kinematics data in 3 TObjArrays (PHOS, EMCAL, CTS)
//                 : AliCaloTrackAODReader: Fills AOD data in 3 TObjArrays (PHOS, EMCAL, CTS)
//-- Author: Gustavo Conesa (LNF-INFN)
//////////////////////////////////////////////////////////////////////////////


// --- ROOT system ---
#include <TFile.h>
#include <TGeoManager.h>
#include <TStreamerInfo.h>

// ---- ANALYSIS system ----
#include "AliMCEvent.h"
#include "AliAODMCHeader.h"
#include "AliGenPythiaEventHeader.h"
#include "AliGenCocktailEventHeader.h"
#include "AliGenHijingEventHeader.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliVTrack.h"
#include "AliVParticle.h"
#include "AliMixedEvent.h"
//#include "AliTriggerAnalysis.h"
#include "AliESDVZERO.h"
#include "AliVCaloCells.h"
#include "AliAnalysisManager.h"
#include "AliInputEventHandler.h"
#include "AliAODMCParticle.h"
#include "AliStack.h"
#include "AliLog.h"

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

// ---- CaloTrackCorr ---
#include "AliCalorimeterUtils.h"
#include "AliCaloTrackReader.h"
// ---- Jets ----
#include "AliAODJet.h"
#include "AliAODJetEventBackground.h"

ClassImp(AliCaloTrackReader)


//________________________________________
AliCaloTrackReader::AliCaloTrackReader() :
TObject(),                   fEventNumber(-1), //fCurrentFileName(""),
fDataType(0),                fDebug(0),
fFiducialCut(0x0),           fCheckFidCut(kFALSE),
fComparePtHardAndJetPt(0),   fPtHardAndJetPtFactor(0),
fComparePtHardAndClusterPt(0),fPtHardAndClusterPtFactor(0),
fCTSPtMin(0),                fEMCALPtMin(0),                  fPHOSPtMin(0),
fCTSPtMax(0),                fEMCALPtMax(0),                  fPHOSPtMax(0),
fUseEMCALTimeCut(1),         fUseParamTimeCut(0),
fUseTrackTimeCut(0),         fAccessTrackTOF(0),
fEMCALTimeCutMin(-10000),    fEMCALTimeCutMax(10000),
fEMCALParamTimeCutMin(),     fEMCALParamTimeCutMax(),
fTrackTimeCutMin(-10000),    fTrackTimeCutMax(10000),
fUseTrackDCACut(0),
fAODBranchList(0x0),
fCTSTracks(0x0),             fEMCALClusters(0x0),
fDCALClusters(0x0),          fPHOSClusters(0x0),
fEMCALCells(0x0),            fPHOSCells(0x0),
fInputEvent(0x0),            fOutputEvent(0x0),fMC(0x0),
fFillCTS(0),                 fFillEMCAL(0),
fFillDCAL(0),                fFillPHOS(0),
fFillEMCALCells(0),          fFillPHOSCells(0),
fRecalculateClusters(kFALSE),fCorrectELinearity(kTRUE),
fSelectEmbeddedClusters(kFALSE),
fSmearShowerShape(0),        fSmearShowerShapeWidth(0),       fRandom(),
fTrackStatus(0),             fSelectSPDHitTracks(0),
fTrackMult(0),               fTrackMultEtaCut(0.9),
fReadStack(kFALSE),          fReadAODMCParticles(kFALSE),
fDeltaAODFileName(""),       fFiredTriggerClassName(""),

fEventTriggerMask(0),        fMixEventTriggerMask(0),         fEventTriggerAtSE(0),
fEventTrigMinBias(0),        fEventTrigCentral(0),
fEventTrigSemiCentral(0),    fEventTrigEMCALL0(0),
fEventTrigEMCALL1Gamma1(0),  fEventTrigEMCALL1Gamma2(0),
fEventTrigEMCALL1Jet1(0),    fEventTrigEMCALL1Jet2(0),
fBitEGA(0),                  fBitEJE(0),

fAnaLED(kFALSE),
fTaskName(""),               fCaloUtils(0x0),
fMixedEvent(NULL),           fNMixedEvent(0),                 fVertex(NULL),
fListMixedTracksEvents(),    fListMixedCaloEvents(),
fLastMixedTracksEvent(-1),   fLastMixedCaloEvent(-1),
fWriteOutputDeltaAOD(kFALSE),
fEMCALClustersListName(""),  fZvtxCut(0.),
fAcceptFastCluster(kFALSE),  fRemoveLEDEvents(kTRUE),
//Trigger rejection
fRemoveBadTriggerEvents(0),  fTriggerPatchClusterMatch(1),
fTriggerPatchTimeWindow(),   fTriggerL0EventThreshold(0),
fTriggerL1EventThreshold(0), fTriggerL1EventThresholdFix(0),
fTriggerClusterBC(0),        fTriggerClusterIndex(0),         fTriggerClusterId(0),
fIsExoticEvent(0),           fIsBadCellEvent(0),              fIsBadMaxCellEvent(0),
fIsTriggerMatch(0),          fIsTriggerMatchOpenCut(),
fTriggerClusterTimeRecal(kTRUE), fRemoveUnMatchedTriggers(kTRUE),
fDoPileUpEventRejection(kFALSE), fDoV0ANDEventSelection(kFALSE),
fDoVertexBCEventSelection(kFALSE),
fDoRejectNoTrackEvents(kFALSE),
fUseEventsWithPrimaryVertex(kFALSE),
//fTriggerAnalysis (0x0),
fTimeStampEventSelect(0),
fTimeStampEventFracMin(0),   fTimeStampEventFracMax(0),
fTimeStampRunMin(0),         fTimeStampRunMax(0),
fNPileUpClusters(-1),        fNNonPileUpClusters(-1),         fNPileUpClustersCut(3),
fVertexBC(-200),             fRecalculateVertexBC(0),
fCentralityClass(""),        fCentralityOpt(0),
fEventPlaneMethod(""),
fAcceptOnlyHIJINGLabels(0),  fNMCProducedMin(0), fNMCProducedMax(0),
fFillInputNonStandardJetBranch(kFALSE),
fNonStandardJets(new TClonesArray("AliAODJet",100)),fInputNonStandardJetBranchName("jets"),
fFillInputBackgroundJetBranch(kFALSE), 
fBackgroundJets(0x0),fInputBackgroundJetBranchName("jets"),
fAcceptEventsWithBit(0),     fRejectEventsWithBit(0), fRejectEMCalTriggerEventsWith2Tresholds(0),
fMomentum()
{
  //Ctor
  
  //Initialize parameters
  InitParameters();
}
//_______________________________________
AliCaloTrackReader::~AliCaloTrackReader()
{
  // Dtor
  DeletePointers();
}

//_______________________________________
void AliCaloTrackReader::DeletePointers()
{
  // Dtor
  
  delete fFiducialCut ;
	
  if(fAODBranchList)
  {
    fAODBranchList->Delete();
    delete fAODBranchList ;
  }
  
  if(fCTSTracks)
  {
    if(fDataType!=kMC)fCTSTracks->Clear() ;
    else              fCTSTracks->Delete() ;
    delete fCTSTracks ;
  }
  
  if(fEMCALClusters)
  {
    if(fDataType!=kMC)fEMCALClusters->Clear("C") ;
    else              fEMCALClusters->Delete() ;
    delete fEMCALClusters ;
  }
  
  if(fDCALClusters)
  {
    if(fDataType!=kMC)fDCALClusters->Clear("C") ;
    else              fDCALClusters->Delete() ;
    delete fDCALClusters ;
  }
  
  if(fPHOSClusters)
  {
    if(fDataType!=kMC)fPHOSClusters->Clear("C") ;
    else              fPHOSClusters->Delete() ;
    delete fPHOSClusters ;
  }
  
  if(fVertex)
  {
    for (Int_t i = 0; i < fNMixedEvent; i++)
    {
      delete [] fVertex[i] ;
      
    }
    delete [] fVertex ;
  }
  
  //delete fTriggerAnalysis;
  
  if(fNonStandardJets)
  {
    if(fDataType!=kMC) fNonStandardJets->Clear("C") ;
    else               fNonStandardJets->Delete() ;
    delete fNonStandardJets ;
  }
  delete fBackgroundJets ;

  fRejectEventsWithBit.Reset();
  fAcceptEventsWithBit.Reset();
  
  //  Pointers not owned, done by the analysis frame
  //  if(fInputEvent)  delete fInputEvent ;
  //  if(fOutputEvent) delete fOutputEvent ;
  //  if(fMC)          delete fMC ;
  //  Pointer not owned, deleted by maker
  //  if (fCaloUtils) delete fCaloUtils ;
  
}

//________________________________________________________________________
Bool_t  AliCaloTrackReader::AcceptDCA(Float_t pt, Float_t dca)
{
  // Accept track if DCA is smaller than function
  
  Float_t cut = fTrackDCACut[0]+fTrackDCACut[1]/TMath::Power(pt,fTrackDCACut[2]);
  
  if(TMath::Abs(dca) < cut)
    return kTRUE;
  else
    return kFALSE;
  
}

//_____________________________________________________
Bool_t  AliCaloTrackReader::AcceptEventWithTriggerBit()
{
  // Accept events that pass the physics selection
  // depending on an array of trigger bits set during the configuration
  
  Int_t nAccept = fAcceptEventsWithBit.GetSize();
  
  //printf("N accept %d\n", nAccept);
  
  if( nAccept <= 0 )
    return kTRUE ; // accept the event
  
  UInt_t trigFired = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
  
  for(Int_t ibit = 0; ibit < nAccept; ibit++)
  {
    Bool_t accept = (trigFired & fAcceptEventsWithBit.At(ibit));
    
    //printf("accept %d, ibit %d, bit %d \n",accept, ibit,fAcceptEventsWithBit.At(ibit));
    if(accept) return kTRUE ; // accept the event
  }
  
  return kFALSE ; // reject the event
  
}

//_____________________________________________________
Bool_t  AliCaloTrackReader::RejectEventWithTriggerBit()
{
  // Reject events that pass the physics selection
  // depending on an array of trigger bits set during the configuration

  Int_t nReject = fRejectEventsWithBit.GetSize();
  
  //printf("N reject %d\n", nReject);
  
  if( nReject <= 0 )
    return kTRUE ; // accept the event
  
  UInt_t trigFired = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
  
  for(Int_t ibit = 0; ibit < nReject; ibit++)
  {
    Bool_t reject = (trigFired & fRejectEventsWithBit.At(ibit));
    
    //printf("reject %d, ibit %d, bit %d \n",reject, ibit,fRejectEventsWithBit.At(ibit));
    if(reject) return kFALSE ; // reject the event
  }
  
  return kTRUE ; // accept the event
  
}

//_____________________________________________
Bool_t AliCaloTrackReader::CheckEventTriggers()
{
  // Do different selection of the event
  // depending on trigger name, event type, goodness of the EMCal trigger ...
  
  //-----------------------------------------------------------
  // Reject events depending on the trigger name and event type
  //-----------------------------------------------------------
  
  Int_t eventType = 0;
  if(fInputEvent->GetHeader())
  eventType = ((AliVHeader*)fInputEvent->GetHeader())->GetEventType();
  
  if( fFiredTriggerClassName  !="" && !fAnaLED)
  {
    //printf("Event type %d\n",eventType);
    if(eventType!=7)
    return kFALSE; //Only physics event, do not use for simulated events!!!
    
   AliDebug(1,Form("FiredTriggerClass <%s>, selected class <%s>, compare name %d",
                   GetFiredTriggerClasses().Data(),fFiredTriggerClassName.Data(),
                   GetFiredTriggerClasses().Contains(fFiredTriggerClassName)));
    
    if( !GetFiredTriggerClasses().Contains(fFiredTriggerClassName) ) return kFALSE;
    else AliDebug(1,"Accepted triggered event");
  }
  else if(fAnaLED)
  {
    //	  kStartOfRun =       1,    // START_OF_RUN
    //	  kEndOfRun =         2,    // END_OF_RUN
    //	  kStartOfRunFiles =  3,    // START_OF_RUN_FILES
    //	  kEndOfRunFiles =    4,    // END_OF_RUN_FILES
    //	  kStartOfBurst =     5,    // START_OF_BURST
    //	  kEndOfBurst =       6,    // END_OF_BURST
    //	  kPhysicsEvent =     7,    // PHYSICS_EVENT
    //	  kCalibrationEvent = 8,    // CALIBRATION_EVENT
    //	  kFormatError =      9,    // EVENT_FORMAT_ERROR
    //	  kStartOfData =      10,   // START_OF_DATA
    //	  kEndOfData =        11,   // END_OF_DATA
    //	  kSystemSoftwareTriggerEvent   = 12, // SYSTEM_SOFTWARE_TRIGGER_EVENT
    //	  kDetectorSoftwareTriggerEvent = 13  // DETECTOR_SOFTWARE_TRIGGER_EVENT
    
	  //if(eventType!=7 && fDebug > 1 )printf("AliCaloTrackReader::CheckEventTriggers() - DO LED, Event Type <%d>, 8 Calibration \n",  eventType);
	  if(eventType!=8) return kFALSE;
  }
  
  AliDebug(1,"Pass Trigger name rejection");

  //-----------------------------------------------------------------
  // In case of mixing analysis, select here the trigger of the event
  //-----------------------------------------------------------------
  UInt_t isTrigger = kFALSE;
  UInt_t isMB      = kFALSE;
  if(!fEventTriggerAtSE)
  {
    // In case of mixing analysis, accept MB events, not only Trigger
    // Track and cluster arrays filled for MB in order to create the pool in the corresponding analysis
    // via de method in the base class FillMixedEventPool()
    
    AliAnalysisManager *manager = AliAnalysisManager::GetAnalysisManager();
    AliInputEventHandler *inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
    
    if(!inputHandler) return kFALSE ;  // to content coverity
    
    isTrigger = inputHandler->IsEventSelected() & fEventTriggerMask;
    isMB      = inputHandler->IsEventSelected() & fMixEventTriggerMask;
    
    if(!isTrigger && !isMB) return kFALSE;
    
    //printf("Selected triggered event : %s\n",GetFiredTriggerClasses().Data());
    AliDebug(0,"Pass uninteresting triggered events rejection in case of mixing analysis");
  }

  //-------------------------------------------------------------------------------------
  // Reject or accept events depending on the trigger bit
  //-------------------------------------------------------------------------------------
  
  Bool_t okA = AcceptEventWithTriggerBit();
  Bool_t okR = RejectEventWithTriggerBit();
  
  //printf("AliCaloTrackReader::FillInputEvent() - Accept event? %d, Reject event %d? \n",okA,okR);
  
  if(!okA || !okR) return kFALSE;
  
  AliDebug(1,"Pass event bit rejection");
  
  //----------------------------------------------------------------------
  // Do not count events that were likely triggered by an exotic cluster
  // or out BC cluster
  //----------------------------------------------------------------------
  
  // Set a bit with the event kind, MB, L0, L1 ...
  SetEventTriggerBit();
  
  // In case of Mixing, avoid checking the triggers in the min bias events
  if(!fEventTriggerAtSE && (isMB && !isTrigger)) return kTRUE;
  
  if( (IsEventEMCALL1() || IsEventEMCALL0())  &&  fTriggerPatchClusterMatch)
  {
    if(fRejectEMCalTriggerEventsWith2Tresholds)
    {
      // Reject triggered events when there is coincidence on both EMCal trigger thresholds,
      // but the requested trigger is the low trigger threshold
      if(IsEventEMCALL1Jet1  () && IsEventEMCALL1Jet2  () && fFiredTriggerClassName.Contains("EJ2")) return kFALSE;
      if(IsEventEMCALL1Gamma1() && IsEventEMCALL1Gamma2() && fFiredTriggerClassName.Contains("EG2")) return kFALSE;
    }
    
    //Get Patches that triggered
    TArrayI patches = GetTriggerPatches(fTriggerPatchTimeWindow[0],fTriggerPatchTimeWindow[1]);
    
    MatchTriggerCluster(patches);
    
    patches.Reset();
    
    // If requested, remove badly triggeed events, but only when the EMCal trigger bit is set
    if(fRemoveBadTriggerEvents)
    {
     AliDebug(1,Form("ACCEPT triggered event? \n exotic? %d - bad cell %d - bad Max cell %d - BC %d  - Matched %d\n",
                     fIsExoticEvent,fIsBadCellEvent, fIsBadMaxCellEvent, fTriggerClusterBC,fIsTriggerMatch));
      if     (fIsExoticEvent)         return kFALSE;
      else if(fIsBadCellEvent)        return kFALSE;
      else if(fRemoveUnMatchedTriggers && !fIsTriggerMatch) return kFALSE ;
      else if(fTriggerClusterBC != 0) return kFALSE;
      AliDebug(1,Form("\t *** YES for %s",GetFiredTriggerClasses().Data()));
    }
    
   AliDebug(1,"Pass EMCal triggered event rejection \n");
  }
  
  //-------------------------------------------------------------------------------------
  //Select events only fired by a certain trigger configuration if it is provided
  //-------------------------------------------------------------------------------------
  if (GetFiredTriggerClasses().Contains("FAST")  && !GetFiredTriggerClasses().Contains("ALL") && !fAcceptFastCluster)
  {
    AliDebug(1,Form("Do not count events from fast cluster, trigger name %s\n",fFiredTriggerClassName.Data()));
    return kFALSE;
  }
  
  //-------------------------------------------------------------------------------------
  // Reject event if large clusters with large energy
  // Use only for LHC11a data for the moment, and if input is clusterizer V1 or V1+unfolding
  // If clusterzer NxN or V2 it does not help
  //-------------------------------------------------------------------------------------
  Int_t run = fInputEvent->GetRunNumber();
  if( fRemoveLEDEvents && run > 146857  && run < 146861 )
  {
    Bool_t reject = RejectLEDEvents();

    if(reject) return kFALSE;
    
    AliDebug(1,"Pass LED event rejection");

  }// Remove LED events
  
  return kTRUE;
}

//________________________________________________
Bool_t AliCaloTrackReader::ComparePtHardAndJetPt()
{
  // Check the event, if the requested ptHard is much smaller than the jet pT, then there is a problem.
  // Only for PYTHIA.
  
  //printf("AliCaloTrackReader::ComparePtHardAndJetPt() - GenHeaderName : %s\n",GetGenEventHeader()->ClassName());
  
  if(!strcmp(GetGenEventHeader()->ClassName(), "AliGenPythiaEventHeader"))
  {
    TParticle * jet =  0;
    AliGenPythiaEventHeader* pygeh= (AliGenPythiaEventHeader*) GetGenEventHeader();
    Int_t nTriggerJets =  pygeh->NTriggerJets();
    Float_t ptHard = pygeh->GetPtHard();
    
    AliDebug(1,Form("Njets: %d, pT Hard %f",nTriggerJets, ptHard));
    
    Float_t tmpjet[]={0,0,0,0};
    for(Int_t ijet = 0; ijet< nTriggerJets; ijet++)
    {
      pygeh->TriggerJet(ijet, tmpjet);
      jet = new TParticle(94, 21, -1, -1, -1, -1, tmpjet[0],tmpjet[1],tmpjet[2],tmpjet[3], 0,0,0,0);
      
      AliDebug(1,Form("jet %d; pycell jet pT %f",ijet, jet->Pt()));
      
      //Compare jet pT and pt Hard
      if(jet->Pt() > fPtHardAndJetPtFactor * ptHard)
      {
        AliInfo(Form("Reject jet event with : pT Hard %2.2f, pycell jet pT %2.2f, rejection factor %1.1f\n",
                     ptHard, jet->Pt(), fPtHardAndJetPtFactor));
        return kFALSE;
      }
    }
    
    if(jet) delete jet;
  }
  
  return kTRUE ;
  
}

//____________________________________________________________________
Bool_t AliCaloTrackReader::ComparePtHardAndClusterPt()
{
  // Check the event, if the requested ptHard is smaller than the calorimeter cluster E, then there is a problem.
  // Only for PYTHIA.
  
  if(!strcmp(GetGenEventHeader()->ClassName(), "AliGenPythiaEventHeader"))
  {
    AliGenPythiaEventHeader* pygeh= (AliGenPythiaEventHeader*) GetGenEventHeader();
    Float_t ptHard = pygeh->GetPtHard();
    
    Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
    for (Int_t iclus =  0; iclus <  nclusters; iclus++)
    {
      AliVCluster * clus = fInputEvent->GetCaloCluster(iclus) ;
      Float_t ecluster = clus->E();
      
      if(ecluster > fPtHardAndClusterPtFactor*ptHard)
      {
        AliInfo(Form("Reject : ecluster %2.2f, calo %d, factor %2.2f, ptHard %f",ecluster,clus->GetType(),fPtHardAndClusterPtFactor,ptHard));
        
        return kFALSE;
      }
    }
    
  }
  
  return kTRUE ;
  
}

//____________________________________________
AliStack* AliCaloTrackReader::GetStack() const
{
  //Return pointer to stack
  if(fMC)
    return fMC->Stack();
  else
  {
    AliDebug(1,"Stack is not available");
    return 0x0 ;
  }
}

//______________________________________________
AliHeader* AliCaloTrackReader::GetHeader() const
{
  //Return pointer to header
  if(fMC)
  {
    return fMC->Header();
  }
  else
  {
    AliInfo("Header is not available");
    return 0x0 ;
  }
}

//____________________________________________________
void AliCaloTrackReader::SetGeneratorMinMaxParticles()
{
  // In case of access only to hijing particles in cocktail
  // get the min and max labels
  // TODO: Check when generator is not the first one ...
  
  fNMCProducedMin = 0;
  fNMCProducedMax = 0;
  
  if     (ReadStack() && fMC)
  {
    AliGenEventHeader * eventHeader = fMC->GenEventHeader();
    
    if(!fAcceptOnlyHIJINGLabels) return ;
    
    // TODO Check if it works from here ...
    
    AliGenCocktailEventHeader *cocktail = dynamic_cast<AliGenCocktailEventHeader *>(eventHeader);
    
    if(!cocktail) return ;
    
    TList *genHeaders = cocktail->GetHeaders();
    
    Int_t nGenerators = genHeaders->GetEntries();
    //printf("N generators %d \n", nGenerators);
    
    for(Int_t igen = 0; igen < nGenerators; igen++)
    {
      AliGenEventHeader * eventHeader2 = (AliGenEventHeader*)genHeaders->At(igen) ;
      TString name = eventHeader2->GetName();
      
      //printf("Generator %d: Class Name %s, Name %s, title %s \n",igen, eventHeader2->ClassName(), name.Data(), eventHeader2->GetTitle());
      
      fNMCProducedMin = fNMCProducedMax;
      fNMCProducedMax+= eventHeader2->NProduced();
      
			if(name.Contains("Hijing",TString::kIgnoreCase)) return ;
    }
        
  }
  else if(ReadAODMCParticles() && GetAODMCHeader())
  {
    Int_t nGenerators = GetAODMCHeader()->GetNCocktailHeaders();
    //printf("AliCaloTrackReader::GetGenEventHeader() - N headers %d\n",nGenerators);
    
    if( nGenerators <= 0)        return ;
    
    if(!fAcceptOnlyHIJINGLabels) return ;
    
    for(Int_t igen = 0; igen < nGenerators; igen++)
    {
      AliGenEventHeader * eventHeader = GetAODMCHeader()->GetCocktailHeader(igen) ;
      TString name = eventHeader->GetName();
      
      //printf("Generator %d: Class Name %s, Name %s, title %s \n",igen, eventHeader->ClassName(), name.Data(), eventHeader->GetTitle());
      
      fNMCProducedMin = fNMCProducedMax;
      fNMCProducedMax+= eventHeader->NProduced();
      
			if(name.Contains("Hijing",TString::kIgnoreCase)) return ;
    }
        
  }
}


//______________________________________________________________
AliGenEventHeader* AliCaloTrackReader::GetGenEventHeader() const
{
  // Return pointer to Generated event header
  // If requested and cocktail, search for the hijing generator
  
  if     (ReadStack() && fMC)
  {
    AliGenEventHeader * eventHeader = fMC->GenEventHeader();
    
    if(!fAcceptOnlyHIJINGLabels) return eventHeader ;
    
    // TODO Check if it works from here ...
    
    AliGenCocktailEventHeader *cocktail = dynamic_cast<AliGenCocktailEventHeader *>(eventHeader);
    
    if(!cocktail) return 0x0 ;
    
    TList *genHeaders = cocktail->GetHeaders();
    
    Int_t nGenerators = genHeaders->GetEntries();
    //printf("N generators %d \n", nGenerators);
    
    for(Int_t igen = 0; igen < nGenerators; igen++)
    {
      AliGenEventHeader * eventHeader2 = (AliGenEventHeader*)genHeaders->At(igen) ;
      TString name = eventHeader2->GetName();
      
      //printf("Generator %d: Class Name %s, Name %s, title %s \n",igen, eventHeader2->ClassName(), name.Data(), eventHeader2->GetTitle());
      
			if(name.Contains("Hijing",TString::kIgnoreCase)) return eventHeader2 ;
    }

    return 0x0;
    
  }
  else if(ReadAODMCParticles() && GetAODMCHeader())
  {
    Int_t nGenerators = GetAODMCHeader()->GetNCocktailHeaders();
    //printf("AliCaloTrackReader::GetGenEventHeader() - N headers %d\n",nGenerators);

    if( nGenerators <= 0)        return 0x0;
    
    if(!fAcceptOnlyHIJINGLabels) return GetAODMCHeader()->GetCocktailHeader(0);
        
    for(Int_t igen = 0; igen < nGenerators; igen++)
    {
      AliGenEventHeader * eventHeader = GetAODMCHeader()->GetCocktailHeader(igen) ;
      TString name = eventHeader->GetName();
      
      //printf("Generator %d: Class Name %s, Name %s, title %s \n",igen, eventHeader->ClassName(), name.Data(), eventHeader->GetTitle());
      
			if(name.Contains("Hijing",TString::kIgnoreCase)) return eventHeader ;
    }
    
    return 0x0;
        
  }
  else
  {
    //printf("AliCaloTrackReader::GetGenEventHeader() - MC header not available! \n");
    return 0x0;
  }
}

//_________________________________________________________
TClonesArray* AliCaloTrackReader::GetAODMCParticles() const
{
  //Return list of particles in AOD, implemented in AliCaloTrackAODReader.
  
  AliInfo("Input are not AODs");
  
  return NULL ;
}

//________________________________________________________
AliAODMCHeader* AliCaloTrackReader::GetAODMCHeader() const
{
  //Return MC header in AOD, implemented in AliCaloTrackAODReader.
  
  AliInfo("Input are not AODs");
  
  return NULL ;
}

//___________________________________________________________
Int_t AliCaloTrackReader::GetVertexBC(const AliVVertex * vtx)
{
  // Get the vertex BC
  
  Int_t vertexBC=vtx->GetBC();
  if(!fRecalculateVertexBC) return vertexBC;
  
  // In old AODs BC not stored, recalculate it
  // loop over the global track and select those which have small DCA to primary vertex (e.g. primary).
  // If at least one of these primaries has valid BC != 0, then this vertex is a pile-up candidate.
  // Execute after CTS
  Double_t bz  = fInputEvent->GetMagneticField();
  Bool_t   bc0 = kFALSE;
  Int_t    ntr = GetCTSTracks()->GetEntriesFast();
  //printf("N Tracks %d\n",ntr);
  
  for(Int_t i = 0 ; i < ntr ; i++)
  {
    AliVTrack * track =  (AliVTrack*) (GetCTSTracks()->At(i));
    
    //Check if has TOF info, if not skip
    ULong_t status  = track->GetStatus();
    Bool_t  okTOF   = (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ;
    vertexBC        = track->GetTOFBunchCrossing(bz);
    Float_t pt      = track->Pt();
    
    if(!okTOF) continue;
    
    // Get DCA x, y
    Double_t dca[2]   = {1e6,1e6};
    Double_t covar[3] = {1e6,1e6,1e6};
    track->PropagateToDCA(vtx,bz,100.,dca,covar);
    
    if(AcceptDCA(pt,dca[0]))
    {
      if     (vertexBC !=0 && fVertexBC != AliVTrack::kTOFBCNA) return vertexBC;
      else if(vertexBC == 0)                                    bc0 = kTRUE;
    }
  }
  
  if( bc0 ) vertexBC = 0 ;
  else      vertexBC = AliVTrack::kTOFBCNA ;
  
  return vertexBC;
  
}

//_____________________________
void AliCaloTrackReader::Init()
{
  //Init reader. Method to be called in AliAnaCaloTrackCorrMaker
  
  if(fReadStack && fReadAODMCParticles)
  {
    AliInfo("Cannot access stack and mcparticles at the same time, change them");
    fReadStack          = kFALSE;
    fReadAODMCParticles = kFALSE;
  }
  
}

//_______________________________________
void AliCaloTrackReader::InitParameters()
{
  //Initialize the parameters of the analysis.
  fDataType   = kESD ;
  fCTSPtMin   = 0.1 ;
  fEMCALPtMin = 0.1 ;
  fPHOSPtMin  = 0.1 ;
  fCTSPtMax   = 1000. ;
  fEMCALPtMax = 1000. ;
  fPHOSPtMax  = 1000. ;
  
  //Track DCA cuts
  // dca_xy cut = 0.0105+0.0350/TMath::Power(pt,1.1);
  fTrackDCACut[0] = 0.0105;
  fTrackDCACut[1] = 0.0350;
  fTrackDCACut[2] = 1.1;
  
  //Do not filter the detectors input by default.
  fFillEMCAL      = kFALSE;
  fFillDCAL       = kFALSE;
  fFillPHOS       = kFALSE;
  fFillCTS        = kFALSE;
  fFillEMCALCells = kFALSE;
  fFillPHOSCells  = kFALSE;
  
  fReadStack             = kFALSE; // Check in the constructor of the other readers if it was set or in the configuration file
  fReadAODMCParticles    = kFALSE; // Check in the constructor of the other readers if it was set or in the configuration file
  fDeltaAODFileName      = "deltaAODPartCorr.root";
  fFiredTriggerClassName = "";
  fEventTriggerMask      = AliVEvent::kAny;
  fMixEventTriggerMask   = AliVEvent::kAnyINT;
  fEventTriggerAtSE      = kTRUE; // Use only events that pass event selection at SE base class
  
  fAcceptFastCluster = kTRUE;
  fAnaLED            = kFALSE;
  
  //We want tracks fitted in the detectors:
  //fTrackStatus=AliESDtrack::kTPCrefit;
  //fTrackStatus|=AliESDtrack::kITSrefit;
  fTrackStatus     = 0;
  
  fV0ADC[0] = 0;   fV0ADC[1] = 0;
  fV0Mul[0] = 0;   fV0Mul[1] = 0;
  
  fZvtxCut   = 10.;
  
  fNMixedEvent = 1;
  
  fPtHardAndJetPtFactor     = 7.;
  fPtHardAndClusterPtFactor = 1.;
  
  //Centrality
  fCentralityClass  = "V0M";
  fCentralityOpt    = 100;
  fCentralityBin[0] = fCentralityBin[1]=-1;
  
  fEventPlaneMethod = "V0";
  
  // Allocate memory (not sure this is the right place)
  fCTSTracks       = new TObjArray();
  fEMCALClusters   = new TObjArray();
  fDCALClusters    = new TObjArray();
  fPHOSClusters    = new TObjArray();
  //fTriggerAnalysis = new AliTriggerAnalysis;
  fAODBranchList   = new TList ;
  
  fPileUpParamSPD[0] = 3   ; fPileUpParamSPD[1] = 0.8 ;
  fPileUpParamSPD[2] = 3.0 ; fPileUpParamSPD[3] = 2.0 ; fPileUpParamSPD[4] = 5.0;
  
  // Parametrized time cut (LHC11d)
  fEMCALParamTimeCutMin[0] =-5; fEMCALParamTimeCutMin[1] =-1 ; fEMCALParamTimeCutMin[2] = 3.5 ; fEMCALParamTimeCutMin[3] = 1.  ;
  fEMCALParamTimeCutMax[0] = 5; fEMCALParamTimeCutMax[1] = 50; fEMCALParamTimeCutMax[2] = 0.45; fEMCALParamTimeCutMax[3] = 1.25;
  
  // Parametrized time cut (LHC11c)
  //fEMCALParamTimeCutMin[0] =-5;   fEMCALParamTimeCutMin[1] =-1 ; fEMCALParamTimeCutMin[2] = 1.87; fEMCALParamTimeCutMin[3] = 0.4;
  //fEMCALParamTimeCutMax[0] = 3.5; fEMCALParamTimeCutMax[1] = 50; fEMCALParamTimeCutMax[2] = 0.15; fEMCALParamTimeCutMax[3] = 1.6;
  
  fTimeStampRunMin = -1;
  fTimeStampRunMax = 1e12;
  fTimeStampEventFracMin = -1;
  fTimeStampEventFracMax = 2;
  
  for(Int_t i = 0; i < 19; i++)
  {
    fEMCalBCEvent   [i] = 0;
    fEMCalBCEventCut[i] = 0;
    fTrackBCEvent   [i] = 0;
    fTrackBCEventCut[i] = 0;
  }
  
  // Trigger match-rejection
  fTriggerPatchTimeWindow[0] = 8;
  fTriggerPatchTimeWindow[1] = 9;
  
  fTriggerClusterBC        = -10000 ;
  fTriggerL0EventThreshold =  2.;
  fTriggerL1EventThreshold =  4.;
  fTriggerClusterIndex     = -1;
  fTriggerClusterId        = -1;
  
  //Jets
  fInputNonStandardJetBranchName = "jets";
  fFillInputNonStandardJetBranch = kFALSE;
  if(!fNonStandardJets) fNonStandardJets = new TClonesArray("AliAODJet",100);
  fInputBackgroundJetBranchName = "jets";
  fFillInputBackgroundJetBranch = kFALSE; 
  if(!fBackgroundJets) fBackgroundJets = new AliAODJetEventBackground();

  fSmearShowerShapeWidth = 0.002;
  
}

//________________________________________________________________________
Bool_t AliCaloTrackReader::IsHIJINGLabel(Int_t label)
{
 
  // Find if cluster/track was generated by HIJING
  
  AliGenHijingEventHeader*  hijingHeader =  dynamic_cast<AliGenHijingEventHeader *> (GetGenEventHeader());
  
  //printf("header %p, label %d\n",hijingHeader,label);
  
  if(!hijingHeader || label < 0 ) return kFALSE;
  
  
  //printf("pass a), N produced %d\n",nproduced);
  
  if(label >= fNMCProducedMin && label < fNMCProducedMax)
  {
    //printf(" accept!, label is smaller than produced, N %d\n",nproduced);

    return kTRUE;
  }
  
  if(ReadStack())
  {
    if(!GetStack()) return kFALSE;
    
    Int_t nprimaries = GetStack()->GetNtrack();
    
    if(label > nprimaries) return kFALSE;
    
    TParticle * mom = GetStack()->Particle(label);
    
    Int_t iMom = label;
    Int_t iParent = mom->GetFirstMother();
    while(iParent!=-1)
    {
      if(iParent >= fNMCProducedMin && iParent < fNMCProducedMax)
      {
        //printf("\t accept, mother is %d \n",iParent)
        return kTRUE;
      }
      
      iMom = iParent;
      mom = GetStack()->Particle(iMom);
      iParent = mom->GetFirstMother();
    }
    
    return kFALSE ;
    
  } // ESD
  else
  {
    TClonesArray* mcparticles = GetAODMCParticles();
    
    if(!mcparticles) return kFALSE;
    
    Int_t nprimaries = mcparticles->GetEntriesFast();
    
    if(label > nprimaries) return kFALSE;
    
    //printf("pass b) N primaries %d \n",nprimaries);
    
    if(label >= fNMCProducedMin && label < fNMCProducedMax)
    {
      return kTRUE;
    }
    
    // Find grand parent, check if produced in the good range
    AliAODMCParticle * mom = (AliAODMCParticle *) mcparticles->At(label);
    
    Int_t iMom = label;
    Int_t iParent = mom->GetMother();
    while(iParent!=-1)
    {
      if(iParent >= fNMCProducedMin && iParent < fNMCProducedMax)
      {
        //printf("\t accept, mother is %d, with nProduced %d \n",iParent, nproduced);
        return kTRUE;
      }
      
      iMom = iParent;
      mom = (AliAODMCParticle *) mcparticles->At(iMom);
      iParent = mom->GetMother();

    }
    
    //printf("pass c), no match found \n");
    
    return kFALSE ;
    
  }//AOD
}

//__________________________________________________________________________
Bool_t AliCaloTrackReader::IsInTimeWindow(Double_t tof, Float_t energy) const
{
  // Cluster time selection window
  
  // Parametrized cut depending on E
  if(fUseParamTimeCut)
  {
    Float_t minCut= fEMCALParamTimeCutMin[0]+fEMCALParamTimeCutMin[1]*TMath::Exp(-(energy-fEMCALParamTimeCutMin[2])/fEMCALParamTimeCutMin[3]);
    Float_t maxCut= fEMCALParamTimeCutMax[0]+fEMCALParamTimeCutMax[1]*TMath::Exp(-(energy-fEMCALParamTimeCutMax[2])/fEMCALParamTimeCutMax[3]);
    //printf("tof %f, minCut %f, maxCut %f\n",tof,minCut,maxCut);
    if( tof < minCut || tof > maxCut )  return kFALSE ;
  }
  
  //In any case, the time should to be larger than the fixed window ...
  if( tof < fEMCALTimeCutMin  || tof > fEMCALTimeCutMax )  return kFALSE ;
  
  return kTRUE ;
}

//________________________________________________
Bool_t AliCaloTrackReader::IsPileUpFromSPD() const
{
  // Check if event is from pile-up determined by SPD
  // Default values: (3, 0.8, 3., 2., 5.)
  return fInputEvent->IsPileupFromSPD((Int_t) fPileUpParamSPD[0] , fPileUpParamSPD[1] ,
                                      fPileUpParamSPD[2] , fPileUpParamSPD[3] , fPileUpParamSPD[4] );
  //printf("Param : %d, %2.2f, %2.2f, %2.2f, %2.2f\n",(Int_t) fPileUpParamSPD[0], fPileUpParamSPD[1], fPileUpParamSPD[2], fPileUpParamSPD[3], fPileUpParamSPD[4]);
  
}

//__________________________________________________
Bool_t AliCaloTrackReader::IsPileUpFromEMCal() const
{
  // Check if event is from pile-up determined by EMCal
  if(fNPileUpClusters > fNPileUpClustersCut) return kTRUE ;
  else                                       return kFALSE;
}

//________________________________________________________
Bool_t AliCaloTrackReader::IsPileUpFromSPDAndEMCal() const
{
  // Check if event is from pile-up determined by SPD and EMCal
  if( IsPileUpFromSPD() && IsPileUpFromEMCal()) return kTRUE ;
  else                                          return kFALSE;
}

//_______________________________________________________
Bool_t AliCaloTrackReader::IsPileUpFromSPDOrEMCal() const
{
  // Check if event is from pile-up determined by SPD or EMCal
  if( IsPileUpFromSPD() || IsPileUpFromEMCal()) return kTRUE ;
  else                                          return kFALSE;
}

//___________________________________________________________
Bool_t AliCaloTrackReader::IsPileUpFromSPDAndNotEMCal() const
{
  // Check if event is from pile-up determined by SPD and not by EMCal
  if( IsPileUpFromSPD() && !IsPileUpFromEMCal()) return kTRUE ;
  else                                          return kFALSE;
}

//___________________________________________________________
Bool_t AliCaloTrackReader::IsPileUpFromEMCalAndNotSPD() const
{
  // Check if event is from pile-up determined by EMCal, not by SPD
  if( !IsPileUpFromSPD() && IsPileUpFromEMCal()) return kTRUE ;
  else                                           return kFALSE;
}

//______________________________________________________________
Bool_t AliCaloTrackReader::IsPileUpFromNotSPDAndNotEMCal() const
{
  // Check if event not from pile-up determined neither by SPD nor by EMCal
  if( !IsPileUpFromSPD() && !IsPileUpFromEMCal()) return kTRUE ;
  else                                            return kFALSE;
}

//___________________________________________________________________________________
Bool_t AliCaloTrackReader::FillInputEvent(Int_t iEntry, const char * /*curFileName*/)
{
  //Fill the event counter and input lists that are needed, called by the analysis maker.
  
  fEventNumber         = iEntry;
  fTriggerClusterIndex = -1;
  fTriggerClusterId    = -1;
  fIsTriggerMatch      = kFALSE;
  fTriggerClusterBC    = -10000;
  fIsExoticEvent       = kFALSE;
  fIsBadCellEvent      = kFALSE;
  fIsBadMaxCellEvent   = kFALSE;
  
  fIsTriggerMatchOpenCut[0] = kFALSE ;
  fIsTriggerMatchOpenCut[1] = kFALSE ;
  fIsTriggerMatchOpenCut[2] = kFALSE ;
  
  //fCurrentFileName = TString(currentFileName);
  if(!fInputEvent)
  {
    AliInfo("Input event not available, skip event analysis");
    return kFALSE;
  }
  
  //-----------------------------------------------
  // Select the event depending on the trigger type
  // and other event characteristics
  // like the goodness of the EMCal trigger
  //-----------------------------------------------
  
  Bool_t accept = CheckEventTriggers();
  if(!accept) return kFALSE;
  
  AliDebug(1,"Pass Event trigger selection");
  
  //---------------------------------------------------------------------------
  // In case of analysis of events with jets, skip those with jet pt > 5 pt hard
  // To be used on for MC data in pT hard bins
  //---------------------------------------------------------------------------
  
  if(fComparePtHardAndJetPt)
  {
    if(!ComparePtHardAndJetPt()) return kFALSE ;
    AliDebug(1,"Pass Pt Hard - Jet rejection");
  }
  
  if(fComparePtHardAndClusterPt)
  {
    if(!ComparePtHardAndClusterPt()) return kFALSE ;
    AliDebug(1,"Pass Pt Hard - Cluster rejection");
  }
  
  //------------------------------------------------------
  // Event rejection depending on time stamp
  //------------------------------------------------------
  
  if(fDataType==kESD && fTimeStampEventSelect)
  {
    AliESDEvent* esd = dynamic_cast<AliESDEvent*> (fInputEvent);
    if(esd)
    {
      Int_t timeStamp = esd->GetTimeStamp();
      Float_t timeStampFrac = 1.*(timeStamp-fTimeStampRunMin) / (fTimeStampRunMax-fTimeStampRunMin);
      
      //printf("stamp0 %d, max0 %d, frac %f\n", timeStamp-fTimeStampRunMin,fTimeStampRunMax-fTimeStampRunMin, timeStampFrac);
      
      if(timeStampFrac < fTimeStampEventFracMin || timeStampFrac > fTimeStampEventFracMax) return kFALSE;
    }
    
    AliDebug(1,"Pass Time Stamp rejection");
  }
  
  //------------------------------------------------------
  // Event rejection depending on vertex, pileup, v0and
  //------------------------------------------------------
  
  FillVertexArray();
  
  //Reject events with Z vertex too large, only for SE analysis, if not, cut on the analysis code
  if(!GetMixedEvent() && TMath::Abs(fVertex[0][2]) > fZvtxCut) return kFALSE;
  
  if(fUseEventsWithPrimaryVertex)
  {
    if( !CheckForPrimaryVertex() )              return kFALSE; // algorithm in ESD/AOD Readers
    if( TMath::Abs(fVertex[0][0] ) < 1.e-6 &&
        TMath::Abs(fVertex[0][1] ) < 1.e-6 &&
        TMath::Abs(fVertex[0][2] ) < 1.e-6    ) return kFALSE;
  }
  
  AliDebug(1,"Pass primary vertex rejection");
  
  //printf("Reader : IsPileUp %d, Multi %d\n",IsPileUpFromSPD(),fInputEvent->IsPileupFromSPDInMultBins());
  
  if(fDoPileUpEventRejection)
  {
    // Do not analyze events with pileup
    Bool_t bPileup = IsPileUpFromSPD();
    //IsPileupFromSPDInMultBins() // method to try
    //printf("pile-up %d, %d, %2.2f, %2.2f, %2.2f, %2.2f\n",bPileup, (Int_t) fPileUpParamSPD[0], fPileUpParamSPD[1], fPileUpParamSPD[2], fPileUpParamSPD[3], fPileUpParamSPD[4]);
    if(bPileup) return kFALSE;
    
    AliDebug(1,"Pass Pile-Up event rejection");
  }
  
  if(fDoV0ANDEventSelection)
  {
    AliVVZERO* v0 = fInputEvent->GetVZEROData();

    Bool_t bV0AND = ((v0->GetV0ADecision()==1) && (v0->GetV0CDecision()==1));
    //bV0AND = fTriggerAnalysis->IsOfflineTriggerFired((AliESDEvent*)fInputEvent, AliTriggerAnalysis::kV0AND);
    //printf("V0AND event? %d\n",bV0AND);

    if(!bV0AND)
    {
      AliDebug(1,"Reject event by V0AND");
      return kFALSE;
    }
    
    AliDebug(1,"Pass V0AND event rejection");
  }

  //------------------------------------------------------
  // Check if there is a centrality value, PbPb analysis,
  // and if a centrality bin selection is requested
  //------------------------------------------------------
  
  //If we need a centrality bin, we select only those events in the corresponding bin.
  if(GetCentrality() && fCentralityBin[0]>=0 && fCentralityBin[1]>=0 && fCentralityOpt==100)
  {
    Int_t cen = GetEventCentrality();
    if(cen > fCentralityBin[1] || cen < fCentralityBin[0]) return kFALSE; //reject events out of bin.
    
    AliDebug(1,"Pass centrality rejection");
  }
  
  //---------------------------------------------------------------------------
  // In case of MC analysis, set the range of interest in the MC particles list
  // The particle selection is done inside the FillInputDetector() methods
  //---------------------------------------------------------------------------
  if(fAcceptOnlyHIJINGLabels) SetGeneratorMinMaxParticles();
  
  //printf("N min %d, N max %d\n",fNMCProducedMin,fNMCProducedMax);
  
  //-------------------------------------------------------
  // Get the main vertex BC, in case not available
  // it is calculated in FillCTS checking the BC of tracks
  //------------------------------------------------------
  fVertexBC = fInputEvent->GetPrimaryVertex()->GetBC();
  
  //-----------------------------------------------
  // Fill the arrays with cluster/tracks/cells data
  //-----------------------------------------------
  
  if(fFillCTS)
  {
    FillInputCTS();
    //Accept events with at least one track
    if(fTrackMult == 0 && fDoRejectNoTrackEvents) return kFALSE ;
    
    AliDebug(1,"Pass rejection of null track events");
  }
  
  if(fDoVertexBCEventSelection)
  {
    if(fVertexBC != 0 && fVertexBC != AliVTrack::kTOFBCNA) return kFALSE ;
    
    AliDebug(1,"Pass rejection of events with vertex at BC!=0");
  }
  
  if(fFillEMCALCells)
    FillInputEMCALCells();
  
  if(fFillPHOSCells)
    FillInputPHOSCells();
  
  if(fFillEMCAL || fFillDCAL)
    FillInputEMCAL();
  
  if(fFillPHOS)
    FillInputPHOS();
  
  FillInputVZERO();
  
  //one specified jet branch
  if(fFillInputNonStandardJetBranch)
    FillInputNonStandardJets();
  if(fFillInputBackgroundJetBranch)
    FillInputBackgroundJets();

  AliDebug(1,"Event accepted for analysis");

  return kTRUE ;
}

//__________________________________________________
Int_t AliCaloTrackReader::GetEventCentrality() const
{
  //Return current event centrality
  
  if(GetCentrality())
  {
    if     (fCentralityOpt==100) return (Int_t) GetCentrality()->GetCentralityPercentile(fCentralityClass); // 100 bins max
    else if(fCentralityOpt==10)  return GetCentrality()->GetCentralityClass10(fCentralityClass);// 10 bins max
    else if(fCentralityOpt==20)  return GetCentrality()->GetCentralityClass5(fCentralityClass); // 20 bins max
    else
    {
      AliInfo(Form("Unknown centrality option %d, use 10, 20 or 100\n",fCentralityOpt));
      return -1;
    }
  }
  else return -1;
  
}

//_____________________________________________________
Double_t AliCaloTrackReader::GetEventPlaneAngle() const
{
  //Return current event centrality
  
  if(GetEventPlane())
  {
    Float_t ep =  GetEventPlane()->GetEventplane(GetEventPlaneMethod(), GetInputEvent());
    
    if(GetEventPlaneMethod()=="Q" && (ep < 0 || ep > TMath::Pi()))
    {
      AliDebug(1,Form("Bad EP for <Q> method : %f\n",ep));
      return -1000;
    }
    else if(GetEventPlaneMethod().Contains("V0")  )
    {
      if((ep > TMath::Pi()/2 || ep < -TMath::Pi()/2))
      {
        AliDebug(1,Form("Bad EP for <%s> method : %f\n",GetEventPlaneMethod().Data(), ep));
        return -1000;
      }
      
      ep+=TMath::Pi()/2; // put same range as for <Q> method
      
    }
    
    AliDebug(3,Form("Event plane angle %f",ep));
    
//    if(fDebug > 0 )
//    {
//      if     (ep > TMath::Pi()) printf("AliCaloTrackReader::GetEventPlaneAngle() - Too large angle = %f\n",ep);
//      else if(ep < 0          ) printf("AliCaloTrackReader::GetEventPlaneAngle() - Negative angle = %f\n" ,ep);
//    }
    
    return ep;
  }
  else
  {
    return -1000;
  }
  
}

//__________________________________________________________
void AliCaloTrackReader::GetVertex(Double_t vertex[3]) const
{
  //Return vertex position to be used for single event analysis
  vertex[0]=fVertex[0][0];
  vertex[1]=fVertex[0][1];
  vertex[2]=fVertex[0][2];
}

//__________________________________________________________________________
void AliCaloTrackReader::GetVertex(Double_t vertex[3], Int_t evtIndex) const
{
  //Return vertex position for mixed event, recover the vertex in a particular event.
  
  vertex[0]=fVertex[evtIndex][0];  vertex[1]=fVertex[evtIndex][1];  vertex[2]=fVertex[evtIndex][2];
  
}

//________________________________________
void AliCaloTrackReader::FillVertexArray()
{
  //Fill data member with vertex
  //In case of Mixed event, multiple vertices
  
  //Delete previous vertex
  if(fVertex)
  {
    for (Int_t i = 0; i < fNMixedEvent; i++)
    {
      delete [] fVertex[i] ;
    }
    delete [] fVertex ;
  }
  
  fVertex = new Double_t*[fNMixedEvent] ;
  for (Int_t i = 0; i < fNMixedEvent; i++)
  {
    fVertex[i] = new Double_t[3] ;
    fVertex[i][0] = 0.0 ;
    fVertex[i][1] = 0.0 ;
    fVertex[i][2] = 0.0 ;
  }
  
  if (!fMixedEvent)
  { //Single event analysis
    if(fDataType!=kMC)
    {
      
      if(fInputEvent->GetPrimaryVertex())
      {
        fInputEvent->GetPrimaryVertex()->GetXYZ(fVertex[0]);
      }
      else
      {
        AliWarning("NULL primary vertex");
        fVertex[0][0]=0.;   fVertex[0][1]=0.;   fVertex[0][2]=0.;
      }//Primary vertex pointer do not exist
      
    } else
    {//MC read event
      fVertex[0][0]=0.;   fVertex[0][1]=0.;   fVertex[0][2]=0.;
    }
    
    AliDebug(1,Form("Single Event Vertex : %f,%f,%f\n",fVertex[0][0],fVertex[0][1],fVertex[0][2]));
    
  } else
  { // MultiEvent analysis
    for (Int_t iev = 0; iev < fNMixedEvent; iev++)
    {
      if (fMixedEvent->GetVertexOfEvent(iev))
        fMixedEvent->GetVertexOfEvent(iev)->GetXYZ(fVertex[iev]);
      else
         AliWarning("No vertex found");
      
      AliDebug(1,Form("Multi Event %d Vertex : %f,%f,%f",iev,fVertex[iev][0],fVertex[iev][1],fVertex[iev][2]));
    }
  }
  
}

//_____________________________________
void AliCaloTrackReader::FillInputCTS()
{
  //Return array with Central Tracking System (CTS) tracks
  
  AliDebug(1,"Begin");
  
  Double_t pTrack[3] = {0,0,0};
  
  Int_t nTracks = fInputEvent->GetNumberOfTracks() ;
  fTrackMult    = 0;
  Int_t nstatus = 0;
  Double_t bz   = GetInputEvent()->GetMagneticField();
  
  for(Int_t i = 0; i < 19; i++)
  {
    fTrackBCEvent   [i] = 0;
    fTrackBCEventCut[i] = 0;
  }
  
  Bool_t   bc0  = kFALSE;
  if(fRecalculateVertexBC) fVertexBC = AliVTrack::kTOFBCNA;
  
  for (Int_t itrack =  0; itrack <  nTracks; itrack++)
  {////////////// track loop
    AliVTrack * track = (AliVTrack*)fInputEvent->GetTrack(itrack) ; // retrieve track from esd
    
    if(fAcceptOnlyHIJINGLabels && !IsHIJINGLabel(track->GetLabel())) continue ;
    
    //Select tracks under certain conditions, TPCrefit, ITSrefit ... check the set bits
    ULong_t status = track->GetStatus();
    
    if (fTrackStatus && !((status & fTrackStatus) == fTrackStatus))
      continue ;
    
    nstatus++;
    
    // Select the tracks depending on cuts of AOD or ESD
    if(!SelectTrack(track, pTrack)) continue ;
    
    // TOF cuts
    Bool_t okTOF  = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
    Double_t tof  = -1000;
    Int_t trackBC = -1000 ;
    
    if(fAccessTrackTOF)
    {
      if(okTOF)
      {
        trackBC = track->GetTOFBunchCrossing(bz);
        SetTrackEventBC(trackBC+9);
        
        tof = track->GetTOFsignal()*1e-3;
        
        //After selecting tracks with small DCA, pointing to vertex, set vertex BC depeding on tracks BC
        if(fRecalculateVertexBC)
        {
          if     (trackBC != 0 && trackBC != AliVTrack::kTOFBCNA) fVertexBC = trackBC;
          else if(trackBC == 0)                                   bc0       = kTRUE;
        }
        
        //In any case, the time should to be larger than the fixed window ...
        if( fUseTrackTimeCut && (trackBC !=0 || tof < fTrackTimeCutMin  || tof > fTrackTimeCutMax) )
        {
          //printf("Remove track time %f and bc = %d\n",tof,trackBC);
          continue ;
        }
        //else printf("Accept track time %f and bc = %d\n",tof,trackBC);
      }
    }
    
    fMomentum.SetPxPyPzE(pTrack[0],pTrack[1],pTrack[2],0);
    
    // DCA cuts
    
    if(fUseTrackDCACut)
    {      
      Float_t dcaTPC =-999;
      //In case of AODs, TPC tracks cannot be propagated back to primary vertex,
      if( fDataType == kAOD ) dcaTPC = ((AliAODTrack*) track)->DCA();

      //normal way to get the dca, cut on dca_xy
      if(dcaTPC==-999)
      {
        Double_t dca[2]   = {1e6,1e6};
        Double_t covar[3] = {1e6,1e6,1e6};
        Bool_t okDCA = track->PropagateToDCA(fInputEvent->GetPrimaryVertex(),bz,100.,dca,covar);
        if( okDCA) okDCA = AcceptDCA(fMomentum.Pt(),dca[0]);
        if(!okDCA)
        {
          //printf("AliCaloTrackReader::FillInputCTS() - Reject track pt %2.2f, dca_xy %2.4f\n",fMomentum.Pt(),dca[0]);
          continue ;
        }
      }
    }// DCA cuts
    
    //Count the tracks in eta < 0.9
    if(TMath::Abs(track->Eta())< fTrackMultEtaCut) fTrackMult++;
    
    if(fCTSPtMin > fMomentum.Pt() || fCTSPtMax < fMomentum.Pt()) continue ;
    
    // Check effect of cuts on track BC
    if(fAccessTrackTOF && okTOF) SetTrackEventBCcut(trackBC+9);
    
    if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kCTS)) continue;
    
    AliDebug(2,Form("Selected tracks pt %3.2f, phi %3.2f, eta %3.2f",
                    fMomentum.Pt(),fMomentum.Phi()*TMath::RadToDeg(),fMomentum.Eta()));
    
    if (fMixedEvent)  track->SetID(itrack);
    
    
    fCTSTracks->Add(track);
    
  }// track loop
	
  if( fRecalculateVertexBC && (fVertexBC == 0 || fVertexBC == AliVTrack::kTOFBCNA))
  {
    if( bc0 ) fVertexBC = 0 ;
    else      fVertexBC = AliVTrack::kTOFBCNA ;
  }
  
  AliDebug(1,Form("AOD entries %d, input tracks %d, pass status %d, multipliticy %d", fCTSTracks->GetEntriesFast(), nTracks, nstatus, fTrackMult));//fCTSTracksNormalInputEntries);
  
}

//_______________________________________________________________________________
void AliCaloTrackReader::FillInputEMCALAlgorithm(AliVCluster * clus, Int_t iclus)
{
  //Fill the EMCAL data in the array, do it
  
  // Accept clusters with the proper label, TO DO, use the new more General methods!!!
  if(fAcceptOnlyHIJINGLabels && !IsHIJINGLabel( clus->GetLabel() )) return ;
  
  Int_t vindex = 0 ;
  if (fMixedEvent)
    vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
  
  
  clus->GetMomentum(fMomentum, fVertex[vindex]);
  
  //if( (fDebug > 2 && fMomentum.E() > 0.1) || fDebug > 10 )
  AliDebug(2,Form("Input cluster E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f",
                  fMomentum.E(),fMomentum.Pt(),fMomentum.Phi()*TMath::RadToDeg(),fMomentum.Eta()));

  if(fRecalculateClusters)
  {
    //Recalibrate the cluster energy
    if(GetCaloUtils()->IsRecalibrationOn())
    {
      Float_t energy = GetCaloUtils()->RecalibrateClusterEnergy(clus, GetEMCALCells());
      
      clus->SetE(energy);
      //printf("Recalibrated Energy %f\n",clus->E());
      
      GetCaloUtils()->RecalculateClusterShowerShapeParameters(GetEMCALCells(),clus);
      GetCaloUtils()->RecalculateClusterPID(clus);
      
    } // recalculate E
    
    //Recalculate distance to bad channels, if new list of bad channels provided
    GetCaloUtils()->RecalculateClusterDistanceToBadChannel(GetEMCALCells(),clus);
    
    //Recalculate cluster position
    if(GetCaloUtils()->IsRecalculationOfClusterPositionOn())
    {
      GetCaloUtils()->RecalculateClusterPosition(GetEMCALCells(),clus);
      //clus->GetPosition(pos);
      //printf("After  Corrections: e %f, x %f, y %f, z %f\n",clus->E(),pos[0],pos[1],pos[2]);
    }
    
    // Recalculate TOF
    if(GetCaloUtils()->GetEMCALRecoUtils()->IsTimeRecalibrationOn())
    {
      Double_t tof      = clus->GetTOF();
      Float_t  frac     =-1;
      Int_t    absIdMax = GetCaloUtils()->GetMaxEnergyCell(fEMCALCells, clus,frac);
      
      if(fDataType==AliCaloTrackReader::kESD)
      {
        tof = fEMCALCells->GetCellTime(absIdMax);
      }
      
      GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTime(absIdMax,fInputEvent->GetBunchCrossNumber(),tof);
      
      clus->SetTOF(tof);
      
    }// Time recalibration
  }
  
  //Reject clusters with bad channels, close to borders and exotic;
  Bool_t goodCluster = GetCaloUtils()->GetEMCALRecoUtils()->IsGoodCluster(clus,
                                                                          GetCaloUtils()->GetEMCALGeometry(),
                                                                          GetEMCALCells(),fInputEvent->GetBunchCrossNumber());
  
  if(!goodCluster)
  {
    //if( (fDebug > 2 && fMomentum.E() > 0.1) || fDebug > 10 )
    AliDebug(2,Form("Bad cluster E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f",
                    fMomentum.E(),fMomentum.Pt(),fMomentum.Phi()*TMath::RadToDeg(),fMomentum.Eta()));

    return;
  }
  
  //Mask all cells in collumns facing ALICE thick material if requested
  if(GetCaloUtils()->GetNMaskCellColumns())
  {
    Int_t absId   = -1;
    Int_t iSupMod = -1;
    Int_t iphi    = -1;
    Int_t ieta    = -1;
    Bool_t shared = kFALSE;
    GetCaloUtils()->GetEMCALRecoUtils()->GetMaxEnergyCell(GetCaloUtils()->GetEMCALGeometry(), GetEMCALCells(),clus,absId,iSupMod,ieta,iphi,shared);
    if(GetCaloUtils()->MaskFrameCluster(iSupMod, ieta)) return;
  }
  
  if(fSelectEmbeddedClusters)
  {
    if(clus->GetNLabels()==0 || clus->GetLabel() < 0) return;
    //else printf("Embedded cluster,  %d, n label %d label %d  \n",iclus,clus->GetNLabels(),clus->GetLabel());
  }
  
  //Float_t pos[3];
  //clus->GetPosition(pos);
  //printf("Before Corrections: e %f, x %f, y %f, z %f\n",clus->E(),pos[0],pos[1],pos[2]);
  
  //Correct non linearity or smear energy
  if(fCorrectELinearity && GetCaloUtils()->IsCorrectionOfClusterEnergyOn())
  {
    GetCaloUtils()->CorrectClusterEnergy(clus) ;
    
    //if( (fDebug > 5 && fMomentum.E() > 0.1) || fDebug > 10 )
    AliDebug(5,Form("Correct Non Lin: Old E %3.2f, New E %3.2f",
                    fMomentum.E(),clus->E()));

    // In case of MC analysis, to match resolution/calibration in real data
    // Not needed anymore, just leave for MC studies on systematics
    if( GetCaloUtils()->GetEMCALRecoUtils()->IsClusterEnergySmeared() )
    {
      Float_t rdmEnergy = GetCaloUtils()->GetEMCALRecoUtils()->SmearClusterEnergy(clus);
      
      //if( (fDebug > 5 && fMomentum.E() > 0.1) || fDebug > 10 )
      AliDebug(5,Form("Smear energy: Old E %3.2f, New E %3.2f",clus->E(),rdmEnergy));
    
      clus->SetE(rdmEnergy);
    }
  }
  
  Double_t tof = clus->GetTOF()*1e9;
  
  Int_t bc = TMath::Nint(tof/50) + 9;
  //printf("tof %2.2f, bc+5=%d\n",tof,bc);
  
  SetEMCalEventBC(bc);
  
  if(fEMCALPtMin > clus->E() || fEMCALPtMax < clus->E()) return ;
  
  clus->GetMomentum(fMomentum, fVertex[vindex]);
  
  SetEMCalEventBCcut(bc);
  
  if(!IsInTimeWindow(tof,clus->E()))
  {
    fNPileUpClusters++ ;
    if(fUseEMCALTimeCut) return ;
  }
  else
    fNNonPileUpClusters++;
  
  //if((fDebug > 2 && fMomentum.E() > 0.1) || fDebug > 10)
  AliDebug(2,Form("Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f",
                  fMomentum.E(),fMomentum.Pt(),fMomentum.Phi()*TMath::RadToDeg(),fMomentum.Eta()));
  
  if (fMixedEvent)
    clus->SetID(iclus) ;
  
  // Select cluster fiducial region
  Bool_t bEMCAL = kFALSE;
  Bool_t bDCAL  = kFALSE;
  if(fCheckFidCut)
  {
    if(fFillEMCAL && fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kEMCAL)) bEMCAL = kTRUE ;
    if(fFillDCAL  && fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kDCAL )) bDCAL  = kTRUE ;
  }
  else
  {
    bEMCAL = kTRUE;
  }

  // Smear the SS to try to match data and simulations,
  // do it only for simulations.
  if( fSmearShowerShape  && clus->GetNCells() > 2)
  {
    AliDebug(2,Form("Smear shower shape - Original: %2.4f\n", clus->GetM02()));
    clus->SetM02( clus->GetM02() + fRandom.Landau(0, fSmearShowerShapeWidth) );
    //clus->SetM02( fRandom.Landau(clus->GetM02(), fSmearShowerShapeWidth) );
    AliDebug(2,Form("Width %2.4f         Smeared : %2.4f\n", fSmearShowerShapeWidth,clus->GetM02()));
  }
  
  // Fill the corresponding array. Usually just filling EMCal array with upper or lower clusters is enough, but maybe we want to do EMCal-DCal correlations.
  if     (bEMCAL) fEMCALClusters->Add(clus);
  else if(bDCAL ) fDCALClusters ->Add(clus);
  
}

//_______________________________________
void AliCaloTrackReader::FillInputEMCAL()
{
  //Return array with EMCAL clusters in aod format
  
  AliDebug(1,"Begin");
  
  // First recalibrate cells, time or energy
  //  if(GetCaloUtils()->IsRecalibrationOn())
  //    GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCells(GetCaloUtils()->GetEMCALGeometry(),
  //                                                          GetEMCALCells(),
  //                                                          fInputEvent->GetBunchCrossNumber());
  
  fNPileUpClusters    = 0; // Init counter
  fNNonPileUpClusters = 0; // Init counter
  for(Int_t i = 0; i < 19; i++)
  {
    fEMCalBCEvent   [i] = 0;
    fEMCalBCEventCut[i] = 0;
  }
  
  //Loop to select clusters in fiducial cut and fill container with aodClusters
  if(fEMCALClustersListName=="")
  {
    Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
    for (Int_t iclus =  0; iclus <  nclusters; iclus++)
    {
      AliVCluster * clus = 0;
      if ( (clus = fInputEvent->GetCaloCluster(iclus)) )
      {
        if (clus->IsEMCAL())
        {
          FillInputEMCALAlgorithm(clus, iclus);
        }//EMCAL cluster
      }// cluster exists
    }// cluster loop
    
    //Recalculate track matching
    GetCaloUtils()->RecalculateClusterTrackMatching(fInputEvent);
    
  }//Get the clusters from the input event
  else
  {
    TClonesArray * clusterList = 0x0;
    
    if      (fInputEvent->FindListObject(fEMCALClustersListName))
    {
      clusterList = dynamic_cast<TClonesArray*> (fInputEvent->FindListObject(fEMCALClustersListName));
    }
    else if(fOutputEvent)
    {
      clusterList = dynamic_cast<TClonesArray*> (fOutputEvent->FindListObject(fEMCALClustersListName));
    }
    
    if(!clusterList)
    {
      AliWarning(Form("Wrong name of list with clusters?  <%s>",fEMCALClustersListName.Data()));
      return;
    }
    
    Int_t nclusters = clusterList->GetEntriesFast();
    for (Int_t iclus =  0; iclus <  nclusters; iclus++)
    {
      AliVCluster * clus = dynamic_cast<AliVCluster*> (clusterList->At(iclus));
      //printf("E %f\n",clus->E());
      if (clus) FillInputEMCALAlgorithm(clus, iclus);
      else      AliWarning("Null cluster in list!");
    }// cluster loop
    
    // Recalculate the pile-up time, in case long time clusters removed during clusterization
    //printf("Input event INIT : Pile-up clusters %d, NO pile-up %d\n",fNPileUpClusters,fNNonPileUpClusters);
    
    fNPileUpClusters    = 0; // Init counter
    fNNonPileUpClusters = 0; // Init counter
    for(Int_t i = 0; i < 19; i++)
    {
      fEMCalBCEvent   [i] = 0;
      fEMCalBCEventCut[i] = 0;
    }
    
    for (Int_t iclus =  0; iclus < fInputEvent->GetNumberOfCaloClusters(); iclus++)
    {
      AliVCluster * clus = 0;
      
      if ( (clus = fInputEvent->GetCaloCluster(iclus)) )
      {
        if (clus->IsEMCAL())
        {
          
          Float_t  frac     =-1;
          Int_t    absIdMax = GetCaloUtils()->GetMaxEnergyCell(fEMCALCells, clus,frac);
          Double_t tof = clus->GetTOF();
          GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTime(absIdMax,fInputEvent->GetBunchCrossNumber(),tof);
          tof*=1e9;
          
          //printf("Input event cluster : AbsIdMax %d, E %2.2f, time %2.2f \n", absIdMax,clus->E(),tof);
          
          //Reject clusters with bad channels, close to borders and exotic;
          if(!GetCaloUtils()->GetEMCALRecoUtils()->IsGoodCluster(clus,GetCaloUtils()->GetEMCALGeometry(),GetEMCALCells(),fInputEvent->GetBunchCrossNumber()))  continue;
          
          Int_t bc = TMath::Nint(tof/50) + 9;
          SetEMCalEventBC(bc);
          
          if(fEMCALPtMin > clus->E() || fEMCALPtMax < clus->E()) continue ;
          
          clus->GetMomentum(fMomentum, fVertex[0]);
          
          if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kEMCAL)) return ;
          
          SetEMCalEventBCcut(bc);
          
          if(!IsInTimeWindow(tof,clus->E()))
            fNPileUpClusters++ ;
          else
            fNNonPileUpClusters++;
          
        }
      }
    }
    
    //printf("Input event : Pile-up clusters %d, NO pile-up %d\n",fNPileUpClusters,fNNonPileUpClusters);
    
    // Recalculate track matching, not necessary if already done in the reclusterization task.
    // in case it was not done ...
    GetCaloUtils()->RecalculateClusterTrackMatching(fInputEvent,clusterList);
    
  }
  
  AliDebug(1,Form("AOD entries %d, n pile-up clusters %d, n non pile-up %d", fEMCALClusters->GetEntriesFast(),fNPileUpClusters,fNNonPileUpClusters));
  
}

//______________________________________
void AliCaloTrackReader::FillInputPHOS()
{
  //Return array with PHOS clusters in aod format
  
  AliDebug(1,"Begin");
  
  //Loop to select clusters in fiducial cut and fill container with aodClusters
  Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
  for (Int_t iclus = 0; iclus < nclusters; iclus++)
  {
    AliVCluster * clus = 0;
    if ( (clus = fInputEvent->GetCaloCluster(iclus)) )
    {
      if (clus->IsPHOS())
      {
        if(fAcceptOnlyHIJINGLabels && !IsHIJINGLabel(clus->GetLabel())) continue ;
        
        //Check if the cluster contains any bad channel and if close to calorimeter borders
        Int_t vindex = 0 ;
        if (fMixedEvent)
          vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
        if( GetCaloUtils()->ClusterContainsBadChannel(kPHOS,clus->GetCellsAbsId(), clus->GetNCells()))
          continue;
        if(!GetCaloUtils()->CheckCellFiducialRegion(clus, fInputEvent->GetPHOSCells()))
          continue;
        
        if(fRecalculateClusters)
        {
          //Recalibrate the cluster energy
          if(GetCaloUtils()->IsRecalibrationOn())
          {
            Float_t energy = GetCaloUtils()->RecalibrateClusterEnergy(clus, (AliAODCaloCells*)GetPHOSCells());
            clus->SetE(energy);
          }
        }
        
        clus->GetMomentum(fMomentum, fVertex[vindex]);
        
        if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kPHOS)) continue;
        
        if(fPHOSPtMin > fMomentum.E() || fPHOSPtMax < fMomentum.E())         continue;
        
        //if(fDebug > 2 && fMomentum.E() > 0.1)
        AliDebug(2,Form("Selected clusters E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f",
                        fMomentum.E(),fMomentum.Pt(),fMomentum.Phi()*TMath::RadToDeg(),fMomentum.Eta()));
        
        if (fMixedEvent)
        {
          clus->SetID(iclus) ;
        }
        
        fPHOSClusters->Add(clus);
        
      }//PHOS cluster
    }//cluster exists
  }//esd cluster loop
  
 AliDebug(1,Form("AOD entries %d",fPHOSClusters->GetEntriesFast()));
  
}

//____________________________________________
void AliCaloTrackReader::FillInputEMCALCells()
{
  //Return array with EMCAL cells in aod format
  
  fEMCALCells = fInputEvent->GetEMCALCells();
  
}

//___________________________________________
void AliCaloTrackReader::FillInputPHOSCells()
{
  //Return array with PHOS cells in aod format
  
  fPHOSCells = fInputEvent->GetPHOSCells();
  
}

//_______________________________________
void AliCaloTrackReader::FillInputVZERO()
{
  //Fill VZERO information in data member, add all the channels information.
  AliVVZERO* v0 = fInputEvent->GetVZEROData();
  //printf("Init V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
  
  if (v0)
  {
    AliESDVZERO* esdV0 = dynamic_cast<AliESDVZERO*> (v0);
    for (Int_t i = 0; i < 32; i++)
    {
      if(esdV0)
      {//Only available in ESDs
        fV0ADC[0] += (Int_t)esdV0->GetAdcV0C(i);
        fV0ADC[1] += (Int_t)esdV0->GetAdcV0A(i);
      }
      
      fV0Mul[0] += (Int_t)v0->GetMultiplicityV0C(i);
      fV0Mul[1] += (Int_t)v0->GetMultiplicityV0A(i);
    }
    
    AliDebug(1,Form("ADC (%d,%d), Multiplicity (%d,%d)",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]));
  }
  else
  {
    AliDebug(1,"Cannot retrieve V0 ESD! Run w/ null V0 charges");
  }
}

//_________________________________________________
void AliCaloTrackReader::FillInputNonStandardJets()
{
  //
  //fill array with non standard jets
  //
  // Adam T. Matyja
  
  AliDebug(2,"Begin");
  
  //
  //check if branch name is given
  if(!fInputNonStandardJetBranchName.Length())
  {
    fInputEvent->Print();
    AliFatal("No non-standard jet branch name specified. Specify among existing ones.");
  }
  
  fNonStandardJets = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(fInputNonStandardJetBranchName.Data()));
  
  if(!fNonStandardJets)
  {
    //check if jet branch exist; exit if not
    fInputEvent->Print();

    AliFatal(Form("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fInputNonStandardJetBranchName.Data()));
  }
  else
  {
    AliDebug(1,Form("AOD input jets %d", fNonStandardJets->GetEntriesFast()));
  }
  
}

//_________________________________________________
void AliCaloTrackReader::FillInputBackgroundJets()
{
  //
  //fill array with Background jets
  //
  // Adam T. Matyja
  
  AliDebug(1,"Begin");
  //
  //check if branch name is given
  if(!fInputBackgroundJetBranchName.Length())
  {
    fInputEvent->Print();
    
    AliFatal("No background jet branch name specified. Specify among existing ones.");
  }
  
  fBackgroundJets = (AliAODJetEventBackground*)(fInputEvent->FindListObject(fInputBackgroundJetBranchName.Data()));
  
  if(!fBackgroundJets)
  {
    //check if jet branch exist; exit if not
    fInputEvent->Print();

    AliFatal(Form("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fInputBackgroundJetBranchName.Data()));
  }
  else
  {
    AliDebug(1,"FillInputBackgroundJets");
    fBackgroundJets->Print("");
  }
  
}

//________________________________________________________________________________
TArrayI AliCaloTrackReader::GetTriggerPatches(Int_t tmin, Int_t tmax )
{
  // Select the patches that triggered
  // Depend on L0 or L1
	
  // some variables
  Int_t  trigtimes[30], globCol, globRow,ntimes, i;
  Int_t  absId  = -1; //[100];
  Int_t  nPatch = 0;
	
  TArrayI patches(0);
  
  // get object pointer
  AliVCaloTrigger *caloTrigger = GetInputEvent()->GetCaloTrigger( "EMCAL" );

  // Recover the threshold of the event that triggered, only possible for L1
  if(!fTriggerL1EventThresholdFix)
  {
    if(fBitEGA==6)
    {
      if     (IsEventEMCALL1Gamma1()) fTriggerL1EventThreshold =  0.07874*caloTrigger->GetL1Threshold(1);
      else if(IsEventEMCALL1Gamma2()) fTriggerL1EventThreshold =  0.07874*caloTrigger->GetL1Threshold(3);
      else if(IsEventEMCALL1Jet1  ()) fTriggerL1EventThreshold =  0.07874*caloTrigger->GetL1Threshold(0);
      else if(IsEventEMCALL1Jet2  ()) fTriggerL1EventThreshold =  0.07874*caloTrigger->GetL1Threshold(2);
      
//      printf("L1 trigger Threshold Jet1 %f, Gamma1 %f, Jet2 %f, Gamma2 %f\n",
//             0.07874*caloTrigger->GetL1Threshold(0),
//             0.07874*caloTrigger->GetL1Threshold(1),
//             0.07874*caloTrigger->GetL1Threshold(2),
//             0.07874*caloTrigger->GetL1Threshold(3));
    }
    else
    {
      // Old AOD data format, in such case, order of thresholds different!!!
      if     (IsEventEMCALL1Gamma1()) fTriggerL1EventThreshold =  0.07874*caloTrigger->GetL1Threshold(0);
      else if(IsEventEMCALL1Gamma2()) fTriggerL1EventThreshold =  0.07874*caloTrigger->GetL1Threshold(2);
      else if(IsEventEMCALL1Jet1  ()) fTriggerL1EventThreshold =  0.07874*caloTrigger->GetL1Threshold(1);
      else if(IsEventEMCALL1Jet2  ()) fTriggerL1EventThreshold =  0.07874*caloTrigger->GetL1Threshold(3);
      
//      printf("L1 trigger Threshold Jet1 %f, Gamma1 %f, Jet2 %f, Gamma2 %f\n",
//             0.07874*caloTrigger->GetL1Threshold(1),
//             0.07874*caloTrigger->GetL1Threshold(0),
//             0.07874*caloTrigger->GetL1Threshold(3),
//             0.07874*caloTrigger->GetL1Threshold(2));
    }
  }

  //printf("CaloTrigger Entries %d\n",caloTrigger->GetEntries() );
  
  // class is not empty
  if( caloTrigger->GetEntries() > 0 )
  {
    // must reset before usage, or the class will fail
    caloTrigger->Reset();

    // go throuth the trigger channels
    while( caloTrigger->Next() )
    {
      // get position in global 2x2 tower coordinates
      caloTrigger->GetPosition( globCol, globRow );

      //L0
      if(IsEventEMCALL0())
      {
        // get dimension of time arrays
        caloTrigger->GetNL0Times( ntimes );
        
        // no L0s in this channel
        // presence of the channel in the iterator still does not guarantee that L0 was produced!!
        if( ntimes < 1 )
          continue;
        
        // get timing array
        caloTrigger->GetL0Times( trigtimes );
        //printf("Get L0 patch : n times %d - trigger time window %d - %d\n",ntimes, tmin,tmax);
        
        // go through the array
        for( i = 0; i < ntimes; i++ )
        {
          // check if in cut - 8,9 shall be accepted in 2011
          if( trigtimes[i] >= tmin && trigtimes[i] <= tmax )
          {
            //printf("Accepted trigger time %d \n",trigtimes[i]);
            //if(nTrig > 99) continue;
            GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(globCol,globRow, absId);
            //printf("pass the time cut globCol %d, globRow %d absId %d\n",globCol,globRow, absId);
            patches.Set(nPatch+1);
            patches.AddAt(absId,nPatch++);
          }
        } // trigger time array
      }//L0
      else if(IsEventEMCALL1()) // L1
      {
        Int_t bit = 0;
        caloTrigger->GetTriggerBits(bit);
        
        Int_t sum = 0;
        caloTrigger->GetL1TimeSum(sum);
        //fBitEGA-=2;
        Bool_t isEGA1 = ((bit >>  fBitEGA   ) & 0x1) && IsEventEMCALL1Gamma1() ;
        Bool_t isEGA2 = ((bit >> (fBitEGA+1)) & 0x1) && IsEventEMCALL1Gamma2() ;
        Bool_t isEJE1 = ((bit >>  fBitEJE   ) & 0x1) && IsEventEMCALL1Jet1  () ;
        Bool_t isEJE2 = ((bit >> (fBitEJE+1)) & 0x1) && IsEventEMCALL1Jet2  () ;
        
        //if((bit>> fBitEGA   )&0x1) printf("Trig Bit %d - bit %d - EG1 %d - EG2 %d\n",fBitEGA  ,bit,IsEventEMCALL1Gamma1(),IsEventEMCALL1Gamma2());
        //if((bit>>(fBitEGA+1))&0x1) printf("Trig Bit %d - bit %d - EG1 %d - EG2 %d\n",fBitEGA+1,bit,IsEventEMCALL1Gamma1(),IsEventEMCALL1Gamma2());
        
        if(!isEGA1 && !isEJE1 && !isEGA2 && !isEJE2) continue;
        
        Int_t patchsize = -1;
        if      (isEGA1 || isEGA2) patchsize =  2;
        else if (isEJE1 || isEJE2) patchsize = 16;
        
        //printf("**** Get L1 Patch: Bit %x, sum %d, patchsize %d, EGA1 %d, EGA2 %d, EJE1 %d, EJE2 %d, EGA bit %d, EJE bit %d, Trigger Gamma %d, Trigger Jet %d\n",
        //       bit,sum,patchsize,isEGA1,isEGA2,isEJE1,isEJE2,fBitEGA,fBitEJE,IsEventEMCALL1Gamma(),IsEventEMCALL1Jet());

        
        // add 2x2 (EGA) or 16x16 (EJE) patches
        for(Int_t irow=0; irow < patchsize; irow++)
        {
          for(Int_t icol=0; icol < patchsize; icol++)
          {
            GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(globCol+icol,globRow+irow, absId);
            //printf("pass the time cut globCol %d, globRow %d absId %d\n",globCol,globRow, absId);
            patches.Set(nPatch+1);
            patches.AddAt(absId,nPatch++);
          }
        }
        
      } // L1
      
    } // trigger iterator
  } // go through triggers
  
  if(patches.GetSize()<=0) AliInfo(Form("No patch found! for triggers: %s and selected <%s>",
                                        GetFiredTriggerClasses().Data(),fFiredTriggerClassName.Data()));
  //else                     printf(">>>>> N patches %d, test %d,first %d, last %d\n",patches.GetSize(), nPatch, patches.At(0), patches.At(patches.GetSize()-1));
                 
  return patches;
}

//______________________________________________________________________
void  AliCaloTrackReader::MatchTriggerCluster(TArrayI patches)
{
  // Finds the cluster that triggered
  
  // Init info from previous event
  fTriggerClusterIndex = -1;
  fTriggerClusterId    = -1;
  fTriggerClusterBC    = -10000;
  fIsExoticEvent       = kFALSE;
  fIsBadCellEvent      = kFALSE;
  fIsBadMaxCellEvent   = kFALSE;
  
  fIsTriggerMatch           = kFALSE;
  fIsTriggerMatchOpenCut[0] = kFALSE;
  fIsTriggerMatchOpenCut[1] = kFALSE;
  fIsTriggerMatchOpenCut[2] = kFALSE;
  
  // Do only analysis for triggered events
  if(!IsEventEMCALL1() && !IsEventEMCALL0())
  {
    fTriggerClusterBC = 0;
    return;
  }
  
  //printf("***** Try to match trigger to cluster %d **** L0 %d, L1 %d\n",fTriggerPatchClusterMatch,IsEventEMCALL0(),IsEventEMCALL1());
  
  //Recover the list of clusters
  TClonesArray * clusterList = 0;
  if      (fInputEvent->FindListObject(fEMCALClustersListName))
  {
    clusterList = dynamic_cast<TClonesArray*> (fInputEvent->FindListObject(fEMCALClustersListName));
  }
  else if(fOutputEvent)
  {
    clusterList = dynamic_cast<TClonesArray*> (fOutputEvent->FindListObject(fEMCALClustersListName));
  }
  
  // Get number of clusters and of trigger patches
  Int_t   nclusters   = fInputEvent->GetNumberOfCaloClusters();
  if(clusterList)
    nclusters    = clusterList->GetEntriesFast();
  
  Int_t   nPatch      = patches.GetSize();
  Float_t exoDiffTime = GetCaloUtils()->GetEMCALRecoUtils()->GetExoticCellDiffTimeCut();
  
  //Init some variables used in the cluster loop
  Float_t tofPatchMax = 100000;
  Float_t ePatchMax   =-1;
  
  Float_t tofMax      = 100000;
  Float_t eMax        =-1;
  
  Int_t   clusMax     =-1;
  Int_t   idclusMax   =-1;
  Bool_t  badClMax    = kFALSE;
  Bool_t  badCeMax    = kFALSE;
  Bool_t  exoMax      = kFALSE;
//  Int_t   absIdMaxTrig= -1;
  Int_t   absIdMaxMax = -1;
  
  Int_t   nOfHighECl  = 0 ;
  
  Float_t triggerThreshold = fTriggerL1EventThreshold;
  if(IsEventEMCALL0()) triggerThreshold = fTriggerL0EventThreshold;
  //printf("Threshold %f\n",triggerThreshold);
  Float_t minE = triggerThreshold / 2.;

  // This method is not really suitable for JET trigger
  // but in case, reduce the energy cut since we do not trigger on high energy particle
  if(IsEventEMCALL1Jet() || minE < 1) minE = 1;

  //printf("Min trigger Energy threshold %f\n",minE);
  
  // Loop on the clusters, check if there is any that falls into one of the patches
  for (Int_t iclus =  0; iclus <  nclusters; iclus++)
  {
    AliVCluster * clus = 0;
    if(clusterList) clus = (AliVCluster*) clusterList->At(iclus);
    else            clus = fInputEvent->GetCaloCluster(iclus);
    
    if ( !clus )            continue ;
    
    if ( !clus->IsEMCAL() ) continue ;
    
    //Skip clusters with too low energy to be triggering
    if ( clus->E() < minE ) continue ;
    
    Float_t  frac       = -1;
    Int_t    absIdMax   = GetCaloUtils()->GetMaxEnergyCell(fInputEvent->GetEMCALCells(), clus,frac);
    
    Bool_t   badCluster = GetCaloUtils()->GetEMCALRecoUtils()->ClusterContainsBadChannel(GetCaloUtils()->GetEMCALGeometry(),
                                                                                         clus->GetCellsAbsId(),clus->GetNCells());
    UShort_t cellMax[]  = {(UShort_t) absIdMax};
    Bool_t   badCell    = GetCaloUtils()->GetEMCALRecoUtils()->ClusterContainsBadChannel(GetCaloUtils()->GetEMCALGeometry(),cellMax,1);
    
    // if cell is bad, it can happen that time calibration is not available,
    // when calculating if it is exotic, this can make it to be exotic by default
    // open it temporarily for this cluster
    if(badCell)
      GetCaloUtils()->GetEMCALRecoUtils()->SetExoticCellDiffTimeCut(10000000);
    
    Bool_t   exotic     = GetCaloUtils()->GetEMCALRecoUtils()->IsExoticCluster(clus, fInputEvent->GetEMCALCells());
    
    // Set back the time cut on exotics
    if(badCell)
      GetCaloUtils()->GetEMCALRecoUtils()->SetExoticCellDiffTimeCut(exoDiffTime);
    
    // Energy threshold for exotic Ecross typically at 4 GeV,
    // for lower energy, check that there are more than 1 cell in the cluster
    if(!exotic && clus->GetNCells() < 2) exotic = kTRUE;
    
    Float_t  energy     = clus->E();
    Int_t    idclus     = clus->GetID();
    
    Double_t tof        = clus->GetTOF();
    if(GetCaloUtils()->GetEMCALRecoUtils()->IsTimeRecalibrationOn() && fTriggerClusterTimeRecal)
      GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTime(absIdMax,fInputEvent->GetBunchCrossNumber(),tof);
    tof *=1.e9;
    
    //printf("cluster %d, ID %d, E %2.2f, tof %2.2f, AbsId max %d, exotic %d, bad Cluster %d, bad Cell %d\n",
    //       iclus,idclus, energy,tof,absIdMax, exotic, badCluster,badCell);
    
    // Find the highest energy cluster, avobe trigger threshold
    // in the event in case no match to trigger is found
    if( energy > eMax )
    {
      tofMax       = tof;
      eMax         = energy;
      badClMax     = badCluster;
      badCeMax     = badCell;
      exoMax       = exotic;
      clusMax      = iclus;
      idclusMax    = idclus;
      absIdMaxMax  = absIdMax;
    }
    
    // count the good clusters in the event avobe the trigger threshold
    // to check the exotic events
    if(!badCluster && !exotic)
      nOfHighECl++;
    
    // Find match to trigger
    if(fTriggerPatchClusterMatch && nPatch>0)
    {
      for(Int_t iabsId =0; iabsId < nPatch; iabsId++)
      {
        Int_t absIDCell[4];
        GetCaloUtils()->GetEMCALGeometry()->GetCellIndexFromFastORIndex(patches.At(iabsId), absIDCell);
        //if(tof > 75 ) printf("E %2.2f TOF %2.2f Trigger patch %d, cells : %d, %d, %d, %d\n",
        //                     clus->E(),tof,patches.At(iabsId), absIDCell[0],absIDCell[1],absIDCell[2],absIDCell[3]);
        
        for(Int_t ipatch = 0; ipatch < 4; ipatch++)
        {
          if(absIdMax == absIDCell[ipatch])
          {
            //printf("*** Patches : absId %d, E %2.1f, tof %f \n",absIdMax,clus->E(), tof);
            if(energy > ePatchMax)
            {
              tofPatchMax          = tof;
              ePatchMax            = energy;
              fIsBadCellEvent      = badCluster;
              fIsBadMaxCellEvent   = badCell;
              fIsExoticEvent       = exotic;
              fTriggerClusterIndex = iclus;
              fTriggerClusterId    = idclus;
              fIsTriggerMatch      = kTRUE;
//              absIdMaxTrig         = absIdMax;
            }
          }
        }// cell patch loop
      }// trigger patch loop
    } // Do trigger patch matching
    
  }// Cluster loop
  
  // If there was no match, assign as trigger
  // the highest energy cluster in the event
  if(!fIsTriggerMatch)
  {
    tofPatchMax          = tofMax;
    ePatchMax            = eMax;
    fIsBadCellEvent      = badClMax;
    fIsBadMaxCellEvent   = badCeMax;
    fIsExoticEvent       = exoMax;
    fTriggerClusterIndex = clusMax;
    fTriggerClusterId    = idclusMax;
  }
  
  Double_t tofPatchMaxUS = TMath::Abs(tofPatchMax);
  
  if     (tofPatchMaxUS < 28 ) fTriggerClusterBC = 0 ;
  else if(tofPatchMaxUS < 75 ) fTriggerClusterBC = 1 ;
  else if(tofPatchMaxUS < 125) fTriggerClusterBC = 2 ;
  else if(tofPatchMaxUS < 175) fTriggerClusterBC = 3 ;
  else if(tofPatchMaxUS < 225) fTriggerClusterBC = 4 ;
  else if(tofPatchMaxUS < 275) fTriggerClusterBC = 5 ;
  else
  {
    //printf("AliCaloTrackReader::MatchTriggerCluster() - Large BC - tof %2.3f - Index %d\n",tofPatchMaxUS,fTriggerClusterIndex);
    if(fTriggerClusterIndex >= 0) fTriggerClusterBC = 6 ;
    else
    {
      fTriggerClusterIndex = -2;
      fTriggerClusterId    = -2;
    }
  }
  
  if(tofPatchMax < 0) fTriggerClusterBC*=-1;
  
  
  //  printf("AliCaloTrackReader::MatchTriggerCluster(TArrayI patches) - Trigger cluster: index %d, ID %d, E = %2.2f, tof = %2.2f (BC = %d), bad cluster? %d, bad cell? %d, exotic? %d, patch match? %d, n High E cluster %d, absId Max %d\n",
  //         fTriggerClusterIndex, fTriggerClusterId,ePatchMax, tofPatchMax,
  //         fTriggerClusterBC, fIsBadCellEvent,fIsBadMaxCellEvent,fIsExoticEvent, fIsTriggerMatch, nOfHighECl,absIdMaxMax);
  //
  //  if(!fIsTriggerMatch) printf("\t highest energy cluster:  index %d, ID %d, E = %2.2f, tof = %2.2f, bad cluster? %d, bad cell? %d, exotic? %d\n",
  //                              clusMax, idclusMax, eMax,tofMax, badClMax, badCeMax,exoMax);
  
  //Redo matching but open cuts
  if(!fIsTriggerMatch && fTriggerClusterId >= 0)
  {
    // Open time patch time
    TArrayI patchOpen = GetTriggerPatches(7,10);
    
    
    Int_t patchAbsIdOpenTime = -1;
    for(Int_t iabsId =0; iabsId < patchOpen.GetSize(); iabsId++)
    {
      Int_t absIDCell[4];
      patchAbsIdOpenTime = patchOpen.At(iabsId);
      GetCaloUtils()->GetEMCALGeometry()->GetCellIndexFromFastORIndex(patchAbsIdOpenTime, absIDCell);
      //if(tof > 75 ) printf("E %2.2f TOF %2.2f Trigger patch %d, cells : %d, %d, %d, %d\n",
      //                     clus->E(),tof,patches.At(iabsId), absIDCell[0],absIDCell[1],absIDCell[2],absIDCell[3]);
      
      for(Int_t ipatch = 0; ipatch < 4; ipatch++)
      {
        if(absIdMaxMax == absIDCell[ipatch])
        {
          fIsTriggerMatchOpenCut[0] = kTRUE;
          break;
        }
      }// cell patch loop
    }// trigger patch loop
    
    // Check neighbour patches
    Int_t patchAbsId = -1;
    Int_t globalCol  = -1;
    Int_t globalRow  = -1;
    GetCaloUtils()->GetEMCALGeometry()->GetFastORIndexFromCellIndex(absIdMaxMax, patchAbsId);
    GetCaloUtils()->GetEMCALGeometry()->GetPositionInEMCALFromAbsFastORIndex(patchAbsId,globalCol,globalRow);
    
    // Check patches with strict time cut
    Int_t patchAbsIdNeigh = -1;
    for(Int_t icol = globalCol-1; icol <= globalCol+1; icol++)
    {
      if(icol < 0 || icol > 47) continue;
      
      for(Int_t irow = globalRow; irow <= globalRow+1; irow++)
      {
        if(irow < 0 || irow > 63) continue;
        
        GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(icol, irow, patchAbsIdNeigh);
        
        if ( patchAbsIdNeigh < 0 ) continue;
        
        for(Int_t iabsId =0; iabsId < patches.GetSize(); iabsId++)
        {
          if(patchAbsIdNeigh == patches.At(iabsId))
          {
            fIsTriggerMatchOpenCut[1] = kTRUE;
            break;
          }
        }// trigger patch loop
        
      }// row
    }// col
    
    // Check patches with open time cut
    Int_t patchAbsIdNeighOpenTime = -1;
    for(Int_t icol = globalCol-1; icol <= globalCol+1; icol++)
    {
      if(icol < 0 || icol > 47) continue;
      
      for(Int_t irow = globalRow; irow <= globalRow+1; irow++)
      {
        if(irow < 0 || irow > 63) continue;
        
        GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(icol, irow, patchAbsIdNeighOpenTime);
        
        if ( patchAbsIdNeighOpenTime < 0 ) continue;
        
        for(Int_t iabsId =0; iabsId < patchOpen.GetSize(); iabsId++)
        {
          if(patchAbsIdNeighOpenTime == patchOpen.At(iabsId))
          {
            fIsTriggerMatchOpenCut[2] = kTRUE;
            break;
          }
        }// trigger patch loop
        
      }// row
    }// col
    
    //    printf("No match, new match: Open time %d-%d, open Neigh %d-%d, both open %d-%d\n",fIsTriggerMatchOpenCut[0],patchAbsIdOpenTime,
    //           fIsTriggerMatchOpenCut[1],patchAbsIdNeigh,
    //           fIsTriggerMatchOpenCut[2],patchAbsIdNeighOpenTime);
    
    patchOpen.Reset();
    
  }// No trigger match found
  //printf("Trigger BC %d, Id %d, Index %d\n",fTriggerClusterBC,fTriggerClusterId,fTriggerClusterIndex);
  
}

//________________________________________________________
void AliCaloTrackReader::Print(const Option_t * opt) const
{
  
  //Print some relevant parameters set for the analysis
  if(! opt)
    return;
  
  printf("***** Print: %s %s ******\n",    GetName(), GetTitle() ) ;
  printf("Task name      : %s\n",          fTaskName.Data()) ;
  printf("Data type      : %d\n",          fDataType) ;
  printf("CTS Min pT     : %2.1f GeV/c\n", fCTSPtMin) ;
  printf("EMCAL Min pT   : %2.1f GeV/c\n", fEMCALPtMin) ;
  printf("PHOS Min pT    : %2.1f GeV/c\n", fPHOSPtMin) ;
  printf("CTS Max pT     : %2.1f GeV/c\n", fCTSPtMax) ;
  printf("EMCAL Max pT   : %2.1f GeV/c\n", fEMCALPtMax) ;
  printf("PHOS Max pT    : %2.1f GeV/c\n", fPHOSPtMax) ;
  printf("EMCAL Time Cut: %3.1f < TOF  < %3.1f\n", fEMCALTimeCutMin, fEMCALTimeCutMax);
  printf("Use CTS         =     %d\n",     fFillCTS) ;
  printf("Use EMCAL       =     %d\n",     fFillEMCAL) ;
  printf("Use DCAL        =     %d\n",     fFillDCAL)  ;
  printf("Use PHOS        =     %d\n",     fFillPHOS) ;
  printf("Use EMCAL Cells =     %d\n",     fFillEMCALCells) ;
  printf("Use PHOS  Cells =     %d\n",     fFillPHOSCells) ;
  printf("Track status    =     %d\n", (Int_t) fTrackStatus) ;
  //printf("AODs Track filter mask  =  %d or hybrid %d (if filter bit comp %d), select : SPD hit %d, primary %d\n",
  //       (Int_t) fTrackFilterMask, fSelectHybridTracks, (Int_t) fTrackFilterMaskComplementary, fSelectSPDHitTracks,fSelectPrimaryTracks) ;
  printf("Track Mult Eta Cut =  %d\n", (Int_t) fTrackMultEtaCut) ;
  printf("Write delta AOD =     %d\n",     fWriteOutputDeltaAOD) ;
  printf("Recalculate Clusters = %d, E linearity = %d\n",    fRecalculateClusters, fCorrectELinearity) ;
  
  printf("Use Triggers selected in SE base class %d; If not what Trigger Mask? %d; MB Trigger Mask for mixed %d \n",
         fEventTriggerAtSE, fEventTriggerMask,fMixEventTriggerMask);
  
  if(fComparePtHardAndClusterPt)
    printf("Compare jet pt and pt hard to accept event, factor = %2.2f",fPtHardAndJetPtFactor);
  
  if(fComparePtHardAndClusterPt)
    printf("Compare cluster pt and pt hard to accept event, factor = %2.2f",fPtHardAndClusterPtFactor);
  
  printf("Read Kine from, stack? %d, AOD ? %d \n", fReadStack, fReadAODMCParticles) ;
  printf("Delta AOD File Name =     %s\n", fDeltaAODFileName.Data()) ;
  printf("Centrality: Class %s, Option %d, Bin [%d,%d] \n", fCentralityClass.Data(),fCentralityOpt,fCentralityBin[0], fCentralityBin[1]) ;
  
  printf("    \n") ;
  
}

//__________________________________________
Bool_t  AliCaloTrackReader::RejectLEDEvents()
{
  // LED Events in period LHC11a contaminated sample, simple method
  // to reject such events
  
  // Count number of cells with energy larger than 0.1 in SM3, cut on this number
  Int_t ncellsSM3 = 0;
  for(Int_t icell = 0; icell < fInputEvent->GetEMCALCells()->GetNumberOfCells(); icell++)
  {
    Int_t absID = fInputEvent->GetEMCALCells()->GetCellNumber(icell);
    Int_t sm    = GetCaloUtils()->GetEMCALGeometry()->GetSuperModuleNumber(absID);
    if(fInputEvent->GetEMCALCells()->GetAmplitude(icell) > 0.1 && sm==3) ncellsSM3++;
  }
  
  Int_t ncellcut = 21;
  if(GetFiredTriggerClasses().Contains("EMC")) ncellcut = 35;
  
  if(ncellsSM3 >= ncellcut)
  {
    AliDebug(1,Form("Reject event with ncells in SM3 %d, cut %d, trig %s",
                    ncellsSM3,ncellcut,GetFiredTriggerClasses().Data()));
    return kTRUE;
  }
  
  return kFALSE;
  
}

//_________________________________________________________
void AliCaloTrackReader::RemapMCLabelForAODs(Int_t & label)
{
  // MC label for Cells not remapped after ESD filtering, do it here.
  
  if(label < 0) return ;
  
  AliAODEvent  * evt = dynamic_cast<AliAODEvent*> (fInputEvent) ;
  if(!evt) return ;
  
  TClonesArray * arr = dynamic_cast<TClonesArray*>(evt->FindListObject("mcparticles")) ;
  if(!arr) return ;
  
  if(label < arr->GetEntriesFast())
  {
    AliAODMCParticle * particle = dynamic_cast<AliAODMCParticle *>(arr->At(label));
    if(!particle) return ;
    
    if(label == particle->Label()) return ; // label already OK
    //else printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label  %d - AOD stack %d \n",label, particle->Label());
  }
  //else printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label  %d > AOD labels %d \n",label, arr->GetEntriesFast());
  
  // loop on the particles list and check if there is one with the same label
  for(Int_t ind = 0; ind < arr->GetEntriesFast(); ind++ )
  {
    AliAODMCParticle * particle = dynamic_cast<AliAODMCParticle *>(arr->At(ind));
    if(!particle) continue ;
    
    if(label == particle->Label())
    {
      label = ind;
      //printf("AliAnalysisTaskEMCALClusterize::RemapMCLabelForAODs() - New Label Index  %d \n",label);
      return;
    }
  }
  
  label = -1;
  
  //printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label not found set to -1 \n");
  
}


//___________________________________
void AliCaloTrackReader::ResetLists()
{
  //  Reset lists, called by the analysis maker
  
  if(fCTSTracks)       fCTSTracks     -> Clear();
  if(fEMCALClusters)   fEMCALClusters -> Clear("C");
  if(fPHOSClusters)    fPHOSClusters  -> Clear("C");
  
  fV0ADC[0] = 0;   fV0ADC[1] = 0;
  fV0Mul[0] = 0;   fV0Mul[1] = 0;
  
  if(fNonStandardJets) fNonStandardJets -> Clear("C");
  fBackgroundJets->Reset();

}

//___________________________________________
void AliCaloTrackReader::SetEventTriggerBit()
{
  // Tag event depeding on trigger name
	
  fEventTrigMinBias       = kFALSE;
  fEventTrigCentral       = kFALSE;
  fEventTrigSemiCentral   = kFALSE;
  fEventTrigEMCALL0       = kFALSE;
  fEventTrigEMCALL1Gamma1 = kFALSE;
  fEventTrigEMCALL1Gamma2 = kFALSE;
  fEventTrigEMCALL1Jet1   = kFALSE;
  fEventTrigEMCALL1Jet2   = kFALSE;
  
  AliDebug(1,Form("Select trigger mask bit %d - Trigger Event %s - Select <%s>",
                  fEventTriggerMask,GetFiredTriggerClasses().Data(),fFiredTriggerClassName.Data()));
  
  if(fEventTriggerMask <=0 )// in case no mask set
  {
    // EMC triggered event? Which type?
    if( GetFiredTriggerClasses().Contains("-B-") || GetFiredTriggerClasses().Contains("-S-") || GetFiredTriggerClasses().Contains("-I-") )
    {
      if     ( GetFiredTriggerClasses().Contains("EGA" ) ||
              GetFiredTriggerClasses().Contains("EG1" )   )
      {
        fEventTrigEMCALL1Gamma1 = kTRUE;
        if( GetFiredTriggerClasses().Contains("EG1" ) && !fFiredTriggerClassName.Contains("EG1") ) fEventTrigEMCALL1Gamma1 = kFALSE;
      }
      else if( GetFiredTriggerClasses().Contains("EG2" )   )
      {
        fEventTrigEMCALL1Gamma2   = kTRUE;
        if( !fFiredTriggerClassName.Contains("EG2") ) fEventTrigEMCALL1Gamma2 = kFALSE;
      }
      else if( GetFiredTriggerClasses().Contains("EJE" ) ||
              GetFiredTriggerClasses().Contains("EJ1" )   )
      {
        fEventTrigEMCALL1Jet1   = kTRUE;
        if( GetFiredTriggerClasses().Contains("EJ1" ) && !fFiredTriggerClassName.Contains("EJ1") )
          fEventTrigEMCALL1Jet1 = kFALSE;
      }
      else if( GetFiredTriggerClasses().Contains("EJ2" )   )
      {
        fEventTrigEMCALL1Jet2   = kTRUE;
        if( !fFiredTriggerClassName.Contains("EJ2") ) fEventTrigEMCALL1Jet2 = kFALSE;
      }
      else if( GetFiredTriggerClasses().Contains("CEMC") &&
              !GetFiredTriggerClasses().Contains("EGA" ) &&
              !GetFiredTriggerClasses().Contains("EJE" ) &&
              !GetFiredTriggerClasses().Contains("EG1" ) &&
              !GetFiredTriggerClasses().Contains("EJ1" ) &&
              !GetFiredTriggerClasses().Contains("EG2" ) &&
              !GetFiredTriggerClasses().Contains("EJ2" )    )
      {
        fEventTrigEMCALL0 = kTRUE;
      }
      
      //Min bias event trigger?
      if     (GetFiredTriggerClasses().Contains("CCENT_R2-B-NOPF-ALLNOTRD"))
      {
        fEventTrigCentral     = kTRUE;
      }
      else if(GetFiredTriggerClasses().Contains("CSEMI_R1-B-NOPF-ALLNOTRD"))
      {
        fEventTrigSemiCentral = kTRUE;
      }
			else if((GetFiredTriggerClasses().Contains("CINT") || GetFiredTriggerClasses().Contains("CPBI2_B1") ) &&
              GetFiredTriggerClasses().Contains("-NOPF-ALLNOTRD") )
      {
			  fEventTrigMinBias = kTRUE;
      }
    }
  }
  else
	{
	  // EMC L1 Gamma
	  if     ( fEventTriggerMask & AliVEvent::kEMCEGA      )
    {
      //printf("EGA trigger bit\n");
      if     (GetFiredTriggerClasses().Contains("EG"))
      {
        if     (GetFiredTriggerClasses().Contains("EGA")) fEventTrigEMCALL1Gamma1 = kTRUE;
        else
        {
          if(GetFiredTriggerClasses().Contains("EG1")) fEventTrigEMCALL1Gamma1 = kTRUE;
          if(GetFiredTriggerClasses().Contains("EG2")) fEventTrigEMCALL1Gamma2 = kTRUE;
        }
      }
    }
	  // EMC L1 Jet
	  else if( fEventTriggerMask & AliVEvent::kEMCEJE      )
    {
      //printf("EGA trigger bit\n");
      if     (GetFiredTriggerClasses().Contains("EJ"))
      {
        if     (GetFiredTriggerClasses().Contains("EJE")) fEventTrigEMCALL1Jet1 = kTRUE;
        else
        {
          if(GetFiredTriggerClasses().Contains("EJ1")) fEventTrigEMCALL1Jet1 = kTRUE;
          if(GetFiredTriggerClasses().Contains("EJ2")) fEventTrigEMCALL1Jet2 = kTRUE;
        }
      }
    }
		// EMC L0
	  else if((fEventTriggerMask & AliVEvent::kEMC7) ||
            (fEventTriggerMask & AliVEvent::kEMC1)       )
    {
      //printf("L0 trigger bit\n");
	    fEventTrigEMCALL0 = kTRUE;
    }
	  // Min Bias Pb-Pb
	  else if( fEventTriggerMask & AliVEvent::kCentral     )
    {
      //printf("MB semi central trigger bit\n");
	    fEventTrigSemiCentral = kTRUE;
    }
	  // Min Bias Pb-Pb
	  else if( fEventTriggerMask & AliVEvent::kSemiCentral )
    {
      //printf("MB central trigger bit\n");
	    fEventTrigCentral = kTRUE;
    }
	  // Min Bias pp, PbPb, pPb
	  else if((fEventTriggerMask & AliVEvent::kMB  ) ||
            (fEventTriggerMask & AliVEvent::kINT7) ||
            (fEventTriggerMask & AliVEvent::kINT8) ||
            (fEventTriggerMask & AliVEvent::kAnyINT) )
    {
      //printf("MB trigger bit\n");
	    fEventTrigMinBias = kTRUE;
    }
	}
  
  AliDebug(1,Form("Event bits: \n \t MB   %d, Cen  %d, Sem  %d, L0   %d, L1G1 %d, L1G2 %d, L1J1 %d, L1J2 %d",
                  fEventTrigMinBias,      fEventTrigCentral,       fEventTrigSemiCentral,
                  fEventTrigEMCALL0 ,     fEventTrigEMCALL1Gamma1, fEventTrigEMCALL1Gamma2,
                  fEventTrigEMCALL1Jet1 , fEventTrigEMCALL1Jet2));
  
  if(fBitEGA == 0 && fBitEJE ==0)
  {
    // Init the trigger bit once, correct depending on AliESDAODCaloTrigger header version
    // Old values
    fBitEGA = 4;
    fBitEJE = 5;
    
    TFile* file = AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile();
    
    const TList *clist = file->GetStreamerInfoCache();
    
    if(clist)
    {
      TStreamerInfo *cinfo = (TStreamerInfo*)clist->FindObject("AliESDCaloTrigger");
      Int_t verid = 5; // newer ESD header version
      if(!cinfo)
      {
        cinfo = (TStreamerInfo*)clist->FindObject("AliAODCaloTrigger");
        verid = 3; // newer AOD header version
      }
      
      if(cinfo)
	    {
	      Int_t classversionid = cinfo->GetClassVersion();
	      //printf("********* Header class version %d *********** \n",classversionid);
	      
        if (classversionid >= verid)
        {
          fBitEGA = 6;
          fBitEJE = 8;
        }
	    }  else AliInfo("AliCaloTrackReader()::SetEventTriggerBit() - Streamer info for trigger class not available, bit not changed");
    } else AliInfo("AliCaloTrackReader::SetEventTriggerBit() -  Streamer list not available!, bit not changed");
    
  } // set once the EJE, EGA trigger bit
  
}

//____________________________________________________________
void AliCaloTrackReader::SetInputEvent(AliVEvent* const input)
{
  fInputEvent  = input;
  fMixedEvent = dynamic_cast<AliMixedEvent*>(GetInputEvent()) ;
  if (fMixedEvent)
    fNMixedEvent = fMixedEvent->GetNumberOfEvents() ;
  
  //Delete previous vertex
  if(fVertex)
  {
    for (Int_t i = 0; i < fNMixedEvent; i++)
    {
      delete [] fVertex[i] ;
    }
    delete [] fVertex ;
  }
  
  fVertex = new Double_t*[fNMixedEvent] ;
  for (Int_t i = 0; i < fNMixedEvent; i++)
  {
    fVertex[i] = new Double_t[3] ;
    fVertex[i][0] = 0.0 ;
    fVertex[i][1] = 0.0 ;
    fVertex[i][2] = 0.0 ;
  }
}


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