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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Check basic detector results at ESD level                            //
//   - Geometrical efficiency                                           //
//   - Tracking efficiency                                              //
//   - PID efficiency                                                   //
//   - Refit efficiency                                                 //
//                                                                      //
// Author                                                               //
//   Alex Bercuci <A.Bercuci@gsi.de>                                    //
//   Ionut Arsene <i.c.arsene@gsi.de>                                   //
//                                                                      //
//     The analysis task fills AliCFContainer objects defined in the    //
//   configuration macro using the AddCFContainer() method.             //
//   The CF containers can be filled with any of the variables defined  //
//   in ETrdCfVariables and at any of the steps defined in ETrdCfSteps. //
//     To define a new variable one needs to:                           //
//   1. Add an entry in the ETrdCfVariables enumeration                 //
//   2. Add the corresponding variable name (and in the correct order)  //
//      in fgkVarNames                                                  //
//   3. Define how the variable is filled in one of the Fill functions: //
//      FillEventInfo(), FillTrackInfo(), FillTrackletInfo(),           //
//      FillTrackletSliceInfo().                                        //
//     To define a new step one needs to:                               //
//   1. Add an entry in the ETrdCfSteps                                 //
//   2. Add the corresponding name in fgkStepNames                      //
//   3. Define the track level cuts for this step in IsTrackSelected()  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <TClonesArray.h>
#include <TCanvas.h>
#include <TObjArray.h>
#include <TPad.h>
#include <TLegend.h>
#include <TLatex.h>
#include <TLine.h>
#include <TF1.h>
#include <TH1D.h>
#include <TH2D.h>
#include <TH3D.h>
#include <TH2I.h>
#include <TH2F.h>
#include <TH3S.h>
#include <TH3F.h>
#include <TProfile2D.h>
#include <TProfile.h>
#include <TGraphErrors.h>
#include <TGraphAsymmErrors.h>
#include <TFile.h>
#include <TTree.h>
#include <TROOT.h>
#include <TChain.h>
#include <TParticle.h>
#include <TTimeStamp.h>
#include <TRandom.h>
#include <TString.h>

#include "AliLog.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisCuts.h"
#include "AliPhysicsSelection.h"
#include "AliESDEvent.h"
#include "AliESDkink.h"
#include "AliMCEvent.h"
#include "AliESDInputHandler.h"
#include "AliMCEventHandler.h"
#include "AliESDpid.h"
#include "AliExternalTrackParam.h"

#include "AliESDtrack.h"
#include "AliMCParticle.h"
#include "AliPID.h"
#include "AliStack.h"
#include "AliTrackReference.h"
#include "AliMultiplicity.h"
#include "AliCFContainer.h"

#include "AliTRDcheckESD.h"
#include <iostream>
using std::cout;
using std::endl;

ClassImp(AliTRDcheckESD)

const Float_t AliTRDcheckESD::fgkxTPC = 290.;
const Float_t AliTRDcheckESD::fgkxTOF = 365.;
const Char_t* AliTRDcheckESD::fgkVarNames[AliTRDcheckESD::kNTrdCfVariables] = {
    "vtxZ", "multiplicity", "trigger", "BC", "TOFBC", "DCAxy", "DCAz", "charge", "OuterParam rad.", "phiVtx", "phi", 
    "etaVtx", "eta", "pt", "ptTRD", "P", "PTRD", "TRDchi2", "tracklets", "clusters", "TrdQuality", 
    "TrdBudget", "TOFchi2", "Qtot0", "ClustersPerRows", "Clusters/tracklet", "TrdP", "TrdPloss", "layer", "slice", "PH0"
}; 
const Char_t* AliTRDcheckESD::fgkStepNames[AliTRDcheckESD::kNSteps] = {"TPC", "TRD", "TOF", "TOFin", "TOFout"};  

FILE* AliTRDcheckESD::fgFile = NULL;

//____________________________________________________________________
AliTRDcheckESD::AliTRDcheckESD():
  AliAnalysisTaskSE()
  ,fStatus(0)
  ,fNRefFigures(0)
  ,fESD(NULL)
  ,fMC(NULL)
  ,fESDpid(new AliESDpid)
  ,fHistos(NULL)
  ,fReferenceTrackFilter(NULL)
  ,fPhysSelTriggersEnabled(kFALSE)
  ,fUserEnabledTriggers("")
  ,fNAssignedTriggers(0)
{
  //
  // Default constructor
  //
  SetNameTitle("TRDcheckESD", "Check TRD @ ESD level");
  SetMC(kTRUE);
}

//____________________________________________________________________
AliTRDcheckESD::AliTRDcheckESD(char* name):
  AliAnalysisTaskSE(name)
  ,fStatus(0)
  ,fNRefFigures(0)
  ,fESD(NULL)
  ,fMC(NULL)
  ,fESDpid(new AliESDpid)
  ,fHistos(NULL)
  ,fReferenceTrackFilter(NULL)
  ,fPhysSelTriggersEnabled(kFALSE)
  ,fUserEnabledTriggers("")
  ,fNAssignedTriggers(0)
{
  //
  // Default constructor
  //
  SetMC(kTRUE);
  SetTitle("Check TRD @ ESD level");
  DefineOutput(1, TObjArray::Class());
}

//____________________________________________________________________
AliTRDcheckESD::~AliTRDcheckESD()
{
  // Destructor
  if(fHistos && !(AliAnalysisManager::GetAnalysisManager() && AliAnalysisManager::GetAnalysisManager()->IsProofMode())){
    if(fHistos->IsOwner()) fHistos->Delete();
    delete fHistos;
    fHistos = NULL;
  }
}

//____________________________________________________________________
void AliTRDcheckESD::FillEventInfo(Double_t* values) {
  //
  // Fill event information
  //
  values[kEventVtxZ] = fESD->GetPrimaryVertex()->GetZ();
  values[kEventBC] = fESD->GetBunchCrossNumber();
  
  const AliMultiplicity* mult=fESD->GetMultiplicity();
  Double_t itsNTracklets = mult->GetNumberOfTracklets();
  values[kEventMult] = itsNTracklets;
}

//____________________________________________________________________
void AliTRDcheckESD::FillTrackInfo(Double_t* values, AliESDtrack* esdTrack) {
  //
  // Fill track information
  //
  Float_t dcaxy,dcaz;
  esdTrack->GetImpactParameters(dcaxy,dcaz);
  values[kTrackDCAxy]  = dcaxy;
  values[kTrackDCAz]   = dcaz;  
  values[kTrackCharge] = esdTrack->Charge();
  values[kTrackPt]     = esdTrack->Pt();
  values[kTrackPhi]    = esdTrack->Phi();
  values[kTrackEta]    = esdTrack->Eta();
  values[kTrackP]      = esdTrack->P();
  values[kTrackTrdTracklets] = esdTrack->GetTRDntracklets();
  values[kTrackTrdClusters]  = esdTrack->GetTRDncls();
  values[kTrackTrdChi2]      = esdTrack->GetTRDchi2()/(esdTrack->GetTRDntracklets()>0 ? esdTrack->GetTRDntracklets() : 1.0);
  values[kTrackTrdQuality]   = esdTrack->GetTRDQuality();
  values[kTrackTRDBudget]    = -1.0*esdTrack->GetTRDBudget();
  values[kTrackTOFBC]        = esdTrack->GetTOFBunchCrossing(fESD->GetMagneticField());
  values[kTrackTOFchi2]      = esdTrack->GetTOFchi2();
  const AliExternalTrackParam *out=esdTrack->GetOuterParam();
  Double_t p[3];
  if(out->GetXYZ(p)) 
    values[kTrackOuterParamRadius] = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
  else 
    values[kTrackOuterParamRadius] = 0.0;
}

//____________________________________________________________________
void AliTRDcheckESD::FillTrackletInfo(Double_t* values, AliESDtrack* esdTrack, Int_t iPlane,
                                      Double_t* localSagitaPhi, Double_t localMom[][3], Bool_t* localMomGood) {
  //
  // Fill TRD tracklet info
  //
  values[kTrackletClustersVsRows] = esdTrack->GetTRDtrkltClCross(iPlane);
  values[kTrackletClusters]       = esdTrack->GetTRDtrkltOccupancy(iPlane);
  values[kTrackletQtot]           = esdTrack->GetTRDslice(iPlane, 0);
  values[kTrackletP]              = esdTrack->GetTRDmomentum(iPlane);
  values[kTrackPlossTRDlayer]     = 1000.0*(esdTrack->P() - values[kTrackletP]);    // p loss in MeV    
  values[kTrackletLayer]          = iPlane;
  values[kTrackPhiTRD]            = localSagitaPhi[iPlane];
  values[kTrackPtTRD]         = (localMomGood[iPlane] ? TMath::Sqrt(localMom[iPlane][0]*localMom[iPlane][0]+
	                                                            localMom[iPlane][1]*localMom[iPlane][1]) : values[kTrackPt]);
  values[kTrackPTRD]          = (localMomGood[iPlane] ? TMath::Sqrt(values[kTrackPtTRD]*values[kTrackPtTRD]+
                                                                    localMom[iPlane][2]*localMom[iPlane][2]) : values[kTrackP]);	
  values[kTrackEtaTRD] = values[kTrackPTRD]-(localMomGood[iPlane] ? localMom[iPlane][2] : esdTrack->Pz());
  values[kTrackEtaTRD] = (TMath::Abs(values[kTrackPTRD])>1.0e-8 ? (values[kTrackPTRD]+(localMomGood[iPlane] ? localMom[iPlane][2] : esdTrack->Pz()))/values[kTrackEtaTRD] : 0.0);
  values[kTrackEtaTRD] = (values[kTrackEtaTRD]>1.0e-8 ? 0.5*TMath::Log(values[kTrackEtaTRD]) : -999.);
}

//____________________________________________________________________
void AliTRDcheckESD::FillTrackletSliceInfo(Double_t* values, AliESDtrack* esdTrack, Int_t iSlice) {
  //
  // Fill TRD tracklet info
  //
  values[kTrackletPHslice] = esdTrack->GetTRDslice(Int_t(values[kTrackletLayer]), iSlice);
  values[kTrackletSlice] = iSlice;
}

//____________________________________________________________________
Bool_t AliTRDcheckESD::IsTrackSelected(AliESDtrack* track, Double_t* /*values*/, Int_t step) {
  //
  // Select tracks at each step
  //  
  Bool_t referenceFilter = fReferenceTrackFilter->IsSelected(track);
  if(step==kTPCreference) {    // reference track filter
    return referenceFilter;
  }
  if(step==kTRD) {    // TRD reference track filter
    return (referenceFilter && Int_t(track->GetTRDntracklets()>0));
  }
  if(step==kTOF) {    // TRD+(TOFout || TOFpid) request
    return (referenceFilter && Int_t(track->GetTRDntracklets())>0 && 
           ((track->GetStatus() & AliESDtrack::kTOFout) || (track->GetStatus() & AliESDtrack::kTOFpid))); 
  }
  if(step==kTOFin) {    // TOFin request
    return (referenceFilter && (track->GetStatus() & AliESDtrack::kTOFin)); 
  }
  if(step==kTOFout) {    // TOFout request
    return (referenceFilter && (track->GetStatus() & AliESDtrack::kTOFout)); 
  }
  return kFALSE;
}

//____________________________________________________________________
void AliTRDcheckESD::UserCreateOutputObjects()
{	
  //
  // Create Output Containers (TObjectArray containing 1D histograms)
  //
  Histos();
  PostData(1, fHistos);
}

//____________________________________________________________________
void AliTRDcheckESD::MakeSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/){
  //
  // Draw summary plots for the ESDcheck task using the CF container
  //

  cout << "Make summary from CF" << endl;
  TCanvas *cOut=0x0;
  if(gROOT->FindObject("trackingSummary")) delete gROOT->FindObject("trackingSummary");
  cOut = new TCanvas("trackingSummary", "Tracking summary for the ESD task", 1600, 1200);
  cOut->cd();
  //PlotTrackingSummaryFromCF(trendValues, triggerName, useIsolatedBC, cutTOFbc);
  PlotTrackingSummaryFromCF(trendValues);
  cOut->SaveAs("trackingSummary.gif");
  
  if(gROOT->FindObject("pidSummary")) delete gROOT->FindObject("pidSummary");
  cOut = new TCanvas("pidSummary", "PID summary for the ESD task", 1600, 1200);
  cOut->cd();
  //PlotPidSummaryFromCF(trendValues, triggerName, useIsolatedBC, cutTOFbc);
  PlotPidSummaryFromCF(trendValues);
  cOut->SaveAs("pidSummary.gif");

  if(gROOT->FindObject("centSummary")) delete gROOT->FindObject("centSummary");
  cOut = new TCanvas("centSummary", "Centrality summary for the ESD task", 1600, 1200);
  cOut->cd();
  //PlotCentSummaryFromCF(trendValues, triggerName, useIsolatedBC, cutTOFbc);
  PlotCentSummaryFromCF(trendValues);
  cOut->SaveAs("centSummary.gif");
  
  PlotOtherSummaryFromCF(trendValues);
  
  if(trendValues)
    for(Int_t i=0;i<50;++i) cout << "trend #" << i << " :: " << trendValues[i] << endl;
}


//____________________________________________________________________
void AliTRDcheckESD::UserExec(Option_t *){
  //
  // Run the Analysis
  //
  fESD = dynamic_cast<AliESDEvent*>(InputEvent());
  fMC = MCEvent();

  if(!fESD){
    AliError("ESD event missing.");
    return;
  }
  
  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
  AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
  if(!inputHandler) return;
  
  if(!fPhysSelTriggersEnabled) {
    InitializeCFContainers();
    fPhysSelTriggersEnabled = kTRUE;
  }
    
  UInt_t isSelected = AliVEvent::kAny;
  if(inputHandler){
    if(inputHandler->GetEventSelection()) {
      isSelected = inputHandler->IsEventSelected();
    }
  }
  if(!isSelected) return;

  TString triggerClasses = fESD->GetFiredTriggerClasses();
  //cout << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++triggers fired:  " << triggerClasses.Data() << endl;
  TObjArray* triggers = triggerClasses.Tokenize(" ");
  TObjArray* userTriggers = fUserEnabledTriggers.Tokenize(";");
  if(triggers->GetEntries()<1) {delete triggers; delete userTriggers; return;}
  Bool_t hasGoodTriggers = kFALSE;
  Int_t triggerIndices[kNMaxAssignedTriggers] = {0};
  Int_t nTrigFired=0;
  Bool_t trigAlreadyChecked = kFALSE;
  Bool_t trigSelected = kFALSE;
  Int_t trigIdx = 0;
  for(Int_t i=0; i<triggers->GetEntries(); ++i) {
    TString trigStr=triggers->At(i)->GetName();
    if(!trigStr.Contains("NOTRD") && !trigStr.Contains("MUON")) hasGoodTriggers = kTRUE;    // check wheter TRD was read out in this event
    if(trigStr.Contains("NOTRD")) continue;
    if(trigStr.Contains("MUON")) continue;
    if(i>=kNMaxAssignedTriggers) continue;
    
    hasGoodTriggers = kTRUE;
    // enable the "All triggers" bit
    trigIdx = 1;
    trigAlreadyChecked = kFALSE;
    for(Int_t k=0;k<nTrigFired;++k) 
      if(triggerIndices[k]==trigIdx) {
	trigAlreadyChecked = kTRUE;
	break;
    }
    if(!trigAlreadyChecked) triggerIndices[nTrigFired++] = trigIdx;  
    
    trigSelected = kFALSE;
    // check whether this trigger matches any of the user defined trigger families
    for(Int_t j=0;j<userTriggers->GetEntries();++j) {
      TString userTrigStr=userTriggers->At(j)->GetName();
      if(trigStr.Contains(userTrigStr.Data())) {
	trigSelected = kTRUE;
	trigIdx = GetTriggerIndex(userTrigStr.Data(), kFALSE);
	trigAlreadyChecked = kFALSE;
	for(Int_t k=0;k<nTrigFired;++k) 
	  if(triggerIndices[k]==trigIdx) {
	    trigAlreadyChecked = kTRUE;
	    break;
	  }
	if(!trigAlreadyChecked) {    // add trigger to the list of enabled triggers only if it was not added already
	  triggerIndices[nTrigFired++] = trigIdx;  
	}
      }
    }
    
    trigIdx = GetTriggerIndex(trigStr.Data(), kFALSE);
    if(trigIdx>0) trigSelected = kTRUE;
    if(trigIdx==-1) trigIdx=1;  
    trigAlreadyChecked = kFALSE;
    for(Int_t k=0;k<nTrigFired;++k) 
      if(triggerIndices[k]==trigIdx) {
        trigAlreadyChecked = kTRUE;
	break;
      }
    if(!trigAlreadyChecked) {
      triggerIndices[nTrigFired++]=1;  // 0-assigned to all other triggers
    }
  }  // end loop over triggers  
  
  if(!trigSelected && hasGoodTriggers) {
    triggerIndices[nTrigFired++]=2;
  }
  
  TH1F* hTrig = (TH1F*)fHistos->FindObject("hTriggerDefs");
  for(Int_t i=0; i<nTrigFired; ++i)
    hTrig->Fill(triggerIndices[i]);

  if(!hasGoodTriggers) {
    PostData(1, fHistos);
    delete triggers;
    delete userTriggers;
    return;
  }
  
  Int_t* trigFiredIdx=new Int_t[nTrigFired];
  for(Int_t i=0;i<nTrigFired;++i) trigFiredIdx[i] = triggerIndices[i];
  
  // Get MC information if available
  //AliStack * fStack = NULL;
  if(HasMC()){
    if(!fMC){ 
      AliWarning("MC event missing");
      SetMC(kFALSE);
    } else {
      if(!fMC->Stack()){
        AliWarning("MC stack missing");
        SetMC(kFALSE);
      }
    }
  }
  
  Double_t values[kNTrdCfVariables];      // array where the CF container variables are stored
  for(Int_t i=0;i<kNTrdCfVariables; ++i) values[i] = -999.;
  FillEventInfo(values);  
  
  Int_t multLimits[6] = {0, 700, 1400, 2100, 2800, 3500};
  Int_t centralityClass = 0;
  for(Int_t iCent=0; iCent<5; ++iCent) {
    if(values[kEventMult]>=multLimits[iCent] && values[kEventMult]<multLimits[iCent+1])
      centralityClass=iCent+1;
  }
  if(centralityClass == 0) return;
  
  // radius of TRD entrance plane in each layer
  Double_t rTRD[6] = {298.0, 311.0, 324.0, 337.0, 350.0, 363.0};
  
  AliESDtrack *esdTrack(NULL);
  for(Int_t itrk = 0; itrk < fESD->GetNumberOfTracks(); itrk++){
    esdTrack = fESD->GetTrack(itrk);
    
    Bool_t stepSelections[kNSteps]; 
    for(Int_t is=0;is<kNSteps;++is) {
      stepSelections[is] = IsTrackSelected(esdTrack, values, is);
    }
    if(!stepSelections[0]) continue;
    
    FillTrackInfo(values, esdTrack);
    
    // find position and momentum of the track at entrance in TRD
    const AliExternalTrackParam *outerParam = esdTrack->GetOuterParam();
    Double_t localCoord[6][3] = {{0.0}};
    Bool_t localCoordGood[6];
    for(Int_t il=0;il<6;++il) 
      localCoordGood[il] = (outerParam ? outerParam : esdTrack)->GetXYZAt(rTRD[il], fESD->GetMagneticField(), localCoord[il]);  
    Double_t localMom[6][3] = {{0.0}};
    Bool_t localMomGood[6];
    for(Int_t il=0; il<6; ++il) 
      localMomGood[il] = (outerParam ? outerParam : esdTrack)->GetPxPyPzAt(rTRD[il], fESD->GetMagneticField(), localMom[il]);
    Double_t localSagitaPhi[6] = {-999.};
    for(Int_t il=0; il<6; ++il) 
      localSagitaPhi[il] = (localCoordGood[il] ? TMath::ATan2(localCoord[il][1], localCoord[il][0]) : -999.);
    if(!localMomGood[0]) continue;
    
    // fill tracklet values such that the TRD local coordinates are filled
    FillTrackletInfo(values, esdTrack, 0, localSagitaPhi, localMom, localMomGood);
        
    for(Int_t itrig=0; itrig<nTrigFired; ++itrig) {
      values[kEventTrigger] = Double_t(trigFiredIdx[itrig]);
      
      // check if cf needs tracklet or slice info
      FillGlobalTrackContainers(values, stepSelections, itrig);
      
      for(Int_t iPlane=0; iPlane<6; iPlane++) {
        FillTrackletInfo(values, esdTrack, iPlane, localSagitaPhi, localMom, localMomGood);
	if(values[kTrackletQtot]>20.0) FillTrdTrackletContainers(values, stepSelections, itrig);
	
	for(Int_t iSlice=0; iSlice<8; iSlice++) {
	  FillTrackletSliceInfo(values, esdTrack, iSlice);
	  if(values[kTrackletPHslice]>20.0) FillTrdSliceContainers(values, stepSelections, itrig);
	}  // end loop over slices
      }  // end loop over TRD layers
    }  // end loop over triggers
  }  // end loop over tracks
  
  delete triggers;
  delete userTriggers;
  delete [] trigFiredIdx;  
  
  PostData(1, fHistos);
}

//____________________________________________________________________
TObjArray* AliTRDcheckESD::Histos()
{
  // Retrieve histograms array if already build or build it
  if(!fHistos) {
    fHistos = new TObjArray();
    fHistos->SetOwner(kTRUE);
  }
  
  TH1* h = 0x0;
  // Trigger definitions
  if(!(h=(TH1F*)gROOT->FindObject("hTriggerDefs"))) {
    h = new TH1F("hTriggerDefs", "Trigger definitions", kNMaxAssignedTriggers, 0.5, 0.5+Float_t(kNMaxAssignedTriggers));
  }
  else h->Reset();
  fHistos->Add(h);
    
  return fHistos;
}


//__________________________________________________________________________________________________________
void AliTRDcheckESD::InitializeCFContainers() {
  //
  //  Initialize the CF container
  //
  AliAnalysisManager* man=AliAnalysisManager::GetAnalysisManager();
  AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
  if(!inputHandler) return;

  GetTriggerIndex("All triggers", kTRUE);
  GetTriggerIndex("Not specified triggers", kTRUE);

  AliPhysicsSelection* physSel = (AliPhysicsSelection*)inputHandler->GetEventSelection();
  const TList* trigList = (physSel ? physSel->GetCollisionTriggerClasses() : 0x0);
  const TList* bgTrigList = (physSel ? physSel->GetBGTriggerClasses() : 0x0);
  
  // Add collision triggers from PhysicsSelection
  if(trigList) {
    for(Int_t it=0; it<trigList->GetEntries(); ++it) {
      TString trigName = trigList->At(it)->GetName();
      TObjArray* arr = trigName.Tokenize(" ");
      trigName = arr->At(0)->GetName();
      trigName.Remove(0,1);
      TObjArray* arr2 = trigName.Tokenize(",");
      for(Int_t jt=0; jt<arr2->GetEntries(); ++jt) {
        // Assign an index into the trigger histogram and the CF container for this trigger
        GetTriggerIndex(arr2->At(jt)->GetName(), kTRUE);
      }
      delete arr;
    }
  }
  // Add background triggers from PhysicsSelection
  if(bgTrigList) {
    for(Int_t it=0; it<bgTrigList->GetEntries(); ++it) {
      TString trigName = bgTrigList->At(it)->GetName();
      TObjArray* arr = trigName.Tokenize(" ");
      trigName = arr->At(0)->GetName();
      trigName.Remove(0,1);
      TObjArray* arr2 = trigName.Tokenize(",");
      for(Int_t jt=0; jt<arr2->GetEntries(); ++jt) {
        // Assign an index into the trigger histogram and the CF container for this trigger
        GetTriggerIndex(arr2->At(jt)->GetName(), kTRUE);
      }
      delete arr;
    }
  }
    
  // Add user enabled triggers
  TObjArray* arr = fUserEnabledTriggers.Tokenize(";");
  for(Int_t it=0; it<arr->GetEntries(); ++it) {
    GetTriggerIndex(arr->At(it)->GetName(), kTRUE);
  }
  delete arr;
}


//__________________________________________________________________________________________________________
void AliTRDcheckESD::AddCFContainer(const Char_t* name, const Char_t* title,
				    Int_t nSteps, Int_t* steps, 
				    Int_t nVars, UInt_t* vars, TArrayD* binLimits) {
  //
  // Add a CF container
  //
  if(!fHistos) {
    fHistos = new TObjArray();
    fHistos->SetOwner(kTRUE);
  }
  // get number of bins for each variable
  Int_t* nBins = new Int_t[nVars];
  for(Int_t iv=0;iv<nVars;++iv)
    nBins[iv] = binLimits[iv].GetSize()-1;  
  // create the CF container
  AliCFContainer* cf = new AliCFContainer(name, title, nSteps, nVars, nBins);
  // set CF container variable binning and name
  for(Int_t iv=0;iv<nVars;++iv) {
    cf->SetBinLimits(iv, binLimits[iv].GetArray());
    cf->SetVarTitle(iv, fgkVarNames[vars[iv]]);
  }
  // set the step names 
  for(Int_t is=0; is<nSteps; ++is) {
    cf->SetStepTitle(is, fgkStepNames[steps[is]]);
    for(Int_t iv=0;iv<nVars;++iv) cf->GetAxis(iv, is)->SetUniqueID(vars[iv]);
  }
  fHistos->Add(cf);
}

//__________________________________________________________________________________________________
void AliTRDcheckESD::FillTrdSliceContainers(Double_t* values, Bool_t* stepSelections, Int_t itrig) {
  //
  // fill TRD slice info
  //
  if(!fHistos) return;
  for(Int_t i=0;i<fHistos->GetEntries();++i) {
    TString objType = fHistos->At(i)->IsA()->GetName();
    if(!objType.Contains("AliCFContainer")) continue;
    AliCFContainer* cf = (AliCFContainer*)fHistos->At(i);
    TString varNames="";
    for(Int_t ivar=0;ivar<cf->GetNVar();++ivar) {
      varNames += cf->GetVarTitle(ivar); varNames += ";";
    }
    //if(cf->GetVar(fgkVarNames[kTrackletSlice])<0 && cf->GetVar(fgkVarNames[kTrackletPHslice])<0) continue;
    if(!varNames.Contains(fgkVarNames[kTrackletSlice]) && !varNames.Contains(fgkVarNames[kTrackletPHslice])) continue;
    //if((cf->GetVar(fgkVarNames[kEventTrigger])<0 && itrig==0) || (cf->GetVar(fgkVarNames[kEventTrigger])>=0))
    if((!varNames.Contains(fgkVarNames[kEventTrigger]) && itrig==0) || varNames.Contains(fgkVarNames[kEventTrigger]))
      FillCFContainer(cf, values, stepSelections);
  }
}

//__________________________________________________________________________________________________
void AliTRDcheckESD::FillTrdTrackletContainers(Double_t* values, Bool_t* stepSelections, Int_t itrig) {
  //
  // fill global track info
  //
  if(!fHistos) return;
  for(Int_t i=0;i<fHistos->GetEntries();++i) {
    TString objType = fHistos->At(i)->IsA()->GetName();
    if(!objType.Contains("AliCFContainer")) continue;
    AliCFContainer* cf = (AliCFContainer*)fHistos->At(i);
    TString varNames="";
    for(Int_t ivar=0;ivar<cf->GetNVar();++ivar) {
      varNames += cf->GetVarTitle(ivar); varNames += ";";
    }
    //if(cf->GetVar(fgkVarNames[kTrackletSlice])>=0 || cf->GetVar(fgkVarNames[kTrackletPHslice])>=0) continue;
    if(varNames.Contains(fgkVarNames[kTrackletSlice]) || varNames.Contains(fgkVarNames[kTrackletPHslice])) continue;
    //if(cf->GetVar(fgkVarNames[kTrackletLayer])<0 && cf->GetVar(fgkVarNames[kTrackletQtot])<0) continue;
    if(!varNames.Contains(fgkVarNames[kTrackletLayer]) && !varNames.Contains(fgkVarNames[kTrackletQtot])) continue;
    //if((cf->GetVar(fgkVarNames[kEventTrigger])<0 && itrig==0) || (cf->GetVar(fgkVarNames[kEventTrigger])>=0))
    if((!varNames.Contains(fgkVarNames[kEventTrigger]) && itrig==0) || varNames.Contains(fgkVarNames[kEventTrigger]))
      FillCFContainer(cf, values, stepSelections);
  }
}

//__________________________________________________________________________________________________
void AliTRDcheckESD::FillGlobalTrackContainers(Double_t* values, Bool_t* stepSelections, Int_t itrig) {
  //
  // fill global track info
  //
  if(!fHistos) return;
  for(Int_t i=0;i<fHistos->GetEntries();++i) {
    TString objType = fHistos->At(i)->IsA()->GetName();
    if(!objType.Contains("AliCFContainer")) continue;
    AliCFContainer* cf = (AliCFContainer*)fHistos->At(i);
    TString varNames="";
    for(Int_t ivar=0;ivar<cf->GetNVar();++ivar) {
      varNames += cf->GetVarTitle(ivar); varNames += ";";
    }
    /*if(cf->GetVar(fgkVarNames[kTrackletLayer])>=0 || 
       cf->GetVar(fgkVarNames[kTrackletSlice])>=0 || 
       cf->GetVar(fgkVarNames[kTrackletQtot])>=0 || 
       cf->GetVar(fgkVarNames[kTrackletPHslice])>=0) continue;*/
    if(varNames.Contains(fgkVarNames[kTrackletLayer]) || 
       varNames.Contains(fgkVarNames[kTrackletSlice]) || 
       varNames.Contains(fgkVarNames[kTrackletQtot]) || 
       varNames.Contains(fgkVarNames[kTrackletPHslice])) continue;
    /*if((cf->GetVar(fgkVarNames[kEventTrigger])<0 && itrig==0) || 
       (cf->GetVar(fgkVarNames[kEventTrigger])>=0))*/
    if((!varNames.Contains(fgkVarNames[kEventTrigger]) && itrig==0) || 
       varNames.Contains(fgkVarNames[kEventTrigger]))
      FillCFContainer(cf, values, stepSelections);
  }
}

//__________________________________________________________________________________________________
void AliTRDcheckESD::FillCFContainer(AliCFContainer* cf, Double_t* values, Bool_t* stepSelections) {
  //
  // Fill CF container
  //
  Double_t* cfValues=new Double_t[cf->GetNVar()];
  for(Int_t iv=0;iv<cf->GetNVar();++iv)
    cfValues[iv] = values[cf->GetAxis(iv,0)->GetUniqueID()];
    
  for(Int_t istep=0; istep<cf->GetNStep(); ++istep) {
    TString stepTitle = cf->GetStepTitle(istep);
    Int_t stepNo = -1;
    for(Int_t is=0;is<kNSteps;++is) 
      if(!stepTitle.CompareTo(fgkStepNames[is])) {
	stepNo = is;
	break;
      }
    if(stepSelections[stepNo]) cf->Fill(cfValues, istep);
  }  // end loop over steps

  delete [] cfValues;
}

//____________________________________________________________________
Bool_t AliTRDcheckESD::Load(const Char_t *file, const Char_t *dir, const Char_t *name)
{
  //
  // Load data from performance file
  //
  if(!TFile::Open(file)){
    AliWarning(Form("Couldn't open file %s.", file));
    return kFALSE;
  }
  if(dir){
    if(!gFile->cd(dir)){
      AliWarning(Form("Couldn't cd to %s in %s.", dir, file));
      return kFALSE;
    }
  }
  TObjArray *o(NULL);
  const Char_t *tn=(name ? name : GetName());
  if(!(o = (TObjArray*)gDirectory->Get(tn))){
    AliWarning(Form("Missing histogram container %s.", tn));
    return kFALSE;
  }
  fHistos = (TObjArray*)o->Clone(GetName());
    
  TH1F* trigHist = (TH1F*)fHistos->FindObject("hTriggerDefs");
  for(Int_t i=1;i<=trigHist->GetXaxis()->GetNbins();++i) {
    if(trigHist->GetXaxis()->GetBinLabel(i)[0]!='\0') ++fNAssignedTriggers;
  }
  gFile->Close();
  return kTRUE;
}

//_______________________________________________________
Bool_t AliTRDcheckESD::PutTrendValue(const Char_t *name, Double_t val)
{
// Dump trending value to default file

  if(!fgFile){
    fgFile = fopen("TRD.Performance.txt", "at");
  }
  fprintf(fgFile, "%s_%s %f\n", GetName(), name, val);
  return kTRUE;
}

//____________________________________________________________________
void AliTRDcheckESD::Terminate(Option_t *)
{
  // Steer post-processing 
  if(!fHistos){
    fHistos = dynamic_cast<TObjArray *>(GetOutputData(1));
    if(!fHistos){
      AliError("Histogram container not found in output");
      return;
    }
  }
}

//____________________________________________________________________
Int_t AliTRDcheckESD::Pdg2Idx(Int_t pdg) const
{
  //
  // Helper function converting PDG code into AliPID index
  //
  switch(pdg){
  case kElectron: 
  case kPositron: return AliPID::kElectron;  
  case kMuonPlus:
  case kMuonMinus: return AliPID::kMuon;  
  case kPiPlus: 
  case kPiMinus: return AliPID::kPion;  
  case kKPlus: 
  case kKMinus: return AliPID::kKaon;
  case kProton: 
  case kProtonBar: return AliPID::kProton;
  } 
  return -1;
}

  
//________________________________________________________
void AliTRDcheckESD::Process2D(TH2 * const h2, TGraphErrors **g)
{
  //
  // Do the processing
  //

  Int_t n = 0;
  if((n=g[0]->GetN())) for(;n--;) g[0]->RemovePoint(n);
  if((n=g[1]->GetN())) for(;n--;) g[1]->RemovePoint(n);
  TF1 f("fg", "gaus", -3.,3.);
  for(Int_t ibin = 1; ibin <= h2->GetNbinsX(); ibin++){
    Double_t x = h2->GetXaxis()->GetBinCenter(ibin);
    TH1D *h = h2->ProjectionY("py", ibin, ibin);
    if(h->GetEntries()<100) continue;
    //AdjustF1(h, f);

    h->Fit(&f, "QN");
    Int_t ip = g[0]->GetN();
    g[0]->SetPoint(ip, x, f.GetParameter(1));
    g[0]->SetPointError(ip, 0., f.GetParError(1));
    g[1]->SetPoint(ip, x, f.GetParameter(2));
    g[1]->SetPointError(ip, 0., f.GetParError(2));
  }
  return;
}
//____________________________________________________________________
void AliTRDcheckESD::PrintStatus(ULong_t status)
{
// Dump track status to stdout

  printf("ITS[i(%d) o(%d) r(%d)] TPC[i(%d) o(%d) r(%d) p(%d)] TRD[i(%d) o(%d) r(%d) p(%d) s(%d)] HMPID[o(%d) p(%d)]\n"
    ,Bool_t(status & AliESDtrack::kITSin)
    ,Bool_t(status & AliESDtrack::kITSout)
    ,Bool_t(status & AliESDtrack::kITSrefit)
    ,Bool_t(status & AliESDtrack::kTPCin)
    ,Bool_t(status & AliESDtrack::kTPCout)
    ,Bool_t(status & AliESDtrack::kTPCrefit)
    ,Bool_t(status & AliESDtrack::kTPCpid)
    ,Bool_t(status & AliESDtrack::kTRDin)
    ,Bool_t(status & AliESDtrack::kTRDout)
    ,Bool_t(status & AliESDtrack::kTRDrefit)
    ,Bool_t(status & AliESDtrack::kTRDpid)
    ,Bool_t(status & AliESDtrack::kTRDStop)
    ,Bool_t(status & AliESDtrack::kHMPIDout)
    ,Bool_t(status & AliESDtrack::kHMPIDpid)
  );
}

//____________________________________________________________________
TH1D* AliTRDcheckESD::Proj2D(TH2* hist, TH1* mpvErr, TH1* widthErr, TH1* chi2) {
  //
  // project the PH vs Slice 2D-histo into a 1D histo with Landau MPV and widths
  //
  
  TH1D* hProjection = (TH1D*)hist->ProjectionX(Form("hProjection_%f", gRandom->Rndm()));
  hProjection->Reset();
  
  TF1* fitLandau = new TF1("landauFunc","landau",20.,3000.);
  TH1D *hD;
  for(Int_t iBin=1;iBin<=hist->GetXaxis()->GetNbins();iBin++) {
    if(gROOT->FindObject("projection"))
      delete gROOT->FindObject("projection");
    hD = (TH1D*)hist->ProjectionY("projection",iBin,iBin);
    //hD->Rebin(4);
    if(hD->Integral()>10) {
      fitLandau->SetParameter(1, hD->GetBinCenter(hD->GetMaximumBin()));
      fitLandau->SetParLimits(1, 0.2*hD->GetBinCenter(hD->GetMaximumBin()), 3.0*hD->GetBinCenter(hD->GetMaximumBin()));
      fitLandau->SetParameter(0, 1000.);
      fitLandau->SetParLimits(0, 1., 10000000.);
      fitLandau->SetParameter(2, 0.5*hD->GetBinCenter(hD->GetMaximumBin()));
      fitLandau->SetParLimits(2, 0.01*hD->GetBinCenter(hD->GetMaximumBin()), 1.0*hD->GetRMS());
      hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
      hD->Fit(fitLandau, "Q0", "", hD->GetXaxis()->GetXmin(), hD->GetXaxis()->GetXmax());
      hProjection->SetBinContent(iBin, fitLandau->GetParameter(1));
      hProjection->SetBinError(iBin, fitLandau->GetParameter(2));
      if(mpvErr) {
	mpvErr->SetBinContent(iBin, fitLandau->GetParameter(1));
	mpvErr->SetBinError(iBin, fitLandau->GetParError(1));
      }
      if(widthErr) {
	widthErr->SetBinContent(iBin, fitLandau->GetParameter(2));
	widthErr->SetBinError(iBin, fitLandau->GetParError(2));
      }
      if(chi2) {
	chi2->SetBinContent(iBin, (fitLandau->GetNDF()>0 ? fitLandau->GetChisquare()/Double_t(fitLandau->GetNDF()) : 0.0));
      }
    }
    else{
      hProjection->SetBinContent(iBin, 0);
      hProjection->SetBinError(iBin, 0);
    }
  }
  return hProjection;
}

//____________________________________________________________________
TH2F* AliTRDcheckESD::Proj3D(TH3* hist, TH2* accMap, Int_t zbinLow, Int_t zbinHigh, Float_t &entries) {
  //
  //  Project a 3D histogram to a 2D histogram in the Z axis interval [zbinLow,zbinHigh] 
  //  Return the 2D histogram and also the number of entries into this projection (entries)

  Int_t nBinsX = hist->GetXaxis()->GetNbins();   // X and Y axis bins are assumed to be all equal
  Float_t minX = hist->GetXaxis()->GetXmin();
  Float_t maxX = hist->GetXaxis()->GetXmax();
  Int_t nBinsY = hist->GetYaxis()->GetNbins();
  Float_t minY = hist->GetYaxis()->GetXmin();
  Float_t maxY = hist->GetYaxis()->GetXmax();
  Int_t nBinsZ = hist->GetZaxis()->GetNbins();  // Z axis bins (pt) might have different widths

  TH2F* projHisto = (TH2F*)gROOT->FindObject("projHisto");
  if(projHisto) 
    projHisto->Reset();
  else
    projHisto = new TH2F("projHisto", "projection", nBinsX, minX, maxX, nBinsY, minY, maxY);

  for(Int_t iZ=1; iZ<=nBinsZ; iZ++) {
    if(iZ<zbinLow) continue;
    if(iZ>zbinHigh) continue;
    for(Int_t iX=1; iX<=nBinsX; iX++) {
      for(Int_t iY=1; iY<=nBinsY; iY++) {
        if(accMap) {
          if(accMap->GetBinContent(iX,iY)>0.1)
            projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
        }
        else    // no acc. cut 
          projHisto->SetBinContent(iX, iY, projHisto->GetBinContent(iX, iY)+hist->GetBinContent(iX,iY,iZ));
        // count only the entries which are inside the acceptance map
        if(accMap) {
          if(accMap->GetBinContent(iX,iY)>0.1)
            entries+=hist->GetBinContent(iX,iY,iZ);
        }
        else    // no acc. cut
          entries+=hist->GetBinContent(iX,iY,iZ);
      }
    }
  }
  return projHisto;
}

//____________________________________________________________________
void AliTRDcheckESD::CheckActiveSM(TH1D* phiProj, Bool_t activeSM[18]) {
  //
  // Check the active super-modules
  //
  Double_t entries[18] = {0.0};
  Double_t smPhiLimits[19];
  for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
  for(Int_t phiBin=1; phiBin<=phiProj->GetXaxis()->GetNbins(); ++phiBin) {
    Double_t phi = phiProj->GetBinCenter(phiBin);
    Int_t sm = -1;
    for(Int_t ism=0; ism<18; ++ism) 
      if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1]) sm = ism;
    if(sm==-1) continue;
    entries[sm] += phiProj->GetBinContent(phiBin);
  }
  Double_t avEntries = Double_t(phiProj->Integral())/18.0;
  for(Int_t ism=0; ism<18; ++ism) 
    if(entries[ism]>0.5*avEntries) activeSM[ism] = kTRUE;
}


//__________________________________________________________________________________________________
TH1F* AliTRDcheckESD::EfficiencyFromPhiPt(AliCFContainer* cf, Int_t minNtrkl, Int_t maxNtrkl, 
					  Int_t stepNom, Int_t stepDenom, Int_t var) {
  //
  // Use the CF container to extract the efficiency vs pt (other variables beside pt also posible)
  //
  Int_t varTrackPhi = cf->GetVar(fgkVarNames[kTrackPhiTRD]);
  Int_t otherVar = cf->GetVar(fgkVarNames[var]);  
  Int_t trdStepNumber = cf->GetStep(fgkStepNames[kTRD]);
  Int_t tpcStepNumber = cf->GetStep(fgkStepNames[kTPCreference]);
    
  TH1D* phiProj = (TH1D*)cf->Project(trdStepNumber, varTrackPhi);
  Bool_t activeSM[18] = {kFALSE};
  CheckActiveSM(phiProj, activeSM); delete phiProj;
  Double_t smPhiLimits[19];
  for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
  
  TH2D* hNomPhiVar=0x0;
  TH2D* hDenomPhiVar=0x0;
  
  if((stepNom!=tpcStepNumber) &&
     (minNtrkl>-1 && minNtrkl<7 && maxNtrkl>-1 && maxNtrkl<7)) {
    cf->SetRangeUser(cf->GetVar(fgkVarNames[kTrackTrdTracklets]), Double_t(minNtrkl), Double_t(maxNtrkl));
    hNomPhiVar = (TH2D*)cf->Project(stepNom, otherVar, varTrackPhi);
    cf->SetRangeUser(cf->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0,6.0);
  }
  else
    hNomPhiVar = (TH2D*)cf->Project(stepNom, otherVar, varTrackPhi);
  if((stepDenom!=tpcStepNumber) &&
     (minNtrkl>-1 && minNtrkl<7 && maxNtrkl>-1 && maxNtrkl<7)) {
    cf->SetRangeUser(cf->GetVar(fgkVarNames[kTrackTrdTracklets]), Double_t(minNtrkl), Double_t(maxNtrkl));
    hDenomPhiVar = (TH2D*)cf->Project(stepDenom, otherVar, varTrackPhi);
    cf->SetRangeUser(cf->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0,6.0);
  } 
  else
    hDenomPhiVar = (TH2D*)cf->Project(stepDenom, otherVar, varTrackPhi);
    
  TH1F* hEff = new TH1F(Form("hEff%s_%d_%d_%f", fgkVarNames[var], stepNom, stepDenom, gRandom->Rndm()), "", 
			hNomPhiVar->GetXaxis()->GetNbins(), hNomPhiVar->GetXaxis()->GetXbins()->GetArray());
  for(Int_t ib=1;ib<=hNomPhiVar->GetXaxis()->GetNbins();++ib)
    hEff->GetXaxis()->SetBinLabel(ib, hNomPhiVar->GetXaxis()->GetBinLabel(ib));
  
  for(Int_t ivar=1; ivar<=hEff->GetXaxis()->GetNbins(); ++ivar) {
    Double_t nom = 0.0; Double_t denom = 0.0;
    Double_t eff = 0.0; Double_t err = 0.0;
    for(Int_t iphi=1; iphi<=hNomPhiVar->GetYaxis()->GetNbins(); ++iphi) {
      Double_t phi = hNomPhiVar->GetYaxis()->GetBinCenter(iphi);
      Bool_t isActive = kFALSE;
      for(Int_t ism=0; ism<18; ++ism) 
        if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) 
	  isActive = kTRUE;
      if(!isActive) continue;
      nom += hNomPhiVar->GetBinContent(ivar, iphi);
      denom += hDenomPhiVar->GetBinContent(ivar, iphi);
    }
    eff = (denom>0.001 ? nom/denom : 0.0);
    err = (denom>0.001 && (denom-nom)>0.001 && nom>0.001 ? (TMath::Sqrt(nom*(denom-nom)/denom/denom/denom)) : 0.0);
    hEff->SetBinContent(ivar, eff);
    hEff->SetBinError(ivar, err);
  }   // end loop over pt bins
  delete hNomPhiVar; delete hDenomPhiVar;
  return hEff;
}


//____________________________________________________________________
TH1F* AliTRDcheckESD::EfficiencyTRD(TH3* tpc3D, TH3* trd3D, Bool_t useAcceptance) {
  //
  // Calculate the TRD-TPC matching efficiency as function of pt
  //
  
  if(!tpc3D || !trd3D) return NULL;
  Int_t nBinsZ = trd3D->GetZaxis()->GetNbins();
  // project everything on the eta-phi map to obtain an acceptance map
  Float_t nada = 0.;
  TH2F *trdAcc = (useAcceptance ? (TH2F*)Proj3D(trd3D, 0x0, 1, nBinsZ, nada)->Clone(Form("trdAcc%f", gRandom->Rndm())) : 0x0);
  TH1D *phiProj = (trdAcc ? trdAcc->ProjectionY(Form("phiProj%f", gRandom->Rndm())) : 0x0);
  
  // prepare the acceptance map
  Bool_t activeSM[18] = {kFALSE};
  Double_t smPhiLimits[19];
  for(Int_t ism=0; ism<=18; ++ism) smPhiLimits[ism] = -TMath::Pi() + (2.0*TMath::Pi()/18.0)*ism;
  if(phiProj) {
    CheckActiveSM(phiProj, activeSM);   // get the active SMs
    trdAcc->Reset();
    // Put 1 entry in every bin which belongs to an active SM
    for(Int_t iY=1; iY<=trdAcc->GetYaxis()->GetNbins(); ++iY) {
      Double_t phi = trdAcc->GetYaxis()->GetBinCenter(iY);
      Bool_t isActive = kFALSE;
      for(Int_t ism=0; ism<18; ++ism) {
        if(phi>=smPhiLimits[ism] && phi<smPhiLimits[ism+1] && activeSM[ism]) {
	  isActive = kTRUE;
        }
      }
      if(!isActive) continue;
      for(Int_t iX=1; iX<=trdAcc->GetXaxis()->GetNbins(); ++iX) 
        if(trdAcc->GetXaxis()->GetBinCenter(iX)>=-0.85 && trdAcc->GetXaxis()->GetBinCenter(iX)<=0.85) trdAcc->SetBinContent(iX, iY, 1.0);
    }  // end for over Y(phi) bins
  }  // end if phiProj
    
  // get the bin limits from the Z axis of 3D histos
  Float_t *ptBinLimits = new Float_t[nBinsZ+1];
  for(Int_t i=1; i<=nBinsZ; i++) {
    ptBinLimits[i-1] = trd3D->GetZaxis()->GetBinLowEdge(i);
  }
  ptBinLimits[nBinsZ] = trd3D->GetZaxis()->GetBinUpEdge(nBinsZ);
  
  TH1F *efficiency = new TH1F(Form("eff%d", Int_t(1000000.0*gRandom->Rndm())), "TRD-TPC matching efficiency", nBinsZ, ptBinLimits);
  
  // loop over Z bins
  Bool_t effGood = kFALSE;
  for(Int_t i=1; i<=nBinsZ; i++) {
    Float_t tpcEntries = 0.0; Float_t trdEntries = 0.0;
    Proj3D(tpc3D, trdAcc, i, i, tpcEntries);
    Proj3D(trd3D, trdAcc, i, i, trdEntries);
    Float_t ratio = 0;
    if(tpcEntries>0) ratio = trdEntries/tpcEntries;
    Float_t error = 0;
    if(tpcEntries>0 && trdEntries>0 && (tpcEntries-trdEntries)>=0.0) 
      error = TMath::Sqrt(trdEntries*(tpcEntries-trdEntries)/tpcEntries/tpcEntries/tpcEntries);
    if(ratio>0.001) {
      efficiency->SetBinContent(i,ratio);
      efficiency->SetBinError(i,error);
      effGood = kTRUE;
    }
  }     // end loop over Z bins
  if(!effGood) return 0x0;
  
  return efficiency;
}


//__________________________________________________________________________________________________
void AliTRDcheckESD::PlotCentSummaryFromCF(Double_t* /*trendValues*/, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
  //
  // Make the centrality summary figure from the CF container 
  // 
  if(!fHistos) return;
  AliCFContainer* matchPt=(AliCFContainer*)fHistos->FindObject("MatchingPt");
  if(!matchPt) return;
  AliCFContainer* centCF=(AliCFContainer*)fHistos->FindObject("CentralityCF");
  if(!centCF) return;
  AliCFContainer* clustersCF=(AliCFContainer*)fHistos->FindObject("ClustersCF");
  if(!clustersCF) return;
  
  TLatex* lat=new TLatex();
  lat->SetTextSize(0.06);
  lat->SetTextColor(2);

  gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001); gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
  gPad->Divide(3,3,0.,0.);
  TList* l=gPad->GetListOfPrimitives();
  TVirtualPad* pad=0x0;
  
  if(gROOT->FindObject("rangeEffPt")) delete gROOT->FindObject("rangeEffPt");
  TH2F* rangeEffPt=new TH2F("rangeEffPt", "",10,0.,10.,10,0.,1.3);
  rangeEffPt->SetStats(kFALSE);
  SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
  
  Int_t padsForEffs[5] = {0,3,6,1,4};
  for(Int_t iCent=1; iCent<6; ++iCent) {
    pad = ((TVirtualPad*)l->At(padsForEffs[iCent-1])); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02); pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
    pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
    rangeEffPt->Draw();
    TLine line;
    line.SetLineStyle(2);
    line.SetLineWidth(2);
    line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
    line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
    
    matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
       
    matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);  
    TH1F* hEffPosAll = EfficiencyFromPhiPt(matchPt,  0,  6, 1, 0);
    TH1F* hEffPosTrk4 = EfficiencyFromPhiPt(matchPt, 4,  4, 1, 0);  
    TH1F* hEffPosTrk5 = EfficiencyFromPhiPt(matchPt, 5,  5, 1, 0);
    TH1F* hEffPosTrk6 = EfficiencyFromPhiPt(matchPt, 6,  6, 1, 0);
     
    matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);  
    TH1F* hEffNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);  
    TH1F* hEffNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);  
    TH1F* hEffNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);  
    TH1F* hEffNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
    matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0, 6.0);  
    matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0);  
    
    SetStyle(hEffPosAll,  1, kRed, 1, 24, kRed, 1);
    SetStyle(hEffPosTrk4, 1, kRed, 1, 25, kRed, 1);
    SetStyle(hEffPosTrk5, 1, kRed, 1, 26, kRed, 1);
    SetStyle(hEffPosTrk6, 1, kRed, 1, 27, kRed, 1);
    SetStyle(hEffNegAll,  1, kBlue, 1, 24, kBlue, 1);
    SetStyle(hEffNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
    SetStyle(hEffNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
    SetStyle(hEffNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
    hEffPosAll->Draw("same");
    hEffNegAll->Draw("same");
    hEffPosTrk4->Draw("same");
    hEffNegTrk4->Draw("same");
    hEffPosTrk5->Draw("same");
    hEffNegTrk5->Draw("same");
    hEffPosTrk6->Draw("same");
    hEffNegTrk6->Draw("same");    
        
    TLegend* leg=new TLegend(0.18, 0.7, 0.77, 0.89);
    if(iCent==1) {
      leg->SetFillColor(0);
      leg->SetNColumns(2);
      leg->SetMargin(0.1);
      leg->SetBorderSize(0);
      leg->AddEntry(hEffPosAll,  "pos. (#geq 1 tracklet)", "p");
      leg->AddEntry(hEffNegAll,  "neg. (#geq 1 tracklet)", "p");
      leg->AddEntry(hEffPosTrk4, "pos. (4 tracklets)", "p");
      leg->AddEntry(hEffNegTrk4, "neg. (4 tracklets)", "p");
      leg->AddEntry(hEffPosTrk5, "pos. (5 tracklets)", "p");
      leg->AddEntry(hEffNegTrk5, "neg. (5 tracklets)", "p");
      leg->AddEntry(hEffPosTrk6, "pos. (6 tracklets)", "p");     
      leg->AddEntry(hEffNegTrk6, "neg. (6 tracklets)", "p");
      leg->Draw();
    }
    lat->DrawLatex(0.2, 1.32, Form("%.0f < SPD tracklets < %.0f", matchPt->GetAxis(matchPt->GetVar(fgkVarNames[kEventMult]),0)->GetBinLowEdge(iCent), matchPt->GetAxis(matchPt->GetVar(fgkVarNames[kEventMult]),0)->GetBinUpEdge(iCent)));
  }   // end for loop over multiplicity classes
  
  // Reset the modified user ranges of the CF container
  matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kEventMult]), 0., 3500.);
     
  // Cluster distributions in all multiplicity classes
  pad = ((TVirtualPad*)l->At(2)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
  pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  if(gROOT->FindObject("rangeNcls")) delete gROOT->FindObject("rangeNcls");
  TH2F* rangeNcls = new TH2F("rangeNcls", "", 10, 0.0, 199.9, 10, 0.0, 1.199);
  SetStyle(rangeNcls->GetXaxis(), "# TRD clusters", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeNcls->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
  rangeNcls->SetStats(kFALSE);
  rangeNcls->Draw();
    
  TH1D* hNcls[6]={0x0};
  TLegend* legCls=new TLegend(0.7, 0.75, 0.97, 0.97);
  legCls->SetBorderSize(0);
  legCls->SetFillColor(0);
  legCls->SetMargin(0.15);
  
  for(Int_t iCent=0; iCent<6; ++iCent) {
    if(iCent>0)
      clustersCF->SetRangeUser(clustersCF->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
    hNcls[iCent] = (TH1D*)clustersCF->Project(0, clustersCF->GetVar(fgkVarNames[kTrackTrdClusters]));
    if(!hNcls[iCent]) continue;
    
    hNcls[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
    Double_t maximum = hNcls[iCent]->GetMaximum();
    if(maximum>1.0)
      hNcls[iCent]->Scale(1.0/maximum);
    hNcls[iCent]->SetStats(kFALSE);
    hNcls[iCent]->SetTitle("");
    hNcls[iCent]->SetLineWidth(2);
    
    if(hNcls[iCent]->Integral()>0.01) {
      hNcls[iCent]->Draw("same");
      legCls->AddEntry(hNcls[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", clustersCF->GetAxis(clustersCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinLowEdge(iCent), 
									   clustersCF->GetAxis(clustersCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinUpEdge(iCent))), "l");
    }
  }
  legCls->Draw();
  clustersCF->SetRangeUser(clustersCF->GetVar(fgkVarNames[kEventMult]), 0.0, 6.0, kTRUE);
  
  // Qtot distributions
  pad = ((TVirtualPad*)l->At(5)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
  pad->SetTopMargin(0.02); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  if(gROOT->FindObject("rangeQtot")) delete gROOT->FindObject("rangeQtot");
  TH2F* rangeQtot = new TH2F("rangeQtot", "", 10, 0.0, 9.999, 10, 0.0, 1.199);
  SetStyle(rangeQtot->GetXaxis(), "Q_{tot} (a.u.)", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeQtot->GetYaxis(), "entries (a.u.)", 0.07, 0.8, kTRUE, 0.05);
  rangeQtot->SetStats(kFALSE);
  rangeQtot->Draw();
  
  TH1D* hQtot[6+1]={0x0};
  TLegend* leg2=new TLegend(0.6, 0.7, 0.9, 0.97);
  leg2->SetFillColor(0);
  leg2->SetBorderSize(0);
  
  for(Int_t iCent=0; iCent<6; ++iCent) {
    if(iCent>0)
      centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), Double_t(iCent), Double_t(iCent), kTRUE);
    
    hQtot[iCent] = (TH1D*)centCF->Project(0, centCF->GetVar(fgkVarNames[kTrackletQtot]));
    if(!hQtot[iCent]) continue;
    hQtot[iCent]->SetBinContent(1, 0);
    
    Double_t maximum = hQtot[iCent]->GetMaximum();
    if(maximum>1.0)
      hQtot[iCent]->Scale(1.0/maximum);
    hQtot[iCent]->SetLineColor(iCent<4 ? iCent+1 : iCent+2);
    hQtot[iCent]->SetStats(kFALSE);
    hQtot[iCent]->SetTitle("");
    hQtot[iCent]->SetLineWidth(2);
    if(hQtot[iCent]->Integral()>0.01) {
      hQtot[iCent]->Draw(iCent==0 ? "" : "same");
      leg2->AddEntry(hQtot[iCent], (iCent==0 ? "all centralities" : Form("%.0f < SPD tracklets < %.0f", centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinLowEdge(iCent), 
									   centCF->GetAxis(centCF->GetVar(fgkVarNames[kEventMult]),0)->GetBinUpEdge(iCent))), "l");
    }
  }
  leg2->Draw();
  centCF->SetRangeUser(centCF->GetVar(fgkVarNames[kEventMult]), 0.0, 5.0, kTRUE);
}



//_________________________________________________________________
void AliTRDcheckESD::PlotTrackingSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
  //
  //  Plot tracking summary
  //
  //  trendValues will be filled with trending variables
  //  trendValues[0] : TPC-TRD matching efficiency for positive tracks in the range 1.0<pt<3.0 GeV/c
  //  trendValues[1] : statistical error of trendValues[0]
  //  trendValues[2] : TPC-TRD matching efficiency for negative tracks in the range 1.0<pt<3.0 GeV/c
  //  trendValues[3] : statistical error of trendValues[2]
  //  trendValues[4] : TRD-TOF matching efficiency for positive tracks in the range 1.0<pt<3.0 GeV/c
  //  trendValues[5] : statistical error of trendValues[4]
  //  trendValues[6] : TRD-TOF matching efficiency for negative tracks in the range 1.0<pt<3.0 GeV/c
  //  trendValues[7] : statistical error of trendValues[6]
  //  trendValues[8] : Average number of TRD tracklets per track in the range 1.0<pt<3.0 GeV/c
  //  trendValues[9] : statistical error of trendValues[8]
  //  trendValues[10]: Average number of TRD clusters per track in the range 1.0<p<3.0 GeV/c
  //  trendValues[11]: statistical error of trendValues[10]
  // 
  if(!fHistos) return;
  AliCFContainer* matchPhiEta=(AliCFContainer*)fHistos->FindObject("MatchingPhiEta");
  if(!matchPhiEta) return;
  AliCFContainer* matchPt=(AliCFContainer*)fHistos->FindObject("MatchingPt");
  if(!matchPt) return;
  AliCFContainer* clustersCF=(AliCFContainer*)fHistos->FindObject("ClustersCF");
  if(!clustersCF) return;
  AliCFContainer* bcCF=(AliCFContainer*)fHistos->FindObject("BunchCrossingsCF");
  if(!bcCF) return;
  
  TLatex *lat=new TLatex();
  lat->SetTextSize(0.06);
  lat->SetTextColor(2);
  lat->SetTextFont(42);
  
  gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
  gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
  gPad->Divide(3,3,0.,0.);
  TList* l=gPad->GetListOfPrimitives();
  
  // eta-phi distr. for positive TPC tracks
  TVirtualPad* pad = ((TVirtualPad*)l->At(0)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  
  TH2D* hTPCrefPos = 0x0; TH2D* hTRDrefPos = 0x0; TH2D* hTOFrefPos = 0x0;
  TH2D* hTPCrefNeg = 0x0; TH2D* hTRDrefNeg = 0x0; TH2D* hTOFrefNeg = 0x0;
  matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackTrdTracklets]), 0.0, 6.0);
  matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);      // positive charges
  hTPCrefPos = (TH2D*)matchPhiEta->Project(0, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
  hTRDrefPos = (TH2D*)matchPhiEta->Project(1, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
  hTOFrefPos = (TH2D*)matchPhiEta->Project(2, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
  matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);      // negative charges
  hTPCrefNeg = (TH2D*)matchPhiEta->Project(0, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
  hTRDrefNeg = (TH2D*)matchPhiEta->Project(1, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
  hTOFrefNeg = (TH2D*)matchPhiEta->Project(2, matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]));
  matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0);      // reset charge cut
    
  if(gROOT->FindObject("rangeEtaPhi")) delete gROOT->FindObject("rangeEtaPhi");
  TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi", "", 10, -0.99, +0.99, 10, -3.15, 3.15);
  SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
  rangeEtaPhi->SetStats(kFALSE);  
  
  //----------------------------------------------
  // eta-phi efficiency for positive TRD tracks
  pad = ((TVirtualPad*)l->At(0)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  rangeEtaPhi->Draw();
  
  TH2D* hTRDeffPos = (hTRDrefPos ? (TH2D*)hTRDrefPos->Clone("hTRDeffPos") : 0x0);
  if(hTRDeffPos) {
    hTRDeffPos->Reset();
    hTRDeffPos->SetStats(kFALSE);
    hTRDeffPos->Divide(hTRDrefPos, hTPCrefPos);
    hTRDeffPos->SetMaximum(1.0);
    hTRDeffPos->Draw("samecolz");
    lat->DrawLatex(-0.9, 3.3, "TPC-TRD matching for positive tracks");
    DrawTRDGrid();
  }
  
  //----------------------------------------------
  // eta-phi efficiency for negative TRD tracks
  pad = ((TVirtualPad*)l->At(3)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  rangeEtaPhi->Draw();
  
  TH2D* hTRDeffNeg = (hTRDrefNeg ? (TH2D*)hTRDrefNeg->Clone("hTRDeffNeg") : 0x0);
  if(hTRDeffNeg) {
    hTRDeffNeg->Reset();
    hTRDeffNeg->SetStats(kFALSE);
    hTRDeffNeg->Divide(hTRDrefNeg, hTPCrefNeg);
    hTRDeffNeg->SetMaximum(1.0);
    hTRDeffNeg->Draw("samecolz");
    lat->DrawLatex(-0.9, 3.3, "TPC-TRD matching for negative tracks");
    DrawTRDGrid();  
  }
  
  //----------------------------------------------
  // eta-phi TRD-TOF matching efficiency for positive tracks
  pad = ((TVirtualPad*)l->At(1)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  rangeEtaPhi->Draw();
  
  TH2D* hTOFeffPos = (hTOFrefPos ? (TH2D*)hTOFrefPos->Clone("hTOFeffPos") : 0x0);
  if(hTOFeffPos) {
    hTOFeffPos->Reset();
    hTOFeffPos->SetStats(kFALSE);
    hTOFeffPos->Divide(hTOFrefPos, hTRDrefPos);
    hTOFeffPos->SetMaximum(1.0);
    hTOFeffPos->Draw("samecolz");
    lat->DrawLatex(-0.9, 3.3, "TRD-TOF matching for positive tracks");
    DrawTRDGrid();
  }
  
  //----------------------------------------------
  // eta-phi TRD-TOF matching efficiency for negative tracks
  pad = ((TVirtualPad*)l->At(4)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  rangeEtaPhi->Draw();
  
  TH2D* hTOFeffNeg = (hTOFrefNeg ? (TH2D*)hTOFrefNeg->Clone("hTOFeffNeg") : 0x0);
  if(hTOFeffNeg) {
    hTOFeffNeg->Reset();
    hTOFeffNeg->SetStats(kFALSE);
    hTOFeffNeg->Divide(hTOFrefNeg, hTRDrefNeg);
    hTOFeffNeg->SetMaximum(1.0);
    hTOFeffNeg->Draw("samecolz");
    lat->DrawLatex(-0.9, 3.3, "TRD-TOF matching for negative tracks");
    DrawTRDGrid();
  }
  
  if(hTRDrefPos) delete hTRDrefPos; if(hTPCrefPos) delete hTPCrefPos; if(hTOFrefPos) delete hTOFrefPos;
  if(hTRDrefNeg) delete hTRDrefNeg; if(hTPCrefNeg) delete hTPCrefNeg; if(hTOFrefNeg) delete hTOFrefNeg;
  
  // switch to the Pt cf container
  matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);  
  TH1F* hTRDEffPtPosAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
  TH1F* hTOFEffPtPosAll = EfficiencyFromPhiPt(matchPt, 0, 6, 2, 1);
  TH1F* hTRDEffPtPosTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
  TH1F* hTOFEffPtPosTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 2, 1);
  TH1F* hTRDEffPtPosTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
  TH1F* hTOFEffPtPosTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 2, 1);
  TH1F* hTRDEffPtPosTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
  TH1F* hTOFEffPtPosTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 2, 1);
  
  matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);  
  TH1F* hTRDEffPtNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 1, 0);
  TH1F* hTOFEffPtNegAll = EfficiencyFromPhiPt(matchPt, 0, 6, 2, 1);
  TH1F* hTRDEffPtNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 1, 0);
  TH1F* hTOFEffPtNegTrk4 = EfficiencyFromPhiPt(matchPt, 4, 4, 2, 1);
  TH1F* hTRDEffPtNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 1, 0);
  TH1F* hTOFEffPtNegTrk5 = EfficiencyFromPhiPt(matchPt, 5, 5, 2, 1);
  TH1F* hTRDEffPtNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 1, 0);
  TH1F* hTOFEffPtNegTrk6 = EfficiencyFromPhiPt(matchPt, 6, 6, 2, 1);
  matchPt->SetRangeUser(matchPt->GetVar(fgkVarNames[kTrackCharge]), -1.0, +1.0);  
  
  
  TF1* funcConst = new TF1("constFunc", "[0]", 1.0, 3.0);
  if(trendValues) {
    if(hTRDEffPtPosAll && hTRDEffPtPosAll->Integral()>0.1) {
      hTRDEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
      trendValues[0] = funcConst->GetParameter(0);
      trendValues[1] = funcConst->GetParError(0);
    }
  }
  if(trendValues) { 
    if(hTRDEffPtNegAll && hTRDEffPtNegAll->Integral()>0.1) {
      hTRDEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
      trendValues[2] = funcConst->GetParameter(0);
      trendValues[3] = funcConst->GetParError(0);
    }
  }
  if(trendValues) { 
    if(hTOFEffPtPosAll && hTOFEffPtPosAll->Integral()>0.1) {
      hTOFEffPtPosAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
      trendValues[4] = funcConst->GetParameter(0);
      trendValues[5] = funcConst->GetParError(0);
    }
  }
  if(trendValues) { 
    if(hTOFEffPtNegAll && hTOFEffPtNegAll->Integral()>0.1) {
      hTOFEffPtNegAll->Fit(funcConst, "Q0ME", "goff", 1.0, 3.0);
      trendValues[6] = funcConst->GetParameter(0);
      trendValues[7] = funcConst->GetParError(0);
    }
  }
  
  //---------------------------------------------------------
  // TPC-TRD matching efficiency vs pt
  pad = ((TVirtualPad*)l->At(6)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  
  if(gROOT->FindObject("rangeEffPt2")) delete gROOT->FindObject("rangeEffPt2");
  TH2F* rangeEffPt=new TH2F("rangeEffPt2", "",10,0.,10.,10,0.,1.4);
  rangeEffPt->SetStats(kFALSE);
  SetStyle(rangeEffPt->GetXaxis(), "p_{T} [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeEffPt->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
  rangeEffPt->Draw();
  lat->DrawLatex(0.2, 1.44, "TPC-TRD matching efficiency");
  //++++++++++++++++++
  TLine line;
  line.SetLineStyle(2);
  line.SetLineWidth(2);
  line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.7, rangeEffPt->GetXaxis()->GetXmax(), 0.7);
  line.DrawLine(rangeEffPt->GetXaxis()->GetXmin(), 0.9, rangeEffPt->GetXaxis()->GetXmax(), 0.9);
  TLegend* leg=new TLegend(0.2, 0.7, 0.7, 0.89);
  leg->SetNColumns(2);
  leg->SetMargin(0.15);
  leg->SetBorderSize(0);
  leg->SetFillColor(0);

  SetStyle(hTRDEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
  SetStyle(hTRDEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
  SetStyle(hTRDEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
  SetStyle(hTRDEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
  SetStyle(hTRDEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
  SetStyle(hTRDEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
  SetStyle(hTRDEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
  SetStyle(hTRDEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
  if(hTRDEffPtPosAll) {hTRDEffPtPosAll->Draw("same"); leg->AddEntry(hTRDEffPtPosAll, "pos. (#geq 1 tracklet)", "p");}
  if(hTRDEffPtNegAll) {hTRDEffPtNegAll->Draw("same"); leg->AddEntry(hTRDEffPtNegAll, "neg. (#geq 1 tracklet)", "p");}
  hTRDEffPtPosTrk4->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk4, "pos. (4 tracklets)", "p");
  hTRDEffPtNegTrk4->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk4, "neg. (4 tracklets)", "p");
  hTRDEffPtPosTrk5->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk5, "pos. (5 tracklets)", "p");
  hTRDEffPtNegTrk5->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk5, "neg. (5 tracklets)", "p");
  hTRDEffPtPosTrk6->Draw("same"); leg->AddEntry(hTRDEffPtPosTrk6, "pos. (6 tracklets)", "p");
  hTRDEffPtNegTrk6->Draw("same"); leg->AddEntry(hTRDEffPtNegTrk6, "neg. (6 tracklets)", "p");
  leg->Draw();
  
  //---------------------------------------------------------
  // TRD-TOF matching efficiency vs pt
  pad = ((TVirtualPad*)l->At(7)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  
  rangeEffPt->Draw();
  lat->DrawLatex(0.2, 1.44, "TRD-TOF matching efficiency");
  SetStyle(hTOFEffPtPosAll, 1, kRed, 1, 24, kRed, 1);
  SetStyle(hTOFEffPtPosTrk4, 1, kRed, 1, 25, kRed, 1);
  SetStyle(hTOFEffPtPosTrk5, 1, kRed, 1, 26, kRed, 1);
  SetStyle(hTOFEffPtPosTrk6, 1, kRed, 1, 27, kRed, 1);
  SetStyle(hTOFEffPtNegAll, 1, kBlue, 1, 24, kBlue, 1);
  SetStyle(hTOFEffPtNegTrk4, 1, kBlue, 1, 25, kBlue, 1);
  SetStyle(hTOFEffPtNegTrk5, 1, kBlue, 1, 26, kBlue, 1);
  SetStyle(hTOFEffPtNegTrk6, 1, kBlue, 1, 27, kBlue, 1);
  if(hTOFEffPtPosAll) hTOFEffPtPosAll->Draw("same"); 
  hTOFEffPtPosTrk4->Draw("same"); 
  hTOFEffPtPosTrk5->Draw("same"); 
  hTOFEffPtPosTrk6->Draw("same"); 
  if(hTOFEffPtNegAll) hTOFEffPtNegAll->Draw("same"); 
  hTOFEffPtNegTrk4->Draw("same"); 
  hTOFEffPtNegTrk5->Draw("same"); 
  hTOFEffPtNegTrk6->Draw("same");  
    
  //-----------------------------------------------------
  // <ntracklets> vs (phi,eta)
  pad = ((TVirtualPad*)l->At(2)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  
  rangeEtaPhi->Draw();
  lat->DrawLatex(-0.9, 3.3, "TRD <N_{tracklets}>");
  
  TH3D* hNtracklets = (TH3D*)matchPhiEta->Project(kTRD, matchPhiEta->GetVar(fgkVarNames[kTrackPhiTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackEtaTRD]), matchPhiEta->GetVar(fgkVarNames[kTrackTrdTracklets]));
  
  TProfile2D* hNtrackletsProf = hNtracklets->Project3DProfile();
  delete hNtracklets;
  if(hNtrackletsProf) {
    hNtrackletsProf->SetStats(kFALSE);
    hNtrackletsProf->SetMinimum(0.);
    hNtrackletsProf->SetMaximum(6.);
    hNtrackletsProf->Draw("samecolz");
    DrawTRDGrid();
  }
  
  // calculate the trend value for tracklets/track
  TH2D* hNtrackletsVsP = (TH2D*)matchPt->Project(kTRD, matchPt->GetVar(fgkVarNames[kTrackPt]), matchPt->GetVar(fgkVarNames[kTrackTrdTracklets]));
  if(trendValues &&  hNtrackletsVsP && hNtrackletsVsP->GetEntries()>0.1) {
    TProfile* hNtrackletsVsPprof = hNtrackletsVsP->ProfileX("hNtrackletsVsPprof");
    hNtrackletsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
    trendValues[8] = funcConst->GetParameter(0);
    trendValues[9] = funcConst->GetParError(0);
    delete hNtrackletsVsP;
  }
    
  //--------------------------------------------------------------
  // Nclusters per TRD track vs momentum
  pad = ((TVirtualPad*)l->At(5)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.12);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  pad->SetLogz();
  
  if(gROOT->FindObject("rangeNclsP")) delete gROOT->FindObject("rangeNclsP");
  TH2F* rangeNclsP = new TH2F("rangeNclsP", "", 10, 0.0, 11.99, 10, 0.0, 199.0);
  SetStyle(rangeNclsP->GetXaxis(), "p [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeNclsP->GetYaxis(), "#clusters", 0.07, 0.8, kTRUE, 0.05);
  rangeNclsP->SetStats(kFALSE);
  rangeNclsP->Draw();
  lat->DrawLatex(1.0, 205., "TRD Clusters / track");
  
  TH2D* hNclsVsP = (TH2D*)clustersCF->Project(0, clustersCF->GetVar(fgkVarNames[kTrackP]), clustersCF->GetVar(fgkVarNames[kTrackTrdClusters]));
  if(hNclsVsP) {
    hNclsVsP->SetStats(kFALSE);
    hNclsVsP->Draw("samecolz");
  }
    
  if(trendValues && hNclsVsP && hNclsVsP->GetEntries()>10) {
    TProfile* hNclsVsPprof = hNclsVsP->ProfileX("hNclsVsPprof");
    hNclsVsPprof->Fit(funcConst, "QME0", "goff", 1.0, 3.0);
    trendValues[10] = funcConst->GetParameter(0);
    trendValues[11] = funcConst->GetParError(0);
  }
  
  //--------------------------------------------------------------
  // TRD-TPC and TOF-TRD matching efficiency vs bunch crossing
  pad = ((TVirtualPad*)l->At(8)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.02);
  pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);

  TH1F* hTRDEffBC = EfficiencyFromPhiPt(bcCF, -1, -1, 1, 0, kEventBC);
  TH1F* hTOFEffBC = EfficiencyFromPhiPt(bcCF, -1, -1, 2, 1, kEventBC);
   
  if(gROOT->FindObject("rangeBC")) delete gROOT->FindObject("rangeBC");
  TH2F* rangeBC = new TH2F("rangeBC", "", 10, -0.5, 3499.5, 10, 0.0, 1.4);
  rangeBC->SetStats(kFALSE);
  SetStyle(rangeBC->GetXaxis(), "Bunch crossing", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeBC->GetYaxis(), "efficiency", 0.07, 0.8, kTRUE, 0.05);
  rangeBC->Draw();
  
  TLegend* legBC=new TLegend(0.8, 0.7, 0.95, 0.89);
  legBC->SetBorderSize(0);
  legBC->SetMargin(0.15);
  legBC->SetFillColor(0);
  if(hTRDEffBC) {
    hTRDEffBC->SetStats(kFALSE);
    SetStyle(hTRDEffBC, 1, kRed, 2, 24, kRed, 1); legBC->AddEntry(hTRDEffBC, "TPC-TRD", "p");
    SetStyle(hTOFEffBC, 1, kBlue, 2, 24, kBlue, 1); legBC->AddEntry(hTOFEffBC, "TRD-TOF", "p");
    hTRDEffBC->Draw("same");
    hTOFEffBC->Draw("same");
    legBC->Draw();
    lat->DrawLatex(200., 1.44, "Matching efficiency at 1<p_{T}<3 GeV/c");
  }
  
  delete funcConst;
}



//_________________________________________________________________
void AliTRDcheckESD::PlotPidSummaryFromCF(Double_t* trendValues, const Char_t* /*triggerName*/, Bool_t /*useIsolatedBC*/, Bool_t /*cutTOFbc*/) {
  //
  // PID summary
  //
  //  trendValues will be filled with trending variables
  //  trendValues[12] : PH plateau height from slices times 0.002
  //  trendValues[13] : statistical error of trendValues[12]
  //  trendValues[14] : PH slope from slices times 0.002
  //  trendValues[15] : statistical error of trendValues[14]
  //  trendValues[16] : Landau MPV of tracklet Qtot distribution at p=1GeV/c times 0.002
  //  trendValues[17] : Landau width of tracklet Qtot distribution at p=1GeV/c times 0.002
  //  trendValues[18] : PH plateau height from slices
  //  trendValues[19] : statistical error of trendValues[19]
  //  trendValues[20] : PH slope from slices
  //  trendValues[21] : statistical error of trendValues[20]
  //  trendValues[22] : Landau MPV of tracklet Qtot distribution at p=1GeV/c
  //  trendValues[23] : Landau width of tracklet Qtot distribution at p=1GeV/c
  //
  if(!fHistos) return;
  AliCFContainer* qtotCF = (AliCFContainer*)fHistos->FindObject("QtotCF");
  if(!qtotCF) return;
  AliCFContainer* phCF = (AliCFContainer*)fHistos->FindObject("PulseHeightCF");
  if(!phCF) return;
  AliCFContainer* centCF = (AliCFContainer*)fHistos->FindObject("CentralityCF");
  if(!centCF) return;   
  
  TLatex *lat=new TLatex();
  lat->SetTextSize(0.07);
  lat->SetTextColor(2);
  lat->SetTextFont(42);
  gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
  gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
  gPad->Divide(3,3,0.,0.);
  TList* l=gPad->GetListOfPrimitives();
    
  if(gROOT->FindObject("rangeEtaPhi2")) delete gROOT->FindObject("rangeEtaPhi2");
  TH2F* rangeEtaPhi = new TH2F("rangeEtaPhi2", "", 10, -0.99, +0.99, 10, -3.15, 3.15);
  SetStyle(rangeEtaPhi->GetXaxis(), "#eta", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeEtaPhi->GetYaxis(), "detector #varphi", 0.07, 0.8, kTRUE, 0.05);
  rangeEtaPhi->SetStats(kFALSE);  
  
  // eta-phi distr. for <Qtot> in layer 0
  TVirtualPad* pad;
  TProfile2D* hProf2D;
  TH1D* hqtot = (TH1D*)qtotCF->Project(0, qtotCF->GetVar(fgkVarNames[kTrackletQtot]));
  for(Int_t iLayer=0; iLayer<6; ++iLayer) {
    pad = ((TVirtualPad*)l->At((iLayer<3 ? iLayer*3 : (iLayer-3)*3+1))); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
    pad->SetTopMargin(0.1); pad->SetBottomMargin(0.15);
    pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
    rangeEtaPhi->Draw();
    qtotCF->SetRangeUser(qtotCF->GetVar(fgkVarNames[kTrackletLayer]), Double_t(iLayer), Double_t(iLayer));
    TH3D* hQtotEtaPhi = (TH3D*)qtotCF->Project(0, qtotCF->GetVar(fgkVarNames[kTrackPhiTRD]), qtotCF->GetVar(fgkVarNames[kTrackEtaTRD]), qtotCF->GetVar(fgkVarNames[kTrackletQtot]));  
    hProf2D = (hQtotEtaPhi ? hQtotEtaPhi->Project3DProfile() : 0x0);
    if(hQtotEtaPhi) delete hQtotEtaPhi;
    
    if(hProf2D) {
      hProf2D->SetName(Form("Qtot_layer%d",iLayer));
      hProf2D->SetStats(kFALSE);
      hProf2D->SetMinimum(0.);
      hProf2D->SetMaximum((hqtot->GetMean()<10 ? 4.0 : 2000.));
      hProf2D->Draw("samecolz");
    }
    lat->DrawLatex(-0.9, 3.3, Form("TRD <Q_{tot}> Layer %d", iLayer));
    DrawTRDGrid();
  }
  qtotCF->SetRangeUser(qtotCF->GetVar(fgkVarNames[kTrackletLayer]), 0.0, 5.0);
  // PH versus slice number
  pad = ((TVirtualPad*)l->At(2)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  
  if(gROOT->FindObject("rangePHslice")) delete gROOT->FindObject("rangePHslice");
  TH2F* rangePHslice=new TH2F("rangePHslice", "", 8, -0.5, 7.5, 10, 0.0, (hqtot->GetMean()<10.0 ? 6.0 : 3000.));
  rangePHslice->SetStats(kFALSE);
  SetStyle(rangePHslice->GetXaxis(), "slice", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangePHslice->GetYaxis(), "PH", 0.07, 0.8, kTRUE, 0.05);
  rangePHslice->Draw();
  
  TF1* funcPol1 = new TF1("funcPol1", "[0]+[1]*x", 2.9, 6.4);
  
  TH2D* hPH = (TH2D*)phCF->Project(0, phCF->GetVar(fgkVarNames[kTrackletSlice]), phCF->GetVar(fgkVarNames[kTrackletPHslice]));
  TH1D* hSliceErr = new TH1D(Form("hSliceErr%f", gRandom->Rndm()), "", hPH->GetXaxis()->GetNbins(), hPH->GetXaxis()->GetXbins()->GetArray());
  TH1D* hLandauFit = Proj2D(hPH, hSliceErr);
  hPH->SetStats(kFALSE);
  hPH->Draw("samecolz");
  const Double_t kQx = 0.002;
  if(trendValues) {
    hSliceErr->Fit(funcPol1, "QME0", "goff", 2.9, 6.4);
    trendValues[12] = kQx*funcPol1->GetParameter(0);  // PH plateau
    trendValues[13] = kQx*funcPol1->GetParError(0);   // PH plateau
    trendValues[14] = kQx*funcPol1->GetParameter(1);  // PH slope
    trendValues[15] = kQx*funcPol1->GetParError(1);   // PH slope
    trendValues[18] = funcPol1->GetParameter(0);  // PH plateau
    trendValues[19] = funcPol1->GetParError(0);   // PH plateau
    trendValues[20] = funcPol1->GetParameter(1);  // PH slope
    trendValues[21] = funcPol1->GetParError(1);   // PH slope
  }
  hLandauFit->SetLineWidth(2);
  hLandauFit->SetLineStyle(2);
  hLandauFit->Draw("same");
  
  delete funcPol1; delete hSliceErr;
  // Qtot vs P
  pad = ((TVirtualPad*)l->At(5)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  pad->SetLogz();
  
  if(gROOT->FindObject("rangeQtotP")) delete gROOT->FindObject("rangeQtotP");
  TH2F* rangeQtotP = new TH2F("rangeQtotP", "", 10, 0.0, 11.99, 10, 0.0, (hqtot->GetMean()<10.0 ? 11.99 : 5999.));
  SetStyle(rangeQtotP->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeQtotP->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
  rangeQtotP->SetStats(kFALSE);
  rangeQtotP->Draw();
  
  Int_t pVar = centCF->GetVar(fgkVarNames[kTrackP]);
  if(pVar<0) pVar = centCF->GetVar(fgkVarNames[kTrackletP]);
  TH2D* hQtotP = (TH2D*)centCF->Project(0, pVar, centCF->GetVar(fgkVarNames[kTrackletQtot]));
  TH1D* mpvErr=new TH1D("mpvErr", "Landau MPV error vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());  
  TH1D* widthErr=new TH1D("widthErr", "Landau width error vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());
  TH1D* landauChi2=new TH1D("landauChi2", "Landau fit #chi^{2} vs. P", hQtotP->GetXaxis()->GetNbins(), hQtotP->GetXaxis()->GetXbins()->GetArray());  
  if(hQtotP)
    for(Int_t i=1; i<=hQtotP->GetXaxis()->GetNbins(); ++i) 
      hQtotP->SetBinContent(i, 1, 0.0);  
  TH1D* hQtotProj = (hQtotP ? Proj2D(hQtotP, mpvErr, widthErr, landauChi2) : 0x0);
  //landauChi2->Scale(0.001);
  if(hQtotProj) SetStyle(hQtotProj, 2, kBlue, 2, 1, kBlue, 1);
  if(trendValues && hQtotProj && hQtotProj->GetEntries()>2) {
    trendValues[16] = kQx*hQtotProj->GetBinContent(hQtotProj->FindBin(1.0));   // Landau MPV at 1GeV/c
    trendValues[17] = kQx*hQtotProj->GetBinError(hQtotProj->FindBin(1.0));     // Landau width at 1 GeV/c
    trendValues[22] = hQtotProj->GetBinContent(hQtotProj->FindBin(1.0));   // Landau MPV at 1GeV/c
    trendValues[23] = hQtotProj->GetBinError(hQtotProj->FindBin(1.0));     // Landau width at 1 GeV/c
  }
  if(hQtotP) {
    hQtotP->SetStats(kFALSE);
    hQtotP->Draw("samecolz");
    hQtotProj->Draw("same");
  }
  
  // Qtot vs P (fit results)
  pad = ((TVirtualPad*)l->At(8)); pad->cd();
  pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
  pad->SetTopMargin(0.03); pad->SetBottomMargin(0.15);
  pad->SetGridx(kFALSE); pad->SetGridy(kFALSE);
  pad->SetLogz();
  
  if(gROOT->FindObject("rangeQtotPfit")) delete gROOT->FindObject("rangeQtotPfit");
  TH2F* rangeQtotPfit = new TH2F("rangeQtotPfit", "", 100, 0.0, 11.99, 100, 0.0, (hqtot->GetMean()<10.0 ? 6.0 : 3999.));
  SetStyle(rangeQtotPfit->GetXaxis(), "P [GeV/c]", 0.07, 0.8, kTRUE, 0.05);
  SetStyle(rangeQtotPfit->GetYaxis(), "Q_{tot}", 0.07, 0.8, kTRUE, 0.05);
  rangeQtotPfit->SetStats(kFALSE);
  rangeQtotPfit->Draw();
  
  if(mpvErr) SetStyle(mpvErr, 1, kBlue, 2, 1, kBlue, 1);
  if(widthErr) SetStyle(widthErr, 2, kRed, 2, 1, kRed, 1);
  if(mpvErr) {
    mpvErr->SetStats(kFALSE);
    mpvErr->Draw("same");
  }
  if(widthErr) {
    widthErr->SetStats(kFALSE);
    widthErr->Draw("same");
  }
  TLegend* leg=new TLegend(0.2,0.6,0.5,0.9);
  leg->SetFillColor(0);
  leg->SetBorderSize(0);
  leg->AddEntry("mpvErr","Landau MPV","l");
  leg->AddEntry("widthErr","Landau width","l");
  leg->Draw();
}


//__________________________________________________________________________________________________
void AliTRDcheckESD::PlotOtherSummaryFromCF(Double_t* /*trendValues*/) {
  //
  // Plot additional QA 
  //
  if(!fHistos) return;
  AliCFContainer* matchPhiEta = (AliCFContainer*)fHistos->FindObject("MatchingPhiEta");
  AliCFContainer* trdChi2 = (AliCFContainer*)fHistos->FindObject("trdChi2");
  AliCFContainer* trdBudget = (AliCFContainer*)fHistos->FindObject("trdBudget");
  AliCFContainer* ploss = (AliCFContainer*)fHistos->FindObject("Ploss");
  AliCFContainer* clusters = (AliCFContainer*)fHistos->FindObject("clustersPerTracklet");  
  AliCFContainer* clsRows = (AliCFContainer*)fHistos->FindObject("clustersVsRows");
    
  TLatex *lat=new TLatex();
  lat->SetTextSize(0.06);
  lat->SetTextColor(2);
  lat->SetNDC();
  lat->SetTextFont(42);
  TCanvas* c1 = new TCanvas("ESDsummary", "ESD summary 1", 1600, 1200);
  gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
  gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
  gPad->Divide(3,3,0.,0.);
  TList* l=gPad->GetListOfPrimitives();
  TVirtualPad* pad=0x0;
  
  // matching as a function of trigger class
  if(matchPhiEta) {
    matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
    TH1F* hTRDEffTriggerNeg = EfficiencyFromPhiPt(matchPhiEta, -1, -1, 1, 0, kEventTrigger);
    matchPhiEta->SetRangeUser(matchPhiEta->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
    TH1F* hTRDEffTriggerPos = EfficiencyFromPhiPt(matchPhiEta, -1, -1, 1, 0, kEventTrigger);
      
    pad = ((TVirtualPad*)l->At(0)); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
    pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
    hTRDEffTriggerNeg->SetStats(kFALSE);
    SetStyle(hTRDEffTriggerNeg->GetYaxis(), "efficiency", 0.06, 1.0, kTRUE, 0.06);
    hTRDEffTriggerNeg->GetXaxis()->SetRange(1,fNAssignedTriggers);
    hTRDEffTriggerPos->GetXaxis()->SetRange(1,fNAssignedTriggers);
    SetStyle(hTRDEffTriggerNeg, 1, 2, 2, 20, 2, 1);
    SetStyle(hTRDEffTriggerPos, 1, 4, 2, 20, 4, 1);
    hTRDEffTriggerNeg->Draw();
    hTRDEffTriggerPos->Draw("same");
    TLegend* legEff=new TLegend(0.5,0.5,0.7,0.7);
    legEff->SetFillColor(0);
    legEff->SetBorderSize(0);
    legEff->AddEntry(hTRDEffTriggerNeg, "negatives", "l");
    legEff->AddEntry(hTRDEffTriggerPos, "positives", "l");
    legEff->Draw();
    lat->DrawLatex(0.2, 0.95, "TPC-TRD matching efficiency");
  }
  
  if(trdChi2) {
    // Track TRD chi2 vs (eta,phi)
    TH3D* trdChi23D = (TH3D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackEtaTRD]), 
		                               trdChi2->GetVar(fgkVarNames[kTrackPhiTRD]),
				  	       trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
    trdChi23D->SetName("trdChi23D");
    TProfile2D* prof2DChi2 = trdChi23D->Project3DProfile("yx");
    prof2DChi2->SetName("prof2DChi2");
    pad = ((TVirtualPad*)l->At(3)); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
    pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
    prof2DChi2->SetStats(kFALSE);
    prof2DChi2->SetTitle("");
    SetStyle(prof2DChi2->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
    SetStyle(prof2DChi2->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
    prof2DChi2->SetMaximum(2.9);
    prof2DChi2->Draw("colz");
    lat->DrawLatex(0.2, 0.95, "TRD #chi^{2}");
    DrawTRDGrid();
  
    // Track TRD chi2 vs pt and charge
    trdChi2->SetRangeUser(trdChi2->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
    TH2D* trdChi2VsPtNeg = (TH2D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackPt]),
                                                    trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
    trdChi2VsPtNeg->SetName("trdChi2VsPtNeg");
    TProfile* trdChi2VsPtNegProf = trdChi2VsPtNeg->ProfileX();
    trdChi2VsPtNegProf->SetName("trdChi2VsPtNegProf");
    trdChi2->SetRangeUser(trdChi2->GetVar(fgkVarNames[kTrackCharge]), 1.0, 1.0);
    TH2D* trdChi2VsPtPos = (TH2D*)trdChi2->Project(0, trdChi2->GetVar(fgkVarNames[kTrackPt]),
                                                    trdChi2->GetVar(fgkVarNames[kTrackTrdChi2]));
    trdChi2VsPtPos->SetName("trdChi2VsPtPos");
    TProfile* trdChi2VsPtPosProf = trdChi2VsPtPos->ProfileX();
    trdChi2VsPtPosProf->SetName("trdChi2VsPtPosProf");
    pad = ((TVirtualPad*)l->At(6)); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
    pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
    trdChi2VsPtNegProf->SetStats(kFALSE);
    trdChi2VsPtNegProf->SetTitle("");
    SetStyle(trdChi2VsPtNegProf->GetXaxis(), "p_{T} (GeV/c)", 0.06, 1.0, kTRUE, 0.06);
    SetStyle(trdChi2VsPtNegProf->GetYaxis(), "<TRD #chi^{2}>", 0.06, 1.0, kTRUE, 0.06);
    SetStyle(trdChi2VsPtNegProf, 1, 2, 2, 20, 2, 1);
    SetStyle(trdChi2VsPtPosProf, 1, 4, 2, 20, 4, 1);
    trdChi2VsPtNegProf->Draw();
    trdChi2VsPtPosProf->Draw("same");
    lat->DrawLatex(0.2, 0.95, "TRD #chi^{2}");
  }
  
  if(trdBudget) {
    // Track TRD budget vs (eta,phi)
    TH3D* trdBudget3D = (TH3D*)trdBudget->Project(0, trdBudget->GetVar(fgkVarNames[kTrackEtaTRD]), 
		                                   trdBudget->GetVar(fgkVarNames[kTrackPhiTRD]),
						   trdBudget->GetVar(fgkVarNames[kTrackTRDBudget]));
    trdBudget3D->SetName("trdBudget3D");
    TProfile2D* prof2DBudget = trdBudget3D->Project3DProfile("yx");
    prof2DBudget->SetName("prof2DBudget");
    pad = ((TVirtualPad*)l->At(1)); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
    pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
    prof2DBudget->SetStats(kFALSE);
    prof2DBudget->SetTitle("");
    SetStyle(prof2DBudget->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
    SetStyle(prof2DBudget->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
    prof2DBudget->Draw("colz");
    lat->DrawLatex(0.2, 0.95, "TRD budget");
    DrawTRDGrid();
  }
  
  if(ploss) {
    // momentum loss
    ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), -1.0, -1.0);
    TH2D* plossLayerNeg = (TH2D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackletLayer]), 
		                                   ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
    plossLayerNeg->SetName("plossLayerNeg");
    TProfile* plossLayerNegProf = plossLayerNeg->ProfileX();
    plossLayerNegProf->SetName("plossLayerNegProf");
    ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), +1.0, +1.0);
    TH2D* plossLayerPos = (TH2D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackletLayer]), 
		                                   ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
    plossLayerPos->SetName("plossLayerPos");
    TProfile* plossLayerPosProf = plossLayerPos->ProfileX();
    plossLayerPosProf->SetName("plossLayerPosProf");
    ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackCharge]), -1.5, +1.5);
    
    ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackletLayer]), 0.0, 0.0);
    TH3D* ploss3Dl0 = (TH3D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackEtaTRD]), 
		                             ploss->GetVar(fgkVarNames[kTrackPhiTRD]), 
		                             ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
    ploss3Dl0->SetName("ploss3Dl0");
    TProfile2D* plossEtaPhiL0Prof = ploss3Dl0->Project3DProfile("yx");
    plossEtaPhiL0Prof->SetName("plossEtaPhiL0Prof");
    ploss->SetRangeUser(ploss->GetVar(fgkVarNames[kTrackletLayer]), 5.0, 5.0);
    TH3D* ploss3Dl5 = (TH3D*)ploss->Project(0, ploss->GetVar(fgkVarNames[kTrackEtaTRD]), 
		                             ploss->GetVar(fgkVarNames[kTrackPhiTRD]), 
		                             ploss->GetVar(fgkVarNames[kTrackPlossTRDlayer]));
    ploss3Dl5->SetName("ploss3Dl5");
    TProfile2D* plossEtaPhiL5Prof = ploss3Dl5->Project3DProfile("yx");
    plossEtaPhiL5Prof->SetName("plossEtaPhiL5Prof");
    pad = ((TVirtualPad*)l->At(4)); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
    pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
    plossEtaPhiL0Prof->SetStats(kFALSE);
    plossEtaPhiL0Prof->SetTitle("");
    SetStyle(plossEtaPhiL0Prof->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
    SetStyle(plossEtaPhiL0Prof->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
    plossEtaPhiL0Prof->SetMaximum(80.0);
    plossEtaPhiL0Prof->SetMinimum(-20.0);
    plossEtaPhiL0Prof->Draw("colz");
    lat->DrawLatex(0.2, 0.95, "P_{loss} at layer 0");
    DrawTRDGrid();
    pad = ((TVirtualPad*)l->At(7)); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
    pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
    plossEtaPhiL5Prof->SetStats(kFALSE);
    plossEtaPhiL5Prof->SetTitle("");
    SetStyle(plossEtaPhiL5Prof->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
    SetStyle(plossEtaPhiL5Prof->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
    plossEtaPhiL5Prof->SetMaximum(80.0);
    plossEtaPhiL5Prof->SetMinimum(-20.0);
    plossEtaPhiL5Prof->Draw("colz");
    lat->DrawLatex(0.2, 0.95, "P_{loss} at layer 5");
    DrawTRDGrid();
    pad = ((TVirtualPad*)l->At(2)); pad->cd();
    pad->SetLeftMargin(0.15); pad->SetRightMargin(0.01);
    pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
    plossLayerNegProf->SetStats(kFALSE);
    plossLayerNegProf->SetTitle("");
    SetStyle(plossLayerNegProf->GetYaxis(), "#Delta P (MeV/c)", 0.06, 1.0, kTRUE, 0.06);
    SetStyle(plossLayerNegProf->GetXaxis(), "TRD layer", 0.06, 1.0, kTRUE, 0.06);
    SetStyle(plossLayerNegProf, 1, 2, 2, 20, 2, 1);
    SetStyle(plossLayerPosProf, 1, 4, 2, 20, 4, 1);
    plossLayerNegProf->GetYaxis()->SetRangeUser(TMath::Min(plossLayerNegProf->GetMinimum(),plossLayerPosProf->GetMinimum()-5.0),
                                                TMath::Max(plossLayerNegProf->GetMaximum(),plossLayerPosProf->GetMaximum())+5.0);
    plossLayerNegProf->Draw();  
    plossLayerPosProf->Draw("same");
    lat->DrawLatex(0.2, 0.95, "P_{loss} vs layer");
  }
  
  // clusters/tracklet and clusters/crossed rows
  TH3D* clustersEtaPhi[6]={0x0};
  TH3D* clsRowsEtaPhi[6]={0x0};
  for(Int_t il=0;il<6;++il) {
    if(clusters) {
      clusters->SetRangeUser(clusters->GetVar(fgkVarNames[kTrackletLayer]), Double_t(il), Double_t(il));
      clustersEtaPhi[il]=(TH3D*)clusters->Project(0, clusters->GetVar(fgkVarNames[kTrackEtaTRD]),
                                                   clusters->GetVar(fgkVarNames[kTrackPhiTRD]),
                                                   clusters->GetVar(fgkVarNames[kTrackletClusters]));
      clustersEtaPhi[il]->SetName(Form("clustersEtaPhi%d",il));
    }
    if(clsRows) {
      clsRows->SetRangeUser(clsRows->GetVar(fgkVarNames[kTrackletLayer]), Double_t(il), Double_t(il));
      clsRowsEtaPhi[il]=(TH3D*)clsRows->Project(0, clsRows->GetVar(fgkVarNames[kTrackEtaTRD]),
                                                 clsRows->GetVar(fgkVarNames[kTrackPhiTRD]),
                                                 clsRows->GetVar(fgkVarNames[kTrackletClustersVsRows]));
      clsRowsEtaPhi[il]->SetName(Form("clsRowsEtaPhi%d",il));
    }
  }
    
  lat->SetTextSize(0.05);
  Int_t layerPads[6] = {0, 2, 4, 1, 3, 5};
  
  TCanvas* c2=0x0;
  if(clusters) {
    c2 = new TCanvas("ESDsummary2", "ESD summary 2", 1600, 1200);
    gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
    gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
    gPad->Divide(3,2,0.,0.);
    l=gPad->GetListOfPrimitives();
    for(Int_t il=0;il<6;++il) {
      TProfile2D* clustersEtaPhiProf = clustersEtaPhi[il]->Project3DProfile("yx");
      pad = ((TVirtualPad*)l->At(layerPads[il])); pad->cd();
      pad->SetLeftMargin(0.15); pad->SetRightMargin(0.1);
      pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
      clustersEtaPhiProf->SetStats(kFALSE);
      clustersEtaPhiProf->SetTitle("");
      SetStyle(clustersEtaPhiProf->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
      SetStyle(clustersEtaPhiProf->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
      clustersEtaPhiProf->SetMaximum(30.);
      clustersEtaPhiProf->Draw("colz");
      lat->DrawLatex(0.2, 0.95, Form("Clusters / tracklet, layer %d", il));
      DrawTRDGrid();
    }
  }
  
  TCanvas* c3=0x0;
  if(clsRows) {
    c3 = new TCanvas("ESDsummary3", "ESD summary 3", 1600, 1200);
    gPad->SetTopMargin(0.05); gPad->SetBottomMargin(0.001);
    gPad->SetLeftMargin(0.001); gPad->SetRightMargin(0.001);
    gPad->Divide(3,2,0.,0.);
    l=gPad->GetListOfPrimitives();
    for(Int_t il=0;il<6;++il) {
      TProfile2D* clsRowsEtaPhiProf = clsRowsEtaPhi[il]->Project3DProfile("yx");
      pad = ((TVirtualPad*)l->At(layerPads[il])); pad->cd();
      pad->SetLeftMargin(0.15); pad->SetRightMargin(0.13);
      pad->SetTopMargin(0.06); pad->SetBottomMargin(0.15);
      clsRowsEtaPhiProf->SetStats(kFALSE);
      clsRowsEtaPhiProf->SetTitle("");
      SetStyle(clsRowsEtaPhiProf->GetXaxis(), "#eta", 0.06, 1.0, kTRUE, 0.06);
      SetStyle(clsRowsEtaPhiProf->GetYaxis(), "#varphi (rad.)", 0.06, 1.0, kTRUE, 0.06);
      clsRowsEtaPhiProf->Draw("colz");
      lat->DrawLatex(0.2, 0.95, Form("Clusters / crossed rows, layer %d", il));
      DrawTRDGrid();
    }
  }
  
  if(matchPhiEta || trdChi2 || trdBudget || ploss) c1->SaveAs("esdSummary1.gif");
  if(clusters) c2->SaveAs("esdSummary2.gif");
  if(clsRows) c3->SaveAs("esdSummary3.gif");
}


//__________________________________________________________________________________________________
void AliTRDcheckESD::DrawTRDGrid() {
  //
  //   Draw a grid of lines showing the TRD supermodule and stack structure in (eta,phi) coordinates.
  //   The canvas on which to draw must already exist.
  //
  TLine line;
  line.SetLineColor(2);
  line.SetLineWidth(1);
  line.SetLineStyle(2);
  for(Int_t i=-9; i<=9; ++i) {
    line.DrawLine(-0.92, 2.0*TMath::Pi()/18.0*i, +0.92, 2.0*TMath::Pi()/18.0*i);
  }
  line.DrawLine(-0.85, -3.15, -0.85, 3.15);
  line.DrawLine(-0.54, -3.15, -0.54, 3.15);
  line.DrawLine(-0.16, -3.15, -0.16, 3.15);
  line.DrawLine(+0.16, -3.15, +0.16, 3.15);
  line.DrawLine(+0.54, -3.15, +0.54, 3.15);
  line.DrawLine(+0.85, -3.15, +0.85, 3.15);
}

//_________________________________________________________________
void AliTRDcheckESD::SetStyle(TH1* hist, 
			      Int_t lineStyle, Int_t lineColor, Int_t lineWidth, 
			      Int_t markerStyle, Int_t markerColor, Int_t markerSize) {
  //
  // Set style settings for histograms
  //
  if(!hist) return;
  hist->SetLineStyle(lineStyle);
  hist->SetLineColor(lineColor);
  hist->SetLineWidth(lineWidth);
  hist->SetMarkerStyle(markerStyle);
  hist->SetMarkerColor(markerColor);
  hist->SetMarkerSize(markerSize);
}

//____________________________________________________________________
void AliTRDcheckESD::SetStyle(TAxis* axis, const Char_t* title, Float_t titleSize, Float_t titleOffset, Bool_t centerTitle, 
                              Float_t labelSize) {
  //
  // Set style settings for axes
  //
  if(!axis) return;
  axis->SetTitle(title);
  axis->SetTitleSize(titleSize);
  axis->SetTitleOffset(titleOffset); 
  axis->CenterTitle(centerTitle);
  axis->SetLabelSize(labelSize);
  axis->SetTitleFont(42);
  axis->SetLabelFont(42);
  axis->SetNdivisions(507);
}

//____________________________________________________________________
void AliTRDcheckESD::FindIsolatedBCs(TH1D* bcHist, Bool_t isIsolated[3500]) {
  //
  // Find the isolated bunch crossings
  //
  Int_t isolationSize = 5;      // number of free bunches in both directions
  for(Int_t bcBin=1; bcBin<=bcHist->GetXaxis()->GetNbins(); ++bcBin) {
    Int_t bc = TMath::Nint(bcHist->GetBinCenter(bcBin));
    if(bc<-0.001 || bc>3499.01) {
      isIsolated[bc] = kFALSE;
      continue;
    }
    Double_t entries = bcHist->GetBinContent(bcBin);
    if(entries<0.001) {
      isIsolated[bc] = kFALSE;
      continue;     // no entries
    }
        
    // check isolation
    isIsolated[bc] = kTRUE;
    for(Int_t ibc = TMath::Max(1,bcBin-isolationSize); ibc<=TMath::Min(3499, bcBin+isolationSize); ++ibc) {
      if(ibc==bcBin) continue;
      if(bcHist->GetBinContent(ibc)>0.01) {
        isIsolated[bc] = kFALSE;
        break;
      }
    }
  }   // end loop over BC bins
  
  cout << "Isolated bunches: " << endl;
  for(Int_t ibc=0; ibc<3500; ++ibc) 
    if(isIsolated[ibc]) cout << "BC #" << ibc << endl; 
}


//__________________________________________________________________________________________________
Int_t AliTRDcheckESD::GetTriggerIndex(const Char_t* name, Bool_t createNew/*=kTRUE*/) {
  //
  //  Return the index of trigger "name" in the trigger histogram.
  //  If the index for this trigger does not exist yet, then assign one if createNew is set to TRUE 
  //
  //cout << "GetTriggerIndex for " << name << endl;
  TH1F* triggerHist = (TH1F*)fHistos->FindObject("hTriggerDefs");
  TString nameStr=name;
  for(Int_t i=1; i<=triggerHist->GetXaxis()->GetNbins(); ++i) {
    if(!nameStr.CompareTo(triggerHist->GetXaxis()->GetBinLabel(i))) {
      //cout << "       index found: " << i << endl;
      return i;
    }
  }
  if(createNew) {
    triggerHist->GetXaxis()->SetBinLabel(fNAssignedTriggers+1, name);
    for(Int_t i=1;i<fHistos->GetEntries();++i) {
      TString objType = fHistos->At(i)->IsA()->GetName();
      if(!objType.Contains("AliCFContainer")) continue;
      AliCFContainer* cf=(AliCFContainer*)fHistos->At(i);
      Int_t trigVar = cf->GetVar(fgkVarNames[kEventTrigger]);
      if(trigVar>=0)
	for(Int_t istep=0;istep<cf->GetNStep();++istep) 
	  cf->GetAxis(trigVar, istep)->SetBinLabel(fNAssignedTriggers+1, name);
    }  // end loop over histograms and CFs
        
    ++fNAssignedTriggers;
    return fNAssignedTriggers+1;
  }
  else {
    return -1;
  }
}

//__________________________________________________________________________________________________
void AliTRDcheckESD::PrintTriggers() const {
  //
  //  Print the available triggers for this run
  //
  if(!fHistos) {
    cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
    return;
  }
  TH1F* hTriggers = (TH1F*)fHistos->FindObject("hTriggerDefs");
  cout << "Triggers found in this run" << endl;
  cout << "==========================" << endl;
  cout << "Name   Index   Entries    " << endl;
  for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
    if(hTriggers->GetXaxis()->GetBinLabel(it)[0]!='\0') {
      cout << hTriggers->GetXaxis()->GetBinLabel(it) << "  " << hTriggers->GetXaxis()->GetBinCenter(it) << "  " << hTriggers->GetBinContent(it) << endl;
    }
  }
}


//__________________________________________________________________________________________________
Int_t AliTRDcheckESD::GetTriggerCounter(const Char_t* triggerName) const {
  //
  // Get the number of events for a given trigger name
  //
  if(!fHistos) {
    cout << "Warning in AliTRDcheckESD::PrintTriggers(): No file loaded!" << endl;
    return -1;
  }
  TH1F* hTriggers = (TH1F*)fHistos->FindObject("hTriggerDefs");
  Int_t counter = -1;
  for(Int_t it=1; it<hTriggers->GetXaxis()->GetNbins(); ++it) {
    TString trgString = hTriggers->GetXaxis()->GetBinLabel(it);
    if(!trgString.CompareTo(triggerName)) 
      counter = (Int_t)hTriggers->GetBinContent(it);
  }
  if(counter<0) {cout << "AliTRDcheckESD::GetTriggerCounter()  Trigger not found !!";}
  return counter;
}


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